165282 2016-12-01 15:15:55 -0800 WebAssembly: handle and optimize wasm export => wasm import calls 2017-01-02 17:58:42 -0800 1 1 1 Unclassified WebKit JavaScriptCore WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 165118 161709 162952 166442 166444 166462 166486 166625 166623 1 jfbastien jfbastien commit-queue fpizlo ggaren jfbastien keith_miller mark.lam msaboff saam webkit-bug-importer oldest_to_newest 1255512 0 jfbastien 2016-12-01 15:15:55 -0800 The spec mentions Function Exotic Object. These are the WebAssembly exports: https://github.com/WebAssembly/design/blob/master/JS.md#exported-function-exotic-objects When a WebAssembly function import is a Function Exotic Object then extra checks need to occur for signature match: https://github.com/WebAssembly/design/blob/master/JS.md#webassemblyinstance-constructor This is conveniently the amount of information we need to optimize through wasm ↔ wasm calls. Right now (bug #165118) I'm ignoring the requirement, we should fix it later. One tricky thing will be to make sure that Instance lifetime is kept! Importing an Instance's export means keeping that entire Instance alive, but the importObject would only have given use the Instance's `exports` object so we need to map it back to its parent, and put it in a Vector<WriteBarrier> on the importing Instance. 1261767 1 webkit-bug-importer 2016-12-20 14:29:54 -0800 <rdar://problem/29760322> 1262333 2 297658 jfbastien 2016-12-22 10:52:12 -0800 Created attachment 297658 WP Start this patch. Currently implemented: Changes to the WebAssembly implementation: - Add a new JSType for WebAssemblyFunction, and use it when creating its structure. This will be used to quickly detect from wasm whether the import call is to another wasm module, or whether it's to JS. - Use cell instead of objects to detect wasm->wasm, the previous code was wrong. - Improve diagnostic printout for wasm stubs: print the full signature. - Properly check that wasm -> wasm calls have matching signatures. Add testing for this. - Test some of the wasm -> wasm calls, not working yet, and more tests need to get implemented. Support changes: - Add a Proxy to Builder.js, which intercepts unknown property lookups. This creates way better error messages on typos than 'undefined is not a function', which happens semi-frequently as I typo opcode names (and which one is a typo is hard to find because we chain builders). - Add limited support for var{u}int64 (only the 32-bit values). 1262778 3 297773 jfbastien 2016-12-26 14:20:33 -0800 Created attachment 297773 WIP An update. This is still missing: - The wasm->wasm stub in WasmBinding.cpp, which is why the wasm-to-wasm.js test is currently disabled. - Currently crashing when trying to access memory. I'll debug this next. wasm->wasm Changes to the WebAssembly implementation: - Add a new JSType for WebAssemblyFunction, and use it when creating its structure. This will be used to quickly detect from wasm whether the import call is to another wasm module, or whether it's to JS. - Use cell instead of objects to detect wasm->wasm, the previous code was wrong. - Improve diagnostic printout for wasm stubs: print the full signature. - Properly check that wasm -> wasm calls have matching signatures. Add testing for this. - Test some of the wasm -> wasm calls, not working yet, and more tests need to get implemented. - Generate two stubs from the import stub generator: one for wasm->JS and one for wasm -> wasm. This is done at Module time. Which is called will only be known at Instance time, once we've received the import object. We want to avoid codegen at Instance time, so having both around is great. - Restore the WebAssembly global state (VM top Instance, and pinned registers) after call / call_indirect, and in the JS->wasm entry stub. Support changes: - Add a Proxy to Builder.js, which intercepts unknown property lookups. This creates way better error messages on typos than 'undefined is not a function', which happens semi-frequently as I typo opcode names (and which one is a typo is hard to find because we chain builders). - Add limited support for var{u}int64 (only the 32-bit values). - Get rid of much of the function index space: we already have all of its information elsewhere, and as-is it provides no extra efficiency. - Store Wasm::Memory directly on JSWebAssemblyMemory, instead of through a unique_ptr. This removes an indirection and useless allocation. - Remove VM'a WebAssembly memory / size, and obtain them from Instance instead. This requires an extra indirection, but is cleaner. 1262787 4 297775 jfbastien 2016-12-26 17:54:57 -0800 Created attachment 297775 WIP - Fix B3 codegen of calls when the return type is Void. - Pass in Instance properly when calling from JS. Other fixes still necessary: - Memory seems borked. $r12 is 0 in places it shouldn't I must be restoring the registers wrong. - The element-data.js test also segfaults, probably the same issue. 1262792 5 297777 jfbastien 2016-12-26 19:55:20 -0800 Created attachment 297777 WIP Working on this on and off... I realized what an obvious bug was, fixed it. There are still bugs though. Here are some notes so i know where to start again. The codegen leading up to wasm->js entry looks like: Generated JIT code for Wasm JS entrypoint: Code at [0x2d8702a1a440, 0x2d8702a1a4a0): 0x2d8702a1a440: push %rbp 0x2d8702a1a441: mov %rsp, %rbp 0x2d8702a1a444: add $0xffffffffffffffe0, %rsp 0x2d8702a1a448: mov $0x0, %rax 0x2d8702a1a452: mov %rax, 0x18(%rbp) 0x2d8702a1a456: mov $0x0, 0x10(%rbp) 0x2d8702a1a45e: cmp $0x2, 0x20(%rbp) 0x2d8702a1a462: jb 0x2d8702a1a49e 0x2d8702a1a468: mov $0x1053f5578, %rax # address of vm.topJSWebAssemblyInstance. I've checked that this is correct. 0x2d8702a1a472: mov (%rax), %rax # Load it (it was saved by the C++ stub). 0x2d8702a1a475: mov 0x28(%rax), %rcx # Load WriteBarrier<JSWebAssemblyMemory> m_memory; 0x2d8702a1a479: mov 0x18(%rcx), %rax # From Wasm::Memory load void* m_memory. 0x2d8702a1a47d: mov 0x20(%rcx), %ecx # From Wasm::Memory load uint32_t m_size. 0x2d8702a1a480: mov %rax, %r12 # Move to pinned memory register. 0x2d8702a1a483: mov %rcx, %rbx # Move to pinned size register. 0x2d8702a1a486: mov 0x28(%rbp), %edi 0x2d8702a1a489: mov 0x30(%rbp), %esi 0x2d8702a1a48c: mov $0x2d8702a1a380, %r11 0x2d8702a1a496: call *%r11 0x2d8702a1a499: mov %rbp, %rsp 0x2d8702a1a49c: pop %rbp 0x2d8702a1a49d: ret 0x2d8702a1a49e: int3 Or at least that's my understanding. The following tests fail: Segmentation fault: 11 ../../current-debug/bin/jsc --useWebAssembly=1 -m .//function-tests/i32-load.js Segmentation fault: 11 ../../current-debug/bin/jsc --useWebAssembly=1 -m .//function-tests/i32-load8-s.js Segmentation fault: 11 ../../current-debug/bin/jsc --useWebAssembly=1 -m .//js-api/element-data.js Segmentation fault: 11 ../../current-debug/bin/jsc --useWebAssembly=1 -m .//js-api/test_Data.js Segmentation fault: 11 ../../current-debug/bin/jsc --useWebAssembly=1 -m .//js-api/test_memory.js 1262796 6 297779 jfbastien 2016-12-26 21:57:54 -0800 Created attachment 297779 WIP I found the bug! Everything was good, except I was destroying the memory before using it. Bad idea. All the tests now pass. This patch is now missing: - WasmBinding.cpp:wasmToWasm implementation (this should be pretty straightforward). - Un-comment associated test wasm-to-wasm.js. - ChangeLog. And then we should be good to go! Early reviews welcome. 1262876 7 297779 saam 2016-12-27 15:41:01 -0800 Comment on attachment 297779 WIP View in context: https://bugs.webkit.org/attachment.cgi?id=297779&action=review LGTM, but the some of the important bits aren't done yet, so I'll take a look again when you implement them. > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:747 > + CCallHelpers::Call call = jit.call(); You need to store to the VM::topWasmInstance before this call, right? > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:749 > + bool toJS = false; // Maybe external wasm -> wasm. Style nit: I'm guilty of using a boolean for these things too, but an enum with two values is almost always better than a boolean. > Source/JavaScriptCore/wasm/WasmBinding.cpp:260 > + jit.emitFunctionPrologue(); > + jit.store64(JIT::TrustedImm32(0), JIT::Address(GPRInfo::callFrameRegister, CallFrameSlot::codeBlock * static_cast<int>(sizeof(Register)))); // FIXME Stop using 0 as codeBlocks. https://bugs.webkit.org/show_bug.cgi?id=165321 > + jit.storePtr(JIT::TrustedImmPtr(vm->webAssemblyToJSCallee.get()), JIT::Address(GPRInfo::callFrameRegister, CallFrameSlot::callee * static_cast<int>(sizeof(Register)))); > + > + // FIXME perform a stack check before updating SP. https://bugs.webkit.org/show_bug.cgi?id=165546 > + > + unsigned numberOfParameters = argCount + 1; // There is a "this" argument. > + unsigned numberOfRegsForCall = CallFrame::headerSizeInRegisters + numberOfParameters; > + unsigned numberOfBytesForCall = numberOfRegsForCall * sizeof(Register) - sizeof(CallerFrameAndPC); > + const unsigned stackOffset = WTF::roundUpToMultipleOf(stackAlignmentBytes(), numberOfBytesForCall); > + jit.subPtr(MacroAssembler::TrustedImm32(stackOffset), MacroAssembler::stackPointerRegister); > + JIT::Address calleeFrame = CCallHelpers::Address(MacroAssembler::stackPointerRegister, -static_cast<ptrdiff_t>(sizeof(CallerFrameAndPC))); > + > + // FIXME implement this. > + jit.breakpoint(); Are you going to implement this as a tail call? > Source/JavaScriptCore/wasm/WasmFormat.h:190 > + Vector<SignatureIndex> moduleSignatureIndicesToUniquedSignatureIndices; Nit: This is only used during compilation, so it shouldn't live on ModuleInformation which lives as long as a WebAssembly.Module lives. > Source/JavaScriptCore/wasm/WasmMemory.h:50 > + memset(&other, 0, sizeof(other)); Style: I think it's lest of a footgun to just store to the fields of 'other' to null them out. > Source/JavaScriptCore/wasm/WasmSignature.cpp:55 > +String Signature::toString() const > +{ > + String result(makeString(returnType())); > + result.append(" ("); > + for (SignatureArgCount arg = 0; arg < argumentCount(); ++arg) { > + if (arg) > + result.append(", "); > + result.append(makeString(argument(arg))); > + } > + result.append(')'); > + return result; > +} Since you made this, you should just make ::dump() print the result of this function. > Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.cpp:122 > + return JSValue::encode(throwException(exec, throwScope, createJSWebAssemblyLinkError(exec, vm, ASCIILiteral("imported function's signature mismatches the provided WebAssembly function's signature")))); Nit: "mismatches" => "does not match" or "doesn't match" 1263116 8 297845 jfbastien 2016-12-29 17:43:04 -0800 Created attachment 297845 WIP Rebase, address comments. Still need to do the rest of the patch. > > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:747 > > + CCallHelpers::Call call = jit.call(); > > You need to store to the VM::topWasmInstance before this call, right? I don't think so: every function starts by creating a Value* for its Instance. I expect B3 to delete this materialization if it goes unused, and I expect it to be spilled or kept in callee-saved if it is live across a call (as I'm doing here). The only inefficiency here is in leaf functions (assuming we don't inline current_memory / grow_memory), which we could annotate and save from the useless materialization if needed. The generated code looks like: mov $0x1055f5578, %r14 # &vm.topJSWebAssemblyInstance mov (%r14), %r13 # topJSWebAssemblyInstance mov 0x48(%r13), %rax cmp $0x36, 0x5(%rax) jz 0x32a43381c018 mov $0x0, %r11 # Patched at runtime call *%r11 mov %r13, (%r14) # Restore vm.topJSWebAssemblyInstance after a call mov 0x28(%r13), %rcx mov 0x18(%rcx), %rax # void* m_memory mov 0x20(%rcx), %rcx # uint64_t m_size mov %rax, %r12 # Pinned memory register mov %rcx, %rbx # Pinned size register Do I have this right? > > Source/JavaScriptCore/wasm/WasmBinding.cpp:260 > > + jit.emitFunctionPrologue(); > > + jit.store64(JIT::TrustedImm32(0), JIT::Address(GPRInfo::callFrameRegister, CallFrameSlot::codeBlock * static_cast<int>(sizeof(Register)))); // FIXME Stop using 0 as codeBlocks. https://bugs.webkit.org/show_bug.cgi?id=165321 > > + jit.storePtr(JIT::TrustedImmPtr(vm->webAssemblyToJSCallee.get()), JIT::Address(GPRInfo::callFrameRegister, CallFrameSlot::callee * static_cast<int>(sizeof(Register)))); > > + > > + // FIXME perform a stack check before updating SP. https://bugs.webkit.org/show_bug.cgi?id=165546 > > + > > + unsigned numberOfParameters = argCount + 1; // There is a "this" argument. > > + unsigned numberOfRegsForCall = CallFrame::headerSizeInRegisters + numberOfParameters; > > + unsigned numberOfBytesForCall = numberOfRegsForCall * sizeof(Register) - sizeof(CallerFrameAndPC); > > + const unsigned stackOffset = WTF::roundUpToMultipleOf(stackAlignmentBytes(), numberOfBytesForCall); > > + jit.subPtr(MacroAssembler::TrustedImm32(stackOffset), MacroAssembler::stackPointerRegister); > > + JIT::Address calleeFrame = CCallHelpers::Address(MacroAssembler::stackPointerRegister, -static_cast<ptrdiff_t>(sizeof(CallerFrameAndPC))); > > + > > + // FIXME implement this. > > + jit.breakpoint(); > > Are you going to implement this as a tail call? I think I can since the Instance is saved / restored by the caller. It only needs to: - Adjust vm.topJSWebAssemblyInstance. - Adjust pinned registers. I don't think this function requires any stack space. 1263117 9 saam 2016-12-29 18:44:19 -0800 (In reply to comment #8) > Created attachment 297845 [details] > WIP > > Rebase, address comments. Still need to do the rest of the patch. > > > > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:747 > > > + CCallHelpers::Call call = jit.call(); > > > > You need to store to the VM::topWasmInstance before this call, right? > > I don't think so: every function starts by creating a Value* for its > Instance. I expect B3 to delete this materialization if it goes unused, and > I expect it to be spilled or kept in callee-saved if it is live across a > call (as I'm doing here). You could be calling cross Instance here, right? If so, the cross Instance callee wants the topInstabcePointer to be correct. > > The only inefficiency here is in leaf functions (assuming we don't inline > current_memory / grow_memory), which we could annotate and save from the > useless materialization if needed. > > The generated code looks like: > > mov $0x1055f5578, %r14 # &vm.topJSWebAssemblyInstance > mov (%r14), %r13 # topJSWebAssemblyInstance > mov 0x48(%r13), %rax > cmp $0x36, 0x5(%rax) > jz 0x32a43381c018 > mov $0x0, %r11 # Patched at runtime > call *%r11 > mov %r13, (%r14) # Restore vm.topJSWebAssemblyInstance after a call > mov 0x28(%r13), %rcx > mov 0x18(%rcx), %rax # void* m_memory > mov 0x20(%rcx), %rcx # uint64_t m_size > mov %rax, %r12 # Pinned memory register > mov %rcx, %rbx # Pinned size register > > Do I have this right? > > > > > Source/JavaScriptCore/wasm/WasmBinding.cpp:260 > > > + jit.emitFunctionPrologue(); > > > + jit.store64(JIT::TrustedImm32(0), JIT::Address(GPRInfo::callFrameRegister, CallFrameSlot::codeBlock * static_cast<int>(sizeof(Register)))); // FIXME Stop using 0 as codeBlocks. https://bugs.webkit.org/show_bug.cgi?id=165321 > > > + jit.storePtr(JIT::TrustedImmPtr(vm->webAssemblyToJSCallee.get()), JIT::Address(GPRInfo::callFrameRegister, CallFrameSlot::callee * static_cast<int>(sizeof(Register)))); > > > + > > > + // FIXME perform a stack check before updating SP. https://bugs.webkit.org/show_bug.cgi?id=165546 > > > + > > > + unsigned numberOfParameters = argCount + 1; // There is a "this" argument. > > > + unsigned numberOfRegsForCall = CallFrame::headerSizeInRegisters + numberOfParameters; > > > + unsigned numberOfBytesForCall = numberOfRegsForCall * sizeof(Register) - sizeof(CallerFrameAndPC); > > > + const unsigned stackOffset = WTF::roundUpToMultipleOf(stackAlignmentBytes(), numberOfBytesForCall); > > > + jit.subPtr(MacroAssembler::TrustedImm32(stackOffset), MacroAssembler::stackPointerRegister); > > > + JIT::Address calleeFrame = CCallHelpers::Address(MacroAssembler::stackPointerRegister, -static_cast<ptrdiff_t>(sizeof(CallerFrameAndPC))); > > > + > > > + // FIXME implement this. > > > + jit.breakpoint(); > > > > Are you going to implement this as a tail call? > > I think I can since the Instance is saved / restored by the caller. It only > needs to: > - Adjust vm.topJSWebAssemblyInstance. > - Adjust pinned registers. > I don't think this function requires any stack space. 1263122 10 297848 jfbastien 2016-12-29 23:54:22 -0800 Created attachment 297848 WIP Here's an updated WIP patch with the wasm->wasm thunk implemented. There seems to be an issue, maybe related to what Saam is asking. All wasm function start with the following: m_instanceValue = m_currentBlock->appendNew<MemoryValue>(m_proc, Load, pointerType(), Origin(), m_currentBlock->appendNew<ConstPtrValue>(m_proc, Origin(), &m_vm.topJSWebAssemblyInstance)); I was therefore thinking that this Value* would be available throughout the function: either it's in a callee-saved register, or it's spilled before a call. In the code below it seems to be in $rbx, and the address &vm.topJSWebAssemblyInstance in $r12. Now that's surprising, because those are the pinned registers! It's OK though because these functions don't have a Memory, so B3IrGenerator starts with info.hasMemory() and doesn't pin these. So it's clear that the registers which are usually pinned are getting clobbered, but I'm not sure what the best approach is. A few thoughts: 1) In the wasm -> wasm thunk I don't know whether I'm calling another Module which uses Memory or not, so I have to restore its pinned registers just in case (or generate a bunch more, non-straight-line, code). 2) The thunk really only has one scratch register, and uses the usually-pinned registers because it assumes the caller doesn't care (and sure enough, pinning them unconditionally fixes the issues). 3) Modules which don't have a Memory could mark the usually-pinned registers as clobbered in addCall / addCallIndirect. They would still be free to use, but the caller would have to be careful around calls. Here's generated wasm code, which calls another instance's wasm function, from wasm-to-wasm-js: Generated JIT code for WebAssembly function[0] I32 (I32): Code at [0x4cb604238460, 0x4cb604238500): 0x4cb604238460: push %rbp 0x4cb604238461: mov %rsp, %rbp 0x4cb604238464: add $0xffffffffffffffd0, %rsp 0x4cb604238468: mov %rbx, -0x10(%rbp) 0x4cb60423846c: mov %r12, -0x8(%rbp) 0x4cb604238470: mov $0x0, %rax 0x4cb60423847a: mov %rax, 0x18(%rbp) 0x4cb60423847e: mov $0x0, 0x10(%rbp) 0x4cb604238486: mov $0x104df5578, %r12 # &vm.topJSWebAssemblyInstance 0x4cb604238490: mov (%r12), %rbx # m_instanceValue 0x4cb604238494: mov %edi, %eax 0x4cb604238496: mov $0xc0febeef00000000, %rdi 0x4cb6042384a0: or %rax, %rdi 0x4cb6042384a3: mov 0x48(%rbx), %rax 0x4cb6042384a7: cmp $0x36, 0x5(%rax) +------- 0x4cb6042384ab: jz 0x4cb6042384d8 | 0x4cb6042384b1: mov $0x0, %r11 | 0x4cb6042384bb: call *%r11 | +-> 0x4cb6042384be: mov %rbx, (%r12) # Crash here, because $r12 is now 0 (so is $rbx) | | 0x4cb6042384c2: mov %rax, %rcx | | 0x4cb6042384c5: shr $0x20, %rcx | | 0x4cb6042384c9: xor %ecx, %eax | | 0x4cb6042384cb: mov -0x10(%rbp), %rbx | | 0x4cb6042384cf: mov -0x8(%rbp), %r12 | | 0x4cb6042384d3: mov %rbp, %rsp | | 0x4cb6042384d6: pop %rbp | | 0x4cb6042384d7: ret +----|-> 0x4cb6042384d8: mov $0x0, %r11 | 0x4cb6042384e2: call *%r11 | 0x4cb6042384e5: int3 # My breakpoint, for debugging +-- 0x4cb6042384e6: jmp 0x4cb6042384be Here's the annotated thunk, so that WasmBinding.cpp:wasmToWasm is easier to understand: Generated JIT code for WebAssembly->WebAssembly import[0]: Code at [0x4cb60421bea0, 0x4cb60421bee0): 0x4cb60421bea0: mov $0x104df5578, %r10 # &vm.topJSWebAssemblyInstance 0x4cb60421beaa: mov (%r10), %r10 # Get the caller's Instance 0x4cb60421bead: mov 0x48(%r10), %r10 # Import function 0x4cb60421beb1: mov 0x28(%r10), %r12 # Callee's Instance 0x4cb60421beb5: mov $0x104df5578, %r11 # &vm.topJSWebAssemblyInstance (again) 0x4cb60421bebf: mov %r12, (%r11) # Set the callee's instance 0x4cb60421bec2: mov 0x28(%r12), %r12 # Callee's JSWebAssemblyMemory 0x4cb60421bec7: mov 0x20(%r12), %rbx # Callee's memory size (in its pinned register) 0x4cb60421becc: mov 0x18(%r12), %r12 # Callee's memory address (in its pinned register) 0x4cb60421bed1: mov 0x30(%r10), %r10 # Callee code address 0x4cb60421bed5: jmp *%r10 ---------- Updated change notes: Changes to the WebAssembly implementation: - Add a new JSType for WebAssemblyFunction, and use it when creating its structure. This will be used to quickly detect from wasm whether the import call is to another wasm module, or whether it's to JS. - Use cell instead of objects to detect wasm->wasm, the previous code was wrong. - Improve diagnostic printout for wasm stubs: print the full signature. - Properly check that wasm -> wasm calls have matching signatures. Add testing for this. - Test some of the wasm -> wasm calls, not working yet, and more tests need to get implemented. - Generate two stubs from the import stub generator: one for wasm->JS and one for wasm -> wasm. This is done at Module time. Which is called will only be known at Instance time, once we've received the import object. We want to avoid codegen at Instance time, so having both around is great. - Restore the WebAssembly global state (VM top Instance, and pinned registers) after call / call_indirect, and in the JS->wasm entry stub. - Pinned registers are now a global thing, not per-Memory, because the wasm -> wasm stubs are generated at Module time where we don't really have enough information to do the right thing (doing so would generate too much code). Support changes: - Add a Proxy to Builder.js, which intercepts unknown property lookups. This creates way better error messages on typos than 'undefined is not a function', which happens semi-frequently as I typo opcode names (and which one is a typo is hard to find because we chain builders). - Add limited support for var{u}int64 (only the 32-bit values). - Get rid of much of the function index space: we already have all of its information elsewhere, and as-is it provides no extra efficiency. - Store Wasm::Memory directly on JSWebAssemblyMemory, instead of through a unique_ptr. This removes an indirection and useless allocation. - Remove VM'a WebAssembly memory / size, and obtain them from Instance instead. This requires an extra indirection, but is cleaner. - Cache the wasm entrypoint code's location on WebAssemblyFunction for faster access. - All Instance now have a valid JSWebAssemblyMemory when created, which allows the wasm -> wasm stub to assume it isn't null when trying to set the pinned registers. 1263163 11 jfbastien 2016-12-30 11:52:13 -0800 For comparison, here's the generated code if I always pin the registers, even if no memory is present: Generated JIT code for WebAssembly function[0] I32 (I32): Code at [0x24a7fac391e0, 0x24a7fac39280): 0x24a7fac391e0: push %rbp 0x24a7fac391e1: mov %rsp, %rbp 0x24a7fac391e4: add $0xffffffffffffffd0, %rsp 0x24a7fac391e8: mov %r13, -0x10(%rbp) 0x24a7fac391ec: mov %r14, -0x8(%rbp) 0x24a7fac391f0: mov $0x0, %rax 0x24a7fac391fa: mov %rax, 0x18(%rbp) 0x24a7fac391fe: mov $0x0, 0x10(%rbp) 0x24a7fac39206: mov $0x1055f5578, %r14 # It uses a different register here 0x24a7fac39210: mov (%r14), %r13 # And here 0x24a7fac39213: mov %edi, %eax 0x24a7fac39215: mov $0xc0febeef00000000, %rdi 0x24a7fac3921f: or %rax, %rdi 0x24a7fac39222: mov 0x48(%r13), %rax 0x24a7fac39226: cmp $0x36, 0x5(%rax) 0x24a7fac3922a: jz 0x24a7fac39256 0x24a7fac39230: mov $0x0, %r11 0x24a7fac3923a: call *%r11 0x24a7fac3923d: mov %r13, (%r14) # Assumes these registers are callee-saved (they are) and uses them again! 0x24a7fac39240: mov %rax, %rcx 0x24a7fac39243: shr $0x20, %rcx 0x24a7fac39247: xor %ecx, %eax 0x24a7fac39249: mov -0x10(%rbp), %r13 0x24a7fac3924d: mov -0x8(%rbp), %r14 0x24a7fac39251: mov %rbp, %rsp 0x24a7fac39254: pop %rbp 0x24a7fac39255: ret 0x24a7fac39256: mov $0x0, %r11 0x24a7fac39260: call *%r11 0x24a7fac39263: jmp 0x24a7fac3923d Generated JIT code for JavaScript->WebAssembly entrypoint[0] I32 (I32): Code at [0x24a7fac39280, 0x24a7fac392c0): 0x24a7fac39280: push %rbp 0x24a7fac39281: mov %rsp, %rbp 0x24a7fac39284: add $0xffffffffffffffe0, %rsp 0x24a7fac39288: mov $0x0, %rax 0x24a7fac39292: mov %rax, 0x18(%rbp) 0x24a7fac39296: mov $0x0, 0x10(%rbp) 0x24a7fac3929e: cmp $0x1, 0x20(%rbp) 0x24a7fac392a2: jb 0x24a7fac392bd 0x24a7fac392a8: mov 0x28(%rbp), %edi 0x24a7fac392ab: mov $0x24a7fac391e0, %r11 0x24a7fac392b5: call *%r11 0x24a7fac392b8: mov %rbp, %rsp 0x24a7fac392bb: pop %rbp 0x24a7fac392bc: ret 0x24a7fac392bd: int3 1263164 12 jfbastien 2016-12-30 11:57:27 -0800 I'm not sure it's even worth *not* pinning these registers for a Module which doesn't have a Memory. Is that ever a compelling usecase which we need to optimize for, and suffer my current headache? 1263166 13 297859 jfbastien 2016-12-30 12:11:01 -0800 Created attachment 297859 WIP Tiny update to always pin registers, even if we don't need to. The wasm-to-wasm.js test isn't passing yet, I must have messed something up. Will get back to it later today. 1263168 14 297860 jfbastien 2016-12-30 12:24:29 -0800 Created attachment 297860 WIP Actually I found the bug as I was walking away... I wasn't coercing 32-bit values in JavaScript properly, so it was using a negative value instead of a positive one as I wanted :-s I think, with a ChangeLog, this patch is now good to go! Will submit one soon. 1263174 15 297863 jfbastien 2016-12-30 12:54:18 -0800 Created attachment 297863 patch Ready for review! 1263331 16 297863 saam 2017-01-02 12:10:51 -0800 Comment on attachment 297863 patch View in context: https://bugs.webkit.org/attachment.cgi?id=297863&action=review Mostly LGTM, but I don't think we should require registers always be pinned. I don't think doing so actually make the code any simpler to reason about. > Source/JavaScriptCore/jsc.cpp:2673 > + SymbolTable* exportSymbolTable = SymbolTable::create(vm); > + auto* moduleStructure = InternalFunction::createSubclassStructure(exec, JSValue(), exec->lexicalGlobalObject()->WebAssemblyModuleStructure()); > + RETURN_IF_EXCEPTION(scope, encodedJSValue()); > + JSWebAssemblyModule* module = JSWebAssemblyModule::create(vm, moduleStructure, plan.takeModuleInformation(), plan.takeCallLinkInfos(), plan.takeWasmExitStubs(), exportSymbolTable, 0); > + Structure* instanceStructure = InternalFunction::createSubclassStructure(exec, JSValue(), globalObject->WebAssemblyInstanceStructure()); > + RETURN_IF_EXCEPTION(scope, encodedJSValue()); > + Identifier moduleKey = Identifier::fromUid(PrivateName(PrivateName::Description, "WebAssemblyInstance")); > + WebAssemblyModuleRecord* moduleRecord = WebAssemblyModuleRecord::create(exec, vm, globalObject->webAssemblyModuleRecordStructure(), moduleKey, module->moduleInformation()); > + RETURN_IF_EXCEPTION(scope, encodedJSValue()); > + JSWebAssemblyInstance* instance = JSWebAssemblyInstance::create(vm, instanceStructure, module, moduleRecord->getModuleNamespace(exec)); > + RETURN_IF_EXCEPTION(scope, encodedJSValue()); > + vm.topJSWebAssemblyInstance = instance; > + > + if (!!module->moduleInformation().memory) { > + bool failed; > + Wasm::Memory memory(module->moduleInformation().memory.initial(), module->moduleInformation().memory.maximum(), failed); > + RELEASE_ASSERT(failed); > + instance->setMemory(vm, JSWebAssemblyMemory::create(vm, globalObject->WebAssemblyMemoryStructure(), WTFMove(memory))); > + } Why is all this new stuff needed? I updated all tests that used this API and memory operations to the JS API. Therefore, that RELEASE_ASSERT you're removing was really protecting us from new tests of that form from being added. > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:260 > + // FIXME we don't really need to pin registers here if there's no memory. It makes wasm -> wasm thunks simpler for now. https://bugs.webkit.org/show_bug.cgi?id=166623 > + const PinnedRegisterInfo& pinnedRegs = PinnedRegisterInfo::get(); > + m_memoryBaseGPR = pinnedRegs.baseMemoryPointer; > m_proc.pinRegister(m_memoryBaseGPR); > - ASSERT(!info.memory.pinnedRegisters().sizeRegisters[0].sizeOffset); > - m_memorySizeGPR = info.memory.pinnedRegisters().sizeRegisters[0].sizeRegister; > - for (const PinnedSizeRegisterInfo& regInfo : info.memory.pinnedRegisters().sizeRegisters) > + ASSERT(!pinnedRegs.sizeRegisters[0].sizeOffset); > + m_memorySizeGPR = pinnedRegs.sizeRegisters[0].sizeRegister; > + for (const PinnedSizeRegisterInfo& regInfo : pinnedRegs.sizeRegisters) > m_proc.pinRegister(regInfo.sizeRegister); Style: Your indentation is off here. > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:328 > + B3::PatchpointValue* patchpoint = block->appendNew<B3::PatchpointValue>(proc, B3::Void, Origin()); > + patchpoint->effects = Effects::none(); > + patchpoint->effects.writesPinned = true; > + patchpoint->clobber(clobbers); > + patchpoint->appendVectorWithRep(arguments, ValueRep::SomeRegister); > + > + patchpoint->setGenerator([&pinnedRegs] (CCallHelpers& jit, const B3::StackmapGenerationParams& params) { > + AllowMacroScratchRegisterUsage allowScratch(jit); > + > + jit.move(params[0].gpr(), pinnedRegs.baseMemoryPointer); > + for (uint32_t i = 0; i < pinnedRegs.sizeRegisters.size(); ++i) > + jit.move(params[1 + i].gpr(), pinnedRegs.sizeRegisters[i].sizeRegister); > + }); > + } This is less efficient than the version I had. My version did most of the work in the MacroAssembler and required fewer moves. The reason for this is that it only took a Instance as an argument to the patchpoint, and then did all the work inside the patchpoint, so it could just load directly into the registers it needed to write to. Please revert back to the better version. > Source/JavaScriptCore/wasm/WasmBinding.cpp:274 > + // FIXME the following code assumes that all WebAssembly.Instance have the same pinned registers. https://bugs.webkit.org/show_bug.cgi?id=162952 > + // Set up the callee's baseMemory register as well as the memory size registers. > + jit.loadPtr(JIT::Address(baseMemory, JSWebAssemblyInstance::offsetOfMemory()), baseMemory); // JSWebAssemblyMemory*. > + const auto& sizeRegs = pinnedRegs.sizeRegisters; > + ASSERT(sizeRegs.size() >= 1); > + ASSERT(sizeRegs[0].sizeRegister != baseMemory); > + ASSERT(sizeRegs[0].sizeRegister != scratch); > + ASSERT(!sizeRegs[0].sizeOffset); // The following code assumes we start at 0, and calculates subsequent size registers relative to 0. > + jit.loadPtr(JIT::Address(baseMemory, JSWebAssemblyMemory::offsetOfSize()), sizeRegs[0].sizeRegister); // Memory size. > + jit.loadPtr(JIT::Address(baseMemory, JSWebAssemblyMemory::offsetOfMemory()), baseMemory); // WasmMemory::void*. > + for (unsigned i = 1; i < sizeRegs.size(); ++i) { > + ASSERT(sizeRegs[i].sizeRegister != baseMemory); > + ASSERT(sizeRegs[i].sizeRegister != scratch); > + jit.add64(JIT::TrustedImm32(-sizeRegs[i].sizeOffset), sizeRegs[0].sizeRegister, sizeRegs[1].sizeRegister); > + } This code is not correct. > Source/JavaScriptCore/wasm/WasmMemory.h:51 > + Memory() = default; Not a fan of this. If you go with my suggestion of not having to always pin registers, this isn't needed. > Source/JavaScriptCore/wasm/WasmSignature.h:85 > + WTF::String toString() const; Nit: WTF prefix not needed. > Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.cpp:91 > + { > + // Always start with a dummy Memory, so that wasm -> wasm thunks avoid checking for a nullptr Memory when trying to set pinned registers. > + Wasm::Memory memory; > + instance->setMemory(vm, JSWebAssemblyMemory::create(vm, exec->lexicalGlobalObject()->WebAssemblyMemoryStructure(), WTFMove(memory))); > + } I'm not sure this is the best design decision. Why not have the check for nullptr be the check seeing if we need to materialize registers or not? Then we don't have to unconditionally pin registers. Maybe this won't be a common use case, but I could imagine some math-heavy functions being bogged down doing the extra materialization work (and also hurt by extra register pressure). > Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.cpp:-137 > - // This should be guaranteed by module verification. > - RELEASE_ASSERT(instance->memory()); Then you can add this back. 1263333 17 297863 saam 2017-01-02 12:23:08 -0800 Comment on attachment 297863 patch View in context: https://bugs.webkit.org/attachment.cgi?id=297863&action=review >> Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:328 >> + } > > This is less efficient than the version I had. My version did most of the work in the MacroAssembler and required fewer moves. The reason for this is that it only took a Instance as an argument to the patchpoint, and then did all the work inside the patchpoint, so it could just load directly into the registers it needed to write to. Please revert back to the better version. You can also make my code use the 3-operand add like you have in the wasmToWasm() stub. >> Source/JavaScriptCore/wasm/WasmBinding.cpp:274 >> + } > > This code is not correct. This is correct, sorry. I meant to delete this comment. I wrote this before I realized you pre-populated a JSWebAssemblyMemory, always. That said, I still think we shouldn't have to do this. 1263336 18 saam 2017-01-02 12:30:07 -0800 (changing unicode in the title) 1263356 19 297913 jfbastien 2017-01-02 15:02:02 -0800 Created attachment 297913 patch Address comments. > Mostly LGTM, but I don't think we should require registers always be pinned. > I don't think doing so actually make the code any simpler to reason about. We could check on wasm->wasm entry, but then: - Code would be more complex / slower. - Stuck at 1 scratch register. - Calls from wasm instances which don't pin registers couldn't be tail calls since they'd need to spill. At the end of the day I just don't see wasm without a memory as a compelling use case. I could be wrong, but what's the point of using wasm that way? I do think it makes the code more complicated to try to handle pinned registers properly. > > Source/JavaScriptCore/jsc.cpp:2673 > > + SymbolTable* exportSymbolTable = SymbolTable::create(vm); > > + auto* moduleStructure = InternalFunction::createSubclassStructure(exec, JSValue(), exec->lexicalGlobalObject()->WebAssemblyModuleStructure()); > > + RETURN_IF_EXCEPTION(scope, encodedJSValue()); > > + JSWebAssemblyModule* module = JSWebAssemblyModule::create(vm, moduleStructure, plan.takeModuleInformation(), plan.takeCallLinkInfos(), plan.takeWasmExitStubs(), exportSymbolTable, 0); > > + Structure* instanceStructure = InternalFunction::createSubclassStructure(exec, JSValue(), globalObject->WebAssemblyInstanceStructure()); > > + RETURN_IF_EXCEPTION(scope, encodedJSValue()); > > + Identifier moduleKey = Identifier::fromUid(PrivateName(PrivateName::Description, "WebAssemblyInstance")); > > + WebAssemblyModuleRecord* moduleRecord = WebAssemblyModuleRecord::create(exec, vm, globalObject->webAssemblyModuleRecordStructure(), moduleKey, module->moduleInformation()); > > + RETURN_IF_EXCEPTION(scope, encodedJSValue()); > > + JSWebAssemblyInstance* instance = JSWebAssemblyInstance::create(vm, instanceStructure, module, moduleRecord->getModuleNamespace(exec)); > > + RETURN_IF_EXCEPTION(scope, encodedJSValue()); > > + vm.topJSWebAssemblyInstance = instance; > > + > > + if (!!module->moduleInformation().memory) { > > + bool failed; > > + Wasm::Memory memory(module->moduleInformation().memory.initial(), module->moduleInformation().memory.maximum(), failed); > > + RELEASE_ASSERT(failed); > > + instance->setMemory(vm, JSWebAssemblyMemory::create(vm, globalObject->WebAssemblyMemoryStructure(), WTFMove(memory))); > > + } > > Why is all this new stuff needed? I updated all tests that used this API and > memory operations to the JS API. > Therefore, that RELEASE_ASSERT you're removing was really protecting us from > new tests of that form from being added. I wrote that code before your patches went in. You're right, with the new uses it's simpler so I deleted this and removed the EXPORT stuff. > > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:328 > > + B3::PatchpointValue* patchpoint = block->appendNew<B3::PatchpointValue>(proc, B3::Void, Origin()); > > + patchpoint->effects = Effects::none(); > > + patchpoint->effects.writesPinned = true; > > + patchpoint->clobber(clobbers); > > + patchpoint->appendVectorWithRep(arguments, ValueRep::SomeRegister); > > + > > + patchpoint->setGenerator([&pinnedRegs] (CCallHelpers& jit, const B3::StackmapGenerationParams& params) { > > + AllowMacroScratchRegisterUsage allowScratch(jit); > > + > > + jit.move(params[0].gpr(), pinnedRegs.baseMemoryPointer); > > + for (uint32_t i = 0; i < pinnedRegs.sizeRegisters.size(); ++i) > > + jit.move(params[1 + i].gpr(), pinnedRegs.sizeRegisters[i].sizeRegister); > > + }); > > + } > > This is less efficient than the version I had. My version did most of the > work in the MacroAssembler and required fewer moves. The reason for this is > that it only took a Instance as an argument to the patchpoint, and then did > all the work inside the patchpoint, so it could just load directly into the > registers it needed to write to. Please revert back to the better version. I thought that having the Value* around would allow B3 to move things more, and generate better code in the long run? The code I had was pretty similar to what Keith had written before for this. In any case, you're right that what you wrote is pretty close to the thunks I also wrote, so I moved to this since it does generate better code at the moment, and from what you say it sounds like that's what's expected to be better in the future as well. > > Source/JavaScriptCore/wasm/WasmSignature.h:85 > > + WTF::String toString() const; > > Nit: WTF prefix not needed. It is needed because it's only forward-declared: In file included from ../Source/JavaScriptCore/wasm/WasmSignature.cpp:27: ../Source/JavaScriptCore/wasm/WasmSignature.h:85:5: error: unknown type name 'String'; did you mean 'WTF::String'? String toString() const; ^~~~~~ WTF::String ../Source/WTF/wtf/HashTraits.h:32:7: note: 'WTF::String' declared here class String; ^ I could include the right header, but that's against the "include what you use" approach so I'd rather not. > > Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.cpp:91 > > + { > > + // Always start with a dummy Memory, so that wasm -> wasm thunks avoid checking for a nullptr Memory when trying to set pinned registers. > > + Wasm::Memory memory; > > + instance->setMemory(vm, JSWebAssemblyMemory::create(vm, exec->lexicalGlobalObject()->WebAssemblyMemoryStructure(), WTFMove(memory))); > > + } > > I'm not sure this is the best design decision. > > Why not have the check for nullptr be the check seeing if we need to > materialize registers or not? Then we don't have to unconditionally pin > registers. Maybe this won't be a common use case, but I could imagine some > math-heavy functions being bogged down doing the extra materialization work > (and also hurt by extra register pressure). I just don't see wasm without Memory being a serious use case. To do math-heavy things without a Memory you'd need to call into wasm, and then hold all of your state in locals / globals. Sure that can be done since we have infinite locals and globals, but wasm being a compilation target means that LLVM won't generate such code, at least not for the foreseeable future. You'd need to hand-write that code, and I don't think it'll happen soon. On the other hand, I see wasm->wasm calls as a very serious use case! That's how you'll call libc and other things that your application depend on through dynamic linking. Having it be as fast as possible is super important IMO. That's why having a tail call, and fewer conditions in this code, are pretty important IMO. In that case, why have the null check, ever? 1263364 20 297913 saam 2017-01-02 16:16:50 -0800 Comment on attachment 297913 patch View in context: https://bugs.webkit.org/attachment.cgi?id=297913&action=review r=me with comments and some bugs found. > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:309 > + patchpoint->numGPScratchRegisters = 1; This is no longer needed since you're code is doing the 3-operand add based off the zero size register. > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:317 > + jit.loadPtr(CCallHelpers::Address(baseMemory, JSWebAssemblyMemory::offsetOfSize()), sizeRegs[0].sizeRegister); Can you add back your assert that this has a zero offset? > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:320 > + for (unsigned i = 1; i < sizeRegs.size(); ++i) > + jit.add64(CCallHelpers::TrustedImm32(-sizeRegs[i].sizeOffset), sizeRegs[0].sizeRegister, sizeRegs[1].sizeRegister); This code here is wrong. It should not be writing to sizeRegs[1]. It should be writing to sizeRegs[i].sizeRegister. Given that this code is never run now, I wonder if we're just better off not pretending it can be run, and just asserting that it can't be run. Then we can get back to it when we implement > 1 pinned size register. > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:841 > + ExpressionType functionImport = m_currentBlock->appendNew<MemoryValue>(m_proc, Load, pointerType(), Origin(), m_instanceValue, JSWebAssemblyInstance::offsetOfImportFunction(functionIndex)); > + ExpressionType jsTypeOfImport = m_currentBlock->appendNew<MemoryValue>(m_proc, Load8Z, Origin(), functionImport, JSCell::typeInfoTypeOffset()); Nit: I'd make these Value* instead of ExpressionType, since the very next statement uses Value*. > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:890 > + // The call could have been to another WebAssembly instance, and / or could have modified our Memory. > + restoreWebAssemblyGlobalState(m_vm, m_info.memory, m_instanceValue, m_proc, continuation); This code only needs to be emitted along the wasm path. > Source/JavaScriptCore/wasm/WasmBinding.cpp:41 > +static void materializeImportJSCell(VM* vm, JIT& jit, unsigned importIndex, GPRReg gpr) Style nit: I think we usually call "gpr" "result" in these types of functions. > Source/JavaScriptCore/wasm/WasmBinding.cpp:43 > + // Each JS -> wasm entry sets the WebAssembly.Instance whose export is being called. We're calling out of this Instance, and can therefore figure out the import being called. Nit: This comment is somewhat confusing and I don't think adds much to help guide what the code is doing. > Source/JavaScriptCore/wasm/WasmBinding.cpp:261 > + // FIXME the following code assumes that all WebAssembly.Instance have the same pinned registers. https://bugs.webkit.org/show_bug.cgi?id=162952 > + // Set up the callee's baseMemory register as well as the memory size registers. We could easily support this in the future if we just had wasm callee generate this code for itself instead of the caller generate it. That might be a nicer architecture going forward regardless since it would also nicely handle the materialize pinned registers problem. > Source/JavaScriptCore/wasm/WasmBinding.cpp:274 > + for (unsigned i = 1; i < sizeRegs.size(); ++i) { > + ASSERT(sizeRegs[i].sizeRegister != baseMemory); > + ASSERT(sizeRegs[i].sizeRegister != scratch); > + jit.add64(JIT::TrustedImm32(-sizeRegs[i].sizeOffset), sizeRegs[0].sizeRegister, sizeRegs[1].sizeRegister); > + } Same comment as earlier. This code shouldn't be storing to sizeRegs[1]. Also, this code is almost identical (or maybe exactly identical) to the code inside WasmB3IRGenerator. Maybe it's worth writing a common function for it? > Source/JavaScriptCore/wasm/WasmFormat.h:262 > + toJS, > + toWasm, Style Nit: I'd make these capitalized. So: "ToJs" and "ToWasm" > Source/JavaScriptCore/wasm/WasmPlan.cpp:223 > + std::make_unique<B3::Compilation>(FINALIZE_CODE(linkBuffer, ("JavaScript->WebAssembly entrypoint[%i] %s", functionIndex, signatureDescription.ascii().data())), WTFMove(context.jsEntrypointByproducts)); Nice. > Source/JavaScriptCore/wasm/js/WebAssemblyFunction.h:69 > + WebAssemblyFunction(VM&, JSGlobalObject*, Structure*, Wasm::SignatureIndex, void*); There is no need to pass in this void* directly since it can just be gotten of the JSWebAssemblyCallee inside finishCreation(). > Source/JavaScriptCore/wasm/js/WebAssemblyFunction.h:72 > + void* m_wasmEntryPointCode; // Remove indirections for wasm -> wasm calls. This comment is somewhat confusing. Maybe something like: "Caching the code pointer allows the wasm -> wasm stub to do a single load and jump instead of having dependent loads." (or something like that) > Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.cpp:90 > + // Always start with a dummy Memory, so that wasm -> wasm thunks avoid checking for a nullptr Memory when trying to set pinned registers. > + Wasm::Memory memory; > + instance->setMemory(vm, JSWebAssemblyMemory::create(vm, exec->lexicalGlobalObject()->WebAssemblyMemoryStructure(), WTFMove(memory))); This makes me wonder if we're better off just having the callee instead of caller generate a wasm->wasm call thunk. Maybe we should do that in a later patch, or at least have a bug open to consider it. 1263367 21 297918 jfbastien 2017-01-02 17:01:52 -0800 Created attachment 297918 patch Address more comments. A few questions left: > > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:890 > > + // The call could have been to another WebAssembly instance, and / or could have modified our Memory. > > + restoreWebAssemblyGlobalState(m_vm, m_info.memory, m_instanceValue, m_proc, continuation); > > This code only needs to be emitted along the wasm path. I don't think this is true: the JS code could modify Memory, or it could have called another Instance. We want to remove the double entry from JS to wasm, and then we'll need this code. No? > > Source/JavaScriptCore/wasm/WasmBinding.cpp:274 > > + for (unsigned i = 1; i < sizeRegs.size(); ++i) { > > + ASSERT(sizeRegs[i].sizeRegister != baseMemory); > > + ASSERT(sizeRegs[i].sizeRegister != scratch); > > + jit.add64(JIT::TrustedImm32(-sizeRegs[i].sizeOffset), sizeRegs[0].sizeRegister, sizeRegs[1].sizeRegister); > > + } > > Same comment as earlier. This code shouldn't be storing to sizeRegs[1]. > Also, this code is almost identical (or maybe exactly identical) to the code > inside WasmB3IRGenerator. Maybe it's worth writing a common function for it? Yeah it's almost the same except: - Uses a different JIT type (AssemblyHelpers instead of CCallHelpers). Should I make these the same, or use a template? - This code also restores Instance differently (B3 has a Value* that is kept live in the function, this needs to figure it out from the import). It could be split up, but I have some asserts on which registers are used to avoid unexpected clobbers. So I agree we could share things, but I'm not sure we want to. > > Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.cpp:90 > > + // Always start with a dummy Memory, so that wasm -> wasm thunks avoid checking for a nullptr Memory when trying to set pinned registers. > > + Wasm::Memory memory; > > + instance->setMemory(vm, JSWebAssemblyMemory::create(vm, exec->lexicalGlobalObject()->WebAssemblyMemoryStructure(), WTFMove(memory))); > > This makes me wonder if we're better off just having the callee instead of > caller generate a wasm->wasm call thunk. Maybe we should do that in a later > patch, or at least have a bug open to consider it. Yeah I guess we could have an off-to-the-side entrypeint from "other wasm", in addition to the regular "entry from this wasm instance", for all of the exported functions. We'd need to also change the callee codegen, but then we wouldn't need to tail (or rather, we'd inline that tail). That could be more efficient. 1263368 22 saam 2017-01-02 17:10:50 -0800 (In reply to comment #21) > Created attachment 297918 [details] > patch > > Address more comments. A few questions left: > > > > > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:890 > > > + // The call could have been to another WebAssembly instance, and / or could have modified our Memory. > > > + restoreWebAssemblyGlobalState(m_vm, m_info.memory, m_instanceValue, m_proc, continuation); > > > > This code only needs to be emitted along the wasm path. > > I don't think this is true: the JS code could modify Memory, or it could > have called another Instance. We want to remove the double entry from JS to > wasm, and then we'll need this code. No? Yeah I'm wrong, I wasn't thinking about this correctly. Ignore my comment. > > > > > Source/JavaScriptCore/wasm/WasmBinding.cpp:274 > > > + for (unsigned i = 1; i < sizeRegs.size(); ++i) { > > > + ASSERT(sizeRegs[i].sizeRegister != baseMemory); > > > + ASSERT(sizeRegs[i].sizeRegister != scratch); > > > + jit.add64(JIT::TrustedImm32(-sizeRegs[i].sizeOffset), sizeRegs[0].sizeRegister, sizeRegs[1].sizeRegister); > > > + } > > > > Same comment as earlier. This code shouldn't be storing to sizeRegs[1]. > > Also, this code is almost identical (or maybe exactly identical) to the code > > inside WasmB3IRGenerator. Maybe it's worth writing a common function for it? > > Yeah it's almost the same except: > - Uses a different JIT type (AssemblyHelpers instead of CCallHelpers). > Should I make these the same, or use a template? > - This code also restores Instance differently (B3 has a Value* that is > kept live in the function, this needs to figure it out from the import). It > could be split up, but I have some asserts on which registers are used to > avoid unexpected clobbers. > > So I agree we could share things, but I'm not sure we want to. Yeah, I agree that we probably don't want to share here. It seems like it'd make it more complicated. (Side note: CCallHelpers inherits from AssemblyHelpers, so you'd just declare it as AssemblyHelpers) > > > > > Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.cpp:90 > > > + // Always start with a dummy Memory, so that wasm -> wasm thunks avoid checking for a nullptr Memory when trying to set pinned registers. > > > + Wasm::Memory memory; > > > + instance->setMemory(vm, JSWebAssemblyMemory::create(vm, exec->lexicalGlobalObject()->WebAssemblyMemoryStructure(), WTFMove(memory))); > > > > This makes me wonder if we're better off just having the callee instead of > > caller generate a wasm->wasm call thunk. Maybe we should do that in a later > > patch, or at least have a bug open to consider it. > > Yeah I guess we could have an off-to-the-side entrypeint from "other wasm", > in addition to the regular "entry from this wasm instance", for all of the > exported functions. We'd need to also change the callee codegen, but then we > wouldn't need to tail (or rather, we'd inline that tail). > > That could be more efficient. Yeah, let's open a bug and deal with it later. 1263370 23 jfbastien 2017-01-02 17:30:41 -0800 > > > > Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.cpp:90 > > > > + // Always start with a dummy Memory, so that wasm -> wasm thunks avoid checking for a nullptr Memory when trying to set pinned registers. > > > > + Wasm::Memory memory; > > > > + instance->setMemory(vm, JSWebAssemblyMemory::create(vm, exec->lexicalGlobalObject()->WebAssemblyMemoryStructure(), WTFMove(memory))); > > > > > > This makes me wonder if we're better off just having the callee instead of > > > caller generate a wasm->wasm call thunk. Maybe we should do that in a later > > > patch, or at least have a bug open to consider it. > > > > Yeah I guess we could have an off-to-the-side entrypeint from "other wasm", > > in addition to the regular "entry from this wasm instance", for all of the > > exported functions. We'd need to also change the callee codegen, but then we > > wouldn't need to tail (or rather, we'd inline that tail). > > > > That could be more efficient. > Yeah, let's open a bug and deal with it later. I think we can tag it as part of: https://bugs.webkit.org/show_bug.cgi?id=166486 I'll add a comment there. 1263372 24 297918 commit-queue 2017-01-02 17:58:36 -0800 Comment on attachment 297918 patch Clearing flags on attachment: 297918 Committed r210229: <http://trac.webkit.org/changeset/210229> 1263373 25 commit-queue 2017-01-02 17:58:42 -0800 All reviewed patches have been landed. Closing bug. 297658 2016-12-22 10:52:12 -0800 2016-12-26 14:20:33 -0800 WP 0001-wasm-wasm.patch text/plain 31959 jfbastien RnJvbSAzNmI4MTRiYzg4NjQyODYwMDgwMTg5YTA5M2NlMjUxM2Y1ODM3MGRmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBXZWQsIDIxIERlYyAyMDE2IDE1OjU5OjU2IC0wODAwClN1YmplY3Q6IFtQQVRDSF0gd2FzbS0+ d2FzbQoKQ2hhbmdlcyB0byB0aGUgV2ViQXNzZW1ibHkgaW1wbGVtZW50YXRpb246CgogIC0gQWRk IGEgbmV3IEpTVHlwZSBmb3IgV2ViQXNzZW1ibHlGdW5jdGlvbiwgYW5kIHVzZSBpdCB3aGVuIGNy ZWF0aW5nIGl0cwogICAgc3RydWN0dXJlLiBUaGlzIHdpbGwgYmUgdXNlZCB0byBxdWlja2x5IGRl dGVjdCBmcm9tIHdhc20gd2hldGhlciB0aGUgaW1wb3J0CiAgICBjYWxsIGlzIHRvIGFub3RoZXIg d2FzbSBtb2R1bGUsIG9yIHdoZXRoZXIgaXQncyB0byBKUy4KICAtIFVzZSBjZWxsIGluc3RlYWQg b2Ygb2JqZWN0cyB0byBkZXRlY3Qgd2FzbS0+d2FzbSwgdGhlIHByZXZpb3VzIGNvZGUgd2FzIHdy b25nLgogIC0gSW1wcm92ZSBkaWFnbm9zdGljIHByaW50b3V0IGZvciB3YXNtIHN0dWJzOiBwcmlu dCB0aGUgZnVsbCBzaWduYXR1cmUuCiAgLSBQcm9wZXJseSBjaGVjayB0aGF0IHdhc20gLT4gd2Fz bSBjYWxscyBoYXZlIG1hdGNoaW5nIHNpZ25hdHVyZXMuIEFkZCB0ZXN0aW5nIGZvciB0aGlzLgog IC0gVGVzdCBzb21lIG9mIHRoZSB3YXNtIC0+IHdhc20gY2FsbHMsIG5vdCB3b3JraW5nIHlldCwg YW5kIG1vcmUgdGVzdHMgbmVlZCB0bwogICAgZ2V0IGltcGxlbWVudGVkLgoKU3VwcG9ydCBjaGFu Z2VzOgoKICAtIEFkZCBhIFByb3h5IHRvIEJ1aWxkZXIuanMsIHdoaWNoIGludGVyY2VwdHMgdW5r bm93biBwcm9wZXJ0eSBsb29rdXBzLiBUaGlzCiAgICBjcmVhdGVzIHdheSBiZXR0ZXIgZXJyb3Ig bWVzc2FnZXMgb24gdHlwb3MgdGhhbiAndW5kZWZpbmVkIGlzIG5vdCBhCiAgICBmdW5jdGlvbics IHdoaWNoIGhhcHBlbnMgc2VtaS1mcmVxdWVudGx5IGFzIEkgdHlwbyBvcGNvZGUgbmFtZXMgKGFu ZCB3aGljaAogICAgb25lIGlzIGEgdHlwbyBpcyBoYXJkIHRvIGZpbmQgYmVjYXVzZSB3ZSBjaGFp biBidWlsZGVycykuCiAgLSBBZGQgbGltaXRlZCBzdXBwb3J0IGZvciB2YXJ7dX1pbnQ2NCAob25s eSB0aGUgMzItYml0IHZhbHVlcykuCi0tLQogSlNUZXN0cy93YXNtL0J1aWxkZXIuanMgICAgICAg ICAgICAgICAgICAgICAgICAgICAgfCAgOTEgKysrKysrKysrKy0tLS0tLS0tCiBKU1Rlc3RzL3dh c20vTG93TGV2ZWxCaW5hcnkuanMgICAgICAgICAgICAgICAgICAgICB8ICAxMiArKysKIEpTVGVz dHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLWJhZC1zaWduYXR1cmUuanMgIHwgMTA1ICsrKysr KysrKysrKysrKysrKysrKwogSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMgICAg ICAgICAgICAgICAgfCAgNzIgKysrKysrKysrKysrKysKIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9y dW50aW1lL0pTVHlwZS5oICAgICAgICAgICAgIHwgICAyICsKIFNvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL1dhc21CaW5kaW5nLmNwcCAgICAgICAgIHwgICAzICstCiBTb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmNwcCAgICAgICB8ICAxMyArKysKIFNvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuaCAgICAgICAgIHwgICAxICsKIC4uLi9KYXZh U2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uY3BwIHwgICAyICstCiAuLi4v d2FzbS9qcy9XZWJBc3NlbWJseUluc3RhbmNlQ29uc3RydWN0b3IuY3BwICAgICB8ICAxMyArLS0K IDEwIGZpbGVzIGNoYW5nZWQsIDI2NiBpbnNlcnRpb25zKCspLCA0OCBkZWxldGlvbnMoLSkKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBKU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS1iYWQtc2ln bmF0dXJlLmpzCiBjcmVhdGUgbW9kZSAxMDA2NDQgSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRv LXdhc20uanMKCmRpZmYgLS1naXQgYS9KU1Rlc3RzL3dhc20vQnVpbGRlci5qcyBiL0pTVGVzdHMv d2FzbS9CdWlsZGVyLmpzCmluZGV4IGRhNTg0YzQuLjI2YmE2NmUgMTAwNjQ0Ci0tLSBhL0pTVGVz dHMvd2FzbS9CdWlsZGVyLmpzCisrKyBiL0pTVGVzdHMvd2FzbS9CdWlsZGVyLmpzCkBAIC0zOCw3 ICszOCw3IEBAIGNvbnN0IF9pc1ZhbGlkVmFsdWUgPSAodmFsdWUsIHR5cGUpID0+IHsKICAgICBz d2l0Y2ggKHR5cGUpIHsKICAgICAvLyBXZSBhbGxvdyBib3RoIHNpZ25lZCBhbmQgdW5zaWduZWQg bnVtYmVycy4KICAgICBjYXNlICJpMzIiOiByZXR1cm4gTWF0aC5yb3VuZCh2YWx1ZSkgPT09IHZh bHVlICYmIExMQi52YXJpbnQzMk1pbiA8PSB2YWx1ZSAmJiB2YWx1ZSA8PSBMTEIudmFydWludDMy TWF4OwotICAgIGNhc2UgImk2NCI6IHRocm93IG5ldyBFcnJvcihgVW5pbXBsZW1lbnRlZDogdmFs dWUgY2hlY2sgZm9yICR7dHlwZX1gKTsgLy8gRklYTUUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE2MzQyMCA2NC1iaXQgdmFsdWVzCisgICAgY2FzZSAiaTY0IjogcmV0 dXJuIHRydWU7IC8vIEZJWE1FIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0xNjM0MjAgNjQtYml0IHZhbHVlcwogICAgIGNhc2UgImYzMiI6IHJldHVybiB0eXBlb2YodmFs dWUpID09PSAibnVtYmVyIiAmJiBpc0Zpbml0ZSh2YWx1ZSk7CiAgICAgY2FzZSAiZjY0IjogcmV0 dXJuIHR5cGVvZih2YWx1ZSkgPT09ICJudW1iZXIiICYmIGlzRmluaXRlKHZhbHVlKTsKICAgICBk ZWZhdWx0OiB0aHJvdyBuZXcgRXJyb3IoYEltcGxlbWVudGF0aW9uIHByb2JsZW06IHVua25vd24g dHlwZSAke3R5cGV9YCk7CkBAIC01Nyw2ICs1NywxNiBAQCBjb25zdCBfbm9ybWFsaXplRnVuY3Rp b25TaWduYXR1cmUgPSAocGFyYW1zLCByZXQpID0+IHsKICAgICByZXR1cm4gW3BhcmFtcywgcmV0 XTsKIH07CiAKK2NvbnN0IF9lcnJvckhhbmRsaW5nUHJveHlGb3IgPSBidWlsZGVyID0+IGJ1aWxk ZXJbIl9faXNQcm94eSJdID8gYnVpbGRlciA6IG5ldyBQcm94eShidWlsZGVyLCB7CisgICAgZ2V0 OiAodGFyZ2V0LCBwcm9wZXJ0eSwgcmVjZWl2ZXIpID0+IHsKKyAgICAgICAgaWYgKHByb3BlcnR5 ID09PSAiX19pc1Byb3h5IikKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICBpZiAo dGFyZ2V0W3Byb3BlcnR5XSA9PT0gdW5kZWZpbmVkKQorICAgICAgICAgICAgdGhyb3cgbmV3IEVy cm9yKGBXZWJBc3NlbWJseSBidWlsZGVyIHJlY2VpdmVkIHVua25vd24gcHJvcGVydHkgJyR7cHJv cGVydHl9J2ApOworICAgICAgICByZXR1cm4gdGFyZ2V0W3Byb3BlcnR5XTsKKyAgICB9Cit9KTsK KwogY29uc3QgX21heWJlUmVnaXN0ZXJUeXBlID0gKGJ1aWxkZXIsIHR5cGUpID0+IHsKICAgICBj b25zdCB0eXBlU2VjdGlvbiA9IGJ1aWxkZXIuX2dldFNlY3Rpb24oIlR5cGUiKTsKICAgICBpZiAo dHlwZW9mKHR5cGUpID09PSAibnVtYmVyIikgewpAQCAtMTAwLDcgKzExMCw3IEBAIGNvbnN0IF9p bXBvcnRGdW5jdGlvbkNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRl cikgPT4gewogICAgICAgICBzZWN0aW9uLmRhdGEucHVzaCh7IGZpZWxkOiBmaWVsZCwgdHlwZTog dHlwZSwga2luZDogIkZ1bmN0aW9uIiwgbW9kdWxlOiBtb2R1bGUgfSk7CiAgICAgICAgIC8vIElt cG9ydHMgYWxzbyBjb3VudCBpbiB0aGUgZnVuY3Rpb24gaW5kZXggc3BhY2UuIE1hcCB0aGVtIGFz IG9iamVjdHMgdG8gYXZvaWQgY2xhc2hpbmcgd2l0aCBDb2RlIGZ1bmN0aW9ucycgbmFtZXMuCiAg ICAgICAgIGJ1aWxkZXIuX3JlZ2lzdGVyRnVuY3Rpb25Ub0luZGV4U3BhY2UoeyBtb2R1bGU6IG1v ZHVsZSwgZmllbGQ6IGZpZWxkIH0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAg ICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9Owog fTsKIApAQCAtMTA5LDcgKzExOSw3IEBAIGNvbnN0IF9pbXBvcnRNZW1vcnlDb250aW51YXRpb24g PSAoYnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1aWxkZXIpID0+IHsKICAgICAgICAgYXNzZXJ0Lmlz U3RyaW5nKG1vZHVsZSwgYEltcG9ydCBNZW1vcnkgbW9kdWxlIHNob3VsZCBiZSBhIHN0cmluZywg Z290ICIke21vZHVsZX0iYCk7CiAgICAgICAgIGFzc2VydC5pc1N0cmluZyhmaWVsZCwgYEltcG9y dCBNZW1vcnkgZmllbGQgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7ZmllbGR9ImApOwogICAg ICAgICBzZWN0aW9uLmRhdGEucHVzaCh7bW9kdWxlLCBmaWVsZCwga2luZDogIk1lbW9yeSIsIG1l bW9yeURlc2NyaXB0aW9uOiB7aW5pdGlhbCwgbWF4aW11bX19KTsKLSAgICAgICAgcmV0dXJuIG5l eHRCdWlsZGVyOworICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihuZXh0QnVp bGRlcik7CiAgICAgfTsKIH07CiAKQEAgLTExOCw3ICsxMjgsNyBAQCBjb25zdCBfaW1wb3J0VGFi bGVDb250aW51YXRpb24gPSAoYnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1aWxkZXIpID0+IHsKICAg ICAgICAgYXNzZXJ0LmlzU3RyaW5nKG1vZHVsZSwgYEltcG9ydCBUYWJsZSBtb2R1bGUgc2hvdWxk IGJlIGEgc3RyaW5nLCBnb3QgIiR7bW9kdWxlfSJgKTsKICAgICAgICAgYXNzZXJ0LmlzU3RyaW5n KGZpZWxkLCBgSW1wb3J0IFRhYmxlIGZpZWxkIHNob3VsZCBiZSBhIHN0cmluZywgZ290ICIke2Zp ZWxkfSJgKTsKICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2goe21vZHVsZSwgZmllbGQsIGtpbmQ6 ICJUYWJsZSIsIHRhYmxlRGVzY3JpcHRpb246IHtpbml0aWFsLCBtYXhpbXVtLCBlbGVtZW50fX0p OwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5k bGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9OwogfTsKIApAQCAtMTcyLDcgKzE4Miw3 IEBAIGNvbnN0IF9leHBvcnRGdW5jdGlvbkNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9u LCBuZXh0QnVpbGRlcikgPT4gewogICAgICAgICAgICAgICAgIGFzc2VydC5lcSh0eXBlLCBleHBv cnRlZEltcG9ydC50eXBlLCBgUmUtZXhwb3J0aW5nIGltcG9ydCAiJHtleHBvcnRlZEltcG9ydC5m aWVsZH0iIGFzICIke2ZpZWxkfSIgaGFzIG1pc21hdGNoaW5nIHR5cGVgKTsKICAgICAgICAgfQog ICAgICAgICBzZWN0aW9uLmRhdGEucHVzaCh7IGZpZWxkOiBmaWVsZCwgdHlwZTogdHlwZSwga2lu ZDogIkZ1bmN0aW9uIiwgaW5kZXg6IGluZGV4IH0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxk ZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsK ICAgICB9OwogfTsKIApAQCAtMTg5LDcgKzE5OSw3IEBAIGNvbnN0IF9leHBvcnRHbG9iYWxDb250 aW51YXRpb24gPSAoYnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1aWxkZXIpID0+IHsKICAgICByZXR1 cm4gKGZpZWxkLCBpbmRleCkgPT4gewogICAgICAgICBhc3NlcnQuaXNOdW1iZXIoaW5kZXgsIGBH bG9iYWwgZXhwb3J0cyBvbmx5IHN1cHBvcnQgbnVtYmVyIGluZGljZXMgcmlnaHQgbm93YCk7CiAg ICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHsgZmllbGQsIGtpbmQ6ICJHbG9iYWwiLCBpbmRleCB9 KTsKLSAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICByZXR1cm4gX2Vycm9ySGFu ZGxpbmdQcm94eUZvcihuZXh0QnVpbGRlcik7CiAgICAgfQogfTsKIApAQCAtMTk3LDcgKzIwNyw3 IEBAIGNvbnN0IF9leHBvcnRNZW1vcnlDb250aW51YXRpb24gPSAoYnVpbGRlciwgc2VjdGlvbiwg bmV4dEJ1aWxkZXIpID0+IHsKICAgICByZXR1cm4gKGZpZWxkLCBpbmRleCkgPT4gewogICAgICAg ICBhc3NlcnQuaXNOdW1iZXIoaW5kZXgsIGBNZW1vcnkgZXhwb3J0cyBvbmx5IHN1cHBvcnQgbnVt YmVyIGluZGljZXNgKTsKICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2goe2ZpZWxkLCBraW5kOiAi TWVtb3J5IiwgaW5kZXh9KTsKLSAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICBy ZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihuZXh0QnVpbGRlcik7CiAgICAgfQogfTsKIApA QCAtMjA1LDcgKzIxNSw3IEBAIGNvbnN0IF9leHBvcnRUYWJsZUNvbnRpbnVhdGlvbiA9IChidWls ZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgIHJldHVybiAoZmllbGQsIGluZGV4 KSA9PiB7CiAgICAgICAgIGFzc2VydC5pc051bWJlcihpbmRleCwgYFRhYmxlIGV4cG9ydHMgb25s eSBzdXBwb3J0IG51bWJlciBpbmRpY2VzYCk7CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHtm aWVsZCwga2luZDogIlRhYmxlIiwgaW5kZXh9KTsKLSAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVy OworICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihuZXh0QnVpbGRlcik7CiAg ICAgfQogfTsKIApAQCAtMjIwLDEwICsyMzAsMTAgQEAgY29uc3QgX2ltcG9ydEdsb2JhbENvbnRp bnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgICAgICAg ICAgICAgIGFzc2VydC5pc1N0cmluZyhmaWVsZCwgYEltcG9ydCBnbG9iYWwgZmllbGQgc2hvdWxk IGJlIGEgc3RyaW5nLCBnb3QgIiR7ZmllbGR9ImApOwogICAgICAgICAgICAgICAgIGFzc2VydC5p c1N0cmluZyhtdXRhYmlsaXR5LCBgSW1wb3J0IGdsb2JhbCBtdXRhYmlsaXR5IHNob3VsZCBiZSBh IHN0cmluZywgZ290ICIke211dGFiaWxpdHl9ImApOwogICAgICAgICAgICAgICAgIHNlY3Rpb24u ZGF0YS5wdXNoKHsgZ2xvYmFsRGVzY3JpcHRpb246IHsgdHlwZTogb3AsIG11dGFiaWxpdHk6IF9u b3JtYWxpemVNdXRhYmlsaXR5KG11dGFiaWxpdHkpIH0sIG1vZHVsZSwgZmllbGQsIGtpbmQ6ICJH bG9iYWwiIH0pOwotICAgICAgICAgICAgICAgIHJldHVybiBnbG9iYWxCdWlsZGVyOworICAgICAg ICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwog ICAgICAgICAgICAgfTsKICAgICAgICAgfQotICAgICAgICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsK KyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7CiAg ICAgfTsKIH07CiAKQEAgLTMyNCwxMSArMzM0LDExIEBAIGNvbnN0IF9jcmVhdGVGdW5jdGlvbkJ1 aWxkZXIgPSAoZnVuYywgYnVpbGRlciwgcHJldmlvdXNCdWlsZGVyKSA9PiB7CiAgICAgICAgICAg ICBkZWZhdWx0OgogICAgICAgICAgICAgICAgIG5leHRCdWlsZGVyID0gZnVuY3Rpb25CdWlsZGVy OwogICAgICAgICAgICAgICAgIGJyZWFrOwotICAgICAgICAgICAgICAgIGNhc2UgIkVuZCI6Cisg ICAgICAgICAgICBjYXNlICJFbmQiOgogICAgICAgICAgICAgICAgIG5leHRCdWlsZGVyID0gcHJl dmlvdXNCdWlsZGVyOwotICAgICAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgICAg ICBicmVhazsKICAgICAgICAgICAgIGNhc2UgIkJsb2NrIjoKLSAgICAgICAgICAgICAgICBjYXNl ICJMb29wIjoKKyAgICAgICAgICAgIGNhc2UgIkxvb3AiOgogICAgICAgICAgICAgY2FzZSAiSWYi OgogICAgICAgICAgICAgICAgIG5leHRCdWlsZGVyID0gX2NyZWF0ZUZ1bmN0aW9uQnVpbGRlcihm dW5jLCBidWlsZGVyLCBmdW5jdGlvbkJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIGJyZWFrOwpA QCAtMzQ0LDExICszNTQsMTIgQEAgY29uc3QgX2NyZWF0ZUZ1bmN0aW9uQnVpbGRlciA9IChmdW5j LCBidWlsZGVyLCBwcmV2aW91c0J1aWxkZXIpID0+IHsKICAgICAgICAgICAgIGNvbnN0IHN0YWNr QXJncyA9IFtdOyAvLyBGSVhNRSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTYyNzA2CiAgICAgICAgICAgICBmdW5jLmNvZGUucHVzaCh7IG5hbWU6IG9wLCB2YWx1ZTog dmFsdWUsIGFyZ3VtZW50czogc3RhY2tBcmdzLCBpbW1lZGlhdGVzOiBpbW1zIH0pOwogICAgICAg ICAgICAgaWYgKGhhc0NvbnRpbnVhdGlvbikKLSAgICAgICAgICAgICAgICByZXR1cm4gY29udGlu dWF0aW9uKG5leHRCdWlsZGVyKS5FbmQoKTsKLSAgICAgICAgICAgIHJldHVybiBuZXh0QnVpbGRl cjsKKyAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihjb250aW51 YXRpb24obmV4dEJ1aWxkZXIpLkVuZCgpKTsKKyAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5k bGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICAgICAgfTsKLSAgICB9Ci0gICAgcmV0dXJu IGZ1bmN0aW9uQnVpbGRlcjsKKyAgICB9OworCisgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJv eHlGb3IoZnVuY3Rpb25CdWlsZGVyKTsKIH0KIAogY29uc3QgX2NyZWF0ZUZ1bmN0aW9uID0gKHNl Y3Rpb24sIGJ1aWxkZXIsIHByZXZpb3VzQnVpbGRlcikgPT4gewpAQCAtNDQ5LDEwICs0NjAsMTAg QEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAg ICBGdW5jOiAocGFyYW1zLCByZXQpID0+IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBb cGFyYW1zLCByZXRdID0gX25vcm1hbGl6ZUZ1bmN0aW9uU2lnbmF0dXJlKHBhcmFtcywgcmV0KTsK ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaCh7IHBhcmFtczogcGFyYW1z LCByZXQ6IHJldCB9KTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gdHlwZUJ1 aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5n UHJveHlGb3IodHlwZUJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAgICAgfSwKICAgICAg ICAgICAgICAgICAgICAgfTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHR5cGVCdWlsZGVy OworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih0eXBl QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApA QCAtNDY2LDcgKzQ3Nyw3IEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAg ICAgICAgICAgICAgICBpbXBvcnRCdWlsZGVyLkZ1bmN0aW9uID0gX2ltcG9ydEZ1bmN0aW9uQ29u dGludWF0aW9uKHRoaXMsIHMsIGltcG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICBp bXBvcnRCdWlsZGVyLk1lbW9yeSA9IF9pbXBvcnRNZW1vcnlDb250aW51YXRpb24odGhpcywgcywg aW1wb3J0QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgIGltcG9ydEJ1aWxkZXIuVGFibGUg PSBfaW1wb3J0VGFibGVDb250aW51YXRpb24odGhpcywgcywgaW1wb3J0QnVpbGRlcik7Ci0gICAg ICAgICAgICAgICAgICAgIHJldHVybiBpbXBvcnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAg ICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihpbXBvcnRCdWlsZGVyKTsKICAgICAgICAg ICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC00NzcsNyArNDg4LDcgQEAg ZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBF bmQ6ICgpID0+IHRoaXMKICAgICAgICAgICAgICAgICAgICAgICAgIC8vIEZJWE1FOiBhZGQgYWJp bGl0eSB0byBhZGQgdGhpcyB3aXRoIHdoYXRldmVyLgogICAgICAgICAgICAgICAgICAgICB9Owot ICAgICAgICAgICAgICAgICAgICByZXR1cm4gZnVuY3Rpb25CdWlsZGVyOworICAgICAgICAgICAg ICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihmdW5jdGlvbkJ1aWxkZXIpOwog ICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTQ4OCwxMCAr NDk5LDEwIEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAg ICAgICAgICAgRW5kOiAoKSA9PiB0aGlzLAogICAgICAgICAgICAgICAgICAgICAgICAgVGFibGU6 ICh7aW5pdGlhbCwgbWF4aW11bSwgZWxlbWVudH0pID0+IHsKICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBzLmRhdGEucHVzaCh7dGFibGVEZXNjcmlwdGlvbjoge2luaXRpYWwsIG1heGltdW0s IGVsZW1lbnR9fSk7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHRhYmxlQnVp bGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQ cm94eUZvcih0YWJsZUJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAg ICAgICAgICAgICAgICB9OwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gdGFibGVCdWlsZGVy OworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih0YWJs ZUJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAK QEAgLTUwMiwxMCArNTEzLDEwIEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAg ICAgICAgICAgICAgICAgICAgICAgRW5kOiAoKSA9PiB0aGlzLAogICAgICAgICAgICAgICAgICAg ICAgICAgSW5pdGlhbE1heFBhZ2VzOiAoaW5pdGlhbCwgbWF4KSA9PiB7CiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgcy5kYXRhLnB1c2goeyBpbml0aWFsLCBtYXggfSk7Ci0gICAgICAgICAg ICAgICAgICAgICAgICAgICAgcmV0dXJuIG1lbW9yeUJ1aWxkZXI7CisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobWVtb3J5QnVpbGRlcik7 CiAgICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAg ICAgICAgICAgICAgICAgIHJldHVybiBtZW1vcnlCdWlsZGVyOworICAgICAgICAgICAgICAgICAg ICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihtZW1vcnlCdWlsZGVyKTsKICAgICAgICAg ICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC01MTYsMTYgKzUyNywxNiBA QCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAg IEVuZDogKCkgPT4gdGhpcywKICAgICAgICAgICAgICAgICAgICAgICAgIEdldEdsb2JhbDogKHR5 cGUsIGluaXRWYWx1ZSwgbXV0YWJpbGl0eSkgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHMuZGF0YS5wdXNoKHsgdHlwZSwgb3A6ICJnZXRfZ2xvYmFsIiwgbXV0YWJpbGl0eTogX25v cm1hbGl6ZU11dGFiaWxpdHkobXV0YWJpbGl0eSksIGluaXRWYWx1ZSB9KTsKLSAgICAgICAgICAg ICAgICAgICAgICAgICAgICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsK ICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgfTsKICAgICAg ICAgICAgICAgICAgICAgZm9yIChsZXQgb3Agb2YgV0FTTS5kZXNjcmlwdGlvbi52YWx1ZV90eXBl KSB7CiAgICAgICAgICAgICAgICAgICAgICAgICBnbG9iYWxCdWlsZGVyW190b0phdmFTY3JpcHRO YW1lKG9wKV0gPSAoaW5pdFZhbHVlLCBtdXRhYmlsaXR5KSA9PiB7CiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgcy5kYXRhLnB1c2goeyB0eXBlOiBvcCwgb3A6IG9wICsgIi5jb25zdCIsIG11 dGFiaWxpdHk6IF9ub3JtYWxpemVNdXRhYmlsaXR5KG11dGFiaWxpdHkpLCBpbml0VmFsdWUgfSk7 Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZ2xv YmFsQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAg ICAgICB9Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiBnbG9iYWxCdWlsZGVyOworICAgICAg ICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVy KTsKICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC01Mzks NyArNTUwLDcgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAg ICAgICAgIGV4cG9ydEJ1aWxkZXIuRnVuY3Rpb24gPSBfZXhwb3J0RnVuY3Rpb25Db250aW51YXRp b24odGhpcywgcywgZXhwb3J0QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgIGV4cG9ydEJ1 aWxkZXIuTWVtb3J5ID0gX2V4cG9ydE1lbW9yeUNvbnRpbnVhdGlvbih0aGlzLCBzLCBleHBvcnRC dWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgZXhwb3J0QnVpbGRlci5UYWJsZSA9IF9leHBv cnRUYWJsZUNvbnRpbnVhdGlvbih0aGlzLCBzLCBleHBvcnRCdWlsZGVyKTsKLSAgICAgICAgICAg ICAgICAgICAgcmV0dXJuIGV4cG9ydEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVy biBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGV4cG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAg IH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTU1Miw3ICs1NjMsNyBAQCBleHBvcnQg ZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgaWYgKHR5cGVvZihm dW5jdGlvbkluZGV4T3JOYW1lKSAhPT0gIm51bWJlciIgJiYgdHlwZW9mKGZ1bmN0aW9uSW5kZXhP ck5hbWUpICE9PSAic3RyaW5nIikKICAgICAgICAgICAgICAgICAgICAgICAgIHRocm93IG5ldyBF cnJvcihgU3RhcnQgc2VjdGlvbidzIGZ1bmN0aW9uIGluZGV4ICBtdXN0IGVpdGhlciBiZSBhIG51 bWJlciBvciBhIHN0cmluZ2ApOwogICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaChmdW5j dGlvbkluZGV4T3JOYW1lKTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHN0YXJ0QnVpbGRl cjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3Ioc3Rh cnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwog CkBAIC01NjMsMTEgKzU3NCwxMSBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAg ICAgICAgICAgICAgICAgICAgICAgIEVuZDogKCkgPT4gdGhpcywKICAgICAgICAgICAgICAgICAg ICAgICAgIEVsZW1lbnQ6ICh7dGFibGVJbmRleCA9IDAsIG9mZnNldCwgZnVuY3Rpb25JbmRpY2Vz fSkgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKHt0YWJsZUlu ZGV4LCBvZmZzZXQsIGZ1bmN0aW9uSW5kaWNlc30pOwotICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHJldHVybiBlbGVtZW50QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihlbGVtZW50QnVpbGRlcik7CiAgICAgICAgICAg ICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgIH07CiAKLSAgICAgICAgICAgICAg ICAgICAgcmV0dXJuIGVsZW1lbnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4g X2Vycm9ySGFuZGxpbmdQcm94eUZvcihlbGVtZW50QnVpbGRlcik7CiAgICAgICAgICAgICAgICAg fTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNjMyLDEyICs2NDMsMTIgQEAgZXhwb3J0 IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAvLyBGSVhNRSBpbiBjaGVja2VkIG1vZGUsIHRlc3QgdGhhdCB0aGUgdHlwZSBpcyBhY2Nl cHRhYmxlIGZvciBzdGFydCBmdW5jdGlvbi4gV2UgcHJvYmFibHkgd2FudCBfcmVnaXN0ZXJGdW5j dGlvblRvSW5kZXhTcGFjZSB0byBhbHNvIHJlZ2lzdGVyIHR5cGVzIHBlciBpbmRleC4gaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NTY1OAogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfQotICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBidWlsZGVyOworICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGJ1aWxkZXIpOwogICAgICAg ICAgICAgICAgICAgICAgICAgfSwKIAogICAgICAgICAgICAgICAgICAgICB9OwogICAgICAgICAg ICAgICAgICAgICBjb2RlQnVpbGRlci5GdW5jdGlvbiA9IF9jcmVhdGVGdW5jdGlvbihzLCBidWls ZGVyLCBjb2RlQnVpbGRlcik7Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiBjb2RlQnVpbGRl cjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoY29k ZUJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAK QEAgLTY2MCwxOSArNjcxLDE5IEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBJbmRleDogaW5kZXggPT4gewogICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgYXNzZXJ0LmVxKGluZGV4LCAwKTsgLy8gTGluZWFy IG1lbW9yeSBpbmRleCBtdXN0IGJlIHplcm8gaW4gTVZQLgogICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgdGhpc1NlZ21lbnQuaW5kZXggPSBpbmRleDsKLSAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBzZWdtZW50QnVpbGRlcjsKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHNl Z21lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfSwKICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgT2Zmc2V0OiBvZmZzZXQgPT4gewogICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gRklYTUUgYWxsb3cgY29tcGxleCBpbml0X2V4 cHIgaGVyZS4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NTcwMAog ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYXNzZXJ0LmlzTnVtYmVyKG9mZnNl dCk7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0aGlzU2VnbWVudC5vZmZz ZXQgPSBvZmZzZXQ7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4g c2VnbWVudEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1 cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihzZWdtZW50QnVpbGRlcik7CiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIH0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfTsKLSAg ICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gc2VnbWVudEJ1aWxkZXI7CisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3Ioc2VnbWVu dEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAgICAgfSwKICAgICAgICAgICAgICAgICAg ICAgfTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGRhdGFCdWlsZGVyOworICAgICAgICAg ICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihkYXRhQnVpbGRlcik7CiAg ICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNjkwLDEwICs3 MDEsMTAgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAg Qnl0ZTogYiA9PiB7CiAgICAgICAgICAgICAgICAgICAgIGFzc2VydC5lcShiICYgMHhGRiwgYiwg YFVua25vd24gc2VjdGlvbiBleHBlY3RlZCBieXRlLCBnb3Q6ICIke2J9ImApOwogICAgICAgICAg ICAgICAgICAgICBzLmRhdGEucHVzaChiKTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHVu a25vd25CdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQ cm94eUZvcih1bmtub3duQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAg fTsKLSAgICAgICAgICAgIHJldHVybiB1bmtub3duQnVpbGRlcjsKKyAgICAgICAgICAgIHJldHVy biBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHVua25vd25CdWlsZGVyKTsKICAgICAgICAgfTsKICAg ICB9CiAgICAgX2FkZFNlY3Rpb24obmFtZU9yTnVtYmVyLCBleHRyYU9iamVjdCkgewpkaWZmIC0t Z2l0IGEvSlNUZXN0cy93YXNtL0xvd0xldmVsQmluYXJ5LmpzIGIvSlNUZXN0cy93YXNtL0xvd0xl dmVsQmluYXJ5LmpzCmluZGV4IDYxMWEyNmQuLmY5YmM4YTMgMTAwNjQ0Ci0tLSBhL0pTVGVzdHMv d2FzbS9Mb3dMZXZlbEJpbmFyeS5qcworKysgYi9KU1Rlc3RzL3dhc20vTG93TGV2ZWxCaW5hcnku anMKQEAgLTE3MCw2ICsxNzAsMTggQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgTG93TGV2ZWxCaW5h cnkgewogICAgICAgICAgICAgdGhpcy51aW50OCgweDgwIHwgYik7CiAgICAgICAgIH0gd2hpbGUg KHRydWUpOwogICAgIH0KKyAgICB2YXJ1aW50NjQodikgeworICAgICAgICBhc3NlcnQuaXNOdW1i ZXIodik7CisgICAgICAgIGlmICh2IDwgdmFydWludDMyTWluIHx8IHZhcnVpbnQzMk1heCA8IHYp CisgICAgICAgICAgICB0aHJvdyBuZXcgUmFuZ2VFcnJvcihgdW5pbXBsZW1lbnRlZDogdmFydWlu dDY0IGxhcmdlciB0aGFuIDMyLWJpdGApOworICAgICAgICB0aGlzLnZhcnVpbnQzMih2KTsgLy8g RklYTUUgaW1wbGVtZW50IDY0LWJpdCB2YXJ7dX1pbnQgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE2MzQyMAorICAgIH0KKyAgICB2YXJpbnQ2NCh2KSB7CisgICAgICAg IGFzc2VydC5pc051bWJlcih2KTsKKyAgICAgICAgaWYgKHYgPCB2YXJpbnQzMk1pbiB8fCB2YXJp bnQzMk1heCA8IHYpCisgICAgICAgICAgICB0aHJvdyBuZXcgUmFuZ2VFcnJvcihgdW5pbXBsZW1l bnRlZDogdmFyaW50NjQgbGFyZ2VyIHRoYW4gMzItYml0YCk7CisgICAgICAgIHRoaXMudmFyaW50 MzIodik7IC8vIEZJWE1FIGltcGxlbWVudCA2NC1iaXQgdmFye3V9aW50IGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjM0MjAKKyAgICB9CiAgICAgdmFydWludDEodikg ewogICAgICAgICBpZiAodiAhPT0gMCAmJiB2ICE9PSAxKQogICAgICAgICAgICAgdGhyb3cgbmV3 IFJhbmdlRXJyb3IoYEludmFsaWQgdmFydWludDEgJHt2fSByYW5nZSBpcyBbMCwgMV1gKTsKZGlm ZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLWJhZC1zaWduYXR1cmUu anMgYi9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS1iYWQtc2lnbmF0dXJlLmpzCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdhNTY0ZWMKLS0tIC9kZXYvbnVsbAor KysgYi9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS1iYWQtc2lnbmF0dXJlLmpzCkBA IC0wLDAgKzEsMTA1IEBACitpbXBvcnQgKiBhcyBhc3NlcnQgZnJvbSAnLi4vYXNzZXJ0LmpzJzsK K2ltcG9ydCBCdWlsZGVyIGZyb20gJy4uL0J1aWxkZXIuanMnOworCitjb25zdCBpbXBvcnROYW1l ID0gInBpZXJPbmUiOworY29uc3QgdHlwZXMgPSBbImkzMiIsICJpNjQiLCAiZjMyIiwgImY2NCIs ICJ2b2lkIl07Citjb25zdCB0eXBlc05vblZvaWQgPSBbImkzMiIsICJpNjQiLCAiZjMyIiwgImY2 NCJdOworY29uc3Qgc3dhcFR5cGUgPSAodHlwZSwgaW5kZXgpID0+IHR5cGVzWyh0eXBlcy5pbmRl eE9mKHR5cGUpICsgaW5kZXgpICUgdHlwZXMubGVuZ3RoXTsKK2NvbnN0IHN3YXBUeXBlTm9uVm9p ZCA9ICh0eXBlLCBpbmRleCkgPT4gdHlwZXNOb25Wb2lkWyh0eXBlc05vblZvaWQuaW5kZXhPZih0 eXBlKSArIGluZGV4KSAlIHR5cGVzTm9uVm9pZC5sZW5ndGhdOworCitjb25zdCBzaWduYXR1cmVz ID0gWworICAgIHsgcGFyYW1zOiBbImkzMiJdLCByZXQ6ICJ2b2lkIiB9LAorICAgIHsgcGFyYW1z OiBbImk2NCJdLCByZXQ6ICJ2b2lkIiB9LAorICAgIHsgcGFyYW1zOiBbImYzMiJdLCByZXQ6ICJ2 b2lkIiB9LAorICAgIHsgcGFyYW1zOiBbImY2NCJdLCByZXQ6ICJ2b2lkIiB9LAorICAgIHsgcGFy YW1zOiBbImkzMiJdLCByZXQ6ICJpMzIiIH0sCisgICAgeyBwYXJhbXM6IFsiaTY0Il0sIHJldDog Imk2NCIgfSwKKyAgICB7IHBhcmFtczogWyJmMzIiXSwgcmV0OiAiZjMyIiB9LAorICAgIHsgcGFy YW1zOiBbImY2NCJdLCByZXQ6ICJmNjQiIH0sCisgICAgeyBwYXJhbXM6IFsiaTMyIiwgImYzMiJd LCByZXQ6ICJpMzIiIH0sCisgICAgeyBwYXJhbXM6IFsiZjMyIiwgImkzMiJdLCByZXQ6ICJpMzIi IH0sCisgICAgeyBwYXJhbXM6IFsiaTY0IiwgImY2NCJdLCByZXQ6ICJpNjQiIH0sCisgICAgeyBw YXJhbXM6IFsiZjY0IiwgImk2NCJdLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IFsiaTMy IiwgImYzMiIsICJpMzIiXSwgcmV0OiAiaTMyIiB9LAorICAgIHsgcGFyYW1zOiBbImkzMiIsICJm MzIiLCAiaTMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7IHBhcmFtczogWyJpNjQiLCAiZjY0Iiwg Imk2NCJdLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IFsiaTY0IiwgImY2NCIsICJpNjQi XSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBBcnJheSgzMikuZmlsbCgiaTMyIiksIHJl dDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogQXJyYXkoMzIpLmZpbGwoImk2NCIpLCByZXQ6ICJp NjQiIH0sCisgICAgeyBwYXJhbXM6IEFycmF5KDMyKS5maWxsKCJmMzIiKSwgcmV0OiAiaTY0IiB9 LAorICAgIHsgcGFyYW1zOiBBcnJheSgzMikuZmlsbCgiZjY0IiksIHJldDogImk2NCIgfSwKK107 CisKK2NvbnN0IG1ha2VJbXBvcnRlciA9IHNpZ25hdHVyZSA9PiB7CisgICAgY29uc3QgYnVpbGRl ciA9IChuZXcgQnVpbGRlcigpKQorICAgICAgICAuVHlwZSgpLkVuZCgpCisgICAgICAgIC5JbXBv cnQoKS5GdW5jdGlvbigiZXhwb3J0cyIsIGltcG9ydE5hbWUsIHNpZ25hdHVyZSkuRW5kKCk7Cisg ICAgcmV0dXJuIG5ldyBXZWJBc3NlbWJseS5Nb2R1bGUoYnVpbGRlci5XZWJBc3NlbWJseSgpLmdl dCgpKTsKK307CisKK2NvbnN0IG1ha2VJbXBvcnRlZSA9IHNpZ25hdHVyZSA9PiB7CisgICAgY29u c3QgYnVpbGRlciA9IChuZXcgQnVpbGRlcigpKQorICAgICAgICAuVHlwZSgpLkVuZCgpCisgICAg ICAgIC5GdW5jdGlvbigpLkVuZCgpCisgICAgICAgIC5FeHBvcnQoKQorICAgICAgICAgICAgLkZ1 bmN0aW9uKGltcG9ydE5hbWUpCisgICAgICAgIC5FbmQoKQorICAgICAgICAuQ29kZSgpCisgICAg ICAgICAgICAuRnVuY3Rpb24oaW1wb3J0TmFtZSwgc2lnbmF0dXJlKTsKKyAgICBzd2l0Y2ggKHNp Z25hdHVyZS5yZXQpIHsKKyAgICBjYXNlICJpMzIiOiBidWlsZGVyLkkzMkNvbnN0KDApOyBicmVh azsKKyAgICBjYXNlICJpNjQiOiBidWlsZGVyLkk2NENvbnN0KDApOyBicmVhazsKKyAgICBjYXNl ICJmMzIiOiBidWlsZGVyLkYzMkNvbnN0KDApOyBicmVhazsKKyAgICBjYXNlICJmNjQiOiBidWls ZGVyLkY2NENvbnN0KDApOyBicmVhazsKKyAgICBjYXNlICJ2b2lkIjogYnJlYWs7CisgICAgfQor ICAgIHJldHVybiBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UobmV3IFdlYkFzc2VtYmx5Lk1vZHVs ZShidWlsZGVyLlJldHVybigpLkVuZCgpLkVuZCgpLldlYkFzc2VtYmx5KCkuZ2V0KCkpKTsKK307 CisKKyhmdW5jdGlvbiBCYWJTaWduYXR1cmVEcm9wU3RhcnRQYXJhbXMoKSB7CisgICAgZm9yIChs ZXQgc2lnbmF0dXJlIG9mIHNpZ25hdHVyZXMpIHsKKyAgICAgICAgY29uc3QgaW1wb3J0ZWUgPSBt YWtlSW1wb3J0ZWUoc2lnbmF0dXJlKTsKKyAgICAgICAgZm9yIChsZXQgaSA9IDE7IGkgPD0gc2ln bmF0dXJlLnBhcmFtcy5sZW5ndGg7ICsraSkgeworICAgICAgICAgICAgY29uc3QgYmFkUGFyYW1T aWduYXR1cmUgPSB7IHBhcmFtczogc2lnbmF0dXJlLnBhcmFtcy5zbGljZShpLCBzaWduYXR1cmUu cGFyYW1zLmxlbmd0aCksIHJldDogc2lnbmF0dXJlLnJldCB9OworICAgICAgICAgICAgY29uc3Qg aW1wb3J0ZXIgPSBtYWtlSW1wb3J0ZXIoYmFkUGFyYW1TaWduYXR1cmUpOworICAgICAgICAgICAg YXNzZXJ0LnRocm93cygoKSA9PiBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGlt cG9ydGVlKSwgV2ViQXNzZW1ibHkuTGlua0Vycm9yLCBgaW1wb3J0ZWQgZnVuY3Rpb24ncyBzaWdu YXR1cmUgbWlzbWF0Y2hlcyB0aGUgcHJvdmlkZWQgV2ViQXNzZW1ibHkgZnVuY3Rpb24ncyBzaWdu YXR1cmUgKGV2YWx1YXRpbmcgJ25ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1w b3J0ZWUpJylgKTsKKyAgICAgICAgfQorICAgIH0KK30pKCk7CisKKyhmdW5jdGlvbiBCYWJTaWdu YXR1cmVEcm9wRW5kUGFyYW1zKCkgeworICAgIGZvciAobGV0IHNpZ25hdHVyZSBvZiBzaWduYXR1 cmVzKSB7CisgICAgICAgIGNvbnN0IGltcG9ydGVlID0gbWFrZUltcG9ydGVlKHNpZ25hdHVyZSk7 CisgICAgICAgIGZvciAobGV0IGkgPSAxOyBpIDwgc2lnbmF0dXJlLnBhcmFtcy5sZW5ndGg7ICsr aSkgeworICAgICAgICAgICAgY29uc3QgYmFkUGFyYW1TaWduYXR1cmUgPSB7IHBhcmFtczogc2ln bmF0dXJlLnBhcmFtcy5zbGljZSgwLCBpKSwgcmV0OiBzaWduYXR1cmUucmV0IH07CisgICAgICAg ICAgICBjb25zdCBpbXBvcnRlciA9IG1ha2VJbXBvcnRlcihiYWRQYXJhbVNpZ25hdHVyZSk7Cisg ICAgICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShp bXBvcnRlciwgaW1wb3J0ZWUpLCBXZWJBc3NlbWJseS5MaW5rRXJyb3IsIGBpbXBvcnRlZCBmdW5j dGlvbidzIHNpZ25hdHVyZSBtaXNtYXRjaGVzIHRoZSBwcm92aWRlZCBXZWJBc3NlbWJseSBmdW5j dGlvbidzIHNpZ25hdHVyZSAoZXZhbHVhdGluZyAnbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGlt cG9ydGVyLCBpbXBvcnRlZSknKWApOworICAgICAgICB9CisgICAgfQorfSkoKTsKKworKGZ1bmN0 aW9uIEJhYlNpZ25hdHVyZVN3YXBQYXJhbSgpIHsKKyAgICBmb3IgKGxldCBzaWduYXR1cmUgb2Yg c2lnbmF0dXJlcykgeworICAgICAgICBjb25zdCBpbXBvcnRlZSA9IG1ha2VJbXBvcnRlZShzaWdu YXR1cmUpOworICAgICAgICBmb3IgKGxldCBzaWduYXR1cmVJbmRleCA9IDA7IHNpZ25hdHVyZUlu ZGV4IDwgc2lnbmF0dXJlLmxlbmd0aDsgKytzaWduYXR1cmVJbmRleCkgeworICAgICAgICAgICAg Zm9yIChsZXQgdHlwZUluZGV4ID0gMTsgdHlwZUluZGV4IDwgdHlwZXNOb25Wb2lkLmxlbmd0aDsg Kyt0eXBlSW5kZXgpIHsKKyAgICAgICAgICAgICAgICBsZXQgYmFkUGFyYW1zID0gc2lnbmF0dXJl LnBhcmFtcy5zbGljZSgpOworICAgICAgICAgICAgICAgIGJhZFBhcmFtc1tzaWduYXR1cmVJbmRl eF0gPSBzd2FwVHlwZU5vblZvaWQoYmFkUGFyYW1zW3NpZ25hdHVyZUluZGV4XSwgdHlwZUluZGV4 KTsKKyAgICAgICAgICAgICAgICBjb25zdCBiYWRQYXJhbVNpZ25hdHVyZSA9IHsgcGFyYW1zOiBi YWRQYXJhbXMsIHJldDogc2lnbmF0dXJlLnJldCB9OworICAgICAgICAgICAgICAgIGNvbnN0IGlt cG9ydGVyID0gbWFrZUltcG9ydGVyKGJhZFBhcmFtU2lnbmF0dXJlKTsKKyAgICAgICAgICAgICAg ICBhc3NlcnQudGhyb3dzKCgpID0+IG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwg aW1wb3J0ZWUpLCBXZWJBc3NlbWJseS5MaW5rRXJyb3IsIGBpbXBvcnRlZCBmdW5jdGlvbidzIHNp Z25hdHVyZSBtaXNtYXRjaGVzIHRoZSBwcm92aWRlZCBXZWJBc3NlbWJseSBmdW5jdGlvbidzIHNp Z25hdHVyZSAoZXZhbHVhdGluZyAnbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBp bXBvcnRlZSknKWApOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorfSkoKTsKKwor KGZ1bmN0aW9uIEJhYlNpZ25hdHVyZVJldCgpIHsKKyAgICBmb3IgKGxldCBzaWduYXR1cmUgb2Yg c2lnbmF0dXJlcykgeworICAgICAgICBjb25zdCBpbXBvcnRlZSA9IG1ha2VJbXBvcnRlZShzaWdu YXR1cmUpOworICAgICAgICBmb3IgKGxldCB0eXBlSW5kZXggPSAxOyB0eXBlSW5kZXggPCB0eXBl cy5sZW5ndGg7ICsrdHlwZUluZGV4KSB7CisgICAgICAgICAgICBjb25zdCBiYWRQYXJhbVNpZ25h dHVyZSA9IHsgcGFyYW1zOiBzaWduYXR1cmUucGFyYW1zLCByZXQ6IHN3YXBUeXBlKHNpZ25hdHVy ZS5yZXQsIHR5cGVJbmRleCkgfTsKKyAgICAgICAgICAgIGNvbnN0IGltcG9ydGVyID0gbWFrZUlt cG9ydGVyKGJhZFBhcmFtU2lnbmF0dXJlKTsKKyAgICAgICAgICAgIGFzc2VydC50aHJvd3MoKCkg PT4gbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSksIFdlYkFzc2Vt Ymx5LkxpbmtFcnJvciwgYGltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIG1pc21hdGNoZXMg dGhlIHByb3ZpZGVkIFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIChldmFsdWF0aW5n ICduZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKScpYCk7CisgICAg ICAgIH0KKyAgICB9Cit9KSgpOwpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2pzLWFwaS93YXNt LXRvLXdhc20uanMgYi9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS5qcwpuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41MjRlNDUzCi0tLSAvZGV2L251bGwKKysrIGIv SlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMKQEAgLTAsMCArMSw3MiBAQAoraW1w b3J0ICogYXMgYXNzZXJ0IGZyb20gJy4uL2Fzc2VydC5qcyc7CitpbXBvcnQgQnVpbGRlciBmcm9t ICcuLi9CdWlsZGVyLmpzJzsKKworY29uc3QgY2FsbGVyVG9wQml0cyA9IDB4QzBGRUJFRUY7Citj b25zdCBpbm5lclJldHVybkhpID0gMHhERUFERkFDRTsKK2NvbnN0IGlubmVyUmV0dXJuTG8gPSAw eEMwRkVDMEZFOworCitjb25zdCBjYWxsZXJNb2R1bGUgPSAoKSA9PiB7CisgICAgY29uc3QgYnVp bGRlciA9IChuZXcgQnVpbGRlcigpKQorICAgICAgICAuVHlwZSgpLkVuZCgpCisgICAgICAgIC5J bXBvcnQoKQorICAgICAgICAgICAgLkZ1bmN0aW9uKCJleHBvcnRzIiwgImNhbGxNZSIsIHsgcGFy YW1zOiBbImk2NCJdLCByZXQ6ICJpNjQiIH0pCisgICAgICAgIC5FbmQoKQorICAgICAgICAuRnVu Y3Rpb24oKS5FbmQoKQorICAgICAgICAuRXhwb3J0KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigi ZW50cnkiKQorICAgICAgICAuRW5kKCkKKyAgICAgICAgLkNvZGUoKQorICAgICAgICAgICAgLkZ1 bmN0aW9uKCJlbnRyeSIsIHsgcGFyYW1zOiBbImkzMiJdLCByZXQ6ICJpMzIiIH0sIFsiaTY0Il0p CisgICAgICAgICAgICAgICAgLkkzMkNvbnN0KGNhbGxlclRvcEJpdHMpLkk2NEV4dGVuZFVJMzIo KS5JMzJDb25zdCgzMikuSTY0RXh0ZW5kVUkzMigpLkk2NFNobCgpIC8vICgoaTY0KWNhbGxlclRv cEJpdHMpIDw8IDMyCisgICAgICAgICAgICAgICAgLkdldExvY2FsKDApLkk2NEV4dGVuZFVJMzIo KQorICAgICAgICAgICAgICAgIC5JNjRPcigpIC8vIHZhbHVlOiBwYXJhbSB8ICgoKGk2NCljYWxs ZXJUb3BCaXRzIDw8IDMyKSkKKyAgICAgICAgICAgICAgICAuQ2FsbCgwKSAvLyBDYWxscyBleHBv cnRzLmNhbGxNZShwYXJhbSB8ICgoKGk2NCljYWxsZXJUb3BCaXRzKSA8PCAzMikpLgorICAgICAg ICAgICAgICAgIC5UZWVMb2NhbCgxKS5JMzJXcmFwSTY0KCkgLy8gbG86IChpMzIpY2FsbFJlc3Vs dAorICAgICAgICAgICAgICAgIC5HZXRMb2NhbCgxKS5JMzJDb25zdCgzMikuSTY0RXh0ZW5kVUkz MigpLkk2NFNoclUoKS5JMzJXcmFwSTY0KCkgLy8gaGk6IChpMzIpKGNhbGxSZXN1bHQgPj4gMzIp CisgICAgICAgICAgICAgICAgLkkzMlhvcigpCisgICAgICAgICAgICAgICAgLlJldHVybigpCisg ICAgICAgICAgICAuRW5kKCkKKyAgICAgICAgLkVuZCgpOworICAgIHJldHVybiBuZXcgV2ViQXNz ZW1ibHkuTW9kdWxlKGJ1aWxkZXIuV2ViQXNzZW1ibHkoKS5nZXQoKSk7Cit9OworCitjb25zdCBj YWxsZWVNb2R1bGUgPSAoKSA9PiB7CisgICAgY29uc3QgYnVpbGRlciA9IChuZXcgQnVpbGRlcigp KQorICAgICAgICAuVHlwZSgpLkVuZCgpCisgICAgICAgIC5JbXBvcnQoKQorICAgICAgICAgICAg LkZ1bmN0aW9uKCJpbXAiLCAiZnVuYyIsIHsgcGFyYW1zOiBbImkzMiIsICJpMzIiXSwgcmV0OiAi aTMyIiB9KQorICAgICAgICAuRW5kKCkKKyAgICAgICAgLkZ1bmN0aW9uKCkuRW5kKCkKKyAgICAg ICAgLkV4cG9ydCgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImNhbGxNZSIpCisgICAgICAgIC5F bmQoKQorICAgICAgICAuQ29kZSgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImNhbGxNZSIsIHsg cGFyYW1zOiBbImk2NCJdLCByZXQ6ICJpNjQiIH0pCisgICAgICAgICAgICAgICAgLkdldExvY2Fs KDApLkkzMldyYXBJNjQoKSAvLyBsbzogKGkzMilwYXJhbQorICAgICAgICAgICAgICAgIC5HZXRM b2NhbCgwKS5JMzJDb25zdCgzMikuSTY0RXh0ZW5kVUkzMigpLkk2NFNoclUoKS5JMzJXcmFwSTY0 KCkgLy8gaGk6IChpMzIpKHBhcmFtID4+IDMyKQorICAgICAgICAgICAgICAgIC5DYWxsKDApIC8v IENhbGxzIGltcC5mdW5jIHdpdGggdGhlIDY0LWJpdCB2YWx1ZSBhcyBpMzIgeyBoaSwgbG8gfS4K KyAgICAgICAgICAgICAgICAuRHJvcCgpCisgICAgICAgICAgICAgICAgLkkzMkNvbnN0KGlubmVy UmV0dXJuSGkpLkk2NEV4dGVuZFVJMzIoKS5JMzJDb25zdCgzMikuSTY0RXh0ZW5kVUkzMigpLkk2 NFNobCgpLkkzMkNvbnN0KGlubmVyUmV0dXJuTG8pLkk2NEV4dGVuZFVJMzIoKS5JNjRPcigpIC8v ICgoaTY0KWhpIDw8IDMyKSB8IChpNjQpbG8KKyAgICAgICAgICAgICAgICAuUmV0dXJuKCkKKyAg ICAgICAgICAgIC5FbmQoKQorICAgICAgICAuRW5kKCk7CisgICAgcmV0dXJuIG5ldyBXZWJBc3Nl bWJseS5Nb2R1bGUoYnVpbGRlci5XZWJBc3NlbWJseSgpLmdldCgpKTsKK307CisKKyhmdW5jdGlv biBXYXNtVG9XYXNtKCkgeworICAgIGxldCB2YWx1ZTsKKyAgICBjb25zdCBmdW5jID0gKGhpLCBs bykgPT4geyB2YWx1ZSA9IHsgaGk6IGhpLCBsbzogbG8gfTsgcHJpbnQoYCR7RXJyb3Iuc3RhY2t9 YCk7IHJldHVybiBoaSBeIGxvOyB9OworICAgIGNvbnN0IGNhbGxlZSA9IG5ldyBXZWJBc3NlbWJs eS5JbnN0YW5jZShjYWxsZWVNb2R1bGUoKSwgeyBpbXA6IHsgZnVuYzogZnVuYyB9IH0pOworICAg IGNvbnN0IGNhbGxlciA9IG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShjYWxsZXJNb2R1bGUoKSwg Y2FsbGVlKTsKKyAgICBmb3IgKGxldCBpID0gMDsgaSA8IDQwOTY7ICsraSkgeworICAgICAgICBh c3NlcnQuZXEoY2FsbGVyLmV4cG9ydHMuZW50cnkoaSksIGlubmVyUmV0dXJuSGkgXiBpbm5lclJl dHVybkxvKTsKKyAgICAgICAgYXNzZXJ0LmVxKHZhbHVlLmhpLCBjYWxsZXJUb3BCaXRzKTsKKyAg ICAgICAgYXNzZXJ0LmVxKHZhbHVlLmxvLCBpKTsKKyAgICB9Cit9KSgpOworCisKKy8vIEZJWE1F OiB0ZXN0IHdhc20tPndhc20gdXNpbmcgMzItYml0IHRoaW5ncyAoaW5jbHVkaW5nIGZsb2F0KSwg YXMgd2VsbCBhcyA2NC1iaXQgTmFOcyB0aGF0IGRvbid0IGdldCBjYW5vbmljYWxpemVkCisvLyBG SVhNRTogZG8gYSB0aHJvdyB0d28tZGVlcAorLy8gRklYTUU6IGNoZWNrIHRoYXQgdGhlIGZpcnN0 IHdhc20ncyBpbnN0YW5jZSBpcyBiYWNrIGluIE9LIHN0YXRlICh3aXRoIHRhYmxlIG9yIGdsb2Jh bD8pCisvLyBGSVhNRTogdGVzdCBjYWxsaW5nIHRocm91Z2ggYSBUYWJsZQpkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmggYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvcnVudGltZS9KU1R5cGUuaAppbmRleCAwNTIwMmYzLi5hYzUwOWQ3IDEwMDY0NAotLS0g YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU1R5cGUuaAorKysgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvcnVudGltZS9KU1R5cGUuaApAQCAtOTMsNiArOTMsOCBAQCBlbnVtIEpTVHlw ZSA6IHVpbnQ4X3QgewogICAgIEpTTWFwVHlwZSwKICAgICBKU1NldFR5cGUsCiAKKyAgICBXZWJB c3NlbWJseUZ1bmN0aW9uVHlwZSwKKwogICAgIExhc3RKU0NPYmplY3RUeXBlID0gSlNTZXRUeXBl LAogICAgIE1heEpTVHlwZSA9IDBiMTExMTExMTEsCiB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbUJpbmRpbmcuY3BwCmluZGV4IDBlNTkyNDcuLjg4NmQzZjkgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmNwcAorKysgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5jcHAKQEAgLTIzMSw3ICsyMzEsOCBAQCBX YXNtVG9KU1N0dWIgaW1wb3J0U3R1YkdlbmVyYXRvcihWTSogdm0sIEJhZzxDYWxsTGlua0luZm8+ JiBjYWxsTGlua0luZm9zLCBTaWduYQogICAgIENvZGVMb2NhdGlvbkxhYmVsIGhvdFBhdGhCZWdp bihwYXRjaEJ1ZmZlci5sb2NhdGlvbk9mKHRhcmdldFRvQ2hlY2spKTsKICAgICBDb2RlTG9jYXRp b25OZWFyQ2FsbCBob3RQYXRoT3RoZXIgPSBwYXRjaEJ1ZmZlci5sb2NhdGlvbk9mTmVhckNhbGwo ZmFzdENhbGwpOwogICAgIGNhbGxMaW5rSW5mby0+c2V0Q2FsbExvY2F0aW9ucyhjYWxsUmV0dXJu TG9jYXRpb24sIGhvdFBhdGhCZWdpbiwgaG90UGF0aE90aGVyKTsKLSAgICByZXR1cm4gRklOQUxJ WkVfQ09ERShwYXRjaEJ1ZmZlciwgKCJXZWJBc3NlbWJseSBpbXBvcnRbJWldIHN0dWIgZm9yIHNp Z25hdHVyZSAlaSIsIGltcG9ydEluZGV4LCBzaWduYXR1cmVJbmRleCkpOworICAgIFN0cmluZyBz aWduYXR1cmVEZXNjcmlwdGlvbiA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQodm0sIHNpZ25h dHVyZUluZGV4KS0+dG9TdHJpbmcoKTsKKyAgICByZXR1cm4gRklOQUxJWkVfQ09ERShwYXRjaEJ1 ZmZlciwgKCJXZWJBc3NlbWJseSBpbXBvcnRbJWldIHN0dWIgZm9yIHNpZ25hdHVyZSAlaTogJXMi LCBpbXBvcnRJbmRleCwgc2lnbmF0dXJlSW5kZXgsIHNpZ25hdHVyZURlc2NyaXB0aW9uLmFzY2lp KCkuZGF0YSgpKSk7CiB9CiAKIH0gfSAvLyBuYW1lc3BhY2UgSlNDOjpXYXNtCmRpZmYgLS1naXQg YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmNwcCBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuY3BwCmluZGV4IDZkNWIxZjYuLjk5N2Jk MDYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUu Y3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuY3BwCkBA IC00MSw2ICs0MSwxOSBAQCBjb25zdCBib29sIHZlcmJvc2UgPSBmYWxzZTsKIAogY29uc3QgY29u c3RleHByIFNpZ25hdHVyZUluZGV4IFNpZ25hdHVyZTo6aW52YWxpZEluZGV4OwogCitTdHJpbmcg U2lnbmF0dXJlOjp0b1N0cmluZygpIGNvbnN0Cit7CisgICAgU3RyaW5nIHJlc3VsdChtYWtlU3Ry aW5nKHJldHVyblR5cGUoKSkpOworICAgIHJlc3VsdC5hcHBlbmQoIiAoIik7CisgICAgZm9yIChT aWduYXR1cmVBcmdDb3VudCBhcmcgPSAwOyBhcmcgPCBhcmd1bWVudENvdW50KCk7ICsrYXJnKSB7 CisgICAgICAgIGlmIChhcmcpCisgICAgICAgICAgICByZXN1bHQuYXBwZW5kKCIsICIpOworICAg ICAgICByZXN1bHQuYXBwZW5kKG1ha2VTdHJpbmcoYXJndW1lbnQoYXJnKSkpOworICAgIH0KKyAg ICByZXN1bHQuYXBwZW5kKCcpJyk7CisgICAgcmV0dXJuIHJlc3VsdDsKK30KKwogdm9pZCBTaWdu YXR1cmU6OmR1bXAoUHJpbnRTdHJlYW0mIG91dCkgY29uc3QKIHsKICAgICBvdXQucHJpbnQobWFr ZVN0cmluZyhyZXR1cm5UeXBlKCkpLCAiICgiKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21TaWduYXR1cmUuaAppbmRleCAwZDZjN2I1Li40ZDQzZmZjIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmgKKysrIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5oCkBAIC04Miw2ICs4Miw3IEBAIHB1YmxpYzoK ICAgICB9CiAgICAgVHlwZSBhcmd1bWVudChTaWduYXR1cmVBcmdDb3VudCBpKSBjb25zdCB7IHJl dHVybiBjb25zdF9jYXN0PFNpZ25hdHVyZSo+KHRoaXMpLT5hcmd1bWVudChpKTsgfQogCisgICAg V1RGOjpTdHJpbmcgdG9TdHJpbmcoKSBjb25zdDsKICAgICB2b2lkIGR1bXAoV1RGOjpQcmludFN0 cmVhbSYgb3V0KSBjb25zdDsKICAgICBib29sIG9wZXJhdG9yPT0oY29uc3QgU2lnbmF0dXJlJiBy aHMpIGNvbnN0CiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v anMvV2ViQXNzZW1ibHlGdW5jdGlvbi5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9q cy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNwcAppbmRleCA0ZjBkN2E4Li40MDI1MGEzIDEwMDY0NAot LS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNw cAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9u LmNwcApAQCAtMTUzLDcgKzE1Myw3IEBAIFdlYkFzc2VtYmx5RnVuY3Rpb24qIFdlYkFzc2VtYmx5 RnVuY3Rpb246OmNyZWF0ZShWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPCiBTdHJ1Y3R1 cmUqIFdlYkFzc2VtYmx5RnVuY3Rpb246OmNyZWF0ZVN0cnVjdHVyZShWTSYgdm0sIEpTR2xvYmFs T2JqZWN0KiBnbG9iYWxPYmplY3QsIEpTVmFsdWUgcHJvdG90eXBlKQogewogICAgIEFTU0VSVChn bG9iYWxPYmplY3QpOwotICAgIHJldHVybiBTdHJ1Y3R1cmU6OmNyZWF0ZSh2bSwgZ2xvYmFsT2Jq ZWN0LCBwcm90b3R5cGUsIFR5cGVJbmZvKEpTRnVuY3Rpb25UeXBlLCBTdHJ1Y3R1cmVGbGFncyks IGluZm8oKSk7CisgICAgcmV0dXJuIFN0cnVjdHVyZTo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3Qs IHByb3RvdHlwZSwgVHlwZUluZm8oV2ViQXNzZW1ibHlGdW5jdGlvblR5cGUsIFN0cnVjdHVyZUZs YWdzKSwgaW5mbygpKTsKIH0KIAogV2ViQXNzZW1ibHlGdW5jdGlvbjo6V2ViQXNzZW1ibHlGdW5j dGlvbihWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QsIFN0cnVjdHVyZSogc3Ry dWN0dXJlLCBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCkKZGlmZiAtLWdpdCBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VDb25zdHJ1 Y3Rvci5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUluc3Rh bmNlQ29uc3RydWN0b3IuY3BwCmluZGV4IGQ2M2U4MzkuLjY0NTViOWIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VDb25zdHJ1Y3Rv ci5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlJbnN0 YW5jZUNvbnN0cnVjdG9yLmNwcApAQCAtMTE0LDE4ICsxMTQsMTkgQEAgc3RhdGljIEVuY29kZWRK U1ZhbHVlIEpTQ19IT1NUX0NBTEwgY29uc3RydWN0SlNXZWJBc3NlbWJseUluc3RhbmNlKEV4ZWNT dGF0ZSogZXgKICAgICAgICAgICAgICAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKHRocm93RXhj ZXB0aW9uKGV4ZWMsIHRocm93U2NvcGUsIGNyZWF0ZUpTV2ViQXNzZW1ibHlMaW5rRXJyb3IoZXhl YywgJnZtLCBBU0NJSUxpdGVyYWwoImltcG9ydCBmdW5jdGlvbiBtdXN0IGJlIGNhbGxhYmxlIikp KSk7CiAgICAgICAgICAgICBKU0NlbGwqIGNlbGwgPSB2YWx1ZS5hc0NlbGwoKTsKICAgICAgICAg ICAgIC8vIGlpLiBJZiB2IGlzIGFuIEV4cG9ydGVkIEZ1bmN0aW9uIEV4b3RpYyBPYmplY3Q6Ci0g ICAgICAgICAgICBpZiAoV2ViQXNzZW1ibHlGdW5jdGlvbiogaW1wb3J0ZWRFeHBvcnRzID0ganNE eW5hbWljQ2FzdDxXZWJBc3NlbWJseUZ1bmN0aW9uKj4ob2JqZWN0KSkgewotICAgICAgICAgICAg ICAgIC8vIEZJWE1FIGhhbmRsZSBGdW5jdGlvbiBFeG90aWMgT2JqZWN0IHByb3Blcmx5LiBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1MjgyCi0gICAgICAgICAgICAg ICAgLy8gYS4gSWYgdGhlIHNpZ25hdHVyZSBvZiB2IGRvZXMgbm90IG1hdGNoIHRoZSBzaWduYXR1 cmUgb2YgaSwgdGhyb3cgYSBUeXBlRXJyb3IuCisgICAgICAgICAgICBpZiAoV2ViQXNzZW1ibHlG dW5jdGlvbiogaW1wb3J0ZWRFeHBvcnQgPSBqc0R5bmFtaWNDYXN0PFdlYkFzc2VtYmx5RnVuY3Rp b24qPihjZWxsKSkgeworICAgICAgICAgICAgICAgIC8vIGEuIElmIHRoZSBzaWduYXR1cmUgb2Yg diBkb2VzIG5vdCBtYXRjaCB0aGUgc2lnbmF0dXJlIG9mIGksIHRocm93IGEgV2ViQXNzZW1ibHku TGlua0Vycm9yLgorICAgICAgICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IGltcG9ydGVk U2lnbmF0dXJlSW5kZXggPSBpbXBvcnRlZEV4cG9ydC0+c2lnbmF0dXJlSW5kZXgoKTsKKyAgICAg ICAgICAgICAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBleHBlY3RlZFNpZ25hdHVyZUluZGV4ID0g bW9kdWxlSW5mb3JtYXRpb24uaW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzW2ltcG9ydC5r aW5kSW5kZXhdOworICAgICAgICAgICAgICAgIGlmIChpbXBvcnRlZFNpZ25hdHVyZUluZGV4ICE9 IGV4cGVjdGVkU2lnbmF0dXJlSW5kZXgpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBKU1Zh bHVlOjplbmNvZGUodGhyb3dFeGNlcHRpb24oZXhlYywgdGhyb3dTY29wZSwgY3JlYXRlSlNXZWJB c3NlbWJseUxpbmtFcnJvcihleGVjLCAmdm0sIEFTQ0lJTGl0ZXJhbCgiaW1wb3J0ZWQgZnVuY3Rp b24ncyBzaWduYXR1cmUgbWlzbWF0Y2hlcyB0aGUgcHJvdmlkZWQgV2ViQXNzZW1ibHkgZnVuY3Rp b24ncyBzaWduYXR1cmUiKSkpKTsKICAgICAgICAgICAgICAgICAvLyBiLiBMZXQgY2xvc3VyZSBi ZSB2LltbQ2xvc3VyZV1dLgotICAgICAgICAgICAgICAgIFJFTEVBU0VfQVNTRVJUX05PVF9SRUFD SEVEKCk7Ci0gICAgICAgICAgICAgICAgVU5VU0VEX1BBUkFNKGltcG9ydGVkRXhwb3J0cyk7Ci0g ICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgICB9CiAgICAgICAgICAgICAvLyBpaWku IE90aGVyd2lzZToKICAgICAgICAgICAgIC8vIGEuIExldCBjbG9zdXJlIGJlIGEgbmV3IGhvc3Qg ZnVuY3Rpb24gb2YgdGhlIGdpdmVuIHNpZ25hdHVyZSB3aGljaCBjYWxscyB2IGJ5IGNvZXJjaW5n IFdlYkFzc2VtYmx5IGFyZ3VtZW50cyB0byBKYXZhU2NyaXB0IGFyZ3VtZW50cyB2aWEgVG9KU1Zh bHVlIGFuZCByZXR1cm5zIHRoZSByZXN1bHQsIGlmIGFueSwgYnkgY29lcmNpbmcgdmlhIFRvV2Vi QXNzZW1ibHlWYWx1ZS4KICAgICAgICAgICAgIC8vIE5vdGU6IGRvbmUgYXMgcGFydCBvZiBQbGFu IGNvbXBpbGF0aW9uLgogICAgICAgICAgICAgLy8gaXYuIEFwcGVuZCB2IHRvIGZ1bmNzLgorICAg ICAgICAgICAgLy8gTm90ZTogYWRkaW5nIHRoZSBKU0NlbGwgdG8gdGhlIGluc3RhbmNlIGxpc3Qg ZnVsZmlsbHMgY2xvc3VyZSByZXF1aXJlbWVudHMgYi4gYWJvdmUgKHRoZSBXZWJBc3NlbWJseS5J bnN0YW5jZSB3aWwgYmUga2VwdCBhbGl2ZSkgYW5kIHYuIGJlbG93ICh0aGUgSlNGdW5jdGlvbiku CiAgICAgICAgICAgICBpbnN0YW5jZS0+c2V0SW1wb3J0RnVuY3Rpb24odm0sIGNlbGwsIG51bUlt cG9ydEZ1bmN0aW9ucysrKTsKICAgICAgICAgICAgIC8vIHYuIEFwcGVuZCBjbG9zdXJlIHRvIGlt cG9ydHMuCiAgICAgICAgICAgICBicmVhazsKLS0gCjIuMTAuMQoK 297773 2016-12-26 14:20:33 -0800 2016-12-26 17:54:57 -0800 WIP 0001-wasm-wasm.patch text/plain 103397 jfbastien RnJvbSBkMTk2ZDI1Njk2OTMzOTIxN2FiN2QyYjAwNzc3Y2VkOTQ4NTQ4MmY1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBXZWQsIDIxIERlYyAyMDE2IDE1OjU5OjU2IC0wODAwClN1YmplY3Q6IFtQQVRDSF0gd2FzbS0+ d2FzbQoKQ2hhbmdlcyB0byB0aGUgV2ViQXNzZW1ibHkgaW1wbGVtZW50YXRpb246CgogIC0gQWRk IGEgbmV3IEpTVHlwZSBmb3IgV2ViQXNzZW1ibHlGdW5jdGlvbiwgYW5kIHVzZSBpdCB3aGVuIGNy ZWF0aW5nIGl0cwogICAgc3RydWN0dXJlLiBUaGlzIHdpbGwgYmUgdXNlZCB0byBxdWlja2x5IGRl dGVjdCBmcm9tIHdhc20gd2hldGhlciB0aGUgaW1wb3J0CiAgICBjYWxsIGlzIHRvIGFub3RoZXIg d2FzbSBtb2R1bGUsIG9yIHdoZXRoZXIgaXQncyB0byBKUy4KICAtIFVzZSBjZWxsIGluc3RlYWQg b2Ygb2JqZWN0cyB0byBkZXRlY3Qgd2FzbS0+d2FzbSwgdGhlIHByZXZpb3VzIGNvZGUgd2FzIHdy b25nLgogIC0gSW1wcm92ZSBkaWFnbm9zdGljIHByaW50b3V0IGZvciB3YXNtIHN0dWJzOiBwcmlu dCB0aGUgZnVsbCBzaWduYXR1cmUuCiAgLSBQcm9wZXJseSBjaGVjayB0aGF0IHdhc20gLT4gd2Fz bSBjYWxscyBoYXZlIG1hdGNoaW5nIHNpZ25hdHVyZXMuIEFkZCB0ZXN0aW5nIGZvciB0aGlzLgog IC0gVGVzdCBzb21lIG9mIHRoZSB3YXNtIC0+IHdhc20gY2FsbHMsIG5vdCB3b3JraW5nIHlldCwg YW5kIG1vcmUgdGVzdHMgbmVlZCB0bwogICAgZ2V0IGltcGxlbWVudGVkLgogIC0gR2VuZXJhdGUg dHdvIHN0dWJzIGZyb20gdGhlIGltcG9ydCBzdHViIGdlbmVyYXRvcjogb25lIGZvciB3YXNtLT5K UyBhbmQgb25lCiAgICBmb3Igd2FzbSAtPiB3YXNtLiBUaGlzIGlzIGRvbmUgYXQgTW9kdWxlIHRp bWUuIFdoaWNoIGlzIGNhbGxlZCB3aWxsIG9ubHkgYmUKICAgIGtub3duIGF0IEluc3RhbmNlIHRp bWUsIG9uY2Ugd2UndmUgcmVjZWl2ZWQgdGhlIGltcG9ydCBvYmplY3QuIFdlIHdhbnQgdG8KICAg IGF2b2lkIGNvZGVnZW4gYXQgSW5zdGFuY2UgdGltZSwgc28gaGF2aW5nIGJvdGggYXJvdW5kIGlz IGdyZWF0LgogIC0gUmVzdG9yZSB0aGUgV2ViQXNzZW1ibHkgZ2xvYmFsIHN0YXRlIChWTSB0b3Ag SW5zdGFuY2UsIGFuZCBwaW5uZWQgcmVnaXN0ZXJzKQogICAgYWZ0ZXIgY2FsbCAvIGNhbGxfaW5k aXJlY3QsIGFuZCBpbiB0aGUgSlMtPndhc20gZW50cnkgc3R1Yi4KClN1cHBvcnQgY2hhbmdlczoK CiAgLSBBZGQgYSBQcm94eSB0byBCdWlsZGVyLmpzLCB3aGljaCBpbnRlcmNlcHRzIHVua25vd24g cHJvcGVydHkgbG9va3Vwcy4gVGhpcwogICAgY3JlYXRlcyB3YXkgYmV0dGVyIGVycm9yIG1lc3Nh Z2VzIG9uIHR5cG9zIHRoYW4gJ3VuZGVmaW5lZCBpcyBub3QgYQogICAgZnVuY3Rpb24nLCB3aGlj aCBoYXBwZW5zIHNlbWktZnJlcXVlbnRseSBhcyBJIHR5cG8gb3Bjb2RlIG5hbWVzIChhbmQgd2hp Y2gKICAgIG9uZSBpcyBhIHR5cG8gaXMgaGFyZCB0byBmaW5kIGJlY2F1c2Ugd2UgY2hhaW4gYnVp bGRlcnMpLgogIC0gQWRkIGxpbWl0ZWQgc3VwcG9ydCBmb3IgdmFye3V9aW50NjQgKG9ubHkgdGhl IDMyLWJpdCB2YWx1ZXMpLgogIC0gR2V0IHJpZCBvZiBtdWNoIG9mIHRoZSBmdW5jdGlvbiBpbmRl eCBzcGFjZTogd2UgYWxyZWFkeSBoYXZlIGFsbCBvZiBpdHMKICAgIGluZm9ybWF0aW9uIGVsc2V3 aGVyZSwgYW5kIGFzLWlzIGl0IHByb3ZpZGVzIG5vIGV4dHJhIGVmZmljaWVuY3kuCiAgLSBTdG9y ZSBXYXNtOjpNZW1vcnkgZGlyZWN0bHkgb24gSlNXZWJBc3NlbWJseU1lbW9yeSwgaW5zdGVhZCBv ZiB0aHJvdWdoIGEKICAgIHVuaXF1ZV9wdHIuIFRoaXMgcmVtb3ZlcyBhbiBpbmRpcmVjdGlvbiBh bmQgdXNlbGVzcyBhbGxvY2F0aW9uLgogIC0gUmVtb3ZlIFZNJ2EgV2ViQXNzZW1ibHkgbWVtb3J5 IC8gc2l6ZSwgYW5kIG9idGFpbiB0aGVtIGZyb20gSW5zdGFuY2UKICAgIGluc3RlYWQuIFRoaXMg cmVxdWlyZXMgYW4gZXh0cmEgaW5kaXJlY3Rpb24sIGJ1dCBpcyBjbGVhbmVyLgotLS0KIEpTVGVz dHMvd2FzbS9CdWlsZGVyLmpzICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDkxICsrKysr KystLS0tLS0KIEpTVGVzdHMvd2FzbS9Mb3dMZXZlbEJpbmFyeS5qcyAgICAgICAgICAgICAgICAg ICAgIHwgIDEyICsrCiBKU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvZXhjZXB0aW9ucy5qcyAg ICAgICAgICB8ICAgNiArLQogSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtbG9hZC5q cyAgICAgICAgICAgfCAgIDIgKy0KIEpTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLXN0 b3JlLmpzICAgICAgICAgIHwgICAyICstCiBKU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2Fz bS1iYWQtc2lnbmF0dXJlLmpzICB8IDEwNSArKysrKysrKysrKysrKwogSlNUZXN0cy93YXNtL2pz LWFwaS93YXNtLXRvLXdhc20uanMgICAgICAgICAgICAgICAgfCAgNzMgKysrKysrKysrKwogU291 cmNlL0phdmFTY3JpcHRDb3JlL2pzYy5jcHAgICAgICAgICAgICAgICAgICAgICAgfCAgMzEgKysr LS0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTVHlwZS5oICAgICAgICAgICAgIHwg ICAyICsKIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZNLmggICAgICAgICAgICAgICAg IHwgICAyIC0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNw cCAgIHwgMTUxICsrKysrKysrKysrKysrKy0tLS0tLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbUIzSVJHZW5lcmF0b3IuaCAgICAgfCAgIDIgKy0KIFNvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL1dhc21CaW5kaW5nLmNwcCAgICAgICAgIHwgIDE4ICsrLQogU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuaCAgICAgICAgICAgfCAgIDIgKy0KIFNvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21Gb3JtYXQuaCAgICAgICAgICAgIHwgIDI2ICsrLS0KIFNvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21GdW5jdGlvblBhcnNlci5oICAgIHwgIDE0ICstCiBT b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmNwcCAgICAgICAgICB8ICAgNCAr LQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5oICAgICAgICAgICAgfCAg IDggKy0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwICAg IHwgIDI0ICsrLS0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIu aCAgICAgIHwgICAxIC0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmNwcCAg ICAgICAgICAgIHwgIDM3ICsrLS0tCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxh bi5oICAgICAgICAgICAgICB8ICAxMyArLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bVNpZ25hdHVyZS5jcHAgICAgICAgfCAgMTMgKysKIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21TaWduYXR1cmUuaCAgICAgICAgIHwgICAxICsKIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21WYWxpZGF0ZS5jcHAgICAgICAgIHwgICA0ICstCiBTb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtVmFsaWRhdGUuaCAgICAgICAgICB8ICAgMiArLQogLi4uL0phdmFTY3JpcHRD b3JlL3dhc20vanMvSlNXZWJBc3NlbWJseUluc3RhbmNlLmggfCAgIDggKy0KIC4uLi9KYXZhU2Ny aXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuY3BwIHwgICA4ICstCiAuLi4vSmF2 YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmggICB8ICAxMSArLQogLi4u L0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5jcHAgfCAgIDkgKy0K IC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUuaCAgIHwgIDE2 ICstLQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlvbi5jcHAg fCAgMTIgKy0KIC4uLi93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VDb25zdHJ1Y3Rvci5jcHAg ICAgIHwgIDE3ICstLQogLi4uL3dhc20vanMvV2ViQXNzZW1ibHlNZW1vcnlDb25zdHJ1Y3Rvci5j cHAgICAgICAgfCAgIDQgKy0KIC4uLi93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlQ29uc3RydWN0 b3IuY3BwICAgICAgIHwgICAyICstCiAuLi4vd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZVJlY29y ZC5jcHAgICAgICAgICAgICB8ICAgNiArLQogMzYgZmlsZXMgY2hhbmdlZCwgNTIwIGluc2VydGlv bnMoKyksIDIxOSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBKU1Rlc3RzL3dhc20v anMtYXBpL3dhc20tdG8td2FzbS1iYWQtc2lnbmF0dXJlLmpzCiBjcmVhdGUgbW9kZSAxMDA2NDQg SlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMKCmRpZmYgLS1naXQgYS9KU1Rlc3Rz L3dhc20vQnVpbGRlci5qcyBiL0pTVGVzdHMvd2FzbS9CdWlsZGVyLmpzCmluZGV4IGRhNTg0YzQu LjI2YmE2NmUgMTAwNjQ0Ci0tLSBhL0pTVGVzdHMvd2FzbS9CdWlsZGVyLmpzCisrKyBiL0pTVGVz dHMvd2FzbS9CdWlsZGVyLmpzCkBAIC0zOCw3ICszOCw3IEBAIGNvbnN0IF9pc1ZhbGlkVmFsdWUg PSAodmFsdWUsIHR5cGUpID0+IHsKICAgICBzd2l0Y2ggKHR5cGUpIHsKICAgICAvLyBXZSBhbGxv dyBib3RoIHNpZ25lZCBhbmQgdW5zaWduZWQgbnVtYmVycy4KICAgICBjYXNlICJpMzIiOiByZXR1 cm4gTWF0aC5yb3VuZCh2YWx1ZSkgPT09IHZhbHVlICYmIExMQi52YXJpbnQzMk1pbiA8PSB2YWx1 ZSAmJiB2YWx1ZSA8PSBMTEIudmFydWludDMyTWF4OwotICAgIGNhc2UgImk2NCI6IHRocm93IG5l dyBFcnJvcihgVW5pbXBsZW1lbnRlZDogdmFsdWUgY2hlY2sgZm9yICR7dHlwZX1gKTsgLy8gRklY TUUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MzQyMCA2NC1iaXQg dmFsdWVzCisgICAgY2FzZSAiaTY0IjogcmV0dXJuIHRydWU7IC8vIEZJWE1FIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjM0MjAgNjQtYml0IHZhbHVlcwogICAgIGNh c2UgImYzMiI6IHJldHVybiB0eXBlb2YodmFsdWUpID09PSAibnVtYmVyIiAmJiBpc0Zpbml0ZSh2 YWx1ZSk7CiAgICAgY2FzZSAiZjY0IjogcmV0dXJuIHR5cGVvZih2YWx1ZSkgPT09ICJudW1iZXIi ICYmIGlzRmluaXRlKHZhbHVlKTsKICAgICBkZWZhdWx0OiB0aHJvdyBuZXcgRXJyb3IoYEltcGxl bWVudGF0aW9uIHByb2JsZW06IHVua25vd24gdHlwZSAke3R5cGV9YCk7CkBAIC01Nyw2ICs1Nywx NiBAQCBjb25zdCBfbm9ybWFsaXplRnVuY3Rpb25TaWduYXR1cmUgPSAocGFyYW1zLCByZXQpID0+ IHsKICAgICByZXR1cm4gW3BhcmFtcywgcmV0XTsKIH07CiAKK2NvbnN0IF9lcnJvckhhbmRsaW5n UHJveHlGb3IgPSBidWlsZGVyID0+IGJ1aWxkZXJbIl9faXNQcm94eSJdID8gYnVpbGRlciA6IG5l dyBQcm94eShidWlsZGVyLCB7CisgICAgZ2V0OiAodGFyZ2V0LCBwcm9wZXJ0eSwgcmVjZWl2ZXIp ID0+IHsKKyAgICAgICAgaWYgKHByb3BlcnR5ID09PSAiX19pc1Byb3h5IikKKyAgICAgICAgICAg IHJldHVybiB0cnVlOworICAgICAgICBpZiAodGFyZ2V0W3Byb3BlcnR5XSA9PT0gdW5kZWZpbmVk KQorICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBXZWJBc3NlbWJseSBidWlsZGVyIHJlY2Vp dmVkIHVua25vd24gcHJvcGVydHkgJyR7cHJvcGVydHl9J2ApOworICAgICAgICByZXR1cm4gdGFy Z2V0W3Byb3BlcnR5XTsKKyAgICB9Cit9KTsKKwogY29uc3QgX21heWJlUmVnaXN0ZXJUeXBlID0g KGJ1aWxkZXIsIHR5cGUpID0+IHsKICAgICBjb25zdCB0eXBlU2VjdGlvbiA9IGJ1aWxkZXIuX2dl dFNlY3Rpb24oIlR5cGUiKTsKICAgICBpZiAodHlwZW9mKHR5cGUpID09PSAibnVtYmVyIikgewpA QCAtMTAwLDcgKzExMCw3IEBAIGNvbnN0IF9pbXBvcnRGdW5jdGlvbkNvbnRpbnVhdGlvbiA9IChi dWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgICAgICBzZWN0aW9uLmRhdGEu cHVzaCh7IGZpZWxkOiBmaWVsZCwgdHlwZTogdHlwZSwga2luZDogIkZ1bmN0aW9uIiwgbW9kdWxl OiBtb2R1bGUgfSk7CiAgICAgICAgIC8vIEltcG9ydHMgYWxzbyBjb3VudCBpbiB0aGUgZnVuY3Rp b24gaW5kZXggc3BhY2UuIE1hcCB0aGVtIGFzIG9iamVjdHMgdG8gYXZvaWQgY2xhc2hpbmcgd2l0 aCBDb2RlIGZ1bmN0aW9ucycgbmFtZXMuCiAgICAgICAgIGJ1aWxkZXIuX3JlZ2lzdGVyRnVuY3Rp b25Ub0luZGV4U3BhY2UoeyBtb2R1bGU6IG1vZHVsZSwgZmllbGQ6IGZpZWxkIH0pOwotICAgICAg ICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5 Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9OwogfTsKIApAQCAtMTA5LDcgKzExOSw3IEBAIGNvbnN0 IF9pbXBvcnRNZW1vcnlDb250aW51YXRpb24gPSAoYnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1aWxk ZXIpID0+IHsKICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKG1vZHVsZSwgYEltcG9ydCBNZW1vcnkg bW9kdWxlIHNob3VsZCBiZSBhIHN0cmluZywgZ290ICIke21vZHVsZX0iYCk7CiAgICAgICAgIGFz c2VydC5pc1N0cmluZyhmaWVsZCwgYEltcG9ydCBNZW1vcnkgZmllbGQgc2hvdWxkIGJlIGEgc3Ry aW5nLCBnb3QgIiR7ZmllbGR9ImApOwogICAgICAgICBzZWN0aW9uLmRhdGEucHVzaCh7bW9kdWxl LCBmaWVsZCwga2luZDogIk1lbW9yeSIsIG1lbW9yeURlc2NyaXB0aW9uOiB7aW5pdGlhbCwgbWF4 aW11bX19KTsKLSAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICByZXR1cm4gX2Vy cm9ySGFuZGxpbmdQcm94eUZvcihuZXh0QnVpbGRlcik7CiAgICAgfTsKIH07CiAKQEAgLTExOCw3 ICsxMjgsNyBAQCBjb25zdCBfaW1wb3J0VGFibGVDb250aW51YXRpb24gPSAoYnVpbGRlciwgc2Vj dGlvbiwgbmV4dEJ1aWxkZXIpID0+IHsKICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKG1vZHVsZSwg YEltcG9ydCBUYWJsZSBtb2R1bGUgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7bW9kdWxlfSJg KTsKICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKGZpZWxkLCBgSW1wb3J0IFRhYmxlIGZpZWxkIHNo b3VsZCBiZSBhIHN0cmluZywgZ290ICIke2ZpZWxkfSJgKTsKICAgICAgICAgc2VjdGlvbi5kYXRh LnB1c2goe21vZHVsZSwgZmllbGQsIGtpbmQ6ICJUYWJsZSIsIHRhYmxlRGVzY3JpcHRpb246IHtp bml0aWFsLCBtYXhpbXVtLCBlbGVtZW50fX0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7 CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAg ICB9OwogfTsKIApAQCAtMTcyLDcgKzE4Miw3IEBAIGNvbnN0IF9leHBvcnRGdW5jdGlvbkNvbnRp bnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgICAgICAg ICAgICAgIGFzc2VydC5lcSh0eXBlLCBleHBvcnRlZEltcG9ydC50eXBlLCBgUmUtZXhwb3J0aW5n IGltcG9ydCAiJHtleHBvcnRlZEltcG9ydC5maWVsZH0iIGFzICIke2ZpZWxkfSIgaGFzIG1pc21h dGNoaW5nIHR5cGVgKTsKICAgICAgICAgfQogICAgICAgICBzZWN0aW9uLmRhdGEucHVzaCh7IGZp ZWxkOiBmaWVsZCwgdHlwZTogdHlwZSwga2luZDogIkZ1bmN0aW9uIiwgaW5kZXg6IGluZGV4IH0p OwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5k bGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9OwogfTsKIApAQCAtMTg5LDcgKzE5OSw3 IEBAIGNvbnN0IF9leHBvcnRHbG9iYWxDb250aW51YXRpb24gPSAoYnVpbGRlciwgc2VjdGlvbiwg bmV4dEJ1aWxkZXIpID0+IHsKICAgICByZXR1cm4gKGZpZWxkLCBpbmRleCkgPT4gewogICAgICAg ICBhc3NlcnQuaXNOdW1iZXIoaW5kZXgsIGBHbG9iYWwgZXhwb3J0cyBvbmx5IHN1cHBvcnQgbnVt YmVyIGluZGljZXMgcmlnaHQgbm93YCk7CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHsgZmll bGQsIGtpbmQ6ICJHbG9iYWwiLCBpbmRleCB9KTsKLSAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVy OworICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihuZXh0QnVpbGRlcik7CiAg ICAgfQogfTsKIApAQCAtMTk3LDcgKzIwNyw3IEBAIGNvbnN0IF9leHBvcnRNZW1vcnlDb250aW51 YXRpb24gPSAoYnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1aWxkZXIpID0+IHsKICAgICByZXR1cm4g KGZpZWxkLCBpbmRleCkgPT4gewogICAgICAgICBhc3NlcnQuaXNOdW1iZXIoaW5kZXgsIGBNZW1v cnkgZXhwb3J0cyBvbmx5IHN1cHBvcnQgbnVtYmVyIGluZGljZXNgKTsKICAgICAgICAgc2VjdGlv bi5kYXRhLnB1c2goe2ZpZWxkLCBraW5kOiAiTWVtb3J5IiwgaW5kZXh9KTsKLSAgICAgICAgcmV0 dXJuIG5leHRCdWlsZGVyOworICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihu ZXh0QnVpbGRlcik7CiAgICAgfQogfTsKIApAQCAtMjA1LDcgKzIxNSw3IEBAIGNvbnN0IF9leHBv cnRUYWJsZUNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4g ewogICAgIHJldHVybiAoZmllbGQsIGluZGV4KSA9PiB7CiAgICAgICAgIGFzc2VydC5pc051bWJl cihpbmRleCwgYFRhYmxlIGV4cG9ydHMgb25seSBzdXBwb3J0IG51bWJlciBpbmRpY2VzYCk7CiAg ICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHtmaWVsZCwga2luZDogIlRhYmxlIiwgaW5kZXh9KTsK LSAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxp bmdQcm94eUZvcihuZXh0QnVpbGRlcik7CiAgICAgfQogfTsKIApAQCAtMjIwLDEwICsyMzAsMTAg QEAgY29uc3QgX2ltcG9ydEdsb2JhbENvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBu ZXh0QnVpbGRlcikgPT4gewogICAgICAgICAgICAgICAgIGFzc2VydC5pc1N0cmluZyhmaWVsZCwg YEltcG9ydCBnbG9iYWwgZmllbGQgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7ZmllbGR9ImAp OwogICAgICAgICAgICAgICAgIGFzc2VydC5pc1N0cmluZyhtdXRhYmlsaXR5LCBgSW1wb3J0IGds b2JhbCBtdXRhYmlsaXR5IHNob3VsZCBiZSBhIHN0cmluZywgZ290ICIke211dGFiaWxpdHl9ImAp OwogICAgICAgICAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHsgZ2xvYmFsRGVzY3JpcHRpb246 IHsgdHlwZTogb3AsIG11dGFiaWxpdHk6IF9ub3JtYWxpemVNdXRhYmlsaXR5KG11dGFiaWxpdHkp IH0sIG1vZHVsZSwgZmllbGQsIGtpbmQ6ICJHbG9iYWwiIH0pOwotICAgICAgICAgICAgICAgIHJl dHVybiBnbG9iYWxCdWlsZGVyOworICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGlu Z1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwogICAgICAgICAgICAgfTsKICAgICAgICAgfQotICAg ICAgICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5n UHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7CiAgICAgfTsKIH07CiAKQEAgLTMyNCwxMSArMzM0LDEx IEBAIGNvbnN0IF9jcmVhdGVGdW5jdGlvbkJ1aWxkZXIgPSAoZnVuYywgYnVpbGRlciwgcHJldmlv dXNCdWlsZGVyKSA9PiB7CiAgICAgICAgICAgICBkZWZhdWx0OgogICAgICAgICAgICAgICAgIG5l eHRCdWlsZGVyID0gZnVuY3Rpb25CdWlsZGVyOwogICAgICAgICAgICAgICAgIGJyZWFrOwotICAg ICAgICAgICAgICAgIGNhc2UgIkVuZCI6CisgICAgICAgICAgICBjYXNlICJFbmQiOgogICAgICAg ICAgICAgICAgIG5leHRCdWlsZGVyID0gcHJldmlvdXNCdWlsZGVyOwotICAgICAgICAgICAgICAg ICAgICBicmVhazsKKyAgICAgICAgICAgICAgICBicmVhazsKICAgICAgICAgICAgIGNhc2UgIkJs b2NrIjoKLSAgICAgICAgICAgICAgICBjYXNlICJMb29wIjoKKyAgICAgICAgICAgIGNhc2UgIkxv b3AiOgogICAgICAgICAgICAgY2FzZSAiSWYiOgogICAgICAgICAgICAgICAgIG5leHRCdWlsZGVy ID0gX2NyZWF0ZUZ1bmN0aW9uQnVpbGRlcihmdW5jLCBidWlsZGVyLCBmdW5jdGlvbkJ1aWxkZXIp OwogICAgICAgICAgICAgICAgIGJyZWFrOwpAQCAtMzQ0LDExICszNTQsMTIgQEAgY29uc3QgX2Ny ZWF0ZUZ1bmN0aW9uQnVpbGRlciA9IChmdW5jLCBidWlsZGVyLCBwcmV2aW91c0J1aWxkZXIpID0+ IHsKICAgICAgICAgICAgIGNvbnN0IHN0YWNrQXJncyA9IFtdOyAvLyBGSVhNRSBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYyNzA2CiAgICAgICAgICAgICBmdW5jLmNv ZGUucHVzaCh7IG5hbWU6IG9wLCB2YWx1ZTogdmFsdWUsIGFyZ3VtZW50czogc3RhY2tBcmdzLCBp bW1lZGlhdGVzOiBpbW1zIH0pOwogICAgICAgICAgICAgaWYgKGhhc0NvbnRpbnVhdGlvbikKLSAg ICAgICAgICAgICAgICByZXR1cm4gY29udGludWF0aW9uKG5leHRCdWlsZGVyKS5FbmQoKTsKLSAg ICAgICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgICAgICAgICByZXR1cm4gX2Vy cm9ySGFuZGxpbmdQcm94eUZvcihjb250aW51YXRpb24obmV4dEJ1aWxkZXIpLkVuZCgpKTsKKyAg ICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAg ICAgICAgfTsKLSAgICB9Ci0gICAgcmV0dXJuIGZ1bmN0aW9uQnVpbGRlcjsKKyAgICB9OworCisg ICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZnVuY3Rpb25CdWlsZGVyKTsKIH0KIAog Y29uc3QgX2NyZWF0ZUZ1bmN0aW9uID0gKHNlY3Rpb24sIGJ1aWxkZXIsIHByZXZpb3VzQnVpbGRl cikgPT4gewpAQCAtNDQ5LDEwICs0NjAsMTAgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRl ciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBGdW5jOiAocGFyYW1zLCByZXQpID0+IHsKICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBbcGFyYW1zLCByZXRdID0gX25vcm1hbGl6ZUZ1bmN0 aW9uU2lnbmF0dXJlKHBhcmFtcywgcmV0KTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBz LmRhdGEucHVzaCh7IHBhcmFtczogcGFyYW1zLCByZXQ6IHJldCB9KTsKLSAgICAgICAgICAgICAg ICAgICAgICAgICAgICByZXR1cm4gdHlwZUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IodHlwZUJ1aWxkZXIpOwogICAgICAg ICAgICAgICAgICAgICAgICAgfSwKICAgICAgICAgICAgICAgICAgICAgfTsKLSAgICAgICAgICAg ICAgICAgICAgcmV0dXJuIHR5cGVCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4g X2Vycm9ySGFuZGxpbmdQcm94eUZvcih0eXBlQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsK ICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNDY2LDcgKzQ3Nyw3IEBAIGV4cG9ydCBkZWZh dWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICBpbXBvcnRCdWlsZGVyLkZ1 bmN0aW9uID0gX2ltcG9ydEZ1bmN0aW9uQ29udGludWF0aW9uKHRoaXMsIHMsIGltcG9ydEJ1aWxk ZXIpOwogICAgICAgICAgICAgICAgICAgICBpbXBvcnRCdWlsZGVyLk1lbW9yeSA9IF9pbXBvcnRN ZW1vcnlDb250aW51YXRpb24odGhpcywgcywgaW1wb3J0QnVpbGRlcik7CiAgICAgICAgICAgICAg ICAgICAgIGltcG9ydEJ1aWxkZXIuVGFibGUgPSBfaW1wb3J0VGFibGVDb250aW51YXRpb24odGhp cywgcywgaW1wb3J0QnVpbGRlcik7Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiBpbXBvcnRC dWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZv cihpbXBvcnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJy ZWFrOwogCkBAIC00NzcsNyArNDg4LDcgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7 CiAgICAgICAgICAgICAgICAgICAgICAgICBFbmQ6ICgpID0+IHRoaXMKICAgICAgICAgICAgICAg ICAgICAgICAgIC8vIEZJWE1FOiBhZGQgYWJpbGl0eSB0byBhZGQgdGhpcyB3aXRoIHdoYXRldmVy LgogICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gZnVu Y3Rpb25CdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQ cm94eUZvcihmdW5jdGlvbkJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAg ICAgICAgYnJlYWs7CiAKQEAgLTQ4OCwxMCArNDk5LDEwIEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNz IEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRW5kOiAoKSA9PiB0aGlzLAogICAg ICAgICAgICAgICAgICAgICAgICAgVGFibGU6ICh7aW5pdGlhbCwgbWF4aW11bSwgZWxlbWVudH0p ID0+IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaCh7dGFibGVEZXNj cmlwdGlvbjoge2luaXRpYWwsIG1heGltdW0sIGVsZW1lbnR9fSk7Ci0gICAgICAgICAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIHRhYmxlQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih0YWJsZUJ1aWxkZXIpOwogICAgICAg ICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAgICAg ICAgICAgICByZXR1cm4gdGFibGVCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4g X2Vycm9ySGFuZGxpbmdQcm94eUZvcih0YWJsZUJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07 CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTUwMiwxMCArNTEzLDEwIEBAIGV4cG9ydCBk ZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRW5kOiAoKSA9 PiB0aGlzLAogICAgICAgICAgICAgICAgICAgICAgICAgSW5pdGlhbE1heFBhZ2VzOiAoaW5pdGlh bCwgbWF4KSA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcy5kYXRhLnB1c2goeyBp bml0aWFsLCBtYXggfSk7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIG1lbW9y eUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRs aW5nUHJveHlGb3IobWVtb3J5QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICB9CiAg ICAgICAgICAgICAgICAgICAgIH07Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiBtZW1vcnlC dWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZv cihtZW1vcnlCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJy ZWFrOwogCkBAIC01MTYsMTYgKzUyNywxNiBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVy IHsKICAgICAgICAgICAgICAgICAgICAgICAgIEVuZDogKCkgPT4gdGhpcywKICAgICAgICAgICAg ICAgICAgICAgICAgIEdldEdsb2JhbDogKHR5cGUsIGluaXRWYWx1ZSwgbXV0YWJpbGl0eSkgPT4g ewogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKHsgdHlwZSwgb3A6ICJn ZXRfZ2xvYmFsIiwgbXV0YWJpbGl0eTogX25vcm1hbGl6ZU11dGFiaWxpdHkobXV0YWJpbGl0eSks IGluaXRWYWx1ZSB9KTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gZ2xvYmFs QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxp bmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAg ICAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICAgICAgZm9yIChsZXQgb3Agb2Yg V0FTTS5kZXNjcmlwdGlvbi52YWx1ZV90eXBlKSB7CiAgICAgICAgICAgICAgICAgICAgICAgICBn bG9iYWxCdWlsZGVyW190b0phdmFTY3JpcHROYW1lKG9wKV0gPSAoaW5pdFZhbHVlLCBtdXRhYmls aXR5KSA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcy5kYXRhLnB1c2goeyB0eXBl OiBvcCwgb3A6IG9wICsgIi5jb25zdCIsIG11dGFiaWxpdHk6IF9ub3JtYWxpemVNdXRhYmlsaXR5 KG11dGFiaWxpdHkpLCBpbml0VmFsdWUgfSk7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAg cmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJu IF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7CiAgICAgICAgICAgICAgICAg ICAgICAgICB9OwogICAgICAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgICAgIHJl dHVybiBnbG9iYWxCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFu ZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAg ICAgICAgICAgIGJyZWFrOwogCkBAIC01MzksNyArNTUwLDcgQEAgZXhwb3J0IGRlZmF1bHQgY2xh c3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgIGV4cG9ydEJ1aWxkZXIuRnVuY3Rpb24g PSBfZXhwb3J0RnVuY3Rpb25Db250aW51YXRpb24odGhpcywgcywgZXhwb3J0QnVpbGRlcik7CiAg ICAgICAgICAgICAgICAgICAgIGV4cG9ydEJ1aWxkZXIuTWVtb3J5ID0gX2V4cG9ydE1lbW9yeUNv bnRpbnVhdGlvbih0aGlzLCBzLCBleHBvcnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAg ZXhwb3J0QnVpbGRlci5UYWJsZSA9IF9leHBvcnRUYWJsZUNvbnRpbnVhdGlvbih0aGlzLCBzLCBl eHBvcnRCdWlsZGVyKTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGV4cG9ydEJ1aWxkZXI7 CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGV4cG9y dEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAK QEAgLTU1Miw3ICs1NjMsNyBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAg ICAgICAgICAgICAgICAgaWYgKHR5cGVvZihmdW5jdGlvbkluZGV4T3JOYW1lKSAhPT0gIm51bWJl ciIgJiYgdHlwZW9mKGZ1bmN0aW9uSW5kZXhPck5hbWUpICE9PSAic3RyaW5nIikKICAgICAgICAg ICAgICAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcihgU3RhcnQgc2VjdGlvbidzIGZ1bmN0aW9u IGluZGV4ICBtdXN0IGVpdGhlciBiZSBhIG51bWJlciBvciBhIHN0cmluZ2ApOwogICAgICAgICAg ICAgICAgICAgICBzLmRhdGEucHVzaChmdW5jdGlvbkluZGV4T3JOYW1lKTsKLSAgICAgICAgICAg ICAgICAgICAgcmV0dXJuIHN0YXJ0QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJu IF9lcnJvckhhbmRsaW5nUHJveHlGb3Ioc3RhcnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9 OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC01NjMsMTEgKzU3NCwxMSBAQCBleHBvcnQg ZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgIEVuZDogKCkg PT4gdGhpcywKICAgICAgICAgICAgICAgICAgICAgICAgIEVsZW1lbnQ6ICh7dGFibGVJbmRleCA9 IDAsIG9mZnNldCwgZnVuY3Rpb25JbmRpY2VzfSkgPT4gewogICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHMuZGF0YS5wdXNoKHt0YWJsZUluZGV4LCBvZmZzZXQsIGZ1bmN0aW9uSW5kaWNlc30p OwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBlbGVtZW50QnVpbGRlcjsKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihl bGVtZW50QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAg ICAgICAgIH07CiAKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGVsZW1lbnRCdWlsZGVyOwor ICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihlbGVtZW50 QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApA QCAtNjMyLDEyICs2NDMsMTIgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyBGSVhNRSBpbiBjaGVja2VkIG1vZGUs IHRlc3QgdGhhdCB0aGUgdHlwZSBpcyBhY2NlcHRhYmxlIGZvciBzdGFydCBmdW5jdGlvbi4gV2Ug cHJvYmFibHkgd2FudCBfcmVnaXN0ZXJGdW5jdGlvblRvSW5kZXhTcGFjZSB0byBhbHNvIHJlZ2lz dGVyIHR5cGVzIHBlciBpbmRleC4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTE2NTY1OAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBi dWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGlu Z1Byb3h5Rm9yKGJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAgICAgfSwKIAogICAgICAg ICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgICAgICBjb2RlQnVpbGRlci5GdW5jdGlv biA9IF9jcmVhdGVGdW5jdGlvbihzLCBidWlsZGVyLCBjb2RlQnVpbGRlcik7Ci0gICAgICAgICAg ICAgICAgICAgIHJldHVybiBjb2RlQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJu IF9lcnJvckhhbmRsaW5nUHJveHlGb3IoY29kZUJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07 CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTY2MCwxOSArNjcxLDE5IEBAIGV4cG9ydCBk ZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBJ bmRleDogaW5kZXggPT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYXNz ZXJ0LmVxKGluZGV4LCAwKTsgLy8gTGluZWFyIG1lbW9yeSBpbmRleCBtdXN0IGJlIHplcm8gaW4g TVZQLgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGhpc1NlZ21lbnQuaW5k ZXggPSBpbmRleDsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBz ZWdtZW50QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVy biBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHNlZ21lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgfSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgT2Zm c2V0OiBvZmZzZXQgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8g RklYTUUgYWxsb3cgY29tcGxleCBpbml0X2V4cHIgaGVyZS4gaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTE2NTcwMAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgYXNzZXJ0LmlzTnVtYmVyKG9mZnNldCk7CiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB0aGlzU2VnbWVudC5vZmZzZXQgPSBvZmZzZXQ7Ci0gICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICByZXR1cm4gc2VnbWVudEJ1aWxkZXI7CisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihzZWdt ZW50QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0sCiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgfTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1 cm4gc2VnbWVudEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9l cnJvckhhbmRsaW5nUHJveHlGb3Ioc2VnbWVudEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAg ICAgICAgfSwKICAgICAgICAgICAgICAgICAgICAgfTsKLSAgICAgICAgICAgICAgICAgICAgcmV0 dXJuIGRhdGFCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxp bmdQcm94eUZvcihkYXRhQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAg ICAgICBicmVhazsKIApAQCAtNjkwLDEwICs3MDEsMTAgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3Mg QnVpbGRlciB7CiAgICAgICAgICAgICAgICAgQnl0ZTogYiA9PiB7CiAgICAgICAgICAgICAgICAg ICAgIGFzc2VydC5lcShiICYgMHhGRiwgYiwgYFVua25vd24gc2VjdGlvbiBleHBlY3RlZCBieXRl LCBnb3Q6ICIke2J9ImApOwogICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaChiKTsKLSAg ICAgICAgICAgICAgICAgICAgcmV0dXJuIHVua25vd25CdWlsZGVyOworICAgICAgICAgICAgICAg ICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih1bmtub3duQnVpbGRlcik7CiAgICAg ICAgICAgICAgICAgfQogICAgICAgICAgICAgfTsKLSAgICAgICAgICAgIHJldHVybiB1bmtub3du QnVpbGRlcjsKKyAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHVua25v d25CdWlsZGVyKTsKICAgICAgICAgfTsKICAgICB9CiAgICAgX2FkZFNlY3Rpb24obmFtZU9yTnVt YmVyLCBleHRyYU9iamVjdCkgewpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL0xvd0xldmVsQmlu YXJ5LmpzIGIvSlNUZXN0cy93YXNtL0xvd0xldmVsQmluYXJ5LmpzCmluZGV4IDYxMWEyNmQuLmY5 YmM4YTMgMTAwNjQ0Ci0tLSBhL0pTVGVzdHMvd2FzbS9Mb3dMZXZlbEJpbmFyeS5qcworKysgYi9K U1Rlc3RzL3dhc20vTG93TGV2ZWxCaW5hcnkuanMKQEAgLTE3MCw2ICsxNzAsMTggQEAgZXhwb3J0 IGRlZmF1bHQgY2xhc3MgTG93TGV2ZWxCaW5hcnkgewogICAgICAgICAgICAgdGhpcy51aW50OCgw eDgwIHwgYik7CiAgICAgICAgIH0gd2hpbGUgKHRydWUpOwogICAgIH0KKyAgICB2YXJ1aW50NjQo dikgeworICAgICAgICBhc3NlcnQuaXNOdW1iZXIodik7CisgICAgICAgIGlmICh2IDwgdmFydWlu dDMyTWluIHx8IHZhcnVpbnQzMk1heCA8IHYpCisgICAgICAgICAgICB0aHJvdyBuZXcgUmFuZ2VF cnJvcihgdW5pbXBsZW1lbnRlZDogdmFydWludDY0IGxhcmdlciB0aGFuIDMyLWJpdGApOworICAg ICAgICB0aGlzLnZhcnVpbnQzMih2KTsgLy8gRklYTUUgaW1wbGVtZW50IDY0LWJpdCB2YXJ7dX1p bnQgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MzQyMAorICAgIH0K KyAgICB2YXJpbnQ2NCh2KSB7CisgICAgICAgIGFzc2VydC5pc051bWJlcih2KTsKKyAgICAgICAg aWYgKHYgPCB2YXJpbnQzMk1pbiB8fCB2YXJpbnQzMk1heCA8IHYpCisgICAgICAgICAgICB0aHJv dyBuZXcgUmFuZ2VFcnJvcihgdW5pbXBsZW1lbnRlZDogdmFyaW50NjQgbGFyZ2VyIHRoYW4gMzIt Yml0YCk7CisgICAgICAgIHRoaXMudmFyaW50MzIodik7IC8vIEZJWE1FIGltcGxlbWVudCA2NC1i aXQgdmFye3V9aW50IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjM0 MjAKKyAgICB9CiAgICAgdmFydWludDEodikgewogICAgICAgICBpZiAodiAhPT0gMCAmJiB2ICE9 PSAxKQogICAgICAgICAgICAgdGhyb3cgbmV3IFJhbmdlRXJyb3IoYEludmFsaWQgdmFydWludDEg JHt2fSByYW5nZSBpcyBbMCwgMV1gKTsKZGlmZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9mdW5jdGlv bi10ZXN0cy9leGNlcHRpb25zLmpzIGIvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL2V4Y2Vw dGlvbnMuanMKaW5kZXggZDJiM2E0OS4uOTUyNTEzZiAxMDA2NDQKLS0tIGEvSlNUZXN0cy93YXNt L2Z1bmN0aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMKKysrIGIvSlNUZXN0cy93YXNtL2Z1bmN0aW9u LXRlc3RzL2V4Y2VwdGlvbnMuanMKQEAgLTQ1LDE4ICs0NSwxOCBAQCBmdW5jdGlvbiBtYWtlSW5z dGFuY2UoKSB7CiAgICAgYXNzZXJ0LmVxKHRhYmxlLmdldCgwKSwgbnVsbCk7CiAKICAgICBmb3Ig KGxldCBpID0gMDsgaSA8IDEwMDA7IGkrKykgewotICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+ IGZvbygwLCBpKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9yLCAiY2FsbF9pbmRpcmVjdCB0byBh IG51bGwgdGFibGUgZW50cnkgKGV2YWx1YXRpbmcgJ2Z1bmMoLi4uYXJncyknKSIpOworICAgICAg ICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbygwLCBpKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9y LCAiY2FsbF9pbmRpcmVjdCB0byBhIG51bGwgdGFibGUgZW50cnkiKTsKICAgICB9CiAKICAgICB0 YWJsZS5zZXQoMCwgZm9vKTsKICAgICBhc3NlcnQuZXEodGFibGUuZ2V0KDApLCBmb28pOwogCiAg ICAgZm9yIChsZXQgaSA9IDA7IGkgPCAxMDAwOyBpKyspIHsKLSAgICAgICAgYXNzZXJ0LnRocm93 cygoKSA9PiBmb28oMSArIGksIGkpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJPdXQgb2Yg Ym91bmRzIGNhbGxfaW5kaXJlY3QgKGV2YWx1YXRpbmcgJ2Z1bmMoLi4uYXJncyknKSIpOworICAg ICAgICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbygxICsgaSwgaSksIFdlYkFzc2VtYmx5LlJ1bnRp bWVFcnJvciwgIk91dCBvZiBib3VuZHMgY2FsbF9pbmRpcmVjdCIpOwogICAgIH0KIAogICAgIGZv ciAobGV0IGkgPSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0gICAgICAgIGFzc2VydC50aHJvd3MoKCkg PT4gZm9vKDAsIGkpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJjYWxsX2luZGlyZWN0IHRv IGEgc2lnbmF0dXJlIHRoYXQgZG9lcyBub3QgbWF0Y2ggKGV2YWx1YXRpbmcgJ2Z1bmMoLi4uYXJn cyknKSIpOworICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbygwLCBpKSwgV2ViQXNzZW1i bHkuUnVudGltZUVycm9yLCAiY2FsbF9pbmRpcmVjdCB0byBhIHNpZ25hdHVyZSB0aGF0IGRvZXMg bm90IG1hdGNoIik7CiAgICAgfQogCiAgICAgdGFibGUuc2V0KDAsIGJhcik7CmRpZmYgLS1naXQg YS9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpzIGIvSlNUZXN0cy93YXNt L2Z1bmN0aW9uLXRlc3RzL3RyYXAtbG9hZC5qcwppbmRleCA0ZGQ4MmRjLi4xMjMxZTAzIDEwMDY0 NAotLS0gYS9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpzCisrKyBiL0pT VGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMKQEAgLTI5LDYgKzI5LDYgQEAg ZnVuY3Rpb24gd2FzbUZyYW1lQ291bnRGcm9tRXJyb3IoZSkgewogfQogCiBmb3IgKGxldCBpID0g MDsgaSA8IDEwMDA7IGkrKykgewotICAgIGNvbnN0IGUgPSBhc3NlcnQudGhyb3dzKCgpID0+IGZv byhudW1QYWdlcyAqIHBhZ2VTaXplICsgMSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgIk91 dCBvZiBib3VuZHMgbWVtb3J5IGFjY2VzcyAoZXZhbHVhdGluZyAnZnVuYyguLi5hcmdzKScpIik7 CisgICAgY29uc3QgZSA9IGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKG51bVBhZ2VzICogcGFnZVNp emUgKyAxKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9yLCAiT3V0IG9mIGJvdW5kcyBtZW1vcnkg YWNjZXNzIik7CiAgICAgYXNzZXJ0LmVxKHdhc21GcmFtZUNvdW50RnJvbUVycm9yKGUpLCAyKTsK IH0KZGlmZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLXN0b3JlLmpz IGIvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtc3RvcmUuanMKaW5kZXggNTU5ODdj Mi4uMzY1NzEzYSAxMDA2NDQKLS0tIGEvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAt c3RvcmUuanMKKysrIGIvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtc3RvcmUuanMK QEAgLTI1LDUgKzI1LDUgQEAgY29uc3QgbnVtUGFnZXMgPSAxMDsKICAgICBjb25zdCBmb28gPSBu ZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UobW9kdWxlLCB7YToge2I6IG5ldyBXZWJBc3NlbWJseS5N ZW1vcnkoe2luaXRpYWw6IG51bVBhZ2VzfSl9fSkuZXhwb3J0cy5mb287CiAKICAgICBmb3IgKGxl dCBpID0gMDsgaSA8IDEwMDAwOyBpKyspCi0gICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9v KGksIG51bVBhZ2VzICogcGFnZVNpemUgKyAxKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9yLCAi T3V0IG9mIGJvdW5kcyBtZW1vcnkgYWNjZXNzIChldmFsdWF0aW5nICdmdW5jKC4uLmFyZ3MpJyki KTsKKyAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBmb28oaSwgbnVtUGFnZXMgKiBwYWdlU2l6 ZSArIDEpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJPdXQgb2YgYm91bmRzIG1lbW9yeSBh Y2Nlc3MiKTsKIH0KZGlmZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNt LWJhZC1zaWduYXR1cmUuanMgYi9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS1iYWQt c2lnbmF0dXJlLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdhNTY0ZWMK LS0tIC9kZXYvbnVsbAorKysgYi9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS1iYWQt c2lnbmF0dXJlLmpzCkBAIC0wLDAgKzEsMTA1IEBACitpbXBvcnQgKiBhcyBhc3NlcnQgZnJvbSAn Li4vYXNzZXJ0LmpzJzsKK2ltcG9ydCBCdWlsZGVyIGZyb20gJy4uL0J1aWxkZXIuanMnOworCitj b25zdCBpbXBvcnROYW1lID0gInBpZXJPbmUiOworY29uc3QgdHlwZXMgPSBbImkzMiIsICJpNjQi LCAiZjMyIiwgImY2NCIsICJ2b2lkIl07Citjb25zdCB0eXBlc05vblZvaWQgPSBbImkzMiIsICJp NjQiLCAiZjMyIiwgImY2NCJdOworY29uc3Qgc3dhcFR5cGUgPSAodHlwZSwgaW5kZXgpID0+IHR5 cGVzWyh0eXBlcy5pbmRleE9mKHR5cGUpICsgaW5kZXgpICUgdHlwZXMubGVuZ3RoXTsKK2NvbnN0 IHN3YXBUeXBlTm9uVm9pZCA9ICh0eXBlLCBpbmRleCkgPT4gdHlwZXNOb25Wb2lkWyh0eXBlc05v blZvaWQuaW5kZXhPZih0eXBlKSArIGluZGV4KSAlIHR5cGVzTm9uVm9pZC5sZW5ndGhdOworCitj b25zdCBzaWduYXR1cmVzID0gWworICAgIHsgcGFyYW1zOiBbImkzMiJdLCByZXQ6ICJ2b2lkIiB9 LAorICAgIHsgcGFyYW1zOiBbImk2NCJdLCByZXQ6ICJ2b2lkIiB9LAorICAgIHsgcGFyYW1zOiBb ImYzMiJdLCByZXQ6ICJ2b2lkIiB9LAorICAgIHsgcGFyYW1zOiBbImY2NCJdLCByZXQ6ICJ2b2lk IiB9LAorICAgIHsgcGFyYW1zOiBbImkzMiJdLCByZXQ6ICJpMzIiIH0sCisgICAgeyBwYXJhbXM6 IFsiaTY0Il0sIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogWyJmMzIiXSwgcmV0OiAiZjMy IiB9LAorICAgIHsgcGFyYW1zOiBbImY2NCJdLCByZXQ6ICJmNjQiIH0sCisgICAgeyBwYXJhbXM6 IFsiaTMyIiwgImYzMiJdLCByZXQ6ICJpMzIiIH0sCisgICAgeyBwYXJhbXM6IFsiZjMyIiwgImkz MiJdLCByZXQ6ICJpMzIiIH0sCisgICAgeyBwYXJhbXM6IFsiaTY0IiwgImY2NCJdLCByZXQ6ICJp NjQiIH0sCisgICAgeyBwYXJhbXM6IFsiZjY0IiwgImk2NCJdLCByZXQ6ICJpNjQiIH0sCisgICAg eyBwYXJhbXM6IFsiaTMyIiwgImYzMiIsICJpMzIiXSwgcmV0OiAiaTMyIiB9LAorICAgIHsgcGFy YW1zOiBbImkzMiIsICJmMzIiLCAiaTMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7IHBhcmFtczog WyJpNjQiLCAiZjY0IiwgImk2NCJdLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IFsiaTY0 IiwgImY2NCIsICJpNjQiXSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBBcnJheSgzMiku ZmlsbCgiaTMyIiksIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogQXJyYXkoMzIpLmZpbGwo Imk2NCIpLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IEFycmF5KDMyKS5maWxsKCJmMzIi KSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBBcnJheSgzMikuZmlsbCgiZjY0IiksIHJl dDogImk2NCIgfSwKK107CisKK2NvbnN0IG1ha2VJbXBvcnRlciA9IHNpZ25hdHVyZSA9PiB7Cisg ICAgY29uc3QgYnVpbGRlciA9IChuZXcgQnVpbGRlcigpKQorICAgICAgICAuVHlwZSgpLkVuZCgp CisgICAgICAgIC5JbXBvcnQoKS5GdW5jdGlvbigiZXhwb3J0cyIsIGltcG9ydE5hbWUsIHNpZ25h dHVyZSkuRW5kKCk7CisgICAgcmV0dXJuIG5ldyBXZWJBc3NlbWJseS5Nb2R1bGUoYnVpbGRlci5X ZWJBc3NlbWJseSgpLmdldCgpKTsKK307CisKK2NvbnN0IG1ha2VJbXBvcnRlZSA9IHNpZ25hdHVy ZSA9PiB7CisgICAgY29uc3QgYnVpbGRlciA9IChuZXcgQnVpbGRlcigpKQorICAgICAgICAuVHlw ZSgpLkVuZCgpCisgICAgICAgIC5GdW5jdGlvbigpLkVuZCgpCisgICAgICAgIC5FeHBvcnQoKQor ICAgICAgICAgICAgLkZ1bmN0aW9uKGltcG9ydE5hbWUpCisgICAgICAgIC5FbmQoKQorICAgICAg ICAuQ29kZSgpCisgICAgICAgICAgICAuRnVuY3Rpb24oaW1wb3J0TmFtZSwgc2lnbmF0dXJlKTsK KyAgICBzd2l0Y2ggKHNpZ25hdHVyZS5yZXQpIHsKKyAgICBjYXNlICJpMzIiOiBidWlsZGVyLkkz MkNvbnN0KDApOyBicmVhazsKKyAgICBjYXNlICJpNjQiOiBidWlsZGVyLkk2NENvbnN0KDApOyBi cmVhazsKKyAgICBjYXNlICJmMzIiOiBidWlsZGVyLkYzMkNvbnN0KDApOyBicmVhazsKKyAgICBj YXNlICJmNjQiOiBidWlsZGVyLkY2NENvbnN0KDApOyBicmVhazsKKyAgICBjYXNlICJ2b2lkIjog YnJlYWs7CisgICAgfQorICAgIHJldHVybiBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UobmV3IFdl YkFzc2VtYmx5Lk1vZHVsZShidWlsZGVyLlJldHVybigpLkVuZCgpLkVuZCgpLldlYkFzc2VtYmx5 KCkuZ2V0KCkpKTsKK307CisKKyhmdW5jdGlvbiBCYWJTaWduYXR1cmVEcm9wU3RhcnRQYXJhbXMo KSB7CisgICAgZm9yIChsZXQgc2lnbmF0dXJlIG9mIHNpZ25hdHVyZXMpIHsKKyAgICAgICAgY29u c3QgaW1wb3J0ZWUgPSBtYWtlSW1wb3J0ZWUoc2lnbmF0dXJlKTsKKyAgICAgICAgZm9yIChsZXQg aSA9IDE7IGkgPD0gc2lnbmF0dXJlLnBhcmFtcy5sZW5ndGg7ICsraSkgeworICAgICAgICAgICAg Y29uc3QgYmFkUGFyYW1TaWduYXR1cmUgPSB7IHBhcmFtczogc2lnbmF0dXJlLnBhcmFtcy5zbGlj ZShpLCBzaWduYXR1cmUucGFyYW1zLmxlbmd0aCksIHJldDogc2lnbmF0dXJlLnJldCB9OworICAg ICAgICAgICAgY29uc3QgaW1wb3J0ZXIgPSBtYWtlSW1wb3J0ZXIoYmFkUGFyYW1TaWduYXR1cmUp OworICAgICAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBuZXcgV2ViQXNzZW1ibHkuSW5zdGFu Y2UoaW1wb3J0ZXIsIGltcG9ydGVlKSwgV2ViQXNzZW1ibHkuTGlua0Vycm9yLCBgaW1wb3J0ZWQg ZnVuY3Rpb24ncyBzaWduYXR1cmUgbWlzbWF0Y2hlcyB0aGUgcHJvdmlkZWQgV2ViQXNzZW1ibHkg ZnVuY3Rpb24ncyBzaWduYXR1cmUgKGV2YWx1YXRpbmcgJ25ldyBXZWJBc3NlbWJseS5JbnN0YW5j ZShpbXBvcnRlciwgaW1wb3J0ZWUpJylgKTsKKyAgICAgICAgfQorICAgIH0KK30pKCk7CisKKyhm dW5jdGlvbiBCYWJTaWduYXR1cmVEcm9wRW5kUGFyYW1zKCkgeworICAgIGZvciAobGV0IHNpZ25h dHVyZSBvZiBzaWduYXR1cmVzKSB7CisgICAgICAgIGNvbnN0IGltcG9ydGVlID0gbWFrZUltcG9y dGVlKHNpZ25hdHVyZSk7CisgICAgICAgIGZvciAobGV0IGkgPSAxOyBpIDwgc2lnbmF0dXJlLnBh cmFtcy5sZW5ndGg7ICsraSkgeworICAgICAgICAgICAgY29uc3QgYmFkUGFyYW1TaWduYXR1cmUg PSB7IHBhcmFtczogc2lnbmF0dXJlLnBhcmFtcy5zbGljZSgwLCBpKSwgcmV0OiBzaWduYXR1cmUu cmV0IH07CisgICAgICAgICAgICBjb25zdCBpbXBvcnRlciA9IG1ha2VJbXBvcnRlcihiYWRQYXJh bVNpZ25hdHVyZSk7CisgICAgICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IG5ldyBXZWJBc3Nl bWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpLCBXZWJBc3NlbWJseS5MaW5rRXJyb3Is IGBpbXBvcnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBtaXNtYXRjaGVzIHRoZSBwcm92aWRlZCBX ZWJBc3NlbWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSAoZXZhbHVhdGluZyAnbmV3IFdlYkFzc2Vt Ymx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSknKWApOworICAgICAgICB9CisgICAgfQor fSkoKTsKKworKGZ1bmN0aW9uIEJhYlNpZ25hdHVyZVN3YXBQYXJhbSgpIHsKKyAgICBmb3IgKGxl dCBzaWduYXR1cmUgb2Ygc2lnbmF0dXJlcykgeworICAgICAgICBjb25zdCBpbXBvcnRlZSA9IG1h a2VJbXBvcnRlZShzaWduYXR1cmUpOworICAgICAgICBmb3IgKGxldCBzaWduYXR1cmVJbmRleCA9 IDA7IHNpZ25hdHVyZUluZGV4IDwgc2lnbmF0dXJlLmxlbmd0aDsgKytzaWduYXR1cmVJbmRleCkg eworICAgICAgICAgICAgZm9yIChsZXQgdHlwZUluZGV4ID0gMTsgdHlwZUluZGV4IDwgdHlwZXNO b25Wb2lkLmxlbmd0aDsgKyt0eXBlSW5kZXgpIHsKKyAgICAgICAgICAgICAgICBsZXQgYmFkUGFy YW1zID0gc2lnbmF0dXJlLnBhcmFtcy5zbGljZSgpOworICAgICAgICAgICAgICAgIGJhZFBhcmFt c1tzaWduYXR1cmVJbmRleF0gPSBzd2FwVHlwZU5vblZvaWQoYmFkUGFyYW1zW3NpZ25hdHVyZUlu ZGV4XSwgdHlwZUluZGV4KTsKKyAgICAgICAgICAgICAgICBjb25zdCBiYWRQYXJhbVNpZ25hdHVy ZSA9IHsgcGFyYW1zOiBiYWRQYXJhbXMsIHJldDogc2lnbmF0dXJlLnJldCB9OworICAgICAgICAg ICAgICAgIGNvbnN0IGltcG9ydGVyID0gbWFrZUltcG9ydGVyKGJhZFBhcmFtU2lnbmF0dXJlKTsK KyAgICAgICAgICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IG5ldyBXZWJBc3NlbWJseS5JbnN0 YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpLCBXZWJBc3NlbWJseS5MaW5rRXJyb3IsIGBpbXBvcnRl ZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBtaXNtYXRjaGVzIHRoZSBwcm92aWRlZCBXZWJBc3NlbWJs eSBmdW5jdGlvbidzIHNpZ25hdHVyZSAoZXZhbHVhdGluZyAnbmV3IFdlYkFzc2VtYmx5Lkluc3Rh bmNlKGltcG9ydGVyLCBpbXBvcnRlZSknKWApOworICAgICAgICAgICAgfQorICAgICAgICB9Cisg ICAgfQorfSkoKTsKKworKGZ1bmN0aW9uIEJhYlNpZ25hdHVyZVJldCgpIHsKKyAgICBmb3IgKGxl dCBzaWduYXR1cmUgb2Ygc2lnbmF0dXJlcykgeworICAgICAgICBjb25zdCBpbXBvcnRlZSA9IG1h a2VJbXBvcnRlZShzaWduYXR1cmUpOworICAgICAgICBmb3IgKGxldCB0eXBlSW5kZXggPSAxOyB0 eXBlSW5kZXggPCB0eXBlcy5sZW5ndGg7ICsrdHlwZUluZGV4KSB7CisgICAgICAgICAgICBjb25z dCBiYWRQYXJhbVNpZ25hdHVyZSA9IHsgcGFyYW1zOiBzaWduYXR1cmUucGFyYW1zLCByZXQ6IHN3 YXBUeXBlKHNpZ25hdHVyZS5yZXQsIHR5cGVJbmRleCkgfTsKKyAgICAgICAgICAgIGNvbnN0IGlt cG9ydGVyID0gbWFrZUltcG9ydGVyKGJhZFBhcmFtU2lnbmF0dXJlKTsKKyAgICAgICAgICAgIGFz c2VydC50aHJvd3MoKCkgPT4gbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBv cnRlZSksIFdlYkFzc2VtYmx5LkxpbmtFcnJvciwgYGltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0 dXJlIG1pc21hdGNoZXMgdGhlIHByb3ZpZGVkIFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2lnbmF0 dXJlIChldmFsdWF0aW5nICduZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9y dGVlKScpYCk7CisgICAgICAgIH0KKyAgICB9Cit9KSgpOwpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93 YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMgYi9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8t d2FzbS5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wODI1NWM2Ci0tLSAv ZGV2L251bGwKKysrIGIvSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMKQEAgLTAs MCArMSw3MyBAQAoraW1wb3J0ICogYXMgYXNzZXJ0IGZyb20gJy4uL2Fzc2VydC5qcyc7CitpbXBv cnQgQnVpbGRlciBmcm9tICcuLi9CdWlsZGVyLmpzJzsKKy8qCitjb25zdCBjYWxsZXJUb3BCaXRz ID0gMHhDMEZFQkVFRjsKK2NvbnN0IGlubmVyUmV0dXJuSGkgPSAweERFQURGQUNFOworY29uc3Qg aW5uZXJSZXR1cm5MbyA9IDB4QzBGRUMwRkU7CisKK2NvbnN0IGNhbGxlck1vZHVsZSA9ICgpID0+ IHsKKyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAgIC5UeXBlKCku RW5kKCkKKyAgICAgICAgLkltcG9ydCgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImV4cG9ydHMi LCAiY2FsbE1lIiwgeyBwYXJhbXM6IFsiaTY0Il0sIHJldDogImk2NCIgfSkKKyAgICAgICAgLkVu ZCgpCisgICAgICAgIC5GdW5jdGlvbigpLkVuZCgpCisgICAgICAgIC5FeHBvcnQoKQorICAgICAg ICAgICAgLkZ1bmN0aW9uKCJlbnRyeSIpCisgICAgICAgIC5FbmQoKQorICAgICAgICAuQ29kZSgp CisgICAgICAgICAgICAuRnVuY3Rpb24oImVudHJ5IiwgeyBwYXJhbXM6IFsiaTMyIl0sIHJldDog ImkzMiIgfSwgWyJpNjQiXSkKKyAgICAgICAgICAgICAgICAuSTMyQ29uc3QoY2FsbGVyVG9wQml0 cykuSTY0RXh0ZW5kVUkzMigpLkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRVSTMyKCkuSTY0U2hsKCkg Ly8gKChpNjQpY2FsbGVyVG9wQml0cykgPDwgMzIKKyAgICAgICAgICAgICAgICAuR2V0TG9jYWwo MCkuSTY0RXh0ZW5kVUkzMigpCisgICAgICAgICAgICAgICAgLkk2NE9yKCkgLy8gdmFsdWU6IHBh cmFtIHwgKCgoaTY0KWNhbGxlclRvcEJpdHMgPDwgMzIpKQorICAgICAgICAgICAgICAgIC5DYWxs KDApIC8vIENhbGxzIGV4cG9ydHMuY2FsbE1lKHBhcmFtIHwgKCgoaTY0KWNhbGxlclRvcEJpdHMp IDw8IDMyKSkuCisgICAgICAgICAgICAgICAgLlRlZUxvY2FsKDEpLkkzMldyYXBJNjQoKSAvLyBs bzogKGkzMiljYWxsUmVzdWx0CisgICAgICAgICAgICAgICAgLkdldExvY2FsKDEpLkkzMkNvbnN0 KDMyKS5JNjRFeHRlbmRVSTMyKCkuSTY0U2hyVSgpLkkzMldyYXBJNjQoKSAvLyBoaTogKGkzMiko Y2FsbFJlc3VsdCA+PiAzMikKKyAgICAgICAgICAgICAgICAuSTMyWG9yKCkKKyAgICAgICAgICAg ICAgICAuUmV0dXJuKCkKKyAgICAgICAgICAgIC5FbmQoKQorICAgICAgICAuRW5kKCk7CisgICAg cmV0dXJuIG5ldyBXZWJBc3NlbWJseS5Nb2R1bGUoYnVpbGRlci5XZWJBc3NlbWJseSgpLmdldCgp KTsKK307CisKK2NvbnN0IGNhbGxlZU1vZHVsZSA9ICgpID0+IHsKKyAgICBjb25zdCBidWlsZGVy ID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAgIC5UeXBlKCkuRW5kKCkKKyAgICAgICAgLkltcG9y dCgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImltcCIsICJmdW5jIiwgeyBwYXJhbXM6IFsiaTMy IiwgImkzMiJdLCByZXQ6ICJpMzIiIH0pCisgICAgICAgIC5FbmQoKQorICAgICAgICAuRnVuY3Rp b24oKS5FbmQoKQorICAgICAgICAuRXhwb3J0KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigiY2Fs bE1lIikKKyAgICAgICAgLkVuZCgpCisgICAgICAgIC5Db2RlKCkKKyAgICAgICAgICAgIC5GdW5j dGlvbigiY2FsbE1lIiwgeyBwYXJhbXM6IFsiaTY0Il0sIHJldDogImk2NCIgfSkKKyAgICAgICAg ICAgICAgICAuR2V0TG9jYWwoMCkuSTMyV3JhcEk2NCgpIC8vIGxvOiAoaTMyKXBhcmFtCisgICAg ICAgICAgICAgICAgLkdldExvY2FsKDApLkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRVSTMyKCkuSTY0 U2hyVSgpLkkzMldyYXBJNjQoKSAvLyBoaTogKGkzMikocGFyYW0gPj4gMzIpCisgICAgICAgICAg ICAgICAgLkNhbGwoMCkgLy8gQ2FsbHMgaW1wLmZ1bmMgd2l0aCB0aGUgNjQtYml0IHZhbHVlIGFz IGkzMiB7IGhpLCBsbyB9LgorICAgICAgICAgICAgICAgIC5Ecm9wKCkKKyAgICAgICAgICAgICAg ICAuSTMyQ29uc3QoaW5uZXJSZXR1cm5IaSkuSTY0RXh0ZW5kVUkzMigpLkkzMkNvbnN0KDMyKS5J NjRFeHRlbmRVSTMyKCkuSTY0U2hsKCkuSTMyQ29uc3QoaW5uZXJSZXR1cm5MbykuSTY0RXh0ZW5k VUkzMigpLkk2NE9yKCkgLy8gKChpNjQpaGkgPDwgMzIpIHwgKGk2NClsbworICAgICAgICAgICAg ICAgIC5SZXR1cm4oKQorICAgICAgICAgICAgLkVuZCgpCisgICAgICAgIC5FbmQoKTsKKyAgICBy ZXR1cm4gbmV3IFdlYkFzc2VtYmx5Lk1vZHVsZShidWlsZGVyLldlYkFzc2VtYmx5KCkuZ2V0KCkp OworfTsKKworKGZ1bmN0aW9uIFdhc21Ub1dhc20oKSB7CisgICAgbGV0IHZhbHVlOworICAgIGNv bnN0IGZ1bmMgPSAoaGksIGxvKSA9PiB7IHZhbHVlID0geyBoaTogaGksIGxvOiBsbyB9OyBwcmlu dChgJHtFcnJvci5zdGFja31gKTsgcmV0dXJuIGhpIF4gbG87IH07CisgICAgY29uc3QgY2FsbGVl ID0gbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGNhbGxlZU1vZHVsZSgpLCB7IGltcDogeyBmdW5j OiBmdW5jIH0gfSk7CisgICAgY29uc3QgY2FsbGVyID0gbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNl KGNhbGxlck1vZHVsZSgpLCBjYWxsZWUpOworICAgIGZvciAobGV0IGkgPSAwOyBpIDwgNDA5Njsg KytpKSB7CisgICAgICAgIGFzc2VydC5lcShjYWxsZXIuZXhwb3J0cy5lbnRyeShpKSwgaW5uZXJS ZXR1cm5IaSBeIGlubmVyUmV0dXJuTG8pOworICAgICAgICBhc3NlcnQuZXEodmFsdWUuaGksIGNh bGxlclRvcEJpdHMpOworICAgICAgICBhc3NlcnQuZXEodmFsdWUubG8sIGkpOworICAgIH0KK30p KCk7CisKKworLy8gRklYTUU6IHRlc3Qgd2FzbS0+d2FzbSB1c2luZyAzMi1iaXQgdGhpbmdzIChp bmNsdWRpbmcgZmxvYXQpLCBhcyB3ZWxsIGFzIDY0LWJpdCBOYU5zIHRoYXQgZG9uJ3QgZ2V0IGNh bm9uaWNhbGl6ZWQKKy8vIEZJWE1FOiBkbyBhIHRocm93IHR3by1kZWVwCisvLyBGSVhNRTogY2hl Y2sgdGhhdCB0aGUgZmlyc3Qgd2FzbSdzIGluc3RhbmNlIGlzIGJhY2sgaW4gT0sgc3RhdGUgKHdp dGggdGFibGUgb3IgZ2xvYmFsPykKKy8vIEZJWE1FOiB0ZXN0IGNhbGxpbmcgdGhyb3VnaCBhIFRh YmxlCisqLwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2pzYy5jcHAgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvanNjLmNwcAppbmRleCAyOTIzOGEwLi5jNTY1MmE0IDEwMDY0NAot LS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvanNjLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvanNjLmNwcApAQCAtNTQsNiArNTQsOCBAQAogI2luY2x1ZGUgIkpTU3RyaW5nLmgiCiAj aW5jbHVkZSAiSlNUeXBlZEFycmF5cy5oIgogI2luY2x1ZGUgIkpTV2ViQXNzZW1ibHlDYWxsZWUu aCIKKyNpbmNsdWRlICJKU1dlYkFzc2VtYmx5SW5zdGFuY2UuaCIKKyNpbmNsdWRlICJKU1dlYkFz c2VtYmx5TW9kdWxlLmgiCiAjaW5jbHVkZSAiTExJbnREYXRhLmgiCiAjaW5jbHVkZSAiTExJbnRU aHVua3MuaCIKICNpbmNsdWRlICJPYmplY3RDb25zdHJ1Y3Rvci5oIgpAQCAtNzAsNiArNzIsNyBA QAogI2luY2x1ZGUgIlR5cGVQcm9maWxlckxvZy5oIgogI2luY2x1ZGUgIldhc21QbGFuLmgiCiAj aW5jbHVkZSAiV2FzbU1lbW9yeS5oIgorI2luY2x1ZGUgIldlYkFzc2VtYmx5TW9kdWxlUmVjb3Jk LmgiCiAjaW5jbHVkZSA8bG9jYWxlLmg+CiAjaW5jbHVkZSA8bWF0aC5oPgogI2luY2x1ZGUgPHN0 ZGlvLmg+CkBAIC0yNjAwLDYgKzI2MDMsNyBAQCBzdGF0aWMgRW5jb2RlZEpTVmFsdWUgSlNDX0hP U1RfQ0FMTCBmdW5jdGlvblRlc3RXYXNtTW9kdWxlRnVuY3Rpb25zKEV4ZWNTdGF0ZSogZQogewog ICAgIFZNJiB2bSA9IGV4ZWMtPnZtKCk7CiAgICAgYXV0byBzY29wZSA9IERFQ0xBUkVfVEhST1df U0NPUEUodm0pOworICAgIGF1dG8qIGdsb2JhbE9iamVjdCA9IGV4ZWMtPmxleGljYWxHbG9iYWxP YmplY3QoKTsKIAogICAgIGlmICghT3B0aW9uczo6dXNlV2ViQXNzZW1ibHkoKSkKICAgICAgICAg cmV0dXJuIHRocm93Vk1UeXBlRXJyb3IoZXhlYywgc2NvcGUsIEFTQ0lJTGl0ZXJhbCgidGVzdFdh c21Nb2R1bGUgc2hvdWxkIG9ubHkgYmUgY2FsbGVkIGlmIHRoZSB1c2VXZWJBc3NlbWJseSBvcHRp b24gaXMgc2V0IikpOwpAQCAtMjYzMywxOSArMjYzNywyNCBAQCBzdGF0aWMgRW5jb2RlZEpTVmFs dWUgSlNDX0hPU1RfQ0FMTCBmdW5jdGlvblRlc3RXYXNtTW9kdWxlRnVuY3Rpb25zKEV4ZWNTdGF0 ZSogZQogICAgICAgICAgICAgfSk7CiAgICAgfQogCi0gICAgdm9pZCogbWVtb3J5Qnl0ZXMgPSBu dWxscHRyOwotICAgIHVpbnQzMl90IG1lbW9yeVNpemUgPSAwOwotICAgIHN0ZDo6dW5pcXVlX3B0 cjxXYXNtOjpNZW1vcnk+IG1lbW9yeTsKLSAgICBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxl SW5mb3JtYXRpb24+IG1vZHVsZUluZm9ybWF0aW9uID0gcGxhbi50YWtlTW9kdWxlSW5mb3JtYXRp b24oKTsKKyAgICBTeW1ib2xUYWJsZSogZXhwb3J0U3ltYm9sVGFibGUgPSBTeW1ib2xUYWJsZTo6 Y3JlYXRlKHZtKTsKKyAgICBhdXRvKiBtb2R1bGVTdHJ1Y3R1cmUgPSBJbnRlcm5hbEZ1bmN0aW9u OjpjcmVhdGVTdWJjbGFzc1N0cnVjdHVyZShleGVjLCBKU1ZhbHVlKCksIGV4ZWMtPmxleGljYWxH bG9iYWxPYmplY3QoKS0+V2ViQXNzZW1ibHlNb2R1bGVTdHJ1Y3R1cmUoKSk7CisgICAgUkVUVVJO X0lGX0VYQ0VQVElPTihzY29wZSwgZW5jb2RlZEpTVmFsdWUoKSk7CisgICAgSlNXZWJBc3NlbWJs eU1vZHVsZSogbW9kdWxlID0gSlNXZWJBc3NlbWJseU1vZHVsZTo6Y3JlYXRlKHZtLCBtb2R1bGVT dHJ1Y3R1cmUsIHBsYW4udGFrZU1vZHVsZUluZm9ybWF0aW9uKCksIHBsYW4udGFrZUNhbGxMaW5r SW5mb3MoKSwgcGxhbi50YWtlV2FzbUV4aXRTdHVicygpLCBleHBvcnRTeW1ib2xUYWJsZSwgMCk7 CisgICAgU3RydWN0dXJlKiBpbnN0YW5jZVN0cnVjdHVyZSA9IEludGVybmFsRnVuY3Rpb246OmNy ZWF0ZVN1YmNsYXNzU3RydWN0dXJlKGV4ZWMsIEpTVmFsdWUoKSwgZ2xvYmFsT2JqZWN0LT5XZWJB c3NlbWJseUluc3RhbmNlU3RydWN0dXJlKCkpOworICAgIFJFVFVSTl9JRl9FWENFUFRJT04oc2Nv cGUsIGVuY29kZWRKU1ZhbHVlKCkpOworICAgIElkZW50aWZpZXIgbW9kdWxlS2V5ID0gSWRlbnRp Zmllcjo6ZnJvbVVpZChQcml2YXRlTmFtZShQcml2YXRlTmFtZTo6RGVzY3JpcHRpb24sICJXZWJB c3NlbWJseUluc3RhbmNlIikpOworICAgIFdlYkFzc2VtYmx5TW9kdWxlUmVjb3JkKiBtb2R1bGVS ZWNvcmQgPSBXZWJBc3NlbWJseU1vZHVsZVJlY29yZDo6Y3JlYXRlKGV4ZWMsIHZtLCBnbG9iYWxP YmplY3QtPndlYkFzc2VtYmx5TW9kdWxlUmVjb3JkU3RydWN0dXJlKCksIG1vZHVsZUtleSwgbW9k dWxlLT5tb2R1bGVJbmZvcm1hdGlvbigpKTsKKyAgICBSRVRVUk5fSUZfRVhDRVBUSU9OKHNjb3Bl LCBlbmNvZGVkSlNWYWx1ZSgpKTsKKyAgICBKU1dlYkFzc2VtYmx5SW5zdGFuY2UqIGluc3RhbmNl ID0gSlNXZWJBc3NlbWJseUluc3RhbmNlOjpjcmVhdGUodm0sIGluc3RhbmNlU3RydWN0dXJlLCBt b2R1bGUsIG1vZHVsZVJlY29yZC0+Z2V0TW9kdWxlTmFtZXNwYWNlKGV4ZWMpKTsKKyAgICBSRVRV Uk5fSUZfRVhDRVBUSU9OKHNjb3BlLCBlbmNvZGVkSlNWYWx1ZSgpKTsKKyAgICB2bS50b3BKU1dl YkFzc2VtYmx5SW5zdGFuY2UgPSBpbnN0YW5jZTsKIAotICAgIGlmICghIW1vZHVsZUluZm9ybWF0 aW9uLT5tZW1vcnkpIHsKLSAgICAgICAgbWVtb3J5ID0gc3RkOjptYWtlX3VuaXF1ZTxXYXNtOjpN ZW1vcnk+KG1vZHVsZUluZm9ybWF0aW9uLT5tZW1vcnkuaW5pdGlhbCgpLCBtb2R1bGVJbmZvcm1h dGlvbi0+bWVtb3J5Lm1heGltdW0oKSk7Ci0gICAgICAgIFJFTEVBU0VfQVNTRVJUKG1lbW9yeS0+ aXNWYWxpZCgpKTsKLSAgICAgICAgbWVtb3J5Qnl0ZXMgPSBtZW1vcnktPm1lbW9yeSgpOwotICAg ICAgICBtZW1vcnlTaXplID0gbWVtb3J5LT5zaXplKCk7CisgICAgaWYgKCEhbW9kdWxlLT5tb2R1 bGVJbmZvcm1hdGlvbigpLm1lbW9yeSkgeworICAgICAgICBXYXNtOjpNZW1vcnkgbWVtb3J5KG1v ZHVsZS0+bW9kdWxlSW5mb3JtYXRpb24oKS5tZW1vcnkuaW5pdGlhbCgpLCBtb2R1bGUtPm1vZHVs ZUluZm9ybWF0aW9uKCkubWVtb3J5Lm1heGltdW0oKSk7CisgICAgICAgIFJFTEVBU0VfQVNTRVJU KG1lbW9yeS5pc1ZhbGlkKCkpOworICAgICAgICBpbnN0YW5jZS0+c2V0TWVtb3J5KHZtLCBKU1dl YkFzc2VtYmx5TWVtb3J5OjpjcmVhdGUodm0sIGdsb2JhbE9iamVjdC0+V2ViQXNzZW1ibHlNZW1v cnlTdHJ1Y3R1cmUoKSwgV1RGTW92ZShtZW1vcnkpKSk7CiAgICAgfQotICAgIHZtLnRvcFdhc21N ZW1vcnlQb2ludGVyID0gbWVtb3J5Qnl0ZXM7Ci0gICAgdm0udG9wV2FzbU1lbW9yeVNpemUgPSBt ZW1vcnlTaXplOwogCiAgICAgZm9yICh1aW50MzJfdCBpID0gMDsgaSA8IGZ1bmN0aW9uQ291bnQ7 ICsraSkgewogICAgICAgICBKU0FycmF5KiB0ZXN0Q2FzZXMgPSBqc0Nhc3Q8SlNBcnJheSo+KGV4 ZWMtPmFyZ3VtZW50KGkgKyAyKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv cnVudGltZS9KU1R5cGUuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTVHlwZS5o CmluZGV4IDA1MjAyZjMuLmFjNTA5ZDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9ydW50aW1lL0pTVHlwZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pT VHlwZS5oCkBAIC05Myw2ICs5Myw4IEBAIGVudW0gSlNUeXBlIDogdWludDhfdCB7CiAgICAgSlNN YXBUeXBlLAogICAgIEpTU2V0VHlwZSwKIAorICAgIFdlYkFzc2VtYmx5RnVuY3Rpb25UeXBlLAor CiAgICAgTGFzdEpTQ09iamVjdFR5cGUgPSBKU1NldFR5cGUsCiAgICAgTWF4SlNUeXBlID0gMGIx MTExMTExMSwKIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9W TS5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVk0uaAppbmRleCBmMzQwZTk2Li4w Y2I2MmMzIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9WTS5oCisr KyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZNLmgKQEAgLTMwMSw4ICszMDEsNiBA QCBwdWJsaWM6CiAgICAgLy8gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE2MDQ0MQogICAgIEV4ZWNTdGF0ZSogdG9wQ2FsbEZyYW1lOwogICAgIEpTV2ViQXNzZW1ibHlJ bnN0YW5jZSogdG9wSlNXZWJBc3NlbWJseUluc3RhbmNlOwotICAgIHZvaWQqIHRvcFdhc21NZW1v cnlQb2ludGVyOwotICAgIHVpbnQzMl90IHRvcFdhc21NZW1vcnlTaXplOwogICAgIFN0cm9uZzxT dHJ1Y3R1cmU+IHN0cnVjdHVyZVN0cnVjdHVyZTsKICAgICBTdHJvbmc8U3RydWN0dXJlPiBzdHJ1 Y3R1cmVSYXJlRGF0YVN0cnVjdHVyZTsKICAgICBTdHJvbmc8U3RydWN0dXJlPiB0ZXJtaW5hdGVk RXhlY3V0aW9uRXJyb3JTdHJ1Y3R1cmU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtQjNJUkdlbmVyYXRvci5jcHAKaW5kZXggMjJjNmU4NS4uZjEyYzZjNiAxMDA2NDQKLS0t IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuY3BwCisrKyBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcApAQCAtMTU1 LDcgKzE1NSw3IEBAIHB1YmxpYzoKICAgICAgICAgICAgIHJldHVybiBmYWlsKF9fVkFfQVJHU19f KTsgICAgICAgICAgICAgXAogICAgIH0gd2hpbGUgKDApCiAKLSAgICBCM0lSR2VuZXJhdG9yKFZN JiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mLCBQcm9jZWR1cmUmLCBXYXNtSW50ZXJuYWxGdW5j dGlvbiosIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYsIGNvbnN0IEltbXV0YWJsZUZ1 bmN0aW9uSW5kZXhTcGFjZSYpOworICAgIEIzSVJHZW5lcmF0b3IoVk0mLCBjb25zdCBNb2R1bGVJ bmZvcm1hdGlvbiYsIFByb2NlZHVyZSYsIFdhc21JbnRlcm5hbEZ1bmN0aW9uKiwgVmVjdG9yPFVu bGlua2VkV2FzbVRvV2FzbUNhbGw+Jik7CiAKICAgICBQYXJ0aWFsUmVzdWx0IFdBUk5fVU5VU0VE X1JFVFVSTiBhZGRBcmd1bWVudHMoY29uc3QgU2lnbmF0dXJlKik7CiAgICAgUGFydGlhbFJlc3Vs dCBXQVJOX1VOVVNFRF9SRVRVUk4gYWRkTG9jYWwoVHlwZSwgdWludDMyX3QpOwpAQCAtMjEzLDcg KzIxMyw2IEBAIHByaXZhdGU6CiAgICAgVmFsdWUqIHplcm9Gb3JUeXBlKFR5cGUpOwogCiAgICAg Vk0mIG1fdm07Ci0gICAgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiBtX2Z1bmN0 aW9uSW5kZXhTcGFjZTsKICAgICBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgbV9pbmZvOwogICAg IFByb2NlZHVyZSYgbV9wcm9jOwogICAgIEJhc2ljQmxvY2sqIG1fY3VycmVudEJsb2NrOwpAQCAt MjI1LDkgKzIyNCw4IEBAIHByaXZhdGU6CiAgICAgVmFsdWUqIG1faW5zdGFuY2VWYWx1ZTsKIH07 CiAKLUIzSVJHZW5lcmF0b3I6OkIzSVJHZW5lcmF0b3IoVk0mIHZtLCBjb25zdCBNb2R1bGVJbmZv cm1hdGlvbiYgaW5mbywgUHJvY2VkdXJlJiBwcm9jZWR1cmUsIFdhc21JbnRlcm5hbEZ1bmN0aW9u KiBjb21waWxhdGlvbiwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+JiB1bmxpbmtlZFdh c21Ub1dhc21DYWxscywgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiBmdW5jdGlv bkluZGV4U3BhY2UpCitCM0lSR2VuZXJhdG9yOjpCM0lSR2VuZXJhdG9yKFZNJiB2bSwgY29uc3Qg TW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFByb2NlZHVyZSYgcHJvY2VkdXJlLCBXYXNtSW50ZXJu YWxGdW5jdGlvbiogY29tcGlsYXRpb24sIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYg dW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMpCiAgICAgOiBtX3ZtKHZtKQotICAgICwgbV9mdW5jdGlv bkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleFNwYWNlKQogICAgICwgbV9pbmZvKGluZm8pCiAgICAg LCBtX3Byb2MocHJvY2VkdXJlKQogICAgICwgbV91bmxpbmtlZFdhc21Ub1dhc21DYWxscyh1bmxp bmtlZFdhc21Ub1dhc21DYWxscykKQEAgLTI2OSw2ICsyNjcsNDIgQEAgQjNJUkdlbmVyYXRvcjo6 QjNJUkdlbmVyYXRvcihWTSYgdm0sIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBpbmZvLCBQcm9j ZWR1cmUmIHAKICAgICAgICAgbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxDb25zdFB0clZhbHVl PihtX3Byb2MsIE9yaWdpbigpLCAmbV92bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UpKTsKIH0K IAorc3RhdGljIHZvaWQgcmVzdG9yZVdlYkFzc2VtYmx5R2xvYmFsU3RhdGUoVk0mIHZtLCBjb25z dCBNZW1vcnlJbmZvcm1hdGlvbiYgbWVtb3J5LCBWYWx1ZSogaW5zdGFuY2UsIFByb2NlZHVyZSYg cHJvYywgQmFzaWNCbG9jayogYmxvY2spCit7CisgICAgaWYgKGluc3RhbmNlKQorICAgICAgICBi bG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihwcm9jLCBTdG9yZSwgT3JpZ2luKCksIGluc3Rh bmNlLCBibG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KHByb2MsIE9yaWdpbigpLCAmdm0u dG9wSlNXZWJBc3NlbWJseUluc3RhbmNlKSk7CisKKyAgICBpZiAoISFtZW1vcnkpIHsKKyAgICAg ICAgVmFsdWUqIG1lbW9yeU9iamVjdCA9IGJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KHBy b2MsIExvYWQsIHBvaW50ZXJUeXBlKCksIE9yaWdpbigpLCBibG9jay0+YXBwZW5kTmV3PENvbnN0 UHRyVmFsdWU+KHByb2MsIE9yaWdpbigpLCBpbnN0YW5jZSksIEpTV2ViQXNzZW1ibHlJbnN0YW5j ZTo6b2Zmc2V0T2ZNZW1vcnkoKSk7CisKKyAgICAgICAgc3RhdGljX2Fzc2VydChzaXplb2YoZGVj bHR5cGUodm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlLT5tZW1vcnkoKS0+bWVtb3J5KCktPm1l bW9yeSgpKSkgPT0gc2l6ZW9mKHZvaWQqKSwgImNvZGVnZW4gcmVsaWVzIG9uIHRoaXMgc2l6ZSIp OworICAgICAgICBzdGF0aWNfYXNzZXJ0KHNpemVvZihkZWNsdHlwZSh2bS50b3BKU1dlYkFzc2Vt Ymx5SW5zdGFuY2UtPm1lbW9yeSgpLT5tZW1vcnkoKS0+c2l6ZSgpKSkgPT0gc2l6ZW9mKHVpbnQz Ml90KSwgImNvZGVnZW4gcmVsaWVzIG9uIHRoaXMgc2l6ZSIpOworICAgICAgICBWYWx1ZSogYmFz ZU1lbW9yeSA9IGJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KHByb2MsIExvYWQsIHBvaW50 ZXJUeXBlKCksIE9yaWdpbigpLCBibG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KHByb2Ms IE9yaWdpbigpLCBtZW1vcnlPYmplY3QpLCBKU1dlYkFzc2VtYmx5TWVtb3J5OjpvZmZzZXRPZk1l bW9yeSgpKTsKKyAgICAgICAgVmFsdWUqIG1lbW9yeVNpemUgPSBibG9jay0+YXBwZW5kTmV3PE1l bW9yeVZhbHVlPihwcm9jLCBMb2FkLCBJbnQzMiwgT3JpZ2luKCksIGJsb2NrLT5hcHBlbmROZXc8 Q29uc3RQdHJWYWx1ZT4ocHJvYywgT3JpZ2luKCksIG1lbW9yeU9iamVjdCksIEpTV2ViQXNzZW1i bHlNZW1vcnk6Om9mZnNldE9mU2l6ZSgpKTsKKworICAgICAgICBWZWN0b3I8VmFsdWUqPiBhcmd1 bWVudHM7CisgICAgICAgIGFyZ3VtZW50cy5yZXNlcnZlQ2FwYWNpdHkoMSArIG1lbW9yeS5waW5u ZWRSZWdpc3RlcnMoKS5zaXplUmVnaXN0ZXJzLnNpemUoKSk7CisgICAgICAgIGFyZ3VtZW50cy5h cHBlbmQoYmFzZU1lbW9yeSk7CisgICAgICAgIGZvciAoYXV0byBpbmZvIDogbWVtb3J5LnBpbm5l ZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnMpIHsKKyAgICAgICAgICAgIFZhbHVlKiBzaXplVmFs dWUgPSBibG9jay0+YXBwZW5kTmV3PFZhbHVlPihwcm9jLCBTdWIsIE9yaWdpbigpLCBtZW1vcnlT aXplLCBibG9jay0+YXBwZW5kTmV3PENvbnN0MzJWYWx1ZT4ocHJvYywgT3JpZ2luKCksIGluZm8u c2l6ZU9mZnNldCkpOworICAgICAgICAgICAgYXJndW1lbnRzLmFwcGVuZChzaXplVmFsdWUpOwor ICAgICAgICB9CisKKyAgICAgICAgQjM6OlBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCA9IGJs b2NrLT5hcHBlbmROZXc8QjM6OlBhdGNocG9pbnRWYWx1ZT4ocHJvYywgQjM6OlZvaWQsIE9yaWdp bigpKTsKKyAgICAgICAgcGF0Y2hwb2ludC0+ZWZmZWN0cyA9IEVmZmVjdHM6Om5vbmUoKTsKKyAg ICAgICAgcGF0Y2hwb2ludC0+ZWZmZWN0cy53cml0ZXNQaW5uZWQgPSB0cnVlOworICAgICAgICBw YXRjaHBvaW50LT5hcHBlbmRWZWN0b3JXaXRoUmVwKGFyZ3VtZW50cywgVmFsdWVSZXA6OlNvbWVS ZWdpc3Rlcik7CisKKyAgICAgICAgcGF0Y2hwb2ludC0+c2V0R2VuZXJhdG9yKFttZW1vcnldIChD Q2FsbEhlbHBlcnMmIGppdCwgY29uc3QgQjM6OlN0YWNrbWFwR2VuZXJhdGlvblBhcmFtcyYgcGFy YW1zKSB7CisgICAgICAgICAgICBBbGxvd01hY3JvU2NyYXRjaFJlZ2lzdGVyVXNhZ2UgYWxsb3dT Y3JhdGNoKGppdCk7CisKKyAgICAgICAgICAgIGppdC5tb3ZlKHBhcmFtc1swXS5ncHIoKSwgbWVt b3J5LnBpbm5lZFJlZ2lzdGVycygpLmJhc2VNZW1vcnlQb2ludGVyKTsKKyAgICAgICAgICAgIGZv ciAodWludDMyX3QgaSA9IDA7IGkgPCBtZW1vcnkucGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lz dGVycy5zaXplKCk7ICsraSkKKyAgICAgICAgICAgICAgICBqaXQubW92ZShwYXJhbXNbMSArIGld LmdwcigpLCBtZW1vcnkucGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVyc1tpXS5zaXplUmVn aXN0ZXIpOworICAgICAgICB9KTsKKyAgICB9Cit9CisKIHZvaWQgQjNJUkdlbmVyYXRvcjo6ZW1p dEV4Y2VwdGlvbkNoZWNrKENDYWxsSGVscGVycyYgaml0LCBFeGNlcHRpb25UeXBlIHR5cGUpCiB7 CiAgICAgaml0Lm1vdmUoQ0NhbGxIZWxwZXJzOjpUcnVzdGVkSW1tMzIoc3RhdGljX2Nhc3Q8dWlu dDMyX3Q+KHR5cGUpKSwgR1BSSW5mbzo6YXJndW1lbnRHUFIxKTsKQEAgLTY5MiwyMyArNzI2LDc4 IEBAIGF1dG8gQjNJUkdlbmVyYXRvcjo6YWRkQ2FsbCh1aW50MzJfdCBmdW5jdGlvbkluZGV4LCBj b25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSwKICAgICBBU1NFUlQoc2lnbmF0dXJlLT5hcmd1bWVu dENvdW50KCkgPT0gYXJncy5zaXplKCkpOwogCiAgICAgVHlwZSByZXR1cm5UeXBlID0gc2lnbmF0 dXJlLT5yZXR1cm5UeXBlKCk7CisgICAgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+KiB1 bmxpbmtlZFdhc21Ub1dhc21DYWxscyA9ICZtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzOwogCi0g ICAgcmVzdWx0ID0gd2FzbUNhbGxpbmdDb252ZW50aW9uKCkuc2V0dXBDYWxsKG1fcHJvYywgbV9j dXJyZW50QmxvY2ssIE9yaWdpbigpLCBhcmdzLCB0b0IzVHlwZShyZXR1cm5UeXBlKSwKLSAgICAg ICAgWyZdIChQYXRjaHBvaW50VmFsdWUqIHBhdGNocG9pbnQpIHsKLSAgICAgICAgICAgIHBhdGNo cG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKLSAgICAgICAgICAgIHBhdGNocG9p bnQtPmVmZmVjdHMucmVhZHNQaW5uZWQgPSB0cnVlOworICAgIGlmIChtX2luZm8uaXNJbXBvcnRl ZEZ1bmN0aW9uRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KSkgeworICAgICAg ICAvLyBGSVhNRSBpbXBvcnRzIGNhbiBiZSBsaW5rZWQgaGVyZSwgaW5zdGVhZCBvZiBnZW5lcmF0 aW5nIGEgcGF0Y2hwb2ludCwgYmVjYXVzZSBhbGwgaW1wb3J0IHN0dWJzIGFyZSBnZW5lcmF0ZWQg YmVmb3JlIEIzIGNvbXBpbGF0aW9uIHN0YXJ0cy4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTE2NjQ2MgorICAgICAgICBFeHByZXNzaW9uVHlwZSBmdW5jdGlvbkltcG9y dCA9IG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KG1fcHJvYywgTG9hZCwg cG9pbnRlclR5cGUoKSwgT3JpZ2luKCksIG1faW5zdGFuY2VWYWx1ZSwgSlNXZWJBc3NlbWJseUlu c3RhbmNlOjpvZmZzZXRPZkltcG9ydEZ1bmN0aW9uKGZ1bmN0aW9uSW5kZXgpKTsKKyAgICAgICAg RXhwcmVzc2lvblR5cGUganNUeXBlT2ZJbXBvcnQgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3 PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQ4WiwgT3JpZ2luKCksIGZ1bmN0aW9uSW1wb3J0LCBK U0NlbGw6OnR5cGVJbmZvVHlwZU9mZnNldCgpKTsKKyAgICAgICAgVmFsdWUqIGlzV2FzbUNhbGwg PSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PFZhbHVlPihtX3Byb2MsIEVxdWFsLCBPcmlnaW4o KSwganNUeXBlT2ZJbXBvcnQsIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8Q29uc3QzMlZhbHVl PihtX3Byb2MsIE9yaWdpbigpLCBXZWJBc3NlbWJseUZ1bmN0aW9uVHlwZSkpOwogCi0gICAgICAg ICAgICBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4qIHVubGlua2VkV2FzbVRvV2FzbUNh bGxzID0gJm1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHM7Ci0gICAgICAgICAgICBwYXRjaHBvaW50 LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAo Q0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7 Ci0gICAgICAgICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93U2Ny YXRjaChqaXQpOworICAgICAgICBCYXNpY0Jsb2NrKiBpc1dhc21CbG9jayA9IG1fcHJvYy5hZGRC bG9jaygpOworICAgICAgICBCYXNpY0Jsb2NrKiBpc0pTQmxvY2sgPSBtX3Byb2MuYWRkQmxvY2so KTsKKyAgICAgICAgQmFzaWNCbG9jayogY29udGludWF0aW9uID0gbV9wcm9jLmFkZEJsb2NrKCk7 CisgICAgICAgIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8VmFsdWU+KG1fcHJvYywgQjM6OkJy YW5jaCwgT3JpZ2luKCksIGlzV2FzbUNhbGwpOworICAgICAgICBtX2N1cnJlbnRCbG9jay0+c2V0 U3VjY2Vzc29ycyhGcmVxdWVudGVkQmxvY2soaXNXYXNtQmxvY2spLCBGcmVxdWVudGVkQmxvY2so aXNKU0Jsb2NrKSk7CisKKyAgICAgICAgaXNXYXNtQmxvY2stPmFkZFByZWRlY2Vzc29yKG1fY3Vy cmVudEJsb2NrKTsKKyAgICAgICAgVmFsdWUqIHdhc21DYWxsUmVzdWx0ID0gd2FzbUNhbGxpbmdD b252ZW50aW9uKCkuc2V0dXBDYWxsKG1fcHJvYywgaXNXYXNtQmxvY2ssIE9yaWdpbigpLCBhcmdz LCB0b0IzVHlwZShyZXR1cm5UeXBlKSwKKyAgICAgICAgICAgIFsmXSAoUGF0Y2hwb2ludFZhbHVl KiBwYXRjaHBvaW50KSB7CisgICAgICAgICAgICAgICAgcGF0Y2hwb2ludC0+ZWZmZWN0cy53cml0 ZXNQaW5uZWQgPSB0cnVlOworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMucmVh ZHNQaW5uZWQgPSB0cnVlOworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPnNldEdlbmVyYXRv cihbdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGZ1bmN0aW9uSW5kZXhdIChDQ2FsbEhlbHBlcnMm IGppdCwgY29uc3QgQjM6OlN0YWNrbWFwR2VuZXJhdGlvblBhcmFtcyYpIHsKKyAgICAgICAgICAg ICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93U2NyYXRjaChqaXQp OworICAgICAgICAgICAgICAgICAgICBDQ2FsbEhlbHBlcnM6OkNhbGwgY2FsbCA9IGppdC5jYWxs KCk7CisgICAgICAgICAgICAgICAgICAgIGppdC5hZGRMaW5rVGFzayhbdW5saW5rZWRXYXNtVG9X YXNtQ2FsbHMsIGNhbGwsIGZ1bmN0aW9uSW5kZXhdIChMaW5rQnVmZmVyJiBsaW5rQnVmZmVyKSB7 CisgICAgICAgICAgICAgICAgICAgICAgICBib29sIHRvSlMgPSBmYWxzZTsgLy8gTWF5YmUgZXh0 ZXJuYWwgd2FzbSAtPiB3YXNtLgorICAgICAgICAgICAgICAgICAgICAgICAgdW5saW5rZWRXYXNt VG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZmZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rp b25JbmRleCwgdG9KUyB9KTsKKyAgICAgICAgICAgICAgICAgICAgfSk7CisgICAgICAgICAgICAg ICAgfSk7CisgICAgICAgICAgICB9KTsKKyAgICAgICAgVXBzaWxvblZhbHVlKiB3YXNtQ2FsbFJl c3VsdFVwc2lsb24gPSBpc1dhc21CbG9jay0+YXBwZW5kTmV3PFVwc2lsb25WYWx1ZT4obV9wcm9j LCBPcmlnaW4oKSwgd2FzbUNhbGxSZXN1bHQpOworICAgICAgICBpc1dhc21CbG9jay0+YXBwZW5k TmV3Q29udHJvbFZhbHVlKG1fcHJvYywgSnVtcCwgT3JpZ2luKCksIGNvbnRpbnVhdGlvbik7CisK KyAgICAgICAgaXNKU0Jsb2NrLT5hZGRQcmVkZWNlc3NvcihtX2N1cnJlbnRCbG9jayk7CisgICAg ICAgIFZhbHVlKiBqc0NhbGxSZXN1bHQgPSB3YXNtQ2FsbGluZ0NvbnZlbnRpb24oKS5zZXR1cENh bGwobV9wcm9jLCBpc0pTQmxvY2ssIE9yaWdpbigpLCBhcmdzLCB0b0IzVHlwZShyZXR1cm5UeXBl KSwKKyAgICAgICAgICAgIFsmXSAoUGF0Y2hwb2ludFZhbHVlKiBwYXRjaHBvaW50KSB7CisgICAg ICAgICAgICAgICAgcGF0Y2hwb2ludC0+ZWZmZWN0cy53cml0ZXNQaW5uZWQgPSB0cnVlOworICAg ICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMucmVhZHNQaW5uZWQgPSB0cnVlOworICAg ICAgICAgICAgICAgIHBhdGNocG9pbnQtPnNldEdlbmVyYXRvcihbdW5saW5rZWRXYXNtVG9XYXNt Q2FsbHMsIGZ1bmN0aW9uSW5kZXhdIChDQ2FsbEhlbHBlcnMmIGppdCwgY29uc3QgQjM6OlN0YWNr bWFwR2VuZXJhdGlvblBhcmFtcyYpIHsKKyAgICAgICAgICAgICAgICAgICAgQWxsb3dNYWNyb1Nj cmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93U2NyYXRjaChqaXQpOworICAgICAgICAgICAgICAgICAg ICBDQ2FsbEhlbHBlcnM6OkNhbGwgY2FsbCA9IGppdC5jYWxsKCk7CisgICAgICAgICAgICAgICAg ICAgIGppdC5hZGRMaW5rVGFzayhbdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGNhbGwsIGZ1bmN0 aW9uSW5kZXhdIChMaW5rQnVmZmVyJiBsaW5rQnVmZmVyKSB7CisgICAgICAgICAgICAgICAgICAg ICAgICBib29sIHRvSlMgPSB0cnVlOyAvLyBFeHRlcm5hbCB3YXNtIC0+IEpTLgorICAgICAgICAg ICAgICAgICAgICAgICAgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZm ZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rpb25JbmRleCwgdG9KUyB9KTsKKyAgICAgICAgICAg ICAgICAgICAgfSk7CisgICAgICAgICAgICAgICAgfSk7CisgICAgICAgICAgICB9KTsKKyAgICAg ICAgVXBzaWxvblZhbHVlKiBqc0NhbGxSZXN1bHRVcHNpbG9uID0gaXNKU0Jsb2NrLT5hcHBlbmRO ZXc8VXBzaWxvblZhbHVlPihtX3Byb2MsIE9yaWdpbigpLCBqc0NhbGxSZXN1bHQpOworICAgICAg ICBpc0pTQmxvY2stPmFwcGVuZE5ld0NvbnRyb2xWYWx1ZShtX3Byb2MsIEp1bXAsIE9yaWdpbigp LCBjb250aW51YXRpb24pOwogCi0gICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNh bGwgPSBqaXQuY2FsbCgpOworICAgICAgICBtX2N1cnJlbnRCbG9jayA9IGNvbnRpbnVhdGlvbjsK KworICAgICAgICByZXN1bHQgPSBjb250aW51YXRpb24tPmFwcGVuZE5ldzxWYWx1ZT4obV9wcm9j LCBQaGksIHRvQjNUeXBlKHJldHVyblR5cGUpLCBPcmlnaW4oKSk7CisgICAgICAgIHdhc21DYWxs UmVzdWx0VXBzaWxvbi0+c2V0UGhpKHJlc3VsdCk7CisgICAgICAgIGpzQ2FsbFJlc3VsdFVwc2ls b24tPnNldFBoaShyZXN1bHQpOwogCi0gICAgICAgICAgICAgICAgaml0LmFkZExpbmtUYXNrKFt1 bmxpbmtlZFdhc21Ub1dhc21DYWxscywgY2FsbCwgZnVuY3Rpb25JbmRleF0gKExpbmtCdWZmZXIm IGxpbmtCdWZmZXIpIHsKLSAgICAgICAgICAgICAgICAgICAgdW5saW5rZWRXYXNtVG9XYXNtQ2Fs bHMtPmFwcGVuZCh7IGxpbmtCdWZmZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rpb25JbmRleCB9 KTsKKyAgICAgICAgLy8gVGhlIGNhbGwgY291bGQgaGF2ZSBiZWVuIHRvIGFub3RoZXIgV2ViQXNz ZW1ibHkgaW5zdGFuY2UsIGluIHdoaWNoIGNhc2Ugd2UgbmVlZCB0byByZXN0b3JlIHRvcEluc3Rh bmNlLCBhbmQgLyBvciBjb3VsZCBoYXZlIG1vZGlmaWVkIG91ciBNZW1vcnkuCisgICAgICAgIHJl c3RvcmVXZWJBc3NlbWJseUdsb2JhbFN0YXRlKG1fdm0sIG1faW5mby5tZW1vcnksIG1faW5zdGFu Y2VWYWx1ZSwgbV9wcm9jLCBjb250aW51YXRpb24pOworICAgIH0gZWxzZSB7CisgICAgICAgIHJl c3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigpLnNldHVwQ2FsbChtX3Byb2MsIG1fY3VycmVu dEJsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0dXJuVHlwZSksCisgICAgICAgICAg ICBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkgeworICAgICAgICAgICAgICAgIHBh dGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBw YXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBw YXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlv bkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25Q YXJhbXMmKSB7CisgICAgICAgICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJV c2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJz OjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICAgICAgICAgICAgICBqaXQuYWRkTGlu a1Rhc2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4XSAoTGlu a0J1ZmZlciYgbGlua0J1ZmZlcikgeworICAgICAgICAgICAgICAgICAgICAgICAgYm9vbCB0b0pT ID0gZmFsc2U7IC8vIEludGVybmFsIHdhc20gLT4gd2FzbS4KKyAgICAgICAgICAgICAgICAgICAg ICAgIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLT5hcHBlbmQoeyBsaW5rQnVmZmVyLmxvY2F0aW9u T2YoY2FsbCksIGZ1bmN0aW9uSW5kZXgsIHRvSlMgfSk7CisgICAgICAgICAgICAgICAgICAgIH0p OwogICAgICAgICAgICAgICAgIH0pOwogICAgICAgICAgICAgfSk7Ci0gICAgICAgIH0pOworICAg IH0KKwogICAgIHJldHVybiB7IH07CiB9CiAKQEAgLTc4NSw2ICs4NzQsOSBAQCBhdXRvIEIzSVJH ZW5lcmF0b3I6OmFkZENhbGxJbmRpcmVjdChjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSwgU2ln bmF0dXJlSW5kZXggcwogICAgICAgICAgICAgfSk7CiAgICAgICAgIH0pOwogCisgICAgLy8gVGhl IGNhbGwgY291bGQgaGF2ZSBiZWVuIHRvIGFub3RoZXIgV2ViQXNzZW1ibHkgaW5zdGFuY2UsIGlu IHdoaWNoIGNhc2Ugd2UgbmVlZCB0byByZXN0b3JlIHRvcEluc3RhbmNlLCBhbmQgLyBvciBjb3Vs ZCBoYXZlIG1vZGlmaWVkIG91ciBNZW1vcnkuCisgICAgcmVzdG9yZVdlYkFzc2VtYmx5R2xvYmFs U3RhdGUobV92bSwgbV9pbmZvLm1lbW9yeSwgbV9pbnN0YW5jZVZhbHVlLCBtX3Byb2MsIG1fY3Vy cmVudEJsb2NrKTsKKwogICAgIHJldHVybiB7IH07CiB9CiAKQEAgLTg1NCwyMCArOTQ2LDggQEAg c3RhdGljIHZvaWQgY3JlYXRlSlNUb1dhc21XcmFwcGVyKFZNJiB2bSwgQ29tcGlsYXRpb25Db250 ZXh0JiBjb21waWxhdGlvbkNvbnRleHQKICAgICAgICAgfSk7CiAgICAgfQogCi0gICAgLy8gTW92 ZSBtZW1vcnkgdmFsdWVzIHRvIHRoZSBhcHByb3JpYXRlIHBsYWNlcywgaWYgbmVlZGVkLgotICAg IFZhbHVlKiBiYXNlTWVtb3J5ID0gbnVsbHB0cjsKLSAgICBWZWN0b3I8VmFsdWUqPiBzaXplczsK LSAgICBpZiAoISFtZW1vcnkpIHsKLSAgICAgICAgYmFzZU1lbW9yeSA9IGJsb2NrLT5hcHBlbmRO ZXc8TWVtb3J5VmFsdWU+KHByb2MsIExvYWQsIEludDY0LCBPcmlnaW4oKSwKLSAgICAgICAgICAg IGJsb2NrLT5hcHBlbmROZXc8Q29uc3RQdHJWYWx1ZT4ocHJvYywgT3JpZ2luKCksICZ2bS50b3BX YXNtTWVtb3J5UG9pbnRlcikpOwotICAgICAgICBWYWx1ZSogc2l6ZSA9IGJsb2NrLT5hcHBlbmRO ZXc8TWVtb3J5VmFsdWU+KHByb2MsIExvYWQsIEludDMyLCBPcmlnaW4oKSwKLSAgICAgICAgICAg IGJsb2NrLT5hcHBlbmROZXc8Q29uc3RQdHJWYWx1ZT4ocHJvYywgT3JpZ2luKCksICZ2bS50b3BX YXNtTWVtb3J5U2l6ZSkpOwotICAgICAgICBzaXplcy5yZXNlcnZlQ2FwYWNpdHkobWVtb3J5LnBp bm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnMuc2l6ZSgpKTsKLSAgICAgICAgZm9yIChhdXRv IGluZm8gOiBtZW1vcnkucGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVycykgewotICAgICAg ICAgICAgc2l6ZXMuYXBwZW5kKGJsb2NrLT5hcHBlbmROZXc8VmFsdWU+KHByb2MsIFN1Yiwgb3Jp Z2luLCBzaXplLAotICAgICAgICAgICAgICAgIGJsb2NrLT5hcHBlbmROZXc8Q29uc3QzMlZhbHVl Pihwcm9jLCBvcmlnaW4sIGluZm8uc2l6ZU9mZnNldCkpKTsKLSAgICAgICAgfQotICAgIH0KKyAg ICBWYWx1ZSogaW5zdGFuY2UgPSBudWxscHRyOyAvLyBTZXQgYnkgdGhlIGNhbGxlciBpbnN0ZWFk LgorICAgIHJlc3RvcmVXZWJBc3NlbWJseUdsb2JhbFN0YXRlKHZtLCBtZW1vcnksIGluc3RhbmNl LCBwcm9jLCBibG9jayk7CiAKICAgICAvLyBHZXQgb3VyIGFyZ3VtZW50cy4KICAgICBWZWN0b3I8 VmFsdWUqPiBhcmd1bWVudHM7CkBAIC04NzcsMTMgKzk1Nyw2IEBAIHN0YXRpYyB2b2lkIGNyZWF0 ZUpTVG9XYXNtV3JhcHBlcihWTSYgdm0sIENvbXBpbGF0aW9uQ29udGV4dCYgY29tcGlsYXRpb25D b250ZXh0CiAKICAgICAvLyBNb3ZlIHRoZSBhcmd1bWVudHMgaW50byBwbGFjZS4KICAgICBWYWx1 ZSogcmVzdWx0ID0gd2FzbUNhbGxpbmdDb252ZW50aW9uKCkuc2V0dXBDYWxsKHByb2MsIGJsb2Nr LCBvcmlnaW4sIGFyZ3VtZW50cywgdG9CM1R5cGUoc2lnbmF0dXJlLT5yZXR1cm5UeXBlKCkpLCBb Jl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkgewotICAgICAgICBpZiAoISFtZW1vcnkp IHsKLSAgICAgICAgICAgIEFTU0VSVChzaXplcy5zaXplKCkgPT0gbWVtb3J5LnBpbm5lZFJlZ2lz dGVycygpLnNpemVSZWdpc3RlcnMuc2l6ZSgpKTsKLSAgICAgICAgICAgIHBhdGNocG9pbnQtPmFw cGVuZChDb25zdHJhaW5lZFZhbHVlKGJhc2VNZW1vcnksIFZhbHVlUmVwOjpyZWcobWVtb3J5LnBp bm5lZFJlZ2lzdGVycygpLmJhc2VNZW1vcnlQb2ludGVyKSkpOwotICAgICAgICAgICAgZm9yICh1 bnNpZ25lZCBpID0gMDsgaSA8IHNpemVzLnNpemUoKTsgKytpKQotICAgICAgICAgICAgICAgIHBh dGNocG9pbnQtPmFwcGVuZChDb25zdHJhaW5lZFZhbHVlKHNpemVzW2ldLCBWYWx1ZVJlcDo6cmVn KG1lbW9yeS5waW5uZWRSZWdpc3RlcnMoKS5zaXplUmVnaXN0ZXJzW2ldLnNpemVSZWdpc3Rlcikp KTsKLSAgICAgICAgfQotCiAgICAgICAgIENvbXBpbGF0aW9uQ29udGV4dCogY29udGV4dCA9ICZj b21waWxhdGlvbkNvbnRleHQ7CiAgICAgICAgIHBhdGNocG9pbnQtPnNldEdlbmVyYXRvcihbY29u dGV4dF0gKENDYWxsSGVscGVycyYgaml0LCBjb25zdCBCMzo6U3RhY2ttYXBHZW5lcmF0aW9uUGFy YW1zJikgewogICAgICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93 U2NyYXRjaChqaXQpOwpAQCAtOTE3LDcgKzk5MCw3IEBAIHN0YXRpYyB2b2lkIGNyZWF0ZUpTVG9X YXNtV3JhcHBlcihWTSYgdm0sIENvbXBpbGF0aW9uQ29udGV4dCYgY29tcGlsYXRpb25Db250ZXh0 CiAgICAgZnVuY3Rpb24uanNUb1dhc21FbnRyeXBvaW50LmNhbGxlZVNhdmVSZWdpc3RlcnMgPSBw cm9jLmNhbGxlZVNhdmVSZWdpc3RlcnMoKTsKIH0KIAotRXhwZWN0ZWQ8c3RkOjp1bmlxdWVfcHRy PFdhc21JbnRlcm5hbEZ1bmN0aW9uPiwgU3RyaW5nPiBwYXJzZUFuZENvbXBpbGUoVk0mIHZtLCBD b21waWxhdGlvbkNvbnRleHQmIGNvbXBpbGF0aW9uQ29udGV4dCwgY29uc3QgdWludDhfdCogZnVu Y3Rpb25TdGFydCwgc2l6ZV90IGZ1bmN0aW9uTGVuZ3RoLCBjb25zdCBTaWduYXR1cmUqIHNpZ25h dHVyZSwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+JiB1bmxpbmtlZFdhc21Ub1dhc21D YWxscywgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiBmdW5jdGlvbkluZGV4U3Bh Y2UsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBpbmZvLCB1bnNpZ25lZCBvcHRMZXZlbCkKK0V4 cGVjdGVkPHN0ZDo6dW5pcXVlX3B0cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0cmluZz4gcGFy c2VBbmRDb21waWxlKFZNJiB2bSwgQ29tcGlsYXRpb25Db250ZXh0JiBjb21waWxhdGlvbkNvbnRl eHQsIGNvbnN0IHVpbnQ4X3QqIGZ1bmN0aW9uU3RhcnQsIHNpemVfdCBmdW5jdGlvbkxlbmd0aCwg Y29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUsIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxs PiYgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBpbmZv LCB1bnNpZ25lZCBvcHRMZXZlbCkKIHsKICAgICBhdXRvIHJlc3VsdCA9IHN0ZDo6bWFrZV91bmlx dWU8V2FzbUludGVybmFsRnVuY3Rpb24+KCk7CiAKQEAgLTkyNSw4ICs5OTgsOCBAQCBFeHBlY3Rl ZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbUludGVybmFsRnVuY3Rpb24+LCBTdHJpbmc+IHBhcnNlQW5k Q29tcGlsZShWTSYgdm0sCiAgICAgY29tcGlsYXRpb25Db250ZXh0Lndhc21FbnRyeXBvaW50SklU ID0gc3RkOjptYWtlX3VuaXF1ZTxDQ2FsbEhlbHBlcnM+KCZ2bSk7CiAKICAgICBQcm9jZWR1cmUg cHJvY2VkdXJlOwotICAgIEIzSVJHZW5lcmF0b3IgY29udGV4dCh2bSwgaW5mbywgcHJvY2VkdXJl LCByZXN1bHQuZ2V0KCksIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4U3Bh Y2UpOwotICAgIEZ1bmN0aW9uUGFyc2VyPEIzSVJHZW5lcmF0b3I+IHBhcnNlcigmdm0sIGNvbnRl eHQsIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWduYXR1cmUsIGZ1bmN0aW9uSW5k ZXhTcGFjZSwgaW5mbyk7CisgICAgQjNJUkdlbmVyYXRvciBjb250ZXh0KHZtLCBpbmZvLCBwcm9j ZWR1cmUsIHJlc3VsdC5nZXQoKSwgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMpOworICAgIEZ1bmN0 aW9uUGFyc2VyPEIzSVJHZW5lcmF0b3I+IHBhcnNlcigmdm0sIGNvbnRleHQsIGZ1bmN0aW9uU3Rh cnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWduYXR1cmUsIGluZm8pOwogICAgIFdBU01fRkFJTF9JRl9I RUxQRVJfRkFJTFMocGFyc2VyLnBhcnNlKCkpOwogCiAgICAgcHJvY2VkdXJlLnJlc2V0UmVhY2hh YmlsaXR5KCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQjNJ UkdlbmVyYXRvci5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0 b3IuaAppbmRleCBiNWM5ZjQ2Li5kODk3NTg1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmgKQEAgLTQ3LDcgKzQ3LDcgQEAgc3RydWN0IENvbXBp bGF0aW9uQ29udGV4dCB7CiAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGpzRW50cnlwb2ludFRvV2Fz bUVudHJ5cG9pbnRDYWxsOwogfTsKIAotRXhwZWN0ZWQ8c3RkOjp1bmlxdWVfcHRyPFdhc21JbnRl cm5hbEZ1bmN0aW9uPiwgU3RyaW5nPiBwYXJzZUFuZENvbXBpbGUoVk0mLCBDb21waWxhdGlvbkNv bnRleHQmLCBjb25zdCB1aW50OF90Kiwgc2l6ZV90LCBjb25zdCBTaWduYXR1cmUqLCBWZWN0b3I8 VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3Bh Y2UmLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYsIHVuc2lnbmVkIG9wdExldmVsID0gMSk7CitF eHBlY3RlZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbUludGVybmFsRnVuY3Rpb24+LCBTdHJpbmc+IHBh cnNlQW5kQ29tcGlsZShWTSYsIENvbXBpbGF0aW9uQ29udGV4dCYsIGNvbnN0IHVpbnQ4X3QqLCBz aXplX3QsIGNvbnN0IFNpZ25hdHVyZSosIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYs IGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiwgdW5zaWduZWQgb3B0TGV2ZWwgPSAxKTsKIAogfSB9 IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbUJpbmRpbmcuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bUJpbmRpbmcuY3BwCmluZGV4IDBlNTkyNDcuLjU4Mzk5MTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtQmluZGluZy5jcHAKQEAgLTM2LDcgKzM2LDcgQEAKIAogbmFtZXNwYWNl IEpTQyB7IG5hbWVzcGFjZSBXYXNtIHsKIAotV2FzbVRvSlNTdHViIGltcG9ydFN0dWJHZW5lcmF0 b3IoVk0qIHZtLCBCYWc8Q2FsbExpbmtJbmZvPiYgY2FsbExpbmtJbmZvcywgU2lnbmF0dXJlSW5k ZXggc2lnbmF0dXJlSW5kZXgsIHVuc2lnbmVkIGltcG9ydEluZGV4KQorc3RhdGljIE1hY3JvQXNz ZW1ibGVyQ29kZVJlZiB3YXNtVG9KUyhWTSogdm0sIEJhZzxDYWxsTGlua0luZm8+JiBjYWxsTGlu a0luZm9zLCBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCwgdW5zaWduZWQgaW1wb3J0SW5k ZXgpCiB7CiAgICAgY29uc3QgV2FzbUNhbGxpbmdDb252ZW50aW9uJiB3YXNtQ0MgPSB3YXNtQ2Fs bGluZ0NvbnZlbnRpb24oKTsKICAgICBjb25zdCBKU0NDYWxsaW5nQ29udmVudGlvbiYganNDQyA9 IGpzY0NhbGxpbmdDb252ZW50aW9uKCk7CkBAIC0yMzEsNyArMjMxLDIxIEBAIFdhc21Ub0pTU3R1 YiBpbXBvcnRTdHViR2VuZXJhdG9yKFZNKiB2bSwgQmFnPENhbGxMaW5rSW5mbz4mIGNhbGxMaW5r SW5mb3MsIFNpZ25hCiAgICAgQ29kZUxvY2F0aW9uTGFiZWwgaG90UGF0aEJlZ2luKHBhdGNoQnVm ZmVyLmxvY2F0aW9uT2YodGFyZ2V0VG9DaGVjaykpOwogICAgIENvZGVMb2NhdGlvbk5lYXJDYWxs IGhvdFBhdGhPdGhlciA9IHBhdGNoQnVmZmVyLmxvY2F0aW9uT2ZOZWFyQ2FsbChmYXN0Q2FsbCk7 CiAgICAgY2FsbExpbmtJbmZvLT5zZXRDYWxsTG9jYXRpb25zKGNhbGxSZXR1cm5Mb2NhdGlvbiwg aG90UGF0aEJlZ2luLCBob3RQYXRoT3RoZXIpOwotICAgIHJldHVybiBGSU5BTElaRV9DT0RFKHBh dGNoQnVmZmVyLCAoIldlYkFzc2VtYmx5IGltcG9ydFslaV0gc3R1YiBmb3Igc2lnbmF0dXJlICVp IiwgaW1wb3J0SW5kZXgsIHNpZ25hdHVyZUluZGV4KSk7CisgICAgU3RyaW5nIHNpZ25hdHVyZURl c2NyaXB0aW9uID0gU2lnbmF0dXJlSW5mb3JtYXRpb246OmdldCh2bSwgc2lnbmF0dXJlSW5kZXgp LT50b1N0cmluZygpOworICAgIHJldHVybiBGSU5BTElaRV9DT0RFKHBhdGNoQnVmZmVyLCAoIldl YkFzc2VtYmx5IGltcG9ydFslaV0gc3R1YiBmb3Igc2lnbmF0dXJlICVpOiAlcyIsIGltcG9ydElu ZGV4LCBzaWduYXR1cmVJbmRleCwgc2lnbmF0dXJlRGVzY3JpcHRpb24uYXNjaWkoKS5kYXRhKCkp KTsKK30KKworc3RhdGljIE1hY3JvQXNzZW1ibGVyQ29kZVJlZiB3YXNtVG9XYXNtKFZNKiB2bSwg QmFnPENhbGxMaW5rSW5mbz4mIGNhbGxMaW5rSW5mb3MsIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVy ZUluZGV4LCB1bnNpZ25lZCBpbXBvcnRJbmRleCkKK3sKKyAgICByZXR1cm4geyB9OyAvLyBGSVhN RSBpbXBsZW1lbnQgdGhpcy4KK30KKworV2FzbUV4aXRTdHVicyBleGl0U3R1YkdlbmVyYXRvcihW TSogdm0sIEJhZzxDYWxsTGlua0luZm8+JiBjYWxsTGlua0luZm9zLCBTaWduYXR1cmVJbmRleCBz aWduYXR1cmVJbmRleCwgdW5zaWduZWQgaW1wb3J0SW5kZXgpCit7CisgICAgV2FzbUV4aXRTdHVi cyBzdHViczsKKyAgICBzdHVicy53YXNtVG9KUyA9IHdhc21Ub0pTKHZtLCBjYWxsTGlua0luZm9z LCBzaWduYXR1cmVJbmRleCwgaW1wb3J0SW5kZXgpOworICAgIHN0dWJzLndhc21Ub1dhc20gPSB3 YXNtVG9XYXNtKHZtLCBjYWxsTGlua0luZm9zLCBzaWduYXR1cmVJbmRleCwgaW1wb3J0SW5kZXgp OworICAgIHJldHVybiBzdHViczsKIH0KIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KZGlm ZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmggYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5oCmluZGV4IGZkN2UwM2QuLjQwMjFm MTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmgK KysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuaApAQCAtMzgsNyAr MzgsNyBAQCBjbGFzcyBDYWxsTGlua0luZm87CiAKIG5hbWVzcGFjZSBXYXNtIHsKIAotV2FzbVRv SlNTdHViIGltcG9ydFN0dWJHZW5lcmF0b3IoVk0qLCBCYWc8Q2FsbExpbmtJbmZvPiYsIFNpZ25h dHVyZUluZGV4LCB1bnNpZ25lZCk7CitXYXNtRXhpdFN0dWJzIGV4aXRTdHViR2VuZXJhdG9yKFZN KiwgQmFnPENhbGxMaW5rSW5mbz4mLCBTaWduYXR1cmVJbmRleCwgdW5zaWduZWQpOwogCiB9IH0g Ly8gbmFtZXNwYWNlIEpTQzo6V2FzbQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtRm9ybWF0LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRm9y bWF0LmgKaW5kZXggMzU5ZGRjYy4uYjZkYWRlOSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbUZvcm1hdC5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21Gb3JtYXQuaApAQCAtMTg3LDcgKzE4Nyw3IEBAIHByaXZhdGU6CiB9OwogCiBzdHJ1Y3Qg TW9kdWxlSW5mb3JtYXRpb24gewotICAgIFZlY3RvcjxTaWduYXR1cmVJbmRleD4gc2lnbmF0dXJl SW5kaWNlczsKKyAgICBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+IG1vZHVsZVNpZ25hdHVyZUluZGlj ZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzOwogICAgIFZlY3RvcjxJbXBvcnQ+IGltcG9ydHM7 CiAgICAgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiBpbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGlj ZXM7CiAgICAgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiBpbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJl SW5kaWNlczsKQEAgLTE5OSw2ICsxOTksMTggQEAgc3RydWN0IE1vZHVsZUluZm9ybWF0aW9uIHsK ICAgICBUYWJsZUluZm9ybWF0aW9uIHRhYmxlSW5mb3JtYXRpb247CiAgICAgVmVjdG9yPEdsb2Jh bD4gZ2xvYmFsczsKICAgICB1bnNpZ25lZCBmaXJzdEludGVybmFsR2xvYmFsIHsgMCB9OworICAg IHNpemVfdCBmdW5jdGlvbkluZGV4U3BhY2VTaXplKCkgY29uc3QgeyByZXR1cm4gaW1wb3J0RnVu Y3Rpb25TaWduYXR1cmVJbmRpY2VzLnNpemUoKSArIGludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJ bmRpY2VzLnNpemUoKTsgfQorICAgIGJvb2wgaXNJbXBvcnRlZEZ1bmN0aW9uRnJvbUZ1bmN0aW9u SW5kZXhTcGFjZShzaXplX3QgZnVuY3Rpb25JbmRleCkgY29uc3QKKyAgICB7CisgICAgICAgIEFT U0VSVChmdW5jdGlvbkluZGV4IDwgZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpKTsKKyAgICAgICAg cmV0dXJuIGZ1bmN0aW9uSW5kZXggPCBpbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMuc2l6 ZSgpOworICAgIH0KKyAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleEZyb21GdW5jdGlv bkluZGV4U3BhY2Uoc2l6ZV90IGZ1bmN0aW9uSW5kZXgpIGNvbnN0CisgICAgeworICAgICAgICBy ZXR1cm4gaXNJbXBvcnRlZEZ1bmN0aW9uRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbklu ZGV4KQorICAgICAgICAgICAgPyBpbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXNbZnVuY3Rp b25JbmRleF0KKyAgICAgICAgICAgIDogaW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXNb ZnVuY3Rpb25JbmRleCAtIGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCldOwor ICAgIH0KIAogICAgIH5Nb2R1bGVJbmZvcm1hdGlvbigpOwogfTsKQEAgLTIwNiw2ICsyMTgsNyBA QCBzdHJ1Y3QgTW9kdWxlSW5mb3JtYXRpb24gewogc3RydWN0IFVubGlua2VkV2FzbVRvV2FzbUNh bGwgewogICAgIENvZGVMb2NhdGlvbkNhbGwgY2FsbExvY2F0aW9uOwogICAgIHNpemVfdCBmdW5j dGlvbkluZGV4OworICAgIGJvb2wgdG9KUzsKIH07CiAKIHN0cnVjdCBFbnRyeXBvaW50IHsKQEAg LTIyMSw3ICsyMzQsMTAgQEAgc3RydWN0IFdhc21JbnRlcm5hbEZ1bmN0aW9uIHsKICAgICBFbnRy eXBvaW50IGpzVG9XYXNtRW50cnlwb2ludDsKIH07CiAKLXR5cGVkZWYgTWFjcm9Bc3NlbWJsZXJD b2RlUmVmIFdhc21Ub0pTU3R1YjsKK3N0cnVjdCBXYXNtRXhpdFN0dWJzIHsKKyAgICBNYWNyb0Fz c2VtYmxlckNvZGVSZWYgd2FzbVRvSlM7CisgICAgTWFjcm9Bc3NlbWJsZXJDb2RlUmVmIHdhc21U b1dhc207Cit9OwogCiAvLyBXZWJBc3NlbWJseSBkaXJlY3QgY2FsbHMgYW5kIGNhbGxfaW5kaXJl Y3QgdXNlIGluZGljZXMgaW50byAiZnVuY3Rpb24gaW5kZXggc3BhY2UiLiBUaGlzIHNwYWNlIHN0 YXJ0cyB3aXRoIGFsbCBpbXBvcnRzLCBhbmQgdGhlbiBhbGwgaW50ZXJuYWwgZnVuY3Rpb25zLgog Ly8gQ2FsbGFibGVGdW5jdGlvbiBhbmQgRnVuY3Rpb25JbmRleFNwYWNlIGFyZSBvbmx5IG1lYW50 IGFzIGZhc3QgbG9va3VwIHRhYmxlcyBmb3IgdGhlc2Ugb3Bjb2RlcywgYW5kIGRvIG5vdCBvd24g Y29kZS4KQEAgLTI0MCwxMiArMjU2LDYgQEAgc3RydWN0IENhbGxhYmxlRnVuY3Rpb24gewogfTsK IHR5cGVkZWYgVmVjdG9yPENhbGxhYmxlRnVuY3Rpb24+IEZ1bmN0aW9uSW5kZXhTcGFjZTsKIAot Ci1zdHJ1Y3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlIHsKLSAgICBNYWxsb2NQdHI8Q2Fs bGFibGVGdW5jdGlvbj4gYnVmZmVyOwotICAgIHNpemVfdCBzaXplOwotfTsKLQogfSB9IC8vIG5h bWVzcGFjZSBKU0M6Oldhc20KIAogI2VuZGlmIC8vIEVOQUJMRShXRUJBU1NFTUJMWSkKZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21GdW5jdGlvblBhcnNlci5oIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmgKaW5kZXggYTYw YWM0Ny4uM2VjYjM5MyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bUZ1bmN0aW9uUGFyc2VyLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1 bmN0aW9uUGFyc2VyLmgKQEAgLTQ2LDcgKzQ2LDcgQEAgcHVibGljOgogICAgIHR5cGVkZWYgdHlw ZW5hbWUgQ29udGV4dDo6Q29udHJvbFR5cGUgQ29udHJvbFR5cGU7CiAgICAgdHlwZWRlZiB0eXBl bmFtZSBDb250ZXh0OjpFeHByZXNzaW9uTGlzdCBFeHByZXNzaW9uTGlzdDsKIAotICAgIEZ1bmN0 aW9uUGFyc2VyKFZNKiwgQ29udGV4dCYsIGNvbnN0IHVpbnQ4X3QqIGZ1bmN0aW9uU3RhcnQsIHNp emVfdCBmdW5jdGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiwgY29uc3QgSW1tdXRhYmxlRnVu Y3Rpb25JbmRleFNwYWNlJiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mKTsKKyAgICBGdW5jdGlv blBhcnNlcihWTSosIENvbnRleHQmLCBjb25zdCB1aW50OF90KiBmdW5jdGlvblN0YXJ0LCBzaXpl X3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSosIGNvbnN0IE1vZHVsZUluZm9ybWF0 aW9uJik7CiAKICAgICBSZXN1bHQgV0FSTl9VTlVTRURfUkVUVVJOIHBhcnNlKCk7CiAKQEAgLTgy LDE3ICs4MiwxNSBAQCBwcml2YXRlOgogICAgIEV4cHJlc3Npb25MaXN0IG1fZXhwcmVzc2lvblN0 YWNrOwogICAgIFZlY3RvcjxDb250cm9sRW50cnk+IG1fY29udHJvbFN0YWNrOwogICAgIGNvbnN0 IFNpZ25hdHVyZSogbV9zaWduYXR1cmU7Ci0gICAgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRl eFNwYWNlJiBtX2Z1bmN0aW9uSW5kZXhTcGFjZTsKICAgICBjb25zdCBNb2R1bGVJbmZvcm1hdGlv biYgbV9pbmZvOwogICAgIHVuc2lnbmVkIG1fdW5yZWFjaGFibGVCbG9ja3MgeyAwIH07CiB9Owog CiB0ZW1wbGF0ZTx0eXBlbmFtZSBDb250ZXh0PgotRnVuY3Rpb25QYXJzZXI8Q29udGV4dD46OkZ1 bmN0aW9uUGFyc2VyKFZNKiB2bSwgQ29udGV4dCYgY29udGV4dCwgY29uc3QgdWludDhfdCogZnVu Y3Rpb25TdGFydCwgc2l6ZV90IGZ1bmN0aW9uTGVuZ3RoLCBjb25zdCBTaWduYXR1cmUqIHNpZ25h dHVyZSwgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiBmdW5jdGlvbkluZGV4U3Bh Y2UsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBpbmZvKQorRnVuY3Rpb25QYXJzZXI8Q29udGV4 dD46OkZ1bmN0aW9uUGFyc2VyKFZNKiB2bSwgQ29udGV4dCYgY29udGV4dCwgY29uc3QgdWludDhf dCogZnVuY3Rpb25TdGFydCwgc2l6ZV90IGZ1bmN0aW9uTGVuZ3RoLCBjb25zdCBTaWduYXR1cmUq IHNpZ25hdHVyZSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8pCiAgICAgOiBQYXJzZXIo dm0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoKQogICAgICwgbV9jb250ZXh0KGNvbnRl eHQpCiAgICAgLCBtX3NpZ25hdHVyZShzaWduYXR1cmUpCi0gICAgLCBtX2Z1bmN0aW9uSW5kZXhT cGFjZShmdW5jdGlvbkluZGV4U3BhY2UpCiAgICAgLCBtX2luZm8oaW5mbykKIHsKICAgICBpZiAo dmVyYm9zZSkKQEAgLTMwOCw5ICszMDYsOSBAQCBhdXRvIEZ1bmN0aW9uUGFyc2VyPENvbnRleHQ+ OjpwYXJzZUV4cHJlc3Npb24oT3BUeXBlIG9wKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgY2FzZSBD YWxsOiB7CiAgICAgICAgIHVpbnQzMl90IGZ1bmN0aW9uSW5kZXg7CiAgICAgICAgIFdBU01fUEFS U0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKGZ1bmN0aW9uSW5kZXgpLCAiY2FuJ3QgcGFyc2Ug Y2FsbCdzIGZ1bmN0aW9uIGluZGV4Iik7Ci0gICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVu Y3Rpb25JbmRleCA+PSBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5zaXplLCAiY2FsbCBmdW5jdGlvbiBp bmRleCAiLCBmdW5jdGlvbkluZGV4LCAiIGV4Y2VlZHMgZnVuY3Rpb24gaW5kZXggc3BhY2UgIiwg bV9mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSk7CisgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYo ZnVuY3Rpb25JbmRleCA+PSBtX2luZm8uZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpLCAiY2FsbCBm dW5jdGlvbiBpbmRleCAiLCBmdW5jdGlvbkluZGV4LCAiIGV4Y2VlZHMgZnVuY3Rpb24gaW5kZXgg c3BhY2UgIiwgbV9pbmZvLmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSk7CiAKLSAgICAgICAgU2ln bmF0dXJlSW5kZXggY2FsbGVlU2lnbmF0dXJlSW5kZXggPSBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5i dWZmZXIuZ2V0KClbZnVuY3Rpb25JbmRleF0uc2lnbmF0dXJlSW5kZXg7CisgICAgICAgIFNpZ25h dHVyZUluZGV4IGNhbGxlZVNpZ25hdHVyZUluZGV4ID0gbV9pbmZvLnNpZ25hdHVyZUluZGV4RnJv bUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KTsKICAgICAgICAgY29uc3QgU2lnbmF0 dXJlKiBjYWxsZWVTaWduYXR1cmUgPSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KG1fdm0sIGNh bGxlZVNpZ25hdHVyZUluZGV4KTsKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihjYWxsZWVT aWduYXR1cmUtPmFyZ3VtZW50Q291bnQoKSA+IG1fZXhwcmVzc2lvblN0YWNrLnNpemUoKSwgImNh bGwgZnVuY3Rpb24gaW5kZXggIiwgZnVuY3Rpb25JbmRleCwgIiBoYXMgIiwgY2FsbGVlU2lnbmF0 dXJlLT5hcmd1bWVudENvdW50KCksICIgYXJndW1lbnRzLCBidXQgdGhlIGV4cHJlc3Npb24gc3Rh Y2sgY3VycmVudGx5IGhvbGRzICIsIG1fZXhwcmVzc2lvblN0YWNrLnNpemUoKSwgIiB2YWx1ZXMi KTsKIApAQCAtMzM3LDkgKzMzNSw5IEBAIGF1dG8gRnVuY3Rpb25QYXJzZXI8Q29udGV4dD46OnBh cnNlRXhwcmVzc2lvbihPcFR5cGUgb3ApIC0+IFBhcnRpYWxSZXN1bHQKICAgICAgICAgV0FTTV9Q QVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoc2lnbmF0dXJlSW5kZXgpLCAiY2FuJ3QgZ2V0 IGNhbGxfaW5kaXJlY3QncyBzaWduYXR1cmUgaW5kZXgiKTsKICAgICAgICAgV0FTTV9QQVJTRVJf RkFJTF9JRighcGFyc2VWYXJVSW50MShyZXNlcnZlZCksICJjYW4ndCBnZXQgY2FsbF9pbmRpcmVj dCdzIHJlc2VydmVkIGJ5dGUiKTsKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihyZXNlcnZl ZCwgImNhbGxfaW5kaXJlY3QncyAncmVzZXJ2ZWQnIHZhcnVpbnQxIG11c3QgYmUgMHgwIik7Ci0g ICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYobV9pbmZvLnNpZ25hdHVyZUluZGljZXMuc2l6ZSgp IDw9IHNpZ25hdHVyZUluZGV4LCAiY2FsbF9pbmRpcmVjdCdzIHNpZ25hdHVyZSBpbmRleCAiLCBz aWduYXR1cmVJbmRleCwgIiBleGNlZWRzIGtub3duIHNpZ25hdHVyZXMgIiwgbV9pbmZvLnNpZ25h dHVyZUluZGljZXMuc2l6ZSgpKTsKKyAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihtX2luZm8u bW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMuc2l6ZSgpIDw9 IHNpZ25hdHVyZUluZGV4LCAiY2FsbF9pbmRpcmVjdCdzIHNpZ25hdHVyZSBpbmRleCAiLCBzaWdu YXR1cmVJbmRleCwgIiBleGNlZWRzIGtub3duIHNpZ25hdHVyZXMgIiwgbV9pbmZvLm1vZHVsZVNp Z25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzLnNpemUoKSk7CiAKLSAgICAg ICAgU2lnbmF0dXJlSW5kZXggY2FsbGVlU2lnbmF0dXJlSW5kZXggPSBtX2luZm8uc2lnbmF0dXJl SW5kaWNlc1tzaWduYXR1cmVJbmRleF07CisgICAgICAgIFNpZ25hdHVyZUluZGV4IGNhbGxlZVNp Z25hdHVyZUluZGV4ID0gbV9pbmZvLm1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWdu YXR1cmVJbmRpY2VzW3NpZ25hdHVyZUluZGV4XTsKICAgICAgICAgY29uc3QgU2lnbmF0dXJlKiBj YWxsZWVTaWduYXR1cmUgPSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KG1fdm0sIGNhbGxlZVNp Z25hdHVyZUluZGV4KTsKICAgICAgICAgc2l6ZV90IGFyZ3VtZW50Q291bnQgPSBjYWxsZWVTaWdu YXR1cmUtPmFyZ3VtZW50Q291bnQoKSArIDE7IC8vIEFkZCB0aGUgY2FsbGVlJ3MgaW5kZXguCiAg ICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoYXJndW1lbnRDb3VudCA+IG1fZXhwcmVzc2lvblN0 YWNrLnNpemUoKSwgImNhbGxfaW5kaXJlY3QgZXhwZWN0cyAiLCBhcmd1bWVudENvdW50LCAiIGFy Z3VtZW50cywgYnV0IHRoZSBleHByZXNzaW9uIHN0YWNrIGN1cnJlbnRseSBob2xkcyAiLCBtX2V4 cHJlc3Npb25TdGFjay5zaXplKCksICIgdmFsdWVzIik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21NZW1vcnkuY3BwCmluZGV4IGYxOWVjZTAuLjFlOWM5YmYgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwCisrKyBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwCkBAIC0zMSwxMSArMzEsMTEgQEAKIG5hbWVz cGFjZSBKU0MgeyBuYW1lc3BhY2UgV2FzbSB7CiAKIE1lbW9yeTo6TWVtb3J5KFBhZ2VDb3VudCBp bml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSkKLSAgICA6IG1fbW9kZShNb2RlOjpCb3VuZHNDaGVj a2luZykKLSAgICAsIG1fc2l6ZShpbml0aWFsLmJ5dGVzKCkpCisgICAgOiBtX3NpemUoaW5pdGlh bC5ieXRlcygpKQogICAgICwgbV9jYXBhY2l0eShtYXhpbXVtID8gbWF4aW11bS5ieXRlcygpIDog UGFnZUNvdW50OjptYXgoKS5ieXRlcygpKQogICAgICwgbV9pbml0aWFsKGluaXRpYWwpCiAgICAg LCBtX21heGltdW0obWF4aW11bSkKKyAgICAsIG1fbW9kZShNb2RlOjpCb3VuZHNDaGVja2luZykK ICAgICAvLyBGSVhNRTogSWYgd2UgYWRkIHNpZ25hbCBiYXNlZCBib3VuZHMgY2hlY2tpbmcgdGhl biB3ZSBuZWVkIGV4dHJhIHNwYWNlIGZvciBvdmVyZmxvdyBvbiBsb2FkLgogICAgIC8vIHNlZTog aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MjY5MwogewpkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5oIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5oCmluZGV4IGI0MTFmMzQ4Li40MzA0NzY5IDEw MDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmgKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5oCkBAIC0zOCw2ICszOCw3IEBA IGNsYXNzIE1lbW9yeSB7CiAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoTWVtb3J5KTsKICAgICBX VEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKIHB1YmxpYzoKKyAgICBNZW1vcnkoTWVtb3J5JiYpID0g ZGVmYXVsdDsKIAogICAgIC8vIEZJWE1FOiBXZSBzaG91bGQgc3VwcG9ydCBvdGhlciBtb2Rlcy4g c2VlOiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYyNjkzCiAgICAg ZW51bSBjbGFzcyBNb2RlIHsKQEAgLTU3LDExICs1OCwxMSBAQCBwdWJsaWM6CiAgICAgdm9pZCog bWVtb3J5KCkgY29uc3QgeyByZXR1cm4gbV9tZW1vcnk7IH0KICAgICB1aW50MzJfdCBzaXplKCkg Y29uc3QgeyByZXR1cm4gbV9zaXplOyB9CiAKLSAgICBNb2RlIG1vZGUoKSBjb25zdCB7IHJldHVy biBtX21vZGU7IH0KLQogICAgIFBhZ2VDb3VudCBpbml0aWFsKCkgY29uc3QgeyByZXR1cm4gbV9p bml0aWFsOyB9CiAgICAgUGFnZUNvdW50IG1heGltdW0oKSBjb25zdCB7IHJldHVybiBtX21heGlt dW07IH0KIAorICAgIE1vZGUgbW9kZSgpIGNvbnN0IHsgcmV0dXJuIG1fbW9kZTsgfQorCiAgICAg Ym9vbCBncm93KHVpbnQzMl90IG5ld1NpemUpCiAgICAgewogICAgICAgICBBU1NFUlQobV9tZW1v cnkpOwpAQCAtNzEsMTcgKzcyLDE4IEBAIHB1YmxpYzoKICAgICAgICAgcmV0dXJuICFtcHJvdGVj dChtX21lbW9yeSwgbmV3U2l6ZSwgUFJPVF9SRUFEIHwgUFJPVF9XUklURSk7CiAgICAgfQogCisg ICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZk1lbW9yeSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZT RVRPRihNZW1vcnksIG1fbWVtb3J5KTsgfQogICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZT aXplKCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKE1lbW9yeSwgbV9zaXplKTsgfQogCiAgICAg CiBwcml2YXRlOgogICAgIHZvaWQqIG1fbWVtb3J5IHsgbnVsbHB0ciB9OwotICAgIE1vZGUgbV9t b2RlOwogICAgIHVpbnQzMl90IG1fc2l6ZSB7IDAgfTsKICAgICB1aW50MzJfdCBtX2NhcGFjaXR5 IHsgMCB9OwogICAgIFBhZ2VDb3VudCBtX2luaXRpYWw7CiAgICAgUGFnZUNvdW50IG1fbWF4aW11 bTsKICAgICB1aW50NjRfdCBtX21hcHBlZENhcGFjaXR5IHsgMCB9OworICAgIE1vZGUgbV9tb2Rl IHsgTW9kZTo6Qm91bmRzQ2hlY2tpbmcgfTsKIH07CiAKIH0gfSAvLyBuYW1lc3BhY2UgSlNDOjpX YXNtCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFy c2VyLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3Bw CmluZGV4IDg5MTg0NzUuLjUyZmViYWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCkBAIC05OSw3ICs5OSw3IEBAIGF1dG8gTW9kdWxlUGFy c2VyOjpwYXJzZVR5cGUoKSAtPiBQYXJ0aWFsUmVzdWx0CiAKICAgICBXQVNNX1BBUlNFUl9GQUlM X0lGKCFwYXJzZVZhclVJbnQzMihjb3VudCksICJjYW4ndCBnZXQgVHlwZSBzZWN0aW9uJ3MgY291 bnQiKTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGNvdW50ID09IHN0ZDo6bnVtZXJpY19saW1p dHM8dWludDMyX3Q+OjptYXgoKSwgIlR5cGUgc2VjdGlvbidzIGNvdW50IGlzIHRvbyBiaWcgIiwg Y291bnQpOwotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0 dXJlSW5kaWNlcy50cnlSZXNlcnZlQ2FwYWNpdHkoY291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5v dWdoIG1lbW9yeSBmb3IgVHlwZSBzZWN0aW9uJ3MgIiwgY291bnQsICIgZW50cmllcyIpOworICAg IFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0Lm1vZHVsZS0+bW9kdWxlU2lnbmF0dXJlSW5k aWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50KSwg ImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yIFR5cGUgc2VjdGlvbidzICIsIGNvdW50 LCAiIGVudHJpZXMiKTsKIAogICAgIGZvciAodWludDMyX3QgaSA9IDA7IGkgPCBjb3VudDsgKytp KSB7CiAgICAgICAgIGludDhfdCB0eXBlOwpAQCAtMTMxLDcgKzEzMSw3IEBAIGF1dG8gTW9kdWxl UGFyc2VyOjpwYXJzZVR5cGUoKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgICAgIHNpZ25hdHVyZS0+ cmV0dXJuVHlwZSgpID0gcmV0dXJuVHlwZTsKIAogICAgICAgICBTaWduYXR1cmVJbmRleCBzaWdu YXR1cmVJbmRleCA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjphZG9wdChtX3ZtLCBzaWduYXR1cmUu cmVsZWFzZSgpKTsKLSAgICAgICAgbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnVu Y2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7CisgICAgICAgIG1fcmVzdWx0Lm1vZHVsZS0+ bW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMudW5jaGVja2Vk QXBwZW5kKHNpZ25hdHVyZUluZGV4KTsKICAgICB9CiAgICAgcmV0dXJuIHsgfTsKIH0KQEAgLTE0 NCw3ICsxNDQsNiBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VJbXBvcnQoKSAtPiBQYXJ0aWFs UmVzdWx0CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlLT5nbG9iYWxz LnRyeVJlc2VydmVDYXBhY2l0eShpbXBvcnRDb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2gg bWVtb3J5IGZvciAiLCBpbXBvcnRDb3VudCwgIiBnbG9iYWxzIik7IC8vIEZJWE1FIHRoaXMgb3Zl ci1hbGxvY2F0ZXMgd2hlbiB3ZSBmaXggdGhlIEZJWE1FcyBiZWxvdy4KICAgICBXQVNNX1BBUlNF Ul9GQUlMX0lGKCFtX3Jlc3VsdC5tb2R1bGUtPmltcG9ydHMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGlt cG9ydENvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGltcG9ydENv dW50LCAiIGltcG9ydHMiKTsgLy8gRklYTUUgdGhpcyBvdmVyLWFsbG9jYXRlcyB3aGVuIHdlIGZp eCB0aGUgRklYTUVzIGJlbG93LgogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0Lm1v ZHVsZS0+aW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnRyeVJlc2VydmVDYXBhY2l0eShp bXBvcnRDb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBpbXBvcnRD b3VudCwgIiBpbXBvcnQgZnVuY3Rpb24gc2lnbmF0dXJlcyIpOyAvLyBGSVhNRSB0aGlzIG92ZXIt YWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBGSVhNRXMgYmVsb3cuCi0gICAgV0FTTV9QQVJTRVJf RkFJTF9JRighbV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnRyeVJlc2VydmVDYXBhY2l0eShp bXBvcnRDb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBpbXBvcnRD b3VudCwgIiBmdW5jdGlvbnMgaW4gdGhlIGluZGV4IHNwYWNlIik7IC8vIEZJWE1FIHRoaXMgb3Zl ci1hbGxvY2F0ZXMgd2hlbiB3ZSBmaXggdGhlIEZJWE1FcyBiZWxvdy4gV2UnbGwgYWxsb2NhdGUg c29tZSBtb3JlIGhlcmUgd2hlbiB3ZSBrbm93IGhvdyBtYW55IGZ1bmN0aW9ucyB0byBleHBlY3Qu CiAKICAgICBmb3IgKHVpbnQzMl90IGltcG9ydE51bWJlciA9IDA7IGltcG9ydE51bWJlciA8IGlt cG9ydENvdW50OyArK2ltcG9ydE51bWJlcikgewogICAgICAgICBJbXBvcnQgaW1wOwpAQCAtMTY2 LDExICsxNjUsMTAgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlSW1wb3J0KCkgLT4gUGFydGlh bFJlc3VsdAogICAgICAgICBjYXNlIEV4dGVybmFsS2luZDo6RnVuY3Rpb246IHsKICAgICAgICAg ICAgIHVpbnQzMl90IGZ1bmN0aW9uU2lnbmF0dXJlSW5kZXg7CiAgICAgICAgICAgICBXQVNNX1BB UlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihmdW5jdGlvblNpZ25hdHVyZUluZGV4KSwgImNh bid0IGdldCAiLCBpbXBvcnROdW1iZXIsICJ0aCBJbXBvcnQncyBmdW5jdGlvbiBzaWduYXR1cmUg aW4gbW9kdWxlICciLCBtb2R1bGVTdHJpbmcsICInIGZpZWxkICciLCBmaWVsZFN0cmluZywgIici KTsKLSAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVuY3Rpb25TaWduYXR1cmVJbmRl eCA+PSBtX3Jlc3VsdC5tb2R1bGUtPnNpZ25hdHVyZUluZGljZXMuc2l6ZSgpLCAiaW52YWxpZCBm dW5jdGlvbiBzaWduYXR1cmUgZm9yICIsIGltcG9ydE51bWJlciwgInRoIEltcG9ydCwgIiwgZnVu Y3Rpb25TaWduYXR1cmVJbmRleCwgIiBpcyBvdXQgb2YgcmFuZ2Ugb2YgIiwgbV9yZXN1bHQubW9k dWxlLT5zaWduYXR1cmVJbmRpY2VzLnNpemUoKSwgIiBpbiBtb2R1bGUgJyIsIG1vZHVsZVN0cmlu ZywgIicgZmllbGQgJyIsIGZpZWxkU3RyaW5nLCAiJyIpOworICAgICAgICAgICAgV0FTTV9QQVJT RVJfRkFJTF9JRihmdW5jdGlvblNpZ25hdHVyZUluZGV4ID49IG1fcmVzdWx0Lm1vZHVsZS0+bW9k dWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMuc2l6ZSgpLCAiaW52 YWxpZCBmdW5jdGlvbiBzaWduYXR1cmUgZm9yICIsIGltcG9ydE51bWJlciwgInRoIEltcG9ydCwg IiwgZnVuY3Rpb25TaWduYXR1cmVJbmRleCwgIiBpcyBvdXQgb2YgcmFuZ2Ugb2YgIiwgbV9yZXN1 bHQubW9kdWxlLT5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNl cy5zaXplKCksICIgaW4gbW9kdWxlICciLCBtb2R1bGVTdHJpbmcsICInIGZpZWxkICciLCBmaWVs ZFN0cmluZywgIiciKTsKICAgICAgICAgICAgIGltcC5raW5kSW5kZXggPSBtX3Jlc3VsdC5tb2R1 bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCk7Ci0gICAgICAgICAgICBT aWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJl SW5kaWNlc1tmdW5jdGlvblNpZ25hdHVyZUluZGV4XTsKKyAgICAgICAgICAgIFNpZ25hdHVyZUlu ZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlLT5tb2R1bGVTaWduYXR1cmVJbmRp Y2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvblNpZ25hdHVyZUluZGV4XTsKICAg ICAgICAgICAgIG1fcmVzdWx0Lm1vZHVsZS0+aW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2Vz LnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7Ci0gICAgICAgICAgICBtX3Jlc3VsdC5m dW5jdGlvbkluZGV4U3BhY2UudW5jaGVja2VkQXBwZW5kKHNpZ25hdHVyZUluZGV4KTsKICAgICAg ICAgICAgIGJyZWFrOwogICAgICAgICB9CiAgICAgICAgIGNhc2UgRXh0ZXJuYWxLaW5kOjpUYWJs ZTogewpAQCAtMjEyLDIwICsyMTAsMTggQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlRnVuY3Rp b24oKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihjb3VudCA9PSBz dGQ6Om51bWVyaWNfbGltaXRzPHVpbnQzMl90Pjo6bWF4KCksICJGdW5jdGlvbiBzZWN0aW9uJ3Mg Y291bnQgaXMgdG9vIGJpZyAiLCBjb3VudCk7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9y ZXN1bHQubW9kdWxlLT5pbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy50cnlSZXNlcnZl Q2FwYWNpdHkoY291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgY291 bnQsICIgRnVuY3Rpb24gc2lnbmF0dXJlcyIpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1f cmVzdWx0LmZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeS50cnlSZXNlcnZlQ2FwYWNpdHkoY291bnQp LCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgY291bnQsICJGdW5jdGlvbiBs b2NhdGlvbnMiKTsKLSAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX3Jlc3VsdC5mdW5jdGlvbklu ZGV4U3BhY2UudHJ5UmVzZXJ2ZUNhcGFjaXR5KG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5z aXplKCkgKyBjb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBjb3Vu dCwgIiBtb3JlIGZ1bmN0aW9ucyBpbiB0aGUgZnVuY3Rpb24gaW5kZXggc3BhY2UiKTsKIAogICAg IGZvciAodWludDMyX3QgaSA9IDA7IGkgPCBjb3VudDsgKytpKSB7CiAgICAgICAgIHVpbnQzMl90 IHR5cGVOdW1iZXI7CiAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMy KHR5cGVOdW1iZXIpLCAiY2FuJ3QgZ2V0ICIsIGksICJ0aCBGdW5jdGlvbidzIHR5cGUgbnVtYmVy Iik7Ci0gICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYodHlwZU51bWJlciA+PSBtX3Jlc3VsdC5t b2R1bGUtPnNpZ25hdHVyZUluZGljZXMuc2l6ZSgpLCBpLCAidGggRnVuY3Rpb24gdHlwZSBudW1i ZXIgaXMgaW52YWxpZCAiLCB0eXBlTnVtYmVyKTsKKyAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9J Rih0eXBlTnVtYmVyID49IG1fcmVzdWx0Lm1vZHVsZS0+bW9kdWxlU2lnbmF0dXJlSW5kaWNlc1Rv VW5pcXVlZFNpZ25hdHVyZUluZGljZXMuc2l6ZSgpLCBpLCAidGggRnVuY3Rpb24gdHlwZSBudW1i ZXIgaXMgaW52YWxpZCAiLCB0eXBlTnVtYmVyKTsKIAotICAgICAgICBTaWduYXR1cmVJbmRleCBz aWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlc1t0eXBlTnVt YmVyXTsKKyAgICAgICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtX3Jlc3VsdC5t b2R1bGUtPm1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzW3R5 cGVOdW1iZXJdOwogICAgICAgICAvLyBUaGUgQ29kZSBzZWN0aW9uIGZpeGVzIHVwIHN0YXJ0IGFu ZCBlbmQuCiAgICAgICAgIHNpemVfdCBzdGFydCA9IDA7CiAgICAgICAgIHNpemVfdCBlbmQgPSAw OwogICAgICAgICBtX3Jlc3VsdC5tb2R1bGUtPmludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRp Y2VzLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7CiAgICAgICAgIG1fcmVzdWx0LmZ1 bmN0aW9uTG9jYXRpb25JbkJpbmFyeS51bmNoZWNrZWRBcHBlbmQoeyBzdGFydCwgZW5kIH0pOwot ICAgICAgICBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2UudW5jaGVja2VkQXBwZW5kKHNpZ25h dHVyZUluZGV4KTsKICAgICB9CiAKICAgICByZXR1cm4geyB9OwpAQCAtMzk2LDcgKzM5Miw3IEBA IGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZUV4cG9ydCgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICAg ICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoZXhwLmtpbmRJbmRleCksICJj YW4ndCBnZXQgIiwgZXhwb3J0TnVtYmVyLCAidGggRXhwb3J0J3Mga2luZCBpbmRleCwgbmFtZWQg JyIsIGZpZWxkU3RyaW5nLCAiJyIpOwogICAgICAgICBzd2l0Y2ggKGV4cC5raW5kKSB7CiAgICAg ICAgIGNhc2UgRXh0ZXJuYWxLaW5kOjpGdW5jdGlvbjogewotICAgICAgICAgICAgV0FTTV9QQVJT RVJfRkFJTF9JRihleHAua2luZEluZGV4ID49IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5z aXplKCksIGV4cG9ydE51bWJlciwgInRoIEV4cG9ydCBoYXMgaW52YWxpZCBmdW5jdGlvbiBudW1i ZXIgIiwgZXhwLmtpbmRJbmRleCwgIiBpdCBleGNlZWRzIHRoZSBmdW5jdGlvbiBpbmRleCBzcGFj ZSAiLCBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpLCAiLCBuYW1lZCAnIiwgZmll bGRTdHJpbmcsICInIik7CisgICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGV4cC5raW5k SW5kZXggPj0gbV9yZXN1bHQubW9kdWxlLT5mdW5jdGlvbkluZGV4U3BhY2VTaXplKCksIGV4cG9y dE51bWJlciwgInRoIEV4cG9ydCBoYXMgaW52YWxpZCBmdW5jdGlvbiBudW1iZXIgIiwgZXhwLmtp bmRJbmRleCwgIiBpdCBleGNlZWRzIHRoZSBmdW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX3Jlc3Vs dC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSwgIiwgbmFtZWQgJyIsIGZpZWxkU3Ry aW5nLCAiJyIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIH0KICAgICAgICAgY2FzZSBF eHRlcm5hbEtpbmQ6OlRhYmxlOiB7CkBAIC00MjYsOCArNDIyLDggQEAgYXV0byBNb2R1bGVQYXJz ZXI6OnBhcnNlU3RhcnQoKSAtPiBQYXJ0aWFsUmVzdWx0CiB7CiAgICAgdWludDMyX3Qgc3RhcnRG dW5jdGlvbkluZGV4OwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKHN0 YXJ0RnVuY3Rpb25JbmRleCksICJjYW4ndCBnZXQgU3RhcnQgaW5kZXgiKTsKLSAgICBXQVNNX1BB UlNFUl9GQUlMX0lGKHN0YXJ0RnVuY3Rpb25JbmRleCA+PSBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4 U3BhY2Uuc2l6ZSgpLCAiU3RhcnQgaW5kZXggIiwgc3RhcnRGdW5jdGlvbkluZGV4LCAiIGV4Y2Vl ZHMgZnVuY3Rpb24gaW5kZXggc3BhY2UgIiwgbV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnNp emUoKSk7Ci0gICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtX3Jlc3VsdC5mdW5j dGlvbkluZGV4U3BhY2Vbc3RhcnRGdW5jdGlvbkluZGV4XS5zaWduYXR1cmVJbmRleDsKKyAgICBX QVNNX1BBUlNFUl9GQUlMX0lGKHN0YXJ0RnVuY3Rpb25JbmRleCA+PSBtX3Jlc3VsdC5tb2R1bGUt PmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSwgIlN0YXJ0IGluZGV4ICIsIHN0YXJ0RnVuY3Rpb25J bmRleCwgIiBleGNlZWRzIGZ1bmN0aW9uIGluZGV4IHNwYWNlICIsIG1fcmVzdWx0Lm1vZHVsZS0+ ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpKTsKKyAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJ bmRleCA9IG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRleFNw YWNlKHN0YXJ0RnVuY3Rpb25JbmRleCk7CiAgICAgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUg PSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KG1fdm0sIHNpZ25hdHVyZUluZGV4KTsKICAgICBX QVNNX1BBUlNFUl9GQUlMX0lGKHNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpLCAiU3RhcnQgZnVu Y3Rpb24gY2FuJ3QgaGF2ZSBhcmd1bWVudHMiKTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHNp Z25hdHVyZS0+cmV0dXJuVHlwZSgpICE9IFZvaWQsICJTdGFydCBmdW5jdGlvbiBjYW4ndCByZXR1 cm4gYSB2YWx1ZSIpOwpAQCAtNDc3LDcgKzQ3Myw3IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJz ZUVsZW1lbnQoKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgICAgIGZvciAodW5zaWduZWQgaW5kZXgg PSAwOyBpbmRleCA8IGluZGV4Q291bnQ7ICsraW5kZXgpIHsKICAgICAgICAgICAgIHVpbnQzMl90 IGZ1bmN0aW9uSW5kZXg7CiAgICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZh clVJbnQzMihmdW5jdGlvbkluZGV4KSwgImNhbid0IGdldCBFbGVtZW50IHNlY3Rpb24ncyAiLCBl bGVtZW50TnVtLCAidGggZWxlbWVudCdzICIsIGluZGV4LCAidGggaW5kZXgiKTsKLSAgICAgICAg ICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVuY3Rpb25JbmRleCA+PSBtX3Jlc3VsdC5mdW5jdGlv bkluZGV4U3BhY2Uuc2l6ZSgpLCAiRWxlbWVudCBzZWN0aW9uJ3MgIiwgZWxlbWVudE51bSwgInRo IGVsZW1lbnQncyAiLCBpbmRleCwgInRoIGluZGV4IGlzICIsIGZ1bmN0aW9uSW5kZXgsICIgd2hp Y2ggZXhjZWVkcyB0aGUgZnVuY3Rpb24gaW5kZXggc3BhY2Ugc2l6ZSBvZiAiLCBtX3Jlc3VsdC5m dW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpKTsKKyAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxf SUYoZnVuY3Rpb25JbmRleCA+PSBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhTcGFjZVNp emUoKSwgIkVsZW1lbnQgc2VjdGlvbidzICIsIGVsZW1lbnROdW0sICJ0aCBlbGVtZW50J3MgIiwg aW5kZXgsICJ0aCBpbmRleCBpcyAiLCBmdW5jdGlvbkluZGV4LCAiIHdoaWNoIGV4Y2VlZHMgdGhl IGZ1bmN0aW9uIGluZGV4IHNwYWNlIHNpemUgb2YgIiwgbV9yZXN1bHQubW9kdWxlLT5mdW5jdGlv bkluZGV4U3BhY2VTaXplKCkpOwogCiAgICAgICAgICAgICBlbGVtZW50LmZ1bmN0aW9uSW5kaWNl cy51bmNoZWNrZWRBcHBlbmQoZnVuY3Rpb25JbmRleCk7CiAgICAgICAgIH0KZGlmZiAtLWdpdCBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuaCBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuaAppbmRleCA5NmMwNGQ0Li5lY2M0 NzM5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFy c2VyLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5o CkBAIC0zNiw3ICszNiw2IEBAIG5hbWVzcGFjZSBKU0MgeyBuYW1lc3BhY2UgV2FzbSB7CiAKIHN0 cnVjdCBNb2R1bGVQYXJzZXJSZXN1bHQgewogICAgIHN0ZDo6dW5pcXVlX3B0cjxNb2R1bGVJbmZv cm1hdGlvbj4gbW9kdWxlOwotICAgIEZ1bmN0aW9uSW5kZXhTcGFjZSBmdW5jdGlvbkluZGV4U3Bh Y2U7CiAgICAgVmVjdG9yPEZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeT4gZnVuY3Rpb25Mb2NhdGlv bkluQmluYXJ5OwogfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbVBsYW4uY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uY3BwCmlu ZGV4IGM4NTMxYzguLmRmNTM0MDIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21QbGFuLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxh bi5jcHAKQEAgLTc2LDggKzc2LDYgQEAgYm9vbCBQbGFuOjpwYXJzZUFuZFZhbGlkYXRlTW9kdWxl KCkKICAgICAgICAgfQogICAgICAgICBtX21vZHVsZUluZm9ybWF0aW9uID0gV1RGTW92ZShwYXJz ZVJlc3VsdC0+bW9kdWxlKTsKICAgICAgICAgbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkgPSBX VEZNb3ZlKHBhcnNlUmVzdWx0LT5mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkpOwotICAgICAgICBt X2Z1bmN0aW9uSW5kZXhTcGFjZS5zaXplID0gcGFyc2VSZXN1bHQtPmZ1bmN0aW9uSW5kZXhTcGFj ZS5zaXplKCk7Ci0gICAgICAgIG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlciA9IHBhcnNlUmVz dWx0LT5mdW5jdGlvbkluZGV4U3BhY2UucmVsZWFzZUJ1ZmZlcigpOwogICAgIH0KIAogICAgIGZv ciAodW5zaWduZWQgZnVuY3Rpb25JbmRleCA9IDA7IGZ1bmN0aW9uSW5kZXggPCBtX2Z1bmN0aW9u TG9jYXRpb25JbkJpbmFyeS5zaXplKCk7ICsrZnVuY3Rpb25JbmRleCkgewpAQCAtODksNyArODcs NyBAQCBib29sIFBsYW46OnBhcnNlQW5kVmFsaWRhdGVNb2R1bGUoKQogICAgICAgICBTaWduYXR1 cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fbW9kdWxlSW5mb3JtYXRpb24tPmludGVybmFsRnVu Y3Rpb25TaWduYXR1cmVJbmRpY2VzW2Z1bmN0aW9uSW5kZXhdOwogICAgICAgICBjb25zdCBTaWdu YXR1cmUqIHNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgc2lnbmF0 dXJlSW5kZXgpOwogCi0gICAgICAgIGF1dG8gdmFsaWRhdGlvblJlc3VsdCA9IHZhbGlkYXRlRnVu Y3Rpb24obV92bSwgZnVuY3Rpb25TdGFydCwgZnVuY3Rpb25MZW5ndGgsIHNpZ25hdHVyZSwgbV9m dW5jdGlvbkluZGV4U3BhY2UsICptX21vZHVsZUluZm9ybWF0aW9uKTsKKyAgICAgICAgYXV0byB2 YWxpZGF0aW9uUmVzdWx0ID0gdmFsaWRhdGVGdW5jdGlvbihtX3ZtLCBmdW5jdGlvblN0YXJ0LCBm dW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCAqbV9tb2R1bGVJbmZvcm1hdGlvbik7CiAgICAgICAg IGlmICghdmFsaWRhdGlvblJlc3VsdCkgewogICAgICAgICAgICAgaWYgKHZlcmJvc2UpIHsKICAg ICAgICAgICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgZnVuY3Rpb25MZW5ndGg7ICsr aSkKQEAgLTEyNyw3ICsxMjUsNyBAQCB2b2lkIFBsYW46OnJ1bigpCiAgICAgICAgIHJldHVybiB0 cnVlOwogICAgIH07CiAKLSAgICBpZiAoIXRyeVJlc2VydmVDYXBhY2l0eShtX3dhc21Ub0pTU3R1 YnMsIG1fbW9kdWxlSW5mb3JtYXRpb24tPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5z aXplKCksICIgV2ViQXNzZW1ibHkgdG8gSmF2YVNjcmlwdCBzdHVicyIpCisgICAgaWYgKCF0cnlS ZXNlcnZlQ2FwYWNpdHkobV93YXNtRXhpdFN0dWJzLCBtX21vZHVsZUluZm9ybWF0aW9uLT5pbXBv cnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMuc2l6ZSgpLCAiIFdlYkFzc2VtYmx5IHRvIEphdmFT Y3JpcHQgc3R1YnMiKQogICAgICAgICB8fCAhdHJ5UmVzZXJ2ZUNhcGFjaXR5KG1fdW5saW5rZWRX YXNtVG9XYXNtQ2FsbHMsIG1fZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5LnNpemUoKSwgIiB1bmxp bmtlZCBXZWJBc3NlbWJseSB0byBXZWJBc3NlbWJseSBjYWxscyIpCiAgICAgICAgIHx8ICF0cnlS ZXNlcnZlQ2FwYWNpdHkobV93YXNtSW50ZXJuYWxGdW5jdGlvbnMsIG1fZnVuY3Rpb25Mb2NhdGlv bkluQmluYXJ5LnNpemUoKSwgIiBXZWJBc3NlbWJseSBmdW5jdGlvbnMiKQogICAgICAgICB8fCAh dHJ5UmVzZXJ2ZUNhcGFjaXR5KG1fY29tcGlsYXRpb25Db250ZXh0cywgbV9mdW5jdGlvbkxvY2F0 aW9uSW5CaW5hcnkuc2l6ZSgpLCAiIGNvbXBpbGF0aW9uIGNvbnRleHRzIikpCkBAIC0xNDEsMTIg KzEzOSwxMSBAQCB2b2lkIFBsYW46OnJ1bigpCiAgICAgICAgIEltcG9ydCogaW1wb3J0ID0gJm1f bW9kdWxlSW5mb3JtYXRpb24tPmltcG9ydHNbaW1wb3J0SW5kZXhdOwogICAgICAgICBpZiAoaW1w b3J0LT5raW5kICE9IEV4dGVybmFsS2luZDo6RnVuY3Rpb24pCiAgICAgICAgICAgICBjb250aW51 ZTsKLSAgICAgICAgdW5zaWduZWQgaW1wb3J0RnVuY3Rpb25JbmRleCA9IG1fd2FzbVRvSlNTdHVi cy5zaXplKCk7CisgICAgICAgIHVuc2lnbmVkIGltcG9ydEZ1bmN0aW9uSW5kZXggPSBtX3dhc21F eGl0U3R1YnMuc2l6ZSgpOwogICAgICAgICBpZiAodmVyYm9zZSkKICAgICAgICAgICAgIGRhdGFM b2dMbigiUHJvY2Vzc2luZyBpbXBvcnQgZnVuY3Rpb24gbnVtYmVyICIsIGltcG9ydEZ1bmN0aW9u SW5kZXgsICI6ICIsIGltcG9ydC0+bW9kdWxlLCAiOiAiLCBpbXBvcnQtPmZpZWxkKTsKICAgICAg ICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtX21vZHVsZUluZm9ybWF0aW9uLT5p bXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMuYXQoaW1wb3J0LT5raW5kSW5kZXgpOwotICAg ICAgICBtX3dhc21Ub0pTU3R1YnMudW5jaGVja2VkQXBwZW5kKGltcG9ydFN0dWJHZW5lcmF0b3Io bV92bSwgbV9jYWxsTGlua0luZm9zLCBzaWduYXR1cmVJbmRleCwgaW1wb3J0RnVuY3Rpb25JbmRl eCkpOwotICAgICAgICBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5idWZmZXIuZ2V0KClbaW1wb3J0RnVu Y3Rpb25JbmRleF0uY29kZSA9IG1fd2FzbVRvSlNTdHVic1tpbXBvcnRGdW5jdGlvbkluZGV4XS5j b2RlKCkuZXhlY3V0YWJsZUFkZHJlc3MoKTsKKyAgICAgICAgbV93YXNtRXhpdFN0dWJzLnVuY2hl Y2tlZEFwcGVuZChleGl0U3R1YkdlbmVyYXRvcihtX3ZtLCBtX2NhbGxMaW5rSW5mb3MsIHNpZ25h dHVyZUluZGV4LCBpbXBvcnRGdW5jdGlvbkluZGV4KSk7CiAgICAgfQogCiAgICAgbV9jdXJyZW50 SW5kZXggPSAwOwpAQCAtMTY3LDEyICsxNjQsMTIgQEAgdm9pZCBQbGFuOjpydW4oKQogICAgICAg ICAgICAgQVNTRVJUKGZ1bmN0aW9uTGVuZ3RoIDw9IG1fc291cmNlTGVuZ3RoKTsKICAgICAgICAg ICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9tb2R1bGVJbmZvcm1hdGlvbi0+ aW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXNbZnVuY3Rpb25JbmRleF07CiAgICAgICAg ICAgICBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpn ZXQobV92bSwgc2lnbmF0dXJlSW5kZXgpOwotICAgICAgICAgICAgdW5zaWduZWQgZnVuY3Rpb25J bmRleFNwYWNlID0gbV93YXNtVG9KU1N0dWJzLnNpemUoKSArIGZ1bmN0aW9uSW5kZXg7Ci0gICAg ICAgICAgICBBU1NFUlRfVU5VU0VEKGZ1bmN0aW9uSW5kZXhTcGFjZSwgbV9mdW5jdGlvbkluZGV4 U3BhY2UuYnVmZmVyLmdldCgpW2Z1bmN0aW9uSW5kZXhTcGFjZV0uc2lnbmF0dXJlSW5kZXggPT0g c2lnbmF0dXJlSW5kZXgpOwotICAgICAgICAgICAgQVNTRVJUKHZhbGlkYXRlRnVuY3Rpb24obV92 bSwgZnVuY3Rpb25TdGFydCwgZnVuY3Rpb25MZW5ndGgsIHNpZ25hdHVyZSwgbV9mdW5jdGlvbklu ZGV4U3BhY2UsICptX21vZHVsZUluZm9ybWF0aW9uKSk7CisgICAgICAgICAgICB1bnNpZ25lZCBm dW5jdGlvbkluZGV4U3BhY2UgPSBtX3dhc21FeGl0U3R1YnMuc2l6ZSgpICsgZnVuY3Rpb25JbmRl eDsKKyAgICAgICAgICAgIEFTU0VSVF9VTlVTRUQoZnVuY3Rpb25JbmRleFNwYWNlLCBtX21vZHVs ZUluZm9ybWF0aW9uLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rp b25JbmRleFNwYWNlKSA9PSBzaWduYXR1cmVJbmRleCk7CisgICAgICAgICAgICBBU1NFUlQodmFs aWRhdGVGdW5jdGlvbihtX3ZtLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0 dXJlLCAqbV9tb2R1bGVJbmZvcm1hdGlvbikpOwogCiAgICAgICAgICAgICBtX3VubGlua2VkV2Fz bVRvV2FzbUNhbGxzW2Z1bmN0aW9uSW5kZXhdID0gVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNh bGw+KCk7Ci0gICAgICAgICAgICBhdXRvIHBhcnNlQW5kQ29tcGlsZVJlc3VsdCA9IHBhcnNlQW5k Q29tcGlsZSgqbV92bSwgbV9jb21waWxhdGlvbkNvbnRleHRzW2Z1bmN0aW9uSW5kZXhdLCBmdW5j dGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBtX3VubGlua2VkV2FzbVRvV2Fz bUNhbGxzW2Z1bmN0aW9uSW5kZXhdLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZSwgKm1fbW9kdWxlSW5m b3JtYXRpb24pOworICAgICAgICAgICAgYXV0byBwYXJzZUFuZENvbXBpbGVSZXN1bHQgPSBwYXJz ZUFuZENvbXBpbGUoKm1fdm0sIG1fY29tcGlsYXRpb25Db250ZXh0c1tmdW5jdGlvbkluZGV4XSwg ZnVuY3Rpb25TdGFydCwgZnVuY3Rpb25MZW5ndGgsIHNpZ25hdHVyZSwgbV91bmxpbmtlZFdhc21U b1dhc21DYWxsc1tmdW5jdGlvbkluZGV4XSwgKm1fbW9kdWxlSW5mb3JtYXRpb24pOwogCiAgICAg ICAgICAgICBpZiAoVU5MSUtFTFkoIXBhcnNlQW5kQ29tcGlsZVJlc3VsdCkpIHsKICAgICAgICAg ICAgICAgICBhdXRvIGxvY2tlciA9IGhvbGRMb2NrKG1fbG9jayk7CkBAIC0yMjMsOSArMjIwLDYg QEAgdm9pZCBQbGFuOjpydW4oKQogICAgICAgICAgICAgICAgICAgICBzdGQ6Om1ha2VfdW5pcXVl PEIzOjpDb21waWxhdGlvbj4oRklOQUxJWkVfQ09ERShsaW5rQnVmZmVyLCAoIldhc20gSlMgZW50 cnlwb2ludCIpKSwgV1RGTW92ZShjb250ZXh0LmpzRW50cnlwb2ludEJ5cHJvZHVjdHMpKTsKICAg ICAgICAgICAgIH0KICAgICAgICAgfQotCi0gICAgICAgIHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhT cGFjZSA9IG1fd2FzbVRvSlNTdHVicy5zaXplKCkgKyBmdW5jdGlvbkluZGV4OwotICAgICAgICBt X2Z1bmN0aW9uSW5kZXhTcGFjZS5idWZmZXIuZ2V0KClbZnVuY3Rpb25JbmRleFNwYWNlXS5jb2Rl ID0gbV93YXNtSW50ZXJuYWxGdW5jdGlvbnNbZnVuY3Rpb25JbmRleF0tPndhc21FbnRyeXBvaW50 LmNvbXBpbGF0aW9uLT5jb2RlKCkuZXhlY3V0YWJsZUFkZHJlc3MoKTsKICAgICB9CiAKICAgICBp ZiAodmVyYm9zZSB8fCBPcHRpb25zOjpyZXBvcnRDb21waWxlVGltZXMoKSkgewpAQCAtMjM1LDgg KzIyOSwxOSBAQCB2b2lkIFBsYW46OnJ1bigpCiAKICAgICAvLyBQYXRjaCB0aGUgY2FsbCBzaXRl cyBmb3IgZWFjaCBXZWJBc3NlbWJseSBmdW5jdGlvbi4KICAgICBmb3IgKGF1dG8mIHVubGlua2Vk IDogbV91bmxpbmtlZFdhc21Ub1dhc21DYWxscykgewotICAgICAgICBmb3IgKGF1dG8mIGNhbGwg OiB1bmxpbmtlZCkKLSAgICAgICAgICAgIE1hY3JvQXNzZW1ibGVyOjpyZXBhdGNoQ2FsbChjYWxs LmNhbGxMb2NhdGlvbiwgQ29kZUxvY2F0aW9uTGFiZWwobV9mdW5jdGlvbkluZGV4U3BhY2UuYnVm ZmVyLmdldCgpW2NhbGwuZnVuY3Rpb25JbmRleF0uY29kZSkpOworICAgICAgICBmb3IgKGF1dG8m IGNhbGwgOiB1bmxpbmtlZCkgeworICAgICAgICAgICAgdm9pZCogZXhlY3V0YWJsZUFkZHJlc3M7 CisgICAgICAgICAgICBpZiAobV9tb2R1bGVJbmZvcm1hdGlvbi0+aXNJbXBvcnRlZEZ1bmN0aW9u RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShjYWxsLmZ1bmN0aW9uSW5kZXgpKSB7CisgICAgICAgICAg ICAgICAgLy8gRklYTUUgaW1wb3J0cyBjb3VsZCBoYXZlIGJlZW4gbGlua2VkIGluIEIzLCBpbnN0 ZWFkIG9mIGdlbmVyYXRpbmcgYSBwYXRjaHBvaW50LiBUaGlzIGNvbmRpdGlvbiBzaG91bGQgYmUg cmVwbGFjZWQgYnkgYSBSRUxFQVNFX0FTU0VSVC4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTE2NjQ2MgorICAgICAgICAgICAgICAgIGV4ZWN1dGFibGVBZGRyZXNzID0g Y2FsbC50b0pTCisgICAgICAgICAgICAgICAgICAgID8gbV93YXNtRXhpdFN0dWJzLmF0KGNhbGwu ZnVuY3Rpb25JbmRleCkud2FzbVRvSlMuY29kZSgpLmV4ZWN1dGFibGVBZGRyZXNzKCkKKyAgICAg ICAgICAgICAgICAgICAgOiBtX3dhc21FeGl0U3R1YnMuYXQoY2FsbC5mdW5jdGlvbkluZGV4KS53 YXNtVG9XYXNtLmNvZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpOworICAgICAgICAgICAgfSBlbHNl IHsKKyAgICAgICAgICAgICAgICBBU1NFUlQoIWNhbGwudG9KUyk7CisgICAgICAgICAgICAgICAg ZXhlY3V0YWJsZUFkZHJlc3MgPSBtX3dhc21JbnRlcm5hbEZ1bmN0aW9ucy5hdChjYWxsLmZ1bmN0 aW9uSW5kZXggLSBtX3dhc21FeGl0U3R1YnMuc2l6ZSgpKS0+d2FzbUVudHJ5cG9pbnQuY29tcGls YXRpb24tPmNvZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpOworICAgICAgICAgICAgfQorICAgICAg ICAgICAgTWFjcm9Bc3NlbWJsZXI6OnJlcGF0Y2hDYWxsKGNhbGwuY2FsbExvY2F0aW9uLCBDb2Rl TG9jYXRpb25MYWJlbChleGVjdXRhYmxlQWRkcmVzcykpOworICAgICAgICB9CiAgICAgfQogCiAg ICAgbV9mYWlsZWQgPSBmYWxzZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21QbGFuLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5oCmlu ZGV4IDNiYjAxYzguLjgzMTU5NjUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21QbGFuLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4u aApAQCAtODYsMjYgKzg2LDE5IEBAIHB1YmxpYzoKICAgICAgICAgcmV0dXJuIFdURk1vdmUobV9j YWxsTGlua0luZm9zKTsKICAgICB9CiAKLSAgICBWZWN0b3I8V2FzbVRvSlNTdHViPiYmIHRha2VX YXNtVG9KU1N0dWJzKCkKKyAgICBWZWN0b3I8V2FzbUV4aXRTdHVicz4mJiB0YWtlV2FzbUV4aXRT dHVicygpCiAgICAgewogICAgICAgICBSRUxFQVNFX0FTU0VSVCghZmFpbGVkKCkpOwotICAgICAg ICByZXR1cm4gV1RGTW92ZShtX3dhc21Ub0pTU3R1YnMpOwotICAgIH0KLQotICAgIEltbXV0YWJs ZUZ1bmN0aW9uSW5kZXhTcGFjZSYmIHRha2VGdW5jdGlvbkluZGV4U3BhY2UoKQotICAgIHsKLSAg ICAgICAgUkVMRUFTRV9BU1NFUlQoIWZhaWxlZCgpKTsKLSAgICAgICAgcmV0dXJuIFdURk1vdmUo bV9mdW5jdGlvbkluZGV4U3BhY2UpOworICAgICAgICByZXR1cm4gV1RGTW92ZShtX3dhc21FeGl0 U3R1YnMpOwogICAgIH0KIAogcHJpdmF0ZToKICAgICBzdGQ6OnVuaXF1ZV9wdHI8TW9kdWxlSW5m b3JtYXRpb24+IG1fbW9kdWxlSW5mb3JtYXRpb247CiAgICAgVmVjdG9yPEZ1bmN0aW9uTG9jYXRp b25JbkJpbmFyeT4gbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnk7CiAgICAgQmFnPENhbGxMaW5r SW5mbz4gbV9jYWxsTGlua0luZm9zOwotICAgIFZlY3RvcjxXYXNtVG9KU1N0dWI+IG1fd2FzbVRv SlNTdHViczsKKyAgICBWZWN0b3I8V2FzbUV4aXRTdHVicz4gbV93YXNtRXhpdFN0dWJzOwogICAg IFZlY3RvcjxzdGQ6OnVuaXF1ZV9wdHI8V2FzbUludGVybmFsRnVuY3Rpb24+PiBtX3dhc21JbnRl cm5hbEZ1bmN0aW9uczsKICAgICBWZWN0b3I8Q29tcGlsYXRpb25Db250ZXh0PiBtX2NvbXBpbGF0 aW9uQ29udGV4dHM7Ci0gICAgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlIG1fZnVuY3Rpb25J bmRleFNwYWNlOwogCiAgICAgVk0qIG1fdm07CiAgICAgVmVjdG9yPFZlY3RvcjxVbmxpbmtlZFdh c21Ub1dhc21DYWxsPj4gbV91bmxpbmtlZFdhc21Ub1dhc21DYWxsczsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuY3BwIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5jcHAKaW5kZXggNmQ1YjFmNi4uOTk3YmQwNiAx MDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5jcHAK KysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5jcHAKQEAgLTQx LDYgKzQxLDE5IEBAIGNvbnN0IGJvb2wgdmVyYm9zZSA9IGZhbHNlOwogCiBjb25zdCBjb25zdGV4 cHIgU2lnbmF0dXJlSW5kZXggU2lnbmF0dXJlOjppbnZhbGlkSW5kZXg7CiAKK1N0cmluZyBTaWdu YXR1cmU6OnRvU3RyaW5nKCkgY29uc3QKK3sKKyAgICBTdHJpbmcgcmVzdWx0KG1ha2VTdHJpbmco cmV0dXJuVHlwZSgpKSk7CisgICAgcmVzdWx0LmFwcGVuZCgiICgiKTsKKyAgICBmb3IgKFNpZ25h dHVyZUFyZ0NvdW50IGFyZyA9IDA7IGFyZyA8IGFyZ3VtZW50Q291bnQoKTsgKythcmcpIHsKKyAg ICAgICAgaWYgKGFyZykKKyAgICAgICAgICAgIHJlc3VsdC5hcHBlbmQoIiwgIik7CisgICAgICAg IHJlc3VsdC5hcHBlbmQobWFrZVN0cmluZyhhcmd1bWVudChhcmcpKSk7CisgICAgfQorICAgIHJl c3VsdC5hcHBlbmQoJyknKTsKKyAgICByZXR1cm4gcmVzdWx0OworfQorCiB2b2lkIFNpZ25hdHVy ZTo6ZHVtcChQcmludFN0cmVhbSYgb3V0KSBjb25zdAogewogICAgIG91dC5wcmludChtYWtlU3Ry aW5nKHJldHVyblR5cGUoKSksICIgKCIpOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbVNpZ25hdHVyZS5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bVNpZ25hdHVyZS5oCmluZGV4IDBkNmM3YjUuLjRkNDNmZmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmgKQEAgLTgyLDYgKzgyLDcgQEAgcHVibGljOgogICAg IH0KICAgICBUeXBlIGFyZ3VtZW50KFNpZ25hdHVyZUFyZ0NvdW50IGkpIGNvbnN0IHsgcmV0dXJu IGNvbnN0X2Nhc3Q8U2lnbmF0dXJlKj4odGhpcyktPmFyZ3VtZW50KGkpOyB9CiAKKyAgICBXVEY6 OlN0cmluZyB0b1N0cmluZygpIGNvbnN0OwogICAgIHZvaWQgZHVtcChXVEY6OlByaW50U3RyZWFt JiBvdXQpIGNvbnN0OwogICAgIGJvb2wgb3BlcmF0b3I9PShjb25zdCBTaWduYXR1cmUmIHJocykg Y29uc3QKICAgICB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt VmFsaWRhdGUuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmNw cAppbmRleCAyNjEzNzBiLi5hNjg3NDgxIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21WYWxpZGF0ZS5jcHAKQEAgLTM2MiwxMCArMzYyLDEwIEBAIHZvaWQgVmFsaWRhdGU6OmR1 bXAoY29uc3QgVmVjdG9yPENvbnRyb2xFbnRyeT4mLCBjb25zdCBFeHByZXNzaW9uTGlzdCYpCiAg ICAgLy8gVGhpbmsgb2YgdGhpcyBhcyBwZW5hbmNlIGZvciB0aGUgc2luIG9mIGJhZCBlcnJvciBt ZXNzYWdlcy4KIH0KIAotRXhwZWN0ZWQ8dm9pZCwgU3RyaW5nPiB2YWxpZGF0ZUZ1bmN0aW9uKFZN KiB2bSwgY29uc3QgdWludDhfdCogc291cmNlLCBzaXplX3QgbGVuZ3RoLCBjb25zdCBTaWduYXR1 cmUqIHNpZ25hdHVyZSwgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiBmdW5jdGlv bkluZGV4U3BhY2UsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBtb2R1bGUpCitFeHBlY3RlZDx2 b2lkLCBTdHJpbmc+IHZhbGlkYXRlRnVuY3Rpb24oVk0qIHZtLCBjb25zdCB1aW50OF90KiBzb3Vy Y2UsIHNpemVfdCBsZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBjb25zdCBNb2R1 bGVJbmZvcm1hdGlvbiYgbW9kdWxlKQogewogICAgIFZhbGlkYXRlIGNvbnRleHQobW9kdWxlKTsK LSAgICBGdW5jdGlvblBhcnNlcjxWYWxpZGF0ZT4gdmFsaWRhdG9yKHZtLCBjb250ZXh0LCBzb3Vy Y2UsIGxlbmd0aCwgc2lnbmF0dXJlLCBmdW5jdGlvbkluZGV4U3BhY2UsIG1vZHVsZSk7CisgICAg RnVuY3Rpb25QYXJzZXI8VmFsaWRhdGU+IHZhbGlkYXRvcih2bSwgY29udGV4dCwgc291cmNlLCBs ZW5ndGgsIHNpZ25hdHVyZSwgbW9kdWxlKTsKICAgICBXQVNNX0ZBSUxfSUZfSEVMUEVSX0ZBSUxT KHZhbGlkYXRvci5wYXJzZSgpKTsKICAgICByZXR1cm4geyB9OwogfQpkaWZmIC0tZ2l0IGEvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmggYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuaAppbmRleCAxNDgyMWYyLi5lYjFhZDhjIDEwMDY0NAot LS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuaAorKysgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuaApAQCAtMzYsNyArMzYsNyBAQCBj bGFzcyBWTTsKIAogbmFtZXNwYWNlIFdhc20gewogCi1FeHBlY3RlZDx2b2lkLCBTdHJpbmc+IHZh bGlkYXRlRnVuY3Rpb24oVk0qLCBjb25zdCB1aW50OF90Kiwgc2l6ZV90LCBjb25zdCBTaWduYXR1 cmUqLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmLCBjb25zdCBNb2R1bGVJbmZv cm1hdGlvbiYpOworRXhwZWN0ZWQ8dm9pZCwgU3RyaW5nPiB2YWxpZGF0ZUZ1bmN0aW9uKFZNKiwg Y29uc3QgdWludDhfdCosIHNpemVfdCwgY29uc3QgU2lnbmF0dXJlKiwgY29uc3QgTW9kdWxlSW5m b3JtYXRpb24mKTsKIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KIApkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseUluc3RhbmNlLmggYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaAppbmRl eCBmMzRiMDUyLi45OWEyYzkwIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaApAQCAtODYsOCArODYsMTEgQEAgcHVibGlj OgogICAgICAgICByZXR1cm4gb2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbnMoKSArIHNpemVvZihXcml0 ZUJhcnJpZXI8SlNDZWxsPikgKiBpZHg7CiAgICAgfQogCisgICAgc3RhdGljIHB0cmRpZmZfdCBv ZmZzZXRPZk1lbW9yeSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFzc2VtYmx5SW5z dGFuY2UsIG1fbWVtb3J5KTsgfQogICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZUYWJsZSgp IHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFzc2VtYmx5SW5zdGFuY2UsIG1fdGFibGUp OyB9CiAgICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZkdsb2JhbHMoKSB7IHJldHVybiBPQkpF Q1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseUluc3RhbmNlLCBtX2dsb2JhbHMpOyB9CisgICAgc3Rh dGljIHNpemVfdCBvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucygpIHsgcmV0dXJuIFdURjo6cm91bmRV cFRvTXVsdGlwbGVPZjxzaXplb2YoV3JpdGVCYXJyaWVyPEpTQ2VsbD4pPihzaXplb2YoSlNXZWJB c3NlbWJseUluc3RhbmNlKSk7IH0KKyAgICBzdGF0aWMgc2l6ZV90IG9mZnNldE9mSW1wb3J0RnVu Y3Rpb24oc2l6ZV90IGltcG9ydEZ1bmN0aW9uTnVtKSB7IHJldHVybiBvZmZzZXRPZkltcG9ydEZ1 bmN0aW9ucygpICsgaW1wb3J0RnVuY3Rpb25OdW0gKiBzaXplb2Yoc2l6ZW9mKFdyaXRlQmFycmll cjxKU0NlbGw+KSk7IH0KIAogcHJvdGVjdGVkOgogICAgIEpTV2ViQXNzZW1ibHlJbnN0YW5jZShW TSYsIFN0cnVjdHVyZSosIHVuc2lnbmVkIG51bUltcG9ydEZ1bmN0aW9ucyk7CkBAIC05NSwxMSAr OTgsNiBAQCBwcm90ZWN0ZWQ6CiAgICAgc3RhdGljIHZvaWQgZGVzdHJveShKU0NlbGwqKTsKICAg ICBzdGF0aWMgdm9pZCB2aXNpdENoaWxkcmVuKEpTQ2VsbCosIFNsb3RWaXNpdG9yJik7CiAKLSAg ICBzdGF0aWMgc2l6ZV90IG9mZnNldE9mSW1wb3J0RnVuY3Rpb25zKCkKLSAgICB7Ci0gICAgICAg IHJldHVybiBXVEY6OnJvdW5kVXBUb011bHRpcGxlT2Y8c2l6ZW9mKFdyaXRlQmFycmllcjxKU0Nl bGw+KT4oc2l6ZW9mKEpTV2ViQXNzZW1ibHlJbnN0YW5jZSkpOwotICAgIH0KLQogICAgIHN0YXRp YyBzaXplX3QgYWxsb2NhdGlvblNpemUodW5zaWduZWQgbnVtSW1wb3J0RnVuY3Rpb25zKQogICAg IHsKICAgICAgICAgcmV0dXJuIG9mZnNldE9mSW1wb3J0RnVuY3Rpb25zKCkgKyBzaXplb2YoV3Jp dGVCYXJyaWVyPEpTQ2VsbD4pICogbnVtSW1wb3J0RnVuY3Rpb25zOwpkaWZmIC0tZ2l0IGEvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5jcHAgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNwcAppbmRleCBi YzQ0OWE4Li40NTFiZjc5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9q cy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNwcApAQCAtMzcsOSArMzcsOSBAQCBuYW1lc3BhY2Ug SlNDIHsKIAogY29uc3QgQ2xhc3NJbmZvIEpTV2ViQXNzZW1ibHlNZW1vcnk6OnNfaW5mbyA9IHsg IldlYkFzc2VtYmx5Lk1lbW9yeSIsICZCYXNlOjpzX2luZm8sIDAsIENSRUFURV9NRVRIT0RfVEFC TEUoSlNXZWJBc3NlbWJseU1lbW9yeSkgfTsKIAotSlNXZWJBc3NlbWJseU1lbW9yeSogSlNXZWJB c3NlbWJseU1lbW9yeTo6Y3JlYXRlKFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6 dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+JiYgbWVtb3J5KQorSlNXZWJBc3NlbWJseU1lbW9yeSog SlNXZWJBc3NlbWJseU1lbW9yeTo6Y3JlYXRlKFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUs IFdhc206Ok1lbW9yeSYmIG1lbW9yeSkKIHsKLSAgICBhdXRvKiBpbnN0YW5jZSA9IG5ldyAoTm90 TnVsbCwgYWxsb2NhdGVDZWxsPEpTV2ViQXNzZW1ibHlNZW1vcnk+KHZtLmhlYXApKSBKU1dlYkFz c2VtYmx5TWVtb3J5KHZtLCBzdHJ1Y3R1cmUsIFdURk1vdmUobWVtb3J5KSk7CisgICAgYXV0byog aW5zdGFuY2UgPSBuZXcgKE5vdE51bGwsIGFsbG9jYXRlQ2VsbDxKU1dlYkFzc2VtYmx5TWVtb3J5 Pih2bS5oZWFwKSkgSlNXZWJBc3NlbWJseU1lbW9yeSh2bSwgc3RydWN0dXJlLCBzdGQ6OmZvcndh cmQ8V2FzbTo6TWVtb3J5PihtZW1vcnkpKTsKICAgICBpbnN0YW5jZS0+ZmluaXNoQ3JlYXRpb24o dm0pOwogICAgIHJldHVybiBpbnN0YW5jZTsKIH0KQEAgLTQ5LDcgKzQ5LDcgQEAgU3RydWN0dXJl KiBKU1dlYkFzc2VtYmx5TWVtb3J5OjpjcmVhdGVTdHJ1Y3R1cmUoVk0mIHZtLCBKU0dsb2JhbE9i amVjdCogZ2xvYmFsT2IKICAgICByZXR1cm4gU3RydWN0dXJlOjpjcmVhdGUodm0sIGdsb2JhbE9i amVjdCwgcHJvdG90eXBlLCBUeXBlSW5mbyhPYmplY3RUeXBlLCBTdHJ1Y3R1cmVGbGFncyksIGlu Zm8oKSk7CiB9CiAKLUpTV2ViQXNzZW1ibHlNZW1vcnk6OkpTV2ViQXNzZW1ibHlNZW1vcnkoVk0m IHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1lbW9yeT4m JiBtZW1vcnkpCitKU1dlYkFzc2VtYmx5TWVtb3J5OjpKU1dlYkFzc2VtYmx5TWVtb3J5KFZNJiB2 bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIFdhc206Ok1lbW9yeSYmIG1lbW9yeSkKICAgICA6IEJh c2Uodm0sIHN0cnVjdHVyZSkKICAgICAsIG1fbWVtb3J5KFdURk1vdmUobWVtb3J5KSkKIHsKQEAg LTYzLDcgKzYzLDcgQEAgSlNBcnJheUJ1ZmZlciogSlNXZWJBc3NlbWJseU1lbW9yeTo6YnVmZmVy KFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCkKICAgICBhdXRvIGRlc3RydWN0 b3IgPSBbXSAodm9pZCopIHsKICAgICAgICAgLy8gV2UgZG9uJ3QgbmVlZCB0byBkbyBhbnl0aGlu ZyBoZXJlIHRvIGRlc3Ryb3kgdGhlIG1lbW9yeS4KICAgICAgICAgLy8gVGhlIEFycmF5QnVmZmVy IGJhY2tpbmcgdGhlIEpTQXJyYXlCdWZmZXIgaXMgb25seSBvd25lZCBieSB1cywKLSAgICAgICAg Ly8gc28gd2UgZ3VhcmFudGVlIGl0cyBsaWZlY3lsY2UuCisgICAgICAgIC8vIHNvIHdlIGd1YXJh bnRlZSBpdHMgbGlmZWN5Y2xlLgogICAgIH07CiAgICAgbV9idWZmZXIgPSBBcnJheUJ1ZmZlcjo6 Y3JlYXRlRnJvbUJ5dGVzKG1lbW9yeSgpLT5tZW1vcnkoKSwgbWVtb3J5KCktPnNpemUoKSwgV1RG TW92ZShkZXN0cnVjdG9yKSk7CiAgICAgbV9idWZmZXJXcmFwcGVyLnNldCh2bSwgdGhpcywgSlNB cnJheUJ1ZmZlcjo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3QtPm1fYXJyYXlCdWZmZXJTdHJ1Y3R1 cmUuZ2V0KCksIG1fYnVmZmVyLmdldCgpKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmgKaW5kZXggMWQ0M2M5NS4uNmMyNjRjOCAx MDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1l bW9yeS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlN ZW1vcnkuaApAQCAtNDEsMjEgKzQxLDI0IEBAIGNsYXNzIEpTV2ViQXNzZW1ibHlNZW1vcnkgOiBw dWJsaWMgSlNEZXN0cnVjdGlibGVPYmplY3QgewogcHVibGljOgogICAgIHR5cGVkZWYgSlNEZXN0 cnVjdGlibGVPYmplY3QgQmFzZTsKIAotICAgIHN0YXRpYyBKU1dlYkFzc2VtYmx5TWVtb3J5KiBj cmVhdGUoVk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiYmKTsK KyAgICBzdGF0aWMgSlNXZWJBc3NlbWJseU1lbW9yeSogY3JlYXRlKFZNJiwgU3RydWN0dXJlKiwg V2FzbTo6TWVtb3J5JiYpOwogICAgIHN0YXRpYyBTdHJ1Y3R1cmUqIGNyZWF0ZVN0cnVjdHVyZShW TSYsIEpTR2xvYmFsT2JqZWN0KiwgSlNWYWx1ZSk7CiAKICAgICBERUNMQVJFX0lORk87CiAKLSAg ICBXYXNtOjpNZW1vcnkqIG1lbW9yeSgpIHsgcmV0dXJuIG1fbWVtb3J5LmdldCgpOyB9CisgICAg V2FzbTo6TWVtb3J5KiBtZW1vcnkoKSB7IHJldHVybiAmbV9tZW1vcnk7IH0KICAgICBKU0FycmF5 QnVmZmVyKiBidWZmZXIoVk0mIHZtLCBKU0dsb2JhbE9iamVjdCopOwogCisgICAgc3RhdGljIHB0 cmRpZmZfdCBvZmZzZXRPZk1lbW9yeSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFz c2VtYmx5TWVtb3J5LCBtX21lbW9yeSkgKyBXYXNtOjpNZW1vcnk6Om9mZnNldE9mTWVtb3J5KCk7 IH0KKyAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mU2l6ZSgpIHsgcmV0dXJuIE9CSkVDVF9P RkZTRVRPRihKU1dlYkFzc2VtYmx5TWVtb3J5LCBtX21lbW9yeSkgKyBXYXNtOjpNZW1vcnk6Om9m ZnNldE9mU2l6ZSgpOyB9CisKIHByb3RlY3RlZDoKLSAgICBKU1dlYkFzc2VtYmx5TWVtb3J5KFZN JiwgU3RydWN0dXJlKiwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1lbW9yeT4mJik7CisgICAgSlNX ZWJBc3NlbWJseU1lbW9yeShWTSYsIFN0cnVjdHVyZSosIFdhc206Ok1lbW9yeSYmKTsKICAgICB2 b2lkIGZpbmlzaENyZWF0aW9uKFZNJik7CiAgICAgc3RhdGljIHZvaWQgZGVzdHJveShKU0NlbGwq KTsKICAgICBzdGF0aWMgdm9pZCB2aXNpdENoaWxkcmVuKEpTQ2VsbCosIFNsb3RWaXNpdG9yJik7 CiAKLSAgICBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiBtX21lbW9yeTsKKyAgICBXYXNt OjpNZW1vcnkgbV9tZW1vcnk7CiAgICAgV3JpdGVCYXJyaWVyPEpTQXJyYXlCdWZmZXI+IG1fYnVm ZmVyV3JhcHBlcjsKICAgICBSZWZQdHI8QXJyYXlCdWZmZXI+IG1fYnVmZmVyOwogfTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUu Y3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5j cHAKaW5kZXggZDY1MjRjNS4uZmEwZTg1OSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5jcHAKKysrIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5jcHAKQEAgLTM4LDkgKzM4LDkgQEAg bmFtZXNwYWNlIEpTQyB7CiAKIGNvbnN0IENsYXNzSW5mbyBKU1dlYkFzc2VtYmx5TW9kdWxlOjpz X2luZm8gPSB7ICJXZWJBc3NlbWJseS5Nb2R1bGUiLCAmQmFzZTo6c19pbmZvLCBudWxscHRyLCBD UkVBVEVfTUVUSE9EX1RBQkxFKEpTV2ViQXNzZW1ibHlNb2R1bGUpIH07CiAKLUpTV2ViQXNzZW1i bHlNb2R1bGUqIEpTV2ViQXNzZW1ibHlNb2R1bGU6OmNyZWF0ZShWTSYgdm0sIFN0cnVjdHVyZSog c3RydWN0dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYgbW9k dWxlSW5mb3JtYXRpb24sIEJhZzxDYWxsTGlua0luZm8+JiYgY2FsbExpbmtJbmZvcywgVmVjdG9y PFdhc206Oldhc21Ub0pTU3R1Yj4mJiB3YXNtVG9KU1N0dWJzLCBXYXNtOjpJbW11dGFibGVGdW5j dGlvbkluZGV4U3BhY2UmJiBmdW5jdGlvbkluZGV4U3BhY2UsIFN5bWJvbFRhYmxlKiBleHBvcnRT eW1ib2xUYWJsZSwgdW5zaWduZWQgY2FsbGVlQ291bnQpCitKU1dlYkFzc2VtYmx5TW9kdWxlKiBK U1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGUoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwg c3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPiYmIG1vZHVsZUluZm9ybWF0 aW9uLCBCYWc8Q2FsbExpbmtJbmZvPiYmIGNhbGxMaW5rSW5mb3MsIFZlY3RvcjxXYXNtOjpXYXNt RXhpdFN0dWJzPiYmIHdhc21FeGl0U3R1YnMsIFN5bWJvbFRhYmxlKiBleHBvcnRTeW1ib2xUYWJs ZSwgdW5zaWduZWQgY2FsbGVlQ291bnQpCiB7Ci0gICAgYXV0byogaW5zdGFuY2UgPSBuZXcgKE5v dE51bGwsIGFsbG9jYXRlQ2VsbDxKU1dlYkFzc2VtYmx5TW9kdWxlPih2bS5oZWFwLCBhbGxvY2F0 aW9uU2l6ZShjYWxsZWVDb3VudCkpKSBKU1dlYkFzc2VtYmx5TW9kdWxlKHZtLCBzdHJ1Y3R1cmUs IHN0ZDo6Zm9yd2FyZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+Piht b2R1bGVJbmZvcm1hdGlvbiksIHN0ZDo6Zm9yd2FyZDxCYWc8Q2FsbExpbmtJbmZvPj4oY2FsbExp bmtJbmZvcyksIHN0ZDo6Zm9yd2FyZDxWZWN0b3I8V2FzbTo6V2FzbVRvSlNTdHViPj4od2FzbVRv SlNTdHVicyksIHN0ZDo6Zm9yd2FyZDxXYXNtOjpJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2U+ KGZ1bmN0aW9uSW5kZXhTcGFjZSksIGNhbGxlZUNvdW50KTsKKyAgICBhdXRvKiBpbnN0YW5jZSA9 IG5ldyAoTm90TnVsbCwgYWxsb2NhdGVDZWxsPEpTV2ViQXNzZW1ibHlNb2R1bGU+KHZtLmhlYXAs IGFsbG9jYXRpb25TaXplKGNhbGxlZUNvdW50KSkpIEpTV2ViQXNzZW1ibHlNb2R1bGUodm0sIHN0 cnVjdHVyZSwgc3RkOjpmb3J3YXJkPHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1h dGlvbj4+KG1vZHVsZUluZm9ybWF0aW9uKSwgc3RkOjpmb3J3YXJkPEJhZzxDYWxsTGlua0luZm8+ PihjYWxsTGlua0luZm9zKSwgc3RkOjpmb3J3YXJkPFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJz Pj4od2FzbUV4aXRTdHVicyksIGNhbGxlZUNvdW50KTsKICAgICBpbnN0YW5jZS0+ZmluaXNoQ3Jl YXRpb24odm0sIGV4cG9ydFN5bWJvbFRhYmxlKTsKICAgICByZXR1cm4gaW5zdGFuY2U7CiB9CkBA IC01MCwxMiArNTAsMTEgQEAgU3RydWN0dXJlKiBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGVT dHJ1Y3R1cmUoVk0mIHZtLCBKU0dsb2JhbE9iamVjdCogZ2xvYmFsT2IKICAgICByZXR1cm4gU3Ry dWN0dXJlOjpjcmVhdGUodm0sIGdsb2JhbE9iamVjdCwgcHJvdG90eXBlLCBUeXBlSW5mbyhPYmpl Y3RUeXBlLCBTdHJ1Y3R1cmVGbGFncyksIGluZm8oKSk7CiB9CiAKLUpTV2ViQXNzZW1ibHlNb2R1 bGU6OkpTV2ViQXNzZW1ibHlNb2R1bGUoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3Rk Ojp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPiYmIG1vZHVsZUluZm9ybWF0aW9u LCBCYWc8Q2FsbExpbmtJbmZvPiYmIGNhbGxMaW5rSW5mb3MsIFZlY3RvcjxXYXNtOjpXYXNtVG9K U1N0dWI+JiYgd2FzbVRvSlNTdHVicywgV2FzbTo6SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNl JiYgZnVuY3Rpb25JbmRleFNwYWNlLCB1bnNpZ25lZCBjYWxsZWVDb3VudCkKK0pTV2ViQXNzZW1i bHlNb2R1bGU6OkpTV2ViQXNzZW1ibHlNb2R1bGUoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVy ZSwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPiYmIG1vZHVsZUluZm9y bWF0aW9uLCBCYWc8Q2FsbExpbmtJbmZvPiYmIGNhbGxMaW5rSW5mb3MsIFZlY3RvcjxXYXNtOjpX YXNtRXhpdFN0dWJzPiYmIHdhc21FeGl0U3R1YnMsIHVuc2lnbmVkIGNhbGxlZUNvdW50KQogICAg IDogQmFzZSh2bSwgc3RydWN0dXJlKQogICAgICwgbV9tb2R1bGVJbmZvcm1hdGlvbihXVEZNb3Zl KG1vZHVsZUluZm9ybWF0aW9uKSkKICAgICAsIG1fY2FsbExpbmtJbmZvcyhXVEZNb3ZlKGNhbGxM aW5rSW5mb3MpKQotICAgICwgbV93YXNtVG9KU1N0dWJzKFdURk1vdmUod2FzbVRvSlNTdHVicykp Ci0gICAgLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZShXVEZNb3ZlKGZ1bmN0aW9uSW5kZXhTcGFjZSkp CisgICAgLCBtX3dhc21FeGl0U3R1YnMoV1RGTW92ZSh3YXNtRXhpdFN0dWJzKSkKICAgICAsIG1f Y2FsbGVlQ291bnQoY2FsbGVlQ291bnQpCiB7CiAgICAgbWVtc2V0KGNhbGxlZXMoKSwgMCwgbV9j YWxsZWVDb3VudCAqIHNpemVvZihXcml0ZUJhcnJpZXI8SlNXZWJBc3NlbWJseUNhbGxlZT4pICog Mik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2Vt Ymx5TW9kdWxlLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5 TW9kdWxlLmgKaW5kZXggMmUxMTM2MS4uYmY1MmUyYiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5oCisrKyBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUuaApAQCAtNDMsMTkgKzQzLDE4 IEBAIGNsYXNzIEpTV2ViQXNzZW1ibHlNb2R1bGUgOiBwdWJsaWMgSlNEZXN0cnVjdGlibGVPYmpl Y3QgewogcHVibGljOgogICAgIHR5cGVkZWYgSlNEZXN0cnVjdGlibGVPYmplY3QgQmFzZTsKIAot ICAgIHN0YXRpYyBKU1dlYkFzc2VtYmx5TW9kdWxlKiBjcmVhdGUoVk0mLCBTdHJ1Y3R1cmUqLCBz dGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYsIEJhZzxDYWxsTGlua0lu Zm8+JiYsIFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0dWI+JiYsIFdhc206OkltbXV0YWJsZUZ1bmN0 aW9uSW5kZXhTcGFjZSYmLCBTeW1ib2xUYWJsZSosIHVuc2lnbmVkKTsKKyAgICBzdGF0aWMgSlNX ZWJBc3NlbWJseU1vZHVsZSogY3JlYXRlKFZNJiwgU3RydWN0dXJlKiwgc3RkOjp1bmlxdWVfcHRy PFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPiYmLCBCYWc8Q2FsbExpbmtJbmZvPiYmLCBWZWN0b3I8 V2FzbTo6V2FzbUV4aXRTdHVicz4mJiwgU3ltYm9sVGFibGUqLCB1bnNpZ25lZCk7CiAgICAgc3Rh dGljIFN0cnVjdHVyZSogY3JlYXRlU3RydWN0dXJlKFZNJiwgSlNHbG9iYWxPYmplY3QqLCBKU1Zh bHVlKTsKIAogICAgIERFQ0xBUkVfSU5GTzsKIAogICAgIGNvbnN0IFdhc206Ok1vZHVsZUluZm9y bWF0aW9uJiBtb2R1bGVJbmZvcm1hdGlvbigpIGNvbnN0IHsgcmV0dXJuICptX21vZHVsZUluZm9y bWF0aW9uLmdldCgpOyB9CiAgICAgU3ltYm9sVGFibGUqIGV4cG9ydFN5bWJvbFRhYmxlKCkgY29u c3QgeyByZXR1cm4gbV9leHBvcnRTeW1ib2xUYWJsZS5nZXQoKTsgfQotICAgIFdhc206OlNpZ25h dHVyZUluZGV4IHNpZ25hdHVyZUZvckZ1bmN0aW9uSW5kZXhTcGFjZSh1bnNpZ25lZCBmdW5jdGlv bkluZGV4U3BhY2UpIGNvbnN0CisgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5k ZXhGcm9tRnVuY3Rpb25JbmRleFNwYWNlKHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFjZSkgY29u c3QKICAgICB7Ci0gICAgICAgIEFTU0VSVChmdW5jdGlvbkluZGV4U3BhY2UgPCBtX2Z1bmN0aW9u SW5kZXhTcGFjZS5zaXplKTsKLSAgICAgICAgcmV0dXJuIG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1 ZmZlci5nZXQoKVtmdW5jdGlvbkluZGV4U3BhY2VdLnNpZ25hdHVyZUluZGV4OworICAgICAgICBy ZXR1cm4gbV9tb2R1bGVJbmZvcm1hdGlvbi0+c2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRl eFNwYWNlKGZ1bmN0aW9uSW5kZXhTcGFjZSk7CiAgICAgfQotICAgIHVuc2lnbmVkIGltcG9ydENv dW50KCkgY29uc3QgeyByZXR1cm4gbV93YXNtVG9KU1N0dWJzLnNpemUoKTsgfQorICAgIHVuc2ln bmVkIGltcG9ydENvdW50KCkgY29uc3QgeyByZXR1cm4gbV93YXNtRXhpdFN0dWJzLnNpemUoKTsg fQogCiAgICAgSlNXZWJBc3NlbWJseUNhbGxlZSoganNFbnRyeXBvaW50Q2FsbGVlRnJvbUZ1bmN0 aW9uSW5kZXhTcGFjZSh1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2UpCiAgICAgewpAQCAtOTAs MTAgKzg5LDggQEAgcHVibGljOgogICAgICAgICByZXR1cm4gYml0d2lzZV9jYXN0PFdyaXRlQmFy cmllcjxKU1dlYkFzc2VtYmx5Q2FsbGVlPio+KGJpdHdpc2VfY2FzdDxjaGFyKj4odGhpcykgKyBv ZmZzZXRPZkNhbGxlZXMoKSk7CiAgICAgfQogCi0gICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRP ZkZ1bmN0aW9uSW5kZXhTcGFjZSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFzc2Vt Ymx5TW9kdWxlLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZSk7IH0KLQogcHJvdGVjdGVkOgotICAgIEpT V2ViQXNzZW1ibHlNb2R1bGUoVk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6 TW9kdWxlSW5mb3JtYXRpb24+JiYsIEJhZzxDYWxsTGlua0luZm8+JiYsIFZlY3RvcjxXYXNtOjpX YXNtVG9KU1N0dWI+JiYsIFdhc206OkltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmLCB1bnNp Z25lZCBjYWxsZWVDb3VudCk7CisgICAgSlNXZWJBc3NlbWJseU1vZHVsZShWTSYsIFN0cnVjdHVy ZSosIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4mJiwgQmFnPENhbGxM aW5rSW5mbz4mJiwgVmVjdG9yPFdhc206Oldhc21FeGl0U3R1YnM+JiYsIHVuc2lnbmVkIGNhbGxl ZUNvdW50KTsKICAgICB2b2lkIGZpbmlzaENyZWF0aW9uKFZNJiwgU3ltYm9sVGFibGUqKTsKICAg ICBzdGF0aWMgdm9pZCBkZXN0cm95KEpTQ2VsbCopOwogICAgIHN0YXRpYyB2b2lkIHZpc2l0Q2hp bGRyZW4oSlNDZWxsKiwgU2xvdFZpc2l0b3ImKTsKQEAgLTExNyw4ICsxMTQsNyBAQCBwcml2YXRl OgogICAgIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4gbV9tb2R1bGVJ bmZvcm1hdGlvbjsKICAgICBCYWc8Q2FsbExpbmtJbmZvPiBtX2NhbGxMaW5rSW5mb3M7CiAgICAg V3JpdGVCYXJyaWVyPFN5bWJvbFRhYmxlPiBtX2V4cG9ydFN5bWJvbFRhYmxlOwotICAgIFZlY3Rv cjxXYXNtOjpXYXNtVG9KU1N0dWI+IG1fd2FzbVRvSlNTdHViczsKLSAgICBjb25zdCBXYXNtOjpJ bW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UgbV9mdW5jdGlvbkluZGV4U3BhY2U7CisgICAgVmVj dG9yPFdhc206Oldhc21FeGl0U3R1YnM+IG1fd2FzbUV4aXRTdHViczsKICAgICB1bnNpZ25lZCBt X2NhbGxlZUNvdW50OwogfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vanMvV2ViQXNzZW1ibHlGdW5jdGlvbi5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNwcAppbmRleCA0ZjBkN2E4Li40YzY3NWRiIDEwMDY0 NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9u LmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0 aW9uLmNwcApAQCAtMTA1LDE2ICsxMDUsNiBAQCBzdGF0aWMgRW5jb2RlZEpTVmFsdWUgSlNDX0hP U1RfQ0FMTCBjYWxsV2ViQXNzZW1ibHlGdW5jdGlvbihFeGVjU3RhdGUqIGV4ZWMpCiAKIEVuY29k ZWRKU1ZhbHVlIFdlYkFzc2VtYmx5RnVuY3Rpb246OmNhbGwoVk0mIHZtLCBQcm90b0NhbGxGcmFt ZSogcHJvdG9DYWxsRnJhbWUpCiB7Ci0gICAgLy8gU2V0dXAgdGhlIG1lbW9yeSB0aGF0IHRoZSBl bnRyYW5jZSBsb2Fkcy4KLSAgICBpZiAoSlNXZWJBc3NlbWJseU1lbW9yeSogbWVtb3J5ID0gaW5z dGFuY2UoKS0+bWVtb3J5KCkpIHsKLSAgICAgICAgV2FzbTo6TWVtb3J5KiB3YXNtTWVtb3J5ID0g bWVtb3J5LT5tZW1vcnkoKTsKLSAgICAgICAgdm0udG9wV2FzbU1lbW9yeVBvaW50ZXIgPSB3YXNt TWVtb3J5LT5tZW1vcnkoKTsKLSAgICAgICAgdm0udG9wV2FzbU1lbW9yeVNpemUgPSB3YXNtTWVt b3J5LT5zaXplKCk7Ci0gICAgfSBlbHNlIHsKLSAgICAgICAgdm0udG9wV2FzbU1lbW9yeVBvaW50 ZXIgPSBudWxscHRyOwotICAgICAgICB2bS50b3BXYXNtTWVtb3J5U2l6ZSA9IDA7Ci0gICAgfQot CiAgICAgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBwcmV2SlNXZWJBc3NlbWJseUluc3RhbmNlID0g dm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlOwogICAgIHZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0 YW5jZSA9IGluc3RhbmNlKCk7CiAgICAgQVNTRVJUKGluc3RhbmNlKCkpOwpAQCAtMTUzLDcgKzE0 Myw3IEBAIFdlYkFzc2VtYmx5RnVuY3Rpb24qIFdlYkFzc2VtYmx5RnVuY3Rpb246OmNyZWF0ZShW TSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPCiBTdHJ1Y3R1cmUqIFdlYkFzc2VtYmx5RnVu Y3Rpb246OmNyZWF0ZVN0cnVjdHVyZShWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmpl Y3QsIEpTVmFsdWUgcHJvdG90eXBlKQogewogICAgIEFTU0VSVChnbG9iYWxPYmplY3QpOwotICAg IHJldHVybiBTdHJ1Y3R1cmU6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LCBwcm90b3R5cGUsIFR5 cGVJbmZvKEpTRnVuY3Rpb25UeXBlLCBTdHJ1Y3R1cmVGbGFncyksIGluZm8oKSk7CisgICAgcmV0 dXJuIFN0cnVjdHVyZTo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3QsIHByb3RvdHlwZSwgVHlwZUlu Zm8oV2ViQXNzZW1ibHlGdW5jdGlvblR5cGUsIFN0cnVjdHVyZUZsYWdzKSwgaW5mbygpKTsKIH0K IAogV2ViQXNzZW1ibHlGdW5jdGlvbjo6V2ViQXNzZW1ibHlGdW5jdGlvbihWTSYgdm0sIEpTR2xv YmFsT2JqZWN0KiBnbG9iYWxPYmplY3QsIFN0cnVjdHVyZSogc3RydWN0dXJlLCBXYXNtOjpTaWdu YXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VDb25zdHJ1Y3Rvci5jcHAgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUluc3RhbmNlQ29uc3RydWN0b3IuY3Bw CmluZGV4IDU4ZWEyNTg0Li5kMjRhYjgxIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9qcy9XZWJBc3NlbWJseUluc3RhbmNlQ29uc3RydWN0b3IuY3BwCisrKyBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VDb25zdHJ1Y3Rvci5j cHAKQEAgLTExNCwxOCArMTE0LDE5IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9D QUxMIGNvbnN0cnVjdEpTV2ViQXNzZW1ibHlJbnN0YW5jZShFeGVjU3RhdGUqIGV4CiAgICAgICAg ICAgICAgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29kZSh0aHJvd0V4Y2VwdGlvbihleGVjLCB0aHJv d1Njb3BlLCBjcmVhdGVKU1dlYkFzc2VtYmx5TGlua0Vycm9yKGV4ZWMsIHZtLCBBU0NJSUxpdGVy YWwoImltcG9ydCBmdW5jdGlvbiBtdXN0IGJlIGNhbGxhYmxlIikpKSk7CiAgICAgICAgICAgICBK U0NlbGwqIGNlbGwgPSB2YWx1ZS5hc0NlbGwoKTsKICAgICAgICAgICAgIC8vIGlpLiBJZiB2IGlz IGFuIEV4cG9ydGVkIEZ1bmN0aW9uIEV4b3RpYyBPYmplY3Q6Ci0gICAgICAgICAgICBpZiAoV2Vi QXNzZW1ibHlGdW5jdGlvbiogaW1wb3J0ZWRFeHBvcnRzID0ganNEeW5hbWljQ2FzdDxXZWJBc3Nl bWJseUZ1bmN0aW9uKj4ob2JqZWN0KSkgewotICAgICAgICAgICAgICAgIC8vIEZJWE1FIGhhbmRs ZSBGdW5jdGlvbiBFeG90aWMgT2JqZWN0IHByb3Blcmx5LiBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTY1MjgyCi0gICAgICAgICAgICAgICAgLy8gYS4gSWYgdGhlIHNp Z25hdHVyZSBvZiB2IGRvZXMgbm90IG1hdGNoIHRoZSBzaWduYXR1cmUgb2YgaSwgdGhyb3cgYSBU eXBlRXJyb3IuCisgICAgICAgICAgICBpZiAoV2ViQXNzZW1ibHlGdW5jdGlvbiogaW1wb3J0ZWRF eHBvcnQgPSBqc0R5bmFtaWNDYXN0PFdlYkFzc2VtYmx5RnVuY3Rpb24qPihjZWxsKSkgeworICAg ICAgICAgICAgICAgIC8vIGEuIElmIHRoZSBzaWduYXR1cmUgb2YgdiBkb2VzIG5vdCBtYXRjaCB0 aGUgc2lnbmF0dXJlIG9mIGksIHRocm93IGEgV2ViQXNzZW1ibHkuTGlua0Vycm9yLgorICAgICAg ICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IGltcG9ydGVkU2lnbmF0dXJlSW5kZXggPSBp bXBvcnRlZEV4cG9ydC0+c2lnbmF0dXJlSW5kZXgoKTsKKyAgICAgICAgICAgICAgICBXYXNtOjpT aWduYXR1cmVJbmRleCBleHBlY3RlZFNpZ25hdHVyZUluZGV4ID0gbW9kdWxlSW5mb3JtYXRpb24u aW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzW2ltcG9ydC5raW5kSW5kZXhdOworICAgICAg ICAgICAgICAgIGlmIChpbXBvcnRlZFNpZ25hdHVyZUluZGV4ICE9IGV4cGVjdGVkU2lnbmF0dXJl SW5kZXgpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBKU1ZhbHVlOjplbmNvZGUodGhyb3dF eGNlcHRpb24oZXhlYywgdGhyb3dTY29wZSwgY3JlYXRlSlNXZWJBc3NlbWJseUxpbmtFcnJvcihl eGVjLCB2bSwgQVNDSUlMaXRlcmFsKCJpbXBvcnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBtaXNt YXRjaGVzIHRoZSBwcm92aWRlZCBXZWJBc3NlbWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSIpKSkp OwogICAgICAgICAgICAgICAgIC8vIGIuIExldCBjbG9zdXJlIGJlIHYuW1tDbG9zdXJlXV0uCi0g ICAgICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKLSAgICAgICAgICAg ICAgICBVTlVTRURfUEFSQU0oaW1wb3J0ZWRFeHBvcnRzKTsKLSAgICAgICAgICAgICAgICBicmVh azsKICAgICAgICAgICAgIH0KICAgICAgICAgICAgIC8vIGlpaS4gT3RoZXJ3aXNlOgogICAgICAg ICAgICAgLy8gYS4gTGV0IGNsb3N1cmUgYmUgYSBuZXcgaG9zdCBmdW5jdGlvbiBvZiB0aGUgZ2l2 ZW4gc2lnbmF0dXJlIHdoaWNoIGNhbGxzIHYgYnkgY29lcmNpbmcgV2ViQXNzZW1ibHkgYXJndW1l bnRzIHRvIEphdmFTY3JpcHQgYXJndW1lbnRzIHZpYSBUb0pTVmFsdWUgYW5kIHJldHVybnMgdGhl IHJlc3VsdCwgaWYgYW55LCBieSBjb2VyY2luZyB2aWEgVG9XZWJBc3NlbWJseVZhbHVlLgogICAg ICAgICAgICAgLy8gTm90ZTogZG9uZSBhcyBwYXJ0IG9mIFBsYW4gY29tcGlsYXRpb24uCiAgICAg ICAgICAgICAvLyBpdi4gQXBwZW5kIHYgdG8gZnVuY3MuCisgICAgICAgICAgICAvLyBOb3RlOiBh ZGRpbmcgdGhlIEpTQ2VsbCB0byB0aGUgaW5zdGFuY2UgbGlzdCBmdWxmaWxscyBjbG9zdXJlIHJl cXVpcmVtZW50cyBiLiBhYm92ZSAodGhlIFdlYkFzc2VtYmx5Lkluc3RhbmNlIHdpbCBiZSBrZXB0 IGFsaXZlKSBhbmQgdi4gYmVsb3cgKHRoZSBKU0Z1bmN0aW9uKS4KICAgICAgICAgICAgIGluc3Rh bmNlLT5zZXRJbXBvcnRGdW5jdGlvbih2bSwgY2VsbCwgbnVtSW1wb3J0RnVuY3Rpb25zKyspOwog ICAgICAgICAgICAgLy8gdi4gQXBwZW5kIGNsb3N1cmUgdG8gaW1wb3J0cy4KICAgICAgICAgICAg IGJyZWFrOwpAQCAtMjI5LDggKzIzMCw4IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9T VF9DQUxMIGNvbnN0cnVjdEpTV2ViQXNzZW1ibHlJbnN0YW5jZShFeGVjU3RhdGUqIGV4CiAgICAg ICAgIGlmIChtb2R1bGVJbmZvcm1hdGlvbi5tZW1vcnkgJiYgIWhhc01lbW9yeUltcG9ydCkgewog ICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQoIW1vZHVsZUluZm9ybWF0aW9uLm1lbW9yeS5pc0lt cG9ydCgpKTsKICAgICAgICAgICAgIC8vIFdlIGNyZWF0ZSBhIG1lbW9yeSB3aGVuIGl0J3MgYSBt ZW1vcnkgZGVmaW5pdGlvbi4KLSAgICAgICAgICAgIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1v cnk+IG1lbW9yeSA9IHN0ZDo6bWFrZV91bmlxdWU8V2FzbTo6TWVtb3J5Pihtb2R1bGVJbmZvcm1h dGlvbi5tZW1vcnkuaW5pdGlhbCgpLCBtb2R1bGVJbmZvcm1hdGlvbi5tZW1vcnkubWF4aW11bSgp KTsKLSAgICAgICAgICAgIGlmICghbWVtb3J5LT5pc1ZhbGlkKCkpCisgICAgICAgICAgICBXYXNt OjpNZW1vcnkgbWVtb3J5KG1vZHVsZUluZm9ybWF0aW9uLm1lbW9yeS5pbml0aWFsKCksIG1vZHVs ZUluZm9ybWF0aW9uLm1lbW9yeS5tYXhpbXVtKCkpOworICAgICAgICAgICAgaWYgKCFtZW1vcnku aXNWYWxpZCgpKQogICAgICAgICAgICAgICAgIHJldHVybiBKU1ZhbHVlOjplbmNvZGUodGhyb3dF eGNlcHRpb24oZXhlYywgdGhyb3dTY29wZSwgY3JlYXRlT3V0T2ZNZW1vcnlFcnJvcihleGVjKSkp OwogICAgICAgICAgICAgaW5zdGFuY2UtPnNldE1lbW9yeSh2bSwKICAgICAgICAgICAgICAgIEpT V2ViQXNzZW1ibHlNZW1vcnk6OmNyZWF0ZSh2bSwgZXhlYy0+bGV4aWNhbEdsb2JhbE9iamVjdCgp LT5XZWJBc3NlbWJseU1lbW9yeVN0cnVjdHVyZSgpLCBXVEZNb3ZlKG1lbW9yeSkpKTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TWVtb3J5Q29u c3RydWN0b3IuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlN ZW1vcnlDb25zdHJ1Y3Rvci5jcHAKaW5kZXggM2Y4OGVkNC4uZGNjZWMxNiAxMDA2NDQKLS0tIGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNZW1vcnlDb25zdHJ1Y3Rv ci5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNZW1v cnlDb25zdHJ1Y3Rvci5jcHAKQEAgLTk2LDggKzk2LDggQEAgc3RhdGljIEVuY29kZWRKU1ZhbHVl IEpTQ19IT1NUX0NBTEwgY29uc3RydWN0SlNXZWJBc3NlbWJseU1lbW9yeShFeGVjU3RhdGUqIGV4 ZWMKICAgICAgICAgfQogICAgIH0KIAotICAgIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+ IG1lbW9yeSA9IHN0ZDo6bWFrZV91bmlxdWU8V2FzbTo6TWVtb3J5Pihpbml0aWFsUGFnZUNvdW50 LCBtYXhpbXVtUGFnZUNvdW50KTsKLSAgICBpZiAoIW1lbW9yeS0+aXNWYWxpZCgpKQorICAgIFdh c206Ok1lbW9yeSBtZW1vcnkoaW5pdGlhbFBhZ2VDb3VudCwgbWF4aW11bVBhZ2VDb3VudCk7Cisg ICAgaWYgKCFtZW1vcnkuaXNWYWxpZCgpKQogICAgICAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2Rl KHRocm93RXhjZXB0aW9uKGV4ZWMsIHRocm93U2NvcGUsIGNyZWF0ZU91dE9mTWVtb3J5RXJyb3Io ZXhlYykpKTsKIAogICAgIHJldHVybiBKU1ZhbHVlOjplbmNvZGUoSlNXZWJBc3NlbWJseU1lbW9y eTo6Y3JlYXRlKHZtLCBleGVjLT5sZXhpY2FsR2xvYmFsT2JqZWN0KCktPldlYkFzc2VtYmx5TWVt b3J5U3RydWN0dXJlKCksIFdURk1vdmUobWVtb3J5KSkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVDb25zdHJ1Y3Rvci5jcHAgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9y LmNwcAppbmRleCAzOGVkYjhjLi44MTI5NTkyIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNwcAorKysgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNw cApAQCAtOTcsNyArOTcsNyBAQCBKU1ZhbHVlIFdlYkFzc2VtYmx5TW9kdWxlQ29uc3RydWN0b3I6 OmNyZWF0ZU1vZHVsZShFeGVjU3RhdGUqIHN0YXRlLCBTdHJ1Y3R1cmUqCiAKICAgICAvLyBPbmx5 IHdhc20taW50ZXJuYWwgZnVuY3Rpb25zIGhhdmUgYSBjYWxsZWUsIHN0dWJzIHRvIEpTIGRvIG5v dC4KICAgICB1bnNpZ25lZCBjYWxsZWVDb3VudCA9IHBsYW4uaW50ZXJuYWxGdW5jdGlvbkNvdW50 KCk7Ci0gICAgSlNXZWJBc3NlbWJseU1vZHVsZSogcmVzdWx0ID0gSlNXZWJBc3NlbWJseU1vZHVs ZTo6Y3JlYXRlKHZtLCBzdHJ1Y3R1cmUsIHBsYW4udGFrZU1vZHVsZUluZm9ybWF0aW9uKCksIHBs YW4udGFrZUNhbGxMaW5rSW5mb3MoKSwgcGxhbi50YWtlV2FzbVRvSlNTdHVicygpLCBwbGFuLnRh a2VGdW5jdGlvbkluZGV4U3BhY2UoKSwgZXhwb3J0U3ltYm9sVGFibGUsIGNhbGxlZUNvdW50KTsK KyAgICBKU1dlYkFzc2VtYmx5TW9kdWxlKiByZXN1bHQgPSBKU1dlYkFzc2VtYmx5TW9kdWxlOjpj cmVhdGUodm0sIHN0cnVjdHVyZSwgcGxhbi50YWtlTW9kdWxlSW5mb3JtYXRpb24oKSwgcGxhbi50 YWtlQ2FsbExpbmtJbmZvcygpLCBwbGFuLnRha2VXYXNtRXhpdFN0dWJzKCksIGV4cG9ydFN5bWJv bFRhYmxlLCBjYWxsZWVDb3VudCk7CiAgICAgcGxhbi5pbml0aWFsaXplQ2FsbGVlcyhzdGF0ZS0+ anNDYWxsZWUoKS0+Z2xvYmFsT2JqZWN0KCksIAogICAgICAgICBbJl0gKHVuc2lnbmVkIGNhbGxl ZUluZGV4LCBKU1dlYkFzc2VtYmx5Q2FsbGVlKiBqc0VudHJ5cG9pbnRDYWxsZWUsIEpTV2ViQXNz ZW1ibHlDYWxsZWUqIHdhc21FbnRyeXBvaW50Q2FsbGVlKSB7CiAgICAgICAgICAgICByZXN1bHQt PnNldEpTRW50cnlwb2ludENhbGxlZSh2bSwgY2FsbGVlSW5kZXgsIGpzRW50cnlwb2ludENhbGxl ZSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJs eU1vZHVsZVJlY29yZC5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3Nl bWJseU1vZHVsZVJlY29yZC5jcHAKaW5kZXggYjRjYjA1NS4uMDc4Njk3OCAxMDA2NDQKLS0tIGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQuY3Bw CisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVj b3JkLmNwcApAQCAtMTE4LDcgKzExOCw3IEBAIHZvaWQgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6 OmxpbmsoRXhlY1N0YXRlKiBzdGF0ZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBpbnN0CiAgICAg ICAgICAgICAvLyAgICAgYy4gUmV0dXJuIGZ1bmMuCiAgICAgICAgICAgICBKU1dlYkFzc2VtYmx5 Q2FsbGVlKiBqc0VudHJ5cG9pbnRDYWxsZWUgPSBtb2R1bGUtPmpzRW50cnlwb2ludENhbGxlZUZy b21GdW5jdGlvbkluZGV4U3BhY2UoZXhwLmtpbmRJbmRleCk7CiAgICAgICAgICAgICBKU1dlYkFz c2VtYmx5Q2FsbGVlKiB3YXNtRW50cnlwb2ludENhbGxlZSA9IG1vZHVsZS0+d2FzbUVudHJ5cG9p bnRDYWxsZWVGcm9tRnVuY3Rpb25JbmRleFNwYWNlKGV4cC5raW5kSW5kZXgpOwotICAgICAgICAg ICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVy ZUZvckZ1bmN0aW9uSW5kZXhTcGFjZShleHAua2luZEluZGV4KTsKKyAgICAgICAgICAgIFdhc206 OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVJbmRleEZy b21GdW5jdGlvbkluZGV4U3BhY2UoZXhwLmtpbmRJbmRleCk7CiAgICAgICAgICAgICBjb25zdCBX YXNtOjpTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFdhc206OlNpZ25hdHVyZUluZm9ybWF0aW9uOjpn ZXQoJnZtLCBzaWduYXR1cmVJbmRleCk7CiAgICAgICAgICAgICBXZWJBc3NlbWJseUZ1bmN0aW9u KiBmdW5jdGlvbiA9IFdlYkFzc2VtYmx5RnVuY3Rpb246OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0 LCBzaWduYXR1cmUtPmFyZ3VtZW50Q291bnQoKSwgZXhwLmZpZWxkLnN0cmluZygpLCBpbnN0YW5j ZSwganNFbnRyeXBvaW50Q2FsbGVlLCB3YXNtRW50cnlwb2ludENhbGxlZSwgc2lnbmF0dXJlSW5k ZXgpOwogICAgICAgICAgICAgZXhwb3J0ZWRWYWx1ZSA9IGZ1bmN0aW9uOwpAQCAtMTc1LDcgKzE3 NSw3IEBAIHZvaWQgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmxpbmsoRXhlY1N0YXRlKiBzdGF0 ZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBpbnN0CiAgICAgYm9vbCBoYXNTdGFydCA9ICEhbW9k dWxlSW5mb3JtYXRpb24uc3RhcnRGdW5jdGlvbkluZGV4U3BhY2U7CiAgICAgaWYgKGhhc1N0YXJ0 KSB7CiAgICAgICAgIGF1dG8gc3RhcnRGdW5jdGlvbkluZGV4U3BhY2UgPSBtb2R1bGVJbmZvcm1h dGlvbi5zdGFydEZ1bmN0aW9uSW5kZXhTcGFjZS52YWx1ZV9vcigwKTsKLSAgICAgICAgV2FzbTo6 U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVyZUZvckZ1bmN0 aW9uSW5kZXhTcGFjZShzdGFydEZ1bmN0aW9uSW5kZXhTcGFjZSk7CisgICAgICAgIFdhc206OlNp Z25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21G dW5jdGlvbkluZGV4U3BhY2Uoc3RhcnRGdW5jdGlvbkluZGV4U3BhY2UpOwogICAgICAgICBjb25z dCBXYXNtOjpTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFdhc206OlNpZ25hdHVyZUluZm9ybWF0aW9u OjpnZXQoJnZtLCBzaWduYXR1cmVJbmRleCk7CiAgICAgICAgIC8vIFRoZSBzdGFydCBmdW5jdGlv biBtdXN0IG5vdCB0YWtlIGFueSBhcmd1bWVudHMgb3IgcmV0dXJuIGFueXRoaW5nLiBUaGlzIGlz IGVuZm9yY2VkIGJ5IHRoZSBwYXJzZXIuCiAgICAgICAgIEFTU0VSVCghc2lnbmF0dXJlLT5hcmd1 bWVudENvdW50KCkpOwpAQCAtMjM4LDcgKzIzOCw3IEBAIEpTVmFsdWUgV2ViQXNzZW1ibHlNb2R1 bGVSZWNvcmQ6OmV2YWx1YXRlKEV4ZWNTdGF0ZSogc3RhdGUpCiAKICAgICAgICAgICAgICAgICBK U1dlYkFzc2VtYmx5Q2FsbGVlKiBqc0VudHJ5cG9pbnRDYWxsZWUgPSBtb2R1bGUtPmpzRW50cnlw b2ludENhbGxlZUZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleCk7CiAgICAgICAg ICAgICAgICAgSlNXZWJBc3NlbWJseUNhbGxlZSogd2FzbUVudHJ5cG9pbnRDYWxsZWUgPSBtb2R1 bGUtPndhc21FbnRyeXBvaW50Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbklu ZGV4KTsKLSAgICAgICAgICAgICAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRl eCA9IG1vZHVsZS0+c2lnbmF0dXJlRm9yRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgp OworICAgICAgICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0g bW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRl eCk7CiAgICAgICAgICAgICAgICAgY29uc3QgV2FzbTo6U2lnbmF0dXJlKiBzaWduYXR1cmUgPSBX YXNtOjpTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KCZ2bSwgc2lnbmF0dXJlSW5kZXgpOwogICAg ICAgICAgICAgICAgIC8vIEZJWE1FOiBTYXkgd2UgZXhwb3J0IGxvY2FsIGZ1bmN0aW9uICJmb28i IGF0IGZ1bmNpdG9uIGluZGV4IDAuCiAgICAgICAgICAgICAgICAgLy8gV2hhdCBpZiB3ZSBhbHNv IHNldCBpdCB0byB0aGUgdGFibGUgYW4gRWxlbWVudCB3LyBpbmRleCAwLgotLSAKMi4xMC4xCgo= 297775 2016-12-26 17:54:57 -0800 2016-12-26 19:55:20 -0800 WIP 0001-wasm-wasm.patch text/plain 105502 jfbastien RnJvbSBkNmMxMzlhOGMwZDJiZDBmMWVmNWUxY2E2NjFhYmQ1ZTkxNTY3YzgzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBXZWQsIDIxIERlYyAyMDE2IDE1OjU5OjU2IC0wODAwClN1YmplY3Q6IFtQQVRDSF0gd2FzbS0+ d2FzbQoKQ2hhbmdlcyB0byB0aGUgV2ViQXNzZW1ibHkgaW1wbGVtZW50YXRpb246CgogIC0gQWRk IGEgbmV3IEpTVHlwZSBmb3IgV2ViQXNzZW1ibHlGdW5jdGlvbiwgYW5kIHVzZSBpdCB3aGVuIGNy ZWF0aW5nIGl0cwogICAgc3RydWN0dXJlLiBUaGlzIHdpbGwgYmUgdXNlZCB0byBxdWlja2x5IGRl dGVjdCBmcm9tIHdhc20gd2hldGhlciB0aGUgaW1wb3J0CiAgICBjYWxsIGlzIHRvIGFub3RoZXIg d2FzbSBtb2R1bGUsIG9yIHdoZXRoZXIgaXQncyB0byBKUy4KICAtIFVzZSBjZWxsIGluc3RlYWQg b2Ygb2JqZWN0cyB0byBkZXRlY3Qgd2FzbS0+d2FzbSwgdGhlIHByZXZpb3VzIGNvZGUgd2FzIHdy b25nLgogIC0gSW1wcm92ZSBkaWFnbm9zdGljIHByaW50b3V0IGZvciB3YXNtIHN0dWJzOiBwcmlu dCB0aGUgZnVsbCBzaWduYXR1cmUuCiAgLSBQcm9wZXJseSBjaGVjayB0aGF0IHdhc20gLT4gd2Fz bSBjYWxscyBoYXZlIG1hdGNoaW5nIHNpZ25hdHVyZXMuIEFkZCB0ZXN0aW5nIGZvciB0aGlzLgog IC0gVGVzdCBzb21lIG9mIHRoZSB3YXNtIC0+IHdhc20gY2FsbHMsIG5vdCB3b3JraW5nIHlldCwg YW5kIG1vcmUgdGVzdHMgbmVlZCB0bwogICAgZ2V0IGltcGxlbWVudGVkLgogIC0gR2VuZXJhdGUg dHdvIHN0dWJzIGZyb20gdGhlIGltcG9ydCBzdHViIGdlbmVyYXRvcjogb25lIGZvciB3YXNtLT5K UyBhbmQgb25lCiAgICBmb3Igd2FzbSAtPiB3YXNtLiBUaGlzIGlzIGRvbmUgYXQgTW9kdWxlIHRp bWUuIFdoaWNoIGlzIGNhbGxlZCB3aWxsIG9ubHkgYmUKICAgIGtub3duIGF0IEluc3RhbmNlIHRp bWUsIG9uY2Ugd2UndmUgcmVjZWl2ZWQgdGhlIGltcG9ydCBvYmplY3QuIFdlIHdhbnQgdG8KICAg IGF2b2lkIGNvZGVnZW4gYXQgSW5zdGFuY2UgdGltZSwgc28gaGF2aW5nIGJvdGggYXJvdW5kIGlz IGdyZWF0LgogIC0gUmVzdG9yZSB0aGUgV2ViQXNzZW1ibHkgZ2xvYmFsIHN0YXRlIChWTSB0b3Ag SW5zdGFuY2UsIGFuZCBwaW5uZWQgcmVnaXN0ZXJzKQogICAgYWZ0ZXIgY2FsbCAvIGNhbGxfaW5k aXJlY3QsIGFuZCBpbiB0aGUgSlMtPndhc20gZW50cnkgc3R1Yi4KClN1cHBvcnQgY2hhbmdlczoK CiAgLSBBZGQgYSBQcm94eSB0byBCdWlsZGVyLmpzLCB3aGljaCBpbnRlcmNlcHRzIHVua25vd24g cHJvcGVydHkgbG9va3Vwcy4gVGhpcwogICAgY3JlYXRlcyB3YXkgYmV0dGVyIGVycm9yIG1lc3Nh Z2VzIG9uIHR5cG9zIHRoYW4gJ3VuZGVmaW5lZCBpcyBub3QgYQogICAgZnVuY3Rpb24nLCB3aGlj aCBoYXBwZW5zIHNlbWktZnJlcXVlbnRseSBhcyBJIHR5cG8gb3Bjb2RlIG5hbWVzIChhbmQgd2hp Y2gKICAgIG9uZSBpcyBhIHR5cG8gaXMgaGFyZCB0byBmaW5kIGJlY2F1c2Ugd2UgY2hhaW4gYnVp bGRlcnMpLgogIC0gQWRkIGxpbWl0ZWQgc3VwcG9ydCBmb3IgdmFye3V9aW50NjQgKG9ubHkgdGhl IDMyLWJpdCB2YWx1ZXMpLgogIC0gR2V0IHJpZCBvZiBtdWNoIG9mIHRoZSBmdW5jdGlvbiBpbmRl eCBzcGFjZTogd2UgYWxyZWFkeSBoYXZlIGFsbCBvZiBpdHMKICAgIGluZm9ybWF0aW9uIGVsc2V3 aGVyZSwgYW5kIGFzLWlzIGl0IHByb3ZpZGVzIG5vIGV4dHJhIGVmZmljaWVuY3kuCiAgLSBTdG9y ZSBXYXNtOjpNZW1vcnkgZGlyZWN0bHkgb24gSlNXZWJBc3NlbWJseU1lbW9yeSwgaW5zdGVhZCBv ZiB0aHJvdWdoIGEKICAgIHVuaXF1ZV9wdHIuIFRoaXMgcmVtb3ZlcyBhbiBpbmRpcmVjdGlvbiBh bmQgdXNlbGVzcyBhbGxvY2F0aW9uLgogIC0gUmVtb3ZlIFZNJ2EgV2ViQXNzZW1ibHkgbWVtb3J5 IC8gc2l6ZSwgYW5kIG9idGFpbiB0aGVtIGZyb20gSW5zdGFuY2UKICAgIGluc3RlYWQuIFRoaXMg cmVxdWlyZXMgYW4gZXh0cmEgaW5kaXJlY3Rpb24sIGJ1dCBpcyBjbGVhbmVyLgotLS0KIEpTVGVz dHMvd2FzbS9CdWlsZGVyLmpzICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDkxICsrKysr Ky0tLS0tLQogSlNUZXN0cy93YXNtL0xvd0xldmVsQmluYXJ5LmpzICAgICAgICAgICAgICAgICAg ICAgfCAgMTIgKysKIEpTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy9leGNlcHRpb25zLmpzICAg ICAgICAgIHwgICA2ICstCiBKU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpz ICAgICAgICAgICB8ICAgMiArLQogSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtc3Rv cmUuanMgICAgICAgICAgfCAgIDIgKy0KIEpTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNt LWJhZC1zaWduYXR1cmUuanMgIHwgMTA1ICsrKysrKysrKysrKysrCiBKU1Rlc3RzL3dhc20vanMt YXBpL3dhc20tdG8td2FzbS5qcyAgICAgICAgICAgICAgICB8ICA3MyArKysrKysrKysrCiBTb3Vy Y2UvSmF2YVNjcmlwdENvcmUvanNjLmNwcCAgICAgICAgICAgICAgICAgICAgICB8ICAzMSArKyst LQogU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmggICAgICAgICAgICAgfCAg IDIgKwogU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVk0uaCAgICAgICAgICAgICAgICAg fCAgIDIgLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuY3Bw ICAgfCAxNTMgKysrKysrKysrKysrKysrLS0tLS0tCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtQjNJUkdlbmVyYXRvci5oICAgICB8ICAgMiArLQogU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbUJpbmRpbmcuY3BwICAgICAgICAgfCAgNDUgKysrKystCiBTb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5oICAgICAgICAgICB8ICAgMiArLQogU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vV2FzbUZvcm1hdC5oICAgICAgICAgICAgfCAgMjYgKystLQogU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmggICAgfCAgMTQgKy0K IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwICAgICAgICAgIHwgICA0 ICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmggICAgICAgICAgICB8 ICAgOCArLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5jcHAg ICAgfCAgMjQgKystLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNl ci5oICAgICAgfCAgIDEgLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uY3Bw ICAgICAgICAgICAgfCAgMzcgKystLS0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Q bGFuLmggICAgICAgICAgICAgIHwgIDEzICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9X YXNtU2lnbmF0dXJlLmNwcCAgICAgICB8ICAxMyArKwogU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbVNpZ25hdHVyZS5oICAgICAgICAgfCAgIDEgKwogU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbVZhbGlkYXRlLmNwcCAgICAgICAgfCAgIDQgKy0KIFNvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5oICAgICAgICAgIHwgICAyICstCiAuLi4vSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaCB8ICAgOCArLQogLi4uL0phdmFT Y3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5jcHAgfCAgIDggKy0KIC4uLi9K YXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuaCAgIHwgIDExICstCiAu Li4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmNwcCB8ICAgOSAr LQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5oICAgfCAg MTYgKy0tCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNw cCB8ICAxMyArLQogLi4uL3dhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVjdG9yLmNw cCAgICAgfCAgMTcgKy0tCiAuLi4vd2FzbS9qcy9XZWJBc3NlbWJseU1lbW9yeUNvbnN0cnVjdG9y LmNwcCAgICAgICB8ICAgNCArLQogLi4uL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVDb25zdHJ1 Y3Rvci5jcHAgICAgICAgfCAgIDIgKy0KIC4uLi93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVj b3JkLmNwcCAgICAgICAgICAgIHwgICA2ICstCiAzNiBmaWxlcyBjaGFuZ2VkLCA1NTAgaW5zZXJ0 aW9ucygrKSwgMjE5IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IEpTVGVzdHMvd2Fz bS9qcy1hcGkvd2FzbS10by13YXNtLWJhZC1zaWduYXR1cmUuanMKIGNyZWF0ZSBtb2RlIDEwMDY0 NCBKU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS5qcwoKZGlmZiAtLWdpdCBhL0pTVGVz dHMvd2FzbS9CdWlsZGVyLmpzIGIvSlNUZXN0cy93YXNtL0J1aWxkZXIuanMKaW5kZXggZGE1ODRj NC4uMjZiYTY2ZSAxMDA2NDQKLS0tIGEvSlNUZXN0cy93YXNtL0J1aWxkZXIuanMKKysrIGIvSlNU ZXN0cy93YXNtL0J1aWxkZXIuanMKQEAgLTM4LDcgKzM4LDcgQEAgY29uc3QgX2lzVmFsaWRWYWx1 ZSA9ICh2YWx1ZSwgdHlwZSkgPT4gewogICAgIHN3aXRjaCAodHlwZSkgewogICAgIC8vIFdlIGFs bG93IGJvdGggc2lnbmVkIGFuZCB1bnNpZ25lZCBudW1iZXJzLgogICAgIGNhc2UgImkzMiI6IHJl dHVybiBNYXRoLnJvdW5kKHZhbHVlKSA9PT0gdmFsdWUgJiYgTExCLnZhcmludDMyTWluIDw9IHZh bHVlICYmIHZhbHVlIDw9IExMQi52YXJ1aW50MzJNYXg7Ci0gICAgY2FzZSAiaTY0IjogdGhyb3cg bmV3IEVycm9yKGBVbmltcGxlbWVudGVkOiB2YWx1ZSBjaGVjayBmb3IgJHt0eXBlfWApOyAvLyBG SVhNRSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNDIwIDY0LWJp dCB2YWx1ZXMKKyAgICBjYXNlICJpNjQiOiByZXR1cm4gdHJ1ZTsgLy8gRklYTUUgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MzQyMCA2NC1iaXQgdmFsdWVzCiAgICAg Y2FzZSAiZjMyIjogcmV0dXJuIHR5cGVvZih2YWx1ZSkgPT09ICJudW1iZXIiICYmIGlzRmluaXRl KHZhbHVlKTsKICAgICBjYXNlICJmNjQiOiByZXR1cm4gdHlwZW9mKHZhbHVlKSA9PT0gIm51bWJl ciIgJiYgaXNGaW5pdGUodmFsdWUpOwogICAgIGRlZmF1bHQ6IHRocm93IG5ldyBFcnJvcihgSW1w bGVtZW50YXRpb24gcHJvYmxlbTogdW5rbm93biB0eXBlICR7dHlwZX1gKTsKQEAgLTU3LDYgKzU3 LDE2IEBAIGNvbnN0IF9ub3JtYWxpemVGdW5jdGlvblNpZ25hdHVyZSA9IChwYXJhbXMsIHJldCkg PT4gewogICAgIHJldHVybiBbcGFyYW1zLCByZXRdOwogfTsKIAorY29uc3QgX2Vycm9ySGFuZGxp bmdQcm94eUZvciA9IGJ1aWxkZXIgPT4gYnVpbGRlclsiX19pc1Byb3h5Il0gPyBidWlsZGVyIDog bmV3IFByb3h5KGJ1aWxkZXIsIHsKKyAgICBnZXQ6ICh0YXJnZXQsIHByb3BlcnR5LCByZWNlaXZl cikgPT4geworICAgICAgICBpZiAocHJvcGVydHkgPT09ICJfX2lzUHJveHkiKQorICAgICAgICAg ICAgcmV0dXJuIHRydWU7CisgICAgICAgIGlmICh0YXJnZXRbcHJvcGVydHldID09PSB1bmRlZmlu ZWQpCisgICAgICAgICAgICB0aHJvdyBuZXcgRXJyb3IoYFdlYkFzc2VtYmx5IGJ1aWxkZXIgcmVj ZWl2ZWQgdW5rbm93biBwcm9wZXJ0eSAnJHtwcm9wZXJ0eX0nYCk7CisgICAgICAgIHJldHVybiB0 YXJnZXRbcHJvcGVydHldOworICAgIH0KK30pOworCiBjb25zdCBfbWF5YmVSZWdpc3RlclR5cGUg PSAoYnVpbGRlciwgdHlwZSkgPT4gewogICAgIGNvbnN0IHR5cGVTZWN0aW9uID0gYnVpbGRlci5f Z2V0U2VjdGlvbigiVHlwZSIpOwogICAgIGlmICh0eXBlb2YodHlwZSkgPT09ICJudW1iZXIiKSB7 CkBAIC0xMDAsNyArMTEwLDcgQEAgY29uc3QgX2ltcG9ydEZ1bmN0aW9uQ29udGludWF0aW9uID0g KGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAgIHNlY3Rpb24uZGF0 YS5wdXNoKHsgZmllbGQ6IGZpZWxkLCB0eXBlOiB0eXBlLCBraW5kOiAiRnVuY3Rpb24iLCBtb2R1 bGU6IG1vZHVsZSB9KTsKICAgICAgICAgLy8gSW1wb3J0cyBhbHNvIGNvdW50IGluIHRoZSBmdW5j dGlvbiBpbmRleCBzcGFjZS4gTWFwIHRoZW0gYXMgb2JqZWN0cyB0byBhdm9pZCBjbGFzaGluZyB3 aXRoIENvZGUgZnVuY3Rpb25zJyBuYW1lcy4KICAgICAgICAgYnVpbGRlci5fcmVnaXN0ZXJGdW5j dGlvblRvSW5kZXhTcGFjZSh7IG1vZHVsZTogbW9kdWxlLCBmaWVsZDogZmllbGQgfSk7Ci0gICAg ICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJv eHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH07CiB9OwogCkBAIC0xMDksNyArMTE5LDcgQEAgY29u c3QgX2ltcG9ydE1lbW9yeUNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVp bGRlcikgPT4gewogICAgICAgICBhc3NlcnQuaXNTdHJpbmcobW9kdWxlLCBgSW1wb3J0IE1lbW9y eSBtb2R1bGUgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7bW9kdWxlfSJgKTsKICAgICAgICAg YXNzZXJ0LmlzU3RyaW5nKGZpZWxkLCBgSW1wb3J0IE1lbW9yeSBmaWVsZCBzaG91bGQgYmUgYSBz dHJpbmcsIGdvdCAiJHtmaWVsZH0iYCk7CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHttb2R1 bGUsIGZpZWxkLCBraW5kOiAiTWVtb3J5IiwgbWVtb3J5RGVzY3JpcHRpb246IHtpbml0aWFsLCBt YXhpbXVtfX0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBf ZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9OwogfTsKIApAQCAtMTE4 LDcgKzEyOCw3IEBAIGNvbnN0IF9pbXBvcnRUYWJsZUNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBz ZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgICAgICBhc3NlcnQuaXNTdHJpbmcobW9kdWxl LCBgSW1wb3J0IFRhYmxlIG1vZHVsZSBzaG91bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHttb2R1bGV9 ImApOwogICAgICAgICBhc3NlcnQuaXNTdHJpbmcoZmllbGQsIGBJbXBvcnQgVGFibGUgZmllbGQg c2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7ZmllbGR9ImApOwogICAgICAgICBzZWN0aW9uLmRh dGEucHVzaCh7bW9kdWxlLCBmaWVsZCwga2luZDogIlRhYmxlIiwgdGFibGVEZXNjcmlwdGlvbjog e2luaXRpYWwsIG1heGltdW0sIGVsZW1lbnR9fSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRl cjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwog ICAgIH07CiB9OwogCkBAIC0xNzIsNyArMTgyLDcgQEAgY29uc3QgX2V4cG9ydEZ1bmN0aW9uQ29u dGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAg ICAgICAgICAgYXNzZXJ0LmVxKHR5cGUsIGV4cG9ydGVkSW1wb3J0LnR5cGUsIGBSZS1leHBvcnRp bmcgaW1wb3J0ICIke2V4cG9ydGVkSW1wb3J0LmZpZWxkfSIgYXMgIiR7ZmllbGR9IiBoYXMgbWlz bWF0Y2hpbmcgdHlwZWApOwogICAgICAgICB9CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHsg ZmllbGQ6IGZpZWxkLCB0eXBlOiB0eXBlLCBraW5kOiAiRnVuY3Rpb24iLCBpbmRleDogaW5kZXgg fSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhh bmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH07CiB9OwogCkBAIC0xODksNyArMTk5 LDcgQEAgY29uc3QgX2V4cG9ydEdsb2JhbENvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9u LCBuZXh0QnVpbGRlcikgPT4gewogICAgIHJldHVybiAoZmllbGQsIGluZGV4KSA9PiB7CiAgICAg ICAgIGFzc2VydC5pc051bWJlcihpbmRleCwgYEdsb2JhbCBleHBvcnRzIG9ubHkgc3VwcG9ydCBu dW1iZXIgaW5kaWNlcyByaWdodCBub3dgKTsKICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2goeyBm aWVsZCwga2luZDogIkdsb2JhbCIsIGluZGV4IH0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxk ZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsK ICAgICB9CiB9OwogCkBAIC0xOTcsNyArMjA3LDcgQEAgY29uc3QgX2V4cG9ydE1lbW9yeUNvbnRp bnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgIHJldHVy biAoZmllbGQsIGluZGV4KSA9PiB7CiAgICAgICAgIGFzc2VydC5pc051bWJlcihpbmRleCwgYE1l bW9yeSBleHBvcnRzIG9ubHkgc3VwcG9ydCBudW1iZXIgaW5kaWNlc2ApOwogICAgICAgICBzZWN0 aW9uLmRhdGEucHVzaCh7ZmllbGQsIGtpbmQ6ICJNZW1vcnkiLCBpbmRleH0pOwotICAgICAgICBy ZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9y KG5leHRCdWlsZGVyKTsKICAgICB9CiB9OwogCkBAIC0yMDUsNyArMjE1LDcgQEAgY29uc3QgX2V4 cG9ydFRhYmxlQ29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9 PiB7CiAgICAgcmV0dXJuIChmaWVsZCwgaW5kZXgpID0+IHsKICAgICAgICAgYXNzZXJ0LmlzTnVt YmVyKGluZGV4LCBgVGFibGUgZXhwb3J0cyBvbmx5IHN1cHBvcnQgbnVtYmVyIGluZGljZXNgKTsK ICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2goe2ZpZWxkLCBraW5kOiAiVGFibGUiLCBpbmRleH0p OwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5k bGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9CiB9OwogCkBAIC0yMjAsMTAgKzIzMCwx MCBAQCBjb25zdCBfaW1wb3J0R2xvYmFsQ29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24s IG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAgICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKGZpZWxk LCBgSW1wb3J0IGdsb2JhbCBmaWVsZCBzaG91bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHtmaWVsZH0i YCk7CiAgICAgICAgICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKG11dGFiaWxpdHksIGBJbXBvcnQg Z2xvYmFsIG11dGFiaWxpdHkgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7bXV0YWJpbGl0eX0i YCk7CiAgICAgICAgICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2goeyBnbG9iYWxEZXNjcmlwdGlv bjogeyB0eXBlOiBvcCwgbXV0YWJpbGl0eTogX25vcm1hbGl6ZU11dGFiaWxpdHkobXV0YWJpbGl0 eSkgfSwgbW9kdWxlLCBmaWVsZCwga2luZDogIkdsb2JhbCIgfSk7Ci0gICAgICAgICAgICAgICAg cmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRs aW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7CiAgICAgICAgICAgICB9OwogICAgICAgICB9Ci0g ICAgICAgIHJldHVybiBnbG9iYWxCdWlsZGVyOworICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxp bmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICB9OwogfTsKIApAQCAtMzI0LDExICszMzQs MTEgQEAgY29uc3QgX2NyZWF0ZUZ1bmN0aW9uQnVpbGRlciA9IChmdW5jLCBidWlsZGVyLCBwcmV2 aW91c0J1aWxkZXIpID0+IHsKICAgICAgICAgICAgIGRlZmF1bHQ6CiAgICAgICAgICAgICAgICAg bmV4dEJ1aWxkZXIgPSBmdW5jdGlvbkJ1aWxkZXI7CiAgICAgICAgICAgICAgICAgYnJlYWs7Ci0g ICAgICAgICAgICAgICAgY2FzZSAiRW5kIjoKKyAgICAgICAgICAgIGNhc2UgIkVuZCI6CiAgICAg ICAgICAgICAgICAgbmV4dEJ1aWxkZXIgPSBwcmV2aW91c0J1aWxkZXI7Ci0gICAgICAgICAgICAg ICAgICAgIGJyZWFrOworICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICAgY2FzZSAi QmxvY2siOgotICAgICAgICAgICAgICAgIGNhc2UgIkxvb3AiOgorICAgICAgICAgICAgY2FzZSAi TG9vcCI6CiAgICAgICAgICAgICBjYXNlICJJZiI6CiAgICAgICAgICAgICAgICAgbmV4dEJ1aWxk ZXIgPSBfY3JlYXRlRnVuY3Rpb25CdWlsZGVyKGZ1bmMsIGJ1aWxkZXIsIGZ1bmN0aW9uQnVpbGRl cik7CiAgICAgICAgICAgICAgICAgYnJlYWs7CkBAIC0zNDQsMTEgKzM1NCwxMiBAQCBjb25zdCBf Y3JlYXRlRnVuY3Rpb25CdWlsZGVyID0gKGZ1bmMsIGJ1aWxkZXIsIHByZXZpb3VzQnVpbGRlcikg PT4gewogICAgICAgICAgICAgY29uc3Qgc3RhY2tBcmdzID0gW107IC8vIEZJWE1FIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjI3MDYKICAgICAgICAgICAgIGZ1bmMu Y29kZS5wdXNoKHsgbmFtZTogb3AsIHZhbHVlOiB2YWx1ZSwgYXJndW1lbnRzOiBzdGFja0FyZ3Ms IGltbWVkaWF0ZXM6IGltbXMgfSk7CiAgICAgICAgICAgICBpZiAoaGFzQ29udGludWF0aW9uKQot ICAgICAgICAgICAgICAgIHJldHVybiBjb250aW51YXRpb24obmV4dEJ1aWxkZXIpLkVuZCgpOwot ICAgICAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICAgICAgICAgIHJldHVybiBf ZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGNvbnRpbnVhdGlvbihuZXh0QnVpbGRlcikuRW5kKCkpOwor ICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwog ICAgICAgICB9OwotICAgIH0KLSAgICByZXR1cm4gZnVuY3Rpb25CdWlsZGVyOworICAgIH07CisK KyAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihmdW5jdGlvbkJ1aWxkZXIpOwogfQog CiBjb25zdCBfY3JlYXRlRnVuY3Rpb24gPSAoc2VjdGlvbiwgYnVpbGRlciwgcHJldmlvdXNCdWls ZGVyKSA9PiB7CkBAIC00NDksMTAgKzQ2MCwxMCBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWls ZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgIEZ1bmM6IChwYXJhbXMsIHJldCkgPT4gewog ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtwYXJhbXMsIHJldF0gPSBfbm9ybWFsaXplRnVu Y3Rpb25TaWduYXR1cmUocGFyYW1zLCByZXQpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAg IHMuZGF0YS5wdXNoKHsgcGFyYW1zOiBwYXJhbXMsIHJldDogcmV0IH0pOwotICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHJldHVybiB0eXBlQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih0eXBlQnVpbGRlcik7CiAgICAg ICAgICAgICAgICAgICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAg ICAgICAgICAgICByZXR1cm4gdHlwZUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVy biBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHR5cGVCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9 OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC00NjYsNyArNDc3LDcgQEAgZXhwb3J0IGRl ZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgIGltcG9ydEJ1aWxkZXIu RnVuY3Rpb24gPSBfaW1wb3J0RnVuY3Rpb25Db250aW51YXRpb24odGhpcywgcywgaW1wb3J0QnVp bGRlcik7CiAgICAgICAgICAgICAgICAgICAgIGltcG9ydEJ1aWxkZXIuTWVtb3J5ID0gX2ltcG9y dE1lbW9yeUNvbnRpbnVhdGlvbih0aGlzLCBzLCBpbXBvcnRCdWlsZGVyKTsKICAgICAgICAgICAg ICAgICAgICAgaW1wb3J0QnVpbGRlci5UYWJsZSA9IF9pbXBvcnRUYWJsZUNvbnRpbnVhdGlvbih0 aGlzLCBzLCBpbXBvcnRCdWlsZGVyKTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGltcG9y dEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5 Rm9yKGltcG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAg YnJlYWs7CiAKQEAgLTQ3Nyw3ICs0ODgsNyBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVy IHsKICAgICAgICAgICAgICAgICAgICAgICAgIEVuZDogKCkgPT4gdGhpcwogICAgICAgICAgICAg ICAgICAgICAgICAgLy8gRklYTUU6IGFkZCBhYmlsaXR5IHRvIGFkZCB0aGlzIHdpdGggd2hhdGV2 ZXIuCiAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiBm dW5jdGlvbkJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGlu Z1Byb3h5Rm9yKGZ1bmN0aW9uQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAg ICAgICAgICBicmVhazsKIApAQCAtNDg4LDEwICs0OTksMTAgQEAgZXhwb3J0IGRlZmF1bHQgY2xh c3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBFbmQ6ICgpID0+IHRoaXMsCiAg ICAgICAgICAgICAgICAgICAgICAgICBUYWJsZTogKHtpbml0aWFsLCBtYXhpbXVtLCBlbGVtZW50 fSkgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKHt0YWJsZURl c2NyaXB0aW9uOiB7aW5pdGlhbCwgbWF4aW11bSwgZWxlbWVudH19KTsKLSAgICAgICAgICAgICAg ICAgICAgICAgICAgICByZXR1cm4gdGFibGVCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHRhYmxlQnVpbGRlcik7CiAgICAg ICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAgICAgICAg ICAgICAgICAgIHJldHVybiB0YWJsZUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVy biBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHRhYmxlQnVpbGRlcik7CiAgICAgICAgICAgICAgICAg fTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNTAyLDEwICs1MTMsMTAgQEAgZXhwb3J0 IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBFbmQ6ICgp ID0+IHRoaXMsCiAgICAgICAgICAgICAgICAgICAgICAgICBJbml0aWFsTWF4UGFnZXM6IChpbml0 aWFsLCBtYXgpID0+IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaCh7 IGluaXRpYWwsIG1heCB9KTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gbWVt b3J5QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFu ZGxpbmdQcm94eUZvcihtZW1vcnlCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH0K ICAgICAgICAgICAgICAgICAgICAgfTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIG1lbW9y eUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5 Rm9yKG1lbW9yeUJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAg YnJlYWs7CiAKQEAgLTUxNiwxNiArNTI3LDE2IEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxk ZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRW5kOiAoKSA9PiB0aGlzLAogICAgICAgICAg ICAgICAgICAgICAgICAgR2V0R2xvYmFsOiAodHlwZSwgaW5pdFZhbHVlLCBtdXRhYmlsaXR5KSA9 PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcy5kYXRhLnB1c2goeyB0eXBlLCBvcDog ImdldF9nbG9iYWwiLCBtdXRhYmlsaXR5OiBfbm9ybWFsaXplTXV0YWJpbGl0eShtdXRhYmlsaXR5 KSwgaW5pdFZhbHVlIH0pOwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBnbG9i YWxCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5k bGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAgICAgfQog ICAgICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgICAgICBmb3IgKGxldCBvcCBv ZiBXQVNNLmRlc2NyaXB0aW9uLnZhbHVlX3R5cGUpIHsKICAgICAgICAgICAgICAgICAgICAgICAg IGdsb2JhbEJ1aWxkZXJbX3RvSmF2YVNjcmlwdE5hbWUob3ApXSA9IChpbml0VmFsdWUsIG11dGFi aWxpdHkpID0+IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaCh7IHR5 cGU6IG9wLCBvcDogb3AgKyAiLmNvbnN0IiwgbXV0YWJpbGl0eTogX25vcm1hbGl6ZU11dGFiaWxp dHkobXV0YWJpbGl0eSksIGluaXRWYWx1ZSB9KTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAg ICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1 cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICAgICAgICAgICAg ICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgICAgICAgICAg cmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JI YW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAg ICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTUzOSw3ICs1NTAsNyBAQCBleHBvcnQgZGVmYXVsdCBj bGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgZXhwb3J0QnVpbGRlci5GdW5jdGlv biA9IF9leHBvcnRGdW5jdGlvbkNvbnRpbnVhdGlvbih0aGlzLCBzLCBleHBvcnRCdWlsZGVyKTsK ICAgICAgICAgICAgICAgICAgICAgZXhwb3J0QnVpbGRlci5NZW1vcnkgPSBfZXhwb3J0TWVtb3J5 Q29udGludWF0aW9uKHRoaXMsIHMsIGV4cG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAg ICBleHBvcnRCdWlsZGVyLlRhYmxlID0gX2V4cG9ydFRhYmxlQ29udGludWF0aW9uKHRoaXMsIHMs IGV4cG9ydEJ1aWxkZXIpOwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gZXhwb3J0QnVpbGRl cjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZXhw b3J0QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsK IApAQCAtNTUyLDcgKzU2Myw3IEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAg ICAgICAgICAgICAgICAgICBpZiAodHlwZW9mKGZ1bmN0aW9uSW5kZXhPck5hbWUpICE9PSAibnVt YmVyIiAmJiB0eXBlb2YoZnVuY3Rpb25JbmRleE9yTmFtZSkgIT09ICJzdHJpbmciKQogICAgICAg ICAgICAgICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBTdGFydCBzZWN0aW9uJ3MgZnVuY3Rp b24gaW5kZXggIG11c3QgZWl0aGVyIGJlIGEgbnVtYmVyIG9yIGEgc3RyaW5nYCk7CiAgICAgICAg ICAgICAgICAgICAgIHMuZGF0YS5wdXNoKGZ1bmN0aW9uSW5kZXhPck5hbWUpOwotICAgICAgICAg ICAgICAgICAgICByZXR1cm4gc3RhcnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1 cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihzdGFydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAg IH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTU2MywxMSArNTc0LDExIEBAIGV4cG9y dCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRW5kOiAo KSA9PiB0aGlzLAogICAgICAgICAgICAgICAgICAgICAgICAgRWxlbWVudDogKHt0YWJsZUluZGV4 ID0gMCwgb2Zmc2V0LCBmdW5jdGlvbkluZGljZXN9KSA9PiB7CiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgcy5kYXRhLnB1c2goe3RhYmxlSW5kZXgsIG9mZnNldCwgZnVuY3Rpb25JbmRpY2Vz fSk7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGVsZW1lbnRCdWlsZGVyOwor ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9y KGVsZW1lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAg ICAgICAgICAgfTsKIAotICAgICAgICAgICAgICAgICAgICByZXR1cm4gZWxlbWVudEJ1aWxkZXI7 CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGVsZW1l bnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwog CkBAIC02MzIsMTIgKzY0MywxMiBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIEZJWE1FIGluIGNoZWNrZWQgbW9k ZSwgdGVzdCB0aGF0IHRoZSB0eXBlIGlzIGFjY2VwdGFibGUgZm9yIHN0YXJ0IGZ1bmN0aW9uLiBX ZSBwcm9iYWJseSB3YW50IF9yZWdpc3RlckZ1bmN0aW9uVG9JbmRleFNwYWNlIHRvIGFsc28gcmVn aXN0ZXIgdHlwZXMgcGVyIGluZGV4LiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MTY1NjU4CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJu IGJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRs aW5nUHJveHlGb3IoYnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICB9LAogCiAgICAg ICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgICAgIGNvZGVCdWlsZGVyLkZ1bmN0 aW9uID0gX2NyZWF0ZUZ1bmN0aW9uKHMsIGJ1aWxkZXIsIGNvZGVCdWlsZGVyKTsKLSAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIGNvZGVCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1 cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihjb2RlQnVpbGRlcik7CiAgICAgICAgICAgICAgICAg fTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNjYwLDE5ICs2NzEsMTkgQEAgZXhwb3J0 IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IEluZGV4OiBpbmRleCA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBh c3NlcnQuZXEoaW5kZXgsIDApOyAvLyBMaW5lYXIgbWVtb3J5IGluZGV4IG11c3QgYmUgemVybyBp biBNVlAuCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0aGlzU2VnbWVudC5p bmRleCA9IGluZGV4OwotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJu IHNlZ21lbnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0 dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3Ioc2VnbWVudEJ1aWxkZXIpOwogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBP ZmZzZXQ6IG9mZnNldCA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAv LyBGSVhNRSBhbGxvdyBjb21wbGV4IGluaXRfZXhwciBoZXJlLiBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1NzAwCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBhc3NlcnQuaXNOdW1iZXIob2Zmc2V0KTsKICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHRoaXNTZWdtZW50Lm9mZnNldCA9IG9mZnNldDsKLSAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBzZWdtZW50QnVpbGRlcjsKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHNl Z21lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfSwKICAgICAg ICAgICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJl dHVybiBzZWdtZW50QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4g X2Vycm9ySGFuZGxpbmdQcm94eUZvcihzZWdtZW50QnVpbGRlcik7CiAgICAgICAgICAgICAgICAg ICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gZGF0YUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5k bGluZ1Byb3h5Rm9yKGRhdGFCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAgICAg ICAgICAgIGJyZWFrOwogCkBAIC02OTAsMTAgKzcwMSwxMCBAQCBleHBvcnQgZGVmYXVsdCBjbGFz cyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICBCeXRlOiBiID0+IHsKICAgICAgICAgICAgICAg ICAgICAgYXNzZXJ0LmVxKGIgJiAweEZGLCBiLCBgVW5rbm93biBzZWN0aW9uIGV4cGVjdGVkIGJ5 dGUsIGdvdDogIiR7Yn0iYCk7CiAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKGIpOwot ICAgICAgICAgICAgICAgICAgICByZXR1cm4gdW5rbm93bkJ1aWxkZXI7CisgICAgICAgICAgICAg ICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHVua25vd25CdWlsZGVyKTsKICAg ICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9OwotICAgICAgICAgICAgcmV0dXJuIHVua25v d25CdWlsZGVyOworICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IodW5r bm93bkJ1aWxkZXIpOwogICAgICAgICB9OwogICAgIH0KICAgICBfYWRkU2VjdGlvbihuYW1lT3JO dW1iZXIsIGV4dHJhT2JqZWN0KSB7CmRpZmYgLS1naXQgYS9KU1Rlc3RzL3dhc20vTG93TGV2ZWxC aW5hcnkuanMgYi9KU1Rlc3RzL3dhc20vTG93TGV2ZWxCaW5hcnkuanMKaW5kZXggNjExYTI2ZC4u ZjliYzhhMyAxMDA2NDQKLS0tIGEvSlNUZXN0cy93YXNtL0xvd0xldmVsQmluYXJ5LmpzCisrKyBi L0pTVGVzdHMvd2FzbS9Mb3dMZXZlbEJpbmFyeS5qcwpAQCAtMTcwLDYgKzE3MCwxOCBAQCBleHBv cnQgZGVmYXVsdCBjbGFzcyBMb3dMZXZlbEJpbmFyeSB7CiAgICAgICAgICAgICB0aGlzLnVpbnQ4 KDB4ODAgfCBiKTsKICAgICAgICAgfSB3aGlsZSAodHJ1ZSk7CiAgICAgfQorICAgIHZhcnVpbnQ2 NCh2KSB7CisgICAgICAgIGFzc2VydC5pc051bWJlcih2KTsKKyAgICAgICAgaWYgKHYgPCB2YXJ1 aW50MzJNaW4gfHwgdmFydWludDMyTWF4IDwgdikKKyAgICAgICAgICAgIHRocm93IG5ldyBSYW5n ZUVycm9yKGB1bmltcGxlbWVudGVkOiB2YXJ1aW50NjQgbGFyZ2VyIHRoYW4gMzItYml0YCk7Cisg ICAgICAgIHRoaXMudmFydWludDMyKHYpOyAvLyBGSVhNRSBpbXBsZW1lbnQgNjQtYml0IHZhcnt1 fWludCBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNDIwCisgICAg fQorICAgIHZhcmludDY0KHYpIHsKKyAgICAgICAgYXNzZXJ0LmlzTnVtYmVyKHYpOworICAgICAg ICBpZiAodiA8IHZhcmludDMyTWluIHx8IHZhcmludDMyTWF4IDwgdikKKyAgICAgICAgICAgIHRo cm93IG5ldyBSYW5nZUVycm9yKGB1bmltcGxlbWVudGVkOiB2YXJpbnQ2NCBsYXJnZXIgdGhhbiAz Mi1iaXRgKTsKKyAgICAgICAgdGhpcy52YXJpbnQzMih2KTsgLy8gRklYTUUgaW1wbGVtZW50IDY0 LWJpdCB2YXJ7dX1pbnQgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2 MzQyMAorICAgIH0KICAgICB2YXJ1aW50MSh2KSB7CiAgICAgICAgIGlmICh2ICE9PSAwICYmIHYg IT09IDEpCiAgICAgICAgICAgICB0aHJvdyBuZXcgUmFuZ2VFcnJvcihgSW52YWxpZCB2YXJ1aW50 MSAke3Z9IHJhbmdlIGlzIFswLCAxXWApOwpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2Z1bmN0 aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvZXhj ZXB0aW9ucy5qcwppbmRleCBkMmIzYTQ5Li45NTI1MTNmIDEwMDY0NAotLS0gYS9KU1Rlc3RzL3dh c20vZnVuY3Rpb24tdGVzdHMvZXhjZXB0aW9ucy5qcworKysgYi9KU1Rlc3RzL3dhc20vZnVuY3Rp b24tdGVzdHMvZXhjZXB0aW9ucy5qcwpAQCAtNDUsMTggKzQ1LDE4IEBAIGZ1bmN0aW9uIG1ha2VJ bnN0YW5jZSgpIHsKICAgICBhc3NlcnQuZXEodGFibGUuZ2V0KDApLCBudWxsKTsKIAogICAgIGZv ciAobGV0IGkgPSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0gICAgICAgIGFzc2VydC50aHJvd3MoKCkg PT4gZm9vKDAsIGkpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJjYWxsX2luZGlyZWN0IHRv IGEgbnVsbCB0YWJsZSBlbnRyeSAoZXZhbHVhdGluZyAnZnVuYyguLi5hcmdzKScpIik7CisgICAg ICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDAsIGkpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJy b3IsICJjYWxsX2luZGlyZWN0IHRvIGEgbnVsbCB0YWJsZSBlbnRyeSIpOwogICAgIH0KIAogICAg IHRhYmxlLnNldCgwLCBmb28pOwogICAgIGFzc2VydC5lcSh0YWJsZS5nZXQoMCksIGZvbyk7CiAK ICAgICBmb3IgKGxldCBpID0gMDsgaSA8IDEwMDA7IGkrKykgewotICAgICAgICBhc3NlcnQudGhy b3dzKCgpID0+IGZvbygxICsgaSwgaSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgIk91dCBv ZiBib3VuZHMgY2FsbF9pbmRpcmVjdCAoZXZhbHVhdGluZyAnZnVuYyguLi5hcmdzKScpIik7Cisg ICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDEgKyBpLCBpKSwgV2ViQXNzZW1ibHkuUnVu dGltZUVycm9yLCAiT3V0IG9mIGJvdW5kcyBjYWxsX2luZGlyZWN0Iik7CiAgICAgfQogCiAgICAg Zm9yIChsZXQgaSA9IDA7IGkgPCAxMDAwOyBpKyspIHsKLSAgICAgICAgYXNzZXJ0LnRocm93cygo KSA9PiBmb28oMCwgaSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgImNhbGxfaW5kaXJlY3Qg dG8gYSBzaWduYXR1cmUgdGhhdCBkb2VzIG5vdCBtYXRjaCAoZXZhbHVhdGluZyAnZnVuYyguLi5h cmdzKScpIik7CisgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDAsIGkpLCBXZWJBc3Nl bWJseS5SdW50aW1lRXJyb3IsICJjYWxsX2luZGlyZWN0IHRvIGEgc2lnbmF0dXJlIHRoYXQgZG9l cyBub3QgbWF0Y2giKTsKICAgICB9CiAKICAgICB0YWJsZS5zZXQoMCwgYmFyKTsKZGlmZiAtLWdp dCBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMgYi9KU1Rlc3RzL3dh c20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpzCmluZGV4IDRkZDgyZGMuLjEyMzFlMDMgMTAw NjQ0Ci0tLSBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMKKysrIGIv SlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtbG9hZC5qcwpAQCAtMjksNiArMjksNiBA QCBmdW5jdGlvbiB3YXNtRnJhbWVDb3VudEZyb21FcnJvcihlKSB7CiB9CiAKIGZvciAobGV0IGkg PSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0gICAgY29uc3QgZSA9IGFzc2VydC50aHJvd3MoKCkgPT4g Zm9vKG51bVBhZ2VzICogcGFnZVNpemUgKyAxKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9yLCAi T3V0IG9mIGJvdW5kcyBtZW1vcnkgYWNjZXNzIChldmFsdWF0aW5nICdmdW5jKC4uLmFyZ3MpJyki KTsKKyAgICBjb25zdCBlID0gYXNzZXJ0LnRocm93cygoKSA9PiBmb28obnVtUGFnZXMgKiBwYWdl U2l6ZSArIDEpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJPdXQgb2YgYm91bmRzIG1lbW9y eSBhY2Nlc3MiKTsKICAgICBhc3NlcnQuZXEod2FzbUZyYW1lQ291bnRGcm9tRXJyb3IoZSksIDIp OwogfQpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtc3RvcmUu anMgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5qcwppbmRleCA1NTk4 N2MyLi4zNjU3MTNhIDEwMDY0NAotLS0gYS9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJh cC1zdG9yZS5qcworKysgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5q cwpAQCAtMjUsNSArMjUsNSBAQCBjb25zdCBudW1QYWdlcyA9IDEwOwogICAgIGNvbnN0IGZvbyA9 IG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShtb2R1bGUsIHthOiB7YjogbmV3IFdlYkFzc2VtYmx5 Lk1lbW9yeSh7aW5pdGlhbDogbnVtUGFnZXN9KX19KS5leHBvcnRzLmZvbzsKIAogICAgIGZvciAo bGV0IGkgPSAwOyBpIDwgMTAwMDA7IGkrKykKLSAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBm b28oaSwgbnVtUGFnZXMgKiBwYWdlU2l6ZSArIDEpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3Is ICJPdXQgb2YgYm91bmRzIG1lbW9yeSBhY2Nlc3MgKGV2YWx1YXRpbmcgJ2Z1bmMoLi4uYXJncykn KSIpOworICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbyhpLCBudW1QYWdlcyAqIHBhZ2VT aXplICsgMSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgIk91dCBvZiBib3VuZHMgbWVtb3J5 IGFjY2VzcyIpOwogfQpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdh c20tYmFkLXNpZ25hdHVyZS5qcyBiL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLWJh ZC1zaWduYXR1cmUuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2U3MGQ3 OAotLS0gL2Rldi9udWxsCisrKyBiL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLWJh ZC1zaWduYXR1cmUuanMKQEAgLTAsMCArMSwxMDUgQEAKK2ltcG9ydCAqIGFzIGFzc2VydCBmcm9t ICcuLi9hc3NlcnQuanMnOworaW1wb3J0IEJ1aWxkZXIgZnJvbSAnLi4vQnVpbGRlci5qcyc7CisK K2NvbnN0IGltcG9ydE5hbWUgPSAicGllck9uZSI7Citjb25zdCB0eXBlcyA9IFsiaTMyIiwgImk2 NCIsICJmMzIiLCAiZjY0IiwgInZvaWQiXTsKK2NvbnN0IHR5cGVzTm9uVm9pZCA9IFsiaTMyIiwg Imk2NCIsICJmMzIiLCAiZjY0Il07Citjb25zdCBzd2FwVHlwZSA9ICh0eXBlLCBpbmRleCkgPT4g dHlwZXNbKHR5cGVzLmluZGV4T2YodHlwZSkgKyBpbmRleCkgJSB0eXBlcy5sZW5ndGhdOworY29u c3Qgc3dhcFR5cGVOb25Wb2lkID0gKHR5cGUsIGluZGV4KSA9PiB0eXBlc05vblZvaWRbKHR5cGVz Tm9uVm9pZC5pbmRleE9mKHR5cGUpICsgaW5kZXgpICUgdHlwZXNOb25Wb2lkLmxlbmd0aF07CisK K2NvbnN0IHNpZ25hdHVyZXMgPSBbCisgICAgeyBwYXJhbXM6IFsiaTMyIl0sIHJldDogInZvaWQi IH0sCisgICAgeyBwYXJhbXM6IFsiaTY0Il0sIHJldDogInZvaWQiIH0sCisgICAgeyBwYXJhbXM6 IFsiZjMyIl0sIHJldDogInZvaWQiIH0sCisgICAgeyBwYXJhbXM6IFsiZjY0Il0sIHJldDogInZv aWQiIH0sCisgICAgeyBwYXJhbXM6IFsiaTMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7IHBhcmFt czogWyJpNjQiXSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBbImYzMiJdLCByZXQ6ICJm MzIiIH0sCisgICAgeyBwYXJhbXM6IFsiZjY0Il0sIHJldDogImY2NCIgfSwKKyAgICB7IHBhcmFt czogWyJpMzIiLCAiZjMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7IHBhcmFtczogWyJmMzIiLCAi aTMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7IHBhcmFtczogWyJpNjQiLCAiZjY0Il0sIHJldDog Imk2NCIgfSwKKyAgICB7IHBhcmFtczogWyJmNjQiLCAiaTY0Il0sIHJldDogImk2NCIgfSwKKyAg ICB7IHBhcmFtczogWyJpMzIiLCAiZjMyIiwgImkzMiJdLCByZXQ6ICJpMzIiIH0sCisgICAgeyBw YXJhbXM6IFsiaTMyIiwgImYzMiIsICJpMzIiXSwgcmV0OiAiaTMyIiB9LAorICAgIHsgcGFyYW1z OiBbImk2NCIsICJmNjQiLCAiaTY0Il0sIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogWyJp NjQiLCAiZjY0IiwgImk2NCJdLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IEFycmF5KDMy KS5maWxsKCJpMzIiKSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBBcnJheSgzMikuZmls bCgiaTY0IiksIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogQXJyYXkoMzIpLmZpbGwoImYz MiIpLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IEFycmF5KDMyKS5maWxsKCJmNjQiKSwg cmV0OiAiaTY0IiB9LAorXTsKKworY29uc3QgbWFrZUltcG9ydGVyID0gc2lnbmF0dXJlID0+IHsK KyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAgIC5UeXBlKCkuRW5k KCkKKyAgICAgICAgLkltcG9ydCgpLkZ1bmN0aW9uKCJleHBvcnRzIiwgaW1wb3J0TmFtZSwgc2ln bmF0dXJlKS5FbmQoKTsKKyAgICByZXR1cm4gbmV3IFdlYkFzc2VtYmx5Lk1vZHVsZShidWlsZGVy LldlYkFzc2VtYmx5KCkuZ2V0KCkpOworfTsKKworY29uc3QgbWFrZUltcG9ydGVlID0gc2lnbmF0 dXJlID0+IHsKKyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAgIC5U eXBlKCkuRW5kKCkKKyAgICAgICAgLkZ1bmN0aW9uKCkuRW5kKCkKKyAgICAgICAgLkV4cG9ydCgp CisgICAgICAgICAgICAuRnVuY3Rpb24oaW1wb3J0TmFtZSkKKyAgICAgICAgLkVuZCgpCisgICAg ICAgIC5Db2RlKCkKKyAgICAgICAgICAgIC5GdW5jdGlvbihpbXBvcnROYW1lLCBzaWduYXR1cmUp OworICAgIHN3aXRjaCAoc2lnbmF0dXJlLnJldCkgeworICAgIGNhc2UgImkzMiI6IGJ1aWxkZXIu STMyQ29uc3QoMCk7IGJyZWFrOworICAgIGNhc2UgImk2NCI6IGJ1aWxkZXIuSTY0Q29uc3QoMCk7 IGJyZWFrOworICAgIGNhc2UgImYzMiI6IGJ1aWxkZXIuRjMyQ29uc3QoMCk7IGJyZWFrOworICAg IGNhc2UgImY2NCI6IGJ1aWxkZXIuRjY0Q29uc3QoMCk7IGJyZWFrOworICAgIGNhc2UgInZvaWQi OiBicmVhazsKKyAgICB9CisgICAgcmV0dXJuIG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShuZXcg V2ViQXNzZW1ibHkuTW9kdWxlKGJ1aWxkZXIuUmV0dXJuKCkuRW5kKCkuRW5kKCkuV2ViQXNzZW1i bHkoKS5nZXQoKSkpOworfTsKKworKGZ1bmN0aW9uIEJhZFNpZ25hdHVyZURyb3BTdGFydFBhcmFt cygpIHsKKyAgICBmb3IgKGxldCBzaWduYXR1cmUgb2Ygc2lnbmF0dXJlcykgeworICAgICAgICBj b25zdCBpbXBvcnRlZSA9IG1ha2VJbXBvcnRlZShzaWduYXR1cmUpOworICAgICAgICBmb3IgKGxl dCBpID0gMTsgaSA8PSBzaWduYXR1cmUucGFyYW1zLmxlbmd0aDsgKytpKSB7CisgICAgICAgICAg ICBjb25zdCBiYWRQYXJhbVNpZ25hdHVyZSA9IHsgcGFyYW1zOiBzaWduYXR1cmUucGFyYW1zLnNs aWNlKGksIHNpZ25hdHVyZS5wYXJhbXMubGVuZ3RoKSwgcmV0OiBzaWduYXR1cmUucmV0IH07Cisg ICAgICAgICAgICBjb25zdCBpbXBvcnRlciA9IG1ha2VJbXBvcnRlcihiYWRQYXJhbVNpZ25hdHVy ZSk7CisgICAgICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IG5ldyBXZWJBc3NlbWJseS5JbnN0 YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpLCBXZWJBc3NlbWJseS5MaW5rRXJyb3IsIGBpbXBvcnRl ZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBtaXNtYXRjaGVzIHRoZSBwcm92aWRlZCBXZWJBc3NlbWJs eSBmdW5jdGlvbidzIHNpZ25hdHVyZSAoZXZhbHVhdGluZyAnbmV3IFdlYkFzc2VtYmx5Lkluc3Rh bmNlKGltcG9ydGVyLCBpbXBvcnRlZSknKWApOworICAgICAgICB9CisgICAgfQorfSkoKTsKKwor KGZ1bmN0aW9uIEJhZFNpZ25hdHVyZURyb3BFbmRQYXJhbXMoKSB7CisgICAgZm9yIChsZXQgc2ln bmF0dXJlIG9mIHNpZ25hdHVyZXMpIHsKKyAgICAgICAgY29uc3QgaW1wb3J0ZWUgPSBtYWtlSW1w b3J0ZWUoc2lnbmF0dXJlKTsKKyAgICAgICAgZm9yIChsZXQgaSA9IDE7IGkgPCBzaWduYXR1cmUu cGFyYW1zLmxlbmd0aDsgKytpKSB7CisgICAgICAgICAgICBjb25zdCBiYWRQYXJhbVNpZ25hdHVy ZSA9IHsgcGFyYW1zOiBzaWduYXR1cmUucGFyYW1zLnNsaWNlKDAsIGkpLCByZXQ6IHNpZ25hdHVy ZS5yZXQgfTsKKyAgICAgICAgICAgIGNvbnN0IGltcG9ydGVyID0gbWFrZUltcG9ydGVyKGJhZFBh cmFtU2lnbmF0dXJlKTsKKyAgICAgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gbmV3IFdlYkFz c2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSksIFdlYkFzc2VtYmx5LkxpbmtFcnJv ciwgYGltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIG1pc21hdGNoZXMgdGhlIHByb3ZpZGVk IFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIChldmFsdWF0aW5nICduZXcgV2ViQXNz ZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKScpYCk7CisgICAgICAgIH0KKyAgICB9 Cit9KSgpOworCisoZnVuY3Rpb24gQmFkU2lnbmF0dXJlU3dhcFBhcmFtKCkgeworICAgIGZvciAo bGV0IHNpZ25hdHVyZSBvZiBzaWduYXR1cmVzKSB7CisgICAgICAgIGNvbnN0IGltcG9ydGVlID0g bWFrZUltcG9ydGVlKHNpZ25hdHVyZSk7CisgICAgICAgIGZvciAobGV0IHNpZ25hdHVyZUluZGV4 ID0gMDsgc2lnbmF0dXJlSW5kZXggPCBzaWduYXR1cmUubGVuZ3RoOyArK3NpZ25hdHVyZUluZGV4 KSB7CisgICAgICAgICAgICBmb3IgKGxldCB0eXBlSW5kZXggPSAxOyB0eXBlSW5kZXggPCB0eXBl c05vblZvaWQubGVuZ3RoOyArK3R5cGVJbmRleCkgeworICAgICAgICAgICAgICAgIGxldCBiYWRQ YXJhbXMgPSBzaWduYXR1cmUucGFyYW1zLnNsaWNlKCk7CisgICAgICAgICAgICAgICAgYmFkUGFy YW1zW3NpZ25hdHVyZUluZGV4XSA9IHN3YXBUeXBlTm9uVm9pZChiYWRQYXJhbXNbc2lnbmF0dXJl SW5kZXhdLCB0eXBlSW5kZXgpOworICAgICAgICAgICAgICAgIGNvbnN0IGJhZFBhcmFtU2lnbmF0 dXJlID0geyBwYXJhbXM6IGJhZFBhcmFtcywgcmV0OiBzaWduYXR1cmUucmV0IH07CisgICAgICAg ICAgICAgICAgY29uc3QgaW1wb3J0ZXIgPSBtYWtlSW1wb3J0ZXIoYmFkUGFyYW1TaWduYXR1cmUp OworICAgICAgICAgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gbmV3IFdlYkFzc2VtYmx5Lklu c3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSksIFdlYkFzc2VtYmx5LkxpbmtFcnJvciwgYGltcG9y dGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIG1pc21hdGNoZXMgdGhlIHByb3ZpZGVkIFdlYkFzc2Vt Ymx5IGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIChldmFsdWF0aW5nICduZXcgV2ViQXNzZW1ibHkuSW5z dGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKScpYCk7CisgICAgICAgICAgICB9CisgICAgICAgIH0K KyAgICB9Cit9KSgpOworCisoZnVuY3Rpb24gQmFkU2lnbmF0dXJlUmV0KCkgeworICAgIGZvciAo bGV0IHNpZ25hdHVyZSBvZiBzaWduYXR1cmVzKSB7CisgICAgICAgIGNvbnN0IGltcG9ydGVlID0g bWFrZUltcG9ydGVlKHNpZ25hdHVyZSk7CisgICAgICAgIGZvciAobGV0IHR5cGVJbmRleCA9IDE7 IHR5cGVJbmRleCA8IHR5cGVzLmxlbmd0aDsgKyt0eXBlSW5kZXgpIHsKKyAgICAgICAgICAgIGNv bnN0IGJhZFBhcmFtU2lnbmF0dXJlID0geyBwYXJhbXM6IHNpZ25hdHVyZS5wYXJhbXMsIHJldDog c3dhcFR5cGUoc2lnbmF0dXJlLnJldCwgdHlwZUluZGV4KSB9OworICAgICAgICAgICAgY29uc3Qg aW1wb3J0ZXIgPSBtYWtlSW1wb3J0ZXIoYmFkUGFyYW1TaWduYXR1cmUpOworICAgICAgICAgICAg YXNzZXJ0LnRocm93cygoKSA9PiBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGlt cG9ydGVlKSwgV2ViQXNzZW1ibHkuTGlua0Vycm9yLCBgaW1wb3J0ZWQgZnVuY3Rpb24ncyBzaWdu YXR1cmUgbWlzbWF0Y2hlcyB0aGUgcHJvdmlkZWQgV2ViQXNzZW1ibHkgZnVuY3Rpb24ncyBzaWdu YXR1cmUgKGV2YWx1YXRpbmcgJ25ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1w b3J0ZWUpJylgKTsKKyAgICAgICAgfQorICAgIH0KK30pKCk7CmRpZmYgLS1naXQgYS9KU1Rlc3Rz L3dhc20vanMtYXBpL3dhc20tdG8td2FzbS5qcyBiL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10 by13YXNtLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjA4MjU1YzYKLS0t IC9kZXYvbnVsbAorKysgYi9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS5qcwpAQCAt MCwwICsxLDczIEBACitpbXBvcnQgKiBhcyBhc3NlcnQgZnJvbSAnLi4vYXNzZXJ0LmpzJzsKK2lt cG9ydCBCdWlsZGVyIGZyb20gJy4uL0J1aWxkZXIuanMnOworLyoKK2NvbnN0IGNhbGxlclRvcEJp dHMgPSAweEMwRkVCRUVGOworY29uc3QgaW5uZXJSZXR1cm5IaSA9IDB4REVBREZBQ0U7Citjb25z dCBpbm5lclJldHVybkxvID0gMHhDMEZFQzBGRTsKKworY29uc3QgY2FsbGVyTW9kdWxlID0gKCkg PT4geworICAgIGNvbnN0IGJ1aWxkZXIgPSAobmV3IEJ1aWxkZXIoKSkKKyAgICAgICAgLlR5cGUo KS5FbmQoKQorICAgICAgICAuSW1wb3J0KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigiZXhwb3J0 cyIsICJjYWxsTWUiLCB7IHBhcmFtczogWyJpNjQiXSwgcmV0OiAiaTY0IiB9KQorICAgICAgICAu RW5kKCkKKyAgICAgICAgLkZ1bmN0aW9uKCkuRW5kKCkKKyAgICAgICAgLkV4cG9ydCgpCisgICAg ICAgICAgICAuRnVuY3Rpb24oImVudHJ5IikKKyAgICAgICAgLkVuZCgpCisgICAgICAgIC5Db2Rl KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigiZW50cnkiLCB7IHBhcmFtczogWyJpMzIiXSwgcmV0 OiAiaTMyIiB9LCBbImk2NCJdKQorICAgICAgICAgICAgICAgIC5JMzJDb25zdChjYWxsZXJUb3BC aXRzKS5JNjRFeHRlbmRVSTMyKCkuSTMyQ29uc3QoMzIpLkk2NEV4dGVuZFVJMzIoKS5JNjRTaGwo KSAvLyAoKGk2NCljYWxsZXJUb3BCaXRzKSA8PCAzMgorICAgICAgICAgICAgICAgIC5HZXRMb2Nh bCgwKS5JNjRFeHRlbmRVSTMyKCkKKyAgICAgICAgICAgICAgICAuSTY0T3IoKSAvLyB2YWx1ZTog cGFyYW0gfCAoKChpNjQpY2FsbGVyVG9wQml0cyA8PCAzMikpCisgICAgICAgICAgICAgICAgLkNh bGwoMCkgLy8gQ2FsbHMgZXhwb3J0cy5jYWxsTWUocGFyYW0gfCAoKChpNjQpY2FsbGVyVG9wQml0 cykgPDwgMzIpKS4KKyAgICAgICAgICAgICAgICAuVGVlTG9jYWwoMSkuSTMyV3JhcEk2NCgpIC8v IGxvOiAoaTMyKWNhbGxSZXN1bHQKKyAgICAgICAgICAgICAgICAuR2V0TG9jYWwoMSkuSTMyQ29u c3QoMzIpLkk2NEV4dGVuZFVJMzIoKS5JNjRTaHJVKCkuSTMyV3JhcEk2NCgpIC8vIGhpOiAoaTMy KShjYWxsUmVzdWx0ID4+IDMyKQorICAgICAgICAgICAgICAgIC5JMzJYb3IoKQorICAgICAgICAg ICAgICAgIC5SZXR1cm4oKQorICAgICAgICAgICAgLkVuZCgpCisgICAgICAgIC5FbmQoKTsKKyAg ICByZXR1cm4gbmV3IFdlYkFzc2VtYmx5Lk1vZHVsZShidWlsZGVyLldlYkFzc2VtYmx5KCkuZ2V0 KCkpOworfTsKKworY29uc3QgY2FsbGVlTW9kdWxlID0gKCkgPT4geworICAgIGNvbnN0IGJ1aWxk ZXIgPSAobmV3IEJ1aWxkZXIoKSkKKyAgICAgICAgLlR5cGUoKS5FbmQoKQorICAgICAgICAuSW1w b3J0KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigiaW1wIiwgImZ1bmMiLCB7IHBhcmFtczogWyJp MzIiLCAiaTMyIl0sIHJldDogImkzMiIgfSkKKyAgICAgICAgLkVuZCgpCisgICAgICAgIC5GdW5j dGlvbigpLkVuZCgpCisgICAgICAgIC5FeHBvcnQoKQorICAgICAgICAgICAgLkZ1bmN0aW9uKCJj YWxsTWUiKQorICAgICAgICAuRW5kKCkKKyAgICAgICAgLkNvZGUoKQorICAgICAgICAgICAgLkZ1 bmN0aW9uKCJjYWxsTWUiLCB7IHBhcmFtczogWyJpNjQiXSwgcmV0OiAiaTY0IiB9KQorICAgICAg ICAgICAgICAgIC5HZXRMb2NhbCgwKS5JMzJXcmFwSTY0KCkgLy8gbG86IChpMzIpcGFyYW0KKyAg ICAgICAgICAgICAgICAuR2V0TG9jYWwoMCkuSTMyQ29uc3QoMzIpLkk2NEV4dGVuZFVJMzIoKS5J NjRTaHJVKCkuSTMyV3JhcEk2NCgpIC8vIGhpOiAoaTMyKShwYXJhbSA+PiAzMikKKyAgICAgICAg ICAgICAgICAuQ2FsbCgwKSAvLyBDYWxscyBpbXAuZnVuYyB3aXRoIHRoZSA2NC1iaXQgdmFsdWUg YXMgaTMyIHsgaGksIGxvIH0uCisgICAgICAgICAgICAgICAgLkRyb3AoKQorICAgICAgICAgICAg ICAgIC5JMzJDb25zdChpbm5lclJldHVybkhpKS5JNjRFeHRlbmRVSTMyKCkuSTMyQ29uc3QoMzIp Lkk2NEV4dGVuZFVJMzIoKS5JNjRTaGwoKS5JMzJDb25zdChpbm5lclJldHVybkxvKS5JNjRFeHRl bmRVSTMyKCkuSTY0T3IoKSAvLyAoKGk2NCloaSA8PCAzMikgfCAoaTY0KWxvCisgICAgICAgICAg ICAgICAgLlJldHVybigpCisgICAgICAgICAgICAuRW5kKCkKKyAgICAgICAgLkVuZCgpOworICAg IHJldHVybiBuZXcgV2ViQXNzZW1ibHkuTW9kdWxlKGJ1aWxkZXIuV2ViQXNzZW1ibHkoKS5nZXQo KSk7Cit9OworCisoZnVuY3Rpb24gV2FzbVRvV2FzbSgpIHsKKyAgICBsZXQgdmFsdWU7CisgICAg Y29uc3QgZnVuYyA9IChoaSwgbG8pID0+IHsgdmFsdWUgPSB7IGhpOiBoaSwgbG86IGxvIH07IHBy aW50KGAke0Vycm9yLnN0YWNrfWApOyByZXR1cm4gaGkgXiBsbzsgfTsKKyAgICBjb25zdCBjYWxs ZWUgPSBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoY2FsbGVlTW9kdWxlKCksIHsgaW1wOiB7IGZ1 bmM6IGZ1bmMgfSB9KTsKKyAgICBjb25zdCBjYWxsZXIgPSBuZXcgV2ViQXNzZW1ibHkuSW5zdGFu Y2UoY2FsbGVyTW9kdWxlKCksIGNhbGxlZSk7CisgICAgZm9yIChsZXQgaSA9IDA7IGkgPCA0MDk2 OyArK2kpIHsKKyAgICAgICAgYXNzZXJ0LmVxKGNhbGxlci5leHBvcnRzLmVudHJ5KGkpLCBpbm5l clJldHVybkhpIF4gaW5uZXJSZXR1cm5Mbyk7CisgICAgICAgIGFzc2VydC5lcSh2YWx1ZS5oaSwg Y2FsbGVyVG9wQml0cyk7CisgICAgICAgIGFzc2VydC5lcSh2YWx1ZS5sbywgaSk7CisgICAgfQor fSkoKTsKKworCisvLyBGSVhNRTogdGVzdCB3YXNtLT53YXNtIHVzaW5nIDMyLWJpdCB0aGluZ3Mg KGluY2x1ZGluZyBmbG9hdCksIGFzIHdlbGwgYXMgNjQtYml0IE5hTnMgdGhhdCBkb24ndCBnZXQg Y2Fub25pY2FsaXplZAorLy8gRklYTUU6IGRvIGEgdGhyb3cgdHdvLWRlZXAKKy8vIEZJWE1FOiBj aGVjayB0aGF0IHRoZSBmaXJzdCB3YXNtJ3MgaW5zdGFuY2UgaXMgYmFjayBpbiBPSyBzdGF0ZSAo d2l0aCB0YWJsZSBvciBnbG9iYWw/KQorLy8gRklYTUU6IHRlc3QgY2FsbGluZyB0aHJvdWdoIGEg VGFibGUKKyovCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvanNjLmNwcCBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9qc2MuY3BwCmluZGV4IDI5MjM4YTAuLmM1NjUyYTQgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9qc2MuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9qc2MuY3BwCkBAIC01NCw2ICs1NCw4IEBACiAjaW5jbHVkZSAiSlNTdHJpbmcuaCIK ICNpbmNsdWRlICJKU1R5cGVkQXJyYXlzLmgiCiAjaW5jbHVkZSAiSlNXZWJBc3NlbWJseUNhbGxl ZS5oIgorI2luY2x1ZGUgIkpTV2ViQXNzZW1ibHlJbnN0YW5jZS5oIgorI2luY2x1ZGUgIkpTV2Vi QXNzZW1ibHlNb2R1bGUuaCIKICNpbmNsdWRlICJMTEludERhdGEuaCIKICNpbmNsdWRlICJMTElu dFRodW5rcy5oIgogI2luY2x1ZGUgIk9iamVjdENvbnN0cnVjdG9yLmgiCkBAIC03MCw2ICs3Miw3 IEBACiAjaW5jbHVkZSAiVHlwZVByb2ZpbGVyTG9nLmgiCiAjaW5jbHVkZSAiV2FzbVBsYW4uaCIK ICNpbmNsdWRlICJXYXNtTWVtb3J5LmgiCisjaW5jbHVkZSAiV2ViQXNzZW1ibHlNb2R1bGVSZWNv cmQuaCIKICNpbmNsdWRlIDxsb2NhbGUuaD4KICNpbmNsdWRlIDxtYXRoLmg+CiAjaW5jbHVkZSA8 c3RkaW8uaD4KQEAgLTI2MDAsNiArMjYwMyw3IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0Nf SE9TVF9DQUxMIGZ1bmN0aW9uVGVzdFdhc21Nb2R1bGVGdW5jdGlvbnMoRXhlY1N0YXRlKiBlCiB7 CiAgICAgVk0mIHZtID0gZXhlYy0+dm0oKTsKICAgICBhdXRvIHNjb3BlID0gREVDTEFSRV9USFJP V19TQ09QRSh2bSk7CisgICAgYXV0byogZ2xvYmFsT2JqZWN0ID0gZXhlYy0+bGV4aWNhbEdsb2Jh bE9iamVjdCgpOwogCiAgICAgaWYgKCFPcHRpb25zOjp1c2VXZWJBc3NlbWJseSgpKQogICAgICAg ICByZXR1cm4gdGhyb3dWTVR5cGVFcnJvcihleGVjLCBzY29wZSwgQVNDSUlMaXRlcmFsKCJ0ZXN0 V2FzbU1vZHVsZSBzaG91bGQgb25seSBiZSBjYWxsZWQgaWYgdGhlIHVzZVdlYkFzc2VtYmx5IG9w dGlvbiBpcyBzZXQiKSk7CkBAIC0yNjMzLDE5ICsyNjM3LDI0IEBAIHN0YXRpYyBFbmNvZGVkSlNW YWx1ZSBKU0NfSE9TVF9DQUxMIGZ1bmN0aW9uVGVzdFdhc21Nb2R1bGVGdW5jdGlvbnMoRXhlY1N0 YXRlKiBlCiAgICAgICAgICAgICB9KTsKICAgICB9CiAKLSAgICB2b2lkKiBtZW1vcnlCeXRlcyA9 IG51bGxwdHI7Ci0gICAgdWludDMyX3QgbWVtb3J5U2l6ZSA9IDA7Ci0gICAgc3RkOjp1bmlxdWVf cHRyPFdhc206Ok1lbW9yeT4gbWVtb3J5OwotICAgIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1 bGVJbmZvcm1hdGlvbj4gbW9kdWxlSW5mb3JtYXRpb24gPSBwbGFuLnRha2VNb2R1bGVJbmZvcm1h dGlvbigpOworICAgIFN5bWJvbFRhYmxlKiBleHBvcnRTeW1ib2xUYWJsZSA9IFN5bWJvbFRhYmxl OjpjcmVhdGUodm0pOworICAgIGF1dG8qIG1vZHVsZVN0cnVjdHVyZSA9IEludGVybmFsRnVuY3Rp b246OmNyZWF0ZVN1YmNsYXNzU3RydWN0dXJlKGV4ZWMsIEpTVmFsdWUoKSwgZXhlYy0+bGV4aWNh bEdsb2JhbE9iamVjdCgpLT5XZWJBc3NlbWJseU1vZHVsZVN0cnVjdHVyZSgpKTsKKyAgICBSRVRV Uk5fSUZfRVhDRVBUSU9OKHNjb3BlLCBlbmNvZGVkSlNWYWx1ZSgpKTsKKyAgICBKU1dlYkFzc2Vt Ymx5TW9kdWxlKiBtb2R1bGUgPSBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGUodm0sIG1vZHVs ZVN0cnVjdHVyZSwgcGxhbi50YWtlTW9kdWxlSW5mb3JtYXRpb24oKSwgcGxhbi50YWtlQ2FsbExp bmtJbmZvcygpLCBwbGFuLnRha2VXYXNtRXhpdFN0dWJzKCksIGV4cG9ydFN5bWJvbFRhYmxlLCAw KTsKKyAgICBTdHJ1Y3R1cmUqIGluc3RhbmNlU3RydWN0dXJlID0gSW50ZXJuYWxGdW5jdGlvbjo6 Y3JlYXRlU3ViY2xhc3NTdHJ1Y3R1cmUoZXhlYywgSlNWYWx1ZSgpLCBnbG9iYWxPYmplY3QtPldl YkFzc2VtYmx5SW5zdGFuY2VTdHJ1Y3R1cmUoKSk7CisgICAgUkVUVVJOX0lGX0VYQ0VQVElPTihz Y29wZSwgZW5jb2RlZEpTVmFsdWUoKSk7CisgICAgSWRlbnRpZmllciBtb2R1bGVLZXkgPSBJZGVu dGlmaWVyOjpmcm9tVWlkKFByaXZhdGVOYW1lKFByaXZhdGVOYW1lOjpEZXNjcmlwdGlvbiwgIldl YkFzc2VtYmx5SW5zdGFuY2UiKSk7CisgICAgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQqIG1vZHVs ZVJlY29yZCA9IFdlYkFzc2VtYmx5TW9kdWxlUmVjb3JkOjpjcmVhdGUoZXhlYywgdm0sIGdsb2Jh bE9iamVjdC0+d2ViQXNzZW1ibHlNb2R1bGVSZWNvcmRTdHJ1Y3R1cmUoKSwgbW9kdWxlS2V5LCBt b2R1bGUtPm1vZHVsZUluZm9ybWF0aW9uKCkpOworICAgIFJFVFVSTl9JRl9FWENFUFRJT04oc2Nv cGUsIGVuY29kZWRKU1ZhbHVlKCkpOworICAgIEpTV2ViQXNzZW1ibHlJbnN0YW5jZSogaW5zdGFu Y2UgPSBKU1dlYkFzc2VtYmx5SW5zdGFuY2U6OmNyZWF0ZSh2bSwgaW5zdGFuY2VTdHJ1Y3R1cmUs IG1vZHVsZSwgbW9kdWxlUmVjb3JkLT5nZXRNb2R1bGVOYW1lc3BhY2UoZXhlYykpOworICAgIFJF VFVSTl9JRl9FWENFUFRJT04oc2NvcGUsIGVuY29kZWRKU1ZhbHVlKCkpOworICAgIHZtLnRvcEpT V2ViQXNzZW1ibHlJbnN0YW5jZSA9IGluc3RhbmNlOwogCi0gICAgaWYgKCEhbW9kdWxlSW5mb3Jt YXRpb24tPm1lbW9yeSkgewotICAgICAgICBtZW1vcnkgPSBzdGQ6Om1ha2VfdW5pcXVlPFdhc206 Ok1lbW9yeT4obW9kdWxlSW5mb3JtYXRpb24tPm1lbW9yeS5pbml0aWFsKCksIG1vZHVsZUluZm9y bWF0aW9uLT5tZW1vcnkubWF4aW11bSgpKTsKLSAgICAgICAgUkVMRUFTRV9BU1NFUlQobWVtb3J5 LT5pc1ZhbGlkKCkpOwotICAgICAgICBtZW1vcnlCeXRlcyA9IG1lbW9yeS0+bWVtb3J5KCk7Ci0g ICAgICAgIG1lbW9yeVNpemUgPSBtZW1vcnktPnNpemUoKTsKKyAgICBpZiAoISFtb2R1bGUtPm1v ZHVsZUluZm9ybWF0aW9uKCkubWVtb3J5KSB7CisgICAgICAgIFdhc206Ok1lbW9yeSBtZW1vcnko bW9kdWxlLT5tb2R1bGVJbmZvcm1hdGlvbigpLm1lbW9yeS5pbml0aWFsKCksIG1vZHVsZS0+bW9k dWxlSW5mb3JtYXRpb24oKS5tZW1vcnkubWF4aW11bSgpKTsKKyAgICAgICAgUkVMRUFTRV9BU1NF UlQobWVtb3J5LmlzVmFsaWQoKSk7CisgICAgICAgIGluc3RhbmNlLT5zZXRNZW1vcnkodm0sIEpT V2ViQXNzZW1ibHlNZW1vcnk6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LT5XZWJBc3NlbWJseU1l bW9yeVN0cnVjdHVyZSgpLCBXVEZNb3ZlKG1lbW9yeSkpKTsKICAgICB9Ci0gICAgdm0udG9wV2Fz bU1lbW9yeVBvaW50ZXIgPSBtZW1vcnlCeXRlczsKLSAgICB2bS50b3BXYXNtTWVtb3J5U2l6ZSA9 IG1lbW9yeVNpemU7CiAKICAgICBmb3IgKHVpbnQzMl90IGkgPSAwOyBpIDwgZnVuY3Rpb25Db3Vu dDsgKytpKSB7CiAgICAgICAgIEpTQXJyYXkqIHRlc3RDYXNlcyA9IGpzQ2FzdDxKU0FycmF5Kj4o ZXhlYy0+YXJndW1lbnQoaSArIDIpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9ydW50aW1lL0pTVHlwZS5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBl LmgKaW5kZXggMDUyMDJmMy4uYWM1MDlkNyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3J1bnRpbWUvSlNUeXBlLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUv SlNUeXBlLmgKQEAgLTkzLDYgKzkzLDggQEAgZW51bSBKU1R5cGUgOiB1aW50OF90IHsKICAgICBK U01hcFR5cGUsCiAgICAgSlNTZXRUeXBlLAogCisgICAgV2ViQXNzZW1ibHlGdW5jdGlvblR5cGUs CisKICAgICBMYXN0SlNDT2JqZWN0VHlwZSA9IEpTU2V0VHlwZSwKICAgICBNYXhKU1R5cGUgPSAw YjExMTExMTExLAogfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L1ZNLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9WTS5oCmluZGV4IGYzNDBlOTYu LjBjYjYyYzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZNLmgK KysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVk0uaApAQCAtMzAxLDggKzMwMSw2 IEBAIHB1YmxpYzoKICAgICAvLyBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTYwNDQxCiAgICAgRXhlY1N0YXRlKiB0b3BDYWxsRnJhbWU7CiAgICAgSlNXZWJBc3NlbWJs eUluc3RhbmNlKiB0b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2U7Ci0gICAgdm9pZCogdG9wV2FzbU1l bW9yeVBvaW50ZXI7Ci0gICAgdWludDMyX3QgdG9wV2FzbU1lbW9yeVNpemU7CiAgICAgU3Ryb25n PFN0cnVjdHVyZT4gc3RydWN0dXJlU3RydWN0dXJlOwogICAgIFN0cm9uZzxTdHJ1Y3R1cmU+IHN0 cnVjdHVyZVJhcmVEYXRhU3RydWN0dXJlOwogICAgIFN0cm9uZzxTdHJ1Y3R1cmU+IHRlcm1pbmF0 ZWRFeGVjdXRpb25FcnJvclN0cnVjdHVyZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcAppbmRleCAyMmM2ZTg1Li4zM2ZiOGJmIDEwMDY0NAot LS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5jcHAKKysr IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuY3BwCkBAIC0x NTUsNyArMTU1LDcgQEAgcHVibGljOgogICAgICAgICAgICAgcmV0dXJuIGZhaWwoX19WQV9BUkdT X18pOyAgICAgICAgICAgICBcCiAgICAgfSB3aGlsZSAoMCkKIAotICAgIEIzSVJHZW5lcmF0b3Io Vk0mLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYsIFByb2NlZHVyZSYsIFdhc21JbnRlcm5hbEZ1 bmN0aW9uKiwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+JiwgY29uc3QgSW1tdXRhYmxl RnVuY3Rpb25JbmRleFNwYWNlJik7CisgICAgQjNJUkdlbmVyYXRvcihWTSYsIGNvbnN0IE1vZHVs ZUluZm9ybWF0aW9uJiwgUHJvY2VkdXJlJiwgV2FzbUludGVybmFsRnVuY3Rpb24qLCBWZWN0b3I8 VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mKTsKIAogICAgIFBhcnRpYWxSZXN1bHQgV0FSTl9VTlVT RURfUkVUVVJOIGFkZEFyZ3VtZW50cyhjb25zdCBTaWduYXR1cmUqKTsKICAgICBQYXJ0aWFsUmVz dWx0IFdBUk5fVU5VU0VEX1JFVFVSTiBhZGRMb2NhbChUeXBlLCB1aW50MzJfdCk7CkBAIC0yMTMs NyArMjEzLDYgQEAgcHJpdmF0ZToKICAgICBWYWx1ZSogemVyb0ZvclR5cGUoVHlwZSk7CiAKICAg ICBWTSYgbV92bTsKLSAgICBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIG1fZnVu Y3Rpb25JbmRleFNwYWNlOwogICAgIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBtX2luZm87CiAg ICAgUHJvY2VkdXJlJiBtX3Byb2M7CiAgICAgQmFzaWNCbG9jayogbV9jdXJyZW50QmxvY2s7CkBA IC0yMjUsOSArMjI0LDggQEAgcHJpdmF0ZToKICAgICBWYWx1ZSogbV9pbnN0YW5jZVZhbHVlOwog fTsKIAotQjNJUkdlbmVyYXRvcjo6QjNJUkdlbmVyYXRvcihWTSYgdm0sIGNvbnN0IE1vZHVsZUlu Zm9ybWF0aW9uJiBpbmZvLCBQcm9jZWR1cmUmIHByb2NlZHVyZSwgV2FzbUludGVybmFsRnVuY3Rp b24qIGNvbXBpbGF0aW9uLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mIHVubGlua2Vk V2FzbVRvV2FzbUNhbGxzLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIGZ1bmN0 aW9uSW5kZXhTcGFjZSkKK0IzSVJHZW5lcmF0b3I6OkIzSVJHZW5lcmF0b3IoVk0mIHZtLCBjb25z dCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgUHJvY2VkdXJlJiBwcm9jZWR1cmUsIFdhc21JbnRl cm5hbEZ1bmN0aW9uKiBjb21waWxhdGlvbiwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+ JiB1bmxpbmtlZFdhc21Ub1dhc21DYWxscykKICAgICA6IG1fdm0odm0pCi0gICAgLCBtX2Z1bmN0 aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4U3BhY2UpCiAgICAgLCBtX2luZm8oaW5mbykKICAg ICAsIG1fcHJvYyhwcm9jZWR1cmUpCiAgICAgLCBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzKHVu bGlua2VkV2FzbVRvV2FzbUNhbGxzKQpAQCAtMjY5LDYgKzI2Nyw0MSBAQCBCM0lSR2VuZXJhdG9y OjpCM0lSR2VuZXJhdG9yKFZNJiB2bSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFBy b2NlZHVyZSYgcAogICAgICAgICBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFs dWU+KG1fcHJvYywgT3JpZ2luKCksICZtX3ZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZSkpOwog fQogCitzdGF0aWMgdm9pZCByZXN0b3JlV2ViQXNzZW1ibHlHbG9iYWxTdGF0ZShWTSYgdm0sIGNv bnN0IE1lbW9yeUluZm9ybWF0aW9uJiBtZW1vcnksIFZhbHVlKiBpbnN0YW5jZSwgUHJvY2VkdXJl JiBwcm9jLCBCYXNpY0Jsb2NrKiBibG9jaykKK3sKKyAgICBibG9jay0+YXBwZW5kTmV3PE1lbW9y eVZhbHVlPihwcm9jLCBTdG9yZSwgT3JpZ2luKCksIGluc3RhbmNlLCBibG9jay0+YXBwZW5kTmV3 PENvbnN0UHRyVmFsdWU+KHByb2MsIE9yaWdpbigpLCAmdm0udG9wSlNXZWJBc3NlbWJseUluc3Rh bmNlKSk7CisKKyAgICBpZiAoISFtZW1vcnkpIHsKKyAgICAgICAgVmFsdWUqIG1lbW9yeU9iamVj dCA9IGJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KHByb2MsIExvYWQsIHBvaW50ZXJUeXBl KCksIE9yaWdpbigpLCBibG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KHByb2MsIE9yaWdp bigpLCBpbnN0YW5jZSksIEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZNZW1vcnkoKSk7 CisKKyAgICAgICAgc3RhdGljX2Fzc2VydChzaXplb2YoZGVjbHR5cGUodm0udG9wSlNXZWJBc3Nl bWJseUluc3RhbmNlLT5tZW1vcnkoKS0+bWVtb3J5KCktPm1lbW9yeSgpKSkgPT0gc2l6ZW9mKHZv aWQqKSwgImNvZGVnZW4gcmVsaWVzIG9uIHRoaXMgc2l6ZSIpOworICAgICAgICBzdGF0aWNfYXNz ZXJ0KHNpemVvZihkZWNsdHlwZSh2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UtPm1lbW9yeSgp LT5tZW1vcnkoKS0+c2l6ZSgpKSkgPT0gc2l6ZW9mKHVpbnQzMl90KSwgImNvZGVnZW4gcmVsaWVz IG9uIHRoaXMgc2l6ZSIpOworICAgICAgICBWYWx1ZSogYmFzZU1lbW9yeSA9IGJsb2NrLT5hcHBl bmROZXc8TWVtb3J5VmFsdWU+KHByb2MsIExvYWQsIHBvaW50ZXJUeXBlKCksIE9yaWdpbigpLCBi bG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KHByb2MsIE9yaWdpbigpLCBtZW1vcnlPYmpl Y3QpLCBKU1dlYkFzc2VtYmx5TWVtb3J5OjpvZmZzZXRPZk1lbW9yeSgpKTsKKyAgICAgICAgVmFs dWUqIG1lbW9yeVNpemUgPSBibG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihwcm9jLCBMb2Fk LCBJbnQzMiwgT3JpZ2luKCksIGJsb2NrLT5hcHBlbmROZXc8Q29uc3RQdHJWYWx1ZT4ocHJvYywg T3JpZ2luKCksIG1lbW9yeU9iamVjdCksIEpTV2ViQXNzZW1ibHlNZW1vcnk6Om9mZnNldE9mU2l6 ZSgpKTsKKworICAgICAgICBWZWN0b3I8VmFsdWUqPiBhcmd1bWVudHM7CisgICAgICAgIGFyZ3Vt ZW50cy5yZXNlcnZlQ2FwYWNpdHkoMSArIG1lbW9yeS5waW5uZWRSZWdpc3RlcnMoKS5zaXplUmVn aXN0ZXJzLnNpemUoKSk7CisgICAgICAgIGFyZ3VtZW50cy5hcHBlbmQoYmFzZU1lbW9yeSk7Cisg ICAgICAgIGZvciAoYXV0byBpbmZvIDogbWVtb3J5LnBpbm5lZFJlZ2lzdGVycygpLnNpemVSZWdp c3RlcnMpIHsKKyAgICAgICAgICAgIFZhbHVlKiBzaXplVmFsdWUgPSBibG9jay0+YXBwZW5kTmV3 PFZhbHVlPihwcm9jLCBTdWIsIE9yaWdpbigpLCBtZW1vcnlTaXplLCBibG9jay0+YXBwZW5kTmV3 PENvbnN0MzJWYWx1ZT4ocHJvYywgT3JpZ2luKCksIGluZm8uc2l6ZU9mZnNldCkpOworICAgICAg ICAgICAgYXJndW1lbnRzLmFwcGVuZChzaXplVmFsdWUpOworICAgICAgICB9CisKKyAgICAgICAg QjM6OlBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCA9IGJsb2NrLT5hcHBlbmROZXc8QjM6OlBh dGNocG9pbnRWYWx1ZT4ocHJvYywgQjM6OlZvaWQsIE9yaWdpbigpKTsKKyAgICAgICAgcGF0Y2hw b2ludC0+ZWZmZWN0cyA9IEVmZmVjdHM6Om5vbmUoKTsKKyAgICAgICAgcGF0Y2hwb2ludC0+ZWZm ZWN0cy53cml0ZXNQaW5uZWQgPSB0cnVlOworICAgICAgICBwYXRjaHBvaW50LT5hcHBlbmRWZWN0 b3JXaXRoUmVwKGFyZ3VtZW50cywgVmFsdWVSZXA6OlNvbWVSZWdpc3Rlcik7CisKKyAgICAgICAg cGF0Y2hwb2ludC0+c2V0R2VuZXJhdG9yKFttZW1vcnldIChDQ2FsbEhlbHBlcnMmIGppdCwgY29u c3QgQjM6OlN0YWNrbWFwR2VuZXJhdGlvblBhcmFtcyYgcGFyYW1zKSB7CisgICAgICAgICAgICBB bGxvd01hY3JvU2NyYXRjaFJlZ2lzdGVyVXNhZ2UgYWxsb3dTY3JhdGNoKGppdCk7CisKKyAgICAg ICAgICAgIGppdC5tb3ZlKHBhcmFtc1swXS5ncHIoKSwgbWVtb3J5LnBpbm5lZFJlZ2lzdGVycygp LmJhc2VNZW1vcnlQb2ludGVyKTsKKyAgICAgICAgICAgIGZvciAodWludDMyX3QgaSA9IDA7IGkg PCBtZW1vcnkucGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVycy5zaXplKCk7ICsraSkKKyAg ICAgICAgICAgICAgICBqaXQubW92ZShwYXJhbXNbMSArIGldLmdwcigpLCBtZW1vcnkucGlubmVk UmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVyc1tpXS5zaXplUmVnaXN0ZXIpOworICAgICAgICB9KTsK KyAgICB9Cit9CisKIHZvaWQgQjNJUkdlbmVyYXRvcjo6ZW1pdEV4Y2VwdGlvbkNoZWNrKENDYWxs SGVscGVycyYgaml0LCBFeGNlcHRpb25UeXBlIHR5cGUpCiB7CiAgICAgaml0Lm1vdmUoQ0NhbGxI ZWxwZXJzOjpUcnVzdGVkSW1tMzIoc3RhdGljX2Nhc3Q8dWludDMyX3Q+KHR5cGUpKSwgR1BSSW5m bzo6YXJndW1lbnRHUFIxKTsKQEAgLTY5MiwyMyArNzI1LDc5IEBAIGF1dG8gQjNJUkdlbmVyYXRv cjo6YWRkQ2FsbCh1aW50MzJfdCBmdW5jdGlvbkluZGV4LCBjb25zdCBTaWduYXR1cmUqIHNpZ25h dHVyZSwKICAgICBBU1NFUlQoc2lnbmF0dXJlLT5hcmd1bWVudENvdW50KCkgPT0gYXJncy5zaXpl KCkpOwogCiAgICAgVHlwZSByZXR1cm5UeXBlID0gc2lnbmF0dXJlLT5yZXR1cm5UeXBlKCk7Cisg ICAgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+KiB1bmxpbmtlZFdhc21Ub1dhc21DYWxs cyA9ICZtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzOwogCi0gICAgcmVzdWx0ID0gd2FzbUNhbGxp bmdDb252ZW50aW9uKCkuc2V0dXBDYWxsKG1fcHJvYywgbV9jdXJyZW50QmxvY2ssIE9yaWdpbigp LCBhcmdzLCB0b0IzVHlwZShyZXR1cm5UeXBlKSwKLSAgICAgICAgWyZdIChQYXRjaHBvaW50VmFs dWUqIHBhdGNocG9pbnQpIHsKLSAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVz UGlubmVkID0gdHJ1ZTsKLSAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMucmVhZHNQaW5u ZWQgPSB0cnVlOworICAgIGlmIChtX2luZm8uaXNJbXBvcnRlZEZ1bmN0aW9uRnJvbUZ1bmN0aW9u SW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KSkgeworICAgICAgICAvLyBGSVhNRSBpbXBvcnRzIGNh biBiZSBsaW5rZWQgaGVyZSwgaW5zdGVhZCBvZiBnZW5lcmF0aW5nIGEgcGF0Y2hwb2ludCwgYmVj YXVzZSBhbGwgaW1wb3J0IHN0dWJzIGFyZSBnZW5lcmF0ZWQgYmVmb3JlIEIzIGNvbXBpbGF0aW9u IHN0YXJ0cy4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NjQ2Mgor ICAgICAgICBFeHByZXNzaW9uVHlwZSBmdW5jdGlvbkltcG9ydCA9IG1fY3VycmVudEJsb2NrLT5h cHBlbmROZXc8TWVtb3J5VmFsdWU+KG1fcHJvYywgTG9hZCwgcG9pbnRlclR5cGUoKSwgT3JpZ2lu KCksIG1faW5zdGFuY2VWYWx1ZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlOjpvZmZzZXRPZkltcG9y dEZ1bmN0aW9uKGZ1bmN0aW9uSW5kZXgpKTsKKyAgICAgICAgRXhwcmVzc2lvblR5cGUganNUeXBl T2ZJbXBvcnQgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihtX3Byb2Ms IExvYWQ4WiwgT3JpZ2luKCksIGZ1bmN0aW9uSW1wb3J0LCBKU0NlbGw6OnR5cGVJbmZvVHlwZU9m ZnNldCgpKTsKKyAgICAgICAgVmFsdWUqIGlzV2FzbUNhbGwgPSBtX2N1cnJlbnRCbG9jay0+YXBw ZW5kTmV3PFZhbHVlPihtX3Byb2MsIEVxdWFsLCBPcmlnaW4oKSwganNUeXBlT2ZJbXBvcnQsIG1f Y3VycmVudEJsb2NrLT5hcHBlbmROZXc8Q29uc3QzMlZhbHVlPihtX3Byb2MsIE9yaWdpbigpLCBX ZWJBc3NlbWJseUZ1bmN0aW9uVHlwZSkpOwogCi0gICAgICAgICAgICBWZWN0b3I8VW5saW5rZWRX YXNtVG9XYXNtQ2FsbD4qIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzID0gJm1fdW5saW5rZWRXYXNt VG9XYXNtQ2FsbHM7Ci0gICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlu a2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNv bnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7Ci0gICAgICAgICAgICAgICAgQWxs b3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93U2NyYXRjaChqaXQpOworICAgICAgICBC YXNpY0Jsb2NrKiBpc1dhc21CbG9jayA9IG1fcHJvYy5hZGRCbG9jaygpOworICAgICAgICBCYXNp Y0Jsb2NrKiBpc0pTQmxvY2sgPSBtX3Byb2MuYWRkQmxvY2soKTsKKyAgICAgICAgQmFzaWNCbG9j ayogY29udGludWF0aW9uID0gbV9wcm9jLmFkZEJsb2NrKCk7CisgICAgICAgIG1fY3VycmVudEJs b2NrLT5hcHBlbmROZXdDb250cm9sVmFsdWUobV9wcm9jLCBCMzo6QnJhbmNoLCBPcmlnaW4oKSwg aXNXYXNtQ2FsbCwgRnJlcXVlbnRlZEJsb2NrKGlzV2FzbUJsb2NrKSwgRnJlcXVlbnRlZEJsb2Nr KGlzSlNCbG9jaykpOworCisgICAgICAgIFZhbHVlKiB3YXNtQ2FsbFJlc3VsdCA9IHdhc21DYWxs aW5nQ29udmVudGlvbigpLnNldHVwQ2FsbChtX3Byb2MsIGlzV2FzbUJsb2NrLCBPcmlnaW4oKSwg YXJncywgdG9CM1R5cGUocmV0dXJuVHlwZSksCisgICAgICAgICAgICBbJl0gKFBhdGNocG9pbnRW YWx1ZSogcGF0Y2hwb2ludCkgeworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMu d3JpdGVzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3Rz LnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5l cmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxw ZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7CisgICAgICAg ICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2go aml0KTsKKyAgICAgICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQu Y2FsbCgpOworICAgICAgICAgICAgICAgICAgICBqaXQuYWRkTGlua1Rhc2soW3VubGlua2VkV2Fz bVRvV2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZl cikgeworICAgICAgICAgICAgICAgICAgICAgICAgYm9vbCB0b0pTID0gZmFsc2U7IC8vIE1heWJl IGV4dGVybmFsIHdhc20gLT4gd2FzbS4KKyAgICAgICAgICAgICAgICAgICAgICAgIHVubGlua2Vk V2FzbVRvV2FzbUNhbGxzLT5hcHBlbmQoeyBsaW5rQnVmZmVyLmxvY2F0aW9uT2YoY2FsbCksIGZ1 bmN0aW9uSW5kZXgsIHRvSlMgfSk7CisgICAgICAgICAgICAgICAgICAgIH0pOworICAgICAgICAg ICAgICAgIH0pOworICAgICAgICAgICAgfSk7CisgICAgICAgIFVwc2lsb25WYWx1ZSogd2FzbUNh bGxSZXN1bHRVcHNpbG9uID0gcmV0dXJuVHlwZSA9PSBWb2lkID8gbnVsbHB0ciA6IGlzV2FzbUJs b2NrLT5hcHBlbmROZXc8VXBzaWxvblZhbHVlPihtX3Byb2MsIE9yaWdpbigpLCB3YXNtQ2FsbFJl c3VsdCk7CisgICAgICAgIGlzV2FzbUJsb2NrLT5hcHBlbmROZXdDb250cm9sVmFsdWUobV9wcm9j LCBKdW1wLCBPcmlnaW4oKSwgY29udGludWF0aW9uKTsKKworICAgICAgICBWYWx1ZSoganNDYWxs UmVzdWx0ID0gd2FzbUNhbGxpbmdDb252ZW50aW9uKCkuc2V0dXBDYWxsKG1fcHJvYywgaXNKU0Js b2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0dXJuVHlwZSksCisgICAgICAgICAgICBb Jl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkgeworICAgICAgICAgICAgICAgIHBhdGNo cG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRj aHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRj aHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbklu ZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJh bXMmKSB7CisgICAgICAgICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2Fn ZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpD YWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICAgICAgICAgICAgICBqaXQuYWRkTGlua1Rh c2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4XSAoTGlua0J1 ZmZlciYgbGlua0J1ZmZlcikgeworICAgICAgICAgICAgICAgICAgICAgICAgYm9vbCB0b0pTID0g dHJ1ZTsgLy8gRXh0ZXJuYWwgd2FzbSAtPiBKUy4KKyAgICAgICAgICAgICAgICAgICAgICAgIHVu bGlua2VkV2FzbVRvV2FzbUNhbGxzLT5hcHBlbmQoeyBsaW5rQnVmZmVyLmxvY2F0aW9uT2YoY2Fs bCksIGZ1bmN0aW9uSW5kZXgsIHRvSlMgfSk7CisgICAgICAgICAgICAgICAgICAgIH0pOworICAg ICAgICAgICAgICAgIH0pOworICAgICAgICAgICAgfSk7CisgICAgICAgIFVwc2lsb25WYWx1ZSog anNDYWxsUmVzdWx0VXBzaWxvbiA9IHJldHVyblR5cGUgPT0gVm9pZCA/IG51bGxwdHIgOiBpc0pT QmxvY2stPmFwcGVuZE5ldzxVcHNpbG9uVmFsdWU+KG1fcHJvYywgT3JpZ2luKCksIGpzQ2FsbFJl c3VsdCk7CisgICAgICAgIGlzSlNCbG9jay0+YXBwZW5kTmV3Q29udHJvbFZhbHVlKG1fcHJvYywg SnVtcCwgT3JpZ2luKCksIGNvbnRpbnVhdGlvbik7CiAKLSAgICAgICAgICAgICAgICBDQ2FsbEhl bHBlcnM6OkNhbGwgY2FsbCA9IGppdC5jYWxsKCk7CisgICAgICAgIG1fY3VycmVudEJsb2NrID0g Y29udGludWF0aW9uOworCisgICAgICAgIGlmIChyZXR1cm5UeXBlID09IFZvaWQpCisgICAgICAg ICAgICByZXN1bHQgPSBudWxscHRyOworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIHJlc3Vs dCA9IGNvbnRpbnVhdGlvbi0+YXBwZW5kTmV3PFZhbHVlPihtX3Byb2MsIFBoaSwgdG9CM1R5cGUo cmV0dXJuVHlwZSksIE9yaWdpbigpKTsKKyAgICAgICAgICAgIHdhc21DYWxsUmVzdWx0VXBzaWxv bi0+c2V0UGhpKHJlc3VsdCk7CisgICAgICAgICAgICBqc0NhbGxSZXN1bHRVcHNpbG9uLT5zZXRQ aGkocmVzdWx0KTsKKyAgICAgICAgfQogCi0gICAgICAgICAgICAgICAgaml0LmFkZExpbmtUYXNr KFt1bmxpbmtlZFdhc21Ub1dhc21DYWxscywgY2FsbCwgZnVuY3Rpb25JbmRleF0gKExpbmtCdWZm ZXImIGxpbmtCdWZmZXIpIHsKLSAgICAgICAgICAgICAgICAgICAgdW5saW5rZWRXYXNtVG9XYXNt Q2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZmZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rpb25JbmRl eCB9KTsKKyAgICAgICAgLy8gVGhlIGNhbGwgY291bGQgaGF2ZSBiZWVuIHRvIGFub3RoZXIgV2Vi QXNzZW1ibHkgaW5zdGFuY2UsIGFuZCAvIG9yIGNvdWxkIGhhdmUgbW9kaWZpZWQgb3VyIE1lbW9y eS4KKyAgICAgICAgcmVzdG9yZVdlYkFzc2VtYmx5R2xvYmFsU3RhdGUobV92bSwgbV9pbmZvLm1l bW9yeSwgbV9pbnN0YW5jZVZhbHVlLCBtX3Byb2MsIGNvbnRpbnVhdGlvbik7CisgICAgfSBlbHNl IHsKKyAgICAgICAgcmVzdWx0ID0gd2FzbUNhbGxpbmdDb252ZW50aW9uKCkuc2V0dXBDYWxsKG1f cHJvYywgbV9jdXJyZW50QmxvY2ssIE9yaWdpbigpLCBhcmdzLCB0b0IzVHlwZShyZXR1cm5UeXBl KSwKKyAgICAgICAgICAgIFsmXSAoUGF0Y2hwb2ludFZhbHVlKiBwYXRjaHBvaW50KSB7CisgICAg ICAgICAgICAgICAgcGF0Y2hwb2ludC0+ZWZmZWN0cy53cml0ZXNQaW5uZWQgPSB0cnVlOworICAg ICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMucmVhZHNQaW5uZWQgPSB0cnVlOworICAg ICAgICAgICAgICAgIHBhdGNocG9pbnQtPnNldEdlbmVyYXRvcihbdW5saW5rZWRXYXNtVG9XYXNt Q2FsbHMsIGZ1bmN0aW9uSW5kZXhdIChDQ2FsbEhlbHBlcnMmIGppdCwgY29uc3QgQjM6OlN0YWNr bWFwR2VuZXJhdGlvblBhcmFtcyYpIHsKKyAgICAgICAgICAgICAgICAgICAgQWxsb3dNYWNyb1Nj cmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93U2NyYXRjaChqaXQpOworICAgICAgICAgICAgICAgICAg ICBDQ2FsbEhlbHBlcnM6OkNhbGwgY2FsbCA9IGppdC5jYWxsKCk7CisgICAgICAgICAgICAgICAg ICAgIGppdC5hZGRMaW5rVGFzayhbdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGNhbGwsIGZ1bmN0 aW9uSW5kZXhdIChMaW5rQnVmZmVyJiBsaW5rQnVmZmVyKSB7CisgICAgICAgICAgICAgICAgICAg ICAgICBib29sIHRvSlMgPSBmYWxzZTsgLy8gSW50ZXJuYWwgd2FzbSAtPiB3YXNtLgorICAgICAg ICAgICAgICAgICAgICAgICAgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtC dWZmZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rpb25JbmRleCwgdG9KUyB9KTsKKyAgICAgICAg ICAgICAgICAgICAgfSk7CiAgICAgICAgICAgICAgICAgfSk7CiAgICAgICAgICAgICB9KTsKLSAg ICAgICAgfSk7CisgICAgfQorCiAgICAgcmV0dXJuIHsgfTsKIH0KIApAQCAtNzg1LDYgKzg3NCw5 IEBAIGF1dG8gQjNJUkdlbmVyYXRvcjo6YWRkQ2FsbEluZGlyZWN0KGNvbnN0IFNpZ25hdHVyZSog c2lnbmF0dXJlLCBTaWduYXR1cmVJbmRleCBzCiAgICAgICAgICAgICB9KTsKICAgICAgICAgfSk7 CiAKKyAgICAvLyBUaGUgY2FsbCBjb3VsZCBoYXZlIGJlZW4gdG8gYW5vdGhlciBXZWJBc3NlbWJs eSBpbnN0YW5jZSwgYW5kIC8gb3IgY291bGQgaGF2ZSBtb2RpZmllZCBvdXIgTWVtb3J5LgorICAg IHJlc3RvcmVXZWJBc3NlbWJseUdsb2JhbFN0YXRlKG1fdm0sIG1faW5mby5tZW1vcnksIG1faW5z dGFuY2VWYWx1ZSwgbV9wcm9jLCBtX2N1cnJlbnRCbG9jayk7CisKICAgICByZXR1cm4geyB9Owog fQogCkBAIC04NTQsMjAgKzk0NiwxMCBAQCBzdGF0aWMgdm9pZCBjcmVhdGVKU1RvV2FzbVdyYXBw ZXIoVk0mIHZtLCBDb21waWxhdGlvbkNvbnRleHQmIGNvbXBpbGF0aW9uQ29udGV4dAogICAgICAg ICB9KTsKICAgICB9CiAKLSAgICAvLyBNb3ZlIG1lbW9yeSB2YWx1ZXMgdG8gdGhlIGFwcHJvcmlh dGUgcGxhY2VzLCBpZiBuZWVkZWQuCi0gICAgVmFsdWUqIGJhc2VNZW1vcnkgPSBudWxscHRyOwot ICAgIFZlY3RvcjxWYWx1ZSo+IHNpemVzOwotICAgIGlmICghIW1lbW9yeSkgewotICAgICAgICBi YXNlTWVtb3J5ID0gYmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4ocHJvYywgTG9hZCwgSW50 NjQsIE9yaWdpbigpLAotICAgICAgICAgICAgYmxvY2stPmFwcGVuZE5ldzxDb25zdFB0clZhbHVl Pihwcm9jLCBPcmlnaW4oKSwgJnZtLnRvcFdhc21NZW1vcnlQb2ludGVyKSk7Ci0gICAgICAgIFZh bHVlKiBzaXplID0gYmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4ocHJvYywgTG9hZCwgSW50 MzIsIE9yaWdpbigpLAotICAgICAgICAgICAgYmxvY2stPmFwcGVuZE5ldzxDb25zdFB0clZhbHVl Pihwcm9jLCBPcmlnaW4oKSwgJnZtLnRvcFdhc21NZW1vcnlTaXplKSk7Ci0gICAgICAgIHNpemVz LnJlc2VydmVDYXBhY2l0eShtZW1vcnkucGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVycy5z aXplKCkpOwotICAgICAgICBmb3IgKGF1dG8gaW5mbyA6IG1lbW9yeS5waW5uZWRSZWdpc3RlcnMo KS5zaXplUmVnaXN0ZXJzKSB7Ci0gICAgICAgICAgICBzaXplcy5hcHBlbmQoYmxvY2stPmFwcGVu ZE5ldzxWYWx1ZT4ocHJvYywgU3ViLCBvcmlnaW4sIHNpemUsCi0gICAgICAgICAgICAgICAgYmxv Y2stPmFwcGVuZE5ldzxDb25zdDMyVmFsdWU+KHByb2MsIG9yaWdpbiwgaW5mby5zaXplT2Zmc2V0 KSkpOwotICAgICAgICB9Ci0gICAgfQorICAgIC8vIEZJWE1FIFRoZSBpbnN0YW5jZSBpcyBjdXJy ZW50bHkgc2V0IGJ5IHRoZSBDKysgY29kZSBpbiBXZWJBc3NlbWJseUZ1bmN0aW9uOjpjYWxsLiBX ZSBzaG91bGRuJ3QgZ28gdGhyb3VnaCB0aGUgZXh0cmEgQysrIGhvb3AuIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjY0ODYKKyAgICBWYWx1ZSogaW5zdGFuY2UgPSBi bG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihwcm9jLCBMb2FkLCBwb2ludGVyVHlwZSgpLCBP cmlnaW4oKSwKKyAgICAgICAgYmxvY2stPmFwcGVuZE5ldzxDb25zdFB0clZhbHVlPihwcm9jLCBP cmlnaW4oKSwgJnZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZSkpOworICAgIHJlc3RvcmVXZWJB c3NlbWJseUdsb2JhbFN0YXRlKHZtLCBtZW1vcnksIGluc3RhbmNlLCBwcm9jLCBibG9jayk7CiAK ICAgICAvLyBHZXQgb3VyIGFyZ3VtZW50cy4KICAgICBWZWN0b3I8VmFsdWUqPiBhcmd1bWVudHM7 CkBAIC04NzcsMTMgKzk1OSw2IEBAIHN0YXRpYyB2b2lkIGNyZWF0ZUpTVG9XYXNtV3JhcHBlcihW TSYgdm0sIENvbXBpbGF0aW9uQ29udGV4dCYgY29tcGlsYXRpb25Db250ZXh0CiAKICAgICAvLyBN b3ZlIHRoZSBhcmd1bWVudHMgaW50byBwbGFjZS4KICAgICBWYWx1ZSogcmVzdWx0ID0gd2FzbUNh bGxpbmdDb252ZW50aW9uKCkuc2V0dXBDYWxsKHByb2MsIGJsb2NrLCBvcmlnaW4sIGFyZ3VtZW50 cywgdG9CM1R5cGUoc2lnbmF0dXJlLT5yZXR1cm5UeXBlKCkpLCBbJl0gKFBhdGNocG9pbnRWYWx1 ZSogcGF0Y2hwb2ludCkgewotICAgICAgICBpZiAoISFtZW1vcnkpIHsKLSAgICAgICAgICAgIEFT U0VSVChzaXplcy5zaXplKCkgPT0gbWVtb3J5LnBpbm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3Rl cnMuc2l6ZSgpKTsKLSAgICAgICAgICAgIHBhdGNocG9pbnQtPmFwcGVuZChDb25zdHJhaW5lZFZh bHVlKGJhc2VNZW1vcnksIFZhbHVlUmVwOjpyZWcobWVtb3J5LnBpbm5lZFJlZ2lzdGVycygpLmJh c2VNZW1vcnlQb2ludGVyKSkpOwotICAgICAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8 IHNpemVzLnNpemUoKTsgKytpKQotICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmFwcGVuZChD b25zdHJhaW5lZFZhbHVlKHNpemVzW2ldLCBWYWx1ZVJlcDo6cmVnKG1lbW9yeS5waW5uZWRSZWdp c3RlcnMoKS5zaXplUmVnaXN0ZXJzW2ldLnNpemVSZWdpc3RlcikpKTsKLSAgICAgICAgfQotCiAg ICAgICAgIENvbXBpbGF0aW9uQ29udGV4dCogY29udGV4dCA9ICZjb21waWxhdGlvbkNvbnRleHQ7 CiAgICAgICAgIHBhdGNocG9pbnQtPnNldEdlbmVyYXRvcihbY29udGV4dF0gKENDYWxsSGVscGVy cyYgaml0LCBjb25zdCBCMzo6U3RhY2ttYXBHZW5lcmF0aW9uUGFyYW1zJikgewogICAgICAgICAg ICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93U2NyYXRjaChqaXQpOwpAQCAt OTE3LDcgKzk5Miw3IEBAIHN0YXRpYyB2b2lkIGNyZWF0ZUpTVG9XYXNtV3JhcHBlcihWTSYgdm0s IENvbXBpbGF0aW9uQ29udGV4dCYgY29tcGlsYXRpb25Db250ZXh0CiAgICAgZnVuY3Rpb24uanNU b1dhc21FbnRyeXBvaW50LmNhbGxlZVNhdmVSZWdpc3RlcnMgPSBwcm9jLmNhbGxlZVNhdmVSZWdp c3RlcnMoKTsKIH0KIAotRXhwZWN0ZWQ8c3RkOjp1bmlxdWVfcHRyPFdhc21JbnRlcm5hbEZ1bmN0 aW9uPiwgU3RyaW5nPiBwYXJzZUFuZENvbXBpbGUoVk0mIHZtLCBDb21waWxhdGlvbkNvbnRleHQm IGNvbXBpbGF0aW9uQ29udGV4dCwgY29uc3QgdWludDhfdCogZnVuY3Rpb25TdGFydCwgc2l6ZV90 IGZ1bmN0aW9uTGVuZ3RoLCBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSwgVmVjdG9yPFVubGlu a2VkV2FzbVRvV2FzbUNhbGw+JiB1bmxpbmtlZFdhc21Ub1dhc21DYWxscywgY29uc3QgSW1tdXRh YmxlRnVuY3Rpb25JbmRleFNwYWNlJiBmdW5jdGlvbkluZGV4U3BhY2UsIGNvbnN0IE1vZHVsZUlu Zm9ybWF0aW9uJiBpbmZvLCB1bnNpZ25lZCBvcHRMZXZlbCkKK0V4cGVjdGVkPHN0ZDo6dW5pcXVl X3B0cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0cmluZz4gcGFyc2VBbmRDb21waWxlKFZNJiB2 bSwgQ29tcGlsYXRpb25Db250ZXh0JiBjb21waWxhdGlvbkNvbnRleHQsIGNvbnN0IHVpbnQ4X3Qq IGZ1bmN0aW9uU3RhcnQsIHNpemVfdCBmdW5jdGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiBz aWduYXR1cmUsIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYgdW5saW5rZWRXYXNtVG9X YXNtQ2FsbHMsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBpbmZvLCB1bnNpZ25lZCBvcHRMZXZl bCkKIHsKICAgICBhdXRvIHJlc3VsdCA9IHN0ZDo6bWFrZV91bmlxdWU8V2FzbUludGVybmFsRnVu Y3Rpb24+KCk7CiAKQEAgLTkyNSw4ICsxMDAwLDggQEAgRXhwZWN0ZWQ8c3RkOjp1bmlxdWVfcHRy PFdhc21JbnRlcm5hbEZ1bmN0aW9uPiwgU3RyaW5nPiBwYXJzZUFuZENvbXBpbGUoVk0mIHZtLAog ICAgIGNvbXBpbGF0aW9uQ29udGV4dC53YXNtRW50cnlwb2ludEpJVCA9IHN0ZDo6bWFrZV91bmlx dWU8Q0NhbGxIZWxwZXJzPigmdm0pOwogCiAgICAgUHJvY2VkdXJlIHByb2NlZHVyZTsKLSAgICBC M0lSR2VuZXJhdG9yIGNvbnRleHQodm0sIGluZm8sIHByb2NlZHVyZSwgcmVzdWx0LmdldCgpLCB1 bmxpbmtlZFdhc21Ub1dhc21DYWxscywgZnVuY3Rpb25JbmRleFNwYWNlKTsKLSAgICBGdW5jdGlv blBhcnNlcjxCM0lSR2VuZXJhdG9yPiBwYXJzZXIoJnZtLCBjb250ZXh0LCBmdW5jdGlvblN0YXJ0 LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBmdW5jdGlvbkluZGV4U3BhY2UsIGluZm8pOwor ICAgIEIzSVJHZW5lcmF0b3IgY29udGV4dCh2bSwgaW5mbywgcHJvY2VkdXJlLCByZXN1bHQuZ2V0 KCksIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzKTsKKyAgICBGdW5jdGlvblBhcnNlcjxCM0lSR2Vu ZXJhdG9yPiBwYXJzZXIoJnZtLCBjb250ZXh0LCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0 aCwgc2lnbmF0dXJlLCBpbmZvKTsKICAgICBXQVNNX0ZBSUxfSUZfSEVMUEVSX0ZBSUxTKHBhcnNl ci5wYXJzZSgpKTsKIAogICAgIHByb2NlZHVyZS5yZXNldFJlYWNoYWJpbGl0eSgpOwpkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuaCBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmgKaW5kZXggYjVjOWY0 Ni4uZDg5NzU4NSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIz SVJHZW5lcmF0b3IuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQjNJUkdl bmVyYXRvci5oCkBAIC00Nyw3ICs0Nyw3IEBAIHN0cnVjdCBDb21waWxhdGlvbkNvbnRleHQgewog ICAgIENDYWxsSGVscGVyczo6Q2FsbCBqc0VudHJ5cG9pbnRUb1dhc21FbnRyeXBvaW50Q2FsbDsK IH07CiAKLUV4cGVjdGVkPHN0ZDo6dW5pcXVlX3B0cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0 cmluZz4gcGFyc2VBbmRDb21waWxlKFZNJiwgQ29tcGlsYXRpb25Db250ZXh0JiwgY29uc3QgdWlu dDhfdCosIHNpemVfdCwgY29uc3QgU2lnbmF0dXJlKiwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2Fz bUNhbGw+JiwgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiwgY29uc3QgTW9kdWxl SW5mb3JtYXRpb24mLCB1bnNpZ25lZCBvcHRMZXZlbCA9IDEpOworRXhwZWN0ZWQ8c3RkOjp1bmlx dWVfcHRyPFdhc21JbnRlcm5hbEZ1bmN0aW9uPiwgU3RyaW5nPiBwYXJzZUFuZENvbXBpbGUoVk0m LCBDb21waWxhdGlvbkNvbnRleHQmLCBjb25zdCB1aW50OF90Kiwgc2l6ZV90LCBjb25zdCBTaWdu YXR1cmUqLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mLCBjb25zdCBNb2R1bGVJbmZv cm1hdGlvbiYsIHVuc2lnbmVkIG9wdExldmVsID0gMSk7CiAKIH0gfSAvLyBuYW1lc3BhY2UgSlND OjpXYXNtCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5k aW5nLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmNwcAppbmRl eCAwZTU5MjQ3Li44OTJiZTA1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtQmluZGluZy5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJp bmRpbmcuY3BwCkBAIC0zNiw3ICszNiw3IEBACiAKIG5hbWVzcGFjZSBKU0MgeyBuYW1lc3BhY2Ug V2FzbSB7CiAKLVdhc21Ub0pTU3R1YiBpbXBvcnRTdHViR2VuZXJhdG9yKFZNKiB2bSwgQmFnPENh bGxMaW5rSW5mbz4mIGNhbGxMaW5rSW5mb3MsIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4 LCB1bnNpZ25lZCBpbXBvcnRJbmRleCkKK3N0YXRpYyBNYWNyb0Fzc2VtYmxlckNvZGVSZWYgd2Fz bVRvSlMoVk0qIHZtLCBCYWc8Q2FsbExpbmtJbmZvPiYgY2FsbExpbmtJbmZvcywgU2lnbmF0dXJl SW5kZXggc2lnbmF0dXJlSW5kZXgsIHVuc2lnbmVkIGltcG9ydEluZGV4KQogewogICAgIGNvbnN0 IFdhc21DYWxsaW5nQ29udmVudGlvbiYgd2FzbUNDID0gd2FzbUNhbGxpbmdDb252ZW50aW9uKCk7 CiAgICAgY29uc3QgSlNDQ2FsbGluZ0NvbnZlbnRpb24mIGpzQ0MgPSBqc2NDYWxsaW5nQ29udmVu dGlvbigpOwpAQCAtMjMxLDcgKzIzMSw0OCBAQCBXYXNtVG9KU1N0dWIgaW1wb3J0U3R1YkdlbmVy YXRvcihWTSogdm0sIEJhZzxDYWxsTGlua0luZm8+JiBjYWxsTGlua0luZm9zLCBTaWduYQogICAg IENvZGVMb2NhdGlvbkxhYmVsIGhvdFBhdGhCZWdpbihwYXRjaEJ1ZmZlci5sb2NhdGlvbk9mKHRh cmdldFRvQ2hlY2spKTsKICAgICBDb2RlTG9jYXRpb25OZWFyQ2FsbCBob3RQYXRoT3RoZXIgPSBw YXRjaEJ1ZmZlci5sb2NhdGlvbk9mTmVhckNhbGwoZmFzdENhbGwpOwogICAgIGNhbGxMaW5rSW5m by0+c2V0Q2FsbExvY2F0aW9ucyhjYWxsUmV0dXJuTG9jYXRpb24sIGhvdFBhdGhCZWdpbiwgaG90 UGF0aE90aGVyKTsKLSAgICByZXR1cm4gRklOQUxJWkVfQ09ERShwYXRjaEJ1ZmZlciwgKCJXZWJB c3NlbWJseSBpbXBvcnRbJWldIHN0dWIgZm9yIHNpZ25hdHVyZSAlaSIsIGltcG9ydEluZGV4LCBz aWduYXR1cmVJbmRleCkpOworICAgIFN0cmluZyBzaWduYXR1cmVEZXNjcmlwdGlvbiA9IFNpZ25h dHVyZUluZm9ybWF0aW9uOjpnZXQodm0sIHNpZ25hdHVyZUluZGV4KS0+dG9TdHJpbmcoKTsKKyAg ICByZXR1cm4gRklOQUxJWkVfQ09ERShwYXRjaEJ1ZmZlciwgKCJXZWJBc3NlbWJseS0+SmF2YVNj cmlwdCBpbXBvcnRbJWldICVzIiwgaW1wb3J0SW5kZXgsIHNpZ25hdHVyZURlc2NyaXB0aW9uLmFz Y2lpKCkuZGF0YSgpKSk7Cit9CisKK3N0YXRpYyBNYWNyb0Fzc2VtYmxlckNvZGVSZWYgd2FzbVRv V2FzbShWTSogdm0sIEJhZzxDYWxsTGlua0luZm8+JiBjYWxsTGlua0luZm9zLCBTaWduYXR1cmVJ bmRleCBzaWduYXR1cmVJbmRleCwgdW5zaWduZWQgaW1wb3J0SW5kZXgpCit7CisgICAgY29uc3Qg V2FzbUNhbGxpbmdDb252ZW50aW9uJiB3YXNtQ0MgPSB3YXNtQ2FsbGluZ0NvbnZlbnRpb24oKTsK KyAgICBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpn ZXQodm0sIHNpZ25hdHVyZUluZGV4KTsKKyAgICB1bnNpZ25lZCBhcmdDb3VudCA9IHNpZ25hdHVy ZS0+YXJndW1lbnRDb3VudCgpOworICAgIHR5cGVkZWYgQXNzZW1ibHlIZWxwZXJzIEpJVDsKKyAg ICBKSVQgaml0KHZtLCBudWxscHRyKTsKKworICAgIGppdC5lbWl0RnVuY3Rpb25Qcm9sb2d1ZSgp OworICAgIGppdC5zdG9yZTY0KEpJVDo6VHJ1c3RlZEltbTMyKDApLCBKSVQ6OkFkZHJlc3MoR1BS SW5mbzo6Y2FsbEZyYW1lUmVnaXN0ZXIsIENhbGxGcmFtZVNsb3Q6OmNvZGVCbG9jayAqIHN0YXRp Y19jYXN0PGludD4oc2l6ZW9mKFJlZ2lzdGVyKSkpKTsgLy8gRklYTUUgU3RvcCB1c2luZyAwIGFz IGNvZGVCbG9ja3MuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjUz MjEKKyAgICBqaXQuc3RvcmVQdHIoSklUOjpUcnVzdGVkSW1tUHRyKHZtLT53ZWJBc3NlbWJseVRv SlNDYWxsZWUuZ2V0KCkpLCBKSVQ6OkFkZHJlc3MoR1BSSW5mbzo6Y2FsbEZyYW1lUmVnaXN0ZXIs IENhbGxGcmFtZVNsb3Q6OmNhbGxlZSAqIHN0YXRpY19jYXN0PGludD4oc2l6ZW9mKFJlZ2lzdGVy KSkpKTsKKworICAgIC8vIEZJWE1FIHBlcmZvcm0gYSBzdGFjayBjaGVjayBiZWZvcmUgdXBkYXRp bmcgU1AuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjU1NDYKKwor ICAgIHVuc2lnbmVkIG51bWJlck9mUGFyYW1ldGVycyA9IGFyZ0NvdW50ICsgMTsgLy8gVGhlcmUg aXMgYSAidGhpcyIgYXJndW1lbnQuCisgICAgdW5zaWduZWQgbnVtYmVyT2ZSZWdzRm9yQ2FsbCA9 IENhbGxGcmFtZTo6aGVhZGVyU2l6ZUluUmVnaXN0ZXJzICsgbnVtYmVyT2ZQYXJhbWV0ZXJzOwor ICAgIHVuc2lnbmVkIG51bWJlck9mQnl0ZXNGb3JDYWxsID0gbnVtYmVyT2ZSZWdzRm9yQ2FsbCAq IHNpemVvZihSZWdpc3RlcikgLSBzaXplb2YoQ2FsbGVyRnJhbWVBbmRQQyk7CisgICAgY29uc3Qg dW5zaWduZWQgc3RhY2tPZmZzZXQgPSBXVEY6OnJvdW5kVXBUb011bHRpcGxlT2Yoc3RhY2tBbGln bm1lbnRCeXRlcygpLCBudW1iZXJPZkJ5dGVzRm9yQ2FsbCk7CisgICAgaml0LnN1YlB0cihNYWNy b0Fzc2VtYmxlcjo6VHJ1c3RlZEltbTMyKHN0YWNrT2Zmc2V0KSwgTWFjcm9Bc3NlbWJsZXI6OnN0 YWNrUG9pbnRlclJlZ2lzdGVyKTsKKyAgICBKSVQ6OkFkZHJlc3MgY2FsbGVlRnJhbWUgPSBDQ2Fs bEhlbHBlcnM6OkFkZHJlc3MoTWFjcm9Bc3NlbWJsZXI6OnN0YWNrUG9pbnRlclJlZ2lzdGVyLCAt c3RhdGljX2Nhc3Q8cHRyZGlmZl90PihzaXplb2YoQ2FsbGVyRnJhbWVBbmRQQykpKTsKKworICAg IC8vIEZJWE1FIGltcGxlbWVudCB0aGlzLgorICAgIGppdC5icmVha3BvaW50KCk7CisKKyAgICBq aXQuZW1pdEZ1bmN0aW9uRXBpbG9ndWUoKTsKKyAgICBqaXQucmV0KCk7CisKKyAgICBMaW5rQnVm ZmVyIHBhdGNoQnVmZmVyKCp2bSwgaml0LCBHTE9CQUxfVEhVTktfSUQpOworICAgIFN0cmluZyBz aWduYXR1cmVEZXNjcmlwdGlvbiA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQodm0sIHNpZ25h dHVyZUluZGV4KS0+dG9TdHJpbmcoKTsKKyAgICByZXR1cm4gRklOQUxJWkVfQ09ERShwYXRjaEJ1 ZmZlciwgKCJXZWJBc3NlbWJseS0+V2ViQXNzZW1ibHkgaW1wb3J0WyVpXSAlcyIsIGltcG9ydElu ZGV4LCBzaWduYXR1cmVEZXNjcmlwdGlvbi5hc2NpaSgpLmRhdGEoKSkpOworfQorCitXYXNtRXhp dFN0dWJzIGV4aXRTdHViR2VuZXJhdG9yKFZNKiB2bSwgQmFnPENhbGxMaW5rSW5mbz4mIGNhbGxM aW5rSW5mb3MsIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4LCB1bnNpZ25lZCBpbXBvcnRJ bmRleCkKK3sKKyAgICBXYXNtRXhpdFN0dWJzIHN0dWJzOworICAgIHN0dWJzLndhc21Ub0pTID0g d2FzbVRvSlModm0sIGNhbGxMaW5rSW5mb3MsIHNpZ25hdHVyZUluZGV4LCBpbXBvcnRJbmRleCk7 CisgICAgc3R1YnMud2FzbVRvV2FzbSA9IHdhc21Ub1dhc20odm0sIGNhbGxMaW5rSW5mb3MsIHNp Z25hdHVyZUluZGV4LCBpbXBvcnRJbmRleCk7CisgICAgcmV0dXJuIHN0dWJzOwogfQogCiB9IH0g Ly8gbmFtZXNwYWNlIEpTQzo6V2FzbQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbUJpbmRpbmcuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5k aW5nLmgKaW5kZXggZmQ3ZTAzZC4uNDAyMWYxNyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtQmluZGluZy5oCkBAIC0zOCw3ICszOCw3IEBAIGNsYXNzIENhbGxMaW5rSW5mbzsKIAog bmFtZXNwYWNlIFdhc20gewogCi1XYXNtVG9KU1N0dWIgaW1wb3J0U3R1YkdlbmVyYXRvcihWTSos IEJhZzxDYWxsTGlua0luZm8+JiwgU2lnbmF0dXJlSW5kZXgsIHVuc2lnbmVkKTsKK1dhc21FeGl0 U3R1YnMgZXhpdFN0dWJHZW5lcmF0b3IoVk0qLCBCYWc8Q2FsbExpbmtJbmZvPiYsIFNpZ25hdHVy ZUluZGV4LCB1bnNpZ25lZCk7CiAKIH0gfSAvLyBuYW1lc3BhY2UgSlNDOjpXYXNtCiAKZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Gb3JtYXQuaCBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21Gb3JtYXQuaAppbmRleCAzNTlkZGNjLi5iNmRhZGU5IDEw MDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRm9ybWF0LmgKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZvcm1hdC5oCkBAIC0xODcsNyArMTg3LDcg QEAgcHJpdmF0ZToKIH07CiAKIHN0cnVjdCBNb2R1bGVJbmZvcm1hdGlvbiB7Ci0gICAgVmVjdG9y PFNpZ25hdHVyZUluZGV4PiBzaWduYXR1cmVJbmRpY2VzOworICAgIFZlY3RvcjxTaWduYXR1cmVJ bmRleD4gbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXM7CiAg ICAgVmVjdG9yPEltcG9ydD4gaW1wb3J0czsKICAgICBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+IGlt cG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlczsKICAgICBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+ IGludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzOwpAQCAtMTk5LDYgKzE5OSwxOCBAQCBz dHJ1Y3QgTW9kdWxlSW5mb3JtYXRpb24gewogICAgIFRhYmxlSW5mb3JtYXRpb24gdGFibGVJbmZv cm1hdGlvbjsKICAgICBWZWN0b3I8R2xvYmFsPiBnbG9iYWxzOwogICAgIHVuc2lnbmVkIGZpcnN0 SW50ZXJuYWxHbG9iYWwgeyAwIH07CisgICAgc2l6ZV90IGZ1bmN0aW9uSW5kZXhTcGFjZVNpemUo KSBjb25zdCB7IHJldHVybiBpbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMuc2l6ZSgpICsg aW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXMuc2l6ZSgpOyB9CisgICAgYm9vbCBpc0lt cG9ydGVkRnVuY3Rpb25Gcm9tRnVuY3Rpb25JbmRleFNwYWNlKHNpemVfdCBmdW5jdGlvbkluZGV4 KSBjb25zdAorICAgIHsKKyAgICAgICAgQVNTRVJUKGZ1bmN0aW9uSW5kZXggPCBmdW5jdGlvbklu ZGV4U3BhY2VTaXplKCkpOworICAgICAgICByZXR1cm4gZnVuY3Rpb25JbmRleCA8IGltcG9ydEZ1 bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCk7CisgICAgfQorICAgIFNpZ25hdHVyZUluZGV4 IHNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShzaXplX3QgZnVuY3Rpb25JbmRl eCkgY29uc3QKKyAgICB7CisgICAgICAgIHJldHVybiBpc0ltcG9ydGVkRnVuY3Rpb25Gcm9tRnVu Y3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgpCisgICAgICAgICAgICA/IGltcG9ydEZ1bmN0 aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4XQorICAgICAgICAgICAgOiBpbnRlcm5h bEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4IC0gaW1wb3J0RnVuY3Rpb25T aWduYXR1cmVJbmRpY2VzLnNpemUoKV07CisgICAgfQogCiAgICAgfk1vZHVsZUluZm9ybWF0aW9u KCk7CiB9OwpAQCAtMjA2LDYgKzIxOCw3IEBAIHN0cnVjdCBNb2R1bGVJbmZvcm1hdGlvbiB7CiBz dHJ1Y3QgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbCB7CiAgICAgQ29kZUxvY2F0aW9uQ2FsbCBjYWxs TG9jYXRpb247CiAgICAgc2l6ZV90IGZ1bmN0aW9uSW5kZXg7CisgICAgYm9vbCB0b0pTOwogfTsK IAogc3RydWN0IEVudHJ5cG9pbnQgewpAQCAtMjIxLDcgKzIzNCwxMCBAQCBzdHJ1Y3QgV2FzbUlu dGVybmFsRnVuY3Rpb24gewogICAgIEVudHJ5cG9pbnQganNUb1dhc21FbnRyeXBvaW50OwogfTsK IAotdHlwZWRlZiBNYWNyb0Fzc2VtYmxlckNvZGVSZWYgV2FzbVRvSlNTdHViOworc3RydWN0IFdh c21FeGl0U3R1YnMgeworICAgIE1hY3JvQXNzZW1ibGVyQ29kZVJlZiB3YXNtVG9KUzsKKyAgICBN YWNyb0Fzc2VtYmxlckNvZGVSZWYgd2FzbVRvV2FzbTsKK307CiAKIC8vIFdlYkFzc2VtYmx5IGRp cmVjdCBjYWxscyBhbmQgY2FsbF9pbmRpcmVjdCB1c2UgaW5kaWNlcyBpbnRvICJmdW5jdGlvbiBp bmRleCBzcGFjZSIuIFRoaXMgc3BhY2Ugc3RhcnRzIHdpdGggYWxsIGltcG9ydHMsIGFuZCB0aGVu IGFsbCBpbnRlcm5hbCBmdW5jdGlvbnMuCiAvLyBDYWxsYWJsZUZ1bmN0aW9uIGFuZCBGdW5jdGlv bkluZGV4U3BhY2UgYXJlIG9ubHkgbWVhbnQgYXMgZmFzdCBsb29rdXAgdGFibGVzIGZvciB0aGVz ZSBvcGNvZGVzLCBhbmQgZG8gbm90IG93biBjb2RlLgpAQCAtMjQwLDEyICsyNTYsNiBAQCBzdHJ1 Y3QgQ2FsbGFibGVGdW5jdGlvbiB7CiB9OwogdHlwZWRlZiBWZWN0b3I8Q2FsbGFibGVGdW5jdGlv bj4gRnVuY3Rpb25JbmRleFNwYWNlOwogCi0KLXN0cnVjdCBJbW11dGFibGVGdW5jdGlvbkluZGV4 U3BhY2UgewotICAgIE1hbGxvY1B0cjxDYWxsYWJsZUZ1bmN0aW9uPiBidWZmZXI7Ci0gICAgc2l6 ZV90IHNpemU7Ci19OwotCiB9IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2FzbQogCiAjZW5kaWYgLy8g RU5BQkxFKFdFQkFTU0VNQkxZKQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbUZ1bmN0aW9uUGFyc2VyLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt RnVuY3Rpb25QYXJzZXIuaAppbmRleCBhNjBhYzQ3Li4zZWNiMzkzIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rpb25QYXJzZXIuaAorKysgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rpb25QYXJzZXIuaApAQCAtNDYsNyArNDYsNyBA QCBwdWJsaWM6CiAgICAgdHlwZWRlZiB0eXBlbmFtZSBDb250ZXh0OjpDb250cm9sVHlwZSBDb250 cm9sVHlwZTsKICAgICB0eXBlZGVmIHR5cGVuYW1lIENvbnRleHQ6OkV4cHJlc3Npb25MaXN0IEV4 cHJlc3Npb25MaXN0OwogCi0gICAgRnVuY3Rpb25QYXJzZXIoVk0qLCBDb250ZXh0JiwgY29uc3Qg dWludDhfdCogZnVuY3Rpb25TdGFydCwgc2l6ZV90IGZ1bmN0aW9uTGVuZ3RoLCBjb25zdCBTaWdu YXR1cmUqLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmLCBjb25zdCBNb2R1bGVJ bmZvcm1hdGlvbiYpOworICAgIEZ1bmN0aW9uUGFyc2VyKFZNKiwgQ29udGV4dCYsIGNvbnN0IHVp bnQ4X3QqIGZ1bmN0aW9uU3RhcnQsIHNpemVfdCBmdW5jdGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0 dXJlKiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mKTsKIAogICAgIFJlc3VsdCBXQVJOX1VOVVNF RF9SRVRVUk4gcGFyc2UoKTsKIApAQCAtODIsMTcgKzgyLDE1IEBAIHByaXZhdGU6CiAgICAgRXhw cmVzc2lvbkxpc3QgbV9leHByZXNzaW9uU3RhY2s7CiAgICAgVmVjdG9yPENvbnRyb2xFbnRyeT4g bV9jb250cm9sU3RhY2s7CiAgICAgY29uc3QgU2lnbmF0dXJlKiBtX3NpZ25hdHVyZTsKLSAgICBj b25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIG1fZnVuY3Rpb25JbmRleFNwYWNlOwog ICAgIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBtX2luZm87CiAgICAgdW5zaWduZWQgbV91bnJl YWNoYWJsZUJsb2NrcyB7IDAgfTsKIH07CiAKIHRlbXBsYXRlPHR5cGVuYW1lIENvbnRleHQ+Ci1G dW5jdGlvblBhcnNlcjxDb250ZXh0Pjo6RnVuY3Rpb25QYXJzZXIoVk0qIHZtLCBDb250ZXh0JiBj b250ZXh0LCBjb25zdCB1aW50OF90KiBmdW5jdGlvblN0YXJ0LCBzaXplX3QgZnVuY3Rpb25MZW5n dGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbklu ZGV4U3BhY2UmIGZ1bmN0aW9uSW5kZXhTcGFjZSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGlu Zm8pCitGdW5jdGlvblBhcnNlcjxDb250ZXh0Pjo6RnVuY3Rpb25QYXJzZXIoVk0qIHZtLCBDb250 ZXh0JiBjb250ZXh0LCBjb25zdCB1aW50OF90KiBmdW5jdGlvblN0YXJ0LCBzaXplX3QgZnVuY3Rp b25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBjb25zdCBNb2R1bGVJbmZvcm1h dGlvbiYgaW5mbykKICAgICA6IFBhcnNlcih2bSwgZnVuY3Rpb25TdGFydCwgZnVuY3Rpb25MZW5n dGgpCiAgICAgLCBtX2NvbnRleHQoY29udGV4dCkKICAgICAsIG1fc2lnbmF0dXJlKHNpZ25hdHVy ZSkKLSAgICAsIG1fZnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXhTcGFjZSkKICAgICAs IG1faW5mbyhpbmZvKQogewogICAgIGlmICh2ZXJib3NlKQpAQCAtMzA4LDkgKzMwNiw5IEBAIGF1 dG8gRnVuY3Rpb25QYXJzZXI8Q29udGV4dD46OnBhcnNlRXhwcmVzc2lvbihPcFR5cGUgb3ApIC0+ IFBhcnRpYWxSZXN1bHQKICAgICBjYXNlIENhbGw6IHsKICAgICAgICAgdWludDMyX3QgZnVuY3Rp b25JbmRleDsKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoZnVu Y3Rpb25JbmRleCksICJjYW4ndCBwYXJzZSBjYWxsJ3MgZnVuY3Rpb24gaW5kZXgiKTsKLSAgICAg ICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1fZnVuY3Rpb25JbmRleFNw YWNlLnNpemUsICJjYWxsIGZ1bmN0aW9uIGluZGV4ICIsIGZ1bmN0aW9uSW5kZXgsICIgZXhjZWVk cyBmdW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5zaXplKTsKKyAg ICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1faW5mby5mdW5jdGlv bkluZGV4U3BhY2VTaXplKCksICJjYWxsIGZ1bmN0aW9uIGluZGV4ICIsIGZ1bmN0aW9uSW5kZXgs ICIgZXhjZWVkcyBmdW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX2luZm8uZnVuY3Rpb25JbmRleFNw YWNlU2l6ZSgpKTsKIAotICAgICAgICBTaWduYXR1cmVJbmRleCBjYWxsZWVTaWduYXR1cmVJbmRl eCA9IG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtmdW5jdGlvbkluZGV4XS5zaWdu YXR1cmVJbmRleDsKKyAgICAgICAgU2lnbmF0dXJlSW5kZXggY2FsbGVlU2lnbmF0dXJlSW5kZXgg PSBtX2luZm8uc2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5k ZXgpOwogICAgICAgICBjb25zdCBTaWduYXR1cmUqIGNhbGxlZVNpZ25hdHVyZSA9IFNpZ25hdHVy ZUluZm9ybWF0aW9uOjpnZXQobV92bSwgY2FsbGVlU2lnbmF0dXJlSW5kZXgpOwogICAgICAgICBX QVNNX1BBUlNFUl9GQUlMX0lGKGNhbGxlZVNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpID4gbV9l eHByZXNzaW9uU3RhY2suc2l6ZSgpLCAiY2FsbCBmdW5jdGlvbiBpbmRleCAiLCBmdW5jdGlvbklu ZGV4LCAiIGhhcyAiLCBjYWxsZWVTaWduYXR1cmUtPmFyZ3VtZW50Q291bnQoKSwgIiBhcmd1bWVu dHMsIGJ1dCB0aGUgZXhwcmVzc2lvbiBzdGFjayBjdXJyZW50bHkgaG9sZHMgIiwgbV9leHByZXNz aW9uU3RhY2suc2l6ZSgpLCAiIHZhbHVlcyIpOwogCkBAIC0zMzcsOSArMzM1LDkgQEAgYXV0byBG dW5jdGlvblBhcnNlcjxDb250ZXh0Pjo6cGFyc2VFeHByZXNzaW9uKE9wVHlwZSBvcCkgLT4gUGFy dGlhbFJlc3VsdAogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihz aWduYXR1cmVJbmRleCksICJjYW4ndCBnZXQgY2FsbF9pbmRpcmVjdCdzIHNpZ25hdHVyZSBpbmRl eCIpOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQxKHJlc2VydmVk KSwgImNhbid0IGdldCBjYWxsX2luZGlyZWN0J3MgcmVzZXJ2ZWQgYnl0ZSIpOwogICAgICAgICBX QVNNX1BBUlNFUl9GQUlMX0lGKHJlc2VydmVkLCAiY2FsbF9pbmRpcmVjdCdzICdyZXNlcnZlZCcg dmFydWludDEgbXVzdCBiZSAweDAiKTsKLSAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihtX2lu Zm8uc2lnbmF0dXJlSW5kaWNlcy5zaXplKCkgPD0gc2lnbmF0dXJlSW5kZXgsICJjYWxsX2luZGly ZWN0J3Mgc2lnbmF0dXJlIGluZGV4ICIsIHNpZ25hdHVyZUluZGV4LCAiIGV4Y2VlZHMga25vd24g c2lnbmF0dXJlcyAiLCBtX2luZm8uc2lnbmF0dXJlSW5kaWNlcy5zaXplKCkpOworICAgICAgICBX QVNNX1BBUlNFUl9GQUlMX0lGKG1faW5mby5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVk U2lnbmF0dXJlSW5kaWNlcy5zaXplKCkgPD0gc2lnbmF0dXJlSW5kZXgsICJjYWxsX2luZGlyZWN0 J3Mgc2lnbmF0dXJlIGluZGV4ICIsIHNpZ25hdHVyZUluZGV4LCAiIGV4Y2VlZHMga25vd24gc2ln bmF0dXJlcyAiLCBtX2luZm8ubW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVy ZUluZGljZXMuc2l6ZSgpKTsKIAotICAgICAgICBTaWduYXR1cmVJbmRleCBjYWxsZWVTaWduYXR1 cmVJbmRleCA9IG1faW5mby5zaWduYXR1cmVJbmRpY2VzW3NpZ25hdHVyZUluZGV4XTsKKyAgICAg ICAgU2lnbmF0dXJlSW5kZXggY2FsbGVlU2lnbmF0dXJlSW5kZXggPSBtX2luZm8ubW9kdWxlU2ln bmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXNbc2lnbmF0dXJlSW5kZXhdOwog ICAgICAgICBjb25zdCBTaWduYXR1cmUqIGNhbGxlZVNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9y bWF0aW9uOjpnZXQobV92bSwgY2FsbGVlU2lnbmF0dXJlSW5kZXgpOwogICAgICAgICBzaXplX3Qg YXJndW1lbnRDb3VudCA9IGNhbGxlZVNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpICsgMTsgLy8g QWRkIHRoZSBjYWxsZWUncyBpbmRleC4KICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihhcmd1 bWVudENvdW50ID4gbV9leHByZXNzaW9uU3RhY2suc2l6ZSgpLCAiY2FsbF9pbmRpcmVjdCBleHBl Y3RzICIsIGFyZ3VtZW50Q291bnQsICIgYXJndW1lbnRzLCBidXQgdGhlIGV4cHJlc3Npb24gc3Rh Y2sgY3VycmVudGx5IGhvbGRzICIsIG1fZXhwcmVzc2lvblN0YWNrLnNpemUoKSwgIiB2YWx1ZXMi KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3Bw IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5jcHAKaW5kZXggZjE5ZWNl MC4uMWU5YzliZiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1l bW9yeS5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5jcHAK QEAgLTMxLDExICszMSwxMSBAQAogbmFtZXNwYWNlIEpTQyB7IG5hbWVzcGFjZSBXYXNtIHsKIAog TWVtb3J5OjpNZW1vcnkoUGFnZUNvdW50IGluaXRpYWwsIFBhZ2VDb3VudCBtYXhpbXVtKQotICAg IDogbV9tb2RlKE1vZGU6OkJvdW5kc0NoZWNraW5nKQotICAgICwgbV9zaXplKGluaXRpYWwuYnl0 ZXMoKSkKKyAgICA6IG1fc2l6ZShpbml0aWFsLmJ5dGVzKCkpCiAgICAgLCBtX2NhcGFjaXR5KG1h eGltdW0gPyBtYXhpbXVtLmJ5dGVzKCkgOiBQYWdlQ291bnQ6Om1heCgpLmJ5dGVzKCkpCiAgICAg LCBtX2luaXRpYWwoaW5pdGlhbCkKICAgICAsIG1fbWF4aW11bShtYXhpbXVtKQorICAgICwgbV9t b2RlKE1vZGU6OkJvdW5kc0NoZWNraW5nKQogICAgIC8vIEZJWE1FOiBJZiB3ZSBhZGQgc2lnbmFs IGJhc2VkIGJvdW5kcyBjaGVja2luZyB0aGVuIHdlIG5lZWQgZXh0cmEgc3BhY2UgZm9yIG92ZXJm bG93IG9uIGxvYWQuCiAgICAgLy8gc2VlOiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MTYyNjkzCiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtTWVtb3J5LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmgK aW5kZXggYjQxMWYzNDguLjQzMDQ3NjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL1dhc21NZW1vcnkuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt TWVtb3J5LmgKQEAgLTM4LDYgKzM4LDcgQEAgY2xhc3MgTWVtb3J5IHsKICAgICBXVEZfTUFLRV9O T05DT1BZQUJMRShNZW1vcnkpOwogICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwogcHVibGlj OgorICAgIE1lbW9yeShNZW1vcnkmJikgPSBkZWZhdWx0OwogCiAgICAgLy8gRklYTUU6IFdlIHNo b3VsZCBzdXBwb3J0IG90aGVyIG1vZGVzLiBzZWU6IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xNjI2OTMKICAgICBlbnVtIGNsYXNzIE1vZGUgewpAQCAtNTcsMTEgKzU4 LDExIEBAIHB1YmxpYzoKICAgICB2b2lkKiBtZW1vcnkoKSBjb25zdCB7IHJldHVybiBtX21lbW9y eTsgfQogICAgIHVpbnQzMl90IHNpemUoKSBjb25zdCB7IHJldHVybiBtX3NpemU7IH0KIAotICAg IE1vZGUgbW9kZSgpIGNvbnN0IHsgcmV0dXJuIG1fbW9kZTsgfQotCiAgICAgUGFnZUNvdW50IGlu aXRpYWwoKSBjb25zdCB7IHJldHVybiBtX2luaXRpYWw7IH0KICAgICBQYWdlQ291bnQgbWF4aW11 bSgpIGNvbnN0IHsgcmV0dXJuIG1fbWF4aW11bTsgfQogCisgICAgTW9kZSBtb2RlKCkgY29uc3Qg eyByZXR1cm4gbV9tb2RlOyB9CisKICAgICBib29sIGdyb3codWludDMyX3QgbmV3U2l6ZSkKICAg ICB7CiAgICAgICAgIEFTU0VSVChtX21lbW9yeSk7CkBAIC03MSwxNyArNzIsMTggQEAgcHVibGlj OgogICAgICAgICByZXR1cm4gIW1wcm90ZWN0KG1fbWVtb3J5LCBuZXdTaXplLCBQUk9UX1JFQUQg fCBQUk9UX1dSSVRFKTsKICAgICB9CiAKKyAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mTWVt b3J5KCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKE1lbW9yeSwgbV9tZW1vcnkpOyB9CiAgICAg c3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZlNpemUoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0Yo TWVtb3J5LCBtX3NpemUpOyB9CiAKICAgICAKIHByaXZhdGU6CiAgICAgdm9pZCogbV9tZW1vcnkg eyBudWxscHRyIH07Ci0gICAgTW9kZSBtX21vZGU7CiAgICAgdWludDMyX3QgbV9zaXplIHsgMCB9 OwogICAgIHVpbnQzMl90IG1fY2FwYWNpdHkgeyAwIH07CiAgICAgUGFnZUNvdW50IG1faW5pdGlh bDsKICAgICBQYWdlQ291bnQgbV9tYXhpbXVtOwogICAgIHVpbnQ2NF90IG1fbWFwcGVkQ2FwYWNp dHkgeyAwIH07CisgICAgTW9kZSBtX21vZGUgeyBNb2RlOjpCb3VuZHNDaGVja2luZyB9OwogfTsK IAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbU1vZHVsZVBhcnNlci5jcHAKaW5kZXggODkxODQ3NS4uNTJmZWJhYyAxMDA2NDQK LS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5jcHAKKysr IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5jcHAKQEAgLTk5 LDcgKzk5LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlVHlwZSgpIC0+IFBhcnRpYWxSZXN1 bHQKIAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKGNvdW50KSwgImNh bid0IGdldCBUeXBlIHNlY3Rpb24ncyBjb3VudCIpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYo Y291bnQgPT0gc3RkOjpudW1lcmljX2xpbWl0czx1aW50MzJfdD46Om1heCgpLCAiVHlwZSBzZWN0 aW9uJ3MgY291bnQgaXMgdG9vIGJpZyAiLCBjb3VudCk7Ci0gICAgV0FTTV9QQVJTRVJfRkFJTF9J RighbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnRyeVJlc2VydmVDYXBhY2l0eShj b3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciBUeXBlIHNlY3Rpb24ncyAi LCBjb3VudCwgIiBlbnRyaWVzIik7CisgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQu bW9kdWxlLT5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy50 cnlSZXNlcnZlQ2FwYWNpdHkoY291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBm b3IgVHlwZSBzZWN0aW9uJ3MgIiwgY291bnQsICIgZW50cmllcyIpOwogCiAgICAgZm9yICh1aW50 MzJfdCBpID0gMDsgaSA8IGNvdW50OyArK2kpIHsKICAgICAgICAgaW50OF90IHR5cGU7CkBAIC0x MzEsNyArMTMxLDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlVHlwZSgpIC0+IFBhcnRpYWxS ZXN1bHQKICAgICAgICAgc2lnbmF0dXJlLT5yZXR1cm5UeXBlKCkgPSByZXR1cm5UeXBlOwogCiAg ICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gU2lnbmF0dXJlSW5mb3JtYXRp b246OmFkb3B0KG1fdm0sIHNpZ25hdHVyZS5yZWxlYXNlKCkpOwotICAgICAgICBtX3Jlc3VsdC5t b2R1bGUtPnNpZ25hdHVyZUluZGljZXMudW5jaGVja2VkQXBwZW5kKHNpZ25hdHVyZUluZGV4KTsK KyAgICAgICAgbV9yZXN1bHQubW9kdWxlLT5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVk U2lnbmF0dXJlSW5kaWNlcy51bmNoZWNrZWRBcHBlbmQoc2lnbmF0dXJlSW5kZXgpOwogICAgIH0K ICAgICByZXR1cm4geyB9OwogfQpAQCAtMTQ0LDcgKzE0NCw2IEBAIGF1dG8gTW9kdWxlUGFyc2Vy OjpwYXJzZUltcG9ydCgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lG KCFtX3Jlc3VsdC5tb2R1bGUtPmdsb2JhbHMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGltcG9ydENvdW50 KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGltcG9ydENvdW50LCAiIGds b2JhbHMiKTsgLy8gRklYTUUgdGhpcyBvdmVyLWFsbG9jYXRlcyB3aGVuIHdlIGZpeCB0aGUgRklY TUVzIGJlbG93LgogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0Lm1vZHVsZS0+aW1w b3J0cy50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5v dWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIgaW1wb3J0cyIpOyAvLyBGSVhNRSB0aGlz IG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBGSVhNRXMgYmVsb3cuCiAgICAgV0FTTV9Q QVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlLT5pbXBvcnRGdW5jdGlvblNpZ25hdHVyZUlu ZGljZXMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGltcG9ydENvdW50KSwgImNhbid0IGFsbG9jYXRlIGVu b3VnaCBtZW1vcnkgZm9yICIsIGltcG9ydENvdW50LCAiIGltcG9ydCBmdW5jdGlvbiBzaWduYXR1 cmVzIik7IC8vIEZJWE1FIHRoaXMgb3Zlci1hbGxvY2F0ZXMgd2hlbiB3ZSBmaXggdGhlIEZJWE1F cyBiZWxvdy4KLSAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX3Jlc3VsdC5mdW5jdGlvbkluZGV4 U3BhY2UudHJ5UmVzZXJ2ZUNhcGFjaXR5KGltcG9ydENvdW50KSwgImNhbid0IGFsbG9jYXRlIGVu b3VnaCBtZW1vcnkgZm9yICIsIGltcG9ydENvdW50LCAiIGZ1bmN0aW9ucyBpbiB0aGUgaW5kZXgg c3BhY2UiKTsgLy8gRklYTUUgdGhpcyBvdmVyLWFsbG9jYXRlcyB3aGVuIHdlIGZpeCB0aGUgRklY TUVzIGJlbG93LiBXZSdsbCBhbGxvY2F0ZSBzb21lIG1vcmUgaGVyZSB3aGVuIHdlIGtub3cgaG93 IG1hbnkgZnVuY3Rpb25zIHRvIGV4cGVjdC4KIAogICAgIGZvciAodWludDMyX3QgaW1wb3J0TnVt YmVyID0gMDsgaW1wb3J0TnVtYmVyIDwgaW1wb3J0Q291bnQ7ICsraW1wb3J0TnVtYmVyKSB7CiAg ICAgICAgIEltcG9ydCBpbXA7CkBAIC0xNjYsMTEgKzE2NSwxMCBAQCBhdXRvIE1vZHVsZVBhcnNl cjo6cGFyc2VJbXBvcnQoKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgICAgIGNhc2UgRXh0ZXJuYWxL aW5kOjpGdW5jdGlvbjogewogICAgICAgICAgICAgdWludDMyX3QgZnVuY3Rpb25TaWduYXR1cmVJ bmRleDsKICAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKGZ1 bmN0aW9uU2lnbmF0dXJlSW5kZXgpLCAiY2FuJ3QgZ2V0ICIsIGltcG9ydE51bWJlciwgInRoIElt cG9ydCdzIGZ1bmN0aW9uIHNpZ25hdHVyZSBpbiBtb2R1bGUgJyIsIG1vZHVsZVN0cmluZywgIicg ZmllbGQgJyIsIGZpZWxkU3RyaW5nLCAiJyIpOwotICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJ TF9JRihmdW5jdGlvblNpZ25hdHVyZUluZGV4ID49IG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJl SW5kaWNlcy5zaXplKCksICJpbnZhbGlkIGZ1bmN0aW9uIHNpZ25hdHVyZSBmb3IgIiwgaW1wb3J0 TnVtYmVyLCAidGggSW1wb3J0LCAiLCBmdW5jdGlvblNpZ25hdHVyZUluZGV4LCAiIGlzIG91dCBv ZiByYW5nZSBvZiAiLCBtX3Jlc3VsdC5tb2R1bGUtPnNpZ25hdHVyZUluZGljZXMuc2l6ZSgpLCAi IGluIG1vZHVsZSAnIiwgbW9kdWxlU3RyaW5nLCAiJyBmaWVsZCAnIiwgZmllbGRTdHJpbmcsICIn Iik7CisgICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGZ1bmN0aW9uU2lnbmF0dXJlSW5k ZXggPj0gbV9yZXN1bHQubW9kdWxlLT5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2ln bmF0dXJlSW5kaWNlcy5zaXplKCksICJpbnZhbGlkIGZ1bmN0aW9uIHNpZ25hdHVyZSBmb3IgIiwg aW1wb3J0TnVtYmVyLCAidGggSW1wb3J0LCAiLCBmdW5jdGlvblNpZ25hdHVyZUluZGV4LCAiIGlz IG91dCBvZiByYW5nZSBvZiAiLCBtX3Jlc3VsdC5tb2R1bGUtPm1vZHVsZVNpZ25hdHVyZUluZGlj ZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzLnNpemUoKSwgIiBpbiBtb2R1bGUgJyIsIG1vZHVs ZVN0cmluZywgIicgZmllbGQgJyIsIGZpZWxkU3RyaW5nLCAiJyIpOwogICAgICAgICAgICAgaW1w LmtpbmRJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZS0+aW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRp Y2VzLnNpemUoKTsKLSAgICAgICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0g bV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzW2Z1bmN0aW9uU2lnbmF0dXJlSW5kZXhd OworICAgICAgICAgICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtX3Jlc3VsdC5t b2R1bGUtPm1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzW2Z1 bmN0aW9uU2lnbmF0dXJlSW5kZXhdOwogICAgICAgICAgICAgbV9yZXN1bHQubW9kdWxlLT5pbXBv cnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMudW5jaGVja2VkQXBwZW5kKHNpZ25hdHVyZUluZGV4 KTsKLSAgICAgICAgICAgIG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS51bmNoZWNrZWRBcHBl bmQoc2lnbmF0dXJlSW5kZXgpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIH0KICAgICAg ICAgY2FzZSBFeHRlcm5hbEtpbmQ6OlRhYmxlOiB7CkBAIC0yMTIsMjAgKzIxMCwxOCBAQCBhdXRv IE1vZHVsZVBhcnNlcjo6cGFyc2VGdW5jdGlvbigpIC0+IFBhcnRpYWxSZXN1bHQKICAgICBXQVNN X1BBUlNFUl9GQUlMX0lGKGNvdW50ID09IHN0ZDo6bnVtZXJpY19saW1pdHM8dWludDMyX3Q+Ojpt YXgoKSwgIkZ1bmN0aW9uIHNlY3Rpb24ncyBjb3VudCBpcyB0b28gYmlnICIsIGNvdW50KTsKICAg ICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX3Jlc3VsdC5tb2R1bGUtPmludGVybmFsRnVuY3Rpb25T aWduYXR1cmVJbmRpY2VzLnRyeVJlc2VydmVDYXBhY2l0eShjb3VudCksICJjYW4ndCBhbGxvY2F0 ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBjb3VudCwgIiBGdW5jdGlvbiBzaWduYXR1cmVzIik7CiAg ICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQuZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5 LnRyeVJlc2VydmVDYXBhY2l0eShjb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5 IGZvciAiLCBjb3VudCwgIkZ1bmN0aW9uIGxvY2F0aW9ucyIpOwotICAgIFdBU01fUEFSU0VSX0ZB SUxfSUYoIW1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS50cnlSZXNlcnZlQ2FwYWNpdHkobV9y ZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnNpemUoKSArIGNvdW50KSwgImNhbid0IGFsbG9jYXRl IGVub3VnaCBtZW1vcnkgZm9yICIsIGNvdW50LCAiIG1vcmUgZnVuY3Rpb25zIGluIHRoZSBmdW5j dGlvbiBpbmRleCBzcGFjZSIpOwogCiAgICAgZm9yICh1aW50MzJfdCBpID0gMDsgaSA8IGNvdW50 OyArK2kpIHsKICAgICAgICAgdWludDMyX3QgdHlwZU51bWJlcjsKICAgICAgICAgV0FTTV9QQVJT RVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIodHlwZU51bWJlciksICJjYW4ndCBnZXQgIiwgaSwg InRoIEZ1bmN0aW9uJ3MgdHlwZSBudW1iZXIiKTsKLSAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9J Rih0eXBlTnVtYmVyID49IG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlcy5zaXplKCks IGksICJ0aCBGdW5jdGlvbiB0eXBlIG51bWJlciBpcyBpbnZhbGlkICIsIHR5cGVOdW1iZXIpOwor ICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHR5cGVOdW1iZXIgPj0gbV9yZXN1bHQubW9kdWxl LT5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXplKCks IGksICJ0aCBGdW5jdGlvbiB0eXBlIG51bWJlciBpcyBpbnZhbGlkICIsIHR5cGVOdW1iZXIpOwog Ci0gICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9yZXN1bHQubW9kdWxl LT5zaWduYXR1cmVJbmRpY2VzW3R5cGVOdW1iZXJdOworICAgICAgICBTaWduYXR1cmVJbmRleCBz aWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZS0+bW9kdWxlU2lnbmF0dXJlSW5kaWNlc1Rv VW5pcXVlZFNpZ25hdHVyZUluZGljZXNbdHlwZU51bWJlcl07CiAgICAgICAgIC8vIFRoZSBDb2Rl IHNlY3Rpb24gZml4ZXMgdXAgc3RhcnQgYW5kIGVuZC4KICAgICAgICAgc2l6ZV90IHN0YXJ0ID0g MDsKICAgICAgICAgc2l6ZV90IGVuZCA9IDA7CiAgICAgICAgIG1fcmVzdWx0Lm1vZHVsZS0+aW50 ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXMudW5jaGVja2VkQXBwZW5kKHNpZ25hdHVyZUlu ZGV4KTsKICAgICAgICAgbV9yZXN1bHQuZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5LnVuY2hlY2tl ZEFwcGVuZCh7IHN0YXJ0LCBlbmQgfSk7Ci0gICAgICAgIG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhT cGFjZS51bmNoZWNrZWRBcHBlbmQoc2lnbmF0dXJlSW5kZXgpOwogICAgIH0KIAogICAgIHJldHVy biB7IH07CkBAIC0zOTYsNyArMzkyLDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlRXhwb3J0 KCkgLT4gUGFydGlhbFJlc3VsdAogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZh clVJbnQzMihleHAua2luZEluZGV4KSwgImNhbid0IGdldCAiLCBleHBvcnROdW1iZXIsICJ0aCBF eHBvcnQncyBraW5kIGluZGV4LCBuYW1lZCAnIiwgZmllbGRTdHJpbmcsICInIik7CiAgICAgICAg IHN3aXRjaCAoZXhwLmtpbmQpIHsKICAgICAgICAgY2FzZSBFeHRlcm5hbEtpbmQ6OkZ1bmN0aW9u OiB7Ci0gICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGV4cC5raW5kSW5kZXggPj0gbV9y ZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnNpemUoKSwgZXhwb3J0TnVtYmVyLCAidGggRXhwb3J0 IGhhcyBpbnZhbGlkIGZ1bmN0aW9uIG51bWJlciAiLCBleHAua2luZEluZGV4LCAiIGl0IGV4Y2Vl ZHMgdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlICIsIG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFj ZS5zaXplKCksICIsIG5hbWVkICciLCBmaWVsZFN0cmluZywgIiciKTsKKyAgICAgICAgICAgIFdB U01fUEFSU0VSX0ZBSUxfSUYoZXhwLmtpbmRJbmRleCA+PSBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0 aW9uSW5kZXhTcGFjZVNpemUoKSwgZXhwb3J0TnVtYmVyLCAidGggRXhwb3J0IGhhcyBpbnZhbGlk IGZ1bmN0aW9uIG51bWJlciAiLCBleHAua2luZEluZGV4LCAiIGl0IGV4Y2VlZHMgdGhlIGZ1bmN0 aW9uIGluZGV4IHNwYWNlICIsIG1fcmVzdWx0Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6 ZSgpLCAiLCBuYW1lZCAnIiwgZmllbGRTdHJpbmcsICInIik7CiAgICAgICAgICAgICBicmVhazsK ICAgICAgICAgfQogICAgICAgICBjYXNlIEV4dGVybmFsS2luZDo6VGFibGU6IHsKQEAgLTQyNiw4 ICs0MjIsOCBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VTdGFydCgpIC0+IFBhcnRpYWxSZXN1 bHQKIHsKICAgICB1aW50MzJfdCBzdGFydEZ1bmN0aW9uSW5kZXg7CiAgICAgV0FTTV9QQVJTRVJf RkFJTF9JRighcGFyc2VWYXJVSW50MzIoc3RhcnRGdW5jdGlvbkluZGV4KSwgImNhbid0IGdldCBT dGFydCBpbmRleCIpOwotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc3RhcnRGdW5jdGlvbkluZGV4 ID49IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCksICJTdGFydCBpbmRleCAiLCBz dGFydEZ1bmN0aW9uSW5kZXgsICIgZXhjZWVkcyBmdW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX3Jl c3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpKTsKLSAgICBTaWduYXR1cmVJbmRleCBzaWdu YXR1cmVJbmRleCA9IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZVtzdGFydEZ1bmN0aW9uSW5k ZXhdLnNpZ25hdHVyZUluZGV4OworICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc3RhcnRGdW5jdGlv bkluZGV4ID49IG1fcmVzdWx0Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpLCAiU3Rh cnQgaW5kZXggIiwgc3RhcnRGdW5jdGlvbkluZGV4LCAiIGV4Y2VlZHMgZnVuY3Rpb24gaW5kZXgg c3BhY2UgIiwgbV9yZXN1bHQubW9kdWxlLT5mdW5jdGlvbkluZGV4U3BhY2VTaXplKCkpOworICAg IFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1 cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2Uoc3RhcnRGdW5jdGlvbkluZGV4KTsKICAgICBj b25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92 bSwgc2lnbmF0dXJlSW5kZXgpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc2lnbmF0dXJlLT5h cmd1bWVudENvdW50KCksICJTdGFydCBmdW5jdGlvbiBjYW4ndCBoYXZlIGFyZ3VtZW50cyIpOwog ICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc2lnbmF0dXJlLT5yZXR1cm5UeXBlKCkgIT0gVm9pZCwg IlN0YXJ0IGZ1bmN0aW9uIGNhbid0IHJldHVybiBhIHZhbHVlIik7CkBAIC00NzcsNyArNDczLDcg QEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlRWxlbWVudCgpIC0+IFBhcnRpYWxSZXN1bHQKICAg ICAgICAgZm9yICh1bnNpZ25lZCBpbmRleCA9IDA7IGluZGV4IDwgaW5kZXhDb3VudDsgKytpbmRl eCkgewogICAgICAgICAgICAgdWludDMyX3QgZnVuY3Rpb25JbmRleDsKICAgICAgICAgICAgIFdB U01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKGZ1bmN0aW9uSW5kZXgpLCAiY2FuJ3Qg Z2V0IEVsZW1lbnQgc2VjdGlvbidzICIsIGVsZW1lbnROdW0sICJ0aCBlbGVtZW50J3MgIiwgaW5k ZXgsICJ0aCBpbmRleCIpOwotICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlv bkluZGV4ID49IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCksICJFbGVtZW50IHNl Y3Rpb24ncyAiLCBlbGVtZW50TnVtLCAidGggZWxlbWVudCdzICIsIGluZGV4LCAidGggaW5kZXgg aXMgIiwgZnVuY3Rpb25JbmRleCwgIiB3aGljaCBleGNlZWRzIHRoZSBmdW5jdGlvbiBpbmRleCBz cGFjZSBzaXplIG9mICIsIG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCkpOworICAg ICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0Lm1v ZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpLCAiRWxlbWVudCBzZWN0aW9uJ3MgIiwgZWxl bWVudE51bSwgInRoIGVsZW1lbnQncyAiLCBpbmRleCwgInRoIGluZGV4IGlzICIsIGZ1bmN0aW9u SW5kZXgsICIgd2hpY2ggZXhjZWVkcyB0aGUgZnVuY3Rpb24gaW5kZXggc3BhY2Ugc2l6ZSBvZiAi LCBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSk7CiAKICAgICAgICAg ICAgIGVsZW1lbnQuZnVuY3Rpb25JbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChmdW5jdGlvbkluZGV4 KTsKICAgICAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bU1vZHVsZVBhcnNlci5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBh cnNlci5oCmluZGV4IDk2YzA0ZDQuLmVjYzQ3MzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmgKQEAgLTM2LDcgKzM2LDYgQEAgbmFtZXNwYWNlIEpT QyB7IG5hbWVzcGFjZSBXYXNtIHsKIAogc3RydWN0IE1vZHVsZVBhcnNlclJlc3VsdCB7CiAgICAg c3RkOjp1bmlxdWVfcHRyPE1vZHVsZUluZm9ybWF0aW9uPiBtb2R1bGU7Ci0gICAgRnVuY3Rpb25J bmRleFNwYWNlIGZ1bmN0aW9uSW5kZXhTcGFjZTsKICAgICBWZWN0b3I8RnVuY3Rpb25Mb2NhdGlv bkluQmluYXJ5PiBmdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnk7CiB9OwogCmRpZmYgLS1naXQgYS9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtUGxhbi5jcHAKaW5kZXggYzg1MzFjOC4uZGY1MzQwMiAxMDA2NDQKLS0t IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uY3BwCisrKyBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmNwcApAQCAtNzYsOCArNzYsNiBAQCBib29sIFBs YW46OnBhcnNlQW5kVmFsaWRhdGVNb2R1bGUoKQogICAgICAgICB9CiAgICAgICAgIG1fbW9kdWxl SW5mb3JtYXRpb24gPSBXVEZNb3ZlKHBhcnNlUmVzdWx0LT5tb2R1bGUpOwogICAgICAgICBtX2Z1 bmN0aW9uTG9jYXRpb25JbkJpbmFyeSA9IFdURk1vdmUocGFyc2VSZXN1bHQtPmZ1bmN0aW9uTG9j YXRpb25JbkJpbmFyeSk7Ci0gICAgICAgIG1fZnVuY3Rpb25JbmRleFNwYWNlLnNpemUgPSBwYXJz ZVJlc3VsdC0+ZnVuY3Rpb25JbmRleFNwYWNlLnNpemUoKTsKLSAgICAgICAgbV9mdW5jdGlvbklu ZGV4U3BhY2UuYnVmZmVyID0gcGFyc2VSZXN1bHQtPmZ1bmN0aW9uSW5kZXhTcGFjZS5yZWxlYXNl QnVmZmVyKCk7CiAgICAgfQogCiAgICAgZm9yICh1bnNpZ25lZCBmdW5jdGlvbkluZGV4ID0gMDsg ZnVuY3Rpb25JbmRleCA8IG1fZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5LnNpemUoKTsgKytmdW5j dGlvbkluZGV4KSB7CkBAIC04OSw3ICs4Nyw3IEBAIGJvb2wgUGxhbjo6cGFyc2VBbmRWYWxpZGF0 ZU1vZHVsZSgpCiAgICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9tb2R1 bGVJbmZvcm1hdGlvbi0+aW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXNbZnVuY3Rpb25J bmRleF07CiAgICAgICAgIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlID0gU2lnbmF0dXJlSW5m b3JtYXRpb246OmdldChtX3ZtLCBzaWduYXR1cmVJbmRleCk7CiAKLSAgICAgICAgYXV0byB2YWxp ZGF0aW9uUmVzdWx0ID0gdmFsaWRhdGVGdW5jdGlvbihtX3ZtLCBmdW5jdGlvblN0YXJ0LCBmdW5j dGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZSwgKm1fbW9kdWxlSW5m b3JtYXRpb24pOworICAgICAgICBhdXRvIHZhbGlkYXRpb25SZXN1bHQgPSB2YWxpZGF0ZUZ1bmN0 aW9uKG1fdm0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWduYXR1cmUsICptX21v ZHVsZUluZm9ybWF0aW9uKTsKICAgICAgICAgaWYgKCF2YWxpZGF0aW9uUmVzdWx0KSB7CiAgICAg ICAgICAgICBpZiAodmVyYm9zZSkgewogICAgICAgICAgICAgICAgIGZvciAodW5zaWduZWQgaSA9 IDA7IGkgPCBmdW5jdGlvbkxlbmd0aDsgKytpKQpAQCAtMTI3LDcgKzEyNSw3IEBAIHZvaWQgUGxh bjo6cnVuKCkKICAgICAgICAgcmV0dXJuIHRydWU7CiAgICAgfTsKIAotICAgIGlmICghdHJ5UmVz ZXJ2ZUNhcGFjaXR5KG1fd2FzbVRvSlNTdHVicywgbV9tb2R1bGVJbmZvcm1hdGlvbi0+aW1wb3J0 RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnNpemUoKSwgIiBXZWJBc3NlbWJseSB0byBKYXZhU2Ny aXB0IHN0dWJzIikKKyAgICBpZiAoIXRyeVJlc2VydmVDYXBhY2l0eShtX3dhc21FeGl0U3R1YnMs IG1fbW9kdWxlSW5mb3JtYXRpb24tPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXpl KCksICIgV2ViQXNzZW1ibHkgdG8gSmF2YVNjcmlwdCBzdHVicyIpCiAgICAgICAgIHx8ICF0cnlS ZXNlcnZlQ2FwYWNpdHkobV91bmxpbmtlZFdhc21Ub1dhc21DYWxscywgbV9mdW5jdGlvbkxvY2F0 aW9uSW5CaW5hcnkuc2l6ZSgpLCAiIHVubGlua2VkIFdlYkFzc2VtYmx5IHRvIFdlYkFzc2VtYmx5 IGNhbGxzIikKICAgICAgICAgfHwgIXRyeVJlc2VydmVDYXBhY2l0eShtX3dhc21JbnRlcm5hbEZ1 bmN0aW9ucywgbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgpLCAiIFdlYkFzc2VtYmx5 IGZ1bmN0aW9ucyIpCiAgICAgICAgIHx8ICF0cnlSZXNlcnZlQ2FwYWNpdHkobV9jb21waWxhdGlv bkNvbnRleHRzLCBtX2Z1bmN0aW9uTG9jYXRpb25JbkJpbmFyeS5zaXplKCksICIgY29tcGlsYXRp b24gY29udGV4dHMiKSkKQEAgLTE0MSwxMiArMTM5LDExIEBAIHZvaWQgUGxhbjo6cnVuKCkKICAg ICAgICAgSW1wb3J0KiBpbXBvcnQgPSAmbV9tb2R1bGVJbmZvcm1hdGlvbi0+aW1wb3J0c1tpbXBv cnRJbmRleF07CiAgICAgICAgIGlmIChpbXBvcnQtPmtpbmQgIT0gRXh0ZXJuYWxLaW5kOjpGdW5j dGlvbikKICAgICAgICAgICAgIGNvbnRpbnVlOwotICAgICAgICB1bnNpZ25lZCBpbXBvcnRGdW5j dGlvbkluZGV4ID0gbV93YXNtVG9KU1N0dWJzLnNpemUoKTsKKyAgICAgICAgdW5zaWduZWQgaW1w b3J0RnVuY3Rpb25JbmRleCA9IG1fd2FzbUV4aXRTdHVicy5zaXplKCk7CiAgICAgICAgIGlmICh2 ZXJib3NlKQogICAgICAgICAgICAgZGF0YUxvZ0xuKCJQcm9jZXNzaW5nIGltcG9ydCBmdW5jdGlv biBudW1iZXIgIiwgaW1wb3J0RnVuY3Rpb25JbmRleCwgIjogIiwgaW1wb3J0LT5tb2R1bGUsICI6 ICIsIGltcG9ydC0+ZmllbGQpOwogICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRl eCA9IG1fbW9kdWxlSW5mb3JtYXRpb24tPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5h dChpbXBvcnQtPmtpbmRJbmRleCk7Ci0gICAgICAgIG1fd2FzbVRvSlNTdHVicy51bmNoZWNrZWRB cHBlbmQoaW1wb3J0U3R1YkdlbmVyYXRvcihtX3ZtLCBtX2NhbGxMaW5rSW5mb3MsIHNpZ25hdHVy ZUluZGV4LCBpbXBvcnRGdW5jdGlvbkluZGV4KSk7Ci0gICAgICAgIG1fZnVuY3Rpb25JbmRleFNw YWNlLmJ1ZmZlci5nZXQoKVtpbXBvcnRGdW5jdGlvbkluZGV4XS5jb2RlID0gbV93YXNtVG9KU1N0 dWJzW2ltcG9ydEZ1bmN0aW9uSW5kZXhdLmNvZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpOworICAg ICAgICBtX3dhc21FeGl0U3R1YnMudW5jaGVja2VkQXBwZW5kKGV4aXRTdHViR2VuZXJhdG9yKG1f dm0sIG1fY2FsbExpbmtJbmZvcywgc2lnbmF0dXJlSW5kZXgsIGltcG9ydEZ1bmN0aW9uSW5kZXgp KTsKICAgICB9CiAKICAgICBtX2N1cnJlbnRJbmRleCA9IDA7CkBAIC0xNjcsMTIgKzE2NCwxMiBA QCB2b2lkIFBsYW46OnJ1bigpCiAgICAgICAgICAgICBBU1NFUlQoZnVuY3Rpb25MZW5ndGggPD0g bV9zb3VyY2VMZW5ndGgpOwogICAgICAgICAgICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5k ZXggPSBtX21vZHVsZUluZm9ybWF0aW9uLT5pbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNl c1tmdW5jdGlvbkluZGV4XTsKICAgICAgICAgICAgIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJl ID0gU2lnbmF0dXJlSW5mb3JtYXRpb246OmdldChtX3ZtLCBzaWduYXR1cmVJbmRleCk7Ci0gICAg ICAgICAgICB1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2UgPSBtX3dhc21Ub0pTU3R1YnMuc2l6 ZSgpICsgZnVuY3Rpb25JbmRleDsKLSAgICAgICAgICAgIEFTU0VSVF9VTlVTRUQoZnVuY3Rpb25J bmRleFNwYWNlLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5idWZmZXIuZ2V0KClbZnVuY3Rpb25JbmRl eFNwYWNlXS5zaWduYXR1cmVJbmRleCA9PSBzaWduYXR1cmVJbmRleCk7Ci0gICAgICAgICAgICBB U1NFUlQodmFsaWRhdGVGdW5jdGlvbihtX3ZtLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0 aCwgc2lnbmF0dXJlLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZSwgKm1fbW9kdWxlSW5mb3JtYXRpb24p KTsKKyAgICAgICAgICAgIHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFjZSA9IG1fd2FzbUV4aXRT dHVicy5zaXplKCkgKyBmdW5jdGlvbkluZGV4OworICAgICAgICAgICAgQVNTRVJUX1VOVVNFRChm dW5jdGlvbkluZGV4U3BhY2UsIG1fbW9kdWxlSW5mb3JtYXRpb24tPnNpZ25hdHVyZUluZGV4RnJv bUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4U3BhY2UpID09IHNpZ25hdHVyZUluZGV4 KTsKKyAgICAgICAgICAgIEFTU0VSVCh2YWxpZGF0ZUZ1bmN0aW9uKG1fdm0sIGZ1bmN0aW9uU3Rh cnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWduYXR1cmUsICptX21vZHVsZUluZm9ybWF0aW9uKSk7CiAK ICAgICAgICAgICAgIG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHNbZnVuY3Rpb25JbmRleF0gPSBW ZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4oKTsKLSAgICAgICAgICAgIGF1dG8gcGFyc2VB bmRDb21waWxlUmVzdWx0ID0gcGFyc2VBbmRDb21waWxlKCptX3ZtLCBtX2NvbXBpbGF0aW9uQ29u dGV4dHNbZnVuY3Rpb25JbmRleF0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWdu YXR1cmUsIG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHNbZnVuY3Rpb25JbmRleF0sIG1fZnVuY3Rp b25JbmRleFNwYWNlLCAqbV9tb2R1bGVJbmZvcm1hdGlvbik7CisgICAgICAgICAgICBhdXRvIHBh cnNlQW5kQ29tcGlsZVJlc3VsdCA9IHBhcnNlQW5kQ29tcGlsZSgqbV92bSwgbV9jb21waWxhdGlv bkNvbnRleHRzW2Z1bmN0aW9uSW5kZXhdLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwg c2lnbmF0dXJlLCBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzW2Z1bmN0aW9uSW5kZXhdLCAqbV9t b2R1bGVJbmZvcm1hdGlvbik7CiAKICAgICAgICAgICAgIGlmIChVTkxJS0VMWSghcGFyc2VBbmRD b21waWxlUmVzdWx0KSkgewogICAgICAgICAgICAgICAgIGF1dG8gbG9ja2VyID0gaG9sZExvY2so bV9sb2NrKTsKQEAgLTIyMyw5ICsyMjAsNiBAQCB2b2lkIFBsYW46OnJ1bigpCiAgICAgICAgICAg ICAgICAgICAgIHN0ZDo6bWFrZV91bmlxdWU8QjM6OkNvbXBpbGF0aW9uPihGSU5BTElaRV9DT0RF KGxpbmtCdWZmZXIsICgiV2FzbSBKUyBlbnRyeXBvaW50IikpLCBXVEZNb3ZlKGNvbnRleHQuanNF bnRyeXBvaW50Qnlwcm9kdWN0cykpOwogICAgICAgICAgICAgfQogICAgICAgICB9Ci0KLSAgICAg ICAgdW5zaWduZWQgZnVuY3Rpb25JbmRleFNwYWNlID0gbV93YXNtVG9KU1N0dWJzLnNpemUoKSAr IGZ1bmN0aW9uSW5kZXg7Ci0gICAgICAgIG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQo KVtmdW5jdGlvbkluZGV4U3BhY2VdLmNvZGUgPSBtX3dhc21JbnRlcm5hbEZ1bmN0aW9uc1tmdW5j dGlvbkluZGV4XS0+d2FzbUVudHJ5cG9pbnQuY29tcGlsYXRpb24tPmNvZGUoKS5leGVjdXRhYmxl QWRkcmVzcygpOwogICAgIH0KIAogICAgIGlmICh2ZXJib3NlIHx8IE9wdGlvbnM6OnJlcG9ydENv bXBpbGVUaW1lcygpKSB7CkBAIC0yMzUsOCArMjI5LDE5IEBAIHZvaWQgUGxhbjo6cnVuKCkKIAog ICAgIC8vIFBhdGNoIHRoZSBjYWxsIHNpdGVzIGZvciBlYWNoIFdlYkFzc2VtYmx5IGZ1bmN0aW9u LgogICAgIGZvciAoYXV0byYgdW5saW5rZWQgOiBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzKSB7 Ci0gICAgICAgIGZvciAoYXV0byYgY2FsbCA6IHVubGlua2VkKQotICAgICAgICAgICAgTWFjcm9B c3NlbWJsZXI6OnJlcGF0Y2hDYWxsKGNhbGwuY2FsbExvY2F0aW9uLCBDb2RlTG9jYXRpb25MYWJl bChtX2Z1bmN0aW9uSW5kZXhTcGFjZS5idWZmZXIuZ2V0KClbY2FsbC5mdW5jdGlvbkluZGV4XS5j b2RlKSk7CisgICAgICAgIGZvciAoYXV0byYgY2FsbCA6IHVubGlua2VkKSB7CisgICAgICAgICAg ICB2b2lkKiBleGVjdXRhYmxlQWRkcmVzczsKKyAgICAgICAgICAgIGlmIChtX21vZHVsZUluZm9y bWF0aW9uLT5pc0ltcG9ydGVkRnVuY3Rpb25Gcm9tRnVuY3Rpb25JbmRleFNwYWNlKGNhbGwuZnVu Y3Rpb25JbmRleCkpIHsKKyAgICAgICAgICAgICAgICAvLyBGSVhNRSBpbXBvcnRzIGNvdWxkIGhh dmUgYmVlbiBsaW5rZWQgaW4gQjMsIGluc3RlYWQgb2YgZ2VuZXJhdGluZyBhIHBhdGNocG9pbnQu IFRoaXMgY29uZGl0aW9uIHNob3VsZCBiZSByZXBsYWNlZCBieSBhIFJFTEVBU0VfQVNTRVJULiBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY2NDYyCisgICAgICAgICAg ICAgICAgZXhlY3V0YWJsZUFkZHJlc3MgPSBjYWxsLnRvSlMKKyAgICAgICAgICAgICAgICAgICAg PyBtX3dhc21FeGl0U3R1YnMuYXQoY2FsbC5mdW5jdGlvbkluZGV4KS53YXNtVG9KUy5jb2RlKCku ZXhlY3V0YWJsZUFkZHJlc3MoKQorICAgICAgICAgICAgICAgICAgICA6IG1fd2FzbUV4aXRTdHVi cy5hdChjYWxsLmZ1bmN0aW9uSW5kZXgpLndhc21Ub1dhc20uY29kZSgpLmV4ZWN1dGFibGVBZGRy ZXNzKCk7CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIEFTU0VSVCghY2Fs bC50b0pTKTsKKyAgICAgICAgICAgICAgICBleGVjdXRhYmxlQWRkcmVzcyA9IG1fd2FzbUludGVy bmFsRnVuY3Rpb25zLmF0KGNhbGwuZnVuY3Rpb25JbmRleCAtIG1fd2FzbUV4aXRTdHVicy5zaXpl KCkpLT53YXNtRW50cnlwb2ludC5jb21waWxhdGlvbi0+Y29kZSgpLmV4ZWN1dGFibGVBZGRyZXNz KCk7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBNYWNyb0Fzc2VtYmxlcjo6cmVwYXRjaENh bGwoY2FsbC5jYWxsTG9jYXRpb24sIENvZGVMb2NhdGlvbkxhYmVsKGV4ZWN1dGFibGVBZGRyZXNz KSk7CisgICAgICAgIH0KICAgICB9CiAKICAgICBtX2ZhaWxlZCA9IGZhbHNlOwpkaWZmIC0tZ2l0 IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uaCBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21QbGFuLmgKaW5kZXggM2JiMDFjOC4uODMxNTk2NSAxMDA2NDQKLS0t IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uaAorKysgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5oCkBAIC04NiwyNiArODYsMTkgQEAgcHVibGljOgog ICAgICAgICByZXR1cm4gV1RGTW92ZShtX2NhbGxMaW5rSW5mb3MpOwogICAgIH0KIAotICAgIFZl Y3RvcjxXYXNtVG9KU1N0dWI+JiYgdGFrZVdhc21Ub0pTU3R1YnMoKQorICAgIFZlY3RvcjxXYXNt RXhpdFN0dWJzPiYmIHRha2VXYXNtRXhpdFN0dWJzKCkKICAgICB7CiAgICAgICAgIFJFTEVBU0Vf QVNTRVJUKCFmYWlsZWQoKSk7Ci0gICAgICAgIHJldHVybiBXVEZNb3ZlKG1fd2FzbVRvSlNTdHVi cyk7Ci0gICAgfQotCi0gICAgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiYgdGFrZUZ1bmN0 aW9uSW5kZXhTcGFjZSgpCi0gICAgewotICAgICAgICBSRUxFQVNFX0FTU0VSVCghZmFpbGVkKCkp OwotICAgICAgICByZXR1cm4gV1RGTW92ZShtX2Z1bmN0aW9uSW5kZXhTcGFjZSk7CisgICAgICAg IHJldHVybiBXVEZNb3ZlKG1fd2FzbUV4aXRTdHVicyk7CiAgICAgfQogCiBwcml2YXRlOgogICAg IHN0ZDo6dW5pcXVlX3B0cjxNb2R1bGVJbmZvcm1hdGlvbj4gbV9tb2R1bGVJbmZvcm1hdGlvbjsK ICAgICBWZWN0b3I8RnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5PiBtX2Z1bmN0aW9uTG9jYXRpb25J bkJpbmFyeTsKICAgICBCYWc8Q2FsbExpbmtJbmZvPiBtX2NhbGxMaW5rSW5mb3M7Ci0gICAgVmVj dG9yPFdhc21Ub0pTU3R1Yj4gbV93YXNtVG9KU1N0dWJzOworICAgIFZlY3RvcjxXYXNtRXhpdFN0 dWJzPiBtX3dhc21FeGl0U3R1YnM7CiAgICAgVmVjdG9yPHN0ZDo6dW5pcXVlX3B0cjxXYXNtSW50 ZXJuYWxGdW5jdGlvbj4+IG1fd2FzbUludGVybmFsRnVuY3Rpb25zOwogICAgIFZlY3RvcjxDb21w aWxhdGlvbkNvbnRleHQ+IG1fY29tcGlsYXRpb25Db250ZXh0czsKLSAgICBJbW11dGFibGVGdW5j dGlvbkluZGV4U3BhY2UgbV9mdW5jdGlvbkluZGV4U3BhY2U7CiAKICAgICBWTSogbV92bTsKICAg ICBWZWN0b3I8VmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+PiBtX3VubGlua2VkV2FzbVRv V2FzbUNhbGxzOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVNp Z25hdHVyZS5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmNw cAppbmRleCA2ZDViMWY2Li45OTdiZDA2IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtU2lnbmF0dXJlLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtU2lnbmF0dXJlLmNwcApAQCAtNDEsNiArNDEsMTkgQEAgY29uc3QgYm9vbCB2ZXJib3Nl ID0gZmFsc2U7CiAKIGNvbnN0IGNvbnN0ZXhwciBTaWduYXR1cmVJbmRleCBTaWduYXR1cmU6Omlu dmFsaWRJbmRleDsKIAorU3RyaW5nIFNpZ25hdHVyZTo6dG9TdHJpbmcoKSBjb25zdAoreworICAg IFN0cmluZyByZXN1bHQobWFrZVN0cmluZyhyZXR1cm5UeXBlKCkpKTsKKyAgICByZXN1bHQuYXBw ZW5kKCIgKCIpOworICAgIGZvciAoU2lnbmF0dXJlQXJnQ291bnQgYXJnID0gMDsgYXJnIDwgYXJn dW1lbnRDb3VudCgpOyArK2FyZykgeworICAgICAgICBpZiAoYXJnKQorICAgICAgICAgICAgcmVz dWx0LmFwcGVuZCgiLCAiKTsKKyAgICAgICAgcmVzdWx0LmFwcGVuZChtYWtlU3RyaW5nKGFyZ3Vt ZW50KGFyZykpKTsKKyAgICB9CisgICAgcmVzdWx0LmFwcGVuZCgnKScpOworICAgIHJldHVybiBy ZXN1bHQ7Cit9CisKIHZvaWQgU2lnbmF0dXJlOjpkdW1wKFByaW50U3RyZWFtJiBvdXQpIGNvbnN0 CiB7CiAgICAgb3V0LnByaW50KG1ha2VTdHJpbmcocmV0dXJuVHlwZSgpKSwgIiAoIik7CmRpZmYg LS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmggYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmgKaW5kZXggMGQ2YzdiNS4uNGQ0 M2ZmYyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVy ZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuaApAQCAt ODIsNiArODIsNyBAQCBwdWJsaWM6CiAgICAgfQogICAgIFR5cGUgYXJndW1lbnQoU2lnbmF0dXJl QXJnQ291bnQgaSkgY29uc3QgeyByZXR1cm4gY29uc3RfY2FzdDxTaWduYXR1cmUqPih0aGlzKS0+ YXJndW1lbnQoaSk7IH0KIAorICAgIFdURjo6U3RyaW5nIHRvU3RyaW5nKCkgY29uc3Q7CiAgICAg dm9pZCBkdW1wKFdURjo6UHJpbnRTdHJlYW0mIG91dCkgY29uc3Q7CiAgICAgYm9vbCBvcGVyYXRv cj09KGNvbnN0IFNpZ25hdHVyZSYgcmhzKSBjb25zdAogICAgIHsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwCmluZGV4IDI2MTM3MGIuLmE2ODc0ODEgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5jcHAKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmNwcApAQCAtMzYyLDEwICsz NjIsMTAgQEAgdm9pZCBWYWxpZGF0ZTo6ZHVtcChjb25zdCBWZWN0b3I8Q29udHJvbEVudHJ5PiYs IGNvbnN0IEV4cHJlc3Npb25MaXN0JikKICAgICAvLyBUaGluayBvZiB0aGlzIGFzIHBlbmFuY2Ug Zm9yIHRoZSBzaW4gb2YgYmFkIGVycm9yIG1lc3NhZ2VzLgogfQogCi1FeHBlY3RlZDx2b2lkLCBT dHJpbmc+IHZhbGlkYXRlRnVuY3Rpb24oVk0qIHZtLCBjb25zdCB1aW50OF90KiBzb3VyY2UsIHNp emVfdCBsZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBjb25zdCBJbW11dGFibGVG dW5jdGlvbkluZGV4U3BhY2UmIGZ1bmN0aW9uSW5kZXhTcGFjZSwgY29uc3QgTW9kdWxlSW5mb3Jt YXRpb24mIG1vZHVsZSkKK0V4cGVjdGVkPHZvaWQsIFN0cmluZz4gdmFsaWRhdGVGdW5jdGlvbihW TSogdm0sIGNvbnN0IHVpbnQ4X3QqIHNvdXJjZSwgc2l6ZV90IGxlbmd0aCwgY29uc3QgU2lnbmF0 dXJlKiBzaWduYXR1cmUsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBtb2R1bGUpCiB7CiAgICAg VmFsaWRhdGUgY29udGV4dChtb2R1bGUpOwotICAgIEZ1bmN0aW9uUGFyc2VyPFZhbGlkYXRlPiB2 YWxpZGF0b3Iodm0sIGNvbnRleHQsIHNvdXJjZSwgbGVuZ3RoLCBzaWduYXR1cmUsIGZ1bmN0aW9u SW5kZXhTcGFjZSwgbW9kdWxlKTsKKyAgICBGdW5jdGlvblBhcnNlcjxWYWxpZGF0ZT4gdmFsaWRh dG9yKHZtLCBjb250ZXh0LCBzb3VyY2UsIGxlbmd0aCwgc2lnbmF0dXJlLCBtb2R1bGUpOwogICAg IFdBU01fRkFJTF9JRl9IRUxQRVJfRkFJTFModmFsaWRhdG9yLnBhcnNlKCkpOwogICAgIHJldHVy biB7IH07CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFs aWRhdGUuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5oCmluZGV4 IDE0ODIxZjIuLmViMWFkOGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21WYWxpZGF0ZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxp ZGF0ZS5oCkBAIC0zNiw3ICszNiw3IEBAIGNsYXNzIFZNOwogCiBuYW1lc3BhY2UgV2FzbSB7CiAK LUV4cGVjdGVkPHZvaWQsIFN0cmluZz4gdmFsaWRhdGVGdW5jdGlvbihWTSosIGNvbnN0IHVpbnQ4 X3QqLCBzaXplX3QsIGNvbnN0IFNpZ25hdHVyZSosIGNvbnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5k ZXhTcGFjZSYsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJik7CitFeHBlY3RlZDx2b2lkLCBTdHJp bmc+IHZhbGlkYXRlRnVuY3Rpb24oVk0qLCBjb25zdCB1aW50OF90Kiwgc2l6ZV90LCBjb25zdCBT aWduYXR1cmUqLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYpOwogCiB9IH0gLy8gbmFtZXNwYWNl IEpTQzo6V2FzbQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9K U1dlYkFzc2VtYmx5SW5zdGFuY2UuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pT V2ViQXNzZW1ibHlJbnN0YW5jZS5oCmluZGV4IGYzNGIwNTIuLjk5YTJjOTAgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5oCisr KyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5o CkBAIC04Niw4ICs4NiwxMSBAQCBwdWJsaWM6CiAgICAgICAgIHJldHVybiBvZmZzZXRPZkltcG9y dEZ1bmN0aW9ucygpICsgc2l6ZW9mKFdyaXRlQmFycmllcjxKU0NlbGw+KSAqIGlkeDsKICAgICB9 CiAKKyAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mTWVtb3J5KCkgeyByZXR1cm4gT0JKRUNU X09GRlNFVE9GKEpTV2ViQXNzZW1ibHlJbnN0YW5jZSwgbV9tZW1vcnkpOyB9CiAgICAgc3RhdGlj IHB0cmRpZmZfdCBvZmZzZXRPZlRhYmxlKCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKEpTV2Vi QXNzZW1ibHlJbnN0YW5jZSwgbV90YWJsZSk7IH0KICAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNl dE9mR2xvYmFscygpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFzc2VtYmx5SW5zdGFu Y2UsIG1fZ2xvYmFscyk7IH0KKyAgICBzdGF0aWMgc2l6ZV90IG9mZnNldE9mSW1wb3J0RnVuY3Rp b25zKCkgeyByZXR1cm4gV1RGOjpyb3VuZFVwVG9NdWx0aXBsZU9mPHNpemVvZihXcml0ZUJhcnJp ZXI8SlNDZWxsPik+KHNpemVvZihKU1dlYkFzc2VtYmx5SW5zdGFuY2UpKTsgfQorICAgIHN0YXRp YyBzaXplX3Qgb2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbihzaXplX3QgaW1wb3J0RnVuY3Rpb25OdW0p IHsgcmV0dXJuIG9mZnNldE9mSW1wb3J0RnVuY3Rpb25zKCkgKyBpbXBvcnRGdW5jdGlvbk51bSAq IHNpemVvZihzaXplb2YoV3JpdGVCYXJyaWVyPEpTQ2VsbD4pKTsgfQogCiBwcm90ZWN0ZWQ6CiAg ICAgSlNXZWJBc3NlbWJseUluc3RhbmNlKFZNJiwgU3RydWN0dXJlKiwgdW5zaWduZWQgbnVtSW1w b3J0RnVuY3Rpb25zKTsKQEAgLTk1LDExICs5OCw2IEBAIHByb3RlY3RlZDoKICAgICBzdGF0aWMg dm9pZCBkZXN0cm95KEpTQ2VsbCopOwogICAgIHN0YXRpYyB2b2lkIHZpc2l0Q2hpbGRyZW4oSlND ZWxsKiwgU2xvdFZpc2l0b3ImKTsKIAotICAgIHN0YXRpYyBzaXplX3Qgb2Zmc2V0T2ZJbXBvcnRG dW5jdGlvbnMoKQotICAgIHsKLSAgICAgICAgcmV0dXJuIFdURjo6cm91bmRVcFRvTXVsdGlwbGVP ZjxzaXplb2YoV3JpdGVCYXJyaWVyPEpTQ2VsbD4pPihzaXplb2YoSlNXZWJBc3NlbWJseUluc3Rh bmNlKSk7Ci0gICAgfQotCiAgICAgc3RhdGljIHNpemVfdCBhbGxvY2F0aW9uU2l6ZSh1bnNpZ25l ZCBudW1JbXBvcnRGdW5jdGlvbnMpCiAgICAgewogICAgICAgICByZXR1cm4gb2Zmc2V0T2ZJbXBv cnRGdW5jdGlvbnMoKSArIHNpemVvZihXcml0ZUJhcnJpZXI8SlNDZWxsPikgKiBudW1JbXBvcnRG dW5jdGlvbnM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dl YkFzc2VtYmx5TWVtb3J5LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2Vi QXNzZW1ibHlNZW1vcnkuY3BwCmluZGV4IGJjNDQ5YTguLjQ1MWJmNzkgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuY3BwCisrKyBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuY3BwCkBA IC0zNyw5ICszNyw5IEBAIG5hbWVzcGFjZSBKU0MgewogCiBjb25zdCBDbGFzc0luZm8gSlNXZWJB c3NlbWJseU1lbW9yeTo6c19pbmZvID0geyAiV2ViQXNzZW1ibHkuTWVtb3J5IiwgJkJhc2U6OnNf aW5mbywgMCwgQ1JFQVRFX01FVEhPRF9UQUJMRShKU1dlYkFzc2VtYmx5TWVtb3J5KSB9OwogCi1K U1dlYkFzc2VtYmx5TWVtb3J5KiBKU1dlYkFzc2VtYmx5TWVtb3J5OjpjcmVhdGUoVk0mIHZtLCBT dHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1lbW9yeT4mJiBtZW1v cnkpCitKU1dlYkFzc2VtYmx5TWVtb3J5KiBKU1dlYkFzc2VtYmx5TWVtb3J5OjpjcmVhdGUoVk0m IHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgV2FzbTo6TWVtb3J5JiYgbWVtb3J5KQogewotICAg IGF1dG8qIGluc3RhbmNlID0gbmV3IChOb3ROdWxsLCBhbGxvY2F0ZUNlbGw8SlNXZWJBc3NlbWJs eU1lbW9yeT4odm0uaGVhcCkpIEpTV2ViQXNzZW1ibHlNZW1vcnkodm0sIHN0cnVjdHVyZSwgV1RG TW92ZShtZW1vcnkpKTsKKyAgICBhdXRvKiBpbnN0YW5jZSA9IG5ldyAoTm90TnVsbCwgYWxsb2Nh dGVDZWxsPEpTV2ViQXNzZW1ibHlNZW1vcnk+KHZtLmhlYXApKSBKU1dlYkFzc2VtYmx5TWVtb3J5 KHZtLCBzdHJ1Y3R1cmUsIHN0ZDo6Zm9yd2FyZDxXYXNtOjpNZW1vcnk+KG1lbW9yeSkpOwogICAg IGluc3RhbmNlLT5maW5pc2hDcmVhdGlvbih2bSk7CiAgICAgcmV0dXJuIGluc3RhbmNlOwogfQpA QCAtNDksNyArNDksNyBAQCBTdHJ1Y3R1cmUqIEpTV2ViQXNzZW1ibHlNZW1vcnk6OmNyZWF0ZVN0 cnVjdHVyZShWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYgogICAgIHJldHVybiBTdHJ1 Y3R1cmU6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LCBwcm90b3R5cGUsIFR5cGVJbmZvKE9iamVj dFR5cGUsIFN0cnVjdHVyZUZsYWdzKSwgaW5mbygpKTsKIH0KIAotSlNXZWJBc3NlbWJseU1lbW9y eTo6SlNXZWJBc3NlbWJseU1lbW9yeShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBzdGQ6 OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiYmIG1lbW9yeSkKK0pTV2ViQXNzZW1ibHlNZW1vcnk6 OkpTV2ViQXNzZW1ibHlNZW1vcnkoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgV2FzbTo6 TWVtb3J5JiYgbWVtb3J5KQogICAgIDogQmFzZSh2bSwgc3RydWN0dXJlKQogICAgICwgbV9tZW1v cnkoV1RGTW92ZShtZW1vcnkpKQogewpAQCAtNjMsNyArNjMsNyBAQCBKU0FycmF5QnVmZmVyKiBK U1dlYkFzc2VtYmx5TWVtb3J5OjpidWZmZXIoVk0mIHZtLCBKU0dsb2JhbE9iamVjdCogZ2xvYmFs T2JqZWN0KQogICAgIGF1dG8gZGVzdHJ1Y3RvciA9IFtdICh2b2lkKikgewogICAgICAgICAvLyBX ZSBkb24ndCBuZWVkIHRvIGRvIGFueXRoaW5nIGhlcmUgdG8gZGVzdHJveSB0aGUgbWVtb3J5Lgog ICAgICAgICAvLyBUaGUgQXJyYXlCdWZmZXIgYmFja2luZyB0aGUgSlNBcnJheUJ1ZmZlciBpcyBv bmx5IG93bmVkIGJ5IHVzLAotICAgICAgICAvLyBzbyB3ZSBndWFyYW50ZWUgaXRzIGxpZmVjeWxj ZS4KKyAgICAgICAgLy8gc28gd2UgZ3VhcmFudGVlIGl0cyBsaWZlY3ljbGUuCiAgICAgfTsKICAg ICBtX2J1ZmZlciA9IEFycmF5QnVmZmVyOjpjcmVhdGVGcm9tQnl0ZXMobWVtb3J5KCktPm1lbW9y eSgpLCBtZW1vcnkoKS0+c2l6ZSgpLCBXVEZNb3ZlKGRlc3RydWN0b3IpKTsKICAgICBtX2J1ZmZl cldyYXBwZXIuc2V0KHZtLCB0aGlzLCBKU0FycmF5QnVmZmVyOjpjcmVhdGUodm0sIGdsb2JhbE9i amVjdC0+bV9hcnJheUJ1ZmZlclN0cnVjdHVyZS5nZXQoKSwgbV9idWZmZXIuZ2V0KCkpKTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1v cnkuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnku aAppbmRleCAxZDQzYzk1Li42YzI2NGM4IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5oCkBAIC00MSwyMSArNDEsMjQgQEAgY2xh c3MgSlNXZWJBc3NlbWJseU1lbW9yeSA6IHB1YmxpYyBKU0Rlc3RydWN0aWJsZU9iamVjdCB7CiBw dWJsaWM6CiAgICAgdHlwZWRlZiBKU0Rlc3RydWN0aWJsZU9iamVjdCBCYXNlOwogCi0gICAgc3Rh dGljIEpTV2ViQXNzZW1ibHlNZW1vcnkqIGNyZWF0ZShWTSYsIFN0cnVjdHVyZSosIHN0ZDo6dW5p cXVlX3B0cjxXYXNtOjpNZW1vcnk+JiYpOworICAgIHN0YXRpYyBKU1dlYkFzc2VtYmx5TWVtb3J5 KiBjcmVhdGUoVk0mLCBTdHJ1Y3R1cmUqLCBXYXNtOjpNZW1vcnkmJik7CiAgICAgc3RhdGljIFN0 cnVjdHVyZSogY3JlYXRlU3RydWN0dXJlKFZNJiwgSlNHbG9iYWxPYmplY3QqLCBKU1ZhbHVlKTsK IAogICAgIERFQ0xBUkVfSU5GTzsKIAotICAgIFdhc206Ok1lbW9yeSogbWVtb3J5KCkgeyByZXR1 cm4gbV9tZW1vcnkuZ2V0KCk7IH0KKyAgICBXYXNtOjpNZW1vcnkqIG1lbW9yeSgpIHsgcmV0dXJu ICZtX21lbW9yeTsgfQogICAgIEpTQXJyYXlCdWZmZXIqIGJ1ZmZlcihWTSYgdm0sIEpTR2xvYmFs T2JqZWN0Kik7CiAKKyAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mTWVtb3J5KCkgeyByZXR1 cm4gT0JKRUNUX09GRlNFVE9GKEpTV2ViQXNzZW1ibHlNZW1vcnksIG1fbWVtb3J5KSArIFdhc206 Ok1lbW9yeTo6b2Zmc2V0T2ZNZW1vcnkoKTsgfQorICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0 T2ZTaXplKCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKEpTV2ViQXNzZW1ibHlNZW1vcnksIG1f bWVtb3J5KSArIFdhc206Ok1lbW9yeTo6b2Zmc2V0T2ZTaXplKCk7IH0KKwogcHJvdGVjdGVkOgot ICAgIEpTV2ViQXNzZW1ibHlNZW1vcnkoVk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8 V2FzbTo6TWVtb3J5PiYmKTsKKyAgICBKU1dlYkFzc2VtYmx5TWVtb3J5KFZNJiwgU3RydWN0dXJl KiwgV2FzbTo6TWVtb3J5JiYpOwogICAgIHZvaWQgZmluaXNoQ3JlYXRpb24oVk0mKTsKICAgICBz dGF0aWMgdm9pZCBkZXN0cm95KEpTQ2VsbCopOwogICAgIHN0YXRpYyB2b2lkIHZpc2l0Q2hpbGRy ZW4oSlNDZWxsKiwgU2xvdFZpc2l0b3ImKTsKIAotICAgIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpN ZW1vcnk+IG1fbWVtb3J5OworICAgIFdhc206Ok1lbW9yeSBtX21lbW9yeTsKICAgICBXcml0ZUJh cnJpZXI8SlNBcnJheUJ1ZmZlcj4gbV9idWZmZXJXcmFwcGVyOwogICAgIFJlZlB0cjxBcnJheUJ1 ZmZlcj4gbV9idWZmZXI7CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmNwcAppbmRleCBkNjUyNGM1Li5mYTBlODU5IDEwMDY0 NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxl LmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9k dWxlLmNwcApAQCAtMzgsOSArMzgsOSBAQCBuYW1lc3BhY2UgSlNDIHsKIAogY29uc3QgQ2xhc3NJ bmZvIEpTV2ViQXNzZW1ibHlNb2R1bGU6OnNfaW5mbyA9IHsgIldlYkFzc2VtYmx5Lk1vZHVsZSIs ICZCYXNlOjpzX2luZm8sIG51bGxwdHIsIENSRUFURV9NRVRIT0RfVEFCTEUoSlNXZWJBc3NlbWJs eU1vZHVsZSkgfTsKIAotSlNXZWJBc3NlbWJseU1vZHVsZSogSlNXZWJBc3NlbWJseU1vZHVsZTo6 Y3JlYXRlKFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0cjxXYXNt OjpNb2R1bGVJbmZvcm1hdGlvbj4mJiBtb2R1bGVJbmZvcm1hdGlvbiwgQmFnPENhbGxMaW5rSW5m bz4mJiBjYWxsTGlua0luZm9zLCBWZWN0b3I8V2FzbTo6V2FzbVRvSlNTdHViPiYmIHdhc21Ub0pT U3R1YnMsIFdhc206OkltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmIGZ1bmN0aW9uSW5kZXhT cGFjZSwgU3ltYm9sVGFibGUqIGV4cG9ydFN5bWJvbFRhYmxlLCB1bnNpZ25lZCBjYWxsZWVDb3Vu dCkKK0pTV2ViQXNzZW1ibHlNb2R1bGUqIEpTV2ViQXNzZW1ibHlNb2R1bGU6OmNyZWF0ZShWTSYg dm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5m b3JtYXRpb24+JiYgbW9kdWxlSW5mb3JtYXRpb24sIEJhZzxDYWxsTGlua0luZm8+JiYgY2FsbExp bmtJbmZvcywgVmVjdG9yPFdhc206Oldhc21FeGl0U3R1YnM+JiYgd2FzbUV4aXRTdHVicywgU3lt Ym9sVGFibGUqIGV4cG9ydFN5bWJvbFRhYmxlLCB1bnNpZ25lZCBjYWxsZWVDb3VudCkKIHsKLSAg ICBhdXRvKiBpbnN0YW5jZSA9IG5ldyAoTm90TnVsbCwgYWxsb2NhdGVDZWxsPEpTV2ViQXNzZW1i bHlNb2R1bGU+KHZtLmhlYXAsIGFsbG9jYXRpb25TaXplKGNhbGxlZUNvdW50KSkpIEpTV2ViQXNz ZW1ibHlNb2R1bGUodm0sIHN0cnVjdHVyZSwgc3RkOjpmb3J3YXJkPHN0ZDo6dW5pcXVlX3B0cjxX YXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4+KG1vZHVsZUluZm9ybWF0aW9uKSwgc3RkOjpmb3J3YXJk PEJhZzxDYWxsTGlua0luZm8+PihjYWxsTGlua0luZm9zKSwgc3RkOjpmb3J3YXJkPFZlY3RvcjxX YXNtOjpXYXNtVG9KU1N0dWI+Pih3YXNtVG9KU1N0dWJzKSwgc3RkOjpmb3J3YXJkPFdhc206Oklt bXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZT4oZnVuY3Rpb25JbmRleFNwYWNlKSwgY2FsbGVlQ291 bnQpOworICAgIGF1dG8qIGluc3RhbmNlID0gbmV3IChOb3ROdWxsLCBhbGxvY2F0ZUNlbGw8SlNX ZWJBc3NlbWJseU1vZHVsZT4odm0uaGVhcCwgYWxsb2NhdGlvblNpemUoY2FsbGVlQ291bnQpKSkg SlNXZWJBc3NlbWJseU1vZHVsZSh2bSwgc3RydWN0dXJlLCBzdGQ6OmZvcndhcmQ8c3RkOjp1bmlx dWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPj4obW9kdWxlSW5mb3JtYXRpb24pLCBzdGQ6 OmZvcndhcmQ8QmFnPENhbGxMaW5rSW5mbz4+KGNhbGxMaW5rSW5mb3MpLCBzdGQ6OmZvcndhcmQ8 VmVjdG9yPFdhc206Oldhc21FeGl0U3R1YnM+Pih3YXNtRXhpdFN0dWJzKSwgY2FsbGVlQ291bnQp OwogICAgIGluc3RhbmNlLT5maW5pc2hDcmVhdGlvbih2bSwgZXhwb3J0U3ltYm9sVGFibGUpOwog ICAgIHJldHVybiBpbnN0YW5jZTsKIH0KQEAgLTUwLDEyICs1MCwxMSBAQCBTdHJ1Y3R1cmUqIEpT V2ViQXNzZW1ibHlNb2R1bGU6OmNyZWF0ZVN0cnVjdHVyZShWTSYgdm0sIEpTR2xvYmFsT2JqZWN0 KiBnbG9iYWxPYgogICAgIHJldHVybiBTdHJ1Y3R1cmU6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0 LCBwcm90b3R5cGUsIFR5cGVJbmZvKE9iamVjdFR5cGUsIFN0cnVjdHVyZUZsYWdzKSwgaW5mbygp KTsKIH0KIAotSlNXZWJBc3NlbWJseU1vZHVsZTo6SlNXZWJBc3NlbWJseU1vZHVsZShWTSYgdm0s IFN0cnVjdHVyZSogc3RydWN0dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3Jt YXRpb24+JiYgbW9kdWxlSW5mb3JtYXRpb24sIEJhZzxDYWxsTGlua0luZm8+JiYgY2FsbExpbmtJ bmZvcywgVmVjdG9yPFdhc206Oldhc21Ub0pTU3R1Yj4mJiB3YXNtVG9KU1N0dWJzLCBXYXNtOjpJ bW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmJiBmdW5jdGlvbkluZGV4U3BhY2UsIHVuc2lnbmVk IGNhbGxlZUNvdW50KQorSlNXZWJBc3NlbWJseU1vZHVsZTo6SlNXZWJBc3NlbWJseU1vZHVsZShW TSYgdm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxl SW5mb3JtYXRpb24+JiYgbW9kdWxlSW5mb3JtYXRpb24sIEJhZzxDYWxsTGlua0luZm8+JiYgY2Fs bExpbmtJbmZvcywgVmVjdG9yPFdhc206Oldhc21FeGl0U3R1YnM+JiYgd2FzbUV4aXRTdHVicywg dW5zaWduZWQgY2FsbGVlQ291bnQpCiAgICAgOiBCYXNlKHZtLCBzdHJ1Y3R1cmUpCiAgICAgLCBt X21vZHVsZUluZm9ybWF0aW9uKFdURk1vdmUobW9kdWxlSW5mb3JtYXRpb24pKQogICAgICwgbV9j YWxsTGlua0luZm9zKFdURk1vdmUoY2FsbExpbmtJbmZvcykpCi0gICAgLCBtX3dhc21Ub0pTU3R1 YnMoV1RGTW92ZSh3YXNtVG9KU1N0dWJzKSkKLSAgICAsIG1fZnVuY3Rpb25JbmRleFNwYWNlKFdU Rk1vdmUoZnVuY3Rpb25JbmRleFNwYWNlKSkKKyAgICAsIG1fd2FzbUV4aXRTdHVicyhXVEZNb3Zl KHdhc21FeGl0U3R1YnMpKQogICAgICwgbV9jYWxsZWVDb3VudChjYWxsZWVDb3VudCkKIHsKICAg ICBtZW1zZXQoY2FsbGVlcygpLCAwLCBtX2NhbGxlZUNvdW50ICogc2l6ZW9mKFdyaXRlQmFycmll cjxKU1dlYkFzc2VtYmx5Q2FsbGVlPikgKiAyKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUuaCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUuaAppbmRleCAyZTExMzYxLi5iZjUyZTJi IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5 TW9kdWxlLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJs eU1vZHVsZS5oCkBAIC00MywxOSArNDMsMTggQEAgY2xhc3MgSlNXZWJBc3NlbWJseU1vZHVsZSA6 IHB1YmxpYyBKU0Rlc3RydWN0aWJsZU9iamVjdCB7CiBwdWJsaWM6CiAgICAgdHlwZWRlZiBKU0Rl c3RydWN0aWJsZU9iamVjdCBCYXNlOwogCi0gICAgc3RhdGljIEpTV2ViQXNzZW1ibHlNb2R1bGUq IGNyZWF0ZShWTSYsIFN0cnVjdHVyZSosIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZv cm1hdGlvbj4mJiwgQmFnPENhbGxMaW5rSW5mbz4mJiwgVmVjdG9yPFdhc206Oldhc21Ub0pTU3R1 Yj4mJiwgV2FzbTo6SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiYsIFN5bWJvbFRhYmxlKiwg dW5zaWduZWQpOworICAgIHN0YXRpYyBKU1dlYkFzc2VtYmx5TW9kdWxlKiBjcmVhdGUoVk0mLCBT dHJ1Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYsIEJh ZzxDYWxsTGlua0luZm8+JiYsIFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPiYmLCBTeW1ib2xU YWJsZSosIHVuc2lnbmVkKTsKICAgICBzdGF0aWMgU3RydWN0dXJlKiBjcmVhdGVTdHJ1Y3R1cmUo Vk0mLCBKU0dsb2JhbE9iamVjdCosIEpTVmFsdWUpOwogCiAgICAgREVDTEFSRV9JTkZPOwogCiAg ICAgY29uc3QgV2FzbTo6TW9kdWxlSW5mb3JtYXRpb24mIG1vZHVsZUluZm9ybWF0aW9uKCkgY29u c3QgeyByZXR1cm4gKm1fbW9kdWxlSW5mb3JtYXRpb24uZ2V0KCk7IH0KICAgICBTeW1ib2xUYWJs ZSogZXhwb3J0U3ltYm9sVGFibGUoKSBjb25zdCB7IHJldHVybiBtX2V4cG9ydFN5bWJvbFRhYmxl LmdldCgpOyB9Ci0gICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlRm9yRnVuY3Rpb25J bmRleFNwYWNlKHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFjZSkgY29uc3QKKyAgICBXYXNtOjpT aWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2UodW5zaWdu ZWQgZnVuY3Rpb25JbmRleFNwYWNlKSBjb25zdAogICAgIHsKLSAgICAgICAgQVNTRVJUKGZ1bmN0 aW9uSW5kZXhTcGFjZSA8IG1fZnVuY3Rpb25JbmRleFNwYWNlLnNpemUpOwotICAgICAgICByZXR1 cm4gbV9mdW5jdGlvbkluZGV4U3BhY2UuYnVmZmVyLmdldCgpW2Z1bmN0aW9uSW5kZXhTcGFjZV0u c2lnbmF0dXJlSW5kZXg7CisgICAgICAgIHJldHVybiBtX21vZHVsZUluZm9ybWF0aW9uLT5zaWdu YXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleFNwYWNlKTsKICAg ICB9Ci0gICAgdW5zaWduZWQgaW1wb3J0Q291bnQoKSBjb25zdCB7IHJldHVybiBtX3dhc21Ub0pT U3R1YnMuc2l6ZSgpOyB9CisgICAgdW5zaWduZWQgaW1wb3J0Q291bnQoKSBjb25zdCB7IHJldHVy biBtX3dhc21FeGl0U3R1YnMuc2l6ZSgpOyB9CiAKICAgICBKU1dlYkFzc2VtYmx5Q2FsbGVlKiBq c0VudHJ5cG9pbnRDYWxsZWVGcm9tRnVuY3Rpb25JbmRleFNwYWNlKHVuc2lnbmVkIGZ1bmN0aW9u SW5kZXhTcGFjZSkKICAgICB7CkBAIC05MCwxMCArODksOCBAQCBwdWJsaWM6CiAgICAgICAgIHJl dHVybiBiaXR3aXNlX2Nhc3Q8V3JpdGVCYXJyaWVyPEpTV2ViQXNzZW1ibHlDYWxsZWU+Kj4oYml0 d2lzZV9jYXN0PGNoYXIqPih0aGlzKSArIG9mZnNldE9mQ2FsbGVlcygpKTsKICAgICB9CiAKLSAg ICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mRnVuY3Rpb25JbmRleFNwYWNlKCkgeyByZXR1cm4g T0JKRUNUX09GRlNFVE9GKEpTV2ViQXNzZW1ibHlNb2R1bGUsIG1fZnVuY3Rpb25JbmRleFNwYWNl KTsgfQotCiBwcm90ZWN0ZWQ6Ci0gICAgSlNXZWJBc3NlbWJseU1vZHVsZShWTSYsIFN0cnVjdHVy ZSosIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4mJiwgQmFnPENhbGxM aW5rSW5mbz4mJiwgVmVjdG9yPFdhc206Oldhc21Ub0pTU3R1Yj4mJiwgV2FzbTo6SW1tdXRhYmxl RnVuY3Rpb25JbmRleFNwYWNlJiYsIHVuc2lnbmVkIGNhbGxlZUNvdW50KTsKKyAgICBKU1dlYkFz c2VtYmx5TW9kdWxlKFZNJiwgU3RydWN0dXJlKiwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVs ZUluZm9ybWF0aW9uPiYmLCBCYWc8Q2FsbExpbmtJbmZvPiYmLCBWZWN0b3I8V2FzbTo6V2FzbUV4 aXRTdHVicz4mJiwgdW5zaWduZWQgY2FsbGVlQ291bnQpOwogICAgIHZvaWQgZmluaXNoQ3JlYXRp b24oVk0mLCBTeW1ib2xUYWJsZSopOwogICAgIHN0YXRpYyB2b2lkIGRlc3Ryb3koSlNDZWxsKik7 CiAgICAgc3RhdGljIHZvaWQgdmlzaXRDaGlsZHJlbihKU0NlbGwqLCBTbG90VmlzaXRvciYpOwpA QCAtMTE3LDggKzExNCw3IEBAIHByaXZhdGU6CiAgICAgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1v ZHVsZUluZm9ybWF0aW9uPiBtX21vZHVsZUluZm9ybWF0aW9uOwogICAgIEJhZzxDYWxsTGlua0lu Zm8+IG1fY2FsbExpbmtJbmZvczsKICAgICBXcml0ZUJhcnJpZXI8U3ltYm9sVGFibGU+IG1fZXhw b3J0U3ltYm9sVGFibGU7Ci0gICAgVmVjdG9yPFdhc206Oldhc21Ub0pTU3R1Yj4gbV93YXNtVG9K U1N0dWJzOwotICAgIGNvbnN0IFdhc206OkltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSBtX2Z1 bmN0aW9uSW5kZXhTcGFjZTsKKyAgICBWZWN0b3I8V2FzbTo6V2FzbUV4aXRTdHVicz4gbV93YXNt RXhpdFN0dWJzOwogICAgIHVuc2lnbmVkIG1fY2FsbGVlQ291bnQ7CiB9OwogCmRpZmYgLS1naXQg YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNwcCBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uY3BwCmlu ZGV4IDRmMGQ3YTguLmQ1OWEwNTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uY3BwCkBAIC0xMDUsMTYgKzEwNSw3IEBAIHN0 YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGNhbGxXZWJBc3NlbWJseUZ1bmN0aW9u KEV4ZWNTdGF0ZSogZXhlYykKIAogRW5jb2RlZEpTVmFsdWUgV2ViQXNzZW1ibHlGdW5jdGlvbjo6 Y2FsbChWTSYgdm0sIFByb3RvQ2FsbEZyYW1lKiBwcm90b0NhbGxGcmFtZSkKIHsKLSAgICAvLyBT ZXR1cCB0aGUgbWVtb3J5IHRoYXQgdGhlIGVudHJhbmNlIGxvYWRzLgotICAgIGlmIChKU1dlYkFz c2VtYmx5TWVtb3J5KiBtZW1vcnkgPSBpbnN0YW5jZSgpLT5tZW1vcnkoKSkgewotICAgICAgICBX YXNtOjpNZW1vcnkqIHdhc21NZW1vcnkgPSBtZW1vcnktPm1lbW9yeSgpOwotICAgICAgICB2bS50 b3BXYXNtTWVtb3J5UG9pbnRlciA9IHdhc21NZW1vcnktPm1lbW9yeSgpOwotICAgICAgICB2bS50 b3BXYXNtTWVtb3J5U2l6ZSA9IHdhc21NZW1vcnktPnNpemUoKTsKLSAgICB9IGVsc2UgewotICAg ICAgICB2bS50b3BXYXNtTWVtb3J5UG9pbnRlciA9IG51bGxwdHI7Ci0gICAgICAgIHZtLnRvcFdh c21NZW1vcnlTaXplID0gMDsKLSAgICB9Ci0KKyAgICAvLyBGSVhNRSBEbyBhd2F5IHdpdGggdGhp cyBlbnRpcmUgZnVuY3Rpb24sIGFuZCBvbmx5IHVzZSB0aGUgZW50cnlwb2ludCBnZW5lcmF0ZWQg YnkgQjMuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjY0ODYKICAg ICBKU1dlYkFzc2VtYmx5SW5zdGFuY2UqIHByZXZKU1dlYkFzc2VtYmx5SW5zdGFuY2UgPSB2bS50 b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2U7CiAgICAgdm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNl ID0gaW5zdGFuY2UoKTsKICAgICBBU1NFUlQoaW5zdGFuY2UoKSk7CkBAIC0xNTMsNyArMTQ0LDcg QEAgV2ViQXNzZW1ibHlGdW5jdGlvbiogV2ViQXNzZW1ibHlGdW5jdGlvbjo6Y3JlYXRlKFZNJiB2 bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE8KIFN0cnVjdHVyZSogV2ViQXNzZW1ibHlGdW5jdGlv bjo6Y3JlYXRlU3RydWN0dXJlKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCwg SlNWYWx1ZSBwcm90b3R5cGUpCiB7CiAgICAgQVNTRVJUKGdsb2JhbE9iamVjdCk7Ci0gICAgcmV0 dXJuIFN0cnVjdHVyZTo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3QsIHByb3RvdHlwZSwgVHlwZUlu Zm8oSlNGdW5jdGlvblR5cGUsIFN0cnVjdHVyZUZsYWdzKSwgaW5mbygpKTsKKyAgICByZXR1cm4g U3RydWN0dXJlOjpjcmVhdGUodm0sIGdsb2JhbE9iamVjdCwgcHJvdG90eXBlLCBUeXBlSW5mbyhX ZWJBc3NlbWJseUZ1bmN0aW9uVHlwZSwgU3RydWN0dXJlRmxhZ3MpLCBpbmZvKCkpOwogfQogCiBX ZWJBc3NlbWJseUZ1bmN0aW9uOjpXZWJBc3NlbWJseUZ1bmN0aW9uKFZNJiB2bSwgSlNHbG9iYWxP YmplY3QqIGdsb2JhbE9iamVjdCwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIFdhc206OlNpZ25hdHVy ZUluZGV4IHNpZ25hdHVyZUluZGV4KQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVjdG9yLmNwcCBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VDb25zdHJ1Y3Rvci5jcHAKaW5k ZXggNThlYTI1ODQuLmQyNGFiODEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VDb25zdHJ1Y3Rvci5jcHAKKysrIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVjdG9yLmNwcApA QCAtMTE0LDE4ICsxMTQsMTkgQEAgc3RhdGljIEVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwg Y29uc3RydWN0SlNXZWJBc3NlbWJseUluc3RhbmNlKEV4ZWNTdGF0ZSogZXgKICAgICAgICAgICAg ICAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKHRocm93RXhjZXB0aW9uKGV4ZWMsIHRocm93U2Nv cGUsIGNyZWF0ZUpTV2ViQXNzZW1ibHlMaW5rRXJyb3IoZXhlYywgdm0sIEFTQ0lJTGl0ZXJhbCgi aW1wb3J0IGZ1bmN0aW9uIG11c3QgYmUgY2FsbGFibGUiKSkpKTsKICAgICAgICAgICAgIEpTQ2Vs bCogY2VsbCA9IHZhbHVlLmFzQ2VsbCgpOwogICAgICAgICAgICAgLy8gaWkuIElmIHYgaXMgYW4g RXhwb3J0ZWQgRnVuY3Rpb24gRXhvdGljIE9iamVjdDoKLSAgICAgICAgICAgIGlmIChXZWJBc3Nl bWJseUZ1bmN0aW9uKiBpbXBvcnRlZEV4cG9ydHMgPSBqc0R5bmFtaWNDYXN0PFdlYkFzc2VtYmx5 RnVuY3Rpb24qPihvYmplY3QpKSB7Ci0gICAgICAgICAgICAgICAgLy8gRklYTUUgaGFuZGxlIEZ1 bmN0aW9uIEV4b3RpYyBPYmplY3QgcHJvcGVybHkuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xNjUyODIKLSAgICAgICAgICAgICAgICAvLyBhLiBJZiB0aGUgc2lnbmF0 dXJlIG9mIHYgZG9lcyBub3QgbWF0Y2ggdGhlIHNpZ25hdHVyZSBvZiBpLCB0aHJvdyBhIFR5cGVF cnJvci4KKyAgICAgICAgICAgIGlmIChXZWJBc3NlbWJseUZ1bmN0aW9uKiBpbXBvcnRlZEV4cG9y dCA9IGpzRHluYW1pY0Nhc3Q8V2ViQXNzZW1ibHlGdW5jdGlvbio+KGNlbGwpKSB7CisgICAgICAg ICAgICAgICAgLy8gYS4gSWYgdGhlIHNpZ25hdHVyZSBvZiB2IGRvZXMgbm90IG1hdGNoIHRoZSBz aWduYXR1cmUgb2YgaSwgdGhyb3cgYSBXZWJBc3NlbWJseS5MaW5rRXJyb3IuCisgICAgICAgICAg ICAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggaW1wb3J0ZWRTaWduYXR1cmVJbmRleCA9IGltcG9y dGVkRXhwb3J0LT5zaWduYXR1cmVJbmRleCgpOworICAgICAgICAgICAgICAgIFdhc206OlNpZ25h dHVyZUluZGV4IGV4cGVjdGVkU2lnbmF0dXJlSW5kZXggPSBtb2R1bGVJbmZvcm1hdGlvbi5pbXBv cnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXNbaW1wb3J0LmtpbmRJbmRleF07CisgICAgICAgICAg ICAgICAgaWYgKGltcG9ydGVkU2lnbmF0dXJlSW5kZXggIT0gZXhwZWN0ZWRTaWduYXR1cmVJbmRl eCkKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29kZSh0aHJvd0V4Y2Vw dGlvbihleGVjLCB0aHJvd1Njb3BlLCBjcmVhdGVKU1dlYkFzc2VtYmx5TGlua0Vycm9yKGV4ZWMs IHZtLCBBU0NJSUxpdGVyYWwoImltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIG1pc21hdGNo ZXMgdGhlIHByb3ZpZGVkIFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIikpKSk7CiAg ICAgICAgICAgICAgICAgLy8gYi4gTGV0IGNsb3N1cmUgYmUgdi5bW0Nsb3N1cmVdXS4KLSAgICAg ICAgICAgICAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOwotICAgICAgICAgICAgICAg IFVOVVNFRF9QQVJBTShpbXBvcnRlZEV4cG9ydHMpOwotICAgICAgICAgICAgICAgIGJyZWFrOwog ICAgICAgICAgICAgfQogICAgICAgICAgICAgLy8gaWlpLiBPdGhlcndpc2U6CiAgICAgICAgICAg ICAvLyBhLiBMZXQgY2xvc3VyZSBiZSBhIG5ldyBob3N0IGZ1bmN0aW9uIG9mIHRoZSBnaXZlbiBz aWduYXR1cmUgd2hpY2ggY2FsbHMgdiBieSBjb2VyY2luZyBXZWJBc3NlbWJseSBhcmd1bWVudHMg dG8gSmF2YVNjcmlwdCBhcmd1bWVudHMgdmlhIFRvSlNWYWx1ZSBhbmQgcmV0dXJucyB0aGUgcmVz dWx0LCBpZiBhbnksIGJ5IGNvZXJjaW5nIHZpYSBUb1dlYkFzc2VtYmx5VmFsdWUuCiAgICAgICAg ICAgICAvLyBOb3RlOiBkb25lIGFzIHBhcnQgb2YgUGxhbiBjb21waWxhdGlvbi4KICAgICAgICAg ICAgIC8vIGl2LiBBcHBlbmQgdiB0byBmdW5jcy4KKyAgICAgICAgICAgIC8vIE5vdGU6IGFkZGlu ZyB0aGUgSlNDZWxsIHRvIHRoZSBpbnN0YW5jZSBsaXN0IGZ1bGZpbGxzIGNsb3N1cmUgcmVxdWly ZW1lbnRzIGIuIGFib3ZlICh0aGUgV2ViQXNzZW1ibHkuSW5zdGFuY2Ugd2lsIGJlIGtlcHQgYWxp dmUpIGFuZCB2LiBiZWxvdyAodGhlIEpTRnVuY3Rpb24pLgogICAgICAgICAgICAgaW5zdGFuY2Ut PnNldEltcG9ydEZ1bmN0aW9uKHZtLCBjZWxsLCBudW1JbXBvcnRGdW5jdGlvbnMrKyk7CiAgICAg ICAgICAgICAvLyB2LiBBcHBlbmQgY2xvc3VyZSB0byBpbXBvcnRzLgogICAgICAgICAgICAgYnJl YWs7CkBAIC0yMjksOCArMjMwLDggQEAgc3RhdGljIEVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NB TEwgY29uc3RydWN0SlNXZWJBc3NlbWJseUluc3RhbmNlKEV4ZWNTdGF0ZSogZXgKICAgICAgICAg aWYgKG1vZHVsZUluZm9ybWF0aW9uLm1lbW9yeSAmJiAhaGFzTWVtb3J5SW1wb3J0KSB7CiAgICAg ICAgICAgICBSRUxFQVNFX0FTU0VSVCghbW9kdWxlSW5mb3JtYXRpb24ubWVtb3J5LmlzSW1wb3J0 KCkpOwogICAgICAgICAgICAgLy8gV2UgY3JlYXRlIGEgbWVtb3J5IHdoZW4gaXQncyBhIG1lbW9y eSBkZWZpbml0aW9uLgotICAgICAgICAgICAgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1lbW9yeT4g bWVtb3J5ID0gc3RkOjptYWtlX3VuaXF1ZTxXYXNtOjpNZW1vcnk+KG1vZHVsZUluZm9ybWF0aW9u Lm1lbW9yeS5pbml0aWFsKCksIG1vZHVsZUluZm9ybWF0aW9uLm1lbW9yeS5tYXhpbXVtKCkpOwot ICAgICAgICAgICAgaWYgKCFtZW1vcnktPmlzVmFsaWQoKSkKKyAgICAgICAgICAgIFdhc206Ok1l bW9yeSBtZW1vcnkobW9kdWxlSW5mb3JtYXRpb24ubWVtb3J5LmluaXRpYWwoKSwgbW9kdWxlSW5m b3JtYXRpb24ubWVtb3J5Lm1heGltdW0oKSk7CisgICAgICAgICAgICBpZiAoIW1lbW9yeS5pc1Zh bGlkKCkpCiAgICAgICAgICAgICAgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29kZSh0aHJvd0V4Y2Vw dGlvbihleGVjLCB0aHJvd1Njb3BlLCBjcmVhdGVPdXRPZk1lbW9yeUVycm9yKGV4ZWMpKSk7CiAg ICAgICAgICAgICBpbnN0YW5jZS0+c2V0TWVtb3J5KHZtLAogICAgICAgICAgICAgICAgSlNXZWJB c3NlbWJseU1lbW9yeTo6Y3JlYXRlKHZtLCBleGVjLT5sZXhpY2FsR2xvYmFsT2JqZWN0KCktPldl YkFzc2VtYmx5TWVtb3J5U3RydWN0dXJlKCksIFdURk1vdmUobWVtb3J5KSkpOwpkaWZmIC0tZ2l0 IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNZW1vcnlDb25zdHJ1 Y3Rvci5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1lbW9y eUNvbnN0cnVjdG9yLmNwcAppbmRleCAzZjg4ZWQ0Li5kY2NlYzE2IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1lbW9yeUNvbnN0cnVjdG9yLmNw cAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1lbW9yeUNv bnN0cnVjdG9yLmNwcApAQCAtOTYsOCArOTYsOCBAQCBzdGF0aWMgRW5jb2RlZEpTVmFsdWUgSlND X0hPU1RfQ0FMTCBjb25zdHJ1Y3RKU1dlYkFzc2VtYmx5TWVtb3J5KEV4ZWNTdGF0ZSogZXhlYwog ICAgICAgICB9CiAgICAgfQogCi0gICAgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1lbW9yeT4gbWVt b3J5ID0gc3RkOjptYWtlX3VuaXF1ZTxXYXNtOjpNZW1vcnk+KGluaXRpYWxQYWdlQ291bnQsIG1h eGltdW1QYWdlQ291bnQpOwotICAgIGlmICghbWVtb3J5LT5pc1ZhbGlkKCkpCisgICAgV2FzbTo6 TWVtb3J5IG1lbW9yeShpbml0aWFsUGFnZUNvdW50LCBtYXhpbXVtUGFnZUNvdW50KTsKKyAgICBp ZiAoIW1lbW9yeS5pc1ZhbGlkKCkpCiAgICAgICAgIHJldHVybiBKU1ZhbHVlOjplbmNvZGUodGhy b3dFeGNlcHRpb24oZXhlYywgdGhyb3dTY29wZSwgY3JlYXRlT3V0T2ZNZW1vcnlFcnJvcihleGVj KSkpOwogCiAgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29kZShKU1dlYkFzc2VtYmx5TWVtb3J5Ojpj cmVhdGUodm0sIGV4ZWMtPmxleGljYWxHbG9iYWxPYmplY3QoKS0+V2ViQXNzZW1ibHlNZW1vcnlT dHJ1Y3R1cmUoKSwgV1RGTW92ZShtZW1vcnkpKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNwcCBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlQ29uc3RydWN0b3IuY3Bw CmluZGV4IDM4ZWRiOGMuLjgxMjk1OTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlQ29uc3RydWN0b3IuY3BwCisrKyBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlQ29uc3RydWN0b3IuY3BwCkBA IC05Nyw3ICs5Nyw3IEBAIEpTVmFsdWUgV2ViQXNzZW1ibHlNb2R1bGVDb25zdHJ1Y3Rvcjo6Y3Jl YXRlTW9kdWxlKEV4ZWNTdGF0ZSogc3RhdGUsIFN0cnVjdHVyZSoKIAogICAgIC8vIE9ubHkgd2Fz bS1pbnRlcm5hbCBmdW5jdGlvbnMgaGF2ZSBhIGNhbGxlZSwgc3R1YnMgdG8gSlMgZG8gbm90Lgog ICAgIHVuc2lnbmVkIGNhbGxlZUNvdW50ID0gcGxhbi5pbnRlcm5hbEZ1bmN0aW9uQ291bnQoKTsK LSAgICBKU1dlYkFzc2VtYmx5TW9kdWxlKiByZXN1bHQgPSBKU1dlYkFzc2VtYmx5TW9kdWxlOjpj cmVhdGUodm0sIHN0cnVjdHVyZSwgcGxhbi50YWtlTW9kdWxlSW5mb3JtYXRpb24oKSwgcGxhbi50 YWtlQ2FsbExpbmtJbmZvcygpLCBwbGFuLnRha2VXYXNtVG9KU1N0dWJzKCksIHBsYW4udGFrZUZ1 bmN0aW9uSW5kZXhTcGFjZSgpLCBleHBvcnRTeW1ib2xUYWJsZSwgY2FsbGVlQ291bnQpOworICAg IEpTV2ViQXNzZW1ibHlNb2R1bGUqIHJlc3VsdCA9IEpTV2ViQXNzZW1ibHlNb2R1bGU6OmNyZWF0 ZSh2bSwgc3RydWN0dXJlLCBwbGFuLnRha2VNb2R1bGVJbmZvcm1hdGlvbigpLCBwbGFuLnRha2VD YWxsTGlua0luZm9zKCksIHBsYW4udGFrZVdhc21FeGl0U3R1YnMoKSwgZXhwb3J0U3ltYm9sVGFi bGUsIGNhbGxlZUNvdW50KTsKICAgICBwbGFuLmluaXRpYWxpemVDYWxsZWVzKHN0YXRlLT5qc0Nh bGxlZSgpLT5nbG9iYWxPYmplY3QoKSwgCiAgICAgICAgIFsmXSAodW5zaWduZWQgY2FsbGVlSW5k ZXgsIEpTV2ViQXNzZW1ibHlDYWxsZWUqIGpzRW50cnlwb2ludENhbGxlZSwgSlNXZWJBc3NlbWJs eUNhbGxlZSogd2FzbUVudHJ5cG9pbnRDYWxsZWUpIHsKICAgICAgICAgICAgIHJlc3VsdC0+c2V0 SlNFbnRyeXBvaW50Q2FsbGVlKHZtLCBjYWxsZWVJbmRleCwganNFbnRyeXBvaW50Q2FsbGVlKTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9k dWxlUmVjb3JkLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5 TW9kdWxlUmVjb3JkLmNwcAppbmRleCBiNGNiMDU1Li4wNzg2OTc4IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZVJlY29yZC5jcHAKKysr IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQu Y3BwCkBAIC0xMTgsNyArMTE4LDcgQEAgdm9pZCBXZWJBc3NlbWJseU1vZHVsZVJlY29yZDo6bGlu ayhFeGVjU3RhdGUqIHN0YXRlLCBKU1dlYkFzc2VtYmx5SW5zdGFuY2UqIGluc3QKICAgICAgICAg ICAgIC8vICAgICBjLiBSZXR1cm4gZnVuYy4KICAgICAgICAgICAgIEpTV2ViQXNzZW1ibHlDYWxs ZWUqIGpzRW50cnlwb2ludENhbGxlZSA9IG1vZHVsZS0+anNFbnRyeXBvaW50Q2FsbGVlRnJvbUZ1 bmN0aW9uSW5kZXhTcGFjZShleHAua2luZEluZGV4KTsKICAgICAgICAgICAgIEpTV2ViQXNzZW1i bHlDYWxsZWUqIHdhc21FbnRyeXBvaW50Q2FsbGVlID0gbW9kdWxlLT53YXNtRW50cnlwb2ludENh bGxlZUZyb21GdW5jdGlvbkluZGV4U3BhY2UoZXhwLmtpbmRJbmRleCk7Ci0gICAgICAgICAgICBX YXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1vZHVsZS0+c2lnbmF0dXJlRm9y RnVuY3Rpb25JbmRleFNwYWNlKGV4cC5raW5kSW5kZXgpOworICAgICAgICAgICAgV2FzbTo6U2ln bmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVyZUluZGV4RnJvbUZ1 bmN0aW9uSW5kZXhTcGFjZShleHAua2luZEluZGV4KTsKICAgICAgICAgICAgIGNvbnN0IFdhc206 OlNpZ25hdHVyZSogc2lnbmF0dXJlID0gV2FzbTo6U2lnbmF0dXJlSW5mb3JtYXRpb246OmdldCgm dm0sIHNpZ25hdHVyZUluZGV4KTsKICAgICAgICAgICAgIFdlYkFzc2VtYmx5RnVuY3Rpb24qIGZ1 bmN0aW9uID0gV2ViQXNzZW1ibHlGdW5jdGlvbjo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3QsIHNp Z25hdHVyZS0+YXJndW1lbnRDb3VudCgpLCBleHAuZmllbGQuc3RyaW5nKCksIGluc3RhbmNlLCBq c0VudHJ5cG9pbnRDYWxsZWUsIHdhc21FbnRyeXBvaW50Q2FsbGVlLCBzaWduYXR1cmVJbmRleCk7 CiAgICAgICAgICAgICBleHBvcnRlZFZhbHVlID0gZnVuY3Rpb247CkBAIC0xNzUsNyArMTc1LDcg QEAgdm9pZCBXZWJBc3NlbWJseU1vZHVsZVJlY29yZDo6bGluayhFeGVjU3RhdGUqIHN0YXRlLCBK U1dlYkFzc2VtYmx5SW5zdGFuY2UqIGluc3QKICAgICBib29sIGhhc1N0YXJ0ID0gISFtb2R1bGVJ bmZvcm1hdGlvbi5zdGFydEZ1bmN0aW9uSW5kZXhTcGFjZTsKICAgICBpZiAoaGFzU3RhcnQpIHsK ICAgICAgICAgYXV0byBzdGFydEZ1bmN0aW9uSW5kZXhTcGFjZSA9IG1vZHVsZUluZm9ybWF0aW9u LnN0YXJ0RnVuY3Rpb25JbmRleFNwYWNlLnZhbHVlX29yKDApOwotICAgICAgICBXYXNtOjpTaWdu YXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1vZHVsZS0+c2lnbmF0dXJlRm9yRnVuY3Rpb25J bmRleFNwYWNlKHN0YXJ0RnVuY3Rpb25JbmRleFNwYWNlKTsKKyAgICAgICAgV2FzbTo6U2lnbmF0 dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0 aW9uSW5kZXhTcGFjZShzdGFydEZ1bmN0aW9uSW5kZXhTcGFjZSk7CiAgICAgICAgIGNvbnN0IFdh c206OlNpZ25hdHVyZSogc2lnbmF0dXJlID0gV2FzbTo6U2lnbmF0dXJlSW5mb3JtYXRpb246Omdl dCgmdm0sIHNpZ25hdHVyZUluZGV4KTsKICAgICAgICAgLy8gVGhlIHN0YXJ0IGZ1bmN0aW9uIG11 c3Qgbm90IHRha2UgYW55IGFyZ3VtZW50cyBvciByZXR1cm4gYW55dGhpbmcuIFRoaXMgaXMgZW5m b3JjZWQgYnkgdGhlIHBhcnNlci4KICAgICAgICAgQVNTRVJUKCFzaWduYXR1cmUtPmFyZ3VtZW50 Q291bnQoKSk7CkBAIC0yMzgsNyArMjM4LDcgQEAgSlNWYWx1ZSBXZWJBc3NlbWJseU1vZHVsZVJl Y29yZDo6ZXZhbHVhdGUoRXhlY1N0YXRlKiBzdGF0ZSkKIAogICAgICAgICAgICAgICAgIEpTV2Vi QXNzZW1ibHlDYWxsZWUqIGpzRW50cnlwb2ludENhbGxlZSA9IG1vZHVsZS0+anNFbnRyeXBvaW50 Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KTsKICAgICAgICAgICAg ICAgICBKU1dlYkFzc2VtYmx5Q2FsbGVlKiB3YXNtRW50cnlwb2ludENhbGxlZSA9IG1vZHVsZS0+ d2FzbUVudHJ5cG9pbnRDYWxsZWVGcm9tRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgp OwotICAgICAgICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0g bW9kdWxlLT5zaWduYXR1cmVGb3JGdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleCk7Cisg ICAgICAgICAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1 bGUtPnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KTsK ICAgICAgICAgICAgICAgICBjb25zdCBXYXNtOjpTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFdhc206 OlNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQoJnZtLCBzaWduYXR1cmVJbmRleCk7CiAgICAgICAg ICAgICAgICAgLy8gRklYTUU6IFNheSB3ZSBleHBvcnQgbG9jYWwgZnVuY3Rpb24gImZvbyIgYXQg ZnVuY2l0b24gaW5kZXggMC4KICAgICAgICAgICAgICAgICAvLyBXaGF0IGlmIHdlIGFsc28gc2V0 IGl0IHRvIHRoZSB0YWJsZSBhbiBFbGVtZW50IHcvIGluZGV4IDAuCi0tIAoyLjEwLjEKCg== 297777 2016-12-26 19:55:20 -0800 2016-12-26 21:57:54 -0800 WIP 0001-wasm-wasm.patch text/plain 105355 jfbastien RnJvbSBkNDcxYmY4MTIyODBlMjhiZTUzM2YxMDNiYTg0NWExZDIwMTMwYjA2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBXZWQsIDIxIERlYyAyMDE2IDE1OjU5OjU2IC0wODAwClN1YmplY3Q6IFtQQVRDSF0gd2FzbS0+ d2FzbQoKQ2hhbmdlcyB0byB0aGUgV2ViQXNzZW1ibHkgaW1wbGVtZW50YXRpb246CgogIC0gQWRk IGEgbmV3IEpTVHlwZSBmb3IgV2ViQXNzZW1ibHlGdW5jdGlvbiwgYW5kIHVzZSBpdCB3aGVuIGNy ZWF0aW5nIGl0cwogICAgc3RydWN0dXJlLiBUaGlzIHdpbGwgYmUgdXNlZCB0byBxdWlja2x5IGRl dGVjdCBmcm9tIHdhc20gd2hldGhlciB0aGUgaW1wb3J0CiAgICBjYWxsIGlzIHRvIGFub3RoZXIg d2FzbSBtb2R1bGUsIG9yIHdoZXRoZXIgaXQncyB0byBKUy4KICAtIFVzZSBjZWxsIGluc3RlYWQg b2Ygb2JqZWN0cyB0byBkZXRlY3Qgd2FzbS0+d2FzbSwgdGhlIHByZXZpb3VzIGNvZGUgd2FzIHdy b25nLgogIC0gSW1wcm92ZSBkaWFnbm9zdGljIHByaW50b3V0IGZvciB3YXNtIHN0dWJzOiBwcmlu dCB0aGUgZnVsbCBzaWduYXR1cmUuCiAgLSBQcm9wZXJseSBjaGVjayB0aGF0IHdhc20gLT4gd2Fz bSBjYWxscyBoYXZlIG1hdGNoaW5nIHNpZ25hdHVyZXMuIEFkZCB0ZXN0aW5nIGZvciB0aGlzLgog IC0gVGVzdCBzb21lIG9mIHRoZSB3YXNtIC0+IHdhc20gY2FsbHMsIG5vdCB3b3JraW5nIHlldCwg YW5kIG1vcmUgdGVzdHMgbmVlZCB0bwogICAgZ2V0IGltcGxlbWVudGVkLgogIC0gR2VuZXJhdGUg dHdvIHN0dWJzIGZyb20gdGhlIGltcG9ydCBzdHViIGdlbmVyYXRvcjogb25lIGZvciB3YXNtLT5K UyBhbmQgb25lCiAgICBmb3Igd2FzbSAtPiB3YXNtLiBUaGlzIGlzIGRvbmUgYXQgTW9kdWxlIHRp bWUuIFdoaWNoIGlzIGNhbGxlZCB3aWxsIG9ubHkgYmUKICAgIGtub3duIGF0IEluc3RhbmNlIHRp bWUsIG9uY2Ugd2UndmUgcmVjZWl2ZWQgdGhlIGltcG9ydCBvYmplY3QuIFdlIHdhbnQgdG8KICAg IGF2b2lkIGNvZGVnZW4gYXQgSW5zdGFuY2UgdGltZSwgc28gaGF2aW5nIGJvdGggYXJvdW5kIGlz IGdyZWF0LgogIC0gUmVzdG9yZSB0aGUgV2ViQXNzZW1ibHkgZ2xvYmFsIHN0YXRlIChWTSB0b3Ag SW5zdGFuY2UsIGFuZCBwaW5uZWQgcmVnaXN0ZXJzKQogICAgYWZ0ZXIgY2FsbCAvIGNhbGxfaW5k aXJlY3QsIGFuZCBpbiB0aGUgSlMtPndhc20gZW50cnkgc3R1Yi4KClN1cHBvcnQgY2hhbmdlczoK CiAgLSBBZGQgYSBQcm94eSB0byBCdWlsZGVyLmpzLCB3aGljaCBpbnRlcmNlcHRzIHVua25vd24g cHJvcGVydHkgbG9va3Vwcy4gVGhpcwogICAgY3JlYXRlcyB3YXkgYmV0dGVyIGVycm9yIG1lc3Nh Z2VzIG9uIHR5cG9zIHRoYW4gJ3VuZGVmaW5lZCBpcyBub3QgYQogICAgZnVuY3Rpb24nLCB3aGlj aCBoYXBwZW5zIHNlbWktZnJlcXVlbnRseSBhcyBJIHR5cG8gb3Bjb2RlIG5hbWVzIChhbmQgd2hp Y2gKICAgIG9uZSBpcyBhIHR5cG8gaXMgaGFyZCB0byBmaW5kIGJlY2F1c2Ugd2UgY2hhaW4gYnVp bGRlcnMpLgogIC0gQWRkIGxpbWl0ZWQgc3VwcG9ydCBmb3IgdmFye3V9aW50NjQgKG9ubHkgdGhl IDMyLWJpdCB2YWx1ZXMpLgogIC0gR2V0IHJpZCBvZiBtdWNoIG9mIHRoZSBmdW5jdGlvbiBpbmRl eCBzcGFjZTogd2UgYWxyZWFkeSBoYXZlIGFsbCBvZiBpdHMKICAgIGluZm9ybWF0aW9uIGVsc2V3 aGVyZSwgYW5kIGFzLWlzIGl0IHByb3ZpZGVzIG5vIGV4dHJhIGVmZmljaWVuY3kuCiAgLSBTdG9y ZSBXYXNtOjpNZW1vcnkgZGlyZWN0bHkgb24gSlNXZWJBc3NlbWJseU1lbW9yeSwgaW5zdGVhZCBv ZiB0aHJvdWdoIGEKICAgIHVuaXF1ZV9wdHIuIFRoaXMgcmVtb3ZlcyBhbiBpbmRpcmVjdGlvbiBh bmQgdXNlbGVzcyBhbGxvY2F0aW9uLgogIC0gUmVtb3ZlIFZNJ2EgV2ViQXNzZW1ibHkgbWVtb3J5 IC8gc2l6ZSwgYW5kIG9idGFpbiB0aGVtIGZyb20gSW5zdGFuY2UKICAgIGluc3RlYWQuIFRoaXMg cmVxdWlyZXMgYW4gZXh0cmEgaW5kaXJlY3Rpb24sIGJ1dCBpcyBjbGVhbmVyLgotLS0KIEpTVGVz dHMvd2FzbS9CdWlsZGVyLmpzICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDkxICsrKysr Ky0tLS0tLQogSlNUZXN0cy93YXNtL0xvd0xldmVsQmluYXJ5LmpzICAgICAgICAgICAgICAgICAg ICAgfCAgMTIgKysKIEpTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy9leGNlcHRpb25zLmpzICAg ICAgICAgIHwgICA2ICstCiBKU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpz ICAgICAgICAgICB8ICAgMiArLQogSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtc3Rv cmUuanMgICAgICAgICAgfCAgIDIgKy0KIEpTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNt LWJhZC1zaWduYXR1cmUuanMgIHwgMTA1ICsrKysrKysrKysrKysrCiBKU1Rlc3RzL3dhc20vanMt YXBpL3dhc20tdG8td2FzbS5qcyAgICAgICAgICAgICAgICB8ICA3MyArKysrKysrKysrCiBTb3Vy Y2UvSmF2YVNjcmlwdENvcmUvanNjLmNwcCAgICAgICAgICAgICAgICAgICAgICB8ICAzMSArKyst LQogU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmggICAgICAgICAgICAgfCAg IDIgKwogU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVk0uaCAgICAgICAgICAgICAgICAg fCAgIDIgLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuY3Bw ICAgfCAxNTMgKysrKysrKysrKysrKysrLS0tLS0tCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtQjNJUkdlbmVyYXRvci5oICAgICB8ICAgMiArLQogU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbUJpbmRpbmcuY3BwICAgICAgICAgfCAgNDUgKysrKystCiBTb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5oICAgICAgICAgICB8ICAgMiArLQogU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vV2FzbUZvcm1hdC5oICAgICAgICAgICAgfCAgMjYgKystLQogU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmggICAgfCAgMTQgKy0K IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwICAgICAgICAgIHwgICA0 ICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmggICAgICAgICAgICB8 ICAgOCArLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5jcHAg ICAgfCAgMjQgKystLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNl ci5oICAgICAgfCAgIDEgLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uY3Bw ICAgICAgICAgICAgfCAgMzcgKystLS0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Q bGFuLmggICAgICAgICAgICAgIHwgIDEzICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9X YXNtU2lnbmF0dXJlLmNwcCAgICAgICB8ICAxMyArKwogU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbVNpZ25hdHVyZS5oICAgICAgICAgfCAgIDEgKwogU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbVZhbGlkYXRlLmNwcCAgICAgICAgfCAgIDQgKy0KIFNvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5oICAgICAgICAgIHwgICAyICstCiAuLi4vSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaCB8ICAgOCArLQogLi4uL0phdmFT Y3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5jcHAgfCAgIDggKy0KIC4uLi9K YXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuaCAgIHwgIDExICstCiAu Li4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmNwcCB8ICAgOSAr LQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5oICAgfCAg MTYgKy0tCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNw cCB8ICAxMyArLQogLi4uL3dhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVjdG9yLmNw cCAgICAgfCAgMTcgKy0tCiAuLi4vd2FzbS9qcy9XZWJBc3NlbWJseU1lbW9yeUNvbnN0cnVjdG9y LmNwcCAgICAgICB8ICAgNCArLQogLi4uL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVDb25zdHJ1 Y3Rvci5jcHAgICAgICAgfCAgIDIgKy0KIC4uLi93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVj b3JkLmNwcCAgICAgICAgICAgIHwgICA2ICstCiAzNiBmaWxlcyBjaGFuZ2VkLCA1NTAgaW5zZXJ0 aW9ucygrKSwgMjE5IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IEpTVGVzdHMvd2Fz bS9qcy1hcGkvd2FzbS10by13YXNtLWJhZC1zaWduYXR1cmUuanMKIGNyZWF0ZSBtb2RlIDEwMDY0 NCBKU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS5qcwoKZGlmZiAtLWdpdCBhL0pTVGVz dHMvd2FzbS9CdWlsZGVyLmpzIGIvSlNUZXN0cy93YXNtL0J1aWxkZXIuanMKaW5kZXggZGE1ODRj NC4uMjZiYTY2ZSAxMDA2NDQKLS0tIGEvSlNUZXN0cy93YXNtL0J1aWxkZXIuanMKKysrIGIvSlNU ZXN0cy93YXNtL0J1aWxkZXIuanMKQEAgLTM4LDcgKzM4LDcgQEAgY29uc3QgX2lzVmFsaWRWYWx1 ZSA9ICh2YWx1ZSwgdHlwZSkgPT4gewogICAgIHN3aXRjaCAodHlwZSkgewogICAgIC8vIFdlIGFs bG93IGJvdGggc2lnbmVkIGFuZCB1bnNpZ25lZCBudW1iZXJzLgogICAgIGNhc2UgImkzMiI6IHJl dHVybiBNYXRoLnJvdW5kKHZhbHVlKSA9PT0gdmFsdWUgJiYgTExCLnZhcmludDMyTWluIDw9IHZh bHVlICYmIHZhbHVlIDw9IExMQi52YXJ1aW50MzJNYXg7Ci0gICAgY2FzZSAiaTY0IjogdGhyb3cg bmV3IEVycm9yKGBVbmltcGxlbWVudGVkOiB2YWx1ZSBjaGVjayBmb3IgJHt0eXBlfWApOyAvLyBG SVhNRSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNDIwIDY0LWJp dCB2YWx1ZXMKKyAgICBjYXNlICJpNjQiOiByZXR1cm4gdHJ1ZTsgLy8gRklYTUUgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MzQyMCA2NC1iaXQgdmFsdWVzCiAgICAg Y2FzZSAiZjMyIjogcmV0dXJuIHR5cGVvZih2YWx1ZSkgPT09ICJudW1iZXIiICYmIGlzRmluaXRl KHZhbHVlKTsKICAgICBjYXNlICJmNjQiOiByZXR1cm4gdHlwZW9mKHZhbHVlKSA9PT0gIm51bWJl ciIgJiYgaXNGaW5pdGUodmFsdWUpOwogICAgIGRlZmF1bHQ6IHRocm93IG5ldyBFcnJvcihgSW1w bGVtZW50YXRpb24gcHJvYmxlbTogdW5rbm93biB0eXBlICR7dHlwZX1gKTsKQEAgLTU3LDYgKzU3 LDE2IEBAIGNvbnN0IF9ub3JtYWxpemVGdW5jdGlvblNpZ25hdHVyZSA9IChwYXJhbXMsIHJldCkg PT4gewogICAgIHJldHVybiBbcGFyYW1zLCByZXRdOwogfTsKIAorY29uc3QgX2Vycm9ySGFuZGxp bmdQcm94eUZvciA9IGJ1aWxkZXIgPT4gYnVpbGRlclsiX19pc1Byb3h5Il0gPyBidWlsZGVyIDog bmV3IFByb3h5KGJ1aWxkZXIsIHsKKyAgICBnZXQ6ICh0YXJnZXQsIHByb3BlcnR5LCByZWNlaXZl cikgPT4geworICAgICAgICBpZiAocHJvcGVydHkgPT09ICJfX2lzUHJveHkiKQorICAgICAgICAg ICAgcmV0dXJuIHRydWU7CisgICAgICAgIGlmICh0YXJnZXRbcHJvcGVydHldID09PSB1bmRlZmlu ZWQpCisgICAgICAgICAgICB0aHJvdyBuZXcgRXJyb3IoYFdlYkFzc2VtYmx5IGJ1aWxkZXIgcmVj ZWl2ZWQgdW5rbm93biBwcm9wZXJ0eSAnJHtwcm9wZXJ0eX0nYCk7CisgICAgICAgIHJldHVybiB0 YXJnZXRbcHJvcGVydHldOworICAgIH0KK30pOworCiBjb25zdCBfbWF5YmVSZWdpc3RlclR5cGUg PSAoYnVpbGRlciwgdHlwZSkgPT4gewogICAgIGNvbnN0IHR5cGVTZWN0aW9uID0gYnVpbGRlci5f Z2V0U2VjdGlvbigiVHlwZSIpOwogICAgIGlmICh0eXBlb2YodHlwZSkgPT09ICJudW1iZXIiKSB7 CkBAIC0xMDAsNyArMTEwLDcgQEAgY29uc3QgX2ltcG9ydEZ1bmN0aW9uQ29udGludWF0aW9uID0g KGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAgIHNlY3Rpb24uZGF0 YS5wdXNoKHsgZmllbGQ6IGZpZWxkLCB0eXBlOiB0eXBlLCBraW5kOiAiRnVuY3Rpb24iLCBtb2R1 bGU6IG1vZHVsZSB9KTsKICAgICAgICAgLy8gSW1wb3J0cyBhbHNvIGNvdW50IGluIHRoZSBmdW5j dGlvbiBpbmRleCBzcGFjZS4gTWFwIHRoZW0gYXMgb2JqZWN0cyB0byBhdm9pZCBjbGFzaGluZyB3 aXRoIENvZGUgZnVuY3Rpb25zJyBuYW1lcy4KICAgICAgICAgYnVpbGRlci5fcmVnaXN0ZXJGdW5j dGlvblRvSW5kZXhTcGFjZSh7IG1vZHVsZTogbW9kdWxlLCBmaWVsZDogZmllbGQgfSk7Ci0gICAg ICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJv eHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH07CiB9OwogCkBAIC0xMDksNyArMTE5LDcgQEAgY29u c3QgX2ltcG9ydE1lbW9yeUNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVp bGRlcikgPT4gewogICAgICAgICBhc3NlcnQuaXNTdHJpbmcobW9kdWxlLCBgSW1wb3J0IE1lbW9y eSBtb2R1bGUgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7bW9kdWxlfSJgKTsKICAgICAgICAg YXNzZXJ0LmlzU3RyaW5nKGZpZWxkLCBgSW1wb3J0IE1lbW9yeSBmaWVsZCBzaG91bGQgYmUgYSBz dHJpbmcsIGdvdCAiJHtmaWVsZH0iYCk7CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHttb2R1 bGUsIGZpZWxkLCBraW5kOiAiTWVtb3J5IiwgbWVtb3J5RGVzY3JpcHRpb246IHtpbml0aWFsLCBt YXhpbXVtfX0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBf ZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9OwogfTsKIApAQCAtMTE4 LDcgKzEyOCw3IEBAIGNvbnN0IF9pbXBvcnRUYWJsZUNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBz ZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgICAgICBhc3NlcnQuaXNTdHJpbmcobW9kdWxl LCBgSW1wb3J0IFRhYmxlIG1vZHVsZSBzaG91bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHttb2R1bGV9 ImApOwogICAgICAgICBhc3NlcnQuaXNTdHJpbmcoZmllbGQsIGBJbXBvcnQgVGFibGUgZmllbGQg c2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7ZmllbGR9ImApOwogICAgICAgICBzZWN0aW9uLmRh dGEucHVzaCh7bW9kdWxlLCBmaWVsZCwga2luZDogIlRhYmxlIiwgdGFibGVEZXNjcmlwdGlvbjog e2luaXRpYWwsIG1heGltdW0sIGVsZW1lbnR9fSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRl cjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwog ICAgIH07CiB9OwogCkBAIC0xNzIsNyArMTgyLDcgQEAgY29uc3QgX2V4cG9ydEZ1bmN0aW9uQ29u dGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAg ICAgICAgICAgYXNzZXJ0LmVxKHR5cGUsIGV4cG9ydGVkSW1wb3J0LnR5cGUsIGBSZS1leHBvcnRp bmcgaW1wb3J0ICIke2V4cG9ydGVkSW1wb3J0LmZpZWxkfSIgYXMgIiR7ZmllbGR9IiBoYXMgbWlz bWF0Y2hpbmcgdHlwZWApOwogICAgICAgICB9CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHsg ZmllbGQ6IGZpZWxkLCB0eXBlOiB0eXBlLCBraW5kOiAiRnVuY3Rpb24iLCBpbmRleDogaW5kZXgg fSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhh bmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH07CiB9OwogCkBAIC0xODksNyArMTk5 LDcgQEAgY29uc3QgX2V4cG9ydEdsb2JhbENvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9u LCBuZXh0QnVpbGRlcikgPT4gewogICAgIHJldHVybiAoZmllbGQsIGluZGV4KSA9PiB7CiAgICAg ICAgIGFzc2VydC5pc051bWJlcihpbmRleCwgYEdsb2JhbCBleHBvcnRzIG9ubHkgc3VwcG9ydCBu dW1iZXIgaW5kaWNlcyByaWdodCBub3dgKTsKICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2goeyBm aWVsZCwga2luZDogIkdsb2JhbCIsIGluZGV4IH0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxk ZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsK ICAgICB9CiB9OwogCkBAIC0xOTcsNyArMjA3LDcgQEAgY29uc3QgX2V4cG9ydE1lbW9yeUNvbnRp bnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgIHJldHVy biAoZmllbGQsIGluZGV4KSA9PiB7CiAgICAgICAgIGFzc2VydC5pc051bWJlcihpbmRleCwgYE1l bW9yeSBleHBvcnRzIG9ubHkgc3VwcG9ydCBudW1iZXIgaW5kaWNlc2ApOwogICAgICAgICBzZWN0 aW9uLmRhdGEucHVzaCh7ZmllbGQsIGtpbmQ6ICJNZW1vcnkiLCBpbmRleH0pOwotICAgICAgICBy ZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9y KG5leHRCdWlsZGVyKTsKICAgICB9CiB9OwogCkBAIC0yMDUsNyArMjE1LDcgQEAgY29uc3QgX2V4 cG9ydFRhYmxlQ29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9 PiB7CiAgICAgcmV0dXJuIChmaWVsZCwgaW5kZXgpID0+IHsKICAgICAgICAgYXNzZXJ0LmlzTnVt YmVyKGluZGV4LCBgVGFibGUgZXhwb3J0cyBvbmx5IHN1cHBvcnQgbnVtYmVyIGluZGljZXNgKTsK ICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2goe2ZpZWxkLCBraW5kOiAiVGFibGUiLCBpbmRleH0p OwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5k bGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9CiB9OwogCkBAIC0yMjAsMTAgKzIzMCwx MCBAQCBjb25zdCBfaW1wb3J0R2xvYmFsQ29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24s IG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAgICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKGZpZWxk LCBgSW1wb3J0IGdsb2JhbCBmaWVsZCBzaG91bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHtmaWVsZH0i YCk7CiAgICAgICAgICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKG11dGFiaWxpdHksIGBJbXBvcnQg Z2xvYmFsIG11dGFiaWxpdHkgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7bXV0YWJpbGl0eX0i YCk7CiAgICAgICAgICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2goeyBnbG9iYWxEZXNjcmlwdGlv bjogeyB0eXBlOiBvcCwgbXV0YWJpbGl0eTogX25vcm1hbGl6ZU11dGFiaWxpdHkobXV0YWJpbGl0 eSkgfSwgbW9kdWxlLCBmaWVsZCwga2luZDogIkdsb2JhbCIgfSk7Ci0gICAgICAgICAgICAgICAg cmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRs aW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7CiAgICAgICAgICAgICB9OwogICAgICAgICB9Ci0g ICAgICAgIHJldHVybiBnbG9iYWxCdWlsZGVyOworICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxp bmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICB9OwogfTsKIApAQCAtMzI0LDExICszMzQs MTEgQEAgY29uc3QgX2NyZWF0ZUZ1bmN0aW9uQnVpbGRlciA9IChmdW5jLCBidWlsZGVyLCBwcmV2 aW91c0J1aWxkZXIpID0+IHsKICAgICAgICAgICAgIGRlZmF1bHQ6CiAgICAgICAgICAgICAgICAg bmV4dEJ1aWxkZXIgPSBmdW5jdGlvbkJ1aWxkZXI7CiAgICAgICAgICAgICAgICAgYnJlYWs7Ci0g ICAgICAgICAgICAgICAgY2FzZSAiRW5kIjoKKyAgICAgICAgICAgIGNhc2UgIkVuZCI6CiAgICAg ICAgICAgICAgICAgbmV4dEJ1aWxkZXIgPSBwcmV2aW91c0J1aWxkZXI7Ci0gICAgICAgICAgICAg ICAgICAgIGJyZWFrOworICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICAgY2FzZSAi QmxvY2siOgotICAgICAgICAgICAgICAgIGNhc2UgIkxvb3AiOgorICAgICAgICAgICAgY2FzZSAi TG9vcCI6CiAgICAgICAgICAgICBjYXNlICJJZiI6CiAgICAgICAgICAgICAgICAgbmV4dEJ1aWxk ZXIgPSBfY3JlYXRlRnVuY3Rpb25CdWlsZGVyKGZ1bmMsIGJ1aWxkZXIsIGZ1bmN0aW9uQnVpbGRl cik7CiAgICAgICAgICAgICAgICAgYnJlYWs7CkBAIC0zNDQsMTEgKzM1NCwxMiBAQCBjb25zdCBf Y3JlYXRlRnVuY3Rpb25CdWlsZGVyID0gKGZ1bmMsIGJ1aWxkZXIsIHByZXZpb3VzQnVpbGRlcikg PT4gewogICAgICAgICAgICAgY29uc3Qgc3RhY2tBcmdzID0gW107IC8vIEZJWE1FIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjI3MDYKICAgICAgICAgICAgIGZ1bmMu Y29kZS5wdXNoKHsgbmFtZTogb3AsIHZhbHVlOiB2YWx1ZSwgYXJndW1lbnRzOiBzdGFja0FyZ3Ms IGltbWVkaWF0ZXM6IGltbXMgfSk7CiAgICAgICAgICAgICBpZiAoaGFzQ29udGludWF0aW9uKQot ICAgICAgICAgICAgICAgIHJldHVybiBjb250aW51YXRpb24obmV4dEJ1aWxkZXIpLkVuZCgpOwot ICAgICAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICAgICAgICAgIHJldHVybiBf ZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGNvbnRpbnVhdGlvbihuZXh0QnVpbGRlcikuRW5kKCkpOwor ICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwog ICAgICAgICB9OwotICAgIH0KLSAgICByZXR1cm4gZnVuY3Rpb25CdWlsZGVyOworICAgIH07CisK KyAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihmdW5jdGlvbkJ1aWxkZXIpOwogfQog CiBjb25zdCBfY3JlYXRlRnVuY3Rpb24gPSAoc2VjdGlvbiwgYnVpbGRlciwgcHJldmlvdXNCdWls ZGVyKSA9PiB7CkBAIC00NDksMTAgKzQ2MCwxMCBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWls ZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgIEZ1bmM6IChwYXJhbXMsIHJldCkgPT4gewog ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtwYXJhbXMsIHJldF0gPSBfbm9ybWFsaXplRnVu Y3Rpb25TaWduYXR1cmUocGFyYW1zLCByZXQpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAg IHMuZGF0YS5wdXNoKHsgcGFyYW1zOiBwYXJhbXMsIHJldDogcmV0IH0pOwotICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHJldHVybiB0eXBlQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih0eXBlQnVpbGRlcik7CiAgICAg ICAgICAgICAgICAgICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAg ICAgICAgICAgICByZXR1cm4gdHlwZUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVy biBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHR5cGVCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9 OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC00NjYsNyArNDc3LDcgQEAgZXhwb3J0IGRl ZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgIGltcG9ydEJ1aWxkZXIu RnVuY3Rpb24gPSBfaW1wb3J0RnVuY3Rpb25Db250aW51YXRpb24odGhpcywgcywgaW1wb3J0QnVp bGRlcik7CiAgICAgICAgICAgICAgICAgICAgIGltcG9ydEJ1aWxkZXIuTWVtb3J5ID0gX2ltcG9y dE1lbW9yeUNvbnRpbnVhdGlvbih0aGlzLCBzLCBpbXBvcnRCdWlsZGVyKTsKICAgICAgICAgICAg ICAgICAgICAgaW1wb3J0QnVpbGRlci5UYWJsZSA9IF9pbXBvcnRUYWJsZUNvbnRpbnVhdGlvbih0 aGlzLCBzLCBpbXBvcnRCdWlsZGVyKTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGltcG9y dEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5 Rm9yKGltcG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAg YnJlYWs7CiAKQEAgLTQ3Nyw3ICs0ODgsNyBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVy IHsKICAgICAgICAgICAgICAgICAgICAgICAgIEVuZDogKCkgPT4gdGhpcwogICAgICAgICAgICAg ICAgICAgICAgICAgLy8gRklYTUU6IGFkZCBhYmlsaXR5IHRvIGFkZCB0aGlzIHdpdGggd2hhdGV2 ZXIuCiAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiBm dW5jdGlvbkJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGlu Z1Byb3h5Rm9yKGZ1bmN0aW9uQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAg ICAgICAgICBicmVhazsKIApAQCAtNDg4LDEwICs0OTksMTAgQEAgZXhwb3J0IGRlZmF1bHQgY2xh c3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBFbmQ6ICgpID0+IHRoaXMsCiAg ICAgICAgICAgICAgICAgICAgICAgICBUYWJsZTogKHtpbml0aWFsLCBtYXhpbXVtLCBlbGVtZW50 fSkgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKHt0YWJsZURl c2NyaXB0aW9uOiB7aW5pdGlhbCwgbWF4aW11bSwgZWxlbWVudH19KTsKLSAgICAgICAgICAgICAg ICAgICAgICAgICAgICByZXR1cm4gdGFibGVCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHRhYmxlQnVpbGRlcik7CiAgICAg ICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAgICAgICAg ICAgICAgICAgIHJldHVybiB0YWJsZUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVy biBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHRhYmxlQnVpbGRlcik7CiAgICAgICAgICAgICAgICAg fTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNTAyLDEwICs1MTMsMTAgQEAgZXhwb3J0 IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBFbmQ6ICgp ID0+IHRoaXMsCiAgICAgICAgICAgICAgICAgICAgICAgICBJbml0aWFsTWF4UGFnZXM6IChpbml0 aWFsLCBtYXgpID0+IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaCh7 IGluaXRpYWwsIG1heCB9KTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gbWVt b3J5QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFu ZGxpbmdQcm94eUZvcihtZW1vcnlCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH0K ICAgICAgICAgICAgICAgICAgICAgfTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIG1lbW9y eUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5 Rm9yKG1lbW9yeUJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAg YnJlYWs7CiAKQEAgLTUxNiwxNiArNTI3LDE2IEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxk ZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRW5kOiAoKSA9PiB0aGlzLAogICAgICAgICAg ICAgICAgICAgICAgICAgR2V0R2xvYmFsOiAodHlwZSwgaW5pdFZhbHVlLCBtdXRhYmlsaXR5KSA9 PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcy5kYXRhLnB1c2goeyB0eXBlLCBvcDog ImdldF9nbG9iYWwiLCBtdXRhYmlsaXR5OiBfbm9ybWFsaXplTXV0YWJpbGl0eShtdXRhYmlsaXR5 KSwgaW5pdFZhbHVlIH0pOwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBnbG9i YWxCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5k bGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAgICAgfQog ICAgICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgICAgICBmb3IgKGxldCBvcCBv ZiBXQVNNLmRlc2NyaXB0aW9uLnZhbHVlX3R5cGUpIHsKICAgICAgICAgICAgICAgICAgICAgICAg IGdsb2JhbEJ1aWxkZXJbX3RvSmF2YVNjcmlwdE5hbWUob3ApXSA9IChpbml0VmFsdWUsIG11dGFi aWxpdHkpID0+IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaCh7IHR5 cGU6IG9wLCBvcDogb3AgKyAiLmNvbnN0IiwgbXV0YWJpbGl0eTogX25vcm1hbGl6ZU11dGFiaWxp dHkobXV0YWJpbGl0eSksIGluaXRWYWx1ZSB9KTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAg ICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1 cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICAgICAgICAgICAg ICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgICAgICAgICAg cmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JI YW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAg ICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTUzOSw3ICs1NTAsNyBAQCBleHBvcnQgZGVmYXVsdCBj bGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgZXhwb3J0QnVpbGRlci5GdW5jdGlv biA9IF9leHBvcnRGdW5jdGlvbkNvbnRpbnVhdGlvbih0aGlzLCBzLCBleHBvcnRCdWlsZGVyKTsK ICAgICAgICAgICAgICAgICAgICAgZXhwb3J0QnVpbGRlci5NZW1vcnkgPSBfZXhwb3J0TWVtb3J5 Q29udGludWF0aW9uKHRoaXMsIHMsIGV4cG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAg ICBleHBvcnRCdWlsZGVyLlRhYmxlID0gX2V4cG9ydFRhYmxlQ29udGludWF0aW9uKHRoaXMsIHMs IGV4cG9ydEJ1aWxkZXIpOwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gZXhwb3J0QnVpbGRl cjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZXhw b3J0QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsK IApAQCAtNTUyLDcgKzU2Myw3IEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAg ICAgICAgICAgICAgICAgICBpZiAodHlwZW9mKGZ1bmN0aW9uSW5kZXhPck5hbWUpICE9PSAibnVt YmVyIiAmJiB0eXBlb2YoZnVuY3Rpb25JbmRleE9yTmFtZSkgIT09ICJzdHJpbmciKQogICAgICAg ICAgICAgICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBTdGFydCBzZWN0aW9uJ3MgZnVuY3Rp b24gaW5kZXggIG11c3QgZWl0aGVyIGJlIGEgbnVtYmVyIG9yIGEgc3RyaW5nYCk7CiAgICAgICAg ICAgICAgICAgICAgIHMuZGF0YS5wdXNoKGZ1bmN0aW9uSW5kZXhPck5hbWUpOwotICAgICAgICAg ICAgICAgICAgICByZXR1cm4gc3RhcnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1 cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihzdGFydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAg IH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTU2MywxMSArNTc0LDExIEBAIGV4cG9y dCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRW5kOiAo KSA9PiB0aGlzLAogICAgICAgICAgICAgICAgICAgICAgICAgRWxlbWVudDogKHt0YWJsZUluZGV4 ID0gMCwgb2Zmc2V0LCBmdW5jdGlvbkluZGljZXN9KSA9PiB7CiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgcy5kYXRhLnB1c2goe3RhYmxlSW5kZXgsIG9mZnNldCwgZnVuY3Rpb25JbmRpY2Vz fSk7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGVsZW1lbnRCdWlsZGVyOwor ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9y KGVsZW1lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAg ICAgICAgICAgfTsKIAotICAgICAgICAgICAgICAgICAgICByZXR1cm4gZWxlbWVudEJ1aWxkZXI7 CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGVsZW1l bnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwog CkBAIC02MzIsMTIgKzY0MywxMiBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIEZJWE1FIGluIGNoZWNrZWQgbW9k ZSwgdGVzdCB0aGF0IHRoZSB0eXBlIGlzIGFjY2VwdGFibGUgZm9yIHN0YXJ0IGZ1bmN0aW9uLiBX ZSBwcm9iYWJseSB3YW50IF9yZWdpc3RlckZ1bmN0aW9uVG9JbmRleFNwYWNlIHRvIGFsc28gcmVn aXN0ZXIgdHlwZXMgcGVyIGluZGV4LiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MTY1NjU4CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJu IGJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRs aW5nUHJveHlGb3IoYnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICB9LAogCiAgICAg ICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgICAgIGNvZGVCdWlsZGVyLkZ1bmN0 aW9uID0gX2NyZWF0ZUZ1bmN0aW9uKHMsIGJ1aWxkZXIsIGNvZGVCdWlsZGVyKTsKLSAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIGNvZGVCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1 cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihjb2RlQnVpbGRlcik7CiAgICAgICAgICAgICAgICAg fTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNjYwLDE5ICs2NzEsMTkgQEAgZXhwb3J0 IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IEluZGV4OiBpbmRleCA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBh c3NlcnQuZXEoaW5kZXgsIDApOyAvLyBMaW5lYXIgbWVtb3J5IGluZGV4IG11c3QgYmUgemVybyBp biBNVlAuCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0aGlzU2VnbWVudC5p bmRleCA9IGluZGV4OwotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJu IHNlZ21lbnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0 dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3Ioc2VnbWVudEJ1aWxkZXIpOwogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBP ZmZzZXQ6IG9mZnNldCA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAv LyBGSVhNRSBhbGxvdyBjb21wbGV4IGluaXRfZXhwciBoZXJlLiBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1NzAwCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBhc3NlcnQuaXNOdW1iZXIob2Zmc2V0KTsKICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHRoaXNTZWdtZW50Lm9mZnNldCA9IG9mZnNldDsKLSAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBzZWdtZW50QnVpbGRlcjsKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHNl Z21lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfSwKICAgICAg ICAgICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJl dHVybiBzZWdtZW50QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4g X2Vycm9ySGFuZGxpbmdQcm94eUZvcihzZWdtZW50QnVpbGRlcik7CiAgICAgICAgICAgICAgICAg ICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gZGF0YUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5k bGluZ1Byb3h5Rm9yKGRhdGFCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAgICAg ICAgICAgIGJyZWFrOwogCkBAIC02OTAsMTAgKzcwMSwxMCBAQCBleHBvcnQgZGVmYXVsdCBjbGFz cyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICBCeXRlOiBiID0+IHsKICAgICAgICAgICAgICAg ICAgICAgYXNzZXJ0LmVxKGIgJiAweEZGLCBiLCBgVW5rbm93biBzZWN0aW9uIGV4cGVjdGVkIGJ5 dGUsIGdvdDogIiR7Yn0iYCk7CiAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKGIpOwot ICAgICAgICAgICAgICAgICAgICByZXR1cm4gdW5rbm93bkJ1aWxkZXI7CisgICAgICAgICAgICAg ICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHVua25vd25CdWlsZGVyKTsKICAg ICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9OwotICAgICAgICAgICAgcmV0dXJuIHVua25v d25CdWlsZGVyOworICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IodW5r bm93bkJ1aWxkZXIpOwogICAgICAgICB9OwogICAgIH0KICAgICBfYWRkU2VjdGlvbihuYW1lT3JO dW1iZXIsIGV4dHJhT2JqZWN0KSB7CmRpZmYgLS1naXQgYS9KU1Rlc3RzL3dhc20vTG93TGV2ZWxC aW5hcnkuanMgYi9KU1Rlc3RzL3dhc20vTG93TGV2ZWxCaW5hcnkuanMKaW5kZXggNjExYTI2ZC4u ZjliYzhhMyAxMDA2NDQKLS0tIGEvSlNUZXN0cy93YXNtL0xvd0xldmVsQmluYXJ5LmpzCisrKyBi L0pTVGVzdHMvd2FzbS9Mb3dMZXZlbEJpbmFyeS5qcwpAQCAtMTcwLDYgKzE3MCwxOCBAQCBleHBv cnQgZGVmYXVsdCBjbGFzcyBMb3dMZXZlbEJpbmFyeSB7CiAgICAgICAgICAgICB0aGlzLnVpbnQ4 KDB4ODAgfCBiKTsKICAgICAgICAgfSB3aGlsZSAodHJ1ZSk7CiAgICAgfQorICAgIHZhcnVpbnQ2 NCh2KSB7CisgICAgICAgIGFzc2VydC5pc051bWJlcih2KTsKKyAgICAgICAgaWYgKHYgPCB2YXJ1 aW50MzJNaW4gfHwgdmFydWludDMyTWF4IDwgdikKKyAgICAgICAgICAgIHRocm93IG5ldyBSYW5n ZUVycm9yKGB1bmltcGxlbWVudGVkOiB2YXJ1aW50NjQgbGFyZ2VyIHRoYW4gMzItYml0YCk7Cisg ICAgICAgIHRoaXMudmFydWludDMyKHYpOyAvLyBGSVhNRSBpbXBsZW1lbnQgNjQtYml0IHZhcnt1 fWludCBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNDIwCisgICAg fQorICAgIHZhcmludDY0KHYpIHsKKyAgICAgICAgYXNzZXJ0LmlzTnVtYmVyKHYpOworICAgICAg ICBpZiAodiA8IHZhcmludDMyTWluIHx8IHZhcmludDMyTWF4IDwgdikKKyAgICAgICAgICAgIHRo cm93IG5ldyBSYW5nZUVycm9yKGB1bmltcGxlbWVudGVkOiB2YXJpbnQ2NCBsYXJnZXIgdGhhbiAz Mi1iaXRgKTsKKyAgICAgICAgdGhpcy52YXJpbnQzMih2KTsgLy8gRklYTUUgaW1wbGVtZW50IDY0 LWJpdCB2YXJ7dX1pbnQgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2 MzQyMAorICAgIH0KICAgICB2YXJ1aW50MSh2KSB7CiAgICAgICAgIGlmICh2ICE9PSAwICYmIHYg IT09IDEpCiAgICAgICAgICAgICB0aHJvdyBuZXcgUmFuZ2VFcnJvcihgSW52YWxpZCB2YXJ1aW50 MSAke3Z9IHJhbmdlIGlzIFswLCAxXWApOwpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2Z1bmN0 aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvZXhj ZXB0aW9ucy5qcwppbmRleCBkMmIzYTQ5Li45NTI1MTNmIDEwMDY0NAotLS0gYS9KU1Rlc3RzL3dh c20vZnVuY3Rpb24tdGVzdHMvZXhjZXB0aW9ucy5qcworKysgYi9KU1Rlc3RzL3dhc20vZnVuY3Rp b24tdGVzdHMvZXhjZXB0aW9ucy5qcwpAQCAtNDUsMTggKzQ1LDE4IEBAIGZ1bmN0aW9uIG1ha2VJ bnN0YW5jZSgpIHsKICAgICBhc3NlcnQuZXEodGFibGUuZ2V0KDApLCBudWxsKTsKIAogICAgIGZv ciAobGV0IGkgPSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0gICAgICAgIGFzc2VydC50aHJvd3MoKCkg PT4gZm9vKDAsIGkpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJjYWxsX2luZGlyZWN0IHRv IGEgbnVsbCB0YWJsZSBlbnRyeSAoZXZhbHVhdGluZyAnZnVuYyguLi5hcmdzKScpIik7CisgICAg ICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDAsIGkpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJy b3IsICJjYWxsX2luZGlyZWN0IHRvIGEgbnVsbCB0YWJsZSBlbnRyeSIpOwogICAgIH0KIAogICAg IHRhYmxlLnNldCgwLCBmb28pOwogICAgIGFzc2VydC5lcSh0YWJsZS5nZXQoMCksIGZvbyk7CiAK ICAgICBmb3IgKGxldCBpID0gMDsgaSA8IDEwMDA7IGkrKykgewotICAgICAgICBhc3NlcnQudGhy b3dzKCgpID0+IGZvbygxICsgaSwgaSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgIk91dCBv ZiBib3VuZHMgY2FsbF9pbmRpcmVjdCAoZXZhbHVhdGluZyAnZnVuYyguLi5hcmdzKScpIik7Cisg ICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDEgKyBpLCBpKSwgV2ViQXNzZW1ibHkuUnVu dGltZUVycm9yLCAiT3V0IG9mIGJvdW5kcyBjYWxsX2luZGlyZWN0Iik7CiAgICAgfQogCiAgICAg Zm9yIChsZXQgaSA9IDA7IGkgPCAxMDAwOyBpKyspIHsKLSAgICAgICAgYXNzZXJ0LnRocm93cygo KSA9PiBmb28oMCwgaSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgImNhbGxfaW5kaXJlY3Qg dG8gYSBzaWduYXR1cmUgdGhhdCBkb2VzIG5vdCBtYXRjaCAoZXZhbHVhdGluZyAnZnVuYyguLi5h cmdzKScpIik7CisgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDAsIGkpLCBXZWJBc3Nl bWJseS5SdW50aW1lRXJyb3IsICJjYWxsX2luZGlyZWN0IHRvIGEgc2lnbmF0dXJlIHRoYXQgZG9l cyBub3QgbWF0Y2giKTsKICAgICB9CiAKICAgICB0YWJsZS5zZXQoMCwgYmFyKTsKZGlmZiAtLWdp dCBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMgYi9KU1Rlc3RzL3dh c20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpzCmluZGV4IDRkZDgyZGMuLjEyMzFlMDMgMTAw NjQ0Ci0tLSBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMKKysrIGIv SlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtbG9hZC5qcwpAQCAtMjksNiArMjksNiBA QCBmdW5jdGlvbiB3YXNtRnJhbWVDb3VudEZyb21FcnJvcihlKSB7CiB9CiAKIGZvciAobGV0IGkg PSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0gICAgY29uc3QgZSA9IGFzc2VydC50aHJvd3MoKCkgPT4g Zm9vKG51bVBhZ2VzICogcGFnZVNpemUgKyAxKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9yLCAi T3V0IG9mIGJvdW5kcyBtZW1vcnkgYWNjZXNzIChldmFsdWF0aW5nICdmdW5jKC4uLmFyZ3MpJyki KTsKKyAgICBjb25zdCBlID0gYXNzZXJ0LnRocm93cygoKSA9PiBmb28obnVtUGFnZXMgKiBwYWdl U2l6ZSArIDEpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJPdXQgb2YgYm91bmRzIG1lbW9y eSBhY2Nlc3MiKTsKICAgICBhc3NlcnQuZXEod2FzbUZyYW1lQ291bnRGcm9tRXJyb3IoZSksIDIp OwogfQpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtc3RvcmUu anMgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5qcwppbmRleCA1NTk4 N2MyLi4zNjU3MTNhIDEwMDY0NAotLS0gYS9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJh cC1zdG9yZS5qcworKysgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5q cwpAQCAtMjUsNSArMjUsNSBAQCBjb25zdCBudW1QYWdlcyA9IDEwOwogICAgIGNvbnN0IGZvbyA9 IG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShtb2R1bGUsIHthOiB7YjogbmV3IFdlYkFzc2VtYmx5 Lk1lbW9yeSh7aW5pdGlhbDogbnVtUGFnZXN9KX19KS5leHBvcnRzLmZvbzsKIAogICAgIGZvciAo bGV0IGkgPSAwOyBpIDwgMTAwMDA7IGkrKykKLSAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBm b28oaSwgbnVtUGFnZXMgKiBwYWdlU2l6ZSArIDEpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3Is ICJPdXQgb2YgYm91bmRzIG1lbW9yeSBhY2Nlc3MgKGV2YWx1YXRpbmcgJ2Z1bmMoLi4uYXJncykn KSIpOworICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbyhpLCBudW1QYWdlcyAqIHBhZ2VT aXplICsgMSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgIk91dCBvZiBib3VuZHMgbWVtb3J5 IGFjY2VzcyIpOwogfQpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdh c20tYmFkLXNpZ25hdHVyZS5qcyBiL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLWJh ZC1zaWduYXR1cmUuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2U3MGQ3 OAotLS0gL2Rldi9udWxsCisrKyBiL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLWJh ZC1zaWduYXR1cmUuanMKQEAgLTAsMCArMSwxMDUgQEAKK2ltcG9ydCAqIGFzIGFzc2VydCBmcm9t ICcuLi9hc3NlcnQuanMnOworaW1wb3J0IEJ1aWxkZXIgZnJvbSAnLi4vQnVpbGRlci5qcyc7CisK K2NvbnN0IGltcG9ydE5hbWUgPSAicGllck9uZSI7Citjb25zdCB0eXBlcyA9IFsiaTMyIiwgImk2 NCIsICJmMzIiLCAiZjY0IiwgInZvaWQiXTsKK2NvbnN0IHR5cGVzTm9uVm9pZCA9IFsiaTMyIiwg Imk2NCIsICJmMzIiLCAiZjY0Il07Citjb25zdCBzd2FwVHlwZSA9ICh0eXBlLCBpbmRleCkgPT4g dHlwZXNbKHR5cGVzLmluZGV4T2YodHlwZSkgKyBpbmRleCkgJSB0eXBlcy5sZW5ndGhdOworY29u c3Qgc3dhcFR5cGVOb25Wb2lkID0gKHR5cGUsIGluZGV4KSA9PiB0eXBlc05vblZvaWRbKHR5cGVz Tm9uVm9pZC5pbmRleE9mKHR5cGUpICsgaW5kZXgpICUgdHlwZXNOb25Wb2lkLmxlbmd0aF07CisK K2NvbnN0IHNpZ25hdHVyZXMgPSBbCisgICAgeyBwYXJhbXM6IFsiaTMyIl0sIHJldDogInZvaWQi IH0sCisgICAgeyBwYXJhbXM6IFsiaTY0Il0sIHJldDogInZvaWQiIH0sCisgICAgeyBwYXJhbXM6 IFsiZjMyIl0sIHJldDogInZvaWQiIH0sCisgICAgeyBwYXJhbXM6IFsiZjY0Il0sIHJldDogInZv aWQiIH0sCisgICAgeyBwYXJhbXM6IFsiaTMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7IHBhcmFt czogWyJpNjQiXSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBbImYzMiJdLCByZXQ6ICJm MzIiIH0sCisgICAgeyBwYXJhbXM6IFsiZjY0Il0sIHJldDogImY2NCIgfSwKKyAgICB7IHBhcmFt czogWyJpMzIiLCAiZjMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7IHBhcmFtczogWyJmMzIiLCAi aTMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7IHBhcmFtczogWyJpNjQiLCAiZjY0Il0sIHJldDog Imk2NCIgfSwKKyAgICB7IHBhcmFtczogWyJmNjQiLCAiaTY0Il0sIHJldDogImk2NCIgfSwKKyAg ICB7IHBhcmFtczogWyJpMzIiLCAiZjMyIiwgImkzMiJdLCByZXQ6ICJpMzIiIH0sCisgICAgeyBw YXJhbXM6IFsiaTMyIiwgImYzMiIsICJpMzIiXSwgcmV0OiAiaTMyIiB9LAorICAgIHsgcGFyYW1z OiBbImk2NCIsICJmNjQiLCAiaTY0Il0sIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogWyJp NjQiLCAiZjY0IiwgImk2NCJdLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IEFycmF5KDMy KS5maWxsKCJpMzIiKSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBBcnJheSgzMikuZmls bCgiaTY0IiksIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogQXJyYXkoMzIpLmZpbGwoImYz MiIpLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IEFycmF5KDMyKS5maWxsKCJmNjQiKSwg cmV0OiAiaTY0IiB9LAorXTsKKworY29uc3QgbWFrZUltcG9ydGVyID0gc2lnbmF0dXJlID0+IHsK KyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAgIC5UeXBlKCkuRW5k KCkKKyAgICAgICAgLkltcG9ydCgpLkZ1bmN0aW9uKCJleHBvcnRzIiwgaW1wb3J0TmFtZSwgc2ln bmF0dXJlKS5FbmQoKTsKKyAgICByZXR1cm4gbmV3IFdlYkFzc2VtYmx5Lk1vZHVsZShidWlsZGVy LldlYkFzc2VtYmx5KCkuZ2V0KCkpOworfTsKKworY29uc3QgbWFrZUltcG9ydGVlID0gc2lnbmF0 dXJlID0+IHsKKyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAgIC5U eXBlKCkuRW5kKCkKKyAgICAgICAgLkZ1bmN0aW9uKCkuRW5kKCkKKyAgICAgICAgLkV4cG9ydCgp CisgICAgICAgICAgICAuRnVuY3Rpb24oaW1wb3J0TmFtZSkKKyAgICAgICAgLkVuZCgpCisgICAg ICAgIC5Db2RlKCkKKyAgICAgICAgICAgIC5GdW5jdGlvbihpbXBvcnROYW1lLCBzaWduYXR1cmUp OworICAgIHN3aXRjaCAoc2lnbmF0dXJlLnJldCkgeworICAgIGNhc2UgImkzMiI6IGJ1aWxkZXIu STMyQ29uc3QoMCk7IGJyZWFrOworICAgIGNhc2UgImk2NCI6IGJ1aWxkZXIuSTY0Q29uc3QoMCk7 IGJyZWFrOworICAgIGNhc2UgImYzMiI6IGJ1aWxkZXIuRjMyQ29uc3QoMCk7IGJyZWFrOworICAg IGNhc2UgImY2NCI6IGJ1aWxkZXIuRjY0Q29uc3QoMCk7IGJyZWFrOworICAgIGNhc2UgInZvaWQi OiBicmVhazsKKyAgICB9CisgICAgcmV0dXJuIG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShuZXcg V2ViQXNzZW1ibHkuTW9kdWxlKGJ1aWxkZXIuUmV0dXJuKCkuRW5kKCkuRW5kKCkuV2ViQXNzZW1i bHkoKS5nZXQoKSkpOworfTsKKworKGZ1bmN0aW9uIEJhZFNpZ25hdHVyZURyb3BTdGFydFBhcmFt cygpIHsKKyAgICBmb3IgKGxldCBzaWduYXR1cmUgb2Ygc2lnbmF0dXJlcykgeworICAgICAgICBj b25zdCBpbXBvcnRlZSA9IG1ha2VJbXBvcnRlZShzaWduYXR1cmUpOworICAgICAgICBmb3IgKGxl dCBpID0gMTsgaSA8PSBzaWduYXR1cmUucGFyYW1zLmxlbmd0aDsgKytpKSB7CisgICAgICAgICAg ICBjb25zdCBiYWRQYXJhbVNpZ25hdHVyZSA9IHsgcGFyYW1zOiBzaWduYXR1cmUucGFyYW1zLnNs aWNlKGksIHNpZ25hdHVyZS5wYXJhbXMubGVuZ3RoKSwgcmV0OiBzaWduYXR1cmUucmV0IH07Cisg ICAgICAgICAgICBjb25zdCBpbXBvcnRlciA9IG1ha2VJbXBvcnRlcihiYWRQYXJhbVNpZ25hdHVy ZSk7CisgICAgICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IG5ldyBXZWJBc3NlbWJseS5JbnN0 YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpLCBXZWJBc3NlbWJseS5MaW5rRXJyb3IsIGBpbXBvcnRl ZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBtaXNtYXRjaGVzIHRoZSBwcm92aWRlZCBXZWJBc3NlbWJs eSBmdW5jdGlvbidzIHNpZ25hdHVyZSAoZXZhbHVhdGluZyAnbmV3IFdlYkFzc2VtYmx5Lkluc3Rh bmNlKGltcG9ydGVyLCBpbXBvcnRlZSknKWApOworICAgICAgICB9CisgICAgfQorfSkoKTsKKwor KGZ1bmN0aW9uIEJhZFNpZ25hdHVyZURyb3BFbmRQYXJhbXMoKSB7CisgICAgZm9yIChsZXQgc2ln bmF0dXJlIG9mIHNpZ25hdHVyZXMpIHsKKyAgICAgICAgY29uc3QgaW1wb3J0ZWUgPSBtYWtlSW1w b3J0ZWUoc2lnbmF0dXJlKTsKKyAgICAgICAgZm9yIChsZXQgaSA9IDE7IGkgPCBzaWduYXR1cmUu cGFyYW1zLmxlbmd0aDsgKytpKSB7CisgICAgICAgICAgICBjb25zdCBiYWRQYXJhbVNpZ25hdHVy ZSA9IHsgcGFyYW1zOiBzaWduYXR1cmUucGFyYW1zLnNsaWNlKDAsIGkpLCByZXQ6IHNpZ25hdHVy ZS5yZXQgfTsKKyAgICAgICAgICAgIGNvbnN0IGltcG9ydGVyID0gbWFrZUltcG9ydGVyKGJhZFBh cmFtU2lnbmF0dXJlKTsKKyAgICAgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gbmV3IFdlYkFz c2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSksIFdlYkFzc2VtYmx5LkxpbmtFcnJv ciwgYGltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIG1pc21hdGNoZXMgdGhlIHByb3ZpZGVk IFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIChldmFsdWF0aW5nICduZXcgV2ViQXNz ZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKScpYCk7CisgICAgICAgIH0KKyAgICB9 Cit9KSgpOworCisoZnVuY3Rpb24gQmFkU2lnbmF0dXJlU3dhcFBhcmFtKCkgeworICAgIGZvciAo bGV0IHNpZ25hdHVyZSBvZiBzaWduYXR1cmVzKSB7CisgICAgICAgIGNvbnN0IGltcG9ydGVlID0g bWFrZUltcG9ydGVlKHNpZ25hdHVyZSk7CisgICAgICAgIGZvciAobGV0IHNpZ25hdHVyZUluZGV4 ID0gMDsgc2lnbmF0dXJlSW5kZXggPCBzaWduYXR1cmUubGVuZ3RoOyArK3NpZ25hdHVyZUluZGV4 KSB7CisgICAgICAgICAgICBmb3IgKGxldCB0eXBlSW5kZXggPSAxOyB0eXBlSW5kZXggPCB0eXBl c05vblZvaWQubGVuZ3RoOyArK3R5cGVJbmRleCkgeworICAgICAgICAgICAgICAgIGxldCBiYWRQ YXJhbXMgPSBzaWduYXR1cmUucGFyYW1zLnNsaWNlKCk7CisgICAgICAgICAgICAgICAgYmFkUGFy YW1zW3NpZ25hdHVyZUluZGV4XSA9IHN3YXBUeXBlTm9uVm9pZChiYWRQYXJhbXNbc2lnbmF0dXJl SW5kZXhdLCB0eXBlSW5kZXgpOworICAgICAgICAgICAgICAgIGNvbnN0IGJhZFBhcmFtU2lnbmF0 dXJlID0geyBwYXJhbXM6IGJhZFBhcmFtcywgcmV0OiBzaWduYXR1cmUucmV0IH07CisgICAgICAg ICAgICAgICAgY29uc3QgaW1wb3J0ZXIgPSBtYWtlSW1wb3J0ZXIoYmFkUGFyYW1TaWduYXR1cmUp OworICAgICAgICAgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gbmV3IFdlYkFzc2VtYmx5Lklu c3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSksIFdlYkFzc2VtYmx5LkxpbmtFcnJvciwgYGltcG9y dGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIG1pc21hdGNoZXMgdGhlIHByb3ZpZGVkIFdlYkFzc2Vt Ymx5IGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIChldmFsdWF0aW5nICduZXcgV2ViQXNzZW1ibHkuSW5z dGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKScpYCk7CisgICAgICAgICAgICB9CisgICAgICAgIH0K KyAgICB9Cit9KSgpOworCisoZnVuY3Rpb24gQmFkU2lnbmF0dXJlUmV0KCkgeworICAgIGZvciAo bGV0IHNpZ25hdHVyZSBvZiBzaWduYXR1cmVzKSB7CisgICAgICAgIGNvbnN0IGltcG9ydGVlID0g bWFrZUltcG9ydGVlKHNpZ25hdHVyZSk7CisgICAgICAgIGZvciAobGV0IHR5cGVJbmRleCA9IDE7 IHR5cGVJbmRleCA8IHR5cGVzLmxlbmd0aDsgKyt0eXBlSW5kZXgpIHsKKyAgICAgICAgICAgIGNv bnN0IGJhZFBhcmFtU2lnbmF0dXJlID0geyBwYXJhbXM6IHNpZ25hdHVyZS5wYXJhbXMsIHJldDog c3dhcFR5cGUoc2lnbmF0dXJlLnJldCwgdHlwZUluZGV4KSB9OworICAgICAgICAgICAgY29uc3Qg aW1wb3J0ZXIgPSBtYWtlSW1wb3J0ZXIoYmFkUGFyYW1TaWduYXR1cmUpOworICAgICAgICAgICAg YXNzZXJ0LnRocm93cygoKSA9PiBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGlt cG9ydGVlKSwgV2ViQXNzZW1ibHkuTGlua0Vycm9yLCBgaW1wb3J0ZWQgZnVuY3Rpb24ncyBzaWdu YXR1cmUgbWlzbWF0Y2hlcyB0aGUgcHJvdmlkZWQgV2ViQXNzZW1ibHkgZnVuY3Rpb24ncyBzaWdu YXR1cmUgKGV2YWx1YXRpbmcgJ25ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1w b3J0ZWUpJylgKTsKKyAgICAgICAgfQorICAgIH0KK30pKCk7CmRpZmYgLS1naXQgYS9KU1Rlc3Rz L3dhc20vanMtYXBpL3dhc20tdG8td2FzbS5qcyBiL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10 by13YXNtLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjA4MjU1YzYKLS0t IC9kZXYvbnVsbAorKysgYi9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS5qcwpAQCAt MCwwICsxLDczIEBACitpbXBvcnQgKiBhcyBhc3NlcnQgZnJvbSAnLi4vYXNzZXJ0LmpzJzsKK2lt cG9ydCBCdWlsZGVyIGZyb20gJy4uL0J1aWxkZXIuanMnOworLyoKK2NvbnN0IGNhbGxlclRvcEJp dHMgPSAweEMwRkVCRUVGOworY29uc3QgaW5uZXJSZXR1cm5IaSA9IDB4REVBREZBQ0U7Citjb25z dCBpbm5lclJldHVybkxvID0gMHhDMEZFQzBGRTsKKworY29uc3QgY2FsbGVyTW9kdWxlID0gKCkg PT4geworICAgIGNvbnN0IGJ1aWxkZXIgPSAobmV3IEJ1aWxkZXIoKSkKKyAgICAgICAgLlR5cGUo KS5FbmQoKQorICAgICAgICAuSW1wb3J0KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigiZXhwb3J0 cyIsICJjYWxsTWUiLCB7IHBhcmFtczogWyJpNjQiXSwgcmV0OiAiaTY0IiB9KQorICAgICAgICAu RW5kKCkKKyAgICAgICAgLkZ1bmN0aW9uKCkuRW5kKCkKKyAgICAgICAgLkV4cG9ydCgpCisgICAg ICAgICAgICAuRnVuY3Rpb24oImVudHJ5IikKKyAgICAgICAgLkVuZCgpCisgICAgICAgIC5Db2Rl KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigiZW50cnkiLCB7IHBhcmFtczogWyJpMzIiXSwgcmV0 OiAiaTMyIiB9LCBbImk2NCJdKQorICAgICAgICAgICAgICAgIC5JMzJDb25zdChjYWxsZXJUb3BC aXRzKS5JNjRFeHRlbmRVSTMyKCkuSTMyQ29uc3QoMzIpLkk2NEV4dGVuZFVJMzIoKS5JNjRTaGwo KSAvLyAoKGk2NCljYWxsZXJUb3BCaXRzKSA8PCAzMgorICAgICAgICAgICAgICAgIC5HZXRMb2Nh bCgwKS5JNjRFeHRlbmRVSTMyKCkKKyAgICAgICAgICAgICAgICAuSTY0T3IoKSAvLyB2YWx1ZTog cGFyYW0gfCAoKChpNjQpY2FsbGVyVG9wQml0cyA8PCAzMikpCisgICAgICAgICAgICAgICAgLkNh bGwoMCkgLy8gQ2FsbHMgZXhwb3J0cy5jYWxsTWUocGFyYW0gfCAoKChpNjQpY2FsbGVyVG9wQml0 cykgPDwgMzIpKS4KKyAgICAgICAgICAgICAgICAuVGVlTG9jYWwoMSkuSTMyV3JhcEk2NCgpIC8v IGxvOiAoaTMyKWNhbGxSZXN1bHQKKyAgICAgICAgICAgICAgICAuR2V0TG9jYWwoMSkuSTMyQ29u c3QoMzIpLkk2NEV4dGVuZFVJMzIoKS5JNjRTaHJVKCkuSTMyV3JhcEk2NCgpIC8vIGhpOiAoaTMy KShjYWxsUmVzdWx0ID4+IDMyKQorICAgICAgICAgICAgICAgIC5JMzJYb3IoKQorICAgICAgICAg ICAgICAgIC5SZXR1cm4oKQorICAgICAgICAgICAgLkVuZCgpCisgICAgICAgIC5FbmQoKTsKKyAg ICByZXR1cm4gbmV3IFdlYkFzc2VtYmx5Lk1vZHVsZShidWlsZGVyLldlYkFzc2VtYmx5KCkuZ2V0 KCkpOworfTsKKworY29uc3QgY2FsbGVlTW9kdWxlID0gKCkgPT4geworICAgIGNvbnN0IGJ1aWxk ZXIgPSAobmV3IEJ1aWxkZXIoKSkKKyAgICAgICAgLlR5cGUoKS5FbmQoKQorICAgICAgICAuSW1w b3J0KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigiaW1wIiwgImZ1bmMiLCB7IHBhcmFtczogWyJp MzIiLCAiaTMyIl0sIHJldDogImkzMiIgfSkKKyAgICAgICAgLkVuZCgpCisgICAgICAgIC5GdW5j dGlvbigpLkVuZCgpCisgICAgICAgIC5FeHBvcnQoKQorICAgICAgICAgICAgLkZ1bmN0aW9uKCJj YWxsTWUiKQorICAgICAgICAuRW5kKCkKKyAgICAgICAgLkNvZGUoKQorICAgICAgICAgICAgLkZ1 bmN0aW9uKCJjYWxsTWUiLCB7IHBhcmFtczogWyJpNjQiXSwgcmV0OiAiaTY0IiB9KQorICAgICAg ICAgICAgICAgIC5HZXRMb2NhbCgwKS5JMzJXcmFwSTY0KCkgLy8gbG86IChpMzIpcGFyYW0KKyAg ICAgICAgICAgICAgICAuR2V0TG9jYWwoMCkuSTMyQ29uc3QoMzIpLkk2NEV4dGVuZFVJMzIoKS5J NjRTaHJVKCkuSTMyV3JhcEk2NCgpIC8vIGhpOiAoaTMyKShwYXJhbSA+PiAzMikKKyAgICAgICAg ICAgICAgICAuQ2FsbCgwKSAvLyBDYWxscyBpbXAuZnVuYyB3aXRoIHRoZSA2NC1iaXQgdmFsdWUg YXMgaTMyIHsgaGksIGxvIH0uCisgICAgICAgICAgICAgICAgLkRyb3AoKQorICAgICAgICAgICAg ICAgIC5JMzJDb25zdChpbm5lclJldHVybkhpKS5JNjRFeHRlbmRVSTMyKCkuSTMyQ29uc3QoMzIp Lkk2NEV4dGVuZFVJMzIoKS5JNjRTaGwoKS5JMzJDb25zdChpbm5lclJldHVybkxvKS5JNjRFeHRl bmRVSTMyKCkuSTY0T3IoKSAvLyAoKGk2NCloaSA8PCAzMikgfCAoaTY0KWxvCisgICAgICAgICAg ICAgICAgLlJldHVybigpCisgICAgICAgICAgICAuRW5kKCkKKyAgICAgICAgLkVuZCgpOworICAg IHJldHVybiBuZXcgV2ViQXNzZW1ibHkuTW9kdWxlKGJ1aWxkZXIuV2ViQXNzZW1ibHkoKS5nZXQo KSk7Cit9OworCisoZnVuY3Rpb24gV2FzbVRvV2FzbSgpIHsKKyAgICBsZXQgdmFsdWU7CisgICAg Y29uc3QgZnVuYyA9IChoaSwgbG8pID0+IHsgdmFsdWUgPSB7IGhpOiBoaSwgbG86IGxvIH07IHBy aW50KGAke0Vycm9yLnN0YWNrfWApOyByZXR1cm4gaGkgXiBsbzsgfTsKKyAgICBjb25zdCBjYWxs ZWUgPSBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoY2FsbGVlTW9kdWxlKCksIHsgaW1wOiB7IGZ1 bmM6IGZ1bmMgfSB9KTsKKyAgICBjb25zdCBjYWxsZXIgPSBuZXcgV2ViQXNzZW1ibHkuSW5zdGFu Y2UoY2FsbGVyTW9kdWxlKCksIGNhbGxlZSk7CisgICAgZm9yIChsZXQgaSA9IDA7IGkgPCA0MDk2 OyArK2kpIHsKKyAgICAgICAgYXNzZXJ0LmVxKGNhbGxlci5leHBvcnRzLmVudHJ5KGkpLCBpbm5l clJldHVybkhpIF4gaW5uZXJSZXR1cm5Mbyk7CisgICAgICAgIGFzc2VydC5lcSh2YWx1ZS5oaSwg Y2FsbGVyVG9wQml0cyk7CisgICAgICAgIGFzc2VydC5lcSh2YWx1ZS5sbywgaSk7CisgICAgfQor fSkoKTsKKworCisvLyBGSVhNRTogdGVzdCB3YXNtLT53YXNtIHVzaW5nIDMyLWJpdCB0aGluZ3Mg KGluY2x1ZGluZyBmbG9hdCksIGFzIHdlbGwgYXMgNjQtYml0IE5hTnMgdGhhdCBkb24ndCBnZXQg Y2Fub25pY2FsaXplZAorLy8gRklYTUU6IGRvIGEgdGhyb3cgdHdvLWRlZXAKKy8vIEZJWE1FOiBj aGVjayB0aGF0IHRoZSBmaXJzdCB3YXNtJ3MgaW5zdGFuY2UgaXMgYmFjayBpbiBPSyBzdGF0ZSAo d2l0aCB0YWJsZSBvciBnbG9iYWw/KQorLy8gRklYTUU6IHRlc3QgY2FsbGluZyB0aHJvdWdoIGEg VGFibGUKKyovCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvanNjLmNwcCBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9qc2MuY3BwCmluZGV4IDI5MjM4YTAuLmM1NjUyYTQgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9qc2MuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9qc2MuY3BwCkBAIC01NCw2ICs1NCw4IEBACiAjaW5jbHVkZSAiSlNTdHJpbmcuaCIK ICNpbmNsdWRlICJKU1R5cGVkQXJyYXlzLmgiCiAjaW5jbHVkZSAiSlNXZWJBc3NlbWJseUNhbGxl ZS5oIgorI2luY2x1ZGUgIkpTV2ViQXNzZW1ibHlJbnN0YW5jZS5oIgorI2luY2x1ZGUgIkpTV2Vi QXNzZW1ibHlNb2R1bGUuaCIKICNpbmNsdWRlICJMTEludERhdGEuaCIKICNpbmNsdWRlICJMTElu dFRodW5rcy5oIgogI2luY2x1ZGUgIk9iamVjdENvbnN0cnVjdG9yLmgiCkBAIC03MCw2ICs3Miw3 IEBACiAjaW5jbHVkZSAiVHlwZVByb2ZpbGVyTG9nLmgiCiAjaW5jbHVkZSAiV2FzbVBsYW4uaCIK ICNpbmNsdWRlICJXYXNtTWVtb3J5LmgiCisjaW5jbHVkZSAiV2ViQXNzZW1ibHlNb2R1bGVSZWNv cmQuaCIKICNpbmNsdWRlIDxsb2NhbGUuaD4KICNpbmNsdWRlIDxtYXRoLmg+CiAjaW5jbHVkZSA8 c3RkaW8uaD4KQEAgLTI2MDAsNiArMjYwMyw3IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0Nf SE9TVF9DQUxMIGZ1bmN0aW9uVGVzdFdhc21Nb2R1bGVGdW5jdGlvbnMoRXhlY1N0YXRlKiBlCiB7 CiAgICAgVk0mIHZtID0gZXhlYy0+dm0oKTsKICAgICBhdXRvIHNjb3BlID0gREVDTEFSRV9USFJP V19TQ09QRSh2bSk7CisgICAgYXV0byogZ2xvYmFsT2JqZWN0ID0gZXhlYy0+bGV4aWNhbEdsb2Jh bE9iamVjdCgpOwogCiAgICAgaWYgKCFPcHRpb25zOjp1c2VXZWJBc3NlbWJseSgpKQogICAgICAg ICByZXR1cm4gdGhyb3dWTVR5cGVFcnJvcihleGVjLCBzY29wZSwgQVNDSUlMaXRlcmFsKCJ0ZXN0 V2FzbU1vZHVsZSBzaG91bGQgb25seSBiZSBjYWxsZWQgaWYgdGhlIHVzZVdlYkFzc2VtYmx5IG9w dGlvbiBpcyBzZXQiKSk7CkBAIC0yNjMzLDE5ICsyNjM3LDI0IEBAIHN0YXRpYyBFbmNvZGVkSlNW YWx1ZSBKU0NfSE9TVF9DQUxMIGZ1bmN0aW9uVGVzdFdhc21Nb2R1bGVGdW5jdGlvbnMoRXhlY1N0 YXRlKiBlCiAgICAgICAgICAgICB9KTsKICAgICB9CiAKLSAgICB2b2lkKiBtZW1vcnlCeXRlcyA9 IG51bGxwdHI7Ci0gICAgdWludDMyX3QgbWVtb3J5U2l6ZSA9IDA7Ci0gICAgc3RkOjp1bmlxdWVf cHRyPFdhc206Ok1lbW9yeT4gbWVtb3J5OwotICAgIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1 bGVJbmZvcm1hdGlvbj4gbW9kdWxlSW5mb3JtYXRpb24gPSBwbGFuLnRha2VNb2R1bGVJbmZvcm1h dGlvbigpOworICAgIFN5bWJvbFRhYmxlKiBleHBvcnRTeW1ib2xUYWJsZSA9IFN5bWJvbFRhYmxl OjpjcmVhdGUodm0pOworICAgIGF1dG8qIG1vZHVsZVN0cnVjdHVyZSA9IEludGVybmFsRnVuY3Rp b246OmNyZWF0ZVN1YmNsYXNzU3RydWN0dXJlKGV4ZWMsIEpTVmFsdWUoKSwgZXhlYy0+bGV4aWNh bEdsb2JhbE9iamVjdCgpLT5XZWJBc3NlbWJseU1vZHVsZVN0cnVjdHVyZSgpKTsKKyAgICBSRVRV Uk5fSUZfRVhDRVBUSU9OKHNjb3BlLCBlbmNvZGVkSlNWYWx1ZSgpKTsKKyAgICBKU1dlYkFzc2Vt Ymx5TW9kdWxlKiBtb2R1bGUgPSBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGUodm0sIG1vZHVs ZVN0cnVjdHVyZSwgcGxhbi50YWtlTW9kdWxlSW5mb3JtYXRpb24oKSwgcGxhbi50YWtlQ2FsbExp bmtJbmZvcygpLCBwbGFuLnRha2VXYXNtRXhpdFN0dWJzKCksIGV4cG9ydFN5bWJvbFRhYmxlLCAw KTsKKyAgICBTdHJ1Y3R1cmUqIGluc3RhbmNlU3RydWN0dXJlID0gSW50ZXJuYWxGdW5jdGlvbjo6 Y3JlYXRlU3ViY2xhc3NTdHJ1Y3R1cmUoZXhlYywgSlNWYWx1ZSgpLCBnbG9iYWxPYmplY3QtPldl YkFzc2VtYmx5SW5zdGFuY2VTdHJ1Y3R1cmUoKSk7CisgICAgUkVUVVJOX0lGX0VYQ0VQVElPTihz Y29wZSwgZW5jb2RlZEpTVmFsdWUoKSk7CisgICAgSWRlbnRpZmllciBtb2R1bGVLZXkgPSBJZGVu dGlmaWVyOjpmcm9tVWlkKFByaXZhdGVOYW1lKFByaXZhdGVOYW1lOjpEZXNjcmlwdGlvbiwgIldl YkFzc2VtYmx5SW5zdGFuY2UiKSk7CisgICAgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQqIG1vZHVs ZVJlY29yZCA9IFdlYkFzc2VtYmx5TW9kdWxlUmVjb3JkOjpjcmVhdGUoZXhlYywgdm0sIGdsb2Jh bE9iamVjdC0+d2ViQXNzZW1ibHlNb2R1bGVSZWNvcmRTdHJ1Y3R1cmUoKSwgbW9kdWxlS2V5LCBt b2R1bGUtPm1vZHVsZUluZm9ybWF0aW9uKCkpOworICAgIFJFVFVSTl9JRl9FWENFUFRJT04oc2Nv cGUsIGVuY29kZWRKU1ZhbHVlKCkpOworICAgIEpTV2ViQXNzZW1ibHlJbnN0YW5jZSogaW5zdGFu Y2UgPSBKU1dlYkFzc2VtYmx5SW5zdGFuY2U6OmNyZWF0ZSh2bSwgaW5zdGFuY2VTdHJ1Y3R1cmUs IG1vZHVsZSwgbW9kdWxlUmVjb3JkLT5nZXRNb2R1bGVOYW1lc3BhY2UoZXhlYykpOworICAgIFJF VFVSTl9JRl9FWENFUFRJT04oc2NvcGUsIGVuY29kZWRKU1ZhbHVlKCkpOworICAgIHZtLnRvcEpT V2ViQXNzZW1ibHlJbnN0YW5jZSA9IGluc3RhbmNlOwogCi0gICAgaWYgKCEhbW9kdWxlSW5mb3Jt YXRpb24tPm1lbW9yeSkgewotICAgICAgICBtZW1vcnkgPSBzdGQ6Om1ha2VfdW5pcXVlPFdhc206 Ok1lbW9yeT4obW9kdWxlSW5mb3JtYXRpb24tPm1lbW9yeS5pbml0aWFsKCksIG1vZHVsZUluZm9y bWF0aW9uLT5tZW1vcnkubWF4aW11bSgpKTsKLSAgICAgICAgUkVMRUFTRV9BU1NFUlQobWVtb3J5 LT5pc1ZhbGlkKCkpOwotICAgICAgICBtZW1vcnlCeXRlcyA9IG1lbW9yeS0+bWVtb3J5KCk7Ci0g ICAgICAgIG1lbW9yeVNpemUgPSBtZW1vcnktPnNpemUoKTsKKyAgICBpZiAoISFtb2R1bGUtPm1v ZHVsZUluZm9ybWF0aW9uKCkubWVtb3J5KSB7CisgICAgICAgIFdhc206Ok1lbW9yeSBtZW1vcnko bW9kdWxlLT5tb2R1bGVJbmZvcm1hdGlvbigpLm1lbW9yeS5pbml0aWFsKCksIG1vZHVsZS0+bW9k dWxlSW5mb3JtYXRpb24oKS5tZW1vcnkubWF4aW11bSgpKTsKKyAgICAgICAgUkVMRUFTRV9BU1NF UlQobWVtb3J5LmlzVmFsaWQoKSk7CisgICAgICAgIGluc3RhbmNlLT5zZXRNZW1vcnkodm0sIEpT V2ViQXNzZW1ibHlNZW1vcnk6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LT5XZWJBc3NlbWJseU1l bW9yeVN0cnVjdHVyZSgpLCBXVEZNb3ZlKG1lbW9yeSkpKTsKICAgICB9Ci0gICAgdm0udG9wV2Fz bU1lbW9yeVBvaW50ZXIgPSBtZW1vcnlCeXRlczsKLSAgICB2bS50b3BXYXNtTWVtb3J5U2l6ZSA9 IG1lbW9yeVNpemU7CiAKICAgICBmb3IgKHVpbnQzMl90IGkgPSAwOyBpIDwgZnVuY3Rpb25Db3Vu dDsgKytpKSB7CiAgICAgICAgIEpTQXJyYXkqIHRlc3RDYXNlcyA9IGpzQ2FzdDxKU0FycmF5Kj4o ZXhlYy0+YXJndW1lbnQoaSArIDIpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9ydW50aW1lL0pTVHlwZS5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBl LmgKaW5kZXggMDUyMDJmMy4uYWM1MDlkNyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3J1bnRpbWUvSlNUeXBlLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUv SlNUeXBlLmgKQEAgLTkzLDYgKzkzLDggQEAgZW51bSBKU1R5cGUgOiB1aW50OF90IHsKICAgICBK U01hcFR5cGUsCiAgICAgSlNTZXRUeXBlLAogCisgICAgV2ViQXNzZW1ibHlGdW5jdGlvblR5cGUs CisKICAgICBMYXN0SlNDT2JqZWN0VHlwZSA9IEpTU2V0VHlwZSwKICAgICBNYXhKU1R5cGUgPSAw YjExMTExMTExLAogfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L1ZNLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9WTS5oCmluZGV4IGYzNDBlOTYu LjBjYjYyYzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZNLmgK KysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVk0uaApAQCAtMzAxLDggKzMwMSw2 IEBAIHB1YmxpYzoKICAgICAvLyBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTYwNDQxCiAgICAgRXhlY1N0YXRlKiB0b3BDYWxsRnJhbWU7CiAgICAgSlNXZWJBc3NlbWJs eUluc3RhbmNlKiB0b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2U7Ci0gICAgdm9pZCogdG9wV2FzbU1l bW9yeVBvaW50ZXI7Ci0gICAgdWludDMyX3QgdG9wV2FzbU1lbW9yeVNpemU7CiAgICAgU3Ryb25n PFN0cnVjdHVyZT4gc3RydWN0dXJlU3RydWN0dXJlOwogICAgIFN0cm9uZzxTdHJ1Y3R1cmU+IHN0 cnVjdHVyZVJhcmVEYXRhU3RydWN0dXJlOwogICAgIFN0cm9uZzxTdHJ1Y3R1cmU+IHRlcm1pbmF0 ZWRFeGVjdXRpb25FcnJvclN0cnVjdHVyZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcAppbmRleCAyMmM2ZTg1Li5lMTY1YTI2IDEwMDY0NAot LS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5jcHAKKysr IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuY3BwCkBAIC0x NTUsNyArMTU1LDcgQEAgcHVibGljOgogICAgICAgICAgICAgcmV0dXJuIGZhaWwoX19WQV9BUkdT X18pOyAgICAgICAgICAgICBcCiAgICAgfSB3aGlsZSAoMCkKIAotICAgIEIzSVJHZW5lcmF0b3Io Vk0mLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYsIFByb2NlZHVyZSYsIFdhc21JbnRlcm5hbEZ1 bmN0aW9uKiwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+JiwgY29uc3QgSW1tdXRhYmxl RnVuY3Rpb25JbmRleFNwYWNlJik7CisgICAgQjNJUkdlbmVyYXRvcihWTSYsIGNvbnN0IE1vZHVs ZUluZm9ybWF0aW9uJiwgUHJvY2VkdXJlJiwgV2FzbUludGVybmFsRnVuY3Rpb24qLCBWZWN0b3I8 VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mKTsKIAogICAgIFBhcnRpYWxSZXN1bHQgV0FSTl9VTlVT RURfUkVUVVJOIGFkZEFyZ3VtZW50cyhjb25zdCBTaWduYXR1cmUqKTsKICAgICBQYXJ0aWFsUmVz dWx0IFdBUk5fVU5VU0VEX1JFVFVSTiBhZGRMb2NhbChUeXBlLCB1aW50MzJfdCk7CkBAIC0yMTMs NyArMjEzLDYgQEAgcHJpdmF0ZToKICAgICBWYWx1ZSogemVyb0ZvclR5cGUoVHlwZSk7CiAKICAg ICBWTSYgbV92bTsKLSAgICBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIG1fZnVu Y3Rpb25JbmRleFNwYWNlOwogICAgIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBtX2luZm87CiAg ICAgUHJvY2VkdXJlJiBtX3Byb2M7CiAgICAgQmFzaWNCbG9jayogbV9jdXJyZW50QmxvY2s7CkBA IC0yMjUsOSArMjI0LDggQEAgcHJpdmF0ZToKICAgICBWYWx1ZSogbV9pbnN0YW5jZVZhbHVlOwog fTsKIAotQjNJUkdlbmVyYXRvcjo6QjNJUkdlbmVyYXRvcihWTSYgdm0sIGNvbnN0IE1vZHVsZUlu Zm9ybWF0aW9uJiBpbmZvLCBQcm9jZWR1cmUmIHByb2NlZHVyZSwgV2FzbUludGVybmFsRnVuY3Rp b24qIGNvbXBpbGF0aW9uLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mIHVubGlua2Vk V2FzbVRvV2FzbUNhbGxzLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIGZ1bmN0 aW9uSW5kZXhTcGFjZSkKK0IzSVJHZW5lcmF0b3I6OkIzSVJHZW5lcmF0b3IoVk0mIHZtLCBjb25z dCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgUHJvY2VkdXJlJiBwcm9jZWR1cmUsIFdhc21JbnRl cm5hbEZ1bmN0aW9uKiBjb21waWxhdGlvbiwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+ JiB1bmxpbmtlZFdhc21Ub1dhc21DYWxscykKICAgICA6IG1fdm0odm0pCi0gICAgLCBtX2Z1bmN0 aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4U3BhY2UpCiAgICAgLCBtX2luZm8oaW5mbykKICAg ICAsIG1fcHJvYyhwcm9jZWR1cmUpCiAgICAgLCBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzKHVu bGlua2VkV2FzbVRvV2FzbUNhbGxzKQpAQCAtMjY5LDYgKzI2Nyw0MSBAQCBCM0lSR2VuZXJhdG9y OjpCM0lSR2VuZXJhdG9yKFZNJiB2bSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFBy b2NlZHVyZSYgcAogICAgICAgICBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFs dWU+KG1fcHJvYywgT3JpZ2luKCksICZtX3ZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZSkpOwog fQogCitzdGF0aWMgdm9pZCByZXN0b3JlV2ViQXNzZW1ibHlHbG9iYWxTdGF0ZShWTSYgdm0sIGNv bnN0IE1lbW9yeUluZm9ybWF0aW9uJiBtZW1vcnksIFZhbHVlKiBpbnN0YW5jZSwgUHJvY2VkdXJl JiBwcm9jLCBCYXNpY0Jsb2NrKiBibG9jaykKK3sKKyAgICBibG9jay0+YXBwZW5kTmV3PE1lbW9y eVZhbHVlPihwcm9jLCBTdG9yZSwgT3JpZ2luKCksIGluc3RhbmNlLCBibG9jay0+YXBwZW5kTmV3 PENvbnN0UHRyVmFsdWU+KHByb2MsIE9yaWdpbigpLCAmdm0udG9wSlNXZWJBc3NlbWJseUluc3Rh bmNlKSk7CisKKyAgICBpZiAoISFtZW1vcnkpIHsKKyAgICAgICAgVmFsdWUqIG1lbW9yeU9iamVj dCA9IGJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KHByb2MsIExvYWQsIHBvaW50ZXJUeXBl KCksIE9yaWdpbigpLCBpbnN0YW5jZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlOjpvZmZzZXRPZk1l bW9yeSgpKTsKKworICAgICAgICBzdGF0aWNfYXNzZXJ0KHNpemVvZihkZWNsdHlwZSh2bS50b3BK U1dlYkFzc2VtYmx5SW5zdGFuY2UtPm1lbW9yeSgpLT5tZW1vcnkoKS0+bWVtb3J5KCkpKSA9PSBz aXplb2Yodm9pZCopLCAiY29kZWdlbiByZWxpZXMgb24gdGhpcyBzaXplIik7CisgICAgICAgIHN0 YXRpY19hc3NlcnQoc2l6ZW9mKGRlY2x0eXBlKHZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZS0+ bWVtb3J5KCktPm1lbW9yeSgpLT5zaXplKCkpKSA9PSBzaXplb2YodWludDMyX3QpLCAiY29kZWdl biByZWxpZXMgb24gdGhpcyBzaXplIik7CisgICAgICAgIFZhbHVlKiBiYXNlTWVtb3J5ID0gYmxv Y2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4ocHJvYywgTG9hZCwgcG9pbnRlclR5cGUoKSwgT3Jp Z2luKCksIG1lbW9yeU9iamVjdCwgSlNXZWJBc3NlbWJseU1lbW9yeTo6b2Zmc2V0T2ZNZW1vcnko KSk7CisgICAgICAgIFZhbHVlKiBtZW1vcnlTaXplID0gYmxvY2stPmFwcGVuZE5ldzxNZW1vcnlW YWx1ZT4ocHJvYywgTG9hZCwgSW50MzIsIE9yaWdpbigpLCBtZW1vcnlPYmplY3QsIEpTV2ViQXNz ZW1ibHlNZW1vcnk6Om9mZnNldE9mU2l6ZSgpKTsKKworICAgICAgICBWZWN0b3I8VmFsdWUqPiBh cmd1bWVudHM7CisgICAgICAgIGFyZ3VtZW50cy5yZXNlcnZlQ2FwYWNpdHkoMSArIG1lbW9yeS5w aW5uZWRSZWdpc3RlcnMoKS5zaXplUmVnaXN0ZXJzLnNpemUoKSk7CisgICAgICAgIGFyZ3VtZW50 cy5hcHBlbmQoYmFzZU1lbW9yeSk7CisgICAgICAgIGZvciAoYXV0byBpbmZvIDogbWVtb3J5LnBp bm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnMpIHsKKyAgICAgICAgICAgIFZhbHVlKiBzaXpl VmFsdWUgPSBibG9jay0+YXBwZW5kTmV3PFZhbHVlPihwcm9jLCBTdWIsIE9yaWdpbigpLCBtZW1v cnlTaXplLCBibG9jay0+YXBwZW5kTmV3PENvbnN0MzJWYWx1ZT4ocHJvYywgT3JpZ2luKCksIGlu Zm8uc2l6ZU9mZnNldCkpOworICAgICAgICAgICAgYXJndW1lbnRzLmFwcGVuZChzaXplVmFsdWUp OworICAgICAgICB9CisKKyAgICAgICAgQjM6OlBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCA9 IGJsb2NrLT5hcHBlbmROZXc8QjM6OlBhdGNocG9pbnRWYWx1ZT4ocHJvYywgQjM6OlZvaWQsIE9y aWdpbigpKTsKKyAgICAgICAgcGF0Y2hwb2ludC0+ZWZmZWN0cyA9IEVmZmVjdHM6Om5vbmUoKTsK KyAgICAgICAgcGF0Y2hwb2ludC0+ZWZmZWN0cy53cml0ZXNQaW5uZWQgPSB0cnVlOworICAgICAg ICBwYXRjaHBvaW50LT5hcHBlbmRWZWN0b3JXaXRoUmVwKGFyZ3VtZW50cywgVmFsdWVSZXA6OlNv bWVSZWdpc3Rlcik7CisKKyAgICAgICAgcGF0Y2hwb2ludC0+c2V0R2VuZXJhdG9yKFttZW1vcnld IChDQ2FsbEhlbHBlcnMmIGppdCwgY29uc3QgQjM6OlN0YWNrbWFwR2VuZXJhdGlvblBhcmFtcyYg cGFyYW1zKSB7CisgICAgICAgICAgICBBbGxvd01hY3JvU2NyYXRjaFJlZ2lzdGVyVXNhZ2UgYWxs b3dTY3JhdGNoKGppdCk7CisKKyAgICAgICAgICAgIGppdC5tb3ZlKHBhcmFtc1swXS5ncHIoKSwg bWVtb3J5LnBpbm5lZFJlZ2lzdGVycygpLmJhc2VNZW1vcnlQb2ludGVyKTsKKyAgICAgICAgICAg IGZvciAodWludDMyX3QgaSA9IDA7IGkgPCBtZW1vcnkucGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJl Z2lzdGVycy5zaXplKCk7ICsraSkKKyAgICAgICAgICAgICAgICBqaXQubW92ZShwYXJhbXNbMSAr IGldLmdwcigpLCBtZW1vcnkucGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVyc1tpXS5zaXpl UmVnaXN0ZXIpOworICAgICAgICB9KTsKKyAgICB9Cit9CisKIHZvaWQgQjNJUkdlbmVyYXRvcjo6 ZW1pdEV4Y2VwdGlvbkNoZWNrKENDYWxsSGVscGVycyYgaml0LCBFeGNlcHRpb25UeXBlIHR5cGUp CiB7CiAgICAgaml0Lm1vdmUoQ0NhbGxIZWxwZXJzOjpUcnVzdGVkSW1tMzIoc3RhdGljX2Nhc3Q8 dWludDMyX3Q+KHR5cGUpKSwgR1BSSW5mbzo6YXJndW1lbnRHUFIxKTsKQEAgLTY5MiwyMyArNzI1 LDc5IEBAIGF1dG8gQjNJUkdlbmVyYXRvcjo6YWRkQ2FsbCh1aW50MzJfdCBmdW5jdGlvbkluZGV4 LCBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSwKICAgICBBU1NFUlQoc2lnbmF0dXJlLT5hcmd1 bWVudENvdW50KCkgPT0gYXJncy5zaXplKCkpOwogCiAgICAgVHlwZSByZXR1cm5UeXBlID0gc2ln bmF0dXJlLT5yZXR1cm5UeXBlKCk7CisgICAgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+ KiB1bmxpbmtlZFdhc21Ub1dhc21DYWxscyA9ICZtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzOwog Ci0gICAgcmVzdWx0ID0gd2FzbUNhbGxpbmdDb252ZW50aW9uKCkuc2V0dXBDYWxsKG1fcHJvYywg bV9jdXJyZW50QmxvY2ssIE9yaWdpbigpLCBhcmdzLCB0b0IzVHlwZShyZXR1cm5UeXBlKSwKLSAg ICAgICAgWyZdIChQYXRjaHBvaW50VmFsdWUqIHBhdGNocG9pbnQpIHsKLSAgICAgICAgICAgIHBh dGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKLSAgICAgICAgICAgIHBhdGNo cG9pbnQtPmVmZmVjdHMucmVhZHNQaW5uZWQgPSB0cnVlOworICAgIGlmIChtX2luZm8uaXNJbXBv cnRlZEZ1bmN0aW9uRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KSkgeworICAg ICAgICAvLyBGSVhNRSBpbXBvcnRzIGNhbiBiZSBsaW5rZWQgaGVyZSwgaW5zdGVhZCBvZiBnZW5l cmF0aW5nIGEgcGF0Y2hwb2ludCwgYmVjYXVzZSBhbGwgaW1wb3J0IHN0dWJzIGFyZSBnZW5lcmF0 ZWQgYmVmb3JlIEIzIGNvbXBpbGF0aW9uIHN0YXJ0cy4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE2NjQ2MgorICAgICAgICBFeHByZXNzaW9uVHlwZSBmdW5jdGlvbklt cG9ydCA9IG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KG1fcHJvYywgTG9h ZCwgcG9pbnRlclR5cGUoKSwgT3JpZ2luKCksIG1faW5zdGFuY2VWYWx1ZSwgSlNXZWJBc3NlbWJs eUluc3RhbmNlOjpvZmZzZXRPZkltcG9ydEZ1bmN0aW9uKGZ1bmN0aW9uSW5kZXgpKTsKKyAgICAg ICAgRXhwcmVzc2lvblR5cGUganNUeXBlT2ZJbXBvcnQgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5k TmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQ4WiwgT3JpZ2luKCksIGZ1bmN0aW9uSW1wb3J0 LCBKU0NlbGw6OnR5cGVJbmZvVHlwZU9mZnNldCgpKTsKKyAgICAgICAgVmFsdWUqIGlzV2FzbUNh bGwgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PFZhbHVlPihtX3Byb2MsIEVxdWFsLCBPcmln aW4oKSwganNUeXBlT2ZJbXBvcnQsIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8Q29uc3QzMlZh bHVlPihtX3Byb2MsIE9yaWdpbigpLCBXZWJBc3NlbWJseUZ1bmN0aW9uVHlwZSkpOwogCi0gICAg ICAgICAgICBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4qIHVubGlua2VkV2FzbVRvV2Fz bUNhbGxzID0gJm1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHM7Ci0gICAgICAgICAgICBwYXRjaHBv aW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4 XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMm KSB7Ci0gICAgICAgICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93 U2NyYXRjaChqaXQpOworICAgICAgICBCYXNpY0Jsb2NrKiBpc1dhc21CbG9jayA9IG1fcHJvYy5h ZGRCbG9jaygpOworICAgICAgICBCYXNpY0Jsb2NrKiBpc0pTQmxvY2sgPSBtX3Byb2MuYWRkQmxv Y2soKTsKKyAgICAgICAgQmFzaWNCbG9jayogY29udGludWF0aW9uID0gbV9wcm9jLmFkZEJsb2Nr KCk7CisgICAgICAgIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXdDb250cm9sVmFsdWUobV9wcm9j LCBCMzo6QnJhbmNoLCBPcmlnaW4oKSwgaXNXYXNtQ2FsbCwgRnJlcXVlbnRlZEJsb2NrKGlzV2Fz bUJsb2NrKSwgRnJlcXVlbnRlZEJsb2NrKGlzSlNCbG9jaykpOworCisgICAgICAgIFZhbHVlKiB3 YXNtQ2FsbFJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigpLnNldHVwQ2FsbChtX3Byb2Ms IGlzV2FzbUJsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0dXJuVHlwZSksCisgICAg ICAgICAgICBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkgeworICAgICAgICAgICAg ICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAg ICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAg ICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBm dW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVy YXRpb25QYXJhbXMmKSB7CisgICAgICAgICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVn aXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAgICAgICAgICAgICAgQ0NhbGxI ZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICAgICAgICAgICAgICBqaXQu YWRkTGlua1Rhc2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4 XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZlcikgeworICAgICAgICAgICAgICAgICAgICAgICAgYm9v bCB0b0pTID0gZmFsc2U7IC8vIE1heWJlIGV4dGVybmFsIHdhc20gLT4gd2FzbS4KKyAgICAgICAg ICAgICAgICAgICAgICAgIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLT5hcHBlbmQoeyBsaW5rQnVm ZmVyLmxvY2F0aW9uT2YoY2FsbCksIGZ1bmN0aW9uSW5kZXgsIHRvSlMgfSk7CisgICAgICAgICAg ICAgICAgICAgIH0pOworICAgICAgICAgICAgICAgIH0pOworICAgICAgICAgICAgfSk7CisgICAg ICAgIFVwc2lsb25WYWx1ZSogd2FzbUNhbGxSZXN1bHRVcHNpbG9uID0gcmV0dXJuVHlwZSA9PSBW b2lkID8gbnVsbHB0ciA6IGlzV2FzbUJsb2NrLT5hcHBlbmROZXc8VXBzaWxvblZhbHVlPihtX3By b2MsIE9yaWdpbigpLCB3YXNtQ2FsbFJlc3VsdCk7CisgICAgICAgIGlzV2FzbUJsb2NrLT5hcHBl bmROZXdDb250cm9sVmFsdWUobV9wcm9jLCBKdW1wLCBPcmlnaW4oKSwgY29udGludWF0aW9uKTsK KworICAgICAgICBWYWx1ZSoganNDYWxsUmVzdWx0ID0gd2FzbUNhbGxpbmdDb252ZW50aW9uKCku c2V0dXBDYWxsKG1fcHJvYywgaXNKU0Jsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0 dXJuVHlwZSksCisgICAgICAgICAgICBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkg eworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1 ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1 ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2Fz bVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIz OjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7CisgICAgICAgICAgICAgICAgICAgIEFsbG93 TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAgICAg ICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICAg ICAgICAgICAgICBqaXQuYWRkTGlua1Rhc2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjYWxs LCBmdW5jdGlvbkluZGV4XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZlcikgeworICAgICAgICAgICAg ICAgICAgICAgICAgYm9vbCB0b0pTID0gdHJ1ZTsgLy8gRXh0ZXJuYWwgd2FzbSAtPiBKUy4KKyAg ICAgICAgICAgICAgICAgICAgICAgIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLT5hcHBlbmQoeyBs aW5rQnVmZmVyLmxvY2F0aW9uT2YoY2FsbCksIGZ1bmN0aW9uSW5kZXgsIHRvSlMgfSk7CisgICAg ICAgICAgICAgICAgICAgIH0pOworICAgICAgICAgICAgICAgIH0pOworICAgICAgICAgICAgfSk7 CisgICAgICAgIFVwc2lsb25WYWx1ZSoganNDYWxsUmVzdWx0VXBzaWxvbiA9IHJldHVyblR5cGUg PT0gVm9pZCA/IG51bGxwdHIgOiBpc0pTQmxvY2stPmFwcGVuZE5ldzxVcHNpbG9uVmFsdWU+KG1f cHJvYywgT3JpZ2luKCksIGpzQ2FsbFJlc3VsdCk7CisgICAgICAgIGlzSlNCbG9jay0+YXBwZW5k TmV3Q29udHJvbFZhbHVlKG1fcHJvYywgSnVtcCwgT3JpZ2luKCksIGNvbnRpbnVhdGlvbik7CiAK LSAgICAgICAgICAgICAgICBDQ2FsbEhlbHBlcnM6OkNhbGwgY2FsbCA9IGppdC5jYWxsKCk7Cisg ICAgICAgIG1fY3VycmVudEJsb2NrID0gY29udGludWF0aW9uOworCisgICAgICAgIGlmIChyZXR1 cm5UeXBlID09IFZvaWQpCisgICAgICAgICAgICByZXN1bHQgPSBudWxscHRyOworICAgICAgICBl bHNlIHsKKyAgICAgICAgICAgIHJlc3VsdCA9IGNvbnRpbnVhdGlvbi0+YXBwZW5kTmV3PFZhbHVl PihtX3Byb2MsIFBoaSwgdG9CM1R5cGUocmV0dXJuVHlwZSksIE9yaWdpbigpKTsKKyAgICAgICAg ICAgIHdhc21DYWxsUmVzdWx0VXBzaWxvbi0+c2V0UGhpKHJlc3VsdCk7CisgICAgICAgICAgICBq c0NhbGxSZXN1bHRVcHNpbG9uLT5zZXRQaGkocmVzdWx0KTsKKyAgICAgICAgfQogCi0gICAgICAg ICAgICAgICAgaml0LmFkZExpbmtUYXNrKFt1bmxpbmtlZFdhc21Ub1dhc21DYWxscywgY2FsbCwg ZnVuY3Rpb25JbmRleF0gKExpbmtCdWZmZXImIGxpbmtCdWZmZXIpIHsKLSAgICAgICAgICAgICAg ICAgICAgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZmZXIubG9jYXRp b25PZihjYWxsKSwgZnVuY3Rpb25JbmRleCB9KTsKKyAgICAgICAgLy8gVGhlIGNhbGwgY291bGQg aGF2ZSBiZWVuIHRvIGFub3RoZXIgV2ViQXNzZW1ibHkgaW5zdGFuY2UsIGFuZCAvIG9yIGNvdWxk IGhhdmUgbW9kaWZpZWQgb3VyIE1lbW9yeS4KKyAgICAgICAgcmVzdG9yZVdlYkFzc2VtYmx5R2xv YmFsU3RhdGUobV92bSwgbV9pbmZvLm1lbW9yeSwgbV9pbnN0YW5jZVZhbHVlLCBtX3Byb2MsIGNv bnRpbnVhdGlvbik7CisgICAgfSBlbHNlIHsKKyAgICAgICAgcmVzdWx0ID0gd2FzbUNhbGxpbmdD b252ZW50aW9uKCkuc2V0dXBDYWxsKG1fcHJvYywgbV9jdXJyZW50QmxvY2ssIE9yaWdpbigpLCBh cmdzLCB0b0IzVHlwZShyZXR1cm5UeXBlKSwKKyAgICAgICAgICAgIFsmXSAoUGF0Y2hwb2ludFZh bHVlKiBwYXRjaHBvaW50KSB7CisgICAgICAgICAgICAgICAgcGF0Y2hwb2ludC0+ZWZmZWN0cy53 cml0ZXNQaW5uZWQgPSB0cnVlOworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMu cmVhZHNQaW5uZWQgPSB0cnVlOworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPnNldEdlbmVy YXRvcihbdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGZ1bmN0aW9uSW5kZXhdIChDQ2FsbEhlbHBl cnMmIGppdCwgY29uc3QgQjM6OlN0YWNrbWFwR2VuZXJhdGlvblBhcmFtcyYpIHsKKyAgICAgICAg ICAgICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93U2NyYXRjaChq aXQpOworICAgICAgICAgICAgICAgICAgICBDQ2FsbEhlbHBlcnM6OkNhbGwgY2FsbCA9IGppdC5j YWxsKCk7CisgICAgICAgICAgICAgICAgICAgIGppdC5hZGRMaW5rVGFzayhbdW5saW5rZWRXYXNt VG9XYXNtQ2FsbHMsIGNhbGwsIGZ1bmN0aW9uSW5kZXhdIChMaW5rQnVmZmVyJiBsaW5rQnVmZmVy KSB7CisgICAgICAgICAgICAgICAgICAgICAgICBib29sIHRvSlMgPSBmYWxzZTsgLy8gSW50ZXJu YWwgd2FzbSAtPiB3YXNtLgorICAgICAgICAgICAgICAgICAgICAgICAgdW5saW5rZWRXYXNtVG9X YXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZmZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rpb25J bmRleCwgdG9KUyB9KTsKKyAgICAgICAgICAgICAgICAgICAgfSk7CiAgICAgICAgICAgICAgICAg fSk7CiAgICAgICAgICAgICB9KTsKLSAgICAgICAgfSk7CisgICAgfQorCiAgICAgcmV0dXJuIHsg fTsKIH0KIApAQCAtNzg1LDYgKzg3NCw5IEBAIGF1dG8gQjNJUkdlbmVyYXRvcjo6YWRkQ2FsbElu ZGlyZWN0KGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBTaWduYXR1cmVJbmRleCBzCiAgICAg ICAgICAgICB9KTsKICAgICAgICAgfSk7CiAKKyAgICAvLyBUaGUgY2FsbCBjb3VsZCBoYXZlIGJl ZW4gdG8gYW5vdGhlciBXZWJBc3NlbWJseSBpbnN0YW5jZSwgYW5kIC8gb3IgY291bGQgaGF2ZSBt b2RpZmllZCBvdXIgTWVtb3J5LgorICAgIHJlc3RvcmVXZWJBc3NlbWJseUdsb2JhbFN0YXRlKG1f dm0sIG1faW5mby5tZW1vcnksIG1faW5zdGFuY2VWYWx1ZSwgbV9wcm9jLCBtX2N1cnJlbnRCbG9j ayk7CisKICAgICByZXR1cm4geyB9OwogfQogCkBAIC04NTQsMjAgKzk0NiwxMCBAQCBzdGF0aWMg dm9pZCBjcmVhdGVKU1RvV2FzbVdyYXBwZXIoVk0mIHZtLCBDb21waWxhdGlvbkNvbnRleHQmIGNv bXBpbGF0aW9uQ29udGV4dAogICAgICAgICB9KTsKICAgICB9CiAKLSAgICAvLyBNb3ZlIG1lbW9y eSB2YWx1ZXMgdG8gdGhlIGFwcHJvcmlhdGUgcGxhY2VzLCBpZiBuZWVkZWQuCi0gICAgVmFsdWUq IGJhc2VNZW1vcnkgPSBudWxscHRyOwotICAgIFZlY3RvcjxWYWx1ZSo+IHNpemVzOwotICAgIGlm ICghIW1lbW9yeSkgewotICAgICAgICBiYXNlTWVtb3J5ID0gYmxvY2stPmFwcGVuZE5ldzxNZW1v cnlWYWx1ZT4ocHJvYywgTG9hZCwgSW50NjQsIE9yaWdpbigpLAotICAgICAgICAgICAgYmxvY2st PmFwcGVuZE5ldzxDb25zdFB0clZhbHVlPihwcm9jLCBPcmlnaW4oKSwgJnZtLnRvcFdhc21NZW1v cnlQb2ludGVyKSk7Ci0gICAgICAgIFZhbHVlKiBzaXplID0gYmxvY2stPmFwcGVuZE5ldzxNZW1v cnlWYWx1ZT4ocHJvYywgTG9hZCwgSW50MzIsIE9yaWdpbigpLAotICAgICAgICAgICAgYmxvY2st PmFwcGVuZE5ldzxDb25zdFB0clZhbHVlPihwcm9jLCBPcmlnaW4oKSwgJnZtLnRvcFdhc21NZW1v cnlTaXplKSk7Ci0gICAgICAgIHNpemVzLnJlc2VydmVDYXBhY2l0eShtZW1vcnkucGlubmVkUmVn aXN0ZXJzKCkuc2l6ZVJlZ2lzdGVycy5zaXplKCkpOwotICAgICAgICBmb3IgKGF1dG8gaW5mbyA6 IG1lbW9yeS5waW5uZWRSZWdpc3RlcnMoKS5zaXplUmVnaXN0ZXJzKSB7Ci0gICAgICAgICAgICBz aXplcy5hcHBlbmQoYmxvY2stPmFwcGVuZE5ldzxWYWx1ZT4ocHJvYywgU3ViLCBvcmlnaW4sIHNp emUsCi0gICAgICAgICAgICAgICAgYmxvY2stPmFwcGVuZE5ldzxDb25zdDMyVmFsdWU+KHByb2Ms IG9yaWdpbiwgaW5mby5zaXplT2Zmc2V0KSkpOwotICAgICAgICB9Ci0gICAgfQorICAgIC8vIEZJ WE1FIFRoZSBpbnN0YW5jZSBpcyBjdXJyZW50bHkgc2V0IGJ5IHRoZSBDKysgY29kZSBpbiBXZWJB c3NlbWJseUZ1bmN0aW9uOjpjYWxsLiBXZSBzaG91bGRuJ3QgZ28gdGhyb3VnaCB0aGUgZXh0cmEg QysrIGhvb3AuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjY0ODYK KyAgICBWYWx1ZSogaW5zdGFuY2UgPSBibG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihwcm9j LCBMb2FkLCBwb2ludGVyVHlwZSgpLCBPcmlnaW4oKSwKKyAgICAgICAgYmxvY2stPmFwcGVuZE5l dzxDb25zdFB0clZhbHVlPihwcm9jLCBPcmlnaW4oKSwgJnZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0 YW5jZSkpOworICAgIHJlc3RvcmVXZWJBc3NlbWJseUdsb2JhbFN0YXRlKHZtLCBtZW1vcnksIGlu c3RhbmNlLCBwcm9jLCBibG9jayk7CiAKICAgICAvLyBHZXQgb3VyIGFyZ3VtZW50cy4KICAgICBW ZWN0b3I8VmFsdWUqPiBhcmd1bWVudHM7CkBAIC04NzcsMTMgKzk1OSw2IEBAIHN0YXRpYyB2b2lk IGNyZWF0ZUpTVG9XYXNtV3JhcHBlcihWTSYgdm0sIENvbXBpbGF0aW9uQ29udGV4dCYgY29tcGls YXRpb25Db250ZXh0CiAKICAgICAvLyBNb3ZlIHRoZSBhcmd1bWVudHMgaW50byBwbGFjZS4KICAg ICBWYWx1ZSogcmVzdWx0ID0gd2FzbUNhbGxpbmdDb252ZW50aW9uKCkuc2V0dXBDYWxsKHByb2Ms IGJsb2NrLCBvcmlnaW4sIGFyZ3VtZW50cywgdG9CM1R5cGUoc2lnbmF0dXJlLT5yZXR1cm5UeXBl KCkpLCBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkgewotICAgICAgICBpZiAoISFt ZW1vcnkpIHsKLSAgICAgICAgICAgIEFTU0VSVChzaXplcy5zaXplKCkgPT0gbWVtb3J5LnBpbm5l ZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnMuc2l6ZSgpKTsKLSAgICAgICAgICAgIHBhdGNocG9p bnQtPmFwcGVuZChDb25zdHJhaW5lZFZhbHVlKGJhc2VNZW1vcnksIFZhbHVlUmVwOjpyZWcobWVt b3J5LnBpbm5lZFJlZ2lzdGVycygpLmJhc2VNZW1vcnlQb2ludGVyKSkpOwotICAgICAgICAgICAg Zm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHNpemVzLnNpemUoKTsgKytpKQotICAgICAgICAgICAg ICAgIHBhdGNocG9pbnQtPmFwcGVuZChDb25zdHJhaW5lZFZhbHVlKHNpemVzW2ldLCBWYWx1ZVJl cDo6cmVnKG1lbW9yeS5waW5uZWRSZWdpc3RlcnMoKS5zaXplUmVnaXN0ZXJzW2ldLnNpemVSZWdp c3RlcikpKTsKLSAgICAgICAgfQotCiAgICAgICAgIENvbXBpbGF0aW9uQ29udGV4dCogY29udGV4 dCA9ICZjb21waWxhdGlvbkNvbnRleHQ7CiAgICAgICAgIHBhdGNocG9pbnQtPnNldEdlbmVyYXRv cihbY29udGV4dF0gKENDYWxsSGVscGVycyYgaml0LCBjb25zdCBCMzo6U3RhY2ttYXBHZW5lcmF0 aW9uUGFyYW1zJikgewogICAgICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdl IGFsbG93U2NyYXRjaChqaXQpOwpAQCAtOTE3LDcgKzk5Miw3IEBAIHN0YXRpYyB2b2lkIGNyZWF0 ZUpTVG9XYXNtV3JhcHBlcihWTSYgdm0sIENvbXBpbGF0aW9uQ29udGV4dCYgY29tcGlsYXRpb25D b250ZXh0CiAgICAgZnVuY3Rpb24uanNUb1dhc21FbnRyeXBvaW50LmNhbGxlZVNhdmVSZWdpc3Rl cnMgPSBwcm9jLmNhbGxlZVNhdmVSZWdpc3RlcnMoKTsKIH0KIAotRXhwZWN0ZWQ8c3RkOjp1bmlx dWVfcHRyPFdhc21JbnRlcm5hbEZ1bmN0aW9uPiwgU3RyaW5nPiBwYXJzZUFuZENvbXBpbGUoVk0m IHZtLCBDb21waWxhdGlvbkNvbnRleHQmIGNvbXBpbGF0aW9uQ29udGV4dCwgY29uc3QgdWludDhf dCogZnVuY3Rpb25TdGFydCwgc2l6ZV90IGZ1bmN0aW9uTGVuZ3RoLCBjb25zdCBTaWduYXR1cmUq IHNpZ25hdHVyZSwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+JiB1bmxpbmtlZFdhc21U b1dhc21DYWxscywgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiBmdW5jdGlvbklu ZGV4U3BhY2UsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBpbmZvLCB1bnNpZ25lZCBvcHRMZXZl bCkKK0V4cGVjdGVkPHN0ZDo6dW5pcXVlX3B0cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0cmlu Zz4gcGFyc2VBbmRDb21waWxlKFZNJiB2bSwgQ29tcGlsYXRpb25Db250ZXh0JiBjb21waWxhdGlv bkNvbnRleHQsIGNvbnN0IHVpbnQ4X3QqIGZ1bmN0aW9uU3RhcnQsIHNpemVfdCBmdW5jdGlvbkxl bmd0aCwgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUsIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dh c21DYWxsPiYgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9u JiBpbmZvLCB1bnNpZ25lZCBvcHRMZXZlbCkKIHsKICAgICBhdXRvIHJlc3VsdCA9IHN0ZDo6bWFr ZV91bmlxdWU8V2FzbUludGVybmFsRnVuY3Rpb24+KCk7CiAKQEAgLTkyNSw4ICsxMDAwLDggQEAg RXhwZWN0ZWQ8c3RkOjp1bmlxdWVfcHRyPFdhc21JbnRlcm5hbEZ1bmN0aW9uPiwgU3RyaW5nPiBw YXJzZUFuZENvbXBpbGUoVk0mIHZtLAogICAgIGNvbXBpbGF0aW9uQ29udGV4dC53YXNtRW50cnlw b2ludEpJVCA9IHN0ZDo6bWFrZV91bmlxdWU8Q0NhbGxIZWxwZXJzPigmdm0pOwogCiAgICAgUHJv Y2VkdXJlIHByb2NlZHVyZTsKLSAgICBCM0lSR2VuZXJhdG9yIGNvbnRleHQodm0sIGluZm8sIHBy b2NlZHVyZSwgcmVzdWx0LmdldCgpLCB1bmxpbmtlZFdhc21Ub1dhc21DYWxscywgZnVuY3Rpb25J bmRleFNwYWNlKTsKLSAgICBGdW5jdGlvblBhcnNlcjxCM0lSR2VuZXJhdG9yPiBwYXJzZXIoJnZt LCBjb250ZXh0LCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBmdW5j dGlvbkluZGV4U3BhY2UsIGluZm8pOworICAgIEIzSVJHZW5lcmF0b3IgY29udGV4dCh2bSwgaW5m bywgcHJvY2VkdXJlLCByZXN1bHQuZ2V0KCksIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzKTsKKyAg ICBGdW5jdGlvblBhcnNlcjxCM0lSR2VuZXJhdG9yPiBwYXJzZXIoJnZtLCBjb250ZXh0LCBmdW5j dGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBpbmZvKTsKICAgICBXQVNNX0ZB SUxfSUZfSEVMUEVSX0ZBSUxTKHBhcnNlci5wYXJzZSgpKTsKIAogICAgIHByb2NlZHVyZS5yZXNl dFJlYWNoYWJpbGl0eSgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbUIzSVJHZW5lcmF0b3IuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lS R2VuZXJhdG9yLmgKaW5kZXggYjVjOWY0Ni4uZDg5NzU4NSAxMDA2NDQKLS0tIGEvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuaAorKysgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5oCkBAIC00Nyw3ICs0Nyw3IEBAIHN0cnVj dCBDb21waWxhdGlvbkNvbnRleHQgewogICAgIENDYWxsSGVscGVyczo6Q2FsbCBqc0VudHJ5cG9p bnRUb1dhc21FbnRyeXBvaW50Q2FsbDsKIH07CiAKLUV4cGVjdGVkPHN0ZDo6dW5pcXVlX3B0cjxX YXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0cmluZz4gcGFyc2VBbmRDb21waWxlKFZNJiwgQ29tcGls YXRpb25Db250ZXh0JiwgY29uc3QgdWludDhfdCosIHNpemVfdCwgY29uc3QgU2lnbmF0dXJlKiwg VmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+JiwgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25J bmRleFNwYWNlJiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mLCB1bnNpZ25lZCBvcHRMZXZlbCA9 IDEpOworRXhwZWN0ZWQ8c3RkOjp1bmlxdWVfcHRyPFdhc21JbnRlcm5hbEZ1bmN0aW9uPiwgU3Ry aW5nPiBwYXJzZUFuZENvbXBpbGUoVk0mLCBDb21waWxhdGlvbkNvbnRleHQmLCBjb25zdCB1aW50 OF90Kiwgc2l6ZV90LCBjb25zdCBTaWduYXR1cmUqLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNt Q2FsbD4mLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYsIHVuc2lnbmVkIG9wdExldmVsID0gMSk7 CiAKIH0gfSAvLyBuYW1lc3BhY2UgSlNDOjpXYXNtCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21CaW5kaW5nLmNwcAppbmRleCAwZTU5MjQ3Li44OTJiZTA1IDEwMDY0NAotLS0gYS9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5jcHAKKysrIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuY3BwCkBAIC0zNiw3ICszNiw3IEBACiAKIG5h bWVzcGFjZSBKU0MgeyBuYW1lc3BhY2UgV2FzbSB7CiAKLVdhc21Ub0pTU3R1YiBpbXBvcnRTdHVi R2VuZXJhdG9yKFZNKiB2bSwgQmFnPENhbGxMaW5rSW5mbz4mIGNhbGxMaW5rSW5mb3MsIFNpZ25h dHVyZUluZGV4IHNpZ25hdHVyZUluZGV4LCB1bnNpZ25lZCBpbXBvcnRJbmRleCkKK3N0YXRpYyBN YWNyb0Fzc2VtYmxlckNvZGVSZWYgd2FzbVRvSlMoVk0qIHZtLCBCYWc8Q2FsbExpbmtJbmZvPiYg Y2FsbExpbmtJbmZvcywgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXgsIHVuc2lnbmVkIGlt cG9ydEluZGV4KQogewogICAgIGNvbnN0IFdhc21DYWxsaW5nQ29udmVudGlvbiYgd2FzbUNDID0g d2FzbUNhbGxpbmdDb252ZW50aW9uKCk7CiAgICAgY29uc3QgSlNDQ2FsbGluZ0NvbnZlbnRpb24m IGpzQ0MgPSBqc2NDYWxsaW5nQ29udmVudGlvbigpOwpAQCAtMjMxLDcgKzIzMSw0OCBAQCBXYXNt VG9KU1N0dWIgaW1wb3J0U3R1YkdlbmVyYXRvcihWTSogdm0sIEJhZzxDYWxsTGlua0luZm8+JiBj YWxsTGlua0luZm9zLCBTaWduYQogICAgIENvZGVMb2NhdGlvbkxhYmVsIGhvdFBhdGhCZWdpbihw YXRjaEJ1ZmZlci5sb2NhdGlvbk9mKHRhcmdldFRvQ2hlY2spKTsKICAgICBDb2RlTG9jYXRpb25O ZWFyQ2FsbCBob3RQYXRoT3RoZXIgPSBwYXRjaEJ1ZmZlci5sb2NhdGlvbk9mTmVhckNhbGwoZmFz dENhbGwpOwogICAgIGNhbGxMaW5rSW5mby0+c2V0Q2FsbExvY2F0aW9ucyhjYWxsUmV0dXJuTG9j YXRpb24sIGhvdFBhdGhCZWdpbiwgaG90UGF0aE90aGVyKTsKLSAgICByZXR1cm4gRklOQUxJWkVf Q09ERShwYXRjaEJ1ZmZlciwgKCJXZWJBc3NlbWJseSBpbXBvcnRbJWldIHN0dWIgZm9yIHNpZ25h dHVyZSAlaSIsIGltcG9ydEluZGV4LCBzaWduYXR1cmVJbmRleCkpOworICAgIFN0cmluZyBzaWdu YXR1cmVEZXNjcmlwdGlvbiA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQodm0sIHNpZ25hdHVy ZUluZGV4KS0+dG9TdHJpbmcoKTsKKyAgICByZXR1cm4gRklOQUxJWkVfQ09ERShwYXRjaEJ1ZmZl ciwgKCJXZWJBc3NlbWJseS0+SmF2YVNjcmlwdCBpbXBvcnRbJWldICVzIiwgaW1wb3J0SW5kZXgs IHNpZ25hdHVyZURlc2NyaXB0aW9uLmFzY2lpKCkuZGF0YSgpKSk7Cit9CisKK3N0YXRpYyBNYWNy b0Fzc2VtYmxlckNvZGVSZWYgd2FzbVRvV2FzbShWTSogdm0sIEJhZzxDYWxsTGlua0luZm8+JiBj YWxsTGlua0luZm9zLCBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCwgdW5zaWduZWQgaW1w b3J0SW5kZXgpCit7CisgICAgY29uc3QgV2FzbUNhbGxpbmdDb252ZW50aW9uJiB3YXNtQ0MgPSB3 YXNtQ2FsbGluZ0NvbnZlbnRpb24oKTsKKyAgICBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSA9 IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQodm0sIHNpZ25hdHVyZUluZGV4KTsKKyAgICB1bnNp Z25lZCBhcmdDb3VudCA9IHNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpOworICAgIHR5cGVkZWYg QXNzZW1ibHlIZWxwZXJzIEpJVDsKKyAgICBKSVQgaml0KHZtLCBudWxscHRyKTsKKworICAgIGpp dC5lbWl0RnVuY3Rpb25Qcm9sb2d1ZSgpOworICAgIGppdC5zdG9yZTY0KEpJVDo6VHJ1c3RlZElt bTMyKDApLCBKSVQ6OkFkZHJlc3MoR1BSSW5mbzo6Y2FsbEZyYW1lUmVnaXN0ZXIsIENhbGxGcmFt ZVNsb3Q6OmNvZGVCbG9jayAqIHN0YXRpY19jYXN0PGludD4oc2l6ZW9mKFJlZ2lzdGVyKSkpKTsg Ly8gRklYTUUgU3RvcCB1c2luZyAwIGFzIGNvZGVCbG9ja3MuIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xNjUzMjEKKyAgICBqaXQuc3RvcmVQdHIoSklUOjpUcnVzdGVk SW1tUHRyKHZtLT53ZWJBc3NlbWJseVRvSlNDYWxsZWUuZ2V0KCkpLCBKSVQ6OkFkZHJlc3MoR1BS SW5mbzo6Y2FsbEZyYW1lUmVnaXN0ZXIsIENhbGxGcmFtZVNsb3Q6OmNhbGxlZSAqIHN0YXRpY19j YXN0PGludD4oc2l6ZW9mKFJlZ2lzdGVyKSkpKTsKKworICAgIC8vIEZJWE1FIHBlcmZvcm0gYSBz dGFjayBjaGVjayBiZWZvcmUgdXBkYXRpbmcgU1AuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xNjU1NDYKKworICAgIHVuc2lnbmVkIG51bWJlck9mUGFyYW1ldGVycyA9 IGFyZ0NvdW50ICsgMTsgLy8gVGhlcmUgaXMgYSAidGhpcyIgYXJndW1lbnQuCisgICAgdW5zaWdu ZWQgbnVtYmVyT2ZSZWdzRm9yQ2FsbCA9IENhbGxGcmFtZTo6aGVhZGVyU2l6ZUluUmVnaXN0ZXJz ICsgbnVtYmVyT2ZQYXJhbWV0ZXJzOworICAgIHVuc2lnbmVkIG51bWJlck9mQnl0ZXNGb3JDYWxs ID0gbnVtYmVyT2ZSZWdzRm9yQ2FsbCAqIHNpemVvZihSZWdpc3RlcikgLSBzaXplb2YoQ2FsbGVy RnJhbWVBbmRQQyk7CisgICAgY29uc3QgdW5zaWduZWQgc3RhY2tPZmZzZXQgPSBXVEY6OnJvdW5k VXBUb011bHRpcGxlT2Yoc3RhY2tBbGlnbm1lbnRCeXRlcygpLCBudW1iZXJPZkJ5dGVzRm9yQ2Fs bCk7CisgICAgaml0LnN1YlB0cihNYWNyb0Fzc2VtYmxlcjo6VHJ1c3RlZEltbTMyKHN0YWNrT2Zm c2V0KSwgTWFjcm9Bc3NlbWJsZXI6OnN0YWNrUG9pbnRlclJlZ2lzdGVyKTsKKyAgICBKSVQ6OkFk ZHJlc3MgY2FsbGVlRnJhbWUgPSBDQ2FsbEhlbHBlcnM6OkFkZHJlc3MoTWFjcm9Bc3NlbWJsZXI6 OnN0YWNrUG9pbnRlclJlZ2lzdGVyLCAtc3RhdGljX2Nhc3Q8cHRyZGlmZl90PihzaXplb2YoQ2Fs bGVyRnJhbWVBbmRQQykpKTsKKworICAgIC8vIEZJWE1FIGltcGxlbWVudCB0aGlzLgorICAgIGpp dC5icmVha3BvaW50KCk7CisKKyAgICBqaXQuZW1pdEZ1bmN0aW9uRXBpbG9ndWUoKTsKKyAgICBq aXQucmV0KCk7CisKKyAgICBMaW5rQnVmZmVyIHBhdGNoQnVmZmVyKCp2bSwgaml0LCBHTE9CQUxf VEhVTktfSUQpOworICAgIFN0cmluZyBzaWduYXR1cmVEZXNjcmlwdGlvbiA9IFNpZ25hdHVyZUlu Zm9ybWF0aW9uOjpnZXQodm0sIHNpZ25hdHVyZUluZGV4KS0+dG9TdHJpbmcoKTsKKyAgICByZXR1 cm4gRklOQUxJWkVfQ09ERShwYXRjaEJ1ZmZlciwgKCJXZWJBc3NlbWJseS0+V2ViQXNzZW1ibHkg aW1wb3J0WyVpXSAlcyIsIGltcG9ydEluZGV4LCBzaWduYXR1cmVEZXNjcmlwdGlvbi5hc2NpaSgp LmRhdGEoKSkpOworfQorCitXYXNtRXhpdFN0dWJzIGV4aXRTdHViR2VuZXJhdG9yKFZNKiB2bSwg QmFnPENhbGxMaW5rSW5mbz4mIGNhbGxMaW5rSW5mb3MsIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVy ZUluZGV4LCB1bnNpZ25lZCBpbXBvcnRJbmRleCkKK3sKKyAgICBXYXNtRXhpdFN0dWJzIHN0dWJz OworICAgIHN0dWJzLndhc21Ub0pTID0gd2FzbVRvSlModm0sIGNhbGxMaW5rSW5mb3MsIHNpZ25h dHVyZUluZGV4LCBpbXBvcnRJbmRleCk7CisgICAgc3R1YnMud2FzbVRvV2FzbSA9IHdhc21Ub1dh c20odm0sIGNhbGxMaW5rSW5mb3MsIHNpZ25hdHVyZUluZGV4LCBpbXBvcnRJbmRleCk7CisgICAg cmV0dXJuIHN0dWJzOwogfQogCiB9IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2FzbQpkaWZmIC0tZ2l0 IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuaCBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmgKaW5kZXggZmQ3ZTAzZC4uNDAyMWYxNyAxMDA2 NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuaAorKysgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5oCkBAIC0zOCw3ICszOCw3IEBA IGNsYXNzIENhbGxMaW5rSW5mbzsKIAogbmFtZXNwYWNlIFdhc20gewogCi1XYXNtVG9KU1N0dWIg aW1wb3J0U3R1YkdlbmVyYXRvcihWTSosIEJhZzxDYWxsTGlua0luZm8+JiwgU2lnbmF0dXJlSW5k ZXgsIHVuc2lnbmVkKTsKK1dhc21FeGl0U3R1YnMgZXhpdFN0dWJHZW5lcmF0b3IoVk0qLCBCYWc8 Q2FsbExpbmtJbmZvPiYsIFNpZ25hdHVyZUluZGV4LCB1bnNpZ25lZCk7CiAKIH0gfSAvLyBuYW1l c3BhY2UgSlNDOjpXYXNtCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21Gb3JtYXQuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Gb3JtYXQuaApp bmRleCAzNTlkZGNjLi5iNmRhZGU5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9XYXNtRm9ybWF0LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZv cm1hdC5oCkBAIC0xODcsNyArMTg3LDcgQEAgcHJpdmF0ZToKIH07CiAKIHN0cnVjdCBNb2R1bGVJ bmZvcm1hdGlvbiB7Ci0gICAgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiBzaWduYXR1cmVJbmRpY2Vz OworICAgIFZlY3RvcjxTaWduYXR1cmVJbmRleD4gbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5p cXVlZFNpZ25hdHVyZUluZGljZXM7CiAgICAgVmVjdG9yPEltcG9ydD4gaW1wb3J0czsKICAgICBW ZWN0b3I8U2lnbmF0dXJlSW5kZXg+IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlczsKICAg ICBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+IGludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2Vz OwpAQCAtMTk5LDYgKzE5OSwxOCBAQCBzdHJ1Y3QgTW9kdWxlSW5mb3JtYXRpb24gewogICAgIFRh YmxlSW5mb3JtYXRpb24gdGFibGVJbmZvcm1hdGlvbjsKICAgICBWZWN0b3I8R2xvYmFsPiBnbG9i YWxzOwogICAgIHVuc2lnbmVkIGZpcnN0SW50ZXJuYWxHbG9iYWwgeyAwIH07CisgICAgc2l6ZV90 IGZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSBjb25zdCB7IHJldHVybiBpbXBvcnRGdW5jdGlvblNp Z25hdHVyZUluZGljZXMuc2l6ZSgpICsgaW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXMu c2l6ZSgpOyB9CisgICAgYm9vbCBpc0ltcG9ydGVkRnVuY3Rpb25Gcm9tRnVuY3Rpb25JbmRleFNw YWNlKHNpemVfdCBmdW5jdGlvbkluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgQVNTRVJUKGZ1 bmN0aW9uSW5kZXggPCBmdW5jdGlvbkluZGV4U3BhY2VTaXplKCkpOworICAgICAgICByZXR1cm4g ZnVuY3Rpb25JbmRleCA8IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCk7Cisg ICAgfQorICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhT cGFjZShzaXplX3QgZnVuY3Rpb25JbmRleCkgY29uc3QKKyAgICB7CisgICAgICAgIHJldHVybiBp c0ltcG9ydGVkRnVuY3Rpb25Gcm9tRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgpCisg ICAgICAgICAgICA/IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4 XQorICAgICAgICAgICAgOiBpbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlv bkluZGV4IC0gaW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnNpemUoKV07CisgICAgfQog CiAgICAgfk1vZHVsZUluZm9ybWF0aW9uKCk7CiB9OwpAQCAtMjA2LDYgKzIxOCw3IEBAIHN0cnVj dCBNb2R1bGVJbmZvcm1hdGlvbiB7CiBzdHJ1Y3QgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbCB7CiAg ICAgQ29kZUxvY2F0aW9uQ2FsbCBjYWxsTG9jYXRpb247CiAgICAgc2l6ZV90IGZ1bmN0aW9uSW5k ZXg7CisgICAgYm9vbCB0b0pTOwogfTsKIAogc3RydWN0IEVudHJ5cG9pbnQgewpAQCAtMjIxLDcg KzIzNCwxMCBAQCBzdHJ1Y3QgV2FzbUludGVybmFsRnVuY3Rpb24gewogICAgIEVudHJ5cG9pbnQg anNUb1dhc21FbnRyeXBvaW50OwogfTsKIAotdHlwZWRlZiBNYWNyb0Fzc2VtYmxlckNvZGVSZWYg V2FzbVRvSlNTdHViOworc3RydWN0IFdhc21FeGl0U3R1YnMgeworICAgIE1hY3JvQXNzZW1ibGVy Q29kZVJlZiB3YXNtVG9KUzsKKyAgICBNYWNyb0Fzc2VtYmxlckNvZGVSZWYgd2FzbVRvV2FzbTsK K307CiAKIC8vIFdlYkFzc2VtYmx5IGRpcmVjdCBjYWxscyBhbmQgY2FsbF9pbmRpcmVjdCB1c2Ug aW5kaWNlcyBpbnRvICJmdW5jdGlvbiBpbmRleCBzcGFjZSIuIFRoaXMgc3BhY2Ugc3RhcnRzIHdp dGggYWxsIGltcG9ydHMsIGFuZCB0aGVuIGFsbCBpbnRlcm5hbCBmdW5jdGlvbnMuCiAvLyBDYWxs YWJsZUZ1bmN0aW9uIGFuZCBGdW5jdGlvbkluZGV4U3BhY2UgYXJlIG9ubHkgbWVhbnQgYXMgZmFz dCBsb29rdXAgdGFibGVzIGZvciB0aGVzZSBvcGNvZGVzLCBhbmQgZG8gbm90IG93biBjb2RlLgpA QCAtMjQwLDEyICsyNTYsNiBAQCBzdHJ1Y3QgQ2FsbGFibGVGdW5jdGlvbiB7CiB9OwogdHlwZWRl ZiBWZWN0b3I8Q2FsbGFibGVGdW5jdGlvbj4gRnVuY3Rpb25JbmRleFNwYWNlOwogCi0KLXN0cnVj dCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UgewotICAgIE1hbGxvY1B0cjxDYWxsYWJsZUZ1 bmN0aW9uPiBidWZmZXI7Ci0gICAgc2l6ZV90IHNpemU7Ci19OwotCiB9IH0gLy8gbmFtZXNwYWNl IEpTQzo6V2FzbQogCiAjZW5kaWYgLy8gRU5BQkxFKFdFQkFTU0VNQkxZKQpkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmggYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rpb25QYXJzZXIuaAppbmRleCBhNjBhYzQ3Li4z ZWNiMzkzIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rp b25QYXJzZXIuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rpb25Q YXJzZXIuaApAQCAtNDYsNyArNDYsNyBAQCBwdWJsaWM6CiAgICAgdHlwZWRlZiB0eXBlbmFtZSBD b250ZXh0OjpDb250cm9sVHlwZSBDb250cm9sVHlwZTsKICAgICB0eXBlZGVmIHR5cGVuYW1lIENv bnRleHQ6OkV4cHJlc3Npb25MaXN0IEV4cHJlc3Npb25MaXN0OwogCi0gICAgRnVuY3Rpb25QYXJz ZXIoVk0qLCBDb250ZXh0JiwgY29uc3QgdWludDhfdCogZnVuY3Rpb25TdGFydCwgc2l6ZV90IGZ1 bmN0aW9uTGVuZ3RoLCBjb25zdCBTaWduYXR1cmUqLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbklu ZGV4U3BhY2UmLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYpOworICAgIEZ1bmN0aW9uUGFyc2Vy KFZNKiwgQ29udGV4dCYsIGNvbnN0IHVpbnQ4X3QqIGZ1bmN0aW9uU3RhcnQsIHNpemVfdCBmdW5j dGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mKTsK IAogICAgIFJlc3VsdCBXQVJOX1VOVVNFRF9SRVRVUk4gcGFyc2UoKTsKIApAQCAtODIsMTcgKzgy LDE1IEBAIHByaXZhdGU6CiAgICAgRXhwcmVzc2lvbkxpc3QgbV9leHByZXNzaW9uU3RhY2s7CiAg ICAgVmVjdG9yPENvbnRyb2xFbnRyeT4gbV9jb250cm9sU3RhY2s7CiAgICAgY29uc3QgU2lnbmF0 dXJlKiBtX3NpZ25hdHVyZTsKLSAgICBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2Um IG1fZnVuY3Rpb25JbmRleFNwYWNlOwogICAgIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBtX2lu Zm87CiAgICAgdW5zaWduZWQgbV91bnJlYWNoYWJsZUJsb2NrcyB7IDAgfTsKIH07CiAKIHRlbXBs YXRlPHR5cGVuYW1lIENvbnRleHQ+Ci1GdW5jdGlvblBhcnNlcjxDb250ZXh0Pjo6RnVuY3Rpb25Q YXJzZXIoVk0qIHZtLCBDb250ZXh0JiBjb250ZXh0LCBjb25zdCB1aW50OF90KiBmdW5jdGlvblN0 YXJ0LCBzaXplX3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBj b25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIGZ1bmN0aW9uSW5kZXhTcGFjZSwgY29u c3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8pCitGdW5jdGlvblBhcnNlcjxDb250ZXh0Pjo6RnVu Y3Rpb25QYXJzZXIoVk0qIHZtLCBDb250ZXh0JiBjb250ZXh0LCBjb25zdCB1aW50OF90KiBmdW5j dGlvblN0YXJ0LCBzaXplX3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0 dXJlLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbykKICAgICA6IFBhcnNlcih2bSwgZnVu Y3Rpb25TdGFydCwgZnVuY3Rpb25MZW5ndGgpCiAgICAgLCBtX2NvbnRleHQoY29udGV4dCkKICAg ICAsIG1fc2lnbmF0dXJlKHNpZ25hdHVyZSkKLSAgICAsIG1fZnVuY3Rpb25JbmRleFNwYWNlKGZ1 bmN0aW9uSW5kZXhTcGFjZSkKICAgICAsIG1faW5mbyhpbmZvKQogewogICAgIGlmICh2ZXJib3Nl KQpAQCAtMzA4LDkgKzMwNiw5IEBAIGF1dG8gRnVuY3Rpb25QYXJzZXI8Q29udGV4dD46OnBhcnNl RXhwcmVzc2lvbihPcFR5cGUgb3ApIC0+IFBhcnRpYWxSZXN1bHQKICAgICBjYXNlIENhbGw6IHsK ICAgICAgICAgdWludDMyX3QgZnVuY3Rpb25JbmRleDsKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJ TF9JRighcGFyc2VWYXJVSW50MzIoZnVuY3Rpb25JbmRleCksICJjYW4ndCBwYXJzZSBjYWxsJ3Mg ZnVuY3Rpb24gaW5kZXgiKTsKLSAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvbklu ZGV4ID49IG1fZnVuY3Rpb25JbmRleFNwYWNlLnNpemUsICJjYWxsIGZ1bmN0aW9uIGluZGV4ICIs IGZ1bmN0aW9uSW5kZXgsICIgZXhjZWVkcyBmdW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX2Z1bmN0 aW9uSW5kZXhTcGFjZS5zaXplKTsKKyAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlv bkluZGV4ID49IG1faW5mby5mdW5jdGlvbkluZGV4U3BhY2VTaXplKCksICJjYWxsIGZ1bmN0aW9u IGluZGV4ICIsIGZ1bmN0aW9uSW5kZXgsICIgZXhjZWVkcyBmdW5jdGlvbiBpbmRleCBzcGFjZSAi LCBtX2luZm8uZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpKTsKIAotICAgICAgICBTaWduYXR1cmVJ bmRleCBjYWxsZWVTaWduYXR1cmVJbmRleCA9IG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5n ZXQoKVtmdW5jdGlvbkluZGV4XS5zaWduYXR1cmVJbmRleDsKKyAgICAgICAgU2lnbmF0dXJlSW5k ZXggY2FsbGVlU2lnbmF0dXJlSW5kZXggPSBtX2luZm8uc2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rp b25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgpOwogICAgICAgICBjb25zdCBTaWduYXR1cmUqIGNh bGxlZVNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgY2FsbGVlU2ln bmF0dXJlSW5kZXgpOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGNhbGxlZVNpZ25hdHVy ZS0+YXJndW1lbnRDb3VudCgpID4gbV9leHByZXNzaW9uU3RhY2suc2l6ZSgpLCAiY2FsbCBmdW5j dGlvbiBpbmRleCAiLCBmdW5jdGlvbkluZGV4LCAiIGhhcyAiLCBjYWxsZWVTaWduYXR1cmUtPmFy Z3VtZW50Q291bnQoKSwgIiBhcmd1bWVudHMsIGJ1dCB0aGUgZXhwcmVzc2lvbiBzdGFjayBjdXJy ZW50bHkgaG9sZHMgIiwgbV9leHByZXNzaW9uU3RhY2suc2l6ZSgpLCAiIHZhbHVlcyIpOwogCkBA IC0zMzcsOSArMzM1LDkgQEAgYXV0byBGdW5jdGlvblBhcnNlcjxDb250ZXh0Pjo6cGFyc2VFeHBy ZXNzaW9uKE9wVHlwZSBvcCkgLT4gUGFydGlhbFJlc3VsdAogICAgICAgICBXQVNNX1BBUlNFUl9G QUlMX0lGKCFwYXJzZVZhclVJbnQzMihzaWduYXR1cmVJbmRleCksICJjYW4ndCBnZXQgY2FsbF9p bmRpcmVjdCdzIHNpZ25hdHVyZSBpbmRleCIpOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lG KCFwYXJzZVZhclVJbnQxKHJlc2VydmVkKSwgImNhbid0IGdldCBjYWxsX2luZGlyZWN0J3MgcmVz ZXJ2ZWQgYnl0ZSIpOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHJlc2VydmVkLCAiY2Fs bF9pbmRpcmVjdCdzICdyZXNlcnZlZCcgdmFydWludDEgbXVzdCBiZSAweDAiKTsKLSAgICAgICAg V0FTTV9QQVJTRVJfRkFJTF9JRihtX2luZm8uc2lnbmF0dXJlSW5kaWNlcy5zaXplKCkgPD0gc2ln bmF0dXJlSW5kZXgsICJjYWxsX2luZGlyZWN0J3Mgc2lnbmF0dXJlIGluZGV4ICIsIHNpZ25hdHVy ZUluZGV4LCAiIGV4Y2VlZHMga25vd24gc2lnbmF0dXJlcyAiLCBtX2luZm8uc2lnbmF0dXJlSW5k aWNlcy5zaXplKCkpOworICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKG1faW5mby5tb2R1bGVT aWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXplKCkgPD0gc2lnbmF0 dXJlSW5kZXgsICJjYWxsX2luZGlyZWN0J3Mgc2lnbmF0dXJlIGluZGV4ICIsIHNpZ25hdHVyZUlu ZGV4LCAiIGV4Y2VlZHMga25vd24gc2lnbmF0dXJlcyAiLCBtX2luZm8ubW9kdWxlU2lnbmF0dXJl SW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMuc2l6ZSgpKTsKIAotICAgICAgICBTaWdu YXR1cmVJbmRleCBjYWxsZWVTaWduYXR1cmVJbmRleCA9IG1faW5mby5zaWduYXR1cmVJbmRpY2Vz W3NpZ25hdHVyZUluZGV4XTsKKyAgICAgICAgU2lnbmF0dXJlSW5kZXggY2FsbGVlU2lnbmF0dXJl SW5kZXggPSBtX2luZm8ubW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUlu ZGljZXNbc2lnbmF0dXJlSW5kZXhdOwogICAgICAgICBjb25zdCBTaWduYXR1cmUqIGNhbGxlZVNp Z25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgY2FsbGVlU2lnbmF0dXJl SW5kZXgpOwogICAgICAgICBzaXplX3QgYXJndW1lbnRDb3VudCA9IGNhbGxlZVNpZ25hdHVyZS0+ YXJndW1lbnRDb3VudCgpICsgMTsgLy8gQWRkIHRoZSBjYWxsZWUncyBpbmRleC4KICAgICAgICAg V0FTTV9QQVJTRVJfRkFJTF9JRihhcmd1bWVudENvdW50ID4gbV9leHByZXNzaW9uU3RhY2suc2l6 ZSgpLCAiY2FsbF9pbmRpcmVjdCBleHBlY3RzICIsIGFyZ3VtZW50Q291bnQsICIgYXJndW1lbnRz LCBidXQgdGhlIGV4cHJlc3Npb24gc3RhY2sgY3VycmVudGx5IGhvbGRzICIsIG1fZXhwcmVzc2lv blN0YWNrLnNpemUoKSwgIiB2YWx1ZXMiKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bU1lbW9yeS5jcHAKaW5kZXggZjE5ZWNlMC4uMWU5YzliZiAxMDA2NDQKLS0tIGEvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbU1lbW9yeS5jcHAKQEAgLTMxLDExICszMSwxMSBAQAogbmFtZXNwYWNlIEpT QyB7IG5hbWVzcGFjZSBXYXNtIHsKIAogTWVtb3J5OjpNZW1vcnkoUGFnZUNvdW50IGluaXRpYWws IFBhZ2VDb3VudCBtYXhpbXVtKQotICAgIDogbV9tb2RlKE1vZGU6OkJvdW5kc0NoZWNraW5nKQot ICAgICwgbV9zaXplKGluaXRpYWwuYnl0ZXMoKSkKKyAgICA6IG1fc2l6ZShpbml0aWFsLmJ5dGVz KCkpCiAgICAgLCBtX2NhcGFjaXR5KG1heGltdW0gPyBtYXhpbXVtLmJ5dGVzKCkgOiBQYWdlQ291 bnQ6Om1heCgpLmJ5dGVzKCkpCiAgICAgLCBtX2luaXRpYWwoaW5pdGlhbCkKICAgICAsIG1fbWF4 aW11bShtYXhpbXVtKQorICAgICwgbV9tb2RlKE1vZGU6OkJvdW5kc0NoZWNraW5nKQogICAgIC8v IEZJWE1FOiBJZiB3ZSBhZGQgc2lnbmFsIGJhc2VkIGJvdW5kcyBjaGVja2luZyB0aGVuIHdlIG5l ZWQgZXh0cmEgc3BhY2UgZm9yIG92ZXJmbG93IG9uIGxvYWQuCiAgICAgLy8gc2VlOiBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYyNjkzCiB7CmRpZmYgLS1naXQgYS9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmggYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtTWVtb3J5LmgKaW5kZXggYjQxMWYzNDguLjQzMDQ3NjkgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuaAorKysgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmgKQEAgLTM4LDYgKzM4LDcgQEAgY2xhc3Mg TWVtb3J5IHsKICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShNZW1vcnkpOwogICAgIFdURl9NQUtF X0ZBU1RfQUxMT0NBVEVEOwogcHVibGljOgorICAgIE1lbW9yeShNZW1vcnkmJikgPSBkZWZhdWx0 OwogCiAgICAgLy8gRklYTUU6IFdlIHNob3VsZCBzdXBwb3J0IG90aGVyIG1vZGVzLiBzZWU6IGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjI2OTMKICAgICBlbnVtIGNs YXNzIE1vZGUgewpAQCAtNTcsMTEgKzU4LDExIEBAIHB1YmxpYzoKICAgICB2b2lkKiBtZW1vcnko KSBjb25zdCB7IHJldHVybiBtX21lbW9yeTsgfQogICAgIHVpbnQzMl90IHNpemUoKSBjb25zdCB7 IHJldHVybiBtX3NpemU7IH0KIAotICAgIE1vZGUgbW9kZSgpIGNvbnN0IHsgcmV0dXJuIG1fbW9k ZTsgfQotCiAgICAgUGFnZUNvdW50IGluaXRpYWwoKSBjb25zdCB7IHJldHVybiBtX2luaXRpYWw7 IH0KICAgICBQYWdlQ291bnQgbWF4aW11bSgpIGNvbnN0IHsgcmV0dXJuIG1fbWF4aW11bTsgfQog CisgICAgTW9kZSBtb2RlKCkgY29uc3QgeyByZXR1cm4gbV9tb2RlOyB9CisKICAgICBib29sIGdy b3codWludDMyX3QgbmV3U2l6ZSkKICAgICB7CiAgICAgICAgIEFTU0VSVChtX21lbW9yeSk7CkBA IC03MSwxNyArNzIsMTggQEAgcHVibGljOgogICAgICAgICByZXR1cm4gIW1wcm90ZWN0KG1fbWVt b3J5LCBuZXdTaXplLCBQUk9UX1JFQUQgfCBQUk9UX1dSSVRFKTsKICAgICB9CiAKKyAgICBzdGF0 aWMgcHRyZGlmZl90IG9mZnNldE9mTWVtb3J5KCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKE1l bW9yeSwgbV9tZW1vcnkpOyB9CiAgICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZlNpemUoKSB7 IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoTWVtb3J5LCBtX3NpemUpOyB9CiAKICAgICAKIHByaXZh dGU6CiAgICAgdm9pZCogbV9tZW1vcnkgeyBudWxscHRyIH07Ci0gICAgTW9kZSBtX21vZGU7CiAg ICAgdWludDMyX3QgbV9zaXplIHsgMCB9OwogICAgIHVpbnQzMl90IG1fY2FwYWNpdHkgeyAwIH07 CiAgICAgUGFnZUNvdW50IG1faW5pdGlhbDsKICAgICBQYWdlQ291bnQgbV9tYXhpbXVtOwogICAg IHVpbnQ2NF90IG1fbWFwcGVkQ2FwYWNpdHkgeyAwIH07CisgICAgTW9kZSBtX21vZGUgeyBNb2Rl OjpCb3VuZHNDaGVja2luZyB9OwogfTsKIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KZGlm ZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3Bw IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5jcHAKaW5kZXgg ODkxODQ3NS4uNTJmZWJhYyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbU1vZHVsZVBhcnNlci5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bU1vZHVsZVBhcnNlci5jcHAKQEAgLTk5LDcgKzk5LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBh cnNlVHlwZSgpIC0+IFBhcnRpYWxSZXN1bHQKIAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBh cnNlVmFyVUludDMyKGNvdW50KSwgImNhbid0IGdldCBUeXBlIHNlY3Rpb24ncyBjb3VudCIpOwog ICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoY291bnQgPT0gc3RkOjpudW1lcmljX2xpbWl0czx1aW50 MzJfdD46Om1heCgpLCAiVHlwZSBzZWN0aW9uJ3MgY291bnQgaXMgdG9vIGJpZyAiLCBjb3VudCk7 Ci0gICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRp Y2VzLnRyeVJlc2VydmVDYXBhY2l0eShjb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVt b3J5IGZvciBUeXBlIHNlY3Rpb24ncyAiLCBjb3VudCwgIiBlbnRyaWVzIik7CisgICAgV0FTTV9Q QVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlLT5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9V bmlxdWVkU2lnbmF0dXJlSW5kaWNlcy50cnlSZXNlcnZlQ2FwYWNpdHkoY291bnQpLCAiY2FuJ3Qg YWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgVHlwZSBzZWN0aW9uJ3MgIiwgY291bnQsICIgZW50 cmllcyIpOwogCiAgICAgZm9yICh1aW50MzJfdCBpID0gMDsgaSA8IGNvdW50OyArK2kpIHsKICAg ICAgICAgaW50OF90IHR5cGU7CkBAIC0xMzEsNyArMTMxLDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6 OnBhcnNlVHlwZSgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICAgICAgc2lnbmF0dXJlLT5yZXR1cm5U eXBlKCkgPSByZXR1cm5UeXBlOwogCiAgICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUlu ZGV4ID0gU2lnbmF0dXJlSW5mb3JtYXRpb246OmFkb3B0KG1fdm0sIHNpZ25hdHVyZS5yZWxlYXNl KCkpOwotICAgICAgICBtX3Jlc3VsdC5tb2R1bGUtPnNpZ25hdHVyZUluZGljZXMudW5jaGVja2Vk QXBwZW5kKHNpZ25hdHVyZUluZGV4KTsKKyAgICAgICAgbV9yZXN1bHQubW9kdWxlLT5tb2R1bGVT aWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy51bmNoZWNrZWRBcHBlbmQo c2lnbmF0dXJlSW5kZXgpOwogICAgIH0KICAgICByZXR1cm4geyB9OwogfQpAQCAtMTQ0LDcgKzE0 NCw2IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZUltcG9ydCgpIC0+IFBhcnRpYWxSZXN1bHQK ICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX3Jlc3VsdC5tb2R1bGUtPmdsb2JhbHMudHJ5UmVz ZXJ2ZUNhcGFjaXR5KGltcG9ydENvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkg Zm9yICIsIGltcG9ydENvdW50LCAiIGdsb2JhbHMiKTsgLy8gRklYTUUgdGhpcyBvdmVyLWFsbG9j YXRlcyB3aGVuIHdlIGZpeCB0aGUgRklYTUVzIGJlbG93LgogICAgIFdBU01fUEFSU0VSX0ZBSUxf SUYoIW1fcmVzdWx0Lm1vZHVsZS0+aW1wb3J0cy50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291 bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIg aW1wb3J0cyIpOyAvLyBGSVhNRSB0aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBG SVhNRXMgYmVsb3cuCiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlLT5p bXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGltcG9ydENv dW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGltcG9ydENvdW50LCAi IGltcG9ydCBmdW5jdGlvbiBzaWduYXR1cmVzIik7IC8vIEZJWE1FIHRoaXMgb3Zlci1hbGxvY2F0 ZXMgd2hlbiB3ZSBmaXggdGhlIEZJWE1FcyBiZWxvdy4KLSAgICBXQVNNX1BBUlNFUl9GQUlMX0lG KCFtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2UudHJ5UmVzZXJ2ZUNhcGFjaXR5KGltcG9ydENv dW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGltcG9ydENvdW50LCAi IGZ1bmN0aW9ucyBpbiB0aGUgaW5kZXggc3BhY2UiKTsgLy8gRklYTUUgdGhpcyBvdmVyLWFsbG9j YXRlcyB3aGVuIHdlIGZpeCB0aGUgRklYTUVzIGJlbG93LiBXZSdsbCBhbGxvY2F0ZSBzb21lIG1v cmUgaGVyZSB3aGVuIHdlIGtub3cgaG93IG1hbnkgZnVuY3Rpb25zIHRvIGV4cGVjdC4KIAogICAg IGZvciAodWludDMyX3QgaW1wb3J0TnVtYmVyID0gMDsgaW1wb3J0TnVtYmVyIDwgaW1wb3J0Q291 bnQ7ICsraW1wb3J0TnVtYmVyKSB7CiAgICAgICAgIEltcG9ydCBpbXA7CkBAIC0xNjYsMTEgKzE2 NSwxMCBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VJbXBvcnQoKSAtPiBQYXJ0aWFsUmVzdWx0 CiAgICAgICAgIGNhc2UgRXh0ZXJuYWxLaW5kOjpGdW5jdGlvbjogewogICAgICAgICAgICAgdWlu dDMyX3QgZnVuY3Rpb25TaWduYXR1cmVJbmRleDsKICAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZB SUxfSUYoIXBhcnNlVmFyVUludDMyKGZ1bmN0aW9uU2lnbmF0dXJlSW5kZXgpLCAiY2FuJ3QgZ2V0 ICIsIGltcG9ydE51bWJlciwgInRoIEltcG9ydCdzIGZ1bmN0aW9uIHNpZ25hdHVyZSBpbiBtb2R1 bGUgJyIsIG1vZHVsZVN0cmluZywgIicgZmllbGQgJyIsIGZpZWxkU3RyaW5nLCAiJyIpOwotICAg ICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvblNpZ25hdHVyZUluZGV4ID49IG1f cmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICJpbnZhbGlkIGZ1bmN0aW9u IHNpZ25hdHVyZSBmb3IgIiwgaW1wb3J0TnVtYmVyLCAidGggSW1wb3J0LCAiLCBmdW5jdGlvblNp Z25hdHVyZUluZGV4LCAiIGlzIG91dCBvZiByYW5nZSBvZiAiLCBtX3Jlc3VsdC5tb2R1bGUtPnNp Z25hdHVyZUluZGljZXMuc2l6ZSgpLCAiIGluIG1vZHVsZSAnIiwgbW9kdWxlU3RyaW5nLCAiJyBm aWVsZCAnIiwgZmllbGRTdHJpbmcsICInIik7CisgICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlM X0lGKGZ1bmN0aW9uU2lnbmF0dXJlSW5kZXggPj0gbV9yZXN1bHQubW9kdWxlLT5tb2R1bGVTaWdu YXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICJpbnZhbGlkIGZ1 bmN0aW9uIHNpZ25hdHVyZSBmb3IgIiwgaW1wb3J0TnVtYmVyLCAidGggSW1wb3J0LCAiLCBmdW5j dGlvblNpZ25hdHVyZUluZGV4LCAiIGlzIG91dCBvZiByYW5nZSBvZiAiLCBtX3Jlc3VsdC5tb2R1 bGUtPm1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzLnNpemUo KSwgIiBpbiBtb2R1bGUgJyIsIG1vZHVsZVN0cmluZywgIicgZmllbGQgJyIsIGZpZWxkU3RyaW5n LCAiJyIpOwogICAgICAgICAgICAgaW1wLmtpbmRJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZS0+aW1w b3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnNpemUoKTsKLSAgICAgICAgICAgIFNpZ25hdHVy ZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2Vz W2Z1bmN0aW9uU2lnbmF0dXJlSW5kZXhdOworICAgICAgICAgICAgU2lnbmF0dXJlSW5kZXggc2ln bmF0dXJlSW5kZXggPSBtX3Jlc3VsdC5tb2R1bGUtPm1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1Vu aXF1ZWRTaWduYXR1cmVJbmRpY2VzW2Z1bmN0aW9uU2lnbmF0dXJlSW5kZXhdOwogICAgICAgICAg ICAgbV9yZXN1bHQubW9kdWxlLT5pbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMudW5jaGVj a2VkQXBwZW5kKHNpZ25hdHVyZUluZGV4KTsKLSAgICAgICAgICAgIG1fcmVzdWx0LmZ1bmN0aW9u SW5kZXhTcGFjZS51bmNoZWNrZWRBcHBlbmQoc2lnbmF0dXJlSW5kZXgpOwogICAgICAgICAgICAg YnJlYWs7CiAgICAgICAgIH0KICAgICAgICAgY2FzZSBFeHRlcm5hbEtpbmQ6OlRhYmxlOiB7CkBA IC0yMTIsMjAgKzIxMCwxOCBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VGdW5jdGlvbigpIC0+ IFBhcnRpYWxSZXN1bHQKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGNvdW50ID09IHN0ZDo6bnVt ZXJpY19saW1pdHM8dWludDMyX3Q+OjptYXgoKSwgIkZ1bmN0aW9uIHNlY3Rpb24ncyBjb3VudCBp cyB0b28gYmlnICIsIGNvdW50KTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX3Jlc3VsdC5t b2R1bGUtPmludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnRyeVJlc2VydmVDYXBhY2l0 eShjb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBjb3VudCwgIiBG dW5jdGlvbiBzaWduYXR1cmVzIik7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQu ZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5LnRyeVJlc2VydmVDYXBhY2l0eShjb3VudCksICJjYW4n dCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBjb3VudCwgIkZ1bmN0aW9uIGxvY2F0aW9u cyIpOwotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFj ZS50cnlSZXNlcnZlQ2FwYWNpdHkobV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnNpemUoKSAr IGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGNvdW50LCAiIG1v cmUgZnVuY3Rpb25zIGluIHRoZSBmdW5jdGlvbiBpbmRleCBzcGFjZSIpOwogCiAgICAgZm9yICh1 aW50MzJfdCBpID0gMDsgaSA8IGNvdW50OyArK2kpIHsKICAgICAgICAgdWludDMyX3QgdHlwZU51 bWJlcjsKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIodHlwZU51 bWJlciksICJjYW4ndCBnZXQgIiwgaSwgInRoIEZ1bmN0aW9uJ3MgdHlwZSBudW1iZXIiKTsKLSAg ICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRih0eXBlTnVtYmVyID49IG1fcmVzdWx0Lm1vZHVsZS0+ c2lnbmF0dXJlSW5kaWNlcy5zaXplKCksIGksICJ0aCBGdW5jdGlvbiB0eXBlIG51bWJlciBpcyBp bnZhbGlkICIsIHR5cGVOdW1iZXIpOworICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHR5cGVO dW1iZXIgPj0gbV9yZXN1bHQubW9kdWxlLT5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVk U2lnbmF0dXJlSW5kaWNlcy5zaXplKCksIGksICJ0aCBGdW5jdGlvbiB0eXBlIG51bWJlciBpcyBp bnZhbGlkICIsIHR5cGVOdW1iZXIpOwogCi0gICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVy ZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzW3R5cGVOdW1iZXJdOwor ICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZS0+ bW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXNbdHlwZU51bWJl cl07CiAgICAgICAgIC8vIFRoZSBDb2RlIHNlY3Rpb24gZml4ZXMgdXAgc3RhcnQgYW5kIGVuZC4K ICAgICAgICAgc2l6ZV90IHN0YXJ0ID0gMDsKICAgICAgICAgc2l6ZV90IGVuZCA9IDA7CiAgICAg ICAgIG1fcmVzdWx0Lm1vZHVsZS0+aW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXMudW5j aGVja2VkQXBwZW5kKHNpZ25hdHVyZUluZGV4KTsKICAgICAgICAgbV9yZXN1bHQuZnVuY3Rpb25M b2NhdGlvbkluQmluYXJ5LnVuY2hlY2tlZEFwcGVuZCh7IHN0YXJ0LCBlbmQgfSk7Ci0gICAgICAg IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS51bmNoZWNrZWRBcHBlbmQoc2lnbmF0dXJlSW5k ZXgpOwogICAgIH0KIAogICAgIHJldHVybiB7IH07CkBAIC0zOTYsNyArMzkyLDcgQEAgYXV0byBN b2R1bGVQYXJzZXI6OnBhcnNlRXhwb3J0KCkgLT4gUGFydGlhbFJlc3VsdAogICAgICAgICBXQVNN X1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihleHAua2luZEluZGV4KSwgImNhbid0IGdl dCAiLCBleHBvcnROdW1iZXIsICJ0aCBFeHBvcnQncyBraW5kIGluZGV4LCBuYW1lZCAnIiwgZmll bGRTdHJpbmcsICInIik7CiAgICAgICAgIHN3aXRjaCAoZXhwLmtpbmQpIHsKICAgICAgICAgY2Fz ZSBFeHRlcm5hbEtpbmQ6OkZ1bmN0aW9uOiB7Ci0gICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlM X0lGKGV4cC5raW5kSW5kZXggPj0gbV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnNpemUoKSwg ZXhwb3J0TnVtYmVyLCAidGggRXhwb3J0IGhhcyBpbnZhbGlkIGZ1bmN0aW9uIG51bWJlciAiLCBl eHAua2luZEluZGV4LCAiIGl0IGV4Y2VlZHMgdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlICIsIG1f cmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCksICIsIG5hbWVkICciLCBmaWVsZFN0cmlu ZywgIiciKTsKKyAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZXhwLmtpbmRJbmRleCA+ PSBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSwgZXhwb3J0TnVtYmVy LCAidGggRXhwb3J0IGhhcyBpbnZhbGlkIGZ1bmN0aW9uIG51bWJlciAiLCBleHAua2luZEluZGV4 LCAiIGl0IGV4Y2VlZHMgdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlICIsIG1fcmVzdWx0Lm1vZHVs ZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpLCAiLCBuYW1lZCAnIiwgZmllbGRTdHJpbmcsICIn Iik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQogICAgICAgICBjYXNlIEV4dGVybmFs S2luZDo6VGFibGU6IHsKQEAgLTQyNiw4ICs0MjIsOCBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFy c2VTdGFydCgpIC0+IFBhcnRpYWxSZXN1bHQKIHsKICAgICB1aW50MzJfdCBzdGFydEZ1bmN0aW9u SW5kZXg7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoc3RhcnRGdW5j dGlvbkluZGV4KSwgImNhbid0IGdldCBTdGFydCBpbmRleCIpOwotICAgIFdBU01fUEFSU0VSX0ZB SUxfSUYoc3RhcnRGdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5z aXplKCksICJTdGFydCBpbmRleCAiLCBzdGFydEZ1bmN0aW9uSW5kZXgsICIgZXhjZWVkcyBmdW5j dGlvbiBpbmRleCBzcGFjZSAiLCBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpKTsK LSAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0LmZ1bmN0aW9uSW5k ZXhTcGFjZVtzdGFydEZ1bmN0aW9uSW5kZXhdLnNpZ25hdHVyZUluZGV4OworICAgIFdBU01fUEFS U0VSX0ZBSUxfSUYoc3RhcnRGdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0Lm1vZHVsZS0+ZnVuY3Rp b25JbmRleFNwYWNlU2l6ZSgpLCAiU3RhcnQgaW5kZXggIiwgc3RhcnRGdW5jdGlvbkluZGV4LCAi IGV4Y2VlZHMgZnVuY3Rpb24gaW5kZXggc3BhY2UgIiwgbV9yZXN1bHQubW9kdWxlLT5mdW5jdGlv bkluZGV4U3BhY2VTaXplKCkpOworICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0g bV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2Uoc3Rh cnRGdW5jdGlvbkluZGV4KTsKICAgICBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFNpZ25h dHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgc2lnbmF0dXJlSW5kZXgpOwogICAgIFdBU01fUEFS U0VSX0ZBSUxfSUYoc2lnbmF0dXJlLT5hcmd1bWVudENvdW50KCksICJTdGFydCBmdW5jdGlvbiBj YW4ndCBoYXZlIGFyZ3VtZW50cyIpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc2lnbmF0dXJl LT5yZXR1cm5UeXBlKCkgIT0gVm9pZCwgIlN0YXJ0IGZ1bmN0aW9uIGNhbid0IHJldHVybiBhIHZh bHVlIik7CkBAIC00NzcsNyArNDczLDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlRWxlbWVu dCgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICAgICAgZm9yICh1bnNpZ25lZCBpbmRleCA9IDA7IGlu ZGV4IDwgaW5kZXhDb3VudDsgKytpbmRleCkgewogICAgICAgICAgICAgdWludDMyX3QgZnVuY3Rp b25JbmRleDsKICAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMy KGZ1bmN0aW9uSW5kZXgpLCAiY2FuJ3QgZ2V0IEVsZW1lbnQgc2VjdGlvbidzICIsIGVsZW1lbnRO dW0sICJ0aCBlbGVtZW50J3MgIiwgaW5kZXgsICJ0aCBpbmRleCIpOwotICAgICAgICAgICAgV0FT TV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhT cGFjZS5zaXplKCksICJFbGVtZW50IHNlY3Rpb24ncyAiLCBlbGVtZW50TnVtLCAidGggZWxlbWVu dCdzICIsIGluZGV4LCAidGggaW5kZXggaXMgIiwgZnVuY3Rpb25JbmRleCwgIiB3aGljaCBleGNl ZWRzIHRoZSBmdW5jdGlvbiBpbmRleCBzcGFjZSBzaXplIG9mICIsIG1fcmVzdWx0LmZ1bmN0aW9u SW5kZXhTcGFjZS5zaXplKCkpOworICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5j dGlvbkluZGV4ID49IG1fcmVzdWx0Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpLCAi RWxlbWVudCBzZWN0aW9uJ3MgIiwgZWxlbWVudE51bSwgInRoIGVsZW1lbnQncyAiLCBpbmRleCwg InRoIGluZGV4IGlzICIsIGZ1bmN0aW9uSW5kZXgsICIgd2hpY2ggZXhjZWVkcyB0aGUgZnVuY3Rp b24gaW5kZXggc3BhY2Ugc2l6ZSBvZiAiLCBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhT cGFjZVNpemUoKSk7CiAKICAgICAgICAgICAgIGVsZW1lbnQuZnVuY3Rpb25JbmRpY2VzLnVuY2hl Y2tlZEFwcGVuZChmdW5jdGlvbkluZGV4KTsKICAgICAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5oIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5oCmluZGV4IDk2YzA0ZDQuLmVjYzQ3MzkgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuaAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmgKQEAgLTM2 LDcgKzM2LDYgQEAgbmFtZXNwYWNlIEpTQyB7IG5hbWVzcGFjZSBXYXNtIHsKIAogc3RydWN0IE1v ZHVsZVBhcnNlclJlc3VsdCB7CiAgICAgc3RkOjp1bmlxdWVfcHRyPE1vZHVsZUluZm9ybWF0aW9u PiBtb2R1bGU7Ci0gICAgRnVuY3Rpb25JbmRleFNwYWNlIGZ1bmN0aW9uSW5kZXhTcGFjZTsKICAg ICBWZWN0b3I8RnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5PiBmdW5jdGlvbkxvY2F0aW9uSW5CaW5h cnk7CiB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxh bi5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5jcHAKaW5kZXggYzg1 MzFjOC4uZGY1MzQwMiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bVBsYW4uY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmNwcApA QCAtNzYsOCArNzYsNiBAQCBib29sIFBsYW46OnBhcnNlQW5kVmFsaWRhdGVNb2R1bGUoKQogICAg ICAgICB9CiAgICAgICAgIG1fbW9kdWxlSW5mb3JtYXRpb24gPSBXVEZNb3ZlKHBhcnNlUmVzdWx0 LT5tb2R1bGUpOwogICAgICAgICBtX2Z1bmN0aW9uTG9jYXRpb25JbkJpbmFyeSA9IFdURk1vdmUo cGFyc2VSZXN1bHQtPmZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeSk7Ci0gICAgICAgIG1fZnVuY3Rp b25JbmRleFNwYWNlLnNpemUgPSBwYXJzZVJlc3VsdC0+ZnVuY3Rpb25JbmRleFNwYWNlLnNpemUo KTsKLSAgICAgICAgbV9mdW5jdGlvbkluZGV4U3BhY2UuYnVmZmVyID0gcGFyc2VSZXN1bHQtPmZ1 bmN0aW9uSW5kZXhTcGFjZS5yZWxlYXNlQnVmZmVyKCk7CiAgICAgfQogCiAgICAgZm9yICh1bnNp Z25lZCBmdW5jdGlvbkluZGV4ID0gMDsgZnVuY3Rpb25JbmRleCA8IG1fZnVuY3Rpb25Mb2NhdGlv bkluQmluYXJ5LnNpemUoKTsgKytmdW5jdGlvbkluZGV4KSB7CkBAIC04OSw3ICs4Nyw3IEBAIGJv b2wgUGxhbjo6cGFyc2VBbmRWYWxpZGF0ZU1vZHVsZSgpCiAgICAgICAgIFNpZ25hdHVyZUluZGV4 IHNpZ25hdHVyZUluZGV4ID0gbV9tb2R1bGVJbmZvcm1hdGlvbi0+aW50ZXJuYWxGdW5jdGlvblNp Z25hdHVyZUluZGljZXNbZnVuY3Rpb25JbmRleF07CiAgICAgICAgIGNvbnN0IFNpZ25hdHVyZSog c2lnbmF0dXJlID0gU2lnbmF0dXJlSW5mb3JtYXRpb246OmdldChtX3ZtLCBzaWduYXR1cmVJbmRl eCk7CiAKLSAgICAgICAgYXV0byB2YWxpZGF0aW9uUmVzdWx0ID0gdmFsaWRhdGVGdW5jdGlvbiht X3ZtLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBtX2Z1bmN0aW9u SW5kZXhTcGFjZSwgKm1fbW9kdWxlSW5mb3JtYXRpb24pOworICAgICAgICBhdXRvIHZhbGlkYXRp b25SZXN1bHQgPSB2YWxpZGF0ZUZ1bmN0aW9uKG1fdm0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9u TGVuZ3RoLCBzaWduYXR1cmUsICptX21vZHVsZUluZm9ybWF0aW9uKTsKICAgICAgICAgaWYgKCF2 YWxpZGF0aW9uUmVzdWx0KSB7CiAgICAgICAgICAgICBpZiAodmVyYm9zZSkgewogICAgICAgICAg ICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBmdW5jdGlvbkxlbmd0aDsgKytpKQpAQCAt MTI3LDcgKzEyNSw3IEBAIHZvaWQgUGxhbjo6cnVuKCkKICAgICAgICAgcmV0dXJuIHRydWU7CiAg ICAgfTsKIAotICAgIGlmICghdHJ5UmVzZXJ2ZUNhcGFjaXR5KG1fd2FzbVRvSlNTdHVicywgbV9t b2R1bGVJbmZvcm1hdGlvbi0+aW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnNpemUoKSwg IiBXZWJBc3NlbWJseSB0byBKYXZhU2NyaXB0IHN0dWJzIikKKyAgICBpZiAoIXRyeVJlc2VydmVD YXBhY2l0eShtX3dhc21FeGl0U3R1YnMsIG1fbW9kdWxlSW5mb3JtYXRpb24tPmltcG9ydEZ1bmN0 aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICIgV2ViQXNzZW1ibHkgdG8gSmF2YVNjcmlwdCBz dHVicyIpCiAgICAgICAgIHx8ICF0cnlSZXNlcnZlQ2FwYWNpdHkobV91bmxpbmtlZFdhc21Ub1dh c21DYWxscywgbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgpLCAiIHVubGlua2VkIFdl YkFzc2VtYmx5IHRvIFdlYkFzc2VtYmx5IGNhbGxzIikKICAgICAgICAgfHwgIXRyeVJlc2VydmVD YXBhY2l0eShtX3dhc21JbnRlcm5hbEZ1bmN0aW9ucywgbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5h cnkuc2l6ZSgpLCAiIFdlYkFzc2VtYmx5IGZ1bmN0aW9ucyIpCiAgICAgICAgIHx8ICF0cnlSZXNl cnZlQ2FwYWNpdHkobV9jb21waWxhdGlvbkNvbnRleHRzLCBtX2Z1bmN0aW9uTG9jYXRpb25JbkJp bmFyeS5zaXplKCksICIgY29tcGlsYXRpb24gY29udGV4dHMiKSkKQEAgLTE0MSwxMiArMTM5LDEx IEBAIHZvaWQgUGxhbjo6cnVuKCkKICAgICAgICAgSW1wb3J0KiBpbXBvcnQgPSAmbV9tb2R1bGVJ bmZvcm1hdGlvbi0+aW1wb3J0c1tpbXBvcnRJbmRleF07CiAgICAgICAgIGlmIChpbXBvcnQtPmtp bmQgIT0gRXh0ZXJuYWxLaW5kOjpGdW5jdGlvbikKICAgICAgICAgICAgIGNvbnRpbnVlOwotICAg ICAgICB1bnNpZ25lZCBpbXBvcnRGdW5jdGlvbkluZGV4ID0gbV93YXNtVG9KU1N0dWJzLnNpemUo KTsKKyAgICAgICAgdW5zaWduZWQgaW1wb3J0RnVuY3Rpb25JbmRleCA9IG1fd2FzbUV4aXRTdHVi cy5zaXplKCk7CiAgICAgICAgIGlmICh2ZXJib3NlKQogICAgICAgICAgICAgZGF0YUxvZ0xuKCJQ cm9jZXNzaW5nIGltcG9ydCBmdW5jdGlvbiBudW1iZXIgIiwgaW1wb3J0RnVuY3Rpb25JbmRleCwg IjogIiwgaW1wb3J0LT5tb2R1bGUsICI6ICIsIGltcG9ydC0+ZmllbGQpOwogICAgICAgICBTaWdu YXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fbW9kdWxlSW5mb3JtYXRpb24tPmltcG9ydEZ1 bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5hdChpbXBvcnQtPmtpbmRJbmRleCk7Ci0gICAgICAgIG1f d2FzbVRvSlNTdHVicy51bmNoZWNrZWRBcHBlbmQoaW1wb3J0U3R1YkdlbmVyYXRvcihtX3ZtLCBt X2NhbGxMaW5rSW5mb3MsIHNpZ25hdHVyZUluZGV4LCBpbXBvcnRGdW5jdGlvbkluZGV4KSk7Ci0g ICAgICAgIG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtpbXBvcnRGdW5jdGlvbklu ZGV4XS5jb2RlID0gbV93YXNtVG9KU1N0dWJzW2ltcG9ydEZ1bmN0aW9uSW5kZXhdLmNvZGUoKS5l eGVjdXRhYmxlQWRkcmVzcygpOworICAgICAgICBtX3dhc21FeGl0U3R1YnMudW5jaGVja2VkQXBw ZW5kKGV4aXRTdHViR2VuZXJhdG9yKG1fdm0sIG1fY2FsbExpbmtJbmZvcywgc2lnbmF0dXJlSW5k ZXgsIGltcG9ydEZ1bmN0aW9uSW5kZXgpKTsKICAgICB9CiAKICAgICBtX2N1cnJlbnRJbmRleCA9 IDA7CkBAIC0xNjcsMTIgKzE2NCwxMiBAQCB2b2lkIFBsYW46OnJ1bigpCiAgICAgICAgICAgICBB U1NFUlQoZnVuY3Rpb25MZW5ndGggPD0gbV9zb3VyY2VMZW5ndGgpOwogICAgICAgICAgICAgU2ln bmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtX21vZHVsZUluZm9ybWF0aW9uLT5pbnRlcm5h bEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4XTsKICAgICAgICAgICAgIGNv bnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlID0gU2lnbmF0dXJlSW5mb3JtYXRpb246OmdldChtX3Zt LCBzaWduYXR1cmVJbmRleCk7Ci0gICAgICAgICAgICB1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3Bh Y2UgPSBtX3dhc21Ub0pTU3R1YnMuc2l6ZSgpICsgZnVuY3Rpb25JbmRleDsKLSAgICAgICAgICAg IEFTU0VSVF9VTlVTRUQoZnVuY3Rpb25JbmRleFNwYWNlLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5i dWZmZXIuZ2V0KClbZnVuY3Rpb25JbmRleFNwYWNlXS5zaWduYXR1cmVJbmRleCA9PSBzaWduYXR1 cmVJbmRleCk7Ci0gICAgICAgICAgICBBU1NFUlQodmFsaWRhdGVGdW5jdGlvbihtX3ZtLCBmdW5j dGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBtX2Z1bmN0aW9uSW5kZXhTcGFj ZSwgKm1fbW9kdWxlSW5mb3JtYXRpb24pKTsKKyAgICAgICAgICAgIHVuc2lnbmVkIGZ1bmN0aW9u SW5kZXhTcGFjZSA9IG1fd2FzbUV4aXRTdHVicy5zaXplKCkgKyBmdW5jdGlvbkluZGV4OworICAg ICAgICAgICAgQVNTRVJUX1VOVVNFRChmdW5jdGlvbkluZGV4U3BhY2UsIG1fbW9kdWxlSW5mb3Jt YXRpb24tPnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4 U3BhY2UpID09IHNpZ25hdHVyZUluZGV4KTsKKyAgICAgICAgICAgIEFTU0VSVCh2YWxpZGF0ZUZ1 bmN0aW9uKG1fdm0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWduYXR1cmUsICpt X21vZHVsZUluZm9ybWF0aW9uKSk7CiAKICAgICAgICAgICAgIG1fdW5saW5rZWRXYXNtVG9XYXNt Q2FsbHNbZnVuY3Rpb25JbmRleF0gPSBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4oKTsK LSAgICAgICAgICAgIGF1dG8gcGFyc2VBbmRDb21waWxlUmVzdWx0ID0gcGFyc2VBbmRDb21waWxl KCptX3ZtLCBtX2NvbXBpbGF0aW9uQ29udGV4dHNbZnVuY3Rpb25JbmRleF0sIGZ1bmN0aW9uU3Rh cnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWduYXR1cmUsIG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHNb ZnVuY3Rpb25JbmRleF0sIG1fZnVuY3Rpb25JbmRleFNwYWNlLCAqbV9tb2R1bGVJbmZvcm1hdGlv bik7CisgICAgICAgICAgICBhdXRvIHBhcnNlQW5kQ29tcGlsZVJlc3VsdCA9IHBhcnNlQW5kQ29t cGlsZSgqbV92bSwgbV9jb21waWxhdGlvbkNvbnRleHRzW2Z1bmN0aW9uSW5kZXhdLCBmdW5jdGlv blN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBtX3VubGlua2VkV2FzbVRvV2FzbUNh bGxzW2Z1bmN0aW9uSW5kZXhdLCAqbV9tb2R1bGVJbmZvcm1hdGlvbik7CiAKICAgICAgICAgICAg IGlmIChVTkxJS0VMWSghcGFyc2VBbmRDb21waWxlUmVzdWx0KSkgewogICAgICAgICAgICAgICAg IGF1dG8gbG9ja2VyID0gaG9sZExvY2sobV9sb2NrKTsKQEAgLTIyMyw5ICsyMjAsNiBAQCB2b2lk IFBsYW46OnJ1bigpCiAgICAgICAgICAgICAgICAgICAgIHN0ZDo6bWFrZV91bmlxdWU8QjM6OkNv bXBpbGF0aW9uPihGSU5BTElaRV9DT0RFKGxpbmtCdWZmZXIsICgiV2FzbSBKUyBlbnRyeXBvaW50 IikpLCBXVEZNb3ZlKGNvbnRleHQuanNFbnRyeXBvaW50Qnlwcm9kdWN0cykpOwogICAgICAgICAg ICAgfQogICAgICAgICB9Ci0KLSAgICAgICAgdW5zaWduZWQgZnVuY3Rpb25JbmRleFNwYWNlID0g bV93YXNtVG9KU1N0dWJzLnNpemUoKSArIGZ1bmN0aW9uSW5kZXg7Ci0gICAgICAgIG1fZnVuY3Rp b25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtmdW5jdGlvbkluZGV4U3BhY2VdLmNvZGUgPSBtX3dh c21JbnRlcm5hbEZ1bmN0aW9uc1tmdW5jdGlvbkluZGV4XS0+d2FzbUVudHJ5cG9pbnQuY29tcGls YXRpb24tPmNvZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpOwogICAgIH0KIAogICAgIGlmICh2ZXJi b3NlIHx8IE9wdGlvbnM6OnJlcG9ydENvbXBpbGVUaW1lcygpKSB7CkBAIC0yMzUsOCArMjI5LDE5 IEBAIHZvaWQgUGxhbjo6cnVuKCkKIAogICAgIC8vIFBhdGNoIHRoZSBjYWxsIHNpdGVzIGZvciBl YWNoIFdlYkFzc2VtYmx5IGZ1bmN0aW9uLgogICAgIGZvciAoYXV0byYgdW5saW5rZWQgOiBtX3Vu bGlua2VkV2FzbVRvV2FzbUNhbGxzKSB7Ci0gICAgICAgIGZvciAoYXV0byYgY2FsbCA6IHVubGlu a2VkKQotICAgICAgICAgICAgTWFjcm9Bc3NlbWJsZXI6OnJlcGF0Y2hDYWxsKGNhbGwuY2FsbExv Y2F0aW9uLCBDb2RlTG9jYXRpb25MYWJlbChtX2Z1bmN0aW9uSW5kZXhTcGFjZS5idWZmZXIuZ2V0 KClbY2FsbC5mdW5jdGlvbkluZGV4XS5jb2RlKSk7CisgICAgICAgIGZvciAoYXV0byYgY2FsbCA6 IHVubGlua2VkKSB7CisgICAgICAgICAgICB2b2lkKiBleGVjdXRhYmxlQWRkcmVzczsKKyAgICAg ICAgICAgIGlmIChtX21vZHVsZUluZm9ybWF0aW9uLT5pc0ltcG9ydGVkRnVuY3Rpb25Gcm9tRnVu Y3Rpb25JbmRleFNwYWNlKGNhbGwuZnVuY3Rpb25JbmRleCkpIHsKKyAgICAgICAgICAgICAgICAv LyBGSVhNRSBpbXBvcnRzIGNvdWxkIGhhdmUgYmVlbiBsaW5rZWQgaW4gQjMsIGluc3RlYWQgb2Yg Z2VuZXJhdGluZyBhIHBhdGNocG9pbnQuIFRoaXMgY29uZGl0aW9uIHNob3VsZCBiZSByZXBsYWNl ZCBieSBhIFJFTEVBU0VfQVNTRVJULiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MTY2NDYyCisgICAgICAgICAgICAgICAgZXhlY3V0YWJsZUFkZHJlc3MgPSBjYWxsLnRv SlMKKyAgICAgICAgICAgICAgICAgICAgPyBtX3dhc21FeGl0U3R1YnMuYXQoY2FsbC5mdW5jdGlv bkluZGV4KS53YXNtVG9KUy5jb2RlKCkuZXhlY3V0YWJsZUFkZHJlc3MoKQorICAgICAgICAgICAg ICAgICAgICA6IG1fd2FzbUV4aXRTdHVicy5hdChjYWxsLmZ1bmN0aW9uSW5kZXgpLndhc21Ub1dh c20uY29kZSgpLmV4ZWN1dGFibGVBZGRyZXNzKCk7CisgICAgICAgICAgICB9IGVsc2UgeworICAg ICAgICAgICAgICAgIEFTU0VSVCghY2FsbC50b0pTKTsKKyAgICAgICAgICAgICAgICBleGVjdXRh YmxlQWRkcmVzcyA9IG1fd2FzbUludGVybmFsRnVuY3Rpb25zLmF0KGNhbGwuZnVuY3Rpb25JbmRl eCAtIG1fd2FzbUV4aXRTdHVicy5zaXplKCkpLT53YXNtRW50cnlwb2ludC5jb21waWxhdGlvbi0+ Y29kZSgpLmV4ZWN1dGFibGVBZGRyZXNzKCk7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBN YWNyb0Fzc2VtYmxlcjo6cmVwYXRjaENhbGwoY2FsbC5jYWxsTG9jYXRpb24sIENvZGVMb2NhdGlv bkxhYmVsKGV4ZWN1dGFibGVBZGRyZXNzKSk7CisgICAgICAgIH0KICAgICB9CiAKICAgICBtX2Zh aWxlZCA9IGZhbHNlOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bVBsYW4uaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmgKaW5kZXggM2Ji MDFjOC4uODMxNTk2NSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bVBsYW4uaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5oCkBAIC04 NiwyNiArODYsMTkgQEAgcHVibGljOgogICAgICAgICByZXR1cm4gV1RGTW92ZShtX2NhbGxMaW5r SW5mb3MpOwogICAgIH0KIAotICAgIFZlY3RvcjxXYXNtVG9KU1N0dWI+JiYgdGFrZVdhc21Ub0pT U3R1YnMoKQorICAgIFZlY3RvcjxXYXNtRXhpdFN0dWJzPiYmIHRha2VXYXNtRXhpdFN0dWJzKCkK ICAgICB7CiAgICAgICAgIFJFTEVBU0VfQVNTRVJUKCFmYWlsZWQoKSk7Ci0gICAgICAgIHJldHVy biBXVEZNb3ZlKG1fd2FzbVRvSlNTdHVicyk7Ci0gICAgfQotCi0gICAgSW1tdXRhYmxlRnVuY3Rp b25JbmRleFNwYWNlJiYgdGFrZUZ1bmN0aW9uSW5kZXhTcGFjZSgpCi0gICAgewotICAgICAgICBS RUxFQVNFX0FTU0VSVCghZmFpbGVkKCkpOwotICAgICAgICByZXR1cm4gV1RGTW92ZShtX2Z1bmN0 aW9uSW5kZXhTcGFjZSk7CisgICAgICAgIHJldHVybiBXVEZNb3ZlKG1fd2FzbUV4aXRTdHVicyk7 CiAgICAgfQogCiBwcml2YXRlOgogICAgIHN0ZDo6dW5pcXVlX3B0cjxNb2R1bGVJbmZvcm1hdGlv bj4gbV9tb2R1bGVJbmZvcm1hdGlvbjsKICAgICBWZWN0b3I8RnVuY3Rpb25Mb2NhdGlvbkluQmlu YXJ5PiBtX2Z1bmN0aW9uTG9jYXRpb25JbkJpbmFyeTsKICAgICBCYWc8Q2FsbExpbmtJbmZvPiBt X2NhbGxMaW5rSW5mb3M7Ci0gICAgVmVjdG9yPFdhc21Ub0pTU3R1Yj4gbV93YXNtVG9KU1N0dWJz OworICAgIFZlY3RvcjxXYXNtRXhpdFN0dWJzPiBtX3dhc21FeGl0U3R1YnM7CiAgICAgVmVjdG9y PHN0ZDo6dW5pcXVlX3B0cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4+IG1fd2FzbUludGVybmFsRnVu Y3Rpb25zOwogICAgIFZlY3RvcjxDb21waWxhdGlvbkNvbnRleHQ+IG1fY29tcGlsYXRpb25Db250 ZXh0czsKLSAgICBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UgbV9mdW5jdGlvbkluZGV4U3Bh Y2U7CiAKICAgICBWTSogbV92bTsKICAgICBWZWN0b3I8VmVjdG9yPFVubGlua2VkV2FzbVRvV2Fz bUNhbGw+PiBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzOwpkaWZmIC0tZ2l0IGEvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtU2lnbmF0dXJlLmNwcAppbmRleCA2ZDViMWY2Li45OTdiZDA2IDEwMDY0NAot LS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmNwcAorKysgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmNwcApAQCAtNDEsNiArNDEs MTkgQEAgY29uc3QgYm9vbCB2ZXJib3NlID0gZmFsc2U7CiAKIGNvbnN0IGNvbnN0ZXhwciBTaWdu YXR1cmVJbmRleCBTaWduYXR1cmU6OmludmFsaWRJbmRleDsKIAorU3RyaW5nIFNpZ25hdHVyZTo6 dG9TdHJpbmcoKSBjb25zdAoreworICAgIFN0cmluZyByZXN1bHQobWFrZVN0cmluZyhyZXR1cm5U eXBlKCkpKTsKKyAgICByZXN1bHQuYXBwZW5kKCIgKCIpOworICAgIGZvciAoU2lnbmF0dXJlQXJn Q291bnQgYXJnID0gMDsgYXJnIDwgYXJndW1lbnRDb3VudCgpOyArK2FyZykgeworICAgICAgICBp ZiAoYXJnKQorICAgICAgICAgICAgcmVzdWx0LmFwcGVuZCgiLCAiKTsKKyAgICAgICAgcmVzdWx0 LmFwcGVuZChtYWtlU3RyaW5nKGFyZ3VtZW50KGFyZykpKTsKKyAgICB9CisgICAgcmVzdWx0LmFw cGVuZCgnKScpOworICAgIHJldHVybiByZXN1bHQ7Cit9CisKIHZvaWQgU2lnbmF0dXJlOjpkdW1w KFByaW50U3RyZWFtJiBvdXQpIGNvbnN0CiB7CiAgICAgb3V0LnByaW50KG1ha2VTdHJpbmcocmV0 dXJuVHlwZSgpKSwgIiAoIik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtU2lnbmF0dXJlLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0 dXJlLmgKaW5kZXggMGQ2YzdiNS4uNGQ0M2ZmYyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21TaWduYXR1cmUuaApAQCAtODIsNiArODIsNyBAQCBwdWJsaWM6CiAgICAgfQogICAg IFR5cGUgYXJndW1lbnQoU2lnbmF0dXJlQXJnQ291bnQgaSkgY29uc3QgeyByZXR1cm4gY29uc3Rf Y2FzdDxTaWduYXR1cmUqPih0aGlzKS0+YXJndW1lbnQoaSk7IH0KIAorICAgIFdURjo6U3RyaW5n IHRvU3RyaW5nKCkgY29uc3Q7CiAgICAgdm9pZCBkdW1wKFdURjo6UHJpbnRTdHJlYW0mIG91dCkg Y29uc3Q7CiAgICAgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFNpZ25hdHVyZSYgcmhzKSBjb25zdAog ICAgIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0 ZS5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwCmluZGV4 IDI2MTM3MGIuLmE2ODc0ODEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21WYWxpZGF0ZS5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZh bGlkYXRlLmNwcApAQCAtMzYyLDEwICszNjIsMTAgQEAgdm9pZCBWYWxpZGF0ZTo6ZHVtcChjb25z dCBWZWN0b3I8Q29udHJvbEVudHJ5PiYsIGNvbnN0IEV4cHJlc3Npb25MaXN0JikKICAgICAvLyBU aGluayBvZiB0aGlzIGFzIHBlbmFuY2UgZm9yIHRoZSBzaW4gb2YgYmFkIGVycm9yIG1lc3NhZ2Vz LgogfQogCi1FeHBlY3RlZDx2b2lkLCBTdHJpbmc+IHZhbGlkYXRlRnVuY3Rpb24oVk0qIHZtLCBj b25zdCB1aW50OF90KiBzb3VyY2UsIHNpemVfdCBsZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2ln bmF0dXJlLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIGZ1bmN0aW9uSW5kZXhT cGFjZSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIG1vZHVsZSkKK0V4cGVjdGVkPHZvaWQsIFN0 cmluZz4gdmFsaWRhdGVGdW5jdGlvbihWTSogdm0sIGNvbnN0IHVpbnQ4X3QqIHNvdXJjZSwgc2l6 ZV90IGxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUsIGNvbnN0IE1vZHVsZUluZm9y bWF0aW9uJiBtb2R1bGUpCiB7CiAgICAgVmFsaWRhdGUgY29udGV4dChtb2R1bGUpOwotICAgIEZ1 bmN0aW9uUGFyc2VyPFZhbGlkYXRlPiB2YWxpZGF0b3Iodm0sIGNvbnRleHQsIHNvdXJjZSwgbGVu Z3RoLCBzaWduYXR1cmUsIGZ1bmN0aW9uSW5kZXhTcGFjZSwgbW9kdWxlKTsKKyAgICBGdW5jdGlv blBhcnNlcjxWYWxpZGF0ZT4gdmFsaWRhdG9yKHZtLCBjb250ZXh0LCBzb3VyY2UsIGxlbmd0aCwg c2lnbmF0dXJlLCBtb2R1bGUpOwogICAgIFdBU01fRkFJTF9JRl9IRUxQRVJfRkFJTFModmFsaWRh dG9yLnBhcnNlKCkpOwogICAgIHJldHVybiB7IH07CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21WYWxpZGF0ZS5oCmluZGV4IDE0ODIxZjIuLmViMWFkOGMgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5oCisrKyBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5oCkBAIC0zNiw3ICszNiw3IEBAIGNsYXNzIFZN OwogCiBuYW1lc3BhY2UgV2FzbSB7CiAKLUV4cGVjdGVkPHZvaWQsIFN0cmluZz4gdmFsaWRhdGVG dW5jdGlvbihWTSosIGNvbnN0IHVpbnQ4X3QqLCBzaXplX3QsIGNvbnN0IFNpZ25hdHVyZSosIGNv bnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9u Jik7CitFeHBlY3RlZDx2b2lkLCBTdHJpbmc+IHZhbGlkYXRlRnVuY3Rpb24oVk0qLCBjb25zdCB1 aW50OF90Kiwgc2l6ZV90LCBjb25zdCBTaWduYXR1cmUqLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlv biYpOwogCiB9IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2FzbQogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaCBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5oCmluZGV4IGYzNGIw NTIuLjk5YTJjOTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pT V2ViQXNzZW1ibHlJbnN0YW5jZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pz L0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5oCkBAIC04Niw4ICs4NiwxMSBAQCBwdWJsaWM6CiAgICAg ICAgIHJldHVybiBvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucygpICsgc2l6ZW9mKFdyaXRlQmFycmll cjxKU0NlbGw+KSAqIGlkeDsKICAgICB9CiAKKyAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9m TWVtb3J5KCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKEpTV2ViQXNzZW1ibHlJbnN0YW5jZSwg bV9tZW1vcnkpOyB9CiAgICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZlRhYmxlKCkgeyByZXR1 cm4gT0JKRUNUX09GRlNFVE9GKEpTV2ViQXNzZW1ibHlJbnN0YW5jZSwgbV90YWJsZSk7IH0KICAg ICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mR2xvYmFscygpIHsgcmV0dXJuIE9CSkVDVF9PRkZT RVRPRihKU1dlYkFzc2VtYmx5SW5zdGFuY2UsIG1fZ2xvYmFscyk7IH0KKyAgICBzdGF0aWMgc2l6 ZV90IG9mZnNldE9mSW1wb3J0RnVuY3Rpb25zKCkgeyByZXR1cm4gV1RGOjpyb3VuZFVwVG9NdWx0 aXBsZU9mPHNpemVvZihXcml0ZUJhcnJpZXI8SlNDZWxsPik+KHNpemVvZihKU1dlYkFzc2VtYmx5 SW5zdGFuY2UpKTsgfQorICAgIHN0YXRpYyBzaXplX3Qgb2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbihz aXplX3QgaW1wb3J0RnVuY3Rpb25OdW0pIHsgcmV0dXJuIG9mZnNldE9mSW1wb3J0RnVuY3Rpb25z KCkgKyBpbXBvcnRGdW5jdGlvbk51bSAqIHNpemVvZihzaXplb2YoV3JpdGVCYXJyaWVyPEpTQ2Vs bD4pKTsgfQogCiBwcm90ZWN0ZWQ6CiAgICAgSlNXZWJBc3NlbWJseUluc3RhbmNlKFZNJiwgU3Ry dWN0dXJlKiwgdW5zaWduZWQgbnVtSW1wb3J0RnVuY3Rpb25zKTsKQEAgLTk1LDExICs5OCw2IEBA IHByb3RlY3RlZDoKICAgICBzdGF0aWMgdm9pZCBkZXN0cm95KEpTQ2VsbCopOwogICAgIHN0YXRp YyB2b2lkIHZpc2l0Q2hpbGRyZW4oSlNDZWxsKiwgU2xvdFZpc2l0b3ImKTsKIAotICAgIHN0YXRp YyBzaXplX3Qgb2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbnMoKQotICAgIHsKLSAgICAgICAgcmV0dXJu IFdURjo6cm91bmRVcFRvTXVsdGlwbGVPZjxzaXplb2YoV3JpdGVCYXJyaWVyPEpTQ2VsbD4pPihz aXplb2YoSlNXZWJBc3NlbWJseUluc3RhbmNlKSk7Ci0gICAgfQotCiAgICAgc3RhdGljIHNpemVf dCBhbGxvY2F0aW9uU2l6ZSh1bnNpZ25lZCBudW1JbXBvcnRGdW5jdGlvbnMpCiAgICAgewogICAg ICAgICByZXR1cm4gb2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbnMoKSArIHNpemVvZihXcml0ZUJhcnJp ZXI8SlNDZWxsPikgKiBudW1JbXBvcnRGdW5jdGlvbnM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNwcCBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuY3BwCmluZGV4IGJjNDQ5YTgu LjQ1MWJmNzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2Vi QXNzZW1ibHlNZW1vcnkuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pT V2ViQXNzZW1ibHlNZW1vcnkuY3BwCkBAIC0zNyw5ICszNyw5IEBAIG5hbWVzcGFjZSBKU0Mgewog CiBjb25zdCBDbGFzc0luZm8gSlNXZWJBc3NlbWJseU1lbW9yeTo6c19pbmZvID0geyAiV2ViQXNz ZW1ibHkuTWVtb3J5IiwgJkJhc2U6OnNfaW5mbywgMCwgQ1JFQVRFX01FVEhPRF9UQUJMRShKU1dl YkFzc2VtYmx5TWVtb3J5KSB9OwogCi1KU1dlYkFzc2VtYmx5TWVtb3J5KiBKU1dlYkFzc2VtYmx5 TWVtb3J5OjpjcmVhdGUoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVf cHRyPFdhc206Ok1lbW9yeT4mJiBtZW1vcnkpCitKU1dlYkFzc2VtYmx5TWVtb3J5KiBKU1dlYkFz c2VtYmx5TWVtb3J5OjpjcmVhdGUoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgV2FzbTo6 TWVtb3J5JiYgbWVtb3J5KQogewotICAgIGF1dG8qIGluc3RhbmNlID0gbmV3IChOb3ROdWxsLCBh bGxvY2F0ZUNlbGw8SlNXZWJBc3NlbWJseU1lbW9yeT4odm0uaGVhcCkpIEpTV2ViQXNzZW1ibHlN ZW1vcnkodm0sIHN0cnVjdHVyZSwgV1RGTW92ZShtZW1vcnkpKTsKKyAgICBhdXRvKiBpbnN0YW5j ZSA9IG5ldyAoTm90TnVsbCwgYWxsb2NhdGVDZWxsPEpTV2ViQXNzZW1ibHlNZW1vcnk+KHZtLmhl YXApKSBKU1dlYkFzc2VtYmx5TWVtb3J5KHZtLCBzdHJ1Y3R1cmUsIHN0ZDo6Zm9yd2FyZDxXYXNt OjpNZW1vcnk+KG1lbW9yeSkpOwogICAgIGluc3RhbmNlLT5maW5pc2hDcmVhdGlvbih2bSk7CiAg ICAgcmV0dXJuIGluc3RhbmNlOwogfQpAQCAtNDksNyArNDksNyBAQCBTdHJ1Y3R1cmUqIEpTV2Vi QXNzZW1ibHlNZW1vcnk6OmNyZWF0ZVN0cnVjdHVyZShWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBn bG9iYWxPYgogICAgIHJldHVybiBTdHJ1Y3R1cmU6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LCBw cm90b3R5cGUsIFR5cGVJbmZvKE9iamVjdFR5cGUsIFN0cnVjdHVyZUZsYWdzKSwgaW5mbygpKTsK IH0KIAotSlNXZWJBc3NlbWJseU1lbW9yeTo6SlNXZWJBc3NlbWJseU1lbW9yeShWTSYgdm0sIFN0 cnVjdHVyZSogc3RydWN0dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiYmIG1lbW9y eSkKK0pTV2ViQXNzZW1ibHlNZW1vcnk6OkpTV2ViQXNzZW1ibHlNZW1vcnkoVk0mIHZtLCBTdHJ1 Y3R1cmUqIHN0cnVjdHVyZSwgV2FzbTo6TWVtb3J5JiYgbWVtb3J5KQogICAgIDogQmFzZSh2bSwg c3RydWN0dXJlKQogICAgICwgbV9tZW1vcnkoV1RGTW92ZShtZW1vcnkpKQogewpAQCAtNjMsNyAr NjMsNyBAQCBKU0FycmF5QnVmZmVyKiBKU1dlYkFzc2VtYmx5TWVtb3J5OjpidWZmZXIoVk0mIHZt LCBKU0dsb2JhbE9iamVjdCogZ2xvYmFsT2JqZWN0KQogICAgIGF1dG8gZGVzdHJ1Y3RvciA9IFtd ICh2b2lkKikgewogICAgICAgICAvLyBXZSBkb24ndCBuZWVkIHRvIGRvIGFueXRoaW5nIGhlcmUg dG8gZGVzdHJveSB0aGUgbWVtb3J5LgogICAgICAgICAvLyBUaGUgQXJyYXlCdWZmZXIgYmFja2lu ZyB0aGUgSlNBcnJheUJ1ZmZlciBpcyBvbmx5IG93bmVkIGJ5IHVzLAotICAgICAgICAvLyBzbyB3 ZSBndWFyYW50ZWUgaXRzIGxpZmVjeWxjZS4KKyAgICAgICAgLy8gc28gd2UgZ3VhcmFudGVlIGl0 cyBsaWZlY3ljbGUuCiAgICAgfTsKICAgICBtX2J1ZmZlciA9IEFycmF5QnVmZmVyOjpjcmVhdGVG cm9tQnl0ZXMobWVtb3J5KCktPm1lbW9yeSgpLCBtZW1vcnkoKS0+c2l6ZSgpLCBXVEZNb3ZlKGRl c3RydWN0b3IpKTsKICAgICBtX2J1ZmZlcldyYXBwZXIuc2V0KHZtLCB0aGlzLCBKU0FycmF5QnVm ZmVyOjpjcmVhdGUodm0sIGdsb2JhbE9iamVjdC0+bV9hcnJheUJ1ZmZlclN0cnVjdHVyZS5nZXQo KSwgbV9idWZmZXIuZ2V0KCkpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuaAppbmRleCAxZDQzYzk1Li42YzI2NGM4IDEwMDY0NAot LS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmgK KysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5o CkBAIC00MSwyMSArNDEsMjQgQEAgY2xhc3MgSlNXZWJBc3NlbWJseU1lbW9yeSA6IHB1YmxpYyBK U0Rlc3RydWN0aWJsZU9iamVjdCB7CiBwdWJsaWM6CiAgICAgdHlwZWRlZiBKU0Rlc3RydWN0aWJs ZU9iamVjdCBCYXNlOwogCi0gICAgc3RhdGljIEpTV2ViQXNzZW1ibHlNZW1vcnkqIGNyZWF0ZShW TSYsIFN0cnVjdHVyZSosIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+JiYpOworICAgIHN0 YXRpYyBKU1dlYkFzc2VtYmx5TWVtb3J5KiBjcmVhdGUoVk0mLCBTdHJ1Y3R1cmUqLCBXYXNtOjpN ZW1vcnkmJik7CiAgICAgc3RhdGljIFN0cnVjdHVyZSogY3JlYXRlU3RydWN0dXJlKFZNJiwgSlNH bG9iYWxPYmplY3QqLCBKU1ZhbHVlKTsKIAogICAgIERFQ0xBUkVfSU5GTzsKIAotICAgIFdhc206 Ok1lbW9yeSogbWVtb3J5KCkgeyByZXR1cm4gbV9tZW1vcnkuZ2V0KCk7IH0KKyAgICBXYXNtOjpN ZW1vcnkqIG1lbW9yeSgpIHsgcmV0dXJuICZtX21lbW9yeTsgfQogICAgIEpTQXJyYXlCdWZmZXIq IGJ1ZmZlcihWTSYgdm0sIEpTR2xvYmFsT2JqZWN0Kik7CiAKKyAgICBzdGF0aWMgcHRyZGlmZl90 IG9mZnNldE9mTWVtb3J5KCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKEpTV2ViQXNzZW1ibHlN ZW1vcnksIG1fbWVtb3J5KSArIFdhc206Ok1lbW9yeTo6b2Zmc2V0T2ZNZW1vcnkoKTsgfQorICAg IHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZTaXplKCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9G KEpTV2ViQXNzZW1ibHlNZW1vcnksIG1fbWVtb3J5KSArIFdhc206Ok1lbW9yeTo6b2Zmc2V0T2ZT aXplKCk7IH0KKwogcHJvdGVjdGVkOgotICAgIEpTV2ViQXNzZW1ibHlNZW1vcnkoVk0mLCBTdHJ1 Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiYmKTsKKyAgICBKU1dlYkFzc2Vt Ymx5TWVtb3J5KFZNJiwgU3RydWN0dXJlKiwgV2FzbTo6TWVtb3J5JiYpOwogICAgIHZvaWQgZmlu aXNoQ3JlYXRpb24oVk0mKTsKICAgICBzdGF0aWMgdm9pZCBkZXN0cm95KEpTQ2VsbCopOwogICAg IHN0YXRpYyB2b2lkIHZpc2l0Q2hpbGRyZW4oSlNDZWxsKiwgU2xvdFZpc2l0b3ImKTsKIAotICAg IHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+IG1fbWVtb3J5OworICAgIFdhc206Ok1lbW9y eSBtX21lbW9yeTsKICAgICBXcml0ZUJhcnJpZXI8SlNBcnJheUJ1ZmZlcj4gbV9idWZmZXJXcmFw cGVyOwogICAgIFJlZlB0cjxBcnJheUJ1ZmZlcj4gbV9idWZmZXI7CiB9OwpkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5jcHAgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmNwcAppbmRl eCBkNjUyNGM1Li5mYTBlODU5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmNwcApAQCAtMzgsOSArMzgsOSBAQCBuYW1lc3Bh Y2UgSlNDIHsKIAogY29uc3QgQ2xhc3NJbmZvIEpTV2ViQXNzZW1ibHlNb2R1bGU6OnNfaW5mbyA9 IHsgIldlYkFzc2VtYmx5Lk1vZHVsZSIsICZCYXNlOjpzX2luZm8sIG51bGxwdHIsIENSRUFURV9N RVRIT0RfVEFCTEUoSlNXZWJBc3NlbWJseU1vZHVsZSkgfTsKIAotSlNXZWJBc3NlbWJseU1vZHVs ZSogSlNXZWJBc3NlbWJseU1vZHVsZTo6Y3JlYXRlKFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1 cmUsIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4mJiBtb2R1bGVJbmZv cm1hdGlvbiwgQmFnPENhbGxMaW5rSW5mbz4mJiBjYWxsTGlua0luZm9zLCBWZWN0b3I8V2FzbTo6 V2FzbVRvSlNTdHViPiYmIHdhc21Ub0pTU3R1YnMsIFdhc206OkltbXV0YWJsZUZ1bmN0aW9uSW5k ZXhTcGFjZSYmIGZ1bmN0aW9uSW5kZXhTcGFjZSwgU3ltYm9sVGFibGUqIGV4cG9ydFN5bWJvbFRh YmxlLCB1bnNpZ25lZCBjYWxsZWVDb3VudCkKK0pTV2ViQXNzZW1ibHlNb2R1bGUqIEpTV2ViQXNz ZW1ibHlNb2R1bGU6OmNyZWF0ZShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBzdGQ6OnVu aXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYgbW9kdWxlSW5mb3JtYXRpb24sIEJh ZzxDYWxsTGlua0luZm8+JiYgY2FsbExpbmtJbmZvcywgVmVjdG9yPFdhc206Oldhc21FeGl0U3R1 YnM+JiYgd2FzbUV4aXRTdHVicywgU3ltYm9sVGFibGUqIGV4cG9ydFN5bWJvbFRhYmxlLCB1bnNp Z25lZCBjYWxsZWVDb3VudCkKIHsKLSAgICBhdXRvKiBpbnN0YW5jZSA9IG5ldyAoTm90TnVsbCwg YWxsb2NhdGVDZWxsPEpTV2ViQXNzZW1ibHlNb2R1bGU+KHZtLmhlYXAsIGFsbG9jYXRpb25TaXpl KGNhbGxlZUNvdW50KSkpIEpTV2ViQXNzZW1ibHlNb2R1bGUodm0sIHN0cnVjdHVyZSwgc3RkOjpm b3J3YXJkPHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4+KG1vZHVsZUlu Zm9ybWF0aW9uKSwgc3RkOjpmb3J3YXJkPEJhZzxDYWxsTGlua0luZm8+PihjYWxsTGlua0luZm9z KSwgc3RkOjpmb3J3YXJkPFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0dWI+Pih3YXNtVG9KU1N0dWJz KSwgc3RkOjpmb3J3YXJkPFdhc206OkltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZT4oZnVuY3Rp b25JbmRleFNwYWNlKSwgY2FsbGVlQ291bnQpOworICAgIGF1dG8qIGluc3RhbmNlID0gbmV3IChO b3ROdWxsLCBhbGxvY2F0ZUNlbGw8SlNXZWJBc3NlbWJseU1vZHVsZT4odm0uaGVhcCwgYWxsb2Nh dGlvblNpemUoY2FsbGVlQ291bnQpKSkgSlNXZWJBc3NlbWJseU1vZHVsZSh2bSwgc3RydWN0dXJl LCBzdGQ6OmZvcndhcmQ8c3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPj4o bW9kdWxlSW5mb3JtYXRpb24pLCBzdGQ6OmZvcndhcmQ8QmFnPENhbGxMaW5rSW5mbz4+KGNhbGxM aW5rSW5mb3MpLCBzdGQ6OmZvcndhcmQ8VmVjdG9yPFdhc206Oldhc21FeGl0U3R1YnM+Pih3YXNt RXhpdFN0dWJzKSwgY2FsbGVlQ291bnQpOwogICAgIGluc3RhbmNlLT5maW5pc2hDcmVhdGlvbih2 bSwgZXhwb3J0U3ltYm9sVGFibGUpOwogICAgIHJldHVybiBpbnN0YW5jZTsKIH0KQEAgLTUwLDEy ICs1MCwxMSBAQCBTdHJ1Y3R1cmUqIEpTV2ViQXNzZW1ibHlNb2R1bGU6OmNyZWF0ZVN0cnVjdHVy ZShWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYgogICAgIHJldHVybiBTdHJ1Y3R1cmU6 OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LCBwcm90b3R5cGUsIFR5cGVJbmZvKE9iamVjdFR5cGUs IFN0cnVjdHVyZUZsYWdzKSwgaW5mbygpKTsKIH0KIAotSlNXZWJBc3NlbWJseU1vZHVsZTo6SlNX ZWJBc3NlbWJseU1vZHVsZShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBzdGQ6OnVuaXF1 ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYgbW9kdWxlSW5mb3JtYXRpb24sIEJhZzxD YWxsTGlua0luZm8+JiYgY2FsbExpbmtJbmZvcywgVmVjdG9yPFdhc206Oldhc21Ub0pTU3R1Yj4m JiB3YXNtVG9KU1N0dWJzLCBXYXNtOjpJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmJiBmdW5j dGlvbkluZGV4U3BhY2UsIHVuc2lnbmVkIGNhbGxlZUNvdW50KQorSlNXZWJBc3NlbWJseU1vZHVs ZTo6SlNXZWJBc3NlbWJseU1vZHVsZShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBzdGQ6 OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYgbW9kdWxlSW5mb3JtYXRpb24s IEJhZzxDYWxsTGlua0luZm8+JiYgY2FsbExpbmtJbmZvcywgVmVjdG9yPFdhc206Oldhc21FeGl0 U3R1YnM+JiYgd2FzbUV4aXRTdHVicywgdW5zaWduZWQgY2FsbGVlQ291bnQpCiAgICAgOiBCYXNl KHZtLCBzdHJ1Y3R1cmUpCiAgICAgLCBtX21vZHVsZUluZm9ybWF0aW9uKFdURk1vdmUobW9kdWxl SW5mb3JtYXRpb24pKQogICAgICwgbV9jYWxsTGlua0luZm9zKFdURk1vdmUoY2FsbExpbmtJbmZv cykpCi0gICAgLCBtX3dhc21Ub0pTU3R1YnMoV1RGTW92ZSh3YXNtVG9KU1N0dWJzKSkKLSAgICAs IG1fZnVuY3Rpb25JbmRleFNwYWNlKFdURk1vdmUoZnVuY3Rpb25JbmRleFNwYWNlKSkKKyAgICAs IG1fd2FzbUV4aXRTdHVicyhXVEZNb3ZlKHdhc21FeGl0U3R1YnMpKQogICAgICwgbV9jYWxsZWVD b3VudChjYWxsZWVDb3VudCkKIHsKICAgICBtZW1zZXQoY2FsbGVlcygpLCAwLCBtX2NhbGxlZUNv dW50ICogc2l6ZW9mKFdyaXRlQmFycmllcjxKU1dlYkFzc2VtYmx5Q2FsbGVlPikgKiAyKTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1 bGUuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUu aAppbmRleCAyZTExMzYxLi5iZjUyZTJiIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5oCkBAIC00MywxOSArNDMsMTggQEAgY2xh c3MgSlNXZWJBc3NlbWJseU1vZHVsZSA6IHB1YmxpYyBKU0Rlc3RydWN0aWJsZU9iamVjdCB7CiBw dWJsaWM6CiAgICAgdHlwZWRlZiBKU0Rlc3RydWN0aWJsZU9iamVjdCBCYXNlOwogCi0gICAgc3Rh dGljIEpTV2ViQXNzZW1ibHlNb2R1bGUqIGNyZWF0ZShWTSYsIFN0cnVjdHVyZSosIHN0ZDo6dW5p cXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4mJiwgQmFnPENhbGxMaW5rSW5mbz4mJiwg VmVjdG9yPFdhc206Oldhc21Ub0pTU3R1Yj4mJiwgV2FzbTo6SW1tdXRhYmxlRnVuY3Rpb25JbmRl eFNwYWNlJiYsIFN5bWJvbFRhYmxlKiwgdW5zaWduZWQpOworICAgIHN0YXRpYyBKU1dlYkFzc2Vt Ymx5TW9kdWxlKiBjcmVhdGUoVk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6 TW9kdWxlSW5mb3JtYXRpb24+JiYsIEJhZzxDYWxsTGlua0luZm8+JiYsIFZlY3RvcjxXYXNtOjpX YXNtRXhpdFN0dWJzPiYmLCBTeW1ib2xUYWJsZSosIHVuc2lnbmVkKTsKICAgICBzdGF0aWMgU3Ry dWN0dXJlKiBjcmVhdGVTdHJ1Y3R1cmUoVk0mLCBKU0dsb2JhbE9iamVjdCosIEpTVmFsdWUpOwog CiAgICAgREVDTEFSRV9JTkZPOwogCiAgICAgY29uc3QgV2FzbTo6TW9kdWxlSW5mb3JtYXRpb24m IG1vZHVsZUluZm9ybWF0aW9uKCkgY29uc3QgeyByZXR1cm4gKm1fbW9kdWxlSW5mb3JtYXRpb24u Z2V0KCk7IH0KICAgICBTeW1ib2xUYWJsZSogZXhwb3J0U3ltYm9sVGFibGUoKSBjb25zdCB7IHJl dHVybiBtX2V4cG9ydFN5bWJvbFRhYmxlLmdldCgpOyB9Ci0gICAgV2FzbTo6U2lnbmF0dXJlSW5k ZXggc2lnbmF0dXJlRm9yRnVuY3Rpb25JbmRleFNwYWNlKHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhT cGFjZSkgY29uc3QKKyAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleEZyb21G dW5jdGlvbkluZGV4U3BhY2UodW5zaWduZWQgZnVuY3Rpb25JbmRleFNwYWNlKSBjb25zdAogICAg IHsKLSAgICAgICAgQVNTRVJUKGZ1bmN0aW9uSW5kZXhTcGFjZSA8IG1fZnVuY3Rpb25JbmRleFNw YWNlLnNpemUpOwotICAgICAgICByZXR1cm4gbV9mdW5jdGlvbkluZGV4U3BhY2UuYnVmZmVyLmdl dCgpW2Z1bmN0aW9uSW5kZXhTcGFjZV0uc2lnbmF0dXJlSW5kZXg7CisgICAgICAgIHJldHVybiBt X21vZHVsZUluZm9ybWF0aW9uLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2Uo ZnVuY3Rpb25JbmRleFNwYWNlKTsKICAgICB9Ci0gICAgdW5zaWduZWQgaW1wb3J0Q291bnQoKSBj b25zdCB7IHJldHVybiBtX3dhc21Ub0pTU3R1YnMuc2l6ZSgpOyB9CisgICAgdW5zaWduZWQgaW1w b3J0Q291bnQoKSBjb25zdCB7IHJldHVybiBtX3dhc21FeGl0U3R1YnMuc2l6ZSgpOyB9CiAKICAg ICBKU1dlYkFzc2VtYmx5Q2FsbGVlKiBqc0VudHJ5cG9pbnRDYWxsZWVGcm9tRnVuY3Rpb25JbmRl eFNwYWNlKHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFjZSkKICAgICB7CkBAIC05MCwxMCArODks OCBAQCBwdWJsaWM6CiAgICAgICAgIHJldHVybiBiaXR3aXNlX2Nhc3Q8V3JpdGVCYXJyaWVyPEpT V2ViQXNzZW1ibHlDYWxsZWU+Kj4oYml0d2lzZV9jYXN0PGNoYXIqPih0aGlzKSArIG9mZnNldE9m Q2FsbGVlcygpKTsKICAgICB9CiAKLSAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mRnVuY3Rp b25JbmRleFNwYWNlKCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKEpTV2ViQXNzZW1ibHlNb2R1 bGUsIG1fZnVuY3Rpb25JbmRleFNwYWNlKTsgfQotCiBwcm90ZWN0ZWQ6Ci0gICAgSlNXZWJBc3Nl bWJseU1vZHVsZShWTSYsIFN0cnVjdHVyZSosIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJ bmZvcm1hdGlvbj4mJiwgQmFnPENhbGxMaW5rSW5mbz4mJiwgVmVjdG9yPFdhc206Oldhc21Ub0pT U3R1Yj4mJiwgV2FzbTo6SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiYsIHVuc2lnbmVkIGNh bGxlZUNvdW50KTsKKyAgICBKU1dlYkFzc2VtYmx5TW9kdWxlKFZNJiwgU3RydWN0dXJlKiwgc3Rk Ojp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPiYmLCBCYWc8Q2FsbExpbmtJbmZv PiYmLCBWZWN0b3I8V2FzbTo6V2FzbUV4aXRTdHVicz4mJiwgdW5zaWduZWQgY2FsbGVlQ291bnQp OwogICAgIHZvaWQgZmluaXNoQ3JlYXRpb24oVk0mLCBTeW1ib2xUYWJsZSopOwogICAgIHN0YXRp YyB2b2lkIGRlc3Ryb3koSlNDZWxsKik7CiAgICAgc3RhdGljIHZvaWQgdmlzaXRDaGlsZHJlbihK U0NlbGwqLCBTbG90VmlzaXRvciYpOwpAQCAtMTE3LDggKzExNCw3IEBAIHByaXZhdGU6CiAgICAg c3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPiBtX21vZHVsZUluZm9ybWF0 aW9uOwogICAgIEJhZzxDYWxsTGlua0luZm8+IG1fY2FsbExpbmtJbmZvczsKICAgICBXcml0ZUJh cnJpZXI8U3ltYm9sVGFibGU+IG1fZXhwb3J0U3ltYm9sVGFibGU7Ci0gICAgVmVjdG9yPFdhc206 Oldhc21Ub0pTU3R1Yj4gbV93YXNtVG9KU1N0dWJzOwotICAgIGNvbnN0IFdhc206OkltbXV0YWJs ZUZ1bmN0aW9uSW5kZXhTcGFjZSBtX2Z1bmN0aW9uSW5kZXhTcGFjZTsKKyAgICBWZWN0b3I8V2Fz bTo6V2FzbUV4aXRTdHVicz4gbV93YXNtRXhpdFN0dWJzOwogICAgIHVuc2lnbmVkIG1fY2FsbGVl Q291bnQ7CiB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9X ZWJBc3NlbWJseUZ1bmN0aW9uLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dl YkFzc2VtYmx5RnVuY3Rpb24uY3BwCmluZGV4IDRmMGQ3YTguLmQ1OWEwNTkgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uY3BwCisr KyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uY3Bw CkBAIC0xMDUsMTYgKzEwNSw3IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxM IGNhbGxXZWJBc3NlbWJseUZ1bmN0aW9uKEV4ZWNTdGF0ZSogZXhlYykKIAogRW5jb2RlZEpTVmFs dWUgV2ViQXNzZW1ibHlGdW5jdGlvbjo6Y2FsbChWTSYgdm0sIFByb3RvQ2FsbEZyYW1lKiBwcm90 b0NhbGxGcmFtZSkKIHsKLSAgICAvLyBTZXR1cCB0aGUgbWVtb3J5IHRoYXQgdGhlIGVudHJhbmNl IGxvYWRzLgotICAgIGlmIChKU1dlYkFzc2VtYmx5TWVtb3J5KiBtZW1vcnkgPSBpbnN0YW5jZSgp LT5tZW1vcnkoKSkgewotICAgICAgICBXYXNtOjpNZW1vcnkqIHdhc21NZW1vcnkgPSBtZW1vcnkt Pm1lbW9yeSgpOwotICAgICAgICB2bS50b3BXYXNtTWVtb3J5UG9pbnRlciA9IHdhc21NZW1vcnkt Pm1lbW9yeSgpOwotICAgICAgICB2bS50b3BXYXNtTWVtb3J5U2l6ZSA9IHdhc21NZW1vcnktPnNp emUoKTsKLSAgICB9IGVsc2UgewotICAgICAgICB2bS50b3BXYXNtTWVtb3J5UG9pbnRlciA9IG51 bGxwdHI7Ci0gICAgICAgIHZtLnRvcFdhc21NZW1vcnlTaXplID0gMDsKLSAgICB9Ci0KKyAgICAv LyBGSVhNRSBEbyBhd2F5IHdpdGggdGhpcyBlbnRpcmUgZnVuY3Rpb24sIGFuZCBvbmx5IHVzZSB0 aGUgZW50cnlwb2ludCBnZW5lcmF0ZWQgYnkgQjMuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xNjY0ODYKICAgICBKU1dlYkFzc2VtYmx5SW5zdGFuY2UqIHByZXZKU1dl YkFzc2VtYmx5SW5zdGFuY2UgPSB2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2U7CiAgICAgdm0u dG9wSlNXZWJBc3NlbWJseUluc3RhbmNlID0gaW5zdGFuY2UoKTsKICAgICBBU1NFUlQoaW5zdGFu Y2UoKSk7CkBAIC0xNTMsNyArMTQ0LDcgQEAgV2ViQXNzZW1ibHlGdW5jdGlvbiogV2ViQXNzZW1i bHlGdW5jdGlvbjo6Y3JlYXRlKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE8KIFN0cnVj dHVyZSogV2ViQXNzZW1ibHlGdW5jdGlvbjo6Y3JlYXRlU3RydWN0dXJlKFZNJiB2bSwgSlNHbG9i YWxPYmplY3QqIGdsb2JhbE9iamVjdCwgSlNWYWx1ZSBwcm90b3R5cGUpCiB7CiAgICAgQVNTRVJU KGdsb2JhbE9iamVjdCk7Ci0gICAgcmV0dXJuIFN0cnVjdHVyZTo6Y3JlYXRlKHZtLCBnbG9iYWxP YmplY3QsIHByb3RvdHlwZSwgVHlwZUluZm8oSlNGdW5jdGlvblR5cGUsIFN0cnVjdHVyZUZsYWdz KSwgaW5mbygpKTsKKyAgICByZXR1cm4gU3RydWN0dXJlOjpjcmVhdGUodm0sIGdsb2JhbE9iamVj dCwgcHJvdG90eXBlLCBUeXBlSW5mbyhXZWJBc3NlbWJseUZ1bmN0aW9uVHlwZSwgU3RydWN0dXJl RmxhZ3MpLCBpbmZvKCkpOwogfQogCiBXZWJBc3NlbWJseUZ1bmN0aW9uOjpXZWJBc3NlbWJseUZ1 bmN0aW9uKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCwgU3RydWN0dXJlKiBz dHJ1Y3R1cmUsIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4KQpkaWZmIC0tZ2l0 IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0 cnVjdG9yLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5SW5z dGFuY2VDb25zdHJ1Y3Rvci5jcHAKaW5kZXggNThlYTI1ODQuLmQyNGFiODEgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VDb25zdHJ1 Y3Rvci5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlJ bnN0YW5jZUNvbnN0cnVjdG9yLmNwcApAQCAtMTE0LDE4ICsxMTQsMTkgQEAgc3RhdGljIEVuY29k ZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwgY29uc3RydWN0SlNXZWJBc3NlbWJseUluc3RhbmNlKEV4 ZWNTdGF0ZSogZXgKICAgICAgICAgICAgICAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKHRocm93 RXhjZXB0aW9uKGV4ZWMsIHRocm93U2NvcGUsIGNyZWF0ZUpTV2ViQXNzZW1ibHlMaW5rRXJyb3Io ZXhlYywgdm0sIEFTQ0lJTGl0ZXJhbCgiaW1wb3J0IGZ1bmN0aW9uIG11c3QgYmUgY2FsbGFibGUi KSkpKTsKICAgICAgICAgICAgIEpTQ2VsbCogY2VsbCA9IHZhbHVlLmFzQ2VsbCgpOwogICAgICAg ICAgICAgLy8gaWkuIElmIHYgaXMgYW4gRXhwb3J0ZWQgRnVuY3Rpb24gRXhvdGljIE9iamVjdDoK LSAgICAgICAgICAgIGlmIChXZWJBc3NlbWJseUZ1bmN0aW9uKiBpbXBvcnRlZEV4cG9ydHMgPSBq c0R5bmFtaWNDYXN0PFdlYkFzc2VtYmx5RnVuY3Rpb24qPihvYmplY3QpKSB7Ci0gICAgICAgICAg ICAgICAgLy8gRklYTUUgaGFuZGxlIEZ1bmN0aW9uIEV4b3RpYyBPYmplY3QgcHJvcGVybHkuIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjUyODIKLSAgICAgICAgICAg ICAgICAvLyBhLiBJZiB0aGUgc2lnbmF0dXJlIG9mIHYgZG9lcyBub3QgbWF0Y2ggdGhlIHNpZ25h dHVyZSBvZiBpLCB0aHJvdyBhIFR5cGVFcnJvci4KKyAgICAgICAgICAgIGlmIChXZWJBc3NlbWJs eUZ1bmN0aW9uKiBpbXBvcnRlZEV4cG9ydCA9IGpzRHluYW1pY0Nhc3Q8V2ViQXNzZW1ibHlGdW5j dGlvbio+KGNlbGwpKSB7CisgICAgICAgICAgICAgICAgLy8gYS4gSWYgdGhlIHNpZ25hdHVyZSBv ZiB2IGRvZXMgbm90IG1hdGNoIHRoZSBzaWduYXR1cmUgb2YgaSwgdGhyb3cgYSBXZWJBc3NlbWJs eS5MaW5rRXJyb3IuCisgICAgICAgICAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggaW1wb3J0 ZWRTaWduYXR1cmVJbmRleCA9IGltcG9ydGVkRXhwb3J0LT5zaWduYXR1cmVJbmRleCgpOworICAg ICAgICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IGV4cGVjdGVkU2lnbmF0dXJlSW5kZXgg PSBtb2R1bGVJbmZvcm1hdGlvbi5pbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXNbaW1wb3J0 LmtpbmRJbmRleF07CisgICAgICAgICAgICAgICAgaWYgKGltcG9ydGVkU2lnbmF0dXJlSW5kZXgg IT0gZXhwZWN0ZWRTaWduYXR1cmVJbmRleCkKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIEpT VmFsdWU6OmVuY29kZSh0aHJvd0V4Y2VwdGlvbihleGVjLCB0aHJvd1Njb3BlLCBjcmVhdGVKU1dl YkFzc2VtYmx5TGlua0Vycm9yKGV4ZWMsIHZtLCBBU0NJSUxpdGVyYWwoImltcG9ydGVkIGZ1bmN0 aW9uJ3Mgc2lnbmF0dXJlIG1pc21hdGNoZXMgdGhlIHByb3ZpZGVkIFdlYkFzc2VtYmx5IGZ1bmN0 aW9uJ3Mgc2lnbmF0dXJlIikpKSk7CiAgICAgICAgICAgICAgICAgLy8gYi4gTGV0IGNsb3N1cmUg YmUgdi5bW0Nsb3N1cmVdXS4KLSAgICAgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVB Q0hFRCgpOwotICAgICAgICAgICAgICAgIFVOVVNFRF9QQVJBTShpbXBvcnRlZEV4cG9ydHMpOwot ICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICAgfQogICAgICAgICAgICAgLy8gaWlp LiBPdGhlcndpc2U6CiAgICAgICAgICAgICAvLyBhLiBMZXQgY2xvc3VyZSBiZSBhIG5ldyBob3N0 IGZ1bmN0aW9uIG9mIHRoZSBnaXZlbiBzaWduYXR1cmUgd2hpY2ggY2FsbHMgdiBieSBjb2VyY2lu ZyBXZWJBc3NlbWJseSBhcmd1bWVudHMgdG8gSmF2YVNjcmlwdCBhcmd1bWVudHMgdmlhIFRvSlNW YWx1ZSBhbmQgcmV0dXJucyB0aGUgcmVzdWx0LCBpZiBhbnksIGJ5IGNvZXJjaW5nIHZpYSBUb1dl YkFzc2VtYmx5VmFsdWUuCiAgICAgICAgICAgICAvLyBOb3RlOiBkb25lIGFzIHBhcnQgb2YgUGxh biBjb21waWxhdGlvbi4KICAgICAgICAgICAgIC8vIGl2LiBBcHBlbmQgdiB0byBmdW5jcy4KKyAg ICAgICAgICAgIC8vIE5vdGU6IGFkZGluZyB0aGUgSlNDZWxsIHRvIHRoZSBpbnN0YW5jZSBsaXN0 IGZ1bGZpbGxzIGNsb3N1cmUgcmVxdWlyZW1lbnRzIGIuIGFib3ZlICh0aGUgV2ViQXNzZW1ibHku SW5zdGFuY2Ugd2lsIGJlIGtlcHQgYWxpdmUpIGFuZCB2LiBiZWxvdyAodGhlIEpTRnVuY3Rpb24p LgogICAgICAgICAgICAgaW5zdGFuY2UtPnNldEltcG9ydEZ1bmN0aW9uKHZtLCBjZWxsLCBudW1J bXBvcnRGdW5jdGlvbnMrKyk7CiAgICAgICAgICAgICAvLyB2LiBBcHBlbmQgY2xvc3VyZSB0byBp bXBvcnRzLgogICAgICAgICAgICAgYnJlYWs7CkBAIC0yMjksOCArMjMwLDggQEAgc3RhdGljIEVu Y29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwgY29uc3RydWN0SlNXZWJBc3NlbWJseUluc3RhbmNl KEV4ZWNTdGF0ZSogZXgKICAgICAgICAgaWYgKG1vZHVsZUluZm9ybWF0aW9uLm1lbW9yeSAmJiAh aGFzTWVtb3J5SW1wb3J0KSB7CiAgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVCghbW9kdWxlSW5m b3JtYXRpb24ubWVtb3J5LmlzSW1wb3J0KCkpOwogICAgICAgICAgICAgLy8gV2UgY3JlYXRlIGEg bWVtb3J5IHdoZW4gaXQncyBhIG1lbW9yeSBkZWZpbml0aW9uLgotICAgICAgICAgICAgc3RkOjp1 bmlxdWVfcHRyPFdhc206Ok1lbW9yeT4gbWVtb3J5ID0gc3RkOjptYWtlX3VuaXF1ZTxXYXNtOjpN ZW1vcnk+KG1vZHVsZUluZm9ybWF0aW9uLm1lbW9yeS5pbml0aWFsKCksIG1vZHVsZUluZm9ybWF0 aW9uLm1lbW9yeS5tYXhpbXVtKCkpOwotICAgICAgICAgICAgaWYgKCFtZW1vcnktPmlzVmFsaWQo KSkKKyAgICAgICAgICAgIFdhc206Ok1lbW9yeSBtZW1vcnkobW9kdWxlSW5mb3JtYXRpb24ubWVt b3J5LmluaXRpYWwoKSwgbW9kdWxlSW5mb3JtYXRpb24ubWVtb3J5Lm1heGltdW0oKSk7CisgICAg ICAgICAgICBpZiAoIW1lbW9yeS5pc1ZhbGlkKCkpCiAgICAgICAgICAgICAgICAgcmV0dXJuIEpT VmFsdWU6OmVuY29kZSh0aHJvd0V4Y2VwdGlvbihleGVjLCB0aHJvd1Njb3BlLCBjcmVhdGVPdXRP Zk1lbW9yeUVycm9yKGV4ZWMpKSk7CiAgICAgICAgICAgICBpbnN0YW5jZS0+c2V0TWVtb3J5KHZt LAogICAgICAgICAgICAgICAgSlNXZWJBc3NlbWJseU1lbW9yeTo6Y3JlYXRlKHZtLCBleGVjLT5s ZXhpY2FsR2xvYmFsT2JqZWN0KCktPldlYkFzc2VtYmx5TWVtb3J5U3RydWN0dXJlKCksIFdURk1v dmUobWVtb3J5KSkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMv V2ViQXNzZW1ibHlNZW1vcnlDb25zdHJ1Y3Rvci5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9qcy9XZWJBc3NlbWJseU1lbW9yeUNvbnN0cnVjdG9yLmNwcAppbmRleCAzZjg4ZWQ0Li5k Y2NlYzE2IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3Nl bWJseU1lbW9yeUNvbnN0cnVjdG9yLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9qcy9XZWJBc3NlbWJseU1lbW9yeUNvbnN0cnVjdG9yLmNwcApAQCAtOTYsOCArOTYsOCBAQCBz dGF0aWMgRW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBjb25zdHJ1Y3RKU1dlYkFzc2VtYmx5 TWVtb3J5KEV4ZWNTdGF0ZSogZXhlYwogICAgICAgICB9CiAgICAgfQogCi0gICAgc3RkOjp1bmlx dWVfcHRyPFdhc206Ok1lbW9yeT4gbWVtb3J5ID0gc3RkOjptYWtlX3VuaXF1ZTxXYXNtOjpNZW1v cnk+KGluaXRpYWxQYWdlQ291bnQsIG1heGltdW1QYWdlQ291bnQpOwotICAgIGlmICghbWVtb3J5 LT5pc1ZhbGlkKCkpCisgICAgV2FzbTo6TWVtb3J5IG1lbW9yeShpbml0aWFsUGFnZUNvdW50LCBt YXhpbXVtUGFnZUNvdW50KTsKKyAgICBpZiAoIW1lbW9yeS5pc1ZhbGlkKCkpCiAgICAgICAgIHJl dHVybiBKU1ZhbHVlOjplbmNvZGUodGhyb3dFeGNlcHRpb24oZXhlYywgdGhyb3dTY29wZSwgY3Jl YXRlT3V0T2ZNZW1vcnlFcnJvcihleGVjKSkpOwogCiAgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29k ZShKU1dlYkFzc2VtYmx5TWVtb3J5OjpjcmVhdGUodm0sIGV4ZWMtPmxleGljYWxHbG9iYWxPYmpl Y3QoKS0+V2ViQXNzZW1ibHlNZW1vcnlTdHJ1Y3R1cmUoKSwgV1RGTW92ZShtZW1vcnkpKSk7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVs ZUNvbnN0cnVjdG9yLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2Vt Ymx5TW9kdWxlQ29uc3RydWN0b3IuY3BwCmluZGV4IDM4ZWRiOGMuLjgxMjk1OTIgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlQ29uc3Ry dWN0b3IuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5 TW9kdWxlQ29uc3RydWN0b3IuY3BwCkBAIC05Nyw3ICs5Nyw3IEBAIEpTVmFsdWUgV2ViQXNzZW1i bHlNb2R1bGVDb25zdHJ1Y3Rvcjo6Y3JlYXRlTW9kdWxlKEV4ZWNTdGF0ZSogc3RhdGUsIFN0cnVj dHVyZSoKIAogICAgIC8vIE9ubHkgd2FzbS1pbnRlcm5hbCBmdW5jdGlvbnMgaGF2ZSBhIGNhbGxl ZSwgc3R1YnMgdG8gSlMgZG8gbm90LgogICAgIHVuc2lnbmVkIGNhbGxlZUNvdW50ID0gcGxhbi5p bnRlcm5hbEZ1bmN0aW9uQ291bnQoKTsKLSAgICBKU1dlYkFzc2VtYmx5TW9kdWxlKiByZXN1bHQg PSBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGUodm0sIHN0cnVjdHVyZSwgcGxhbi50YWtlTW9k dWxlSW5mb3JtYXRpb24oKSwgcGxhbi50YWtlQ2FsbExpbmtJbmZvcygpLCBwbGFuLnRha2VXYXNt VG9KU1N0dWJzKCksIHBsYW4udGFrZUZ1bmN0aW9uSW5kZXhTcGFjZSgpLCBleHBvcnRTeW1ib2xU YWJsZSwgY2FsbGVlQ291bnQpOworICAgIEpTV2ViQXNzZW1ibHlNb2R1bGUqIHJlc3VsdCA9IEpT V2ViQXNzZW1ibHlNb2R1bGU6OmNyZWF0ZSh2bSwgc3RydWN0dXJlLCBwbGFuLnRha2VNb2R1bGVJ bmZvcm1hdGlvbigpLCBwbGFuLnRha2VDYWxsTGlua0luZm9zKCksIHBsYW4udGFrZVdhc21FeGl0 U3R1YnMoKSwgZXhwb3J0U3ltYm9sVGFibGUsIGNhbGxlZUNvdW50KTsKICAgICBwbGFuLmluaXRp YWxpemVDYWxsZWVzKHN0YXRlLT5qc0NhbGxlZSgpLT5nbG9iYWxPYmplY3QoKSwgCiAgICAgICAg IFsmXSAodW5zaWduZWQgY2FsbGVlSW5kZXgsIEpTV2ViQXNzZW1ibHlDYWxsZWUqIGpzRW50cnlw b2ludENhbGxlZSwgSlNXZWJBc3NlbWJseUNhbGxlZSogd2FzbUVudHJ5cG9pbnRDYWxsZWUpIHsK ICAgICAgICAgICAgIHJlc3VsdC0+c2V0SlNFbnRyeXBvaW50Q2FsbGVlKHZtLCBjYWxsZWVJbmRl eCwganNFbnRyeXBvaW50Q2FsbGVlKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmNwcAppbmRleCBiNGNiMDU1Li4w Nzg2OTc4IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3Nl bWJseU1vZHVsZVJlY29yZC5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMv V2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQuY3BwCkBAIC0xMTgsNyArMTE4LDcgQEAgdm9pZCBXZWJB c3NlbWJseU1vZHVsZVJlY29yZDo6bGluayhFeGVjU3RhdGUqIHN0YXRlLCBKU1dlYkFzc2VtYmx5 SW5zdGFuY2UqIGluc3QKICAgICAgICAgICAgIC8vICAgICBjLiBSZXR1cm4gZnVuYy4KICAgICAg ICAgICAgIEpTV2ViQXNzZW1ibHlDYWxsZWUqIGpzRW50cnlwb2ludENhbGxlZSA9IG1vZHVsZS0+ anNFbnRyeXBvaW50Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShleHAua2luZEluZGV4KTsK ICAgICAgICAgICAgIEpTV2ViQXNzZW1ibHlDYWxsZWUqIHdhc21FbnRyeXBvaW50Q2FsbGVlID0g bW9kdWxlLT53YXNtRW50cnlwb2ludENhbGxlZUZyb21GdW5jdGlvbkluZGV4U3BhY2UoZXhwLmtp bmRJbmRleCk7Ci0gICAgICAgICAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRl eCA9IG1vZHVsZS0+c2lnbmF0dXJlRm9yRnVuY3Rpb25JbmRleFNwYWNlKGV4cC5raW5kSW5kZXgp OworICAgICAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1 bGUtPnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShleHAua2luZEluZGV4KTsK ICAgICAgICAgICAgIGNvbnN0IFdhc206OlNpZ25hdHVyZSogc2lnbmF0dXJlID0gV2FzbTo6U2ln bmF0dXJlSW5mb3JtYXRpb246OmdldCgmdm0sIHNpZ25hdHVyZUluZGV4KTsKICAgICAgICAgICAg IFdlYkFzc2VtYmx5RnVuY3Rpb24qIGZ1bmN0aW9uID0gV2ViQXNzZW1ibHlGdW5jdGlvbjo6Y3Jl YXRlKHZtLCBnbG9iYWxPYmplY3QsIHNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpLCBleHAuZmll bGQuc3RyaW5nKCksIGluc3RhbmNlLCBqc0VudHJ5cG9pbnRDYWxsZWUsIHdhc21FbnRyeXBvaW50 Q2FsbGVlLCBzaWduYXR1cmVJbmRleCk7CiAgICAgICAgICAgICBleHBvcnRlZFZhbHVlID0gZnVu Y3Rpb247CkBAIC0xNzUsNyArMTc1LDcgQEAgdm9pZCBXZWJBc3NlbWJseU1vZHVsZVJlY29yZDo6 bGluayhFeGVjU3RhdGUqIHN0YXRlLCBKU1dlYkFzc2VtYmx5SW5zdGFuY2UqIGluc3QKICAgICBi b29sIGhhc1N0YXJ0ID0gISFtb2R1bGVJbmZvcm1hdGlvbi5zdGFydEZ1bmN0aW9uSW5kZXhTcGFj ZTsKICAgICBpZiAoaGFzU3RhcnQpIHsKICAgICAgICAgYXV0byBzdGFydEZ1bmN0aW9uSW5kZXhT cGFjZSA9IG1vZHVsZUluZm9ybWF0aW9uLnN0YXJ0RnVuY3Rpb25JbmRleFNwYWNlLnZhbHVlX29y KDApOwotICAgICAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1vZHVs ZS0+c2lnbmF0dXJlRm9yRnVuY3Rpb25JbmRleFNwYWNlKHN0YXJ0RnVuY3Rpb25JbmRleFNwYWNl KTsKKyAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUt PnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShzdGFydEZ1bmN0aW9uSW5kZXhT cGFjZSk7CiAgICAgICAgIGNvbnN0IFdhc206OlNpZ25hdHVyZSogc2lnbmF0dXJlID0gV2FzbTo6 U2lnbmF0dXJlSW5mb3JtYXRpb246OmdldCgmdm0sIHNpZ25hdHVyZUluZGV4KTsKICAgICAgICAg Ly8gVGhlIHN0YXJ0IGZ1bmN0aW9uIG11c3Qgbm90IHRha2UgYW55IGFyZ3VtZW50cyBvciByZXR1 cm4gYW55dGhpbmcuIFRoaXMgaXMgZW5mb3JjZWQgYnkgdGhlIHBhcnNlci4KICAgICAgICAgQVNT RVJUKCFzaWduYXR1cmUtPmFyZ3VtZW50Q291bnQoKSk7CkBAIC0yMzgsNyArMjM4LDcgQEAgSlNW YWx1ZSBXZWJBc3NlbWJseU1vZHVsZVJlY29yZDo6ZXZhbHVhdGUoRXhlY1N0YXRlKiBzdGF0ZSkK IAogICAgICAgICAgICAgICAgIEpTV2ViQXNzZW1ibHlDYWxsZWUqIGpzRW50cnlwb2ludENhbGxl ZSA9IG1vZHVsZS0+anNFbnRyeXBvaW50Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5j dGlvbkluZGV4KTsKICAgICAgICAgICAgICAgICBKU1dlYkFzc2VtYmx5Q2FsbGVlKiB3YXNtRW50 cnlwb2ludENhbGxlZSA9IG1vZHVsZS0+d2FzbUVudHJ5cG9pbnRDYWxsZWVGcm9tRnVuY3Rpb25J bmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgpOwotICAgICAgICAgICAgICAgIFdhc206OlNpZ25hdHVy ZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVGb3JGdW5jdGlvbkluZGV4 U3BhY2UoZnVuY3Rpb25JbmRleCk7CisgICAgICAgICAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5k ZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5k ZXhTcGFjZShmdW5jdGlvbkluZGV4KTsKICAgICAgICAgICAgICAgICBjb25zdCBXYXNtOjpTaWdu YXR1cmUqIHNpZ25hdHVyZSA9IFdhc206OlNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQoJnZtLCBz aWduYXR1cmVJbmRleCk7CiAgICAgICAgICAgICAgICAgLy8gRklYTUU6IFNheSB3ZSBleHBvcnQg bG9jYWwgZnVuY3Rpb24gImZvbyIgYXQgZnVuY2l0b24gaW5kZXggMC4KICAgICAgICAgICAgICAg ICAvLyBXaGF0IGlmIHdlIGFsc28gc2V0IGl0IHRvIHRoZSB0YWJsZSBhbiBFbGVtZW50IHcvIGlu ZGV4IDAuCi0tIAoyLjEwLjEKCg== 297779 2016-12-26 21:57:54 -0800 2016-12-29 17:43:04 -0800 WIP 0001-wasm-wasm.patch text/plain 105677 jfbastien RnJvbSA0ODU5YzYwN2YwNzlmNTcwNDI5YWVlZGQ0Njk5NjZlMGQyNTI0OTE1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBXZWQsIDIxIERlYyAyMDE2IDE1OjU5OjU2IC0wODAwClN1YmplY3Q6IFtQQVRDSF0gd2FzbS0+ d2FzbQoKQ2hhbmdlcyB0byB0aGUgV2ViQXNzZW1ibHkgaW1wbGVtZW50YXRpb246CgogIC0gQWRk IGEgbmV3IEpTVHlwZSBmb3IgV2ViQXNzZW1ibHlGdW5jdGlvbiwgYW5kIHVzZSBpdCB3aGVuIGNy ZWF0aW5nIGl0cwogICAgc3RydWN0dXJlLiBUaGlzIHdpbGwgYmUgdXNlZCB0byBxdWlja2x5IGRl dGVjdCBmcm9tIHdhc20gd2hldGhlciB0aGUgaW1wb3J0CiAgICBjYWxsIGlzIHRvIGFub3RoZXIg d2FzbSBtb2R1bGUsIG9yIHdoZXRoZXIgaXQncyB0byBKUy4KICAtIFVzZSBjZWxsIGluc3RlYWQg b2Ygb2JqZWN0cyB0byBkZXRlY3Qgd2FzbS0+d2FzbSwgdGhlIHByZXZpb3VzIGNvZGUgd2FzIHdy b25nLgogIC0gSW1wcm92ZSBkaWFnbm9zdGljIHByaW50b3V0IGZvciB3YXNtIHN0dWJzOiBwcmlu dCB0aGUgZnVsbCBzaWduYXR1cmUuCiAgLSBQcm9wZXJseSBjaGVjayB0aGF0IHdhc20gLT4gd2Fz bSBjYWxscyBoYXZlIG1hdGNoaW5nIHNpZ25hdHVyZXMuIEFkZCB0ZXN0aW5nIGZvciB0aGlzLgog IC0gVGVzdCBzb21lIG9mIHRoZSB3YXNtIC0+IHdhc20gY2FsbHMsIG5vdCB3b3JraW5nIHlldCwg YW5kIG1vcmUgdGVzdHMgbmVlZCB0bwogICAgZ2V0IGltcGxlbWVudGVkLgogIC0gR2VuZXJhdGUg dHdvIHN0dWJzIGZyb20gdGhlIGltcG9ydCBzdHViIGdlbmVyYXRvcjogb25lIGZvciB3YXNtLT5K UyBhbmQgb25lCiAgICBmb3Igd2FzbSAtPiB3YXNtLiBUaGlzIGlzIGRvbmUgYXQgTW9kdWxlIHRp bWUuIFdoaWNoIGlzIGNhbGxlZCB3aWxsIG9ubHkgYmUKICAgIGtub3duIGF0IEluc3RhbmNlIHRp bWUsIG9uY2Ugd2UndmUgcmVjZWl2ZWQgdGhlIGltcG9ydCBvYmplY3QuIFdlIHdhbnQgdG8KICAg IGF2b2lkIGNvZGVnZW4gYXQgSW5zdGFuY2UgdGltZSwgc28gaGF2aW5nIGJvdGggYXJvdW5kIGlz IGdyZWF0LgogIC0gUmVzdG9yZSB0aGUgV2ViQXNzZW1ibHkgZ2xvYmFsIHN0YXRlIChWTSB0b3Ag SW5zdGFuY2UsIGFuZCBwaW5uZWQgcmVnaXN0ZXJzKQogICAgYWZ0ZXIgY2FsbCAvIGNhbGxfaW5k aXJlY3QsIGFuZCBpbiB0aGUgSlMtPndhc20gZW50cnkgc3R1Yi4KClN1cHBvcnQgY2hhbmdlczoK CiAgLSBBZGQgYSBQcm94eSB0byBCdWlsZGVyLmpzLCB3aGljaCBpbnRlcmNlcHRzIHVua25vd24g cHJvcGVydHkgbG9va3Vwcy4gVGhpcwogICAgY3JlYXRlcyB3YXkgYmV0dGVyIGVycm9yIG1lc3Nh Z2VzIG9uIHR5cG9zIHRoYW4gJ3VuZGVmaW5lZCBpcyBub3QgYQogICAgZnVuY3Rpb24nLCB3aGlj aCBoYXBwZW5zIHNlbWktZnJlcXVlbnRseSBhcyBJIHR5cG8gb3Bjb2RlIG5hbWVzIChhbmQgd2hp Y2gKICAgIG9uZSBpcyBhIHR5cG8gaXMgaGFyZCB0byBmaW5kIGJlY2F1c2Ugd2UgY2hhaW4gYnVp bGRlcnMpLgogIC0gQWRkIGxpbWl0ZWQgc3VwcG9ydCBmb3IgdmFye3V9aW50NjQgKG9ubHkgdGhl IDMyLWJpdCB2YWx1ZXMpLgogIC0gR2V0IHJpZCBvZiBtdWNoIG9mIHRoZSBmdW5jdGlvbiBpbmRl eCBzcGFjZTogd2UgYWxyZWFkeSBoYXZlIGFsbCBvZiBpdHMKICAgIGluZm9ybWF0aW9uIGVsc2V3 aGVyZSwgYW5kIGFzLWlzIGl0IHByb3ZpZGVzIG5vIGV4dHJhIGVmZmljaWVuY3kuCiAgLSBTdG9y ZSBXYXNtOjpNZW1vcnkgZGlyZWN0bHkgb24gSlNXZWJBc3NlbWJseU1lbW9yeSwgaW5zdGVhZCBv ZiB0aHJvdWdoIGEKICAgIHVuaXF1ZV9wdHIuIFRoaXMgcmVtb3ZlcyBhbiBpbmRpcmVjdGlvbiBh bmQgdXNlbGVzcyBhbGxvY2F0aW9uLgogIC0gUmVtb3ZlIFZNJ2EgV2ViQXNzZW1ibHkgbWVtb3J5 IC8gc2l6ZSwgYW5kIG9idGFpbiB0aGVtIGZyb20gSW5zdGFuY2UKICAgIGluc3RlYWQuIFRoaXMg cmVxdWlyZXMgYW4gZXh0cmEgaW5kaXJlY3Rpb24sIGJ1dCBpcyBjbGVhbmVyLgotLS0KIEpTVGVz dHMvd2FzbS9CdWlsZGVyLmpzICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDkxICsrKysr Ky0tLS0tLQogSlNUZXN0cy93YXNtL0xvd0xldmVsQmluYXJ5LmpzICAgICAgICAgICAgICAgICAg ICAgfCAgMTIgKysKIEpTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy9leGNlcHRpb25zLmpzICAg ICAgICAgIHwgICA2ICstCiBKU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpz ICAgICAgICAgICB8ICAgMiArLQogSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtc3Rv cmUuanMgICAgICAgICAgfCAgIDIgKy0KIEpTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNt LWJhZC1zaWduYXR1cmUuanMgIHwgMTA1ICsrKysrKysrKysrKysrCiBKU1Rlc3RzL3dhc20vanMt YXBpL3dhc20tdG8td2FzbS5qcyAgICAgICAgICAgICAgICB8ICA3MyArKysrKysrKysrCiBTb3Vy Y2UvSmF2YVNjcmlwdENvcmUvanNjLmNwcCAgICAgICAgICAgICAgICAgICAgICB8ICAzMSArKyst LQogU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmggICAgICAgICAgICAgfCAg IDIgKwogU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVk0uaCAgICAgICAgICAgICAgICAg fCAgIDIgLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuY3Bw ICAgfCAxNTMgKysrKysrKysrKysrKysrLS0tLS0tCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtQjNJUkdlbmVyYXRvci5oICAgICB8ICAgMiArLQogU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbUJpbmRpbmcuY3BwICAgICAgICAgfCAgNDUgKysrKystCiBTb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5oICAgICAgICAgICB8ICAgMiArLQogU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vV2FzbUZvcm1hdC5oICAgICAgICAgICAgfCAgMjYgKystLQogU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmggICAgfCAgMTQgKy0K IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwICAgICAgICAgIHwgICA0 ICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmggICAgICAgICAgICB8 ICAxOCArKy0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3Bw ICAgIHwgIDI0ICsrLS0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJz ZXIuaCAgICAgIHwgICAxIC0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmNw cCAgICAgICAgICAgIHwgIDM3ICsrLS0tCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt UGxhbi5oICAgICAgICAgICAgICB8ICAxMyArLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbVNpZ25hdHVyZS5jcHAgICAgICAgfCAgMTMgKysKIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21TaWduYXR1cmUuaCAgICAgICAgIHwgICAxICsKIFNvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL1dhc21WYWxpZGF0ZS5jcHAgICAgICAgIHwgICA0ICstCiBTb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuaCAgICAgICAgICB8ICAgMiArLQogLi4uL0phdmFTY3Jp cHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseUluc3RhbmNlLmggfCAgIDggKy0KIC4uLi9KYXZh U2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuY3BwIHwgICA4ICstCiAuLi4v SmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmggICB8ICAxMSArLQog Li4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5jcHAgfCAgIDkg Ky0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUuaCAgIHwg IDE2ICstLQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlvbi5j cHAgfCAgMTMgKy0KIC4uLi93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VDb25zdHJ1Y3Rvci5j cHAgICAgIHwgIDE3ICstLQogLi4uL3dhc20vanMvV2ViQXNzZW1ibHlNZW1vcnlDb25zdHJ1Y3Rv ci5jcHAgICAgICAgfCAgIDQgKy0KIC4uLi93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlQ29uc3Ry dWN0b3IuY3BwICAgICAgIHwgICAyICstCiAuLi4vd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZVJl Y29yZC5jcHAgICAgICAgICAgICB8ICAgNiArLQogMzYgZmlsZXMgY2hhbmdlZCwgNTYwIGluc2Vy dGlvbnMoKyksIDIxOSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBKU1Rlc3RzL3dh c20vanMtYXBpL3dhc20tdG8td2FzbS1iYWQtc2lnbmF0dXJlLmpzCiBjcmVhdGUgbW9kZSAxMDA2 NDQgSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMKCmRpZmYgLS1naXQgYS9KU1Rl c3RzL3dhc20vQnVpbGRlci5qcyBiL0pTVGVzdHMvd2FzbS9CdWlsZGVyLmpzCmluZGV4IGRhNTg0 YzQuLjI2YmE2NmUgMTAwNjQ0Ci0tLSBhL0pTVGVzdHMvd2FzbS9CdWlsZGVyLmpzCisrKyBiL0pT VGVzdHMvd2FzbS9CdWlsZGVyLmpzCkBAIC0zOCw3ICszOCw3IEBAIGNvbnN0IF9pc1ZhbGlkVmFs dWUgPSAodmFsdWUsIHR5cGUpID0+IHsKICAgICBzd2l0Y2ggKHR5cGUpIHsKICAgICAvLyBXZSBh bGxvdyBib3RoIHNpZ25lZCBhbmQgdW5zaWduZWQgbnVtYmVycy4KICAgICBjYXNlICJpMzIiOiBy ZXR1cm4gTWF0aC5yb3VuZCh2YWx1ZSkgPT09IHZhbHVlICYmIExMQi52YXJpbnQzMk1pbiA8PSB2 YWx1ZSAmJiB2YWx1ZSA8PSBMTEIudmFydWludDMyTWF4OwotICAgIGNhc2UgImk2NCI6IHRocm93 IG5ldyBFcnJvcihgVW5pbXBsZW1lbnRlZDogdmFsdWUgY2hlY2sgZm9yICR7dHlwZX1gKTsgLy8g RklYTUUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MzQyMCA2NC1i aXQgdmFsdWVzCisgICAgY2FzZSAiaTY0IjogcmV0dXJuIHRydWU7IC8vIEZJWE1FIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjM0MjAgNjQtYml0IHZhbHVlcwogICAg IGNhc2UgImYzMiI6IHJldHVybiB0eXBlb2YodmFsdWUpID09PSAibnVtYmVyIiAmJiBpc0Zpbml0 ZSh2YWx1ZSk7CiAgICAgY2FzZSAiZjY0IjogcmV0dXJuIHR5cGVvZih2YWx1ZSkgPT09ICJudW1i ZXIiICYmIGlzRmluaXRlKHZhbHVlKTsKICAgICBkZWZhdWx0OiB0aHJvdyBuZXcgRXJyb3IoYElt cGxlbWVudGF0aW9uIHByb2JsZW06IHVua25vd24gdHlwZSAke3R5cGV9YCk7CkBAIC01Nyw2ICs1 NywxNiBAQCBjb25zdCBfbm9ybWFsaXplRnVuY3Rpb25TaWduYXR1cmUgPSAocGFyYW1zLCByZXQp ID0+IHsKICAgICByZXR1cm4gW3BhcmFtcywgcmV0XTsKIH07CiAKK2NvbnN0IF9lcnJvckhhbmRs aW5nUHJveHlGb3IgPSBidWlsZGVyID0+IGJ1aWxkZXJbIl9faXNQcm94eSJdID8gYnVpbGRlciA6 IG5ldyBQcm94eShidWlsZGVyLCB7CisgICAgZ2V0OiAodGFyZ2V0LCBwcm9wZXJ0eSwgcmVjZWl2 ZXIpID0+IHsKKyAgICAgICAgaWYgKHByb3BlcnR5ID09PSAiX19pc1Byb3h5IikKKyAgICAgICAg ICAgIHJldHVybiB0cnVlOworICAgICAgICBpZiAodGFyZ2V0W3Byb3BlcnR5XSA9PT0gdW5kZWZp bmVkKQorICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBXZWJBc3NlbWJseSBidWlsZGVyIHJl Y2VpdmVkIHVua25vd24gcHJvcGVydHkgJyR7cHJvcGVydHl9J2ApOworICAgICAgICByZXR1cm4g dGFyZ2V0W3Byb3BlcnR5XTsKKyAgICB9Cit9KTsKKwogY29uc3QgX21heWJlUmVnaXN0ZXJUeXBl ID0gKGJ1aWxkZXIsIHR5cGUpID0+IHsKICAgICBjb25zdCB0eXBlU2VjdGlvbiA9IGJ1aWxkZXIu X2dldFNlY3Rpb24oIlR5cGUiKTsKICAgICBpZiAodHlwZW9mKHR5cGUpID09PSAibnVtYmVyIikg ewpAQCAtMTAwLDcgKzExMCw3IEBAIGNvbnN0IF9pbXBvcnRGdW5jdGlvbkNvbnRpbnVhdGlvbiA9 IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgICAgICBzZWN0aW9uLmRh dGEucHVzaCh7IGZpZWxkOiBmaWVsZCwgdHlwZTogdHlwZSwga2luZDogIkZ1bmN0aW9uIiwgbW9k dWxlOiBtb2R1bGUgfSk7CiAgICAgICAgIC8vIEltcG9ydHMgYWxzbyBjb3VudCBpbiB0aGUgZnVu Y3Rpb24gaW5kZXggc3BhY2UuIE1hcCB0aGVtIGFzIG9iamVjdHMgdG8gYXZvaWQgY2xhc2hpbmcg d2l0aCBDb2RlIGZ1bmN0aW9ucycgbmFtZXMuCiAgICAgICAgIGJ1aWxkZXIuX3JlZ2lzdGVyRnVu Y3Rpb25Ub0luZGV4U3BhY2UoeyBtb2R1bGU6IG1vZHVsZSwgZmllbGQ6IGZpZWxkIH0pOwotICAg ICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1By b3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9OwogfTsKIApAQCAtMTA5LDcgKzExOSw3IEBAIGNv bnN0IF9pbXBvcnRNZW1vcnlDb250aW51YXRpb24gPSAoYnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1 aWxkZXIpID0+IHsKICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKG1vZHVsZSwgYEltcG9ydCBNZW1v cnkgbW9kdWxlIHNob3VsZCBiZSBhIHN0cmluZywgZ290ICIke21vZHVsZX0iYCk7CiAgICAgICAg IGFzc2VydC5pc1N0cmluZyhmaWVsZCwgYEltcG9ydCBNZW1vcnkgZmllbGQgc2hvdWxkIGJlIGEg c3RyaW5nLCBnb3QgIiR7ZmllbGR9ImApOwogICAgICAgICBzZWN0aW9uLmRhdGEucHVzaCh7bW9k dWxlLCBmaWVsZCwga2luZDogIk1lbW9yeSIsIG1lbW9yeURlc2NyaXB0aW9uOiB7aW5pdGlhbCwg bWF4aW11bX19KTsKLSAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICByZXR1cm4g X2Vycm9ySGFuZGxpbmdQcm94eUZvcihuZXh0QnVpbGRlcik7CiAgICAgfTsKIH07CiAKQEAgLTEx OCw3ICsxMjgsNyBAQCBjb25zdCBfaW1wb3J0VGFibGVDb250aW51YXRpb24gPSAoYnVpbGRlciwg c2VjdGlvbiwgbmV4dEJ1aWxkZXIpID0+IHsKICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKG1vZHVs ZSwgYEltcG9ydCBUYWJsZSBtb2R1bGUgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7bW9kdWxl fSJgKTsKICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKGZpZWxkLCBgSW1wb3J0IFRhYmxlIGZpZWxk IHNob3VsZCBiZSBhIHN0cmluZywgZ290ICIke2ZpZWxkfSJgKTsKICAgICAgICAgc2VjdGlvbi5k YXRhLnB1c2goe21vZHVsZSwgZmllbGQsIGtpbmQ6ICJUYWJsZSIsIHRhYmxlRGVzY3JpcHRpb246 IHtpbml0aWFsLCBtYXhpbXVtLCBlbGVtZW50fX0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxk ZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsK ICAgICB9OwogfTsKIApAQCAtMTcyLDcgKzE4Miw3IEBAIGNvbnN0IF9leHBvcnRGdW5jdGlvbkNv bnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgICAg ICAgICAgICAgIGFzc2VydC5lcSh0eXBlLCBleHBvcnRlZEltcG9ydC50eXBlLCBgUmUtZXhwb3J0 aW5nIGltcG9ydCAiJHtleHBvcnRlZEltcG9ydC5maWVsZH0iIGFzICIke2ZpZWxkfSIgaGFzIG1p c21hdGNoaW5nIHR5cGVgKTsKICAgICAgICAgfQogICAgICAgICBzZWN0aW9uLmRhdGEucHVzaCh7 IGZpZWxkOiBmaWVsZCwgdHlwZTogdHlwZSwga2luZDogIkZ1bmN0aW9uIiwgaW5kZXg6IGluZGV4 IH0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JI YW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9OwogfTsKIApAQCAtMTg5LDcgKzE5 OSw3IEBAIGNvbnN0IF9leHBvcnRHbG9iYWxDb250aW51YXRpb24gPSAoYnVpbGRlciwgc2VjdGlv biwgbmV4dEJ1aWxkZXIpID0+IHsKICAgICByZXR1cm4gKGZpZWxkLCBpbmRleCkgPT4gewogICAg ICAgICBhc3NlcnQuaXNOdW1iZXIoaW5kZXgsIGBHbG9iYWwgZXhwb3J0cyBvbmx5IHN1cHBvcnQg bnVtYmVyIGluZGljZXMgcmlnaHQgbm93YCk7CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHsg ZmllbGQsIGtpbmQ6ICJHbG9iYWwiLCBpbmRleCB9KTsKLSAgICAgICAgcmV0dXJuIG5leHRCdWls ZGVyOworICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihuZXh0QnVpbGRlcik7 CiAgICAgfQogfTsKIApAQCAtMTk3LDcgKzIwNyw3IEBAIGNvbnN0IF9leHBvcnRNZW1vcnlDb250 aW51YXRpb24gPSAoYnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1aWxkZXIpID0+IHsKICAgICByZXR1 cm4gKGZpZWxkLCBpbmRleCkgPT4gewogICAgICAgICBhc3NlcnQuaXNOdW1iZXIoaW5kZXgsIGBN ZW1vcnkgZXhwb3J0cyBvbmx5IHN1cHBvcnQgbnVtYmVyIGluZGljZXNgKTsKICAgICAgICAgc2Vj dGlvbi5kYXRhLnB1c2goe2ZpZWxkLCBraW5kOiAiTWVtb3J5IiwgaW5kZXh9KTsKLSAgICAgICAg cmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZv cihuZXh0QnVpbGRlcik7CiAgICAgfQogfTsKIApAQCAtMjA1LDcgKzIxNSw3IEBAIGNvbnN0IF9l eHBvcnRUYWJsZUNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikg PT4gewogICAgIHJldHVybiAoZmllbGQsIGluZGV4KSA9PiB7CiAgICAgICAgIGFzc2VydC5pc051 bWJlcihpbmRleCwgYFRhYmxlIGV4cG9ydHMgb25seSBzdXBwb3J0IG51bWJlciBpbmRpY2VzYCk7 CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHtmaWVsZCwga2luZDogIlRhYmxlIiwgaW5kZXh9 KTsKLSAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICByZXR1cm4gX2Vycm9ySGFu ZGxpbmdQcm94eUZvcihuZXh0QnVpbGRlcik7CiAgICAgfQogfTsKIApAQCAtMjIwLDEwICsyMzAs MTAgQEAgY29uc3QgX2ltcG9ydEdsb2JhbENvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9u LCBuZXh0QnVpbGRlcikgPT4gewogICAgICAgICAgICAgICAgIGFzc2VydC5pc1N0cmluZyhmaWVs ZCwgYEltcG9ydCBnbG9iYWwgZmllbGQgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7ZmllbGR9 ImApOwogICAgICAgICAgICAgICAgIGFzc2VydC5pc1N0cmluZyhtdXRhYmlsaXR5LCBgSW1wb3J0 IGdsb2JhbCBtdXRhYmlsaXR5IHNob3VsZCBiZSBhIHN0cmluZywgZ290ICIke211dGFiaWxpdHl9 ImApOwogICAgICAgICAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHsgZ2xvYmFsRGVzY3JpcHRp b246IHsgdHlwZTogb3AsIG11dGFiaWxpdHk6IF9ub3JtYWxpemVNdXRhYmlsaXR5KG11dGFiaWxp dHkpIH0sIG1vZHVsZSwgZmllbGQsIGtpbmQ6ICJHbG9iYWwiIH0pOwotICAgICAgICAgICAgICAg IHJldHVybiBnbG9iYWxCdWlsZGVyOworICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5k bGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwogICAgICAgICAgICAgfTsKICAgICAgICAgfQot ICAgICAgICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRs aW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7CiAgICAgfTsKIH07CiAKQEAgLTMyNCwxMSArMzM0 LDExIEBAIGNvbnN0IF9jcmVhdGVGdW5jdGlvbkJ1aWxkZXIgPSAoZnVuYywgYnVpbGRlciwgcHJl dmlvdXNCdWlsZGVyKSA9PiB7CiAgICAgICAgICAgICBkZWZhdWx0OgogICAgICAgICAgICAgICAg IG5leHRCdWlsZGVyID0gZnVuY3Rpb25CdWlsZGVyOwogICAgICAgICAgICAgICAgIGJyZWFrOwot ICAgICAgICAgICAgICAgIGNhc2UgIkVuZCI6CisgICAgICAgICAgICBjYXNlICJFbmQiOgogICAg ICAgICAgICAgICAgIG5leHRCdWlsZGVyID0gcHJldmlvdXNCdWlsZGVyOwotICAgICAgICAgICAg ICAgICAgICBicmVhazsKKyAgICAgICAgICAgICAgICBicmVhazsKICAgICAgICAgICAgIGNhc2Ug IkJsb2NrIjoKLSAgICAgICAgICAgICAgICBjYXNlICJMb29wIjoKKyAgICAgICAgICAgIGNhc2Ug Ikxvb3AiOgogICAgICAgICAgICAgY2FzZSAiSWYiOgogICAgICAgICAgICAgICAgIG5leHRCdWls ZGVyID0gX2NyZWF0ZUZ1bmN0aW9uQnVpbGRlcihmdW5jLCBidWlsZGVyLCBmdW5jdGlvbkJ1aWxk ZXIpOwogICAgICAgICAgICAgICAgIGJyZWFrOwpAQCAtMzQ0LDExICszNTQsMTIgQEAgY29uc3Qg X2NyZWF0ZUZ1bmN0aW9uQnVpbGRlciA9IChmdW5jLCBidWlsZGVyLCBwcmV2aW91c0J1aWxkZXIp ID0+IHsKICAgICAgICAgICAgIGNvbnN0IHN0YWNrQXJncyA9IFtdOyAvLyBGSVhNRSBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYyNzA2CiAgICAgICAgICAgICBmdW5j LmNvZGUucHVzaCh7IG5hbWU6IG9wLCB2YWx1ZTogdmFsdWUsIGFyZ3VtZW50czogc3RhY2tBcmdz LCBpbW1lZGlhdGVzOiBpbW1zIH0pOwogICAgICAgICAgICAgaWYgKGhhc0NvbnRpbnVhdGlvbikK LSAgICAgICAgICAgICAgICByZXR1cm4gY29udGludWF0aW9uKG5leHRCdWlsZGVyKS5FbmQoKTsK LSAgICAgICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgICAgICAgICByZXR1cm4g X2Vycm9ySGFuZGxpbmdQcm94eUZvcihjb250aW51YXRpb24obmV4dEJ1aWxkZXIpLkVuZCgpKTsK KyAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsK ICAgICAgICAgfTsKLSAgICB9Ci0gICAgcmV0dXJuIGZ1bmN0aW9uQnVpbGRlcjsKKyAgICB9Owor CisgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZnVuY3Rpb25CdWlsZGVyKTsKIH0K IAogY29uc3QgX2NyZWF0ZUZ1bmN0aW9uID0gKHNlY3Rpb24sIGJ1aWxkZXIsIHByZXZpb3VzQnVp bGRlcikgPT4gewpAQCAtNDQ5LDEwICs0NjAsMTAgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVp bGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBGdW5jOiAocGFyYW1zLCByZXQpID0+IHsK ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbcGFyYW1zLCByZXRdID0gX25vcm1hbGl6ZUZ1 bmN0aW9uU2lnbmF0dXJlKHBhcmFtcywgcmV0KTsKICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBzLmRhdGEucHVzaCh7IHBhcmFtczogcGFyYW1zLCByZXQ6IHJldCB9KTsKLSAgICAgICAgICAg ICAgICAgICAgICAgICAgICByZXR1cm4gdHlwZUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IodHlwZUJ1aWxkZXIpOwogICAg ICAgICAgICAgICAgICAgICAgICAgfSwKICAgICAgICAgICAgICAgICAgICAgfTsKLSAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIHR5cGVCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1 cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih0eXBlQnVpbGRlcik7CiAgICAgICAgICAgICAgICAg fTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNDY2LDcgKzQ3Nyw3IEBAIGV4cG9ydCBk ZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICBpbXBvcnRCdWlsZGVy LkZ1bmN0aW9uID0gX2ltcG9ydEZ1bmN0aW9uQ29udGludWF0aW9uKHRoaXMsIHMsIGltcG9ydEJ1 aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICBpbXBvcnRCdWlsZGVyLk1lbW9yeSA9IF9pbXBv cnRNZW1vcnlDb250aW51YXRpb24odGhpcywgcywgaW1wb3J0QnVpbGRlcik7CiAgICAgICAgICAg ICAgICAgICAgIGltcG9ydEJ1aWxkZXIuVGFibGUgPSBfaW1wb3J0VGFibGVDb250aW51YXRpb24o dGhpcywgcywgaW1wb3J0QnVpbGRlcik7Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiBpbXBv cnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94 eUZvcihpbXBvcnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAg IGJyZWFrOwogCkBAIC00NzcsNyArNDg4LDcgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRl ciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBFbmQ6ICgpID0+IHRoaXMKICAgICAgICAgICAg ICAgICAgICAgICAgIC8vIEZJWE1FOiBhZGQgYWJpbGl0eSB0byBhZGQgdGhpcyB3aXRoIHdoYXRl dmVyLgogICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAgICAgICAgICAgICByZXR1cm4g ZnVuY3Rpb25CdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxp bmdQcm94eUZvcihmdW5jdGlvbkJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAg ICAgICAgICAgYnJlYWs7CiAKQEAgLTQ4OCwxMCArNDk5LDEwIEBAIGV4cG9ydCBkZWZhdWx0IGNs YXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRW5kOiAoKSA9PiB0aGlzLAog ICAgICAgICAgICAgICAgICAgICAgICAgVGFibGU6ICh7aW5pdGlhbCwgbWF4aW11bSwgZWxlbWVu dH0pID0+IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaCh7dGFibGVE ZXNjcmlwdGlvbjoge2luaXRpYWwsIG1heGltdW0sIGVsZW1lbnR9fSk7Ci0gICAgICAgICAgICAg ICAgICAgICAgICAgICAgcmV0dXJuIHRhYmxlQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih0YWJsZUJ1aWxkZXIpOwogICAg ICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAg ICAgICAgICAgICByZXR1cm4gdGFibGVCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1 cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih0YWJsZUJ1aWxkZXIpOwogICAgICAgICAgICAgICAg IH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTUwMiwxMCArNTEzLDEwIEBAIGV4cG9y dCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRW5kOiAo KSA9PiB0aGlzLAogICAgICAgICAgICAgICAgICAgICAgICAgSW5pdGlhbE1heFBhZ2VzOiAoaW5p dGlhbCwgbWF4KSA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcy5kYXRhLnB1c2go eyBpbml0aWFsLCBtYXggfSk7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIG1l bW9yeUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhh bmRsaW5nUHJveHlGb3IobWVtb3J5QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICB9 CiAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiBtZW1v cnlCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94 eUZvcihtZW1vcnlCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAg IGJyZWFrOwogCkBAIC01MTYsMTYgKzUyNywxNiBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWls ZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgIEVuZDogKCkgPT4gdGhpcywKICAgICAgICAg ICAgICAgICAgICAgICAgIEdldEdsb2JhbDogKHR5cGUsIGluaXRWYWx1ZSwgbXV0YWJpbGl0eSkg PT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKHsgdHlwZSwgb3A6 ICJnZXRfZ2xvYmFsIiwgbXV0YWJpbGl0eTogX25vcm1hbGl6ZU11dGFiaWxpdHkobXV0YWJpbGl0 eSksIGluaXRWYWx1ZSB9KTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gZ2xv YmFsQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFu ZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH0K ICAgICAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICAgICAgZm9yIChsZXQgb3Ag b2YgV0FTTS5kZXNjcmlwdGlvbi52YWx1ZV90eXBlKSB7CiAgICAgICAgICAgICAgICAgICAgICAg ICBnbG9iYWxCdWlsZGVyW190b0phdmFTY3JpcHROYW1lKG9wKV0gPSAoaW5pdFZhbHVlLCBtdXRh YmlsaXR5KSA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcy5kYXRhLnB1c2goeyB0 eXBlOiBvcCwgb3A6IG9wICsgIi5jb25zdCIsIG11dGFiaWxpdHk6IF9ub3JtYWxpemVNdXRhYmls aXR5KG11dGFiaWxpdHkpLCBpbml0VmFsdWUgfSk7Ci0gICAgICAgICAgICAgICAgICAgICAgICAg ICAgcmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0 dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7CiAgICAgICAgICAgICAg ICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgICAg IHJldHVybiBnbG9iYWxCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9y SGFuZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAg ICAgICAgICAgICAgIGJyZWFrOwogCkBAIC01MzksNyArNTUwLDcgQEAgZXhwb3J0IGRlZmF1bHQg Y2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgIGV4cG9ydEJ1aWxkZXIuRnVuY3Rp b24gPSBfZXhwb3J0RnVuY3Rpb25Db250aW51YXRpb24odGhpcywgcywgZXhwb3J0QnVpbGRlcik7 CiAgICAgICAgICAgICAgICAgICAgIGV4cG9ydEJ1aWxkZXIuTWVtb3J5ID0gX2V4cG9ydE1lbW9y eUNvbnRpbnVhdGlvbih0aGlzLCBzLCBleHBvcnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAg ICAgZXhwb3J0QnVpbGRlci5UYWJsZSA9IF9leHBvcnRUYWJsZUNvbnRpbnVhdGlvbih0aGlzLCBz LCBleHBvcnRCdWlsZGVyKTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGV4cG9ydEJ1aWxk ZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGV4 cG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7 CiAKQEAgLTU1Miw3ICs1NjMsNyBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAg ICAgICAgICAgICAgICAgICAgaWYgKHR5cGVvZihmdW5jdGlvbkluZGV4T3JOYW1lKSAhPT0gIm51 bWJlciIgJiYgdHlwZW9mKGZ1bmN0aW9uSW5kZXhPck5hbWUpICE9PSAic3RyaW5nIikKICAgICAg ICAgICAgICAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcihgU3RhcnQgc2VjdGlvbidzIGZ1bmN0 aW9uIGluZGV4ICBtdXN0IGVpdGhlciBiZSBhIG51bWJlciBvciBhIHN0cmluZ2ApOwogICAgICAg ICAgICAgICAgICAgICBzLmRhdGEucHVzaChmdW5jdGlvbkluZGV4T3JOYW1lKTsKLSAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIHN0YXJ0QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0 dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3Ioc3RhcnRCdWlsZGVyKTsKICAgICAgICAgICAgICAg ICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC01NjMsMTEgKzU3NCwxMSBAQCBleHBv cnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgIEVuZDog KCkgPT4gdGhpcywKICAgICAgICAgICAgICAgICAgICAgICAgIEVsZW1lbnQ6ICh7dGFibGVJbmRl eCA9IDAsIG9mZnNldCwgZnVuY3Rpb25JbmRpY2VzfSkgPT4gewogICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHMuZGF0YS5wdXNoKHt0YWJsZUluZGV4LCBvZmZzZXQsIGZ1bmN0aW9uSW5kaWNl c30pOwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBlbGVtZW50QnVpbGRlcjsK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZv cihlbGVtZW50QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAg ICAgICAgICAgIH07CiAKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGVsZW1lbnRCdWlsZGVy OworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihlbGVt ZW50QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsK IApAQCAtNjMyLDEyICs2NDMsMTIgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyBGSVhNRSBpbiBjaGVja2VkIG1v ZGUsIHRlc3QgdGhhdCB0aGUgdHlwZSBpcyBhY2NlcHRhYmxlIGZvciBzdGFydCBmdW5jdGlvbi4g V2UgcHJvYmFibHkgd2FudCBfcmVnaXN0ZXJGdW5jdGlvblRvSW5kZXhTcGFjZSB0byBhbHNvIHJl Z2lzdGVyIHR5cGVzIHBlciBpbmRleC4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTE2NTY1OAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVy biBidWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5k bGluZ1Byb3h5Rm9yKGJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAgICAgfSwKIAogICAg ICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgICAgICBjb2RlQnVpbGRlci5GdW5j dGlvbiA9IF9jcmVhdGVGdW5jdGlvbihzLCBidWlsZGVyLCBjb2RlQnVpbGRlcik7Ci0gICAgICAg ICAgICAgICAgICAgIHJldHVybiBjb2RlQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0 dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoY29kZUJ1aWxkZXIpOwogICAgICAgICAgICAgICAg IH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTY2MCwxOSArNjcxLDE5IEBAIGV4cG9y dCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBJbmRleDogaW5kZXggPT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg YXNzZXJ0LmVxKGluZGV4LCAwKTsgLy8gTGluZWFyIG1lbW9yeSBpbmRleCBtdXN0IGJlIHplcm8g aW4gTVZQLgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGhpc1NlZ21lbnQu aW5kZXggPSBpbmRleDsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVy biBzZWdtZW50QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJl dHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHNlZ21lbnRCdWlsZGVyKTsKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgfSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg T2Zmc2V0OiBvZmZzZXQgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg Ly8gRklYTUUgYWxsb3cgY29tcGxleCBpbml0X2V4cHIgaGVyZS4gaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NTcwMAogICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgYXNzZXJ0LmlzTnVtYmVyKG9mZnNldCk7CiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICB0aGlzU2VnbWVudC5vZmZzZXQgPSBvZmZzZXQ7Ci0gICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gc2VnbWVudEJ1aWxkZXI7CisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihz ZWdtZW50QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0sCiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgfTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gc2VnbWVudEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJu IF9lcnJvckhhbmRsaW5nUHJveHlGb3Ioc2VnbWVudEJ1aWxkZXIpOwogICAgICAgICAgICAgICAg ICAgICAgICAgfSwKICAgICAgICAgICAgICAgICAgICAgfTsKLSAgICAgICAgICAgICAgICAgICAg cmV0dXJuIGRhdGFCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFu ZGxpbmdQcm94eUZvcihkYXRhQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAg ICAgICAgICBicmVhazsKIApAQCAtNjkwLDEwICs3MDEsMTAgQEAgZXhwb3J0IGRlZmF1bHQgY2xh c3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgQnl0ZTogYiA9PiB7CiAgICAgICAgICAgICAg ICAgICAgIGFzc2VydC5lcShiICYgMHhGRiwgYiwgYFVua25vd24gc2VjdGlvbiBleHBlY3RlZCBi eXRlLCBnb3Q6ICIke2J9ImApOwogICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaChiKTsK LSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHVua25vd25CdWlsZGVyOworICAgICAgICAgICAg ICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih1bmtub3duQnVpbGRlcik7CiAg ICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfTsKLSAgICAgICAgICAgIHJldHVybiB1bmtu b3duQnVpbGRlcjsKKyAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHVu a25vd25CdWlsZGVyKTsKICAgICAgICAgfTsKICAgICB9CiAgICAgX2FkZFNlY3Rpb24obmFtZU9y TnVtYmVyLCBleHRyYU9iamVjdCkgewpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL0xvd0xldmVs QmluYXJ5LmpzIGIvSlNUZXN0cy93YXNtL0xvd0xldmVsQmluYXJ5LmpzCmluZGV4IDYxMWEyNmQu LmY5YmM4YTMgMTAwNjQ0Ci0tLSBhL0pTVGVzdHMvd2FzbS9Mb3dMZXZlbEJpbmFyeS5qcworKysg Yi9KU1Rlc3RzL3dhc20vTG93TGV2ZWxCaW5hcnkuanMKQEAgLTE3MCw2ICsxNzAsMTggQEAgZXhw b3J0IGRlZmF1bHQgY2xhc3MgTG93TGV2ZWxCaW5hcnkgewogICAgICAgICAgICAgdGhpcy51aW50 OCgweDgwIHwgYik7CiAgICAgICAgIH0gd2hpbGUgKHRydWUpOwogICAgIH0KKyAgICB2YXJ1aW50 NjQodikgeworICAgICAgICBhc3NlcnQuaXNOdW1iZXIodik7CisgICAgICAgIGlmICh2IDwgdmFy dWludDMyTWluIHx8IHZhcnVpbnQzMk1heCA8IHYpCisgICAgICAgICAgICB0aHJvdyBuZXcgUmFu Z2VFcnJvcihgdW5pbXBsZW1lbnRlZDogdmFydWludDY0IGxhcmdlciB0aGFuIDMyLWJpdGApOwor ICAgICAgICB0aGlzLnZhcnVpbnQzMih2KTsgLy8gRklYTUUgaW1wbGVtZW50IDY0LWJpdCB2YXJ7 dX1pbnQgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MzQyMAorICAg IH0KKyAgICB2YXJpbnQ2NCh2KSB7CisgICAgICAgIGFzc2VydC5pc051bWJlcih2KTsKKyAgICAg ICAgaWYgKHYgPCB2YXJpbnQzMk1pbiB8fCB2YXJpbnQzMk1heCA8IHYpCisgICAgICAgICAgICB0 aHJvdyBuZXcgUmFuZ2VFcnJvcihgdW5pbXBsZW1lbnRlZDogdmFyaW50NjQgbGFyZ2VyIHRoYW4g MzItYml0YCk7CisgICAgICAgIHRoaXMudmFyaW50MzIodik7IC8vIEZJWE1FIGltcGxlbWVudCA2 NC1iaXQgdmFye3V9aW50IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x NjM0MjAKKyAgICB9CiAgICAgdmFydWludDEodikgewogICAgICAgICBpZiAodiAhPT0gMCAmJiB2 ICE9PSAxKQogICAgICAgICAgICAgdGhyb3cgbmV3IFJhbmdlRXJyb3IoYEludmFsaWQgdmFydWlu dDEgJHt2fSByYW5nZSBpcyBbMCwgMV1gKTsKZGlmZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9mdW5j dGlvbi10ZXN0cy9leGNlcHRpb25zLmpzIGIvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL2V4 Y2VwdGlvbnMuanMKaW5kZXggZDJiM2E0OS4uOTUyNTEzZiAxMDA2NDQKLS0tIGEvSlNUZXN0cy93 YXNtL2Z1bmN0aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMKKysrIGIvSlNUZXN0cy93YXNtL2Z1bmN0 aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMKQEAgLTQ1LDE4ICs0NSwxOCBAQCBmdW5jdGlvbiBtYWtl SW5zdGFuY2UoKSB7CiAgICAgYXNzZXJ0LmVxKHRhYmxlLmdldCgwKSwgbnVsbCk7CiAKICAgICBm b3IgKGxldCBpID0gMDsgaSA8IDEwMDA7IGkrKykgewotICAgICAgICBhc3NlcnQudGhyb3dzKCgp ID0+IGZvbygwLCBpKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9yLCAiY2FsbF9pbmRpcmVjdCB0 byBhIG51bGwgdGFibGUgZW50cnkgKGV2YWx1YXRpbmcgJ2Z1bmMoLi4uYXJncyknKSIpOworICAg ICAgICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbygwLCBpKSwgV2ViQXNzZW1ibHkuUnVudGltZUVy cm9yLCAiY2FsbF9pbmRpcmVjdCB0byBhIG51bGwgdGFibGUgZW50cnkiKTsKICAgICB9CiAKICAg ICB0YWJsZS5zZXQoMCwgZm9vKTsKICAgICBhc3NlcnQuZXEodGFibGUuZ2V0KDApLCBmb28pOwog CiAgICAgZm9yIChsZXQgaSA9IDA7IGkgPCAxMDAwOyBpKyspIHsKLSAgICAgICAgYXNzZXJ0LnRo cm93cygoKSA9PiBmb28oMSArIGksIGkpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJPdXQg b2YgYm91bmRzIGNhbGxfaW5kaXJlY3QgKGV2YWx1YXRpbmcgJ2Z1bmMoLi4uYXJncyknKSIpOwor ICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbygxICsgaSwgaSksIFdlYkFzc2VtYmx5LlJ1 bnRpbWVFcnJvciwgIk91dCBvZiBib3VuZHMgY2FsbF9pbmRpcmVjdCIpOwogICAgIH0KIAogICAg IGZvciAobGV0IGkgPSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0gICAgICAgIGFzc2VydC50aHJvd3Mo KCkgPT4gZm9vKDAsIGkpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJjYWxsX2luZGlyZWN0 IHRvIGEgc2lnbmF0dXJlIHRoYXQgZG9lcyBub3QgbWF0Y2ggKGV2YWx1YXRpbmcgJ2Z1bmMoLi4u YXJncyknKSIpOworICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbygwLCBpKSwgV2ViQXNz ZW1ibHkuUnVudGltZUVycm9yLCAiY2FsbF9pbmRpcmVjdCB0byBhIHNpZ25hdHVyZSB0aGF0IGRv ZXMgbm90IG1hdGNoIik7CiAgICAgfQogCiAgICAgdGFibGUuc2V0KDAsIGJhcik7CmRpZmYgLS1n aXQgYS9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpzIGIvSlNUZXN0cy93 YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtbG9hZC5qcwppbmRleCA0ZGQ4MmRjLi4xMjMxZTAzIDEw MDY0NAotLS0gYS9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpzCisrKyBi L0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMKQEAgLTI5LDYgKzI5LDYg QEAgZnVuY3Rpb24gd2FzbUZyYW1lQ291bnRGcm9tRXJyb3IoZSkgewogfQogCiBmb3IgKGxldCBp ID0gMDsgaSA8IDEwMDA7IGkrKykgewotICAgIGNvbnN0IGUgPSBhc3NlcnQudGhyb3dzKCgpID0+ IGZvbyhudW1QYWdlcyAqIHBhZ2VTaXplICsgMSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwg Ik91dCBvZiBib3VuZHMgbWVtb3J5IGFjY2VzcyAoZXZhbHVhdGluZyAnZnVuYyguLi5hcmdzKScp Iik7CisgICAgY29uc3QgZSA9IGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKG51bVBhZ2VzICogcGFn ZVNpemUgKyAxKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9yLCAiT3V0IG9mIGJvdW5kcyBtZW1v cnkgYWNjZXNzIik7CiAgICAgYXNzZXJ0LmVxKHdhc21GcmFtZUNvdW50RnJvbUVycm9yKGUpLCAy KTsKIH0KZGlmZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLXN0b3Jl LmpzIGIvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtc3RvcmUuanMKaW5kZXggNTU5 ODdjMi4uMzY1NzEzYSAxMDA2NDQKLS0tIGEvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3Ry YXAtc3RvcmUuanMKKysrIGIvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtc3RvcmUu anMKQEAgLTI1LDUgKzI1LDUgQEAgY29uc3QgbnVtUGFnZXMgPSAxMDsKICAgICBjb25zdCBmb28g PSBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UobW9kdWxlLCB7YToge2I6IG5ldyBXZWJBc3NlbWJs eS5NZW1vcnkoe2luaXRpYWw6IG51bVBhZ2VzfSl9fSkuZXhwb3J0cy5mb287CiAKICAgICBmb3Ig KGxldCBpID0gMDsgaSA8IDEwMDAwOyBpKyspCi0gICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4g Zm9vKGksIG51bVBhZ2VzICogcGFnZVNpemUgKyAxKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9y LCAiT3V0IG9mIGJvdW5kcyBtZW1vcnkgYWNjZXNzIChldmFsdWF0aW5nICdmdW5jKC4uLmFyZ3Mp JykiKTsKKyAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBmb28oaSwgbnVtUGFnZXMgKiBwYWdl U2l6ZSArIDEpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJPdXQgb2YgYm91bmRzIG1lbW9y eSBhY2Nlc3MiKTsKIH0KZGlmZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13 YXNtLWJhZC1zaWduYXR1cmUuanMgYi9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS1i YWQtc2lnbmF0dXJlLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjNlNzBk NzgKLS0tIC9kZXYvbnVsbAorKysgYi9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS1i YWQtc2lnbmF0dXJlLmpzCkBAIC0wLDAgKzEsMTA1IEBACitpbXBvcnQgKiBhcyBhc3NlcnQgZnJv bSAnLi4vYXNzZXJ0LmpzJzsKK2ltcG9ydCBCdWlsZGVyIGZyb20gJy4uL0J1aWxkZXIuanMnOwor Citjb25zdCBpbXBvcnROYW1lID0gInBpZXJPbmUiOworY29uc3QgdHlwZXMgPSBbImkzMiIsICJp NjQiLCAiZjMyIiwgImY2NCIsICJ2b2lkIl07Citjb25zdCB0eXBlc05vblZvaWQgPSBbImkzMiIs ICJpNjQiLCAiZjMyIiwgImY2NCJdOworY29uc3Qgc3dhcFR5cGUgPSAodHlwZSwgaW5kZXgpID0+ IHR5cGVzWyh0eXBlcy5pbmRleE9mKHR5cGUpICsgaW5kZXgpICUgdHlwZXMubGVuZ3RoXTsKK2Nv bnN0IHN3YXBUeXBlTm9uVm9pZCA9ICh0eXBlLCBpbmRleCkgPT4gdHlwZXNOb25Wb2lkWyh0eXBl c05vblZvaWQuaW5kZXhPZih0eXBlKSArIGluZGV4KSAlIHR5cGVzTm9uVm9pZC5sZW5ndGhdOwor Citjb25zdCBzaWduYXR1cmVzID0gWworICAgIHsgcGFyYW1zOiBbImkzMiJdLCByZXQ6ICJ2b2lk IiB9LAorICAgIHsgcGFyYW1zOiBbImk2NCJdLCByZXQ6ICJ2b2lkIiB9LAorICAgIHsgcGFyYW1z OiBbImYzMiJdLCByZXQ6ICJ2b2lkIiB9LAorICAgIHsgcGFyYW1zOiBbImY2NCJdLCByZXQ6ICJ2 b2lkIiB9LAorICAgIHsgcGFyYW1zOiBbImkzMiJdLCByZXQ6ICJpMzIiIH0sCisgICAgeyBwYXJh bXM6IFsiaTY0Il0sIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogWyJmMzIiXSwgcmV0OiAi ZjMyIiB9LAorICAgIHsgcGFyYW1zOiBbImY2NCJdLCByZXQ6ICJmNjQiIH0sCisgICAgeyBwYXJh bXM6IFsiaTMyIiwgImYzMiJdLCByZXQ6ICJpMzIiIH0sCisgICAgeyBwYXJhbXM6IFsiZjMyIiwg ImkzMiJdLCByZXQ6ICJpMzIiIH0sCisgICAgeyBwYXJhbXM6IFsiaTY0IiwgImY2NCJdLCByZXQ6 ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IFsiZjY0IiwgImk2NCJdLCByZXQ6ICJpNjQiIH0sCisg ICAgeyBwYXJhbXM6IFsiaTMyIiwgImYzMiIsICJpMzIiXSwgcmV0OiAiaTMyIiB9LAorICAgIHsg cGFyYW1zOiBbImkzMiIsICJmMzIiLCAiaTMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7IHBhcmFt czogWyJpNjQiLCAiZjY0IiwgImk2NCJdLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IFsi aTY0IiwgImY2NCIsICJpNjQiXSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBBcnJheSgz MikuZmlsbCgiaTMyIiksIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogQXJyYXkoMzIpLmZp bGwoImk2NCIpLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IEFycmF5KDMyKS5maWxsKCJm MzIiKSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBBcnJheSgzMikuZmlsbCgiZjY0Iiks IHJldDogImk2NCIgfSwKK107CisKK2NvbnN0IG1ha2VJbXBvcnRlciA9IHNpZ25hdHVyZSA9PiB7 CisgICAgY29uc3QgYnVpbGRlciA9IChuZXcgQnVpbGRlcigpKQorICAgICAgICAuVHlwZSgpLkVu ZCgpCisgICAgICAgIC5JbXBvcnQoKS5GdW5jdGlvbigiZXhwb3J0cyIsIGltcG9ydE5hbWUsIHNp Z25hdHVyZSkuRW5kKCk7CisgICAgcmV0dXJuIG5ldyBXZWJBc3NlbWJseS5Nb2R1bGUoYnVpbGRl ci5XZWJBc3NlbWJseSgpLmdldCgpKTsKK307CisKK2NvbnN0IG1ha2VJbXBvcnRlZSA9IHNpZ25h dHVyZSA9PiB7CisgICAgY29uc3QgYnVpbGRlciA9IChuZXcgQnVpbGRlcigpKQorICAgICAgICAu VHlwZSgpLkVuZCgpCisgICAgICAgIC5GdW5jdGlvbigpLkVuZCgpCisgICAgICAgIC5FeHBvcnQo KQorICAgICAgICAgICAgLkZ1bmN0aW9uKGltcG9ydE5hbWUpCisgICAgICAgIC5FbmQoKQorICAg ICAgICAuQ29kZSgpCisgICAgICAgICAgICAuRnVuY3Rpb24oaW1wb3J0TmFtZSwgc2lnbmF0dXJl KTsKKyAgICBzd2l0Y2ggKHNpZ25hdHVyZS5yZXQpIHsKKyAgICBjYXNlICJpMzIiOiBidWlsZGVy LkkzMkNvbnN0KDApOyBicmVhazsKKyAgICBjYXNlICJpNjQiOiBidWlsZGVyLkk2NENvbnN0KDAp OyBicmVhazsKKyAgICBjYXNlICJmMzIiOiBidWlsZGVyLkYzMkNvbnN0KDApOyBicmVhazsKKyAg ICBjYXNlICJmNjQiOiBidWlsZGVyLkY2NENvbnN0KDApOyBicmVhazsKKyAgICBjYXNlICJ2b2lk IjogYnJlYWs7CisgICAgfQorICAgIHJldHVybiBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UobmV3 IFdlYkFzc2VtYmx5Lk1vZHVsZShidWlsZGVyLlJldHVybigpLkVuZCgpLkVuZCgpLldlYkFzc2Vt Ymx5KCkuZ2V0KCkpKTsKK307CisKKyhmdW5jdGlvbiBCYWRTaWduYXR1cmVEcm9wU3RhcnRQYXJh bXMoKSB7CisgICAgZm9yIChsZXQgc2lnbmF0dXJlIG9mIHNpZ25hdHVyZXMpIHsKKyAgICAgICAg Y29uc3QgaW1wb3J0ZWUgPSBtYWtlSW1wb3J0ZWUoc2lnbmF0dXJlKTsKKyAgICAgICAgZm9yIChs ZXQgaSA9IDE7IGkgPD0gc2lnbmF0dXJlLnBhcmFtcy5sZW5ndGg7ICsraSkgeworICAgICAgICAg ICAgY29uc3QgYmFkUGFyYW1TaWduYXR1cmUgPSB7IHBhcmFtczogc2lnbmF0dXJlLnBhcmFtcy5z bGljZShpLCBzaWduYXR1cmUucGFyYW1zLmxlbmd0aCksIHJldDogc2lnbmF0dXJlLnJldCB9Owor ICAgICAgICAgICAgY29uc3QgaW1wb3J0ZXIgPSBtYWtlSW1wb3J0ZXIoYmFkUGFyYW1TaWduYXR1 cmUpOworICAgICAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBuZXcgV2ViQXNzZW1ibHkuSW5z dGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKSwgV2ViQXNzZW1ibHkuTGlua0Vycm9yLCBgaW1wb3J0 ZWQgZnVuY3Rpb24ncyBzaWduYXR1cmUgbWlzbWF0Y2hlcyB0aGUgcHJvdmlkZWQgV2ViQXNzZW1i bHkgZnVuY3Rpb24ncyBzaWduYXR1cmUgKGV2YWx1YXRpbmcgJ25ldyBXZWJBc3NlbWJseS5JbnN0 YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpJylgKTsKKyAgICAgICAgfQorICAgIH0KK30pKCk7CisK KyhmdW5jdGlvbiBCYWRTaWduYXR1cmVEcm9wRW5kUGFyYW1zKCkgeworICAgIGZvciAobGV0IHNp Z25hdHVyZSBvZiBzaWduYXR1cmVzKSB7CisgICAgICAgIGNvbnN0IGltcG9ydGVlID0gbWFrZUlt cG9ydGVlKHNpZ25hdHVyZSk7CisgICAgICAgIGZvciAobGV0IGkgPSAxOyBpIDwgc2lnbmF0dXJl LnBhcmFtcy5sZW5ndGg7ICsraSkgeworICAgICAgICAgICAgY29uc3QgYmFkUGFyYW1TaWduYXR1 cmUgPSB7IHBhcmFtczogc2lnbmF0dXJlLnBhcmFtcy5zbGljZSgwLCBpKSwgcmV0OiBzaWduYXR1 cmUucmV0IH07CisgICAgICAgICAgICBjb25zdCBpbXBvcnRlciA9IG1ha2VJbXBvcnRlcihiYWRQ YXJhbVNpZ25hdHVyZSk7CisgICAgICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IG5ldyBXZWJB c3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpLCBXZWJBc3NlbWJseS5MaW5rRXJy b3IsIGBpbXBvcnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBtaXNtYXRjaGVzIHRoZSBwcm92aWRl ZCBXZWJBc3NlbWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSAoZXZhbHVhdGluZyAnbmV3IFdlYkFz c2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSknKWApOworICAgICAgICB9CisgICAg fQorfSkoKTsKKworKGZ1bmN0aW9uIEJhZFNpZ25hdHVyZVN3YXBQYXJhbSgpIHsKKyAgICBmb3Ig KGxldCBzaWduYXR1cmUgb2Ygc2lnbmF0dXJlcykgeworICAgICAgICBjb25zdCBpbXBvcnRlZSA9 IG1ha2VJbXBvcnRlZShzaWduYXR1cmUpOworICAgICAgICBmb3IgKGxldCBzaWduYXR1cmVJbmRl eCA9IDA7IHNpZ25hdHVyZUluZGV4IDwgc2lnbmF0dXJlLmxlbmd0aDsgKytzaWduYXR1cmVJbmRl eCkgeworICAgICAgICAgICAgZm9yIChsZXQgdHlwZUluZGV4ID0gMTsgdHlwZUluZGV4IDwgdHlw ZXNOb25Wb2lkLmxlbmd0aDsgKyt0eXBlSW5kZXgpIHsKKyAgICAgICAgICAgICAgICBsZXQgYmFk UGFyYW1zID0gc2lnbmF0dXJlLnBhcmFtcy5zbGljZSgpOworICAgICAgICAgICAgICAgIGJhZFBh cmFtc1tzaWduYXR1cmVJbmRleF0gPSBzd2FwVHlwZU5vblZvaWQoYmFkUGFyYW1zW3NpZ25hdHVy ZUluZGV4XSwgdHlwZUluZGV4KTsKKyAgICAgICAgICAgICAgICBjb25zdCBiYWRQYXJhbVNpZ25h dHVyZSA9IHsgcGFyYW1zOiBiYWRQYXJhbXMsIHJldDogc2lnbmF0dXJlLnJldCB9OworICAgICAg ICAgICAgICAgIGNvbnN0IGltcG9ydGVyID0gbWFrZUltcG9ydGVyKGJhZFBhcmFtU2lnbmF0dXJl KTsKKyAgICAgICAgICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IG5ldyBXZWJBc3NlbWJseS5J bnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpLCBXZWJBc3NlbWJseS5MaW5rRXJyb3IsIGBpbXBv cnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBtaXNtYXRjaGVzIHRoZSBwcm92aWRlZCBXZWJBc3Nl bWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSAoZXZhbHVhdGluZyAnbmV3IFdlYkFzc2VtYmx5Lklu c3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSknKWApOworICAgICAgICAgICAgfQorICAgICAgICB9 CisgICAgfQorfSkoKTsKKworKGZ1bmN0aW9uIEJhZFNpZ25hdHVyZVJldCgpIHsKKyAgICBmb3Ig KGxldCBzaWduYXR1cmUgb2Ygc2lnbmF0dXJlcykgeworICAgICAgICBjb25zdCBpbXBvcnRlZSA9 IG1ha2VJbXBvcnRlZShzaWduYXR1cmUpOworICAgICAgICBmb3IgKGxldCB0eXBlSW5kZXggPSAx OyB0eXBlSW5kZXggPCB0eXBlcy5sZW5ndGg7ICsrdHlwZUluZGV4KSB7CisgICAgICAgICAgICBj b25zdCBiYWRQYXJhbVNpZ25hdHVyZSA9IHsgcGFyYW1zOiBzaWduYXR1cmUucGFyYW1zLCByZXQ6 IHN3YXBUeXBlKHNpZ25hdHVyZS5yZXQsIHR5cGVJbmRleCkgfTsKKyAgICAgICAgICAgIGNvbnN0 IGltcG9ydGVyID0gbWFrZUltcG9ydGVyKGJhZFBhcmFtU2lnbmF0dXJlKTsKKyAgICAgICAgICAg IGFzc2VydC50aHJvd3MoKCkgPT4gbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBp bXBvcnRlZSksIFdlYkFzc2VtYmx5LkxpbmtFcnJvciwgYGltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2ln bmF0dXJlIG1pc21hdGNoZXMgdGhlIHByb3ZpZGVkIFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2ln bmF0dXJlIChldmFsdWF0aW5nICduZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGlt cG9ydGVlKScpYCk7CisgICAgICAgIH0KKyAgICB9Cit9KSgpOwpkaWZmIC0tZ2l0IGEvSlNUZXN0 cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMgYi9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20t dG8td2FzbS5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wODI1NWM2Ci0t LSAvZGV2L251bGwKKysrIGIvSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMKQEAg LTAsMCArMSw3MyBAQAoraW1wb3J0ICogYXMgYXNzZXJ0IGZyb20gJy4uL2Fzc2VydC5qcyc7Citp bXBvcnQgQnVpbGRlciBmcm9tICcuLi9CdWlsZGVyLmpzJzsKKy8qCitjb25zdCBjYWxsZXJUb3BC aXRzID0gMHhDMEZFQkVFRjsKK2NvbnN0IGlubmVyUmV0dXJuSGkgPSAweERFQURGQUNFOworY29u c3QgaW5uZXJSZXR1cm5MbyA9IDB4QzBGRUMwRkU7CisKK2NvbnN0IGNhbGxlck1vZHVsZSA9ICgp ID0+IHsKKyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAgIC5UeXBl KCkuRW5kKCkKKyAgICAgICAgLkltcG9ydCgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImV4cG9y dHMiLCAiY2FsbE1lIiwgeyBwYXJhbXM6IFsiaTY0Il0sIHJldDogImk2NCIgfSkKKyAgICAgICAg LkVuZCgpCisgICAgICAgIC5GdW5jdGlvbigpLkVuZCgpCisgICAgICAgIC5FeHBvcnQoKQorICAg ICAgICAgICAgLkZ1bmN0aW9uKCJlbnRyeSIpCisgICAgICAgIC5FbmQoKQorICAgICAgICAuQ29k ZSgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImVudHJ5IiwgeyBwYXJhbXM6IFsiaTMyIl0sIHJl dDogImkzMiIgfSwgWyJpNjQiXSkKKyAgICAgICAgICAgICAgICAuSTMyQ29uc3QoY2FsbGVyVG9w Qml0cykuSTY0RXh0ZW5kVUkzMigpLkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRVSTMyKCkuSTY0U2hs KCkgLy8gKChpNjQpY2FsbGVyVG9wQml0cykgPDwgMzIKKyAgICAgICAgICAgICAgICAuR2V0TG9j YWwoMCkuSTY0RXh0ZW5kVUkzMigpCisgICAgICAgICAgICAgICAgLkk2NE9yKCkgLy8gdmFsdWU6 IHBhcmFtIHwgKCgoaTY0KWNhbGxlclRvcEJpdHMgPDwgMzIpKQorICAgICAgICAgICAgICAgIC5D YWxsKDApIC8vIENhbGxzIGV4cG9ydHMuY2FsbE1lKHBhcmFtIHwgKCgoaTY0KWNhbGxlclRvcEJp dHMpIDw8IDMyKSkuCisgICAgICAgICAgICAgICAgLlRlZUxvY2FsKDEpLkkzMldyYXBJNjQoKSAv LyBsbzogKGkzMiljYWxsUmVzdWx0CisgICAgICAgICAgICAgICAgLkdldExvY2FsKDEpLkkzMkNv bnN0KDMyKS5JNjRFeHRlbmRVSTMyKCkuSTY0U2hyVSgpLkkzMldyYXBJNjQoKSAvLyBoaTogKGkz MikoY2FsbFJlc3VsdCA+PiAzMikKKyAgICAgICAgICAgICAgICAuSTMyWG9yKCkKKyAgICAgICAg ICAgICAgICAuUmV0dXJuKCkKKyAgICAgICAgICAgIC5FbmQoKQorICAgICAgICAuRW5kKCk7Cisg ICAgcmV0dXJuIG5ldyBXZWJBc3NlbWJseS5Nb2R1bGUoYnVpbGRlci5XZWJBc3NlbWJseSgpLmdl dCgpKTsKK307CisKK2NvbnN0IGNhbGxlZU1vZHVsZSA9ICgpID0+IHsKKyAgICBjb25zdCBidWls ZGVyID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAgIC5UeXBlKCkuRW5kKCkKKyAgICAgICAgLklt cG9ydCgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImltcCIsICJmdW5jIiwgeyBwYXJhbXM6IFsi aTMyIiwgImkzMiJdLCByZXQ6ICJpMzIiIH0pCisgICAgICAgIC5FbmQoKQorICAgICAgICAuRnVu Y3Rpb24oKS5FbmQoKQorICAgICAgICAuRXhwb3J0KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigi Y2FsbE1lIikKKyAgICAgICAgLkVuZCgpCisgICAgICAgIC5Db2RlKCkKKyAgICAgICAgICAgIC5G dW5jdGlvbigiY2FsbE1lIiwgeyBwYXJhbXM6IFsiaTY0Il0sIHJldDogImk2NCIgfSkKKyAgICAg ICAgICAgICAgICAuR2V0TG9jYWwoMCkuSTMyV3JhcEk2NCgpIC8vIGxvOiAoaTMyKXBhcmFtCisg ICAgICAgICAgICAgICAgLkdldExvY2FsKDApLkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRVSTMyKCku STY0U2hyVSgpLkkzMldyYXBJNjQoKSAvLyBoaTogKGkzMikocGFyYW0gPj4gMzIpCisgICAgICAg ICAgICAgICAgLkNhbGwoMCkgLy8gQ2FsbHMgaW1wLmZ1bmMgd2l0aCB0aGUgNjQtYml0IHZhbHVl IGFzIGkzMiB7IGhpLCBsbyB9LgorICAgICAgICAgICAgICAgIC5Ecm9wKCkKKyAgICAgICAgICAg ICAgICAuSTMyQ29uc3QoaW5uZXJSZXR1cm5IaSkuSTY0RXh0ZW5kVUkzMigpLkkzMkNvbnN0KDMy KS5JNjRFeHRlbmRVSTMyKCkuSTY0U2hsKCkuSTMyQ29uc3QoaW5uZXJSZXR1cm5MbykuSTY0RXh0 ZW5kVUkzMigpLkk2NE9yKCkgLy8gKChpNjQpaGkgPDwgMzIpIHwgKGk2NClsbworICAgICAgICAg ICAgICAgIC5SZXR1cm4oKQorICAgICAgICAgICAgLkVuZCgpCisgICAgICAgIC5FbmQoKTsKKyAg ICByZXR1cm4gbmV3IFdlYkFzc2VtYmx5Lk1vZHVsZShidWlsZGVyLldlYkFzc2VtYmx5KCkuZ2V0 KCkpOworfTsKKworKGZ1bmN0aW9uIFdhc21Ub1dhc20oKSB7CisgICAgbGV0IHZhbHVlOworICAg IGNvbnN0IGZ1bmMgPSAoaGksIGxvKSA9PiB7IHZhbHVlID0geyBoaTogaGksIGxvOiBsbyB9OyBw cmludChgJHtFcnJvci5zdGFja31gKTsgcmV0dXJuIGhpIF4gbG87IH07CisgICAgY29uc3QgY2Fs bGVlID0gbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGNhbGxlZU1vZHVsZSgpLCB7IGltcDogeyBm dW5jOiBmdW5jIH0gfSk7CisgICAgY29uc3QgY2FsbGVyID0gbmV3IFdlYkFzc2VtYmx5Lkluc3Rh bmNlKGNhbGxlck1vZHVsZSgpLCBjYWxsZWUpOworICAgIGZvciAobGV0IGkgPSAwOyBpIDwgNDA5 NjsgKytpKSB7CisgICAgICAgIGFzc2VydC5lcShjYWxsZXIuZXhwb3J0cy5lbnRyeShpKSwgaW5u ZXJSZXR1cm5IaSBeIGlubmVyUmV0dXJuTG8pOworICAgICAgICBhc3NlcnQuZXEodmFsdWUuaGks IGNhbGxlclRvcEJpdHMpOworICAgICAgICBhc3NlcnQuZXEodmFsdWUubG8sIGkpOworICAgIH0K K30pKCk7CisKKworLy8gRklYTUU6IHRlc3Qgd2FzbS0+d2FzbSB1c2luZyAzMi1iaXQgdGhpbmdz IChpbmNsdWRpbmcgZmxvYXQpLCBhcyB3ZWxsIGFzIDY0LWJpdCBOYU5zIHRoYXQgZG9uJ3QgZ2V0 IGNhbm9uaWNhbGl6ZWQKKy8vIEZJWE1FOiBkbyBhIHRocm93IHR3by1kZWVwCisvLyBGSVhNRTog Y2hlY2sgdGhhdCB0aGUgZmlyc3Qgd2FzbSdzIGluc3RhbmNlIGlzIGJhY2sgaW4gT0sgc3RhdGUg KHdpdGggdGFibGUgb3IgZ2xvYmFsPykKKy8vIEZJWE1FOiB0ZXN0IGNhbGxpbmcgdGhyb3VnaCBh IFRhYmxlCisqLwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2pzYy5jcHAgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvanNjLmNwcAppbmRleCAyOTIzOGEwLi5jNTY1MmE0IDEwMDY0 NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvanNjLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvanNjLmNwcApAQCAtNTQsNiArNTQsOCBAQAogI2luY2x1ZGUgIkpTU3RyaW5nLmgi CiAjaW5jbHVkZSAiSlNUeXBlZEFycmF5cy5oIgogI2luY2x1ZGUgIkpTV2ViQXNzZW1ibHlDYWxs ZWUuaCIKKyNpbmNsdWRlICJKU1dlYkFzc2VtYmx5SW5zdGFuY2UuaCIKKyNpbmNsdWRlICJKU1dl YkFzc2VtYmx5TW9kdWxlLmgiCiAjaW5jbHVkZSAiTExJbnREYXRhLmgiCiAjaW5jbHVkZSAiTExJ bnRUaHVua3MuaCIKICNpbmNsdWRlICJPYmplY3RDb25zdHJ1Y3Rvci5oIgpAQCAtNzAsNiArNzIs NyBAQAogI2luY2x1ZGUgIlR5cGVQcm9maWxlckxvZy5oIgogI2luY2x1ZGUgIldhc21QbGFuLmgi CiAjaW5jbHVkZSAiV2FzbU1lbW9yeS5oIgorI2luY2x1ZGUgIldlYkFzc2VtYmx5TW9kdWxlUmVj b3JkLmgiCiAjaW5jbHVkZSA8bG9jYWxlLmg+CiAjaW5jbHVkZSA8bWF0aC5oPgogI2luY2x1ZGUg PHN0ZGlvLmg+CkBAIC0yNjAwLDYgKzI2MDMsNyBAQCBzdGF0aWMgRW5jb2RlZEpTVmFsdWUgSlND X0hPU1RfQ0FMTCBmdW5jdGlvblRlc3RXYXNtTW9kdWxlRnVuY3Rpb25zKEV4ZWNTdGF0ZSogZQog ewogICAgIFZNJiB2bSA9IGV4ZWMtPnZtKCk7CiAgICAgYXV0byBzY29wZSA9IERFQ0xBUkVfVEhS T1dfU0NPUEUodm0pOworICAgIGF1dG8qIGdsb2JhbE9iamVjdCA9IGV4ZWMtPmxleGljYWxHbG9i YWxPYmplY3QoKTsKIAogICAgIGlmICghT3B0aW9uczo6dXNlV2ViQXNzZW1ibHkoKSkKICAgICAg ICAgcmV0dXJuIHRocm93Vk1UeXBlRXJyb3IoZXhlYywgc2NvcGUsIEFTQ0lJTGl0ZXJhbCgidGVz dFdhc21Nb2R1bGUgc2hvdWxkIG9ubHkgYmUgY2FsbGVkIGlmIHRoZSB1c2VXZWJBc3NlbWJseSBv cHRpb24gaXMgc2V0IikpOwpAQCAtMjYzMywxOSArMjYzNywyNCBAQCBzdGF0aWMgRW5jb2RlZEpT VmFsdWUgSlNDX0hPU1RfQ0FMTCBmdW5jdGlvblRlc3RXYXNtTW9kdWxlRnVuY3Rpb25zKEV4ZWNT dGF0ZSogZQogICAgICAgICAgICAgfSk7CiAgICAgfQogCi0gICAgdm9pZCogbWVtb3J5Qnl0ZXMg PSBudWxscHRyOwotICAgIHVpbnQzMl90IG1lbW9yeVNpemUgPSAwOwotICAgIHN0ZDo6dW5pcXVl X3B0cjxXYXNtOjpNZW1vcnk+IG1lbW9yeTsKLSAgICBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9k dWxlSW5mb3JtYXRpb24+IG1vZHVsZUluZm9ybWF0aW9uID0gcGxhbi50YWtlTW9kdWxlSW5mb3Jt YXRpb24oKTsKKyAgICBTeW1ib2xUYWJsZSogZXhwb3J0U3ltYm9sVGFibGUgPSBTeW1ib2xUYWJs ZTo6Y3JlYXRlKHZtKTsKKyAgICBhdXRvKiBtb2R1bGVTdHJ1Y3R1cmUgPSBJbnRlcm5hbEZ1bmN0 aW9uOjpjcmVhdGVTdWJjbGFzc1N0cnVjdHVyZShleGVjLCBKU1ZhbHVlKCksIGV4ZWMtPmxleGlj YWxHbG9iYWxPYmplY3QoKS0+V2ViQXNzZW1ibHlNb2R1bGVTdHJ1Y3R1cmUoKSk7CisgICAgUkVU VVJOX0lGX0VYQ0VQVElPTihzY29wZSwgZW5jb2RlZEpTVmFsdWUoKSk7CisgICAgSlNXZWJBc3Nl bWJseU1vZHVsZSogbW9kdWxlID0gSlNXZWJBc3NlbWJseU1vZHVsZTo6Y3JlYXRlKHZtLCBtb2R1 bGVTdHJ1Y3R1cmUsIHBsYW4udGFrZU1vZHVsZUluZm9ybWF0aW9uKCksIHBsYW4udGFrZUNhbGxM aW5rSW5mb3MoKSwgcGxhbi50YWtlV2FzbUV4aXRTdHVicygpLCBleHBvcnRTeW1ib2xUYWJsZSwg MCk7CisgICAgU3RydWN0dXJlKiBpbnN0YW5jZVN0cnVjdHVyZSA9IEludGVybmFsRnVuY3Rpb246 OmNyZWF0ZVN1YmNsYXNzU3RydWN0dXJlKGV4ZWMsIEpTVmFsdWUoKSwgZ2xvYmFsT2JqZWN0LT5X ZWJBc3NlbWJseUluc3RhbmNlU3RydWN0dXJlKCkpOworICAgIFJFVFVSTl9JRl9FWENFUFRJT04o c2NvcGUsIGVuY29kZWRKU1ZhbHVlKCkpOworICAgIElkZW50aWZpZXIgbW9kdWxlS2V5ID0gSWRl bnRpZmllcjo6ZnJvbVVpZChQcml2YXRlTmFtZShQcml2YXRlTmFtZTo6RGVzY3JpcHRpb24sICJX ZWJBc3NlbWJseUluc3RhbmNlIikpOworICAgIFdlYkFzc2VtYmx5TW9kdWxlUmVjb3JkKiBtb2R1 bGVSZWNvcmQgPSBXZWJBc3NlbWJseU1vZHVsZVJlY29yZDo6Y3JlYXRlKGV4ZWMsIHZtLCBnbG9i YWxPYmplY3QtPndlYkFzc2VtYmx5TW9kdWxlUmVjb3JkU3RydWN0dXJlKCksIG1vZHVsZUtleSwg bW9kdWxlLT5tb2R1bGVJbmZvcm1hdGlvbigpKTsKKyAgICBSRVRVUk5fSUZfRVhDRVBUSU9OKHNj b3BlLCBlbmNvZGVkSlNWYWx1ZSgpKTsKKyAgICBKU1dlYkFzc2VtYmx5SW5zdGFuY2UqIGluc3Rh bmNlID0gSlNXZWJBc3NlbWJseUluc3RhbmNlOjpjcmVhdGUodm0sIGluc3RhbmNlU3RydWN0dXJl LCBtb2R1bGUsIG1vZHVsZVJlY29yZC0+Z2V0TW9kdWxlTmFtZXNwYWNlKGV4ZWMpKTsKKyAgICBS RVRVUk5fSUZfRVhDRVBUSU9OKHNjb3BlLCBlbmNvZGVkSlNWYWx1ZSgpKTsKKyAgICB2bS50b3BK U1dlYkFzc2VtYmx5SW5zdGFuY2UgPSBpbnN0YW5jZTsKIAotICAgIGlmICghIW1vZHVsZUluZm9y bWF0aW9uLT5tZW1vcnkpIHsKLSAgICAgICAgbWVtb3J5ID0gc3RkOjptYWtlX3VuaXF1ZTxXYXNt OjpNZW1vcnk+KG1vZHVsZUluZm9ybWF0aW9uLT5tZW1vcnkuaW5pdGlhbCgpLCBtb2R1bGVJbmZv cm1hdGlvbi0+bWVtb3J5Lm1heGltdW0oKSk7Ci0gICAgICAgIFJFTEVBU0VfQVNTRVJUKG1lbW9y eS0+aXNWYWxpZCgpKTsKLSAgICAgICAgbWVtb3J5Qnl0ZXMgPSBtZW1vcnktPm1lbW9yeSgpOwot ICAgICAgICBtZW1vcnlTaXplID0gbWVtb3J5LT5zaXplKCk7CisgICAgaWYgKCEhbW9kdWxlLT5t b2R1bGVJbmZvcm1hdGlvbigpLm1lbW9yeSkgeworICAgICAgICBXYXNtOjpNZW1vcnkgbWVtb3J5 KG1vZHVsZS0+bW9kdWxlSW5mb3JtYXRpb24oKS5tZW1vcnkuaW5pdGlhbCgpLCBtb2R1bGUtPm1v ZHVsZUluZm9ybWF0aW9uKCkubWVtb3J5Lm1heGltdW0oKSk7CisgICAgICAgIFJFTEVBU0VfQVNT RVJUKG1lbW9yeS5pc1ZhbGlkKCkpOworICAgICAgICBpbnN0YW5jZS0+c2V0TWVtb3J5KHZtLCBK U1dlYkFzc2VtYmx5TWVtb3J5OjpjcmVhdGUodm0sIGdsb2JhbE9iamVjdC0+V2ViQXNzZW1ibHlN ZW1vcnlTdHJ1Y3R1cmUoKSwgV1RGTW92ZShtZW1vcnkpKSk7CiAgICAgfQotICAgIHZtLnRvcFdh c21NZW1vcnlQb2ludGVyID0gbWVtb3J5Qnl0ZXM7Ci0gICAgdm0udG9wV2FzbU1lbW9yeVNpemUg PSBtZW1vcnlTaXplOwogCiAgICAgZm9yICh1aW50MzJfdCBpID0gMDsgaSA8IGZ1bmN0aW9uQ291 bnQ7ICsraSkgewogICAgICAgICBKU0FycmF5KiB0ZXN0Q2FzZXMgPSBqc0Nhc3Q8SlNBcnJheSo+ KGV4ZWMtPmFyZ3VtZW50KGkgKyAyKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvcnVudGltZS9KU1R5cGUuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTVHlw ZS5oCmluZGV4IDA1MjAyZjMuLmFjNTA5ZDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL0pTVHlwZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L0pTVHlwZS5oCkBAIC05Myw2ICs5Myw4IEBAIGVudW0gSlNUeXBlIDogdWludDhfdCB7CiAgICAg SlNNYXBUeXBlLAogICAgIEpTU2V0VHlwZSwKIAorICAgIFdlYkFzc2VtYmx5RnVuY3Rpb25UeXBl LAorCiAgICAgTGFzdEpTQ09iamVjdFR5cGUgPSBKU1NldFR5cGUsCiAgICAgTWF4SlNUeXBlID0g MGIxMTExMTExMSwKIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGlt ZS9WTS5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVk0uaAppbmRleCBmMzQwZTk2 Li4wY2I2MmMzIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9WTS5o CisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZNLmgKQEAgLTMwMSw4ICszMDEs NiBAQCBwdWJsaWM6CiAgICAgLy8gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTE2MDQ0MQogICAgIEV4ZWNTdGF0ZSogdG9wQ2FsbEZyYW1lOwogICAgIEpTV2ViQXNzZW1i bHlJbnN0YW5jZSogdG9wSlNXZWJBc3NlbWJseUluc3RhbmNlOwotICAgIHZvaWQqIHRvcFdhc21N ZW1vcnlQb2ludGVyOwotICAgIHVpbnQzMl90IHRvcFdhc21NZW1vcnlTaXplOwogICAgIFN0cm9u ZzxTdHJ1Y3R1cmU+IHN0cnVjdHVyZVN0cnVjdHVyZTsKICAgICBTdHJvbmc8U3RydWN0dXJlPiBz dHJ1Y3R1cmVSYXJlRGF0YVN0cnVjdHVyZTsKICAgICBTdHJvbmc8U3RydWN0dXJlPiB0ZXJtaW5h dGVkRXhlY3V0aW9uRXJyb3JTdHJ1Y3R1cmU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9XYXNtQjNJUkdlbmVyYXRvci5jcHAKaW5kZXggMjJjNmU4NS4uZTE2NWEyNiAxMDA2NDQK LS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuY3BwCisr KyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcApAQCAt MTU1LDcgKzE1NSw3IEBAIHB1YmxpYzoKICAgICAgICAgICAgIHJldHVybiBmYWlsKF9fVkFfQVJH U19fKTsgICAgICAgICAgICAgXAogICAgIH0gd2hpbGUgKDApCiAKLSAgICBCM0lSR2VuZXJhdG9y KFZNJiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mLCBQcm9jZWR1cmUmLCBXYXNtSW50ZXJuYWxG dW5jdGlvbiosIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYsIGNvbnN0IEltbXV0YWJs ZUZ1bmN0aW9uSW5kZXhTcGFjZSYpOworICAgIEIzSVJHZW5lcmF0b3IoVk0mLCBjb25zdCBNb2R1 bGVJbmZvcm1hdGlvbiYsIFByb2NlZHVyZSYsIFdhc21JbnRlcm5hbEZ1bmN0aW9uKiwgVmVjdG9y PFVubGlua2VkV2FzbVRvV2FzbUNhbGw+Jik7CiAKICAgICBQYXJ0aWFsUmVzdWx0IFdBUk5fVU5V U0VEX1JFVFVSTiBhZGRBcmd1bWVudHMoY29uc3QgU2lnbmF0dXJlKik7CiAgICAgUGFydGlhbFJl c3VsdCBXQVJOX1VOVVNFRF9SRVRVUk4gYWRkTG9jYWwoVHlwZSwgdWludDMyX3QpOwpAQCAtMjEz LDcgKzIxMyw2IEBAIHByaXZhdGU6CiAgICAgVmFsdWUqIHplcm9Gb3JUeXBlKFR5cGUpOwogCiAg ICAgVk0mIG1fdm07Ci0gICAgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiBtX2Z1 bmN0aW9uSW5kZXhTcGFjZTsKICAgICBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgbV9pbmZvOwog ICAgIFByb2NlZHVyZSYgbV9wcm9jOwogICAgIEJhc2ljQmxvY2sqIG1fY3VycmVudEJsb2NrOwpA QCAtMjI1LDkgKzIyNCw4IEBAIHByaXZhdGU6CiAgICAgVmFsdWUqIG1faW5zdGFuY2VWYWx1ZTsK IH07CiAKLUIzSVJHZW5lcmF0b3I6OkIzSVJHZW5lcmF0b3IoVk0mIHZtLCBjb25zdCBNb2R1bGVJ bmZvcm1hdGlvbiYgaW5mbywgUHJvY2VkdXJlJiBwcm9jZWR1cmUsIFdhc21JbnRlcm5hbEZ1bmN0 aW9uKiBjb21waWxhdGlvbiwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+JiB1bmxpbmtl ZFdhc21Ub1dhc21DYWxscywgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiBmdW5j dGlvbkluZGV4U3BhY2UpCitCM0lSR2VuZXJhdG9yOjpCM0lSR2VuZXJhdG9yKFZNJiB2bSwgY29u c3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFByb2NlZHVyZSYgcHJvY2VkdXJlLCBXYXNtSW50 ZXJuYWxGdW5jdGlvbiogY29tcGlsYXRpb24sIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxs PiYgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMpCiAgICAgOiBtX3ZtKHZtKQotICAgICwgbV9mdW5j dGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleFNwYWNlKQogICAgICwgbV9pbmZvKGluZm8pCiAg ICAgLCBtX3Byb2MocHJvY2VkdXJlKQogICAgICwgbV91bmxpbmtlZFdhc21Ub1dhc21DYWxscyh1 bmxpbmtlZFdhc21Ub1dhc21DYWxscykKQEAgLTI2OSw2ICsyNjcsNDEgQEAgQjNJUkdlbmVyYXRv cjo6QjNJUkdlbmVyYXRvcihWTSYgdm0sIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBpbmZvLCBQ cm9jZWR1cmUmIHAKICAgICAgICAgbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxDb25zdFB0clZh bHVlPihtX3Byb2MsIE9yaWdpbigpLCAmbV92bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UpKTsK IH0KIAorc3RhdGljIHZvaWQgcmVzdG9yZVdlYkFzc2VtYmx5R2xvYmFsU3RhdGUoVk0mIHZtLCBj b25zdCBNZW1vcnlJbmZvcm1hdGlvbiYgbWVtb3J5LCBWYWx1ZSogaW5zdGFuY2UsIFByb2NlZHVy ZSYgcHJvYywgQmFzaWNCbG9jayogYmxvY2spCit7CisgICAgYmxvY2stPmFwcGVuZE5ldzxNZW1v cnlWYWx1ZT4ocHJvYywgU3RvcmUsIE9yaWdpbigpLCBpbnN0YW5jZSwgYmxvY2stPmFwcGVuZE5l dzxDb25zdFB0clZhbHVlPihwcm9jLCBPcmlnaW4oKSwgJnZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0 YW5jZSkpOworCisgICAgaWYgKCEhbWVtb3J5KSB7CisgICAgICAgIFZhbHVlKiBtZW1vcnlPYmpl Y3QgPSBibG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihwcm9jLCBMb2FkLCBwb2ludGVyVHlw ZSgpLCBPcmlnaW4oKSwgaW5zdGFuY2UsIEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZN ZW1vcnkoKSk7CisKKyAgICAgICAgc3RhdGljX2Fzc2VydChzaXplb2YoZGVjbHR5cGUodm0udG9w SlNXZWJBc3NlbWJseUluc3RhbmNlLT5tZW1vcnkoKS0+bWVtb3J5KCktPm1lbW9yeSgpKSkgPT0g c2l6ZW9mKHZvaWQqKSwgImNvZGVnZW4gcmVsaWVzIG9uIHRoaXMgc2l6ZSIpOworICAgICAgICBz dGF0aWNfYXNzZXJ0KHNpemVvZihkZWNsdHlwZSh2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2Ut Pm1lbW9yeSgpLT5tZW1vcnkoKS0+c2l6ZSgpKSkgPT0gc2l6ZW9mKHVpbnQzMl90KSwgImNvZGVn ZW4gcmVsaWVzIG9uIHRoaXMgc2l6ZSIpOworICAgICAgICBWYWx1ZSogYmFzZU1lbW9yeSA9IGJs b2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KHByb2MsIExvYWQsIHBvaW50ZXJUeXBlKCksIE9y aWdpbigpLCBtZW1vcnlPYmplY3QsIEpTV2ViQXNzZW1ibHlNZW1vcnk6Om9mZnNldE9mTWVtb3J5 KCkpOworICAgICAgICBWYWx1ZSogbWVtb3J5U2l6ZSA9IGJsb2NrLT5hcHBlbmROZXc8TWVtb3J5 VmFsdWU+KHByb2MsIExvYWQsIEludDMyLCBPcmlnaW4oKSwgbWVtb3J5T2JqZWN0LCBKU1dlYkFz c2VtYmx5TWVtb3J5OjpvZmZzZXRPZlNpemUoKSk7CisKKyAgICAgICAgVmVjdG9yPFZhbHVlKj4g YXJndW1lbnRzOworICAgICAgICBhcmd1bWVudHMucmVzZXJ2ZUNhcGFjaXR5KDEgKyBtZW1vcnku cGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVycy5zaXplKCkpOworICAgICAgICBhcmd1bWVu dHMuYXBwZW5kKGJhc2VNZW1vcnkpOworICAgICAgICBmb3IgKGF1dG8gaW5mbyA6IG1lbW9yeS5w aW5uZWRSZWdpc3RlcnMoKS5zaXplUmVnaXN0ZXJzKSB7CisgICAgICAgICAgICBWYWx1ZSogc2l6 ZVZhbHVlID0gYmxvY2stPmFwcGVuZE5ldzxWYWx1ZT4ocHJvYywgU3ViLCBPcmlnaW4oKSwgbWVt b3J5U2l6ZSwgYmxvY2stPmFwcGVuZE5ldzxDb25zdDMyVmFsdWU+KHByb2MsIE9yaWdpbigpLCBp bmZvLnNpemVPZmZzZXQpKTsKKyAgICAgICAgICAgIGFyZ3VtZW50cy5hcHBlbmQoc2l6ZVZhbHVl KTsKKyAgICAgICAgfQorCisgICAgICAgIEIzOjpQYXRjaHBvaW50VmFsdWUqIHBhdGNocG9pbnQg PSBibG9jay0+YXBwZW5kTmV3PEIzOjpQYXRjaHBvaW50VmFsdWU+KHByb2MsIEIzOjpWb2lkLCBP cmlnaW4oKSk7CisgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMgPSBFZmZlY3RzOjpub25lKCk7 CisgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKKyAgICAg ICAgcGF0Y2hwb2ludC0+YXBwZW5kVmVjdG9yV2l0aFJlcChhcmd1bWVudHMsIFZhbHVlUmVwOjpT b21lUmVnaXN0ZXIpOworCisgICAgICAgIHBhdGNocG9pbnQtPnNldEdlbmVyYXRvcihbbWVtb3J5 XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMm IHBhcmFtcykgeworICAgICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFs bG93U2NyYXRjaChqaXQpOworCisgICAgICAgICAgICBqaXQubW92ZShwYXJhbXNbMF0uZ3ByKCks IG1lbW9yeS5waW5uZWRSZWdpc3RlcnMoKS5iYXNlTWVtb3J5UG9pbnRlcik7CisgICAgICAgICAg ICBmb3IgKHVpbnQzMl90IGkgPSAwOyBpIDwgbWVtb3J5LnBpbm5lZFJlZ2lzdGVycygpLnNpemVS ZWdpc3RlcnMuc2l6ZSgpOyArK2kpCisgICAgICAgICAgICAgICAgaml0Lm1vdmUocGFyYW1zWzEg KyBpXS5ncHIoKSwgbWVtb3J5LnBpbm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnNbaV0uc2l6 ZVJlZ2lzdGVyKTsKKyAgICAgICAgfSk7CisgICAgfQorfQorCiB2b2lkIEIzSVJHZW5lcmF0b3I6 OmVtaXRFeGNlcHRpb25DaGVjayhDQ2FsbEhlbHBlcnMmIGppdCwgRXhjZXB0aW9uVHlwZSB0eXBl KQogewogICAgIGppdC5tb3ZlKENDYWxsSGVscGVyczo6VHJ1c3RlZEltbTMyKHN0YXRpY19jYXN0 PHVpbnQzMl90Pih0eXBlKSksIEdQUkluZm86OmFyZ3VtZW50R1BSMSk7CkBAIC02OTIsMjMgKzcy NSw3OSBAQCBhdXRvIEIzSVJHZW5lcmF0b3I6OmFkZENhbGwodWludDMyX3QgZnVuY3Rpb25JbmRl eCwgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUsCiAgICAgQVNTRVJUKHNpZ25hdHVyZS0+YXJn dW1lbnRDb3VudCgpID09IGFyZ3Muc2l6ZSgpKTsKIAogICAgIFR5cGUgcmV0dXJuVHlwZSA9IHNp Z25hdHVyZS0+cmV0dXJuVHlwZSgpOworICAgIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxs PiogdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMgPSAmbV91bmxpbmtlZFdhc21Ub1dhc21DYWxsczsK IAotICAgIHJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigpLnNldHVwQ2FsbChtX3Byb2Ms IG1fY3VycmVudEJsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0dXJuVHlwZSksCi0g ICAgICAgIFsmXSAoUGF0Y2hwb2ludFZhbHVlKiBwYXRjaHBvaW50KSB7Ci0gICAgICAgICAgICBw YXRjaHBvaW50LT5lZmZlY3RzLndyaXRlc1Bpbm5lZCA9IHRydWU7Ci0gICAgICAgICAgICBwYXRj aHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICBpZiAobV9pbmZvLmlzSW1w b3J0ZWRGdW5jdGlvbkZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleCkpIHsKKyAg ICAgICAgLy8gRklYTUUgaW1wb3J0cyBjYW4gYmUgbGlua2VkIGhlcmUsIGluc3RlYWQgb2YgZ2Vu ZXJhdGluZyBhIHBhdGNocG9pbnQsIGJlY2F1c2UgYWxsIGltcG9ydCBzdHVicyBhcmUgZ2VuZXJh dGVkIGJlZm9yZSBCMyBjb21waWxhdGlvbiBzdGFydHMuIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0xNjY0NjIKKyAgICAgICAgRXhwcmVzc2lvblR5cGUgZnVuY3Rpb25J bXBvcnQgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExv YWQsIHBvaW50ZXJUeXBlKCksIE9yaWdpbigpLCBtX2luc3RhbmNlVmFsdWUsIEpTV2ViQXNzZW1i bHlJbnN0YW5jZTo6b2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbihmdW5jdGlvbkluZGV4KSk7CisgICAg ICAgIEV4cHJlc3Npb25UeXBlIGpzVHlwZU9mSW1wb3J0ID0gbV9jdXJyZW50QmxvY2stPmFwcGVu ZE5ldzxNZW1vcnlWYWx1ZT4obV9wcm9jLCBMb2FkOFosIE9yaWdpbigpLCBmdW5jdGlvbkltcG9y dCwgSlNDZWxsOjp0eXBlSW5mb1R5cGVPZmZzZXQoKSk7CisgICAgICAgIFZhbHVlKiBpc1dhc21D YWxsID0gbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxWYWx1ZT4obV9wcm9jLCBFcXVhbCwgT3Jp Z2luKCksIGpzVHlwZU9mSW1wb3J0LCBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PENvbnN0MzJW YWx1ZT4obV9wcm9jLCBPcmlnaW4oKSwgV2ViQXNzZW1ibHlGdW5jdGlvblR5cGUpKTsKIAotICAg ICAgICAgICAgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+KiB1bmxpbmtlZFdhc21Ub1dh c21DYWxscyA9ICZtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzOwotICAgICAgICAgICAgcGF0Y2hw b2ludC0+c2V0R2VuZXJhdG9yKFt1bmxpbmtlZFdhc21Ub1dhc21DYWxscywgZnVuY3Rpb25JbmRl eF0gKENDYWxsSGVscGVycyYgaml0LCBjb25zdCBCMzo6U3RhY2ttYXBHZW5lcmF0aW9uUGFyYW1z JikgewotICAgICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxv d1NjcmF0Y2goaml0KTsKKyAgICAgICAgQmFzaWNCbG9jayogaXNXYXNtQmxvY2sgPSBtX3Byb2Mu YWRkQmxvY2soKTsKKyAgICAgICAgQmFzaWNCbG9jayogaXNKU0Jsb2NrID0gbV9wcm9jLmFkZEJs b2NrKCk7CisgICAgICAgIEJhc2ljQmxvY2sqIGNvbnRpbnVhdGlvbiA9IG1fcHJvYy5hZGRCbG9j aygpOworICAgICAgICBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3Q29udHJvbFZhbHVlKG1fcHJv YywgQjM6OkJyYW5jaCwgT3JpZ2luKCksIGlzV2FzbUNhbGwsIEZyZXF1ZW50ZWRCbG9jayhpc1dh c21CbG9jayksIEZyZXF1ZW50ZWRCbG9jayhpc0pTQmxvY2spKTsKKworICAgICAgICBWYWx1ZSog d2FzbUNhbGxSZXN1bHQgPSB3YXNtQ2FsbGluZ0NvbnZlbnRpb24oKS5zZXR1cENhbGwobV9wcm9j LCBpc1dhc21CbG9jaywgT3JpZ2luKCksIGFyZ3MsIHRvQjNUeXBlKHJldHVyblR5cGUpLAorICAg ICAgICAgICAgWyZdIChQYXRjaHBvaW50VmFsdWUqIHBhdGNocG9pbnQpIHsKKyAgICAgICAgICAg ICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLndyaXRlc1Bpbm5lZCA9IHRydWU7CisgICAgICAgICAg ICAgICAgcGF0Y2hwb2ludC0+ZWZmZWN0cy5yZWFkc1Bpbm5lZCA9IHRydWU7CisgICAgICAgICAg ICAgICAgcGF0Y2hwb2ludC0+c2V0R2VuZXJhdG9yKFt1bmxpbmtlZFdhc21Ub1dhc21DYWxscywg ZnVuY3Rpb25JbmRleF0gKENDYWxsSGVscGVycyYgaml0LCBjb25zdCBCMzo6U3RhY2ttYXBHZW5l cmF0aW9uUGFyYW1zJikgeworICAgICAgICAgICAgICAgICAgICBBbGxvd01hY3JvU2NyYXRjaFJl Z2lzdGVyVXNhZ2UgYWxsb3dTY3JhdGNoKGppdCk7CisgICAgICAgICAgICAgICAgICAgIENDYWxs SGVscGVyczo6Q2FsbCBjYWxsID0gaml0LmNhbGwoKTsKKyAgICAgICAgICAgICAgICAgICAgaml0 LmFkZExpbmtUYXNrKFt1bmxpbmtlZFdhc21Ub1dhc21DYWxscywgY2FsbCwgZnVuY3Rpb25JbmRl eF0gKExpbmtCdWZmZXImIGxpbmtCdWZmZXIpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGJv b2wgdG9KUyA9IGZhbHNlOyAvLyBNYXliZSBleHRlcm5hbCB3YXNtIC0+IHdhc20uCisgICAgICAg ICAgICAgICAgICAgICAgICB1bmxpbmtlZFdhc21Ub1dhc21DYWxscy0+YXBwZW5kKHsgbGlua0J1 ZmZlci5sb2NhdGlvbk9mKGNhbGwpLCBmdW5jdGlvbkluZGV4LCB0b0pTIH0pOworICAgICAgICAg ICAgICAgICAgICB9KTsKKyAgICAgICAgICAgICAgICB9KTsKKyAgICAgICAgICAgIH0pOworICAg ICAgICBVcHNpbG9uVmFsdWUqIHdhc21DYWxsUmVzdWx0VXBzaWxvbiA9IHJldHVyblR5cGUgPT0g Vm9pZCA/IG51bGxwdHIgOiBpc1dhc21CbG9jay0+YXBwZW5kTmV3PFVwc2lsb25WYWx1ZT4obV9w cm9jLCBPcmlnaW4oKSwgd2FzbUNhbGxSZXN1bHQpOworICAgICAgICBpc1dhc21CbG9jay0+YXBw ZW5kTmV3Q29udHJvbFZhbHVlKG1fcHJvYywgSnVtcCwgT3JpZ2luKCksIGNvbnRpbnVhdGlvbik7 CisKKyAgICAgICAgVmFsdWUqIGpzQ2FsbFJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigp LnNldHVwQ2FsbChtX3Byb2MsIGlzSlNCbG9jaywgT3JpZ2luKCksIGFyZ3MsIHRvQjNUeXBlKHJl dHVyblR5cGUpLAorICAgICAgICAgICAgWyZdIChQYXRjaHBvaW50VmFsdWUqIHBhdGNocG9pbnQp IHsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLndyaXRlc1Bpbm5lZCA9IHRy dWU7CisgICAgICAgICAgICAgICAgcGF0Y2hwb2ludC0+ZWZmZWN0cy5yZWFkc1Bpbm5lZCA9IHRy dWU7CisgICAgICAgICAgICAgICAgcGF0Y2hwb2ludC0+c2V0R2VuZXJhdG9yKFt1bmxpbmtlZFdh c21Ub1dhc21DYWxscywgZnVuY3Rpb25JbmRleF0gKENDYWxsSGVscGVycyYgaml0LCBjb25zdCBC Mzo6U3RhY2ttYXBHZW5lcmF0aW9uUGFyYW1zJikgeworICAgICAgICAgICAgICAgICAgICBBbGxv d01hY3JvU2NyYXRjaFJlZ2lzdGVyVXNhZ2UgYWxsb3dTY3JhdGNoKGppdCk7CisgICAgICAgICAg ICAgICAgICAgIENDYWxsSGVscGVyczo6Q2FsbCBjYWxsID0gaml0LmNhbGwoKTsKKyAgICAgICAg ICAgICAgICAgICAgaml0LmFkZExpbmtUYXNrKFt1bmxpbmtlZFdhc21Ub1dhc21DYWxscywgY2Fs bCwgZnVuY3Rpb25JbmRleF0gKExpbmtCdWZmZXImIGxpbmtCdWZmZXIpIHsKKyAgICAgICAgICAg ICAgICAgICAgICAgIGJvb2wgdG9KUyA9IHRydWU7IC8vIEV4dGVybmFsIHdhc20gLT4gSlMuCisg ICAgICAgICAgICAgICAgICAgICAgICB1bmxpbmtlZFdhc21Ub1dhc21DYWxscy0+YXBwZW5kKHsg bGlua0J1ZmZlci5sb2NhdGlvbk9mKGNhbGwpLCBmdW5jdGlvbkluZGV4LCB0b0pTIH0pOworICAg ICAgICAgICAgICAgICAgICB9KTsKKyAgICAgICAgICAgICAgICB9KTsKKyAgICAgICAgICAgIH0p OworICAgICAgICBVcHNpbG9uVmFsdWUqIGpzQ2FsbFJlc3VsdFVwc2lsb24gPSByZXR1cm5UeXBl ID09IFZvaWQgPyBudWxscHRyIDogaXNKU0Jsb2NrLT5hcHBlbmROZXc8VXBzaWxvblZhbHVlPiht X3Byb2MsIE9yaWdpbigpLCBqc0NhbGxSZXN1bHQpOworICAgICAgICBpc0pTQmxvY2stPmFwcGVu ZE5ld0NvbnRyb2xWYWx1ZShtX3Byb2MsIEp1bXAsIE9yaWdpbigpLCBjb250aW51YXRpb24pOwog Ci0gICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOwor ICAgICAgICBtX2N1cnJlbnRCbG9jayA9IGNvbnRpbnVhdGlvbjsKKworICAgICAgICBpZiAocmV0 dXJuVHlwZSA9PSBWb2lkKQorICAgICAgICAgICAgcmVzdWx0ID0gbnVsbHB0cjsKKyAgICAgICAg ZWxzZSB7CisgICAgICAgICAgICByZXN1bHQgPSBjb250aW51YXRpb24tPmFwcGVuZE5ldzxWYWx1 ZT4obV9wcm9jLCBQaGksIHRvQjNUeXBlKHJldHVyblR5cGUpLCBPcmlnaW4oKSk7CisgICAgICAg ICAgICB3YXNtQ2FsbFJlc3VsdFVwc2lsb24tPnNldFBoaShyZXN1bHQpOworICAgICAgICAgICAg anNDYWxsUmVzdWx0VXBzaWxvbi0+c2V0UGhpKHJlc3VsdCk7CisgICAgICAgIH0KIAotICAgICAg ICAgICAgICAgIGppdC5hZGRMaW5rVGFzayhbdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGNhbGws IGZ1bmN0aW9uSW5kZXhdIChMaW5rQnVmZmVyJiBsaW5rQnVmZmVyKSB7Ci0gICAgICAgICAgICAg ICAgICAgIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLT5hcHBlbmQoeyBsaW5rQnVmZmVyLmxvY2F0 aW9uT2YoY2FsbCksIGZ1bmN0aW9uSW5kZXggfSk7CisgICAgICAgIC8vIFRoZSBjYWxsIGNvdWxk IGhhdmUgYmVlbiB0byBhbm90aGVyIFdlYkFzc2VtYmx5IGluc3RhbmNlLCBhbmQgLyBvciBjb3Vs ZCBoYXZlIG1vZGlmaWVkIG91ciBNZW1vcnkuCisgICAgICAgIHJlc3RvcmVXZWJBc3NlbWJseUds b2JhbFN0YXRlKG1fdm0sIG1faW5mby5tZW1vcnksIG1faW5zdGFuY2VWYWx1ZSwgbV9wcm9jLCBj b250aW51YXRpb24pOworICAgIH0gZWxzZSB7CisgICAgICAgIHJlc3VsdCA9IHdhc21DYWxsaW5n Q29udmVudGlvbigpLnNldHVwQ2FsbChtX3Byb2MsIG1fY3VycmVudEJsb2NrLCBPcmlnaW4oKSwg YXJncywgdG9CM1R5cGUocmV0dXJuVHlwZSksCisgICAgICAgICAgICBbJl0gKFBhdGNocG9pbnRW YWx1ZSogcGF0Y2hwb2ludCkgeworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMu d3JpdGVzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3Rz LnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5l cmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxw ZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7CisgICAgICAg ICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2go aml0KTsKKyAgICAgICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQu Y2FsbCgpOworICAgICAgICAgICAgICAgICAgICBqaXQuYWRkTGlua1Rhc2soW3VubGlua2VkV2Fz bVRvV2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZl cikgeworICAgICAgICAgICAgICAgICAgICAgICAgYm9vbCB0b0pTID0gZmFsc2U7IC8vIEludGVy bmFsIHdhc20gLT4gd2FzbS4KKyAgICAgICAgICAgICAgICAgICAgICAgIHVubGlua2VkV2FzbVRv V2FzbUNhbGxzLT5hcHBlbmQoeyBsaW5rQnVmZmVyLmxvY2F0aW9uT2YoY2FsbCksIGZ1bmN0aW9u SW5kZXgsIHRvSlMgfSk7CisgICAgICAgICAgICAgICAgICAgIH0pOwogICAgICAgICAgICAgICAg IH0pOwogICAgICAgICAgICAgfSk7Ci0gICAgICAgIH0pOworICAgIH0KKwogICAgIHJldHVybiB7 IH07CiB9CiAKQEAgLTc4NSw2ICs4NzQsOSBAQCBhdXRvIEIzSVJHZW5lcmF0b3I6OmFkZENhbGxJ bmRpcmVjdChjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSwgU2lnbmF0dXJlSW5kZXggcwogICAg ICAgICAgICAgfSk7CiAgICAgICAgIH0pOwogCisgICAgLy8gVGhlIGNhbGwgY291bGQgaGF2ZSBi ZWVuIHRvIGFub3RoZXIgV2ViQXNzZW1ibHkgaW5zdGFuY2UsIGFuZCAvIG9yIGNvdWxkIGhhdmUg bW9kaWZpZWQgb3VyIE1lbW9yeS4KKyAgICByZXN0b3JlV2ViQXNzZW1ibHlHbG9iYWxTdGF0ZSht X3ZtLCBtX2luZm8ubWVtb3J5LCBtX2luc3RhbmNlVmFsdWUsIG1fcHJvYywgbV9jdXJyZW50Qmxv Y2spOworCiAgICAgcmV0dXJuIHsgfTsKIH0KIApAQCAtODU0LDIwICs5NDYsMTAgQEAgc3RhdGlj IHZvaWQgY3JlYXRlSlNUb1dhc21XcmFwcGVyKFZNJiB2bSwgQ29tcGlsYXRpb25Db250ZXh0JiBj b21waWxhdGlvbkNvbnRleHQKICAgICAgICAgfSk7CiAgICAgfQogCi0gICAgLy8gTW92ZSBtZW1v cnkgdmFsdWVzIHRvIHRoZSBhcHByb3JpYXRlIHBsYWNlcywgaWYgbmVlZGVkLgotICAgIFZhbHVl KiBiYXNlTWVtb3J5ID0gbnVsbHB0cjsKLSAgICBWZWN0b3I8VmFsdWUqPiBzaXplczsKLSAgICBp ZiAoISFtZW1vcnkpIHsKLSAgICAgICAgYmFzZU1lbW9yeSA9IGJsb2NrLT5hcHBlbmROZXc8TWVt b3J5VmFsdWU+KHByb2MsIExvYWQsIEludDY0LCBPcmlnaW4oKSwKLSAgICAgICAgICAgIGJsb2Nr LT5hcHBlbmROZXc8Q29uc3RQdHJWYWx1ZT4ocHJvYywgT3JpZ2luKCksICZ2bS50b3BXYXNtTWVt b3J5UG9pbnRlcikpOwotICAgICAgICBWYWx1ZSogc2l6ZSA9IGJsb2NrLT5hcHBlbmROZXc8TWVt b3J5VmFsdWU+KHByb2MsIExvYWQsIEludDMyLCBPcmlnaW4oKSwKLSAgICAgICAgICAgIGJsb2Nr LT5hcHBlbmROZXc8Q29uc3RQdHJWYWx1ZT4ocHJvYywgT3JpZ2luKCksICZ2bS50b3BXYXNtTWVt b3J5U2l6ZSkpOwotICAgICAgICBzaXplcy5yZXNlcnZlQ2FwYWNpdHkobWVtb3J5LnBpbm5lZFJl Z2lzdGVycygpLnNpemVSZWdpc3RlcnMuc2l6ZSgpKTsKLSAgICAgICAgZm9yIChhdXRvIGluZm8g OiBtZW1vcnkucGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVycykgewotICAgICAgICAgICAg c2l6ZXMuYXBwZW5kKGJsb2NrLT5hcHBlbmROZXc8VmFsdWU+KHByb2MsIFN1Yiwgb3JpZ2luLCBz aXplLAotICAgICAgICAgICAgICAgIGJsb2NrLT5hcHBlbmROZXc8Q29uc3QzMlZhbHVlPihwcm9j LCBvcmlnaW4sIGluZm8uc2l6ZU9mZnNldCkpKTsKLSAgICAgICAgfQotICAgIH0KKyAgICAvLyBG SVhNRSBUaGUgaW5zdGFuY2UgaXMgY3VycmVudGx5IHNldCBieSB0aGUgQysrIGNvZGUgaW4gV2Vi QXNzZW1ibHlGdW5jdGlvbjo6Y2FsbC4gV2Ugc2hvdWxkbid0IGdvIHRocm91Z2ggdGhlIGV4dHJh IEMrKyBob29wLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY2NDg2 CisgICAgVmFsdWUqIGluc3RhbmNlID0gYmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4ocHJv YywgTG9hZCwgcG9pbnRlclR5cGUoKSwgT3JpZ2luKCksCisgICAgICAgIGJsb2NrLT5hcHBlbmRO ZXc8Q29uc3RQdHJWYWx1ZT4ocHJvYywgT3JpZ2luKCksICZ2bS50b3BKU1dlYkFzc2VtYmx5SW5z dGFuY2UpKTsKKyAgICByZXN0b3JlV2ViQXNzZW1ibHlHbG9iYWxTdGF0ZSh2bSwgbWVtb3J5LCBp bnN0YW5jZSwgcHJvYywgYmxvY2spOwogCiAgICAgLy8gR2V0IG91ciBhcmd1bWVudHMuCiAgICAg VmVjdG9yPFZhbHVlKj4gYXJndW1lbnRzOwpAQCAtODc3LDEzICs5NTksNiBAQCBzdGF0aWMgdm9p ZCBjcmVhdGVKU1RvV2FzbVdyYXBwZXIoVk0mIHZtLCBDb21waWxhdGlvbkNvbnRleHQmIGNvbXBp bGF0aW9uQ29udGV4dAogCiAgICAgLy8gTW92ZSB0aGUgYXJndW1lbnRzIGludG8gcGxhY2UuCiAg ICAgVmFsdWUqIHJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigpLnNldHVwQ2FsbChwcm9j LCBibG9jaywgb3JpZ2luLCBhcmd1bWVudHMsIHRvQjNUeXBlKHNpZ25hdHVyZS0+cmV0dXJuVHlw ZSgpKSwgWyZdIChQYXRjaHBvaW50VmFsdWUqIHBhdGNocG9pbnQpIHsKLSAgICAgICAgaWYgKCEh bWVtb3J5KSB7Ci0gICAgICAgICAgICBBU1NFUlQoc2l6ZXMuc2l6ZSgpID09IG1lbW9yeS5waW5u ZWRSZWdpc3RlcnMoKS5zaXplUmVnaXN0ZXJzLnNpemUoKSk7Ci0gICAgICAgICAgICBwYXRjaHBv aW50LT5hcHBlbmQoQ29uc3RyYWluZWRWYWx1ZShiYXNlTWVtb3J5LCBWYWx1ZVJlcDo6cmVnKG1l bW9yeS5waW5uZWRSZWdpc3RlcnMoKS5iYXNlTWVtb3J5UG9pbnRlcikpKTsKLSAgICAgICAgICAg IGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBzaXplcy5zaXplKCk7ICsraSkKLSAgICAgICAgICAg ICAgICBwYXRjaHBvaW50LT5hcHBlbmQoQ29uc3RyYWluZWRWYWx1ZShzaXplc1tpXSwgVmFsdWVS ZXA6OnJlZyhtZW1vcnkucGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVyc1tpXS5zaXplUmVn aXN0ZXIpKSk7Ci0gICAgICAgIH0KLQogICAgICAgICBDb21waWxhdGlvbkNvbnRleHQqIGNvbnRl eHQgPSAmY29tcGlsYXRpb25Db250ZXh0OwogICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0 b3IoW2NvbnRleHRdIChDQ2FsbEhlbHBlcnMmIGppdCwgY29uc3QgQjM6OlN0YWNrbWFwR2VuZXJh dGlvblBhcmFtcyYpIHsKICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2Fn ZSBhbGxvd1NjcmF0Y2goaml0KTsKQEAgLTkxNyw3ICs5OTIsNyBAQCBzdGF0aWMgdm9pZCBjcmVh dGVKU1RvV2FzbVdyYXBwZXIoVk0mIHZtLCBDb21waWxhdGlvbkNvbnRleHQmIGNvbXBpbGF0aW9u Q29udGV4dAogICAgIGZ1bmN0aW9uLmpzVG9XYXNtRW50cnlwb2ludC5jYWxsZWVTYXZlUmVnaXN0 ZXJzID0gcHJvYy5jYWxsZWVTYXZlUmVnaXN0ZXJzKCk7CiB9CiAKLUV4cGVjdGVkPHN0ZDo6dW5p cXVlX3B0cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0cmluZz4gcGFyc2VBbmRDb21waWxlKFZN JiB2bSwgQ29tcGlsYXRpb25Db250ZXh0JiBjb21waWxhdGlvbkNvbnRleHQsIGNvbnN0IHVpbnQ4 X3QqIGZ1bmN0aW9uU3RhcnQsIHNpemVfdCBmdW5jdGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0dXJl KiBzaWduYXR1cmUsIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYgdW5saW5rZWRXYXNt VG9XYXNtQ2FsbHMsIGNvbnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYgZnVuY3Rpb25J bmRleFNwYWNlLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgdW5zaWduZWQgb3B0TGV2 ZWwpCitFeHBlY3RlZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbUludGVybmFsRnVuY3Rpb24+LCBTdHJp bmc+IHBhcnNlQW5kQ29tcGlsZShWTSYgdm0sIENvbXBpbGF0aW9uQ29udGV4dCYgY29tcGlsYXRp b25Db250ZXh0LCBjb25zdCB1aW50OF90KiBmdW5jdGlvblN0YXJ0LCBzaXplX3QgZnVuY3Rpb25M ZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9X YXNtQ2FsbD4mIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlv biYgaW5mbywgdW5zaWduZWQgb3B0TGV2ZWwpCiB7CiAgICAgYXV0byByZXN1bHQgPSBzdGQ6Om1h a2VfdW5pcXVlPFdhc21JbnRlcm5hbEZ1bmN0aW9uPigpOwogCkBAIC05MjUsOCArMTAwMCw4IEBA IEV4cGVjdGVkPHN0ZDo6dW5pcXVlX3B0cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0cmluZz4g cGFyc2VBbmRDb21waWxlKFZNJiB2bSwKICAgICBjb21waWxhdGlvbkNvbnRleHQud2FzbUVudHJ5 cG9pbnRKSVQgPSBzdGQ6Om1ha2VfdW5pcXVlPENDYWxsSGVscGVycz4oJnZtKTsKIAogICAgIFBy b2NlZHVyZSBwcm9jZWR1cmU7Ci0gICAgQjNJUkdlbmVyYXRvciBjb250ZXh0KHZtLCBpbmZvLCBw cm9jZWR1cmUsIHJlc3VsdC5nZXQoKSwgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGZ1bmN0aW9u SW5kZXhTcGFjZSk7Ci0gICAgRnVuY3Rpb25QYXJzZXI8QjNJUkdlbmVyYXRvcj4gcGFyc2VyKCZ2 bSwgY29udGV4dCwgZnVuY3Rpb25TdGFydCwgZnVuY3Rpb25MZW5ndGgsIHNpZ25hdHVyZSwgZnVu Y3Rpb25JbmRleFNwYWNlLCBpbmZvKTsKKyAgICBCM0lSR2VuZXJhdG9yIGNvbnRleHQodm0sIGlu Zm8sIHByb2NlZHVyZSwgcmVzdWx0LmdldCgpLCB1bmxpbmtlZFdhc21Ub1dhc21DYWxscyk7Cisg ICAgRnVuY3Rpb25QYXJzZXI8QjNJUkdlbmVyYXRvcj4gcGFyc2VyKCZ2bSwgY29udGV4dCwgZnVu Y3Rpb25TdGFydCwgZnVuY3Rpb25MZW5ndGgsIHNpZ25hdHVyZSwgaW5mbyk7CiAgICAgV0FTTV9G QUlMX0lGX0hFTFBFUl9GQUlMUyhwYXJzZXIucGFyc2UoKSk7CiAKICAgICBwcm9jZWR1cmUucmVz ZXRSZWFjaGFiaWxpdHkoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21CM0lSR2VuZXJhdG9yLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQjNJ UkdlbmVyYXRvci5oCmluZGV4IGI1YzlmNDYuLmQ4OTc1ODUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmgKKysrIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuaApAQCAtNDcsNyArNDcsNyBAQCBzdHJ1 Y3QgQ29tcGlsYXRpb25Db250ZXh0IHsKICAgICBDQ2FsbEhlbHBlcnM6OkNhbGwganNFbnRyeXBv aW50VG9XYXNtRW50cnlwb2ludENhbGw7CiB9OwogCi1FeHBlY3RlZDxzdGQ6OnVuaXF1ZV9wdHI8 V2FzbUludGVybmFsRnVuY3Rpb24+LCBTdHJpbmc+IHBhcnNlQW5kQ29tcGlsZShWTSYsIENvbXBp bGF0aW9uQ29udGV4dCYsIGNvbnN0IHVpbnQ4X3QqLCBzaXplX3QsIGNvbnN0IFNpZ25hdHVyZSos IFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYsIGNvbnN0IEltbXV0YWJsZUZ1bmN0aW9u SW5kZXhTcGFjZSYsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiwgdW5zaWduZWQgb3B0TGV2ZWwg PSAxKTsKK0V4cGVjdGVkPHN0ZDo6dW5pcXVlX3B0cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0 cmluZz4gcGFyc2VBbmRDb21waWxlKFZNJiwgQ29tcGlsYXRpb25Db250ZXh0JiwgY29uc3QgdWlu dDhfdCosIHNpemVfdCwgY29uc3QgU2lnbmF0dXJlKiwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2Fz bUNhbGw+JiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mLCB1bnNpZ25lZCBvcHRMZXZlbCA9IDEp OwogCiB9IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2FzbQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9XYXNtQmluZGluZy5jcHAKaW5kZXggMGU1OTI0Ny4uODkyYmUwNSAxMDA2NDQKLS0tIGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuY3BwCisrKyBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmNwcApAQCAtMzYsNyArMzYsNyBAQAogCiBu YW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIFdhc20gewogCi1XYXNtVG9KU1N0dWIgaW1wb3J0U3R1 YkdlbmVyYXRvcihWTSogdm0sIEJhZzxDYWxsTGlua0luZm8+JiBjYWxsTGlua0luZm9zLCBTaWdu YXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCwgdW5zaWduZWQgaW1wb3J0SW5kZXgpCitzdGF0aWMg TWFjcm9Bc3NlbWJsZXJDb2RlUmVmIHdhc21Ub0pTKFZNKiB2bSwgQmFnPENhbGxMaW5rSW5mbz4m IGNhbGxMaW5rSW5mb3MsIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4LCB1bnNpZ25lZCBp bXBvcnRJbmRleCkKIHsKICAgICBjb25zdCBXYXNtQ2FsbGluZ0NvbnZlbnRpb24mIHdhc21DQyA9 IHdhc21DYWxsaW5nQ29udmVudGlvbigpOwogICAgIGNvbnN0IEpTQ0NhbGxpbmdDb252ZW50aW9u JiBqc0NDID0ganNjQ2FsbGluZ0NvbnZlbnRpb24oKTsKQEAgLTIzMSw3ICsyMzEsNDggQEAgV2Fz bVRvSlNTdHViIGltcG9ydFN0dWJHZW5lcmF0b3IoVk0qIHZtLCBCYWc8Q2FsbExpbmtJbmZvPiYg Y2FsbExpbmtJbmZvcywgU2lnbmEKICAgICBDb2RlTG9jYXRpb25MYWJlbCBob3RQYXRoQmVnaW4o cGF0Y2hCdWZmZXIubG9jYXRpb25PZih0YXJnZXRUb0NoZWNrKSk7CiAgICAgQ29kZUxvY2F0aW9u TmVhckNhbGwgaG90UGF0aE90aGVyID0gcGF0Y2hCdWZmZXIubG9jYXRpb25PZk5lYXJDYWxsKGZh c3RDYWxsKTsKICAgICBjYWxsTGlua0luZm8tPnNldENhbGxMb2NhdGlvbnMoY2FsbFJldHVybkxv Y2F0aW9uLCBob3RQYXRoQmVnaW4sIGhvdFBhdGhPdGhlcik7Ci0gICAgcmV0dXJuIEZJTkFMSVpF X0NPREUocGF0Y2hCdWZmZXIsICgiV2ViQXNzZW1ibHkgaW1wb3J0WyVpXSBzdHViIGZvciBzaWdu YXR1cmUgJWkiLCBpbXBvcnRJbmRleCwgc2lnbmF0dXJlSW5kZXgpKTsKKyAgICBTdHJpbmcgc2ln bmF0dXJlRGVzY3JpcHRpb24gPSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KHZtLCBzaWduYXR1 cmVJbmRleCktPnRvU3RyaW5nKCk7CisgICAgcmV0dXJuIEZJTkFMSVpFX0NPREUocGF0Y2hCdWZm ZXIsICgiV2ViQXNzZW1ibHktPkphdmFTY3JpcHQgaW1wb3J0WyVpXSAlcyIsIGltcG9ydEluZGV4 LCBzaWduYXR1cmVEZXNjcmlwdGlvbi5hc2NpaSgpLmRhdGEoKSkpOworfQorCitzdGF0aWMgTWFj cm9Bc3NlbWJsZXJDb2RlUmVmIHdhc21Ub1dhc20oVk0qIHZtLCBCYWc8Q2FsbExpbmtJbmZvPiYg Y2FsbExpbmtJbmZvcywgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXgsIHVuc2lnbmVkIGlt cG9ydEluZGV4KQoreworICAgIGNvbnN0IFdhc21DYWxsaW5nQ29udmVudGlvbiYgd2FzbUNDID0g d2FzbUNhbGxpbmdDb252ZW50aW9uKCk7CisgICAgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUg PSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KHZtLCBzaWduYXR1cmVJbmRleCk7CisgICAgdW5z aWduZWQgYXJnQ291bnQgPSBzaWduYXR1cmUtPmFyZ3VtZW50Q291bnQoKTsKKyAgICB0eXBlZGVm IEFzc2VtYmx5SGVscGVycyBKSVQ7CisgICAgSklUIGppdCh2bSwgbnVsbHB0cik7CisKKyAgICBq aXQuZW1pdEZ1bmN0aW9uUHJvbG9ndWUoKTsKKyAgICBqaXQuc3RvcmU2NChKSVQ6OlRydXN0ZWRJ bW0zMigwKSwgSklUOjpBZGRyZXNzKEdQUkluZm86OmNhbGxGcmFtZVJlZ2lzdGVyLCBDYWxsRnJh bWVTbG90Ojpjb2RlQmxvY2sgKiBzdGF0aWNfY2FzdDxpbnQ+KHNpemVvZihSZWdpc3RlcikpKSk7 IC8vIEZJWE1FIFN0b3AgdXNpbmcgMCBhcyBjb2RlQmxvY2tzLiBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1MzIxCisgICAgaml0LnN0b3JlUHRyKEpJVDo6VHJ1c3Rl ZEltbVB0cih2bS0+d2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmdldCgpKSwgSklUOjpBZGRyZXNzKEdQ UkluZm86OmNhbGxGcmFtZVJlZ2lzdGVyLCBDYWxsRnJhbWVTbG90OjpjYWxsZWUgKiBzdGF0aWNf Y2FzdDxpbnQ+KHNpemVvZihSZWdpc3RlcikpKSk7CisKKyAgICAvLyBGSVhNRSBwZXJmb3JtIGEg c3RhY2sgY2hlY2sgYmVmb3JlIHVwZGF0aW5nIFNQLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTY1NTQ2CisKKyAgICB1bnNpZ25lZCBudW1iZXJPZlBhcmFtZXRlcnMg PSBhcmdDb3VudCArIDE7IC8vIFRoZXJlIGlzIGEgInRoaXMiIGFyZ3VtZW50LgorICAgIHVuc2ln bmVkIG51bWJlck9mUmVnc0ZvckNhbGwgPSBDYWxsRnJhbWU6OmhlYWRlclNpemVJblJlZ2lzdGVy cyArIG51bWJlck9mUGFyYW1ldGVyczsKKyAgICB1bnNpZ25lZCBudW1iZXJPZkJ5dGVzRm9yQ2Fs bCA9IG51bWJlck9mUmVnc0ZvckNhbGwgKiBzaXplb2YoUmVnaXN0ZXIpIC0gc2l6ZW9mKENhbGxl ckZyYW1lQW5kUEMpOworICAgIGNvbnN0IHVuc2lnbmVkIHN0YWNrT2Zmc2V0ID0gV1RGOjpyb3Vu ZFVwVG9NdWx0aXBsZU9mKHN0YWNrQWxpZ25tZW50Qnl0ZXMoKSwgbnVtYmVyT2ZCeXRlc0ZvckNh bGwpOworICAgIGppdC5zdWJQdHIoTWFjcm9Bc3NlbWJsZXI6OlRydXN0ZWRJbW0zMihzdGFja09m ZnNldCksIE1hY3JvQXNzZW1ibGVyOjpzdGFja1BvaW50ZXJSZWdpc3Rlcik7CisgICAgSklUOjpB ZGRyZXNzIGNhbGxlZUZyYW1lID0gQ0NhbGxIZWxwZXJzOjpBZGRyZXNzKE1hY3JvQXNzZW1ibGVy OjpzdGFja1BvaW50ZXJSZWdpc3RlciwgLXN0YXRpY19jYXN0PHB0cmRpZmZfdD4oc2l6ZW9mKENh bGxlckZyYW1lQW5kUEMpKSk7CisKKyAgICAvLyBGSVhNRSBpbXBsZW1lbnQgdGhpcy4KKyAgICBq aXQuYnJlYWtwb2ludCgpOworCisgICAgaml0LmVtaXRGdW5jdGlvbkVwaWxvZ3VlKCk7CisgICAg aml0LnJldCgpOworCisgICAgTGlua0J1ZmZlciBwYXRjaEJ1ZmZlcigqdm0sIGppdCwgR0xPQkFM X1RIVU5LX0lEKTsKKyAgICBTdHJpbmcgc2lnbmF0dXJlRGVzY3JpcHRpb24gPSBTaWduYXR1cmVJ bmZvcm1hdGlvbjo6Z2V0KHZtLCBzaWduYXR1cmVJbmRleCktPnRvU3RyaW5nKCk7CisgICAgcmV0 dXJuIEZJTkFMSVpFX0NPREUocGF0Y2hCdWZmZXIsICgiV2ViQXNzZW1ibHktPldlYkFzc2VtYmx5 IGltcG9ydFslaV0gJXMiLCBpbXBvcnRJbmRleCwgc2lnbmF0dXJlRGVzY3JpcHRpb24uYXNjaWko KS5kYXRhKCkpKTsKK30KKworV2FzbUV4aXRTdHVicyBleGl0U3R1YkdlbmVyYXRvcihWTSogdm0s IEJhZzxDYWxsTGlua0luZm8+JiBjYWxsTGlua0luZm9zLCBTaWduYXR1cmVJbmRleCBzaWduYXR1 cmVJbmRleCwgdW5zaWduZWQgaW1wb3J0SW5kZXgpCit7CisgICAgV2FzbUV4aXRTdHVicyBzdHVi czsKKyAgICBzdHVicy53YXNtVG9KUyA9IHdhc21Ub0pTKHZtLCBjYWxsTGlua0luZm9zLCBzaWdu YXR1cmVJbmRleCwgaW1wb3J0SW5kZXgpOworICAgIHN0dWJzLndhc21Ub1dhc20gPSB3YXNtVG9X YXNtKHZtLCBjYWxsTGlua0luZm9zLCBzaWduYXR1cmVJbmRleCwgaW1wb3J0SW5kZXgpOworICAg IHJldHVybiBzdHViczsKIH0KIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KZGlmZiAtLWdp dCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmggYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5oCmluZGV4IGZkN2UwM2QuLjQwMjFmMTcgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmgKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuaApAQCAtMzgsNyArMzgsNyBA QCBjbGFzcyBDYWxsTGlua0luZm87CiAKIG5hbWVzcGFjZSBXYXNtIHsKIAotV2FzbVRvSlNTdHVi IGltcG9ydFN0dWJHZW5lcmF0b3IoVk0qLCBCYWc8Q2FsbExpbmtJbmZvPiYsIFNpZ25hdHVyZUlu ZGV4LCB1bnNpZ25lZCk7CitXYXNtRXhpdFN0dWJzIGV4aXRTdHViR2VuZXJhdG9yKFZNKiwgQmFn PENhbGxMaW5rSW5mbz4mLCBTaWduYXR1cmVJbmRleCwgdW5zaWduZWQpOwogCiB9IH0gLy8gbmFt ZXNwYWNlIEpTQzo6V2FzbQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtRm9ybWF0LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRm9ybWF0LmgK aW5kZXggMzU5ZGRjYy4uYjZkYWRlOSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbUZvcm1hdC5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21G b3JtYXQuaApAQCAtMTg3LDcgKzE4Nyw3IEBAIHByaXZhdGU6CiB9OwogCiBzdHJ1Y3QgTW9kdWxl SW5mb3JtYXRpb24gewotICAgIFZlY3RvcjxTaWduYXR1cmVJbmRleD4gc2lnbmF0dXJlSW5kaWNl czsKKyAgICBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+IG1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1Vu aXF1ZWRTaWduYXR1cmVJbmRpY2VzOwogICAgIFZlY3RvcjxJbXBvcnQ+IGltcG9ydHM7CiAgICAg VmVjdG9yPFNpZ25hdHVyZUluZGV4PiBpbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXM7CiAg ICAgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiBpbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNl czsKQEAgLTE5OSw2ICsxOTksMTggQEAgc3RydWN0IE1vZHVsZUluZm9ybWF0aW9uIHsKICAgICBU YWJsZUluZm9ybWF0aW9uIHRhYmxlSW5mb3JtYXRpb247CiAgICAgVmVjdG9yPEdsb2JhbD4gZ2xv YmFsczsKICAgICB1bnNpZ25lZCBmaXJzdEludGVybmFsR2xvYmFsIHsgMCB9OworICAgIHNpemVf dCBmdW5jdGlvbkluZGV4U3BhY2VTaXplKCkgY29uc3QgeyByZXR1cm4gaW1wb3J0RnVuY3Rpb25T aWduYXR1cmVJbmRpY2VzLnNpemUoKSArIGludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2Vz LnNpemUoKTsgfQorICAgIGJvb2wgaXNJbXBvcnRlZEZ1bmN0aW9uRnJvbUZ1bmN0aW9uSW5kZXhT cGFjZShzaXplX3QgZnVuY3Rpb25JbmRleCkgY29uc3QKKyAgICB7CisgICAgICAgIEFTU0VSVChm dW5jdGlvbkluZGV4IDwgZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpKTsKKyAgICAgICAgcmV0dXJu IGZ1bmN0aW9uSW5kZXggPCBpbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMuc2l6ZSgpOwor ICAgIH0KKyAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4 U3BhY2Uoc2l6ZV90IGZ1bmN0aW9uSW5kZXgpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4g aXNJbXBvcnRlZEZ1bmN0aW9uRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KQor ICAgICAgICAgICAgPyBpbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXNbZnVuY3Rpb25JbmRl eF0KKyAgICAgICAgICAgIDogaW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXNbZnVuY3Rp b25JbmRleCAtIGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCldOworICAgIH0K IAogICAgIH5Nb2R1bGVJbmZvcm1hdGlvbigpOwogfTsKQEAgLTIwNiw2ICsyMTgsNyBAQCBzdHJ1 Y3QgTW9kdWxlSW5mb3JtYXRpb24gewogc3RydWN0IFVubGlua2VkV2FzbVRvV2FzbUNhbGwgewog ICAgIENvZGVMb2NhdGlvbkNhbGwgY2FsbExvY2F0aW9uOwogICAgIHNpemVfdCBmdW5jdGlvbklu ZGV4OworICAgIGJvb2wgdG9KUzsKIH07CiAKIHN0cnVjdCBFbnRyeXBvaW50IHsKQEAgLTIyMSw3 ICsyMzQsMTAgQEAgc3RydWN0IFdhc21JbnRlcm5hbEZ1bmN0aW9uIHsKICAgICBFbnRyeXBvaW50 IGpzVG9XYXNtRW50cnlwb2ludDsKIH07CiAKLXR5cGVkZWYgTWFjcm9Bc3NlbWJsZXJDb2RlUmVm IFdhc21Ub0pTU3R1YjsKK3N0cnVjdCBXYXNtRXhpdFN0dWJzIHsKKyAgICBNYWNyb0Fzc2VtYmxl ckNvZGVSZWYgd2FzbVRvSlM7CisgICAgTWFjcm9Bc3NlbWJsZXJDb2RlUmVmIHdhc21Ub1dhc207 Cit9OwogCiAvLyBXZWJBc3NlbWJseSBkaXJlY3QgY2FsbHMgYW5kIGNhbGxfaW5kaXJlY3QgdXNl IGluZGljZXMgaW50byAiZnVuY3Rpb24gaW5kZXggc3BhY2UiLiBUaGlzIHNwYWNlIHN0YXJ0cyB3 aXRoIGFsbCBpbXBvcnRzLCBhbmQgdGhlbiBhbGwgaW50ZXJuYWwgZnVuY3Rpb25zLgogLy8gQ2Fs bGFibGVGdW5jdGlvbiBhbmQgRnVuY3Rpb25JbmRleFNwYWNlIGFyZSBvbmx5IG1lYW50IGFzIGZh c3QgbG9va3VwIHRhYmxlcyBmb3IgdGhlc2Ugb3Bjb2RlcywgYW5kIGRvIG5vdCBvd24gY29kZS4K QEAgLTI0MCwxMiArMjU2LDYgQEAgc3RydWN0IENhbGxhYmxlRnVuY3Rpb24gewogfTsKIHR5cGVk ZWYgVmVjdG9yPENhbGxhYmxlRnVuY3Rpb24+IEZ1bmN0aW9uSW5kZXhTcGFjZTsKIAotCi1zdHJ1 Y3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlIHsKLSAgICBNYWxsb2NQdHI8Q2FsbGFibGVG dW5jdGlvbj4gYnVmZmVyOwotICAgIHNpemVfdCBzaXplOwotfTsKLQogfSB9IC8vIG5hbWVzcGFj ZSBKU0M6Oldhc20KIAogI2VuZGlmIC8vIEVOQUJMRShXRUJBU1NFTUJMWSkKZGlmZiAtLWdpdCBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21GdW5jdGlvblBhcnNlci5oIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmgKaW5kZXggYTYwYWM0Ny4u M2VjYjM5MyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0 aW9uUGFyc2VyLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9u UGFyc2VyLmgKQEAgLTQ2LDcgKzQ2LDcgQEAgcHVibGljOgogICAgIHR5cGVkZWYgdHlwZW5hbWUg Q29udGV4dDo6Q29udHJvbFR5cGUgQ29udHJvbFR5cGU7CiAgICAgdHlwZWRlZiB0eXBlbmFtZSBD b250ZXh0OjpFeHByZXNzaW9uTGlzdCBFeHByZXNzaW9uTGlzdDsKIAotICAgIEZ1bmN0aW9uUGFy c2VyKFZNKiwgQ29udGV4dCYsIGNvbnN0IHVpbnQ4X3QqIGZ1bmN0aW9uU3RhcnQsIHNpemVfdCBm dW5jdGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiwgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25J bmRleFNwYWNlJiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mKTsKKyAgICBGdW5jdGlvblBhcnNl cihWTSosIENvbnRleHQmLCBjb25zdCB1aW50OF90KiBmdW5jdGlvblN0YXJ0LCBzaXplX3QgZnVu Y3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSosIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJik7 CiAKICAgICBSZXN1bHQgV0FSTl9VTlVTRURfUkVUVVJOIHBhcnNlKCk7CiAKQEAgLTgyLDE3ICs4 MiwxNSBAQCBwcml2YXRlOgogICAgIEV4cHJlc3Npb25MaXN0IG1fZXhwcmVzc2lvblN0YWNrOwog ICAgIFZlY3RvcjxDb250cm9sRW50cnk+IG1fY29udHJvbFN0YWNrOwogICAgIGNvbnN0IFNpZ25h dHVyZSogbV9zaWduYXR1cmU7Ci0gICAgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNl JiBtX2Z1bmN0aW9uSW5kZXhTcGFjZTsKICAgICBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgbV9p bmZvOwogICAgIHVuc2lnbmVkIG1fdW5yZWFjaGFibGVCbG9ja3MgeyAwIH07CiB9OwogCiB0ZW1w bGF0ZTx0eXBlbmFtZSBDb250ZXh0PgotRnVuY3Rpb25QYXJzZXI8Q29udGV4dD46OkZ1bmN0aW9u UGFyc2VyKFZNKiB2bSwgQ29udGV4dCYgY29udGV4dCwgY29uc3QgdWludDhfdCogZnVuY3Rpb25T dGFydCwgc2l6ZV90IGZ1bmN0aW9uTGVuZ3RoLCBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSwg Y29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiBmdW5jdGlvbkluZGV4U3BhY2UsIGNv bnN0IE1vZHVsZUluZm9ybWF0aW9uJiBpbmZvKQorRnVuY3Rpb25QYXJzZXI8Q29udGV4dD46OkZ1 bmN0aW9uUGFyc2VyKFZNKiB2bSwgQ29udGV4dCYgY29udGV4dCwgY29uc3QgdWludDhfdCogZnVu Y3Rpb25TdGFydCwgc2l6ZV90IGZ1bmN0aW9uTGVuZ3RoLCBjb25zdCBTaWduYXR1cmUqIHNpZ25h dHVyZSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8pCiAgICAgOiBQYXJzZXIodm0sIGZ1 bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoKQogICAgICwgbV9jb250ZXh0KGNvbnRleHQpCiAg ICAgLCBtX3NpZ25hdHVyZShzaWduYXR1cmUpCi0gICAgLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZShm dW5jdGlvbkluZGV4U3BhY2UpCiAgICAgLCBtX2luZm8oaW5mbykKIHsKICAgICBpZiAodmVyYm9z ZSkKQEAgLTMwOCw5ICszMDYsOSBAQCBhdXRvIEZ1bmN0aW9uUGFyc2VyPENvbnRleHQ+OjpwYXJz ZUV4cHJlc3Npb24oT3BUeXBlIG9wKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgY2FzZSBDYWxsOiB7 CiAgICAgICAgIHVpbnQzMl90IGZ1bmN0aW9uSW5kZXg7CiAgICAgICAgIFdBU01fUEFSU0VSX0ZB SUxfSUYoIXBhcnNlVmFyVUludDMyKGZ1bmN0aW9uSW5kZXgpLCAiY2FuJ3QgcGFyc2UgY2FsbCdz IGZ1bmN0aW9uIGluZGV4Iik7Ci0gICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVuY3Rpb25J bmRleCA+PSBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5zaXplLCAiY2FsbCBmdW5jdGlvbiBpbmRleCAi LCBmdW5jdGlvbkluZGV4LCAiIGV4Y2VlZHMgZnVuY3Rpb24gaW5kZXggc3BhY2UgIiwgbV9mdW5j dGlvbkluZGV4U3BhY2Uuc2l6ZSk7CisgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVuY3Rp b25JbmRleCA+PSBtX2luZm8uZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpLCAiY2FsbCBmdW5jdGlv biBpbmRleCAiLCBmdW5jdGlvbkluZGV4LCAiIGV4Y2VlZHMgZnVuY3Rpb24gaW5kZXggc3BhY2Ug IiwgbV9pbmZvLmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSk7CiAKLSAgICAgICAgU2lnbmF0dXJl SW5kZXggY2FsbGVlU2lnbmF0dXJlSW5kZXggPSBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5idWZmZXIu Z2V0KClbZnVuY3Rpb25JbmRleF0uc2lnbmF0dXJlSW5kZXg7CisgICAgICAgIFNpZ25hdHVyZUlu ZGV4IGNhbGxlZVNpZ25hdHVyZUluZGV4ID0gbV9pbmZvLnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0 aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KTsKICAgICAgICAgY29uc3QgU2lnbmF0dXJlKiBj YWxsZWVTaWduYXR1cmUgPSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KG1fdm0sIGNhbGxlZVNp Z25hdHVyZUluZGV4KTsKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihjYWxsZWVTaWduYXR1 cmUtPmFyZ3VtZW50Q291bnQoKSA+IG1fZXhwcmVzc2lvblN0YWNrLnNpemUoKSwgImNhbGwgZnVu Y3Rpb24gaW5kZXggIiwgZnVuY3Rpb25JbmRleCwgIiBoYXMgIiwgY2FsbGVlU2lnbmF0dXJlLT5h cmd1bWVudENvdW50KCksICIgYXJndW1lbnRzLCBidXQgdGhlIGV4cHJlc3Npb24gc3RhY2sgY3Vy cmVudGx5IGhvbGRzICIsIG1fZXhwcmVzc2lvblN0YWNrLnNpemUoKSwgIiB2YWx1ZXMiKTsKIApA QCAtMzM3LDkgKzMzNSw5IEBAIGF1dG8gRnVuY3Rpb25QYXJzZXI8Q29udGV4dD46OnBhcnNlRXhw cmVzc2lvbihPcFR5cGUgb3ApIC0+IFBhcnRpYWxSZXN1bHQKICAgICAgICAgV0FTTV9QQVJTRVJf RkFJTF9JRighcGFyc2VWYXJVSW50MzIoc2lnbmF0dXJlSW5kZXgpLCAiY2FuJ3QgZ2V0IGNhbGxf aW5kaXJlY3QncyBzaWduYXR1cmUgaW5kZXgiKTsKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9J RighcGFyc2VWYXJVSW50MShyZXNlcnZlZCksICJjYW4ndCBnZXQgY2FsbF9pbmRpcmVjdCdzIHJl c2VydmVkIGJ5dGUiKTsKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihyZXNlcnZlZCwgImNh bGxfaW5kaXJlY3QncyAncmVzZXJ2ZWQnIHZhcnVpbnQxIG11c3QgYmUgMHgwIik7Ci0gICAgICAg IFdBU01fUEFSU0VSX0ZBSUxfSUYobV9pbmZvLnNpZ25hdHVyZUluZGljZXMuc2l6ZSgpIDw9IHNp Z25hdHVyZUluZGV4LCAiY2FsbF9pbmRpcmVjdCdzIHNpZ25hdHVyZSBpbmRleCAiLCBzaWduYXR1 cmVJbmRleCwgIiBleGNlZWRzIGtub3duIHNpZ25hdHVyZXMgIiwgbV9pbmZvLnNpZ25hdHVyZUlu ZGljZXMuc2l6ZSgpKTsKKyAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihtX2luZm8ubW9kdWxl U2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMuc2l6ZSgpIDw9IHNpZ25h dHVyZUluZGV4LCAiY2FsbF9pbmRpcmVjdCdzIHNpZ25hdHVyZSBpbmRleCAiLCBzaWduYXR1cmVJ bmRleCwgIiBleGNlZWRzIGtub3duIHNpZ25hdHVyZXMgIiwgbV9pbmZvLm1vZHVsZVNpZ25hdHVy ZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzLnNpemUoKSk7CiAKLSAgICAgICAgU2ln bmF0dXJlSW5kZXggY2FsbGVlU2lnbmF0dXJlSW5kZXggPSBtX2luZm8uc2lnbmF0dXJlSW5kaWNl c1tzaWduYXR1cmVJbmRleF07CisgICAgICAgIFNpZ25hdHVyZUluZGV4IGNhbGxlZVNpZ25hdHVy ZUluZGV4ID0gbV9pbmZvLm1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJ bmRpY2VzW3NpZ25hdHVyZUluZGV4XTsKICAgICAgICAgY29uc3QgU2lnbmF0dXJlKiBjYWxsZWVT aWduYXR1cmUgPSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KG1fdm0sIGNhbGxlZVNpZ25hdHVy ZUluZGV4KTsKICAgICAgICAgc2l6ZV90IGFyZ3VtZW50Q291bnQgPSBjYWxsZWVTaWduYXR1cmUt PmFyZ3VtZW50Q291bnQoKSArIDE7IC8vIEFkZCB0aGUgY2FsbGVlJ3MgaW5kZXguCiAgICAgICAg IFdBU01fUEFSU0VSX0ZBSUxfSUYoYXJndW1lbnRDb3VudCA+IG1fZXhwcmVzc2lvblN0YWNrLnNp emUoKSwgImNhbGxfaW5kaXJlY3QgZXhwZWN0cyAiLCBhcmd1bWVudENvdW50LCAiIGFyZ3VtZW50 cywgYnV0IHRoZSBleHByZXNzaW9uIHN0YWNrIGN1cnJlbnRseSBob2xkcyAiLCBtX2V4cHJlc3Np b25TdGFjay5zaXplKCksICIgdmFsdWVzIik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtTWVtb3J5LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dh c21NZW1vcnkuY3BwCmluZGV4IGYxOWVjZTAuLjFlOWM5YmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwCkBAIC0zMSwxMSArMzEsMTEgQEAKIG5hbWVzcGFjZSBK U0MgeyBuYW1lc3BhY2UgV2FzbSB7CiAKIE1lbW9yeTo6TWVtb3J5KFBhZ2VDb3VudCBpbml0aWFs LCBQYWdlQ291bnQgbWF4aW11bSkKLSAgICA6IG1fbW9kZShNb2RlOjpCb3VuZHNDaGVja2luZykK LSAgICAsIG1fc2l6ZShpbml0aWFsLmJ5dGVzKCkpCisgICAgOiBtX3NpemUoaW5pdGlhbC5ieXRl cygpKQogICAgICwgbV9jYXBhY2l0eShtYXhpbXVtID8gbWF4aW11bS5ieXRlcygpIDogUGFnZUNv dW50OjptYXgoKS5ieXRlcygpKQogICAgICwgbV9pbml0aWFsKGluaXRpYWwpCiAgICAgLCBtX21h eGltdW0obWF4aW11bSkKKyAgICAsIG1fbW9kZShNb2RlOjpCb3VuZHNDaGVja2luZykKICAgICAv LyBGSVhNRTogSWYgd2UgYWRkIHNpZ25hbCBiYXNlZCBib3VuZHMgY2hlY2tpbmcgdGhlbiB3ZSBu ZWVkIGV4dHJhIHNwYWNlIGZvciBvdmVyZmxvdyBvbiBsb2FkLgogICAgIC8vIHNlZTogaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MjY5MwogewpkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5oIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbU1lbW9yeS5oCmluZGV4IGI0MTFmMzQ4Li45ZDQwZTNkIDEwMDY0NAot LS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmgKKysrIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5oCkBAIC0zOCw2ICszOCwxNyBAQCBjbGFz cyBNZW1vcnkgewogICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKE1lbW9yeSk7CiAgICAgV1RGX01B S0VfRkFTVF9BTExPQ0FURUQ7CiBwdWJsaWM6CisgICAgTWVtb3J5KE1lbW9yeSYmIG90aGVyKQor ICAgICAgICA6IG1fbWVtb3J5KG90aGVyLm1fbWVtb3J5KQorICAgICAgICAsIG1fc2l6ZShvdGhl ci5tX3NpemUpCisgICAgICAgICwgbV9jYXBhY2l0eShvdGhlci5tX2NhcGFjaXR5KQorICAgICAg ICAsIG1faW5pdGlhbChvdGhlci5tX2luaXRpYWwpCisgICAgICAgICwgbV9tYXhpbXVtKG90aGVy Lm1fbWF4aW11bSkKKyAgICAgICAgLCBtX21hcHBlZENhcGFjaXR5KG90aGVyLm1fbWFwcGVkQ2Fw YWNpdHkpCisgICAgICAgICwgbV9tb2RlKG90aGVyLm1fbW9kZSkKKyAgICB7CisgICAgICAgIG1l bXNldCgmb3RoZXIsIDAsIHNpemVvZihvdGhlcikpOworICAgIH0KIAogICAgIC8vIEZJWE1FOiBX ZSBzaG91bGQgc3VwcG9ydCBvdGhlciBtb2Rlcy4gc2VlOiBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTYyNjkzCiAgICAgZW51bSBjbGFzcyBNb2RlIHsKQEAgLTU3LDEx ICs2OCwxMSBAQCBwdWJsaWM6CiAgICAgdm9pZCogbWVtb3J5KCkgY29uc3QgeyByZXR1cm4gbV9t ZW1vcnk7IH0KICAgICB1aW50MzJfdCBzaXplKCkgY29uc3QgeyByZXR1cm4gbV9zaXplOyB9CiAK LSAgICBNb2RlIG1vZGUoKSBjb25zdCB7IHJldHVybiBtX21vZGU7IH0KLQogICAgIFBhZ2VDb3Vu dCBpbml0aWFsKCkgY29uc3QgeyByZXR1cm4gbV9pbml0aWFsOyB9CiAgICAgUGFnZUNvdW50IG1h eGltdW0oKSBjb25zdCB7IHJldHVybiBtX21heGltdW07IH0KIAorICAgIE1vZGUgbW9kZSgpIGNv bnN0IHsgcmV0dXJuIG1fbW9kZTsgfQorCiAgICAgYm9vbCBncm93KHVpbnQzMl90IG5ld1NpemUp CiAgICAgewogICAgICAgICBBU1NFUlQobV9tZW1vcnkpOwpAQCAtNzEsMTcgKzgyLDE4IEBAIHB1 YmxpYzoKICAgICAgICAgcmV0dXJuICFtcHJvdGVjdChtX21lbW9yeSwgbmV3U2l6ZSwgUFJPVF9S RUFEIHwgUFJPVF9XUklURSk7CiAgICAgfQogCisgICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRP Zk1lbW9yeSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihNZW1vcnksIG1fbWVtb3J5KTsgfQog ICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZTaXplKCkgeyByZXR1cm4gT0JKRUNUX09GRlNF VE9GKE1lbW9yeSwgbV9zaXplKTsgfQogCiAgICAgCiBwcml2YXRlOgogICAgIHZvaWQqIG1fbWVt b3J5IHsgbnVsbHB0ciB9OwotICAgIE1vZGUgbV9tb2RlOwogICAgIHVpbnQzMl90IG1fc2l6ZSB7 IDAgfTsKICAgICB1aW50MzJfdCBtX2NhcGFjaXR5IHsgMCB9OwogICAgIFBhZ2VDb3VudCBtX2lu aXRpYWw7CiAgICAgUGFnZUNvdW50IG1fbWF4aW11bTsKICAgICB1aW50NjRfdCBtX21hcHBlZENh cGFjaXR5IHsgMCB9OworICAgIE1vZGUgbV9tb2RlIHsgTW9kZTo6Qm91bmRzQ2hlY2tpbmcgfTsK IH07CiAKIH0gfSAvLyBuYW1lc3BhY2UgSlNDOjpXYXNtCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCmluZGV4IDg5MTg0NzUuLjUyZmViYWMgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3Bw CisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCkBA IC05OSw3ICs5OSw3IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZVR5cGUoKSAtPiBQYXJ0aWFs UmVzdWx0CiAKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihjb3VudCks ICJjYW4ndCBnZXQgVHlwZSBzZWN0aW9uJ3MgY291bnQiKTsKICAgICBXQVNNX1BBUlNFUl9GQUlM X0lGKGNvdW50ID09IHN0ZDo6bnVtZXJpY19saW1pdHM8dWludDMyX3Q+OjptYXgoKSwgIlR5cGUg c2VjdGlvbidzIGNvdW50IGlzIHRvbyBiaWcgIiwgY291bnQpOwotICAgIFdBU01fUEFSU0VSX0ZB SUxfSUYoIW1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlcy50cnlSZXNlcnZlQ2FwYWNp dHkoY291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgVHlwZSBzZWN0aW9u J3MgIiwgY291bnQsICIgZW50cmllcyIpOworICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVz dWx0Lm1vZHVsZS0+bW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGlj ZXMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1v cnkgZm9yIFR5cGUgc2VjdGlvbidzICIsIGNvdW50LCAiIGVudHJpZXMiKTsKIAogICAgIGZvciAo dWludDMyX3QgaSA9IDA7IGkgPCBjb3VudDsgKytpKSB7CiAgICAgICAgIGludDhfdCB0eXBlOwpA QCAtMTMxLDcgKzEzMSw3IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZVR5cGUoKSAtPiBQYXJ0 aWFsUmVzdWx0CiAgICAgICAgIHNpZ25hdHVyZS0+cmV0dXJuVHlwZSgpID0gcmV0dXJuVHlwZTsK IAogICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IFNpZ25hdHVyZUluZm9y bWF0aW9uOjphZG9wdChtX3ZtLCBzaWduYXR1cmUucmVsZWFzZSgpKTsKLSAgICAgICAgbV9yZXN1 bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRl eCk7CisgICAgICAgIG1fcmVzdWx0Lm1vZHVsZS0+bW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5p cXVlZFNpZ25hdHVyZUluZGljZXMudW5jaGVja2VkQXBwZW5kKHNpZ25hdHVyZUluZGV4KTsKICAg ICB9CiAgICAgcmV0dXJuIHsgfTsKIH0KQEAgLTE0NCw3ICsxNDQsNiBAQCBhdXRvIE1vZHVsZVBh cnNlcjo6cGFyc2VJbXBvcnQoKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgV0FTTV9QQVJTRVJfRkFJ TF9JRighbV9yZXN1bHQubW9kdWxlLT5nbG9iYWxzLnRyeVJlc2VydmVDYXBhY2l0eShpbXBvcnRD b3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBpbXBvcnRDb3VudCwg IiBnbG9iYWxzIik7IC8vIEZJWE1FIHRoaXMgb3Zlci1hbGxvY2F0ZXMgd2hlbiB3ZSBmaXggdGhl IEZJWE1FcyBiZWxvdy4KICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX3Jlc3VsdC5tb2R1bGUt PmltcG9ydHMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGltcG9ydENvdW50KSwgImNhbid0IGFsbG9jYXRl IGVub3VnaCBtZW1vcnkgZm9yICIsIGltcG9ydENvdW50LCAiIGltcG9ydHMiKTsgLy8gRklYTUUg dGhpcyBvdmVyLWFsbG9jYXRlcyB3aGVuIHdlIGZpeCB0aGUgRklYTUVzIGJlbG93LgogICAgIFdB U01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0Lm1vZHVsZS0+aW1wb3J0RnVuY3Rpb25TaWduYXR1 cmVJbmRpY2VzLnRyeVJlc2VydmVDYXBhY2l0eShpbXBvcnRDb3VudCksICJjYW4ndCBhbGxvY2F0 ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBpbXBvcnRDb3VudCwgIiBpbXBvcnQgZnVuY3Rpb24gc2ln bmF0dXJlcyIpOyAvLyBGSVhNRSB0aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBG SVhNRXMgYmVsb3cuCi0gICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQuZnVuY3Rpb25J bmRleFNwYWNlLnRyeVJlc2VydmVDYXBhY2l0eShpbXBvcnRDb3VudCksICJjYW4ndCBhbGxvY2F0 ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBpbXBvcnRDb3VudCwgIiBmdW5jdGlvbnMgaW4gdGhlIGlu ZGV4IHNwYWNlIik7IC8vIEZJWE1FIHRoaXMgb3Zlci1hbGxvY2F0ZXMgd2hlbiB3ZSBmaXggdGhl IEZJWE1FcyBiZWxvdy4gV2UnbGwgYWxsb2NhdGUgc29tZSBtb3JlIGhlcmUgd2hlbiB3ZSBrbm93 IGhvdyBtYW55IGZ1bmN0aW9ucyB0byBleHBlY3QuCiAKICAgICBmb3IgKHVpbnQzMl90IGltcG9y dE51bWJlciA9IDA7IGltcG9ydE51bWJlciA8IGltcG9ydENvdW50OyArK2ltcG9ydE51bWJlcikg ewogICAgICAgICBJbXBvcnQgaW1wOwpAQCAtMTY2LDExICsxNjUsMTAgQEAgYXV0byBNb2R1bGVQ YXJzZXI6OnBhcnNlSW1wb3J0KCkgLT4gUGFydGlhbFJlc3VsdAogICAgICAgICBjYXNlIEV4dGVy bmFsS2luZDo6RnVuY3Rpb246IHsKICAgICAgICAgICAgIHVpbnQzMl90IGZ1bmN0aW9uU2lnbmF0 dXJlSW5kZXg7CiAgICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQz MihmdW5jdGlvblNpZ25hdHVyZUluZGV4KSwgImNhbid0IGdldCAiLCBpbXBvcnROdW1iZXIsICJ0 aCBJbXBvcnQncyBmdW5jdGlvbiBzaWduYXR1cmUgaW4gbW9kdWxlICciLCBtb2R1bGVTdHJpbmcs ICInIGZpZWxkICciLCBmaWVsZFN0cmluZywgIiciKTsKLSAgICAgICAgICAgIFdBU01fUEFSU0VS X0ZBSUxfSUYoZnVuY3Rpb25TaWduYXR1cmVJbmRleCA+PSBtX3Jlc3VsdC5tb2R1bGUtPnNpZ25h dHVyZUluZGljZXMuc2l6ZSgpLCAiaW52YWxpZCBmdW5jdGlvbiBzaWduYXR1cmUgZm9yICIsIGlt cG9ydE51bWJlciwgInRoIEltcG9ydCwgIiwgZnVuY3Rpb25TaWduYXR1cmVJbmRleCwgIiBpcyBv dXQgb2YgcmFuZ2Ugb2YgIiwgbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnNpemUo KSwgIiBpbiBtb2R1bGUgJyIsIG1vZHVsZVN0cmluZywgIicgZmllbGQgJyIsIGZpZWxkU3RyaW5n LCAiJyIpOworICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvblNpZ25hdHVy ZUluZGV4ID49IG1fcmVzdWx0Lm1vZHVsZS0+bW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVl ZFNpZ25hdHVyZUluZGljZXMuc2l6ZSgpLCAiaW52YWxpZCBmdW5jdGlvbiBzaWduYXR1cmUgZm9y ICIsIGltcG9ydE51bWJlciwgInRoIEltcG9ydCwgIiwgZnVuY3Rpb25TaWduYXR1cmVJbmRleCwg IiBpcyBvdXQgb2YgcmFuZ2Ugb2YgIiwgbV9yZXN1bHQubW9kdWxlLT5tb2R1bGVTaWduYXR1cmVJ bmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICIgaW4gbW9kdWxlICciLCBt b2R1bGVTdHJpbmcsICInIGZpZWxkICciLCBmaWVsZFN0cmluZywgIiciKTsKICAgICAgICAgICAg IGltcC5raW5kSW5kZXggPSBtX3Jlc3VsdC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJl SW5kaWNlcy5zaXplKCk7Ci0gICAgICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRl eCA9IG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvblNpZ25hdHVyZUlu ZGV4XTsKKyAgICAgICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9yZXN1 bHQubW9kdWxlLT5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNl c1tmdW5jdGlvblNpZ25hdHVyZUluZGV4XTsKICAgICAgICAgICAgIG1fcmVzdWx0Lm1vZHVsZS0+ aW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJ bmRleCk7Ci0gICAgICAgICAgICBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2UudW5jaGVja2Vk QXBwZW5kKHNpZ25hdHVyZUluZGV4KTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICB9CiAg ICAgICAgIGNhc2UgRXh0ZXJuYWxLaW5kOjpUYWJsZTogewpAQCAtMjEyLDIwICsyMTAsMTggQEAg YXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlRnVuY3Rpb24oKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAg V0FTTV9QQVJTRVJfRkFJTF9JRihjb3VudCA9PSBzdGQ6Om51bWVyaWNfbGltaXRzPHVpbnQzMl90 Pjo6bWF4KCksICJGdW5jdGlvbiBzZWN0aW9uJ3MgY291bnQgaXMgdG9vIGJpZyAiLCBjb3VudCk7 CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlLT5pbnRlcm5hbEZ1bmN0 aW9uU2lnbmF0dXJlSW5kaWNlcy50cnlSZXNlcnZlQ2FwYWNpdHkoY291bnQpLCAiY2FuJ3QgYWxs b2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgY291bnQsICIgRnVuY3Rpb24gc2lnbmF0dXJlcyIp OwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0LmZ1bmN0aW9uTG9jYXRpb25JbkJp bmFyeS50cnlSZXNlcnZlQ2FwYWNpdHkoY291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1l bW9yeSBmb3IgIiwgY291bnQsICJGdW5jdGlvbiBsb2NhdGlvbnMiKTsKLSAgICBXQVNNX1BBUlNF Ul9GQUlMX0lGKCFtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2UudHJ5UmVzZXJ2ZUNhcGFjaXR5 KG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCkgKyBjb3VudCksICJjYW4ndCBhbGxv Y2F0ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBjb3VudCwgIiBtb3JlIGZ1bmN0aW9ucyBpbiB0aGUg ZnVuY3Rpb24gaW5kZXggc3BhY2UiKTsKIAogICAgIGZvciAodWludDMyX3QgaSA9IDA7IGkgPCBj b3VudDsgKytpKSB7CiAgICAgICAgIHVpbnQzMl90IHR5cGVOdW1iZXI7CiAgICAgICAgIFdBU01f UEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKHR5cGVOdW1iZXIpLCAiY2FuJ3QgZ2V0ICIs IGksICJ0aCBGdW5jdGlvbidzIHR5cGUgbnVtYmVyIik7Ci0gICAgICAgIFdBU01fUEFSU0VSX0ZB SUxfSUYodHlwZU51bWJlciA+PSBtX3Jlc3VsdC5tb2R1bGUtPnNpZ25hdHVyZUluZGljZXMuc2l6 ZSgpLCBpLCAidGggRnVuY3Rpb24gdHlwZSBudW1iZXIgaXMgaW52YWxpZCAiLCB0eXBlTnVtYmVy KTsKKyAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRih0eXBlTnVtYmVyID49IG1fcmVzdWx0Lm1v ZHVsZS0+bW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMuc2l6 ZSgpLCBpLCAidGggRnVuY3Rpb24gdHlwZSBudW1iZXIgaXMgaW52YWxpZCAiLCB0eXBlTnVtYmVy KTsKIAotICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1v ZHVsZS0+c2lnbmF0dXJlSW5kaWNlc1t0eXBlTnVtYmVyXTsKKyAgICAgICAgU2lnbmF0dXJlSW5k ZXggc2lnbmF0dXJlSW5kZXggPSBtX3Jlc3VsdC5tb2R1bGUtPm1vZHVsZVNpZ25hdHVyZUluZGlj ZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzW3R5cGVOdW1iZXJdOwogICAgICAgICAvLyBUaGUg Q29kZSBzZWN0aW9uIGZpeGVzIHVwIHN0YXJ0IGFuZCBlbmQuCiAgICAgICAgIHNpemVfdCBzdGFy dCA9IDA7CiAgICAgICAgIHNpemVfdCBlbmQgPSAwOwogICAgICAgICBtX3Jlc3VsdC5tb2R1bGUt PmludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1 cmVJbmRleCk7CiAgICAgICAgIG1fcmVzdWx0LmZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeS51bmNo ZWNrZWRBcHBlbmQoeyBzdGFydCwgZW5kIH0pOwotICAgICAgICBtX3Jlc3VsdC5mdW5jdGlvbklu ZGV4U3BhY2UudW5jaGVja2VkQXBwZW5kKHNpZ25hdHVyZUluZGV4KTsKICAgICB9CiAKICAgICBy ZXR1cm4geyB9OwpAQCAtMzk2LDcgKzM5Miw3IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZUV4 cG9ydCgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFy c2VWYXJVSW50MzIoZXhwLmtpbmRJbmRleCksICJjYW4ndCBnZXQgIiwgZXhwb3J0TnVtYmVyLCAi dGggRXhwb3J0J3Mga2luZCBpbmRleCwgbmFtZWQgJyIsIGZpZWxkU3RyaW5nLCAiJyIpOwogICAg ICAgICBzd2l0Y2ggKGV4cC5raW5kKSB7CiAgICAgICAgIGNhc2UgRXh0ZXJuYWxLaW5kOjpGdW5j dGlvbjogewotICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihleHAua2luZEluZGV4ID49 IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCksIGV4cG9ydE51bWJlciwgInRoIEV4 cG9ydCBoYXMgaW52YWxpZCBmdW5jdGlvbiBudW1iZXIgIiwgZXhwLmtpbmRJbmRleCwgIiBpdCBl eGNlZWRzIHRoZSBmdW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4 U3BhY2Uuc2l6ZSgpLCAiLCBuYW1lZCAnIiwgZmllbGRTdHJpbmcsICInIik7CisgICAgICAgICAg ICBXQVNNX1BBUlNFUl9GQUlMX0lGKGV4cC5raW5kSW5kZXggPj0gbV9yZXN1bHQubW9kdWxlLT5m dW5jdGlvbkluZGV4U3BhY2VTaXplKCksIGV4cG9ydE51bWJlciwgInRoIEV4cG9ydCBoYXMgaW52 YWxpZCBmdW5jdGlvbiBudW1iZXIgIiwgZXhwLmtpbmRJbmRleCwgIiBpdCBleGNlZWRzIHRoZSBm dW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhTcGFj ZVNpemUoKSwgIiwgbmFtZWQgJyIsIGZpZWxkU3RyaW5nLCAiJyIpOwogICAgICAgICAgICAgYnJl YWs7CiAgICAgICAgIH0KICAgICAgICAgY2FzZSBFeHRlcm5hbEtpbmQ6OlRhYmxlOiB7CkBAIC00 MjYsOCArNDIyLDggQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlU3RhcnQoKSAtPiBQYXJ0aWFs UmVzdWx0CiB7CiAgICAgdWludDMyX3Qgc3RhcnRGdW5jdGlvbkluZGV4OwogICAgIFdBU01fUEFS U0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKHN0YXJ0RnVuY3Rpb25JbmRleCksICJjYW4ndCBn ZXQgU3RhcnQgaW5kZXgiKTsKLSAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHN0YXJ0RnVuY3Rpb25J bmRleCA+PSBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpLCAiU3RhcnQgaW5kZXgg Iiwgc3RhcnRGdW5jdGlvbkluZGV4LCAiIGV4Y2VlZHMgZnVuY3Rpb24gaW5kZXggc3BhY2UgIiwg bV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnNpemUoKSk7Ci0gICAgU2lnbmF0dXJlSW5kZXgg c2lnbmF0dXJlSW5kZXggPSBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Vbc3RhcnRGdW5jdGlv bkluZGV4XS5zaWduYXR1cmVJbmRleDsKKyAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHN0YXJ0RnVu Y3Rpb25JbmRleCA+PSBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSwg IlN0YXJ0IGluZGV4ICIsIHN0YXJ0RnVuY3Rpb25JbmRleCwgIiBleGNlZWRzIGZ1bmN0aW9uIGlu ZGV4IHNwYWNlICIsIG1fcmVzdWx0Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpKTsK KyAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZS0+c2ln bmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRleFNwYWNlKHN0YXJ0RnVuY3Rpb25JbmRleCk7CiAg ICAgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUgPSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0 KG1fdm0sIHNpZ25hdHVyZUluZGV4KTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHNpZ25hdHVy ZS0+YXJndW1lbnRDb3VudCgpLCAiU3RhcnQgZnVuY3Rpb24gY2FuJ3QgaGF2ZSBhcmd1bWVudHMi KTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHNpZ25hdHVyZS0+cmV0dXJuVHlwZSgpICE9IFZv aWQsICJTdGFydCBmdW5jdGlvbiBjYW4ndCByZXR1cm4gYSB2YWx1ZSIpOwpAQCAtNDc3LDcgKzQ3 Myw3IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZUVsZW1lbnQoKSAtPiBQYXJ0aWFsUmVzdWx0 CiAgICAgICAgIGZvciAodW5zaWduZWQgaW5kZXggPSAwOyBpbmRleCA8IGluZGV4Q291bnQ7ICsr aW5kZXgpIHsKICAgICAgICAgICAgIHVpbnQzMl90IGZ1bmN0aW9uSW5kZXg7CiAgICAgICAgICAg ICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihmdW5jdGlvbkluZGV4KSwgImNh bid0IGdldCBFbGVtZW50IHNlY3Rpb24ncyAiLCBlbGVtZW50TnVtLCAidGggZWxlbWVudCdzICIs IGluZGV4LCAidGggaW5kZXgiKTsKLSAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVu Y3Rpb25JbmRleCA+PSBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpLCAiRWxlbWVu dCBzZWN0aW9uJ3MgIiwgZWxlbWVudE51bSwgInRoIGVsZW1lbnQncyAiLCBpbmRleCwgInRoIGlu ZGV4IGlzICIsIGZ1bmN0aW9uSW5kZXgsICIgd2hpY2ggZXhjZWVkcyB0aGUgZnVuY3Rpb24gaW5k ZXggc3BhY2Ugc2l6ZSBvZiAiLCBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpKTsK KyAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVuY3Rpb25JbmRleCA+PSBtX3Jlc3Vs dC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSwgIkVsZW1lbnQgc2VjdGlvbidzICIs IGVsZW1lbnROdW0sICJ0aCBlbGVtZW50J3MgIiwgaW5kZXgsICJ0aCBpbmRleCBpcyAiLCBmdW5j dGlvbkluZGV4LCAiIHdoaWNoIGV4Y2VlZHMgdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlIHNpemUg b2YgIiwgbV9yZXN1bHQubW9kdWxlLT5mdW5jdGlvbkluZGV4U3BhY2VTaXplKCkpOwogCiAgICAg ICAgICAgICBlbGVtZW50LmZ1bmN0aW9uSW5kaWNlcy51bmNoZWNrZWRBcHBlbmQoZnVuY3Rpb25J bmRleCk7CiAgICAgICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21Nb2R1bGVQYXJzZXIuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1 bGVQYXJzZXIuaAppbmRleCA5NmMwNGQ0Li5lY2M0NzM5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmgKKysrIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5oCkBAIC0zNiw3ICszNiw2IEBAIG5hbWVzcGFj ZSBKU0MgeyBuYW1lc3BhY2UgV2FzbSB7CiAKIHN0cnVjdCBNb2R1bGVQYXJzZXJSZXN1bHQgewog ICAgIHN0ZDo6dW5pcXVlX3B0cjxNb2R1bGVJbmZvcm1hdGlvbj4gbW9kdWxlOwotICAgIEZ1bmN0 aW9uSW5kZXhTcGFjZSBmdW5jdGlvbkluZGV4U3BhY2U7CiAgICAgVmVjdG9yPEZ1bmN0aW9uTG9j YXRpb25JbkJpbmFyeT4gZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5OwogfTsKIApkaWZmIC0tZ2l0 IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uY3BwIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uY3BwCmluZGV4IGM4NTMxYzguLmRmNTM0MDIgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmNwcAorKysgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5jcHAKQEAgLTc2LDggKzc2LDYgQEAgYm9v bCBQbGFuOjpwYXJzZUFuZFZhbGlkYXRlTW9kdWxlKCkKICAgICAgICAgfQogICAgICAgICBtX21v ZHVsZUluZm9ybWF0aW9uID0gV1RGTW92ZShwYXJzZVJlc3VsdC0+bW9kdWxlKTsKICAgICAgICAg bV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkgPSBXVEZNb3ZlKHBhcnNlUmVzdWx0LT5mdW5jdGlv bkxvY2F0aW9uSW5CaW5hcnkpOwotICAgICAgICBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5zaXplID0g cGFyc2VSZXN1bHQtPmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCk7Ci0gICAgICAgIG1fZnVuY3Rp b25JbmRleFNwYWNlLmJ1ZmZlciA9IHBhcnNlUmVzdWx0LT5mdW5jdGlvbkluZGV4U3BhY2UucmVs ZWFzZUJ1ZmZlcigpOwogICAgIH0KIAogICAgIGZvciAodW5zaWduZWQgZnVuY3Rpb25JbmRleCA9 IDA7IGZ1bmN0aW9uSW5kZXggPCBtX2Z1bmN0aW9uTG9jYXRpb25JbkJpbmFyeS5zaXplKCk7ICsr ZnVuY3Rpb25JbmRleCkgewpAQCAtODksNyArODcsNyBAQCBib29sIFBsYW46OnBhcnNlQW5kVmFs aWRhdGVNb2R1bGUoKQogICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1f bW9kdWxlSW5mb3JtYXRpb24tPmludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzW2Z1bmN0 aW9uSW5kZXhdOwogICAgICAgICBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFNpZ25hdHVy ZUluZm9ybWF0aW9uOjpnZXQobV92bSwgc2lnbmF0dXJlSW5kZXgpOwogCi0gICAgICAgIGF1dG8g dmFsaWRhdGlvblJlc3VsdCA9IHZhbGlkYXRlRnVuY3Rpb24obV92bSwgZnVuY3Rpb25TdGFydCwg ZnVuY3Rpb25MZW5ndGgsIHNpZ25hdHVyZSwgbV9mdW5jdGlvbkluZGV4U3BhY2UsICptX21vZHVs ZUluZm9ybWF0aW9uKTsKKyAgICAgICAgYXV0byB2YWxpZGF0aW9uUmVzdWx0ID0gdmFsaWRhdGVG dW5jdGlvbihtX3ZtLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCAq bV9tb2R1bGVJbmZvcm1hdGlvbik7CiAgICAgICAgIGlmICghdmFsaWRhdGlvblJlc3VsdCkgewog ICAgICAgICAgICAgaWYgKHZlcmJvc2UpIHsKICAgICAgICAgICAgICAgICBmb3IgKHVuc2lnbmVk IGkgPSAwOyBpIDwgZnVuY3Rpb25MZW5ndGg7ICsraSkKQEAgLTEyNyw3ICsxMjUsNyBAQCB2b2lk IFBsYW46OnJ1bigpCiAgICAgICAgIHJldHVybiB0cnVlOwogICAgIH07CiAKLSAgICBpZiAoIXRy eVJlc2VydmVDYXBhY2l0eShtX3dhc21Ub0pTU3R1YnMsIG1fbW9kdWxlSW5mb3JtYXRpb24tPmlt cG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICIgV2ViQXNzZW1ibHkgdG8gSmF2 YVNjcmlwdCBzdHVicyIpCisgICAgaWYgKCF0cnlSZXNlcnZlQ2FwYWNpdHkobV93YXNtRXhpdFN0 dWJzLCBtX21vZHVsZUluZm9ybWF0aW9uLT5pbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMu c2l6ZSgpLCAiIFdlYkFzc2VtYmx5IHRvIEphdmFTY3JpcHQgc3R1YnMiKQogICAgICAgICB8fCAh dHJ5UmVzZXJ2ZUNhcGFjaXR5KG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIG1fZnVuY3Rpb25M b2NhdGlvbkluQmluYXJ5LnNpemUoKSwgIiB1bmxpbmtlZCBXZWJBc3NlbWJseSB0byBXZWJBc3Nl bWJseSBjYWxscyIpCiAgICAgICAgIHx8ICF0cnlSZXNlcnZlQ2FwYWNpdHkobV93YXNtSW50ZXJu YWxGdW5jdGlvbnMsIG1fZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5LnNpemUoKSwgIiBXZWJBc3Nl bWJseSBmdW5jdGlvbnMiKQogICAgICAgICB8fCAhdHJ5UmVzZXJ2ZUNhcGFjaXR5KG1fY29tcGls YXRpb25Db250ZXh0cywgbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgpLCAiIGNvbXBp bGF0aW9uIGNvbnRleHRzIikpCkBAIC0xNDEsMTIgKzEzOSwxMSBAQCB2b2lkIFBsYW46OnJ1bigp CiAgICAgICAgIEltcG9ydCogaW1wb3J0ID0gJm1fbW9kdWxlSW5mb3JtYXRpb24tPmltcG9ydHNb aW1wb3J0SW5kZXhdOwogICAgICAgICBpZiAoaW1wb3J0LT5raW5kICE9IEV4dGVybmFsS2luZDo6 RnVuY3Rpb24pCiAgICAgICAgICAgICBjb250aW51ZTsKLSAgICAgICAgdW5zaWduZWQgaW1wb3J0 RnVuY3Rpb25JbmRleCA9IG1fd2FzbVRvSlNTdHVicy5zaXplKCk7CisgICAgICAgIHVuc2lnbmVk IGltcG9ydEZ1bmN0aW9uSW5kZXggPSBtX3dhc21FeGl0U3R1YnMuc2l6ZSgpOwogICAgICAgICBp ZiAodmVyYm9zZSkKICAgICAgICAgICAgIGRhdGFMb2dMbigiUHJvY2Vzc2luZyBpbXBvcnQgZnVu Y3Rpb24gbnVtYmVyICIsIGltcG9ydEZ1bmN0aW9uSW5kZXgsICI6ICIsIGltcG9ydC0+bW9kdWxl LCAiOiAiLCBpbXBvcnQtPmZpZWxkKTsKICAgICAgICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJl SW5kZXggPSBtX21vZHVsZUluZm9ybWF0aW9uLT5pbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGlj ZXMuYXQoaW1wb3J0LT5raW5kSW5kZXgpOwotICAgICAgICBtX3dhc21Ub0pTU3R1YnMudW5jaGVj a2VkQXBwZW5kKGltcG9ydFN0dWJHZW5lcmF0b3IobV92bSwgbV9jYWxsTGlua0luZm9zLCBzaWdu YXR1cmVJbmRleCwgaW1wb3J0RnVuY3Rpb25JbmRleCkpOwotICAgICAgICBtX2Z1bmN0aW9uSW5k ZXhTcGFjZS5idWZmZXIuZ2V0KClbaW1wb3J0RnVuY3Rpb25JbmRleF0uY29kZSA9IG1fd2FzbVRv SlNTdHVic1tpbXBvcnRGdW5jdGlvbkluZGV4XS5jb2RlKCkuZXhlY3V0YWJsZUFkZHJlc3MoKTsK KyAgICAgICAgbV93YXNtRXhpdFN0dWJzLnVuY2hlY2tlZEFwcGVuZChleGl0U3R1YkdlbmVyYXRv cihtX3ZtLCBtX2NhbGxMaW5rSW5mb3MsIHNpZ25hdHVyZUluZGV4LCBpbXBvcnRGdW5jdGlvbklu ZGV4KSk7CiAgICAgfQogCiAgICAgbV9jdXJyZW50SW5kZXggPSAwOwpAQCAtMTY3LDEyICsxNjQs MTIgQEAgdm9pZCBQbGFuOjpydW4oKQogICAgICAgICAgICAgQVNTRVJUKGZ1bmN0aW9uTGVuZ3Ro IDw9IG1fc291cmNlTGVuZ3RoKTsKICAgICAgICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVy ZUluZGV4ID0gbV9tb2R1bGVJbmZvcm1hdGlvbi0+aW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUlu ZGljZXNbZnVuY3Rpb25JbmRleF07CiAgICAgICAgICAgICBjb25zdCBTaWduYXR1cmUqIHNpZ25h dHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgc2lnbmF0dXJlSW5kZXgpOwot ICAgICAgICAgICAgdW5zaWduZWQgZnVuY3Rpb25JbmRleFNwYWNlID0gbV93YXNtVG9KU1N0dWJz LnNpemUoKSArIGZ1bmN0aW9uSW5kZXg7Ci0gICAgICAgICAgICBBU1NFUlRfVU5VU0VEKGZ1bmN0 aW9uSW5kZXhTcGFjZSwgbV9mdW5jdGlvbkluZGV4U3BhY2UuYnVmZmVyLmdldCgpW2Z1bmN0aW9u SW5kZXhTcGFjZV0uc2lnbmF0dXJlSW5kZXggPT0gc2lnbmF0dXJlSW5kZXgpOwotICAgICAgICAg ICAgQVNTRVJUKHZhbGlkYXRlRnVuY3Rpb24obV92bSwgZnVuY3Rpb25TdGFydCwgZnVuY3Rpb25M ZW5ndGgsIHNpZ25hdHVyZSwgbV9mdW5jdGlvbkluZGV4U3BhY2UsICptX21vZHVsZUluZm9ybWF0 aW9uKSk7CisgICAgICAgICAgICB1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2UgPSBtX3dhc21F eGl0U3R1YnMuc2l6ZSgpICsgZnVuY3Rpb25JbmRleDsKKyAgICAgICAgICAgIEFTU0VSVF9VTlVT RUQoZnVuY3Rpb25JbmRleFNwYWNlLCBtX21vZHVsZUluZm9ybWF0aW9uLT5zaWduYXR1cmVJbmRl eEZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleFNwYWNlKSA9PSBzaWduYXR1cmVJ bmRleCk7CisgICAgICAgICAgICBBU1NFUlQodmFsaWRhdGVGdW5jdGlvbihtX3ZtLCBmdW5jdGlv blN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCAqbV9tb2R1bGVJbmZvcm1hdGlvbikp OwogCiAgICAgICAgICAgICBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzW2Z1bmN0aW9uSW5kZXhd ID0gVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+KCk7Ci0gICAgICAgICAgICBhdXRvIHBh cnNlQW5kQ29tcGlsZVJlc3VsdCA9IHBhcnNlQW5kQ29tcGlsZSgqbV92bSwgbV9jb21waWxhdGlv bkNvbnRleHRzW2Z1bmN0aW9uSW5kZXhdLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwg c2lnbmF0dXJlLCBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzW2Z1bmN0aW9uSW5kZXhdLCBtX2Z1 bmN0aW9uSW5kZXhTcGFjZSwgKm1fbW9kdWxlSW5mb3JtYXRpb24pOworICAgICAgICAgICAgYXV0 byBwYXJzZUFuZENvbXBpbGVSZXN1bHQgPSBwYXJzZUFuZENvbXBpbGUoKm1fdm0sIG1fY29tcGls YXRpb25Db250ZXh0c1tmdW5jdGlvbkluZGV4XSwgZnVuY3Rpb25TdGFydCwgZnVuY3Rpb25MZW5n dGgsIHNpZ25hdHVyZSwgbV91bmxpbmtlZFdhc21Ub1dhc21DYWxsc1tmdW5jdGlvbkluZGV4XSwg Km1fbW9kdWxlSW5mb3JtYXRpb24pOwogCiAgICAgICAgICAgICBpZiAoVU5MSUtFTFkoIXBhcnNl QW5kQ29tcGlsZVJlc3VsdCkpIHsKICAgICAgICAgICAgICAgICBhdXRvIGxvY2tlciA9IGhvbGRM b2NrKG1fbG9jayk7CkBAIC0yMjMsOSArMjIwLDYgQEAgdm9pZCBQbGFuOjpydW4oKQogICAgICAg ICAgICAgICAgICAgICBzdGQ6Om1ha2VfdW5pcXVlPEIzOjpDb21waWxhdGlvbj4oRklOQUxJWkVf Q09ERShsaW5rQnVmZmVyLCAoIldhc20gSlMgZW50cnlwb2ludCIpKSwgV1RGTW92ZShjb250ZXh0 LmpzRW50cnlwb2ludEJ5cHJvZHVjdHMpKTsKICAgICAgICAgICAgIH0KICAgICAgICAgfQotCi0g ICAgICAgIHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFjZSA9IG1fd2FzbVRvSlNTdHVicy5zaXpl KCkgKyBmdW5jdGlvbkluZGV4OwotICAgICAgICBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5idWZmZXIu Z2V0KClbZnVuY3Rpb25JbmRleFNwYWNlXS5jb2RlID0gbV93YXNtSW50ZXJuYWxGdW5jdGlvbnNb ZnVuY3Rpb25JbmRleF0tPndhc21FbnRyeXBvaW50LmNvbXBpbGF0aW9uLT5jb2RlKCkuZXhlY3V0 YWJsZUFkZHJlc3MoKTsKICAgICB9CiAKICAgICBpZiAodmVyYm9zZSB8fCBPcHRpb25zOjpyZXBv cnRDb21waWxlVGltZXMoKSkgewpAQCAtMjM1LDggKzIyOSwxOSBAQCB2b2lkIFBsYW46OnJ1bigp CiAKICAgICAvLyBQYXRjaCB0aGUgY2FsbCBzaXRlcyBmb3IgZWFjaCBXZWJBc3NlbWJseSBmdW5j dGlvbi4KICAgICBmb3IgKGF1dG8mIHVubGlua2VkIDogbV91bmxpbmtlZFdhc21Ub1dhc21DYWxs cykgewotICAgICAgICBmb3IgKGF1dG8mIGNhbGwgOiB1bmxpbmtlZCkKLSAgICAgICAgICAgIE1h Y3JvQXNzZW1ibGVyOjpyZXBhdGNoQ2FsbChjYWxsLmNhbGxMb2NhdGlvbiwgQ29kZUxvY2F0aW9u TGFiZWwobV9mdW5jdGlvbkluZGV4U3BhY2UuYnVmZmVyLmdldCgpW2NhbGwuZnVuY3Rpb25JbmRl eF0uY29kZSkpOworICAgICAgICBmb3IgKGF1dG8mIGNhbGwgOiB1bmxpbmtlZCkgeworICAgICAg ICAgICAgdm9pZCogZXhlY3V0YWJsZUFkZHJlc3M7CisgICAgICAgICAgICBpZiAobV9tb2R1bGVJ bmZvcm1hdGlvbi0+aXNJbXBvcnRlZEZ1bmN0aW9uRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShjYWxs LmZ1bmN0aW9uSW5kZXgpKSB7CisgICAgICAgICAgICAgICAgLy8gRklYTUUgaW1wb3J0cyBjb3Vs ZCBoYXZlIGJlZW4gbGlua2VkIGluIEIzLCBpbnN0ZWFkIG9mIGdlbmVyYXRpbmcgYSBwYXRjaHBv aW50LiBUaGlzIGNvbmRpdGlvbiBzaG91bGQgYmUgcmVwbGFjZWQgYnkgYSBSRUxFQVNFX0FTU0VS VC4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NjQ2MgorICAgICAg ICAgICAgICAgIGV4ZWN1dGFibGVBZGRyZXNzID0gY2FsbC50b0pTCisgICAgICAgICAgICAgICAg ICAgID8gbV93YXNtRXhpdFN0dWJzLmF0KGNhbGwuZnVuY3Rpb25JbmRleCkud2FzbVRvSlMuY29k ZSgpLmV4ZWN1dGFibGVBZGRyZXNzKCkKKyAgICAgICAgICAgICAgICAgICAgOiBtX3dhc21FeGl0 U3R1YnMuYXQoY2FsbC5mdW5jdGlvbkluZGV4KS53YXNtVG9XYXNtLmNvZGUoKS5leGVjdXRhYmxl QWRkcmVzcygpOworICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICBBU1NFUlQo IWNhbGwudG9KUyk7CisgICAgICAgICAgICAgICAgZXhlY3V0YWJsZUFkZHJlc3MgPSBtX3dhc21J bnRlcm5hbEZ1bmN0aW9ucy5hdChjYWxsLmZ1bmN0aW9uSW5kZXggLSBtX3dhc21FeGl0U3R1YnMu c2l6ZSgpKS0+d2FzbUVudHJ5cG9pbnQuY29tcGlsYXRpb24tPmNvZGUoKS5leGVjdXRhYmxlQWRk cmVzcygpOworICAgICAgICAgICAgfQorICAgICAgICAgICAgTWFjcm9Bc3NlbWJsZXI6OnJlcGF0 Y2hDYWxsKGNhbGwuY2FsbExvY2F0aW9uLCBDb2RlTG9jYXRpb25MYWJlbChleGVjdXRhYmxlQWRk cmVzcykpOworICAgICAgICB9CiAgICAgfQogCiAgICAgbV9mYWlsZWQgPSBmYWxzZTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmggYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5oCmluZGV4IDNiYjAxYzguLjgzMTU5NjUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmgKKysrIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uaApAQCAtODYsMjYgKzg2LDE5IEBAIHB1Ymxp YzoKICAgICAgICAgcmV0dXJuIFdURk1vdmUobV9jYWxsTGlua0luZm9zKTsKICAgICB9CiAKLSAg ICBWZWN0b3I8V2FzbVRvSlNTdHViPiYmIHRha2VXYXNtVG9KU1N0dWJzKCkKKyAgICBWZWN0b3I8 V2FzbUV4aXRTdHVicz4mJiB0YWtlV2FzbUV4aXRTdHVicygpCiAgICAgewogICAgICAgICBSRUxF QVNFX0FTU0VSVCghZmFpbGVkKCkpOwotICAgICAgICByZXR1cm4gV1RGTW92ZShtX3dhc21Ub0pT U3R1YnMpOwotICAgIH0KLQotICAgIEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmIHRha2VG dW5jdGlvbkluZGV4U3BhY2UoKQotICAgIHsKLSAgICAgICAgUkVMRUFTRV9BU1NFUlQoIWZhaWxl ZCgpKTsKLSAgICAgICAgcmV0dXJuIFdURk1vdmUobV9mdW5jdGlvbkluZGV4U3BhY2UpOworICAg ICAgICByZXR1cm4gV1RGTW92ZShtX3dhc21FeGl0U3R1YnMpOwogICAgIH0KIAogcHJpdmF0ZToK ICAgICBzdGQ6OnVuaXF1ZV9wdHI8TW9kdWxlSW5mb3JtYXRpb24+IG1fbW9kdWxlSW5mb3JtYXRp b247CiAgICAgVmVjdG9yPEZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeT4gbV9mdW5jdGlvbkxvY2F0 aW9uSW5CaW5hcnk7CiAgICAgQmFnPENhbGxMaW5rSW5mbz4gbV9jYWxsTGlua0luZm9zOwotICAg IFZlY3RvcjxXYXNtVG9KU1N0dWI+IG1fd2FzbVRvSlNTdHViczsKKyAgICBWZWN0b3I8V2FzbUV4 aXRTdHVicz4gbV93YXNtRXhpdFN0dWJzOwogICAgIFZlY3RvcjxzdGQ6OnVuaXF1ZV9wdHI8V2Fz bUludGVybmFsRnVuY3Rpb24+PiBtX3dhc21JbnRlcm5hbEZ1bmN0aW9uczsKICAgICBWZWN0b3I8 Q29tcGlsYXRpb25Db250ZXh0PiBtX2NvbXBpbGF0aW9uQ29udGV4dHM7Ci0gICAgSW1tdXRhYmxl RnVuY3Rpb25JbmRleFNwYWNlIG1fZnVuY3Rpb25JbmRleFNwYWNlOwogCiAgICAgVk0qIG1fdm07 CiAgICAgVmVjdG9yPFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPj4gbV91bmxpbmtlZFdh c21Ub1dhc21DYWxsczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dh c21TaWduYXR1cmUuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVy ZS5jcHAKaW5kZXggNmQ1YjFmNi4uOTk3YmQwNiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbVNpZ25hdHVyZS5jcHAKQEAgLTQxLDYgKzQxLDE5IEBAIGNvbnN0IGJvb2wgdmVy Ym9zZSA9IGZhbHNlOwogCiBjb25zdCBjb25zdGV4cHIgU2lnbmF0dXJlSW5kZXggU2lnbmF0dXJl OjppbnZhbGlkSW5kZXg7CiAKK1N0cmluZyBTaWduYXR1cmU6OnRvU3RyaW5nKCkgY29uc3QKK3sK KyAgICBTdHJpbmcgcmVzdWx0KG1ha2VTdHJpbmcocmV0dXJuVHlwZSgpKSk7CisgICAgcmVzdWx0 LmFwcGVuZCgiICgiKTsKKyAgICBmb3IgKFNpZ25hdHVyZUFyZ0NvdW50IGFyZyA9IDA7IGFyZyA8 IGFyZ3VtZW50Q291bnQoKTsgKythcmcpIHsKKyAgICAgICAgaWYgKGFyZykKKyAgICAgICAgICAg IHJlc3VsdC5hcHBlbmQoIiwgIik7CisgICAgICAgIHJlc3VsdC5hcHBlbmQobWFrZVN0cmluZyhh cmd1bWVudChhcmcpKSk7CisgICAgfQorICAgIHJlc3VsdC5hcHBlbmQoJyknKTsKKyAgICByZXR1 cm4gcmVzdWx0OworfQorCiB2b2lkIFNpZ25hdHVyZTo6ZHVtcChQcmludFN0cmVhbSYgb3V0KSBj b25zdAogewogICAgIG91dC5wcmludChtYWtlU3RyaW5nKHJldHVyblR5cGUoKSksICIgKCIpOwpk aWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5oIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5oCmluZGV4IDBkNmM3YjUu LjRkNDNmZmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWdu YXR1cmUuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmgK QEAgLTgyLDYgKzgyLDcgQEAgcHVibGljOgogICAgIH0KICAgICBUeXBlIGFyZ3VtZW50KFNpZ25h dHVyZUFyZ0NvdW50IGkpIGNvbnN0IHsgcmV0dXJuIGNvbnN0X2Nhc3Q8U2lnbmF0dXJlKj4odGhp cyktPmFyZ3VtZW50KGkpOyB9CiAKKyAgICBXVEY6OlN0cmluZyB0b1N0cmluZygpIGNvbnN0Owog ICAgIHZvaWQgZHVtcChXVEY6OlByaW50U3RyZWFtJiBvdXQpIGNvbnN0OwogICAgIGJvb2wgb3Bl cmF0b3I9PShjb25zdCBTaWduYXR1cmUmIHJocykgY29uc3QKICAgICB7CmRpZmYgLS1naXQgYS9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmNwcAppbmRleCAyNjEzNzBiLi5hNjg3NDgxIDEw MDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwCisr KyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5jcHAKQEAgLTM2Miwx MCArMzYyLDEwIEBAIHZvaWQgVmFsaWRhdGU6OmR1bXAoY29uc3QgVmVjdG9yPENvbnRyb2xFbnRy eT4mLCBjb25zdCBFeHByZXNzaW9uTGlzdCYpCiAgICAgLy8gVGhpbmsgb2YgdGhpcyBhcyBwZW5h bmNlIGZvciB0aGUgc2luIG9mIGJhZCBlcnJvciBtZXNzYWdlcy4KIH0KIAotRXhwZWN0ZWQ8dm9p ZCwgU3RyaW5nPiB2YWxpZGF0ZUZ1bmN0aW9uKFZNKiB2bSwgY29uc3QgdWludDhfdCogc291cmNl LCBzaXplX3QgbGVuZ3RoLCBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSwgY29uc3QgSW1tdXRh YmxlRnVuY3Rpb25JbmRleFNwYWNlJiBmdW5jdGlvbkluZGV4U3BhY2UsIGNvbnN0IE1vZHVsZUlu Zm9ybWF0aW9uJiBtb2R1bGUpCitFeHBlY3RlZDx2b2lkLCBTdHJpbmc+IHZhbGlkYXRlRnVuY3Rp b24oVk0qIHZtLCBjb25zdCB1aW50OF90KiBzb3VyY2UsIHNpemVfdCBsZW5ndGgsIGNvbnN0IFNp Z25hdHVyZSogc2lnbmF0dXJlLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgbW9kdWxlKQogewog ICAgIFZhbGlkYXRlIGNvbnRleHQobW9kdWxlKTsKLSAgICBGdW5jdGlvblBhcnNlcjxWYWxpZGF0 ZT4gdmFsaWRhdG9yKHZtLCBjb250ZXh0LCBzb3VyY2UsIGxlbmd0aCwgc2lnbmF0dXJlLCBmdW5j dGlvbkluZGV4U3BhY2UsIG1vZHVsZSk7CisgICAgRnVuY3Rpb25QYXJzZXI8VmFsaWRhdGU+IHZh bGlkYXRvcih2bSwgY29udGV4dCwgc291cmNlLCBsZW5ndGgsIHNpZ25hdHVyZSwgbW9kdWxlKTsK ICAgICBXQVNNX0ZBSUxfSUZfSEVMUEVSX0ZBSUxTKHZhbGlkYXRvci5wYXJzZSgpKTsKICAgICBy ZXR1cm4geyB9OwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bVZhbGlkYXRlLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuaApp bmRleCAxNDgyMWYyLi5lYjFhZDhjIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9XYXNtVmFsaWRhdGUuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt VmFsaWRhdGUuaApAQCAtMzYsNyArMzYsNyBAQCBjbGFzcyBWTTsKIAogbmFtZXNwYWNlIFdhc20g ewogCi1FeHBlY3RlZDx2b2lkLCBTdHJpbmc+IHZhbGlkYXRlRnVuY3Rpb24oVk0qLCBjb25zdCB1 aW50OF90Kiwgc2l6ZV90LCBjb25zdCBTaWduYXR1cmUqLCBjb25zdCBJbW11dGFibGVGdW5jdGlv bkluZGV4U3BhY2UmLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYpOworRXhwZWN0ZWQ8dm9pZCwg U3RyaW5nPiB2YWxpZGF0ZUZ1bmN0aW9uKFZNKiwgY29uc3QgdWludDhfdCosIHNpemVfdCwgY29u c3QgU2lnbmF0dXJlKiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mKTsKIAogfSB9IC8vIG5hbWVz cGFjZSBKU0M6Oldhc20KIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v anMvSlNXZWJBc3NlbWJseUluc3RhbmNlLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9q cy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaAppbmRleCBmMzRiMDUyLi45OWEyYzkwIDEwMDY0NAot LS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2Uu aAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFu Y2UuaApAQCAtODYsOCArODYsMTEgQEAgcHVibGljOgogICAgICAgICByZXR1cm4gb2Zmc2V0T2ZJ bXBvcnRGdW5jdGlvbnMoKSArIHNpemVvZihXcml0ZUJhcnJpZXI8SlNDZWxsPikgKiBpZHg7CiAg ICAgfQogCisgICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZk1lbW9yeSgpIHsgcmV0dXJuIE9C SkVDVF9PRkZTRVRPRihKU1dlYkFzc2VtYmx5SW5zdGFuY2UsIG1fbWVtb3J5KTsgfQogICAgIHN0 YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZUYWJsZSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihK U1dlYkFzc2VtYmx5SW5zdGFuY2UsIG1fdGFibGUpOyB9CiAgICAgc3RhdGljIHB0cmRpZmZfdCBv ZmZzZXRPZkdsb2JhbHMoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseUlu c3RhbmNlLCBtX2dsb2JhbHMpOyB9CisgICAgc3RhdGljIHNpemVfdCBvZmZzZXRPZkltcG9ydEZ1 bmN0aW9ucygpIHsgcmV0dXJuIFdURjo6cm91bmRVcFRvTXVsdGlwbGVPZjxzaXplb2YoV3JpdGVC YXJyaWVyPEpTQ2VsbD4pPihzaXplb2YoSlNXZWJBc3NlbWJseUluc3RhbmNlKSk7IH0KKyAgICBz dGF0aWMgc2l6ZV90IG9mZnNldE9mSW1wb3J0RnVuY3Rpb24oc2l6ZV90IGltcG9ydEZ1bmN0aW9u TnVtKSB7IHJldHVybiBvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucygpICsgaW1wb3J0RnVuY3Rpb25O dW0gKiBzaXplb2Yoc2l6ZW9mKFdyaXRlQmFycmllcjxKU0NlbGw+KSk7IH0KIAogcHJvdGVjdGVk OgogICAgIEpTV2ViQXNzZW1ibHlJbnN0YW5jZShWTSYsIFN0cnVjdHVyZSosIHVuc2lnbmVkIG51 bUltcG9ydEZ1bmN0aW9ucyk7CkBAIC05NSwxMSArOTgsNiBAQCBwcm90ZWN0ZWQ6CiAgICAgc3Rh dGljIHZvaWQgZGVzdHJveShKU0NlbGwqKTsKICAgICBzdGF0aWMgdm9pZCB2aXNpdENoaWxkcmVu KEpTQ2VsbCosIFNsb3RWaXNpdG9yJik7CiAKLSAgICBzdGF0aWMgc2l6ZV90IG9mZnNldE9mSW1w b3J0RnVuY3Rpb25zKCkKLSAgICB7Ci0gICAgICAgIHJldHVybiBXVEY6OnJvdW5kVXBUb011bHRp cGxlT2Y8c2l6ZW9mKFdyaXRlQmFycmllcjxKU0NlbGw+KT4oc2l6ZW9mKEpTV2ViQXNzZW1ibHlJ bnN0YW5jZSkpOwotICAgIH0KLQogICAgIHN0YXRpYyBzaXplX3QgYWxsb2NhdGlvblNpemUodW5z aWduZWQgbnVtSW1wb3J0RnVuY3Rpb25zKQogICAgIHsKICAgICAgICAgcmV0dXJuIG9mZnNldE9m SW1wb3J0RnVuY3Rpb25zKCkgKyBzaXplb2YoV3JpdGVCYXJyaWVyPEpTQ2VsbD4pICogbnVtSW1w b3J0RnVuY3Rpb25zOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMv SlNXZWJBc3NlbWJseU1lbW9yeS5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9K U1dlYkFzc2VtYmx5TWVtb3J5LmNwcAppbmRleCBiYzQ0OWE4Li40NTFiZjc5IDEwMDY0NAotLS0g YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNwcAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNw cApAQCAtMzcsOSArMzcsOSBAQCBuYW1lc3BhY2UgSlNDIHsKIAogY29uc3QgQ2xhc3NJbmZvIEpT V2ViQXNzZW1ibHlNZW1vcnk6OnNfaW5mbyA9IHsgIldlYkFzc2VtYmx5Lk1lbW9yeSIsICZCYXNl OjpzX2luZm8sIDAsIENSRUFURV9NRVRIT0RfVEFCTEUoSlNXZWJBc3NlbWJseU1lbW9yeSkgfTsK IAotSlNXZWJBc3NlbWJseU1lbW9yeSogSlNXZWJBc3NlbWJseU1lbW9yeTo6Y3JlYXRlKFZNJiB2 bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+JiYg bWVtb3J5KQorSlNXZWJBc3NlbWJseU1lbW9yeSogSlNXZWJBc3NlbWJseU1lbW9yeTo6Y3JlYXRl KFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIFdhc206Ok1lbW9yeSYmIG1lbW9yeSkKIHsK LSAgICBhdXRvKiBpbnN0YW5jZSA9IG5ldyAoTm90TnVsbCwgYWxsb2NhdGVDZWxsPEpTV2ViQXNz ZW1ibHlNZW1vcnk+KHZtLmhlYXApKSBKU1dlYkFzc2VtYmx5TWVtb3J5KHZtLCBzdHJ1Y3R1cmUs IFdURk1vdmUobWVtb3J5KSk7CisgICAgYXV0byogaW5zdGFuY2UgPSBuZXcgKE5vdE51bGwsIGFs bG9jYXRlQ2VsbDxKU1dlYkFzc2VtYmx5TWVtb3J5Pih2bS5oZWFwKSkgSlNXZWJBc3NlbWJseU1l bW9yeSh2bSwgc3RydWN0dXJlLCBzdGQ6OmZvcndhcmQ8V2FzbTo6TWVtb3J5PihtZW1vcnkpKTsK ICAgICBpbnN0YW5jZS0+ZmluaXNoQ3JlYXRpb24odm0pOwogICAgIHJldHVybiBpbnN0YW5jZTsK IH0KQEAgLTQ5LDcgKzQ5LDcgQEAgU3RydWN0dXJlKiBKU1dlYkFzc2VtYmx5TWVtb3J5OjpjcmVh dGVTdHJ1Y3R1cmUoVk0mIHZtLCBKU0dsb2JhbE9iamVjdCogZ2xvYmFsT2IKICAgICByZXR1cm4g U3RydWN0dXJlOjpjcmVhdGUodm0sIGdsb2JhbE9iamVjdCwgcHJvdG90eXBlLCBUeXBlSW5mbyhP YmplY3RUeXBlLCBTdHJ1Y3R1cmVGbGFncyksIGluZm8oKSk7CiB9CiAKLUpTV2ViQXNzZW1ibHlN ZW1vcnk6OkpTV2ViQXNzZW1ibHlNZW1vcnkoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwg c3RkOjp1bmlxdWVfcHRyPFdhc206Ok1lbW9yeT4mJiBtZW1vcnkpCitKU1dlYkFzc2VtYmx5TWVt b3J5OjpKU1dlYkFzc2VtYmx5TWVtb3J5KFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIFdh c206Ok1lbW9yeSYmIG1lbW9yeSkKICAgICA6IEJhc2Uodm0sIHN0cnVjdHVyZSkKICAgICAsIG1f bWVtb3J5KFdURk1vdmUobWVtb3J5KSkKIHsKQEAgLTYzLDcgKzYzLDcgQEAgSlNBcnJheUJ1ZmZl ciogSlNXZWJBc3NlbWJseU1lbW9yeTo6YnVmZmVyKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGds b2JhbE9iamVjdCkKICAgICBhdXRvIGRlc3RydWN0b3IgPSBbXSAodm9pZCopIHsKICAgICAgICAg Ly8gV2UgZG9uJ3QgbmVlZCB0byBkbyBhbnl0aGluZyBoZXJlIHRvIGRlc3Ryb3kgdGhlIG1lbW9y eS4KICAgICAgICAgLy8gVGhlIEFycmF5QnVmZmVyIGJhY2tpbmcgdGhlIEpTQXJyYXlCdWZmZXIg aXMgb25seSBvd25lZCBieSB1cywKLSAgICAgICAgLy8gc28gd2UgZ3VhcmFudGVlIGl0cyBsaWZl Y3lsY2UuCisgICAgICAgIC8vIHNvIHdlIGd1YXJhbnRlZSBpdHMgbGlmZWN5Y2xlLgogICAgIH07 CiAgICAgbV9idWZmZXIgPSBBcnJheUJ1ZmZlcjo6Y3JlYXRlRnJvbUJ5dGVzKG1lbW9yeSgpLT5t ZW1vcnkoKSwgbWVtb3J5KCktPnNpemUoKSwgV1RGTW92ZShkZXN0cnVjdG9yKSk7CiAgICAgbV9i dWZmZXJXcmFwcGVyLnNldCh2bSwgdGhpcywgSlNBcnJheUJ1ZmZlcjo6Y3JlYXRlKHZtLCBnbG9i YWxPYmplY3QtPm1fYXJyYXlCdWZmZXJTdHJ1Y3R1cmUuZ2V0KCksIG1fYnVmZmVyLmdldCgpKSk7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5 TWVtb3J5LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVt b3J5LmgKaW5kZXggMWQ0M2M5NS4uNmMyNjRjOCAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5oCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuaApAQCAtNDEsMjEgKzQxLDI0IEBA IGNsYXNzIEpTV2ViQXNzZW1ibHlNZW1vcnkgOiBwdWJsaWMgSlNEZXN0cnVjdGlibGVPYmplY3Qg ewogcHVibGljOgogICAgIHR5cGVkZWYgSlNEZXN0cnVjdGlibGVPYmplY3QgQmFzZTsKIAotICAg IHN0YXRpYyBKU1dlYkFzc2VtYmx5TWVtb3J5KiBjcmVhdGUoVk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6 OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiYmKTsKKyAgICBzdGF0aWMgSlNXZWJBc3NlbWJseU1l bW9yeSogY3JlYXRlKFZNJiwgU3RydWN0dXJlKiwgV2FzbTo6TWVtb3J5JiYpOwogICAgIHN0YXRp YyBTdHJ1Y3R1cmUqIGNyZWF0ZVN0cnVjdHVyZShWTSYsIEpTR2xvYmFsT2JqZWN0KiwgSlNWYWx1 ZSk7CiAKICAgICBERUNMQVJFX0lORk87CiAKLSAgICBXYXNtOjpNZW1vcnkqIG1lbW9yeSgpIHsg cmV0dXJuIG1fbWVtb3J5LmdldCgpOyB9CisgICAgV2FzbTo6TWVtb3J5KiBtZW1vcnkoKSB7IHJl dHVybiAmbV9tZW1vcnk7IH0KICAgICBKU0FycmF5QnVmZmVyKiBidWZmZXIoVk0mIHZtLCBKU0ds b2JhbE9iamVjdCopOwogCisgICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZk1lbW9yeSgpIHsg cmV0dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFzc2VtYmx5TWVtb3J5LCBtX21lbW9yeSkgKyBX YXNtOjpNZW1vcnk6Om9mZnNldE9mTWVtb3J5KCk7IH0KKyAgICBzdGF0aWMgcHRyZGlmZl90IG9m ZnNldE9mU2l6ZSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFzc2VtYmx5TWVtb3J5 LCBtX21lbW9yeSkgKyBXYXNtOjpNZW1vcnk6Om9mZnNldE9mU2l6ZSgpOyB9CisKIHByb3RlY3Rl ZDoKLSAgICBKU1dlYkFzc2VtYmx5TWVtb3J5KFZNJiwgU3RydWN0dXJlKiwgc3RkOjp1bmlxdWVf cHRyPFdhc206Ok1lbW9yeT4mJik7CisgICAgSlNXZWJBc3NlbWJseU1lbW9yeShWTSYsIFN0cnVj dHVyZSosIFdhc206Ok1lbW9yeSYmKTsKICAgICB2b2lkIGZpbmlzaENyZWF0aW9uKFZNJik7CiAg ICAgc3RhdGljIHZvaWQgZGVzdHJveShKU0NlbGwqKTsKICAgICBzdGF0aWMgdm9pZCB2aXNpdENo aWxkcmVuKEpTQ2VsbCosIFNsb3RWaXNpdG9yJik7CiAKLSAgICBzdGQ6OnVuaXF1ZV9wdHI8V2Fz bTo6TWVtb3J5PiBtX21lbW9yeTsKKyAgICBXYXNtOjpNZW1vcnkgbV9tZW1vcnk7CiAgICAgV3Jp dGVCYXJyaWVyPEpTQXJyYXlCdWZmZXI+IG1fYnVmZmVyV3JhcHBlcjsKICAgICBSZWZQdHI8QXJy YXlCdWZmZXI+IG1fYnVmZmVyOwogfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5jcHAKaW5kZXggZDY1MjRjNS4uZmEwZTg1OSAx MDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1v ZHVsZS5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJs eU1vZHVsZS5jcHAKQEAgLTM4LDkgKzM4LDkgQEAgbmFtZXNwYWNlIEpTQyB7CiAKIGNvbnN0IENs YXNzSW5mbyBKU1dlYkFzc2VtYmx5TW9kdWxlOjpzX2luZm8gPSB7ICJXZWJBc3NlbWJseS5Nb2R1 bGUiLCAmQmFzZTo6c19pbmZvLCBudWxscHRyLCBDUkVBVEVfTUVUSE9EX1RBQkxFKEpTV2ViQXNz ZW1ibHlNb2R1bGUpIH07CiAKLUpTV2ViQXNzZW1ibHlNb2R1bGUqIEpTV2ViQXNzZW1ibHlNb2R1 bGU6OmNyZWF0ZShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8 V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYgbW9kdWxlSW5mb3JtYXRpb24sIEJhZzxDYWxsTGlu a0luZm8+JiYgY2FsbExpbmtJbmZvcywgVmVjdG9yPFdhc206Oldhc21Ub0pTU3R1Yj4mJiB3YXNt VG9KU1N0dWJzLCBXYXNtOjpJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmJiBmdW5jdGlvbklu ZGV4U3BhY2UsIFN5bWJvbFRhYmxlKiBleHBvcnRTeW1ib2xUYWJsZSwgdW5zaWduZWQgY2FsbGVl Q291bnQpCitKU1dlYkFzc2VtYmx5TW9kdWxlKiBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGUo Vk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVs ZUluZm9ybWF0aW9uPiYmIG1vZHVsZUluZm9ybWF0aW9uLCBCYWc8Q2FsbExpbmtJbmZvPiYmIGNh bGxMaW5rSW5mb3MsIFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPiYmIHdhc21FeGl0U3R1YnMs IFN5bWJvbFRhYmxlKiBleHBvcnRTeW1ib2xUYWJsZSwgdW5zaWduZWQgY2FsbGVlQ291bnQpCiB7 Ci0gICAgYXV0byogaW5zdGFuY2UgPSBuZXcgKE5vdE51bGwsIGFsbG9jYXRlQ2VsbDxKU1dlYkFz c2VtYmx5TW9kdWxlPih2bS5oZWFwLCBhbGxvY2F0aW9uU2l6ZShjYWxsZWVDb3VudCkpKSBKU1dl YkFzc2VtYmx5TW9kdWxlKHZtLCBzdHJ1Y3R1cmUsIHN0ZDo6Zm9yd2FyZDxzdGQ6OnVuaXF1ZV9w dHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+Pihtb2R1bGVJbmZvcm1hdGlvbiksIHN0ZDo6Zm9y d2FyZDxCYWc8Q2FsbExpbmtJbmZvPj4oY2FsbExpbmtJbmZvcyksIHN0ZDo6Zm9yd2FyZDxWZWN0 b3I8V2FzbTo6V2FzbVRvSlNTdHViPj4od2FzbVRvSlNTdHVicyksIHN0ZDo6Zm9yd2FyZDxXYXNt OjpJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2U+KGZ1bmN0aW9uSW5kZXhTcGFjZSksIGNhbGxl ZUNvdW50KTsKKyAgICBhdXRvKiBpbnN0YW5jZSA9IG5ldyAoTm90TnVsbCwgYWxsb2NhdGVDZWxs PEpTV2ViQXNzZW1ibHlNb2R1bGU+KHZtLmhlYXAsIGFsbG9jYXRpb25TaXplKGNhbGxlZUNvdW50 KSkpIEpTV2ViQXNzZW1ibHlNb2R1bGUodm0sIHN0cnVjdHVyZSwgc3RkOjpmb3J3YXJkPHN0ZDo6 dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4+KG1vZHVsZUluZm9ybWF0aW9uKSwg c3RkOjpmb3J3YXJkPEJhZzxDYWxsTGlua0luZm8+PihjYWxsTGlua0luZm9zKSwgc3RkOjpmb3J3 YXJkPFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPj4od2FzbUV4aXRTdHVicyksIGNhbGxlZUNv dW50KTsKICAgICBpbnN0YW5jZS0+ZmluaXNoQ3JlYXRpb24odm0sIGV4cG9ydFN5bWJvbFRhYmxl KTsKICAgICByZXR1cm4gaW5zdGFuY2U7CiB9CkBAIC01MCwxMiArNTAsMTEgQEAgU3RydWN0dXJl KiBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGVTdHJ1Y3R1cmUoVk0mIHZtLCBKU0dsb2JhbE9i amVjdCogZ2xvYmFsT2IKICAgICByZXR1cm4gU3RydWN0dXJlOjpjcmVhdGUodm0sIGdsb2JhbE9i amVjdCwgcHJvdG90eXBlLCBUeXBlSW5mbyhPYmplY3RUeXBlLCBTdHJ1Y3R1cmVGbGFncyksIGlu Zm8oKSk7CiB9CiAKLUpTV2ViQXNzZW1ibHlNb2R1bGU6OkpTV2ViQXNzZW1ibHlNb2R1bGUoVk0m IHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUlu Zm9ybWF0aW9uPiYmIG1vZHVsZUluZm9ybWF0aW9uLCBCYWc8Q2FsbExpbmtJbmZvPiYmIGNhbGxM aW5rSW5mb3MsIFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0dWI+JiYgd2FzbVRvSlNTdHVicywgV2Fz bTo6SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiYgZnVuY3Rpb25JbmRleFNwYWNlLCB1bnNp Z25lZCBjYWxsZWVDb3VudCkKK0pTV2ViQXNzZW1ibHlNb2R1bGU6OkpTV2ViQXNzZW1ibHlNb2R1 bGUoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1v ZHVsZUluZm9ybWF0aW9uPiYmIG1vZHVsZUluZm9ybWF0aW9uLCBCYWc8Q2FsbExpbmtJbmZvPiYm IGNhbGxMaW5rSW5mb3MsIFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPiYmIHdhc21FeGl0U3R1 YnMsIHVuc2lnbmVkIGNhbGxlZUNvdW50KQogICAgIDogQmFzZSh2bSwgc3RydWN0dXJlKQogICAg ICwgbV9tb2R1bGVJbmZvcm1hdGlvbihXVEZNb3ZlKG1vZHVsZUluZm9ybWF0aW9uKSkKICAgICAs IG1fY2FsbExpbmtJbmZvcyhXVEZNb3ZlKGNhbGxMaW5rSW5mb3MpKQotICAgICwgbV93YXNtVG9K U1N0dWJzKFdURk1vdmUod2FzbVRvSlNTdHVicykpCi0gICAgLCBtX2Z1bmN0aW9uSW5kZXhTcGFj ZShXVEZNb3ZlKGZ1bmN0aW9uSW5kZXhTcGFjZSkpCisgICAgLCBtX3dhc21FeGl0U3R1YnMoV1RG TW92ZSh3YXNtRXhpdFN0dWJzKSkKICAgICAsIG1fY2FsbGVlQ291bnQoY2FsbGVlQ291bnQpCiB7 CiAgICAgbWVtc2V0KGNhbGxlZXMoKSwgMCwgbV9jYWxsZWVDb3VudCAqIHNpemVvZihXcml0ZUJh cnJpZXI8SlNXZWJBc3NlbWJseUNhbGxlZT4pICogMik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmggYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmgKaW5kZXggMmUxMTM2MS4uYmY1 MmUyYiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3Nl bWJseU1vZHVsZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNz ZW1ibHlNb2R1bGUuaApAQCAtNDMsMTkgKzQzLDE4IEBAIGNsYXNzIEpTV2ViQXNzZW1ibHlNb2R1 bGUgOiBwdWJsaWMgSlNEZXN0cnVjdGlibGVPYmplY3QgewogcHVibGljOgogICAgIHR5cGVkZWYg SlNEZXN0cnVjdGlibGVPYmplY3QgQmFzZTsKIAotICAgIHN0YXRpYyBKU1dlYkFzc2VtYmx5TW9k dWxlKiBjcmVhdGUoVk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxl SW5mb3JtYXRpb24+JiYsIEJhZzxDYWxsTGlua0luZm8+JiYsIFZlY3RvcjxXYXNtOjpXYXNtVG9K U1N0dWI+JiYsIFdhc206OkltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmLCBTeW1ib2xUYWJs ZSosIHVuc2lnbmVkKTsKKyAgICBzdGF0aWMgSlNXZWJBc3NlbWJseU1vZHVsZSogY3JlYXRlKFZN JiwgU3RydWN0dXJlKiwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPiYm LCBCYWc8Q2FsbExpbmtJbmZvPiYmLCBWZWN0b3I8V2FzbTo6V2FzbUV4aXRTdHVicz4mJiwgU3lt Ym9sVGFibGUqLCB1bnNpZ25lZCk7CiAgICAgc3RhdGljIFN0cnVjdHVyZSogY3JlYXRlU3RydWN0 dXJlKFZNJiwgSlNHbG9iYWxPYmplY3QqLCBKU1ZhbHVlKTsKIAogICAgIERFQ0xBUkVfSU5GTzsK IAogICAgIGNvbnN0IFdhc206Ok1vZHVsZUluZm9ybWF0aW9uJiBtb2R1bGVJbmZvcm1hdGlvbigp IGNvbnN0IHsgcmV0dXJuICptX21vZHVsZUluZm9ybWF0aW9uLmdldCgpOyB9CiAgICAgU3ltYm9s VGFibGUqIGV4cG9ydFN5bWJvbFRhYmxlKCkgY29uc3QgeyByZXR1cm4gbV9leHBvcnRTeW1ib2xU YWJsZS5nZXQoKTsgfQotICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUZvckZ1bmN0 aW9uSW5kZXhTcGFjZSh1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2UpIGNvbnN0CisgICAgV2Fz bTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRleFNwYWNlKHVu c2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFjZSkgY29uc3QKICAgICB7Ci0gICAgICAgIEFTU0VSVChm dW5jdGlvbkluZGV4U3BhY2UgPCBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5zaXplKTsKLSAgICAgICAg cmV0dXJuIG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtmdW5jdGlvbkluZGV4U3Bh Y2VdLnNpZ25hdHVyZUluZGV4OworICAgICAgICByZXR1cm4gbV9tb2R1bGVJbmZvcm1hdGlvbi0+ c2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXhTcGFjZSk7 CiAgICAgfQotICAgIHVuc2lnbmVkIGltcG9ydENvdW50KCkgY29uc3QgeyByZXR1cm4gbV93YXNt VG9KU1N0dWJzLnNpemUoKTsgfQorICAgIHVuc2lnbmVkIGltcG9ydENvdW50KCkgY29uc3QgeyBy ZXR1cm4gbV93YXNtRXhpdFN0dWJzLnNpemUoKTsgfQogCiAgICAgSlNXZWJBc3NlbWJseUNhbGxl ZSoganNFbnRyeXBvaW50Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZSh1bnNpZ25lZCBmdW5j dGlvbkluZGV4U3BhY2UpCiAgICAgewpAQCAtOTAsMTAgKzg5LDggQEAgcHVibGljOgogICAgICAg ICByZXR1cm4gYml0d2lzZV9jYXN0PFdyaXRlQmFycmllcjxKU1dlYkFzc2VtYmx5Q2FsbGVlPio+ KGJpdHdpc2VfY2FzdDxjaGFyKj4odGhpcykgKyBvZmZzZXRPZkNhbGxlZXMoKSk7CiAgICAgfQog Ci0gICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZkZ1bmN0aW9uSW5kZXhTcGFjZSgpIHsgcmV0 dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFzc2VtYmx5TW9kdWxlLCBtX2Z1bmN0aW9uSW5kZXhT cGFjZSk7IH0KLQogcHJvdGVjdGVkOgotICAgIEpTV2ViQXNzZW1ibHlNb2R1bGUoVk0mLCBTdHJ1 Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYsIEJhZzxD YWxsTGlua0luZm8+JiYsIFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0dWI+JiYsIFdhc206OkltbXV0 YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmLCB1bnNpZ25lZCBjYWxsZWVDb3VudCk7CisgICAgSlNX ZWJBc3NlbWJseU1vZHVsZShWTSYsIFN0cnVjdHVyZSosIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpN b2R1bGVJbmZvcm1hdGlvbj4mJiwgQmFnPENhbGxMaW5rSW5mbz4mJiwgVmVjdG9yPFdhc206Oldh c21FeGl0U3R1YnM+JiYsIHVuc2lnbmVkIGNhbGxlZUNvdW50KTsKICAgICB2b2lkIGZpbmlzaENy ZWF0aW9uKFZNJiwgU3ltYm9sVGFibGUqKTsKICAgICBzdGF0aWMgdm9pZCBkZXN0cm95KEpTQ2Vs bCopOwogICAgIHN0YXRpYyB2b2lkIHZpc2l0Q2hpbGRyZW4oSlNDZWxsKiwgU2xvdFZpc2l0b3Im KTsKQEAgLTExNyw4ICsxMTQsNyBAQCBwcml2YXRlOgogICAgIHN0ZDo6dW5pcXVlX3B0cjxXYXNt OjpNb2R1bGVJbmZvcm1hdGlvbj4gbV9tb2R1bGVJbmZvcm1hdGlvbjsKICAgICBCYWc8Q2FsbExp bmtJbmZvPiBtX2NhbGxMaW5rSW5mb3M7CiAgICAgV3JpdGVCYXJyaWVyPFN5bWJvbFRhYmxlPiBt X2V4cG9ydFN5bWJvbFRhYmxlOwotICAgIFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0dWI+IG1fd2Fz bVRvSlNTdHViczsKLSAgICBjb25zdCBXYXNtOjpJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2Ug bV9mdW5jdGlvbkluZGV4U3BhY2U7CisgICAgVmVjdG9yPFdhc206Oldhc21FeGl0U3R1YnM+IG1f d2FzbUV4aXRTdHViczsKICAgICB1bnNpZ25lZCBtX2NhbGxlZUNvdW50OwogfTsKIApkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlvbi5j cHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNw cAppbmRleCA0ZjBkN2E4Li5kNTlhMDU5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNwcApAQCAtMTA1LDE2ICsxMDUsNyBA QCBzdGF0aWMgRW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBjYWxsV2ViQXNzZW1ibHlGdW5j dGlvbihFeGVjU3RhdGUqIGV4ZWMpCiAKIEVuY29kZWRKU1ZhbHVlIFdlYkFzc2VtYmx5RnVuY3Rp b246OmNhbGwoVk0mIHZtLCBQcm90b0NhbGxGcmFtZSogcHJvdG9DYWxsRnJhbWUpCiB7Ci0gICAg Ly8gU2V0dXAgdGhlIG1lbW9yeSB0aGF0IHRoZSBlbnRyYW5jZSBsb2Fkcy4KLSAgICBpZiAoSlNX ZWJBc3NlbWJseU1lbW9yeSogbWVtb3J5ID0gaW5zdGFuY2UoKS0+bWVtb3J5KCkpIHsKLSAgICAg ICAgV2FzbTo6TWVtb3J5KiB3YXNtTWVtb3J5ID0gbWVtb3J5LT5tZW1vcnkoKTsKLSAgICAgICAg dm0udG9wV2FzbU1lbW9yeVBvaW50ZXIgPSB3YXNtTWVtb3J5LT5tZW1vcnkoKTsKLSAgICAgICAg dm0udG9wV2FzbU1lbW9yeVNpemUgPSB3YXNtTWVtb3J5LT5zaXplKCk7Ci0gICAgfSBlbHNlIHsK LSAgICAgICAgdm0udG9wV2FzbU1lbW9yeVBvaW50ZXIgPSBudWxscHRyOwotICAgICAgICB2bS50 b3BXYXNtTWVtb3J5U2l6ZSA9IDA7Ci0gICAgfQotCisgICAgLy8gRklYTUUgRG8gYXdheSB3aXRo IHRoaXMgZW50aXJlIGZ1bmN0aW9uLCBhbmQgb25seSB1c2UgdGhlIGVudHJ5cG9pbnQgZ2VuZXJh dGVkIGJ5IEIzLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY2NDg2 CiAgICAgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBwcmV2SlNXZWJBc3NlbWJseUluc3RhbmNlID0g dm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlOwogICAgIHZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0 YW5jZSA9IGluc3RhbmNlKCk7CiAgICAgQVNTRVJUKGluc3RhbmNlKCkpOwpAQCAtMTUzLDcgKzE0 NCw3IEBAIFdlYkFzc2VtYmx5RnVuY3Rpb24qIFdlYkFzc2VtYmx5RnVuY3Rpb246OmNyZWF0ZShW TSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPCiBTdHJ1Y3R1cmUqIFdlYkFzc2VtYmx5RnVu Y3Rpb246OmNyZWF0ZVN0cnVjdHVyZShWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmpl Y3QsIEpTVmFsdWUgcHJvdG90eXBlKQogewogICAgIEFTU0VSVChnbG9iYWxPYmplY3QpOwotICAg IHJldHVybiBTdHJ1Y3R1cmU6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LCBwcm90b3R5cGUsIFR5 cGVJbmZvKEpTRnVuY3Rpb25UeXBlLCBTdHJ1Y3R1cmVGbGFncyksIGluZm8oKSk7CisgICAgcmV0 dXJuIFN0cnVjdHVyZTo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3QsIHByb3RvdHlwZSwgVHlwZUlu Zm8oV2ViQXNzZW1ibHlGdW5jdGlvblR5cGUsIFN0cnVjdHVyZUZsYWdzKSwgaW5mbygpKTsKIH0K IAogV2ViQXNzZW1ibHlGdW5jdGlvbjo6V2ViQXNzZW1ibHlGdW5jdGlvbihWTSYgdm0sIEpTR2xv YmFsT2JqZWN0KiBnbG9iYWxPYmplY3QsIFN0cnVjdHVyZSogc3RydWN0dXJlLCBXYXNtOjpTaWdu YXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VDb25zdHJ1Y3Rvci5jcHAgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUluc3RhbmNlQ29uc3RydWN0b3IuY3Bw CmluZGV4IDU4ZWEyNTg0Li5kMjRhYjgxIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9qcy9XZWJBc3NlbWJseUluc3RhbmNlQ29uc3RydWN0b3IuY3BwCisrKyBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VDb25zdHJ1Y3Rvci5j cHAKQEAgLTExNCwxOCArMTE0LDE5IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9D QUxMIGNvbnN0cnVjdEpTV2ViQXNzZW1ibHlJbnN0YW5jZShFeGVjU3RhdGUqIGV4CiAgICAgICAg ICAgICAgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29kZSh0aHJvd0V4Y2VwdGlvbihleGVjLCB0aHJv d1Njb3BlLCBjcmVhdGVKU1dlYkFzc2VtYmx5TGlua0Vycm9yKGV4ZWMsIHZtLCBBU0NJSUxpdGVy YWwoImltcG9ydCBmdW5jdGlvbiBtdXN0IGJlIGNhbGxhYmxlIikpKSk7CiAgICAgICAgICAgICBK U0NlbGwqIGNlbGwgPSB2YWx1ZS5hc0NlbGwoKTsKICAgICAgICAgICAgIC8vIGlpLiBJZiB2IGlz IGFuIEV4cG9ydGVkIEZ1bmN0aW9uIEV4b3RpYyBPYmplY3Q6Ci0gICAgICAgICAgICBpZiAoV2Vi QXNzZW1ibHlGdW5jdGlvbiogaW1wb3J0ZWRFeHBvcnRzID0ganNEeW5hbWljQ2FzdDxXZWJBc3Nl bWJseUZ1bmN0aW9uKj4ob2JqZWN0KSkgewotICAgICAgICAgICAgICAgIC8vIEZJWE1FIGhhbmRs ZSBGdW5jdGlvbiBFeG90aWMgT2JqZWN0IHByb3Blcmx5LiBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTY1MjgyCi0gICAgICAgICAgICAgICAgLy8gYS4gSWYgdGhlIHNp Z25hdHVyZSBvZiB2IGRvZXMgbm90IG1hdGNoIHRoZSBzaWduYXR1cmUgb2YgaSwgdGhyb3cgYSBU eXBlRXJyb3IuCisgICAgICAgICAgICBpZiAoV2ViQXNzZW1ibHlGdW5jdGlvbiogaW1wb3J0ZWRF eHBvcnQgPSBqc0R5bmFtaWNDYXN0PFdlYkFzc2VtYmx5RnVuY3Rpb24qPihjZWxsKSkgeworICAg ICAgICAgICAgICAgIC8vIGEuIElmIHRoZSBzaWduYXR1cmUgb2YgdiBkb2VzIG5vdCBtYXRjaCB0 aGUgc2lnbmF0dXJlIG9mIGksIHRocm93IGEgV2ViQXNzZW1ibHkuTGlua0Vycm9yLgorICAgICAg ICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IGltcG9ydGVkU2lnbmF0dXJlSW5kZXggPSBp bXBvcnRlZEV4cG9ydC0+c2lnbmF0dXJlSW5kZXgoKTsKKyAgICAgICAgICAgICAgICBXYXNtOjpT aWduYXR1cmVJbmRleCBleHBlY3RlZFNpZ25hdHVyZUluZGV4ID0gbW9kdWxlSW5mb3JtYXRpb24u aW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzW2ltcG9ydC5raW5kSW5kZXhdOworICAgICAg ICAgICAgICAgIGlmIChpbXBvcnRlZFNpZ25hdHVyZUluZGV4ICE9IGV4cGVjdGVkU2lnbmF0dXJl SW5kZXgpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBKU1ZhbHVlOjplbmNvZGUodGhyb3dF eGNlcHRpb24oZXhlYywgdGhyb3dTY29wZSwgY3JlYXRlSlNXZWJBc3NlbWJseUxpbmtFcnJvcihl eGVjLCB2bSwgQVNDSUlMaXRlcmFsKCJpbXBvcnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBtaXNt YXRjaGVzIHRoZSBwcm92aWRlZCBXZWJBc3NlbWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSIpKSkp OwogICAgICAgICAgICAgICAgIC8vIGIuIExldCBjbG9zdXJlIGJlIHYuW1tDbG9zdXJlXV0uCi0g ICAgICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKLSAgICAgICAgICAg ICAgICBVTlVTRURfUEFSQU0oaW1wb3J0ZWRFeHBvcnRzKTsKLSAgICAgICAgICAgICAgICBicmVh azsKICAgICAgICAgICAgIH0KICAgICAgICAgICAgIC8vIGlpaS4gT3RoZXJ3aXNlOgogICAgICAg ICAgICAgLy8gYS4gTGV0IGNsb3N1cmUgYmUgYSBuZXcgaG9zdCBmdW5jdGlvbiBvZiB0aGUgZ2l2 ZW4gc2lnbmF0dXJlIHdoaWNoIGNhbGxzIHYgYnkgY29lcmNpbmcgV2ViQXNzZW1ibHkgYXJndW1l bnRzIHRvIEphdmFTY3JpcHQgYXJndW1lbnRzIHZpYSBUb0pTVmFsdWUgYW5kIHJldHVybnMgdGhl IHJlc3VsdCwgaWYgYW55LCBieSBjb2VyY2luZyB2aWEgVG9XZWJBc3NlbWJseVZhbHVlLgogICAg ICAgICAgICAgLy8gTm90ZTogZG9uZSBhcyBwYXJ0IG9mIFBsYW4gY29tcGlsYXRpb24uCiAgICAg ICAgICAgICAvLyBpdi4gQXBwZW5kIHYgdG8gZnVuY3MuCisgICAgICAgICAgICAvLyBOb3RlOiBh ZGRpbmcgdGhlIEpTQ2VsbCB0byB0aGUgaW5zdGFuY2UgbGlzdCBmdWxmaWxscyBjbG9zdXJlIHJl cXVpcmVtZW50cyBiLiBhYm92ZSAodGhlIFdlYkFzc2VtYmx5Lkluc3RhbmNlIHdpbCBiZSBrZXB0 IGFsaXZlKSBhbmQgdi4gYmVsb3cgKHRoZSBKU0Z1bmN0aW9uKS4KICAgICAgICAgICAgIGluc3Rh bmNlLT5zZXRJbXBvcnRGdW5jdGlvbih2bSwgY2VsbCwgbnVtSW1wb3J0RnVuY3Rpb25zKyspOwog ICAgICAgICAgICAgLy8gdi4gQXBwZW5kIGNsb3N1cmUgdG8gaW1wb3J0cy4KICAgICAgICAgICAg IGJyZWFrOwpAQCAtMjI5LDggKzIzMCw4IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9T VF9DQUxMIGNvbnN0cnVjdEpTV2ViQXNzZW1ibHlJbnN0YW5jZShFeGVjU3RhdGUqIGV4CiAgICAg ICAgIGlmIChtb2R1bGVJbmZvcm1hdGlvbi5tZW1vcnkgJiYgIWhhc01lbW9yeUltcG9ydCkgewog ICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQoIW1vZHVsZUluZm9ybWF0aW9uLm1lbW9yeS5pc0lt cG9ydCgpKTsKICAgICAgICAgICAgIC8vIFdlIGNyZWF0ZSBhIG1lbW9yeSB3aGVuIGl0J3MgYSBt ZW1vcnkgZGVmaW5pdGlvbi4KLSAgICAgICAgICAgIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1v cnk+IG1lbW9yeSA9IHN0ZDo6bWFrZV91bmlxdWU8V2FzbTo6TWVtb3J5Pihtb2R1bGVJbmZvcm1h dGlvbi5tZW1vcnkuaW5pdGlhbCgpLCBtb2R1bGVJbmZvcm1hdGlvbi5tZW1vcnkubWF4aW11bSgp KTsKLSAgICAgICAgICAgIGlmICghbWVtb3J5LT5pc1ZhbGlkKCkpCisgICAgICAgICAgICBXYXNt OjpNZW1vcnkgbWVtb3J5KG1vZHVsZUluZm9ybWF0aW9uLm1lbW9yeS5pbml0aWFsKCksIG1vZHVs ZUluZm9ybWF0aW9uLm1lbW9yeS5tYXhpbXVtKCkpOworICAgICAgICAgICAgaWYgKCFtZW1vcnku aXNWYWxpZCgpKQogICAgICAgICAgICAgICAgIHJldHVybiBKU1ZhbHVlOjplbmNvZGUodGhyb3dF eGNlcHRpb24oZXhlYywgdGhyb3dTY29wZSwgY3JlYXRlT3V0T2ZNZW1vcnlFcnJvcihleGVjKSkp OwogICAgICAgICAgICAgaW5zdGFuY2UtPnNldE1lbW9yeSh2bSwKICAgICAgICAgICAgICAgIEpT V2ViQXNzZW1ibHlNZW1vcnk6OmNyZWF0ZSh2bSwgZXhlYy0+bGV4aWNhbEdsb2JhbE9iamVjdCgp LT5XZWJBc3NlbWJseU1lbW9yeVN0cnVjdHVyZSgpLCBXVEZNb3ZlKG1lbW9yeSkpKTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TWVtb3J5Q29u c3RydWN0b3IuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlN ZW1vcnlDb25zdHJ1Y3Rvci5jcHAKaW5kZXggM2Y4OGVkNC4uZGNjZWMxNiAxMDA2NDQKLS0tIGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNZW1vcnlDb25zdHJ1Y3Rv ci5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNZW1v cnlDb25zdHJ1Y3Rvci5jcHAKQEAgLTk2LDggKzk2LDggQEAgc3RhdGljIEVuY29kZWRKU1ZhbHVl IEpTQ19IT1NUX0NBTEwgY29uc3RydWN0SlNXZWJBc3NlbWJseU1lbW9yeShFeGVjU3RhdGUqIGV4 ZWMKICAgICAgICAgfQogICAgIH0KIAotICAgIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+ IG1lbW9yeSA9IHN0ZDo6bWFrZV91bmlxdWU8V2FzbTo6TWVtb3J5Pihpbml0aWFsUGFnZUNvdW50 LCBtYXhpbXVtUGFnZUNvdW50KTsKLSAgICBpZiAoIW1lbW9yeS0+aXNWYWxpZCgpKQorICAgIFdh c206Ok1lbW9yeSBtZW1vcnkoaW5pdGlhbFBhZ2VDb3VudCwgbWF4aW11bVBhZ2VDb3VudCk7Cisg ICAgaWYgKCFtZW1vcnkuaXNWYWxpZCgpKQogICAgICAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2Rl KHRocm93RXhjZXB0aW9uKGV4ZWMsIHRocm93U2NvcGUsIGNyZWF0ZU91dE9mTWVtb3J5RXJyb3Io ZXhlYykpKTsKIAogICAgIHJldHVybiBKU1ZhbHVlOjplbmNvZGUoSlNXZWJBc3NlbWJseU1lbW9y eTo6Y3JlYXRlKHZtLCBleGVjLT5sZXhpY2FsR2xvYmFsT2JqZWN0KCktPldlYkFzc2VtYmx5TWVt b3J5U3RydWN0dXJlKCksIFdURk1vdmUobWVtb3J5KSkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVDb25zdHJ1Y3Rvci5jcHAgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9y LmNwcAppbmRleCAzOGVkYjhjLi44MTI5NTkyIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNwcAorKysgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNw cApAQCAtOTcsNyArOTcsNyBAQCBKU1ZhbHVlIFdlYkFzc2VtYmx5TW9kdWxlQ29uc3RydWN0b3I6 OmNyZWF0ZU1vZHVsZShFeGVjU3RhdGUqIHN0YXRlLCBTdHJ1Y3R1cmUqCiAKICAgICAvLyBPbmx5 IHdhc20taW50ZXJuYWwgZnVuY3Rpb25zIGhhdmUgYSBjYWxsZWUsIHN0dWJzIHRvIEpTIGRvIG5v dC4KICAgICB1bnNpZ25lZCBjYWxsZWVDb3VudCA9IHBsYW4uaW50ZXJuYWxGdW5jdGlvbkNvdW50 KCk7Ci0gICAgSlNXZWJBc3NlbWJseU1vZHVsZSogcmVzdWx0ID0gSlNXZWJBc3NlbWJseU1vZHVs ZTo6Y3JlYXRlKHZtLCBzdHJ1Y3R1cmUsIHBsYW4udGFrZU1vZHVsZUluZm9ybWF0aW9uKCksIHBs YW4udGFrZUNhbGxMaW5rSW5mb3MoKSwgcGxhbi50YWtlV2FzbVRvSlNTdHVicygpLCBwbGFuLnRh a2VGdW5jdGlvbkluZGV4U3BhY2UoKSwgZXhwb3J0U3ltYm9sVGFibGUsIGNhbGxlZUNvdW50KTsK KyAgICBKU1dlYkFzc2VtYmx5TW9kdWxlKiByZXN1bHQgPSBKU1dlYkFzc2VtYmx5TW9kdWxlOjpj cmVhdGUodm0sIHN0cnVjdHVyZSwgcGxhbi50YWtlTW9kdWxlSW5mb3JtYXRpb24oKSwgcGxhbi50 YWtlQ2FsbExpbmtJbmZvcygpLCBwbGFuLnRha2VXYXNtRXhpdFN0dWJzKCksIGV4cG9ydFN5bWJv bFRhYmxlLCBjYWxsZWVDb3VudCk7CiAgICAgcGxhbi5pbml0aWFsaXplQ2FsbGVlcyhzdGF0ZS0+ anNDYWxsZWUoKS0+Z2xvYmFsT2JqZWN0KCksIAogICAgICAgICBbJl0gKHVuc2lnbmVkIGNhbGxl ZUluZGV4LCBKU1dlYkFzc2VtYmx5Q2FsbGVlKiBqc0VudHJ5cG9pbnRDYWxsZWUsIEpTV2ViQXNz ZW1ibHlDYWxsZWUqIHdhc21FbnRyeXBvaW50Q2FsbGVlKSB7CiAgICAgICAgICAgICByZXN1bHQt PnNldEpTRW50cnlwb2ludENhbGxlZSh2bSwgY2FsbGVlSW5kZXgsIGpzRW50cnlwb2ludENhbGxl ZSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJs eU1vZHVsZVJlY29yZC5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3Nl bWJseU1vZHVsZVJlY29yZC5jcHAKaW5kZXggYjRjYjA1NS4uMDc4Njk3OCAxMDA2NDQKLS0tIGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQuY3Bw CisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVj b3JkLmNwcApAQCAtMTE4LDcgKzExOCw3IEBAIHZvaWQgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6 OmxpbmsoRXhlY1N0YXRlKiBzdGF0ZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBpbnN0CiAgICAg ICAgICAgICAvLyAgICAgYy4gUmV0dXJuIGZ1bmMuCiAgICAgICAgICAgICBKU1dlYkFzc2VtYmx5 Q2FsbGVlKiBqc0VudHJ5cG9pbnRDYWxsZWUgPSBtb2R1bGUtPmpzRW50cnlwb2ludENhbGxlZUZy b21GdW5jdGlvbkluZGV4U3BhY2UoZXhwLmtpbmRJbmRleCk7CiAgICAgICAgICAgICBKU1dlYkFz c2VtYmx5Q2FsbGVlKiB3YXNtRW50cnlwb2ludENhbGxlZSA9IG1vZHVsZS0+d2FzbUVudHJ5cG9p bnRDYWxsZWVGcm9tRnVuY3Rpb25JbmRleFNwYWNlKGV4cC5raW5kSW5kZXgpOwotICAgICAgICAg ICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVy ZUZvckZ1bmN0aW9uSW5kZXhTcGFjZShleHAua2luZEluZGV4KTsKKyAgICAgICAgICAgIFdhc206 OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVJbmRleEZy b21GdW5jdGlvbkluZGV4U3BhY2UoZXhwLmtpbmRJbmRleCk7CiAgICAgICAgICAgICBjb25zdCBX YXNtOjpTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFdhc206OlNpZ25hdHVyZUluZm9ybWF0aW9uOjpn ZXQoJnZtLCBzaWduYXR1cmVJbmRleCk7CiAgICAgICAgICAgICBXZWJBc3NlbWJseUZ1bmN0aW9u KiBmdW5jdGlvbiA9IFdlYkFzc2VtYmx5RnVuY3Rpb246OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0 LCBzaWduYXR1cmUtPmFyZ3VtZW50Q291bnQoKSwgZXhwLmZpZWxkLnN0cmluZygpLCBpbnN0YW5j ZSwganNFbnRyeXBvaW50Q2FsbGVlLCB3YXNtRW50cnlwb2ludENhbGxlZSwgc2lnbmF0dXJlSW5k ZXgpOwogICAgICAgICAgICAgZXhwb3J0ZWRWYWx1ZSA9IGZ1bmN0aW9uOwpAQCAtMTc1LDcgKzE3 NSw3IEBAIHZvaWQgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmxpbmsoRXhlY1N0YXRlKiBzdGF0 ZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBpbnN0CiAgICAgYm9vbCBoYXNTdGFydCA9ICEhbW9k dWxlSW5mb3JtYXRpb24uc3RhcnRGdW5jdGlvbkluZGV4U3BhY2U7CiAgICAgaWYgKGhhc1N0YXJ0 KSB7CiAgICAgICAgIGF1dG8gc3RhcnRGdW5jdGlvbkluZGV4U3BhY2UgPSBtb2R1bGVJbmZvcm1h dGlvbi5zdGFydEZ1bmN0aW9uSW5kZXhTcGFjZS52YWx1ZV9vcigwKTsKLSAgICAgICAgV2FzbTo6 U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVyZUZvckZ1bmN0 aW9uSW5kZXhTcGFjZShzdGFydEZ1bmN0aW9uSW5kZXhTcGFjZSk7CisgICAgICAgIFdhc206OlNp Z25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21G dW5jdGlvbkluZGV4U3BhY2Uoc3RhcnRGdW5jdGlvbkluZGV4U3BhY2UpOwogICAgICAgICBjb25z dCBXYXNtOjpTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFdhc206OlNpZ25hdHVyZUluZm9ybWF0aW9u OjpnZXQoJnZtLCBzaWduYXR1cmVJbmRleCk7CiAgICAgICAgIC8vIFRoZSBzdGFydCBmdW5jdGlv biBtdXN0IG5vdCB0YWtlIGFueSBhcmd1bWVudHMgb3IgcmV0dXJuIGFueXRoaW5nLiBUaGlzIGlz IGVuZm9yY2VkIGJ5IHRoZSBwYXJzZXIuCiAgICAgICAgIEFTU0VSVCghc2lnbmF0dXJlLT5hcmd1 bWVudENvdW50KCkpOwpAQCAtMjM4LDcgKzIzOCw3IEBAIEpTVmFsdWUgV2ViQXNzZW1ibHlNb2R1 bGVSZWNvcmQ6OmV2YWx1YXRlKEV4ZWNTdGF0ZSogc3RhdGUpCiAKICAgICAgICAgICAgICAgICBK U1dlYkFzc2VtYmx5Q2FsbGVlKiBqc0VudHJ5cG9pbnRDYWxsZWUgPSBtb2R1bGUtPmpzRW50cnlw b2ludENhbGxlZUZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleCk7CiAgICAgICAg ICAgICAgICAgSlNXZWJBc3NlbWJseUNhbGxlZSogd2FzbUVudHJ5cG9pbnRDYWxsZWUgPSBtb2R1 bGUtPndhc21FbnRyeXBvaW50Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbklu ZGV4KTsKLSAgICAgICAgICAgICAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRl eCA9IG1vZHVsZS0+c2lnbmF0dXJlRm9yRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgp OworICAgICAgICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0g bW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRl eCk7CiAgICAgICAgICAgICAgICAgY29uc3QgV2FzbTo6U2lnbmF0dXJlKiBzaWduYXR1cmUgPSBX YXNtOjpTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KCZ2bSwgc2lnbmF0dXJlSW5kZXgpOwogICAg ICAgICAgICAgICAgIC8vIEZJWE1FOiBTYXkgd2UgZXhwb3J0IGxvY2FsIGZ1bmN0aW9uICJmb28i IGF0IGZ1bmNpdG9uIGluZGV4IDAuCiAgICAgICAgICAgICAgICAgLy8gV2hhdCBpZiB3ZSBhbHNv IHNldCBpdCB0byB0aGUgdGFibGUgYW4gRWxlbWVudCB3LyBpbmRleCAwLgotLSAKMi4xMC4xCgo= 297845 2016-12-29 17:43:04 -0800 2016-12-29 23:54:22 -0800 WIP 0001-wasm-wasm.patch text/plain 128619 jfbastien RnJvbSBlN2NkMWUxYmY3OGVlM2Q2YmM1N2ZmN2E0NTM1YjA2NWUzYWQ0MjhmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBXZWQsIDIxIERlYyAyMDE2IDE1OjU5OjU2IC0wODAwClN1YmplY3Q6IFtQQVRDSF0gd2FzbS0+ d2FzbQoKQ2hhbmdlcyB0byB0aGUgV2ViQXNzZW1ibHkgaW1wbGVtZW50YXRpb246CgogIC0gQWRk IGEgbmV3IEpTVHlwZSBmb3IgV2ViQXNzZW1ibHlGdW5jdGlvbiwgYW5kIHVzZSBpdCB3aGVuIGNy ZWF0aW5nIGl0cwogICAgc3RydWN0dXJlLiBUaGlzIHdpbGwgYmUgdXNlZCB0byBxdWlja2x5IGRl dGVjdCBmcm9tIHdhc20gd2hldGhlciB0aGUgaW1wb3J0CiAgICBjYWxsIGlzIHRvIGFub3RoZXIg d2FzbSBtb2R1bGUsIG9yIHdoZXRoZXIgaXQncyB0byBKUy4KICAtIFVzZSBjZWxsIGluc3RlYWQg b2Ygb2JqZWN0cyB0byBkZXRlY3Qgd2FzbS0+d2FzbSwgdGhlIHByZXZpb3VzIGNvZGUgd2FzIHdy b25nLgogIC0gSW1wcm92ZSBkaWFnbm9zdGljIHByaW50b3V0IGZvciB3YXNtIHN0dWJzOiBwcmlu dCB0aGUgZnVsbCBzaWduYXR1cmUuCiAgLSBQcm9wZXJseSBjaGVjayB0aGF0IHdhc20gLT4gd2Fz bSBjYWxscyBoYXZlIG1hdGNoaW5nIHNpZ25hdHVyZXMuIEFkZCB0ZXN0aW5nIGZvciB0aGlzLgog IC0gVGVzdCBzb21lIG9mIHRoZSB3YXNtIC0+IHdhc20gY2FsbHMsIG5vdCB3b3JraW5nIHlldCwg YW5kIG1vcmUgdGVzdHMgbmVlZCB0bwogICAgZ2V0IGltcGxlbWVudGVkLgogIC0gR2VuZXJhdGUg dHdvIHN0dWJzIGZyb20gdGhlIGltcG9ydCBzdHViIGdlbmVyYXRvcjogb25lIGZvciB3YXNtLT5K UyBhbmQgb25lCiAgICBmb3Igd2FzbSAtPiB3YXNtLiBUaGlzIGlzIGRvbmUgYXQgTW9kdWxlIHRp bWUuIFdoaWNoIGlzIGNhbGxlZCB3aWxsIG9ubHkgYmUKICAgIGtub3duIGF0IEluc3RhbmNlIHRp bWUsIG9uY2Ugd2UndmUgcmVjZWl2ZWQgdGhlIGltcG9ydCBvYmplY3QuIFdlIHdhbnQgdG8KICAg IGF2b2lkIGNvZGVnZW4gYXQgSW5zdGFuY2UgdGltZSwgc28gaGF2aW5nIGJvdGggYXJvdW5kIGlz IGdyZWF0LgogIC0gUmVzdG9yZSB0aGUgV2ViQXNzZW1ibHkgZ2xvYmFsIHN0YXRlIChWTSB0b3Ag SW5zdGFuY2UsIGFuZCBwaW5uZWQgcmVnaXN0ZXJzKQogICAgYWZ0ZXIgY2FsbCAvIGNhbGxfaW5k aXJlY3QsIGFuZCBpbiB0aGUgSlMtPndhc20gZW50cnkgc3R1Yi4KClN1cHBvcnQgY2hhbmdlczoK CiAgLSBBZGQgYSBQcm94eSB0byBCdWlsZGVyLmpzLCB3aGljaCBpbnRlcmNlcHRzIHVua25vd24g cHJvcGVydHkgbG9va3Vwcy4gVGhpcwogICAgY3JlYXRlcyB3YXkgYmV0dGVyIGVycm9yIG1lc3Nh Z2VzIG9uIHR5cG9zIHRoYW4gJ3VuZGVmaW5lZCBpcyBub3QgYQogICAgZnVuY3Rpb24nLCB3aGlj aCBoYXBwZW5zIHNlbWktZnJlcXVlbnRseSBhcyBJIHR5cG8gb3Bjb2RlIG5hbWVzIChhbmQgd2hp Y2gKICAgIG9uZSBpcyBhIHR5cG8gaXMgaGFyZCB0byBmaW5kIGJlY2F1c2Ugd2UgY2hhaW4gYnVp bGRlcnMpLgogIC0gQWRkIGxpbWl0ZWQgc3VwcG9ydCBmb3IgdmFye3V9aW50NjQgKG9ubHkgdGhl IDMyLWJpdCB2YWx1ZXMpLgogIC0gR2V0IHJpZCBvZiBtdWNoIG9mIHRoZSBmdW5jdGlvbiBpbmRl eCBzcGFjZTogd2UgYWxyZWFkeSBoYXZlIGFsbCBvZiBpdHMKICAgIGluZm9ybWF0aW9uIGVsc2V3 aGVyZSwgYW5kIGFzLWlzIGl0IHByb3ZpZGVzIG5vIGV4dHJhIGVmZmljaWVuY3kuCiAgLSBTdG9y ZSBXYXNtOjpNZW1vcnkgZGlyZWN0bHkgb24gSlNXZWJBc3NlbWJseU1lbW9yeSwgaW5zdGVhZCBv ZiB0aHJvdWdoIGEKICAgIHVuaXF1ZV9wdHIuIFRoaXMgcmVtb3ZlcyBhbiBpbmRpcmVjdGlvbiBh bmQgdXNlbGVzcyBhbGxvY2F0aW9uLgogIC0gUmVtb3ZlIFZNJ2EgV2ViQXNzZW1ibHkgbWVtb3J5 IC8gc2l6ZSwgYW5kIG9idGFpbiB0aGVtIGZyb20gSW5zdGFuY2UKICAgIGluc3RlYWQuIFRoaXMg cmVxdWlyZXMgYW4gZXh0cmEgaW5kaXJlY3Rpb24sIGJ1dCBpcyBjbGVhbmVyLgotLS0KIEpTVGVz dHMvd2FzbS9CdWlsZGVyLmpzICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDkxICsrKysr LS0tLQogSlNUZXN0cy93YXNtL0xvd0xldmVsQmluYXJ5LmpzICAgICAgICAgICAgICAgICAgICAg fCAgMTIgKysKIEpTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy9leGNlcHRpb25zLmpzICAgICAg ICAgIHwgICA2ICstCiBKU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpzICAg ICAgICAgICB8ICAgMiArLQogSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtc3RvcmUu anMgICAgICAgICAgfCAgIDIgKy0KIEpTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLWJh ZC1zaWduYXR1cmUuanMgIHwgMTA1ICsrKysrKysrKysrCiBKU1Rlc3RzL3dhc20vanMtYXBpL3dh c20tdG8td2FzbS5qcyAgICAgICAgICAgICAgICB8ICA3MiArKysrKysrCiBTb3VyY2UvSmF2YVNj cmlwdENvcmUvQ01ha2VMaXN0cy50eHQgICAgICAgICAgICAgICB8ICAgMSArCiAuLi4vSmF2YVNj cmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiAgICAgICB8ICAgOCArLQogU291cmNl L0phdmFTY3JpcHRDb3JlL2pzYy5jcHAgICAgICAgICAgICAgICAgICAgICAgfCAgMjUgKystCiAu Li4vSmF2YVNjcmlwdENvcmUvcnVudGltZS9BYnN0cmFjdE1vZHVsZVJlY29yZC5oICB8ICAgMiAr LQogU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmggICAgICAgICAgICAgfCAg IDIgKwogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuY3BwICAg fCAyMDkgKysrKysrKysrKysrKy0tLS0tLS0tCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9X YXNtQjNJUkdlbmVyYXRvci5oICAgICB8ICAgMiArLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbUJpbmRpbmcuY3BwICAgICAgICAgfCAgNDkgKysrKy0KIFNvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21CaW5kaW5nLmggICAgICAgICAgIHwgICAyICstCiBTb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtRm9ybWF0LmggICAgICAgICAgICB8ICAyOCArKy0KIFNvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21GdW5jdGlvblBhcnNlci5oICAgIHwgIDE2ICstCiBTb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmNwcCAgICAgICAgICB8ICA1NyArKysr Ky0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuaCAgICAgICAgICAgIHwg IDM1ICsrLS0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnlJbmZvcm1hdGlvbi5j cHAgIHwgICA0ICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2Vy LmNwcCAgICB8ICAyNCArLS0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQ YXJzZXIuaCAgICAgIHwgICAyICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFn ZUNvdW50LmNwcCAgICAgICB8ICA0NSArKysrKwogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbVBhZ2VDb3VudC5oICAgICAgICAgfCAgIDYgKwogU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbVBsYW4uY3BwICAgICAgICAgICAgfCAgMzggKystLQogU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbVBsYW4uaCAgICAgICAgICAgICAgfCAgMTQgKy0KIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuY3BwICAgICAgIHwgIDE4ICstCiBTb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmggICAgICAgICB8ICAgMSArCiBTb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwICAgICAgICB8ICAgNCArLQogU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmggICAgICAgICAgfCAgIDIgKy0K IC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5oIHwgIDEx ICstCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNwcCB8 ICAxMiArLQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5o ICAgfCAgMTMgKy0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1 bGUuY3BwIHwgICA5ICstCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5 TW9kdWxlLmggICB8ICAxNiArLQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1i bHlGdW5jdGlvbi5jcHAgfCAgIDMgKy0KIC4uLi93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VD b25zdHJ1Y3Rvci5jcHAgICAgIHwgIDE1ICstCiAuLi4vd2FzbS9qcy9XZWJBc3NlbWJseU1lbW9y eUNvbnN0cnVjdG9yLmNwcCAgICAgICB8ICAgMiArLQogLi4uL3dhc20vanMvV2ViQXNzZW1ibHlN b2R1bGVDb25zdHJ1Y3Rvci5jcHAgICAgICAgfCAgIDIgKy0KIC4uLi93YXNtL2pzL1dlYkFzc2Vt Ymx5TW9kdWxlUmVjb3JkLmNwcCAgICAgICAgICAgIHwgICA2ICstCiAuLi4vd2FzbS9qcy9XZWJB c3NlbWJseU1vZHVsZVJlY29yZC5oICAgICAgICAgICAgICB8ICAgMiArLQogNDIgZmlsZXMgY2hh bmdlZCwgNzE0IGluc2VydGlvbnMoKyksIDI2MSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEw MDY0NCBKU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS1iYWQtc2lnbmF0dXJlLmpzCiBj cmVhdGUgbW9kZSAxMDA2NDQgSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFnZUNvdW50 LmNwcAoKZGlmZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9CdWlsZGVyLmpzIGIvSlNUZXN0cy93YXNt L0J1aWxkZXIuanMKaW5kZXggZGE1ODRjNC4uMjZiYTY2ZSAxMDA2NDQKLS0tIGEvSlNUZXN0cy93 YXNtL0J1aWxkZXIuanMKKysrIGIvSlNUZXN0cy93YXNtL0J1aWxkZXIuanMKQEAgLTM4LDcgKzM4 LDcgQEAgY29uc3QgX2lzVmFsaWRWYWx1ZSA9ICh2YWx1ZSwgdHlwZSkgPT4gewogICAgIHN3aXRj aCAodHlwZSkgewogICAgIC8vIFdlIGFsbG93IGJvdGggc2lnbmVkIGFuZCB1bnNpZ25lZCBudW1i ZXJzLgogICAgIGNhc2UgImkzMiI6IHJldHVybiBNYXRoLnJvdW5kKHZhbHVlKSA9PT0gdmFsdWUg JiYgTExCLnZhcmludDMyTWluIDw9IHZhbHVlICYmIHZhbHVlIDw9IExMQi52YXJ1aW50MzJNYXg7 Ci0gICAgY2FzZSAiaTY0IjogdGhyb3cgbmV3IEVycm9yKGBVbmltcGxlbWVudGVkOiB2YWx1ZSBj aGVjayBmb3IgJHt0eXBlfWApOyAvLyBGSVhNRSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTYzNDIwIDY0LWJpdCB2YWx1ZXMKKyAgICBjYXNlICJpNjQiOiByZXR1cm4g dHJ1ZTsgLy8gRklYTUUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2 MzQyMCA2NC1iaXQgdmFsdWVzCiAgICAgY2FzZSAiZjMyIjogcmV0dXJuIHR5cGVvZih2YWx1ZSkg PT09ICJudW1iZXIiICYmIGlzRmluaXRlKHZhbHVlKTsKICAgICBjYXNlICJmNjQiOiByZXR1cm4g dHlwZW9mKHZhbHVlKSA9PT0gIm51bWJlciIgJiYgaXNGaW5pdGUodmFsdWUpOwogICAgIGRlZmF1 bHQ6IHRocm93IG5ldyBFcnJvcihgSW1wbGVtZW50YXRpb24gcHJvYmxlbTogdW5rbm93biB0eXBl ICR7dHlwZX1gKTsKQEAgLTU3LDYgKzU3LDE2IEBAIGNvbnN0IF9ub3JtYWxpemVGdW5jdGlvblNp Z25hdHVyZSA9IChwYXJhbXMsIHJldCkgPT4gewogICAgIHJldHVybiBbcGFyYW1zLCByZXRdOwog fTsKIAorY29uc3QgX2Vycm9ySGFuZGxpbmdQcm94eUZvciA9IGJ1aWxkZXIgPT4gYnVpbGRlclsi X19pc1Byb3h5Il0gPyBidWlsZGVyIDogbmV3IFByb3h5KGJ1aWxkZXIsIHsKKyAgICBnZXQ6ICh0 YXJnZXQsIHByb3BlcnR5LCByZWNlaXZlcikgPT4geworICAgICAgICBpZiAocHJvcGVydHkgPT09 ICJfX2lzUHJveHkiKQorICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIGlmICh0YXJn ZXRbcHJvcGVydHldID09PSB1bmRlZmluZWQpCisgICAgICAgICAgICB0aHJvdyBuZXcgRXJyb3Io YFdlYkFzc2VtYmx5IGJ1aWxkZXIgcmVjZWl2ZWQgdW5rbm93biBwcm9wZXJ0eSAnJHtwcm9wZXJ0 eX0nYCk7CisgICAgICAgIHJldHVybiB0YXJnZXRbcHJvcGVydHldOworICAgIH0KK30pOworCiBj b25zdCBfbWF5YmVSZWdpc3RlclR5cGUgPSAoYnVpbGRlciwgdHlwZSkgPT4gewogICAgIGNvbnN0 IHR5cGVTZWN0aW9uID0gYnVpbGRlci5fZ2V0U2VjdGlvbigiVHlwZSIpOwogICAgIGlmICh0eXBl b2YodHlwZSkgPT09ICJudW1iZXIiKSB7CkBAIC0xMDAsNyArMTEwLDcgQEAgY29uc3QgX2ltcG9y dEZ1bmN0aW9uQ29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9 PiB7CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHsgZmllbGQ6IGZpZWxkLCB0eXBlOiB0eXBl LCBraW5kOiAiRnVuY3Rpb24iLCBtb2R1bGU6IG1vZHVsZSB9KTsKICAgICAgICAgLy8gSW1wb3J0 cyBhbHNvIGNvdW50IGluIHRoZSBmdW5jdGlvbiBpbmRleCBzcGFjZS4gTWFwIHRoZW0gYXMgb2Jq ZWN0cyB0byBhdm9pZCBjbGFzaGluZyB3aXRoIENvZGUgZnVuY3Rpb25zJyBuYW1lcy4KICAgICAg ICAgYnVpbGRlci5fcmVnaXN0ZXJGdW5jdGlvblRvSW5kZXhTcGFjZSh7IG1vZHVsZTogbW9kdWxl LCBmaWVsZDogZmllbGQgfSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAg cmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH07CiB9Owog CkBAIC0xMDksNyArMTE5LDcgQEAgY29uc3QgX2ltcG9ydE1lbW9yeUNvbnRpbnVhdGlvbiA9IChi dWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgICAgICBhc3NlcnQuaXNTdHJp bmcobW9kdWxlLCBgSW1wb3J0IE1lbW9yeSBtb2R1bGUgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3Qg IiR7bW9kdWxlfSJgKTsKICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKGZpZWxkLCBgSW1wb3J0IE1l bW9yeSBmaWVsZCBzaG91bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHtmaWVsZH0iYCk7CiAgICAgICAg IHNlY3Rpb24uZGF0YS5wdXNoKHttb2R1bGUsIGZpZWxkLCBraW5kOiAiTWVtb3J5IiwgbWVtb3J5 RGVzY3JpcHRpb246IHtpbml0aWFsLCBtYXhpbXVtfX0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1 aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVy KTsKICAgICB9OwogfTsKIApAQCAtMTE4LDcgKzEyOCw3IEBAIGNvbnN0IF9pbXBvcnRUYWJsZUNv bnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgICAg ICBhc3NlcnQuaXNTdHJpbmcobW9kdWxlLCBgSW1wb3J0IFRhYmxlIG1vZHVsZSBzaG91bGQgYmUg YSBzdHJpbmcsIGdvdCAiJHttb2R1bGV9ImApOwogICAgICAgICBhc3NlcnQuaXNTdHJpbmcoZmll bGQsIGBJbXBvcnQgVGFibGUgZmllbGQgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7ZmllbGR9 ImApOwogICAgICAgICBzZWN0aW9uLmRhdGEucHVzaCh7bW9kdWxlLCBmaWVsZCwga2luZDogIlRh YmxlIiwgdGFibGVEZXNjcmlwdGlvbjoge2luaXRpYWwsIG1heGltdW0sIGVsZW1lbnR9fSk7Ci0g ICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5n UHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH07CiB9OwogCkBAIC0xNzIsNyArMTgyLDcgQEAg Y29uc3QgX2V4cG9ydEZ1bmN0aW9uQ29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5l eHRCdWlsZGVyKSA9PiB7CiAgICAgICAgICAgICAgICAgYXNzZXJ0LmVxKHR5cGUsIGV4cG9ydGVk SW1wb3J0LnR5cGUsIGBSZS1leHBvcnRpbmcgaW1wb3J0ICIke2V4cG9ydGVkSW1wb3J0LmZpZWxk fSIgYXMgIiR7ZmllbGR9IiBoYXMgbWlzbWF0Y2hpbmcgdHlwZWApOwogICAgICAgICB9CiAgICAg ICAgIHNlY3Rpb24uZGF0YS5wdXNoKHsgZmllbGQ6IGZpZWxkLCB0eXBlOiB0eXBlLCBraW5kOiAi RnVuY3Rpb24iLCBpbmRleDogaW5kZXggfSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsK KyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAg IH07CiB9OwogCkBAIC0xODksNyArMTk5LDcgQEAgY29uc3QgX2V4cG9ydEdsb2JhbENvbnRpbnVh dGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgIHJldHVybiAo ZmllbGQsIGluZGV4KSA9PiB7CiAgICAgICAgIGFzc2VydC5pc051bWJlcihpbmRleCwgYEdsb2Jh bCBleHBvcnRzIG9ubHkgc3VwcG9ydCBudW1iZXIgaW5kaWNlcyByaWdodCBub3dgKTsKICAgICAg ICAgc2VjdGlvbi5kYXRhLnB1c2goeyBmaWVsZCwga2luZDogIkdsb2JhbCIsIGluZGV4IH0pOwot ICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGlu Z1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9CiB9OwogCkBAIC0xOTcsNyArMjA3LDcgQEAg Y29uc3QgX2V4cG9ydE1lbW9yeUNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0 QnVpbGRlcikgPT4gewogICAgIHJldHVybiAoZmllbGQsIGluZGV4KSA9PiB7CiAgICAgICAgIGFz c2VydC5pc051bWJlcihpbmRleCwgYE1lbW9yeSBleHBvcnRzIG9ubHkgc3VwcG9ydCBudW1iZXIg aW5kaWNlc2ApOwogICAgICAgICBzZWN0aW9uLmRhdGEucHVzaCh7ZmllbGQsIGtpbmQ6ICJNZW1v cnkiLCBpbmRleH0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVy biBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9CiB9OwogCkBAIC0y MDUsNyArMjE1LDcgQEAgY29uc3QgX2V4cG9ydFRhYmxlQ29udGludWF0aW9uID0gKGJ1aWxkZXIs IHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgcmV0dXJuIChmaWVsZCwgaW5kZXgpID0+ IHsKICAgICAgICAgYXNzZXJ0LmlzTnVtYmVyKGluZGV4LCBgVGFibGUgZXhwb3J0cyBvbmx5IHN1 cHBvcnQgbnVtYmVyIGluZGljZXNgKTsKICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2goe2ZpZWxk LCBraW5kOiAiVGFibGUiLCBpbmRleH0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7Cisg ICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9 CiB9OwogCkBAIC0yMjAsMTAgKzIzMCwxMCBAQCBjb25zdCBfaW1wb3J0R2xvYmFsQ29udGludWF0 aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAgICAgICAg ICAgYXNzZXJ0LmlzU3RyaW5nKGZpZWxkLCBgSW1wb3J0IGdsb2JhbCBmaWVsZCBzaG91bGQgYmUg YSBzdHJpbmcsIGdvdCAiJHtmaWVsZH0iYCk7CiAgICAgICAgICAgICAgICAgYXNzZXJ0LmlzU3Ry aW5nKG11dGFiaWxpdHksIGBJbXBvcnQgZ2xvYmFsIG11dGFiaWxpdHkgc2hvdWxkIGJlIGEgc3Ry aW5nLCBnb3QgIiR7bXV0YWJpbGl0eX0iYCk7CiAgICAgICAgICAgICAgICAgc2VjdGlvbi5kYXRh LnB1c2goeyBnbG9iYWxEZXNjcmlwdGlvbjogeyB0eXBlOiBvcCwgbXV0YWJpbGl0eTogX25vcm1h bGl6ZU11dGFiaWxpdHkobXV0YWJpbGl0eSkgfSwgbW9kdWxlLCBmaWVsZCwga2luZDogIkdsb2Jh bCIgfSk7Ci0gICAgICAgICAgICAgICAgcmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgICAg ICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7CiAgICAg ICAgICAgICB9OwogICAgICAgICB9Ci0gICAgICAgIHJldHVybiBnbG9iYWxCdWlsZGVyOworICAg ICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICB9 OwogfTsKIApAQCAtMzI0LDExICszMzQsMTEgQEAgY29uc3QgX2NyZWF0ZUZ1bmN0aW9uQnVpbGRl ciA9IChmdW5jLCBidWlsZGVyLCBwcmV2aW91c0J1aWxkZXIpID0+IHsKICAgICAgICAgICAgIGRl ZmF1bHQ6CiAgICAgICAgICAgICAgICAgbmV4dEJ1aWxkZXIgPSBmdW5jdGlvbkJ1aWxkZXI7CiAg ICAgICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgICAgICAgICAgY2FzZSAiRW5kIjoKKyAgICAg ICAgICAgIGNhc2UgIkVuZCI6CiAgICAgICAgICAgICAgICAgbmV4dEJ1aWxkZXIgPSBwcmV2aW91 c0J1aWxkZXI7Ci0gICAgICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgICAgIGJy ZWFrOwogICAgICAgICAgICAgY2FzZSAiQmxvY2siOgotICAgICAgICAgICAgICAgIGNhc2UgIkxv b3AiOgorICAgICAgICAgICAgY2FzZSAiTG9vcCI6CiAgICAgICAgICAgICBjYXNlICJJZiI6CiAg ICAgICAgICAgICAgICAgbmV4dEJ1aWxkZXIgPSBfY3JlYXRlRnVuY3Rpb25CdWlsZGVyKGZ1bmMs IGJ1aWxkZXIsIGZ1bmN0aW9uQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgYnJlYWs7CkBAIC0z NDQsMTEgKzM1NCwxMiBAQCBjb25zdCBfY3JlYXRlRnVuY3Rpb25CdWlsZGVyID0gKGZ1bmMsIGJ1 aWxkZXIsIHByZXZpb3VzQnVpbGRlcikgPT4gewogICAgICAgICAgICAgY29uc3Qgc3RhY2tBcmdz ID0gW107IC8vIEZJWE1FIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x NjI3MDYKICAgICAgICAgICAgIGZ1bmMuY29kZS5wdXNoKHsgbmFtZTogb3AsIHZhbHVlOiB2YWx1 ZSwgYXJndW1lbnRzOiBzdGFja0FyZ3MsIGltbWVkaWF0ZXM6IGltbXMgfSk7CiAgICAgICAgICAg ICBpZiAoaGFzQ29udGludWF0aW9uKQotICAgICAgICAgICAgICAgIHJldHVybiBjb250aW51YXRp b24obmV4dEJ1aWxkZXIpLkVuZCgpOwotICAgICAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOwor ICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGNvbnRpbnVhdGlv bihuZXh0QnVpbGRlcikuRW5kKCkpOworICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5n UHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgICAgICB9OwotICAgIH0KLSAgICByZXR1cm4gZnVu Y3Rpb25CdWlsZGVyOworICAgIH07CisKKyAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZv cihmdW5jdGlvbkJ1aWxkZXIpOwogfQogCiBjb25zdCBfY3JlYXRlRnVuY3Rpb24gPSAoc2VjdGlv biwgYnVpbGRlciwgcHJldmlvdXNCdWlsZGVyKSA9PiB7CkBAIC00NDksMTAgKzQ2MCwxMCBAQCBl eHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgIEZ1 bmM6IChwYXJhbXMsIHJldCkgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtwYXJh bXMsIHJldF0gPSBfbm9ybWFsaXplRnVuY3Rpb25TaWduYXR1cmUocGFyYW1zLCByZXQpOwogICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKHsgcGFyYW1zOiBwYXJhbXMsIHJl dDogcmV0IH0pOwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiB0eXBlQnVpbGRl cjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94 eUZvcih0eXBlQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICB9LAogICAgICAgICAg ICAgICAgICAgICB9OwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gdHlwZUJ1aWxkZXI7Cisg ICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHR5cGVCdWls ZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC00 NjYsNyArNDc3LDcgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAg ICAgICAgICAgIGltcG9ydEJ1aWxkZXIuRnVuY3Rpb24gPSBfaW1wb3J0RnVuY3Rpb25Db250aW51 YXRpb24odGhpcywgcywgaW1wb3J0QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgIGltcG9y dEJ1aWxkZXIuTWVtb3J5ID0gX2ltcG9ydE1lbW9yeUNvbnRpbnVhdGlvbih0aGlzLCBzLCBpbXBv cnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgaW1wb3J0QnVpbGRlci5UYWJsZSA9IF9p bXBvcnRUYWJsZUNvbnRpbnVhdGlvbih0aGlzLCBzLCBpbXBvcnRCdWlsZGVyKTsKLSAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIGltcG9ydEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJl dHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGltcG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAg ICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTQ3Nyw3ICs0ODgsNyBAQCBleHBv cnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgIEVuZDog KCkgPT4gdGhpcwogICAgICAgICAgICAgICAgICAgICAgICAgLy8gRklYTUU6IGFkZCBhYmlsaXR5 IHRvIGFkZCB0aGlzIHdpdGggd2hhdGV2ZXIuCiAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAg ICAgICAgICAgICAgICAgIHJldHVybiBmdW5jdGlvbkJ1aWxkZXI7CisgICAgICAgICAgICAgICAg ICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGZ1bmN0aW9uQnVpbGRlcik7CiAgICAg ICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNDg4LDEwICs0OTks MTAgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAg ICAgICBFbmQ6ICgpID0+IHRoaXMsCiAgICAgICAgICAgICAgICAgICAgICAgICBUYWJsZTogKHtp bml0aWFsLCBtYXhpbXVtLCBlbGVtZW50fSkgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHMuZGF0YS5wdXNoKHt0YWJsZURlc2NyaXB0aW9uOiB7aW5pdGlhbCwgbWF4aW11bSwgZWxl bWVudH19KTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gdGFibGVCdWlsZGVy OworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5 Rm9yKHRhYmxlQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAg ICAgICAgICAgIH07Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiB0YWJsZUJ1aWxkZXI7Cisg ICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHRhYmxlQnVp bGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAt NTAyLDEwICs1MTMsMTAgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAg ICAgICAgICAgICAgICAgICBFbmQ6ICgpID0+IHRoaXMsCiAgICAgICAgICAgICAgICAgICAgICAg ICBJbml0aWFsTWF4UGFnZXM6IChpbml0aWFsLCBtYXgpID0+IHsKICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBzLmRhdGEucHVzaCh7IGluaXRpYWwsIG1heCB9KTsKLSAgICAgICAgICAgICAg ICAgICAgICAgICAgICByZXR1cm4gbWVtb3J5QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihtZW1vcnlCdWlsZGVyKTsKICAg ICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgfTsKLSAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIG1lbW9yeUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJl dHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG1lbW9yeUJ1aWxkZXIpOwogICAgICAgICAgICAg ICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTUxNiwxNiArNTI3LDE2IEBAIGV4 cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRW5k OiAoKSA9PiB0aGlzLAogICAgICAgICAgICAgICAgICAgICAgICAgR2V0R2xvYmFsOiAodHlwZSwg aW5pdFZhbHVlLCBtdXRhYmlsaXR5KSA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg cy5kYXRhLnB1c2goeyB0eXBlLCBvcDogImdldF9nbG9iYWwiLCBtdXRhYmlsaXR5OiBfbm9ybWFs aXplTXV0YWJpbGl0eShtdXRhYmlsaXR5KSwgaW5pdFZhbHVlIH0pOwotICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHJldHVybiBnbG9iYWxCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwogICAg ICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICB9OwogICAgICAgICAg ICAgICAgICAgICBmb3IgKGxldCBvcCBvZiBXQVNNLmRlc2NyaXB0aW9uLnZhbHVlX3R5cGUpIHsK ICAgICAgICAgICAgICAgICAgICAgICAgIGdsb2JhbEJ1aWxkZXJbX3RvSmF2YVNjcmlwdE5hbWUo b3ApXSA9IChpbml0VmFsdWUsIG11dGFiaWxpdHkpID0+IHsKICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBzLmRhdGEucHVzaCh7IHR5cGU6IG9wLCBvcDogb3AgKyAiLmNvbnN0IiwgbXV0YWJp bGl0eTogX25vcm1hbGl6ZU11dGFiaWxpdHkobXV0YWJpbGl0eSksIGluaXRWYWx1ZSB9KTsKLSAg ICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihnbG9iYWxC dWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgICAg IH0KLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgICAg ICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwog ICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTUzOSw3ICs1 NTAsNyBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAg ICAgZXhwb3J0QnVpbGRlci5GdW5jdGlvbiA9IF9leHBvcnRGdW5jdGlvbkNvbnRpbnVhdGlvbih0 aGlzLCBzLCBleHBvcnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgZXhwb3J0QnVpbGRl ci5NZW1vcnkgPSBfZXhwb3J0TWVtb3J5Q29udGludWF0aW9uKHRoaXMsIHMsIGV4cG9ydEJ1aWxk ZXIpOwogICAgICAgICAgICAgICAgICAgICBleHBvcnRCdWlsZGVyLlRhYmxlID0gX2V4cG9ydFRh YmxlQ29udGludWF0aW9uKHRoaXMsIHMsIGV4cG9ydEJ1aWxkZXIpOwotICAgICAgICAgICAgICAg ICAgICByZXR1cm4gZXhwb3J0QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9l cnJvckhhbmRsaW5nUHJveHlGb3IoZXhwb3J0QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsK ICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNTUyLDcgKzU2Myw3IEBAIGV4cG9ydCBkZWZh dWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICBpZiAodHlwZW9mKGZ1bmN0 aW9uSW5kZXhPck5hbWUpICE9PSAibnVtYmVyIiAmJiB0eXBlb2YoZnVuY3Rpb25JbmRleE9yTmFt ZSkgIT09ICJzdHJpbmciKQogICAgICAgICAgICAgICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9y KGBTdGFydCBzZWN0aW9uJ3MgZnVuY3Rpb24gaW5kZXggIG11c3QgZWl0aGVyIGJlIGEgbnVtYmVy IG9yIGEgc3RyaW5nYCk7CiAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKGZ1bmN0aW9u SW5kZXhPck5hbWUpOwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gc3RhcnRCdWlsZGVyOwor ICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihzdGFydEJ1 aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAg LTU2MywxMSArNTc0LDExIEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAg ICAgICAgICAgICAgICAgICAgRW5kOiAoKSA9PiB0aGlzLAogICAgICAgICAgICAgICAgICAgICAg ICAgRWxlbWVudDogKHt0YWJsZUluZGV4ID0gMCwgb2Zmc2V0LCBmdW5jdGlvbkluZGljZXN9KSA9 PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcy5kYXRhLnB1c2goe3RhYmxlSW5kZXgs IG9mZnNldCwgZnVuY3Rpb25JbmRpY2VzfSk7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAg cmV0dXJuIGVsZW1lbnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVy biBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGVsZW1lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAg ICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgfTsKIAotICAgICAgICAgICAgICAgICAg ICByZXR1cm4gZWxlbWVudEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJy b3JIYW5kbGluZ1Byb3h5Rm9yKGVsZW1lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9Owog ICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC02MzIsMTIgKzY0MywxMiBAQCBleHBvcnQgZGVm YXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IC8vIEZJWE1FIGluIGNoZWNrZWQgbW9kZSwgdGVzdCB0aGF0IHRoZSB0eXBlIGlzIGFjY2VwdGFi bGUgZm9yIHN0YXJ0IGZ1bmN0aW9uLiBXZSBwcm9iYWJseSB3YW50IF9yZWdpc3RlckZ1bmN0aW9u VG9JbmRleFNwYWNlIHRvIGFsc28gcmVnaXN0ZXIgdHlwZXMgcGVyIGluZGV4LiBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1NjU4CiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAg ICAgICAgICAgICAgICAgICAgcmV0dXJuIGJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoYnVpbGRlcik7CiAgICAgICAgICAg ICAgICAgICAgICAgICB9LAogCiAgICAgICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAg ICAgICAgIGNvZGVCdWlsZGVyLkZ1bmN0aW9uID0gX2NyZWF0ZUZ1bmN0aW9uKHMsIGJ1aWxkZXIs IGNvZGVCdWlsZGVyKTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGNvZGVCdWlsZGVyOwor ICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihjb2RlQnVp bGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAt NjYwLDE5ICs2NzEsMTkgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIEluZGV4OiBpbmRleCA9PiB7CiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBhc3NlcnQuZXEoaW5kZXgsIDApOyAvLyBMaW5lYXIgbWVt b3J5IGluZGV4IG11c3QgYmUgemVybyBpbiBNVlAuCiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB0aGlzU2VnbWVudC5pbmRleCA9IGluZGV4OwotICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgcmV0dXJuIHNlZ21lbnRCdWlsZGVyOworICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3Ioc2VnbWVu dEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9LAogICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBPZmZzZXQ6IG9mZnNldCA9PiB7CiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAvLyBGSVhNRSBhbGxvdyBjb21wbGV4IGluaXRfZXhwciBo ZXJlLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1NzAwCiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhc3NlcnQuaXNOdW1iZXIob2Zmc2V0KTsK ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRoaXNTZWdtZW50Lm9mZnNldCA9 IG9mZnNldDsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBzZWdt ZW50QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBf ZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHNlZ21lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgfSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9OwotICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBzZWdtZW50QnVpbGRlcjsKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihzZWdtZW50QnVp bGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICB9 OwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gZGF0YUJ1aWxkZXI7CisgICAgICAgICAgICAg ICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGRhdGFCdWlsZGVyKTsKICAgICAg ICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC02OTAsMTAgKzcwMSwx MCBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICBCeXRl OiBiID0+IHsKICAgICAgICAgICAgICAgICAgICAgYXNzZXJ0LmVxKGIgJiAweEZGLCBiLCBgVW5r bm93biBzZWN0aW9uIGV4cGVjdGVkIGJ5dGUsIGdvdDogIiR7Yn0iYCk7CiAgICAgICAgICAgICAg ICAgICAgIHMuZGF0YS5wdXNoKGIpOwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gdW5rbm93 bkJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5 Rm9yKHVua25vd25CdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9Owot ICAgICAgICAgICAgcmV0dXJuIHVua25vd25CdWlsZGVyOworICAgICAgICAgICAgcmV0dXJuIF9l cnJvckhhbmRsaW5nUHJveHlGb3IodW5rbm93bkJ1aWxkZXIpOwogICAgICAgICB9OwogICAgIH0K ICAgICBfYWRkU2VjdGlvbihuYW1lT3JOdW1iZXIsIGV4dHJhT2JqZWN0KSB7CmRpZmYgLS1naXQg YS9KU1Rlc3RzL3dhc20vTG93TGV2ZWxCaW5hcnkuanMgYi9KU1Rlc3RzL3dhc20vTG93TGV2ZWxC aW5hcnkuanMKaW5kZXggNjExYTI2ZC4uZjliYzhhMyAxMDA2NDQKLS0tIGEvSlNUZXN0cy93YXNt L0xvd0xldmVsQmluYXJ5LmpzCisrKyBiL0pTVGVzdHMvd2FzbS9Mb3dMZXZlbEJpbmFyeS5qcwpA QCAtMTcwLDYgKzE3MCwxOCBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBMb3dMZXZlbEJpbmFyeSB7 CiAgICAgICAgICAgICB0aGlzLnVpbnQ4KDB4ODAgfCBiKTsKICAgICAgICAgfSB3aGlsZSAodHJ1 ZSk7CiAgICAgfQorICAgIHZhcnVpbnQ2NCh2KSB7CisgICAgICAgIGFzc2VydC5pc051bWJlcih2 KTsKKyAgICAgICAgaWYgKHYgPCB2YXJ1aW50MzJNaW4gfHwgdmFydWludDMyTWF4IDwgdikKKyAg ICAgICAgICAgIHRocm93IG5ldyBSYW5nZUVycm9yKGB1bmltcGxlbWVudGVkOiB2YXJ1aW50NjQg bGFyZ2VyIHRoYW4gMzItYml0YCk7CisgICAgICAgIHRoaXMudmFydWludDMyKHYpOyAvLyBGSVhN RSBpbXBsZW1lbnQgNjQtYml0IHZhcnt1fWludCBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTYzNDIwCisgICAgfQorICAgIHZhcmludDY0KHYpIHsKKyAgICAgICAgYXNz ZXJ0LmlzTnVtYmVyKHYpOworICAgICAgICBpZiAodiA8IHZhcmludDMyTWluIHx8IHZhcmludDMy TWF4IDwgdikKKyAgICAgICAgICAgIHRocm93IG5ldyBSYW5nZUVycm9yKGB1bmltcGxlbWVudGVk OiB2YXJpbnQ2NCBsYXJnZXIgdGhhbiAzMi1iaXRgKTsKKyAgICAgICAgdGhpcy52YXJpbnQzMih2 KTsgLy8gRklYTUUgaW1wbGVtZW50IDY0LWJpdCB2YXJ7dX1pbnQgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MzQyMAorICAgIH0KICAgICB2YXJ1aW50MSh2KSB7CiAg ICAgICAgIGlmICh2ICE9PSAwICYmIHYgIT09IDEpCiAgICAgICAgICAgICB0aHJvdyBuZXcgUmFu Z2VFcnJvcihgSW52YWxpZCB2YXJ1aW50MSAke3Z9IHJhbmdlIGlzIFswLCAxXWApOwpkaWZmIC0t Z2l0IGEvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMgYi9KU1Rlc3Rz L3dhc20vZnVuY3Rpb24tdGVzdHMvZXhjZXB0aW9ucy5qcwppbmRleCBkMmIzYTQ5Li45NTI1MTNm IDEwMDY0NAotLS0gYS9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvZXhjZXB0aW9ucy5qcwor KysgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvZXhjZXB0aW9ucy5qcwpAQCAtNDUsMTgg KzQ1LDE4IEBAIGZ1bmN0aW9uIG1ha2VJbnN0YW5jZSgpIHsKICAgICBhc3NlcnQuZXEodGFibGUu Z2V0KDApLCBudWxsKTsKIAogICAgIGZvciAobGV0IGkgPSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0g ICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDAsIGkpLCBXZWJBc3NlbWJseS5SdW50aW1l RXJyb3IsICJjYWxsX2luZGlyZWN0IHRvIGEgbnVsbCB0YWJsZSBlbnRyeSAoZXZhbHVhdGluZyAn ZnVuYyguLi5hcmdzKScpIik7CisgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDAsIGkp LCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJjYWxsX2luZGlyZWN0IHRvIGEgbnVsbCB0YWJs ZSBlbnRyeSIpOwogICAgIH0KIAogICAgIHRhYmxlLnNldCgwLCBmb28pOwogICAgIGFzc2VydC5l cSh0YWJsZS5nZXQoMCksIGZvbyk7CiAKICAgICBmb3IgKGxldCBpID0gMDsgaSA8IDEwMDA7IGkr KykgewotICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbygxICsgaSwgaSksIFdlYkFzc2Vt Ymx5LlJ1bnRpbWVFcnJvciwgIk91dCBvZiBib3VuZHMgY2FsbF9pbmRpcmVjdCAoZXZhbHVhdGlu ZyAnZnVuYyguLi5hcmdzKScpIik7CisgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDEg KyBpLCBpKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9yLCAiT3V0IG9mIGJvdW5kcyBjYWxsX2lu ZGlyZWN0Iik7CiAgICAgfQogCiAgICAgZm9yIChsZXQgaSA9IDA7IGkgPCAxMDAwOyBpKyspIHsK LSAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBmb28oMCwgaSksIFdlYkFzc2VtYmx5LlJ1bnRp bWVFcnJvciwgImNhbGxfaW5kaXJlY3QgdG8gYSBzaWduYXR1cmUgdGhhdCBkb2VzIG5vdCBtYXRj aCAoZXZhbHVhdGluZyAnZnVuYyguLi5hcmdzKScpIik7CisgICAgICAgIGFzc2VydC50aHJvd3Mo KCkgPT4gZm9vKDAsIGkpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJjYWxsX2luZGlyZWN0 IHRvIGEgc2lnbmF0dXJlIHRoYXQgZG9lcyBub3QgbWF0Y2giKTsKICAgICB9CiAKICAgICB0YWJs ZS5zZXQoMCwgYmFyKTsKZGlmZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90 cmFwLWxvYWQuanMgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpzCmlu ZGV4IDRkZDgyZGMuLjEyMzFlMDMgMTAwNjQ0Ci0tLSBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10 ZXN0cy90cmFwLWxvYWQuanMKKysrIGIvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAt bG9hZC5qcwpAQCAtMjksNiArMjksNiBAQCBmdW5jdGlvbiB3YXNtRnJhbWVDb3VudEZyb21FcnJv cihlKSB7CiB9CiAKIGZvciAobGV0IGkgPSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0gICAgY29uc3Qg ZSA9IGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKG51bVBhZ2VzICogcGFnZVNpemUgKyAxKSwgV2Vi QXNzZW1ibHkuUnVudGltZUVycm9yLCAiT3V0IG9mIGJvdW5kcyBtZW1vcnkgYWNjZXNzIChldmFs dWF0aW5nICdmdW5jKC4uLmFyZ3MpJykiKTsKKyAgICBjb25zdCBlID0gYXNzZXJ0LnRocm93cygo KSA9PiBmb28obnVtUGFnZXMgKiBwYWdlU2l6ZSArIDEpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJy b3IsICJPdXQgb2YgYm91bmRzIG1lbW9yeSBhY2Nlc3MiKTsKICAgICBhc3NlcnQuZXEod2FzbUZy YW1lQ291bnRGcm9tRXJyb3IoZSksIDIpOwogfQpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2Z1 bmN0aW9uLXRlc3RzL3RyYXAtc3RvcmUuanMgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMv dHJhcC1zdG9yZS5qcwppbmRleCA1NTk4N2MyLi4zNjU3MTNhIDEwMDY0NAotLS0gYS9KU1Rlc3Rz L3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5qcworKysgYi9KU1Rlc3RzL3dhc20vZnVu Y3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5qcwpAQCAtMjUsNSArMjUsNSBAQCBjb25zdCBudW1QYWdl cyA9IDEwOwogICAgIGNvbnN0IGZvbyA9IG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShtb2R1bGUs IHthOiB7YjogbmV3IFdlYkFzc2VtYmx5Lk1lbW9yeSh7aW5pdGlhbDogbnVtUGFnZXN9KX19KS5l eHBvcnRzLmZvbzsKIAogICAgIGZvciAobGV0IGkgPSAwOyBpIDwgMTAwMDA7IGkrKykKLSAgICAg ICAgYXNzZXJ0LnRocm93cygoKSA9PiBmb28oaSwgbnVtUGFnZXMgKiBwYWdlU2l6ZSArIDEpLCBX ZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJPdXQgb2YgYm91bmRzIG1lbW9yeSBhY2Nlc3MgKGV2 YWx1YXRpbmcgJ2Z1bmMoLi4uYXJncyknKSIpOworICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+ IGZvbyhpLCBudW1QYWdlcyAqIHBhZ2VTaXplICsgMSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJv ciwgIk91dCBvZiBib3VuZHMgbWVtb3J5IGFjY2VzcyIpOwogfQpkaWZmIC0tZ2l0IGEvSlNUZXN0 cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20tYmFkLXNpZ25hdHVyZS5qcyBiL0pTVGVzdHMvd2Fz bS9qcy1hcGkvd2FzbS10by13YXNtLWJhZC1zaWduYXR1cmUuanMKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMC4uZDY5YmEyYwotLS0gL2Rldi9udWxsCisrKyBiL0pTVGVzdHMvd2Fz bS9qcy1hcGkvd2FzbS10by13YXNtLWJhZC1zaWduYXR1cmUuanMKQEAgLTAsMCArMSwxMDUgQEAK K2ltcG9ydCAqIGFzIGFzc2VydCBmcm9tICcuLi9hc3NlcnQuanMnOworaW1wb3J0IEJ1aWxkZXIg ZnJvbSAnLi4vQnVpbGRlci5qcyc7CisKK2NvbnN0IGltcG9ydE5hbWUgPSAicGllck9uZSI7Citj b25zdCB0eXBlcyA9IFsiaTMyIiwgImk2NCIsICJmMzIiLCAiZjY0IiwgInZvaWQiXTsKK2NvbnN0 IHR5cGVzTm9uVm9pZCA9IFsiaTMyIiwgImk2NCIsICJmMzIiLCAiZjY0Il07Citjb25zdCBzd2Fw VHlwZSA9ICh0eXBlLCBpbmRleCkgPT4gdHlwZXNbKHR5cGVzLmluZGV4T2YodHlwZSkgKyBpbmRl eCkgJSB0eXBlcy5sZW5ndGhdOworY29uc3Qgc3dhcFR5cGVOb25Wb2lkID0gKHR5cGUsIGluZGV4 KSA9PiB0eXBlc05vblZvaWRbKHR5cGVzTm9uVm9pZC5pbmRleE9mKHR5cGUpICsgaW5kZXgpICUg dHlwZXNOb25Wb2lkLmxlbmd0aF07CisKK2NvbnN0IHNpZ25hdHVyZXMgPSBbCisgICAgeyBwYXJh bXM6IFsiaTMyIl0sIHJldDogInZvaWQiIH0sCisgICAgeyBwYXJhbXM6IFsiaTY0Il0sIHJldDog InZvaWQiIH0sCisgICAgeyBwYXJhbXM6IFsiZjMyIl0sIHJldDogInZvaWQiIH0sCisgICAgeyBw YXJhbXM6IFsiZjY0Il0sIHJldDogInZvaWQiIH0sCisgICAgeyBwYXJhbXM6IFsiaTMyIl0sIHJl dDogImkzMiIgfSwKKyAgICB7IHBhcmFtczogWyJpNjQiXSwgcmV0OiAiaTY0IiB9LAorICAgIHsg cGFyYW1zOiBbImYzMiJdLCByZXQ6ICJmMzIiIH0sCisgICAgeyBwYXJhbXM6IFsiZjY0Il0sIHJl dDogImY2NCIgfSwKKyAgICB7IHBhcmFtczogWyJpMzIiLCAiZjMyIl0sIHJldDogImkzMiIgfSwK KyAgICB7IHBhcmFtczogWyJmMzIiLCAiaTMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7IHBhcmFt czogWyJpNjQiLCAiZjY0Il0sIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogWyJmNjQiLCAi aTY0Il0sIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogWyJpMzIiLCAiZjMyIiwgImkzMiJd LCByZXQ6ICJpMzIiIH0sCisgICAgeyBwYXJhbXM6IFsiaTMyIiwgImYzMiIsICJpMzIiXSwgcmV0 OiAiaTMyIiB9LAorICAgIHsgcGFyYW1zOiBbImk2NCIsICJmNjQiLCAiaTY0Il0sIHJldDogImk2 NCIgfSwKKyAgICB7IHBhcmFtczogWyJpNjQiLCAiZjY0IiwgImk2NCJdLCByZXQ6ICJpNjQiIH0s CisgICAgeyBwYXJhbXM6IEFycmF5KDMyKS5maWxsKCJpMzIiKSwgcmV0OiAiaTY0IiB9LAorICAg IHsgcGFyYW1zOiBBcnJheSgzMikuZmlsbCgiaTY0IiksIHJldDogImk2NCIgfSwKKyAgICB7IHBh cmFtczogQXJyYXkoMzIpLmZpbGwoImYzMiIpLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6 IEFycmF5KDMyKS5maWxsKCJmNjQiKSwgcmV0OiAiaTY0IiB9LAorXTsKKworY29uc3QgbWFrZUlt cG9ydGVyID0gc2lnbmF0dXJlID0+IHsKKyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVy KCkpCisgICAgICAgIC5UeXBlKCkuRW5kKCkKKyAgICAgICAgLkltcG9ydCgpLkZ1bmN0aW9uKCJl eHBvcnRzIiwgaW1wb3J0TmFtZSwgc2lnbmF0dXJlKS5FbmQoKTsKKyAgICByZXR1cm4gbmV3IFdl YkFzc2VtYmx5Lk1vZHVsZShidWlsZGVyLldlYkFzc2VtYmx5KCkuZ2V0KCkpOworfTsKKworY29u c3QgbWFrZUltcG9ydGVlID0gc2lnbmF0dXJlID0+IHsKKyAgICBjb25zdCBidWlsZGVyID0gKG5l dyBCdWlsZGVyKCkpCisgICAgICAgIC5UeXBlKCkuRW5kKCkKKyAgICAgICAgLkZ1bmN0aW9uKCku RW5kKCkKKyAgICAgICAgLkV4cG9ydCgpCisgICAgICAgICAgICAuRnVuY3Rpb24oaW1wb3J0TmFt ZSkKKyAgICAgICAgLkVuZCgpCisgICAgICAgIC5Db2RlKCkKKyAgICAgICAgICAgIC5GdW5jdGlv bihpbXBvcnROYW1lLCBzaWduYXR1cmUpOworICAgIHN3aXRjaCAoc2lnbmF0dXJlLnJldCkgewor ICAgIGNhc2UgImkzMiI6IGJ1aWxkZXIuSTMyQ29uc3QoMCk7IGJyZWFrOworICAgIGNhc2UgImk2 NCI6IGJ1aWxkZXIuSTY0Q29uc3QoMCk7IGJyZWFrOworICAgIGNhc2UgImYzMiI6IGJ1aWxkZXIu RjMyQ29uc3QoMCk7IGJyZWFrOworICAgIGNhc2UgImY2NCI6IGJ1aWxkZXIuRjY0Q29uc3QoMCk7 IGJyZWFrOworICAgIGNhc2UgInZvaWQiOiBicmVhazsKKyAgICB9CisgICAgcmV0dXJuIG5ldyBX ZWJBc3NlbWJseS5JbnN0YW5jZShuZXcgV2ViQXNzZW1ibHkuTW9kdWxlKGJ1aWxkZXIuUmV0dXJu KCkuRW5kKCkuRW5kKCkuV2ViQXNzZW1ibHkoKS5nZXQoKSkpOworfTsKKworKGZ1bmN0aW9uIEJh ZFNpZ25hdHVyZURyb3BTdGFydFBhcmFtcygpIHsKKyAgICBmb3IgKGxldCBzaWduYXR1cmUgb2Yg c2lnbmF0dXJlcykgeworICAgICAgICBjb25zdCBpbXBvcnRlZSA9IG1ha2VJbXBvcnRlZShzaWdu YXR1cmUpOworICAgICAgICBmb3IgKGxldCBpID0gMTsgaSA8PSBzaWduYXR1cmUucGFyYW1zLmxl bmd0aDsgKytpKSB7CisgICAgICAgICAgICBjb25zdCBiYWRQYXJhbVNpZ25hdHVyZSA9IHsgcGFy YW1zOiBzaWduYXR1cmUucGFyYW1zLnNsaWNlKGksIHNpZ25hdHVyZS5wYXJhbXMubGVuZ3RoKSwg cmV0OiBzaWduYXR1cmUucmV0IH07CisgICAgICAgICAgICBjb25zdCBpbXBvcnRlciA9IG1ha2VJ bXBvcnRlcihiYWRQYXJhbVNpZ25hdHVyZSk7CisgICAgICAgICAgICBhc3NlcnQudGhyb3dzKCgp ID0+IG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpLCBXZWJBc3Nl bWJseS5MaW5rRXJyb3IsIGBpbXBvcnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBkb2Vzbid0IG1h dGNoIHRoZSBwcm92aWRlZCBXZWJBc3NlbWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSAoZXZhbHVh dGluZyAnbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSknKWApOwor ICAgICAgICB9CisgICAgfQorfSkoKTsKKworKGZ1bmN0aW9uIEJhZFNpZ25hdHVyZURyb3BFbmRQ YXJhbXMoKSB7CisgICAgZm9yIChsZXQgc2lnbmF0dXJlIG9mIHNpZ25hdHVyZXMpIHsKKyAgICAg ICAgY29uc3QgaW1wb3J0ZWUgPSBtYWtlSW1wb3J0ZWUoc2lnbmF0dXJlKTsKKyAgICAgICAgZm9y IChsZXQgaSA9IDE7IGkgPCBzaWduYXR1cmUucGFyYW1zLmxlbmd0aDsgKytpKSB7CisgICAgICAg ICAgICBjb25zdCBiYWRQYXJhbVNpZ25hdHVyZSA9IHsgcGFyYW1zOiBzaWduYXR1cmUucGFyYW1z LnNsaWNlKDAsIGkpLCByZXQ6IHNpZ25hdHVyZS5yZXQgfTsKKyAgICAgICAgICAgIGNvbnN0IGlt cG9ydGVyID0gbWFrZUltcG9ydGVyKGJhZFBhcmFtU2lnbmF0dXJlKTsKKyAgICAgICAgICAgIGFz c2VydC50aHJvd3MoKCkgPT4gbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBv cnRlZSksIFdlYkFzc2VtYmx5LkxpbmtFcnJvciwgYGltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0 dXJlIGRvZXNuJ3QgbWF0Y2ggdGhlIHByb3ZpZGVkIFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2ln bmF0dXJlIChldmFsdWF0aW5nICduZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGlt cG9ydGVlKScpYCk7CisgICAgICAgIH0KKyAgICB9Cit9KSgpOworCisoZnVuY3Rpb24gQmFkU2ln bmF0dXJlU3dhcFBhcmFtKCkgeworICAgIGZvciAobGV0IHNpZ25hdHVyZSBvZiBzaWduYXR1cmVz KSB7CisgICAgICAgIGNvbnN0IGltcG9ydGVlID0gbWFrZUltcG9ydGVlKHNpZ25hdHVyZSk7Cisg ICAgICAgIGZvciAobGV0IHNpZ25hdHVyZUluZGV4ID0gMDsgc2lnbmF0dXJlSW5kZXggPCBzaWdu YXR1cmUubGVuZ3RoOyArK3NpZ25hdHVyZUluZGV4KSB7CisgICAgICAgICAgICBmb3IgKGxldCB0 eXBlSW5kZXggPSAxOyB0eXBlSW5kZXggPCB0eXBlc05vblZvaWQubGVuZ3RoOyArK3R5cGVJbmRl eCkgeworICAgICAgICAgICAgICAgIGxldCBiYWRQYXJhbXMgPSBzaWduYXR1cmUucGFyYW1zLnNs aWNlKCk7CisgICAgICAgICAgICAgICAgYmFkUGFyYW1zW3NpZ25hdHVyZUluZGV4XSA9IHN3YXBU eXBlTm9uVm9pZChiYWRQYXJhbXNbc2lnbmF0dXJlSW5kZXhdLCB0eXBlSW5kZXgpOworICAgICAg ICAgICAgICAgIGNvbnN0IGJhZFBhcmFtU2lnbmF0dXJlID0geyBwYXJhbXM6IGJhZFBhcmFtcywg cmV0OiBzaWduYXR1cmUucmV0IH07CisgICAgICAgICAgICAgICAgY29uc3QgaW1wb3J0ZXIgPSBt YWtlSW1wb3J0ZXIoYmFkUGFyYW1TaWduYXR1cmUpOworICAgICAgICAgICAgICAgIGFzc2VydC50 aHJvd3MoKCkgPT4gbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSks IFdlYkFzc2VtYmx5LkxpbmtFcnJvciwgYGltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIGRv ZXNuJ3QgbWF0Y2ggdGhlIHByb3ZpZGVkIFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2lnbmF0dXJl IChldmFsdWF0aW5nICduZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVl KScpYCk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9Cit9KSgpOworCisoZnVuY3Rp b24gQmFkU2lnbmF0dXJlUmV0KCkgeworICAgIGZvciAobGV0IHNpZ25hdHVyZSBvZiBzaWduYXR1 cmVzKSB7CisgICAgICAgIGNvbnN0IGltcG9ydGVlID0gbWFrZUltcG9ydGVlKHNpZ25hdHVyZSk7 CisgICAgICAgIGZvciAobGV0IHR5cGVJbmRleCA9IDE7IHR5cGVJbmRleCA8IHR5cGVzLmxlbmd0 aDsgKyt0eXBlSW5kZXgpIHsKKyAgICAgICAgICAgIGNvbnN0IGJhZFBhcmFtU2lnbmF0dXJlID0g eyBwYXJhbXM6IHNpZ25hdHVyZS5wYXJhbXMsIHJldDogc3dhcFR5cGUoc2lnbmF0dXJlLnJldCwg dHlwZUluZGV4KSB9OworICAgICAgICAgICAgY29uc3QgaW1wb3J0ZXIgPSBtYWtlSW1wb3J0ZXIo YmFkUGFyYW1TaWduYXR1cmUpOworICAgICAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBuZXcg V2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKSwgV2ViQXNzZW1ibHkuTGlu a0Vycm9yLCBgaW1wb3J0ZWQgZnVuY3Rpb24ncyBzaWduYXR1cmUgZG9lc24ndCBtYXRjaCB0aGUg cHJvdmlkZWQgV2ViQXNzZW1ibHkgZnVuY3Rpb24ncyBzaWduYXR1cmUgKGV2YWx1YXRpbmcgJ25l dyBXZWJBc3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpJylgKTsKKyAgICAgICAg fQorICAgIH0KK30pKCk7CmRpZmYgLS1naXQgYS9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8t d2FzbS5qcyBiL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLmpzCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjUyNGU0NTMKLS0tIC9kZXYvbnVsbAorKysgYi9KU1Rl c3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS5qcwpAQCAtMCwwICsxLDcyIEBACitpbXBvcnQg KiBhcyBhc3NlcnQgZnJvbSAnLi4vYXNzZXJ0LmpzJzsKK2ltcG9ydCBCdWlsZGVyIGZyb20gJy4u L0J1aWxkZXIuanMnOworCitjb25zdCBjYWxsZXJUb3BCaXRzID0gMHhDMEZFQkVFRjsKK2NvbnN0 IGlubmVyUmV0dXJuSGkgPSAweERFQURGQUNFOworY29uc3QgaW5uZXJSZXR1cm5MbyA9IDB4QzBG RUMwRkU7CisKK2NvbnN0IGNhbGxlck1vZHVsZSA9ICgpID0+IHsKKyAgICBjb25zdCBidWlsZGVy ID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAgIC5UeXBlKCkuRW5kKCkKKyAgICAgICAgLkltcG9y dCgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImV4cG9ydHMiLCAiY2FsbE1lIiwgeyBwYXJhbXM6 IFsiaTY0Il0sIHJldDogImk2NCIgfSkKKyAgICAgICAgLkVuZCgpCisgICAgICAgIC5GdW5jdGlv bigpLkVuZCgpCisgICAgICAgIC5FeHBvcnQoKQorICAgICAgICAgICAgLkZ1bmN0aW9uKCJlbnRy eSIpCisgICAgICAgIC5FbmQoKQorICAgICAgICAuQ29kZSgpCisgICAgICAgICAgICAuRnVuY3Rp b24oImVudHJ5IiwgeyBwYXJhbXM6IFsiaTMyIl0sIHJldDogImkzMiIgfSwgWyJpNjQiXSkKKyAg ICAgICAgICAgICAgICAuSTMyQ29uc3QoY2FsbGVyVG9wQml0cykuSTY0RXh0ZW5kVUkzMigpLkkz MkNvbnN0KDMyKS5JNjRFeHRlbmRVSTMyKCkuSTY0U2hsKCkgLy8gKChpNjQpY2FsbGVyVG9wQml0 cykgPDwgMzIKKyAgICAgICAgICAgICAgICAuR2V0TG9jYWwoMCkuSTY0RXh0ZW5kVUkzMigpCisg ICAgICAgICAgICAgICAgLkk2NE9yKCkgLy8gdmFsdWU6IHBhcmFtIHwgKCgoaTY0KWNhbGxlclRv cEJpdHMgPDwgMzIpKQorICAgICAgICAgICAgICAgIC5DYWxsKDApIC8vIENhbGxzIGV4cG9ydHMu Y2FsbE1lKHBhcmFtIHwgKCgoaTY0KWNhbGxlclRvcEJpdHMpIDw8IDMyKSkuCisgICAgICAgICAg ICAgICAgLlRlZUxvY2FsKDEpLkkzMldyYXBJNjQoKSAvLyBsbzogKGkzMiljYWxsUmVzdWx0Cisg ICAgICAgICAgICAgICAgLkdldExvY2FsKDEpLkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRVSTMyKCku STY0U2hyVSgpLkkzMldyYXBJNjQoKSAvLyBoaTogKGkzMikoY2FsbFJlc3VsdCA+PiAzMikKKyAg ICAgICAgICAgICAgICAuSTMyWG9yKCkKKyAgICAgICAgICAgICAgICAuUmV0dXJuKCkKKyAgICAg ICAgICAgIC5FbmQoKQorICAgICAgICAuRW5kKCk7CisgICAgcmV0dXJuIG5ldyBXZWJBc3NlbWJs eS5Nb2R1bGUoYnVpbGRlci5XZWJBc3NlbWJseSgpLmdldCgpKTsKK307CisKK2NvbnN0IGNhbGxl ZU1vZHVsZSA9ICgpID0+IHsKKyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVyKCkpCisg ICAgICAgIC5UeXBlKCkuRW5kKCkKKyAgICAgICAgLkltcG9ydCgpCisgICAgICAgICAgICAuRnVu Y3Rpb24oImltcCIsICJmdW5jIiwgeyBwYXJhbXM6IFsiaTMyIiwgImkzMiJdLCByZXQ6ICJpMzIi IH0pCisgICAgICAgIC5FbmQoKQorICAgICAgICAuRnVuY3Rpb24oKS5FbmQoKQorICAgICAgICAu RXhwb3J0KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigiY2FsbE1lIikKKyAgICAgICAgLkVuZCgp CisgICAgICAgIC5Db2RlKCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigiY2FsbE1lIiwgeyBwYXJh bXM6IFsiaTY0Il0sIHJldDogImk2NCIgfSkKKyAgICAgICAgICAgICAgICAuR2V0TG9jYWwoMCku STMyV3JhcEk2NCgpIC8vIGxvOiAoaTMyKXBhcmFtCisgICAgICAgICAgICAgICAgLkdldExvY2Fs KDApLkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRVSTMyKCkuSTY0U2hyVSgpLkkzMldyYXBJNjQoKSAv LyBoaTogKGkzMikocGFyYW0gPj4gMzIpCisgICAgICAgICAgICAgICAgLkNhbGwoMCkgLy8gQ2Fs bHMgaW1wLmZ1bmMgd2l0aCB0aGUgNjQtYml0IHZhbHVlIGFzIGkzMiB7IGhpLCBsbyB9LgorICAg ICAgICAgICAgICAgIC5Ecm9wKCkKKyAgICAgICAgICAgICAgICAuSTMyQ29uc3QoaW5uZXJSZXR1 cm5IaSkuSTY0RXh0ZW5kVUkzMigpLkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRVSTMyKCkuSTY0U2hs KCkuSTMyQ29uc3QoaW5uZXJSZXR1cm5MbykuSTY0RXh0ZW5kVUkzMigpLkk2NE9yKCkgLy8gKChp NjQpaGkgPDwgMzIpIHwgKGk2NClsbworICAgICAgICAgICAgICAgIC5SZXR1cm4oKQorICAgICAg ICAgICAgLkVuZCgpCisgICAgICAgIC5FbmQoKTsKKyAgICByZXR1cm4gbmV3IFdlYkFzc2VtYmx5 Lk1vZHVsZShidWlsZGVyLldlYkFzc2VtYmx5KCkuZ2V0KCkpOworfTsKKworKGZ1bmN0aW9uIFdh c21Ub1dhc20oKSB7CisgICAgbGV0IHZhbHVlOworICAgIGNvbnN0IGZ1bmMgPSAoaGksIGxvKSA9 PiB7IHZhbHVlID0geyBoaTogaGksIGxvOiBsbyB9OyBwcmludChgJHtFcnJvci5zdGFja31gKTsg cmV0dXJuIGhpIF4gbG87IH07CisgICAgY29uc3QgY2FsbGVlID0gbmV3IFdlYkFzc2VtYmx5Lklu c3RhbmNlKGNhbGxlZU1vZHVsZSgpLCB7IGltcDogeyBmdW5jOiBmdW5jIH0gfSk7CisgICAgY29u c3QgY2FsbGVyID0gbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGNhbGxlck1vZHVsZSgpLCBjYWxs ZWUpOworICAgIGZvciAobGV0IGkgPSAwOyBpIDwgNDA5NjsgKytpKSB7CisgICAgICAgIGFzc2Vy dC5lcShjYWxsZXIuZXhwb3J0cy5lbnRyeShpKSwgaW5uZXJSZXR1cm5IaSBeIGlubmVyUmV0dXJu TG8pOworICAgICAgICBhc3NlcnQuZXEodmFsdWUuaGksIGNhbGxlclRvcEJpdHMpOworICAgICAg ICBhc3NlcnQuZXEodmFsdWUubG8sIGkpOworICAgIH0KK30pKCk7CisKKworLy8gRklYTUU6IHRl c3Qgd2FzbS0+d2FzbSB1c2luZyAzMi1iaXQgdGhpbmdzIChpbmNsdWRpbmcgZmxvYXQpLCBhcyB3 ZWxsIGFzIDY0LWJpdCBOYU5zIHRoYXQgZG9uJ3QgZ2V0IGNhbm9uaWNhbGl6ZWQKKy8vIEZJWE1F OiBkbyBhIHRocm93IHR3by1kZWVwCisvLyBGSVhNRTogY2hlY2sgdGhhdCB0aGUgZmlyc3Qgd2Fz bSdzIGluc3RhbmNlIGlzIGJhY2sgaW4gT0sgc3RhdGUgKHdpdGggdGFibGUgb3IgZ2xvYmFsPykK Ky8vIEZJWE1FOiB0ZXN0IGNhbGxpbmcgdGhyb3VnaCBhIFRhYmxlCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvQ01ha2VMaXN0cy50eHQgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv Q01ha2VMaXN0cy50eHQKaW5kZXggOTY5YTEyMy4uOWRlMWEzYSAxMDA2NDQKLS0tIGEvU291cmNl L0phdmFTY3JpcHRDb3JlL0NNYWtlTGlzdHMudHh0CisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9DTWFrZUxpc3RzLnR4dApAQCAtOTA1LDYgKzkwNSw3IEBAIHNldChKYXZhU2NyaXB0Q29yZV9T T1VSQ0VTCiAgICAgd2FzbS9XYXNtTWVtb3J5LmNwcAogICAgIHdhc20vV2FzbU1lbW9yeUluZm9y bWF0aW9uLmNwcAogICAgIHdhc20vV2FzbU1vZHVsZVBhcnNlci5jcHAKKyAgICB3YXNtL1dhc21Q YWdlQ291bnQuY3BwCiAgICAgd2FzbS9XYXNtUGxhbi5jcHAKICAgICB3YXNtL1dhc21TaWduYXR1 cmUuY3BwCiAgICAgd2FzbS9XYXNtVmFsaWRhdGUuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhw cm9qCmluZGV4IGQ5MzI1NmIuLjExNjM2OWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9KYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q CkBAIC0xMjM1LDYgKzEyMzUsNyBAQAogCQkyQURGQTI2MzE4RUYzNTQwMDA0RjlGQ0MgLyogR0NM b2dnaW5nLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IDJBREZBMjYyMThFRjM1NDAwMDRGOUZDQyAvKiBHQ0xvZ2dpbmcuY3BwICovOyB9OwogCQkyQUY3 MzgyQzE4QkJCRjkyMDA4QTVBMzcgLyogU3RydWN0dXJlSURUYWJsZS5jcHAgaW4gU291cmNlcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAyQUY3MzgyQTE4QkJCRjkyMDA4QTVB MzcgLyogU3RydWN0dXJlSURUYWJsZS5jcHAgKi87IH07CiAJCTJBRjczODJEMThCQkJGOTIwMDhB NUEzNyAvKiBTdHJ1Y3R1cmVJRFRhYmxlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSAyQUY3MzgyQjE4QkJCRjkyMDA4QTVBMzcgLyogU3RydWN0dXJlSURU YWJsZS5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CisJ CTJEMzQyRjM2RjcyNDQwOTY4MDRBREIyNCAvKiBTb3VyY2VPcmlnaW4uaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQyNUJBMTMzN0U0MzQ0RTFCMjY5QTY3 MSAvKiBTb3VyY2VPcmlnaW4uaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRl LCApOyB9OyB9OwogCQkzNzFEODQyRDE3Qzk4QjZFMDBFQ0Y5OTQgLyogbGliei5keWxpYiBpbiBG cmFtZXdvcmtzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDM3MUQ4NDJDMTdD OThCNkUwMEVDRjk5NCAvKiBsaWJ6LmR5bGliICovOyB9OwogCQk0MTI5NTI3NzFEMkNGNkJDMDBF NzhCODkgLyogYnVpbHRpbnNfZ2VuZXJhdGVfaW50ZXJuYWxzX3dyYXBwZXJfaGVhZGVyLnB5IGlu IEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDEyOTUyNzMxRDJD RjZBQzAwRTc4Qjg5IC8qIGJ1aWx0aW5zX2dlbmVyYXRlX2ludGVybmFsc193cmFwcGVyX2hlYWRl ci5weSAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQk0 MTI5NTI3ODFEMkNGNkJDMDBFNzhCODkgLyogYnVpbHRpbnNfZ2VuZXJhdGVfaW50ZXJuYWxzX3dy YXBwZXJfaW1wbGVtZW50YXRpb24ucHkgaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA0MTI5NTI3NDFEMkNGNkFDMDBFNzhCODkgLyogYnVpbHRpbnNfZ2VuZXJh dGVfaW50ZXJuYWxzX3dyYXBwZXJfaW1wbGVtZW50YXRpb24ucHkgKi87IHNldHRpbmdzID0ge0FU VFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKQEAgLTIwMjUsNiArMjAyNiw3IEBACiAJCUFE NzQzOEMwMUUwNDU3QTQwMEZEMEMyQSAvKiBXYXNtU2lnbmF0dXJlLmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBRDc0MzhCRjFFMDQ1NzkyMDBGRDBDMkEg LyogV2FzbVNpZ25hdHVyZS5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUs ICk7IH07IH07CiAJCUFENzQzOEMxMUUwNDU3QUEwMEZEMEMyQSAvKiBXYXNtU2lnbmF0dXJlLmNw cCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEFENzQzOEJF MUUwNDU3OTIwMEZEMEMyQSAvKiBXYXNtU2lnbmF0dXJlLmNwcCAqLzsgfTsKIAkJQUQ4NkE5M0Ux QUE0RDg4RDAwMkZFNzdGIC8qIFdlYWtHQ01hcElubGluZXMuaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEFEODZBOTNEMUFBNEQ4N0MwMDJGRTc3RiAvKiBX ZWFrR0NNYXBJbmxpbmVzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwg KTsgfTsgfTsKKwkJQURCNkY2N0QxRTE1RDc2MDAwODJGMzg0IC8qIFdhc21QYWdlQ291bnQuY3Bw IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQURCNkY2N0Mx RTE1RDc1MDAwODJGMzg0IC8qIFdhc21QYWdlQ291bnQuY3BwICovOyB9OwogCQlBREJDNTRENDFE RjhFQTJCMDA1QkY3MzggLyogV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmNwcCBpbiBTb3VyY2VzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEFEQkM1NEQyMURGOEVBMDAwMDVCRjcz OCAvKiBXZWJBc3NlbWJseVRvSlNDYWxsZWUuY3BwICovOyB9OwogCQlBREJDNTRENTFERjhFQTJC MDA1QkY3MzggLyogV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmggaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBREJDNTREMzFERjhFQTAwMDA1QkY3MzggLyogV2Vi QXNzZW1ibHlUb0pTQ2FsbGVlLmggKi87IH07CiAJCUFEREIxRjYzMThENzdEQkUwMDlCNThBOCAv KiBPcGFxdWVSb290U2V0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSBBRERCMUY2MjE4RDc3REI3MDA5QjU4QTggLyogT3BhcXVlUm9vdFNldC5oICovOyBz ZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CkBAIC0yMzYxLDcgKzIz NjMsNiBAQAogCQlGRUQ5NEYyRjE3MUUzRTIzMDBCRTc3QTQgLyogV2F0Y2hkb2cuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZFRDk0RjJDMTcxRTNFMjMw MEJFNzdBNCAvKiBXYXRjaGRvZy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZh dGUsICk7IH07IH07CiAJCUZFRjA0MDUxMUFBRTY2MkQwMEJEMjhCMCAvKiBDb21wYXJlQW5kU3dh cFRlc3QuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g RkVGMDQwNTAxQUFFNjYyRDAwQkQyOEIwIC8qIENvbXBhcmVBbmRTd2FwVGVzdC5jcHAgKi87IH07 CiAJCUZFRkQ2RkM2MUQ1RTc5OTIwMDhGMkYwQiAvKiBKU1N0cmluZ0lubGluZXMuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZFRkQ2RkM1MUQ1RTc5NzAw MDhGMkYwQiAvKiBKU1N0cmluZ0lubGluZXMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9 IChQcml2YXRlLCApOyB9OyB9OwotCQkyRDM0MkYzNkY3MjQ0MDk2ODA0QURCMjQgLyogU291cmNl T3JpZ2luLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0 MjVCQTEzMzdFNDM0NEUxQjI2OUE2NzEgLyogU291cmNlT3JpZ2luLmggKi87IHNldHRpbmdzID0g e0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIC8qIEVuZCBQQlhCdWlsZEZpbGUgc2Vj dGlvbiAqLwogCiAvKiBCZWdpbiBQQlhDb250YWluZXJJdGVtUHJveHkgc2VjdGlvbiAqLwpAQCAt MzYzOCw2ICszNjM5LDcgQEAKIAkJNDEyOTUyNzUxRDJDRjZBQzAwRTc4Qjg5IC8qIGJ1aWx0aW5z X2dlbmVyYXRlX3dyYXBwZXJfaGVhZGVyLnB5ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dC5zY3JpcHQucHl0aG9u OyBwYXRoID0gYnVpbHRpbnNfZ2VuZXJhdGVfd3JhcHBlcl9oZWFkZXIucHk7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCTQxMjk1Mjc2MUQyQ0Y2QUMwMEU3OEI4OSAvKiBidWlsdGluc19n ZW5lcmF0ZV93cmFwcGVyX2ltcGxlbWVudGF0aW9uLnB5ICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dC5zY3JpcHQu cHl0aG9uOyBwYXRoID0gYnVpbHRpbnNfZ2VuZXJhdGVfd3JhcHBlcl9pbXBsZW1lbnRhdGlvbi5w eTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDFERUExMzExQjlGMzE1NDAwNkQ2NURE IC8qIEJ1aWx0aW5VdGlscy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBCdWls dGluVXRpbHMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNDI1QkExMzM3RTQzNDRF MUIyNjlBNjcxIC8qIFNvdXJjZU9yaWdpbi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBTb3VyY2VPcmlnaW4uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDMxOURB MDExQzFCRTNDMTAwMUQyNjBCIC8qIEIzTG93ZXJNYWNyb3NBZnRlck9wdGltaXphdGlvbnMuY3Bw ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gQjNMb3dlck1hY3Jvc0FmdGVy T3B0aW1pemF0aW9ucy5jcHA7IHBhdGggPSBiMy9CM0xvd2VyTWFjcm9zQWZ0ZXJPcHRpbWl6YXRp b25zLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDMxOURBMDIxQzFCRTNDMTAw MUQyNjBCIC8qIEIzTG93ZXJNYWNyb3NBZnRlck9wdGltaXphdGlvbnMuaCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBuYW1lID0gQjNMb3dlck1hY3Jvc0FmdGVyT3B0aW1pemF0aW9ucy5oOyBw YXRoID0gYjMvQjNMb3dlck1hY3Jvc0FmdGVyT3B0aW1pemF0aW9ucy5oOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQk0MzQwQTQ4MjFBOTA1MUFGMDBENzNDQ0EgLyogTWF0aENvbW1vbi5j cHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBNYXRoQ29tbW9uLmNwcDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTQ1MTAsNiArNDUxMiw3IEBACiAJCUFENzQz OEJFMUUwNDU3OTIwMEZEMEMyQSAvKiBXYXNtU2lnbmF0dXJlLmNwcCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFdhc21TaWduYXR1cmUuY3BwOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQlBRDc0MzhCRjFFMDQ1NzkyMDBGRDBDMkEgLyogV2FzbVNpZ25hdHVyZS5o ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXYXNtU2lnbmF0dXJlLmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUFEODZBOTNEMUFBNEQ4N0MwMDJGRTc3RiAvKiBXZWFr R0NNYXBJbmxpbmVzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFdlYWtHQ01h cElubGluZXMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJQURCNkY2N0MxRTE1RDc1 MDAwODJGMzg0IC8qIFdhc21QYWdlQ291bnQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAu Y3BwOyBwYXRoID0gV2FzbVBhZ2VDb3VudC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCUFEQkM1NEQyMURGOEVBMDAwMDVCRjczOCAvKiBXZWJBc3NlbWJseVRvSlNDYWxsZWUuY3Bw ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gV2ViQXNzZW1ibHlUb0pTQ2Fs bGVlLmNwcDsgcGF0aCA9IGpzL1dlYkFzc2VtYmx5VG9KU0NhbGxlZS5jcHA7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCUFEQkM1NEQzMURGOEVBMDAwMDVCRjczOCAvKiBXZWJBc3NlbWJs eVRvSlNDYWxsZWUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gV2ViQXNzZW1i bHlUb0pTQ2FsbGVlLmg7IHBhdGggPSBqcy9XZWJBc3NlbWJseVRvSlNDYWxsZWUuaDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQUREQjFGNjIxOEQ3N0RCNzAwOUI1OEE4IC8qIE9wYXF1 ZVJvb3RTZXQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gT3BhcXVlUm9vdFNl dC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtNDg3OSw3ICs0ODgyLDYgQEAKIAkJ RkVGMDQwNTAxQUFFNjYyRDAwQkQyOEIwIC8qIENvbXBhcmVBbmRTd2FwVGVzdC5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUgPSBDb21wYXJlQW5kU3dhcFRlc3QuY3BwOyBw YXRoID0gQVBJL3Rlc3RzL0NvbXBhcmVBbmRTd2FwVGVzdC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCUZFRjA0MDUyMUFBRUM0RUQwMEJEMjhCMCAvKiBDb21wYXJlQW5kU3dhcFRl c3QuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gQ29tcGFyZUFuZFN3YXBUZXN0 Lmg7IHBhdGggPSBBUEkvdGVzdHMvQ29tcGFyZUFuZFN3YXBUZXN0Lmg7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCUZFRkQ2RkM1MUQ1RTc5NzAwMDhGMkYwQiAvKiBKU1N0cmluZ0lubGlu ZXMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSlNTdHJpbmdJbmxpbmVzLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07Ci0JCTQyNUJBMTMzN0U0MzQ0RTFCMjY5QTY3MSAv KiBTb3VyY2VPcmlnaW4uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gU291cmNl T3JpZ2luLmg7IHBhdGggPSBTb3VyY2VPcmlnaW4uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIC8qIEVuZCBQQlhGaWxlUmVmZXJlbmNlIHNlY3Rpb24gKi8KIAogLyogQmVnaW4gUEJYRnJh bWV3b3Jrc0J1aWxkUGhhc2Ugc2VjdGlvbiAqLwpAQCAtNjA0Nyw2ICs2MDQ5LDcgQEAKIAkJCQk3 OUI3NTk3MjFERkE0QzYwMDA1MjE3NEMgLyogV2FzbU1lbW9yeUluZm9ybWF0aW9uLmggKi8sCiAJ CQkJNTNGNDBFOTYxRDVBN0JFQzAwOTlBMUI2IC8qIFdhc21Nb2R1bGVQYXJzZXIuY3BwICovLAog CQkJCTUzRjQwRTk0MUQ1QTdBRUYwMDk5QTFCNiAvKiBXYXNtTW9kdWxlUGFyc2VyLmggKi8sCisJ CQkJQURCNkY2N0MxRTE1RDc1MDAwODJGMzg0IC8qIFdhc21QYWdlQ291bnQuY3BwICovLAogCQkJ CTc5Qjc1OTczMURGQTRDNjAwMDUyMTc0QyAvKiBXYXNtUGFnZUNvdW50LmggKi8sCiAJCQkJNTNG NDBFOEMxRDU5MDFGMjAwOTlBMUI2IC8qIFdhc21QYXJzZXIuaCAqLywKIAkJCQk1MzEzNzRCRTFE NUNFOTUwMDBBRjdBMEIgLyogV2FzbVBsYW4uY3BwICovLApAQCAtOTcwMyw2ICs5NzA2LDcgQEAK IAkJCQkwRjY0QjI3MTFBNzg0QkFGMDA2RTRFNjYgLyogQmluYXJ5U3dpdGNoLmNwcCBpbiBTb3Vy Y2VzICovLAogCQkJCTE0MjgwODYzMTA3RUMxMUEwMDEzRTdCMiAvKiBCb29sZWFuQ29uc3RydWN0 b3IuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJMTQyODA4NjQxMDdFQzExQTAwMTNFN0IyIC8qIEJv b2xlYW5PYmplY3QuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJQURCNkY2N0QxRTE1RDc2MDAwODJG Mzg0IC8qIFdhc21QYWdlQ291bnQuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJMTQyODA4NjUxMDdF QzExQTAwMTNFN0IyIC8qIEJvb2xlYW5Qcm90b3R5cGUuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJ REUyNkU5MDcxQ0I1REVGQjAwRDJCRTgyIC8qIEJ1aWx0aW5FeGVjdXRhYmxlQ3JlYXRvci5jcHAg aW4gU291cmNlcyAqLywKIAkJCQlBN0Q4MDFBNDE4ODBENjZFMDAyNkMzOUIgLyogQnVpbHRpbkV4 ZWN1dGFibGVzLmNwcCBpbiBTb3VyY2VzICovLApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL2pzYy5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvanNjLmNwcAppbmRleCAzZWFm NGEwLi5mNDM0Y2FjIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvanNjLmNwcAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvanNjLmNwcApAQCAtNTQsNiArNTQsOCBAQAogI2lu Y2x1ZGUgIkpTU3RyaW5nLmgiCiAjaW5jbHVkZSAiSlNUeXBlZEFycmF5cy5oIgogI2luY2x1ZGUg IkpTV2ViQXNzZW1ibHlDYWxsZWUuaCIKKyNpbmNsdWRlICJKU1dlYkFzc2VtYmx5SW5zdGFuY2Uu aCIKKyNpbmNsdWRlICJKU1dlYkFzc2VtYmx5TW9kdWxlLmgiCiAjaW5jbHVkZSAiTExJbnREYXRh LmgiCiAjaW5jbHVkZSAiTExJbnRUaHVua3MuaCIKICNpbmNsdWRlICJPYmplY3RDb25zdHJ1Y3Rv ci5oIgpAQCAtNzAsNiArNzIsNyBAQAogI2luY2x1ZGUgIlR5cGVQcm9maWxlckxvZy5oIgogI2lu Y2x1ZGUgIldhc21QbGFuLmgiCiAjaW5jbHVkZSAiV2FzbU1lbW9yeS5oIgorI2luY2x1ZGUgIldl YkFzc2VtYmx5TW9kdWxlUmVjb3JkLmgiCiAjaW5jbHVkZSA8bG9jYWxlLmg+CiAjaW5jbHVkZSA8 bWF0aC5oPgogI2luY2x1ZGUgPHN0ZGlvLmg+CkBAIC0yNjE1LDYgKzI2MTgsNyBAQCBzdGF0aWMg RW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBmdW5jdGlvblRlc3RXYXNtTW9kdWxlRnVuY3Rp b25zKEV4ZWNTdGF0ZSogZQogewogICAgIFZNJiB2bSA9IGV4ZWMtPnZtKCk7CiAgICAgYXV0byBz Y29wZSA9IERFQ0xBUkVfVEhST1dfU0NPUEUodm0pOworICAgIGF1dG8qIGdsb2JhbE9iamVjdCA9 IGV4ZWMtPmxleGljYWxHbG9iYWxPYmplY3QoKTsKIAogICAgIGlmICghT3B0aW9uczo6dXNlV2Vi QXNzZW1ibHkoKSkKICAgICAgICAgcmV0dXJuIHRocm93Vk1UeXBlRXJyb3IoZXhlYywgc2NvcGUs IEFTQ0lJTGl0ZXJhbCgidGVzdFdhc21Nb2R1bGUgc2hvdWxkIG9ubHkgYmUgY2FsbGVkIGlmIHRo ZSB1c2VXZWJBc3NlbWJseSBvcHRpb24gaXMgc2V0IikpOwpAQCAtMjY0OCw4ICsyNjUyLDI1IEBA IHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGZ1bmN0aW9uVGVzdFdhc21Nb2R1 bGVGdW5jdGlvbnMoRXhlY1N0YXRlKiBlCiAgICAgICAgICAgICB9KTsKICAgICB9CiAKLSAgICBz dGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+IG1vZHVsZUluZm9ybWF0aW9u ID0gcGxhbi50YWtlTW9kdWxlSW5mb3JtYXRpb24oKTsKLSAgICBSRUxFQVNFX0FTU0VSVCghbW9k dWxlSW5mb3JtYXRpb24tPm1lbW9yeSk7CisgICAgU3ltYm9sVGFibGUqIGV4cG9ydFN5bWJvbFRh YmxlID0gU3ltYm9sVGFibGU6OmNyZWF0ZSh2bSk7CisgICAgYXV0byogbW9kdWxlU3RydWN0dXJl ID0gSW50ZXJuYWxGdW5jdGlvbjo6Y3JlYXRlU3ViY2xhc3NTdHJ1Y3R1cmUoZXhlYywgSlNWYWx1 ZSgpLCBleGVjLT5sZXhpY2FsR2xvYmFsT2JqZWN0KCktPldlYkFzc2VtYmx5TW9kdWxlU3RydWN0 dXJlKCkpOworICAgIFJFVFVSTl9JRl9FWENFUFRJT04oc2NvcGUsIGVuY29kZWRKU1ZhbHVlKCkp OworICAgIEpTV2ViQXNzZW1ibHlNb2R1bGUqIG1vZHVsZSA9IEpTV2ViQXNzZW1ibHlNb2R1bGU6 OmNyZWF0ZSh2bSwgbW9kdWxlU3RydWN0dXJlLCBwbGFuLnRha2VNb2R1bGVJbmZvcm1hdGlvbigp LCBwbGFuLnRha2VDYWxsTGlua0luZm9zKCksIHBsYW4udGFrZVdhc21FeGl0U3R1YnMoKSwgZXhw b3J0U3ltYm9sVGFibGUsIDApOworICAgIFN0cnVjdHVyZSogaW5zdGFuY2VTdHJ1Y3R1cmUgPSBJ bnRlcm5hbEZ1bmN0aW9uOjpjcmVhdGVTdWJjbGFzc1N0cnVjdHVyZShleGVjLCBKU1ZhbHVlKCks IGdsb2JhbE9iamVjdC0+V2ViQXNzZW1ibHlJbnN0YW5jZVN0cnVjdHVyZSgpKTsKKyAgICBSRVRV Uk5fSUZfRVhDRVBUSU9OKHNjb3BlLCBlbmNvZGVkSlNWYWx1ZSgpKTsKKyAgICBJZGVudGlmaWVy IG1vZHVsZUtleSA9IElkZW50aWZpZXI6OmZyb21VaWQoUHJpdmF0ZU5hbWUoUHJpdmF0ZU5hbWU6 OkRlc2NyaXB0aW9uLCAiV2ViQXNzZW1ibHlJbnN0YW5jZSIpKTsKKyAgICBXZWJBc3NlbWJseU1v ZHVsZVJlY29yZCogbW9kdWxlUmVjb3JkID0gV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmNyZWF0 ZShleGVjLCB2bSwgZ2xvYmFsT2JqZWN0LT53ZWJBc3NlbWJseU1vZHVsZVJlY29yZFN0cnVjdHVy ZSgpLCBtb2R1bGVLZXksIG1vZHVsZS0+bW9kdWxlSW5mb3JtYXRpb24oKSk7CisgICAgUkVUVVJO X0lGX0VYQ0VQVElPTihzY29wZSwgZW5jb2RlZEpTVmFsdWUoKSk7CisgICAgSlNXZWJBc3NlbWJs eUluc3RhbmNlKiBpbnN0YW5jZSA9IEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6Y3JlYXRlKHZtLCBp bnN0YW5jZVN0cnVjdHVyZSwgbW9kdWxlLCBtb2R1bGVSZWNvcmQtPmdldE1vZHVsZU5hbWVzcGFj ZShleGVjKSk7CisgICAgUkVUVVJOX0lGX0VYQ0VQVElPTihzY29wZSwgZW5jb2RlZEpTVmFsdWUo KSk7CisgICAgdm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlID0gaW5zdGFuY2U7CisKKyAgICBp ZiAoISFtb2R1bGUtPm1vZHVsZUluZm9ybWF0aW9uKCkubWVtb3J5KSB7CisgICAgICAgIGJvb2wg ZmFpbGVkOworICAgICAgICBXYXNtOjpNZW1vcnkgbWVtb3J5KG1vZHVsZS0+bW9kdWxlSW5mb3Jt YXRpb24oKS5tZW1vcnkuaW5pdGlhbCgpLCBtb2R1bGUtPm1vZHVsZUluZm9ybWF0aW9uKCkubWVt b3J5Lm1heGltdW0oKSwgZmFpbGVkKTsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQoZmFpbGVkKTsK KyAgICAgICAgaW5zdGFuY2UtPnNldE1lbW9yeSh2bSwgSlNXZWJBc3NlbWJseU1lbW9yeTo6Y3Jl YXRlKHZtLCBnbG9iYWxPYmplY3QtPldlYkFzc2VtYmx5TWVtb3J5U3RydWN0dXJlKCksIFdURk1v dmUobWVtb3J5KSkpOworICAgIH0KIAogICAgIGZvciAodWludDMyX3QgaSA9IDA7IGkgPCBmdW5j dGlvbkNvdW50OyArK2kpIHsKICAgICAgICAgSlNBcnJheSogdGVzdENhc2VzID0ganNDYXN0PEpT QXJyYXkqPihleGVjLT5hcmd1bWVudChpICsgMikpOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvQWJzdHJhY3RNb2R1bGVSZWNvcmQuaCBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL0Fic3RyYWN0TW9kdWxlUmVjb3JkLmgKaW5kZXggMDRhZjEyNi4uMzlm YzJkMSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvQWJzdHJhY3RN b2R1bGVSZWNvcmQuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9BYnN0cmFj dE1vZHVsZVJlY29yZC5oCkBAIC0xMTMsNyArMTEzLDcgQEAgcHVibGljOgogCiAgICAgQWJzdHJh Y3RNb2R1bGVSZWNvcmQqIGhvc3RSZXNvbHZlSW1wb3J0ZWRNb2R1bGUoRXhlY1N0YXRlKiwgY29u c3QgSWRlbnRpZmllciYgbW9kdWxlTmFtZSk7CiAKLSAgICBKU01vZHVsZU5hbWVzcGFjZU9iamVj dCogZ2V0TW9kdWxlTmFtZXNwYWNlKEV4ZWNTdGF0ZSopOworICAgIEpTX0VYUE9SVF9QUklWQVRF IEpTTW9kdWxlTmFtZXNwYWNlT2JqZWN0KiBnZXRNb2R1bGVOYW1lc3BhY2UoRXhlY1N0YXRlKik7 CiAgICAgCiAgICAgSlNNb2R1bGVFbnZpcm9ubWVudCogbW9kdWxlRW52aXJvbm1lbnQoKQogICAg IHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTVHlwZS5oIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmgKaW5kZXggMDUyMDJmMy4uYWM1 MDlkNyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmgK KysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmgKQEAgLTkzLDYgKzkz LDggQEAgZW51bSBKU1R5cGUgOiB1aW50OF90IHsKICAgICBKU01hcFR5cGUsCiAgICAgSlNTZXRU eXBlLAogCisgICAgV2ViQXNzZW1ibHlGdW5jdGlvblR5cGUsCisKICAgICBMYXN0SlNDT2JqZWN0 VHlwZSA9IEpTU2V0VHlwZSwKICAgICBNYXhKU1R5cGUgPSAwYjExMTExMTExLAogfTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcCBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcAppbmRleCAx MTdkNzY0Li5lNzkyMDEzIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9X YXNtQjNJUkdlbmVyYXRvci5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bUIzSVJHZW5lcmF0b3IuY3BwCkBAIC0xNTUsNyArMTU1LDcgQEAgcHVibGljOgogICAgICAgICAg ICAgcmV0dXJuIGZhaWwoX19WQV9BUkdTX18pOyAgICAgICAgICAgICBcCiAgICAgfSB3aGlsZSAo MCkKIAotICAgIEIzSVJHZW5lcmF0b3IoVk0mLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYsIFBy b2NlZHVyZSYsIFdhc21JbnRlcm5hbEZ1bmN0aW9uKiwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2Fz bUNhbGw+JiwgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJik7CisgICAgQjNJUkdl bmVyYXRvcihWTSYsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiwgUHJvY2VkdXJlJiwgV2FzbUlu dGVybmFsRnVuY3Rpb24qLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mKTsKIAogICAg IFBhcnRpYWxSZXN1bHQgV0FSTl9VTlVTRURfUkVUVVJOIGFkZEFyZ3VtZW50cyhjb25zdCBTaWdu YXR1cmUqKTsKICAgICBQYXJ0aWFsUmVzdWx0IFdBUk5fVU5VU0VEX1JFVFVSTiBhZGRMb2NhbChU eXBlLCB1aW50MzJfdCk7CkBAIC0yMDUsOCArMjA1LDYgQEAgcHVibGljOgogCiAgICAgdm9pZCBl bWl0RXhjZXB0aW9uQ2hlY2soQ0NhbGxIZWxwZXJzJiwgRXhjZXB0aW9uVHlwZSk7CiAKLSAgICB2 b2lkIGVtaXRSZWxvYWRQaW5uZWRSZWdpc3RlcnMoKTsKLQogcHJpdmF0ZToKICAgICBFeHByZXNz aW9uVHlwZSBlbWl0Q2hlY2tBbmRQcmVwYXJlUG9pbnRlcihFeHByZXNzaW9uVHlwZSBwb2ludGVy LCB1aW50MzJfdCBvZmZzZXQsIHVpbnQzMl90IHNpemVPZk9wKTsKICAgICBFeHByZXNzaW9uVHlw ZSBlbWl0TG9hZE9wKExvYWRPcFR5cGUsIE9yaWdpbiwgRXhwcmVzc2lvblR5cGUgcG9pbnRlciwg dWludDMyX3Qgb2Zmc2V0KTsKQEAgLTIxOSw3ICsyMTcsNiBAQCBwcml2YXRlOgogICAgIHZvaWQg ZW1pdENoZWNrc0Zvck1vZE9yRGl2KEIzOjpPcGNvZGUsIEV4cHJlc3Npb25UeXBlIGxlZnQsIEV4 cHJlc3Npb25UeXBlIHJpZ2h0KTsKIAogICAgIFZNJiBtX3ZtOwotICAgIGNvbnN0IEltbXV0YWJs ZUZ1bmN0aW9uSW5kZXhTcGFjZSYgbV9mdW5jdGlvbkluZGV4U3BhY2U7CiAgICAgY29uc3QgTW9k dWxlSW5mb3JtYXRpb24mIG1faW5mbzsKICAgICBQcm9jZWR1cmUmIG1fcHJvYzsKICAgICBCYXNp Y0Jsb2NrKiBtX2N1cnJlbnRCbG9jazsKQEAgLTIzMSw5ICsyMjgsOCBAQCBwcml2YXRlOgogICAg IFZhbHVlKiBtX2luc3RhbmNlVmFsdWU7CiB9OwogCi1CM0lSR2VuZXJhdG9yOjpCM0lSR2VuZXJh dG9yKFZNJiB2bSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFByb2NlZHVyZSYgcHJv Y2VkdXJlLCBXYXNtSW50ZXJuYWxGdW5jdGlvbiogY29tcGlsYXRpb24sIFZlY3RvcjxVbmxpbmtl ZFdhc21Ub1dhc21DYWxsPiYgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGNvbnN0IEltbXV0YWJs ZUZ1bmN0aW9uSW5kZXhTcGFjZSYgZnVuY3Rpb25JbmRleFNwYWNlKQorQjNJUkdlbmVyYXRvcjo6 QjNJUkdlbmVyYXRvcihWTSYgdm0sIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBpbmZvLCBQcm9j ZWR1cmUmIHByb2NlZHVyZSwgV2FzbUludGVybmFsRnVuY3Rpb24qIGNvbXBpbGF0aW9uLCBWZWN0 b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzKQogICAg IDogbV92bSh2bSkKLSAgICAsIG1fZnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXhTcGFj ZSkKICAgICAsIG1faW5mbyhpbmZvKQogICAgICwgbV9wcm9jKHByb2NlZHVyZSkKICAgICAsIG1f dW5saW5rZWRXYXNtVG9XYXNtQ2FsbHModW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMpCkBAIC0yNzUs NiArMjcxLDYwIEBAIEIzSVJHZW5lcmF0b3I6OkIzSVJHZW5lcmF0b3IoVk0mIHZtLCBjb25zdCBN b2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgUHJvY2VkdXJlJiBwCiAgICAgICAgIG1fY3VycmVudEJs b2NrLT5hcHBlbmROZXc8Q29uc3RQdHJWYWx1ZT4obV9wcm9jLCBPcmlnaW4oKSwgJm1fdm0udG9w SlNXZWJBc3NlbWJseUluc3RhbmNlKSk7CiB9CiAKK3N0cnVjdCBNZW1vcnlCYXNlQW5kU2l6ZSB7 CisgICAgVmFsdWUqIGJhc2U7CisgICAgVmFsdWUqIHNpemU7Cit9OworCitzdGF0aWMgTWVtb3J5 QmFzZUFuZFNpemUgZ2V0TWVtb3J5QmFzZUFuZFNpemUoVk0mIHZtLCBWYWx1ZSogaW5zdGFuY2Us IFByb2NlZHVyZSYgcHJvYywgQmFzaWNCbG9jayogYmxvY2spCit7CisgICAgVmFsdWUqIG1lbW9y eU9iamVjdCA9IGJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KHByb2MsIExvYWQsIHBvaW50 ZXJUeXBlKCksIE9yaWdpbigpLCBpbnN0YW5jZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlOjpvZmZz ZXRPZk1lbW9yeSgpKTsKKworICAgIHN0YXRpY19hc3NlcnQoc2l6ZW9mKGRlY2x0eXBlKHZtLnRv cEpTV2ViQXNzZW1ibHlJbnN0YW5jZS0+bWVtb3J5KCktPm1lbW9yeSgpLT5tZW1vcnkoKSkpID09 IHNpemVvZih2b2lkKiksICJjb2RlZ2VuIHJlbGllcyBvbiB0aGlzIHNpemUiKTsKKyAgICBzdGF0 aWNfYXNzZXJ0KHNpemVvZihkZWNsdHlwZSh2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UtPm1l bW9yeSgpLT5tZW1vcnkoKS0+c2l6ZSgpKSkgPT0gc2l6ZW9mKHVpbnQ2NF90KSwgImNvZGVnZW4g cmVsaWVzIG9uIHRoaXMgc2l6ZSIpOworICAgIE1lbW9yeUJhc2VBbmRTaXplIHJlc3VsdDsKKyAg ICByZXN1bHQuYmFzZSA9IGJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KHByb2MsIExvYWQs IHBvaW50ZXJUeXBlKCksIE9yaWdpbigpLCBtZW1vcnlPYmplY3QsIEpTV2ViQXNzZW1ibHlNZW1v cnk6Om9mZnNldE9mTWVtb3J5KCkpOworICAgIHJlc3VsdC5zaXplID0gYmxvY2stPmFwcGVuZE5l dzxNZW1vcnlWYWx1ZT4ocHJvYywgTG9hZCwgSW50NjQsIE9yaWdpbigpLCBtZW1vcnlPYmplY3Qs IEpTV2ViQXNzZW1ibHlNZW1vcnk6Om9mZnNldE9mU2l6ZSgpKTsKKworICAgIHJldHVybiByZXN1 bHQ7Cit9CisKK3N0YXRpYyB2b2lkIHJlc3RvcmVXZWJBc3NlbWJseUdsb2JhbFN0YXRlKFZNJiB2 bSwgY29uc3QgTWVtb3J5SW5mb3JtYXRpb24mIG1lbW9yeSwgVmFsdWUqIGluc3RhbmNlLCBQcm9j ZWR1cmUmIHByb2MsIEJhc2ljQmxvY2sqIGJsb2NrKQoreworICAgIGJsb2NrLT5hcHBlbmROZXc8 TWVtb3J5VmFsdWU+KHByb2MsIFN0b3JlLCBPcmlnaW4oKSwgaW5zdGFuY2UsIGJsb2NrLT5hcHBl bmROZXc8Q29uc3RQdHJWYWx1ZT4ocHJvYywgT3JpZ2luKCksICZ2bS50b3BKU1dlYkFzc2VtYmx5 SW5zdGFuY2UpKTsKKworICAgIGlmICghIW1lbW9yeSkgeworICAgICAgICBhdXRvIG1lbW9yeVZh bHVlID0gZ2V0TWVtb3J5QmFzZUFuZFNpemUodm0sIGluc3RhbmNlLCBwcm9jLCBibG9jayk7CisK KyAgICAgICAgVmVjdG9yPFZhbHVlKj4gYXJndW1lbnRzOworICAgICAgICBhcmd1bWVudHMucmVz ZXJ2ZUNhcGFjaXR5KDEgKyBtZW1vcnkucGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVycy5z aXplKCkpOworICAgICAgICBhcmd1bWVudHMuYXBwZW5kKG1lbW9yeVZhbHVlLmJhc2UpOworICAg ICAgICBmb3IgKGF1dG8gaW5mbyA6IG1lbW9yeS5waW5uZWRSZWdpc3RlcnMoKS5zaXplUmVnaXN0 ZXJzKSB7CisgICAgICAgICAgICBWYWx1ZSogc2l6ZVZhbHVlID0gYmxvY2stPmFwcGVuZE5ldzxW YWx1ZT4ocHJvYywgU3ViLCBPcmlnaW4oKSwgbWVtb3J5VmFsdWUuc2l6ZSwgYmxvY2stPmFwcGVu ZE5ldzxDb25zdDY0VmFsdWU+KHByb2MsIE9yaWdpbigpLCBpbmZvLnNpemVPZmZzZXQpKTsKKyAg ICAgICAgICAgIGFyZ3VtZW50cy5hcHBlbmQoc2l6ZVZhbHVlKTsKKyAgICAgICAgfQorCisgICAg ICAgIFJlZ2lzdGVyU2V0IGNsb2JiZXJzOworICAgICAgICBjbG9iYmVycy5zZXQobWVtb3J5LnBp bm5lZFJlZ2lzdGVycygpLmJhc2VNZW1vcnlQb2ludGVyKTsKKyAgICAgICAgZm9yIChhdXRvIGlu Zm8gOiBtZW1vcnkucGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVycykKKyAgICAgICAgICAg IGNsb2JiZXJzLnNldChpbmZvLnNpemVSZWdpc3Rlcik7CisKKyAgICAgICAgQjM6OlBhdGNocG9p bnRWYWx1ZSogcGF0Y2hwb2ludCA9IGJsb2NrLT5hcHBlbmROZXc8QjM6OlBhdGNocG9pbnRWYWx1 ZT4ocHJvYywgQjM6OlZvaWQsIE9yaWdpbigpKTsKKyAgICAgICAgcGF0Y2hwb2ludC0+ZWZmZWN0 cyA9IEVmZmVjdHM6Om5vbmUoKTsKKyAgICAgICAgcGF0Y2hwb2ludC0+ZWZmZWN0cy53cml0ZXNQ aW5uZWQgPSB0cnVlOworICAgICAgICBwYXRjaHBvaW50LT5jbG9iYmVyKGNsb2JiZXJzKTsKKyAg ICAgICAgcGF0Y2hwb2ludC0+YXBwZW5kVmVjdG9yV2l0aFJlcChhcmd1bWVudHMsIFZhbHVlUmVw OjpTb21lUmVnaXN0ZXIpOworCisgICAgICAgIHBhdGNocG9pbnQtPnNldEdlbmVyYXRvcihbbWVt b3J5XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJh bXMmIHBhcmFtcykgeworICAgICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdl IGFsbG93U2NyYXRjaChqaXQpOworCisgICAgICAgICAgICBqaXQubW92ZShwYXJhbXNbMF0uZ3By KCksIG1lbW9yeS5waW5uZWRSZWdpc3RlcnMoKS5iYXNlTWVtb3J5UG9pbnRlcik7CisgICAgICAg ICAgICBmb3IgKHVpbnQzMl90IGkgPSAwOyBpIDwgbWVtb3J5LnBpbm5lZFJlZ2lzdGVycygpLnNp emVSZWdpc3RlcnMuc2l6ZSgpOyArK2kpCisgICAgICAgICAgICAgICAgaml0Lm1vdmUocGFyYW1z WzEgKyBpXS5ncHIoKSwgbWVtb3J5LnBpbm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnNbaV0u c2l6ZVJlZ2lzdGVyKTsKKyAgICAgICAgfSk7CisgICAgfQorfQorCiB2b2lkIEIzSVJHZW5lcmF0 b3I6OmVtaXRFeGNlcHRpb25DaGVjayhDQ2FsbEhlbHBlcnMmIGppdCwgRXhjZXB0aW9uVHlwZSB0 eXBlKQogewogICAgIGppdC5tb3ZlKENDYWxsSGVscGVyczo6VHJ1c3RlZEltbTMyKHN0YXRpY19j YXN0PHVpbnQzMl90Pih0eXBlKSksIEdQUkluZm86OmFyZ3VtZW50R1BSMSk7CkBAIC0zMzgsNDkg KzM4OCw2IEBAIGF1dG8gQjNJUkdlbmVyYXRvcjo6YWRkVW5yZWFjaGFibGUoKSAtPiBQYXJ0aWFs UmVzdWx0CiAgICAgcmV0dXJuIHsgfTsKIH0KIAotc3RhdGljIHZvaWQgcmVsb2FkUGlubmVkUmVn aXN0ZXJzKFByb2NlZHVyZSYgcHJvYywgQmFzaWNCbG9jayogYmxvY2ssIGNvbnN0IE1vZHVsZUlu Zm9ybWF0aW9uJiBpbmZvLCBWYWx1ZSogaW5zdGFuY2UpCi17Ci0gICAgaWYgKCFpbmZvLmhhc01l bW9yeSgpKQotICAgICAgICByZXR1cm47Ci0KLSAgICBjb25zdCBNZW1vcnlJbmZvcm1hdGlvbiog bWVtb3J5ID0gJmluZm8ubWVtb3J5OwotCi0gICAgUmVnaXN0ZXJTZXQgY2xvYmJlcnM7Ci0gICAg Y2xvYmJlcnMuc2V0KG1lbW9yeS0+cGlubmVkUmVnaXN0ZXJzKCkuYmFzZU1lbW9yeVBvaW50ZXIp OwotICAgIGZvciAoYXV0byBpbmZvIDogbWVtb3J5LT5waW5uZWRSZWdpc3RlcnMoKS5zaXplUmVn aXN0ZXJzKQotICAgICAgICBjbG9iYmVycy5zZXQoaW5mby5zaXplUmVnaXN0ZXIpOwotCi0gICAg QjM6OlBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCA9IGJsb2NrLT5hcHBlbmROZXc8QjM6OlBh dGNocG9pbnRWYWx1ZT4ocHJvYywgQjM6OlZvaWQsIE9yaWdpbigpKTsKLSAgICBwYXRjaHBvaW50 LT5lZmZlY3RzID0gRWZmZWN0czo6bm9uZSgpOwotICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3Jp dGVzUGlubmVkID0gdHJ1ZTsKLSAgICBwYXRjaHBvaW50LT5jbG9iYmVyKGNsb2JiZXJzKTsKLSAg ICBwYXRjaHBvaW50LT5udW1HUFNjcmF0Y2hSZWdpc3RlcnMgPSAxOwotCi0gICAgcGF0Y2hwb2lu dC0+YXBwZW5kKGluc3RhbmNlLCBWYWx1ZVJlcDo6U29tZVJlZ2lzdGVyKTsKLQotICAgIHBhdGNo cG9pbnQtPnNldEdlbmVyYXRvcihbbWVtb3J5XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIz OjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmIHBhcmFtcykgewotICAgICAgICBBbGxvd01hY3Jv U2NyYXRjaFJlZ2lzdGVyVXNhZ2UgYWxsb3dTY3JhdGNoKGppdCk7Ci0KLSAgICAgICAgR1BSUmVn IHNjcmF0Y2ggPSBwYXJhbXMuZ3BTY3JhdGNoKDApOwotICAgICAgICBqaXQubG9hZFB0cihDQ2Fs bEhlbHBlcnM6OkFkZHJlc3MocGFyYW1zWzBdLmdwcigpLCBKU1dlYkFzc2VtYmx5SW5zdGFuY2U6 Om9mZnNldE9mTWVtb3J5KCkpLCBzY3JhdGNoKTsKLSAgICAgICAgaml0LmxvYWRQdHIoQ0NhbGxI ZWxwZXJzOjpBZGRyZXNzKHNjcmF0Y2gsIEpTV2ViQXNzZW1ibHlNZW1vcnk6Om9mZnNldE9mTWVt b3J5KCkpLCBzY3JhdGNoKTsKLSAgICAgICAgaml0LmxvYWRQdHIoQ0NhbGxIZWxwZXJzOjpBZGRy ZXNzKHNjcmF0Y2gsIE1lbW9yeTo6b2Zmc2V0T2ZNZW1vcnkoKSksIG1lbW9yeS0+cGlubmVkUmVn aXN0ZXJzKCkuYmFzZU1lbW9yeVBvaW50ZXIpOwotCi0gICAgICAgIGppdC5sb2FkNjQoQ0NhbGxI ZWxwZXJzOjpBZGRyZXNzKHNjcmF0Y2gsIE1lbW9yeTo6b2Zmc2V0T2ZTaXplKCkpLCBzY3JhdGNo KTsKLSAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IG1lbW9yeS0+cGlubmVkUmVnaXN0 ZXJzKCkuc2l6ZVJlZ2lzdGVycy5zaXplKCk7IGkrKykgewotICAgICAgICAgICAgR1BSUmVnIHNp emVSZWcgPSBtZW1vcnktPnBpbm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnNbaV0uc2l6ZVJl Z2lzdGVyOwotICAgICAgICAgICAgaml0Lm1vdmUoc2NyYXRjaCwgc2l6ZVJlZyk7Ci0gICAgICAg ICAgICBqaXQuc3ViNjQoQ0NhbGxIZWxwZXJzOjpUcnVzdGVkSW1tMzIobWVtb3J5LT5waW5uZWRS ZWdpc3RlcnMoKS5zaXplUmVnaXN0ZXJzW2ldLnNpemVPZmZzZXQpLCBzaXplUmVnKTsKLSAgICAg ICAgfQotICAgIH0pOwotfQotCi12b2lkIEIzSVJHZW5lcmF0b3I6OmVtaXRSZWxvYWRQaW5uZWRS ZWdpc3RlcnMoKQotewotICAgIHJlbG9hZFBpbm5lZFJlZ2lzdGVycyhtX3Byb2MsIG1fY3VycmVu dEJsb2NrLCBtX2luZm8sIG1faW5zdGFuY2VWYWx1ZSk7Ci19Ci0KLQogYXV0byBCM0lSR2VuZXJh dG9yOjphZGRHcm93TWVtb3J5KEV4cHJlc3Npb25UeXBlIGRlbHRhLCBFeHByZXNzaW9uVHlwZSYg cmVzdWx0KSAtPiBQYXJ0aWFsUmVzdWx0CiB7CiAgICAgaW50MzJfdCAoKmdyb3dNZW1vcnkpIChF eGVjU3RhdGUqLCBpbnQzMl90KSA9IFtdIChFeGVjU3RhdGUqIGV4ZWMsIGludDMyX3QgZGVsdGEp IC0+IGludDMyX3QgewpAQCAtNDA3LDIxICs0MTQsMTkgQEAgYXV0byBCM0lSR2VuZXJhdG9yOjph ZGRHcm93TWVtb3J5KEV4cHJlc3Npb25UeXBlIGRlbHRhLCBFeHByZXNzaW9uVHlwZSYgcmVzdWx0 KQogICAgICAgICBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KG1fcHJv YywgT3JpZ2luKCksIGJpdHdpc2VfY2FzdDx2b2lkKj4oZ3Jvd01lbW9yeSkpLAogICAgICAgICBt X2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PEIzOjpWYWx1ZT4obV9wcm9jLCBCMzo6RnJhbWVQb2lu dGVyLCBPcmlnaW4oKSksIGRlbHRhKTsKIAotICAgIGVtaXRSZWxvYWRQaW5uZWRSZWdpc3RlcnMo KTsKKyAgICByZXN0b3JlV2ViQXNzZW1ibHlHbG9iYWxTdGF0ZShtX3ZtLCBtX2luZm8ubWVtb3J5 LCBtX2luc3RhbmNlVmFsdWUsIG1fcHJvYywgbV9jdXJyZW50QmxvY2spOwogCiAgICAgcmV0dXJu IHsgfTsKIH0KIAogYXV0byBCM0lSR2VuZXJhdG9yOjphZGRDdXJyZW50TWVtb3J5KEV4cHJlc3Np b25UeXBlJiByZXN1bHQpIC0+IFBhcnRpYWxSZXN1bHQKIHsKLSAgICBWYWx1ZSoganNNZW1vcnkg PSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQsIHBv aW50ZXJUeXBlKCksIE9yaWdpbigpLCBtX2luc3RhbmNlVmFsdWUsIEpTV2ViQXNzZW1ibHlJbnN0 YW5jZTo6b2Zmc2V0T2ZNZW1vcnkoKSk7Ci0gICAgVmFsdWUqIHdhc21NZW1vcnkgPSBtX2N1cnJl bnRCbG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQsIHBvaW50ZXJUeXBl KCksIE9yaWdpbigpLCBqc01lbW9yeSwgSlNXZWJBc3NlbWJseU1lbW9yeTo6b2Zmc2V0T2ZNZW1v cnkoKSk7Ci0gICAgVmFsdWUqIHNpemUgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PE1lbW9y eVZhbHVlPihtX3Byb2MsIExvYWQsIEIzOjpJbnQ2NCwgT3JpZ2luKCksIHdhc21NZW1vcnksIE1l bW9yeTo6b2Zmc2V0T2ZTaXplKCkpOworICAgIGF1dG8gbWVtb3J5VmFsdWUgPSBnZXRNZW1vcnlC YXNlQW5kU2l6ZShtX3ZtLCBtX2luc3RhbmNlVmFsdWUsIG1fcHJvYywgbV9jdXJyZW50QmxvY2sp OwogCiAgICAgY29uc3RleHByIHVpbnQzMl90IHNoaWZ0VmFsdWUgPSAxNjsKICAgICBzdGF0aWNf YXNzZXJ0KFBhZ2VDb3VudDo6cGFnZVNpemUgPT0gMSA8PCBzaGlmdFZhbHVlLCAiVGhpcyBtdXN0 IGhvbGQgZm9yIHRoZSBjb2RlIGJlbG93IHRvIGJlIGNvcnJlY3QuIik7CiAgICAgVmFsdWUqIG51 bVBhZ2VzID0gbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxWYWx1ZT4obV9wcm9jLCBaU2hyLCBP cmlnaW4oKSwKLSAgICAgICAgc2l6ZSwgbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxDb25zdDMy VmFsdWU+KG1fcHJvYywgT3JpZ2luKCksIHNoaWZ0VmFsdWUpKTsKKyAgICAgICAgbWVtb3J5VmFs dWUuc2l6ZSwgbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxDb25zdDMyVmFsdWU+KG1fcHJvYywg T3JpZ2luKCksIHNoaWZ0VmFsdWUpKTsKIAogICAgIHJlc3VsdCA9IG1fY3VycmVudEJsb2NrLT5h cHBlbmROZXc8VmFsdWU+KG1fcHJvYywgVHJ1bmMsIE9yaWdpbigpLCBudW1QYWdlcyk7CiAKQEAg LTgzMiwyNiArODM3LDc1IEBAIGF1dG8gQjNJUkdlbmVyYXRvcjo6YWRkQ2FsbCh1aW50MzJfdCBm dW5jdGlvbkluZGV4LCBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSwKICAgICBBU1NFUlQoc2ln bmF0dXJlLT5hcmd1bWVudENvdW50KCkgPT0gYXJncy5zaXplKCkpOwogCiAgICAgVHlwZSByZXR1 cm5UeXBlID0gc2lnbmF0dXJlLT5yZXR1cm5UeXBlKCk7CisgICAgVmVjdG9yPFVubGlua2VkV2Fz bVRvV2FzbUNhbGw+KiB1bmxpbmtlZFdhc21Ub1dhc21DYWxscyA9ICZtX3VubGlua2VkV2FzbVRv V2FzbUNhbGxzOwogCi0gICAgcmVzdWx0ID0gd2FzbUNhbGxpbmdDb252ZW50aW9uKCkuc2V0dXBD YWxsKG1fcHJvYywgbV9jdXJyZW50QmxvY2ssIE9yaWdpbigpLCBhcmdzLCB0b0IzVHlwZShyZXR1 cm5UeXBlKSwKLSAgICAgICAgWyZdIChQYXRjaHBvaW50VmFsdWUqIHBhdGNocG9pbnQpIHsKLSAg ICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKLSAgICAg ICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMucmVhZHNQaW5uZWQgPSB0cnVlOworICAgIGlmICht X2luZm8uaXNJbXBvcnRlZEZ1bmN0aW9uRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbklu ZGV4KSkgeworICAgICAgICAvLyBGSVhNRSBpbXBvcnRzIGNhbiBiZSBsaW5rZWQgaGVyZSwgaW5z dGVhZCBvZiBnZW5lcmF0aW5nIGEgcGF0Y2hwb2ludCwgYmVjYXVzZSBhbGwgaW1wb3J0IHN0dWJz IGFyZSBnZW5lcmF0ZWQgYmVmb3JlIEIzIGNvbXBpbGF0aW9uIHN0YXJ0cy4gaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NjQ2MgorICAgICAgICBFeHByZXNzaW9uVHlw ZSBmdW5jdGlvbkltcG9ydCA9IG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+ KG1fcHJvYywgTG9hZCwgcG9pbnRlclR5cGUoKSwgT3JpZ2luKCksIG1faW5zdGFuY2VWYWx1ZSwg SlNXZWJBc3NlbWJseUluc3RhbmNlOjpvZmZzZXRPZkltcG9ydEZ1bmN0aW9uKGZ1bmN0aW9uSW5k ZXgpKTsKKyAgICAgICAgRXhwcmVzc2lvblR5cGUganNUeXBlT2ZJbXBvcnQgPSBtX2N1cnJlbnRC bG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQ4WiwgT3JpZ2luKCksIGZ1 bmN0aW9uSW1wb3J0LCBKU0NlbGw6OnR5cGVJbmZvVHlwZU9mZnNldCgpKTsKKyAgICAgICAgVmFs dWUqIGlzV2FzbUNhbGwgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PFZhbHVlPihtX3Byb2Ms IEVxdWFsLCBPcmlnaW4oKSwganNUeXBlT2ZJbXBvcnQsIG1fY3VycmVudEJsb2NrLT5hcHBlbmRO ZXc8Q29uc3QzMlZhbHVlPihtX3Byb2MsIE9yaWdpbigpLCBXZWJBc3NlbWJseUZ1bmN0aW9uVHlw ZSkpOwogCi0gICAgICAgICAgICBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4qIHVubGlu a2VkV2FzbVRvV2FzbUNhbGxzID0gJm1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHM7Ci0gICAgICAg ICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBm dW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVy YXRpb25QYXJhbXMmKSB7Ci0gICAgICAgICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3Rl clVzYWdlIGFsbG93U2NyYXRjaChqaXQpOworICAgICAgICBCYXNpY0Jsb2NrKiBpc1dhc21CbG9j ayA9IG1fcHJvYy5hZGRCbG9jaygpOworICAgICAgICBCYXNpY0Jsb2NrKiBpc0pTQmxvY2sgPSBt X3Byb2MuYWRkQmxvY2soKTsKKyAgICAgICAgQmFzaWNCbG9jayogY29udGludWF0aW9uID0gbV9w cm9jLmFkZEJsb2NrKCk7CisgICAgICAgIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXdDb250cm9s VmFsdWUobV9wcm9jLCBCMzo6QnJhbmNoLCBPcmlnaW4oKSwgaXNXYXNtQ2FsbCwgRnJlcXVlbnRl ZEJsb2NrKGlzV2FzbUJsb2NrKSwgRnJlcXVlbnRlZEJsb2NrKGlzSlNCbG9jaykpOworCisgICAg ICAgIFZhbHVlKiB3YXNtQ2FsbFJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigpLnNldHVw Q2FsbChtX3Byb2MsIGlzV2FzbUJsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0dXJu VHlwZSksCisgICAgICAgICAgICBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkgewor ICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsK KyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsK KyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRv V2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpT dGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7CisgICAgICAgICAgICAgICAgICAgIEFsbG93TWFj cm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAgICAgICAg ICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICAgICAg ICAgICAgICBqaXQuYWRkTGlua1Rhc2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjYWxsLCBm dW5jdGlvbkluZGV4XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZlcikgeworICAgICAgICAgICAgICAg ICAgICAgICAgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZmZXIubG9j YXRpb25PZihjYWxsKSwgZnVuY3Rpb25JbmRleCwgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbDo6VGFy Z2V0Ojp0b1dhc20gfSk7CisgICAgICAgICAgICAgICAgICAgIH0pOworICAgICAgICAgICAgICAg IH0pOworICAgICAgICAgICAgfSk7CisgICAgICAgIFVwc2lsb25WYWx1ZSogd2FzbUNhbGxSZXN1 bHRVcHNpbG9uID0gcmV0dXJuVHlwZSA9PSBWb2lkID8gbnVsbHB0ciA6IGlzV2FzbUJsb2NrLT5h cHBlbmROZXc8VXBzaWxvblZhbHVlPihtX3Byb2MsIE9yaWdpbigpLCB3YXNtQ2FsbFJlc3VsdCk7 CisgICAgICAgIGlzV2FzbUJsb2NrLT5hcHBlbmROZXdDb250cm9sVmFsdWUobV9wcm9jLCBKdW1w LCBPcmlnaW4oKSwgY29udGludWF0aW9uKTsKKworICAgICAgICBWYWx1ZSoganNDYWxsUmVzdWx0 ID0gd2FzbUNhbGxpbmdDb252ZW50aW9uKCkuc2V0dXBDYWxsKG1fcHJvYywgaXNKU0Jsb2NrLCBP cmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0dXJuVHlwZSksCisgICAgICAgICAgICBbJl0gKFBh dGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkgeworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQt PmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50 LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50 LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAo Q0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7 CisgICAgICAgICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxv d1NjcmF0Y2goaml0KTsKKyAgICAgICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNh bGwgPSBqaXQuY2FsbCgpOworICAgICAgICAgICAgICAgICAgICBqaXQuYWRkTGlua1Rhc2soW3Vu bGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4XSAoTGlua0J1ZmZlciYg bGlua0J1ZmZlcikgeworICAgICAgICAgICAgICAgICAgICAgICAgdW5saW5rZWRXYXNtVG9XYXNt Q2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZmZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rpb25JbmRl eCwgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbDo6VGFyZ2V0Ojp0b0pTIH0pOworICAgICAgICAgICAg ICAgICAgICB9KTsKKyAgICAgICAgICAgICAgICB9KTsKKyAgICAgICAgICAgIH0pOworICAgICAg ICBVcHNpbG9uVmFsdWUqIGpzQ2FsbFJlc3VsdFVwc2lsb24gPSByZXR1cm5UeXBlID09IFZvaWQg PyBudWxscHRyIDogaXNKU0Jsb2NrLT5hcHBlbmROZXc8VXBzaWxvblZhbHVlPihtX3Byb2MsIE9y aWdpbigpLCBqc0NhbGxSZXN1bHQpOworICAgICAgICBpc0pTQmxvY2stPmFwcGVuZE5ld0NvbnRy b2xWYWx1ZShtX3Byb2MsIEp1bXAsIE9yaWdpbigpLCBjb250aW51YXRpb24pOworCisgICAgICAg IG1fY3VycmVudEJsb2NrID0gY29udGludWF0aW9uOwogCi0gICAgICAgICAgICAgICAgQ0NhbGxI ZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICBpZiAocmV0dXJuVHlwZSA9 PSBWb2lkKQorICAgICAgICAgICAgcmVzdWx0ID0gbnVsbHB0cjsKKyAgICAgICAgZWxzZSB7Cisg ICAgICAgICAgICByZXN1bHQgPSBjb250aW51YXRpb24tPmFwcGVuZE5ldzxWYWx1ZT4obV9wcm9j LCBQaGksIHRvQjNUeXBlKHJldHVyblR5cGUpLCBPcmlnaW4oKSk7CisgICAgICAgICAgICB3YXNt Q2FsbFJlc3VsdFVwc2lsb24tPnNldFBoaShyZXN1bHQpOworICAgICAgICAgICAganNDYWxsUmVz dWx0VXBzaWxvbi0+c2V0UGhpKHJlc3VsdCk7CisgICAgICAgIH0KIAotICAgICAgICAgICAgICAg IGppdC5hZGRMaW5rVGFzayhbdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGNhbGwsIGZ1bmN0aW9u SW5kZXhdIChMaW5rQnVmZmVyJiBsaW5rQnVmZmVyKSB7Ci0gICAgICAgICAgICAgICAgICAgIHVu bGlua2VkV2FzbVRvV2FzbUNhbGxzLT5hcHBlbmQoeyBsaW5rQnVmZmVyLmxvY2F0aW9uT2YoY2Fs bCksIGZ1bmN0aW9uSW5kZXggfSk7CisgICAgICAgIC8vIFRoZSBjYWxsIGNvdWxkIGhhdmUgYmVl biB0byBhbm90aGVyIFdlYkFzc2VtYmx5IGluc3RhbmNlLCBhbmQgLyBvciBjb3VsZCBoYXZlIG1v ZGlmaWVkIG91ciBNZW1vcnkuCisgICAgICAgIHJlc3RvcmVXZWJBc3NlbWJseUdsb2JhbFN0YXRl KG1fdm0sIG1faW5mby5tZW1vcnksIG1faW5zdGFuY2VWYWx1ZSwgbV9wcm9jLCBjb250aW51YXRp b24pOworICAgIH0gZWxzZSB7CisgICAgICAgIHJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlv bigpLnNldHVwQ2FsbChtX3Byb2MsIG1fY3VycmVudEJsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9C M1R5cGUocmV0dXJuVHlwZSksCisgICAgICAgICAgICBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0 Y2hwb2ludCkgeworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlu bmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlu bmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3Vu bGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQs IGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7CisgICAgICAgICAgICAgICAg ICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAg ICAgICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOwor ICAgICAgICAgICAgICAgICAgICBqaXQuYWRkTGlua1Rhc2soW3VubGlua2VkV2FzbVRvV2FzbUNh bGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZlcikgeworICAg ICAgICAgICAgICAgICAgICAgICAgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxp bmtCdWZmZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rpb25JbmRleCwgVW5saW5rZWRXYXNtVG9X YXNtQ2FsbDo6VGFyZ2V0Ojp0b1dhc20gfSk7CisgICAgICAgICAgICAgICAgICAgIH0pOwogICAg ICAgICAgICAgICAgIH0pOwogICAgICAgICAgICAgfSk7Ci0gICAgICAgIH0pOwotCi0gICAgaWYg KGZ1bmN0aW9uSW5kZXggPCBtX2luZm8uaW1wb3J0RnVuY3Rpb25Db3VudCgpKQotICAgICAgICBl bWl0UmVsb2FkUGlubmVkUmVnaXN0ZXJzKCk7CisgICAgfQogCiAgICAgcmV0dXJuIHsgfTsKIH0K QEAgLTkyOSw3ICs5ODMsOCBAQCBhdXRvIEIzSVJHZW5lcmF0b3I6OmFkZENhbGxJbmRpcmVjdChj b25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSwgU2lnbmF0dXJlSW5kZXggcwogICAgICAgICAgICAg fSk7CiAgICAgICAgIH0pOwogCi0gICAgZW1pdFJlbG9hZFBpbm5lZFJlZ2lzdGVycygpOworICAg IC8vIFRoZSBjYWxsIGNvdWxkIGhhdmUgYmVlbiB0byBhbm90aGVyIFdlYkFzc2VtYmx5IGluc3Rh bmNlLCBhbmQgLyBvciBjb3VsZCBoYXZlIG1vZGlmaWVkIG91ciBNZW1vcnkuCisgICAgcmVzdG9y ZVdlYkFzc2VtYmx5R2xvYmFsU3RhdGUobV92bSwgbV9pbmZvLm1lbW9yeSwgbV9pbnN0YW5jZVZh bHVlLCBtX3Byb2MsIG1fY3VycmVudEJsb2NrKTsKIAogICAgIHJldHVybiB7IH07CiB9CkBAIC05 OTgsMTIgKzEwNTMsMTAgQEAgc3RhdGljIHZvaWQgY3JlYXRlSlNUb1dhc21XcmFwcGVyKFZNJiB2 bSwgQ29tcGlsYXRpb25Db250ZXh0JiBjb21waWxhdGlvbkNvbnRleHQKICAgICAgICAgfSk7CiAg ICAgfQogCi0gICAgLy8gTW92ZSBtZW1vcnkgdmFsdWVzIHRvIHRoZSBhcHByb3JpYXRlIHBsYWNl cywgaWYgbmVlZGVkLgotICAgIHsKLSAgICAgICAgVmFsdWUqIGluc3RhbmNlID0gYmxvY2stPmFw cGVuZE5ldzxNZW1vcnlWYWx1ZT4ocHJvYywgTG9hZCwgcG9pbnRlclR5cGUoKSwgT3JpZ2luKCks Ci0gICAgICAgICAgICBibG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KHByb2MsIE9yaWdp bigpLCAmdm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlKSk7Ci0gICAgICAgIHJlbG9hZFBpbm5l ZFJlZ2lzdGVycyhwcm9jLCBibG9jaywgaW5mbywgaW5zdGFuY2UpOwotICAgIH0KKyAgICAvLyBG SVhNRSBUaGUgaW5zdGFuY2UgaXMgY3VycmVudGx5IHNldCBieSB0aGUgQysrIGNvZGUgaW4gV2Vi QXNzZW1ibHlGdW5jdGlvbjo6Y2FsbC4gV2Ugc2hvdWxkbid0IGdvIHRocm91Z2ggdGhlIGV4dHJh IEMrKyBob29wLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY2NDg2 CisgICAgVmFsdWUqIGluc3RhbmNlID0gYmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4ocHJv YywgTG9hZCwgcG9pbnRlclR5cGUoKSwgT3JpZ2luKCksCisgICAgICAgIGJsb2NrLT5hcHBlbmRO ZXc8Q29uc3RQdHJWYWx1ZT4ocHJvYywgT3JpZ2luKCksICZ2bS50b3BKU1dlYkFzc2VtYmx5SW5z dGFuY2UpKTsKKyAgICByZXN0b3JlV2ViQXNzZW1ibHlHbG9iYWxTdGF0ZSh2bSwgaW5mby5tZW1v cnksIGluc3RhbmNlLCBwcm9jLCBibG9jayk7CiAKICAgICAvLyBHZXQgb3VyIGFyZ3VtZW50cy4K ICAgICBWZWN0b3I8VmFsdWUqPiBhcmd1bWVudHM7CkBAIC0xMDQ2LDcgKzEwOTksNyBAQCBzdGF0 aWMgdm9pZCBjcmVhdGVKU1RvV2FzbVdyYXBwZXIoVk0mIHZtLCBDb21waWxhdGlvbkNvbnRleHQm IGNvbXBpbGF0aW9uQ29udGV4dAogICAgIGZ1bmN0aW9uLmpzVG9XYXNtRW50cnlwb2ludC5jYWxs ZWVTYXZlUmVnaXN0ZXJzID0gcHJvYy5jYWxsZWVTYXZlUmVnaXN0ZXJzKCk7CiB9CiAKLUV4cGVj dGVkPHN0ZDo6dW5pcXVlX3B0cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0cmluZz4gcGFyc2VB bmRDb21waWxlKFZNJiB2bSwgQ29tcGlsYXRpb25Db250ZXh0JiBjb21waWxhdGlvbkNvbnRleHQs IGNvbnN0IHVpbnQ4X3QqIGZ1bmN0aW9uU3RhcnQsIHNpemVfdCBmdW5jdGlvbkxlbmd0aCwgY29u c3QgU2lnbmF0dXJlKiBzaWduYXR1cmUsIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYg dW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGNvbnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFj ZSYgZnVuY3Rpb25JbmRleFNwYWNlLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgdW5z aWduZWQgb3B0TGV2ZWwpCitFeHBlY3RlZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbUludGVybmFsRnVu Y3Rpb24+LCBTdHJpbmc+IHBhcnNlQW5kQ29tcGlsZShWTSYgdm0sIENvbXBpbGF0aW9uQ29udGV4 dCYgY29tcGlsYXRpb25Db250ZXh0LCBjb25zdCB1aW50OF90KiBmdW5jdGlvblN0YXJ0LCBzaXpl X3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBWZWN0b3I8VW5s aW5rZWRXYXNtVG9XYXNtQ2FsbD4mIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjb25zdCBNb2R1 bGVJbmZvcm1hdGlvbiYgaW5mbywgY29uc3QgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiYgbW9kdWxl U2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMsIHVuc2lnbmVkIG9wdExl dmVsKQogewogICAgIGF1dG8gcmVzdWx0ID0gc3RkOjptYWtlX3VuaXF1ZTxXYXNtSW50ZXJuYWxG dW5jdGlvbj4oKTsKIApAQCAtMTA1NCw4ICsxMTA3LDggQEAgRXhwZWN0ZWQ8c3RkOjp1bmlxdWVf cHRyPFdhc21JbnRlcm5hbEZ1bmN0aW9uPiwgU3RyaW5nPiBwYXJzZUFuZENvbXBpbGUoVk0mIHZt LAogICAgIGNvbXBpbGF0aW9uQ29udGV4dC53YXNtRW50cnlwb2ludEpJVCA9IHN0ZDo6bWFrZV91 bmlxdWU8Q0NhbGxIZWxwZXJzPigmdm0pOwogCiAgICAgUHJvY2VkdXJlIHByb2NlZHVyZTsKLSAg ICBCM0lSR2VuZXJhdG9yIGNvbnRleHQodm0sIGluZm8sIHByb2NlZHVyZSwgcmVzdWx0LmdldCgp LCB1bmxpbmtlZFdhc21Ub1dhc21DYWxscywgZnVuY3Rpb25JbmRleFNwYWNlKTsKLSAgICBGdW5j dGlvblBhcnNlcjxCM0lSR2VuZXJhdG9yPiBwYXJzZXIoJnZtLCBjb250ZXh0LCBmdW5jdGlvblN0 YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBmdW5jdGlvbkluZGV4U3BhY2UsIGluZm8p OworICAgIEIzSVJHZW5lcmF0b3IgY29udGV4dCh2bSwgaW5mbywgcHJvY2VkdXJlLCByZXN1bHQu Z2V0KCksIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzKTsKKyAgICBGdW5jdGlvblBhcnNlcjxCM0lS R2VuZXJhdG9yPiBwYXJzZXIoJnZtLCBjb250ZXh0LCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxl bmd0aCwgc2lnbmF0dXJlLCBpbmZvLCBtb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2ln bmF0dXJlSW5kaWNlcyk7CiAgICAgV0FTTV9GQUlMX0lGX0hFTFBFUl9GQUlMUyhwYXJzZXIucGFy c2UoKSk7CiAKICAgICBwcm9jZWR1cmUucmVzZXRSZWFjaGFiaWxpdHkoKTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmggYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5oCmluZGV4IGI1YzlmNDYuLjI0 OWQ1NzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2Vu ZXJhdG9yLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0 b3IuaApAQCAtNDcsNyArNDcsNyBAQCBzdHJ1Y3QgQ29tcGlsYXRpb25Db250ZXh0IHsKICAgICBD Q2FsbEhlbHBlcnM6OkNhbGwganNFbnRyeXBvaW50VG9XYXNtRW50cnlwb2ludENhbGw7CiB9Owog Ci1FeHBlY3RlZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbUludGVybmFsRnVuY3Rpb24+LCBTdHJpbmc+ IHBhcnNlQW5kQ29tcGlsZShWTSYsIENvbXBpbGF0aW9uQ29udGV4dCYsIGNvbnN0IHVpbnQ4X3Qq LCBzaXplX3QsIGNvbnN0IFNpZ25hdHVyZSosIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxs PiYsIGNvbnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYsIGNvbnN0IE1vZHVsZUluZm9y bWF0aW9uJiwgdW5zaWduZWQgb3B0TGV2ZWwgPSAxKTsKK0V4cGVjdGVkPHN0ZDo6dW5pcXVlX3B0 cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0cmluZz4gcGFyc2VBbmRDb21waWxlKFZNJiwgQ29t cGlsYXRpb25Db250ZXh0JiwgY29uc3QgdWludDhfdCosIHNpemVfdCwgY29uc3QgU2lnbmF0dXJl KiwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+JiwgY29uc3QgTW9kdWxlSW5mb3JtYXRp b24mLCBjb25zdCBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+JiwgdW5zaWduZWQgb3B0TGV2ZWwgPSAx KTsKIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KIApkaWZmIC0tZ2l0IGEvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbUJpbmRpbmcuY3BwCmluZGV4IDBlNTkyNDcuLmJhOGFlNWUgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmNwcAorKysgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5jcHAKQEAgLTM2LDcgKzM2LDcgQEAKIAog bmFtZXNwYWNlIEpTQyB7IG5hbWVzcGFjZSBXYXNtIHsKIAotV2FzbVRvSlNTdHViIGltcG9ydFN0 dWJHZW5lcmF0b3IoVk0qIHZtLCBCYWc8Q2FsbExpbmtJbmZvPiYgY2FsbExpbmtJbmZvcywgU2ln bmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXgsIHVuc2lnbmVkIGltcG9ydEluZGV4KQorc3RhdGlj IE1hY3JvQXNzZW1ibGVyQ29kZVJlZiB3YXNtVG9KUyhWTSogdm0sIEJhZzxDYWxsTGlua0luZm8+ JiBjYWxsTGlua0luZm9zLCBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCwgdW5zaWduZWQg aW1wb3J0SW5kZXgpCiB7CiAgICAgY29uc3QgV2FzbUNhbGxpbmdDb252ZW50aW9uJiB3YXNtQ0Mg PSB3YXNtQ2FsbGluZ0NvbnZlbnRpb24oKTsKICAgICBjb25zdCBKU0NDYWxsaW5nQ29udmVudGlv biYganNDQyA9IGpzY0NhbGxpbmdDb252ZW50aW9uKCk7CkBAIC0yMzEsNyArMjMxLDUyIEBAIFdh c21Ub0pTU3R1YiBpbXBvcnRTdHViR2VuZXJhdG9yKFZNKiB2bSwgQmFnPENhbGxMaW5rSW5mbz4m IGNhbGxMaW5rSW5mb3MsIFNpZ25hCiAgICAgQ29kZUxvY2F0aW9uTGFiZWwgaG90UGF0aEJlZ2lu KHBhdGNoQnVmZmVyLmxvY2F0aW9uT2YodGFyZ2V0VG9DaGVjaykpOwogICAgIENvZGVMb2NhdGlv bk5lYXJDYWxsIGhvdFBhdGhPdGhlciA9IHBhdGNoQnVmZmVyLmxvY2F0aW9uT2ZOZWFyQ2FsbChm YXN0Q2FsbCk7CiAgICAgY2FsbExpbmtJbmZvLT5zZXRDYWxsTG9jYXRpb25zKGNhbGxSZXR1cm5M b2NhdGlvbiwgaG90UGF0aEJlZ2luLCBob3RQYXRoT3RoZXIpOwotICAgIHJldHVybiBGSU5BTEla RV9DT0RFKHBhdGNoQnVmZmVyLCAoIldlYkFzc2VtYmx5IGltcG9ydFslaV0gc3R1YiBmb3Igc2ln bmF0dXJlICVpIiwgaW1wb3J0SW5kZXgsIHNpZ25hdHVyZUluZGV4KSk7CisgICAgU3RyaW5nIHNp Z25hdHVyZURlc2NyaXB0aW9uID0gU2lnbmF0dXJlSW5mb3JtYXRpb246OmdldCh2bSwgc2lnbmF0 dXJlSW5kZXgpLT50b1N0cmluZygpOworICAgIHJldHVybiBGSU5BTElaRV9DT0RFKHBhdGNoQnVm ZmVyLCAoIldlYkFzc2VtYmx5LT5KYXZhU2NyaXB0IGltcG9ydFslaV0gJXMiLCBpbXBvcnRJbmRl eCwgc2lnbmF0dXJlRGVzY3JpcHRpb24uYXNjaWkoKS5kYXRhKCkpKTsKK30KKworc3RhdGljIE1h Y3JvQXNzZW1ibGVyQ29kZVJlZiB3YXNtVG9XYXNtKFZNKiB2bSwgQmFnPENhbGxMaW5rSW5mbz4m IGNhbGxMaW5rSW5mb3MsIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4LCB1bnNpZ25lZCBp bXBvcnRJbmRleCkKK3sKKyAgICBjb25zdCBXYXNtQ2FsbGluZ0NvbnZlbnRpb24mIHdhc21DQyA9 IHdhc21DYWxsaW5nQ29udmVudGlvbigpOworICAgIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJl ID0gU2lnbmF0dXJlSW5mb3JtYXRpb246OmdldCh2bSwgc2lnbmF0dXJlSW5kZXgpOworICAgIHVu c2lnbmVkIGFyZ0NvdW50ID0gc2lnbmF0dXJlLT5hcmd1bWVudENvdW50KCk7CisgICAgdHlwZWRl ZiBBc3NlbWJseUhlbHBlcnMgSklUOworICAgIEpJVCBqaXQodm0sIG51bGxwdHIpOworCisgICAg aml0LmVtaXRGdW5jdGlvblByb2xvZ3VlKCk7CisgICAgaml0LnN0b3JlNjQoSklUOjpUcnVzdGVk SW1tMzIoMCksIEpJVDo6QWRkcmVzcyhHUFJJbmZvOjpjYWxsRnJhbWVSZWdpc3RlciwgQ2FsbEZy YW1lU2xvdDo6Y29kZUJsb2NrICogc3RhdGljX2Nhc3Q8aW50PihzaXplb2YoUmVnaXN0ZXIpKSkp OyAvLyBGSVhNRSBTdG9wIHVzaW5nIDAgYXMgY29kZUJsb2Nrcy4gaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NTMyMQorICAgIGppdC5zdG9yZVB0cihKSVQ6OlRydXN0 ZWRJbW1QdHIodm0tPndlYkFzc2VtYmx5VG9KU0NhbGxlZS5nZXQoKSksIEpJVDo6QWRkcmVzcyhH UFJJbmZvOjpjYWxsRnJhbWVSZWdpc3RlciwgQ2FsbEZyYW1lU2xvdDo6Y2FsbGVlICogc3RhdGlj X2Nhc3Q8aW50PihzaXplb2YoUmVnaXN0ZXIpKSkpOworCisgICAgLy8gRklYTUUgcGVyZm9ybSBh IHN0YWNrIGNoZWNrIGJlZm9yZSB1cGRhdGluZyBTUC4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE2NTU0NgorCisgICAgdW5zaWduZWQgbnVtYmVyT2ZQYXJhbWV0ZXJz ID0gYXJnQ291bnQgKyAxOyAvLyBUaGVyZSBpcyBhICJ0aGlzIiBhcmd1bWVudC4KKyAgICB1bnNp Z25lZCBudW1iZXJPZlJlZ3NGb3JDYWxsID0gQ2FsbEZyYW1lOjpoZWFkZXJTaXplSW5SZWdpc3Rl cnMgKyBudW1iZXJPZlBhcmFtZXRlcnM7CisgICAgdW5zaWduZWQgbnVtYmVyT2ZCeXRlc0ZvckNh bGwgPSBudW1iZXJPZlJlZ3NGb3JDYWxsICogc2l6ZW9mKFJlZ2lzdGVyKSAtIHNpemVvZihDYWxs ZXJGcmFtZUFuZFBDKTsKKyAgICBjb25zdCB1bnNpZ25lZCBzdGFja09mZnNldCA9IFdURjo6cm91 bmRVcFRvTXVsdGlwbGVPZihzdGFja0FsaWdubWVudEJ5dGVzKCksIG51bWJlck9mQnl0ZXNGb3JD YWxsKTsKKyAgICBqaXQuc3ViUHRyKE1hY3JvQXNzZW1ibGVyOjpUcnVzdGVkSW1tMzIoc3RhY2tP ZmZzZXQpLCBNYWNyb0Fzc2VtYmxlcjo6c3RhY2tQb2ludGVyUmVnaXN0ZXIpOworICAgIEpJVDo6 QWRkcmVzcyBjYWxsZWVGcmFtZSA9IENDYWxsSGVscGVyczo6QWRkcmVzcyhNYWNyb0Fzc2VtYmxl cjo6c3RhY2tQb2ludGVyUmVnaXN0ZXIsIC1zdGF0aWNfY2FzdDxwdHJkaWZmX3Q+KHNpemVvZihD YWxsZXJGcmFtZUFuZFBDKSkpOworCisgICAgLy8gRklYTUUgaW1wbGVtZW50IHRoaXMuCisgICAg aml0LmJyZWFrcG9pbnQoKTsKKworICAgICh2b2lkKWNhbGxMaW5rSW5mb3M7CisgICAgKHZvaWQp Y2FsbGVlRnJhbWU7CisgICAgKHZvaWQpd2FzbUNDOworCisgICAgaml0LmVtaXRGdW5jdGlvbkVw aWxvZ3VlKCk7CisgICAgaml0LnJldCgpOworCisgICAgTGlua0J1ZmZlciBwYXRjaEJ1ZmZlcigq dm0sIGppdCwgR0xPQkFMX1RIVU5LX0lEKTsKKyAgICBTdHJpbmcgc2lnbmF0dXJlRGVzY3JpcHRp b24gPSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KHZtLCBzaWduYXR1cmVJbmRleCktPnRvU3Ry aW5nKCk7CisgICAgcmV0dXJuIEZJTkFMSVpFX0NPREUocGF0Y2hCdWZmZXIsICgiV2ViQXNzZW1i bHktPldlYkFzc2VtYmx5IGltcG9ydFslaV0gJXMiLCBpbXBvcnRJbmRleCwgc2lnbmF0dXJlRGVz Y3JpcHRpb24uYXNjaWkoKS5kYXRhKCkpKTsKK30KKworV2FzbUV4aXRTdHVicyBleGl0U3R1Ykdl bmVyYXRvcihWTSogdm0sIEJhZzxDYWxsTGlua0luZm8+JiBjYWxsTGlua0luZm9zLCBTaWduYXR1 cmVJbmRleCBzaWduYXR1cmVJbmRleCwgdW5zaWduZWQgaW1wb3J0SW5kZXgpCit7CisgICAgV2Fz bUV4aXRTdHVicyBzdHViczsKKyAgICBzdHVicy53YXNtVG9KUyA9IHdhc21Ub0pTKHZtLCBjYWxs TGlua0luZm9zLCBzaWduYXR1cmVJbmRleCwgaW1wb3J0SW5kZXgpOworICAgIHN0dWJzLndhc21U b1dhc20gPSB3YXNtVG9XYXNtKHZtLCBjYWxsTGlua0luZm9zLCBzaWduYXR1cmVJbmRleCwgaW1w b3J0SW5kZXgpOworICAgIHJldHVybiBzdHViczsKIH0KIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6 Oldhc20KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5n LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5oCmluZGV4IGZkN2Uw M2QuLjQwMjFmMTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21C aW5kaW5nLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuaApA QCAtMzgsNyArMzgsNyBAQCBjbGFzcyBDYWxsTGlua0luZm87CiAKIG5hbWVzcGFjZSBXYXNtIHsK IAotV2FzbVRvSlNTdHViIGltcG9ydFN0dWJHZW5lcmF0b3IoVk0qLCBCYWc8Q2FsbExpbmtJbmZv PiYsIFNpZ25hdHVyZUluZGV4LCB1bnNpZ25lZCk7CitXYXNtRXhpdFN0dWJzIGV4aXRTdHViR2Vu ZXJhdG9yKFZNKiwgQmFnPENhbGxMaW5rSW5mbz4mLCBTaWduYXR1cmVJbmRleCwgdW5zaWduZWQp OwogCiB9IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2FzbQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtRm9ybWF0LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtRm9ybWF0LmgKaW5kZXggY2IyYmU1NS4uMjNkOGVkMyAxMDA2NDQKLS0tIGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZvcm1hdC5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21Gb3JtYXQuaApAQCAtMjIyLDcgKzIyMiw2IEBAIHByaXZhdGU6CiB9Owog CiBzdHJ1Y3QgTW9kdWxlSW5mb3JtYXRpb24gewotICAgIFZlY3RvcjxTaWduYXR1cmVJbmRleD4g c2lnbmF0dXJlSW5kaWNlczsKICAgICBWZWN0b3I8SW1wb3J0PiBpbXBvcnRzOwogICAgIFZlY3Rv cjxTaWduYXR1cmVJbmRleD4gaW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzOwogICAgIFZl Y3RvcjxTaWduYXR1cmVJbmRleD4gaW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXM7CkBA IC0yMzYsNiArMjM1LDE4IEBAIHN0cnVjdCBNb2R1bGVJbmZvcm1hdGlvbiB7CiAgICAgVGFibGVJ bmZvcm1hdGlvbiB0YWJsZUluZm9ybWF0aW9uOwogICAgIFZlY3RvcjxHbG9iYWw+IGdsb2JhbHM7 CiAgICAgdW5zaWduZWQgZmlyc3RJbnRlcm5hbEdsb2JhbCB7IDAgfTsKKyAgICBzaXplX3QgZnVu Y3Rpb25JbmRleFNwYWNlU2l6ZSgpIGNvbnN0IHsgcmV0dXJuIGltcG9ydEZ1bmN0aW9uU2lnbmF0 dXJlSW5kaWNlcy5zaXplKCkgKyBpbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXpl KCk7IH0KKyAgICBib29sIGlzSW1wb3J0ZWRGdW5jdGlvbkZyb21GdW5jdGlvbkluZGV4U3BhY2Uo c2l6ZV90IGZ1bmN0aW9uSW5kZXgpIGNvbnN0CisgICAgeworICAgICAgICBBU1NFUlQoZnVuY3Rp b25JbmRleCA8IGZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSk7CisgICAgICAgIHJldHVybiBmdW5j dGlvbkluZGV4IDwgaW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnNpemUoKTsKKyAgICB9 CisgICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRleFNwYWNl KHNpemVfdCBmdW5jdGlvbkluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIGlzSW1w b3J0ZWRGdW5jdGlvbkZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleCkKKyAgICAg ICAgICAgID8gaW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzW2Z1bmN0aW9uSW5kZXhdCisg ICAgICAgICAgICA6IGludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzW2Z1bmN0aW9uSW5k ZXggLSBpbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMuc2l6ZSgpXTsKKyAgICB9CiAKICAg ICB1aW50MzJfdCBpbXBvcnRGdW5jdGlvbkNvdW50KCkgY29uc3QgeyByZXR1cm4gaW1wb3J0RnVu Y3Rpb25TaWduYXR1cmVJbmRpY2VzLnNpemUoKTsgfQogICAgIGJvb2wgaGFzTWVtb3J5KCkgY29u c3QgeyByZXR1cm4gISFtZW1vcnk7IH0KQEAgLTI0Niw2ICsyNTcsMTAgQEAgc3RydWN0IE1vZHVs ZUluZm9ybWF0aW9uIHsKIHN0cnVjdCBVbmxpbmtlZFdhc21Ub1dhc21DYWxsIHsKICAgICBDb2Rl TG9jYXRpb25DYWxsIGNhbGxMb2NhdGlvbjsKICAgICBzaXplX3QgZnVuY3Rpb25JbmRleDsKKyAg ICBlbnVtIGNsYXNzIFRhcmdldCA6IHVpbnQ4X3QgeworICAgICAgICB0b0pTLAorICAgICAgICB0 b1dhc20sCisgICAgfSB0YXJnZXQ7CiB9OwogCiBzdHJ1Y3QgRW50cnlwb2ludCB7CkBAIC0yNjEs NyArMjc2LDEwIEBAIHN0cnVjdCBXYXNtSW50ZXJuYWxGdW5jdGlvbiB7CiAgICAgRW50cnlwb2lu dCBqc1RvV2FzbUVudHJ5cG9pbnQ7CiB9OwogCi10eXBlZGVmIE1hY3JvQXNzZW1ibGVyQ29kZVJl ZiBXYXNtVG9KU1N0dWI7CitzdHJ1Y3QgV2FzbUV4aXRTdHVicyB7CisgICAgTWFjcm9Bc3NlbWJs ZXJDb2RlUmVmIHdhc21Ub0pTOworICAgIE1hY3JvQXNzZW1ibGVyQ29kZVJlZiB3YXNtVG9XYXNt OworfTsKIAogLy8gV2ViQXNzZW1ibHkgZGlyZWN0IGNhbGxzIGFuZCBjYWxsX2luZGlyZWN0IHVz ZSBpbmRpY2VzIGludG8gImZ1bmN0aW9uIGluZGV4IHNwYWNlIi4gVGhpcyBzcGFjZSBzdGFydHMg d2l0aCBhbGwgaW1wb3J0cywgYW5kIHRoZW4gYWxsIGludGVybmFsIGZ1bmN0aW9ucy4KIC8vIENh bGxhYmxlRnVuY3Rpb24gYW5kIEZ1bmN0aW9uSW5kZXhTcGFjZSBhcmUgb25seSBtZWFudCBhcyBm YXN0IGxvb2t1cCB0YWJsZXMgZm9yIHRoZXNlIG9wY29kZXMsIGFuZCBkbyBub3Qgb3duIGNvZGUu CkBAIC0yODAsMTIgKzI5OCw2IEBAIHN0cnVjdCBDYWxsYWJsZUZ1bmN0aW9uIHsKIH07CiB0eXBl ZGVmIFZlY3RvcjxDYWxsYWJsZUZ1bmN0aW9uPiBGdW5jdGlvbkluZGV4U3BhY2U7CiAKLQotc3Ry dWN0IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSB7Ci0gICAgTWFsbG9jUHRyPENhbGxhYmxl RnVuY3Rpb24+IGJ1ZmZlcjsKLSAgICBzaXplX3Qgc2l6ZTsKLX07Ci0KIH0gfSAvLyBuYW1lc3Bh Y2UgSlNDOjpXYXNtCiAKICNlbmRpZiAvLyBFTkFCTEUoV0VCQVNTRU1CTFkpCmRpZmYgLS1naXQg YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rpb25QYXJzZXIuaCBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21GdW5jdGlvblBhcnNlci5oCmluZGV4IDUyMDEwZGMu LjMxMTA1ZDggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21GdW5j dGlvblBhcnNlci5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21GdW5jdGlv blBhcnNlci5oCkBAIC00Niw3ICs0Niw3IEBAIHB1YmxpYzoKICAgICB0eXBlZGVmIHR5cGVuYW1l IENvbnRleHQ6OkNvbnRyb2xUeXBlIENvbnRyb2xUeXBlOwogICAgIHR5cGVkZWYgdHlwZW5hbWUg Q29udGV4dDo6RXhwcmVzc2lvbkxpc3QgRXhwcmVzc2lvbkxpc3Q7CiAKLSAgICBGdW5jdGlvblBh cnNlcihWTSosIENvbnRleHQmLCBjb25zdCB1aW50OF90KiBmdW5jdGlvblN0YXJ0LCBzaXplX3Qg ZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSosIGNvbnN0IEltbXV0YWJsZUZ1bmN0aW9u SW5kZXhTcGFjZSYsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJik7CisgICAgRnVuY3Rpb25QYXJz ZXIoVk0qLCBDb250ZXh0JiwgY29uc3QgdWludDhfdCogZnVuY3Rpb25TdGFydCwgc2l6ZV90IGZ1 bmN0aW9uTGVuZ3RoLCBjb25zdCBTaWduYXR1cmUqLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYs IGNvbnN0IFZlY3RvcjxTaWduYXR1cmVJbmRleD4mKTsKIAogICAgIFJlc3VsdCBXQVJOX1VOVVNF RF9SRVRVUk4gcGFyc2UoKTsKIApAQCAtODIsMTggKzgyLDE4IEBAIHByaXZhdGU6CiAgICAgRXhw cmVzc2lvbkxpc3QgbV9leHByZXNzaW9uU3RhY2s7CiAgICAgVmVjdG9yPENvbnRyb2xFbnRyeT4g bV9jb250cm9sU3RhY2s7CiAgICAgY29uc3QgU2lnbmF0dXJlKiBtX3NpZ25hdHVyZTsKLSAgICBj b25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIG1fZnVuY3Rpb25JbmRleFNwYWNlOwog ICAgIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBtX2luZm87CisgICAgY29uc3QgVmVjdG9yPFNp Z25hdHVyZUluZGV4PiYgbV9tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJl SW5kaWNlczsKICAgICB1bnNpZ25lZCBtX3VucmVhY2hhYmxlQmxvY2tzIHsgMCB9OwogfTsKIAog dGVtcGxhdGU8dHlwZW5hbWUgQ29udGV4dD4KLUZ1bmN0aW9uUGFyc2VyPENvbnRleHQ+OjpGdW5j dGlvblBhcnNlcihWTSogdm0sIENvbnRleHQmIGNvbnRleHQsIGNvbnN0IHVpbnQ4X3QqIGZ1bmN0 aW9uU3RhcnQsIHNpemVfdCBmdW5jdGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1 cmUsIGNvbnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYgZnVuY3Rpb25JbmRleFNwYWNl LCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbykKK0Z1bmN0aW9uUGFyc2VyPENvbnRleHQ+ OjpGdW5jdGlvblBhcnNlcihWTSogdm0sIENvbnRleHQmIGNvbnRleHQsIGNvbnN0IHVpbnQ4X3Qq IGZ1bmN0aW9uU3RhcnQsIHNpemVfdCBmdW5jdGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiBz aWduYXR1cmUsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBpbmZvLCBjb25zdCBWZWN0b3I8U2ln bmF0dXJlSW5kZXg+JiBtb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5k aWNlcykKICAgICA6IFBhcnNlcih2bSwgZnVuY3Rpb25TdGFydCwgZnVuY3Rpb25MZW5ndGgpCiAg ICAgLCBtX2NvbnRleHQoY29udGV4dCkKICAgICAsIG1fc2lnbmF0dXJlKHNpZ25hdHVyZSkKLSAg ICAsIG1fZnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXhTcGFjZSkKICAgICAsIG1faW5m byhpbmZvKQorICAgICwgbV9tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJl SW5kaWNlcyhtb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcykK IHsKICAgICBpZiAodmVyYm9zZSkKICAgICAgICAgZGF0YUxvZ0xuKCJQYXJzaW5nIGZ1bmN0aW9u IHN0YXJ0aW5nIGF0OiAiLCAodWludHB0cl90KWZ1bmN0aW9uU3RhcnQsICIgb2YgbGVuZ3RoOiAi LCBmdW5jdGlvbkxlbmd0aCk7CkBAIC0zMDgsOSArMzA4LDkgQEAgYXV0byBGdW5jdGlvblBhcnNl cjxDb250ZXh0Pjo6cGFyc2VFeHByZXNzaW9uKE9wVHlwZSBvcCkgLT4gUGFydGlhbFJlc3VsdAog ICAgIGNhc2UgQ2FsbDogewogICAgICAgICB1aW50MzJfdCBmdW5jdGlvbkluZGV4OwogICAgICAg ICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihmdW5jdGlvbkluZGV4KSwgImNh bid0IHBhcnNlIGNhbGwncyBmdW5jdGlvbiBpbmRleCIpOwotICAgICAgICBXQVNNX1BBUlNFUl9G QUlMX0lGKGZ1bmN0aW9uSW5kZXggPj0gbV9mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSwgImNhbGwg ZnVuY3Rpb24gaW5kZXggIiwgZnVuY3Rpb25JbmRleCwgIiBleGNlZWRzIGZ1bmN0aW9uIGluZGV4 IHNwYWNlICIsIG1fZnVuY3Rpb25JbmRleFNwYWNlLnNpemUpOworICAgICAgICBXQVNNX1BBUlNF Ul9GQUlMX0lGKGZ1bmN0aW9uSW5kZXggPj0gbV9pbmZvLmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUo KSwgImNhbGwgZnVuY3Rpb24gaW5kZXggIiwgZnVuY3Rpb25JbmRleCwgIiBleGNlZWRzIGZ1bmN0 aW9uIGluZGV4IHNwYWNlICIsIG1faW5mby5mdW5jdGlvbkluZGV4U3BhY2VTaXplKCkpOwogCi0g ICAgICAgIFNpZ25hdHVyZUluZGV4IGNhbGxlZVNpZ25hdHVyZUluZGV4ID0gbV9mdW5jdGlvbklu ZGV4U3BhY2UuYnVmZmVyLmdldCgpW2Z1bmN0aW9uSW5kZXhdLnNpZ25hdHVyZUluZGV4OworICAg ICAgICBTaWduYXR1cmVJbmRleCBjYWxsZWVTaWduYXR1cmVJbmRleCA9IG1faW5mby5zaWduYXR1 cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleCk7CiAgICAgICAgIGNv bnN0IFNpZ25hdHVyZSogY2FsbGVlU2lnbmF0dXJlID0gU2lnbmF0dXJlSW5mb3JtYXRpb246Omdl dChtX3ZtLCBjYWxsZWVTaWduYXR1cmVJbmRleCk7CiAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxf SUYoY2FsbGVlU2lnbmF0dXJlLT5hcmd1bWVudENvdW50KCkgPiBtX2V4cHJlc3Npb25TdGFjay5z aXplKCksICJjYWxsIGZ1bmN0aW9uIGluZGV4ICIsIGZ1bmN0aW9uSW5kZXgsICIgaGFzICIsIGNh bGxlZVNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpLCAiIGFyZ3VtZW50cywgYnV0IHRoZSBleHBy ZXNzaW9uIHN0YWNrIGN1cnJlbnRseSBob2xkcyAiLCBtX2V4cHJlc3Npb25TdGFjay5zaXplKCks ICIgdmFsdWVzIik7CiAKQEAgLTMzNyw5ICszMzcsOSBAQCBhdXRvIEZ1bmN0aW9uUGFyc2VyPENv bnRleHQ+OjpwYXJzZUV4cHJlc3Npb24oT3BUeXBlIG9wKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAg ICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKHNpZ25hdHVyZUluZGV4KSwg ImNhbid0IGdldCBjYWxsX2luZGlyZWN0J3Mgc2lnbmF0dXJlIGluZGV4Iik7CiAgICAgICAgIFdB U01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDEocmVzZXJ2ZWQpLCAiY2FuJ3QgZ2V0IGNh bGxfaW5kaXJlY3QncyByZXNlcnZlZCBieXRlIik7CiAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxf SUYocmVzZXJ2ZWQsICJjYWxsX2luZGlyZWN0J3MgJ3Jlc2VydmVkJyB2YXJ1aW50MSBtdXN0IGJl IDB4MCIpOwotICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKG1faW5mby5zaWduYXR1cmVJbmRp Y2VzLnNpemUoKSA8PSBzaWduYXR1cmVJbmRleCwgImNhbGxfaW5kaXJlY3QncyBzaWduYXR1cmUg aW5kZXggIiwgc2lnbmF0dXJlSW5kZXgsICIgZXhjZWVkcyBrbm93biBzaWduYXR1cmVzICIsIG1f aW5mby5zaWduYXR1cmVJbmRpY2VzLnNpemUoKSk7CisgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxf SUYobV9tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXpl KCkgPD0gc2lnbmF0dXJlSW5kZXgsICJjYWxsX2luZGlyZWN0J3Mgc2lnbmF0dXJlIGluZGV4ICIs IHNpZ25hdHVyZUluZGV4LCAiIGV4Y2VlZHMga25vd24gc2lnbmF0dXJlcyAiLCBtX21vZHVsZVNp Z25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzLnNpemUoKSk7CiAKLSAgICAg ICAgU2lnbmF0dXJlSW5kZXggY2FsbGVlU2lnbmF0dXJlSW5kZXggPSBtX2luZm8uc2lnbmF0dXJl SW5kaWNlc1tzaWduYXR1cmVJbmRleF07CisgICAgICAgIFNpZ25hdHVyZUluZGV4IGNhbGxlZVNp Z25hdHVyZUluZGV4ID0gbV9tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJl SW5kaWNlc1tzaWduYXR1cmVJbmRleF07CiAgICAgICAgIGNvbnN0IFNpZ25hdHVyZSogY2FsbGVl U2lnbmF0dXJlID0gU2lnbmF0dXJlSW5mb3JtYXRpb246OmdldChtX3ZtLCBjYWxsZWVTaWduYXR1 cmVJbmRleCk7CiAgICAgICAgIHNpemVfdCBhcmd1bWVudENvdW50ID0gY2FsbGVlU2lnbmF0dXJl LT5hcmd1bWVudENvdW50KCkgKyAxOyAvLyBBZGQgdGhlIGNhbGxlZSdzIGluZGV4LgogICAgICAg ICBXQVNNX1BBUlNFUl9GQUlMX0lGKGFyZ3VtZW50Q291bnQgPiBtX2V4cHJlc3Npb25TdGFjay5z aXplKCksICJjYWxsX2luZGlyZWN0IGV4cGVjdHMgIiwgYXJndW1lbnRDb3VudCwgIiBhcmd1bWVu dHMsIGJ1dCB0aGUgZXhwcmVzc2lvbiBzdGFjayBjdXJyZW50bHkgaG9sZHMgIiwgbV9leHByZXNz aW9uU3RhY2suc2l6ZSgpLCAiIHZhbHVlcyIpOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbU1lbW9yeS5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9X YXNtTWVtb3J5LmNwcAppbmRleCA3MDBlM2FjLi5hYWQ5MWMxIDEwMDY0NAotLS0gYS9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtTWVtb3J5LmNwcApAQCAtMjgsMTUgKzI4LDM5IEBACiAKICNpZiBFTkFC TEUoV0VCQVNTRU1CTFkpCiAKKyNpbmNsdWRlIDx3dGYvSGV4TnVtYmVyLmg+CisjaW5jbHVkZSA8 d3RmL1ByaW50U3RyZWFtLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CisKIG5h bWVzcGFjZSBKU0MgeyBuYW1lc3BhY2UgV2FzbSB7CiAKK25hbWVzcGFjZSB7Citjb25zdCBib29s IHZlcmJvc2UgPSBmYWxzZTsKK30KKwordm9pZCBNZW1vcnk6OmR1bXAoUHJpbnRTdHJlYW0mIG91 dCkgY29uc3QKK3sKKyAgICBTdHJpbmcgbWVtb3J5SGV4OworICAgIFdURjo6YXBwZW5kVW5zaWdu ZWQ2NEFzSGV4KCh1aW50NjRfdCkodWludHB0cl90KW1fbWVtb3J5LCBtZW1vcnlIZXgpOworICAg IG91dC5wcmludCgiTWVtb3J5IGF0IDB4IiwgbWVtb3J5SGV4LCAiLCBzaXplICIsIG1fc2l6ZSwg IkIgY2FwYWNpdHkgIiwgbV9tYXBwZWRDYXBhY2l0eSwgIkIsIGluaXRpYWwgIiwgbV9pbml0aWFs LCAiIG1heGltdW0gIiwgbV9tYXhpbXVtLCAiIG1vZGUgIiwgbWFrZVN0cmluZyhtX21vZGUpKTsK K30KKworY29uc3QgY2hhciogTWVtb3J5OjptYWtlU3RyaW5nKE1vZGUgbW9kZSkgY29uc3QKK3sK KyAgICBzd2l0Y2ggKG1vZGUpIHsKKyAgICBjYXNlIE1vZGU6OkJvdW5kc0NoZWNraW5nOiByZXR1 cm4gIkJvdW5kc0NoZWNraW5nIjsKKyAgICB9CisgICAgUkVMRUFTRV9BU1NFUlRfTk9UX1JFQUNI RUQoKTsKKyAgICByZXR1cm4gIiI7Cit9CisKIHN0YXRpY19hc3NlcnQoc2l6ZW9mKHVpbnQ2NF90 KSA9PSBzaXplb2Yoc2l6ZV90KSwgIldlIHJlbHkgb24gYWxsb3dpbmcgdGhlIG1heGltdW0gc2l6 ZSBvZiBNZW1vcnkgd2UgbWFwIHRvIGJlIDJeMzIgd2hpY2ggaXMgbGFyZ2VyIHRoYW4gZml0cyBp biBhIDMyLWJpdCBpbnRlZ2VyIHRoYXQgd2UnZCBwYXNzIHRvIG1wcm90ZWN0IGlmIHRoaXMgZGlk bid0IGhvbGQuIik7CiAKIE1lbW9yeTo6TWVtb3J5KFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291 bnQgbWF4aW11bSwgYm9vbCYgZmFpbGVkKQotICAgIDogbV9tb2RlKE1vZGU6OkJvdW5kc0NoZWNr aW5nKQorICAgIDogbV9zaXplKGluaXRpYWwuYnl0ZXMoKSkKICAgICAsIG1faW5pdGlhbChpbml0 aWFsKQogICAgICwgbV9tYXhpbXVtKG1heGltdW0pCi0gICAgLCBtX3NpemUoaW5pdGlhbC5ieXRl cygpKQorICAgICwgbV9tb2RlKE1vZGU6OkJvdW5kc0NoZWNraW5nKQogICAgIC8vIEZJWE1FOiBJ ZiB3ZSBhZGQgc2lnbmFsIGJhc2VkIGJvdW5kcyBjaGVja2luZyB0aGVuIHdlIG5lZWQgZXh0cmEg c3BhY2UgZm9yIG92ZXJmbG93IG9uIGxvYWQuCiAgICAgLy8gc2VlOiBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYyNjkzCiB7CkBAIC00Niw5ICs3MCwxMSBAQCBNZW1v cnk6Ok1lbW9yeShQYWdlQ291bnQgaW5pdGlhbCwgUGFnZUNvdW50IG1heGltdW0sIGJvb2wmIGZh aWxlZCkKICAgICBpZiAoIW1fbWFwcGVkQ2FwYWNpdHkpIHsKICAgICAgICAgLy8gVGhpcyBtZWFu cyB3ZSBzcGVjaWZpZWQgYSB6ZXJvIGFzIG1heGltdW0gKHdoaWNoIG1lYW5zIHdlIGFsc28gaGF2 ZSB6ZXJvIGFzIGluaXRpYWwgc2l6ZSkuCiAgICAgICAgIFJFTEVBU0VfQVNTRVJUKG1fc2l6ZSA9 PSAwKTsKLSAgICAgICAgbV9tYXBwZWRDYXBhY2l0eSA9IDA7CiAgICAgICAgIG1fbWVtb3J5ID0g bnVsbHB0cjsKKyAgICAgICAgbV9tYXBwZWRDYXBhY2l0eSA9IDA7CiAgICAgICAgIGZhaWxlZCA9 IGZhbHNlOworICAgICAgICBpZiAodmVyYm9zZSkKKyAgICAgICAgICAgIGRhdGFMb2dMbigiTWVt b3J5OjpNZW1vcnkgYWxsb2NhdGluZyBub3RoaW5nICIsICp0aGlzKTsKICAgICAgICAgcmV0dXJu OwogICAgIH0KIApAQCAtNTYsMTUgKzgyLDIxIEBAIE1lbW9yeTo6TWVtb3J5KFBhZ2VDb3VudCBp bml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSwgYm9vbCYgZmFpbGVkKQogICAgIHZvaWQqIHJlc3Vs dCA9IE9wdGlvbnM6OnNpbXVsYXRlV2ViQXNzZW1ibHlMb3dNZW1vcnkoKSA/IE1BUF9GQUlMRUQg OiBtbWFwKG51bGxwdHIsIG1fbWFwcGVkQ2FwYWNpdHksIFBST1RfTk9ORSwgTUFQX1BSSVZBVEUg fCBNQVBfQU5PTiwgLTEsIDApOwogICAgIGlmIChyZXN1bHQgPT0gTUFQX0ZBSUxFRCkgewogICAg ICAgICAvLyBUcnkgYWdhaW4gd2l0aCBhIGRpZmZlcmVudCBudW1iZXIuCisgICAgICAgIGlmICh2 ZXJib3NlKQorICAgICAgICAgICAgZGF0YUxvZ0xuKCJNZW1vcnk6Ok1lbW9yeSBtbWFwIGZhaWxl ZCBvbmNlIGZvciBjYXBhY2l0eSwgdHJ5aW5nIGFnYWluIiwgKnRoaXMpOwogICAgICAgICBtX21h cHBlZENhcGFjaXR5ID0gbV9zaXplOwogICAgICAgICBpZiAoIW1fbWFwcGVkQ2FwYWNpdHkpIHsK ICAgICAgICAgICAgIG1fbWVtb3J5ID0gbnVsbHB0cjsKICAgICAgICAgICAgIGZhaWxlZCA9IGZh bHNlOworICAgICAgICAgICAgaWYgKHZlcmJvc2UpCisgICAgICAgICAgICAgICAgZGF0YUxvZ0xu KCJNZW1vcnk6Ok1lbW9yeSBtbWFwIG5vdCB0cnlpbmcgYWdhaW4gYmVjYXVzZSBzaXplIGlzIHpl cm8gIiwgKnRoaXMpOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CiAKICAgICAgICAg cmVzdWx0ID0gbW1hcChudWxscHRyLCBtX21hcHBlZENhcGFjaXR5LCBQUk9UX05PTkUsIE1BUF9Q UklWQVRFIHwgTUFQX0FOT04sIC0xLCAwKTsKICAgICAgICAgaWYgKHJlc3VsdCA9PSBNQVBfRkFJ TEVEKSB7CisgICAgICAgICAgICBpZiAodmVyYm9zZSkKKyAgICAgICAgICAgICAgICBkYXRhTG9n TG4oIk1lbW9yeTo6TWVtb3J5IG1tYXAgZmFpbGVkIHR3aWNlICIsICp0aGlzKTsKICAgICAgICAg ICAgIGZhaWxlZCA9IHRydWU7CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0KQEAgLTc4 LDEyICsxMTAsMjcgQEAgTWVtb3J5OjpNZW1vcnkoUGFnZUNvdW50IGluaXRpYWwsIFBhZ2VDb3Vu dCBtYXhpbXVtLCBib29sJiBmYWlsZWQpCiAKICAgICBtX21lbW9yeSA9IHJlc3VsdDsKICAgICBm YWlsZWQgPSBmYWxzZTsKKyAgICBpZiAodmVyYm9zZSkKKyAgICAgICAgZGF0YUxvZ0xuKCJNZW1v cnk6Ok1lbW9yeSBtbWFwIHN1Y2NlZWRlZCAiLCAqdGhpcyk7Cit9CisKK01lbW9yeTo6fk1lbW9y eSgpCit7CisgICAgaWYgKHZlcmJvc2UpCisgICAgICAgIGRhdGFMb2dMbigiTWVtb3J5Ojp+TWVt b3J5ICIsICp0aGlzKTsKKyAgICBpZiAobV9tZW1vcnkpIHsKKyAgICAgICAgaWYgKG11bm1hcCht X21lbW9yeSwgbV9tYXBwZWRDYXBhY2l0eSkpCisgICAgICAgICAgICBDUkFTSCgpOworICAgIH0K IH0KIAogYm9vbCBNZW1vcnk6Omdyb3coUGFnZUNvdW50IG5ld1NpemUpCiB7CiAgICAgUkVMRUFT RV9BU1NFUlQobmV3U2l6ZSA+IFBhZ2VDb3VudDo6ZnJvbUJ5dGVzKG1fc2l6ZSkpOwogCisgICAg aWYgKHZlcmJvc2UpCisgICAgICAgIGRhdGFMb2dMbigiTWVtb3J5Ojpncm93IHRvICIsIG5ld1Np emUsICIgZnJvbSAiLCAqdGhpcyk7CisKICAgICBpZiAobWF4aW11bSgpICYmIG5ld1NpemUgPiBt YXhpbXVtKCkpCiAgICAgICAgIHJldHVybiBmYWxzZTsKIApAQCAtOTMsNiArMTQwLDggQEAgYm9v bCBNZW1vcnk6Omdyb3coUGFnZUNvdW50IG5ld1NpemUpCiAgICAgICAgIGJvb2wgc3VjY2VzcyA9 ICFtcHJvdGVjdChzdGF0aWNfY2FzdDx1aW50OF90Kj4obV9tZW1vcnkpICsgbV9zaXplLCBzdGF0 aWNfY2FzdDxzaXplX3Q+KGRlc2lyZWRTaXplIC0gbV9zaXplKSwgUFJPVF9SRUFEIHwgUFJPVF9X UklURSk7CiAgICAgICAgIFJFTEVBU0VfQVNTRVJUKHN1Y2Nlc3MpOwogICAgICAgICBtX3NpemUg PSBkZXNpcmVkU2l6ZTsKKyAgICAgICAgaWYgKHZlcmJvc2UpCisgICAgICAgICAgICBkYXRhTG9n TG4oIk1lbW9yeTo6Z3JvdyBpbi1wbGFjZSAiLCAqdGhpcyk7CiAgICAgICAgIHJldHVybiB0cnVl OwogICAgIH0KIApAQCAtMTEwLDYgKzE1OSw4IEBAIGJvb2wgTWVtb3J5Ojpncm93KFBhZ2VDb3Vu dCBuZXdTaXplKQogICAgIG1fbWFwcGVkQ2FwYWNpdHkgPSBkZXNpcmVkU2l6ZTsKICAgICBtX3Np emUgPSBkZXNpcmVkU2l6ZTsKIAorICAgIGlmICh2ZXJib3NlKQorICAgICAgICBkYXRhTG9nTG4o Ik1lbW9yeTo6Z3JvdyAiLCAqdGhpcyk7CiAgICAgcmV0dXJuIHRydWU7CiB9CiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuaCBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuaAppbmRleCA0ZTVlZTM2Li45MTQ5MzA1IDEwMDY0 NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmgKKysrIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5oCkBAIC0zMCw3ICszMCw5IEBACiAj aW5jbHVkZSAiV2FzbUNhbGxpbmdDb252ZW50aW9uLmgiCiAjaW5jbHVkZSAiV2FzbVBhZ2VDb3Vu dC5oIgogCi0jaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorbmFtZXNwYWNlIFdURiB7CitjbGFzcyBQ cmludFN0cmVhbTsKK30KIAogbmFtZXNwYWNlIEpTQyB7IG5hbWVzcGFjZSBXYXNtIHsKIApAQCAt MzgsNDEgKzQwLDUwIEBAIGNsYXNzIE1lbW9yeSB7CiAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUo TWVtb3J5KTsKICAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKIHB1YmxpYzoKKyAgICBNZW1v cnkoTWVtb3J5JiYgb3RoZXIpCisgICAgICAgIDogbV9tZW1vcnkob3RoZXIubV9tZW1vcnkpCisg ICAgICAgICwgbV9zaXplKG90aGVyLm1fc2l6ZSkKKyAgICAgICAgLCBtX2luaXRpYWwob3RoZXIu bV9pbml0aWFsKQorICAgICAgICAsIG1fbWF4aW11bShvdGhlci5tX21heGltdW0pCisgICAgICAg ICwgbV9tYXBwZWRDYXBhY2l0eShvdGhlci5tX21hcHBlZENhcGFjaXR5KQorICAgICAgICAsIG1f bW9kZShvdGhlci5tX21vZGUpCisgICAgeworICAgICAgICAvLyBNb3ZpbmcgdHJhbnNmZXJzIG93 bmVyc2hpcCBvZiB0aGUgYWxsb2NhdGVkIG1lbW9yeS4KKyAgICAgICAgb3RoZXIubV9tZW1vcnkg PSBudWxscHRyOworICAgIH0KKworICAgIHZvaWQgZHVtcChXVEY6OlByaW50U3RyZWFtJikgY29u c3Q7CiAKICAgICAvLyBGSVhNRTogV2Ugc2hvdWxkIHN1cHBvcnQgb3RoZXIgbW9kZXMuIHNlZTog aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MjY5MwogICAgIGVudW0g Y2xhc3MgTW9kZSB7CiAgICAgICAgIEJvdW5kc0NoZWNraW5nCiAgICAgfTsKKyAgICBjb25zdCBj aGFyKiBtYWtlU3RyaW5nKE1vZGUpIGNvbnN0OwogCiAgICAgSlNfRVhQT1JUX1BSSVZBVEUgTWVt b3J5KFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSwgYm9vbCYgZmFpbGVkKTsK LQotICAgIH5NZW1vcnkoKQotICAgIHsKLSAgICAgICAgaWYgKG1fbWVtb3J5KQotICAgICAgICAg ICAgbXVubWFwKG1fbWVtb3J5LCBtX21hcHBlZENhcGFjaXR5KTsKLSAgICB9CisgICAgSlNfRVhQ T1JUX1BSSVZBVEUgfk1lbW9yeSgpOwogCiAgICAgdm9pZCogbWVtb3J5KCkgY29uc3QgeyByZXR1 cm4gbV9tZW1vcnk7IH0KICAgICB1aW50NjRfdCBzaXplKCkgY29uc3QgeyByZXR1cm4gbV9zaXpl OyB9CiAgICAgUGFnZUNvdW50IHNpemVJblBhZ2VzKCkgY29uc3QgeyByZXR1cm4gUGFnZUNvdW50 Ojpmcm9tQnl0ZXMobV9zaXplKTsgfQogCi0gICAgTW9kZSBtb2RlKCkgY29uc3QgeyByZXR1cm4g bV9tb2RlOyB9Ci0KICAgICBQYWdlQ291bnQgaW5pdGlhbCgpIGNvbnN0IHsgcmV0dXJuIG1faW5p dGlhbDsgfQogICAgIFBhZ2VDb3VudCBtYXhpbXVtKCkgY29uc3QgeyByZXR1cm4gbV9tYXhpbXVt OyB9CiAKKyAgICBNb2RlIG1vZGUoKSBjb25zdCB7IHJldHVybiBtX21vZGU7IH0KKwogICAgIGJv b2wgZ3JvdyhQYWdlQ291bnQpOwogCi0gICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZlNpemUo KSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoTWVtb3J5LCBtX3NpemUpOyB9CiAgICAgc3RhdGlj IHB0cmRpZmZfdCBvZmZzZXRPZk1lbW9yeSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihNZW1v cnksIG1fbWVtb3J5KTsgfQorICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZTaXplKCkgeyBy ZXR1cm4gT0JKRUNUX09GRlNFVE9GKE1lbW9yeSwgbV9zaXplKTsgfQogICAgIAogcHJpdmF0ZToK ICAgICB2b2lkKiBtX21lbW9yeSB7IG51bGxwdHIgfTsKLSAgICBNb2RlIG1fbW9kZTsKKyAgICB1 aW50NjRfdCBtX3NpemUgeyAwIH07CiAgICAgUGFnZUNvdW50IG1faW5pdGlhbDsKICAgICBQYWdl Q291bnQgbV9tYXhpbXVtOwotICAgIHVpbnQ2NF90IG1fc2l6ZSB7IDAgfTsKICAgICB1aW50NjRf dCBtX21hcHBlZENhcGFjaXR5IHsgMCB9OworICAgIE1vZGUgbV9tb2RlIHsgTW9kZTo6Qm91bmRz Q2hlY2tpbmcgfTsKIH07CiAKIH0gfSAvLyBuYW1lc3BhY2UgSlNDOjpXYXNtCmRpZmYgLS1naXQg YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5SW5mb3JtYXRpb24uY3BwIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmNwcAppbmRl eCAyZTFkMzBhLi5kNWIzMTM1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtTWVtb3J5SW5mb3JtYXRpb24uY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21NZW1vcnlJbmZvcm1hdGlvbi5jcHAKQEAgLTI2LDEwICsyNiwxMCBAQAogI2luY2x1 ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIldhc21NZW1vcnlJbmZvcm1hdGlvbi5oIgogCi0jaW5j bHVkZSAiV2FzbUNhbGxpbmdDb252ZW50aW9uLmgiCi0KICNpZiBFTkFCTEUoV0VCQVNTRU1CTFkp CiAKKyNpbmNsdWRlICJXYXNtQ2FsbGluZ0NvbnZlbnRpb24uaCIKKwogbmFtZXNwYWNlIEpTQyB7 IG5hbWVzcGFjZSBXYXNtIHsKIAogTWVtb3J5SW5mb3JtYXRpb246Ok1lbW9yeUluZm9ybWF0aW9u KFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSwgIGNvbnN0IFZlY3Rvcjx1bnNp Z25lZD4mIHBpbm5lZFNpemVSZWdpc3RlcnMsIGJvb2wgaXNJbXBvcnQpCmRpZmYgLS1naXQgYS9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmNwcCBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCmluZGV4IDYyNjFlN2YuLjhk ZjRhODYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQ YXJzZXIuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJz ZXIuY3BwCkBAIC0xMDcsNyArMTA3LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlVHlwZSgp IC0+IFBhcnRpYWxSZXN1bHQKIAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUlu dDMyKGNvdW50KSwgImNhbid0IGdldCBUeXBlIHNlY3Rpb24ncyBjb3VudCIpOwogICAgIFdBU01f UEFSU0VSX0ZBSUxfSUYoY291bnQgPT0gc3RkOjpudW1lcmljX2xpbWl0czx1aW50MzJfdD46Om1h eCgpLCAiVHlwZSBzZWN0aW9uJ3MgY291bnQgaXMgdG9vIGJpZyAiLCBjb3VudCk7Ci0gICAgV0FT TV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnRyeVJl c2VydmVDYXBhY2l0eShjb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciBU eXBlIHNlY3Rpb24ncyAiLCBjb3VudCwgIiBlbnRyaWVzIik7CisgICAgV0FTTV9QQVJTRVJfRkFJ TF9JRighbV9yZXN1bHQubW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUlu ZGljZXMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBt ZW1vcnkgZm9yIFR5cGUgc2VjdGlvbidzICIsIGNvdW50LCAiIGVudHJpZXMiKTsKIAogICAgIGZv ciAodWludDMyX3QgaSA9IDA7IGkgPCBjb3VudDsgKytpKSB7CiAgICAgICAgIGludDhfdCB0eXBl OwpAQCAtMTM5LDcgKzEzOSw3IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZVR5cGUoKSAtPiBQ YXJ0aWFsUmVzdWx0CiAgICAgICAgIHNpZ25hdHVyZS0+cmV0dXJuVHlwZSgpID0gcmV0dXJuVHlw ZTsKIAogICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IFNpZ25hdHVyZUlu Zm9ybWF0aW9uOjphZG9wdChtX3ZtLCBzaWduYXR1cmUucmVsZWFzZSgpKTsKLSAgICAgICAgbV9y ZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJ bmRleCk7CisgICAgICAgIG1fcmVzdWx0Lm1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRT aWduYXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7CiAgICAgfQog ICAgIHJldHVybiB7IH07CiB9CkBAIC0xNTIsNyArMTUyLDYgQEAgYXV0byBNb2R1bGVQYXJzZXI6 OnBhcnNlSW1wb3J0KCkgLT4gUGFydGlhbFJlc3VsdAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYo IW1fcmVzdWx0Lm1vZHVsZS0+Z2xvYmFscy50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291bnQp LCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIgZ2xv YmFscyIpOyAvLyBGSVhNRSB0aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBGSVhN RXMgYmVsb3cuCiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlLT5pbXBv cnRzLnRyeVJlc2VydmVDYXBhY2l0eShpbXBvcnRDb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91 Z2ggbWVtb3J5IGZvciAiLCBpbXBvcnRDb3VudCwgIiBpbXBvcnRzIik7IC8vIEZJWE1FIHRoaXMg b3Zlci1hbGxvY2F0ZXMgd2hlbiB3ZSBmaXggdGhlIEZJWE1FcyBiZWxvdy4KICAgICBXQVNNX1BB UlNFUl9GQUlMX0lGKCFtX3Jlc3VsdC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5k aWNlcy50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5v dWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIgaW1wb3J0IGZ1bmN0aW9uIHNpZ25hdHVy ZXMiKTsgLy8gRklYTUUgdGhpcyBvdmVyLWFsbG9jYXRlcyB3aGVuIHdlIGZpeCB0aGUgRklYTUVz IGJlbG93LgotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhT cGFjZS50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5v dWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIgZnVuY3Rpb25zIGluIHRoZSBpbmRleCBz cGFjZSIpOyAvLyBGSVhNRSB0aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBGSVhN RXMgYmVsb3cuIFdlJ2xsIGFsbG9jYXRlIHNvbWUgbW9yZSBoZXJlIHdoZW4gd2Uga25vdyBob3cg bWFueSBmdW5jdGlvbnMgdG8gZXhwZWN0LgogCiAgICAgZm9yICh1aW50MzJfdCBpbXBvcnROdW1i ZXIgPSAwOyBpbXBvcnROdW1iZXIgPCBpbXBvcnRDb3VudDsgKytpbXBvcnROdW1iZXIpIHsKICAg ICAgICAgSW1wb3J0IGltcDsKQEAgLTE3NCwxMSArMTczLDEwIEBAIGF1dG8gTW9kdWxlUGFyc2Vy OjpwYXJzZUltcG9ydCgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICAgICAgY2FzZSBFeHRlcm5hbEtp bmQ6OkZ1bmN0aW9uOiB7CiAgICAgICAgICAgICB1aW50MzJfdCBmdW5jdGlvblNpZ25hdHVyZUlu ZGV4OwogICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoZnVu Y3Rpb25TaWduYXR1cmVJbmRleCksICJjYW4ndCBnZXQgIiwgaW1wb3J0TnVtYmVyLCAidGggSW1w b3J0J3MgZnVuY3Rpb24gc2lnbmF0dXJlIGluIG1vZHVsZSAnIiwgbW9kdWxlU3RyaW5nLCAiJyBm aWVsZCAnIiwgZmllbGRTdHJpbmcsICInIik7Ci0gICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlM X0lGKGZ1bmN0aW9uU2lnbmF0dXJlSW5kZXggPj0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJ bmRpY2VzLnNpemUoKSwgImludmFsaWQgZnVuY3Rpb24gc2lnbmF0dXJlIGZvciAiLCBpbXBvcnRO dW1iZXIsICJ0aCBJbXBvcnQsICIsIGZ1bmN0aW9uU2lnbmF0dXJlSW5kZXgsICIgaXMgb3V0IG9m IHJhbmdlIG9mICIsIG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICIg aW4gbW9kdWxlICciLCBtb2R1bGVTdHJpbmcsICInIGZpZWxkICciLCBmaWVsZFN0cmluZywgIici KTsKKyAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVuY3Rpb25TaWduYXR1cmVJbmRl eCA+PSBtX3Jlc3VsdC5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5k aWNlcy5zaXplKCksICJpbnZhbGlkIGZ1bmN0aW9uIHNpZ25hdHVyZSBmb3IgIiwgaW1wb3J0TnVt YmVyLCAidGggSW1wb3J0LCAiLCBmdW5jdGlvblNpZ25hdHVyZUluZGV4LCAiIGlzIG91dCBvZiBy YW5nZSBvZiAiLCBtX3Jlc3VsdC5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0 dXJlSW5kaWNlcy5zaXplKCksICIgaW4gbW9kdWxlICciLCBtb2R1bGVTdHJpbmcsICInIGZpZWxk ICciLCBmaWVsZFN0cmluZywgIiciKTsKICAgICAgICAgICAgIGltcC5raW5kSW5kZXggPSBtX3Jl c3VsdC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCk7Ci0gICAg ICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZS0+ c2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvblNpZ25hdHVyZUluZGV4XTsKKyAgICAgICAgICAgIFNp Z25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlU2lnbmF0dXJlSW5k aWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXNbZnVuY3Rpb25TaWduYXR1cmVJbmRleF07CiAg ICAgICAgICAgICBtX3Jlc3VsdC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNl cy51bmNoZWNrZWRBcHBlbmQoc2lnbmF0dXJlSW5kZXgpOwotICAgICAgICAgICAgbV9yZXN1bHQu ZnVuY3Rpb25JbmRleFNwYWNlLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7CiAgICAg ICAgICAgICBicmVhazsKICAgICAgICAgfQogICAgICAgICBjYXNlIEV4dGVybmFsS2luZDo6VGFi bGU6IHsKQEAgLTIyMCwyMCArMjE4LDE4IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZUZ1bmN0 aW9uKCkgLT4gUGFydGlhbFJlc3VsdAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoY291bnQgPT0g c3RkOjpudW1lcmljX2xpbWl0czx1aW50MzJfdD46Om1heCgpLCAiRnVuY3Rpb24gc2VjdGlvbidz IGNvdW50IGlzIHRvbyBiaWcgIiwgY291bnQpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1f cmVzdWx0Lm1vZHVsZS0+aW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXMudHJ5UmVzZXJ2 ZUNhcGFjaXR5KGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGNv dW50LCAiIEZ1bmN0aW9uIHNpZ25hdHVyZXMiKTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFt X3Jlc3VsdC5mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50 KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGNvdW50LCAiRnVuY3Rpb24g bG9jYXRpb25zIik7Ci0gICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQuZnVuY3Rpb25J bmRleFNwYWNlLnRyeVJlc2VydmVDYXBhY2l0eShtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uu c2l6ZSgpICsgY291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgY291 bnQsICIgbW9yZSBmdW5jdGlvbnMgaW4gdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlIik7CiAKICAg ICBmb3IgKHVpbnQzMl90IGkgPSAwOyBpIDwgY291bnQ7ICsraSkgewogICAgICAgICB1aW50MzJf dCB0eXBlTnVtYmVyOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQz Mih0eXBlTnVtYmVyKSwgImNhbid0IGdldCAiLCBpLCAidGggRnVuY3Rpb24ncyB0eXBlIG51bWJl ciIpOwotICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHR5cGVOdW1iZXIgPj0gbV9yZXN1bHQu bW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnNpemUoKSwgaSwgInRoIEZ1bmN0aW9uIHR5cGUgbnVt YmVyIGlzIGludmFsaWQgIiwgdHlwZU51bWJlcik7CisgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxf SUYodHlwZU51bWJlciA+PSBtX3Jlc3VsdC5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVk U2lnbmF0dXJlSW5kaWNlcy5zaXplKCksIGksICJ0aCBGdW5jdGlvbiB0eXBlIG51bWJlciBpcyBp bnZhbGlkICIsIHR5cGVOdW1iZXIpOwogCi0gICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVy ZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzW3R5cGVOdW1iZXJdOwor ICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZVNp Z25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzW3R5cGVOdW1iZXJdOwogICAg ICAgICAvLyBUaGUgQ29kZSBzZWN0aW9uIGZpeGVzIHVwIHN0YXJ0IGFuZCBlbmQuCiAgICAgICAg IHNpemVfdCBzdGFydCA9IDA7CiAgICAgICAgIHNpemVfdCBlbmQgPSAwOwogICAgICAgICBtX3Jl c3VsdC5tb2R1bGUtPmludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFw cGVuZChzaWduYXR1cmVJbmRleCk7CiAgICAgICAgIG1fcmVzdWx0LmZ1bmN0aW9uTG9jYXRpb25J bkJpbmFyeS51bmNoZWNrZWRBcHBlbmQoeyBzdGFydCwgZW5kIH0pOwotICAgICAgICBtX3Jlc3Vs dC5mdW5jdGlvbkluZGV4U3BhY2UudW5jaGVja2VkQXBwZW5kKHNpZ25hdHVyZUluZGV4KTsKICAg ICB9CiAKICAgICByZXR1cm4geyB9OwpAQCAtMzg3LDcgKzM4Myw3IEBAIGF1dG8gTW9kdWxlUGFy c2VyOjpwYXJzZUV4cG9ydCgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICAgICAgV0FTTV9QQVJTRVJf RkFJTF9JRighcGFyc2VWYXJVSW50MzIoZXhwLmtpbmRJbmRleCksICJjYW4ndCBnZXQgIiwgZXhw b3J0TnVtYmVyLCAidGggRXhwb3J0J3Mga2luZCBpbmRleCwgbmFtZWQgJyIsIGZpZWxkU3RyaW5n LCAiJyIpOwogICAgICAgICBzd2l0Y2ggKGV4cC5raW5kKSB7CiAgICAgICAgIGNhc2UgRXh0ZXJu YWxLaW5kOjpGdW5jdGlvbjogewotICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihleHAu a2luZEluZGV4ID49IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCksIGV4cG9ydE51 bWJlciwgInRoIEV4cG9ydCBoYXMgaW52YWxpZCBmdW5jdGlvbiBudW1iZXIgIiwgZXhwLmtpbmRJ bmRleCwgIiBpdCBleGNlZWRzIHRoZSBmdW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX3Jlc3VsdC5m dW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpLCAiLCBuYW1lZCAnIiwgZmllbGRTdHJpbmcsICInIik7 CisgICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGV4cC5raW5kSW5kZXggPj0gbV9yZXN1 bHQubW9kdWxlLT5mdW5jdGlvbkluZGV4U3BhY2VTaXplKCksIGV4cG9ydE51bWJlciwgInRoIEV4 cG9ydCBoYXMgaW52YWxpZCBmdW5jdGlvbiBudW1iZXIgIiwgZXhwLmtpbmRJbmRleCwgIiBpdCBl eGNlZWRzIHRoZSBmdW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0 aW9uSW5kZXhTcGFjZVNpemUoKSwgIiwgbmFtZWQgJyIsIGZpZWxkU3RyaW5nLCAiJyIpOwogICAg ICAgICAgICAgYnJlYWs7CiAgICAgICAgIH0KICAgICAgICAgY2FzZSBFeHRlcm5hbEtpbmQ6OlRh YmxlOiB7CkBAIC00MTcsOCArNDEzLDggQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlU3RhcnQo KSAtPiBQYXJ0aWFsUmVzdWx0CiB7CiAgICAgdWludDMyX3Qgc3RhcnRGdW5jdGlvbkluZGV4Owog ICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKHN0YXJ0RnVuY3Rpb25JbmRl eCksICJjYW4ndCBnZXQgU3RhcnQgaW5kZXgiKTsKLSAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHN0 YXJ0RnVuY3Rpb25JbmRleCA+PSBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpLCAi U3RhcnQgaW5kZXggIiwgc3RhcnRGdW5jdGlvbkluZGV4LCAiIGV4Y2VlZHMgZnVuY3Rpb24gaW5k ZXggc3BhY2UgIiwgbV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnNpemUoKSk7Ci0gICAgU2ln bmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Vb c3RhcnRGdW5jdGlvbkluZGV4XS5zaWduYXR1cmVJbmRleDsKKyAgICBXQVNNX1BBUlNFUl9GQUlM X0lGKHN0YXJ0RnVuY3Rpb25JbmRleCA+PSBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhT cGFjZVNpemUoKSwgIlN0YXJ0IGluZGV4ICIsIHN0YXJ0RnVuY3Rpb25JbmRleCwgIiBleGNlZWRz IGZ1bmN0aW9uIGluZGV4IHNwYWNlICIsIG1fcmVzdWx0Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNw YWNlU2l6ZSgpKTsKKyAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0 Lm1vZHVsZS0+c2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRleFNwYWNlKHN0YXJ0RnVuY3Rp b25JbmRleCk7CiAgICAgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUgPSBTaWduYXR1cmVJbmZv cm1hdGlvbjo6Z2V0KG1fdm0sIHNpZ25hdHVyZUluZGV4KTsKICAgICBXQVNNX1BBUlNFUl9GQUlM X0lGKHNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpLCAiU3RhcnQgZnVuY3Rpb24gY2FuJ3QgaGF2 ZSBhcmd1bWVudHMiKTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHNpZ25hdHVyZS0+cmV0dXJu VHlwZSgpICE9IFZvaWQsICJTdGFydCBmdW5jdGlvbiBjYW4ndCByZXR1cm4gYSB2YWx1ZSIpOwpA QCAtNDY5LDcgKzQ2NSw3IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZUVsZW1lbnQoKSAtPiBQ YXJ0aWFsUmVzdWx0CiAgICAgICAgIGZvciAodW5zaWduZWQgaW5kZXggPSAwOyBpbmRleCA8IGlu ZGV4Q291bnQ7ICsraW5kZXgpIHsKICAgICAgICAgICAgIHVpbnQzMl90IGZ1bmN0aW9uSW5kZXg7 CiAgICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihmdW5jdGlv bkluZGV4KSwgImNhbid0IGdldCBFbGVtZW50IHNlY3Rpb24ncyAiLCBlbGVtZW50TnVtLCAidGgg ZWxlbWVudCdzICIsIGluZGV4LCAidGggaW5kZXgiKTsKLSAgICAgICAgICAgIFdBU01fUEFSU0VS X0ZBSUxfSUYoZnVuY3Rpb25JbmRleCA+PSBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6 ZSgpLCAiRWxlbWVudCBzZWN0aW9uJ3MgIiwgZWxlbWVudE51bSwgInRoIGVsZW1lbnQncyAiLCBp bmRleCwgInRoIGluZGV4IGlzICIsIGZ1bmN0aW9uSW5kZXgsICIgd2hpY2ggZXhjZWVkcyB0aGUg ZnVuY3Rpb24gaW5kZXggc3BhY2Ugc2l6ZSBvZiAiLCBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3Bh Y2Uuc2l6ZSgpKTsKKyAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVuY3Rpb25JbmRl eCA+PSBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSwgIkVsZW1lbnQg c2VjdGlvbidzICIsIGVsZW1lbnROdW0sICJ0aCBlbGVtZW50J3MgIiwgaW5kZXgsICJ0aCBpbmRl eCBpcyAiLCBmdW5jdGlvbkluZGV4LCAiIHdoaWNoIGV4Y2VlZHMgdGhlIGZ1bmN0aW9uIGluZGV4 IHNwYWNlIHNpemUgb2YgIiwgbV9yZXN1bHQubW9kdWxlLT5mdW5jdGlvbkluZGV4U3BhY2VTaXpl KCkpOwogCiAgICAgICAgICAgICBlbGVtZW50LmZ1bmN0aW9uSW5kaWNlcy51bmNoZWNrZWRBcHBl bmQoZnVuY3Rpb25JbmRleCk7CiAgICAgICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21Nb2R1bGVQYXJzZXIuaAppbmRleCBlM2I3NWE3Li43ZTAyNmM5IDEwMDY0NAotLS0g YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmgKKysrIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5oCkBAIC0zNiw4ICszNiw4 IEBAIG5hbWVzcGFjZSBKU0MgeyBuYW1lc3BhY2UgV2FzbSB7CiAKIHN0cnVjdCBNb2R1bGVQYXJz ZXJSZXN1bHQgewogICAgIHN0ZDo6dW5pcXVlX3B0cjxNb2R1bGVJbmZvcm1hdGlvbj4gbW9kdWxl OwotICAgIEZ1bmN0aW9uSW5kZXhTcGFjZSBmdW5jdGlvbkluZGV4U3BhY2U7CiAgICAgVmVjdG9y PEZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeT4gZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5OworICAg IFZlY3RvcjxTaWduYXR1cmVJbmRleD4gbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNp Z25hdHVyZUluZGljZXM7CiB9OwogCiBjbGFzcyBNb2R1bGVQYXJzZXIgOiBwdWJsaWMgUGFyc2Vy PE1vZHVsZVBhcnNlclJlc3VsdD4gewpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbVBhZ2VDb3VudC5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt UGFnZUNvdW50LmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40Yjg3NzA1 Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBhZ2VD b3VudC5jcHAKQEAgLTAsMCArMSw0NSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNiBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNT IE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRI RQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBG T1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQg U0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJ UkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENP TlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQ Uk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwg REFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBD QVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05U UkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBU SElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0gg REFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJXYXNtUGFnZUNv dW50LmgiCisKKyNpZiBFTkFCTEUoV0VCQVNTRU1CTFkpCisKKyNpbmNsdWRlIDx3dGYvUHJpbnRT dHJlYW0uaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KKworbmFtZXNwYWNlIEpT QyB7IG5hbWVzcGFjZSBXYXNtIHsKKwordm9pZCBQYWdlQ291bnQ6OmR1bXAoUHJpbnRTdHJlYW0m IG91dCkgY29uc3QKK3sKKyAgICBvdXQucHJpbnQoU3RyaW5nOjpudW1iZXIoYnl0ZXMoKSksICJC Iik7Cit9CisKK30gLy8gbmFtZXNwYWNlIEpTQworCit9IC8vIG5hbWVzcGFjZSBXYXNtCisKKyNl bmRpZiAvLyBFTkFCTEUoV0VCQVNTRU1CTFkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtUGFnZUNvdW50LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9X YXNtUGFnZUNvdW50LmgKaW5kZXggYTE1ZDUwNS4uNjdkYmI1NSAxMDA2NDQKLS0tIGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBhZ2VDb3VudC5oCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21QYWdlQ291bnQuaApAQCAtMjcsNiArMjcsMTAgQEAKIAogI2lmIEVO QUJMRShXRUJBU1NFTUJMWSkKIAorbmFtZXNwYWNlIFdURiB7CitjbGFzcyBQcmludFN0cmVhbTsK K30KKwogbmFtZXNwYWNlIEpTQyB7IG5hbWVzcGFjZSBXYXNtIHsKIAogY2xhc3MgUGFnZUNvdW50 IHsKQEAgLTQyLDYgKzQ2LDggQEAgcHVibGljOgogICAgICAgICA6IG1fcGFnZUNvdW50KHBhZ2VD b3VudCkKICAgICB7IH0KIAorICAgIHZvaWQgZHVtcChXVEY6OlByaW50U3RyZWFtJikgY29uc3Q7 CisKICAgICB1aW50NjRfdCBieXRlcygpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PHVpbnQ2 NF90PihtX3BhZ2VDb3VudCkgKiBzdGF0aWNfY2FzdDx1aW50NjRfdD4ocGFnZVNpemUpOyB9CiAg ICAgdWludDMyX3QgcGFnZUNvdW50KCkgY29uc3QgeyByZXR1cm4gbV9wYWdlQ291bnQ7IH0KIApk aWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uY3BwIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uY3BwCmluZGV4IGVkMjhiYmMuLmI3Y2Ew NWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmNwcAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5jcHAKQEAgLTc2LDggKzc2 LDcgQEAgYm9vbCBQbGFuOjpwYXJzZUFuZFZhbGlkYXRlTW9kdWxlKCkKICAgICAgICAgfQogICAg ICAgICBtX21vZHVsZUluZm9ybWF0aW9uID0gV1RGTW92ZShwYXJzZVJlc3VsdC0+bW9kdWxlKTsK ICAgICAgICAgbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkgPSBXVEZNb3ZlKHBhcnNlUmVzdWx0 LT5mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkpOwotICAgICAgICBtX2Z1bmN0aW9uSW5kZXhTcGFj ZS5zaXplID0gcGFyc2VSZXN1bHQtPmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCk7Ci0gICAgICAg IG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlciA9IHBhcnNlUmVzdWx0LT5mdW5jdGlvbkluZGV4 U3BhY2UucmVsZWFzZUJ1ZmZlcigpOworICAgICAgICBtX21vZHVsZVNpZ25hdHVyZUluZGljZXNU b1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzID0gV1RGTW92ZShwYXJzZVJlc3VsdC0+bW9kdWxlU2ln bmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMpOwogICAgIH0KIAogICAgIGZv ciAodW5zaWduZWQgZnVuY3Rpb25JbmRleCA9IDA7IGZ1bmN0aW9uSW5kZXggPCBtX2Z1bmN0aW9u TG9jYXRpb25JbkJpbmFyeS5zaXplKCk7ICsrZnVuY3Rpb25JbmRleCkgewpAQCAtODksNyArODgs NyBAQCBib29sIFBsYW46OnBhcnNlQW5kVmFsaWRhdGVNb2R1bGUoKQogICAgICAgICBTaWduYXR1 cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fbW9kdWxlSW5mb3JtYXRpb24tPmludGVybmFsRnVu Y3Rpb25TaWduYXR1cmVJbmRpY2VzW2Z1bmN0aW9uSW5kZXhdOwogICAgICAgICBjb25zdCBTaWdu YXR1cmUqIHNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgc2lnbmF0 dXJlSW5kZXgpOwogCi0gICAgICAgIGF1dG8gdmFsaWRhdGlvblJlc3VsdCA9IHZhbGlkYXRlRnVu Y3Rpb24obV92bSwgZnVuY3Rpb25TdGFydCwgZnVuY3Rpb25MZW5ndGgsIHNpZ25hdHVyZSwgbV9m dW5jdGlvbkluZGV4U3BhY2UsICptX21vZHVsZUluZm9ybWF0aW9uKTsKKyAgICAgICAgYXV0byB2 YWxpZGF0aW9uUmVzdWx0ID0gdmFsaWRhdGVGdW5jdGlvbihtX3ZtLCBmdW5jdGlvblN0YXJ0LCBm dW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCAqbV9tb2R1bGVJbmZvcm1hdGlvbiwgbV9tb2R1bGVT aWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcyk7CiAgICAgICAgIGlmICgh dmFsaWRhdGlvblJlc3VsdCkgewogICAgICAgICAgICAgaWYgKHZlcmJvc2UpIHsKICAgICAgICAg ICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgZnVuY3Rpb25MZW5ndGg7ICsraSkKQEAg LTEyNyw3ICsxMjYsNyBAQCB2b2lkIFBsYW46OnJ1bigpCiAgICAgICAgIHJldHVybiB0cnVlOwog ICAgIH07CiAKLSAgICBpZiAoIXRyeVJlc2VydmVDYXBhY2l0eShtX3dhc21Ub0pTU3R1YnMsIG1f bW9kdWxlSW5mb3JtYXRpb24tPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCks ICIgV2ViQXNzZW1ibHkgdG8gSmF2YVNjcmlwdCBzdHVicyIpCisgICAgaWYgKCF0cnlSZXNlcnZl Q2FwYWNpdHkobV93YXNtRXhpdFN0dWJzLCBtX21vZHVsZUluZm9ybWF0aW9uLT5pbXBvcnRGdW5j dGlvblNpZ25hdHVyZUluZGljZXMuc2l6ZSgpLCAiIFdlYkFzc2VtYmx5IHRvIEphdmFTY3JpcHQg c3R1YnMiKQogICAgICAgICB8fCAhdHJ5UmVzZXJ2ZUNhcGFjaXR5KG1fdW5saW5rZWRXYXNtVG9X YXNtQ2FsbHMsIG1fZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5LnNpemUoKSwgIiB1bmxpbmtlZCBX ZWJBc3NlbWJseSB0byBXZWJBc3NlbWJseSBjYWxscyIpCiAgICAgICAgIHx8ICF0cnlSZXNlcnZl Q2FwYWNpdHkobV93YXNtSW50ZXJuYWxGdW5jdGlvbnMsIG1fZnVuY3Rpb25Mb2NhdGlvbkluQmlu YXJ5LnNpemUoKSwgIiBXZWJBc3NlbWJseSBmdW5jdGlvbnMiKQogICAgICAgICB8fCAhdHJ5UmVz ZXJ2ZUNhcGFjaXR5KG1fY29tcGlsYXRpb25Db250ZXh0cywgbV9mdW5jdGlvbkxvY2F0aW9uSW5C aW5hcnkuc2l6ZSgpLCAiIGNvbXBpbGF0aW9uIGNvbnRleHRzIikpCkBAIC0xNDEsMTIgKzE0MCwx MSBAQCB2b2lkIFBsYW46OnJ1bigpCiAgICAgICAgIEltcG9ydCogaW1wb3J0ID0gJm1fbW9kdWxl SW5mb3JtYXRpb24tPmltcG9ydHNbaW1wb3J0SW5kZXhdOwogICAgICAgICBpZiAoaW1wb3J0LT5r aW5kICE9IEV4dGVybmFsS2luZDo6RnVuY3Rpb24pCiAgICAgICAgICAgICBjb250aW51ZTsKLSAg ICAgICAgdW5zaWduZWQgaW1wb3J0RnVuY3Rpb25JbmRleCA9IG1fd2FzbVRvSlNTdHVicy5zaXpl KCk7CisgICAgICAgIHVuc2lnbmVkIGltcG9ydEZ1bmN0aW9uSW5kZXggPSBtX3dhc21FeGl0U3R1 YnMuc2l6ZSgpOwogICAgICAgICBpZiAodmVyYm9zZSkKICAgICAgICAgICAgIGRhdGFMb2dMbigi UHJvY2Vzc2luZyBpbXBvcnQgZnVuY3Rpb24gbnVtYmVyICIsIGltcG9ydEZ1bmN0aW9uSW5kZXgs ICI6ICIsIGltcG9ydC0+bW9kdWxlLCAiOiAiLCBpbXBvcnQtPmZpZWxkKTsKICAgICAgICAgU2ln bmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtX21vZHVsZUluZm9ybWF0aW9uLT5pbXBvcnRG dW5jdGlvblNpZ25hdHVyZUluZGljZXMuYXQoaW1wb3J0LT5raW5kSW5kZXgpOwotICAgICAgICBt X3dhc21Ub0pTU3R1YnMudW5jaGVja2VkQXBwZW5kKGltcG9ydFN0dWJHZW5lcmF0b3IobV92bSwg bV9jYWxsTGlua0luZm9zLCBzaWduYXR1cmVJbmRleCwgaW1wb3J0RnVuY3Rpb25JbmRleCkpOwot ICAgICAgICBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5idWZmZXIuZ2V0KClbaW1wb3J0RnVuY3Rpb25J bmRleF0uY29kZSA9IG1fd2FzbVRvSlNTdHVic1tpbXBvcnRGdW5jdGlvbkluZGV4XS5jb2RlKCku ZXhlY3V0YWJsZUFkZHJlc3MoKTsKKyAgICAgICAgbV93YXNtRXhpdFN0dWJzLnVuY2hlY2tlZEFw cGVuZChleGl0U3R1YkdlbmVyYXRvcihtX3ZtLCBtX2NhbGxMaW5rSW5mb3MsIHNpZ25hdHVyZUlu ZGV4LCBpbXBvcnRGdW5jdGlvbkluZGV4KSk7CiAgICAgfQogCiAgICAgbV9jdXJyZW50SW5kZXgg PSAwOwpAQCAtMTY3LDEyICsxNjUsMTIgQEAgdm9pZCBQbGFuOjpydW4oKQogICAgICAgICAgICAg QVNTRVJUKGZ1bmN0aW9uTGVuZ3RoIDw9IG1fc291cmNlTGVuZ3RoKTsKICAgICAgICAgICAgIFNp Z25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9tb2R1bGVJbmZvcm1hdGlvbi0+aW50ZXJu YWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXNbZnVuY3Rpb25JbmRleF07CiAgICAgICAgICAgICBj b25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92 bSwgc2lnbmF0dXJlSW5kZXgpOwotICAgICAgICAgICAgdW5zaWduZWQgZnVuY3Rpb25JbmRleFNw YWNlID0gbV93YXNtVG9KU1N0dWJzLnNpemUoKSArIGZ1bmN0aW9uSW5kZXg7Ci0gICAgICAgICAg ICBBU1NFUlRfVU5VU0VEKGZ1bmN0aW9uSW5kZXhTcGFjZSwgbV9mdW5jdGlvbkluZGV4U3BhY2Uu YnVmZmVyLmdldCgpW2Z1bmN0aW9uSW5kZXhTcGFjZV0uc2lnbmF0dXJlSW5kZXggPT0gc2lnbmF0 dXJlSW5kZXgpOwotICAgICAgICAgICAgQVNTRVJUKHZhbGlkYXRlRnVuY3Rpb24obV92bSwgZnVu Y3Rpb25TdGFydCwgZnVuY3Rpb25MZW5ndGgsIHNpZ25hdHVyZSwgbV9mdW5jdGlvbkluZGV4U3Bh Y2UsICptX21vZHVsZUluZm9ybWF0aW9uKSk7CisgICAgICAgICAgICB1bnNpZ25lZCBmdW5jdGlv bkluZGV4U3BhY2UgPSBtX3dhc21FeGl0U3R1YnMuc2l6ZSgpICsgZnVuY3Rpb25JbmRleDsKKyAg ICAgICAgICAgIEFTU0VSVF9VTlVTRUQoZnVuY3Rpb25JbmRleFNwYWNlLCBtX21vZHVsZUluZm9y bWF0aW9uLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRl eFNwYWNlKSA9PSBzaWduYXR1cmVJbmRleCk7CisgICAgICAgICAgICBBU1NFUlQodmFsaWRhdGVG dW5jdGlvbihtX3ZtLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCAq bV9tb2R1bGVJbmZvcm1hdGlvbiwgbV9tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2ln bmF0dXJlSW5kaWNlcykpOwogCiAgICAgICAgICAgICBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxz W2Z1bmN0aW9uSW5kZXhdID0gVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+KCk7Ci0gICAg ICAgICAgICBhdXRvIHBhcnNlQW5kQ29tcGlsZVJlc3VsdCA9IHBhcnNlQW5kQ29tcGlsZSgqbV92 bSwgbV9jb21waWxhdGlvbkNvbnRleHRzW2Z1bmN0aW9uSW5kZXhdLCBmdW5jdGlvblN0YXJ0LCBm dW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzW2Z1bmN0 aW9uSW5kZXhdLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZSwgKm1fbW9kdWxlSW5mb3JtYXRpb24pOwor ICAgICAgICAgICAgYXV0byBwYXJzZUFuZENvbXBpbGVSZXN1bHQgPSBwYXJzZUFuZENvbXBpbGUo Km1fdm0sIG1fY29tcGlsYXRpb25Db250ZXh0c1tmdW5jdGlvbkluZGV4XSwgZnVuY3Rpb25TdGFy dCwgZnVuY3Rpb25MZW5ndGgsIHNpZ25hdHVyZSwgbV91bmxpbmtlZFdhc21Ub1dhc21DYWxsc1tm dW5jdGlvbkluZGV4XSwgKm1fbW9kdWxlSW5mb3JtYXRpb24sIG1fbW9kdWxlU2lnbmF0dXJlSW5k aWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMpOwogCiAgICAgICAgICAgICBpZiAoVU5MSUtF TFkoIXBhcnNlQW5kQ29tcGlsZVJlc3VsdCkpIHsKICAgICAgICAgICAgICAgICBhdXRvIGxvY2tl ciA9IGhvbGRMb2NrKG1fbG9jayk7CkBAIC0yMjMsOSArMjIxLDYgQEAgdm9pZCBQbGFuOjpydW4o KQogICAgICAgICAgICAgICAgICAgICBzdGQ6Om1ha2VfdW5pcXVlPEIzOjpDb21waWxhdGlvbj4o RklOQUxJWkVfQ09ERShsaW5rQnVmZmVyLCAoIldhc20gSlMgZW50cnlwb2ludCIpKSwgV1RGTW92 ZShjb250ZXh0LmpzRW50cnlwb2ludEJ5cHJvZHVjdHMpKTsKICAgICAgICAgICAgIH0KICAgICAg ICAgfQotCi0gICAgICAgIHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFjZSA9IG1fd2FzbVRvSlNT dHVicy5zaXplKCkgKyBmdW5jdGlvbkluZGV4OwotICAgICAgICBtX2Z1bmN0aW9uSW5kZXhTcGFj ZS5idWZmZXIuZ2V0KClbZnVuY3Rpb25JbmRleFNwYWNlXS5jb2RlID0gbV93YXNtSW50ZXJuYWxG dW5jdGlvbnNbZnVuY3Rpb25JbmRleF0tPndhc21FbnRyeXBvaW50LmNvbXBpbGF0aW9uLT5jb2Rl KCkuZXhlY3V0YWJsZUFkZHJlc3MoKTsKICAgICB9CiAKICAgICBpZiAodmVyYm9zZSB8fCBPcHRp b25zOjpyZXBvcnRDb21waWxlVGltZXMoKSkgewpAQCAtMjM1LDggKzIzMCwxOSBAQCB2b2lkIFBs YW46OnJ1bigpCiAKICAgICAvLyBQYXRjaCB0aGUgY2FsbCBzaXRlcyBmb3IgZWFjaCBXZWJBc3Nl bWJseSBmdW5jdGlvbi4KICAgICBmb3IgKGF1dG8mIHVubGlua2VkIDogbV91bmxpbmtlZFdhc21U b1dhc21DYWxscykgewotICAgICAgICBmb3IgKGF1dG8mIGNhbGwgOiB1bmxpbmtlZCkKLSAgICAg ICAgICAgIE1hY3JvQXNzZW1ibGVyOjpyZXBhdGNoQ2FsbChjYWxsLmNhbGxMb2NhdGlvbiwgQ29k ZUxvY2F0aW9uTGFiZWwobV9mdW5jdGlvbkluZGV4U3BhY2UuYnVmZmVyLmdldCgpW2NhbGwuZnVu Y3Rpb25JbmRleF0uY29kZSkpOworICAgICAgICBmb3IgKGF1dG8mIGNhbGwgOiB1bmxpbmtlZCkg eworICAgICAgICAgICAgdm9pZCogZXhlY3V0YWJsZUFkZHJlc3M7CisgICAgICAgICAgICBpZiAo bV9tb2R1bGVJbmZvcm1hdGlvbi0+aXNJbXBvcnRlZEZ1bmN0aW9uRnJvbUZ1bmN0aW9uSW5kZXhT cGFjZShjYWxsLmZ1bmN0aW9uSW5kZXgpKSB7CisgICAgICAgICAgICAgICAgLy8gRklYTUUgaW1w b3J0cyBjb3VsZCBoYXZlIGJlZW4gbGlua2VkIGluIEIzLCBpbnN0ZWFkIG9mIGdlbmVyYXRpbmcg YSBwYXRjaHBvaW50LiBUaGlzIGNvbmRpdGlvbiBzaG91bGQgYmUgcmVwbGFjZWQgYnkgYSBSRUxF QVNFX0FTU0VSVC4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NjQ2 MgorICAgICAgICAgICAgICAgIGV4ZWN1dGFibGVBZGRyZXNzID0gY2FsbC50YXJnZXQgPT0gVW5s aW5rZWRXYXNtVG9XYXNtQ2FsbDo6VGFyZ2V0Ojp0b0pTCisgICAgICAgICAgICAgICAgICAgID8g bV93YXNtRXhpdFN0dWJzLmF0KGNhbGwuZnVuY3Rpb25JbmRleCkud2FzbVRvSlMuY29kZSgpLmV4 ZWN1dGFibGVBZGRyZXNzKCkKKyAgICAgICAgICAgICAgICAgICAgOiBtX3dhc21FeGl0U3R1YnMu YXQoY2FsbC5mdW5jdGlvbkluZGV4KS53YXNtVG9XYXNtLmNvZGUoKS5leGVjdXRhYmxlQWRkcmVz cygpOworICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICBBU1NFUlQoY2FsbC50 YXJnZXQgIT0gVW5saW5rZWRXYXNtVG9XYXNtQ2FsbDo6VGFyZ2V0Ojp0b0pTKTsKKyAgICAgICAg ICAgICAgICBleGVjdXRhYmxlQWRkcmVzcyA9IG1fd2FzbUludGVybmFsRnVuY3Rpb25zLmF0KGNh bGwuZnVuY3Rpb25JbmRleCAtIG1fd2FzbUV4aXRTdHVicy5zaXplKCkpLT53YXNtRW50cnlwb2lu dC5jb21waWxhdGlvbi0+Y29kZSgpLmV4ZWN1dGFibGVBZGRyZXNzKCk7CisgICAgICAgICAgICB9 CisgICAgICAgICAgICBNYWNyb0Fzc2VtYmxlcjo6cmVwYXRjaENhbGwoY2FsbC5jYWxsTG9jYXRp b24sIENvZGVMb2NhdGlvbkxhYmVsKGV4ZWN1dGFibGVBZGRyZXNzKSk7CisgICAgICAgIH0KICAg ICB9CiAKICAgICBtX2ZhaWxlZCA9IGZhbHNlOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbVBsYW4uaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Q bGFuLmgKaW5kZXggM2JiMDFjOC4uNjk4MGJkYiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbVBsYW4uaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9X YXNtUGxhbi5oCkBAIC04NiwyNiArODYsMjAgQEAgcHVibGljOgogICAgICAgICByZXR1cm4gV1RG TW92ZShtX2NhbGxMaW5rSW5mb3MpOwogICAgIH0KIAotICAgIFZlY3RvcjxXYXNtVG9KU1N0dWI+ JiYgdGFrZVdhc21Ub0pTU3R1YnMoKQorICAgIFZlY3RvcjxXYXNtRXhpdFN0dWJzPiYmIHRha2VX YXNtRXhpdFN0dWJzKCkKICAgICB7CiAgICAgICAgIFJFTEVBU0VfQVNTRVJUKCFmYWlsZWQoKSk7 Ci0gICAgICAgIHJldHVybiBXVEZNb3ZlKG1fd2FzbVRvSlNTdHVicyk7Ci0gICAgfQotCi0gICAg SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiYgdGFrZUZ1bmN0aW9uSW5kZXhTcGFjZSgpCi0g ICAgewotICAgICAgICBSRUxFQVNFX0FTU0VSVCghZmFpbGVkKCkpOwotICAgICAgICByZXR1cm4g V1RGTW92ZShtX2Z1bmN0aW9uSW5kZXhTcGFjZSk7CisgICAgICAgIHJldHVybiBXVEZNb3ZlKG1f d2FzbUV4aXRTdHVicyk7CiAgICAgfQogCiBwcml2YXRlOgogICAgIHN0ZDo6dW5pcXVlX3B0cjxN b2R1bGVJbmZvcm1hdGlvbj4gbV9tb2R1bGVJbmZvcm1hdGlvbjsKICAgICBWZWN0b3I8RnVuY3Rp b25Mb2NhdGlvbkluQmluYXJ5PiBtX2Z1bmN0aW9uTG9jYXRpb25JbkJpbmFyeTsKKyAgICBWZWN0 b3I8U2lnbmF0dXJlSW5kZXg+IG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25h dHVyZUluZGljZXM7CiAgICAgQmFnPENhbGxMaW5rSW5mbz4gbV9jYWxsTGlua0luZm9zOwotICAg IFZlY3RvcjxXYXNtVG9KU1N0dWI+IG1fd2FzbVRvSlNTdHViczsKKyAgICBWZWN0b3I8V2FzbUV4 aXRTdHVicz4gbV93YXNtRXhpdFN0dWJzOwogICAgIFZlY3RvcjxzdGQ6OnVuaXF1ZV9wdHI8V2Fz bUludGVybmFsRnVuY3Rpb24+PiBtX3dhc21JbnRlcm5hbEZ1bmN0aW9uczsKICAgICBWZWN0b3I8 Q29tcGlsYXRpb25Db250ZXh0PiBtX2NvbXBpbGF0aW9uQ29udGV4dHM7Ci0gICAgSW1tdXRhYmxl RnVuY3Rpb25JbmRleFNwYWNlIG1fZnVuY3Rpb25JbmRleFNwYWNlOwogCiAgICAgVk0qIG1fdm07 CiAgICAgVmVjdG9yPFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPj4gbV91bmxpbmtlZFdh c21Ub1dhc21DYWxsczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dh c21TaWduYXR1cmUuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVy ZS5jcHAKaW5kZXggNmQ1YjFmNi4uMDk2NmRhYiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbVNpZ25hdHVyZS5jcHAKQEAgLTQxLDEyICs0MSwyMiBAQCBjb25zdCBib29sIHZl cmJvc2UgPSBmYWxzZTsKIAogY29uc3QgY29uc3RleHByIFNpZ25hdHVyZUluZGV4IFNpZ25hdHVy ZTo6aW52YWxpZEluZGV4OwogCitTdHJpbmcgU2lnbmF0dXJlOjp0b1N0cmluZygpIGNvbnN0Cit7 CisgICAgU3RyaW5nIHJlc3VsdChtYWtlU3RyaW5nKHJldHVyblR5cGUoKSkpOworICAgIHJlc3Vs dC5hcHBlbmQoIiAoIik7CisgICAgZm9yIChTaWduYXR1cmVBcmdDb3VudCBhcmcgPSAwOyBhcmcg PCBhcmd1bWVudENvdW50KCk7ICsrYXJnKSB7CisgICAgICAgIGlmIChhcmcpCisgICAgICAgICAg ICByZXN1bHQuYXBwZW5kKCIsICIpOworICAgICAgICByZXN1bHQuYXBwZW5kKG1ha2VTdHJpbmco YXJndW1lbnQoYXJnKSkpOworICAgIH0KKyAgICByZXN1bHQuYXBwZW5kKCcpJyk7CisgICAgcmV0 dXJuIHJlc3VsdDsKK30KKwogdm9pZCBTaWduYXR1cmU6OmR1bXAoUHJpbnRTdHJlYW0mIG91dCkg Y29uc3QKIHsKLSAgICBvdXQucHJpbnQobWFrZVN0cmluZyhyZXR1cm5UeXBlKCkpLCAiICgiKTsK LSAgICBmb3IgKFNpZ25hdHVyZUFyZ0NvdW50IGFyZyA9IDA7IGFyZyA8IGFyZ3VtZW50Q291bnQo KTsgKythcmcpCi0gICAgICAgIG91dC5wcmludCgoYXJnID8gIiwgIiA6ICIiKSwgbWFrZVN0cmlu Zyhhcmd1bWVudChhcmcpKSk7Ci0gICAgb3V0LnByaW50KCIpIik7CisgICAgb3V0LnByaW50KHRv U3RyaW5nKCkpOwogfQogCiB1bnNpZ25lZCBTaWduYXR1cmU6Omhhc2goKSBjb25zdApkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5oIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5oCmluZGV4IDBkNmM3YjUuLjRkNDNm ZmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUu aAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmgKQEAgLTgy LDYgKzgyLDcgQEAgcHVibGljOgogICAgIH0KICAgICBUeXBlIGFyZ3VtZW50KFNpZ25hdHVyZUFy Z0NvdW50IGkpIGNvbnN0IHsgcmV0dXJuIGNvbnN0X2Nhc3Q8U2lnbmF0dXJlKj4odGhpcyktPmFy Z3VtZW50KGkpOyB9CiAKKyAgICBXVEY6OlN0cmluZyB0b1N0cmluZygpIGNvbnN0OwogICAgIHZv aWQgZHVtcChXVEY6OlByaW50U3RyZWFtJiBvdXQpIGNvbnN0OwogICAgIGJvb2wgb3BlcmF0b3I9 PShjb25zdCBTaWduYXR1cmUmIHJocykgY29uc3QKICAgICB7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbVZhbGlkYXRlLmNwcAppbmRleCBlMzIxNjEzLi43NWQzODI2IDEwMDY0NAot LS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwCisrKyBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5jcHAKQEAgLTM4MSwxMCArMzgx LDEwIEBAIHZvaWQgVmFsaWRhdGU6OmR1bXAoY29uc3QgVmVjdG9yPENvbnRyb2xFbnRyeT4mIGNv bnRyb2xTdGFjaywgY29uc3QgRXhwcmVzc2lvbkxpCiAgICAgZGF0YUxvZ0xuKCk7CiB9CiAKLUV4 cGVjdGVkPHZvaWQsIFN0cmluZz4gdmFsaWRhdGVGdW5jdGlvbihWTSogdm0sIGNvbnN0IHVpbnQ4 X3QqIHNvdXJjZSwgc2l6ZV90IGxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUsIGNv bnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYgZnVuY3Rpb25JbmRleFNwYWNlLCBjb25z dCBNb2R1bGVJbmZvcm1hdGlvbiYgbW9kdWxlKQorRXhwZWN0ZWQ8dm9pZCwgU3RyaW5nPiB2YWxp ZGF0ZUZ1bmN0aW9uKFZNKiB2bSwgY29uc3QgdWludDhfdCogc291cmNlLCBzaXplX3QgbGVuZ3Ro LCBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIG1v ZHVsZSwgY29uc3QgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiYgbW9kdWxlU2lnbmF0dXJlSW5kaWNl c1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMpCiB7CiAgICAgVmFsaWRhdGUgY29udGV4dChtb2R1 bGUpOwotICAgIEZ1bmN0aW9uUGFyc2VyPFZhbGlkYXRlPiB2YWxpZGF0b3Iodm0sIGNvbnRleHQs IHNvdXJjZSwgbGVuZ3RoLCBzaWduYXR1cmUsIGZ1bmN0aW9uSW5kZXhTcGFjZSwgbW9kdWxlKTsK KyAgICBGdW5jdGlvblBhcnNlcjxWYWxpZGF0ZT4gdmFsaWRhdG9yKHZtLCBjb250ZXh0LCBzb3Vy Y2UsIGxlbmd0aCwgc2lnbmF0dXJlLCBtb2R1bGUsIG1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1Vu aXF1ZWRTaWduYXR1cmVJbmRpY2VzKTsKICAgICBXQVNNX0ZBSUxfSUZfSEVMUEVSX0ZBSUxTKHZh bGlkYXRvci5wYXJzZSgpKTsKICAgICByZXR1cm4geyB9OwogfQpkaWZmIC0tZ2l0IGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtVmFsaWRhdGUuaAppbmRleCAxNDgyMWYyLi43M2U3ZDg3IDEwMDY0NAotLS0g YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuaAorKysgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuaApAQCAtMzYsNyArMzYsNyBAQCBjbGFz cyBWTTsKIAogbmFtZXNwYWNlIFdhc20gewogCi1FeHBlY3RlZDx2b2lkLCBTdHJpbmc+IHZhbGlk YXRlRnVuY3Rpb24oVk0qLCBjb25zdCB1aW50OF90Kiwgc2l6ZV90LCBjb25zdCBTaWduYXR1cmUq LCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmLCBjb25zdCBNb2R1bGVJbmZvcm1h dGlvbiYpOworRXhwZWN0ZWQ8dm9pZCwgU3RyaW5nPiB2YWxpZGF0ZUZ1bmN0aW9uKFZNKiwgY29u c3QgdWludDhfdCosIHNpemVfdCwgY29uc3QgU2lnbmF0dXJlKiwgY29uc3QgTW9kdWxlSW5mb3Jt YXRpb24mLCBjb25zdCBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+Jik7CiAKIH0gfSAvLyBuYW1lc3Bh Y2UgSlNDOjpXYXNtCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pz L0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMv SlNXZWJBc3NlbWJseUluc3RhbmNlLmgKaW5kZXggOTI4ZjQyMy4uNTRhZTE3ZCAxMDA2NDQKLS0t IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseUluc3RhbmNlLmgK KysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseUluc3RhbmNl LmgKQEAgLTQyLDcgKzQyLDcgQEAgcHVibGljOgogICAgIHR5cGVkZWYgSlNEZXN0cnVjdGlibGVP YmplY3QgQmFzZTsKIAogCi0gICAgc3RhdGljIEpTV2ViQXNzZW1ibHlJbnN0YW5jZSogY3JlYXRl KFZNJiwgU3RydWN0dXJlKiwgSlNXZWJBc3NlbWJseU1vZHVsZSosIEpTTW9kdWxlTmFtZXNwYWNl T2JqZWN0Kik7CisgICAgSlNfRVhQT1JUX1BSSVZBVEUgc3RhdGljIEpTV2ViQXNzZW1ibHlJbnN0 YW5jZSogY3JlYXRlKFZNJiwgU3RydWN0dXJlKiwgSlNXZWJBc3NlbWJseU1vZHVsZSosIEpTTW9k dWxlTmFtZXNwYWNlT2JqZWN0Kik7CiAgICAgc3RhdGljIFN0cnVjdHVyZSogY3JlYXRlU3RydWN0 dXJlKFZNJiwgSlNHbG9iYWxPYmplY3QqLCBKU1ZhbHVlKTsKIAogICAgIERFQ0xBUkVfSU5GTzsK QEAgLTg2LDkgKzg2LDExIEBAIHB1YmxpYzoKICAgICAgICAgcmV0dXJuIG9mZnNldE9mSW1wb3J0 RnVuY3Rpb25zKCkgKyBzaXplb2YoV3JpdGVCYXJyaWVyPEpTQ2VsbD4pICogaWR4OwogICAgIH0K IAotICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZUYWJsZSgpIHsgcmV0dXJuIE9CSkVDVF9P RkZTRVRPRihKU1dlYkFzc2VtYmx5SW5zdGFuY2UsIG1fdGFibGUpOyB9CiAgICAgc3RhdGljIHB0 cmRpZmZfdCBvZmZzZXRPZk1lbW9yeSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFz c2VtYmx5SW5zdGFuY2UsIG1fbWVtb3J5KTsgfQorICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0 T2ZUYWJsZSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFzc2VtYmx5SW5zdGFuY2Us IG1fdGFibGUpOyB9CiAgICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZkdsb2JhbHMoKSB7IHJl dHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseUluc3RhbmNlLCBtX2dsb2JhbHMpOyB9 CisgICAgc3RhdGljIHNpemVfdCBvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucygpIHsgcmV0dXJuIFdU Rjo6cm91bmRVcFRvTXVsdGlwbGVPZjxzaXplb2YoV3JpdGVCYXJyaWVyPEpTQ2VsbD4pPihzaXpl b2YoSlNXZWJBc3NlbWJseUluc3RhbmNlKSk7IH0KKyAgICBzdGF0aWMgc2l6ZV90IG9mZnNldE9m SW1wb3J0RnVuY3Rpb24oc2l6ZV90IGltcG9ydEZ1bmN0aW9uTnVtKSB7IHJldHVybiBvZmZzZXRP ZkltcG9ydEZ1bmN0aW9ucygpICsgaW1wb3J0RnVuY3Rpb25OdW0gKiBzaXplb2Yoc2l6ZW9mKFdy aXRlQmFycmllcjxKU0NlbGw+KSk7IH0KIAogcHJvdGVjdGVkOgogICAgIEpTV2ViQXNzZW1ibHlJ bnN0YW5jZShWTSYsIFN0cnVjdHVyZSosIHVuc2lnbmVkIG51bUltcG9ydEZ1bmN0aW9ucyk7CkBA IC05NiwxMSArOTgsNiBAQCBwcm90ZWN0ZWQ6CiAgICAgc3RhdGljIHZvaWQgZGVzdHJveShKU0Nl bGwqKTsKICAgICBzdGF0aWMgdm9pZCB2aXNpdENoaWxkcmVuKEpTQ2VsbCosIFNsb3RWaXNpdG9y Jik7CiAKLSAgICBzdGF0aWMgc2l6ZV90IG9mZnNldE9mSW1wb3J0RnVuY3Rpb25zKCkKLSAgICB7 Ci0gICAgICAgIHJldHVybiBXVEY6OnJvdW5kVXBUb011bHRpcGxlT2Y8c2l6ZW9mKFdyaXRlQmFy cmllcjxKU0NlbGw+KT4oc2l6ZW9mKEpTV2ViQXNzZW1ibHlJbnN0YW5jZSkpOwotICAgIH0KLQog ICAgIHN0YXRpYyBzaXplX3QgYWxsb2NhdGlvblNpemUodW5zaWduZWQgbnVtSW1wb3J0RnVuY3Rp b25zKQogICAgIHsKICAgICAgICAgcmV0dXJuIG9mZnNldE9mSW1wb3J0RnVuY3Rpb25zKCkgKyBz aXplb2YoV3JpdGVCYXJyaWVyPEpTQ2VsbD4pICogbnVtSW1wb3J0RnVuY3Rpb25zOwpkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5j cHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNw cAppbmRleCA1MjhhYjY5Li40YzRjYzNlIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNwcApAQCAtMzcsOSArMzcsOSBAQCBu YW1lc3BhY2UgSlNDIHsKIAogY29uc3QgQ2xhc3NJbmZvIEpTV2ViQXNzZW1ibHlNZW1vcnk6OnNf aW5mbyA9IHsgIldlYkFzc2VtYmx5Lk1lbW9yeSIsICZCYXNlOjpzX2luZm8sIDAsIENSRUFURV9N RVRIT0RfVEFCTEUoSlNXZWJBc3NlbWJseU1lbW9yeSkgfTsKIAotSlNXZWJBc3NlbWJseU1lbW9y eSogSlNXZWJBc3NlbWJseU1lbW9yeTo6Y3JlYXRlKFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1 cmUsIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+JiYgbWVtb3J5KQorSlNXZWJBc3NlbWJs eU1lbW9yeSogSlNXZWJBc3NlbWJseU1lbW9yeTo6Y3JlYXRlKFZNJiB2bSwgU3RydWN0dXJlKiBz dHJ1Y3R1cmUsIFdhc206Ok1lbW9yeSYmIG1lbW9yeSkKIHsKLSAgICBhdXRvKiBpbnN0YW5jZSA9 IG5ldyAoTm90TnVsbCwgYWxsb2NhdGVDZWxsPEpTV2ViQXNzZW1ibHlNZW1vcnk+KHZtLmhlYXAp KSBKU1dlYkFzc2VtYmx5TWVtb3J5KHZtLCBzdHJ1Y3R1cmUsIFdURk1vdmUobWVtb3J5KSk7Cisg ICAgYXV0byogaW5zdGFuY2UgPSBuZXcgKE5vdE51bGwsIGFsbG9jYXRlQ2VsbDxKU1dlYkFzc2Vt Ymx5TWVtb3J5Pih2bS5oZWFwKSkgSlNXZWJBc3NlbWJseU1lbW9yeSh2bSwgc3RydWN0dXJlLCBz dGQ6OmZvcndhcmQ8V2FzbTo6TWVtb3J5PihtZW1vcnkpKTsKICAgICBpbnN0YW5jZS0+ZmluaXNo Q3JlYXRpb24odm0pOwogICAgIHJldHVybiBpbnN0YW5jZTsKIH0KQEAgLTQ5LDcgKzQ5LDcgQEAg U3RydWN0dXJlKiBKU1dlYkFzc2VtYmx5TWVtb3J5OjpjcmVhdGVTdHJ1Y3R1cmUoVk0mIHZtLCBK U0dsb2JhbE9iamVjdCogZ2xvYmFsT2IKICAgICByZXR1cm4gU3RydWN0dXJlOjpjcmVhdGUodm0s IGdsb2JhbE9iamVjdCwgcHJvdG90eXBlLCBUeXBlSW5mbyhPYmplY3RUeXBlLCBTdHJ1Y3R1cmVG bGFncyksIGluZm8oKSk7CiB9CiAKLUpTV2ViQXNzZW1ibHlNZW1vcnk6OkpTV2ViQXNzZW1ibHlN ZW1vcnkoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVfcHRyPFdhc206 Ok1lbW9yeT4mJiBtZW1vcnkpCitKU1dlYkFzc2VtYmx5TWVtb3J5OjpKU1dlYkFzc2VtYmx5TWVt b3J5KFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIFdhc206Ok1lbW9yeSYmIG1lbW9yeSkK ICAgICA6IEJhc2Uodm0sIHN0cnVjdHVyZSkKICAgICAsIG1fbWVtb3J5KFdURk1vdmUobWVtb3J5 KSkKIHsKQEAgLTcyLDcgKzcyLDcgQEAgSlNBcnJheUJ1ZmZlciogSlNXZWJBc3NlbWJseU1lbW9y eTo6YnVmZmVyKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCkKICAgICBhdXRv IGRlc3RydWN0b3IgPSBbXSAodm9pZCopIHsKICAgICAgICAgLy8gV2UgZG9uJ3QgbmVlZCB0byBk byBhbnl0aGluZyBoZXJlIHRvIGRlc3Ryb3kgdGhlIG1lbW9yeS4KICAgICAgICAgLy8gVGhlIEFy cmF5QnVmZmVyIGJhY2tpbmcgdGhlIEpTQXJyYXlCdWZmZXIgaXMgb25seSBvd25lZCBieSB1cywK LSAgICAgICAgLy8gc28gd2UgZ3VhcmFudGVlIGl0cyBsaWZlY3lsY2UuCisgICAgICAgIC8vIHNv IHdlIGd1YXJhbnRlZSBpdHMgbGlmZWN5Y2xlLgogICAgIH07CiAgICAgbV9idWZmZXIgPSBBcnJh eUJ1ZmZlcjo6Y3JlYXRlRnJvbUJ5dGVzKG1lbW9yeSgpLT5tZW1vcnkoKSwgbWVtb3J5KCktPnNp emUoKSwgV1RGTW92ZShkZXN0cnVjdG9yKSk7CiAgICAgbV9idWZmZXJXcmFwcGVyLnNldCh2bSwg dGhpcywgSlNBcnJheUJ1ZmZlcjo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3QtPm1fYXJyYXlCdWZm ZXJTdHJ1Y3R1cmUuZ2V0KCksIG1fYnVmZmVyLmdldCgpKSk7CkBAIC04NSw3ICs4NSw3IEBAIFdh c206OlBhZ2VDb3VudCBKU1dlYkFzc2VtYmx5TWVtb3J5Ojpncm93KEV4ZWNTdGF0ZSogZXhlYywg dWludDMyX3QgZGVsdGEsIGJvb2wKICAgICBWTSYgdm0gPSBleGVjLT52bSgpOwogICAgIGF1dG8g dGhyb3dTY29wZSA9IERFQ0xBUkVfVEhST1dfU0NPUEUodm0pOwogCi0gICAgV2FzbTo6UGFnZUNv dW50IG9sZFBhZ2VDb3VudCA9IG1fbWVtb3J5LT5zaXplSW5QYWdlcygpOworICAgIFdhc206OlBh Z2VDb3VudCBvbGRQYWdlQ291bnQgPSBtZW1vcnkoKS0+c2l6ZUluUGFnZXMoKTsKIAogICAgIGlm ICghV2FzbTo6UGFnZUNvdW50Ojppc1ZhbGlkKGRlbHRhKSkgewogICAgICAgICBpZiAoc2hvdWxk VGhyb3dFeGNlcHRpb25zT25GYWlsdXJlKQpAQCAtMTAxLDcgKzEwMSw3IEBAIFdhc206OlBhZ2VD b3VudCBKU1dlYkFzc2VtYmx5TWVtb3J5Ojpncm93KEV4ZWNTdGF0ZSogZXhlYywgdWludDMyX3Qg ZGVsdGEsIGJvb2wKICAgICB9CiAKICAgICBpZiAoZGVsdGEpIHsKLSAgICAgICAgYm9vbCBzdWNj ZXNzID0gbV9tZW1vcnktPmdyb3cobmV3U2l6ZSk7CisgICAgICAgIGJvb2wgc3VjY2VzcyA9IG1l bW9yeSgpLT5ncm93KG5ld1NpemUpOwogICAgICAgICBpZiAoIXN1Y2Nlc3MpIHsKICAgICAgICAg ICAgIGlmIChzaG91bGRUaHJvd0V4Y2VwdGlvbnNPbkZhaWx1cmUpCiAgICAgICAgICAgICAgICAg dGhyb3dFeGNlcHRpb24oZXhlYywgdGhyb3dTY29wZSwgY3JlYXRlT3V0T2ZNZW1vcnlFcnJvcihl eGVjKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFz c2VtYmx5TWVtb3J5LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2Vt Ymx5TWVtb3J5LmgKaW5kZXggMjg3OTdjNi4uMzlhMzViYiAxMDA2NDQKLS0tIGEvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5oCisrKyBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuaApAQCAtNDEsMjUgKzQx LDI2IEBAIGNsYXNzIEpTV2ViQXNzZW1ibHlNZW1vcnkgOiBwdWJsaWMgSlNEZXN0cnVjdGlibGVP YmplY3QgewogcHVibGljOgogICAgIHR5cGVkZWYgSlNEZXN0cnVjdGlibGVPYmplY3QgQmFzZTsK IAotICAgIHN0YXRpYyBKU1dlYkFzc2VtYmx5TWVtb3J5KiBjcmVhdGUoVk0mLCBTdHJ1Y3R1cmUq LCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiYmKTsKKyAgICBKU19FWFBPUlRfUFJJVkFU RSBzdGF0aWMgSlNXZWJBc3NlbWJseU1lbW9yeSogY3JlYXRlKFZNJiwgU3RydWN0dXJlKiwgV2Fz bTo6TWVtb3J5JiYpOwogICAgIHN0YXRpYyBTdHJ1Y3R1cmUqIGNyZWF0ZVN0cnVjdHVyZShWTSYs IEpTR2xvYmFsT2JqZWN0KiwgSlNWYWx1ZSk7CiAKLSAgICBERUNMQVJFX0lORk87CisgICAgREVD TEFSRV9FWFBPUlRfSU5GTzsKIAotICAgIFdhc206Ok1lbW9yeSogbWVtb3J5KCkgeyByZXR1cm4g bV9tZW1vcnkuZ2V0KCk7IH0KKyAgICBXYXNtOjpNZW1vcnkqIG1lbW9yeSgpIHsgcmV0dXJuICZt X21lbW9yeTsgfQogICAgIEpTQXJyYXlCdWZmZXIqIGJ1ZmZlcihWTSYgdm0sIEpTR2xvYmFsT2Jq ZWN0Kik7CiAgICAgV2FzbTo6UGFnZUNvdW50IGdyb3coRXhlY1N0YXRlKiwgdWludDMyX3QgZGVs dGEsIGJvb2wgc2hvdWxkVGhyb3dFeGNlcHRpb25zT25GYWlsdXJlKTsKIAotICAgIHN0YXRpYyBw dHJkaWZmX3Qgb2Zmc2V0T2ZNZW1vcnkoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJB c3NlbWJseU1lbW9yeSwgbV9tZW1vcnkpOyB9CisgICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRP Zk1lbW9yeSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFzc2VtYmx5TWVtb3J5LCBt X21lbW9yeSkgKyBXYXNtOjpNZW1vcnk6Om9mZnNldE9mTWVtb3J5KCk7IH0KKyAgICBzdGF0aWMg cHRyZGlmZl90IG9mZnNldE9mU2l6ZSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFz c2VtYmx5TWVtb3J5LCBtX21lbW9yeSkgKyBXYXNtOjpNZW1vcnk6Om9mZnNldE9mU2l6ZSgpOyB9 CiAKIHByb3RlY3RlZDoKLSAgICBKU1dlYkFzc2VtYmx5TWVtb3J5KFZNJiwgU3RydWN0dXJlKiwg c3RkOjp1bmlxdWVfcHRyPFdhc206Ok1lbW9yeT4mJik7CisgICAgSlNXZWJBc3NlbWJseU1lbW9y eShWTSYsIFN0cnVjdHVyZSosIFdhc206Ok1lbW9yeSYmKTsKICAgICB+SlNXZWJBc3NlbWJseU1l bW9yeSgpOwogICAgIHZvaWQgZmluaXNoQ3JlYXRpb24oVk0mKTsKICAgICBzdGF0aWMgdm9pZCBk ZXN0cm95KEpTQ2VsbCopOwogICAgIHN0YXRpYyB2b2lkIHZpc2l0Q2hpbGRyZW4oSlNDZWxsKiwg U2xvdFZpc2l0b3ImKTsKIAotICAgIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+IG1fbWVt b3J5OworICAgIFdhc206Ok1lbW9yeSBtX21lbW9yeTsKICAgICBXcml0ZUJhcnJpZXI8SlNBcnJh eUJ1ZmZlcj4gbV9idWZmZXJXcmFwcGVyOwogICAgIFJlZlB0cjxBcnJheUJ1ZmZlcj4gbV9idWZm ZXI7CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJB c3NlbWJseU1vZHVsZS5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFz c2VtYmx5TW9kdWxlLmNwcAppbmRleCBkNjUyNGM1Li5mYTBlODU5IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmNwcAorKysgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmNwcApAQCAt MzgsOSArMzgsOSBAQCBuYW1lc3BhY2UgSlNDIHsKIAogY29uc3QgQ2xhc3NJbmZvIEpTV2ViQXNz ZW1ibHlNb2R1bGU6OnNfaW5mbyA9IHsgIldlYkFzc2VtYmx5Lk1vZHVsZSIsICZCYXNlOjpzX2lu Zm8sIG51bGxwdHIsIENSRUFURV9NRVRIT0RfVEFCTEUoSlNXZWJBc3NlbWJseU1vZHVsZSkgfTsK IAotSlNXZWJBc3NlbWJseU1vZHVsZSogSlNXZWJBc3NlbWJseU1vZHVsZTo6Y3JlYXRlKFZNJiB2 bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZv cm1hdGlvbj4mJiBtb2R1bGVJbmZvcm1hdGlvbiwgQmFnPENhbGxMaW5rSW5mbz4mJiBjYWxsTGlu a0luZm9zLCBWZWN0b3I8V2FzbTo6V2FzbVRvSlNTdHViPiYmIHdhc21Ub0pTU3R1YnMsIFdhc206 OkltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmIGZ1bmN0aW9uSW5kZXhTcGFjZSwgU3ltYm9s VGFibGUqIGV4cG9ydFN5bWJvbFRhYmxlLCB1bnNpZ25lZCBjYWxsZWVDb3VudCkKK0pTV2ViQXNz ZW1ibHlNb2R1bGUqIEpTV2ViQXNzZW1ibHlNb2R1bGU6OmNyZWF0ZShWTSYgdm0sIFN0cnVjdHVy ZSogc3RydWN0dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYg bW9kdWxlSW5mb3JtYXRpb24sIEJhZzxDYWxsTGlua0luZm8+JiYgY2FsbExpbmtJbmZvcywgVmVj dG9yPFdhc206Oldhc21FeGl0U3R1YnM+JiYgd2FzbUV4aXRTdHVicywgU3ltYm9sVGFibGUqIGV4 cG9ydFN5bWJvbFRhYmxlLCB1bnNpZ25lZCBjYWxsZWVDb3VudCkKIHsKLSAgICBhdXRvKiBpbnN0 YW5jZSA9IG5ldyAoTm90TnVsbCwgYWxsb2NhdGVDZWxsPEpTV2ViQXNzZW1ibHlNb2R1bGU+KHZt LmhlYXAsIGFsbG9jYXRpb25TaXplKGNhbGxlZUNvdW50KSkpIEpTV2ViQXNzZW1ibHlNb2R1bGUo dm0sIHN0cnVjdHVyZSwgc3RkOjpmb3J3YXJkPHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJ bmZvcm1hdGlvbj4+KG1vZHVsZUluZm9ybWF0aW9uKSwgc3RkOjpmb3J3YXJkPEJhZzxDYWxsTGlu a0luZm8+PihjYWxsTGlua0luZm9zKSwgc3RkOjpmb3J3YXJkPFZlY3RvcjxXYXNtOjpXYXNtVG9K U1N0dWI+Pih3YXNtVG9KU1N0dWJzKSwgc3RkOjpmb3J3YXJkPFdhc206OkltbXV0YWJsZUZ1bmN0 aW9uSW5kZXhTcGFjZT4oZnVuY3Rpb25JbmRleFNwYWNlKSwgY2FsbGVlQ291bnQpOworICAgIGF1 dG8qIGluc3RhbmNlID0gbmV3IChOb3ROdWxsLCBhbGxvY2F0ZUNlbGw8SlNXZWJBc3NlbWJseU1v ZHVsZT4odm0uaGVhcCwgYWxsb2NhdGlvblNpemUoY2FsbGVlQ291bnQpKSkgSlNXZWJBc3NlbWJs eU1vZHVsZSh2bSwgc3RydWN0dXJlLCBzdGQ6OmZvcndhcmQ8c3RkOjp1bmlxdWVfcHRyPFdhc206 Ok1vZHVsZUluZm9ybWF0aW9uPj4obW9kdWxlSW5mb3JtYXRpb24pLCBzdGQ6OmZvcndhcmQ8QmFn PENhbGxMaW5rSW5mbz4+KGNhbGxMaW5rSW5mb3MpLCBzdGQ6OmZvcndhcmQ8VmVjdG9yPFdhc206 Oldhc21FeGl0U3R1YnM+Pih3YXNtRXhpdFN0dWJzKSwgY2FsbGVlQ291bnQpOwogICAgIGluc3Rh bmNlLT5maW5pc2hDcmVhdGlvbih2bSwgZXhwb3J0U3ltYm9sVGFibGUpOwogICAgIHJldHVybiBp bnN0YW5jZTsKIH0KQEAgLTUwLDEyICs1MCwxMSBAQCBTdHJ1Y3R1cmUqIEpTV2ViQXNzZW1ibHlN b2R1bGU6OmNyZWF0ZVN0cnVjdHVyZShWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYgog ICAgIHJldHVybiBTdHJ1Y3R1cmU6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LCBwcm90b3R5cGUs IFR5cGVJbmZvKE9iamVjdFR5cGUsIFN0cnVjdHVyZUZsYWdzKSwgaW5mbygpKTsKIH0KIAotSlNX ZWJBc3NlbWJseU1vZHVsZTo6SlNXZWJBc3NlbWJseU1vZHVsZShWTSYgdm0sIFN0cnVjdHVyZSog c3RydWN0dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYgbW9k dWxlSW5mb3JtYXRpb24sIEJhZzxDYWxsTGlua0luZm8+JiYgY2FsbExpbmtJbmZvcywgVmVjdG9y PFdhc206Oldhc21Ub0pTU3R1Yj4mJiB3YXNtVG9KU1N0dWJzLCBXYXNtOjpJbW11dGFibGVGdW5j dGlvbkluZGV4U3BhY2UmJiBmdW5jdGlvbkluZGV4U3BhY2UsIHVuc2lnbmVkIGNhbGxlZUNvdW50 KQorSlNXZWJBc3NlbWJseU1vZHVsZTo6SlNXZWJBc3NlbWJseU1vZHVsZShWTSYgdm0sIFN0cnVj dHVyZSogc3RydWN0dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+ JiYgbW9kdWxlSW5mb3JtYXRpb24sIEJhZzxDYWxsTGlua0luZm8+JiYgY2FsbExpbmtJbmZvcywg VmVjdG9yPFdhc206Oldhc21FeGl0U3R1YnM+JiYgd2FzbUV4aXRTdHVicywgdW5zaWduZWQgY2Fs bGVlQ291bnQpCiAgICAgOiBCYXNlKHZtLCBzdHJ1Y3R1cmUpCiAgICAgLCBtX21vZHVsZUluZm9y bWF0aW9uKFdURk1vdmUobW9kdWxlSW5mb3JtYXRpb24pKQogICAgICwgbV9jYWxsTGlua0luZm9z KFdURk1vdmUoY2FsbExpbmtJbmZvcykpCi0gICAgLCBtX3dhc21Ub0pTU3R1YnMoV1RGTW92ZSh3 YXNtVG9KU1N0dWJzKSkKLSAgICAsIG1fZnVuY3Rpb25JbmRleFNwYWNlKFdURk1vdmUoZnVuY3Rp b25JbmRleFNwYWNlKSkKKyAgICAsIG1fd2FzbUV4aXRTdHVicyhXVEZNb3ZlKHdhc21FeGl0U3R1 YnMpKQogICAgICwgbV9jYWxsZWVDb3VudChjYWxsZWVDb3VudCkKIHsKICAgICBtZW1zZXQoY2Fs bGVlcygpLCAwLCBtX2NhbGxlZUNvdW50ICogc2l6ZW9mKFdyaXRlQmFycmllcjxKU1dlYkFzc2Vt Ymx5Q2FsbGVlPikgKiAyKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pz L0pTV2ViQXNzZW1ibHlNb2R1bGUuaAppbmRleCBmZWM0ZWVkLi5mYTY3M2FmIDEwMDY0NAotLS0g YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmgKKysr IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5oCkBA IC00MywxOSArNDMsMTggQEAgY2xhc3MgSlNXZWJBc3NlbWJseU1vZHVsZSA6IHB1YmxpYyBKU0Rl c3RydWN0aWJsZU9iamVjdCB7CiBwdWJsaWM6CiAgICAgdHlwZWRlZiBKU0Rlc3RydWN0aWJsZU9i amVjdCBCYXNlOwogCi0gICAgc3RhdGljIEpTV2ViQXNzZW1ibHlNb2R1bGUqIGNyZWF0ZShWTSYs IFN0cnVjdHVyZSosIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4mJiwg QmFnPENhbGxMaW5rSW5mbz4mJiwgVmVjdG9yPFdhc206Oldhc21Ub0pTU3R1Yj4mJiwgV2FzbTo6 SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiYsIFN5bWJvbFRhYmxlKiwgdW5zaWduZWQpOwor ICAgIEpTX0VYUE9SVF9QUklWQVRFIHN0YXRpYyBKU1dlYkFzc2VtYmx5TW9kdWxlKiBjcmVhdGUo Vk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+ JiYsIEJhZzxDYWxsTGlua0luZm8+JiYsIFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPiYmLCBT eW1ib2xUYWJsZSosIHVuc2lnbmVkKTsKICAgICBzdGF0aWMgU3RydWN0dXJlKiBjcmVhdGVTdHJ1 Y3R1cmUoVk0mLCBKU0dsb2JhbE9iamVjdCosIEpTVmFsdWUpOwogCiAgICAgREVDTEFSRV9JTkZP OwogCiAgICAgY29uc3QgV2FzbTo6TW9kdWxlSW5mb3JtYXRpb24mIG1vZHVsZUluZm9ybWF0aW9u KCkgY29uc3QgeyByZXR1cm4gKm1fbW9kdWxlSW5mb3JtYXRpb24uZ2V0KCk7IH0KICAgICBTeW1i b2xUYWJsZSogZXhwb3J0U3ltYm9sVGFibGUoKSBjb25zdCB7IHJldHVybiBtX2V4cG9ydFN5bWJv bFRhYmxlLmdldCgpOyB9Ci0gICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlRm9yRnVu Y3Rpb25JbmRleFNwYWNlKHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFjZSkgY29uc3QKKyAgICBX YXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2Uo dW5zaWduZWQgZnVuY3Rpb25JbmRleFNwYWNlKSBjb25zdAogICAgIHsKLSAgICAgICAgQVNTRVJU KGZ1bmN0aW9uSW5kZXhTcGFjZSA8IG1fZnVuY3Rpb25JbmRleFNwYWNlLnNpemUpOwotICAgICAg ICByZXR1cm4gbV9mdW5jdGlvbkluZGV4U3BhY2UuYnVmZmVyLmdldCgpW2Z1bmN0aW9uSW5kZXhT cGFjZV0uc2lnbmF0dXJlSW5kZXg7CisgICAgICAgIHJldHVybiBtX21vZHVsZUluZm9ybWF0aW9u LT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleFNwYWNl KTsKICAgICB9Ci0gICAgdW5zaWduZWQgZnVuY3Rpb25JbXBvcnRDb3VudCgpIGNvbnN0IHsgcmV0 dXJuIG1fd2FzbVRvSlNTdHVicy5zaXplKCk7IH0KKyAgICB1bnNpZ25lZCBmdW5jdGlvbkltcG9y dENvdW50KCkgY29uc3QgeyByZXR1cm4gbV93YXNtRXhpdFN0dWJzLnNpemUoKTsgfQogCiAgICAg SlNXZWJBc3NlbWJseUNhbGxlZSoganNFbnRyeXBvaW50Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhT cGFjZSh1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2UpCiAgICAgewpAQCAtOTAsMTAgKzg5LDgg QEAgcHVibGljOgogICAgICAgICByZXR1cm4gYml0d2lzZV9jYXN0PFdyaXRlQmFycmllcjxKU1dl YkFzc2VtYmx5Q2FsbGVlPio+KGJpdHdpc2VfY2FzdDxjaGFyKj4odGhpcykgKyBvZmZzZXRPZkNh bGxlZXMoKSk7CiAgICAgfQogCi0gICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZkZ1bmN0aW9u SW5kZXhTcGFjZSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFzc2VtYmx5TW9kdWxl LCBtX2Z1bmN0aW9uSW5kZXhTcGFjZSk7IH0KLQogcHJvdGVjdGVkOgotICAgIEpTV2ViQXNzZW1i bHlNb2R1bGUoVk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5m b3JtYXRpb24+JiYsIEJhZzxDYWxsTGlua0luZm8+JiYsIFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0 dWI+JiYsIFdhc206OkltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmLCB1bnNpZ25lZCBjYWxs ZWVDb3VudCk7CisgICAgSlNXZWJBc3NlbWJseU1vZHVsZShWTSYsIFN0cnVjdHVyZSosIHN0ZDo6 dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4mJiwgQmFnPENhbGxMaW5rSW5mbz4m JiwgVmVjdG9yPFdhc206Oldhc21FeGl0U3R1YnM+JiYsIHVuc2lnbmVkIGNhbGxlZUNvdW50KTsK ICAgICB2b2lkIGZpbmlzaENyZWF0aW9uKFZNJiwgU3ltYm9sVGFibGUqKTsKICAgICBzdGF0aWMg dm9pZCBkZXN0cm95KEpTQ2VsbCopOwogICAgIHN0YXRpYyB2b2lkIHZpc2l0Q2hpbGRyZW4oSlND ZWxsKiwgU2xvdFZpc2l0b3ImKTsKQEAgLTExNyw4ICsxMTQsNyBAQCBwcml2YXRlOgogICAgIHN0 ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4gbV9tb2R1bGVJbmZvcm1hdGlv bjsKICAgICBCYWc8Q2FsbExpbmtJbmZvPiBtX2NhbGxMaW5rSW5mb3M7CiAgICAgV3JpdGVCYXJy aWVyPFN5bWJvbFRhYmxlPiBtX2V4cG9ydFN5bWJvbFRhYmxlOwotICAgIFZlY3RvcjxXYXNtOjpX YXNtVG9KU1N0dWI+IG1fd2FzbVRvSlNTdHViczsKLSAgICBjb25zdCBXYXNtOjpJbW11dGFibGVG dW5jdGlvbkluZGV4U3BhY2UgbV9mdW5jdGlvbkluZGV4U3BhY2U7CisgICAgVmVjdG9yPFdhc206 Oldhc21FeGl0U3R1YnM+IG1fd2FzbUV4aXRTdHViczsKICAgICB1bnNpZ25lZCBtX2NhbGxlZUNv dW50OwogfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2Vi QXNzZW1ibHlGdW5jdGlvbi5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJB c3NlbWJseUZ1bmN0aW9uLmNwcAppbmRleCBiZTI3ZjU3Li41OTAzMmJhIDEwMDY0NAotLS0gYS9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNwcAorKysg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNwcApA QCAtMTE5LDYgKzExOSw3IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGNh bGxXZWJBc3NlbWJseUZ1bmN0aW9uKEV4ZWNTdGF0ZSogZXhlYykKICAgICBQcm90b0NhbGxGcmFt ZSBwcm90b0NhbGxGcmFtZTsKICAgICBwcm90b0NhbGxGcmFtZS5pbml0KG51bGxwdHIsIHdhc21G dW5jdGlvbiwgZmlyc3RBcmd1bWVudCwgYXJnQ291bnQsIHJlbWFpbmluZ0FyZ3MpOwogCisgICAg Ly8gRklYTUUgRG8gYXdheSB3aXRoIHRoaXMgZW50aXJlIGZ1bmN0aW9uLCBhbmQgb25seSB1c2Ug dGhlIGVudHJ5cG9pbnQgZ2VuZXJhdGVkIGJ5IEIzLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTY2NDg2CiAgICAgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBwcmV2SlNX ZWJBc3NlbWJseUluc3RhbmNlID0gdm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlOwogICAgIHZt LnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZSA9IHdhc21GdW5jdGlvbi0+aW5zdGFuY2UoKTsKICAg ICBBU1NFUlQod2FzbUZ1bmN0aW9uLT5pbnN0YW5jZSgpKTsKQEAgLTE1Nyw3ICsxNTgsNyBAQCBX ZWJBc3NlbWJseUZ1bmN0aW9uKiBXZWJBc3NlbWJseUZ1bmN0aW9uOjpjcmVhdGUoVk0mIHZtLCBK U0dsb2JhbE9iamVjdCogZ2xvYmFsTwogU3RydWN0dXJlKiBXZWJBc3NlbWJseUZ1bmN0aW9uOjpj cmVhdGVTdHJ1Y3R1cmUoVk0mIHZtLCBKU0dsb2JhbE9iamVjdCogZ2xvYmFsT2JqZWN0LCBKU1Zh bHVlIHByb3RvdHlwZSkKIHsKICAgICBBU1NFUlQoZ2xvYmFsT2JqZWN0KTsKLSAgICByZXR1cm4g U3RydWN0dXJlOjpjcmVhdGUodm0sIGdsb2JhbE9iamVjdCwgcHJvdG90eXBlLCBUeXBlSW5mbyhK U0Z1bmN0aW9uVHlwZSwgU3RydWN0dXJlRmxhZ3MpLCBpbmZvKCkpOworICAgIHJldHVybiBTdHJ1 Y3R1cmU6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LCBwcm90b3R5cGUsIFR5cGVJbmZvKFdlYkFz c2VtYmx5RnVuY3Rpb25UeXBlLCBTdHJ1Y3R1cmVGbGFncyksIGluZm8oKSk7CiB9CiAKIFdlYkFz c2VtYmx5RnVuY3Rpb246OldlYkFzc2VtYmx5RnVuY3Rpb24oVk0mIHZtLCBKU0dsb2JhbE9iamVj dCogZ2xvYmFsT2JqZWN0LCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgV2FzbTo6U2lnbmF0dXJlSW5k ZXggc2lnbmF0dXJlSW5kZXgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9qcy9XZWJBc3NlbWJseUluc3RhbmNlQ29uc3RydWN0b3IuY3BwIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVjdG9yLmNwcAppbmRleCBk NjBmNDBlLi4zYWFkNTNjIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9q cy9XZWJBc3NlbWJseUluc3RhbmNlQ29uc3RydWN0b3IuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VDb25zdHJ1Y3Rvci5jcHAKQEAgLTEx NCwxOCArMTE0LDE5IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGNvbnN0 cnVjdEpTV2ViQXNzZW1ibHlJbnN0YW5jZShFeGVjU3RhdGUqIGV4CiAgICAgICAgICAgICAgICAg cmV0dXJuIEpTVmFsdWU6OmVuY29kZSh0aHJvd0V4Y2VwdGlvbihleGVjLCB0aHJvd1Njb3BlLCBj cmVhdGVKU1dlYkFzc2VtYmx5TGlua0Vycm9yKGV4ZWMsIHZtLCBBU0NJSUxpdGVyYWwoImltcG9y dCBmdW5jdGlvbiBtdXN0IGJlIGNhbGxhYmxlIikpKSk7CiAgICAgICAgICAgICBKU0NlbGwqIGNl bGwgPSB2YWx1ZS5hc0NlbGwoKTsKICAgICAgICAgICAgIC8vIGlpLiBJZiB2IGlzIGFuIEV4cG9y dGVkIEZ1bmN0aW9uIEV4b3RpYyBPYmplY3Q6Ci0gICAgICAgICAgICBpZiAoV2ViQXNzZW1ibHlG dW5jdGlvbiogaW1wb3J0ZWRFeHBvcnRzID0ganNEeW5hbWljQ2FzdDxXZWJBc3NlbWJseUZ1bmN0 aW9uKj4ob2JqZWN0KSkgewotICAgICAgICAgICAgICAgIC8vIEZJWE1FIGhhbmRsZSBGdW5jdGlv biBFeG90aWMgT2JqZWN0IHByb3Blcmx5LiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MTY1MjgyCi0gICAgICAgICAgICAgICAgLy8gYS4gSWYgdGhlIHNpZ25hdHVyZSBv ZiB2IGRvZXMgbm90IG1hdGNoIHRoZSBzaWduYXR1cmUgb2YgaSwgdGhyb3cgYSBUeXBlRXJyb3Iu CisgICAgICAgICAgICBpZiAoV2ViQXNzZW1ibHlGdW5jdGlvbiogaW1wb3J0ZWRFeHBvcnQgPSBq c0R5bmFtaWNDYXN0PFdlYkFzc2VtYmx5RnVuY3Rpb24qPihjZWxsKSkgeworICAgICAgICAgICAg ICAgIC8vIGEuIElmIHRoZSBzaWduYXR1cmUgb2YgdiBkb2VzIG5vdCBtYXRjaCB0aGUgc2lnbmF0 dXJlIG9mIGksIHRocm93IGEgV2ViQXNzZW1ibHkuTGlua0Vycm9yLgorICAgICAgICAgICAgICAg IFdhc206OlNpZ25hdHVyZUluZGV4IGltcG9ydGVkU2lnbmF0dXJlSW5kZXggPSBpbXBvcnRlZEV4 cG9ydC0+c2lnbmF0dXJlSW5kZXgoKTsKKyAgICAgICAgICAgICAgICBXYXNtOjpTaWduYXR1cmVJ bmRleCBleHBlY3RlZFNpZ25hdHVyZUluZGV4ID0gbW9kdWxlSW5mb3JtYXRpb24uaW1wb3J0RnVu Y3Rpb25TaWduYXR1cmVJbmRpY2VzW2ltcG9ydC5raW5kSW5kZXhdOworICAgICAgICAgICAgICAg IGlmIChpbXBvcnRlZFNpZ25hdHVyZUluZGV4ICE9IGV4cGVjdGVkU2lnbmF0dXJlSW5kZXgpCisg ICAgICAgICAgICAgICAgICAgIHJldHVybiBKU1ZhbHVlOjplbmNvZGUodGhyb3dFeGNlcHRpb24o ZXhlYywgdGhyb3dTY29wZSwgY3JlYXRlSlNXZWJBc3NlbWJseUxpbmtFcnJvcihleGVjLCB2bSwg QVNDSUlMaXRlcmFsKCJpbXBvcnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBkb2Vzbid0IG1hdGNo IHRoZSBwcm92aWRlZCBXZWJBc3NlbWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSIpKSkpOwogICAg ICAgICAgICAgICAgIC8vIGIuIExldCBjbG9zdXJlIGJlIHYuW1tDbG9zdXJlXV0uCi0gICAgICAg ICAgICAgICAgUkVMRUFTRV9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKLSAgICAgICAgICAgICAgICBV TlVTRURfUEFSQU0oaW1wb3J0ZWRFeHBvcnRzKTsKLSAgICAgICAgICAgICAgICBicmVhazsKICAg ICAgICAgICAgIH0KICAgICAgICAgICAgIC8vIGlpaS4gT3RoZXJ3aXNlOgogICAgICAgICAgICAg Ly8gYS4gTGV0IGNsb3N1cmUgYmUgYSBuZXcgaG9zdCBmdW5jdGlvbiBvZiB0aGUgZ2l2ZW4gc2ln bmF0dXJlIHdoaWNoIGNhbGxzIHYgYnkgY29lcmNpbmcgV2ViQXNzZW1ibHkgYXJndW1lbnRzIHRv IEphdmFTY3JpcHQgYXJndW1lbnRzIHZpYSBUb0pTVmFsdWUgYW5kIHJldHVybnMgdGhlIHJlc3Vs dCwgaWYgYW55LCBieSBjb2VyY2luZyB2aWEgVG9XZWJBc3NlbWJseVZhbHVlLgogICAgICAgICAg ICAgLy8gTm90ZTogZG9uZSBhcyBwYXJ0IG9mIFBsYW4gY29tcGlsYXRpb24uCiAgICAgICAgICAg ICAvLyBpdi4gQXBwZW5kIHYgdG8gZnVuY3MuCisgICAgICAgICAgICAvLyBOb3RlOiBhZGRpbmcg dGhlIEpTQ2VsbCB0byB0aGUgaW5zdGFuY2UgbGlzdCBmdWxmaWxscyBjbG9zdXJlIHJlcXVpcmVt ZW50cyBiLiBhYm92ZSAodGhlIFdlYkFzc2VtYmx5Lkluc3RhbmNlIHdpbCBiZSBrZXB0IGFsaXZl KSBhbmQgdi4gYmVsb3cgKHRoZSBKU0Z1bmN0aW9uKS4KICAgICAgICAgICAgIGluc3RhbmNlLT5z ZXRJbXBvcnRGdW5jdGlvbih2bSwgY2VsbCwgbnVtSW1wb3J0RnVuY3Rpb25zKyspOwogICAgICAg ICAgICAgLy8gdi4gQXBwZW5kIGNsb3N1cmUgdG8gaW1wb3J0cy4KICAgICAgICAgICAgIGJyZWFr OwpAQCAtMjMwLDcgKzIzMSw3IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxM IGNvbnN0cnVjdEpTV2ViQXNzZW1ibHlJbnN0YW5jZShFeGVjU3RhdGUqIGV4CiAgICAgICAgICAg ICBSRUxFQVNFX0FTU0VSVCghbW9kdWxlSW5mb3JtYXRpb24ubWVtb3J5LmlzSW1wb3J0KCkpOwog ICAgICAgICAgICAgLy8gV2UgY3JlYXRlIGEgbWVtb3J5IHdoZW4gaXQncyBhIG1lbW9yeSBkZWZp bml0aW9uLgogICAgICAgICAgICAgYm9vbCBmYWlsZWQ7Ci0gICAgICAgICAgICBzdGQ6OnVuaXF1 ZV9wdHI8V2FzbTo6TWVtb3J5PiBtZW1vcnkgPSBzdGQ6Om1ha2VfdW5pcXVlPFdhc206Ok1lbW9y eT4obW9kdWxlSW5mb3JtYXRpb24ubWVtb3J5LmluaXRpYWwoKSwgbW9kdWxlSW5mb3JtYXRpb24u bWVtb3J5Lm1heGltdW0oKSwgZmFpbGVkKTsKKyAgICAgICAgICAgIFdhc206Ok1lbW9yeSBtZW1v cnkobW9kdWxlSW5mb3JtYXRpb24ubWVtb3J5LmluaXRpYWwoKSwgbW9kdWxlSW5mb3JtYXRpb24u bWVtb3J5Lm1heGltdW0oKSwgZmFpbGVkKTsKICAgICAgICAgICAgIGlmIChmYWlsZWQpCiAgICAg ICAgICAgICAgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29kZSh0aHJvd0V4Y2VwdGlvbihleGVjLCB0 aHJvd1Njb3BlLCBjcmVhdGVPdXRPZk1lbW9yeUVycm9yKGV4ZWMpKSk7CiAgICAgICAgICAgICBp bnN0YW5jZS0+c2V0TWVtb3J5KHZtLApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vanMvV2ViQXNzZW1ibHlNZW1vcnlDb25zdHJ1Y3Rvci5jcHAgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1lbW9yeUNvbnN0cnVjdG9yLmNwcAppbmRleCA1 ZDVhNmNkLi42Yzg4N2FmIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9q cy9XZWJBc3NlbWJseU1lbW9yeUNvbnN0cnVjdG9yLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1lbW9yeUNvbnN0cnVjdG9yLmNwcApAQCAtOTcsNyAr OTcsNyBAQCBzdGF0aWMgRW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBjb25zdHJ1Y3RKU1dl YkFzc2VtYmx5TWVtb3J5KEV4ZWNTdGF0ZSogZXhlYwogICAgIH0KIAogICAgIGJvb2wgZmFpbGVk OwotICAgIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+IG1lbW9yeSA9IHN0ZDo6bWFrZV91 bmlxdWU8V2FzbTo6TWVtb3J5Pihpbml0aWFsUGFnZUNvdW50LCBtYXhpbXVtUGFnZUNvdW50LCBm YWlsZWQpOworICAgIFdhc206Ok1lbW9yeSBtZW1vcnkoaW5pdGlhbFBhZ2VDb3VudCwgbWF4aW11 bVBhZ2VDb3VudCwgZmFpbGVkKTsKICAgICBpZiAoZmFpbGVkKQogICAgICAgICByZXR1cm4gSlNW YWx1ZTo6ZW5jb2RlKHRocm93RXhjZXB0aW9uKGV4ZWMsIHRocm93U2NvcGUsIGNyZWF0ZU91dE9m TWVtb3J5RXJyb3IoZXhlYykpKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVDb25zdHJ1Y3Rvci5jcHAgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNwcAppbmRleCAz OGVkYjhjLi44MTI5NTkyIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9q cy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNwcApAQCAtOTcsNyAr OTcsNyBAQCBKU1ZhbHVlIFdlYkFzc2VtYmx5TW9kdWxlQ29uc3RydWN0b3I6OmNyZWF0ZU1vZHVs ZShFeGVjU3RhdGUqIHN0YXRlLCBTdHJ1Y3R1cmUqCiAKICAgICAvLyBPbmx5IHdhc20taW50ZXJu YWwgZnVuY3Rpb25zIGhhdmUgYSBjYWxsZWUsIHN0dWJzIHRvIEpTIGRvIG5vdC4KICAgICB1bnNp Z25lZCBjYWxsZWVDb3VudCA9IHBsYW4uaW50ZXJuYWxGdW5jdGlvbkNvdW50KCk7Ci0gICAgSlNX ZWJBc3NlbWJseU1vZHVsZSogcmVzdWx0ID0gSlNXZWJBc3NlbWJseU1vZHVsZTo6Y3JlYXRlKHZt LCBzdHJ1Y3R1cmUsIHBsYW4udGFrZU1vZHVsZUluZm9ybWF0aW9uKCksIHBsYW4udGFrZUNhbGxM aW5rSW5mb3MoKSwgcGxhbi50YWtlV2FzbVRvSlNTdHVicygpLCBwbGFuLnRha2VGdW5jdGlvbklu ZGV4U3BhY2UoKSwgZXhwb3J0U3ltYm9sVGFibGUsIGNhbGxlZUNvdW50KTsKKyAgICBKU1dlYkFz c2VtYmx5TW9kdWxlKiByZXN1bHQgPSBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGUodm0sIHN0 cnVjdHVyZSwgcGxhbi50YWtlTW9kdWxlSW5mb3JtYXRpb24oKSwgcGxhbi50YWtlQ2FsbExpbmtJ bmZvcygpLCBwbGFuLnRha2VXYXNtRXhpdFN0dWJzKCksIGV4cG9ydFN5bWJvbFRhYmxlLCBjYWxs ZWVDb3VudCk7CiAgICAgcGxhbi5pbml0aWFsaXplQ2FsbGVlcyhzdGF0ZS0+anNDYWxsZWUoKS0+ Z2xvYmFsT2JqZWN0KCksIAogICAgICAgICBbJl0gKHVuc2lnbmVkIGNhbGxlZUluZGV4LCBKU1dl YkFzc2VtYmx5Q2FsbGVlKiBqc0VudHJ5cG9pbnRDYWxsZWUsIEpTV2ViQXNzZW1ibHlDYWxsZWUq IHdhc21FbnRyeXBvaW50Q2FsbGVlKSB7CiAgICAgICAgICAgICByZXN1bHQtPnNldEpTRW50cnlw b2ludENhbGxlZSh2bSwgY2FsbGVlSW5kZXgsIGpzRW50cnlwb2ludENhbGxlZSk7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZVJlY29y ZC5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZVJl Y29yZC5jcHAKaW5kZXggYzFiZDgyMC4uZWMwNWFlMyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQuY3BwCisrKyBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmNwcApAQCAt MTE4LDcgKzExOCw3IEBAIHZvaWQgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmxpbmsoRXhlY1N0 YXRlKiBzdGF0ZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBpbnN0CiAgICAgICAgICAgICAvLyAg ICAgYy4gUmV0dXJuIGZ1bmMuCiAgICAgICAgICAgICBKU1dlYkFzc2VtYmx5Q2FsbGVlKiBqc0Vu dHJ5cG9pbnRDYWxsZWUgPSBtb2R1bGUtPmpzRW50cnlwb2ludENhbGxlZUZyb21GdW5jdGlvbklu ZGV4U3BhY2UoZXhwLmtpbmRJbmRleCk7CiAgICAgICAgICAgICBKU1dlYkFzc2VtYmx5Q2FsbGVl KiB3YXNtRW50cnlwb2ludENhbGxlZSA9IG1vZHVsZS0+d2FzbUVudHJ5cG9pbnRDYWxsZWVGcm9t RnVuY3Rpb25JbmRleFNwYWNlKGV4cC5raW5kSW5kZXgpOwotICAgICAgICAgICAgV2FzbTo6U2ln bmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVyZUZvckZ1bmN0aW9u SW5kZXhTcGFjZShleHAua2luZEluZGV4KTsKKyAgICAgICAgICAgIFdhc206OlNpZ25hdHVyZUlu ZGV4IHNpZ25hdHVyZUluZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbklu ZGV4U3BhY2UoZXhwLmtpbmRJbmRleCk7CiAgICAgICAgICAgICBjb25zdCBXYXNtOjpTaWduYXR1 cmUqIHNpZ25hdHVyZSA9IFdhc206OlNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQoJnZtLCBzaWdu YXR1cmVJbmRleCk7CiAgICAgICAgICAgICBXZWJBc3NlbWJseUZ1bmN0aW9uKiBmdW5jdGlvbiA9 IFdlYkFzc2VtYmx5RnVuY3Rpb246OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LCBzaWduYXR1cmUt PmFyZ3VtZW50Q291bnQoKSwgZXhwLmZpZWxkLnN0cmluZygpLCBpbnN0YW5jZSwganNFbnRyeXBv aW50Q2FsbGVlLCB3YXNtRW50cnlwb2ludENhbGxlZSwgc2lnbmF0dXJlSW5kZXgpOwogICAgICAg ICAgICAgZXhwb3J0ZWRWYWx1ZSA9IGZ1bmN0aW9uOwpAQCAtMTc1LDcgKzE3NSw3IEBAIHZvaWQg V2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmxpbmsoRXhlY1N0YXRlKiBzdGF0ZSwgSlNXZWJBc3Nl bWJseUluc3RhbmNlKiBpbnN0CiAgICAgYm9vbCBoYXNTdGFydCA9ICEhbW9kdWxlSW5mb3JtYXRp b24uc3RhcnRGdW5jdGlvbkluZGV4U3BhY2U7CiAgICAgaWYgKGhhc1N0YXJ0KSB7CiAgICAgICAg IGF1dG8gc3RhcnRGdW5jdGlvbkluZGV4U3BhY2UgPSBtb2R1bGVJbmZvcm1hdGlvbi5zdGFydEZ1 bmN0aW9uSW5kZXhTcGFjZS52YWx1ZV9vcigwKTsKLSAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5k ZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVyZUZvckZ1bmN0aW9uSW5kZXhTcGFj ZShzdGFydEZ1bmN0aW9uSW5kZXhTcGFjZSk7CisgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4 IHNpZ25hdHVyZUluZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4 U3BhY2Uoc3RhcnRGdW5jdGlvbkluZGV4U3BhY2UpOwogICAgICAgICBjb25zdCBXYXNtOjpTaWdu YXR1cmUqIHNpZ25hdHVyZSA9IFdhc206OlNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQoJnZtLCBz aWduYXR1cmVJbmRleCk7CiAgICAgICAgIC8vIFRoZSBzdGFydCBmdW5jdGlvbiBtdXN0IG5vdCB0 YWtlIGFueSBhcmd1bWVudHMgb3IgcmV0dXJuIGFueXRoaW5nLiBUaGlzIGlzIGVuZm9yY2VkIGJ5 IHRoZSBwYXJzZXIuCiAgICAgICAgIEFTU0VSVCghc2lnbmF0dXJlLT5hcmd1bWVudENvdW50KCkp OwpAQCAtMjM4LDcgKzIzOCw3IEBAIEpTVmFsdWUgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmV2 YWx1YXRlKEV4ZWNTdGF0ZSogc3RhdGUpCiAKICAgICAgICAgICAgICAgICBKU1dlYkFzc2VtYmx5 Q2FsbGVlKiBqc0VudHJ5cG9pbnRDYWxsZWUgPSBtb2R1bGUtPmpzRW50cnlwb2ludENhbGxlZUZy b21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleCk7CiAgICAgICAgICAgICAgICAgSlNX ZWJBc3NlbWJseUNhbGxlZSogd2FzbUVudHJ5cG9pbnRDYWxsZWUgPSBtb2R1bGUtPndhc21FbnRy eXBvaW50Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KTsKLSAgICAg ICAgICAgICAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1vZHVsZS0+ c2lnbmF0dXJlRm9yRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgpOworICAgICAgICAg ICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbW9kdWxlLT5zaWdu YXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleCk7CiAgICAgICAg ICAgICAgICAgY29uc3QgV2FzbTo6U2lnbmF0dXJlKiBzaWduYXR1cmUgPSBXYXNtOjpTaWduYXR1 cmVJbmZvcm1hdGlvbjo6Z2V0KCZ2bSwgc2lnbmF0dXJlSW5kZXgpOwogICAgICAgICAgICAgICAg IC8vIEZJWE1FOiBTYXkgd2UgZXhwb3J0IGxvY2FsIGZ1bmN0aW9uICJmb28iIGF0IGZ1bmNpdG9u IGluZGV4IDAuCiAgICAgICAgICAgICAgICAgLy8gV2hhdCBpZiB3ZSBhbHNvIHNldCBpdCB0byB0 aGUgdGFibGUgYW4gRWxlbWVudCB3LyBpbmRleCAwLgpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQuaCBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmgKaW5kZXggZTEyNjY3 MC4uMjQ2NWQ4MyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2Vi QXNzZW1ibHlNb2R1bGVSZWNvcmQuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9q cy9XZWJBc3NlbWJseU1vZHVsZVJlY29yZC5oCkBAIC00NSw3ICs0NSw3IEBAIHB1YmxpYzoKICAg ICBERUNMQVJFX0VYUE9SVF9JTkZPOwogCiAgICAgc3RhdGljIFN0cnVjdHVyZSogY3JlYXRlU3Ry dWN0dXJlKFZNJiwgSlNHbG9iYWxPYmplY3QqLCBKU1ZhbHVlKTsKLSAgICBzdGF0aWMgV2ViQXNz ZW1ibHlNb2R1bGVSZWNvcmQqIGNyZWF0ZShFeGVjU3RhdGUqLCBWTSYsIFN0cnVjdHVyZSosIGNv bnN0IElkZW50aWZpZXImLCBjb25zdCBXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbiYpOworICAgIEpT X0VYUE9SVF9QUklWQVRFIHN0YXRpYyBXZWJBc3NlbWJseU1vZHVsZVJlY29yZCogY3JlYXRlKEV4 ZWNTdGF0ZSosIFZNJiwgU3RydWN0dXJlKiwgY29uc3QgSWRlbnRpZmllciYsIGNvbnN0IFdhc206 Ok1vZHVsZUluZm9ybWF0aW9uJik7CiAKICAgICB2b2lkIGxpbmsoRXhlY1N0YXRlKiwgSlNXZWJB c3NlbWJseUluc3RhbmNlKik7CiAgICAgSlNfRVhQT1JUX1BSSVZBVEUgSlNWYWx1ZSBldmFsdWF0 ZShFeGVjU3RhdGUqKTsKLS0gCjIuMTAuMQoK 297848 2016-12-29 23:54:22 -0800 2016-12-30 12:11:01 -0800 WIP 0001-wasm-wasm.patch text/plain 143918 jfbastien RnJvbSAyYzRmYTRkYjQ4YjE5ZWY4OWI3ODI4YzFhNDliMGY3NjkwMGNmNGQ0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBXZWQsIDIxIERlYyAyMDE2IDE1OjU5OjU2IC0wODAwClN1YmplY3Q6IFtQQVRDSF0gd2FzbS0+ d2FzbQoKQ2hhbmdlcyB0byB0aGUgV2ViQXNzZW1ibHkgaW1wbGVtZW50YXRpb246CgogIC0gQWRk IGEgbmV3IEpTVHlwZSBmb3IgV2ViQXNzZW1ibHlGdW5jdGlvbiwgYW5kIHVzZSBpdCB3aGVuIGNy ZWF0aW5nIGl0cwogICAgc3RydWN0dXJlLiBUaGlzIHdpbGwgYmUgdXNlZCB0byBxdWlja2x5IGRl dGVjdCBmcm9tIHdhc20gd2hldGhlciB0aGUgaW1wb3J0CiAgICBjYWxsIGlzIHRvIGFub3RoZXIg d2FzbSBtb2R1bGUsIG9yIHdoZXRoZXIgaXQncyB0byBKUy4KICAtIFVzZSBjZWxsIGluc3RlYWQg b2Ygb2JqZWN0cyB0byBkZXRlY3Qgd2FzbS0+d2FzbSwgdGhlIHByZXZpb3VzIGNvZGUgd2FzIHdy b25nLgogIC0gSW1wcm92ZSBkaWFnbm9zdGljIHByaW50b3V0IGZvciB3YXNtIHN0dWJzOiBwcmlu dCB0aGUgZnVsbCBzaWduYXR1cmUuCiAgLSBQcm9wZXJseSBjaGVjayB0aGF0IHdhc20gLT4gd2Fz bSBjYWxscyBoYXZlIG1hdGNoaW5nIHNpZ25hdHVyZXMuIEFkZCB0ZXN0aW5nIGZvciB0aGlzLgog IC0gVGVzdCBzb21lIG9mIHRoZSB3YXNtIC0+IHdhc20gY2FsbHMsIG5vdCB3b3JraW5nIHlldCwg YW5kIG1vcmUgdGVzdHMgbmVlZCB0bwogICAgZ2V0IGltcGxlbWVudGVkLgogIC0gR2VuZXJhdGUg dHdvIHN0dWJzIGZyb20gdGhlIGltcG9ydCBzdHViIGdlbmVyYXRvcjogb25lIGZvciB3YXNtLT5K UyBhbmQgb25lCiAgICBmb3Igd2FzbSAtPiB3YXNtLiBUaGlzIGlzIGRvbmUgYXQgTW9kdWxlIHRp bWUuIFdoaWNoIGlzIGNhbGxlZCB3aWxsIG9ubHkgYmUKICAgIGtub3duIGF0IEluc3RhbmNlIHRp bWUsIG9uY2Ugd2UndmUgcmVjZWl2ZWQgdGhlIGltcG9ydCBvYmplY3QuIFdlIHdhbnQgdG8KICAg IGF2b2lkIGNvZGVnZW4gYXQgSW5zdGFuY2UgdGltZSwgc28gaGF2aW5nIGJvdGggYXJvdW5kIGlz IGdyZWF0LgogIC0gUmVzdG9yZSB0aGUgV2ViQXNzZW1ibHkgZ2xvYmFsIHN0YXRlIChWTSB0b3Ag SW5zdGFuY2UsIGFuZCBwaW5uZWQgcmVnaXN0ZXJzKQogICAgYWZ0ZXIgY2FsbCAvIGNhbGxfaW5k aXJlY3QsIGFuZCBpbiB0aGUgSlMtPndhc20gZW50cnkgc3R1Yi4KICAtIFBpbm5lZCByZWdpc3Rl cnMgYXJlIG5vdyBhIGdsb2JhbCB0aGluZywgbm90IHBlci1NZW1vcnksIGJlY2F1c2UgdGhlIHdh c20gLT4KICAgIHdhc20gc3R1YnMgYXJlIGdlbmVyYXRlZCBhdCBNb2R1bGUgdGltZSB3aGVyZSB3 ZSBkb24ndCByZWFsbHkgaGF2ZSBlbm91Z2gKICAgIGluZm9ybWF0aW9uIHRvIGRvIHRoZSByaWdo dCB0aGluZyAoZG9pbmcgc28gd291bGQgZ2VuZXJhdGUgdG9vIG11Y2ggY29kZSkuCgpTdXBwb3J0 IGNoYW5nZXM6CgogIC0gQWRkIGEgUHJveHkgdG8gQnVpbGRlci5qcywgd2hpY2ggaW50ZXJjZXB0 cyB1bmtub3duIHByb3BlcnR5IGxvb2t1cHMuIFRoaXMKICAgIGNyZWF0ZXMgd2F5IGJldHRlciBl cnJvciBtZXNzYWdlcyBvbiB0eXBvcyB0aGFuICd1bmRlZmluZWQgaXMgbm90IGEKICAgIGZ1bmN0 aW9uJywgd2hpY2ggaGFwcGVucyBzZW1pLWZyZXF1ZW50bHkgYXMgSSB0eXBvIG9wY29kZSBuYW1l cyAoYW5kIHdoaWNoCiAgICBvbmUgaXMgYSB0eXBvIGlzIGhhcmQgdG8gZmluZCBiZWNhdXNlIHdl IGNoYWluIGJ1aWxkZXJzKS4KICAtIEFkZCBsaW1pdGVkIHN1cHBvcnQgZm9yIHZhcnt1fWludDY0 IChvbmx5IHRoZSAzMi1iaXQgdmFsdWVzKS4KICAtIEdldCByaWQgb2YgbXVjaCBvZiB0aGUgZnVu Y3Rpb24gaW5kZXggc3BhY2U6IHdlIGFscmVhZHkgaGF2ZSBhbGwgb2YgaXRzCiAgICBpbmZvcm1h dGlvbiBlbHNld2hlcmUsIGFuZCBhcy1pcyBpdCBwcm92aWRlcyBubyBleHRyYSBlZmZpY2llbmN5 LgogIC0gU3RvcmUgV2FzbTo6TWVtb3J5IGRpcmVjdGx5IG9uIEpTV2ViQXNzZW1ibHlNZW1vcnks IGluc3RlYWQgb2YgdGhyb3VnaCBhCiAgICB1bmlxdWVfcHRyLiBUaGlzIHJlbW92ZXMgYW4gaW5k aXJlY3Rpb24gYW5kIHVzZWxlc3MgYWxsb2NhdGlvbi4KICAtIFJlbW92ZSBWTSdhIFdlYkFzc2Vt Ymx5IG1lbW9yeSAvIHNpemUsIGFuZCBvYnRhaW4gdGhlbSBmcm9tIEluc3RhbmNlCiAgICBpbnN0 ZWFkLiBUaGlzIHJlcXVpcmVzIGFuIGV4dHJhIGluZGlyZWN0aW9uLCBidXQgaXMgY2xlYW5lci4K ICAtIENhY2hlIHRoZSB3YXNtIGVudHJ5cG9pbnQgY29kZSdzIGxvY2F0aW9uIG9uIFdlYkFzc2Vt Ymx5RnVuY3Rpb24gZm9yIGZhc3RlcgogICAgYWNjZXNzLgogIC0gQWxsIEluc3RhbmNlIG5vdyBo YXZlIGEgdmFsaWQgSlNXZWJBc3NlbWJseU1lbW9yeSB3aGVuIGNyZWF0ZWQsIHdoaWNoIGFsbG93 cwogICAgdGhlIHdhc20gLT4gd2FzbSBzdHViIHRvIGFzc3VtZSBpdCBpc24ndCBudWxsIHdoZW4g dHJ5aW5nIHRvIHNldCB0aGUgcGlubmVkCiAgICByZWdpc3RlcnMuCi0tLQogSlNUZXN0cy93YXNt L0J1aWxkZXIuanMgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgOTEgKysrKystLS0tCiBK U1Rlc3RzL3dhc20vTG93TGV2ZWxCaW5hcnkuanMgICAgICAgICAgICAgICAgICAgICB8ICAxMiAr KwogSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMgICAgICAgICAgfCAg IDYgKy0KIEpTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMgICAgICAgICAg IHwgICAyICstCiBKU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5qcyAgICAg ICAgICB8ICAgMiArLQogSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20tYmFkLXNpZ25h dHVyZS5qcyAgfCAxMDUgKysrKysrKysrKwogSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdh c20uanMgICAgICAgICAgICAgICAgfCAgNzIgKysrKysrKwogU291cmNlL0phdmFTY3JpcHRDb3Jl L0NNYWtlTGlzdHMudHh0ICAgICAgICAgICAgICAgfCAgIDEgKwogLi4uL0phdmFTY3JpcHRDb3Jl Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogICAgICAgfCAgIDggKy0KIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS9qc2MuY3BwICAgICAgICAgICAgICAgICAgICAgIHwgIDI1ICsrLQogLi4uL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvQWJzdHJhY3RNb2R1bGVSZWNvcmQuaCAgfCAgIDIgKy0KIFNvdXJj ZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTVHlwZS5oICAgICAgICAgICAgIHwgICAyICsKIFNv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcCAgIHwgMjIwICsr KysrKysrKysrKystLS0tLS0tLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJH ZW5lcmF0b3IuaCAgICAgfCAgIDIgKy0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21C aW5kaW5nLmNwcCAgICAgICAgIHwgIDY3ICsrKysrKy0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21CaW5kaW5nLmggICAgICAgICAgIHwgICAyICstCiBTb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtRm9ybWF0LmggICAgICAgICAgICB8ICAyOCArKy0KIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21GdW5jdGlvblBhcnNlci5oICAgIHwgIDE2ICstCiBTb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmNwcCAgICAgICAgICB8ICA1NyArKysrKy0KIFNv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuaCAgICAgICAgICAgIHwgIDMxICsr LQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmNwcCAgfCAg NTkgKysrKy0tCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5SW5mb3JtYXRp b24uaCB8ICAgOSArLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNl ci5jcHAgICAgfCAgMjcgKystCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxl UGFyc2VyLmggICAgICB8ICAgMiArLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBh Z2VDb3VudC5jcHAgICAgICAgfCAgNDUgKysrKysKIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21QYWdlQ291bnQuaCAgICAgICAgIHwgICA2ICsKIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21QbGFuLmNwcCAgICAgICAgICAgIHwgIDQ0ICsrKy0tCiBTb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtUGxhbi5oICAgICAgICAgICAgICB8ICAxNCArLQogU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5jcHAgICAgICAgfCAgMTggKy0KIFNvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuaCAgICAgICAgIHwgICAxICsKIFNvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5jcHAgICAgICAgIHwgICA0ICstCiBT b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuaCAgICAgICAgICB8ICAgMiAr LQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseUluc3RhbmNlLmggfCAg MTEgKy0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuY3Bw IHwgIDEyICstCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5 LmggICB8ICAxMyArLQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1v ZHVsZS5jcHAgfCAgIDkgKy0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1i bHlNb2R1bGUuaCAgIHwgIDE2ICstCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3Nl bWJseUZ1bmN0aW9uLmNwcCB8ICAgOSArLQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2Vi QXNzZW1ibHlGdW5jdGlvbi5oICAgfCAgIDggKy0KIC4uLi93YXNtL2pzL1dlYkFzc2VtYmx5SW5z dGFuY2VDb25zdHJ1Y3Rvci5jcHAgICAgIHwgIDIwICstCiAuLi4vd2FzbS9qcy9XZWJBc3NlbWJs eU1lbW9yeUNvbnN0cnVjdG9yLmNwcCAgICAgICB8ICAgMiArLQogLi4uL3dhc20vanMvV2ViQXNz ZW1ibHlNb2R1bGVDb25zdHJ1Y3Rvci5jcHAgICAgICAgfCAgIDIgKy0KIC4uLi93YXNtL2pzL1dl YkFzc2VtYmx5TW9kdWxlUmVjb3JkLmNwcCAgICAgICAgICAgIHwgICA5ICstCiAuLi4vd2FzbS9q cy9XZWJBc3NlbWJseU1vZHVsZVJlY29yZC5oICAgICAgICAgICAgICB8ICAgMiArLQogNDQgZmls ZXMgY2hhbmdlZCwgNzk1IGluc2VydGlvbnMoKyksIDMwMCBkZWxldGlvbnMoLSkKIGNyZWF0ZSBt b2RlIDEwMDY0NCBKU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS1iYWQtc2lnbmF0dXJl LmpzCiBjcmVhdGUgbW9kZSAxMDA2NDQgSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20u anMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFn ZUNvdW50LmNwcAoKZGlmZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9CdWlsZGVyLmpzIGIvSlNUZXN0 cy93YXNtL0J1aWxkZXIuanMKaW5kZXggZGE1ODRjNC4uMjZiYTY2ZSAxMDA2NDQKLS0tIGEvSlNU ZXN0cy93YXNtL0J1aWxkZXIuanMKKysrIGIvSlNUZXN0cy93YXNtL0J1aWxkZXIuanMKQEAgLTM4 LDcgKzM4LDcgQEAgY29uc3QgX2lzVmFsaWRWYWx1ZSA9ICh2YWx1ZSwgdHlwZSkgPT4gewogICAg IHN3aXRjaCAodHlwZSkgewogICAgIC8vIFdlIGFsbG93IGJvdGggc2lnbmVkIGFuZCB1bnNpZ25l ZCBudW1iZXJzLgogICAgIGNhc2UgImkzMiI6IHJldHVybiBNYXRoLnJvdW5kKHZhbHVlKSA9PT0g dmFsdWUgJiYgTExCLnZhcmludDMyTWluIDw9IHZhbHVlICYmIHZhbHVlIDw9IExMQi52YXJ1aW50 MzJNYXg7Ci0gICAgY2FzZSAiaTY0IjogdGhyb3cgbmV3IEVycm9yKGBVbmltcGxlbWVudGVkOiB2 YWx1ZSBjaGVjayBmb3IgJHt0eXBlfWApOyAvLyBGSVhNRSBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNDIwIDY0LWJpdCB2YWx1ZXMKKyAgICBjYXNlICJpNjQiOiBy ZXR1cm4gdHJ1ZTsgLy8gRklYTUUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTE2MzQyMCA2NC1iaXQgdmFsdWVzCiAgICAgY2FzZSAiZjMyIjogcmV0dXJuIHR5cGVvZih2 YWx1ZSkgPT09ICJudW1iZXIiICYmIGlzRmluaXRlKHZhbHVlKTsKICAgICBjYXNlICJmNjQiOiBy ZXR1cm4gdHlwZW9mKHZhbHVlKSA9PT0gIm51bWJlciIgJiYgaXNGaW5pdGUodmFsdWUpOwogICAg IGRlZmF1bHQ6IHRocm93IG5ldyBFcnJvcihgSW1wbGVtZW50YXRpb24gcHJvYmxlbTogdW5rbm93 biB0eXBlICR7dHlwZX1gKTsKQEAgLTU3LDYgKzU3LDE2IEBAIGNvbnN0IF9ub3JtYWxpemVGdW5j dGlvblNpZ25hdHVyZSA9IChwYXJhbXMsIHJldCkgPT4gewogICAgIHJldHVybiBbcGFyYW1zLCBy ZXRdOwogfTsKIAorY29uc3QgX2Vycm9ySGFuZGxpbmdQcm94eUZvciA9IGJ1aWxkZXIgPT4gYnVp bGRlclsiX19pc1Byb3h5Il0gPyBidWlsZGVyIDogbmV3IFByb3h5KGJ1aWxkZXIsIHsKKyAgICBn ZXQ6ICh0YXJnZXQsIHByb3BlcnR5LCByZWNlaXZlcikgPT4geworICAgICAgICBpZiAocHJvcGVy dHkgPT09ICJfX2lzUHJveHkiKQorICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIGlm ICh0YXJnZXRbcHJvcGVydHldID09PSB1bmRlZmluZWQpCisgICAgICAgICAgICB0aHJvdyBuZXcg RXJyb3IoYFdlYkFzc2VtYmx5IGJ1aWxkZXIgcmVjZWl2ZWQgdW5rbm93biBwcm9wZXJ0eSAnJHtw cm9wZXJ0eX0nYCk7CisgICAgICAgIHJldHVybiB0YXJnZXRbcHJvcGVydHldOworICAgIH0KK30p OworCiBjb25zdCBfbWF5YmVSZWdpc3RlclR5cGUgPSAoYnVpbGRlciwgdHlwZSkgPT4gewogICAg IGNvbnN0IHR5cGVTZWN0aW9uID0gYnVpbGRlci5fZ2V0U2VjdGlvbigiVHlwZSIpOwogICAgIGlm ICh0eXBlb2YodHlwZSkgPT09ICJudW1iZXIiKSB7CkBAIC0xMDAsNyArMTEwLDcgQEAgY29uc3Qg X2ltcG9ydEZ1bmN0aW9uQ29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWls ZGVyKSA9PiB7CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHsgZmllbGQ6IGZpZWxkLCB0eXBl OiB0eXBlLCBraW5kOiAiRnVuY3Rpb24iLCBtb2R1bGU6IG1vZHVsZSB9KTsKICAgICAgICAgLy8g SW1wb3J0cyBhbHNvIGNvdW50IGluIHRoZSBmdW5jdGlvbiBpbmRleCBzcGFjZS4gTWFwIHRoZW0g YXMgb2JqZWN0cyB0byBhdm9pZCBjbGFzaGluZyB3aXRoIENvZGUgZnVuY3Rpb25zJyBuYW1lcy4K ICAgICAgICAgYnVpbGRlci5fcmVnaXN0ZXJGdW5jdGlvblRvSW5kZXhTcGFjZSh7IG1vZHVsZTog bW9kdWxlLCBmaWVsZDogZmllbGQgfSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAg ICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH07 CiB9OwogCkBAIC0xMDksNyArMTE5LDcgQEAgY29uc3QgX2ltcG9ydE1lbW9yeUNvbnRpbnVhdGlv biA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgICAgICBhc3NlcnQu aXNTdHJpbmcobW9kdWxlLCBgSW1wb3J0IE1lbW9yeSBtb2R1bGUgc2hvdWxkIGJlIGEgc3RyaW5n LCBnb3QgIiR7bW9kdWxlfSJgKTsKICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKGZpZWxkLCBgSW1w b3J0IE1lbW9yeSBmaWVsZCBzaG91bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHtmaWVsZH0iYCk7CiAg ICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHttb2R1bGUsIGZpZWxkLCBraW5kOiAiTWVtb3J5Iiwg bWVtb3J5RGVzY3JpcHRpb246IHtpbml0aWFsLCBtYXhpbXVtfX0pOwotICAgICAgICByZXR1cm4g bmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRC dWlsZGVyKTsKICAgICB9OwogfTsKIApAQCAtMTE4LDcgKzEyOCw3IEBAIGNvbnN0IF9pbXBvcnRU YWJsZUNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewog ICAgICAgICBhc3NlcnQuaXNTdHJpbmcobW9kdWxlLCBgSW1wb3J0IFRhYmxlIG1vZHVsZSBzaG91 bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHttb2R1bGV9ImApOwogICAgICAgICBhc3NlcnQuaXNTdHJp bmcoZmllbGQsIGBJbXBvcnQgVGFibGUgZmllbGQgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7 ZmllbGR9ImApOwogICAgICAgICBzZWN0aW9uLmRhdGEucHVzaCh7bW9kdWxlLCBmaWVsZCwga2lu ZDogIlRhYmxlIiwgdGFibGVEZXNjcmlwdGlvbjoge2luaXRpYWwsIG1heGltdW0sIGVsZW1lbnR9 fSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhh bmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH07CiB9OwogCkBAIC0xNzIsNyArMTgy LDcgQEAgY29uc3QgX2V4cG9ydEZ1bmN0aW9uQ29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rp b24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAgICAgICAgICAgYXNzZXJ0LmVxKHR5cGUsIGV4 cG9ydGVkSW1wb3J0LnR5cGUsIGBSZS1leHBvcnRpbmcgaW1wb3J0ICIke2V4cG9ydGVkSW1wb3J0 LmZpZWxkfSIgYXMgIiR7ZmllbGR9IiBoYXMgbWlzbWF0Y2hpbmcgdHlwZWApOwogICAgICAgICB9 CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHsgZmllbGQ6IGZpZWxkLCB0eXBlOiB0eXBlLCBr aW5kOiAiRnVuY3Rpb24iLCBpbmRleDogaW5kZXggfSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVp bGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIp OwogICAgIH07CiB9OwogCkBAIC0xODksNyArMTk5LDcgQEAgY29uc3QgX2V4cG9ydEdsb2JhbENv bnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgIHJl dHVybiAoZmllbGQsIGluZGV4KSA9PiB7CiAgICAgICAgIGFzc2VydC5pc051bWJlcihpbmRleCwg YEdsb2JhbCBleHBvcnRzIG9ubHkgc3VwcG9ydCBudW1iZXIgaW5kaWNlcyByaWdodCBub3dgKTsK ICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2goeyBmaWVsZCwga2luZDogIkdsb2JhbCIsIGluZGV4 IH0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JI YW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9CiB9OwogCkBAIC0xOTcsNyArMjA3 LDcgQEAgY29uc3QgX2V4cG9ydE1lbW9yeUNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9u LCBuZXh0QnVpbGRlcikgPT4gewogICAgIHJldHVybiAoZmllbGQsIGluZGV4KSA9PiB7CiAgICAg ICAgIGFzc2VydC5pc051bWJlcihpbmRleCwgYE1lbW9yeSBleHBvcnRzIG9ubHkgc3VwcG9ydCBu dW1iZXIgaW5kaWNlc2ApOwogICAgICAgICBzZWN0aW9uLmRhdGEucHVzaCh7ZmllbGQsIGtpbmQ6 ICJNZW1vcnkiLCBpbmRleH0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAg IHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9CiB9Owog CkBAIC0yMDUsNyArMjE1LDcgQEAgY29uc3QgX2V4cG9ydFRhYmxlQ29udGludWF0aW9uID0gKGJ1 aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgcmV0dXJuIChmaWVsZCwgaW5k ZXgpID0+IHsKICAgICAgICAgYXNzZXJ0LmlzTnVtYmVyKGluZGV4LCBgVGFibGUgZXhwb3J0cyBv bmx5IHN1cHBvcnQgbnVtYmVyIGluZGljZXNgKTsKICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2go e2ZpZWxkLCBraW5kOiAiVGFibGUiLCBpbmRleH0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxk ZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsK ICAgICB9CiB9OwogCkBAIC0yMjAsMTAgKzIzMCwxMCBAQCBjb25zdCBfaW1wb3J0R2xvYmFsQ29u dGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAg ICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKGZpZWxkLCBgSW1wb3J0IGdsb2JhbCBmaWVsZCBzaG91 bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHtmaWVsZH0iYCk7CiAgICAgICAgICAgICAgICAgYXNzZXJ0 LmlzU3RyaW5nKG11dGFiaWxpdHksIGBJbXBvcnQgZ2xvYmFsIG11dGFiaWxpdHkgc2hvdWxkIGJl IGEgc3RyaW5nLCBnb3QgIiR7bXV0YWJpbGl0eX0iYCk7CiAgICAgICAgICAgICAgICAgc2VjdGlv bi5kYXRhLnB1c2goeyBnbG9iYWxEZXNjcmlwdGlvbjogeyB0eXBlOiBvcCwgbXV0YWJpbGl0eTog X25vcm1hbGl6ZU11dGFiaWxpdHkobXV0YWJpbGl0eSkgfSwgbW9kdWxlLCBmaWVsZCwga2luZDog Ikdsb2JhbCIgfSk7Ci0gICAgICAgICAgICAgICAgcmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAg ICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7 CiAgICAgICAgICAgICB9OwogICAgICAgICB9Ci0gICAgICAgIHJldHVybiBnbG9iYWxCdWlsZGVy OworICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsK ICAgICB9OwogfTsKIApAQCAtMzI0LDExICszMzQsMTEgQEAgY29uc3QgX2NyZWF0ZUZ1bmN0aW9u QnVpbGRlciA9IChmdW5jLCBidWlsZGVyLCBwcmV2aW91c0J1aWxkZXIpID0+IHsKICAgICAgICAg ICAgIGRlZmF1bHQ6CiAgICAgICAgICAgICAgICAgbmV4dEJ1aWxkZXIgPSBmdW5jdGlvbkJ1aWxk ZXI7CiAgICAgICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgICAgICAgICAgY2FzZSAiRW5kIjoK KyAgICAgICAgICAgIGNhc2UgIkVuZCI6CiAgICAgICAgICAgICAgICAgbmV4dEJ1aWxkZXIgPSBw cmV2aW91c0J1aWxkZXI7Ci0gICAgICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAg ICAgIGJyZWFrOwogICAgICAgICAgICAgY2FzZSAiQmxvY2siOgotICAgICAgICAgICAgICAgIGNh c2UgIkxvb3AiOgorICAgICAgICAgICAgY2FzZSAiTG9vcCI6CiAgICAgICAgICAgICBjYXNlICJJ ZiI6CiAgICAgICAgICAgICAgICAgbmV4dEJ1aWxkZXIgPSBfY3JlYXRlRnVuY3Rpb25CdWlsZGVy KGZ1bmMsIGJ1aWxkZXIsIGZ1bmN0aW9uQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgYnJlYWs7 CkBAIC0zNDQsMTEgKzM1NCwxMiBAQCBjb25zdCBfY3JlYXRlRnVuY3Rpb25CdWlsZGVyID0gKGZ1 bmMsIGJ1aWxkZXIsIHByZXZpb3VzQnVpbGRlcikgPT4gewogICAgICAgICAgICAgY29uc3Qgc3Rh Y2tBcmdzID0gW107IC8vIEZJWE1FIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xNjI3MDYKICAgICAgICAgICAgIGZ1bmMuY29kZS5wdXNoKHsgbmFtZTogb3AsIHZhbHVl OiB2YWx1ZSwgYXJndW1lbnRzOiBzdGFja0FyZ3MsIGltbWVkaWF0ZXM6IGltbXMgfSk7CiAgICAg ICAgICAgICBpZiAoaGFzQ29udGludWF0aW9uKQotICAgICAgICAgICAgICAgIHJldHVybiBjb250 aW51YXRpb24obmV4dEJ1aWxkZXIpLkVuZCgpOwotICAgICAgICAgICAgcmV0dXJuIG5leHRCdWls ZGVyOworICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGNvbnRp bnVhdGlvbihuZXh0QnVpbGRlcikuRW5kKCkpOworICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhh bmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgICAgICB9OwotICAgIH0KLSAgICByZXR1 cm4gZnVuY3Rpb25CdWlsZGVyOworICAgIH07CisKKyAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQ cm94eUZvcihmdW5jdGlvbkJ1aWxkZXIpOwogfQogCiBjb25zdCBfY3JlYXRlRnVuY3Rpb24gPSAo c2VjdGlvbiwgYnVpbGRlciwgcHJldmlvdXNCdWlsZGVyKSA9PiB7CkBAIC00NDksMTAgKzQ2MCwx MCBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAg ICAgIEZ1bmM6IChwYXJhbXMsIHJldCkgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAg IFtwYXJhbXMsIHJldF0gPSBfbm9ybWFsaXplRnVuY3Rpb25TaWduYXR1cmUocGFyYW1zLCByZXQp OwogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKHsgcGFyYW1zOiBwYXJh bXMsIHJldDogcmV0IH0pOwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiB0eXBl QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxp bmdQcm94eUZvcih0eXBlQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICB9LAogICAg ICAgICAgICAgICAgICAgICB9OwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gdHlwZUJ1aWxk ZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHR5 cGVCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwog CkBAIC00NjYsNyArNDc3LDcgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAg ICAgICAgICAgICAgICAgIGltcG9ydEJ1aWxkZXIuRnVuY3Rpb24gPSBfaW1wb3J0RnVuY3Rpb25D b250aW51YXRpb24odGhpcywgcywgaW1wb3J0QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAg IGltcG9ydEJ1aWxkZXIuTWVtb3J5ID0gX2ltcG9ydE1lbW9yeUNvbnRpbnVhdGlvbih0aGlzLCBz LCBpbXBvcnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgaW1wb3J0QnVpbGRlci5UYWJs ZSA9IF9pbXBvcnRUYWJsZUNvbnRpbnVhdGlvbih0aGlzLCBzLCBpbXBvcnRCdWlsZGVyKTsKLSAg ICAgICAgICAgICAgICAgICAgcmV0dXJuIGltcG9ydEJ1aWxkZXI7CisgICAgICAgICAgICAgICAg ICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGltcG9ydEJ1aWxkZXIpOwogICAgICAg ICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTQ3Nyw3ICs0ODgsNyBA QCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAg IEVuZDogKCkgPT4gdGhpcwogICAgICAgICAgICAgICAgICAgICAgICAgLy8gRklYTUU6IGFkZCBh YmlsaXR5IHRvIGFkZCB0aGlzIHdpdGggd2hhdGV2ZXIuCiAgICAgICAgICAgICAgICAgICAgIH07 Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiBmdW5jdGlvbkJ1aWxkZXI7CisgICAgICAgICAg ICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGZ1bmN0aW9uQnVpbGRlcik7 CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNDg4LDEw ICs0OTksMTAgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAg ICAgICAgICAgICBFbmQ6ICgpID0+IHRoaXMsCiAgICAgICAgICAgICAgICAgICAgICAgICBUYWJs ZTogKHtpbml0aWFsLCBtYXhpbXVtLCBlbGVtZW50fSkgPT4gewogICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHMuZGF0YS5wdXNoKHt0YWJsZURlc2NyaXB0aW9uOiB7aW5pdGlhbCwgbWF4aW11 bSwgZWxlbWVudH19KTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gdGFibGVC dWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGlu Z1Byb3h5Rm9yKHRhYmxlQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAg ICAgICAgICAgICAgICAgIH07Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiB0YWJsZUJ1aWxk ZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHRh YmxlQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsK IApAQCAtNTAyLDEwICs1MTMsMTAgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAg ICAgICAgICAgICAgICAgICAgICAgICBFbmQ6ICgpID0+IHRoaXMsCiAgICAgICAgICAgICAgICAg ICAgICAgICBJbml0aWFsTWF4UGFnZXM6IChpbml0aWFsLCBtYXgpID0+IHsKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaCh7IGluaXRpYWwsIG1heCB9KTsKLSAgICAgICAg ICAgICAgICAgICAgICAgICAgICByZXR1cm4gbWVtb3J5QnVpbGRlcjsKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihtZW1vcnlCdWlsZGVy KTsKICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgfTsKLSAg ICAgICAgICAgICAgICAgICAgcmV0dXJuIG1lbW9yeUJ1aWxkZXI7CisgICAgICAgICAgICAgICAg ICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG1lbW9yeUJ1aWxkZXIpOwogICAgICAg ICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTUxNiwxNiArNTI3LDE2 IEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAg ICAgRW5kOiAoKSA9PiB0aGlzLAogICAgICAgICAgICAgICAgICAgICAgICAgR2V0R2xvYmFsOiAo dHlwZSwgaW5pdFZhbHVlLCBtdXRhYmlsaXR5KSA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgcy5kYXRhLnB1c2goeyB0eXBlLCBvcDogImdldF9nbG9iYWwiLCBtdXRhYmlsaXR5OiBf bm9ybWFsaXplTXV0YWJpbGl0eShtdXRhYmlsaXR5KSwgaW5pdFZhbHVlIH0pOwotICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHJldHVybiBnbG9iYWxCdWlsZGVyOworICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIp OwogICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICB9OwogICAg ICAgICAgICAgICAgICAgICBmb3IgKGxldCBvcCBvZiBXQVNNLmRlc2NyaXB0aW9uLnZhbHVlX3R5 cGUpIHsKICAgICAgICAgICAgICAgICAgICAgICAgIGdsb2JhbEJ1aWxkZXJbX3RvSmF2YVNjcmlw dE5hbWUob3ApXSA9IChpbml0VmFsdWUsIG11dGFiaWxpdHkpID0+IHsKICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBzLmRhdGEucHVzaCh7IHR5cGU6IG9wLCBvcDogb3AgKyAiLmNvbnN0Iiwg bXV0YWJpbGl0eTogX25vcm1hbGl6ZU11dGFiaWxpdHkobXV0YWJpbGl0eSksIGluaXRWYWx1ZSB9 KTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihn bG9iYWxCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAg ICAgICAgIH0KLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAg ICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxk ZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTUz OSw3ICs1NTAsNyBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAg ICAgICAgICAgZXhwb3J0QnVpbGRlci5GdW5jdGlvbiA9IF9leHBvcnRGdW5jdGlvbkNvbnRpbnVh dGlvbih0aGlzLCBzLCBleHBvcnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgZXhwb3J0 QnVpbGRlci5NZW1vcnkgPSBfZXhwb3J0TWVtb3J5Q29udGludWF0aW9uKHRoaXMsIHMsIGV4cG9y dEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICBleHBvcnRCdWlsZGVyLlRhYmxlID0gX2V4 cG9ydFRhYmxlQ29udGludWF0aW9uKHRoaXMsIHMsIGV4cG9ydEJ1aWxkZXIpOwotICAgICAgICAg ICAgICAgICAgICByZXR1cm4gZXhwb3J0QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0 dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZXhwb3J0QnVpbGRlcik7CiAgICAgICAgICAgICAg ICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNTUyLDcgKzU2Myw3IEBAIGV4cG9y dCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICBpZiAodHlwZW9m KGZ1bmN0aW9uSW5kZXhPck5hbWUpICE9PSAibnVtYmVyIiAmJiB0eXBlb2YoZnVuY3Rpb25JbmRl eE9yTmFtZSkgIT09ICJzdHJpbmciKQogICAgICAgICAgICAgICAgICAgICAgICAgdGhyb3cgbmV3 IEVycm9yKGBTdGFydCBzZWN0aW9uJ3MgZnVuY3Rpb24gaW5kZXggIG11c3QgZWl0aGVyIGJlIGEg bnVtYmVyIG9yIGEgc3RyaW5nYCk7CiAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKGZ1 bmN0aW9uSW5kZXhPck5hbWUpOwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gc3RhcnRCdWls ZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihz dGFydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7 CiAKQEAgLTU2MywxMSArNTc0LDExIEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewog ICAgICAgICAgICAgICAgICAgICAgICAgRW5kOiAoKSA9PiB0aGlzLAogICAgICAgICAgICAgICAg ICAgICAgICAgRWxlbWVudDogKHt0YWJsZUluZGV4ID0gMCwgb2Zmc2V0LCBmdW5jdGlvbkluZGlj ZXN9KSA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcy5kYXRhLnB1c2goe3RhYmxl SW5kZXgsIG9mZnNldCwgZnVuY3Rpb25JbmRpY2VzfSk7Ci0gICAgICAgICAgICAgICAgICAgICAg ICAgICAgcmV0dXJuIGVsZW1lbnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAg IHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGVsZW1lbnRCdWlsZGVyKTsKICAgICAgICAg ICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgfTsKIAotICAgICAgICAgICAg ICAgICAgICByZXR1cm4gZWxlbWVudEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVy biBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGVsZW1lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAg ICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC02MzIsMTIgKzY0MywxMiBAQCBleHBv cnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIC8vIEZJWE1FIGluIGNoZWNrZWQgbW9kZSwgdGVzdCB0aGF0IHRoZSB0eXBlIGlzIGFj Y2VwdGFibGUgZm9yIHN0YXJ0IGZ1bmN0aW9uLiBXZSBwcm9iYWJseSB3YW50IF9yZWdpc3RlckZ1 bmN0aW9uVG9JbmRleFNwYWNlIHRvIGFsc28gcmVnaXN0ZXIgdHlwZXMgcGVyIGluZGV4LiBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1NjU4CiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9Ci0gICAg ICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGJ1aWxkZXI7CisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoYnVpbGRlcik7CiAgICAg ICAgICAgICAgICAgICAgICAgICB9LAogCiAgICAgICAgICAgICAgICAgICAgIH07CiAgICAgICAg ICAgICAgICAgICAgIGNvZGVCdWlsZGVyLkZ1bmN0aW9uID0gX2NyZWF0ZUZ1bmN0aW9uKHMsIGJ1 aWxkZXIsIGNvZGVCdWlsZGVyKTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGNvZGVCdWls ZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihj b2RlQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsK IApAQCAtNjYwLDE5ICs2NzEsMTkgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEluZGV4OiBpbmRleCA9PiB7CiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhc3NlcnQuZXEoaW5kZXgsIDApOyAvLyBMaW5l YXIgbWVtb3J5IGluZGV4IG11c3QgYmUgemVybyBpbiBNVlAuCiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB0aGlzU2VnbWVudC5pbmRleCA9IGluZGV4OwotICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHNlZ21lbnRCdWlsZGVyOworICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3Io c2VnbWVudEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9LAogICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBPZmZzZXQ6IG9mZnNldCA9PiB7CiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyBGSVhNRSBhbGxvdyBjb21wbGV4IGluaXRf ZXhwciBoZXJlLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1NzAw CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhc3NlcnQuaXNOdW1iZXIob2Zm c2V0KTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRoaXNTZWdtZW50Lm9m ZnNldCA9IG9mZnNldDsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVy biBzZWdtZW50QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJl dHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHNlZ21lbnRCdWlsZGVyKTsKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgfSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9Owot ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBzZWdtZW50QnVpbGRlcjsKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihzZWdt ZW50QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICB9LAogICAgICAgICAgICAgICAg ICAgICB9OwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gZGF0YUJ1aWxkZXI7CisgICAgICAg ICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGRhdGFCdWlsZGVyKTsK ICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC02OTAsMTAg KzcwMSwxMCBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAg ICBCeXRlOiBiID0+IHsKICAgICAgICAgICAgICAgICAgICAgYXNzZXJ0LmVxKGIgJiAweEZGLCBi LCBgVW5rbm93biBzZWN0aW9uIGV4cGVjdGVkIGJ5dGUsIGdvdDogIiR7Yn0iYCk7CiAgICAgICAg ICAgICAgICAgICAgIHMuZGF0YS5wdXNoKGIpOwotICAgICAgICAgICAgICAgICAgICByZXR1cm4g dW5rbm93bkJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGlu Z1Byb3h5Rm9yKHVua25vd25CdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAg ICB9OwotICAgICAgICAgICAgcmV0dXJuIHVua25vd25CdWlsZGVyOworICAgICAgICAgICAgcmV0 dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IodW5rbm93bkJ1aWxkZXIpOwogICAgICAgICB9Owog ICAgIH0KICAgICBfYWRkU2VjdGlvbihuYW1lT3JOdW1iZXIsIGV4dHJhT2JqZWN0KSB7CmRpZmYg LS1naXQgYS9KU1Rlc3RzL3dhc20vTG93TGV2ZWxCaW5hcnkuanMgYi9KU1Rlc3RzL3dhc20vTG93 TGV2ZWxCaW5hcnkuanMKaW5kZXggNjExYTI2ZC4uZjliYzhhMyAxMDA2NDQKLS0tIGEvSlNUZXN0 cy93YXNtL0xvd0xldmVsQmluYXJ5LmpzCisrKyBiL0pTVGVzdHMvd2FzbS9Mb3dMZXZlbEJpbmFy eS5qcwpAQCAtMTcwLDYgKzE3MCwxOCBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBMb3dMZXZlbEJp bmFyeSB7CiAgICAgICAgICAgICB0aGlzLnVpbnQ4KDB4ODAgfCBiKTsKICAgICAgICAgfSB3aGls ZSAodHJ1ZSk7CiAgICAgfQorICAgIHZhcnVpbnQ2NCh2KSB7CisgICAgICAgIGFzc2VydC5pc051 bWJlcih2KTsKKyAgICAgICAgaWYgKHYgPCB2YXJ1aW50MzJNaW4gfHwgdmFydWludDMyTWF4IDwg dikKKyAgICAgICAgICAgIHRocm93IG5ldyBSYW5nZUVycm9yKGB1bmltcGxlbWVudGVkOiB2YXJ1 aW50NjQgbGFyZ2VyIHRoYW4gMzItYml0YCk7CisgICAgICAgIHRoaXMudmFydWludDMyKHYpOyAv LyBGSVhNRSBpbXBsZW1lbnQgNjQtYml0IHZhcnt1fWludCBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNDIwCisgICAgfQorICAgIHZhcmludDY0KHYpIHsKKyAgICAg ICAgYXNzZXJ0LmlzTnVtYmVyKHYpOworICAgICAgICBpZiAodiA8IHZhcmludDMyTWluIHx8IHZh cmludDMyTWF4IDwgdikKKyAgICAgICAgICAgIHRocm93IG5ldyBSYW5nZUVycm9yKGB1bmltcGxl bWVudGVkOiB2YXJpbnQ2NCBsYXJnZXIgdGhhbiAzMi1iaXRgKTsKKyAgICAgICAgdGhpcy52YXJp bnQzMih2KTsgLy8gRklYTUUgaW1wbGVtZW50IDY0LWJpdCB2YXJ7dX1pbnQgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MzQyMAorICAgIH0KICAgICB2YXJ1aW50MSh2 KSB7CiAgICAgICAgIGlmICh2ICE9PSAwICYmIHYgIT09IDEpCiAgICAgICAgICAgICB0aHJvdyBu ZXcgUmFuZ2VFcnJvcihgSW52YWxpZCB2YXJ1aW50MSAke3Z9IHJhbmdlIGlzIFswLCAxXWApOwpk aWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMgYi9K U1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvZXhjZXB0aW9ucy5qcwppbmRleCBkMmIzYTQ5Li45 NTI1MTNmIDEwMDY0NAotLS0gYS9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvZXhjZXB0aW9u cy5qcworKysgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvZXhjZXB0aW9ucy5qcwpAQCAt NDUsMTggKzQ1LDE4IEBAIGZ1bmN0aW9uIG1ha2VJbnN0YW5jZSgpIHsKICAgICBhc3NlcnQuZXEo dGFibGUuZ2V0KDApLCBudWxsKTsKIAogICAgIGZvciAobGV0IGkgPSAwOyBpIDwgMTAwMDsgaSsr KSB7Ci0gICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDAsIGkpLCBXZWJBc3NlbWJseS5S dW50aW1lRXJyb3IsICJjYWxsX2luZGlyZWN0IHRvIGEgbnVsbCB0YWJsZSBlbnRyeSAoZXZhbHVh dGluZyAnZnVuYyguLi5hcmdzKScpIik7CisgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9v KDAsIGkpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJjYWxsX2luZGlyZWN0IHRvIGEgbnVs bCB0YWJsZSBlbnRyeSIpOwogICAgIH0KIAogICAgIHRhYmxlLnNldCgwLCBmb28pOwogICAgIGFz c2VydC5lcSh0YWJsZS5nZXQoMCksIGZvbyk7CiAKICAgICBmb3IgKGxldCBpID0gMDsgaSA8IDEw MDA7IGkrKykgewotICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbygxICsgaSwgaSksIFdl YkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgIk91dCBvZiBib3VuZHMgY2FsbF9pbmRpcmVjdCAoZXZh bHVhdGluZyAnZnVuYyguLi5hcmdzKScpIik7CisgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4g Zm9vKDEgKyBpLCBpKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9yLCAiT3V0IG9mIGJvdW5kcyBj YWxsX2luZGlyZWN0Iik7CiAgICAgfQogCiAgICAgZm9yIChsZXQgaSA9IDA7IGkgPCAxMDAwOyBp KyspIHsKLSAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBmb28oMCwgaSksIFdlYkFzc2VtYmx5 LlJ1bnRpbWVFcnJvciwgImNhbGxfaW5kaXJlY3QgdG8gYSBzaWduYXR1cmUgdGhhdCBkb2VzIG5v dCBtYXRjaCAoZXZhbHVhdGluZyAnZnVuYyguLi5hcmdzKScpIik7CisgICAgICAgIGFzc2VydC50 aHJvd3MoKCkgPT4gZm9vKDAsIGkpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJjYWxsX2lu ZGlyZWN0IHRvIGEgc2lnbmF0dXJlIHRoYXQgZG9lcyBub3QgbWF0Y2giKTsKICAgICB9CiAKICAg ICB0YWJsZS5zZXQoMCwgYmFyKTsKZGlmZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10 ZXN0cy90cmFwLWxvYWQuanMgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2Fk LmpzCmluZGV4IDRkZDgyZGMuLjEyMzFlMDMgMTAwNjQ0Ci0tLSBhL0pTVGVzdHMvd2FzbS9mdW5j dGlvbi10ZXN0cy90cmFwLWxvYWQuanMKKysrIGIvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3Rz L3RyYXAtbG9hZC5qcwpAQCAtMjksNiArMjksNiBAQCBmdW5jdGlvbiB3YXNtRnJhbWVDb3VudEZy b21FcnJvcihlKSB7CiB9CiAKIGZvciAobGV0IGkgPSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0gICAg Y29uc3QgZSA9IGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKG51bVBhZ2VzICogcGFnZVNpemUgKyAx KSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9yLCAiT3V0IG9mIGJvdW5kcyBtZW1vcnkgYWNjZXNz IChldmFsdWF0aW5nICdmdW5jKC4uLmFyZ3MpJykiKTsKKyAgICBjb25zdCBlID0gYXNzZXJ0LnRo cm93cygoKSA9PiBmb28obnVtUGFnZXMgKiBwYWdlU2l6ZSArIDEpLCBXZWJBc3NlbWJseS5SdW50 aW1lRXJyb3IsICJPdXQgb2YgYm91bmRzIG1lbW9yeSBhY2Nlc3MiKTsKICAgICBhc3NlcnQuZXEo d2FzbUZyYW1lQ291bnRGcm9tRXJyb3IoZSksIDIpOwogfQpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93 YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtc3RvcmUuanMgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24t dGVzdHMvdHJhcC1zdG9yZS5qcwppbmRleCA1NTk4N2MyLi4zNjU3MTNhIDEwMDY0NAotLS0gYS9K U1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5qcworKysgYi9KU1Rlc3RzL3dh c20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5qcwpAQCAtMjUsNSArMjUsNSBAQCBjb25zdCBu dW1QYWdlcyA9IDEwOwogICAgIGNvbnN0IGZvbyA9IG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZSht b2R1bGUsIHthOiB7YjogbmV3IFdlYkFzc2VtYmx5Lk1lbW9yeSh7aW5pdGlhbDogbnVtUGFnZXN9 KX19KS5leHBvcnRzLmZvbzsKIAogICAgIGZvciAobGV0IGkgPSAwOyBpIDwgMTAwMDA7IGkrKykK LSAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBmb28oaSwgbnVtUGFnZXMgKiBwYWdlU2l6ZSAr IDEpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJPdXQgb2YgYm91bmRzIG1lbW9yeSBhY2Nl c3MgKGV2YWx1YXRpbmcgJ2Z1bmMoLi4uYXJncyknKSIpOworICAgICAgICBhc3NlcnQudGhyb3dz KCgpID0+IGZvbyhpLCBudW1QYWdlcyAqIHBhZ2VTaXplICsgMSksIFdlYkFzc2VtYmx5LlJ1bnRp bWVFcnJvciwgIk91dCBvZiBib3VuZHMgbWVtb3J5IGFjY2VzcyIpOwogfQpkaWZmIC0tZ2l0IGEv SlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20tYmFkLXNpZ25hdHVyZS5qcyBiL0pTVGVz dHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLWJhZC1zaWduYXR1cmUuanMKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZDY5YmEyYwotLS0gL2Rldi9udWxsCisrKyBiL0pTVGVz dHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLWJhZC1zaWduYXR1cmUuanMKQEAgLTAsMCArMSwx MDUgQEAKK2ltcG9ydCAqIGFzIGFzc2VydCBmcm9tICcuLi9hc3NlcnQuanMnOworaW1wb3J0IEJ1 aWxkZXIgZnJvbSAnLi4vQnVpbGRlci5qcyc7CisKK2NvbnN0IGltcG9ydE5hbWUgPSAicGllck9u ZSI7Citjb25zdCB0eXBlcyA9IFsiaTMyIiwgImk2NCIsICJmMzIiLCAiZjY0IiwgInZvaWQiXTsK K2NvbnN0IHR5cGVzTm9uVm9pZCA9IFsiaTMyIiwgImk2NCIsICJmMzIiLCAiZjY0Il07Citjb25z dCBzd2FwVHlwZSA9ICh0eXBlLCBpbmRleCkgPT4gdHlwZXNbKHR5cGVzLmluZGV4T2YodHlwZSkg KyBpbmRleCkgJSB0eXBlcy5sZW5ndGhdOworY29uc3Qgc3dhcFR5cGVOb25Wb2lkID0gKHR5cGUs IGluZGV4KSA9PiB0eXBlc05vblZvaWRbKHR5cGVzTm9uVm9pZC5pbmRleE9mKHR5cGUpICsgaW5k ZXgpICUgdHlwZXNOb25Wb2lkLmxlbmd0aF07CisKK2NvbnN0IHNpZ25hdHVyZXMgPSBbCisgICAg eyBwYXJhbXM6IFsiaTMyIl0sIHJldDogInZvaWQiIH0sCisgICAgeyBwYXJhbXM6IFsiaTY0Il0s IHJldDogInZvaWQiIH0sCisgICAgeyBwYXJhbXM6IFsiZjMyIl0sIHJldDogInZvaWQiIH0sCisg ICAgeyBwYXJhbXM6IFsiZjY0Il0sIHJldDogInZvaWQiIH0sCisgICAgeyBwYXJhbXM6IFsiaTMy Il0sIHJldDogImkzMiIgfSwKKyAgICB7IHBhcmFtczogWyJpNjQiXSwgcmV0OiAiaTY0IiB9LAor ICAgIHsgcGFyYW1zOiBbImYzMiJdLCByZXQ6ICJmMzIiIH0sCisgICAgeyBwYXJhbXM6IFsiZjY0 Il0sIHJldDogImY2NCIgfSwKKyAgICB7IHBhcmFtczogWyJpMzIiLCAiZjMyIl0sIHJldDogImkz MiIgfSwKKyAgICB7IHBhcmFtczogWyJmMzIiLCAiaTMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7 IHBhcmFtczogWyJpNjQiLCAiZjY0Il0sIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogWyJm NjQiLCAiaTY0Il0sIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogWyJpMzIiLCAiZjMyIiwg ImkzMiJdLCByZXQ6ICJpMzIiIH0sCisgICAgeyBwYXJhbXM6IFsiaTMyIiwgImYzMiIsICJpMzIi XSwgcmV0OiAiaTMyIiB9LAorICAgIHsgcGFyYW1zOiBbImk2NCIsICJmNjQiLCAiaTY0Il0sIHJl dDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogWyJpNjQiLCAiZjY0IiwgImk2NCJdLCByZXQ6ICJp NjQiIH0sCisgICAgeyBwYXJhbXM6IEFycmF5KDMyKS5maWxsKCJpMzIiKSwgcmV0OiAiaTY0IiB9 LAorICAgIHsgcGFyYW1zOiBBcnJheSgzMikuZmlsbCgiaTY0IiksIHJldDogImk2NCIgfSwKKyAg ICB7IHBhcmFtczogQXJyYXkoMzIpLmZpbGwoImYzMiIpLCByZXQ6ICJpNjQiIH0sCisgICAgeyBw YXJhbXM6IEFycmF5KDMyKS5maWxsKCJmNjQiKSwgcmV0OiAiaTY0IiB9LAorXTsKKworY29uc3Qg bWFrZUltcG9ydGVyID0gc2lnbmF0dXJlID0+IHsKKyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBC dWlsZGVyKCkpCisgICAgICAgIC5UeXBlKCkuRW5kKCkKKyAgICAgICAgLkltcG9ydCgpLkZ1bmN0 aW9uKCJleHBvcnRzIiwgaW1wb3J0TmFtZSwgc2lnbmF0dXJlKS5FbmQoKTsKKyAgICByZXR1cm4g bmV3IFdlYkFzc2VtYmx5Lk1vZHVsZShidWlsZGVyLldlYkFzc2VtYmx5KCkuZ2V0KCkpOworfTsK KworY29uc3QgbWFrZUltcG9ydGVlID0gc2lnbmF0dXJlID0+IHsKKyAgICBjb25zdCBidWlsZGVy ID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAgIC5UeXBlKCkuRW5kKCkKKyAgICAgICAgLkZ1bmN0 aW9uKCkuRW5kKCkKKyAgICAgICAgLkV4cG9ydCgpCisgICAgICAgICAgICAuRnVuY3Rpb24oaW1w b3J0TmFtZSkKKyAgICAgICAgLkVuZCgpCisgICAgICAgIC5Db2RlKCkKKyAgICAgICAgICAgIC5G dW5jdGlvbihpbXBvcnROYW1lLCBzaWduYXR1cmUpOworICAgIHN3aXRjaCAoc2lnbmF0dXJlLnJl dCkgeworICAgIGNhc2UgImkzMiI6IGJ1aWxkZXIuSTMyQ29uc3QoMCk7IGJyZWFrOworICAgIGNh c2UgImk2NCI6IGJ1aWxkZXIuSTY0Q29uc3QoMCk7IGJyZWFrOworICAgIGNhc2UgImYzMiI6IGJ1 aWxkZXIuRjMyQ29uc3QoMCk7IGJyZWFrOworICAgIGNhc2UgImY2NCI6IGJ1aWxkZXIuRjY0Q29u c3QoMCk7IGJyZWFrOworICAgIGNhc2UgInZvaWQiOiBicmVhazsKKyAgICB9CisgICAgcmV0dXJu IG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShuZXcgV2ViQXNzZW1ibHkuTW9kdWxlKGJ1aWxkZXIu UmV0dXJuKCkuRW5kKCkuRW5kKCkuV2ViQXNzZW1ibHkoKS5nZXQoKSkpOworfTsKKworKGZ1bmN0 aW9uIEJhZFNpZ25hdHVyZURyb3BTdGFydFBhcmFtcygpIHsKKyAgICBmb3IgKGxldCBzaWduYXR1 cmUgb2Ygc2lnbmF0dXJlcykgeworICAgICAgICBjb25zdCBpbXBvcnRlZSA9IG1ha2VJbXBvcnRl ZShzaWduYXR1cmUpOworICAgICAgICBmb3IgKGxldCBpID0gMTsgaSA8PSBzaWduYXR1cmUucGFy YW1zLmxlbmd0aDsgKytpKSB7CisgICAgICAgICAgICBjb25zdCBiYWRQYXJhbVNpZ25hdHVyZSA9 IHsgcGFyYW1zOiBzaWduYXR1cmUucGFyYW1zLnNsaWNlKGksIHNpZ25hdHVyZS5wYXJhbXMubGVu Z3RoKSwgcmV0OiBzaWduYXR1cmUucmV0IH07CisgICAgICAgICAgICBjb25zdCBpbXBvcnRlciA9 IG1ha2VJbXBvcnRlcihiYWRQYXJhbVNpZ25hdHVyZSk7CisgICAgICAgICAgICBhc3NlcnQudGhy b3dzKCgpID0+IG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpLCBX ZWJBc3NlbWJseS5MaW5rRXJyb3IsIGBpbXBvcnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBkb2Vz bid0IG1hdGNoIHRoZSBwcm92aWRlZCBXZWJBc3NlbWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSAo ZXZhbHVhdGluZyAnbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSkn KWApOworICAgICAgICB9CisgICAgfQorfSkoKTsKKworKGZ1bmN0aW9uIEJhZFNpZ25hdHVyZURy b3BFbmRQYXJhbXMoKSB7CisgICAgZm9yIChsZXQgc2lnbmF0dXJlIG9mIHNpZ25hdHVyZXMpIHsK KyAgICAgICAgY29uc3QgaW1wb3J0ZWUgPSBtYWtlSW1wb3J0ZWUoc2lnbmF0dXJlKTsKKyAgICAg ICAgZm9yIChsZXQgaSA9IDE7IGkgPCBzaWduYXR1cmUucGFyYW1zLmxlbmd0aDsgKytpKSB7Cisg ICAgICAgICAgICBjb25zdCBiYWRQYXJhbVNpZ25hdHVyZSA9IHsgcGFyYW1zOiBzaWduYXR1cmUu cGFyYW1zLnNsaWNlKDAsIGkpLCByZXQ6IHNpZ25hdHVyZS5yZXQgfTsKKyAgICAgICAgICAgIGNv bnN0IGltcG9ydGVyID0gbWFrZUltcG9ydGVyKGJhZFBhcmFtU2lnbmF0dXJlKTsKKyAgICAgICAg ICAgIGFzc2VydC50aHJvd3MoKCkgPT4gbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVy LCBpbXBvcnRlZSksIFdlYkFzc2VtYmx5LkxpbmtFcnJvciwgYGltcG9ydGVkIGZ1bmN0aW9uJ3Mg c2lnbmF0dXJlIGRvZXNuJ3QgbWF0Y2ggdGhlIHByb3ZpZGVkIFdlYkFzc2VtYmx5IGZ1bmN0aW9u J3Mgc2lnbmF0dXJlIChldmFsdWF0aW5nICduZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0 ZXIsIGltcG9ydGVlKScpYCk7CisgICAgICAgIH0KKyAgICB9Cit9KSgpOworCisoZnVuY3Rpb24g QmFkU2lnbmF0dXJlU3dhcFBhcmFtKCkgeworICAgIGZvciAobGV0IHNpZ25hdHVyZSBvZiBzaWdu YXR1cmVzKSB7CisgICAgICAgIGNvbnN0IGltcG9ydGVlID0gbWFrZUltcG9ydGVlKHNpZ25hdHVy ZSk7CisgICAgICAgIGZvciAobGV0IHNpZ25hdHVyZUluZGV4ID0gMDsgc2lnbmF0dXJlSW5kZXgg PCBzaWduYXR1cmUubGVuZ3RoOyArK3NpZ25hdHVyZUluZGV4KSB7CisgICAgICAgICAgICBmb3Ig KGxldCB0eXBlSW5kZXggPSAxOyB0eXBlSW5kZXggPCB0eXBlc05vblZvaWQubGVuZ3RoOyArK3R5 cGVJbmRleCkgeworICAgICAgICAgICAgICAgIGxldCBiYWRQYXJhbXMgPSBzaWduYXR1cmUucGFy YW1zLnNsaWNlKCk7CisgICAgICAgICAgICAgICAgYmFkUGFyYW1zW3NpZ25hdHVyZUluZGV4XSA9 IHN3YXBUeXBlTm9uVm9pZChiYWRQYXJhbXNbc2lnbmF0dXJlSW5kZXhdLCB0eXBlSW5kZXgpOwor ICAgICAgICAgICAgICAgIGNvbnN0IGJhZFBhcmFtU2lnbmF0dXJlID0geyBwYXJhbXM6IGJhZFBh cmFtcywgcmV0OiBzaWduYXR1cmUucmV0IH07CisgICAgICAgICAgICAgICAgY29uc3QgaW1wb3J0 ZXIgPSBtYWtlSW1wb3J0ZXIoYmFkUGFyYW1TaWduYXR1cmUpOworICAgICAgICAgICAgICAgIGFz c2VydC50aHJvd3MoKCkgPT4gbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBv cnRlZSksIFdlYkFzc2VtYmx5LkxpbmtFcnJvciwgYGltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0 dXJlIGRvZXNuJ3QgbWF0Y2ggdGhlIHByb3ZpZGVkIFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2ln bmF0dXJlIChldmFsdWF0aW5nICduZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGlt cG9ydGVlKScpYCk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9Cit9KSgpOworCiso ZnVuY3Rpb24gQmFkU2lnbmF0dXJlUmV0KCkgeworICAgIGZvciAobGV0IHNpZ25hdHVyZSBvZiBz aWduYXR1cmVzKSB7CisgICAgICAgIGNvbnN0IGltcG9ydGVlID0gbWFrZUltcG9ydGVlKHNpZ25h dHVyZSk7CisgICAgICAgIGZvciAobGV0IHR5cGVJbmRleCA9IDE7IHR5cGVJbmRleCA8IHR5cGVz Lmxlbmd0aDsgKyt0eXBlSW5kZXgpIHsKKyAgICAgICAgICAgIGNvbnN0IGJhZFBhcmFtU2lnbmF0 dXJlID0geyBwYXJhbXM6IHNpZ25hdHVyZS5wYXJhbXMsIHJldDogc3dhcFR5cGUoc2lnbmF0dXJl LnJldCwgdHlwZUluZGV4KSB9OworICAgICAgICAgICAgY29uc3QgaW1wb3J0ZXIgPSBtYWtlSW1w b3J0ZXIoYmFkUGFyYW1TaWduYXR1cmUpOworICAgICAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9 PiBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKSwgV2ViQXNzZW1i bHkuTGlua0Vycm9yLCBgaW1wb3J0ZWQgZnVuY3Rpb24ncyBzaWduYXR1cmUgZG9lc24ndCBtYXRj aCB0aGUgcHJvdmlkZWQgV2ViQXNzZW1ibHkgZnVuY3Rpb24ncyBzaWduYXR1cmUgKGV2YWx1YXRp bmcgJ25ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpJylgKTsKKyAg ICAgICAgfQorICAgIH0KK30pKCk7CmRpZmYgLS1naXQgYS9KU1Rlc3RzL3dhc20vanMtYXBpL3dh c20tdG8td2FzbS5qcyBiL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLmpzCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjUyNGU0NTMKLS0tIC9kZXYvbnVsbAorKysg Yi9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS5qcwpAQCAtMCwwICsxLDcyIEBACitp bXBvcnQgKiBhcyBhc3NlcnQgZnJvbSAnLi4vYXNzZXJ0LmpzJzsKK2ltcG9ydCBCdWlsZGVyIGZy b20gJy4uL0J1aWxkZXIuanMnOworCitjb25zdCBjYWxsZXJUb3BCaXRzID0gMHhDMEZFQkVFRjsK K2NvbnN0IGlubmVyUmV0dXJuSGkgPSAweERFQURGQUNFOworY29uc3QgaW5uZXJSZXR1cm5MbyA9 IDB4QzBGRUMwRkU7CisKK2NvbnN0IGNhbGxlck1vZHVsZSA9ICgpID0+IHsKKyAgICBjb25zdCBi dWlsZGVyID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAgIC5UeXBlKCkuRW5kKCkKKyAgICAgICAg LkltcG9ydCgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImV4cG9ydHMiLCAiY2FsbE1lIiwgeyBw YXJhbXM6IFsiaTY0Il0sIHJldDogImk2NCIgfSkKKyAgICAgICAgLkVuZCgpCisgICAgICAgIC5G dW5jdGlvbigpLkVuZCgpCisgICAgICAgIC5FeHBvcnQoKQorICAgICAgICAgICAgLkZ1bmN0aW9u KCJlbnRyeSIpCisgICAgICAgIC5FbmQoKQorICAgICAgICAuQ29kZSgpCisgICAgICAgICAgICAu RnVuY3Rpb24oImVudHJ5IiwgeyBwYXJhbXM6IFsiaTMyIl0sIHJldDogImkzMiIgfSwgWyJpNjQi XSkKKyAgICAgICAgICAgICAgICAuSTMyQ29uc3QoY2FsbGVyVG9wQml0cykuSTY0RXh0ZW5kVUkz MigpLkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRVSTMyKCkuSTY0U2hsKCkgLy8gKChpNjQpY2FsbGVy VG9wQml0cykgPDwgMzIKKyAgICAgICAgICAgICAgICAuR2V0TG9jYWwoMCkuSTY0RXh0ZW5kVUkz MigpCisgICAgICAgICAgICAgICAgLkk2NE9yKCkgLy8gdmFsdWU6IHBhcmFtIHwgKCgoaTY0KWNh bGxlclRvcEJpdHMgPDwgMzIpKQorICAgICAgICAgICAgICAgIC5DYWxsKDApIC8vIENhbGxzIGV4 cG9ydHMuY2FsbE1lKHBhcmFtIHwgKCgoaTY0KWNhbGxlclRvcEJpdHMpIDw8IDMyKSkuCisgICAg ICAgICAgICAgICAgLlRlZUxvY2FsKDEpLkkzMldyYXBJNjQoKSAvLyBsbzogKGkzMiljYWxsUmVz dWx0CisgICAgICAgICAgICAgICAgLkdldExvY2FsKDEpLkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRV STMyKCkuSTY0U2hyVSgpLkkzMldyYXBJNjQoKSAvLyBoaTogKGkzMikoY2FsbFJlc3VsdCA+PiAz MikKKyAgICAgICAgICAgICAgICAuSTMyWG9yKCkKKyAgICAgICAgICAgICAgICAuUmV0dXJuKCkK KyAgICAgICAgICAgIC5FbmQoKQorICAgICAgICAuRW5kKCk7CisgICAgcmV0dXJuIG5ldyBXZWJB c3NlbWJseS5Nb2R1bGUoYnVpbGRlci5XZWJBc3NlbWJseSgpLmdldCgpKTsKK307CisKK2NvbnN0 IGNhbGxlZU1vZHVsZSA9ICgpID0+IHsKKyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVy KCkpCisgICAgICAgIC5UeXBlKCkuRW5kKCkKKyAgICAgICAgLkltcG9ydCgpCisgICAgICAgICAg ICAuRnVuY3Rpb24oImltcCIsICJmdW5jIiwgeyBwYXJhbXM6IFsiaTMyIiwgImkzMiJdLCByZXQ6 ICJpMzIiIH0pCisgICAgICAgIC5FbmQoKQorICAgICAgICAuRnVuY3Rpb24oKS5FbmQoKQorICAg ICAgICAuRXhwb3J0KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigiY2FsbE1lIikKKyAgICAgICAg LkVuZCgpCisgICAgICAgIC5Db2RlKCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigiY2FsbE1lIiwg eyBwYXJhbXM6IFsiaTY0Il0sIHJldDogImk2NCIgfSkKKyAgICAgICAgICAgICAgICAuR2V0TG9j YWwoMCkuSTMyV3JhcEk2NCgpIC8vIGxvOiAoaTMyKXBhcmFtCisgICAgICAgICAgICAgICAgLkdl dExvY2FsKDApLkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRVSTMyKCkuSTY0U2hyVSgpLkkzMldyYXBJ NjQoKSAvLyBoaTogKGkzMikocGFyYW0gPj4gMzIpCisgICAgICAgICAgICAgICAgLkNhbGwoMCkg Ly8gQ2FsbHMgaW1wLmZ1bmMgd2l0aCB0aGUgNjQtYml0IHZhbHVlIGFzIGkzMiB7IGhpLCBsbyB9 LgorICAgICAgICAgICAgICAgIC5Ecm9wKCkKKyAgICAgICAgICAgICAgICAuSTMyQ29uc3QoaW5u ZXJSZXR1cm5IaSkuSTY0RXh0ZW5kVUkzMigpLkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRVSTMyKCku STY0U2hsKCkuSTMyQ29uc3QoaW5uZXJSZXR1cm5MbykuSTY0RXh0ZW5kVUkzMigpLkk2NE9yKCkg Ly8gKChpNjQpaGkgPDwgMzIpIHwgKGk2NClsbworICAgICAgICAgICAgICAgIC5SZXR1cm4oKQor ICAgICAgICAgICAgLkVuZCgpCisgICAgICAgIC5FbmQoKTsKKyAgICByZXR1cm4gbmV3IFdlYkFz c2VtYmx5Lk1vZHVsZShidWlsZGVyLldlYkFzc2VtYmx5KCkuZ2V0KCkpOworfTsKKworKGZ1bmN0 aW9uIFdhc21Ub1dhc20oKSB7CisgICAgbGV0IHZhbHVlOworICAgIGNvbnN0IGZ1bmMgPSAoaGks IGxvKSA9PiB7IHZhbHVlID0geyBoaTogaGksIGxvOiBsbyB9OyBwcmludChgJHtFcnJvci5zdGFj a31gKTsgcmV0dXJuIGhpIF4gbG87IH07CisgICAgY29uc3QgY2FsbGVlID0gbmV3IFdlYkFzc2Vt Ymx5Lkluc3RhbmNlKGNhbGxlZU1vZHVsZSgpLCB7IGltcDogeyBmdW5jOiBmdW5jIH0gfSk7Cisg ICAgY29uc3QgY2FsbGVyID0gbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGNhbGxlck1vZHVsZSgp LCBjYWxsZWUpOworICAgIGZvciAobGV0IGkgPSAwOyBpIDwgNDA5NjsgKytpKSB7CisgICAgICAg IGFzc2VydC5lcShjYWxsZXIuZXhwb3J0cy5lbnRyeShpKSwgaW5uZXJSZXR1cm5IaSBeIGlubmVy UmV0dXJuTG8pOworICAgICAgICBhc3NlcnQuZXEodmFsdWUuaGksIGNhbGxlclRvcEJpdHMpOwor ICAgICAgICBhc3NlcnQuZXEodmFsdWUubG8sIGkpOworICAgIH0KK30pKCk7CisKKworLy8gRklY TUU6IHRlc3Qgd2FzbS0+d2FzbSB1c2luZyAzMi1iaXQgdGhpbmdzIChpbmNsdWRpbmcgZmxvYXQp LCBhcyB3ZWxsIGFzIDY0LWJpdCBOYU5zIHRoYXQgZG9uJ3QgZ2V0IGNhbm9uaWNhbGl6ZWQKKy8v IEZJWE1FOiBkbyBhIHRocm93IHR3by1kZWVwCisvLyBGSVhNRTogY2hlY2sgdGhhdCB0aGUgZmly c3Qgd2FzbSdzIGluc3RhbmNlIGlzIGJhY2sgaW4gT0sgc3RhdGUgKHdpdGggdGFibGUgb3IgZ2xv YmFsPykKKy8vIEZJWE1FOiB0ZXN0IGNhbGxpbmcgdGhyb3VnaCBhIFRhYmxlCmRpZmYgLS1naXQg YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ01ha2VMaXN0cy50eHQgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ01ha2VMaXN0cy50eHQKaW5kZXggOTY5YTEyMy4uOWRlMWEzYSAxMDA2NDQKLS0tIGEv U291cmNlL0phdmFTY3JpcHRDb3JlL0NNYWtlTGlzdHMudHh0CisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9DTWFrZUxpc3RzLnR4dApAQCAtOTA1LDYgKzkwNSw3IEBAIHNldChKYXZhU2NyaXB0 Q29yZV9TT1VSQ0VTCiAgICAgd2FzbS9XYXNtTWVtb3J5LmNwcAogICAgIHdhc20vV2FzbU1lbW9y eUluZm9ybWF0aW9uLmNwcAogICAgIHdhc20vV2FzbU1vZHVsZVBhcnNlci5jcHAKKyAgICB3YXNt L1dhc21QYWdlQ291bnQuY3BwCiAgICAgd2FzbS9XYXNtUGxhbi5jcHAKICAgICB3YXNtL1dhc21T aWduYXR1cmUuY3BwCiAgICAgd2FzbS9XYXNtVmFsaWRhdGUuY3BwCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv aiBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVj dC5wYnhwcm9qCmluZGV4IGQ5MzI1NmIuLjExNjM2OWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCkBAIC0xMjM1LDYgKzEyMzUsNyBAQAogCQkyQURGQTI2MzE4RUYzNTQwMDA0RjlGQ0Mg LyogR0NMb2dnaW5nLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDJBREZBMjYyMThFRjM1NDAwMDRGOUZDQyAvKiBHQ0xvZ2dpbmcuY3BwICovOyB9Owog CQkyQUY3MzgyQzE4QkJCRjkyMDA4QTVBMzcgLyogU3RydWN0dXJlSURUYWJsZS5jcHAgaW4gU291 cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAyQUY3MzgyQTE4QkJCRjky MDA4QTVBMzcgLyogU3RydWN0dXJlSURUYWJsZS5jcHAgKi87IH07CiAJCTJBRjczODJEMThCQkJG OTIwMDhBNUEzNyAvKiBTdHJ1Y3R1cmVJRFRhYmxlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAyQUY3MzgyQjE4QkJCRjkyMDA4QTVBMzcgLyogU3RydWN0 dXJlSURUYWJsZS5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07 IH07CisJCTJEMzQyRjM2RjcyNDQwOTY4MDRBREIyNCAvKiBTb3VyY2VPcmlnaW4uaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQyNUJBMTMzN0U0MzQ0RTFC MjY5QTY3MSAvKiBTb3VyY2VPcmlnaW4uaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQ cml2YXRlLCApOyB9OyB9OwogCQkzNzFEODQyRDE3Qzk4QjZFMDBFQ0Y5OTQgLyogbGliei5keWxp YiBpbiBGcmFtZXdvcmtzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDM3MUQ4 NDJDMTdDOThCNkUwMEVDRjk5NCAvKiBsaWJ6LmR5bGliICovOyB9OwogCQk0MTI5NTI3NzFEMkNG NkJDMDBFNzhCODkgLyogYnVpbHRpbnNfZ2VuZXJhdGVfaW50ZXJuYWxzX3dyYXBwZXJfaGVhZGVy LnB5IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDEyOTUy NzMxRDJDRjZBQzAwRTc4Qjg5IC8qIGJ1aWx0aW5zX2dlbmVyYXRlX2ludGVybmFsc193cmFwcGVy X2hlYWRlci5weSAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9 OwogCQk0MTI5NTI3ODFEMkNGNkJDMDBFNzhCODkgLyogYnVpbHRpbnNfZ2VuZXJhdGVfaW50ZXJu YWxzX3dyYXBwZXJfaW1wbGVtZW50YXRpb24ucHkgaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSA0MTI5NTI3NDFEMkNGNkFDMDBFNzhCODkgLyogYnVpbHRpbnNf Z2VuZXJhdGVfaW50ZXJuYWxzX3dyYXBwZXJfaW1wbGVtZW50YXRpb24ucHkgKi87IHNldHRpbmdz ID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKQEAgLTIwMjUsNiArMjAyNiw3IEBA CiAJCUFENzQzOEMwMUUwNDU3QTQwMEZEMEMyQSAvKiBXYXNtU2lnbmF0dXJlLmggaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBRDc0MzhCRjFFMDQ1NzkyMDBG RDBDMkEgLyogV2FzbVNpZ25hdHVyZS5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFBy aXZhdGUsICk7IH07IH07CiAJCUFENzQzOEMxMUUwNDU3QUEwMEZEMEMyQSAvKiBXYXNtU2lnbmF0 dXJlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEFE NzQzOEJFMUUwNDU3OTIwMEZEMEMyQSAvKiBXYXNtU2lnbmF0dXJlLmNwcCAqLzsgfTsKIAkJQUQ4 NkE5M0UxQUE0RDg4RDAwMkZFNzdGIC8qIFdlYWtHQ01hcElubGluZXMuaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEFEODZBOTNEMUFBNEQ4N0MwMDJGRTc3 RiAvKiBXZWFrR0NNYXBJbmxpbmVzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJp dmF0ZSwgKTsgfTsgfTsKKwkJQURCNkY2N0QxRTE1RDc2MDAwODJGMzg0IC8qIFdhc21QYWdlQ291 bnQuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQURC NkY2N0MxRTE1RDc1MDAwODJGMzg0IC8qIFdhc21QYWdlQ291bnQuY3BwICovOyB9OwogCQlBREJD NTRENDFERjhFQTJCMDA1QkY3MzggLyogV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmNwcCBpbiBTb3Vy Y2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEFEQkM1NEQyMURGOEVBMDAw MDVCRjczOCAvKiBXZWJBc3NlbWJseVRvSlNDYWxsZWUuY3BwICovOyB9OwogCQlBREJDNTRENTFE RjhFQTJCMDA1QkY3MzggLyogV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBREJDNTREMzFERjhFQTAwMDA1QkY3Mzgg LyogV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmggKi87IH07CiAJCUFEREIxRjYzMThENzdEQkUwMDlC NThBOCAvKiBPcGFxdWVSb290U2V0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBBRERCMUY2MjE4RDc3REI3MDA5QjU4QTggLyogT3BhcXVlUm9vdFNldC5o ICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CkBAIC0yMzYx LDcgKzIzNjMsNiBAQAogCQlGRUQ5NEYyRjE3MUUzRTIzMDBCRTc3QTQgLyogV2F0Y2hkb2cuaCBp biBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZFRDk0RjJDMTcx RTNFMjMwMEJFNzdBNCAvKiBXYXRjaGRvZy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0g KFByaXZhdGUsICk7IH07IH07CiAJCUZFRjA0MDUxMUFBRTY2MkQwMEJEMjhCMCAvKiBDb21wYXJl QW5kU3dhcFRlc3QuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gRkVGMDQwNTAxQUFFNjYyRDAwQkQyOEIwIC8qIENvbXBhcmVBbmRTd2FwVGVzdC5jcHAg Ki87IH07CiAJCUZFRkQ2RkM2MUQ1RTc5OTIwMDhGMkYwQiAvKiBKU1N0cmluZ0lubGluZXMuaCBp biBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZFRkQ2RkM1MUQ1 RTc5NzAwMDhGMkYwQiAvKiBKU1N0cmluZ0lubGluZXMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklC VVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwotCQkyRDM0MkYzNkY3MjQ0MDk2ODA0QURCMjQgLyog U291cmNlT3JpZ2luLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA0MjVCQTEzMzdFNDM0NEUxQjI2OUE2NzEgLyogU291cmNlT3JpZ2luLmggKi87IHNldHRp bmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIC8qIEVuZCBQQlhCdWlsZEZp bGUgc2VjdGlvbiAqLwogCiAvKiBCZWdpbiBQQlhDb250YWluZXJJdGVtUHJveHkgc2VjdGlvbiAq LwpAQCAtMzYzOCw2ICszNjM5LDcgQEAKIAkJNDEyOTUyNzUxRDJDRjZBQzAwRTc4Qjg5IC8qIGJ1 aWx0aW5zX2dlbmVyYXRlX3dyYXBwZXJfaGVhZGVyLnB5ICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dC5zY3JpcHQu cHl0aG9uOyBwYXRoID0gYnVpbHRpbnNfZ2VuZXJhdGVfd3JhcHBlcl9oZWFkZXIucHk7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQxMjk1Mjc2MUQyQ0Y2QUMwMEU3OEI4OSAvKiBidWls dGluc19nZW5lcmF0ZV93cmFwcGVyX2ltcGxlbWVudGF0aW9uLnB5ICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dC5z Y3JpcHQucHl0aG9uOyBwYXRoID0gYnVpbHRpbnNfZ2VuZXJhdGVfd3JhcHBlcl9pbXBsZW1lbnRh dGlvbi5weTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDFERUExMzExQjlGMzE1NDAw NkQ2NUREIC8qIEJ1aWx0aW5VdGlscy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBCdWlsdGluVXRpbHMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNDI1QkExMzM3 RTQzNDRFMUIyNjlBNjcxIC8qIFNvdXJjZU9yaWdpbi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBTb3VyY2VPcmlnaW4uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ NDMxOURBMDExQzFCRTNDMTAwMUQyNjBCIC8qIEIzTG93ZXJNYWNyb3NBZnRlck9wdGltaXphdGlv bnMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gQjNMb3dlck1hY3Jv c0FmdGVyT3B0aW1pemF0aW9ucy5jcHA7IHBhdGggPSBiMy9CM0xvd2VyTWFjcm9zQWZ0ZXJPcHRp bWl6YXRpb25zLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDMxOURBMDIxQzFC RTNDMTAwMUQyNjBCIC8qIEIzTG93ZXJNYWNyb3NBZnRlck9wdGltaXphdGlvbnMuaCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gQjNMb3dlck1hY3Jvc0FmdGVyT3B0aW1pemF0aW9u cy5oOyBwYXRoID0gYjMvQjNMb3dlck1hY3Jvc0FmdGVyT3B0aW1pemF0aW9ucy5oOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQk0MzQwQTQ4MjFBOTA1MUFGMDBENzNDQ0EgLyogTWF0aENv bW1vbi5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBNYXRoQ29tbW9u LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTQ1MTAsNiArNDUxMiw3IEBACiAJ CUFENzQzOEJFMUUwNDU3OTIwMEZEMEMyQSAvKiBXYXNtU2lnbmF0dXJlLmNwcCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFdhc21TaWduYXR1cmUuY3BwOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQlBRDc0MzhCRjFFMDQ1NzkyMDBGRDBDMkEgLyogV2FzbVNpZ25h dHVyZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXYXNtU2lnbmF0dXJlLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUFEODZBOTNEMUFBNEQ4N0MwMDJGRTc3RiAv KiBXZWFrR0NNYXBJbmxpbmVzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFdl YWtHQ01hcElubGluZXMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJQURCNkY2N0Mx RTE1RDc1MDAwODJGMzg0IC8qIFdhc21QYWdlQ291bnQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAuY3BwOyBwYXRoID0gV2FzbVBhZ2VDb3VudC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCUFEQkM1NEQyMURGOEVBMDAwMDVCRjczOCAvKiBXZWJBc3NlbWJseVRvSlNDYWxs ZWUuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gV2ViQXNzZW1ibHlU b0pTQ2FsbGVlLmNwcDsgcGF0aCA9IGpzL1dlYkFzc2VtYmx5VG9KU0NhbGxlZS5jcHA7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUFEQkM1NEQzMURGOEVBMDAwMDVCRjczOCAvKiBXZWJB c3NlbWJseVRvSlNDYWxsZWUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gV2Vi QXNzZW1ibHlUb0pTQ2FsbGVlLmg7IHBhdGggPSBqcy9XZWJBc3NlbWJseVRvSlNDYWxsZWUuaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQUREQjFGNjIxOEQ3N0RCNzAwOUI1OEE4IC8q IE9wYXF1ZVJvb3RTZXQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gT3BhcXVl Um9vdFNldC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtNDg3OSw3ICs0ODgyLDYg QEAKIAkJRkVGMDQwNTAxQUFFNjYyRDAwQkQyOEIwIC8qIENvbXBhcmVBbmRTd2FwVGVzdC5jcHAg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUgPSBDb21wYXJlQW5kU3dhcFRlc3Qu Y3BwOyBwYXRoID0gQVBJL3Rlc3RzL0NvbXBhcmVBbmRTd2FwVGVzdC5jcHA7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCUZFRjA0MDUyMUFBRUM0RUQwMEJEMjhCMCAvKiBDb21wYXJlQW5k U3dhcFRlc3QuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gQ29tcGFyZUFuZFN3 YXBUZXN0Lmg7IHBhdGggPSBBUEkvdGVzdHMvQ29tcGFyZUFuZFN3YXBUZXN0Lmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZFRkQ2RkM1MUQ1RTc5NzAwMDhGMkYwQiAvKiBKU1N0cmlu Z0lubGluZXMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSlNTdHJpbmdJbmxp bmVzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07Ci0JCTQyNUJBMTMzN0U0MzQ0RTFCMjY5 QTY3MSAvKiBTb3VyY2VPcmlnaW4uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0g U291cmNlT3JpZ2luLmg7IHBhdGggPSBTb3VyY2VPcmlnaW4uaDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIC8qIEVuZCBQQlhGaWxlUmVmZXJlbmNlIHNlY3Rpb24gKi8KIAogLyogQmVnaW4g UEJYRnJhbWV3b3Jrc0J1aWxkUGhhc2Ugc2VjdGlvbiAqLwpAQCAtNjA0Nyw2ICs2MDQ5LDcgQEAK IAkJCQk3OUI3NTk3MjFERkE0QzYwMDA1MjE3NEMgLyogV2FzbU1lbW9yeUluZm9ybWF0aW9uLmgg Ki8sCiAJCQkJNTNGNDBFOTYxRDVBN0JFQzAwOTlBMUI2IC8qIFdhc21Nb2R1bGVQYXJzZXIuY3Bw ICovLAogCQkJCTUzRjQwRTk0MUQ1QTdBRUYwMDk5QTFCNiAvKiBXYXNtTW9kdWxlUGFyc2VyLmgg Ki8sCisJCQkJQURCNkY2N0MxRTE1RDc1MDAwODJGMzg0IC8qIFdhc21QYWdlQ291bnQuY3BwICov LAogCQkJCTc5Qjc1OTczMURGQTRDNjAwMDUyMTc0QyAvKiBXYXNtUGFnZUNvdW50LmggKi8sCiAJ CQkJNTNGNDBFOEMxRDU5MDFGMjAwOTlBMUI2IC8qIFdhc21QYXJzZXIuaCAqLywKIAkJCQk1MzEz NzRCRTFENUNFOTUwMDBBRjdBMEIgLyogV2FzbVBsYW4uY3BwICovLApAQCAtOTcwMyw2ICs5NzA2 LDcgQEAKIAkJCQkwRjY0QjI3MTFBNzg0QkFGMDA2RTRFNjYgLyogQmluYXJ5U3dpdGNoLmNwcCBp biBTb3VyY2VzICovLAogCQkJCTE0MjgwODYzMTA3RUMxMUEwMDEzRTdCMiAvKiBCb29sZWFuQ29u c3RydWN0b3IuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJMTQyODA4NjQxMDdFQzExQTAwMTNFN0Iy IC8qIEJvb2xlYW5PYmplY3QuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJQURCNkY2N0QxRTE1RDc2 MDAwODJGMzg0IC8qIFdhc21QYWdlQ291bnQuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJMTQyODA4 NjUxMDdFQzExQTAwMTNFN0IyIC8qIEJvb2xlYW5Qcm90b3R5cGUuY3BwIGluIFNvdXJjZXMgKi8s CiAJCQkJREUyNkU5MDcxQ0I1REVGQjAwRDJCRTgyIC8qIEJ1aWx0aW5FeGVjdXRhYmxlQ3JlYXRv ci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlBN0Q4MDFBNDE4ODBENjZFMDAyNkMzOUIgLyogQnVp bHRpbkV4ZWN1dGFibGVzLmNwcCBpbiBTb3VyY2VzICovLApkaWZmIC0tZ2l0IGEvU291cmNlL0ph dmFTY3JpcHRDb3JlL2pzYy5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvanNjLmNwcAppbmRl eCAzZWFmNGEwLi5mNDM0Y2FjIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvanNj LmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvanNjLmNwcApAQCAtNTQsNiArNTQsOCBA QAogI2luY2x1ZGUgIkpTU3RyaW5nLmgiCiAjaW5jbHVkZSAiSlNUeXBlZEFycmF5cy5oIgogI2lu Y2x1ZGUgIkpTV2ViQXNzZW1ibHlDYWxsZWUuaCIKKyNpbmNsdWRlICJKU1dlYkFzc2VtYmx5SW5z dGFuY2UuaCIKKyNpbmNsdWRlICJKU1dlYkFzc2VtYmx5TW9kdWxlLmgiCiAjaW5jbHVkZSAiTExJ bnREYXRhLmgiCiAjaW5jbHVkZSAiTExJbnRUaHVua3MuaCIKICNpbmNsdWRlICJPYmplY3RDb25z dHJ1Y3Rvci5oIgpAQCAtNzAsNiArNzIsNyBAQAogI2luY2x1ZGUgIlR5cGVQcm9maWxlckxvZy5o IgogI2luY2x1ZGUgIldhc21QbGFuLmgiCiAjaW5jbHVkZSAiV2FzbU1lbW9yeS5oIgorI2luY2x1 ZGUgIldlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmgiCiAjaW5jbHVkZSA8bG9jYWxlLmg+CiAjaW5j bHVkZSA8bWF0aC5oPgogI2luY2x1ZGUgPHN0ZGlvLmg+CkBAIC0yNjE1LDYgKzI2MTgsNyBAQCBz dGF0aWMgRW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBmdW5jdGlvblRlc3RXYXNtTW9kdWxl RnVuY3Rpb25zKEV4ZWNTdGF0ZSogZQogewogICAgIFZNJiB2bSA9IGV4ZWMtPnZtKCk7CiAgICAg YXV0byBzY29wZSA9IERFQ0xBUkVfVEhST1dfU0NPUEUodm0pOworICAgIGF1dG8qIGdsb2JhbE9i amVjdCA9IGV4ZWMtPmxleGljYWxHbG9iYWxPYmplY3QoKTsKIAogICAgIGlmICghT3B0aW9uczo6 dXNlV2ViQXNzZW1ibHkoKSkKICAgICAgICAgcmV0dXJuIHRocm93Vk1UeXBlRXJyb3IoZXhlYywg c2NvcGUsIEFTQ0lJTGl0ZXJhbCgidGVzdFdhc21Nb2R1bGUgc2hvdWxkIG9ubHkgYmUgY2FsbGVk IGlmIHRoZSB1c2VXZWJBc3NlbWJseSBvcHRpb24gaXMgc2V0IikpOwpAQCAtMjY0OCw4ICsyNjUy LDI1IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGZ1bmN0aW9uVGVzdFdh c21Nb2R1bGVGdW5jdGlvbnMoRXhlY1N0YXRlKiBlCiAgICAgICAgICAgICB9KTsKICAgICB9CiAK LSAgICBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+IG1vZHVsZUluZm9y bWF0aW9uID0gcGxhbi50YWtlTW9kdWxlSW5mb3JtYXRpb24oKTsKLSAgICBSRUxFQVNFX0FTU0VS VCghbW9kdWxlSW5mb3JtYXRpb24tPm1lbW9yeSk7CisgICAgU3ltYm9sVGFibGUqIGV4cG9ydFN5 bWJvbFRhYmxlID0gU3ltYm9sVGFibGU6OmNyZWF0ZSh2bSk7CisgICAgYXV0byogbW9kdWxlU3Ry dWN0dXJlID0gSW50ZXJuYWxGdW5jdGlvbjo6Y3JlYXRlU3ViY2xhc3NTdHJ1Y3R1cmUoZXhlYywg SlNWYWx1ZSgpLCBleGVjLT5sZXhpY2FsR2xvYmFsT2JqZWN0KCktPldlYkFzc2VtYmx5TW9kdWxl U3RydWN0dXJlKCkpOworICAgIFJFVFVSTl9JRl9FWENFUFRJT04oc2NvcGUsIGVuY29kZWRKU1Zh bHVlKCkpOworICAgIEpTV2ViQXNzZW1ibHlNb2R1bGUqIG1vZHVsZSA9IEpTV2ViQXNzZW1ibHlN b2R1bGU6OmNyZWF0ZSh2bSwgbW9kdWxlU3RydWN0dXJlLCBwbGFuLnRha2VNb2R1bGVJbmZvcm1h dGlvbigpLCBwbGFuLnRha2VDYWxsTGlua0luZm9zKCksIHBsYW4udGFrZVdhc21FeGl0U3R1YnMo KSwgZXhwb3J0U3ltYm9sVGFibGUsIDApOworICAgIFN0cnVjdHVyZSogaW5zdGFuY2VTdHJ1Y3R1 cmUgPSBJbnRlcm5hbEZ1bmN0aW9uOjpjcmVhdGVTdWJjbGFzc1N0cnVjdHVyZShleGVjLCBKU1Zh bHVlKCksIGdsb2JhbE9iamVjdC0+V2ViQXNzZW1ibHlJbnN0YW5jZVN0cnVjdHVyZSgpKTsKKyAg ICBSRVRVUk5fSUZfRVhDRVBUSU9OKHNjb3BlLCBlbmNvZGVkSlNWYWx1ZSgpKTsKKyAgICBJZGVu dGlmaWVyIG1vZHVsZUtleSA9IElkZW50aWZpZXI6OmZyb21VaWQoUHJpdmF0ZU5hbWUoUHJpdmF0 ZU5hbWU6OkRlc2NyaXB0aW9uLCAiV2ViQXNzZW1ibHlJbnN0YW5jZSIpKTsKKyAgICBXZWJBc3Nl bWJseU1vZHVsZVJlY29yZCogbW9kdWxlUmVjb3JkID0gV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6 OmNyZWF0ZShleGVjLCB2bSwgZ2xvYmFsT2JqZWN0LT53ZWJBc3NlbWJseU1vZHVsZVJlY29yZFN0 cnVjdHVyZSgpLCBtb2R1bGVLZXksIG1vZHVsZS0+bW9kdWxlSW5mb3JtYXRpb24oKSk7CisgICAg UkVUVVJOX0lGX0VYQ0VQVElPTihzY29wZSwgZW5jb2RlZEpTVmFsdWUoKSk7CisgICAgSlNXZWJB c3NlbWJseUluc3RhbmNlKiBpbnN0YW5jZSA9IEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6Y3JlYXRl KHZtLCBpbnN0YW5jZVN0cnVjdHVyZSwgbW9kdWxlLCBtb2R1bGVSZWNvcmQtPmdldE1vZHVsZU5h bWVzcGFjZShleGVjKSk7CisgICAgUkVUVVJOX0lGX0VYQ0VQVElPTihzY29wZSwgZW5jb2RlZEpT VmFsdWUoKSk7CisgICAgdm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlID0gaW5zdGFuY2U7CisK KyAgICBpZiAoISFtb2R1bGUtPm1vZHVsZUluZm9ybWF0aW9uKCkubWVtb3J5KSB7CisgICAgICAg IGJvb2wgZmFpbGVkOworICAgICAgICBXYXNtOjpNZW1vcnkgbWVtb3J5KG1vZHVsZS0+bW9kdWxl SW5mb3JtYXRpb24oKS5tZW1vcnkuaW5pdGlhbCgpLCBtb2R1bGUtPm1vZHVsZUluZm9ybWF0aW9u KCkubWVtb3J5Lm1heGltdW0oKSwgZmFpbGVkKTsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQoZmFp bGVkKTsKKyAgICAgICAgaW5zdGFuY2UtPnNldE1lbW9yeSh2bSwgSlNXZWJBc3NlbWJseU1lbW9y eTo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3QtPldlYkFzc2VtYmx5TWVtb3J5U3RydWN0dXJlKCks IFdURk1vdmUobWVtb3J5KSkpOworICAgIH0KIAogICAgIGZvciAodWludDMyX3QgaSA9IDA7IGkg PCBmdW5jdGlvbkNvdW50OyArK2kpIHsKICAgICAgICAgSlNBcnJheSogdGVzdENhc2VzID0ganND YXN0PEpTQXJyYXkqPihleGVjLT5hcmd1bWVudChpICsgMikpOwpkaWZmIC0tZ2l0IGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvQWJzdHJhY3RNb2R1bGVSZWNvcmQuaCBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS9ydW50aW1lL0Fic3RyYWN0TW9kdWxlUmVjb3JkLmgKaW5kZXggMDRhZjEy Ni4uMzlmYzJkMSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvQWJz dHJhY3RNb2R1bGVSZWNvcmQuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9B YnN0cmFjdE1vZHVsZVJlY29yZC5oCkBAIC0xMTMsNyArMTEzLDcgQEAgcHVibGljOgogCiAgICAg QWJzdHJhY3RNb2R1bGVSZWNvcmQqIGhvc3RSZXNvbHZlSW1wb3J0ZWRNb2R1bGUoRXhlY1N0YXRl KiwgY29uc3QgSWRlbnRpZmllciYgbW9kdWxlTmFtZSk7CiAKLSAgICBKU01vZHVsZU5hbWVzcGFj ZU9iamVjdCogZ2V0TW9kdWxlTmFtZXNwYWNlKEV4ZWNTdGF0ZSopOworICAgIEpTX0VYUE9SVF9Q UklWQVRFIEpTTW9kdWxlTmFtZXNwYWNlT2JqZWN0KiBnZXRNb2R1bGVOYW1lc3BhY2UoRXhlY1N0 YXRlKik7CiAgICAgCiAgICAgSlNNb2R1bGVFbnZpcm9ubWVudCogbW9kdWxlRW52aXJvbm1lbnQo KQogICAgIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTVHlw ZS5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmgKaW5kZXggMDUyMDJm My4uYWM1MDlkNyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNU eXBlLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmgKQEAgLTkz LDYgKzkzLDggQEAgZW51bSBKU1R5cGUgOiB1aW50OF90IHsKICAgICBKU01hcFR5cGUsCiAgICAg SlNTZXRUeXBlLAogCisgICAgV2ViQXNzZW1ibHlGdW5jdGlvblR5cGUsCisKICAgICBMYXN0SlND T2JqZWN0VHlwZSA9IEpTU2V0VHlwZSwKICAgICBNYXhKU1R5cGUgPSAwYjExMTExMTExLAogfTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9y LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcApp bmRleCAxMTdkNzY0Li44YjhhZmVjIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9XYXNtQjNJUkdlbmVyYXRvci5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbUIzSVJHZW5lcmF0b3IuY3BwCkBAIC0xNTUsNyArMTU1LDcgQEAgcHVibGljOgogICAg ICAgICAgICAgcmV0dXJuIGZhaWwoX19WQV9BUkdTX18pOyAgICAgICAgICAgICBcCiAgICAgfSB3 aGlsZSAoMCkKIAotICAgIEIzSVJHZW5lcmF0b3IoVk0mLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlv biYsIFByb2NlZHVyZSYsIFdhc21JbnRlcm5hbEZ1bmN0aW9uKiwgVmVjdG9yPFVubGlua2VkV2Fz bVRvV2FzbUNhbGw+JiwgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJik7CisgICAg QjNJUkdlbmVyYXRvcihWTSYsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiwgUHJvY2VkdXJlJiwg V2FzbUludGVybmFsRnVuY3Rpb24qLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mKTsK IAogICAgIFBhcnRpYWxSZXN1bHQgV0FSTl9VTlVTRURfUkVUVVJOIGFkZEFyZ3VtZW50cyhjb25z dCBTaWduYXR1cmUqKTsKICAgICBQYXJ0aWFsUmVzdWx0IFdBUk5fVU5VU0VEX1JFVFVSTiBhZGRM b2NhbChUeXBlLCB1aW50MzJfdCk7CkBAIC0yMDUsOCArMjA1LDYgQEAgcHVibGljOgogCiAgICAg dm9pZCBlbWl0RXhjZXB0aW9uQ2hlY2soQ0NhbGxIZWxwZXJzJiwgRXhjZXB0aW9uVHlwZSk7CiAK LSAgICB2b2lkIGVtaXRSZWxvYWRQaW5uZWRSZWdpc3RlcnMoKTsKLQogcHJpdmF0ZToKICAgICBF eHByZXNzaW9uVHlwZSBlbWl0Q2hlY2tBbmRQcmVwYXJlUG9pbnRlcihFeHByZXNzaW9uVHlwZSBw b2ludGVyLCB1aW50MzJfdCBvZmZzZXQsIHVpbnQzMl90IHNpemVPZk9wKTsKICAgICBFeHByZXNz aW9uVHlwZSBlbWl0TG9hZE9wKExvYWRPcFR5cGUsIE9yaWdpbiwgRXhwcmVzc2lvblR5cGUgcG9p bnRlciwgdWludDMyX3Qgb2Zmc2V0KTsKQEAgLTIxOSw3ICsyMTcsNiBAQCBwcml2YXRlOgogICAg IHZvaWQgZW1pdENoZWNrc0Zvck1vZE9yRGl2KEIzOjpPcGNvZGUsIEV4cHJlc3Npb25UeXBlIGxl ZnQsIEV4cHJlc3Npb25UeXBlIHJpZ2h0KTsKIAogICAgIFZNJiBtX3ZtOwotICAgIGNvbnN0IElt bXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYgbV9mdW5jdGlvbkluZGV4U3BhY2U7CiAgICAgY29u c3QgTW9kdWxlSW5mb3JtYXRpb24mIG1faW5mbzsKICAgICBQcm9jZWR1cmUmIG1fcHJvYzsKICAg ICBCYXNpY0Jsb2NrKiBtX2N1cnJlbnRCbG9jazsKQEAgLTIzMSw5ICsyMjgsOCBAQCBwcml2YXRl OgogICAgIFZhbHVlKiBtX2luc3RhbmNlVmFsdWU7CiB9OwogCi1CM0lSR2VuZXJhdG9yOjpCM0lS R2VuZXJhdG9yKFZNJiB2bSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFByb2NlZHVy ZSYgcHJvY2VkdXJlLCBXYXNtSW50ZXJuYWxGdW5jdGlvbiogY29tcGlsYXRpb24sIFZlY3RvcjxV bmxpbmtlZFdhc21Ub1dhc21DYWxsPiYgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGNvbnN0IElt bXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYgZnVuY3Rpb25JbmRleFNwYWNlKQorQjNJUkdlbmVy YXRvcjo6QjNJUkdlbmVyYXRvcihWTSYgdm0sIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBpbmZv LCBQcm9jZWR1cmUmIHByb2NlZHVyZSwgV2FzbUludGVybmFsRnVuY3Rpb24qIGNvbXBpbGF0aW9u LCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mIHVubGlua2VkV2FzbVRvV2FzbUNhbGxz KQogICAgIDogbV92bSh2bSkKLSAgICAsIG1fZnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5k ZXhTcGFjZSkKICAgICAsIG1faW5mbyhpbmZvKQogICAgICwgbV9wcm9jKHByb2NlZHVyZSkKICAg ICAsIG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHModW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMpCkBA IC0yNTUsMTEgKzI1MSwxMiBAQCBCM0lSR2VuZXJhdG9yOjpCM0lSR2VuZXJhdG9yKFZNJiB2bSwg Y29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFByb2NlZHVyZSYgcAogICAgIH0KIAogICAg IGlmIChpbmZvLmhhc01lbW9yeSgpKSB7Ci0gICAgICAgIG1fbWVtb3J5QmFzZUdQUiA9IGluZm8u bWVtb3J5LnBpbm5lZFJlZ2lzdGVycygpLmJhc2VNZW1vcnlQb2ludGVyOworICAgICAgICBjb25z dCBQaW5uZWRSZWdpc3RlckluZm8mIHBpbm5lZFJlZ3MgPSBQaW5uZWRSZWdpc3RlckluZm86Omdl dCgpOworICAgICAgICBtX21lbW9yeUJhc2VHUFIgPSBwaW5uZWRSZWdzLmJhc2VNZW1vcnlQb2lu dGVyOwogICAgICAgICBtX3Byb2MucGluUmVnaXN0ZXIobV9tZW1vcnlCYXNlR1BSKTsKLSAgICAg ICAgQVNTRVJUKCFpbmZvLm1lbW9yeS5waW5uZWRSZWdpc3RlcnMoKS5zaXplUmVnaXN0ZXJzWzBd LnNpemVPZmZzZXQpOwotICAgICAgICBtX21lbW9yeVNpemVHUFIgPSBpbmZvLm1lbW9yeS5waW5u ZWRSZWdpc3RlcnMoKS5zaXplUmVnaXN0ZXJzWzBdLnNpemVSZWdpc3RlcjsKLSAgICAgICAgZm9y IChjb25zdCBQaW5uZWRTaXplUmVnaXN0ZXJJbmZvJiByZWdJbmZvIDogaW5mby5tZW1vcnkucGlu bmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVycykKKyAgICAgICAgQVNTRVJUKCFwaW5uZWRSZWdz LnNpemVSZWdpc3RlcnNbMF0uc2l6ZU9mZnNldCk7CisgICAgICAgIG1fbWVtb3J5U2l6ZUdQUiA9 IHBpbm5lZFJlZ3Muc2l6ZVJlZ2lzdGVyc1swXS5zaXplUmVnaXN0ZXI7CisgICAgICAgIGZvciAo Y29uc3QgUGlubmVkU2l6ZVJlZ2lzdGVySW5mbyYgcmVnSW5mbyA6IHBpbm5lZFJlZ3Muc2l6ZVJl Z2lzdGVycykKICAgICAgICAgICAgIG1fcHJvYy5waW5SZWdpc3RlcihyZWdJbmZvLnNpemVSZWdp c3Rlcik7CiAKICAgICAgICAgbV9wcm9jLnNldFdhc21Cb3VuZHNDaGVja0dlbmVyYXRvcihbPV0g KENDYWxsSGVscGVycyYgaml0LCBHUFJSZWcgcGlubmVkR1BSLCB1bnNpZ25lZCkgewpAQCAtMjc1 LDYgKzI3Miw2MSBAQCBCM0lSR2VuZXJhdG9yOjpCM0lSR2VuZXJhdG9yKFZNJiB2bSwgY29uc3Qg TW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFByb2NlZHVyZSYgcAogICAgICAgICBtX2N1cnJlbnRC bG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KG1fcHJvYywgT3JpZ2luKCksICZtX3ZtLnRv cEpTV2ViQXNzZW1ibHlJbnN0YW5jZSkpOwogfQogCitzdHJ1Y3QgTWVtb3J5QmFzZUFuZFNpemUg eworICAgIFZhbHVlKiBiYXNlOworICAgIFZhbHVlKiBzaXplOworfTsKKworc3RhdGljIE1lbW9y eUJhc2VBbmRTaXplIGdldE1lbW9yeUJhc2VBbmRTaXplKFZNJiB2bSwgVmFsdWUqIGluc3RhbmNl LCBQcm9jZWR1cmUmIHByb2MsIEJhc2ljQmxvY2sqIGJsb2NrKQoreworICAgIFZhbHVlKiBtZW1v cnlPYmplY3QgPSBibG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihwcm9jLCBMb2FkLCBwb2lu dGVyVHlwZSgpLCBPcmlnaW4oKSwgaW5zdGFuY2UsIEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zm c2V0T2ZNZW1vcnkoKSk7CisKKyAgICBzdGF0aWNfYXNzZXJ0KHNpemVvZihkZWNsdHlwZSh2bS50 b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UtPm1lbW9yeSgpLT5tZW1vcnkoKS0+bWVtb3J5KCkpKSA9 PSBzaXplb2Yodm9pZCopLCAiY29kZWdlbiByZWxpZXMgb24gdGhpcyBzaXplIik7CisgICAgc3Rh dGljX2Fzc2VydChzaXplb2YoZGVjbHR5cGUodm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlLT5t ZW1vcnkoKS0+bWVtb3J5KCktPnNpemUoKSkpID09IHNpemVvZih1aW50NjRfdCksICJjb2RlZ2Vu IHJlbGllcyBvbiB0aGlzIHNpemUiKTsKKyAgICBNZW1vcnlCYXNlQW5kU2l6ZSByZXN1bHQ7Cisg ICAgcmVzdWx0LmJhc2UgPSBibG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihwcm9jLCBMb2Fk LCBwb2ludGVyVHlwZSgpLCBPcmlnaW4oKSwgbWVtb3J5T2JqZWN0LCBKU1dlYkFzc2VtYmx5TWVt b3J5OjpvZmZzZXRPZk1lbW9yeSgpKTsKKyAgICByZXN1bHQuc2l6ZSA9IGJsb2NrLT5hcHBlbmRO ZXc8TWVtb3J5VmFsdWU+KHByb2MsIExvYWQsIEludDY0LCBPcmlnaW4oKSwgbWVtb3J5T2JqZWN0 LCBKU1dlYkFzc2VtYmx5TWVtb3J5OjpvZmZzZXRPZlNpemUoKSk7CisKKyAgICByZXR1cm4gcmVz dWx0OworfQorCitzdGF0aWMgdm9pZCByZXN0b3JlV2ViQXNzZW1ibHlHbG9iYWxTdGF0ZShWTSYg dm0sIGNvbnN0IE1lbW9yeUluZm9ybWF0aW9uJiBtZW1vcnksIFZhbHVlKiBpbnN0YW5jZSwgUHJv Y2VkdXJlJiBwcm9jLCBCYXNpY0Jsb2NrKiBibG9jaykKK3sKKyAgICBibG9jay0+YXBwZW5kTmV3 PE1lbW9yeVZhbHVlPihwcm9jLCBTdG9yZSwgT3JpZ2luKCksIGluc3RhbmNlLCBibG9jay0+YXBw ZW5kTmV3PENvbnN0UHRyVmFsdWU+KHByb2MsIE9yaWdpbigpLCAmdm0udG9wSlNXZWJBc3NlbWJs eUluc3RhbmNlKSk7CisKKyAgICBpZiAoISFtZW1vcnkpIHsKKyAgICAgICAgY29uc3QgUGlubmVk UmVnaXN0ZXJJbmZvJiBwaW5uZWRSZWdzID0gUGlubmVkUmVnaXN0ZXJJbmZvOjpnZXQoKTsKKyAg ICAgICAgYXV0byBtZW1vcnlWYWx1ZSA9IGdldE1lbW9yeUJhc2VBbmRTaXplKHZtLCBpbnN0YW5j ZSwgcHJvYywgYmxvY2spOworCisgICAgICAgIFZlY3RvcjxWYWx1ZSo+IGFyZ3VtZW50czsKKyAg ICAgICAgYXJndW1lbnRzLnJlc2VydmVDYXBhY2l0eSgxICsgcGlubmVkUmVncy5zaXplUmVnaXN0 ZXJzLnNpemUoKSk7CisgICAgICAgIGFyZ3VtZW50cy5hcHBlbmQobWVtb3J5VmFsdWUuYmFzZSk7 CisgICAgICAgIGZvciAoYXV0byBpbmZvIDogcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzKSB7Cisg ICAgICAgICAgICBWYWx1ZSogc2l6ZVZhbHVlID0gYmxvY2stPmFwcGVuZE5ldzxWYWx1ZT4ocHJv YywgU3ViLCBPcmlnaW4oKSwgbWVtb3J5VmFsdWUuc2l6ZSwgYmxvY2stPmFwcGVuZE5ldzxDb25z dDY0VmFsdWU+KHByb2MsIE9yaWdpbigpLCBpbmZvLnNpemVPZmZzZXQpKTsKKyAgICAgICAgICAg IGFyZ3VtZW50cy5hcHBlbmQoc2l6ZVZhbHVlKTsKKyAgICAgICAgfQorCisgICAgICAgIFJlZ2lz dGVyU2V0IGNsb2JiZXJzOworICAgICAgICBjbG9iYmVycy5zZXQocGlubmVkUmVncy5iYXNlTWVt b3J5UG9pbnRlcik7CisgICAgICAgIGZvciAoYXV0byBpbmZvIDogcGlubmVkUmVncy5zaXplUmVn aXN0ZXJzKQorICAgICAgICAgICAgY2xvYmJlcnMuc2V0KGluZm8uc2l6ZVJlZ2lzdGVyKTsKKwor ICAgICAgICBCMzo6UGF0Y2hwb2ludFZhbHVlKiBwYXRjaHBvaW50ID0gYmxvY2stPmFwcGVuZE5l dzxCMzo6UGF0Y2hwb2ludFZhbHVlPihwcm9jLCBCMzo6Vm9pZCwgT3JpZ2luKCkpOworICAgICAg ICBwYXRjaHBvaW50LT5lZmZlY3RzID0gRWZmZWN0czo6bm9uZSgpOworICAgICAgICBwYXRjaHBv aW50LT5lZmZlY3RzLndyaXRlc1Bpbm5lZCA9IHRydWU7CisgICAgICAgIHBhdGNocG9pbnQtPmNs b2JiZXIoY2xvYmJlcnMpOworICAgICAgICBwYXRjaHBvaW50LT5hcHBlbmRWZWN0b3JXaXRoUmVw KGFyZ3VtZW50cywgVmFsdWVSZXA6OlNvbWVSZWdpc3Rlcik7CisKKyAgICAgICAgcGF0Y2hwb2lu dC0+c2V0R2VuZXJhdG9yKFsmcGlubmVkUmVnc10gKENDYWxsSGVscGVycyYgaml0LCBjb25zdCBC Mzo6U3RhY2ttYXBHZW5lcmF0aW9uUGFyYW1zJiBwYXJhbXMpIHsKKyAgICAgICAgICAgIEFsbG93 TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKworICAgICAgICAg ICAgaml0Lm1vdmUocGFyYW1zWzBdLmdwcigpLCBwaW5uZWRSZWdzLmJhc2VNZW1vcnlQb2ludGVy KTsKKyAgICAgICAgICAgIGZvciAodWludDMyX3QgaSA9IDA7IGkgPCBwaW5uZWRSZWdzLnNpemVS ZWdpc3RlcnMuc2l6ZSgpOyArK2kpCisgICAgICAgICAgICAgICAgaml0Lm1vdmUocGFyYW1zWzEg KyBpXS5ncHIoKSwgcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzW2ldLnNpemVSZWdpc3Rlcik7Cisg ICAgICAgIH0pOworICAgIH0KK30KKwogdm9pZCBCM0lSR2VuZXJhdG9yOjplbWl0RXhjZXB0aW9u Q2hlY2soQ0NhbGxIZWxwZXJzJiBqaXQsIEV4Y2VwdGlvblR5cGUgdHlwZSkKIHsKICAgICBqaXQu bW92ZShDQ2FsbEhlbHBlcnM6OlRydXN0ZWRJbW0zMihzdGF0aWNfY2FzdDx1aW50MzJfdD4odHlw ZSkpLCBHUFJJbmZvOjphcmd1bWVudEdQUjEpOwpAQCAtMzM4LDQ5ICszOTAsNiBAQCBhdXRvIEIz SVJHZW5lcmF0b3I6OmFkZFVucmVhY2hhYmxlKCkgLT4gUGFydGlhbFJlc3VsdAogICAgIHJldHVy biB7IH07CiB9CiAKLXN0YXRpYyB2b2lkIHJlbG9hZFBpbm5lZFJlZ2lzdGVycyhQcm9jZWR1cmUm IHByb2MsIEJhc2ljQmxvY2sqIGJsb2NrLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywg VmFsdWUqIGluc3RhbmNlKQotewotICAgIGlmICghaW5mby5oYXNNZW1vcnkoKSkKLSAgICAgICAg cmV0dXJuOwotCi0gICAgY29uc3QgTWVtb3J5SW5mb3JtYXRpb24qIG1lbW9yeSA9ICZpbmZvLm1l bW9yeTsKLQotICAgIFJlZ2lzdGVyU2V0IGNsb2JiZXJzOwotICAgIGNsb2JiZXJzLnNldChtZW1v cnktPnBpbm5lZFJlZ2lzdGVycygpLmJhc2VNZW1vcnlQb2ludGVyKTsKLSAgICBmb3IgKGF1dG8g aW5mbyA6IG1lbW9yeS0+cGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVycykKLSAgICAgICAg Y2xvYmJlcnMuc2V0KGluZm8uc2l6ZVJlZ2lzdGVyKTsKLQotICAgIEIzOjpQYXRjaHBvaW50VmFs dWUqIHBhdGNocG9pbnQgPSBibG9jay0+YXBwZW5kTmV3PEIzOjpQYXRjaHBvaW50VmFsdWU+KHBy b2MsIEIzOjpWb2lkLCBPcmlnaW4oKSk7Ci0gICAgcGF0Y2hwb2ludC0+ZWZmZWN0cyA9IEVmZmVj dHM6Om5vbmUoKTsKLSAgICBwYXRjaHBvaW50LT5lZmZlY3RzLndyaXRlc1Bpbm5lZCA9IHRydWU7 Ci0gICAgcGF0Y2hwb2ludC0+Y2xvYmJlcihjbG9iYmVycyk7Ci0gICAgcGF0Y2hwb2ludC0+bnVt R1BTY3JhdGNoUmVnaXN0ZXJzID0gMTsKLQotICAgIHBhdGNocG9pbnQtPmFwcGVuZChpbnN0YW5j ZSwgVmFsdWVSZXA6OlNvbWVSZWdpc3Rlcik7Ci0KLSAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0 b3IoW21lbW9yeV0gKENDYWxsSGVscGVycyYgaml0LCBjb25zdCBCMzo6U3RhY2ttYXBHZW5lcmF0 aW9uUGFyYW1zJiBwYXJhbXMpIHsKLSAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVz YWdlIGFsbG93U2NyYXRjaChqaXQpOwotCi0gICAgICAgIEdQUlJlZyBzY3JhdGNoID0gcGFyYW1z LmdwU2NyYXRjaCgwKTsKLSAgICAgICAgaml0LmxvYWRQdHIoQ0NhbGxIZWxwZXJzOjpBZGRyZXNz KHBhcmFtc1swXS5ncHIoKSwgSlNXZWJBc3NlbWJseUluc3RhbmNlOjpvZmZzZXRPZk1lbW9yeSgp KSwgc2NyYXRjaCk7Ci0gICAgICAgIGppdC5sb2FkUHRyKENDYWxsSGVscGVyczo6QWRkcmVzcyhz Y3JhdGNoLCBKU1dlYkFzc2VtYmx5TWVtb3J5OjpvZmZzZXRPZk1lbW9yeSgpKSwgc2NyYXRjaCk7 Ci0gICAgICAgIGppdC5sb2FkUHRyKENDYWxsSGVscGVyczo6QWRkcmVzcyhzY3JhdGNoLCBNZW1v cnk6Om9mZnNldE9mTWVtb3J5KCkpLCBtZW1vcnktPnBpbm5lZFJlZ2lzdGVycygpLmJhc2VNZW1v cnlQb2ludGVyKTsKLQotICAgICAgICBqaXQubG9hZDY0KENDYWxsSGVscGVyczo6QWRkcmVzcyhz Y3JhdGNoLCBNZW1vcnk6Om9mZnNldE9mU2l6ZSgpKSwgc2NyYXRjaCk7Ci0gICAgICAgIGZvciAo dW5zaWduZWQgaSA9IDA7IGkgPCBtZW1vcnktPnBpbm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3Rl cnMuc2l6ZSgpOyBpKyspIHsKLSAgICAgICAgICAgIEdQUlJlZyBzaXplUmVnID0gbWVtb3J5LT5w aW5uZWRSZWdpc3RlcnMoKS5zaXplUmVnaXN0ZXJzW2ldLnNpemVSZWdpc3RlcjsKLSAgICAgICAg ICAgIGppdC5tb3ZlKHNjcmF0Y2gsIHNpemVSZWcpOwotICAgICAgICAgICAgaml0LnN1YjY0KEND YWxsSGVscGVyczo6VHJ1c3RlZEltbTMyKG1lbW9yeS0+cGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJl Z2lzdGVyc1tpXS5zaXplT2Zmc2V0KSwgc2l6ZVJlZyk7Ci0gICAgICAgIH0KLSAgICB9KTsKLX0K LQotdm9pZCBCM0lSR2VuZXJhdG9yOjplbWl0UmVsb2FkUGlubmVkUmVnaXN0ZXJzKCkKLXsKLSAg ICByZWxvYWRQaW5uZWRSZWdpc3RlcnMobV9wcm9jLCBtX2N1cnJlbnRCbG9jaywgbV9pbmZvLCBt X2luc3RhbmNlVmFsdWUpOwotfQotCi0KIGF1dG8gQjNJUkdlbmVyYXRvcjo6YWRkR3Jvd01lbW9y eShFeHByZXNzaW9uVHlwZSBkZWx0YSwgRXhwcmVzc2lvblR5cGUmIHJlc3VsdCkgLT4gUGFydGlh bFJlc3VsdAogewogICAgIGludDMyX3QgKCpncm93TWVtb3J5KSAoRXhlY1N0YXRlKiwgaW50MzJf dCkgPSBbXSAoRXhlY1N0YXRlKiBleGVjLCBpbnQzMl90IGRlbHRhKSAtPiBpbnQzMl90IHsKQEAg LTM4OSw3ICszOTgsNiBAQCBhdXRvIEIzSVJHZW5lcmF0b3I6OmFkZEdyb3dNZW1vcnkoRXhwcmVz c2lvblR5cGUgZGVsdGEsIEV4cHJlc3Npb25UeXBlJiByZXN1bHQpCiAKICAgICAgICAgSlNXZWJB c3NlbWJseUluc3RhbmNlKiBpbnN0YW5jZSA9IHZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZTsK ICAgICAgICAgSlNXZWJBc3NlbWJseU1lbW9yeSogd2FzbU1lbW9yeSA9IGluc3RhbmNlLT5tZW1v cnkoKTsKLSAgICAgICAgUkVMRUFTRV9BU1NFUlQod2FzbU1lbW9yeSk7IC8vIFRoaXMgd291bGQg ZmFpbCB2YWxpZGF0aW9uIG90aGVyd2lzZS4KIAogICAgICAgICBpZiAoZGVsdGEgPCAwKQogICAg ICAgICAgICAgcmV0dXJuIC0xOwpAQCAtNDA3LDIxICs0MTUsMTkgQEAgYXV0byBCM0lSR2VuZXJh dG9yOjphZGRHcm93TWVtb3J5KEV4cHJlc3Npb25UeXBlIGRlbHRhLCBFeHByZXNzaW9uVHlwZSYg cmVzdWx0KQogICAgICAgICBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+ KG1fcHJvYywgT3JpZ2luKCksIGJpdHdpc2VfY2FzdDx2b2lkKj4oZ3Jvd01lbW9yeSkpLAogICAg ICAgICBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PEIzOjpWYWx1ZT4obV9wcm9jLCBCMzo6RnJh bWVQb2ludGVyLCBPcmlnaW4oKSksIGRlbHRhKTsKIAotICAgIGVtaXRSZWxvYWRQaW5uZWRSZWdp c3RlcnMoKTsKKyAgICByZXN0b3JlV2ViQXNzZW1ibHlHbG9iYWxTdGF0ZShtX3ZtLCBtX2luZm8u bWVtb3J5LCBtX2luc3RhbmNlVmFsdWUsIG1fcHJvYywgbV9jdXJyZW50QmxvY2spOwogCiAgICAg cmV0dXJuIHsgfTsKIH0KIAogYXV0byBCM0lSR2VuZXJhdG9yOjphZGRDdXJyZW50TWVtb3J5KEV4 cHJlc3Npb25UeXBlJiByZXN1bHQpIC0+IFBhcnRpYWxSZXN1bHQKIHsKLSAgICBWYWx1ZSoganNN ZW1vcnkgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExv YWQsIHBvaW50ZXJUeXBlKCksIE9yaWdpbigpLCBtX2luc3RhbmNlVmFsdWUsIEpTV2ViQXNzZW1i bHlJbnN0YW5jZTo6b2Zmc2V0T2ZNZW1vcnkoKSk7Ci0gICAgVmFsdWUqIHdhc21NZW1vcnkgPSBt X2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQsIHBvaW50 ZXJUeXBlKCksIE9yaWdpbigpLCBqc01lbW9yeSwgSlNXZWJBc3NlbWJseU1lbW9yeTo6b2Zmc2V0 T2ZNZW1vcnkoKSk7Ci0gICAgVmFsdWUqIHNpemUgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3 PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQsIEIzOjpJbnQ2NCwgT3JpZ2luKCksIHdhc21NZW1v cnksIE1lbW9yeTo6b2Zmc2V0T2ZTaXplKCkpOworICAgIGF1dG8gbWVtb3J5VmFsdWUgPSBnZXRN ZW1vcnlCYXNlQW5kU2l6ZShtX3ZtLCBtX2luc3RhbmNlVmFsdWUsIG1fcHJvYywgbV9jdXJyZW50 QmxvY2spOwogCiAgICAgY29uc3RleHByIHVpbnQzMl90IHNoaWZ0VmFsdWUgPSAxNjsKICAgICBz dGF0aWNfYXNzZXJ0KFBhZ2VDb3VudDo6cGFnZVNpemUgPT0gMSA8PCBzaGlmdFZhbHVlLCAiVGhp cyBtdXN0IGhvbGQgZm9yIHRoZSBjb2RlIGJlbG93IHRvIGJlIGNvcnJlY3QuIik7CiAgICAgVmFs dWUqIG51bVBhZ2VzID0gbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxWYWx1ZT4obV9wcm9jLCBa U2hyLCBPcmlnaW4oKSwKLSAgICAgICAgc2l6ZSwgbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxD b25zdDMyVmFsdWU+KG1fcHJvYywgT3JpZ2luKCksIHNoaWZ0VmFsdWUpKTsKKyAgICAgICAgbWVt b3J5VmFsdWUuc2l6ZSwgbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxDb25zdDMyVmFsdWU+KG1f cHJvYywgT3JpZ2luKCksIHNoaWZ0VmFsdWUpKTsKIAogICAgIHJlc3VsdCA9IG1fY3VycmVudEJs b2NrLT5hcHBlbmROZXc8VmFsdWU+KG1fcHJvYywgVHJ1bmMsIE9yaWdpbigpLCBudW1QYWdlcyk7 CiAKQEAgLTgzMiwyNiArODM4LDc1IEBAIGF1dG8gQjNJUkdlbmVyYXRvcjo6YWRkQ2FsbCh1aW50 MzJfdCBmdW5jdGlvbkluZGV4LCBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSwKICAgICBBU1NF UlQoc2lnbmF0dXJlLT5hcmd1bWVudENvdW50KCkgPT0gYXJncy5zaXplKCkpOwogCiAgICAgVHlw ZSByZXR1cm5UeXBlID0gc2lnbmF0dXJlLT5yZXR1cm5UeXBlKCk7CisgICAgVmVjdG9yPFVubGlu a2VkV2FzbVRvV2FzbUNhbGw+KiB1bmxpbmtlZFdhc21Ub1dhc21DYWxscyA9ICZtX3VubGlua2Vk V2FzbVRvV2FzbUNhbGxzOwogCi0gICAgcmVzdWx0ID0gd2FzbUNhbGxpbmdDb252ZW50aW9uKCku c2V0dXBDYWxsKG1fcHJvYywgbV9jdXJyZW50QmxvY2ssIE9yaWdpbigpLCBhcmdzLCB0b0IzVHlw ZShyZXR1cm5UeXBlKSwKLSAgICAgICAgWyZdIChQYXRjaHBvaW50VmFsdWUqIHBhdGNocG9pbnQp IHsKLSAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsK LSAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMucmVhZHNQaW5uZWQgPSB0cnVlOworICAg IGlmIChtX2luZm8uaXNJbXBvcnRlZEZ1bmN0aW9uRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5j dGlvbkluZGV4KSkgeworICAgICAgICAvLyBGSVhNRSBpbXBvcnRzIGNhbiBiZSBsaW5rZWQgaGVy ZSwgaW5zdGVhZCBvZiBnZW5lcmF0aW5nIGEgcGF0Y2hwb2ludCwgYmVjYXVzZSBhbGwgaW1wb3J0 IHN0dWJzIGFyZSBnZW5lcmF0ZWQgYmVmb3JlIEIzIGNvbXBpbGF0aW9uIHN0YXJ0cy4gaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NjQ2MgorICAgICAgICBFeHByZXNz aW9uVHlwZSBmdW5jdGlvbkltcG9ydCA9IG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8TWVtb3J5 VmFsdWU+KG1fcHJvYywgTG9hZCwgcG9pbnRlclR5cGUoKSwgT3JpZ2luKCksIG1faW5zdGFuY2VW YWx1ZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlOjpvZmZzZXRPZkltcG9ydEZ1bmN0aW9uKGZ1bmN0 aW9uSW5kZXgpKTsKKyAgICAgICAgRXhwcmVzc2lvblR5cGUganNUeXBlT2ZJbXBvcnQgPSBtX2N1 cnJlbnRCbG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQ4WiwgT3JpZ2lu KCksIGZ1bmN0aW9uSW1wb3J0LCBKU0NlbGw6OnR5cGVJbmZvVHlwZU9mZnNldCgpKTsKKyAgICAg ICAgVmFsdWUqIGlzV2FzbUNhbGwgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PFZhbHVlPiht X3Byb2MsIEVxdWFsLCBPcmlnaW4oKSwganNUeXBlT2ZJbXBvcnQsIG1fY3VycmVudEJsb2NrLT5h cHBlbmROZXc8Q29uc3QzMlZhbHVlPihtX3Byb2MsIE9yaWdpbigpLCBXZWJBc3NlbWJseUZ1bmN0 aW9uVHlwZSkpOwogCi0gICAgICAgICAgICBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4q IHVubGlua2VkV2FzbVRvV2FzbUNhbGxzID0gJm1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHM7Ci0g ICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNh bGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21h cEdlbmVyYXRpb25QYXJhbXMmKSB7Ci0gICAgICAgICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hS ZWdpc3RlclVzYWdlIGFsbG93U2NyYXRjaChqaXQpOworICAgICAgICBCYXNpY0Jsb2NrKiBpc1dh c21CbG9jayA9IG1fcHJvYy5hZGRCbG9jaygpOworICAgICAgICBCYXNpY0Jsb2NrKiBpc0pTQmxv Y2sgPSBtX3Byb2MuYWRkQmxvY2soKTsKKyAgICAgICAgQmFzaWNCbG9jayogY29udGludWF0aW9u ID0gbV9wcm9jLmFkZEJsb2NrKCk7CisgICAgICAgIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXdD b250cm9sVmFsdWUobV9wcm9jLCBCMzo6QnJhbmNoLCBPcmlnaW4oKSwgaXNXYXNtQ2FsbCwgRnJl cXVlbnRlZEJsb2NrKGlzV2FzbUJsb2NrKSwgRnJlcXVlbnRlZEJsb2NrKGlzSlNCbG9jaykpOwor CisgICAgICAgIFZhbHVlKiB3YXNtQ2FsbFJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigp LnNldHVwQ2FsbChtX3Byb2MsIGlzV2FzbUJsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUo cmV0dXJuVHlwZSksCisgICAgICAgICAgICBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2lu dCkgeworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0g dHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0g dHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2Vk V2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0 IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7CisgICAgICAgICAgICAgICAgICAgIEFs bG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAg ICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAg ICAgICAgICAgICAgICBqaXQuYWRkTGlua1Rhc2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBj YWxsLCBmdW5jdGlvbkluZGV4XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZlcikgeworICAgICAgICAg ICAgICAgICAgICAgICAgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZm ZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rpb25JbmRleCwgVW5saW5rZWRXYXNtVG9XYXNtQ2Fs bDo6VGFyZ2V0Ojp0b1dhc20gfSk7CisgICAgICAgICAgICAgICAgICAgIH0pOworICAgICAgICAg ICAgICAgIH0pOworICAgICAgICAgICAgfSk7CisgICAgICAgIFVwc2lsb25WYWx1ZSogd2FzbUNh bGxSZXN1bHRVcHNpbG9uID0gcmV0dXJuVHlwZSA9PSBWb2lkID8gbnVsbHB0ciA6IGlzV2FzbUJs b2NrLT5hcHBlbmROZXc8VXBzaWxvblZhbHVlPihtX3Byb2MsIE9yaWdpbigpLCB3YXNtQ2FsbFJl c3VsdCk7CisgICAgICAgIGlzV2FzbUJsb2NrLT5hcHBlbmROZXdDb250cm9sVmFsdWUobV9wcm9j LCBKdW1wLCBPcmlnaW4oKSwgY29udGludWF0aW9uKTsKKworICAgICAgICBWYWx1ZSoganNDYWxs UmVzdWx0ID0gd2FzbUNhbGxpbmdDb252ZW50aW9uKCkuc2V0dXBDYWxsKG1fcHJvYywgaXNKU0Js b2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0dXJuVHlwZSksCisgICAgICAgICAgICBb Jl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkgeworICAgICAgICAgICAgICAgIHBhdGNo cG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRj aHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRj aHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbklu ZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJh bXMmKSB7CisgICAgICAgICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2Fn ZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpD YWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICAgICAgICAgICAgICBqaXQuYWRkTGlua1Rh c2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4XSAoTGlua0J1 ZmZlciYgbGlua0J1ZmZlcikgeworICAgICAgICAgICAgICAgICAgICAgICAgdW5saW5rZWRXYXNt VG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZmZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rp b25JbmRleCwgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbDo6VGFyZ2V0Ojp0b0pTIH0pOworICAgICAg ICAgICAgICAgICAgICB9KTsKKyAgICAgICAgICAgICAgICB9KTsKKyAgICAgICAgICAgIH0pOwor ICAgICAgICBVcHNpbG9uVmFsdWUqIGpzQ2FsbFJlc3VsdFVwc2lsb24gPSByZXR1cm5UeXBlID09 IFZvaWQgPyBudWxscHRyIDogaXNKU0Jsb2NrLT5hcHBlbmROZXc8VXBzaWxvblZhbHVlPihtX3By b2MsIE9yaWdpbigpLCBqc0NhbGxSZXN1bHQpOworICAgICAgICBpc0pTQmxvY2stPmFwcGVuZE5l d0NvbnRyb2xWYWx1ZShtX3Byb2MsIEp1bXAsIE9yaWdpbigpLCBjb250aW51YXRpb24pOworCisg ICAgICAgIG1fY3VycmVudEJsb2NrID0gY29udGludWF0aW9uOwogCi0gICAgICAgICAgICAgICAg Q0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICBpZiAocmV0dXJu VHlwZSA9PSBWb2lkKQorICAgICAgICAgICAgcmVzdWx0ID0gbnVsbHB0cjsKKyAgICAgICAgZWxz ZSB7CisgICAgICAgICAgICByZXN1bHQgPSBjb250aW51YXRpb24tPmFwcGVuZE5ldzxWYWx1ZT4o bV9wcm9jLCBQaGksIHRvQjNUeXBlKHJldHVyblR5cGUpLCBPcmlnaW4oKSk7CisgICAgICAgICAg ICB3YXNtQ2FsbFJlc3VsdFVwc2lsb24tPnNldFBoaShyZXN1bHQpOworICAgICAgICAgICAganND YWxsUmVzdWx0VXBzaWxvbi0+c2V0UGhpKHJlc3VsdCk7CisgICAgICAgIH0KIAotICAgICAgICAg ICAgICAgIGppdC5hZGRMaW5rVGFzayhbdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGNhbGwsIGZ1 bmN0aW9uSW5kZXhdIChMaW5rQnVmZmVyJiBsaW5rQnVmZmVyKSB7Ci0gICAgICAgICAgICAgICAg ICAgIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLT5hcHBlbmQoeyBsaW5rQnVmZmVyLmxvY2F0aW9u T2YoY2FsbCksIGZ1bmN0aW9uSW5kZXggfSk7CisgICAgICAgIC8vIFRoZSBjYWxsIGNvdWxkIGhh dmUgYmVlbiB0byBhbm90aGVyIFdlYkFzc2VtYmx5IGluc3RhbmNlLCBhbmQgLyBvciBjb3VsZCBo YXZlIG1vZGlmaWVkIG91ciBNZW1vcnkuCisgICAgICAgIHJlc3RvcmVXZWJBc3NlbWJseUdsb2Jh bFN0YXRlKG1fdm0sIG1faW5mby5tZW1vcnksIG1faW5zdGFuY2VWYWx1ZSwgbV9wcm9jLCBjb250 aW51YXRpb24pOworICAgIH0gZWxzZSB7CisgICAgICAgIHJlc3VsdCA9IHdhc21DYWxsaW5nQ29u dmVudGlvbigpLnNldHVwQ2FsbChtX3Byb2MsIG1fY3VycmVudEJsb2NrLCBPcmlnaW4oKSwgYXJn cywgdG9CM1R5cGUocmV0dXJuVHlwZSksCisgICAgICAgICAgICBbJl0gKFBhdGNocG9pbnRWYWx1 ZSogcGF0Y2hwb2ludCkgeworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3Jp dGVzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJl YWRzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0 b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJz JiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7CisgICAgICAgICAg ICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0 KTsKKyAgICAgICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2Fs bCgpOworICAgICAgICAgICAgICAgICAgICBqaXQuYWRkTGlua1Rhc2soW3VubGlua2VkV2FzbVRv V2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZlcikg eworICAgICAgICAgICAgICAgICAgICAgICAgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVu ZCh7IGxpbmtCdWZmZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rpb25JbmRleCwgVW5saW5rZWRX YXNtVG9XYXNtQ2FsbDo6VGFyZ2V0Ojp0b1dhc20gfSk7CisgICAgICAgICAgICAgICAgICAgIH0p OwogICAgICAgICAgICAgICAgIH0pOwogICAgICAgICAgICAgfSk7Ci0gICAgICAgIH0pOwotCi0g ICAgaWYgKGZ1bmN0aW9uSW5kZXggPCBtX2luZm8uaW1wb3J0RnVuY3Rpb25Db3VudCgpKQotICAg ICAgICBlbWl0UmVsb2FkUGlubmVkUmVnaXN0ZXJzKCk7CisgICAgfQogCiAgICAgcmV0dXJuIHsg fTsKIH0KQEAgLTkyOSw3ICs5ODQsOCBAQCBhdXRvIEIzSVJHZW5lcmF0b3I6OmFkZENhbGxJbmRp cmVjdChjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSwgU2lnbmF0dXJlSW5kZXggcwogICAgICAg ICAgICAgfSk7CiAgICAgICAgIH0pOwogCi0gICAgZW1pdFJlbG9hZFBpbm5lZFJlZ2lzdGVycygp OworICAgIC8vIFRoZSBjYWxsIGNvdWxkIGhhdmUgYmVlbiB0byBhbm90aGVyIFdlYkFzc2VtYmx5 IGluc3RhbmNlLCBhbmQgLyBvciBjb3VsZCBoYXZlIG1vZGlmaWVkIG91ciBNZW1vcnkuCisgICAg cmVzdG9yZVdlYkFzc2VtYmx5R2xvYmFsU3RhdGUobV92bSwgbV9pbmZvLm1lbW9yeSwgbV9pbnN0 YW5jZVZhbHVlLCBtX3Byb2MsIG1fY3VycmVudEJsb2NrKTsKIAogICAgIHJldHVybiB7IH07CiB9 CkBAIC05OTgsMTIgKzEwNTQsMTAgQEAgc3RhdGljIHZvaWQgY3JlYXRlSlNUb1dhc21XcmFwcGVy KFZNJiB2bSwgQ29tcGlsYXRpb25Db250ZXh0JiBjb21waWxhdGlvbkNvbnRleHQKICAgICAgICAg fSk7CiAgICAgfQogCi0gICAgLy8gTW92ZSBtZW1vcnkgdmFsdWVzIHRvIHRoZSBhcHByb3JpYXRl IHBsYWNlcywgaWYgbmVlZGVkLgotICAgIHsKLSAgICAgICAgVmFsdWUqIGluc3RhbmNlID0gYmxv Y2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4ocHJvYywgTG9hZCwgcG9pbnRlclR5cGUoKSwgT3Jp Z2luKCksCi0gICAgICAgICAgICBibG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KHByb2Ms IE9yaWdpbigpLCAmdm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlKSk7Ci0gICAgICAgIHJlbG9h ZFBpbm5lZFJlZ2lzdGVycyhwcm9jLCBibG9jaywgaW5mbywgaW5zdGFuY2UpOwotICAgIH0KKyAg ICAvLyBGSVhNRSBUaGUgaW5zdGFuY2UgaXMgY3VycmVudGx5IHNldCBieSB0aGUgQysrIGNvZGUg aW4gV2ViQXNzZW1ibHlGdW5jdGlvbjo6Y2FsbC4gV2Ugc2hvdWxkbid0IGdvIHRocm91Z2ggdGhl IGV4dHJhIEMrKyBob29wLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MTY2NDg2CisgICAgVmFsdWUqIGluc3RhbmNlID0gYmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1 ZT4ocHJvYywgTG9hZCwgcG9pbnRlclR5cGUoKSwgT3JpZ2luKCksCisgICAgICAgIGJsb2NrLT5h cHBlbmROZXc8Q29uc3RQdHJWYWx1ZT4ocHJvYywgT3JpZ2luKCksICZ2bS50b3BKU1dlYkFzc2Vt Ymx5SW5zdGFuY2UpKTsKKyAgICByZXN0b3JlV2ViQXNzZW1ibHlHbG9iYWxTdGF0ZSh2bSwgaW5m by5tZW1vcnksIGluc3RhbmNlLCBwcm9jLCBibG9jayk7CiAKICAgICAvLyBHZXQgb3VyIGFyZ3Vt ZW50cy4KICAgICBWZWN0b3I8VmFsdWUqPiBhcmd1bWVudHM7CkBAIC0xMDQ2LDcgKzExMDAsNyBA QCBzdGF0aWMgdm9pZCBjcmVhdGVKU1RvV2FzbVdyYXBwZXIoVk0mIHZtLCBDb21waWxhdGlvbkNv bnRleHQmIGNvbXBpbGF0aW9uQ29udGV4dAogICAgIGZ1bmN0aW9uLmpzVG9XYXNtRW50cnlwb2lu dC5jYWxsZWVTYXZlUmVnaXN0ZXJzID0gcHJvYy5jYWxsZWVTYXZlUmVnaXN0ZXJzKCk7CiB9CiAK LUV4cGVjdGVkPHN0ZDo6dW5pcXVlX3B0cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0cmluZz4g cGFyc2VBbmRDb21waWxlKFZNJiB2bSwgQ29tcGlsYXRpb25Db250ZXh0JiBjb21waWxhdGlvbkNv bnRleHQsIGNvbnN0IHVpbnQ4X3QqIGZ1bmN0aW9uU3RhcnQsIHNpemVfdCBmdW5jdGlvbkxlbmd0 aCwgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUsIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21D YWxsPiYgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGNvbnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5k ZXhTcGFjZSYgZnVuY3Rpb25JbmRleFNwYWNlLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5m bywgdW5zaWduZWQgb3B0TGV2ZWwpCitFeHBlY3RlZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbUludGVy bmFsRnVuY3Rpb24+LCBTdHJpbmc+IHBhcnNlQW5kQ29tcGlsZShWTSYgdm0sIENvbXBpbGF0aW9u Q29udGV4dCYgY29tcGlsYXRpb25Db250ZXh0LCBjb25zdCB1aW50OF90KiBmdW5jdGlvblN0YXJ0 LCBzaXplX3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBWZWN0 b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjb25z dCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgY29uc3QgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiYg bW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMsIHVuc2lnbmVk IG9wdExldmVsKQogewogICAgIGF1dG8gcmVzdWx0ID0gc3RkOjptYWtlX3VuaXF1ZTxXYXNtSW50 ZXJuYWxGdW5jdGlvbj4oKTsKIApAQCAtMTA1NCw4ICsxMTA4LDggQEAgRXhwZWN0ZWQ8c3RkOjp1 bmlxdWVfcHRyPFdhc21JbnRlcm5hbEZ1bmN0aW9uPiwgU3RyaW5nPiBwYXJzZUFuZENvbXBpbGUo Vk0mIHZtLAogICAgIGNvbXBpbGF0aW9uQ29udGV4dC53YXNtRW50cnlwb2ludEpJVCA9IHN0ZDo6 bWFrZV91bmlxdWU8Q0NhbGxIZWxwZXJzPigmdm0pOwogCiAgICAgUHJvY2VkdXJlIHByb2NlZHVy ZTsKLSAgICBCM0lSR2VuZXJhdG9yIGNvbnRleHQodm0sIGluZm8sIHByb2NlZHVyZSwgcmVzdWx0 LmdldCgpLCB1bmxpbmtlZFdhc21Ub1dhc21DYWxscywgZnVuY3Rpb25JbmRleFNwYWNlKTsKLSAg ICBGdW5jdGlvblBhcnNlcjxCM0lSR2VuZXJhdG9yPiBwYXJzZXIoJnZtLCBjb250ZXh0LCBmdW5j dGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBmdW5jdGlvbkluZGV4U3BhY2Us IGluZm8pOworICAgIEIzSVJHZW5lcmF0b3IgY29udGV4dCh2bSwgaW5mbywgcHJvY2VkdXJlLCBy ZXN1bHQuZ2V0KCksIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzKTsKKyAgICBGdW5jdGlvblBhcnNl cjxCM0lSR2VuZXJhdG9yPiBwYXJzZXIoJnZtLCBjb250ZXh0LCBmdW5jdGlvblN0YXJ0LCBmdW5j dGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBpbmZvLCBtb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9Vbmlx dWVkU2lnbmF0dXJlSW5kaWNlcyk7CiAgICAgV0FTTV9GQUlMX0lGX0hFTFBFUl9GQUlMUyhwYXJz ZXIucGFyc2UoKSk7CiAKICAgICBwcm9jZWR1cmUucmVzZXRSZWFjaGFiaWxpdHkoKTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmggYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5oCmluZGV4IGI1Yzlm NDYuLjI0OWQ1NzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21C M0lSR2VuZXJhdG9yLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJH ZW5lcmF0b3IuaApAQCAtNDcsNyArNDcsNyBAQCBzdHJ1Y3QgQ29tcGlsYXRpb25Db250ZXh0IHsK ICAgICBDQ2FsbEhlbHBlcnM6OkNhbGwganNFbnRyeXBvaW50VG9XYXNtRW50cnlwb2ludENhbGw7 CiB9OwogCi1FeHBlY3RlZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbUludGVybmFsRnVuY3Rpb24+LCBT dHJpbmc+IHBhcnNlQW5kQ29tcGlsZShWTSYsIENvbXBpbGF0aW9uQ29udGV4dCYsIGNvbnN0IHVp bnQ4X3QqLCBzaXplX3QsIGNvbnN0IFNpZ25hdHVyZSosIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dh c21DYWxsPiYsIGNvbnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYsIGNvbnN0IE1vZHVs ZUluZm9ybWF0aW9uJiwgdW5zaWduZWQgb3B0TGV2ZWwgPSAxKTsKK0V4cGVjdGVkPHN0ZDo6dW5p cXVlX3B0cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0cmluZz4gcGFyc2VBbmRDb21waWxlKFZN JiwgQ29tcGlsYXRpb25Db250ZXh0JiwgY29uc3QgdWludDhfdCosIHNpemVfdCwgY29uc3QgU2ln bmF0dXJlKiwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+JiwgY29uc3QgTW9kdWxlSW5m b3JtYXRpb24mLCBjb25zdCBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+JiwgdW5zaWduZWQgb3B0TGV2 ZWwgPSAxKTsKIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KIApkaWZmIC0tZ2l0IGEvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuY3BwIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuY3BwCmluZGV4IDBlNTkyNDcuLjliYjZhNzQgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmNwcAorKysgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5jcHAKQEAgLTM2LDEzICszNiwy MSBAQAogCiBuYW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIFdhc20gewogCi1XYXNtVG9KU1N0dWIg aW1wb3J0U3R1YkdlbmVyYXRvcihWTSogdm0sIEJhZzxDYWxsTGlua0luZm8+JiBjYWxsTGlua0lu Zm9zLCBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCwgdW5zaWduZWQgaW1wb3J0SW5kZXgp Cit0eXBlZGVmIEFzc2VtYmx5SGVscGVycyBKSVQ7CisKK3N0YXRpYyB2b2lkIG1hdGVyaWFsaXpl SW1wb3J0SlNDZWxsKFZNKiB2bSwgSklUJiBqaXQsIHVuc2lnbmVkIGltcG9ydEluZGV4LCBHUFJS ZWcgZ3ByKQoreworICAgIC8vIEVhY2ggSlMgLT4gd2FzbSBlbnRyeSBzZXRzIHRoZSBXZWJBc3Nl bWJseS5JbnN0YW5jZSB3aG9zZSBleHBvcnQgaXMgYmVpbmcgY2FsbGVkLiBXZSdyZSBjYWxsaW5n IG91dCBvZiB0aGlzIEluc3RhbmNlLCBhbmQgY2FuIHRoZXJlZm9yZSBmaWd1cmUgb3V0IHRoZSBp bXBvcnQgYmVpbmcgY2FsbGVkLgorICAgIGppdC5sb2FkUHRyKCZ2bS0+dG9wSlNXZWJBc3NlbWJs eUluc3RhbmNlLCBncHIpOworICAgIGppdC5sb2FkUHRyKEpJVDo6QWRkcmVzcyhncHIsIEpTV2Vi QXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbihpbXBvcnRJbmRleCkpLCBn cHIpOworfQorCitzdGF0aWMgTWFjcm9Bc3NlbWJsZXJDb2RlUmVmIHdhc21Ub0pTKFZNKiB2bSwg QmFnPENhbGxMaW5rSW5mbz4mIGNhbGxMaW5rSW5mb3MsIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVy ZUluZGV4LCB1bnNpZ25lZCBpbXBvcnRJbmRleCkKIHsKICAgICBjb25zdCBXYXNtQ2FsbGluZ0Nv bnZlbnRpb24mIHdhc21DQyA9IHdhc21DYWxsaW5nQ29udmVudGlvbigpOwogICAgIGNvbnN0IEpT Q0NhbGxpbmdDb252ZW50aW9uJiBqc0NDID0ganNjQ2FsbGluZ0NvbnZlbnRpb24oKTsKICAgICBj b25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQodm0s IHNpZ25hdHVyZUluZGV4KTsKICAgICB1bnNpZ25lZCBhcmdDb3VudCA9IHNpZ25hdHVyZS0+YXJn dW1lbnRDb3VudCgpOwotICAgIHR5cGVkZWYgQXNzZW1ibHlIZWxwZXJzIEpJVDsKICAgICBKSVQg aml0KHZtLCBudWxscHRyKTsKIAogICAgIC8vIEJlbG93LCB3ZSBhc3N1bWUgdGhhdCB0aGUgSlMg Y2FsbGluZyBjb252ZW50aW9uIGlzIGFsd2F5cyBvbiB0aGUgc3RhY2suCkBAIC0xMzgsOSArMTQ2 LDcgQEAgV2FzbVRvSlNTdHViIGltcG9ydFN0dWJHZW5lcmF0b3IoVk0qIHZtLCBCYWc8Q2FsbExp bmtJbmZvPiYgY2FsbExpbmtJbmZvcywgU2lnbmEKICAgICBHUFJSZWcgaW1wb3J0SlNDZWxsR1BS UmVnID0gR1BSSW5mbzo6cmVnVDA7IC8vIENhbGxlZSBuZWVkcyB0byBiZSBpbiByZWdUMCBmb3Ig c2xvdyBwYXRoIGJlbG93LgogICAgIEFTU0VSVCghd2FzbUNDLm1fY2FsbGVlU2F2ZVJlZ2lzdGVy cy5nZXQoaW1wb3J0SlNDZWxsR1BSUmVnKSk7CiAKLSAgICAvLyBFYWNoIEpTIC0+IHdhc20gZW50 cnkgc2V0cyB0aGUgV2ViQXNzZW1ibHkuSW5zdGFuY2Ugd2hvc2UgZXhwb3J0IGlzIGJlaW5nIGNh bGxlZC4gV2UncmUgY2FsbGluZyBvdXQgb2YgdGhpcyBJbnN0YW5jZSwgYW5kIGNhbiB0aGVyZWZv cmUgZmlndXJlIG91dCB0aGUgaW1wb3J0IGJlaW5nIGNhbGxlZC4KLSAgICBqaXQubG9hZFB0cigm dm0tPnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZSwgaW1wb3J0SlNDZWxsR1BSUmVnKTsKLSAgICBq aXQubG9hZFB0cihKSVQ6OkFkZHJlc3MoaW1wb3J0SlNDZWxsR1BSUmVnLCBKU1dlYkFzc2VtYmx5 SW5zdGFuY2U6Om9mZnNldE9mSW1wb3J0RnVuY3Rpb24oaW1wb3J0SW5kZXgpKSwgaW1wb3J0SlND ZWxsR1BSUmVnKTsKKyAgICBtYXRlcmlhbGl6ZUltcG9ydEpTQ2VsbCh2bSwgaml0LCBpbXBvcnRJ bmRleCwgaW1wb3J0SlNDZWxsR1BSUmVnKTsKIAogICAgIHVpbnQ2NF90IHRoaXNBcmd1bWVudCA9 IFZhbHVlVW5kZWZpbmVkOyAvLyBGSVhNRSB3aGF0IGRvZXMgdGhlIFdlYkFzc2VtYmx5IHNwZWMg c2F5IHRoaXMgc2hvdWxkIGJlPyBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTY1NDcxCiAgICAgaml0LnN0b3JlNjQoaW1wb3J0SlNDZWxsR1BSUmVnLCBjYWxsZWVGcmFt ZS53aXRoT2Zmc2V0KENhbGxGcmFtZVNsb3Q6OmNhbGxlZSAqIHN0YXRpY19jYXN0PGludD4oc2l6 ZW9mKFJlZ2lzdGVyKSkpKTsKQEAgLTIzMSw3ICsyMzcsNTYgQEAgV2FzbVRvSlNTdHViIGltcG9y dFN0dWJHZW5lcmF0b3IoVk0qIHZtLCBCYWc8Q2FsbExpbmtJbmZvPiYgY2FsbExpbmtJbmZvcywg U2lnbmEKICAgICBDb2RlTG9jYXRpb25MYWJlbCBob3RQYXRoQmVnaW4ocGF0Y2hCdWZmZXIubG9j YXRpb25PZih0YXJnZXRUb0NoZWNrKSk7CiAgICAgQ29kZUxvY2F0aW9uTmVhckNhbGwgaG90UGF0 aE90aGVyID0gcGF0Y2hCdWZmZXIubG9jYXRpb25PZk5lYXJDYWxsKGZhc3RDYWxsKTsKICAgICBj YWxsTGlua0luZm8tPnNldENhbGxMb2NhdGlvbnMoY2FsbFJldHVybkxvY2F0aW9uLCBob3RQYXRo QmVnaW4sIGhvdFBhdGhPdGhlcik7Ci0gICAgcmV0dXJuIEZJTkFMSVpFX0NPREUocGF0Y2hCdWZm ZXIsICgiV2ViQXNzZW1ibHkgaW1wb3J0WyVpXSBzdHViIGZvciBzaWduYXR1cmUgJWkiLCBpbXBv cnRJbmRleCwgc2lnbmF0dXJlSW5kZXgpKTsKKyAgICBTdHJpbmcgc2lnbmF0dXJlRGVzY3JpcHRp b24gPSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KHZtLCBzaWduYXR1cmVJbmRleCktPnRvU3Ry aW5nKCk7CisgICAgcmV0dXJuIEZJTkFMSVpFX0NPREUocGF0Y2hCdWZmZXIsICgiV2ViQXNzZW1i bHktPkphdmFTY3JpcHQgaW1wb3J0WyVpXSAlcyIsIGltcG9ydEluZGV4LCBzaWduYXR1cmVEZXNj cmlwdGlvbi5hc2NpaSgpLmRhdGEoKSkpOworfQorCitzdGF0aWMgTWFjcm9Bc3NlbWJsZXJDb2Rl UmVmIHdhc21Ub1dhc20oVk0qIHZtLCB1bnNpZ25lZCBpbXBvcnRJbmRleCkKK3sKKyAgICBjb25z dCBQaW5uZWRSZWdpc3RlckluZm8mIHBpbm5lZFJlZ3MgPSBQaW5uZWRSZWdpc3RlckluZm86Omdl dCgpOworICAgIEpJVCBqaXQodm0sIG51bGxwdHIpOworCisgICAgR1BSUmVnIHNjcmF0Y2ggPSBH UFJJbmZvOjpub25QcmVzZXJ2ZWROb25Bcmd1bWVudEdQUjsKKworICAgIC8vIEIzJ3MgY2FsbCBj b2RlZ2VuIGVuc3VyZXMgdGhhdCB0aGUgSlNDZWxsIGlzIGEgV2ViQXNzZW1ibHlGdW5jdGlvbi4K KyAgICBtYXRlcmlhbGl6ZUltcG9ydEpTQ2VsbCh2bSwgaml0LCBpbXBvcnRJbmRleCwgc2NyYXRj aCk7CisKKyAgICAvLyBHZXQgdGhlIGNhbGxlZSdzIFdlYkFzc2VtYmx5Lkluc3RhbmNlIGFuZCBz ZXQgaXQgYXMgdm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlLiBUaGUgY2FsbGVyIHdpbGwgdGFr ZSBjYXJlIG9mIHJlc3RvcmluZyBpdHMgb3duIEluc3RhbmNlLgorICAgIEdQUlJlZyBiYXNlTWVt b3J5ID0gcGlubmVkUmVncy5iYXNlTWVtb3J5UG9pbnRlcjsKKyAgICBBU1NFUlQoYmFzZU1lbW9y eSAhPSBzY3JhdGNoKTsKKyAgICBqaXQubG9hZFB0cihKSVQ6OkFkZHJlc3Moc2NyYXRjaCwgV2Vi QXNzZW1ibHlGdW5jdGlvbjo6b2Zmc2V0T2ZJbnN0YW5jZSgpKSwgYmFzZU1lbW9yeSk7IC8vIElu c3RhbmNlKi4KKyAgICBqaXQuc3RvcmVQdHIoYmFzZU1lbW9yeSwgJnZtLT50b3BKU1dlYkFzc2Vt Ymx5SW5zdGFuY2UpOworCisgICAgLy8gRklYTUUgdGhlIGZvbGxvd2luZyBjb2RlIGFzc3VtZXMg dGhhdCBhbGwgV2ViQXNzZW1ibHkuSW5zdGFuY2UgaGF2ZSB0aGUgc2FtZSBwaW5uZWQgcmVnaXN0 ZXJzLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYyOTUyCisgICAg Ly8gU2V0IHVwIHRoZSBjYWxsZWUncyBiYXNlTWVtb3J5IHJlZ2lzdGVyIGFzIHdlbGwgYXMgdGhl IG1lbW9yeSBzaXplIHJlZ2lzdGVycy4KKyAgICBqaXQubG9hZFB0cihKSVQ6OkFkZHJlc3MoYmFz ZU1lbW9yeSwgSlNXZWJBc3NlbWJseUluc3RhbmNlOjpvZmZzZXRPZk1lbW9yeSgpKSwgYmFzZU1l bW9yeSk7IC8vIEpTV2ViQXNzZW1ibHlNZW1vcnkqLgorICAgIGNvbnN0IGF1dG8mIHNpemVSZWdz ID0gcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzOworICAgIEFTU0VSVChzaXplUmVncy5zaXplKCkg Pj0gMSk7CisgICAgQVNTRVJUKHNpemVSZWdzWzBdLnNpemVSZWdpc3RlciAhPSBiYXNlTWVtb3J5 KTsKKyAgICBBU1NFUlQoc2l6ZVJlZ3NbMF0uc2l6ZVJlZ2lzdGVyICE9IHNjcmF0Y2gpOworICAg IEFTU0VSVCghc2l6ZVJlZ3NbMF0uc2l6ZU9mZnNldCk7IC8vIFRoZSBmb2xsb3dpbmcgY29kZSBh c3N1bWVzIHdlIHN0YXJ0IGF0IDAsIGFuZCBjYWxjdWxhdGVzIHN1YnNlcXVlbnQgc2l6ZSByZWdp c3RlcnMgcmVsYXRpdmUgdG8gMC4KKyAgICBqaXQubG9hZFB0cihKSVQ6OkFkZHJlc3MoYmFzZU1l bW9yeSwgSlNXZWJBc3NlbWJseU1lbW9yeTo6b2Zmc2V0T2ZTaXplKCkpLCBzaXplUmVnc1swXS5z aXplUmVnaXN0ZXIpOyAvLyBNZW1vcnkgc2l6ZS4KKyAgICBqaXQubG9hZFB0cihKSVQ6OkFkZHJl c3MoYmFzZU1lbW9yeSwgSlNXZWJBc3NlbWJseU1lbW9yeTo6b2Zmc2V0T2ZNZW1vcnkoKSksIGJh c2VNZW1vcnkpOyAvLyBXYXNtTWVtb3J5Ojp2b2lkKi4KKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAx OyBpIDwgc2l6ZVJlZ3Muc2l6ZSgpOyArK2kpIHsKKyAgICAgICAgQVNTRVJUKHNpemVSZWdzW2ld LnNpemVSZWdpc3RlciAhPSBiYXNlTWVtb3J5KTsKKyAgICAgICAgQVNTRVJUKHNpemVSZWdzW2ld LnNpemVSZWdpc3RlciAhPSBzY3JhdGNoKTsKKyAgICAgICAgaml0LmFkZDY0KEpJVDo6VHJ1c3Rl ZEltbTMyKC1zaXplUmVnc1tpXS5zaXplT2Zmc2V0KSwgc2l6ZVJlZ3NbMF0uc2l6ZVJlZ2lzdGVy LCBzaXplUmVnc1sxXS5zaXplUmVnaXN0ZXIpOworICAgIH0KKworICAgIC8vIFRhaWwgY2FsbCBp bnRvIHRoZSBjYWxsZWUgV2ViQXNzZW1ibHkgZnVuY3Rpb24uCisgICAgaml0LmxvYWRQdHIoSklU OjpBZGRyZXNzKHNjcmF0Y2gsIFdlYkFzc2VtYmx5RnVuY3Rpb246Om9mZnNldE9mV2FzbUVudHJ5 UG9pbnRDb2RlKCkpLCBzY3JhdGNoKTsKKyAgICBqaXQuanVtcChzY3JhdGNoKTsKKworICAgIExp bmtCdWZmZXIgcGF0Y2hCdWZmZXIoKnZtLCBqaXQsIEdMT0JBTF9USFVOS19JRCk7CisgICAgcmV0 dXJuIEZJTkFMSVpFX0NPREUocGF0Y2hCdWZmZXIsICgiV2ViQXNzZW1ibHktPldlYkFzc2VtYmx5 IGltcG9ydFslaV0iLCBpbXBvcnRJbmRleCkpOworfQorCitXYXNtRXhpdFN0dWJzIGV4aXRTdHVi R2VuZXJhdG9yKFZNKiB2bSwgQmFnPENhbGxMaW5rSW5mbz4mIGNhbGxMaW5rSW5mb3MsIFNpZ25h dHVyZUluZGV4IHNpZ25hdHVyZUluZGV4LCB1bnNpZ25lZCBpbXBvcnRJbmRleCkKK3sKKyAgICBX YXNtRXhpdFN0dWJzIHN0dWJzOworICAgIHN0dWJzLndhc21Ub0pTID0gd2FzbVRvSlModm0sIGNh bGxMaW5rSW5mb3MsIHNpZ25hdHVyZUluZGV4LCBpbXBvcnRJbmRleCk7CisgICAgc3R1YnMud2Fz bVRvV2FzbSA9IHdhc21Ub1dhc20odm0sIGltcG9ydEluZGV4KTsKKyAgICByZXR1cm4gc3R1YnM7 CiB9CiAKIH0gfSAvLyBuYW1lc3BhY2UgSlNDOjpXYXNtCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbUJpbmRpbmcuaAppbmRleCBmZDdlMDNkLi40MDIxZjE3IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5oCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmgKQEAgLTM4LDcgKzM4LDcgQEAgY2xhc3MgQ2FsbExp bmtJbmZvOwogCiBuYW1lc3BhY2UgV2FzbSB7CiAKLVdhc21Ub0pTU3R1YiBpbXBvcnRTdHViR2Vu ZXJhdG9yKFZNKiwgQmFnPENhbGxMaW5rSW5mbz4mLCBTaWduYXR1cmVJbmRleCwgdW5zaWduZWQp OworV2FzbUV4aXRTdHVicyBleGl0U3R1YkdlbmVyYXRvcihWTSosIEJhZzxDYWxsTGlua0luZm8+ JiwgU2lnbmF0dXJlSW5kZXgsIHVuc2lnbmVkKTsKIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldh c20KIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZvcm1hdC5o IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZvcm1hdC5oCmluZGV4IGNiMmJlNTUu LjIzZDhlZDMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Gb3Jt YXQuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRm9ybWF0LmgKQEAgLTIy Miw3ICsyMjIsNiBAQCBwcml2YXRlOgogfTsKIAogc3RydWN0IE1vZHVsZUluZm9ybWF0aW9uIHsK LSAgICBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+IHNpZ25hdHVyZUluZGljZXM7CiAgICAgVmVjdG9y PEltcG9ydD4gaW1wb3J0czsKICAgICBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+IGltcG9ydEZ1bmN0 aW9uU2lnbmF0dXJlSW5kaWNlczsKICAgICBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+IGludGVybmFs RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzOwpAQCAtMjM2LDYgKzIzNSwxOCBAQCBzdHJ1Y3QgTW9k dWxlSW5mb3JtYXRpb24gewogICAgIFRhYmxlSW5mb3JtYXRpb24gdGFibGVJbmZvcm1hdGlvbjsK ICAgICBWZWN0b3I8R2xvYmFsPiBnbG9iYWxzOwogICAgIHVuc2lnbmVkIGZpcnN0SW50ZXJuYWxH bG9iYWwgeyAwIH07CisgICAgc2l6ZV90IGZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSBjb25zdCB7 IHJldHVybiBpbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMuc2l6ZSgpICsgaW50ZXJuYWxG dW5jdGlvblNpZ25hdHVyZUluZGljZXMuc2l6ZSgpOyB9CisgICAgYm9vbCBpc0ltcG9ydGVkRnVu Y3Rpb25Gcm9tRnVuY3Rpb25JbmRleFNwYWNlKHNpemVfdCBmdW5jdGlvbkluZGV4KSBjb25zdAor ICAgIHsKKyAgICAgICAgQVNTRVJUKGZ1bmN0aW9uSW5kZXggPCBmdW5jdGlvbkluZGV4U3BhY2VT aXplKCkpOworICAgICAgICByZXR1cm4gZnVuY3Rpb25JbmRleCA8IGltcG9ydEZ1bmN0aW9uU2ln bmF0dXJlSW5kaWNlcy5zaXplKCk7CisgICAgfQorICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVy ZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShzaXplX3QgZnVuY3Rpb25JbmRleCkgY29uc3QK KyAgICB7CisgICAgICAgIHJldHVybiBpc0ltcG9ydGVkRnVuY3Rpb25Gcm9tRnVuY3Rpb25JbmRl eFNwYWNlKGZ1bmN0aW9uSW5kZXgpCisgICAgICAgICAgICA/IGltcG9ydEZ1bmN0aW9uU2lnbmF0 dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4XQorICAgICAgICAgICAgOiBpbnRlcm5hbEZ1bmN0aW9u U2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4IC0gaW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJ bmRpY2VzLnNpemUoKV07CisgICAgfQogCiAgICAgdWludDMyX3QgaW1wb3J0RnVuY3Rpb25Db3Vu dCgpIGNvbnN0IHsgcmV0dXJuIGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCk7 IH0KICAgICBib29sIGhhc01lbW9yeSgpIGNvbnN0IHsgcmV0dXJuICEhbWVtb3J5OyB9CkBAIC0y NDYsNiArMjU3LDEwIEBAIHN0cnVjdCBNb2R1bGVJbmZvcm1hdGlvbiB7CiBzdHJ1Y3QgVW5saW5r ZWRXYXNtVG9XYXNtQ2FsbCB7CiAgICAgQ29kZUxvY2F0aW9uQ2FsbCBjYWxsTG9jYXRpb247CiAg ICAgc2l6ZV90IGZ1bmN0aW9uSW5kZXg7CisgICAgZW51bSBjbGFzcyBUYXJnZXQgOiB1aW50OF90 IHsKKyAgICAgICAgdG9KUywKKyAgICAgICAgdG9XYXNtLAorICAgIH0gdGFyZ2V0OwogfTsKIAog c3RydWN0IEVudHJ5cG9pbnQgewpAQCAtMjYxLDcgKzI3NiwxMCBAQCBzdHJ1Y3QgV2FzbUludGVy bmFsRnVuY3Rpb24gewogICAgIEVudHJ5cG9pbnQganNUb1dhc21FbnRyeXBvaW50OwogfTsKIAot dHlwZWRlZiBNYWNyb0Fzc2VtYmxlckNvZGVSZWYgV2FzbVRvSlNTdHViOworc3RydWN0IFdhc21F eGl0U3R1YnMgeworICAgIE1hY3JvQXNzZW1ibGVyQ29kZVJlZiB3YXNtVG9KUzsKKyAgICBNYWNy b0Fzc2VtYmxlckNvZGVSZWYgd2FzbVRvV2FzbTsKK307CiAKIC8vIFdlYkFzc2VtYmx5IGRpcmVj dCBjYWxscyBhbmQgY2FsbF9pbmRpcmVjdCB1c2UgaW5kaWNlcyBpbnRvICJmdW5jdGlvbiBpbmRl eCBzcGFjZSIuIFRoaXMgc3BhY2Ugc3RhcnRzIHdpdGggYWxsIGltcG9ydHMsIGFuZCB0aGVuIGFs bCBpbnRlcm5hbCBmdW5jdGlvbnMuCiAvLyBDYWxsYWJsZUZ1bmN0aW9uIGFuZCBGdW5jdGlvbklu ZGV4U3BhY2UgYXJlIG9ubHkgbWVhbnQgYXMgZmFzdCBsb29rdXAgdGFibGVzIGZvciB0aGVzZSBv cGNvZGVzLCBhbmQgZG8gbm90IG93biBjb2RlLgpAQCAtMjgwLDEyICsyOTgsNiBAQCBzdHJ1Y3Qg Q2FsbGFibGVGdW5jdGlvbiB7CiB9OwogdHlwZWRlZiBWZWN0b3I8Q2FsbGFibGVGdW5jdGlvbj4g RnVuY3Rpb25JbmRleFNwYWNlOwogCi0KLXN0cnVjdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3Bh Y2UgewotICAgIE1hbGxvY1B0cjxDYWxsYWJsZUZ1bmN0aW9uPiBidWZmZXI7Ci0gICAgc2l6ZV90 IHNpemU7Ci19OwotCiB9IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2FzbQogCiAjZW5kaWYgLy8gRU5B QkxFKFdFQkFTU0VNQkxZKQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbUZ1bmN0aW9uUGFyc2VyLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVu Y3Rpb25QYXJzZXIuaAppbmRleCA1MjAxMGRjLi4zMTEwNWQ4IDEwMDY0NAotLS0gYS9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rpb25QYXJzZXIuaAorKysgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rpb25QYXJzZXIuaApAQCAtNDYsNyArNDYsNyBAQCBw dWJsaWM6CiAgICAgdHlwZWRlZiB0eXBlbmFtZSBDb250ZXh0OjpDb250cm9sVHlwZSBDb250cm9s VHlwZTsKICAgICB0eXBlZGVmIHR5cGVuYW1lIENvbnRleHQ6OkV4cHJlc3Npb25MaXN0IEV4cHJl c3Npb25MaXN0OwogCi0gICAgRnVuY3Rpb25QYXJzZXIoVk0qLCBDb250ZXh0JiwgY29uc3QgdWlu dDhfdCogZnVuY3Rpb25TdGFydCwgc2l6ZV90IGZ1bmN0aW9uTGVuZ3RoLCBjb25zdCBTaWduYXR1 cmUqLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmLCBjb25zdCBNb2R1bGVJbmZv cm1hdGlvbiYpOworICAgIEZ1bmN0aW9uUGFyc2VyKFZNKiwgQ29udGV4dCYsIGNvbnN0IHVpbnQ4 X3QqIGZ1bmN0aW9uU3RhcnQsIHNpemVfdCBmdW5jdGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0dXJl KiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mLCBjb25zdCBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+ Jik7CiAKICAgICBSZXN1bHQgV0FSTl9VTlVTRURfUkVUVVJOIHBhcnNlKCk7CiAKQEAgLTgyLDE4 ICs4MiwxOCBAQCBwcml2YXRlOgogICAgIEV4cHJlc3Npb25MaXN0IG1fZXhwcmVzc2lvblN0YWNr OwogICAgIFZlY3RvcjxDb250cm9sRW50cnk+IG1fY29udHJvbFN0YWNrOwogICAgIGNvbnN0IFNp Z25hdHVyZSogbV9zaWduYXR1cmU7Ci0gICAgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNw YWNlJiBtX2Z1bmN0aW9uSW5kZXhTcGFjZTsKICAgICBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYg bV9pbmZvOworICAgIGNvbnN0IFZlY3RvcjxTaWduYXR1cmVJbmRleD4mIG1fbW9kdWxlU2lnbmF0 dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXM7CiAgICAgdW5zaWduZWQgbV91bnJl YWNoYWJsZUJsb2NrcyB7IDAgfTsKIH07CiAKIHRlbXBsYXRlPHR5cGVuYW1lIENvbnRleHQ+Ci1G dW5jdGlvblBhcnNlcjxDb250ZXh0Pjo6RnVuY3Rpb25QYXJzZXIoVk0qIHZtLCBDb250ZXh0JiBj b250ZXh0LCBjb25zdCB1aW50OF90KiBmdW5jdGlvblN0YXJ0LCBzaXplX3QgZnVuY3Rpb25MZW5n dGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbklu ZGV4U3BhY2UmIGZ1bmN0aW9uSW5kZXhTcGFjZSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGlu Zm8pCitGdW5jdGlvblBhcnNlcjxDb250ZXh0Pjo6RnVuY3Rpb25QYXJzZXIoVk0qIHZtLCBDb250 ZXh0JiBjb250ZXh0LCBjb25zdCB1aW50OF90KiBmdW5jdGlvblN0YXJ0LCBzaXplX3QgZnVuY3Rp b25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBjb25zdCBNb2R1bGVJbmZvcm1h dGlvbiYgaW5mbywgY29uc3QgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiYgbW9kdWxlU2lnbmF0dXJl SW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMpCiAgICAgOiBQYXJzZXIodm0sIGZ1bmN0 aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoKQogICAgICwgbV9jb250ZXh0KGNvbnRleHQpCiAgICAg LCBtX3NpZ25hdHVyZShzaWduYXR1cmUpCi0gICAgLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZShmdW5j dGlvbkluZGV4U3BhY2UpCiAgICAgLCBtX2luZm8oaW5mbykKKyAgICAsIG1fbW9kdWxlU2lnbmF0 dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMobW9kdWxlU2lnbmF0dXJlSW5kaWNl c1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMpCiB7CiAgICAgaWYgKHZlcmJvc2UpCiAgICAgICAg IGRhdGFMb2dMbigiUGFyc2luZyBmdW5jdGlvbiBzdGFydGluZyBhdDogIiwgKHVpbnRwdHJfdClm dW5jdGlvblN0YXJ0LCAiIG9mIGxlbmd0aDogIiwgZnVuY3Rpb25MZW5ndGgpOwpAQCAtMzA4LDkg KzMwOCw5IEBAIGF1dG8gRnVuY3Rpb25QYXJzZXI8Q29udGV4dD46OnBhcnNlRXhwcmVzc2lvbihP cFR5cGUgb3ApIC0+IFBhcnRpYWxSZXN1bHQKICAgICBjYXNlIENhbGw6IHsKICAgICAgICAgdWlu dDMyX3QgZnVuY3Rpb25JbmRleDsKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VW YXJVSW50MzIoZnVuY3Rpb25JbmRleCksICJjYW4ndCBwYXJzZSBjYWxsJ3MgZnVuY3Rpb24gaW5k ZXgiKTsKLSAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1fZnVu Y3Rpb25JbmRleFNwYWNlLnNpemUsICJjYWxsIGZ1bmN0aW9uIGluZGV4ICIsIGZ1bmN0aW9uSW5k ZXgsICIgZXhjZWVkcyBmdW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX2Z1bmN0aW9uSW5kZXhTcGFj ZS5zaXplKTsKKyAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1f aW5mby5mdW5jdGlvbkluZGV4U3BhY2VTaXplKCksICJjYWxsIGZ1bmN0aW9uIGluZGV4ICIsIGZ1 bmN0aW9uSW5kZXgsICIgZXhjZWVkcyBmdW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX2luZm8uZnVu Y3Rpb25JbmRleFNwYWNlU2l6ZSgpKTsKIAotICAgICAgICBTaWduYXR1cmVJbmRleCBjYWxsZWVT aWduYXR1cmVJbmRleCA9IG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtmdW5jdGlv bkluZGV4XS5zaWduYXR1cmVJbmRleDsKKyAgICAgICAgU2lnbmF0dXJlSW5kZXggY2FsbGVlU2ln bmF0dXJlSW5kZXggPSBtX2luZm8uc2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRleFNwYWNl KGZ1bmN0aW9uSW5kZXgpOwogICAgICAgICBjb25zdCBTaWduYXR1cmUqIGNhbGxlZVNpZ25hdHVy ZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgY2FsbGVlU2lnbmF0dXJlSW5kZXgp OwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGNhbGxlZVNpZ25hdHVyZS0+YXJndW1lbnRD b3VudCgpID4gbV9leHByZXNzaW9uU3RhY2suc2l6ZSgpLCAiY2FsbCBmdW5jdGlvbiBpbmRleCAi LCBmdW5jdGlvbkluZGV4LCAiIGhhcyAiLCBjYWxsZWVTaWduYXR1cmUtPmFyZ3VtZW50Q291bnQo KSwgIiBhcmd1bWVudHMsIGJ1dCB0aGUgZXhwcmVzc2lvbiBzdGFjayBjdXJyZW50bHkgaG9sZHMg IiwgbV9leHByZXNzaW9uU3RhY2suc2l6ZSgpLCAiIHZhbHVlcyIpOwogCkBAIC0zMzcsOSArMzM3 LDkgQEAgYXV0byBGdW5jdGlvblBhcnNlcjxDb250ZXh0Pjo6cGFyc2VFeHByZXNzaW9uKE9wVHlw ZSBvcCkgLT4gUGFydGlhbFJlc3VsdAogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJz ZVZhclVJbnQzMihzaWduYXR1cmVJbmRleCksICJjYW4ndCBnZXQgY2FsbF9pbmRpcmVjdCdzIHNp Z25hdHVyZSBpbmRleCIpOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJ bnQxKHJlc2VydmVkKSwgImNhbid0IGdldCBjYWxsX2luZGlyZWN0J3MgcmVzZXJ2ZWQgYnl0ZSIp OwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHJlc2VydmVkLCAiY2FsbF9pbmRpcmVjdCdz ICdyZXNlcnZlZCcgdmFydWludDEgbXVzdCBiZSAweDAiKTsKLSAgICAgICAgV0FTTV9QQVJTRVJf RkFJTF9JRihtX2luZm8uc2lnbmF0dXJlSW5kaWNlcy5zaXplKCkgPD0gc2lnbmF0dXJlSW5kZXgs ICJjYWxsX2luZGlyZWN0J3Mgc2lnbmF0dXJlIGluZGV4ICIsIHNpZ25hdHVyZUluZGV4LCAiIGV4 Y2VlZHMga25vd24gc2lnbmF0dXJlcyAiLCBtX2luZm8uc2lnbmF0dXJlSW5kaWNlcy5zaXplKCkp OworICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1Rv VW5pcXVlZFNpZ25hdHVyZUluZGljZXMuc2l6ZSgpIDw9IHNpZ25hdHVyZUluZGV4LCAiY2FsbF9p bmRpcmVjdCdzIHNpZ25hdHVyZSBpbmRleCAiLCBzaWduYXR1cmVJbmRleCwgIiBleGNlZWRzIGtu b3duIHNpZ25hdHVyZXMgIiwgbV9tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0 dXJlSW5kaWNlcy5zaXplKCkpOwogCi0gICAgICAgIFNpZ25hdHVyZUluZGV4IGNhbGxlZVNpZ25h dHVyZUluZGV4ID0gbV9pbmZvLnNpZ25hdHVyZUluZGljZXNbc2lnbmF0dXJlSW5kZXhdOworICAg ICAgICBTaWduYXR1cmVJbmRleCBjYWxsZWVTaWduYXR1cmVJbmRleCA9IG1fbW9kdWxlU2lnbmF0 dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXNbc2lnbmF0dXJlSW5kZXhdOwogICAg ICAgICBjb25zdCBTaWduYXR1cmUqIGNhbGxlZVNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0 aW9uOjpnZXQobV92bSwgY2FsbGVlU2lnbmF0dXJlSW5kZXgpOwogICAgICAgICBzaXplX3QgYXJn dW1lbnRDb3VudCA9IGNhbGxlZVNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpICsgMTsgLy8gQWRk IHRoZSBjYWxsZWUncyBpbmRleC4KICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihhcmd1bWVu dENvdW50ID4gbV9leHByZXNzaW9uU3RhY2suc2l6ZSgpLCAiY2FsbF9pbmRpcmVjdCBleHBlY3Rz ICIsIGFyZ3VtZW50Q291bnQsICIgYXJndW1lbnRzLCBidXQgdGhlIGV4cHJlc3Npb24gc3RhY2sg Y3VycmVudGx5IGhvbGRzICIsIG1fZXhwcmVzc2lvblN0YWNrLnNpemUoKSwgIiB2YWx1ZXMiKTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5jcHAKaW5kZXggNzAwZTNhYy4u YWFkOTFjMSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9y eS5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5jcHAKQEAg LTI4LDE1ICsyOCwzOSBAQAogCiAjaWYgRU5BQkxFKFdFQkFTU0VNQkxZKQogCisjaW5jbHVkZSA8 d3RmL0hleE51bWJlci5oPgorI2luY2x1ZGUgPHd0Zi9QcmludFN0cmVhbS5oPgorI2luY2x1ZGUg PHd0Zi90ZXh0L1dURlN0cmluZy5oPgorCiBuYW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIFdhc20g ewogCituYW1lc3BhY2UgeworY29uc3QgYm9vbCB2ZXJib3NlID0gZmFsc2U7Cit9CisKK3ZvaWQg TWVtb3J5OjpkdW1wKFByaW50U3RyZWFtJiBvdXQpIGNvbnN0Cit7CisgICAgU3RyaW5nIG1lbW9y eUhleDsKKyAgICBXVEY6OmFwcGVuZFVuc2lnbmVkNjRBc0hleCgodWludDY0X3QpKHVpbnRwdHJf dCltX21lbW9yeSwgbWVtb3J5SGV4KTsKKyAgICBvdXQucHJpbnQoIk1lbW9yeSBhdCAweCIsIG1l bW9yeUhleCwgIiwgc2l6ZSAiLCBtX3NpemUsICJCIGNhcGFjaXR5ICIsIG1fbWFwcGVkQ2FwYWNp dHksICJCLCBpbml0aWFsICIsIG1faW5pdGlhbCwgIiBtYXhpbXVtICIsIG1fbWF4aW11bSwgIiBt b2RlICIsIG1ha2VTdHJpbmcobV9tb2RlKSk7Cit9CisKK2NvbnN0IGNoYXIqIE1lbW9yeTo6bWFr ZVN0cmluZyhNb2RlIG1vZGUpIGNvbnN0Cit7CisgICAgc3dpdGNoIChtb2RlKSB7CisgICAgY2Fz ZSBNb2RlOjpCb3VuZHNDaGVja2luZzogcmV0dXJuICJCb3VuZHNDaGVja2luZyI7CisgICAgfQor ICAgIFJFTEVBU0VfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgcmV0dXJuICIiOworfQorCiBz dGF0aWNfYXNzZXJ0KHNpemVvZih1aW50NjRfdCkgPT0gc2l6ZW9mKHNpemVfdCksICJXZSByZWx5 IG9uIGFsbG93aW5nIHRoZSBtYXhpbXVtIHNpemUgb2YgTWVtb3J5IHdlIG1hcCB0byBiZSAyXjMy IHdoaWNoIGlzIGxhcmdlciB0aGFuIGZpdHMgaW4gYSAzMi1iaXQgaW50ZWdlciB0aGF0IHdlJ2Qg cGFzcyB0byBtcHJvdGVjdCBpZiB0aGlzIGRpZG4ndCBob2xkLiIpOwogCiBNZW1vcnk6Ok1lbW9y eShQYWdlQ291bnQgaW5pdGlhbCwgUGFnZUNvdW50IG1heGltdW0sIGJvb2wmIGZhaWxlZCkKLSAg ICA6IG1fbW9kZShNb2RlOjpCb3VuZHNDaGVja2luZykKKyAgICA6IG1fc2l6ZShpbml0aWFsLmJ5 dGVzKCkpCiAgICAgLCBtX2luaXRpYWwoaW5pdGlhbCkKICAgICAsIG1fbWF4aW11bShtYXhpbXVt KQotICAgICwgbV9zaXplKGluaXRpYWwuYnl0ZXMoKSkKKyAgICAsIG1fbW9kZShNb2RlOjpCb3Vu ZHNDaGVja2luZykKICAgICAvLyBGSVhNRTogSWYgd2UgYWRkIHNpZ25hbCBiYXNlZCBib3VuZHMg Y2hlY2tpbmcgdGhlbiB3ZSBuZWVkIGV4dHJhIHNwYWNlIGZvciBvdmVyZmxvdyBvbiBsb2FkLgog ICAgIC8vIHNlZTogaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MjY5 MwogewpAQCAtNDYsOSArNzAsMTEgQEAgTWVtb3J5OjpNZW1vcnkoUGFnZUNvdW50IGluaXRpYWws IFBhZ2VDb3VudCBtYXhpbXVtLCBib29sJiBmYWlsZWQpCiAgICAgaWYgKCFtX21hcHBlZENhcGFj aXR5KSB7CiAgICAgICAgIC8vIFRoaXMgbWVhbnMgd2Ugc3BlY2lmaWVkIGEgemVybyBhcyBtYXhp bXVtICh3aGljaCBtZWFucyB3ZSBhbHNvIGhhdmUgemVybyBhcyBpbml0aWFsIHNpemUpLgogICAg ICAgICBSRUxFQVNFX0FTU0VSVChtX3NpemUgPT0gMCk7Ci0gICAgICAgIG1fbWFwcGVkQ2FwYWNp dHkgPSAwOwogICAgICAgICBtX21lbW9yeSA9IG51bGxwdHI7CisgICAgICAgIG1fbWFwcGVkQ2Fw YWNpdHkgPSAwOwogICAgICAgICBmYWlsZWQgPSBmYWxzZTsKKyAgICAgICAgaWYgKHZlcmJvc2Up CisgICAgICAgICAgICBkYXRhTG9nTG4oIk1lbW9yeTo6TWVtb3J5IGFsbG9jYXRpbmcgbm90aGlu ZyAiLCAqdGhpcyk7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAKQEAgLTU2LDE1ICs4MiwyMSBA QCBNZW1vcnk6Ok1lbW9yeShQYWdlQ291bnQgaW5pdGlhbCwgUGFnZUNvdW50IG1heGltdW0sIGJv b2wmIGZhaWxlZCkKICAgICB2b2lkKiByZXN1bHQgPSBPcHRpb25zOjpzaW11bGF0ZVdlYkFzc2Vt Ymx5TG93TWVtb3J5KCkgPyBNQVBfRkFJTEVEIDogbW1hcChudWxscHRyLCBtX21hcHBlZENhcGFj aXR5LCBQUk9UX05PTkUsIE1BUF9QUklWQVRFIHwgTUFQX0FOT04sIC0xLCAwKTsKICAgICBpZiAo cmVzdWx0ID09IE1BUF9GQUlMRUQpIHsKICAgICAgICAgLy8gVHJ5IGFnYWluIHdpdGggYSBkaWZm ZXJlbnQgbnVtYmVyLgorICAgICAgICBpZiAodmVyYm9zZSkKKyAgICAgICAgICAgIGRhdGFMb2dM bigiTWVtb3J5OjpNZW1vcnkgbW1hcCBmYWlsZWQgb25jZSBmb3IgY2FwYWNpdHksIHRyeWluZyBh Z2FpbiIsICp0aGlzKTsKICAgICAgICAgbV9tYXBwZWRDYXBhY2l0eSA9IG1fc2l6ZTsKICAgICAg ICAgaWYgKCFtX21hcHBlZENhcGFjaXR5KSB7CiAgICAgICAgICAgICBtX21lbW9yeSA9IG51bGxw dHI7CiAgICAgICAgICAgICBmYWlsZWQgPSBmYWxzZTsKKyAgICAgICAgICAgIGlmICh2ZXJib3Nl KQorICAgICAgICAgICAgICAgIGRhdGFMb2dMbigiTWVtb3J5OjpNZW1vcnkgbW1hcCBub3QgdHJ5 aW5nIGFnYWluIGJlY2F1c2Ugc2l6ZSBpcyB6ZXJvICIsICp0aGlzKTsKICAgICAgICAgICAgIHJl dHVybjsKICAgICAgICAgfQogCiAgICAgICAgIHJlc3VsdCA9IG1tYXAobnVsbHB0ciwgbV9tYXBw ZWRDYXBhY2l0eSwgUFJPVF9OT05FLCBNQVBfUFJJVkFURSB8IE1BUF9BTk9OLCAtMSwgMCk7CiAg ICAgICAgIGlmIChyZXN1bHQgPT0gTUFQX0ZBSUxFRCkgeworICAgICAgICAgICAgaWYgKHZlcmJv c2UpCisgICAgICAgICAgICAgICAgZGF0YUxvZ0xuKCJNZW1vcnk6Ok1lbW9yeSBtbWFwIGZhaWxl ZCB0d2ljZSAiLCAqdGhpcyk7CiAgICAgICAgICAgICBmYWlsZWQgPSB0cnVlOwogICAgICAgICAg ICAgcmV0dXJuOwogICAgICAgICB9CkBAIC03OCwxMiArMTEwLDI3IEBAIE1lbW9yeTo6TWVtb3J5 KFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSwgYm9vbCYgZmFpbGVkKQogCiAg ICAgbV9tZW1vcnkgPSByZXN1bHQ7CiAgICAgZmFpbGVkID0gZmFsc2U7CisgICAgaWYgKHZlcmJv c2UpCisgICAgICAgIGRhdGFMb2dMbigiTWVtb3J5OjpNZW1vcnkgbW1hcCBzdWNjZWVkZWQgIiwg KnRoaXMpOworfQorCitNZW1vcnk6On5NZW1vcnkoKQoreworICAgIGlmICh2ZXJib3NlKQorICAg ICAgICBkYXRhTG9nTG4oIk1lbW9yeTo6fk1lbW9yeSAiLCAqdGhpcyk7CisgICAgaWYgKG1fbWVt b3J5KSB7CisgICAgICAgIGlmIChtdW5tYXAobV9tZW1vcnksIG1fbWFwcGVkQ2FwYWNpdHkpKQor ICAgICAgICAgICAgQ1JBU0goKTsKKyAgICB9CiB9CiAKIGJvb2wgTWVtb3J5Ojpncm93KFBhZ2VD b3VudCBuZXdTaXplKQogewogICAgIFJFTEVBU0VfQVNTRVJUKG5ld1NpemUgPiBQYWdlQ291bnQ6 OmZyb21CeXRlcyhtX3NpemUpKTsKIAorICAgIGlmICh2ZXJib3NlKQorICAgICAgICBkYXRhTG9n TG4oIk1lbW9yeTo6Z3JvdyB0byAiLCBuZXdTaXplLCAiIGZyb20gIiwgKnRoaXMpOworCiAgICAg aWYgKG1heGltdW0oKSAmJiBuZXdTaXplID4gbWF4aW11bSgpKQogICAgICAgICByZXR1cm4gZmFs c2U7CiAKQEAgLTkzLDYgKzE0MCw4IEBAIGJvb2wgTWVtb3J5Ojpncm93KFBhZ2VDb3VudCBuZXdT aXplKQogICAgICAgICBib29sIHN1Y2Nlc3MgPSAhbXByb3RlY3Qoc3RhdGljX2Nhc3Q8dWludDhf dCo+KG1fbWVtb3J5KSArIG1fc2l6ZSwgc3RhdGljX2Nhc3Q8c2l6ZV90PihkZXNpcmVkU2l6ZSAt IG1fc2l6ZSksIFBST1RfUkVBRCB8IFBST1RfV1JJVEUpOwogICAgICAgICBSRUxFQVNFX0FTU0VS VChzdWNjZXNzKTsKICAgICAgICAgbV9zaXplID0gZGVzaXJlZFNpemU7CisgICAgICAgIGlmICh2 ZXJib3NlKQorICAgICAgICAgICAgZGF0YUxvZ0xuKCJNZW1vcnk6Omdyb3cgaW4tcGxhY2UgIiwg KnRoaXMpOwogICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICB9CiAKQEAgLTExMCw2ICsxNTksOCBA QCBib29sIE1lbW9yeTo6Z3JvdyhQYWdlQ291bnQgbmV3U2l6ZSkKICAgICBtX21hcHBlZENhcGFj aXR5ID0gZGVzaXJlZFNpemU7CiAgICAgbV9zaXplID0gZGVzaXJlZFNpemU7CiAKKyAgICBpZiAo dmVyYm9zZSkKKyAgICAgICAgZGF0YUxvZ0xuKCJNZW1vcnk6Omdyb3cgIiwgKnRoaXMpOwogICAg IHJldHVybiB0cnVlOwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtTWVtb3J5LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmgK aW5kZXggNGU1ZWUzNi4uZTQ3MGM0MSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbU1lbW9yeS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21N ZW1vcnkuaApAQCAtMzAsNyArMzAsOSBAQAogI2luY2x1ZGUgIldhc21DYWxsaW5nQ29udmVudGlv bi5oIgogI2luY2x1ZGUgIldhc21QYWdlQ291bnQuaCIKIAotI2luY2x1ZGUgPHd0Zi9WZWN0b3Iu aD4KK25hbWVzcGFjZSBXVEYgeworY2xhc3MgUHJpbnRTdHJlYW07Cit9CiAKIG5hbWVzcGFjZSBK U0MgeyBuYW1lc3BhY2UgV2FzbSB7CiAKQEAgLTM4LDQxICs0MCw1MCBAQCBjbGFzcyBNZW1vcnkg ewogICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKE1lbW9yeSk7CiAgICAgV1RGX01BS0VfRkFTVF9B TExPQ0FURUQ7CiBwdWJsaWM6CisgICAgdm9pZCBkdW1wKFdURjo6UHJpbnRTdHJlYW0mKSBjb25z dDsKIAogICAgIC8vIEZJWE1FOiBXZSBzaG91bGQgc3VwcG9ydCBvdGhlciBtb2Rlcy4gc2VlOiBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYyNjkzCiAgICAgZW51bSBj bGFzcyBNb2RlIHsKICAgICAgICAgQm91bmRzQ2hlY2tpbmcKICAgICB9OworICAgIGNvbnN0IGNo YXIqIG1ha2VTdHJpbmcoTW9kZSkgY29uc3Q7CiAKKyAgICBNZW1vcnkoKSA9IGRlZmF1bHQ7CiAg ICAgSlNfRVhQT1JUX1BSSVZBVEUgTWVtb3J5KFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQg bWF4aW11bSwgYm9vbCYgZmFpbGVkKTsKLQotICAgIH5NZW1vcnkoKQorICAgIE1lbW9yeShNZW1v cnkmJiBvdGhlcikKKyAgICAgICAgOiBtX21lbW9yeShvdGhlci5tX21lbW9yeSkKKyAgICAgICAg LCBtX3NpemUob3RoZXIubV9zaXplKQorICAgICAgICAsIG1faW5pdGlhbChvdGhlci5tX2luaXRp YWwpCisgICAgICAgICwgbV9tYXhpbXVtKG90aGVyLm1fbWF4aW11bSkKKyAgICAgICAgLCBtX21h cHBlZENhcGFjaXR5KG90aGVyLm1fbWFwcGVkQ2FwYWNpdHkpCisgICAgICAgICwgbV9tb2RlKG90 aGVyLm1fbW9kZSkKICAgICB7Ci0gICAgICAgIGlmIChtX21lbW9yeSkKLSAgICAgICAgICAgIG11 bm1hcChtX21lbW9yeSwgbV9tYXBwZWRDYXBhY2l0eSk7CisgICAgICAgIC8vIE1vdmluZyB0cmFu c2ZlcnMgb3duZXJzaGlwIG9mIHRoZSBhbGxvY2F0ZWQgbWVtb3J5LgorICAgICAgICBvdGhlci5t X21lbW9yeSA9IG51bGxwdHI7CiAgICAgfQorICAgIEpTX0VYUE9SVF9QUklWQVRFIH5NZW1vcnko KTsKIAogICAgIHZvaWQqIG1lbW9yeSgpIGNvbnN0IHsgcmV0dXJuIG1fbWVtb3J5OyB9CiAgICAg dWludDY0X3Qgc2l6ZSgpIGNvbnN0IHsgcmV0dXJuIG1fc2l6ZTsgfQogICAgIFBhZ2VDb3VudCBz aXplSW5QYWdlcygpIGNvbnN0IHsgcmV0dXJuIFBhZ2VDb3VudDo6ZnJvbUJ5dGVzKG1fc2l6ZSk7 IH0KIAotICAgIE1vZGUgbW9kZSgpIGNvbnN0IHsgcmV0dXJuIG1fbW9kZTsgfQotCiAgICAgUGFn ZUNvdW50IGluaXRpYWwoKSBjb25zdCB7IHJldHVybiBtX2luaXRpYWw7IH0KICAgICBQYWdlQ291 bnQgbWF4aW11bSgpIGNvbnN0IHsgcmV0dXJuIG1fbWF4aW11bTsgfQogCisgICAgTW9kZSBtb2Rl KCkgY29uc3QgeyByZXR1cm4gbV9tb2RlOyB9CisKICAgICBib29sIGdyb3coUGFnZUNvdW50KTsK IAotICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZTaXplKCkgeyByZXR1cm4gT0JKRUNUX09G RlNFVE9GKE1lbW9yeSwgbV9zaXplKTsgfQogICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZN ZW1vcnkoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoTWVtb3J5LCBtX21lbW9yeSk7IH0KKyAg ICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mU2l6ZSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRP RihNZW1vcnksIG1fc2l6ZSk7IH0KICAgICAKIHByaXZhdGU6CiAgICAgdm9pZCogbV9tZW1vcnkg eyBudWxscHRyIH07Ci0gICAgTW9kZSBtX21vZGU7CisgICAgdWludDY0X3QgbV9zaXplIHsgMCB9 OwogICAgIFBhZ2VDb3VudCBtX2luaXRpYWw7CiAgICAgUGFnZUNvdW50IG1fbWF4aW11bTsKLSAg ICB1aW50NjRfdCBtX3NpemUgeyAwIH07CiAgICAgdWludDY0X3QgbV9tYXBwZWRDYXBhY2l0eSB7 IDAgfTsKKyAgICBNb2RlIG1fbW9kZSB7IE1vZGU6OkJvdW5kc0NoZWNraW5nIH07CiB9OwogCiB9 IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2FzbQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL1dhc21NZW1vcnlJbmZvcm1hdGlvbi5jcHAKaW5kZXggMmUxZDMwYS4uNmIwNjNkMyAx MDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0 aW9uLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5SW5mb3Jt YXRpb24uY3BwCkBAIC0yNiwxMyArMjYsNTIgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNs dWRlICJXYXNtTWVtb3J5SW5mb3JtYXRpb24uaCIKIAotI2luY2x1ZGUgIldhc21DYWxsaW5nQ29u dmVudGlvbi5oIgotCiAjaWYgRU5BQkxFKFdFQkFTU0VNQkxZKQogCisjaW5jbHVkZSAiV2FzbUNh bGxpbmdDb252ZW50aW9uLmgiCisjaW5jbHVkZSA8d3RmL05ldmVyRGVzdHJveWVkLmg+CisKIG5h bWVzcGFjZSBKU0MgeyBuYW1lc3BhY2UgV2FzbSB7CiAKLU1lbW9yeUluZm9ybWF0aW9uOjpNZW1v cnlJbmZvcm1hdGlvbihQYWdlQ291bnQgaW5pdGlhbCwgUGFnZUNvdW50IG1heGltdW0sICBjb25z dCBWZWN0b3I8dW5zaWduZWQ+JiBwaW5uZWRTaXplUmVnaXN0ZXJzLCBib29sIGlzSW1wb3J0KQor Y29uc3QgUGlubmVkUmVnaXN0ZXJJbmZvJiBQaW5uZWRSZWdpc3RlckluZm86OmdldCgpCit7Cisg ICAgc3RhdGljIExhenlOZXZlckRlc3Ryb3llZDxQaW5uZWRSZWdpc3RlckluZm8+IHN0YXRpY1Bp bm5lZFJlZ2lzdGVySW5mbzsKKyAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgc3RhdGljUGlubmVk UmVnaXN0ZXJJbmZvRmxhZzsKKyAgICBzdGQ6OmNhbGxfb25jZShzdGF0aWNQaW5uZWRSZWdpc3Rl ckluZm9GbGFnLCBbXSAoKSB7CisgICAgICAgIFZlY3RvcjxQaW5uZWRTaXplUmVnaXN0ZXJJbmZv PiBzaXplUmVnaXN0ZXJzOworICAgICAgICBHUFJSZWcgYmFzZU1lbW9yeVBvaW50ZXI7CisKKyAg ICAgICAgLy8gRklYTUU6IFdlIHNob3VsZCBzdXBwb3J0IG1vcmUgdGhhbiBvbmUgbWVtb3J5IHNp emUgcmVnaXN0ZXIsIGFuZCB3ZSBzaG91bGQgYWxsb3cgZGlmZmVyZW50CisgICAgICAgIC8vICAg ICAgICBXZWJBc3NlbWJseS5JbnN0YW5jZSB0byBoYXZlIGRpZmZlcmVudCBwaW5zLiBSaWdodCBu b3cgd2UgdGFrZSBhIHZlY3RvciB3aXRoIG9ubHkgb25lIGVudHJ5LgorICAgICAgICAvLyAgICAg ICAgSWYgd2UgaGF2ZSBtb3JlIHRoYW4gb25lIHNpemUgcmVnaXN0ZXIsIHdlIGNhbiBoYXZlIG9u ZSBmb3IgZWFjaCBsb2FkIHNpemUgY2xhc3MuCisgICAgICAgIC8vICAgICAgICBzZWU6IGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjI5NTIKKyAgICAgICAgVmVjdG9y PHVuc2lnbmVkPiBwaW5uZWRTaXplcyA9IHsgMCB9OworICAgICAgICB1bnNpZ25lZCByZW1haW5p bmdQaW5uZWRSZWdpc3RlcnMgPSBwaW5uZWRTaXplcy5zaXplKCkgKyAxOworICAgICAgICBqc2ND YWxsaW5nQ29udmVudGlvbigpLm1fY2FsbGVlU2F2ZVJlZ2lzdGVycy5mb3JFYWNoKFsmXSAoUmVn IHJlZykgeworICAgICAgICAgICAgR1BSUmVnIGdwciA9IHJlZy5ncHIoKTsKKyAgICAgICAgICAg IGlmICghcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzIHx8IFJlZ2lzdGVyU2V0OjpzdGFja1JlZ2lz dGVycygpLmdldChyZWcpKQorICAgICAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgICAgIGlm IChyZW1haW5pbmdQaW5uZWRSZWdpc3RlcnMgPT0gMSkgeworICAgICAgICAgICAgICAgIGJhc2VN ZW1vcnlQb2ludGVyID0gZ3ByOworICAgICAgICAgICAgICAgIHJlbWFpbmluZ1Bpbm5lZFJlZ2lz dGVycy0tOworICAgICAgICAgICAgfSBlbHNlCisgICAgICAgICAgICAgICAgc2l6ZVJlZ2lzdGVy cy5hcHBlbmQoeyBncHIsIHBpbm5lZFNpemVzWy0tcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzIC0g MV0gfSk7CisgICAgICAgIH0pOworCisgICAgICAgIEFTU0VSVCghcmVtYWluaW5nUGlubmVkUmVn aXN0ZXJzKTsKKyAgICAgICAgc3RhdGljUGlubmVkUmVnaXN0ZXJJbmZvLmNvbnN0cnVjdChXVEZN b3ZlKHNpemVSZWdpc3RlcnMpLCBiYXNlTWVtb3J5UG9pbnRlcik7CisgICAgfSk7CisKKyAgICBy ZXR1cm4gc3RhdGljUGlubmVkUmVnaXN0ZXJJbmZvLmdldCgpOworfQorCitQaW5uZWRSZWdpc3Rl ckluZm86OlBpbm5lZFJlZ2lzdGVySW5mbyhWZWN0b3I8UGlubmVkU2l6ZVJlZ2lzdGVySW5mbz4m JiBzaXplUmVnaXN0ZXJzLCBHUFJSZWcgYmFzZU1lbW9yeVBvaW50ZXIpCisgICAgOiBzaXplUmVn aXN0ZXJzKFdURk1vdmUoc2l6ZVJlZ2lzdGVycykpCisgICAgLCBiYXNlTWVtb3J5UG9pbnRlcihi YXNlTWVtb3J5UG9pbnRlcikKK3sKK30KKworTWVtb3J5SW5mb3JtYXRpb246Ok1lbW9yeUluZm9y bWF0aW9uKFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSwgIGJvb2wgaXNJbXBv cnQpCiAgICAgOiBtX2luaXRpYWwoaW5pdGlhbCkKICAgICAsIG1fbWF4aW11bShtYXhpbXVtKQog ICAgICwgbV9pc0ltcG9ydChpc0ltcG9ydCkKQEAgLTQwLDIwICs3OSw2IEBAIE1lbW9yeUluZm9y bWF0aW9uOjpNZW1vcnlJbmZvcm1hdGlvbihQYWdlQ291bnQgaW5pdGlhbCwgUGFnZUNvdW50IG1h eGltdW0sICBjb25zCiAgICAgUkVMRUFTRV9BU1NFUlQoISFtX2luaXRpYWwpOwogICAgIFJFTEVB U0VfQVNTRVJUKCFtX21heGltdW0gfHwgbV9tYXhpbXVtID49IG1faW5pdGlhbCk7CiAgICAgQVNT RVJUKCEhKnRoaXMpOwotCi0gICAgdW5zaWduZWQgcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzID0g cGlubmVkU2l6ZVJlZ2lzdGVycy5zaXplKCkgKyAxOwotICAgIGpzY0NhbGxpbmdDb252ZW50aW9u KCkubV9jYWxsZWVTYXZlUmVnaXN0ZXJzLmZvckVhY2goWyZdIChSZWcgcmVnKSB7Ci0gICAgICAg IEdQUlJlZyBncHIgPSByZWcuZ3ByKCk7Ci0gICAgICAgIGlmICghcmVtYWluaW5nUGlubmVkUmVn aXN0ZXJzIHx8IFJlZ2lzdGVyU2V0OjpzdGFja1JlZ2lzdGVycygpLmdldChyZWcpKQotICAgICAg ICAgICAgcmV0dXJuOwotICAgICAgICBpZiAocmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzID09IDEp IHsKLSAgICAgICAgICAgIG1fcGlubmVkUmVnaXN0ZXJzLmJhc2VNZW1vcnlQb2ludGVyID0gZ3By OwotICAgICAgICAgICAgcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzLS07Ci0gICAgICAgIH0gZWxz ZQotICAgICAgICAgICAgbV9waW5uZWRSZWdpc3RlcnMuc2l6ZVJlZ2lzdGVycy5hcHBlbmQoeyBn cHIsIHBpbm5lZFNpemVSZWdpc3RlcnNbLS1yZW1haW5pbmdQaW5uZWRSZWdpc3RlcnMgLSAxXSB9 KTsKLSAgICB9KTsKLQotICAgIEFTU0VSVCghcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzKTsKIH0K IAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21NZW1vcnlJbmZvcm1hdGlvbi5oIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmgKaW5kZXggZWU2M2Q5ZS4uNmU3ZjUyMSAx MDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0 aW9uLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0 aW9uLmgKQEAgLTM4LDEyICszOCwxMSBAQCBzdHJ1Y3QgUGlubmVkU2l6ZVJlZ2lzdGVySW5mbyB7 CiAgICAgdW5zaWduZWQgc2l6ZU9mZnNldDsKIH07CiAKLS8vIEZJWE1FOiBXZSBzaG91bGQgc3Vw cG9ydCBtb3JlIHRoYW4gb25lIG1lbW9yeSBzaXplIHJlZ2lzdGVyLiBSaWdodCBub3cgd2UgdGFr ZSBhIHZlY3RvciB3aXRoIG9ubHkgb25lCi0vLyBlbnRyeS4gU3BlY2lmaWNhbGx5IGFuIGVudHJ5 IHdoZXJlIHRoZSBzaXplT2Zmc2V0ID09IDAuIElmIHdlIGhhdmUgbW9yZSB0aGFuIG9uZSBzaXpl IHJlZ2lzdGVyLAotLy8gd2UgY2FuIGhhdmUgb25lIGZvciBlYWNoIGxvYWQgc2l6ZSBjbGFzcy4g c2VlOiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYyOTUyCiBzdHJ1 Y3QgUGlubmVkUmVnaXN0ZXJJbmZvIHsKICAgICBWZWN0b3I8UGlubmVkU2l6ZVJlZ2lzdGVySW5m bz4gc2l6ZVJlZ2lzdGVyczsKICAgICBHUFJSZWcgYmFzZU1lbW9yeVBvaW50ZXI7CisgICAgc3Rh dGljIGNvbnN0IFBpbm5lZFJlZ2lzdGVySW5mbyYgZ2V0KCk7CisgICAgUGlubmVkUmVnaXN0ZXJJ bmZvKFZlY3RvcjxQaW5uZWRTaXplUmVnaXN0ZXJJbmZvPiYmLCBHUFJSZWcpOwogfTsKIAogY2xh c3MgTWVtb3J5SW5mb3JtYXRpb24gewpAQCAtNTMsOSArNTIsOCBAQCBwdWJsaWM6CiAgICAgICAg IEFTU0VSVCghKnRoaXMpOwogICAgIH0KIAotICAgIE1lbW9yeUluZm9ybWF0aW9uKFBhZ2VDb3Vu dCBpbml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSwgY29uc3QgVmVjdG9yPHVuc2lnbmVkPiYgcGlu bmVkU2l6ZVJlZ2lzdGVycywgYm9vbCBpc0ltcG9ydCk7CisgICAgTWVtb3J5SW5mb3JtYXRpb24o UGFnZUNvdW50IGluaXRpYWwsIFBhZ2VDb3VudCBtYXhpbXVtLCBib29sIGlzSW1wb3J0KTsKIAot ICAgIGNvbnN0IFBpbm5lZFJlZ2lzdGVySW5mbyYgcGlubmVkUmVnaXN0ZXJzKCkgY29uc3QgeyBy ZXR1cm4gbV9waW5uZWRSZWdpc3RlcnM7IH0KICAgICBQYWdlQ291bnQgaW5pdGlhbCgpIGNvbnN0 IHsgcmV0dXJuIG1faW5pdGlhbDsgfQogICAgIFBhZ2VDb3VudCBtYXhpbXVtKCkgY29uc3QgeyBy ZXR1cm4gbV9tYXhpbXVtOyB9CiAgICAgYm9vbCBpc0ltcG9ydCgpIGNvbnN0IHsgcmV0dXJuIG1f aXNJbXBvcnQ7IH0KQEAgLTY1LDcgKzYzLDYgQEAgcHVibGljOgogcHJpdmF0ZToKICAgICBQYWdl Q291bnQgbV9pbml0aWFsIHsgfTsKICAgICBQYWdlQ291bnQgbV9tYXhpbXVtIHsgfTsKLSAgICBQ aW5uZWRSZWdpc3RlckluZm8gbV9waW5uZWRSZWdpc3RlcnMgeyB9OwogICAgIGJvb2wgbV9pc0lt cG9ydCB7IGZhbHNlIH07CiB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9XYXNtTW9kdWxlUGFyc2VyLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dh c21Nb2R1bGVQYXJzZXIuY3BwCmluZGV4IDYyNjFlN2YuLjMwMTFjODkgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCisrKyBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCkBAIC0xMDcsNyArMTA3 LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlVHlwZSgpIC0+IFBhcnRpYWxSZXN1bHQKIAog ICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKGNvdW50KSwgImNhbid0IGdl dCBUeXBlIHNlY3Rpb24ncyBjb3VudCIpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoY291bnQg PT0gc3RkOjpudW1lcmljX2xpbWl0czx1aW50MzJfdD46Om1heCgpLCAiVHlwZSBzZWN0aW9uJ3Mg Y291bnQgaXMgdG9vIGJpZyAiLCBjb3VudCk7Ci0gICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9y ZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnRyeVJlc2VydmVDYXBhY2l0eShjb3VudCks ICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciBUeXBlIHNlY3Rpb24ncyAiLCBjb3Vu dCwgIiBlbnRyaWVzIik7CisgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxl U2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMudHJ5UmVzZXJ2ZUNhcGFj aXR5KGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yIFR5cGUgc2VjdGlv bidzICIsIGNvdW50LCAiIGVudHJpZXMiKTsKIAogICAgIGZvciAodWludDMyX3QgaSA9IDA7IGkg PCBjb3VudDsgKytpKSB7CiAgICAgICAgIGludDhfdCB0eXBlOwpAQCAtMTM5LDcgKzEzOSw3IEBA IGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZVR5cGUoKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgICAg IHNpZ25hdHVyZS0+cmV0dXJuVHlwZSgpID0gcmV0dXJuVHlwZTsKIAogICAgICAgICBTaWduYXR1 cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjphZG9wdChtX3Zt LCBzaWduYXR1cmUucmVsZWFzZSgpKTsKLSAgICAgICAgbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1 cmVJbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7CisgICAgICAgIG1fcmVz dWx0Lm1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzLnVuY2hl Y2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7CiAgICAgfQogICAgIHJldHVybiB7IH07CiB9CkBA IC0xNTIsNyArMTUyLDYgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlSW1wb3J0KCkgLT4gUGFy dGlhbFJlc3VsdAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0Lm1vZHVsZS0+Z2xv YmFscy50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5v dWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIgZ2xvYmFscyIpOyAvLyBGSVhNRSB0aGlz IG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBGSVhNRXMgYmVsb3cuCiAgICAgV0FTTV9Q QVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlLT5pbXBvcnRzLnRyeVJlc2VydmVDYXBhY2l0 eShpbXBvcnRDb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBpbXBv cnRDb3VudCwgIiBpbXBvcnRzIik7IC8vIEZJWE1FIHRoaXMgb3Zlci1hbGxvY2F0ZXMgd2hlbiB3 ZSBmaXggdGhlIEZJWE1FcyBiZWxvdy4KICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX3Jlc3Vs dC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy50cnlSZXNlcnZlQ2FwYWNp dHkoaW1wb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgaW1w b3J0Q291bnQsICIgaW1wb3J0IGZ1bmN0aW9uIHNpZ25hdHVyZXMiKTsgLy8gRklYTUUgdGhpcyBv dmVyLWFsbG9jYXRlcyB3aGVuIHdlIGZpeCB0aGUgRklYTUVzIGJlbG93LgotICAgIFdBU01fUEFS U0VSX0ZBSUxfSUYoIW1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS50cnlSZXNlcnZlQ2FwYWNp dHkoaW1wb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgaW1w b3J0Q291bnQsICIgZnVuY3Rpb25zIGluIHRoZSBpbmRleCBzcGFjZSIpOyAvLyBGSVhNRSB0aGlz IG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBGSVhNRXMgYmVsb3cuIFdlJ2xsIGFsbG9j YXRlIHNvbWUgbW9yZSBoZXJlIHdoZW4gd2Uga25vdyBob3cgbWFueSBmdW5jdGlvbnMgdG8gZXhw ZWN0LgogCiAgICAgZm9yICh1aW50MzJfdCBpbXBvcnROdW1iZXIgPSAwOyBpbXBvcnROdW1iZXIg PCBpbXBvcnRDb3VudDsgKytpbXBvcnROdW1iZXIpIHsKICAgICAgICAgSW1wb3J0IGltcDsKQEAg LTE3NCwxMSArMTczLDEwIEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZUltcG9ydCgpIC0+IFBh cnRpYWxSZXN1bHQKICAgICAgICAgY2FzZSBFeHRlcm5hbEtpbmQ6OkZ1bmN0aW9uOiB7CiAgICAg ICAgICAgICB1aW50MzJfdCBmdW5jdGlvblNpZ25hdHVyZUluZGV4OwogICAgICAgICAgICAgV0FT TV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoZnVuY3Rpb25TaWduYXR1cmVJbmRleCks ICJjYW4ndCBnZXQgIiwgaW1wb3J0TnVtYmVyLCAidGggSW1wb3J0J3MgZnVuY3Rpb24gc2lnbmF0 dXJlIGluIG1vZHVsZSAnIiwgbW9kdWxlU3RyaW5nLCAiJyBmaWVsZCAnIiwgZmllbGRTdHJpbmcs ICInIik7Ci0gICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGZ1bmN0aW9uU2lnbmF0dXJl SW5kZXggPj0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnNpemUoKSwgImludmFs aWQgZnVuY3Rpb24gc2lnbmF0dXJlIGZvciAiLCBpbXBvcnROdW1iZXIsICJ0aCBJbXBvcnQsICIs IGZ1bmN0aW9uU2lnbmF0dXJlSW5kZXgsICIgaXMgb3V0IG9mIHJhbmdlIG9mICIsIG1fcmVzdWx0 Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICIgaW4gbW9kdWxlICciLCBtb2R1bGVT dHJpbmcsICInIGZpZWxkICciLCBmaWVsZFN0cmluZywgIiciKTsKKyAgICAgICAgICAgIFdBU01f UEFSU0VSX0ZBSUxfSUYoZnVuY3Rpb25TaWduYXR1cmVJbmRleCA+PSBtX3Jlc3VsdC5tb2R1bGVT aWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICJpbnZhbGlk IGZ1bmN0aW9uIHNpZ25hdHVyZSBmb3IgIiwgaW1wb3J0TnVtYmVyLCAidGggSW1wb3J0LCAiLCBm dW5jdGlvblNpZ25hdHVyZUluZGV4LCAiIGlzIG91dCBvZiByYW5nZSBvZiAiLCBtX3Jlc3VsdC5t b2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICIg aW4gbW9kdWxlICciLCBtb2R1bGVTdHJpbmcsICInIGZpZWxkICciLCBmaWVsZFN0cmluZywgIici KTsKICAgICAgICAgICAgIGltcC5raW5kSW5kZXggPSBtX3Jlc3VsdC5tb2R1bGUtPmltcG9ydEZ1 bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCk7Ci0gICAgICAgICAgICBTaWduYXR1cmVJbmRl eCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlc1tmdW5j dGlvblNpZ25hdHVyZUluZGV4XTsKKyAgICAgICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVy ZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVy ZUluZGljZXNbZnVuY3Rpb25TaWduYXR1cmVJbmRleF07CiAgICAgICAgICAgICBtX3Jlc3VsdC5t b2R1bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy51bmNoZWNrZWRBcHBlbmQoc2ln bmF0dXJlSW5kZXgpOwotICAgICAgICAgICAgbV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnVu Y2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7CiAgICAgICAgICAgICBicmVhazsKICAgICAg ICAgfQogICAgICAgICBjYXNlIEV4dGVybmFsS2luZDo6VGFibGU6IHsKQEAgLTIyMCwyMCArMjE4 LDE4IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZUZ1bmN0aW9uKCkgLT4gUGFydGlhbFJlc3Vs dAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoY291bnQgPT0gc3RkOjpudW1lcmljX2xpbWl0czx1 aW50MzJfdD46Om1heCgpLCAiRnVuY3Rpb24gc2VjdGlvbidzIGNvdW50IGlzIHRvbyBiaWcgIiwg Y291bnQpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0Lm1vZHVsZS0+aW50ZXJu YWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50KSwgImNh bid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGNvdW50LCAiIEZ1bmN0aW9uIHNpZ25h dHVyZXMiKTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX3Jlc3VsdC5mdW5jdGlvbkxvY2F0 aW9uSW5CaW5hcnkudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVu b3VnaCBtZW1vcnkgZm9yICIsIGNvdW50LCAiRnVuY3Rpb24gbG9jYXRpb25zIik7Ci0gICAgV0FT TV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnRyeVJlc2VydmVD YXBhY2l0eShtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpICsgY291bnQpLCAiY2Fu J3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgY291bnQsICIgbW9yZSBmdW5jdGlvbnMg aW4gdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlIik7CiAKICAgICBmb3IgKHVpbnQzMl90IGkgPSAw OyBpIDwgY291bnQ7ICsraSkgewogICAgICAgICB1aW50MzJfdCB0eXBlTnVtYmVyOwogICAgICAg ICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMih0eXBlTnVtYmVyKSwgImNhbid0 IGdldCAiLCBpLCAidGggRnVuY3Rpb24ncyB0eXBlIG51bWJlciIpOwotICAgICAgICBXQVNNX1BB UlNFUl9GQUlMX0lGKHR5cGVOdW1iZXIgPj0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRp Y2VzLnNpemUoKSwgaSwgInRoIEZ1bmN0aW9uIHR5cGUgbnVtYmVyIGlzIGludmFsaWQgIiwgdHlw ZU51bWJlcik7CisgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYodHlwZU51bWJlciA+PSBtX3Jl c3VsdC5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXpl KCksIGksICJ0aCBGdW5jdGlvbiB0eXBlIG51bWJlciBpcyBpbnZhbGlkICIsIHR5cGVOdW1iZXIp OwogCi0gICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9yZXN1bHQubW9k dWxlLT5zaWduYXR1cmVJbmRpY2VzW3R5cGVOdW1iZXJdOworICAgICAgICBTaWduYXR1cmVJbmRl eCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1 ZWRTaWduYXR1cmVJbmRpY2VzW3R5cGVOdW1iZXJdOwogICAgICAgICAvLyBUaGUgQ29kZSBzZWN0 aW9uIGZpeGVzIHVwIHN0YXJ0IGFuZCBlbmQuCiAgICAgICAgIHNpemVfdCBzdGFydCA9IDA7CiAg ICAgICAgIHNpemVfdCBlbmQgPSAwOwogICAgICAgICBtX3Jlc3VsdC5tb2R1bGUtPmludGVybmFs RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7 CiAgICAgICAgIG1fcmVzdWx0LmZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeS51bmNoZWNrZWRBcHBl bmQoeyBzdGFydCwgZW5kIH0pOwotICAgICAgICBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uu dW5jaGVja2VkQXBwZW5kKHNpZ25hdHVyZUluZGV4KTsKICAgICB9CiAKICAgICByZXR1cm4geyB9 OwpAQCAtMzIwLDggKzMxNiw3IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZU1lbW9yeUhlbHBl cihib29sIGlzSW1wb3J0KSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgQVNTRVJUKGluaXRpYWxQYWdl Q291bnQpOwogICAgIEFTU0VSVCghbWF4aW11bVBhZ2VDb3VudCB8fCBtYXhpbXVtUGFnZUNvdW50 ID49IGluaXRpYWxQYWdlQ291bnQpOwogCi0gICAgVmVjdG9yPHVuc2lnbmVkPiBwaW5uZWRTaXpl cyA9IHsgMCB9OwotICAgIG1fcmVzdWx0Lm1vZHVsZS0+bWVtb3J5ID0gTWVtb3J5SW5mb3JtYXRp b24oaW5pdGlhbFBhZ2VDb3VudCwgbWF4aW11bVBhZ2VDb3VudCwgcGlubmVkU2l6ZXMsIGlzSW1w b3J0KTsKKyAgICBtX3Jlc3VsdC5tb2R1bGUtPm1lbW9yeSA9IE1lbW9yeUluZm9ybWF0aW9uKGlu aXRpYWxQYWdlQ291bnQsIG1heGltdW1QYWdlQ291bnQsIGlzSW1wb3J0KTsKICAgICByZXR1cm4g eyB9OwogfQogCkBAIC0zODcsNyArMzgyLDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlRXhw b3J0KCkgLT4gUGFydGlhbFJlc3VsdAogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJz ZVZhclVJbnQzMihleHAua2luZEluZGV4KSwgImNhbid0IGdldCAiLCBleHBvcnROdW1iZXIsICJ0 aCBFeHBvcnQncyBraW5kIGluZGV4LCBuYW1lZCAnIiwgZmllbGRTdHJpbmcsICInIik7CiAgICAg ICAgIHN3aXRjaCAoZXhwLmtpbmQpIHsKICAgICAgICAgY2FzZSBFeHRlcm5hbEtpbmQ6OkZ1bmN0 aW9uOiB7Ci0gICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGV4cC5raW5kSW5kZXggPj0g bV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnNpemUoKSwgZXhwb3J0TnVtYmVyLCAidGggRXhw b3J0IGhhcyBpbnZhbGlkIGZ1bmN0aW9uIG51bWJlciAiLCBleHAua2luZEluZGV4LCAiIGl0IGV4 Y2VlZHMgdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlICIsIG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhT cGFjZS5zaXplKCksICIsIG5hbWVkICciLCBmaWVsZFN0cmluZywgIiciKTsKKyAgICAgICAgICAg IFdBU01fUEFSU0VSX0ZBSUxfSUYoZXhwLmtpbmRJbmRleCA+PSBtX3Jlc3VsdC5tb2R1bGUtPmZ1 bmN0aW9uSW5kZXhTcGFjZVNpemUoKSwgZXhwb3J0TnVtYmVyLCAidGggRXhwb3J0IGhhcyBpbnZh bGlkIGZ1bmN0aW9uIG51bWJlciAiLCBleHAua2luZEluZGV4LCAiIGl0IGV4Y2VlZHMgdGhlIGZ1 bmN0aW9uIGluZGV4IHNwYWNlICIsIG1fcmVzdWx0Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNl U2l6ZSgpLCAiLCBuYW1lZCAnIiwgZmllbGRTdHJpbmcsICInIik7CiAgICAgICAgICAgICBicmVh azsKICAgICAgICAgfQogICAgICAgICBjYXNlIEV4dGVybmFsS2luZDo6VGFibGU6IHsKQEAgLTQx Nyw4ICs0MTIsOCBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VTdGFydCgpIC0+IFBhcnRpYWxS ZXN1bHQKIHsKICAgICB1aW50MzJfdCBzdGFydEZ1bmN0aW9uSW5kZXg7CiAgICAgV0FTTV9QQVJT RVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoc3RhcnRGdW5jdGlvbkluZGV4KSwgImNhbid0IGdl dCBTdGFydCBpbmRleCIpOwotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc3RhcnRGdW5jdGlvbklu ZGV4ID49IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCksICJTdGFydCBpbmRleCAi LCBzdGFydEZ1bmN0aW9uSW5kZXgsICIgZXhjZWVkcyBmdW5jdGlvbiBpbmRleCBzcGFjZSAiLCBt X3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpKTsKLSAgICBTaWduYXR1cmVJbmRleCBz aWduYXR1cmVJbmRleCA9IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZVtzdGFydEZ1bmN0aW9u SW5kZXhdLnNpZ25hdHVyZUluZGV4OworICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc3RhcnRGdW5j dGlvbkluZGV4ID49IG1fcmVzdWx0Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpLCAi U3RhcnQgaW5kZXggIiwgc3RhcnRGdW5jdGlvbkluZGV4LCAiIGV4Y2VlZHMgZnVuY3Rpb24gaW5k ZXggc3BhY2UgIiwgbV9yZXN1bHQubW9kdWxlLT5mdW5jdGlvbkluZGV4U3BhY2VTaXplKCkpOwor ICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlLT5zaWdu YXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2Uoc3RhcnRGdW5jdGlvbkluZGV4KTsKICAg ICBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQo bV92bSwgc2lnbmF0dXJlSW5kZXgpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc2lnbmF0dXJl LT5hcmd1bWVudENvdW50KCksICJTdGFydCBmdW5jdGlvbiBjYW4ndCBoYXZlIGFyZ3VtZW50cyIp OwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc2lnbmF0dXJlLT5yZXR1cm5UeXBlKCkgIT0gVm9p ZCwgIlN0YXJ0IGZ1bmN0aW9uIGNhbid0IHJldHVybiBhIHZhbHVlIik7CkBAIC00NjksNyArNDY0 LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlRWxlbWVudCgpIC0+IFBhcnRpYWxSZXN1bHQK ICAgICAgICAgZm9yICh1bnNpZ25lZCBpbmRleCA9IDA7IGluZGV4IDwgaW5kZXhDb3VudDsgKytp bmRleCkgewogICAgICAgICAgICAgdWludDMyX3QgZnVuY3Rpb25JbmRleDsKICAgICAgICAgICAg IFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKGZ1bmN0aW9uSW5kZXgpLCAiY2Fu J3QgZ2V0IEVsZW1lbnQgc2VjdGlvbidzICIsIGVsZW1lbnROdW0sICJ0aCBlbGVtZW50J3MgIiwg aW5kZXgsICJ0aCBpbmRleCIpOwotICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5j dGlvbkluZGV4ID49IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCksICJFbGVtZW50 IHNlY3Rpb24ncyAiLCBlbGVtZW50TnVtLCAidGggZWxlbWVudCdzICIsIGluZGV4LCAidGggaW5k ZXggaXMgIiwgZnVuY3Rpb25JbmRleCwgIiB3aGljaCBleGNlZWRzIHRoZSBmdW5jdGlvbiBpbmRl eCBzcGFjZSBzaXplIG9mICIsIG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCkpOwor ICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0 Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpLCAiRWxlbWVudCBzZWN0aW9uJ3MgIiwg ZWxlbWVudE51bSwgInRoIGVsZW1lbnQncyAiLCBpbmRleCwgInRoIGluZGV4IGlzICIsIGZ1bmN0 aW9uSW5kZXgsICIgd2hpY2ggZXhjZWVkcyB0aGUgZnVuY3Rpb24gaW5kZXggc3BhY2Ugc2l6ZSBv ZiAiLCBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSk7CiAKICAgICAg ICAgICAgIGVsZW1lbnQuZnVuY3Rpb25JbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChmdW5jdGlvbklu ZGV4KTsKICAgICAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbU1vZHVsZVBhcnNlci5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVs ZVBhcnNlci5oCmluZGV4IGUzYjc1YTcuLjdlMDI2YzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmgKQEAgLTM2LDggKzM2LDggQEAgbmFtZXNwYWNl IEpTQyB7IG5hbWVzcGFjZSBXYXNtIHsKIAogc3RydWN0IE1vZHVsZVBhcnNlclJlc3VsdCB7CiAg ICAgc3RkOjp1bmlxdWVfcHRyPE1vZHVsZUluZm9ybWF0aW9uPiBtb2R1bGU7Ci0gICAgRnVuY3Rp b25JbmRleFNwYWNlIGZ1bmN0aW9uSW5kZXhTcGFjZTsKICAgICBWZWN0b3I8RnVuY3Rpb25Mb2Nh dGlvbkluQmluYXJ5PiBmdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnk7CisgICAgVmVjdG9yPFNpZ25h dHVyZUluZGV4PiBtb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNl czsKIH07CiAKIGNsYXNzIE1vZHVsZVBhcnNlciA6IHB1YmxpYyBQYXJzZXI8TW9kdWxlUGFyc2Vy UmVzdWx0PiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFn ZUNvdW50LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QYWdlQ291bnQuY3Bw Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjRiODc3MDUKLS0tIC9kZXYvbnVs bAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFnZUNvdW50LmNwcApAQCAt MCwwICsxLDQ1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE2IEFwcGxlIEluYy4gQWxsIHJp Z2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1l dDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGlu IHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVE IEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBX QVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJ TkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVD VCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBE QU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9G IFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICog UFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04g QU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8K KworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIldhc21QYWdlQ291bnQuaCIKKworI2lm IEVOQUJMRShXRUJBU1NFTUJMWSkKKworI2luY2x1ZGUgPHd0Zi9QcmludFN0cmVhbS5oPgorI2lu Y2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgorCituYW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNl IFdhc20geworCit2b2lkIFBhZ2VDb3VudDo6ZHVtcChQcmludFN0cmVhbSYgb3V0KSBjb25zdAor eworICAgIG91dC5wcmludChTdHJpbmc6Om51bWJlcihieXRlcygpKSwgIkIiKTsKK30KKworfSAv LyBuYW1lc3BhY2UgSlNDCisKK30gLy8gbmFtZXNwYWNlIFdhc20KKworI2VuZGlmIC8vIEVOQUJM RShXRUJBU1NFTUJMWSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dh c21QYWdlQ291bnQuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QYWdlQ291bnQu aAppbmRleCBhMTVkNTA1Li42N2RiYjU1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtUGFnZUNvdW50LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbVBhZ2VDb3VudC5oCkBAIC0yNyw2ICsyNywxMCBAQAogCiAjaWYgRU5BQkxFKFdFQkFTU0VN QkxZKQogCituYW1lc3BhY2UgV1RGIHsKK2NsYXNzIFByaW50U3RyZWFtOworfQorCiBuYW1lc3Bh Y2UgSlNDIHsgbmFtZXNwYWNlIFdhc20gewogCiBjbGFzcyBQYWdlQ291bnQgewpAQCAtNDIsNiAr NDYsOCBAQCBwdWJsaWM6CiAgICAgICAgIDogbV9wYWdlQ291bnQocGFnZUNvdW50KQogICAgIHsg fQogCisgICAgdm9pZCBkdW1wKFdURjo6UHJpbnRTdHJlYW0mKSBjb25zdDsKKwogICAgIHVpbnQ2 NF90IGJ5dGVzKCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8dWludDY0X3Q+KG1fcGFnZUNv dW50KSAqIHN0YXRpY19jYXN0PHVpbnQ2NF90PihwYWdlU2l6ZSk7IH0KICAgICB1aW50MzJfdCBw YWdlQ291bnQoKSBjb25zdCB7IHJldHVybiBtX3BhZ2VDb3VudDsgfQogCmRpZmYgLS1naXQgYS9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtUGxhbi5jcHAKaW5kZXggZWQyOGJiYy4uMmQzNDIyZiAxMDA2NDQKLS0t IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uY3BwCisrKyBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmNwcApAQCAtNzYsOCArNzYsNyBAQCBib29sIFBs YW46OnBhcnNlQW5kVmFsaWRhdGVNb2R1bGUoKQogICAgICAgICB9CiAgICAgICAgIG1fbW9kdWxl SW5mb3JtYXRpb24gPSBXVEZNb3ZlKHBhcnNlUmVzdWx0LT5tb2R1bGUpOwogICAgICAgICBtX2Z1 bmN0aW9uTG9jYXRpb25JbkJpbmFyeSA9IFdURk1vdmUocGFyc2VSZXN1bHQtPmZ1bmN0aW9uTG9j YXRpb25JbkJpbmFyeSk7Ci0gICAgICAgIG1fZnVuY3Rpb25JbmRleFNwYWNlLnNpemUgPSBwYXJz ZVJlc3VsdC0+ZnVuY3Rpb25JbmRleFNwYWNlLnNpemUoKTsKLSAgICAgICAgbV9mdW5jdGlvbklu ZGV4U3BhY2UuYnVmZmVyID0gcGFyc2VSZXN1bHQtPmZ1bmN0aW9uSW5kZXhTcGFjZS5yZWxlYXNl QnVmZmVyKCk7CisgICAgICAgIG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25h dHVyZUluZGljZXMgPSBXVEZNb3ZlKHBhcnNlUmVzdWx0LT5tb2R1bGVTaWduYXR1cmVJbmRpY2Vz VG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcyk7CiAgICAgfQogCiAgICAgZm9yICh1bnNpZ25lZCBm dW5jdGlvbkluZGV4ID0gMDsgZnVuY3Rpb25JbmRleCA8IG1fZnVuY3Rpb25Mb2NhdGlvbkluQmlu YXJ5LnNpemUoKTsgKytmdW5jdGlvbkluZGV4KSB7CkBAIC04OSw3ICs4OCw3IEBAIGJvb2wgUGxh bjo6cGFyc2VBbmRWYWxpZGF0ZU1vZHVsZSgpCiAgICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25h dHVyZUluZGV4ID0gbV9tb2R1bGVJbmZvcm1hdGlvbi0+aW50ZXJuYWxGdW5jdGlvblNpZ25hdHVy ZUluZGljZXNbZnVuY3Rpb25JbmRleF07CiAgICAgICAgIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0 dXJlID0gU2lnbmF0dXJlSW5mb3JtYXRpb246OmdldChtX3ZtLCBzaWduYXR1cmVJbmRleCk7CiAK LSAgICAgICAgYXV0byB2YWxpZGF0aW9uUmVzdWx0ID0gdmFsaWRhdGVGdW5jdGlvbihtX3ZtLCBm dW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBtX2Z1bmN0aW9uSW5kZXhT cGFjZSwgKm1fbW9kdWxlSW5mb3JtYXRpb24pOworICAgICAgICBhdXRvIHZhbGlkYXRpb25SZXN1 bHQgPSB2YWxpZGF0ZUZ1bmN0aW9uKG1fdm0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3Ro LCBzaWduYXR1cmUsICptX21vZHVsZUluZm9ybWF0aW9uLCBtX21vZHVsZVNpZ25hdHVyZUluZGlj ZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzKTsKICAgICAgICAgaWYgKCF2YWxpZGF0aW9uUmVz dWx0KSB7CiAgICAgICAgICAgICBpZiAodmVyYm9zZSkgewogICAgICAgICAgICAgICAgIGZvciAo dW5zaWduZWQgaSA9IDA7IGkgPCBmdW5jdGlvbkxlbmd0aDsgKytpKQpAQCAtMTI3LDcgKzEyNiw3 IEBAIHZvaWQgUGxhbjo6cnVuKCkKICAgICAgICAgcmV0dXJuIHRydWU7CiAgICAgfTsKIAotICAg IGlmICghdHJ5UmVzZXJ2ZUNhcGFjaXR5KG1fd2FzbVRvSlNTdHVicywgbV9tb2R1bGVJbmZvcm1h dGlvbi0+aW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnNpemUoKSwgIiBXZWJBc3NlbWJs eSB0byBKYXZhU2NyaXB0IHN0dWJzIikKKyAgICBpZiAoIXRyeVJlc2VydmVDYXBhY2l0eShtX3dh c21FeGl0U3R1YnMsIG1fbW9kdWxlSW5mb3JtYXRpb24tPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJl SW5kaWNlcy5zaXplKCksICIgV2ViQXNzZW1ibHkgdG8gSmF2YVNjcmlwdCBzdHVicyIpCiAgICAg ICAgIHx8ICF0cnlSZXNlcnZlQ2FwYWNpdHkobV91bmxpbmtlZFdhc21Ub1dhc21DYWxscywgbV9m dW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgpLCAiIHVubGlua2VkIFdlYkFzc2VtYmx5IHRv IFdlYkFzc2VtYmx5IGNhbGxzIikKICAgICAgICAgfHwgIXRyeVJlc2VydmVDYXBhY2l0eShtX3dh c21JbnRlcm5hbEZ1bmN0aW9ucywgbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgpLCAi IFdlYkFzc2VtYmx5IGZ1bmN0aW9ucyIpCiAgICAgICAgIHx8ICF0cnlSZXNlcnZlQ2FwYWNpdHko bV9jb21waWxhdGlvbkNvbnRleHRzLCBtX2Z1bmN0aW9uTG9jYXRpb25JbkJpbmFyeS5zaXplKCks ICIgY29tcGlsYXRpb24gY29udGV4dHMiKSkKQEAgLTE0MSwxMiArMTQwLDExIEBAIHZvaWQgUGxh bjo6cnVuKCkKICAgICAgICAgSW1wb3J0KiBpbXBvcnQgPSAmbV9tb2R1bGVJbmZvcm1hdGlvbi0+ aW1wb3J0c1tpbXBvcnRJbmRleF07CiAgICAgICAgIGlmIChpbXBvcnQtPmtpbmQgIT0gRXh0ZXJu YWxLaW5kOjpGdW5jdGlvbikKICAgICAgICAgICAgIGNvbnRpbnVlOwotICAgICAgICB1bnNpZ25l ZCBpbXBvcnRGdW5jdGlvbkluZGV4ID0gbV93YXNtVG9KU1N0dWJzLnNpemUoKTsKKyAgICAgICAg dW5zaWduZWQgaW1wb3J0RnVuY3Rpb25JbmRleCA9IG1fd2FzbUV4aXRTdHVicy5zaXplKCk7CiAg ICAgICAgIGlmICh2ZXJib3NlKQogICAgICAgICAgICAgZGF0YUxvZ0xuKCJQcm9jZXNzaW5nIGlt cG9ydCBmdW5jdGlvbiBudW1iZXIgIiwgaW1wb3J0RnVuY3Rpb25JbmRleCwgIjogIiwgaW1wb3J0 LT5tb2R1bGUsICI6ICIsIGltcG9ydC0+ZmllbGQpOwogICAgICAgICBTaWduYXR1cmVJbmRleCBz aWduYXR1cmVJbmRleCA9IG1fbW9kdWxlSW5mb3JtYXRpb24tPmltcG9ydEZ1bmN0aW9uU2lnbmF0 dXJlSW5kaWNlcy5hdChpbXBvcnQtPmtpbmRJbmRleCk7Ci0gICAgICAgIG1fd2FzbVRvSlNTdHVi cy51bmNoZWNrZWRBcHBlbmQoaW1wb3J0U3R1YkdlbmVyYXRvcihtX3ZtLCBtX2NhbGxMaW5rSW5m b3MsIHNpZ25hdHVyZUluZGV4LCBpbXBvcnRGdW5jdGlvbkluZGV4KSk7Ci0gICAgICAgIG1fZnVu Y3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtpbXBvcnRGdW5jdGlvbkluZGV4XS5jb2RlID0g bV93YXNtVG9KU1N0dWJzW2ltcG9ydEZ1bmN0aW9uSW5kZXhdLmNvZGUoKS5leGVjdXRhYmxlQWRk cmVzcygpOworICAgICAgICBtX3dhc21FeGl0U3R1YnMudW5jaGVja2VkQXBwZW5kKGV4aXRTdHVi R2VuZXJhdG9yKG1fdm0sIG1fY2FsbExpbmtJbmZvcywgc2lnbmF0dXJlSW5kZXgsIGltcG9ydEZ1 bmN0aW9uSW5kZXgpKTsKICAgICB9CiAKICAgICBtX2N1cnJlbnRJbmRleCA9IDA7CkBAIC0xNjcs MTIgKzE2NSwxMiBAQCB2b2lkIFBsYW46OnJ1bigpCiAgICAgICAgICAgICBBU1NFUlQoZnVuY3Rp b25MZW5ndGggPD0gbV9zb3VyY2VMZW5ndGgpOwogICAgICAgICAgICAgU2lnbmF0dXJlSW5kZXgg c2lnbmF0dXJlSW5kZXggPSBtX21vZHVsZUluZm9ybWF0aW9uLT5pbnRlcm5hbEZ1bmN0aW9uU2ln bmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4XTsKICAgICAgICAgICAgIGNvbnN0IFNpZ25hdHVy ZSogc2lnbmF0dXJlID0gU2lnbmF0dXJlSW5mb3JtYXRpb246OmdldChtX3ZtLCBzaWduYXR1cmVJ bmRleCk7Ci0gICAgICAgICAgICB1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2UgPSBtX3dhc21U b0pTU3R1YnMuc2l6ZSgpICsgZnVuY3Rpb25JbmRleDsKLSAgICAgICAgICAgIEFTU0VSVF9VTlVT RUQoZnVuY3Rpb25JbmRleFNwYWNlLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5idWZmZXIuZ2V0KClb ZnVuY3Rpb25JbmRleFNwYWNlXS5zaWduYXR1cmVJbmRleCA9PSBzaWduYXR1cmVJbmRleCk7Ci0g ICAgICAgICAgICBBU1NFUlQodmFsaWRhdGVGdW5jdGlvbihtX3ZtLCBmdW5jdGlvblN0YXJ0LCBm dW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZSwgKm1fbW9kdWxl SW5mb3JtYXRpb24pKTsKKyAgICAgICAgICAgIHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFjZSA9 IG1fd2FzbUV4aXRTdHVicy5zaXplKCkgKyBmdW5jdGlvbkluZGV4OworICAgICAgICAgICAgQVNT RVJUX1VOVVNFRChmdW5jdGlvbkluZGV4U3BhY2UsIG1fbW9kdWxlSW5mb3JtYXRpb24tPnNpZ25h dHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4U3BhY2UpID09IHNp Z25hdHVyZUluZGV4KTsKKyAgICAgICAgICAgIEFTU0VSVCh2YWxpZGF0ZUZ1bmN0aW9uKG1fdm0s IGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWduYXR1cmUsICptX21vZHVsZUluZm9y bWF0aW9uLCBtX21vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2Vz KSk7CiAKICAgICAgICAgICAgIG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHNbZnVuY3Rpb25JbmRl eF0gPSBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4oKTsKLSAgICAgICAgICAgIGF1dG8g cGFyc2VBbmRDb21waWxlUmVzdWx0ID0gcGFyc2VBbmRDb21waWxlKCptX3ZtLCBtX2NvbXBpbGF0 aW9uQ29udGV4dHNbZnVuY3Rpb25JbmRleF0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3Ro LCBzaWduYXR1cmUsIG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHNbZnVuY3Rpb25JbmRleF0sIG1f ZnVuY3Rpb25JbmRleFNwYWNlLCAqbV9tb2R1bGVJbmZvcm1hdGlvbik7CisgICAgICAgICAgICBh dXRvIHBhcnNlQW5kQ29tcGlsZVJlc3VsdCA9IHBhcnNlQW5kQ29tcGlsZSgqbV92bSwgbV9jb21w aWxhdGlvbkNvbnRleHRzW2Z1bmN0aW9uSW5kZXhdLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxl bmd0aCwgc2lnbmF0dXJlLCBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzW2Z1bmN0aW9uSW5kZXhd LCAqbV9tb2R1bGVJbmZvcm1hdGlvbiwgbV9tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVk U2lnbmF0dXJlSW5kaWNlcyk7CiAKICAgICAgICAgICAgIGlmIChVTkxJS0VMWSghcGFyc2VBbmRD b21waWxlUmVzdWx0KSkgewogICAgICAgICAgICAgICAgIGF1dG8gbG9ja2VyID0gaG9sZExvY2so bV9sb2NrKTsKQEAgLTIwOSwxMCArMjA3LDEyIEBAIHZvaWQgUGxhbjo6cnVuKCkKICAgICBmb3Ig KHVpbnQzMl90IGZ1bmN0aW9uSW5kZXggPSAwOyBmdW5jdGlvbkluZGV4IDwgbV9mdW5jdGlvbkxv Y2F0aW9uSW5CaW5hcnkuc2l6ZSgpOyBmdW5jdGlvbkluZGV4KyspIHsKICAgICAgICAgewogICAg ICAgICAgICAgQ29tcGlsYXRpb25Db250ZXh0JiBjb250ZXh0ID0gbV9jb21waWxhdGlvbkNvbnRl eHRzW2Z1bmN0aW9uSW5kZXhdOworICAgICAgICAgICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJl SW5kZXggPSBtX21vZHVsZUluZm9ybWF0aW9uLT5pbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5k aWNlc1tmdW5jdGlvbkluZGV4XTsKKyAgICAgICAgICAgIFN0cmluZyBzaWduYXR1cmVEZXNjcmlw dGlvbiA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgc2lnbmF0dXJlSW5kZXgpLT50 b1N0cmluZygpOwogICAgICAgICAgICAgewogICAgICAgICAgICAgICAgIExpbmtCdWZmZXIgbGlu a0J1ZmZlcigqbV92bSwgKmNvbnRleHQud2FzbUVudHJ5cG9pbnRKSVQsIG51bGxwdHIpOwogICAg ICAgICAgICAgICAgIG1fd2FzbUludGVybmFsRnVuY3Rpb25zW2Z1bmN0aW9uSW5kZXhdLT53YXNt RW50cnlwb2ludC5jb21waWxhdGlvbiA9Ci0gICAgICAgICAgICAgICAgICAgIHN0ZDo6bWFrZV91 bmlxdWU8QjM6OkNvbXBpbGF0aW9uPihGSU5BTElaRV9DT0RFKGxpbmtCdWZmZXIsICgiV2FzbSBm dW5jdGlvbiIpKSwgV1RGTW92ZShjb250ZXh0Lndhc21FbnRyeXBvaW50Qnlwcm9kdWN0cykpOwor ICAgICAgICAgICAgICAgICAgICBzdGQ6Om1ha2VfdW5pcXVlPEIzOjpDb21waWxhdGlvbj4oRklO QUxJWkVfQ09ERShsaW5rQnVmZmVyLCAoIldlYkFzc2VtYmx5IGZ1bmN0aW9uWyVpXSAlcyIsIGZ1 bmN0aW9uSW5kZXgsIHNpZ25hdHVyZURlc2NyaXB0aW9uLmFzY2lpKCkuZGF0YSgpKSksIFdURk1v dmUoY29udGV4dC53YXNtRW50cnlwb2ludEJ5cHJvZHVjdHMpKTsKICAgICAgICAgICAgIH0KIAog ICAgICAgICAgICAgewpAQCAtMjIwLDEyICsyMjAsOSBAQCB2b2lkIFBsYW46OnJ1bigpCiAgICAg ICAgICAgICAgICAgbGlua0J1ZmZlci5saW5rKGNvbnRleHQuanNFbnRyeXBvaW50VG9XYXNtRW50 cnlwb2ludENhbGwsIEZ1bmN0aW9uUHRyKG1fd2FzbUludGVybmFsRnVuY3Rpb25zW2Z1bmN0aW9u SW5kZXhdLT53YXNtRW50cnlwb2ludC5jb21waWxhdGlvbi0+Y29kZSgpLmV4ZWN1dGFibGVBZGRy ZXNzKCkpKTsKIAogICAgICAgICAgICAgICAgIG1fd2FzbUludGVybmFsRnVuY3Rpb25zW2Z1bmN0 aW9uSW5kZXhdLT5qc1RvV2FzbUVudHJ5cG9pbnQuY29tcGlsYXRpb24gPQotICAgICAgICAgICAg ICAgICAgICBzdGQ6Om1ha2VfdW5pcXVlPEIzOjpDb21waWxhdGlvbj4oRklOQUxJWkVfQ09ERShs aW5rQnVmZmVyLCAoIldhc20gSlMgZW50cnlwb2ludCIpKSwgV1RGTW92ZShjb250ZXh0LmpzRW50 cnlwb2ludEJ5cHJvZHVjdHMpKTsKKyAgICAgICAgICAgICAgICAgICAgc3RkOjptYWtlX3VuaXF1 ZTxCMzo6Q29tcGlsYXRpb24+KEZJTkFMSVpFX0NPREUobGlua0J1ZmZlciwgKCJKYXZhU2NyaXB0 LT5XZWJBc3NlbWJseSBlbnRyeXBvaW50WyVpXSAlcyIsIGZ1bmN0aW9uSW5kZXgsIHNpZ25hdHVy ZURlc2NyaXB0aW9uLmFzY2lpKCkuZGF0YSgpKSksIFdURk1vdmUoY29udGV4dC5qc0VudHJ5cG9p bnRCeXByb2R1Y3RzKSk7CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KLQotICAgICAgICB1bnNp Z25lZCBmdW5jdGlvbkluZGV4U3BhY2UgPSBtX3dhc21Ub0pTU3R1YnMuc2l6ZSgpICsgZnVuY3Rp b25JbmRleDsKLSAgICAgICAgbV9mdW5jdGlvbkluZGV4U3BhY2UuYnVmZmVyLmdldCgpW2Z1bmN0 aW9uSW5kZXhTcGFjZV0uY29kZSA9IG1fd2FzbUludGVybmFsRnVuY3Rpb25zW2Z1bmN0aW9uSW5k ZXhdLT53YXNtRW50cnlwb2ludC5jb21waWxhdGlvbi0+Y29kZSgpLmV4ZWN1dGFibGVBZGRyZXNz KCk7CiAgICAgfQogCiAgICAgaWYgKHZlcmJvc2UgfHwgT3B0aW9uczo6cmVwb3J0Q29tcGlsZVRp bWVzKCkpIHsKQEAgLTIzNSw4ICsyMzIsMTkgQEAgdm9pZCBQbGFuOjpydW4oKQogCiAgICAgLy8g UGF0Y2ggdGhlIGNhbGwgc2l0ZXMgZm9yIGVhY2ggV2ViQXNzZW1ibHkgZnVuY3Rpb24uCiAgICAg Zm9yIChhdXRvJiB1bmxpbmtlZCA6IG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMpIHsKLSAgICAg ICAgZm9yIChhdXRvJiBjYWxsIDogdW5saW5rZWQpCi0gICAgICAgICAgICBNYWNyb0Fzc2VtYmxl cjo6cmVwYXRjaENhbGwoY2FsbC5jYWxsTG9jYXRpb24sIENvZGVMb2NhdGlvbkxhYmVsKG1fZnVu Y3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtjYWxsLmZ1bmN0aW9uSW5kZXhdLmNvZGUpKTsK KyAgICAgICAgZm9yIChhdXRvJiBjYWxsIDogdW5saW5rZWQpIHsKKyAgICAgICAgICAgIHZvaWQq IGV4ZWN1dGFibGVBZGRyZXNzOworICAgICAgICAgICAgaWYgKG1fbW9kdWxlSW5mb3JtYXRpb24t PmlzSW1wb3J0ZWRGdW5jdGlvbkZyb21GdW5jdGlvbkluZGV4U3BhY2UoY2FsbC5mdW5jdGlvbklu ZGV4KSkgeworICAgICAgICAgICAgICAgIC8vIEZJWE1FIGltcG9ydHMgY291bGQgaGF2ZSBiZWVu IGxpbmtlZCBpbiBCMywgaW5zdGVhZCBvZiBnZW5lcmF0aW5nIGEgcGF0Y2hwb2ludC4gVGhpcyBj b25kaXRpb24gc2hvdWxkIGJlIHJlcGxhY2VkIGJ5IGEgUkVMRUFTRV9BU1NFUlQuIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjY0NjIKKyAgICAgICAgICAgICAgICBl eGVjdXRhYmxlQWRkcmVzcyA9IGNhbGwudGFyZ2V0ID09IFVubGlua2VkV2FzbVRvV2FzbUNhbGw6 OlRhcmdldDo6dG9KUworICAgICAgICAgICAgICAgICAgICA/IG1fd2FzbUV4aXRTdHVicy5hdChj YWxsLmZ1bmN0aW9uSW5kZXgpLndhc21Ub0pTLmNvZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpCisg ICAgICAgICAgICAgICAgICAgIDogbV93YXNtRXhpdFN0dWJzLmF0KGNhbGwuZnVuY3Rpb25JbmRl eCkud2FzbVRvV2FzbS5jb2RlKCkuZXhlY3V0YWJsZUFkZHJlc3MoKTsKKyAgICAgICAgICAgIH0g ZWxzZSB7CisgICAgICAgICAgICAgICAgQVNTRVJUKGNhbGwudGFyZ2V0ICE9IFVubGlua2VkV2Fz bVRvV2FzbUNhbGw6OlRhcmdldDo6dG9KUyk7CisgICAgICAgICAgICAgICAgZXhlY3V0YWJsZUFk ZHJlc3MgPSBtX3dhc21JbnRlcm5hbEZ1bmN0aW9ucy5hdChjYWxsLmZ1bmN0aW9uSW5kZXggLSBt X3dhc21FeGl0U3R1YnMuc2l6ZSgpKS0+d2FzbUVudHJ5cG9pbnQuY29tcGlsYXRpb24tPmNvZGUo KS5leGVjdXRhYmxlQWRkcmVzcygpOworICAgICAgICAgICAgfQorICAgICAgICAgICAgTWFjcm9B c3NlbWJsZXI6OnJlcGF0Y2hDYWxsKGNhbGwuY2FsbExvY2F0aW9uLCBDb2RlTG9jYXRpb25MYWJl bChleGVjdXRhYmxlQWRkcmVzcykpOworICAgICAgICB9CiAgICAgfQogCiAgICAgbV9mYWlsZWQg PSBmYWxzZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFu LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5oCmluZGV4IDNiYjAxYzgu LjY5ODBiZGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFu LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uaApAQCAtODYsMjYg Kzg2LDIwIEBAIHB1YmxpYzoKICAgICAgICAgcmV0dXJuIFdURk1vdmUobV9jYWxsTGlua0luZm9z KTsKICAgICB9CiAKLSAgICBWZWN0b3I8V2FzbVRvSlNTdHViPiYmIHRha2VXYXNtVG9KU1N0dWJz KCkKKyAgICBWZWN0b3I8V2FzbUV4aXRTdHVicz4mJiB0YWtlV2FzbUV4aXRTdHVicygpCiAgICAg ewogICAgICAgICBSRUxFQVNFX0FTU0VSVCghZmFpbGVkKCkpOwotICAgICAgICByZXR1cm4gV1RG TW92ZShtX3dhc21Ub0pTU3R1YnMpOwotICAgIH0KLQotICAgIEltbXV0YWJsZUZ1bmN0aW9uSW5k ZXhTcGFjZSYmIHRha2VGdW5jdGlvbkluZGV4U3BhY2UoKQotICAgIHsKLSAgICAgICAgUkVMRUFT RV9BU1NFUlQoIWZhaWxlZCgpKTsKLSAgICAgICAgcmV0dXJuIFdURk1vdmUobV9mdW5jdGlvbklu ZGV4U3BhY2UpOworICAgICAgICByZXR1cm4gV1RGTW92ZShtX3dhc21FeGl0U3R1YnMpOwogICAg IH0KIAogcHJpdmF0ZToKICAgICBzdGQ6OnVuaXF1ZV9wdHI8TW9kdWxlSW5mb3JtYXRpb24+IG1f bW9kdWxlSW5mb3JtYXRpb247CiAgICAgVmVjdG9yPEZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeT4g bV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnk7CisgICAgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiBt X21vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzOwogICAgIEJh ZzxDYWxsTGlua0luZm8+IG1fY2FsbExpbmtJbmZvczsKLSAgICBWZWN0b3I8V2FzbVRvSlNTdHVi PiBtX3dhc21Ub0pTU3R1YnM7CisgICAgVmVjdG9yPFdhc21FeGl0U3R1YnM+IG1fd2FzbUV4aXRT dHViczsKICAgICBWZWN0b3I8c3RkOjp1bmlxdWVfcHRyPFdhc21JbnRlcm5hbEZ1bmN0aW9uPj4g bV93YXNtSW50ZXJuYWxGdW5jdGlvbnM7CiAgICAgVmVjdG9yPENvbXBpbGF0aW9uQ29udGV4dD4g bV9jb21waWxhdGlvbkNvbnRleHRzOwotICAgIEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSBt X2Z1bmN0aW9uSW5kZXhTcGFjZTsKIAogICAgIFZNKiBtX3ZtOwogICAgIFZlY3RvcjxWZWN0b3I8 VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4+IG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHM7CmRpZmYg LS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmNwcCBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuY3BwCmluZGV4IDZkNWIxZjYu LjA5NjZkYWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWdu YXR1cmUuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUu Y3BwCkBAIC00MSwxMiArNDEsMjIgQEAgY29uc3QgYm9vbCB2ZXJib3NlID0gZmFsc2U7CiAKIGNv bnN0IGNvbnN0ZXhwciBTaWduYXR1cmVJbmRleCBTaWduYXR1cmU6OmludmFsaWRJbmRleDsKIAor U3RyaW5nIFNpZ25hdHVyZTo6dG9TdHJpbmcoKSBjb25zdAoreworICAgIFN0cmluZyByZXN1bHQo bWFrZVN0cmluZyhyZXR1cm5UeXBlKCkpKTsKKyAgICByZXN1bHQuYXBwZW5kKCIgKCIpOworICAg IGZvciAoU2lnbmF0dXJlQXJnQ291bnQgYXJnID0gMDsgYXJnIDwgYXJndW1lbnRDb3VudCgpOyAr K2FyZykgeworICAgICAgICBpZiAoYXJnKQorICAgICAgICAgICAgcmVzdWx0LmFwcGVuZCgiLCAi KTsKKyAgICAgICAgcmVzdWx0LmFwcGVuZChtYWtlU3RyaW5nKGFyZ3VtZW50KGFyZykpKTsKKyAg ICB9CisgICAgcmVzdWx0LmFwcGVuZCgnKScpOworICAgIHJldHVybiByZXN1bHQ7Cit9CisKIHZv aWQgU2lnbmF0dXJlOjpkdW1wKFByaW50U3RyZWFtJiBvdXQpIGNvbnN0CiB7Ci0gICAgb3V0LnBy aW50KG1ha2VTdHJpbmcocmV0dXJuVHlwZSgpKSwgIiAoIik7Ci0gICAgZm9yIChTaWduYXR1cmVB cmdDb3VudCBhcmcgPSAwOyBhcmcgPCBhcmd1bWVudENvdW50KCk7ICsrYXJnKQotICAgICAgICBv dXQucHJpbnQoKGFyZyA/ICIsICIgOiAiIiksIG1ha2VTdHJpbmcoYXJndW1lbnQoYXJnKSkpOwot ICAgIG91dC5wcmludCgiKSIpOworICAgIG91dC5wcmludCh0b1N0cmluZygpKTsKIH0KIAogdW5z aWduZWQgU2lnbmF0dXJlOjpoYXNoKCkgY29uc3QKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21TaWduYXR1cmUuaAppbmRleCAwZDZjN2I1Li40ZDQzZmZjIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmgKKysrIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5oCkBAIC04Miw2ICs4Miw3IEBAIHB1YmxpYzoK ICAgICB9CiAgICAgVHlwZSBhcmd1bWVudChTaWduYXR1cmVBcmdDb3VudCBpKSBjb25zdCB7IHJl dHVybiBjb25zdF9jYXN0PFNpZ25hdHVyZSo+KHRoaXMpLT5hcmd1bWVudChpKTsgfQogCisgICAg V1RGOjpTdHJpbmcgdG9TdHJpbmcoKSBjb25zdDsKICAgICB2b2lkIGR1bXAoV1RGOjpQcmludFN0 cmVhbSYgb3V0KSBjb25zdDsKICAgICBib29sIG9wZXJhdG9yPT0oY29uc3QgU2lnbmF0dXJlJiBy aHMpIGNvbnN0CiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbVZhbGlkYXRlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0 ZS5jcHAKaW5kZXggZTMyMTYxMy4uNzVkMzgyNiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9XYXNtVmFsaWRhdGUuY3BwCkBAIC0zODEsMTAgKzM4MSwxMCBAQCB2b2lkIFZhbGlkYXRl OjpkdW1wKGNvbnN0IFZlY3RvcjxDb250cm9sRW50cnk+JiBjb250cm9sU3RhY2ssIGNvbnN0IEV4 cHJlc3Npb25MaQogICAgIGRhdGFMb2dMbigpOwogfQogCi1FeHBlY3RlZDx2b2lkLCBTdHJpbmc+ IHZhbGlkYXRlRnVuY3Rpb24oVk0qIHZtLCBjb25zdCB1aW50OF90KiBzb3VyY2UsIHNpemVfdCBs ZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBjb25zdCBJbW11dGFibGVGdW5jdGlv bkluZGV4U3BhY2UmIGZ1bmN0aW9uSW5kZXhTcGFjZSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24m IG1vZHVsZSkKK0V4cGVjdGVkPHZvaWQsIFN0cmluZz4gdmFsaWRhdGVGdW5jdGlvbihWTSogdm0s IGNvbnN0IHVpbnQ4X3QqIHNvdXJjZSwgc2l6ZV90IGxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiBz aWduYXR1cmUsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBtb2R1bGUsIGNvbnN0IFZlY3RvcjxT aWduYXR1cmVJbmRleD4mIG1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJ bmRpY2VzKQogewogICAgIFZhbGlkYXRlIGNvbnRleHQobW9kdWxlKTsKLSAgICBGdW5jdGlvblBh cnNlcjxWYWxpZGF0ZT4gdmFsaWRhdG9yKHZtLCBjb250ZXh0LCBzb3VyY2UsIGxlbmd0aCwgc2ln bmF0dXJlLCBmdW5jdGlvbkluZGV4U3BhY2UsIG1vZHVsZSk7CisgICAgRnVuY3Rpb25QYXJzZXI8 VmFsaWRhdGU+IHZhbGlkYXRvcih2bSwgY29udGV4dCwgc291cmNlLCBsZW5ndGgsIHNpZ25hdHVy ZSwgbW9kdWxlLCBtb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNl cyk7CiAgICAgV0FTTV9GQUlMX0lGX0hFTFBFUl9GQUlMUyh2YWxpZGF0b3IucGFyc2UoKSk7CiAg ICAgcmV0dXJuIHsgfTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21WYWxpZGF0ZS5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRl LmgKaW5kZXggMTQ4MjFmMi4uNzNlN2Q4NyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbVZhbGlkYXRlLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbVZhbGlkYXRlLmgKQEAgLTM2LDcgKzM2LDcgQEAgY2xhc3MgVk07CiAKIG5hbWVzcGFjZSBX YXNtIHsKIAotRXhwZWN0ZWQ8dm9pZCwgU3RyaW5nPiB2YWxpZGF0ZUZ1bmN0aW9uKFZNKiwgY29u c3QgdWludDhfdCosIHNpemVfdCwgY29uc3QgU2lnbmF0dXJlKiwgY29uc3QgSW1tdXRhYmxlRnVu Y3Rpb25JbmRleFNwYWNlJiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mKTsKK0V4cGVjdGVkPHZv aWQsIFN0cmluZz4gdmFsaWRhdGVGdW5jdGlvbihWTSosIGNvbnN0IHVpbnQ4X3QqLCBzaXplX3Qs IGNvbnN0IFNpZ25hdHVyZSosIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiwgY29uc3QgVmVjdG9y PFNpZ25hdHVyZUluZGV4PiYpOwogCiB9IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2FzbQogCmRpZmYg LS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFu Y2UuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5j ZS5oCmluZGV4IDkyOGY0MjMuLjU0YWUxN2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5oCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5oCkBAIC00Miw3ICs0Miw3IEBA IHB1YmxpYzoKICAgICB0eXBlZGVmIEpTRGVzdHJ1Y3RpYmxlT2JqZWN0IEJhc2U7CiAKIAotICAg IHN0YXRpYyBKU1dlYkFzc2VtYmx5SW5zdGFuY2UqIGNyZWF0ZShWTSYsIFN0cnVjdHVyZSosIEpT V2ViQXNzZW1ibHlNb2R1bGUqLCBKU01vZHVsZU5hbWVzcGFjZU9iamVjdCopOworICAgIEpTX0VY UE9SVF9QUklWQVRFIHN0YXRpYyBKU1dlYkFzc2VtYmx5SW5zdGFuY2UqIGNyZWF0ZShWTSYsIFN0 cnVjdHVyZSosIEpTV2ViQXNzZW1ibHlNb2R1bGUqLCBKU01vZHVsZU5hbWVzcGFjZU9iamVjdCop OwogICAgIHN0YXRpYyBTdHJ1Y3R1cmUqIGNyZWF0ZVN0cnVjdHVyZShWTSYsIEpTR2xvYmFsT2Jq ZWN0KiwgSlNWYWx1ZSk7CiAKICAgICBERUNMQVJFX0lORk87CkBAIC04Niw5ICs4NiwxMSBAQCBw dWJsaWM6CiAgICAgICAgIHJldHVybiBvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucygpICsgc2l6ZW9m KFdyaXRlQmFycmllcjxKU0NlbGw+KSAqIGlkeDsKICAgICB9CiAKLSAgICBzdGF0aWMgcHRyZGlm Zl90IG9mZnNldE9mVGFibGUoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJs eUluc3RhbmNlLCBtX3RhYmxlKTsgfQogICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZNZW1v cnkoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseUluc3RhbmNlLCBtX21l bW9yeSk7IH0KKyAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mVGFibGUoKSB7IHJldHVybiBP QkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseUluc3RhbmNlLCBtX3RhYmxlKTsgfQogICAgIHN0 YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZHbG9iYWxzKCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9G KEpTV2ViQXNzZW1ibHlJbnN0YW5jZSwgbV9nbG9iYWxzKTsgfQorICAgIHN0YXRpYyBzaXplX3Qg b2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbnMoKSB7IHJldHVybiBXVEY6OnJvdW5kVXBUb011bHRpcGxl T2Y8c2l6ZW9mKFdyaXRlQmFycmllcjxKU0NlbGw+KT4oc2l6ZW9mKEpTV2ViQXNzZW1ibHlJbnN0 YW5jZSkpOyB9CisgICAgc3RhdGljIHNpemVfdCBvZmZzZXRPZkltcG9ydEZ1bmN0aW9uKHNpemVf dCBpbXBvcnRGdW5jdGlvbk51bSkgeyByZXR1cm4gb2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbnMoKSAr IGltcG9ydEZ1bmN0aW9uTnVtICogc2l6ZW9mKHNpemVvZihXcml0ZUJhcnJpZXI8SlNDZWxsPikp OyB9CiAKIHByb3RlY3RlZDoKICAgICBKU1dlYkFzc2VtYmx5SW5zdGFuY2UoVk0mLCBTdHJ1Y3R1 cmUqLCB1bnNpZ25lZCBudW1JbXBvcnRGdW5jdGlvbnMpOwpAQCAtOTYsMTEgKzk4LDYgQEAgcHJv dGVjdGVkOgogICAgIHN0YXRpYyB2b2lkIGRlc3Ryb3koSlNDZWxsKik7CiAgICAgc3RhdGljIHZv aWQgdmlzaXRDaGlsZHJlbihKU0NlbGwqLCBTbG90VmlzaXRvciYpOwogCi0gICAgc3RhdGljIHNp emVfdCBvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucygpCi0gICAgewotICAgICAgICByZXR1cm4gV1RG Ojpyb3VuZFVwVG9NdWx0aXBsZU9mPHNpemVvZihXcml0ZUJhcnJpZXI8SlNDZWxsPik+KHNpemVv ZihKU1dlYkFzc2VtYmx5SW5zdGFuY2UpKTsKLSAgICB9Ci0KICAgICBzdGF0aWMgc2l6ZV90IGFs bG9jYXRpb25TaXplKHVuc2lnbmVkIG51bUltcG9ydEZ1bmN0aW9ucykKICAgICB7CiAgICAgICAg IHJldHVybiBvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucygpICsgc2l6ZW9mKFdyaXRlQmFycmllcjxK U0NlbGw+KSAqIG51bUltcG9ydEZ1bmN0aW9uczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuY3BwIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5jcHAKaW5kZXggNTI4YWI2OS4uNGM0 Y2MzZSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3Nl bWJseU1lbW9yeS5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJB c3NlbWJseU1lbW9yeS5jcHAKQEAgLTM3LDkgKzM3LDkgQEAgbmFtZXNwYWNlIEpTQyB7CiAKIGNv bnN0IENsYXNzSW5mbyBKU1dlYkFzc2VtYmx5TWVtb3J5OjpzX2luZm8gPSB7ICJXZWJBc3NlbWJs eS5NZW1vcnkiLCAmQmFzZTo6c19pbmZvLCAwLCBDUkVBVEVfTUVUSE9EX1RBQkxFKEpTV2ViQXNz ZW1ibHlNZW1vcnkpIH07CiAKLUpTV2ViQXNzZW1ibHlNZW1vcnkqIEpTV2ViQXNzZW1ibHlNZW1v cnk6OmNyZWF0ZShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8 V2FzbTo6TWVtb3J5PiYmIG1lbW9yeSkKK0pTV2ViQXNzZW1ibHlNZW1vcnkqIEpTV2ViQXNzZW1i bHlNZW1vcnk6OmNyZWF0ZShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBXYXNtOjpNZW1v cnkmJiBtZW1vcnkpCiB7Ci0gICAgYXV0byogaW5zdGFuY2UgPSBuZXcgKE5vdE51bGwsIGFsbG9j YXRlQ2VsbDxKU1dlYkFzc2VtYmx5TWVtb3J5Pih2bS5oZWFwKSkgSlNXZWJBc3NlbWJseU1lbW9y eSh2bSwgc3RydWN0dXJlLCBXVEZNb3ZlKG1lbW9yeSkpOworICAgIGF1dG8qIGluc3RhbmNlID0g bmV3IChOb3ROdWxsLCBhbGxvY2F0ZUNlbGw8SlNXZWJBc3NlbWJseU1lbW9yeT4odm0uaGVhcCkp IEpTV2ViQXNzZW1ibHlNZW1vcnkodm0sIHN0cnVjdHVyZSwgc3RkOjpmb3J3YXJkPFdhc206Ok1l bW9yeT4obWVtb3J5KSk7CiAgICAgaW5zdGFuY2UtPmZpbmlzaENyZWF0aW9uKHZtKTsKICAgICBy ZXR1cm4gaW5zdGFuY2U7CiB9CkBAIC00OSw3ICs0OSw3IEBAIFN0cnVjdHVyZSogSlNXZWJBc3Nl bWJseU1lbW9yeTo6Y3JlYXRlU3RydWN0dXJlKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2Jh bE9iCiAgICAgcmV0dXJuIFN0cnVjdHVyZTo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3QsIHByb3Rv dHlwZSwgVHlwZUluZm8oT2JqZWN0VHlwZSwgU3RydWN0dXJlRmxhZ3MpLCBpbmZvKCkpOwogfQog Ci1KU1dlYkFzc2VtYmx5TWVtb3J5OjpKU1dlYkFzc2VtYmx5TWVtb3J5KFZNJiB2bSwgU3RydWN0 dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+JiYgbWVtb3J5KQor SlNXZWJBc3NlbWJseU1lbW9yeTo6SlNXZWJBc3NlbWJseU1lbW9yeShWTSYgdm0sIFN0cnVjdHVy ZSogc3RydWN0dXJlLCBXYXNtOjpNZW1vcnkmJiBtZW1vcnkpCiAgICAgOiBCYXNlKHZtLCBzdHJ1 Y3R1cmUpCiAgICAgLCBtX21lbW9yeShXVEZNb3ZlKG1lbW9yeSkpCiB7CkBAIC03Miw3ICs3Miw3 IEBAIEpTQXJyYXlCdWZmZXIqIEpTV2ViQXNzZW1ibHlNZW1vcnk6OmJ1ZmZlcihWTSYgdm0sIEpT R2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QpCiAgICAgYXV0byBkZXN0cnVjdG9yID0gW10gKHZv aWQqKSB7CiAgICAgICAgIC8vIFdlIGRvbid0IG5lZWQgdG8gZG8gYW55dGhpbmcgaGVyZSB0byBk ZXN0cm95IHRoZSBtZW1vcnkuCiAgICAgICAgIC8vIFRoZSBBcnJheUJ1ZmZlciBiYWNraW5nIHRo ZSBKU0FycmF5QnVmZmVyIGlzIG9ubHkgb3duZWQgYnkgdXMsCi0gICAgICAgIC8vIHNvIHdlIGd1 YXJhbnRlZSBpdHMgbGlmZWN5bGNlLgorICAgICAgICAvLyBzbyB3ZSBndWFyYW50ZWUgaXRzIGxp ZmVjeWNsZS4KICAgICB9OwogICAgIG1fYnVmZmVyID0gQXJyYXlCdWZmZXI6OmNyZWF0ZUZyb21C eXRlcyhtZW1vcnkoKS0+bWVtb3J5KCksIG1lbW9yeSgpLT5zaXplKCksIFdURk1vdmUoZGVzdHJ1 Y3RvcikpOwogICAgIG1fYnVmZmVyV3JhcHBlci5zZXQodm0sIHRoaXMsIEpTQXJyYXlCdWZmZXI6 OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LT5tX2FycmF5QnVmZmVyU3RydWN0dXJlLmdldCgpLCBt X2J1ZmZlci5nZXQoKSkpOwpAQCAtODUsNyArODUsNyBAQCBXYXNtOjpQYWdlQ291bnQgSlNXZWJB c3NlbWJseU1lbW9yeTo6Z3JvdyhFeGVjU3RhdGUqIGV4ZWMsIHVpbnQzMl90IGRlbHRhLCBib29s CiAgICAgVk0mIHZtID0gZXhlYy0+dm0oKTsKICAgICBhdXRvIHRocm93U2NvcGUgPSBERUNMQVJF X1RIUk9XX1NDT1BFKHZtKTsKIAotICAgIFdhc206OlBhZ2VDb3VudCBvbGRQYWdlQ291bnQgPSBt X21lbW9yeS0+c2l6ZUluUGFnZXMoKTsKKyAgICBXYXNtOjpQYWdlQ291bnQgb2xkUGFnZUNvdW50 ID0gbWVtb3J5KCktPnNpemVJblBhZ2VzKCk7CiAKICAgICBpZiAoIVdhc206OlBhZ2VDb3VudDo6 aXNWYWxpZChkZWx0YSkpIHsKICAgICAgICAgaWYgKHNob3VsZFRocm93RXhjZXB0aW9uc09uRmFp bHVyZSkKQEAgLTEwMSw3ICsxMDEsNyBAQCBXYXNtOjpQYWdlQ291bnQgSlNXZWJBc3NlbWJseU1l bW9yeTo6Z3JvdyhFeGVjU3RhdGUqIGV4ZWMsIHVpbnQzMl90IGRlbHRhLCBib29sCiAgICAgfQog CiAgICAgaWYgKGRlbHRhKSB7Ci0gICAgICAgIGJvb2wgc3VjY2VzcyA9IG1fbWVtb3J5LT5ncm93 KG5ld1NpemUpOworICAgICAgICBib29sIHN1Y2Nlc3MgPSBtZW1vcnkoKS0+Z3JvdyhuZXdTaXpl KTsKICAgICAgICAgaWYgKCFzdWNjZXNzKSB7CiAgICAgICAgICAgICBpZiAoc2hvdWxkVGhyb3dF eGNlcHRpb25zT25GYWlsdXJlKQogICAgICAgICAgICAgICAgIHRocm93RXhjZXB0aW9uKGV4ZWMs IHRocm93U2NvcGUsIGNyZWF0ZU91dE9mTWVtb3J5RXJyb3IoZXhlYykpOwpkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5oIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5oCmluZGV4IDI4 Nzk3YzYuLjM5YTM1YmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pz L0pTV2ViQXNzZW1ibHlNZW1vcnkuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9q cy9KU1dlYkFzc2VtYmx5TWVtb3J5LmgKQEAgLTQxLDI1ICs0MSwyNiBAQCBjbGFzcyBKU1dlYkFz c2VtYmx5TWVtb3J5IDogcHVibGljIEpTRGVzdHJ1Y3RpYmxlT2JqZWN0IHsKIHB1YmxpYzoKICAg ICB0eXBlZGVmIEpTRGVzdHJ1Y3RpYmxlT2JqZWN0IEJhc2U7CiAKLSAgICBzdGF0aWMgSlNXZWJB c3NlbWJseU1lbW9yeSogY3JlYXRlKFZNJiwgU3RydWN0dXJlKiwgc3RkOjp1bmlxdWVfcHRyPFdh c206Ok1lbW9yeT4mJik7CisgICAgSlNfRVhQT1JUX1BSSVZBVEUgc3RhdGljIEpTV2ViQXNzZW1i bHlNZW1vcnkqIGNyZWF0ZShWTSYsIFN0cnVjdHVyZSosIFdhc206Ok1lbW9yeSYmKTsKICAgICBz dGF0aWMgU3RydWN0dXJlKiBjcmVhdGVTdHJ1Y3R1cmUoVk0mLCBKU0dsb2JhbE9iamVjdCosIEpT VmFsdWUpOwogCi0gICAgREVDTEFSRV9JTkZPOworICAgIERFQ0xBUkVfRVhQT1JUX0lORk87CiAK LSAgICBXYXNtOjpNZW1vcnkqIG1lbW9yeSgpIHsgcmV0dXJuIG1fbWVtb3J5LmdldCgpOyB9Cisg ICAgV2FzbTo6TWVtb3J5KiBtZW1vcnkoKSB7IHJldHVybiAmbV9tZW1vcnk7IH0KICAgICBKU0Fy cmF5QnVmZmVyKiBidWZmZXIoVk0mIHZtLCBKU0dsb2JhbE9iamVjdCopOwogICAgIFdhc206OlBh Z2VDb3VudCBncm93KEV4ZWNTdGF0ZSosIHVpbnQzMl90IGRlbHRhLCBib29sIHNob3VsZFRocm93 RXhjZXB0aW9uc09uRmFpbHVyZSk7CiAKLSAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mTWVt b3J5KCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKEpTV2ViQXNzZW1ibHlNZW1vcnksIG1fbWVt b3J5KTsgfQorICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZNZW1vcnkoKSB7IHJldHVybiBP QkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseU1lbW9yeSwgbV9tZW1vcnkpICsgV2FzbTo6TWVt b3J5OjpvZmZzZXRPZk1lbW9yeSgpOyB9CisgICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZlNp emUoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseU1lbW9yeSwgbV9tZW1v cnkpICsgV2FzbTo6TWVtb3J5OjpvZmZzZXRPZlNpemUoKTsgfQogCiBwcm90ZWN0ZWQ6Ci0gICAg SlNXZWJBc3NlbWJseU1lbW9yeShWTSYsIFN0cnVjdHVyZSosIHN0ZDo6dW5pcXVlX3B0cjxXYXNt OjpNZW1vcnk+JiYpOworICAgIEpTV2ViQXNzZW1ibHlNZW1vcnkoVk0mLCBTdHJ1Y3R1cmUqLCBX YXNtOjpNZW1vcnkmJik7CiAgICAgfkpTV2ViQXNzZW1ibHlNZW1vcnkoKTsKICAgICB2b2lkIGZp bmlzaENyZWF0aW9uKFZNJik7CiAgICAgc3RhdGljIHZvaWQgZGVzdHJveShKU0NlbGwqKTsKICAg ICBzdGF0aWMgdm9pZCB2aXNpdENoaWxkcmVuKEpTQ2VsbCosIFNsb3RWaXNpdG9yJik7CiAKLSAg ICBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiBtX21lbW9yeTsKKyAgICBXYXNtOjpNZW1v cnkgbV9tZW1vcnk7CiAgICAgV3JpdGVCYXJyaWVyPEpTQXJyYXlCdWZmZXI+IG1fYnVmZmVyV3Jh cHBlcjsKICAgICBSZWZQdHI8QXJyYXlCdWZmZXI+IG1fYnVmZmVyOwogfTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUuY3BwIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5jcHAKaW5k ZXggZDY1MjRjNS4uZmEwZTg1OSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5jcHAKQEAgLTM4LDkgKzM4LDkgQEAgbmFtZXNw YWNlIEpTQyB7CiAKIGNvbnN0IENsYXNzSW5mbyBKU1dlYkFzc2VtYmx5TW9kdWxlOjpzX2luZm8g PSB7ICJXZWJBc3NlbWJseS5Nb2R1bGUiLCAmQmFzZTo6c19pbmZvLCBudWxscHRyLCBDUkVBVEVf TUVUSE9EX1RBQkxFKEpTV2ViQXNzZW1ibHlNb2R1bGUpIH07CiAKLUpTV2ViQXNzZW1ibHlNb2R1 bGUqIEpTV2ViQXNzZW1ibHlNb2R1bGU6OmNyZWF0ZShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0 dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYgbW9kdWxlSW5m b3JtYXRpb24sIEJhZzxDYWxsTGlua0luZm8+JiYgY2FsbExpbmtJbmZvcywgVmVjdG9yPFdhc206 Oldhc21Ub0pTU3R1Yj4mJiB3YXNtVG9KU1N0dWJzLCBXYXNtOjpJbW11dGFibGVGdW5jdGlvbklu ZGV4U3BhY2UmJiBmdW5jdGlvbkluZGV4U3BhY2UsIFN5bWJvbFRhYmxlKiBleHBvcnRTeW1ib2xU YWJsZSwgdW5zaWduZWQgY2FsbGVlQ291bnQpCitKU1dlYkFzc2VtYmx5TW9kdWxlKiBKU1dlYkFz c2VtYmx5TW9kdWxlOjpjcmVhdGUoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1 bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPiYmIG1vZHVsZUluZm9ybWF0aW9uLCBC YWc8Q2FsbExpbmtJbmZvPiYmIGNhbGxMaW5rSW5mb3MsIFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0 dWJzPiYmIHdhc21FeGl0U3R1YnMsIFN5bWJvbFRhYmxlKiBleHBvcnRTeW1ib2xUYWJsZSwgdW5z aWduZWQgY2FsbGVlQ291bnQpCiB7Ci0gICAgYXV0byogaW5zdGFuY2UgPSBuZXcgKE5vdE51bGws IGFsbG9jYXRlQ2VsbDxKU1dlYkFzc2VtYmx5TW9kdWxlPih2bS5oZWFwLCBhbGxvY2F0aW9uU2l6 ZShjYWxsZWVDb3VudCkpKSBKU1dlYkFzc2VtYmx5TW9kdWxlKHZtLCBzdHJ1Y3R1cmUsIHN0ZDo6 Zm9yd2FyZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+Pihtb2R1bGVJ bmZvcm1hdGlvbiksIHN0ZDo6Zm9yd2FyZDxCYWc8Q2FsbExpbmtJbmZvPj4oY2FsbExpbmtJbmZv cyksIHN0ZDo6Zm9yd2FyZDxWZWN0b3I8V2FzbTo6V2FzbVRvSlNTdHViPj4od2FzbVRvSlNTdHVi cyksIHN0ZDo6Zm9yd2FyZDxXYXNtOjpJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2U+KGZ1bmN0 aW9uSW5kZXhTcGFjZSksIGNhbGxlZUNvdW50KTsKKyAgICBhdXRvKiBpbnN0YW5jZSA9IG5ldyAo Tm90TnVsbCwgYWxsb2NhdGVDZWxsPEpTV2ViQXNzZW1ibHlNb2R1bGU+KHZtLmhlYXAsIGFsbG9j YXRpb25TaXplKGNhbGxlZUNvdW50KSkpIEpTV2ViQXNzZW1ibHlNb2R1bGUodm0sIHN0cnVjdHVy ZSwgc3RkOjpmb3J3YXJkPHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4+ KG1vZHVsZUluZm9ybWF0aW9uKSwgc3RkOjpmb3J3YXJkPEJhZzxDYWxsTGlua0luZm8+PihjYWxs TGlua0luZm9zKSwgc3RkOjpmb3J3YXJkPFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPj4od2Fz bUV4aXRTdHVicyksIGNhbGxlZUNvdW50KTsKICAgICBpbnN0YW5jZS0+ZmluaXNoQ3JlYXRpb24o dm0sIGV4cG9ydFN5bWJvbFRhYmxlKTsKICAgICByZXR1cm4gaW5zdGFuY2U7CiB9CkBAIC01MCwx MiArNTAsMTEgQEAgU3RydWN0dXJlKiBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGVTdHJ1Y3R1 cmUoVk0mIHZtLCBKU0dsb2JhbE9iamVjdCogZ2xvYmFsT2IKICAgICByZXR1cm4gU3RydWN0dXJl OjpjcmVhdGUodm0sIGdsb2JhbE9iamVjdCwgcHJvdG90eXBlLCBUeXBlSW5mbyhPYmplY3RUeXBl LCBTdHJ1Y3R1cmVGbGFncyksIGluZm8oKSk7CiB9CiAKLUpTV2ViQXNzZW1ibHlNb2R1bGU6OkpT V2ViQXNzZW1ibHlNb2R1bGUoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlx dWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPiYmIG1vZHVsZUluZm9ybWF0aW9uLCBCYWc8 Q2FsbExpbmtJbmZvPiYmIGNhbGxMaW5rSW5mb3MsIFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0dWI+ JiYgd2FzbVRvSlNTdHVicywgV2FzbTo6SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiYgZnVu Y3Rpb25JbmRleFNwYWNlLCB1bnNpZ25lZCBjYWxsZWVDb3VudCkKK0pTV2ViQXNzZW1ibHlNb2R1 bGU6OkpTV2ViQXNzZW1ibHlNb2R1bGUoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3Rk Ojp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPiYmIG1vZHVsZUluZm9ybWF0aW9u LCBCYWc8Q2FsbExpbmtJbmZvPiYmIGNhbGxMaW5rSW5mb3MsIFZlY3RvcjxXYXNtOjpXYXNtRXhp dFN0dWJzPiYmIHdhc21FeGl0U3R1YnMsIHVuc2lnbmVkIGNhbGxlZUNvdW50KQogICAgIDogQmFz ZSh2bSwgc3RydWN0dXJlKQogICAgICwgbV9tb2R1bGVJbmZvcm1hdGlvbihXVEZNb3ZlKG1vZHVs ZUluZm9ybWF0aW9uKSkKICAgICAsIG1fY2FsbExpbmtJbmZvcyhXVEZNb3ZlKGNhbGxMaW5rSW5m b3MpKQotICAgICwgbV93YXNtVG9KU1N0dWJzKFdURk1vdmUod2FzbVRvSlNTdHVicykpCi0gICAg LCBtX2Z1bmN0aW9uSW5kZXhTcGFjZShXVEZNb3ZlKGZ1bmN0aW9uSW5kZXhTcGFjZSkpCisgICAg LCBtX3dhc21FeGl0U3R1YnMoV1RGTW92ZSh3YXNtRXhpdFN0dWJzKSkKICAgICAsIG1fY2FsbGVl Q291bnQoY2FsbGVlQ291bnQpCiB7CiAgICAgbWVtc2V0KGNhbGxlZXMoKSwgMCwgbV9jYWxsZWVD b3VudCAqIHNpemVvZihXcml0ZUJhcnJpZXI8SlNXZWJBc3NlbWJseUNhbGxlZT4pICogMik7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9k dWxlLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxl LmgKaW5kZXggZmVjNGVlZC4uZmE2NzNhZiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUuaApAQCAtNDMsMTkgKzQzLDE4IEBAIGNs YXNzIEpTV2ViQXNzZW1ibHlNb2R1bGUgOiBwdWJsaWMgSlNEZXN0cnVjdGlibGVPYmplY3Qgewog cHVibGljOgogICAgIHR5cGVkZWYgSlNEZXN0cnVjdGlibGVPYmplY3QgQmFzZTsKIAotICAgIHN0 YXRpYyBKU1dlYkFzc2VtYmx5TW9kdWxlKiBjcmVhdGUoVk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6OnVu aXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYsIEJhZzxDYWxsTGlua0luZm8+JiYs IFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0dWI+JiYsIFdhc206OkltbXV0YWJsZUZ1bmN0aW9uSW5k ZXhTcGFjZSYmLCBTeW1ib2xUYWJsZSosIHVuc2lnbmVkKTsKKyAgICBKU19FWFBPUlRfUFJJVkFU RSBzdGF0aWMgSlNXZWJBc3NlbWJseU1vZHVsZSogY3JlYXRlKFZNJiwgU3RydWN0dXJlKiwgc3Rk Ojp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPiYmLCBCYWc8Q2FsbExpbmtJbmZv PiYmLCBWZWN0b3I8V2FzbTo6V2FzbUV4aXRTdHVicz4mJiwgU3ltYm9sVGFibGUqLCB1bnNpZ25l ZCk7CiAgICAgc3RhdGljIFN0cnVjdHVyZSogY3JlYXRlU3RydWN0dXJlKFZNJiwgSlNHbG9iYWxP YmplY3QqLCBKU1ZhbHVlKTsKIAogICAgIERFQ0xBUkVfSU5GTzsKIAogICAgIGNvbnN0IFdhc206 Ok1vZHVsZUluZm9ybWF0aW9uJiBtb2R1bGVJbmZvcm1hdGlvbigpIGNvbnN0IHsgcmV0dXJuICpt X21vZHVsZUluZm9ybWF0aW9uLmdldCgpOyB9CiAgICAgU3ltYm9sVGFibGUqIGV4cG9ydFN5bWJv bFRhYmxlKCkgY29uc3QgeyByZXR1cm4gbV9leHBvcnRTeW1ib2xUYWJsZS5nZXQoKTsgfQotICAg IFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUZvckZ1bmN0aW9uSW5kZXhTcGFjZSh1bnNp Z25lZCBmdW5jdGlvbkluZGV4U3BhY2UpIGNvbnN0CisgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXgg c2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRleFNwYWNlKHVuc2lnbmVkIGZ1bmN0aW9uSW5k ZXhTcGFjZSkgY29uc3QKICAgICB7Ci0gICAgICAgIEFTU0VSVChmdW5jdGlvbkluZGV4U3BhY2Ug PCBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5zaXplKTsKLSAgICAgICAgcmV0dXJuIG1fZnVuY3Rpb25J bmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtmdW5jdGlvbkluZGV4U3BhY2VdLnNpZ25hdHVyZUluZGV4 OworICAgICAgICByZXR1cm4gbV9tb2R1bGVJbmZvcm1hdGlvbi0+c2lnbmF0dXJlSW5kZXhGcm9t RnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXhTcGFjZSk7CiAgICAgfQotICAgIHVuc2ln bmVkIGZ1bmN0aW9uSW1wb3J0Q291bnQoKSBjb25zdCB7IHJldHVybiBtX3dhc21Ub0pTU3R1YnMu c2l6ZSgpOyB9CisgICAgdW5zaWduZWQgZnVuY3Rpb25JbXBvcnRDb3VudCgpIGNvbnN0IHsgcmV0 dXJuIG1fd2FzbUV4aXRTdHVicy5zaXplKCk7IH0KIAogICAgIEpTV2ViQXNzZW1ibHlDYWxsZWUq IGpzRW50cnlwb2ludENhbGxlZUZyb21GdW5jdGlvbkluZGV4U3BhY2UodW5zaWduZWQgZnVuY3Rp b25JbmRleFNwYWNlKQogICAgIHsKQEAgLTkwLDEwICs4OSw4IEBAIHB1YmxpYzoKICAgICAgICAg cmV0dXJuIGJpdHdpc2VfY2FzdDxXcml0ZUJhcnJpZXI8SlNXZWJBc3NlbWJseUNhbGxlZT4qPihi aXR3aXNlX2Nhc3Q8Y2hhcio+KHRoaXMpICsgb2Zmc2V0T2ZDYWxsZWVzKCkpOwogICAgIH0KIAot ICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZGdW5jdGlvbkluZGV4U3BhY2UoKSB7IHJldHVy biBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseU1vZHVsZSwgbV9mdW5jdGlvbkluZGV4U3Bh Y2UpOyB9Ci0KIHByb3RlY3RlZDoKLSAgICBKU1dlYkFzc2VtYmx5TW9kdWxlKFZNJiwgU3RydWN0 dXJlKiwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPiYmLCBCYWc8Q2Fs bExpbmtJbmZvPiYmLCBWZWN0b3I8V2FzbTo6V2FzbVRvSlNTdHViPiYmLCBXYXNtOjpJbW11dGFi bGVGdW5jdGlvbkluZGV4U3BhY2UmJiwgdW5zaWduZWQgY2FsbGVlQ291bnQpOworICAgIEpTV2Vi QXNzZW1ibHlNb2R1bGUoVk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9k dWxlSW5mb3JtYXRpb24+JiYsIEJhZzxDYWxsTGlua0luZm8+JiYsIFZlY3RvcjxXYXNtOjpXYXNt RXhpdFN0dWJzPiYmLCB1bnNpZ25lZCBjYWxsZWVDb3VudCk7CiAgICAgdm9pZCBmaW5pc2hDcmVh dGlvbihWTSYsIFN5bWJvbFRhYmxlKik7CiAgICAgc3RhdGljIHZvaWQgZGVzdHJveShKU0NlbGwq KTsKICAgICBzdGF0aWMgdm9pZCB2aXNpdENoaWxkcmVuKEpTQ2VsbCosIFNsb3RWaXNpdG9yJik7 CkBAIC0xMTcsOCArMTE0LDcgQEAgcHJpdmF0ZToKICAgICBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6 TW9kdWxlSW5mb3JtYXRpb24+IG1fbW9kdWxlSW5mb3JtYXRpb247CiAgICAgQmFnPENhbGxMaW5r SW5mbz4gbV9jYWxsTGlua0luZm9zOwogICAgIFdyaXRlQmFycmllcjxTeW1ib2xUYWJsZT4gbV9l eHBvcnRTeW1ib2xUYWJsZTsKLSAgICBWZWN0b3I8V2FzbTo6V2FzbVRvSlNTdHViPiBtX3dhc21U b0pTU3R1YnM7Ci0gICAgY29uc3QgV2FzbTo6SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlIG1f ZnVuY3Rpb25JbmRleFNwYWNlOworICAgIFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPiBtX3dh c21FeGl0U3R1YnM7CiAgICAgdW5zaWduZWQgbV9jYWxsZWVDb3VudDsKIH07CiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uY3Bw IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlvbi5jcHAK aW5kZXggYmUyN2Y1Ny4uYmNhNDc5MiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlvbi5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlvbi5jcHAKQEAgLTExOSw2ICsxMTksNyBAQCBz dGF0aWMgRW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBjYWxsV2ViQXNzZW1ibHlGdW5jdGlv bihFeGVjU3RhdGUqIGV4ZWMpCiAgICAgUHJvdG9DYWxsRnJhbWUgcHJvdG9DYWxsRnJhbWU7CiAg ICAgcHJvdG9DYWxsRnJhbWUuaW5pdChudWxscHRyLCB3YXNtRnVuY3Rpb24sIGZpcnN0QXJndW1l bnQsIGFyZ0NvdW50LCByZW1haW5pbmdBcmdzKTsKIAorICAgIC8vIEZJWE1FIERvIGF3YXkgd2l0 aCB0aGlzIGVudGlyZSBmdW5jdGlvbiwgYW5kIG9ubHkgdXNlIHRoZSBlbnRyeXBvaW50IGdlbmVy YXRlZCBieSBCMy4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NjQ4 NgogICAgIEpTV2ViQXNzZW1ibHlJbnN0YW5jZSogcHJldkpTV2ViQXNzZW1ibHlJbnN0YW5jZSA9 IHZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZTsKICAgICB2bS50b3BKU1dlYkFzc2VtYmx5SW5z dGFuY2UgPSB3YXNtRnVuY3Rpb24tPmluc3RhbmNlKCk7CiAgICAgQVNTRVJUKHdhc21GdW5jdGlv bi0+aW5zdGFuY2UoKSk7CkBAIC0xNDksNyArMTUwLDcgQEAgV2ViQXNzZW1ibHlGdW5jdGlvbiog V2ViQXNzZW1ibHlGdW5jdGlvbjo6Y3JlYXRlKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2Jh bE8KIHsKICAgICBOYXRpdmVFeGVjdXRhYmxlKiBleGVjdXRhYmxlID0gdm0uZ2V0SG9zdEZ1bmN0 aW9uKGNhbGxXZWJBc3NlbWJseUZ1bmN0aW9uLCBOb0ludHJpbnNpYywgY2FsbEhvc3RGdW5jdGlv bkFzQ29uc3RydWN0b3IsIG51bGxwdHIsIG5hbWUpOwogICAgIFN0cnVjdHVyZSogc3RydWN0dXJl ID0gZ2xvYmFsT2JqZWN0LT53ZWJBc3NlbWJseUZ1bmN0aW9uU3RydWN0dXJlKCk7Ci0gICAgV2Vi QXNzZW1ibHlGdW5jdGlvbiogZnVuY3Rpb24gPSBuZXcgKE5vdE51bGwsIGFsbG9jYXRlQ2VsbDxX ZWJBc3NlbWJseUZ1bmN0aW9uPih2bS5oZWFwKSkgV2ViQXNzZW1ibHlGdW5jdGlvbih2bSwgZ2xv YmFsT2JqZWN0LCBzdHJ1Y3R1cmUsIHNpZ25hdHVyZUluZGV4KTsKKyAgICBXZWJBc3NlbWJseUZ1 bmN0aW9uKiBmdW5jdGlvbiA9IG5ldyAoTm90TnVsbCwgYWxsb2NhdGVDZWxsPFdlYkFzc2VtYmx5 RnVuY3Rpb24+KHZtLmhlYXApKSBXZWJBc3NlbWJseUZ1bmN0aW9uKHZtLCBnbG9iYWxPYmplY3Qs IHN0cnVjdHVyZSwgc2lnbmF0dXJlSW5kZXgsIHdhc21FbnRyeXBvaW50LT5lbnRyeXBvaW50KCkp OwogICAgIGZ1bmN0aW9uLT5maW5pc2hDcmVhdGlvbih2bSwgZXhlY3V0YWJsZSwgbGVuZ3RoLCBu YW1lLCBpbnN0YW5jZSwganNFbnRyeXBvaW50LCB3YXNtRW50cnlwb2ludCk7CiAgICAgcmV0dXJu IGZ1bmN0aW9uOwogfQpAQCAtMTU3LDExICsxNTgsMTIgQEAgV2ViQXNzZW1ibHlGdW5jdGlvbiog V2ViQXNzZW1ibHlGdW5jdGlvbjo6Y3JlYXRlKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2Jh bE8KIFN0cnVjdHVyZSogV2ViQXNzZW1ibHlGdW5jdGlvbjo6Y3JlYXRlU3RydWN0dXJlKFZNJiB2 bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCwgSlNWYWx1ZSBwcm90b3R5cGUpCiB7CiAg ICAgQVNTRVJUKGdsb2JhbE9iamVjdCk7Ci0gICAgcmV0dXJuIFN0cnVjdHVyZTo6Y3JlYXRlKHZt LCBnbG9iYWxPYmplY3QsIHByb3RvdHlwZSwgVHlwZUluZm8oSlNGdW5jdGlvblR5cGUsIFN0cnVj dHVyZUZsYWdzKSwgaW5mbygpKTsKKyAgICByZXR1cm4gU3RydWN0dXJlOjpjcmVhdGUodm0sIGds b2JhbE9iamVjdCwgcHJvdG90eXBlLCBUeXBlSW5mbyhXZWJBc3NlbWJseUZ1bmN0aW9uVHlwZSwg U3RydWN0dXJlRmxhZ3MpLCBpbmZvKCkpOwogfQogCi1XZWJBc3NlbWJseUZ1bmN0aW9uOjpXZWJB c3NlbWJseUZ1bmN0aW9uKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCwgU3Ry dWN0dXJlKiBzdHJ1Y3R1cmUsIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4KQor V2ViQXNzZW1ibHlGdW5jdGlvbjo6V2ViQXNzZW1ibHlGdW5jdGlvbihWTSYgdm0sIEpTR2xvYmFs T2JqZWN0KiBnbG9iYWxPYmplY3QsIFN0cnVjdHVyZSogc3RydWN0dXJlLCBXYXNtOjpTaWduYXR1 cmVJbmRleCBzaWduYXR1cmVJbmRleCwgdm9pZCogd2FzbUVudHJ5cG9pbnQpCiAgICAgOiBCYXNl KHZtLCBnbG9iYWxPYmplY3QsIHN0cnVjdHVyZSkKKyAgICAsIG1fd2FzbUVudHJ5UG9pbnRDb2Rl KHdhc21FbnRyeXBvaW50KQogICAgICwgbV9zaWduYXR1cmVJbmRleChzaWduYXR1cmVJbmRleCkK IHsgfQogCkBAIC0xODMsNiArMTg1LDcgQEAgdm9pZCBXZWJBc3NlbWJseUZ1bmN0aW9uOjpmaW5p c2hDcmVhdGlvbihWTSYgdm0sIE5hdGl2ZUV4ZWN1dGFibGUqIGV4ZWN1dGFibGUsIHUKICAgICBB U1NFUlQoanNFbnRyeXBvaW50ICE9IHdhc21FbnRyeXBvaW50KTsKICAgICBtX2pzRW50cnlwb2lu dC5zZXQodm0sIHRoaXMsIGpzRW50cnlwb2ludCk7CiAgICAgbV93YXNtRW50cnlwb2ludC5zZXQo dm0sIHRoaXMsIHdhc21FbnRyeXBvaW50KTsKKyAgICBBU1NFUlQobV93YXNtRW50cnlwb2ludC0+ ZW50cnlwb2ludCgpID09IG1fd2FzbUVudHJ5UG9pbnRDb2RlKTsKIH0KIAogfSAvLyBuYW1lc3Bh Y2UgSlNDCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3Nl bWJseUZ1bmN0aW9uLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJs eUZ1bmN0aW9uLmgKaW5kZXggMzQ5MDUwMi4uMzg3N2EwMiAxMDA2NDQKLS0tIGEvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlvbi5oCisrKyBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uaApAQCAtNTQsMTggKzU0 LDIyIEBAIHB1YmxpYzoKIAogICAgIEpTV2ViQXNzZW1ibHlJbnN0YW5jZSogaW5zdGFuY2UoKSBj b25zdCB7IHJldHVybiBtX2luc3RhbmNlLmdldCgpOyB9CiAgICAgV2FzbTo6U2lnbmF0dXJlSW5k ZXggc2lnbmF0dXJlSW5kZXgoKSBjb25zdCB7IHJldHVybiBtX3NpZ25hdHVyZUluZGV4OyB9Ci0g ICAgdm9pZCogd2FzbUVudHJ5cG9pbnQoKSB7IHJldHVybiBtX3dhc21FbnRyeXBvaW50LT5lbnRy eXBvaW50KCk7IH0KKyAgICB2b2lkKiB3YXNtRW50cnlwb2ludCgpIHsgcmV0dXJuIG1fd2FzbUVu dHJ5UG9pbnRDb2RlOyB9CiAgICAgdm9pZCoganNFbnRyeXBvaW50KCkgeyByZXR1cm4gbV9qc0Vu dHJ5cG9pbnQtPmVudHJ5cG9pbnQoKTsgfQogCisgICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRP Zkluc3RhbmNlKCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKFdlYkFzc2VtYmx5RnVuY3Rpb24s IG1faW5zdGFuY2UpOyB9CisgICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZldhc21FbnRyeVBv aW50Q29kZSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihXZWJBc3NlbWJseUZ1bmN0aW9uLCBt X3dhc21FbnRyeVBvaW50Q29kZSk7IH0KKwogcHJvdGVjdGVkOgogICAgIHN0YXRpYyB2b2lkIHZp c2l0Q2hpbGRyZW4oSlNDZWxsKiwgU2xvdFZpc2l0b3ImKTsKIAogICAgIHZvaWQgZmluaXNoQ3Jl YXRpb24oVk0mLCBOYXRpdmVFeGVjdXRhYmxlKiwgdW5zaWduZWQgbGVuZ3RoLCBjb25zdCBTdHJp bmcmIG5hbWUsIEpTV2ViQXNzZW1ibHlJbnN0YW5jZSosIEpTV2ViQXNzZW1ibHlDYWxsZWUqIGpz RW50cnlwb2ludCwgSlNXZWJBc3NlbWJseUNhbGxlZSogd2FzbUVudHJ5cG9pbnQpOwogCiBwcml2 YXRlOgotICAgIFdlYkFzc2VtYmx5RnVuY3Rpb24oVk0mLCBKU0dsb2JhbE9iamVjdCosIFN0cnVj dHVyZSosIFdhc206OlNpZ25hdHVyZUluZGV4KTsKKyAgICBXZWJBc3NlbWJseUZ1bmN0aW9uKFZN JiwgSlNHbG9iYWxPYmplY3QqLCBTdHJ1Y3R1cmUqLCBXYXNtOjpTaWduYXR1cmVJbmRleCwgdm9p ZCopOwogCiAgICAgV3JpdGVCYXJyaWVyPEpTV2ViQXNzZW1ibHlJbnN0YW5jZT4gbV9pbnN0YW5j ZTsKKyAgICB2b2lkKiBtX3dhc21FbnRyeVBvaW50Q29kZTsgLy8gUmVtb3ZlIGluZGlyZWN0aW9u cyBmb3Igd2FzbSAtPiB3YXNtIGNhbGxzLgogICAgIFdyaXRlQmFycmllcjxKU1dlYkFzc2VtYmx5 Q2FsbGVlPiBtX2pzRW50cnlwb2ludDsKICAgICBXcml0ZUJhcnJpZXI8SlNXZWJBc3NlbWJseUNh bGxlZT4gbV93YXNtRW50cnlwb2ludDsKICAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBtX3NpZ25h dHVyZUluZGV4OwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2Vi QXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVjdG9yLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VDb25zdHJ1Y3Rvci5jcHAKaW5kZXggZDYwZjQwZS4u MWI0NjExMiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNz ZW1ibHlJbnN0YW5jZUNvbnN0cnVjdG9yLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9qcy9XZWJBc3NlbWJseUluc3RhbmNlQ29uc3RydWN0b3IuY3BwCkBAIC04NCw2ICs4NCwx MSBAQCBzdGF0aWMgRW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBjb25zdHJ1Y3RKU1dlYkFz c2VtYmx5SW5zdGFuY2UoRXhlY1N0YXRlKiBleAogCiAgICAgSlNXZWJBc3NlbWJseUluc3RhbmNl KiBpbnN0YW5jZSA9IEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6Y3JlYXRlKHZtLCBpbnN0YW5jZVN0 cnVjdHVyZSwganNNb2R1bGUsIG1vZHVsZVJlY29yZC0+Z2V0TW9kdWxlTmFtZXNwYWNlKGV4ZWMp KTsKICAgICBSRVRVUk5fSUZfRVhDRVBUSU9OKHRocm93U2NvcGUsIGVuY29kZWRKU1ZhbHVlKCkp OworICAgIHsKKyAgICAgICAgLy8gQWx3YXlzIHN0YXJ0IHdpdGggYSBkdW1teSBNZW1vcnksIHNv IHRoYXQgd2FzbSAtPiB3YXNtIHRodW5rcyBhdm9pZCBjaGVja2luZyBmb3IgYSBudWxscHRyIE1l bW9yeSB3aGVuIHRyeWluZyB0byBzZXQgcGlubmVkIHJlZ2lzdGVycy4KKyAgICAgICAgV2FzbTo6 TWVtb3J5IG1lbW9yeTsKKyAgICAgICAgaW5zdGFuY2UtPnNldE1lbW9yeSh2bSwgSlNXZWJBc3Nl bWJseU1lbW9yeTo6Y3JlYXRlKHZtLCBleGVjLT5sZXhpY2FsR2xvYmFsT2JqZWN0KCktPldlYkFz c2VtYmx5TWVtb3J5U3RydWN0dXJlKCksIFdURk1vdmUobWVtb3J5KSkpOworICAgIH0KIAogICAg IC8vIExldCBmdW5jcywgbWVtb3JpZXMgYW5kIHRhYmxlcyBiZSBpbml0aWFsbHktZW1wdHkgbGlz dHMgb2YgY2FsbGFibGUgSmF2YVNjcmlwdCBvYmplY3RzLCBXZWJBc3NlbWJseS5NZW1vcnkgb2Jq ZWN0cyBhbmQgV2ViQXNzZW1ibHkuVGFibGUgb2JqZWN0cywgcmVzcGVjdGl2ZWx5LgogICAgIC8v IExldCBpbXBvcnRzIGJlIGFuIGluaXRpYWxseS1lbXB0eSBsaXN0IG9mIGV4dGVybmFsIHZhbHVl cy4KQEAgLTExNCwxOCArMTE5LDE5IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9D QUxMIGNvbnN0cnVjdEpTV2ViQXNzZW1ibHlJbnN0YW5jZShFeGVjU3RhdGUqIGV4CiAgICAgICAg ICAgICAgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29kZSh0aHJvd0V4Y2VwdGlvbihleGVjLCB0aHJv d1Njb3BlLCBjcmVhdGVKU1dlYkFzc2VtYmx5TGlua0Vycm9yKGV4ZWMsIHZtLCBBU0NJSUxpdGVy YWwoImltcG9ydCBmdW5jdGlvbiBtdXN0IGJlIGNhbGxhYmxlIikpKSk7CiAgICAgICAgICAgICBK U0NlbGwqIGNlbGwgPSB2YWx1ZS5hc0NlbGwoKTsKICAgICAgICAgICAgIC8vIGlpLiBJZiB2IGlz IGFuIEV4cG9ydGVkIEZ1bmN0aW9uIEV4b3RpYyBPYmplY3Q6Ci0gICAgICAgICAgICBpZiAoV2Vi QXNzZW1ibHlGdW5jdGlvbiogaW1wb3J0ZWRFeHBvcnRzID0ganNEeW5hbWljQ2FzdDxXZWJBc3Nl bWJseUZ1bmN0aW9uKj4ob2JqZWN0KSkgewotICAgICAgICAgICAgICAgIC8vIEZJWE1FIGhhbmRs ZSBGdW5jdGlvbiBFeG90aWMgT2JqZWN0IHByb3Blcmx5LiBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTY1MjgyCi0gICAgICAgICAgICAgICAgLy8gYS4gSWYgdGhlIHNp Z25hdHVyZSBvZiB2IGRvZXMgbm90IG1hdGNoIHRoZSBzaWduYXR1cmUgb2YgaSwgdGhyb3cgYSBU eXBlRXJyb3IuCisgICAgICAgICAgICBpZiAoV2ViQXNzZW1ibHlGdW5jdGlvbiogaW1wb3J0ZWRF eHBvcnQgPSBqc0R5bmFtaWNDYXN0PFdlYkFzc2VtYmx5RnVuY3Rpb24qPihjZWxsKSkgeworICAg ICAgICAgICAgICAgIC8vIGEuIElmIHRoZSBzaWduYXR1cmUgb2YgdiBkb2VzIG5vdCBtYXRjaCB0 aGUgc2lnbmF0dXJlIG9mIGksIHRocm93IGEgV2ViQXNzZW1ibHkuTGlua0Vycm9yLgorICAgICAg ICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IGltcG9ydGVkU2lnbmF0dXJlSW5kZXggPSBp bXBvcnRlZEV4cG9ydC0+c2lnbmF0dXJlSW5kZXgoKTsKKyAgICAgICAgICAgICAgICBXYXNtOjpT aWduYXR1cmVJbmRleCBleHBlY3RlZFNpZ25hdHVyZUluZGV4ID0gbW9kdWxlSW5mb3JtYXRpb24u aW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzW2ltcG9ydC5raW5kSW5kZXhdOworICAgICAg ICAgICAgICAgIGlmIChpbXBvcnRlZFNpZ25hdHVyZUluZGV4ICE9IGV4cGVjdGVkU2lnbmF0dXJl SW5kZXgpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBKU1ZhbHVlOjplbmNvZGUodGhyb3dF eGNlcHRpb24oZXhlYywgdGhyb3dTY29wZSwgY3JlYXRlSlNXZWJBc3NlbWJseUxpbmtFcnJvcihl eGVjLCB2bSwgQVNDSUlMaXRlcmFsKCJpbXBvcnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBkb2Vz bid0IG1hdGNoIHRoZSBwcm92aWRlZCBXZWJBc3NlbWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSIp KSkpOwogICAgICAgICAgICAgICAgIC8vIGIuIExldCBjbG9zdXJlIGJlIHYuW1tDbG9zdXJlXV0u Ci0gICAgICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKLSAgICAgICAg ICAgICAgICBVTlVTRURfUEFSQU0oaW1wb3J0ZWRFeHBvcnRzKTsKLSAgICAgICAgICAgICAgICBi cmVhazsKICAgICAgICAgICAgIH0KICAgICAgICAgICAgIC8vIGlpaS4gT3RoZXJ3aXNlOgogICAg ICAgICAgICAgLy8gYS4gTGV0IGNsb3N1cmUgYmUgYSBuZXcgaG9zdCBmdW5jdGlvbiBvZiB0aGUg Z2l2ZW4gc2lnbmF0dXJlIHdoaWNoIGNhbGxzIHYgYnkgY29lcmNpbmcgV2ViQXNzZW1ibHkgYXJn dW1lbnRzIHRvIEphdmFTY3JpcHQgYXJndW1lbnRzIHZpYSBUb0pTVmFsdWUgYW5kIHJldHVybnMg dGhlIHJlc3VsdCwgaWYgYW55LCBieSBjb2VyY2luZyB2aWEgVG9XZWJBc3NlbWJseVZhbHVlLgog ICAgICAgICAgICAgLy8gTm90ZTogZG9uZSBhcyBwYXJ0IG9mIFBsYW4gY29tcGlsYXRpb24uCiAg ICAgICAgICAgICAvLyBpdi4gQXBwZW5kIHYgdG8gZnVuY3MuCisgICAgICAgICAgICAvLyBOb3Rl OiBhZGRpbmcgdGhlIEpTQ2VsbCB0byB0aGUgaW5zdGFuY2UgbGlzdCBmdWxmaWxscyBjbG9zdXJl IHJlcXVpcmVtZW50cyBiLiBhYm92ZSAodGhlIFdlYkFzc2VtYmx5Lkluc3RhbmNlIHdpbCBiZSBr ZXB0IGFsaXZlKSBhbmQgdi4gYmVsb3cgKHRoZSBKU0Z1bmN0aW9uKS4KICAgICAgICAgICAgIGlu c3RhbmNlLT5zZXRJbXBvcnRGdW5jdGlvbih2bSwgY2VsbCwgbnVtSW1wb3J0RnVuY3Rpb25zKysp OwogICAgICAgICAgICAgLy8gdi4gQXBwZW5kIGNsb3N1cmUgdG8gaW1wb3J0cy4KICAgICAgICAg ICAgIGJyZWFrOwpAQCAtMjMwLDcgKzIzNiw3IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0Nf SE9TVF9DQUxMIGNvbnN0cnVjdEpTV2ViQXNzZW1ibHlJbnN0YW5jZShFeGVjU3RhdGUqIGV4CiAg ICAgICAgICAgICBSRUxFQVNFX0FTU0VSVCghbW9kdWxlSW5mb3JtYXRpb24ubWVtb3J5LmlzSW1w b3J0KCkpOwogICAgICAgICAgICAgLy8gV2UgY3JlYXRlIGEgbWVtb3J5IHdoZW4gaXQncyBhIG1l bW9yeSBkZWZpbml0aW9uLgogICAgICAgICAgICAgYm9vbCBmYWlsZWQ7Ci0gICAgICAgICAgICBz dGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiBtZW1vcnkgPSBzdGQ6Om1ha2VfdW5pcXVlPFdh c206Ok1lbW9yeT4obW9kdWxlSW5mb3JtYXRpb24ubWVtb3J5LmluaXRpYWwoKSwgbW9kdWxlSW5m b3JtYXRpb24ubWVtb3J5Lm1heGltdW0oKSwgZmFpbGVkKTsKKyAgICAgICAgICAgIFdhc206Ok1l bW9yeSBtZW1vcnkobW9kdWxlSW5mb3JtYXRpb24ubWVtb3J5LmluaXRpYWwoKSwgbW9kdWxlSW5m b3JtYXRpb24ubWVtb3J5Lm1heGltdW0oKSwgZmFpbGVkKTsKICAgICAgICAgICAgIGlmIChmYWls ZWQpCiAgICAgICAgICAgICAgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29kZSh0aHJvd0V4Y2VwdGlv bihleGVjLCB0aHJvd1Njb3BlLCBjcmVhdGVPdXRPZk1lbW9yeUVycm9yKGV4ZWMpKSk7CiAgICAg ICAgICAgICBpbnN0YW5jZS0+c2V0TWVtb3J5KHZtLApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNZW1vcnlDb25zdHJ1Y3Rvci5jcHAgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1lbW9yeUNvbnN0cnVjdG9yLmNw cAppbmRleCA1ZDVhNmNkLi42Yzg4N2FmIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9qcy9XZWJBc3NlbWJseU1lbW9yeUNvbnN0cnVjdG9yLmNwcAorKysgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1lbW9yeUNvbnN0cnVjdG9yLmNwcApA QCAtOTcsNyArOTcsNyBAQCBzdGF0aWMgRW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBjb25z dHJ1Y3RKU1dlYkFzc2VtYmx5TWVtb3J5KEV4ZWNTdGF0ZSogZXhlYwogICAgIH0KIAogICAgIGJv b2wgZmFpbGVkOwotICAgIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+IG1lbW9yeSA9IHN0 ZDo6bWFrZV91bmlxdWU8V2FzbTo6TWVtb3J5Pihpbml0aWFsUGFnZUNvdW50LCBtYXhpbXVtUGFn ZUNvdW50LCBmYWlsZWQpOworICAgIFdhc206Ok1lbW9yeSBtZW1vcnkoaW5pdGlhbFBhZ2VDb3Vu dCwgbWF4aW11bVBhZ2VDb3VudCwgZmFpbGVkKTsKICAgICBpZiAoZmFpbGVkKQogICAgICAgICBy ZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKHRocm93RXhjZXB0aW9uKGV4ZWMsIHRocm93U2NvcGUsIGNy ZWF0ZU91dE9mTWVtb3J5RXJyb3IoZXhlYykpKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVDb25zdHJ1Y3Rvci5jcHAgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNw cAppbmRleCAzOGVkYjhjLi44MTI5NTkyIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNwcAorKysgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNwcApA QCAtOTcsNyArOTcsNyBAQCBKU1ZhbHVlIFdlYkFzc2VtYmx5TW9kdWxlQ29uc3RydWN0b3I6OmNy ZWF0ZU1vZHVsZShFeGVjU3RhdGUqIHN0YXRlLCBTdHJ1Y3R1cmUqCiAKICAgICAvLyBPbmx5IHdh c20taW50ZXJuYWwgZnVuY3Rpb25zIGhhdmUgYSBjYWxsZWUsIHN0dWJzIHRvIEpTIGRvIG5vdC4K ICAgICB1bnNpZ25lZCBjYWxsZWVDb3VudCA9IHBsYW4uaW50ZXJuYWxGdW5jdGlvbkNvdW50KCk7 Ci0gICAgSlNXZWJBc3NlbWJseU1vZHVsZSogcmVzdWx0ID0gSlNXZWJBc3NlbWJseU1vZHVsZTo6 Y3JlYXRlKHZtLCBzdHJ1Y3R1cmUsIHBsYW4udGFrZU1vZHVsZUluZm9ybWF0aW9uKCksIHBsYW4u dGFrZUNhbGxMaW5rSW5mb3MoKSwgcGxhbi50YWtlV2FzbVRvSlNTdHVicygpLCBwbGFuLnRha2VG dW5jdGlvbkluZGV4U3BhY2UoKSwgZXhwb3J0U3ltYm9sVGFibGUsIGNhbGxlZUNvdW50KTsKKyAg ICBKU1dlYkFzc2VtYmx5TW9kdWxlKiByZXN1bHQgPSBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVh dGUodm0sIHN0cnVjdHVyZSwgcGxhbi50YWtlTW9kdWxlSW5mb3JtYXRpb24oKSwgcGxhbi50YWtl Q2FsbExpbmtJbmZvcygpLCBwbGFuLnRha2VXYXNtRXhpdFN0dWJzKCksIGV4cG9ydFN5bWJvbFRh YmxlLCBjYWxsZWVDb3VudCk7CiAgICAgcGxhbi5pbml0aWFsaXplQ2FsbGVlcyhzdGF0ZS0+anND YWxsZWUoKS0+Z2xvYmFsT2JqZWN0KCksIAogICAgICAgICBbJl0gKHVuc2lnbmVkIGNhbGxlZUlu ZGV4LCBKU1dlYkFzc2VtYmx5Q2FsbGVlKiBqc0VudHJ5cG9pbnRDYWxsZWUsIEpTV2ViQXNzZW1i bHlDYWxsZWUqIHdhc21FbnRyeXBvaW50Q2FsbGVlKSB7CiAgICAgICAgICAgICByZXN1bHQtPnNl dEpTRW50cnlwb2ludENhbGxlZSh2bSwgY2FsbGVlSW5kZXgsIGpzRW50cnlwb2ludENhbGxlZSk7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1v ZHVsZVJlY29yZC5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJs eU1vZHVsZVJlY29yZC5jcHAKaW5kZXggYzFiZDgyMC4uOWVmZjRjNCAxMDA2NDQKLS0tIGEvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQuY3BwCisr KyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3Jk LmNwcApAQCAtMTE4LDcgKzExOCw3IEBAIHZvaWQgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6Omxp bmsoRXhlY1N0YXRlKiBzdGF0ZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBpbnN0CiAgICAgICAg ICAgICAvLyAgICAgYy4gUmV0dXJuIGZ1bmMuCiAgICAgICAgICAgICBKU1dlYkFzc2VtYmx5Q2Fs bGVlKiBqc0VudHJ5cG9pbnRDYWxsZWUgPSBtb2R1bGUtPmpzRW50cnlwb2ludENhbGxlZUZyb21G dW5jdGlvbkluZGV4U3BhY2UoZXhwLmtpbmRJbmRleCk7CiAgICAgICAgICAgICBKU1dlYkFzc2Vt Ymx5Q2FsbGVlKiB3YXNtRW50cnlwb2ludENhbGxlZSA9IG1vZHVsZS0+d2FzbUVudHJ5cG9pbnRD YWxsZWVGcm9tRnVuY3Rpb25JbmRleFNwYWNlKGV4cC5raW5kSW5kZXgpOwotICAgICAgICAgICAg V2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVyZUZv ckZ1bmN0aW9uSW5kZXhTcGFjZShleHAua2luZEluZGV4KTsKKyAgICAgICAgICAgIFdhc206OlNp Z25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21G dW5jdGlvbkluZGV4U3BhY2UoZXhwLmtpbmRJbmRleCk7CiAgICAgICAgICAgICBjb25zdCBXYXNt OjpTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFdhc206OlNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQo JnZtLCBzaWduYXR1cmVJbmRleCk7CiAgICAgICAgICAgICBXZWJBc3NlbWJseUZ1bmN0aW9uKiBm dW5jdGlvbiA9IFdlYkFzc2VtYmx5RnVuY3Rpb246OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LCBz aWduYXR1cmUtPmFyZ3VtZW50Q291bnQoKSwgZXhwLmZpZWxkLnN0cmluZygpLCBpbnN0YW5jZSwg anNFbnRyeXBvaW50Q2FsbGVlLCB3YXNtRW50cnlwb2ludENhbGxlZSwgc2lnbmF0dXJlSW5kZXgp OwogICAgICAgICAgICAgZXhwb3J0ZWRWYWx1ZSA9IGZ1bmN0aW9uOwpAQCAtMTMzLDggKzEzMyw2 IEBAIHZvaWQgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmxpbmsoRXhlY1N0YXRlKiBzdGF0ZSwg SlNXZWJBc3NlbWJseUluc3RhbmNlKiBpbnN0CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAg fQogICAgICAgICBjYXNlIFdhc206OkV4dGVybmFsS2luZDo6TWVtb3J5OiB7Ci0gICAgICAgICAg ICAvLyBUaGlzIHNob3VsZCBiZSBndWFyYW50ZWVkIGJ5IG1vZHVsZSB2ZXJpZmljYXRpb24uCi0g ICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChpbnN0YW5jZS0+bWVtb3J5KCkpOyAKICAgICAgICAg ICAgIEFTU0VSVChleHAua2luZEluZGV4ID09IDApOwogCiAgICAgICAgICAgICBleHBvcnRlZFZh bHVlID0gaW5zdGFuY2UtPm1lbW9yeSgpOwpAQCAtMTc1LDcgKzE3Myw3IEBAIHZvaWQgV2ViQXNz ZW1ibHlNb2R1bGVSZWNvcmQ6OmxpbmsoRXhlY1N0YXRlKiBzdGF0ZSwgSlNXZWJBc3NlbWJseUlu c3RhbmNlKiBpbnN0CiAgICAgYm9vbCBoYXNTdGFydCA9ICEhbW9kdWxlSW5mb3JtYXRpb24uc3Rh cnRGdW5jdGlvbkluZGV4U3BhY2U7CiAgICAgaWYgKGhhc1N0YXJ0KSB7CiAgICAgICAgIGF1dG8g c3RhcnRGdW5jdGlvbkluZGV4U3BhY2UgPSBtb2R1bGVJbmZvcm1hdGlvbi5zdGFydEZ1bmN0aW9u SW5kZXhTcGFjZS52YWx1ZV9vcigwKTsKLSAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2ln bmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVyZUZvckZ1bmN0aW9uSW5kZXhTcGFjZShzdGFy dEZ1bmN0aW9uSW5kZXhTcGFjZSk7CisgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25h dHVyZUluZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2Uo c3RhcnRGdW5jdGlvbkluZGV4U3BhY2UpOwogICAgICAgICBjb25zdCBXYXNtOjpTaWduYXR1cmUq IHNpZ25hdHVyZSA9IFdhc206OlNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQoJnZtLCBzaWduYXR1 cmVJbmRleCk7CiAgICAgICAgIC8vIFRoZSBzdGFydCBmdW5jdGlvbiBtdXN0IG5vdCB0YWtlIGFu eSBhcmd1bWVudHMgb3IgcmV0dXJuIGFueXRoaW5nLiBUaGlzIGlzIGVuZm9yY2VkIGJ5IHRoZSBw YXJzZXIuCiAgICAgICAgIEFTU0VSVCghc2lnbmF0dXJlLT5hcmd1bWVudENvdW50KCkpOwpAQCAt MjM4LDcgKzIzNiw3IEBAIEpTVmFsdWUgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmV2YWx1YXRl KEV4ZWNTdGF0ZSogc3RhdGUpCiAKICAgICAgICAgICAgICAgICBKU1dlYkFzc2VtYmx5Q2FsbGVl KiBqc0VudHJ5cG9pbnRDYWxsZWUgPSBtb2R1bGUtPmpzRW50cnlwb2ludENhbGxlZUZyb21GdW5j dGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleCk7CiAgICAgICAgICAgICAgICAgSlNXZWJBc3Nl bWJseUNhbGxlZSogd2FzbUVudHJ5cG9pbnRDYWxsZWUgPSBtb2R1bGUtPndhc21FbnRyeXBvaW50 Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KTsKLSAgICAgICAgICAg ICAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1vZHVsZS0+c2lnbmF0 dXJlRm9yRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgpOworICAgICAgICAgICAgICAg IFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVJ bmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleCk7CiAgICAgICAgICAgICAg ICAgY29uc3QgV2FzbTo6U2lnbmF0dXJlKiBzaWduYXR1cmUgPSBXYXNtOjpTaWduYXR1cmVJbmZv cm1hdGlvbjo6Z2V0KCZ2bSwgc2lnbmF0dXJlSW5kZXgpOwogICAgICAgICAgICAgICAgIC8vIEZJ WE1FOiBTYXkgd2UgZXhwb3J0IGxvY2FsIGZ1bmN0aW9uICJmb28iIGF0IGZ1bmNpdG9uIGluZGV4 IDAuCiAgICAgICAgICAgICAgICAgLy8gV2hhdCBpZiB3ZSBhbHNvIHNldCBpdCB0byB0aGUgdGFi bGUgYW4gRWxlbWVudCB3LyBpbmRleCAwLgpAQCAtMjU3LDcgKzI1NSw2IEBAIEpTVmFsdWUgV2Vi QXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmV2YWx1YXRlKEV4ZWNTdGF0ZSogc3RhdGUpCiAgICAgICAg IGNvbnN0IFZlY3RvcjxXYXNtOjpTZWdtZW50OjpQdHI+JiBkYXRhID0gbV9pbnN0YW5jZS0+bW9k dWxlKCktPm1vZHVsZUluZm9ybWF0aW9uKCkuZGF0YTsKICAgICAgICAgSlNXZWJBc3NlbWJseU1l bW9yeSoganNNZW1vcnkgPSBtX2luc3RhbmNlLT5tZW1vcnkoKTsKICAgICAgICAgaWYgKCFkYXRh LmlzRW1wdHkoKSkgewotICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQoanNNZW1vcnkpOyAvLyBJ dCBpcyBhIHZhbGlkYXRpb24gZXJyb3IgZm9yIGEgRGF0YSBzZWN0aW9uIHRvIGV4aXN0IHdpdGhv dXQgYSBNZW1vcnkgc2VjdGlvbiBvciBpbXBvcnQuCiAgICAgICAgICAgICB1aW50OF90KiBtZW1v cnkgPSByZWludGVycHJldF9jYXN0PHVpbnQ4X3QqPihqc01lbW9yeS0+bWVtb3J5KCktPm1lbW9y eSgpKTsKICAgICAgICAgICAgIHVpbnQ2NF90IHNpemVJbkJ5dGVzID0ganNNZW1vcnktPm1lbW9y eSgpLT5zaXplKCk7CiAgICAgICAgICAgICBmb3IgKGF1dG8mIHNlZ21lbnQgOiBkYXRhKSB7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVs ZVJlY29yZC5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1 bGVSZWNvcmQuaAppbmRleCBlMTI2NjcwLi4yNDY1ZDgzIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZVJlY29yZC5oCisrKyBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmgKQEAgLTQ1 LDcgKzQ1LDcgQEAgcHVibGljOgogICAgIERFQ0xBUkVfRVhQT1JUX0lORk87CiAKICAgICBzdGF0 aWMgU3RydWN0dXJlKiBjcmVhdGVTdHJ1Y3R1cmUoVk0mLCBKU0dsb2JhbE9iamVjdCosIEpTVmFs dWUpOwotICAgIHN0YXRpYyBXZWJBc3NlbWJseU1vZHVsZVJlY29yZCogY3JlYXRlKEV4ZWNTdGF0 ZSosIFZNJiwgU3RydWN0dXJlKiwgY29uc3QgSWRlbnRpZmllciYsIGNvbnN0IFdhc206Ok1vZHVs ZUluZm9ybWF0aW9uJik7CisgICAgSlNfRVhQT1JUX1BSSVZBVEUgc3RhdGljIFdlYkFzc2VtYmx5 TW9kdWxlUmVjb3JkKiBjcmVhdGUoRXhlY1N0YXRlKiwgVk0mLCBTdHJ1Y3R1cmUqLCBjb25zdCBJ ZGVudGlmaWVyJiwgY29uc3QgV2FzbTo6TW9kdWxlSW5mb3JtYXRpb24mKTsKIAogICAgIHZvaWQg bGluayhFeGVjU3RhdGUqLCBKU1dlYkFzc2VtYmx5SW5zdGFuY2UqKTsKICAgICBKU19FWFBPUlRf UFJJVkFURSBKU1ZhbHVlIGV2YWx1YXRlKEV4ZWNTdGF0ZSopOwotLSAKMi4xMC4xCgo= 297859 2016-12-30 12:11:01 -0800 2016-12-30 12:24:29 -0800 WIP 0001-wasm-wasm.patch text/plain 144363 jfbastien RnJvbSA3NzNkZTZkZGNlMDkzOWMzNzg2NDE4YjRhMTdhYTIyZThiNDc5MTJjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBXZWQsIDIxIERlYyAyMDE2IDE1OjU5OjU2IC0wODAwClN1YmplY3Q6IFtQQVRDSF0gd2FzbS0+ d2FzbQoKQ2hhbmdlcyB0byB0aGUgV2ViQXNzZW1ibHkgaW1wbGVtZW50YXRpb246CgogIC0gQWRk IGEgbmV3IEpTVHlwZSBmb3IgV2ViQXNzZW1ibHlGdW5jdGlvbiwgYW5kIHVzZSBpdCB3aGVuIGNy ZWF0aW5nIGl0cwogICAgc3RydWN0dXJlLiBUaGlzIHdpbGwgYmUgdXNlZCB0byBxdWlja2x5IGRl dGVjdCBmcm9tIHdhc20gd2hldGhlciB0aGUgaW1wb3J0CiAgICBjYWxsIGlzIHRvIGFub3RoZXIg d2FzbSBtb2R1bGUsIG9yIHdoZXRoZXIgaXQncyB0byBKUy4KICAtIFVzZSBjZWxsIGluc3RlYWQg b2Ygb2JqZWN0cyB0byBkZXRlY3Qgd2FzbS0+d2FzbSwgdGhlIHByZXZpb3VzIGNvZGUgd2FzIHdy b25nLgogIC0gSW1wcm92ZSBkaWFnbm9zdGljIHByaW50b3V0IGZvciB3YXNtIHN0dWJzOiBwcmlu dCB0aGUgZnVsbCBzaWduYXR1cmUuCiAgLSBQcm9wZXJseSBjaGVjayB0aGF0IHdhc20gLT4gd2Fz bSBjYWxscyBoYXZlIG1hdGNoaW5nIHNpZ25hdHVyZXMuIEFkZCB0ZXN0aW5nIGZvciB0aGlzLgog IC0gVGVzdCBzb21lIG9mIHRoZSB3YXNtIC0+IHdhc20gY2FsbHMsIG5vdCB3b3JraW5nIHlldCwg YW5kIG1vcmUgdGVzdHMgbmVlZCB0bwogICAgZ2V0IGltcGxlbWVudGVkLgogIC0gR2VuZXJhdGUg dHdvIHN0dWJzIGZyb20gdGhlIGltcG9ydCBzdHViIGdlbmVyYXRvcjogb25lIGZvciB3YXNtLT5K UyBhbmQgb25lCiAgICBmb3Igd2FzbSAtPiB3YXNtLiBUaGlzIGlzIGRvbmUgYXQgTW9kdWxlIHRp bWUuIFdoaWNoIGlzIGNhbGxlZCB3aWxsIG9ubHkgYmUKICAgIGtub3duIGF0IEluc3RhbmNlIHRp bWUsIG9uY2Ugd2UndmUgcmVjZWl2ZWQgdGhlIGltcG9ydCBvYmplY3QuIFdlIHdhbnQgdG8KICAg IGF2b2lkIGNvZGVnZW4gYXQgSW5zdGFuY2UgdGltZSwgc28gaGF2aW5nIGJvdGggYXJvdW5kIGlz IGdyZWF0LgogIC0gUmVzdG9yZSB0aGUgV2ViQXNzZW1ibHkgZ2xvYmFsIHN0YXRlIChWTSB0b3Ag SW5zdGFuY2UsIGFuZCBwaW5uZWQgcmVnaXN0ZXJzKQogICAgYWZ0ZXIgY2FsbCAvIGNhbGxfaW5k aXJlY3QsIGFuZCBpbiB0aGUgSlMtPndhc20gZW50cnkgc3R1Yi4KICAtIFBpbm5lZCByZWdpc3Rl cnMgYXJlIG5vdyBhIGdsb2JhbCB0aGluZywgbm90IHBlci1NZW1vcnksIGJlY2F1c2UgdGhlIHdh c20gLT4KICAgIHdhc20gc3R1YnMgYXJlIGdlbmVyYXRlZCBhdCBNb2R1bGUgdGltZSB3aGVyZSB3 ZSBkb24ndCByZWFsbHkgaGF2ZSBlbm91Z2gKICAgIGluZm9ybWF0aW9uIHRvIGRvIHRoZSByaWdo dCB0aGluZyAoZG9pbmcgc28gd291bGQgZ2VuZXJhdGUgdG9vIG11Y2ggY29kZSkuCgpTdXBwb3J0 IGNoYW5nZXM6CgogIC0gQWRkIGEgUHJveHkgdG8gQnVpbGRlci5qcywgd2hpY2ggaW50ZXJjZXB0 cyB1bmtub3duIHByb3BlcnR5IGxvb2t1cHMuIFRoaXMKICAgIGNyZWF0ZXMgd2F5IGJldHRlciBl cnJvciBtZXNzYWdlcyBvbiB0eXBvcyB0aGFuICd1bmRlZmluZWQgaXMgbm90IGEKICAgIGZ1bmN0 aW9uJywgd2hpY2ggaGFwcGVucyBzZW1pLWZyZXF1ZW50bHkgYXMgSSB0eXBvIG9wY29kZSBuYW1l cyAoYW5kIHdoaWNoCiAgICBvbmUgaXMgYSB0eXBvIGlzIGhhcmQgdG8gZmluZCBiZWNhdXNlIHdl IGNoYWluIGJ1aWxkZXJzKS4KICAtIEFkZCBsaW1pdGVkIHN1cHBvcnQgZm9yIHZhcnt1fWludDY0 IChvbmx5IHRoZSAzMi1iaXQgdmFsdWVzKS4KICAtIEdldCByaWQgb2YgbXVjaCBvZiB0aGUgZnVu Y3Rpb24gaW5kZXggc3BhY2U6IHdlIGFscmVhZHkgaGF2ZSBhbGwgb2YgaXRzCiAgICBpbmZvcm1h dGlvbiBlbHNld2hlcmUsIGFuZCBhcy1pcyBpdCBwcm92aWRlcyBubyBleHRyYSBlZmZpY2llbmN5 LgogIC0gU3RvcmUgV2FzbTo6TWVtb3J5IGRpcmVjdGx5IG9uIEpTV2ViQXNzZW1ibHlNZW1vcnks IGluc3RlYWQgb2YgdGhyb3VnaCBhCiAgICB1bmlxdWVfcHRyLiBUaGlzIHJlbW92ZXMgYW4gaW5k aXJlY3Rpb24gYW5kIHVzZWxlc3MgYWxsb2NhdGlvbi4KICAtIFJlbW92ZSBWTSdhIFdlYkFzc2Vt Ymx5IG1lbW9yeSAvIHNpemUsIGFuZCBvYnRhaW4gdGhlbSBmcm9tIEluc3RhbmNlCiAgICBpbnN0 ZWFkLiBUaGlzIHJlcXVpcmVzIGFuIGV4dHJhIGluZGlyZWN0aW9uLCBidXQgaXMgY2xlYW5lci4K ICAtIENhY2hlIHRoZSB3YXNtIGVudHJ5cG9pbnQgY29kZSdzIGxvY2F0aW9uIG9uIFdlYkFzc2Vt Ymx5RnVuY3Rpb24gZm9yIGZhc3RlcgogICAgYWNjZXNzLgogIC0gQWxsIEluc3RhbmNlIG5vdyBo YXZlIGEgdmFsaWQgSlNXZWJBc3NlbWJseU1lbW9yeSB3aGVuIGNyZWF0ZWQsIHdoaWNoIGFsbG93 cwogICAgdGhlIHdhc20gLT4gd2FzbSBzdHViIHRvIGFzc3VtZSBpdCBpc24ndCBudWxsIHdoZW4g dHJ5aW5nIHRvIHNldCB0aGUgcGlubmVkCiAgICByZWdpc3RlcnMuCiAgLSBBbHdheXMgcGluIHJl Z2lzdGVycywgZXZlbiBpZiBubyBNZW1vcnkgaXMgcHJlc2VudCBhbmQgd2UgZG9uJ3QgdGVjaG5p Y2FsbHkKICAgIG5lZWQgdG8gcGluIHRoZW0uCi0tLQogSlNUZXN0cy93YXNtL0J1aWxkZXIuanMg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgOTEgKysrKystLS0tCiBKU1Rlc3RzL3dhc20v TG93TGV2ZWxCaW5hcnkuanMgICAgICAgICAgICAgICAgICAgICB8ICAxMiArKwogSlNUZXN0cy93 YXNtL2Z1bmN0aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMgICAgICAgICAgfCAgIDYgKy0KIEpTVGVz dHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMgICAgICAgICAgIHwgICAyICstCiBK U1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5qcyAgICAgICAgICB8ICAgMiAr LQogSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20tYmFkLXNpZ25hdHVyZS5qcyAgfCAx MDUgKysrKysrKysrKwogSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMgICAgICAg ICAgICAgICAgfCAgNzIgKysrKysrKwogU291cmNlL0phdmFTY3JpcHRDb3JlL0NNYWtlTGlzdHMu dHh0ICAgICAgICAgICAgICAgfCAgIDEgKwogLi4uL0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2ogICAgICAgfCAgIDggKy0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9qc2Mu Y3BwICAgICAgICAgICAgICAgICAgICAgIHwgIDI1ICsrLQogLi4uL0phdmFTY3JpcHRDb3JlL3J1 bnRpbWUvQWJzdHJhY3RNb2R1bGVSZWNvcmQuaCAgfCAgIDIgKy0KIFNvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL0pTVHlwZS5oICAgICAgICAgICAgIHwgICAyICsKIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcCAgIHwgMjIzICsrKysrKysrKysrKyst LS0tLS0tLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuaCAg ICAgfCAgIDIgKy0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmNwcCAg ICAgICAgIHwgIDY3ICsrKysrKy0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5k aW5nLmggICAgICAgICAgIHwgICAyICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt Rm9ybWF0LmggICAgICAgICAgICB8ICAyOCArKy0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21GdW5jdGlvblBhcnNlci5oICAgIHwgIDE2ICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9XYXNtTWVtb3J5LmNwcCAgICAgICAgICB8ICA1NyArKysrKy0KIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21NZW1vcnkuaCAgICAgICAgICAgIHwgIDMxICsrLQogLi4uL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmNwcCAgfCAgNTkgKysrKy0tCiBT b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5SW5mb3JtYXRpb24uaCB8ICAgOSAr LQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5jcHAgICAgfCAg MjcgKy0tCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmggICAg ICB8ICAgMiArLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBhZ2VDb3VudC5jcHAg ICAgICAgfCAgNDUgKysrKysKIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QYWdlQ291 bnQuaCAgICAgICAgIHwgICA2ICsKIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFu LmNwcCAgICAgICAgICAgIHwgIDQ0ICsrLS0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dh c21QbGFuLmggICAgICAgICAgICAgIHwgIDE0ICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtU2lnbmF0dXJlLmNwcCAgICAgICB8ICAxOCArLQogU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbVNpZ25hdHVyZS5oICAgICAgICAgfCAgIDEgKwogU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbVZhbGlkYXRlLmNwcCAgICAgICAgfCAgIDQgKy0KIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5oICAgICAgICAgIHwgICAyICstCiAuLi4vSmF2YVNj cmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaCB8ICAxMSArLQogLi4uL0ph dmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5jcHAgfCAgMTIgKy0KIC4u Li9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuaCAgIHwgIDEzICst CiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmNwcCB8ICAg OSArLQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5oICAg fCAgMTYgKy0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24u Y3BwIHwgICA5ICstCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0 aW9uLmggICB8ICAgOCArLQogLi4uL3dhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVj dG9yLmNwcCAgICAgfCAgMjAgKy0KIC4uLi93YXNtL2pzL1dlYkFzc2VtYmx5TWVtb3J5Q29uc3Ry dWN0b3IuY3BwICAgICAgIHwgICAyICstCiAuLi4vd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNv bnN0cnVjdG9yLmNwcCAgICAgICB8ICAgMiArLQogLi4uL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1 bGVSZWNvcmQuY3BwICAgICAgICAgICAgfCAgIDkgKy0KIC4uLi93YXNtL2pzL1dlYkFzc2VtYmx5 TW9kdWxlUmVjb3JkLmggICAgICAgICAgICAgIHwgICAyICstCiA0NCBmaWxlcyBjaGFuZ2VkLCA3 OTcgaW5zZXJ0aW9ucygrKSwgMzAxIGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IEpT VGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLWJhZC1zaWduYXR1cmUuanMKIGNyZWF0ZSBt b2RlIDEwMDY0NCBKU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS5qcwogY3JlYXRlIG1v ZGUgMTAwNjQ0IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QYWdlQ291bnQuY3BwCgpk aWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL0J1aWxkZXIuanMgYi9KU1Rlc3RzL3dhc20vQnVpbGRl ci5qcwppbmRleCBkYTU4NGM0Li4yNmJhNjZlIDEwMDY0NAotLS0gYS9KU1Rlc3RzL3dhc20vQnVp bGRlci5qcworKysgYi9KU1Rlc3RzL3dhc20vQnVpbGRlci5qcwpAQCAtMzgsNyArMzgsNyBAQCBj b25zdCBfaXNWYWxpZFZhbHVlID0gKHZhbHVlLCB0eXBlKSA9PiB7CiAgICAgc3dpdGNoICh0eXBl KSB7CiAgICAgLy8gV2UgYWxsb3cgYm90aCBzaWduZWQgYW5kIHVuc2lnbmVkIG51bWJlcnMuCiAg ICAgY2FzZSAiaTMyIjogcmV0dXJuIE1hdGgucm91bmQodmFsdWUpID09PSB2YWx1ZSAmJiBMTEIu dmFyaW50MzJNaW4gPD0gdmFsdWUgJiYgdmFsdWUgPD0gTExCLnZhcnVpbnQzMk1heDsKLSAgICBj YXNlICJpNjQiOiB0aHJvdyBuZXcgRXJyb3IoYFVuaW1wbGVtZW50ZWQ6IHZhbHVlIGNoZWNrIGZv ciAke3R5cGV9YCk7IC8vIEZJWE1FIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xNjM0MjAgNjQtYml0IHZhbHVlcworICAgIGNhc2UgImk2NCI6IHJldHVybiB0cnVlOyAv LyBGSVhNRSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNDIwIDY0 LWJpdCB2YWx1ZXMKICAgICBjYXNlICJmMzIiOiByZXR1cm4gdHlwZW9mKHZhbHVlKSA9PT0gIm51 bWJlciIgJiYgaXNGaW5pdGUodmFsdWUpOwogICAgIGNhc2UgImY2NCI6IHJldHVybiB0eXBlb2Yo dmFsdWUpID09PSAibnVtYmVyIiAmJiBpc0Zpbml0ZSh2YWx1ZSk7CiAgICAgZGVmYXVsdDogdGhy b3cgbmV3IEVycm9yKGBJbXBsZW1lbnRhdGlvbiBwcm9ibGVtOiB1bmtub3duIHR5cGUgJHt0eXBl fWApOwpAQCAtNTcsNiArNTcsMTYgQEAgY29uc3QgX25vcm1hbGl6ZUZ1bmN0aW9uU2lnbmF0dXJl ID0gKHBhcmFtcywgcmV0KSA9PiB7CiAgICAgcmV0dXJuIFtwYXJhbXMsIHJldF07CiB9OwogCitj b25zdCBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yID0gYnVpbGRlciA9PiBidWlsZGVyWyJfX2lzUHJv eHkiXSA/IGJ1aWxkZXIgOiBuZXcgUHJveHkoYnVpbGRlciwgeworICAgIGdldDogKHRhcmdldCwg cHJvcGVydHksIHJlY2VpdmVyKSA9PiB7CisgICAgICAgIGlmIChwcm9wZXJ0eSA9PT0gIl9faXNQ cm94eSIpCisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgaWYgKHRhcmdldFtwcm9w ZXJ0eV0gPT09IHVuZGVmaW5lZCkKKyAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcihgV2ViQXNz ZW1ibHkgYnVpbGRlciByZWNlaXZlZCB1bmtub3duIHByb3BlcnR5ICcke3Byb3BlcnR5fSdgKTsK KyAgICAgICAgcmV0dXJuIHRhcmdldFtwcm9wZXJ0eV07CisgICAgfQorfSk7CisKIGNvbnN0IF9t YXliZVJlZ2lzdGVyVHlwZSA9IChidWlsZGVyLCB0eXBlKSA9PiB7CiAgICAgY29uc3QgdHlwZVNl Y3Rpb24gPSBidWlsZGVyLl9nZXRTZWN0aW9uKCJUeXBlIik7CiAgICAgaWYgKHR5cGVvZih0eXBl KSA9PT0gIm51bWJlciIpIHsKQEAgLTEwMCw3ICsxMTAsNyBAQCBjb25zdCBfaW1wb3J0RnVuY3Rp b25Db250aW51YXRpb24gPSAoYnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1aWxkZXIpID0+IHsKICAg ICAgICAgc2VjdGlvbi5kYXRhLnB1c2goeyBmaWVsZDogZmllbGQsIHR5cGU6IHR5cGUsIGtpbmQ6 ICJGdW5jdGlvbiIsIG1vZHVsZTogbW9kdWxlIH0pOwogICAgICAgICAvLyBJbXBvcnRzIGFsc28g Y291bnQgaW4gdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlLiBNYXAgdGhlbSBhcyBvYmplY3RzIHRv IGF2b2lkIGNsYXNoaW5nIHdpdGggQ29kZSBmdW5jdGlvbnMnIG5hbWVzLgogICAgICAgICBidWls ZGVyLl9yZWdpc3RlckZ1bmN0aW9uVG9JbmRleFNwYWNlKHsgbW9kdWxlOiBtb2R1bGUsIGZpZWxk OiBmaWVsZCB9KTsKLSAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICByZXR1cm4g X2Vycm9ySGFuZGxpbmdQcm94eUZvcihuZXh0QnVpbGRlcik7CiAgICAgfTsKIH07CiAKQEAgLTEw OSw3ICsxMTksNyBAQCBjb25zdCBfaW1wb3J0TWVtb3J5Q29udGludWF0aW9uID0gKGJ1aWxkZXIs IHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAgIGFzc2VydC5pc1N0cmluZyhtb2R1 bGUsIGBJbXBvcnQgTWVtb3J5IG1vZHVsZSBzaG91bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHttb2R1 bGV9ImApOwogICAgICAgICBhc3NlcnQuaXNTdHJpbmcoZmllbGQsIGBJbXBvcnQgTWVtb3J5IGZp ZWxkIHNob3VsZCBiZSBhIHN0cmluZywgZ290ICIke2ZpZWxkfSJgKTsKICAgICAgICAgc2VjdGlv bi5kYXRhLnB1c2goe21vZHVsZSwgZmllbGQsIGtpbmQ6ICJNZW1vcnkiLCBtZW1vcnlEZXNjcmlw dGlvbjoge2luaXRpYWwsIG1heGltdW19fSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsK KyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAg IH07CiB9OwogCkBAIC0xMTgsNyArMTI4LDcgQEAgY29uc3QgX2ltcG9ydFRhYmxlQ29udGludWF0 aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAgIGFzc2Vy dC5pc1N0cmluZyhtb2R1bGUsIGBJbXBvcnQgVGFibGUgbW9kdWxlIHNob3VsZCBiZSBhIHN0cmlu ZywgZ290ICIke21vZHVsZX0iYCk7CiAgICAgICAgIGFzc2VydC5pc1N0cmluZyhmaWVsZCwgYElt cG9ydCBUYWJsZSBmaWVsZCBzaG91bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHtmaWVsZH0iYCk7CiAg ICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHttb2R1bGUsIGZpZWxkLCBraW5kOiAiVGFibGUiLCB0 YWJsZURlc2NyaXB0aW9uOiB7aW5pdGlhbCwgbWF4aW11bSwgZWxlbWVudH19KTsKLSAgICAgICAg cmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZv cihuZXh0QnVpbGRlcik7CiAgICAgfTsKIH07CiAKQEAgLTE3Miw3ICsxODIsNyBAQCBjb25zdCBf ZXhwb3J0RnVuY3Rpb25Db250aW51YXRpb24gPSAoYnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1aWxk ZXIpID0+IHsKICAgICAgICAgICAgICAgICBhc3NlcnQuZXEodHlwZSwgZXhwb3J0ZWRJbXBvcnQu dHlwZSwgYFJlLWV4cG9ydGluZyBpbXBvcnQgIiR7ZXhwb3J0ZWRJbXBvcnQuZmllbGR9IiBhcyAi JHtmaWVsZH0iIGhhcyBtaXNtYXRjaGluZyB0eXBlYCk7CiAgICAgICAgIH0KICAgICAgICAgc2Vj dGlvbi5kYXRhLnB1c2goeyBmaWVsZDogZmllbGQsIHR5cGU6IHR5cGUsIGtpbmQ6ICJGdW5jdGlv biIsIGluZGV4OiBpbmRleCB9KTsKLSAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAg ICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihuZXh0QnVpbGRlcik7CiAgICAgfTsKIH07 CiAKQEAgLTE4OSw3ICsxOTksNyBAQCBjb25zdCBfZXhwb3J0R2xvYmFsQ29udGludWF0aW9uID0g KGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgcmV0dXJuIChmaWVsZCwg aW5kZXgpID0+IHsKICAgICAgICAgYXNzZXJ0LmlzTnVtYmVyKGluZGV4LCBgR2xvYmFsIGV4cG9y dHMgb25seSBzdXBwb3J0IG51bWJlciBpbmRpY2VzIHJpZ2h0IG5vd2ApOwogICAgICAgICBzZWN0 aW9uLmRhdGEucHVzaCh7IGZpZWxkLCBraW5kOiAiR2xvYmFsIiwgaW5kZXggfSk7Ci0gICAgICAg IHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlG b3IobmV4dEJ1aWxkZXIpOwogICAgIH0KIH07CiAKQEAgLTE5Nyw3ICsyMDcsNyBAQCBjb25zdCBf ZXhwb3J0TWVtb3J5Q29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVy KSA9PiB7CiAgICAgcmV0dXJuIChmaWVsZCwgaW5kZXgpID0+IHsKICAgICAgICAgYXNzZXJ0Lmlz TnVtYmVyKGluZGV4LCBgTWVtb3J5IGV4cG9ydHMgb25seSBzdXBwb3J0IG51bWJlciBpbmRpY2Vz YCk7CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHtmaWVsZCwga2luZDogIk1lbW9yeSIsIGlu ZGV4fSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJv ckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH0KIH07CiAKQEAgLTIwNSw3ICsy MTUsNyBAQCBjb25zdCBfZXhwb3J0VGFibGVDb250aW51YXRpb24gPSAoYnVpbGRlciwgc2VjdGlv biwgbmV4dEJ1aWxkZXIpID0+IHsKICAgICByZXR1cm4gKGZpZWxkLCBpbmRleCkgPT4gewogICAg ICAgICBhc3NlcnQuaXNOdW1iZXIoaW5kZXgsIGBUYWJsZSBleHBvcnRzIG9ubHkgc3VwcG9ydCBu dW1iZXIgaW5kaWNlc2ApOwogICAgICAgICBzZWN0aW9uLmRhdGEucHVzaCh7ZmllbGQsIGtpbmQ6 ICJUYWJsZSIsIGluZGV4fSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAg cmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH0KIH07CiAK QEAgLTIyMCwxMCArMjMwLDEwIEBAIGNvbnN0IF9pbXBvcnRHbG9iYWxDb250aW51YXRpb24gPSAo YnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1aWxkZXIpID0+IHsKICAgICAgICAgICAgICAgICBhc3Nl cnQuaXNTdHJpbmcoZmllbGQsIGBJbXBvcnQgZ2xvYmFsIGZpZWxkIHNob3VsZCBiZSBhIHN0cmlu ZywgZ290ICIke2ZpZWxkfSJgKTsKICAgICAgICAgICAgICAgICBhc3NlcnQuaXNTdHJpbmcobXV0 YWJpbGl0eSwgYEltcG9ydCBnbG9iYWwgbXV0YWJpbGl0eSBzaG91bGQgYmUgYSBzdHJpbmcsIGdv dCAiJHttdXRhYmlsaXR5fSJgKTsKICAgICAgICAgICAgICAgICBzZWN0aW9uLmRhdGEucHVzaCh7 IGdsb2JhbERlc2NyaXB0aW9uOiB7IHR5cGU6IG9wLCBtdXRhYmlsaXR5OiBfbm9ybWFsaXplTXV0 YWJpbGl0eShtdXRhYmlsaXR5KSB9LCBtb2R1bGUsIGZpZWxkLCBraW5kOiAiR2xvYmFsIiB9KTsK LSAgICAgICAgICAgICAgICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsKKyAgICAgICAgICAgICAgICBy ZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICAgICAgICAg IH07CiAgICAgICAgIH0KLSAgICAgICAgcmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgIHJl dHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwogICAgIH07CiB9Owog CkBAIC0zMjQsMTEgKzMzNCwxMSBAQCBjb25zdCBfY3JlYXRlRnVuY3Rpb25CdWlsZGVyID0gKGZ1 bmMsIGJ1aWxkZXIsIHByZXZpb3VzQnVpbGRlcikgPT4gewogICAgICAgICAgICAgZGVmYXVsdDoK ICAgICAgICAgICAgICAgICBuZXh0QnVpbGRlciA9IGZ1bmN0aW9uQnVpbGRlcjsKICAgICAgICAg ICAgICAgICBicmVhazsKLSAgICAgICAgICAgICAgICBjYXNlICJFbmQiOgorICAgICAgICAgICAg Y2FzZSAiRW5kIjoKICAgICAgICAgICAgICAgICBuZXh0QnVpbGRlciA9IHByZXZpb3VzQnVpbGRl cjsKLSAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgYnJlYWs7CiAg ICAgICAgICAgICBjYXNlICJCbG9jayI6Ci0gICAgICAgICAgICAgICAgY2FzZSAiTG9vcCI6Cisg ICAgICAgICAgICBjYXNlICJMb29wIjoKICAgICAgICAgICAgIGNhc2UgIklmIjoKICAgICAgICAg ICAgICAgICBuZXh0QnVpbGRlciA9IF9jcmVhdGVGdW5jdGlvbkJ1aWxkZXIoZnVuYywgYnVpbGRl ciwgZnVuY3Rpb25CdWlsZGVyKTsKICAgICAgICAgICAgICAgICBicmVhazsKQEAgLTM0NCwxMSAr MzU0LDEyIEBAIGNvbnN0IF9jcmVhdGVGdW5jdGlvbkJ1aWxkZXIgPSAoZnVuYywgYnVpbGRlciwg cHJldmlvdXNCdWlsZGVyKSA9PiB7CiAgICAgICAgICAgICBjb25zdCBzdGFja0FyZ3MgPSBbXTsg Ly8gRklYTUUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MjcwNgog ICAgICAgICAgICAgZnVuYy5jb2RlLnB1c2goeyBuYW1lOiBvcCwgdmFsdWU6IHZhbHVlLCBhcmd1 bWVudHM6IHN0YWNrQXJncywgaW1tZWRpYXRlczogaW1tcyB9KTsKICAgICAgICAgICAgIGlmICho YXNDb250aW51YXRpb24pCi0gICAgICAgICAgICAgICAgcmV0dXJuIGNvbnRpbnVhdGlvbihuZXh0 QnVpbGRlcikuRW5kKCk7Ci0gICAgICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAg ICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoY29udGludWF0aW9uKG5leHRC dWlsZGVyKS5FbmQoKSk7CisgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZv cihuZXh0QnVpbGRlcik7CiAgICAgICAgIH07Ci0gICAgfQotICAgIHJldHVybiBmdW5jdGlvbkJ1 aWxkZXI7CisgICAgfTsKKworICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGZ1bmN0 aW9uQnVpbGRlcik7CiB9CiAKIGNvbnN0IF9jcmVhdGVGdW5jdGlvbiA9IChzZWN0aW9uLCBidWls ZGVyLCBwcmV2aW91c0J1aWxkZXIpID0+IHsKQEAgLTQ0OSwxMCArNDYwLDEwIEBAIGV4cG9ydCBk ZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRnVuYzogKHBh cmFtcywgcmV0KSA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW3BhcmFtcywgcmV0 XSA9IF9ub3JtYWxpemVGdW5jdGlvblNpZ25hdHVyZShwYXJhbXMsIHJldCk7CiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgcy5kYXRhLnB1c2goeyBwYXJhbXM6IHBhcmFtcywgcmV0OiByZXQg fSk7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHR5cGVCdWlsZGVyOworICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHR5 cGVCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH0sCiAgICAgICAgICAgICAgICAg ICAgIH07Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiB0eXBlQnVpbGRlcjsKKyAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IodHlwZUJ1aWxkZXIpOwog ICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTQ2Niw3ICs0 NzcsNyBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAg ICAgaW1wb3J0QnVpbGRlci5GdW5jdGlvbiA9IF9pbXBvcnRGdW5jdGlvbkNvbnRpbnVhdGlvbih0 aGlzLCBzLCBpbXBvcnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgaW1wb3J0QnVpbGRl ci5NZW1vcnkgPSBfaW1wb3J0TWVtb3J5Q29udGludWF0aW9uKHRoaXMsIHMsIGltcG9ydEJ1aWxk ZXIpOwogICAgICAgICAgICAgICAgICAgICBpbXBvcnRCdWlsZGVyLlRhYmxlID0gX2ltcG9ydFRh YmxlQ29udGludWF0aW9uKHRoaXMsIHMsIGltcG9ydEJ1aWxkZXIpOwotICAgICAgICAgICAgICAg ICAgICByZXR1cm4gaW1wb3J0QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9l cnJvckhhbmRsaW5nUHJveHlGb3IoaW1wb3J0QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsK ICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNDc3LDcgKzQ4OCw3IEBAIGV4cG9ydCBkZWZh dWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRW5kOiAoKSA9PiB0 aGlzCiAgICAgICAgICAgICAgICAgICAgICAgICAvLyBGSVhNRTogYWRkIGFiaWxpdHkgdG8gYWRk IHRoaXMgd2l0aCB3aGF0ZXZlci4KICAgICAgICAgICAgICAgICAgICAgfTsKLSAgICAgICAgICAg ICAgICAgICAgcmV0dXJuIGZ1bmN0aW9uQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0 dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZnVuY3Rpb25CdWlsZGVyKTsKICAgICAgICAgICAg ICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC00ODgsMTAgKzQ5OSwxMCBAQCBl eHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgIEVu ZDogKCkgPT4gdGhpcywKICAgICAgICAgICAgICAgICAgICAgICAgIFRhYmxlOiAoe2luaXRpYWws IG1heGltdW0sIGVsZW1lbnR9KSA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcy5k YXRhLnB1c2goe3RhYmxlRGVzY3JpcHRpb246IHtpbml0aWFsLCBtYXhpbXVtLCBlbGVtZW50fX0p OwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiB0YWJsZUJ1aWxkZXI7CisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IodGFi bGVCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAg ICAgfTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHRhYmxlQnVpbGRlcjsKKyAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IodGFibGVCdWlsZGVyKTsK ICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC01MDIsMTAg KzUxMywxMCBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAg ICAgICAgICAgIEVuZDogKCkgPT4gdGhpcywKICAgICAgICAgICAgICAgICAgICAgICAgIEluaXRp YWxNYXhQYWdlczogKGluaXRpYWwsIG1heCkgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHMuZGF0YS5wdXNoKHsgaW5pdGlhbCwgbWF4IH0pOwotICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHJldHVybiBtZW1vcnlCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAg IHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG1lbW9yeUJ1aWxkZXIpOwogICAgICAgICAg ICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAgICAgICAg ICAgICByZXR1cm4gbWVtb3J5QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9l cnJvckhhbmRsaW5nUHJveHlGb3IobWVtb3J5QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsK ICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNTE2LDE2ICs1MjcsMTYgQEAgZXhwb3J0IGRl ZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBFbmQ6ICgpID0+ IHRoaXMsCiAgICAgICAgICAgICAgICAgICAgICAgICBHZXRHbG9iYWw6ICh0eXBlLCBpbml0VmFs dWUsIG11dGFiaWxpdHkpID0+IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRhdGEu cHVzaCh7IHR5cGUsIG9wOiAiZ2V0X2dsb2JhbCIsIG11dGFiaWxpdHk6IF9ub3JtYWxpemVNdXRh YmlsaXR5KG11dGFiaWxpdHkpLCBpbml0VmFsdWUgfSk7Ci0gICAgICAgICAgICAgICAgICAgICAg ICAgICAgcmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAg cmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7CiAgICAgICAgICAg ICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAg ICAgIGZvciAobGV0IG9wIG9mIFdBU00uZGVzY3JpcHRpb24udmFsdWVfdHlwZSkgewogICAgICAg ICAgICAgICAgICAgICAgICAgZ2xvYmFsQnVpbGRlcltfdG9KYXZhU2NyaXB0TmFtZShvcCldID0g KGluaXRWYWx1ZSwgbXV0YWJpbGl0eSkgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAg IHMuZGF0YS5wdXNoKHsgdHlwZTogb3AsIG9wOiBvcCArICIuY29uc3QiLCBtdXRhYmlsaXR5OiBf bm9ybWFsaXplTXV0YWJpbGl0eShtdXRhYmlsaXR5KSwgaW5pdFZhbHVlIH0pOwotICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHJldHVybiBnbG9iYWxCdWlsZGVyOworICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIp OwogICAgICAgICAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICAgICAgfQotICAg ICAgICAgICAgICAgICAgICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAg ICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7CiAgICAgICAg ICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNTM5LDcgKzU1MCw3IEBA IGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICBleHBv cnRCdWlsZGVyLkZ1bmN0aW9uID0gX2V4cG9ydEZ1bmN0aW9uQ29udGludWF0aW9uKHRoaXMsIHMs IGV4cG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICBleHBvcnRCdWlsZGVyLk1lbW9y eSA9IF9leHBvcnRNZW1vcnlDb250aW51YXRpb24odGhpcywgcywgZXhwb3J0QnVpbGRlcik7CiAg ICAgICAgICAgICAgICAgICAgIGV4cG9ydEJ1aWxkZXIuVGFibGUgPSBfZXhwb3J0VGFibGVDb250 aW51YXRpb24odGhpcywgcywgZXhwb3J0QnVpbGRlcik7Ci0gICAgICAgICAgICAgICAgICAgIHJl dHVybiBleHBvcnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFu ZGxpbmdQcm94eUZvcihleHBvcnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAg ICAgICAgICAgIGJyZWFrOwogCkBAIC01NTIsNyArNTYzLDcgQEAgZXhwb3J0IGRlZmF1bHQgY2xh c3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgIGlmICh0eXBlb2YoZnVuY3Rpb25JbmRl eE9yTmFtZSkgIT09ICJudW1iZXIiICYmIHR5cGVvZihmdW5jdGlvbkluZGV4T3JOYW1lKSAhPT0g InN0cmluZyIpCiAgICAgICAgICAgICAgICAgICAgICAgICB0aHJvdyBuZXcgRXJyb3IoYFN0YXJ0 IHNlY3Rpb24ncyBmdW5jdGlvbiBpbmRleCAgbXVzdCBlaXRoZXIgYmUgYSBudW1iZXIgb3IgYSBz dHJpbmdgKTsKICAgICAgICAgICAgICAgICAgICAgcy5kYXRhLnB1c2goZnVuY3Rpb25JbmRleE9y TmFtZSk7Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiBzdGFydEJ1aWxkZXI7CisgICAgICAg ICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHN0YXJ0QnVpbGRlcik7 CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNTYzLDEx ICs1NzQsMTEgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAg ICAgICAgICAgICBFbmQ6ICgpID0+IHRoaXMsCiAgICAgICAgICAgICAgICAgICAgICAgICBFbGVt ZW50OiAoe3RhYmxlSW5kZXggPSAwLCBvZmZzZXQsIGZ1bmN0aW9uSW5kaWNlc30pID0+IHsKICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaCh7dGFibGVJbmRleCwgb2Zmc2V0 LCBmdW5jdGlvbkluZGljZXN9KTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4g ZWxlbWVudEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJv ckhhbmRsaW5nUHJveHlGb3IoZWxlbWVudEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAg ICAgfQogICAgICAgICAgICAgICAgICAgICB9OwogCi0gICAgICAgICAgICAgICAgICAgIHJldHVy biBlbGVtZW50QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRs aW5nUHJveHlGb3IoZWxlbWVudEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAg ICAgICAgICAgYnJlYWs7CiAKQEAgLTYzMiwxMiArNjQzLDEyIEBAIGV4cG9ydCBkZWZhdWx0IGNs YXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gRklY TUUgaW4gY2hlY2tlZCBtb2RlLCB0ZXN0IHRoYXQgdGhlIHR5cGUgaXMgYWNjZXB0YWJsZSBmb3Ig c3RhcnQgZnVuY3Rpb24uIFdlIHByb2JhYmx5IHdhbnQgX3JlZ2lzdGVyRnVuY3Rpb25Ub0luZGV4 U3BhY2UgdG8gYWxzbyByZWdpc3RlciB0eXBlcyBwZXIgaW5kZXguIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjU2NTgKICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgfQogICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICByZXR1cm4gYnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihidWlsZGVyKTsKICAgICAgICAgICAgICAgICAg ICAgICAgIH0sCiAKICAgICAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICAgICAg Y29kZUJ1aWxkZXIuRnVuY3Rpb24gPSBfY3JlYXRlRnVuY3Rpb24ocywgYnVpbGRlciwgY29kZUJ1 aWxkZXIpOwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gY29kZUJ1aWxkZXI7CisgICAgICAg ICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGNvZGVCdWlsZGVyKTsK ICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC02NjAsMTkg KzY3MSwxOSBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgSW5kZXg6IGluZGV4ID0+IHsKICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGFzc2VydC5lcShpbmRleCwgMCk7IC8vIExpbmVhciBtZW1vcnkgaW5k ZXggbXVzdCBiZSB6ZXJvIGluIE1WUC4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHRoaXNTZWdtZW50LmluZGV4ID0gaW5kZXg7Ci0gICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICByZXR1cm4gc2VnbWVudEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihzZWdtZW50QnVpbGRl cik7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0sCiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIE9mZnNldDogb2Zmc2V0ID0+IHsKICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIC8vIEZJWE1FIGFsbG93IGNvbXBsZXggaW5pdF9leHByIGhlcmUuIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjU3MDAKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGFzc2VydC5pc051bWJlcihvZmZzZXQpOwogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGhpc1NlZ21lbnQub2Zmc2V0ID0gb2Zmc2V0 OwotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHNlZ21lbnRCdWls ZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhh bmRsaW5nUHJveHlGb3Ioc2VnbWVudEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAgICAgICAgICAg ICAgICAgICAgICAgICAgcmV0dXJuIHNlZ21lbnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHNlZ21lbnRCdWlsZGVyKTsK ICAgICAgICAgICAgICAgICAgICAgICAgIH0sCiAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAg ICAgICAgICAgICAgICAgIHJldHVybiBkYXRhQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAg cmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZGF0YUJ1aWxkZXIpOwogICAgICAgICAgICAg ICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTY5MCwxMCArNzAxLDEwIEBAIGV4 cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgIEJ5dGU6IGIgPT4g ewogICAgICAgICAgICAgICAgICAgICBhc3NlcnQuZXEoYiAmIDB4RkYsIGIsIGBVbmtub3duIHNl Y3Rpb24gZXhwZWN0ZWQgYnl0ZSwgZ290OiAiJHtifSJgKTsKICAgICAgICAgICAgICAgICAgICAg cy5kYXRhLnB1c2goYik7Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiB1bmtub3duQnVpbGRl cjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IodW5r bm93bkJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgIH07Ci0gICAgICAg ICAgICByZXR1cm4gdW5rbm93bkJ1aWxkZXI7CisgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFu ZGxpbmdQcm94eUZvcih1bmtub3duQnVpbGRlcik7CiAgICAgICAgIH07CiAgICAgfQogICAgIF9h ZGRTZWN0aW9uKG5hbWVPck51bWJlciwgZXh0cmFPYmplY3QpIHsKZGlmZiAtLWdpdCBhL0pTVGVz dHMvd2FzbS9Mb3dMZXZlbEJpbmFyeS5qcyBiL0pTVGVzdHMvd2FzbS9Mb3dMZXZlbEJpbmFyeS5q cwppbmRleCA2MTFhMjZkLi5mOWJjOGEzIDEwMDY0NAotLS0gYS9KU1Rlc3RzL3dhc20vTG93TGV2 ZWxCaW5hcnkuanMKKysrIGIvSlNUZXN0cy93YXNtL0xvd0xldmVsQmluYXJ5LmpzCkBAIC0xNzAs NiArMTcwLDE4IEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIExvd0xldmVsQmluYXJ5IHsKICAgICAg ICAgICAgIHRoaXMudWludDgoMHg4MCB8IGIpOwogICAgICAgICB9IHdoaWxlICh0cnVlKTsKICAg ICB9CisgICAgdmFydWludDY0KHYpIHsKKyAgICAgICAgYXNzZXJ0LmlzTnVtYmVyKHYpOworICAg ICAgICBpZiAodiA8IHZhcnVpbnQzMk1pbiB8fCB2YXJ1aW50MzJNYXggPCB2KQorICAgICAgICAg ICAgdGhyb3cgbmV3IFJhbmdlRXJyb3IoYHVuaW1wbGVtZW50ZWQ6IHZhcnVpbnQ2NCBsYXJnZXIg dGhhbiAzMi1iaXRgKTsKKyAgICAgICAgdGhpcy52YXJ1aW50MzIodik7IC8vIEZJWE1FIGltcGxl bWVudCA2NC1iaXQgdmFye3V9aW50IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xNjM0MjAKKyAgICB9CisgICAgdmFyaW50NjQodikgeworICAgICAgICBhc3NlcnQuaXNO dW1iZXIodik7CisgICAgICAgIGlmICh2IDwgdmFyaW50MzJNaW4gfHwgdmFyaW50MzJNYXggPCB2 KQorICAgICAgICAgICAgdGhyb3cgbmV3IFJhbmdlRXJyb3IoYHVuaW1wbGVtZW50ZWQ6IHZhcmlu dDY0IGxhcmdlciB0aGFuIDMyLWJpdGApOworICAgICAgICB0aGlzLnZhcmludDMyKHYpOyAvLyBG SVhNRSBpbXBsZW1lbnQgNjQtYml0IHZhcnt1fWludCBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTYzNDIwCisgICAgfQogICAgIHZhcnVpbnQxKHYpIHsKICAgICAgICAg aWYgKHYgIT09IDAgJiYgdiAhPT0gMSkKICAgICAgICAgICAgIHRocm93IG5ldyBSYW5nZUVycm9y KGBJbnZhbGlkIHZhcnVpbnQxICR7dn0gcmFuZ2UgaXMgWzAsIDFdYCk7CmRpZmYgLS1naXQgYS9K U1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvZXhjZXB0aW9ucy5qcyBiL0pTVGVzdHMvd2FzbS9m dW5jdGlvbi10ZXN0cy9leGNlcHRpb25zLmpzCmluZGV4IGQyYjNhNDkuLjk1MjUxM2YgMTAwNjQ0 Ci0tLSBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy9leGNlcHRpb25zLmpzCisrKyBiL0pT VGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy9leGNlcHRpb25zLmpzCkBAIC00NSwxOCArNDUsMTgg QEAgZnVuY3Rpb24gbWFrZUluc3RhbmNlKCkgewogICAgIGFzc2VydC5lcSh0YWJsZS5nZXQoMCks IG51bGwpOwogCiAgICAgZm9yIChsZXQgaSA9IDA7IGkgPCAxMDAwOyBpKyspIHsKLSAgICAgICAg YXNzZXJ0LnRocm93cygoKSA9PiBmb28oMCwgaSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwg ImNhbGxfaW5kaXJlY3QgdG8gYSBudWxsIHRhYmxlIGVudHJ5IChldmFsdWF0aW5nICdmdW5jKC4u LmFyZ3MpJykiKTsKKyAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBmb28oMCwgaSksIFdlYkFz c2VtYmx5LlJ1bnRpbWVFcnJvciwgImNhbGxfaW5kaXJlY3QgdG8gYSBudWxsIHRhYmxlIGVudHJ5 Iik7CiAgICAgfQogCiAgICAgdGFibGUuc2V0KDAsIGZvbyk7CiAgICAgYXNzZXJ0LmVxKHRhYmxl LmdldCgwKSwgZm9vKTsKIAogICAgIGZvciAobGV0IGkgPSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0g ICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDEgKyBpLCBpKSwgV2ViQXNzZW1ibHkuUnVu dGltZUVycm9yLCAiT3V0IG9mIGJvdW5kcyBjYWxsX2luZGlyZWN0IChldmFsdWF0aW5nICdmdW5j KC4uLmFyZ3MpJykiKTsKKyAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBmb28oMSArIGksIGkp LCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJPdXQgb2YgYm91bmRzIGNhbGxfaW5kaXJlY3Qi KTsKICAgICB9CiAKICAgICBmb3IgKGxldCBpID0gMDsgaSA8IDEwMDA7IGkrKykgewotICAgICAg ICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbygwLCBpKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9y LCAiY2FsbF9pbmRpcmVjdCB0byBhIHNpZ25hdHVyZSB0aGF0IGRvZXMgbm90IG1hdGNoIChldmFs dWF0aW5nICdmdW5jKC4uLmFyZ3MpJykiKTsKKyAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBm b28oMCwgaSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgImNhbGxfaW5kaXJlY3QgdG8gYSBz aWduYXR1cmUgdGhhdCBkb2VzIG5vdCBtYXRjaCIpOwogICAgIH0KIAogICAgIHRhYmxlLnNldCgw LCBiYXIpOwpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtbG9h ZC5qcyBiL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMKaW5kZXggNGRk ODJkYy4uMTIzMWUwMyAxMDA2NDQKLS0tIGEvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3Ry YXAtbG9hZC5qcworKysgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpz CkBAIC0yOSw2ICsyOSw2IEBAIGZ1bmN0aW9uIHdhc21GcmFtZUNvdW50RnJvbUVycm9yKGUpIHsK IH0KIAogZm9yIChsZXQgaSA9IDA7IGkgPCAxMDAwOyBpKyspIHsKLSAgICBjb25zdCBlID0gYXNz ZXJ0LnRocm93cygoKSA9PiBmb28obnVtUGFnZXMgKiBwYWdlU2l6ZSArIDEpLCBXZWJBc3NlbWJs eS5SdW50aW1lRXJyb3IsICJPdXQgb2YgYm91bmRzIG1lbW9yeSBhY2Nlc3MgKGV2YWx1YXRpbmcg J2Z1bmMoLi4uYXJncyknKSIpOworICAgIGNvbnN0IGUgPSBhc3NlcnQudGhyb3dzKCgpID0+IGZv byhudW1QYWdlcyAqIHBhZ2VTaXplICsgMSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgIk91 dCBvZiBib3VuZHMgbWVtb3J5IGFjY2VzcyIpOwogICAgIGFzc2VydC5lcSh3YXNtRnJhbWVDb3Vu dEZyb21FcnJvcihlKSwgMik7CiB9CmRpZmYgLS1naXQgYS9KU1Rlc3RzL3dhc20vZnVuY3Rpb24t dGVzdHMvdHJhcC1zdG9yZS5qcyBiL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLXN0 b3JlLmpzCmluZGV4IDU1OTg3YzIuLjM2NTcxM2EgMTAwNjQ0Ci0tLSBhL0pTVGVzdHMvd2FzbS9m dW5jdGlvbi10ZXN0cy90cmFwLXN0b3JlLmpzCisrKyBiL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10 ZXN0cy90cmFwLXN0b3JlLmpzCkBAIC0yNSw1ICsyNSw1IEBAIGNvbnN0IG51bVBhZ2VzID0gMTA7 CiAgICAgY29uc3QgZm9vID0gbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKG1vZHVsZSwge2E6IHti OiBuZXcgV2ViQXNzZW1ibHkuTWVtb3J5KHtpbml0aWFsOiBudW1QYWdlc30pfX0pLmV4cG9ydHMu Zm9vOwogCiAgICAgZm9yIChsZXQgaSA9IDA7IGkgPCAxMDAwMDsgaSsrKQotICAgICAgICBhc3Nl cnQudGhyb3dzKCgpID0+IGZvbyhpLCBudW1QYWdlcyAqIHBhZ2VTaXplICsgMSksIFdlYkFzc2Vt Ymx5LlJ1bnRpbWVFcnJvciwgIk91dCBvZiBib3VuZHMgbWVtb3J5IGFjY2VzcyAoZXZhbHVhdGlu ZyAnZnVuYyguLi5hcmdzKScpIik7CisgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKGks IG51bVBhZ2VzICogcGFnZVNpemUgKyAxKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9yLCAiT3V0 IG9mIGJvdW5kcyBtZW1vcnkgYWNjZXNzIik7CiB9CmRpZmYgLS1naXQgYS9KU1Rlc3RzL3dhc20v anMtYXBpL3dhc20tdG8td2FzbS1iYWQtc2lnbmF0dXJlLmpzIGIvSlNUZXN0cy93YXNtL2pzLWFw aS93YXNtLXRvLXdhc20tYmFkLXNpZ25hdHVyZS5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwLi5kNjliYTJjCi0tLSAvZGV2L251bGwKKysrIGIvSlNUZXN0cy93YXNtL2pzLWFw aS93YXNtLXRvLXdhc20tYmFkLXNpZ25hdHVyZS5qcwpAQCAtMCwwICsxLDEwNSBAQAoraW1wb3J0 ICogYXMgYXNzZXJ0IGZyb20gJy4uL2Fzc2VydC5qcyc7CitpbXBvcnQgQnVpbGRlciBmcm9tICcu Li9CdWlsZGVyLmpzJzsKKworY29uc3QgaW1wb3J0TmFtZSA9ICJwaWVyT25lIjsKK2NvbnN0IHR5 cGVzID0gWyJpMzIiLCAiaTY0IiwgImYzMiIsICJmNjQiLCAidm9pZCJdOworY29uc3QgdHlwZXNO b25Wb2lkID0gWyJpMzIiLCAiaTY0IiwgImYzMiIsICJmNjQiXTsKK2NvbnN0IHN3YXBUeXBlID0g KHR5cGUsIGluZGV4KSA9PiB0eXBlc1sodHlwZXMuaW5kZXhPZih0eXBlKSArIGluZGV4KSAlIHR5 cGVzLmxlbmd0aF07Citjb25zdCBzd2FwVHlwZU5vblZvaWQgPSAodHlwZSwgaW5kZXgpID0+IHR5 cGVzTm9uVm9pZFsodHlwZXNOb25Wb2lkLmluZGV4T2YodHlwZSkgKyBpbmRleCkgJSB0eXBlc05v blZvaWQubGVuZ3RoXTsKKworY29uc3Qgc2lnbmF0dXJlcyA9IFsKKyAgICB7IHBhcmFtczogWyJp MzIiXSwgcmV0OiAidm9pZCIgfSwKKyAgICB7IHBhcmFtczogWyJpNjQiXSwgcmV0OiAidm9pZCIg fSwKKyAgICB7IHBhcmFtczogWyJmMzIiXSwgcmV0OiAidm9pZCIgfSwKKyAgICB7IHBhcmFtczog WyJmNjQiXSwgcmV0OiAidm9pZCIgfSwKKyAgICB7IHBhcmFtczogWyJpMzIiXSwgcmV0OiAiaTMy IiB9LAorICAgIHsgcGFyYW1zOiBbImk2NCJdLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6 IFsiZjMyIl0sIHJldDogImYzMiIgfSwKKyAgICB7IHBhcmFtczogWyJmNjQiXSwgcmV0OiAiZjY0 IiB9LAorICAgIHsgcGFyYW1zOiBbImkzMiIsICJmMzIiXSwgcmV0OiAiaTMyIiB9LAorICAgIHsg cGFyYW1zOiBbImYzMiIsICJpMzIiXSwgcmV0OiAiaTMyIiB9LAorICAgIHsgcGFyYW1zOiBbImk2 NCIsICJmNjQiXSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBbImY2NCIsICJpNjQiXSwg cmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBbImkzMiIsICJmMzIiLCAiaTMyIl0sIHJldDog ImkzMiIgfSwKKyAgICB7IHBhcmFtczogWyJpMzIiLCAiZjMyIiwgImkzMiJdLCByZXQ6ICJpMzIi IH0sCisgICAgeyBwYXJhbXM6IFsiaTY0IiwgImY2NCIsICJpNjQiXSwgcmV0OiAiaTY0IiB9LAor ICAgIHsgcGFyYW1zOiBbImk2NCIsICJmNjQiLCAiaTY0Il0sIHJldDogImk2NCIgfSwKKyAgICB7 IHBhcmFtczogQXJyYXkoMzIpLmZpbGwoImkzMiIpLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJh bXM6IEFycmF5KDMyKS5maWxsKCJpNjQiKSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBB cnJheSgzMikuZmlsbCgiZjMyIiksIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogQXJyYXko MzIpLmZpbGwoImY2NCIpLCByZXQ6ICJpNjQiIH0sCitdOworCitjb25zdCBtYWtlSW1wb3J0ZXIg PSBzaWduYXR1cmUgPT4geworICAgIGNvbnN0IGJ1aWxkZXIgPSAobmV3IEJ1aWxkZXIoKSkKKyAg ICAgICAgLlR5cGUoKS5FbmQoKQorICAgICAgICAuSW1wb3J0KCkuRnVuY3Rpb24oImV4cG9ydHMi LCBpbXBvcnROYW1lLCBzaWduYXR1cmUpLkVuZCgpOworICAgIHJldHVybiBuZXcgV2ViQXNzZW1i bHkuTW9kdWxlKGJ1aWxkZXIuV2ViQXNzZW1ibHkoKS5nZXQoKSk7Cit9OworCitjb25zdCBtYWtl SW1wb3J0ZWUgPSBzaWduYXR1cmUgPT4geworICAgIGNvbnN0IGJ1aWxkZXIgPSAobmV3IEJ1aWxk ZXIoKSkKKyAgICAgICAgLlR5cGUoKS5FbmQoKQorICAgICAgICAuRnVuY3Rpb24oKS5FbmQoKQor ICAgICAgICAuRXhwb3J0KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbihpbXBvcnROYW1lKQorICAg ICAgICAuRW5kKCkKKyAgICAgICAgLkNvZGUoKQorICAgICAgICAgICAgLkZ1bmN0aW9uKGltcG9y dE5hbWUsIHNpZ25hdHVyZSk7CisgICAgc3dpdGNoIChzaWduYXR1cmUucmV0KSB7CisgICAgY2Fz ZSAiaTMyIjogYnVpbGRlci5JMzJDb25zdCgwKTsgYnJlYWs7CisgICAgY2FzZSAiaTY0IjogYnVp bGRlci5JNjRDb25zdCgwKTsgYnJlYWs7CisgICAgY2FzZSAiZjMyIjogYnVpbGRlci5GMzJDb25z dCgwKTsgYnJlYWs7CisgICAgY2FzZSAiZjY0IjogYnVpbGRlci5GNjRDb25zdCgwKTsgYnJlYWs7 CisgICAgY2FzZSAidm9pZCI6IGJyZWFrOworICAgIH0KKyAgICByZXR1cm4gbmV3IFdlYkFzc2Vt Ymx5Lkluc3RhbmNlKG5ldyBXZWJBc3NlbWJseS5Nb2R1bGUoYnVpbGRlci5SZXR1cm4oKS5FbmQo KS5FbmQoKS5XZWJBc3NlbWJseSgpLmdldCgpKSk7Cit9OworCisoZnVuY3Rpb24gQmFkU2lnbmF0 dXJlRHJvcFN0YXJ0UGFyYW1zKCkgeworICAgIGZvciAobGV0IHNpZ25hdHVyZSBvZiBzaWduYXR1 cmVzKSB7CisgICAgICAgIGNvbnN0IGltcG9ydGVlID0gbWFrZUltcG9ydGVlKHNpZ25hdHVyZSk7 CisgICAgICAgIGZvciAobGV0IGkgPSAxOyBpIDw9IHNpZ25hdHVyZS5wYXJhbXMubGVuZ3RoOyAr K2kpIHsKKyAgICAgICAgICAgIGNvbnN0IGJhZFBhcmFtU2lnbmF0dXJlID0geyBwYXJhbXM6IHNp Z25hdHVyZS5wYXJhbXMuc2xpY2UoaSwgc2lnbmF0dXJlLnBhcmFtcy5sZW5ndGgpLCByZXQ6IHNp Z25hdHVyZS5yZXQgfTsKKyAgICAgICAgICAgIGNvbnN0IGltcG9ydGVyID0gbWFrZUltcG9ydGVy KGJhZFBhcmFtU2lnbmF0dXJlKTsKKyAgICAgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gbmV3 IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSksIFdlYkFzc2VtYmx5Lkxp bmtFcnJvciwgYGltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIGRvZXNuJ3QgbWF0Y2ggdGhl IHByb3ZpZGVkIFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIChldmFsdWF0aW5nICdu ZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKScpYCk7CisgICAgICAg IH0KKyAgICB9Cit9KSgpOworCisoZnVuY3Rpb24gQmFkU2lnbmF0dXJlRHJvcEVuZFBhcmFtcygp IHsKKyAgICBmb3IgKGxldCBzaWduYXR1cmUgb2Ygc2lnbmF0dXJlcykgeworICAgICAgICBjb25z dCBpbXBvcnRlZSA9IG1ha2VJbXBvcnRlZShzaWduYXR1cmUpOworICAgICAgICBmb3IgKGxldCBp ID0gMTsgaSA8IHNpZ25hdHVyZS5wYXJhbXMubGVuZ3RoOyArK2kpIHsKKyAgICAgICAgICAgIGNv bnN0IGJhZFBhcmFtU2lnbmF0dXJlID0geyBwYXJhbXM6IHNpZ25hdHVyZS5wYXJhbXMuc2xpY2Uo MCwgaSksIHJldDogc2lnbmF0dXJlLnJldCB9OworICAgICAgICAgICAgY29uc3QgaW1wb3J0ZXIg PSBtYWtlSW1wb3J0ZXIoYmFkUGFyYW1TaWduYXR1cmUpOworICAgICAgICAgICAgYXNzZXJ0LnRo cm93cygoKSA9PiBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKSwg V2ViQXNzZW1ibHkuTGlua0Vycm9yLCBgaW1wb3J0ZWQgZnVuY3Rpb24ncyBzaWduYXR1cmUgZG9l c24ndCBtYXRjaCB0aGUgcHJvdmlkZWQgV2ViQXNzZW1ibHkgZnVuY3Rpb24ncyBzaWduYXR1cmUg KGV2YWx1YXRpbmcgJ25ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUp JylgKTsKKyAgICAgICAgfQorICAgIH0KK30pKCk7CisKKyhmdW5jdGlvbiBCYWRTaWduYXR1cmVT d2FwUGFyYW0oKSB7CisgICAgZm9yIChsZXQgc2lnbmF0dXJlIG9mIHNpZ25hdHVyZXMpIHsKKyAg ICAgICAgY29uc3QgaW1wb3J0ZWUgPSBtYWtlSW1wb3J0ZWUoc2lnbmF0dXJlKTsKKyAgICAgICAg Zm9yIChsZXQgc2lnbmF0dXJlSW5kZXggPSAwOyBzaWduYXR1cmVJbmRleCA8IHNpZ25hdHVyZS5s ZW5ndGg7ICsrc2lnbmF0dXJlSW5kZXgpIHsKKyAgICAgICAgICAgIGZvciAobGV0IHR5cGVJbmRl eCA9IDE7IHR5cGVJbmRleCA8IHR5cGVzTm9uVm9pZC5sZW5ndGg7ICsrdHlwZUluZGV4KSB7Cisg ICAgICAgICAgICAgICAgbGV0IGJhZFBhcmFtcyA9IHNpZ25hdHVyZS5wYXJhbXMuc2xpY2UoKTsK KyAgICAgICAgICAgICAgICBiYWRQYXJhbXNbc2lnbmF0dXJlSW5kZXhdID0gc3dhcFR5cGVOb25W b2lkKGJhZFBhcmFtc1tzaWduYXR1cmVJbmRleF0sIHR5cGVJbmRleCk7CisgICAgICAgICAgICAg ICAgY29uc3QgYmFkUGFyYW1TaWduYXR1cmUgPSB7IHBhcmFtczogYmFkUGFyYW1zLCByZXQ6IHNp Z25hdHVyZS5yZXQgfTsKKyAgICAgICAgICAgICAgICBjb25zdCBpbXBvcnRlciA9IG1ha2VJbXBv cnRlcihiYWRQYXJhbVNpZ25hdHVyZSk7CisgICAgICAgICAgICAgICAgYXNzZXJ0LnRocm93cygo KSA9PiBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKSwgV2ViQXNz ZW1ibHkuTGlua0Vycm9yLCBgaW1wb3J0ZWQgZnVuY3Rpb24ncyBzaWduYXR1cmUgZG9lc24ndCBt YXRjaCB0aGUgcHJvdmlkZWQgV2ViQXNzZW1ibHkgZnVuY3Rpb24ncyBzaWduYXR1cmUgKGV2YWx1 YXRpbmcgJ25ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpJylgKTsK KyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0KK30pKCk7CisKKyhmdW5jdGlvbiBCYWRT aWduYXR1cmVSZXQoKSB7CisgICAgZm9yIChsZXQgc2lnbmF0dXJlIG9mIHNpZ25hdHVyZXMpIHsK KyAgICAgICAgY29uc3QgaW1wb3J0ZWUgPSBtYWtlSW1wb3J0ZWUoc2lnbmF0dXJlKTsKKyAgICAg ICAgZm9yIChsZXQgdHlwZUluZGV4ID0gMTsgdHlwZUluZGV4IDwgdHlwZXMubGVuZ3RoOyArK3R5 cGVJbmRleCkgeworICAgICAgICAgICAgY29uc3QgYmFkUGFyYW1TaWduYXR1cmUgPSB7IHBhcmFt czogc2lnbmF0dXJlLnBhcmFtcywgcmV0OiBzd2FwVHlwZShzaWduYXR1cmUucmV0LCB0eXBlSW5k ZXgpIH07CisgICAgICAgICAgICBjb25zdCBpbXBvcnRlciA9IG1ha2VJbXBvcnRlcihiYWRQYXJh bVNpZ25hdHVyZSk7CisgICAgICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IG5ldyBXZWJBc3Nl bWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpLCBXZWJBc3NlbWJseS5MaW5rRXJyb3Is IGBpbXBvcnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBkb2Vzbid0IG1hdGNoIHRoZSBwcm92aWRl ZCBXZWJBc3NlbWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSAoZXZhbHVhdGluZyAnbmV3IFdlYkFz c2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSknKWApOworICAgICAgICB9CisgICAg fQorfSkoKTsKZGlmZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLmpz IGIvSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMC4uNTI0ZTQ1MwotLS0gL2Rldi9udWxsCisrKyBiL0pTVGVzdHMvd2Fz bS9qcy1hcGkvd2FzbS10by13YXNtLmpzCkBAIC0wLDAgKzEsNzIgQEAKK2ltcG9ydCAqIGFzIGFz c2VydCBmcm9tICcuLi9hc3NlcnQuanMnOworaW1wb3J0IEJ1aWxkZXIgZnJvbSAnLi4vQnVpbGRl ci5qcyc7CisKK2NvbnN0IGNhbGxlclRvcEJpdHMgPSAweEMwRkVCRUVGOworY29uc3QgaW5uZXJS ZXR1cm5IaSA9IDB4REVBREZBQ0U7Citjb25zdCBpbm5lclJldHVybkxvID0gMHhDMEZFQzBGRTsK KworY29uc3QgY2FsbGVyTW9kdWxlID0gKCkgPT4geworICAgIGNvbnN0IGJ1aWxkZXIgPSAobmV3 IEJ1aWxkZXIoKSkKKyAgICAgICAgLlR5cGUoKS5FbmQoKQorICAgICAgICAuSW1wb3J0KCkKKyAg ICAgICAgICAgIC5GdW5jdGlvbigiZXhwb3J0cyIsICJjYWxsTWUiLCB7IHBhcmFtczogWyJpNjQi XSwgcmV0OiAiaTY0IiB9KQorICAgICAgICAuRW5kKCkKKyAgICAgICAgLkZ1bmN0aW9uKCkuRW5k KCkKKyAgICAgICAgLkV4cG9ydCgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImVudHJ5IikKKyAg ICAgICAgLkVuZCgpCisgICAgICAgIC5Db2RlKCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigiZW50 cnkiLCB7IHBhcmFtczogWyJpMzIiXSwgcmV0OiAiaTMyIiB9LCBbImk2NCJdKQorICAgICAgICAg ICAgICAgIC5JMzJDb25zdChjYWxsZXJUb3BCaXRzKS5JNjRFeHRlbmRVSTMyKCkuSTMyQ29uc3Qo MzIpLkk2NEV4dGVuZFVJMzIoKS5JNjRTaGwoKSAvLyAoKGk2NCljYWxsZXJUb3BCaXRzKSA8PCAz MgorICAgICAgICAgICAgICAgIC5HZXRMb2NhbCgwKS5JNjRFeHRlbmRVSTMyKCkKKyAgICAgICAg ICAgICAgICAuSTY0T3IoKSAvLyB2YWx1ZTogcGFyYW0gfCAoKChpNjQpY2FsbGVyVG9wQml0cyA8 PCAzMikpCisgICAgICAgICAgICAgICAgLkNhbGwoMCkgLy8gQ2FsbHMgZXhwb3J0cy5jYWxsTWUo cGFyYW0gfCAoKChpNjQpY2FsbGVyVG9wQml0cykgPDwgMzIpKS4KKyAgICAgICAgICAgICAgICAu VGVlTG9jYWwoMSkuSTMyV3JhcEk2NCgpIC8vIGxvOiAoaTMyKWNhbGxSZXN1bHQKKyAgICAgICAg ICAgICAgICAuR2V0TG9jYWwoMSkuSTMyQ29uc3QoMzIpLkk2NEV4dGVuZFVJMzIoKS5JNjRTaHJV KCkuSTMyV3JhcEk2NCgpIC8vIGhpOiAoaTMyKShjYWxsUmVzdWx0ID4+IDMyKQorICAgICAgICAg ICAgICAgIC5JMzJYb3IoKQorICAgICAgICAgICAgICAgIC5SZXR1cm4oKQorICAgICAgICAgICAg LkVuZCgpCisgICAgICAgIC5FbmQoKTsKKyAgICByZXR1cm4gbmV3IFdlYkFzc2VtYmx5Lk1vZHVs ZShidWlsZGVyLldlYkFzc2VtYmx5KCkuZ2V0KCkpOworfTsKKworY29uc3QgY2FsbGVlTW9kdWxl ID0gKCkgPT4geworICAgIGNvbnN0IGJ1aWxkZXIgPSAobmV3IEJ1aWxkZXIoKSkKKyAgICAgICAg LlR5cGUoKS5FbmQoKQorICAgICAgICAuSW1wb3J0KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigi aW1wIiwgImZ1bmMiLCB7IHBhcmFtczogWyJpMzIiLCAiaTMyIl0sIHJldDogImkzMiIgfSkKKyAg ICAgICAgLkVuZCgpCisgICAgICAgIC5GdW5jdGlvbigpLkVuZCgpCisgICAgICAgIC5FeHBvcnQo KQorICAgICAgICAgICAgLkZ1bmN0aW9uKCJjYWxsTWUiKQorICAgICAgICAuRW5kKCkKKyAgICAg ICAgLkNvZGUoKQorICAgICAgICAgICAgLkZ1bmN0aW9uKCJjYWxsTWUiLCB7IHBhcmFtczogWyJp NjQiXSwgcmV0OiAiaTY0IiB9KQorICAgICAgICAgICAgICAgIC5HZXRMb2NhbCgwKS5JMzJXcmFw STY0KCkgLy8gbG86IChpMzIpcGFyYW0KKyAgICAgICAgICAgICAgICAuR2V0TG9jYWwoMCkuSTMy Q29uc3QoMzIpLkk2NEV4dGVuZFVJMzIoKS5JNjRTaHJVKCkuSTMyV3JhcEk2NCgpIC8vIGhpOiAo aTMyKShwYXJhbSA+PiAzMikKKyAgICAgICAgICAgICAgICAuQ2FsbCgwKSAvLyBDYWxscyBpbXAu ZnVuYyB3aXRoIHRoZSA2NC1iaXQgdmFsdWUgYXMgaTMyIHsgaGksIGxvIH0uCisgICAgICAgICAg ICAgICAgLkRyb3AoKQorICAgICAgICAgICAgICAgIC5JMzJDb25zdChpbm5lclJldHVybkhpKS5J NjRFeHRlbmRVSTMyKCkuSTMyQ29uc3QoMzIpLkk2NEV4dGVuZFVJMzIoKS5JNjRTaGwoKS5JMzJD b25zdChpbm5lclJldHVybkxvKS5JNjRFeHRlbmRVSTMyKCkuSTY0T3IoKSAvLyAoKGk2NCloaSA8 PCAzMikgfCAoaTY0KWxvCisgICAgICAgICAgICAgICAgLlJldHVybigpCisgICAgICAgICAgICAu RW5kKCkKKyAgICAgICAgLkVuZCgpOworICAgIHJldHVybiBuZXcgV2ViQXNzZW1ibHkuTW9kdWxl KGJ1aWxkZXIuV2ViQXNzZW1ibHkoKS5nZXQoKSk7Cit9OworCisoZnVuY3Rpb24gV2FzbVRvV2Fz bSgpIHsKKyAgICBsZXQgdmFsdWU7CisgICAgY29uc3QgZnVuYyA9IChoaSwgbG8pID0+IHsgdmFs dWUgPSB7IGhpOiBoaSwgbG86IGxvIH07IHByaW50KGAke0Vycm9yLnN0YWNrfWApOyByZXR1cm4g aGkgXiBsbzsgfTsKKyAgICBjb25zdCBjYWxsZWUgPSBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2Uo Y2FsbGVlTW9kdWxlKCksIHsgaW1wOiB7IGZ1bmM6IGZ1bmMgfSB9KTsKKyAgICBjb25zdCBjYWxs ZXIgPSBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoY2FsbGVyTW9kdWxlKCksIGNhbGxlZSk7Cisg ICAgZm9yIChsZXQgaSA9IDA7IGkgPCA0MDk2OyArK2kpIHsKKyAgICAgICAgYXNzZXJ0LmVxKGNh bGxlci5leHBvcnRzLmVudHJ5KGkpLCBpbm5lclJldHVybkhpIF4gaW5uZXJSZXR1cm5Mbyk7Cisg ICAgICAgIGFzc2VydC5lcSh2YWx1ZS5oaSwgY2FsbGVyVG9wQml0cyk7CisgICAgICAgIGFzc2Vy dC5lcSh2YWx1ZS5sbywgaSk7CisgICAgfQorfSkoKTsKKworCisvLyBGSVhNRTogdGVzdCB3YXNt LT53YXNtIHVzaW5nIDMyLWJpdCB0aGluZ3MgKGluY2x1ZGluZyBmbG9hdCksIGFzIHdlbGwgYXMg NjQtYml0IE5hTnMgdGhhdCBkb24ndCBnZXQgY2Fub25pY2FsaXplZAorLy8gRklYTUU6IGRvIGEg dGhyb3cgdHdvLWRlZXAKKy8vIEZJWE1FOiBjaGVjayB0aGF0IHRoZSBmaXJzdCB3YXNtJ3MgaW5z dGFuY2UgaXMgYmFjayBpbiBPSyBzdGF0ZSAod2l0aCB0YWJsZSBvciBnbG9iYWw/KQorLy8gRklY TUU6IHRlc3QgY2FsbGluZyB0aHJvdWdoIGEgVGFibGUKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS9DTWFrZUxpc3RzLnR4dCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DTWFrZUxp c3RzLnR4dAppbmRleCA5NjlhMTIzLi45ZGUxYTNhIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvQ01ha2VMaXN0cy50eHQKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NNYWtl TGlzdHMudHh0CkBAIC05MDUsNiArOTA1LDcgQEAgc2V0KEphdmFTY3JpcHRDb3JlX1NPVVJDRVMK ICAgICB3YXNtL1dhc21NZW1vcnkuY3BwCiAgICAgd2FzbS9XYXNtTWVtb3J5SW5mb3JtYXRpb24u Y3BwCiAgICAgd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmNwcAorICAgIHdhc20vV2FzbVBhZ2VDb3Vu dC5jcHAKICAgICB3YXNtL1dhc21QbGFuLmNwcAogICAgIHdhc20vV2FzbVNpZ25hdHVyZS5jcHAK ICAgICB3YXNtL1dhc21WYWxpZGF0ZS5jcHAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9KYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5k ZXggZDkzMjU2Yi4uMTE2MzY5ZSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0ph dmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTEy MzUsNiArMTIzNSw3IEBACiAJCTJBREZBMjYzMThFRjM1NDAwMDRGOUZDQyAvKiBHQ0xvZ2dpbmcu Y3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMkFERkEy NjIxOEVGMzU0MDAwNEY5RkNDIC8qIEdDTG9nZ2luZy5jcHAgKi87IH07CiAJCTJBRjczODJDMThC QkJGOTIwMDhBNUEzNyAvKiBTdHJ1Y3R1cmVJRFRhYmxlLmNwcCBpbiBTb3VyY2VzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDJBRjczODJBMThCQkJGOTIwMDhBNUEzNyAvKiBT dHJ1Y3R1cmVJRFRhYmxlLmNwcCAqLzsgfTsKIAkJMkFGNzM4MkQxOEJCQkY5MjAwOEE1QTM3IC8q IFN0cnVjdHVyZUlEVGFibGUuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDJBRjczODJCMThCQkJGOTIwMDhBNUEzNyAvKiBTdHJ1Y3R1cmVJRFRhYmxlLmgg Ki87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKKwkJMkQzNDJG MzZGNzI0NDA5NjgwNEFEQjI0IC8qIFNvdXJjZU9yaWdpbi5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDI1QkExMzM3RTQzNDRFMUIyNjlBNjcxIC8qIFNv dXJjZU9yaWdpbi5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07 IH07CiAJCTM3MUQ4NDJEMTdDOThCNkUwMEVDRjk5NCAvKiBsaWJ6LmR5bGliIGluIEZyYW1ld29y a3MgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMzcxRDg0MkMxN0M5OEI2RTAw RUNGOTk0IC8qIGxpYnouZHlsaWIgKi87IH07CiAJCTQxMjk1Mjc3MUQyQ0Y2QkMwMEU3OEI4OSAv KiBidWlsdGluc19nZW5lcmF0ZV9pbnRlcm5hbHNfd3JhcHBlcl9oZWFkZXIucHkgaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0MTI5NTI3MzFEMkNGNkFDMDBF NzhCODkgLyogYnVpbHRpbnNfZ2VuZXJhdGVfaW50ZXJuYWxzX3dyYXBwZXJfaGVhZGVyLnB5ICov OyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTQxMjk1Mjc4 MUQyQ0Y2QkMwMEU3OEI4OSAvKiBidWlsdGluc19nZW5lcmF0ZV9pbnRlcm5hbHNfd3JhcHBlcl9p bXBsZW1lbnRhdGlvbi5weSBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDQxMjk1Mjc0MUQyQ0Y2QUMwMEU3OEI4OSAvKiBidWlsdGluc19nZW5lcmF0ZV9pbnRl cm5hbHNfd3JhcHBlcl9pbXBsZW1lbnRhdGlvbi5weSAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRF UyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAtMjAyNSw2ICsyMDI2LDcgQEAKIAkJQUQ3NDM4QzAx RTA0NTdBNDAwRkQwQzJBIC8qIFdhc21TaWduYXR1cmUuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEFENzQzOEJGMUUwNDU3OTIwMEZEMEMyQSAvKiBXYXNt U2lnbmF0dXJlLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsg fTsKIAkJQUQ3NDM4QzExRTA0NTdBQTAwRkQwQzJBIC8qIFdhc21TaWduYXR1cmUuY3BwIGluIFNv dXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQUQ3NDM4QkUxRTA0NTc5 MjAwRkQwQzJBIC8qIFdhc21TaWduYXR1cmUuY3BwICovOyB9OwogCQlBRDg2QTkzRTFBQTREODhE MDAyRkU3N0YgLyogV2Vha0dDTWFwSW5saW5lcy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gQUQ4NkE5M0QxQUE0RDg3QzAwMkZFNzdGIC8qIFdlYWtHQ01h cElubGluZXMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9 OworCQlBREI2RjY3RDFFMTVENzYwMDA4MkYzODQgLyogV2FzbVBhZ2VDb3VudC5jcHAgaW4gU291 cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBREI2RjY3QzFFMTVENzUw MDA4MkYzODQgLyogV2FzbVBhZ2VDb3VudC5jcHAgKi87IH07CiAJCUFEQkM1NEQ0MURGOEVBMkIw MDVCRjczOCAvKiBXZWJBc3NlbWJseVRvSlNDYWxsZWUuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQURCQzU0RDIxREY4RUEwMDAwNUJGNzM4IC8qIFdl YkFzc2VtYmx5VG9KU0NhbGxlZS5jcHAgKi87IH07CiAJCUFEQkM1NEQ1MURGOEVBMkIwMDVCRjcz OCAvKiBXZWJBc3NlbWJseVRvSlNDYWxsZWUuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IEFEQkM1NEQzMURGOEVBMDAwMDVCRjczOCAvKiBXZWJBc3NlbWJs eVRvSlNDYWxsZWUuaCAqLzsgfTsKIAkJQUREQjFGNjMxOEQ3N0RCRTAwOUI1OEE4IC8qIE9wYXF1 ZVJvb3RTZXQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IEFEREIxRjYyMThENzdEQjcwMDlCNThBOCAvKiBPcGFxdWVSb290U2V0LmggKi87IHNldHRpbmdz ID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKQEAgLTIzNjEsNyArMjM2Myw2IEBA CiAJCUZFRDk0RjJGMTcxRTNFMjMwMEJFNzdBNCAvKiBXYXRjaGRvZy5oIGluIEhlYWRlcnMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkVEOTRGMkMxNzFFM0UyMzAwQkU3N0E0 IC8qIFdhdGNoZG9nLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsg fTsgfTsKIAkJRkVGMDQwNTExQUFFNjYyRDAwQkQyOEIwIC8qIENvbXBhcmVBbmRTd2FwVGVzdC5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGRUYwNDA1 MDFBQUU2NjJEMDBCRDI4QjAgLyogQ29tcGFyZUFuZFN3YXBUZXN0LmNwcCAqLzsgfTsKIAkJRkVG RDZGQzYxRDVFNzk5MjAwOEYyRjBCIC8qIEpTU3RyaW5nSW5saW5lcy5oIGluIEhlYWRlcnMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkVGRDZGQzUxRDVFNzk3MDAwOEYyRjBC IC8qIEpTU3RyaW5nSW5saW5lcy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZh dGUsICk7IH07IH07Ci0JCTJEMzQyRjM2RjcyNDQwOTY4MDRBREIyNCAvKiBTb3VyY2VPcmlnaW4u aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQyNUJBMTMz N0U0MzQ0RTFCMjY5QTY3MSAvKiBTb3VyY2VPcmlnaW4uaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklC VVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogLyogRW5kIFBCWEJ1aWxkRmlsZSBzZWN0aW9uICov CiAKIC8qIEJlZ2luIFBCWENvbnRhaW5lckl0ZW1Qcm94eSBzZWN0aW9uICovCkBAIC0zNjM4LDYg KzM2MzksNyBAQAogCQk0MTI5NTI3NTFEMkNGNkFDMDBFNzhCODkgLyogYnVpbHRpbnNfZ2VuZXJh dGVfd3JhcHBlcl9oZWFkZXIucHkgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0LnNjcmlwdC5weXRob247IHBhdGgg PSBidWlsdGluc19nZW5lcmF0ZV93cmFwcGVyX2hlYWRlci5weTsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJNDEyOTUyNzYxRDJDRjZBQzAwRTc4Qjg5IC8qIGJ1aWx0aW5zX2dlbmVyYXRl X3dyYXBwZXJfaW1wbGVtZW50YXRpb24ucHkgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0LnNjcmlwdC5weXRob247 IHBhdGggPSBidWlsdGluc19nZW5lcmF0ZV93cmFwcGVyX2ltcGxlbWVudGF0aW9uLnB5OyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0MURFQTEzMTFCOUYzMTU0MDA2RDY1REQgLyogQnVp bHRpblV0aWxzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEJ1aWx0aW5VdGls cy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk0MjVCQTEzMzdFNDM0NEUxQjI2OUE2 NzEgLyogU291cmNlT3JpZ2luLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFNv dXJjZU9yaWdpbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0MzE5REEwMTFDMUJF M0MxMDAxRDI2MEIgLyogQjNMb3dlck1hY3Jvc0FmdGVyT3B0aW1pemF0aW9ucy5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUgPSBCM0xvd2VyTWFjcm9zQWZ0ZXJPcHRpbWl6 YXRpb25zLmNwcDsgcGF0aCA9IGIzL0IzTG93ZXJNYWNyb3NBZnRlck9wdGltaXphdGlvbnMuY3Bw OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0MzE5REEwMjFDMUJFM0MxMDAxRDI2MEIg LyogQjNMb3dlck1hY3Jvc0FmdGVyT3B0aW1pemF0aW9ucy5oICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jLmg7IG5hbWUgPSBCM0xvd2VyTWFjcm9zQWZ0ZXJPcHRpbWl6YXRpb25zLmg7IHBhdGggPSBi My9CM0xvd2VyTWFjcm9zQWZ0ZXJPcHRpbWl6YXRpb25zLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTQzNDBBNDgyMUE5MDUxQUYwMEQ3M0NDQSAvKiBNYXRoQ29tbW9uLmNwcCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IE1hdGhDb21tb24uY3BwOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwpAQCAtNDUxMCw2ICs0NTEyLDcgQEAKIAkJQUQ3NDM4QkUxRTA0 NTc5MjAwRkQwQzJBIC8qIFdhc21TaWduYXR1cmUuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBwYXRoID0gV2FzbVNpZ25hdHVyZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CiAJCUFENzQzOEJGMUUwNDU3OTIwMEZEMEMyQSAvKiBXYXNtU2lnbmF0dXJlLmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFdhc21TaWduYXR1cmUuaDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJQUQ4NkE5M0QxQUE0RDg3QzAwMkZFNzdGIC8qIFdlYWtHQ01hcElu bGluZXMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gV2Vha0dDTWFwSW5saW5l cy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlBREI2RjY3QzFFMTVENzUwMDA4MkYz ODQgLyogV2FzbVBhZ2VDb3VudC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBh dGggPSBXYXNtUGFnZUNvdW50LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQURC QzU0RDIxREY4RUEwMDAwNUJGNzM4IC8qIFdlYkFzc2VtYmx5VG9KU0NhbGxlZS5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUgPSBXZWJBc3NlbWJseVRvSlNDYWxsZWUuY3Bw OyBwYXRoID0ganMvV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJQURCQzU0RDMxREY4RUEwMDAwNUJGNzM4IC8qIFdlYkFzc2VtYmx5VG9KU0Nh bGxlZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IG5hbWUgPSBXZWJBc3NlbWJseVRvSlND YWxsZWUuaDsgcGF0aCA9IGpzL1dlYkFzc2VtYmx5VG9KU0NhbGxlZS5oOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQlBRERCMUY2MjE4RDc3REI3MDA5QjU4QTggLyogT3BhcXVlUm9vdFNl dC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBPcGFxdWVSb290U2V0Lmg7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC00ODc5LDcgKzQ4ODIsNiBAQAogCQlGRUYwNDA1 MDFBQUU2NjJEMDBCRDI4QjAgLyogQ29tcGFyZUFuZFN3YXBUZXN0LmNwcCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuY3BwLmNwcDsgbmFtZSA9IENvbXBhcmVBbmRTd2FwVGVzdC5jcHA7IHBhdGggPSBB UEkvdGVzdHMvQ29tcGFyZUFuZFN3YXBUZXN0LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJRkVGMDQwNTIxQUFFQzRFRDAwQkQyOEIwIC8qIENvbXBhcmVBbmRTd2FwVGVzdC5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IG5hbWUgPSBDb21wYXJlQW5kU3dhcFRlc3QuaDsgcGF0 aCA9IEFQSS90ZXN0cy9Db21wYXJlQW5kU3dhcFRlc3QuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKIAkJRkVGRDZGQzUxRDVFNzk3MDAwOEYyRjBCIC8qIEpTU3RyaW5nSW5saW5lcy5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBKU1N0cmluZ0lubGluZXMuaDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKLQkJNDI1QkExMzM3RTQzNDRFMUIyNjlBNjcxIC8qIFNvdXJj ZU9yaWdpbi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IG5hbWUgPSBTb3VyY2VPcmlnaW4u aDsgcGF0aCA9IFNvdXJjZU9yaWdpbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogLyog RW5kIFBCWEZpbGVSZWZlcmVuY2Ugc2VjdGlvbiAqLwogCiAvKiBCZWdpbiBQQlhGcmFtZXdvcmtz QnVpbGRQaGFzZSBzZWN0aW9uICovCkBAIC02MDQ3LDYgKzYwNDksNyBAQAogCQkJCTc5Qjc1OTcy MURGQTRDNjAwMDUyMTc0QyAvKiBXYXNtTWVtb3J5SW5mb3JtYXRpb24uaCAqLywKIAkJCQk1M0Y0 MEU5NjFENUE3QkVDMDA5OUExQjYgLyogV2FzbU1vZHVsZVBhcnNlci5jcHAgKi8sCiAJCQkJNTNG NDBFOTQxRDVBN0FFRjAwOTlBMUI2IC8qIFdhc21Nb2R1bGVQYXJzZXIuaCAqLywKKwkJCQlBREI2 RjY3QzFFMTVENzUwMDA4MkYzODQgLyogV2FzbVBhZ2VDb3VudC5jcHAgKi8sCiAJCQkJNzlCNzU5 NzMxREZBNEM2MDAwNTIxNzRDIC8qIFdhc21QYWdlQ291bnQuaCAqLywKIAkJCQk1M0Y0MEU4QzFE NTkwMUYyMDA5OUExQjYgLyogV2FzbVBhcnNlci5oICovLAogCQkJCTUzMTM3NEJFMUQ1Q0U5NTAw MEFGN0EwQiAvKiBXYXNtUGxhbi5jcHAgKi8sCkBAIC05NzAzLDYgKzk3MDYsNyBAQAogCQkJCTBG NjRCMjcxMUE3ODRCQUYwMDZFNEU2NiAvKiBCaW5hcnlTd2l0Y2guY3BwIGluIFNvdXJjZXMgKi8s CiAJCQkJMTQyODA4NjMxMDdFQzExQTAwMTNFN0IyIC8qIEJvb2xlYW5Db25zdHJ1Y3Rvci5jcHAg aW4gU291cmNlcyAqLywKIAkJCQkxNDI4MDg2NDEwN0VDMTFBMDAxM0U3QjIgLyogQm9vbGVhbk9i amVjdC5jcHAgaW4gU291cmNlcyAqLywKKwkJCQlBREI2RjY3RDFFMTVENzYwMDA4MkYzODQgLyog V2FzbVBhZ2VDb3VudC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkxNDI4MDg2NTEwN0VDMTFBMDAx M0U3QjIgLyogQm9vbGVhblByb3RvdHlwZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlERTI2RTkw NzFDQjVERUZCMDBEMkJFODIgLyogQnVpbHRpbkV4ZWN1dGFibGVDcmVhdG9yLmNwcCBpbiBTb3Vy Y2VzICovLAogCQkJCUE3RDgwMUE0MTg4MEQ2NkUwMDI2QzM5QiAvKiBCdWlsdGluRXhlY3V0YWJs ZXMuY3BwIGluIFNvdXJjZXMgKi8sCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv anNjLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9qc2MuY3BwCmluZGV4IDNlYWY0YTAuLmY0 MzRjYWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9qc2MuY3BwCisrKyBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9qc2MuY3BwCkBAIC01NCw2ICs1NCw4IEBACiAjaW5jbHVkZSAi SlNTdHJpbmcuaCIKICNpbmNsdWRlICJKU1R5cGVkQXJyYXlzLmgiCiAjaW5jbHVkZSAiSlNXZWJB c3NlbWJseUNhbGxlZS5oIgorI2luY2x1ZGUgIkpTV2ViQXNzZW1ibHlJbnN0YW5jZS5oIgorI2lu Y2x1ZGUgIkpTV2ViQXNzZW1ibHlNb2R1bGUuaCIKICNpbmNsdWRlICJMTEludERhdGEuaCIKICNp bmNsdWRlICJMTEludFRodW5rcy5oIgogI2luY2x1ZGUgIk9iamVjdENvbnN0cnVjdG9yLmgiCkBA IC03MCw2ICs3Miw3IEBACiAjaW5jbHVkZSAiVHlwZVByb2ZpbGVyTG9nLmgiCiAjaW5jbHVkZSAi V2FzbVBsYW4uaCIKICNpbmNsdWRlICJXYXNtTWVtb3J5LmgiCisjaW5jbHVkZSAiV2ViQXNzZW1i bHlNb2R1bGVSZWNvcmQuaCIKICNpbmNsdWRlIDxsb2NhbGUuaD4KICNpbmNsdWRlIDxtYXRoLmg+ CiAjaW5jbHVkZSA8c3RkaW8uaD4KQEAgLTI2MTUsNiArMjYxOCw3IEBAIHN0YXRpYyBFbmNvZGVk SlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGZ1bmN0aW9uVGVzdFdhc21Nb2R1bGVGdW5jdGlvbnMoRXhl Y1N0YXRlKiBlCiB7CiAgICAgVk0mIHZtID0gZXhlYy0+dm0oKTsKICAgICBhdXRvIHNjb3BlID0g REVDTEFSRV9USFJPV19TQ09QRSh2bSk7CisgICAgYXV0byogZ2xvYmFsT2JqZWN0ID0gZXhlYy0+ bGV4aWNhbEdsb2JhbE9iamVjdCgpOwogCiAgICAgaWYgKCFPcHRpb25zOjp1c2VXZWJBc3NlbWJs eSgpKQogICAgICAgICByZXR1cm4gdGhyb3dWTVR5cGVFcnJvcihleGVjLCBzY29wZSwgQVNDSUlM aXRlcmFsKCJ0ZXN0V2FzbU1vZHVsZSBzaG91bGQgb25seSBiZSBjYWxsZWQgaWYgdGhlIHVzZVdl YkFzc2VtYmx5IG9wdGlvbiBpcyBzZXQiKSk7CkBAIC0yNjQ4LDggKzI2NTIsMjUgQEAgc3RhdGlj IEVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwgZnVuY3Rpb25UZXN0V2FzbU1vZHVsZUZ1bmN0 aW9ucyhFeGVjU3RhdGUqIGUKICAgICAgICAgICAgIH0pOwogICAgIH0KIAotICAgIHN0ZDo6dW5p cXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4gbW9kdWxlSW5mb3JtYXRpb24gPSBwbGFu LnRha2VNb2R1bGVJbmZvcm1hdGlvbigpOwotICAgIFJFTEVBU0VfQVNTRVJUKCFtb2R1bGVJbmZv cm1hdGlvbi0+bWVtb3J5KTsKKyAgICBTeW1ib2xUYWJsZSogZXhwb3J0U3ltYm9sVGFibGUgPSBT eW1ib2xUYWJsZTo6Y3JlYXRlKHZtKTsKKyAgICBhdXRvKiBtb2R1bGVTdHJ1Y3R1cmUgPSBJbnRl cm5hbEZ1bmN0aW9uOjpjcmVhdGVTdWJjbGFzc1N0cnVjdHVyZShleGVjLCBKU1ZhbHVlKCksIGV4 ZWMtPmxleGljYWxHbG9iYWxPYmplY3QoKS0+V2ViQXNzZW1ibHlNb2R1bGVTdHJ1Y3R1cmUoKSk7 CisgICAgUkVUVVJOX0lGX0VYQ0VQVElPTihzY29wZSwgZW5jb2RlZEpTVmFsdWUoKSk7CisgICAg SlNXZWJBc3NlbWJseU1vZHVsZSogbW9kdWxlID0gSlNXZWJBc3NlbWJseU1vZHVsZTo6Y3JlYXRl KHZtLCBtb2R1bGVTdHJ1Y3R1cmUsIHBsYW4udGFrZU1vZHVsZUluZm9ybWF0aW9uKCksIHBsYW4u dGFrZUNhbGxMaW5rSW5mb3MoKSwgcGxhbi50YWtlV2FzbUV4aXRTdHVicygpLCBleHBvcnRTeW1i b2xUYWJsZSwgMCk7CisgICAgU3RydWN0dXJlKiBpbnN0YW5jZVN0cnVjdHVyZSA9IEludGVybmFs RnVuY3Rpb246OmNyZWF0ZVN1YmNsYXNzU3RydWN0dXJlKGV4ZWMsIEpTVmFsdWUoKSwgZ2xvYmFs T2JqZWN0LT5XZWJBc3NlbWJseUluc3RhbmNlU3RydWN0dXJlKCkpOworICAgIFJFVFVSTl9JRl9F WENFUFRJT04oc2NvcGUsIGVuY29kZWRKU1ZhbHVlKCkpOworICAgIElkZW50aWZpZXIgbW9kdWxl S2V5ID0gSWRlbnRpZmllcjo6ZnJvbVVpZChQcml2YXRlTmFtZShQcml2YXRlTmFtZTo6RGVzY3Jp cHRpb24sICJXZWJBc3NlbWJseUluc3RhbmNlIikpOworICAgIFdlYkFzc2VtYmx5TW9kdWxlUmVj b3JkKiBtb2R1bGVSZWNvcmQgPSBXZWJBc3NlbWJseU1vZHVsZVJlY29yZDo6Y3JlYXRlKGV4ZWMs IHZtLCBnbG9iYWxPYmplY3QtPndlYkFzc2VtYmx5TW9kdWxlUmVjb3JkU3RydWN0dXJlKCksIG1v ZHVsZUtleSwgbW9kdWxlLT5tb2R1bGVJbmZvcm1hdGlvbigpKTsKKyAgICBSRVRVUk5fSUZfRVhD RVBUSU9OKHNjb3BlLCBlbmNvZGVkSlNWYWx1ZSgpKTsKKyAgICBKU1dlYkFzc2VtYmx5SW5zdGFu Y2UqIGluc3RhbmNlID0gSlNXZWJBc3NlbWJseUluc3RhbmNlOjpjcmVhdGUodm0sIGluc3RhbmNl U3RydWN0dXJlLCBtb2R1bGUsIG1vZHVsZVJlY29yZC0+Z2V0TW9kdWxlTmFtZXNwYWNlKGV4ZWMp KTsKKyAgICBSRVRVUk5fSUZfRVhDRVBUSU9OKHNjb3BlLCBlbmNvZGVkSlNWYWx1ZSgpKTsKKyAg ICB2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UgPSBpbnN0YW5jZTsKKworICAgIGlmICghIW1v ZHVsZS0+bW9kdWxlSW5mb3JtYXRpb24oKS5tZW1vcnkpIHsKKyAgICAgICAgYm9vbCBmYWlsZWQ7 CisgICAgICAgIFdhc206Ok1lbW9yeSBtZW1vcnkobW9kdWxlLT5tb2R1bGVJbmZvcm1hdGlvbigp Lm1lbW9yeS5pbml0aWFsKCksIG1vZHVsZS0+bW9kdWxlSW5mb3JtYXRpb24oKS5tZW1vcnkubWF4 aW11bSgpLCBmYWlsZWQpOworICAgICAgICBSRUxFQVNFX0FTU0VSVChmYWlsZWQpOworICAgICAg ICBpbnN0YW5jZS0+c2V0TWVtb3J5KHZtLCBKU1dlYkFzc2VtYmx5TWVtb3J5OjpjcmVhdGUodm0s IGdsb2JhbE9iamVjdC0+V2ViQXNzZW1ibHlNZW1vcnlTdHJ1Y3R1cmUoKSwgV1RGTW92ZShtZW1v cnkpKSk7CisgICAgfQogCiAgICAgZm9yICh1aW50MzJfdCBpID0gMDsgaSA8IGZ1bmN0aW9uQ291 bnQ7ICsraSkgewogICAgICAgICBKU0FycmF5KiB0ZXN0Q2FzZXMgPSBqc0Nhc3Q8SlNBcnJheSo+ KGV4ZWMtPmFyZ3VtZW50KGkgKyAyKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvcnVudGltZS9BYnN0cmFjdE1vZHVsZVJlY29yZC5oIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3J1bnRpbWUvQWJzdHJhY3RNb2R1bGVSZWNvcmQuaAppbmRleCAwNGFmMTI2Li4zOWZjMmQxIDEw MDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9BYnN0cmFjdE1vZHVsZVJl Y29yZC5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0Fic3RyYWN0TW9kdWxl UmVjb3JkLmgKQEAgLTExMyw3ICsxMTMsNyBAQCBwdWJsaWM6CiAKICAgICBBYnN0cmFjdE1vZHVs ZVJlY29yZCogaG9zdFJlc29sdmVJbXBvcnRlZE1vZHVsZShFeGVjU3RhdGUqLCBjb25zdCBJZGVu dGlmaWVyJiBtb2R1bGVOYW1lKTsKIAotICAgIEpTTW9kdWxlTmFtZXNwYWNlT2JqZWN0KiBnZXRN b2R1bGVOYW1lc3BhY2UoRXhlY1N0YXRlKik7CisgICAgSlNfRVhQT1JUX1BSSVZBVEUgSlNNb2R1 bGVOYW1lc3BhY2VPYmplY3QqIGdldE1vZHVsZU5hbWVzcGFjZShFeGVjU3RhdGUqKTsKICAgICAK ICAgICBKU01vZHVsZUVudmlyb25tZW50KiBtb2R1bGVFbnZpcm9ubWVudCgpCiAgICAgewpkaWZm IC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmggYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvcnVudGltZS9KU1R5cGUuaAppbmRleCAwNTIwMmYzLi5hYzUwOWQ3IDEw MDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU1R5cGUuaAorKysgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU1R5cGUuaApAQCAtOTMsNiArOTMsOCBAQCBl bnVtIEpTVHlwZSA6IHVpbnQ4X3QgewogICAgIEpTTWFwVHlwZSwKICAgICBKU1NldFR5cGUsCiAK KyAgICBXZWJBc3NlbWJseUZ1bmN0aW9uVHlwZSwKKwogICAgIExhc3RKU0NPYmplY3RUeXBlID0g SlNTZXRUeXBlLAogICAgIE1heEpTVHlwZSA9IDBiMTExMTExMTEsCiB9OwpkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuY3BwIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuY3BwCmluZGV4IDExN2Q3NjQu LjdmNTZmMmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lS R2VuZXJhdG9yLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQjNJUkdl bmVyYXRvci5jcHAKQEAgLTE1NSw3ICsxNTUsNyBAQCBwdWJsaWM6CiAgICAgICAgICAgICByZXR1 cm4gZmFpbChfX1ZBX0FSR1NfXyk7ICAgICAgICAgICAgIFwKICAgICB9IHdoaWxlICgwKQogCi0g ICAgQjNJUkdlbmVyYXRvcihWTSYsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiwgUHJvY2VkdXJl JiwgV2FzbUludGVybmFsRnVuY3Rpb24qLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4m LCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmKTsKKyAgICBCM0lSR2VuZXJhdG9y KFZNJiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mLCBQcm9jZWR1cmUmLCBXYXNtSW50ZXJuYWxG dW5jdGlvbiosIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYpOwogCiAgICAgUGFydGlh bFJlc3VsdCBXQVJOX1VOVVNFRF9SRVRVUk4gYWRkQXJndW1lbnRzKGNvbnN0IFNpZ25hdHVyZSop OwogICAgIFBhcnRpYWxSZXN1bHQgV0FSTl9VTlVTRURfUkVUVVJOIGFkZExvY2FsKFR5cGUsIHVp bnQzMl90KTsKQEAgLTIwNSw4ICsyMDUsNiBAQCBwdWJsaWM6CiAKICAgICB2b2lkIGVtaXRFeGNl cHRpb25DaGVjayhDQ2FsbEhlbHBlcnMmLCBFeGNlcHRpb25UeXBlKTsKIAotICAgIHZvaWQgZW1p dFJlbG9hZFBpbm5lZFJlZ2lzdGVycygpOwotCiBwcml2YXRlOgogICAgIEV4cHJlc3Npb25UeXBl IGVtaXRDaGVja0FuZFByZXBhcmVQb2ludGVyKEV4cHJlc3Npb25UeXBlIHBvaW50ZXIsIHVpbnQz Ml90IG9mZnNldCwgdWludDMyX3Qgc2l6ZU9mT3ApOwogICAgIEV4cHJlc3Npb25UeXBlIGVtaXRM b2FkT3AoTG9hZE9wVHlwZSwgT3JpZ2luLCBFeHByZXNzaW9uVHlwZSBwb2ludGVyLCB1aW50MzJf dCBvZmZzZXQpOwpAQCAtMjE5LDcgKzIxNyw2IEBAIHByaXZhdGU6CiAgICAgdm9pZCBlbWl0Q2hl Y2tzRm9yTW9kT3JEaXYoQjM6Ok9wY29kZSwgRXhwcmVzc2lvblR5cGUgbGVmdCwgRXhwcmVzc2lv blR5cGUgcmlnaHQpOwogCiAgICAgVk0mIG1fdm07Ci0gICAgY29uc3QgSW1tdXRhYmxlRnVuY3Rp b25JbmRleFNwYWNlJiBtX2Z1bmN0aW9uSW5kZXhTcGFjZTsKICAgICBjb25zdCBNb2R1bGVJbmZv cm1hdGlvbiYgbV9pbmZvOwogICAgIFByb2NlZHVyZSYgbV9wcm9jOwogICAgIEJhc2ljQmxvY2sq IG1fY3VycmVudEJsb2NrOwpAQCAtMjMxLDkgKzIyOCw4IEBAIHByaXZhdGU6CiAgICAgVmFsdWUq IG1faW5zdGFuY2VWYWx1ZTsKIH07CiAKLUIzSVJHZW5lcmF0b3I6OkIzSVJHZW5lcmF0b3IoVk0m IHZtLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgUHJvY2VkdXJlJiBwcm9jZWR1cmUs IFdhc21JbnRlcm5hbEZ1bmN0aW9uKiBjb21waWxhdGlvbiwgVmVjdG9yPFVubGlua2VkV2FzbVRv V2FzbUNhbGw+JiB1bmxpbmtlZFdhc21Ub1dhc21DYWxscywgY29uc3QgSW1tdXRhYmxlRnVuY3Rp b25JbmRleFNwYWNlJiBmdW5jdGlvbkluZGV4U3BhY2UpCitCM0lSR2VuZXJhdG9yOjpCM0lSR2Vu ZXJhdG9yKFZNJiB2bSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFByb2NlZHVyZSYg cHJvY2VkdXJlLCBXYXNtSW50ZXJuYWxGdW5jdGlvbiogY29tcGlsYXRpb24sIFZlY3RvcjxVbmxp bmtlZFdhc21Ub1dhc21DYWxsPiYgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMpCiAgICAgOiBtX3Zt KHZtKQotICAgICwgbV9mdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleFNwYWNlKQogICAg ICwgbV9pbmZvKGluZm8pCiAgICAgLCBtX3Byb2MocHJvY2VkdXJlKQogICAgICwgbV91bmxpbmtl ZFdhc21Ub1dhc21DYWxscyh1bmxpbmtlZFdhc21Ub1dhc21DYWxscykKQEAgLTI1NCwxNCArMjUw LDE2IEBAIEIzSVJHZW5lcmF0b3I6OkIzSVJHZW5lcmF0b3IoVk0mIHZtLCBjb25zdCBNb2R1bGVJ bmZvcm1hdGlvbiYgaW5mbywgUHJvY2VkdXJlJiBwCiAgICAgICAgIH0KICAgICB9CiAKLSAgICBp ZiAoaW5mby5oYXNNZW1vcnkoKSkgewotICAgICAgICBtX21lbW9yeUJhc2VHUFIgPSBpbmZvLm1l bW9yeS5waW5uZWRSZWdpc3RlcnMoKS5iYXNlTWVtb3J5UG9pbnRlcjsKKyAgICAvLyBGSVhNRSB3 ZSBkb24ndCByZWFsbHkgbmVlZCB0byBwaW4gcmVnaXN0ZXJzIGhlcmUgaWYgdGhlcmUncyBubyBt ZW1vcnkuIEl0IG1ha2VzIHdhc20gLT4gd2FzbSB0aHVua3Mgc2ltcGxlciBmb3Igbm93LiBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY2NjIzCisgICAgICAgIGNvbnN0 IFBpbm5lZFJlZ2lzdGVySW5mbyYgcGlubmVkUmVncyA9IFBpbm5lZFJlZ2lzdGVySW5mbzo6Z2V0 KCk7CisgICAgICAgIG1fbWVtb3J5QmFzZUdQUiA9IHBpbm5lZFJlZ3MuYmFzZU1lbW9yeVBvaW50 ZXI7CiAgICAgICAgIG1fcHJvYy5waW5SZWdpc3RlcihtX21lbW9yeUJhc2VHUFIpOwotICAgICAg ICBBU1NFUlQoIWluZm8ubWVtb3J5LnBpbm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnNbMF0u c2l6ZU9mZnNldCk7Ci0gICAgICAgIG1fbWVtb3J5U2l6ZUdQUiA9IGluZm8ubWVtb3J5LnBpbm5l ZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnNbMF0uc2l6ZVJlZ2lzdGVyOwotICAgICAgICBmb3Ig KGNvbnN0IFBpbm5lZFNpemVSZWdpc3RlckluZm8mIHJlZ0luZm8gOiBpbmZvLm1lbW9yeS5waW5u ZWRSZWdpc3RlcnMoKS5zaXplUmVnaXN0ZXJzKQorICAgICAgICBBU1NFUlQoIXBpbm5lZFJlZ3Mu c2l6ZVJlZ2lzdGVyc1swXS5zaXplT2Zmc2V0KTsKKyAgICAgICAgbV9tZW1vcnlTaXplR1BSID0g cGlubmVkUmVncy5zaXplUmVnaXN0ZXJzWzBdLnNpemVSZWdpc3RlcjsKKyAgICAgICAgZm9yIChj b25zdCBQaW5uZWRTaXplUmVnaXN0ZXJJbmZvJiByZWdJbmZvIDogcGlubmVkUmVncy5zaXplUmVn aXN0ZXJzKQogICAgICAgICAgICAgbV9wcm9jLnBpblJlZ2lzdGVyKHJlZ0luZm8uc2l6ZVJlZ2lz dGVyKTsKIAorICAgIGlmIChpbmZvLmhhc01lbW9yeSgpKSB7CiAgICAgICAgIG1fcHJvYy5zZXRX YXNtQm91bmRzQ2hlY2tHZW5lcmF0b3IoWz1dIChDQ2FsbEhlbHBlcnMmIGppdCwgR1BSUmVnIHBp bm5lZEdQUiwgdW5zaWduZWQpIHsKICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0 ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKICAgICAgICAgICAgIEFTU0VSVF9VTlVTRUQocGlu bmVkR1BSLCBtX21lbW9yeVNpemVHUFIgPT0gcGlubmVkR1BSKTsKQEAgLTI3NSw2ICsyNzMsNjEg QEAgQjNJUkdlbmVyYXRvcjo6QjNJUkdlbmVyYXRvcihWTSYgdm0sIGNvbnN0IE1vZHVsZUluZm9y bWF0aW9uJiBpbmZvLCBQcm9jZWR1cmUmIHAKICAgICAgICAgbV9jdXJyZW50QmxvY2stPmFwcGVu ZE5ldzxDb25zdFB0clZhbHVlPihtX3Byb2MsIE9yaWdpbigpLCAmbV92bS50b3BKU1dlYkFzc2Vt Ymx5SW5zdGFuY2UpKTsKIH0KIAorc3RydWN0IE1lbW9yeUJhc2VBbmRTaXplIHsKKyAgICBWYWx1 ZSogYmFzZTsKKyAgICBWYWx1ZSogc2l6ZTsKK307CisKK3N0YXRpYyBNZW1vcnlCYXNlQW5kU2l6 ZSBnZXRNZW1vcnlCYXNlQW5kU2l6ZShWTSYgdm0sIFZhbHVlKiBpbnN0YW5jZSwgUHJvY2VkdXJl JiBwcm9jLCBCYXNpY0Jsb2NrKiBibG9jaykKK3sKKyAgICBWYWx1ZSogbWVtb3J5T2JqZWN0ID0g YmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4ocHJvYywgTG9hZCwgcG9pbnRlclR5cGUoKSwg T3JpZ2luKCksIGluc3RhbmNlLCBKU1dlYkFzc2VtYmx5SW5zdGFuY2U6Om9mZnNldE9mTWVtb3J5 KCkpOworCisgICAgc3RhdGljX2Fzc2VydChzaXplb2YoZGVjbHR5cGUodm0udG9wSlNXZWJBc3Nl bWJseUluc3RhbmNlLT5tZW1vcnkoKS0+bWVtb3J5KCktPm1lbW9yeSgpKSkgPT0gc2l6ZW9mKHZv aWQqKSwgImNvZGVnZW4gcmVsaWVzIG9uIHRoaXMgc2l6ZSIpOworICAgIHN0YXRpY19hc3NlcnQo c2l6ZW9mKGRlY2x0eXBlKHZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZS0+bWVtb3J5KCktPm1l bW9yeSgpLT5zaXplKCkpKSA9PSBzaXplb2YodWludDY0X3QpLCAiY29kZWdlbiByZWxpZXMgb24g dGhpcyBzaXplIik7CisgICAgTWVtb3J5QmFzZUFuZFNpemUgcmVzdWx0OworICAgIHJlc3VsdC5i YXNlID0gYmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4ocHJvYywgTG9hZCwgcG9pbnRlclR5 cGUoKSwgT3JpZ2luKCksIG1lbW9yeU9iamVjdCwgSlNXZWJBc3NlbWJseU1lbW9yeTo6b2Zmc2V0 T2ZNZW1vcnkoKSk7CisgICAgcmVzdWx0LnNpemUgPSBibG9jay0+YXBwZW5kTmV3PE1lbW9yeVZh bHVlPihwcm9jLCBMb2FkLCBJbnQ2NCwgT3JpZ2luKCksIG1lbW9yeU9iamVjdCwgSlNXZWJBc3Nl bWJseU1lbW9yeTo6b2Zmc2V0T2ZTaXplKCkpOworCisgICAgcmV0dXJuIHJlc3VsdDsKK30KKwor c3RhdGljIHZvaWQgcmVzdG9yZVdlYkFzc2VtYmx5R2xvYmFsU3RhdGUoVk0mIHZtLCBjb25zdCBN ZW1vcnlJbmZvcm1hdGlvbiYgbWVtb3J5LCBWYWx1ZSogaW5zdGFuY2UsIFByb2NlZHVyZSYgcHJv YywgQmFzaWNCbG9jayogYmxvY2spCit7CisgICAgYmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1 ZT4ocHJvYywgU3RvcmUsIE9yaWdpbigpLCBpbnN0YW5jZSwgYmxvY2stPmFwcGVuZE5ldzxDb25z dFB0clZhbHVlPihwcm9jLCBPcmlnaW4oKSwgJnZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZSkp OworCisgICAgaWYgKCEhbWVtb3J5KSB7CisgICAgICAgIGNvbnN0IFBpbm5lZFJlZ2lzdGVySW5m byYgcGlubmVkUmVncyA9IFBpbm5lZFJlZ2lzdGVySW5mbzo6Z2V0KCk7CisgICAgICAgIGF1dG8g bWVtb3J5VmFsdWUgPSBnZXRNZW1vcnlCYXNlQW5kU2l6ZSh2bSwgaW5zdGFuY2UsIHByb2MsIGJs b2NrKTsKKworICAgICAgICBWZWN0b3I8VmFsdWUqPiBhcmd1bWVudHM7CisgICAgICAgIGFyZ3Vt ZW50cy5yZXNlcnZlQ2FwYWNpdHkoMSArIHBpbm5lZFJlZ3Muc2l6ZVJlZ2lzdGVycy5zaXplKCkp OworICAgICAgICBhcmd1bWVudHMuYXBwZW5kKG1lbW9yeVZhbHVlLmJhc2UpOworICAgICAgICBm b3IgKGF1dG8gaW5mbyA6IHBpbm5lZFJlZ3Muc2l6ZVJlZ2lzdGVycykgeworICAgICAgICAgICAg VmFsdWUqIHNpemVWYWx1ZSA9IGJsb2NrLT5hcHBlbmROZXc8VmFsdWU+KHByb2MsIFN1YiwgT3Jp Z2luKCksIG1lbW9yeVZhbHVlLnNpemUsIGJsb2NrLT5hcHBlbmROZXc8Q29uc3Q2NFZhbHVlPihw cm9jLCBPcmlnaW4oKSwgaW5mby5zaXplT2Zmc2V0KSk7CisgICAgICAgICAgICBhcmd1bWVudHMu YXBwZW5kKHNpemVWYWx1ZSk7CisgICAgICAgIH0KKworICAgICAgICBSZWdpc3RlclNldCBjbG9i YmVyczsKKyAgICAgICAgY2xvYmJlcnMuc2V0KHBpbm5lZFJlZ3MuYmFzZU1lbW9yeVBvaW50ZXIp OworICAgICAgICBmb3IgKGF1dG8gaW5mbyA6IHBpbm5lZFJlZ3Muc2l6ZVJlZ2lzdGVycykKKyAg ICAgICAgICAgIGNsb2JiZXJzLnNldChpbmZvLnNpemVSZWdpc3Rlcik7CisKKyAgICAgICAgQjM6 OlBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCA9IGJsb2NrLT5hcHBlbmROZXc8QjM6OlBhdGNo cG9pbnRWYWx1ZT4ocHJvYywgQjM6OlZvaWQsIE9yaWdpbigpKTsKKyAgICAgICAgcGF0Y2hwb2lu dC0+ZWZmZWN0cyA9IEVmZmVjdHM6Om5vbmUoKTsKKyAgICAgICAgcGF0Y2hwb2ludC0+ZWZmZWN0 cy53cml0ZXNQaW5uZWQgPSB0cnVlOworICAgICAgICBwYXRjaHBvaW50LT5jbG9iYmVyKGNsb2Ji ZXJzKTsKKyAgICAgICAgcGF0Y2hwb2ludC0+YXBwZW5kVmVjdG9yV2l0aFJlcChhcmd1bWVudHMs IFZhbHVlUmVwOjpTb21lUmVnaXN0ZXIpOworCisgICAgICAgIHBhdGNocG9pbnQtPnNldEdlbmVy YXRvcihbJnBpbm5lZFJlZ3NdIChDQ2FsbEhlbHBlcnMmIGppdCwgY29uc3QgQjM6OlN0YWNrbWFw R2VuZXJhdGlvblBhcmFtcyYgcGFyYW1zKSB7CisgICAgICAgICAgICBBbGxvd01hY3JvU2NyYXRj aFJlZ2lzdGVyVXNhZ2UgYWxsb3dTY3JhdGNoKGppdCk7CisKKyAgICAgICAgICAgIGppdC5tb3Zl KHBhcmFtc1swXS5ncHIoKSwgcGlubmVkUmVncy5iYXNlTWVtb3J5UG9pbnRlcik7CisgICAgICAg ICAgICBmb3IgKHVpbnQzMl90IGkgPSAwOyBpIDwgcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzLnNp emUoKTsgKytpKQorICAgICAgICAgICAgICAgIGppdC5tb3ZlKHBhcmFtc1sxICsgaV0uZ3ByKCks IHBpbm5lZFJlZ3Muc2l6ZVJlZ2lzdGVyc1tpXS5zaXplUmVnaXN0ZXIpOworICAgICAgICB9KTsK KyAgICB9Cit9CisKIHZvaWQgQjNJUkdlbmVyYXRvcjo6ZW1pdEV4Y2VwdGlvbkNoZWNrKENDYWxs SGVscGVycyYgaml0LCBFeGNlcHRpb25UeXBlIHR5cGUpCiB7CiAgICAgaml0Lm1vdmUoQ0NhbGxI ZWxwZXJzOjpUcnVzdGVkSW1tMzIoc3RhdGljX2Nhc3Q8dWludDMyX3Q+KHR5cGUpKSwgR1BSSW5m bzo6YXJndW1lbnRHUFIxKTsKQEAgLTMzOCw0OSArMzkxLDYgQEAgYXV0byBCM0lSR2VuZXJhdG9y OjphZGRVbnJlYWNoYWJsZSgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICByZXR1cm4geyB9OwogfQog Ci1zdGF0aWMgdm9pZCByZWxvYWRQaW5uZWRSZWdpc3RlcnMoUHJvY2VkdXJlJiBwcm9jLCBCYXNp Y0Jsb2NrKiBibG9jaywgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFZhbHVlKiBpbnN0 YW5jZSkKLXsKLSAgICBpZiAoIWluZm8uaGFzTWVtb3J5KCkpCi0gICAgICAgIHJldHVybjsKLQot ICAgIGNvbnN0IE1lbW9yeUluZm9ybWF0aW9uKiBtZW1vcnkgPSAmaW5mby5tZW1vcnk7Ci0KLSAg ICBSZWdpc3RlclNldCBjbG9iYmVyczsKLSAgICBjbG9iYmVycy5zZXQobWVtb3J5LT5waW5uZWRS ZWdpc3RlcnMoKS5iYXNlTWVtb3J5UG9pbnRlcik7Ci0gICAgZm9yIChhdXRvIGluZm8gOiBtZW1v cnktPnBpbm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnMpCi0gICAgICAgIGNsb2JiZXJzLnNl dChpbmZvLnNpemVSZWdpc3Rlcik7Ci0KLSAgICBCMzo6UGF0Y2hwb2ludFZhbHVlKiBwYXRjaHBv aW50ID0gYmxvY2stPmFwcGVuZE5ldzxCMzo6UGF0Y2hwb2ludFZhbHVlPihwcm9jLCBCMzo6Vm9p ZCwgT3JpZ2luKCkpOwotICAgIHBhdGNocG9pbnQtPmVmZmVjdHMgPSBFZmZlY3RzOjpub25lKCk7 Ci0gICAgcGF0Y2hwb2ludC0+ZWZmZWN0cy53cml0ZXNQaW5uZWQgPSB0cnVlOwotICAgIHBhdGNo cG9pbnQtPmNsb2JiZXIoY2xvYmJlcnMpOwotICAgIHBhdGNocG9pbnQtPm51bUdQU2NyYXRjaFJl Z2lzdGVycyA9IDE7Ci0KLSAgICBwYXRjaHBvaW50LT5hcHBlbmQoaW5zdGFuY2UsIFZhbHVlUmVw OjpTb21lUmVnaXN0ZXIpOwotCi0gICAgcGF0Y2hwb2ludC0+c2V0R2VuZXJhdG9yKFttZW1vcnld IChDQ2FsbEhlbHBlcnMmIGppdCwgY29uc3QgQjM6OlN0YWNrbWFwR2VuZXJhdGlvblBhcmFtcyYg cGFyYW1zKSB7Ci0gICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1Nj cmF0Y2goaml0KTsKLQotICAgICAgICBHUFJSZWcgc2NyYXRjaCA9IHBhcmFtcy5ncFNjcmF0Y2go MCk7Ci0gICAgICAgIGppdC5sb2FkUHRyKENDYWxsSGVscGVyczo6QWRkcmVzcyhwYXJhbXNbMF0u Z3ByKCksIEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZNZW1vcnkoKSksIHNjcmF0Y2gp OwotICAgICAgICBqaXQubG9hZFB0cihDQ2FsbEhlbHBlcnM6OkFkZHJlc3Moc2NyYXRjaCwgSlNX ZWJBc3NlbWJseU1lbW9yeTo6b2Zmc2V0T2ZNZW1vcnkoKSksIHNjcmF0Y2gpOwotICAgICAgICBq aXQubG9hZFB0cihDQ2FsbEhlbHBlcnM6OkFkZHJlc3Moc2NyYXRjaCwgTWVtb3J5OjpvZmZzZXRP Zk1lbW9yeSgpKSwgbWVtb3J5LT5waW5uZWRSZWdpc3RlcnMoKS5iYXNlTWVtb3J5UG9pbnRlcik7 Ci0KLSAgICAgICAgaml0LmxvYWQ2NChDQ2FsbEhlbHBlcnM6OkFkZHJlc3Moc2NyYXRjaCwgTWVt b3J5OjpvZmZzZXRPZlNpemUoKSksIHNjcmF0Y2gpOwotICAgICAgICBmb3IgKHVuc2lnbmVkIGkg PSAwOyBpIDwgbWVtb3J5LT5waW5uZWRSZWdpc3RlcnMoKS5zaXplUmVnaXN0ZXJzLnNpemUoKTsg aSsrKSB7Ci0gICAgICAgICAgICBHUFJSZWcgc2l6ZVJlZyA9IG1lbW9yeS0+cGlubmVkUmVnaXN0 ZXJzKCkuc2l6ZVJlZ2lzdGVyc1tpXS5zaXplUmVnaXN0ZXI7Ci0gICAgICAgICAgICBqaXQubW92 ZShzY3JhdGNoLCBzaXplUmVnKTsKLSAgICAgICAgICAgIGppdC5zdWI2NChDQ2FsbEhlbHBlcnM6 OlRydXN0ZWRJbW0zMihtZW1vcnktPnBpbm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnNbaV0u c2l6ZU9mZnNldCksIHNpemVSZWcpOwotICAgICAgICB9Ci0gICAgfSk7Ci19Ci0KLXZvaWQgQjNJ UkdlbmVyYXRvcjo6ZW1pdFJlbG9hZFBpbm5lZFJlZ2lzdGVycygpCi17Ci0gICAgcmVsb2FkUGlu bmVkUmVnaXN0ZXJzKG1fcHJvYywgbV9jdXJyZW50QmxvY2ssIG1faW5mbywgbV9pbnN0YW5jZVZh bHVlKTsKLX0KLQotCiBhdXRvIEIzSVJHZW5lcmF0b3I6OmFkZEdyb3dNZW1vcnkoRXhwcmVzc2lv blR5cGUgZGVsdGEsIEV4cHJlc3Npb25UeXBlJiByZXN1bHQpIC0+IFBhcnRpYWxSZXN1bHQKIHsK ICAgICBpbnQzMl90ICgqZ3Jvd01lbW9yeSkgKEV4ZWNTdGF0ZSosIGludDMyX3QpID0gW10gKEV4 ZWNTdGF0ZSogZXhlYywgaW50MzJfdCBkZWx0YSkgLT4gaW50MzJfdCB7CkBAIC0zODksNyArMzk5 LDYgQEAgYXV0byBCM0lSR2VuZXJhdG9yOjphZGRHcm93TWVtb3J5KEV4cHJlc3Npb25UeXBlIGRl bHRhLCBFeHByZXNzaW9uVHlwZSYgcmVzdWx0KQogCiAgICAgICAgIEpTV2ViQXNzZW1ibHlJbnN0 YW5jZSogaW5zdGFuY2UgPSB2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2U7CiAgICAgICAgIEpT V2ViQXNzZW1ibHlNZW1vcnkqIHdhc21NZW1vcnkgPSBpbnN0YW5jZS0+bWVtb3J5KCk7Ci0gICAg ICAgIFJFTEVBU0VfQVNTRVJUKHdhc21NZW1vcnkpOyAvLyBUaGlzIHdvdWxkIGZhaWwgdmFsaWRh dGlvbiBvdGhlcndpc2UuCiAKICAgICAgICAgaWYgKGRlbHRhIDwgMCkKICAgICAgICAgICAgIHJl dHVybiAtMTsKQEAgLTQwNywyMSArNDE2LDE5IEBAIGF1dG8gQjNJUkdlbmVyYXRvcjo6YWRkR3Jv d01lbW9yeShFeHByZXNzaW9uVHlwZSBkZWx0YSwgRXhwcmVzc2lvblR5cGUmIHJlc3VsdCkKICAg ICAgICAgbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxDb25zdFB0clZhbHVlPihtX3Byb2MsIE9y aWdpbigpLCBiaXR3aXNlX2Nhc3Q8dm9pZCo+KGdyb3dNZW1vcnkpKSwKICAgICAgICAgbV9jdXJy ZW50QmxvY2stPmFwcGVuZE5ldzxCMzo6VmFsdWU+KG1fcHJvYywgQjM6OkZyYW1lUG9pbnRlciwg T3JpZ2luKCkpLCBkZWx0YSk7CiAKLSAgICBlbWl0UmVsb2FkUGlubmVkUmVnaXN0ZXJzKCk7Cisg ICAgcmVzdG9yZVdlYkFzc2VtYmx5R2xvYmFsU3RhdGUobV92bSwgbV9pbmZvLm1lbW9yeSwgbV9p bnN0YW5jZVZhbHVlLCBtX3Byb2MsIG1fY3VycmVudEJsb2NrKTsKIAogICAgIHJldHVybiB7IH07 CiB9CiAKIGF1dG8gQjNJUkdlbmVyYXRvcjo6YWRkQ3VycmVudE1lbW9yeShFeHByZXNzaW9uVHlw ZSYgcmVzdWx0KSAtPiBQYXJ0aWFsUmVzdWx0CiB7Ci0gICAgVmFsdWUqIGpzTWVtb3J5ID0gbV9j dXJyZW50QmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4obV9wcm9jLCBMb2FkLCBwb2ludGVy VHlwZSgpLCBPcmlnaW4oKSwgbV9pbnN0YW5jZVZhbHVlLCBKU1dlYkFzc2VtYmx5SW5zdGFuY2U6 Om9mZnNldE9mTWVtb3J5KCkpOwotICAgIFZhbHVlKiB3YXNtTWVtb3J5ID0gbV9jdXJyZW50Qmxv Y2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4obV9wcm9jLCBMb2FkLCBwb2ludGVyVHlwZSgpLCBP cmlnaW4oKSwganNNZW1vcnksIEpTV2ViQXNzZW1ibHlNZW1vcnk6Om9mZnNldE9mTWVtb3J5KCkp OwotICAgIFZhbHVlKiBzaXplID0gbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1 ZT4obV9wcm9jLCBMb2FkLCBCMzo6SW50NjQsIE9yaWdpbigpLCB3YXNtTWVtb3J5LCBNZW1vcnk6 Om9mZnNldE9mU2l6ZSgpKTsKKyAgICBhdXRvIG1lbW9yeVZhbHVlID0gZ2V0TWVtb3J5QmFzZUFu ZFNpemUobV92bSwgbV9pbnN0YW5jZVZhbHVlLCBtX3Byb2MsIG1fY3VycmVudEJsb2NrKTsKIAog ICAgIGNvbnN0ZXhwciB1aW50MzJfdCBzaGlmdFZhbHVlID0gMTY7CiAgICAgc3RhdGljX2Fzc2Vy dChQYWdlQ291bnQ6OnBhZ2VTaXplID09IDEgPDwgc2hpZnRWYWx1ZSwgIlRoaXMgbXVzdCBob2xk IGZvciB0aGUgY29kZSBiZWxvdyB0byBiZSBjb3JyZWN0LiIpOwogICAgIFZhbHVlKiBudW1QYWdl cyA9IG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8VmFsdWU+KG1fcHJvYywgWlNociwgT3JpZ2lu KCksCi0gICAgICAgIHNpemUsIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8Q29uc3QzMlZhbHVl PihtX3Byb2MsIE9yaWdpbigpLCBzaGlmdFZhbHVlKSk7CisgICAgICAgIG1lbW9yeVZhbHVlLnNp emUsIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8Q29uc3QzMlZhbHVlPihtX3Byb2MsIE9yaWdp bigpLCBzaGlmdFZhbHVlKSk7CiAKICAgICByZXN1bHQgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5k TmV3PFZhbHVlPihtX3Byb2MsIFRydW5jLCBPcmlnaW4oKSwgbnVtUGFnZXMpOwogCkBAIC04MzIs MjYgKzgzOSw3NSBAQCBhdXRvIEIzSVJHZW5lcmF0b3I6OmFkZENhbGwodWludDMyX3QgZnVuY3Rp b25JbmRleCwgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUsCiAgICAgQVNTRVJUKHNpZ25hdHVy ZS0+YXJndW1lbnRDb3VudCgpID09IGFyZ3Muc2l6ZSgpKTsKIAogICAgIFR5cGUgcmV0dXJuVHlw ZSA9IHNpZ25hdHVyZS0+cmV0dXJuVHlwZSgpOworICAgIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dh c21DYWxsPiogdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMgPSAmbV91bmxpbmtlZFdhc21Ub1dhc21D YWxsczsKIAotICAgIHJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigpLnNldHVwQ2FsbCht X3Byb2MsIG1fY3VycmVudEJsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0dXJuVHlw ZSksCi0gICAgICAgIFsmXSAoUGF0Y2hwb2ludFZhbHVlKiBwYXRjaHBvaW50KSB7Ci0gICAgICAg ICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLndyaXRlc1Bpbm5lZCA9IHRydWU7Ci0gICAgICAgICAg ICBwYXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICBpZiAobV9pbmZv LmlzSW1wb3J0ZWRGdW5jdGlvbkZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleCkp IHsKKyAgICAgICAgLy8gRklYTUUgaW1wb3J0cyBjYW4gYmUgbGlua2VkIGhlcmUsIGluc3RlYWQg b2YgZ2VuZXJhdGluZyBhIHBhdGNocG9pbnQsIGJlY2F1c2UgYWxsIGltcG9ydCBzdHVicyBhcmUg Z2VuZXJhdGVkIGJlZm9yZSBCMyBjb21waWxhdGlvbiBzdGFydHMuIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjY0NjIKKyAgICAgICAgRXhwcmVzc2lvblR5cGUgZnVu Y3Rpb25JbXBvcnQgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihtX3By b2MsIExvYWQsIHBvaW50ZXJUeXBlKCksIE9yaWdpbigpLCBtX2luc3RhbmNlVmFsdWUsIEpTV2Vi QXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbihmdW5jdGlvbkluZGV4KSk7 CisgICAgICAgIEV4cHJlc3Npb25UeXBlIGpzVHlwZU9mSW1wb3J0ID0gbV9jdXJyZW50QmxvY2st PmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4obV9wcm9jLCBMb2FkOFosIE9yaWdpbigpLCBmdW5jdGlv bkltcG9ydCwgSlNDZWxsOjp0eXBlSW5mb1R5cGVPZmZzZXQoKSk7CisgICAgICAgIFZhbHVlKiBp c1dhc21DYWxsID0gbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxWYWx1ZT4obV9wcm9jLCBFcXVh bCwgT3JpZ2luKCksIGpzVHlwZU9mSW1wb3J0LCBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PENv bnN0MzJWYWx1ZT4obV9wcm9jLCBPcmlnaW4oKSwgV2ViQXNzZW1ibHlGdW5jdGlvblR5cGUpKTsK IAotICAgICAgICAgICAgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+KiB1bmxpbmtlZFdh c21Ub1dhc21DYWxscyA9ICZtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzOwotICAgICAgICAgICAg cGF0Y2hwb2ludC0+c2V0R2VuZXJhdG9yKFt1bmxpbmtlZFdhc21Ub1dhc21DYWxscywgZnVuY3Rp b25JbmRleF0gKENDYWxsSGVscGVycyYgaml0LCBjb25zdCBCMzo6U3RhY2ttYXBHZW5lcmF0aW9u UGFyYW1zJikgewotICAgICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2Fn ZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAgQmFzaWNCbG9jayogaXNXYXNtQmxvY2sgPSBt X3Byb2MuYWRkQmxvY2soKTsKKyAgICAgICAgQmFzaWNCbG9jayogaXNKU0Jsb2NrID0gbV9wcm9j LmFkZEJsb2NrKCk7CisgICAgICAgIEJhc2ljQmxvY2sqIGNvbnRpbnVhdGlvbiA9IG1fcHJvYy5h ZGRCbG9jaygpOworICAgICAgICBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3Q29udHJvbFZhbHVl KG1fcHJvYywgQjM6OkJyYW5jaCwgT3JpZ2luKCksIGlzV2FzbUNhbGwsIEZyZXF1ZW50ZWRCbG9j ayhpc1dhc21CbG9jayksIEZyZXF1ZW50ZWRCbG9jayhpc0pTQmxvY2spKTsKKworICAgICAgICBW YWx1ZSogd2FzbUNhbGxSZXN1bHQgPSB3YXNtQ2FsbGluZ0NvbnZlbnRpb24oKS5zZXR1cENhbGwo bV9wcm9jLCBpc1dhc21CbG9jaywgT3JpZ2luKCksIGFyZ3MsIHRvQjNUeXBlKHJldHVyblR5cGUp LAorICAgICAgICAgICAgWyZdIChQYXRjaHBvaW50VmFsdWUqIHBhdGNocG9pbnQpIHsKKyAgICAg ICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLndyaXRlc1Bpbm5lZCA9IHRydWU7CisgICAg ICAgICAgICAgICAgcGF0Y2hwb2ludC0+ZWZmZWN0cy5yZWFkc1Bpbm5lZCA9IHRydWU7CisgICAg ICAgICAgICAgICAgcGF0Y2hwb2ludC0+c2V0R2VuZXJhdG9yKFt1bmxpbmtlZFdhc21Ub1dhc21D YWxscywgZnVuY3Rpb25JbmRleF0gKENDYWxsSGVscGVycyYgaml0LCBjb25zdCBCMzo6U3RhY2tt YXBHZW5lcmF0aW9uUGFyYW1zJikgeworICAgICAgICAgICAgICAgICAgICBBbGxvd01hY3JvU2Ny YXRjaFJlZ2lzdGVyVXNhZ2UgYWxsb3dTY3JhdGNoKGppdCk7CisgICAgICAgICAgICAgICAgICAg IENDYWxsSGVscGVyczo6Q2FsbCBjYWxsID0gaml0LmNhbGwoKTsKKyAgICAgICAgICAgICAgICAg ICAgaml0LmFkZExpbmtUYXNrKFt1bmxpbmtlZFdhc21Ub1dhc21DYWxscywgY2FsbCwgZnVuY3Rp b25JbmRleF0gKExpbmtCdWZmZXImIGxpbmtCdWZmZXIpIHsKKyAgICAgICAgICAgICAgICAgICAg ICAgIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLT5hcHBlbmQoeyBsaW5rQnVmZmVyLmxvY2F0aW9u T2YoY2FsbCksIGZ1bmN0aW9uSW5kZXgsIFVubGlua2VkV2FzbVRvV2FzbUNhbGw6OlRhcmdldDo6 dG9XYXNtIH0pOworICAgICAgICAgICAgICAgICAgICB9KTsKKyAgICAgICAgICAgICAgICB9KTsK KyAgICAgICAgICAgIH0pOworICAgICAgICBVcHNpbG9uVmFsdWUqIHdhc21DYWxsUmVzdWx0VXBz aWxvbiA9IHJldHVyblR5cGUgPT0gVm9pZCA/IG51bGxwdHIgOiBpc1dhc21CbG9jay0+YXBwZW5k TmV3PFVwc2lsb25WYWx1ZT4obV9wcm9jLCBPcmlnaW4oKSwgd2FzbUNhbGxSZXN1bHQpOworICAg ICAgICBpc1dhc21CbG9jay0+YXBwZW5kTmV3Q29udHJvbFZhbHVlKG1fcHJvYywgSnVtcCwgT3Jp Z2luKCksIGNvbnRpbnVhdGlvbik7CisKKyAgICAgICAgVmFsdWUqIGpzQ2FsbFJlc3VsdCA9IHdh c21DYWxsaW5nQ29udmVudGlvbigpLnNldHVwQ2FsbChtX3Byb2MsIGlzSlNCbG9jaywgT3JpZ2lu KCksIGFyZ3MsIHRvQjNUeXBlKHJldHVyblR5cGUpLAorICAgICAgICAgICAgWyZdIChQYXRjaHBv aW50VmFsdWUqIHBhdGNocG9pbnQpIHsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZl Y3RzLndyaXRlc1Bpbm5lZCA9IHRydWU7CisgICAgICAgICAgICAgICAgcGF0Y2hwb2ludC0+ZWZm ZWN0cy5yZWFkc1Bpbm5lZCA9IHRydWU7CisgICAgICAgICAgICAgICAgcGF0Y2hwb2ludC0+c2V0 R2VuZXJhdG9yKFt1bmxpbmtlZFdhc21Ub1dhc21DYWxscywgZnVuY3Rpb25JbmRleF0gKENDYWxs SGVscGVycyYgaml0LCBjb25zdCBCMzo6U3RhY2ttYXBHZW5lcmF0aW9uUGFyYW1zJikgeworICAg ICAgICAgICAgICAgICAgICBBbGxvd01hY3JvU2NyYXRjaFJlZ2lzdGVyVXNhZ2UgYWxsb3dTY3Jh dGNoKGppdCk7CisgICAgICAgICAgICAgICAgICAgIENDYWxsSGVscGVyczo6Q2FsbCBjYWxsID0g aml0LmNhbGwoKTsKKyAgICAgICAgICAgICAgICAgICAgaml0LmFkZExpbmtUYXNrKFt1bmxpbmtl ZFdhc21Ub1dhc21DYWxscywgY2FsbCwgZnVuY3Rpb25JbmRleF0gKExpbmtCdWZmZXImIGxpbmtC dWZmZXIpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIHVubGlua2VkV2FzbVRvV2FzbUNhbGxz LT5hcHBlbmQoeyBsaW5rQnVmZmVyLmxvY2F0aW9uT2YoY2FsbCksIGZ1bmN0aW9uSW5kZXgsIFVu bGlua2VkV2FzbVRvV2FzbUNhbGw6OlRhcmdldDo6dG9KUyB9KTsKKyAgICAgICAgICAgICAgICAg ICAgfSk7CisgICAgICAgICAgICAgICAgfSk7CisgICAgICAgICAgICB9KTsKKyAgICAgICAgVXBz aWxvblZhbHVlKiBqc0NhbGxSZXN1bHRVcHNpbG9uID0gcmV0dXJuVHlwZSA9PSBWb2lkID8gbnVs bHB0ciA6IGlzSlNCbG9jay0+YXBwZW5kTmV3PFVwc2lsb25WYWx1ZT4obV9wcm9jLCBPcmlnaW4o KSwganNDYWxsUmVzdWx0KTsKKyAgICAgICAgaXNKU0Jsb2NrLT5hcHBlbmROZXdDb250cm9sVmFs dWUobV9wcm9jLCBKdW1wLCBPcmlnaW4oKSwgY29udGludWF0aW9uKTsKIAotICAgICAgICAgICAg ICAgIENDYWxsSGVscGVyczo6Q2FsbCBjYWxsID0gaml0LmNhbGwoKTsKKyAgICAgICAgbV9jdXJy ZW50QmxvY2sgPSBjb250aW51YXRpb247CiAKLSAgICAgICAgICAgICAgICBqaXQuYWRkTGlua1Rh c2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4XSAoTGlua0J1 ZmZlciYgbGlua0J1ZmZlcikgewotICAgICAgICAgICAgICAgICAgICB1bmxpbmtlZFdhc21Ub1dh c21DYWxscy0+YXBwZW5kKHsgbGlua0J1ZmZlci5sb2NhdGlvbk9mKGNhbGwpLCBmdW5jdGlvbklu ZGV4IH0pOworICAgICAgICBpZiAocmV0dXJuVHlwZSA9PSBWb2lkKQorICAgICAgICAgICAgcmVz dWx0ID0gbnVsbHB0cjsKKyAgICAgICAgZWxzZSB7CisgICAgICAgICAgICByZXN1bHQgPSBjb250 aW51YXRpb24tPmFwcGVuZE5ldzxWYWx1ZT4obV9wcm9jLCBQaGksIHRvQjNUeXBlKHJldHVyblR5 cGUpLCBPcmlnaW4oKSk7CisgICAgICAgICAgICB3YXNtQ2FsbFJlc3VsdFVwc2lsb24tPnNldFBo aShyZXN1bHQpOworICAgICAgICAgICAganNDYWxsUmVzdWx0VXBzaWxvbi0+c2V0UGhpKHJlc3Vs dCk7CisgICAgICAgIH0KKworICAgICAgICAvLyBUaGUgY2FsbCBjb3VsZCBoYXZlIGJlZW4gdG8g YW5vdGhlciBXZWJBc3NlbWJseSBpbnN0YW5jZSwgYW5kIC8gb3IgY291bGQgaGF2ZSBtb2RpZmll ZCBvdXIgTWVtb3J5LgorICAgICAgICByZXN0b3JlV2ViQXNzZW1ibHlHbG9iYWxTdGF0ZShtX3Zt LCBtX2luZm8ubWVtb3J5LCBtX2luc3RhbmNlVmFsdWUsIG1fcHJvYywgY29udGludWF0aW9uKTsK KyAgICB9IGVsc2UgeworICAgICAgICByZXN1bHQgPSB3YXNtQ2FsbGluZ0NvbnZlbnRpb24oKS5z ZXR1cENhbGwobV9wcm9jLCBtX2N1cnJlbnRCbG9jaywgT3JpZ2luKCksIGFyZ3MsIHRvQjNUeXBl KHJldHVyblR5cGUpLAorICAgICAgICAgICAgWyZdIChQYXRjaHBvaW50VmFsdWUqIHBhdGNocG9p bnQpIHsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLndyaXRlc1Bpbm5lZCA9 IHRydWU7CisgICAgICAgICAgICAgICAgcGF0Y2hwb2ludC0+ZWZmZWN0cy5yZWFkc1Bpbm5lZCA9 IHRydWU7CisgICAgICAgICAgICAgICAgcGF0Y2hwb2ludC0+c2V0R2VuZXJhdG9yKFt1bmxpbmtl ZFdhc21Ub1dhc21DYWxscywgZnVuY3Rpb25JbmRleF0gKENDYWxsSGVscGVycyYgaml0LCBjb25z dCBCMzo6U3RhY2ttYXBHZW5lcmF0aW9uUGFyYW1zJikgeworICAgICAgICAgICAgICAgICAgICBB bGxvd01hY3JvU2NyYXRjaFJlZ2lzdGVyVXNhZ2UgYWxsb3dTY3JhdGNoKGppdCk7CisgICAgICAg ICAgICAgICAgICAgIENDYWxsSGVscGVyczo6Q2FsbCBjYWxsID0gaml0LmNhbGwoKTsKKyAgICAg ICAgICAgICAgICAgICAgaml0LmFkZExpbmtUYXNrKFt1bmxpbmtlZFdhc21Ub1dhc21DYWxscywg Y2FsbCwgZnVuY3Rpb25JbmRleF0gKExpbmtCdWZmZXImIGxpbmtCdWZmZXIpIHsKKyAgICAgICAg ICAgICAgICAgICAgICAgIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLT5hcHBlbmQoeyBsaW5rQnVm ZmVyLmxvY2F0aW9uT2YoY2FsbCksIGZ1bmN0aW9uSW5kZXgsIFVubGlua2VkV2FzbVRvV2FzbUNh bGw6OlRhcmdldDo6dG9XYXNtIH0pOworICAgICAgICAgICAgICAgICAgICB9KTsKICAgICAgICAg ICAgICAgICB9KTsKICAgICAgICAgICAgIH0pOwotICAgICAgICB9KTsKLQotICAgIGlmIChmdW5j dGlvbkluZGV4IDwgbV9pbmZvLmltcG9ydEZ1bmN0aW9uQ291bnQoKSkKLSAgICAgICAgZW1pdFJl bG9hZFBpbm5lZFJlZ2lzdGVycygpOworICAgIH0KIAogICAgIHJldHVybiB7IH07CiB9CkBAIC05 MjksNyArOTg1LDggQEAgYXV0byBCM0lSR2VuZXJhdG9yOjphZGRDYWxsSW5kaXJlY3QoY29uc3Qg U2lnbmF0dXJlKiBzaWduYXR1cmUsIFNpZ25hdHVyZUluZGV4IHMKICAgICAgICAgICAgIH0pOwog ICAgICAgICB9KTsKIAotICAgIGVtaXRSZWxvYWRQaW5uZWRSZWdpc3RlcnMoKTsKKyAgICAvLyBU aGUgY2FsbCBjb3VsZCBoYXZlIGJlZW4gdG8gYW5vdGhlciBXZWJBc3NlbWJseSBpbnN0YW5jZSwg YW5kIC8gb3IgY291bGQgaGF2ZSBtb2RpZmllZCBvdXIgTWVtb3J5LgorICAgIHJlc3RvcmVXZWJB c3NlbWJseUdsb2JhbFN0YXRlKG1fdm0sIG1faW5mby5tZW1vcnksIG1faW5zdGFuY2VWYWx1ZSwg bV9wcm9jLCBtX2N1cnJlbnRCbG9jayk7CiAKICAgICByZXR1cm4geyB9OwogfQpAQCAtOTk4LDEy ICsxMDU1LDEwIEBAIHN0YXRpYyB2b2lkIGNyZWF0ZUpTVG9XYXNtV3JhcHBlcihWTSYgdm0sIENv bXBpbGF0aW9uQ29udGV4dCYgY29tcGlsYXRpb25Db250ZXh0CiAgICAgICAgIH0pOwogICAgIH0K IAotICAgIC8vIE1vdmUgbWVtb3J5IHZhbHVlcyB0byB0aGUgYXBwcm9yaWF0ZSBwbGFjZXMsIGlm IG5lZWRlZC4KLSAgICB7Ci0gICAgICAgIFZhbHVlKiBpbnN0YW5jZSA9IGJsb2NrLT5hcHBlbmRO ZXc8TWVtb3J5VmFsdWU+KHByb2MsIExvYWQsIHBvaW50ZXJUeXBlKCksIE9yaWdpbigpLAotICAg ICAgICAgICAgYmxvY2stPmFwcGVuZE5ldzxDb25zdFB0clZhbHVlPihwcm9jLCBPcmlnaW4oKSwg JnZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZSkpOwotICAgICAgICByZWxvYWRQaW5uZWRSZWdp c3RlcnMocHJvYywgYmxvY2ssIGluZm8sIGluc3RhbmNlKTsKLSAgICB9CisgICAgLy8gRklYTUUg VGhlIGluc3RhbmNlIGlzIGN1cnJlbnRseSBzZXQgYnkgdGhlIEMrKyBjb2RlIGluIFdlYkFzc2Vt Ymx5RnVuY3Rpb246OmNhbGwuIFdlIHNob3VsZG4ndCBnbyB0aHJvdWdoIHRoZSBleHRyYSBDKysg aG9vcC4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NjQ4NgorICAg IFZhbHVlKiBpbnN0YW5jZSA9IGJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KHByb2MsIExv YWQsIHBvaW50ZXJUeXBlKCksIE9yaWdpbigpLAorICAgICAgICBibG9jay0+YXBwZW5kTmV3PENv bnN0UHRyVmFsdWU+KHByb2MsIE9yaWdpbigpLCAmdm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNl KSk7CisgICAgcmVzdG9yZVdlYkFzc2VtYmx5R2xvYmFsU3RhdGUodm0sIGluZm8ubWVtb3J5LCBp bnN0YW5jZSwgcHJvYywgYmxvY2spOwogCiAgICAgLy8gR2V0IG91ciBhcmd1bWVudHMuCiAgICAg VmVjdG9yPFZhbHVlKj4gYXJndW1lbnRzOwpAQCAtMTA0Niw3ICsxMTAxLDcgQEAgc3RhdGljIHZv aWQgY3JlYXRlSlNUb1dhc21XcmFwcGVyKFZNJiB2bSwgQ29tcGlsYXRpb25Db250ZXh0JiBjb21w aWxhdGlvbkNvbnRleHQKICAgICBmdW5jdGlvbi5qc1RvV2FzbUVudHJ5cG9pbnQuY2FsbGVlU2F2 ZVJlZ2lzdGVycyA9IHByb2MuY2FsbGVlU2F2ZVJlZ2lzdGVycygpOwogfQogCi1FeHBlY3RlZDxz dGQ6OnVuaXF1ZV9wdHI8V2FzbUludGVybmFsRnVuY3Rpb24+LCBTdHJpbmc+IHBhcnNlQW5kQ29t cGlsZShWTSYgdm0sIENvbXBpbGF0aW9uQ29udGV4dCYgY29tcGlsYXRpb25Db250ZXh0LCBjb25z dCB1aW50OF90KiBmdW5jdGlvblN0YXJ0LCBzaXplX3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNp Z25hdHVyZSogc2lnbmF0dXJlLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mIHVubGlu a2VkV2FzbVRvV2FzbUNhbGxzLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIGZ1 bmN0aW9uSW5kZXhTcGFjZSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIHVuc2lnbmVk IG9wdExldmVsKQorRXhwZWN0ZWQ8c3RkOjp1bmlxdWVfcHRyPFdhc21JbnRlcm5hbEZ1bmN0aW9u PiwgU3RyaW5nPiBwYXJzZUFuZENvbXBpbGUoVk0mIHZtLCBDb21waWxhdGlvbkNvbnRleHQmIGNv bXBpbGF0aW9uQ29udGV4dCwgY29uc3QgdWludDhfdCogZnVuY3Rpb25TdGFydCwgc2l6ZV90IGZ1 bmN0aW9uTGVuZ3RoLCBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSwgVmVjdG9yPFVubGlua2Vk V2FzbVRvV2FzbUNhbGw+JiB1bmxpbmtlZFdhc21Ub1dhc21DYWxscywgY29uc3QgTW9kdWxlSW5m b3JtYXRpb24mIGluZm8sIGNvbnN0IFZlY3RvcjxTaWduYXR1cmVJbmRleD4mIG1vZHVsZVNpZ25h dHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzLCB1bnNpZ25lZCBvcHRMZXZlbCkK IHsKICAgICBhdXRvIHJlc3VsdCA9IHN0ZDo6bWFrZV91bmlxdWU8V2FzbUludGVybmFsRnVuY3Rp b24+KCk7CiAKQEAgLTEwNTQsOCArMTEwOSw4IEBAIEV4cGVjdGVkPHN0ZDo6dW5pcXVlX3B0cjxX YXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0cmluZz4gcGFyc2VBbmRDb21waWxlKFZNJiB2bSwKICAg ICBjb21waWxhdGlvbkNvbnRleHQud2FzbUVudHJ5cG9pbnRKSVQgPSBzdGQ6Om1ha2VfdW5pcXVl PENDYWxsSGVscGVycz4oJnZtKTsKIAogICAgIFByb2NlZHVyZSBwcm9jZWR1cmU7Ci0gICAgQjNJ UkdlbmVyYXRvciBjb250ZXh0KHZtLCBpbmZvLCBwcm9jZWR1cmUsIHJlc3VsdC5nZXQoKSwgdW5s aW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGZ1bmN0aW9uSW5kZXhTcGFjZSk7Ci0gICAgRnVuY3Rpb25Q YXJzZXI8QjNJUkdlbmVyYXRvcj4gcGFyc2VyKCZ2bSwgY29udGV4dCwgZnVuY3Rpb25TdGFydCwg ZnVuY3Rpb25MZW5ndGgsIHNpZ25hdHVyZSwgZnVuY3Rpb25JbmRleFNwYWNlLCBpbmZvKTsKKyAg ICBCM0lSR2VuZXJhdG9yIGNvbnRleHQodm0sIGluZm8sIHByb2NlZHVyZSwgcmVzdWx0LmdldCgp LCB1bmxpbmtlZFdhc21Ub1dhc21DYWxscyk7CisgICAgRnVuY3Rpb25QYXJzZXI8QjNJUkdlbmVy YXRvcj4gcGFyc2VyKCZ2bSwgY29udGV4dCwgZnVuY3Rpb25TdGFydCwgZnVuY3Rpb25MZW5ndGgs IHNpZ25hdHVyZSwgaW5mbywgbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVy ZUluZGljZXMpOwogICAgIFdBU01fRkFJTF9JRl9IRUxQRVJfRkFJTFMocGFyc2VyLnBhcnNlKCkp OwogCiAgICAgcHJvY2VkdXJlLnJlc2V0UmVhY2hhYmlsaXR5KCk7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5oIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuaAppbmRleCBiNWM5ZjQ2Li4yNDlkNTc4 IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRv ci5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmgK QEAgLTQ3LDcgKzQ3LDcgQEAgc3RydWN0IENvbXBpbGF0aW9uQ29udGV4dCB7CiAgICAgQ0NhbGxI ZWxwZXJzOjpDYWxsIGpzRW50cnlwb2ludFRvV2FzbUVudHJ5cG9pbnRDYWxsOwogfTsKIAotRXhw ZWN0ZWQ8c3RkOjp1bmlxdWVfcHRyPFdhc21JbnRlcm5hbEZ1bmN0aW9uPiwgU3RyaW5nPiBwYXJz ZUFuZENvbXBpbGUoVk0mLCBDb21waWxhdGlvbkNvbnRleHQmLCBjb25zdCB1aW50OF90Kiwgc2l6 ZV90LCBjb25zdCBTaWduYXR1cmUqLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mLCBj b25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlv biYsIHVuc2lnbmVkIG9wdExldmVsID0gMSk7CitFeHBlY3RlZDxzdGQ6OnVuaXF1ZV9wdHI8V2Fz bUludGVybmFsRnVuY3Rpb24+LCBTdHJpbmc+IHBhcnNlQW5kQ29tcGlsZShWTSYsIENvbXBpbGF0 aW9uQ29udGV4dCYsIGNvbnN0IHVpbnQ4X3QqLCBzaXplX3QsIGNvbnN0IFNpZ25hdHVyZSosIFZl Y3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiwg Y29uc3QgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiYsIHVuc2lnbmVkIG9wdExldmVsID0gMSk7CiAK IH0gfSAvLyBuYW1lc3BhY2UgSlNDOjpXYXNtCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21CaW5kaW5nLmNwcAppbmRleCAwZTU5MjQ3Li45YmI2YTc0IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5jcHAKKysrIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuY3BwCkBAIC0zNiwxMyArMzYsMjEgQEAKIAogbmFt ZXNwYWNlIEpTQyB7IG5hbWVzcGFjZSBXYXNtIHsKIAotV2FzbVRvSlNTdHViIGltcG9ydFN0dWJH ZW5lcmF0b3IoVk0qIHZtLCBCYWc8Q2FsbExpbmtJbmZvPiYgY2FsbExpbmtJbmZvcywgU2lnbmF0 dXJlSW5kZXggc2lnbmF0dXJlSW5kZXgsIHVuc2lnbmVkIGltcG9ydEluZGV4KQordHlwZWRlZiBB c3NlbWJseUhlbHBlcnMgSklUOworCitzdGF0aWMgdm9pZCBtYXRlcmlhbGl6ZUltcG9ydEpTQ2Vs bChWTSogdm0sIEpJVCYgaml0LCB1bnNpZ25lZCBpbXBvcnRJbmRleCwgR1BSUmVnIGdwcikKK3sK KyAgICAvLyBFYWNoIEpTIC0+IHdhc20gZW50cnkgc2V0cyB0aGUgV2ViQXNzZW1ibHkuSW5zdGFu Y2Ugd2hvc2UgZXhwb3J0IGlzIGJlaW5nIGNhbGxlZC4gV2UncmUgY2FsbGluZyBvdXQgb2YgdGhp cyBJbnN0YW5jZSwgYW5kIGNhbiB0aGVyZWZvcmUgZmlndXJlIG91dCB0aGUgaW1wb3J0IGJlaW5n IGNhbGxlZC4KKyAgICBqaXQubG9hZFB0cigmdm0tPnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZSwg Z3ByKTsKKyAgICBqaXQubG9hZFB0cihKSVQ6OkFkZHJlc3MoZ3ByLCBKU1dlYkFzc2VtYmx5SW5z dGFuY2U6Om9mZnNldE9mSW1wb3J0RnVuY3Rpb24oaW1wb3J0SW5kZXgpKSwgZ3ByKTsKK30KKwor c3RhdGljIE1hY3JvQXNzZW1ibGVyQ29kZVJlZiB3YXNtVG9KUyhWTSogdm0sIEJhZzxDYWxsTGlu a0luZm8+JiBjYWxsTGlua0luZm9zLCBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCwgdW5z aWduZWQgaW1wb3J0SW5kZXgpCiB7CiAgICAgY29uc3QgV2FzbUNhbGxpbmdDb252ZW50aW9uJiB3 YXNtQ0MgPSB3YXNtQ2FsbGluZ0NvbnZlbnRpb24oKTsKICAgICBjb25zdCBKU0NDYWxsaW5nQ29u dmVudGlvbiYganNDQyA9IGpzY0NhbGxpbmdDb252ZW50aW9uKCk7CiAgICAgY29uc3QgU2lnbmF0 dXJlKiBzaWduYXR1cmUgPSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KHZtLCBzaWduYXR1cmVJ bmRleCk7CiAgICAgdW5zaWduZWQgYXJnQ291bnQgPSBzaWduYXR1cmUtPmFyZ3VtZW50Q291bnQo KTsKLSAgICB0eXBlZGVmIEFzc2VtYmx5SGVscGVycyBKSVQ7CiAgICAgSklUIGppdCh2bSwgbnVs bHB0cik7CiAKICAgICAvLyBCZWxvdywgd2UgYXNzdW1lIHRoYXQgdGhlIEpTIGNhbGxpbmcgY29u dmVudGlvbiBpcyBhbHdheXMgb24gdGhlIHN0YWNrLgpAQCAtMTM4LDkgKzE0Niw3IEBAIFdhc21U b0pTU3R1YiBpbXBvcnRTdHViR2VuZXJhdG9yKFZNKiB2bSwgQmFnPENhbGxMaW5rSW5mbz4mIGNh bGxMaW5rSW5mb3MsIFNpZ25hCiAgICAgR1BSUmVnIGltcG9ydEpTQ2VsbEdQUlJlZyA9IEdQUklu Zm86OnJlZ1QwOyAvLyBDYWxsZWUgbmVlZHMgdG8gYmUgaW4gcmVnVDAgZm9yIHNsb3cgcGF0aCBi ZWxvdy4KICAgICBBU1NFUlQoIXdhc21DQy5tX2NhbGxlZVNhdmVSZWdpc3RlcnMuZ2V0KGltcG9y dEpTQ2VsbEdQUlJlZykpOwogCi0gICAgLy8gRWFjaCBKUyAtPiB3YXNtIGVudHJ5IHNldHMgdGhl IFdlYkFzc2VtYmx5Lkluc3RhbmNlIHdob3NlIGV4cG9ydCBpcyBiZWluZyBjYWxsZWQuIFdlJ3Jl IGNhbGxpbmcgb3V0IG9mIHRoaXMgSW5zdGFuY2UsIGFuZCBjYW4gdGhlcmVmb3JlIGZpZ3VyZSBv dXQgdGhlIGltcG9ydCBiZWluZyBjYWxsZWQuCi0gICAgaml0LmxvYWRQdHIoJnZtLT50b3BKU1dl YkFzc2VtYmx5SW5zdGFuY2UsIGltcG9ydEpTQ2VsbEdQUlJlZyk7Ci0gICAgaml0LmxvYWRQdHIo SklUOjpBZGRyZXNzKGltcG9ydEpTQ2VsbEdQUlJlZywgSlNXZWJBc3NlbWJseUluc3RhbmNlOjpv ZmZzZXRPZkltcG9ydEZ1bmN0aW9uKGltcG9ydEluZGV4KSksIGltcG9ydEpTQ2VsbEdQUlJlZyk7 CisgICAgbWF0ZXJpYWxpemVJbXBvcnRKU0NlbGwodm0sIGppdCwgaW1wb3J0SW5kZXgsIGltcG9y dEpTQ2VsbEdQUlJlZyk7CiAKICAgICB1aW50NjRfdCB0aGlzQXJndW1lbnQgPSBWYWx1ZVVuZGVm aW5lZDsgLy8gRklYTUUgd2hhdCBkb2VzIHRoZSBXZWJBc3NlbWJseSBzcGVjIHNheSB0aGlzIHNo b3VsZCBiZT8gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NTQ3MQog ICAgIGppdC5zdG9yZTY0KGltcG9ydEpTQ2VsbEdQUlJlZywgY2FsbGVlRnJhbWUud2l0aE9mZnNl dChDYWxsRnJhbWVTbG90OjpjYWxsZWUgKiBzdGF0aWNfY2FzdDxpbnQ+KHNpemVvZihSZWdpc3Rl cikpKSk7CkBAIC0yMzEsNyArMjM3LDU2IEBAIFdhc21Ub0pTU3R1YiBpbXBvcnRTdHViR2VuZXJh dG9yKFZNKiB2bSwgQmFnPENhbGxMaW5rSW5mbz4mIGNhbGxMaW5rSW5mb3MsIFNpZ25hCiAgICAg Q29kZUxvY2F0aW9uTGFiZWwgaG90UGF0aEJlZ2luKHBhdGNoQnVmZmVyLmxvY2F0aW9uT2YodGFy Z2V0VG9DaGVjaykpOwogICAgIENvZGVMb2NhdGlvbk5lYXJDYWxsIGhvdFBhdGhPdGhlciA9IHBh dGNoQnVmZmVyLmxvY2F0aW9uT2ZOZWFyQ2FsbChmYXN0Q2FsbCk7CiAgICAgY2FsbExpbmtJbmZv LT5zZXRDYWxsTG9jYXRpb25zKGNhbGxSZXR1cm5Mb2NhdGlvbiwgaG90UGF0aEJlZ2luLCBob3RQ YXRoT3RoZXIpOwotICAgIHJldHVybiBGSU5BTElaRV9DT0RFKHBhdGNoQnVmZmVyLCAoIldlYkFz c2VtYmx5IGltcG9ydFslaV0gc3R1YiBmb3Igc2lnbmF0dXJlICVpIiwgaW1wb3J0SW5kZXgsIHNp Z25hdHVyZUluZGV4KSk7CisgICAgU3RyaW5nIHNpZ25hdHVyZURlc2NyaXB0aW9uID0gU2lnbmF0 dXJlSW5mb3JtYXRpb246OmdldCh2bSwgc2lnbmF0dXJlSW5kZXgpLT50b1N0cmluZygpOworICAg IHJldHVybiBGSU5BTElaRV9DT0RFKHBhdGNoQnVmZmVyLCAoIldlYkFzc2VtYmx5LT5KYXZhU2Ny aXB0IGltcG9ydFslaV0gJXMiLCBpbXBvcnRJbmRleCwgc2lnbmF0dXJlRGVzY3JpcHRpb24uYXNj aWkoKS5kYXRhKCkpKTsKK30KKworc3RhdGljIE1hY3JvQXNzZW1ibGVyQ29kZVJlZiB3YXNtVG9X YXNtKFZNKiB2bSwgdW5zaWduZWQgaW1wb3J0SW5kZXgpCit7CisgICAgY29uc3QgUGlubmVkUmVn aXN0ZXJJbmZvJiBwaW5uZWRSZWdzID0gUGlubmVkUmVnaXN0ZXJJbmZvOjpnZXQoKTsKKyAgICBK SVQgaml0KHZtLCBudWxscHRyKTsKKworICAgIEdQUlJlZyBzY3JhdGNoID0gR1BSSW5mbzo6bm9u UHJlc2VydmVkTm9uQXJndW1lbnRHUFI7CisKKyAgICAvLyBCMydzIGNhbGwgY29kZWdlbiBlbnN1 cmVzIHRoYXQgdGhlIEpTQ2VsbCBpcyBhIFdlYkFzc2VtYmx5RnVuY3Rpb24uCisgICAgbWF0ZXJp YWxpemVJbXBvcnRKU0NlbGwodm0sIGppdCwgaW1wb3J0SW5kZXgsIHNjcmF0Y2gpOworCisgICAg Ly8gR2V0IHRoZSBjYWxsZWUncyBXZWJBc3NlbWJseS5JbnN0YW5jZSBhbmQgc2V0IGl0IGFzIHZt LnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZS4gVGhlIGNhbGxlciB3aWxsIHRha2UgY2FyZSBvZiBy ZXN0b3JpbmcgaXRzIG93biBJbnN0YW5jZS4KKyAgICBHUFJSZWcgYmFzZU1lbW9yeSA9IHBpbm5l ZFJlZ3MuYmFzZU1lbW9yeVBvaW50ZXI7CisgICAgQVNTRVJUKGJhc2VNZW1vcnkgIT0gc2NyYXRj aCk7CisgICAgaml0LmxvYWRQdHIoSklUOjpBZGRyZXNzKHNjcmF0Y2gsIFdlYkFzc2VtYmx5RnVu Y3Rpb246Om9mZnNldE9mSW5zdGFuY2UoKSksIGJhc2VNZW1vcnkpOyAvLyBJbnN0YW5jZSouCisg ICAgaml0LnN0b3JlUHRyKGJhc2VNZW1vcnksICZ2bS0+dG9wSlNXZWJBc3NlbWJseUluc3RhbmNl KTsKKworICAgIC8vIEZJWE1FIHRoZSBmb2xsb3dpbmcgY29kZSBhc3N1bWVzIHRoYXQgYWxsIFdl YkFzc2VtYmx5Lkluc3RhbmNlIGhhdmUgdGhlIHNhbWUgcGlubmVkIHJlZ2lzdGVycy4gaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2Mjk1MgorICAgIC8vIFNldCB1cCB0 aGUgY2FsbGVlJ3MgYmFzZU1lbW9yeSByZWdpc3RlciBhcyB3ZWxsIGFzIHRoZSBtZW1vcnkgc2l6 ZSByZWdpc3RlcnMuCisgICAgaml0LmxvYWRQdHIoSklUOjpBZGRyZXNzKGJhc2VNZW1vcnksIEpT V2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZNZW1vcnkoKSksIGJhc2VNZW1vcnkpOyAvLyBK U1dlYkFzc2VtYmx5TWVtb3J5Ki4KKyAgICBjb25zdCBhdXRvJiBzaXplUmVncyA9IHBpbm5lZFJl Z3Muc2l6ZVJlZ2lzdGVyczsKKyAgICBBU1NFUlQoc2l6ZVJlZ3Muc2l6ZSgpID49IDEpOworICAg IEFTU0VSVChzaXplUmVnc1swXS5zaXplUmVnaXN0ZXIgIT0gYmFzZU1lbW9yeSk7CisgICAgQVNT RVJUKHNpemVSZWdzWzBdLnNpemVSZWdpc3RlciAhPSBzY3JhdGNoKTsKKyAgICBBU1NFUlQoIXNp emVSZWdzWzBdLnNpemVPZmZzZXQpOyAvLyBUaGUgZm9sbG93aW5nIGNvZGUgYXNzdW1lcyB3ZSBz dGFydCBhdCAwLCBhbmQgY2FsY3VsYXRlcyBzdWJzZXF1ZW50IHNpemUgcmVnaXN0ZXJzIHJlbGF0 aXZlIHRvIDAuCisgICAgaml0LmxvYWRQdHIoSklUOjpBZGRyZXNzKGJhc2VNZW1vcnksIEpTV2Vi QXNzZW1ibHlNZW1vcnk6Om9mZnNldE9mU2l6ZSgpKSwgc2l6ZVJlZ3NbMF0uc2l6ZVJlZ2lzdGVy KTsgLy8gTWVtb3J5IHNpemUuCisgICAgaml0LmxvYWRQdHIoSklUOjpBZGRyZXNzKGJhc2VNZW1v cnksIEpTV2ViQXNzZW1ibHlNZW1vcnk6Om9mZnNldE9mTWVtb3J5KCkpLCBiYXNlTWVtb3J5KTsg Ly8gV2FzbU1lbW9yeTo6dm9pZCouCisgICAgZm9yICh1bnNpZ25lZCBpID0gMTsgaSA8IHNpemVS ZWdzLnNpemUoKTsgKytpKSB7CisgICAgICAgIEFTU0VSVChzaXplUmVnc1tpXS5zaXplUmVnaXN0 ZXIgIT0gYmFzZU1lbW9yeSk7CisgICAgICAgIEFTU0VSVChzaXplUmVnc1tpXS5zaXplUmVnaXN0 ZXIgIT0gc2NyYXRjaCk7CisgICAgICAgIGppdC5hZGQ2NChKSVQ6OlRydXN0ZWRJbW0zMigtc2l6 ZVJlZ3NbaV0uc2l6ZU9mZnNldCksIHNpemVSZWdzWzBdLnNpemVSZWdpc3Rlciwgc2l6ZVJlZ3Nb MV0uc2l6ZVJlZ2lzdGVyKTsKKyAgICB9CisKKyAgICAvLyBUYWlsIGNhbGwgaW50byB0aGUgY2Fs bGVlIFdlYkFzc2VtYmx5IGZ1bmN0aW9uLgorICAgIGppdC5sb2FkUHRyKEpJVDo6QWRkcmVzcyhz Y3JhdGNoLCBXZWJBc3NlbWJseUZ1bmN0aW9uOjpvZmZzZXRPZldhc21FbnRyeVBvaW50Q29kZSgp KSwgc2NyYXRjaCk7CisgICAgaml0Lmp1bXAoc2NyYXRjaCk7CisKKyAgICBMaW5rQnVmZmVyIHBh dGNoQnVmZmVyKCp2bSwgaml0LCBHTE9CQUxfVEhVTktfSUQpOworICAgIHJldHVybiBGSU5BTEla RV9DT0RFKHBhdGNoQnVmZmVyLCAoIldlYkFzc2VtYmx5LT5XZWJBc3NlbWJseSBpbXBvcnRbJWld IiwgaW1wb3J0SW5kZXgpKTsKK30KKworV2FzbUV4aXRTdHVicyBleGl0U3R1YkdlbmVyYXRvcihW TSogdm0sIEJhZzxDYWxsTGlua0luZm8+JiBjYWxsTGlua0luZm9zLCBTaWduYXR1cmVJbmRleCBz aWduYXR1cmVJbmRleCwgdW5zaWduZWQgaW1wb3J0SW5kZXgpCit7CisgICAgV2FzbUV4aXRTdHVi cyBzdHViczsKKyAgICBzdHVicy53YXNtVG9KUyA9IHdhc21Ub0pTKHZtLCBjYWxsTGlua0luZm9z LCBzaWduYXR1cmVJbmRleCwgaW1wb3J0SW5kZXgpOworICAgIHN0dWJzLndhc21Ub1dhc20gPSB3 YXNtVG9XYXNtKHZtLCBpbXBvcnRJbmRleCk7CisgICAgcmV0dXJuIHN0dWJzOwogfQogCiB9IH0g Ly8gbmFtZXNwYWNlIEpTQzo6V2FzbQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbUJpbmRpbmcuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5k aW5nLmgKaW5kZXggZmQ3ZTAzZC4uNDAyMWYxNyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtQmluZGluZy5oCkBAIC0zOCw3ICszOCw3IEBAIGNsYXNzIENhbGxMaW5rSW5mbzsKIAog bmFtZXNwYWNlIFdhc20gewogCi1XYXNtVG9KU1N0dWIgaW1wb3J0U3R1YkdlbmVyYXRvcihWTSos IEJhZzxDYWxsTGlua0luZm8+JiwgU2lnbmF0dXJlSW5kZXgsIHVuc2lnbmVkKTsKK1dhc21FeGl0 U3R1YnMgZXhpdFN0dWJHZW5lcmF0b3IoVk0qLCBCYWc8Q2FsbExpbmtJbmZvPiYsIFNpZ25hdHVy ZUluZGV4LCB1bnNpZ25lZCk7CiAKIH0gfSAvLyBuYW1lc3BhY2UgSlNDOjpXYXNtCiAKZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Gb3JtYXQuaCBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21Gb3JtYXQuaAppbmRleCBjYjJiZTU1Li4yM2Q4ZWQzIDEw MDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRm9ybWF0LmgKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZvcm1hdC5oCkBAIC0yMjIsNyArMjIyLDYg QEAgcHJpdmF0ZToKIH07CiAKIHN0cnVjdCBNb2R1bGVJbmZvcm1hdGlvbiB7Ci0gICAgVmVjdG9y PFNpZ25hdHVyZUluZGV4PiBzaWduYXR1cmVJbmRpY2VzOwogICAgIFZlY3RvcjxJbXBvcnQ+IGlt cG9ydHM7CiAgICAgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiBpbXBvcnRGdW5jdGlvblNpZ25hdHVy ZUluZGljZXM7CiAgICAgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiBpbnRlcm5hbEZ1bmN0aW9uU2ln bmF0dXJlSW5kaWNlczsKQEAgLTIzNiw2ICsyMzUsMTggQEAgc3RydWN0IE1vZHVsZUluZm9ybWF0 aW9uIHsKICAgICBUYWJsZUluZm9ybWF0aW9uIHRhYmxlSW5mb3JtYXRpb247CiAgICAgVmVjdG9y PEdsb2JhbD4gZ2xvYmFsczsKICAgICB1bnNpZ25lZCBmaXJzdEludGVybmFsR2xvYmFsIHsgMCB9 OworICAgIHNpemVfdCBmdW5jdGlvbkluZGV4U3BhY2VTaXplKCkgY29uc3QgeyByZXR1cm4gaW1w b3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnNpemUoKSArIGludGVybmFsRnVuY3Rpb25TaWdu YXR1cmVJbmRpY2VzLnNpemUoKTsgfQorICAgIGJvb2wgaXNJbXBvcnRlZEZ1bmN0aW9uRnJvbUZ1 bmN0aW9uSW5kZXhTcGFjZShzaXplX3QgZnVuY3Rpb25JbmRleCkgY29uc3QKKyAgICB7CisgICAg ICAgIEFTU0VSVChmdW5jdGlvbkluZGV4IDwgZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpKTsKKyAg ICAgICAgcmV0dXJuIGZ1bmN0aW9uSW5kZXggPCBpbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGlj ZXMuc2l6ZSgpOworICAgIH0KKyAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleEZyb21G dW5jdGlvbkluZGV4U3BhY2Uoc2l6ZV90IGZ1bmN0aW9uSW5kZXgpIGNvbnN0CisgICAgeworICAg ICAgICByZXR1cm4gaXNJbXBvcnRlZEZ1bmN0aW9uRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5j dGlvbkluZGV4KQorICAgICAgICAgICAgPyBpbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXNb ZnVuY3Rpb25JbmRleF0KKyAgICAgICAgICAgIDogaW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUlu ZGljZXNbZnVuY3Rpb25JbmRleCAtIGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXpl KCldOworICAgIH0KIAogICAgIHVpbnQzMl90IGltcG9ydEZ1bmN0aW9uQ291bnQoKSBjb25zdCB7 IHJldHVybiBpbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMuc2l6ZSgpOyB9CiAgICAgYm9v bCBoYXNNZW1vcnkoKSBjb25zdCB7IHJldHVybiAhIW1lbW9yeTsgfQpAQCAtMjQ2LDYgKzI1Nywx MCBAQCBzdHJ1Y3QgTW9kdWxlSW5mb3JtYXRpb24gewogc3RydWN0IFVubGlua2VkV2FzbVRvV2Fz bUNhbGwgewogICAgIENvZGVMb2NhdGlvbkNhbGwgY2FsbExvY2F0aW9uOwogICAgIHNpemVfdCBm dW5jdGlvbkluZGV4OworICAgIGVudW0gY2xhc3MgVGFyZ2V0IDogdWludDhfdCB7CisgICAgICAg IHRvSlMsCisgICAgICAgIHRvV2FzbSwKKyAgICB9IHRhcmdldDsKIH07CiAKIHN0cnVjdCBFbnRy eXBvaW50IHsKQEAgLTI2MSw3ICsyNzYsMTAgQEAgc3RydWN0IFdhc21JbnRlcm5hbEZ1bmN0aW9u IHsKICAgICBFbnRyeXBvaW50IGpzVG9XYXNtRW50cnlwb2ludDsKIH07CiAKLXR5cGVkZWYgTWFj cm9Bc3NlbWJsZXJDb2RlUmVmIFdhc21Ub0pTU3R1YjsKK3N0cnVjdCBXYXNtRXhpdFN0dWJzIHsK KyAgICBNYWNyb0Fzc2VtYmxlckNvZGVSZWYgd2FzbVRvSlM7CisgICAgTWFjcm9Bc3NlbWJsZXJD b2RlUmVmIHdhc21Ub1dhc207Cit9OwogCiAvLyBXZWJBc3NlbWJseSBkaXJlY3QgY2FsbHMgYW5k IGNhbGxfaW5kaXJlY3QgdXNlIGluZGljZXMgaW50byAiZnVuY3Rpb24gaW5kZXggc3BhY2UiLiBU aGlzIHNwYWNlIHN0YXJ0cyB3aXRoIGFsbCBpbXBvcnRzLCBhbmQgdGhlbiBhbGwgaW50ZXJuYWwg ZnVuY3Rpb25zLgogLy8gQ2FsbGFibGVGdW5jdGlvbiBhbmQgRnVuY3Rpb25JbmRleFNwYWNlIGFy ZSBvbmx5IG1lYW50IGFzIGZhc3QgbG9va3VwIHRhYmxlcyBmb3IgdGhlc2Ugb3Bjb2RlcywgYW5k IGRvIG5vdCBvd24gY29kZS4KQEAgLTI4MCwxMiArMjk4LDYgQEAgc3RydWN0IENhbGxhYmxlRnVu Y3Rpb24gewogfTsKIHR5cGVkZWYgVmVjdG9yPENhbGxhYmxlRnVuY3Rpb24+IEZ1bmN0aW9uSW5k ZXhTcGFjZTsKIAotCi1zdHJ1Y3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlIHsKLSAgICBN YWxsb2NQdHI8Q2FsbGFibGVGdW5jdGlvbj4gYnVmZmVyOwotICAgIHNpemVfdCBzaXplOwotfTsK LQogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KIAogI2VuZGlmIC8vIEVOQUJMRShXRUJBU1NF TUJMWSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21GdW5jdGlv blBhcnNlci5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2Vy LmgKaW5kZXggNTIwMTBkYy4uMzExMDVkOCAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmgKQEAgLTQ2LDcgKzQ2LDcgQEAgcHVibGljOgogICAg IHR5cGVkZWYgdHlwZW5hbWUgQ29udGV4dDo6Q29udHJvbFR5cGUgQ29udHJvbFR5cGU7CiAgICAg dHlwZWRlZiB0eXBlbmFtZSBDb250ZXh0OjpFeHByZXNzaW9uTGlzdCBFeHByZXNzaW9uTGlzdDsK IAotICAgIEZ1bmN0aW9uUGFyc2VyKFZNKiwgQ29udGV4dCYsIGNvbnN0IHVpbnQ4X3QqIGZ1bmN0 aW9uU3RhcnQsIHNpemVfdCBmdW5jdGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiwgY29uc3Qg SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mKTsK KyAgICBGdW5jdGlvblBhcnNlcihWTSosIENvbnRleHQmLCBjb25zdCB1aW50OF90KiBmdW5jdGlv blN0YXJ0LCBzaXplX3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSosIGNvbnN0IE1v ZHVsZUluZm9ybWF0aW9uJiwgY29uc3QgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiYpOwogCiAgICAg UmVzdWx0IFdBUk5fVU5VU0VEX1JFVFVSTiBwYXJzZSgpOwogCkBAIC04MiwxOCArODIsMTggQEAg cHJpdmF0ZToKICAgICBFeHByZXNzaW9uTGlzdCBtX2V4cHJlc3Npb25TdGFjazsKICAgICBWZWN0 b3I8Q29udHJvbEVudHJ5PiBtX2NvbnRyb2xTdGFjazsKICAgICBjb25zdCBTaWduYXR1cmUqIG1f c2lnbmF0dXJlOwotICAgIGNvbnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYgbV9mdW5j dGlvbkluZGV4U3BhY2U7CiAgICAgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIG1faW5mbzsKKyAg ICBjb25zdCBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+JiBtX21vZHVsZVNpZ25hdHVyZUluZGljZXNU b1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzOwogICAgIHVuc2lnbmVkIG1fdW5yZWFjaGFibGVCbG9j a3MgeyAwIH07CiB9OwogCiB0ZW1wbGF0ZTx0eXBlbmFtZSBDb250ZXh0PgotRnVuY3Rpb25QYXJz ZXI8Q29udGV4dD46OkZ1bmN0aW9uUGFyc2VyKFZNKiB2bSwgQ29udGV4dCYgY29udGV4dCwgY29u c3QgdWludDhfdCogZnVuY3Rpb25TdGFydCwgc2l6ZV90IGZ1bmN0aW9uTGVuZ3RoLCBjb25zdCBT aWduYXR1cmUqIHNpZ25hdHVyZSwgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiBm dW5jdGlvbkluZGV4U3BhY2UsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBpbmZvKQorRnVuY3Rp b25QYXJzZXI8Q29udGV4dD46OkZ1bmN0aW9uUGFyc2VyKFZNKiB2bSwgQ29udGV4dCYgY29udGV4 dCwgY29uc3QgdWludDhfdCogZnVuY3Rpb25TdGFydCwgc2l6ZV90IGZ1bmN0aW9uTGVuZ3RoLCBj b25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8s IGNvbnN0IFZlY3RvcjxTaWduYXR1cmVJbmRleD4mIG1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1Vu aXF1ZWRTaWduYXR1cmVJbmRpY2VzKQogICAgIDogUGFyc2VyKHZtLCBmdW5jdGlvblN0YXJ0LCBm dW5jdGlvbkxlbmd0aCkKICAgICAsIG1fY29udGV4dChjb250ZXh0KQogICAgICwgbV9zaWduYXR1 cmUoc2lnbmF0dXJlKQotICAgICwgbV9mdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleFNw YWNlKQogICAgICwgbV9pbmZvKGluZm8pCisgICAgLCBtX21vZHVsZVNpZ25hdHVyZUluZGljZXNU b1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzKG1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRT aWduYXR1cmVJbmRpY2VzKQogewogICAgIGlmICh2ZXJib3NlKQogICAgICAgICBkYXRhTG9nTG4o IlBhcnNpbmcgZnVuY3Rpb24gc3RhcnRpbmcgYXQ6ICIsICh1aW50cHRyX3QpZnVuY3Rpb25TdGFy dCwgIiBvZiBsZW5ndGg6ICIsIGZ1bmN0aW9uTGVuZ3RoKTsKQEAgLTMwOCw5ICszMDgsOSBAQCBh dXRvIEZ1bmN0aW9uUGFyc2VyPENvbnRleHQ+OjpwYXJzZUV4cHJlc3Npb24oT3BUeXBlIG9wKSAt PiBQYXJ0aWFsUmVzdWx0CiAgICAgY2FzZSBDYWxsOiB7CiAgICAgICAgIHVpbnQzMl90IGZ1bmN0 aW9uSW5kZXg7CiAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKGZ1 bmN0aW9uSW5kZXgpLCAiY2FuJ3QgcGFyc2UgY2FsbCdzIGZ1bmN0aW9uIGluZGV4Iik7Ci0gICAg ICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVuY3Rpb25JbmRleCA+PSBtX2Z1bmN0aW9uSW5kZXhT cGFjZS5zaXplLCAiY2FsbCBmdW5jdGlvbiBpbmRleCAiLCBmdW5jdGlvbkluZGV4LCAiIGV4Y2Vl ZHMgZnVuY3Rpb24gaW5kZXggc3BhY2UgIiwgbV9mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSk7Cisg ICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVuY3Rpb25JbmRleCA+PSBtX2luZm8uZnVuY3Rp b25JbmRleFNwYWNlU2l6ZSgpLCAiY2FsbCBmdW5jdGlvbiBpbmRleCAiLCBmdW5jdGlvbkluZGV4 LCAiIGV4Y2VlZHMgZnVuY3Rpb24gaW5kZXggc3BhY2UgIiwgbV9pbmZvLmZ1bmN0aW9uSW5kZXhT cGFjZVNpemUoKSk7CiAKLSAgICAgICAgU2lnbmF0dXJlSW5kZXggY2FsbGVlU2lnbmF0dXJlSW5k ZXggPSBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5idWZmZXIuZ2V0KClbZnVuY3Rpb25JbmRleF0uc2ln bmF0dXJlSW5kZXg7CisgICAgICAgIFNpZ25hdHVyZUluZGV4IGNhbGxlZVNpZ25hdHVyZUluZGV4 ID0gbV9pbmZvLnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbklu ZGV4KTsKICAgICAgICAgY29uc3QgU2lnbmF0dXJlKiBjYWxsZWVTaWduYXR1cmUgPSBTaWduYXR1 cmVJbmZvcm1hdGlvbjo6Z2V0KG1fdm0sIGNhbGxlZVNpZ25hdHVyZUluZGV4KTsKICAgICAgICAg V0FTTV9QQVJTRVJfRkFJTF9JRihjYWxsZWVTaWduYXR1cmUtPmFyZ3VtZW50Q291bnQoKSA+IG1f ZXhwcmVzc2lvblN0YWNrLnNpemUoKSwgImNhbGwgZnVuY3Rpb24gaW5kZXggIiwgZnVuY3Rpb25J bmRleCwgIiBoYXMgIiwgY2FsbGVlU2lnbmF0dXJlLT5hcmd1bWVudENvdW50KCksICIgYXJndW1l bnRzLCBidXQgdGhlIGV4cHJlc3Npb24gc3RhY2sgY3VycmVudGx5IGhvbGRzICIsIG1fZXhwcmVz c2lvblN0YWNrLnNpemUoKSwgIiB2YWx1ZXMiKTsKIApAQCAtMzM3LDkgKzMzNyw5IEBAIGF1dG8g RnVuY3Rpb25QYXJzZXI8Q29udGV4dD46OnBhcnNlRXhwcmVzc2lvbihPcFR5cGUgb3ApIC0+IFBh cnRpYWxSZXN1bHQKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIo c2lnbmF0dXJlSW5kZXgpLCAiY2FuJ3QgZ2V0IGNhbGxfaW5kaXJlY3QncyBzaWduYXR1cmUgaW5k ZXgiKTsKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MShyZXNlcnZl ZCksICJjYW4ndCBnZXQgY2FsbF9pbmRpcmVjdCdzIHJlc2VydmVkIGJ5dGUiKTsKICAgICAgICAg V0FTTV9QQVJTRVJfRkFJTF9JRihyZXNlcnZlZCwgImNhbGxfaW5kaXJlY3QncyAncmVzZXJ2ZWQn IHZhcnVpbnQxIG11c3QgYmUgMHgwIik7Ci0gICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYobV9p bmZvLnNpZ25hdHVyZUluZGljZXMuc2l6ZSgpIDw9IHNpZ25hdHVyZUluZGV4LCAiY2FsbF9pbmRp cmVjdCdzIHNpZ25hdHVyZSBpbmRleCAiLCBzaWduYXR1cmVJbmRleCwgIiBleGNlZWRzIGtub3du IHNpZ25hdHVyZXMgIiwgbV9pbmZvLnNpZ25hdHVyZUluZGljZXMuc2l6ZSgpKTsKKyAgICAgICAg V0FTTV9QQVJTRVJfRkFJTF9JRihtX21vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWdu YXR1cmVJbmRpY2VzLnNpemUoKSA8PSBzaWduYXR1cmVJbmRleCwgImNhbGxfaW5kaXJlY3QncyBz aWduYXR1cmUgaW5kZXggIiwgc2lnbmF0dXJlSW5kZXgsICIgZXhjZWVkcyBrbm93biBzaWduYXR1 cmVzICIsIG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMu c2l6ZSgpKTsKIAotICAgICAgICBTaWduYXR1cmVJbmRleCBjYWxsZWVTaWduYXR1cmVJbmRleCA9 IG1faW5mby5zaWduYXR1cmVJbmRpY2VzW3NpZ25hdHVyZUluZGV4XTsKKyAgICAgICAgU2lnbmF0 dXJlSW5kZXggY2FsbGVlU2lnbmF0dXJlSW5kZXggPSBtX21vZHVsZVNpZ25hdHVyZUluZGljZXNU b1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzW3NpZ25hdHVyZUluZGV4XTsKICAgICAgICAgY29uc3Qg U2lnbmF0dXJlKiBjYWxsZWVTaWduYXR1cmUgPSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KG1f dm0sIGNhbGxlZVNpZ25hdHVyZUluZGV4KTsKICAgICAgICAgc2l6ZV90IGFyZ3VtZW50Q291bnQg PSBjYWxsZWVTaWduYXR1cmUtPmFyZ3VtZW50Q291bnQoKSArIDE7IC8vIEFkZCB0aGUgY2FsbGVl J3MgaW5kZXguCiAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoYXJndW1lbnRDb3VudCA+IG1f ZXhwcmVzc2lvblN0YWNrLnNpemUoKSwgImNhbGxfaW5kaXJlY3QgZXhwZWN0cyAiLCBhcmd1bWVu dENvdW50LCAiIGFyZ3VtZW50cywgYnV0IHRoZSBleHByZXNzaW9uIHN0YWNrIGN1cnJlbnRseSBo b2xkcyAiLCBtX2V4cHJlc3Npb25TdGFjay5zaXplKCksICIgdmFsdWVzIik7CmRpZmYgLS1naXQg YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmNwcCBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwCmluZGV4IDcwMGUzYWMuLmFhZDkxYzEgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwCisrKyBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwCkBAIC0yOCwxNSArMjgs MzkgQEAKIAogI2lmIEVOQUJMRShXRUJBU1NFTUJMWSkKIAorI2luY2x1ZGUgPHd0Zi9IZXhOdW1i ZXIuaD4KKyNpbmNsdWRlIDx3dGYvUHJpbnRTdHJlYW0uaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9X VEZTdHJpbmcuaD4KKwogbmFtZXNwYWNlIEpTQyB7IG5hbWVzcGFjZSBXYXNtIHsKIAorbmFtZXNw YWNlIHsKK2NvbnN0IGJvb2wgdmVyYm9zZSA9IGZhbHNlOworfQorCit2b2lkIE1lbW9yeTo6ZHVt cChQcmludFN0cmVhbSYgb3V0KSBjb25zdAoreworICAgIFN0cmluZyBtZW1vcnlIZXg7CisgICAg V1RGOjphcHBlbmRVbnNpZ25lZDY0QXNIZXgoKHVpbnQ2NF90KSh1aW50cHRyX3QpbV9tZW1vcnks IG1lbW9yeUhleCk7CisgICAgb3V0LnByaW50KCJNZW1vcnkgYXQgMHgiLCBtZW1vcnlIZXgsICIs IHNpemUgIiwgbV9zaXplLCAiQiBjYXBhY2l0eSAiLCBtX21hcHBlZENhcGFjaXR5LCAiQiwgaW5p dGlhbCAiLCBtX2luaXRpYWwsICIgbWF4aW11bSAiLCBtX21heGltdW0sICIgbW9kZSAiLCBtYWtl U3RyaW5nKG1fbW9kZSkpOworfQorCitjb25zdCBjaGFyKiBNZW1vcnk6Om1ha2VTdHJpbmcoTW9k ZSBtb2RlKSBjb25zdAoreworICAgIHN3aXRjaCAobW9kZSkgeworICAgIGNhc2UgTW9kZTo6Qm91 bmRzQ2hlY2tpbmc6IHJldHVybiAiQm91bmRzQ2hlY2tpbmciOworICAgIH0KKyAgICBSRUxFQVNF X0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIHJldHVybiAiIjsKK30KKwogc3RhdGljX2Fzc2Vy dChzaXplb2YodWludDY0X3QpID09IHNpemVvZihzaXplX3QpLCAiV2UgcmVseSBvbiBhbGxvd2lu ZyB0aGUgbWF4aW11bSBzaXplIG9mIE1lbW9yeSB3ZSBtYXAgdG8gYmUgMl4zMiB3aGljaCBpcyBs YXJnZXIgdGhhbiBmaXRzIGluIGEgMzItYml0IGludGVnZXIgdGhhdCB3ZSdkIHBhc3MgdG8gbXBy b3RlY3QgaWYgdGhpcyBkaWRuJ3QgaG9sZC4iKTsKIAogTWVtb3J5OjpNZW1vcnkoUGFnZUNvdW50 IGluaXRpYWwsIFBhZ2VDb3VudCBtYXhpbXVtLCBib29sJiBmYWlsZWQpCi0gICAgOiBtX21vZGUo TW9kZTo6Qm91bmRzQ2hlY2tpbmcpCisgICAgOiBtX3NpemUoaW5pdGlhbC5ieXRlcygpKQogICAg ICwgbV9pbml0aWFsKGluaXRpYWwpCiAgICAgLCBtX21heGltdW0obWF4aW11bSkKLSAgICAsIG1f c2l6ZShpbml0aWFsLmJ5dGVzKCkpCisgICAgLCBtX21vZGUoTW9kZTo6Qm91bmRzQ2hlY2tpbmcp CiAgICAgLy8gRklYTUU6IElmIHdlIGFkZCBzaWduYWwgYmFzZWQgYm91bmRzIGNoZWNraW5nIHRo ZW4gd2UgbmVlZCBleHRyYSBzcGFjZSBmb3Igb3ZlcmZsb3cgb24gbG9hZC4KICAgICAvLyBzZWU6 IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjI2OTMKIHsKQEAgLTQ2 LDkgKzcwLDExIEBAIE1lbW9yeTo6TWVtb3J5KFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQg bWF4aW11bSwgYm9vbCYgZmFpbGVkKQogICAgIGlmICghbV9tYXBwZWRDYXBhY2l0eSkgewogICAg ICAgICAvLyBUaGlzIG1lYW5zIHdlIHNwZWNpZmllZCBhIHplcm8gYXMgbWF4aW11bSAod2hpY2gg bWVhbnMgd2UgYWxzbyBoYXZlIHplcm8gYXMgaW5pdGlhbCBzaXplKS4KICAgICAgICAgUkVMRUFT RV9BU1NFUlQobV9zaXplID09IDApOwotICAgICAgICBtX21hcHBlZENhcGFjaXR5ID0gMDsKICAg ICAgICAgbV9tZW1vcnkgPSBudWxscHRyOworICAgICAgICBtX21hcHBlZENhcGFjaXR5ID0gMDsK ICAgICAgICAgZmFpbGVkID0gZmFsc2U7CisgICAgICAgIGlmICh2ZXJib3NlKQorICAgICAgICAg ICAgZGF0YUxvZ0xuKCJNZW1vcnk6Ok1lbW9yeSBhbGxvY2F0aW5nIG5vdGhpbmcgIiwgKnRoaXMp OwogICAgICAgICByZXR1cm47CiAgICAgfQogCkBAIC01NiwxNSArODIsMjEgQEAgTWVtb3J5OjpN ZW1vcnkoUGFnZUNvdW50IGluaXRpYWwsIFBhZ2VDb3VudCBtYXhpbXVtLCBib29sJiBmYWlsZWQp CiAgICAgdm9pZCogcmVzdWx0ID0gT3B0aW9uczo6c2ltdWxhdGVXZWJBc3NlbWJseUxvd01lbW9y eSgpID8gTUFQX0ZBSUxFRCA6IG1tYXAobnVsbHB0ciwgbV9tYXBwZWRDYXBhY2l0eSwgUFJPVF9O T05FLCBNQVBfUFJJVkFURSB8IE1BUF9BTk9OLCAtMSwgMCk7CiAgICAgaWYgKHJlc3VsdCA9PSBN QVBfRkFJTEVEKSB7CiAgICAgICAgIC8vIFRyeSBhZ2FpbiB3aXRoIGEgZGlmZmVyZW50IG51bWJl ci4KKyAgICAgICAgaWYgKHZlcmJvc2UpCisgICAgICAgICAgICBkYXRhTG9nTG4oIk1lbW9yeTo6 TWVtb3J5IG1tYXAgZmFpbGVkIG9uY2UgZm9yIGNhcGFjaXR5LCB0cnlpbmcgYWdhaW4iLCAqdGhp cyk7CiAgICAgICAgIG1fbWFwcGVkQ2FwYWNpdHkgPSBtX3NpemU7CiAgICAgICAgIGlmICghbV9t YXBwZWRDYXBhY2l0eSkgewogICAgICAgICAgICAgbV9tZW1vcnkgPSBudWxscHRyOwogICAgICAg ICAgICAgZmFpbGVkID0gZmFsc2U7CisgICAgICAgICAgICBpZiAodmVyYm9zZSkKKyAgICAgICAg ICAgICAgICBkYXRhTG9nTG4oIk1lbW9yeTo6TWVtb3J5IG1tYXAgbm90IHRyeWluZyBhZ2FpbiBi ZWNhdXNlIHNpemUgaXMgemVybyAiLCAqdGhpcyk7CiAgICAgICAgICAgICByZXR1cm47CiAgICAg ICAgIH0KIAogICAgICAgICByZXN1bHQgPSBtbWFwKG51bGxwdHIsIG1fbWFwcGVkQ2FwYWNpdHks IFBST1RfTk9ORSwgTUFQX1BSSVZBVEUgfCBNQVBfQU5PTiwgLTEsIDApOwogICAgICAgICBpZiAo cmVzdWx0ID09IE1BUF9GQUlMRUQpIHsKKyAgICAgICAgICAgIGlmICh2ZXJib3NlKQorICAgICAg ICAgICAgICAgIGRhdGFMb2dMbigiTWVtb3J5OjpNZW1vcnkgbW1hcCBmYWlsZWQgdHdpY2UgIiwg KnRoaXMpOwogICAgICAgICAgICAgZmFpbGVkID0gdHJ1ZTsKICAgICAgICAgICAgIHJldHVybjsK ICAgICAgICAgfQpAQCAtNzgsMTIgKzExMCwyNyBAQCBNZW1vcnk6Ok1lbW9yeShQYWdlQ291bnQg aW5pdGlhbCwgUGFnZUNvdW50IG1heGltdW0sIGJvb2wmIGZhaWxlZCkKIAogICAgIG1fbWVtb3J5 ID0gcmVzdWx0OwogICAgIGZhaWxlZCA9IGZhbHNlOworICAgIGlmICh2ZXJib3NlKQorICAgICAg ICBkYXRhTG9nTG4oIk1lbW9yeTo6TWVtb3J5IG1tYXAgc3VjY2VlZGVkICIsICp0aGlzKTsKK30K KworTWVtb3J5Ojp+TWVtb3J5KCkKK3sKKyAgICBpZiAodmVyYm9zZSkKKyAgICAgICAgZGF0YUxv Z0xuKCJNZW1vcnk6On5NZW1vcnkgIiwgKnRoaXMpOworICAgIGlmIChtX21lbW9yeSkgeworICAg ICAgICBpZiAobXVubWFwKG1fbWVtb3J5LCBtX21hcHBlZENhcGFjaXR5KSkKKyAgICAgICAgICAg IENSQVNIKCk7CisgICAgfQogfQogCiBib29sIE1lbW9yeTo6Z3JvdyhQYWdlQ291bnQgbmV3U2l6 ZSkKIHsKICAgICBSRUxFQVNFX0FTU0VSVChuZXdTaXplID4gUGFnZUNvdW50Ojpmcm9tQnl0ZXMo bV9zaXplKSk7CiAKKyAgICBpZiAodmVyYm9zZSkKKyAgICAgICAgZGF0YUxvZ0xuKCJNZW1vcnk6 Omdyb3cgdG8gIiwgbmV3U2l6ZSwgIiBmcm9tICIsICp0aGlzKTsKKwogICAgIGlmIChtYXhpbXVt KCkgJiYgbmV3U2l6ZSA+IG1heGltdW0oKSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwogCkBAIC05 Myw2ICsxNDAsOCBAQCBib29sIE1lbW9yeTo6Z3JvdyhQYWdlQ291bnQgbmV3U2l6ZSkKICAgICAg ICAgYm9vbCBzdWNjZXNzID0gIW1wcm90ZWN0KHN0YXRpY19jYXN0PHVpbnQ4X3QqPihtX21lbW9y eSkgKyBtX3NpemUsIHN0YXRpY19jYXN0PHNpemVfdD4oZGVzaXJlZFNpemUgLSBtX3NpemUpLCBQ Uk9UX1JFQUQgfCBQUk9UX1dSSVRFKTsKICAgICAgICAgUkVMRUFTRV9BU1NFUlQoc3VjY2Vzcyk7 CiAgICAgICAgIG1fc2l6ZSA9IGRlc2lyZWRTaXplOworICAgICAgICBpZiAodmVyYm9zZSkKKyAg ICAgICAgICAgIGRhdGFMb2dMbigiTWVtb3J5Ojpncm93IGluLXBsYWNlICIsICp0aGlzKTsKICAg ICAgICAgcmV0dXJuIHRydWU7CiAgICAgfQogCkBAIC0xMTAsNiArMTU5LDggQEAgYm9vbCBNZW1v cnk6Omdyb3coUGFnZUNvdW50IG5ld1NpemUpCiAgICAgbV9tYXBwZWRDYXBhY2l0eSA9IGRlc2ly ZWRTaXplOwogICAgIG1fc2l6ZSA9IGRlc2lyZWRTaXplOwogCisgICAgaWYgKHZlcmJvc2UpCisg ICAgICAgIGRhdGFMb2dMbigiTWVtb3J5Ojpncm93ICIsICp0aGlzKTsKICAgICByZXR1cm4gdHJ1 ZTsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9y eS5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5oCmluZGV4IDRlNWVl MzYuLmU0NzBjNDEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21N ZW1vcnkuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmgKQEAg LTMwLDcgKzMwLDkgQEAKICNpbmNsdWRlICJXYXNtQ2FsbGluZ0NvbnZlbnRpb24uaCIKICNpbmNs dWRlICJXYXNtUGFnZUNvdW50LmgiCiAKLSNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CituYW1lc3Bh Y2UgV1RGIHsKK2NsYXNzIFByaW50U3RyZWFtOworfQogCiBuYW1lc3BhY2UgSlNDIHsgbmFtZXNw YWNlIFdhc20gewogCkBAIC0zOCw0MSArNDAsNTAgQEAgY2xhc3MgTWVtb3J5IHsKICAgICBXVEZf TUFLRV9OT05DT1BZQUJMRShNZW1vcnkpOwogICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwog cHVibGljOgorICAgIHZvaWQgZHVtcChXVEY6OlByaW50U3RyZWFtJikgY29uc3Q7CiAKICAgICAv LyBGSVhNRTogV2Ugc2hvdWxkIHN1cHBvcnQgb3RoZXIgbW9kZXMuIHNlZTogaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MjY5MwogICAgIGVudW0gY2xhc3MgTW9kZSB7 CiAgICAgICAgIEJvdW5kc0NoZWNraW5nCiAgICAgfTsKKyAgICBjb25zdCBjaGFyKiBtYWtlU3Ry aW5nKE1vZGUpIGNvbnN0OwogCisgICAgTWVtb3J5KCkgPSBkZWZhdWx0OwogICAgIEpTX0VYUE9S VF9QUklWQVRFIE1lbW9yeShQYWdlQ291bnQgaW5pdGlhbCwgUGFnZUNvdW50IG1heGltdW0sIGJv b2wmIGZhaWxlZCk7Ci0KLSAgICB+TWVtb3J5KCkKKyAgICBNZW1vcnkoTWVtb3J5JiYgb3RoZXIp CisgICAgICAgIDogbV9tZW1vcnkob3RoZXIubV9tZW1vcnkpCisgICAgICAgICwgbV9zaXplKG90 aGVyLm1fc2l6ZSkKKyAgICAgICAgLCBtX2luaXRpYWwob3RoZXIubV9pbml0aWFsKQorICAgICAg ICAsIG1fbWF4aW11bShvdGhlci5tX21heGltdW0pCisgICAgICAgICwgbV9tYXBwZWRDYXBhY2l0 eShvdGhlci5tX21hcHBlZENhcGFjaXR5KQorICAgICAgICAsIG1fbW9kZShvdGhlci5tX21vZGUp CiAgICAgewotICAgICAgICBpZiAobV9tZW1vcnkpCi0gICAgICAgICAgICBtdW5tYXAobV9tZW1v cnksIG1fbWFwcGVkQ2FwYWNpdHkpOworICAgICAgICAvLyBNb3ZpbmcgdHJhbnNmZXJzIG93bmVy c2hpcCBvZiB0aGUgYWxsb2NhdGVkIG1lbW9yeS4KKyAgICAgICAgb3RoZXIubV9tZW1vcnkgPSBu dWxscHRyOwogICAgIH0KKyAgICBKU19FWFBPUlRfUFJJVkFURSB+TWVtb3J5KCk7CiAKICAgICB2 b2lkKiBtZW1vcnkoKSBjb25zdCB7IHJldHVybiBtX21lbW9yeTsgfQogICAgIHVpbnQ2NF90IHNp emUoKSBjb25zdCB7IHJldHVybiBtX3NpemU7IH0KICAgICBQYWdlQ291bnQgc2l6ZUluUGFnZXMo KSBjb25zdCB7IHJldHVybiBQYWdlQ291bnQ6OmZyb21CeXRlcyhtX3NpemUpOyB9CiAKLSAgICBN b2RlIG1vZGUoKSBjb25zdCB7IHJldHVybiBtX21vZGU7IH0KLQogICAgIFBhZ2VDb3VudCBpbml0 aWFsKCkgY29uc3QgeyByZXR1cm4gbV9pbml0aWFsOyB9CiAgICAgUGFnZUNvdW50IG1heGltdW0o KSBjb25zdCB7IHJldHVybiBtX21heGltdW07IH0KIAorICAgIE1vZGUgbW9kZSgpIGNvbnN0IHsg cmV0dXJuIG1fbW9kZTsgfQorCiAgICAgYm9vbCBncm93KFBhZ2VDb3VudCk7CiAKLSAgICBzdGF0 aWMgcHRyZGlmZl90IG9mZnNldE9mU2l6ZSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihNZW1v cnksIG1fc2l6ZSk7IH0KICAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mTWVtb3J5KCkgeyBy ZXR1cm4gT0JKRUNUX09GRlNFVE9GKE1lbW9yeSwgbV9tZW1vcnkpOyB9CisgICAgc3RhdGljIHB0 cmRpZmZfdCBvZmZzZXRPZlNpemUoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoTWVtb3J5LCBt X3NpemUpOyB9CiAgICAgCiBwcml2YXRlOgogICAgIHZvaWQqIG1fbWVtb3J5IHsgbnVsbHB0ciB9 OwotICAgIE1vZGUgbV9tb2RlOworICAgIHVpbnQ2NF90IG1fc2l6ZSB7IDAgfTsKICAgICBQYWdl Q291bnQgbV9pbml0aWFsOwogICAgIFBhZ2VDb3VudCBtX21heGltdW07Ci0gICAgdWludDY0X3Qg bV9zaXplIHsgMCB9OwogICAgIHVpbnQ2NF90IG1fbWFwcGVkQ2FwYWNpdHkgeyAwIH07CisgICAg TW9kZSBtX21vZGUgeyBNb2RlOjpCb3VuZHNDaGVja2luZyB9OwogfTsKIAogfSB9IC8vIG5hbWVz cGFjZSBKU0M6Oldhc20KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dh c21NZW1vcnlJbmZvcm1hdGlvbi5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt TWVtb3J5SW5mb3JtYXRpb24uY3BwCmluZGV4IDJlMWQzMGEuLjZiMDYzZDMgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnlJbmZvcm1hdGlvbi5jcHAKKysr IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmNwcApA QCAtMjYsMTMgKzI2LDUyIEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiV2FzbU1l bW9yeUluZm9ybWF0aW9uLmgiCiAKLSNpbmNsdWRlICJXYXNtQ2FsbGluZ0NvbnZlbnRpb24uaCIK LQogI2lmIEVOQUJMRShXRUJBU1NFTUJMWSkKIAorI2luY2x1ZGUgIldhc21DYWxsaW5nQ29udmVu dGlvbi5oIgorI2luY2x1ZGUgPHd0Zi9OZXZlckRlc3Ryb3llZC5oPgorCiBuYW1lc3BhY2UgSlND IHsgbmFtZXNwYWNlIFdhc20gewogCi1NZW1vcnlJbmZvcm1hdGlvbjo6TWVtb3J5SW5mb3JtYXRp b24oUGFnZUNvdW50IGluaXRpYWwsIFBhZ2VDb3VudCBtYXhpbXVtLCAgY29uc3QgVmVjdG9yPHVu c2lnbmVkPiYgcGlubmVkU2l6ZVJlZ2lzdGVycywgYm9vbCBpc0ltcG9ydCkKK2NvbnN0IFBpbm5l ZFJlZ2lzdGVySW5mbyYgUGlubmVkUmVnaXN0ZXJJbmZvOjpnZXQoKQoreworICAgIHN0YXRpYyBM YXp5TmV2ZXJEZXN0cm95ZWQ8UGlubmVkUmVnaXN0ZXJJbmZvPiBzdGF0aWNQaW5uZWRSZWdpc3Rl ckluZm87CisgICAgc3RhdGljIHN0ZDo6b25jZV9mbGFnIHN0YXRpY1Bpbm5lZFJlZ2lzdGVySW5m b0ZsYWc7CisgICAgc3RkOjpjYWxsX29uY2Uoc3RhdGljUGlubmVkUmVnaXN0ZXJJbmZvRmxhZywg W10gKCkgeworICAgICAgICBWZWN0b3I8UGlubmVkU2l6ZVJlZ2lzdGVySW5mbz4gc2l6ZVJlZ2lz dGVyczsKKyAgICAgICAgR1BSUmVnIGJhc2VNZW1vcnlQb2ludGVyOworCisgICAgICAgIC8vIEZJ WE1FOiBXZSBzaG91bGQgc3VwcG9ydCBtb3JlIHRoYW4gb25lIG1lbW9yeSBzaXplIHJlZ2lzdGVy LCBhbmQgd2Ugc2hvdWxkIGFsbG93IGRpZmZlcmVudAorICAgICAgICAvLyAgICAgICAgV2ViQXNz ZW1ibHkuSW5zdGFuY2UgdG8gaGF2ZSBkaWZmZXJlbnQgcGlucy4gUmlnaHQgbm93IHdlIHRha2Ug YSB2ZWN0b3Igd2l0aCBvbmx5IG9uZSBlbnRyeS4KKyAgICAgICAgLy8gICAgICAgIElmIHdlIGhh dmUgbW9yZSB0aGFuIG9uZSBzaXplIHJlZ2lzdGVyLCB3ZSBjYW4gaGF2ZSBvbmUgZm9yIGVhY2gg bG9hZCBzaXplIGNsYXNzLgorICAgICAgICAvLyAgICAgICAgc2VlOiBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYyOTUyCisgICAgICAgIFZlY3Rvcjx1bnNpZ25lZD4g cGlubmVkU2l6ZXMgPSB7IDAgfTsKKyAgICAgICAgdW5zaWduZWQgcmVtYWluaW5nUGlubmVkUmVn aXN0ZXJzID0gcGlubmVkU2l6ZXMuc2l6ZSgpICsgMTsKKyAgICAgICAganNjQ2FsbGluZ0NvbnZl bnRpb24oKS5tX2NhbGxlZVNhdmVSZWdpc3RlcnMuZm9yRWFjaChbJl0gKFJlZyByZWcpIHsKKyAg ICAgICAgICAgIEdQUlJlZyBncHIgPSByZWcuZ3ByKCk7CisgICAgICAgICAgICBpZiAoIXJlbWFp bmluZ1Bpbm5lZFJlZ2lzdGVycyB8fCBSZWdpc3RlclNldDo6c3RhY2tSZWdpc3RlcnMoKS5nZXQo cmVnKSkKKyAgICAgICAgICAgICAgICByZXR1cm47CisgICAgICAgICAgICBpZiAocmVtYWluaW5n UGlubmVkUmVnaXN0ZXJzID09IDEpIHsKKyAgICAgICAgICAgICAgICBiYXNlTWVtb3J5UG9pbnRl ciA9IGdwcjsKKyAgICAgICAgICAgICAgICByZW1haW5pbmdQaW5uZWRSZWdpc3RlcnMtLTsKKyAg ICAgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgICAgIHNpemVSZWdpc3RlcnMuYXBwZW5kKHsg Z3ByLCBwaW5uZWRTaXplc1stLXJlbWFpbmluZ1Bpbm5lZFJlZ2lzdGVycyAtIDFdIH0pOworICAg ICAgICB9KTsKKworICAgICAgICBBU1NFUlQoIXJlbWFpbmluZ1Bpbm5lZFJlZ2lzdGVycyk7Cisg ICAgICAgIHN0YXRpY1Bpbm5lZFJlZ2lzdGVySW5mby5jb25zdHJ1Y3QoV1RGTW92ZShzaXplUmVn aXN0ZXJzKSwgYmFzZU1lbW9yeVBvaW50ZXIpOworICAgIH0pOworCisgICAgcmV0dXJuIHN0YXRp Y1Bpbm5lZFJlZ2lzdGVySW5mby5nZXQoKTsKK30KKworUGlubmVkUmVnaXN0ZXJJbmZvOjpQaW5u ZWRSZWdpc3RlckluZm8oVmVjdG9yPFBpbm5lZFNpemVSZWdpc3RlckluZm8+JiYgc2l6ZVJlZ2lz dGVycywgR1BSUmVnIGJhc2VNZW1vcnlQb2ludGVyKQorICAgIDogc2l6ZVJlZ2lzdGVycyhXVEZN b3ZlKHNpemVSZWdpc3RlcnMpKQorICAgICwgYmFzZU1lbW9yeVBvaW50ZXIoYmFzZU1lbW9yeVBv aW50ZXIpCit7Cit9CisKK01lbW9yeUluZm9ybWF0aW9uOjpNZW1vcnlJbmZvcm1hdGlvbihQYWdl Q291bnQgaW5pdGlhbCwgUGFnZUNvdW50IG1heGltdW0sICBib29sIGlzSW1wb3J0KQogICAgIDog bV9pbml0aWFsKGluaXRpYWwpCiAgICAgLCBtX21heGltdW0obWF4aW11bSkKICAgICAsIG1faXNJ bXBvcnQoaXNJbXBvcnQpCkBAIC00MCwyMCArNzksNiBAQCBNZW1vcnlJbmZvcm1hdGlvbjo6TWVt b3J5SW5mb3JtYXRpb24oUGFnZUNvdW50IGluaXRpYWwsIFBhZ2VDb3VudCBtYXhpbXVtLCAgY29u cwogICAgIFJFTEVBU0VfQVNTRVJUKCEhbV9pbml0aWFsKTsKICAgICBSRUxFQVNFX0FTU0VSVCgh bV9tYXhpbXVtIHx8IG1fbWF4aW11bSA+PSBtX2luaXRpYWwpOwogICAgIEFTU0VSVCghISp0aGlz KTsKLQotICAgIHVuc2lnbmVkIHJlbWFpbmluZ1Bpbm5lZFJlZ2lzdGVycyA9IHBpbm5lZFNpemVS ZWdpc3RlcnMuc2l6ZSgpICsgMTsKLSAgICBqc2NDYWxsaW5nQ29udmVudGlvbigpLm1fY2FsbGVl U2F2ZVJlZ2lzdGVycy5mb3JFYWNoKFsmXSAoUmVnIHJlZykgewotICAgICAgICBHUFJSZWcgZ3By ID0gcmVnLmdwcigpOwotICAgICAgICBpZiAoIXJlbWFpbmluZ1Bpbm5lZFJlZ2lzdGVycyB8fCBS ZWdpc3RlclNldDo6c3RhY2tSZWdpc3RlcnMoKS5nZXQocmVnKSkKLSAgICAgICAgICAgIHJldHVy bjsKLSAgICAgICAgaWYgKHJlbWFpbmluZ1Bpbm5lZFJlZ2lzdGVycyA9PSAxKSB7Ci0gICAgICAg ICAgICBtX3Bpbm5lZFJlZ2lzdGVycy5iYXNlTWVtb3J5UG9pbnRlciA9IGdwcjsKLSAgICAgICAg ICAgIHJlbWFpbmluZ1Bpbm5lZFJlZ2lzdGVycy0tOwotICAgICAgICB9IGVsc2UKLSAgICAgICAg ICAgIG1fcGlubmVkUmVnaXN0ZXJzLnNpemVSZWdpc3RlcnMuYXBwZW5kKHsgZ3ByLCBwaW5uZWRT aXplUmVnaXN0ZXJzWy0tcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzIC0gMV0gfSk7Ci0gICAgfSk7 Ci0KLSAgICBBU1NFUlQoIXJlbWFpbmluZ1Bpbm5lZFJlZ2lzdGVycyk7CiB9CiAKIH0gfSAvLyBu YW1lc3BhY2UgSlNDOjpXYXNtCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtTWVtb3J5SW5mb3JtYXRpb24uaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dh c21NZW1vcnlJbmZvcm1hdGlvbi5oCmluZGV4IGVlNjNkOWUuLjZlN2Y1MjEgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnlJbmZvcm1hdGlvbi5oCisrKyBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnlJbmZvcm1hdGlvbi5oCkBAIC0z OCwxMiArMzgsMTEgQEAgc3RydWN0IFBpbm5lZFNpemVSZWdpc3RlckluZm8gewogICAgIHVuc2ln bmVkIHNpemVPZmZzZXQ7CiB9OwogCi0vLyBGSVhNRTogV2Ugc2hvdWxkIHN1cHBvcnQgbW9yZSB0 aGFuIG9uZSBtZW1vcnkgc2l6ZSByZWdpc3Rlci4gUmlnaHQgbm93IHdlIHRha2UgYSB2ZWN0b3Ig d2l0aCBvbmx5IG9uZQotLy8gZW50cnkuIFNwZWNpZmljYWxseSBhbiBlbnRyeSB3aGVyZSB0aGUg c2l6ZU9mZnNldCA9PSAwLiBJZiB3ZSBoYXZlIG1vcmUgdGhhbiBvbmUgc2l6ZSByZWdpc3RlciwK LS8vIHdlIGNhbiBoYXZlIG9uZSBmb3IgZWFjaCBsb2FkIHNpemUgY2xhc3MuIHNlZTogaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2Mjk1Mgogc3RydWN0IFBpbm5lZFJl Z2lzdGVySW5mbyB7CiAgICAgVmVjdG9yPFBpbm5lZFNpemVSZWdpc3RlckluZm8+IHNpemVSZWdp c3RlcnM7CiAgICAgR1BSUmVnIGJhc2VNZW1vcnlQb2ludGVyOworICAgIHN0YXRpYyBjb25zdCBQ aW5uZWRSZWdpc3RlckluZm8mIGdldCgpOworICAgIFBpbm5lZFJlZ2lzdGVySW5mbyhWZWN0b3I8 UGlubmVkU2l6ZVJlZ2lzdGVySW5mbz4mJiwgR1BSUmVnKTsKIH07CiAKIGNsYXNzIE1lbW9yeUlu Zm9ybWF0aW9uIHsKQEAgLTUzLDkgKzUyLDggQEAgcHVibGljOgogICAgICAgICBBU1NFUlQoISp0 aGlzKTsKICAgICB9CiAKLSAgICBNZW1vcnlJbmZvcm1hdGlvbihQYWdlQ291bnQgaW5pdGlhbCwg UGFnZUNvdW50IG1heGltdW0sIGNvbnN0IFZlY3Rvcjx1bnNpZ25lZD4mIHBpbm5lZFNpemVSZWdp c3RlcnMsIGJvb2wgaXNJbXBvcnQpOworICAgIE1lbW9yeUluZm9ybWF0aW9uKFBhZ2VDb3VudCBp bml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSwgYm9vbCBpc0ltcG9ydCk7CiAKLSAgICBjb25zdCBQ aW5uZWRSZWdpc3RlckluZm8mIHBpbm5lZFJlZ2lzdGVycygpIGNvbnN0IHsgcmV0dXJuIG1fcGlu bmVkUmVnaXN0ZXJzOyB9CiAgICAgUGFnZUNvdW50IGluaXRpYWwoKSBjb25zdCB7IHJldHVybiBt X2luaXRpYWw7IH0KICAgICBQYWdlQ291bnQgbWF4aW11bSgpIGNvbnN0IHsgcmV0dXJuIG1fbWF4 aW11bTsgfQogICAgIGJvb2wgaXNJbXBvcnQoKSBjb25zdCB7IHJldHVybiBtX2lzSW1wb3J0OyB9 CkBAIC02NSw3ICs2Myw2IEBAIHB1YmxpYzoKIHByaXZhdGU6CiAgICAgUGFnZUNvdW50IG1faW5p dGlhbCB7IH07CiAgICAgUGFnZUNvdW50IG1fbWF4aW11bSB7IH07Ci0gICAgUGlubmVkUmVnaXN0 ZXJJbmZvIG1fcGlubmVkUmVnaXN0ZXJzIHsgfTsKICAgICBib29sIG1faXNJbXBvcnQgeyBmYWxz ZSB9OwogfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1v ZHVsZVBhcnNlci5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFy c2VyLmNwcAppbmRleCA2MjYxZTdmLi4zMDExYzg5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmNwcApAQCAtMTA3LDcgKzEwNyw3IEBAIGF1dG8g TW9kdWxlUGFyc2VyOjpwYXJzZVR5cGUoKSAtPiBQYXJ0aWFsUmVzdWx0CiAKICAgICBXQVNNX1BB UlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihjb3VudCksICJjYW4ndCBnZXQgVHlwZSBzZWN0 aW9uJ3MgY291bnQiKTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGNvdW50ID09IHN0ZDo6bnVt ZXJpY19saW1pdHM8dWludDMyX3Q+OjptYXgoKSwgIlR5cGUgc2VjdGlvbidzIGNvdW50IGlzIHRv byBiaWcgIiwgY291bnQpOwotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0Lm1vZHVs ZS0+c2lnbmF0dXJlSW5kaWNlcy50cnlSZXNlcnZlQ2FwYWNpdHkoY291bnQpLCAiY2FuJ3QgYWxs b2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgVHlwZSBzZWN0aW9uJ3MgIiwgY291bnQsICIgZW50cmll cyIpOworICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0Lm1vZHVsZVNpZ25hdHVyZUlu ZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzLnRyeVJlc2VydmVDYXBhY2l0eShjb3VudCks ICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciBUeXBlIHNlY3Rpb24ncyAiLCBjb3Vu dCwgIiBlbnRyaWVzIik7CiAKICAgICBmb3IgKHVpbnQzMl90IGkgPSAwOyBpIDwgY291bnQ7ICsr aSkgewogICAgICAgICBpbnQ4X3QgdHlwZTsKQEAgLTEzOSw3ICsxMzksNyBAQCBhdXRvIE1vZHVs ZVBhcnNlcjo6cGFyc2VUeXBlKCkgLT4gUGFydGlhbFJlc3VsdAogICAgICAgICBzaWduYXR1cmUt PnJldHVyblR5cGUoKSA9IHJldHVyblR5cGU7CiAKICAgICAgICAgU2lnbmF0dXJlSW5kZXggc2ln bmF0dXJlSW5kZXggPSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6YWRvcHQobV92bSwgc2lnbmF0dXJl LnJlbGVhc2UoKSk7Ci0gICAgICAgIG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlcy51 bmNoZWNrZWRBcHBlbmQoc2lnbmF0dXJlSW5kZXgpOworICAgICAgICBtX3Jlc3VsdC5tb2R1bGVT aWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy51bmNoZWNrZWRBcHBlbmQo c2lnbmF0dXJlSW5kZXgpOwogICAgIH0KICAgICByZXR1cm4geyB9OwogfQpAQCAtMTUyLDcgKzE1 Miw2IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZUltcG9ydCgpIC0+IFBhcnRpYWxSZXN1bHQK ICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX3Jlc3VsdC5tb2R1bGUtPmdsb2JhbHMudHJ5UmVz ZXJ2ZUNhcGFjaXR5KGltcG9ydENvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkg Zm9yICIsIGltcG9ydENvdW50LCAiIGdsb2JhbHMiKTsgLy8gRklYTUUgdGhpcyBvdmVyLWFsbG9j YXRlcyB3aGVuIHdlIGZpeCB0aGUgRklYTUVzIGJlbG93LgogICAgIFdBU01fUEFSU0VSX0ZBSUxf SUYoIW1fcmVzdWx0Lm1vZHVsZS0+aW1wb3J0cy50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291 bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIg aW1wb3J0cyIpOyAvLyBGSVhNRSB0aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBG SVhNRXMgYmVsb3cuCiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlLT5p bXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGltcG9ydENv dW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGltcG9ydENvdW50LCAi IGltcG9ydCBmdW5jdGlvbiBzaWduYXR1cmVzIik7IC8vIEZJWE1FIHRoaXMgb3Zlci1hbGxvY2F0 ZXMgd2hlbiB3ZSBmaXggdGhlIEZJWE1FcyBiZWxvdy4KLSAgICBXQVNNX1BBUlNFUl9GQUlMX0lG KCFtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2UudHJ5UmVzZXJ2ZUNhcGFjaXR5KGltcG9ydENv dW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGltcG9ydENvdW50LCAi IGZ1bmN0aW9ucyBpbiB0aGUgaW5kZXggc3BhY2UiKTsgLy8gRklYTUUgdGhpcyBvdmVyLWFsbG9j YXRlcyB3aGVuIHdlIGZpeCB0aGUgRklYTUVzIGJlbG93LiBXZSdsbCBhbGxvY2F0ZSBzb21lIG1v cmUgaGVyZSB3aGVuIHdlIGtub3cgaG93IG1hbnkgZnVuY3Rpb25zIHRvIGV4cGVjdC4KIAogICAg IGZvciAodWludDMyX3QgaW1wb3J0TnVtYmVyID0gMDsgaW1wb3J0TnVtYmVyIDwgaW1wb3J0Q291 bnQ7ICsraW1wb3J0TnVtYmVyKSB7CiAgICAgICAgIEltcG9ydCBpbXA7CkBAIC0xNzQsMTEgKzE3 MywxMCBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VJbXBvcnQoKSAtPiBQYXJ0aWFsUmVzdWx0 CiAgICAgICAgIGNhc2UgRXh0ZXJuYWxLaW5kOjpGdW5jdGlvbjogewogICAgICAgICAgICAgdWlu dDMyX3QgZnVuY3Rpb25TaWduYXR1cmVJbmRleDsKICAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZB SUxfSUYoIXBhcnNlVmFyVUludDMyKGZ1bmN0aW9uU2lnbmF0dXJlSW5kZXgpLCAiY2FuJ3QgZ2V0 ICIsIGltcG9ydE51bWJlciwgInRoIEltcG9ydCdzIGZ1bmN0aW9uIHNpZ25hdHVyZSBpbiBtb2R1 bGUgJyIsIG1vZHVsZVN0cmluZywgIicgZmllbGQgJyIsIGZpZWxkU3RyaW5nLCAiJyIpOwotICAg ICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvblNpZ25hdHVyZUluZGV4ID49IG1f cmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICJpbnZhbGlkIGZ1bmN0aW9u IHNpZ25hdHVyZSBmb3IgIiwgaW1wb3J0TnVtYmVyLCAidGggSW1wb3J0LCAiLCBmdW5jdGlvblNp Z25hdHVyZUluZGV4LCAiIGlzIG91dCBvZiByYW5nZSBvZiAiLCBtX3Jlc3VsdC5tb2R1bGUtPnNp Z25hdHVyZUluZGljZXMuc2l6ZSgpLCAiIGluIG1vZHVsZSAnIiwgbW9kdWxlU3RyaW5nLCAiJyBm aWVsZCAnIiwgZmllbGRTdHJpbmcsICInIik7CisgICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlM X0lGKGZ1bmN0aW9uU2lnbmF0dXJlSW5kZXggPj0gbV9yZXN1bHQubW9kdWxlU2lnbmF0dXJlSW5k aWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMuc2l6ZSgpLCAiaW52YWxpZCBmdW5jdGlvbiBz aWduYXR1cmUgZm9yICIsIGltcG9ydE51bWJlciwgInRoIEltcG9ydCwgIiwgZnVuY3Rpb25TaWdu YXR1cmVJbmRleCwgIiBpcyBvdXQgb2YgcmFuZ2Ugb2YgIiwgbV9yZXN1bHQubW9kdWxlU2lnbmF0 dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMuc2l6ZSgpLCAiIGluIG1vZHVsZSAn IiwgbW9kdWxlU3RyaW5nLCAiJyBmaWVsZCAnIiwgZmllbGRTdHJpbmcsICInIik7CiAgICAgICAg ICAgICBpbXAua2luZEluZGV4ID0gbV9yZXN1bHQubW9kdWxlLT5pbXBvcnRGdW5jdGlvblNpZ25h dHVyZUluZGljZXMuc2l6ZSgpOwotICAgICAgICAgICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJl SW5kZXggPSBtX3Jlc3VsdC5tb2R1bGUtPnNpZ25hdHVyZUluZGljZXNbZnVuY3Rpb25TaWduYXR1 cmVJbmRleF07CisgICAgICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1f cmVzdWx0Lm1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzW2Z1 bmN0aW9uU2lnbmF0dXJlSW5kZXhdOwogICAgICAgICAgICAgbV9yZXN1bHQubW9kdWxlLT5pbXBv cnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMudW5jaGVja2VkQXBwZW5kKHNpZ25hdHVyZUluZGV4 KTsKLSAgICAgICAgICAgIG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS51bmNoZWNrZWRBcHBl bmQoc2lnbmF0dXJlSW5kZXgpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIH0KICAgICAg ICAgY2FzZSBFeHRlcm5hbEtpbmQ6OlRhYmxlOiB7CkBAIC0yMjAsMjAgKzIxOCwxOCBAQCBhdXRv IE1vZHVsZVBhcnNlcjo6cGFyc2VGdW5jdGlvbigpIC0+IFBhcnRpYWxSZXN1bHQKICAgICBXQVNN X1BBUlNFUl9GQUlMX0lGKGNvdW50ID09IHN0ZDo6bnVtZXJpY19saW1pdHM8dWludDMyX3Q+Ojpt YXgoKSwgIkZ1bmN0aW9uIHNlY3Rpb24ncyBjb3VudCBpcyB0b28gYmlnICIsIGNvdW50KTsKICAg ICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX3Jlc3VsdC5tb2R1bGUtPmludGVybmFsRnVuY3Rpb25T aWduYXR1cmVJbmRpY2VzLnRyeVJlc2VydmVDYXBhY2l0eShjb3VudCksICJjYW4ndCBhbGxvY2F0 ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBjb3VudCwgIiBGdW5jdGlvbiBzaWduYXR1cmVzIik7CiAg ICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQuZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5 LnRyeVJlc2VydmVDYXBhY2l0eShjb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5 IGZvciAiLCBjb3VudCwgIkZ1bmN0aW9uIGxvY2F0aW9ucyIpOwotICAgIFdBU01fUEFSU0VSX0ZB SUxfSUYoIW1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS50cnlSZXNlcnZlQ2FwYWNpdHkobV9y ZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnNpemUoKSArIGNvdW50KSwgImNhbid0IGFsbG9jYXRl IGVub3VnaCBtZW1vcnkgZm9yICIsIGNvdW50LCAiIG1vcmUgZnVuY3Rpb25zIGluIHRoZSBmdW5j dGlvbiBpbmRleCBzcGFjZSIpOwogCiAgICAgZm9yICh1aW50MzJfdCBpID0gMDsgaSA8IGNvdW50 OyArK2kpIHsKICAgICAgICAgdWludDMyX3QgdHlwZU51bWJlcjsKICAgICAgICAgV0FTTV9QQVJT RVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIodHlwZU51bWJlciksICJjYW4ndCBnZXQgIiwgaSwg InRoIEZ1bmN0aW9uJ3MgdHlwZSBudW1iZXIiKTsKLSAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9J Rih0eXBlTnVtYmVyID49IG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlcy5zaXplKCks IGksICJ0aCBGdW5jdGlvbiB0eXBlIG51bWJlciBpcyBpbnZhbGlkICIsIHR5cGVOdW1iZXIpOwor ICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHR5cGVOdW1iZXIgPj0gbV9yZXN1bHQubW9kdWxl U2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMuc2l6ZSgpLCBpLCAidGgg RnVuY3Rpb24gdHlwZSBudW1iZXIgaXMgaW52YWxpZCAiLCB0eXBlTnVtYmVyKTsKIAotICAgICAg ICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0 dXJlSW5kaWNlc1t0eXBlTnVtYmVyXTsKKyAgICAgICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJl SW5kZXggPSBtX3Jlc3VsdC5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJl SW5kaWNlc1t0eXBlTnVtYmVyXTsKICAgICAgICAgLy8gVGhlIENvZGUgc2VjdGlvbiBmaXhlcyB1 cCBzdGFydCBhbmQgZW5kLgogICAgICAgICBzaXplX3Qgc3RhcnQgPSAwOwogICAgICAgICBzaXpl X3QgZW5kID0gMDsKICAgICAgICAgbV9yZXN1bHQubW9kdWxlLT5pbnRlcm5hbEZ1bmN0aW9uU2ln bmF0dXJlSW5kaWNlcy51bmNoZWNrZWRBcHBlbmQoc2lnbmF0dXJlSW5kZXgpOwogICAgICAgICBt X3Jlc3VsdC5mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkudW5jaGVja2VkQXBwZW5kKHsgc3RhcnQs IGVuZCB9KTsKLSAgICAgICAgbV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnVuY2hlY2tlZEFw cGVuZChzaWduYXR1cmVJbmRleCk7CiAgICAgfQogCiAgICAgcmV0dXJuIHsgfTsKQEAgLTMyMCw4 ICszMTYsNyBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VNZW1vcnlIZWxwZXIoYm9vbCBpc0lt cG9ydCkgLT4gUGFydGlhbFJlc3VsdAogICAgIEFTU0VSVChpbml0aWFsUGFnZUNvdW50KTsKICAg ICBBU1NFUlQoIW1heGltdW1QYWdlQ291bnQgfHwgbWF4aW11bVBhZ2VDb3VudCA+PSBpbml0aWFs UGFnZUNvdW50KTsKIAotICAgIFZlY3Rvcjx1bnNpZ25lZD4gcGlubmVkU2l6ZXMgPSB7IDAgfTsK LSAgICBtX3Jlc3VsdC5tb2R1bGUtPm1lbW9yeSA9IE1lbW9yeUluZm9ybWF0aW9uKGluaXRpYWxQ YWdlQ291bnQsIG1heGltdW1QYWdlQ291bnQsIHBpbm5lZFNpemVzLCBpc0ltcG9ydCk7CisgICAg bV9yZXN1bHQubW9kdWxlLT5tZW1vcnkgPSBNZW1vcnlJbmZvcm1hdGlvbihpbml0aWFsUGFnZUNv dW50LCBtYXhpbXVtUGFnZUNvdW50LCBpc0ltcG9ydCk7CiAgICAgcmV0dXJuIHsgfTsKIH0KIApA QCAtMzg3LDcgKzM4Miw3IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZUV4cG9ydCgpIC0+IFBh cnRpYWxSZXN1bHQKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIo ZXhwLmtpbmRJbmRleCksICJjYW4ndCBnZXQgIiwgZXhwb3J0TnVtYmVyLCAidGggRXhwb3J0J3Mg a2luZCBpbmRleCwgbmFtZWQgJyIsIGZpZWxkU3RyaW5nLCAiJyIpOwogICAgICAgICBzd2l0Y2gg KGV4cC5raW5kKSB7CiAgICAgICAgIGNhc2UgRXh0ZXJuYWxLaW5kOjpGdW5jdGlvbjogewotICAg ICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihleHAua2luZEluZGV4ID49IG1fcmVzdWx0LmZ1 bmN0aW9uSW5kZXhTcGFjZS5zaXplKCksIGV4cG9ydE51bWJlciwgInRoIEV4cG9ydCBoYXMgaW52 YWxpZCBmdW5jdGlvbiBudW1iZXIgIiwgZXhwLmtpbmRJbmRleCwgIiBpdCBleGNlZWRzIHRoZSBm dW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgp LCAiLCBuYW1lZCAnIiwgZmllbGRTdHJpbmcsICInIik7CisgICAgICAgICAgICBXQVNNX1BBUlNF Ul9GQUlMX0lGKGV4cC5raW5kSW5kZXggPj0gbV9yZXN1bHQubW9kdWxlLT5mdW5jdGlvbkluZGV4 U3BhY2VTaXplKCksIGV4cG9ydE51bWJlciwgInRoIEV4cG9ydCBoYXMgaW52YWxpZCBmdW5jdGlv biBudW1iZXIgIiwgZXhwLmtpbmRJbmRleCwgIiBpdCBleGNlZWRzIHRoZSBmdW5jdGlvbiBpbmRl eCBzcGFjZSAiLCBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSwgIiwg bmFtZWQgJyIsIGZpZWxkU3RyaW5nLCAiJyIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAg IH0KICAgICAgICAgY2FzZSBFeHRlcm5hbEtpbmQ6OlRhYmxlOiB7CkBAIC00MTcsOCArNDEyLDgg QEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlU3RhcnQoKSAtPiBQYXJ0aWFsUmVzdWx0CiB7CiAg ICAgdWludDMyX3Qgc3RhcnRGdW5jdGlvbkluZGV4OwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYo IXBhcnNlVmFyVUludDMyKHN0YXJ0RnVuY3Rpb25JbmRleCksICJjYW4ndCBnZXQgU3RhcnQgaW5k ZXgiKTsKLSAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHN0YXJ0RnVuY3Rpb25JbmRleCA+PSBtX3Jl c3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpLCAiU3RhcnQgaW5kZXggIiwgc3RhcnRGdW5j dGlvbkluZGV4LCAiIGV4Y2VlZHMgZnVuY3Rpb24gaW5kZXggc3BhY2UgIiwgbV9yZXN1bHQuZnVu Y3Rpb25JbmRleFNwYWNlLnNpemUoKSk7Ci0gICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5k ZXggPSBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Vbc3RhcnRGdW5jdGlvbkluZGV4XS5zaWdu YXR1cmVJbmRleDsKKyAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHN0YXJ0RnVuY3Rpb25JbmRleCA+ PSBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSwgIlN0YXJ0IGluZGV4 ICIsIHN0YXJ0RnVuY3Rpb25JbmRleCwgIiBleGNlZWRzIGZ1bmN0aW9uIGluZGV4IHNwYWNlICIs IG1fcmVzdWx0Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpKTsKKyAgICBTaWduYXR1 cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kZXhG cm9tRnVuY3Rpb25JbmRleFNwYWNlKHN0YXJ0RnVuY3Rpb25JbmRleCk7CiAgICAgY29uc3QgU2ln bmF0dXJlKiBzaWduYXR1cmUgPSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KG1fdm0sIHNpZ25h dHVyZUluZGV4KTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHNpZ25hdHVyZS0+YXJndW1lbnRD b3VudCgpLCAiU3RhcnQgZnVuY3Rpb24gY2FuJ3QgaGF2ZSBhcmd1bWVudHMiKTsKICAgICBXQVNN X1BBUlNFUl9GQUlMX0lGKHNpZ25hdHVyZS0+cmV0dXJuVHlwZSgpICE9IFZvaWQsICJTdGFydCBm dW5jdGlvbiBjYW4ndCByZXR1cm4gYSB2YWx1ZSIpOwpAQCAtNDY5LDcgKzQ2NCw3IEBAIGF1dG8g TW9kdWxlUGFyc2VyOjpwYXJzZUVsZW1lbnQoKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgICAgIGZv ciAodW5zaWduZWQgaW5kZXggPSAwOyBpbmRleCA8IGluZGV4Q291bnQ7ICsraW5kZXgpIHsKICAg ICAgICAgICAgIHVpbnQzMl90IGZ1bmN0aW9uSW5kZXg7CiAgICAgICAgICAgICBXQVNNX1BBUlNF Ul9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihmdW5jdGlvbkluZGV4KSwgImNhbid0IGdldCBFbGVt ZW50IHNlY3Rpb24ncyAiLCBlbGVtZW50TnVtLCAidGggZWxlbWVudCdzICIsIGluZGV4LCAidGgg aW5kZXgiKTsKLSAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVuY3Rpb25JbmRleCA+ PSBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpLCAiRWxlbWVudCBzZWN0aW9uJ3Mg IiwgZWxlbWVudE51bSwgInRoIGVsZW1lbnQncyAiLCBpbmRleCwgInRoIGluZGV4IGlzICIsIGZ1 bmN0aW9uSW5kZXgsICIgd2hpY2ggZXhjZWVkcyB0aGUgZnVuY3Rpb24gaW5kZXggc3BhY2Ugc2l6 ZSBvZiAiLCBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpKTsKKyAgICAgICAgICAg IFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVuY3Rpb25JbmRleCA+PSBtX3Jlc3VsdC5tb2R1bGUtPmZ1 bmN0aW9uSW5kZXhTcGFjZVNpemUoKSwgIkVsZW1lbnQgc2VjdGlvbidzICIsIGVsZW1lbnROdW0s ICJ0aCBlbGVtZW50J3MgIiwgaW5kZXgsICJ0aCBpbmRleCBpcyAiLCBmdW5jdGlvbkluZGV4LCAi IHdoaWNoIGV4Y2VlZHMgdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlIHNpemUgb2YgIiwgbV9yZXN1 bHQubW9kdWxlLT5mdW5jdGlvbkluZGV4U3BhY2VTaXplKCkpOwogCiAgICAgICAgICAgICBlbGVt ZW50LmZ1bmN0aW9uSW5kaWNlcy51bmNoZWNrZWRBcHBlbmQoZnVuY3Rpb25JbmRleCk7CiAgICAg ICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQ YXJzZXIuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuaApp bmRleCBlM2I3NWE3Li43ZTAyNmM5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9XYXNtTW9kdWxlUGFyc2VyLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbU1vZHVsZVBhcnNlci5oCkBAIC0zNiw4ICszNiw4IEBAIG5hbWVzcGFjZSBKU0MgeyBuYW1l c3BhY2UgV2FzbSB7CiAKIHN0cnVjdCBNb2R1bGVQYXJzZXJSZXN1bHQgewogICAgIHN0ZDo6dW5p cXVlX3B0cjxNb2R1bGVJbmZvcm1hdGlvbj4gbW9kdWxlOwotICAgIEZ1bmN0aW9uSW5kZXhTcGFj ZSBmdW5jdGlvbkluZGV4U3BhY2U7CiAgICAgVmVjdG9yPEZ1bmN0aW9uTG9jYXRpb25JbkJpbmFy eT4gZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5OworICAgIFZlY3RvcjxTaWduYXR1cmVJbmRleD4g bW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXM7CiB9OwogCiBj bGFzcyBNb2R1bGVQYXJzZXIgOiBwdWJsaWMgUGFyc2VyPE1vZHVsZVBhcnNlclJlc3VsdD4gewpk aWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBhZ2VDb3VudC5jcHAg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFnZUNvdW50LmNwcApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40Yjg3NzA1Ci0tLSAvZGV2L251bGwKKysrIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBhZ2VDb3VudC5jcHAKQEAgLTAsMCArMSw0NSBA QAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNiBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAg IGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBk aXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJ TkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVT IE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQ T1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICog Q09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5U QUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5D TFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRF IEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9S IEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkK KyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwg T1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJ TiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFE VklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRl ICJjb25maWcuaCIKKyNpbmNsdWRlICJXYXNtUGFnZUNvdW50LmgiCisKKyNpZiBFTkFCTEUoV0VC QVNTRU1CTFkpCisKKyNpbmNsdWRlIDx3dGYvUHJpbnRTdHJlYW0uaD4KKyNpbmNsdWRlIDx3dGYv dGV4dC9XVEZTdHJpbmcuaD4KKworbmFtZXNwYWNlIEpTQyB7IG5hbWVzcGFjZSBXYXNtIHsKKwor dm9pZCBQYWdlQ291bnQ6OmR1bXAoUHJpbnRTdHJlYW0mIG91dCkgY29uc3QKK3sKKyAgICBvdXQu cHJpbnQoU3RyaW5nOjpudW1iZXIoYnl0ZXMoKSksICJCIik7Cit9CisKK30gLy8gbmFtZXNwYWNl IEpTQworCit9IC8vIG5hbWVzcGFjZSBXYXNtCisKKyNlbmRpZiAvLyBFTkFCTEUoV0VCQVNTRU1C TFkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFnZUNvdW50 LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFnZUNvdW50LmgKaW5kZXggYTE1 ZDUwNS4uNjdkYmI1NSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bVBhZ2VDb3VudC5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QYWdlQ291 bnQuaApAQCAtMjcsNiArMjcsMTAgQEAKIAogI2lmIEVOQUJMRShXRUJBU1NFTUJMWSkKIAorbmFt ZXNwYWNlIFdURiB7CitjbGFzcyBQcmludFN0cmVhbTsKK30KKwogbmFtZXNwYWNlIEpTQyB7IG5h bWVzcGFjZSBXYXNtIHsKIAogY2xhc3MgUGFnZUNvdW50IHsKQEAgLTQyLDYgKzQ2LDggQEAgcHVi bGljOgogICAgICAgICA6IG1fcGFnZUNvdW50KHBhZ2VDb3VudCkKICAgICB7IH0KIAorICAgIHZv aWQgZHVtcChXVEY6OlByaW50U3RyZWFtJikgY29uc3Q7CisKICAgICB1aW50NjRfdCBieXRlcygp IGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PHVpbnQ2NF90PihtX3BhZ2VDb3VudCkgKiBzdGF0 aWNfY2FzdDx1aW50NjRfdD4ocGFnZVNpemUpOyB9CiAgICAgdWludDMyX3QgcGFnZUNvdW50KCkg Y29uc3QgeyByZXR1cm4gbV9wYWdlQ291bnQ7IH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbVBsYW4uY3BwCmluZGV4IGVkMjhiYmMuLjJkMzQyMmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtUGxhbi5jcHAKQEAgLTc2LDggKzc2LDcgQEAgYm9vbCBQbGFuOjpwYXJzZUFu ZFZhbGlkYXRlTW9kdWxlKCkKICAgICAgICAgfQogICAgICAgICBtX21vZHVsZUluZm9ybWF0aW9u ID0gV1RGTW92ZShwYXJzZVJlc3VsdC0+bW9kdWxlKTsKICAgICAgICAgbV9mdW5jdGlvbkxvY2F0 aW9uSW5CaW5hcnkgPSBXVEZNb3ZlKHBhcnNlUmVzdWx0LT5mdW5jdGlvbkxvY2F0aW9uSW5CaW5h cnkpOwotICAgICAgICBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5zaXplID0gcGFyc2VSZXN1bHQtPmZ1 bmN0aW9uSW5kZXhTcGFjZS5zaXplKCk7Ci0gICAgICAgIG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1 ZmZlciA9IHBhcnNlUmVzdWx0LT5mdW5jdGlvbkluZGV4U3BhY2UucmVsZWFzZUJ1ZmZlcigpOwor ICAgICAgICBtX21vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2Vz ID0gV1RGTW92ZShwYXJzZVJlc3VsdC0+bW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNp Z25hdHVyZUluZGljZXMpOwogICAgIH0KIAogICAgIGZvciAodW5zaWduZWQgZnVuY3Rpb25JbmRl eCA9IDA7IGZ1bmN0aW9uSW5kZXggPCBtX2Z1bmN0aW9uTG9jYXRpb25JbkJpbmFyeS5zaXplKCk7 ICsrZnVuY3Rpb25JbmRleCkgewpAQCAtODksNyArODgsNyBAQCBib29sIFBsYW46OnBhcnNlQW5k VmFsaWRhdGVNb2R1bGUoKQogICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9 IG1fbW9kdWxlSW5mb3JtYXRpb24tPmludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzW2Z1 bmN0aW9uSW5kZXhdOwogICAgICAgICBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFNpZ25h dHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgc2lnbmF0dXJlSW5kZXgpOwogCi0gICAgICAgIGF1 dG8gdmFsaWRhdGlvblJlc3VsdCA9IHZhbGlkYXRlRnVuY3Rpb24obV92bSwgZnVuY3Rpb25TdGFy dCwgZnVuY3Rpb25MZW5ndGgsIHNpZ25hdHVyZSwgbV9mdW5jdGlvbkluZGV4U3BhY2UsICptX21v ZHVsZUluZm9ybWF0aW9uKTsKKyAgICAgICAgYXV0byB2YWxpZGF0aW9uUmVzdWx0ID0gdmFsaWRh dGVGdW5jdGlvbihtX3ZtLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJl LCAqbV9tb2R1bGVJbmZvcm1hdGlvbiwgbV9tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVk U2lnbmF0dXJlSW5kaWNlcyk7CiAgICAgICAgIGlmICghdmFsaWRhdGlvblJlc3VsdCkgewogICAg ICAgICAgICAgaWYgKHZlcmJvc2UpIHsKICAgICAgICAgICAgICAgICBmb3IgKHVuc2lnbmVkIGkg PSAwOyBpIDwgZnVuY3Rpb25MZW5ndGg7ICsraSkKQEAgLTEyNyw3ICsxMjYsNyBAQCB2b2lkIFBs YW46OnJ1bigpCiAgICAgICAgIHJldHVybiB0cnVlOwogICAgIH07CiAKLSAgICBpZiAoIXRyeVJl c2VydmVDYXBhY2l0eShtX3dhc21Ub0pTU3R1YnMsIG1fbW9kdWxlSW5mb3JtYXRpb24tPmltcG9y dEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICIgV2ViQXNzZW1ibHkgdG8gSmF2YVNj cmlwdCBzdHVicyIpCisgICAgaWYgKCF0cnlSZXNlcnZlQ2FwYWNpdHkobV93YXNtRXhpdFN0dWJz LCBtX21vZHVsZUluZm9ybWF0aW9uLT5pbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMuc2l6 ZSgpLCAiIFdlYkFzc2VtYmx5IHRvIEphdmFTY3JpcHQgc3R1YnMiKQogICAgICAgICB8fCAhdHJ5 UmVzZXJ2ZUNhcGFjaXR5KG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIG1fZnVuY3Rpb25Mb2Nh dGlvbkluQmluYXJ5LnNpemUoKSwgIiB1bmxpbmtlZCBXZWJBc3NlbWJseSB0byBXZWJBc3NlbWJs eSBjYWxscyIpCiAgICAgICAgIHx8ICF0cnlSZXNlcnZlQ2FwYWNpdHkobV93YXNtSW50ZXJuYWxG dW5jdGlvbnMsIG1fZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5LnNpemUoKSwgIiBXZWJBc3NlbWJs eSBmdW5jdGlvbnMiKQogICAgICAgICB8fCAhdHJ5UmVzZXJ2ZUNhcGFjaXR5KG1fY29tcGlsYXRp b25Db250ZXh0cywgbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgpLCAiIGNvbXBpbGF0 aW9uIGNvbnRleHRzIikpCkBAIC0xNDEsMTIgKzE0MCwxMSBAQCB2b2lkIFBsYW46OnJ1bigpCiAg ICAgICAgIEltcG9ydCogaW1wb3J0ID0gJm1fbW9kdWxlSW5mb3JtYXRpb24tPmltcG9ydHNbaW1w b3J0SW5kZXhdOwogICAgICAgICBpZiAoaW1wb3J0LT5raW5kICE9IEV4dGVybmFsS2luZDo6RnVu Y3Rpb24pCiAgICAgICAgICAgICBjb250aW51ZTsKLSAgICAgICAgdW5zaWduZWQgaW1wb3J0RnVu Y3Rpb25JbmRleCA9IG1fd2FzbVRvSlNTdHVicy5zaXplKCk7CisgICAgICAgIHVuc2lnbmVkIGlt cG9ydEZ1bmN0aW9uSW5kZXggPSBtX3dhc21FeGl0U3R1YnMuc2l6ZSgpOwogICAgICAgICBpZiAo dmVyYm9zZSkKICAgICAgICAgICAgIGRhdGFMb2dMbigiUHJvY2Vzc2luZyBpbXBvcnQgZnVuY3Rp b24gbnVtYmVyICIsIGltcG9ydEZ1bmN0aW9uSW5kZXgsICI6ICIsIGltcG9ydC0+bW9kdWxlLCAi OiAiLCBpbXBvcnQtPmZpZWxkKTsKICAgICAgICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5k ZXggPSBtX21vZHVsZUluZm9ybWF0aW9uLT5pbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXMu YXQoaW1wb3J0LT5raW5kSW5kZXgpOwotICAgICAgICBtX3dhc21Ub0pTU3R1YnMudW5jaGVja2Vk QXBwZW5kKGltcG9ydFN0dWJHZW5lcmF0b3IobV92bSwgbV9jYWxsTGlua0luZm9zLCBzaWduYXR1 cmVJbmRleCwgaW1wb3J0RnVuY3Rpb25JbmRleCkpOwotICAgICAgICBtX2Z1bmN0aW9uSW5kZXhT cGFjZS5idWZmZXIuZ2V0KClbaW1wb3J0RnVuY3Rpb25JbmRleF0uY29kZSA9IG1fd2FzbVRvSlNT dHVic1tpbXBvcnRGdW5jdGlvbkluZGV4XS5jb2RlKCkuZXhlY3V0YWJsZUFkZHJlc3MoKTsKKyAg ICAgICAgbV93YXNtRXhpdFN0dWJzLnVuY2hlY2tlZEFwcGVuZChleGl0U3R1YkdlbmVyYXRvciht X3ZtLCBtX2NhbGxMaW5rSW5mb3MsIHNpZ25hdHVyZUluZGV4LCBpbXBvcnRGdW5jdGlvbkluZGV4 KSk7CiAgICAgfQogCiAgICAgbV9jdXJyZW50SW5kZXggPSAwOwpAQCAtMTY3LDEyICsxNjUsMTIg QEAgdm9pZCBQbGFuOjpydW4oKQogICAgICAgICAgICAgQVNTRVJUKGZ1bmN0aW9uTGVuZ3RoIDw9 IG1fc291cmNlTGVuZ3RoKTsKICAgICAgICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUlu ZGV4ID0gbV9tb2R1bGVJbmZvcm1hdGlvbi0+aW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGlj ZXNbZnVuY3Rpb25JbmRleF07CiAgICAgICAgICAgICBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVy ZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgc2lnbmF0dXJlSW5kZXgpOwotICAg ICAgICAgICAgdW5zaWduZWQgZnVuY3Rpb25JbmRleFNwYWNlID0gbV93YXNtVG9KU1N0dWJzLnNp emUoKSArIGZ1bmN0aW9uSW5kZXg7Ci0gICAgICAgICAgICBBU1NFUlRfVU5VU0VEKGZ1bmN0aW9u SW5kZXhTcGFjZSwgbV9mdW5jdGlvbkluZGV4U3BhY2UuYnVmZmVyLmdldCgpW2Z1bmN0aW9uSW5k ZXhTcGFjZV0uc2lnbmF0dXJlSW5kZXggPT0gc2lnbmF0dXJlSW5kZXgpOwotICAgICAgICAgICAg QVNTRVJUKHZhbGlkYXRlRnVuY3Rpb24obV92bSwgZnVuY3Rpb25TdGFydCwgZnVuY3Rpb25MZW5n dGgsIHNpZ25hdHVyZSwgbV9mdW5jdGlvbkluZGV4U3BhY2UsICptX21vZHVsZUluZm9ybWF0aW9u KSk7CisgICAgICAgICAgICB1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2UgPSBtX3dhc21FeGl0 U3R1YnMuc2l6ZSgpICsgZnVuY3Rpb25JbmRleDsKKyAgICAgICAgICAgIEFTU0VSVF9VTlVTRUQo ZnVuY3Rpb25JbmRleFNwYWNlLCBtX21vZHVsZUluZm9ybWF0aW9uLT5zaWduYXR1cmVJbmRleEZy b21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleFNwYWNlKSA9PSBzaWduYXR1cmVJbmRl eCk7CisgICAgICAgICAgICBBU1NFUlQodmFsaWRhdGVGdW5jdGlvbihtX3ZtLCBmdW5jdGlvblN0 YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCAqbV9tb2R1bGVJbmZvcm1hdGlvbiwgbV9t b2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcykpOwogCiAgICAg ICAgICAgICBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzW2Z1bmN0aW9uSW5kZXhdID0gVmVjdG9y PFVubGlua2VkV2FzbVRvV2FzbUNhbGw+KCk7Ci0gICAgICAgICAgICBhdXRvIHBhcnNlQW5kQ29t cGlsZVJlc3VsdCA9IHBhcnNlQW5kQ29tcGlsZSgqbV92bSwgbV9jb21waWxhdGlvbkNvbnRleHRz W2Z1bmN0aW9uSW5kZXhdLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJl LCBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzW2Z1bmN0aW9uSW5kZXhdLCBtX2Z1bmN0aW9uSW5k ZXhTcGFjZSwgKm1fbW9kdWxlSW5mb3JtYXRpb24pOworICAgICAgICAgICAgYXV0byBwYXJzZUFu ZENvbXBpbGVSZXN1bHQgPSBwYXJzZUFuZENvbXBpbGUoKm1fdm0sIG1fY29tcGlsYXRpb25Db250 ZXh0c1tmdW5jdGlvbkluZGV4XSwgZnVuY3Rpb25TdGFydCwgZnVuY3Rpb25MZW5ndGgsIHNpZ25h dHVyZSwgbV91bmxpbmtlZFdhc21Ub1dhc21DYWxsc1tmdW5jdGlvbkluZGV4XSwgKm1fbW9kdWxl SW5mb3JtYXRpb24sIG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUlu ZGljZXMpOwogCiAgICAgICAgICAgICBpZiAoVU5MSUtFTFkoIXBhcnNlQW5kQ29tcGlsZVJlc3Vs dCkpIHsKICAgICAgICAgICAgICAgICBhdXRvIGxvY2tlciA9IGhvbGRMb2NrKG1fbG9jayk7CkBA IC0yMDksMTAgKzIwNywxMiBAQCB2b2lkIFBsYW46OnJ1bigpCiAgICAgZm9yICh1aW50MzJfdCBm dW5jdGlvbkluZGV4ID0gMDsgZnVuY3Rpb25JbmRleCA8IG1fZnVuY3Rpb25Mb2NhdGlvbkluQmlu YXJ5LnNpemUoKTsgZnVuY3Rpb25JbmRleCsrKSB7CiAgICAgICAgIHsKICAgICAgICAgICAgIENv bXBpbGF0aW9uQ29udGV4dCYgY29udGV4dCA9IG1fY29tcGlsYXRpb25Db250ZXh0c1tmdW5jdGlv bkluZGV4XTsKKyAgICAgICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9t b2R1bGVJbmZvcm1hdGlvbi0+aW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXNbZnVuY3Rp b25JbmRleF07CisgICAgICAgICAgICBTdHJpbmcgc2lnbmF0dXJlRGVzY3JpcHRpb24gPSBTaWdu YXR1cmVJbmZvcm1hdGlvbjo6Z2V0KG1fdm0sIHNpZ25hdHVyZUluZGV4KS0+dG9TdHJpbmcoKTsK ICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICBMaW5rQnVmZmVyIGxpbmtCdWZmZXIoKm1f dm0sICpjb250ZXh0Lndhc21FbnRyeXBvaW50SklULCBudWxscHRyKTsKICAgICAgICAgICAgICAg ICBtX3dhc21JbnRlcm5hbEZ1bmN0aW9uc1tmdW5jdGlvbkluZGV4XS0+d2FzbUVudHJ5cG9pbnQu Y29tcGlsYXRpb24gPQotICAgICAgICAgICAgICAgICAgICBzdGQ6Om1ha2VfdW5pcXVlPEIzOjpD b21waWxhdGlvbj4oRklOQUxJWkVfQ09ERShsaW5rQnVmZmVyLCAoIldhc20gZnVuY3Rpb24iKSks IFdURk1vdmUoY29udGV4dC53YXNtRW50cnlwb2ludEJ5cHJvZHVjdHMpKTsKKyAgICAgICAgICAg ICAgICAgICAgc3RkOjptYWtlX3VuaXF1ZTxCMzo6Q29tcGlsYXRpb24+KEZJTkFMSVpFX0NPREUo bGlua0J1ZmZlciwgKCJXZWJBc3NlbWJseSBmdW5jdGlvblslaV0gJXMiLCBmdW5jdGlvbkluZGV4 LCBzaWduYXR1cmVEZXNjcmlwdGlvbi5hc2NpaSgpLmRhdGEoKSkpLCBXVEZNb3ZlKGNvbnRleHQu d2FzbUVudHJ5cG9pbnRCeXByb2R1Y3RzKSk7CiAgICAgICAgICAgICB9CiAKICAgICAgICAgICAg IHsKQEAgLTIyMCwxMiArMjIwLDkgQEAgdm9pZCBQbGFuOjpydW4oKQogICAgICAgICAgICAgICAg IGxpbmtCdWZmZXIubGluayhjb250ZXh0LmpzRW50cnlwb2ludFRvV2FzbUVudHJ5cG9pbnRDYWxs LCBGdW5jdGlvblB0cihtX3dhc21JbnRlcm5hbEZ1bmN0aW9uc1tmdW5jdGlvbkluZGV4XS0+d2Fz bUVudHJ5cG9pbnQuY29tcGlsYXRpb24tPmNvZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpKSk7CiAK ICAgICAgICAgICAgICAgICBtX3dhc21JbnRlcm5hbEZ1bmN0aW9uc1tmdW5jdGlvbkluZGV4XS0+ anNUb1dhc21FbnRyeXBvaW50LmNvbXBpbGF0aW9uID0KLSAgICAgICAgICAgICAgICAgICAgc3Rk OjptYWtlX3VuaXF1ZTxCMzo6Q29tcGlsYXRpb24+KEZJTkFMSVpFX0NPREUobGlua0J1ZmZlciwg KCJXYXNtIEpTIGVudHJ5cG9pbnQiKSksIFdURk1vdmUoY29udGV4dC5qc0VudHJ5cG9pbnRCeXBy b2R1Y3RzKSk7CisgICAgICAgICAgICAgICAgICAgIHN0ZDo6bWFrZV91bmlxdWU8QjM6OkNvbXBp bGF0aW9uPihGSU5BTElaRV9DT0RFKGxpbmtCdWZmZXIsICgiSmF2YVNjcmlwdC0+V2ViQXNzZW1i bHkgZW50cnlwb2ludFslaV0gJXMiLCBmdW5jdGlvbkluZGV4LCBzaWduYXR1cmVEZXNjcmlwdGlv bi5hc2NpaSgpLmRhdGEoKSkpLCBXVEZNb3ZlKGNvbnRleHQuanNFbnRyeXBvaW50Qnlwcm9kdWN0 cykpOwogICAgICAgICAgICAgfQogICAgICAgICB9Ci0KLSAgICAgICAgdW5zaWduZWQgZnVuY3Rp b25JbmRleFNwYWNlID0gbV93YXNtVG9KU1N0dWJzLnNpemUoKSArIGZ1bmN0aW9uSW5kZXg7Ci0g ICAgICAgIG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtmdW5jdGlvbkluZGV4U3Bh Y2VdLmNvZGUgPSBtX3dhc21JbnRlcm5hbEZ1bmN0aW9uc1tmdW5jdGlvbkluZGV4XS0+d2FzbUVu dHJ5cG9pbnQuY29tcGlsYXRpb24tPmNvZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpOwogICAgIH0K IAogICAgIGlmICh2ZXJib3NlIHx8IE9wdGlvbnM6OnJlcG9ydENvbXBpbGVUaW1lcygpKSB7CkBA IC0yMzUsOCArMjMyLDE5IEBAIHZvaWQgUGxhbjo6cnVuKCkKIAogICAgIC8vIFBhdGNoIHRoZSBj YWxsIHNpdGVzIGZvciBlYWNoIFdlYkFzc2VtYmx5IGZ1bmN0aW9uLgogICAgIGZvciAoYXV0byYg dW5saW5rZWQgOiBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzKSB7Ci0gICAgICAgIGZvciAoYXV0 byYgY2FsbCA6IHVubGlua2VkKQotICAgICAgICAgICAgTWFjcm9Bc3NlbWJsZXI6OnJlcGF0Y2hD YWxsKGNhbGwuY2FsbExvY2F0aW9uLCBDb2RlTG9jYXRpb25MYWJlbChtX2Z1bmN0aW9uSW5kZXhT cGFjZS5idWZmZXIuZ2V0KClbY2FsbC5mdW5jdGlvbkluZGV4XS5jb2RlKSk7CisgICAgICAgIGZv ciAoYXV0byYgY2FsbCA6IHVubGlua2VkKSB7CisgICAgICAgICAgICB2b2lkKiBleGVjdXRhYmxl QWRkcmVzczsKKyAgICAgICAgICAgIGlmIChtX21vZHVsZUluZm9ybWF0aW9uLT5pc0ltcG9ydGVk RnVuY3Rpb25Gcm9tRnVuY3Rpb25JbmRleFNwYWNlKGNhbGwuZnVuY3Rpb25JbmRleCkpIHsKKyAg ICAgICAgICAgICAgICAvLyBGSVhNRSBpbXBvcnRzIGNvdWxkIGhhdmUgYmVlbiBsaW5rZWQgaW4g QjMsIGluc3RlYWQgb2YgZ2VuZXJhdGluZyBhIHBhdGNocG9pbnQuIFRoaXMgY29uZGl0aW9uIHNo b3VsZCBiZSByZXBsYWNlZCBieSBhIFJFTEVBU0VfQVNTRVJULiBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY2NDYyCisgICAgICAgICAgICAgICAgZXhlY3V0YWJsZUFk ZHJlc3MgPSBjYWxsLnRhcmdldCA9PSBVbmxpbmtlZFdhc21Ub1dhc21DYWxsOjpUYXJnZXQ6OnRv SlMKKyAgICAgICAgICAgICAgICAgICAgPyBtX3dhc21FeGl0U3R1YnMuYXQoY2FsbC5mdW5jdGlv bkluZGV4KS53YXNtVG9KUy5jb2RlKCkuZXhlY3V0YWJsZUFkZHJlc3MoKQorICAgICAgICAgICAg ICAgICAgICA6IG1fd2FzbUV4aXRTdHVicy5hdChjYWxsLmZ1bmN0aW9uSW5kZXgpLndhc21Ub1dh c20uY29kZSgpLmV4ZWN1dGFibGVBZGRyZXNzKCk7CisgICAgICAgICAgICB9IGVsc2UgeworICAg ICAgICAgICAgICAgIEFTU0VSVChjYWxsLnRhcmdldCAhPSBVbmxpbmtlZFdhc21Ub1dhc21DYWxs OjpUYXJnZXQ6OnRvSlMpOworICAgICAgICAgICAgICAgIGV4ZWN1dGFibGVBZGRyZXNzID0gbV93 YXNtSW50ZXJuYWxGdW5jdGlvbnMuYXQoY2FsbC5mdW5jdGlvbkluZGV4IC0gbV93YXNtRXhpdFN0 dWJzLnNpemUoKSktPndhc21FbnRyeXBvaW50LmNvbXBpbGF0aW9uLT5jb2RlKCkuZXhlY3V0YWJs ZUFkZHJlc3MoKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIE1hY3JvQXNzZW1ibGVyOjpy ZXBhdGNoQ2FsbChjYWxsLmNhbGxMb2NhdGlvbiwgQ29kZUxvY2F0aW9uTGFiZWwoZXhlY3V0YWJs ZUFkZHJlc3MpKTsKKyAgICAgICAgfQogICAgIH0KIAogICAgIG1fZmFpbGVkID0gZmFsc2U7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5oIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uaAppbmRleCAzYmIwMWM4Li42OTgwYmRiIDEw MDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5oCisrKyBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmgKQEAgLTg2LDI2ICs4NiwyMCBAQCBw dWJsaWM6CiAgICAgICAgIHJldHVybiBXVEZNb3ZlKG1fY2FsbExpbmtJbmZvcyk7CiAgICAgfQog Ci0gICAgVmVjdG9yPFdhc21Ub0pTU3R1Yj4mJiB0YWtlV2FzbVRvSlNTdHVicygpCisgICAgVmVj dG9yPFdhc21FeGl0U3R1YnM+JiYgdGFrZVdhc21FeGl0U3R1YnMoKQogICAgIHsKICAgICAgICAg UkVMRUFTRV9BU1NFUlQoIWZhaWxlZCgpKTsKLSAgICAgICAgcmV0dXJuIFdURk1vdmUobV93YXNt VG9KU1N0dWJzKTsKLSAgICB9Ci0KLSAgICBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmJiB0 YWtlRnVuY3Rpb25JbmRleFNwYWNlKCkKLSAgICB7Ci0gICAgICAgIFJFTEVBU0VfQVNTRVJUKCFm YWlsZWQoKSk7Ci0gICAgICAgIHJldHVybiBXVEZNb3ZlKG1fZnVuY3Rpb25JbmRleFNwYWNlKTsK KyAgICAgICAgcmV0dXJuIFdURk1vdmUobV93YXNtRXhpdFN0dWJzKTsKICAgICB9CiAKIHByaXZh dGU6CiAgICAgc3RkOjp1bmlxdWVfcHRyPE1vZHVsZUluZm9ybWF0aW9uPiBtX21vZHVsZUluZm9y bWF0aW9uOwogICAgIFZlY3RvcjxGdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnk+IG1fZnVuY3Rpb25M b2NhdGlvbkluQmluYXJ5OworICAgIFZlY3RvcjxTaWduYXR1cmVJbmRleD4gbV9tb2R1bGVTaWdu YXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlczsKICAgICBCYWc8Q2FsbExpbmtJ bmZvPiBtX2NhbGxMaW5rSW5mb3M7Ci0gICAgVmVjdG9yPFdhc21Ub0pTU3R1Yj4gbV93YXNtVG9K U1N0dWJzOworICAgIFZlY3RvcjxXYXNtRXhpdFN0dWJzPiBtX3dhc21FeGl0U3R1YnM7CiAgICAg VmVjdG9yPHN0ZDo6dW5pcXVlX3B0cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4+IG1fd2FzbUludGVy bmFsRnVuY3Rpb25zOwogICAgIFZlY3RvcjxDb21waWxhdGlvbkNvbnRleHQ+IG1fY29tcGlsYXRp b25Db250ZXh0czsKLSAgICBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UgbV9mdW5jdGlvbklu ZGV4U3BhY2U7CiAKICAgICBWTSogbV92bTsKICAgICBWZWN0b3I8VmVjdG9yPFVubGlua2VkV2Fz bVRvV2FzbUNhbGw+PiBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzOwpkaWZmIC0tZ2l0IGEvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5jcHAgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmNwcAppbmRleCA2ZDViMWY2Li4wOTY2ZGFiIDEw MDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmNwcAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmNwcApAQCAtNDEs MTIgKzQxLDIyIEBAIGNvbnN0IGJvb2wgdmVyYm9zZSA9IGZhbHNlOwogCiBjb25zdCBjb25zdGV4 cHIgU2lnbmF0dXJlSW5kZXggU2lnbmF0dXJlOjppbnZhbGlkSW5kZXg7CiAKK1N0cmluZyBTaWdu YXR1cmU6OnRvU3RyaW5nKCkgY29uc3QKK3sKKyAgICBTdHJpbmcgcmVzdWx0KG1ha2VTdHJpbmco cmV0dXJuVHlwZSgpKSk7CisgICAgcmVzdWx0LmFwcGVuZCgiICgiKTsKKyAgICBmb3IgKFNpZ25h dHVyZUFyZ0NvdW50IGFyZyA9IDA7IGFyZyA8IGFyZ3VtZW50Q291bnQoKTsgKythcmcpIHsKKyAg ICAgICAgaWYgKGFyZykKKyAgICAgICAgICAgIHJlc3VsdC5hcHBlbmQoIiwgIik7CisgICAgICAg IHJlc3VsdC5hcHBlbmQobWFrZVN0cmluZyhhcmd1bWVudChhcmcpKSk7CisgICAgfQorICAgIHJl c3VsdC5hcHBlbmQoJyknKTsKKyAgICByZXR1cm4gcmVzdWx0OworfQorCiB2b2lkIFNpZ25hdHVy ZTo6ZHVtcChQcmludFN0cmVhbSYgb3V0KSBjb25zdAogewotICAgIG91dC5wcmludChtYWtlU3Ry aW5nKHJldHVyblR5cGUoKSksICIgKCIpOwotICAgIGZvciAoU2lnbmF0dXJlQXJnQ291bnQgYXJn ID0gMDsgYXJnIDwgYXJndW1lbnRDb3VudCgpOyArK2FyZykKLSAgICAgICAgb3V0LnByaW50KChh cmcgPyAiLCAiIDogIiIpLCBtYWtlU3RyaW5nKGFyZ3VtZW50KGFyZykpKTsKLSAgICBvdXQucHJp bnQoIikiKTsKKyAgICBvdXQucHJpbnQodG9TdHJpbmcoKSk7CiB9CiAKIHVuc2lnbmVkIFNpZ25h dHVyZTo6aGFzaCgpIGNvbnN0CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtU2lnbmF0dXJlLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0 dXJlLmgKaW5kZXggMGQ2YzdiNS4uNGQ0M2ZmYyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21TaWduYXR1cmUuaApAQCAtODIsNiArODIsNyBAQCBwdWJsaWM6CiAgICAgfQogICAg IFR5cGUgYXJndW1lbnQoU2lnbmF0dXJlQXJnQ291bnQgaSkgY29uc3QgeyByZXR1cm4gY29uc3Rf Y2FzdDxTaWduYXR1cmUqPih0aGlzKS0+YXJndW1lbnQoaSk7IH0KIAorICAgIFdURjo6U3RyaW5n IHRvU3RyaW5nKCkgY29uc3Q7CiAgICAgdm9pZCBkdW1wKFdURjo6UHJpbnRTdHJlYW0mIG91dCkg Y29uc3Q7CiAgICAgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFNpZ25hdHVyZSYgcmhzKSBjb25zdAog ICAgIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0 ZS5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwCmluZGV4 IGUzMjE2MTMuLjc1ZDM4MjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21WYWxpZGF0ZS5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZh bGlkYXRlLmNwcApAQCAtMzgxLDEwICszODEsMTAgQEAgdm9pZCBWYWxpZGF0ZTo6ZHVtcChjb25z dCBWZWN0b3I8Q29udHJvbEVudHJ5PiYgY29udHJvbFN0YWNrLCBjb25zdCBFeHByZXNzaW9uTGkK ICAgICBkYXRhTG9nTG4oKTsKIH0KIAotRXhwZWN0ZWQ8dm9pZCwgU3RyaW5nPiB2YWxpZGF0ZUZ1 bmN0aW9uKFZNKiB2bSwgY29uc3QgdWludDhfdCogc291cmNlLCBzaXplX3QgbGVuZ3RoLCBjb25z dCBTaWduYXR1cmUqIHNpZ25hdHVyZSwgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNl JiBmdW5jdGlvbkluZGV4U3BhY2UsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBtb2R1bGUpCitF eHBlY3RlZDx2b2lkLCBTdHJpbmc+IHZhbGlkYXRlRnVuY3Rpb24oVk0qIHZtLCBjb25zdCB1aW50 OF90KiBzb3VyY2UsIHNpemVfdCBsZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBj b25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgbW9kdWxlLCBjb25zdCBWZWN0b3I8U2lnbmF0dXJlSW5k ZXg+JiBtb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcykKIHsK ICAgICBWYWxpZGF0ZSBjb250ZXh0KG1vZHVsZSk7Ci0gICAgRnVuY3Rpb25QYXJzZXI8VmFsaWRh dGU+IHZhbGlkYXRvcih2bSwgY29udGV4dCwgc291cmNlLCBsZW5ndGgsIHNpZ25hdHVyZSwgZnVu Y3Rpb25JbmRleFNwYWNlLCBtb2R1bGUpOworICAgIEZ1bmN0aW9uUGFyc2VyPFZhbGlkYXRlPiB2 YWxpZGF0b3Iodm0sIGNvbnRleHQsIHNvdXJjZSwgbGVuZ3RoLCBzaWduYXR1cmUsIG1vZHVsZSwg bW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMpOwogICAgIFdB U01fRkFJTF9JRl9IRUxQRVJfRkFJTFModmFsaWRhdG9yLnBhcnNlKCkpOwogICAgIHJldHVybiB7 IH07CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRh dGUuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5oCmluZGV4IDE0 ODIxZjIuLjczZTdkODcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dh c21WYWxpZGF0ZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0 ZS5oCkBAIC0zNiw3ICszNiw3IEBAIGNsYXNzIFZNOwogCiBuYW1lc3BhY2UgV2FzbSB7CiAKLUV4 cGVjdGVkPHZvaWQsIFN0cmluZz4gdmFsaWRhdGVGdW5jdGlvbihWTSosIGNvbnN0IHVpbnQ4X3Qq LCBzaXplX3QsIGNvbnN0IFNpZ25hdHVyZSosIGNvbnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhT cGFjZSYsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJik7CitFeHBlY3RlZDx2b2lkLCBTdHJpbmc+ IHZhbGlkYXRlRnVuY3Rpb24oVk0qLCBjb25zdCB1aW50OF90Kiwgc2l6ZV90LCBjb25zdCBTaWdu YXR1cmUqLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYsIGNvbnN0IFZlY3RvcjxTaWduYXR1cmVJ bmRleD4mKTsKIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KIApkaWZmIC0tZ2l0IGEvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseUluc3RhbmNlLmggYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaAppbmRleCA5 MjhmNDIzLi41NGFlMTdkIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9q cy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaApAQCAtNDIsNyArNDIsNyBAQCBwdWJsaWM6CiAg ICAgdHlwZWRlZiBKU0Rlc3RydWN0aWJsZU9iamVjdCBCYXNlOwogCiAKLSAgICBzdGF0aWMgSlNX ZWJBc3NlbWJseUluc3RhbmNlKiBjcmVhdGUoVk0mLCBTdHJ1Y3R1cmUqLCBKU1dlYkFzc2VtYmx5 TW9kdWxlKiwgSlNNb2R1bGVOYW1lc3BhY2VPYmplY3QqKTsKKyAgICBKU19FWFBPUlRfUFJJVkFU RSBzdGF0aWMgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBjcmVhdGUoVk0mLCBTdHJ1Y3R1cmUqLCBK U1dlYkFzc2VtYmx5TW9kdWxlKiwgSlNNb2R1bGVOYW1lc3BhY2VPYmplY3QqKTsKICAgICBzdGF0 aWMgU3RydWN0dXJlKiBjcmVhdGVTdHJ1Y3R1cmUoVk0mLCBKU0dsb2JhbE9iamVjdCosIEpTVmFs dWUpOwogCiAgICAgREVDTEFSRV9JTkZPOwpAQCAtODYsOSArODYsMTEgQEAgcHVibGljOgogICAg ICAgICByZXR1cm4gb2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbnMoKSArIHNpemVvZihXcml0ZUJhcnJp ZXI8SlNDZWxsPikgKiBpZHg7CiAgICAgfQogCi0gICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRP ZlRhYmxlKCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKEpTV2ViQXNzZW1ibHlJbnN0YW5jZSwg bV90YWJsZSk7IH0KICAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mTWVtb3J5KCkgeyByZXR1 cm4gT0JKRUNUX09GRlNFVE9GKEpTV2ViQXNzZW1ibHlJbnN0YW5jZSwgbV9tZW1vcnkpOyB9Cisg ICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZlRhYmxlKCkgeyByZXR1cm4gT0JKRUNUX09GRlNF VE9GKEpTV2ViQXNzZW1ibHlJbnN0YW5jZSwgbV90YWJsZSk7IH0KICAgICBzdGF0aWMgcHRyZGlm Zl90IG9mZnNldE9mR2xvYmFscygpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFzc2Vt Ymx5SW5zdGFuY2UsIG1fZ2xvYmFscyk7IH0KKyAgICBzdGF0aWMgc2l6ZV90IG9mZnNldE9mSW1w b3J0RnVuY3Rpb25zKCkgeyByZXR1cm4gV1RGOjpyb3VuZFVwVG9NdWx0aXBsZU9mPHNpemVvZihX cml0ZUJhcnJpZXI8SlNDZWxsPik+KHNpemVvZihKU1dlYkFzc2VtYmx5SW5zdGFuY2UpKTsgfQor ICAgIHN0YXRpYyBzaXplX3Qgb2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbihzaXplX3QgaW1wb3J0RnVu Y3Rpb25OdW0pIHsgcmV0dXJuIG9mZnNldE9mSW1wb3J0RnVuY3Rpb25zKCkgKyBpbXBvcnRGdW5j dGlvbk51bSAqIHNpemVvZihzaXplb2YoV3JpdGVCYXJyaWVyPEpTQ2VsbD4pKTsgfQogCiBwcm90 ZWN0ZWQ6CiAgICAgSlNXZWJBc3NlbWJseUluc3RhbmNlKFZNJiwgU3RydWN0dXJlKiwgdW5zaWdu ZWQgbnVtSW1wb3J0RnVuY3Rpb25zKTsKQEAgLTk2LDExICs5OCw2IEBAIHByb3RlY3RlZDoKICAg ICBzdGF0aWMgdm9pZCBkZXN0cm95KEpTQ2VsbCopOwogICAgIHN0YXRpYyB2b2lkIHZpc2l0Q2hp bGRyZW4oSlNDZWxsKiwgU2xvdFZpc2l0b3ImKTsKIAotICAgIHN0YXRpYyBzaXplX3Qgb2Zmc2V0 T2ZJbXBvcnRGdW5jdGlvbnMoKQotICAgIHsKLSAgICAgICAgcmV0dXJuIFdURjo6cm91bmRVcFRv TXVsdGlwbGVPZjxzaXplb2YoV3JpdGVCYXJyaWVyPEpTQ2VsbD4pPihzaXplb2YoSlNXZWJBc3Nl bWJseUluc3RhbmNlKSk7Ci0gICAgfQotCiAgICAgc3RhdGljIHNpemVfdCBhbGxvY2F0aW9uU2l6 ZSh1bnNpZ25lZCBudW1JbXBvcnRGdW5jdGlvbnMpCiAgICAgewogICAgICAgICByZXR1cm4gb2Zm c2V0T2ZJbXBvcnRGdW5jdGlvbnMoKSArIHNpemVvZihXcml0ZUJhcnJpZXI8SlNDZWxsPikgKiBu dW1JbXBvcnRGdW5jdGlvbnM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuY3BwCmluZGV4IDUyOGFiNjkuLjRjNGNjM2UgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnku Y3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1v cnkuY3BwCkBAIC0zNyw5ICszNyw5IEBAIG5hbWVzcGFjZSBKU0MgewogCiBjb25zdCBDbGFzc0lu Zm8gSlNXZWJBc3NlbWJseU1lbW9yeTo6c19pbmZvID0geyAiV2ViQXNzZW1ibHkuTWVtb3J5Iiwg JkJhc2U6OnNfaW5mbywgMCwgQ1JFQVRFX01FVEhPRF9UQUJMRShKU1dlYkFzc2VtYmx5TWVtb3J5 KSB9OwogCi1KU1dlYkFzc2VtYmx5TWVtb3J5KiBKU1dlYkFzc2VtYmx5TWVtb3J5OjpjcmVhdGUo Vk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1lbW9y eT4mJiBtZW1vcnkpCitKU1dlYkFzc2VtYmx5TWVtb3J5KiBKU1dlYkFzc2VtYmx5TWVtb3J5Ojpj cmVhdGUoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgV2FzbTo6TWVtb3J5JiYgbWVtb3J5 KQogewotICAgIGF1dG8qIGluc3RhbmNlID0gbmV3IChOb3ROdWxsLCBhbGxvY2F0ZUNlbGw8SlNX ZWJBc3NlbWJseU1lbW9yeT4odm0uaGVhcCkpIEpTV2ViQXNzZW1ibHlNZW1vcnkodm0sIHN0cnVj dHVyZSwgV1RGTW92ZShtZW1vcnkpKTsKKyAgICBhdXRvKiBpbnN0YW5jZSA9IG5ldyAoTm90TnVs bCwgYWxsb2NhdGVDZWxsPEpTV2ViQXNzZW1ibHlNZW1vcnk+KHZtLmhlYXApKSBKU1dlYkFzc2Vt Ymx5TWVtb3J5KHZtLCBzdHJ1Y3R1cmUsIHN0ZDo6Zm9yd2FyZDxXYXNtOjpNZW1vcnk+KG1lbW9y eSkpOwogICAgIGluc3RhbmNlLT5maW5pc2hDcmVhdGlvbih2bSk7CiAgICAgcmV0dXJuIGluc3Rh bmNlOwogfQpAQCAtNDksNyArNDksNyBAQCBTdHJ1Y3R1cmUqIEpTV2ViQXNzZW1ibHlNZW1vcnk6 OmNyZWF0ZVN0cnVjdHVyZShWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYgogICAgIHJl dHVybiBTdHJ1Y3R1cmU6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LCBwcm90b3R5cGUsIFR5cGVJ bmZvKE9iamVjdFR5cGUsIFN0cnVjdHVyZUZsYWdzKSwgaW5mbygpKTsKIH0KIAotSlNXZWJBc3Nl bWJseU1lbW9yeTo6SlNXZWJBc3NlbWJseU1lbW9yeShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0 dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiYmIG1lbW9yeSkKK0pTV2ViQXNzZW1i bHlNZW1vcnk6OkpTV2ViQXNzZW1ibHlNZW1vcnkoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVy ZSwgV2FzbTo6TWVtb3J5JiYgbWVtb3J5KQogICAgIDogQmFzZSh2bSwgc3RydWN0dXJlKQogICAg ICwgbV9tZW1vcnkoV1RGTW92ZShtZW1vcnkpKQogewpAQCAtNzIsNyArNzIsNyBAQCBKU0FycmF5 QnVmZmVyKiBKU1dlYkFzc2VtYmx5TWVtb3J5OjpidWZmZXIoVk0mIHZtLCBKU0dsb2JhbE9iamVj dCogZ2xvYmFsT2JqZWN0KQogICAgIGF1dG8gZGVzdHJ1Y3RvciA9IFtdICh2b2lkKikgewogICAg ICAgICAvLyBXZSBkb24ndCBuZWVkIHRvIGRvIGFueXRoaW5nIGhlcmUgdG8gZGVzdHJveSB0aGUg bWVtb3J5LgogICAgICAgICAvLyBUaGUgQXJyYXlCdWZmZXIgYmFja2luZyB0aGUgSlNBcnJheUJ1 ZmZlciBpcyBvbmx5IG93bmVkIGJ5IHVzLAotICAgICAgICAvLyBzbyB3ZSBndWFyYW50ZWUgaXRz IGxpZmVjeWxjZS4KKyAgICAgICAgLy8gc28gd2UgZ3VhcmFudGVlIGl0cyBsaWZlY3ljbGUuCiAg ICAgfTsKICAgICBtX2J1ZmZlciA9IEFycmF5QnVmZmVyOjpjcmVhdGVGcm9tQnl0ZXMobWVtb3J5 KCktPm1lbW9yeSgpLCBtZW1vcnkoKS0+c2l6ZSgpLCBXVEZNb3ZlKGRlc3RydWN0b3IpKTsKICAg ICBtX2J1ZmZlcldyYXBwZXIuc2V0KHZtLCB0aGlzLCBKU0FycmF5QnVmZmVyOjpjcmVhdGUodm0s IGdsb2JhbE9iamVjdC0+bV9hcnJheUJ1ZmZlclN0cnVjdHVyZS5nZXQoKSwgbV9idWZmZXIuZ2V0 KCkpKTsKQEAgLTg1LDcgKzg1LDcgQEAgV2FzbTo6UGFnZUNvdW50IEpTV2ViQXNzZW1ibHlNZW1v cnk6Omdyb3coRXhlY1N0YXRlKiBleGVjLCB1aW50MzJfdCBkZWx0YSwgYm9vbAogICAgIFZNJiB2 bSA9IGV4ZWMtPnZtKCk7CiAgICAgYXV0byB0aHJvd1Njb3BlID0gREVDTEFSRV9USFJPV19TQ09Q RSh2bSk7CiAKLSAgICBXYXNtOjpQYWdlQ291bnQgb2xkUGFnZUNvdW50ID0gbV9tZW1vcnktPnNp emVJblBhZ2VzKCk7CisgICAgV2FzbTo6UGFnZUNvdW50IG9sZFBhZ2VDb3VudCA9IG1lbW9yeSgp LT5zaXplSW5QYWdlcygpOwogCiAgICAgaWYgKCFXYXNtOjpQYWdlQ291bnQ6OmlzVmFsaWQoZGVs dGEpKSB7CiAgICAgICAgIGlmIChzaG91bGRUaHJvd0V4Y2VwdGlvbnNPbkZhaWx1cmUpCkBAIC0x MDEsNyArMTAxLDcgQEAgV2FzbTo6UGFnZUNvdW50IEpTV2ViQXNzZW1ibHlNZW1vcnk6Omdyb3co RXhlY1N0YXRlKiBleGVjLCB1aW50MzJfdCBkZWx0YSwgYm9vbAogICAgIH0KIAogICAgIGlmIChk ZWx0YSkgewotICAgICAgICBib29sIHN1Y2Nlc3MgPSBtX21lbW9yeS0+Z3JvdyhuZXdTaXplKTsK KyAgICAgICAgYm9vbCBzdWNjZXNzID0gbWVtb3J5KCktPmdyb3cobmV3U2l6ZSk7CiAgICAgICAg IGlmICghc3VjY2VzcykgewogICAgICAgICAgICAgaWYgKHNob3VsZFRocm93RXhjZXB0aW9uc09u RmFpbHVyZSkKICAgICAgICAgICAgICAgICB0aHJvd0V4Y2VwdGlvbihleGVjLCB0aHJvd1Njb3Bl LCBjcmVhdGVPdXRPZk1lbW9yeUVycm9yKGV4ZWMpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuaCBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuaAppbmRleCAyODc5N2M2Li4zOWEz NWJiIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2Vt Ymx5TWVtb3J5LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3Nl bWJseU1lbW9yeS5oCkBAIC00MSwyNSArNDEsMjYgQEAgY2xhc3MgSlNXZWJBc3NlbWJseU1lbW9y eSA6IHB1YmxpYyBKU0Rlc3RydWN0aWJsZU9iamVjdCB7CiBwdWJsaWM6CiAgICAgdHlwZWRlZiBK U0Rlc3RydWN0aWJsZU9iamVjdCBCYXNlOwogCi0gICAgc3RhdGljIEpTV2ViQXNzZW1ibHlNZW1v cnkqIGNyZWF0ZShWTSYsIFN0cnVjdHVyZSosIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+ JiYpOworICAgIEpTX0VYUE9SVF9QUklWQVRFIHN0YXRpYyBKU1dlYkFzc2VtYmx5TWVtb3J5KiBj cmVhdGUoVk0mLCBTdHJ1Y3R1cmUqLCBXYXNtOjpNZW1vcnkmJik7CiAgICAgc3RhdGljIFN0cnVj dHVyZSogY3JlYXRlU3RydWN0dXJlKFZNJiwgSlNHbG9iYWxPYmplY3QqLCBKU1ZhbHVlKTsKIAot ICAgIERFQ0xBUkVfSU5GTzsKKyAgICBERUNMQVJFX0VYUE9SVF9JTkZPOwogCi0gICAgV2FzbTo6 TWVtb3J5KiBtZW1vcnkoKSB7IHJldHVybiBtX21lbW9yeS5nZXQoKTsgfQorICAgIFdhc206Ok1l bW9yeSogbWVtb3J5KCkgeyByZXR1cm4gJm1fbWVtb3J5OyB9CiAgICAgSlNBcnJheUJ1ZmZlciog YnVmZmVyKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqKTsKICAgICBXYXNtOjpQYWdlQ291bnQgZ3Jv dyhFeGVjU3RhdGUqLCB1aW50MzJfdCBkZWx0YSwgYm9vbCBzaG91bGRUaHJvd0V4Y2VwdGlvbnNP bkZhaWx1cmUpOwogCi0gICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZk1lbW9yeSgpIHsgcmV0 dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFzc2VtYmx5TWVtb3J5LCBtX21lbW9yeSk7IH0KKyAg ICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mTWVtb3J5KCkgeyByZXR1cm4gT0JKRUNUX09GRlNF VE9GKEpTV2ViQXNzZW1ibHlNZW1vcnksIG1fbWVtb3J5KSArIFdhc206Ok1lbW9yeTo6b2Zmc2V0 T2ZNZW1vcnkoKTsgfQorICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZTaXplKCkgeyByZXR1 cm4gT0JKRUNUX09GRlNFVE9GKEpTV2ViQXNzZW1ibHlNZW1vcnksIG1fbWVtb3J5KSArIFdhc206 Ok1lbW9yeTo6b2Zmc2V0T2ZTaXplKCk7IH0KIAogcHJvdGVjdGVkOgotICAgIEpTV2ViQXNzZW1i bHlNZW1vcnkoVk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiYm KTsKKyAgICBKU1dlYkFzc2VtYmx5TWVtb3J5KFZNJiwgU3RydWN0dXJlKiwgV2FzbTo6TWVtb3J5 JiYpOwogICAgIH5KU1dlYkFzc2VtYmx5TWVtb3J5KCk7CiAgICAgdm9pZCBmaW5pc2hDcmVhdGlv bihWTSYpOwogICAgIHN0YXRpYyB2b2lkIGRlc3Ryb3koSlNDZWxsKik7CiAgICAgc3RhdGljIHZv aWQgdmlzaXRDaGlsZHJlbihKU0NlbGwqLCBTbG90VmlzaXRvciYpOwogCi0gICAgc3RkOjp1bmlx dWVfcHRyPFdhc206Ok1lbW9yeT4gbV9tZW1vcnk7CisgICAgV2FzbTo6TWVtb3J5IG1fbWVtb3J5 OwogICAgIFdyaXRlQmFycmllcjxKU0FycmF5QnVmZmVyPiBtX2J1ZmZlcldyYXBwZXI7CiAgICAg UmVmUHRyPEFycmF5QnVmZmVyPiBtX2J1ZmZlcjsKIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmNwcCBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUuY3BwCmluZGV4IGQ2NTI0YzUu LmZhMGU4NTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2Vi QXNzZW1ibHlNb2R1bGUuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pT V2ViQXNzZW1ibHlNb2R1bGUuY3BwCkBAIC0zOCw5ICszOCw5IEBAIG5hbWVzcGFjZSBKU0Mgewog CiBjb25zdCBDbGFzc0luZm8gSlNXZWJBc3NlbWJseU1vZHVsZTo6c19pbmZvID0geyAiV2ViQXNz ZW1ibHkuTW9kdWxlIiwgJkJhc2U6OnNfaW5mbywgbnVsbHB0ciwgQ1JFQVRFX01FVEhPRF9UQUJM RShKU1dlYkFzc2VtYmx5TW9kdWxlKSB9OwogCi1KU1dlYkFzc2VtYmx5TW9kdWxlKiBKU1dlYkFz c2VtYmx5TW9kdWxlOjpjcmVhdGUoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1 bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPiYmIG1vZHVsZUluZm9ybWF0aW9uLCBC YWc8Q2FsbExpbmtJbmZvPiYmIGNhbGxMaW5rSW5mb3MsIFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0 dWI+JiYgd2FzbVRvSlNTdHVicywgV2FzbTo6SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiYg ZnVuY3Rpb25JbmRleFNwYWNlLCBTeW1ib2xUYWJsZSogZXhwb3J0U3ltYm9sVGFibGUsIHVuc2ln bmVkIGNhbGxlZUNvdW50KQorSlNXZWJBc3NlbWJseU1vZHVsZSogSlNXZWJBc3NlbWJseU1vZHVs ZTo6Y3JlYXRlKFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0cjxX YXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4mJiBtb2R1bGVJbmZvcm1hdGlvbiwgQmFnPENhbGxMaW5r SW5mbz4mJiBjYWxsTGlua0luZm9zLCBWZWN0b3I8V2FzbTo6V2FzbUV4aXRTdHVicz4mJiB3YXNt RXhpdFN0dWJzLCBTeW1ib2xUYWJsZSogZXhwb3J0U3ltYm9sVGFibGUsIHVuc2lnbmVkIGNhbGxl ZUNvdW50KQogewotICAgIGF1dG8qIGluc3RhbmNlID0gbmV3IChOb3ROdWxsLCBhbGxvY2F0ZUNl bGw8SlNXZWJBc3NlbWJseU1vZHVsZT4odm0uaGVhcCwgYWxsb2NhdGlvblNpemUoY2FsbGVlQ291 bnQpKSkgSlNXZWJBc3NlbWJseU1vZHVsZSh2bSwgc3RydWN0dXJlLCBzdGQ6OmZvcndhcmQ8c3Rk Ojp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPj4obW9kdWxlSW5mb3JtYXRpb24p LCBzdGQ6OmZvcndhcmQ8QmFnPENhbGxMaW5rSW5mbz4+KGNhbGxMaW5rSW5mb3MpLCBzdGQ6OmZv cndhcmQ8VmVjdG9yPFdhc206Oldhc21Ub0pTU3R1Yj4+KHdhc21Ub0pTU3R1YnMpLCBzdGQ6OmZv cndhcmQ8V2FzbTo6SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlPihmdW5jdGlvbkluZGV4U3Bh Y2UpLCBjYWxsZWVDb3VudCk7CisgICAgYXV0byogaW5zdGFuY2UgPSBuZXcgKE5vdE51bGwsIGFs bG9jYXRlQ2VsbDxKU1dlYkFzc2VtYmx5TW9kdWxlPih2bS5oZWFwLCBhbGxvY2F0aW9uU2l6ZShj YWxsZWVDb3VudCkpKSBKU1dlYkFzc2VtYmx5TW9kdWxlKHZtLCBzdHJ1Y3R1cmUsIHN0ZDo6Zm9y d2FyZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+Pihtb2R1bGVJbmZv cm1hdGlvbiksIHN0ZDo6Zm9yd2FyZDxCYWc8Q2FsbExpbmtJbmZvPj4oY2FsbExpbmtJbmZvcyks IHN0ZDo6Zm9yd2FyZDxWZWN0b3I8V2FzbTo6V2FzbUV4aXRTdHVicz4+KHdhc21FeGl0U3R1YnMp LCBjYWxsZWVDb3VudCk7CiAgICAgaW5zdGFuY2UtPmZpbmlzaENyZWF0aW9uKHZtLCBleHBvcnRT eW1ib2xUYWJsZSk7CiAgICAgcmV0dXJuIGluc3RhbmNlOwogfQpAQCAtNTAsMTIgKzUwLDExIEBA IFN0cnVjdHVyZSogSlNXZWJBc3NlbWJseU1vZHVsZTo6Y3JlYXRlU3RydWN0dXJlKFZNJiB2bSwg SlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iCiAgICAgcmV0dXJuIFN0cnVjdHVyZTo6Y3JlYXRlKHZt LCBnbG9iYWxPYmplY3QsIHByb3RvdHlwZSwgVHlwZUluZm8oT2JqZWN0VHlwZSwgU3RydWN0dXJl RmxhZ3MpLCBpbmZvKCkpOwogfQogCi1KU1dlYkFzc2VtYmx5TW9kdWxlOjpKU1dlYkFzc2VtYmx5 TW9kdWxlKFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0cjxXYXNt OjpNb2R1bGVJbmZvcm1hdGlvbj4mJiBtb2R1bGVJbmZvcm1hdGlvbiwgQmFnPENhbGxMaW5rSW5m bz4mJiBjYWxsTGlua0luZm9zLCBWZWN0b3I8V2FzbTo6V2FzbVRvSlNTdHViPiYmIHdhc21Ub0pT U3R1YnMsIFdhc206OkltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmIGZ1bmN0aW9uSW5kZXhT cGFjZSwgdW5zaWduZWQgY2FsbGVlQ291bnQpCitKU1dlYkFzc2VtYmx5TW9kdWxlOjpKU1dlYkFz c2VtYmx5TW9kdWxlKFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0 cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4mJiBtb2R1bGVJbmZvcm1hdGlvbiwgQmFnPENhbGxM aW5rSW5mbz4mJiBjYWxsTGlua0luZm9zLCBWZWN0b3I8V2FzbTo6V2FzbUV4aXRTdHVicz4mJiB3 YXNtRXhpdFN0dWJzLCB1bnNpZ25lZCBjYWxsZWVDb3VudCkKICAgICA6IEJhc2Uodm0sIHN0cnVj dHVyZSkKICAgICAsIG1fbW9kdWxlSW5mb3JtYXRpb24oV1RGTW92ZShtb2R1bGVJbmZvcm1hdGlv bikpCiAgICAgLCBtX2NhbGxMaW5rSW5mb3MoV1RGTW92ZShjYWxsTGlua0luZm9zKSkKLSAgICAs IG1fd2FzbVRvSlNTdHVicyhXVEZNb3ZlKHdhc21Ub0pTU3R1YnMpKQotICAgICwgbV9mdW5jdGlv bkluZGV4U3BhY2UoV1RGTW92ZShmdW5jdGlvbkluZGV4U3BhY2UpKQorICAgICwgbV93YXNtRXhp dFN0dWJzKFdURk1vdmUod2FzbUV4aXRTdHVicykpCiAgICAgLCBtX2NhbGxlZUNvdW50KGNhbGxl ZUNvdW50KQogewogICAgIG1lbXNldChjYWxsZWVzKCksIDAsIG1fY2FsbGVlQ291bnQgKiBzaXpl b2YoV3JpdGVCYXJyaWVyPEpTV2ViQXNzZW1ibHlDYWxsZWU+KSAqIDIpOwpkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5oIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5oCmluZGV4IGZl YzRlZWQuLmZhNjczYWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pz L0pTV2ViQXNzZW1ibHlNb2R1bGUuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9q cy9KU1dlYkFzc2VtYmx5TW9kdWxlLmgKQEAgLTQzLDE5ICs0MywxOCBAQCBjbGFzcyBKU1dlYkFz c2VtYmx5TW9kdWxlIDogcHVibGljIEpTRGVzdHJ1Y3RpYmxlT2JqZWN0IHsKIHB1YmxpYzoKICAg ICB0eXBlZGVmIEpTRGVzdHJ1Y3RpYmxlT2JqZWN0IEJhc2U7CiAKLSAgICBzdGF0aWMgSlNXZWJB c3NlbWJseU1vZHVsZSogY3JlYXRlKFZNJiwgU3RydWN0dXJlKiwgc3RkOjp1bmlxdWVfcHRyPFdh c206Ok1vZHVsZUluZm9ybWF0aW9uPiYmLCBCYWc8Q2FsbExpbmtJbmZvPiYmLCBWZWN0b3I8V2Fz bTo6V2FzbVRvSlNTdHViPiYmLCBXYXNtOjpJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmJiwg U3ltYm9sVGFibGUqLCB1bnNpZ25lZCk7CisgICAgSlNfRVhQT1JUX1BSSVZBVEUgc3RhdGljIEpT V2ViQXNzZW1ibHlNb2R1bGUqIGNyZWF0ZShWTSYsIFN0cnVjdHVyZSosIHN0ZDo6dW5pcXVlX3B0 cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4mJiwgQmFnPENhbGxMaW5rSW5mbz4mJiwgVmVjdG9y PFdhc206Oldhc21FeGl0U3R1YnM+JiYsIFN5bWJvbFRhYmxlKiwgdW5zaWduZWQpOwogICAgIHN0 YXRpYyBTdHJ1Y3R1cmUqIGNyZWF0ZVN0cnVjdHVyZShWTSYsIEpTR2xvYmFsT2JqZWN0KiwgSlNW YWx1ZSk7CiAKICAgICBERUNMQVJFX0lORk87CiAKICAgICBjb25zdCBXYXNtOjpNb2R1bGVJbmZv cm1hdGlvbiYgbW9kdWxlSW5mb3JtYXRpb24oKSBjb25zdCB7IHJldHVybiAqbV9tb2R1bGVJbmZv cm1hdGlvbi5nZXQoKTsgfQogICAgIFN5bWJvbFRhYmxlKiBleHBvcnRTeW1ib2xUYWJsZSgpIGNv bnN0IHsgcmV0dXJuIG1fZXhwb3J0U3ltYm9sVGFibGUuZ2V0KCk7IH0KLSAgICBXYXNtOjpTaWdu YXR1cmVJbmRleCBzaWduYXR1cmVGb3JGdW5jdGlvbkluZGV4U3BhY2UodW5zaWduZWQgZnVuY3Rp b25JbmRleFNwYWNlKSBjb25zdAorICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUlu ZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZSh1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2UpIGNv bnN0CiAgICAgewotICAgICAgICBBU1NFUlQoZnVuY3Rpb25JbmRleFNwYWNlIDwgbV9mdW5jdGlv bkluZGV4U3BhY2Uuc2l6ZSk7Ci0gICAgICAgIHJldHVybiBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5i dWZmZXIuZ2V0KClbZnVuY3Rpb25JbmRleFNwYWNlXS5zaWduYXR1cmVJbmRleDsKKyAgICAgICAg cmV0dXJuIG1fbW9kdWxlSW5mb3JtYXRpb24tPnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5k ZXhTcGFjZShmdW5jdGlvbkluZGV4U3BhY2UpOwogICAgIH0KLSAgICB1bnNpZ25lZCBmdW5jdGlv bkltcG9ydENvdW50KCkgY29uc3QgeyByZXR1cm4gbV93YXNtVG9KU1N0dWJzLnNpemUoKTsgfQor ICAgIHVuc2lnbmVkIGZ1bmN0aW9uSW1wb3J0Q291bnQoKSBjb25zdCB7IHJldHVybiBtX3dhc21F eGl0U3R1YnMuc2l6ZSgpOyB9CiAKICAgICBKU1dlYkFzc2VtYmx5Q2FsbGVlKiBqc0VudHJ5cG9p bnRDYWxsZWVGcm9tRnVuY3Rpb25JbmRleFNwYWNlKHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFj ZSkKICAgICB7CkBAIC05MCwxMCArODksOCBAQCBwdWJsaWM6CiAgICAgICAgIHJldHVybiBiaXR3 aXNlX2Nhc3Q8V3JpdGVCYXJyaWVyPEpTV2ViQXNzZW1ibHlDYWxsZWU+Kj4oYml0d2lzZV9jYXN0 PGNoYXIqPih0aGlzKSArIG9mZnNldE9mQ2FsbGVlcygpKTsKICAgICB9CiAKLSAgICBzdGF0aWMg cHRyZGlmZl90IG9mZnNldE9mRnVuY3Rpb25JbmRleFNwYWNlKCkgeyByZXR1cm4gT0JKRUNUX09G RlNFVE9GKEpTV2ViQXNzZW1ibHlNb2R1bGUsIG1fZnVuY3Rpb25JbmRleFNwYWNlKTsgfQotCiBw cm90ZWN0ZWQ6Ci0gICAgSlNXZWJBc3NlbWJseU1vZHVsZShWTSYsIFN0cnVjdHVyZSosIHN0ZDo6 dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4mJiwgQmFnPENhbGxMaW5rSW5mbz4m JiwgVmVjdG9yPFdhc206Oldhc21Ub0pTU3R1Yj4mJiwgV2FzbTo6SW1tdXRhYmxlRnVuY3Rpb25J bmRleFNwYWNlJiYsIHVuc2lnbmVkIGNhbGxlZUNvdW50KTsKKyAgICBKU1dlYkFzc2VtYmx5TW9k dWxlKFZNJiwgU3RydWN0dXJlKiwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0 aW9uPiYmLCBCYWc8Q2FsbExpbmtJbmZvPiYmLCBWZWN0b3I8V2FzbTo6V2FzbUV4aXRTdHVicz4m JiwgdW5zaWduZWQgY2FsbGVlQ291bnQpOwogICAgIHZvaWQgZmluaXNoQ3JlYXRpb24oVk0mLCBT eW1ib2xUYWJsZSopOwogICAgIHN0YXRpYyB2b2lkIGRlc3Ryb3koSlNDZWxsKik7CiAgICAgc3Rh dGljIHZvaWQgdmlzaXRDaGlsZHJlbihKU0NlbGwqLCBTbG90VmlzaXRvciYpOwpAQCAtMTE3LDgg KzExNCw3IEBAIHByaXZhdGU6CiAgICAgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9y bWF0aW9uPiBtX21vZHVsZUluZm9ybWF0aW9uOwogICAgIEJhZzxDYWxsTGlua0luZm8+IG1fY2Fs bExpbmtJbmZvczsKICAgICBXcml0ZUJhcnJpZXI8U3ltYm9sVGFibGU+IG1fZXhwb3J0U3ltYm9s VGFibGU7Ci0gICAgVmVjdG9yPFdhc206Oldhc21Ub0pTU3R1Yj4gbV93YXNtVG9KU1N0dWJzOwot ICAgIGNvbnN0IFdhc206OkltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSBtX2Z1bmN0aW9uSW5k ZXhTcGFjZTsKKyAgICBWZWN0b3I8V2FzbTo6V2FzbUV4aXRTdHVicz4gbV93YXNtRXhpdFN0dWJz OwogICAgIHVuc2lnbmVkIG1fY2FsbGVlQ291bnQ7CiB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNwcCBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uY3BwCmluZGV4IGJlMjdm NTcuLmJjYTQ3OTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dl YkFzc2VtYmx5RnVuY3Rpb24uY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pz L1dlYkFzc2VtYmx5RnVuY3Rpb24uY3BwCkBAIC0xMTksNiArMTE5LDcgQEAgc3RhdGljIEVuY29k ZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwgY2FsbFdlYkFzc2VtYmx5RnVuY3Rpb24oRXhlY1N0YXRl KiBleGVjKQogICAgIFByb3RvQ2FsbEZyYW1lIHByb3RvQ2FsbEZyYW1lOwogICAgIHByb3RvQ2Fs bEZyYW1lLmluaXQobnVsbHB0ciwgd2FzbUZ1bmN0aW9uLCBmaXJzdEFyZ3VtZW50LCBhcmdDb3Vu dCwgcmVtYWluaW5nQXJncyk7CiAKKyAgICAvLyBGSVhNRSBEbyBhd2F5IHdpdGggdGhpcyBlbnRp cmUgZnVuY3Rpb24sIGFuZCBvbmx5IHVzZSB0aGUgZW50cnlwb2ludCBnZW5lcmF0ZWQgYnkgQjMu IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjY0ODYKICAgICBKU1dl YkFzc2VtYmx5SW5zdGFuY2UqIHByZXZKU1dlYkFzc2VtYmx5SW5zdGFuY2UgPSB2bS50b3BKU1dl YkFzc2VtYmx5SW5zdGFuY2U7CiAgICAgdm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlID0gd2Fz bUZ1bmN0aW9uLT5pbnN0YW5jZSgpOwogICAgIEFTU0VSVCh3YXNtRnVuY3Rpb24tPmluc3RhbmNl KCkpOwpAQCAtMTQ5LDcgKzE1MCw3IEBAIFdlYkFzc2VtYmx5RnVuY3Rpb24qIFdlYkFzc2VtYmx5 RnVuY3Rpb246OmNyZWF0ZShWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPCiB7CiAgICAg TmF0aXZlRXhlY3V0YWJsZSogZXhlY3V0YWJsZSA9IHZtLmdldEhvc3RGdW5jdGlvbihjYWxsV2Vi QXNzZW1ibHlGdW5jdGlvbiwgTm9JbnRyaW5zaWMsIGNhbGxIb3N0RnVuY3Rpb25Bc0NvbnN0cnVj dG9yLCBudWxscHRyLCBuYW1lKTsKICAgICBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSA9IGdsb2JhbE9i amVjdC0+d2ViQXNzZW1ibHlGdW5jdGlvblN0cnVjdHVyZSgpOwotICAgIFdlYkFzc2VtYmx5RnVu Y3Rpb24qIGZ1bmN0aW9uID0gbmV3IChOb3ROdWxsLCBhbGxvY2F0ZUNlbGw8V2ViQXNzZW1ibHlG dW5jdGlvbj4odm0uaGVhcCkpIFdlYkFzc2VtYmx5RnVuY3Rpb24odm0sIGdsb2JhbE9iamVjdCwg c3RydWN0dXJlLCBzaWduYXR1cmVJbmRleCk7CisgICAgV2ViQXNzZW1ibHlGdW5jdGlvbiogZnVu Y3Rpb24gPSBuZXcgKE5vdE51bGwsIGFsbG9jYXRlQ2VsbDxXZWJBc3NlbWJseUZ1bmN0aW9uPih2 bS5oZWFwKSkgV2ViQXNzZW1ibHlGdW5jdGlvbih2bSwgZ2xvYmFsT2JqZWN0LCBzdHJ1Y3R1cmUs IHNpZ25hdHVyZUluZGV4LCB3YXNtRW50cnlwb2ludC0+ZW50cnlwb2ludCgpKTsKICAgICBmdW5j dGlvbi0+ZmluaXNoQ3JlYXRpb24odm0sIGV4ZWN1dGFibGUsIGxlbmd0aCwgbmFtZSwgaW5zdGFu Y2UsIGpzRW50cnlwb2ludCwgd2FzbUVudHJ5cG9pbnQpOwogICAgIHJldHVybiBmdW5jdGlvbjsK IH0KQEAgLTE1NywxMSArMTU4LDEyIEBAIFdlYkFzc2VtYmx5RnVuY3Rpb24qIFdlYkFzc2VtYmx5 RnVuY3Rpb246OmNyZWF0ZShWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPCiBTdHJ1Y3R1 cmUqIFdlYkFzc2VtYmx5RnVuY3Rpb246OmNyZWF0ZVN0cnVjdHVyZShWTSYgdm0sIEpTR2xvYmFs T2JqZWN0KiBnbG9iYWxPYmplY3QsIEpTVmFsdWUgcHJvdG90eXBlKQogewogICAgIEFTU0VSVChn bG9iYWxPYmplY3QpOwotICAgIHJldHVybiBTdHJ1Y3R1cmU6OmNyZWF0ZSh2bSwgZ2xvYmFsT2Jq ZWN0LCBwcm90b3R5cGUsIFR5cGVJbmZvKEpTRnVuY3Rpb25UeXBlLCBTdHJ1Y3R1cmVGbGFncyks IGluZm8oKSk7CisgICAgcmV0dXJuIFN0cnVjdHVyZTo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3Qs IHByb3RvdHlwZSwgVHlwZUluZm8oV2ViQXNzZW1ibHlGdW5jdGlvblR5cGUsIFN0cnVjdHVyZUZs YWdzKSwgaW5mbygpKTsKIH0KIAotV2ViQXNzZW1ibHlGdW5jdGlvbjo6V2ViQXNzZW1ibHlGdW5j dGlvbihWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QsIFN0cnVjdHVyZSogc3Ry dWN0dXJlLCBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCkKK1dlYkFzc2VtYmx5 RnVuY3Rpb246OldlYkFzc2VtYmx5RnVuY3Rpb24oVk0mIHZtLCBKU0dsb2JhbE9iamVjdCogZ2xv YmFsT2JqZWN0LCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2ln bmF0dXJlSW5kZXgsIHZvaWQqIHdhc21FbnRyeXBvaW50KQogICAgIDogQmFzZSh2bSwgZ2xvYmFs T2JqZWN0LCBzdHJ1Y3R1cmUpCisgICAgLCBtX3dhc21FbnRyeVBvaW50Q29kZSh3YXNtRW50cnlw b2ludCkKICAgICAsIG1fc2lnbmF0dXJlSW5kZXgoc2lnbmF0dXJlSW5kZXgpCiB7IH0KIApAQCAt MTgzLDYgKzE4NSw3IEBAIHZvaWQgV2ViQXNzZW1ibHlGdW5jdGlvbjo6ZmluaXNoQ3JlYXRpb24o Vk0mIHZtLCBOYXRpdmVFeGVjdXRhYmxlKiBleGVjdXRhYmxlLCB1CiAgICAgQVNTRVJUKGpzRW50 cnlwb2ludCAhPSB3YXNtRW50cnlwb2ludCk7CiAgICAgbV9qc0VudHJ5cG9pbnQuc2V0KHZtLCB0 aGlzLCBqc0VudHJ5cG9pbnQpOwogICAgIG1fd2FzbUVudHJ5cG9pbnQuc2V0KHZtLCB0aGlzLCB3 YXNtRW50cnlwb2ludCk7CisgICAgQVNTRVJUKG1fd2FzbUVudHJ5cG9pbnQtPmVudHJ5cG9pbnQo KSA9PSBtX3dhc21FbnRyeVBvaW50Q29kZSk7CiB9CiAKIH0gLy8gbmFtZXNwYWNlIEpTQwpkaWZm IC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlv bi5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlvbi5o CmluZGV4IDM0OTA1MDIuLjM4NzdhMDIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmgKQEAgLTU0LDE4ICs1NCwyMiBAQCBwdWJs aWM6CiAKICAgICBKU1dlYkFzc2VtYmx5SW5zdGFuY2UqIGluc3RhbmNlKCkgY29uc3QgeyByZXR1 cm4gbV9pbnN0YW5jZS5nZXQoKTsgfQogICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVy ZUluZGV4KCkgY29uc3QgeyByZXR1cm4gbV9zaWduYXR1cmVJbmRleDsgfQotICAgIHZvaWQqIHdh c21FbnRyeXBvaW50KCkgeyByZXR1cm4gbV93YXNtRW50cnlwb2ludC0+ZW50cnlwb2ludCgpOyB9 CisgICAgdm9pZCogd2FzbUVudHJ5cG9pbnQoKSB7IHJldHVybiBtX3dhc21FbnRyeVBvaW50Q29k ZTsgfQogICAgIHZvaWQqIGpzRW50cnlwb2ludCgpIHsgcmV0dXJuIG1fanNFbnRyeXBvaW50LT5l bnRyeXBvaW50KCk7IH0KIAorICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZJbnN0YW5jZSgp IHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihXZWJBc3NlbWJseUZ1bmN0aW9uLCBtX2luc3RhbmNl KTsgfQorICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZXYXNtRW50cnlQb2ludENvZGUoKSB7 IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoV2ViQXNzZW1ibHlGdW5jdGlvbiwgbV93YXNtRW50cnlQ b2ludENvZGUpOyB9CisKIHByb3RlY3RlZDoKICAgICBzdGF0aWMgdm9pZCB2aXNpdENoaWxkcmVu KEpTQ2VsbCosIFNsb3RWaXNpdG9yJik7CiAKICAgICB2b2lkIGZpbmlzaENyZWF0aW9uKFZNJiwg TmF0aXZlRXhlY3V0YWJsZSosIHVuc2lnbmVkIGxlbmd0aCwgY29uc3QgU3RyaW5nJiBuYW1lLCBK U1dlYkFzc2VtYmx5SW5zdGFuY2UqLCBKU1dlYkFzc2VtYmx5Q2FsbGVlKiBqc0VudHJ5cG9pbnQs IEpTV2ViQXNzZW1ibHlDYWxsZWUqIHdhc21FbnRyeXBvaW50KTsKIAogcHJpdmF0ZToKLSAgICBX ZWJBc3NlbWJseUZ1bmN0aW9uKFZNJiwgSlNHbG9iYWxPYmplY3QqLCBTdHJ1Y3R1cmUqLCBXYXNt OjpTaWduYXR1cmVJbmRleCk7CisgICAgV2ViQXNzZW1ibHlGdW5jdGlvbihWTSYsIEpTR2xvYmFs T2JqZWN0KiwgU3RydWN0dXJlKiwgV2FzbTo6U2lnbmF0dXJlSW5kZXgsIHZvaWQqKTsKIAogICAg IFdyaXRlQmFycmllcjxKU1dlYkFzc2VtYmx5SW5zdGFuY2U+IG1faW5zdGFuY2U7CisgICAgdm9p ZCogbV93YXNtRW50cnlQb2ludENvZGU7IC8vIFJlbW92ZSBpbmRpcmVjdGlvbnMgZm9yIHdhc20g LT4gd2FzbSBjYWxscy4KICAgICBXcml0ZUJhcnJpZXI8SlNXZWJBc3NlbWJseUNhbGxlZT4gbV9q c0VudHJ5cG9pbnQ7CiAgICAgV3JpdGVCYXJyaWVyPEpTV2ViQXNzZW1ibHlDYWxsZWU+IG1fd2Fz bUVudHJ5cG9pbnQ7CiAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggbV9zaWduYXR1cmVJbmRleDsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5SW5z dGFuY2VDb25zdHJ1Y3Rvci5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJB c3NlbWJseUluc3RhbmNlQ29uc3RydWN0b3IuY3BwCmluZGV4IGQ2MGY0MGUuLjFiNDYxMTIgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFu Y2VDb25zdHJ1Y3Rvci5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2Vi QXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVjdG9yLmNwcApAQCAtODQsNiArODQsMTEgQEAgc3RhdGlj IEVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwgY29uc3RydWN0SlNXZWJBc3NlbWJseUluc3Rh bmNlKEV4ZWNTdGF0ZSogZXgKIAogICAgIEpTV2ViQXNzZW1ibHlJbnN0YW5jZSogaW5zdGFuY2Ug PSBKU1dlYkFzc2VtYmx5SW5zdGFuY2U6OmNyZWF0ZSh2bSwgaW5zdGFuY2VTdHJ1Y3R1cmUsIGpz TW9kdWxlLCBtb2R1bGVSZWNvcmQtPmdldE1vZHVsZU5hbWVzcGFjZShleGVjKSk7CiAgICAgUkVU VVJOX0lGX0VYQ0VQVElPTih0aHJvd1Njb3BlLCBlbmNvZGVkSlNWYWx1ZSgpKTsKKyAgICB7Cisg ICAgICAgIC8vIEFsd2F5cyBzdGFydCB3aXRoIGEgZHVtbXkgTWVtb3J5LCBzbyB0aGF0IHdhc20g LT4gd2FzbSB0aHVua3MgYXZvaWQgY2hlY2tpbmcgZm9yIGEgbnVsbHB0ciBNZW1vcnkgd2hlbiB0 cnlpbmcgdG8gc2V0IHBpbm5lZCByZWdpc3RlcnMuCisgICAgICAgIFdhc206Ok1lbW9yeSBtZW1v cnk7CisgICAgICAgIGluc3RhbmNlLT5zZXRNZW1vcnkodm0sIEpTV2ViQXNzZW1ibHlNZW1vcnk6 OmNyZWF0ZSh2bSwgZXhlYy0+bGV4aWNhbEdsb2JhbE9iamVjdCgpLT5XZWJBc3NlbWJseU1lbW9y eVN0cnVjdHVyZSgpLCBXVEZNb3ZlKG1lbW9yeSkpKTsKKyAgICB9CiAKICAgICAvLyBMZXQgZnVu Y3MsIG1lbW9yaWVzIGFuZCB0YWJsZXMgYmUgaW5pdGlhbGx5LWVtcHR5IGxpc3RzIG9mIGNhbGxh YmxlIEphdmFTY3JpcHQgb2JqZWN0cywgV2ViQXNzZW1ibHkuTWVtb3J5IG9iamVjdHMgYW5kIFdl YkFzc2VtYmx5LlRhYmxlIG9iamVjdHMsIHJlc3BlY3RpdmVseS4KICAgICAvLyBMZXQgaW1wb3J0 cyBiZSBhbiBpbml0aWFsbHktZW1wdHkgbGlzdCBvZiBleHRlcm5hbCB2YWx1ZXMuCkBAIC0xMTQs MTggKzExOSwxOSBAQCBzdGF0aWMgRW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBjb25zdHJ1 Y3RKU1dlYkFzc2VtYmx5SW5zdGFuY2UoRXhlY1N0YXRlKiBleAogICAgICAgICAgICAgICAgIHJl dHVybiBKU1ZhbHVlOjplbmNvZGUodGhyb3dFeGNlcHRpb24oZXhlYywgdGhyb3dTY29wZSwgY3Jl YXRlSlNXZWJBc3NlbWJseUxpbmtFcnJvcihleGVjLCB2bSwgQVNDSUlMaXRlcmFsKCJpbXBvcnQg ZnVuY3Rpb24gbXVzdCBiZSBjYWxsYWJsZSIpKSkpOwogICAgICAgICAgICAgSlNDZWxsKiBjZWxs ID0gdmFsdWUuYXNDZWxsKCk7CiAgICAgICAgICAgICAvLyBpaS4gSWYgdiBpcyBhbiBFeHBvcnRl ZCBGdW5jdGlvbiBFeG90aWMgT2JqZWN0OgotICAgICAgICAgICAgaWYgKFdlYkFzc2VtYmx5RnVu Y3Rpb24qIGltcG9ydGVkRXhwb3J0cyA9IGpzRHluYW1pY0Nhc3Q8V2ViQXNzZW1ibHlGdW5jdGlv bio+KG9iamVjdCkpIHsKLSAgICAgICAgICAgICAgICAvLyBGSVhNRSBoYW5kbGUgRnVuY3Rpb24g RXhvdGljIE9iamVjdCBwcm9wZXJseS4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTE2NTI4MgotICAgICAgICAgICAgICAgIC8vIGEuIElmIHRoZSBzaWduYXR1cmUgb2Yg diBkb2VzIG5vdCBtYXRjaCB0aGUgc2lnbmF0dXJlIG9mIGksIHRocm93IGEgVHlwZUVycm9yLgor ICAgICAgICAgICAgaWYgKFdlYkFzc2VtYmx5RnVuY3Rpb24qIGltcG9ydGVkRXhwb3J0ID0ganNE eW5hbWljQ2FzdDxXZWJBc3NlbWJseUZ1bmN0aW9uKj4oY2VsbCkpIHsKKyAgICAgICAgICAgICAg ICAvLyBhLiBJZiB0aGUgc2lnbmF0dXJlIG9mIHYgZG9lcyBub3QgbWF0Y2ggdGhlIHNpZ25hdHVy ZSBvZiBpLCB0aHJvdyBhIFdlYkFzc2VtYmx5LkxpbmtFcnJvci4KKyAgICAgICAgICAgICAgICBX YXNtOjpTaWduYXR1cmVJbmRleCBpbXBvcnRlZFNpZ25hdHVyZUluZGV4ID0gaW1wb3J0ZWRFeHBv cnQtPnNpZ25hdHVyZUluZGV4KCk7CisgICAgICAgICAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5k ZXggZXhwZWN0ZWRTaWduYXR1cmVJbmRleCA9IG1vZHVsZUluZm9ybWF0aW9uLmltcG9ydEZ1bmN0 aW9uU2lnbmF0dXJlSW5kaWNlc1tpbXBvcnQua2luZEluZGV4XTsKKyAgICAgICAgICAgICAgICBp ZiAoaW1wb3J0ZWRTaWduYXR1cmVJbmRleCAhPSBleHBlY3RlZFNpZ25hdHVyZUluZGV4KQorICAg ICAgICAgICAgICAgICAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKHRocm93RXhjZXB0aW9uKGV4 ZWMsIHRocm93U2NvcGUsIGNyZWF0ZUpTV2ViQXNzZW1ibHlMaW5rRXJyb3IoZXhlYywgdm0sIEFT Q0lJTGl0ZXJhbCgiaW1wb3J0ZWQgZnVuY3Rpb24ncyBzaWduYXR1cmUgZG9lc24ndCBtYXRjaCB0 aGUgcHJvdmlkZWQgV2ViQXNzZW1ibHkgZnVuY3Rpb24ncyBzaWduYXR1cmUiKSkpKTsKICAgICAg ICAgICAgICAgICAvLyBiLiBMZXQgY2xvc3VyZSBiZSB2LltbQ2xvc3VyZV1dLgotICAgICAgICAg ICAgICAgIFJFTEVBU0VfQVNTRVJUX05PVF9SRUFDSEVEKCk7Ci0gICAgICAgICAgICAgICAgVU5V U0VEX1BBUkFNKGltcG9ydGVkRXhwb3J0cyk7Ci0gICAgICAgICAgICAgICAgYnJlYWs7CiAgICAg ICAgICAgICB9CiAgICAgICAgICAgICAvLyBpaWkuIE90aGVyd2lzZToKICAgICAgICAgICAgIC8v IGEuIExldCBjbG9zdXJlIGJlIGEgbmV3IGhvc3QgZnVuY3Rpb24gb2YgdGhlIGdpdmVuIHNpZ25h dHVyZSB3aGljaCBjYWxscyB2IGJ5IGNvZXJjaW5nIFdlYkFzc2VtYmx5IGFyZ3VtZW50cyB0byBK YXZhU2NyaXB0IGFyZ3VtZW50cyB2aWEgVG9KU1ZhbHVlIGFuZCByZXR1cm5zIHRoZSByZXN1bHQs IGlmIGFueSwgYnkgY29lcmNpbmcgdmlhIFRvV2ViQXNzZW1ibHlWYWx1ZS4KICAgICAgICAgICAg IC8vIE5vdGU6IGRvbmUgYXMgcGFydCBvZiBQbGFuIGNvbXBpbGF0aW9uLgogICAgICAgICAgICAg Ly8gaXYuIEFwcGVuZCB2IHRvIGZ1bmNzLgorICAgICAgICAgICAgLy8gTm90ZTogYWRkaW5nIHRo ZSBKU0NlbGwgdG8gdGhlIGluc3RhbmNlIGxpc3QgZnVsZmlsbHMgY2xvc3VyZSByZXF1aXJlbWVu dHMgYi4gYWJvdmUgKHRoZSBXZWJBc3NlbWJseS5JbnN0YW5jZSB3aWwgYmUga2VwdCBhbGl2ZSkg YW5kIHYuIGJlbG93ICh0aGUgSlNGdW5jdGlvbikuCiAgICAgICAgICAgICBpbnN0YW5jZS0+c2V0 SW1wb3J0RnVuY3Rpb24odm0sIGNlbGwsIG51bUltcG9ydEZ1bmN0aW9ucysrKTsKICAgICAgICAg ICAgIC8vIHYuIEFwcGVuZCBjbG9zdXJlIHRvIGltcG9ydHMuCiAgICAgICAgICAgICBicmVhazsK QEAgLTIzMCw3ICsyMzYsNyBAQCBzdGF0aWMgRW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBj b25zdHJ1Y3RKU1dlYkFzc2VtYmx5SW5zdGFuY2UoRXhlY1N0YXRlKiBleAogICAgICAgICAgICAg UkVMRUFTRV9BU1NFUlQoIW1vZHVsZUluZm9ybWF0aW9uLm1lbW9yeS5pc0ltcG9ydCgpKTsKICAg ICAgICAgICAgIC8vIFdlIGNyZWF0ZSBhIG1lbW9yeSB3aGVuIGl0J3MgYSBtZW1vcnkgZGVmaW5p dGlvbi4KICAgICAgICAgICAgIGJvb2wgZmFpbGVkOwotICAgICAgICAgICAgc3RkOjp1bmlxdWVf cHRyPFdhc206Ok1lbW9yeT4gbWVtb3J5ID0gc3RkOjptYWtlX3VuaXF1ZTxXYXNtOjpNZW1vcnk+ KG1vZHVsZUluZm9ybWF0aW9uLm1lbW9yeS5pbml0aWFsKCksIG1vZHVsZUluZm9ybWF0aW9uLm1l bW9yeS5tYXhpbXVtKCksIGZhaWxlZCk7CisgICAgICAgICAgICBXYXNtOjpNZW1vcnkgbWVtb3J5 KG1vZHVsZUluZm9ybWF0aW9uLm1lbW9yeS5pbml0aWFsKCksIG1vZHVsZUluZm9ybWF0aW9uLm1l bW9yeS5tYXhpbXVtKCksIGZhaWxlZCk7CiAgICAgICAgICAgICBpZiAoZmFpbGVkKQogICAgICAg ICAgICAgICAgIHJldHVybiBKU1ZhbHVlOjplbmNvZGUodGhyb3dFeGNlcHRpb24oZXhlYywgdGhy b3dTY29wZSwgY3JlYXRlT3V0T2ZNZW1vcnlFcnJvcihleGVjKSkpOwogICAgICAgICAgICAgaW5z dGFuY2UtPnNldE1lbW9yeSh2bSwKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL2pzL1dlYkFzc2VtYmx5TWVtb3J5Q29uc3RydWN0b3IuY3BwIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNZW1vcnlDb25zdHJ1Y3Rvci5jcHAKaW5kZXggNWQ1 YTZjZC4uNmM4ODdhZiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMv V2ViQXNzZW1ibHlNZW1vcnlDb25zdHJ1Y3Rvci5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vanMvV2ViQXNzZW1ibHlNZW1vcnlDb25zdHJ1Y3Rvci5jcHAKQEAgLTk3LDcgKzk3 LDcgQEAgc3RhdGljIEVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwgY29uc3RydWN0SlNXZWJB c3NlbWJseU1lbW9yeShFeGVjU3RhdGUqIGV4ZWMKICAgICB9CiAKICAgICBib29sIGZhaWxlZDsK LSAgICBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiBtZW1vcnkgPSBzdGQ6Om1ha2VfdW5p cXVlPFdhc206Ok1lbW9yeT4oaW5pdGlhbFBhZ2VDb3VudCwgbWF4aW11bVBhZ2VDb3VudCwgZmFp bGVkKTsKKyAgICBXYXNtOjpNZW1vcnkgbWVtb3J5KGluaXRpYWxQYWdlQ291bnQsIG1heGltdW1Q YWdlQ291bnQsIGZhaWxlZCk7CiAgICAgaWYgKGZhaWxlZCkKICAgICAgICAgcmV0dXJuIEpTVmFs dWU6OmVuY29kZSh0aHJvd0V4Y2VwdGlvbihleGVjLCB0aHJvd1Njb3BlLCBjcmVhdGVPdXRPZk1l bW9yeUVycm9yKGV4ZWMpKSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlQ29uc3RydWN0b3IuY3BwIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVDb25zdHJ1Y3Rvci5jcHAKaW5kZXggMzhl ZGI4Yy4uODEyOTU5MiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMv V2ViQXNzZW1ibHlNb2R1bGVDb25zdHJ1Y3Rvci5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVDb25zdHJ1Y3Rvci5jcHAKQEAgLTk3LDcgKzk3 LDcgQEAgSlNWYWx1ZSBXZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yOjpjcmVhdGVNb2R1bGUo RXhlY1N0YXRlKiBzdGF0ZSwgU3RydWN0dXJlKgogCiAgICAgLy8gT25seSB3YXNtLWludGVybmFs IGZ1bmN0aW9ucyBoYXZlIGEgY2FsbGVlLCBzdHVicyB0byBKUyBkbyBub3QuCiAgICAgdW5zaWdu ZWQgY2FsbGVlQ291bnQgPSBwbGFuLmludGVybmFsRnVuY3Rpb25Db3VudCgpOwotICAgIEpTV2Vi QXNzZW1ibHlNb2R1bGUqIHJlc3VsdCA9IEpTV2ViQXNzZW1ibHlNb2R1bGU6OmNyZWF0ZSh2bSwg c3RydWN0dXJlLCBwbGFuLnRha2VNb2R1bGVJbmZvcm1hdGlvbigpLCBwbGFuLnRha2VDYWxsTGlu a0luZm9zKCksIHBsYW4udGFrZVdhc21Ub0pTU3R1YnMoKSwgcGxhbi50YWtlRnVuY3Rpb25JbmRl eFNwYWNlKCksIGV4cG9ydFN5bWJvbFRhYmxlLCBjYWxsZWVDb3VudCk7CisgICAgSlNXZWJBc3Nl bWJseU1vZHVsZSogcmVzdWx0ID0gSlNXZWJBc3NlbWJseU1vZHVsZTo6Y3JlYXRlKHZtLCBzdHJ1 Y3R1cmUsIHBsYW4udGFrZU1vZHVsZUluZm9ybWF0aW9uKCksIHBsYW4udGFrZUNhbGxMaW5rSW5m b3MoKSwgcGxhbi50YWtlV2FzbUV4aXRTdHVicygpLCBleHBvcnRTeW1ib2xUYWJsZSwgY2FsbGVl Q291bnQpOwogICAgIHBsYW4uaW5pdGlhbGl6ZUNhbGxlZXMoc3RhdGUtPmpzQ2FsbGVlKCktPmds b2JhbE9iamVjdCgpLCAKICAgICAgICAgWyZdICh1bnNpZ25lZCBjYWxsZWVJbmRleCwgSlNXZWJB c3NlbWJseUNhbGxlZSoganNFbnRyeXBvaW50Q2FsbGVlLCBKU1dlYkFzc2VtYmx5Q2FsbGVlKiB3 YXNtRW50cnlwb2ludENhbGxlZSkgewogICAgICAgICAgICAgcmVzdWx0LT5zZXRKU0VudHJ5cG9p bnRDYWxsZWUodm0sIGNhbGxlZUluZGV4LCBqc0VudHJ5cG9pbnRDYWxsZWUpOwpkaWZmIC0tZ2l0 IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQu Y3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVSZWNv cmQuY3BwCmluZGV4IGMxYmQ4MjAuLjllZmY0YzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmNwcAorKysgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZVJlY29yZC5jcHAKQEAgLTEx OCw3ICsxMTgsNyBAQCB2b2lkIFdlYkFzc2VtYmx5TW9kdWxlUmVjb3JkOjpsaW5rKEV4ZWNTdGF0 ZSogc3RhdGUsIEpTV2ViQXNzZW1ibHlJbnN0YW5jZSogaW5zdAogICAgICAgICAgICAgLy8gICAg IGMuIFJldHVybiBmdW5jLgogICAgICAgICAgICAgSlNXZWJBc3NlbWJseUNhbGxlZSoganNFbnRy eXBvaW50Q2FsbGVlID0gbW9kdWxlLT5qc0VudHJ5cG9pbnRDYWxsZWVGcm9tRnVuY3Rpb25JbmRl eFNwYWNlKGV4cC5raW5kSW5kZXgpOwogICAgICAgICAgICAgSlNXZWJBc3NlbWJseUNhbGxlZSog d2FzbUVudHJ5cG9pbnRDYWxsZWUgPSBtb2R1bGUtPndhc21FbnRyeXBvaW50Q2FsbGVlRnJvbUZ1 bmN0aW9uSW5kZXhTcGFjZShleHAua2luZEluZGV4KTsKLSAgICAgICAgICAgIFdhc206OlNpZ25h dHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVGb3JGdW5jdGlvbklu ZGV4U3BhY2UoZXhwLmtpbmRJbmRleCk7CisgICAgICAgICAgICBXYXNtOjpTaWduYXR1cmVJbmRl eCBzaWduYXR1cmVJbmRleCA9IG1vZHVsZS0+c2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRl eFNwYWNlKGV4cC5raW5kSW5kZXgpOwogICAgICAgICAgICAgY29uc3QgV2FzbTo6U2lnbmF0dXJl KiBzaWduYXR1cmUgPSBXYXNtOjpTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KCZ2bSwgc2lnbmF0 dXJlSW5kZXgpOwogICAgICAgICAgICAgV2ViQXNzZW1ibHlGdW5jdGlvbiogZnVuY3Rpb24gPSBX ZWJBc3NlbWJseUZ1bmN0aW9uOjpjcmVhdGUodm0sIGdsb2JhbE9iamVjdCwgc2lnbmF0dXJlLT5h cmd1bWVudENvdW50KCksIGV4cC5maWVsZC5zdHJpbmcoKSwgaW5zdGFuY2UsIGpzRW50cnlwb2lu dENhbGxlZSwgd2FzbUVudHJ5cG9pbnRDYWxsZWUsIHNpZ25hdHVyZUluZGV4KTsKICAgICAgICAg ICAgIGV4cG9ydGVkVmFsdWUgPSBmdW5jdGlvbjsKQEAgLTEzMyw4ICsxMzMsNiBAQCB2b2lkIFdl YkFzc2VtYmx5TW9kdWxlUmVjb3JkOjpsaW5rKEV4ZWNTdGF0ZSogc3RhdGUsIEpTV2ViQXNzZW1i bHlJbnN0YW5jZSogaW5zdAogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIH0KICAgICAgICAg Y2FzZSBXYXNtOjpFeHRlcm5hbEtpbmQ6Ok1lbW9yeTogewotICAgICAgICAgICAgLy8gVGhpcyBz aG91bGQgYmUgZ3VhcmFudGVlZCBieSBtb2R1bGUgdmVyaWZpY2F0aW9uLgotICAgICAgICAgICAg UkVMRUFTRV9BU1NFUlQoaW5zdGFuY2UtPm1lbW9yeSgpKTsgCiAgICAgICAgICAgICBBU1NFUlQo ZXhwLmtpbmRJbmRleCA9PSAwKTsKIAogICAgICAgICAgICAgZXhwb3J0ZWRWYWx1ZSA9IGluc3Rh bmNlLT5tZW1vcnkoKTsKQEAgLTE3NSw3ICsxNzMsNyBAQCB2b2lkIFdlYkFzc2VtYmx5TW9kdWxl UmVjb3JkOjpsaW5rKEV4ZWNTdGF0ZSogc3RhdGUsIEpTV2ViQXNzZW1ibHlJbnN0YW5jZSogaW5z dAogICAgIGJvb2wgaGFzU3RhcnQgPSAhIW1vZHVsZUluZm9ybWF0aW9uLnN0YXJ0RnVuY3Rpb25J bmRleFNwYWNlOwogICAgIGlmIChoYXNTdGFydCkgewogICAgICAgICBhdXRvIHN0YXJ0RnVuY3Rp b25JbmRleFNwYWNlID0gbW9kdWxlSW5mb3JtYXRpb24uc3RhcnRGdW5jdGlvbkluZGV4U3BhY2Uu dmFsdWVfb3IoMCk7Ci0gICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4 ID0gbW9kdWxlLT5zaWduYXR1cmVGb3JGdW5jdGlvbkluZGV4U3BhY2Uoc3RhcnRGdW5jdGlvbklu ZGV4U3BhY2UpOworICAgICAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9 IG1vZHVsZS0+c2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRleFNwYWNlKHN0YXJ0RnVuY3Rp b25JbmRleFNwYWNlKTsKICAgICAgICAgY29uc3QgV2FzbTo6U2lnbmF0dXJlKiBzaWduYXR1cmUg PSBXYXNtOjpTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KCZ2bSwgc2lnbmF0dXJlSW5kZXgpOwog ICAgICAgICAvLyBUaGUgc3RhcnQgZnVuY3Rpb24gbXVzdCBub3QgdGFrZSBhbnkgYXJndW1lbnRz IG9yIHJldHVybiBhbnl0aGluZy4gVGhpcyBpcyBlbmZvcmNlZCBieSB0aGUgcGFyc2VyLgogICAg ICAgICBBU1NFUlQoIXNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpKTsKQEAgLTIzOCw3ICsyMzYs NyBAQCBKU1ZhbHVlIFdlYkFzc2VtYmx5TW9kdWxlUmVjb3JkOjpldmFsdWF0ZShFeGVjU3RhdGUq IHN0YXRlKQogCiAgICAgICAgICAgICAgICAgSlNXZWJBc3NlbWJseUNhbGxlZSoganNFbnRyeXBv aW50Q2FsbGVlID0gbW9kdWxlLT5qc0VudHJ5cG9pbnRDYWxsZWVGcm9tRnVuY3Rpb25JbmRleFNw YWNlKGZ1bmN0aW9uSW5kZXgpOwogICAgICAgICAgICAgICAgIEpTV2ViQXNzZW1ibHlDYWxsZWUq IHdhc21FbnRyeXBvaW50Q2FsbGVlID0gbW9kdWxlLT53YXNtRW50cnlwb2ludENhbGxlZUZyb21G dW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleCk7Ci0gICAgICAgICAgICAgICAgV2FzbTo6 U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVyZUZvckZ1bmN0 aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KTsKKyAgICAgICAgICAgICAgICBXYXNtOjpTaWdu YXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1vZHVsZS0+c2lnbmF0dXJlSW5kZXhGcm9tRnVu Y3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgpOwogICAgICAgICAgICAgICAgIGNvbnN0IFdh c206OlNpZ25hdHVyZSogc2lnbmF0dXJlID0gV2FzbTo6U2lnbmF0dXJlSW5mb3JtYXRpb246Omdl dCgmdm0sIHNpZ25hdHVyZUluZGV4KTsKICAgICAgICAgICAgICAgICAvLyBGSVhNRTogU2F5IHdl IGV4cG9ydCBsb2NhbCBmdW5jdGlvbiAiZm9vIiBhdCBmdW5jaXRvbiBpbmRleCAwLgogICAgICAg ICAgICAgICAgIC8vIFdoYXQgaWYgd2UgYWxzbyBzZXQgaXQgdG8gdGhlIHRhYmxlIGFuIEVsZW1l bnQgdy8gaW5kZXggMC4KQEAgLTI1Nyw3ICsyNTUsNiBAQCBKU1ZhbHVlIFdlYkFzc2VtYmx5TW9k dWxlUmVjb3JkOjpldmFsdWF0ZShFeGVjU3RhdGUqIHN0YXRlKQogICAgICAgICBjb25zdCBWZWN0 b3I8V2FzbTo6U2VnbWVudDo6UHRyPiYgZGF0YSA9IG1faW5zdGFuY2UtPm1vZHVsZSgpLT5tb2R1 bGVJbmZvcm1hdGlvbigpLmRhdGE7CiAgICAgICAgIEpTV2ViQXNzZW1ibHlNZW1vcnkqIGpzTWVt b3J5ID0gbV9pbnN0YW5jZS0+bWVtb3J5KCk7CiAgICAgICAgIGlmICghZGF0YS5pc0VtcHR5KCkp IHsKLSAgICAgICAgICAgIFJFTEVBU0VfQVNTRVJUKGpzTWVtb3J5KTsgLy8gSXQgaXMgYSB2YWxp ZGF0aW9uIGVycm9yIGZvciBhIERhdGEgc2VjdGlvbiB0byBleGlzdCB3aXRob3V0IGEgTWVtb3J5 IHNlY3Rpb24gb3IgaW1wb3J0LgogICAgICAgICAgICAgdWludDhfdCogbWVtb3J5ID0gcmVpbnRl cnByZXRfY2FzdDx1aW50OF90Kj4oanNNZW1vcnktPm1lbW9yeSgpLT5tZW1vcnkoKSk7CiAgICAg ICAgICAgICB1aW50NjRfdCBzaXplSW5CeXRlcyA9IGpzTWVtb3J5LT5tZW1vcnkoKS0+c2l6ZSgp OwogICAgICAgICAgICAgZm9yIChhdXRvJiBzZWdtZW50IDogZGF0YSkgewpkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQuaCBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmgK aW5kZXggZTEyNjY3MC4uMjQ2NWQ4MyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZVJlY29yZC5oCkBAIC00NSw3ICs0NSw3IEBA IHB1YmxpYzoKICAgICBERUNMQVJFX0VYUE9SVF9JTkZPOwogCiAgICAgc3RhdGljIFN0cnVjdHVy ZSogY3JlYXRlU3RydWN0dXJlKFZNJiwgSlNHbG9iYWxPYmplY3QqLCBKU1ZhbHVlKTsKLSAgICBz dGF0aWMgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQqIGNyZWF0ZShFeGVjU3RhdGUqLCBWTSYsIFN0 cnVjdHVyZSosIGNvbnN0IElkZW50aWZpZXImLCBjb25zdCBXYXNtOjpNb2R1bGVJbmZvcm1hdGlv biYpOworICAgIEpTX0VYUE9SVF9QUklWQVRFIHN0YXRpYyBXZWJBc3NlbWJseU1vZHVsZVJlY29y ZCogY3JlYXRlKEV4ZWNTdGF0ZSosIFZNJiwgU3RydWN0dXJlKiwgY29uc3QgSWRlbnRpZmllciYs IGNvbnN0IFdhc206Ok1vZHVsZUluZm9ybWF0aW9uJik7CiAKICAgICB2b2lkIGxpbmsoRXhlY1N0 YXRlKiwgSlNXZWJBc3NlbWJseUluc3RhbmNlKik7CiAgICAgSlNfRVhQT1JUX1BSSVZBVEUgSlNW YWx1ZSBldmFsdWF0ZShFeGVjU3RhdGUqKTsKLS0gCjIuMTAuMQoK 297860 2016-12-30 12:24:29 -0800 2016-12-30 12:54:18 -0800 WIP 0001-wasm-wasm.patch text/plain 144350 jfbastien RnJvbSAzMDIzZTcyNjNkMTBiZWIwOTU0NjlhYWZjOTFjYjEzNTZhMGI1MjZlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBXZWQsIDIxIERlYyAyMDE2IDE1OjU5OjU2IC0wODAwClN1YmplY3Q6IFtQQVRDSF0gd2FzbS0+ d2FzbQoKQ2hhbmdlcyB0byB0aGUgV2ViQXNzZW1ibHkgaW1wbGVtZW50YXRpb246CgogIC0gQWRk IGEgbmV3IEpTVHlwZSBmb3IgV2ViQXNzZW1ibHlGdW5jdGlvbiwgYW5kIHVzZSBpdCB3aGVuIGNy ZWF0aW5nIGl0cwogICAgc3RydWN0dXJlLiBUaGlzIHdpbGwgYmUgdXNlZCB0byBxdWlja2x5IGRl dGVjdCBmcm9tIHdhc20gd2hldGhlciB0aGUgaW1wb3J0CiAgICBjYWxsIGlzIHRvIGFub3RoZXIg d2FzbSBtb2R1bGUsIG9yIHdoZXRoZXIgaXQncyB0byBKUy4KICAtIFVzZSBjZWxsIGluc3RlYWQg b2Ygb2JqZWN0cyB0byBkZXRlY3Qgd2FzbS0+d2FzbSwgdGhlIHByZXZpb3VzIGNvZGUgd2FzIHdy b25nLgogIC0gSW1wcm92ZSBkaWFnbm9zdGljIHByaW50b3V0IGZvciB3YXNtIHN0dWJzOiBwcmlu dCB0aGUgZnVsbCBzaWduYXR1cmUuCiAgLSBQcm9wZXJseSBjaGVjayB0aGF0IHdhc20gLT4gd2Fz bSBjYWxscyBoYXZlIG1hdGNoaW5nIHNpZ25hdHVyZXMuIEFkZCB0ZXN0aW5nIGZvciB0aGlzLgog IC0gVGVzdCBzb21lIG9mIHRoZSB3YXNtIC0+IHdhc20gY2FsbHMsIG5vdCB3b3JraW5nIHlldCwg YW5kIG1vcmUgdGVzdHMgbmVlZCB0bwogICAgZ2V0IGltcGxlbWVudGVkLgogIC0gR2VuZXJhdGUg dHdvIHN0dWJzIGZyb20gdGhlIGltcG9ydCBzdHViIGdlbmVyYXRvcjogb25lIGZvciB3YXNtLT5K UyBhbmQgb25lCiAgICBmb3Igd2FzbSAtPiB3YXNtLiBUaGlzIGlzIGRvbmUgYXQgTW9kdWxlIHRp bWUuIFdoaWNoIGlzIGNhbGxlZCB3aWxsIG9ubHkgYmUKICAgIGtub3duIGF0IEluc3RhbmNlIHRp bWUsIG9uY2Ugd2UndmUgcmVjZWl2ZWQgdGhlIGltcG9ydCBvYmplY3QuIFdlIHdhbnQgdG8KICAg IGF2b2lkIGNvZGVnZW4gYXQgSW5zdGFuY2UgdGltZSwgc28gaGF2aW5nIGJvdGggYXJvdW5kIGlz IGdyZWF0LgogIC0gUmVzdG9yZSB0aGUgV2ViQXNzZW1ibHkgZ2xvYmFsIHN0YXRlIChWTSB0b3Ag SW5zdGFuY2UsIGFuZCBwaW5uZWQgcmVnaXN0ZXJzKQogICAgYWZ0ZXIgY2FsbCAvIGNhbGxfaW5k aXJlY3QsIGFuZCBpbiB0aGUgSlMtPndhc20gZW50cnkgc3R1Yi4KICAtIFBpbm5lZCByZWdpc3Rl cnMgYXJlIG5vdyBhIGdsb2JhbCB0aGluZywgbm90IHBlci1NZW1vcnksIGJlY2F1c2UgdGhlIHdh c20gLT4KICAgIHdhc20gc3R1YnMgYXJlIGdlbmVyYXRlZCBhdCBNb2R1bGUgdGltZSB3aGVyZSB3 ZSBkb24ndCByZWFsbHkgaGF2ZSBlbm91Z2gKICAgIGluZm9ybWF0aW9uIHRvIGRvIHRoZSByaWdo dCB0aGluZyAoZG9pbmcgc28gd291bGQgZ2VuZXJhdGUgdG9vIG11Y2ggY29kZSkuCgpTdXBwb3J0 IGNoYW5nZXM6CgogIC0gQWRkIGEgUHJveHkgdG8gQnVpbGRlci5qcywgd2hpY2ggaW50ZXJjZXB0 cyB1bmtub3duIHByb3BlcnR5IGxvb2t1cHMuIFRoaXMKICAgIGNyZWF0ZXMgd2F5IGJldHRlciBl cnJvciBtZXNzYWdlcyBvbiB0eXBvcyB0aGFuICd1bmRlZmluZWQgaXMgbm90IGEKICAgIGZ1bmN0 aW9uJywgd2hpY2ggaGFwcGVucyBzZW1pLWZyZXF1ZW50bHkgYXMgSSB0eXBvIG9wY29kZSBuYW1l cyAoYW5kIHdoaWNoCiAgICBvbmUgaXMgYSB0eXBvIGlzIGhhcmQgdG8gZmluZCBiZWNhdXNlIHdl IGNoYWluIGJ1aWxkZXJzKS4KICAtIEFkZCBsaW1pdGVkIHN1cHBvcnQgZm9yIHZhcnt1fWludDY0 IChvbmx5IHRoZSAzMi1iaXQgdmFsdWVzKS4KICAtIEdldCByaWQgb2YgbXVjaCBvZiB0aGUgZnVu Y3Rpb24gaW5kZXggc3BhY2U6IHdlIGFscmVhZHkgaGF2ZSBhbGwgb2YgaXRzCiAgICBpbmZvcm1h dGlvbiBlbHNld2hlcmUsIGFuZCBhcy1pcyBpdCBwcm92aWRlcyBubyBleHRyYSBlZmZpY2llbmN5 LgogIC0gU3RvcmUgV2FzbTo6TWVtb3J5IGRpcmVjdGx5IG9uIEpTV2ViQXNzZW1ibHlNZW1vcnks IGluc3RlYWQgb2YgdGhyb3VnaCBhCiAgICB1bmlxdWVfcHRyLiBUaGlzIHJlbW92ZXMgYW4gaW5k aXJlY3Rpb24gYW5kIHVzZWxlc3MgYWxsb2NhdGlvbi4KICAtIFJlbW92ZSBWTSdhIFdlYkFzc2Vt Ymx5IG1lbW9yeSAvIHNpemUsIGFuZCBvYnRhaW4gdGhlbSBmcm9tIEluc3RhbmNlCiAgICBpbnN0 ZWFkLiBUaGlzIHJlcXVpcmVzIGFuIGV4dHJhIGluZGlyZWN0aW9uLCBidXQgaXMgY2xlYW5lci4K ICAtIENhY2hlIHRoZSB3YXNtIGVudHJ5cG9pbnQgY29kZSdzIGxvY2F0aW9uIG9uIFdlYkFzc2Vt Ymx5RnVuY3Rpb24gZm9yIGZhc3RlcgogICAgYWNjZXNzLgogIC0gQWxsIEluc3RhbmNlIG5vdyBo YXZlIGEgdmFsaWQgSlNXZWJBc3NlbWJseU1lbW9yeSB3aGVuIGNyZWF0ZWQsIHdoaWNoIGFsbG93 cwogICAgdGhlIHdhc20gLT4gd2FzbSBzdHViIHRvIGFzc3VtZSBpdCBpc24ndCBudWxsIHdoZW4g dHJ5aW5nIHRvIHNldCB0aGUgcGlubmVkCiAgICByZWdpc3RlcnMuCiAgLSBBbHdheXMgcGluIHJl Z2lzdGVycywgZXZlbiBpZiBubyBNZW1vcnkgaXMgcHJlc2VudCBhbmQgd2UgZG9uJ3QgdGVjaG5p Y2FsbHkKICAgIG5lZWQgdG8gcGluIHRoZW0uCi0tLQogSlNUZXN0cy93YXNtL0J1aWxkZXIuanMg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgOTEgKysrKystLS0tCiBKU1Rlc3RzL3dhc20v TG93TGV2ZWxCaW5hcnkuanMgICAgICAgICAgICAgICAgICAgICB8ICAxMiArKwogSlNUZXN0cy93 YXNtL2Z1bmN0aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMgICAgICAgICAgfCAgIDYgKy0KIEpTVGVz dHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMgICAgICAgICAgIHwgICAyICstCiBK U1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5qcyAgICAgICAgICB8ICAgMiAr LQogSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20tYmFkLXNpZ25hdHVyZS5qcyAgfCAx MDUgKysrKysrKysrKwogSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMgICAgICAg ICAgICAgICAgfCAgNzIgKysrKysrKwogU291cmNlL0phdmFTY3JpcHRDb3JlL0NNYWtlTGlzdHMu dHh0ICAgICAgICAgICAgICAgfCAgIDEgKwogLi4uL0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2ogICAgICAgfCAgIDggKy0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9qc2Mu Y3BwICAgICAgICAgICAgICAgICAgICAgIHwgIDI1ICsrLQogLi4uL0phdmFTY3JpcHRDb3JlL3J1 bnRpbWUvQWJzdHJhY3RNb2R1bGVSZWNvcmQuaCAgfCAgIDIgKy0KIFNvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL0pTVHlwZS5oICAgICAgICAgICAgIHwgICAyICsKIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcCAgIHwgMjIzICsrKysrKysrKysrKyst LS0tLS0tLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuaCAg ICAgfCAgIDIgKy0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmNwcCAg ICAgICAgIHwgIDY3ICsrKysrKy0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5k aW5nLmggICAgICAgICAgIHwgICAyICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt Rm9ybWF0LmggICAgICAgICAgICB8ICAyOCArKy0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21GdW5jdGlvblBhcnNlci5oICAgIHwgIDE2ICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9XYXNtTWVtb3J5LmNwcCAgICAgICAgICB8ICA1NyArKysrKy0KIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21NZW1vcnkuaCAgICAgICAgICAgIHwgIDMxICsrLQogLi4uL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmNwcCAgfCAgNTkgKysrKy0tCiBT b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5SW5mb3JtYXRpb24uaCB8ICAgOSAr LQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5jcHAgICAgfCAg MjcgKy0tCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmggICAg ICB8ICAgMiArLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBhZ2VDb3VudC5jcHAg ICAgICAgfCAgNDUgKysrKysKIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QYWdlQ291 bnQuaCAgICAgICAgIHwgICA2ICsKIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFu LmNwcCAgICAgICAgICAgIHwgIDQ0ICsrLS0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dh c21QbGFuLmggICAgICAgICAgICAgIHwgIDE0ICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtU2lnbmF0dXJlLmNwcCAgICAgICB8ICAxOCArLQogU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbVNpZ25hdHVyZS5oICAgICAgICAgfCAgIDEgKwogU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbVZhbGlkYXRlLmNwcCAgICAgICAgfCAgIDQgKy0KIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5oICAgICAgICAgIHwgICAyICstCiAuLi4vSmF2YVNj cmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaCB8ICAxMSArLQogLi4uL0ph dmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5jcHAgfCAgMTIgKy0KIC4u Li9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuaCAgIHwgIDEzICst CiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmNwcCB8ICAg OSArLQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5oICAg fCAgMTYgKy0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24u Y3BwIHwgICA5ICstCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0 aW9uLmggICB8ICAgOCArLQogLi4uL3dhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVj dG9yLmNwcCAgICAgfCAgMjAgKy0KIC4uLi93YXNtL2pzL1dlYkFzc2VtYmx5TWVtb3J5Q29uc3Ry dWN0b3IuY3BwICAgICAgIHwgICAyICstCiAuLi4vd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNv bnN0cnVjdG9yLmNwcCAgICAgICB8ICAgMiArLQogLi4uL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1 bGVSZWNvcmQuY3BwICAgICAgICAgICAgfCAgIDkgKy0KIC4uLi93YXNtL2pzL1dlYkFzc2VtYmx5 TW9kdWxlUmVjb3JkLmggICAgICAgICAgICAgIHwgICAyICstCiA0NCBmaWxlcyBjaGFuZ2VkLCA3 OTcgaW5zZXJ0aW9ucygrKSwgMzAxIGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IEpT VGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLWJhZC1zaWduYXR1cmUuanMKIGNyZWF0ZSBt b2RlIDEwMDY0NCBKU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS5qcwogY3JlYXRlIG1v ZGUgMTAwNjQ0IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QYWdlQ291bnQuY3BwCgpk aWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL0J1aWxkZXIuanMgYi9KU1Rlc3RzL3dhc20vQnVpbGRl ci5qcwppbmRleCBkYTU4NGM0Li4yNmJhNjZlIDEwMDY0NAotLS0gYS9KU1Rlc3RzL3dhc20vQnVp bGRlci5qcworKysgYi9KU1Rlc3RzL3dhc20vQnVpbGRlci5qcwpAQCAtMzgsNyArMzgsNyBAQCBj b25zdCBfaXNWYWxpZFZhbHVlID0gKHZhbHVlLCB0eXBlKSA9PiB7CiAgICAgc3dpdGNoICh0eXBl KSB7CiAgICAgLy8gV2UgYWxsb3cgYm90aCBzaWduZWQgYW5kIHVuc2lnbmVkIG51bWJlcnMuCiAg ICAgY2FzZSAiaTMyIjogcmV0dXJuIE1hdGgucm91bmQodmFsdWUpID09PSB2YWx1ZSAmJiBMTEIu dmFyaW50MzJNaW4gPD0gdmFsdWUgJiYgdmFsdWUgPD0gTExCLnZhcnVpbnQzMk1heDsKLSAgICBj YXNlICJpNjQiOiB0aHJvdyBuZXcgRXJyb3IoYFVuaW1wbGVtZW50ZWQ6IHZhbHVlIGNoZWNrIGZv ciAke3R5cGV9YCk7IC8vIEZJWE1FIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xNjM0MjAgNjQtYml0IHZhbHVlcworICAgIGNhc2UgImk2NCI6IHJldHVybiB0cnVlOyAv LyBGSVhNRSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNDIwIDY0 LWJpdCB2YWx1ZXMKICAgICBjYXNlICJmMzIiOiByZXR1cm4gdHlwZW9mKHZhbHVlKSA9PT0gIm51 bWJlciIgJiYgaXNGaW5pdGUodmFsdWUpOwogICAgIGNhc2UgImY2NCI6IHJldHVybiB0eXBlb2Yo dmFsdWUpID09PSAibnVtYmVyIiAmJiBpc0Zpbml0ZSh2YWx1ZSk7CiAgICAgZGVmYXVsdDogdGhy b3cgbmV3IEVycm9yKGBJbXBsZW1lbnRhdGlvbiBwcm9ibGVtOiB1bmtub3duIHR5cGUgJHt0eXBl fWApOwpAQCAtNTcsNiArNTcsMTYgQEAgY29uc3QgX25vcm1hbGl6ZUZ1bmN0aW9uU2lnbmF0dXJl ID0gKHBhcmFtcywgcmV0KSA9PiB7CiAgICAgcmV0dXJuIFtwYXJhbXMsIHJldF07CiB9OwogCitj b25zdCBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yID0gYnVpbGRlciA9PiBidWlsZGVyWyJfX2lzUHJv eHkiXSA/IGJ1aWxkZXIgOiBuZXcgUHJveHkoYnVpbGRlciwgeworICAgIGdldDogKHRhcmdldCwg cHJvcGVydHksIHJlY2VpdmVyKSA9PiB7CisgICAgICAgIGlmIChwcm9wZXJ0eSA9PT0gIl9faXNQ cm94eSIpCisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgaWYgKHRhcmdldFtwcm9w ZXJ0eV0gPT09IHVuZGVmaW5lZCkKKyAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcihgV2ViQXNz ZW1ibHkgYnVpbGRlciByZWNlaXZlZCB1bmtub3duIHByb3BlcnR5ICcke3Byb3BlcnR5fSdgKTsK KyAgICAgICAgcmV0dXJuIHRhcmdldFtwcm9wZXJ0eV07CisgICAgfQorfSk7CisKIGNvbnN0IF9t YXliZVJlZ2lzdGVyVHlwZSA9IChidWlsZGVyLCB0eXBlKSA9PiB7CiAgICAgY29uc3QgdHlwZVNl Y3Rpb24gPSBidWlsZGVyLl9nZXRTZWN0aW9uKCJUeXBlIik7CiAgICAgaWYgKHR5cGVvZih0eXBl KSA9PT0gIm51bWJlciIpIHsKQEAgLTEwMCw3ICsxMTAsNyBAQCBjb25zdCBfaW1wb3J0RnVuY3Rp b25Db250aW51YXRpb24gPSAoYnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1aWxkZXIpID0+IHsKICAg ICAgICAgc2VjdGlvbi5kYXRhLnB1c2goeyBmaWVsZDogZmllbGQsIHR5cGU6IHR5cGUsIGtpbmQ6 ICJGdW5jdGlvbiIsIG1vZHVsZTogbW9kdWxlIH0pOwogICAgICAgICAvLyBJbXBvcnRzIGFsc28g Y291bnQgaW4gdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlLiBNYXAgdGhlbSBhcyBvYmplY3RzIHRv IGF2b2lkIGNsYXNoaW5nIHdpdGggQ29kZSBmdW5jdGlvbnMnIG5hbWVzLgogICAgICAgICBidWls ZGVyLl9yZWdpc3RlckZ1bmN0aW9uVG9JbmRleFNwYWNlKHsgbW9kdWxlOiBtb2R1bGUsIGZpZWxk OiBmaWVsZCB9KTsKLSAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICByZXR1cm4g X2Vycm9ySGFuZGxpbmdQcm94eUZvcihuZXh0QnVpbGRlcik7CiAgICAgfTsKIH07CiAKQEAgLTEw OSw3ICsxMTksNyBAQCBjb25zdCBfaW1wb3J0TWVtb3J5Q29udGludWF0aW9uID0gKGJ1aWxkZXIs IHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAgIGFzc2VydC5pc1N0cmluZyhtb2R1 bGUsIGBJbXBvcnQgTWVtb3J5IG1vZHVsZSBzaG91bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHttb2R1 bGV9ImApOwogICAgICAgICBhc3NlcnQuaXNTdHJpbmcoZmllbGQsIGBJbXBvcnQgTWVtb3J5IGZp ZWxkIHNob3VsZCBiZSBhIHN0cmluZywgZ290ICIke2ZpZWxkfSJgKTsKICAgICAgICAgc2VjdGlv bi5kYXRhLnB1c2goe21vZHVsZSwgZmllbGQsIGtpbmQ6ICJNZW1vcnkiLCBtZW1vcnlEZXNjcmlw dGlvbjoge2luaXRpYWwsIG1heGltdW19fSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsK KyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAg IH07CiB9OwogCkBAIC0xMTgsNyArMTI4LDcgQEAgY29uc3QgX2ltcG9ydFRhYmxlQ29udGludWF0 aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAgIGFzc2Vy dC5pc1N0cmluZyhtb2R1bGUsIGBJbXBvcnQgVGFibGUgbW9kdWxlIHNob3VsZCBiZSBhIHN0cmlu ZywgZ290ICIke21vZHVsZX0iYCk7CiAgICAgICAgIGFzc2VydC5pc1N0cmluZyhmaWVsZCwgYElt cG9ydCBUYWJsZSBmaWVsZCBzaG91bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHtmaWVsZH0iYCk7CiAg ICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHttb2R1bGUsIGZpZWxkLCBraW5kOiAiVGFibGUiLCB0 YWJsZURlc2NyaXB0aW9uOiB7aW5pdGlhbCwgbWF4aW11bSwgZWxlbWVudH19KTsKLSAgICAgICAg cmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZv cihuZXh0QnVpbGRlcik7CiAgICAgfTsKIH07CiAKQEAgLTE3Miw3ICsxODIsNyBAQCBjb25zdCBf ZXhwb3J0RnVuY3Rpb25Db250aW51YXRpb24gPSAoYnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1aWxk ZXIpID0+IHsKICAgICAgICAgICAgICAgICBhc3NlcnQuZXEodHlwZSwgZXhwb3J0ZWRJbXBvcnQu dHlwZSwgYFJlLWV4cG9ydGluZyBpbXBvcnQgIiR7ZXhwb3J0ZWRJbXBvcnQuZmllbGR9IiBhcyAi JHtmaWVsZH0iIGhhcyBtaXNtYXRjaGluZyB0eXBlYCk7CiAgICAgICAgIH0KICAgICAgICAgc2Vj dGlvbi5kYXRhLnB1c2goeyBmaWVsZDogZmllbGQsIHR5cGU6IHR5cGUsIGtpbmQ6ICJGdW5jdGlv biIsIGluZGV4OiBpbmRleCB9KTsKLSAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAg ICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihuZXh0QnVpbGRlcik7CiAgICAgfTsKIH07 CiAKQEAgLTE4OSw3ICsxOTksNyBAQCBjb25zdCBfZXhwb3J0R2xvYmFsQ29udGludWF0aW9uID0g KGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgcmV0dXJuIChmaWVsZCwg aW5kZXgpID0+IHsKICAgICAgICAgYXNzZXJ0LmlzTnVtYmVyKGluZGV4LCBgR2xvYmFsIGV4cG9y dHMgb25seSBzdXBwb3J0IG51bWJlciBpbmRpY2VzIHJpZ2h0IG5vd2ApOwogICAgICAgICBzZWN0 aW9uLmRhdGEucHVzaCh7IGZpZWxkLCBraW5kOiAiR2xvYmFsIiwgaW5kZXggfSk7Ci0gICAgICAg IHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlG b3IobmV4dEJ1aWxkZXIpOwogICAgIH0KIH07CiAKQEAgLTE5Nyw3ICsyMDcsNyBAQCBjb25zdCBf ZXhwb3J0TWVtb3J5Q29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVy KSA9PiB7CiAgICAgcmV0dXJuIChmaWVsZCwgaW5kZXgpID0+IHsKICAgICAgICAgYXNzZXJ0Lmlz TnVtYmVyKGluZGV4LCBgTWVtb3J5IGV4cG9ydHMgb25seSBzdXBwb3J0IG51bWJlciBpbmRpY2Vz YCk7CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHtmaWVsZCwga2luZDogIk1lbW9yeSIsIGlu ZGV4fSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJv ckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH0KIH07CiAKQEAgLTIwNSw3ICsy MTUsNyBAQCBjb25zdCBfZXhwb3J0VGFibGVDb250aW51YXRpb24gPSAoYnVpbGRlciwgc2VjdGlv biwgbmV4dEJ1aWxkZXIpID0+IHsKICAgICByZXR1cm4gKGZpZWxkLCBpbmRleCkgPT4gewogICAg ICAgICBhc3NlcnQuaXNOdW1iZXIoaW5kZXgsIGBUYWJsZSBleHBvcnRzIG9ubHkgc3VwcG9ydCBu dW1iZXIgaW5kaWNlc2ApOwogICAgICAgICBzZWN0aW9uLmRhdGEucHVzaCh7ZmllbGQsIGtpbmQ6 ICJUYWJsZSIsIGluZGV4fSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAg cmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH0KIH07CiAK QEAgLTIyMCwxMCArMjMwLDEwIEBAIGNvbnN0IF9pbXBvcnRHbG9iYWxDb250aW51YXRpb24gPSAo YnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1aWxkZXIpID0+IHsKICAgICAgICAgICAgICAgICBhc3Nl cnQuaXNTdHJpbmcoZmllbGQsIGBJbXBvcnQgZ2xvYmFsIGZpZWxkIHNob3VsZCBiZSBhIHN0cmlu ZywgZ290ICIke2ZpZWxkfSJgKTsKICAgICAgICAgICAgICAgICBhc3NlcnQuaXNTdHJpbmcobXV0 YWJpbGl0eSwgYEltcG9ydCBnbG9iYWwgbXV0YWJpbGl0eSBzaG91bGQgYmUgYSBzdHJpbmcsIGdv dCAiJHttdXRhYmlsaXR5fSJgKTsKICAgICAgICAgICAgICAgICBzZWN0aW9uLmRhdGEucHVzaCh7 IGdsb2JhbERlc2NyaXB0aW9uOiB7IHR5cGU6IG9wLCBtdXRhYmlsaXR5OiBfbm9ybWFsaXplTXV0 YWJpbGl0eShtdXRhYmlsaXR5KSB9LCBtb2R1bGUsIGZpZWxkLCBraW5kOiAiR2xvYmFsIiB9KTsK LSAgICAgICAgICAgICAgICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsKKyAgICAgICAgICAgICAgICBy ZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICAgICAgICAg IH07CiAgICAgICAgIH0KLSAgICAgICAgcmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgIHJl dHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwogICAgIH07CiB9Owog CkBAIC0zMjQsMTEgKzMzNCwxMSBAQCBjb25zdCBfY3JlYXRlRnVuY3Rpb25CdWlsZGVyID0gKGZ1 bmMsIGJ1aWxkZXIsIHByZXZpb3VzQnVpbGRlcikgPT4gewogICAgICAgICAgICAgZGVmYXVsdDoK ICAgICAgICAgICAgICAgICBuZXh0QnVpbGRlciA9IGZ1bmN0aW9uQnVpbGRlcjsKICAgICAgICAg ICAgICAgICBicmVhazsKLSAgICAgICAgICAgICAgICBjYXNlICJFbmQiOgorICAgICAgICAgICAg Y2FzZSAiRW5kIjoKICAgICAgICAgICAgICAgICBuZXh0QnVpbGRlciA9IHByZXZpb3VzQnVpbGRl cjsKLSAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgYnJlYWs7CiAg ICAgICAgICAgICBjYXNlICJCbG9jayI6Ci0gICAgICAgICAgICAgICAgY2FzZSAiTG9vcCI6Cisg ICAgICAgICAgICBjYXNlICJMb29wIjoKICAgICAgICAgICAgIGNhc2UgIklmIjoKICAgICAgICAg ICAgICAgICBuZXh0QnVpbGRlciA9IF9jcmVhdGVGdW5jdGlvbkJ1aWxkZXIoZnVuYywgYnVpbGRl ciwgZnVuY3Rpb25CdWlsZGVyKTsKICAgICAgICAgICAgICAgICBicmVhazsKQEAgLTM0NCwxMSAr MzU0LDEyIEBAIGNvbnN0IF9jcmVhdGVGdW5jdGlvbkJ1aWxkZXIgPSAoZnVuYywgYnVpbGRlciwg cHJldmlvdXNCdWlsZGVyKSA9PiB7CiAgICAgICAgICAgICBjb25zdCBzdGFja0FyZ3MgPSBbXTsg Ly8gRklYTUUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MjcwNgog ICAgICAgICAgICAgZnVuYy5jb2RlLnB1c2goeyBuYW1lOiBvcCwgdmFsdWU6IHZhbHVlLCBhcmd1 bWVudHM6IHN0YWNrQXJncywgaW1tZWRpYXRlczogaW1tcyB9KTsKICAgICAgICAgICAgIGlmICho YXNDb250aW51YXRpb24pCi0gICAgICAgICAgICAgICAgcmV0dXJuIGNvbnRpbnVhdGlvbihuZXh0 QnVpbGRlcikuRW5kKCk7Ci0gICAgICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAg ICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoY29udGludWF0aW9uKG5leHRC dWlsZGVyKS5FbmQoKSk7CisgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZv cihuZXh0QnVpbGRlcik7CiAgICAgICAgIH07Ci0gICAgfQotICAgIHJldHVybiBmdW5jdGlvbkJ1 aWxkZXI7CisgICAgfTsKKworICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGZ1bmN0 aW9uQnVpbGRlcik7CiB9CiAKIGNvbnN0IF9jcmVhdGVGdW5jdGlvbiA9IChzZWN0aW9uLCBidWls ZGVyLCBwcmV2aW91c0J1aWxkZXIpID0+IHsKQEAgLTQ0OSwxMCArNDYwLDEwIEBAIGV4cG9ydCBk ZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRnVuYzogKHBh cmFtcywgcmV0KSA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW3BhcmFtcywgcmV0 XSA9IF9ub3JtYWxpemVGdW5jdGlvblNpZ25hdHVyZShwYXJhbXMsIHJldCk7CiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgcy5kYXRhLnB1c2goeyBwYXJhbXM6IHBhcmFtcywgcmV0OiByZXQg fSk7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHR5cGVCdWlsZGVyOworICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHR5 cGVCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH0sCiAgICAgICAgICAgICAgICAg ICAgIH07Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiB0eXBlQnVpbGRlcjsKKyAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IodHlwZUJ1aWxkZXIpOwog ICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTQ2Niw3ICs0 NzcsNyBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAg ICAgaW1wb3J0QnVpbGRlci5GdW5jdGlvbiA9IF9pbXBvcnRGdW5jdGlvbkNvbnRpbnVhdGlvbih0 aGlzLCBzLCBpbXBvcnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgaW1wb3J0QnVpbGRl ci5NZW1vcnkgPSBfaW1wb3J0TWVtb3J5Q29udGludWF0aW9uKHRoaXMsIHMsIGltcG9ydEJ1aWxk ZXIpOwogICAgICAgICAgICAgICAgICAgICBpbXBvcnRCdWlsZGVyLlRhYmxlID0gX2ltcG9ydFRh YmxlQ29udGludWF0aW9uKHRoaXMsIHMsIGltcG9ydEJ1aWxkZXIpOwotICAgICAgICAgICAgICAg ICAgICByZXR1cm4gaW1wb3J0QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9l cnJvckhhbmRsaW5nUHJveHlGb3IoaW1wb3J0QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsK ICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNDc3LDcgKzQ4OCw3IEBAIGV4cG9ydCBkZWZh dWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRW5kOiAoKSA9PiB0 aGlzCiAgICAgICAgICAgICAgICAgICAgICAgICAvLyBGSVhNRTogYWRkIGFiaWxpdHkgdG8gYWRk IHRoaXMgd2l0aCB3aGF0ZXZlci4KICAgICAgICAgICAgICAgICAgICAgfTsKLSAgICAgICAgICAg ICAgICAgICAgcmV0dXJuIGZ1bmN0aW9uQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0 dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZnVuY3Rpb25CdWlsZGVyKTsKICAgICAgICAgICAg ICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC00ODgsMTAgKzQ5OSwxMCBAQCBl eHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgIEVu ZDogKCkgPT4gdGhpcywKICAgICAgICAgICAgICAgICAgICAgICAgIFRhYmxlOiAoe2luaXRpYWws IG1heGltdW0sIGVsZW1lbnR9KSA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcy5k YXRhLnB1c2goe3RhYmxlRGVzY3JpcHRpb246IHtpbml0aWFsLCBtYXhpbXVtLCBlbGVtZW50fX0p OwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiB0YWJsZUJ1aWxkZXI7CisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IodGFi bGVCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAg ICAgfTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHRhYmxlQnVpbGRlcjsKKyAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IodGFibGVCdWlsZGVyKTsK ICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC01MDIsMTAg KzUxMywxMCBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAg ICAgICAgICAgIEVuZDogKCkgPT4gdGhpcywKICAgICAgICAgICAgICAgICAgICAgICAgIEluaXRp YWxNYXhQYWdlczogKGluaXRpYWwsIG1heCkgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHMuZGF0YS5wdXNoKHsgaW5pdGlhbCwgbWF4IH0pOwotICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHJldHVybiBtZW1vcnlCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAg IHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG1lbW9yeUJ1aWxkZXIpOwogICAgICAgICAg ICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAgICAgICAg ICAgICByZXR1cm4gbWVtb3J5QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9l cnJvckhhbmRsaW5nUHJveHlGb3IobWVtb3J5QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsK ICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNTE2LDE2ICs1MjcsMTYgQEAgZXhwb3J0IGRl ZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBFbmQ6ICgpID0+ IHRoaXMsCiAgICAgICAgICAgICAgICAgICAgICAgICBHZXRHbG9iYWw6ICh0eXBlLCBpbml0VmFs dWUsIG11dGFiaWxpdHkpID0+IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRhdGEu cHVzaCh7IHR5cGUsIG9wOiAiZ2V0X2dsb2JhbCIsIG11dGFiaWxpdHk6IF9ub3JtYWxpemVNdXRh YmlsaXR5KG11dGFiaWxpdHkpLCBpbml0VmFsdWUgfSk7Ci0gICAgICAgICAgICAgICAgICAgICAg ICAgICAgcmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAg cmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7CiAgICAgICAgICAg ICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAg ICAgIGZvciAobGV0IG9wIG9mIFdBU00uZGVzY3JpcHRpb24udmFsdWVfdHlwZSkgewogICAgICAg ICAgICAgICAgICAgICAgICAgZ2xvYmFsQnVpbGRlcltfdG9KYXZhU2NyaXB0TmFtZShvcCldID0g KGluaXRWYWx1ZSwgbXV0YWJpbGl0eSkgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAg IHMuZGF0YS5wdXNoKHsgdHlwZTogb3AsIG9wOiBvcCArICIuY29uc3QiLCBtdXRhYmlsaXR5OiBf bm9ybWFsaXplTXV0YWJpbGl0eShtdXRhYmlsaXR5KSwgaW5pdFZhbHVlIH0pOwotICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHJldHVybiBnbG9iYWxCdWlsZGVyOworICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIp OwogICAgICAgICAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICAgICAgfQotICAg ICAgICAgICAgICAgICAgICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAg ICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7CiAgICAgICAg ICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNTM5LDcgKzU1MCw3IEBA IGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICBleHBv cnRCdWlsZGVyLkZ1bmN0aW9uID0gX2V4cG9ydEZ1bmN0aW9uQ29udGludWF0aW9uKHRoaXMsIHMs IGV4cG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICBleHBvcnRCdWlsZGVyLk1lbW9y eSA9IF9leHBvcnRNZW1vcnlDb250aW51YXRpb24odGhpcywgcywgZXhwb3J0QnVpbGRlcik7CiAg ICAgICAgICAgICAgICAgICAgIGV4cG9ydEJ1aWxkZXIuVGFibGUgPSBfZXhwb3J0VGFibGVDb250 aW51YXRpb24odGhpcywgcywgZXhwb3J0QnVpbGRlcik7Ci0gICAgICAgICAgICAgICAgICAgIHJl dHVybiBleHBvcnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFu ZGxpbmdQcm94eUZvcihleHBvcnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAg ICAgICAgICAgIGJyZWFrOwogCkBAIC01NTIsNyArNTYzLDcgQEAgZXhwb3J0IGRlZmF1bHQgY2xh c3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgIGlmICh0eXBlb2YoZnVuY3Rpb25JbmRl eE9yTmFtZSkgIT09ICJudW1iZXIiICYmIHR5cGVvZihmdW5jdGlvbkluZGV4T3JOYW1lKSAhPT0g InN0cmluZyIpCiAgICAgICAgICAgICAgICAgICAgICAgICB0aHJvdyBuZXcgRXJyb3IoYFN0YXJ0 IHNlY3Rpb24ncyBmdW5jdGlvbiBpbmRleCAgbXVzdCBlaXRoZXIgYmUgYSBudW1iZXIgb3IgYSBz dHJpbmdgKTsKICAgICAgICAgICAgICAgICAgICAgcy5kYXRhLnB1c2goZnVuY3Rpb25JbmRleE9y TmFtZSk7Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiBzdGFydEJ1aWxkZXI7CisgICAgICAg ICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHN0YXJ0QnVpbGRlcik7 CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNTYzLDEx ICs1NzQsMTEgQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAg ICAgICAgICAgICBFbmQ6ICgpID0+IHRoaXMsCiAgICAgICAgICAgICAgICAgICAgICAgICBFbGVt ZW50OiAoe3RhYmxlSW5kZXggPSAwLCBvZmZzZXQsIGZ1bmN0aW9uSW5kaWNlc30pID0+IHsKICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaCh7dGFibGVJbmRleCwgb2Zmc2V0 LCBmdW5jdGlvbkluZGljZXN9KTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4g ZWxlbWVudEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJv ckhhbmRsaW5nUHJveHlGb3IoZWxlbWVudEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAg ICAgfQogICAgICAgICAgICAgICAgICAgICB9OwogCi0gICAgICAgICAgICAgICAgICAgIHJldHVy biBlbGVtZW50QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRs aW5nUHJveHlGb3IoZWxlbWVudEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAg ICAgICAgICAgYnJlYWs7CiAKQEAgLTYzMiwxMiArNjQzLDEyIEBAIGV4cG9ydCBkZWZhdWx0IGNs YXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gRklY TUUgaW4gY2hlY2tlZCBtb2RlLCB0ZXN0IHRoYXQgdGhlIHR5cGUgaXMgYWNjZXB0YWJsZSBmb3Ig c3RhcnQgZnVuY3Rpb24uIFdlIHByb2JhYmx5IHdhbnQgX3JlZ2lzdGVyRnVuY3Rpb25Ub0luZGV4 U3BhY2UgdG8gYWxzbyByZWdpc3RlciB0eXBlcyBwZXIgaW5kZXguIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjU2NTgKICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgfQogICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICByZXR1cm4gYnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihidWlsZGVyKTsKICAgICAgICAgICAgICAgICAg ICAgICAgIH0sCiAKICAgICAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICAgICAg Y29kZUJ1aWxkZXIuRnVuY3Rpb24gPSBfY3JlYXRlRnVuY3Rpb24ocywgYnVpbGRlciwgY29kZUJ1 aWxkZXIpOwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gY29kZUJ1aWxkZXI7CisgICAgICAg ICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGNvZGVCdWlsZGVyKTsK ICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC02NjAsMTkg KzY3MSwxOSBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgSW5kZXg6IGluZGV4ID0+IHsKICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGFzc2VydC5lcShpbmRleCwgMCk7IC8vIExpbmVhciBtZW1vcnkgaW5k ZXggbXVzdCBiZSB6ZXJvIGluIE1WUC4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHRoaXNTZWdtZW50LmluZGV4ID0gaW5kZXg7Ci0gICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICByZXR1cm4gc2VnbWVudEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihzZWdtZW50QnVpbGRl cik7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0sCiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIE9mZnNldDogb2Zmc2V0ID0+IHsKICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIC8vIEZJWE1FIGFsbG93IGNvbXBsZXggaW5pdF9leHByIGhlcmUuIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjU3MDAKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGFzc2VydC5pc051bWJlcihvZmZzZXQpOwogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGhpc1NlZ21lbnQub2Zmc2V0ID0gb2Zmc2V0 OwotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHNlZ21lbnRCdWls ZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhh bmRsaW5nUHJveHlGb3Ioc2VnbWVudEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAgICAgICAgICAg ICAgICAgICAgICAgICAgcmV0dXJuIHNlZ21lbnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHNlZ21lbnRCdWlsZGVyKTsK ICAgICAgICAgICAgICAgICAgICAgICAgIH0sCiAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAg ICAgICAgICAgICAgICAgIHJldHVybiBkYXRhQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAg cmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZGF0YUJ1aWxkZXIpOwogICAgICAgICAgICAg ICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTY5MCwxMCArNzAxLDEwIEBAIGV4 cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgIEJ5dGU6IGIgPT4g ewogICAgICAgICAgICAgICAgICAgICBhc3NlcnQuZXEoYiAmIDB4RkYsIGIsIGBVbmtub3duIHNl Y3Rpb24gZXhwZWN0ZWQgYnl0ZSwgZ290OiAiJHtifSJgKTsKICAgICAgICAgICAgICAgICAgICAg cy5kYXRhLnB1c2goYik7Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiB1bmtub3duQnVpbGRl cjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IodW5r bm93bkJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgIH07Ci0gICAgICAg ICAgICByZXR1cm4gdW5rbm93bkJ1aWxkZXI7CisgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFu ZGxpbmdQcm94eUZvcih1bmtub3duQnVpbGRlcik7CiAgICAgICAgIH07CiAgICAgfQogICAgIF9h ZGRTZWN0aW9uKG5hbWVPck51bWJlciwgZXh0cmFPYmplY3QpIHsKZGlmZiAtLWdpdCBhL0pTVGVz dHMvd2FzbS9Mb3dMZXZlbEJpbmFyeS5qcyBiL0pTVGVzdHMvd2FzbS9Mb3dMZXZlbEJpbmFyeS5q cwppbmRleCA2MTFhMjZkLi5mOWJjOGEzIDEwMDY0NAotLS0gYS9KU1Rlc3RzL3dhc20vTG93TGV2 ZWxCaW5hcnkuanMKKysrIGIvSlNUZXN0cy93YXNtL0xvd0xldmVsQmluYXJ5LmpzCkBAIC0xNzAs NiArMTcwLDE4IEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIExvd0xldmVsQmluYXJ5IHsKICAgICAg ICAgICAgIHRoaXMudWludDgoMHg4MCB8IGIpOwogICAgICAgICB9IHdoaWxlICh0cnVlKTsKICAg ICB9CisgICAgdmFydWludDY0KHYpIHsKKyAgICAgICAgYXNzZXJ0LmlzTnVtYmVyKHYpOworICAg ICAgICBpZiAodiA8IHZhcnVpbnQzMk1pbiB8fCB2YXJ1aW50MzJNYXggPCB2KQorICAgICAgICAg ICAgdGhyb3cgbmV3IFJhbmdlRXJyb3IoYHVuaW1wbGVtZW50ZWQ6IHZhcnVpbnQ2NCBsYXJnZXIg dGhhbiAzMi1iaXRgKTsKKyAgICAgICAgdGhpcy52YXJ1aW50MzIodik7IC8vIEZJWE1FIGltcGxl bWVudCA2NC1iaXQgdmFye3V9aW50IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xNjM0MjAKKyAgICB9CisgICAgdmFyaW50NjQodikgeworICAgICAgICBhc3NlcnQuaXNO dW1iZXIodik7CisgICAgICAgIGlmICh2IDwgdmFyaW50MzJNaW4gfHwgdmFyaW50MzJNYXggPCB2 KQorICAgICAgICAgICAgdGhyb3cgbmV3IFJhbmdlRXJyb3IoYHVuaW1wbGVtZW50ZWQ6IHZhcmlu dDY0IGxhcmdlciB0aGFuIDMyLWJpdGApOworICAgICAgICB0aGlzLnZhcmludDMyKHYpOyAvLyBG SVhNRSBpbXBsZW1lbnQgNjQtYml0IHZhcnt1fWludCBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTYzNDIwCisgICAgfQogICAgIHZhcnVpbnQxKHYpIHsKICAgICAgICAg aWYgKHYgIT09IDAgJiYgdiAhPT0gMSkKICAgICAgICAgICAgIHRocm93IG5ldyBSYW5nZUVycm9y KGBJbnZhbGlkIHZhcnVpbnQxICR7dn0gcmFuZ2UgaXMgWzAsIDFdYCk7CmRpZmYgLS1naXQgYS9K U1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvZXhjZXB0aW9ucy5qcyBiL0pTVGVzdHMvd2FzbS9m dW5jdGlvbi10ZXN0cy9leGNlcHRpb25zLmpzCmluZGV4IGQyYjNhNDkuLjk1MjUxM2YgMTAwNjQ0 Ci0tLSBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy9leGNlcHRpb25zLmpzCisrKyBiL0pT VGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy9leGNlcHRpb25zLmpzCkBAIC00NSwxOCArNDUsMTgg QEAgZnVuY3Rpb24gbWFrZUluc3RhbmNlKCkgewogICAgIGFzc2VydC5lcSh0YWJsZS5nZXQoMCks IG51bGwpOwogCiAgICAgZm9yIChsZXQgaSA9IDA7IGkgPCAxMDAwOyBpKyspIHsKLSAgICAgICAg YXNzZXJ0LnRocm93cygoKSA9PiBmb28oMCwgaSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwg ImNhbGxfaW5kaXJlY3QgdG8gYSBudWxsIHRhYmxlIGVudHJ5IChldmFsdWF0aW5nICdmdW5jKC4u LmFyZ3MpJykiKTsKKyAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBmb28oMCwgaSksIFdlYkFz c2VtYmx5LlJ1bnRpbWVFcnJvciwgImNhbGxfaW5kaXJlY3QgdG8gYSBudWxsIHRhYmxlIGVudHJ5 Iik7CiAgICAgfQogCiAgICAgdGFibGUuc2V0KDAsIGZvbyk7CiAgICAgYXNzZXJ0LmVxKHRhYmxl LmdldCgwKSwgZm9vKTsKIAogICAgIGZvciAobGV0IGkgPSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0g ICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDEgKyBpLCBpKSwgV2ViQXNzZW1ibHkuUnVu dGltZUVycm9yLCAiT3V0IG9mIGJvdW5kcyBjYWxsX2luZGlyZWN0IChldmFsdWF0aW5nICdmdW5j KC4uLmFyZ3MpJykiKTsKKyAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBmb28oMSArIGksIGkp LCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJPdXQgb2YgYm91bmRzIGNhbGxfaW5kaXJlY3Qi KTsKICAgICB9CiAKICAgICBmb3IgKGxldCBpID0gMDsgaSA8IDEwMDA7IGkrKykgewotICAgICAg ICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbygwLCBpKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9y LCAiY2FsbF9pbmRpcmVjdCB0byBhIHNpZ25hdHVyZSB0aGF0IGRvZXMgbm90IG1hdGNoIChldmFs dWF0aW5nICdmdW5jKC4uLmFyZ3MpJykiKTsKKyAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBm b28oMCwgaSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgImNhbGxfaW5kaXJlY3QgdG8gYSBz aWduYXR1cmUgdGhhdCBkb2VzIG5vdCBtYXRjaCIpOwogICAgIH0KIAogICAgIHRhYmxlLnNldCgw LCBiYXIpOwpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtbG9h ZC5qcyBiL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMKaW5kZXggNGRk ODJkYy4uMTIzMWUwMyAxMDA2NDQKLS0tIGEvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3Ry YXAtbG9hZC5qcworKysgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpz CkBAIC0yOSw2ICsyOSw2IEBAIGZ1bmN0aW9uIHdhc21GcmFtZUNvdW50RnJvbUVycm9yKGUpIHsK IH0KIAogZm9yIChsZXQgaSA9IDA7IGkgPCAxMDAwOyBpKyspIHsKLSAgICBjb25zdCBlID0gYXNz ZXJ0LnRocm93cygoKSA9PiBmb28obnVtUGFnZXMgKiBwYWdlU2l6ZSArIDEpLCBXZWJBc3NlbWJs eS5SdW50aW1lRXJyb3IsICJPdXQgb2YgYm91bmRzIG1lbW9yeSBhY2Nlc3MgKGV2YWx1YXRpbmcg J2Z1bmMoLi4uYXJncyknKSIpOworICAgIGNvbnN0IGUgPSBhc3NlcnQudGhyb3dzKCgpID0+IGZv byhudW1QYWdlcyAqIHBhZ2VTaXplICsgMSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgIk91 dCBvZiBib3VuZHMgbWVtb3J5IGFjY2VzcyIpOwogICAgIGFzc2VydC5lcSh3YXNtRnJhbWVDb3Vu dEZyb21FcnJvcihlKSwgMik7CiB9CmRpZmYgLS1naXQgYS9KU1Rlc3RzL3dhc20vZnVuY3Rpb24t dGVzdHMvdHJhcC1zdG9yZS5qcyBiL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLXN0 b3JlLmpzCmluZGV4IDU1OTg3YzIuLjM2NTcxM2EgMTAwNjQ0Ci0tLSBhL0pTVGVzdHMvd2FzbS9m dW5jdGlvbi10ZXN0cy90cmFwLXN0b3JlLmpzCisrKyBiL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10 ZXN0cy90cmFwLXN0b3JlLmpzCkBAIC0yNSw1ICsyNSw1IEBAIGNvbnN0IG51bVBhZ2VzID0gMTA7 CiAgICAgY29uc3QgZm9vID0gbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKG1vZHVsZSwge2E6IHti OiBuZXcgV2ViQXNzZW1ibHkuTWVtb3J5KHtpbml0aWFsOiBudW1QYWdlc30pfX0pLmV4cG9ydHMu Zm9vOwogCiAgICAgZm9yIChsZXQgaSA9IDA7IGkgPCAxMDAwMDsgaSsrKQotICAgICAgICBhc3Nl cnQudGhyb3dzKCgpID0+IGZvbyhpLCBudW1QYWdlcyAqIHBhZ2VTaXplICsgMSksIFdlYkFzc2Vt Ymx5LlJ1bnRpbWVFcnJvciwgIk91dCBvZiBib3VuZHMgbWVtb3J5IGFjY2VzcyAoZXZhbHVhdGlu ZyAnZnVuYyguLi5hcmdzKScpIik7CisgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKGks IG51bVBhZ2VzICogcGFnZVNpemUgKyAxKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9yLCAiT3V0 IG9mIGJvdW5kcyBtZW1vcnkgYWNjZXNzIik7CiB9CmRpZmYgLS1naXQgYS9KU1Rlc3RzL3dhc20v anMtYXBpL3dhc20tdG8td2FzbS1iYWQtc2lnbmF0dXJlLmpzIGIvSlNUZXN0cy93YXNtL2pzLWFw aS93YXNtLXRvLXdhc20tYmFkLXNpZ25hdHVyZS5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwLi5kNjliYTJjCi0tLSAvZGV2L251bGwKKysrIGIvSlNUZXN0cy93YXNtL2pzLWFw aS93YXNtLXRvLXdhc20tYmFkLXNpZ25hdHVyZS5qcwpAQCAtMCwwICsxLDEwNSBAQAoraW1wb3J0 ICogYXMgYXNzZXJ0IGZyb20gJy4uL2Fzc2VydC5qcyc7CitpbXBvcnQgQnVpbGRlciBmcm9tICcu Li9CdWlsZGVyLmpzJzsKKworY29uc3QgaW1wb3J0TmFtZSA9ICJwaWVyT25lIjsKK2NvbnN0IHR5 cGVzID0gWyJpMzIiLCAiaTY0IiwgImYzMiIsICJmNjQiLCAidm9pZCJdOworY29uc3QgdHlwZXNO b25Wb2lkID0gWyJpMzIiLCAiaTY0IiwgImYzMiIsICJmNjQiXTsKK2NvbnN0IHN3YXBUeXBlID0g KHR5cGUsIGluZGV4KSA9PiB0eXBlc1sodHlwZXMuaW5kZXhPZih0eXBlKSArIGluZGV4KSAlIHR5 cGVzLmxlbmd0aF07Citjb25zdCBzd2FwVHlwZU5vblZvaWQgPSAodHlwZSwgaW5kZXgpID0+IHR5 cGVzTm9uVm9pZFsodHlwZXNOb25Wb2lkLmluZGV4T2YodHlwZSkgKyBpbmRleCkgJSB0eXBlc05v blZvaWQubGVuZ3RoXTsKKworY29uc3Qgc2lnbmF0dXJlcyA9IFsKKyAgICB7IHBhcmFtczogWyJp MzIiXSwgcmV0OiAidm9pZCIgfSwKKyAgICB7IHBhcmFtczogWyJpNjQiXSwgcmV0OiAidm9pZCIg fSwKKyAgICB7IHBhcmFtczogWyJmMzIiXSwgcmV0OiAidm9pZCIgfSwKKyAgICB7IHBhcmFtczog WyJmNjQiXSwgcmV0OiAidm9pZCIgfSwKKyAgICB7IHBhcmFtczogWyJpMzIiXSwgcmV0OiAiaTMy IiB9LAorICAgIHsgcGFyYW1zOiBbImk2NCJdLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6 IFsiZjMyIl0sIHJldDogImYzMiIgfSwKKyAgICB7IHBhcmFtczogWyJmNjQiXSwgcmV0OiAiZjY0 IiB9LAorICAgIHsgcGFyYW1zOiBbImkzMiIsICJmMzIiXSwgcmV0OiAiaTMyIiB9LAorICAgIHsg cGFyYW1zOiBbImYzMiIsICJpMzIiXSwgcmV0OiAiaTMyIiB9LAorICAgIHsgcGFyYW1zOiBbImk2 NCIsICJmNjQiXSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBbImY2NCIsICJpNjQiXSwg cmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBbImkzMiIsICJmMzIiLCAiaTMyIl0sIHJldDog ImkzMiIgfSwKKyAgICB7IHBhcmFtczogWyJpMzIiLCAiZjMyIiwgImkzMiJdLCByZXQ6ICJpMzIi IH0sCisgICAgeyBwYXJhbXM6IFsiaTY0IiwgImY2NCIsICJpNjQiXSwgcmV0OiAiaTY0IiB9LAor ICAgIHsgcGFyYW1zOiBbImk2NCIsICJmNjQiLCAiaTY0Il0sIHJldDogImk2NCIgfSwKKyAgICB7 IHBhcmFtczogQXJyYXkoMzIpLmZpbGwoImkzMiIpLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJh bXM6IEFycmF5KDMyKS5maWxsKCJpNjQiKSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBB cnJheSgzMikuZmlsbCgiZjMyIiksIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogQXJyYXko MzIpLmZpbGwoImY2NCIpLCByZXQ6ICJpNjQiIH0sCitdOworCitjb25zdCBtYWtlSW1wb3J0ZXIg PSBzaWduYXR1cmUgPT4geworICAgIGNvbnN0IGJ1aWxkZXIgPSAobmV3IEJ1aWxkZXIoKSkKKyAg ICAgICAgLlR5cGUoKS5FbmQoKQorICAgICAgICAuSW1wb3J0KCkuRnVuY3Rpb24oImV4cG9ydHMi LCBpbXBvcnROYW1lLCBzaWduYXR1cmUpLkVuZCgpOworICAgIHJldHVybiBuZXcgV2ViQXNzZW1i bHkuTW9kdWxlKGJ1aWxkZXIuV2ViQXNzZW1ibHkoKS5nZXQoKSk7Cit9OworCitjb25zdCBtYWtl SW1wb3J0ZWUgPSBzaWduYXR1cmUgPT4geworICAgIGNvbnN0IGJ1aWxkZXIgPSAobmV3IEJ1aWxk ZXIoKSkKKyAgICAgICAgLlR5cGUoKS5FbmQoKQorICAgICAgICAuRnVuY3Rpb24oKS5FbmQoKQor ICAgICAgICAuRXhwb3J0KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbihpbXBvcnROYW1lKQorICAg ICAgICAuRW5kKCkKKyAgICAgICAgLkNvZGUoKQorICAgICAgICAgICAgLkZ1bmN0aW9uKGltcG9y dE5hbWUsIHNpZ25hdHVyZSk7CisgICAgc3dpdGNoIChzaWduYXR1cmUucmV0KSB7CisgICAgY2Fz ZSAiaTMyIjogYnVpbGRlci5JMzJDb25zdCgwKTsgYnJlYWs7CisgICAgY2FzZSAiaTY0IjogYnVp bGRlci5JNjRDb25zdCgwKTsgYnJlYWs7CisgICAgY2FzZSAiZjMyIjogYnVpbGRlci5GMzJDb25z dCgwKTsgYnJlYWs7CisgICAgY2FzZSAiZjY0IjogYnVpbGRlci5GNjRDb25zdCgwKTsgYnJlYWs7 CisgICAgY2FzZSAidm9pZCI6IGJyZWFrOworICAgIH0KKyAgICByZXR1cm4gbmV3IFdlYkFzc2Vt Ymx5Lkluc3RhbmNlKG5ldyBXZWJBc3NlbWJseS5Nb2R1bGUoYnVpbGRlci5SZXR1cm4oKS5FbmQo KS5FbmQoKS5XZWJBc3NlbWJseSgpLmdldCgpKSk7Cit9OworCisoZnVuY3Rpb24gQmFkU2lnbmF0 dXJlRHJvcFN0YXJ0UGFyYW1zKCkgeworICAgIGZvciAobGV0IHNpZ25hdHVyZSBvZiBzaWduYXR1 cmVzKSB7CisgICAgICAgIGNvbnN0IGltcG9ydGVlID0gbWFrZUltcG9ydGVlKHNpZ25hdHVyZSk7 CisgICAgICAgIGZvciAobGV0IGkgPSAxOyBpIDw9IHNpZ25hdHVyZS5wYXJhbXMubGVuZ3RoOyAr K2kpIHsKKyAgICAgICAgICAgIGNvbnN0IGJhZFBhcmFtU2lnbmF0dXJlID0geyBwYXJhbXM6IHNp Z25hdHVyZS5wYXJhbXMuc2xpY2UoaSwgc2lnbmF0dXJlLnBhcmFtcy5sZW5ndGgpLCByZXQ6IHNp Z25hdHVyZS5yZXQgfTsKKyAgICAgICAgICAgIGNvbnN0IGltcG9ydGVyID0gbWFrZUltcG9ydGVy KGJhZFBhcmFtU2lnbmF0dXJlKTsKKyAgICAgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gbmV3 IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSksIFdlYkFzc2VtYmx5Lkxp bmtFcnJvciwgYGltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIGRvZXNuJ3QgbWF0Y2ggdGhl IHByb3ZpZGVkIFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIChldmFsdWF0aW5nICdu ZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKScpYCk7CisgICAgICAg IH0KKyAgICB9Cit9KSgpOworCisoZnVuY3Rpb24gQmFkU2lnbmF0dXJlRHJvcEVuZFBhcmFtcygp IHsKKyAgICBmb3IgKGxldCBzaWduYXR1cmUgb2Ygc2lnbmF0dXJlcykgeworICAgICAgICBjb25z dCBpbXBvcnRlZSA9IG1ha2VJbXBvcnRlZShzaWduYXR1cmUpOworICAgICAgICBmb3IgKGxldCBp ID0gMTsgaSA8IHNpZ25hdHVyZS5wYXJhbXMubGVuZ3RoOyArK2kpIHsKKyAgICAgICAgICAgIGNv bnN0IGJhZFBhcmFtU2lnbmF0dXJlID0geyBwYXJhbXM6IHNpZ25hdHVyZS5wYXJhbXMuc2xpY2Uo MCwgaSksIHJldDogc2lnbmF0dXJlLnJldCB9OworICAgICAgICAgICAgY29uc3QgaW1wb3J0ZXIg PSBtYWtlSW1wb3J0ZXIoYmFkUGFyYW1TaWduYXR1cmUpOworICAgICAgICAgICAgYXNzZXJ0LnRo cm93cygoKSA9PiBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKSwg V2ViQXNzZW1ibHkuTGlua0Vycm9yLCBgaW1wb3J0ZWQgZnVuY3Rpb24ncyBzaWduYXR1cmUgZG9l c24ndCBtYXRjaCB0aGUgcHJvdmlkZWQgV2ViQXNzZW1ibHkgZnVuY3Rpb24ncyBzaWduYXR1cmUg KGV2YWx1YXRpbmcgJ25ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUp JylgKTsKKyAgICAgICAgfQorICAgIH0KK30pKCk7CisKKyhmdW5jdGlvbiBCYWRTaWduYXR1cmVT d2FwUGFyYW0oKSB7CisgICAgZm9yIChsZXQgc2lnbmF0dXJlIG9mIHNpZ25hdHVyZXMpIHsKKyAg ICAgICAgY29uc3QgaW1wb3J0ZWUgPSBtYWtlSW1wb3J0ZWUoc2lnbmF0dXJlKTsKKyAgICAgICAg Zm9yIChsZXQgc2lnbmF0dXJlSW5kZXggPSAwOyBzaWduYXR1cmVJbmRleCA8IHNpZ25hdHVyZS5s ZW5ndGg7ICsrc2lnbmF0dXJlSW5kZXgpIHsKKyAgICAgICAgICAgIGZvciAobGV0IHR5cGVJbmRl eCA9IDE7IHR5cGVJbmRleCA8IHR5cGVzTm9uVm9pZC5sZW5ndGg7ICsrdHlwZUluZGV4KSB7Cisg ICAgICAgICAgICAgICAgbGV0IGJhZFBhcmFtcyA9IHNpZ25hdHVyZS5wYXJhbXMuc2xpY2UoKTsK KyAgICAgICAgICAgICAgICBiYWRQYXJhbXNbc2lnbmF0dXJlSW5kZXhdID0gc3dhcFR5cGVOb25W b2lkKGJhZFBhcmFtc1tzaWduYXR1cmVJbmRleF0sIHR5cGVJbmRleCk7CisgICAgICAgICAgICAg ICAgY29uc3QgYmFkUGFyYW1TaWduYXR1cmUgPSB7IHBhcmFtczogYmFkUGFyYW1zLCByZXQ6IHNp Z25hdHVyZS5yZXQgfTsKKyAgICAgICAgICAgICAgICBjb25zdCBpbXBvcnRlciA9IG1ha2VJbXBv cnRlcihiYWRQYXJhbVNpZ25hdHVyZSk7CisgICAgICAgICAgICAgICAgYXNzZXJ0LnRocm93cygo KSA9PiBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKSwgV2ViQXNz ZW1ibHkuTGlua0Vycm9yLCBgaW1wb3J0ZWQgZnVuY3Rpb24ncyBzaWduYXR1cmUgZG9lc24ndCBt YXRjaCB0aGUgcHJvdmlkZWQgV2ViQXNzZW1ibHkgZnVuY3Rpb24ncyBzaWduYXR1cmUgKGV2YWx1 YXRpbmcgJ25ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpJylgKTsK KyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0KK30pKCk7CisKKyhmdW5jdGlvbiBCYWRT aWduYXR1cmVSZXQoKSB7CisgICAgZm9yIChsZXQgc2lnbmF0dXJlIG9mIHNpZ25hdHVyZXMpIHsK KyAgICAgICAgY29uc3QgaW1wb3J0ZWUgPSBtYWtlSW1wb3J0ZWUoc2lnbmF0dXJlKTsKKyAgICAg ICAgZm9yIChsZXQgdHlwZUluZGV4ID0gMTsgdHlwZUluZGV4IDwgdHlwZXMubGVuZ3RoOyArK3R5 cGVJbmRleCkgeworICAgICAgICAgICAgY29uc3QgYmFkUGFyYW1TaWduYXR1cmUgPSB7IHBhcmFt czogc2lnbmF0dXJlLnBhcmFtcywgcmV0OiBzd2FwVHlwZShzaWduYXR1cmUucmV0LCB0eXBlSW5k ZXgpIH07CisgICAgICAgICAgICBjb25zdCBpbXBvcnRlciA9IG1ha2VJbXBvcnRlcihiYWRQYXJh bVNpZ25hdHVyZSk7CisgICAgICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IG5ldyBXZWJBc3Nl bWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpLCBXZWJBc3NlbWJseS5MaW5rRXJyb3Is IGBpbXBvcnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBkb2Vzbid0IG1hdGNoIHRoZSBwcm92aWRl ZCBXZWJBc3NlbWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSAoZXZhbHVhdGluZyAnbmV3IFdlYkFz c2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSknKWApOworICAgICAgICB9CisgICAg fQorfSkoKTsKZGlmZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLmpz IGIvSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMC4uNGM4NGRkOAotLS0gL2Rldi9udWxsCisrKyBiL0pTVGVzdHMvd2Fz bS9qcy1hcGkvd2FzbS10by13YXNtLmpzCkBAIC0wLDAgKzEsNzIgQEAKK2ltcG9ydCAqIGFzIGFz c2VydCBmcm9tICcuLi9hc3NlcnQuanMnOworaW1wb3J0IEJ1aWxkZXIgZnJvbSAnLi4vQnVpbGRl ci5qcyc7CisKK2NvbnN0IGNhbGxlclRvcEJpdHMgPSAweEMwRkVCRUVGOworY29uc3QgaW5uZXJS ZXR1cm5IaSA9IDB4REVBREZBQ0U7Citjb25zdCBpbm5lclJldHVybkxvID0gMHhDMEZFQzBGRTsK KworY29uc3QgY2FsbGVyTW9kdWxlID0gKCkgPT4geworICAgIGNvbnN0IGJ1aWxkZXIgPSAobmV3 IEJ1aWxkZXIoKSkKKyAgICAgICAgLlR5cGUoKS5FbmQoKQorICAgICAgICAuSW1wb3J0KCkKKyAg ICAgICAgICAgIC5GdW5jdGlvbigiZXhwb3J0cyIsICJjYWxsTWUiLCB7IHBhcmFtczogWyJpNjQi XSwgcmV0OiAiaTY0IiB9KQorICAgICAgICAuRW5kKCkKKyAgICAgICAgLkZ1bmN0aW9uKCkuRW5k KCkKKyAgICAgICAgLkV4cG9ydCgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImVudHJ5IikKKyAg ICAgICAgLkVuZCgpCisgICAgICAgIC5Db2RlKCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigiZW50 cnkiLCB7IHBhcmFtczogWyJpMzIiXSwgcmV0OiAiaTMyIiB9LCBbImk2NCJdKQorICAgICAgICAg ICAgICAgIC5JMzJDb25zdChjYWxsZXJUb3BCaXRzKS5JNjRFeHRlbmRVSTMyKCkuSTMyQ29uc3Qo MzIpLkk2NEV4dGVuZFVJMzIoKS5JNjRTaGwoKSAvLyAoKGk2NCljYWxsZXJUb3BCaXRzKSA8PCAz MgorICAgICAgICAgICAgICAgIC5HZXRMb2NhbCgwKS5JNjRFeHRlbmRVSTMyKCkKKyAgICAgICAg ICAgICAgICAuSTY0T3IoKSAvLyB2YWx1ZTogcGFyYW0gfCAoKChpNjQpY2FsbGVyVG9wQml0cyA8 PCAzMikpCisgICAgICAgICAgICAgICAgLkNhbGwoMCkgLy8gQ2FsbHMgZXhwb3J0cy5jYWxsTWUo cGFyYW0gfCAoKChpNjQpY2FsbGVyVG9wQml0cykgPDwgMzIpKS4KKyAgICAgICAgICAgICAgICAu VGVlTG9jYWwoMSkuSTMyV3JhcEk2NCgpIC8vIGxvOiAoaTMyKWNhbGxSZXN1bHQKKyAgICAgICAg ICAgICAgICAuR2V0TG9jYWwoMSkuSTMyQ29uc3QoMzIpLkk2NEV4dGVuZFVJMzIoKS5JNjRTaHJV KCkuSTMyV3JhcEk2NCgpIC8vIGhpOiAoaTMyKShjYWxsUmVzdWx0ID4+IDMyKQorICAgICAgICAg ICAgICAgIC5JMzJYb3IoKQorICAgICAgICAgICAgICAgIC5SZXR1cm4oKQorICAgICAgICAgICAg LkVuZCgpCisgICAgICAgIC5FbmQoKTsKKyAgICByZXR1cm4gbmV3IFdlYkFzc2VtYmx5Lk1vZHVs ZShidWlsZGVyLldlYkFzc2VtYmx5KCkuZ2V0KCkpOworfTsKKworY29uc3QgY2FsbGVlTW9kdWxl ID0gKCkgPT4geworICAgIGNvbnN0IGJ1aWxkZXIgPSAobmV3IEJ1aWxkZXIoKSkKKyAgICAgICAg LlR5cGUoKS5FbmQoKQorICAgICAgICAuSW1wb3J0KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigi aW1wIiwgImZ1bmMiLCB7IHBhcmFtczogWyJpMzIiLCAiaTMyIl0sIHJldDogImkzMiIgfSkKKyAg ICAgICAgLkVuZCgpCisgICAgICAgIC5GdW5jdGlvbigpLkVuZCgpCisgICAgICAgIC5FeHBvcnQo KQorICAgICAgICAgICAgLkZ1bmN0aW9uKCJjYWxsTWUiKQorICAgICAgICAuRW5kKCkKKyAgICAg ICAgLkNvZGUoKQorICAgICAgICAgICAgLkZ1bmN0aW9uKCJjYWxsTWUiLCB7IHBhcmFtczogWyJp NjQiXSwgcmV0OiAiaTY0IiB9KQorICAgICAgICAgICAgICAgIC5HZXRMb2NhbCgwKS5JMzJXcmFw STY0KCkgLy8gbG86IChpMzIpcGFyYW0KKyAgICAgICAgICAgICAgICAuR2V0TG9jYWwoMCkuSTMy Q29uc3QoMzIpLkk2NEV4dGVuZFVJMzIoKS5JNjRTaHJVKCkuSTMyV3JhcEk2NCgpIC8vIGhpOiAo aTMyKShwYXJhbSA+PiAzMikKKyAgICAgICAgICAgICAgICAuQ2FsbCgwKSAvLyBDYWxscyBpbXAu ZnVuYyB3aXRoIHRoZSA2NC1iaXQgdmFsdWUgYXMgaTMyIHsgaGksIGxvIH0uCisgICAgICAgICAg ICAgICAgLkRyb3AoKQorICAgICAgICAgICAgICAgIC5JMzJDb25zdChpbm5lclJldHVybkhpKS5J NjRFeHRlbmRVSTMyKCkuSTMyQ29uc3QoMzIpLkk2NEV4dGVuZFVJMzIoKS5JNjRTaGwoKS5JMzJD b25zdChpbm5lclJldHVybkxvKS5JNjRFeHRlbmRVSTMyKCkuSTY0T3IoKSAvLyAoKGk2NCloaSA8 PCAzMikgfCAoaTY0KWxvCisgICAgICAgICAgICAgICAgLlJldHVybigpCisgICAgICAgICAgICAu RW5kKCkKKyAgICAgICAgLkVuZCgpOworICAgIHJldHVybiBuZXcgV2ViQXNzZW1ibHkuTW9kdWxl KGJ1aWxkZXIuV2ViQXNzZW1ibHkoKS5nZXQoKSk7Cit9OworCisoZnVuY3Rpb24gV2FzbVRvV2Fz bSgpIHsKKyAgICBsZXQgdmFsdWU7CisgICAgY29uc3QgZnVuYyA9IChoaSwgbG8pID0+IHsgdmFs dWUgPSB7IGhpOiBoaSwgbG86IGxvIH07IHJldHVybiBoaSBeIGxvOyB9OworICAgIGNvbnN0IGNh bGxlZSA9IG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShjYWxsZWVNb2R1bGUoKSwgeyBpbXA6IHsg ZnVuYzogZnVuYyB9IH0pOworICAgIGNvbnN0IGNhbGxlciA9IG5ldyBXZWJBc3NlbWJseS5JbnN0 YW5jZShjYWxsZXJNb2R1bGUoKSwgY2FsbGVlKTsKKyAgICBmb3IgKGxldCBpID0gMDsgaSA8IDQw OTY7ICsraSkgeworICAgICAgICBhc3NlcnQuZXEoY2FsbGVyLmV4cG9ydHMuZW50cnkoaSksIGlu bmVyUmV0dXJuSGkgXiBpbm5lclJldHVybkxvKTsKKyAgICAgICAgYXNzZXJ0LmVxKHZhbHVlLmxv ID4+PiAwLCBjYWxsZXJUb3BCaXRzKTsKKyAgICAgICAgYXNzZXJ0LmVxKHZhbHVlLmhpID4+PiAw LCBpKTsKKyAgICB9Cit9KSgpOworCisKKy8vIEZJWE1FOiB0ZXN0IHdhc20tPndhc20gdXNpbmcg MzItYml0IHRoaW5ncyAoaW5jbHVkaW5nIGZsb2F0KSwgYXMgd2VsbCBhcyA2NC1iaXQgTmFOcyB0 aGF0IGRvbid0IGdldCBjYW5vbmljYWxpemVkCisvLyBGSVhNRTogZG8gYSB0aHJvdyB0d28tZGVl cAorLy8gRklYTUU6IGNoZWNrIHRoYXQgdGhlIGZpcnN0IHdhc20ncyBpbnN0YW5jZSBpcyBiYWNr IGluIE9LIHN0YXRlICh3aXRoIHRhYmxlIG9yIGdsb2JhbD8pCisvLyBGSVhNRTogdGVzdCBjYWxs aW5nIHRocm91Z2ggYSBUYWJsZQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NN YWtlTGlzdHMudHh0IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NNYWtlTGlzdHMudHh0CmluZGV4 IDk2OWExMjMuLjlkZTFhM2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DTWFr ZUxpc3RzLnR4dAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ01ha2VMaXN0cy50eHQKQEAg LTkwNSw2ICs5MDUsNyBAQCBzZXQoSmF2YVNjcmlwdENvcmVfU09VUkNFUwogICAgIHdhc20vV2Fz bU1lbW9yeS5jcHAKICAgICB3YXNtL1dhc21NZW1vcnlJbmZvcm1hdGlvbi5jcHAKICAgICB3YXNt L1dhc21Nb2R1bGVQYXJzZXIuY3BwCisgICAgd2FzbS9XYXNtUGFnZUNvdW50LmNwcAogICAgIHdh c20vV2FzbVBsYW4uY3BwCiAgICAgd2FzbS9XYXNtU2lnbmF0dXJlLmNwcAogICAgIHdhc20vV2Fz bVZhbGlkYXRlLmNwcApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0phdmFTY3Jp cHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv SmF2YVNjcmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCBkOTMyNTZiLi4x MTYzNjllIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvSmF2 YVNjcmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMTIzNSw2ICsxMjM1LDcg QEAKIAkJMkFERkEyNjMxOEVGMzU0MDAwNEY5RkNDIC8qIEdDTG9nZ2luZy5jcHAgaW4gU291cmNl cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAyQURGQTI2MjE4RUYzNTQwMDA0 RjlGQ0MgLyogR0NMb2dnaW5nLmNwcCAqLzsgfTsKIAkJMkFGNzM4MkMxOEJCQkY5MjAwOEE1QTM3 IC8qIFN0cnVjdHVyZUlEVGFibGUuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gMkFGNzM4MkExOEJCQkY5MjAwOEE1QTM3IC8qIFN0cnVjdHVyZUlEVGFi bGUuY3BwICovOyB9OwogCQkyQUY3MzgyRDE4QkJCRjkyMDA4QTVBMzcgLyogU3RydWN0dXJlSURU YWJsZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMkFG NzM4MkIxOEJCQkY5MjAwOEE1QTM3IC8qIFN0cnVjdHVyZUlEVGFibGUuaCAqLzsgc2V0dGluZ3Mg PSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQkyRDM0MkYzNkY3MjQ0MDk2ODA0 QURCMjQgLyogU291cmNlT3JpZ2luLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA0MjVCQTEzMzdFNDM0NEUxQjI2OUE2NzEgLyogU291cmNlT3JpZ2luLmgg Ki87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJMzcxRDg0 MkQxN0M5OEI2RTAwRUNGOTk0IC8qIGxpYnouZHlsaWIgaW4gRnJhbWV3b3JrcyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAzNzFEODQyQzE3Qzk4QjZFMDBFQ0Y5OTQgLyogbGli ei5keWxpYiAqLzsgfTsKIAkJNDEyOTUyNzcxRDJDRjZCQzAwRTc4Qjg5IC8qIGJ1aWx0aW5zX2dl bmVyYXRlX2ludGVybmFsc193cmFwcGVyX2hlYWRlci5weSBpbiBIZWFkZXJzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQxMjk1MjczMUQyQ0Y2QUMwMEU3OEI4OSAvKiBidWls dGluc19nZW5lcmF0ZV9pbnRlcm5hbHNfd3JhcHBlcl9oZWFkZXIucHkgKi87IHNldHRpbmdzID0g e0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDEyOTUyNzgxRDJDRjZCQzAwRTc4 Qjg5IC8qIGJ1aWx0aW5zX2dlbmVyYXRlX2ludGVybmFsc193cmFwcGVyX2ltcGxlbWVudGF0aW9u LnB5IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDEyOTUy NzQxRDJDRjZBQzAwRTc4Qjg5IC8qIGJ1aWx0aW5zX2dlbmVyYXRlX2ludGVybmFsc193cmFwcGVy X2ltcGxlbWVudGF0aW9uLnB5ICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUs ICk7IH07IH07CkBAIC0yMDI1LDYgKzIwMjYsNyBAQAogCQlBRDc0MzhDMDFFMDQ1N0E0MDBGRDBD MkEgLyogV2FzbVNpZ25hdHVyZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gQUQ3NDM4QkYxRTA0NTc5MjAwRkQwQzJBIC8qIFdhc21TaWduYXR1cmUuaCAq Lzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlBRDc0MzhD MTFFMDQ1N0FBMDBGRDBDMkEgLyogV2FzbVNpZ25hdHVyZS5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBRDc0MzhCRTFFMDQ1NzkyMDBGRDBDMkEgLyog V2FzbVNpZ25hdHVyZS5jcHAgKi87IH07CiAJCUFEODZBOTNFMUFBNEQ4OEQwMDJGRTc3RiAvKiBX ZWFrR0NNYXBJbmxpbmVzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSBBRDg2QTkzRDFBQTREODdDMDAyRkU3N0YgLyogV2Vha0dDTWFwSW5saW5lcy5oICov OyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CisJCUFEQjZGNjdE MUUxNUQ3NjAwMDgyRjM4NCAvKiBXYXNtUGFnZUNvdW50LmNwcCBpbiBTb3VyY2VzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEFEQjZGNjdDMUUxNUQ3NTAwMDgyRjM4NCAvKiBX YXNtUGFnZUNvdW50LmNwcCAqLzsgfTsKIAkJQURCQzU0RDQxREY4RUEyQjAwNUJGNzM4IC8qIFdl YkFzc2VtYmx5VG9KU0NhbGxlZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBBREJDNTREMjFERjhFQTAwMDA1QkY3MzggLyogV2ViQXNzZW1ibHlUb0pT Q2FsbGVlLmNwcCAqLzsgfTsKIAkJQURCQzU0RDUxREY4RUEyQjAwNUJGNzM4IC8qIFdlYkFzc2Vt Ymx5VG9KU0NhbGxlZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gQURCQzU0RDMxREY4RUEwMDAwNUJGNzM4IC8qIFdlYkFzc2VtYmx5VG9KU0NhbGxlZS5o ICovOyB9OwogCQlBRERCMUY2MzE4RDc3REJFMDA5QjU4QTggLyogT3BhcXVlUm9vdFNldC5oIGlu IEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQUREQjFGNjIxOEQ3 N0RCNzAwOUI1OEE4IC8qIE9wYXF1ZVJvb3RTZXQuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRF UyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAtMjM2MSw3ICsyMzYzLDYgQEAKIAkJRkVEOTRGMkYx NzFFM0UyMzAwQkU3N0E0IC8qIFdhdGNoZG9nLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSBGRUQ5NEYyQzE3MUUzRTIzMDBCRTc3QTQgLyogV2F0Y2hkb2cu aCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGRUYw NDA1MTFBQUU2NjJEMDBCRDI4QjAgLyogQ29tcGFyZUFuZFN3YXBUZXN0LmNwcCBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZFRjA0MDUwMUFBRTY2MkQwMEJE MjhCMCAvKiBDb21wYXJlQW5kU3dhcFRlc3QuY3BwICovOyB9OwogCQlGRUZENkZDNjFENUU3OTky MDA4RjJGMEIgLyogSlNTdHJpbmdJbmxpbmVzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSBGRUZENkZDNTFENUU3OTcwMDA4RjJGMEIgLyogSlNTdHJpbmdJ bmxpbmVzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsK LQkJMkQzNDJGMzZGNzI0NDA5NjgwNEFEQjI0IC8qIFNvdXJjZU9yaWdpbi5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDI1QkExMzM3RTQzNDRFMUIyNjlB NjcxIC8qIFNvdXJjZU9yaWdpbi5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZh dGUsICk7IH07IH07CiAvKiBFbmQgUEJYQnVpbGRGaWxlIHNlY3Rpb24gKi8KIAogLyogQmVnaW4g UEJYQ29udGFpbmVySXRlbVByb3h5IHNlY3Rpb24gKi8KQEAgLTM2MzgsNiArMzYzOSw3IEBACiAJ CTQxMjk1Mjc1MUQyQ0Y2QUMwMEU3OEI4OSAvKiBidWlsdGluc19nZW5lcmF0ZV93cmFwcGVyX2hl YWRlci5weSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHRleHQuc2NyaXB0LnB5dGhvbjsgcGF0aCA9IGJ1aWx0aW5zX2dl bmVyYXRlX3dyYXBwZXJfaGVhZGVyLnB5OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0 MTI5NTI3NjFEMkNGNkFDMDBFNzhCODkgLyogYnVpbHRpbnNfZ2VuZXJhdGVfd3JhcHBlcl9pbXBs ZW1lbnRhdGlvbi5weSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuc2NyaXB0LnB5dGhvbjsgcGF0aCA9IGJ1aWx0 aW5zX2dlbmVyYXRlX3dyYXBwZXJfaW1wbGVtZW50YXRpb24ucHk7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCTQxREVBMTMxMUI5RjMxNTQwMDZENjVERCAvKiBCdWlsdGluVXRpbHMuaCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQnVpbHRpblV0aWxzLmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCTQyNUJBMTMzN0U0MzQ0RTFCMjY5QTY3MSAvKiBTb3VyY2VP cmlnaW4uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gU291cmNlT3JpZ2luLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQzMTlEQTAxMUMxQkUzQzEwMDFEMjYwQiAv KiBCM0xvd2VyTWFjcm9zQWZ0ZXJPcHRpbWl6YXRpb25zLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgbmFtZSA9IEIzTG93ZXJNYWNyb3NBZnRlck9wdGltaXphdGlvbnMuY3BwOyBw YXRoID0gYjMvQjNMb3dlck1hY3Jvc0FmdGVyT3B0aW1pemF0aW9ucy5jcHA7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCTQzMTlEQTAyMUMxQkUzQzEwMDFEMjYwQiAvKiBCM0xvd2VyTWFj cm9zQWZ0ZXJPcHRpbWl6YXRpb25zLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9 IEIzTG93ZXJNYWNyb3NBZnRlck9wdGltaXphdGlvbnMuaDsgcGF0aCA9IGIzL0IzTG93ZXJNYWNy b3NBZnRlck9wdGltaXphdGlvbnMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDM0 MEE0ODIxQTkwNTFBRjAwRDczQ0NBIC8qIE1hdGhDb21tb24uY3BwICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jcHAuY3BwOyBwYXRoID0gTWF0aENvbW1vbi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CkBAIC00NTEwLDYgKzQ1MTIsNyBAQAogCQlBRDc0MzhCRTFFMDQ1NzkyMDBGRDBDMkEg LyogV2FzbVNpZ25hdHVyZS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGgg PSBXYXNtU2lnbmF0dXJlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQUQ3NDM4 QkYxRTA0NTc5MjAwRkQwQzJBIC8qIFdhc21TaWduYXR1cmUuaCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBwYXRoID0gV2FzbVNpZ25hdHVyZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQlBRDg2QTkzRDFBQTREODdDMDAyRkU3N0YgLyogV2Vha0dDTWFwSW5saW5lcy5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXZWFrR0NNYXBJbmxpbmVzLmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCUFEQjZGNjdDMUUxNUQ3NTAwMDgyRjM4NCAvKiBXYXNtUGFn ZUNvdW50LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFdhc21QYWdl Q291bnQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBREJDNTREMjFERjhFQTAw MDA1QkY3MzggLyogV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgbmFtZSA9IFdlYkFzc2VtYmx5VG9KU0NhbGxlZS5jcHA7IHBhdGggPSBqcy9X ZWJBc3NlbWJseVRvSlNDYWxsZWUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlB REJDNTREMzFERjhFQTAwMDA1QkY3MzggLyogV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFdlYkFzc2VtYmx5VG9KU0NhbGxlZS5oOyBwYXRo ID0ganMvV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCUFEREIxRjYyMThENzdEQjcwMDlCNThBOCAvKiBPcGFxdWVSb290U2V0LmggKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE9wYXF1ZVJvb3RTZXQuaDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKQEAgLTQ4NzksNyArNDg4Miw2IEBACiAJCUZFRjA0MDUwMUFBRTY2MkQwMEJE MjhCMCAvKiBDb21wYXJlQW5kU3dhcFRlc3QuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAu Y3BwOyBuYW1lID0gQ29tcGFyZUFuZFN3YXBUZXN0LmNwcDsgcGF0aCA9IEFQSS90ZXN0cy9Db21w YXJlQW5kU3dhcFRlc3QuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGRUYwNDA1 MjFBQUVDNEVEMDBCRDI4QjAgLyogQ29tcGFyZUFuZFN3YXBUZXN0LmggKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmMuaDsgbmFtZSA9IENvbXBhcmVBbmRTd2FwVGVzdC5oOyBwYXRoID0gQVBJL3Rlc3Rz L0NvbXBhcmVBbmRTd2FwVGVzdC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGRUZE NkZDNTFENUU3OTcwMDA4RjJGMEIgLyogSlNTdHJpbmdJbmxpbmVzLmggKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmMuaDsgcGF0aCA9IEpTU3RyaW5nSW5saW5lcy5oOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwotCQk0MjVCQTEzMzdFNDM0NEUxQjI2OUE2NzEgLyogU291cmNlT3JpZ2luLmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFNvdXJjZU9yaWdpbi5oOyBwYXRoID0gU291 cmNlT3JpZ2luLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAvKiBFbmQgUEJYRmlsZVJl ZmVyZW5jZSBzZWN0aW9uICovCiAKIC8qIEJlZ2luIFBCWEZyYW1ld29ya3NCdWlsZFBoYXNlIHNl Y3Rpb24gKi8KQEAgLTYwNDcsNiArNjA0OSw3IEBACiAJCQkJNzlCNzU5NzIxREZBNEM2MDAwNTIx NzRDIC8qIFdhc21NZW1vcnlJbmZvcm1hdGlvbi5oICovLAogCQkJCTUzRjQwRTk2MUQ1QTdCRUMw MDk5QTFCNiAvKiBXYXNtTW9kdWxlUGFyc2VyLmNwcCAqLywKIAkJCQk1M0Y0MEU5NDFENUE3QUVG MDA5OUExQjYgLyogV2FzbU1vZHVsZVBhcnNlci5oICovLAorCQkJCUFEQjZGNjdDMUUxNUQ3NTAw MDgyRjM4NCAvKiBXYXNtUGFnZUNvdW50LmNwcCAqLywKIAkJCQk3OUI3NTk3MzFERkE0QzYwMDA1 MjE3NEMgLyogV2FzbVBhZ2VDb3VudC5oICovLAogCQkJCTUzRjQwRThDMUQ1OTAxRjIwMDk5QTFC NiAvKiBXYXNtUGFyc2VyLmggKi8sCiAJCQkJNTMxMzc0QkUxRDVDRTk1MDAwQUY3QTBCIC8qIFdh c21QbGFuLmNwcCAqLywKQEAgLTk3MDMsNiArOTcwNiw3IEBACiAJCQkJMEY2NEIyNzExQTc4NEJB RjAwNkU0RTY2IC8qIEJpbmFyeVN3aXRjaC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkxNDI4MDg2 MzEwN0VDMTFBMDAxM0U3QjIgLyogQm9vbGVhbkNvbnN0cnVjdG9yLmNwcCBpbiBTb3VyY2VzICov LAogCQkJCTE0MjgwODY0MTA3RUMxMUEwMDEzRTdCMiAvKiBCb29sZWFuT2JqZWN0LmNwcCBpbiBT b3VyY2VzICovLAorCQkJCUFEQjZGNjdEMUUxNUQ3NjAwMDgyRjM4NCAvKiBXYXNtUGFnZUNvdW50 LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTE0MjgwODY1MTA3RUMxMUEwMDEzRTdCMiAvKiBCb29s ZWFuUHJvdG90eXBlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCURFMjZFOTA3MUNCNURFRkIwMEQy QkU4MiAvKiBCdWlsdGluRXhlY3V0YWJsZUNyZWF0b3IuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJ QTdEODAxQTQxODgwRDY2RTAwMjZDMzlCIC8qIEJ1aWx0aW5FeGVjdXRhYmxlcy5jcHAgaW4gU291 cmNlcyAqLywKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9qc2MuY3BwIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL2pzYy5jcHAKaW5kZXggM2VhZjRhMC4uZjQzNGNhYyAxMDA2NDQK LS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2pzYy5jcHAKKysrIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL2pzYy5jcHAKQEAgLTU0LDYgKzU0LDggQEAKICNpbmNsdWRlICJKU1N0cmluZy5oIgog I2luY2x1ZGUgIkpTVHlwZWRBcnJheXMuaCIKICNpbmNsdWRlICJKU1dlYkFzc2VtYmx5Q2FsbGVl LmgiCisjaW5jbHVkZSAiSlNXZWJBc3NlbWJseUluc3RhbmNlLmgiCisjaW5jbHVkZSAiSlNXZWJB c3NlbWJseU1vZHVsZS5oIgogI2luY2x1ZGUgIkxMSW50RGF0YS5oIgogI2luY2x1ZGUgIkxMSW50 VGh1bmtzLmgiCiAjaW5jbHVkZSAiT2JqZWN0Q29uc3RydWN0b3IuaCIKQEAgLTcwLDYgKzcyLDcg QEAKICNpbmNsdWRlICJUeXBlUHJvZmlsZXJMb2cuaCIKICNpbmNsdWRlICJXYXNtUGxhbi5oIgog I2luY2x1ZGUgIldhc21NZW1vcnkuaCIKKyNpbmNsdWRlICJXZWJBc3NlbWJseU1vZHVsZVJlY29y ZC5oIgogI2luY2x1ZGUgPGxvY2FsZS5oPgogI2luY2x1ZGUgPG1hdGguaD4KICNpbmNsdWRlIDxz dGRpby5oPgpAQCAtMjYxNSw2ICsyNjE4LDcgQEAgc3RhdGljIEVuY29kZWRKU1ZhbHVlIEpTQ19I T1NUX0NBTEwgZnVuY3Rpb25UZXN0V2FzbU1vZHVsZUZ1bmN0aW9ucyhFeGVjU3RhdGUqIGUKIHsK ICAgICBWTSYgdm0gPSBleGVjLT52bSgpOwogICAgIGF1dG8gc2NvcGUgPSBERUNMQVJFX1RIUk9X X1NDT1BFKHZtKTsKKyAgICBhdXRvKiBnbG9iYWxPYmplY3QgPSBleGVjLT5sZXhpY2FsR2xvYmFs T2JqZWN0KCk7CiAKICAgICBpZiAoIU9wdGlvbnM6OnVzZVdlYkFzc2VtYmx5KCkpCiAgICAgICAg IHJldHVybiB0aHJvd1ZNVHlwZUVycm9yKGV4ZWMsIHNjb3BlLCBBU0NJSUxpdGVyYWwoInRlc3RX YXNtTW9kdWxlIHNob3VsZCBvbmx5IGJlIGNhbGxlZCBpZiB0aGUgdXNlV2ViQXNzZW1ibHkgb3B0 aW9uIGlzIHNldCIpKTsKQEAgLTI2NDgsOCArMjY1MiwyNSBAQCBzdGF0aWMgRW5jb2RlZEpTVmFs dWUgSlNDX0hPU1RfQ0FMTCBmdW5jdGlvblRlc3RXYXNtTW9kdWxlRnVuY3Rpb25zKEV4ZWNTdGF0 ZSogZQogICAgICAgICAgICAgfSk7CiAgICAgfQogCi0gICAgc3RkOjp1bmlxdWVfcHRyPFdhc206 Ok1vZHVsZUluZm9ybWF0aW9uPiBtb2R1bGVJbmZvcm1hdGlvbiA9IHBsYW4udGFrZU1vZHVsZUlu Zm9ybWF0aW9uKCk7Ci0gICAgUkVMRUFTRV9BU1NFUlQoIW1vZHVsZUluZm9ybWF0aW9uLT5tZW1v cnkpOworICAgIFN5bWJvbFRhYmxlKiBleHBvcnRTeW1ib2xUYWJsZSA9IFN5bWJvbFRhYmxlOjpj cmVhdGUodm0pOworICAgIGF1dG8qIG1vZHVsZVN0cnVjdHVyZSA9IEludGVybmFsRnVuY3Rpb246 OmNyZWF0ZVN1YmNsYXNzU3RydWN0dXJlKGV4ZWMsIEpTVmFsdWUoKSwgZXhlYy0+bGV4aWNhbEds b2JhbE9iamVjdCgpLT5XZWJBc3NlbWJseU1vZHVsZVN0cnVjdHVyZSgpKTsKKyAgICBSRVRVUk5f SUZfRVhDRVBUSU9OKHNjb3BlLCBlbmNvZGVkSlNWYWx1ZSgpKTsKKyAgICBKU1dlYkFzc2VtYmx5 TW9kdWxlKiBtb2R1bGUgPSBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGUodm0sIG1vZHVsZVN0 cnVjdHVyZSwgcGxhbi50YWtlTW9kdWxlSW5mb3JtYXRpb24oKSwgcGxhbi50YWtlQ2FsbExpbmtJ bmZvcygpLCBwbGFuLnRha2VXYXNtRXhpdFN0dWJzKCksIGV4cG9ydFN5bWJvbFRhYmxlLCAwKTsK KyAgICBTdHJ1Y3R1cmUqIGluc3RhbmNlU3RydWN0dXJlID0gSW50ZXJuYWxGdW5jdGlvbjo6Y3Jl YXRlU3ViY2xhc3NTdHJ1Y3R1cmUoZXhlYywgSlNWYWx1ZSgpLCBnbG9iYWxPYmplY3QtPldlYkFz c2VtYmx5SW5zdGFuY2VTdHJ1Y3R1cmUoKSk7CisgICAgUkVUVVJOX0lGX0VYQ0VQVElPTihzY29w ZSwgZW5jb2RlZEpTVmFsdWUoKSk7CisgICAgSWRlbnRpZmllciBtb2R1bGVLZXkgPSBJZGVudGlm aWVyOjpmcm9tVWlkKFByaXZhdGVOYW1lKFByaXZhdGVOYW1lOjpEZXNjcmlwdGlvbiwgIldlYkFz c2VtYmx5SW5zdGFuY2UiKSk7CisgICAgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQqIG1vZHVsZVJl Y29yZCA9IFdlYkFzc2VtYmx5TW9kdWxlUmVjb3JkOjpjcmVhdGUoZXhlYywgdm0sIGdsb2JhbE9i amVjdC0+d2ViQXNzZW1ibHlNb2R1bGVSZWNvcmRTdHJ1Y3R1cmUoKSwgbW9kdWxlS2V5LCBtb2R1 bGUtPm1vZHVsZUluZm9ybWF0aW9uKCkpOworICAgIFJFVFVSTl9JRl9FWENFUFRJT04oc2NvcGUs IGVuY29kZWRKU1ZhbHVlKCkpOworICAgIEpTV2ViQXNzZW1ibHlJbnN0YW5jZSogaW5zdGFuY2Ug PSBKU1dlYkFzc2VtYmx5SW5zdGFuY2U6OmNyZWF0ZSh2bSwgaW5zdGFuY2VTdHJ1Y3R1cmUsIG1v ZHVsZSwgbW9kdWxlUmVjb3JkLT5nZXRNb2R1bGVOYW1lc3BhY2UoZXhlYykpOworICAgIFJFVFVS Tl9JRl9FWENFUFRJT04oc2NvcGUsIGVuY29kZWRKU1ZhbHVlKCkpOworICAgIHZtLnRvcEpTV2Vi QXNzZW1ibHlJbnN0YW5jZSA9IGluc3RhbmNlOworCisgICAgaWYgKCEhbW9kdWxlLT5tb2R1bGVJ bmZvcm1hdGlvbigpLm1lbW9yeSkgeworICAgICAgICBib29sIGZhaWxlZDsKKyAgICAgICAgV2Fz bTo6TWVtb3J5IG1lbW9yeShtb2R1bGUtPm1vZHVsZUluZm9ybWF0aW9uKCkubWVtb3J5LmluaXRp YWwoKSwgbW9kdWxlLT5tb2R1bGVJbmZvcm1hdGlvbigpLm1lbW9yeS5tYXhpbXVtKCksIGZhaWxl ZCk7CisgICAgICAgIFJFTEVBU0VfQVNTRVJUKGZhaWxlZCk7CisgICAgICAgIGluc3RhbmNlLT5z ZXRNZW1vcnkodm0sIEpTV2ViQXNzZW1ibHlNZW1vcnk6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0 LT5XZWJBc3NlbWJseU1lbW9yeVN0cnVjdHVyZSgpLCBXVEZNb3ZlKG1lbW9yeSkpKTsKKyAgICB9 CiAKICAgICBmb3IgKHVpbnQzMl90IGkgPSAwOyBpIDwgZnVuY3Rpb25Db3VudDsgKytpKSB7CiAg ICAgICAgIEpTQXJyYXkqIHRlc3RDYXNlcyA9IGpzQ2FzdDxKU0FycmF5Kj4oZXhlYy0+YXJndW1l bnQoaSArIDIpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0Fi c3RyYWN0TW9kdWxlUmVjb3JkLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9BYnN0 cmFjdE1vZHVsZVJlY29yZC5oCmluZGV4IDA0YWYxMjYuLjM5ZmMyZDEgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0Fic3RyYWN0TW9kdWxlUmVjb3JkLmgKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvQWJzdHJhY3RNb2R1bGVSZWNvcmQuaApAQCAt MTEzLDcgKzExMyw3IEBAIHB1YmxpYzoKIAogICAgIEFic3RyYWN0TW9kdWxlUmVjb3JkKiBob3N0 UmVzb2x2ZUltcG9ydGVkTW9kdWxlKEV4ZWNTdGF0ZSosIGNvbnN0IElkZW50aWZpZXImIG1vZHVs ZU5hbWUpOwogCi0gICAgSlNNb2R1bGVOYW1lc3BhY2VPYmplY3QqIGdldE1vZHVsZU5hbWVzcGFj ZShFeGVjU3RhdGUqKTsKKyAgICBKU19FWFBPUlRfUFJJVkFURSBKU01vZHVsZU5hbWVzcGFjZU9i amVjdCogZ2V0TW9kdWxlTmFtZXNwYWNlKEV4ZWNTdGF0ZSopOwogICAgIAogICAgIEpTTW9kdWxl RW52aXJvbm1lbnQqIG1vZHVsZUVudmlyb25tZW50KCkKICAgICB7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU1R5cGUuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9ydW50aW1lL0pTVHlwZS5oCmluZGV4IDA1MjAyZjMuLmFjNTA5ZDcgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTVHlwZS5oCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL0pTVHlwZS5oCkBAIC05Myw2ICs5Myw4IEBAIGVudW0gSlNUeXBlIDog dWludDhfdCB7CiAgICAgSlNNYXBUeXBlLAogICAgIEpTU2V0VHlwZSwKIAorICAgIFdlYkFzc2Vt Ymx5RnVuY3Rpb25UeXBlLAorCiAgICAgTGFzdEpTQ09iamVjdFR5cGUgPSBKU1NldFR5cGUsCiAg ICAgTWF4SlNUeXBlID0gMGIxMTExMTExMSwKIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5jcHAKaW5kZXggMTE3ZDc2NC4uN2Y1NmYyZSAxMDA2 NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuY3Bw CisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcApA QCAtMTU1LDcgKzE1NSw3IEBAIHB1YmxpYzoKICAgICAgICAgICAgIHJldHVybiBmYWlsKF9fVkFf QVJHU19fKTsgICAgICAgICAgICAgXAogICAgIH0gd2hpbGUgKDApCiAKLSAgICBCM0lSR2VuZXJh dG9yKFZNJiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mLCBQcm9jZWR1cmUmLCBXYXNtSW50ZXJu YWxGdW5jdGlvbiosIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYsIGNvbnN0IEltbXV0 YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYpOworICAgIEIzSVJHZW5lcmF0b3IoVk0mLCBjb25zdCBN b2R1bGVJbmZvcm1hdGlvbiYsIFByb2NlZHVyZSYsIFdhc21JbnRlcm5hbEZ1bmN0aW9uKiwgVmVj dG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+Jik7CiAKICAgICBQYXJ0aWFsUmVzdWx0IFdBUk5f VU5VU0VEX1JFVFVSTiBhZGRBcmd1bWVudHMoY29uc3QgU2lnbmF0dXJlKik7CiAgICAgUGFydGlh bFJlc3VsdCBXQVJOX1VOVVNFRF9SRVRVUk4gYWRkTG9jYWwoVHlwZSwgdWludDMyX3QpOwpAQCAt MjA1LDggKzIwNSw2IEBAIHB1YmxpYzoKIAogICAgIHZvaWQgZW1pdEV4Y2VwdGlvbkNoZWNrKEND YWxsSGVscGVycyYsIEV4Y2VwdGlvblR5cGUpOwogCi0gICAgdm9pZCBlbWl0UmVsb2FkUGlubmVk UmVnaXN0ZXJzKCk7Ci0KIHByaXZhdGU6CiAgICAgRXhwcmVzc2lvblR5cGUgZW1pdENoZWNrQW5k UHJlcGFyZVBvaW50ZXIoRXhwcmVzc2lvblR5cGUgcG9pbnRlciwgdWludDMyX3Qgb2Zmc2V0LCB1 aW50MzJfdCBzaXplT2ZPcCk7CiAgICAgRXhwcmVzc2lvblR5cGUgZW1pdExvYWRPcChMb2FkT3BU eXBlLCBPcmlnaW4sIEV4cHJlc3Npb25UeXBlIHBvaW50ZXIsIHVpbnQzMl90IG9mZnNldCk7CkBA IC0yMTksNyArMjE3LDYgQEAgcHJpdmF0ZToKICAgICB2b2lkIGVtaXRDaGVja3NGb3JNb2RPckRp dihCMzo6T3Bjb2RlLCBFeHByZXNzaW9uVHlwZSBsZWZ0LCBFeHByZXNzaW9uVHlwZSByaWdodCk7 CiAKICAgICBWTSYgbV92bTsKLSAgICBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2Um IG1fZnVuY3Rpb25JbmRleFNwYWNlOwogICAgIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBtX2lu Zm87CiAgICAgUHJvY2VkdXJlJiBtX3Byb2M7CiAgICAgQmFzaWNCbG9jayogbV9jdXJyZW50Qmxv Y2s7CkBAIC0yMzEsOSArMjI4LDggQEAgcHJpdmF0ZToKICAgICBWYWx1ZSogbV9pbnN0YW5jZVZh bHVlOwogfTsKIAotQjNJUkdlbmVyYXRvcjo6QjNJUkdlbmVyYXRvcihWTSYgdm0sIGNvbnN0IE1v ZHVsZUluZm9ybWF0aW9uJiBpbmZvLCBQcm9jZWR1cmUmIHByb2NlZHVyZSwgV2FzbUludGVybmFs RnVuY3Rpb24qIGNvbXBpbGF0aW9uLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mIHVu bGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2Um IGZ1bmN0aW9uSW5kZXhTcGFjZSkKK0IzSVJHZW5lcmF0b3I6OkIzSVJHZW5lcmF0b3IoVk0mIHZt LCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgUHJvY2VkdXJlJiBwcm9jZWR1cmUsIFdh c21JbnRlcm5hbEZ1bmN0aW9uKiBjb21waWxhdGlvbiwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2Fz bUNhbGw+JiB1bmxpbmtlZFdhc21Ub1dhc21DYWxscykKICAgICA6IG1fdm0odm0pCi0gICAgLCBt X2Z1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4U3BhY2UpCiAgICAgLCBtX2luZm8oaW5m bykKICAgICAsIG1fcHJvYyhwcm9jZWR1cmUpCiAgICAgLCBtX3VubGlua2VkV2FzbVRvV2FzbUNh bGxzKHVubGlua2VkV2FzbVRvV2FzbUNhbGxzKQpAQCAtMjU0LDE0ICsyNTAsMTYgQEAgQjNJUkdl bmVyYXRvcjo6QjNJUkdlbmVyYXRvcihWTSYgdm0sIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBp bmZvLCBQcm9jZWR1cmUmIHAKICAgICAgICAgfQogICAgIH0KIAotICAgIGlmIChpbmZvLmhhc01l bW9yeSgpKSB7Ci0gICAgICAgIG1fbWVtb3J5QmFzZUdQUiA9IGluZm8ubWVtb3J5LnBpbm5lZFJl Z2lzdGVycygpLmJhc2VNZW1vcnlQb2ludGVyOworICAgIC8vIEZJWE1FIHdlIGRvbid0IHJlYWxs eSBuZWVkIHRvIHBpbiByZWdpc3RlcnMgaGVyZSBpZiB0aGVyZSdzIG5vIG1lbW9yeS4gSXQgbWFr ZXMgd2FzbSAtPiB3YXNtIHRodW5rcyBzaW1wbGVyIGZvciBub3cuIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjY2MjMKKyAgICAgICAgY29uc3QgUGlubmVkUmVnaXN0 ZXJJbmZvJiBwaW5uZWRSZWdzID0gUGlubmVkUmVnaXN0ZXJJbmZvOjpnZXQoKTsKKyAgICAgICAg bV9tZW1vcnlCYXNlR1BSID0gcGlubmVkUmVncy5iYXNlTWVtb3J5UG9pbnRlcjsKICAgICAgICAg bV9wcm9jLnBpblJlZ2lzdGVyKG1fbWVtb3J5QmFzZUdQUik7Ci0gICAgICAgIEFTU0VSVCghaW5m by5tZW1vcnkucGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVyc1swXS5zaXplT2Zmc2V0KTsK LSAgICAgICAgbV9tZW1vcnlTaXplR1BSID0gaW5mby5tZW1vcnkucGlubmVkUmVnaXN0ZXJzKCku c2l6ZVJlZ2lzdGVyc1swXS5zaXplUmVnaXN0ZXI7Ci0gICAgICAgIGZvciAoY29uc3QgUGlubmVk U2l6ZVJlZ2lzdGVySW5mbyYgcmVnSW5mbyA6IGluZm8ubWVtb3J5LnBpbm5lZFJlZ2lzdGVycygp LnNpemVSZWdpc3RlcnMpCisgICAgICAgIEFTU0VSVCghcGlubmVkUmVncy5zaXplUmVnaXN0ZXJz WzBdLnNpemVPZmZzZXQpOworICAgICAgICBtX21lbW9yeVNpemVHUFIgPSBwaW5uZWRSZWdzLnNp emVSZWdpc3RlcnNbMF0uc2l6ZVJlZ2lzdGVyOworICAgICAgICBmb3IgKGNvbnN0IFBpbm5lZFNp emVSZWdpc3RlckluZm8mIHJlZ0luZm8gOiBwaW5uZWRSZWdzLnNpemVSZWdpc3RlcnMpCiAgICAg ICAgICAgICBtX3Byb2MucGluUmVnaXN0ZXIocmVnSW5mby5zaXplUmVnaXN0ZXIpOwogCisgICAg aWYgKGluZm8uaGFzTWVtb3J5KCkpIHsKICAgICAgICAgbV9wcm9jLnNldFdhc21Cb3VuZHNDaGVj a0dlbmVyYXRvcihbPV0gKENDYWxsSGVscGVycyYgaml0LCBHUFJSZWcgcGlubmVkR1BSLCB1bnNp Z25lZCkgewogICAgICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93 U2NyYXRjaChqaXQpOwogICAgICAgICAgICAgQVNTRVJUX1VOVVNFRChwaW5uZWRHUFIsIG1fbWVt b3J5U2l6ZUdQUiA9PSBwaW5uZWRHUFIpOwpAQCAtMjc1LDYgKzI3Myw2MSBAQCBCM0lSR2VuZXJh dG9yOjpCM0lSR2VuZXJhdG9yKFZNJiB2bSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8s IFByb2NlZHVyZSYgcAogICAgICAgICBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PENvbnN0UHRy VmFsdWU+KG1fcHJvYywgT3JpZ2luKCksICZtX3ZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZSkp OwogfQogCitzdHJ1Y3QgTWVtb3J5QmFzZUFuZFNpemUgeworICAgIFZhbHVlKiBiYXNlOworICAg IFZhbHVlKiBzaXplOworfTsKKworc3RhdGljIE1lbW9yeUJhc2VBbmRTaXplIGdldE1lbW9yeUJh c2VBbmRTaXplKFZNJiB2bSwgVmFsdWUqIGluc3RhbmNlLCBQcm9jZWR1cmUmIHByb2MsIEJhc2lj QmxvY2sqIGJsb2NrKQoreworICAgIFZhbHVlKiBtZW1vcnlPYmplY3QgPSBibG9jay0+YXBwZW5k TmV3PE1lbW9yeVZhbHVlPihwcm9jLCBMb2FkLCBwb2ludGVyVHlwZSgpLCBPcmlnaW4oKSwgaW5z dGFuY2UsIEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZNZW1vcnkoKSk7CisKKyAgICBz dGF0aWNfYXNzZXJ0KHNpemVvZihkZWNsdHlwZSh2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2Ut Pm1lbW9yeSgpLT5tZW1vcnkoKS0+bWVtb3J5KCkpKSA9PSBzaXplb2Yodm9pZCopLCAiY29kZWdl biByZWxpZXMgb24gdGhpcyBzaXplIik7CisgICAgc3RhdGljX2Fzc2VydChzaXplb2YoZGVjbHR5 cGUodm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlLT5tZW1vcnkoKS0+bWVtb3J5KCktPnNpemUo KSkpID09IHNpemVvZih1aW50NjRfdCksICJjb2RlZ2VuIHJlbGllcyBvbiB0aGlzIHNpemUiKTsK KyAgICBNZW1vcnlCYXNlQW5kU2l6ZSByZXN1bHQ7CisgICAgcmVzdWx0LmJhc2UgPSBibG9jay0+ YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihwcm9jLCBMb2FkLCBwb2ludGVyVHlwZSgpLCBPcmlnaW4o KSwgbWVtb3J5T2JqZWN0LCBKU1dlYkFzc2VtYmx5TWVtb3J5OjpvZmZzZXRPZk1lbW9yeSgpKTsK KyAgICByZXN1bHQuc2l6ZSA9IGJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KHByb2MsIExv YWQsIEludDY0LCBPcmlnaW4oKSwgbWVtb3J5T2JqZWN0LCBKU1dlYkFzc2VtYmx5TWVtb3J5Ojpv ZmZzZXRPZlNpemUoKSk7CisKKyAgICByZXR1cm4gcmVzdWx0OworfQorCitzdGF0aWMgdm9pZCBy ZXN0b3JlV2ViQXNzZW1ibHlHbG9iYWxTdGF0ZShWTSYgdm0sIGNvbnN0IE1lbW9yeUluZm9ybWF0 aW9uJiBtZW1vcnksIFZhbHVlKiBpbnN0YW5jZSwgUHJvY2VkdXJlJiBwcm9jLCBCYXNpY0Jsb2Nr KiBibG9jaykKK3sKKyAgICBibG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihwcm9jLCBTdG9y ZSwgT3JpZ2luKCksIGluc3RhbmNlLCBibG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KHBy b2MsIE9yaWdpbigpLCAmdm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlKSk7CisKKyAgICBpZiAo ISFtZW1vcnkpIHsKKyAgICAgICAgY29uc3QgUGlubmVkUmVnaXN0ZXJJbmZvJiBwaW5uZWRSZWdz ID0gUGlubmVkUmVnaXN0ZXJJbmZvOjpnZXQoKTsKKyAgICAgICAgYXV0byBtZW1vcnlWYWx1ZSA9 IGdldE1lbW9yeUJhc2VBbmRTaXplKHZtLCBpbnN0YW5jZSwgcHJvYywgYmxvY2spOworCisgICAg ICAgIFZlY3RvcjxWYWx1ZSo+IGFyZ3VtZW50czsKKyAgICAgICAgYXJndW1lbnRzLnJlc2VydmVD YXBhY2l0eSgxICsgcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzLnNpemUoKSk7CisgICAgICAgIGFy Z3VtZW50cy5hcHBlbmQobWVtb3J5VmFsdWUuYmFzZSk7CisgICAgICAgIGZvciAoYXV0byBpbmZv IDogcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzKSB7CisgICAgICAgICAgICBWYWx1ZSogc2l6ZVZh bHVlID0gYmxvY2stPmFwcGVuZE5ldzxWYWx1ZT4ocHJvYywgU3ViLCBPcmlnaW4oKSwgbWVtb3J5 VmFsdWUuc2l6ZSwgYmxvY2stPmFwcGVuZE5ldzxDb25zdDY0VmFsdWU+KHByb2MsIE9yaWdpbigp LCBpbmZvLnNpemVPZmZzZXQpKTsKKyAgICAgICAgICAgIGFyZ3VtZW50cy5hcHBlbmQoc2l6ZVZh bHVlKTsKKyAgICAgICAgfQorCisgICAgICAgIFJlZ2lzdGVyU2V0IGNsb2JiZXJzOworICAgICAg ICBjbG9iYmVycy5zZXQocGlubmVkUmVncy5iYXNlTWVtb3J5UG9pbnRlcik7CisgICAgICAgIGZv ciAoYXV0byBpbmZvIDogcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzKQorICAgICAgICAgICAgY2xv YmJlcnMuc2V0KGluZm8uc2l6ZVJlZ2lzdGVyKTsKKworICAgICAgICBCMzo6UGF0Y2hwb2ludFZh bHVlKiBwYXRjaHBvaW50ID0gYmxvY2stPmFwcGVuZE5ldzxCMzo6UGF0Y2hwb2ludFZhbHVlPihw cm9jLCBCMzo6Vm9pZCwgT3JpZ2luKCkpOworICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzID0g RWZmZWN0czo6bm9uZSgpOworICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLndyaXRlc1Bpbm5l ZCA9IHRydWU7CisgICAgICAgIHBhdGNocG9pbnQtPmNsb2JiZXIoY2xvYmJlcnMpOworICAgICAg ICBwYXRjaHBvaW50LT5hcHBlbmRWZWN0b3JXaXRoUmVwKGFyZ3VtZW50cywgVmFsdWVSZXA6OlNv bWVSZWdpc3Rlcik7CisKKyAgICAgICAgcGF0Y2hwb2ludC0+c2V0R2VuZXJhdG9yKFsmcGlubmVk UmVnc10gKENDYWxsSGVscGVycyYgaml0LCBjb25zdCBCMzo6U3RhY2ttYXBHZW5lcmF0aW9uUGFy YW1zJiBwYXJhbXMpIHsKKyAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2Fn ZSBhbGxvd1NjcmF0Y2goaml0KTsKKworICAgICAgICAgICAgaml0Lm1vdmUocGFyYW1zWzBdLmdw cigpLCBwaW5uZWRSZWdzLmJhc2VNZW1vcnlQb2ludGVyKTsKKyAgICAgICAgICAgIGZvciAodWlu dDMyX3QgaSA9IDA7IGkgPCBwaW5uZWRSZWdzLnNpemVSZWdpc3RlcnMuc2l6ZSgpOyArK2kpCisg ICAgICAgICAgICAgICAgaml0Lm1vdmUocGFyYW1zWzEgKyBpXS5ncHIoKSwgcGlubmVkUmVncy5z aXplUmVnaXN0ZXJzW2ldLnNpemVSZWdpc3Rlcik7CisgICAgICAgIH0pOworICAgIH0KK30KKwog dm9pZCBCM0lSR2VuZXJhdG9yOjplbWl0RXhjZXB0aW9uQ2hlY2soQ0NhbGxIZWxwZXJzJiBqaXQs IEV4Y2VwdGlvblR5cGUgdHlwZSkKIHsKICAgICBqaXQubW92ZShDQ2FsbEhlbHBlcnM6OlRydXN0 ZWRJbW0zMihzdGF0aWNfY2FzdDx1aW50MzJfdD4odHlwZSkpLCBHUFJJbmZvOjphcmd1bWVudEdQ UjEpOwpAQCAtMzM4LDQ5ICszOTEsNiBAQCBhdXRvIEIzSVJHZW5lcmF0b3I6OmFkZFVucmVhY2hh YmxlKCkgLT4gUGFydGlhbFJlc3VsdAogICAgIHJldHVybiB7IH07CiB9CiAKLXN0YXRpYyB2b2lk IHJlbG9hZFBpbm5lZFJlZ2lzdGVycyhQcm9jZWR1cmUmIHByb2MsIEJhc2ljQmxvY2sqIGJsb2Nr LCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgVmFsdWUqIGluc3RhbmNlKQotewotICAg IGlmICghaW5mby5oYXNNZW1vcnkoKSkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgY29uc3QgTWVt b3J5SW5mb3JtYXRpb24qIG1lbW9yeSA9ICZpbmZvLm1lbW9yeTsKLQotICAgIFJlZ2lzdGVyU2V0 IGNsb2JiZXJzOwotICAgIGNsb2JiZXJzLnNldChtZW1vcnktPnBpbm5lZFJlZ2lzdGVycygpLmJh c2VNZW1vcnlQb2ludGVyKTsKLSAgICBmb3IgKGF1dG8gaW5mbyA6IG1lbW9yeS0+cGlubmVkUmVn aXN0ZXJzKCkuc2l6ZVJlZ2lzdGVycykKLSAgICAgICAgY2xvYmJlcnMuc2V0KGluZm8uc2l6ZVJl Z2lzdGVyKTsKLQotICAgIEIzOjpQYXRjaHBvaW50VmFsdWUqIHBhdGNocG9pbnQgPSBibG9jay0+ YXBwZW5kTmV3PEIzOjpQYXRjaHBvaW50VmFsdWU+KHByb2MsIEIzOjpWb2lkLCBPcmlnaW4oKSk7 Ci0gICAgcGF0Y2hwb2ludC0+ZWZmZWN0cyA9IEVmZmVjdHM6Om5vbmUoKTsKLSAgICBwYXRjaHBv aW50LT5lZmZlY3RzLndyaXRlc1Bpbm5lZCA9IHRydWU7Ci0gICAgcGF0Y2hwb2ludC0+Y2xvYmJl cihjbG9iYmVycyk7Ci0gICAgcGF0Y2hwb2ludC0+bnVtR1BTY3JhdGNoUmVnaXN0ZXJzID0gMTsK LQotICAgIHBhdGNocG9pbnQtPmFwcGVuZChpbnN0YW5jZSwgVmFsdWVSZXA6OlNvbWVSZWdpc3Rl cik7Ci0KLSAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW21lbW9yeV0gKENDYWxsSGVscGVy cyYgaml0LCBjb25zdCBCMzo6U3RhY2ttYXBHZW5lcmF0aW9uUGFyYW1zJiBwYXJhbXMpIHsKLSAg ICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93U2NyYXRjaChqaXQpOwot Ci0gICAgICAgIEdQUlJlZyBzY3JhdGNoID0gcGFyYW1zLmdwU2NyYXRjaCgwKTsKLSAgICAgICAg aml0LmxvYWRQdHIoQ0NhbGxIZWxwZXJzOjpBZGRyZXNzKHBhcmFtc1swXS5ncHIoKSwgSlNXZWJB c3NlbWJseUluc3RhbmNlOjpvZmZzZXRPZk1lbW9yeSgpKSwgc2NyYXRjaCk7Ci0gICAgICAgIGpp dC5sb2FkUHRyKENDYWxsSGVscGVyczo6QWRkcmVzcyhzY3JhdGNoLCBKU1dlYkFzc2VtYmx5TWVt b3J5OjpvZmZzZXRPZk1lbW9yeSgpKSwgc2NyYXRjaCk7Ci0gICAgICAgIGppdC5sb2FkUHRyKEND YWxsSGVscGVyczo6QWRkcmVzcyhzY3JhdGNoLCBNZW1vcnk6Om9mZnNldE9mTWVtb3J5KCkpLCBt ZW1vcnktPnBpbm5lZFJlZ2lzdGVycygpLmJhc2VNZW1vcnlQb2ludGVyKTsKLQotICAgICAgICBq aXQubG9hZDY0KENDYWxsSGVscGVyczo6QWRkcmVzcyhzY3JhdGNoLCBNZW1vcnk6Om9mZnNldE9m U2l6ZSgpKSwgc2NyYXRjaCk7Ci0gICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBtZW1v cnktPnBpbm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnMuc2l6ZSgpOyBpKyspIHsKLSAgICAg ICAgICAgIEdQUlJlZyBzaXplUmVnID0gbWVtb3J5LT5waW5uZWRSZWdpc3RlcnMoKS5zaXplUmVn aXN0ZXJzW2ldLnNpemVSZWdpc3RlcjsKLSAgICAgICAgICAgIGppdC5tb3ZlKHNjcmF0Y2gsIHNp emVSZWcpOwotICAgICAgICAgICAgaml0LnN1YjY0KENDYWxsSGVscGVyczo6VHJ1c3RlZEltbTMy KG1lbW9yeS0+cGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVyc1tpXS5zaXplT2Zmc2V0KSwg c2l6ZVJlZyk7Ci0gICAgICAgIH0KLSAgICB9KTsKLX0KLQotdm9pZCBCM0lSR2VuZXJhdG9yOjpl bWl0UmVsb2FkUGlubmVkUmVnaXN0ZXJzKCkKLXsKLSAgICByZWxvYWRQaW5uZWRSZWdpc3RlcnMo bV9wcm9jLCBtX2N1cnJlbnRCbG9jaywgbV9pbmZvLCBtX2luc3RhbmNlVmFsdWUpOwotfQotCi0K IGF1dG8gQjNJUkdlbmVyYXRvcjo6YWRkR3Jvd01lbW9yeShFeHByZXNzaW9uVHlwZSBkZWx0YSwg RXhwcmVzc2lvblR5cGUmIHJlc3VsdCkgLT4gUGFydGlhbFJlc3VsdAogewogICAgIGludDMyX3Qg KCpncm93TWVtb3J5KSAoRXhlY1N0YXRlKiwgaW50MzJfdCkgPSBbXSAoRXhlY1N0YXRlKiBleGVj LCBpbnQzMl90IGRlbHRhKSAtPiBpbnQzMl90IHsKQEAgLTM4OSw3ICszOTksNiBAQCBhdXRvIEIz SVJHZW5lcmF0b3I6OmFkZEdyb3dNZW1vcnkoRXhwcmVzc2lvblR5cGUgZGVsdGEsIEV4cHJlc3Np b25UeXBlJiByZXN1bHQpCiAKICAgICAgICAgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBpbnN0YW5j ZSA9IHZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZTsKICAgICAgICAgSlNXZWJBc3NlbWJseU1l bW9yeSogd2FzbU1lbW9yeSA9IGluc3RhbmNlLT5tZW1vcnkoKTsKLSAgICAgICAgUkVMRUFTRV9B U1NFUlQod2FzbU1lbW9yeSk7IC8vIFRoaXMgd291bGQgZmFpbCB2YWxpZGF0aW9uIG90aGVyd2lz ZS4KIAogICAgICAgICBpZiAoZGVsdGEgPCAwKQogICAgICAgICAgICAgcmV0dXJuIC0xOwpAQCAt NDA3LDIxICs0MTYsMTkgQEAgYXV0byBCM0lSR2VuZXJhdG9yOjphZGRHcm93TWVtb3J5KEV4cHJl c3Npb25UeXBlIGRlbHRhLCBFeHByZXNzaW9uVHlwZSYgcmVzdWx0KQogICAgICAgICBtX2N1cnJl bnRCbG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KG1fcHJvYywgT3JpZ2luKCksIGJpdHdp c2VfY2FzdDx2b2lkKj4oZ3Jvd01lbW9yeSkpLAogICAgICAgICBtX2N1cnJlbnRCbG9jay0+YXBw ZW5kTmV3PEIzOjpWYWx1ZT4obV9wcm9jLCBCMzo6RnJhbWVQb2ludGVyLCBPcmlnaW4oKSksIGRl bHRhKTsKIAotICAgIGVtaXRSZWxvYWRQaW5uZWRSZWdpc3RlcnMoKTsKKyAgICByZXN0b3JlV2Vi QXNzZW1ibHlHbG9iYWxTdGF0ZShtX3ZtLCBtX2luZm8ubWVtb3J5LCBtX2luc3RhbmNlVmFsdWUs IG1fcHJvYywgbV9jdXJyZW50QmxvY2spOwogCiAgICAgcmV0dXJuIHsgfTsKIH0KIAogYXV0byBC M0lSR2VuZXJhdG9yOjphZGRDdXJyZW50TWVtb3J5KEV4cHJlc3Npb25UeXBlJiByZXN1bHQpIC0+ IFBhcnRpYWxSZXN1bHQKIHsKLSAgICBWYWx1ZSoganNNZW1vcnkgPSBtX2N1cnJlbnRCbG9jay0+ YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQsIHBvaW50ZXJUeXBlKCksIE9yaWdp bigpLCBtX2luc3RhbmNlVmFsdWUsIEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZNZW1v cnkoKSk7Ci0gICAgVmFsdWUqIHdhc21NZW1vcnkgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3 PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQsIHBvaW50ZXJUeXBlKCksIE9yaWdpbigpLCBqc01l bW9yeSwgSlNXZWJBc3NlbWJseU1lbW9yeTo6b2Zmc2V0T2ZNZW1vcnkoKSk7Ci0gICAgVmFsdWUq IHNpemUgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExv YWQsIEIzOjpJbnQ2NCwgT3JpZ2luKCksIHdhc21NZW1vcnksIE1lbW9yeTo6b2Zmc2V0T2ZTaXpl KCkpOworICAgIGF1dG8gbWVtb3J5VmFsdWUgPSBnZXRNZW1vcnlCYXNlQW5kU2l6ZShtX3ZtLCBt X2luc3RhbmNlVmFsdWUsIG1fcHJvYywgbV9jdXJyZW50QmxvY2spOwogCiAgICAgY29uc3RleHBy IHVpbnQzMl90IHNoaWZ0VmFsdWUgPSAxNjsKICAgICBzdGF0aWNfYXNzZXJ0KFBhZ2VDb3VudDo6 cGFnZVNpemUgPT0gMSA8PCBzaGlmdFZhbHVlLCAiVGhpcyBtdXN0IGhvbGQgZm9yIHRoZSBjb2Rl IGJlbG93IHRvIGJlIGNvcnJlY3QuIik7CiAgICAgVmFsdWUqIG51bVBhZ2VzID0gbV9jdXJyZW50 QmxvY2stPmFwcGVuZE5ldzxWYWx1ZT4obV9wcm9jLCBaU2hyLCBPcmlnaW4oKSwKLSAgICAgICAg c2l6ZSwgbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxDb25zdDMyVmFsdWU+KG1fcHJvYywgT3Jp Z2luKCksIHNoaWZ0VmFsdWUpKTsKKyAgICAgICAgbWVtb3J5VmFsdWUuc2l6ZSwgbV9jdXJyZW50 QmxvY2stPmFwcGVuZE5ldzxDb25zdDMyVmFsdWU+KG1fcHJvYywgT3JpZ2luKCksIHNoaWZ0VmFs dWUpKTsKIAogICAgIHJlc3VsdCA9IG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8VmFsdWU+KG1f cHJvYywgVHJ1bmMsIE9yaWdpbigpLCBudW1QYWdlcyk7CiAKQEAgLTgzMiwyNiArODM5LDc1IEBA IGF1dG8gQjNJUkdlbmVyYXRvcjo6YWRkQ2FsbCh1aW50MzJfdCBmdW5jdGlvbkluZGV4LCBjb25z dCBTaWduYXR1cmUqIHNpZ25hdHVyZSwKICAgICBBU1NFUlQoc2lnbmF0dXJlLT5hcmd1bWVudENv dW50KCkgPT0gYXJncy5zaXplKCkpOwogCiAgICAgVHlwZSByZXR1cm5UeXBlID0gc2lnbmF0dXJl LT5yZXR1cm5UeXBlKCk7CisgICAgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+KiB1bmxp bmtlZFdhc21Ub1dhc21DYWxscyA9ICZtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzOwogCi0gICAg cmVzdWx0ID0gd2FzbUNhbGxpbmdDb252ZW50aW9uKCkuc2V0dXBDYWxsKG1fcHJvYywgbV9jdXJy ZW50QmxvY2ssIE9yaWdpbigpLCBhcmdzLCB0b0IzVHlwZShyZXR1cm5UeXBlKSwKLSAgICAgICAg WyZdIChQYXRjaHBvaW50VmFsdWUqIHBhdGNocG9pbnQpIHsKLSAgICAgICAgICAgIHBhdGNocG9p bnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKLSAgICAgICAgICAgIHBhdGNocG9pbnQt PmVmZmVjdHMucmVhZHNQaW5uZWQgPSB0cnVlOworICAgIGlmIChtX2luZm8uaXNJbXBvcnRlZEZ1 bmN0aW9uRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KSkgeworICAgICAgICAv LyBGSVhNRSBpbXBvcnRzIGNhbiBiZSBsaW5rZWQgaGVyZSwgaW5zdGVhZCBvZiBnZW5lcmF0aW5n IGEgcGF0Y2hwb2ludCwgYmVjYXVzZSBhbGwgaW1wb3J0IHN0dWJzIGFyZSBnZW5lcmF0ZWQgYmVm b3JlIEIzIGNvbXBpbGF0aW9uIHN0YXJ0cy4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTE2NjQ2MgorICAgICAgICBFeHByZXNzaW9uVHlwZSBmdW5jdGlvbkltcG9ydCA9 IG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KG1fcHJvYywgTG9hZCwgcG9p bnRlclR5cGUoKSwgT3JpZ2luKCksIG1faW5zdGFuY2VWYWx1ZSwgSlNXZWJBc3NlbWJseUluc3Rh bmNlOjpvZmZzZXRPZkltcG9ydEZ1bmN0aW9uKGZ1bmN0aW9uSW5kZXgpKTsKKyAgICAgICAgRXhw cmVzc2lvblR5cGUganNUeXBlT2ZJbXBvcnQgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PE1l bW9yeVZhbHVlPihtX3Byb2MsIExvYWQ4WiwgT3JpZ2luKCksIGZ1bmN0aW9uSW1wb3J0LCBKU0Nl bGw6OnR5cGVJbmZvVHlwZU9mZnNldCgpKTsKKyAgICAgICAgVmFsdWUqIGlzV2FzbUNhbGwgPSBt X2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PFZhbHVlPihtX3Byb2MsIEVxdWFsLCBPcmlnaW4oKSwg anNUeXBlT2ZJbXBvcnQsIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8Q29uc3QzMlZhbHVlPiht X3Byb2MsIE9yaWdpbigpLCBXZWJBc3NlbWJseUZ1bmN0aW9uVHlwZSkpOwogCi0gICAgICAgICAg ICBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4qIHVubGlua2VkV2FzbVRvV2FzbUNhbGxz ID0gJm1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHM7Ci0gICAgICAgICAgICBwYXRjaHBvaW50LT5z ZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0Nh bGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7Ci0g ICAgICAgICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93U2NyYXRj aChqaXQpOworICAgICAgICBCYXNpY0Jsb2NrKiBpc1dhc21CbG9jayA9IG1fcHJvYy5hZGRCbG9j aygpOworICAgICAgICBCYXNpY0Jsb2NrKiBpc0pTQmxvY2sgPSBtX3Byb2MuYWRkQmxvY2soKTsK KyAgICAgICAgQmFzaWNCbG9jayogY29udGludWF0aW9uID0gbV9wcm9jLmFkZEJsb2NrKCk7Cisg ICAgICAgIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXdDb250cm9sVmFsdWUobV9wcm9jLCBCMzo6 QnJhbmNoLCBPcmlnaW4oKSwgaXNXYXNtQ2FsbCwgRnJlcXVlbnRlZEJsb2NrKGlzV2FzbUJsb2Nr KSwgRnJlcXVlbnRlZEJsb2NrKGlzSlNCbG9jaykpOworCisgICAgICAgIFZhbHVlKiB3YXNtQ2Fs bFJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigpLnNldHVwQ2FsbChtX3Byb2MsIGlzV2Fz bUJsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0dXJuVHlwZSksCisgICAgICAgICAg ICBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkgeworICAgICAgICAgICAgICAgIHBh dGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBw YXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBw YXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlv bkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25Q YXJhbXMmKSB7CisgICAgICAgICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJV c2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJz OjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICAgICAgICAgICAgICBqaXQuYWRkTGlu a1Rhc2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4XSAoTGlu a0J1ZmZlciYgbGlua0J1ZmZlcikgeworICAgICAgICAgICAgICAgICAgICAgICAgdW5saW5rZWRX YXNtVG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZmZXIubG9jYXRpb25PZihjYWxsKSwgZnVu Y3Rpb25JbmRleCwgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbDo6VGFyZ2V0Ojp0b1dhc20gfSk7Cisg ICAgICAgICAgICAgICAgICAgIH0pOworICAgICAgICAgICAgICAgIH0pOworICAgICAgICAgICAg fSk7CisgICAgICAgIFVwc2lsb25WYWx1ZSogd2FzbUNhbGxSZXN1bHRVcHNpbG9uID0gcmV0dXJu VHlwZSA9PSBWb2lkID8gbnVsbHB0ciA6IGlzV2FzbUJsb2NrLT5hcHBlbmROZXc8VXBzaWxvblZh bHVlPihtX3Byb2MsIE9yaWdpbigpLCB3YXNtQ2FsbFJlc3VsdCk7CisgICAgICAgIGlzV2FzbUJs b2NrLT5hcHBlbmROZXdDb250cm9sVmFsdWUobV9wcm9jLCBKdW1wLCBPcmlnaW4oKSwgY29udGlu dWF0aW9uKTsKKworICAgICAgICBWYWx1ZSoganNDYWxsUmVzdWx0ID0gd2FzbUNhbGxpbmdDb252 ZW50aW9uKCkuc2V0dXBDYWxsKG1fcHJvYywgaXNKU0Jsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9C M1R5cGUocmV0dXJuVHlwZSksCisgICAgICAgICAgICBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0 Y2hwb2ludCkgeworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlu bmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlu bmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3Vu bGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQs IGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7CisgICAgICAgICAgICAgICAg ICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAg ICAgICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOwor ICAgICAgICAgICAgICAgICAgICBqaXQuYWRkTGlua1Rhc2soW3VubGlua2VkV2FzbVRvV2FzbUNh bGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZlcikgeworICAg ICAgICAgICAgICAgICAgICAgICAgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxp bmtCdWZmZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rpb25JbmRleCwgVW5saW5rZWRXYXNtVG9X YXNtQ2FsbDo6VGFyZ2V0Ojp0b0pTIH0pOworICAgICAgICAgICAgICAgICAgICB9KTsKKyAgICAg ICAgICAgICAgICB9KTsKKyAgICAgICAgICAgIH0pOworICAgICAgICBVcHNpbG9uVmFsdWUqIGpz Q2FsbFJlc3VsdFVwc2lsb24gPSByZXR1cm5UeXBlID09IFZvaWQgPyBudWxscHRyIDogaXNKU0Js b2NrLT5hcHBlbmROZXc8VXBzaWxvblZhbHVlPihtX3Byb2MsIE9yaWdpbigpLCBqc0NhbGxSZXN1 bHQpOworICAgICAgICBpc0pTQmxvY2stPmFwcGVuZE5ld0NvbnRyb2xWYWx1ZShtX3Byb2MsIEp1 bXAsIE9yaWdpbigpLCBjb250aW51YXRpb24pOwogCi0gICAgICAgICAgICAgICAgQ0NhbGxIZWxw ZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICBtX2N1cnJlbnRCbG9jayA9IGNv bnRpbnVhdGlvbjsKIAotICAgICAgICAgICAgICAgIGppdC5hZGRMaW5rVGFzayhbdW5saW5rZWRX YXNtVG9XYXNtQ2FsbHMsIGNhbGwsIGZ1bmN0aW9uSW5kZXhdIChMaW5rQnVmZmVyJiBsaW5rQnVm ZmVyKSB7Ci0gICAgICAgICAgICAgICAgICAgIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLT5hcHBl bmQoeyBsaW5rQnVmZmVyLmxvY2F0aW9uT2YoY2FsbCksIGZ1bmN0aW9uSW5kZXggfSk7CisgICAg ICAgIGlmIChyZXR1cm5UeXBlID09IFZvaWQpCisgICAgICAgICAgICByZXN1bHQgPSBudWxscHRy OworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIHJlc3VsdCA9IGNvbnRpbnVhdGlvbi0+YXBw ZW5kTmV3PFZhbHVlPihtX3Byb2MsIFBoaSwgdG9CM1R5cGUocmV0dXJuVHlwZSksIE9yaWdpbigp KTsKKyAgICAgICAgICAgIHdhc21DYWxsUmVzdWx0VXBzaWxvbi0+c2V0UGhpKHJlc3VsdCk7Cisg ICAgICAgICAgICBqc0NhbGxSZXN1bHRVcHNpbG9uLT5zZXRQaGkocmVzdWx0KTsKKyAgICAgICAg fQorCisgICAgICAgIC8vIFRoZSBjYWxsIGNvdWxkIGhhdmUgYmVlbiB0byBhbm90aGVyIFdlYkFz c2VtYmx5IGluc3RhbmNlLCBhbmQgLyBvciBjb3VsZCBoYXZlIG1vZGlmaWVkIG91ciBNZW1vcnku CisgICAgICAgIHJlc3RvcmVXZWJBc3NlbWJseUdsb2JhbFN0YXRlKG1fdm0sIG1faW5mby5tZW1v cnksIG1faW5zdGFuY2VWYWx1ZSwgbV9wcm9jLCBjb250aW51YXRpb24pOworICAgIH0gZWxzZSB7 CisgICAgICAgIHJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigpLnNldHVwQ2FsbChtX3By b2MsIG1fY3VycmVudEJsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0dXJuVHlwZSks CisgICAgICAgICAgICBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkgeworICAgICAg ICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKKyAgICAg ICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICAg ICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNh bGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21h cEdlbmVyYXRpb25QYXJhbXMmKSB7CisgICAgICAgICAgICAgICAgICAgIEFsbG93TWFjcm9TY3Jh dGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAgICAgICAgICAgICAg Q0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICAgICAgICAgICAg ICBqaXQuYWRkTGlua1Rhc2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlv bkluZGV4XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZlcikgeworICAgICAgICAgICAgICAgICAgICAg ICAgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZmZXIubG9jYXRpb25P ZihjYWxsKSwgZnVuY3Rpb25JbmRleCwgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbDo6VGFyZ2V0Ojp0 b1dhc20gfSk7CisgICAgICAgICAgICAgICAgICAgIH0pOwogICAgICAgICAgICAgICAgIH0pOwog ICAgICAgICAgICAgfSk7Ci0gICAgICAgIH0pOwotCi0gICAgaWYgKGZ1bmN0aW9uSW5kZXggPCBt X2luZm8uaW1wb3J0RnVuY3Rpb25Db3VudCgpKQotICAgICAgICBlbWl0UmVsb2FkUGlubmVkUmVn aXN0ZXJzKCk7CisgICAgfQogCiAgICAgcmV0dXJuIHsgfTsKIH0KQEAgLTkyOSw3ICs5ODUsOCBA QCBhdXRvIEIzSVJHZW5lcmF0b3I6OmFkZENhbGxJbmRpcmVjdChjb25zdCBTaWduYXR1cmUqIHNp Z25hdHVyZSwgU2lnbmF0dXJlSW5kZXggcwogICAgICAgICAgICAgfSk7CiAgICAgICAgIH0pOwog Ci0gICAgZW1pdFJlbG9hZFBpbm5lZFJlZ2lzdGVycygpOworICAgIC8vIFRoZSBjYWxsIGNvdWxk IGhhdmUgYmVlbiB0byBhbm90aGVyIFdlYkFzc2VtYmx5IGluc3RhbmNlLCBhbmQgLyBvciBjb3Vs ZCBoYXZlIG1vZGlmaWVkIG91ciBNZW1vcnkuCisgICAgcmVzdG9yZVdlYkFzc2VtYmx5R2xvYmFs U3RhdGUobV92bSwgbV9pbmZvLm1lbW9yeSwgbV9pbnN0YW5jZVZhbHVlLCBtX3Byb2MsIG1fY3Vy cmVudEJsb2NrKTsKIAogICAgIHJldHVybiB7IH07CiB9CkBAIC05OTgsMTIgKzEwNTUsMTAgQEAg c3RhdGljIHZvaWQgY3JlYXRlSlNUb1dhc21XcmFwcGVyKFZNJiB2bSwgQ29tcGlsYXRpb25Db250 ZXh0JiBjb21waWxhdGlvbkNvbnRleHQKICAgICAgICAgfSk7CiAgICAgfQogCi0gICAgLy8gTW92 ZSBtZW1vcnkgdmFsdWVzIHRvIHRoZSBhcHByb3JpYXRlIHBsYWNlcywgaWYgbmVlZGVkLgotICAg IHsKLSAgICAgICAgVmFsdWUqIGluc3RhbmNlID0gYmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1 ZT4ocHJvYywgTG9hZCwgcG9pbnRlclR5cGUoKSwgT3JpZ2luKCksCi0gICAgICAgICAgICBibG9j ay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KHByb2MsIE9yaWdpbigpLCAmdm0udG9wSlNXZWJB c3NlbWJseUluc3RhbmNlKSk7Ci0gICAgICAgIHJlbG9hZFBpbm5lZFJlZ2lzdGVycyhwcm9jLCBi bG9jaywgaW5mbywgaW5zdGFuY2UpOwotICAgIH0KKyAgICAvLyBGSVhNRSBUaGUgaW5zdGFuY2Ug aXMgY3VycmVudGx5IHNldCBieSB0aGUgQysrIGNvZGUgaW4gV2ViQXNzZW1ibHlGdW5jdGlvbjo6 Y2FsbC4gV2Ugc2hvdWxkbid0IGdvIHRocm91Z2ggdGhlIGV4dHJhIEMrKyBob29wLiBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY2NDg2CisgICAgVmFsdWUqIGluc3Rh bmNlID0gYmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4ocHJvYywgTG9hZCwgcG9pbnRlclR5 cGUoKSwgT3JpZ2luKCksCisgICAgICAgIGJsb2NrLT5hcHBlbmROZXc8Q29uc3RQdHJWYWx1ZT4o cHJvYywgT3JpZ2luKCksICZ2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UpKTsKKyAgICByZXN0 b3JlV2ViQXNzZW1ibHlHbG9iYWxTdGF0ZSh2bSwgaW5mby5tZW1vcnksIGluc3RhbmNlLCBwcm9j LCBibG9jayk7CiAKICAgICAvLyBHZXQgb3VyIGFyZ3VtZW50cy4KICAgICBWZWN0b3I8VmFsdWUq PiBhcmd1bWVudHM7CkBAIC0xMDQ2LDcgKzExMDEsNyBAQCBzdGF0aWMgdm9pZCBjcmVhdGVKU1Rv V2FzbVdyYXBwZXIoVk0mIHZtLCBDb21waWxhdGlvbkNvbnRleHQmIGNvbXBpbGF0aW9uQ29udGV4 dAogICAgIGZ1bmN0aW9uLmpzVG9XYXNtRW50cnlwb2ludC5jYWxsZWVTYXZlUmVnaXN0ZXJzID0g cHJvYy5jYWxsZWVTYXZlUmVnaXN0ZXJzKCk7CiB9CiAKLUV4cGVjdGVkPHN0ZDo6dW5pcXVlX3B0 cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0cmluZz4gcGFyc2VBbmRDb21waWxlKFZNJiB2bSwg Q29tcGlsYXRpb25Db250ZXh0JiBjb21waWxhdGlvbkNvbnRleHQsIGNvbnN0IHVpbnQ4X3QqIGZ1 bmN0aW9uU3RhcnQsIHNpemVfdCBmdW5jdGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiBzaWdu YXR1cmUsIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYgdW5saW5rZWRXYXNtVG9XYXNt Q2FsbHMsIGNvbnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYgZnVuY3Rpb25JbmRleFNw YWNlLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgdW5zaWduZWQgb3B0TGV2ZWwpCitF eHBlY3RlZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbUludGVybmFsRnVuY3Rpb24+LCBTdHJpbmc+IHBh cnNlQW5kQ29tcGlsZShWTSYgdm0sIENvbXBpbGF0aW9uQ29udGV4dCYgY29tcGlsYXRpb25Db250 ZXh0LCBjb25zdCB1aW50OF90KiBmdW5jdGlvblN0YXJ0LCBzaXplX3QgZnVuY3Rpb25MZW5ndGgs IGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2Fs bD4mIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5m bywgY29uc3QgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiYgbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1Rv VW5pcXVlZFNpZ25hdHVyZUluZGljZXMsIHVuc2lnbmVkIG9wdExldmVsKQogewogICAgIGF1dG8g cmVzdWx0ID0gc3RkOjptYWtlX3VuaXF1ZTxXYXNtSW50ZXJuYWxGdW5jdGlvbj4oKTsKIApAQCAt MTA1NCw4ICsxMTA5LDggQEAgRXhwZWN0ZWQ8c3RkOjp1bmlxdWVfcHRyPFdhc21JbnRlcm5hbEZ1 bmN0aW9uPiwgU3RyaW5nPiBwYXJzZUFuZENvbXBpbGUoVk0mIHZtLAogICAgIGNvbXBpbGF0aW9u Q29udGV4dC53YXNtRW50cnlwb2ludEpJVCA9IHN0ZDo6bWFrZV91bmlxdWU8Q0NhbGxIZWxwZXJz Pigmdm0pOwogCiAgICAgUHJvY2VkdXJlIHByb2NlZHVyZTsKLSAgICBCM0lSR2VuZXJhdG9yIGNv bnRleHQodm0sIGluZm8sIHByb2NlZHVyZSwgcmVzdWx0LmdldCgpLCB1bmxpbmtlZFdhc21Ub1dh c21DYWxscywgZnVuY3Rpb25JbmRleFNwYWNlKTsKLSAgICBGdW5jdGlvblBhcnNlcjxCM0lSR2Vu ZXJhdG9yPiBwYXJzZXIoJnZtLCBjb250ZXh0LCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0 aCwgc2lnbmF0dXJlLCBmdW5jdGlvbkluZGV4U3BhY2UsIGluZm8pOworICAgIEIzSVJHZW5lcmF0 b3IgY29udGV4dCh2bSwgaW5mbywgcHJvY2VkdXJlLCByZXN1bHQuZ2V0KCksIHVubGlua2VkV2Fz bVRvV2FzbUNhbGxzKTsKKyAgICBGdW5jdGlvblBhcnNlcjxCM0lSR2VuZXJhdG9yPiBwYXJzZXIo JnZtLCBjb250ZXh0LCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBp bmZvLCBtb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcyk7CiAg ICAgV0FTTV9GQUlMX0lGX0hFTFBFUl9GQUlMUyhwYXJzZXIucGFyc2UoKSk7CiAKICAgICBwcm9j ZWR1cmUucmVzZXRSZWFjaGFiaWxpdHkoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtQjNJUkdlbmVyYXRvci5oCmluZGV4IGI1YzlmNDYuLjI0OWQ1NzggMTAwNjQ0Ci0tLSBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmgKKysrIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuaApAQCAtNDcsNyArNDcs NyBAQCBzdHJ1Y3QgQ29tcGlsYXRpb25Db250ZXh0IHsKICAgICBDQ2FsbEhlbHBlcnM6OkNhbGwg anNFbnRyeXBvaW50VG9XYXNtRW50cnlwb2ludENhbGw7CiB9OwogCi1FeHBlY3RlZDxzdGQ6OnVu aXF1ZV9wdHI8V2FzbUludGVybmFsRnVuY3Rpb24+LCBTdHJpbmc+IHBhcnNlQW5kQ29tcGlsZShW TSYsIENvbXBpbGF0aW9uQ29udGV4dCYsIGNvbnN0IHVpbnQ4X3QqLCBzaXplX3QsIGNvbnN0IFNp Z25hdHVyZSosIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYsIGNvbnN0IEltbXV0YWJs ZUZ1bmN0aW9uSW5kZXhTcGFjZSYsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiwgdW5zaWduZWQg b3B0TGV2ZWwgPSAxKTsKK0V4cGVjdGVkPHN0ZDo6dW5pcXVlX3B0cjxXYXNtSW50ZXJuYWxGdW5j dGlvbj4sIFN0cmluZz4gcGFyc2VBbmRDb21waWxlKFZNJiwgQ29tcGlsYXRpb25Db250ZXh0Jiwg Y29uc3QgdWludDhfdCosIHNpemVfdCwgY29uc3QgU2lnbmF0dXJlKiwgVmVjdG9yPFVubGlua2Vk V2FzbVRvV2FzbUNhbGw+JiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mLCBjb25zdCBWZWN0b3I8 U2lnbmF0dXJlSW5kZXg+JiwgdW5zaWduZWQgb3B0TGV2ZWwgPSAxKTsKIAogfSB9IC8vIG5hbWVz cGFjZSBKU0M6Oldhc20KIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbUJpbmRpbmcuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcu Y3BwCmluZGV4IDBlNTkyNDcuLjliYjZhNzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21CaW5kaW5nLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtQmluZGluZy5jcHAKQEAgLTM2LDEzICszNiwyMSBAQAogCiBuYW1lc3BhY2UgSlNDIHsg bmFtZXNwYWNlIFdhc20gewogCi1XYXNtVG9KU1N0dWIgaW1wb3J0U3R1YkdlbmVyYXRvcihWTSog dm0sIEJhZzxDYWxsTGlua0luZm8+JiBjYWxsTGlua0luZm9zLCBTaWduYXR1cmVJbmRleCBzaWdu YXR1cmVJbmRleCwgdW5zaWduZWQgaW1wb3J0SW5kZXgpCit0eXBlZGVmIEFzc2VtYmx5SGVscGVy cyBKSVQ7CisKK3N0YXRpYyB2b2lkIG1hdGVyaWFsaXplSW1wb3J0SlNDZWxsKFZNKiB2bSwgSklU JiBqaXQsIHVuc2lnbmVkIGltcG9ydEluZGV4LCBHUFJSZWcgZ3ByKQoreworICAgIC8vIEVhY2gg SlMgLT4gd2FzbSBlbnRyeSBzZXRzIHRoZSBXZWJBc3NlbWJseS5JbnN0YW5jZSB3aG9zZSBleHBv cnQgaXMgYmVpbmcgY2FsbGVkLiBXZSdyZSBjYWxsaW5nIG91dCBvZiB0aGlzIEluc3RhbmNlLCBh bmQgY2FuIHRoZXJlZm9yZSBmaWd1cmUgb3V0IHRoZSBpbXBvcnQgYmVpbmcgY2FsbGVkLgorICAg IGppdC5sb2FkUHRyKCZ2bS0+dG9wSlNXZWJBc3NlbWJseUluc3RhbmNlLCBncHIpOworICAgIGpp dC5sb2FkUHRyKEpJVDo6QWRkcmVzcyhncHIsIEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0 T2ZJbXBvcnRGdW5jdGlvbihpbXBvcnRJbmRleCkpLCBncHIpOworfQorCitzdGF0aWMgTWFjcm9B c3NlbWJsZXJDb2RlUmVmIHdhc21Ub0pTKFZNKiB2bSwgQmFnPENhbGxMaW5rSW5mbz4mIGNhbGxM aW5rSW5mb3MsIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4LCB1bnNpZ25lZCBpbXBvcnRJ bmRleCkKIHsKICAgICBjb25zdCBXYXNtQ2FsbGluZ0NvbnZlbnRpb24mIHdhc21DQyA9IHdhc21D YWxsaW5nQ29udmVudGlvbigpOwogICAgIGNvbnN0IEpTQ0NhbGxpbmdDb252ZW50aW9uJiBqc0ND ID0ganNjQ2FsbGluZ0NvbnZlbnRpb24oKTsKICAgICBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVy ZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQodm0sIHNpZ25hdHVyZUluZGV4KTsKICAgICB1 bnNpZ25lZCBhcmdDb3VudCA9IHNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpOwotICAgIHR5cGVk ZWYgQXNzZW1ibHlIZWxwZXJzIEpJVDsKICAgICBKSVQgaml0KHZtLCBudWxscHRyKTsKIAogICAg IC8vIEJlbG93LCB3ZSBhc3N1bWUgdGhhdCB0aGUgSlMgY2FsbGluZyBjb252ZW50aW9uIGlzIGFs d2F5cyBvbiB0aGUgc3RhY2suCkBAIC0xMzgsOSArMTQ2LDcgQEAgV2FzbVRvSlNTdHViIGltcG9y dFN0dWJHZW5lcmF0b3IoVk0qIHZtLCBCYWc8Q2FsbExpbmtJbmZvPiYgY2FsbExpbmtJbmZvcywg U2lnbmEKICAgICBHUFJSZWcgaW1wb3J0SlNDZWxsR1BSUmVnID0gR1BSSW5mbzo6cmVnVDA7IC8v IENhbGxlZSBuZWVkcyB0byBiZSBpbiByZWdUMCBmb3Igc2xvdyBwYXRoIGJlbG93LgogICAgIEFT U0VSVCghd2FzbUNDLm1fY2FsbGVlU2F2ZVJlZ2lzdGVycy5nZXQoaW1wb3J0SlNDZWxsR1BSUmVn KSk7CiAKLSAgICAvLyBFYWNoIEpTIC0+IHdhc20gZW50cnkgc2V0cyB0aGUgV2ViQXNzZW1ibHku SW5zdGFuY2Ugd2hvc2UgZXhwb3J0IGlzIGJlaW5nIGNhbGxlZC4gV2UncmUgY2FsbGluZyBvdXQg b2YgdGhpcyBJbnN0YW5jZSwgYW5kIGNhbiB0aGVyZWZvcmUgZmlndXJlIG91dCB0aGUgaW1wb3J0 IGJlaW5nIGNhbGxlZC4KLSAgICBqaXQubG9hZFB0cigmdm0tPnRvcEpTV2ViQXNzZW1ibHlJbnN0 YW5jZSwgaW1wb3J0SlNDZWxsR1BSUmVnKTsKLSAgICBqaXQubG9hZFB0cihKSVQ6OkFkZHJlc3Mo aW1wb3J0SlNDZWxsR1BSUmVnLCBKU1dlYkFzc2VtYmx5SW5zdGFuY2U6Om9mZnNldE9mSW1wb3J0 RnVuY3Rpb24oaW1wb3J0SW5kZXgpKSwgaW1wb3J0SlNDZWxsR1BSUmVnKTsKKyAgICBtYXRlcmlh bGl6ZUltcG9ydEpTQ2VsbCh2bSwgaml0LCBpbXBvcnRJbmRleCwgaW1wb3J0SlNDZWxsR1BSUmVn KTsKIAogICAgIHVpbnQ2NF90IHRoaXNBcmd1bWVudCA9IFZhbHVlVW5kZWZpbmVkOyAvLyBGSVhN RSB3aGF0IGRvZXMgdGhlIFdlYkFzc2VtYmx5IHNwZWMgc2F5IHRoaXMgc2hvdWxkIGJlPyBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1NDcxCiAgICAgaml0LnN0b3Jl NjQoaW1wb3J0SlNDZWxsR1BSUmVnLCBjYWxsZWVGcmFtZS53aXRoT2Zmc2V0KENhbGxGcmFtZVNs b3Q6OmNhbGxlZSAqIHN0YXRpY19jYXN0PGludD4oc2l6ZW9mKFJlZ2lzdGVyKSkpKTsKQEAgLTIz MSw3ICsyMzcsNTYgQEAgV2FzbVRvSlNTdHViIGltcG9ydFN0dWJHZW5lcmF0b3IoVk0qIHZtLCBC YWc8Q2FsbExpbmtJbmZvPiYgY2FsbExpbmtJbmZvcywgU2lnbmEKICAgICBDb2RlTG9jYXRpb25M YWJlbCBob3RQYXRoQmVnaW4ocGF0Y2hCdWZmZXIubG9jYXRpb25PZih0YXJnZXRUb0NoZWNrKSk7 CiAgICAgQ29kZUxvY2F0aW9uTmVhckNhbGwgaG90UGF0aE90aGVyID0gcGF0Y2hCdWZmZXIubG9j YXRpb25PZk5lYXJDYWxsKGZhc3RDYWxsKTsKICAgICBjYWxsTGlua0luZm8tPnNldENhbGxMb2Nh dGlvbnMoY2FsbFJldHVybkxvY2F0aW9uLCBob3RQYXRoQmVnaW4sIGhvdFBhdGhPdGhlcik7Ci0g ICAgcmV0dXJuIEZJTkFMSVpFX0NPREUocGF0Y2hCdWZmZXIsICgiV2ViQXNzZW1ibHkgaW1wb3J0 WyVpXSBzdHViIGZvciBzaWduYXR1cmUgJWkiLCBpbXBvcnRJbmRleCwgc2lnbmF0dXJlSW5kZXgp KTsKKyAgICBTdHJpbmcgc2lnbmF0dXJlRGVzY3JpcHRpb24gPSBTaWduYXR1cmVJbmZvcm1hdGlv bjo6Z2V0KHZtLCBzaWduYXR1cmVJbmRleCktPnRvU3RyaW5nKCk7CisgICAgcmV0dXJuIEZJTkFM SVpFX0NPREUocGF0Y2hCdWZmZXIsICgiV2ViQXNzZW1ibHktPkphdmFTY3JpcHQgaW1wb3J0WyVp XSAlcyIsIGltcG9ydEluZGV4LCBzaWduYXR1cmVEZXNjcmlwdGlvbi5hc2NpaSgpLmRhdGEoKSkp OworfQorCitzdGF0aWMgTWFjcm9Bc3NlbWJsZXJDb2RlUmVmIHdhc21Ub1dhc20oVk0qIHZtLCB1 bnNpZ25lZCBpbXBvcnRJbmRleCkKK3sKKyAgICBjb25zdCBQaW5uZWRSZWdpc3RlckluZm8mIHBp bm5lZFJlZ3MgPSBQaW5uZWRSZWdpc3RlckluZm86OmdldCgpOworICAgIEpJVCBqaXQodm0sIG51 bGxwdHIpOworCisgICAgR1BSUmVnIHNjcmF0Y2ggPSBHUFJJbmZvOjpub25QcmVzZXJ2ZWROb25B cmd1bWVudEdQUjsKKworICAgIC8vIEIzJ3MgY2FsbCBjb2RlZ2VuIGVuc3VyZXMgdGhhdCB0aGUg SlNDZWxsIGlzIGEgV2ViQXNzZW1ibHlGdW5jdGlvbi4KKyAgICBtYXRlcmlhbGl6ZUltcG9ydEpT Q2VsbCh2bSwgaml0LCBpbXBvcnRJbmRleCwgc2NyYXRjaCk7CisKKyAgICAvLyBHZXQgdGhlIGNh bGxlZSdzIFdlYkFzc2VtYmx5Lkluc3RhbmNlIGFuZCBzZXQgaXQgYXMgdm0udG9wSlNXZWJBc3Nl bWJseUluc3RhbmNlLiBUaGUgY2FsbGVyIHdpbGwgdGFrZSBjYXJlIG9mIHJlc3RvcmluZyBpdHMg b3duIEluc3RhbmNlLgorICAgIEdQUlJlZyBiYXNlTWVtb3J5ID0gcGlubmVkUmVncy5iYXNlTWVt b3J5UG9pbnRlcjsKKyAgICBBU1NFUlQoYmFzZU1lbW9yeSAhPSBzY3JhdGNoKTsKKyAgICBqaXQu bG9hZFB0cihKSVQ6OkFkZHJlc3Moc2NyYXRjaCwgV2ViQXNzZW1ibHlGdW5jdGlvbjo6b2Zmc2V0 T2ZJbnN0YW5jZSgpKSwgYmFzZU1lbW9yeSk7IC8vIEluc3RhbmNlKi4KKyAgICBqaXQuc3RvcmVQ dHIoYmFzZU1lbW9yeSwgJnZtLT50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UpOworCisgICAgLy8g RklYTUUgdGhlIGZvbGxvd2luZyBjb2RlIGFzc3VtZXMgdGhhdCBhbGwgV2ViQXNzZW1ibHkuSW5z dGFuY2UgaGF2ZSB0aGUgc2FtZSBwaW5uZWQgcmVnaXN0ZXJzLiBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYyOTUyCisgICAgLy8gU2V0IHVwIHRoZSBjYWxsZWUncyBi YXNlTWVtb3J5IHJlZ2lzdGVyIGFzIHdlbGwgYXMgdGhlIG1lbW9yeSBzaXplIHJlZ2lzdGVycy4K KyAgICBqaXQubG9hZFB0cihKSVQ6OkFkZHJlc3MoYmFzZU1lbW9yeSwgSlNXZWJBc3NlbWJseUlu c3RhbmNlOjpvZmZzZXRPZk1lbW9yeSgpKSwgYmFzZU1lbW9yeSk7IC8vIEpTV2ViQXNzZW1ibHlN ZW1vcnkqLgorICAgIGNvbnN0IGF1dG8mIHNpemVSZWdzID0gcGlubmVkUmVncy5zaXplUmVnaXN0 ZXJzOworICAgIEFTU0VSVChzaXplUmVncy5zaXplKCkgPj0gMSk7CisgICAgQVNTRVJUKHNpemVS ZWdzWzBdLnNpemVSZWdpc3RlciAhPSBiYXNlTWVtb3J5KTsKKyAgICBBU1NFUlQoc2l6ZVJlZ3Nb MF0uc2l6ZVJlZ2lzdGVyICE9IHNjcmF0Y2gpOworICAgIEFTU0VSVCghc2l6ZVJlZ3NbMF0uc2l6 ZU9mZnNldCk7IC8vIFRoZSBmb2xsb3dpbmcgY29kZSBhc3N1bWVzIHdlIHN0YXJ0IGF0IDAsIGFu ZCBjYWxjdWxhdGVzIHN1YnNlcXVlbnQgc2l6ZSByZWdpc3RlcnMgcmVsYXRpdmUgdG8gMC4KKyAg ICBqaXQubG9hZFB0cihKSVQ6OkFkZHJlc3MoYmFzZU1lbW9yeSwgSlNXZWJBc3NlbWJseU1lbW9y eTo6b2Zmc2V0T2ZTaXplKCkpLCBzaXplUmVnc1swXS5zaXplUmVnaXN0ZXIpOyAvLyBNZW1vcnkg c2l6ZS4KKyAgICBqaXQubG9hZFB0cihKSVQ6OkFkZHJlc3MoYmFzZU1lbW9yeSwgSlNXZWJBc3Nl bWJseU1lbW9yeTo6b2Zmc2V0T2ZNZW1vcnkoKSksIGJhc2VNZW1vcnkpOyAvLyBXYXNtTWVtb3J5 Ojp2b2lkKi4KKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAxOyBpIDwgc2l6ZVJlZ3Muc2l6ZSgpOyAr K2kpIHsKKyAgICAgICAgQVNTRVJUKHNpemVSZWdzW2ldLnNpemVSZWdpc3RlciAhPSBiYXNlTWVt b3J5KTsKKyAgICAgICAgQVNTRVJUKHNpemVSZWdzW2ldLnNpemVSZWdpc3RlciAhPSBzY3JhdGNo KTsKKyAgICAgICAgaml0LmFkZDY0KEpJVDo6VHJ1c3RlZEltbTMyKC1zaXplUmVnc1tpXS5zaXpl T2Zmc2V0KSwgc2l6ZVJlZ3NbMF0uc2l6ZVJlZ2lzdGVyLCBzaXplUmVnc1sxXS5zaXplUmVnaXN0 ZXIpOworICAgIH0KKworICAgIC8vIFRhaWwgY2FsbCBpbnRvIHRoZSBjYWxsZWUgV2ViQXNzZW1i bHkgZnVuY3Rpb24uCisgICAgaml0LmxvYWRQdHIoSklUOjpBZGRyZXNzKHNjcmF0Y2gsIFdlYkFz c2VtYmx5RnVuY3Rpb246Om9mZnNldE9mV2FzbUVudHJ5UG9pbnRDb2RlKCkpLCBzY3JhdGNoKTsK KyAgICBqaXQuanVtcChzY3JhdGNoKTsKKworICAgIExpbmtCdWZmZXIgcGF0Y2hCdWZmZXIoKnZt LCBqaXQsIEdMT0JBTF9USFVOS19JRCk7CisgICAgcmV0dXJuIEZJTkFMSVpFX0NPREUocGF0Y2hC dWZmZXIsICgiV2ViQXNzZW1ibHktPldlYkFzc2VtYmx5IGltcG9ydFslaV0iLCBpbXBvcnRJbmRl eCkpOworfQorCitXYXNtRXhpdFN0dWJzIGV4aXRTdHViR2VuZXJhdG9yKFZNKiB2bSwgQmFnPENh bGxMaW5rSW5mbz4mIGNhbGxMaW5rSW5mb3MsIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4 LCB1bnNpZ25lZCBpbXBvcnRJbmRleCkKK3sKKyAgICBXYXNtRXhpdFN0dWJzIHN0dWJzOworICAg IHN0dWJzLndhc21Ub0pTID0gd2FzbVRvSlModm0sIGNhbGxMaW5rSW5mb3MsIHNpZ25hdHVyZUlu ZGV4LCBpbXBvcnRJbmRleCk7CisgICAgc3R1YnMud2FzbVRvV2FzbSA9IHdhc21Ub1dhc20odm0s IGltcG9ydEluZGV4KTsKKyAgICByZXR1cm4gc3R1YnM7CiB9CiAKIH0gfSAvLyBuYW1lc3BhY2Ug SlNDOjpXYXNtCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQmlu ZGluZy5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuaAppbmRleCBm ZDdlMDNkLi40MDIxZjE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9X YXNtQmluZGluZy5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5n LmgKQEAgLTM4LDcgKzM4LDcgQEAgY2xhc3MgQ2FsbExpbmtJbmZvOwogCiBuYW1lc3BhY2UgV2Fz bSB7CiAKLVdhc21Ub0pTU3R1YiBpbXBvcnRTdHViR2VuZXJhdG9yKFZNKiwgQmFnPENhbGxMaW5r SW5mbz4mLCBTaWduYXR1cmVJbmRleCwgdW5zaWduZWQpOworV2FzbUV4aXRTdHVicyBleGl0U3R1 YkdlbmVyYXRvcihWTSosIEJhZzxDYWxsTGlua0luZm8+JiwgU2lnbmF0dXJlSW5kZXgsIHVuc2ln bmVkKTsKIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KIApkaWZmIC0tZ2l0IGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZvcm1hdC5oIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbUZvcm1hdC5oCmluZGV4IGNiMmJlNTUuLjIzZDhlZDMgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Gb3JtYXQuaAorKysgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtRm9ybWF0LmgKQEAgLTIyMiw3ICsyMjIsNiBAQCBwcml2YXRlOgog fTsKIAogc3RydWN0IE1vZHVsZUluZm9ybWF0aW9uIHsKLSAgICBWZWN0b3I8U2lnbmF0dXJlSW5k ZXg+IHNpZ25hdHVyZUluZGljZXM7CiAgICAgVmVjdG9yPEltcG9ydD4gaW1wb3J0czsKICAgICBW ZWN0b3I8U2lnbmF0dXJlSW5kZXg+IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlczsKICAg ICBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+IGludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2Vz OwpAQCAtMjM2LDYgKzIzNSwxOCBAQCBzdHJ1Y3QgTW9kdWxlSW5mb3JtYXRpb24gewogICAgIFRh YmxlSW5mb3JtYXRpb24gdGFibGVJbmZvcm1hdGlvbjsKICAgICBWZWN0b3I8R2xvYmFsPiBnbG9i YWxzOwogICAgIHVuc2lnbmVkIGZpcnN0SW50ZXJuYWxHbG9iYWwgeyAwIH07CisgICAgc2l6ZV90 IGZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSBjb25zdCB7IHJldHVybiBpbXBvcnRGdW5jdGlvblNp Z25hdHVyZUluZGljZXMuc2l6ZSgpICsgaW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXMu c2l6ZSgpOyB9CisgICAgYm9vbCBpc0ltcG9ydGVkRnVuY3Rpb25Gcm9tRnVuY3Rpb25JbmRleFNw YWNlKHNpemVfdCBmdW5jdGlvbkluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgQVNTRVJUKGZ1 bmN0aW9uSW5kZXggPCBmdW5jdGlvbkluZGV4U3BhY2VTaXplKCkpOworICAgICAgICByZXR1cm4g ZnVuY3Rpb25JbmRleCA8IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCk7Cisg ICAgfQorICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhT cGFjZShzaXplX3QgZnVuY3Rpb25JbmRleCkgY29uc3QKKyAgICB7CisgICAgICAgIHJldHVybiBp c0ltcG9ydGVkRnVuY3Rpb25Gcm9tRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgpCisg ICAgICAgICAgICA/IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4 XQorICAgICAgICAgICAgOiBpbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlv bkluZGV4IC0gaW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnNpemUoKV07CisgICAgfQog CiAgICAgdWludDMyX3QgaW1wb3J0RnVuY3Rpb25Db3VudCgpIGNvbnN0IHsgcmV0dXJuIGltcG9y dEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCk7IH0KICAgICBib29sIGhhc01lbW9yeSgp IGNvbnN0IHsgcmV0dXJuICEhbWVtb3J5OyB9CkBAIC0yNDYsNiArMjU3LDEwIEBAIHN0cnVjdCBN b2R1bGVJbmZvcm1hdGlvbiB7CiBzdHJ1Y3QgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbCB7CiAgICAg Q29kZUxvY2F0aW9uQ2FsbCBjYWxsTG9jYXRpb247CiAgICAgc2l6ZV90IGZ1bmN0aW9uSW5kZXg7 CisgICAgZW51bSBjbGFzcyBUYXJnZXQgOiB1aW50OF90IHsKKyAgICAgICAgdG9KUywKKyAgICAg ICAgdG9XYXNtLAorICAgIH0gdGFyZ2V0OwogfTsKIAogc3RydWN0IEVudHJ5cG9pbnQgewpAQCAt MjYxLDcgKzI3NiwxMCBAQCBzdHJ1Y3QgV2FzbUludGVybmFsRnVuY3Rpb24gewogICAgIEVudHJ5 cG9pbnQganNUb1dhc21FbnRyeXBvaW50OwogfTsKIAotdHlwZWRlZiBNYWNyb0Fzc2VtYmxlckNv ZGVSZWYgV2FzbVRvSlNTdHViOworc3RydWN0IFdhc21FeGl0U3R1YnMgeworICAgIE1hY3JvQXNz ZW1ibGVyQ29kZVJlZiB3YXNtVG9KUzsKKyAgICBNYWNyb0Fzc2VtYmxlckNvZGVSZWYgd2FzbVRv V2FzbTsKK307CiAKIC8vIFdlYkFzc2VtYmx5IGRpcmVjdCBjYWxscyBhbmQgY2FsbF9pbmRpcmVj dCB1c2UgaW5kaWNlcyBpbnRvICJmdW5jdGlvbiBpbmRleCBzcGFjZSIuIFRoaXMgc3BhY2Ugc3Rh cnRzIHdpdGggYWxsIGltcG9ydHMsIGFuZCB0aGVuIGFsbCBpbnRlcm5hbCBmdW5jdGlvbnMuCiAv LyBDYWxsYWJsZUZ1bmN0aW9uIGFuZCBGdW5jdGlvbkluZGV4U3BhY2UgYXJlIG9ubHkgbWVhbnQg YXMgZmFzdCBsb29rdXAgdGFibGVzIGZvciB0aGVzZSBvcGNvZGVzLCBhbmQgZG8gbm90IG93biBj b2RlLgpAQCAtMjgwLDEyICsyOTgsNiBAQCBzdHJ1Y3QgQ2FsbGFibGVGdW5jdGlvbiB7CiB9Owog dHlwZWRlZiBWZWN0b3I8Q2FsbGFibGVGdW5jdGlvbj4gRnVuY3Rpb25JbmRleFNwYWNlOwogCi0K LXN0cnVjdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UgewotICAgIE1hbGxvY1B0cjxDYWxs YWJsZUZ1bmN0aW9uPiBidWZmZXI7Ci0gICAgc2l6ZV90IHNpemU7Ci19OwotCiB9IH0gLy8gbmFt ZXNwYWNlIEpTQzo6V2FzbQogCiAjZW5kaWYgLy8gRU5BQkxFKFdFQkFTU0VNQkxZKQpkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmggYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rpb25QYXJzZXIuaAppbmRleCA1MjAx MGRjLi4zMTEwNWQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt RnVuY3Rpb25QYXJzZXIuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVu Y3Rpb25QYXJzZXIuaApAQCAtNDYsNyArNDYsNyBAQCBwdWJsaWM6CiAgICAgdHlwZWRlZiB0eXBl bmFtZSBDb250ZXh0OjpDb250cm9sVHlwZSBDb250cm9sVHlwZTsKICAgICB0eXBlZGVmIHR5cGVu YW1lIENvbnRleHQ6OkV4cHJlc3Npb25MaXN0IEV4cHJlc3Npb25MaXN0OwogCi0gICAgRnVuY3Rp b25QYXJzZXIoVk0qLCBDb250ZXh0JiwgY29uc3QgdWludDhfdCogZnVuY3Rpb25TdGFydCwgc2l6 ZV90IGZ1bmN0aW9uTGVuZ3RoLCBjb25zdCBTaWduYXR1cmUqLCBjb25zdCBJbW11dGFibGVGdW5j dGlvbkluZGV4U3BhY2UmLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYpOworICAgIEZ1bmN0aW9u UGFyc2VyKFZNKiwgQ29udGV4dCYsIGNvbnN0IHVpbnQ4X3QqIGZ1bmN0aW9uU3RhcnQsIHNpemVf dCBmdW5jdGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiwgY29uc3QgTW9kdWxlSW5mb3JtYXRp b24mLCBjb25zdCBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+Jik7CiAKICAgICBSZXN1bHQgV0FSTl9V TlVTRURfUkVUVVJOIHBhcnNlKCk7CiAKQEAgLTgyLDE4ICs4MiwxOCBAQCBwcml2YXRlOgogICAg IEV4cHJlc3Npb25MaXN0IG1fZXhwcmVzc2lvblN0YWNrOwogICAgIFZlY3RvcjxDb250cm9sRW50 cnk+IG1fY29udHJvbFN0YWNrOwogICAgIGNvbnN0IFNpZ25hdHVyZSogbV9zaWduYXR1cmU7Ci0g ICAgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiBtX2Z1bmN0aW9uSW5kZXhTcGFj ZTsKICAgICBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgbV9pbmZvOworICAgIGNvbnN0IFZlY3Rv cjxTaWduYXR1cmVJbmRleD4mIG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25h dHVyZUluZGljZXM7CiAgICAgdW5zaWduZWQgbV91bnJlYWNoYWJsZUJsb2NrcyB7IDAgfTsKIH07 CiAKIHRlbXBsYXRlPHR5cGVuYW1lIENvbnRleHQ+Ci1GdW5jdGlvblBhcnNlcjxDb250ZXh0Pjo6 RnVuY3Rpb25QYXJzZXIoVk0qIHZtLCBDb250ZXh0JiBjb250ZXh0LCBjb25zdCB1aW50OF90KiBm dW5jdGlvblN0YXJ0LCBzaXplX3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2ln bmF0dXJlLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIGZ1bmN0aW9uSW5kZXhT cGFjZSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8pCitGdW5jdGlvblBhcnNlcjxDb250 ZXh0Pjo6RnVuY3Rpb25QYXJzZXIoVk0qIHZtLCBDb250ZXh0JiBjb250ZXh0LCBjb25zdCB1aW50 OF90KiBmdW5jdGlvblN0YXJ0LCBzaXplX3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVy ZSogc2lnbmF0dXJlLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgY29uc3QgVmVjdG9y PFNpZ25hdHVyZUluZGV4PiYgbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVy ZUluZGljZXMpCiAgICAgOiBQYXJzZXIodm0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3Ro KQogICAgICwgbV9jb250ZXh0KGNvbnRleHQpCiAgICAgLCBtX3NpZ25hdHVyZShzaWduYXR1cmUp Ci0gICAgLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4U3BhY2UpCiAgICAgLCBt X2luZm8oaW5mbykKKyAgICAsIG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25h dHVyZUluZGljZXMobW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGlj ZXMpCiB7CiAgICAgaWYgKHZlcmJvc2UpCiAgICAgICAgIGRhdGFMb2dMbigiUGFyc2luZyBmdW5j dGlvbiBzdGFydGluZyBhdDogIiwgKHVpbnRwdHJfdClmdW5jdGlvblN0YXJ0LCAiIG9mIGxlbmd0 aDogIiwgZnVuY3Rpb25MZW5ndGgpOwpAQCAtMzA4LDkgKzMwOCw5IEBAIGF1dG8gRnVuY3Rpb25Q YXJzZXI8Q29udGV4dD46OnBhcnNlRXhwcmVzc2lvbihPcFR5cGUgb3ApIC0+IFBhcnRpYWxSZXN1 bHQKICAgICBjYXNlIENhbGw6IHsKICAgICAgICAgdWludDMyX3QgZnVuY3Rpb25JbmRleDsKICAg ICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoZnVuY3Rpb25JbmRleCks ICJjYW4ndCBwYXJzZSBjYWxsJ3MgZnVuY3Rpb24gaW5kZXgiKTsKLSAgICAgICAgV0FTTV9QQVJT RVJfRkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1fZnVuY3Rpb25JbmRleFNwYWNlLnNpemUsICJj YWxsIGZ1bmN0aW9uIGluZGV4ICIsIGZ1bmN0aW9uSW5kZXgsICIgZXhjZWVkcyBmdW5jdGlvbiBp bmRleCBzcGFjZSAiLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5zaXplKTsKKyAgICAgICAgV0FTTV9Q QVJTRVJfRkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1faW5mby5mdW5jdGlvbkluZGV4U3BhY2VT aXplKCksICJjYWxsIGZ1bmN0aW9uIGluZGV4ICIsIGZ1bmN0aW9uSW5kZXgsICIgZXhjZWVkcyBm dW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX2luZm8uZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpKTsK IAotICAgICAgICBTaWduYXR1cmVJbmRleCBjYWxsZWVTaWduYXR1cmVJbmRleCA9IG1fZnVuY3Rp b25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtmdW5jdGlvbkluZGV4XS5zaWduYXR1cmVJbmRleDsK KyAgICAgICAgU2lnbmF0dXJlSW5kZXggY2FsbGVlU2lnbmF0dXJlSW5kZXggPSBtX2luZm8uc2ln bmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgpOwogICAgICAg ICBjb25zdCBTaWduYXR1cmUqIGNhbGxlZVNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9u OjpnZXQobV92bSwgY2FsbGVlU2lnbmF0dXJlSW5kZXgpOwogICAgICAgICBXQVNNX1BBUlNFUl9G QUlMX0lGKGNhbGxlZVNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpID4gbV9leHByZXNzaW9uU3Rh Y2suc2l6ZSgpLCAiY2FsbCBmdW5jdGlvbiBpbmRleCAiLCBmdW5jdGlvbkluZGV4LCAiIGhhcyAi LCBjYWxsZWVTaWduYXR1cmUtPmFyZ3VtZW50Q291bnQoKSwgIiBhcmd1bWVudHMsIGJ1dCB0aGUg ZXhwcmVzc2lvbiBzdGFjayBjdXJyZW50bHkgaG9sZHMgIiwgbV9leHByZXNzaW9uU3RhY2suc2l6 ZSgpLCAiIHZhbHVlcyIpOwogCkBAIC0zMzcsOSArMzM3LDkgQEAgYXV0byBGdW5jdGlvblBhcnNl cjxDb250ZXh0Pjo6cGFyc2VFeHByZXNzaW9uKE9wVHlwZSBvcCkgLT4gUGFydGlhbFJlc3VsdAog ICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihzaWduYXR1cmVJbmRl eCksICJjYW4ndCBnZXQgY2FsbF9pbmRpcmVjdCdzIHNpZ25hdHVyZSBpbmRleCIpOwogICAgICAg ICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQxKHJlc2VydmVkKSwgImNhbid0IGdl dCBjYWxsX2luZGlyZWN0J3MgcmVzZXJ2ZWQgYnl0ZSIpOwogICAgICAgICBXQVNNX1BBUlNFUl9G QUlMX0lGKHJlc2VydmVkLCAiY2FsbF9pbmRpcmVjdCdzICdyZXNlcnZlZCcgdmFydWludDEgbXVz dCBiZSAweDAiKTsKLSAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihtX2luZm8uc2lnbmF0dXJl SW5kaWNlcy5zaXplKCkgPD0gc2lnbmF0dXJlSW5kZXgsICJjYWxsX2luZGlyZWN0J3Mgc2lnbmF0 dXJlIGluZGV4ICIsIHNpZ25hdHVyZUluZGV4LCAiIGV4Y2VlZHMga25vd24gc2lnbmF0dXJlcyAi LCBtX2luZm8uc2lnbmF0dXJlSW5kaWNlcy5zaXplKCkpOworICAgICAgICBXQVNNX1BBUlNFUl9G QUlMX0lGKG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMu c2l6ZSgpIDw9IHNpZ25hdHVyZUluZGV4LCAiY2FsbF9pbmRpcmVjdCdzIHNpZ25hdHVyZSBpbmRl eCAiLCBzaWduYXR1cmVJbmRleCwgIiBleGNlZWRzIGtub3duIHNpZ25hdHVyZXMgIiwgbV9tb2R1 bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXplKCkpOwogCi0g ICAgICAgIFNpZ25hdHVyZUluZGV4IGNhbGxlZVNpZ25hdHVyZUluZGV4ID0gbV9pbmZvLnNpZ25h dHVyZUluZGljZXNbc2lnbmF0dXJlSW5kZXhdOworICAgICAgICBTaWduYXR1cmVJbmRleCBjYWxs ZWVTaWduYXR1cmVJbmRleCA9IG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25h dHVyZUluZGljZXNbc2lnbmF0dXJlSW5kZXhdOwogICAgICAgICBjb25zdCBTaWduYXR1cmUqIGNh bGxlZVNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgY2FsbGVlU2ln bmF0dXJlSW5kZXgpOwogICAgICAgICBzaXplX3QgYXJndW1lbnRDb3VudCA9IGNhbGxlZVNpZ25h dHVyZS0+YXJndW1lbnRDb3VudCgpICsgMTsgLy8gQWRkIHRoZSBjYWxsZWUncyBpbmRleC4KICAg ICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihhcmd1bWVudENvdW50ID4gbV9leHByZXNzaW9uU3Rh Y2suc2l6ZSgpLCAiY2FsbF9pbmRpcmVjdCBleHBlY3RzICIsIGFyZ3VtZW50Q291bnQsICIgYXJn dW1lbnRzLCBidXQgdGhlIGV4cHJlc3Npb24gc3RhY2sgY3VycmVudGx5IGhvbGRzICIsIG1fZXhw cmVzc2lvblN0YWNrLnNpemUoKSwgIiB2YWx1ZXMiKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbU1lbW9yeS5jcHAKaW5kZXggNzAwZTNhYy4uYWFkOTFjMSAxMDA2NDQKLS0tIGEvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5jcHAKKysrIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5jcHAKQEAgLTI4LDE1ICsyOCwzOSBAQAogCiAjaWYg RU5BQkxFKFdFQkFTU0VNQkxZKQogCisjaW5jbHVkZSA8d3RmL0hleE51bWJlci5oPgorI2luY2x1 ZGUgPHd0Zi9QcmludFN0cmVhbS5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgor CiBuYW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIFdhc20gewogCituYW1lc3BhY2UgeworY29uc3Qg Ym9vbCB2ZXJib3NlID0gZmFsc2U7Cit9CisKK3ZvaWQgTWVtb3J5OjpkdW1wKFByaW50U3RyZWFt JiBvdXQpIGNvbnN0Cit7CisgICAgU3RyaW5nIG1lbW9yeUhleDsKKyAgICBXVEY6OmFwcGVuZFVu c2lnbmVkNjRBc0hleCgodWludDY0X3QpKHVpbnRwdHJfdCltX21lbW9yeSwgbWVtb3J5SGV4KTsK KyAgICBvdXQucHJpbnQoIk1lbW9yeSBhdCAweCIsIG1lbW9yeUhleCwgIiwgc2l6ZSAiLCBtX3Np emUsICJCIGNhcGFjaXR5ICIsIG1fbWFwcGVkQ2FwYWNpdHksICJCLCBpbml0aWFsICIsIG1faW5p dGlhbCwgIiBtYXhpbXVtICIsIG1fbWF4aW11bSwgIiBtb2RlICIsIG1ha2VTdHJpbmcobV9tb2Rl KSk7Cit9CisKK2NvbnN0IGNoYXIqIE1lbW9yeTo6bWFrZVN0cmluZyhNb2RlIG1vZGUpIGNvbnN0 Cit7CisgICAgc3dpdGNoIChtb2RlKSB7CisgICAgY2FzZSBNb2RlOjpCb3VuZHNDaGVja2luZzog cmV0dXJuICJCb3VuZHNDaGVja2luZyI7CisgICAgfQorICAgIFJFTEVBU0VfQVNTRVJUX05PVF9S RUFDSEVEKCk7CisgICAgcmV0dXJuICIiOworfQorCiBzdGF0aWNfYXNzZXJ0KHNpemVvZih1aW50 NjRfdCkgPT0gc2l6ZW9mKHNpemVfdCksICJXZSByZWx5IG9uIGFsbG93aW5nIHRoZSBtYXhpbXVt IHNpemUgb2YgTWVtb3J5IHdlIG1hcCB0byBiZSAyXjMyIHdoaWNoIGlzIGxhcmdlciB0aGFuIGZp dHMgaW4gYSAzMi1iaXQgaW50ZWdlciB0aGF0IHdlJ2QgcGFzcyB0byBtcHJvdGVjdCBpZiB0aGlz IGRpZG4ndCBob2xkLiIpOwogCiBNZW1vcnk6Ok1lbW9yeShQYWdlQ291bnQgaW5pdGlhbCwgUGFn ZUNvdW50IG1heGltdW0sIGJvb2wmIGZhaWxlZCkKLSAgICA6IG1fbW9kZShNb2RlOjpCb3VuZHND aGVja2luZykKKyAgICA6IG1fc2l6ZShpbml0aWFsLmJ5dGVzKCkpCiAgICAgLCBtX2luaXRpYWwo aW5pdGlhbCkKICAgICAsIG1fbWF4aW11bShtYXhpbXVtKQotICAgICwgbV9zaXplKGluaXRpYWwu Ynl0ZXMoKSkKKyAgICAsIG1fbW9kZShNb2RlOjpCb3VuZHNDaGVja2luZykKICAgICAvLyBGSVhN RTogSWYgd2UgYWRkIHNpZ25hbCBiYXNlZCBib3VuZHMgY2hlY2tpbmcgdGhlbiB3ZSBuZWVkIGV4 dHJhIHNwYWNlIGZvciBvdmVyZmxvdyBvbiBsb2FkLgogICAgIC8vIHNlZTogaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MjY5MwogewpAQCAtNDYsOSArNzAsMTEgQEAg TWVtb3J5OjpNZW1vcnkoUGFnZUNvdW50IGluaXRpYWwsIFBhZ2VDb3VudCBtYXhpbXVtLCBib29s JiBmYWlsZWQpCiAgICAgaWYgKCFtX21hcHBlZENhcGFjaXR5KSB7CiAgICAgICAgIC8vIFRoaXMg bWVhbnMgd2Ugc3BlY2lmaWVkIGEgemVybyBhcyBtYXhpbXVtICh3aGljaCBtZWFucyB3ZSBhbHNv IGhhdmUgemVybyBhcyBpbml0aWFsIHNpemUpLgogICAgICAgICBSRUxFQVNFX0FTU0VSVChtX3Np emUgPT0gMCk7Ci0gICAgICAgIG1fbWFwcGVkQ2FwYWNpdHkgPSAwOwogICAgICAgICBtX21lbW9y eSA9IG51bGxwdHI7CisgICAgICAgIG1fbWFwcGVkQ2FwYWNpdHkgPSAwOwogICAgICAgICBmYWls ZWQgPSBmYWxzZTsKKyAgICAgICAgaWYgKHZlcmJvc2UpCisgICAgICAgICAgICBkYXRhTG9nTG4o Ik1lbW9yeTo6TWVtb3J5IGFsbG9jYXRpbmcgbm90aGluZyAiLCAqdGhpcyk7CiAgICAgICAgIHJl dHVybjsKICAgICB9CiAKQEAgLTU2LDE1ICs4MiwyMSBAQCBNZW1vcnk6Ok1lbW9yeShQYWdlQ291 bnQgaW5pdGlhbCwgUGFnZUNvdW50IG1heGltdW0sIGJvb2wmIGZhaWxlZCkKICAgICB2b2lkKiBy ZXN1bHQgPSBPcHRpb25zOjpzaW11bGF0ZVdlYkFzc2VtYmx5TG93TWVtb3J5KCkgPyBNQVBfRkFJ TEVEIDogbW1hcChudWxscHRyLCBtX21hcHBlZENhcGFjaXR5LCBQUk9UX05PTkUsIE1BUF9QUklW QVRFIHwgTUFQX0FOT04sIC0xLCAwKTsKICAgICBpZiAocmVzdWx0ID09IE1BUF9GQUlMRUQpIHsK ICAgICAgICAgLy8gVHJ5IGFnYWluIHdpdGggYSBkaWZmZXJlbnQgbnVtYmVyLgorICAgICAgICBp ZiAodmVyYm9zZSkKKyAgICAgICAgICAgIGRhdGFMb2dMbigiTWVtb3J5OjpNZW1vcnkgbW1hcCBm YWlsZWQgb25jZSBmb3IgY2FwYWNpdHksIHRyeWluZyBhZ2FpbiIsICp0aGlzKTsKICAgICAgICAg bV9tYXBwZWRDYXBhY2l0eSA9IG1fc2l6ZTsKICAgICAgICAgaWYgKCFtX21hcHBlZENhcGFjaXR5 KSB7CiAgICAgICAgICAgICBtX21lbW9yeSA9IG51bGxwdHI7CiAgICAgICAgICAgICBmYWlsZWQg PSBmYWxzZTsKKyAgICAgICAgICAgIGlmICh2ZXJib3NlKQorICAgICAgICAgICAgICAgIGRhdGFM b2dMbigiTWVtb3J5OjpNZW1vcnkgbW1hcCBub3QgdHJ5aW5nIGFnYWluIGJlY2F1c2Ugc2l6ZSBp cyB6ZXJvICIsICp0aGlzKTsKICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgfQogCiAgICAg ICAgIHJlc3VsdCA9IG1tYXAobnVsbHB0ciwgbV9tYXBwZWRDYXBhY2l0eSwgUFJPVF9OT05FLCBN QVBfUFJJVkFURSB8IE1BUF9BTk9OLCAtMSwgMCk7CiAgICAgICAgIGlmIChyZXN1bHQgPT0gTUFQ X0ZBSUxFRCkgeworICAgICAgICAgICAgaWYgKHZlcmJvc2UpCisgICAgICAgICAgICAgICAgZGF0 YUxvZ0xuKCJNZW1vcnk6Ok1lbW9yeSBtbWFwIGZhaWxlZCB0d2ljZSAiLCAqdGhpcyk7CiAgICAg ICAgICAgICBmYWlsZWQgPSB0cnVlOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CkBA IC03OCwxMiArMTEwLDI3IEBAIE1lbW9yeTo6TWVtb3J5KFBhZ2VDb3VudCBpbml0aWFsLCBQYWdl Q291bnQgbWF4aW11bSwgYm9vbCYgZmFpbGVkKQogCiAgICAgbV9tZW1vcnkgPSByZXN1bHQ7CiAg ICAgZmFpbGVkID0gZmFsc2U7CisgICAgaWYgKHZlcmJvc2UpCisgICAgICAgIGRhdGFMb2dMbigi TWVtb3J5OjpNZW1vcnkgbW1hcCBzdWNjZWVkZWQgIiwgKnRoaXMpOworfQorCitNZW1vcnk6On5N ZW1vcnkoKQoreworICAgIGlmICh2ZXJib3NlKQorICAgICAgICBkYXRhTG9nTG4oIk1lbW9yeTo6 fk1lbW9yeSAiLCAqdGhpcyk7CisgICAgaWYgKG1fbWVtb3J5KSB7CisgICAgICAgIGlmIChtdW5t YXAobV9tZW1vcnksIG1fbWFwcGVkQ2FwYWNpdHkpKQorICAgICAgICAgICAgQ1JBU0goKTsKKyAg ICB9CiB9CiAKIGJvb2wgTWVtb3J5Ojpncm93KFBhZ2VDb3VudCBuZXdTaXplKQogewogICAgIFJF TEVBU0VfQVNTRVJUKG5ld1NpemUgPiBQYWdlQ291bnQ6OmZyb21CeXRlcyhtX3NpemUpKTsKIAor ICAgIGlmICh2ZXJib3NlKQorICAgICAgICBkYXRhTG9nTG4oIk1lbW9yeTo6Z3JvdyB0byAiLCBu ZXdTaXplLCAiIGZyb20gIiwgKnRoaXMpOworCiAgICAgaWYgKG1heGltdW0oKSAmJiBuZXdTaXpl ID4gbWF4aW11bSgpKQogICAgICAgICByZXR1cm4gZmFsc2U7CiAKQEAgLTkzLDYgKzE0MCw4IEBA IGJvb2wgTWVtb3J5Ojpncm93KFBhZ2VDb3VudCBuZXdTaXplKQogICAgICAgICBib29sIHN1Y2Nl c3MgPSAhbXByb3RlY3Qoc3RhdGljX2Nhc3Q8dWludDhfdCo+KG1fbWVtb3J5KSArIG1fc2l6ZSwg c3RhdGljX2Nhc3Q8c2l6ZV90PihkZXNpcmVkU2l6ZSAtIG1fc2l6ZSksIFBST1RfUkVBRCB8IFBS T1RfV1JJVEUpOwogICAgICAgICBSRUxFQVNFX0FTU0VSVChzdWNjZXNzKTsKICAgICAgICAgbV9z aXplID0gZGVzaXJlZFNpemU7CisgICAgICAgIGlmICh2ZXJib3NlKQorICAgICAgICAgICAgZGF0 YUxvZ0xuKCJNZW1vcnk6Omdyb3cgaW4tcGxhY2UgIiwgKnRoaXMpOwogICAgICAgICByZXR1cm4g dHJ1ZTsKICAgICB9CiAKQEAgLTExMCw2ICsxNTksOCBAQCBib29sIE1lbW9yeTo6Z3JvdyhQYWdl Q291bnQgbmV3U2l6ZSkKICAgICBtX21hcHBlZENhcGFjaXR5ID0gZGVzaXJlZFNpemU7CiAgICAg bV9zaXplID0gZGVzaXJlZFNpemU7CiAKKyAgICBpZiAodmVyYm9zZSkKKyAgICAgICAgZGF0YUxv Z0xuKCJNZW1vcnk6Omdyb3cgIiwgKnRoaXMpOwogICAgIHJldHVybiB0cnVlOwogfQogCmRpZmYg LS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmggYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmgKaW5kZXggNGU1ZWUzNi4uZTQ3MGM0MSAx MDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5oCisrKyBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuaApAQCAtMzAsNyArMzAsOSBA QAogI2luY2x1ZGUgIldhc21DYWxsaW5nQ29udmVudGlvbi5oIgogI2luY2x1ZGUgIldhc21QYWdl Q291bnQuaCIKIAotI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KK25hbWVzcGFjZSBXVEYgeworY2xh c3MgUHJpbnRTdHJlYW07Cit9CiAKIG5hbWVzcGFjZSBKU0MgeyBuYW1lc3BhY2UgV2FzbSB7CiAK QEAgLTM4LDQxICs0MCw1MCBAQCBjbGFzcyBNZW1vcnkgewogICAgIFdURl9NQUtFX05PTkNPUFlB QkxFKE1lbW9yeSk7CiAgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CiBwdWJsaWM6CisgICAg dm9pZCBkdW1wKFdURjo6UHJpbnRTdHJlYW0mKSBjb25zdDsKIAogICAgIC8vIEZJWE1FOiBXZSBz aG91bGQgc3VwcG9ydCBvdGhlciBtb2Rlcy4gc2VlOiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTYyNjkzCiAgICAgZW51bSBjbGFzcyBNb2RlIHsKICAgICAgICAgQm91 bmRzQ2hlY2tpbmcKICAgICB9OworICAgIGNvbnN0IGNoYXIqIG1ha2VTdHJpbmcoTW9kZSkgY29u c3Q7CiAKKyAgICBNZW1vcnkoKSA9IGRlZmF1bHQ7CiAgICAgSlNfRVhQT1JUX1BSSVZBVEUgTWVt b3J5KFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSwgYm9vbCYgZmFpbGVkKTsK LQotICAgIH5NZW1vcnkoKQorICAgIE1lbW9yeShNZW1vcnkmJiBvdGhlcikKKyAgICAgICAgOiBt X21lbW9yeShvdGhlci5tX21lbW9yeSkKKyAgICAgICAgLCBtX3NpemUob3RoZXIubV9zaXplKQor ICAgICAgICAsIG1faW5pdGlhbChvdGhlci5tX2luaXRpYWwpCisgICAgICAgICwgbV9tYXhpbXVt KG90aGVyLm1fbWF4aW11bSkKKyAgICAgICAgLCBtX21hcHBlZENhcGFjaXR5KG90aGVyLm1fbWFw cGVkQ2FwYWNpdHkpCisgICAgICAgICwgbV9tb2RlKG90aGVyLm1fbW9kZSkKICAgICB7Ci0gICAg ICAgIGlmIChtX21lbW9yeSkKLSAgICAgICAgICAgIG11bm1hcChtX21lbW9yeSwgbV9tYXBwZWRD YXBhY2l0eSk7CisgICAgICAgIC8vIE1vdmluZyB0cmFuc2ZlcnMgb3duZXJzaGlwIG9mIHRoZSBh bGxvY2F0ZWQgbWVtb3J5LgorICAgICAgICBvdGhlci5tX21lbW9yeSA9IG51bGxwdHI7CiAgICAg fQorICAgIEpTX0VYUE9SVF9QUklWQVRFIH5NZW1vcnkoKTsKIAogICAgIHZvaWQqIG1lbW9yeSgp IGNvbnN0IHsgcmV0dXJuIG1fbWVtb3J5OyB9CiAgICAgdWludDY0X3Qgc2l6ZSgpIGNvbnN0IHsg cmV0dXJuIG1fc2l6ZTsgfQogICAgIFBhZ2VDb3VudCBzaXplSW5QYWdlcygpIGNvbnN0IHsgcmV0 dXJuIFBhZ2VDb3VudDo6ZnJvbUJ5dGVzKG1fc2l6ZSk7IH0KIAotICAgIE1vZGUgbW9kZSgpIGNv bnN0IHsgcmV0dXJuIG1fbW9kZTsgfQotCiAgICAgUGFnZUNvdW50IGluaXRpYWwoKSBjb25zdCB7 IHJldHVybiBtX2luaXRpYWw7IH0KICAgICBQYWdlQ291bnQgbWF4aW11bSgpIGNvbnN0IHsgcmV0 dXJuIG1fbWF4aW11bTsgfQogCisgICAgTW9kZSBtb2RlKCkgY29uc3QgeyByZXR1cm4gbV9tb2Rl OyB9CisKICAgICBib29sIGdyb3coUGFnZUNvdW50KTsKIAotICAgIHN0YXRpYyBwdHJkaWZmX3Qg b2Zmc2V0T2ZTaXplKCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKE1lbW9yeSwgbV9zaXplKTsg fQogICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZNZW1vcnkoKSB7IHJldHVybiBPQkpFQ1Rf T0ZGU0VUT0YoTWVtb3J5LCBtX21lbW9yeSk7IH0KKyAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNl dE9mU2l6ZSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihNZW1vcnksIG1fc2l6ZSk7IH0KICAg ICAKIHByaXZhdGU6CiAgICAgdm9pZCogbV9tZW1vcnkgeyBudWxscHRyIH07Ci0gICAgTW9kZSBt X21vZGU7CisgICAgdWludDY0X3QgbV9zaXplIHsgMCB9OwogICAgIFBhZ2VDb3VudCBtX2luaXRp YWw7CiAgICAgUGFnZUNvdW50IG1fbWF4aW11bTsKLSAgICB1aW50NjRfdCBtX3NpemUgeyAwIH07 CiAgICAgdWludDY0X3QgbV9tYXBwZWRDYXBhY2l0eSB7IDAgfTsKKyAgICBNb2RlIG1fbW9kZSB7 IE1vZGU6OkJvdW5kc0NoZWNraW5nIH07CiB9OwogCiB9IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2Fz bQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9y bWF0aW9uLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnlJbmZvcm1h dGlvbi5jcHAKaW5kZXggMmUxZDMwYS4uNmIwNjNkMyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmNwcAorKysgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5SW5mb3JtYXRpb24uY3BwCkBAIC0yNiwxMyArMjYs NTIgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJXYXNtTWVtb3J5SW5mb3JtYXRp b24uaCIKIAotI2luY2x1ZGUgIldhc21DYWxsaW5nQ29udmVudGlvbi5oIgotCiAjaWYgRU5BQkxF KFdFQkFTU0VNQkxZKQogCisjaW5jbHVkZSAiV2FzbUNhbGxpbmdDb252ZW50aW9uLmgiCisjaW5j bHVkZSA8d3RmL05ldmVyRGVzdHJveWVkLmg+CisKIG5hbWVzcGFjZSBKU0MgeyBuYW1lc3BhY2Ug V2FzbSB7CiAKLU1lbW9yeUluZm9ybWF0aW9uOjpNZW1vcnlJbmZvcm1hdGlvbihQYWdlQ291bnQg aW5pdGlhbCwgUGFnZUNvdW50IG1heGltdW0sICBjb25zdCBWZWN0b3I8dW5zaWduZWQ+JiBwaW5u ZWRTaXplUmVnaXN0ZXJzLCBib29sIGlzSW1wb3J0KQorY29uc3QgUGlubmVkUmVnaXN0ZXJJbmZv JiBQaW5uZWRSZWdpc3RlckluZm86OmdldCgpCit7CisgICAgc3RhdGljIExhenlOZXZlckRlc3Ry b3llZDxQaW5uZWRSZWdpc3RlckluZm8+IHN0YXRpY1Bpbm5lZFJlZ2lzdGVySW5mbzsKKyAgICBz dGF0aWMgc3RkOjpvbmNlX2ZsYWcgc3RhdGljUGlubmVkUmVnaXN0ZXJJbmZvRmxhZzsKKyAgICBz dGQ6OmNhbGxfb25jZShzdGF0aWNQaW5uZWRSZWdpc3RlckluZm9GbGFnLCBbXSAoKSB7CisgICAg ICAgIFZlY3RvcjxQaW5uZWRTaXplUmVnaXN0ZXJJbmZvPiBzaXplUmVnaXN0ZXJzOworICAgICAg ICBHUFJSZWcgYmFzZU1lbW9yeVBvaW50ZXI7CisKKyAgICAgICAgLy8gRklYTUU6IFdlIHNob3Vs ZCBzdXBwb3J0IG1vcmUgdGhhbiBvbmUgbWVtb3J5IHNpemUgcmVnaXN0ZXIsIGFuZCB3ZSBzaG91 bGQgYWxsb3cgZGlmZmVyZW50CisgICAgICAgIC8vICAgICAgICBXZWJBc3NlbWJseS5JbnN0YW5j ZSB0byBoYXZlIGRpZmZlcmVudCBwaW5zLiBSaWdodCBub3cgd2UgdGFrZSBhIHZlY3RvciB3aXRo IG9ubHkgb25lIGVudHJ5LgorICAgICAgICAvLyAgICAgICAgSWYgd2UgaGF2ZSBtb3JlIHRoYW4g b25lIHNpemUgcmVnaXN0ZXIsIHdlIGNhbiBoYXZlIG9uZSBmb3IgZWFjaCBsb2FkIHNpemUgY2xh c3MuCisgICAgICAgIC8vICAgICAgICBzZWU6IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0xNjI5NTIKKyAgICAgICAgVmVjdG9yPHVuc2lnbmVkPiBwaW5uZWRTaXplcyA9 IHsgMCB9OworICAgICAgICB1bnNpZ25lZCByZW1haW5pbmdQaW5uZWRSZWdpc3RlcnMgPSBwaW5u ZWRTaXplcy5zaXplKCkgKyAxOworICAgICAgICBqc2NDYWxsaW5nQ29udmVudGlvbigpLm1fY2Fs bGVlU2F2ZVJlZ2lzdGVycy5mb3JFYWNoKFsmXSAoUmVnIHJlZykgeworICAgICAgICAgICAgR1BS UmVnIGdwciA9IHJlZy5ncHIoKTsKKyAgICAgICAgICAgIGlmICghcmVtYWluaW5nUGlubmVkUmVn aXN0ZXJzIHx8IFJlZ2lzdGVyU2V0OjpzdGFja1JlZ2lzdGVycygpLmdldChyZWcpKQorICAgICAg ICAgICAgICAgIHJldHVybjsKKyAgICAgICAgICAgIGlmIChyZW1haW5pbmdQaW5uZWRSZWdpc3Rl cnMgPT0gMSkgeworICAgICAgICAgICAgICAgIGJhc2VNZW1vcnlQb2ludGVyID0gZ3ByOworICAg ICAgICAgICAgICAgIHJlbWFpbmluZ1Bpbm5lZFJlZ2lzdGVycy0tOworICAgICAgICAgICAgfSBl bHNlCisgICAgICAgICAgICAgICAgc2l6ZVJlZ2lzdGVycy5hcHBlbmQoeyBncHIsIHBpbm5lZFNp emVzWy0tcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzIC0gMV0gfSk7CisgICAgICAgIH0pOworCisg ICAgICAgIEFTU0VSVCghcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzKTsKKyAgICAgICAgc3RhdGlj UGlubmVkUmVnaXN0ZXJJbmZvLmNvbnN0cnVjdChXVEZNb3ZlKHNpemVSZWdpc3RlcnMpLCBiYXNl TWVtb3J5UG9pbnRlcik7CisgICAgfSk7CisKKyAgICByZXR1cm4gc3RhdGljUGlubmVkUmVnaXN0 ZXJJbmZvLmdldCgpOworfQorCitQaW5uZWRSZWdpc3RlckluZm86OlBpbm5lZFJlZ2lzdGVySW5m byhWZWN0b3I8UGlubmVkU2l6ZVJlZ2lzdGVySW5mbz4mJiBzaXplUmVnaXN0ZXJzLCBHUFJSZWcg YmFzZU1lbW9yeVBvaW50ZXIpCisgICAgOiBzaXplUmVnaXN0ZXJzKFdURk1vdmUoc2l6ZVJlZ2lz dGVycykpCisgICAgLCBiYXNlTWVtb3J5UG9pbnRlcihiYXNlTWVtb3J5UG9pbnRlcikKK3sKK30K KworTWVtb3J5SW5mb3JtYXRpb246Ok1lbW9yeUluZm9ybWF0aW9uKFBhZ2VDb3VudCBpbml0aWFs LCBQYWdlQ291bnQgbWF4aW11bSwgIGJvb2wgaXNJbXBvcnQpCiAgICAgOiBtX2luaXRpYWwoaW5p dGlhbCkKICAgICAsIG1fbWF4aW11bShtYXhpbXVtKQogICAgICwgbV9pc0ltcG9ydChpc0ltcG9y dCkKQEAgLTQwLDIwICs3OSw2IEBAIE1lbW9yeUluZm9ybWF0aW9uOjpNZW1vcnlJbmZvcm1hdGlv bihQYWdlQ291bnQgaW5pdGlhbCwgUGFnZUNvdW50IG1heGltdW0sICBjb25zCiAgICAgUkVMRUFT RV9BU1NFUlQoISFtX2luaXRpYWwpOwogICAgIFJFTEVBU0VfQVNTRVJUKCFtX21heGltdW0gfHwg bV9tYXhpbXVtID49IG1faW5pdGlhbCk7CiAgICAgQVNTRVJUKCEhKnRoaXMpOwotCi0gICAgdW5z aWduZWQgcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzID0gcGlubmVkU2l6ZVJlZ2lzdGVycy5zaXpl KCkgKyAxOwotICAgIGpzY0NhbGxpbmdDb252ZW50aW9uKCkubV9jYWxsZWVTYXZlUmVnaXN0ZXJz LmZvckVhY2goWyZdIChSZWcgcmVnKSB7Ci0gICAgICAgIEdQUlJlZyBncHIgPSByZWcuZ3ByKCk7 Ci0gICAgICAgIGlmICghcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzIHx8IFJlZ2lzdGVyU2V0Ojpz dGFja1JlZ2lzdGVycygpLmdldChyZWcpKQotICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICBp ZiAocmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzID09IDEpIHsKLSAgICAgICAgICAgIG1fcGlubmVk UmVnaXN0ZXJzLmJhc2VNZW1vcnlQb2ludGVyID0gZ3ByOwotICAgICAgICAgICAgcmVtYWluaW5n UGlubmVkUmVnaXN0ZXJzLS07Ci0gICAgICAgIH0gZWxzZQotICAgICAgICAgICAgbV9waW5uZWRS ZWdpc3RlcnMuc2l6ZVJlZ2lzdGVycy5hcHBlbmQoeyBncHIsIHBpbm5lZFNpemVSZWdpc3RlcnNb LS1yZW1haW5pbmdQaW5uZWRSZWdpc3RlcnMgLSAxXSB9KTsKLSAgICB9KTsKLQotICAgIEFTU0VS VCghcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzKTsKIH0KIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6 Oldhc20KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnlJ bmZvcm1hdGlvbi5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9y bWF0aW9uLmgKaW5kZXggZWU2M2Q5ZS4uNmU3ZjUyMSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmgKKysrIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmgKQEAgLTM4LDEyICszOCwxMSBA QCBzdHJ1Y3QgUGlubmVkU2l6ZVJlZ2lzdGVySW5mbyB7CiAgICAgdW5zaWduZWQgc2l6ZU9mZnNl dDsKIH07CiAKLS8vIEZJWE1FOiBXZSBzaG91bGQgc3VwcG9ydCBtb3JlIHRoYW4gb25lIG1lbW9y eSBzaXplIHJlZ2lzdGVyLiBSaWdodCBub3cgd2UgdGFrZSBhIHZlY3RvciB3aXRoIG9ubHkgb25l Ci0vLyBlbnRyeS4gU3BlY2lmaWNhbGx5IGFuIGVudHJ5IHdoZXJlIHRoZSBzaXplT2Zmc2V0ID09 IDAuIElmIHdlIGhhdmUgbW9yZSB0aGFuIG9uZSBzaXplIHJlZ2lzdGVyLAotLy8gd2UgY2FuIGhh dmUgb25lIGZvciBlYWNoIGxvYWQgc2l6ZSBjbGFzcy4gc2VlOiBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYyOTUyCiBzdHJ1Y3QgUGlubmVkUmVnaXN0ZXJJbmZvIHsK ICAgICBWZWN0b3I8UGlubmVkU2l6ZVJlZ2lzdGVySW5mbz4gc2l6ZVJlZ2lzdGVyczsKICAgICBH UFJSZWcgYmFzZU1lbW9yeVBvaW50ZXI7CisgICAgc3RhdGljIGNvbnN0IFBpbm5lZFJlZ2lzdGVy SW5mbyYgZ2V0KCk7CisgICAgUGlubmVkUmVnaXN0ZXJJbmZvKFZlY3RvcjxQaW5uZWRTaXplUmVn aXN0ZXJJbmZvPiYmLCBHUFJSZWcpOwogfTsKIAogY2xhc3MgTWVtb3J5SW5mb3JtYXRpb24gewpA QCAtNTMsOSArNTIsOCBAQCBwdWJsaWM6CiAgICAgICAgIEFTU0VSVCghKnRoaXMpOwogICAgIH0K IAotICAgIE1lbW9yeUluZm9ybWF0aW9uKFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQgbWF4 aW11bSwgY29uc3QgVmVjdG9yPHVuc2lnbmVkPiYgcGlubmVkU2l6ZVJlZ2lzdGVycywgYm9vbCBp c0ltcG9ydCk7CisgICAgTWVtb3J5SW5mb3JtYXRpb24oUGFnZUNvdW50IGluaXRpYWwsIFBhZ2VD b3VudCBtYXhpbXVtLCBib29sIGlzSW1wb3J0KTsKIAotICAgIGNvbnN0IFBpbm5lZFJlZ2lzdGVy SW5mbyYgcGlubmVkUmVnaXN0ZXJzKCkgY29uc3QgeyByZXR1cm4gbV9waW5uZWRSZWdpc3RlcnM7 IH0KICAgICBQYWdlQ291bnQgaW5pdGlhbCgpIGNvbnN0IHsgcmV0dXJuIG1faW5pdGlhbDsgfQog ICAgIFBhZ2VDb3VudCBtYXhpbXVtKCkgY29uc3QgeyByZXR1cm4gbV9tYXhpbXVtOyB9CiAgICAg Ym9vbCBpc0ltcG9ydCgpIGNvbnN0IHsgcmV0dXJuIG1faXNJbXBvcnQ7IH0KQEAgLTY1LDcgKzYz LDYgQEAgcHVibGljOgogcHJpdmF0ZToKICAgICBQYWdlQ291bnQgbV9pbml0aWFsIHsgfTsKICAg ICBQYWdlQ291bnQgbV9tYXhpbXVtIHsgfTsKLSAgICBQaW5uZWRSZWdpc3RlckluZm8gbV9waW5u ZWRSZWdpc3RlcnMgeyB9OwogICAgIGJvb2wgbV9pc0ltcG9ydCB7IGZhbHNlIH07CiB9OwogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmNw cCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCmluZGV4 IDYyNjFlN2YuLjMwMTFjODkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21Nb2R1bGVQYXJzZXIuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dh c21Nb2R1bGVQYXJzZXIuY3BwCkBAIC0xMDcsNyArMTA3LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6 OnBhcnNlVHlwZSgpIC0+IFBhcnRpYWxSZXN1bHQKIAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYo IXBhcnNlVmFyVUludDMyKGNvdW50KSwgImNhbid0IGdldCBUeXBlIHNlY3Rpb24ncyBjb3VudCIp OwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoY291bnQgPT0gc3RkOjpudW1lcmljX2xpbWl0czx1 aW50MzJfdD46Om1heCgpLCAiVHlwZSBzZWN0aW9uJ3MgY291bnQgaXMgdG9vIGJpZyAiLCBjb3Vu dCk7Ci0gICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJ bmRpY2VzLnRyeVJlc2VydmVDYXBhY2l0eShjb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2gg bWVtb3J5IGZvciBUeXBlIHNlY3Rpb24ncyAiLCBjb3VudCwgIiBlbnRyaWVzIik7CisgICAgV0FT TV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVl ZFNpZ25hdHVyZUluZGljZXMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50KSwgImNhbid0IGFsbG9j YXRlIGVub3VnaCBtZW1vcnkgZm9yIFR5cGUgc2VjdGlvbidzICIsIGNvdW50LCAiIGVudHJpZXMi KTsKIAogICAgIGZvciAodWludDMyX3QgaSA9IDA7IGkgPCBjb3VudDsgKytpKSB7CiAgICAgICAg IGludDhfdCB0eXBlOwpAQCAtMTM5LDcgKzEzOSw3IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJz ZVR5cGUoKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgICAgIHNpZ25hdHVyZS0+cmV0dXJuVHlwZSgp ID0gcmV0dXJuVHlwZTsKIAogICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9 IFNpZ25hdHVyZUluZm9ybWF0aW9uOjphZG9wdChtX3ZtLCBzaWduYXR1cmUucmVsZWFzZSgpKTsK LSAgICAgICAgbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFwcGVu ZChzaWduYXR1cmVJbmRleCk7CisgICAgICAgIG1fcmVzdWx0Lm1vZHVsZVNpZ25hdHVyZUluZGlj ZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRl eCk7CiAgICAgfQogICAgIHJldHVybiB7IH07CiB9CkBAIC0xNTIsNyArMTUyLDYgQEAgYXV0byBN b2R1bGVQYXJzZXI6OnBhcnNlSW1wb3J0KCkgLT4gUGFydGlhbFJlc3VsdAogICAgIFdBU01fUEFS U0VSX0ZBSUxfSUYoIW1fcmVzdWx0Lm1vZHVsZS0+Z2xvYmFscy50cnlSZXNlcnZlQ2FwYWNpdHko aW1wb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0 Q291bnQsICIgZ2xvYmFscyIpOyAvLyBGSVhNRSB0aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2Ug Zml4IHRoZSBGSVhNRXMgYmVsb3cuCiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQu bW9kdWxlLT5pbXBvcnRzLnRyeVJlc2VydmVDYXBhY2l0eShpbXBvcnRDb3VudCksICJjYW4ndCBh bGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBpbXBvcnRDb3VudCwgIiBpbXBvcnRzIik7IC8v IEZJWE1FIHRoaXMgb3Zlci1hbGxvY2F0ZXMgd2hlbiB3ZSBmaXggdGhlIEZJWE1FcyBiZWxvdy4K ICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX3Jlc3VsdC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9u U2lnbmF0dXJlSW5kaWNlcy50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291bnQpLCAiY2FuJ3Qg YWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIgaW1wb3J0IGZ1bmN0 aW9uIHNpZ25hdHVyZXMiKTsgLy8gRklYTUUgdGhpcyBvdmVyLWFsbG9jYXRlcyB3aGVuIHdlIGZp eCB0aGUgRklYTUVzIGJlbG93LgotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0LmZ1 bmN0aW9uSW5kZXhTcGFjZS50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291bnQpLCAiY2FuJ3Qg YWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIgZnVuY3Rpb25zIGlu IHRoZSBpbmRleCBzcGFjZSIpOyAvLyBGSVhNRSB0aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2Ug Zml4IHRoZSBGSVhNRXMgYmVsb3cuIFdlJ2xsIGFsbG9jYXRlIHNvbWUgbW9yZSBoZXJlIHdoZW4g d2Uga25vdyBob3cgbWFueSBmdW5jdGlvbnMgdG8gZXhwZWN0LgogCiAgICAgZm9yICh1aW50MzJf dCBpbXBvcnROdW1iZXIgPSAwOyBpbXBvcnROdW1iZXIgPCBpbXBvcnRDb3VudDsgKytpbXBvcnRO dW1iZXIpIHsKICAgICAgICAgSW1wb3J0IGltcDsKQEAgLTE3NCwxMSArMTczLDEwIEBAIGF1dG8g TW9kdWxlUGFyc2VyOjpwYXJzZUltcG9ydCgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICAgICAgY2Fz ZSBFeHRlcm5hbEtpbmQ6OkZ1bmN0aW9uOiB7CiAgICAgICAgICAgICB1aW50MzJfdCBmdW5jdGlv blNpZ25hdHVyZUluZGV4OwogICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VW YXJVSW50MzIoZnVuY3Rpb25TaWduYXR1cmVJbmRleCksICJjYW4ndCBnZXQgIiwgaW1wb3J0TnVt YmVyLCAidGggSW1wb3J0J3MgZnVuY3Rpb24gc2lnbmF0dXJlIGluIG1vZHVsZSAnIiwgbW9kdWxl U3RyaW5nLCAiJyBmaWVsZCAnIiwgZmllbGRTdHJpbmcsICInIik7Ci0gICAgICAgICAgICBXQVNN X1BBUlNFUl9GQUlMX0lGKGZ1bmN0aW9uU2lnbmF0dXJlSW5kZXggPj0gbV9yZXN1bHQubW9kdWxl LT5zaWduYXR1cmVJbmRpY2VzLnNpemUoKSwgImludmFsaWQgZnVuY3Rpb24gc2lnbmF0dXJlIGZv ciAiLCBpbXBvcnROdW1iZXIsICJ0aCBJbXBvcnQsICIsIGZ1bmN0aW9uU2lnbmF0dXJlSW5kZXgs ICIgaXMgb3V0IG9mIHJhbmdlIG9mICIsIG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNl cy5zaXplKCksICIgaW4gbW9kdWxlICciLCBtb2R1bGVTdHJpbmcsICInIGZpZWxkICciLCBmaWVs ZFN0cmluZywgIiciKTsKKyAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVuY3Rpb25T aWduYXR1cmVJbmRleCA+PSBtX3Jlc3VsdC5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVk U2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICJpbnZhbGlkIGZ1bmN0aW9uIHNpZ25hdHVyZSBmb3Ig IiwgaW1wb3J0TnVtYmVyLCAidGggSW1wb3J0LCAiLCBmdW5jdGlvblNpZ25hdHVyZUluZGV4LCAi IGlzIG91dCBvZiByYW5nZSBvZiAiLCBtX3Jlc3VsdC5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9V bmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICIgaW4gbW9kdWxlICciLCBtb2R1bGVTdHJp bmcsICInIGZpZWxkICciLCBmaWVsZFN0cmluZywgIiciKTsKICAgICAgICAgICAgIGltcC5raW5k SW5kZXggPSBtX3Jlc3VsdC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5z aXplKCk7Ci0gICAgICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVz dWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvblNpZ25hdHVyZUluZGV4XTsKKyAg ICAgICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9yZXN1bHQubW9kdWxl U2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXNbZnVuY3Rpb25TaWduYXR1 cmVJbmRleF07CiAgICAgICAgICAgICBtX3Jlc3VsdC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9uU2ln bmF0dXJlSW5kaWNlcy51bmNoZWNrZWRBcHBlbmQoc2lnbmF0dXJlSW5kZXgpOwotICAgICAgICAg ICAgbV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJ bmRleCk7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQogICAgICAgICBjYXNlIEV4dGVy bmFsS2luZDo6VGFibGU6IHsKQEAgLTIyMCwyMCArMjE4LDE4IEBAIGF1dG8gTW9kdWxlUGFyc2Vy OjpwYXJzZUZ1bmN0aW9uKCkgLT4gUGFydGlhbFJlc3VsdAogICAgIFdBU01fUEFSU0VSX0ZBSUxf SUYoY291bnQgPT0gc3RkOjpudW1lcmljX2xpbWl0czx1aW50MzJfdD46Om1heCgpLCAiRnVuY3Rp b24gc2VjdGlvbidzIGNvdW50IGlzIHRvbyBiaWcgIiwgY291bnQpOwogICAgIFdBU01fUEFSU0VS X0ZBSUxfSUYoIW1fcmVzdWx0Lm1vZHVsZS0+aW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGlj ZXMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1v cnkgZm9yICIsIGNvdW50LCAiIEZ1bmN0aW9uIHNpZ25hdHVyZXMiKTsKICAgICBXQVNNX1BBUlNF Ul9GQUlMX0lGKCFtX3Jlc3VsdC5mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkudHJ5UmVzZXJ2ZUNh cGFjaXR5KGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGNvdW50 LCAiRnVuY3Rpb24gbG9jYXRpb25zIik7Ci0gICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1 bHQuZnVuY3Rpb25JbmRleFNwYWNlLnRyeVJlc2VydmVDYXBhY2l0eShtX3Jlc3VsdC5mdW5jdGlv bkluZGV4U3BhY2Uuc2l6ZSgpICsgY291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9y eSBmb3IgIiwgY291bnQsICIgbW9yZSBmdW5jdGlvbnMgaW4gdGhlIGZ1bmN0aW9uIGluZGV4IHNw YWNlIik7CiAKICAgICBmb3IgKHVpbnQzMl90IGkgPSAwOyBpIDwgY291bnQ7ICsraSkgewogICAg ICAgICB1aW50MzJfdCB0eXBlTnVtYmVyOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFw YXJzZVZhclVJbnQzMih0eXBlTnVtYmVyKSwgImNhbid0IGdldCAiLCBpLCAidGggRnVuY3Rpb24n cyB0eXBlIG51bWJlciIpOwotICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHR5cGVOdW1iZXIg Pj0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnNpemUoKSwgaSwgInRoIEZ1bmN0 aW9uIHR5cGUgbnVtYmVyIGlzIGludmFsaWQgIiwgdHlwZU51bWJlcik7CisgICAgICAgIFdBU01f UEFSU0VSX0ZBSUxfSUYodHlwZU51bWJlciA+PSBtX3Jlc3VsdC5tb2R1bGVTaWduYXR1cmVJbmRp Y2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXplKCksIGksICJ0aCBGdW5jdGlvbiB0eXBl IG51bWJlciBpcyBpbnZhbGlkICIsIHR5cGVOdW1iZXIpOwogCi0gICAgICAgIFNpZ25hdHVyZUlu ZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzW3R5 cGVOdW1iZXJdOworICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVz dWx0Lm1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzW3R5cGVO dW1iZXJdOwogICAgICAgICAvLyBUaGUgQ29kZSBzZWN0aW9uIGZpeGVzIHVwIHN0YXJ0IGFuZCBl bmQuCiAgICAgICAgIHNpemVfdCBzdGFydCA9IDA7CiAgICAgICAgIHNpemVfdCBlbmQgPSAwOwog ICAgICAgICBtX3Jlc3VsdC5tb2R1bGUtPmludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2Vz LnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7CiAgICAgICAgIG1fcmVzdWx0LmZ1bmN0 aW9uTG9jYXRpb25JbkJpbmFyeS51bmNoZWNrZWRBcHBlbmQoeyBzdGFydCwgZW5kIH0pOwotICAg ICAgICBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2UudW5jaGVja2VkQXBwZW5kKHNpZ25hdHVy ZUluZGV4KTsKICAgICB9CiAKICAgICByZXR1cm4geyB9OwpAQCAtMzIwLDggKzMxNiw3IEBAIGF1 dG8gTW9kdWxlUGFyc2VyOjpwYXJzZU1lbW9yeUhlbHBlcihib29sIGlzSW1wb3J0KSAtPiBQYXJ0 aWFsUmVzdWx0CiAgICAgQVNTRVJUKGluaXRpYWxQYWdlQ291bnQpOwogICAgIEFTU0VSVCghbWF4 aW11bVBhZ2VDb3VudCB8fCBtYXhpbXVtUGFnZUNvdW50ID49IGluaXRpYWxQYWdlQ291bnQpOwog Ci0gICAgVmVjdG9yPHVuc2lnbmVkPiBwaW5uZWRTaXplcyA9IHsgMCB9OwotICAgIG1fcmVzdWx0 Lm1vZHVsZS0+bWVtb3J5ID0gTWVtb3J5SW5mb3JtYXRpb24oaW5pdGlhbFBhZ2VDb3VudCwgbWF4 aW11bVBhZ2VDb3VudCwgcGlubmVkU2l6ZXMsIGlzSW1wb3J0KTsKKyAgICBtX3Jlc3VsdC5tb2R1 bGUtPm1lbW9yeSA9IE1lbW9yeUluZm9ybWF0aW9uKGluaXRpYWxQYWdlQ291bnQsIG1heGltdW1Q YWdlQ291bnQsIGlzSW1wb3J0KTsKICAgICByZXR1cm4geyB9OwogfQogCkBAIC0zODcsNyArMzgy LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlRXhwb3J0KCkgLT4gUGFydGlhbFJlc3VsdAog ICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihleHAua2luZEluZGV4 KSwgImNhbid0IGdldCAiLCBleHBvcnROdW1iZXIsICJ0aCBFeHBvcnQncyBraW5kIGluZGV4LCBu YW1lZCAnIiwgZmllbGRTdHJpbmcsICInIik7CiAgICAgICAgIHN3aXRjaCAoZXhwLmtpbmQpIHsK ICAgICAgICAgY2FzZSBFeHRlcm5hbEtpbmQ6OkZ1bmN0aW9uOiB7Ci0gICAgICAgICAgICBXQVNN X1BBUlNFUl9GQUlMX0lGKGV4cC5raW5kSW5kZXggPj0gbV9yZXN1bHQuZnVuY3Rpb25JbmRleFNw YWNlLnNpemUoKSwgZXhwb3J0TnVtYmVyLCAidGggRXhwb3J0IGhhcyBpbnZhbGlkIGZ1bmN0aW9u IG51bWJlciAiLCBleHAua2luZEluZGV4LCAiIGl0IGV4Y2VlZHMgdGhlIGZ1bmN0aW9uIGluZGV4 IHNwYWNlICIsIG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCksICIsIG5hbWVkICci LCBmaWVsZFN0cmluZywgIiciKTsKKyAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZXhw LmtpbmRJbmRleCA+PSBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSwg ZXhwb3J0TnVtYmVyLCAidGggRXhwb3J0IGhhcyBpbnZhbGlkIGZ1bmN0aW9uIG51bWJlciAiLCBl eHAua2luZEluZGV4LCAiIGl0IGV4Y2VlZHMgdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlICIsIG1f cmVzdWx0Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpLCAiLCBuYW1lZCAnIiwgZmll bGRTdHJpbmcsICInIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQogICAgICAgICBj YXNlIEV4dGVybmFsS2luZDo6VGFibGU6IHsKQEAgLTQxNyw4ICs0MTIsOCBAQCBhdXRvIE1vZHVs ZVBhcnNlcjo6cGFyc2VTdGFydCgpIC0+IFBhcnRpYWxSZXN1bHQKIHsKICAgICB1aW50MzJfdCBz dGFydEZ1bmN0aW9uSW5kZXg7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50 MzIoc3RhcnRGdW5jdGlvbkluZGV4KSwgImNhbid0IGdldCBTdGFydCBpbmRleCIpOwotICAgIFdB U01fUEFSU0VSX0ZBSUxfSUYoc3RhcnRGdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0LmZ1bmN0aW9u SW5kZXhTcGFjZS5zaXplKCksICJTdGFydCBpbmRleCAiLCBzdGFydEZ1bmN0aW9uSW5kZXgsICIg ZXhjZWVkcyBmdW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3Bh Y2Uuc2l6ZSgpKTsKLSAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0 LmZ1bmN0aW9uSW5kZXhTcGFjZVtzdGFydEZ1bmN0aW9uSW5kZXhdLnNpZ25hdHVyZUluZGV4Owor ICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc3RhcnRGdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0Lm1v ZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpLCAiU3RhcnQgaW5kZXggIiwgc3RhcnRGdW5j dGlvbkluZGV4LCAiIGV4Y2VlZHMgZnVuY3Rpb24gaW5kZXggc3BhY2UgIiwgbV9yZXN1bHQubW9k dWxlLT5mdW5jdGlvbkluZGV4U3BhY2VTaXplKCkpOworICAgIFNpZ25hdHVyZUluZGV4IHNpZ25h dHVyZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbklu ZGV4U3BhY2Uoc3RhcnRGdW5jdGlvbkluZGV4KTsKICAgICBjb25zdCBTaWduYXR1cmUqIHNpZ25h dHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgc2lnbmF0dXJlSW5kZXgpOwog ICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc2lnbmF0dXJlLT5hcmd1bWVudENvdW50KCksICJTdGFy dCBmdW5jdGlvbiBjYW4ndCBoYXZlIGFyZ3VtZW50cyIpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxf SUYoc2lnbmF0dXJlLT5yZXR1cm5UeXBlKCkgIT0gVm9pZCwgIlN0YXJ0IGZ1bmN0aW9uIGNhbid0 IHJldHVybiBhIHZhbHVlIik7CkBAIC00NjksNyArNDY0LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6 OnBhcnNlRWxlbWVudCgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICAgICAgZm9yICh1bnNpZ25lZCBp bmRleCA9IDA7IGluZGV4IDwgaW5kZXhDb3VudDsgKytpbmRleCkgewogICAgICAgICAgICAgdWlu dDMyX3QgZnVuY3Rpb25JbmRleDsKICAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBh cnNlVmFyVUludDMyKGZ1bmN0aW9uSW5kZXgpLCAiY2FuJ3QgZ2V0IEVsZW1lbnQgc2VjdGlvbidz ICIsIGVsZW1lbnROdW0sICJ0aCBlbGVtZW50J3MgIiwgaW5kZXgsICJ0aCBpbmRleCIpOwotICAg ICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0LmZ1 bmN0aW9uSW5kZXhTcGFjZS5zaXplKCksICJFbGVtZW50IHNlY3Rpb24ncyAiLCBlbGVtZW50TnVt LCAidGggZWxlbWVudCdzICIsIGluZGV4LCAidGggaW5kZXggaXMgIiwgZnVuY3Rpb25JbmRleCwg IiB3aGljaCBleGNlZWRzIHRoZSBmdW5jdGlvbiBpbmRleCBzcGFjZSBzaXplIG9mICIsIG1fcmVz dWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCkpOworICAgICAgICAgICAgV0FTTV9QQVJTRVJf RkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNw YWNlU2l6ZSgpLCAiRWxlbWVudCBzZWN0aW9uJ3MgIiwgZWxlbWVudE51bSwgInRoIGVsZW1lbnQn cyAiLCBpbmRleCwgInRoIGluZGV4IGlzICIsIGZ1bmN0aW9uSW5kZXgsICIgd2hpY2ggZXhjZWVk cyB0aGUgZnVuY3Rpb24gaW5kZXggc3BhY2Ugc2l6ZSBvZiAiLCBtX3Jlc3VsdC5tb2R1bGUtPmZ1 bmN0aW9uSW5kZXhTcGFjZVNpemUoKSk7CiAKICAgICAgICAgICAgIGVsZW1lbnQuZnVuY3Rpb25J bmRpY2VzLnVuY2hlY2tlZEFwcGVuZChmdW5jdGlvbkluZGV4KTsKICAgICAgICAgfQpkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5oIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5oCmluZGV4IGUzYjc1YTcu LjdlMDI2YzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1 bGVQYXJzZXIuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFy c2VyLmgKQEAgLTM2LDggKzM2LDggQEAgbmFtZXNwYWNlIEpTQyB7IG5hbWVzcGFjZSBXYXNtIHsK IAogc3RydWN0IE1vZHVsZVBhcnNlclJlc3VsdCB7CiAgICAgc3RkOjp1bmlxdWVfcHRyPE1vZHVs ZUluZm9ybWF0aW9uPiBtb2R1bGU7Ci0gICAgRnVuY3Rpb25JbmRleFNwYWNlIGZ1bmN0aW9uSW5k ZXhTcGFjZTsKICAgICBWZWN0b3I8RnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5PiBmdW5jdGlvbkxv Y2F0aW9uSW5CaW5hcnk7CisgICAgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiBtb2R1bGVTaWduYXR1 cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlczsKIH07CiAKIGNsYXNzIE1vZHVsZVBh cnNlciA6IHB1YmxpYyBQYXJzZXI8TW9kdWxlUGFyc2VyUmVzdWx0PiB7CmRpZmYgLS1naXQgYS9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFnZUNvdW50LmNwcCBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21QYWdlQ291bnQuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAuLjRiODc3MDUKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtUGFnZUNvdW50LmNwcApAQCAtMCwwICsxLDQ1IEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDE2IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2Ug dGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4K KyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycn IEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwK KyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgor I2luY2x1ZGUgIldhc21QYWdlQ291bnQuaCIKKworI2lmIEVOQUJMRShXRUJBU1NFTUJMWSkKKwor I2luY2x1ZGUgPHd0Zi9QcmludFN0cmVhbS5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmlu Zy5oPgorCituYW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIFdhc20geworCit2b2lkIFBhZ2VDb3Vu dDo6ZHVtcChQcmludFN0cmVhbSYgb3V0KSBjb25zdAoreworICAgIG91dC5wcmludChTdHJpbmc6 Om51bWJlcihieXRlcygpKSwgIkIiKTsKK30KKworfSAvLyBuYW1lc3BhY2UgSlNDCisKK30gLy8g bmFtZXNwYWNlIFdhc20KKworI2VuZGlmIC8vIEVOQUJMRShXRUJBU1NFTUJMWSkKZGlmZiAtLWdp dCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QYWdlQ291bnQuaCBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21QYWdlQ291bnQuaAppbmRleCBhMTVkNTA1Li42N2RiYjU1 IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFnZUNvdW50LmgK KysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBhZ2VDb3VudC5oCkBAIC0yNyw2 ICsyNywxMCBAQAogCiAjaWYgRU5BQkxFKFdFQkFTU0VNQkxZKQogCituYW1lc3BhY2UgV1RGIHsK K2NsYXNzIFByaW50U3RyZWFtOworfQorCiBuYW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIFdhc20g ewogCiBjbGFzcyBQYWdlQ291bnQgewpAQCAtNDIsNiArNDYsOCBAQCBwdWJsaWM6CiAgICAgICAg IDogbV9wYWdlQ291bnQocGFnZUNvdW50KQogICAgIHsgfQogCisgICAgdm9pZCBkdW1wKFdURjo6 UHJpbnRTdHJlYW0mKSBjb25zdDsKKwogICAgIHVpbnQ2NF90IGJ5dGVzKCkgY29uc3QgeyByZXR1 cm4gc3RhdGljX2Nhc3Q8dWludDY0X3Q+KG1fcGFnZUNvdW50KSAqIHN0YXRpY19jYXN0PHVpbnQ2 NF90PihwYWdlU2l6ZSk7IH0KICAgICB1aW50MzJfdCBwYWdlQ291bnQoKSBjb25zdCB7IHJldHVy biBtX3BhZ2VDb3VudDsgfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtUGxhbi5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5jcHAK aW5kZXggZWQyOGJiYy4uMmQzNDIyZiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbVBsYW4uY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Q bGFuLmNwcApAQCAtNzYsOCArNzYsNyBAQCBib29sIFBsYW46OnBhcnNlQW5kVmFsaWRhdGVNb2R1 bGUoKQogICAgICAgICB9CiAgICAgICAgIG1fbW9kdWxlSW5mb3JtYXRpb24gPSBXVEZNb3ZlKHBh cnNlUmVzdWx0LT5tb2R1bGUpOwogICAgICAgICBtX2Z1bmN0aW9uTG9jYXRpb25JbkJpbmFyeSA9 IFdURk1vdmUocGFyc2VSZXN1bHQtPmZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeSk7Ci0gICAgICAg IG1fZnVuY3Rpb25JbmRleFNwYWNlLnNpemUgPSBwYXJzZVJlc3VsdC0+ZnVuY3Rpb25JbmRleFNw YWNlLnNpemUoKTsKLSAgICAgICAgbV9mdW5jdGlvbkluZGV4U3BhY2UuYnVmZmVyID0gcGFyc2VS ZXN1bHQtPmZ1bmN0aW9uSW5kZXhTcGFjZS5yZWxlYXNlQnVmZmVyKCk7CisgICAgICAgIG1fbW9k dWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMgPSBXVEZNb3ZlKHBh cnNlUmVzdWx0LT5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNl cyk7CiAgICAgfQogCiAgICAgZm9yICh1bnNpZ25lZCBmdW5jdGlvbkluZGV4ID0gMDsgZnVuY3Rp b25JbmRleCA8IG1fZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5LnNpemUoKTsgKytmdW5jdGlvbklu ZGV4KSB7CkBAIC04OSw3ICs4OCw3IEBAIGJvb2wgUGxhbjo6cGFyc2VBbmRWYWxpZGF0ZU1vZHVs ZSgpCiAgICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9tb2R1bGVJbmZv cm1hdGlvbi0+aW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXNbZnVuY3Rpb25JbmRleF07 CiAgICAgICAgIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlID0gU2lnbmF0dXJlSW5mb3JtYXRp b246OmdldChtX3ZtLCBzaWduYXR1cmVJbmRleCk7CiAKLSAgICAgICAgYXV0byB2YWxpZGF0aW9u UmVzdWx0ID0gdmFsaWRhdGVGdW5jdGlvbihtX3ZtLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxl bmd0aCwgc2lnbmF0dXJlLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZSwgKm1fbW9kdWxlSW5mb3JtYXRp b24pOworICAgICAgICBhdXRvIHZhbGlkYXRpb25SZXN1bHQgPSB2YWxpZGF0ZUZ1bmN0aW9uKG1f dm0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWduYXR1cmUsICptX21vZHVsZUlu Zm9ybWF0aW9uLCBtX21vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRp Y2VzKTsKICAgICAgICAgaWYgKCF2YWxpZGF0aW9uUmVzdWx0KSB7CiAgICAgICAgICAgICBpZiAo dmVyYm9zZSkgewogICAgICAgICAgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBmdW5j dGlvbkxlbmd0aDsgKytpKQpAQCAtMTI3LDcgKzEyNiw3IEBAIHZvaWQgUGxhbjo6cnVuKCkKICAg ICAgICAgcmV0dXJuIHRydWU7CiAgICAgfTsKIAotICAgIGlmICghdHJ5UmVzZXJ2ZUNhcGFjaXR5 KG1fd2FzbVRvSlNTdHVicywgbV9tb2R1bGVJbmZvcm1hdGlvbi0+aW1wb3J0RnVuY3Rpb25TaWdu YXR1cmVJbmRpY2VzLnNpemUoKSwgIiBXZWJBc3NlbWJseSB0byBKYXZhU2NyaXB0IHN0dWJzIikK KyAgICBpZiAoIXRyeVJlc2VydmVDYXBhY2l0eShtX3dhc21FeGl0U3R1YnMsIG1fbW9kdWxlSW5m b3JtYXRpb24tPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICIgV2ViQXNz ZW1ibHkgdG8gSmF2YVNjcmlwdCBzdHVicyIpCiAgICAgICAgIHx8ICF0cnlSZXNlcnZlQ2FwYWNp dHkobV91bmxpbmtlZFdhc21Ub1dhc21DYWxscywgbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnku c2l6ZSgpLCAiIHVubGlua2VkIFdlYkFzc2VtYmx5IHRvIFdlYkFzc2VtYmx5IGNhbGxzIikKICAg ICAgICAgfHwgIXRyeVJlc2VydmVDYXBhY2l0eShtX3dhc21JbnRlcm5hbEZ1bmN0aW9ucywgbV9m dW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgpLCAiIFdlYkFzc2VtYmx5IGZ1bmN0aW9ucyIp CiAgICAgICAgIHx8ICF0cnlSZXNlcnZlQ2FwYWNpdHkobV9jb21waWxhdGlvbkNvbnRleHRzLCBt X2Z1bmN0aW9uTG9jYXRpb25JbkJpbmFyeS5zaXplKCksICIgY29tcGlsYXRpb24gY29udGV4dHMi KSkKQEAgLTE0MSwxMiArMTQwLDExIEBAIHZvaWQgUGxhbjo6cnVuKCkKICAgICAgICAgSW1wb3J0 KiBpbXBvcnQgPSAmbV9tb2R1bGVJbmZvcm1hdGlvbi0+aW1wb3J0c1tpbXBvcnRJbmRleF07CiAg ICAgICAgIGlmIChpbXBvcnQtPmtpbmQgIT0gRXh0ZXJuYWxLaW5kOjpGdW5jdGlvbikKICAgICAg ICAgICAgIGNvbnRpbnVlOwotICAgICAgICB1bnNpZ25lZCBpbXBvcnRGdW5jdGlvbkluZGV4ID0g bV93YXNtVG9KU1N0dWJzLnNpemUoKTsKKyAgICAgICAgdW5zaWduZWQgaW1wb3J0RnVuY3Rpb25J bmRleCA9IG1fd2FzbUV4aXRTdHVicy5zaXplKCk7CiAgICAgICAgIGlmICh2ZXJib3NlKQogICAg ICAgICAgICAgZGF0YUxvZ0xuKCJQcm9jZXNzaW5nIGltcG9ydCBmdW5jdGlvbiBudW1iZXIgIiwg aW1wb3J0RnVuY3Rpb25JbmRleCwgIjogIiwgaW1wb3J0LT5tb2R1bGUsICI6ICIsIGltcG9ydC0+ ZmllbGQpOwogICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fbW9kdWxl SW5mb3JtYXRpb24tPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5hdChpbXBvcnQtPmtp bmRJbmRleCk7Ci0gICAgICAgIG1fd2FzbVRvSlNTdHVicy51bmNoZWNrZWRBcHBlbmQoaW1wb3J0 U3R1YkdlbmVyYXRvcihtX3ZtLCBtX2NhbGxMaW5rSW5mb3MsIHNpZ25hdHVyZUluZGV4LCBpbXBv cnRGdW5jdGlvbkluZGV4KSk7Ci0gICAgICAgIG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5n ZXQoKVtpbXBvcnRGdW5jdGlvbkluZGV4XS5jb2RlID0gbV93YXNtVG9KU1N0dWJzW2ltcG9ydEZ1 bmN0aW9uSW5kZXhdLmNvZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpOworICAgICAgICBtX3dhc21F eGl0U3R1YnMudW5jaGVja2VkQXBwZW5kKGV4aXRTdHViR2VuZXJhdG9yKG1fdm0sIG1fY2FsbExp bmtJbmZvcywgc2lnbmF0dXJlSW5kZXgsIGltcG9ydEZ1bmN0aW9uSW5kZXgpKTsKICAgICB9CiAK ICAgICBtX2N1cnJlbnRJbmRleCA9IDA7CkBAIC0xNjcsMTIgKzE2NSwxMiBAQCB2b2lkIFBsYW46 OnJ1bigpCiAgICAgICAgICAgICBBU1NFUlQoZnVuY3Rpb25MZW5ndGggPD0gbV9zb3VyY2VMZW5n dGgpOwogICAgICAgICAgICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtX21vZHVs ZUluZm9ybWF0aW9uLT5pbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbklu ZGV4XTsKICAgICAgICAgICAgIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlID0gU2lnbmF0dXJl SW5mb3JtYXRpb246OmdldChtX3ZtLCBzaWduYXR1cmVJbmRleCk7Ci0gICAgICAgICAgICB1bnNp Z25lZCBmdW5jdGlvbkluZGV4U3BhY2UgPSBtX3dhc21Ub0pTU3R1YnMuc2l6ZSgpICsgZnVuY3Rp b25JbmRleDsKLSAgICAgICAgICAgIEFTU0VSVF9VTlVTRUQoZnVuY3Rpb25JbmRleFNwYWNlLCBt X2Z1bmN0aW9uSW5kZXhTcGFjZS5idWZmZXIuZ2V0KClbZnVuY3Rpb25JbmRleFNwYWNlXS5zaWdu YXR1cmVJbmRleCA9PSBzaWduYXR1cmVJbmRleCk7Ci0gICAgICAgICAgICBBU1NFUlQodmFsaWRh dGVGdW5jdGlvbihtX3ZtLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJl LCBtX2Z1bmN0aW9uSW5kZXhTcGFjZSwgKm1fbW9kdWxlSW5mb3JtYXRpb24pKTsKKyAgICAgICAg ICAgIHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFjZSA9IG1fd2FzbUV4aXRTdHVicy5zaXplKCkg KyBmdW5jdGlvbkluZGV4OworICAgICAgICAgICAgQVNTRVJUX1VOVVNFRChmdW5jdGlvbkluZGV4 U3BhY2UsIG1fbW9kdWxlSW5mb3JtYXRpb24tPnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5k ZXhTcGFjZShmdW5jdGlvbkluZGV4U3BhY2UpID09IHNpZ25hdHVyZUluZGV4KTsKKyAgICAgICAg ICAgIEFTU0VSVCh2YWxpZGF0ZUZ1bmN0aW9uKG1fdm0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9u TGVuZ3RoLCBzaWduYXR1cmUsICptX21vZHVsZUluZm9ybWF0aW9uLCBtX21vZHVsZVNpZ25hdHVy ZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzKSk7CiAKICAgICAgICAgICAgIG1fdW5s aW5rZWRXYXNtVG9XYXNtQ2FsbHNbZnVuY3Rpb25JbmRleF0gPSBWZWN0b3I8VW5saW5rZWRXYXNt VG9XYXNtQ2FsbD4oKTsKLSAgICAgICAgICAgIGF1dG8gcGFyc2VBbmRDb21waWxlUmVzdWx0ID0g cGFyc2VBbmRDb21waWxlKCptX3ZtLCBtX2NvbXBpbGF0aW9uQ29udGV4dHNbZnVuY3Rpb25JbmRl eF0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWduYXR1cmUsIG1fdW5saW5rZWRX YXNtVG9XYXNtQ2FsbHNbZnVuY3Rpb25JbmRleF0sIG1fZnVuY3Rpb25JbmRleFNwYWNlLCAqbV9t b2R1bGVJbmZvcm1hdGlvbik7CisgICAgICAgICAgICBhdXRvIHBhcnNlQW5kQ29tcGlsZVJlc3Vs dCA9IHBhcnNlQW5kQ29tcGlsZSgqbV92bSwgbV9jb21waWxhdGlvbkNvbnRleHRzW2Z1bmN0aW9u SW5kZXhdLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBtX3VubGlu a2VkV2FzbVRvV2FzbUNhbGxzW2Z1bmN0aW9uSW5kZXhdLCAqbV9tb2R1bGVJbmZvcm1hdGlvbiwg bV9tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcyk7CiAKICAg ICAgICAgICAgIGlmIChVTkxJS0VMWSghcGFyc2VBbmRDb21waWxlUmVzdWx0KSkgewogICAgICAg ICAgICAgICAgIGF1dG8gbG9ja2VyID0gaG9sZExvY2sobV9sb2NrKTsKQEAgLTIwOSwxMCArMjA3 LDEyIEBAIHZvaWQgUGxhbjo6cnVuKCkKICAgICBmb3IgKHVpbnQzMl90IGZ1bmN0aW9uSW5kZXgg PSAwOyBmdW5jdGlvbkluZGV4IDwgbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgpOyBm dW5jdGlvbkluZGV4KyspIHsKICAgICAgICAgewogICAgICAgICAgICAgQ29tcGlsYXRpb25Db250 ZXh0JiBjb250ZXh0ID0gbV9jb21waWxhdGlvbkNvbnRleHRzW2Z1bmN0aW9uSW5kZXhdOworICAg ICAgICAgICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtX21vZHVsZUluZm9ybWF0 aW9uLT5pbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4XTsKKyAg ICAgICAgICAgIFN0cmluZyBzaWduYXR1cmVEZXNjcmlwdGlvbiA9IFNpZ25hdHVyZUluZm9ybWF0 aW9uOjpnZXQobV92bSwgc2lnbmF0dXJlSW5kZXgpLT50b1N0cmluZygpOwogICAgICAgICAgICAg ewogICAgICAgICAgICAgICAgIExpbmtCdWZmZXIgbGlua0J1ZmZlcigqbV92bSwgKmNvbnRleHQu d2FzbUVudHJ5cG9pbnRKSVQsIG51bGxwdHIpOwogICAgICAgICAgICAgICAgIG1fd2FzbUludGVy bmFsRnVuY3Rpb25zW2Z1bmN0aW9uSW5kZXhdLT53YXNtRW50cnlwb2ludC5jb21waWxhdGlvbiA9 Ci0gICAgICAgICAgICAgICAgICAgIHN0ZDo6bWFrZV91bmlxdWU8QjM6OkNvbXBpbGF0aW9uPihG SU5BTElaRV9DT0RFKGxpbmtCdWZmZXIsICgiV2FzbSBmdW5jdGlvbiIpKSwgV1RGTW92ZShjb250 ZXh0Lndhc21FbnRyeXBvaW50Qnlwcm9kdWN0cykpOworICAgICAgICAgICAgICAgICAgICBzdGQ6 Om1ha2VfdW5pcXVlPEIzOjpDb21waWxhdGlvbj4oRklOQUxJWkVfQ09ERShsaW5rQnVmZmVyLCAo IldlYkFzc2VtYmx5IGZ1bmN0aW9uWyVpXSAlcyIsIGZ1bmN0aW9uSW5kZXgsIHNpZ25hdHVyZURl c2NyaXB0aW9uLmFzY2lpKCkuZGF0YSgpKSksIFdURk1vdmUoY29udGV4dC53YXNtRW50cnlwb2lu dEJ5cHJvZHVjdHMpKTsKICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAgewpAQCAtMjIwLDEy ICsyMjAsOSBAQCB2b2lkIFBsYW46OnJ1bigpCiAgICAgICAgICAgICAgICAgbGlua0J1ZmZlci5s aW5rKGNvbnRleHQuanNFbnRyeXBvaW50VG9XYXNtRW50cnlwb2ludENhbGwsIEZ1bmN0aW9uUHRy KG1fd2FzbUludGVybmFsRnVuY3Rpb25zW2Z1bmN0aW9uSW5kZXhdLT53YXNtRW50cnlwb2ludC5j b21waWxhdGlvbi0+Y29kZSgpLmV4ZWN1dGFibGVBZGRyZXNzKCkpKTsKIAogICAgICAgICAgICAg ICAgIG1fd2FzbUludGVybmFsRnVuY3Rpb25zW2Z1bmN0aW9uSW5kZXhdLT5qc1RvV2FzbUVudHJ5 cG9pbnQuY29tcGlsYXRpb24gPQotICAgICAgICAgICAgICAgICAgICBzdGQ6Om1ha2VfdW5pcXVl PEIzOjpDb21waWxhdGlvbj4oRklOQUxJWkVfQ09ERShsaW5rQnVmZmVyLCAoIldhc20gSlMgZW50 cnlwb2ludCIpKSwgV1RGTW92ZShjb250ZXh0LmpzRW50cnlwb2ludEJ5cHJvZHVjdHMpKTsKKyAg ICAgICAgICAgICAgICAgICAgc3RkOjptYWtlX3VuaXF1ZTxCMzo6Q29tcGlsYXRpb24+KEZJTkFM SVpFX0NPREUobGlua0J1ZmZlciwgKCJKYXZhU2NyaXB0LT5XZWJBc3NlbWJseSBlbnRyeXBvaW50 WyVpXSAlcyIsIGZ1bmN0aW9uSW5kZXgsIHNpZ25hdHVyZURlc2NyaXB0aW9uLmFzY2lpKCkuZGF0 YSgpKSksIFdURk1vdmUoY29udGV4dC5qc0VudHJ5cG9pbnRCeXByb2R1Y3RzKSk7CiAgICAgICAg ICAgICB9CiAgICAgICAgIH0KLQotICAgICAgICB1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2Ug PSBtX3dhc21Ub0pTU3R1YnMuc2l6ZSgpICsgZnVuY3Rpb25JbmRleDsKLSAgICAgICAgbV9mdW5j dGlvbkluZGV4U3BhY2UuYnVmZmVyLmdldCgpW2Z1bmN0aW9uSW5kZXhTcGFjZV0uY29kZSA9IG1f d2FzbUludGVybmFsRnVuY3Rpb25zW2Z1bmN0aW9uSW5kZXhdLT53YXNtRW50cnlwb2ludC5jb21w aWxhdGlvbi0+Y29kZSgpLmV4ZWN1dGFibGVBZGRyZXNzKCk7CiAgICAgfQogCiAgICAgaWYgKHZl cmJvc2UgfHwgT3B0aW9uczo6cmVwb3J0Q29tcGlsZVRpbWVzKCkpIHsKQEAgLTIzNSw4ICsyMzIs MTkgQEAgdm9pZCBQbGFuOjpydW4oKQogCiAgICAgLy8gUGF0Y2ggdGhlIGNhbGwgc2l0ZXMgZm9y IGVhY2ggV2ViQXNzZW1ibHkgZnVuY3Rpb24uCiAgICAgZm9yIChhdXRvJiB1bmxpbmtlZCA6IG1f dW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMpIHsKLSAgICAgICAgZm9yIChhdXRvJiBjYWxsIDogdW5s aW5rZWQpCi0gICAgICAgICAgICBNYWNyb0Fzc2VtYmxlcjo6cmVwYXRjaENhbGwoY2FsbC5jYWxs TG9jYXRpb24sIENvZGVMb2NhdGlvbkxhYmVsKG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5n ZXQoKVtjYWxsLmZ1bmN0aW9uSW5kZXhdLmNvZGUpKTsKKyAgICAgICAgZm9yIChhdXRvJiBjYWxs IDogdW5saW5rZWQpIHsKKyAgICAgICAgICAgIHZvaWQqIGV4ZWN1dGFibGVBZGRyZXNzOworICAg ICAgICAgICAgaWYgKG1fbW9kdWxlSW5mb3JtYXRpb24tPmlzSW1wb3J0ZWRGdW5jdGlvbkZyb21G dW5jdGlvbkluZGV4U3BhY2UoY2FsbC5mdW5jdGlvbkluZGV4KSkgeworICAgICAgICAgICAgICAg IC8vIEZJWE1FIGltcG9ydHMgY291bGQgaGF2ZSBiZWVuIGxpbmtlZCBpbiBCMywgaW5zdGVhZCBv ZiBnZW5lcmF0aW5nIGEgcGF0Y2hwb2ludC4gVGhpcyBjb25kaXRpb24gc2hvdWxkIGJlIHJlcGxh Y2VkIGJ5IGEgUkVMRUFTRV9BU1NFUlQuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xNjY0NjIKKyAgICAgICAgICAgICAgICBleGVjdXRhYmxlQWRkcmVzcyA9IGNhbGwu dGFyZ2V0ID09IFVubGlua2VkV2FzbVRvV2FzbUNhbGw6OlRhcmdldDo6dG9KUworICAgICAgICAg ICAgICAgICAgICA/IG1fd2FzbUV4aXRTdHVicy5hdChjYWxsLmZ1bmN0aW9uSW5kZXgpLndhc21U b0pTLmNvZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpCisgICAgICAgICAgICAgICAgICAgIDogbV93 YXNtRXhpdFN0dWJzLmF0KGNhbGwuZnVuY3Rpb25JbmRleCkud2FzbVRvV2FzbS5jb2RlKCkuZXhl Y3V0YWJsZUFkZHJlc3MoKTsKKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAg QVNTRVJUKGNhbGwudGFyZ2V0ICE9IFVubGlua2VkV2FzbVRvV2FzbUNhbGw6OlRhcmdldDo6dG9K Uyk7CisgICAgICAgICAgICAgICAgZXhlY3V0YWJsZUFkZHJlc3MgPSBtX3dhc21JbnRlcm5hbEZ1 bmN0aW9ucy5hdChjYWxsLmZ1bmN0aW9uSW5kZXggLSBtX3dhc21FeGl0U3R1YnMuc2l6ZSgpKS0+ d2FzbUVudHJ5cG9pbnQuY29tcGlsYXRpb24tPmNvZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpOwor ICAgICAgICAgICAgfQorICAgICAgICAgICAgTWFjcm9Bc3NlbWJsZXI6OnJlcGF0Y2hDYWxsKGNh bGwuY2FsbExvY2F0aW9uLCBDb2RlTG9jYXRpb25MYWJlbChleGVjdXRhYmxlQWRkcmVzcykpOwor ICAgICAgICB9CiAgICAgfQogCiAgICAgbV9mYWlsZWQgPSBmYWxzZTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtUGxhbi5oCmluZGV4IDNiYjAxYzguLjY5ODBiZGIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmgKKysrIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbVBsYW4uaApAQCAtODYsMjYgKzg2LDIwIEBAIHB1YmxpYzoKICAgICAg ICAgcmV0dXJuIFdURk1vdmUobV9jYWxsTGlua0luZm9zKTsKICAgICB9CiAKLSAgICBWZWN0b3I8 V2FzbVRvSlNTdHViPiYmIHRha2VXYXNtVG9KU1N0dWJzKCkKKyAgICBWZWN0b3I8V2FzbUV4aXRT dHVicz4mJiB0YWtlV2FzbUV4aXRTdHVicygpCiAgICAgewogICAgICAgICBSRUxFQVNFX0FTU0VS VCghZmFpbGVkKCkpOwotICAgICAgICByZXR1cm4gV1RGTW92ZShtX3dhc21Ub0pTU3R1YnMpOwot ICAgIH0KLQotICAgIEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmIHRha2VGdW5jdGlvbklu ZGV4U3BhY2UoKQotICAgIHsKLSAgICAgICAgUkVMRUFTRV9BU1NFUlQoIWZhaWxlZCgpKTsKLSAg ICAgICAgcmV0dXJuIFdURk1vdmUobV9mdW5jdGlvbkluZGV4U3BhY2UpOworICAgICAgICByZXR1 cm4gV1RGTW92ZShtX3dhc21FeGl0U3R1YnMpOwogICAgIH0KIAogcHJpdmF0ZToKICAgICBzdGQ6 OnVuaXF1ZV9wdHI8TW9kdWxlSW5mb3JtYXRpb24+IG1fbW9kdWxlSW5mb3JtYXRpb247CiAgICAg VmVjdG9yPEZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeT4gbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5h cnk7CisgICAgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiBtX21vZHVsZVNpZ25hdHVyZUluZGljZXNU b1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzOwogICAgIEJhZzxDYWxsTGlua0luZm8+IG1fY2FsbExp bmtJbmZvczsKLSAgICBWZWN0b3I8V2FzbVRvSlNTdHViPiBtX3dhc21Ub0pTU3R1YnM7CisgICAg VmVjdG9yPFdhc21FeGl0U3R1YnM+IG1fd2FzbUV4aXRTdHViczsKICAgICBWZWN0b3I8c3RkOjp1 bmlxdWVfcHRyPFdhc21JbnRlcm5hbEZ1bmN0aW9uPj4gbV93YXNtSW50ZXJuYWxGdW5jdGlvbnM7 CiAgICAgVmVjdG9yPENvbXBpbGF0aW9uQ29udGV4dD4gbV9jb21waWxhdGlvbkNvbnRleHRzOwot ICAgIEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSBtX2Z1bmN0aW9uSW5kZXhTcGFjZTsKIAog ICAgIFZNKiBtX3ZtOwogICAgIFZlY3RvcjxWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4+ IG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21TaWduYXR1cmUuY3BwCmluZGV4IDZkNWIxZjYuLjA5NjZkYWIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuY3BwCisrKyBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuY3BwCkBAIC00MSwxMiArNDEsMjIgQEAg Y29uc3QgYm9vbCB2ZXJib3NlID0gZmFsc2U7CiAKIGNvbnN0IGNvbnN0ZXhwciBTaWduYXR1cmVJ bmRleCBTaWduYXR1cmU6OmludmFsaWRJbmRleDsKIAorU3RyaW5nIFNpZ25hdHVyZTo6dG9TdHJp bmcoKSBjb25zdAoreworICAgIFN0cmluZyByZXN1bHQobWFrZVN0cmluZyhyZXR1cm5UeXBlKCkp KTsKKyAgICByZXN1bHQuYXBwZW5kKCIgKCIpOworICAgIGZvciAoU2lnbmF0dXJlQXJnQ291bnQg YXJnID0gMDsgYXJnIDwgYXJndW1lbnRDb3VudCgpOyArK2FyZykgeworICAgICAgICBpZiAoYXJn KQorICAgICAgICAgICAgcmVzdWx0LmFwcGVuZCgiLCAiKTsKKyAgICAgICAgcmVzdWx0LmFwcGVu ZChtYWtlU3RyaW5nKGFyZ3VtZW50KGFyZykpKTsKKyAgICB9CisgICAgcmVzdWx0LmFwcGVuZCgn KScpOworICAgIHJldHVybiByZXN1bHQ7Cit9CisKIHZvaWQgU2lnbmF0dXJlOjpkdW1wKFByaW50 U3RyZWFtJiBvdXQpIGNvbnN0CiB7Ci0gICAgb3V0LnByaW50KG1ha2VTdHJpbmcocmV0dXJuVHlw ZSgpKSwgIiAoIik7Ci0gICAgZm9yIChTaWduYXR1cmVBcmdDb3VudCBhcmcgPSAwOyBhcmcgPCBh cmd1bWVudENvdW50KCk7ICsrYXJnKQotICAgICAgICBvdXQucHJpbnQoKGFyZyA/ICIsICIgOiAi IiksIG1ha2VTdHJpbmcoYXJndW1lbnQoYXJnKSkpOwotICAgIG91dC5wcmludCgiKSIpOworICAg IG91dC5wcmludCh0b1N0cmluZygpKTsKIH0KIAogdW5zaWduZWQgU2lnbmF0dXJlOjpoYXNoKCkg Y29uc3QKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1 cmUuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuaAppbmRleCAw ZDZjN2I1Li40ZDQzZmZjIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9X YXNtU2lnbmF0dXJlLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVNpZ25h dHVyZS5oCkBAIC04Miw2ICs4Miw3IEBAIHB1YmxpYzoKICAgICB9CiAgICAgVHlwZSBhcmd1bWVu dChTaWduYXR1cmVBcmdDb3VudCBpKSBjb25zdCB7IHJldHVybiBjb25zdF9jYXN0PFNpZ25hdHVy ZSo+KHRoaXMpLT5hcmd1bWVudChpKTsgfQogCisgICAgV1RGOjpTdHJpbmcgdG9TdHJpbmcoKSBj b25zdDsKICAgICB2b2lkIGR1bXAoV1RGOjpQcmludFN0cmVhbSYgb3V0KSBjb25zdDsKICAgICBi b29sIG9wZXJhdG9yPT0oY29uc3QgU2lnbmF0dXJlJiByaHMpIGNvbnN0CiAgICAgewpkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmNwcCBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5jcHAKaW5kZXggZTMyMTYxMy4uNzVk MzgyNiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRl LmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwCkBA IC0zODEsMTAgKzM4MSwxMCBAQCB2b2lkIFZhbGlkYXRlOjpkdW1wKGNvbnN0IFZlY3RvcjxDb250 cm9sRW50cnk+JiBjb250cm9sU3RhY2ssIGNvbnN0IEV4cHJlc3Npb25MaQogICAgIGRhdGFMb2dM bigpOwogfQogCi1FeHBlY3RlZDx2b2lkLCBTdHJpbmc+IHZhbGlkYXRlRnVuY3Rpb24oVk0qIHZt LCBjb25zdCB1aW50OF90KiBzb3VyY2UsIHNpemVfdCBsZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSog c2lnbmF0dXJlLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIGZ1bmN0aW9uSW5k ZXhTcGFjZSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIG1vZHVsZSkKK0V4cGVjdGVkPHZvaWQs IFN0cmluZz4gdmFsaWRhdGVGdW5jdGlvbihWTSogdm0sIGNvbnN0IHVpbnQ4X3QqIHNvdXJjZSwg c2l6ZV90IGxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUsIGNvbnN0IE1vZHVsZUlu Zm9ybWF0aW9uJiBtb2R1bGUsIGNvbnN0IFZlY3RvcjxTaWduYXR1cmVJbmRleD4mIG1vZHVsZVNp Z25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzKQogewogICAgIFZhbGlkYXRl IGNvbnRleHQobW9kdWxlKTsKLSAgICBGdW5jdGlvblBhcnNlcjxWYWxpZGF0ZT4gdmFsaWRhdG9y KHZtLCBjb250ZXh0LCBzb3VyY2UsIGxlbmd0aCwgc2lnbmF0dXJlLCBmdW5jdGlvbkluZGV4U3Bh Y2UsIG1vZHVsZSk7CisgICAgRnVuY3Rpb25QYXJzZXI8VmFsaWRhdGU+IHZhbGlkYXRvcih2bSwg Y29udGV4dCwgc291cmNlLCBsZW5ndGgsIHNpZ25hdHVyZSwgbW9kdWxlLCBtb2R1bGVTaWduYXR1 cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcyk7CiAgICAgV0FTTV9GQUlMX0lGX0hF TFBFUl9GQUlMUyh2YWxpZGF0b3IucGFyc2UoKSk7CiAgICAgcmV0dXJuIHsgfTsKIH0KZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5oIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmgKaW5kZXggMTQ4MjFmMi4uNzNlN2Q4 NyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmgK KysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmgKQEAgLTM2LDcg KzM2LDcgQEAgY2xhc3MgVk07CiAKIG5hbWVzcGFjZSBXYXNtIHsKIAotRXhwZWN0ZWQ8dm9pZCwg U3RyaW5nPiB2YWxpZGF0ZUZ1bmN0aW9uKFZNKiwgY29uc3QgdWludDhfdCosIHNpemVfdCwgY29u c3QgU2lnbmF0dXJlKiwgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiwgY29uc3Qg TW9kdWxlSW5mb3JtYXRpb24mKTsKK0V4cGVjdGVkPHZvaWQsIFN0cmluZz4gdmFsaWRhdGVGdW5j dGlvbihWTSosIGNvbnN0IHVpbnQ4X3QqLCBzaXplX3QsIGNvbnN0IFNpZ25hdHVyZSosIGNvbnN0 IE1vZHVsZUluZm9ybWF0aW9uJiwgY29uc3QgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiYpOwogCiB9 IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2FzbQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5oCmluZGV4IDkyOGY0MjMuLjU0YWUx N2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1i bHlJbnN0YW5jZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNz ZW1ibHlJbnN0YW5jZS5oCkBAIC00Miw3ICs0Miw3IEBAIHB1YmxpYzoKICAgICB0eXBlZGVmIEpT RGVzdHJ1Y3RpYmxlT2JqZWN0IEJhc2U7CiAKIAotICAgIHN0YXRpYyBKU1dlYkFzc2VtYmx5SW5z dGFuY2UqIGNyZWF0ZShWTSYsIFN0cnVjdHVyZSosIEpTV2ViQXNzZW1ibHlNb2R1bGUqLCBKU01v ZHVsZU5hbWVzcGFjZU9iamVjdCopOworICAgIEpTX0VYUE9SVF9QUklWQVRFIHN0YXRpYyBKU1dl YkFzc2VtYmx5SW5zdGFuY2UqIGNyZWF0ZShWTSYsIFN0cnVjdHVyZSosIEpTV2ViQXNzZW1ibHlN b2R1bGUqLCBKU01vZHVsZU5hbWVzcGFjZU9iamVjdCopOwogICAgIHN0YXRpYyBTdHJ1Y3R1cmUq IGNyZWF0ZVN0cnVjdHVyZShWTSYsIEpTR2xvYmFsT2JqZWN0KiwgSlNWYWx1ZSk7CiAKICAgICBE RUNMQVJFX0lORk87CkBAIC04Niw5ICs4NiwxMSBAQCBwdWJsaWM6CiAgICAgICAgIHJldHVybiBv ZmZzZXRPZkltcG9ydEZ1bmN0aW9ucygpICsgc2l6ZW9mKFdyaXRlQmFycmllcjxKU0NlbGw+KSAq IGlkeDsKICAgICB9CiAKLSAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mVGFibGUoKSB7IHJl dHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseUluc3RhbmNlLCBtX3RhYmxlKTsgfQog ICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZNZW1vcnkoKSB7IHJldHVybiBPQkpFQ1RfT0ZG U0VUT0YoSlNXZWJBc3NlbWJseUluc3RhbmNlLCBtX21lbW9yeSk7IH0KKyAgICBzdGF0aWMgcHRy ZGlmZl90IG9mZnNldE9mVGFibGUoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3Nl bWJseUluc3RhbmNlLCBtX3RhYmxlKTsgfQogICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZH bG9iYWxzKCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKEpTV2ViQXNzZW1ibHlJbnN0YW5jZSwg bV9nbG9iYWxzKTsgfQorICAgIHN0YXRpYyBzaXplX3Qgb2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbnMo KSB7IHJldHVybiBXVEY6OnJvdW5kVXBUb011bHRpcGxlT2Y8c2l6ZW9mKFdyaXRlQmFycmllcjxK U0NlbGw+KT4oc2l6ZW9mKEpTV2ViQXNzZW1ibHlJbnN0YW5jZSkpOyB9CisgICAgc3RhdGljIHNp emVfdCBvZmZzZXRPZkltcG9ydEZ1bmN0aW9uKHNpemVfdCBpbXBvcnRGdW5jdGlvbk51bSkgeyBy ZXR1cm4gb2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbnMoKSArIGltcG9ydEZ1bmN0aW9uTnVtICogc2l6 ZW9mKHNpemVvZihXcml0ZUJhcnJpZXI8SlNDZWxsPikpOyB9CiAKIHByb3RlY3RlZDoKICAgICBK U1dlYkFzc2VtYmx5SW5zdGFuY2UoVk0mLCBTdHJ1Y3R1cmUqLCB1bnNpZ25lZCBudW1JbXBvcnRG dW5jdGlvbnMpOwpAQCAtOTYsMTEgKzk4LDYgQEAgcHJvdGVjdGVkOgogICAgIHN0YXRpYyB2b2lk IGRlc3Ryb3koSlNDZWxsKik7CiAgICAgc3RhdGljIHZvaWQgdmlzaXRDaGlsZHJlbihKU0NlbGwq LCBTbG90VmlzaXRvciYpOwogCi0gICAgc3RhdGljIHNpemVfdCBvZmZzZXRPZkltcG9ydEZ1bmN0 aW9ucygpCi0gICAgewotICAgICAgICByZXR1cm4gV1RGOjpyb3VuZFVwVG9NdWx0aXBsZU9mPHNp emVvZihXcml0ZUJhcnJpZXI8SlNDZWxsPik+KHNpemVvZihKU1dlYkFzc2VtYmx5SW5zdGFuY2Up KTsKLSAgICB9Ci0KICAgICBzdGF0aWMgc2l6ZV90IGFsbG9jYXRpb25TaXplKHVuc2lnbmVkIG51 bUltcG9ydEZ1bmN0aW9ucykKICAgICB7CiAgICAgICAgIHJldHVybiBvZmZzZXRPZkltcG9ydEZ1 bmN0aW9ucygpICsgc2l6ZW9mKFdyaXRlQmFycmllcjxKU0NlbGw+KSAqIG51bUltcG9ydEZ1bmN0 aW9uczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNz ZW1ibHlNZW1vcnkuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3Nl bWJseU1lbW9yeS5jcHAKaW5kZXggNTI4YWI2OS4uNGM0Y2MzZSAxMDA2NDQKLS0tIGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5jcHAKKysrIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5jcHAKQEAgLTM3 LDkgKzM3LDkgQEAgbmFtZXNwYWNlIEpTQyB7CiAKIGNvbnN0IENsYXNzSW5mbyBKU1dlYkFzc2Vt Ymx5TWVtb3J5OjpzX2luZm8gPSB7ICJXZWJBc3NlbWJseS5NZW1vcnkiLCAmQmFzZTo6c19pbmZv LCAwLCBDUkVBVEVfTUVUSE9EX1RBQkxFKEpTV2ViQXNzZW1ibHlNZW1vcnkpIH07CiAKLUpTV2Vi QXNzZW1ibHlNZW1vcnkqIEpTV2ViQXNzZW1ibHlNZW1vcnk6OmNyZWF0ZShWTSYgdm0sIFN0cnVj dHVyZSogc3RydWN0dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiYmIG1lbW9yeSkK K0pTV2ViQXNzZW1ibHlNZW1vcnkqIEpTV2ViQXNzZW1ibHlNZW1vcnk6OmNyZWF0ZShWTSYgdm0s IFN0cnVjdHVyZSogc3RydWN0dXJlLCBXYXNtOjpNZW1vcnkmJiBtZW1vcnkpCiB7Ci0gICAgYXV0 byogaW5zdGFuY2UgPSBuZXcgKE5vdE51bGwsIGFsbG9jYXRlQ2VsbDxKU1dlYkFzc2VtYmx5TWVt b3J5Pih2bS5oZWFwKSkgSlNXZWJBc3NlbWJseU1lbW9yeSh2bSwgc3RydWN0dXJlLCBXVEZNb3Zl KG1lbW9yeSkpOworICAgIGF1dG8qIGluc3RhbmNlID0gbmV3IChOb3ROdWxsLCBhbGxvY2F0ZUNl bGw8SlNXZWJBc3NlbWJseU1lbW9yeT4odm0uaGVhcCkpIEpTV2ViQXNzZW1ibHlNZW1vcnkodm0s IHN0cnVjdHVyZSwgc3RkOjpmb3J3YXJkPFdhc206Ok1lbW9yeT4obWVtb3J5KSk7CiAgICAgaW5z dGFuY2UtPmZpbmlzaENyZWF0aW9uKHZtKTsKICAgICByZXR1cm4gaW5zdGFuY2U7CiB9CkBAIC00 OSw3ICs0OSw3IEBAIFN0cnVjdHVyZSogSlNXZWJBc3NlbWJseU1lbW9yeTo6Y3JlYXRlU3RydWN0 dXJlKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iCiAgICAgcmV0dXJuIFN0cnVjdHVy ZTo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3QsIHByb3RvdHlwZSwgVHlwZUluZm8oT2JqZWN0VHlw ZSwgU3RydWN0dXJlRmxhZ3MpLCBpbmZvKCkpOwogfQogCi1KU1dlYkFzc2VtYmx5TWVtb3J5OjpK U1dlYkFzc2VtYmx5TWVtb3J5KFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6dW5p cXVlX3B0cjxXYXNtOjpNZW1vcnk+JiYgbWVtb3J5KQorSlNXZWJBc3NlbWJseU1lbW9yeTo6SlNX ZWJBc3NlbWJseU1lbW9yeShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBXYXNtOjpNZW1v cnkmJiBtZW1vcnkpCiAgICAgOiBCYXNlKHZtLCBzdHJ1Y3R1cmUpCiAgICAgLCBtX21lbW9yeShX VEZNb3ZlKG1lbW9yeSkpCiB7CkBAIC03Miw3ICs3Miw3IEBAIEpTQXJyYXlCdWZmZXIqIEpTV2Vi QXNzZW1ibHlNZW1vcnk6OmJ1ZmZlcihWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmpl Y3QpCiAgICAgYXV0byBkZXN0cnVjdG9yID0gW10gKHZvaWQqKSB7CiAgICAgICAgIC8vIFdlIGRv bid0IG5lZWQgdG8gZG8gYW55dGhpbmcgaGVyZSB0byBkZXN0cm95IHRoZSBtZW1vcnkuCiAgICAg ICAgIC8vIFRoZSBBcnJheUJ1ZmZlciBiYWNraW5nIHRoZSBKU0FycmF5QnVmZmVyIGlzIG9ubHkg b3duZWQgYnkgdXMsCi0gICAgICAgIC8vIHNvIHdlIGd1YXJhbnRlZSBpdHMgbGlmZWN5bGNlLgor ICAgICAgICAvLyBzbyB3ZSBndWFyYW50ZWUgaXRzIGxpZmVjeWNsZS4KICAgICB9OwogICAgIG1f YnVmZmVyID0gQXJyYXlCdWZmZXI6OmNyZWF0ZUZyb21CeXRlcyhtZW1vcnkoKS0+bWVtb3J5KCks IG1lbW9yeSgpLT5zaXplKCksIFdURk1vdmUoZGVzdHJ1Y3RvcikpOwogICAgIG1fYnVmZmVyV3Jh cHBlci5zZXQodm0sIHRoaXMsIEpTQXJyYXlCdWZmZXI6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0 LT5tX2FycmF5QnVmZmVyU3RydWN0dXJlLmdldCgpLCBtX2J1ZmZlci5nZXQoKSkpOwpAQCAtODUs NyArODUsNyBAQCBXYXNtOjpQYWdlQ291bnQgSlNXZWJBc3NlbWJseU1lbW9yeTo6Z3JvdyhFeGVj U3RhdGUqIGV4ZWMsIHVpbnQzMl90IGRlbHRhLCBib29sCiAgICAgVk0mIHZtID0gZXhlYy0+dm0o KTsKICAgICBhdXRvIHRocm93U2NvcGUgPSBERUNMQVJFX1RIUk9XX1NDT1BFKHZtKTsKIAotICAg IFdhc206OlBhZ2VDb3VudCBvbGRQYWdlQ291bnQgPSBtX21lbW9yeS0+c2l6ZUluUGFnZXMoKTsK KyAgICBXYXNtOjpQYWdlQ291bnQgb2xkUGFnZUNvdW50ID0gbWVtb3J5KCktPnNpemVJblBhZ2Vz KCk7CiAKICAgICBpZiAoIVdhc206OlBhZ2VDb3VudDo6aXNWYWxpZChkZWx0YSkpIHsKICAgICAg ICAgaWYgKHNob3VsZFRocm93RXhjZXB0aW9uc09uRmFpbHVyZSkKQEAgLTEwMSw3ICsxMDEsNyBA QCBXYXNtOjpQYWdlQ291bnQgSlNXZWJBc3NlbWJseU1lbW9yeTo6Z3JvdyhFeGVjU3RhdGUqIGV4 ZWMsIHVpbnQzMl90IGRlbHRhLCBib29sCiAgICAgfQogCiAgICAgaWYgKGRlbHRhKSB7Ci0gICAg ICAgIGJvb2wgc3VjY2VzcyA9IG1fbWVtb3J5LT5ncm93KG5ld1NpemUpOworICAgICAgICBib29s IHN1Y2Nlc3MgPSBtZW1vcnkoKS0+Z3JvdyhuZXdTaXplKTsKICAgICAgICAgaWYgKCFzdWNjZXNz KSB7CiAgICAgICAgICAgICBpZiAoc2hvdWxkVGhyb3dFeGNlcHRpb25zT25GYWlsdXJlKQogICAg ICAgICAgICAgICAgIHRocm93RXhjZXB0aW9uKGV4ZWMsIHRocm93U2NvcGUsIGNyZWF0ZU91dE9m TWVtb3J5RXJyb3IoZXhlYykpOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v anMvSlNXZWJBc3NlbWJseU1lbW9yeS5oCmluZGV4IDI4Nzk3YzYuLjM5YTM1YmIgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuaAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmgK QEAgLTQxLDI1ICs0MSwyNiBAQCBjbGFzcyBKU1dlYkFzc2VtYmx5TWVtb3J5IDogcHVibGljIEpT RGVzdHJ1Y3RpYmxlT2JqZWN0IHsKIHB1YmxpYzoKICAgICB0eXBlZGVmIEpTRGVzdHJ1Y3RpYmxl T2JqZWN0IEJhc2U7CiAKLSAgICBzdGF0aWMgSlNXZWJBc3NlbWJseU1lbW9yeSogY3JlYXRlKFZN JiwgU3RydWN0dXJlKiwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1lbW9yeT4mJik7CisgICAgSlNf RVhQT1JUX1BSSVZBVEUgc3RhdGljIEpTV2ViQXNzZW1ibHlNZW1vcnkqIGNyZWF0ZShWTSYsIFN0 cnVjdHVyZSosIFdhc206Ok1lbW9yeSYmKTsKICAgICBzdGF0aWMgU3RydWN0dXJlKiBjcmVhdGVT dHJ1Y3R1cmUoVk0mLCBKU0dsb2JhbE9iamVjdCosIEpTVmFsdWUpOwogCi0gICAgREVDTEFSRV9J TkZPOworICAgIERFQ0xBUkVfRVhQT1JUX0lORk87CiAKLSAgICBXYXNtOjpNZW1vcnkqIG1lbW9y eSgpIHsgcmV0dXJuIG1fbWVtb3J5LmdldCgpOyB9CisgICAgV2FzbTo6TWVtb3J5KiBtZW1vcnko KSB7IHJldHVybiAmbV9tZW1vcnk7IH0KICAgICBKU0FycmF5QnVmZmVyKiBidWZmZXIoVk0mIHZt LCBKU0dsb2JhbE9iamVjdCopOwogICAgIFdhc206OlBhZ2VDb3VudCBncm93KEV4ZWNTdGF0ZSos IHVpbnQzMl90IGRlbHRhLCBib29sIHNob3VsZFRocm93RXhjZXB0aW9uc09uRmFpbHVyZSk7CiAK LSAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mTWVtb3J5KCkgeyByZXR1cm4gT0JKRUNUX09G RlNFVE9GKEpTV2ViQXNzZW1ibHlNZW1vcnksIG1fbWVtb3J5KTsgfQorICAgIHN0YXRpYyBwdHJk aWZmX3Qgb2Zmc2V0T2ZNZW1vcnkoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3Nl bWJseU1lbW9yeSwgbV9tZW1vcnkpICsgV2FzbTo6TWVtb3J5OjpvZmZzZXRPZk1lbW9yeSgpOyB9 CisgICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZlNpemUoKSB7IHJldHVybiBPQkpFQ1RfT0ZG U0VUT0YoSlNXZWJBc3NlbWJseU1lbW9yeSwgbV9tZW1vcnkpICsgV2FzbTo6TWVtb3J5OjpvZmZz ZXRPZlNpemUoKTsgfQogCiBwcm90ZWN0ZWQ6Ci0gICAgSlNXZWJBc3NlbWJseU1lbW9yeShWTSYs IFN0cnVjdHVyZSosIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+JiYpOworICAgIEpTV2Vi QXNzZW1ibHlNZW1vcnkoVk0mLCBTdHJ1Y3R1cmUqLCBXYXNtOjpNZW1vcnkmJik7CiAgICAgfkpT V2ViQXNzZW1ibHlNZW1vcnkoKTsKICAgICB2b2lkIGZpbmlzaENyZWF0aW9uKFZNJik7CiAgICAg c3RhdGljIHZvaWQgZGVzdHJveShKU0NlbGwqKTsKICAgICBzdGF0aWMgdm9pZCB2aXNpdENoaWxk cmVuKEpTQ2VsbCosIFNsb3RWaXNpdG9yJik7CiAKLSAgICBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6 TWVtb3J5PiBtX21lbW9yeTsKKyAgICBXYXNtOjpNZW1vcnkgbV9tZW1vcnk7CiAgICAgV3JpdGVC YXJyaWVyPEpTQXJyYXlCdWZmZXI+IG1fYnVmZmVyV3JhcHBlcjsKICAgICBSZWZQdHI8QXJyYXlC dWZmZXI+IG1fYnVmZmVyOwogfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5jcHAKaW5kZXggZDY1MjRjNS4uZmEwZTg1OSAxMDA2 NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVs ZS5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1v ZHVsZS5jcHAKQEAgLTM4LDkgKzM4LDkgQEAgbmFtZXNwYWNlIEpTQyB7CiAKIGNvbnN0IENsYXNz SW5mbyBKU1dlYkFzc2VtYmx5TW9kdWxlOjpzX2luZm8gPSB7ICJXZWJBc3NlbWJseS5Nb2R1bGUi LCAmQmFzZTo6c19pbmZvLCBudWxscHRyLCBDUkVBVEVfTUVUSE9EX1RBQkxFKEpTV2ViQXNzZW1i bHlNb2R1bGUpIH07CiAKLUpTV2ViQXNzZW1ibHlNb2R1bGUqIEpTV2ViQXNzZW1ibHlNb2R1bGU6 OmNyZWF0ZShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8V2Fz bTo6TW9kdWxlSW5mb3JtYXRpb24+JiYgbW9kdWxlSW5mb3JtYXRpb24sIEJhZzxDYWxsTGlua0lu Zm8+JiYgY2FsbExpbmtJbmZvcywgVmVjdG9yPFdhc206Oldhc21Ub0pTU3R1Yj4mJiB3YXNtVG9K U1N0dWJzLCBXYXNtOjpJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmJiBmdW5jdGlvbkluZGV4 U3BhY2UsIFN5bWJvbFRhYmxlKiBleHBvcnRTeW1ib2xUYWJsZSwgdW5zaWduZWQgY2FsbGVlQ291 bnQpCitKU1dlYkFzc2VtYmx5TW9kdWxlKiBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGUoVk0m IHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUlu Zm9ybWF0aW9uPiYmIG1vZHVsZUluZm9ybWF0aW9uLCBCYWc8Q2FsbExpbmtJbmZvPiYmIGNhbGxM aW5rSW5mb3MsIFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPiYmIHdhc21FeGl0U3R1YnMsIFN5 bWJvbFRhYmxlKiBleHBvcnRTeW1ib2xUYWJsZSwgdW5zaWduZWQgY2FsbGVlQ291bnQpCiB7Ci0g ICAgYXV0byogaW5zdGFuY2UgPSBuZXcgKE5vdE51bGwsIGFsbG9jYXRlQ2VsbDxKU1dlYkFzc2Vt Ymx5TW9kdWxlPih2bS5oZWFwLCBhbGxvY2F0aW9uU2l6ZShjYWxsZWVDb3VudCkpKSBKU1dlYkFz c2VtYmx5TW9kdWxlKHZtLCBzdHJ1Y3R1cmUsIHN0ZDo6Zm9yd2FyZDxzdGQ6OnVuaXF1ZV9wdHI8 V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+Pihtb2R1bGVJbmZvcm1hdGlvbiksIHN0ZDo6Zm9yd2Fy ZDxCYWc8Q2FsbExpbmtJbmZvPj4oY2FsbExpbmtJbmZvcyksIHN0ZDo6Zm9yd2FyZDxWZWN0b3I8 V2FzbTo6V2FzbVRvSlNTdHViPj4od2FzbVRvSlNTdHVicyksIHN0ZDo6Zm9yd2FyZDxXYXNtOjpJ bW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2U+KGZ1bmN0aW9uSW5kZXhTcGFjZSksIGNhbGxlZUNv dW50KTsKKyAgICBhdXRvKiBpbnN0YW5jZSA9IG5ldyAoTm90TnVsbCwgYWxsb2NhdGVDZWxsPEpT V2ViQXNzZW1ibHlNb2R1bGU+KHZtLmhlYXAsIGFsbG9jYXRpb25TaXplKGNhbGxlZUNvdW50KSkp IEpTV2ViQXNzZW1ibHlNb2R1bGUodm0sIHN0cnVjdHVyZSwgc3RkOjpmb3J3YXJkPHN0ZDo6dW5p cXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4+KG1vZHVsZUluZm9ybWF0aW9uKSwgc3Rk Ojpmb3J3YXJkPEJhZzxDYWxsTGlua0luZm8+PihjYWxsTGlua0luZm9zKSwgc3RkOjpmb3J3YXJk PFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPj4od2FzbUV4aXRTdHVicyksIGNhbGxlZUNvdW50 KTsKICAgICBpbnN0YW5jZS0+ZmluaXNoQ3JlYXRpb24odm0sIGV4cG9ydFN5bWJvbFRhYmxlKTsK ICAgICByZXR1cm4gaW5zdGFuY2U7CiB9CkBAIC01MCwxMiArNTAsMTEgQEAgU3RydWN0dXJlKiBK U1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGVTdHJ1Y3R1cmUoVk0mIHZtLCBKU0dsb2JhbE9iamVj dCogZ2xvYmFsT2IKICAgICByZXR1cm4gU3RydWN0dXJlOjpjcmVhdGUodm0sIGdsb2JhbE9iamVj dCwgcHJvdG90eXBlLCBUeXBlSW5mbyhPYmplY3RUeXBlLCBTdHJ1Y3R1cmVGbGFncyksIGluZm8o KSk7CiB9CiAKLUpTV2ViQXNzZW1ibHlNb2R1bGU6OkpTV2ViQXNzZW1ibHlNb2R1bGUoVk0mIHZt LCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9y bWF0aW9uPiYmIG1vZHVsZUluZm9ybWF0aW9uLCBCYWc8Q2FsbExpbmtJbmZvPiYmIGNhbGxMaW5r SW5mb3MsIFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0dWI+JiYgd2FzbVRvSlNTdHVicywgV2FzbTo6 SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiYgZnVuY3Rpb25JbmRleFNwYWNlLCB1bnNpZ25l ZCBjYWxsZWVDb3VudCkKK0pTV2ViQXNzZW1ibHlNb2R1bGU6OkpTV2ViQXNzZW1ibHlNb2R1bGUo Vk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVs ZUluZm9ybWF0aW9uPiYmIG1vZHVsZUluZm9ybWF0aW9uLCBCYWc8Q2FsbExpbmtJbmZvPiYmIGNh bGxMaW5rSW5mb3MsIFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPiYmIHdhc21FeGl0U3R1YnMs IHVuc2lnbmVkIGNhbGxlZUNvdW50KQogICAgIDogQmFzZSh2bSwgc3RydWN0dXJlKQogICAgICwg bV9tb2R1bGVJbmZvcm1hdGlvbihXVEZNb3ZlKG1vZHVsZUluZm9ybWF0aW9uKSkKICAgICAsIG1f Y2FsbExpbmtJbmZvcyhXVEZNb3ZlKGNhbGxMaW5rSW5mb3MpKQotICAgICwgbV93YXNtVG9KU1N0 dWJzKFdURk1vdmUod2FzbVRvSlNTdHVicykpCi0gICAgLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZShX VEZNb3ZlKGZ1bmN0aW9uSW5kZXhTcGFjZSkpCisgICAgLCBtX3dhc21FeGl0U3R1YnMoV1RGTW92 ZSh3YXNtRXhpdFN0dWJzKSkKICAgICAsIG1fY2FsbGVlQ291bnQoY2FsbGVlQ291bnQpCiB7CiAg ICAgbWVtc2V0KGNhbGxlZXMoKSwgMCwgbV9jYWxsZWVDb3VudCAqIHNpemVvZihXcml0ZUJhcnJp ZXI8SlNXZWJBc3NlbWJseUNhbGxlZT4pICogMik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmggYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmgKaW5kZXggZmVjNGVlZC4uZmE2NzNh ZiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJs eU1vZHVsZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1i bHlNb2R1bGUuaApAQCAtNDMsMTkgKzQzLDE4IEBAIGNsYXNzIEpTV2ViQXNzZW1ibHlNb2R1bGUg OiBwdWJsaWMgSlNEZXN0cnVjdGlibGVPYmplY3QgewogcHVibGljOgogICAgIHR5cGVkZWYgSlNE ZXN0cnVjdGlibGVPYmplY3QgQmFzZTsKIAotICAgIHN0YXRpYyBKU1dlYkFzc2VtYmx5TW9kdWxl KiBjcmVhdGUoVk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5m b3JtYXRpb24+JiYsIEJhZzxDYWxsTGlua0luZm8+JiYsIFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0 dWI+JiYsIFdhc206OkltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmLCBTeW1ib2xUYWJsZSos IHVuc2lnbmVkKTsKKyAgICBKU19FWFBPUlRfUFJJVkFURSBzdGF0aWMgSlNXZWJBc3NlbWJseU1v ZHVsZSogY3JlYXRlKFZNJiwgU3RydWN0dXJlKiwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVs ZUluZm9ybWF0aW9uPiYmLCBCYWc8Q2FsbExpbmtJbmZvPiYmLCBWZWN0b3I8V2FzbTo6V2FzbUV4 aXRTdHVicz4mJiwgU3ltYm9sVGFibGUqLCB1bnNpZ25lZCk7CiAgICAgc3RhdGljIFN0cnVjdHVy ZSogY3JlYXRlU3RydWN0dXJlKFZNJiwgSlNHbG9iYWxPYmplY3QqLCBKU1ZhbHVlKTsKIAogICAg IERFQ0xBUkVfSU5GTzsKIAogICAgIGNvbnN0IFdhc206Ok1vZHVsZUluZm9ybWF0aW9uJiBtb2R1 bGVJbmZvcm1hdGlvbigpIGNvbnN0IHsgcmV0dXJuICptX21vZHVsZUluZm9ybWF0aW9uLmdldCgp OyB9CiAgICAgU3ltYm9sVGFibGUqIGV4cG9ydFN5bWJvbFRhYmxlKCkgY29uc3QgeyByZXR1cm4g bV9leHBvcnRTeW1ib2xUYWJsZS5nZXQoKTsgfQotICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNp Z25hdHVyZUZvckZ1bmN0aW9uSW5kZXhTcGFjZSh1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2Up IGNvbnN0CisgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rp b25JbmRleFNwYWNlKHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFjZSkgY29uc3QKICAgICB7Ci0g ICAgICAgIEFTU0VSVChmdW5jdGlvbkluZGV4U3BhY2UgPCBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5z aXplKTsKLSAgICAgICAgcmV0dXJuIG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtm dW5jdGlvbkluZGV4U3BhY2VdLnNpZ25hdHVyZUluZGV4OworICAgICAgICByZXR1cm4gbV9tb2R1 bGVJbmZvcm1hdGlvbi0+c2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0 aW9uSW5kZXhTcGFjZSk7CiAgICAgfQotICAgIHVuc2lnbmVkIGZ1bmN0aW9uSW1wb3J0Q291bnQo KSBjb25zdCB7IHJldHVybiBtX3dhc21Ub0pTU3R1YnMuc2l6ZSgpOyB9CisgICAgdW5zaWduZWQg ZnVuY3Rpb25JbXBvcnRDb3VudCgpIGNvbnN0IHsgcmV0dXJuIG1fd2FzbUV4aXRTdHVicy5zaXpl KCk7IH0KIAogICAgIEpTV2ViQXNzZW1ibHlDYWxsZWUqIGpzRW50cnlwb2ludENhbGxlZUZyb21G dW5jdGlvbkluZGV4U3BhY2UodW5zaWduZWQgZnVuY3Rpb25JbmRleFNwYWNlKQogICAgIHsKQEAg LTkwLDEwICs4OSw4IEBAIHB1YmxpYzoKICAgICAgICAgcmV0dXJuIGJpdHdpc2VfY2FzdDxXcml0 ZUJhcnJpZXI8SlNXZWJBc3NlbWJseUNhbGxlZT4qPihiaXR3aXNlX2Nhc3Q8Y2hhcio+KHRoaXMp ICsgb2Zmc2V0T2ZDYWxsZWVzKCkpOwogICAgIH0KIAotICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zm c2V0T2ZGdW5jdGlvbkluZGV4U3BhY2UoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJB c3NlbWJseU1vZHVsZSwgbV9mdW5jdGlvbkluZGV4U3BhY2UpOyB9Ci0KIHByb3RlY3RlZDoKLSAg ICBKU1dlYkFzc2VtYmx5TW9kdWxlKFZNJiwgU3RydWN0dXJlKiwgc3RkOjp1bmlxdWVfcHRyPFdh c206Ok1vZHVsZUluZm9ybWF0aW9uPiYmLCBCYWc8Q2FsbExpbmtJbmZvPiYmLCBWZWN0b3I8V2Fz bTo6V2FzbVRvSlNTdHViPiYmLCBXYXNtOjpJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmJiwg dW5zaWduZWQgY2FsbGVlQ291bnQpOworICAgIEpTV2ViQXNzZW1ibHlNb2R1bGUoVk0mLCBTdHJ1 Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYsIEJhZzxD YWxsTGlua0luZm8+JiYsIFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPiYmLCB1bnNpZ25lZCBj YWxsZWVDb3VudCk7CiAgICAgdm9pZCBmaW5pc2hDcmVhdGlvbihWTSYsIFN5bWJvbFRhYmxlKik7 CiAgICAgc3RhdGljIHZvaWQgZGVzdHJveShKU0NlbGwqKTsKICAgICBzdGF0aWMgdm9pZCB2aXNp dENoaWxkcmVuKEpTQ2VsbCosIFNsb3RWaXNpdG9yJik7CkBAIC0xMTcsOCArMTE0LDcgQEAgcHJp dmF0ZToKICAgICBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+IG1fbW9k dWxlSW5mb3JtYXRpb247CiAgICAgQmFnPENhbGxMaW5rSW5mbz4gbV9jYWxsTGlua0luZm9zOwog ICAgIFdyaXRlQmFycmllcjxTeW1ib2xUYWJsZT4gbV9leHBvcnRTeW1ib2xUYWJsZTsKLSAgICBW ZWN0b3I8V2FzbTo6V2FzbVRvSlNTdHViPiBtX3dhc21Ub0pTU3R1YnM7Ci0gICAgY29uc3QgV2Fz bTo6SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlIG1fZnVuY3Rpb25JbmRleFNwYWNlOworICAg IFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPiBtX3dhc21FeGl0U3R1YnM7CiAgICAgdW5zaWdu ZWQgbV9jYWxsZWVDb3VudDsKIH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlvbi5jcHAKaW5kZXggYmUyN2Y1Ny4uYmNhNDc5MiAx MDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlGdW5j dGlvbi5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlG dW5jdGlvbi5jcHAKQEAgLTExOSw2ICsxMTksNyBAQCBzdGF0aWMgRW5jb2RlZEpTVmFsdWUgSlND X0hPU1RfQ0FMTCBjYWxsV2ViQXNzZW1ibHlGdW5jdGlvbihFeGVjU3RhdGUqIGV4ZWMpCiAgICAg UHJvdG9DYWxsRnJhbWUgcHJvdG9DYWxsRnJhbWU7CiAgICAgcHJvdG9DYWxsRnJhbWUuaW5pdChu dWxscHRyLCB3YXNtRnVuY3Rpb24sIGZpcnN0QXJndW1lbnQsIGFyZ0NvdW50LCByZW1haW5pbmdB cmdzKTsKIAorICAgIC8vIEZJWE1FIERvIGF3YXkgd2l0aCB0aGlzIGVudGlyZSBmdW5jdGlvbiwg YW5kIG9ubHkgdXNlIHRoZSBlbnRyeXBvaW50IGdlbmVyYXRlZCBieSBCMy4gaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NjQ4NgogICAgIEpTV2ViQXNzZW1ibHlJbnN0 YW5jZSogcHJldkpTV2ViQXNzZW1ibHlJbnN0YW5jZSA9IHZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0 YW5jZTsKICAgICB2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UgPSB3YXNtRnVuY3Rpb24tPmlu c3RhbmNlKCk7CiAgICAgQVNTRVJUKHdhc21GdW5jdGlvbi0+aW5zdGFuY2UoKSk7CkBAIC0xNDks NyArMTUwLDcgQEAgV2ViQXNzZW1ibHlGdW5jdGlvbiogV2ViQXNzZW1ibHlGdW5jdGlvbjo6Y3Jl YXRlKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE8KIHsKICAgICBOYXRpdmVFeGVjdXRh YmxlKiBleGVjdXRhYmxlID0gdm0uZ2V0SG9zdEZ1bmN0aW9uKGNhbGxXZWJBc3NlbWJseUZ1bmN0 aW9uLCBOb0ludHJpbnNpYywgY2FsbEhvc3RGdW5jdGlvbkFzQ29uc3RydWN0b3IsIG51bGxwdHIs IG5hbWUpOwogICAgIFN0cnVjdHVyZSogc3RydWN0dXJlID0gZ2xvYmFsT2JqZWN0LT53ZWJBc3Nl bWJseUZ1bmN0aW9uU3RydWN0dXJlKCk7Ci0gICAgV2ViQXNzZW1ibHlGdW5jdGlvbiogZnVuY3Rp b24gPSBuZXcgKE5vdE51bGwsIGFsbG9jYXRlQ2VsbDxXZWJBc3NlbWJseUZ1bmN0aW9uPih2bS5o ZWFwKSkgV2ViQXNzZW1ibHlGdW5jdGlvbih2bSwgZ2xvYmFsT2JqZWN0LCBzdHJ1Y3R1cmUsIHNp Z25hdHVyZUluZGV4KTsKKyAgICBXZWJBc3NlbWJseUZ1bmN0aW9uKiBmdW5jdGlvbiA9IG5ldyAo Tm90TnVsbCwgYWxsb2NhdGVDZWxsPFdlYkFzc2VtYmx5RnVuY3Rpb24+KHZtLmhlYXApKSBXZWJB c3NlbWJseUZ1bmN0aW9uKHZtLCBnbG9iYWxPYmplY3QsIHN0cnVjdHVyZSwgc2lnbmF0dXJlSW5k ZXgsIHdhc21FbnRyeXBvaW50LT5lbnRyeXBvaW50KCkpOwogICAgIGZ1bmN0aW9uLT5maW5pc2hD cmVhdGlvbih2bSwgZXhlY3V0YWJsZSwgbGVuZ3RoLCBuYW1lLCBpbnN0YW5jZSwganNFbnRyeXBv aW50LCB3YXNtRW50cnlwb2ludCk7CiAgICAgcmV0dXJuIGZ1bmN0aW9uOwogfQpAQCAtMTU3LDEx ICsxNTgsMTIgQEAgV2ViQXNzZW1ibHlGdW5jdGlvbiogV2ViQXNzZW1ibHlGdW5jdGlvbjo6Y3Jl YXRlKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE8KIFN0cnVjdHVyZSogV2ViQXNzZW1i bHlGdW5jdGlvbjo6Y3JlYXRlU3RydWN0dXJlKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2Jh bE9iamVjdCwgSlNWYWx1ZSBwcm90b3R5cGUpCiB7CiAgICAgQVNTRVJUKGdsb2JhbE9iamVjdCk7 Ci0gICAgcmV0dXJuIFN0cnVjdHVyZTo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3QsIHByb3RvdHlw ZSwgVHlwZUluZm8oSlNGdW5jdGlvblR5cGUsIFN0cnVjdHVyZUZsYWdzKSwgaW5mbygpKTsKKyAg ICByZXR1cm4gU3RydWN0dXJlOjpjcmVhdGUodm0sIGdsb2JhbE9iamVjdCwgcHJvdG90eXBlLCBU eXBlSW5mbyhXZWJBc3NlbWJseUZ1bmN0aW9uVHlwZSwgU3RydWN0dXJlRmxhZ3MpLCBpbmZvKCkp OwogfQogCi1XZWJBc3NlbWJseUZ1bmN0aW9uOjpXZWJBc3NlbWJseUZ1bmN0aW9uKFZNJiB2bSwg SlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIFdhc206 OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4KQorV2ViQXNzZW1ibHlGdW5jdGlvbjo6V2Vi QXNzZW1ibHlGdW5jdGlvbihWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QsIFN0 cnVjdHVyZSogc3RydWN0dXJlLCBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCwg dm9pZCogd2FzbUVudHJ5cG9pbnQpCiAgICAgOiBCYXNlKHZtLCBnbG9iYWxPYmplY3QsIHN0cnVj dHVyZSkKKyAgICAsIG1fd2FzbUVudHJ5UG9pbnRDb2RlKHdhc21FbnRyeXBvaW50KQogICAgICwg bV9zaWduYXR1cmVJbmRleChzaWduYXR1cmVJbmRleCkKIHsgfQogCkBAIC0xODMsNiArMTg1LDcg QEAgdm9pZCBXZWJBc3NlbWJseUZ1bmN0aW9uOjpmaW5pc2hDcmVhdGlvbihWTSYgdm0sIE5hdGl2 ZUV4ZWN1dGFibGUqIGV4ZWN1dGFibGUsIHUKICAgICBBU1NFUlQoanNFbnRyeXBvaW50ICE9IHdh c21FbnRyeXBvaW50KTsKICAgICBtX2pzRW50cnlwb2ludC5zZXQodm0sIHRoaXMsIGpzRW50cnlw b2ludCk7CiAgICAgbV93YXNtRW50cnlwb2ludC5zZXQodm0sIHRoaXMsIHdhc21FbnRyeXBvaW50 KTsKKyAgICBBU1NFUlQobV93YXNtRW50cnlwb2ludC0+ZW50cnlwb2ludCgpID09IG1fd2FzbUVu dHJ5UG9pbnRDb2RlKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UgSlNDCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmggYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmgKaW5kZXggMzQ5MDUw Mi4uMzg3N2EwMiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2Vi QXNzZW1ibHlGdW5jdGlvbi5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dl YkFzc2VtYmx5RnVuY3Rpb24uaApAQCAtNTQsMTggKzU0LDIyIEBAIHB1YmxpYzoKIAogICAgIEpT V2ViQXNzZW1ibHlJbnN0YW5jZSogaW5zdGFuY2UoKSBjb25zdCB7IHJldHVybiBtX2luc3RhbmNl LmdldCgpOyB9CiAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXgoKSBjb25z dCB7IHJldHVybiBtX3NpZ25hdHVyZUluZGV4OyB9Ci0gICAgdm9pZCogd2FzbUVudHJ5cG9pbnQo KSB7IHJldHVybiBtX3dhc21FbnRyeXBvaW50LT5lbnRyeXBvaW50KCk7IH0KKyAgICB2b2lkKiB3 YXNtRW50cnlwb2ludCgpIHsgcmV0dXJuIG1fd2FzbUVudHJ5UG9pbnRDb2RlOyB9CiAgICAgdm9p ZCoganNFbnRyeXBvaW50KCkgeyByZXR1cm4gbV9qc0VudHJ5cG9pbnQtPmVudHJ5cG9pbnQoKTsg fQogCisgICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZkluc3RhbmNlKCkgeyByZXR1cm4gT0JK RUNUX09GRlNFVE9GKFdlYkFzc2VtYmx5RnVuY3Rpb24sIG1faW5zdGFuY2UpOyB9CisgICAgc3Rh dGljIHB0cmRpZmZfdCBvZmZzZXRPZldhc21FbnRyeVBvaW50Q29kZSgpIHsgcmV0dXJuIE9CSkVD VF9PRkZTRVRPRihXZWJBc3NlbWJseUZ1bmN0aW9uLCBtX3dhc21FbnRyeVBvaW50Q29kZSk7IH0K KwogcHJvdGVjdGVkOgogICAgIHN0YXRpYyB2b2lkIHZpc2l0Q2hpbGRyZW4oSlNDZWxsKiwgU2xv dFZpc2l0b3ImKTsKIAogICAgIHZvaWQgZmluaXNoQ3JlYXRpb24oVk0mLCBOYXRpdmVFeGVjdXRh YmxlKiwgdW5zaWduZWQgbGVuZ3RoLCBjb25zdCBTdHJpbmcmIG5hbWUsIEpTV2ViQXNzZW1ibHlJ bnN0YW5jZSosIEpTV2ViQXNzZW1ibHlDYWxsZWUqIGpzRW50cnlwb2ludCwgSlNXZWJBc3NlbWJs eUNhbGxlZSogd2FzbUVudHJ5cG9pbnQpOwogCiBwcml2YXRlOgotICAgIFdlYkFzc2VtYmx5RnVu Y3Rpb24oVk0mLCBKU0dsb2JhbE9iamVjdCosIFN0cnVjdHVyZSosIFdhc206OlNpZ25hdHVyZUlu ZGV4KTsKKyAgICBXZWJBc3NlbWJseUZ1bmN0aW9uKFZNJiwgSlNHbG9iYWxPYmplY3QqLCBTdHJ1 Y3R1cmUqLCBXYXNtOjpTaWduYXR1cmVJbmRleCwgdm9pZCopOwogCiAgICAgV3JpdGVCYXJyaWVy PEpTV2ViQXNzZW1ibHlJbnN0YW5jZT4gbV9pbnN0YW5jZTsKKyAgICB2b2lkKiBtX3dhc21FbnRy eVBvaW50Q29kZTsgLy8gUmVtb3ZlIGluZGlyZWN0aW9ucyBmb3Igd2FzbSAtPiB3YXNtIGNhbGxz LgogICAgIFdyaXRlQmFycmllcjxKU1dlYkFzc2VtYmx5Q2FsbGVlPiBtX2pzRW50cnlwb2ludDsK ICAgICBXcml0ZUJhcnJpZXI8SlNXZWJBc3NlbWJseUNhbGxlZT4gbV93YXNtRW50cnlwb2ludDsK ICAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBtX3NpZ25hdHVyZUluZGV4OwpkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVj dG9yLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFu Y2VDb25zdHJ1Y3Rvci5jcHAKaW5kZXggZDYwZjQwZS4uMWI0NjExMiAxMDA2NDQKLS0tIGEvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVjdG9y LmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUluc3Rh bmNlQ29uc3RydWN0b3IuY3BwCkBAIC04NCw2ICs4NCwxMSBAQCBzdGF0aWMgRW5jb2RlZEpTVmFs dWUgSlNDX0hPU1RfQ0FMTCBjb25zdHJ1Y3RKU1dlYkFzc2VtYmx5SW5zdGFuY2UoRXhlY1N0YXRl KiBleAogCiAgICAgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBpbnN0YW5jZSA9IEpTV2ViQXNzZW1i bHlJbnN0YW5jZTo6Y3JlYXRlKHZtLCBpbnN0YW5jZVN0cnVjdHVyZSwganNNb2R1bGUsIG1vZHVs ZVJlY29yZC0+Z2V0TW9kdWxlTmFtZXNwYWNlKGV4ZWMpKTsKICAgICBSRVRVUk5fSUZfRVhDRVBU SU9OKHRocm93U2NvcGUsIGVuY29kZWRKU1ZhbHVlKCkpOworICAgIHsKKyAgICAgICAgLy8gQWx3 YXlzIHN0YXJ0IHdpdGggYSBkdW1teSBNZW1vcnksIHNvIHRoYXQgd2FzbSAtPiB3YXNtIHRodW5r cyBhdm9pZCBjaGVja2luZyBmb3IgYSBudWxscHRyIE1lbW9yeSB3aGVuIHRyeWluZyB0byBzZXQg cGlubmVkIHJlZ2lzdGVycy4KKyAgICAgICAgV2FzbTo6TWVtb3J5IG1lbW9yeTsKKyAgICAgICAg aW5zdGFuY2UtPnNldE1lbW9yeSh2bSwgSlNXZWJBc3NlbWJseU1lbW9yeTo6Y3JlYXRlKHZtLCBl eGVjLT5sZXhpY2FsR2xvYmFsT2JqZWN0KCktPldlYkFzc2VtYmx5TWVtb3J5U3RydWN0dXJlKCks IFdURk1vdmUobWVtb3J5KSkpOworICAgIH0KIAogICAgIC8vIExldCBmdW5jcywgbWVtb3JpZXMg YW5kIHRhYmxlcyBiZSBpbml0aWFsbHktZW1wdHkgbGlzdHMgb2YgY2FsbGFibGUgSmF2YVNjcmlw dCBvYmplY3RzLCBXZWJBc3NlbWJseS5NZW1vcnkgb2JqZWN0cyBhbmQgV2ViQXNzZW1ibHkuVGFi bGUgb2JqZWN0cywgcmVzcGVjdGl2ZWx5LgogICAgIC8vIExldCBpbXBvcnRzIGJlIGFuIGluaXRp YWxseS1lbXB0eSBsaXN0IG9mIGV4dGVybmFsIHZhbHVlcy4KQEAgLTExNCwxOCArMTE5LDE5IEBA IHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGNvbnN0cnVjdEpTV2ViQXNzZW1i bHlJbnN0YW5jZShFeGVjU3RhdGUqIGV4CiAgICAgICAgICAgICAgICAgcmV0dXJuIEpTVmFsdWU6 OmVuY29kZSh0aHJvd0V4Y2VwdGlvbihleGVjLCB0aHJvd1Njb3BlLCBjcmVhdGVKU1dlYkFzc2Vt Ymx5TGlua0Vycm9yKGV4ZWMsIHZtLCBBU0NJSUxpdGVyYWwoImltcG9ydCBmdW5jdGlvbiBtdXN0 IGJlIGNhbGxhYmxlIikpKSk7CiAgICAgICAgICAgICBKU0NlbGwqIGNlbGwgPSB2YWx1ZS5hc0Nl bGwoKTsKICAgICAgICAgICAgIC8vIGlpLiBJZiB2IGlzIGFuIEV4cG9ydGVkIEZ1bmN0aW9uIEV4 b3RpYyBPYmplY3Q6Ci0gICAgICAgICAgICBpZiAoV2ViQXNzZW1ibHlGdW5jdGlvbiogaW1wb3J0 ZWRFeHBvcnRzID0ganNEeW5hbWljQ2FzdDxXZWJBc3NlbWJseUZ1bmN0aW9uKj4ob2JqZWN0KSkg ewotICAgICAgICAgICAgICAgIC8vIEZJWE1FIGhhbmRsZSBGdW5jdGlvbiBFeG90aWMgT2JqZWN0 IHByb3Blcmx5LiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1Mjgy Ci0gICAgICAgICAgICAgICAgLy8gYS4gSWYgdGhlIHNpZ25hdHVyZSBvZiB2IGRvZXMgbm90IG1h dGNoIHRoZSBzaWduYXR1cmUgb2YgaSwgdGhyb3cgYSBUeXBlRXJyb3IuCisgICAgICAgICAgICBp ZiAoV2ViQXNzZW1ibHlGdW5jdGlvbiogaW1wb3J0ZWRFeHBvcnQgPSBqc0R5bmFtaWNDYXN0PFdl YkFzc2VtYmx5RnVuY3Rpb24qPihjZWxsKSkgeworICAgICAgICAgICAgICAgIC8vIGEuIElmIHRo ZSBzaWduYXR1cmUgb2YgdiBkb2VzIG5vdCBtYXRjaCB0aGUgc2lnbmF0dXJlIG9mIGksIHRocm93 IGEgV2ViQXNzZW1ibHkuTGlua0Vycm9yLgorICAgICAgICAgICAgICAgIFdhc206OlNpZ25hdHVy ZUluZGV4IGltcG9ydGVkU2lnbmF0dXJlSW5kZXggPSBpbXBvcnRlZEV4cG9ydC0+c2lnbmF0dXJl SW5kZXgoKTsKKyAgICAgICAgICAgICAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBleHBlY3RlZFNp Z25hdHVyZUluZGV4ID0gbW9kdWxlSW5mb3JtYXRpb24uaW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJ bmRpY2VzW2ltcG9ydC5raW5kSW5kZXhdOworICAgICAgICAgICAgICAgIGlmIChpbXBvcnRlZFNp Z25hdHVyZUluZGV4ICE9IGV4cGVjdGVkU2lnbmF0dXJlSW5kZXgpCisgICAgICAgICAgICAgICAg ICAgIHJldHVybiBKU1ZhbHVlOjplbmNvZGUodGhyb3dFeGNlcHRpb24oZXhlYywgdGhyb3dTY29w ZSwgY3JlYXRlSlNXZWJBc3NlbWJseUxpbmtFcnJvcihleGVjLCB2bSwgQVNDSUlMaXRlcmFsKCJp bXBvcnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBkb2Vzbid0IG1hdGNoIHRoZSBwcm92aWRlZCBX ZWJBc3NlbWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSIpKSkpOwogICAgICAgICAgICAgICAgIC8v IGIuIExldCBjbG9zdXJlIGJlIHYuW1tDbG9zdXJlXV0uCi0gICAgICAgICAgICAgICAgUkVMRUFT RV9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKLSAgICAgICAgICAgICAgICBVTlVTRURfUEFSQU0oaW1w b3J0ZWRFeHBvcnRzKTsKLSAgICAgICAgICAgICAgICBicmVhazsKICAgICAgICAgICAgIH0KICAg ICAgICAgICAgIC8vIGlpaS4gT3RoZXJ3aXNlOgogICAgICAgICAgICAgLy8gYS4gTGV0IGNsb3N1 cmUgYmUgYSBuZXcgaG9zdCBmdW5jdGlvbiBvZiB0aGUgZ2l2ZW4gc2lnbmF0dXJlIHdoaWNoIGNh bGxzIHYgYnkgY29lcmNpbmcgV2ViQXNzZW1ibHkgYXJndW1lbnRzIHRvIEphdmFTY3JpcHQgYXJn dW1lbnRzIHZpYSBUb0pTVmFsdWUgYW5kIHJldHVybnMgdGhlIHJlc3VsdCwgaWYgYW55LCBieSBj b2VyY2luZyB2aWEgVG9XZWJBc3NlbWJseVZhbHVlLgogICAgICAgICAgICAgLy8gTm90ZTogZG9u ZSBhcyBwYXJ0IG9mIFBsYW4gY29tcGlsYXRpb24uCiAgICAgICAgICAgICAvLyBpdi4gQXBwZW5k IHYgdG8gZnVuY3MuCisgICAgICAgICAgICAvLyBOb3RlOiBhZGRpbmcgdGhlIEpTQ2VsbCB0byB0 aGUgaW5zdGFuY2UgbGlzdCBmdWxmaWxscyBjbG9zdXJlIHJlcXVpcmVtZW50cyBiLiBhYm92ZSAo dGhlIFdlYkFzc2VtYmx5Lkluc3RhbmNlIHdpbCBiZSBrZXB0IGFsaXZlKSBhbmQgdi4gYmVsb3cg KHRoZSBKU0Z1bmN0aW9uKS4KICAgICAgICAgICAgIGluc3RhbmNlLT5zZXRJbXBvcnRGdW5jdGlv bih2bSwgY2VsbCwgbnVtSW1wb3J0RnVuY3Rpb25zKyspOwogICAgICAgICAgICAgLy8gdi4gQXBw ZW5kIGNsb3N1cmUgdG8gaW1wb3J0cy4KICAgICAgICAgICAgIGJyZWFrOwpAQCAtMjMwLDcgKzIz Niw3IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGNvbnN0cnVjdEpTV2Vi QXNzZW1ibHlJbnN0YW5jZShFeGVjU3RhdGUqIGV4CiAgICAgICAgICAgICBSRUxFQVNFX0FTU0VS VCghbW9kdWxlSW5mb3JtYXRpb24ubWVtb3J5LmlzSW1wb3J0KCkpOwogICAgICAgICAgICAgLy8g V2UgY3JlYXRlIGEgbWVtb3J5IHdoZW4gaXQncyBhIG1lbW9yeSBkZWZpbml0aW9uLgogICAgICAg ICAgICAgYm9vbCBmYWlsZWQ7Ci0gICAgICAgICAgICBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVt b3J5PiBtZW1vcnkgPSBzdGQ6Om1ha2VfdW5pcXVlPFdhc206Ok1lbW9yeT4obW9kdWxlSW5mb3Jt YXRpb24ubWVtb3J5LmluaXRpYWwoKSwgbW9kdWxlSW5mb3JtYXRpb24ubWVtb3J5Lm1heGltdW0o KSwgZmFpbGVkKTsKKyAgICAgICAgICAgIFdhc206Ok1lbW9yeSBtZW1vcnkobW9kdWxlSW5mb3Jt YXRpb24ubWVtb3J5LmluaXRpYWwoKSwgbW9kdWxlSW5mb3JtYXRpb24ubWVtb3J5Lm1heGltdW0o KSwgZmFpbGVkKTsKICAgICAgICAgICAgIGlmIChmYWlsZWQpCiAgICAgICAgICAgICAgICAgcmV0 dXJuIEpTVmFsdWU6OmVuY29kZSh0aHJvd0V4Y2VwdGlvbihleGVjLCB0aHJvd1Njb3BlLCBjcmVh dGVPdXRPZk1lbW9yeUVycm9yKGV4ZWMpKSk7CiAgICAgICAgICAgICBpbnN0YW5jZS0+c2V0TWVt b3J5KHZtLApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNz ZW1ibHlNZW1vcnlDb25zdHJ1Y3Rvci5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9q cy9XZWJBc3NlbWJseU1lbW9yeUNvbnN0cnVjdG9yLmNwcAppbmRleCA1ZDVhNmNkLi42Yzg4N2Fm IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1l bW9yeUNvbnN0cnVjdG9yLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9X ZWJBc3NlbWJseU1lbW9yeUNvbnN0cnVjdG9yLmNwcApAQCAtOTcsNyArOTcsNyBAQCBzdGF0aWMg RW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBjb25zdHJ1Y3RKU1dlYkFzc2VtYmx5TWVtb3J5 KEV4ZWNTdGF0ZSogZXhlYwogICAgIH0KIAogICAgIGJvb2wgZmFpbGVkOwotICAgIHN0ZDo6dW5p cXVlX3B0cjxXYXNtOjpNZW1vcnk+IG1lbW9yeSA9IHN0ZDo6bWFrZV91bmlxdWU8V2FzbTo6TWVt b3J5Pihpbml0aWFsUGFnZUNvdW50LCBtYXhpbXVtUGFnZUNvdW50LCBmYWlsZWQpOworICAgIFdh c206Ok1lbW9yeSBtZW1vcnkoaW5pdGlhbFBhZ2VDb3VudCwgbWF4aW11bVBhZ2VDb3VudCwgZmFp bGVkKTsKICAgICBpZiAoZmFpbGVkKQogICAgICAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKHRo cm93RXhjZXB0aW9uKGV4ZWMsIHRocm93U2NvcGUsIGNyZWF0ZU91dE9mTWVtb3J5RXJyb3IoZXhl YykpKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNz ZW1ibHlNb2R1bGVDb25zdHJ1Y3Rvci5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9q cy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNwcAppbmRleCAzOGVkYjhjLi44MTI5NTky IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1v ZHVsZUNvbnN0cnVjdG9yLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9X ZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNwcApAQCAtOTcsNyArOTcsNyBAQCBKU1ZhbHVl IFdlYkFzc2VtYmx5TW9kdWxlQ29uc3RydWN0b3I6OmNyZWF0ZU1vZHVsZShFeGVjU3RhdGUqIHN0 YXRlLCBTdHJ1Y3R1cmUqCiAKICAgICAvLyBPbmx5IHdhc20taW50ZXJuYWwgZnVuY3Rpb25zIGhh dmUgYSBjYWxsZWUsIHN0dWJzIHRvIEpTIGRvIG5vdC4KICAgICB1bnNpZ25lZCBjYWxsZWVDb3Vu dCA9IHBsYW4uaW50ZXJuYWxGdW5jdGlvbkNvdW50KCk7Ci0gICAgSlNXZWJBc3NlbWJseU1vZHVs ZSogcmVzdWx0ID0gSlNXZWJBc3NlbWJseU1vZHVsZTo6Y3JlYXRlKHZtLCBzdHJ1Y3R1cmUsIHBs YW4udGFrZU1vZHVsZUluZm9ybWF0aW9uKCksIHBsYW4udGFrZUNhbGxMaW5rSW5mb3MoKSwgcGxh bi50YWtlV2FzbVRvSlNTdHVicygpLCBwbGFuLnRha2VGdW5jdGlvbkluZGV4U3BhY2UoKSwgZXhw b3J0U3ltYm9sVGFibGUsIGNhbGxlZUNvdW50KTsKKyAgICBKU1dlYkFzc2VtYmx5TW9kdWxlKiBy ZXN1bHQgPSBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGUodm0sIHN0cnVjdHVyZSwgcGxhbi50 YWtlTW9kdWxlSW5mb3JtYXRpb24oKSwgcGxhbi50YWtlQ2FsbExpbmtJbmZvcygpLCBwbGFuLnRh a2VXYXNtRXhpdFN0dWJzKCksIGV4cG9ydFN5bWJvbFRhYmxlLCBjYWxsZWVDb3VudCk7CiAgICAg cGxhbi5pbml0aWFsaXplQ2FsbGVlcyhzdGF0ZS0+anNDYWxsZWUoKS0+Z2xvYmFsT2JqZWN0KCks IAogICAgICAgICBbJl0gKHVuc2lnbmVkIGNhbGxlZUluZGV4LCBKU1dlYkFzc2VtYmx5Q2FsbGVl KiBqc0VudHJ5cG9pbnRDYWxsZWUsIEpTV2ViQXNzZW1ibHlDYWxsZWUqIHdhc21FbnRyeXBvaW50 Q2FsbGVlKSB7CiAgICAgICAgICAgICByZXN1bHQtPnNldEpTRW50cnlwb2ludENhbGxlZSh2bSwg Y2FsbGVlSW5kZXgsIGpzRW50cnlwb2ludENhbGxlZSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZVJlY29yZC5jcHAgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZVJlY29yZC5jcHAKaW5kZXgg YzFiZDgyMC4uOWVmZjRjNCAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v anMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmNwcApAQCAtMTE4LDcgKzExOCw3IEBA IHZvaWQgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmxpbmsoRXhlY1N0YXRlKiBzdGF0ZSwgSlNX ZWJBc3NlbWJseUluc3RhbmNlKiBpbnN0CiAgICAgICAgICAgICAvLyAgICAgYy4gUmV0dXJuIGZ1 bmMuCiAgICAgICAgICAgICBKU1dlYkFzc2VtYmx5Q2FsbGVlKiBqc0VudHJ5cG9pbnRDYWxsZWUg PSBtb2R1bGUtPmpzRW50cnlwb2ludENhbGxlZUZyb21GdW5jdGlvbkluZGV4U3BhY2UoZXhwLmtp bmRJbmRleCk7CiAgICAgICAgICAgICBKU1dlYkFzc2VtYmx5Q2FsbGVlKiB3YXNtRW50cnlwb2lu dENhbGxlZSA9IG1vZHVsZS0+d2FzbUVudHJ5cG9pbnRDYWxsZWVGcm9tRnVuY3Rpb25JbmRleFNw YWNlKGV4cC5raW5kSW5kZXgpOwotICAgICAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2ln bmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVyZUZvckZ1bmN0aW9uSW5kZXhTcGFjZShleHAu a2luZEluZGV4KTsKKyAgICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUlu ZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2UoZXhwLmtp bmRJbmRleCk7CiAgICAgICAgICAgICBjb25zdCBXYXNtOjpTaWduYXR1cmUqIHNpZ25hdHVyZSA9 IFdhc206OlNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQoJnZtLCBzaWduYXR1cmVJbmRleCk7CiAg ICAgICAgICAgICBXZWJBc3NlbWJseUZ1bmN0aW9uKiBmdW5jdGlvbiA9IFdlYkFzc2VtYmx5RnVu Y3Rpb246OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LCBzaWduYXR1cmUtPmFyZ3VtZW50Q291bnQo KSwgZXhwLmZpZWxkLnN0cmluZygpLCBpbnN0YW5jZSwganNFbnRyeXBvaW50Q2FsbGVlLCB3YXNt RW50cnlwb2ludENhbGxlZSwgc2lnbmF0dXJlSW5kZXgpOwogICAgICAgICAgICAgZXhwb3J0ZWRW YWx1ZSA9IGZ1bmN0aW9uOwpAQCAtMTMzLDggKzEzMyw2IEBAIHZvaWQgV2ViQXNzZW1ibHlNb2R1 bGVSZWNvcmQ6OmxpbmsoRXhlY1N0YXRlKiBzdGF0ZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBp bnN0CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQogICAgICAgICBjYXNlIFdhc206OkV4 dGVybmFsS2luZDo6TWVtb3J5OiB7Ci0gICAgICAgICAgICAvLyBUaGlzIHNob3VsZCBiZSBndWFy YW50ZWVkIGJ5IG1vZHVsZSB2ZXJpZmljYXRpb24uCi0gICAgICAgICAgICBSRUxFQVNFX0FTU0VS VChpbnN0YW5jZS0+bWVtb3J5KCkpOyAKICAgICAgICAgICAgIEFTU0VSVChleHAua2luZEluZGV4 ID09IDApOwogCiAgICAgICAgICAgICBleHBvcnRlZFZhbHVlID0gaW5zdGFuY2UtPm1lbW9yeSgp OwpAQCAtMTc1LDcgKzE3Myw3IEBAIHZvaWQgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6Omxpbmso RXhlY1N0YXRlKiBzdGF0ZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBpbnN0CiAgICAgYm9vbCBo YXNTdGFydCA9ICEhbW9kdWxlSW5mb3JtYXRpb24uc3RhcnRGdW5jdGlvbkluZGV4U3BhY2U7CiAg ICAgaWYgKGhhc1N0YXJ0KSB7CiAgICAgICAgIGF1dG8gc3RhcnRGdW5jdGlvbkluZGV4U3BhY2Ug PSBtb2R1bGVJbmZvcm1hdGlvbi5zdGFydEZ1bmN0aW9uSW5kZXhTcGFjZS52YWx1ZV9vcigwKTsK LSAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNp Z25hdHVyZUZvckZ1bmN0aW9uSW5kZXhTcGFjZShzdGFydEZ1bmN0aW9uSW5kZXhTcGFjZSk7Cisg ICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbW9kdWxlLT5zaWdu YXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2Uoc3RhcnRGdW5jdGlvbkluZGV4U3BhY2Up OwogICAgICAgICBjb25zdCBXYXNtOjpTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFdhc206OlNpZ25h dHVyZUluZm9ybWF0aW9uOjpnZXQoJnZtLCBzaWduYXR1cmVJbmRleCk7CiAgICAgICAgIC8vIFRo ZSBzdGFydCBmdW5jdGlvbiBtdXN0IG5vdCB0YWtlIGFueSBhcmd1bWVudHMgb3IgcmV0dXJuIGFu eXRoaW5nLiBUaGlzIGlzIGVuZm9yY2VkIGJ5IHRoZSBwYXJzZXIuCiAgICAgICAgIEFTU0VSVCgh c2lnbmF0dXJlLT5hcmd1bWVudENvdW50KCkpOwpAQCAtMjM4LDcgKzIzNiw3IEBAIEpTVmFsdWUg V2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmV2YWx1YXRlKEV4ZWNTdGF0ZSogc3RhdGUpCiAKICAg ICAgICAgICAgICAgICBKU1dlYkFzc2VtYmx5Q2FsbGVlKiBqc0VudHJ5cG9pbnRDYWxsZWUgPSBt b2R1bGUtPmpzRW50cnlwb2ludENhbGxlZUZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25J bmRleCk7CiAgICAgICAgICAgICAgICAgSlNXZWJBc3NlbWJseUNhbGxlZSogd2FzbUVudHJ5cG9p bnRDYWxsZWUgPSBtb2R1bGUtPndhc21FbnRyeXBvaW50Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhT cGFjZShmdW5jdGlvbkluZGV4KTsKLSAgICAgICAgICAgICAgICBXYXNtOjpTaWduYXR1cmVJbmRl eCBzaWduYXR1cmVJbmRleCA9IG1vZHVsZS0+c2lnbmF0dXJlRm9yRnVuY3Rpb25JbmRleFNwYWNl KGZ1bmN0aW9uSW5kZXgpOworICAgICAgICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNp Z25hdHVyZUluZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3Bh Y2UoZnVuY3Rpb25JbmRleCk7CiAgICAgICAgICAgICAgICAgY29uc3QgV2FzbTo6U2lnbmF0dXJl KiBzaWduYXR1cmUgPSBXYXNtOjpTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KCZ2bSwgc2lnbmF0 dXJlSW5kZXgpOwogICAgICAgICAgICAgICAgIC8vIEZJWE1FOiBTYXkgd2UgZXhwb3J0IGxvY2Fs IGZ1bmN0aW9uICJmb28iIGF0IGZ1bmNpdG9uIGluZGV4IDAuCiAgICAgICAgICAgICAgICAgLy8g V2hhdCBpZiB3ZSBhbHNvIHNldCBpdCB0byB0aGUgdGFibGUgYW4gRWxlbWVudCB3LyBpbmRleCAw LgpAQCAtMjU3LDcgKzI1NSw2IEBAIEpTVmFsdWUgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmV2 YWx1YXRlKEV4ZWNTdGF0ZSogc3RhdGUpCiAgICAgICAgIGNvbnN0IFZlY3RvcjxXYXNtOjpTZWdt ZW50OjpQdHI+JiBkYXRhID0gbV9pbnN0YW5jZS0+bW9kdWxlKCktPm1vZHVsZUluZm9ybWF0aW9u KCkuZGF0YTsKICAgICAgICAgSlNXZWJBc3NlbWJseU1lbW9yeSoganNNZW1vcnkgPSBtX2luc3Rh bmNlLT5tZW1vcnkoKTsKICAgICAgICAgaWYgKCFkYXRhLmlzRW1wdHkoKSkgewotICAgICAgICAg ICAgUkVMRUFTRV9BU1NFUlQoanNNZW1vcnkpOyAvLyBJdCBpcyBhIHZhbGlkYXRpb24gZXJyb3Ig Zm9yIGEgRGF0YSBzZWN0aW9uIHRvIGV4aXN0IHdpdGhvdXQgYSBNZW1vcnkgc2VjdGlvbiBvciBp bXBvcnQuCiAgICAgICAgICAgICB1aW50OF90KiBtZW1vcnkgPSByZWludGVycHJldF9jYXN0PHVp bnQ4X3QqPihqc01lbW9yeS0+bWVtb3J5KCktPm1lbW9yeSgpKTsKICAgICAgICAgICAgIHVpbnQ2 NF90IHNpemVJbkJ5dGVzID0ganNNZW1vcnktPm1lbW9yeSgpLT5zaXplKCk7CiAgICAgICAgICAg ICBmb3IgKGF1dG8mIHNlZ21lbnQgOiBkYXRhKSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZVJlY29yZC5oIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQuaAppbmRleCBlMTI2Njcw Li4yNDY1ZDgzIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJB c3NlbWJseU1vZHVsZVJlY29yZC5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pz L1dlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmgKQEAgLTQ1LDcgKzQ1LDcgQEAgcHVibGljOgogICAg IERFQ0xBUkVfRVhQT1JUX0lORk87CiAKICAgICBzdGF0aWMgU3RydWN0dXJlKiBjcmVhdGVTdHJ1 Y3R1cmUoVk0mLCBKU0dsb2JhbE9iamVjdCosIEpTVmFsdWUpOwotICAgIHN0YXRpYyBXZWJBc3Nl bWJseU1vZHVsZVJlY29yZCogY3JlYXRlKEV4ZWNTdGF0ZSosIFZNJiwgU3RydWN0dXJlKiwgY29u c3QgSWRlbnRpZmllciYsIGNvbnN0IFdhc206Ok1vZHVsZUluZm9ybWF0aW9uJik7CisgICAgSlNf RVhQT1JUX1BSSVZBVEUgc3RhdGljIFdlYkFzc2VtYmx5TW9kdWxlUmVjb3JkKiBjcmVhdGUoRXhl Y1N0YXRlKiwgVk0mLCBTdHJ1Y3R1cmUqLCBjb25zdCBJZGVudGlmaWVyJiwgY29uc3QgV2FzbTo6 TW9kdWxlSW5mb3JtYXRpb24mKTsKIAogICAgIHZvaWQgbGluayhFeGVjU3RhdGUqLCBKU1dlYkFz c2VtYmx5SW5zdGFuY2UqKTsKICAgICBKU19FWFBPUlRfUFJJVkFURSBKU1ZhbHVlIGV2YWx1YXRl KEV4ZWNTdGF0ZSopOwotLSAKMi4xMC4xCgo= 297863 2016-12-30 12:54:18 -0800 2017-01-02 15:02:02 -0800 patch 0001-wasm-wasm.patch text/plain 153863 jfbastien RnJvbSBkNGM4NTVkYzNkMzI2YmI5OWU0MmZlZjUzZTcxZWVjZjJkZDY0Yjc4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBXZWQsIDIxIERlYyAyMDE2IDE1OjU5OjU2IC0wODAwClN1YmplY3Q6IFtQQVRDSF0gd2FzbS0+ d2FzbQoKQ2hhbmdlcyB0byB0aGUgV2ViQXNzZW1ibHkgaW1wbGVtZW50YXRpb246CgogIC0gQWRk IGEgbmV3IEpTVHlwZSBmb3IgV2ViQXNzZW1ibHlGdW5jdGlvbiwgYW5kIHVzZSBpdCB3aGVuIGNy ZWF0aW5nIGl0cwogICAgc3RydWN0dXJlLiBUaGlzIHdpbGwgYmUgdXNlZCB0byBxdWlja2x5IGRl dGVjdCBmcm9tIHdhc20gd2hldGhlciB0aGUgaW1wb3J0CiAgICBjYWxsIGlzIHRvIGFub3RoZXIg d2FzbSBtb2R1bGUsIG9yIHdoZXRoZXIgaXQncyB0byBKUy4KICAtIFVzZSBjZWxsIGluc3RlYWQg b2Ygb2JqZWN0cyB0byBkZXRlY3Qgd2FzbS0+d2FzbSwgdGhlIHByZXZpb3VzIGNvZGUgd2FzIHdy b25nLgogIC0gSW1wcm92ZSBkaWFnbm9zdGljIHByaW50b3V0IGZvciB3YXNtIHN0dWJzOiBwcmlu dCB0aGUgZnVsbCBzaWduYXR1cmUuCiAgLSBQcm9wZXJseSBjaGVjayB0aGF0IHdhc20gLT4gd2Fz bSBjYWxscyBoYXZlIG1hdGNoaW5nIHNpZ25hdHVyZXMuIEFkZCB0ZXN0aW5nIGZvciB0aGlzLgog IC0gVGVzdCBzb21lIG9mIHRoZSB3YXNtIC0+IHdhc20gY2FsbHMsIG5vdCB3b3JraW5nIHlldCwg YW5kIG1vcmUgdGVzdHMgbmVlZCB0bwogICAgZ2V0IGltcGxlbWVudGVkLgogIC0gR2VuZXJhdGUg dHdvIHN0dWJzIGZyb20gdGhlIGltcG9ydCBzdHViIGdlbmVyYXRvcjogb25lIGZvciB3YXNtLT5K UyBhbmQgb25lCiAgICBmb3Igd2FzbSAtPiB3YXNtLiBUaGlzIGlzIGRvbmUgYXQgTW9kdWxlIHRp bWUuIFdoaWNoIGlzIGNhbGxlZCB3aWxsIG9ubHkgYmUKICAgIGtub3duIGF0IEluc3RhbmNlIHRp bWUsIG9uY2Ugd2UndmUgcmVjZWl2ZWQgdGhlIGltcG9ydCBvYmplY3QuIFdlIHdhbnQgdG8KICAg IGF2b2lkIGNvZGVnZW4gYXQgSW5zdGFuY2UgdGltZSwgc28gaGF2aW5nIGJvdGggYXJvdW5kIGlz IGdyZWF0LgogIC0gUmVzdG9yZSB0aGUgV2ViQXNzZW1ibHkgZ2xvYmFsIHN0YXRlIChWTSB0b3Ag SW5zdGFuY2UsIGFuZCBwaW5uZWQgcmVnaXN0ZXJzKQogICAgYWZ0ZXIgY2FsbCAvIGNhbGxfaW5k aXJlY3QsIGFuZCBpbiB0aGUgSlMtPndhc20gZW50cnkgc3R1Yi4KICAtIFBpbm5lZCByZWdpc3Rl cnMgYXJlIG5vdyBhIGdsb2JhbCB0aGluZywgbm90IHBlci1NZW1vcnksIGJlY2F1c2UgdGhlIHdh c20gLT4KICAgIHdhc20gc3R1YnMgYXJlIGdlbmVyYXRlZCBhdCBNb2R1bGUgdGltZSB3aGVyZSB3 ZSBkb24ndCByZWFsbHkgaGF2ZSBlbm91Z2gKICAgIGluZm9ybWF0aW9uIHRvIGRvIHRoZSByaWdo dCB0aGluZyAoZG9pbmcgc28gd291bGQgZ2VuZXJhdGUgdG9vIG11Y2ggY29kZSkuCgpTdXBwb3J0 IGNoYW5nZXM6CgogIC0gQWRkIGEgUHJveHkgdG8gQnVpbGRlci5qcywgd2hpY2ggaW50ZXJjZXB0 cyB1bmtub3duIHByb3BlcnR5IGxvb2t1cHMuIFRoaXMKICAgIGNyZWF0ZXMgd2F5IGJldHRlciBl cnJvciBtZXNzYWdlcyBvbiB0eXBvcyB0aGFuICd1bmRlZmluZWQgaXMgbm90IGEKICAgIGZ1bmN0 aW9uJywgd2hpY2ggaGFwcGVucyBzZW1pLWZyZXF1ZW50bHkgYXMgSSB0eXBvIG9wY29kZSBuYW1l cyAoYW5kIHdoaWNoCiAgICBvbmUgaXMgYSB0eXBvIGlzIGhhcmQgdG8gZmluZCBiZWNhdXNlIHdl IGNoYWluIGJ1aWxkZXJzKS4KICAtIEFkZCBsaW1pdGVkIHN1cHBvcnQgZm9yIHZhcnt1fWludDY0 IChvbmx5IHRoZSAzMi1iaXQgdmFsdWVzKS4KICAtIEdldCByaWQgb2YgbXVjaCBvZiB0aGUgZnVu Y3Rpb24gaW5kZXggc3BhY2U6IHdlIGFscmVhZHkgaGF2ZSBhbGwgb2YgaXRzCiAgICBpbmZvcm1h dGlvbiBlbHNld2hlcmUsIGFuZCBhcy1pcyBpdCBwcm92aWRlcyBubyBleHRyYSBlZmZpY2llbmN5 LgogIC0gU3RvcmUgV2FzbTo6TWVtb3J5IGRpcmVjdGx5IG9uIEpTV2ViQXNzZW1ibHlNZW1vcnks IGluc3RlYWQgb2YgdGhyb3VnaCBhCiAgICB1bmlxdWVfcHRyLiBUaGlzIHJlbW92ZXMgYW4gaW5k aXJlY3Rpb24gYW5kIHVzZWxlc3MgYWxsb2NhdGlvbi4KICAtIFJlbW92ZSBWTSdhIFdlYkFzc2Vt Ymx5IG1lbW9yeSAvIHNpemUsIGFuZCBvYnRhaW4gdGhlbSBmcm9tIEluc3RhbmNlCiAgICBpbnN0 ZWFkLiBUaGlzIHJlcXVpcmVzIGFuIGV4dHJhIGluZGlyZWN0aW9uLCBidXQgaXMgY2xlYW5lci4K ICAtIENhY2hlIHRoZSB3YXNtIGVudHJ5cG9pbnQgY29kZSdzIGxvY2F0aW9uIG9uIFdlYkFzc2Vt Ymx5RnVuY3Rpb24gZm9yIGZhc3RlcgogICAgYWNjZXNzLgogIC0gQWxsIEluc3RhbmNlIG5vdyBo YXZlIGEgdmFsaWQgSlNXZWJBc3NlbWJseU1lbW9yeSB3aGVuIGNyZWF0ZWQsIHdoaWNoIGFsbG93 cwogICAgdGhlIHdhc20gLT4gd2FzbSBzdHViIHRvIGFzc3VtZSBpdCBpc24ndCBudWxsIHdoZW4g dHJ5aW5nIHRvIHNldCB0aGUgcGlubmVkCiAgICByZWdpc3RlcnMuCiAgLSBBbHdheXMgcGluIHJl Z2lzdGVycywgZXZlbiBpZiBubyBNZW1vcnkgaXMgcHJlc2VudCBhbmQgd2UgZG9uJ3QgdGVjaG5p Y2FsbHkKICAgIG5lZWQgdG8gcGluIHRoZW0uCi0tLQogSlNUZXN0cy9DaGFuZ2VMb2cgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMzUgKysrKwogSlNUZXN0cy93YXNtL0J1aWxk ZXIuanMgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgOTEgKysrKystLS0tCiBKU1Rlc3Rz L3dhc20vTG93TGV2ZWxCaW5hcnkuanMgICAgICAgICAgICAgICAgICAgICB8ICAxMiArKwogSlNU ZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMgICAgICAgICAgfCAgIDYgKy0K IEpTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMgICAgICAgICAgIHwgICAy ICstCiBKU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5qcyAgICAgICAgICB8 ICAgMiArLQogSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20tYmFkLXNpZ25hdHVyZS5q cyAgfCAxMDUgKysrKysrKysrKwogSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMg ICAgICAgICAgICAgICAgfCAgNzIgKysrKysrKwogU291cmNlL0phdmFTY3JpcHRDb3JlL0NNYWtl TGlzdHMudHh0ICAgICAgICAgICAgICAgfCAgIDEgKwogU291cmNlL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZyAgICAgICAgICAgICAgICAgICAgfCAxMzAgKysrKysrKysrKysrCiAuLi4vSmF2YVNj cmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiAgICAgICB8ICAgOCArLQogU291cmNl L0phdmFTY3JpcHRDb3JlL2pzYy5jcHAgICAgICAgICAgICAgICAgICAgICAgfCAgMjUgKystCiAu Li4vSmF2YVNjcmlwdENvcmUvcnVudGltZS9BYnN0cmFjdE1vZHVsZVJlY29yZC5oICB8ICAgMiAr LQogU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmggICAgICAgICAgICAgfCAg IDIgKwogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuY3BwICAg fCAyMjMgKysrKysrKysrKysrKy0tLS0tLS0tCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9X YXNtQjNJUkdlbmVyYXRvci5oICAgICB8ICAgMiArLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbUJpbmRpbmcuY3BwICAgICAgICAgfCAgNjcgKysrKysrLQogU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuaCAgICAgICAgICAgfCAgIDIgKy0KIFNvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21Gb3JtYXQuaCAgICAgICAgICAgIHwgIDI4ICsrLQogU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmggICAgfCAgMTYgKy0KIFNv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwICAgICAgICAgIHwgIDU3ICsr KysrLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5oICAgICAgICAgICAg fCAgMzEgKystCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5SW5mb3JtYXRpb24u Y3BwICB8ICA1OSArKysrLS0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnlJ bmZvcm1hdGlvbi5oIHwgICA5ICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9k dWxlUGFyc2VyLmNwcCAgICB8ICAyNyArLS0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dh c21Nb2R1bGVQYXJzZXIuaCAgICAgIHwgICAyICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtUGFnZUNvdW50LmNwcCAgICAgICB8ICA0NSArKysrKwogU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbVBhZ2VDb3VudC5oICAgICAgICAgfCAgIDYgKwogU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbVBsYW4uY3BwICAgICAgICAgICAgfCAgNDQgKystLQogU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uaCAgICAgICAgICAgICAgfCAgMTQgKy0KIFNvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuY3BwICAgICAgIHwgIDE4ICstCiBT b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmggICAgICAgICB8ICAgMSAr CiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwICAgICAgICB8ICAg NCArLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmggICAgICAgICAg fCAgIDIgKy0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5j ZS5oIHwgIDExICstCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVt b3J5LmNwcCB8ICAxMiArLQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJs eU1lbW9yeS5oICAgfCAgMTMgKy0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNz ZW1ibHlNb2R1bGUuY3BwIHwgICA5ICstCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dl YkFzc2VtYmx5TW9kdWxlLmggICB8ICAxNiArLQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMv V2ViQXNzZW1ibHlGdW5jdGlvbi5jcHAgfCAgIDkgKy0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNt L2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uaCAgIHwgICA4ICstCiAuLi4vd2FzbS9qcy9XZWJBc3Nl bWJseUluc3RhbmNlQ29uc3RydWN0b3IuY3BwICAgICB8ICAyMCArLQogLi4uL3dhc20vanMvV2Vi QXNzZW1ibHlNZW1vcnlDb25zdHJ1Y3Rvci5jcHAgICAgICAgfCAgIDIgKy0KIC4uLi93YXNtL2pz L1dlYkFzc2VtYmx5TW9kdWxlQ29uc3RydWN0b3IuY3BwICAgICAgIHwgICAyICstCiAuLi4vd2Fz bS9qcy9XZWJBc3NlbWJseU1vZHVsZVJlY29yZC5jcHAgICAgICAgICAgICB8ICAgOSArLQogLi4u L3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQuaCAgICAgICAgICAgICAgfCAgIDIgKy0K IDQ2IGZpbGVzIGNoYW5nZWQsIDk2MiBpbnNlcnRpb25zKCspLCAzMDEgZGVsZXRpb25zKC0pCiBj cmVhdGUgbW9kZSAxMDA2NDQgSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20tYmFkLXNp Z25hdHVyZS5qcwogY3JlYXRlIG1vZGUgMTAwNjQ0IEpTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10 by13YXNtLmpzCiBjcmVhdGUgbW9kZSAxMDA2NDQgU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbVBhZ2VDb3VudC5jcHAKCmRpZmYgLS1naXQgYS9KU1Rlc3RzL0NoYW5nZUxvZyBiL0pTVGVz dHMvQ2hhbmdlTG9nCmluZGV4IDAwZmQ0OTguLmUzODRkYWMgMTAwNjQ0Ci0tLSBhL0pTVGVzdHMv Q2hhbmdlTG9nCisrKyBiL0pTVGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzggQEAKKzIwMTYt MTItMzAgIEpGIEJhc3RpZW4gIDxqZmJhc3RpZW5AYXBwbGUuY29tPgorCisgICAgICAgIFdlYkFz c2VtYmx5OiBoYW5kbGUgYW5kIG9wdGltaXplIHdhc20gZXhwb3J0IOKGkiB3YXNtIGltcG9ydCBj YWxscworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1 MjgyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiB3 YXNtL0J1aWxkZXIuanM6IEFkZCBhIFByb3h5IHRvIEJ1aWxkZXIuanMsIHdoaWNoIGludGVyY2Vw dHMKKyAgICAgICAgdW5rbm93biBwcm9wZXJ0eSBsb29rdXBzLiBUaGlzIGNyZWF0ZXMgd2F5IGJl dHRlciBlcnJvciBtZXNzYWdlcworICAgICAgICBvbiB0eXBvcyB0aGFuICd1bmRlZmluZWQgaXMg bm90IGEgZnVuY3Rpb24nLCB3aGljaCBoYXBwZW5zCisgICAgICAgIHNlbWktZnJlcXVlbnRseSBh cyBJIHR5cG8gb3Bjb2RlIG5hbWVzIChhbmQgd2hpY2ggb25lIGlzIGEgdHlwbyBpcworICAgICAg ICBoYXJkIHRvIGZpbmQgYmVjYXVzZSB3ZSBjaGFpbiBidWlsZGVycykuCisgICAgICAgIChjb25z dC5faXNWYWxpZFZhbHVlKToKKyAgICAgICAgKGdldCB0YXJnZXQpOgorICAgICAgICAoY29uc3Qu X2ltcG9ydEZ1bmN0aW9uQ29udGludWF0aW9uKToKKyAgICAgICAgKGNvbnN0Ll9pbXBvcnRNZW1v cnlDb250aW51YXRpb24pOgorICAgICAgICAoY29uc3QuX2ltcG9ydFRhYmxlQ29udGludWF0aW9u KToKKyAgICAgICAgKGNvbnN0Ll9leHBvcnRGdW5jdGlvbkNvbnRpbnVhdGlvbik6CisgICAgICAg IChleHBvcnQuZGVmYXVsdC5CdWlsZGVyLnByb3RvdHlwZS5fcmVnaXN0ZXJTZWN0aW9uQnVpbGRl cnMuY29uc3Quc2VjdGlvbi5pbi5XQVNNLmRlc2NyaXB0aW9uLnNlY3Rpb24uc3dpdGNoLnNlY3Rp b24uY2FzZS5zdHJpbmdfYXBwZWFyZWRfaGVyZS50aGlzLnNlY3Rpb24pOgorICAgICAgICAoZXhw b3J0LmRlZmF1bHQuQnVpbGRlci5wcm90b3R5cGUuX3JlZ2lzdGVyU2VjdGlvbkJ1aWxkZXJzLnRo aXMuVW5rbm93bik6CisgICAgICAgICogd2FzbS9Mb3dMZXZlbEJpbmFyeS5qczogQWRkIGxpbWl0 ZWQgc3VwcG9ydCBmb3IgdmFye3V9aW50NjQgKG9ubHkgdGhlIDMyLWJpdCB2YWx1ZXMpCisgICAg ICAgIChleHBvcnQuZGVmYXVsdC5Mb3dMZXZlbEJpbmFyeS5wcm90b3R5cGUudmFyaW50MzIpOgor ICAgICAgICAoZXhwb3J0LmRlZmF1bHQuTG93TGV2ZWxCaW5hcnkucHJvdG90eXBlLnZhcnVpbnQ2 NCk6CisgICAgICAgIChleHBvcnQuZGVmYXVsdC5Mb3dMZXZlbEJpbmFyeS5wcm90b3R5cGUudmFy aW50NjQpOgorICAgICAgICAqIHdhc20vZnVuY3Rpb24tdGVzdHMvZXhjZXB0aW9ucy5qczogdXBk YXRlIGVycm9yIG1lc3NhZ2UKKyAgICAgICAgKiB3YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtbG9h ZC5qczogdXBkYXRlIGVycm9yIG1lc3NhZ2UKKyAgICAgICAgKiB3YXNtL2Z1bmN0aW9uLXRlc3Rz L3RyYXAtc3RvcmUuanM6IHVwZGF0ZSBlcnJvciBtZXNzYWdlCisgICAgICAgICogd2FzbS9qcy1h cGkvd2FzbS10by13YXNtLWJhZC1zaWduYXR1cmUuanM6IEFkZGVkLiBUZXN0IGEgYnVuY2ggb2Yg YmFkIHdhc20tPndhc20gaW1wb3J0IHNpZ25hdHVyZXMKKyAgICAgICAgKGNvbnN0Lm1ha2VJbXBv cnRlZS5zaWduYXR1cmUuc3dpdGNoKToKKyAgICAgICAgKEJhZFNpZ25hdHVyZURyb3BTdGFydFBh cmFtcyk6CisgICAgICAgICogd2FzbS9qcy1hcGkvd2FzbS10by13YXNtLmpzOiBBZGRlZC4gVGVz dCA2NC1iaXQgd2FzbS0+d2FzbSBpbXBvcnQgY2FsbHMKKyAgICAgICAgKGNvbnN0LmNhbGxlck1v ZHVsZSk6CisgICAgICAgIChjb25zdC5jYWxsZWVNb2R1bGUpOgorICAgICAgICAoV2FzbVRvV2Fz bSk6CisKIDIwMTYtMTItMjkgIFNhYW0gQmFyYXRpICA8c2JhcmF0aUBhcHBsZS5jb20+CiAKICAg ICAgICAgV2ViQXNzZW1ibHk6IFJlYmFzZSBzcGVjLXRlc3RzIG5vdyB0aGF0IHdhYnQgaGFzIGJl ZW4gdXBkYXRlZCB0byBwcm9kdWNlIGNlcnRhaW4ga2luZHMgb2YgaW52YWxpZCBtb2R1bGVzCmRp ZmYgLS1naXQgYS9KU1Rlc3RzL3dhc20vQnVpbGRlci5qcyBiL0pTVGVzdHMvd2FzbS9CdWlsZGVy LmpzCmluZGV4IGRhNTg0YzQuLjI2YmE2NmUgMTAwNjQ0Ci0tLSBhL0pTVGVzdHMvd2FzbS9CdWls ZGVyLmpzCisrKyBiL0pTVGVzdHMvd2FzbS9CdWlsZGVyLmpzCkBAIC0zOCw3ICszOCw3IEBAIGNv bnN0IF9pc1ZhbGlkVmFsdWUgPSAodmFsdWUsIHR5cGUpID0+IHsKICAgICBzd2l0Y2ggKHR5cGUp IHsKICAgICAvLyBXZSBhbGxvdyBib3RoIHNpZ25lZCBhbmQgdW5zaWduZWQgbnVtYmVycy4KICAg ICBjYXNlICJpMzIiOiByZXR1cm4gTWF0aC5yb3VuZCh2YWx1ZSkgPT09IHZhbHVlICYmIExMQi52 YXJpbnQzMk1pbiA8PSB2YWx1ZSAmJiB2YWx1ZSA8PSBMTEIudmFydWludDMyTWF4OwotICAgIGNh c2UgImk2NCI6IHRocm93IG5ldyBFcnJvcihgVW5pbXBsZW1lbnRlZDogdmFsdWUgY2hlY2sgZm9y ICR7dHlwZX1gKTsgLy8gRklYTUUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTE2MzQyMCA2NC1iaXQgdmFsdWVzCisgICAgY2FzZSAiaTY0IjogcmV0dXJuIHRydWU7IC8v IEZJWE1FIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjM0MjAgNjQt Yml0IHZhbHVlcwogICAgIGNhc2UgImYzMiI6IHJldHVybiB0eXBlb2YodmFsdWUpID09PSAibnVt YmVyIiAmJiBpc0Zpbml0ZSh2YWx1ZSk7CiAgICAgY2FzZSAiZjY0IjogcmV0dXJuIHR5cGVvZih2 YWx1ZSkgPT09ICJudW1iZXIiICYmIGlzRmluaXRlKHZhbHVlKTsKICAgICBkZWZhdWx0OiB0aHJv dyBuZXcgRXJyb3IoYEltcGxlbWVudGF0aW9uIHByb2JsZW06IHVua25vd24gdHlwZSAke3R5cGV9 YCk7CkBAIC01Nyw2ICs1NywxNiBAQCBjb25zdCBfbm9ybWFsaXplRnVuY3Rpb25TaWduYXR1cmUg PSAocGFyYW1zLCByZXQpID0+IHsKICAgICByZXR1cm4gW3BhcmFtcywgcmV0XTsKIH07CiAKK2Nv bnN0IF9lcnJvckhhbmRsaW5nUHJveHlGb3IgPSBidWlsZGVyID0+IGJ1aWxkZXJbIl9faXNQcm94 eSJdID8gYnVpbGRlciA6IG5ldyBQcm94eShidWlsZGVyLCB7CisgICAgZ2V0OiAodGFyZ2V0LCBw cm9wZXJ0eSwgcmVjZWl2ZXIpID0+IHsKKyAgICAgICAgaWYgKHByb3BlcnR5ID09PSAiX19pc1By b3h5IikKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICBpZiAodGFyZ2V0W3Byb3Bl cnR5XSA9PT0gdW5kZWZpbmVkKQorICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBXZWJBc3Nl bWJseSBidWlsZGVyIHJlY2VpdmVkIHVua25vd24gcHJvcGVydHkgJyR7cHJvcGVydHl9J2ApOwor ICAgICAgICByZXR1cm4gdGFyZ2V0W3Byb3BlcnR5XTsKKyAgICB9Cit9KTsKKwogY29uc3QgX21h eWJlUmVnaXN0ZXJUeXBlID0gKGJ1aWxkZXIsIHR5cGUpID0+IHsKICAgICBjb25zdCB0eXBlU2Vj dGlvbiA9IGJ1aWxkZXIuX2dldFNlY3Rpb24oIlR5cGUiKTsKICAgICBpZiAodHlwZW9mKHR5cGUp ID09PSAibnVtYmVyIikgewpAQCAtMTAwLDcgKzExMCw3IEBAIGNvbnN0IF9pbXBvcnRGdW5jdGlv bkNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAg ICAgICBzZWN0aW9uLmRhdGEucHVzaCh7IGZpZWxkOiBmaWVsZCwgdHlwZTogdHlwZSwga2luZDog IkZ1bmN0aW9uIiwgbW9kdWxlOiBtb2R1bGUgfSk7CiAgICAgICAgIC8vIEltcG9ydHMgYWxzbyBj b3VudCBpbiB0aGUgZnVuY3Rpb24gaW5kZXggc3BhY2UuIE1hcCB0aGVtIGFzIG9iamVjdHMgdG8g YXZvaWQgY2xhc2hpbmcgd2l0aCBDb2RlIGZ1bmN0aW9ucycgbmFtZXMuCiAgICAgICAgIGJ1aWxk ZXIuX3JlZ2lzdGVyRnVuY3Rpb25Ub0luZGV4U3BhY2UoeyBtb2R1bGU6IG1vZHVsZSwgZmllbGQ6 IGZpZWxkIH0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBf ZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9OwogfTsKIApAQCAtMTA5 LDcgKzExOSw3IEBAIGNvbnN0IF9pbXBvcnRNZW1vcnlDb250aW51YXRpb24gPSAoYnVpbGRlciwg c2VjdGlvbiwgbmV4dEJ1aWxkZXIpID0+IHsKICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKG1vZHVs ZSwgYEltcG9ydCBNZW1vcnkgbW9kdWxlIHNob3VsZCBiZSBhIHN0cmluZywgZ290ICIke21vZHVs ZX0iYCk7CiAgICAgICAgIGFzc2VydC5pc1N0cmluZyhmaWVsZCwgYEltcG9ydCBNZW1vcnkgZmll bGQgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7ZmllbGR9ImApOwogICAgICAgICBzZWN0aW9u LmRhdGEucHVzaCh7bW9kdWxlLCBmaWVsZCwga2luZDogIk1lbW9yeSIsIG1lbW9yeURlc2NyaXB0 aW9uOiB7aW5pdGlhbCwgbWF4aW11bX19KTsKLSAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOwor ICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihuZXh0QnVpbGRlcik7CiAgICAg fTsKIH07CiAKQEAgLTExOCw3ICsxMjgsNyBAQCBjb25zdCBfaW1wb3J0VGFibGVDb250aW51YXRp b24gPSAoYnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1aWxkZXIpID0+IHsKICAgICAgICAgYXNzZXJ0 LmlzU3RyaW5nKG1vZHVsZSwgYEltcG9ydCBUYWJsZSBtb2R1bGUgc2hvdWxkIGJlIGEgc3RyaW5n LCBnb3QgIiR7bW9kdWxlfSJgKTsKICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKGZpZWxkLCBgSW1w b3J0IFRhYmxlIGZpZWxkIHNob3VsZCBiZSBhIHN0cmluZywgZ290ICIke2ZpZWxkfSJgKTsKICAg ICAgICAgc2VjdGlvbi5kYXRhLnB1c2goe21vZHVsZSwgZmllbGQsIGtpbmQ6ICJUYWJsZSIsIHRh YmxlRGVzY3JpcHRpb246IHtpbml0aWFsLCBtYXhpbXVtLCBlbGVtZW50fX0pOwotICAgICAgICBy ZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9y KG5leHRCdWlsZGVyKTsKICAgICB9OwogfTsKIApAQCAtMTcyLDcgKzE4Miw3IEBAIGNvbnN0IF9l eHBvcnRGdW5jdGlvbkNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRl cikgPT4gewogICAgICAgICAgICAgICAgIGFzc2VydC5lcSh0eXBlLCBleHBvcnRlZEltcG9ydC50 eXBlLCBgUmUtZXhwb3J0aW5nIGltcG9ydCAiJHtleHBvcnRlZEltcG9ydC5maWVsZH0iIGFzICIk e2ZpZWxkfSIgaGFzIG1pc21hdGNoaW5nIHR5cGVgKTsKICAgICAgICAgfQogICAgICAgICBzZWN0 aW9uLmRhdGEucHVzaCh7IGZpZWxkOiBmaWVsZCwgdHlwZTogdHlwZSwga2luZDogIkZ1bmN0aW9u IiwgaW5kZXg6IGluZGV4IH0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAg IHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9OwogfTsK IApAQCAtMTg5LDcgKzE5OSw3IEBAIGNvbnN0IF9leHBvcnRHbG9iYWxDb250aW51YXRpb24gPSAo YnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1aWxkZXIpID0+IHsKICAgICByZXR1cm4gKGZpZWxkLCBp bmRleCkgPT4gewogICAgICAgICBhc3NlcnQuaXNOdW1iZXIoaW5kZXgsIGBHbG9iYWwgZXhwb3J0 cyBvbmx5IHN1cHBvcnQgbnVtYmVyIGluZGljZXMgcmlnaHQgbm93YCk7CiAgICAgICAgIHNlY3Rp b24uZGF0YS5wdXNoKHsgZmllbGQsIGtpbmQ6ICJHbG9iYWwiLCBpbmRleCB9KTsKLSAgICAgICAg cmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZv cihuZXh0QnVpbGRlcik7CiAgICAgfQogfTsKIApAQCAtMTk3LDcgKzIwNyw3IEBAIGNvbnN0IF9l eHBvcnRNZW1vcnlDb250aW51YXRpb24gPSAoYnVpbGRlciwgc2VjdGlvbiwgbmV4dEJ1aWxkZXIp ID0+IHsKICAgICByZXR1cm4gKGZpZWxkLCBpbmRleCkgPT4gewogICAgICAgICBhc3NlcnQuaXNO dW1iZXIoaW5kZXgsIGBNZW1vcnkgZXhwb3J0cyBvbmx5IHN1cHBvcnQgbnVtYmVyIGluZGljZXNg KTsKICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2goe2ZpZWxkLCBraW5kOiAiTWVtb3J5IiwgaW5k ZXh9KTsKLSAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICByZXR1cm4gX2Vycm9y SGFuZGxpbmdQcm94eUZvcihuZXh0QnVpbGRlcik7CiAgICAgfQogfTsKIApAQCAtMjA1LDcgKzIx NSw3IEBAIGNvbnN0IF9leHBvcnRUYWJsZUNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9u LCBuZXh0QnVpbGRlcikgPT4gewogICAgIHJldHVybiAoZmllbGQsIGluZGV4KSA9PiB7CiAgICAg ICAgIGFzc2VydC5pc051bWJlcihpbmRleCwgYFRhYmxlIGV4cG9ydHMgb25seSBzdXBwb3J0IG51 bWJlciBpbmRpY2VzYCk7CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHtmaWVsZCwga2luZDog IlRhYmxlIiwgaW5kZXh9KTsKLSAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICBy ZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihuZXh0QnVpbGRlcik7CiAgICAgfQogfTsKIApA QCAtMjIwLDEwICsyMzAsMTAgQEAgY29uc3QgX2ltcG9ydEdsb2JhbENvbnRpbnVhdGlvbiA9IChi dWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgICAgICAgICAgICAgIGFzc2Vy dC5pc1N0cmluZyhmaWVsZCwgYEltcG9ydCBnbG9iYWwgZmllbGQgc2hvdWxkIGJlIGEgc3RyaW5n LCBnb3QgIiR7ZmllbGR9ImApOwogICAgICAgICAgICAgICAgIGFzc2VydC5pc1N0cmluZyhtdXRh YmlsaXR5LCBgSW1wb3J0IGdsb2JhbCBtdXRhYmlsaXR5IHNob3VsZCBiZSBhIHN0cmluZywgZ290 ICIke211dGFiaWxpdHl9ImApOwogICAgICAgICAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHsg Z2xvYmFsRGVzY3JpcHRpb246IHsgdHlwZTogb3AsIG11dGFiaWxpdHk6IF9ub3JtYWxpemVNdXRh YmlsaXR5KG11dGFiaWxpdHkpIH0sIG1vZHVsZSwgZmllbGQsIGtpbmQ6ICJHbG9iYWwiIH0pOwot ICAgICAgICAgICAgICAgIHJldHVybiBnbG9iYWxCdWlsZGVyOworICAgICAgICAgICAgICAgIHJl dHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwogICAgICAgICAgICAg fTsKICAgICAgICAgfQotICAgICAgICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsKKyAgICAgICAgcmV0 dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7CiAgICAgfTsKIH07CiAK QEAgLTMyNCwxMSArMzM0LDExIEBAIGNvbnN0IF9jcmVhdGVGdW5jdGlvbkJ1aWxkZXIgPSAoZnVu YywgYnVpbGRlciwgcHJldmlvdXNCdWlsZGVyKSA9PiB7CiAgICAgICAgICAgICBkZWZhdWx0Ogog ICAgICAgICAgICAgICAgIG5leHRCdWlsZGVyID0gZnVuY3Rpb25CdWlsZGVyOwogICAgICAgICAg ICAgICAgIGJyZWFrOwotICAgICAgICAgICAgICAgIGNhc2UgIkVuZCI6CisgICAgICAgICAgICBj YXNlICJFbmQiOgogICAgICAgICAgICAgICAgIG5leHRCdWlsZGVyID0gcHJldmlvdXNCdWlsZGVy OwotICAgICAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgICAgICBicmVhazsKICAg ICAgICAgICAgIGNhc2UgIkJsb2NrIjoKLSAgICAgICAgICAgICAgICBjYXNlICJMb29wIjoKKyAg ICAgICAgICAgIGNhc2UgIkxvb3AiOgogICAgICAgICAgICAgY2FzZSAiSWYiOgogICAgICAgICAg ICAgICAgIG5leHRCdWlsZGVyID0gX2NyZWF0ZUZ1bmN0aW9uQnVpbGRlcihmdW5jLCBidWlsZGVy LCBmdW5jdGlvbkJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIGJyZWFrOwpAQCAtMzQ0LDExICsz NTQsMTIgQEAgY29uc3QgX2NyZWF0ZUZ1bmN0aW9uQnVpbGRlciA9IChmdW5jLCBidWlsZGVyLCBw cmV2aW91c0J1aWxkZXIpID0+IHsKICAgICAgICAgICAgIGNvbnN0IHN0YWNrQXJncyA9IFtdOyAv LyBGSVhNRSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYyNzA2CiAg ICAgICAgICAgICBmdW5jLmNvZGUucHVzaCh7IG5hbWU6IG9wLCB2YWx1ZTogdmFsdWUsIGFyZ3Vt ZW50czogc3RhY2tBcmdzLCBpbW1lZGlhdGVzOiBpbW1zIH0pOwogICAgICAgICAgICAgaWYgKGhh c0NvbnRpbnVhdGlvbikKLSAgICAgICAgICAgICAgICByZXR1cm4gY29udGludWF0aW9uKG5leHRC dWlsZGVyKS5FbmQoKTsKLSAgICAgICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAg ICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihjb250aW51YXRpb24obmV4dEJ1 aWxkZXIpLkVuZCgpKTsKKyAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9y KG5leHRCdWlsZGVyKTsKICAgICAgICAgfTsKLSAgICB9Ci0gICAgcmV0dXJuIGZ1bmN0aW9uQnVp bGRlcjsKKyAgICB9OworCisgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZnVuY3Rp b25CdWlsZGVyKTsKIH0KIAogY29uc3QgX2NyZWF0ZUZ1bmN0aW9uID0gKHNlY3Rpb24sIGJ1aWxk ZXIsIHByZXZpb3VzQnVpbGRlcikgPT4gewpAQCAtNDQ5LDEwICs0NjAsMTAgQEAgZXhwb3J0IGRl ZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBGdW5jOiAocGFy YW1zLCByZXQpID0+IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbcGFyYW1zLCByZXRd ID0gX25vcm1hbGl6ZUZ1bmN0aW9uU2lnbmF0dXJlKHBhcmFtcywgcmV0KTsKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaCh7IHBhcmFtczogcGFyYW1zLCByZXQ6IHJldCB9 KTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gdHlwZUJ1aWxkZXI7CisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IodHlw ZUJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAgICAgfSwKICAgICAgICAgICAgICAgICAg ICAgfTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHR5cGVCdWlsZGVyOworICAgICAgICAg ICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih0eXBlQnVpbGRlcik7CiAg ICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNDY2LDcgKzQ3 Nyw3IEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAg ICBpbXBvcnRCdWlsZGVyLkZ1bmN0aW9uID0gX2ltcG9ydEZ1bmN0aW9uQ29udGludWF0aW9uKHRo aXMsIHMsIGltcG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICBpbXBvcnRCdWlsZGVy Lk1lbW9yeSA9IF9pbXBvcnRNZW1vcnlDb250aW51YXRpb24odGhpcywgcywgaW1wb3J0QnVpbGRl cik7CiAgICAgICAgICAgICAgICAgICAgIGltcG9ydEJ1aWxkZXIuVGFibGUgPSBfaW1wb3J0VGFi bGVDb250aW51YXRpb24odGhpcywgcywgaW1wb3J0QnVpbGRlcik7Ci0gICAgICAgICAgICAgICAg ICAgIHJldHVybiBpbXBvcnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vy cm9ySGFuZGxpbmdQcm94eUZvcihpbXBvcnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9Owog ICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC00NzcsNyArNDg4LDcgQEAgZXhwb3J0IGRlZmF1 bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBFbmQ6ICgpID0+IHRo aXMKICAgICAgICAgICAgICAgICAgICAgICAgIC8vIEZJWE1FOiBhZGQgYWJpbGl0eSB0byBhZGQg dGhpcyB3aXRoIHdoYXRldmVyLgogICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAgICAg ICAgICAgICByZXR1cm4gZnVuY3Rpb25CdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1 cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihmdW5jdGlvbkJ1aWxkZXIpOwogICAgICAgICAgICAg ICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTQ4OCwxMCArNDk5LDEwIEBAIGV4 cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRW5k OiAoKSA9PiB0aGlzLAogICAgICAgICAgICAgICAgICAgICAgICAgVGFibGU6ICh7aW5pdGlhbCwg bWF4aW11bSwgZWxlbWVudH0pID0+IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRh dGEucHVzaCh7dGFibGVEZXNjcmlwdGlvbjoge2luaXRpYWwsIG1heGltdW0sIGVsZW1lbnR9fSk7 Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHRhYmxlQnVpbGRlcjsKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih0YWJs ZUJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAg ICB9OwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gdGFibGVCdWlsZGVyOworICAgICAgICAg ICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih0YWJsZUJ1aWxkZXIpOwog ICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTUwMiwxMCAr NTEzLDEwIEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAg ICAgICAgICAgRW5kOiAoKSA9PiB0aGlzLAogICAgICAgICAgICAgICAgICAgICAgICAgSW5pdGlh bE1heFBhZ2VzOiAoaW5pdGlhbCwgbWF4KSA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgcy5kYXRhLnB1c2goeyBpbml0aWFsLCBtYXggfSk7Ci0gICAgICAgICAgICAgICAgICAgICAg ICAgICAgcmV0dXJuIG1lbW9yeUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAg cmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobWVtb3J5QnVpbGRlcik7CiAgICAgICAgICAg ICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAgICAgICAgICAgICAg ICAgIHJldHVybiBtZW1vcnlCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vy cm9ySGFuZGxpbmdQcm94eUZvcihtZW1vcnlCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9Owog ICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC01MTYsMTYgKzUyNywxNiBAQCBleHBvcnQgZGVm YXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgIEVuZDogKCkgPT4g dGhpcywKICAgICAgICAgICAgICAgICAgICAgICAgIEdldEdsb2JhbDogKHR5cGUsIGluaXRWYWx1 ZSwgbXV0YWJpbGl0eSkgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5w dXNoKHsgdHlwZSwgb3A6ICJnZXRfZ2xvYmFsIiwgbXV0YWJpbGl0eTogX25vcm1hbGl6ZU11dGFi aWxpdHkobXV0YWJpbGl0eSksIGluaXRWYWx1ZSB9KTsKLSAgICAgICAgICAgICAgICAgICAgICAg ICAgICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICAgICAgICAg ICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICAg ICAgZm9yIChsZXQgb3Agb2YgV0FTTS5kZXNjcmlwdGlvbi52YWx1ZV90eXBlKSB7CiAgICAgICAg ICAgICAgICAgICAgICAgICBnbG9iYWxCdWlsZGVyW190b0phdmFTY3JpcHROYW1lKG9wKV0gPSAo aW5pdFZhbHVlLCBtdXRhYmlsaXR5KSA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg cy5kYXRhLnB1c2goeyB0eXBlOiBvcCwgb3A6IG9wICsgIi5jb25zdCIsIG11dGFiaWxpdHk6IF9u b3JtYWxpemVNdXRhYmlsaXR5KG11dGFiaWxpdHkpLCBpbml0VmFsdWUgfSk7Ci0gICAgICAgICAg ICAgICAgICAgICAgICAgICAgcmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7 CiAgICAgICAgICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgICAgICB9Ci0gICAg ICAgICAgICAgICAgICAgIHJldHVybiBnbG9iYWxCdWlsZGVyOworICAgICAgICAgICAgICAgICAg ICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICAgICAg ICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC01MzksNyArNTUwLDcgQEAg ZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgIGV4cG9y dEJ1aWxkZXIuRnVuY3Rpb24gPSBfZXhwb3J0RnVuY3Rpb25Db250aW51YXRpb24odGhpcywgcywg ZXhwb3J0QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgIGV4cG9ydEJ1aWxkZXIuTWVtb3J5 ID0gX2V4cG9ydE1lbW9yeUNvbnRpbnVhdGlvbih0aGlzLCBzLCBleHBvcnRCdWlsZGVyKTsKICAg ICAgICAgICAgICAgICAgICAgZXhwb3J0QnVpbGRlci5UYWJsZSA9IF9leHBvcnRUYWJsZUNvbnRp bnVhdGlvbih0aGlzLCBzLCBleHBvcnRCdWlsZGVyKTsKLSAgICAgICAgICAgICAgICAgICAgcmV0 dXJuIGV4cG9ydEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5k bGluZ1Byb3h5Rm9yKGV4cG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAg ICAgICAgICAgYnJlYWs7CiAKQEAgLTU1Miw3ICs1NjMsNyBAQCBleHBvcnQgZGVmYXVsdCBjbGFz cyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgaWYgKHR5cGVvZihmdW5jdGlvbkluZGV4 T3JOYW1lKSAhPT0gIm51bWJlciIgJiYgdHlwZW9mKGZ1bmN0aW9uSW5kZXhPck5hbWUpICE9PSAi c3RyaW5nIikKICAgICAgICAgICAgICAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcihgU3RhcnQg c2VjdGlvbidzIGZ1bmN0aW9uIGluZGV4ICBtdXN0IGVpdGhlciBiZSBhIG51bWJlciBvciBhIHN0 cmluZ2ApOwogICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaChmdW5jdGlvbkluZGV4T3JO YW1lKTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHN0YXJ0QnVpbGRlcjsKKyAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3Ioc3RhcnRCdWlsZGVyKTsK ICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC01NjMsMTEg KzU3NCwxMSBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAg ICAgICAgICAgIEVuZDogKCkgPT4gdGhpcywKICAgICAgICAgICAgICAgICAgICAgICAgIEVsZW1l bnQ6ICh7dGFibGVJbmRleCA9IDAsIG9mZnNldCwgZnVuY3Rpb25JbmRpY2VzfSkgPT4gewogICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKHt0YWJsZUluZGV4LCBvZmZzZXQs IGZ1bmN0aW9uSW5kaWNlc30pOwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBl bGVtZW50QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9y SGFuZGxpbmdQcm94eUZvcihlbGVtZW50QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAg ICB9CiAgICAgICAgICAgICAgICAgICAgIH07CiAKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJu IGVsZW1lbnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxp bmdQcm94eUZvcihlbGVtZW50QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAg ICAgICAgICBicmVhazsKIApAQCAtNjMyLDEyICs2NDMsMTIgQEAgZXhwb3J0IGRlZmF1bHQgY2xh c3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyBGSVhN RSBpbiBjaGVja2VkIG1vZGUsIHRlc3QgdGhhdCB0aGUgdHlwZSBpcyBhY2NlcHRhYmxlIGZvciBz dGFydCBmdW5jdGlvbi4gV2UgcHJvYmFibHkgd2FudCBfcmVnaXN0ZXJGdW5jdGlvblRvSW5kZXhT cGFjZSB0byBhbHNvIHJlZ2lzdGVyIHR5cGVzIHBlciBpbmRleC4gaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NTY1OAogICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICB9CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHJldHVybiBidWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJl dHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAg ICAgICAgfSwKIAogICAgICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgICAgICBj b2RlQnVpbGRlci5GdW5jdGlvbiA9IF9jcmVhdGVGdW5jdGlvbihzLCBidWlsZGVyLCBjb2RlQnVp bGRlcik7Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiBjb2RlQnVpbGRlcjsKKyAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IoY29kZUJ1aWxkZXIpOwog ICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTY2MCwxOSAr NjcxLDE5IEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBJbmRleDogaW5kZXggPT4gewogICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgYXNzZXJ0LmVxKGluZGV4LCAwKTsgLy8gTGluZWFyIG1lbW9yeSBpbmRl eCBtdXN0IGJlIHplcm8gaW4gTVZQLgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgdGhpc1NlZ21lbnQuaW5kZXggPSBpbmRleDsKLSAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHJldHVybiBzZWdtZW50QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHNlZ21lbnRCdWlsZGVy KTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfSwKICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgT2Zmc2V0OiBvZmZzZXQgPT4gewogICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgLy8gRklYTUUgYWxsb3cgY29tcGxleCBpbml0X2V4cHIgaGVyZS4gaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NTcwMAogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgYXNzZXJ0LmlzTnVtYmVyKG9mZnNldCk7CiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0aGlzU2VnbWVudC5vZmZzZXQgPSBvZmZzZXQ7 Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gc2VnbWVudEJ1aWxk ZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFu ZGxpbmdQcm94eUZvcihzZWdtZW50QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIH0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfTsKLSAgICAgICAgICAgICAg ICAgICAgICAgICAgICByZXR1cm4gc2VnbWVudEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3Ioc2VnbWVudEJ1aWxkZXIpOwog ICAgICAgICAgICAgICAgICAgICAgICAgfSwKICAgICAgICAgICAgICAgICAgICAgfTsKLSAgICAg ICAgICAgICAgICAgICAgcmV0dXJuIGRhdGFCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihkYXRhQnVpbGRlcik7CiAgICAgICAgICAgICAg ICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNjkwLDEwICs3MDEsMTAgQEAgZXhw b3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgQnl0ZTogYiA9PiB7 CiAgICAgICAgICAgICAgICAgICAgIGFzc2VydC5lcShiICYgMHhGRiwgYiwgYFVua25vd24gc2Vj dGlvbiBleHBlY3RlZCBieXRlLCBnb3Q6ICIke2J9ImApOwogICAgICAgICAgICAgICAgICAgICBz LmRhdGEucHVzaChiKTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHVua25vd25CdWlsZGVy OworICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih1bmtu b3duQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfTsKLSAgICAgICAg ICAgIHJldHVybiB1bmtub3duQnVpbGRlcjsKKyAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5k bGluZ1Byb3h5Rm9yKHVua25vd25CdWlsZGVyKTsKICAgICAgICAgfTsKICAgICB9CiAgICAgX2Fk ZFNlY3Rpb24obmFtZU9yTnVtYmVyLCBleHRyYU9iamVjdCkgewpkaWZmIC0tZ2l0IGEvSlNUZXN0 cy93YXNtL0xvd0xldmVsQmluYXJ5LmpzIGIvSlNUZXN0cy93YXNtL0xvd0xldmVsQmluYXJ5Lmpz CmluZGV4IDYxMWEyNmQuLmY5YmM4YTMgMTAwNjQ0Ci0tLSBhL0pTVGVzdHMvd2FzbS9Mb3dMZXZl bEJpbmFyeS5qcworKysgYi9KU1Rlc3RzL3dhc20vTG93TGV2ZWxCaW5hcnkuanMKQEAgLTE3MCw2 ICsxNzAsMTggQEAgZXhwb3J0IGRlZmF1bHQgY2xhc3MgTG93TGV2ZWxCaW5hcnkgewogICAgICAg ICAgICAgdGhpcy51aW50OCgweDgwIHwgYik7CiAgICAgICAgIH0gd2hpbGUgKHRydWUpOwogICAg IH0KKyAgICB2YXJ1aW50NjQodikgeworICAgICAgICBhc3NlcnQuaXNOdW1iZXIodik7CisgICAg ICAgIGlmICh2IDwgdmFydWludDMyTWluIHx8IHZhcnVpbnQzMk1heCA8IHYpCisgICAgICAgICAg ICB0aHJvdyBuZXcgUmFuZ2VFcnJvcihgdW5pbXBsZW1lbnRlZDogdmFydWludDY0IGxhcmdlciB0 aGFuIDMyLWJpdGApOworICAgICAgICB0aGlzLnZhcnVpbnQzMih2KTsgLy8gRklYTUUgaW1wbGVt ZW50IDY0LWJpdCB2YXJ7dX1pbnQgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTE2MzQyMAorICAgIH0KKyAgICB2YXJpbnQ2NCh2KSB7CisgICAgICAgIGFzc2VydC5pc051 bWJlcih2KTsKKyAgICAgICAgaWYgKHYgPCB2YXJpbnQzMk1pbiB8fCB2YXJpbnQzMk1heCA8IHYp CisgICAgICAgICAgICB0aHJvdyBuZXcgUmFuZ2VFcnJvcihgdW5pbXBsZW1lbnRlZDogdmFyaW50 NjQgbGFyZ2VyIHRoYW4gMzItYml0YCk7CisgICAgICAgIHRoaXMudmFyaW50MzIodik7IC8vIEZJ WE1FIGltcGxlbWVudCA2NC1iaXQgdmFye3V9aW50IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xNjM0MjAKKyAgICB9CiAgICAgdmFydWludDEodikgewogICAgICAgICBp ZiAodiAhPT0gMCAmJiB2ICE9PSAxKQogICAgICAgICAgICAgdGhyb3cgbmV3IFJhbmdlRXJyb3Io YEludmFsaWQgdmFydWludDEgJHt2fSByYW5nZSBpcyBbMCwgMV1gKTsKZGlmZiAtLWdpdCBhL0pT VGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy9leGNlcHRpb25zLmpzIGIvSlNUZXN0cy93YXNtL2Z1 bmN0aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMKaW5kZXggZDJiM2E0OS4uOTUyNTEzZiAxMDA2NDQK LS0tIGEvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMKKysrIGIvSlNU ZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMKQEAgLTQ1LDE4ICs0NSwxOCBA QCBmdW5jdGlvbiBtYWtlSW5zdGFuY2UoKSB7CiAgICAgYXNzZXJ0LmVxKHRhYmxlLmdldCgwKSwg bnVsbCk7CiAKICAgICBmb3IgKGxldCBpID0gMDsgaSA8IDEwMDA7IGkrKykgewotICAgICAgICBh c3NlcnQudGhyb3dzKCgpID0+IGZvbygwLCBpKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9yLCAi Y2FsbF9pbmRpcmVjdCB0byBhIG51bGwgdGFibGUgZW50cnkgKGV2YWx1YXRpbmcgJ2Z1bmMoLi4u YXJncyknKSIpOworICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbygwLCBpKSwgV2ViQXNz ZW1ibHkuUnVudGltZUVycm9yLCAiY2FsbF9pbmRpcmVjdCB0byBhIG51bGwgdGFibGUgZW50cnki KTsKICAgICB9CiAKICAgICB0YWJsZS5zZXQoMCwgZm9vKTsKICAgICBhc3NlcnQuZXEodGFibGUu Z2V0KDApLCBmb28pOwogCiAgICAgZm9yIChsZXQgaSA9IDA7IGkgPCAxMDAwOyBpKyspIHsKLSAg ICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBmb28oMSArIGksIGkpLCBXZWJBc3NlbWJseS5SdW50 aW1lRXJyb3IsICJPdXQgb2YgYm91bmRzIGNhbGxfaW5kaXJlY3QgKGV2YWx1YXRpbmcgJ2Z1bmMo Li4uYXJncyknKSIpOworICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbygxICsgaSwgaSks IFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgIk91dCBvZiBib3VuZHMgY2FsbF9pbmRpcmVjdCIp OwogICAgIH0KIAogICAgIGZvciAobGV0IGkgPSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0gICAgICAg IGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDAsIGkpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3Is ICJjYWxsX2luZGlyZWN0IHRvIGEgc2lnbmF0dXJlIHRoYXQgZG9lcyBub3QgbWF0Y2ggKGV2YWx1 YXRpbmcgJ2Z1bmMoLi4uYXJncyknKSIpOworICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IGZv bygwLCBpKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9yLCAiY2FsbF9pbmRpcmVjdCB0byBhIHNp Z25hdHVyZSB0aGF0IGRvZXMgbm90IG1hdGNoIik7CiAgICAgfQogCiAgICAgdGFibGUuc2V0KDAs IGJhcik7CmRpZmYgLS1naXQgYS9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2Fk LmpzIGIvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtbG9hZC5qcwppbmRleCA0ZGQ4 MmRjLi4xMjMxZTAzIDEwMDY0NAotLS0gYS9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJh cC1sb2FkLmpzCisrKyBiL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMK QEAgLTI5LDYgKzI5LDYgQEAgZnVuY3Rpb24gd2FzbUZyYW1lQ291bnRGcm9tRXJyb3IoZSkgewog fQogCiBmb3IgKGxldCBpID0gMDsgaSA8IDEwMDA7IGkrKykgewotICAgIGNvbnN0IGUgPSBhc3Nl cnQudGhyb3dzKCgpID0+IGZvbyhudW1QYWdlcyAqIHBhZ2VTaXplICsgMSksIFdlYkFzc2VtYmx5 LlJ1bnRpbWVFcnJvciwgIk91dCBvZiBib3VuZHMgbWVtb3J5IGFjY2VzcyAoZXZhbHVhdGluZyAn ZnVuYyguLi5hcmdzKScpIik7CisgICAgY29uc3QgZSA9IGFzc2VydC50aHJvd3MoKCkgPT4gZm9v KG51bVBhZ2VzICogcGFnZVNpemUgKyAxKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9yLCAiT3V0 IG9mIGJvdW5kcyBtZW1vcnkgYWNjZXNzIik7CiAgICAgYXNzZXJ0LmVxKHdhc21GcmFtZUNvdW50 RnJvbUVycm9yKGUpLCAyKTsKIH0KZGlmZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10 ZXN0cy90cmFwLXN0b3JlLmpzIGIvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtc3Rv cmUuanMKaW5kZXggNTU5ODdjMi4uMzY1NzEzYSAxMDA2NDQKLS0tIGEvSlNUZXN0cy93YXNtL2Z1 bmN0aW9uLXRlc3RzL3RyYXAtc3RvcmUuanMKKysrIGIvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRl c3RzL3RyYXAtc3RvcmUuanMKQEAgLTI1LDUgKzI1LDUgQEAgY29uc3QgbnVtUGFnZXMgPSAxMDsK ICAgICBjb25zdCBmb28gPSBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UobW9kdWxlLCB7YToge2I6 IG5ldyBXZWJBc3NlbWJseS5NZW1vcnkoe2luaXRpYWw6IG51bVBhZ2VzfSl9fSkuZXhwb3J0cy5m b287CiAKICAgICBmb3IgKGxldCBpID0gMDsgaSA8IDEwMDAwOyBpKyspCi0gICAgICAgIGFzc2Vy dC50aHJvd3MoKCkgPT4gZm9vKGksIG51bVBhZ2VzICogcGFnZVNpemUgKyAxKSwgV2ViQXNzZW1i bHkuUnVudGltZUVycm9yLCAiT3V0IG9mIGJvdW5kcyBtZW1vcnkgYWNjZXNzIChldmFsdWF0aW5n ICdmdW5jKC4uLmFyZ3MpJykiKTsKKyAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBmb28oaSwg bnVtUGFnZXMgKiBwYWdlU2l6ZSArIDEpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJPdXQg b2YgYm91bmRzIG1lbW9yeSBhY2Nlc3MiKTsKIH0KZGlmZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9q cy1hcGkvd2FzbS10by13YXNtLWJhZC1zaWduYXR1cmUuanMgYi9KU1Rlc3RzL3dhc20vanMtYXBp L3dhc20tdG8td2FzbS1iYWQtc2lnbmF0dXJlLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAuLmQ2OWJhMmMKLS0tIC9kZXYvbnVsbAorKysgYi9KU1Rlc3RzL3dhc20vanMtYXBp L3dhc20tdG8td2FzbS1iYWQtc2lnbmF0dXJlLmpzCkBAIC0wLDAgKzEsMTA1IEBACitpbXBvcnQg KiBhcyBhc3NlcnQgZnJvbSAnLi4vYXNzZXJ0LmpzJzsKK2ltcG9ydCBCdWlsZGVyIGZyb20gJy4u L0J1aWxkZXIuanMnOworCitjb25zdCBpbXBvcnROYW1lID0gInBpZXJPbmUiOworY29uc3QgdHlw ZXMgPSBbImkzMiIsICJpNjQiLCAiZjMyIiwgImY2NCIsICJ2b2lkIl07Citjb25zdCB0eXBlc05v blZvaWQgPSBbImkzMiIsICJpNjQiLCAiZjMyIiwgImY2NCJdOworY29uc3Qgc3dhcFR5cGUgPSAo dHlwZSwgaW5kZXgpID0+IHR5cGVzWyh0eXBlcy5pbmRleE9mKHR5cGUpICsgaW5kZXgpICUgdHlw ZXMubGVuZ3RoXTsKK2NvbnN0IHN3YXBUeXBlTm9uVm9pZCA9ICh0eXBlLCBpbmRleCkgPT4gdHlw ZXNOb25Wb2lkWyh0eXBlc05vblZvaWQuaW5kZXhPZih0eXBlKSArIGluZGV4KSAlIHR5cGVzTm9u Vm9pZC5sZW5ndGhdOworCitjb25zdCBzaWduYXR1cmVzID0gWworICAgIHsgcGFyYW1zOiBbImkz MiJdLCByZXQ6ICJ2b2lkIiB9LAorICAgIHsgcGFyYW1zOiBbImk2NCJdLCByZXQ6ICJ2b2lkIiB9 LAorICAgIHsgcGFyYW1zOiBbImYzMiJdLCByZXQ6ICJ2b2lkIiB9LAorICAgIHsgcGFyYW1zOiBb ImY2NCJdLCByZXQ6ICJ2b2lkIiB9LAorICAgIHsgcGFyYW1zOiBbImkzMiJdLCByZXQ6ICJpMzIi IH0sCisgICAgeyBwYXJhbXM6IFsiaTY0Il0sIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczog WyJmMzIiXSwgcmV0OiAiZjMyIiB9LAorICAgIHsgcGFyYW1zOiBbImY2NCJdLCByZXQ6ICJmNjQi IH0sCisgICAgeyBwYXJhbXM6IFsiaTMyIiwgImYzMiJdLCByZXQ6ICJpMzIiIH0sCisgICAgeyBw YXJhbXM6IFsiZjMyIiwgImkzMiJdLCByZXQ6ICJpMzIiIH0sCisgICAgeyBwYXJhbXM6IFsiaTY0 IiwgImY2NCJdLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IFsiZjY0IiwgImk2NCJdLCBy ZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IFsiaTMyIiwgImYzMiIsICJpMzIiXSwgcmV0OiAi aTMyIiB9LAorICAgIHsgcGFyYW1zOiBbImkzMiIsICJmMzIiLCAiaTMyIl0sIHJldDogImkzMiIg fSwKKyAgICB7IHBhcmFtczogWyJpNjQiLCAiZjY0IiwgImk2NCJdLCByZXQ6ICJpNjQiIH0sCisg ICAgeyBwYXJhbXM6IFsiaTY0IiwgImY2NCIsICJpNjQiXSwgcmV0OiAiaTY0IiB9LAorICAgIHsg cGFyYW1zOiBBcnJheSgzMikuZmlsbCgiaTMyIiksIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFt czogQXJyYXkoMzIpLmZpbGwoImk2NCIpLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IEFy cmF5KDMyKS5maWxsKCJmMzIiKSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBBcnJheSgz MikuZmlsbCgiZjY0IiksIHJldDogImk2NCIgfSwKK107CisKK2NvbnN0IG1ha2VJbXBvcnRlciA9 IHNpZ25hdHVyZSA9PiB7CisgICAgY29uc3QgYnVpbGRlciA9IChuZXcgQnVpbGRlcigpKQorICAg ICAgICAuVHlwZSgpLkVuZCgpCisgICAgICAgIC5JbXBvcnQoKS5GdW5jdGlvbigiZXhwb3J0cyIs IGltcG9ydE5hbWUsIHNpZ25hdHVyZSkuRW5kKCk7CisgICAgcmV0dXJuIG5ldyBXZWJBc3NlbWJs eS5Nb2R1bGUoYnVpbGRlci5XZWJBc3NlbWJseSgpLmdldCgpKTsKK307CisKK2NvbnN0IG1ha2VJ bXBvcnRlZSA9IHNpZ25hdHVyZSA9PiB7CisgICAgY29uc3QgYnVpbGRlciA9IChuZXcgQnVpbGRl cigpKQorICAgICAgICAuVHlwZSgpLkVuZCgpCisgICAgICAgIC5GdW5jdGlvbigpLkVuZCgpCisg ICAgICAgIC5FeHBvcnQoKQorICAgICAgICAgICAgLkZ1bmN0aW9uKGltcG9ydE5hbWUpCisgICAg ICAgIC5FbmQoKQorICAgICAgICAuQ29kZSgpCisgICAgICAgICAgICAuRnVuY3Rpb24oaW1wb3J0 TmFtZSwgc2lnbmF0dXJlKTsKKyAgICBzd2l0Y2ggKHNpZ25hdHVyZS5yZXQpIHsKKyAgICBjYXNl ICJpMzIiOiBidWlsZGVyLkkzMkNvbnN0KDApOyBicmVhazsKKyAgICBjYXNlICJpNjQiOiBidWls ZGVyLkk2NENvbnN0KDApOyBicmVhazsKKyAgICBjYXNlICJmMzIiOiBidWlsZGVyLkYzMkNvbnN0 KDApOyBicmVhazsKKyAgICBjYXNlICJmNjQiOiBidWlsZGVyLkY2NENvbnN0KDApOyBicmVhazsK KyAgICBjYXNlICJ2b2lkIjogYnJlYWs7CisgICAgfQorICAgIHJldHVybiBuZXcgV2ViQXNzZW1i bHkuSW5zdGFuY2UobmV3IFdlYkFzc2VtYmx5Lk1vZHVsZShidWlsZGVyLlJldHVybigpLkVuZCgp LkVuZCgpLldlYkFzc2VtYmx5KCkuZ2V0KCkpKTsKK307CisKKyhmdW5jdGlvbiBCYWRTaWduYXR1 cmVEcm9wU3RhcnRQYXJhbXMoKSB7CisgICAgZm9yIChsZXQgc2lnbmF0dXJlIG9mIHNpZ25hdHVy ZXMpIHsKKyAgICAgICAgY29uc3QgaW1wb3J0ZWUgPSBtYWtlSW1wb3J0ZWUoc2lnbmF0dXJlKTsK KyAgICAgICAgZm9yIChsZXQgaSA9IDE7IGkgPD0gc2lnbmF0dXJlLnBhcmFtcy5sZW5ndGg7ICsr aSkgeworICAgICAgICAgICAgY29uc3QgYmFkUGFyYW1TaWduYXR1cmUgPSB7IHBhcmFtczogc2ln bmF0dXJlLnBhcmFtcy5zbGljZShpLCBzaWduYXR1cmUucGFyYW1zLmxlbmd0aCksIHJldDogc2ln bmF0dXJlLnJldCB9OworICAgICAgICAgICAgY29uc3QgaW1wb3J0ZXIgPSBtYWtlSW1wb3J0ZXIo YmFkUGFyYW1TaWduYXR1cmUpOworICAgICAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBuZXcg V2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKSwgV2ViQXNzZW1ibHkuTGlu a0Vycm9yLCBgaW1wb3J0ZWQgZnVuY3Rpb24ncyBzaWduYXR1cmUgZG9lc24ndCBtYXRjaCB0aGUg cHJvdmlkZWQgV2ViQXNzZW1ibHkgZnVuY3Rpb24ncyBzaWduYXR1cmUgKGV2YWx1YXRpbmcgJ25l dyBXZWJBc3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpJylgKTsKKyAgICAgICAg fQorICAgIH0KK30pKCk7CisKKyhmdW5jdGlvbiBCYWRTaWduYXR1cmVEcm9wRW5kUGFyYW1zKCkg eworICAgIGZvciAobGV0IHNpZ25hdHVyZSBvZiBzaWduYXR1cmVzKSB7CisgICAgICAgIGNvbnN0 IGltcG9ydGVlID0gbWFrZUltcG9ydGVlKHNpZ25hdHVyZSk7CisgICAgICAgIGZvciAobGV0IGkg PSAxOyBpIDwgc2lnbmF0dXJlLnBhcmFtcy5sZW5ndGg7ICsraSkgeworICAgICAgICAgICAgY29u c3QgYmFkUGFyYW1TaWduYXR1cmUgPSB7IHBhcmFtczogc2lnbmF0dXJlLnBhcmFtcy5zbGljZSgw LCBpKSwgcmV0OiBzaWduYXR1cmUucmV0IH07CisgICAgICAgICAgICBjb25zdCBpbXBvcnRlciA9 IG1ha2VJbXBvcnRlcihiYWRQYXJhbVNpZ25hdHVyZSk7CisgICAgICAgICAgICBhc3NlcnQudGhy b3dzKCgpID0+IG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpLCBX ZWJBc3NlbWJseS5MaW5rRXJyb3IsIGBpbXBvcnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBkb2Vz bid0IG1hdGNoIHRoZSBwcm92aWRlZCBXZWJBc3NlbWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSAo ZXZhbHVhdGluZyAnbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSkn KWApOworICAgICAgICB9CisgICAgfQorfSkoKTsKKworKGZ1bmN0aW9uIEJhZFNpZ25hdHVyZVN3 YXBQYXJhbSgpIHsKKyAgICBmb3IgKGxldCBzaWduYXR1cmUgb2Ygc2lnbmF0dXJlcykgeworICAg ICAgICBjb25zdCBpbXBvcnRlZSA9IG1ha2VJbXBvcnRlZShzaWduYXR1cmUpOworICAgICAgICBm b3IgKGxldCBzaWduYXR1cmVJbmRleCA9IDA7IHNpZ25hdHVyZUluZGV4IDwgc2lnbmF0dXJlLmxl bmd0aDsgKytzaWduYXR1cmVJbmRleCkgeworICAgICAgICAgICAgZm9yIChsZXQgdHlwZUluZGV4 ID0gMTsgdHlwZUluZGV4IDwgdHlwZXNOb25Wb2lkLmxlbmd0aDsgKyt0eXBlSW5kZXgpIHsKKyAg ICAgICAgICAgICAgICBsZXQgYmFkUGFyYW1zID0gc2lnbmF0dXJlLnBhcmFtcy5zbGljZSgpOwor ICAgICAgICAgICAgICAgIGJhZFBhcmFtc1tzaWduYXR1cmVJbmRleF0gPSBzd2FwVHlwZU5vblZv aWQoYmFkUGFyYW1zW3NpZ25hdHVyZUluZGV4XSwgdHlwZUluZGV4KTsKKyAgICAgICAgICAgICAg ICBjb25zdCBiYWRQYXJhbVNpZ25hdHVyZSA9IHsgcGFyYW1zOiBiYWRQYXJhbXMsIHJldDogc2ln bmF0dXJlLnJldCB9OworICAgICAgICAgICAgICAgIGNvbnN0IGltcG9ydGVyID0gbWFrZUltcG9y dGVyKGJhZFBhcmFtU2lnbmF0dXJlKTsKKyAgICAgICAgICAgICAgICBhc3NlcnQudGhyb3dzKCgp ID0+IG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpLCBXZWJBc3Nl bWJseS5MaW5rRXJyb3IsIGBpbXBvcnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBkb2Vzbid0IG1h dGNoIHRoZSBwcm92aWRlZCBXZWJBc3NlbWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSAoZXZhbHVh dGluZyAnbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSknKWApOwor ICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorfSkoKTsKKworKGZ1bmN0aW9uIEJhZFNp Z25hdHVyZVJldCgpIHsKKyAgICBmb3IgKGxldCBzaWduYXR1cmUgb2Ygc2lnbmF0dXJlcykgewor ICAgICAgICBjb25zdCBpbXBvcnRlZSA9IG1ha2VJbXBvcnRlZShzaWduYXR1cmUpOworICAgICAg ICBmb3IgKGxldCB0eXBlSW5kZXggPSAxOyB0eXBlSW5kZXggPCB0eXBlcy5sZW5ndGg7ICsrdHlw ZUluZGV4KSB7CisgICAgICAgICAgICBjb25zdCBiYWRQYXJhbVNpZ25hdHVyZSA9IHsgcGFyYW1z OiBzaWduYXR1cmUucGFyYW1zLCByZXQ6IHN3YXBUeXBlKHNpZ25hdHVyZS5yZXQsIHR5cGVJbmRl eCkgfTsKKyAgICAgICAgICAgIGNvbnN0IGltcG9ydGVyID0gbWFrZUltcG9ydGVyKGJhZFBhcmFt U2lnbmF0dXJlKTsKKyAgICAgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gbmV3IFdlYkFzc2Vt Ymx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSksIFdlYkFzc2VtYmx5LkxpbmtFcnJvciwg YGltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIGRvZXNuJ3QgbWF0Y2ggdGhlIHByb3ZpZGVk IFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIChldmFsdWF0aW5nICduZXcgV2ViQXNz ZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKScpYCk7CisgICAgICAgIH0KKyAgICB9 Cit9KSgpOwpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMg Yi9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi4yZGY0NmU2Ci0tLSAvZGV2L251bGwKKysrIGIvSlNUZXN0cy93YXNt L2pzLWFwaS93YXNtLXRvLXdhc20uanMKQEAgLTAsMCArMSw3MiBAQAoraW1wb3J0ICogYXMgYXNz ZXJ0IGZyb20gJy4uL2Fzc2VydC5qcyc7CitpbXBvcnQgQnVpbGRlciBmcm9tICcuLi9CdWlsZGVy LmpzJzsKKworY29uc3QgY2FsbGVyVG9wQml0cyA9IDB4QzBGRUJFRUY7Citjb25zdCBpbm5lclJl dHVybkhpID0gMHhERUFERkFDRTsKK2NvbnN0IGlubmVyUmV0dXJuTG8gPSAweEMwRkVDMEZFOwor Citjb25zdCBjYWxsZXJNb2R1bGUgPSAoKSA9PiB7CisgICAgY29uc3QgYnVpbGRlciA9IChuZXcg QnVpbGRlcigpKQorICAgICAgICAuVHlwZSgpLkVuZCgpCisgICAgICAgIC5JbXBvcnQoKQorICAg ICAgICAgICAgLkZ1bmN0aW9uKCJleHBvcnRzIiwgImNhbGxNZSIsIHsgcGFyYW1zOiBbImk2NCJd LCByZXQ6ICJpNjQiIH0pCisgICAgICAgIC5FbmQoKQorICAgICAgICAuRnVuY3Rpb24oKS5FbmQo KQorICAgICAgICAuRXhwb3J0KCkKKyAgICAgICAgICAgIC5GdW5jdGlvbigiZW50cnkiKQorICAg ICAgICAuRW5kKCkKKyAgICAgICAgLkNvZGUoKQorICAgICAgICAgICAgLkZ1bmN0aW9uKCJlbnRy eSIsIHsgcGFyYW1zOiBbImkzMiJdLCByZXQ6ICJpMzIiIH0sIFsiaTY0Il0pCisgICAgICAgICAg ICAgICAgLkkzMkNvbnN0KGNhbGxlclRvcEJpdHMpLkk2NEV4dGVuZFVJMzIoKS5JMzJDb25zdCgz MikuSTY0RXh0ZW5kVUkzMigpLkk2NFNobCgpIC8vICgoaTY0KWNhbGxlclRvcEJpdHMpIDw8IDMy CisgICAgICAgICAgICAgICAgLkdldExvY2FsKDApLkk2NEV4dGVuZFVJMzIoKQorICAgICAgICAg ICAgICAgIC5JNjRPcigpIC8vIHZhbHVlOiBwYXJhbSB8ICgoKGk2NCljYWxsZXJUb3BCaXRzIDw8 IDMyKSkKKyAgICAgICAgICAgICAgICAuQ2FsbCgwKSAvLyBDYWxscyBleHBvcnRzLmNhbGxNZShw YXJhbSB8ICgoKGk2NCljYWxsZXJUb3BCaXRzKSA8PCAzMikpLgorICAgICAgICAgICAgICAgIC5U ZWVMb2NhbCgxKS5JMzJXcmFwSTY0KCkgLy8gbG86IChpMzIpY2FsbFJlc3VsdAorICAgICAgICAg ICAgICAgIC5HZXRMb2NhbCgxKS5JMzJDb25zdCgzMikuSTY0RXh0ZW5kVUkzMigpLkk2NFNoclUo KS5JMzJXcmFwSTY0KCkgLy8gaGk6IChpMzIpKGNhbGxSZXN1bHQgPj4gMzIpCisgICAgICAgICAg ICAgICAgLkkzMlhvcigpCisgICAgICAgICAgICAgICAgLlJldHVybigpCisgICAgICAgICAgICAu RW5kKCkKKyAgICAgICAgLkVuZCgpOworICAgIHJldHVybiBuZXcgV2ViQXNzZW1ibHkuTW9kdWxl KGJ1aWxkZXIuV2ViQXNzZW1ibHkoKS5nZXQoKSk7Cit9OworCitjb25zdCBjYWxsZWVNb2R1bGUg PSAoKSA9PiB7CisgICAgY29uc3QgYnVpbGRlciA9IChuZXcgQnVpbGRlcigpKQorICAgICAgICAu VHlwZSgpLkVuZCgpCisgICAgICAgIC5JbXBvcnQoKQorICAgICAgICAgICAgLkZ1bmN0aW9uKCJp bXAiLCAiZnVuYyIsIHsgcGFyYW1zOiBbImkzMiIsICJpMzIiXSwgcmV0OiAiaTMyIiB9KQorICAg ICAgICAuRW5kKCkKKyAgICAgICAgLkZ1bmN0aW9uKCkuRW5kKCkKKyAgICAgICAgLkV4cG9ydCgp CisgICAgICAgICAgICAuRnVuY3Rpb24oImNhbGxNZSIpCisgICAgICAgIC5FbmQoKQorICAgICAg ICAuQ29kZSgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImNhbGxNZSIsIHsgcGFyYW1zOiBbImk2 NCJdLCByZXQ6ICJpNjQiIH0pCisgICAgICAgICAgICAgICAgLkdldExvY2FsKDApLkkzMldyYXBJ NjQoKSAvLyBsbzogKGkzMilwYXJhbQorICAgICAgICAgICAgICAgIC5HZXRMb2NhbCgwKS5JMzJD b25zdCgzMikuSTY0RXh0ZW5kVUkzMigpLkk2NFNoclUoKS5JMzJXcmFwSTY0KCkgLy8gaGk6IChp MzIpKHBhcmFtID4+IDMyKQorICAgICAgICAgICAgICAgIC5DYWxsKDApIC8vIENhbGxzIGltcC5m dW5jIHdpdGggdGhlIDY0LWJpdCB2YWx1ZSBhcyBpMzIgeyBoaSwgbG8gfS4KKyAgICAgICAgICAg ICAgICAuRHJvcCgpCisgICAgICAgICAgICAgICAgLkkzMkNvbnN0KGlubmVyUmV0dXJuSGkpLkk2 NEV4dGVuZFVJMzIoKS5JMzJDb25zdCgzMikuSTY0RXh0ZW5kVUkzMigpLkk2NFNobCgpLkkzMkNv bnN0KGlubmVyUmV0dXJuTG8pLkk2NEV4dGVuZFVJMzIoKS5JNjRPcigpIC8vICgoaTY0KWhpIDw8 IDMyKSB8IChpNjQpbG8KKyAgICAgICAgICAgICAgICAuUmV0dXJuKCkKKyAgICAgICAgICAgIC5F bmQoKQorICAgICAgICAuRW5kKCk7CisgICAgcmV0dXJuIG5ldyBXZWJBc3NlbWJseS5Nb2R1bGUo YnVpbGRlci5XZWJBc3NlbWJseSgpLmdldCgpKTsKK307CisKKyhmdW5jdGlvbiBXYXNtVG9XYXNt KCkgeworICAgIGxldCB2YWx1ZTsKKyAgICBjb25zdCBmdW5jID0gKGhpLCBsbykgPT4geyB2YWx1 ZSA9IHsgaGk6IGhpLCBsbzogbG8gfTsgcmV0dXJuIGhpIF4gbG87IH07CisgICAgY29uc3QgY2Fs bGVlID0gbmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGNhbGxlZU1vZHVsZSgpLCB7IGltcDogeyBm dW5jOiBmdW5jIH0gfSk7CisgICAgY29uc3QgY2FsbGVyID0gbmV3IFdlYkFzc2VtYmx5Lkluc3Rh bmNlKGNhbGxlck1vZHVsZSgpLCBjYWxsZWUpOworICAgIGZvciAobGV0IGkgPSAwOyBpIDwgNDA5 NjsgKytpKSB7CisgICAgICAgIGFzc2VydC5lcShjYWxsZXIuZXhwb3J0cy5lbnRyeShpKSwgaW5u ZXJSZXR1cm5IaSBeIGlubmVyUmV0dXJuTG8pOworICAgICAgICBhc3NlcnQuZXEodmFsdWUubG8g Pj4+IDAsIGNhbGxlclRvcEJpdHMpOworICAgICAgICBhc3NlcnQuZXEodmFsdWUuaGkgPj4+IDAs IGkpOworICAgIH0KK30pKCk7CisKKy8vIEZJWE1FIHRlc3QgdGhlIGZvbGxvd2luZyBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY2NjI1CisvLyAtIHdhc20tPndhc20g dXNpbmcgMzItYml0IHRoaW5ncyAoaW5jbHVkaW5nIGZsb2F0KSwgYXMgd2VsbCBhcyA2NC1iaXQg TmFOcyB0aGF0IGRvbid0IGdldCBjYW5vbmljYWxpemVkCisvLyAtIERvIGEgdGhyb3cgdHdvLWRl ZXAKKy8vIC0gQ2hlY2sgdGhhdCB0aGUgZmlyc3Qgd2FzbSdzIGluc3RhbmNlIGlzIGJhY2sgaW4g T0sgc3RhdGUgKHdpdGggdGFibGUgb3IgZ2xvYmFsPykKKy8vIC0gVGVzdCBjYWxsaW5nIHRocm91 Z2ggYSBUYWJsZQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NNYWtlTGlzdHMu dHh0IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NNYWtlTGlzdHMudHh0CmluZGV4IDk2OWExMjMu LjlkZTFhM2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DTWFrZUxpc3RzLnR4 dAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ01ha2VMaXN0cy50eHQKQEAgLTkwNSw2ICs5 MDUsNyBAQCBzZXQoSmF2YVNjcmlwdENvcmVfU09VUkNFUwogICAgIHdhc20vV2FzbU1lbW9yeS5j cHAKICAgICB3YXNtL1dhc21NZW1vcnlJbmZvcm1hdGlvbi5jcHAKICAgICB3YXNtL1dhc21Nb2R1 bGVQYXJzZXIuY3BwCisgICAgd2FzbS9XYXNtUGFnZUNvdW50LmNwcAogICAgIHdhc20vV2FzbVBs YW4uY3BwCiAgICAgd2FzbS9XYXNtU2lnbmF0dXJlLmNwcAogICAgIHdhc20vV2FzbVZhbGlkYXRl LmNwcApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZyBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKaW5kZXggMzY0MWRhMi4uMGYyOGE0NiAxMDA2NDQK LS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMzIEBACisyMDE2LTEyLTMwICBKRiBCYXN0 aWVuICA8amZiYXN0aWVuQGFwcGxlLmNvbT4KKworICAgICAgICBXZWJBc3NlbWJseTogaGFuZGxl IGFuZCBvcHRpbWl6ZSB3YXNtIGV4cG9ydCDihpIgd2FzbSBpbXBvcnQgY2FsbHMKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NTI4MgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICAgLSBBZGQgYSBuZXcgSlNU eXBlIGZvciBXZWJBc3NlbWJseUZ1bmN0aW9uLCBhbmQgdXNlIGl0IHdoZW4gY3JlYXRpbmcgaXRz CisgICAgICAgICAgICBzdHJ1Y3R1cmUuIFRoaXMgd2lsbCBpcyB1c2VkIHRvIHF1aWNrbHkgZGV0 ZWN0IGZyb20gd2FzbSB3aGV0aGVyIHRoZSBpbXBvcnQKKyAgICAgICAgICAgIGNhbGwgaXMgdG8g YW5vdGhlciB3YXNtIG1vZHVsZSwgb3Igd2hldGhlciBpdCdzIHRvIEpTLgorICAgICAgICAgIC0g R2VuZXJhdGUgdHdvIHN0dWJzIGZyb20gdGhlIGltcG9ydCBzdHViIGdlbmVyYXRvcjogb25lIGZv ciB3YXNtLT5KUyBhbmQgb25lCisgICAgICAgICAgICBmb3Igd2FzbSAtPiB3YXNtLiBUaGlzIGlz IGRvbmUgYXQgTW9kdWxlIHRpbWUuIFdoaWNoIGlzIGNhbGxlZCB3aWxsIG9ubHkgYmUKKyAgICAg ICAgICAgIGtub3duIGF0IEluc3RhbmNlIHRpbWUsIG9uY2Ugd2UndmUgcmVjZWl2ZWQgdGhlIGlt cG9ydCBvYmplY3QuIFdlIHdhbnQgdG8KKyAgICAgICAgICAgIGF2b2lkIGNvZGVnZW4gYXQgSW5z dGFuY2UgdGltZSwgc28gaGF2aW5nIGJvdGggYXJvdW5kIGlzIGdyZWF0LgorICAgICAgICAgIC0g UmVzdG9yZSB0aGUgV2ViQXNzZW1ibHkgZ2xvYmFsIHN0YXRlIChWTSB0b3AgSW5zdGFuY2UsIGFu ZCBwaW5uZWQgcmVnaXN0ZXJzKQorICAgICAgICAgICAgYWZ0ZXIgY2FsbCAvIGNhbGxfaW5kaXJl Y3QsIGFuZCBpbiB0aGUgSlMtPndhc20gZW50cnkgc3R1Yi4KKyAgICAgICAgICAtIFBpbm5lZCBy ZWdpc3RlcnMgYXJlIG5vdyBhIGdsb2JhbCB0aGluZywgbm90IHBlci1NZW1vcnksIGJlY2F1c2Ug dGhlIHdhc20gLT4KKyAgICAgICAgICAgIHdhc20gc3R1YnMgYXJlIGdlbmVyYXRlZCBhdCBNb2R1 bGUgdGltZSB3aGVyZSB3ZSBkb24ndCByZWFsbHkgaGF2ZSBlbm91Z2gKKyAgICAgICAgICAgIGlu Zm9ybWF0aW9uIHRvIGRvIHRoZSByaWdodCB0aGluZyAoZG9pbmcgc28gd291bGQgZ2VuZXJhdGUg dG9vIG11Y2ggY29kZSkuCisKKyAgICAgICAgKiBDTWFrZUxpc3RzLnR4dDoKKyAgICAgICAgKiBK YXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAqIGpzYy5j cHA6IHNpZ25pZmljYW50IHVwZGF0ZSB0byBmdW5jdGlvblRlc3RXYXNtTW9kdWxlRnVuY3Rpb25z CisgICAgICAgIHNvIGl0IGJ1aWxkcyB3YXNtIG9iamVjdHMgYXMgSlMgd291bGQuIFRoaXMgcmVx dWlyZXMgYSBmZXcgbW9yZQorICAgICAgICBFWFBPUlRzIHRoYW4gd2UgaGFkIGJlZm9yZSBpbiBz b21lIHdhc20gY2xhc3Nlcy4KKyAgICAgICAgKGZ1bmN0aW9uVGVzdFdhc21Nb2R1bGVGdW5jdGlv bnMpOgorICAgICAgICAqIHJ1bnRpbWUvQWJzdHJhY3RNb2R1bGVSZWNvcmQuaDogRVhQT1JUIGZv ciBqc2MuY3BwCisgICAgICAgICogcnVudGltZS9KU1R5cGUuaDogYWRkIFdlYkFzc2VtYmx5RnVu Y3Rpb25UeXBlIGFzIGEgSlNUeXBlCisgICAgICAgICogd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5j cHA6IHNpZ25pZmljYW50bHkgcmV3b3JrIGhvdyBjYWxscyB3aGljaAorICAgICAgICBjb3VsZCBi ZSBleHRlcm5hbCB3b3JrLCBhbmQgaG93IHdlIHNhdmUgLyByZXN0b3JlIGdsb2JhbCBzdGF0ZToK KyAgICAgICAgVk0ncyB0b3AgSW5zdGFuY2UsIGFuZCBwaW5uZWQgcmVnaXN0ZXJzCisgICAgICAg IChKU0M6Oldhc206OkIzSVJHZW5lcmF0b3I6OkIzSVJHZW5lcmF0b3IpOgorICAgICAgICAoSlND OjpXYXNtOjpnZXRNZW1vcnlCYXNlQW5kU2l6ZSk6CisgICAgICAgIChKU0M6Oldhc206OnJlc3Rv cmVXZWJBc3NlbWJseUdsb2JhbFN0YXRlKToKKyAgICAgICAgKEpTQzo6V2FzbTo6Y3JlYXRlSlNU b1dhc21XcmFwcGVyKToKKyAgICAgICAgKEpTQzo6V2FzbTo6cGFyc2VBbmRDb21waWxlKToKKyAg ICAgICAgKiB3YXNtL1dhc21CM0lSR2VuZXJhdG9yLmg6CisgICAgICAgICogd2FzbS9XYXNtQmlu ZGluZy5jcHA6CisgICAgICAgIChKU0M6Oldhc206Om1hdGVyaWFsaXplSW1wb3J0SlNDZWxsKToK KyAgICAgICAgKEpTQzo6V2FzbTo6d2FzbVRvSlMpOgorICAgICAgICAoSlNDOjpXYXNtOjp3YXNt VG9XYXNtKTogdGhlIG1haW4gZ29hbCBvZiB0aGlzIHBhdGNoIHdhcyBhZGRpbmcgdGhpcyBmdW5j dGlvbgorICAgICAgICAoSlNDOjpXYXNtOjpleGl0U3R1YkdlbmVyYXRvcik6CisgICAgICAgICog d2FzbS9XYXNtQmluZGluZy5oOgorICAgICAgICAqIHdhc20vV2FzbUZvcm1hdC5oOiBHZXQgcmlk IG9mIG11Y2ggb2YgdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlOgorICAgICAgICB3ZSBhbHJlYWR5 IGhhdmUgYWxsIG9mIGl0cyBpbmZvcm1hdGlvbiBlbHNld2hlcmUsIGFuZCBhcy1pcyBpdAorICAg ICAgICBwcm92aWRlcyBubyBleHRyYSBlZmZpY2llbmN5LgorICAgICAgICAoSlNDOjpXYXNtOjpN b2R1bGVJbmZvcm1hdGlvbjo6ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSk6CisgICAgICAgIChKU0M6 Oldhc206Ok1vZHVsZUluZm9ybWF0aW9uOjppc0ltcG9ydGVkRnVuY3Rpb25Gcm9tRnVuY3Rpb25J bmRleFNwYWNlKToKKyAgICAgICAgKEpTQzo6V2FzbTo6TW9kdWxlSW5mb3JtYXRpb246OnNpZ25h dHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZSk6CisgICAgICAgICogd2FzbS9XYXNtRnVu Y3Rpb25QYXJzZXIuaDoKKyAgICAgICAgKEpTQzo6V2FzbTo6RnVuY3Rpb25QYXJzZXI8Q29udGV4 dD46OkZ1bmN0aW9uUGFyc2VyKToKKyAgICAgICAgKiB3YXNtL1dhc21NZW1vcnkuY3BwOiBBZGQg c29tZSBsb2dnaW5nLgorICAgICAgICAoSlNDOjpXYXNtOjpNZW1vcnk6OmR1bXApOiB0aGlzIHdh cyBuaWNlIHdoZW4gZGVidWdnaW5nCisgICAgICAgIChKU0M6Oldhc206Ok1lbW9yeTo6bWFrZVN0 cmluZyk6CisgICAgICAgIChKU0M6Oldhc206Ok1lbW9yeTo6TWVtb3J5KToKKyAgICAgICAgKEpT Qzo6V2FzbTo6TWVtb3J5Ojp+TWVtb3J5KToKKyAgICAgICAgKEpTQzo6V2FzbTo6TWVtb3J5Ojpn cm93KToKKyAgICAgICAgKiB3YXNtL1dhc21NZW1vcnkuaDogZG9uJ3QgdXNlIGV4dHJhIGluZGly ZWN0aW9uLCBpdCB3YXNuJ3QKKyAgICAgICAgbmVlZGVkLiBSZW9yZGVyIHNvbWUgb2YgdGhlIGZp ZWxkcyB3aGljaCBhcmUgbG9va2VkIHVwIGF0IHJ1bnRpbWUKKyAgICAgICAgc28gdGhleSdyZSBt b3JlIGNhY2hlLWZyaWVuZGx5LgorICAgICAgICAoSlNDOjpXYXNtOjpNZW1vcnk6Ok1lbW9yeSk6 CisgICAgICAgIChKU0M6Oldhc206Ok1lbW9yeTo6bW9kZSk6CisgICAgICAgIChKU0M6Oldhc206 Ok1lbW9yeTo6b2Zmc2V0T2ZTaXplKToKKyAgICAgICAgKiB3YXNtL1dhc21NZW1vcnlJbmZvcm1h dGlvbi5jcHA6IFBpbm5lZCByZWdpc3RlcnMgYXJlIG5vdyBhCisgICAgICAgIGdsb2JhbCB0aGlu ZyBmb3IgYWxsIG9mIEpTQywgbm90IGEgcGVyLU1lbW9yeSB0aGluZworICAgICAgICBhbnltb3Jl LiB3YXNtLT53YXNtIGNhbGxzIGFyZSBtb3JlIGNvbXBsZXggb3RoZXJ3aXNlOiB0aGV5IGhhdmUg dG8KKyAgICAgICAgZmlndXJlIG91dCBob3cgdG8gYnJpZGdlIGJldHdlZW4gdGhlIGNhbGxlciBh bmQgY2FsbGVlJ3MKKyAgICAgICAgc3BlY2lhbC1zbm93Zmxha2UgcGlubmluZy4KKyAgICAgICAg KEpTQzo6V2FzbTo6UGlubmVkUmVnaXN0ZXJJbmZvOjpnZXQpOgorICAgICAgICAoSlNDOjpXYXNt OjpQaW5uZWRSZWdpc3RlckluZm86OlBpbm5lZFJlZ2lzdGVySW5mbyk6CisgICAgICAgIChKU0M6 Oldhc206Ok1lbW9yeUluZm9ybWF0aW9uOjpNZW1vcnlJbmZvcm1hdGlvbik6CisgICAgICAgICog d2FzbS9XYXNtTWVtb3J5SW5mb3JtYXRpb24uaDoKKyAgICAgICAgKiB3YXNtL1dhc21Nb2R1bGVQ YXJzZXIuY3BwOgorICAgICAgICAqIHdhc20vV2FzbU1vZHVsZVBhcnNlci5oOgorICAgICAgICAq IHdhc20vV2FzbVBhZ2VDb3VudC5jcHA6IENvcGllZCBmcm9tIFNvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL1dhc21CaW5kaW5nLmguCisgICAgICAgIChKU0M6Oldhc206OlBhZ2VDb3VudDo6ZHVt cCk6IG5pY2UgZm9yIGRlYnVnZ2luZworICAgICAgICAqIHdhc20vV2FzbVBhZ2VDb3VudC5oOgor ICAgICAgICAqIHdhc20vV2FzbVBsYW4uY3BwOgorICAgICAgICAoSlNDOjpXYXNtOjpQbGFuOjpw YXJzZUFuZFZhbGlkYXRlTW9kdWxlKToKKyAgICAgICAgKEpTQzo6V2FzbTo6UGxhbjo6cnVuKToK KyAgICAgICAgKiB3YXNtL1dhc21QbGFuLmg6CisgICAgICAgIChKU0M6Oldhc206OlBsYW46OnRh a2VXYXNtRXhpdFN0dWJzKToKKyAgICAgICAgKiB3YXNtL1dhc21TaWduYXR1cmUuY3BwOgorICAg ICAgICAoSlNDOjpXYXNtOjpTaWduYXR1cmU6OnRvU3RyaW5nKToKKyAgICAgICAgKEpTQzo6V2Fz bTo6U2lnbmF0dXJlOjpkdW1wKToKKyAgICAgICAgKiB3YXNtL1dhc21TaWduYXR1cmUuaDoKKyAg ICAgICAgKiB3YXNtL1dhc21WYWxpZGF0ZS5jcHA6CisgICAgICAgIChKU0M6Oldhc206OnZhbGlk YXRlRnVuY3Rpb24pOgorICAgICAgICAqIHdhc20vV2FzbVZhbGlkYXRlLmg6CisgICAgICAgICog d2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaDoKKyAgICAgICAgKEpTQzo6SlNXZWJBc3Nl bWJseUluc3RhbmNlOjpvZmZzZXRPZlRhYmxlKToKKyAgICAgICAgKEpTQzo6SlNXZWJBc3NlbWJs eUluc3RhbmNlOjpvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucyk6CisgICAgICAgIChKU0M6OkpTV2Vi QXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbik6CisgICAgICAgICogd2Fz bS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNwcDoKKyAgICAgICAgKEpTQzo6SlNXZWJBc3NlbWJs eU1lbW9yeTo6Y3JlYXRlKToKKyAgICAgICAgKEpTQzo6SlNXZWJBc3NlbWJseU1lbW9yeTo6SlNX ZWJBc3NlbWJseU1lbW9yeSk6CisgICAgICAgIChKU0M6OkpTV2ViQXNzZW1ibHlNZW1vcnk6OmJ1 ZmZlcik6CisgICAgICAgIChKU0M6OkpTV2ViQXNzZW1ibHlNZW1vcnk6Omdyb3cpOgorICAgICAg ICAqIHdhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5oOgorICAgICAgICAoSlNDOjpKU1dlYkFz c2VtYmx5TWVtb3J5OjptZW1vcnkpOgorICAgICAgICAoSlNDOjpKU1dlYkFzc2VtYmx5TWVtb3J5 OjpvZmZzZXRPZk1lbW9yeSk6CisgICAgICAgIChKU0M6OkpTV2ViQXNzZW1ibHlNZW1vcnk6Om9m ZnNldE9mU2l6ZSk6CisgICAgICAgICogd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmNwcDoK KyAgICAgICAgKEpTQzo6SlNXZWJBc3NlbWJseU1vZHVsZTo6Y3JlYXRlKToKKyAgICAgICAgKEpT Qzo6SlNXZWJBc3NlbWJseU1vZHVsZTo6SlNXZWJBc3NlbWJseU1vZHVsZSk6CisgICAgICAgICog d2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmg6CisgICAgICAgIChKU0M6OkpTV2ViQXNzZW1i bHlNb2R1bGU6OnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZSk6CisgICAgICAg IChKU0M6OkpTV2ViQXNzZW1ibHlNb2R1bGU6OmZ1bmN0aW9uSW1wb3J0Q291bnQpOgorICAgICAg ICAqIHdhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlvbi5jcHA6CisgICAgICAgIChKU0M6OmNhbGxX ZWJBc3NlbWJseUZ1bmN0aW9uKToKKyAgICAgICAgKEpTQzo6V2ViQXNzZW1ibHlGdW5jdGlvbjo6 Y3JlYXRlKToKKyAgICAgICAgKEpTQzo6V2ViQXNzZW1ibHlGdW5jdGlvbjo6Y3JlYXRlU3RydWN0 dXJlKToKKyAgICAgICAgKEpTQzo6V2ViQXNzZW1ibHlGdW5jdGlvbjo6V2ViQXNzZW1ibHlGdW5j dGlvbik6CisgICAgICAgIChKU0M6OldlYkFzc2VtYmx5RnVuY3Rpb246OmZpbmlzaENyZWF0aW9u KToKKyAgICAgICAgKiB3YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uaDoKKyAgICAgICAgKEpT Qzo6V2ViQXNzZW1ibHlGdW5jdGlvbjo6d2FzbUVudHJ5cG9pbnQpOgorICAgICAgICAoSlNDOjpX ZWJBc3NlbWJseUZ1bmN0aW9uOjpvZmZzZXRPZkluc3RhbmNlKToKKyAgICAgICAgKEpTQzo6V2Vi QXNzZW1ibHlGdW5jdGlvbjo6b2Zmc2V0T2ZXYXNtRW50cnlQb2ludENvZGUpOgorICAgICAgICAq IHdhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVjdG9yLmNwcDoKKyAgICAgICAgKEpT Qzo6Y29uc3RydWN0SlNXZWJBc3NlbWJseUluc3RhbmNlKTogYWx3YXlzIHN0YXJ0IHdpdGggYSBk dW1teQorICAgICAgICBtZW1vcnksIHNvIHdhc20tPndhc20gY2FsbHMgZG9uJ3QgbmVlZCB0byBu dWxsLWNoZWNrCisgICAgICAgICogd2FzbS9qcy9XZWJBc3NlbWJseU1lbW9yeUNvbnN0cnVjdG9y LmNwcDoKKyAgICAgICAgKEpTQzo6Y29uc3RydWN0SlNXZWJBc3NlbWJseU1lbW9yeSk6CisgICAg ICAgICogd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNwcDoKKyAgICAgICAg KEpTQzo6V2ViQXNzZW1ibHlNb2R1bGVDb25zdHJ1Y3Rvcjo6Y3JlYXRlTW9kdWxlKToKKyAgICAg ICAgKiB3YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmNwcDoKKyAgICAgICAgKEpTQzo6 V2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmxpbmspOgorICAgICAgICAoSlNDOjpXZWJBc3NlbWJs eU1vZHVsZVJlY29yZDo6ZXZhbHVhdGUpOgorICAgICAgICAqIHdhc20vanMvV2ViQXNzZW1ibHlN b2R1bGVSZWNvcmQuaDoKKwogMjAxNi0xMi0yOCAgU2FhbSBCYXJhdGkgIDxzYmFyYXRpQGFwcGxl LmNvbT4KIAogICAgICAgICBXZWJBc3NlbWJseTogRG9uJ3QgYWxsb3cgZHVwbGljYXRlIGV4cG9y dCBuYW1lcwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3Jl Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvSmF2YVNj cmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCBkOTMyNTZiLi4xMTYzNjll IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlw dENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMTIzNSw2ICsxMjM1LDcgQEAKIAkJ MkFERkEyNjMxOEVGMzU0MDAwNEY5RkNDIC8qIEdDTG9nZ2luZy5jcHAgaW4gU291cmNlcyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAyQURGQTI2MjE4RUYzNTQwMDA0RjlGQ0Mg LyogR0NMb2dnaW5nLmNwcCAqLzsgfTsKIAkJMkFGNzM4MkMxOEJCQkY5MjAwOEE1QTM3IC8qIFN0 cnVjdHVyZUlEVGFibGUuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gMkFGNzM4MkExOEJCQkY5MjAwOEE1QTM3IC8qIFN0cnVjdHVyZUlEVGFibGUuY3Bw ICovOyB9OwogCQkyQUY3MzgyRDE4QkJCRjkyMDA4QTVBMzcgLyogU3RydWN0dXJlSURUYWJsZS5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMkFGNzM4MkIx OEJCQkY5MjAwOEE1QTM3IC8qIFN0cnVjdHVyZUlEVGFibGUuaCAqLzsgc2V0dGluZ3MgPSB7QVRU UklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQkyRDM0MkYzNkY3MjQ0MDk2ODA0QURCMjQg LyogU291cmNlT3JpZ2luLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSA0MjVCQTEzMzdFNDM0NEUxQjI2OUE2NzEgLyogU291cmNlT3JpZ2luLmggKi87IHNl dHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJMzcxRDg0MkQxN0M5 OEI2RTAwRUNGOTk0IC8qIGxpYnouZHlsaWIgaW4gRnJhbWV3b3JrcyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSAzNzFEODQyQzE3Qzk4QjZFMDBFQ0Y5OTQgLyogbGliei5keWxp YiAqLzsgfTsKIAkJNDEyOTUyNzcxRDJDRjZCQzAwRTc4Qjg5IC8qIGJ1aWx0aW5zX2dlbmVyYXRl X2ludGVybmFsc193cmFwcGVyX2hlYWRlci5weSBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDQxMjk1MjczMUQyQ0Y2QUMwMEU3OEI4OSAvKiBidWlsdGluc19n ZW5lcmF0ZV9pbnRlcm5hbHNfd3JhcHBlcl9oZWFkZXIucHkgKi87IHNldHRpbmdzID0ge0FUVFJJ QlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDEyOTUyNzgxRDJDRjZCQzAwRTc4Qjg5IC8q IGJ1aWx0aW5zX2dlbmVyYXRlX2ludGVybmFsc193cmFwcGVyX2ltcGxlbWVudGF0aW9uLnB5IGlu IEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDEyOTUyNzQxRDJD RjZBQzAwRTc4Qjg5IC8qIGJ1aWx0aW5zX2dlbmVyYXRlX2ludGVybmFsc193cmFwcGVyX2ltcGxl bWVudGF0aW9uLnB5ICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07 IH07CkBAIC0yMDI1LDYgKzIwMjYsNyBAQAogCQlBRDc0MzhDMDFFMDQ1N0E0MDBGRDBDMkEgLyog V2FzbVNpZ25hdHVyZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gQUQ3NDM4QkYxRTA0NTc5MjAwRkQwQzJBIC8qIFdhc21TaWduYXR1cmUuaCAqLzsgc2V0 dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlBRDc0MzhDMTFFMDQ1 N0FBMDBGRDBDMkEgLyogV2FzbVNpZ25hdHVyZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBRDc0MzhCRTFFMDQ1NzkyMDBGRDBDMkEgLyogV2FzbVNp Z25hdHVyZS5jcHAgKi87IH07CiAJCUFEODZBOTNFMUFBNEQ4OEQwMDJGRTc3RiAvKiBXZWFrR0NN YXBJbmxpbmVzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSBBRDg2QTkzRDFBQTREODdDMDAyRkU3N0YgLyogV2Vha0dDTWFwSW5saW5lcy5oICovOyBzZXR0 aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CisJCUFEQjZGNjdEMUUxNUQ3 NjAwMDgyRjM4NCAvKiBXYXNtUGFnZUNvdW50LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEFEQjZGNjdDMUUxNUQ3NTAwMDgyRjM4NCAvKiBXYXNtUGFn ZUNvdW50LmNwcCAqLzsgfTsKIAkJQURCQzU0RDQxREY4RUEyQjAwNUJGNzM4IC8qIFdlYkFzc2Vt Ymx5VG9KU0NhbGxlZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSBBREJDNTREMjFERjhFQTAwMDA1QkY3MzggLyogV2ViQXNzZW1ibHlUb0pTQ2FsbGVl LmNwcCAqLzsgfTsKIAkJQURCQzU0RDUxREY4RUEyQjAwNUJGNzM4IC8qIFdlYkFzc2VtYmx5VG9K U0NhbGxlZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g QURCQzU0RDMxREY4RUEwMDAwNUJGNzM4IC8qIFdlYkFzc2VtYmx5VG9KU0NhbGxlZS5oICovOyB9 OwogCQlBRERCMUY2MzE4RDc3REJFMDA5QjU4QTggLyogT3BhcXVlUm9vdFNldC5oIGluIEhlYWRl cnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQUREQjFGNjIxOEQ3N0RCNzAw OUI1OEE4IC8qIE9wYXF1ZVJvb3RTZXQuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQ cml2YXRlLCApOyB9OyB9OwpAQCAtMjM2MSw3ICsyMzYzLDYgQEAKIAkJRkVEOTRGMkYxNzFFM0Uy MzAwQkU3N0E0IC8qIFdhdGNoZG9nLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBGRUQ5NEYyQzE3MUUzRTIzMDBCRTc3QTQgLyogV2F0Y2hkb2cuaCAqLzsg c2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGRUYwNDA1MTFB QUU2NjJEMDBCRDI4QjAgLyogQ29tcGFyZUFuZFN3YXBUZXN0LmNwcCBpbiBTb3VyY2VzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZFRjA0MDUwMUFBRTY2MkQwMEJEMjhCMCAv KiBDb21wYXJlQW5kU3dhcFRlc3QuY3BwICovOyB9OwogCQlGRUZENkZDNjFENUU3OTkyMDA4RjJG MEIgLyogSlNTdHJpbmdJbmxpbmVzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBGRUZENkZDNTFENUU3OTcwMDA4RjJGMEIgLyogSlNTdHJpbmdJbmxpbmVz LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKLQkJMkQz NDJGMzZGNzI0NDA5NjgwNEFEQjI0IC8qIFNvdXJjZU9yaWdpbi5oIGluIEhlYWRlcnMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDI1QkExMzM3RTQzNDRFMUIyNjlBNjcxIC8q IFNvdXJjZU9yaWdpbi5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7 IH07IH07CiAvKiBFbmQgUEJYQnVpbGRGaWxlIHNlY3Rpb24gKi8KIAogLyogQmVnaW4gUEJYQ29u dGFpbmVySXRlbVByb3h5IHNlY3Rpb24gKi8KQEAgLTM2MzgsNiArMzYzOSw3IEBACiAJCTQxMjk1 Mjc1MUQyQ0Y2QUMwMEU3OEI4OSAvKiBidWlsdGluc19nZW5lcmF0ZV93cmFwcGVyX2hlYWRlci5w eSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHRleHQuc2NyaXB0LnB5dGhvbjsgcGF0aCA9IGJ1aWx0aW5zX2dlbmVyYXRl X3dyYXBwZXJfaGVhZGVyLnB5OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0MTI5NTI3 NjFEMkNGNkFDMDBFNzhCODkgLyogYnVpbHRpbnNfZ2VuZXJhdGVfd3JhcHBlcl9pbXBsZW1lbnRh dGlvbi5weSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHRleHQuc2NyaXB0LnB5dGhvbjsgcGF0aCA9IGJ1aWx0aW5zX2dl bmVyYXRlX3dyYXBwZXJfaW1wbGVtZW50YXRpb24ucHk7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CiAJCTQxREVBMTMxMUI5RjMxNTQwMDZENjVERCAvKiBCdWlsdGluVXRpbHMuaCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQnVpbHRpblV0aWxzLmg7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CisJCTQyNUJBMTMzN0U0MzQ0RTFCMjY5QTY3MSAvKiBTb3VyY2VPcmlnaW4u aCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gU291cmNlT3JpZ2luLmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQzMTlEQTAxMUMxQkUzQzEwMDFEMjYwQiAvKiBCM0xv d2VyTWFjcm9zQWZ0ZXJPcHRpbWl6YXRpb25zLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgbmFtZSA9IEIzTG93ZXJNYWNyb3NBZnRlck9wdGltaXphdGlvbnMuY3BwOyBwYXRoID0g YjMvQjNMb3dlck1hY3Jvc0FmdGVyT3B0aW1pemF0aW9ucy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCTQzMTlEQTAyMUMxQkUzQzEwMDFEMjYwQiAvKiBCM0xvd2VyTWFjcm9zQWZ0 ZXJPcHRpbWl6YXRpb25zLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IEIzTG93 ZXJNYWNyb3NBZnRlck9wdGltaXphdGlvbnMuaDsgcGF0aCA9IGIzL0IzTG93ZXJNYWNyb3NBZnRl ck9wdGltaXphdGlvbnMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDM0MEE0ODIx QTkwNTFBRjAwRDczQ0NBIC8qIE1hdGhDb21tb24uY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBwYXRoID0gTWF0aENvbW1vbi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CkBAIC00NTEwLDYgKzQ1MTIsNyBAQAogCQlBRDc0MzhCRTFFMDQ1NzkyMDBGRDBDMkEgLyogV2Fz bVNpZ25hdHVyZS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBXYXNt U2lnbmF0dXJlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQUQ3NDM4QkYxRTA0 NTc5MjAwRkQwQzJBIC8qIFdhc21TaWduYXR1cmUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gV2FzbVNpZ25hdHVyZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlB RDg2QTkzRDFBQTREODdDMDAyRkU3N0YgLyogV2Vha0dDTWFwSW5saW5lcy5oICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jLmg7IHBhdGggPSBXZWFrR0NNYXBJbmxpbmVzLmg7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CisJCUFEQjZGNjdDMUUxNUQ3NTAwMDgyRjM4NCAvKiBXYXNtUGFnZUNvdW50 LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFdhc21QYWdlQ291bnQu Y3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBREJDNTREMjFERjhFQTAwMDA1QkY3 MzggLyogV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgbmFtZSA9IFdlYkFzc2VtYmx5VG9KU0NhbGxlZS5jcHA7IHBhdGggPSBqcy9XZWJBc3Nl bWJseVRvSlNDYWxsZWUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBREJDNTRE MzFERjhFQTAwMDA1QkY3MzggLyogV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFdlYkFzc2VtYmx5VG9KU0NhbGxlZS5oOyBwYXRoID0ganMv V2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUFE REIxRjYyMThENzdEQjcwMDlCNThBOCAvKiBPcGFxdWVSb290U2V0LmggKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmMuaDsgcGF0aCA9IE9wYXF1ZVJvb3RTZXQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKQEAgLTQ4NzksNyArNDg4Miw2IEBACiAJCUZFRjA0MDUwMUFBRTY2MkQwMEJEMjhCMCAv KiBDb21wYXJlQW5kU3dhcFRlc3QuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBu YW1lID0gQ29tcGFyZUFuZFN3YXBUZXN0LmNwcDsgcGF0aCA9IEFQSS90ZXN0cy9Db21wYXJlQW5k U3dhcFRlc3QuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGRUYwNDA1MjFBQUVD NEVEMDBCRDI4QjAgLyogQ29tcGFyZUFuZFN3YXBUZXN0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmMuaDsgbmFtZSA9IENvbXBhcmVBbmRTd2FwVGVzdC5oOyBwYXRoID0gQVBJL3Rlc3RzL0NvbXBh cmVBbmRTd2FwVGVzdC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGRUZENkZDNTFE NUU3OTcwMDA4RjJGMEIgLyogSlNTdHJpbmdJbmxpbmVzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmMuaDsgcGF0aCA9IEpTU3RyaW5nSW5saW5lcy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwotCQk0MjVCQTEzMzdFNDM0NEUxQjI2OUE2NzEgLyogU291cmNlT3JpZ2luLmggKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFNvdXJjZU9yaWdpbi5oOyBwYXRoID0gU291cmNlT3Jp Z2luLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAvKiBFbmQgUEJYRmlsZVJlZmVyZW5j ZSBzZWN0aW9uICovCiAKIC8qIEJlZ2luIFBCWEZyYW1ld29ya3NCdWlsZFBoYXNlIHNlY3Rpb24g Ki8KQEAgLTYwNDcsNiArNjA0OSw3IEBACiAJCQkJNzlCNzU5NzIxREZBNEM2MDAwNTIxNzRDIC8q IFdhc21NZW1vcnlJbmZvcm1hdGlvbi5oICovLAogCQkJCTUzRjQwRTk2MUQ1QTdCRUMwMDk5QTFC NiAvKiBXYXNtTW9kdWxlUGFyc2VyLmNwcCAqLywKIAkJCQk1M0Y0MEU5NDFENUE3QUVGMDA5OUEx QjYgLyogV2FzbU1vZHVsZVBhcnNlci5oICovLAorCQkJCUFEQjZGNjdDMUUxNUQ3NTAwMDgyRjM4 NCAvKiBXYXNtUGFnZUNvdW50LmNwcCAqLywKIAkJCQk3OUI3NTk3MzFERkE0QzYwMDA1MjE3NEMg LyogV2FzbVBhZ2VDb3VudC5oICovLAogCQkJCTUzRjQwRThDMUQ1OTAxRjIwMDk5QTFCNiAvKiBX YXNtUGFyc2VyLmggKi8sCiAJCQkJNTMxMzc0QkUxRDVDRTk1MDAwQUY3QTBCIC8qIFdhc21QbGFu LmNwcCAqLywKQEAgLTk3MDMsNiArOTcwNiw3IEBACiAJCQkJMEY2NEIyNzExQTc4NEJBRjAwNkU0 RTY2IC8qIEJpbmFyeVN3aXRjaC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkxNDI4MDg2MzEwN0VD MTFBMDAxM0U3QjIgLyogQm9vbGVhbkNvbnN0cnVjdG9yLmNwcCBpbiBTb3VyY2VzICovLAogCQkJ CTE0MjgwODY0MTA3RUMxMUEwMDEzRTdCMiAvKiBCb29sZWFuT2JqZWN0LmNwcCBpbiBTb3VyY2Vz ICovLAorCQkJCUFEQjZGNjdEMUUxNUQ3NjAwMDgyRjM4NCAvKiBXYXNtUGFnZUNvdW50LmNwcCBp biBTb3VyY2VzICovLAogCQkJCTE0MjgwODY1MTA3RUMxMUEwMDEzRTdCMiAvKiBCb29sZWFuUHJv dG90eXBlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCURFMjZFOTA3MUNCNURFRkIwMEQyQkU4MiAv KiBCdWlsdGluRXhlY3V0YWJsZUNyZWF0b3IuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQTdEODAx QTQxODgwRDY2RTAwMjZDMzlCIC8qIEJ1aWx0aW5FeGVjdXRhYmxlcy5jcHAgaW4gU291cmNlcyAq LywKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9qc2MuY3BwIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL2pzYy5jcHAKaW5kZXggM2VhZjRhMC4uZjQzNGNhYyAxMDA2NDQKLS0tIGEv U291cmNlL0phdmFTY3JpcHRDb3JlL2pzYy5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L2pzYy5jcHAKQEAgLTU0LDYgKzU0LDggQEAKICNpbmNsdWRlICJKU1N0cmluZy5oIgogI2luY2x1 ZGUgIkpTVHlwZWRBcnJheXMuaCIKICNpbmNsdWRlICJKU1dlYkFzc2VtYmx5Q2FsbGVlLmgiCisj aW5jbHVkZSAiSlNXZWJBc3NlbWJseUluc3RhbmNlLmgiCisjaW5jbHVkZSAiSlNXZWJBc3NlbWJs eU1vZHVsZS5oIgogI2luY2x1ZGUgIkxMSW50RGF0YS5oIgogI2luY2x1ZGUgIkxMSW50VGh1bmtz LmgiCiAjaW5jbHVkZSAiT2JqZWN0Q29uc3RydWN0b3IuaCIKQEAgLTcwLDYgKzcyLDcgQEAKICNp bmNsdWRlICJUeXBlUHJvZmlsZXJMb2cuaCIKICNpbmNsdWRlICJXYXNtUGxhbi5oIgogI2luY2x1 ZGUgIldhc21NZW1vcnkuaCIKKyNpbmNsdWRlICJXZWJBc3NlbWJseU1vZHVsZVJlY29yZC5oIgog I2luY2x1ZGUgPGxvY2FsZS5oPgogI2luY2x1ZGUgPG1hdGguaD4KICNpbmNsdWRlIDxzdGRpby5o PgpAQCAtMjYxNSw2ICsyNjE4LDcgQEAgc3RhdGljIEVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NB TEwgZnVuY3Rpb25UZXN0V2FzbU1vZHVsZUZ1bmN0aW9ucyhFeGVjU3RhdGUqIGUKIHsKICAgICBW TSYgdm0gPSBleGVjLT52bSgpOwogICAgIGF1dG8gc2NvcGUgPSBERUNMQVJFX1RIUk9XX1NDT1BF KHZtKTsKKyAgICBhdXRvKiBnbG9iYWxPYmplY3QgPSBleGVjLT5sZXhpY2FsR2xvYmFsT2JqZWN0 KCk7CiAKICAgICBpZiAoIU9wdGlvbnM6OnVzZVdlYkFzc2VtYmx5KCkpCiAgICAgICAgIHJldHVy biB0aHJvd1ZNVHlwZUVycm9yKGV4ZWMsIHNjb3BlLCBBU0NJSUxpdGVyYWwoInRlc3RXYXNtTW9k dWxlIHNob3VsZCBvbmx5IGJlIGNhbGxlZCBpZiB0aGUgdXNlV2ViQXNzZW1ibHkgb3B0aW9uIGlz IHNldCIpKTsKQEAgLTI2NDgsOCArMjY1MiwyNSBAQCBzdGF0aWMgRW5jb2RlZEpTVmFsdWUgSlND X0hPU1RfQ0FMTCBmdW5jdGlvblRlc3RXYXNtTW9kdWxlRnVuY3Rpb25zKEV4ZWNTdGF0ZSogZQog ICAgICAgICAgICAgfSk7CiAgICAgfQogCi0gICAgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVs ZUluZm9ybWF0aW9uPiBtb2R1bGVJbmZvcm1hdGlvbiA9IHBsYW4udGFrZU1vZHVsZUluZm9ybWF0 aW9uKCk7Ci0gICAgUkVMRUFTRV9BU1NFUlQoIW1vZHVsZUluZm9ybWF0aW9uLT5tZW1vcnkpOwor ICAgIFN5bWJvbFRhYmxlKiBleHBvcnRTeW1ib2xUYWJsZSA9IFN5bWJvbFRhYmxlOjpjcmVhdGUo dm0pOworICAgIGF1dG8qIG1vZHVsZVN0cnVjdHVyZSA9IEludGVybmFsRnVuY3Rpb246OmNyZWF0 ZVN1YmNsYXNzU3RydWN0dXJlKGV4ZWMsIEpTVmFsdWUoKSwgZXhlYy0+bGV4aWNhbEdsb2JhbE9i amVjdCgpLT5XZWJBc3NlbWJseU1vZHVsZVN0cnVjdHVyZSgpKTsKKyAgICBSRVRVUk5fSUZfRVhD RVBUSU9OKHNjb3BlLCBlbmNvZGVkSlNWYWx1ZSgpKTsKKyAgICBKU1dlYkFzc2VtYmx5TW9kdWxl KiBtb2R1bGUgPSBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGUodm0sIG1vZHVsZVN0cnVjdHVy ZSwgcGxhbi50YWtlTW9kdWxlSW5mb3JtYXRpb24oKSwgcGxhbi50YWtlQ2FsbExpbmtJbmZvcygp LCBwbGFuLnRha2VXYXNtRXhpdFN0dWJzKCksIGV4cG9ydFN5bWJvbFRhYmxlLCAwKTsKKyAgICBT dHJ1Y3R1cmUqIGluc3RhbmNlU3RydWN0dXJlID0gSW50ZXJuYWxGdW5jdGlvbjo6Y3JlYXRlU3Vi Y2xhc3NTdHJ1Y3R1cmUoZXhlYywgSlNWYWx1ZSgpLCBnbG9iYWxPYmplY3QtPldlYkFzc2VtYmx5 SW5zdGFuY2VTdHJ1Y3R1cmUoKSk7CisgICAgUkVUVVJOX0lGX0VYQ0VQVElPTihzY29wZSwgZW5j b2RlZEpTVmFsdWUoKSk7CisgICAgSWRlbnRpZmllciBtb2R1bGVLZXkgPSBJZGVudGlmaWVyOjpm cm9tVWlkKFByaXZhdGVOYW1lKFByaXZhdGVOYW1lOjpEZXNjcmlwdGlvbiwgIldlYkFzc2VtYmx5 SW5zdGFuY2UiKSk7CisgICAgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQqIG1vZHVsZVJlY29yZCA9 IFdlYkFzc2VtYmx5TW9kdWxlUmVjb3JkOjpjcmVhdGUoZXhlYywgdm0sIGdsb2JhbE9iamVjdC0+ d2ViQXNzZW1ibHlNb2R1bGVSZWNvcmRTdHJ1Y3R1cmUoKSwgbW9kdWxlS2V5LCBtb2R1bGUtPm1v ZHVsZUluZm9ybWF0aW9uKCkpOworICAgIFJFVFVSTl9JRl9FWENFUFRJT04oc2NvcGUsIGVuY29k ZWRKU1ZhbHVlKCkpOworICAgIEpTV2ViQXNzZW1ibHlJbnN0YW5jZSogaW5zdGFuY2UgPSBKU1dl YkFzc2VtYmx5SW5zdGFuY2U6OmNyZWF0ZSh2bSwgaW5zdGFuY2VTdHJ1Y3R1cmUsIG1vZHVsZSwg bW9kdWxlUmVjb3JkLT5nZXRNb2R1bGVOYW1lc3BhY2UoZXhlYykpOworICAgIFJFVFVSTl9JRl9F WENFUFRJT04oc2NvcGUsIGVuY29kZWRKU1ZhbHVlKCkpOworICAgIHZtLnRvcEpTV2ViQXNzZW1i bHlJbnN0YW5jZSA9IGluc3RhbmNlOworCisgICAgaWYgKCEhbW9kdWxlLT5tb2R1bGVJbmZvcm1h dGlvbigpLm1lbW9yeSkgeworICAgICAgICBib29sIGZhaWxlZDsKKyAgICAgICAgV2FzbTo6TWVt b3J5IG1lbW9yeShtb2R1bGUtPm1vZHVsZUluZm9ybWF0aW9uKCkubWVtb3J5LmluaXRpYWwoKSwg bW9kdWxlLT5tb2R1bGVJbmZvcm1hdGlvbigpLm1lbW9yeS5tYXhpbXVtKCksIGZhaWxlZCk7Cisg ICAgICAgIFJFTEVBU0VfQVNTRVJUKGZhaWxlZCk7CisgICAgICAgIGluc3RhbmNlLT5zZXRNZW1v cnkodm0sIEpTV2ViQXNzZW1ibHlNZW1vcnk6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LT5XZWJB c3NlbWJseU1lbW9yeVN0cnVjdHVyZSgpLCBXVEZNb3ZlKG1lbW9yeSkpKTsKKyAgICB9CiAKICAg ICBmb3IgKHVpbnQzMl90IGkgPSAwOyBpIDwgZnVuY3Rpb25Db3VudDsgKytpKSB7CiAgICAgICAg IEpTQXJyYXkqIHRlc3RDYXNlcyA9IGpzQ2FzdDxKU0FycmF5Kj4oZXhlYy0+YXJndW1lbnQoaSAr IDIpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0Fic3RyYWN0 TW9kdWxlUmVjb3JkLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9BYnN0cmFjdE1v ZHVsZVJlY29yZC5oCmluZGV4IDA0YWYxMjYuLjM5ZmMyZDEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS9ydW50aW1lL0Fic3RyYWN0TW9kdWxlUmVjb3JkLmgKKysrIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvQWJzdHJhY3RNb2R1bGVSZWNvcmQuaApAQCAtMTEzLDcg KzExMyw3IEBAIHB1YmxpYzoKIAogICAgIEFic3RyYWN0TW9kdWxlUmVjb3JkKiBob3N0UmVzb2x2 ZUltcG9ydGVkTW9kdWxlKEV4ZWNTdGF0ZSosIGNvbnN0IElkZW50aWZpZXImIG1vZHVsZU5hbWUp OwogCi0gICAgSlNNb2R1bGVOYW1lc3BhY2VPYmplY3QqIGdldE1vZHVsZU5hbWVzcGFjZShFeGVj U3RhdGUqKTsKKyAgICBKU19FWFBPUlRfUFJJVkFURSBKU01vZHVsZU5hbWVzcGFjZU9iamVjdCog Z2V0TW9kdWxlTmFtZXNwYWNlKEV4ZWNTdGF0ZSopOwogICAgIAogICAgIEpTTW9kdWxlRW52aXJv bm1lbnQqIG1vZHVsZUVudmlyb25tZW50KCkKICAgICB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvcnVudGltZS9KU1R5cGUuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50 aW1lL0pTVHlwZS5oCmluZGV4IDA1MjAyZjMuLmFjNTA5ZDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTVHlwZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9ydW50aW1lL0pTVHlwZS5oCkBAIC05Myw2ICs5Myw4IEBAIGVudW0gSlNUeXBlIDogdWludDhf dCB7CiAgICAgSlNNYXBUeXBlLAogICAgIEpTU2V0VHlwZSwKIAorICAgIFdlYkFzc2VtYmx5RnVu Y3Rpb25UeXBlLAorCiAgICAgTGFzdEpTQ09iamVjdFR5cGUgPSBKU1NldFR5cGUsCiAgICAgTWF4 SlNUeXBlID0gMGIxMTExMTExMSwKIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtQjNJUkdlbmVyYXRvci5jcHAKaW5kZXggMTE3ZDc2NC4uN2Y1NmYyZSAxMDA2NDQKLS0t IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuY3BwCisrKyBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcApAQCAtMTU1 LDcgKzE1NSw3IEBAIHB1YmxpYzoKICAgICAgICAgICAgIHJldHVybiBmYWlsKF9fVkFfQVJHU19f KTsgICAgICAgICAgICAgXAogICAgIH0gd2hpbGUgKDApCiAKLSAgICBCM0lSR2VuZXJhdG9yKFZN JiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mLCBQcm9jZWR1cmUmLCBXYXNtSW50ZXJuYWxGdW5j dGlvbiosIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYsIGNvbnN0IEltbXV0YWJsZUZ1 bmN0aW9uSW5kZXhTcGFjZSYpOworICAgIEIzSVJHZW5lcmF0b3IoVk0mLCBjb25zdCBNb2R1bGVJ bmZvcm1hdGlvbiYsIFByb2NlZHVyZSYsIFdhc21JbnRlcm5hbEZ1bmN0aW9uKiwgVmVjdG9yPFVu bGlua2VkV2FzbVRvV2FzbUNhbGw+Jik7CiAKICAgICBQYXJ0aWFsUmVzdWx0IFdBUk5fVU5VU0VE X1JFVFVSTiBhZGRBcmd1bWVudHMoY29uc3QgU2lnbmF0dXJlKik7CiAgICAgUGFydGlhbFJlc3Vs dCBXQVJOX1VOVVNFRF9SRVRVUk4gYWRkTG9jYWwoVHlwZSwgdWludDMyX3QpOwpAQCAtMjA1LDgg KzIwNSw2IEBAIHB1YmxpYzoKIAogICAgIHZvaWQgZW1pdEV4Y2VwdGlvbkNoZWNrKENDYWxsSGVs cGVycyYsIEV4Y2VwdGlvblR5cGUpOwogCi0gICAgdm9pZCBlbWl0UmVsb2FkUGlubmVkUmVnaXN0 ZXJzKCk7Ci0KIHByaXZhdGU6CiAgICAgRXhwcmVzc2lvblR5cGUgZW1pdENoZWNrQW5kUHJlcGFy ZVBvaW50ZXIoRXhwcmVzc2lvblR5cGUgcG9pbnRlciwgdWludDMyX3Qgb2Zmc2V0LCB1aW50MzJf dCBzaXplT2ZPcCk7CiAgICAgRXhwcmVzc2lvblR5cGUgZW1pdExvYWRPcChMb2FkT3BUeXBlLCBP cmlnaW4sIEV4cHJlc3Npb25UeXBlIHBvaW50ZXIsIHVpbnQzMl90IG9mZnNldCk7CkBAIC0yMTks NyArMjE3LDYgQEAgcHJpdmF0ZToKICAgICB2b2lkIGVtaXRDaGVja3NGb3JNb2RPckRpdihCMzo6 T3Bjb2RlLCBFeHByZXNzaW9uVHlwZSBsZWZ0LCBFeHByZXNzaW9uVHlwZSByaWdodCk7CiAKICAg ICBWTSYgbV92bTsKLSAgICBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIG1fZnVu Y3Rpb25JbmRleFNwYWNlOwogICAgIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBtX2luZm87CiAg ICAgUHJvY2VkdXJlJiBtX3Byb2M7CiAgICAgQmFzaWNCbG9jayogbV9jdXJyZW50QmxvY2s7CkBA IC0yMzEsOSArMjI4LDggQEAgcHJpdmF0ZToKICAgICBWYWx1ZSogbV9pbnN0YW5jZVZhbHVlOwog fTsKIAotQjNJUkdlbmVyYXRvcjo6QjNJUkdlbmVyYXRvcihWTSYgdm0sIGNvbnN0IE1vZHVsZUlu Zm9ybWF0aW9uJiBpbmZvLCBQcm9jZWR1cmUmIHByb2NlZHVyZSwgV2FzbUludGVybmFsRnVuY3Rp b24qIGNvbXBpbGF0aW9uLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mIHVubGlua2Vk V2FzbVRvV2FzbUNhbGxzLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIGZ1bmN0 aW9uSW5kZXhTcGFjZSkKK0IzSVJHZW5lcmF0b3I6OkIzSVJHZW5lcmF0b3IoVk0mIHZtLCBjb25z dCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgUHJvY2VkdXJlJiBwcm9jZWR1cmUsIFdhc21JbnRl cm5hbEZ1bmN0aW9uKiBjb21waWxhdGlvbiwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+ JiB1bmxpbmtlZFdhc21Ub1dhc21DYWxscykKICAgICA6IG1fdm0odm0pCi0gICAgLCBtX2Z1bmN0 aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4U3BhY2UpCiAgICAgLCBtX2luZm8oaW5mbykKICAg ICAsIG1fcHJvYyhwcm9jZWR1cmUpCiAgICAgLCBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzKHVu bGlua2VkV2FzbVRvV2FzbUNhbGxzKQpAQCAtMjU0LDE0ICsyNTAsMTYgQEAgQjNJUkdlbmVyYXRv cjo6QjNJUkdlbmVyYXRvcihWTSYgdm0sIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBpbmZvLCBQ cm9jZWR1cmUmIHAKICAgICAgICAgfQogICAgIH0KIAotICAgIGlmIChpbmZvLmhhc01lbW9yeSgp KSB7Ci0gICAgICAgIG1fbWVtb3J5QmFzZUdQUiA9IGluZm8ubWVtb3J5LnBpbm5lZFJlZ2lzdGVy cygpLmJhc2VNZW1vcnlQb2ludGVyOworICAgIC8vIEZJWE1FIHdlIGRvbid0IHJlYWxseSBuZWVk IHRvIHBpbiByZWdpc3RlcnMgaGVyZSBpZiB0aGVyZSdzIG5vIG1lbW9yeS4gSXQgbWFrZXMgd2Fz bSAtPiB3YXNtIHRodW5rcyBzaW1wbGVyIGZvciBub3cuIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0xNjY2MjMKKyAgICAgICAgY29uc3QgUGlubmVkUmVnaXN0ZXJJbmZv JiBwaW5uZWRSZWdzID0gUGlubmVkUmVnaXN0ZXJJbmZvOjpnZXQoKTsKKyAgICAgICAgbV9tZW1v cnlCYXNlR1BSID0gcGlubmVkUmVncy5iYXNlTWVtb3J5UG9pbnRlcjsKICAgICAgICAgbV9wcm9j LnBpblJlZ2lzdGVyKG1fbWVtb3J5QmFzZUdQUik7Ci0gICAgICAgIEFTU0VSVCghaW5mby5tZW1v cnkucGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVyc1swXS5zaXplT2Zmc2V0KTsKLSAgICAg ICAgbV9tZW1vcnlTaXplR1BSID0gaW5mby5tZW1vcnkucGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJl Z2lzdGVyc1swXS5zaXplUmVnaXN0ZXI7Ci0gICAgICAgIGZvciAoY29uc3QgUGlubmVkU2l6ZVJl Z2lzdGVySW5mbyYgcmVnSW5mbyA6IGluZm8ubWVtb3J5LnBpbm5lZFJlZ2lzdGVycygpLnNpemVS ZWdpc3RlcnMpCisgICAgICAgIEFTU0VSVCghcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzWzBdLnNp emVPZmZzZXQpOworICAgICAgICBtX21lbW9yeVNpemVHUFIgPSBwaW5uZWRSZWdzLnNpemVSZWdp c3RlcnNbMF0uc2l6ZVJlZ2lzdGVyOworICAgICAgICBmb3IgKGNvbnN0IFBpbm5lZFNpemVSZWdp c3RlckluZm8mIHJlZ0luZm8gOiBwaW5uZWRSZWdzLnNpemVSZWdpc3RlcnMpCiAgICAgICAgICAg ICBtX3Byb2MucGluUmVnaXN0ZXIocmVnSW5mby5zaXplUmVnaXN0ZXIpOwogCisgICAgaWYgKGlu Zm8uaGFzTWVtb3J5KCkpIHsKICAgICAgICAgbV9wcm9jLnNldFdhc21Cb3VuZHNDaGVja0dlbmVy YXRvcihbPV0gKENDYWxsSGVscGVycyYgaml0LCBHUFJSZWcgcGlubmVkR1BSLCB1bnNpZ25lZCkg ewogICAgICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93U2NyYXRj aChqaXQpOwogICAgICAgICAgICAgQVNTRVJUX1VOVVNFRChwaW5uZWRHUFIsIG1fbWVtb3J5U2l6 ZUdQUiA9PSBwaW5uZWRHUFIpOwpAQCAtMjc1LDYgKzI3Myw2MSBAQCBCM0lSR2VuZXJhdG9yOjpC M0lSR2VuZXJhdG9yKFZNJiB2bSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFByb2Nl ZHVyZSYgcAogICAgICAgICBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+ KG1fcHJvYywgT3JpZ2luKCksICZtX3ZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZSkpOwogfQog CitzdHJ1Y3QgTWVtb3J5QmFzZUFuZFNpemUgeworICAgIFZhbHVlKiBiYXNlOworICAgIFZhbHVl KiBzaXplOworfTsKKworc3RhdGljIE1lbW9yeUJhc2VBbmRTaXplIGdldE1lbW9yeUJhc2VBbmRT aXplKFZNJiB2bSwgVmFsdWUqIGluc3RhbmNlLCBQcm9jZWR1cmUmIHByb2MsIEJhc2ljQmxvY2sq IGJsb2NrKQoreworICAgIFZhbHVlKiBtZW1vcnlPYmplY3QgPSBibG9jay0+YXBwZW5kTmV3PE1l bW9yeVZhbHVlPihwcm9jLCBMb2FkLCBwb2ludGVyVHlwZSgpLCBPcmlnaW4oKSwgaW5zdGFuY2Us IEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZNZW1vcnkoKSk7CisKKyAgICBzdGF0aWNf YXNzZXJ0KHNpemVvZihkZWNsdHlwZSh2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UtPm1lbW9y eSgpLT5tZW1vcnkoKS0+bWVtb3J5KCkpKSA9PSBzaXplb2Yodm9pZCopLCAiY29kZWdlbiByZWxp ZXMgb24gdGhpcyBzaXplIik7CisgICAgc3RhdGljX2Fzc2VydChzaXplb2YoZGVjbHR5cGUodm0u dG9wSlNXZWJBc3NlbWJseUluc3RhbmNlLT5tZW1vcnkoKS0+bWVtb3J5KCktPnNpemUoKSkpID09 IHNpemVvZih1aW50NjRfdCksICJjb2RlZ2VuIHJlbGllcyBvbiB0aGlzIHNpemUiKTsKKyAgICBN ZW1vcnlCYXNlQW5kU2l6ZSByZXN1bHQ7CisgICAgcmVzdWx0LmJhc2UgPSBibG9jay0+YXBwZW5k TmV3PE1lbW9yeVZhbHVlPihwcm9jLCBMb2FkLCBwb2ludGVyVHlwZSgpLCBPcmlnaW4oKSwgbWVt b3J5T2JqZWN0LCBKU1dlYkFzc2VtYmx5TWVtb3J5OjpvZmZzZXRPZk1lbW9yeSgpKTsKKyAgICBy ZXN1bHQuc2l6ZSA9IGJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KHByb2MsIExvYWQsIElu dDY0LCBPcmlnaW4oKSwgbWVtb3J5T2JqZWN0LCBKU1dlYkFzc2VtYmx5TWVtb3J5OjpvZmZzZXRP ZlNpemUoKSk7CisKKyAgICByZXR1cm4gcmVzdWx0OworfQorCitzdGF0aWMgdm9pZCByZXN0b3Jl V2ViQXNzZW1ibHlHbG9iYWxTdGF0ZShWTSYgdm0sIGNvbnN0IE1lbW9yeUluZm9ybWF0aW9uJiBt ZW1vcnksIFZhbHVlKiBpbnN0YW5jZSwgUHJvY2VkdXJlJiBwcm9jLCBCYXNpY0Jsb2NrKiBibG9j aykKK3sKKyAgICBibG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihwcm9jLCBTdG9yZSwgT3Jp Z2luKCksIGluc3RhbmNlLCBibG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KHByb2MsIE9y aWdpbigpLCAmdm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlKSk7CisKKyAgICBpZiAoISFtZW1v cnkpIHsKKyAgICAgICAgY29uc3QgUGlubmVkUmVnaXN0ZXJJbmZvJiBwaW5uZWRSZWdzID0gUGlu bmVkUmVnaXN0ZXJJbmZvOjpnZXQoKTsKKyAgICAgICAgYXV0byBtZW1vcnlWYWx1ZSA9IGdldE1l bW9yeUJhc2VBbmRTaXplKHZtLCBpbnN0YW5jZSwgcHJvYywgYmxvY2spOworCisgICAgICAgIFZl Y3RvcjxWYWx1ZSo+IGFyZ3VtZW50czsKKyAgICAgICAgYXJndW1lbnRzLnJlc2VydmVDYXBhY2l0 eSgxICsgcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzLnNpemUoKSk7CisgICAgICAgIGFyZ3VtZW50 cy5hcHBlbmQobWVtb3J5VmFsdWUuYmFzZSk7CisgICAgICAgIGZvciAoYXV0byBpbmZvIDogcGlu bmVkUmVncy5zaXplUmVnaXN0ZXJzKSB7CisgICAgICAgICAgICBWYWx1ZSogc2l6ZVZhbHVlID0g YmxvY2stPmFwcGVuZE5ldzxWYWx1ZT4ocHJvYywgU3ViLCBPcmlnaW4oKSwgbWVtb3J5VmFsdWUu c2l6ZSwgYmxvY2stPmFwcGVuZE5ldzxDb25zdDY0VmFsdWU+KHByb2MsIE9yaWdpbigpLCBpbmZv LnNpemVPZmZzZXQpKTsKKyAgICAgICAgICAgIGFyZ3VtZW50cy5hcHBlbmQoc2l6ZVZhbHVlKTsK KyAgICAgICAgfQorCisgICAgICAgIFJlZ2lzdGVyU2V0IGNsb2JiZXJzOworICAgICAgICBjbG9i YmVycy5zZXQocGlubmVkUmVncy5iYXNlTWVtb3J5UG9pbnRlcik7CisgICAgICAgIGZvciAoYXV0 byBpbmZvIDogcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzKQorICAgICAgICAgICAgY2xvYmJlcnMu c2V0KGluZm8uc2l6ZVJlZ2lzdGVyKTsKKworICAgICAgICBCMzo6UGF0Y2hwb2ludFZhbHVlKiBw YXRjaHBvaW50ID0gYmxvY2stPmFwcGVuZE5ldzxCMzo6UGF0Y2hwb2ludFZhbHVlPihwcm9jLCBC Mzo6Vm9pZCwgT3JpZ2luKCkpOworICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzID0gRWZmZWN0 czo6bm9uZSgpOworICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLndyaXRlc1Bpbm5lZCA9IHRy dWU7CisgICAgICAgIHBhdGNocG9pbnQtPmNsb2JiZXIoY2xvYmJlcnMpOworICAgICAgICBwYXRj aHBvaW50LT5hcHBlbmRWZWN0b3JXaXRoUmVwKGFyZ3VtZW50cywgVmFsdWVSZXA6OlNvbWVSZWdp c3Rlcik7CisKKyAgICAgICAgcGF0Y2hwb2ludC0+c2V0R2VuZXJhdG9yKFsmcGlubmVkUmVnc10g KENDYWxsSGVscGVycyYgaml0LCBjb25zdCBCMzo6U3RhY2ttYXBHZW5lcmF0aW9uUGFyYW1zJiBw YXJhbXMpIHsKKyAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxv d1NjcmF0Y2goaml0KTsKKworICAgICAgICAgICAgaml0Lm1vdmUocGFyYW1zWzBdLmdwcigpLCBw aW5uZWRSZWdzLmJhc2VNZW1vcnlQb2ludGVyKTsKKyAgICAgICAgICAgIGZvciAodWludDMyX3Qg aSA9IDA7IGkgPCBwaW5uZWRSZWdzLnNpemVSZWdpc3RlcnMuc2l6ZSgpOyArK2kpCisgICAgICAg ICAgICAgICAgaml0Lm1vdmUocGFyYW1zWzEgKyBpXS5ncHIoKSwgcGlubmVkUmVncy5zaXplUmVn aXN0ZXJzW2ldLnNpemVSZWdpc3Rlcik7CisgICAgICAgIH0pOworICAgIH0KK30KKwogdm9pZCBC M0lSR2VuZXJhdG9yOjplbWl0RXhjZXB0aW9uQ2hlY2soQ0NhbGxIZWxwZXJzJiBqaXQsIEV4Y2Vw dGlvblR5cGUgdHlwZSkKIHsKICAgICBqaXQubW92ZShDQ2FsbEhlbHBlcnM6OlRydXN0ZWRJbW0z MihzdGF0aWNfY2FzdDx1aW50MzJfdD4odHlwZSkpLCBHUFJJbmZvOjphcmd1bWVudEdQUjEpOwpA QCAtMzM4LDQ5ICszOTEsNiBAQCBhdXRvIEIzSVJHZW5lcmF0b3I6OmFkZFVucmVhY2hhYmxlKCkg LT4gUGFydGlhbFJlc3VsdAogICAgIHJldHVybiB7IH07CiB9CiAKLXN0YXRpYyB2b2lkIHJlbG9h ZFBpbm5lZFJlZ2lzdGVycyhQcm9jZWR1cmUmIHByb2MsIEJhc2ljQmxvY2sqIGJsb2NrLCBjb25z dCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgVmFsdWUqIGluc3RhbmNlKQotewotICAgIGlmICgh aW5mby5oYXNNZW1vcnkoKSkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgY29uc3QgTWVtb3J5SW5m b3JtYXRpb24qIG1lbW9yeSA9ICZpbmZvLm1lbW9yeTsKLQotICAgIFJlZ2lzdGVyU2V0IGNsb2Ji ZXJzOwotICAgIGNsb2JiZXJzLnNldChtZW1vcnktPnBpbm5lZFJlZ2lzdGVycygpLmJhc2VNZW1v cnlQb2ludGVyKTsKLSAgICBmb3IgKGF1dG8gaW5mbyA6IG1lbW9yeS0+cGlubmVkUmVnaXN0ZXJz KCkuc2l6ZVJlZ2lzdGVycykKLSAgICAgICAgY2xvYmJlcnMuc2V0KGluZm8uc2l6ZVJlZ2lzdGVy KTsKLQotICAgIEIzOjpQYXRjaHBvaW50VmFsdWUqIHBhdGNocG9pbnQgPSBibG9jay0+YXBwZW5k TmV3PEIzOjpQYXRjaHBvaW50VmFsdWU+KHByb2MsIEIzOjpWb2lkLCBPcmlnaW4oKSk7Ci0gICAg cGF0Y2hwb2ludC0+ZWZmZWN0cyA9IEVmZmVjdHM6Om5vbmUoKTsKLSAgICBwYXRjaHBvaW50LT5l ZmZlY3RzLndyaXRlc1Bpbm5lZCA9IHRydWU7Ci0gICAgcGF0Y2hwb2ludC0+Y2xvYmJlcihjbG9i YmVycyk7Ci0gICAgcGF0Y2hwb2ludC0+bnVtR1BTY3JhdGNoUmVnaXN0ZXJzID0gMTsKLQotICAg IHBhdGNocG9pbnQtPmFwcGVuZChpbnN0YW5jZSwgVmFsdWVSZXA6OlNvbWVSZWdpc3Rlcik7Ci0K LSAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW21lbW9yeV0gKENDYWxsSGVscGVycyYgaml0 LCBjb25zdCBCMzo6U3RhY2ttYXBHZW5lcmF0aW9uUGFyYW1zJiBwYXJhbXMpIHsKLSAgICAgICAg QWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93U2NyYXRjaChqaXQpOwotCi0gICAg ICAgIEdQUlJlZyBzY3JhdGNoID0gcGFyYW1zLmdwU2NyYXRjaCgwKTsKLSAgICAgICAgaml0Lmxv YWRQdHIoQ0NhbGxIZWxwZXJzOjpBZGRyZXNzKHBhcmFtc1swXS5ncHIoKSwgSlNXZWJBc3NlbWJs eUluc3RhbmNlOjpvZmZzZXRPZk1lbW9yeSgpKSwgc2NyYXRjaCk7Ci0gICAgICAgIGppdC5sb2Fk UHRyKENDYWxsSGVscGVyczo6QWRkcmVzcyhzY3JhdGNoLCBKU1dlYkFzc2VtYmx5TWVtb3J5Ojpv ZmZzZXRPZk1lbW9yeSgpKSwgc2NyYXRjaCk7Ci0gICAgICAgIGppdC5sb2FkUHRyKENDYWxsSGVs cGVyczo6QWRkcmVzcyhzY3JhdGNoLCBNZW1vcnk6Om9mZnNldE9mTWVtb3J5KCkpLCBtZW1vcnkt PnBpbm5lZFJlZ2lzdGVycygpLmJhc2VNZW1vcnlQb2ludGVyKTsKLQotICAgICAgICBqaXQubG9h ZDY0KENDYWxsSGVscGVyczo6QWRkcmVzcyhzY3JhdGNoLCBNZW1vcnk6Om9mZnNldE9mU2l6ZSgp KSwgc2NyYXRjaCk7Ci0gICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBtZW1vcnktPnBp bm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnMuc2l6ZSgpOyBpKyspIHsKLSAgICAgICAgICAg IEdQUlJlZyBzaXplUmVnID0gbWVtb3J5LT5waW5uZWRSZWdpc3RlcnMoKS5zaXplUmVnaXN0ZXJz W2ldLnNpemVSZWdpc3RlcjsKLSAgICAgICAgICAgIGppdC5tb3ZlKHNjcmF0Y2gsIHNpemVSZWcp OwotICAgICAgICAgICAgaml0LnN1YjY0KENDYWxsSGVscGVyczo6VHJ1c3RlZEltbTMyKG1lbW9y eS0+cGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVyc1tpXS5zaXplT2Zmc2V0KSwgc2l6ZVJl Zyk7Ci0gICAgICAgIH0KLSAgICB9KTsKLX0KLQotdm9pZCBCM0lSR2VuZXJhdG9yOjplbWl0UmVs b2FkUGlubmVkUmVnaXN0ZXJzKCkKLXsKLSAgICByZWxvYWRQaW5uZWRSZWdpc3RlcnMobV9wcm9j LCBtX2N1cnJlbnRCbG9jaywgbV9pbmZvLCBtX2luc3RhbmNlVmFsdWUpOwotfQotCi0KIGF1dG8g QjNJUkdlbmVyYXRvcjo6YWRkR3Jvd01lbW9yeShFeHByZXNzaW9uVHlwZSBkZWx0YSwgRXhwcmVz c2lvblR5cGUmIHJlc3VsdCkgLT4gUGFydGlhbFJlc3VsdAogewogICAgIGludDMyX3QgKCpncm93 TWVtb3J5KSAoRXhlY1N0YXRlKiwgaW50MzJfdCkgPSBbXSAoRXhlY1N0YXRlKiBleGVjLCBpbnQz Ml90IGRlbHRhKSAtPiBpbnQzMl90IHsKQEAgLTM4OSw3ICszOTksNiBAQCBhdXRvIEIzSVJHZW5l cmF0b3I6OmFkZEdyb3dNZW1vcnkoRXhwcmVzc2lvblR5cGUgZGVsdGEsIEV4cHJlc3Npb25UeXBl JiByZXN1bHQpCiAKICAgICAgICAgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBpbnN0YW5jZSA9IHZt LnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZTsKICAgICAgICAgSlNXZWJBc3NlbWJseU1lbW9yeSog d2FzbU1lbW9yeSA9IGluc3RhbmNlLT5tZW1vcnkoKTsKLSAgICAgICAgUkVMRUFTRV9BU1NFUlQo d2FzbU1lbW9yeSk7IC8vIFRoaXMgd291bGQgZmFpbCB2YWxpZGF0aW9uIG90aGVyd2lzZS4KIAog ICAgICAgICBpZiAoZGVsdGEgPCAwKQogICAgICAgICAgICAgcmV0dXJuIC0xOwpAQCAtNDA3LDIx ICs0MTYsMTkgQEAgYXV0byBCM0lSR2VuZXJhdG9yOjphZGRHcm93TWVtb3J5KEV4cHJlc3Npb25U eXBlIGRlbHRhLCBFeHByZXNzaW9uVHlwZSYgcmVzdWx0KQogICAgICAgICBtX2N1cnJlbnRCbG9j ay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KG1fcHJvYywgT3JpZ2luKCksIGJpdHdpc2VfY2Fz dDx2b2lkKj4oZ3Jvd01lbW9yeSkpLAogICAgICAgICBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3 PEIzOjpWYWx1ZT4obV9wcm9jLCBCMzo6RnJhbWVQb2ludGVyLCBPcmlnaW4oKSksIGRlbHRhKTsK IAotICAgIGVtaXRSZWxvYWRQaW5uZWRSZWdpc3RlcnMoKTsKKyAgICByZXN0b3JlV2ViQXNzZW1i bHlHbG9iYWxTdGF0ZShtX3ZtLCBtX2luZm8ubWVtb3J5LCBtX2luc3RhbmNlVmFsdWUsIG1fcHJv YywgbV9jdXJyZW50QmxvY2spOwogCiAgICAgcmV0dXJuIHsgfTsKIH0KIAogYXV0byBCM0lSR2Vu ZXJhdG9yOjphZGRDdXJyZW50TWVtb3J5KEV4cHJlc3Npb25UeXBlJiByZXN1bHQpIC0+IFBhcnRp YWxSZXN1bHQKIHsKLSAgICBWYWx1ZSoganNNZW1vcnkgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5k TmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQsIHBvaW50ZXJUeXBlKCksIE9yaWdpbigpLCBt X2luc3RhbmNlVmFsdWUsIEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZNZW1vcnkoKSk7 Ci0gICAgVmFsdWUqIHdhc21NZW1vcnkgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PE1lbW9y eVZhbHVlPihtX3Byb2MsIExvYWQsIHBvaW50ZXJUeXBlKCksIE9yaWdpbigpLCBqc01lbW9yeSwg SlNXZWJBc3NlbWJseU1lbW9yeTo6b2Zmc2V0T2ZNZW1vcnkoKSk7Ci0gICAgVmFsdWUqIHNpemUg PSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQsIEIz OjpJbnQ2NCwgT3JpZ2luKCksIHdhc21NZW1vcnksIE1lbW9yeTo6b2Zmc2V0T2ZTaXplKCkpOwor ICAgIGF1dG8gbWVtb3J5VmFsdWUgPSBnZXRNZW1vcnlCYXNlQW5kU2l6ZShtX3ZtLCBtX2luc3Rh bmNlVmFsdWUsIG1fcHJvYywgbV9jdXJyZW50QmxvY2spOwogCiAgICAgY29uc3RleHByIHVpbnQz Ml90IHNoaWZ0VmFsdWUgPSAxNjsKICAgICBzdGF0aWNfYXNzZXJ0KFBhZ2VDb3VudDo6cGFnZVNp emUgPT0gMSA8PCBzaGlmdFZhbHVlLCAiVGhpcyBtdXN0IGhvbGQgZm9yIHRoZSBjb2RlIGJlbG93 IHRvIGJlIGNvcnJlY3QuIik7CiAgICAgVmFsdWUqIG51bVBhZ2VzID0gbV9jdXJyZW50QmxvY2st PmFwcGVuZE5ldzxWYWx1ZT4obV9wcm9jLCBaU2hyLCBPcmlnaW4oKSwKLSAgICAgICAgc2l6ZSwg bV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxDb25zdDMyVmFsdWU+KG1fcHJvYywgT3JpZ2luKCks IHNoaWZ0VmFsdWUpKTsKKyAgICAgICAgbWVtb3J5VmFsdWUuc2l6ZSwgbV9jdXJyZW50QmxvY2st PmFwcGVuZE5ldzxDb25zdDMyVmFsdWU+KG1fcHJvYywgT3JpZ2luKCksIHNoaWZ0VmFsdWUpKTsK IAogICAgIHJlc3VsdCA9IG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8VmFsdWU+KG1fcHJvYywg VHJ1bmMsIE9yaWdpbigpLCBudW1QYWdlcyk7CiAKQEAgLTgzMiwyNiArODM5LDc1IEBAIGF1dG8g QjNJUkdlbmVyYXRvcjo6YWRkQ2FsbCh1aW50MzJfdCBmdW5jdGlvbkluZGV4LCBjb25zdCBTaWdu YXR1cmUqIHNpZ25hdHVyZSwKICAgICBBU1NFUlQoc2lnbmF0dXJlLT5hcmd1bWVudENvdW50KCkg PT0gYXJncy5zaXplKCkpOwogCiAgICAgVHlwZSByZXR1cm5UeXBlID0gc2lnbmF0dXJlLT5yZXR1 cm5UeXBlKCk7CisgICAgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+KiB1bmxpbmtlZFdh c21Ub1dhc21DYWxscyA9ICZtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzOwogCi0gICAgcmVzdWx0 ID0gd2FzbUNhbGxpbmdDb252ZW50aW9uKCkuc2V0dXBDYWxsKG1fcHJvYywgbV9jdXJyZW50Qmxv Y2ssIE9yaWdpbigpLCBhcmdzLCB0b0IzVHlwZShyZXR1cm5UeXBlKSwKLSAgICAgICAgWyZdIChQ YXRjaHBvaW50VmFsdWUqIHBhdGNocG9pbnQpIHsKLSAgICAgICAgICAgIHBhdGNocG9pbnQtPmVm ZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKLSAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVj dHMucmVhZHNQaW5uZWQgPSB0cnVlOworICAgIGlmIChtX2luZm8uaXNJbXBvcnRlZEZ1bmN0aW9u RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KSkgeworICAgICAgICAvLyBGSVhN RSBpbXBvcnRzIGNhbiBiZSBsaW5rZWQgaGVyZSwgaW5zdGVhZCBvZiBnZW5lcmF0aW5nIGEgcGF0 Y2hwb2ludCwgYmVjYXVzZSBhbGwgaW1wb3J0IHN0dWJzIGFyZSBnZW5lcmF0ZWQgYmVmb3JlIEIz IGNvbXBpbGF0aW9uIHN0YXJ0cy4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTE2NjQ2MgorICAgICAgICBFeHByZXNzaW9uVHlwZSBmdW5jdGlvbkltcG9ydCA9IG1fY3Vy cmVudEJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KG1fcHJvYywgTG9hZCwgcG9pbnRlclR5 cGUoKSwgT3JpZ2luKCksIG1faW5zdGFuY2VWYWx1ZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlOjpv ZmZzZXRPZkltcG9ydEZ1bmN0aW9uKGZ1bmN0aW9uSW5kZXgpKTsKKyAgICAgICAgRXhwcmVzc2lv blR5cGUganNUeXBlT2ZJbXBvcnQgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PE1lbW9yeVZh bHVlPihtX3Byb2MsIExvYWQ4WiwgT3JpZ2luKCksIGZ1bmN0aW9uSW1wb3J0LCBKU0NlbGw6OnR5 cGVJbmZvVHlwZU9mZnNldCgpKTsKKyAgICAgICAgVmFsdWUqIGlzV2FzbUNhbGwgPSBtX2N1cnJl bnRCbG9jay0+YXBwZW5kTmV3PFZhbHVlPihtX3Byb2MsIEVxdWFsLCBPcmlnaW4oKSwganNUeXBl T2ZJbXBvcnQsIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8Q29uc3QzMlZhbHVlPihtX3Byb2Ms IE9yaWdpbigpLCBXZWJBc3NlbWJseUZ1bmN0aW9uVHlwZSkpOwogCi0gICAgICAgICAgICBWZWN0 b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4qIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzID0gJm1f dW5saW5rZWRXYXNtVG9XYXNtQ2FsbHM7Ci0gICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5l cmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxw ZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7Ci0gICAgICAg ICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93U2NyYXRjaChqaXQp OworICAgICAgICBCYXNpY0Jsb2NrKiBpc1dhc21CbG9jayA9IG1fcHJvYy5hZGRCbG9jaygpOwor ICAgICAgICBCYXNpY0Jsb2NrKiBpc0pTQmxvY2sgPSBtX3Byb2MuYWRkQmxvY2soKTsKKyAgICAg ICAgQmFzaWNCbG9jayogY29udGludWF0aW9uID0gbV9wcm9jLmFkZEJsb2NrKCk7CisgICAgICAg IG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXdDb250cm9sVmFsdWUobV9wcm9jLCBCMzo6QnJhbmNo LCBPcmlnaW4oKSwgaXNXYXNtQ2FsbCwgRnJlcXVlbnRlZEJsb2NrKGlzV2FzbUJsb2NrKSwgRnJl cXVlbnRlZEJsb2NrKGlzSlNCbG9jaykpOworCisgICAgICAgIFZhbHVlKiB3YXNtQ2FsbFJlc3Vs dCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigpLnNldHVwQ2FsbChtX3Byb2MsIGlzV2FzbUJsb2Nr LCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0dXJuVHlwZSksCisgICAgICAgICAgICBbJl0g KFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkgeworICAgICAgICAgICAgICAgIHBhdGNocG9p bnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBv aW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBv aW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4 XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMm KSB7CisgICAgICAgICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBh bGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxs IGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICAgICAgICAgICAgICBqaXQuYWRkTGlua1Rhc2so W3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4XSAoTGlua0J1ZmZl ciYgbGlua0J1ZmZlcikgeworICAgICAgICAgICAgICAgICAgICAgICAgdW5saW5rZWRXYXNtVG9X YXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZmZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rpb25J bmRleCwgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbDo6VGFyZ2V0Ojp0b1dhc20gfSk7CisgICAgICAg ICAgICAgICAgICAgIH0pOworICAgICAgICAgICAgICAgIH0pOworICAgICAgICAgICAgfSk7Cisg ICAgICAgIFVwc2lsb25WYWx1ZSogd2FzbUNhbGxSZXN1bHRVcHNpbG9uID0gcmV0dXJuVHlwZSA9 PSBWb2lkID8gbnVsbHB0ciA6IGlzV2FzbUJsb2NrLT5hcHBlbmROZXc8VXBzaWxvblZhbHVlPiht X3Byb2MsIE9yaWdpbigpLCB3YXNtQ2FsbFJlc3VsdCk7CisgICAgICAgIGlzV2FzbUJsb2NrLT5h cHBlbmROZXdDb250cm9sVmFsdWUobV9wcm9jLCBKdW1wLCBPcmlnaW4oKSwgY29udGludWF0aW9u KTsKKworICAgICAgICBWYWx1ZSoganNDYWxsUmVzdWx0ID0gd2FzbUNhbGxpbmdDb252ZW50aW9u KCkuc2V0dXBDYWxsKG1fcHJvYywgaXNKU0Jsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUo cmV0dXJuVHlwZSksCisgICAgICAgICAgICBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2lu dCkgeworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0g dHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0g dHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2Vk V2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0 IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7CisgICAgICAgICAgICAgICAgICAgIEFs bG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAg ICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAg ICAgICAgICAgICAgICBqaXQuYWRkTGlua1Rhc2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBj YWxsLCBmdW5jdGlvbkluZGV4XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZlcikgeworICAgICAgICAg ICAgICAgICAgICAgICAgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZm ZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rpb25JbmRleCwgVW5saW5rZWRXYXNtVG9XYXNtQ2Fs bDo6VGFyZ2V0Ojp0b0pTIH0pOworICAgICAgICAgICAgICAgICAgICB9KTsKKyAgICAgICAgICAg ICAgICB9KTsKKyAgICAgICAgICAgIH0pOworICAgICAgICBVcHNpbG9uVmFsdWUqIGpzQ2FsbFJl c3VsdFVwc2lsb24gPSByZXR1cm5UeXBlID09IFZvaWQgPyBudWxscHRyIDogaXNKU0Jsb2NrLT5h cHBlbmROZXc8VXBzaWxvblZhbHVlPihtX3Byb2MsIE9yaWdpbigpLCBqc0NhbGxSZXN1bHQpOwor ICAgICAgICBpc0pTQmxvY2stPmFwcGVuZE5ld0NvbnRyb2xWYWx1ZShtX3Byb2MsIEp1bXAsIE9y aWdpbigpLCBjb250aW51YXRpb24pOwogCi0gICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpD YWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICBtX2N1cnJlbnRCbG9jayA9IGNvbnRpbnVh dGlvbjsKIAotICAgICAgICAgICAgICAgIGppdC5hZGRMaW5rVGFzayhbdW5saW5rZWRXYXNtVG9X YXNtQ2FsbHMsIGNhbGwsIGZ1bmN0aW9uSW5kZXhdIChMaW5rQnVmZmVyJiBsaW5rQnVmZmVyKSB7 Ci0gICAgICAgICAgICAgICAgICAgIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLT5hcHBlbmQoeyBs aW5rQnVmZmVyLmxvY2F0aW9uT2YoY2FsbCksIGZ1bmN0aW9uSW5kZXggfSk7CisgICAgICAgIGlm IChyZXR1cm5UeXBlID09IFZvaWQpCisgICAgICAgICAgICByZXN1bHQgPSBudWxscHRyOworICAg ICAgICBlbHNlIHsKKyAgICAgICAgICAgIHJlc3VsdCA9IGNvbnRpbnVhdGlvbi0+YXBwZW5kTmV3 PFZhbHVlPihtX3Byb2MsIFBoaSwgdG9CM1R5cGUocmV0dXJuVHlwZSksIE9yaWdpbigpKTsKKyAg ICAgICAgICAgIHdhc21DYWxsUmVzdWx0VXBzaWxvbi0+c2V0UGhpKHJlc3VsdCk7CisgICAgICAg ICAgICBqc0NhbGxSZXN1bHRVcHNpbG9uLT5zZXRQaGkocmVzdWx0KTsKKyAgICAgICAgfQorCisg ICAgICAgIC8vIFRoZSBjYWxsIGNvdWxkIGhhdmUgYmVlbiB0byBhbm90aGVyIFdlYkFzc2VtYmx5 IGluc3RhbmNlLCBhbmQgLyBvciBjb3VsZCBoYXZlIG1vZGlmaWVkIG91ciBNZW1vcnkuCisgICAg ICAgIHJlc3RvcmVXZWJBc3NlbWJseUdsb2JhbFN0YXRlKG1fdm0sIG1faW5mby5tZW1vcnksIG1f aW5zdGFuY2VWYWx1ZSwgbV9wcm9jLCBjb250aW51YXRpb24pOworICAgIH0gZWxzZSB7CisgICAg ICAgIHJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigpLnNldHVwQ2FsbChtX3Byb2MsIG1f Y3VycmVudEJsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0dXJuVHlwZSksCisgICAg ICAgICAgICBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkgeworICAgICAgICAgICAg ICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAg ICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAg ICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBm dW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVy YXRpb25QYXJhbXMmKSB7CisgICAgICAgICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVn aXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAgICAgICAgICAgICAgQ0NhbGxI ZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICAgICAgICAgICAgICBqaXQu YWRkTGlua1Rhc2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4 XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZlcikgeworICAgICAgICAgICAgICAgICAgICAgICAgdW5s aW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZmZXIubG9jYXRpb25PZihjYWxs KSwgZnVuY3Rpb25JbmRleCwgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbDo6VGFyZ2V0Ojp0b1dhc20g fSk7CisgICAgICAgICAgICAgICAgICAgIH0pOwogICAgICAgICAgICAgICAgIH0pOwogICAgICAg ICAgICAgfSk7Ci0gICAgICAgIH0pOwotCi0gICAgaWYgKGZ1bmN0aW9uSW5kZXggPCBtX2luZm8u aW1wb3J0RnVuY3Rpb25Db3VudCgpKQotICAgICAgICBlbWl0UmVsb2FkUGlubmVkUmVnaXN0ZXJz KCk7CisgICAgfQogCiAgICAgcmV0dXJuIHsgfTsKIH0KQEAgLTkyOSw3ICs5ODUsOCBAQCBhdXRv IEIzSVJHZW5lcmF0b3I6OmFkZENhbGxJbmRpcmVjdChjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVy ZSwgU2lnbmF0dXJlSW5kZXggcwogICAgICAgICAgICAgfSk7CiAgICAgICAgIH0pOwogCi0gICAg ZW1pdFJlbG9hZFBpbm5lZFJlZ2lzdGVycygpOworICAgIC8vIFRoZSBjYWxsIGNvdWxkIGhhdmUg YmVlbiB0byBhbm90aGVyIFdlYkFzc2VtYmx5IGluc3RhbmNlLCBhbmQgLyBvciBjb3VsZCBoYXZl IG1vZGlmaWVkIG91ciBNZW1vcnkuCisgICAgcmVzdG9yZVdlYkFzc2VtYmx5R2xvYmFsU3RhdGUo bV92bSwgbV9pbmZvLm1lbW9yeSwgbV9pbnN0YW5jZVZhbHVlLCBtX3Byb2MsIG1fY3VycmVudEJs b2NrKTsKIAogICAgIHJldHVybiB7IH07CiB9CkBAIC05OTgsMTIgKzEwNTUsMTAgQEAgc3RhdGlj IHZvaWQgY3JlYXRlSlNUb1dhc21XcmFwcGVyKFZNJiB2bSwgQ29tcGlsYXRpb25Db250ZXh0JiBj b21waWxhdGlvbkNvbnRleHQKICAgICAgICAgfSk7CiAgICAgfQogCi0gICAgLy8gTW92ZSBtZW1v cnkgdmFsdWVzIHRvIHRoZSBhcHByb3JpYXRlIHBsYWNlcywgaWYgbmVlZGVkLgotICAgIHsKLSAg ICAgICAgVmFsdWUqIGluc3RhbmNlID0gYmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4ocHJv YywgTG9hZCwgcG9pbnRlclR5cGUoKSwgT3JpZ2luKCksCi0gICAgICAgICAgICBibG9jay0+YXBw ZW5kTmV3PENvbnN0UHRyVmFsdWU+KHByb2MsIE9yaWdpbigpLCAmdm0udG9wSlNXZWJBc3NlbWJs eUluc3RhbmNlKSk7Ci0gICAgICAgIHJlbG9hZFBpbm5lZFJlZ2lzdGVycyhwcm9jLCBibG9jaywg aW5mbywgaW5zdGFuY2UpOwotICAgIH0KKyAgICAvLyBGSVhNRSBUaGUgaW5zdGFuY2UgaXMgY3Vy cmVudGx5IHNldCBieSB0aGUgQysrIGNvZGUgaW4gV2ViQXNzZW1ibHlGdW5jdGlvbjo6Y2FsbC4g V2Ugc2hvdWxkbid0IGdvIHRocm91Z2ggdGhlIGV4dHJhIEMrKyBob29wLiBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY2NDg2CisgICAgVmFsdWUqIGluc3RhbmNlID0g YmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4ocHJvYywgTG9hZCwgcG9pbnRlclR5cGUoKSwg T3JpZ2luKCksCisgICAgICAgIGJsb2NrLT5hcHBlbmROZXc8Q29uc3RQdHJWYWx1ZT4ocHJvYywg T3JpZ2luKCksICZ2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UpKTsKKyAgICByZXN0b3JlV2Vi QXNzZW1ibHlHbG9iYWxTdGF0ZSh2bSwgaW5mby5tZW1vcnksIGluc3RhbmNlLCBwcm9jLCBibG9j ayk7CiAKICAgICAvLyBHZXQgb3VyIGFyZ3VtZW50cy4KICAgICBWZWN0b3I8VmFsdWUqPiBhcmd1 bWVudHM7CkBAIC0xMDQ2LDcgKzExMDEsNyBAQCBzdGF0aWMgdm9pZCBjcmVhdGVKU1RvV2FzbVdy YXBwZXIoVk0mIHZtLCBDb21waWxhdGlvbkNvbnRleHQmIGNvbXBpbGF0aW9uQ29udGV4dAogICAg IGZ1bmN0aW9uLmpzVG9XYXNtRW50cnlwb2ludC5jYWxsZWVTYXZlUmVnaXN0ZXJzID0gcHJvYy5j YWxsZWVTYXZlUmVnaXN0ZXJzKCk7CiB9CiAKLUV4cGVjdGVkPHN0ZDo6dW5pcXVlX3B0cjxXYXNt SW50ZXJuYWxGdW5jdGlvbj4sIFN0cmluZz4gcGFyc2VBbmRDb21waWxlKFZNJiB2bSwgQ29tcGls YXRpb25Db250ZXh0JiBjb21waWxhdGlvbkNvbnRleHQsIGNvbnN0IHVpbnQ4X3QqIGZ1bmN0aW9u U3RhcnQsIHNpemVfdCBmdW5jdGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUs IFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMs IGNvbnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYgZnVuY3Rpb25JbmRleFNwYWNlLCBj b25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgdW5zaWduZWQgb3B0TGV2ZWwpCitFeHBlY3Rl ZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbUludGVybmFsRnVuY3Rpb24+LCBTdHJpbmc+IHBhcnNlQW5k Q29tcGlsZShWTSYgdm0sIENvbXBpbGF0aW9uQ29udGV4dCYgY29tcGlsYXRpb25Db250ZXh0LCBj b25zdCB1aW50OF90KiBmdW5jdGlvblN0YXJ0LCBzaXplX3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0 IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mIHVu bGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgY29u c3QgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiYgbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVl ZFNpZ25hdHVyZUluZGljZXMsIHVuc2lnbmVkIG9wdExldmVsKQogewogICAgIGF1dG8gcmVzdWx0 ID0gc3RkOjptYWtlX3VuaXF1ZTxXYXNtSW50ZXJuYWxGdW5jdGlvbj4oKTsKIApAQCAtMTA1NCw4 ICsxMTA5LDggQEAgRXhwZWN0ZWQ8c3RkOjp1bmlxdWVfcHRyPFdhc21JbnRlcm5hbEZ1bmN0aW9u PiwgU3RyaW5nPiBwYXJzZUFuZENvbXBpbGUoVk0mIHZtLAogICAgIGNvbXBpbGF0aW9uQ29udGV4 dC53YXNtRW50cnlwb2ludEpJVCA9IHN0ZDo6bWFrZV91bmlxdWU8Q0NhbGxIZWxwZXJzPigmdm0p OwogCiAgICAgUHJvY2VkdXJlIHByb2NlZHVyZTsKLSAgICBCM0lSR2VuZXJhdG9yIGNvbnRleHQo dm0sIGluZm8sIHByb2NlZHVyZSwgcmVzdWx0LmdldCgpLCB1bmxpbmtlZFdhc21Ub1dhc21DYWxs cywgZnVuY3Rpb25JbmRleFNwYWNlKTsKLSAgICBGdW5jdGlvblBhcnNlcjxCM0lSR2VuZXJhdG9y PiBwYXJzZXIoJnZtLCBjb250ZXh0LCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2ln bmF0dXJlLCBmdW5jdGlvbkluZGV4U3BhY2UsIGluZm8pOworICAgIEIzSVJHZW5lcmF0b3IgY29u dGV4dCh2bSwgaW5mbywgcHJvY2VkdXJlLCByZXN1bHQuZ2V0KCksIHVubGlua2VkV2FzbVRvV2Fz bUNhbGxzKTsKKyAgICBGdW5jdGlvblBhcnNlcjxCM0lSR2VuZXJhdG9yPiBwYXJzZXIoJnZtLCBj b250ZXh0LCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBpbmZvLCBt b2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcyk7CiAgICAgV0FT TV9GQUlMX0lGX0hFTFBFUl9GQUlMUyhwYXJzZXIucGFyc2UoKSk7CiAKICAgICBwcm9jZWR1cmUu cmVzZXRSZWFjaGFiaWxpdHkoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21CM0lSR2VuZXJhdG9yLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt QjNJUkdlbmVyYXRvci5oCmluZGV4IGI1YzlmNDYuLjI0OWQ1NzggMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmgKKysrIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuaApAQCAtNDcsNyArNDcsNyBAQCBz dHJ1Y3QgQ29tcGlsYXRpb25Db250ZXh0IHsKICAgICBDQ2FsbEhlbHBlcnM6OkNhbGwganNFbnRy eXBvaW50VG9XYXNtRW50cnlwb2ludENhbGw7CiB9OwogCi1FeHBlY3RlZDxzdGQ6OnVuaXF1ZV9w dHI8V2FzbUludGVybmFsRnVuY3Rpb24+LCBTdHJpbmc+IHBhcnNlQW5kQ29tcGlsZShWTSYsIENv bXBpbGF0aW9uQ29udGV4dCYsIGNvbnN0IHVpbnQ4X3QqLCBzaXplX3QsIGNvbnN0IFNpZ25hdHVy ZSosIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYsIGNvbnN0IEltbXV0YWJsZUZ1bmN0 aW9uSW5kZXhTcGFjZSYsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiwgdW5zaWduZWQgb3B0TGV2 ZWwgPSAxKTsKK0V4cGVjdGVkPHN0ZDo6dW5pcXVlX3B0cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4s IFN0cmluZz4gcGFyc2VBbmRDb21waWxlKFZNJiwgQ29tcGlsYXRpb25Db250ZXh0JiwgY29uc3Qg dWludDhfdCosIHNpemVfdCwgY29uc3QgU2lnbmF0dXJlKiwgVmVjdG9yPFVubGlua2VkV2FzbVRv V2FzbUNhbGw+JiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mLCBjb25zdCBWZWN0b3I8U2lnbmF0 dXJlSW5kZXg+JiwgdW5zaWduZWQgb3B0TGV2ZWwgPSAxKTsKIAogfSB9IC8vIG5hbWVzcGFjZSBK U0M6Oldhc20KIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJp bmRpbmcuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuY3BwCmlu ZGV4IDBlNTkyNDcuLjliYjZhNzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21CaW5kaW5nLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt QmluZGluZy5jcHAKQEAgLTM2LDEzICszNiwyMSBAQAogCiBuYW1lc3BhY2UgSlNDIHsgbmFtZXNw YWNlIFdhc20gewogCi1XYXNtVG9KU1N0dWIgaW1wb3J0U3R1YkdlbmVyYXRvcihWTSogdm0sIEJh ZzxDYWxsTGlua0luZm8+JiBjYWxsTGlua0luZm9zLCBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJ bmRleCwgdW5zaWduZWQgaW1wb3J0SW5kZXgpCit0eXBlZGVmIEFzc2VtYmx5SGVscGVycyBKSVQ7 CisKK3N0YXRpYyB2b2lkIG1hdGVyaWFsaXplSW1wb3J0SlNDZWxsKFZNKiB2bSwgSklUJiBqaXQs IHVuc2lnbmVkIGltcG9ydEluZGV4LCBHUFJSZWcgZ3ByKQoreworICAgIC8vIEVhY2ggSlMgLT4g d2FzbSBlbnRyeSBzZXRzIHRoZSBXZWJBc3NlbWJseS5JbnN0YW5jZSB3aG9zZSBleHBvcnQgaXMg YmVpbmcgY2FsbGVkLiBXZSdyZSBjYWxsaW5nIG91dCBvZiB0aGlzIEluc3RhbmNlLCBhbmQgY2Fu IHRoZXJlZm9yZSBmaWd1cmUgb3V0IHRoZSBpbXBvcnQgYmVpbmcgY2FsbGVkLgorICAgIGppdC5s b2FkUHRyKCZ2bS0+dG9wSlNXZWJBc3NlbWJseUluc3RhbmNlLCBncHIpOworICAgIGppdC5sb2Fk UHRyKEpJVDo6QWRkcmVzcyhncHIsIEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZJbXBv cnRGdW5jdGlvbihpbXBvcnRJbmRleCkpLCBncHIpOworfQorCitzdGF0aWMgTWFjcm9Bc3NlbWJs ZXJDb2RlUmVmIHdhc21Ub0pTKFZNKiB2bSwgQmFnPENhbGxMaW5rSW5mbz4mIGNhbGxMaW5rSW5m b3MsIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4LCB1bnNpZ25lZCBpbXBvcnRJbmRleCkK IHsKICAgICBjb25zdCBXYXNtQ2FsbGluZ0NvbnZlbnRpb24mIHdhc21DQyA9IHdhc21DYWxsaW5n Q29udmVudGlvbigpOwogICAgIGNvbnN0IEpTQ0NhbGxpbmdDb252ZW50aW9uJiBqc0NDID0ganNj Q2FsbGluZ0NvbnZlbnRpb24oKTsKICAgICBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFNp Z25hdHVyZUluZm9ybWF0aW9uOjpnZXQodm0sIHNpZ25hdHVyZUluZGV4KTsKICAgICB1bnNpZ25l ZCBhcmdDb3VudCA9IHNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpOwotICAgIHR5cGVkZWYgQXNz ZW1ibHlIZWxwZXJzIEpJVDsKICAgICBKSVQgaml0KHZtLCBudWxscHRyKTsKIAogICAgIC8vIEJl bG93LCB3ZSBhc3N1bWUgdGhhdCB0aGUgSlMgY2FsbGluZyBjb252ZW50aW9uIGlzIGFsd2F5cyBv biB0aGUgc3RhY2suCkBAIC0xMzgsOSArMTQ2LDcgQEAgV2FzbVRvSlNTdHViIGltcG9ydFN0dWJH ZW5lcmF0b3IoVk0qIHZtLCBCYWc8Q2FsbExpbmtJbmZvPiYgY2FsbExpbmtJbmZvcywgU2lnbmEK ICAgICBHUFJSZWcgaW1wb3J0SlNDZWxsR1BSUmVnID0gR1BSSW5mbzo6cmVnVDA7IC8vIENhbGxl ZSBuZWVkcyB0byBiZSBpbiByZWdUMCBmb3Igc2xvdyBwYXRoIGJlbG93LgogICAgIEFTU0VSVCgh d2FzbUNDLm1fY2FsbGVlU2F2ZVJlZ2lzdGVycy5nZXQoaW1wb3J0SlNDZWxsR1BSUmVnKSk7CiAK LSAgICAvLyBFYWNoIEpTIC0+IHdhc20gZW50cnkgc2V0cyB0aGUgV2ViQXNzZW1ibHkuSW5zdGFu Y2Ugd2hvc2UgZXhwb3J0IGlzIGJlaW5nIGNhbGxlZC4gV2UncmUgY2FsbGluZyBvdXQgb2YgdGhp cyBJbnN0YW5jZSwgYW5kIGNhbiB0aGVyZWZvcmUgZmlndXJlIG91dCB0aGUgaW1wb3J0IGJlaW5n IGNhbGxlZC4KLSAgICBqaXQubG9hZFB0cigmdm0tPnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZSwg aW1wb3J0SlNDZWxsR1BSUmVnKTsKLSAgICBqaXQubG9hZFB0cihKSVQ6OkFkZHJlc3MoaW1wb3J0 SlNDZWxsR1BSUmVnLCBKU1dlYkFzc2VtYmx5SW5zdGFuY2U6Om9mZnNldE9mSW1wb3J0RnVuY3Rp b24oaW1wb3J0SW5kZXgpKSwgaW1wb3J0SlNDZWxsR1BSUmVnKTsKKyAgICBtYXRlcmlhbGl6ZUlt cG9ydEpTQ2VsbCh2bSwgaml0LCBpbXBvcnRJbmRleCwgaW1wb3J0SlNDZWxsR1BSUmVnKTsKIAog ICAgIHVpbnQ2NF90IHRoaXNBcmd1bWVudCA9IFZhbHVlVW5kZWZpbmVkOyAvLyBGSVhNRSB3aGF0 IGRvZXMgdGhlIFdlYkFzc2VtYmx5IHNwZWMgc2F5IHRoaXMgc2hvdWxkIGJlPyBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1NDcxCiAgICAgaml0LnN0b3JlNjQoaW1w b3J0SlNDZWxsR1BSUmVnLCBjYWxsZWVGcmFtZS53aXRoT2Zmc2V0KENhbGxGcmFtZVNsb3Q6OmNh bGxlZSAqIHN0YXRpY19jYXN0PGludD4oc2l6ZW9mKFJlZ2lzdGVyKSkpKTsKQEAgLTIzMSw3ICsy MzcsNTYgQEAgV2FzbVRvSlNTdHViIGltcG9ydFN0dWJHZW5lcmF0b3IoVk0qIHZtLCBCYWc8Q2Fs bExpbmtJbmZvPiYgY2FsbExpbmtJbmZvcywgU2lnbmEKICAgICBDb2RlTG9jYXRpb25MYWJlbCBo b3RQYXRoQmVnaW4ocGF0Y2hCdWZmZXIubG9jYXRpb25PZih0YXJnZXRUb0NoZWNrKSk7CiAgICAg Q29kZUxvY2F0aW9uTmVhckNhbGwgaG90UGF0aE90aGVyID0gcGF0Y2hCdWZmZXIubG9jYXRpb25P Zk5lYXJDYWxsKGZhc3RDYWxsKTsKICAgICBjYWxsTGlua0luZm8tPnNldENhbGxMb2NhdGlvbnMo Y2FsbFJldHVybkxvY2F0aW9uLCBob3RQYXRoQmVnaW4sIGhvdFBhdGhPdGhlcik7Ci0gICAgcmV0 dXJuIEZJTkFMSVpFX0NPREUocGF0Y2hCdWZmZXIsICgiV2ViQXNzZW1ibHkgaW1wb3J0WyVpXSBz dHViIGZvciBzaWduYXR1cmUgJWkiLCBpbXBvcnRJbmRleCwgc2lnbmF0dXJlSW5kZXgpKTsKKyAg ICBTdHJpbmcgc2lnbmF0dXJlRGVzY3JpcHRpb24gPSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0 KHZtLCBzaWduYXR1cmVJbmRleCktPnRvU3RyaW5nKCk7CisgICAgcmV0dXJuIEZJTkFMSVpFX0NP REUocGF0Y2hCdWZmZXIsICgiV2ViQXNzZW1ibHktPkphdmFTY3JpcHQgaW1wb3J0WyVpXSAlcyIs IGltcG9ydEluZGV4LCBzaWduYXR1cmVEZXNjcmlwdGlvbi5hc2NpaSgpLmRhdGEoKSkpOworfQor CitzdGF0aWMgTWFjcm9Bc3NlbWJsZXJDb2RlUmVmIHdhc21Ub1dhc20oVk0qIHZtLCB1bnNpZ25l ZCBpbXBvcnRJbmRleCkKK3sKKyAgICBjb25zdCBQaW5uZWRSZWdpc3RlckluZm8mIHBpbm5lZFJl Z3MgPSBQaW5uZWRSZWdpc3RlckluZm86OmdldCgpOworICAgIEpJVCBqaXQodm0sIG51bGxwdHIp OworCisgICAgR1BSUmVnIHNjcmF0Y2ggPSBHUFJJbmZvOjpub25QcmVzZXJ2ZWROb25Bcmd1bWVu dEdQUjsKKworICAgIC8vIEIzJ3MgY2FsbCBjb2RlZ2VuIGVuc3VyZXMgdGhhdCB0aGUgSlNDZWxs IGlzIGEgV2ViQXNzZW1ibHlGdW5jdGlvbi4KKyAgICBtYXRlcmlhbGl6ZUltcG9ydEpTQ2VsbCh2 bSwgaml0LCBpbXBvcnRJbmRleCwgc2NyYXRjaCk7CisKKyAgICAvLyBHZXQgdGhlIGNhbGxlZSdz IFdlYkFzc2VtYmx5Lkluc3RhbmNlIGFuZCBzZXQgaXQgYXMgdm0udG9wSlNXZWJBc3NlbWJseUlu c3RhbmNlLiBUaGUgY2FsbGVyIHdpbGwgdGFrZSBjYXJlIG9mIHJlc3RvcmluZyBpdHMgb3duIElu c3RhbmNlLgorICAgIEdQUlJlZyBiYXNlTWVtb3J5ID0gcGlubmVkUmVncy5iYXNlTWVtb3J5UG9p bnRlcjsKKyAgICBBU1NFUlQoYmFzZU1lbW9yeSAhPSBzY3JhdGNoKTsKKyAgICBqaXQubG9hZFB0 cihKSVQ6OkFkZHJlc3Moc2NyYXRjaCwgV2ViQXNzZW1ibHlGdW5jdGlvbjo6b2Zmc2V0T2ZJbnN0 YW5jZSgpKSwgYmFzZU1lbW9yeSk7IC8vIEluc3RhbmNlKi4KKyAgICBqaXQuc3RvcmVQdHIoYmFz ZU1lbW9yeSwgJnZtLT50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UpOworCisgICAgLy8gRklYTUUg dGhlIGZvbGxvd2luZyBjb2RlIGFzc3VtZXMgdGhhdCBhbGwgV2ViQXNzZW1ibHkuSW5zdGFuY2Ug aGF2ZSB0aGUgc2FtZSBwaW5uZWQgcmVnaXN0ZXJzLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTYyOTUyCisgICAgLy8gU2V0IHVwIHRoZSBjYWxsZWUncyBiYXNlTWVt b3J5IHJlZ2lzdGVyIGFzIHdlbGwgYXMgdGhlIG1lbW9yeSBzaXplIHJlZ2lzdGVycy4KKyAgICBq aXQubG9hZFB0cihKSVQ6OkFkZHJlc3MoYmFzZU1lbW9yeSwgSlNXZWJBc3NlbWJseUluc3RhbmNl OjpvZmZzZXRPZk1lbW9yeSgpKSwgYmFzZU1lbW9yeSk7IC8vIEpTV2ViQXNzZW1ibHlNZW1vcnkq LgorICAgIGNvbnN0IGF1dG8mIHNpemVSZWdzID0gcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzOwor ICAgIEFTU0VSVChzaXplUmVncy5zaXplKCkgPj0gMSk7CisgICAgQVNTRVJUKHNpemVSZWdzWzBd LnNpemVSZWdpc3RlciAhPSBiYXNlTWVtb3J5KTsKKyAgICBBU1NFUlQoc2l6ZVJlZ3NbMF0uc2l6 ZVJlZ2lzdGVyICE9IHNjcmF0Y2gpOworICAgIEFTU0VSVCghc2l6ZVJlZ3NbMF0uc2l6ZU9mZnNl dCk7IC8vIFRoZSBmb2xsb3dpbmcgY29kZSBhc3N1bWVzIHdlIHN0YXJ0IGF0IDAsIGFuZCBjYWxj dWxhdGVzIHN1YnNlcXVlbnQgc2l6ZSByZWdpc3RlcnMgcmVsYXRpdmUgdG8gMC4KKyAgICBqaXQu bG9hZFB0cihKSVQ6OkFkZHJlc3MoYmFzZU1lbW9yeSwgSlNXZWJBc3NlbWJseU1lbW9yeTo6b2Zm c2V0T2ZTaXplKCkpLCBzaXplUmVnc1swXS5zaXplUmVnaXN0ZXIpOyAvLyBNZW1vcnkgc2l6ZS4K KyAgICBqaXQubG9hZFB0cihKSVQ6OkFkZHJlc3MoYmFzZU1lbW9yeSwgSlNXZWJBc3NlbWJseU1l bW9yeTo6b2Zmc2V0T2ZNZW1vcnkoKSksIGJhc2VNZW1vcnkpOyAvLyBXYXNtTWVtb3J5Ojp2b2lk Ki4KKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAxOyBpIDwgc2l6ZVJlZ3Muc2l6ZSgpOyArK2kpIHsK KyAgICAgICAgQVNTRVJUKHNpemVSZWdzW2ldLnNpemVSZWdpc3RlciAhPSBiYXNlTWVtb3J5KTsK KyAgICAgICAgQVNTRVJUKHNpemVSZWdzW2ldLnNpemVSZWdpc3RlciAhPSBzY3JhdGNoKTsKKyAg ICAgICAgaml0LmFkZDY0KEpJVDo6VHJ1c3RlZEltbTMyKC1zaXplUmVnc1tpXS5zaXplT2Zmc2V0 KSwgc2l6ZVJlZ3NbMF0uc2l6ZVJlZ2lzdGVyLCBzaXplUmVnc1sxXS5zaXplUmVnaXN0ZXIpOwor ICAgIH0KKworICAgIC8vIFRhaWwgY2FsbCBpbnRvIHRoZSBjYWxsZWUgV2ViQXNzZW1ibHkgZnVu Y3Rpb24uCisgICAgaml0LmxvYWRQdHIoSklUOjpBZGRyZXNzKHNjcmF0Y2gsIFdlYkFzc2VtYmx5 RnVuY3Rpb246Om9mZnNldE9mV2FzbUVudHJ5UG9pbnRDb2RlKCkpLCBzY3JhdGNoKTsKKyAgICBq aXQuanVtcChzY3JhdGNoKTsKKworICAgIExpbmtCdWZmZXIgcGF0Y2hCdWZmZXIoKnZtLCBqaXQs IEdMT0JBTF9USFVOS19JRCk7CisgICAgcmV0dXJuIEZJTkFMSVpFX0NPREUocGF0Y2hCdWZmZXIs ICgiV2ViQXNzZW1ibHktPldlYkFzc2VtYmx5IGltcG9ydFslaV0iLCBpbXBvcnRJbmRleCkpOwor fQorCitXYXNtRXhpdFN0dWJzIGV4aXRTdHViR2VuZXJhdG9yKFZNKiB2bSwgQmFnPENhbGxMaW5r SW5mbz4mIGNhbGxMaW5rSW5mb3MsIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4LCB1bnNp Z25lZCBpbXBvcnRJbmRleCkKK3sKKyAgICBXYXNtRXhpdFN0dWJzIHN0dWJzOworICAgIHN0dWJz Lndhc21Ub0pTID0gd2FzbVRvSlModm0sIGNhbGxMaW5rSW5mb3MsIHNpZ25hdHVyZUluZGV4LCBp bXBvcnRJbmRleCk7CisgICAgc3R1YnMud2FzbVRvV2FzbSA9IHdhc21Ub1dhc20odm0sIGltcG9y dEluZGV4KTsKKyAgICByZXR1cm4gc3R1YnM7CiB9CiAKIH0gfSAvLyBuYW1lc3BhY2UgSlNDOjpX YXNtCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5o IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuaAppbmRleCBmZDdlMDNk Li40MDIxZjE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQmlu ZGluZy5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmgKQEAg LTM4LDcgKzM4LDcgQEAgY2xhc3MgQ2FsbExpbmtJbmZvOwogCiBuYW1lc3BhY2UgV2FzbSB7CiAK LVdhc21Ub0pTU3R1YiBpbXBvcnRTdHViR2VuZXJhdG9yKFZNKiwgQmFnPENhbGxMaW5rSW5mbz4m LCBTaWduYXR1cmVJbmRleCwgdW5zaWduZWQpOworV2FzbUV4aXRTdHVicyBleGl0U3R1YkdlbmVy YXRvcihWTSosIEJhZzxDYWxsTGlua0luZm8+JiwgU2lnbmF0dXJlSW5kZXgsIHVuc2lnbmVkKTsK IAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbUZvcm1hdC5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbUZvcm1hdC5oCmluZGV4IGNiMmJlNTUuLjIzZDhlZDMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21Gb3JtYXQuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtRm9ybWF0LmgKQEAgLTIyMiw3ICsyMjIsNiBAQCBwcml2YXRlOgogfTsKIAog c3RydWN0IE1vZHVsZUluZm9ybWF0aW9uIHsKLSAgICBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+IHNp Z25hdHVyZUluZGljZXM7CiAgICAgVmVjdG9yPEltcG9ydD4gaW1wb3J0czsKICAgICBWZWN0b3I8 U2lnbmF0dXJlSW5kZXg+IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlczsKICAgICBWZWN0 b3I8U2lnbmF0dXJlSW5kZXg+IGludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzOwpAQCAt MjM2LDYgKzIzNSwxOCBAQCBzdHJ1Y3QgTW9kdWxlSW5mb3JtYXRpb24gewogICAgIFRhYmxlSW5m b3JtYXRpb24gdGFibGVJbmZvcm1hdGlvbjsKICAgICBWZWN0b3I8R2xvYmFsPiBnbG9iYWxzOwog ICAgIHVuc2lnbmVkIGZpcnN0SW50ZXJuYWxHbG9iYWwgeyAwIH07CisgICAgc2l6ZV90IGZ1bmN0 aW9uSW5kZXhTcGFjZVNpemUoKSBjb25zdCB7IHJldHVybiBpbXBvcnRGdW5jdGlvblNpZ25hdHVy ZUluZGljZXMuc2l6ZSgpICsgaW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXMuc2l6ZSgp OyB9CisgICAgYm9vbCBpc0ltcG9ydGVkRnVuY3Rpb25Gcm9tRnVuY3Rpb25JbmRleFNwYWNlKHNp emVfdCBmdW5jdGlvbkluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgQVNTRVJUKGZ1bmN0aW9u SW5kZXggPCBmdW5jdGlvbkluZGV4U3BhY2VTaXplKCkpOworICAgICAgICByZXR1cm4gZnVuY3Rp b25JbmRleCA8IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCk7CisgICAgfQor ICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShz aXplX3QgZnVuY3Rpb25JbmRleCkgY29uc3QKKyAgICB7CisgICAgICAgIHJldHVybiBpc0ltcG9y dGVkRnVuY3Rpb25Gcm9tRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgpCisgICAgICAg ICAgICA/IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4XQorICAg ICAgICAgICAgOiBpbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4 IC0gaW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnNpemUoKV07CisgICAgfQogCiAgICAg dWludDMyX3QgaW1wb3J0RnVuY3Rpb25Db3VudCgpIGNvbnN0IHsgcmV0dXJuIGltcG9ydEZ1bmN0 aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCk7IH0KICAgICBib29sIGhhc01lbW9yeSgpIGNvbnN0 IHsgcmV0dXJuICEhbWVtb3J5OyB9CkBAIC0yNDYsNiArMjU3LDEwIEBAIHN0cnVjdCBNb2R1bGVJ bmZvcm1hdGlvbiB7CiBzdHJ1Y3QgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbCB7CiAgICAgQ29kZUxv Y2F0aW9uQ2FsbCBjYWxsTG9jYXRpb247CiAgICAgc2l6ZV90IGZ1bmN0aW9uSW5kZXg7CisgICAg ZW51bSBjbGFzcyBUYXJnZXQgOiB1aW50OF90IHsKKyAgICAgICAgdG9KUywKKyAgICAgICAgdG9X YXNtLAorICAgIH0gdGFyZ2V0OwogfTsKIAogc3RydWN0IEVudHJ5cG9pbnQgewpAQCAtMjYxLDcg KzI3NiwxMCBAQCBzdHJ1Y3QgV2FzbUludGVybmFsRnVuY3Rpb24gewogICAgIEVudHJ5cG9pbnQg anNUb1dhc21FbnRyeXBvaW50OwogfTsKIAotdHlwZWRlZiBNYWNyb0Fzc2VtYmxlckNvZGVSZWYg V2FzbVRvSlNTdHViOworc3RydWN0IFdhc21FeGl0U3R1YnMgeworICAgIE1hY3JvQXNzZW1ibGVy Q29kZVJlZiB3YXNtVG9KUzsKKyAgICBNYWNyb0Fzc2VtYmxlckNvZGVSZWYgd2FzbVRvV2FzbTsK K307CiAKIC8vIFdlYkFzc2VtYmx5IGRpcmVjdCBjYWxscyBhbmQgY2FsbF9pbmRpcmVjdCB1c2Ug aW5kaWNlcyBpbnRvICJmdW5jdGlvbiBpbmRleCBzcGFjZSIuIFRoaXMgc3BhY2Ugc3RhcnRzIHdp dGggYWxsIGltcG9ydHMsIGFuZCB0aGVuIGFsbCBpbnRlcm5hbCBmdW5jdGlvbnMuCiAvLyBDYWxs YWJsZUZ1bmN0aW9uIGFuZCBGdW5jdGlvbkluZGV4U3BhY2UgYXJlIG9ubHkgbWVhbnQgYXMgZmFz dCBsb29rdXAgdGFibGVzIGZvciB0aGVzZSBvcGNvZGVzLCBhbmQgZG8gbm90IG93biBjb2RlLgpA QCAtMjgwLDEyICsyOTgsNiBAQCBzdHJ1Y3QgQ2FsbGFibGVGdW5jdGlvbiB7CiB9OwogdHlwZWRl ZiBWZWN0b3I8Q2FsbGFibGVGdW5jdGlvbj4gRnVuY3Rpb25JbmRleFNwYWNlOwogCi0KLXN0cnVj dCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UgewotICAgIE1hbGxvY1B0cjxDYWxsYWJsZUZ1 bmN0aW9uPiBidWZmZXI7Ci0gICAgc2l6ZV90IHNpemU7Ci19OwotCiB9IH0gLy8gbmFtZXNwYWNl IEpTQzo6V2FzbQogCiAjZW5kaWYgLy8gRU5BQkxFKFdFQkFTU0VNQkxZKQpkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmggYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rpb25QYXJzZXIuaAppbmRleCA1MjAxMGRjLi4z MTEwNWQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rp b25QYXJzZXIuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rpb25Q YXJzZXIuaApAQCAtNDYsNyArNDYsNyBAQCBwdWJsaWM6CiAgICAgdHlwZWRlZiB0eXBlbmFtZSBD b250ZXh0OjpDb250cm9sVHlwZSBDb250cm9sVHlwZTsKICAgICB0eXBlZGVmIHR5cGVuYW1lIENv bnRleHQ6OkV4cHJlc3Npb25MaXN0IEV4cHJlc3Npb25MaXN0OwogCi0gICAgRnVuY3Rpb25QYXJz ZXIoVk0qLCBDb250ZXh0JiwgY29uc3QgdWludDhfdCogZnVuY3Rpb25TdGFydCwgc2l6ZV90IGZ1 bmN0aW9uTGVuZ3RoLCBjb25zdCBTaWduYXR1cmUqLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbklu ZGV4U3BhY2UmLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYpOworICAgIEZ1bmN0aW9uUGFyc2Vy KFZNKiwgQ29udGV4dCYsIGNvbnN0IHVpbnQ4X3QqIGZ1bmN0aW9uU3RhcnQsIHNpemVfdCBmdW5j dGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mLCBj b25zdCBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+Jik7CiAKICAgICBSZXN1bHQgV0FSTl9VTlVTRURf UkVUVVJOIHBhcnNlKCk7CiAKQEAgLTgyLDE4ICs4MiwxOCBAQCBwcml2YXRlOgogICAgIEV4cHJl c3Npb25MaXN0IG1fZXhwcmVzc2lvblN0YWNrOwogICAgIFZlY3RvcjxDb250cm9sRW50cnk+IG1f Y29udHJvbFN0YWNrOwogICAgIGNvbnN0IFNpZ25hdHVyZSogbV9zaWduYXR1cmU7Ci0gICAgY29u c3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiBtX2Z1bmN0aW9uSW5kZXhTcGFjZTsKICAg ICBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgbV9pbmZvOworICAgIGNvbnN0IFZlY3RvcjxTaWdu YXR1cmVJbmRleD4mIG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUlu ZGljZXM7CiAgICAgdW5zaWduZWQgbV91bnJlYWNoYWJsZUJsb2NrcyB7IDAgfTsKIH07CiAKIHRl bXBsYXRlPHR5cGVuYW1lIENvbnRleHQ+Ci1GdW5jdGlvblBhcnNlcjxDb250ZXh0Pjo6RnVuY3Rp b25QYXJzZXIoVk0qIHZtLCBDb250ZXh0JiBjb250ZXh0LCBjb25zdCB1aW50OF90KiBmdW5jdGlv blN0YXJ0LCBzaXplX3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJl LCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIGZ1bmN0aW9uSW5kZXhTcGFjZSwg Y29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8pCitGdW5jdGlvblBhcnNlcjxDb250ZXh0Pjo6 RnVuY3Rpb25QYXJzZXIoVk0qIHZtLCBDb250ZXh0JiBjb250ZXh0LCBjb25zdCB1aW50OF90KiBm dW5jdGlvblN0YXJ0LCBzaXplX3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2ln bmF0dXJlLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgY29uc3QgVmVjdG9yPFNpZ25h dHVyZUluZGV4PiYgbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGlj ZXMpCiAgICAgOiBQYXJzZXIodm0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoKQogICAg ICwgbV9jb250ZXh0KGNvbnRleHQpCiAgICAgLCBtX3NpZ25hdHVyZShzaWduYXR1cmUpCi0gICAg LCBtX2Z1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4U3BhY2UpCiAgICAgLCBtX2luZm8o aW5mbykKKyAgICAsIG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUlu ZGljZXMobW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMpCiB7 CiAgICAgaWYgKHZlcmJvc2UpCiAgICAgICAgIGRhdGFMb2dMbigiUGFyc2luZyBmdW5jdGlvbiBz dGFydGluZyBhdDogIiwgKHVpbnRwdHJfdClmdW5jdGlvblN0YXJ0LCAiIG9mIGxlbmd0aDogIiwg ZnVuY3Rpb25MZW5ndGgpOwpAQCAtMzA4LDkgKzMwOCw5IEBAIGF1dG8gRnVuY3Rpb25QYXJzZXI8 Q29udGV4dD46OnBhcnNlRXhwcmVzc2lvbihPcFR5cGUgb3ApIC0+IFBhcnRpYWxSZXN1bHQKICAg ICBjYXNlIENhbGw6IHsKICAgICAgICAgdWludDMyX3QgZnVuY3Rpb25JbmRleDsKICAgICAgICAg V0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoZnVuY3Rpb25JbmRleCksICJjYW4n dCBwYXJzZSBjYWxsJ3MgZnVuY3Rpb24gaW5kZXgiKTsKLSAgICAgICAgV0FTTV9QQVJTRVJfRkFJ TF9JRihmdW5jdGlvbkluZGV4ID49IG1fZnVuY3Rpb25JbmRleFNwYWNlLnNpemUsICJjYWxsIGZ1 bmN0aW9uIGluZGV4ICIsIGZ1bmN0aW9uSW5kZXgsICIgZXhjZWVkcyBmdW5jdGlvbiBpbmRleCBz cGFjZSAiLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5zaXplKTsKKyAgICAgICAgV0FTTV9QQVJTRVJf RkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1faW5mby5mdW5jdGlvbkluZGV4U3BhY2VTaXplKCks ICJjYWxsIGZ1bmN0aW9uIGluZGV4ICIsIGZ1bmN0aW9uSW5kZXgsICIgZXhjZWVkcyBmdW5jdGlv biBpbmRleCBzcGFjZSAiLCBtX2luZm8uZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpKTsKIAotICAg ICAgICBTaWduYXR1cmVJbmRleCBjYWxsZWVTaWduYXR1cmVJbmRleCA9IG1fZnVuY3Rpb25JbmRl eFNwYWNlLmJ1ZmZlci5nZXQoKVtmdW5jdGlvbkluZGV4XS5zaWduYXR1cmVJbmRleDsKKyAgICAg ICAgU2lnbmF0dXJlSW5kZXggY2FsbGVlU2lnbmF0dXJlSW5kZXggPSBtX2luZm8uc2lnbmF0dXJl SW5kZXhGcm9tRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgpOwogICAgICAgICBjb25z dCBTaWduYXR1cmUqIGNhbGxlZVNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQo bV92bSwgY2FsbGVlU2lnbmF0dXJlSW5kZXgpOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lG KGNhbGxlZVNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpID4gbV9leHByZXNzaW9uU3RhY2suc2l6 ZSgpLCAiY2FsbCBmdW5jdGlvbiBpbmRleCAiLCBmdW5jdGlvbkluZGV4LCAiIGhhcyAiLCBjYWxs ZWVTaWduYXR1cmUtPmFyZ3VtZW50Q291bnQoKSwgIiBhcmd1bWVudHMsIGJ1dCB0aGUgZXhwcmVz c2lvbiBzdGFjayBjdXJyZW50bHkgaG9sZHMgIiwgbV9leHByZXNzaW9uU3RhY2suc2l6ZSgpLCAi IHZhbHVlcyIpOwogCkBAIC0zMzcsOSArMzM3LDkgQEAgYXV0byBGdW5jdGlvblBhcnNlcjxDb250 ZXh0Pjo6cGFyc2VFeHByZXNzaW9uKE9wVHlwZSBvcCkgLT4gUGFydGlhbFJlc3VsdAogICAgICAg ICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihzaWduYXR1cmVJbmRleCksICJj YW4ndCBnZXQgY2FsbF9pbmRpcmVjdCdzIHNpZ25hdHVyZSBpbmRleCIpOwogICAgICAgICBXQVNN X1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQxKHJlc2VydmVkKSwgImNhbid0IGdldCBjYWxs X2luZGlyZWN0J3MgcmVzZXJ2ZWQgYnl0ZSIpOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lG KHJlc2VydmVkLCAiY2FsbF9pbmRpcmVjdCdzICdyZXNlcnZlZCcgdmFydWludDEgbXVzdCBiZSAw eDAiKTsKLSAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihtX2luZm8uc2lnbmF0dXJlSW5kaWNl cy5zaXplKCkgPD0gc2lnbmF0dXJlSW5kZXgsICJjYWxsX2luZGlyZWN0J3Mgc2lnbmF0dXJlIGlu ZGV4ICIsIHNpZ25hdHVyZUluZGV4LCAiIGV4Y2VlZHMga25vd24gc2lnbmF0dXJlcyAiLCBtX2lu Zm8uc2lnbmF0dXJlSW5kaWNlcy5zaXplKCkpOworICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lG KG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMuc2l6ZSgp IDw9IHNpZ25hdHVyZUluZGV4LCAiY2FsbF9pbmRpcmVjdCdzIHNpZ25hdHVyZSBpbmRleCAiLCBz aWduYXR1cmVJbmRleCwgIiBleGNlZWRzIGtub3duIHNpZ25hdHVyZXMgIiwgbV9tb2R1bGVTaWdu YXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXplKCkpOwogCi0gICAgICAg IFNpZ25hdHVyZUluZGV4IGNhbGxlZVNpZ25hdHVyZUluZGV4ID0gbV9pbmZvLnNpZ25hdHVyZUlu ZGljZXNbc2lnbmF0dXJlSW5kZXhdOworICAgICAgICBTaWduYXR1cmVJbmRleCBjYWxsZWVTaWdu YXR1cmVJbmRleCA9IG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUlu ZGljZXNbc2lnbmF0dXJlSW5kZXhdOwogICAgICAgICBjb25zdCBTaWduYXR1cmUqIGNhbGxlZVNp Z25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgY2FsbGVlU2lnbmF0dXJl SW5kZXgpOwogICAgICAgICBzaXplX3QgYXJndW1lbnRDb3VudCA9IGNhbGxlZVNpZ25hdHVyZS0+ YXJndW1lbnRDb3VudCgpICsgMTsgLy8gQWRkIHRoZSBjYWxsZWUncyBpbmRleC4KICAgICAgICAg V0FTTV9QQVJTRVJfRkFJTF9JRihhcmd1bWVudENvdW50ID4gbV9leHByZXNzaW9uU3RhY2suc2l6 ZSgpLCAiY2FsbF9pbmRpcmVjdCBleHBlY3RzICIsIGFyZ3VtZW50Q291bnQsICIgYXJndW1lbnRz LCBidXQgdGhlIGV4cHJlc3Npb24gc3RhY2sgY3VycmVudGx5IGhvbGRzICIsIG1fZXhwcmVzc2lv blN0YWNrLnNpemUoKSwgIiB2YWx1ZXMiKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bU1lbW9yeS5jcHAKaW5kZXggNzAwZTNhYy4uYWFkOTFjMSAxMDA2NDQKLS0tIGEvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbU1lbW9yeS5jcHAKQEAgLTI4LDE1ICsyOCwzOSBAQAogCiAjaWYgRU5BQkxF KFdFQkFTU0VNQkxZKQogCisjaW5jbHVkZSA8d3RmL0hleE51bWJlci5oPgorI2luY2x1ZGUgPHd0 Zi9QcmludFN0cmVhbS5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgorCiBuYW1l c3BhY2UgSlNDIHsgbmFtZXNwYWNlIFdhc20gewogCituYW1lc3BhY2UgeworY29uc3QgYm9vbCB2 ZXJib3NlID0gZmFsc2U7Cit9CisKK3ZvaWQgTWVtb3J5OjpkdW1wKFByaW50U3RyZWFtJiBvdXQp IGNvbnN0Cit7CisgICAgU3RyaW5nIG1lbW9yeUhleDsKKyAgICBXVEY6OmFwcGVuZFVuc2lnbmVk NjRBc0hleCgodWludDY0X3QpKHVpbnRwdHJfdCltX21lbW9yeSwgbWVtb3J5SGV4KTsKKyAgICBv dXQucHJpbnQoIk1lbW9yeSBhdCAweCIsIG1lbW9yeUhleCwgIiwgc2l6ZSAiLCBtX3NpemUsICJC IGNhcGFjaXR5ICIsIG1fbWFwcGVkQ2FwYWNpdHksICJCLCBpbml0aWFsICIsIG1faW5pdGlhbCwg IiBtYXhpbXVtICIsIG1fbWF4aW11bSwgIiBtb2RlICIsIG1ha2VTdHJpbmcobV9tb2RlKSk7Cit9 CisKK2NvbnN0IGNoYXIqIE1lbW9yeTo6bWFrZVN0cmluZyhNb2RlIG1vZGUpIGNvbnN0Cit7Cisg ICAgc3dpdGNoIChtb2RlKSB7CisgICAgY2FzZSBNb2RlOjpCb3VuZHNDaGVja2luZzogcmV0dXJu ICJCb3VuZHNDaGVja2luZyI7CisgICAgfQorICAgIFJFTEVBU0VfQVNTRVJUX05PVF9SRUFDSEVE KCk7CisgICAgcmV0dXJuICIiOworfQorCiBzdGF0aWNfYXNzZXJ0KHNpemVvZih1aW50NjRfdCkg PT0gc2l6ZW9mKHNpemVfdCksICJXZSByZWx5IG9uIGFsbG93aW5nIHRoZSBtYXhpbXVtIHNpemUg b2YgTWVtb3J5IHdlIG1hcCB0byBiZSAyXjMyIHdoaWNoIGlzIGxhcmdlciB0aGFuIGZpdHMgaW4g YSAzMi1iaXQgaW50ZWdlciB0aGF0IHdlJ2QgcGFzcyB0byBtcHJvdGVjdCBpZiB0aGlzIGRpZG4n dCBob2xkLiIpOwogCiBNZW1vcnk6Ok1lbW9yeShQYWdlQ291bnQgaW5pdGlhbCwgUGFnZUNvdW50 IG1heGltdW0sIGJvb2wmIGZhaWxlZCkKLSAgICA6IG1fbW9kZShNb2RlOjpCb3VuZHNDaGVja2lu ZykKKyAgICA6IG1fc2l6ZShpbml0aWFsLmJ5dGVzKCkpCiAgICAgLCBtX2luaXRpYWwoaW5pdGlh bCkKICAgICAsIG1fbWF4aW11bShtYXhpbXVtKQotICAgICwgbV9zaXplKGluaXRpYWwuYnl0ZXMo KSkKKyAgICAsIG1fbW9kZShNb2RlOjpCb3VuZHNDaGVja2luZykKICAgICAvLyBGSVhNRTogSWYg d2UgYWRkIHNpZ25hbCBiYXNlZCBib3VuZHMgY2hlY2tpbmcgdGhlbiB3ZSBuZWVkIGV4dHJhIHNw YWNlIGZvciBvdmVyZmxvdyBvbiBsb2FkLgogICAgIC8vIHNlZTogaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MjY5MwogewpAQCAtNDYsOSArNzAsMTEgQEAgTWVtb3J5 OjpNZW1vcnkoUGFnZUNvdW50IGluaXRpYWwsIFBhZ2VDb3VudCBtYXhpbXVtLCBib29sJiBmYWls ZWQpCiAgICAgaWYgKCFtX21hcHBlZENhcGFjaXR5KSB7CiAgICAgICAgIC8vIFRoaXMgbWVhbnMg d2Ugc3BlY2lmaWVkIGEgemVybyBhcyBtYXhpbXVtICh3aGljaCBtZWFucyB3ZSBhbHNvIGhhdmUg emVybyBhcyBpbml0aWFsIHNpemUpLgogICAgICAgICBSRUxFQVNFX0FTU0VSVChtX3NpemUgPT0g MCk7Ci0gICAgICAgIG1fbWFwcGVkQ2FwYWNpdHkgPSAwOwogICAgICAgICBtX21lbW9yeSA9IG51 bGxwdHI7CisgICAgICAgIG1fbWFwcGVkQ2FwYWNpdHkgPSAwOwogICAgICAgICBmYWlsZWQgPSBm YWxzZTsKKyAgICAgICAgaWYgKHZlcmJvc2UpCisgICAgICAgICAgICBkYXRhTG9nTG4oIk1lbW9y eTo6TWVtb3J5IGFsbG9jYXRpbmcgbm90aGluZyAiLCAqdGhpcyk7CiAgICAgICAgIHJldHVybjsK ICAgICB9CiAKQEAgLTU2LDE1ICs4MiwyMSBAQCBNZW1vcnk6Ok1lbW9yeShQYWdlQ291bnQgaW5p dGlhbCwgUGFnZUNvdW50IG1heGltdW0sIGJvb2wmIGZhaWxlZCkKICAgICB2b2lkKiByZXN1bHQg PSBPcHRpb25zOjpzaW11bGF0ZVdlYkFzc2VtYmx5TG93TWVtb3J5KCkgPyBNQVBfRkFJTEVEIDog bW1hcChudWxscHRyLCBtX21hcHBlZENhcGFjaXR5LCBQUk9UX05PTkUsIE1BUF9QUklWQVRFIHwg TUFQX0FOT04sIC0xLCAwKTsKICAgICBpZiAocmVzdWx0ID09IE1BUF9GQUlMRUQpIHsKICAgICAg ICAgLy8gVHJ5IGFnYWluIHdpdGggYSBkaWZmZXJlbnQgbnVtYmVyLgorICAgICAgICBpZiAodmVy Ym9zZSkKKyAgICAgICAgICAgIGRhdGFMb2dMbigiTWVtb3J5OjpNZW1vcnkgbW1hcCBmYWlsZWQg b25jZSBmb3IgY2FwYWNpdHksIHRyeWluZyBhZ2FpbiIsICp0aGlzKTsKICAgICAgICAgbV9tYXBw ZWRDYXBhY2l0eSA9IG1fc2l6ZTsKICAgICAgICAgaWYgKCFtX21hcHBlZENhcGFjaXR5KSB7CiAg ICAgICAgICAgICBtX21lbW9yeSA9IG51bGxwdHI7CiAgICAgICAgICAgICBmYWlsZWQgPSBmYWxz ZTsKKyAgICAgICAgICAgIGlmICh2ZXJib3NlKQorICAgICAgICAgICAgICAgIGRhdGFMb2dMbigi TWVtb3J5OjpNZW1vcnkgbW1hcCBub3QgdHJ5aW5nIGFnYWluIGJlY2F1c2Ugc2l6ZSBpcyB6ZXJv ICIsICp0aGlzKTsKICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgfQogCiAgICAgICAgIHJl c3VsdCA9IG1tYXAobnVsbHB0ciwgbV9tYXBwZWRDYXBhY2l0eSwgUFJPVF9OT05FLCBNQVBfUFJJ VkFURSB8IE1BUF9BTk9OLCAtMSwgMCk7CiAgICAgICAgIGlmIChyZXN1bHQgPT0gTUFQX0ZBSUxF RCkgeworICAgICAgICAgICAgaWYgKHZlcmJvc2UpCisgICAgICAgICAgICAgICAgZGF0YUxvZ0xu KCJNZW1vcnk6Ok1lbW9yeSBtbWFwIGZhaWxlZCB0d2ljZSAiLCAqdGhpcyk7CiAgICAgICAgICAg ICBmYWlsZWQgPSB0cnVlOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CkBAIC03OCwx MiArMTEwLDI3IEBAIE1lbW9yeTo6TWVtb3J5KFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQg bWF4aW11bSwgYm9vbCYgZmFpbGVkKQogCiAgICAgbV9tZW1vcnkgPSByZXN1bHQ7CiAgICAgZmFp bGVkID0gZmFsc2U7CisgICAgaWYgKHZlcmJvc2UpCisgICAgICAgIGRhdGFMb2dMbigiTWVtb3J5 OjpNZW1vcnkgbW1hcCBzdWNjZWVkZWQgIiwgKnRoaXMpOworfQorCitNZW1vcnk6On5NZW1vcnko KQoreworICAgIGlmICh2ZXJib3NlKQorICAgICAgICBkYXRhTG9nTG4oIk1lbW9yeTo6fk1lbW9y eSAiLCAqdGhpcyk7CisgICAgaWYgKG1fbWVtb3J5KSB7CisgICAgICAgIGlmIChtdW5tYXAobV9t ZW1vcnksIG1fbWFwcGVkQ2FwYWNpdHkpKQorICAgICAgICAgICAgQ1JBU0goKTsKKyAgICB9CiB9 CiAKIGJvb2wgTWVtb3J5Ojpncm93KFBhZ2VDb3VudCBuZXdTaXplKQogewogICAgIFJFTEVBU0Vf QVNTRVJUKG5ld1NpemUgPiBQYWdlQ291bnQ6OmZyb21CeXRlcyhtX3NpemUpKTsKIAorICAgIGlm ICh2ZXJib3NlKQorICAgICAgICBkYXRhTG9nTG4oIk1lbW9yeTo6Z3JvdyB0byAiLCBuZXdTaXpl LCAiIGZyb20gIiwgKnRoaXMpOworCiAgICAgaWYgKG1heGltdW0oKSAmJiBuZXdTaXplID4gbWF4 aW11bSgpKQogICAgICAgICByZXR1cm4gZmFsc2U7CiAKQEAgLTkzLDYgKzE0MCw4IEBAIGJvb2wg TWVtb3J5Ojpncm93KFBhZ2VDb3VudCBuZXdTaXplKQogICAgICAgICBib29sIHN1Y2Nlc3MgPSAh bXByb3RlY3Qoc3RhdGljX2Nhc3Q8dWludDhfdCo+KG1fbWVtb3J5KSArIG1fc2l6ZSwgc3RhdGlj X2Nhc3Q8c2l6ZV90PihkZXNpcmVkU2l6ZSAtIG1fc2l6ZSksIFBST1RfUkVBRCB8IFBST1RfV1JJ VEUpOwogICAgICAgICBSRUxFQVNFX0FTU0VSVChzdWNjZXNzKTsKICAgICAgICAgbV9zaXplID0g ZGVzaXJlZFNpemU7CisgICAgICAgIGlmICh2ZXJib3NlKQorICAgICAgICAgICAgZGF0YUxvZ0xu KCJNZW1vcnk6Omdyb3cgaW4tcGxhY2UgIiwgKnRoaXMpOwogICAgICAgICByZXR1cm4gdHJ1ZTsK ICAgICB9CiAKQEAgLTExMCw2ICsxNTksOCBAQCBib29sIE1lbW9yeTo6Z3JvdyhQYWdlQ291bnQg bmV3U2l6ZSkKICAgICBtX21hcHBlZENhcGFjaXR5ID0gZGVzaXJlZFNpemU7CiAgICAgbV9zaXpl ID0gZGVzaXJlZFNpemU7CiAKKyAgICBpZiAodmVyYm9zZSkKKyAgICAgICAgZGF0YUxvZ0xuKCJN ZW1vcnk6Omdyb3cgIiwgKnRoaXMpOwogICAgIHJldHVybiB0cnVlOwogfQogCmRpZmYgLS1naXQg YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmggYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmgKaW5kZXggNGU1ZWUzNi4uZTQ3MGM0MSAxMDA2NDQK LS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5oCisrKyBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuaApAQCAtMzAsNyArMzAsOSBAQAogI2lu Y2x1ZGUgIldhc21DYWxsaW5nQ29udmVudGlvbi5oIgogI2luY2x1ZGUgIldhc21QYWdlQ291bnQu aCIKIAotI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KK25hbWVzcGFjZSBXVEYgeworY2xhc3MgUHJp bnRTdHJlYW07Cit9CiAKIG5hbWVzcGFjZSBKU0MgeyBuYW1lc3BhY2UgV2FzbSB7CiAKQEAgLTM4 LDQxICs0MCw1MCBAQCBjbGFzcyBNZW1vcnkgewogICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKE1l bW9yeSk7CiAgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CiBwdWJsaWM6CisgICAgdm9pZCBk dW1wKFdURjo6UHJpbnRTdHJlYW0mKSBjb25zdDsKIAogICAgIC8vIEZJWE1FOiBXZSBzaG91bGQg c3VwcG9ydCBvdGhlciBtb2Rlcy4gc2VlOiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MTYyNjkzCiAgICAgZW51bSBjbGFzcyBNb2RlIHsKICAgICAgICAgQm91bmRzQ2hl Y2tpbmcKICAgICB9OworICAgIGNvbnN0IGNoYXIqIG1ha2VTdHJpbmcoTW9kZSkgY29uc3Q7CiAK KyAgICBNZW1vcnkoKSA9IGRlZmF1bHQ7CiAgICAgSlNfRVhQT1JUX1BSSVZBVEUgTWVtb3J5KFBh Z2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSwgYm9vbCYgZmFpbGVkKTsKLQotICAg IH5NZW1vcnkoKQorICAgIE1lbW9yeShNZW1vcnkmJiBvdGhlcikKKyAgICAgICAgOiBtX21lbW9y eShvdGhlci5tX21lbW9yeSkKKyAgICAgICAgLCBtX3NpemUob3RoZXIubV9zaXplKQorICAgICAg ICAsIG1faW5pdGlhbChvdGhlci5tX2luaXRpYWwpCisgICAgICAgICwgbV9tYXhpbXVtKG90aGVy Lm1fbWF4aW11bSkKKyAgICAgICAgLCBtX21hcHBlZENhcGFjaXR5KG90aGVyLm1fbWFwcGVkQ2Fw YWNpdHkpCisgICAgICAgICwgbV9tb2RlKG90aGVyLm1fbW9kZSkKICAgICB7Ci0gICAgICAgIGlm IChtX21lbW9yeSkKLSAgICAgICAgICAgIG11bm1hcChtX21lbW9yeSwgbV9tYXBwZWRDYXBhY2l0 eSk7CisgICAgICAgIC8vIE1vdmluZyB0cmFuc2ZlcnMgb3duZXJzaGlwIG9mIHRoZSBhbGxvY2F0 ZWQgbWVtb3J5LgorICAgICAgICBvdGhlci5tX21lbW9yeSA9IG51bGxwdHI7CiAgICAgfQorICAg IEpTX0VYUE9SVF9QUklWQVRFIH5NZW1vcnkoKTsKIAogICAgIHZvaWQqIG1lbW9yeSgpIGNvbnN0 IHsgcmV0dXJuIG1fbWVtb3J5OyB9CiAgICAgdWludDY0X3Qgc2l6ZSgpIGNvbnN0IHsgcmV0dXJu IG1fc2l6ZTsgfQogICAgIFBhZ2VDb3VudCBzaXplSW5QYWdlcygpIGNvbnN0IHsgcmV0dXJuIFBh Z2VDb3VudDo6ZnJvbUJ5dGVzKG1fc2l6ZSk7IH0KIAotICAgIE1vZGUgbW9kZSgpIGNvbnN0IHsg cmV0dXJuIG1fbW9kZTsgfQotCiAgICAgUGFnZUNvdW50IGluaXRpYWwoKSBjb25zdCB7IHJldHVy biBtX2luaXRpYWw7IH0KICAgICBQYWdlQ291bnQgbWF4aW11bSgpIGNvbnN0IHsgcmV0dXJuIG1f bWF4aW11bTsgfQogCisgICAgTW9kZSBtb2RlKCkgY29uc3QgeyByZXR1cm4gbV9tb2RlOyB9CisK ICAgICBib29sIGdyb3coUGFnZUNvdW50KTsKIAotICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0 T2ZTaXplKCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKE1lbW9yeSwgbV9zaXplKTsgfQogICAg IHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZNZW1vcnkoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VU T0YoTWVtb3J5LCBtX21lbW9yeSk7IH0KKyAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mU2l6 ZSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihNZW1vcnksIG1fc2l6ZSk7IH0KICAgICAKIHBy aXZhdGU6CiAgICAgdm9pZCogbV9tZW1vcnkgeyBudWxscHRyIH07Ci0gICAgTW9kZSBtX21vZGU7 CisgICAgdWludDY0X3QgbV9zaXplIHsgMCB9OwogICAgIFBhZ2VDb3VudCBtX2luaXRpYWw7CiAg ICAgUGFnZUNvdW50IG1fbWF4aW11bTsKLSAgICB1aW50NjRfdCBtX3NpemUgeyAwIH07CiAgICAg dWludDY0X3QgbV9tYXBwZWRDYXBhY2l0eSB7IDAgfTsKKyAgICBNb2RlIG1fbW9kZSB7IE1vZGU6 OkJvdW5kc0NoZWNraW5nIH07CiB9OwogCiB9IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2FzbQpkaWZm IC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9u LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnlJbmZvcm1hdGlvbi5j cHAKaW5kZXggMmUxZDMwYS4uNmIwNjNkMyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtTWVtb3J5SW5mb3JtYXRpb24uY3BwCkBAIC0yNiwxMyArMjYsNTIgQEAK ICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJXYXNtTWVtb3J5SW5mb3JtYXRpb24uaCIK IAotI2luY2x1ZGUgIldhc21DYWxsaW5nQ29udmVudGlvbi5oIgotCiAjaWYgRU5BQkxFKFdFQkFT U0VNQkxZKQogCisjaW5jbHVkZSAiV2FzbUNhbGxpbmdDb252ZW50aW9uLmgiCisjaW5jbHVkZSA8 d3RmL05ldmVyRGVzdHJveWVkLmg+CisKIG5hbWVzcGFjZSBKU0MgeyBuYW1lc3BhY2UgV2FzbSB7 CiAKLU1lbW9yeUluZm9ybWF0aW9uOjpNZW1vcnlJbmZvcm1hdGlvbihQYWdlQ291bnQgaW5pdGlh bCwgUGFnZUNvdW50IG1heGltdW0sICBjb25zdCBWZWN0b3I8dW5zaWduZWQ+JiBwaW5uZWRTaXpl UmVnaXN0ZXJzLCBib29sIGlzSW1wb3J0KQorY29uc3QgUGlubmVkUmVnaXN0ZXJJbmZvJiBQaW5u ZWRSZWdpc3RlckluZm86OmdldCgpCit7CisgICAgc3RhdGljIExhenlOZXZlckRlc3Ryb3llZDxQ aW5uZWRSZWdpc3RlckluZm8+IHN0YXRpY1Bpbm5lZFJlZ2lzdGVySW5mbzsKKyAgICBzdGF0aWMg c3RkOjpvbmNlX2ZsYWcgc3RhdGljUGlubmVkUmVnaXN0ZXJJbmZvRmxhZzsKKyAgICBzdGQ6OmNh bGxfb25jZShzdGF0aWNQaW5uZWRSZWdpc3RlckluZm9GbGFnLCBbXSAoKSB7CisgICAgICAgIFZl Y3RvcjxQaW5uZWRTaXplUmVnaXN0ZXJJbmZvPiBzaXplUmVnaXN0ZXJzOworICAgICAgICBHUFJS ZWcgYmFzZU1lbW9yeVBvaW50ZXI7CisKKyAgICAgICAgLy8gRklYTUU6IFdlIHNob3VsZCBzdXBw b3J0IG1vcmUgdGhhbiBvbmUgbWVtb3J5IHNpemUgcmVnaXN0ZXIsIGFuZCB3ZSBzaG91bGQgYWxs b3cgZGlmZmVyZW50CisgICAgICAgIC8vICAgICAgICBXZWJBc3NlbWJseS5JbnN0YW5jZSB0byBo YXZlIGRpZmZlcmVudCBwaW5zLiBSaWdodCBub3cgd2UgdGFrZSBhIHZlY3RvciB3aXRoIG9ubHkg b25lIGVudHJ5LgorICAgICAgICAvLyAgICAgICAgSWYgd2UgaGF2ZSBtb3JlIHRoYW4gb25lIHNp emUgcmVnaXN0ZXIsIHdlIGNhbiBoYXZlIG9uZSBmb3IgZWFjaCBsb2FkIHNpemUgY2xhc3MuCisg ICAgICAgIC8vICAgICAgICBzZWU6IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xNjI5NTIKKyAgICAgICAgVmVjdG9yPHVuc2lnbmVkPiBwaW5uZWRTaXplcyA9IHsgMCB9 OworICAgICAgICB1bnNpZ25lZCByZW1haW5pbmdQaW5uZWRSZWdpc3RlcnMgPSBwaW5uZWRTaXpl cy5zaXplKCkgKyAxOworICAgICAgICBqc2NDYWxsaW5nQ29udmVudGlvbigpLm1fY2FsbGVlU2F2 ZVJlZ2lzdGVycy5mb3JFYWNoKFsmXSAoUmVnIHJlZykgeworICAgICAgICAgICAgR1BSUmVnIGdw ciA9IHJlZy5ncHIoKTsKKyAgICAgICAgICAgIGlmICghcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJz IHx8IFJlZ2lzdGVyU2V0OjpzdGFja1JlZ2lzdGVycygpLmdldChyZWcpKQorICAgICAgICAgICAg ICAgIHJldHVybjsKKyAgICAgICAgICAgIGlmIChyZW1haW5pbmdQaW5uZWRSZWdpc3RlcnMgPT0g MSkgeworICAgICAgICAgICAgICAgIGJhc2VNZW1vcnlQb2ludGVyID0gZ3ByOworICAgICAgICAg ICAgICAgIHJlbWFpbmluZ1Bpbm5lZFJlZ2lzdGVycy0tOworICAgICAgICAgICAgfSBlbHNlCisg ICAgICAgICAgICAgICAgc2l6ZVJlZ2lzdGVycy5hcHBlbmQoeyBncHIsIHBpbm5lZFNpemVzWy0t cmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzIC0gMV0gfSk7CisgICAgICAgIH0pOworCisgICAgICAg IEFTU0VSVCghcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzKTsKKyAgICAgICAgc3RhdGljUGlubmVk UmVnaXN0ZXJJbmZvLmNvbnN0cnVjdChXVEZNb3ZlKHNpemVSZWdpc3RlcnMpLCBiYXNlTWVtb3J5 UG9pbnRlcik7CisgICAgfSk7CisKKyAgICByZXR1cm4gc3RhdGljUGlubmVkUmVnaXN0ZXJJbmZv LmdldCgpOworfQorCitQaW5uZWRSZWdpc3RlckluZm86OlBpbm5lZFJlZ2lzdGVySW5mbyhWZWN0 b3I8UGlubmVkU2l6ZVJlZ2lzdGVySW5mbz4mJiBzaXplUmVnaXN0ZXJzLCBHUFJSZWcgYmFzZU1l bW9yeVBvaW50ZXIpCisgICAgOiBzaXplUmVnaXN0ZXJzKFdURk1vdmUoc2l6ZVJlZ2lzdGVycykp CisgICAgLCBiYXNlTWVtb3J5UG9pbnRlcihiYXNlTWVtb3J5UG9pbnRlcikKK3sKK30KKworTWVt b3J5SW5mb3JtYXRpb246Ok1lbW9yeUluZm9ybWF0aW9uKFBhZ2VDb3VudCBpbml0aWFsLCBQYWdl Q291bnQgbWF4aW11bSwgIGJvb2wgaXNJbXBvcnQpCiAgICAgOiBtX2luaXRpYWwoaW5pdGlhbCkK ICAgICAsIG1fbWF4aW11bShtYXhpbXVtKQogICAgICwgbV9pc0ltcG9ydChpc0ltcG9ydCkKQEAg LTQwLDIwICs3OSw2IEBAIE1lbW9yeUluZm9ybWF0aW9uOjpNZW1vcnlJbmZvcm1hdGlvbihQYWdl Q291bnQgaW5pdGlhbCwgUGFnZUNvdW50IG1heGltdW0sICBjb25zCiAgICAgUkVMRUFTRV9BU1NF UlQoISFtX2luaXRpYWwpOwogICAgIFJFTEVBU0VfQVNTRVJUKCFtX21heGltdW0gfHwgbV9tYXhp bXVtID49IG1faW5pdGlhbCk7CiAgICAgQVNTRVJUKCEhKnRoaXMpOwotCi0gICAgdW5zaWduZWQg cmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzID0gcGlubmVkU2l6ZVJlZ2lzdGVycy5zaXplKCkgKyAx OwotICAgIGpzY0NhbGxpbmdDb252ZW50aW9uKCkubV9jYWxsZWVTYXZlUmVnaXN0ZXJzLmZvckVh Y2goWyZdIChSZWcgcmVnKSB7Ci0gICAgICAgIEdQUlJlZyBncHIgPSByZWcuZ3ByKCk7Ci0gICAg ICAgIGlmICghcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzIHx8IFJlZ2lzdGVyU2V0OjpzdGFja1Jl Z2lzdGVycygpLmdldChyZWcpKQotICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICBpZiAocmVt YWluaW5nUGlubmVkUmVnaXN0ZXJzID09IDEpIHsKLSAgICAgICAgICAgIG1fcGlubmVkUmVnaXN0 ZXJzLmJhc2VNZW1vcnlQb2ludGVyID0gZ3ByOwotICAgICAgICAgICAgcmVtYWluaW5nUGlubmVk UmVnaXN0ZXJzLS07Ci0gICAgICAgIH0gZWxzZQotICAgICAgICAgICAgbV9waW5uZWRSZWdpc3Rl cnMuc2l6ZVJlZ2lzdGVycy5hcHBlbmQoeyBncHIsIHBpbm5lZFNpemVSZWdpc3RlcnNbLS1yZW1h aW5pbmdQaW5uZWRSZWdpc3RlcnMgLSAxXSB9KTsKLSAgICB9KTsKLQotICAgIEFTU0VSVCghcmVt YWluaW5nUGlubmVkUmVnaXN0ZXJzKTsKIH0KIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20K ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnlJbmZvcm1h dGlvbi5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9u LmgKaW5kZXggZWU2M2Q5ZS4uNmU3ZjUyMSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmgKQEAgLTM4LDEyICszOCwxMSBAQCBzdHJ1 Y3QgUGlubmVkU2l6ZVJlZ2lzdGVySW5mbyB7CiAgICAgdW5zaWduZWQgc2l6ZU9mZnNldDsKIH07 CiAKLS8vIEZJWE1FOiBXZSBzaG91bGQgc3VwcG9ydCBtb3JlIHRoYW4gb25lIG1lbW9yeSBzaXpl IHJlZ2lzdGVyLiBSaWdodCBub3cgd2UgdGFrZSBhIHZlY3RvciB3aXRoIG9ubHkgb25lCi0vLyBl bnRyeS4gU3BlY2lmaWNhbGx5IGFuIGVudHJ5IHdoZXJlIHRoZSBzaXplT2Zmc2V0ID09IDAuIElm IHdlIGhhdmUgbW9yZSB0aGFuIG9uZSBzaXplIHJlZ2lzdGVyLAotLy8gd2UgY2FuIGhhdmUgb25l IGZvciBlYWNoIGxvYWQgc2l6ZSBjbGFzcy4gc2VlOiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTYyOTUyCiBzdHJ1Y3QgUGlubmVkUmVnaXN0ZXJJbmZvIHsKICAgICBW ZWN0b3I8UGlubmVkU2l6ZVJlZ2lzdGVySW5mbz4gc2l6ZVJlZ2lzdGVyczsKICAgICBHUFJSZWcg YmFzZU1lbW9yeVBvaW50ZXI7CisgICAgc3RhdGljIGNvbnN0IFBpbm5lZFJlZ2lzdGVySW5mbyYg Z2V0KCk7CisgICAgUGlubmVkUmVnaXN0ZXJJbmZvKFZlY3RvcjxQaW5uZWRTaXplUmVnaXN0ZXJJ bmZvPiYmLCBHUFJSZWcpOwogfTsKIAogY2xhc3MgTWVtb3J5SW5mb3JtYXRpb24gewpAQCAtNTMs OSArNTIsOCBAQCBwdWJsaWM6CiAgICAgICAgIEFTU0VSVCghKnRoaXMpOwogICAgIH0KIAotICAg IE1lbW9yeUluZm9ybWF0aW9uKFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSwg Y29uc3QgVmVjdG9yPHVuc2lnbmVkPiYgcGlubmVkU2l6ZVJlZ2lzdGVycywgYm9vbCBpc0ltcG9y dCk7CisgICAgTWVtb3J5SW5mb3JtYXRpb24oUGFnZUNvdW50IGluaXRpYWwsIFBhZ2VDb3VudCBt YXhpbXVtLCBib29sIGlzSW1wb3J0KTsKIAotICAgIGNvbnN0IFBpbm5lZFJlZ2lzdGVySW5mbyYg cGlubmVkUmVnaXN0ZXJzKCkgY29uc3QgeyByZXR1cm4gbV9waW5uZWRSZWdpc3RlcnM7IH0KICAg ICBQYWdlQ291bnQgaW5pdGlhbCgpIGNvbnN0IHsgcmV0dXJuIG1faW5pdGlhbDsgfQogICAgIFBh Z2VDb3VudCBtYXhpbXVtKCkgY29uc3QgeyByZXR1cm4gbV9tYXhpbXVtOyB9CiAgICAgYm9vbCBp c0ltcG9ydCgpIGNvbnN0IHsgcmV0dXJuIG1faXNJbXBvcnQ7IH0KQEAgLTY1LDcgKzYzLDYgQEAg cHVibGljOgogcHJpdmF0ZToKICAgICBQYWdlQ291bnQgbV9pbml0aWFsIHsgfTsKICAgICBQYWdl Q291bnQgbV9tYXhpbXVtIHsgfTsKLSAgICBQaW5uZWRSZWdpc3RlckluZm8gbV9waW5uZWRSZWdp c3RlcnMgeyB9OwogICAgIGJvb2wgbV9pc0ltcG9ydCB7IGZhbHNlIH07CiB9OwogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmNwcCBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCmluZGV4IDYyNjFl N2YuLjMwMTFjODkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21N b2R1bGVQYXJzZXIuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1 bGVQYXJzZXIuY3BwCkBAIC0xMDcsNyArMTA3LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNl VHlwZSgpIC0+IFBhcnRpYWxSZXN1bHQKIAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNl VmFyVUludDMyKGNvdW50KSwgImNhbid0IGdldCBUeXBlIHNlY3Rpb24ncyBjb3VudCIpOwogICAg IFdBU01fUEFSU0VSX0ZBSUxfSUYoY291bnQgPT0gc3RkOjpudW1lcmljX2xpbWl0czx1aW50MzJf dD46Om1heCgpLCAiVHlwZSBzZWN0aW9uJ3MgY291bnQgaXMgdG9vIGJpZyAiLCBjb3VudCk7Ci0g ICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2Vz LnRyeVJlc2VydmVDYXBhY2l0eShjb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5 IGZvciBUeXBlIHNlY3Rpb24ncyAiLCBjb3VudCwgIiBlbnRyaWVzIik7CisgICAgV0FTTV9QQVJT RVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25h dHVyZUluZGljZXMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVu b3VnaCBtZW1vcnkgZm9yIFR5cGUgc2VjdGlvbidzICIsIGNvdW50LCAiIGVudHJpZXMiKTsKIAog ICAgIGZvciAodWludDMyX3QgaSA9IDA7IGkgPCBjb3VudDsgKytpKSB7CiAgICAgICAgIGludDhf dCB0eXBlOwpAQCAtMTM5LDcgKzEzOSw3IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZVR5cGUo KSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgICAgIHNpZ25hdHVyZS0+cmV0dXJuVHlwZSgpID0gcmV0 dXJuVHlwZTsKIAogICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IFNpZ25h dHVyZUluZm9ybWF0aW9uOjphZG9wdChtX3ZtLCBzaWduYXR1cmUucmVsZWFzZSgpKTsKLSAgICAg ICAgbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChzaWdu YXR1cmVJbmRleCk7CisgICAgICAgIG1fcmVzdWx0Lm1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1Vu aXF1ZWRTaWduYXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7CiAg ICAgfQogICAgIHJldHVybiB7IH07CiB9CkBAIC0xNTIsNyArMTUyLDYgQEAgYXV0byBNb2R1bGVQ YXJzZXI6OnBhcnNlSW1wb3J0KCkgLT4gUGFydGlhbFJlc3VsdAogICAgIFdBU01fUEFSU0VSX0ZB SUxfSUYoIW1fcmVzdWx0Lm1vZHVsZS0+Z2xvYmFscy50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0 Q291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQs ICIgZ2xvYmFscyIpOyAvLyBGSVhNRSB0aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRo ZSBGSVhNRXMgYmVsb3cuCiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxl LT5pbXBvcnRzLnRyeVJlc2VydmVDYXBhY2l0eShpbXBvcnRDb3VudCksICJjYW4ndCBhbGxvY2F0 ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBpbXBvcnRDb3VudCwgIiBpbXBvcnRzIik7IC8vIEZJWE1F IHRoaXMgb3Zlci1hbGxvY2F0ZXMgd2hlbiB3ZSBmaXggdGhlIEZJWE1FcyBiZWxvdy4KICAgICBX QVNNX1BBUlNFUl9GQUlMX0lGKCFtX3Jlc3VsdC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0 dXJlSW5kaWNlcy50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2Nh dGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIgaW1wb3J0IGZ1bmN0aW9uIHNp Z25hdHVyZXMiKTsgLy8gRklYTUUgdGhpcyBvdmVyLWFsbG9jYXRlcyB3aGVuIHdlIGZpeCB0aGUg RklYTUVzIGJlbG93LgotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0LmZ1bmN0aW9u SW5kZXhTcGFjZS50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2Nh dGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIgZnVuY3Rpb25zIGluIHRoZSBp bmRleCBzcGFjZSIpOyAvLyBGSVhNRSB0aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRo ZSBGSVhNRXMgYmVsb3cuIFdlJ2xsIGFsbG9jYXRlIHNvbWUgbW9yZSBoZXJlIHdoZW4gd2Uga25v dyBob3cgbWFueSBmdW5jdGlvbnMgdG8gZXhwZWN0LgogCiAgICAgZm9yICh1aW50MzJfdCBpbXBv cnROdW1iZXIgPSAwOyBpbXBvcnROdW1iZXIgPCBpbXBvcnRDb3VudDsgKytpbXBvcnROdW1iZXIp IHsKICAgICAgICAgSW1wb3J0IGltcDsKQEAgLTE3NCwxMSArMTczLDEwIEBAIGF1dG8gTW9kdWxl UGFyc2VyOjpwYXJzZUltcG9ydCgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICAgICAgY2FzZSBFeHRl cm5hbEtpbmQ6OkZ1bmN0aW9uOiB7CiAgICAgICAgICAgICB1aW50MzJfdCBmdW5jdGlvblNpZ25h dHVyZUluZGV4OwogICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50 MzIoZnVuY3Rpb25TaWduYXR1cmVJbmRleCksICJjYW4ndCBnZXQgIiwgaW1wb3J0TnVtYmVyLCAi dGggSW1wb3J0J3MgZnVuY3Rpb24gc2lnbmF0dXJlIGluIG1vZHVsZSAnIiwgbW9kdWxlU3RyaW5n LCAiJyBmaWVsZCAnIiwgZmllbGRTdHJpbmcsICInIik7Ci0gICAgICAgICAgICBXQVNNX1BBUlNF Ul9GQUlMX0lGKGZ1bmN0aW9uU2lnbmF0dXJlSW5kZXggPj0gbV9yZXN1bHQubW9kdWxlLT5zaWdu YXR1cmVJbmRpY2VzLnNpemUoKSwgImludmFsaWQgZnVuY3Rpb24gc2lnbmF0dXJlIGZvciAiLCBp bXBvcnROdW1iZXIsICJ0aCBJbXBvcnQsICIsIGZ1bmN0aW9uU2lnbmF0dXJlSW5kZXgsICIgaXMg b3V0IG9mIHJhbmdlIG9mICIsIG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlcy5zaXpl KCksICIgaW4gbW9kdWxlICciLCBtb2R1bGVTdHJpbmcsICInIGZpZWxkICciLCBmaWVsZFN0cmlu ZywgIiciKTsKKyAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVuY3Rpb25TaWduYXR1 cmVJbmRleCA+PSBtX3Jlc3VsdC5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0 dXJlSW5kaWNlcy5zaXplKCksICJpbnZhbGlkIGZ1bmN0aW9uIHNpZ25hdHVyZSBmb3IgIiwgaW1w b3J0TnVtYmVyLCAidGggSW1wb3J0LCAiLCBmdW5jdGlvblNpZ25hdHVyZUluZGV4LCAiIGlzIG91 dCBvZiByYW5nZSBvZiAiLCBtX3Jlc3VsdC5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVk U2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICIgaW4gbW9kdWxlICciLCBtb2R1bGVTdHJpbmcsICIn IGZpZWxkICciLCBmaWVsZFN0cmluZywgIiciKTsKICAgICAgICAgICAgIGltcC5raW5kSW5kZXgg PSBtX3Jlc3VsdC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCk7 Ci0gICAgICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1v ZHVsZS0+c2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvblNpZ25hdHVyZUluZGV4XTsKKyAgICAgICAg ICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlU2lnbmF0 dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXNbZnVuY3Rpb25TaWduYXR1cmVJbmRl eF07CiAgICAgICAgICAgICBtX3Jlc3VsdC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJl SW5kaWNlcy51bmNoZWNrZWRBcHBlbmQoc2lnbmF0dXJlSW5kZXgpOwotICAgICAgICAgICAgbV9y ZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7 CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQogICAgICAgICBjYXNlIEV4dGVybmFsS2lu ZDo6VGFibGU6IHsKQEAgLTIyMCwyMCArMjE4LDE4IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJz ZUZ1bmN0aW9uKCkgLT4gUGFydGlhbFJlc3VsdAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoY291 bnQgPT0gc3RkOjpudW1lcmljX2xpbWl0czx1aW50MzJfdD46Om1heCgpLCAiRnVuY3Rpb24gc2Vj dGlvbidzIGNvdW50IGlzIHRvbyBiaWcgIiwgY291bnQpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxf SUYoIW1fcmVzdWx0Lm1vZHVsZS0+aW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXMudHJ5 UmVzZXJ2ZUNhcGFjaXR5KGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9y ICIsIGNvdW50LCAiIEZ1bmN0aW9uIHNpZ25hdHVyZXMiKTsKICAgICBXQVNNX1BBUlNFUl9GQUlM X0lGKCFtX3Jlc3VsdC5mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkudHJ5UmVzZXJ2ZUNhcGFjaXR5 KGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGNvdW50LCAiRnVu Y3Rpb24gbG9jYXRpb25zIik7Ci0gICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQuZnVu Y3Rpb25JbmRleFNwYWNlLnRyeVJlc2VydmVDYXBhY2l0eShtX3Jlc3VsdC5mdW5jdGlvbkluZGV4 U3BhY2Uuc2l6ZSgpICsgY291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3Ig IiwgY291bnQsICIgbW9yZSBmdW5jdGlvbnMgaW4gdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlIik7 CiAKICAgICBmb3IgKHVpbnQzMl90IGkgPSAwOyBpIDwgY291bnQ7ICsraSkgewogICAgICAgICB1 aW50MzJfdCB0eXBlTnVtYmVyOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZh clVJbnQzMih0eXBlTnVtYmVyKSwgImNhbid0IGdldCAiLCBpLCAidGggRnVuY3Rpb24ncyB0eXBl IG51bWJlciIpOwotICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHR5cGVOdW1iZXIgPj0gbV9y ZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnNpemUoKSwgaSwgInRoIEZ1bmN0aW9uIHR5 cGUgbnVtYmVyIGlzIGludmFsaWQgIiwgdHlwZU51bWJlcik7CisgICAgICAgIFdBU01fUEFSU0VS X0ZBSUxfSUYodHlwZU51bWJlciA+PSBtX3Jlc3VsdC5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9V bmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXplKCksIGksICJ0aCBGdW5jdGlvbiB0eXBlIG51bWJl ciBpcyBpbnZhbGlkICIsIHR5cGVOdW1iZXIpOwogCi0gICAgICAgIFNpZ25hdHVyZUluZGV4IHNp Z25hdHVyZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzW3R5cGVOdW1i ZXJdOworICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1v ZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzW3R5cGVOdW1iZXJd OwogICAgICAgICAvLyBUaGUgQ29kZSBzZWN0aW9uIGZpeGVzIHVwIHN0YXJ0IGFuZCBlbmQuCiAg ICAgICAgIHNpemVfdCBzdGFydCA9IDA7CiAgICAgICAgIHNpemVfdCBlbmQgPSAwOwogICAgICAg ICBtX3Jlc3VsdC5tb2R1bGUtPmludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnVuY2hl Y2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7CiAgICAgICAgIG1fcmVzdWx0LmZ1bmN0aW9uTG9j YXRpb25JbkJpbmFyeS51bmNoZWNrZWRBcHBlbmQoeyBzdGFydCwgZW5kIH0pOwotICAgICAgICBt X3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2UudW5jaGVja2VkQXBwZW5kKHNpZ25hdHVyZUluZGV4 KTsKICAgICB9CiAKICAgICByZXR1cm4geyB9OwpAQCAtMzIwLDggKzMxNiw3IEBAIGF1dG8gTW9k dWxlUGFyc2VyOjpwYXJzZU1lbW9yeUhlbHBlcihib29sIGlzSW1wb3J0KSAtPiBQYXJ0aWFsUmVz dWx0CiAgICAgQVNTRVJUKGluaXRpYWxQYWdlQ291bnQpOwogICAgIEFTU0VSVCghbWF4aW11bVBh Z2VDb3VudCB8fCBtYXhpbXVtUGFnZUNvdW50ID49IGluaXRpYWxQYWdlQ291bnQpOwogCi0gICAg VmVjdG9yPHVuc2lnbmVkPiBwaW5uZWRTaXplcyA9IHsgMCB9OwotICAgIG1fcmVzdWx0Lm1vZHVs ZS0+bWVtb3J5ID0gTWVtb3J5SW5mb3JtYXRpb24oaW5pdGlhbFBhZ2VDb3VudCwgbWF4aW11bVBh Z2VDb3VudCwgcGlubmVkU2l6ZXMsIGlzSW1wb3J0KTsKKyAgICBtX3Jlc3VsdC5tb2R1bGUtPm1l bW9yeSA9IE1lbW9yeUluZm9ybWF0aW9uKGluaXRpYWxQYWdlQ291bnQsIG1heGltdW1QYWdlQ291 bnQsIGlzSW1wb3J0KTsKICAgICByZXR1cm4geyB9OwogfQogCkBAIC0zODcsNyArMzgyLDcgQEAg YXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlRXhwb3J0KCkgLT4gUGFydGlhbFJlc3VsdAogICAgICAg ICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihleHAua2luZEluZGV4KSwgImNh bid0IGdldCAiLCBleHBvcnROdW1iZXIsICJ0aCBFeHBvcnQncyBraW5kIGluZGV4LCBuYW1lZCAn IiwgZmllbGRTdHJpbmcsICInIik7CiAgICAgICAgIHN3aXRjaCAoZXhwLmtpbmQpIHsKICAgICAg ICAgY2FzZSBFeHRlcm5hbEtpbmQ6OkZ1bmN0aW9uOiB7Ci0gICAgICAgICAgICBXQVNNX1BBUlNF Ul9GQUlMX0lGKGV4cC5raW5kSW5kZXggPj0gbV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnNp emUoKSwgZXhwb3J0TnVtYmVyLCAidGggRXhwb3J0IGhhcyBpbnZhbGlkIGZ1bmN0aW9uIG51bWJl ciAiLCBleHAua2luZEluZGV4LCAiIGl0IGV4Y2VlZHMgdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNl ICIsIG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCksICIsIG5hbWVkICciLCBmaWVs ZFN0cmluZywgIiciKTsKKyAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZXhwLmtpbmRJ bmRleCA+PSBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSwgZXhwb3J0 TnVtYmVyLCAidGggRXhwb3J0IGhhcyBpbnZhbGlkIGZ1bmN0aW9uIG51bWJlciAiLCBleHAua2lu ZEluZGV4LCAiIGl0IGV4Y2VlZHMgdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlICIsIG1fcmVzdWx0 Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpLCAiLCBuYW1lZCAnIiwgZmllbGRTdHJp bmcsICInIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQogICAgICAgICBjYXNlIEV4 dGVybmFsS2luZDo6VGFibGU6IHsKQEAgLTQxNyw4ICs0MTIsOCBAQCBhdXRvIE1vZHVsZVBhcnNl cjo6cGFyc2VTdGFydCgpIC0+IFBhcnRpYWxSZXN1bHQKIHsKICAgICB1aW50MzJfdCBzdGFydEZ1 bmN0aW9uSW5kZXg7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoc3Rh cnRGdW5jdGlvbkluZGV4KSwgImNhbid0IGdldCBTdGFydCBpbmRleCIpOwotICAgIFdBU01fUEFS U0VSX0ZBSUxfSUYoc3RhcnRGdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhT cGFjZS5zaXplKCksICJTdGFydCBpbmRleCAiLCBzdGFydEZ1bmN0aW9uSW5kZXgsICIgZXhjZWVk cyBmdW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6 ZSgpKTsKLSAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0LmZ1bmN0 aW9uSW5kZXhTcGFjZVtzdGFydEZ1bmN0aW9uSW5kZXhdLnNpZ25hdHVyZUluZGV4OworICAgIFdB U01fUEFSU0VSX0ZBSUxfSUYoc3RhcnRGdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0Lm1vZHVsZS0+ ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpLCAiU3RhcnQgaW5kZXggIiwgc3RhcnRGdW5jdGlvbklu ZGV4LCAiIGV4Y2VlZHMgZnVuY3Rpb24gaW5kZXggc3BhY2UgIiwgbV9yZXN1bHQubW9kdWxlLT5m dW5jdGlvbkluZGV4U3BhY2VTaXplKCkpOworICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUlu ZGV4ID0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3Bh Y2Uoc3RhcnRGdW5jdGlvbkluZGV4KTsKICAgICBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSA9 IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgc2lnbmF0dXJlSW5kZXgpOwogICAgIFdB U01fUEFSU0VSX0ZBSUxfSUYoc2lnbmF0dXJlLT5hcmd1bWVudENvdW50KCksICJTdGFydCBmdW5j dGlvbiBjYW4ndCBoYXZlIGFyZ3VtZW50cyIpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc2ln bmF0dXJlLT5yZXR1cm5UeXBlKCkgIT0gVm9pZCwgIlN0YXJ0IGZ1bmN0aW9uIGNhbid0IHJldHVy biBhIHZhbHVlIik7CkBAIC00NjksNyArNDY0LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNl RWxlbWVudCgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICAgICAgZm9yICh1bnNpZ25lZCBpbmRleCA9 IDA7IGluZGV4IDwgaW5kZXhDb3VudDsgKytpbmRleCkgewogICAgICAgICAgICAgdWludDMyX3Qg ZnVuY3Rpb25JbmRleDsKICAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFy VUludDMyKGZ1bmN0aW9uSW5kZXgpLCAiY2FuJ3QgZ2V0IEVsZW1lbnQgc2VjdGlvbidzICIsIGVs ZW1lbnROdW0sICJ0aCBlbGVtZW50J3MgIiwgaW5kZXgsICJ0aCBpbmRleCIpOwotICAgICAgICAg ICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0LmZ1bmN0aW9u SW5kZXhTcGFjZS5zaXplKCksICJFbGVtZW50IHNlY3Rpb24ncyAiLCBlbGVtZW50TnVtLCAidGgg ZWxlbWVudCdzICIsIGluZGV4LCAidGggaW5kZXggaXMgIiwgZnVuY3Rpb25JbmRleCwgIiB3aGlj aCBleGNlZWRzIHRoZSBmdW5jdGlvbiBpbmRleCBzcGFjZSBzaXplIG9mICIsIG1fcmVzdWx0LmZ1 bmN0aW9uSW5kZXhTcGFjZS5zaXplKCkpOworICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9J RihmdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6 ZSgpLCAiRWxlbWVudCBzZWN0aW9uJ3MgIiwgZWxlbWVudE51bSwgInRoIGVsZW1lbnQncyAiLCBp bmRleCwgInRoIGluZGV4IGlzICIsIGZ1bmN0aW9uSW5kZXgsICIgd2hpY2ggZXhjZWVkcyB0aGUg ZnVuY3Rpb24gaW5kZXggc3BhY2Ugc2l6ZSBvZiAiLCBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9u SW5kZXhTcGFjZVNpemUoKSk7CiAKICAgICAgICAgICAgIGVsZW1lbnQuZnVuY3Rpb25JbmRpY2Vz LnVuY2hlY2tlZEFwcGVuZChmdW5jdGlvbkluZGV4KTsKICAgICAgICAgfQpkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5oIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5oCmluZGV4IGUzYjc1YTcuLjdlMDI2 YzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJz ZXIuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmgK QEAgLTM2LDggKzM2LDggQEAgbmFtZXNwYWNlIEpTQyB7IG5hbWVzcGFjZSBXYXNtIHsKIAogc3Ry dWN0IE1vZHVsZVBhcnNlclJlc3VsdCB7CiAgICAgc3RkOjp1bmlxdWVfcHRyPE1vZHVsZUluZm9y bWF0aW9uPiBtb2R1bGU7Ci0gICAgRnVuY3Rpb25JbmRleFNwYWNlIGZ1bmN0aW9uSW5kZXhTcGFj ZTsKICAgICBWZWN0b3I8RnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5PiBmdW5jdGlvbkxvY2F0aW9u SW5CaW5hcnk7CisgICAgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiBtb2R1bGVTaWduYXR1cmVJbmRp Y2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlczsKIH07CiAKIGNsYXNzIE1vZHVsZVBhcnNlciA6 IHB1YmxpYyBQYXJzZXI8TW9kdWxlUGFyc2VyUmVzdWx0PiB7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFnZUNvdW50LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21QYWdlQ291bnQuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAuLjRiODc3MDUKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9XYXNtUGFnZUNvdW50LmNwcApAQCAtMCwwICsxLDQ1IEBACisvKgorICogQ29weXJpZ2h0 IChDKSAyMDE2IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBz b3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisg KiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFi b3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQv b3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisg KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBB TlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu ICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1 ZGUgIldhc21QYWdlQ291bnQuaCIKKworI2lmIEVOQUJMRShXRUJBU1NFTUJMWSkKKworI2luY2x1 ZGUgPHd0Zi9QcmludFN0cmVhbS5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgor CituYW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIFdhc20geworCit2b2lkIFBhZ2VDb3VudDo6ZHVt cChQcmludFN0cmVhbSYgb3V0KSBjb25zdAoreworICAgIG91dC5wcmludChTdHJpbmc6Om51bWJl cihieXRlcygpKSwgIkIiKTsKK30KKworfSAvLyBuYW1lc3BhY2UgSlNDCisKK30gLy8gbmFtZXNw YWNlIFdhc20KKworI2VuZGlmIC8vIEVOQUJMRShXRUJBU1NFTUJMWSkKZGlmZiAtLWdpdCBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QYWdlQ291bnQuaCBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21QYWdlQ291bnQuaAppbmRleCBhMTVkNTA1Li42N2RiYjU1IDEwMDY0 NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFnZUNvdW50LmgKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBhZ2VDb3VudC5oCkBAIC0yNyw2ICsyNywx MCBAQAogCiAjaWYgRU5BQkxFKFdFQkFTU0VNQkxZKQogCituYW1lc3BhY2UgV1RGIHsKK2NsYXNz IFByaW50U3RyZWFtOworfQorCiBuYW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIFdhc20gewogCiBj bGFzcyBQYWdlQ291bnQgewpAQCAtNDIsNiArNDYsOCBAQCBwdWJsaWM6CiAgICAgICAgIDogbV9w YWdlQ291bnQocGFnZUNvdW50KQogICAgIHsgfQogCisgICAgdm9pZCBkdW1wKFdURjo6UHJpbnRT dHJlYW0mKSBjb25zdDsKKwogICAgIHVpbnQ2NF90IGJ5dGVzKCkgY29uc3QgeyByZXR1cm4gc3Rh dGljX2Nhc3Q8dWludDY0X3Q+KG1fcGFnZUNvdW50KSAqIHN0YXRpY19jYXN0PHVpbnQ2NF90Pihw YWdlU2l6ZSk7IH0KICAgICB1aW50MzJfdCBwYWdlQ291bnQoKSBjb25zdCB7IHJldHVybiBtX3Bh Z2VDb3VudDsgfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt UGxhbi5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5jcHAKaW5kZXgg ZWQyOGJiYy4uMmQzNDIyZiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbVBsYW4uY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmNw cApAQCAtNzYsOCArNzYsNyBAQCBib29sIFBsYW46OnBhcnNlQW5kVmFsaWRhdGVNb2R1bGUoKQog ICAgICAgICB9CiAgICAgICAgIG1fbW9kdWxlSW5mb3JtYXRpb24gPSBXVEZNb3ZlKHBhcnNlUmVz dWx0LT5tb2R1bGUpOwogICAgICAgICBtX2Z1bmN0aW9uTG9jYXRpb25JbkJpbmFyeSA9IFdURk1v dmUocGFyc2VSZXN1bHQtPmZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeSk7Ci0gICAgICAgIG1fZnVu Y3Rpb25JbmRleFNwYWNlLnNpemUgPSBwYXJzZVJlc3VsdC0+ZnVuY3Rpb25JbmRleFNwYWNlLnNp emUoKTsKLSAgICAgICAgbV9mdW5jdGlvbkluZGV4U3BhY2UuYnVmZmVyID0gcGFyc2VSZXN1bHQt PmZ1bmN0aW9uSW5kZXhTcGFjZS5yZWxlYXNlQnVmZmVyKCk7CisgICAgICAgIG1fbW9kdWxlU2ln bmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMgPSBXVEZNb3ZlKHBhcnNlUmVz dWx0LT5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcyk7CiAg ICAgfQogCiAgICAgZm9yICh1bnNpZ25lZCBmdW5jdGlvbkluZGV4ID0gMDsgZnVuY3Rpb25JbmRl eCA8IG1fZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5LnNpemUoKTsgKytmdW5jdGlvbkluZGV4KSB7 CkBAIC04OSw3ICs4OCw3IEBAIGJvb2wgUGxhbjo6cGFyc2VBbmRWYWxpZGF0ZU1vZHVsZSgpCiAg ICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9tb2R1bGVJbmZvcm1hdGlv bi0+aW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXNbZnVuY3Rpb25JbmRleF07CiAgICAg ICAgIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlID0gU2lnbmF0dXJlSW5mb3JtYXRpb246Omdl dChtX3ZtLCBzaWduYXR1cmVJbmRleCk7CiAKLSAgICAgICAgYXV0byB2YWxpZGF0aW9uUmVzdWx0 ID0gdmFsaWRhdGVGdW5jdGlvbihtX3ZtLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwg c2lnbmF0dXJlLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZSwgKm1fbW9kdWxlSW5mb3JtYXRpb24pOwor ICAgICAgICBhdXRvIHZhbGlkYXRpb25SZXN1bHQgPSB2YWxpZGF0ZUZ1bmN0aW9uKG1fdm0sIGZ1 bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWduYXR1cmUsICptX21vZHVsZUluZm9ybWF0 aW9uLCBtX21vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzKTsK ICAgICAgICAgaWYgKCF2YWxpZGF0aW9uUmVzdWx0KSB7CiAgICAgICAgICAgICBpZiAodmVyYm9z ZSkgewogICAgICAgICAgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBmdW5jdGlvbkxl bmd0aDsgKytpKQpAQCAtMTI3LDcgKzEyNiw3IEBAIHZvaWQgUGxhbjo6cnVuKCkKICAgICAgICAg cmV0dXJuIHRydWU7CiAgICAgfTsKIAotICAgIGlmICghdHJ5UmVzZXJ2ZUNhcGFjaXR5KG1fd2Fz bVRvSlNTdHVicywgbV9tb2R1bGVJbmZvcm1hdGlvbi0+aW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJ bmRpY2VzLnNpemUoKSwgIiBXZWJBc3NlbWJseSB0byBKYXZhU2NyaXB0IHN0dWJzIikKKyAgICBp ZiAoIXRyeVJlc2VydmVDYXBhY2l0eShtX3dhc21FeGl0U3R1YnMsIG1fbW9kdWxlSW5mb3JtYXRp b24tPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICIgV2ViQXNzZW1ibHkg dG8gSmF2YVNjcmlwdCBzdHVicyIpCiAgICAgICAgIHx8ICF0cnlSZXNlcnZlQ2FwYWNpdHkobV91 bmxpbmtlZFdhc21Ub1dhc21DYWxscywgbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgp LCAiIHVubGlua2VkIFdlYkFzc2VtYmx5IHRvIFdlYkFzc2VtYmx5IGNhbGxzIikKICAgICAgICAg fHwgIXRyeVJlc2VydmVDYXBhY2l0eShtX3dhc21JbnRlcm5hbEZ1bmN0aW9ucywgbV9mdW5jdGlv bkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgpLCAiIFdlYkFzc2VtYmx5IGZ1bmN0aW9ucyIpCiAgICAg ICAgIHx8ICF0cnlSZXNlcnZlQ2FwYWNpdHkobV9jb21waWxhdGlvbkNvbnRleHRzLCBtX2Z1bmN0 aW9uTG9jYXRpb25JbkJpbmFyeS5zaXplKCksICIgY29tcGlsYXRpb24gY29udGV4dHMiKSkKQEAg LTE0MSwxMiArMTQwLDExIEBAIHZvaWQgUGxhbjo6cnVuKCkKICAgICAgICAgSW1wb3J0KiBpbXBv cnQgPSAmbV9tb2R1bGVJbmZvcm1hdGlvbi0+aW1wb3J0c1tpbXBvcnRJbmRleF07CiAgICAgICAg IGlmIChpbXBvcnQtPmtpbmQgIT0gRXh0ZXJuYWxLaW5kOjpGdW5jdGlvbikKICAgICAgICAgICAg IGNvbnRpbnVlOwotICAgICAgICB1bnNpZ25lZCBpbXBvcnRGdW5jdGlvbkluZGV4ID0gbV93YXNt VG9KU1N0dWJzLnNpemUoKTsKKyAgICAgICAgdW5zaWduZWQgaW1wb3J0RnVuY3Rpb25JbmRleCA9 IG1fd2FzbUV4aXRTdHVicy5zaXplKCk7CiAgICAgICAgIGlmICh2ZXJib3NlKQogICAgICAgICAg ICAgZGF0YUxvZ0xuKCJQcm9jZXNzaW5nIGltcG9ydCBmdW5jdGlvbiBudW1iZXIgIiwgaW1wb3J0 RnVuY3Rpb25JbmRleCwgIjogIiwgaW1wb3J0LT5tb2R1bGUsICI6ICIsIGltcG9ydC0+ZmllbGQp OwogICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fbW9kdWxlSW5mb3Jt YXRpb24tPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5hdChpbXBvcnQtPmtpbmRJbmRl eCk7Ci0gICAgICAgIG1fd2FzbVRvSlNTdHVicy51bmNoZWNrZWRBcHBlbmQoaW1wb3J0U3R1Ykdl bmVyYXRvcihtX3ZtLCBtX2NhbGxMaW5rSW5mb3MsIHNpZ25hdHVyZUluZGV4LCBpbXBvcnRGdW5j dGlvbkluZGV4KSk7Ci0gICAgICAgIG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtp bXBvcnRGdW5jdGlvbkluZGV4XS5jb2RlID0gbV93YXNtVG9KU1N0dWJzW2ltcG9ydEZ1bmN0aW9u SW5kZXhdLmNvZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpOworICAgICAgICBtX3dhc21FeGl0U3R1 YnMudW5jaGVja2VkQXBwZW5kKGV4aXRTdHViR2VuZXJhdG9yKG1fdm0sIG1fY2FsbExpbmtJbmZv cywgc2lnbmF0dXJlSW5kZXgsIGltcG9ydEZ1bmN0aW9uSW5kZXgpKTsKICAgICB9CiAKICAgICBt X2N1cnJlbnRJbmRleCA9IDA7CkBAIC0xNjcsMTIgKzE2NSwxMiBAQCB2b2lkIFBsYW46OnJ1bigp CiAgICAgICAgICAgICBBU1NFUlQoZnVuY3Rpb25MZW5ndGggPD0gbV9zb3VyY2VMZW5ndGgpOwog ICAgICAgICAgICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtX21vZHVsZUluZm9y bWF0aW9uLT5pbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4XTsK ICAgICAgICAgICAgIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlID0gU2lnbmF0dXJlSW5mb3Jt YXRpb246OmdldChtX3ZtLCBzaWduYXR1cmVJbmRleCk7Ci0gICAgICAgICAgICB1bnNpZ25lZCBm dW5jdGlvbkluZGV4U3BhY2UgPSBtX3dhc21Ub0pTU3R1YnMuc2l6ZSgpICsgZnVuY3Rpb25JbmRl eDsKLSAgICAgICAgICAgIEFTU0VSVF9VTlVTRUQoZnVuY3Rpb25JbmRleFNwYWNlLCBtX2Z1bmN0 aW9uSW5kZXhTcGFjZS5idWZmZXIuZ2V0KClbZnVuY3Rpb25JbmRleFNwYWNlXS5zaWduYXR1cmVJ bmRleCA9PSBzaWduYXR1cmVJbmRleCk7Ci0gICAgICAgICAgICBBU1NFUlQodmFsaWRhdGVGdW5j dGlvbihtX3ZtLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBtX2Z1 bmN0aW9uSW5kZXhTcGFjZSwgKm1fbW9kdWxlSW5mb3JtYXRpb24pKTsKKyAgICAgICAgICAgIHVu c2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFjZSA9IG1fd2FzbUV4aXRTdHVicy5zaXplKCkgKyBmdW5j dGlvbkluZGV4OworICAgICAgICAgICAgQVNTRVJUX1VOVVNFRChmdW5jdGlvbkluZGV4U3BhY2Us IG1fbW9kdWxlSW5mb3JtYXRpb24tPnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFj ZShmdW5jdGlvbkluZGV4U3BhY2UpID09IHNpZ25hdHVyZUluZGV4KTsKKyAgICAgICAgICAgIEFT U0VSVCh2YWxpZGF0ZUZ1bmN0aW9uKG1fdm0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3Ro LCBzaWduYXR1cmUsICptX21vZHVsZUluZm9ybWF0aW9uLCBtX21vZHVsZVNpZ25hdHVyZUluZGlj ZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzKSk7CiAKICAgICAgICAgICAgIG1fdW5saW5rZWRX YXNtVG9XYXNtQ2FsbHNbZnVuY3Rpb25JbmRleF0gPSBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNt Q2FsbD4oKTsKLSAgICAgICAgICAgIGF1dG8gcGFyc2VBbmRDb21waWxlUmVzdWx0ID0gcGFyc2VB bmRDb21waWxlKCptX3ZtLCBtX2NvbXBpbGF0aW9uQ29udGV4dHNbZnVuY3Rpb25JbmRleF0sIGZ1 bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWduYXR1cmUsIG1fdW5saW5rZWRXYXNtVG9X YXNtQ2FsbHNbZnVuY3Rpb25JbmRleF0sIG1fZnVuY3Rpb25JbmRleFNwYWNlLCAqbV9tb2R1bGVJ bmZvcm1hdGlvbik7CisgICAgICAgICAgICBhdXRvIHBhcnNlQW5kQ29tcGlsZVJlc3VsdCA9IHBh cnNlQW5kQ29tcGlsZSgqbV92bSwgbV9jb21waWxhdGlvbkNvbnRleHRzW2Z1bmN0aW9uSW5kZXhd LCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBtX3VubGlua2VkV2Fz bVRvV2FzbUNhbGxzW2Z1bmN0aW9uSW5kZXhdLCAqbV9tb2R1bGVJbmZvcm1hdGlvbiwgbV9tb2R1 bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcyk7CiAKICAgICAgICAg ICAgIGlmIChVTkxJS0VMWSghcGFyc2VBbmRDb21waWxlUmVzdWx0KSkgewogICAgICAgICAgICAg ICAgIGF1dG8gbG9ja2VyID0gaG9sZExvY2sobV9sb2NrKTsKQEAgLTIwOSwxMCArMjA3LDEyIEBA IHZvaWQgUGxhbjo6cnVuKCkKICAgICBmb3IgKHVpbnQzMl90IGZ1bmN0aW9uSW5kZXggPSAwOyBm dW5jdGlvbkluZGV4IDwgbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgpOyBmdW5jdGlv bkluZGV4KyspIHsKICAgICAgICAgewogICAgICAgICAgICAgQ29tcGlsYXRpb25Db250ZXh0JiBj b250ZXh0ID0gbV9jb21waWxhdGlvbkNvbnRleHRzW2Z1bmN0aW9uSW5kZXhdOworICAgICAgICAg ICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtX21vZHVsZUluZm9ybWF0aW9uLT5p bnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4XTsKKyAgICAgICAg ICAgIFN0cmluZyBzaWduYXR1cmVEZXNjcmlwdGlvbiA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpn ZXQobV92bSwgc2lnbmF0dXJlSW5kZXgpLT50b1N0cmluZygpOwogICAgICAgICAgICAgewogICAg ICAgICAgICAgICAgIExpbmtCdWZmZXIgbGlua0J1ZmZlcigqbV92bSwgKmNvbnRleHQud2FzbUVu dHJ5cG9pbnRKSVQsIG51bGxwdHIpOwogICAgICAgICAgICAgICAgIG1fd2FzbUludGVybmFsRnVu Y3Rpb25zW2Z1bmN0aW9uSW5kZXhdLT53YXNtRW50cnlwb2ludC5jb21waWxhdGlvbiA9Ci0gICAg ICAgICAgICAgICAgICAgIHN0ZDo6bWFrZV91bmlxdWU8QjM6OkNvbXBpbGF0aW9uPihGSU5BTEla RV9DT0RFKGxpbmtCdWZmZXIsICgiV2FzbSBmdW5jdGlvbiIpKSwgV1RGTW92ZShjb250ZXh0Lndh c21FbnRyeXBvaW50Qnlwcm9kdWN0cykpOworICAgICAgICAgICAgICAgICAgICBzdGQ6Om1ha2Vf dW5pcXVlPEIzOjpDb21waWxhdGlvbj4oRklOQUxJWkVfQ09ERShsaW5rQnVmZmVyLCAoIldlYkFz c2VtYmx5IGZ1bmN0aW9uWyVpXSAlcyIsIGZ1bmN0aW9uSW5kZXgsIHNpZ25hdHVyZURlc2NyaXB0 aW9uLmFzY2lpKCkuZGF0YSgpKSksIFdURk1vdmUoY29udGV4dC53YXNtRW50cnlwb2ludEJ5cHJv ZHVjdHMpKTsKICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAgewpAQCAtMjIwLDEyICsyMjAs OSBAQCB2b2lkIFBsYW46OnJ1bigpCiAgICAgICAgICAgICAgICAgbGlua0J1ZmZlci5saW5rKGNv bnRleHQuanNFbnRyeXBvaW50VG9XYXNtRW50cnlwb2ludENhbGwsIEZ1bmN0aW9uUHRyKG1fd2Fz bUludGVybmFsRnVuY3Rpb25zW2Z1bmN0aW9uSW5kZXhdLT53YXNtRW50cnlwb2ludC5jb21waWxh dGlvbi0+Y29kZSgpLmV4ZWN1dGFibGVBZGRyZXNzKCkpKTsKIAogICAgICAgICAgICAgICAgIG1f d2FzbUludGVybmFsRnVuY3Rpb25zW2Z1bmN0aW9uSW5kZXhdLT5qc1RvV2FzbUVudHJ5cG9pbnQu Y29tcGlsYXRpb24gPQotICAgICAgICAgICAgICAgICAgICBzdGQ6Om1ha2VfdW5pcXVlPEIzOjpD b21waWxhdGlvbj4oRklOQUxJWkVfQ09ERShsaW5rQnVmZmVyLCAoIldhc20gSlMgZW50cnlwb2lu dCIpKSwgV1RGTW92ZShjb250ZXh0LmpzRW50cnlwb2ludEJ5cHJvZHVjdHMpKTsKKyAgICAgICAg ICAgICAgICAgICAgc3RkOjptYWtlX3VuaXF1ZTxCMzo6Q29tcGlsYXRpb24+KEZJTkFMSVpFX0NP REUobGlua0J1ZmZlciwgKCJKYXZhU2NyaXB0LT5XZWJBc3NlbWJseSBlbnRyeXBvaW50WyVpXSAl cyIsIGZ1bmN0aW9uSW5kZXgsIHNpZ25hdHVyZURlc2NyaXB0aW9uLmFzY2lpKCkuZGF0YSgpKSks IFdURk1vdmUoY29udGV4dC5qc0VudHJ5cG9pbnRCeXByb2R1Y3RzKSk7CiAgICAgICAgICAgICB9 CiAgICAgICAgIH0KLQotICAgICAgICB1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2UgPSBtX3dh c21Ub0pTU3R1YnMuc2l6ZSgpICsgZnVuY3Rpb25JbmRleDsKLSAgICAgICAgbV9mdW5jdGlvbklu ZGV4U3BhY2UuYnVmZmVyLmdldCgpW2Z1bmN0aW9uSW5kZXhTcGFjZV0uY29kZSA9IG1fd2FzbUlu dGVybmFsRnVuY3Rpb25zW2Z1bmN0aW9uSW5kZXhdLT53YXNtRW50cnlwb2ludC5jb21waWxhdGlv bi0+Y29kZSgpLmV4ZWN1dGFibGVBZGRyZXNzKCk7CiAgICAgfQogCiAgICAgaWYgKHZlcmJvc2Ug fHwgT3B0aW9uczo6cmVwb3J0Q29tcGlsZVRpbWVzKCkpIHsKQEAgLTIzNSw4ICsyMzIsMTkgQEAg dm9pZCBQbGFuOjpydW4oKQogCiAgICAgLy8gUGF0Y2ggdGhlIGNhbGwgc2l0ZXMgZm9yIGVhY2gg V2ViQXNzZW1ibHkgZnVuY3Rpb24uCiAgICAgZm9yIChhdXRvJiB1bmxpbmtlZCA6IG1fdW5saW5r ZWRXYXNtVG9XYXNtQ2FsbHMpIHsKLSAgICAgICAgZm9yIChhdXRvJiBjYWxsIDogdW5saW5rZWQp Ci0gICAgICAgICAgICBNYWNyb0Fzc2VtYmxlcjo6cmVwYXRjaENhbGwoY2FsbC5jYWxsTG9jYXRp b24sIENvZGVMb2NhdGlvbkxhYmVsKG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtj YWxsLmZ1bmN0aW9uSW5kZXhdLmNvZGUpKTsKKyAgICAgICAgZm9yIChhdXRvJiBjYWxsIDogdW5s aW5rZWQpIHsKKyAgICAgICAgICAgIHZvaWQqIGV4ZWN1dGFibGVBZGRyZXNzOworICAgICAgICAg ICAgaWYgKG1fbW9kdWxlSW5mb3JtYXRpb24tPmlzSW1wb3J0ZWRGdW5jdGlvbkZyb21GdW5jdGlv bkluZGV4U3BhY2UoY2FsbC5mdW5jdGlvbkluZGV4KSkgeworICAgICAgICAgICAgICAgIC8vIEZJ WE1FIGltcG9ydHMgY291bGQgaGF2ZSBiZWVuIGxpbmtlZCBpbiBCMywgaW5zdGVhZCBvZiBnZW5l cmF0aW5nIGEgcGF0Y2hwb2ludC4gVGhpcyBjb25kaXRpb24gc2hvdWxkIGJlIHJlcGxhY2VkIGJ5 IGEgUkVMRUFTRV9BU1NFUlQuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0xNjY0NjIKKyAgICAgICAgICAgICAgICBleGVjdXRhYmxlQWRkcmVzcyA9IGNhbGwudGFyZ2V0 ID09IFVubGlua2VkV2FzbVRvV2FzbUNhbGw6OlRhcmdldDo6dG9KUworICAgICAgICAgICAgICAg ICAgICA/IG1fd2FzbUV4aXRTdHVicy5hdChjYWxsLmZ1bmN0aW9uSW5kZXgpLndhc21Ub0pTLmNv ZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpCisgICAgICAgICAgICAgICAgICAgIDogbV93YXNtRXhp dFN0dWJzLmF0KGNhbGwuZnVuY3Rpb25JbmRleCkud2FzbVRvV2FzbS5jb2RlKCkuZXhlY3V0YWJs ZUFkZHJlc3MoKTsKKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgQVNTRVJU KGNhbGwudGFyZ2V0ICE9IFVubGlua2VkV2FzbVRvV2FzbUNhbGw6OlRhcmdldDo6dG9KUyk7Cisg ICAgICAgICAgICAgICAgZXhlY3V0YWJsZUFkZHJlc3MgPSBtX3dhc21JbnRlcm5hbEZ1bmN0aW9u cy5hdChjYWxsLmZ1bmN0aW9uSW5kZXggLSBtX3dhc21FeGl0U3R1YnMuc2l6ZSgpKS0+d2FzbUVu dHJ5cG9pbnQuY29tcGlsYXRpb24tPmNvZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpOworICAgICAg ICAgICAgfQorICAgICAgICAgICAgTWFjcm9Bc3NlbWJsZXI6OnJlcGF0Y2hDYWxsKGNhbGwuY2Fs bExvY2F0aW9uLCBDb2RlTG9jYXRpb25MYWJlbChleGVjdXRhYmxlQWRkcmVzcykpOworICAgICAg ICB9CiAgICAgfQogCiAgICAgbV9mYWlsZWQgPSBmYWxzZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtUGxhbi5oCmluZGV4IDNiYjAxYzguLjY5ODBiZGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbVBsYW4uaApAQCAtODYsMjYgKzg2LDIwIEBAIHB1YmxpYzoKICAgICAgICAgcmV0 dXJuIFdURk1vdmUobV9jYWxsTGlua0luZm9zKTsKICAgICB9CiAKLSAgICBWZWN0b3I8V2FzbVRv SlNTdHViPiYmIHRha2VXYXNtVG9KU1N0dWJzKCkKKyAgICBWZWN0b3I8V2FzbUV4aXRTdHVicz4m JiB0YWtlV2FzbUV4aXRTdHVicygpCiAgICAgewogICAgICAgICBSRUxFQVNFX0FTU0VSVCghZmFp bGVkKCkpOwotICAgICAgICByZXR1cm4gV1RGTW92ZShtX3dhc21Ub0pTU3R1YnMpOwotICAgIH0K LQotICAgIEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmIHRha2VGdW5jdGlvbkluZGV4U3Bh Y2UoKQotICAgIHsKLSAgICAgICAgUkVMRUFTRV9BU1NFUlQoIWZhaWxlZCgpKTsKLSAgICAgICAg cmV0dXJuIFdURk1vdmUobV9mdW5jdGlvbkluZGV4U3BhY2UpOworICAgICAgICByZXR1cm4gV1RG TW92ZShtX3dhc21FeGl0U3R1YnMpOwogICAgIH0KIAogcHJpdmF0ZToKICAgICBzdGQ6OnVuaXF1 ZV9wdHI8TW9kdWxlSW5mb3JtYXRpb24+IG1fbW9kdWxlSW5mb3JtYXRpb247CiAgICAgVmVjdG9y PEZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeT4gbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnk7Cisg ICAgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiBtX21vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1 ZWRTaWduYXR1cmVJbmRpY2VzOwogICAgIEJhZzxDYWxsTGlua0luZm8+IG1fY2FsbExpbmtJbmZv czsKLSAgICBWZWN0b3I8V2FzbVRvSlNTdHViPiBtX3dhc21Ub0pTU3R1YnM7CisgICAgVmVjdG9y PFdhc21FeGl0U3R1YnM+IG1fd2FzbUV4aXRTdHViczsKICAgICBWZWN0b3I8c3RkOjp1bmlxdWVf cHRyPFdhc21JbnRlcm5hbEZ1bmN0aW9uPj4gbV93YXNtSW50ZXJuYWxGdW5jdGlvbnM7CiAgICAg VmVjdG9yPENvbXBpbGF0aW9uQ29udGV4dD4gbV9jb21waWxhdGlvbkNvbnRleHRzOwotICAgIElt bXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSBtX2Z1bmN0aW9uSW5kZXhTcGFjZTsKIAogICAgIFZN KiBtX3ZtOwogICAgIFZlY3RvcjxWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4+IG1fdW5s aW5rZWRXYXNtVG9XYXNtQ2FsbHM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9XYXNtU2lnbmF0dXJlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21T aWduYXR1cmUuY3BwCmluZGV4IDZkNWIxZjYuLjA5NjZkYWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuY3BwCkBAIC00MSwxMiArNDEsMjIgQEAgY29uc3Qg Ym9vbCB2ZXJib3NlID0gZmFsc2U7CiAKIGNvbnN0IGNvbnN0ZXhwciBTaWduYXR1cmVJbmRleCBT aWduYXR1cmU6OmludmFsaWRJbmRleDsKIAorU3RyaW5nIFNpZ25hdHVyZTo6dG9TdHJpbmcoKSBj b25zdAoreworICAgIFN0cmluZyByZXN1bHQobWFrZVN0cmluZyhyZXR1cm5UeXBlKCkpKTsKKyAg ICByZXN1bHQuYXBwZW5kKCIgKCIpOworICAgIGZvciAoU2lnbmF0dXJlQXJnQ291bnQgYXJnID0g MDsgYXJnIDwgYXJndW1lbnRDb3VudCgpOyArK2FyZykgeworICAgICAgICBpZiAoYXJnKQorICAg ICAgICAgICAgcmVzdWx0LmFwcGVuZCgiLCAiKTsKKyAgICAgICAgcmVzdWx0LmFwcGVuZChtYWtl U3RyaW5nKGFyZ3VtZW50KGFyZykpKTsKKyAgICB9CisgICAgcmVzdWx0LmFwcGVuZCgnKScpOwor ICAgIHJldHVybiByZXN1bHQ7Cit9CisKIHZvaWQgU2lnbmF0dXJlOjpkdW1wKFByaW50U3RyZWFt JiBvdXQpIGNvbnN0CiB7Ci0gICAgb3V0LnByaW50KG1ha2VTdHJpbmcocmV0dXJuVHlwZSgpKSwg IiAoIik7Ci0gICAgZm9yIChTaWduYXR1cmVBcmdDb3VudCBhcmcgPSAwOyBhcmcgPCBhcmd1bWVu dENvdW50KCk7ICsrYXJnKQotICAgICAgICBvdXQucHJpbnQoKGFyZyA/ICIsICIgOiAiIiksIG1h a2VTdHJpbmcoYXJndW1lbnQoYXJnKSkpOwotICAgIG91dC5wcmludCgiKSIpOworICAgIG91dC5w cmludCh0b1N0cmluZygpKTsKIH0KIAogdW5zaWduZWQgU2lnbmF0dXJlOjpoYXNoKCkgY29uc3QK ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuaCBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuaAppbmRleCAwZDZjN2I1 Li40ZDQzZmZjIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2ln bmF0dXJlLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5o CkBAIC04Miw2ICs4Miw3IEBAIHB1YmxpYzoKICAgICB9CiAgICAgVHlwZSBhcmd1bWVudChTaWdu YXR1cmVBcmdDb3VudCBpKSBjb25zdCB7IHJldHVybiBjb25zdF9jYXN0PFNpZ25hdHVyZSo+KHRo aXMpLT5hcmd1bWVudChpKTsgfQogCisgICAgV1RGOjpTdHJpbmcgdG9TdHJpbmcoKSBjb25zdDsK ICAgICB2b2lkIGR1bXAoV1RGOjpQcmludFN0cmVhbSYgb3V0KSBjb25zdDsKICAgICBib29sIG9w ZXJhdG9yPT0oY29uc3QgU2lnbmF0dXJlJiByaHMpIGNvbnN0CiAgICAgewpkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmNwcCBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5jcHAKaW5kZXggZTMyMTYxMy4uNzVkMzgyNiAx MDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmNwcAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwCkBAIC0zODEs MTAgKzM4MSwxMCBAQCB2b2lkIFZhbGlkYXRlOjpkdW1wKGNvbnN0IFZlY3RvcjxDb250cm9sRW50 cnk+JiBjb250cm9sU3RhY2ssIGNvbnN0IEV4cHJlc3Npb25MaQogICAgIGRhdGFMb2dMbigpOwog fQogCi1FeHBlY3RlZDx2b2lkLCBTdHJpbmc+IHZhbGlkYXRlRnVuY3Rpb24oVk0qIHZtLCBjb25z dCB1aW50OF90KiBzb3VyY2UsIHNpemVfdCBsZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0 dXJlLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIGZ1bmN0aW9uSW5kZXhTcGFj ZSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIG1vZHVsZSkKK0V4cGVjdGVkPHZvaWQsIFN0cmlu Zz4gdmFsaWRhdGVGdW5jdGlvbihWTSogdm0sIGNvbnN0IHVpbnQ4X3QqIHNvdXJjZSwgc2l6ZV90 IGxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUsIGNvbnN0IE1vZHVsZUluZm9ybWF0 aW9uJiBtb2R1bGUsIGNvbnN0IFZlY3RvcjxTaWduYXR1cmVJbmRleD4mIG1vZHVsZVNpZ25hdHVy ZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzKQogewogICAgIFZhbGlkYXRlIGNvbnRl eHQobW9kdWxlKTsKLSAgICBGdW5jdGlvblBhcnNlcjxWYWxpZGF0ZT4gdmFsaWRhdG9yKHZtLCBj b250ZXh0LCBzb3VyY2UsIGxlbmd0aCwgc2lnbmF0dXJlLCBmdW5jdGlvbkluZGV4U3BhY2UsIG1v ZHVsZSk7CisgICAgRnVuY3Rpb25QYXJzZXI8VmFsaWRhdGU+IHZhbGlkYXRvcih2bSwgY29udGV4 dCwgc291cmNlLCBsZW5ndGgsIHNpZ25hdHVyZSwgbW9kdWxlLCBtb2R1bGVTaWduYXR1cmVJbmRp Y2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcyk7CiAgICAgV0FTTV9GQUlMX0lGX0hFTFBFUl9G QUlMUyh2YWxpZGF0b3IucGFyc2UoKSk7CiAgICAgcmV0dXJuIHsgfTsKIH0KZGlmZiAtLWdpdCBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5oIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmgKaW5kZXggMTQ4MjFmMi4uNzNlN2Q4NyAxMDA2 NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmgKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmgKQEAgLTM2LDcgKzM2LDcg QEAgY2xhc3MgVk07CiAKIG5hbWVzcGFjZSBXYXNtIHsKIAotRXhwZWN0ZWQ8dm9pZCwgU3RyaW5n PiB2YWxpZGF0ZUZ1bmN0aW9uKFZNKiwgY29uc3QgdWludDhfdCosIHNpemVfdCwgY29uc3QgU2ln bmF0dXJlKiwgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiwgY29uc3QgTW9kdWxl SW5mb3JtYXRpb24mKTsKK0V4cGVjdGVkPHZvaWQsIFN0cmluZz4gdmFsaWRhdGVGdW5jdGlvbihW TSosIGNvbnN0IHVpbnQ4X3QqLCBzaXplX3QsIGNvbnN0IFNpZ25hdHVyZSosIGNvbnN0IE1vZHVs ZUluZm9ybWF0aW9uJiwgY29uc3QgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiYpOwogCiB9IH0gLy8g bmFtZXNwYWNlIEpTQzo6V2FzbQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5oCmluZGV4IDkyOGY0MjMuLjU0YWUxN2QgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0 YW5jZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJ bnN0YW5jZS5oCkBAIC00Miw3ICs0Miw3IEBAIHB1YmxpYzoKICAgICB0eXBlZGVmIEpTRGVzdHJ1 Y3RpYmxlT2JqZWN0IEJhc2U7CiAKIAotICAgIHN0YXRpYyBKU1dlYkFzc2VtYmx5SW5zdGFuY2Uq IGNyZWF0ZShWTSYsIFN0cnVjdHVyZSosIEpTV2ViQXNzZW1ibHlNb2R1bGUqLCBKU01vZHVsZU5h bWVzcGFjZU9iamVjdCopOworICAgIEpTX0VYUE9SVF9QUklWQVRFIHN0YXRpYyBKU1dlYkFzc2Vt Ymx5SW5zdGFuY2UqIGNyZWF0ZShWTSYsIFN0cnVjdHVyZSosIEpTV2ViQXNzZW1ibHlNb2R1bGUq LCBKU01vZHVsZU5hbWVzcGFjZU9iamVjdCopOwogICAgIHN0YXRpYyBTdHJ1Y3R1cmUqIGNyZWF0 ZVN0cnVjdHVyZShWTSYsIEpTR2xvYmFsT2JqZWN0KiwgSlNWYWx1ZSk7CiAKICAgICBERUNMQVJF X0lORk87CkBAIC04Niw5ICs4NiwxMSBAQCBwdWJsaWM6CiAgICAgICAgIHJldHVybiBvZmZzZXRP ZkltcG9ydEZ1bmN0aW9ucygpICsgc2l6ZW9mKFdyaXRlQmFycmllcjxKU0NlbGw+KSAqIGlkeDsK ICAgICB9CiAKLSAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mVGFibGUoKSB7IHJldHVybiBP QkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseUluc3RhbmNlLCBtX3RhYmxlKTsgfQogICAgIHN0 YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZNZW1vcnkoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0Yo SlNXZWJBc3NlbWJseUluc3RhbmNlLCBtX21lbW9yeSk7IH0KKyAgICBzdGF0aWMgcHRyZGlmZl90 IG9mZnNldE9mVGFibGUoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseUlu c3RhbmNlLCBtX3RhYmxlKTsgfQogICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZHbG9iYWxz KCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKEpTV2ViQXNzZW1ibHlJbnN0YW5jZSwgbV9nbG9i YWxzKTsgfQorICAgIHN0YXRpYyBzaXplX3Qgb2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbnMoKSB7IHJl dHVybiBXVEY6OnJvdW5kVXBUb011bHRpcGxlT2Y8c2l6ZW9mKFdyaXRlQmFycmllcjxKU0NlbGw+ KT4oc2l6ZW9mKEpTV2ViQXNzZW1ibHlJbnN0YW5jZSkpOyB9CisgICAgc3RhdGljIHNpemVfdCBv ZmZzZXRPZkltcG9ydEZ1bmN0aW9uKHNpemVfdCBpbXBvcnRGdW5jdGlvbk51bSkgeyByZXR1cm4g b2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbnMoKSArIGltcG9ydEZ1bmN0aW9uTnVtICogc2l6ZW9mKHNp emVvZihXcml0ZUJhcnJpZXI8SlNDZWxsPikpOyB9CiAKIHByb3RlY3RlZDoKICAgICBKU1dlYkFz c2VtYmx5SW5zdGFuY2UoVk0mLCBTdHJ1Y3R1cmUqLCB1bnNpZ25lZCBudW1JbXBvcnRGdW5jdGlv bnMpOwpAQCAtOTYsMTEgKzk4LDYgQEAgcHJvdGVjdGVkOgogICAgIHN0YXRpYyB2b2lkIGRlc3Ry b3koSlNDZWxsKik7CiAgICAgc3RhdGljIHZvaWQgdmlzaXRDaGlsZHJlbihKU0NlbGwqLCBTbG90 VmlzaXRvciYpOwogCi0gICAgc3RhdGljIHNpemVfdCBvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucygp Ci0gICAgewotICAgICAgICByZXR1cm4gV1RGOjpyb3VuZFVwVG9NdWx0aXBsZU9mPHNpemVvZihX cml0ZUJhcnJpZXI8SlNDZWxsPik+KHNpemVvZihKU1dlYkFzc2VtYmx5SW5zdGFuY2UpKTsKLSAg ICB9Ci0KICAgICBzdGF0aWMgc2l6ZV90IGFsbG9jYXRpb25TaXplKHVuc2lnbmVkIG51bUltcG9y dEZ1bmN0aW9ucykKICAgICB7CiAgICAgICAgIHJldHVybiBvZmZzZXRPZkltcG9ydEZ1bmN0aW9u cygpICsgc2l6ZW9mKFdyaXRlQmFycmllcjxKU0NlbGw+KSAqIG51bUltcG9ydEZ1bmN0aW9uczsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlN ZW1vcnkuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1l bW9yeS5jcHAKaW5kZXggNTI4YWI2OS4uNGM0Y2MzZSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5jcHAKKysrIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5jcHAKQEAgLTM3LDkgKzM3 LDkgQEAgbmFtZXNwYWNlIEpTQyB7CiAKIGNvbnN0IENsYXNzSW5mbyBKU1dlYkFzc2VtYmx5TWVt b3J5OjpzX2luZm8gPSB7ICJXZWJBc3NlbWJseS5NZW1vcnkiLCAmQmFzZTo6c19pbmZvLCAwLCBD UkVBVEVfTUVUSE9EX1RBQkxFKEpTV2ViQXNzZW1ibHlNZW1vcnkpIH07CiAKLUpTV2ViQXNzZW1i bHlNZW1vcnkqIEpTV2ViQXNzZW1ibHlNZW1vcnk6OmNyZWF0ZShWTSYgdm0sIFN0cnVjdHVyZSog c3RydWN0dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiYmIG1lbW9yeSkKK0pTV2Vi QXNzZW1ibHlNZW1vcnkqIEpTV2ViQXNzZW1ibHlNZW1vcnk6OmNyZWF0ZShWTSYgdm0sIFN0cnVj dHVyZSogc3RydWN0dXJlLCBXYXNtOjpNZW1vcnkmJiBtZW1vcnkpCiB7Ci0gICAgYXV0byogaW5z dGFuY2UgPSBuZXcgKE5vdE51bGwsIGFsbG9jYXRlQ2VsbDxKU1dlYkFzc2VtYmx5TWVtb3J5Pih2 bS5oZWFwKSkgSlNXZWJBc3NlbWJseU1lbW9yeSh2bSwgc3RydWN0dXJlLCBXVEZNb3ZlKG1lbW9y eSkpOworICAgIGF1dG8qIGluc3RhbmNlID0gbmV3IChOb3ROdWxsLCBhbGxvY2F0ZUNlbGw8SlNX ZWJBc3NlbWJseU1lbW9yeT4odm0uaGVhcCkpIEpTV2ViQXNzZW1ibHlNZW1vcnkodm0sIHN0cnVj dHVyZSwgc3RkOjpmb3J3YXJkPFdhc206Ok1lbW9yeT4obWVtb3J5KSk7CiAgICAgaW5zdGFuY2Ut PmZpbmlzaENyZWF0aW9uKHZtKTsKICAgICByZXR1cm4gaW5zdGFuY2U7CiB9CkBAIC00OSw3ICs0 OSw3IEBAIFN0cnVjdHVyZSogSlNXZWJBc3NlbWJseU1lbW9yeTo6Y3JlYXRlU3RydWN0dXJlKFZN JiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iCiAgICAgcmV0dXJuIFN0cnVjdHVyZTo6Y3Jl YXRlKHZtLCBnbG9iYWxPYmplY3QsIHByb3RvdHlwZSwgVHlwZUluZm8oT2JqZWN0VHlwZSwgU3Ry dWN0dXJlRmxhZ3MpLCBpbmZvKCkpOwogfQogCi1KU1dlYkFzc2VtYmx5TWVtb3J5OjpKU1dlYkFz c2VtYmx5TWVtb3J5KFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0 cjxXYXNtOjpNZW1vcnk+JiYgbWVtb3J5KQorSlNXZWJBc3NlbWJseU1lbW9yeTo6SlNXZWJBc3Nl bWJseU1lbW9yeShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBXYXNtOjpNZW1vcnkmJiBt ZW1vcnkpCiAgICAgOiBCYXNlKHZtLCBzdHJ1Y3R1cmUpCiAgICAgLCBtX21lbW9yeShXVEZNb3Zl KG1lbW9yeSkpCiB7CkBAIC03Miw3ICs3Miw3IEBAIEpTQXJyYXlCdWZmZXIqIEpTV2ViQXNzZW1i bHlNZW1vcnk6OmJ1ZmZlcihWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QpCiAg ICAgYXV0byBkZXN0cnVjdG9yID0gW10gKHZvaWQqKSB7CiAgICAgICAgIC8vIFdlIGRvbid0IG5l ZWQgdG8gZG8gYW55dGhpbmcgaGVyZSB0byBkZXN0cm95IHRoZSBtZW1vcnkuCiAgICAgICAgIC8v IFRoZSBBcnJheUJ1ZmZlciBiYWNraW5nIHRoZSBKU0FycmF5QnVmZmVyIGlzIG9ubHkgb3duZWQg YnkgdXMsCi0gICAgICAgIC8vIHNvIHdlIGd1YXJhbnRlZSBpdHMgbGlmZWN5bGNlLgorICAgICAg ICAvLyBzbyB3ZSBndWFyYW50ZWUgaXRzIGxpZmVjeWNsZS4KICAgICB9OwogICAgIG1fYnVmZmVy ID0gQXJyYXlCdWZmZXI6OmNyZWF0ZUZyb21CeXRlcyhtZW1vcnkoKS0+bWVtb3J5KCksIG1lbW9y eSgpLT5zaXplKCksIFdURk1vdmUoZGVzdHJ1Y3RvcikpOwogICAgIG1fYnVmZmVyV3JhcHBlci5z ZXQodm0sIHRoaXMsIEpTQXJyYXlCdWZmZXI6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LT5tX2Fy cmF5QnVmZmVyU3RydWN0dXJlLmdldCgpLCBtX2J1ZmZlci5nZXQoKSkpOwpAQCAtODUsNyArODUs NyBAQCBXYXNtOjpQYWdlQ291bnQgSlNXZWJBc3NlbWJseU1lbW9yeTo6Z3JvdyhFeGVjU3RhdGUq IGV4ZWMsIHVpbnQzMl90IGRlbHRhLCBib29sCiAgICAgVk0mIHZtID0gZXhlYy0+dm0oKTsKICAg ICBhdXRvIHRocm93U2NvcGUgPSBERUNMQVJFX1RIUk9XX1NDT1BFKHZtKTsKIAotICAgIFdhc206 OlBhZ2VDb3VudCBvbGRQYWdlQ291bnQgPSBtX21lbW9yeS0+c2l6ZUluUGFnZXMoKTsKKyAgICBX YXNtOjpQYWdlQ291bnQgb2xkUGFnZUNvdW50ID0gbWVtb3J5KCktPnNpemVJblBhZ2VzKCk7CiAK ICAgICBpZiAoIVdhc206OlBhZ2VDb3VudDo6aXNWYWxpZChkZWx0YSkpIHsKICAgICAgICAgaWYg KHNob3VsZFRocm93RXhjZXB0aW9uc09uRmFpbHVyZSkKQEAgLTEwMSw3ICsxMDEsNyBAQCBXYXNt OjpQYWdlQ291bnQgSlNXZWJBc3NlbWJseU1lbW9yeTo6Z3JvdyhFeGVjU3RhdGUqIGV4ZWMsIHVp bnQzMl90IGRlbHRhLCBib29sCiAgICAgfQogCiAgICAgaWYgKGRlbHRhKSB7Ci0gICAgICAgIGJv b2wgc3VjY2VzcyA9IG1fbWVtb3J5LT5ncm93KG5ld1NpemUpOworICAgICAgICBib29sIHN1Y2Nl c3MgPSBtZW1vcnkoKS0+Z3JvdyhuZXdTaXplKTsKICAgICAgICAgaWYgKCFzdWNjZXNzKSB7CiAg ICAgICAgICAgICBpZiAoc2hvdWxkVGhyb3dFeGNlcHRpb25zT25GYWlsdXJlKQogICAgICAgICAg ICAgICAgIHRocm93RXhjZXB0aW9uKGV4ZWMsIHRocm93U2NvcGUsIGNyZWF0ZU91dE9mTWVtb3J5 RXJyb3IoZXhlYykpOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMv SlNXZWJBc3NlbWJseU1lbW9yeS5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNX ZWJBc3NlbWJseU1lbW9yeS5oCmluZGV4IDI4Nzk3YzYuLjM5YTM1YmIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuaAorKysgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmgKQEAgLTQx LDI1ICs0MSwyNiBAQCBjbGFzcyBKU1dlYkFzc2VtYmx5TWVtb3J5IDogcHVibGljIEpTRGVzdHJ1 Y3RpYmxlT2JqZWN0IHsKIHB1YmxpYzoKICAgICB0eXBlZGVmIEpTRGVzdHJ1Y3RpYmxlT2JqZWN0 IEJhc2U7CiAKLSAgICBzdGF0aWMgSlNXZWJBc3NlbWJseU1lbW9yeSogY3JlYXRlKFZNJiwgU3Ry dWN0dXJlKiwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1lbW9yeT4mJik7CisgICAgSlNfRVhQT1JU X1BSSVZBVEUgc3RhdGljIEpTV2ViQXNzZW1ibHlNZW1vcnkqIGNyZWF0ZShWTSYsIFN0cnVjdHVy ZSosIFdhc206Ok1lbW9yeSYmKTsKICAgICBzdGF0aWMgU3RydWN0dXJlKiBjcmVhdGVTdHJ1Y3R1 cmUoVk0mLCBKU0dsb2JhbE9iamVjdCosIEpTVmFsdWUpOwogCi0gICAgREVDTEFSRV9JTkZPOwor ICAgIERFQ0xBUkVfRVhQT1JUX0lORk87CiAKLSAgICBXYXNtOjpNZW1vcnkqIG1lbW9yeSgpIHsg cmV0dXJuIG1fbWVtb3J5LmdldCgpOyB9CisgICAgV2FzbTo6TWVtb3J5KiBtZW1vcnkoKSB7IHJl dHVybiAmbV9tZW1vcnk7IH0KICAgICBKU0FycmF5QnVmZmVyKiBidWZmZXIoVk0mIHZtLCBKU0ds b2JhbE9iamVjdCopOwogICAgIFdhc206OlBhZ2VDb3VudCBncm93KEV4ZWNTdGF0ZSosIHVpbnQz Ml90IGRlbHRhLCBib29sIHNob3VsZFRocm93RXhjZXB0aW9uc09uRmFpbHVyZSk7CiAKLSAgICBz dGF0aWMgcHRyZGlmZl90IG9mZnNldE9mTWVtb3J5KCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9G KEpTV2ViQXNzZW1ibHlNZW1vcnksIG1fbWVtb3J5KTsgfQorICAgIHN0YXRpYyBwdHJkaWZmX3Qg b2Zmc2V0T2ZNZW1vcnkoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseU1l bW9yeSwgbV9tZW1vcnkpICsgV2FzbTo6TWVtb3J5OjpvZmZzZXRPZk1lbW9yeSgpOyB9CisgICAg c3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZlNpemUoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0Yo SlNXZWJBc3NlbWJseU1lbW9yeSwgbV9tZW1vcnkpICsgV2FzbTo6TWVtb3J5OjpvZmZzZXRPZlNp emUoKTsgfQogCiBwcm90ZWN0ZWQ6Ci0gICAgSlNXZWJBc3NlbWJseU1lbW9yeShWTSYsIFN0cnVj dHVyZSosIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+JiYpOworICAgIEpTV2ViQXNzZW1i bHlNZW1vcnkoVk0mLCBTdHJ1Y3R1cmUqLCBXYXNtOjpNZW1vcnkmJik7CiAgICAgfkpTV2ViQXNz ZW1ibHlNZW1vcnkoKTsKICAgICB2b2lkIGZpbmlzaENyZWF0aW9uKFZNJik7CiAgICAgc3RhdGlj IHZvaWQgZGVzdHJveShKU0NlbGwqKTsKICAgICBzdGF0aWMgdm9pZCB2aXNpdENoaWxkcmVuKEpT Q2VsbCosIFNsb3RWaXNpdG9yJik7CiAKLSAgICBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5 PiBtX21lbW9yeTsKKyAgICBXYXNtOjpNZW1vcnkgbV9tZW1vcnk7CiAgICAgV3JpdGVCYXJyaWVy PEpTQXJyYXlCdWZmZXI+IG1fYnVmZmVyV3JhcHBlcjsKICAgICBSZWZQdHI8QXJyYXlCdWZmZXI+ IG1fYnVmZmVyOwogfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pz L0pTV2ViQXNzZW1ibHlNb2R1bGUuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMv SlNXZWJBc3NlbWJseU1vZHVsZS5jcHAKaW5kZXggZDY1MjRjNS4uZmEwZTg1OSAxMDA2NDQKLS0t IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5jcHAK KysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5j cHAKQEAgLTM4LDkgKzM4LDkgQEAgbmFtZXNwYWNlIEpTQyB7CiAKIGNvbnN0IENsYXNzSW5mbyBK U1dlYkFzc2VtYmx5TW9kdWxlOjpzX2luZm8gPSB7ICJXZWJBc3NlbWJseS5Nb2R1bGUiLCAmQmFz ZTo6c19pbmZvLCBudWxscHRyLCBDUkVBVEVfTUVUSE9EX1RBQkxFKEpTV2ViQXNzZW1ibHlNb2R1 bGUpIH07CiAKLUpTV2ViQXNzZW1ibHlNb2R1bGUqIEpTV2ViQXNzZW1ibHlNb2R1bGU6OmNyZWF0 ZShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9k dWxlSW5mb3JtYXRpb24+JiYgbW9kdWxlSW5mb3JtYXRpb24sIEJhZzxDYWxsTGlua0luZm8+JiYg Y2FsbExpbmtJbmZvcywgVmVjdG9yPFdhc206Oldhc21Ub0pTU3R1Yj4mJiB3YXNtVG9KU1N0dWJz LCBXYXNtOjpJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmJiBmdW5jdGlvbkluZGV4U3BhY2Us IFN5bWJvbFRhYmxlKiBleHBvcnRTeW1ib2xUYWJsZSwgdW5zaWduZWQgY2FsbGVlQ291bnQpCitK U1dlYkFzc2VtYmx5TW9kdWxlKiBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGUoVk0mIHZtLCBT dHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0 aW9uPiYmIG1vZHVsZUluZm9ybWF0aW9uLCBCYWc8Q2FsbExpbmtJbmZvPiYmIGNhbGxMaW5rSW5m b3MsIFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPiYmIHdhc21FeGl0U3R1YnMsIFN5bWJvbFRh YmxlKiBleHBvcnRTeW1ib2xUYWJsZSwgdW5zaWduZWQgY2FsbGVlQ291bnQpCiB7Ci0gICAgYXV0 byogaW5zdGFuY2UgPSBuZXcgKE5vdE51bGwsIGFsbG9jYXRlQ2VsbDxKU1dlYkFzc2VtYmx5TW9k dWxlPih2bS5oZWFwLCBhbGxvY2F0aW9uU2l6ZShjYWxsZWVDb3VudCkpKSBKU1dlYkFzc2VtYmx5 TW9kdWxlKHZtLCBzdHJ1Y3R1cmUsIHN0ZDo6Zm9yd2FyZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6 TW9kdWxlSW5mb3JtYXRpb24+Pihtb2R1bGVJbmZvcm1hdGlvbiksIHN0ZDo6Zm9yd2FyZDxCYWc8 Q2FsbExpbmtJbmZvPj4oY2FsbExpbmtJbmZvcyksIHN0ZDo6Zm9yd2FyZDxWZWN0b3I8V2FzbTo6 V2FzbVRvSlNTdHViPj4od2FzbVRvSlNTdHVicyksIHN0ZDo6Zm9yd2FyZDxXYXNtOjpJbW11dGFi bGVGdW5jdGlvbkluZGV4U3BhY2U+KGZ1bmN0aW9uSW5kZXhTcGFjZSksIGNhbGxlZUNvdW50KTsK KyAgICBhdXRvKiBpbnN0YW5jZSA9IG5ldyAoTm90TnVsbCwgYWxsb2NhdGVDZWxsPEpTV2ViQXNz ZW1ibHlNb2R1bGU+KHZtLmhlYXAsIGFsbG9jYXRpb25TaXplKGNhbGxlZUNvdW50KSkpIEpTV2Vi QXNzZW1ibHlNb2R1bGUodm0sIHN0cnVjdHVyZSwgc3RkOjpmb3J3YXJkPHN0ZDo6dW5pcXVlX3B0 cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4+KG1vZHVsZUluZm9ybWF0aW9uKSwgc3RkOjpmb3J3 YXJkPEJhZzxDYWxsTGlua0luZm8+PihjYWxsTGlua0luZm9zKSwgc3RkOjpmb3J3YXJkPFZlY3Rv cjxXYXNtOjpXYXNtRXhpdFN0dWJzPj4od2FzbUV4aXRTdHVicyksIGNhbGxlZUNvdW50KTsKICAg ICBpbnN0YW5jZS0+ZmluaXNoQ3JlYXRpb24odm0sIGV4cG9ydFN5bWJvbFRhYmxlKTsKICAgICBy ZXR1cm4gaW5zdGFuY2U7CiB9CkBAIC01MCwxMiArNTAsMTEgQEAgU3RydWN0dXJlKiBKU1dlYkFz c2VtYmx5TW9kdWxlOjpjcmVhdGVTdHJ1Y3R1cmUoVk0mIHZtLCBKU0dsb2JhbE9iamVjdCogZ2xv YmFsT2IKICAgICByZXR1cm4gU3RydWN0dXJlOjpjcmVhdGUodm0sIGdsb2JhbE9iamVjdCwgcHJv dG90eXBlLCBUeXBlSW5mbyhPYmplY3RUeXBlLCBTdHJ1Y3R1cmVGbGFncyksIGluZm8oKSk7CiB9 CiAKLUpTV2ViQXNzZW1ibHlNb2R1bGU6OkpTV2ViQXNzZW1ibHlNb2R1bGUoVk0mIHZtLCBTdHJ1 Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9u PiYmIG1vZHVsZUluZm9ybWF0aW9uLCBCYWc8Q2FsbExpbmtJbmZvPiYmIGNhbGxMaW5rSW5mb3Ms IFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0dWI+JiYgd2FzbVRvSlNTdHVicywgV2FzbTo6SW1tdXRh YmxlRnVuY3Rpb25JbmRleFNwYWNlJiYgZnVuY3Rpb25JbmRleFNwYWNlLCB1bnNpZ25lZCBjYWxs ZWVDb3VudCkKK0pTV2ViQXNzZW1ibHlNb2R1bGU6OkpTV2ViQXNzZW1ibHlNb2R1bGUoVk0mIHZt LCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9y bWF0aW9uPiYmIG1vZHVsZUluZm9ybWF0aW9uLCBCYWc8Q2FsbExpbmtJbmZvPiYmIGNhbGxMaW5r SW5mb3MsIFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPiYmIHdhc21FeGl0U3R1YnMsIHVuc2ln bmVkIGNhbGxlZUNvdW50KQogICAgIDogQmFzZSh2bSwgc3RydWN0dXJlKQogICAgICwgbV9tb2R1 bGVJbmZvcm1hdGlvbihXVEZNb3ZlKG1vZHVsZUluZm9ybWF0aW9uKSkKICAgICAsIG1fY2FsbExp bmtJbmZvcyhXVEZNb3ZlKGNhbGxMaW5rSW5mb3MpKQotICAgICwgbV93YXNtVG9KU1N0dWJzKFdU Rk1vdmUod2FzbVRvSlNTdHVicykpCi0gICAgLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZShXVEZNb3Zl KGZ1bmN0aW9uSW5kZXhTcGFjZSkpCisgICAgLCBtX3dhc21FeGl0U3R1YnMoV1RGTW92ZSh3YXNt RXhpdFN0dWJzKSkKICAgICAsIG1fY2FsbGVlQ291bnQoY2FsbGVlQ291bnQpCiB7CiAgICAgbWVt c2V0KGNhbGxlZXMoKSwgMCwgbV9jYWxsZWVDb3VudCAqIHNpemVvZihXcml0ZUJhcnJpZXI8SlNX ZWJBc3NlbWJseUNhbGxlZT4pICogMik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmgKaW5kZXggZmVjNGVlZC4uZmE2NzNhZiAxMDA2 NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVs ZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1 bGUuaApAQCAtNDMsMTkgKzQzLDE4IEBAIGNsYXNzIEpTV2ViQXNzZW1ibHlNb2R1bGUgOiBwdWJs aWMgSlNEZXN0cnVjdGlibGVPYmplY3QgewogcHVibGljOgogICAgIHR5cGVkZWYgSlNEZXN0cnVj dGlibGVPYmplY3QgQmFzZTsKIAotICAgIHN0YXRpYyBKU1dlYkFzc2VtYmx5TW9kdWxlKiBjcmVh dGUoVk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRp b24+JiYsIEJhZzxDYWxsTGlua0luZm8+JiYsIFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0dWI+JiYs IFdhc206OkltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmLCBTeW1ib2xUYWJsZSosIHVuc2ln bmVkKTsKKyAgICBKU19FWFBPUlRfUFJJVkFURSBzdGF0aWMgSlNXZWJBc3NlbWJseU1vZHVsZSog Y3JlYXRlKFZNJiwgU3RydWN0dXJlKiwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9y bWF0aW9uPiYmLCBCYWc8Q2FsbExpbmtJbmZvPiYmLCBWZWN0b3I8V2FzbTo6V2FzbUV4aXRTdHVi cz4mJiwgU3ltYm9sVGFibGUqLCB1bnNpZ25lZCk7CiAgICAgc3RhdGljIFN0cnVjdHVyZSogY3Jl YXRlU3RydWN0dXJlKFZNJiwgSlNHbG9iYWxPYmplY3QqLCBKU1ZhbHVlKTsKIAogICAgIERFQ0xB UkVfSU5GTzsKIAogICAgIGNvbnN0IFdhc206Ok1vZHVsZUluZm9ybWF0aW9uJiBtb2R1bGVJbmZv cm1hdGlvbigpIGNvbnN0IHsgcmV0dXJuICptX21vZHVsZUluZm9ybWF0aW9uLmdldCgpOyB9CiAg ICAgU3ltYm9sVGFibGUqIGV4cG9ydFN5bWJvbFRhYmxlKCkgY29uc3QgeyByZXR1cm4gbV9leHBv cnRTeW1ib2xUYWJsZS5nZXQoKTsgfQotICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVy ZUZvckZ1bmN0aW9uSW5kZXhTcGFjZSh1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2UpIGNvbnN0 CisgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRl eFNwYWNlKHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFjZSkgY29uc3QKICAgICB7Ci0gICAgICAg IEFTU0VSVChmdW5jdGlvbkluZGV4U3BhY2UgPCBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5zaXplKTsK LSAgICAgICAgcmV0dXJuIG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtmdW5jdGlv bkluZGV4U3BhY2VdLnNpZ25hdHVyZUluZGV4OworICAgICAgICByZXR1cm4gbV9tb2R1bGVJbmZv cm1hdGlvbi0+c2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5k ZXhTcGFjZSk7CiAgICAgfQotICAgIHVuc2lnbmVkIGZ1bmN0aW9uSW1wb3J0Q291bnQoKSBjb25z dCB7IHJldHVybiBtX3dhc21Ub0pTU3R1YnMuc2l6ZSgpOyB9CisgICAgdW5zaWduZWQgZnVuY3Rp b25JbXBvcnRDb3VudCgpIGNvbnN0IHsgcmV0dXJuIG1fd2FzbUV4aXRTdHVicy5zaXplKCk7IH0K IAogICAgIEpTV2ViQXNzZW1ibHlDYWxsZWUqIGpzRW50cnlwb2ludENhbGxlZUZyb21GdW5jdGlv bkluZGV4U3BhY2UodW5zaWduZWQgZnVuY3Rpb25JbmRleFNwYWNlKQogICAgIHsKQEAgLTkwLDEw ICs4OSw4IEBAIHB1YmxpYzoKICAgICAgICAgcmV0dXJuIGJpdHdpc2VfY2FzdDxXcml0ZUJhcnJp ZXI8SlNXZWJBc3NlbWJseUNhbGxlZT4qPihiaXR3aXNlX2Nhc3Q8Y2hhcio+KHRoaXMpICsgb2Zm c2V0T2ZDYWxsZWVzKCkpOwogICAgIH0KIAotICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZG dW5jdGlvbkluZGV4U3BhY2UoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJs eU1vZHVsZSwgbV9mdW5jdGlvbkluZGV4U3BhY2UpOyB9Ci0KIHByb3RlY3RlZDoKLSAgICBKU1dl YkFzc2VtYmx5TW9kdWxlKFZNJiwgU3RydWN0dXJlKiwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1v ZHVsZUluZm9ybWF0aW9uPiYmLCBCYWc8Q2FsbExpbmtJbmZvPiYmLCBWZWN0b3I8V2FzbTo6V2Fz bVRvSlNTdHViPiYmLCBXYXNtOjpJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmJiwgdW5zaWdu ZWQgY2FsbGVlQ291bnQpOworICAgIEpTV2ViQXNzZW1ibHlNb2R1bGUoVk0mLCBTdHJ1Y3R1cmUq LCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYsIEJhZzxDYWxsTGlu a0luZm8+JiYsIFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPiYmLCB1bnNpZ25lZCBjYWxsZWVD b3VudCk7CiAgICAgdm9pZCBmaW5pc2hDcmVhdGlvbihWTSYsIFN5bWJvbFRhYmxlKik7CiAgICAg c3RhdGljIHZvaWQgZGVzdHJveShKU0NlbGwqKTsKICAgICBzdGF0aWMgdm9pZCB2aXNpdENoaWxk cmVuKEpTQ2VsbCosIFNsb3RWaXNpdG9yJik7CkBAIC0xMTcsOCArMTE0LDcgQEAgcHJpdmF0ZToK ICAgICBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+IG1fbW9kdWxlSW5m b3JtYXRpb247CiAgICAgQmFnPENhbGxMaW5rSW5mbz4gbV9jYWxsTGlua0luZm9zOwogICAgIFdy aXRlQmFycmllcjxTeW1ib2xUYWJsZT4gbV9leHBvcnRTeW1ib2xUYWJsZTsKLSAgICBWZWN0b3I8 V2FzbTo6V2FzbVRvSlNTdHViPiBtX3dhc21Ub0pTU3R1YnM7Ci0gICAgY29uc3QgV2FzbTo6SW1t dXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlIG1fZnVuY3Rpb25JbmRleFNwYWNlOworICAgIFZlY3Rv cjxXYXNtOjpXYXNtRXhpdFN0dWJzPiBtX3dhc21FeGl0U3R1YnM7CiAgICAgdW5zaWduZWQgbV9j YWxsZWVDb3VudDsKIH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v anMvV2ViQXNzZW1ibHlGdW5jdGlvbi5jcHAKaW5kZXggYmUyN2Y1Ny4uYmNhNDc5MiAxMDA2NDQK LS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlvbi5j cHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlv bi5jcHAKQEAgLTExOSw2ICsxMTksNyBAQCBzdGF0aWMgRW5jb2RlZEpTVmFsdWUgSlNDX0hPU1Rf Q0FMTCBjYWxsV2ViQXNzZW1ibHlGdW5jdGlvbihFeGVjU3RhdGUqIGV4ZWMpCiAgICAgUHJvdG9D YWxsRnJhbWUgcHJvdG9DYWxsRnJhbWU7CiAgICAgcHJvdG9DYWxsRnJhbWUuaW5pdChudWxscHRy LCB3YXNtRnVuY3Rpb24sIGZpcnN0QXJndW1lbnQsIGFyZ0NvdW50LCByZW1haW5pbmdBcmdzKTsK IAorICAgIC8vIEZJWE1FIERvIGF3YXkgd2l0aCB0aGlzIGVudGlyZSBmdW5jdGlvbiwgYW5kIG9u bHkgdXNlIHRoZSBlbnRyeXBvaW50IGdlbmVyYXRlZCBieSBCMy4gaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NjQ4NgogICAgIEpTV2ViQXNzZW1ibHlJbnN0YW5jZSog cHJldkpTV2ViQXNzZW1ibHlJbnN0YW5jZSA9IHZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZTsK ICAgICB2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UgPSB3YXNtRnVuY3Rpb24tPmluc3RhbmNl KCk7CiAgICAgQVNTRVJUKHdhc21GdW5jdGlvbi0+aW5zdGFuY2UoKSk7CkBAIC0xNDksNyArMTUw LDcgQEAgV2ViQXNzZW1ibHlGdW5jdGlvbiogV2ViQXNzZW1ibHlGdW5jdGlvbjo6Y3JlYXRlKFZN JiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE8KIHsKICAgICBOYXRpdmVFeGVjdXRhYmxlKiBl eGVjdXRhYmxlID0gdm0uZ2V0SG9zdEZ1bmN0aW9uKGNhbGxXZWJBc3NlbWJseUZ1bmN0aW9uLCBO b0ludHJpbnNpYywgY2FsbEhvc3RGdW5jdGlvbkFzQ29uc3RydWN0b3IsIG51bGxwdHIsIG5hbWUp OwogICAgIFN0cnVjdHVyZSogc3RydWN0dXJlID0gZ2xvYmFsT2JqZWN0LT53ZWJBc3NlbWJseUZ1 bmN0aW9uU3RydWN0dXJlKCk7Ci0gICAgV2ViQXNzZW1ibHlGdW5jdGlvbiogZnVuY3Rpb24gPSBu ZXcgKE5vdE51bGwsIGFsbG9jYXRlQ2VsbDxXZWJBc3NlbWJseUZ1bmN0aW9uPih2bS5oZWFwKSkg V2ViQXNzZW1ibHlGdW5jdGlvbih2bSwgZ2xvYmFsT2JqZWN0LCBzdHJ1Y3R1cmUsIHNpZ25hdHVy ZUluZGV4KTsKKyAgICBXZWJBc3NlbWJseUZ1bmN0aW9uKiBmdW5jdGlvbiA9IG5ldyAoTm90TnVs bCwgYWxsb2NhdGVDZWxsPFdlYkFzc2VtYmx5RnVuY3Rpb24+KHZtLmhlYXApKSBXZWJBc3NlbWJs eUZ1bmN0aW9uKHZtLCBnbG9iYWxPYmplY3QsIHN0cnVjdHVyZSwgc2lnbmF0dXJlSW5kZXgsIHdh c21FbnRyeXBvaW50LT5lbnRyeXBvaW50KCkpOwogICAgIGZ1bmN0aW9uLT5maW5pc2hDcmVhdGlv bih2bSwgZXhlY3V0YWJsZSwgbGVuZ3RoLCBuYW1lLCBpbnN0YW5jZSwganNFbnRyeXBvaW50LCB3 YXNtRW50cnlwb2ludCk7CiAgICAgcmV0dXJuIGZ1bmN0aW9uOwogfQpAQCAtMTU3LDExICsxNTgs MTIgQEAgV2ViQXNzZW1ibHlGdW5jdGlvbiogV2ViQXNzZW1ibHlGdW5jdGlvbjo6Y3JlYXRlKFZN JiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE8KIFN0cnVjdHVyZSogV2ViQXNzZW1ibHlGdW5j dGlvbjo6Y3JlYXRlU3RydWN0dXJlKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVj dCwgSlNWYWx1ZSBwcm90b3R5cGUpCiB7CiAgICAgQVNTRVJUKGdsb2JhbE9iamVjdCk7Ci0gICAg cmV0dXJuIFN0cnVjdHVyZTo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3QsIHByb3RvdHlwZSwgVHlw ZUluZm8oSlNGdW5jdGlvblR5cGUsIFN0cnVjdHVyZUZsYWdzKSwgaW5mbygpKTsKKyAgICByZXR1 cm4gU3RydWN0dXJlOjpjcmVhdGUodm0sIGdsb2JhbE9iamVjdCwgcHJvdG90eXBlLCBUeXBlSW5m byhXZWJBc3NlbWJseUZ1bmN0aW9uVHlwZSwgU3RydWN0dXJlRmxhZ3MpLCBpbmZvKCkpOwogfQog Ci1XZWJBc3NlbWJseUZ1bmN0aW9uOjpXZWJBc3NlbWJseUZ1bmN0aW9uKFZNJiB2bSwgSlNHbG9i YWxPYmplY3QqIGdsb2JhbE9iamVjdCwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIFdhc206OlNpZ25h dHVyZUluZGV4IHNpZ25hdHVyZUluZGV4KQorV2ViQXNzZW1ibHlGdW5jdGlvbjo6V2ViQXNzZW1i bHlGdW5jdGlvbihWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QsIFN0cnVjdHVy ZSogc3RydWN0dXJlLCBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCwgdm9pZCog d2FzbUVudHJ5cG9pbnQpCiAgICAgOiBCYXNlKHZtLCBnbG9iYWxPYmplY3QsIHN0cnVjdHVyZSkK KyAgICAsIG1fd2FzbUVudHJ5UG9pbnRDb2RlKHdhc21FbnRyeXBvaW50KQogICAgICwgbV9zaWdu YXR1cmVJbmRleChzaWduYXR1cmVJbmRleCkKIHsgfQogCkBAIC0xODMsNiArMTg1LDcgQEAgdm9p ZCBXZWJBc3NlbWJseUZ1bmN0aW9uOjpmaW5pc2hDcmVhdGlvbihWTSYgdm0sIE5hdGl2ZUV4ZWN1 dGFibGUqIGV4ZWN1dGFibGUsIHUKICAgICBBU1NFUlQoanNFbnRyeXBvaW50ICE9IHdhc21FbnRy eXBvaW50KTsKICAgICBtX2pzRW50cnlwb2ludC5zZXQodm0sIHRoaXMsIGpzRW50cnlwb2ludCk7 CiAgICAgbV93YXNtRW50cnlwb2ludC5zZXQodm0sIHRoaXMsIHdhc21FbnRyeXBvaW50KTsKKyAg ICBBU1NFUlQobV93YXNtRW50cnlwb2ludC0+ZW50cnlwb2ludCgpID09IG1fd2FzbUVudHJ5UG9p bnRDb2RlKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UgSlNDCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmggYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmgKaW5kZXggMzQ5MDUwMi4uMzg3 N2EwMiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1i bHlGdW5jdGlvbi5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2Vt Ymx5RnVuY3Rpb24uaApAQCAtNTQsMTggKzU0LDIyIEBAIHB1YmxpYzoKIAogICAgIEpTV2ViQXNz ZW1ibHlJbnN0YW5jZSogaW5zdGFuY2UoKSBjb25zdCB7IHJldHVybiBtX2luc3RhbmNlLmdldCgp OyB9CiAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXgoKSBjb25zdCB7IHJl dHVybiBtX3NpZ25hdHVyZUluZGV4OyB9Ci0gICAgdm9pZCogd2FzbUVudHJ5cG9pbnQoKSB7IHJl dHVybiBtX3dhc21FbnRyeXBvaW50LT5lbnRyeXBvaW50KCk7IH0KKyAgICB2b2lkKiB3YXNtRW50 cnlwb2ludCgpIHsgcmV0dXJuIG1fd2FzbUVudHJ5UG9pbnRDb2RlOyB9CiAgICAgdm9pZCoganNF bnRyeXBvaW50KCkgeyByZXR1cm4gbV9qc0VudHJ5cG9pbnQtPmVudHJ5cG9pbnQoKTsgfQogCisg ICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZkluc3RhbmNlKCkgeyByZXR1cm4gT0JKRUNUX09G RlNFVE9GKFdlYkFzc2VtYmx5RnVuY3Rpb24sIG1faW5zdGFuY2UpOyB9CisgICAgc3RhdGljIHB0 cmRpZmZfdCBvZmZzZXRPZldhc21FbnRyeVBvaW50Q29kZSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZT RVRPRihXZWJBc3NlbWJseUZ1bmN0aW9uLCBtX3dhc21FbnRyeVBvaW50Q29kZSk7IH0KKwogcHJv dGVjdGVkOgogICAgIHN0YXRpYyB2b2lkIHZpc2l0Q2hpbGRyZW4oSlNDZWxsKiwgU2xvdFZpc2l0 b3ImKTsKIAogICAgIHZvaWQgZmluaXNoQ3JlYXRpb24oVk0mLCBOYXRpdmVFeGVjdXRhYmxlKiwg dW5zaWduZWQgbGVuZ3RoLCBjb25zdCBTdHJpbmcmIG5hbWUsIEpTV2ViQXNzZW1ibHlJbnN0YW5j ZSosIEpTV2ViQXNzZW1ibHlDYWxsZWUqIGpzRW50cnlwb2ludCwgSlNXZWJBc3NlbWJseUNhbGxl ZSogd2FzbUVudHJ5cG9pbnQpOwogCiBwcml2YXRlOgotICAgIFdlYkFzc2VtYmx5RnVuY3Rpb24o Vk0mLCBKU0dsb2JhbE9iamVjdCosIFN0cnVjdHVyZSosIFdhc206OlNpZ25hdHVyZUluZGV4KTsK KyAgICBXZWJBc3NlbWJseUZ1bmN0aW9uKFZNJiwgSlNHbG9iYWxPYmplY3QqLCBTdHJ1Y3R1cmUq LCBXYXNtOjpTaWduYXR1cmVJbmRleCwgdm9pZCopOwogCiAgICAgV3JpdGVCYXJyaWVyPEpTV2Vi QXNzZW1ibHlJbnN0YW5jZT4gbV9pbnN0YW5jZTsKKyAgICB2b2lkKiBtX3dhc21FbnRyeVBvaW50 Q29kZTsgLy8gUmVtb3ZlIGluZGlyZWN0aW9ucyBmb3Igd2FzbSAtPiB3YXNtIGNhbGxzLgogICAg IFdyaXRlQmFycmllcjxKU1dlYkFzc2VtYmx5Q2FsbGVlPiBtX2pzRW50cnlwb2ludDsKICAgICBX cml0ZUJhcnJpZXI8SlNXZWJBc3NlbWJseUNhbGxlZT4gbV93YXNtRW50cnlwb2ludDsKICAgICBX YXNtOjpTaWduYXR1cmVJbmRleCBtX3NpZ25hdHVyZUluZGV4OwpkaWZmIC0tZ2l0IGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVjdG9yLmNw cCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VDb25z dHJ1Y3Rvci5jcHAKaW5kZXggZDYwZjQwZS4uMWI0NjExMiAxMDA2NDQKLS0tIGEvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVjdG9yLmNwcAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUluc3RhbmNlQ29u c3RydWN0b3IuY3BwCkBAIC04NCw2ICs4NCwxMSBAQCBzdGF0aWMgRW5jb2RlZEpTVmFsdWUgSlND X0hPU1RfQ0FMTCBjb25zdHJ1Y3RKU1dlYkFzc2VtYmx5SW5zdGFuY2UoRXhlY1N0YXRlKiBleAog CiAgICAgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBpbnN0YW5jZSA9IEpTV2ViQXNzZW1ibHlJbnN0 YW5jZTo6Y3JlYXRlKHZtLCBpbnN0YW5jZVN0cnVjdHVyZSwganNNb2R1bGUsIG1vZHVsZVJlY29y ZC0+Z2V0TW9kdWxlTmFtZXNwYWNlKGV4ZWMpKTsKICAgICBSRVRVUk5fSUZfRVhDRVBUSU9OKHRo cm93U2NvcGUsIGVuY29kZWRKU1ZhbHVlKCkpOworICAgIHsKKyAgICAgICAgLy8gQWx3YXlzIHN0 YXJ0IHdpdGggYSBkdW1teSBNZW1vcnksIHNvIHRoYXQgd2FzbSAtPiB3YXNtIHRodW5rcyBhdm9p ZCBjaGVja2luZyBmb3IgYSBudWxscHRyIE1lbW9yeSB3aGVuIHRyeWluZyB0byBzZXQgcGlubmVk IHJlZ2lzdGVycy4KKyAgICAgICAgV2FzbTo6TWVtb3J5IG1lbW9yeTsKKyAgICAgICAgaW5zdGFu Y2UtPnNldE1lbW9yeSh2bSwgSlNXZWJBc3NlbWJseU1lbW9yeTo6Y3JlYXRlKHZtLCBleGVjLT5s ZXhpY2FsR2xvYmFsT2JqZWN0KCktPldlYkFzc2VtYmx5TWVtb3J5U3RydWN0dXJlKCksIFdURk1v dmUobWVtb3J5KSkpOworICAgIH0KIAogICAgIC8vIExldCBmdW5jcywgbWVtb3JpZXMgYW5kIHRh YmxlcyBiZSBpbml0aWFsbHktZW1wdHkgbGlzdHMgb2YgY2FsbGFibGUgSmF2YVNjcmlwdCBvYmpl Y3RzLCBXZWJBc3NlbWJseS5NZW1vcnkgb2JqZWN0cyBhbmQgV2ViQXNzZW1ibHkuVGFibGUgb2Jq ZWN0cywgcmVzcGVjdGl2ZWx5LgogICAgIC8vIExldCBpbXBvcnRzIGJlIGFuIGluaXRpYWxseS1l bXB0eSBsaXN0IG9mIGV4dGVybmFsIHZhbHVlcy4KQEAgLTExNCwxOCArMTE5LDE5IEBAIHN0YXRp YyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGNvbnN0cnVjdEpTV2ViQXNzZW1ibHlJbnN0 YW5jZShFeGVjU3RhdGUqIGV4CiAgICAgICAgICAgICAgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29k ZSh0aHJvd0V4Y2VwdGlvbihleGVjLCB0aHJvd1Njb3BlLCBjcmVhdGVKU1dlYkFzc2VtYmx5TGlu a0Vycm9yKGV4ZWMsIHZtLCBBU0NJSUxpdGVyYWwoImltcG9ydCBmdW5jdGlvbiBtdXN0IGJlIGNh bGxhYmxlIikpKSk7CiAgICAgICAgICAgICBKU0NlbGwqIGNlbGwgPSB2YWx1ZS5hc0NlbGwoKTsK ICAgICAgICAgICAgIC8vIGlpLiBJZiB2IGlzIGFuIEV4cG9ydGVkIEZ1bmN0aW9uIEV4b3RpYyBP YmplY3Q6Ci0gICAgICAgICAgICBpZiAoV2ViQXNzZW1ibHlGdW5jdGlvbiogaW1wb3J0ZWRFeHBv cnRzID0ganNEeW5hbWljQ2FzdDxXZWJBc3NlbWJseUZ1bmN0aW9uKj4ob2JqZWN0KSkgewotICAg ICAgICAgICAgICAgIC8vIEZJWE1FIGhhbmRsZSBGdW5jdGlvbiBFeG90aWMgT2JqZWN0IHByb3Bl cmx5LiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1MjgyCi0gICAg ICAgICAgICAgICAgLy8gYS4gSWYgdGhlIHNpZ25hdHVyZSBvZiB2IGRvZXMgbm90IG1hdGNoIHRo ZSBzaWduYXR1cmUgb2YgaSwgdGhyb3cgYSBUeXBlRXJyb3IuCisgICAgICAgICAgICBpZiAoV2Vi QXNzZW1ibHlGdW5jdGlvbiogaW1wb3J0ZWRFeHBvcnQgPSBqc0R5bmFtaWNDYXN0PFdlYkFzc2Vt Ymx5RnVuY3Rpb24qPihjZWxsKSkgeworICAgICAgICAgICAgICAgIC8vIGEuIElmIHRoZSBzaWdu YXR1cmUgb2YgdiBkb2VzIG5vdCBtYXRjaCB0aGUgc2lnbmF0dXJlIG9mIGksIHRocm93IGEgV2Vi QXNzZW1ibHkuTGlua0Vycm9yLgorICAgICAgICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4 IGltcG9ydGVkU2lnbmF0dXJlSW5kZXggPSBpbXBvcnRlZEV4cG9ydC0+c2lnbmF0dXJlSW5kZXgo KTsKKyAgICAgICAgICAgICAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBleHBlY3RlZFNpZ25hdHVy ZUluZGV4ID0gbW9kdWxlSW5mb3JtYXRpb24uaW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2Vz W2ltcG9ydC5raW5kSW5kZXhdOworICAgICAgICAgICAgICAgIGlmIChpbXBvcnRlZFNpZ25hdHVy ZUluZGV4ICE9IGV4cGVjdGVkU2lnbmF0dXJlSW5kZXgpCisgICAgICAgICAgICAgICAgICAgIHJl dHVybiBKU1ZhbHVlOjplbmNvZGUodGhyb3dFeGNlcHRpb24oZXhlYywgdGhyb3dTY29wZSwgY3Jl YXRlSlNXZWJBc3NlbWJseUxpbmtFcnJvcihleGVjLCB2bSwgQVNDSUlMaXRlcmFsKCJpbXBvcnRl ZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBkb2Vzbid0IG1hdGNoIHRoZSBwcm92aWRlZCBXZWJBc3Nl bWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSIpKSkpOwogICAgICAgICAgICAgICAgIC8vIGIuIExl dCBjbG9zdXJlIGJlIHYuW1tDbG9zdXJlXV0uCi0gICAgICAgICAgICAgICAgUkVMRUFTRV9BU1NF UlRfTk9UX1JFQUNIRUQoKTsKLSAgICAgICAgICAgICAgICBVTlVTRURfUEFSQU0oaW1wb3J0ZWRF eHBvcnRzKTsKLSAgICAgICAgICAgICAgICBicmVhazsKICAgICAgICAgICAgIH0KICAgICAgICAg ICAgIC8vIGlpaS4gT3RoZXJ3aXNlOgogICAgICAgICAgICAgLy8gYS4gTGV0IGNsb3N1cmUgYmUg YSBuZXcgaG9zdCBmdW5jdGlvbiBvZiB0aGUgZ2l2ZW4gc2lnbmF0dXJlIHdoaWNoIGNhbGxzIHYg YnkgY29lcmNpbmcgV2ViQXNzZW1ibHkgYXJndW1lbnRzIHRvIEphdmFTY3JpcHQgYXJndW1lbnRz IHZpYSBUb0pTVmFsdWUgYW5kIHJldHVybnMgdGhlIHJlc3VsdCwgaWYgYW55LCBieSBjb2VyY2lu ZyB2aWEgVG9XZWJBc3NlbWJseVZhbHVlLgogICAgICAgICAgICAgLy8gTm90ZTogZG9uZSBhcyBw YXJ0IG9mIFBsYW4gY29tcGlsYXRpb24uCiAgICAgICAgICAgICAvLyBpdi4gQXBwZW5kIHYgdG8g ZnVuY3MuCisgICAgICAgICAgICAvLyBOb3RlOiBhZGRpbmcgdGhlIEpTQ2VsbCB0byB0aGUgaW5z dGFuY2UgbGlzdCBmdWxmaWxscyBjbG9zdXJlIHJlcXVpcmVtZW50cyBiLiBhYm92ZSAodGhlIFdl YkFzc2VtYmx5Lkluc3RhbmNlIHdpbCBiZSBrZXB0IGFsaXZlKSBhbmQgdi4gYmVsb3cgKHRoZSBK U0Z1bmN0aW9uKS4KICAgICAgICAgICAgIGluc3RhbmNlLT5zZXRJbXBvcnRGdW5jdGlvbih2bSwg Y2VsbCwgbnVtSW1wb3J0RnVuY3Rpb25zKyspOwogICAgICAgICAgICAgLy8gdi4gQXBwZW5kIGNs b3N1cmUgdG8gaW1wb3J0cy4KICAgICAgICAgICAgIGJyZWFrOwpAQCAtMjMwLDcgKzIzNiw3IEBA IHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGNvbnN0cnVjdEpTV2ViQXNzZW1i bHlJbnN0YW5jZShFeGVjU3RhdGUqIGV4CiAgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVCghbW9k dWxlSW5mb3JtYXRpb24ubWVtb3J5LmlzSW1wb3J0KCkpOwogICAgICAgICAgICAgLy8gV2UgY3Jl YXRlIGEgbWVtb3J5IHdoZW4gaXQncyBhIG1lbW9yeSBkZWZpbml0aW9uLgogICAgICAgICAgICAg Ym9vbCBmYWlsZWQ7Ci0gICAgICAgICAgICBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiBt ZW1vcnkgPSBzdGQ6Om1ha2VfdW5pcXVlPFdhc206Ok1lbW9yeT4obW9kdWxlSW5mb3JtYXRpb24u bWVtb3J5LmluaXRpYWwoKSwgbW9kdWxlSW5mb3JtYXRpb24ubWVtb3J5Lm1heGltdW0oKSwgZmFp bGVkKTsKKyAgICAgICAgICAgIFdhc206Ok1lbW9yeSBtZW1vcnkobW9kdWxlSW5mb3JtYXRpb24u bWVtb3J5LmluaXRpYWwoKSwgbW9kdWxlSW5mb3JtYXRpb24ubWVtb3J5Lm1heGltdW0oKSwgZmFp bGVkKTsKICAgICAgICAgICAgIGlmIChmYWlsZWQpCiAgICAgICAgICAgICAgICAgcmV0dXJuIEpT VmFsdWU6OmVuY29kZSh0aHJvd0V4Y2VwdGlvbihleGVjLCB0aHJvd1Njb3BlLCBjcmVhdGVPdXRP Zk1lbW9yeUVycm9yKGV4ZWMpKSk7CiAgICAgICAgICAgICBpbnN0YW5jZS0+c2V0TWVtb3J5KHZt LApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlN ZW1vcnlDb25zdHJ1Y3Rvci5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJB c3NlbWJseU1lbW9yeUNvbnN0cnVjdG9yLmNwcAppbmRleCA1ZDVhNmNkLi42Yzg4N2FmIDEwMDY0 NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1lbW9yeUNv bnN0cnVjdG9yLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3Nl bWJseU1lbW9yeUNvbnN0cnVjdG9yLmNwcApAQCAtOTcsNyArOTcsNyBAQCBzdGF0aWMgRW5jb2Rl ZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBjb25zdHJ1Y3RKU1dlYkFzc2VtYmx5TWVtb3J5KEV4ZWNT dGF0ZSogZXhlYwogICAgIH0KIAogICAgIGJvb2wgZmFpbGVkOwotICAgIHN0ZDo6dW5pcXVlX3B0 cjxXYXNtOjpNZW1vcnk+IG1lbW9yeSA9IHN0ZDo6bWFrZV91bmlxdWU8V2FzbTo6TWVtb3J5Pihp bml0aWFsUGFnZUNvdW50LCBtYXhpbXVtUGFnZUNvdW50LCBmYWlsZWQpOworICAgIFdhc206Ok1l bW9yeSBtZW1vcnkoaW5pdGlhbFBhZ2VDb3VudCwgbWF4aW11bVBhZ2VDb3VudCwgZmFpbGVkKTsK ICAgICBpZiAoZmFpbGVkKQogICAgICAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKHRocm93RXhj ZXB0aW9uKGV4ZWMsIHRocm93U2NvcGUsIGNyZWF0ZU91dE9mTWVtb3J5RXJyb3IoZXhlYykpKTsK IApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlN b2R1bGVDb25zdHJ1Y3Rvci5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJB c3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNwcAppbmRleCAzOGVkYjhjLi44MTI5NTkyIDEwMDY0 NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNv bnN0cnVjdG9yLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3Nl bWJseU1vZHVsZUNvbnN0cnVjdG9yLmNwcApAQCAtOTcsNyArOTcsNyBAQCBKU1ZhbHVlIFdlYkFz c2VtYmx5TW9kdWxlQ29uc3RydWN0b3I6OmNyZWF0ZU1vZHVsZShFeGVjU3RhdGUqIHN0YXRlLCBT dHJ1Y3R1cmUqCiAKICAgICAvLyBPbmx5IHdhc20taW50ZXJuYWwgZnVuY3Rpb25zIGhhdmUgYSBj YWxsZWUsIHN0dWJzIHRvIEpTIGRvIG5vdC4KICAgICB1bnNpZ25lZCBjYWxsZWVDb3VudCA9IHBs YW4uaW50ZXJuYWxGdW5jdGlvbkNvdW50KCk7Ci0gICAgSlNXZWJBc3NlbWJseU1vZHVsZSogcmVz dWx0ID0gSlNXZWJBc3NlbWJseU1vZHVsZTo6Y3JlYXRlKHZtLCBzdHJ1Y3R1cmUsIHBsYW4udGFr ZU1vZHVsZUluZm9ybWF0aW9uKCksIHBsYW4udGFrZUNhbGxMaW5rSW5mb3MoKSwgcGxhbi50YWtl V2FzbVRvSlNTdHVicygpLCBwbGFuLnRha2VGdW5jdGlvbkluZGV4U3BhY2UoKSwgZXhwb3J0U3lt Ym9sVGFibGUsIGNhbGxlZUNvdW50KTsKKyAgICBKU1dlYkFzc2VtYmx5TW9kdWxlKiByZXN1bHQg PSBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGUodm0sIHN0cnVjdHVyZSwgcGxhbi50YWtlTW9k dWxlSW5mb3JtYXRpb24oKSwgcGxhbi50YWtlQ2FsbExpbmtJbmZvcygpLCBwbGFuLnRha2VXYXNt RXhpdFN0dWJzKCksIGV4cG9ydFN5bWJvbFRhYmxlLCBjYWxsZWVDb3VudCk7CiAgICAgcGxhbi5p bml0aWFsaXplQ2FsbGVlcyhzdGF0ZS0+anNDYWxsZWUoKS0+Z2xvYmFsT2JqZWN0KCksIAogICAg ICAgICBbJl0gKHVuc2lnbmVkIGNhbGxlZUluZGV4LCBKU1dlYkFzc2VtYmx5Q2FsbGVlKiBqc0Vu dHJ5cG9pbnRDYWxsZWUsIEpTV2ViQXNzZW1ibHlDYWxsZWUqIHdhc21FbnRyeXBvaW50Q2FsbGVl KSB7CiAgICAgICAgICAgICByZXN1bHQtPnNldEpTRW50cnlwb2ludENhbGxlZSh2bSwgY2FsbGVl SW5kZXgsIGpzRW50cnlwb2ludENhbGxlZSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZVJlY29yZC5jcHAgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZVJlY29yZC5jcHAKaW5kZXggYzFiZDgy MC4uOWVmZjRjNCAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2Vi QXNzZW1ibHlNb2R1bGVSZWNvcmQuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmNwcApAQCAtMTE4LDcgKzExOCw3IEBAIHZvaWQg V2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmxpbmsoRXhlY1N0YXRlKiBzdGF0ZSwgSlNXZWJBc3Nl bWJseUluc3RhbmNlKiBpbnN0CiAgICAgICAgICAgICAvLyAgICAgYy4gUmV0dXJuIGZ1bmMuCiAg ICAgICAgICAgICBKU1dlYkFzc2VtYmx5Q2FsbGVlKiBqc0VudHJ5cG9pbnRDYWxsZWUgPSBtb2R1 bGUtPmpzRW50cnlwb2ludENhbGxlZUZyb21GdW5jdGlvbkluZGV4U3BhY2UoZXhwLmtpbmRJbmRl eCk7CiAgICAgICAgICAgICBKU1dlYkFzc2VtYmx5Q2FsbGVlKiB3YXNtRW50cnlwb2ludENhbGxl ZSA9IG1vZHVsZS0+d2FzbUVudHJ5cG9pbnRDYWxsZWVGcm9tRnVuY3Rpb25JbmRleFNwYWNlKGV4 cC5raW5kSW5kZXgpOwotICAgICAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJl SW5kZXggPSBtb2R1bGUtPnNpZ25hdHVyZUZvckZ1bmN0aW9uSW5kZXhTcGFjZShleHAua2luZElu ZGV4KTsKKyAgICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0g bW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2UoZXhwLmtpbmRJbmRl eCk7CiAgICAgICAgICAgICBjb25zdCBXYXNtOjpTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFdhc206 OlNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQoJnZtLCBzaWduYXR1cmVJbmRleCk7CiAgICAgICAg ICAgICBXZWJBc3NlbWJseUZ1bmN0aW9uKiBmdW5jdGlvbiA9IFdlYkFzc2VtYmx5RnVuY3Rpb246 OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LCBzaWduYXR1cmUtPmFyZ3VtZW50Q291bnQoKSwgZXhw LmZpZWxkLnN0cmluZygpLCBpbnN0YW5jZSwganNFbnRyeXBvaW50Q2FsbGVlLCB3YXNtRW50cnlw b2ludENhbGxlZSwgc2lnbmF0dXJlSW5kZXgpOwogICAgICAgICAgICAgZXhwb3J0ZWRWYWx1ZSA9 IGZ1bmN0aW9uOwpAQCAtMTMzLDggKzEzMyw2IEBAIHZvaWQgV2ViQXNzZW1ibHlNb2R1bGVSZWNv cmQ6OmxpbmsoRXhlY1N0YXRlKiBzdGF0ZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBpbnN0CiAg ICAgICAgICAgICBicmVhazsKICAgICAgICAgfQogICAgICAgICBjYXNlIFdhc206OkV4dGVybmFs S2luZDo6TWVtb3J5OiB7Ci0gICAgICAgICAgICAvLyBUaGlzIHNob3VsZCBiZSBndWFyYW50ZWVk IGJ5IG1vZHVsZSB2ZXJpZmljYXRpb24uCi0gICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChpbnN0 YW5jZS0+bWVtb3J5KCkpOyAKICAgICAgICAgICAgIEFTU0VSVChleHAua2luZEluZGV4ID09IDAp OwogCiAgICAgICAgICAgICBleHBvcnRlZFZhbHVlID0gaW5zdGFuY2UtPm1lbW9yeSgpOwpAQCAt MTc1LDcgKzE3Myw3IEBAIHZvaWQgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmxpbmsoRXhlY1N0 YXRlKiBzdGF0ZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBpbnN0CiAgICAgYm9vbCBoYXNTdGFy dCA9ICEhbW9kdWxlSW5mb3JtYXRpb24uc3RhcnRGdW5jdGlvbkluZGV4U3BhY2U7CiAgICAgaWYg KGhhc1N0YXJ0KSB7CiAgICAgICAgIGF1dG8gc3RhcnRGdW5jdGlvbkluZGV4U3BhY2UgPSBtb2R1 bGVJbmZvcm1hdGlvbi5zdGFydEZ1bmN0aW9uSW5kZXhTcGFjZS52YWx1ZV9vcigwKTsKLSAgICAg ICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVy ZUZvckZ1bmN0aW9uSW5kZXhTcGFjZShzdGFydEZ1bmN0aW9uSW5kZXhTcGFjZSk7CisgICAgICAg IFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVJ bmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2Uoc3RhcnRGdW5jdGlvbkluZGV4U3BhY2UpOwogICAg ICAgICBjb25zdCBXYXNtOjpTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFdhc206OlNpZ25hdHVyZUlu Zm9ybWF0aW9uOjpnZXQoJnZtLCBzaWduYXR1cmVJbmRleCk7CiAgICAgICAgIC8vIFRoZSBzdGFy dCBmdW5jdGlvbiBtdXN0IG5vdCB0YWtlIGFueSBhcmd1bWVudHMgb3IgcmV0dXJuIGFueXRoaW5n LiBUaGlzIGlzIGVuZm9yY2VkIGJ5IHRoZSBwYXJzZXIuCiAgICAgICAgIEFTU0VSVCghc2lnbmF0 dXJlLT5hcmd1bWVudENvdW50KCkpOwpAQCAtMjM4LDcgKzIzNiw3IEBAIEpTVmFsdWUgV2ViQXNz ZW1ibHlNb2R1bGVSZWNvcmQ6OmV2YWx1YXRlKEV4ZWNTdGF0ZSogc3RhdGUpCiAKICAgICAgICAg ICAgICAgICBKU1dlYkFzc2VtYmx5Q2FsbGVlKiBqc0VudHJ5cG9pbnRDYWxsZWUgPSBtb2R1bGUt PmpzRW50cnlwb2ludENhbGxlZUZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleCk7 CiAgICAgICAgICAgICAgICAgSlNXZWJBc3NlbWJseUNhbGxlZSogd2FzbUVudHJ5cG9pbnRDYWxs ZWUgPSBtb2R1bGUtPndhc21FbnRyeXBvaW50Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShm dW5jdGlvbkluZGV4KTsKLSAgICAgICAgICAgICAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWdu YXR1cmVJbmRleCA9IG1vZHVsZS0+c2lnbmF0dXJlRm9yRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0 aW9uSW5kZXgpOworICAgICAgICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVy ZUluZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVu Y3Rpb25JbmRleCk7CiAgICAgICAgICAgICAgICAgY29uc3QgV2FzbTo6U2lnbmF0dXJlKiBzaWdu YXR1cmUgPSBXYXNtOjpTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KCZ2bSwgc2lnbmF0dXJlSW5k ZXgpOwogICAgICAgICAgICAgICAgIC8vIEZJWE1FOiBTYXkgd2UgZXhwb3J0IGxvY2FsIGZ1bmN0 aW9uICJmb28iIGF0IGZ1bmNpdG9uIGluZGV4IDAuCiAgICAgICAgICAgICAgICAgLy8gV2hhdCBp ZiB3ZSBhbHNvIHNldCBpdCB0byB0aGUgdGFibGUgYW4gRWxlbWVudCB3LyBpbmRleCAwLgpAQCAt MjU3LDcgKzI1NSw2IEBAIEpTVmFsdWUgV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmV2YWx1YXRl KEV4ZWNTdGF0ZSogc3RhdGUpCiAgICAgICAgIGNvbnN0IFZlY3RvcjxXYXNtOjpTZWdtZW50OjpQ dHI+JiBkYXRhID0gbV9pbnN0YW5jZS0+bW9kdWxlKCktPm1vZHVsZUluZm9ybWF0aW9uKCkuZGF0 YTsKICAgICAgICAgSlNXZWJBc3NlbWJseU1lbW9yeSoganNNZW1vcnkgPSBtX2luc3RhbmNlLT5t ZW1vcnkoKTsKICAgICAgICAgaWYgKCFkYXRhLmlzRW1wdHkoKSkgewotICAgICAgICAgICAgUkVM RUFTRV9BU1NFUlQoanNNZW1vcnkpOyAvLyBJdCBpcyBhIHZhbGlkYXRpb24gZXJyb3IgZm9yIGEg RGF0YSBzZWN0aW9uIHRvIGV4aXN0IHdpdGhvdXQgYSBNZW1vcnkgc2VjdGlvbiBvciBpbXBvcnQu CiAgICAgICAgICAgICB1aW50OF90KiBtZW1vcnkgPSByZWludGVycHJldF9jYXN0PHVpbnQ4X3Qq Pihqc01lbW9yeS0+bWVtb3J5KCktPm1lbW9yeSgpKTsKICAgICAgICAgICAgIHVpbnQ2NF90IHNp emVJbkJ5dGVzID0ganNNZW1vcnktPm1lbW9yeSgpLT5zaXplKCk7CiAgICAgICAgICAgICBmb3Ig KGF1dG8mIHNlZ21lbnQgOiBkYXRhKSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZVJlY29yZC5oIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQuaAppbmRleCBlMTI2NjcwLi4yNDY1 ZDgzIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJs eU1vZHVsZVJlY29yZC5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFz c2VtYmx5TW9kdWxlUmVjb3JkLmgKQEAgLTQ1LDcgKzQ1LDcgQEAgcHVibGljOgogICAgIERFQ0xB UkVfRVhQT1JUX0lORk87CiAKICAgICBzdGF0aWMgU3RydWN0dXJlKiBjcmVhdGVTdHJ1Y3R1cmUo Vk0mLCBKU0dsb2JhbE9iamVjdCosIEpTVmFsdWUpOwotICAgIHN0YXRpYyBXZWJBc3NlbWJseU1v ZHVsZVJlY29yZCogY3JlYXRlKEV4ZWNTdGF0ZSosIFZNJiwgU3RydWN0dXJlKiwgY29uc3QgSWRl bnRpZmllciYsIGNvbnN0IFdhc206Ok1vZHVsZUluZm9ybWF0aW9uJik7CisgICAgSlNfRVhQT1JU X1BSSVZBVEUgc3RhdGljIFdlYkFzc2VtYmx5TW9kdWxlUmVjb3JkKiBjcmVhdGUoRXhlY1N0YXRl KiwgVk0mLCBTdHJ1Y3R1cmUqLCBjb25zdCBJZGVudGlmaWVyJiwgY29uc3QgV2FzbTo6TW9kdWxl SW5mb3JtYXRpb24mKTsKIAogICAgIHZvaWQgbGluayhFeGVjU3RhdGUqLCBKU1dlYkFzc2VtYmx5 SW5zdGFuY2UqKTsKICAgICBKU19FWFBPUlRfUFJJVkFURSBKU1ZhbHVlIGV2YWx1YXRlKEV4ZWNT dGF0ZSopOwotLSAKMi4xMC4xCgo= 297913 2017-01-02 15:02:02 -0800 2017-01-02 17:01:52 -0800 patch 0001-wasm-wasm.patch text/plain 149028 jfbastien RnJvbSBiY2UzYjQ0MDIzZmU0OTMyNTc4MjI0NTFjMTY4ZTk4OWMwYmE3ZWYyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBXZWQsIDIxIERlYyAyMDE2IDE1OjU5OjU2IC0wODAwClN1YmplY3Q6IFtQQVRDSF0gd2FzbS0+ d2FzbQoKQ2hhbmdlcyB0byB0aGUgV2ViQXNzZW1ibHkgaW1wbGVtZW50YXRpb246CgogIC0gQWRk IGEgbmV3IEpTVHlwZSBmb3IgV2ViQXNzZW1ibHlGdW5jdGlvbiwgYW5kIHVzZSBpdCB3aGVuIGNy ZWF0aW5nIGl0cwogICAgc3RydWN0dXJlLiBUaGlzIHdpbGwgYmUgdXNlZCB0byBxdWlja2x5IGRl dGVjdCBmcm9tIHdhc20gd2hldGhlciB0aGUgaW1wb3J0CiAgICBjYWxsIGlzIHRvIGFub3RoZXIg d2FzbSBtb2R1bGUsIG9yIHdoZXRoZXIgaXQncyB0byBKUy4KICAtIFVzZSBjZWxsIGluc3RlYWQg b2Ygb2JqZWN0cyB0byBkZXRlY3Qgd2FzbS0+d2FzbSwgdGhlIHByZXZpb3VzIGNvZGUgd2FzIHdy b25nLgogIC0gSW1wcm92ZSBkaWFnbm9zdGljIHByaW50b3V0IGZvciB3YXNtIHN0dWJzOiBwcmlu dCB0aGUgZnVsbCBzaWduYXR1cmUuCiAgLSBQcm9wZXJseSBjaGVjayB0aGF0IHdhc20gLT4gd2Fz bSBjYWxscyBoYXZlIG1hdGNoaW5nIHNpZ25hdHVyZXMuIEFkZCB0ZXN0aW5nIGZvciB0aGlzLgog IC0gVGVzdCBzb21lIG9mIHRoZSB3YXNtIC0+IHdhc20gY2FsbHMsIG5vdCB3b3JraW5nIHlldCwg YW5kIG1vcmUgdGVzdHMgbmVlZCB0bwogICAgZ2V0IGltcGxlbWVudGVkLgogIC0gR2VuZXJhdGUg dHdvIHN0dWJzIGZyb20gdGhlIGltcG9ydCBzdHViIGdlbmVyYXRvcjogb25lIGZvciB3YXNtLT5K UyBhbmQgb25lCiAgICBmb3Igd2FzbSAtPiB3YXNtLiBUaGlzIGlzIGRvbmUgYXQgTW9kdWxlIHRp bWUuIFdoaWNoIGlzIGNhbGxlZCB3aWxsIG9ubHkgYmUKICAgIGtub3duIGF0IEluc3RhbmNlIHRp bWUsIG9uY2Ugd2UndmUgcmVjZWl2ZWQgdGhlIGltcG9ydCBvYmplY3QuIFdlIHdhbnQgdG8KICAg IGF2b2lkIGNvZGVnZW4gYXQgSW5zdGFuY2UgdGltZSwgc28gaGF2aW5nIGJvdGggYXJvdW5kIGlz IGdyZWF0LgogIC0gUmVzdG9yZSB0aGUgV2ViQXNzZW1ibHkgZ2xvYmFsIHN0YXRlIChWTSB0b3Ag SW5zdGFuY2UsIGFuZCBwaW5uZWQgcmVnaXN0ZXJzKQogICAgYWZ0ZXIgY2FsbCAvIGNhbGxfaW5k aXJlY3QsIGFuZCBpbiB0aGUgSlMtPndhc20gZW50cnkgc3R1Yi4KICAtIFBpbm5lZCByZWdpc3Rl cnMgYXJlIG5vdyBhIGdsb2JhbCB0aGluZywgbm90IHBlci1NZW1vcnksIGJlY2F1c2UgdGhlIHdh c20gLT4KICAgIHdhc20gc3R1YnMgYXJlIGdlbmVyYXRlZCBhdCBNb2R1bGUgdGltZSB3aGVyZSB3 ZSBkb24ndCByZWFsbHkgaGF2ZSBlbm91Z2gKICAgIGluZm9ybWF0aW9uIHRvIGRvIHRoZSByaWdo dCB0aGluZyAoZG9pbmcgc28gd291bGQgZ2VuZXJhdGUgdG9vIG11Y2ggY29kZSkuCgpTdXBwb3J0 IGNoYW5nZXM6CgogIC0gQWRkIGEgUHJveHkgdG8gQnVpbGRlci5qcywgd2hpY2ggaW50ZXJjZXB0 cyB1bmtub3duIHByb3BlcnR5IGxvb2t1cHMuIFRoaXMKICAgIGNyZWF0ZXMgd2F5IGJldHRlciBl cnJvciBtZXNzYWdlcyBvbiB0eXBvcyB0aGFuICd1bmRlZmluZWQgaXMgbm90IGEKICAgIGZ1bmN0 aW9uJywgd2hpY2ggaGFwcGVucyBzZW1pLWZyZXF1ZW50bHkgYXMgSSB0eXBvIG9wY29kZSBuYW1l cyAoYW5kIHdoaWNoCiAgICBvbmUgaXMgYSB0eXBvIGlzIGhhcmQgdG8gZmluZCBiZWNhdXNlIHdl IGNoYWluIGJ1aWxkZXJzKS4KICAtIEFkZCBsaW1pdGVkIHN1cHBvcnQgZm9yIHZhcnt1fWludDY0 IChvbmx5IHRoZSAzMi1iaXQgdmFsdWVzKS4KICAtIEdldCByaWQgb2YgbXVjaCBvZiB0aGUgZnVu Y3Rpb24gaW5kZXggc3BhY2U6IHdlIGFscmVhZHkgaGF2ZSBhbGwgb2YgaXRzCiAgICBpbmZvcm1h dGlvbiBlbHNld2hlcmUsIGFuZCBhcy1pcyBpdCBwcm92aWRlcyBubyBleHRyYSBlZmZpY2llbmN5 LgogIC0gU3RvcmUgV2FzbTo6TWVtb3J5IGRpcmVjdGx5IG9uIEpTV2ViQXNzZW1ibHlNZW1vcnks IGluc3RlYWQgb2YgdGhyb3VnaCBhCiAgICB1bmlxdWVfcHRyLiBUaGlzIHJlbW92ZXMgYW4gaW5k aXJlY3Rpb24gYW5kIHVzZWxlc3MgYWxsb2NhdGlvbi4KICAtIFJlbW92ZSBWTSdhIFdlYkFzc2Vt Ymx5IG1lbW9yeSAvIHNpemUsIGFuZCBvYnRhaW4gdGhlbSBmcm9tIEluc3RhbmNlCiAgICBpbnN0 ZWFkLiBUaGlzIHJlcXVpcmVzIGFuIGV4dHJhIGluZGlyZWN0aW9uLCBidXQgaXMgY2xlYW5lci4K ICAtIENhY2hlIHRoZSB3YXNtIGVudHJ5cG9pbnQgY29kZSdzIGxvY2F0aW9uIG9uIFdlYkFzc2Vt Ymx5RnVuY3Rpb24gZm9yIGZhc3RlcgogICAgYWNjZXNzLgogIC0gQWxsIEluc3RhbmNlIG5vdyBo YXZlIGEgdmFsaWQgSlNXZWJBc3NlbWJseU1lbW9yeSB3aGVuIGNyZWF0ZWQsIHdoaWNoIGFsbG93 cwogICAgdGhlIHdhc20gLT4gd2FzbSBzdHViIHRvIGFzc3VtZSBpdCBpc24ndCBudWxsIHdoZW4g dHJ5aW5nIHRvIHNldCB0aGUgcGlubmVkCiAgICByZWdpc3RlcnMuCiAgLSBBbHdheXMgcGluIHJl Z2lzdGVycywgZXZlbiBpZiBubyBNZW1vcnkgaXMgcHJlc2VudCBhbmQgd2UgZG9uJ3QgdGVjaG5p Y2FsbHkKICAgIG5lZWQgdG8gcGluIHRoZW0uCi0tLQogSlNUZXN0cy9DaGFuZ2VMb2cgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMzUgKysrKwogSlNUZXN0cy93YXNtL0J1aWxk ZXIuanMgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgOTEgKysrKystLS0tCiBKU1Rlc3Rz L3dhc20vTG93TGV2ZWxCaW5hcnkuanMgICAgICAgICAgICAgICAgICAgICB8ICAxMiArKwogSlNU ZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMgICAgICAgICAgfCAgIDYgKy0K IEpTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMgICAgICAgICAgIHwgICAy ICstCiBKU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5qcyAgICAgICAgICB8 ICAgMiArLQogSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20tYmFkLXNpZ25hdHVyZS5q cyAgfCAxMDUgKysrKysrKysrKwogSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMg ICAgICAgICAgICAgICAgfCAgNzIgKysrKysrKwogU291cmNlL0phdmFTY3JpcHRDb3JlL0NNYWtl TGlzdHMudHh0ICAgICAgICAgICAgICAgfCAgIDEgKwogU291cmNlL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZyAgICAgICAgICAgICAgICAgICAgfCAxMjUgKysrKysrKysrKysrCiAuLi4vSmF2YVNj cmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiAgICAgICB8ICAgOCArLQogU291cmNl L0phdmFTY3JpcHRDb3JlL2pzYy5jcHAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgLQogU291 cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmggICAgICAgICAgICAgfCAgIDIgKwog U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuY3BwICAgfCAyMjEg KysrKysrKysrKysrKy0tLS0tLS0tCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQjNJ UkdlbmVyYXRvci5oICAgICB8ICAgMiArLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bUJpbmRpbmcuY3BwICAgICAgICAgfCAgNjcgKysrKysrLQogU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbUJpbmRpbmcuaCAgICAgICAgICAgfCAgIDIgKy0KIFNvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21Gb3JtYXQuaCAgICAgICAgICAgIHwgIDI4ICsrLQogU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmggICAgfCAgMTYgKy0KIFNvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwICAgICAgICAgIHwgIDU3ICsrKysrLQog U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5oICAgICAgICAgICAgfCAgMzEg KystCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5SW5mb3JtYXRpb24uY3BwICB8 ICA1OSArKysrLS0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnlJbmZvcm1h dGlvbi5oIHwgICA5ICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFy c2VyLmNwcCAgICB8ICAyNyArLS0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1 bGVQYXJzZXIuaCAgICAgIHwgICAyICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt UGFnZUNvdW50LmNwcCAgICAgICB8ICA0NSArKysrKwogU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbVBhZ2VDb3VudC5oICAgICAgICAgfCAgIDYgKwogU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbVBsYW4uY3BwICAgICAgICAgICAgfCAgNDQgKystLQogU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbVBsYW4uaCAgICAgICAgICAgICAgfCAgMTQgKy0KIFNvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuY3BwICAgICAgIHwgIDE4ICstCiBTb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmggICAgICAgICB8ICAgMSArCiBTb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwICAgICAgICB8ICAgNCArLQog U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmggICAgICAgICAgfCAgIDIg Ky0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5oIHwg ICA5ICstCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNw cCB8ICAxMiArLQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9y eS5oICAgfCAgMTEgKy0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlN b2R1bGUuY3BwIHwgICA5ICstCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2Vt Ymx5TW9kdWxlLmggICB8ICAxNiArLQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNz ZW1ibHlGdW5jdGlvbi5jcHAgfCAgIDkgKy0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dl YkFzc2VtYmx5RnVuY3Rpb24uaCAgIHwgICA4ICstCiAuLi4vd2FzbS9qcy9XZWJBc3NlbWJseUlu c3RhbmNlQ29uc3RydWN0b3IuY3BwICAgICB8ICAyMCArLQogLi4uL3dhc20vanMvV2ViQXNzZW1i bHlNZW1vcnlDb25zdHJ1Y3Rvci5jcHAgICAgICAgfCAgIDIgKy0KIC4uLi93YXNtL2pzL1dlYkFz c2VtYmx5TW9kdWxlQ29uc3RydWN0b3IuY3BwICAgICAgIHwgICAyICstCiAuLi4vd2FzbS9qcy9X ZWJBc3NlbWJseU1vZHVsZVJlY29yZC5jcHAgICAgICAgICAgICB8ICAgOSArLQogNDQgZmlsZXMg Y2hhbmdlZCwgOTI2IGluc2VydGlvbnMoKyksIDI5OCBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2Rl IDEwMDY0NCBKU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS1iYWQtc2lnbmF0dXJlLmpz CiBjcmVhdGUgbW9kZSAxMDA2NDQgSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMK IGNyZWF0ZSBtb2RlIDEwMDY0NCBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFnZUNv dW50LmNwcAoKZGlmZiAtLWdpdCBhL0pTVGVzdHMvQ2hhbmdlTG9nIGIvSlNUZXN0cy9DaGFuZ2VM b2cKaW5kZXggMDBmZDQ5OC4uZTM4NGRhYyAxMDA2NDQKLS0tIGEvSlNUZXN0cy9DaGFuZ2VMb2cK KysrIGIvSlNUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzOCBAQAorMjAxNi0xMi0zMCAgSkYg QmFzdGllbiAgPGpmYmFzdGllbkBhcHBsZS5jb20+CisKKyAgICAgICAgV2ViQXNzZW1ibHk6IGhh bmRsZSBhbmQgb3B0aW1pemUgd2FzbSBleHBvcnQg4oaSIHdhc20gaW1wb3J0IGNhbGxzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjUyODIKKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHdhc20vQnVpbGRl ci5qczogQWRkIGEgUHJveHkgdG8gQnVpbGRlci5qcywgd2hpY2ggaW50ZXJjZXB0cworICAgICAg ICB1bmtub3duIHByb3BlcnR5IGxvb2t1cHMuIFRoaXMgY3JlYXRlcyB3YXkgYmV0dGVyIGVycm9y IG1lc3NhZ2VzCisgICAgICAgIG9uIHR5cG9zIHRoYW4gJ3VuZGVmaW5lZCBpcyBub3QgYSBmdW5j dGlvbicsIHdoaWNoIGhhcHBlbnMKKyAgICAgICAgc2VtaS1mcmVxdWVudGx5IGFzIEkgdHlwbyBv cGNvZGUgbmFtZXMgKGFuZCB3aGljaCBvbmUgaXMgYSB0eXBvIGlzCisgICAgICAgIGhhcmQgdG8g ZmluZCBiZWNhdXNlIHdlIGNoYWluIGJ1aWxkZXJzKS4KKyAgICAgICAgKGNvbnN0Ll9pc1ZhbGlk VmFsdWUpOgorICAgICAgICAoZ2V0IHRhcmdldCk6CisgICAgICAgIChjb25zdC5faW1wb3J0RnVu Y3Rpb25Db250aW51YXRpb24pOgorICAgICAgICAoY29uc3QuX2ltcG9ydE1lbW9yeUNvbnRpbnVh dGlvbik6CisgICAgICAgIChjb25zdC5faW1wb3J0VGFibGVDb250aW51YXRpb24pOgorICAgICAg ICAoY29uc3QuX2V4cG9ydEZ1bmN0aW9uQ29udGludWF0aW9uKToKKyAgICAgICAgKGV4cG9ydC5k ZWZhdWx0LkJ1aWxkZXIucHJvdG90eXBlLl9yZWdpc3RlclNlY3Rpb25CdWlsZGVycy5jb25zdC5z ZWN0aW9uLmluLldBU00uZGVzY3JpcHRpb24uc2VjdGlvbi5zd2l0Y2guc2VjdGlvbi5jYXNlLnN0 cmluZ19hcHBlYXJlZF9oZXJlLnRoaXMuc2VjdGlvbik6CisgICAgICAgIChleHBvcnQuZGVmYXVs dC5CdWlsZGVyLnByb3RvdHlwZS5fcmVnaXN0ZXJTZWN0aW9uQnVpbGRlcnMudGhpcy5Vbmtub3du KToKKyAgICAgICAgKiB3YXNtL0xvd0xldmVsQmluYXJ5LmpzOiBBZGQgbGltaXRlZCBzdXBwb3J0 IGZvciB2YXJ7dX1pbnQ2NCAob25seSB0aGUgMzItYml0IHZhbHVlcykKKyAgICAgICAgKGV4cG9y dC5kZWZhdWx0Lkxvd0xldmVsQmluYXJ5LnByb3RvdHlwZS52YXJpbnQzMik6CisgICAgICAgIChl eHBvcnQuZGVmYXVsdC5Mb3dMZXZlbEJpbmFyeS5wcm90b3R5cGUudmFydWludDY0KToKKyAgICAg ICAgKGV4cG9ydC5kZWZhdWx0Lkxvd0xldmVsQmluYXJ5LnByb3RvdHlwZS52YXJpbnQ2NCk6Cisg ICAgICAgICogd2FzbS9mdW5jdGlvbi10ZXN0cy9leGNlcHRpb25zLmpzOiB1cGRhdGUgZXJyb3Ig bWVzc2FnZQorICAgICAgICAqIHdhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpzOiB1cGRh dGUgZXJyb3IgbWVzc2FnZQorICAgICAgICAqIHdhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9y ZS5qczogdXBkYXRlIGVycm9yIG1lc3NhZ2UKKyAgICAgICAgKiB3YXNtL2pzLWFwaS93YXNtLXRv LXdhc20tYmFkLXNpZ25hdHVyZS5qczogQWRkZWQuIFRlc3QgYSBidW5jaCBvZiBiYWQgd2FzbS0+ d2FzbSBpbXBvcnQgc2lnbmF0dXJlcworICAgICAgICAoY29uc3QubWFrZUltcG9ydGVlLnNpZ25h dHVyZS5zd2l0Y2gpOgorICAgICAgICAoQmFkU2lnbmF0dXJlRHJvcFN0YXJ0UGFyYW1zKToKKyAg ICAgICAgKiB3YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanM6IEFkZGVkLiBUZXN0IDY0LWJpdCB3 YXNtLT53YXNtIGltcG9ydCBjYWxscworICAgICAgICAoY29uc3QuY2FsbGVyTW9kdWxlKToKKyAg ICAgICAgKGNvbnN0LmNhbGxlZU1vZHVsZSk6CisgICAgICAgIChXYXNtVG9XYXNtKToKKwogMjAx Ni0xMi0yOSAgU2FhbSBCYXJhdGkgIDxzYmFyYXRpQGFwcGxlLmNvbT4KIAogICAgICAgICBXZWJB c3NlbWJseTogUmViYXNlIHNwZWMtdGVzdHMgbm93IHRoYXQgd2FidCBoYXMgYmVlbiB1cGRhdGVk IHRvIHByb2R1Y2UgY2VydGFpbiBraW5kcyBvZiBpbnZhbGlkIG1vZHVsZXMKZGlmZiAtLWdpdCBh L0pTVGVzdHMvd2FzbS9CdWlsZGVyLmpzIGIvSlNUZXN0cy93YXNtL0J1aWxkZXIuanMKaW5kZXgg ZGE1ODRjNC4uMjZiYTY2ZSAxMDA2NDQKLS0tIGEvSlNUZXN0cy93YXNtL0J1aWxkZXIuanMKKysr IGIvSlNUZXN0cy93YXNtL0J1aWxkZXIuanMKQEAgLTM4LDcgKzM4LDcgQEAgY29uc3QgX2lzVmFs aWRWYWx1ZSA9ICh2YWx1ZSwgdHlwZSkgPT4gewogICAgIHN3aXRjaCAodHlwZSkgewogICAgIC8v IFdlIGFsbG93IGJvdGggc2lnbmVkIGFuZCB1bnNpZ25lZCBudW1iZXJzLgogICAgIGNhc2UgImkz MiI6IHJldHVybiBNYXRoLnJvdW5kKHZhbHVlKSA9PT0gdmFsdWUgJiYgTExCLnZhcmludDMyTWlu IDw9IHZhbHVlICYmIHZhbHVlIDw9IExMQi52YXJ1aW50MzJNYXg7Ci0gICAgY2FzZSAiaTY0Ijog dGhyb3cgbmV3IEVycm9yKGBVbmltcGxlbWVudGVkOiB2YWx1ZSBjaGVjayBmb3IgJHt0eXBlfWAp OyAvLyBGSVhNRSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNDIw IDY0LWJpdCB2YWx1ZXMKKyAgICBjYXNlICJpNjQiOiByZXR1cm4gdHJ1ZTsgLy8gRklYTUUgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MzQyMCA2NC1iaXQgdmFsdWVz CiAgICAgY2FzZSAiZjMyIjogcmV0dXJuIHR5cGVvZih2YWx1ZSkgPT09ICJudW1iZXIiICYmIGlz RmluaXRlKHZhbHVlKTsKICAgICBjYXNlICJmNjQiOiByZXR1cm4gdHlwZW9mKHZhbHVlKSA9PT0g Im51bWJlciIgJiYgaXNGaW5pdGUodmFsdWUpOwogICAgIGRlZmF1bHQ6IHRocm93IG5ldyBFcnJv cihgSW1wbGVtZW50YXRpb24gcHJvYmxlbTogdW5rbm93biB0eXBlICR7dHlwZX1gKTsKQEAgLTU3 LDYgKzU3LDE2IEBAIGNvbnN0IF9ub3JtYWxpemVGdW5jdGlvblNpZ25hdHVyZSA9IChwYXJhbXMs IHJldCkgPT4gewogICAgIHJldHVybiBbcGFyYW1zLCByZXRdOwogfTsKIAorY29uc3QgX2Vycm9y SGFuZGxpbmdQcm94eUZvciA9IGJ1aWxkZXIgPT4gYnVpbGRlclsiX19pc1Byb3h5Il0gPyBidWls ZGVyIDogbmV3IFByb3h5KGJ1aWxkZXIsIHsKKyAgICBnZXQ6ICh0YXJnZXQsIHByb3BlcnR5LCBy ZWNlaXZlcikgPT4geworICAgICAgICBpZiAocHJvcGVydHkgPT09ICJfX2lzUHJveHkiKQorICAg ICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIGlmICh0YXJnZXRbcHJvcGVydHldID09PSB1 bmRlZmluZWQpCisgICAgICAgICAgICB0aHJvdyBuZXcgRXJyb3IoYFdlYkFzc2VtYmx5IGJ1aWxk ZXIgcmVjZWl2ZWQgdW5rbm93biBwcm9wZXJ0eSAnJHtwcm9wZXJ0eX0nYCk7CisgICAgICAgIHJl dHVybiB0YXJnZXRbcHJvcGVydHldOworICAgIH0KK30pOworCiBjb25zdCBfbWF5YmVSZWdpc3Rl clR5cGUgPSAoYnVpbGRlciwgdHlwZSkgPT4gewogICAgIGNvbnN0IHR5cGVTZWN0aW9uID0gYnVp bGRlci5fZ2V0U2VjdGlvbigiVHlwZSIpOwogICAgIGlmICh0eXBlb2YodHlwZSkgPT09ICJudW1i ZXIiKSB7CkBAIC0xMDAsNyArMTEwLDcgQEAgY29uc3QgX2ltcG9ydEZ1bmN0aW9uQ29udGludWF0 aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAgIHNlY3Rp b24uZGF0YS5wdXNoKHsgZmllbGQ6IGZpZWxkLCB0eXBlOiB0eXBlLCBraW5kOiAiRnVuY3Rpb24i LCBtb2R1bGU6IG1vZHVsZSB9KTsKICAgICAgICAgLy8gSW1wb3J0cyBhbHNvIGNvdW50IGluIHRo ZSBmdW5jdGlvbiBpbmRleCBzcGFjZS4gTWFwIHRoZW0gYXMgb2JqZWN0cyB0byBhdm9pZCBjbGFz aGluZyB3aXRoIENvZGUgZnVuY3Rpb25zJyBuYW1lcy4KICAgICAgICAgYnVpbGRlci5fcmVnaXN0 ZXJGdW5jdGlvblRvSW5kZXhTcGFjZSh7IG1vZHVsZTogbW9kdWxlLCBmaWVsZDogZmllbGQgfSk7 Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRs aW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH07CiB9OwogCkBAIC0xMDksNyArMTE5LDcg QEAgY29uc3QgX2ltcG9ydE1lbW9yeUNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBu ZXh0QnVpbGRlcikgPT4gewogICAgICAgICBhc3NlcnQuaXNTdHJpbmcobW9kdWxlLCBgSW1wb3J0 IE1lbW9yeSBtb2R1bGUgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7bW9kdWxlfSJgKTsKICAg ICAgICAgYXNzZXJ0LmlzU3RyaW5nKGZpZWxkLCBgSW1wb3J0IE1lbW9yeSBmaWVsZCBzaG91bGQg YmUgYSBzdHJpbmcsIGdvdCAiJHtmaWVsZH0iYCk7CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNo KHttb2R1bGUsIGZpZWxkLCBraW5kOiAiTWVtb3J5IiwgbWVtb3J5RGVzY3JpcHRpb246IHtpbml0 aWFsLCBtYXhpbXVtfX0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJl dHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9OwogfTsKIApA QCAtMTE4LDcgKzEyOCw3IEBAIGNvbnN0IF9pbXBvcnRUYWJsZUNvbnRpbnVhdGlvbiA9IChidWls ZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgICAgICBhc3NlcnQuaXNTdHJpbmco bW9kdWxlLCBgSW1wb3J0IFRhYmxlIG1vZHVsZSBzaG91bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHtt b2R1bGV9ImApOwogICAgICAgICBhc3NlcnQuaXNTdHJpbmcoZmllbGQsIGBJbXBvcnQgVGFibGUg ZmllbGQgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7ZmllbGR9ImApOwogICAgICAgICBzZWN0 aW9uLmRhdGEucHVzaCh7bW9kdWxlLCBmaWVsZCwga2luZDogIlRhYmxlIiwgdGFibGVEZXNjcmlw dGlvbjoge2luaXRpYWwsIG1heGltdW0sIGVsZW1lbnR9fSk7Ci0gICAgICAgIHJldHVybiBuZXh0 QnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxk ZXIpOwogICAgIH07CiB9OwogCkBAIC0xNzIsNyArMTgyLDcgQEAgY29uc3QgX2V4cG9ydEZ1bmN0 aW9uQ29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAg ICAgICAgICAgICAgICAgYXNzZXJ0LmVxKHR5cGUsIGV4cG9ydGVkSW1wb3J0LnR5cGUsIGBSZS1l eHBvcnRpbmcgaW1wb3J0ICIke2V4cG9ydGVkSW1wb3J0LmZpZWxkfSIgYXMgIiR7ZmllbGR9IiBo YXMgbWlzbWF0Y2hpbmcgdHlwZWApOwogICAgICAgICB9CiAgICAgICAgIHNlY3Rpb24uZGF0YS5w dXNoKHsgZmllbGQ6IGZpZWxkLCB0eXBlOiB0eXBlLCBraW5kOiAiRnVuY3Rpb24iLCBpbmRleDog aW5kZXggfSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9l cnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH07CiB9OwogCkBAIC0xODks NyArMTk5LDcgQEAgY29uc3QgX2V4cG9ydEdsb2JhbENvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBz ZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgIHJldHVybiAoZmllbGQsIGluZGV4KSA9PiB7 CiAgICAgICAgIGFzc2VydC5pc051bWJlcihpbmRleCwgYEdsb2JhbCBleHBvcnRzIG9ubHkgc3Vw cG9ydCBudW1iZXIgaW5kaWNlcyByaWdodCBub3dgKTsKICAgICAgICAgc2VjdGlvbi5kYXRhLnB1 c2goeyBmaWVsZCwga2luZDogIkdsb2JhbCIsIGluZGV4IH0pOwotICAgICAgICByZXR1cm4gbmV4 dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWls ZGVyKTsKICAgICB9CiB9OwogCkBAIC0xOTcsNyArMjA3LDcgQEAgY29uc3QgX2V4cG9ydE1lbW9y eUNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAg IHJldHVybiAoZmllbGQsIGluZGV4KSA9PiB7CiAgICAgICAgIGFzc2VydC5pc051bWJlcihpbmRl eCwgYE1lbW9yeSBleHBvcnRzIG9ubHkgc3VwcG9ydCBudW1iZXIgaW5kaWNlc2ApOwogICAgICAg ICBzZWN0aW9uLmRhdGEucHVzaCh7ZmllbGQsIGtpbmQ6ICJNZW1vcnkiLCBpbmRleH0pOwotICAg ICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1By b3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9CiB9OwogCkBAIC0yMDUsNyArMjE1LDcgQEAgY29u c3QgX2V4cG9ydFRhYmxlQ29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWls ZGVyKSA9PiB7CiAgICAgcmV0dXJuIChmaWVsZCwgaW5kZXgpID0+IHsKICAgICAgICAgYXNzZXJ0 LmlzTnVtYmVyKGluZGV4LCBgVGFibGUgZXhwb3J0cyBvbmx5IHN1cHBvcnQgbnVtYmVyIGluZGlj ZXNgKTsKICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2goe2ZpZWxkLCBraW5kOiAiVGFibGUiLCBp bmRleH0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJy b3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9CiB9OwogCkBAIC0yMjAsMTAg KzIzMCwxMCBAQCBjb25zdCBfaW1wb3J0R2xvYmFsQ29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNl Y3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAgICAgICAgICAgYXNzZXJ0LmlzU3RyaW5n KGZpZWxkLCBgSW1wb3J0IGdsb2JhbCBmaWVsZCBzaG91bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHtm aWVsZH0iYCk7CiAgICAgICAgICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKG11dGFiaWxpdHksIGBJ bXBvcnQgZ2xvYmFsIG11dGFiaWxpdHkgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7bXV0YWJp bGl0eX0iYCk7CiAgICAgICAgICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2goeyBnbG9iYWxEZXNj cmlwdGlvbjogeyB0eXBlOiBvcCwgbXV0YWJpbGl0eTogX25vcm1hbGl6ZU11dGFiaWxpdHkobXV0 YWJpbGl0eSkgfSwgbW9kdWxlLCBmaWVsZCwga2luZDogIkdsb2JhbCIgfSk7Ci0gICAgICAgICAg ICAgICAgcmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJv ckhhbmRsaW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7CiAgICAgICAgICAgICB9OwogICAgICAg ICB9Ci0gICAgICAgIHJldHVybiBnbG9iYWxCdWlsZGVyOworICAgICAgICByZXR1cm4gX2Vycm9y SGFuZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICB9OwogfTsKIApAQCAtMzI0LDEx ICszMzQsMTEgQEAgY29uc3QgX2NyZWF0ZUZ1bmN0aW9uQnVpbGRlciA9IChmdW5jLCBidWlsZGVy LCBwcmV2aW91c0J1aWxkZXIpID0+IHsKICAgICAgICAgICAgIGRlZmF1bHQ6CiAgICAgICAgICAg ICAgICAgbmV4dEJ1aWxkZXIgPSBmdW5jdGlvbkJ1aWxkZXI7CiAgICAgICAgICAgICAgICAgYnJl YWs7Ci0gICAgICAgICAgICAgICAgY2FzZSAiRW5kIjoKKyAgICAgICAgICAgIGNhc2UgIkVuZCI6 CiAgICAgICAgICAgICAgICAgbmV4dEJ1aWxkZXIgPSBwcmV2aW91c0J1aWxkZXI7Ci0gICAgICAg ICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICAg Y2FzZSAiQmxvY2siOgotICAgICAgICAgICAgICAgIGNhc2UgIkxvb3AiOgorICAgICAgICAgICAg Y2FzZSAiTG9vcCI6CiAgICAgICAgICAgICBjYXNlICJJZiI6CiAgICAgICAgICAgICAgICAgbmV4 dEJ1aWxkZXIgPSBfY3JlYXRlRnVuY3Rpb25CdWlsZGVyKGZ1bmMsIGJ1aWxkZXIsIGZ1bmN0aW9u QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgYnJlYWs7CkBAIC0zNDQsMTEgKzM1NCwxMiBAQCBj b25zdCBfY3JlYXRlRnVuY3Rpb25CdWlsZGVyID0gKGZ1bmMsIGJ1aWxkZXIsIHByZXZpb3VzQnVp bGRlcikgPT4gewogICAgICAgICAgICAgY29uc3Qgc3RhY2tBcmdzID0gW107IC8vIEZJWE1FIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjI3MDYKICAgICAgICAgICAg IGZ1bmMuY29kZS5wdXNoKHsgbmFtZTogb3AsIHZhbHVlOiB2YWx1ZSwgYXJndW1lbnRzOiBzdGFj a0FyZ3MsIGltbWVkaWF0ZXM6IGltbXMgfSk7CiAgICAgICAgICAgICBpZiAoaGFzQ29udGludWF0 aW9uKQotICAgICAgICAgICAgICAgIHJldHVybiBjb250aW51YXRpb24obmV4dEJ1aWxkZXIpLkVu ZCgpOwotICAgICAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICAgICAgICAgIHJl dHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGNvbnRpbnVhdGlvbihuZXh0QnVpbGRlcikuRW5k KCkpOworICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxk ZXIpOwogICAgICAgICB9OwotICAgIH0KLSAgICByZXR1cm4gZnVuY3Rpb25CdWlsZGVyOworICAg IH07CisKKyAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihmdW5jdGlvbkJ1aWxkZXIp OwogfQogCiBjb25zdCBfY3JlYXRlRnVuY3Rpb24gPSAoc2VjdGlvbiwgYnVpbGRlciwgcHJldmlv dXNCdWlsZGVyKSA9PiB7CkBAIC00NDksMTAgKzQ2MCwxMCBAQCBleHBvcnQgZGVmYXVsdCBjbGFz cyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgIEZ1bmM6IChwYXJhbXMsIHJldCkg PT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtwYXJhbXMsIHJldF0gPSBfbm9ybWFs aXplRnVuY3Rpb25TaWduYXR1cmUocGFyYW1zLCByZXQpOwogICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHMuZGF0YS5wdXNoKHsgcGFyYW1zOiBwYXJhbXMsIHJldDogcmV0IH0pOwotICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHJldHVybiB0eXBlQnVpbGRlcjsKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih0eXBlQnVpbGRlcik7 CiAgICAgICAgICAgICAgICAgICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICB9OwotICAg ICAgICAgICAgICAgICAgICByZXR1cm4gdHlwZUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAg IHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHR5cGVCdWlsZGVyKTsKICAgICAgICAgICAg ICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC00NjYsNyArNDc3LDcgQEAgZXhw b3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgIGltcG9ydEJ1 aWxkZXIuRnVuY3Rpb24gPSBfaW1wb3J0RnVuY3Rpb25Db250aW51YXRpb24odGhpcywgcywgaW1w b3J0QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgIGltcG9ydEJ1aWxkZXIuTWVtb3J5ID0g X2ltcG9ydE1lbW9yeUNvbnRpbnVhdGlvbih0aGlzLCBzLCBpbXBvcnRCdWlsZGVyKTsKICAgICAg ICAgICAgICAgICAgICAgaW1wb3J0QnVpbGRlci5UYWJsZSA9IF9pbXBvcnRUYWJsZUNvbnRpbnVh dGlvbih0aGlzLCBzLCBpbXBvcnRCdWlsZGVyKTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJu IGltcG9ydEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGlu Z1Byb3h5Rm9yKGltcG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAg ICAgICAgYnJlYWs7CiAKQEAgLTQ3Nyw3ICs0ODgsNyBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBC dWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgIEVuZDogKCkgPT4gdGhpcwogICAgICAg ICAgICAgICAgICAgICAgICAgLy8gRklYTUU6IGFkZCBhYmlsaXR5IHRvIGFkZCB0aGlzIHdpdGgg d2hhdGV2ZXIuCiAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAgICAgICAgICAgICAgICAgIHJl dHVybiBmdW5jdGlvbkJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JI YW5kbGluZ1Byb3h5Rm9yKGZ1bmN0aW9uQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAg ICAgICAgICAgICAgICBicmVhazsKIApAQCAtNDg4LDEwICs0OTksMTAgQEAgZXhwb3J0IGRlZmF1 bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBFbmQ6ICgpID0+IHRo aXMsCiAgICAgICAgICAgICAgICAgICAgICAgICBUYWJsZTogKHtpbml0aWFsLCBtYXhpbXVtLCBl bGVtZW50fSkgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKHt0 YWJsZURlc2NyaXB0aW9uOiB7aW5pdGlhbCwgbWF4aW11bSwgZWxlbWVudH19KTsKLSAgICAgICAg ICAgICAgICAgICAgICAgICAgICByZXR1cm4gdGFibGVCdWlsZGVyOworICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHRhYmxlQnVpbGRlcik7 CiAgICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAg ICAgICAgICAgICAgICAgIHJldHVybiB0YWJsZUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAg IHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHRhYmxlQnVpbGRlcik7CiAgICAgICAgICAg ICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNTAyLDEwICs1MTMsMTAgQEAg ZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBF bmQ6ICgpID0+IHRoaXMsCiAgICAgICAgICAgICAgICAgICAgICAgICBJbml0aWFsTWF4UGFnZXM6 IChpbml0aWFsLCBtYXgpID0+IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRhdGEu cHVzaCh7IGluaXRpYWwsIG1heCB9KTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1 cm4gbWVtb3J5QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vy cm9ySGFuZGxpbmdQcm94eUZvcihtZW1vcnlCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAg ICAgIH0KICAgICAgICAgICAgICAgICAgICAgfTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJu IG1lbW9yeUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGlu Z1Byb3h5Rm9yKG1lbW9yeUJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAg ICAgICAgYnJlYWs7CiAKQEAgLTUxNiwxNiArNTI3LDE2IEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNz IEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRW5kOiAoKSA9PiB0aGlzLAogICAg ICAgICAgICAgICAgICAgICAgICAgR2V0R2xvYmFsOiAodHlwZSwgaW5pdFZhbHVlLCBtdXRhYmls aXR5KSA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcy5kYXRhLnB1c2goeyB0eXBl LCBvcDogImdldF9nbG9iYWwiLCBtdXRhYmlsaXR5OiBfbm9ybWFsaXplTXV0YWJpbGl0eShtdXRh YmlsaXR5KSwgaW5pdFZhbHVlIH0pOwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVy biBnbG9iYWxCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJy b3JIYW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAg ICAgfQogICAgICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgICAgICBmb3IgKGxl dCBvcCBvZiBXQVNNLmRlc2NyaXB0aW9uLnZhbHVlX3R5cGUpIHsKICAgICAgICAgICAgICAgICAg ICAgICAgIGdsb2JhbEJ1aWxkZXJbX3RvSmF2YVNjcmlwdE5hbWUob3ApXSA9IChpbml0VmFsdWUs IG11dGFiaWxpdHkpID0+IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVz aCh7IHR5cGU6IG9wLCBvcDogb3AgKyAiLmNvbnN0IiwgbXV0YWJpbGl0eTogX25vcm1hbGl6ZU11 dGFiaWxpdHkobXV0YWJpbGl0eSksIGluaXRWYWx1ZSB9KTsKLSAgICAgICAgICAgICAgICAgICAg ICAgICAgICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICAgICAg ICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgICAg ICAgICAgcmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBf ZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07 CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTUzOSw3ICs1NTAsNyBAQCBleHBvcnQgZGVm YXVsdCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgZXhwb3J0QnVpbGRlci5G dW5jdGlvbiA9IF9leHBvcnRGdW5jdGlvbkNvbnRpbnVhdGlvbih0aGlzLCBzLCBleHBvcnRCdWls ZGVyKTsKICAgICAgICAgICAgICAgICAgICAgZXhwb3J0QnVpbGRlci5NZW1vcnkgPSBfZXhwb3J0 TWVtb3J5Q29udGludWF0aW9uKHRoaXMsIHMsIGV4cG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAg ICAgICAgICBleHBvcnRCdWlsZGVyLlRhYmxlID0gX2V4cG9ydFRhYmxlQ29udGludWF0aW9uKHRo aXMsIHMsIGV4cG9ydEJ1aWxkZXIpOwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gZXhwb3J0 QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlG b3IoZXhwb3J0QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBi cmVhazsKIApAQCAtNTUyLDcgKzU2Myw3IEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIg ewogICAgICAgICAgICAgICAgICAgICBpZiAodHlwZW9mKGZ1bmN0aW9uSW5kZXhPck5hbWUpICE9 PSAibnVtYmVyIiAmJiB0eXBlb2YoZnVuY3Rpb25JbmRleE9yTmFtZSkgIT09ICJzdHJpbmciKQog ICAgICAgICAgICAgICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBTdGFydCBzZWN0aW9uJ3Mg ZnVuY3Rpb24gaW5kZXggIG11c3QgZWl0aGVyIGJlIGEgbnVtYmVyIG9yIGEgc3RyaW5nYCk7CiAg ICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKGZ1bmN0aW9uSW5kZXhPck5hbWUpOwotICAg ICAgICAgICAgICAgICAgICByZXR1cm4gc3RhcnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAg ICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihzdGFydEJ1aWxkZXIpOwogICAgICAgICAg ICAgICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTU2MywxMSArNTc0LDExIEBA IGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAg RW5kOiAoKSA9PiB0aGlzLAogICAgICAgICAgICAgICAgICAgICAgICAgRWxlbWVudDogKHt0YWJs ZUluZGV4ID0gMCwgb2Zmc2V0LCBmdW5jdGlvbkluZGljZXN9KSA9PiB7CiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgcy5kYXRhLnB1c2goe3RhYmxlSW5kZXgsIG9mZnNldCwgZnVuY3Rpb25J bmRpY2VzfSk7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGVsZW1lbnRCdWls ZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1By b3h5Rm9yKGVsZW1lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAg ICAgICAgICAgICAgICAgfTsKIAotICAgICAgICAgICAgICAgICAgICByZXR1cm4gZWxlbWVudEJ1 aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9y KGVsZW1lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJy ZWFrOwogCkBAIC02MzIsMTIgKzY0MywxMiBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVy IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIEZJWE1FIGluIGNoZWNr ZWQgbW9kZSwgdGVzdCB0aGF0IHRoZSB0eXBlIGlzIGFjY2VwdGFibGUgZm9yIHN0YXJ0IGZ1bmN0 aW9uLiBXZSBwcm9iYWJseSB3YW50IF9yZWdpc3RlckZ1bmN0aW9uVG9JbmRleFNwYWNlIHRvIGFs c28gcmVnaXN0ZXIgdHlwZXMgcGVyIGluZGV4LiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTY1NjU4CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAg ICAgICAgICAgICAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAg cmV0dXJuIGJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJv ckhhbmRsaW5nUHJveHlGb3IoYnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICB9LAog CiAgICAgICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgICAgIGNvZGVCdWlsZGVy LkZ1bmN0aW9uID0gX2NyZWF0ZUZ1bmN0aW9uKHMsIGJ1aWxkZXIsIGNvZGVCdWlsZGVyKTsKLSAg ICAgICAgICAgICAgICAgICAgcmV0dXJuIGNvZGVCdWlsZGVyOworICAgICAgICAgICAgICAgICAg ICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihjb2RlQnVpbGRlcik7CiAgICAgICAgICAg ICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNjYwLDE5ICs2NzEsMTkgQEAg ZXhwb3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIEluZGV4OiBpbmRleCA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBhc3NlcnQuZXEoaW5kZXgsIDApOyAvLyBMaW5lYXIgbWVtb3J5IGluZGV4IG11c3QgYmUg emVybyBpbiBNVlAuCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0aGlzU2Vn bWVudC5pbmRleCA9IGluZGV4OwotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg cmV0dXJuIHNlZ21lbnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3Ioc2VnbWVudEJ1aWxkZXIpOwogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBPZmZzZXQ6IG9mZnNldCA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAvLyBGSVhNRSBhbGxvdyBjb21wbGV4IGluaXRfZXhwciBoZXJlLiBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1NzAwCiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBhc3NlcnQuaXNOdW1iZXIob2Zmc2V0KTsKICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHRoaXNTZWdtZW50Lm9mZnNldCA9IG9mZnNldDsKLSAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBzZWdtZW50QnVpbGRlcjsKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5 Rm9yKHNlZ21lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfSwK ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHJldHVybiBzZWdtZW50QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihzZWdtZW50QnVpbGRlcik7CiAgICAgICAgICAg ICAgICAgICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAgICAgICAg ICAgICByZXR1cm4gZGF0YUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJy b3JIYW5kbGluZ1Byb3h5Rm9yKGRhdGFCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAg ICAgICAgICAgICAgIGJyZWFrOwogCkBAIC02OTAsMTAgKzcwMSwxMCBAQCBleHBvcnQgZGVmYXVs dCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICBCeXRlOiBiID0+IHsKICAgICAgICAg ICAgICAgICAgICAgYXNzZXJ0LmVxKGIgJiAweEZGLCBiLCBgVW5rbm93biBzZWN0aW9uIGV4cGVj dGVkIGJ5dGUsIGdvdDogIiR7Yn0iYCk7CiAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNo KGIpOwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gdW5rbm93bkJ1aWxkZXI7CisgICAgICAg ICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHVua25vd25CdWlsZGVy KTsKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9OwotICAgICAgICAgICAgcmV0dXJu IHVua25vd25CdWlsZGVyOworICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlG b3IodW5rbm93bkJ1aWxkZXIpOwogICAgICAgICB9OwogICAgIH0KICAgICBfYWRkU2VjdGlvbihu YW1lT3JOdW1iZXIsIGV4dHJhT2JqZWN0KSB7CmRpZmYgLS1naXQgYS9KU1Rlc3RzL3dhc20vTG93 TGV2ZWxCaW5hcnkuanMgYi9KU1Rlc3RzL3dhc20vTG93TGV2ZWxCaW5hcnkuanMKaW5kZXggNjEx YTI2ZC4uZjliYzhhMyAxMDA2NDQKLS0tIGEvSlNUZXN0cy93YXNtL0xvd0xldmVsQmluYXJ5Lmpz CisrKyBiL0pTVGVzdHMvd2FzbS9Mb3dMZXZlbEJpbmFyeS5qcwpAQCAtMTcwLDYgKzE3MCwxOCBA QCBleHBvcnQgZGVmYXVsdCBjbGFzcyBMb3dMZXZlbEJpbmFyeSB7CiAgICAgICAgICAgICB0aGlz LnVpbnQ4KDB4ODAgfCBiKTsKICAgICAgICAgfSB3aGlsZSAodHJ1ZSk7CiAgICAgfQorICAgIHZh cnVpbnQ2NCh2KSB7CisgICAgICAgIGFzc2VydC5pc051bWJlcih2KTsKKyAgICAgICAgaWYgKHYg PCB2YXJ1aW50MzJNaW4gfHwgdmFydWludDMyTWF4IDwgdikKKyAgICAgICAgICAgIHRocm93IG5l dyBSYW5nZUVycm9yKGB1bmltcGxlbWVudGVkOiB2YXJ1aW50NjQgbGFyZ2VyIHRoYW4gMzItYml0 YCk7CisgICAgICAgIHRoaXMudmFydWludDMyKHYpOyAvLyBGSVhNRSBpbXBsZW1lbnQgNjQtYml0 IHZhcnt1fWludCBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNDIw CisgICAgfQorICAgIHZhcmludDY0KHYpIHsKKyAgICAgICAgYXNzZXJ0LmlzTnVtYmVyKHYpOwor ICAgICAgICBpZiAodiA8IHZhcmludDMyTWluIHx8IHZhcmludDMyTWF4IDwgdikKKyAgICAgICAg ICAgIHRocm93IG5ldyBSYW5nZUVycm9yKGB1bmltcGxlbWVudGVkOiB2YXJpbnQ2NCBsYXJnZXIg dGhhbiAzMi1iaXRgKTsKKyAgICAgICAgdGhpcy52YXJpbnQzMih2KTsgLy8gRklYTUUgaW1wbGVt ZW50IDY0LWJpdCB2YXJ7dX1pbnQgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTE2MzQyMAorICAgIH0KICAgICB2YXJ1aW50MSh2KSB7CiAgICAgICAgIGlmICh2ICE9PSAw ICYmIHYgIT09IDEpCiAgICAgICAgICAgICB0aHJvdyBuZXcgUmFuZ2VFcnJvcihgSW52YWxpZCB2 YXJ1aW50MSAke3Z9IHJhbmdlIGlzIFswLCAxXWApOwpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNt L2Z1bmN0aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVz dHMvZXhjZXB0aW9ucy5qcwppbmRleCBkMmIzYTQ5Li45NTI1MTNmIDEwMDY0NAotLS0gYS9KU1Rl c3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvZXhjZXB0aW9ucy5qcworKysgYi9KU1Rlc3RzL3dhc20v ZnVuY3Rpb24tdGVzdHMvZXhjZXB0aW9ucy5qcwpAQCAtNDUsMTggKzQ1LDE4IEBAIGZ1bmN0aW9u IG1ha2VJbnN0YW5jZSgpIHsKICAgICBhc3NlcnQuZXEodGFibGUuZ2V0KDApLCBudWxsKTsKIAog ICAgIGZvciAobGV0IGkgPSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0gICAgICAgIGFzc2VydC50aHJv d3MoKCkgPT4gZm9vKDAsIGkpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJjYWxsX2luZGly ZWN0IHRvIGEgbnVsbCB0YWJsZSBlbnRyeSAoZXZhbHVhdGluZyAnZnVuYyguLi5hcmdzKScpIik7 CisgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDAsIGkpLCBXZWJBc3NlbWJseS5SdW50 aW1lRXJyb3IsICJjYWxsX2luZGlyZWN0IHRvIGEgbnVsbCB0YWJsZSBlbnRyeSIpOwogICAgIH0K IAogICAgIHRhYmxlLnNldCgwLCBmb28pOwogICAgIGFzc2VydC5lcSh0YWJsZS5nZXQoMCksIGZv byk7CiAKICAgICBmb3IgKGxldCBpID0gMDsgaSA8IDEwMDA7IGkrKykgewotICAgICAgICBhc3Nl cnQudGhyb3dzKCgpID0+IGZvbygxICsgaSwgaSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwg Ik91dCBvZiBib3VuZHMgY2FsbF9pbmRpcmVjdCAoZXZhbHVhdGluZyAnZnVuYyguLi5hcmdzKScp Iik7CisgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDEgKyBpLCBpKSwgV2ViQXNzZW1i bHkuUnVudGltZUVycm9yLCAiT3V0IG9mIGJvdW5kcyBjYWxsX2luZGlyZWN0Iik7CiAgICAgfQog CiAgICAgZm9yIChsZXQgaSA9IDA7IGkgPCAxMDAwOyBpKyspIHsKLSAgICAgICAgYXNzZXJ0LnRo cm93cygoKSA9PiBmb28oMCwgaSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgImNhbGxfaW5k aXJlY3QgdG8gYSBzaWduYXR1cmUgdGhhdCBkb2VzIG5vdCBtYXRjaCAoZXZhbHVhdGluZyAnZnVu YyguLi5hcmdzKScpIik7CisgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDAsIGkpLCBX ZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJjYWxsX2luZGlyZWN0IHRvIGEgc2lnbmF0dXJlIHRo YXQgZG9lcyBub3QgbWF0Y2giKTsKICAgICB9CiAKICAgICB0YWJsZS5zZXQoMCwgYmFyKTsKZGlm ZiAtLWdpdCBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMgYi9KU1Rl c3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpzCmluZGV4IDRkZDgyZGMuLjEyMzFl MDMgMTAwNjQ0Ci0tLSBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMK KysrIGIvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtbG9hZC5qcwpAQCAtMjksNiAr MjksNiBAQCBmdW5jdGlvbiB3YXNtRnJhbWVDb3VudEZyb21FcnJvcihlKSB7CiB9CiAKIGZvciAo bGV0IGkgPSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0gICAgY29uc3QgZSA9IGFzc2VydC50aHJvd3Mo KCkgPT4gZm9vKG51bVBhZ2VzICogcGFnZVNpemUgKyAxKSwgV2ViQXNzZW1ibHkuUnVudGltZUVy cm9yLCAiT3V0IG9mIGJvdW5kcyBtZW1vcnkgYWNjZXNzIChldmFsdWF0aW5nICdmdW5jKC4uLmFy Z3MpJykiKTsKKyAgICBjb25zdCBlID0gYXNzZXJ0LnRocm93cygoKSA9PiBmb28obnVtUGFnZXMg KiBwYWdlU2l6ZSArIDEpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJPdXQgb2YgYm91bmRz IG1lbW9yeSBhY2Nlc3MiKTsKICAgICBhc3NlcnQuZXEod2FzbUZyYW1lQ291bnRGcm9tRXJyb3Io ZSksIDIpOwogfQpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAt c3RvcmUuanMgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5qcwppbmRl eCA1NTk4N2MyLi4zNjU3MTNhIDEwMDY0NAotLS0gYS9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVz dHMvdHJhcC1zdG9yZS5qcworKysgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1z dG9yZS5qcwpAQCAtMjUsNSArMjUsNSBAQCBjb25zdCBudW1QYWdlcyA9IDEwOwogICAgIGNvbnN0 IGZvbyA9IG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShtb2R1bGUsIHthOiB7YjogbmV3IFdlYkFz c2VtYmx5Lk1lbW9yeSh7aW5pdGlhbDogbnVtUGFnZXN9KX19KS5leHBvcnRzLmZvbzsKIAogICAg IGZvciAobGV0IGkgPSAwOyBpIDwgMTAwMDA7IGkrKykKLSAgICAgICAgYXNzZXJ0LnRocm93cygo KSA9PiBmb28oaSwgbnVtUGFnZXMgKiBwYWdlU2l6ZSArIDEpLCBXZWJBc3NlbWJseS5SdW50aW1l RXJyb3IsICJPdXQgb2YgYm91bmRzIG1lbW9yeSBhY2Nlc3MgKGV2YWx1YXRpbmcgJ2Z1bmMoLi4u YXJncyknKSIpOworICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbyhpLCBudW1QYWdlcyAq IHBhZ2VTaXplICsgMSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgIk91dCBvZiBib3VuZHMg bWVtb3J5IGFjY2VzcyIpOwogfQpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2pzLWFwaS93YXNt LXRvLXdhc20tYmFkLXNpZ25hdHVyZS5qcyBiL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13 YXNtLWJhZC1zaWduYXR1cmUuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u ZDY5YmEyYwotLS0gL2Rldi9udWxsCisrKyBiL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13 YXNtLWJhZC1zaWduYXR1cmUuanMKQEAgLTAsMCArMSwxMDUgQEAKK2ltcG9ydCAqIGFzIGFzc2Vy dCBmcm9tICcuLi9hc3NlcnQuanMnOworaW1wb3J0IEJ1aWxkZXIgZnJvbSAnLi4vQnVpbGRlci5q cyc7CisKK2NvbnN0IGltcG9ydE5hbWUgPSAicGllck9uZSI7Citjb25zdCB0eXBlcyA9IFsiaTMy IiwgImk2NCIsICJmMzIiLCAiZjY0IiwgInZvaWQiXTsKK2NvbnN0IHR5cGVzTm9uVm9pZCA9IFsi aTMyIiwgImk2NCIsICJmMzIiLCAiZjY0Il07Citjb25zdCBzd2FwVHlwZSA9ICh0eXBlLCBpbmRl eCkgPT4gdHlwZXNbKHR5cGVzLmluZGV4T2YodHlwZSkgKyBpbmRleCkgJSB0eXBlcy5sZW5ndGhd OworY29uc3Qgc3dhcFR5cGVOb25Wb2lkID0gKHR5cGUsIGluZGV4KSA9PiB0eXBlc05vblZvaWRb KHR5cGVzTm9uVm9pZC5pbmRleE9mKHR5cGUpICsgaW5kZXgpICUgdHlwZXNOb25Wb2lkLmxlbmd0 aF07CisKK2NvbnN0IHNpZ25hdHVyZXMgPSBbCisgICAgeyBwYXJhbXM6IFsiaTMyIl0sIHJldDog InZvaWQiIH0sCisgICAgeyBwYXJhbXM6IFsiaTY0Il0sIHJldDogInZvaWQiIH0sCisgICAgeyBw YXJhbXM6IFsiZjMyIl0sIHJldDogInZvaWQiIH0sCisgICAgeyBwYXJhbXM6IFsiZjY0Il0sIHJl dDogInZvaWQiIH0sCisgICAgeyBwYXJhbXM6IFsiaTMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7 IHBhcmFtczogWyJpNjQiXSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBbImYzMiJdLCBy ZXQ6ICJmMzIiIH0sCisgICAgeyBwYXJhbXM6IFsiZjY0Il0sIHJldDogImY2NCIgfSwKKyAgICB7 IHBhcmFtczogWyJpMzIiLCAiZjMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7IHBhcmFtczogWyJm MzIiLCAiaTMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7IHBhcmFtczogWyJpNjQiLCAiZjY0Il0s IHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogWyJmNjQiLCAiaTY0Il0sIHJldDogImk2NCIg fSwKKyAgICB7IHBhcmFtczogWyJpMzIiLCAiZjMyIiwgImkzMiJdLCByZXQ6ICJpMzIiIH0sCisg ICAgeyBwYXJhbXM6IFsiaTMyIiwgImYzMiIsICJpMzIiXSwgcmV0OiAiaTMyIiB9LAorICAgIHsg cGFyYW1zOiBbImk2NCIsICJmNjQiLCAiaTY0Il0sIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFt czogWyJpNjQiLCAiZjY0IiwgImk2NCJdLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IEFy cmF5KDMyKS5maWxsKCJpMzIiKSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBBcnJheSgz MikuZmlsbCgiaTY0IiksIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogQXJyYXkoMzIpLmZp bGwoImYzMiIpLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IEFycmF5KDMyKS5maWxsKCJm NjQiKSwgcmV0OiAiaTY0IiB9LAorXTsKKworY29uc3QgbWFrZUltcG9ydGVyID0gc2lnbmF0dXJl ID0+IHsKKyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAgIC5UeXBl KCkuRW5kKCkKKyAgICAgICAgLkltcG9ydCgpLkZ1bmN0aW9uKCJleHBvcnRzIiwgaW1wb3J0TmFt ZSwgc2lnbmF0dXJlKS5FbmQoKTsKKyAgICByZXR1cm4gbmV3IFdlYkFzc2VtYmx5Lk1vZHVsZShi dWlsZGVyLldlYkFzc2VtYmx5KCkuZ2V0KCkpOworfTsKKworY29uc3QgbWFrZUltcG9ydGVlID0g c2lnbmF0dXJlID0+IHsKKyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVyKCkpCisgICAg ICAgIC5UeXBlKCkuRW5kKCkKKyAgICAgICAgLkZ1bmN0aW9uKCkuRW5kKCkKKyAgICAgICAgLkV4 cG9ydCgpCisgICAgICAgICAgICAuRnVuY3Rpb24oaW1wb3J0TmFtZSkKKyAgICAgICAgLkVuZCgp CisgICAgICAgIC5Db2RlKCkKKyAgICAgICAgICAgIC5GdW5jdGlvbihpbXBvcnROYW1lLCBzaWdu YXR1cmUpOworICAgIHN3aXRjaCAoc2lnbmF0dXJlLnJldCkgeworICAgIGNhc2UgImkzMiI6IGJ1 aWxkZXIuSTMyQ29uc3QoMCk7IGJyZWFrOworICAgIGNhc2UgImk2NCI6IGJ1aWxkZXIuSTY0Q29u c3QoMCk7IGJyZWFrOworICAgIGNhc2UgImYzMiI6IGJ1aWxkZXIuRjMyQ29uc3QoMCk7IGJyZWFr OworICAgIGNhc2UgImY2NCI6IGJ1aWxkZXIuRjY0Q29uc3QoMCk7IGJyZWFrOworICAgIGNhc2Ug InZvaWQiOiBicmVhazsKKyAgICB9CisgICAgcmV0dXJuIG5ldyBXZWJBc3NlbWJseS5JbnN0YW5j ZShuZXcgV2ViQXNzZW1ibHkuTW9kdWxlKGJ1aWxkZXIuUmV0dXJuKCkuRW5kKCkuRW5kKCkuV2Vi QXNzZW1ibHkoKS5nZXQoKSkpOworfTsKKworKGZ1bmN0aW9uIEJhZFNpZ25hdHVyZURyb3BTdGFy dFBhcmFtcygpIHsKKyAgICBmb3IgKGxldCBzaWduYXR1cmUgb2Ygc2lnbmF0dXJlcykgeworICAg ICAgICBjb25zdCBpbXBvcnRlZSA9IG1ha2VJbXBvcnRlZShzaWduYXR1cmUpOworICAgICAgICBm b3IgKGxldCBpID0gMTsgaSA8PSBzaWduYXR1cmUucGFyYW1zLmxlbmd0aDsgKytpKSB7CisgICAg ICAgICAgICBjb25zdCBiYWRQYXJhbVNpZ25hdHVyZSA9IHsgcGFyYW1zOiBzaWduYXR1cmUucGFy YW1zLnNsaWNlKGksIHNpZ25hdHVyZS5wYXJhbXMubGVuZ3RoKSwgcmV0OiBzaWduYXR1cmUucmV0 IH07CisgICAgICAgICAgICBjb25zdCBpbXBvcnRlciA9IG1ha2VJbXBvcnRlcihiYWRQYXJhbVNp Z25hdHVyZSk7CisgICAgICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IG5ldyBXZWJBc3NlbWJs eS5JbnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpLCBXZWJBc3NlbWJseS5MaW5rRXJyb3IsIGBp bXBvcnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBkb2Vzbid0IG1hdGNoIHRoZSBwcm92aWRlZCBX ZWJBc3NlbWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSAoZXZhbHVhdGluZyAnbmV3IFdlYkFzc2Vt Ymx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSknKWApOworICAgICAgICB9CisgICAgfQor fSkoKTsKKworKGZ1bmN0aW9uIEJhZFNpZ25hdHVyZURyb3BFbmRQYXJhbXMoKSB7CisgICAgZm9y IChsZXQgc2lnbmF0dXJlIG9mIHNpZ25hdHVyZXMpIHsKKyAgICAgICAgY29uc3QgaW1wb3J0ZWUg PSBtYWtlSW1wb3J0ZWUoc2lnbmF0dXJlKTsKKyAgICAgICAgZm9yIChsZXQgaSA9IDE7IGkgPCBz aWduYXR1cmUucGFyYW1zLmxlbmd0aDsgKytpKSB7CisgICAgICAgICAgICBjb25zdCBiYWRQYXJh bVNpZ25hdHVyZSA9IHsgcGFyYW1zOiBzaWduYXR1cmUucGFyYW1zLnNsaWNlKDAsIGkpLCByZXQ6 IHNpZ25hdHVyZS5yZXQgfTsKKyAgICAgICAgICAgIGNvbnN0IGltcG9ydGVyID0gbWFrZUltcG9y dGVyKGJhZFBhcmFtU2lnbmF0dXJlKTsKKyAgICAgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4g bmV3IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSksIFdlYkFzc2VtYmx5 LkxpbmtFcnJvciwgYGltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIGRvZXNuJ3QgbWF0Y2gg dGhlIHByb3ZpZGVkIFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIChldmFsdWF0aW5n ICduZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKScpYCk7CisgICAg ICAgIH0KKyAgICB9Cit9KSgpOworCisoZnVuY3Rpb24gQmFkU2lnbmF0dXJlU3dhcFBhcmFtKCkg eworICAgIGZvciAobGV0IHNpZ25hdHVyZSBvZiBzaWduYXR1cmVzKSB7CisgICAgICAgIGNvbnN0 IGltcG9ydGVlID0gbWFrZUltcG9ydGVlKHNpZ25hdHVyZSk7CisgICAgICAgIGZvciAobGV0IHNp Z25hdHVyZUluZGV4ID0gMDsgc2lnbmF0dXJlSW5kZXggPCBzaWduYXR1cmUubGVuZ3RoOyArK3Np Z25hdHVyZUluZGV4KSB7CisgICAgICAgICAgICBmb3IgKGxldCB0eXBlSW5kZXggPSAxOyB0eXBl SW5kZXggPCB0eXBlc05vblZvaWQubGVuZ3RoOyArK3R5cGVJbmRleCkgeworICAgICAgICAgICAg ICAgIGxldCBiYWRQYXJhbXMgPSBzaWduYXR1cmUucGFyYW1zLnNsaWNlKCk7CisgICAgICAgICAg ICAgICAgYmFkUGFyYW1zW3NpZ25hdHVyZUluZGV4XSA9IHN3YXBUeXBlTm9uVm9pZChiYWRQYXJh bXNbc2lnbmF0dXJlSW5kZXhdLCB0eXBlSW5kZXgpOworICAgICAgICAgICAgICAgIGNvbnN0IGJh ZFBhcmFtU2lnbmF0dXJlID0geyBwYXJhbXM6IGJhZFBhcmFtcywgcmV0OiBzaWduYXR1cmUucmV0 IH07CisgICAgICAgICAgICAgICAgY29uc3QgaW1wb3J0ZXIgPSBtYWtlSW1wb3J0ZXIoYmFkUGFy YW1TaWduYXR1cmUpOworICAgICAgICAgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gbmV3IFdl YkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSksIFdlYkFzc2VtYmx5LkxpbmtF cnJvciwgYGltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIGRvZXNuJ3QgbWF0Y2ggdGhlIHBy b3ZpZGVkIFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIChldmFsdWF0aW5nICduZXcg V2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKScpYCk7CisgICAgICAgICAg ICB9CisgICAgICAgIH0KKyAgICB9Cit9KSgpOworCisoZnVuY3Rpb24gQmFkU2lnbmF0dXJlUmV0 KCkgeworICAgIGZvciAobGV0IHNpZ25hdHVyZSBvZiBzaWduYXR1cmVzKSB7CisgICAgICAgIGNv bnN0IGltcG9ydGVlID0gbWFrZUltcG9ydGVlKHNpZ25hdHVyZSk7CisgICAgICAgIGZvciAobGV0 IHR5cGVJbmRleCA9IDE7IHR5cGVJbmRleCA8IHR5cGVzLmxlbmd0aDsgKyt0eXBlSW5kZXgpIHsK KyAgICAgICAgICAgIGNvbnN0IGJhZFBhcmFtU2lnbmF0dXJlID0geyBwYXJhbXM6IHNpZ25hdHVy ZS5wYXJhbXMsIHJldDogc3dhcFR5cGUoc2lnbmF0dXJlLnJldCwgdHlwZUluZGV4KSB9OworICAg ICAgICAgICAgY29uc3QgaW1wb3J0ZXIgPSBtYWtlSW1wb3J0ZXIoYmFkUGFyYW1TaWduYXR1cmUp OworICAgICAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBuZXcgV2ViQXNzZW1ibHkuSW5zdGFu Y2UoaW1wb3J0ZXIsIGltcG9ydGVlKSwgV2ViQXNzZW1ibHkuTGlua0Vycm9yLCBgaW1wb3J0ZWQg ZnVuY3Rpb24ncyBzaWduYXR1cmUgZG9lc24ndCBtYXRjaCB0aGUgcHJvdmlkZWQgV2ViQXNzZW1i bHkgZnVuY3Rpb24ncyBzaWduYXR1cmUgKGV2YWx1YXRpbmcgJ25ldyBXZWJBc3NlbWJseS5JbnN0 YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpJylgKTsKKyAgICAgICAgfQorICAgIH0KK30pKCk7CmRp ZmYgLS1naXQgYS9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS5qcyBiL0pTVGVzdHMv d2FzbS9qcy1hcGkvd2FzbS10by13YXNtLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAuLjJkZjQ2ZTYKLS0tIC9kZXYvbnVsbAorKysgYi9KU1Rlc3RzL3dhc20vanMtYXBpL3dh c20tdG8td2FzbS5qcwpAQCAtMCwwICsxLDcyIEBACitpbXBvcnQgKiBhcyBhc3NlcnQgZnJvbSAn Li4vYXNzZXJ0LmpzJzsKK2ltcG9ydCBCdWlsZGVyIGZyb20gJy4uL0J1aWxkZXIuanMnOworCitj b25zdCBjYWxsZXJUb3BCaXRzID0gMHhDMEZFQkVFRjsKK2NvbnN0IGlubmVyUmV0dXJuSGkgPSAw eERFQURGQUNFOworY29uc3QgaW5uZXJSZXR1cm5MbyA9IDB4QzBGRUMwRkU7CisKK2NvbnN0IGNh bGxlck1vZHVsZSA9ICgpID0+IHsKKyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVyKCkp CisgICAgICAgIC5UeXBlKCkuRW5kKCkKKyAgICAgICAgLkltcG9ydCgpCisgICAgICAgICAgICAu RnVuY3Rpb24oImV4cG9ydHMiLCAiY2FsbE1lIiwgeyBwYXJhbXM6IFsiaTY0Il0sIHJldDogImk2 NCIgfSkKKyAgICAgICAgLkVuZCgpCisgICAgICAgIC5GdW5jdGlvbigpLkVuZCgpCisgICAgICAg IC5FeHBvcnQoKQorICAgICAgICAgICAgLkZ1bmN0aW9uKCJlbnRyeSIpCisgICAgICAgIC5FbmQo KQorICAgICAgICAuQ29kZSgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImVudHJ5IiwgeyBwYXJh bXM6IFsiaTMyIl0sIHJldDogImkzMiIgfSwgWyJpNjQiXSkKKyAgICAgICAgICAgICAgICAuSTMy Q29uc3QoY2FsbGVyVG9wQml0cykuSTY0RXh0ZW5kVUkzMigpLkkzMkNvbnN0KDMyKS5JNjRFeHRl bmRVSTMyKCkuSTY0U2hsKCkgLy8gKChpNjQpY2FsbGVyVG9wQml0cykgPDwgMzIKKyAgICAgICAg ICAgICAgICAuR2V0TG9jYWwoMCkuSTY0RXh0ZW5kVUkzMigpCisgICAgICAgICAgICAgICAgLkk2 NE9yKCkgLy8gdmFsdWU6IHBhcmFtIHwgKCgoaTY0KWNhbGxlclRvcEJpdHMgPDwgMzIpKQorICAg ICAgICAgICAgICAgIC5DYWxsKDApIC8vIENhbGxzIGV4cG9ydHMuY2FsbE1lKHBhcmFtIHwgKCgo aTY0KWNhbGxlclRvcEJpdHMpIDw8IDMyKSkuCisgICAgICAgICAgICAgICAgLlRlZUxvY2FsKDEp LkkzMldyYXBJNjQoKSAvLyBsbzogKGkzMiljYWxsUmVzdWx0CisgICAgICAgICAgICAgICAgLkdl dExvY2FsKDEpLkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRVSTMyKCkuSTY0U2hyVSgpLkkzMldyYXBJ NjQoKSAvLyBoaTogKGkzMikoY2FsbFJlc3VsdCA+PiAzMikKKyAgICAgICAgICAgICAgICAuSTMy WG9yKCkKKyAgICAgICAgICAgICAgICAuUmV0dXJuKCkKKyAgICAgICAgICAgIC5FbmQoKQorICAg ICAgICAuRW5kKCk7CisgICAgcmV0dXJuIG5ldyBXZWJBc3NlbWJseS5Nb2R1bGUoYnVpbGRlci5X ZWJBc3NlbWJseSgpLmdldCgpKTsKK307CisKK2NvbnN0IGNhbGxlZU1vZHVsZSA9ICgpID0+IHsK KyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAgIC5UeXBlKCkuRW5k KCkKKyAgICAgICAgLkltcG9ydCgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImltcCIsICJmdW5j IiwgeyBwYXJhbXM6IFsiaTMyIiwgImkzMiJdLCByZXQ6ICJpMzIiIH0pCisgICAgICAgIC5FbmQo KQorICAgICAgICAuRnVuY3Rpb24oKS5FbmQoKQorICAgICAgICAuRXhwb3J0KCkKKyAgICAgICAg ICAgIC5GdW5jdGlvbigiY2FsbE1lIikKKyAgICAgICAgLkVuZCgpCisgICAgICAgIC5Db2RlKCkK KyAgICAgICAgICAgIC5GdW5jdGlvbigiY2FsbE1lIiwgeyBwYXJhbXM6IFsiaTY0Il0sIHJldDog Imk2NCIgfSkKKyAgICAgICAgICAgICAgICAuR2V0TG9jYWwoMCkuSTMyV3JhcEk2NCgpIC8vIGxv OiAoaTMyKXBhcmFtCisgICAgICAgICAgICAgICAgLkdldExvY2FsKDApLkkzMkNvbnN0KDMyKS5J NjRFeHRlbmRVSTMyKCkuSTY0U2hyVSgpLkkzMldyYXBJNjQoKSAvLyBoaTogKGkzMikocGFyYW0g Pj4gMzIpCisgICAgICAgICAgICAgICAgLkNhbGwoMCkgLy8gQ2FsbHMgaW1wLmZ1bmMgd2l0aCB0 aGUgNjQtYml0IHZhbHVlIGFzIGkzMiB7IGhpLCBsbyB9LgorICAgICAgICAgICAgICAgIC5Ecm9w KCkKKyAgICAgICAgICAgICAgICAuSTMyQ29uc3QoaW5uZXJSZXR1cm5IaSkuSTY0RXh0ZW5kVUkz MigpLkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRVSTMyKCkuSTY0U2hsKCkuSTMyQ29uc3QoaW5uZXJS ZXR1cm5MbykuSTY0RXh0ZW5kVUkzMigpLkk2NE9yKCkgLy8gKChpNjQpaGkgPDwgMzIpIHwgKGk2 NClsbworICAgICAgICAgICAgICAgIC5SZXR1cm4oKQorICAgICAgICAgICAgLkVuZCgpCisgICAg ICAgIC5FbmQoKTsKKyAgICByZXR1cm4gbmV3IFdlYkFzc2VtYmx5Lk1vZHVsZShidWlsZGVyLldl YkFzc2VtYmx5KCkuZ2V0KCkpOworfTsKKworKGZ1bmN0aW9uIFdhc21Ub1dhc20oKSB7CisgICAg bGV0IHZhbHVlOworICAgIGNvbnN0IGZ1bmMgPSAoaGksIGxvKSA9PiB7IHZhbHVlID0geyBoaTog aGksIGxvOiBsbyB9OyByZXR1cm4gaGkgXiBsbzsgfTsKKyAgICBjb25zdCBjYWxsZWUgPSBuZXcg V2ViQXNzZW1ibHkuSW5zdGFuY2UoY2FsbGVlTW9kdWxlKCksIHsgaW1wOiB7IGZ1bmM6IGZ1bmMg fSB9KTsKKyAgICBjb25zdCBjYWxsZXIgPSBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoY2FsbGVy TW9kdWxlKCksIGNhbGxlZSk7CisgICAgZm9yIChsZXQgaSA9IDA7IGkgPCA0MDk2OyArK2kpIHsK KyAgICAgICAgYXNzZXJ0LmVxKGNhbGxlci5leHBvcnRzLmVudHJ5KGkpLCBpbm5lclJldHVybkhp IF4gaW5uZXJSZXR1cm5Mbyk7CisgICAgICAgIGFzc2VydC5lcSh2YWx1ZS5sbyA+Pj4gMCwgY2Fs bGVyVG9wQml0cyk7CisgICAgICAgIGFzc2VydC5lcSh2YWx1ZS5oaSA+Pj4gMCwgaSk7CisgICAg fQorfSkoKTsKKworLy8gRklYTUUgdGVzdCB0aGUgZm9sbG93aW5nIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjY2MjUKKy8vIC0gd2FzbS0+d2FzbSB1c2luZyAzMi1i aXQgdGhpbmdzIChpbmNsdWRpbmcgZmxvYXQpLCBhcyB3ZWxsIGFzIDY0LWJpdCBOYU5zIHRoYXQg ZG9uJ3QgZ2V0IGNhbm9uaWNhbGl6ZWQKKy8vIC0gRG8gYSB0aHJvdyB0d28tZGVlcAorLy8gLSBD aGVjayB0aGF0IHRoZSBmaXJzdCB3YXNtJ3MgaW5zdGFuY2UgaXMgYmFjayBpbiBPSyBzdGF0ZSAo d2l0aCB0YWJsZSBvciBnbG9iYWw/KQorLy8gLSBUZXN0IGNhbGxpbmcgdGhyb3VnaCBhIFRhYmxl CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ01ha2VMaXN0cy50eHQgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvQ01ha2VMaXN0cy50eHQKaW5kZXggOTY5YTEyMy4uOWRlMWEzYSAx MDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NNYWtlTGlzdHMudHh0CisrKyBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9DTWFrZUxpc3RzLnR4dApAQCAtOTA1LDYgKzkwNSw3IEBAIHNl dChKYXZhU2NyaXB0Q29yZV9TT1VSQ0VTCiAgICAgd2FzbS9XYXNtTWVtb3J5LmNwcAogICAgIHdh c20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmNwcAogICAgIHdhc20vV2FzbU1vZHVsZVBhcnNlci5j cHAKKyAgICB3YXNtL1dhc21QYWdlQ291bnQuY3BwCiAgICAgd2FzbS9XYXNtUGxhbi5jcHAKICAg ICB3YXNtL1dhc21TaWduYXR1cmUuY3BwCiAgICAgd2FzbS9XYXNtVmFsaWRhdGUuY3BwCmRpZmYg LS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL0NoYW5nZUxvZwppbmRleCAzNjQxZGEyLi5iNzdkNWNiIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9D aGFuZ2VMb2cKQEAgLTEsMyArMSwxMjggQEAKKzIwMTYtMTItMzAgIEpGIEJhc3RpZW4gIDxqZmJh c3RpZW5AYXBwbGUuY29tPgorCisgICAgICAgIFdlYkFzc2VtYmx5OiBoYW5kbGUgYW5kIG9wdGlt aXplIHdhc20gZXhwb3J0IOKGkiB3YXNtIGltcG9ydCBjYWxscworICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1MjgyCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgICAtIEFkZCBhIG5ldyBKU1R5cGUgZm9yIFdl YkFzc2VtYmx5RnVuY3Rpb24sIGFuZCB1c2UgaXQgd2hlbiBjcmVhdGluZyBpdHMKKyAgICAgICAg ICAgIHN0cnVjdHVyZS4gVGhpcyB3aWxsIGlzIHVzZWQgdG8gcXVpY2tseSBkZXRlY3QgZnJvbSB3 YXNtIHdoZXRoZXIgdGhlIGltcG9ydAorICAgICAgICAgICAgY2FsbCBpcyB0byBhbm90aGVyIHdh c20gbW9kdWxlLCBvciB3aGV0aGVyIGl0J3MgdG8gSlMuCisgICAgICAgICAgLSBHZW5lcmF0ZSB0 d28gc3R1YnMgZnJvbSB0aGUgaW1wb3J0IHN0dWIgZ2VuZXJhdG9yOiBvbmUgZm9yIHdhc20tPkpT IGFuZCBvbmUKKyAgICAgICAgICAgIGZvciB3YXNtIC0+IHdhc20uIFRoaXMgaXMgZG9uZSBhdCBN b2R1bGUgdGltZS4gV2hpY2ggaXMgY2FsbGVkIHdpbGwgb25seSBiZQorICAgICAgICAgICAga25v d24gYXQgSW5zdGFuY2UgdGltZSwgb25jZSB3ZSd2ZSByZWNlaXZlZCB0aGUgaW1wb3J0IG9iamVj dC4gV2Ugd2FudCB0bworICAgICAgICAgICAgYXZvaWQgY29kZWdlbiBhdCBJbnN0YW5jZSB0aW1l LCBzbyBoYXZpbmcgYm90aCBhcm91bmQgaXMgZ3JlYXQuCisgICAgICAgICAgLSBSZXN0b3JlIHRo ZSBXZWJBc3NlbWJseSBnbG9iYWwgc3RhdGUgKFZNIHRvcCBJbnN0YW5jZSwgYW5kIHBpbm5lZCBy ZWdpc3RlcnMpCisgICAgICAgICAgICBhZnRlciBjYWxsIC8gY2FsbF9pbmRpcmVjdCwgYW5kIGlu IHRoZSBKUy0+d2FzbSBlbnRyeSBzdHViLgorICAgICAgICAgIC0gUGlubmVkIHJlZ2lzdGVycyBh cmUgbm93IGEgZ2xvYmFsIHRoaW5nLCBub3QgcGVyLU1lbW9yeSwgYmVjYXVzZSB0aGUgd2FzbSAt PgorICAgICAgICAgICAgd2FzbSBzdHVicyBhcmUgZ2VuZXJhdGVkIGF0IE1vZHVsZSB0aW1lIHdo ZXJlIHdlIGRvbid0IHJlYWxseSBoYXZlIGVub3VnaAorICAgICAgICAgICAgaW5mb3JtYXRpb24g dG8gZG8gdGhlIHJpZ2h0IHRoaW5nIChkb2luZyBzbyB3b3VsZCBnZW5lcmF0ZSB0b28gbXVjaCBj b2RlKS4KKworICAgICAgICAqIENNYWtlTGlzdHMudHh0OgorICAgICAgICAqIEphdmFTY3JpcHRD b3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogcnVudGltZS9KU1R5cGUu aDogYWRkIFdlYkFzc2VtYmx5RnVuY3Rpb25UeXBlIGFzIGEgSlNUeXBlCisgICAgICAgICogd2Fz bS9XYXNtQjNJUkdlbmVyYXRvci5jcHA6IHNpZ25pZmljYW50bHkgcmV3b3JrIGhvdyBjYWxscyB3 aGljaAorICAgICAgICBjb3VsZCBiZSBleHRlcm5hbCB3b3JrLCBhbmQgaG93IHdlIHNhdmUgLyBy ZXN0b3JlIGdsb2JhbCBzdGF0ZToKKyAgICAgICAgVk0ncyB0b3AgSW5zdGFuY2UsIGFuZCBwaW5u ZWQgcmVnaXN0ZXJzCisgICAgICAgIChKU0M6Oldhc206OkIzSVJHZW5lcmF0b3I6OkIzSVJHZW5l cmF0b3IpOgorICAgICAgICAoSlNDOjpXYXNtOjpnZXRNZW1vcnlCYXNlQW5kU2l6ZSk6CisgICAg ICAgIChKU0M6Oldhc206OnJlc3RvcmVXZWJBc3NlbWJseUdsb2JhbFN0YXRlKToKKyAgICAgICAg KEpTQzo6V2FzbTo6Y3JlYXRlSlNUb1dhc21XcmFwcGVyKToKKyAgICAgICAgKEpTQzo6V2FzbTo6 cGFyc2VBbmRDb21waWxlKToKKyAgICAgICAgKiB3YXNtL1dhc21CM0lSR2VuZXJhdG9yLmg6Cisg ICAgICAgICogd2FzbS9XYXNtQmluZGluZy5jcHA6CisgICAgICAgIChKU0M6Oldhc206Om1hdGVy aWFsaXplSW1wb3J0SlNDZWxsKToKKyAgICAgICAgKEpTQzo6V2FzbTo6d2FzbVRvSlMpOgorICAg ICAgICAoSlNDOjpXYXNtOjp3YXNtVG9XYXNtKTogdGhlIG1haW4gZ29hbCBvZiB0aGlzIHBhdGNo IHdhcyBhZGRpbmcgdGhpcyBmdW5jdGlvbgorICAgICAgICAoSlNDOjpXYXNtOjpleGl0U3R1Ykdl bmVyYXRvcik6CisgICAgICAgICogd2FzbS9XYXNtQmluZGluZy5oOgorICAgICAgICAqIHdhc20v V2FzbUZvcm1hdC5oOiBHZXQgcmlkIG9mIG11Y2ggb2YgdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNl OgorICAgICAgICB3ZSBhbHJlYWR5IGhhdmUgYWxsIG9mIGl0cyBpbmZvcm1hdGlvbiBlbHNld2hl cmUsIGFuZCBhcy1pcyBpdAorICAgICAgICBwcm92aWRlcyBubyBleHRyYSBlZmZpY2llbmN5Lgor ICAgICAgICAoSlNDOjpXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbjo6ZnVuY3Rpb25JbmRleFNwYWNl U2l6ZSk6CisgICAgICAgIChKU0M6Oldhc206Ok1vZHVsZUluZm9ybWF0aW9uOjppc0ltcG9ydGVk RnVuY3Rpb25Gcm9tRnVuY3Rpb25JbmRleFNwYWNlKToKKyAgICAgICAgKEpTQzo6V2FzbTo6TW9k dWxlSW5mb3JtYXRpb246OnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZSk6Cisg ICAgICAgICogd2FzbS9XYXNtRnVuY3Rpb25QYXJzZXIuaDoKKyAgICAgICAgKEpTQzo6V2FzbTo6 RnVuY3Rpb25QYXJzZXI8Q29udGV4dD46OkZ1bmN0aW9uUGFyc2VyKToKKyAgICAgICAgKiB3YXNt L1dhc21NZW1vcnkuY3BwOiBBZGQgc29tZSBsb2dnaW5nLgorICAgICAgICAoSlNDOjpXYXNtOjpN ZW1vcnk6OmR1bXApOiB0aGlzIHdhcyBuaWNlIHdoZW4gZGVidWdnaW5nCisgICAgICAgIChKU0M6 Oldhc206Ok1lbW9yeTo6bWFrZVN0cmluZyk6CisgICAgICAgIChKU0M6Oldhc206Ok1lbW9yeTo6 TWVtb3J5KToKKyAgICAgICAgKEpTQzo6V2FzbTo6TWVtb3J5Ojp+TWVtb3J5KToKKyAgICAgICAg KEpTQzo6V2FzbTo6TWVtb3J5Ojpncm93KToKKyAgICAgICAgKiB3YXNtL1dhc21NZW1vcnkuaDog ZG9uJ3QgdXNlIGV4dHJhIGluZGlyZWN0aW9uLCBpdCB3YXNuJ3QKKyAgICAgICAgbmVlZGVkLiBS ZW9yZGVyIHNvbWUgb2YgdGhlIGZpZWxkcyB3aGljaCBhcmUgbG9va2VkIHVwIGF0IHJ1bnRpbWUK KyAgICAgICAgc28gdGhleSdyZSBtb3JlIGNhY2hlLWZyaWVuZGx5LgorICAgICAgICAoSlNDOjpX YXNtOjpNZW1vcnk6Ok1lbW9yeSk6CisgICAgICAgIChKU0M6Oldhc206Ok1lbW9yeTo6bW9kZSk6 CisgICAgICAgIChKU0M6Oldhc206Ok1lbW9yeTo6b2Zmc2V0T2ZTaXplKToKKyAgICAgICAgKiB3 YXNtL1dhc21NZW1vcnlJbmZvcm1hdGlvbi5jcHA6IFBpbm5lZCByZWdpc3RlcnMgYXJlIG5vdyBh CisgICAgICAgIGdsb2JhbCB0aGluZyBmb3IgYWxsIG9mIEpTQywgbm90IGEgcGVyLU1lbW9yeSB0 aGluZworICAgICAgICBhbnltb3JlLiB3YXNtLT53YXNtIGNhbGxzIGFyZSBtb3JlIGNvbXBsZXgg b3RoZXJ3aXNlOiB0aGV5IGhhdmUgdG8KKyAgICAgICAgZmlndXJlIG91dCBob3cgdG8gYnJpZGdl IGJldHdlZW4gdGhlIGNhbGxlciBhbmQgY2FsbGVlJ3MKKyAgICAgICAgc3BlY2lhbC1zbm93Zmxh a2UgcGlubmluZy4KKyAgICAgICAgKEpTQzo6V2FzbTo6UGlubmVkUmVnaXN0ZXJJbmZvOjpnZXQp OgorICAgICAgICAoSlNDOjpXYXNtOjpQaW5uZWRSZWdpc3RlckluZm86OlBpbm5lZFJlZ2lzdGVy SW5mbyk6CisgICAgICAgIChKU0M6Oldhc206Ok1lbW9yeUluZm9ybWF0aW9uOjpNZW1vcnlJbmZv cm1hdGlvbik6CisgICAgICAgICogd2FzbS9XYXNtTWVtb3J5SW5mb3JtYXRpb24uaDoKKyAgICAg ICAgKiB3YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwOgorICAgICAgICAqIHdhc20vV2FzbU1vZHVs ZVBhcnNlci5oOgorICAgICAgICAqIHdhc20vV2FzbVBhZ2VDb3VudC5jcHA6IENvcGllZCBmcm9t IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmguCisgICAgICAgIChKU0M6 Oldhc206OlBhZ2VDb3VudDo6ZHVtcCk6IG5pY2UgZm9yIGRlYnVnZ2luZworICAgICAgICAqIHdh c20vV2FzbVBhZ2VDb3VudC5oOgorICAgICAgICAqIHdhc20vV2FzbVBsYW4uY3BwOgorICAgICAg ICAoSlNDOjpXYXNtOjpQbGFuOjpwYXJzZUFuZFZhbGlkYXRlTW9kdWxlKToKKyAgICAgICAgKEpT Qzo6V2FzbTo6UGxhbjo6cnVuKToKKyAgICAgICAgKiB3YXNtL1dhc21QbGFuLmg6CisgICAgICAg IChKU0M6Oldhc206OlBsYW46OnRha2VXYXNtRXhpdFN0dWJzKToKKyAgICAgICAgKiB3YXNtL1dh c21TaWduYXR1cmUuY3BwOgorICAgICAgICAoSlNDOjpXYXNtOjpTaWduYXR1cmU6OnRvU3RyaW5n KToKKyAgICAgICAgKEpTQzo6V2FzbTo6U2lnbmF0dXJlOjpkdW1wKToKKyAgICAgICAgKiB3YXNt L1dhc21TaWduYXR1cmUuaDoKKyAgICAgICAgKiB3YXNtL1dhc21WYWxpZGF0ZS5jcHA6CisgICAg ICAgIChKU0M6Oldhc206OnZhbGlkYXRlRnVuY3Rpb24pOgorICAgICAgICAqIHdhc20vV2FzbVZh bGlkYXRlLmg6CisgICAgICAgICogd2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaDoKKyAg ICAgICAgKEpTQzo6SlNXZWJBc3NlbWJseUluc3RhbmNlOjpvZmZzZXRPZlRhYmxlKToKKyAgICAg ICAgKEpTQzo6SlNXZWJBc3NlbWJseUluc3RhbmNlOjpvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucyk6 CisgICAgICAgIChKU0M6OkpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZJbXBvcnRGdW5j dGlvbik6CisgICAgICAgICogd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNwcDoKKyAgICAg ICAgKEpTQzo6SlNXZWJBc3NlbWJseU1lbW9yeTo6Y3JlYXRlKToKKyAgICAgICAgKEpTQzo6SlNX ZWJBc3NlbWJseU1lbW9yeTo6SlNXZWJBc3NlbWJseU1lbW9yeSk6CisgICAgICAgIChKU0M6OkpT V2ViQXNzZW1ibHlNZW1vcnk6OmJ1ZmZlcik6CisgICAgICAgIChKU0M6OkpTV2ViQXNzZW1ibHlN ZW1vcnk6Omdyb3cpOgorICAgICAgICAqIHdhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5oOgor ICAgICAgICAoSlNDOjpKU1dlYkFzc2VtYmx5TWVtb3J5OjptZW1vcnkpOgorICAgICAgICAoSlND OjpKU1dlYkFzc2VtYmx5TWVtb3J5OjpvZmZzZXRPZk1lbW9yeSk6CisgICAgICAgIChKU0M6OkpT V2ViQXNzZW1ibHlNZW1vcnk6Om9mZnNldE9mU2l6ZSk6CisgICAgICAgICogd2FzbS9qcy9KU1dl YkFzc2VtYmx5TW9kdWxlLmNwcDoKKyAgICAgICAgKEpTQzo6SlNXZWJBc3NlbWJseU1vZHVsZTo6 Y3JlYXRlKToKKyAgICAgICAgKEpTQzo6SlNXZWJBc3NlbWJseU1vZHVsZTo6SlNXZWJBc3NlbWJs eU1vZHVsZSk6CisgICAgICAgICogd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmg6CisgICAg ICAgIChKU0M6OkpTV2ViQXNzZW1ibHlNb2R1bGU6OnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9u SW5kZXhTcGFjZSk6CisgICAgICAgIChKU0M6OkpTV2ViQXNzZW1ibHlNb2R1bGU6OmZ1bmN0aW9u SW1wb3J0Q291bnQpOgorICAgICAgICAqIHdhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlvbi5jcHA6 CisgICAgICAgIChKU0M6OmNhbGxXZWJBc3NlbWJseUZ1bmN0aW9uKToKKyAgICAgICAgKEpTQzo6 V2ViQXNzZW1ibHlGdW5jdGlvbjo6Y3JlYXRlKToKKyAgICAgICAgKEpTQzo6V2ViQXNzZW1ibHlG dW5jdGlvbjo6Y3JlYXRlU3RydWN0dXJlKToKKyAgICAgICAgKEpTQzo6V2ViQXNzZW1ibHlGdW5j dGlvbjo6V2ViQXNzZW1ibHlGdW5jdGlvbik6CisgICAgICAgIChKU0M6OldlYkFzc2VtYmx5RnVu Y3Rpb246OmZpbmlzaENyZWF0aW9uKToKKyAgICAgICAgKiB3YXNtL2pzL1dlYkFzc2VtYmx5RnVu Y3Rpb24uaDoKKyAgICAgICAgKEpTQzo6V2ViQXNzZW1ibHlGdW5jdGlvbjo6d2FzbUVudHJ5cG9p bnQpOgorICAgICAgICAoSlNDOjpXZWJBc3NlbWJseUZ1bmN0aW9uOjpvZmZzZXRPZkluc3RhbmNl KToKKyAgICAgICAgKEpTQzo6V2ViQXNzZW1ibHlGdW5jdGlvbjo6b2Zmc2V0T2ZXYXNtRW50cnlQ b2ludENvZGUpOgorICAgICAgICAqIHdhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVj dG9yLmNwcDoKKyAgICAgICAgKEpTQzo6Y29uc3RydWN0SlNXZWJBc3NlbWJseUluc3RhbmNlKTog YWx3YXlzIHN0YXJ0IHdpdGggYSBkdW1teQorICAgICAgICBtZW1vcnksIHNvIHdhc20tPndhc20g Y2FsbHMgZG9uJ3QgbmVlZCB0byBudWxsLWNoZWNrCisgICAgICAgICogd2FzbS9qcy9XZWJBc3Nl bWJseU1lbW9yeUNvbnN0cnVjdG9yLmNwcDoKKyAgICAgICAgKEpTQzo6Y29uc3RydWN0SlNXZWJB c3NlbWJseU1lbW9yeSk6CisgICAgICAgICogd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0 cnVjdG9yLmNwcDoKKyAgICAgICAgKEpTQzo6V2ViQXNzZW1ibHlNb2R1bGVDb25zdHJ1Y3Rvcjo6 Y3JlYXRlTW9kdWxlKToKKyAgICAgICAgKiB3YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3Jk LmNwcDoKKyAgICAgICAgKEpTQzo6V2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmxpbmspOgorICAg ICAgICAoSlNDOjpXZWJBc3NlbWJseU1vZHVsZVJlY29yZDo6ZXZhbHVhdGUpOgorICAgICAgICAq IHdhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQuaDoKKwogMjAxNi0xMi0yOCAgU2FhbSBC YXJhdGkgIDxzYmFyYXRpQGFwcGxlLmNvbT4KIAogICAgICAgICBXZWJBc3NlbWJseTogRG9uJ3Qg YWxsb3cgZHVwbGljYXRlIGV4cG9ydCBuYW1lcwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpp bmRleCBkOTMyNTZiLi4xMTYzNjllIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv SmF2YVNjcmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAt MTIzNSw2ICsxMjM1LDcgQEAKIAkJMkFERkEyNjMxOEVGMzU0MDAwNEY5RkNDIC8qIEdDTG9nZ2lu Zy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAyQURG QTI2MjE4RUYzNTQwMDA0RjlGQ0MgLyogR0NMb2dnaW5nLmNwcCAqLzsgfTsKIAkJMkFGNzM4MkMx OEJCQkY5MjAwOEE1QTM3IC8qIFN0cnVjdHVyZUlEVGFibGUuY3BwIGluIFNvdXJjZXMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMkFGNzM4MkExOEJCQkY5MjAwOEE1QTM3IC8q IFN0cnVjdHVyZUlEVGFibGUuY3BwICovOyB9OwogCQkyQUY3MzgyRDE4QkJCRjkyMDA4QTVBMzcg LyogU3RydWN0dXJlSURUYWJsZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gMkFGNzM4MkIxOEJCQkY5MjAwOEE1QTM3IC8qIFN0cnVjdHVyZUlEVGFibGUu aCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQkyRDM0 MkYzNkY3MjQ0MDk2ODA0QURCMjQgLyogU291cmNlT3JpZ2luLmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0MjVCQTEzMzdFNDM0NEUxQjI2OUE2NzEgLyog U291cmNlT3JpZ2luLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsg fTsgfTsKIAkJMzcxRDg0MkQxN0M5OEI2RTAwRUNGOTk0IC8qIGxpYnouZHlsaWIgaW4gRnJhbWV3 b3JrcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAzNzFEODQyQzE3Qzk4QjZF MDBFQ0Y5OTQgLyogbGliei5keWxpYiAqLzsgfTsKIAkJNDEyOTUyNzcxRDJDRjZCQzAwRTc4Qjg5 IC8qIGJ1aWx0aW5zX2dlbmVyYXRlX2ludGVybmFsc193cmFwcGVyX2hlYWRlci5weSBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQxMjk1MjczMUQyQ0Y2QUMw MEU3OEI4OSAvKiBidWlsdGluc19nZW5lcmF0ZV9pbnRlcm5hbHNfd3JhcHBlcl9oZWFkZXIucHkg Ki87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDEyOTUy NzgxRDJDRjZCQzAwRTc4Qjg5IC8qIGJ1aWx0aW5zX2dlbmVyYXRlX2ludGVybmFsc193cmFwcGVy X2ltcGxlbWVudGF0aW9uLnB5IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gNDEyOTUyNzQxRDJDRjZBQzAwRTc4Qjg5IC8qIGJ1aWx0aW5zX2dlbmVyYXRlX2lu dGVybmFsc193cmFwcGVyX2ltcGxlbWVudGF0aW9uLnB5ICovOyBzZXR0aW5ncyA9IHtBVFRSSUJV VEVTID0gKFByaXZhdGUsICk7IH07IH07CkBAIC0yMDI1LDYgKzIwMjYsNyBAQAogCQlBRDc0MzhD MDFFMDQ1N0E0MDBGRDBDMkEgLyogV2FzbVNpZ25hdHVyZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQUQ3NDM4QkYxRTA0NTc5MjAwRkQwQzJBIC8qIFdh c21TaWduYXR1cmUuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9 OyB9OwogCQlBRDc0MzhDMTFFMDQ1N0FBMDBGRDBDMkEgLyogV2FzbVNpZ25hdHVyZS5jcHAgaW4g U291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBRDc0MzhCRTFFMDQ1 NzkyMDBGRDBDMkEgLyogV2FzbVNpZ25hdHVyZS5jcHAgKi87IH07CiAJCUFEODZBOTNFMUFBNEQ4 OEQwMDJGRTc3RiAvKiBXZWFrR0NNYXBJbmxpbmVzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBRDg2QTkzRDFBQTREODdDMDAyRkU3N0YgLyogV2Vha0dD TWFwSW5saW5lcy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07 IH07CisJCUFEQjZGNjdEMUUxNUQ3NjAwMDgyRjM4NCAvKiBXYXNtUGFnZUNvdW50LmNwcCBpbiBT b3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEFEQjZGNjdDMUUxNUQ3 NTAwMDgyRjM4NCAvKiBXYXNtUGFnZUNvdW50LmNwcCAqLzsgfTsKIAkJQURCQzU0RDQxREY4RUEy QjAwNUJGNzM4IC8qIFdlYkFzc2VtYmx5VG9KU0NhbGxlZS5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBREJDNTREMjFERjhFQTAwMDA1QkY3MzggLyog V2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmNwcCAqLzsgfTsKIAkJQURCQzU0RDUxREY4RUEyQjAwNUJG NzM4IC8qIFdlYkFzc2VtYmx5VG9KU0NhbGxlZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gQURCQzU0RDMxREY4RUEwMDAwNUJGNzM4IC8qIFdlYkFzc2Vt Ymx5VG9KU0NhbGxlZS5oICovOyB9OwogCQlBRERCMUY2MzE4RDc3REJFMDA5QjU4QTggLyogT3Bh cXVlUm9vdFNldC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gQUREQjFGNjIxOEQ3N0RCNzAwOUI1OEE4IC8qIE9wYXF1ZVJvb3RTZXQuaCAqLzsgc2V0dGlu Z3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAtMjM2MSw3ICsyMzYzLDYg QEAKIAkJRkVEOTRGMkYxNzFFM0UyMzAwQkU3N0E0IC8qIFdhdGNoZG9nLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGRUQ5NEYyQzE3MUUzRTIzMDBCRTc3 QTQgLyogV2F0Y2hkb2cuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCAp OyB9OyB9OwogCQlGRUYwNDA1MTFBQUU2NjJEMDBCRDI4QjAgLyogQ29tcGFyZUFuZFN3YXBUZXN0 LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZFRjA0 MDUwMUFBRTY2MkQwMEJEMjhCMCAvKiBDb21wYXJlQW5kU3dhcFRlc3QuY3BwICovOyB9OwogCQlG RUZENkZDNjFENUU3OTkyMDA4RjJGMEIgLyogSlNTdHJpbmdJbmxpbmVzLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGRUZENkZDNTFENUU3OTcwMDA4RjJG MEIgLyogSlNTdHJpbmdJbmxpbmVzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJp dmF0ZSwgKTsgfTsgfTsKLQkJMkQzNDJGMzZGNzI0NDA5NjgwNEFEQjI0IC8qIFNvdXJjZU9yaWdp bi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDI1QkEx MzM3RTQzNDRFMUIyNjlBNjcxIC8qIFNvdXJjZU9yaWdpbi5oICovOyBzZXR0aW5ncyA9IHtBVFRS SUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAvKiBFbmQgUEJYQnVpbGRGaWxlIHNlY3Rpb24g Ki8KIAogLyogQmVnaW4gUEJYQ29udGFpbmVySXRlbVByb3h5IHNlY3Rpb24gKi8KQEAgLTM2Mzgs NiArMzYzOSw3IEBACiAJCTQxMjk1Mjc1MUQyQ0Y2QUMwMEU3OEI4OSAvKiBidWlsdGluc19nZW5l cmF0ZV93cmFwcGVyX2hlYWRlci5weSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuc2NyaXB0LnB5dGhvbjsgcGF0 aCA9IGJ1aWx0aW5zX2dlbmVyYXRlX3dyYXBwZXJfaGVhZGVyLnB5OyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQk0MTI5NTI3NjFEMkNGNkFDMDBFNzhCODkgLyogYnVpbHRpbnNfZ2VuZXJh dGVfd3JhcHBlcl9pbXBsZW1lbnRhdGlvbi5weSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuc2NyaXB0LnB5dGhv bjsgcGF0aCA9IGJ1aWx0aW5zX2dlbmVyYXRlX3dyYXBwZXJfaW1wbGVtZW50YXRpb24ucHk7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQxREVBMTMxMUI5RjMxNTQwMDZENjVERCAvKiBC dWlsdGluVXRpbHMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQnVpbHRpblV0 aWxzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTQyNUJBMTMzN0U0MzQ0RTFCMjY5 QTY3MSAvKiBTb3VyY2VPcmlnaW4uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0g U291cmNlT3JpZ2luLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQzMTlEQTAxMUMx QkUzQzEwMDFEMjYwQiAvKiBCM0xvd2VyTWFjcm9zQWZ0ZXJPcHRpbWl6YXRpb25zLmNwcCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgbmFtZSA9IEIzTG93ZXJNYWNyb3NBZnRlck9wdGlt aXphdGlvbnMuY3BwOyBwYXRoID0gYjMvQjNMb3dlck1hY3Jvc0FmdGVyT3B0aW1pemF0aW9ucy5j cHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQzMTlEQTAyMUMxQkUzQzEwMDFEMjYw QiAvKiBCM0xvd2VyTWFjcm9zQWZ0ZXJPcHRpbWl6YXRpb25zLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgbmFtZSA9IEIzTG93ZXJNYWNyb3NBZnRlck9wdGltaXphdGlvbnMuaDsgcGF0aCA9 IGIzL0IzTG93ZXJNYWNyb3NBZnRlck9wdGltaXphdGlvbnMuaDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJNDM0MEE0ODIxQTkwNTFBRjAwRDczQ0NBIC8qIE1hdGhDb21tb24uY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gTWF0aENvbW1vbi5jcHA7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC00NTEwLDYgKzQ1MTIsNyBAQAogCQlBRDc0MzhCRTFF MDQ1NzkyMDBGRDBDMkEgLyogV2FzbVNpZ25hdHVyZS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmNwcC5jcHA7IHBhdGggPSBXYXNtU2lnbmF0dXJlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKIAkJQUQ3NDM4QkYxRTA0NTc5MjAwRkQwQzJBIC8qIFdhc21TaWduYXR1cmUuaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gV2FzbVNpZ25hdHVyZS5oOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQlBRDg2QTkzRDFBQTREODdDMDAyRkU3N0YgLyogV2Vha0dDTWFw SW5saW5lcy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXZWFrR0NNYXBJbmxp bmVzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUFEQjZGNjdDMUUxNUQ3NTAwMDgy RjM4NCAvKiBXYXNtUGFnZUNvdW50LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsg cGF0aCA9IFdhc21QYWdlQ291bnQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlB REJDNTREMjFERjhFQTAwMDA1QkY3MzggLyogV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmNwcCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgbmFtZSA9IFdlYkFzc2VtYmx5VG9KU0NhbGxlZS5j cHA7IHBhdGggPSBqcy9XZWJBc3NlbWJseVRvSlNDYWxsZWUuY3BwOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQlBREJDNTREMzFERjhFQTAwMDA1QkY3MzggLyogV2ViQXNzZW1ibHlUb0pT Q2FsbGVlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFdlYkFzc2VtYmx5VG9K U0NhbGxlZS5oOyBwYXRoID0ganMvV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCUFEREIxRjYyMThENzdEQjcwMDlCNThBOCAvKiBPcGFxdWVSb290 U2V0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE9wYXF1ZVJvb3RTZXQuaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTQ4NzksNyArNDg4Miw2IEBACiAJCUZFRjA0 MDUwMUFBRTY2MkQwMEJEMjhCMCAvKiBDb21wYXJlQW5kU3dhcFRlc3QuY3BwICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gQ29tcGFyZUFuZFN3YXBUZXN0LmNwcDsgcGF0aCA9 IEFQSS90ZXN0cy9Db21wYXJlQW5kU3dhcFRlc3QuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQlGRUYwNDA1MjFBQUVDNEVEMDBCRDI4QjAgLyogQ29tcGFyZUFuZFN3YXBUZXN0Lmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IENvbXBhcmVBbmRTd2FwVGVzdC5oOyBw YXRoID0gQVBJL3Rlc3RzL0NvbXBhcmVBbmRTd2FwVGVzdC5oOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQlGRUZENkZDNTFENUU3OTcwMDA4RjJGMEIgLyogSlNTdHJpbmdJbmxpbmVzLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpTU3RyaW5nSW5saW5lcy5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwotCQk0MjVCQTEzMzdFNDM0NEUxQjI2OUE2NzEgLyogU291 cmNlT3JpZ2luLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFNvdXJjZU9yaWdp bi5oOyBwYXRoID0gU291cmNlT3JpZ2luLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAv KiBFbmQgUEJYRmlsZVJlZmVyZW5jZSBzZWN0aW9uICovCiAKIC8qIEJlZ2luIFBCWEZyYW1ld29y a3NCdWlsZFBoYXNlIHNlY3Rpb24gKi8KQEAgLTYwNDcsNiArNjA0OSw3IEBACiAJCQkJNzlCNzU5 NzIxREZBNEM2MDAwNTIxNzRDIC8qIFdhc21NZW1vcnlJbmZvcm1hdGlvbi5oICovLAogCQkJCTUz RjQwRTk2MUQ1QTdCRUMwMDk5QTFCNiAvKiBXYXNtTW9kdWxlUGFyc2VyLmNwcCAqLywKIAkJCQk1 M0Y0MEU5NDFENUE3QUVGMDA5OUExQjYgLyogV2FzbU1vZHVsZVBhcnNlci5oICovLAorCQkJCUFE QjZGNjdDMUUxNUQ3NTAwMDgyRjM4NCAvKiBXYXNtUGFnZUNvdW50LmNwcCAqLywKIAkJCQk3OUI3 NTk3MzFERkE0QzYwMDA1MjE3NEMgLyogV2FzbVBhZ2VDb3VudC5oICovLAogCQkJCTUzRjQwRThD MUQ1OTAxRjIwMDk5QTFCNiAvKiBXYXNtUGFyc2VyLmggKi8sCiAJCQkJNTMxMzc0QkUxRDVDRTk1 MDAwQUY3QTBCIC8qIFdhc21QbGFuLmNwcCAqLywKQEAgLTk3MDMsNiArOTcwNiw3IEBACiAJCQkJ MEY2NEIyNzExQTc4NEJBRjAwNkU0RTY2IC8qIEJpbmFyeVN3aXRjaC5jcHAgaW4gU291cmNlcyAq LywKIAkJCQkxNDI4MDg2MzEwN0VDMTFBMDAxM0U3QjIgLyogQm9vbGVhbkNvbnN0cnVjdG9yLmNw cCBpbiBTb3VyY2VzICovLAogCQkJCTE0MjgwODY0MTA3RUMxMUEwMDEzRTdCMiAvKiBCb29sZWFu T2JqZWN0LmNwcCBpbiBTb3VyY2VzICovLAorCQkJCUFEQjZGNjdEMUUxNUQ3NjAwMDgyRjM4NCAv KiBXYXNtUGFnZUNvdW50LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTE0MjgwODY1MTA3RUMxMUEw MDEzRTdCMiAvKiBCb29sZWFuUHJvdG90eXBlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCURFMjZF OTA3MUNCNURFRkIwMEQyQkU4MiAvKiBCdWlsdGluRXhlY3V0YWJsZUNyZWF0b3IuY3BwIGluIFNv dXJjZXMgKi8sCiAJCQkJQTdEODAxQTQxODgwRDY2RTAwMjZDMzlCIC8qIEJ1aWx0aW5FeGVjdXRh Ymxlcy5jcHAgaW4gU291cmNlcyAqLywKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9qc2MuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2pzYy5jcHAKaW5kZXggM2VhZjRhMC4u M2E3YTNmNCAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2pzYy5jcHAKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL2pzYy5jcHAKQEAgLTI2NDcsNyArMjY0Nyw2IEBAIHN0YXRp YyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGZ1bmN0aW9uVGVzdFdhc21Nb2R1bGVGdW5j dGlvbnMoRXhlY1N0YXRlKiBlCiAgICAgICAgICAgICAgICAgbGFzdEluZGV4ID0gY2FsbGVlSW5k ZXg7CiAgICAgICAgICAgICB9KTsKICAgICB9Ci0KICAgICBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6 TW9kdWxlSW5mb3JtYXRpb24+IG1vZHVsZUluZm9ybWF0aW9uID0gcGxhbi50YWtlTW9kdWxlSW5m b3JtYXRpb24oKTsKICAgICBSRUxFQVNFX0FTU0VSVCghbW9kdWxlSW5mb3JtYXRpb24tPm1lbW9y eSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTVHlwZS5o IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmgKaW5kZXggMDUyMDJmMy4u YWM1MDlkNyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBl LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmgKQEAgLTkzLDYg KzkzLDggQEAgZW51bSBKU1R5cGUgOiB1aW50OF90IHsKICAgICBKU01hcFR5cGUsCiAgICAgSlNT ZXRUeXBlLAogCisgICAgV2ViQXNzZW1ibHlGdW5jdGlvblR5cGUsCisKICAgICBMYXN0SlNDT2Jq ZWN0VHlwZSA9IEpTU2V0VHlwZSwKICAgICBNYXhKU1R5cGUgPSAwYjExMTExMTExLAogfTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNw cCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcAppbmRl eCAxMTdkNzY0Li45ZjA0MGI5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtQjNJUkdlbmVyYXRvci5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbUIzSVJHZW5lcmF0b3IuY3BwCkBAIC0xNTUsNyArMTU1LDcgQEAgcHVibGljOgogICAgICAg ICAgICAgcmV0dXJuIGZhaWwoX19WQV9BUkdTX18pOyAgICAgICAgICAgICBcCiAgICAgfSB3aGls ZSAoMCkKIAotICAgIEIzSVJHZW5lcmF0b3IoVk0mLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYs IFByb2NlZHVyZSYsIFdhc21JbnRlcm5hbEZ1bmN0aW9uKiwgVmVjdG9yPFVubGlua2VkV2FzbVRv V2FzbUNhbGw+JiwgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJik7CisgICAgQjNJ UkdlbmVyYXRvcihWTSYsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiwgUHJvY2VkdXJlJiwgV2Fz bUludGVybmFsRnVuY3Rpb24qLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mKTsKIAog ICAgIFBhcnRpYWxSZXN1bHQgV0FSTl9VTlVTRURfUkVUVVJOIGFkZEFyZ3VtZW50cyhjb25zdCBT aWduYXR1cmUqKTsKICAgICBQYXJ0aWFsUmVzdWx0IFdBUk5fVU5VU0VEX1JFVFVSTiBhZGRMb2Nh bChUeXBlLCB1aW50MzJfdCk7CkBAIC0yMDUsOCArMjA1LDYgQEAgcHVibGljOgogCiAgICAgdm9p ZCBlbWl0RXhjZXB0aW9uQ2hlY2soQ0NhbGxIZWxwZXJzJiwgRXhjZXB0aW9uVHlwZSk7CiAKLSAg ICB2b2lkIGVtaXRSZWxvYWRQaW5uZWRSZWdpc3RlcnMoKTsKLQogcHJpdmF0ZToKICAgICBFeHBy ZXNzaW9uVHlwZSBlbWl0Q2hlY2tBbmRQcmVwYXJlUG9pbnRlcihFeHByZXNzaW9uVHlwZSBwb2lu dGVyLCB1aW50MzJfdCBvZmZzZXQsIHVpbnQzMl90IHNpemVPZk9wKTsKICAgICBFeHByZXNzaW9u VHlwZSBlbWl0TG9hZE9wKExvYWRPcFR5cGUsIE9yaWdpbiwgRXhwcmVzc2lvblR5cGUgcG9pbnRl ciwgdWludDMyX3Qgb2Zmc2V0KTsKQEAgLTIxOSw3ICsyMTcsNiBAQCBwcml2YXRlOgogICAgIHZv aWQgZW1pdENoZWNrc0Zvck1vZE9yRGl2KEIzOjpPcGNvZGUsIEV4cHJlc3Npb25UeXBlIGxlZnQs IEV4cHJlc3Npb25UeXBlIHJpZ2h0KTsKIAogICAgIFZNJiBtX3ZtOwotICAgIGNvbnN0IEltbXV0 YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYgbV9mdW5jdGlvbkluZGV4U3BhY2U7CiAgICAgY29uc3Qg TW9kdWxlSW5mb3JtYXRpb24mIG1faW5mbzsKICAgICBQcm9jZWR1cmUmIG1fcHJvYzsKICAgICBC YXNpY0Jsb2NrKiBtX2N1cnJlbnRCbG9jazsKQEAgLTIzMSw5ICsyMjgsOCBAQCBwcml2YXRlOgog ICAgIFZhbHVlKiBtX2luc3RhbmNlVmFsdWU7CiB9OwogCi1CM0lSR2VuZXJhdG9yOjpCM0lSR2Vu ZXJhdG9yKFZNJiB2bSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFByb2NlZHVyZSYg cHJvY2VkdXJlLCBXYXNtSW50ZXJuYWxGdW5jdGlvbiogY29tcGlsYXRpb24sIFZlY3RvcjxVbmxp bmtlZFdhc21Ub1dhc21DYWxsPiYgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGNvbnN0IEltbXV0 YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYgZnVuY3Rpb25JbmRleFNwYWNlKQorQjNJUkdlbmVyYXRv cjo6QjNJUkdlbmVyYXRvcihWTSYgdm0sIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBpbmZvLCBQ cm9jZWR1cmUmIHByb2NlZHVyZSwgV2FzbUludGVybmFsRnVuY3Rpb24qIGNvbXBpbGF0aW9uLCBW ZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzKQog ICAgIDogbV92bSh2bSkKLSAgICAsIG1fZnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXhT cGFjZSkKICAgICAsIG1faW5mbyhpbmZvKQogICAgICwgbV9wcm9jKHByb2NlZHVyZSkKICAgICAs IG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHModW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMpCkBAIC0y NTQsMTQgKzI1MCwxNiBAQCBCM0lSR2VuZXJhdG9yOjpCM0lSR2VuZXJhdG9yKFZNJiB2bSwgY29u c3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFByb2NlZHVyZSYgcAogICAgICAgICB9CiAgICAg fQogCi0gICAgaWYgKGluZm8uaGFzTWVtb3J5KCkpIHsKLSAgICAgICAgbV9tZW1vcnlCYXNlR1BS ID0gaW5mby5tZW1vcnkucGlubmVkUmVnaXN0ZXJzKCkuYmFzZU1lbW9yeVBvaW50ZXI7Ci0gICAg ICAgIG1fcHJvYy5waW5SZWdpc3RlcihtX21lbW9yeUJhc2VHUFIpOwotICAgICAgICBBU1NFUlQo IWluZm8ubWVtb3J5LnBpbm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnNbMF0uc2l6ZU9mZnNl dCk7Ci0gICAgICAgIG1fbWVtb3J5U2l6ZUdQUiA9IGluZm8ubWVtb3J5LnBpbm5lZFJlZ2lzdGVy cygpLnNpemVSZWdpc3RlcnNbMF0uc2l6ZVJlZ2lzdGVyOwotICAgICAgICBmb3IgKGNvbnN0IFBp bm5lZFNpemVSZWdpc3RlckluZm8mIHJlZ0luZm8gOiBpbmZvLm1lbW9yeS5waW5uZWRSZWdpc3Rl cnMoKS5zaXplUmVnaXN0ZXJzKQotICAgICAgICAgICAgbV9wcm9jLnBpblJlZ2lzdGVyKHJlZ0lu Zm8uc2l6ZVJlZ2lzdGVyKTsKKyAgICAvLyBGSVhNRSB3ZSBkb24ndCByZWFsbHkgbmVlZCB0byBw aW4gcmVnaXN0ZXJzIGhlcmUgaWYgdGhlcmUncyBubyBtZW1vcnkuIEl0IG1ha2VzIHdhc20gLT4g d2FzbSB0aHVua3Mgc2ltcGxlciBmb3Igbm93LiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTY2NjIzCisgICAgY29uc3QgUGlubmVkUmVnaXN0ZXJJbmZvJiBwaW5uZWRS ZWdzID0gUGlubmVkUmVnaXN0ZXJJbmZvOjpnZXQoKTsKKyAgICBtX21lbW9yeUJhc2VHUFIgPSBw aW5uZWRSZWdzLmJhc2VNZW1vcnlQb2ludGVyOworICAgIG1fcHJvYy5waW5SZWdpc3RlcihtX21l bW9yeUJhc2VHUFIpOworICAgIEFTU0VSVCghcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzWzBdLnNp emVPZmZzZXQpOworICAgIG1fbWVtb3J5U2l6ZUdQUiA9IHBpbm5lZFJlZ3Muc2l6ZVJlZ2lzdGVy c1swXS5zaXplUmVnaXN0ZXI7CisgICAgZm9yIChjb25zdCBQaW5uZWRTaXplUmVnaXN0ZXJJbmZv JiByZWdJbmZvIDogcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzKQorICAgICAgICBtX3Byb2MucGlu UmVnaXN0ZXIocmVnSW5mby5zaXplUmVnaXN0ZXIpOwogCisgICAgaWYgKGluZm8uaGFzTWVtb3J5 KCkpIHsKICAgICAgICAgbV9wcm9jLnNldFdhc21Cb3VuZHNDaGVja0dlbmVyYXRvcihbPV0gKEND YWxsSGVscGVycyYgaml0LCBHUFJSZWcgcGlubmVkR1BSLCB1bnNpZ25lZCkgewogICAgICAgICAg ICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93U2NyYXRjaChqaXQpOwogICAg ICAgICAgICAgQVNTRVJUX1VOVVNFRChwaW5uZWRHUFIsIG1fbWVtb3J5U2l6ZUdQUiA9PSBwaW5u ZWRHUFIpOwpAQCAtMjc1LDYgKzI3Myw1NSBAQCBCM0lSR2VuZXJhdG9yOjpCM0lSR2VuZXJhdG9y KFZNJiB2bSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFByb2NlZHVyZSYgcAogICAg ICAgICBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KG1fcHJvYywgT3Jp Z2luKCksICZtX3ZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZSkpOwogfQogCitzdHJ1Y3QgTWVt b3J5QmFzZUFuZFNpemUgeworICAgIFZhbHVlKiBiYXNlOworICAgIFZhbHVlKiBzaXplOworfTsK Kworc3RhdGljIE1lbW9yeUJhc2VBbmRTaXplIGdldE1lbW9yeUJhc2VBbmRTaXplKFZNJiB2bSwg VmFsdWUqIGluc3RhbmNlLCBQcm9jZWR1cmUmIHByb2MsIEJhc2ljQmxvY2sqIGJsb2NrKQorewor ICAgIFZhbHVlKiBtZW1vcnlPYmplY3QgPSBibG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihw cm9jLCBMb2FkLCBwb2ludGVyVHlwZSgpLCBPcmlnaW4oKSwgaW5zdGFuY2UsIEpTV2ViQXNzZW1i bHlJbnN0YW5jZTo6b2Zmc2V0T2ZNZW1vcnkoKSk7CisKKyAgICBzdGF0aWNfYXNzZXJ0KHNpemVv ZihkZWNsdHlwZSh2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UtPm1lbW9yeSgpLT5tZW1vcnko KS0+bWVtb3J5KCkpKSA9PSBzaXplb2Yodm9pZCopLCAiY29kZWdlbiByZWxpZXMgb24gdGhpcyBz aXplIik7CisgICAgc3RhdGljX2Fzc2VydChzaXplb2YoZGVjbHR5cGUodm0udG9wSlNXZWJBc3Nl bWJseUluc3RhbmNlLT5tZW1vcnkoKS0+bWVtb3J5KCktPnNpemUoKSkpID09IHNpemVvZih1aW50 NjRfdCksICJjb2RlZ2VuIHJlbGllcyBvbiB0aGlzIHNpemUiKTsKKyAgICBNZW1vcnlCYXNlQW5k U2l6ZSByZXN1bHQ7CisgICAgcmVzdWx0LmJhc2UgPSBibG9jay0+YXBwZW5kTmV3PE1lbW9yeVZh bHVlPihwcm9jLCBMb2FkLCBwb2ludGVyVHlwZSgpLCBPcmlnaW4oKSwgbWVtb3J5T2JqZWN0LCBK U1dlYkFzc2VtYmx5TWVtb3J5OjpvZmZzZXRPZk1lbW9yeSgpKTsKKyAgICByZXN1bHQuc2l6ZSA9 IGJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KHByb2MsIExvYWQsIEludDY0LCBPcmlnaW4o KSwgbWVtb3J5T2JqZWN0LCBKU1dlYkFzc2VtYmx5TWVtb3J5OjpvZmZzZXRPZlNpemUoKSk7CisK KyAgICByZXR1cm4gcmVzdWx0OworfQorCitzdGF0aWMgdm9pZCByZXN0b3JlV2ViQXNzZW1ibHlH bG9iYWxTdGF0ZShWTSYgdm0sIGNvbnN0IE1lbW9yeUluZm9ybWF0aW9uJiBtZW1vcnksIFZhbHVl KiBpbnN0YW5jZSwgUHJvY2VkdXJlJiBwcm9jLCBCYXNpY0Jsb2NrKiBibG9jaykKK3sKKyAgICBi bG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihwcm9jLCBTdG9yZSwgT3JpZ2luKCksIGluc3Rh bmNlLCBibG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KHByb2MsIE9yaWdpbigpLCAmdm0u dG9wSlNXZWJBc3NlbWJseUluc3RhbmNlKSk7CisKKyAgICBpZiAoISFtZW1vcnkpIHsKKyAgICAg ICAgY29uc3QgUGlubmVkUmVnaXN0ZXJJbmZvKiBwaW5uZWRSZWdzID0gJlBpbm5lZFJlZ2lzdGVy SW5mbzo6Z2V0KCk7CisgICAgICAgIFJlZ2lzdGVyU2V0IGNsb2JiZXJzOworICAgICAgICBjbG9i YmVycy5zZXQocGlubmVkUmVncy0+YmFzZU1lbW9yeVBvaW50ZXIpOworICAgICAgICBmb3IgKGF1 dG8gaW5mbyA6IHBpbm5lZFJlZ3MtPnNpemVSZWdpc3RlcnMpCisgICAgICAgICAgICBjbG9iYmVy cy5zZXQoaW5mby5zaXplUmVnaXN0ZXIpOworCisgICAgICAgIEIzOjpQYXRjaHBvaW50VmFsdWUq IHBhdGNocG9pbnQgPSBibG9jay0+YXBwZW5kTmV3PEIzOjpQYXRjaHBvaW50VmFsdWU+KHByb2Ms IEIzOjpWb2lkLCBPcmlnaW4oKSk7CisgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMgPSBFZmZl Y3RzOjpub25lKCk7CisgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0g dHJ1ZTsKKyAgICAgICAgcGF0Y2hwb2ludC0+Y2xvYmJlcihjbG9iYmVycyk7CisgICAgICAgIHBh dGNocG9pbnQtPm51bUdQU2NyYXRjaFJlZ2lzdGVycyA9IDE7CisKKyAgICAgICAgcGF0Y2hwb2lu dC0+YXBwZW5kKGluc3RhbmNlLCBWYWx1ZVJlcDo6U29tZVJlZ2lzdGVyKTsKKworICAgICAgICBw YXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3Bpbm5lZFJlZ3NdIChDQ2FsbEhlbHBlcnMmIGppdCwg Y29uc3QgQjM6OlN0YWNrbWFwR2VuZXJhdGlvblBhcmFtcyYgcGFyYW1zKSB7CisgICAgICAgICAg ICBHUFJSZWcgYmFzZU1lbW9yeSA9IHBpbm5lZFJlZ3MtPmJhc2VNZW1vcnlQb2ludGVyOworICAg ICAgICAgICAgaml0LmxvYWRQdHIoQ0NhbGxIZWxwZXJzOjpBZGRyZXNzKHBhcmFtc1swXS5ncHIo KSwgSlNXZWJBc3NlbWJseUluc3RhbmNlOjpvZmZzZXRPZk1lbW9yeSgpKSwgYmFzZU1lbW9yeSk7 CisgICAgICAgICAgICBjb25zdCBhdXRvJiBzaXplUmVncyA9IHBpbm5lZFJlZ3MtPnNpemVSZWdp c3RlcnM7CisgICAgICAgICAgICBqaXQubG9hZFB0cihDQ2FsbEhlbHBlcnM6OkFkZHJlc3MoYmFz ZU1lbW9yeSwgSlNXZWJBc3NlbWJseU1lbW9yeTo6b2Zmc2V0T2ZTaXplKCkpLCBzaXplUmVnc1sw XS5zaXplUmVnaXN0ZXIpOworICAgICAgICAgICAgaml0LmxvYWRQdHIoQ0NhbGxIZWxwZXJzOjpB ZGRyZXNzKGJhc2VNZW1vcnksIEpTV2ViQXNzZW1ibHlNZW1vcnk6Om9mZnNldE9mTWVtb3J5KCkp LCBiYXNlTWVtb3J5KTsKKyAgICAgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDE7IGkgPCBzaXpl UmVncy5zaXplKCk7ICsraSkKKyAgICAgICAgICAgICAgICBqaXQuYWRkNjQoQ0NhbGxIZWxwZXJz OjpUcnVzdGVkSW1tMzIoLXNpemVSZWdzW2ldLnNpemVPZmZzZXQpLCBzaXplUmVnc1swXS5zaXpl UmVnaXN0ZXIsIHNpemVSZWdzWzFdLnNpemVSZWdpc3Rlcik7CisgICAgICAgIH0pOworICAgIH0K K30KKwogdm9pZCBCM0lSR2VuZXJhdG9yOjplbWl0RXhjZXB0aW9uQ2hlY2soQ0NhbGxIZWxwZXJz JiBqaXQsIEV4Y2VwdGlvblR5cGUgdHlwZSkKIHsKICAgICBqaXQubW92ZShDQ2FsbEhlbHBlcnM6 OlRydXN0ZWRJbW0zMihzdGF0aWNfY2FzdDx1aW50MzJfdD4odHlwZSkpLCBHUFJJbmZvOjphcmd1 bWVudEdQUjEpOwpAQCAtMzM4LDQ5ICszODUsNiBAQCBhdXRvIEIzSVJHZW5lcmF0b3I6OmFkZFVu cmVhY2hhYmxlKCkgLT4gUGFydGlhbFJlc3VsdAogICAgIHJldHVybiB7IH07CiB9CiAKLXN0YXRp YyB2b2lkIHJlbG9hZFBpbm5lZFJlZ2lzdGVycyhQcm9jZWR1cmUmIHByb2MsIEJhc2ljQmxvY2sq IGJsb2NrLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgVmFsdWUqIGluc3RhbmNlKQot ewotICAgIGlmICghaW5mby5oYXNNZW1vcnkoKSkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgY29u c3QgTWVtb3J5SW5mb3JtYXRpb24qIG1lbW9yeSA9ICZpbmZvLm1lbW9yeTsKLQotICAgIFJlZ2lz dGVyU2V0IGNsb2JiZXJzOwotICAgIGNsb2JiZXJzLnNldChtZW1vcnktPnBpbm5lZFJlZ2lzdGVy cygpLmJhc2VNZW1vcnlQb2ludGVyKTsKLSAgICBmb3IgKGF1dG8gaW5mbyA6IG1lbW9yeS0+cGlu bmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVycykKLSAgICAgICAgY2xvYmJlcnMuc2V0KGluZm8u c2l6ZVJlZ2lzdGVyKTsKLQotICAgIEIzOjpQYXRjaHBvaW50VmFsdWUqIHBhdGNocG9pbnQgPSBi bG9jay0+YXBwZW5kTmV3PEIzOjpQYXRjaHBvaW50VmFsdWU+KHByb2MsIEIzOjpWb2lkLCBPcmln aW4oKSk7Ci0gICAgcGF0Y2hwb2ludC0+ZWZmZWN0cyA9IEVmZmVjdHM6Om5vbmUoKTsKLSAgICBw YXRjaHBvaW50LT5lZmZlY3RzLndyaXRlc1Bpbm5lZCA9IHRydWU7Ci0gICAgcGF0Y2hwb2ludC0+ Y2xvYmJlcihjbG9iYmVycyk7Ci0gICAgcGF0Y2hwb2ludC0+bnVtR1BTY3JhdGNoUmVnaXN0ZXJz ID0gMTsKLQotICAgIHBhdGNocG9pbnQtPmFwcGVuZChpbnN0YW5jZSwgVmFsdWVSZXA6OlNvbWVS ZWdpc3Rlcik7Ci0KLSAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW21lbW9yeV0gKENDYWxs SGVscGVycyYgaml0LCBjb25zdCBCMzo6U3RhY2ttYXBHZW5lcmF0aW9uUGFyYW1zJiBwYXJhbXMp IHsKLSAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93U2NyYXRjaChq aXQpOwotCi0gICAgICAgIEdQUlJlZyBzY3JhdGNoID0gcGFyYW1zLmdwU2NyYXRjaCgwKTsKLSAg ICAgICAgaml0LmxvYWRQdHIoQ0NhbGxIZWxwZXJzOjpBZGRyZXNzKHBhcmFtc1swXS5ncHIoKSwg SlNXZWJBc3NlbWJseUluc3RhbmNlOjpvZmZzZXRPZk1lbW9yeSgpKSwgc2NyYXRjaCk7Ci0gICAg ICAgIGppdC5sb2FkUHRyKENDYWxsSGVscGVyczo6QWRkcmVzcyhzY3JhdGNoLCBKU1dlYkFzc2Vt Ymx5TWVtb3J5OjpvZmZzZXRPZk1lbW9yeSgpKSwgc2NyYXRjaCk7Ci0gICAgICAgIGppdC5sb2Fk UHRyKENDYWxsSGVscGVyczo6QWRkcmVzcyhzY3JhdGNoLCBNZW1vcnk6Om9mZnNldE9mTWVtb3J5 KCkpLCBtZW1vcnktPnBpbm5lZFJlZ2lzdGVycygpLmJhc2VNZW1vcnlQb2ludGVyKTsKLQotICAg ICAgICBqaXQubG9hZDY0KENDYWxsSGVscGVyczo6QWRkcmVzcyhzY3JhdGNoLCBNZW1vcnk6Om9m ZnNldE9mU2l6ZSgpKSwgc2NyYXRjaCk7Ci0gICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkg PCBtZW1vcnktPnBpbm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnMuc2l6ZSgpOyBpKyspIHsK LSAgICAgICAgICAgIEdQUlJlZyBzaXplUmVnID0gbWVtb3J5LT5waW5uZWRSZWdpc3RlcnMoKS5z aXplUmVnaXN0ZXJzW2ldLnNpemVSZWdpc3RlcjsKLSAgICAgICAgICAgIGppdC5tb3ZlKHNjcmF0 Y2gsIHNpemVSZWcpOwotICAgICAgICAgICAgaml0LnN1YjY0KENDYWxsSGVscGVyczo6VHJ1c3Rl ZEltbTMyKG1lbW9yeS0+cGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVyc1tpXS5zaXplT2Zm c2V0KSwgc2l6ZVJlZyk7Ci0gICAgICAgIH0KLSAgICB9KTsKLX0KLQotdm9pZCBCM0lSR2VuZXJh dG9yOjplbWl0UmVsb2FkUGlubmVkUmVnaXN0ZXJzKCkKLXsKLSAgICByZWxvYWRQaW5uZWRSZWdp c3RlcnMobV9wcm9jLCBtX2N1cnJlbnRCbG9jaywgbV9pbmZvLCBtX2luc3RhbmNlVmFsdWUpOwot fQotCi0KIGF1dG8gQjNJUkdlbmVyYXRvcjo6YWRkR3Jvd01lbW9yeShFeHByZXNzaW9uVHlwZSBk ZWx0YSwgRXhwcmVzc2lvblR5cGUmIHJlc3VsdCkgLT4gUGFydGlhbFJlc3VsdAogewogICAgIGlu dDMyX3QgKCpncm93TWVtb3J5KSAoRXhlY1N0YXRlKiwgaW50MzJfdCkgPSBbXSAoRXhlY1N0YXRl KiBleGVjLCBpbnQzMl90IGRlbHRhKSAtPiBpbnQzMl90IHsKQEAgLTM4OSw3ICszOTMsNiBAQCBh dXRvIEIzSVJHZW5lcmF0b3I6OmFkZEdyb3dNZW1vcnkoRXhwcmVzc2lvblR5cGUgZGVsdGEsIEV4 cHJlc3Npb25UeXBlJiByZXN1bHQpCiAKICAgICAgICAgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBp bnN0YW5jZSA9IHZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZTsKICAgICAgICAgSlNXZWJBc3Nl bWJseU1lbW9yeSogd2FzbU1lbW9yeSA9IGluc3RhbmNlLT5tZW1vcnkoKTsKLSAgICAgICAgUkVM RUFTRV9BU1NFUlQod2FzbU1lbW9yeSk7IC8vIFRoaXMgd291bGQgZmFpbCB2YWxpZGF0aW9uIG90 aGVyd2lzZS4KIAogICAgICAgICBpZiAoZGVsdGEgPCAwKQogICAgICAgICAgICAgcmV0dXJuIC0x OwpAQCAtNDA3LDIxICs0MTAsMTkgQEAgYXV0byBCM0lSR2VuZXJhdG9yOjphZGRHcm93TWVtb3J5 KEV4cHJlc3Npb25UeXBlIGRlbHRhLCBFeHByZXNzaW9uVHlwZSYgcmVzdWx0KQogICAgICAgICBt X2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KG1fcHJvYywgT3JpZ2luKCks IGJpdHdpc2VfY2FzdDx2b2lkKj4oZ3Jvd01lbW9yeSkpLAogICAgICAgICBtX2N1cnJlbnRCbG9j ay0+YXBwZW5kTmV3PEIzOjpWYWx1ZT4obV9wcm9jLCBCMzo6RnJhbWVQb2ludGVyLCBPcmlnaW4o KSksIGRlbHRhKTsKIAotICAgIGVtaXRSZWxvYWRQaW5uZWRSZWdpc3RlcnMoKTsKKyAgICByZXN0 b3JlV2ViQXNzZW1ibHlHbG9iYWxTdGF0ZShtX3ZtLCBtX2luZm8ubWVtb3J5LCBtX2luc3RhbmNl VmFsdWUsIG1fcHJvYywgbV9jdXJyZW50QmxvY2spOwogCiAgICAgcmV0dXJuIHsgfTsKIH0KIAog YXV0byBCM0lSR2VuZXJhdG9yOjphZGRDdXJyZW50TWVtb3J5KEV4cHJlc3Npb25UeXBlJiByZXN1 bHQpIC0+IFBhcnRpYWxSZXN1bHQKIHsKLSAgICBWYWx1ZSoganNNZW1vcnkgPSBtX2N1cnJlbnRC bG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQsIHBvaW50ZXJUeXBlKCks IE9yaWdpbigpLCBtX2luc3RhbmNlVmFsdWUsIEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0 T2ZNZW1vcnkoKSk7Ci0gICAgVmFsdWUqIHdhc21NZW1vcnkgPSBtX2N1cnJlbnRCbG9jay0+YXBw ZW5kTmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQsIHBvaW50ZXJUeXBlKCksIE9yaWdpbigp LCBqc01lbW9yeSwgSlNXZWJBc3NlbWJseU1lbW9yeTo6b2Zmc2V0T2ZNZW1vcnkoKSk7Ci0gICAg VmFsdWUqIHNpemUgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihtX3By b2MsIExvYWQsIEIzOjpJbnQ2NCwgT3JpZ2luKCksIHdhc21NZW1vcnksIE1lbW9yeTo6b2Zmc2V0 T2ZTaXplKCkpOworICAgIGF1dG8gbWVtb3J5VmFsdWUgPSBnZXRNZW1vcnlCYXNlQW5kU2l6ZSht X3ZtLCBtX2luc3RhbmNlVmFsdWUsIG1fcHJvYywgbV9jdXJyZW50QmxvY2spOwogCiAgICAgY29u c3RleHByIHVpbnQzMl90IHNoaWZ0VmFsdWUgPSAxNjsKICAgICBzdGF0aWNfYXNzZXJ0KFBhZ2VD b3VudDo6cGFnZVNpemUgPT0gMSA8PCBzaGlmdFZhbHVlLCAiVGhpcyBtdXN0IGhvbGQgZm9yIHRo ZSBjb2RlIGJlbG93IHRvIGJlIGNvcnJlY3QuIik7CiAgICAgVmFsdWUqIG51bVBhZ2VzID0gbV9j dXJyZW50QmxvY2stPmFwcGVuZE5ldzxWYWx1ZT4obV9wcm9jLCBaU2hyLCBPcmlnaW4oKSwKLSAg ICAgICAgc2l6ZSwgbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxDb25zdDMyVmFsdWU+KG1fcHJv YywgT3JpZ2luKCksIHNoaWZ0VmFsdWUpKTsKKyAgICAgICAgbWVtb3J5VmFsdWUuc2l6ZSwgbV9j dXJyZW50QmxvY2stPmFwcGVuZE5ldzxDb25zdDMyVmFsdWU+KG1fcHJvYywgT3JpZ2luKCksIHNo aWZ0VmFsdWUpKTsKIAogICAgIHJlc3VsdCA9IG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8VmFs dWU+KG1fcHJvYywgVHJ1bmMsIE9yaWdpbigpLCBudW1QYWdlcyk7CiAKQEAgLTgzMiwyNiArODMz LDc1IEBAIGF1dG8gQjNJUkdlbmVyYXRvcjo6YWRkQ2FsbCh1aW50MzJfdCBmdW5jdGlvbkluZGV4 LCBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSwKICAgICBBU1NFUlQoc2lnbmF0dXJlLT5hcmd1 bWVudENvdW50KCkgPT0gYXJncy5zaXplKCkpOwogCiAgICAgVHlwZSByZXR1cm5UeXBlID0gc2ln bmF0dXJlLT5yZXR1cm5UeXBlKCk7CisgICAgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+ KiB1bmxpbmtlZFdhc21Ub1dhc21DYWxscyA9ICZtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzOwog Ci0gICAgcmVzdWx0ID0gd2FzbUNhbGxpbmdDb252ZW50aW9uKCkuc2V0dXBDYWxsKG1fcHJvYywg bV9jdXJyZW50QmxvY2ssIE9yaWdpbigpLCBhcmdzLCB0b0IzVHlwZShyZXR1cm5UeXBlKSwKLSAg ICAgICAgWyZdIChQYXRjaHBvaW50VmFsdWUqIHBhdGNocG9pbnQpIHsKLSAgICAgICAgICAgIHBh dGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKLSAgICAgICAgICAgIHBhdGNo cG9pbnQtPmVmZmVjdHMucmVhZHNQaW5uZWQgPSB0cnVlOworICAgIGlmIChtX2luZm8uaXNJbXBv cnRlZEZ1bmN0aW9uRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KSkgeworICAg ICAgICAvLyBGSVhNRSBpbXBvcnRzIGNhbiBiZSBsaW5rZWQgaGVyZSwgaW5zdGVhZCBvZiBnZW5l cmF0aW5nIGEgcGF0Y2hwb2ludCwgYmVjYXVzZSBhbGwgaW1wb3J0IHN0dWJzIGFyZSBnZW5lcmF0 ZWQgYmVmb3JlIEIzIGNvbXBpbGF0aW9uIHN0YXJ0cy4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE2NjQ2MgorICAgICAgICBFeHByZXNzaW9uVHlwZSBmdW5jdGlvbklt cG9ydCA9IG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KG1fcHJvYywgTG9h ZCwgcG9pbnRlclR5cGUoKSwgT3JpZ2luKCksIG1faW5zdGFuY2VWYWx1ZSwgSlNXZWJBc3NlbWJs eUluc3RhbmNlOjpvZmZzZXRPZkltcG9ydEZ1bmN0aW9uKGZ1bmN0aW9uSW5kZXgpKTsKKyAgICAg ICAgRXhwcmVzc2lvblR5cGUganNUeXBlT2ZJbXBvcnQgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5k TmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQ4WiwgT3JpZ2luKCksIGZ1bmN0aW9uSW1wb3J0 LCBKU0NlbGw6OnR5cGVJbmZvVHlwZU9mZnNldCgpKTsKKyAgICAgICAgVmFsdWUqIGlzV2FzbUNh bGwgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PFZhbHVlPihtX3Byb2MsIEVxdWFsLCBPcmln aW4oKSwganNUeXBlT2ZJbXBvcnQsIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8Q29uc3QzMlZh bHVlPihtX3Byb2MsIE9yaWdpbigpLCBXZWJBc3NlbWJseUZ1bmN0aW9uVHlwZSkpOwogCi0gICAg ICAgICAgICBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4qIHVubGlua2VkV2FzbVRvV2Fz bUNhbGxzID0gJm1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHM7Ci0gICAgICAgICAgICBwYXRjaHBv aW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4 XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMm KSB7Ci0gICAgICAgICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93 U2NyYXRjaChqaXQpOworICAgICAgICBCYXNpY0Jsb2NrKiBpc1dhc21CbG9jayA9IG1fcHJvYy5h ZGRCbG9jaygpOworICAgICAgICBCYXNpY0Jsb2NrKiBpc0pTQmxvY2sgPSBtX3Byb2MuYWRkQmxv Y2soKTsKKyAgICAgICAgQmFzaWNCbG9jayogY29udGludWF0aW9uID0gbV9wcm9jLmFkZEJsb2Nr KCk7CisgICAgICAgIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXdDb250cm9sVmFsdWUobV9wcm9j LCBCMzo6QnJhbmNoLCBPcmlnaW4oKSwgaXNXYXNtQ2FsbCwgRnJlcXVlbnRlZEJsb2NrKGlzV2Fz bUJsb2NrKSwgRnJlcXVlbnRlZEJsb2NrKGlzSlNCbG9jaykpOworCisgICAgICAgIFZhbHVlKiB3 YXNtQ2FsbFJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigpLnNldHVwQ2FsbChtX3Byb2Ms IGlzV2FzbUJsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0dXJuVHlwZSksCisgICAg ICAgICAgICBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkgeworICAgICAgICAgICAg ICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAg ICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAg ICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBm dW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVy YXRpb25QYXJhbXMmKSB7CisgICAgICAgICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVn aXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAgICAgICAgICAgICAgQ0NhbGxI ZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICAgICAgICAgICAgICBqaXQu YWRkTGlua1Rhc2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4 XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZlcikgeworICAgICAgICAgICAgICAgICAgICAgICAgdW5s aW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZmZXIubG9jYXRpb25PZihjYWxs KSwgZnVuY3Rpb25JbmRleCwgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbDo6VGFyZ2V0Ojp0b1dhc20g fSk7CisgICAgICAgICAgICAgICAgICAgIH0pOworICAgICAgICAgICAgICAgIH0pOworICAgICAg ICAgICAgfSk7CisgICAgICAgIFVwc2lsb25WYWx1ZSogd2FzbUNhbGxSZXN1bHRVcHNpbG9uID0g cmV0dXJuVHlwZSA9PSBWb2lkID8gbnVsbHB0ciA6IGlzV2FzbUJsb2NrLT5hcHBlbmROZXc8VXBz aWxvblZhbHVlPihtX3Byb2MsIE9yaWdpbigpLCB3YXNtQ2FsbFJlc3VsdCk7CisgICAgICAgIGlz V2FzbUJsb2NrLT5hcHBlbmROZXdDb250cm9sVmFsdWUobV9wcm9jLCBKdW1wLCBPcmlnaW4oKSwg Y29udGludWF0aW9uKTsKKworICAgICAgICBWYWx1ZSoganNDYWxsUmVzdWx0ID0gd2FzbUNhbGxp bmdDb252ZW50aW9uKCkuc2V0dXBDYWxsKG1fcHJvYywgaXNKU0Jsb2NrLCBPcmlnaW4oKSwgYXJn cywgdG9CM1R5cGUocmV0dXJuVHlwZSksCisgICAgICAgICAgICBbJl0gKFBhdGNocG9pbnRWYWx1 ZSogcGF0Y2hwb2ludCkgeworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3Jp dGVzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJl YWRzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0 b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJz JiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7CisgICAgICAgICAg ICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0 KTsKKyAgICAgICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2Fs bCgpOworICAgICAgICAgICAgICAgICAgICBqaXQuYWRkTGlua1Rhc2soW3VubGlua2VkV2FzbVRv V2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZlcikg eworICAgICAgICAgICAgICAgICAgICAgICAgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVu ZCh7IGxpbmtCdWZmZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rpb25JbmRleCwgVW5saW5rZWRX YXNtVG9XYXNtQ2FsbDo6VGFyZ2V0Ojp0b0pTIH0pOworICAgICAgICAgICAgICAgICAgICB9KTsK KyAgICAgICAgICAgICAgICB9KTsKKyAgICAgICAgICAgIH0pOworICAgICAgICBVcHNpbG9uVmFs dWUqIGpzQ2FsbFJlc3VsdFVwc2lsb24gPSByZXR1cm5UeXBlID09IFZvaWQgPyBudWxscHRyIDog aXNKU0Jsb2NrLT5hcHBlbmROZXc8VXBzaWxvblZhbHVlPihtX3Byb2MsIE9yaWdpbigpLCBqc0Nh bGxSZXN1bHQpOworICAgICAgICBpc0pTQmxvY2stPmFwcGVuZE5ld0NvbnRyb2xWYWx1ZShtX3By b2MsIEp1bXAsIE9yaWdpbigpLCBjb250aW51YXRpb24pOworCisgICAgICAgIG1fY3VycmVudEJs b2NrID0gY29udGludWF0aW9uOwogCi0gICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxs IGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICBpZiAocmV0dXJuVHlwZSA9PSBWb2lkKQorICAg ICAgICAgICAgcmVzdWx0ID0gbnVsbHB0cjsKKyAgICAgICAgZWxzZSB7CisgICAgICAgICAgICBy ZXN1bHQgPSBjb250aW51YXRpb24tPmFwcGVuZE5ldzxWYWx1ZT4obV9wcm9jLCBQaGksIHRvQjNU eXBlKHJldHVyblR5cGUpLCBPcmlnaW4oKSk7CisgICAgICAgICAgICB3YXNtQ2FsbFJlc3VsdFVw c2lsb24tPnNldFBoaShyZXN1bHQpOworICAgICAgICAgICAganNDYWxsUmVzdWx0VXBzaWxvbi0+ c2V0UGhpKHJlc3VsdCk7CisgICAgICAgIH0KIAotICAgICAgICAgICAgICAgIGppdC5hZGRMaW5r VGFzayhbdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGNhbGwsIGZ1bmN0aW9uSW5kZXhdIChMaW5r QnVmZmVyJiBsaW5rQnVmZmVyKSB7Ci0gICAgICAgICAgICAgICAgICAgIHVubGlua2VkV2FzbVRv V2FzbUNhbGxzLT5hcHBlbmQoeyBsaW5rQnVmZmVyLmxvY2F0aW9uT2YoY2FsbCksIGZ1bmN0aW9u SW5kZXggfSk7CisgICAgICAgIC8vIFRoZSBjYWxsIGNvdWxkIGhhdmUgYmVlbiB0byBhbm90aGVy IFdlYkFzc2VtYmx5IGluc3RhbmNlLCBhbmQgLyBvciBjb3VsZCBoYXZlIG1vZGlmaWVkIG91ciBN ZW1vcnkuCisgICAgICAgIHJlc3RvcmVXZWJBc3NlbWJseUdsb2JhbFN0YXRlKG1fdm0sIG1faW5m by5tZW1vcnksIG1faW5zdGFuY2VWYWx1ZSwgbV9wcm9jLCBjb250aW51YXRpb24pOworICAgIH0g ZWxzZSB7CisgICAgICAgIHJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigpLnNldHVwQ2Fs bChtX3Byb2MsIG1fY3VycmVudEJsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0dXJu VHlwZSksCisgICAgICAgICAgICBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkgewor ICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsK KyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsK KyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRv V2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpT dGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7CisgICAgICAgICAgICAgICAgICAgIEFsbG93TWFj cm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAgICAgICAg ICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICAgICAg ICAgICAgICBqaXQuYWRkTGlua1Rhc2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjYWxsLCBm dW5jdGlvbkluZGV4XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZlcikgeworICAgICAgICAgICAgICAg ICAgICAgICAgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZmZXIubG9j YXRpb25PZihjYWxsKSwgZnVuY3Rpb25JbmRleCwgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbDo6VGFy Z2V0Ojp0b1dhc20gfSk7CisgICAgICAgICAgICAgICAgICAgIH0pOwogICAgICAgICAgICAgICAg IH0pOwogICAgICAgICAgICAgfSk7Ci0gICAgICAgIH0pOwotCi0gICAgaWYgKGZ1bmN0aW9uSW5k ZXggPCBtX2luZm8uaW1wb3J0RnVuY3Rpb25Db3VudCgpKQotICAgICAgICBlbWl0UmVsb2FkUGlu bmVkUmVnaXN0ZXJzKCk7CisgICAgfQogCiAgICAgcmV0dXJuIHsgfTsKIH0KQEAgLTkyOSw3ICs5 NzksOCBAQCBhdXRvIEIzSVJHZW5lcmF0b3I6OmFkZENhbGxJbmRpcmVjdChjb25zdCBTaWduYXR1 cmUqIHNpZ25hdHVyZSwgU2lnbmF0dXJlSW5kZXggcwogICAgICAgICAgICAgfSk7CiAgICAgICAg IH0pOwogCi0gICAgZW1pdFJlbG9hZFBpbm5lZFJlZ2lzdGVycygpOworICAgIC8vIFRoZSBjYWxs IGNvdWxkIGhhdmUgYmVlbiB0byBhbm90aGVyIFdlYkFzc2VtYmx5IGluc3RhbmNlLCBhbmQgLyBv ciBjb3VsZCBoYXZlIG1vZGlmaWVkIG91ciBNZW1vcnkuCisgICAgcmVzdG9yZVdlYkFzc2VtYmx5 R2xvYmFsU3RhdGUobV92bSwgbV9pbmZvLm1lbW9yeSwgbV9pbnN0YW5jZVZhbHVlLCBtX3Byb2Ms IG1fY3VycmVudEJsb2NrKTsKIAogICAgIHJldHVybiB7IH07CiB9CkBAIC05OTgsMTIgKzEwNDks MTAgQEAgc3RhdGljIHZvaWQgY3JlYXRlSlNUb1dhc21XcmFwcGVyKFZNJiB2bSwgQ29tcGlsYXRp b25Db250ZXh0JiBjb21waWxhdGlvbkNvbnRleHQKICAgICAgICAgfSk7CiAgICAgfQogCi0gICAg Ly8gTW92ZSBtZW1vcnkgdmFsdWVzIHRvIHRoZSBhcHByb3JpYXRlIHBsYWNlcywgaWYgbmVlZGVk LgotICAgIHsKLSAgICAgICAgVmFsdWUqIGluc3RhbmNlID0gYmxvY2stPmFwcGVuZE5ldzxNZW1v cnlWYWx1ZT4ocHJvYywgTG9hZCwgcG9pbnRlclR5cGUoKSwgT3JpZ2luKCksCi0gICAgICAgICAg ICBibG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KHByb2MsIE9yaWdpbigpLCAmdm0udG9w SlNXZWJBc3NlbWJseUluc3RhbmNlKSk7Ci0gICAgICAgIHJlbG9hZFBpbm5lZFJlZ2lzdGVycyhw cm9jLCBibG9jaywgaW5mbywgaW5zdGFuY2UpOwotICAgIH0KKyAgICAvLyBGSVhNRSBUaGUgaW5z dGFuY2UgaXMgY3VycmVudGx5IHNldCBieSB0aGUgQysrIGNvZGUgaW4gV2ViQXNzZW1ibHlGdW5j dGlvbjo6Y2FsbC4gV2Ugc2hvdWxkbid0IGdvIHRocm91Z2ggdGhlIGV4dHJhIEMrKyBob29wLiBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY2NDg2CisgICAgVmFsdWUq IGluc3RhbmNlID0gYmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4ocHJvYywgTG9hZCwgcG9p bnRlclR5cGUoKSwgT3JpZ2luKCksCisgICAgICAgIGJsb2NrLT5hcHBlbmROZXc8Q29uc3RQdHJW YWx1ZT4ocHJvYywgT3JpZ2luKCksICZ2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UpKTsKKyAg ICByZXN0b3JlV2ViQXNzZW1ibHlHbG9iYWxTdGF0ZSh2bSwgaW5mby5tZW1vcnksIGluc3RhbmNl LCBwcm9jLCBibG9jayk7CiAKICAgICAvLyBHZXQgb3VyIGFyZ3VtZW50cy4KICAgICBWZWN0b3I8 VmFsdWUqPiBhcmd1bWVudHM7CkBAIC0xMDQ2LDcgKzEwOTUsNyBAQCBzdGF0aWMgdm9pZCBjcmVh dGVKU1RvV2FzbVdyYXBwZXIoVk0mIHZtLCBDb21waWxhdGlvbkNvbnRleHQmIGNvbXBpbGF0aW9u Q29udGV4dAogICAgIGZ1bmN0aW9uLmpzVG9XYXNtRW50cnlwb2ludC5jYWxsZWVTYXZlUmVnaXN0 ZXJzID0gcHJvYy5jYWxsZWVTYXZlUmVnaXN0ZXJzKCk7CiB9CiAKLUV4cGVjdGVkPHN0ZDo6dW5p cXVlX3B0cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0cmluZz4gcGFyc2VBbmRDb21waWxlKFZN JiB2bSwgQ29tcGlsYXRpb25Db250ZXh0JiBjb21waWxhdGlvbkNvbnRleHQsIGNvbnN0IHVpbnQ4 X3QqIGZ1bmN0aW9uU3RhcnQsIHNpemVfdCBmdW5jdGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0dXJl KiBzaWduYXR1cmUsIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYgdW5saW5rZWRXYXNt VG9XYXNtQ2FsbHMsIGNvbnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYgZnVuY3Rpb25J bmRleFNwYWNlLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgdW5zaWduZWQgb3B0TGV2 ZWwpCitFeHBlY3RlZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbUludGVybmFsRnVuY3Rpb24+LCBTdHJp bmc+IHBhcnNlQW5kQ29tcGlsZShWTSYgdm0sIENvbXBpbGF0aW9uQ29udGV4dCYgY29tcGlsYXRp b25Db250ZXh0LCBjb25zdCB1aW50OF90KiBmdW5jdGlvblN0YXJ0LCBzaXplX3QgZnVuY3Rpb25M ZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9X YXNtQ2FsbD4mIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlv biYgaW5mbywgY29uc3QgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiYgbW9kdWxlU2lnbmF0dXJlSW5k aWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMsIHVuc2lnbmVkIG9wdExldmVsKQogewogICAg IGF1dG8gcmVzdWx0ID0gc3RkOjptYWtlX3VuaXF1ZTxXYXNtSW50ZXJuYWxGdW5jdGlvbj4oKTsK IApAQCAtMTA1NCw4ICsxMTAzLDggQEAgRXhwZWN0ZWQ8c3RkOjp1bmlxdWVfcHRyPFdhc21JbnRl cm5hbEZ1bmN0aW9uPiwgU3RyaW5nPiBwYXJzZUFuZENvbXBpbGUoVk0mIHZtLAogICAgIGNvbXBp bGF0aW9uQ29udGV4dC53YXNtRW50cnlwb2ludEpJVCA9IHN0ZDo6bWFrZV91bmlxdWU8Q0NhbGxI ZWxwZXJzPigmdm0pOwogCiAgICAgUHJvY2VkdXJlIHByb2NlZHVyZTsKLSAgICBCM0lSR2VuZXJh dG9yIGNvbnRleHQodm0sIGluZm8sIHByb2NlZHVyZSwgcmVzdWx0LmdldCgpLCB1bmxpbmtlZFdh c21Ub1dhc21DYWxscywgZnVuY3Rpb25JbmRleFNwYWNlKTsKLSAgICBGdW5jdGlvblBhcnNlcjxC M0lSR2VuZXJhdG9yPiBwYXJzZXIoJnZtLCBjb250ZXh0LCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlv bkxlbmd0aCwgc2lnbmF0dXJlLCBmdW5jdGlvbkluZGV4U3BhY2UsIGluZm8pOworICAgIEIzSVJH ZW5lcmF0b3IgY29udGV4dCh2bSwgaW5mbywgcHJvY2VkdXJlLCByZXN1bHQuZ2V0KCksIHVubGlu a2VkV2FzbVRvV2FzbUNhbGxzKTsKKyAgICBGdW5jdGlvblBhcnNlcjxCM0lSR2VuZXJhdG9yPiBw YXJzZXIoJnZtLCBjb250ZXh0LCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0 dXJlLCBpbmZvLCBtb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNl cyk7CiAgICAgV0FTTV9GQUlMX0lGX0hFTFBFUl9GQUlMUyhwYXJzZXIucGFyc2UoKSk7CiAKICAg ICBwcm9jZWR1cmUucmVzZXRSZWFjaGFiaWxpdHkoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5oCmluZGV4IGI1YzlmNDYuLjI0OWQ1NzggMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmgKKysr IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuaApAQCAtNDcs NyArNDcsNyBAQCBzdHJ1Y3QgQ29tcGlsYXRpb25Db250ZXh0IHsKICAgICBDQ2FsbEhlbHBlcnM6 OkNhbGwganNFbnRyeXBvaW50VG9XYXNtRW50cnlwb2ludENhbGw7CiB9OwogCi1FeHBlY3RlZDxz dGQ6OnVuaXF1ZV9wdHI8V2FzbUludGVybmFsRnVuY3Rpb24+LCBTdHJpbmc+IHBhcnNlQW5kQ29t cGlsZShWTSYsIENvbXBpbGF0aW9uQ29udGV4dCYsIGNvbnN0IHVpbnQ4X3QqLCBzaXplX3QsIGNv bnN0IFNpZ25hdHVyZSosIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYsIGNvbnN0IElt bXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiwgdW5z aWduZWQgb3B0TGV2ZWwgPSAxKTsKK0V4cGVjdGVkPHN0ZDo6dW5pcXVlX3B0cjxXYXNtSW50ZXJu YWxGdW5jdGlvbj4sIFN0cmluZz4gcGFyc2VBbmRDb21waWxlKFZNJiwgQ29tcGlsYXRpb25Db250 ZXh0JiwgY29uc3QgdWludDhfdCosIHNpemVfdCwgY29uc3QgU2lnbmF0dXJlKiwgVmVjdG9yPFVu bGlua2VkV2FzbVRvV2FzbUNhbGw+JiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mLCBjb25zdCBW ZWN0b3I8U2lnbmF0dXJlSW5kZXg+JiwgdW5zaWduZWQgb3B0TGV2ZWwgPSAxKTsKIAogfSB9IC8v IG5hbWVzcGFjZSBKU0M6Oldhc20KIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbUJpbmRpbmcuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJp bmRpbmcuY3BwCmluZGV4IDBlNTkyNDcuLjliYjZhNzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtQmluZGluZy5jcHAKQEAgLTM2LDEzICszNiwyMSBAQAogCiBuYW1lc3BhY2Ug SlNDIHsgbmFtZXNwYWNlIFdhc20gewogCi1XYXNtVG9KU1N0dWIgaW1wb3J0U3R1YkdlbmVyYXRv cihWTSogdm0sIEJhZzxDYWxsTGlua0luZm8+JiBjYWxsTGlua0luZm9zLCBTaWduYXR1cmVJbmRl eCBzaWduYXR1cmVJbmRleCwgdW5zaWduZWQgaW1wb3J0SW5kZXgpCit0eXBlZGVmIEFzc2VtYmx5 SGVscGVycyBKSVQ7CisKK3N0YXRpYyB2b2lkIG1hdGVyaWFsaXplSW1wb3J0SlNDZWxsKFZNKiB2 bSwgSklUJiBqaXQsIHVuc2lnbmVkIGltcG9ydEluZGV4LCBHUFJSZWcgZ3ByKQoreworICAgIC8v IEVhY2ggSlMgLT4gd2FzbSBlbnRyeSBzZXRzIHRoZSBXZWJBc3NlbWJseS5JbnN0YW5jZSB3aG9z ZSBleHBvcnQgaXMgYmVpbmcgY2FsbGVkLiBXZSdyZSBjYWxsaW5nIG91dCBvZiB0aGlzIEluc3Rh bmNlLCBhbmQgY2FuIHRoZXJlZm9yZSBmaWd1cmUgb3V0IHRoZSBpbXBvcnQgYmVpbmcgY2FsbGVk LgorICAgIGppdC5sb2FkUHRyKCZ2bS0+dG9wSlNXZWJBc3NlbWJseUluc3RhbmNlLCBncHIpOwor ICAgIGppdC5sb2FkUHRyKEpJVDo6QWRkcmVzcyhncHIsIEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6 b2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbihpbXBvcnRJbmRleCkpLCBncHIpOworfQorCitzdGF0aWMg TWFjcm9Bc3NlbWJsZXJDb2RlUmVmIHdhc21Ub0pTKFZNKiB2bSwgQmFnPENhbGxMaW5rSW5mbz4m IGNhbGxMaW5rSW5mb3MsIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4LCB1bnNpZ25lZCBp bXBvcnRJbmRleCkKIHsKICAgICBjb25zdCBXYXNtQ2FsbGluZ0NvbnZlbnRpb24mIHdhc21DQyA9 IHdhc21DYWxsaW5nQ29udmVudGlvbigpOwogICAgIGNvbnN0IEpTQ0NhbGxpbmdDb252ZW50aW9u JiBqc0NDID0ganNjQ2FsbGluZ0NvbnZlbnRpb24oKTsKICAgICBjb25zdCBTaWduYXR1cmUqIHNp Z25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQodm0sIHNpZ25hdHVyZUluZGV4KTsK ICAgICB1bnNpZ25lZCBhcmdDb3VudCA9IHNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpOwotICAg IHR5cGVkZWYgQXNzZW1ibHlIZWxwZXJzIEpJVDsKICAgICBKSVQgaml0KHZtLCBudWxscHRyKTsK IAogICAgIC8vIEJlbG93LCB3ZSBhc3N1bWUgdGhhdCB0aGUgSlMgY2FsbGluZyBjb252ZW50aW9u IGlzIGFsd2F5cyBvbiB0aGUgc3RhY2suCkBAIC0xMzgsOSArMTQ2LDcgQEAgV2FzbVRvSlNTdHVi IGltcG9ydFN0dWJHZW5lcmF0b3IoVk0qIHZtLCBCYWc8Q2FsbExpbmtJbmZvPiYgY2FsbExpbmtJ bmZvcywgU2lnbmEKICAgICBHUFJSZWcgaW1wb3J0SlNDZWxsR1BSUmVnID0gR1BSSW5mbzo6cmVn VDA7IC8vIENhbGxlZSBuZWVkcyB0byBiZSBpbiByZWdUMCBmb3Igc2xvdyBwYXRoIGJlbG93Lgog ICAgIEFTU0VSVCghd2FzbUNDLm1fY2FsbGVlU2F2ZVJlZ2lzdGVycy5nZXQoaW1wb3J0SlNDZWxs R1BSUmVnKSk7CiAKLSAgICAvLyBFYWNoIEpTIC0+IHdhc20gZW50cnkgc2V0cyB0aGUgV2ViQXNz ZW1ibHkuSW5zdGFuY2Ugd2hvc2UgZXhwb3J0IGlzIGJlaW5nIGNhbGxlZC4gV2UncmUgY2FsbGlu ZyBvdXQgb2YgdGhpcyBJbnN0YW5jZSwgYW5kIGNhbiB0aGVyZWZvcmUgZmlndXJlIG91dCB0aGUg aW1wb3J0IGJlaW5nIGNhbGxlZC4KLSAgICBqaXQubG9hZFB0cigmdm0tPnRvcEpTV2ViQXNzZW1i bHlJbnN0YW5jZSwgaW1wb3J0SlNDZWxsR1BSUmVnKTsKLSAgICBqaXQubG9hZFB0cihKSVQ6OkFk ZHJlc3MoaW1wb3J0SlNDZWxsR1BSUmVnLCBKU1dlYkFzc2VtYmx5SW5zdGFuY2U6Om9mZnNldE9m SW1wb3J0RnVuY3Rpb24oaW1wb3J0SW5kZXgpKSwgaW1wb3J0SlNDZWxsR1BSUmVnKTsKKyAgICBt YXRlcmlhbGl6ZUltcG9ydEpTQ2VsbCh2bSwgaml0LCBpbXBvcnRJbmRleCwgaW1wb3J0SlNDZWxs R1BSUmVnKTsKIAogICAgIHVpbnQ2NF90IHRoaXNBcmd1bWVudCA9IFZhbHVlVW5kZWZpbmVkOyAv LyBGSVhNRSB3aGF0IGRvZXMgdGhlIFdlYkFzc2VtYmx5IHNwZWMgc2F5IHRoaXMgc2hvdWxkIGJl PyBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1NDcxCiAgICAgaml0 LnN0b3JlNjQoaW1wb3J0SlNDZWxsR1BSUmVnLCBjYWxsZWVGcmFtZS53aXRoT2Zmc2V0KENhbGxG cmFtZVNsb3Q6OmNhbGxlZSAqIHN0YXRpY19jYXN0PGludD4oc2l6ZW9mKFJlZ2lzdGVyKSkpKTsK QEAgLTIzMSw3ICsyMzcsNTYgQEAgV2FzbVRvSlNTdHViIGltcG9ydFN0dWJHZW5lcmF0b3IoVk0q IHZtLCBCYWc8Q2FsbExpbmtJbmZvPiYgY2FsbExpbmtJbmZvcywgU2lnbmEKICAgICBDb2RlTG9j YXRpb25MYWJlbCBob3RQYXRoQmVnaW4ocGF0Y2hCdWZmZXIubG9jYXRpb25PZih0YXJnZXRUb0No ZWNrKSk7CiAgICAgQ29kZUxvY2F0aW9uTmVhckNhbGwgaG90UGF0aE90aGVyID0gcGF0Y2hCdWZm ZXIubG9jYXRpb25PZk5lYXJDYWxsKGZhc3RDYWxsKTsKICAgICBjYWxsTGlua0luZm8tPnNldENh bGxMb2NhdGlvbnMoY2FsbFJldHVybkxvY2F0aW9uLCBob3RQYXRoQmVnaW4sIGhvdFBhdGhPdGhl cik7Ci0gICAgcmV0dXJuIEZJTkFMSVpFX0NPREUocGF0Y2hCdWZmZXIsICgiV2ViQXNzZW1ibHkg aW1wb3J0WyVpXSBzdHViIGZvciBzaWduYXR1cmUgJWkiLCBpbXBvcnRJbmRleCwgc2lnbmF0dXJl SW5kZXgpKTsKKyAgICBTdHJpbmcgc2lnbmF0dXJlRGVzY3JpcHRpb24gPSBTaWduYXR1cmVJbmZv cm1hdGlvbjo6Z2V0KHZtLCBzaWduYXR1cmVJbmRleCktPnRvU3RyaW5nKCk7CisgICAgcmV0dXJu IEZJTkFMSVpFX0NPREUocGF0Y2hCdWZmZXIsICgiV2ViQXNzZW1ibHktPkphdmFTY3JpcHQgaW1w b3J0WyVpXSAlcyIsIGltcG9ydEluZGV4LCBzaWduYXR1cmVEZXNjcmlwdGlvbi5hc2NpaSgpLmRh dGEoKSkpOworfQorCitzdGF0aWMgTWFjcm9Bc3NlbWJsZXJDb2RlUmVmIHdhc21Ub1dhc20oVk0q IHZtLCB1bnNpZ25lZCBpbXBvcnRJbmRleCkKK3sKKyAgICBjb25zdCBQaW5uZWRSZWdpc3Rlcklu Zm8mIHBpbm5lZFJlZ3MgPSBQaW5uZWRSZWdpc3RlckluZm86OmdldCgpOworICAgIEpJVCBqaXQo dm0sIG51bGxwdHIpOworCisgICAgR1BSUmVnIHNjcmF0Y2ggPSBHUFJJbmZvOjpub25QcmVzZXJ2 ZWROb25Bcmd1bWVudEdQUjsKKworICAgIC8vIEIzJ3MgY2FsbCBjb2RlZ2VuIGVuc3VyZXMgdGhh dCB0aGUgSlNDZWxsIGlzIGEgV2ViQXNzZW1ibHlGdW5jdGlvbi4KKyAgICBtYXRlcmlhbGl6ZUlt cG9ydEpTQ2VsbCh2bSwgaml0LCBpbXBvcnRJbmRleCwgc2NyYXRjaCk7CisKKyAgICAvLyBHZXQg dGhlIGNhbGxlZSdzIFdlYkFzc2VtYmx5Lkluc3RhbmNlIGFuZCBzZXQgaXQgYXMgdm0udG9wSlNX ZWJBc3NlbWJseUluc3RhbmNlLiBUaGUgY2FsbGVyIHdpbGwgdGFrZSBjYXJlIG9mIHJlc3Rvcmlu ZyBpdHMgb3duIEluc3RhbmNlLgorICAgIEdQUlJlZyBiYXNlTWVtb3J5ID0gcGlubmVkUmVncy5i YXNlTWVtb3J5UG9pbnRlcjsKKyAgICBBU1NFUlQoYmFzZU1lbW9yeSAhPSBzY3JhdGNoKTsKKyAg ICBqaXQubG9hZFB0cihKSVQ6OkFkZHJlc3Moc2NyYXRjaCwgV2ViQXNzZW1ibHlGdW5jdGlvbjo6 b2Zmc2V0T2ZJbnN0YW5jZSgpKSwgYmFzZU1lbW9yeSk7IC8vIEluc3RhbmNlKi4KKyAgICBqaXQu c3RvcmVQdHIoYmFzZU1lbW9yeSwgJnZtLT50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UpOworCisg ICAgLy8gRklYTUUgdGhlIGZvbGxvd2luZyBjb2RlIGFzc3VtZXMgdGhhdCBhbGwgV2ViQXNzZW1i bHkuSW5zdGFuY2UgaGF2ZSB0aGUgc2FtZSBwaW5uZWQgcmVnaXN0ZXJzLiBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYyOTUyCisgICAgLy8gU2V0IHVwIHRoZSBjYWxs ZWUncyBiYXNlTWVtb3J5IHJlZ2lzdGVyIGFzIHdlbGwgYXMgdGhlIG1lbW9yeSBzaXplIHJlZ2lz dGVycy4KKyAgICBqaXQubG9hZFB0cihKSVQ6OkFkZHJlc3MoYmFzZU1lbW9yeSwgSlNXZWJBc3Nl bWJseUluc3RhbmNlOjpvZmZzZXRPZk1lbW9yeSgpKSwgYmFzZU1lbW9yeSk7IC8vIEpTV2ViQXNz ZW1ibHlNZW1vcnkqLgorICAgIGNvbnN0IGF1dG8mIHNpemVSZWdzID0gcGlubmVkUmVncy5zaXpl UmVnaXN0ZXJzOworICAgIEFTU0VSVChzaXplUmVncy5zaXplKCkgPj0gMSk7CisgICAgQVNTRVJU KHNpemVSZWdzWzBdLnNpemVSZWdpc3RlciAhPSBiYXNlTWVtb3J5KTsKKyAgICBBU1NFUlQoc2l6 ZVJlZ3NbMF0uc2l6ZVJlZ2lzdGVyICE9IHNjcmF0Y2gpOworICAgIEFTU0VSVCghc2l6ZVJlZ3Nb MF0uc2l6ZU9mZnNldCk7IC8vIFRoZSBmb2xsb3dpbmcgY29kZSBhc3N1bWVzIHdlIHN0YXJ0IGF0 IDAsIGFuZCBjYWxjdWxhdGVzIHN1YnNlcXVlbnQgc2l6ZSByZWdpc3RlcnMgcmVsYXRpdmUgdG8g MC4KKyAgICBqaXQubG9hZFB0cihKSVQ6OkFkZHJlc3MoYmFzZU1lbW9yeSwgSlNXZWJBc3NlbWJs eU1lbW9yeTo6b2Zmc2V0T2ZTaXplKCkpLCBzaXplUmVnc1swXS5zaXplUmVnaXN0ZXIpOyAvLyBN ZW1vcnkgc2l6ZS4KKyAgICBqaXQubG9hZFB0cihKSVQ6OkFkZHJlc3MoYmFzZU1lbW9yeSwgSlNX ZWJBc3NlbWJseU1lbW9yeTo6b2Zmc2V0T2ZNZW1vcnkoKSksIGJhc2VNZW1vcnkpOyAvLyBXYXNt TWVtb3J5Ojp2b2lkKi4KKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAxOyBpIDwgc2l6ZVJlZ3Muc2l6 ZSgpOyArK2kpIHsKKyAgICAgICAgQVNTRVJUKHNpemVSZWdzW2ldLnNpemVSZWdpc3RlciAhPSBi YXNlTWVtb3J5KTsKKyAgICAgICAgQVNTRVJUKHNpemVSZWdzW2ldLnNpemVSZWdpc3RlciAhPSBz Y3JhdGNoKTsKKyAgICAgICAgaml0LmFkZDY0KEpJVDo6VHJ1c3RlZEltbTMyKC1zaXplUmVnc1tp XS5zaXplT2Zmc2V0KSwgc2l6ZVJlZ3NbMF0uc2l6ZVJlZ2lzdGVyLCBzaXplUmVnc1sxXS5zaXpl UmVnaXN0ZXIpOworICAgIH0KKworICAgIC8vIFRhaWwgY2FsbCBpbnRvIHRoZSBjYWxsZWUgV2Vi QXNzZW1ibHkgZnVuY3Rpb24uCisgICAgaml0LmxvYWRQdHIoSklUOjpBZGRyZXNzKHNjcmF0Y2gs IFdlYkFzc2VtYmx5RnVuY3Rpb246Om9mZnNldE9mV2FzbUVudHJ5UG9pbnRDb2RlKCkpLCBzY3Jh dGNoKTsKKyAgICBqaXQuanVtcChzY3JhdGNoKTsKKworICAgIExpbmtCdWZmZXIgcGF0Y2hCdWZm ZXIoKnZtLCBqaXQsIEdMT0JBTF9USFVOS19JRCk7CisgICAgcmV0dXJuIEZJTkFMSVpFX0NPREUo cGF0Y2hCdWZmZXIsICgiV2ViQXNzZW1ibHktPldlYkFzc2VtYmx5IGltcG9ydFslaV0iLCBpbXBv cnRJbmRleCkpOworfQorCitXYXNtRXhpdFN0dWJzIGV4aXRTdHViR2VuZXJhdG9yKFZNKiB2bSwg QmFnPENhbGxMaW5rSW5mbz4mIGNhbGxMaW5rSW5mb3MsIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVy ZUluZGV4LCB1bnNpZ25lZCBpbXBvcnRJbmRleCkKK3sKKyAgICBXYXNtRXhpdFN0dWJzIHN0dWJz OworICAgIHN0dWJzLndhc21Ub0pTID0gd2FzbVRvSlModm0sIGNhbGxMaW5rSW5mb3MsIHNpZ25h dHVyZUluZGV4LCBpbXBvcnRJbmRleCk7CisgICAgc3R1YnMud2FzbVRvV2FzbSA9IHdhc21Ub1dh c20odm0sIGltcG9ydEluZGV4KTsKKyAgICByZXR1cm4gc3R1YnM7CiB9CiAKIH0gfSAvLyBuYW1l c3BhY2UgSlNDOjpXYXNtCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9X YXNtQmluZGluZy5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuaApp bmRleCBmZDdlMDNkLi40MDIxZjE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9XYXNtQmluZGluZy5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21C aW5kaW5nLmgKQEAgLTM4LDcgKzM4LDcgQEAgY2xhc3MgQ2FsbExpbmtJbmZvOwogCiBuYW1lc3Bh Y2UgV2FzbSB7CiAKLVdhc21Ub0pTU3R1YiBpbXBvcnRTdHViR2VuZXJhdG9yKFZNKiwgQmFnPENh bGxMaW5rSW5mbz4mLCBTaWduYXR1cmVJbmRleCwgdW5zaWduZWQpOworV2FzbUV4aXRTdHVicyBl eGl0U3R1YkdlbmVyYXRvcihWTSosIEJhZzxDYWxsTGlua0luZm8+JiwgU2lnbmF0dXJlSW5kZXgs IHVuc2lnbmVkKTsKIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KIApkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZvcm1hdC5oIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbUZvcm1hdC5oCmluZGV4IGNiMmJlNTUuLjIzZDhlZDMgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Gb3JtYXQuaAorKysgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRm9ybWF0LmgKQEAgLTIyMiw3ICsyMjIsNiBAQCBwcml2 YXRlOgogfTsKIAogc3RydWN0IE1vZHVsZUluZm9ybWF0aW9uIHsKLSAgICBWZWN0b3I8U2lnbmF0 dXJlSW5kZXg+IHNpZ25hdHVyZUluZGljZXM7CiAgICAgVmVjdG9yPEltcG9ydD4gaW1wb3J0czsK ICAgICBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNl czsKICAgICBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+IGludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJ bmRpY2VzOwpAQCAtMjM2LDYgKzIzNSwxOCBAQCBzdHJ1Y3QgTW9kdWxlSW5mb3JtYXRpb24gewog ICAgIFRhYmxlSW5mb3JtYXRpb24gdGFibGVJbmZvcm1hdGlvbjsKICAgICBWZWN0b3I8R2xvYmFs PiBnbG9iYWxzOwogICAgIHVuc2lnbmVkIGZpcnN0SW50ZXJuYWxHbG9iYWwgeyAwIH07CisgICAg c2l6ZV90IGZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSBjb25zdCB7IHJldHVybiBpbXBvcnRGdW5j dGlvblNpZ25hdHVyZUluZGljZXMuc2l6ZSgpICsgaW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUlu ZGljZXMuc2l6ZSgpOyB9CisgICAgYm9vbCBpc0ltcG9ydGVkRnVuY3Rpb25Gcm9tRnVuY3Rpb25J bmRleFNwYWNlKHNpemVfdCBmdW5jdGlvbkluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgQVNT RVJUKGZ1bmN0aW9uSW5kZXggPCBmdW5jdGlvbkluZGV4U3BhY2VTaXplKCkpOworICAgICAgICBy ZXR1cm4gZnVuY3Rpb25JbmRleCA8IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXpl KCk7CisgICAgfQorICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9u SW5kZXhTcGFjZShzaXplX3QgZnVuY3Rpb25JbmRleCkgY29uc3QKKyAgICB7CisgICAgICAgIHJl dHVybiBpc0ltcG9ydGVkRnVuY3Rpb25Gcm9tRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5k ZXgpCisgICAgICAgICAgICA/IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlv bkluZGV4XQorICAgICAgICAgICAgOiBpbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tm dW5jdGlvbkluZGV4IC0gaW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnNpemUoKV07Cisg ICAgfQogCiAgICAgdWludDMyX3QgaW1wb3J0RnVuY3Rpb25Db3VudCgpIGNvbnN0IHsgcmV0dXJu IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCk7IH0KICAgICBib29sIGhhc01l bW9yeSgpIGNvbnN0IHsgcmV0dXJuICEhbWVtb3J5OyB9CkBAIC0yNDYsNiArMjU3LDEwIEBAIHN0 cnVjdCBNb2R1bGVJbmZvcm1hdGlvbiB7CiBzdHJ1Y3QgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbCB7 CiAgICAgQ29kZUxvY2F0aW9uQ2FsbCBjYWxsTG9jYXRpb247CiAgICAgc2l6ZV90IGZ1bmN0aW9u SW5kZXg7CisgICAgZW51bSBjbGFzcyBUYXJnZXQgOiB1aW50OF90IHsKKyAgICAgICAgdG9KUywK KyAgICAgICAgdG9XYXNtLAorICAgIH0gdGFyZ2V0OwogfTsKIAogc3RydWN0IEVudHJ5cG9pbnQg ewpAQCAtMjYxLDcgKzI3NiwxMCBAQCBzdHJ1Y3QgV2FzbUludGVybmFsRnVuY3Rpb24gewogICAg IEVudHJ5cG9pbnQganNUb1dhc21FbnRyeXBvaW50OwogfTsKIAotdHlwZWRlZiBNYWNyb0Fzc2Vt YmxlckNvZGVSZWYgV2FzbVRvSlNTdHViOworc3RydWN0IFdhc21FeGl0U3R1YnMgeworICAgIE1h Y3JvQXNzZW1ibGVyQ29kZVJlZiB3YXNtVG9KUzsKKyAgICBNYWNyb0Fzc2VtYmxlckNvZGVSZWYg d2FzbVRvV2FzbTsKK307CiAKIC8vIFdlYkFzc2VtYmx5IGRpcmVjdCBjYWxscyBhbmQgY2FsbF9p bmRpcmVjdCB1c2UgaW5kaWNlcyBpbnRvICJmdW5jdGlvbiBpbmRleCBzcGFjZSIuIFRoaXMgc3Bh Y2Ugc3RhcnRzIHdpdGggYWxsIGltcG9ydHMsIGFuZCB0aGVuIGFsbCBpbnRlcm5hbCBmdW5jdGlv bnMuCiAvLyBDYWxsYWJsZUZ1bmN0aW9uIGFuZCBGdW5jdGlvbkluZGV4U3BhY2UgYXJlIG9ubHkg bWVhbnQgYXMgZmFzdCBsb29rdXAgdGFibGVzIGZvciB0aGVzZSBvcGNvZGVzLCBhbmQgZG8gbm90 IG93biBjb2RlLgpAQCAtMjgwLDEyICsyOTgsNiBAQCBzdHJ1Y3QgQ2FsbGFibGVGdW5jdGlvbiB7 CiB9OwogdHlwZWRlZiBWZWN0b3I8Q2FsbGFibGVGdW5jdGlvbj4gRnVuY3Rpb25JbmRleFNwYWNl OwogCi0KLXN0cnVjdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UgewotICAgIE1hbGxvY1B0 cjxDYWxsYWJsZUZ1bmN0aW9uPiBidWZmZXI7Ci0gICAgc2l6ZV90IHNpemU7Ci19OwotCiB9IH0g Ly8gbmFtZXNwYWNlIEpTQzo6V2FzbQogCiAjZW5kaWYgLy8gRU5BQkxFKFdFQkFTU0VNQkxZKQpk aWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2Vy LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rpb25QYXJzZXIuaAppbmRl eCA1MjAxMGRjLi4zMTEwNWQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtRnVuY3Rpb25QYXJzZXIuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9X YXNtRnVuY3Rpb25QYXJzZXIuaApAQCAtNDYsNyArNDYsNyBAQCBwdWJsaWM6CiAgICAgdHlwZWRl ZiB0eXBlbmFtZSBDb250ZXh0OjpDb250cm9sVHlwZSBDb250cm9sVHlwZTsKICAgICB0eXBlZGVm IHR5cGVuYW1lIENvbnRleHQ6OkV4cHJlc3Npb25MaXN0IEV4cHJlc3Npb25MaXN0OwogCi0gICAg RnVuY3Rpb25QYXJzZXIoVk0qLCBDb250ZXh0JiwgY29uc3QgdWludDhfdCogZnVuY3Rpb25TdGFy dCwgc2l6ZV90IGZ1bmN0aW9uTGVuZ3RoLCBjb25zdCBTaWduYXR1cmUqLCBjb25zdCBJbW11dGFi bGVGdW5jdGlvbkluZGV4U3BhY2UmLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYpOworICAgIEZ1 bmN0aW9uUGFyc2VyKFZNKiwgQ29udGV4dCYsIGNvbnN0IHVpbnQ4X3QqIGZ1bmN0aW9uU3RhcnQs IHNpemVfdCBmdW5jdGlvbkxlbmd0aCwgY29uc3QgU2lnbmF0dXJlKiwgY29uc3QgTW9kdWxlSW5m b3JtYXRpb24mLCBjb25zdCBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+Jik7CiAKICAgICBSZXN1bHQg V0FSTl9VTlVTRURfUkVUVVJOIHBhcnNlKCk7CiAKQEAgLTgyLDE4ICs4MiwxOCBAQCBwcml2YXRl OgogICAgIEV4cHJlc3Npb25MaXN0IG1fZXhwcmVzc2lvblN0YWNrOwogICAgIFZlY3RvcjxDb250 cm9sRW50cnk+IG1fY29udHJvbFN0YWNrOwogICAgIGNvbnN0IFNpZ25hdHVyZSogbV9zaWduYXR1 cmU7Ci0gICAgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiBtX2Z1bmN0aW9uSW5k ZXhTcGFjZTsKICAgICBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgbV9pbmZvOworICAgIGNvbnN0 IFZlY3RvcjxTaWduYXR1cmVJbmRleD4mIG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVl ZFNpZ25hdHVyZUluZGljZXM7CiAgICAgdW5zaWduZWQgbV91bnJlYWNoYWJsZUJsb2NrcyB7IDAg fTsKIH07CiAKIHRlbXBsYXRlPHR5cGVuYW1lIENvbnRleHQ+Ci1GdW5jdGlvblBhcnNlcjxDb250 ZXh0Pjo6RnVuY3Rpb25QYXJzZXIoVk0qIHZtLCBDb250ZXh0JiBjb250ZXh0LCBjb25zdCB1aW50 OF90KiBmdW5jdGlvblN0YXJ0LCBzaXplX3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVy ZSogc2lnbmF0dXJlLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIGZ1bmN0aW9u SW5kZXhTcGFjZSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8pCitGdW5jdGlvblBhcnNl cjxDb250ZXh0Pjo6RnVuY3Rpb25QYXJzZXIoVk0qIHZtLCBDb250ZXh0JiBjb250ZXh0LCBjb25z dCB1aW50OF90KiBmdW5jdGlvblN0YXJ0LCBzaXplX3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNp Z25hdHVyZSogc2lnbmF0dXJlLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgY29uc3Qg VmVjdG9yPFNpZ25hdHVyZUluZGV4PiYgbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNp Z25hdHVyZUluZGljZXMpCiAgICAgOiBQYXJzZXIodm0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9u TGVuZ3RoKQogICAgICwgbV9jb250ZXh0KGNvbnRleHQpCiAgICAgLCBtX3NpZ25hdHVyZShzaWdu YXR1cmUpCi0gICAgLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4U3BhY2UpCiAg ICAgLCBtX2luZm8oaW5mbykKKyAgICAsIG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVl ZFNpZ25hdHVyZUluZGljZXMobW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVy ZUluZGljZXMpCiB7CiAgICAgaWYgKHZlcmJvc2UpCiAgICAgICAgIGRhdGFMb2dMbigiUGFyc2lu ZyBmdW5jdGlvbiBzdGFydGluZyBhdDogIiwgKHVpbnRwdHJfdClmdW5jdGlvblN0YXJ0LCAiIG9m IGxlbmd0aDogIiwgZnVuY3Rpb25MZW5ndGgpOwpAQCAtMzA4LDkgKzMwOCw5IEBAIGF1dG8gRnVu Y3Rpb25QYXJzZXI8Q29udGV4dD46OnBhcnNlRXhwcmVzc2lvbihPcFR5cGUgb3ApIC0+IFBhcnRp YWxSZXN1bHQKICAgICBjYXNlIENhbGw6IHsKICAgICAgICAgdWludDMyX3QgZnVuY3Rpb25JbmRl eDsKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoZnVuY3Rpb25J bmRleCksICJjYW4ndCBwYXJzZSBjYWxsJ3MgZnVuY3Rpb24gaW5kZXgiKTsKLSAgICAgICAgV0FT TV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1fZnVuY3Rpb25JbmRleFNwYWNlLnNp emUsICJjYWxsIGZ1bmN0aW9uIGluZGV4ICIsIGZ1bmN0aW9uSW5kZXgsICIgZXhjZWVkcyBmdW5j dGlvbiBpbmRleCBzcGFjZSAiLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5zaXplKTsKKyAgICAgICAg V0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1faW5mby5mdW5jdGlvbkluZGV4 U3BhY2VTaXplKCksICJjYWxsIGZ1bmN0aW9uIGluZGV4ICIsIGZ1bmN0aW9uSW5kZXgsICIgZXhj ZWVkcyBmdW5jdGlvbiBpbmRleCBzcGFjZSAiLCBtX2luZm8uZnVuY3Rpb25JbmRleFNwYWNlU2l6 ZSgpKTsKIAotICAgICAgICBTaWduYXR1cmVJbmRleCBjYWxsZWVTaWduYXR1cmVJbmRleCA9IG1f ZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtmdW5jdGlvbkluZGV4XS5zaWduYXR1cmVJ bmRleDsKKyAgICAgICAgU2lnbmF0dXJlSW5kZXggY2FsbGVlU2lnbmF0dXJlSW5kZXggPSBtX2lu Zm8uc2lnbmF0dXJlSW5kZXhGcm9tRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgpOwog ICAgICAgICBjb25zdCBTaWduYXR1cmUqIGNhbGxlZVNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9y bWF0aW9uOjpnZXQobV92bSwgY2FsbGVlU2lnbmF0dXJlSW5kZXgpOwogICAgICAgICBXQVNNX1BB UlNFUl9GQUlMX0lGKGNhbGxlZVNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpID4gbV9leHByZXNz aW9uU3RhY2suc2l6ZSgpLCAiY2FsbCBmdW5jdGlvbiBpbmRleCAiLCBmdW5jdGlvbkluZGV4LCAi IGhhcyAiLCBjYWxsZWVTaWduYXR1cmUtPmFyZ3VtZW50Q291bnQoKSwgIiBhcmd1bWVudHMsIGJ1 dCB0aGUgZXhwcmVzc2lvbiBzdGFjayBjdXJyZW50bHkgaG9sZHMgIiwgbV9leHByZXNzaW9uU3Rh Y2suc2l6ZSgpLCAiIHZhbHVlcyIpOwogCkBAIC0zMzcsOSArMzM3LDkgQEAgYXV0byBGdW5jdGlv blBhcnNlcjxDb250ZXh0Pjo6cGFyc2VFeHByZXNzaW9uKE9wVHlwZSBvcCkgLT4gUGFydGlhbFJl c3VsdAogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihzaWduYXR1 cmVJbmRleCksICJjYW4ndCBnZXQgY2FsbF9pbmRpcmVjdCdzIHNpZ25hdHVyZSBpbmRleCIpOwog ICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQxKHJlc2VydmVkKSwgImNh bid0IGdldCBjYWxsX2luZGlyZWN0J3MgcmVzZXJ2ZWQgYnl0ZSIpOwogICAgICAgICBXQVNNX1BB UlNFUl9GQUlMX0lGKHJlc2VydmVkLCAiY2FsbF9pbmRpcmVjdCdzICdyZXNlcnZlZCcgdmFydWlu dDEgbXVzdCBiZSAweDAiKTsKLSAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihtX2luZm8uc2ln bmF0dXJlSW5kaWNlcy5zaXplKCkgPD0gc2lnbmF0dXJlSW5kZXgsICJjYWxsX2luZGlyZWN0J3Mg c2lnbmF0dXJlIGluZGV4ICIsIHNpZ25hdHVyZUluZGV4LCAiIGV4Y2VlZHMga25vd24gc2lnbmF0 dXJlcyAiLCBtX2luZm8uc2lnbmF0dXJlSW5kaWNlcy5zaXplKCkpOworICAgICAgICBXQVNNX1BB UlNFUl9GQUlMX0lGKG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUlu ZGljZXMuc2l6ZSgpIDw9IHNpZ25hdHVyZUluZGV4LCAiY2FsbF9pbmRpcmVjdCdzIHNpZ25hdHVy ZSBpbmRleCAiLCBzaWduYXR1cmVJbmRleCwgIiBleGNlZWRzIGtub3duIHNpZ25hdHVyZXMgIiwg bV9tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXplKCkp OwogCi0gICAgICAgIFNpZ25hdHVyZUluZGV4IGNhbGxlZVNpZ25hdHVyZUluZGV4ID0gbV9pbmZv LnNpZ25hdHVyZUluZGljZXNbc2lnbmF0dXJlSW5kZXhdOworICAgICAgICBTaWduYXR1cmVJbmRl eCBjYWxsZWVTaWduYXR1cmVJbmRleCA9IG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVl ZFNpZ25hdHVyZUluZGljZXNbc2lnbmF0dXJlSW5kZXhdOwogICAgICAgICBjb25zdCBTaWduYXR1 cmUqIGNhbGxlZVNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgY2Fs bGVlU2lnbmF0dXJlSW5kZXgpOwogICAgICAgICBzaXplX3QgYXJndW1lbnRDb3VudCA9IGNhbGxl ZVNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpICsgMTsgLy8gQWRkIHRoZSBjYWxsZWUncyBpbmRl eC4KICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihhcmd1bWVudENvdW50ID4gbV9leHByZXNz aW9uU3RhY2suc2l6ZSgpLCAiY2FsbF9pbmRpcmVjdCBleHBlY3RzICIsIGFyZ3VtZW50Q291bnQs ICIgYXJndW1lbnRzLCBidXQgdGhlIGV4cHJlc3Npb24gc3RhY2sgY3VycmVudGx5IGhvbGRzICIs IG1fZXhwcmVzc2lvblN0YWNrLnNpemUoKSwgIiB2YWx1ZXMiKTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbU1lbW9yeS5jcHAKaW5kZXggNzAwZTNhYy4uYWFkOTFjMSAxMDA2NDQKLS0t IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5jcHAKKysrIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5jcHAKQEAgLTI4LDE1ICsyOCwzOSBAQAog CiAjaWYgRU5BQkxFKFdFQkFTU0VNQkxZKQogCisjaW5jbHVkZSA8d3RmL0hleE51bWJlci5oPgor I2luY2x1ZGUgPHd0Zi9QcmludFN0cmVhbS5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmlu Zy5oPgorCiBuYW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIFdhc20gewogCituYW1lc3BhY2Ugewor Y29uc3QgYm9vbCB2ZXJib3NlID0gZmFsc2U7Cit9CisKK3ZvaWQgTWVtb3J5OjpkdW1wKFByaW50 U3RyZWFtJiBvdXQpIGNvbnN0Cit7CisgICAgU3RyaW5nIG1lbW9yeUhleDsKKyAgICBXVEY6OmFw cGVuZFVuc2lnbmVkNjRBc0hleCgodWludDY0X3QpKHVpbnRwdHJfdCltX21lbW9yeSwgbWVtb3J5 SGV4KTsKKyAgICBvdXQucHJpbnQoIk1lbW9yeSBhdCAweCIsIG1lbW9yeUhleCwgIiwgc2l6ZSAi LCBtX3NpemUsICJCIGNhcGFjaXR5ICIsIG1fbWFwcGVkQ2FwYWNpdHksICJCLCBpbml0aWFsICIs IG1faW5pdGlhbCwgIiBtYXhpbXVtICIsIG1fbWF4aW11bSwgIiBtb2RlICIsIG1ha2VTdHJpbmco bV9tb2RlKSk7Cit9CisKK2NvbnN0IGNoYXIqIE1lbW9yeTo6bWFrZVN0cmluZyhNb2RlIG1vZGUp IGNvbnN0Cit7CisgICAgc3dpdGNoIChtb2RlKSB7CisgICAgY2FzZSBNb2RlOjpCb3VuZHNDaGVj a2luZzogcmV0dXJuICJCb3VuZHNDaGVja2luZyI7CisgICAgfQorICAgIFJFTEVBU0VfQVNTRVJU X05PVF9SRUFDSEVEKCk7CisgICAgcmV0dXJuICIiOworfQorCiBzdGF0aWNfYXNzZXJ0KHNpemVv Zih1aW50NjRfdCkgPT0gc2l6ZW9mKHNpemVfdCksICJXZSByZWx5IG9uIGFsbG93aW5nIHRoZSBt YXhpbXVtIHNpemUgb2YgTWVtb3J5IHdlIG1hcCB0byBiZSAyXjMyIHdoaWNoIGlzIGxhcmdlciB0 aGFuIGZpdHMgaW4gYSAzMi1iaXQgaW50ZWdlciB0aGF0IHdlJ2QgcGFzcyB0byBtcHJvdGVjdCBp ZiB0aGlzIGRpZG4ndCBob2xkLiIpOwogCiBNZW1vcnk6Ok1lbW9yeShQYWdlQ291bnQgaW5pdGlh bCwgUGFnZUNvdW50IG1heGltdW0sIGJvb2wmIGZhaWxlZCkKLSAgICA6IG1fbW9kZShNb2RlOjpC b3VuZHNDaGVja2luZykKKyAgICA6IG1fc2l6ZShpbml0aWFsLmJ5dGVzKCkpCiAgICAgLCBtX2lu aXRpYWwoaW5pdGlhbCkKICAgICAsIG1fbWF4aW11bShtYXhpbXVtKQotICAgICwgbV9zaXplKGlu aXRpYWwuYnl0ZXMoKSkKKyAgICAsIG1fbW9kZShNb2RlOjpCb3VuZHNDaGVja2luZykKICAgICAv LyBGSVhNRTogSWYgd2UgYWRkIHNpZ25hbCBiYXNlZCBib3VuZHMgY2hlY2tpbmcgdGhlbiB3ZSBu ZWVkIGV4dHJhIHNwYWNlIGZvciBvdmVyZmxvdyBvbiBsb2FkLgogICAgIC8vIHNlZTogaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MjY5MwogewpAQCAtNDYsOSArNzAs MTEgQEAgTWVtb3J5OjpNZW1vcnkoUGFnZUNvdW50IGluaXRpYWwsIFBhZ2VDb3VudCBtYXhpbXVt LCBib29sJiBmYWlsZWQpCiAgICAgaWYgKCFtX21hcHBlZENhcGFjaXR5KSB7CiAgICAgICAgIC8v IFRoaXMgbWVhbnMgd2Ugc3BlY2lmaWVkIGEgemVybyBhcyBtYXhpbXVtICh3aGljaCBtZWFucyB3 ZSBhbHNvIGhhdmUgemVybyBhcyBpbml0aWFsIHNpemUpLgogICAgICAgICBSRUxFQVNFX0FTU0VS VChtX3NpemUgPT0gMCk7Ci0gICAgICAgIG1fbWFwcGVkQ2FwYWNpdHkgPSAwOwogICAgICAgICBt X21lbW9yeSA9IG51bGxwdHI7CisgICAgICAgIG1fbWFwcGVkQ2FwYWNpdHkgPSAwOwogICAgICAg ICBmYWlsZWQgPSBmYWxzZTsKKyAgICAgICAgaWYgKHZlcmJvc2UpCisgICAgICAgICAgICBkYXRh TG9nTG4oIk1lbW9yeTo6TWVtb3J5IGFsbG9jYXRpbmcgbm90aGluZyAiLCAqdGhpcyk7CiAgICAg ICAgIHJldHVybjsKICAgICB9CiAKQEAgLTU2LDE1ICs4MiwyMSBAQCBNZW1vcnk6Ok1lbW9yeShQ YWdlQ291bnQgaW5pdGlhbCwgUGFnZUNvdW50IG1heGltdW0sIGJvb2wmIGZhaWxlZCkKICAgICB2 b2lkKiByZXN1bHQgPSBPcHRpb25zOjpzaW11bGF0ZVdlYkFzc2VtYmx5TG93TWVtb3J5KCkgPyBN QVBfRkFJTEVEIDogbW1hcChudWxscHRyLCBtX21hcHBlZENhcGFjaXR5LCBQUk9UX05PTkUsIE1B UF9QUklWQVRFIHwgTUFQX0FOT04sIC0xLCAwKTsKICAgICBpZiAocmVzdWx0ID09IE1BUF9GQUlM RUQpIHsKICAgICAgICAgLy8gVHJ5IGFnYWluIHdpdGggYSBkaWZmZXJlbnQgbnVtYmVyLgorICAg ICAgICBpZiAodmVyYm9zZSkKKyAgICAgICAgICAgIGRhdGFMb2dMbigiTWVtb3J5OjpNZW1vcnkg bW1hcCBmYWlsZWQgb25jZSBmb3IgY2FwYWNpdHksIHRyeWluZyBhZ2FpbiIsICp0aGlzKTsKICAg ICAgICAgbV9tYXBwZWRDYXBhY2l0eSA9IG1fc2l6ZTsKICAgICAgICAgaWYgKCFtX21hcHBlZENh cGFjaXR5KSB7CiAgICAgICAgICAgICBtX21lbW9yeSA9IG51bGxwdHI7CiAgICAgICAgICAgICBm YWlsZWQgPSBmYWxzZTsKKyAgICAgICAgICAgIGlmICh2ZXJib3NlKQorICAgICAgICAgICAgICAg IGRhdGFMb2dMbigiTWVtb3J5OjpNZW1vcnkgbW1hcCBub3QgdHJ5aW5nIGFnYWluIGJlY2F1c2Ug c2l6ZSBpcyB6ZXJvICIsICp0aGlzKTsKICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgfQog CiAgICAgICAgIHJlc3VsdCA9IG1tYXAobnVsbHB0ciwgbV9tYXBwZWRDYXBhY2l0eSwgUFJPVF9O T05FLCBNQVBfUFJJVkFURSB8IE1BUF9BTk9OLCAtMSwgMCk7CiAgICAgICAgIGlmIChyZXN1bHQg PT0gTUFQX0ZBSUxFRCkgeworICAgICAgICAgICAgaWYgKHZlcmJvc2UpCisgICAgICAgICAgICAg ICAgZGF0YUxvZ0xuKCJNZW1vcnk6Ok1lbW9yeSBtbWFwIGZhaWxlZCB0d2ljZSAiLCAqdGhpcyk7 CiAgICAgICAgICAgICBmYWlsZWQgPSB0cnVlOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAg ICB9CkBAIC03OCwxMiArMTEwLDI3IEBAIE1lbW9yeTo6TWVtb3J5KFBhZ2VDb3VudCBpbml0aWFs LCBQYWdlQ291bnQgbWF4aW11bSwgYm9vbCYgZmFpbGVkKQogCiAgICAgbV9tZW1vcnkgPSByZXN1 bHQ7CiAgICAgZmFpbGVkID0gZmFsc2U7CisgICAgaWYgKHZlcmJvc2UpCisgICAgICAgIGRhdGFM b2dMbigiTWVtb3J5OjpNZW1vcnkgbW1hcCBzdWNjZWVkZWQgIiwgKnRoaXMpOworfQorCitNZW1v cnk6On5NZW1vcnkoKQoreworICAgIGlmICh2ZXJib3NlKQorICAgICAgICBkYXRhTG9nTG4oIk1l bW9yeTo6fk1lbW9yeSAiLCAqdGhpcyk7CisgICAgaWYgKG1fbWVtb3J5KSB7CisgICAgICAgIGlm IChtdW5tYXAobV9tZW1vcnksIG1fbWFwcGVkQ2FwYWNpdHkpKQorICAgICAgICAgICAgQ1JBU0go KTsKKyAgICB9CiB9CiAKIGJvb2wgTWVtb3J5Ojpncm93KFBhZ2VDb3VudCBuZXdTaXplKQogewog ICAgIFJFTEVBU0VfQVNTRVJUKG5ld1NpemUgPiBQYWdlQ291bnQ6OmZyb21CeXRlcyhtX3NpemUp KTsKIAorICAgIGlmICh2ZXJib3NlKQorICAgICAgICBkYXRhTG9nTG4oIk1lbW9yeTo6Z3JvdyB0 byAiLCBuZXdTaXplLCAiIGZyb20gIiwgKnRoaXMpOworCiAgICAgaWYgKG1heGltdW0oKSAmJiBu ZXdTaXplID4gbWF4aW11bSgpKQogICAgICAgICByZXR1cm4gZmFsc2U7CiAKQEAgLTkzLDYgKzE0 MCw4IEBAIGJvb2wgTWVtb3J5Ojpncm93KFBhZ2VDb3VudCBuZXdTaXplKQogICAgICAgICBib29s IHN1Y2Nlc3MgPSAhbXByb3RlY3Qoc3RhdGljX2Nhc3Q8dWludDhfdCo+KG1fbWVtb3J5KSArIG1f c2l6ZSwgc3RhdGljX2Nhc3Q8c2l6ZV90PihkZXNpcmVkU2l6ZSAtIG1fc2l6ZSksIFBST1RfUkVB RCB8IFBST1RfV1JJVEUpOwogICAgICAgICBSRUxFQVNFX0FTU0VSVChzdWNjZXNzKTsKICAgICAg ICAgbV9zaXplID0gZGVzaXJlZFNpemU7CisgICAgICAgIGlmICh2ZXJib3NlKQorICAgICAgICAg ICAgZGF0YUxvZ0xuKCJNZW1vcnk6Omdyb3cgaW4tcGxhY2UgIiwgKnRoaXMpOwogICAgICAgICBy ZXR1cm4gdHJ1ZTsKICAgICB9CiAKQEAgLTExMCw2ICsxNTksOCBAQCBib29sIE1lbW9yeTo6Z3Jv dyhQYWdlQ291bnQgbmV3U2l6ZSkKICAgICBtX21hcHBlZENhcGFjaXR5ID0gZGVzaXJlZFNpemU7 CiAgICAgbV9zaXplID0gZGVzaXJlZFNpemU7CiAKKyAgICBpZiAodmVyYm9zZSkKKyAgICAgICAg ZGF0YUxvZ0xuKCJNZW1vcnk6Omdyb3cgIiwgKnRoaXMpOwogICAgIHJldHVybiB0cnVlOwogfQog CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmggYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmgKaW5kZXggNGU1ZWUzNi4uMjM2 YmY4NSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5o CisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuaApAQCAtMzAsNyAr MzAsOSBAQAogI2luY2x1ZGUgIldhc21DYWxsaW5nQ29udmVudGlvbi5oIgogI2luY2x1ZGUgIldh c21QYWdlQ291bnQuaCIKIAotI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KK25hbWVzcGFjZSBXVEYg eworY2xhc3MgUHJpbnRTdHJlYW07Cit9CiAKIG5hbWVzcGFjZSBKU0MgeyBuYW1lc3BhY2UgV2Fz bSB7CiAKQEAgLTM4LDQxICs0MCw1MCBAQCBjbGFzcyBNZW1vcnkgewogICAgIFdURl9NQUtFX05P TkNPUFlBQkxFKE1lbW9yeSk7CiAgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CiBwdWJsaWM6 CisgICAgdm9pZCBkdW1wKFdURjo6UHJpbnRTdHJlYW0mKSBjb25zdDsKIAogICAgIC8vIEZJWE1F OiBXZSBzaG91bGQgc3VwcG9ydCBvdGhlciBtb2Rlcy4gc2VlOiBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYyNjkzCiAgICAgZW51bSBjbGFzcyBNb2RlIHsKICAgICAg ICAgQm91bmRzQ2hlY2tpbmcKICAgICB9OworICAgIGNvbnN0IGNoYXIqIG1ha2VTdHJpbmcoTW9k ZSkgY29uc3Q7CiAKKyAgICBNZW1vcnkoKSA9IGRlZmF1bHQ7CiAgICAgSlNfRVhQT1JUX1BSSVZB VEUgTWVtb3J5KFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSwgYm9vbCYgZmFp bGVkKTsKLQotICAgIH5NZW1vcnkoKQorICAgIE1lbW9yeShNZW1vcnkmJiBvdGhlcikKKyAgICAg ICAgOiBtX21lbW9yeShvdGhlci5tX21lbW9yeSkKKyAgICAgICAgLCBtX3NpemUob3RoZXIubV9z aXplKQorICAgICAgICAsIG1faW5pdGlhbChvdGhlci5tX2luaXRpYWwpCisgICAgICAgICwgbV9t YXhpbXVtKG90aGVyLm1fbWF4aW11bSkKKyAgICAgICAgLCBtX21hcHBlZENhcGFjaXR5KG90aGVy Lm1fbWFwcGVkQ2FwYWNpdHkpCisgICAgICAgICwgbV9tb2RlKG90aGVyLm1fbW9kZSkKICAgICB7 Ci0gICAgICAgIGlmIChtX21lbW9yeSkKLSAgICAgICAgICAgIG11bm1hcChtX21lbW9yeSwgbV9t YXBwZWRDYXBhY2l0eSk7CisgICAgICAgIC8vIE1vdmluZyB0cmFuc2ZlcnMgb3duZXJzaGlwIG9m IHRoZSBhbGxvY2F0ZWQgbWVtb3J5LgorICAgICAgICBvdGhlci5tX21lbW9yeSA9IG51bGxwdHI7 CiAgICAgfQorICAgIH5NZW1vcnkoKTsKIAogICAgIHZvaWQqIG1lbW9yeSgpIGNvbnN0IHsgcmV0 dXJuIG1fbWVtb3J5OyB9CiAgICAgdWludDY0X3Qgc2l6ZSgpIGNvbnN0IHsgcmV0dXJuIG1fc2l6 ZTsgfQogICAgIFBhZ2VDb3VudCBzaXplSW5QYWdlcygpIGNvbnN0IHsgcmV0dXJuIFBhZ2VDb3Vu dDo6ZnJvbUJ5dGVzKG1fc2l6ZSk7IH0KIAotICAgIE1vZGUgbW9kZSgpIGNvbnN0IHsgcmV0dXJu IG1fbW9kZTsgfQotCiAgICAgUGFnZUNvdW50IGluaXRpYWwoKSBjb25zdCB7IHJldHVybiBtX2lu aXRpYWw7IH0KICAgICBQYWdlQ291bnQgbWF4aW11bSgpIGNvbnN0IHsgcmV0dXJuIG1fbWF4aW11 bTsgfQogCisgICAgTW9kZSBtb2RlKCkgY29uc3QgeyByZXR1cm4gbV9tb2RlOyB9CisKICAgICBi b29sIGdyb3coUGFnZUNvdW50KTsKIAotICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZTaXpl KCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKE1lbW9yeSwgbV9zaXplKTsgfQogICAgIHN0YXRp YyBwdHJkaWZmX3Qgb2Zmc2V0T2ZNZW1vcnkoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoTWVt b3J5LCBtX21lbW9yeSk7IH0KKyAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mU2l6ZSgpIHsg cmV0dXJuIE9CSkVDVF9PRkZTRVRPRihNZW1vcnksIG1fc2l6ZSk7IH0KICAgICAKIHByaXZhdGU6 CiAgICAgdm9pZCogbV9tZW1vcnkgeyBudWxscHRyIH07Ci0gICAgTW9kZSBtX21vZGU7CisgICAg dWludDY0X3QgbV9zaXplIHsgMCB9OwogICAgIFBhZ2VDb3VudCBtX2luaXRpYWw7CiAgICAgUGFn ZUNvdW50IG1fbWF4aW11bTsKLSAgICB1aW50NjRfdCBtX3NpemUgeyAwIH07CiAgICAgdWludDY0 X3QgbV9tYXBwZWRDYXBhY2l0eSB7IDAgfTsKKyAgICBNb2RlIG1fbW9kZSB7IE1vZGU6OkJvdW5k c0NoZWNraW5nIH07CiB9OwogCiB9IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2FzbQpkaWZmIC0tZ2l0 IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmNwcCBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnlJbmZvcm1hdGlvbi5jcHAKaW5k ZXggMmUxZDMwYS4uNmIwNjNkMyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9XYXNtTWVtb3J5SW5mb3JtYXRpb24uY3BwCkBAIC0yNiwxMyArMjYsNTIgQEAKICNpbmNs dWRlICJjb25maWcuaCIKICNpbmNsdWRlICJXYXNtTWVtb3J5SW5mb3JtYXRpb24uaCIKIAotI2lu Y2x1ZGUgIldhc21DYWxsaW5nQ29udmVudGlvbi5oIgotCiAjaWYgRU5BQkxFKFdFQkFTU0VNQkxZ KQogCisjaW5jbHVkZSAiV2FzbUNhbGxpbmdDb252ZW50aW9uLmgiCisjaW5jbHVkZSA8d3RmL05l dmVyRGVzdHJveWVkLmg+CisKIG5hbWVzcGFjZSBKU0MgeyBuYW1lc3BhY2UgV2FzbSB7CiAKLU1l bW9yeUluZm9ybWF0aW9uOjpNZW1vcnlJbmZvcm1hdGlvbihQYWdlQ291bnQgaW5pdGlhbCwgUGFn ZUNvdW50IG1heGltdW0sICBjb25zdCBWZWN0b3I8dW5zaWduZWQ+JiBwaW5uZWRTaXplUmVnaXN0 ZXJzLCBib29sIGlzSW1wb3J0KQorY29uc3QgUGlubmVkUmVnaXN0ZXJJbmZvJiBQaW5uZWRSZWdp c3RlckluZm86OmdldCgpCit7CisgICAgc3RhdGljIExhenlOZXZlckRlc3Ryb3llZDxQaW5uZWRS ZWdpc3RlckluZm8+IHN0YXRpY1Bpbm5lZFJlZ2lzdGVySW5mbzsKKyAgICBzdGF0aWMgc3RkOjpv bmNlX2ZsYWcgc3RhdGljUGlubmVkUmVnaXN0ZXJJbmZvRmxhZzsKKyAgICBzdGQ6OmNhbGxfb25j ZShzdGF0aWNQaW5uZWRSZWdpc3RlckluZm9GbGFnLCBbXSAoKSB7CisgICAgICAgIFZlY3RvcjxQ aW5uZWRTaXplUmVnaXN0ZXJJbmZvPiBzaXplUmVnaXN0ZXJzOworICAgICAgICBHUFJSZWcgYmFz ZU1lbW9yeVBvaW50ZXI7CisKKyAgICAgICAgLy8gRklYTUU6IFdlIHNob3VsZCBzdXBwb3J0IG1v cmUgdGhhbiBvbmUgbWVtb3J5IHNpemUgcmVnaXN0ZXIsIGFuZCB3ZSBzaG91bGQgYWxsb3cgZGlm ZmVyZW50CisgICAgICAgIC8vICAgICAgICBXZWJBc3NlbWJseS5JbnN0YW5jZSB0byBoYXZlIGRp ZmZlcmVudCBwaW5zLiBSaWdodCBub3cgd2UgdGFrZSBhIHZlY3RvciB3aXRoIG9ubHkgb25lIGVu dHJ5LgorICAgICAgICAvLyAgICAgICAgSWYgd2UgaGF2ZSBtb3JlIHRoYW4gb25lIHNpemUgcmVn aXN0ZXIsIHdlIGNhbiBoYXZlIG9uZSBmb3IgZWFjaCBsb2FkIHNpemUgY2xhc3MuCisgICAgICAg IC8vICAgICAgICBzZWU6IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x NjI5NTIKKyAgICAgICAgVmVjdG9yPHVuc2lnbmVkPiBwaW5uZWRTaXplcyA9IHsgMCB9OworICAg ICAgICB1bnNpZ25lZCByZW1haW5pbmdQaW5uZWRSZWdpc3RlcnMgPSBwaW5uZWRTaXplcy5zaXpl KCkgKyAxOworICAgICAgICBqc2NDYWxsaW5nQ29udmVudGlvbigpLm1fY2FsbGVlU2F2ZVJlZ2lz dGVycy5mb3JFYWNoKFsmXSAoUmVnIHJlZykgeworICAgICAgICAgICAgR1BSUmVnIGdwciA9IHJl Zy5ncHIoKTsKKyAgICAgICAgICAgIGlmICghcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzIHx8IFJl Z2lzdGVyU2V0OjpzdGFja1JlZ2lzdGVycygpLmdldChyZWcpKQorICAgICAgICAgICAgICAgIHJl dHVybjsKKyAgICAgICAgICAgIGlmIChyZW1haW5pbmdQaW5uZWRSZWdpc3RlcnMgPT0gMSkgewor ICAgICAgICAgICAgICAgIGJhc2VNZW1vcnlQb2ludGVyID0gZ3ByOworICAgICAgICAgICAgICAg IHJlbWFpbmluZ1Bpbm5lZFJlZ2lzdGVycy0tOworICAgICAgICAgICAgfSBlbHNlCisgICAgICAg ICAgICAgICAgc2l6ZVJlZ2lzdGVycy5hcHBlbmQoeyBncHIsIHBpbm5lZFNpemVzWy0tcmVtYWlu aW5nUGlubmVkUmVnaXN0ZXJzIC0gMV0gfSk7CisgICAgICAgIH0pOworCisgICAgICAgIEFTU0VS VCghcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzKTsKKyAgICAgICAgc3RhdGljUGlubmVkUmVnaXN0 ZXJJbmZvLmNvbnN0cnVjdChXVEZNb3ZlKHNpemVSZWdpc3RlcnMpLCBiYXNlTWVtb3J5UG9pbnRl cik7CisgICAgfSk7CisKKyAgICByZXR1cm4gc3RhdGljUGlubmVkUmVnaXN0ZXJJbmZvLmdldCgp OworfQorCitQaW5uZWRSZWdpc3RlckluZm86OlBpbm5lZFJlZ2lzdGVySW5mbyhWZWN0b3I8UGlu bmVkU2l6ZVJlZ2lzdGVySW5mbz4mJiBzaXplUmVnaXN0ZXJzLCBHUFJSZWcgYmFzZU1lbW9yeVBv aW50ZXIpCisgICAgOiBzaXplUmVnaXN0ZXJzKFdURk1vdmUoc2l6ZVJlZ2lzdGVycykpCisgICAg LCBiYXNlTWVtb3J5UG9pbnRlcihiYXNlTWVtb3J5UG9pbnRlcikKK3sKK30KKworTWVtb3J5SW5m b3JtYXRpb246Ok1lbW9yeUluZm9ybWF0aW9uKFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQg bWF4aW11bSwgIGJvb2wgaXNJbXBvcnQpCiAgICAgOiBtX2luaXRpYWwoaW5pdGlhbCkKICAgICAs IG1fbWF4aW11bShtYXhpbXVtKQogICAgICwgbV9pc0ltcG9ydChpc0ltcG9ydCkKQEAgLTQwLDIw ICs3OSw2IEBAIE1lbW9yeUluZm9ybWF0aW9uOjpNZW1vcnlJbmZvcm1hdGlvbihQYWdlQ291bnQg aW5pdGlhbCwgUGFnZUNvdW50IG1heGltdW0sICBjb25zCiAgICAgUkVMRUFTRV9BU1NFUlQoISFt X2luaXRpYWwpOwogICAgIFJFTEVBU0VfQVNTRVJUKCFtX21heGltdW0gfHwgbV9tYXhpbXVtID49 IG1faW5pdGlhbCk7CiAgICAgQVNTRVJUKCEhKnRoaXMpOwotCi0gICAgdW5zaWduZWQgcmVtYWlu aW5nUGlubmVkUmVnaXN0ZXJzID0gcGlubmVkU2l6ZVJlZ2lzdGVycy5zaXplKCkgKyAxOwotICAg IGpzY0NhbGxpbmdDb252ZW50aW9uKCkubV9jYWxsZWVTYXZlUmVnaXN0ZXJzLmZvckVhY2goWyZd IChSZWcgcmVnKSB7Ci0gICAgICAgIEdQUlJlZyBncHIgPSByZWcuZ3ByKCk7Ci0gICAgICAgIGlm ICghcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzIHx8IFJlZ2lzdGVyU2V0OjpzdGFja1JlZ2lzdGVy cygpLmdldChyZWcpKQotICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICBpZiAocmVtYWluaW5n UGlubmVkUmVnaXN0ZXJzID09IDEpIHsKLSAgICAgICAgICAgIG1fcGlubmVkUmVnaXN0ZXJzLmJh c2VNZW1vcnlQb2ludGVyID0gZ3ByOwotICAgICAgICAgICAgcmVtYWluaW5nUGlubmVkUmVnaXN0 ZXJzLS07Ci0gICAgICAgIH0gZWxzZQotICAgICAgICAgICAgbV9waW5uZWRSZWdpc3RlcnMuc2l6 ZVJlZ2lzdGVycy5hcHBlbmQoeyBncHIsIHBpbm5lZFNpemVSZWdpc3RlcnNbLS1yZW1haW5pbmdQ aW5uZWRSZWdpc3RlcnMgLSAxXSB9KTsKLSAgICB9KTsKLQotICAgIEFTU0VSVCghcmVtYWluaW5n UGlubmVkUmVnaXN0ZXJzKTsKIH0KIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnlJbmZvcm1hdGlvbi5o IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmgKaW5k ZXggZWU2M2Q5ZS4uNmU3ZjUyMSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmgKQEAgLTM4LDEyICszOCwxMSBAQCBzdHJ1Y3QgUGlu bmVkU2l6ZVJlZ2lzdGVySW5mbyB7CiAgICAgdW5zaWduZWQgc2l6ZU9mZnNldDsKIH07CiAKLS8v IEZJWE1FOiBXZSBzaG91bGQgc3VwcG9ydCBtb3JlIHRoYW4gb25lIG1lbW9yeSBzaXplIHJlZ2lz dGVyLiBSaWdodCBub3cgd2UgdGFrZSBhIHZlY3RvciB3aXRoIG9ubHkgb25lCi0vLyBlbnRyeS4g U3BlY2lmaWNhbGx5IGFuIGVudHJ5IHdoZXJlIHRoZSBzaXplT2Zmc2V0ID09IDAuIElmIHdlIGhh dmUgbW9yZSB0aGFuIG9uZSBzaXplIHJlZ2lzdGVyLAotLy8gd2UgY2FuIGhhdmUgb25lIGZvciBl YWNoIGxvYWQgc2l6ZSBjbGFzcy4gc2VlOiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MTYyOTUyCiBzdHJ1Y3QgUGlubmVkUmVnaXN0ZXJJbmZvIHsKICAgICBWZWN0b3I8 UGlubmVkU2l6ZVJlZ2lzdGVySW5mbz4gc2l6ZVJlZ2lzdGVyczsKICAgICBHUFJSZWcgYmFzZU1l bW9yeVBvaW50ZXI7CisgICAgc3RhdGljIGNvbnN0IFBpbm5lZFJlZ2lzdGVySW5mbyYgZ2V0KCk7 CisgICAgUGlubmVkUmVnaXN0ZXJJbmZvKFZlY3RvcjxQaW5uZWRTaXplUmVnaXN0ZXJJbmZvPiYm LCBHUFJSZWcpOwogfTsKIAogY2xhc3MgTWVtb3J5SW5mb3JtYXRpb24gewpAQCAtNTMsOSArNTIs OCBAQCBwdWJsaWM6CiAgICAgICAgIEFTU0VSVCghKnRoaXMpOwogICAgIH0KIAotICAgIE1lbW9y eUluZm9ybWF0aW9uKFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSwgY29uc3Qg VmVjdG9yPHVuc2lnbmVkPiYgcGlubmVkU2l6ZVJlZ2lzdGVycywgYm9vbCBpc0ltcG9ydCk7Cisg ICAgTWVtb3J5SW5mb3JtYXRpb24oUGFnZUNvdW50IGluaXRpYWwsIFBhZ2VDb3VudCBtYXhpbXVt LCBib29sIGlzSW1wb3J0KTsKIAotICAgIGNvbnN0IFBpbm5lZFJlZ2lzdGVySW5mbyYgcGlubmVk UmVnaXN0ZXJzKCkgY29uc3QgeyByZXR1cm4gbV9waW5uZWRSZWdpc3RlcnM7IH0KICAgICBQYWdl Q291bnQgaW5pdGlhbCgpIGNvbnN0IHsgcmV0dXJuIG1faW5pdGlhbDsgfQogICAgIFBhZ2VDb3Vu dCBtYXhpbXVtKCkgY29uc3QgeyByZXR1cm4gbV9tYXhpbXVtOyB9CiAgICAgYm9vbCBpc0ltcG9y dCgpIGNvbnN0IHsgcmV0dXJuIG1faXNJbXBvcnQ7IH0KQEAgLTY1LDcgKzYzLDYgQEAgcHVibGlj OgogcHJpdmF0ZToKICAgICBQYWdlQ291bnQgbV9pbml0aWFsIHsgfTsKICAgICBQYWdlQ291bnQg bV9tYXhpbXVtIHsgfTsKLSAgICBQaW5uZWRSZWdpc3RlckluZm8gbV9waW5uZWRSZWdpc3RlcnMg eyB9OwogICAgIGJvb2wgbV9pc0ltcG9ydCB7IGZhbHNlIH07CiB9OwogCmRpZmYgLS1naXQgYS9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmNwcCBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCmluZGV4IDYyNjFlN2YuLjMw MTFjODkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQ YXJzZXIuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJz ZXIuY3BwCkBAIC0xMDcsNyArMTA3LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlVHlwZSgp IC0+IFBhcnRpYWxSZXN1bHQKIAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUlu dDMyKGNvdW50KSwgImNhbid0IGdldCBUeXBlIHNlY3Rpb24ncyBjb3VudCIpOwogICAgIFdBU01f UEFSU0VSX0ZBSUxfSUYoY291bnQgPT0gc3RkOjpudW1lcmljX2xpbWl0czx1aW50MzJfdD46Om1h eCgpLCAiVHlwZSBzZWN0aW9uJ3MgY291bnQgaXMgdG9vIGJpZyAiLCBjb3VudCk7Ci0gICAgV0FT TV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnRyeVJl c2VydmVDYXBhY2l0eShjb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciBU eXBlIHNlY3Rpb24ncyAiLCBjb3VudCwgIiBlbnRyaWVzIik7CisgICAgV0FTTV9QQVJTRVJfRkFJ TF9JRighbV9yZXN1bHQubW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUlu ZGljZXMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBt ZW1vcnkgZm9yIFR5cGUgc2VjdGlvbidzICIsIGNvdW50LCAiIGVudHJpZXMiKTsKIAogICAgIGZv ciAodWludDMyX3QgaSA9IDA7IGkgPCBjb3VudDsgKytpKSB7CiAgICAgICAgIGludDhfdCB0eXBl OwpAQCAtMTM5LDcgKzEzOSw3IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZVR5cGUoKSAtPiBQ YXJ0aWFsUmVzdWx0CiAgICAgICAgIHNpZ25hdHVyZS0+cmV0dXJuVHlwZSgpID0gcmV0dXJuVHlw ZTsKIAogICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IFNpZ25hdHVyZUlu Zm9ybWF0aW9uOjphZG9wdChtX3ZtLCBzaWduYXR1cmUucmVsZWFzZSgpKTsKLSAgICAgICAgbV9y ZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJ bmRleCk7CisgICAgICAgIG1fcmVzdWx0Lm1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRT aWduYXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7CiAgICAgfQog ICAgIHJldHVybiB7IH07CiB9CkBAIC0xNTIsNyArMTUyLDYgQEAgYXV0byBNb2R1bGVQYXJzZXI6 OnBhcnNlSW1wb3J0KCkgLT4gUGFydGlhbFJlc3VsdAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYo IW1fcmVzdWx0Lm1vZHVsZS0+Z2xvYmFscy50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291bnQp LCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIgZ2xv YmFscyIpOyAvLyBGSVhNRSB0aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBGSVhN RXMgYmVsb3cuCiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlLT5pbXBv cnRzLnRyeVJlc2VydmVDYXBhY2l0eShpbXBvcnRDb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91 Z2ggbWVtb3J5IGZvciAiLCBpbXBvcnRDb3VudCwgIiBpbXBvcnRzIik7IC8vIEZJWE1FIHRoaXMg b3Zlci1hbGxvY2F0ZXMgd2hlbiB3ZSBmaXggdGhlIEZJWE1FcyBiZWxvdy4KICAgICBXQVNNX1BB UlNFUl9GQUlMX0lGKCFtX3Jlc3VsdC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5k aWNlcy50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5v dWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIgaW1wb3J0IGZ1bmN0aW9uIHNpZ25hdHVy ZXMiKTsgLy8gRklYTUUgdGhpcyBvdmVyLWFsbG9jYXRlcyB3aGVuIHdlIGZpeCB0aGUgRklYTUVz IGJlbG93LgotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhT cGFjZS50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5v dWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIgZnVuY3Rpb25zIGluIHRoZSBpbmRleCBz cGFjZSIpOyAvLyBGSVhNRSB0aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBGSVhN RXMgYmVsb3cuIFdlJ2xsIGFsbG9jYXRlIHNvbWUgbW9yZSBoZXJlIHdoZW4gd2Uga25vdyBob3cg bWFueSBmdW5jdGlvbnMgdG8gZXhwZWN0LgogCiAgICAgZm9yICh1aW50MzJfdCBpbXBvcnROdW1i ZXIgPSAwOyBpbXBvcnROdW1iZXIgPCBpbXBvcnRDb3VudDsgKytpbXBvcnROdW1iZXIpIHsKICAg ICAgICAgSW1wb3J0IGltcDsKQEAgLTE3NCwxMSArMTczLDEwIEBAIGF1dG8gTW9kdWxlUGFyc2Vy OjpwYXJzZUltcG9ydCgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICAgICAgY2FzZSBFeHRlcm5hbEtp bmQ6OkZ1bmN0aW9uOiB7CiAgICAgICAgICAgICB1aW50MzJfdCBmdW5jdGlvblNpZ25hdHVyZUlu ZGV4OwogICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoZnVu Y3Rpb25TaWduYXR1cmVJbmRleCksICJjYW4ndCBnZXQgIiwgaW1wb3J0TnVtYmVyLCAidGggSW1w b3J0J3MgZnVuY3Rpb24gc2lnbmF0dXJlIGluIG1vZHVsZSAnIiwgbW9kdWxlU3RyaW5nLCAiJyBm aWVsZCAnIiwgZmllbGRTdHJpbmcsICInIik7Ci0gICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlM X0lGKGZ1bmN0aW9uU2lnbmF0dXJlSW5kZXggPj0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJ bmRpY2VzLnNpemUoKSwgImludmFsaWQgZnVuY3Rpb24gc2lnbmF0dXJlIGZvciAiLCBpbXBvcnRO dW1iZXIsICJ0aCBJbXBvcnQsICIsIGZ1bmN0aW9uU2lnbmF0dXJlSW5kZXgsICIgaXMgb3V0IG9m IHJhbmdlIG9mICIsIG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICIg aW4gbW9kdWxlICciLCBtb2R1bGVTdHJpbmcsICInIGZpZWxkICciLCBmaWVsZFN0cmluZywgIici KTsKKyAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVuY3Rpb25TaWduYXR1cmVJbmRl eCA+PSBtX3Jlc3VsdC5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5k aWNlcy5zaXplKCksICJpbnZhbGlkIGZ1bmN0aW9uIHNpZ25hdHVyZSBmb3IgIiwgaW1wb3J0TnVt YmVyLCAidGggSW1wb3J0LCAiLCBmdW5jdGlvblNpZ25hdHVyZUluZGV4LCAiIGlzIG91dCBvZiBy YW5nZSBvZiAiLCBtX3Jlc3VsdC5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0 dXJlSW5kaWNlcy5zaXplKCksICIgaW4gbW9kdWxlICciLCBtb2R1bGVTdHJpbmcsICInIGZpZWxk ICciLCBmaWVsZFN0cmluZywgIiciKTsKICAgICAgICAgICAgIGltcC5raW5kSW5kZXggPSBtX3Jl c3VsdC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCk7Ci0gICAg ICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZS0+ c2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvblNpZ25hdHVyZUluZGV4XTsKKyAgICAgICAgICAgIFNp Z25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlU2lnbmF0dXJlSW5k aWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXNbZnVuY3Rpb25TaWduYXR1cmVJbmRleF07CiAg ICAgICAgICAgICBtX3Jlc3VsdC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNl cy51bmNoZWNrZWRBcHBlbmQoc2lnbmF0dXJlSW5kZXgpOwotICAgICAgICAgICAgbV9yZXN1bHQu ZnVuY3Rpb25JbmRleFNwYWNlLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7CiAgICAg ICAgICAgICBicmVhazsKICAgICAgICAgfQogICAgICAgICBjYXNlIEV4dGVybmFsS2luZDo6VGFi bGU6IHsKQEAgLTIyMCwyMCArMjE4LDE4IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZUZ1bmN0 aW9uKCkgLT4gUGFydGlhbFJlc3VsdAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoY291bnQgPT0g c3RkOjpudW1lcmljX2xpbWl0czx1aW50MzJfdD46Om1heCgpLCAiRnVuY3Rpb24gc2VjdGlvbidz IGNvdW50IGlzIHRvbyBiaWcgIiwgY291bnQpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1f cmVzdWx0Lm1vZHVsZS0+aW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXMudHJ5UmVzZXJ2 ZUNhcGFjaXR5KGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGNv dW50LCAiIEZ1bmN0aW9uIHNpZ25hdHVyZXMiKTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFt X3Jlc3VsdC5mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50 KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGNvdW50LCAiRnVuY3Rpb24g bG9jYXRpb25zIik7Ci0gICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQuZnVuY3Rpb25J bmRleFNwYWNlLnRyeVJlc2VydmVDYXBhY2l0eShtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uu c2l6ZSgpICsgY291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgY291 bnQsICIgbW9yZSBmdW5jdGlvbnMgaW4gdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlIik7CiAKICAg ICBmb3IgKHVpbnQzMl90IGkgPSAwOyBpIDwgY291bnQ7ICsraSkgewogICAgICAgICB1aW50MzJf dCB0eXBlTnVtYmVyOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQz Mih0eXBlTnVtYmVyKSwgImNhbid0IGdldCAiLCBpLCAidGggRnVuY3Rpb24ncyB0eXBlIG51bWJl ciIpOwotICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHR5cGVOdW1iZXIgPj0gbV9yZXN1bHQu bW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnNpemUoKSwgaSwgInRoIEZ1bmN0aW9uIHR5cGUgbnVt YmVyIGlzIGludmFsaWQgIiwgdHlwZU51bWJlcik7CisgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxf SUYodHlwZU51bWJlciA+PSBtX3Jlc3VsdC5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVk U2lnbmF0dXJlSW5kaWNlcy5zaXplKCksIGksICJ0aCBGdW5jdGlvbiB0eXBlIG51bWJlciBpcyBp bnZhbGlkICIsIHR5cGVOdW1iZXIpOwogCi0gICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVy ZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzW3R5cGVOdW1iZXJdOwor ICAgICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZVNp Z25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzW3R5cGVOdW1iZXJdOwogICAg ICAgICAvLyBUaGUgQ29kZSBzZWN0aW9uIGZpeGVzIHVwIHN0YXJ0IGFuZCBlbmQuCiAgICAgICAg IHNpemVfdCBzdGFydCA9IDA7CiAgICAgICAgIHNpemVfdCBlbmQgPSAwOwogICAgICAgICBtX3Jl c3VsdC5tb2R1bGUtPmludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFw cGVuZChzaWduYXR1cmVJbmRleCk7CiAgICAgICAgIG1fcmVzdWx0LmZ1bmN0aW9uTG9jYXRpb25J bkJpbmFyeS51bmNoZWNrZWRBcHBlbmQoeyBzdGFydCwgZW5kIH0pOwotICAgICAgICBtX3Jlc3Vs dC5mdW5jdGlvbkluZGV4U3BhY2UudW5jaGVja2VkQXBwZW5kKHNpZ25hdHVyZUluZGV4KTsKICAg ICB9CiAKICAgICByZXR1cm4geyB9OwpAQCAtMzIwLDggKzMxNiw3IEBAIGF1dG8gTW9kdWxlUGFy c2VyOjpwYXJzZU1lbW9yeUhlbHBlcihib29sIGlzSW1wb3J0KSAtPiBQYXJ0aWFsUmVzdWx0CiAg ICAgQVNTRVJUKGluaXRpYWxQYWdlQ291bnQpOwogICAgIEFTU0VSVCghbWF4aW11bVBhZ2VDb3Vu dCB8fCBtYXhpbXVtUGFnZUNvdW50ID49IGluaXRpYWxQYWdlQ291bnQpOwogCi0gICAgVmVjdG9y PHVuc2lnbmVkPiBwaW5uZWRTaXplcyA9IHsgMCB9OwotICAgIG1fcmVzdWx0Lm1vZHVsZS0+bWVt b3J5ID0gTWVtb3J5SW5mb3JtYXRpb24oaW5pdGlhbFBhZ2VDb3VudCwgbWF4aW11bVBhZ2VDb3Vu dCwgcGlubmVkU2l6ZXMsIGlzSW1wb3J0KTsKKyAgICBtX3Jlc3VsdC5tb2R1bGUtPm1lbW9yeSA9 IE1lbW9yeUluZm9ybWF0aW9uKGluaXRpYWxQYWdlQ291bnQsIG1heGltdW1QYWdlQ291bnQsIGlz SW1wb3J0KTsKICAgICByZXR1cm4geyB9OwogfQogCkBAIC0zODcsNyArMzgyLDcgQEAgYXV0byBN b2R1bGVQYXJzZXI6OnBhcnNlRXhwb3J0KCkgLT4gUGFydGlhbFJlc3VsdAogICAgICAgICBXQVNN X1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihleHAua2luZEluZGV4KSwgImNhbid0IGdl dCAiLCBleHBvcnROdW1iZXIsICJ0aCBFeHBvcnQncyBraW5kIGluZGV4LCBuYW1lZCAnIiwgZmll bGRTdHJpbmcsICInIik7CiAgICAgICAgIHN3aXRjaCAoZXhwLmtpbmQpIHsKICAgICAgICAgY2Fz ZSBFeHRlcm5hbEtpbmQ6OkZ1bmN0aW9uOiB7Ci0gICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlM X0lGKGV4cC5raW5kSW5kZXggPj0gbV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnNpemUoKSwg ZXhwb3J0TnVtYmVyLCAidGggRXhwb3J0IGhhcyBpbnZhbGlkIGZ1bmN0aW9uIG51bWJlciAiLCBl eHAua2luZEluZGV4LCAiIGl0IGV4Y2VlZHMgdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlICIsIG1f cmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCksICIsIG5hbWVkICciLCBmaWVsZFN0cmlu ZywgIiciKTsKKyAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZXhwLmtpbmRJbmRleCA+ PSBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSwgZXhwb3J0TnVtYmVy LCAidGggRXhwb3J0IGhhcyBpbnZhbGlkIGZ1bmN0aW9uIG51bWJlciAiLCBleHAua2luZEluZGV4 LCAiIGl0IGV4Y2VlZHMgdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlICIsIG1fcmVzdWx0Lm1vZHVs ZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpLCAiLCBuYW1lZCAnIiwgZmllbGRTdHJpbmcsICIn Iik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQogICAgICAgICBjYXNlIEV4dGVybmFs S2luZDo6VGFibGU6IHsKQEAgLTQxNyw4ICs0MTIsOCBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFy c2VTdGFydCgpIC0+IFBhcnRpYWxSZXN1bHQKIHsKICAgICB1aW50MzJfdCBzdGFydEZ1bmN0aW9u SW5kZXg7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoc3RhcnRGdW5j dGlvbkluZGV4KSwgImNhbid0IGdldCBTdGFydCBpbmRleCIpOwotICAgIFdBU01fUEFSU0VSX0ZB SUxfSUYoc3RhcnRGdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5z aXplKCksICJTdGFydCBpbmRleCAiLCBzdGFydEZ1bmN0aW9uSW5kZXgsICIgZXhjZWVkcyBmdW5j dGlvbiBpbmRleCBzcGFjZSAiLCBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpKTsK LSAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0LmZ1bmN0aW9uSW5k ZXhTcGFjZVtzdGFydEZ1bmN0aW9uSW5kZXhdLnNpZ25hdHVyZUluZGV4OworICAgIFdBU01fUEFS U0VSX0ZBSUxfSUYoc3RhcnRGdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0Lm1vZHVsZS0+ZnVuY3Rp b25JbmRleFNwYWNlU2l6ZSgpLCAiU3RhcnQgaW5kZXggIiwgc3RhcnRGdW5jdGlvbkluZGV4LCAi IGV4Y2VlZHMgZnVuY3Rpb24gaW5kZXggc3BhY2UgIiwgbV9yZXN1bHQubW9kdWxlLT5mdW5jdGlv bkluZGV4U3BhY2VTaXplKCkpOworICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0g bV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2Uoc3Rh cnRGdW5jdGlvbkluZGV4KTsKICAgICBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFNpZ25h dHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgc2lnbmF0dXJlSW5kZXgpOwogICAgIFdBU01fUEFS U0VSX0ZBSUxfSUYoc2lnbmF0dXJlLT5hcmd1bWVudENvdW50KCksICJTdGFydCBmdW5jdGlvbiBj YW4ndCBoYXZlIGFyZ3VtZW50cyIpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc2lnbmF0dXJl LT5yZXR1cm5UeXBlKCkgIT0gVm9pZCwgIlN0YXJ0IGZ1bmN0aW9uIGNhbid0IHJldHVybiBhIHZh bHVlIik7CkBAIC00NjksNyArNDY0LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlRWxlbWVu dCgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICAgICAgZm9yICh1bnNpZ25lZCBpbmRleCA9IDA7IGlu ZGV4IDwgaW5kZXhDb3VudDsgKytpbmRleCkgewogICAgICAgICAgICAgdWludDMyX3QgZnVuY3Rp b25JbmRleDsKICAgICAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMy KGZ1bmN0aW9uSW5kZXgpLCAiY2FuJ3QgZ2V0IEVsZW1lbnQgc2VjdGlvbidzICIsIGVsZW1lbnRO dW0sICJ0aCBlbGVtZW50J3MgIiwgaW5kZXgsICJ0aCBpbmRleCIpOwotICAgICAgICAgICAgV0FT TV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhT cGFjZS5zaXplKCksICJFbGVtZW50IHNlY3Rpb24ncyAiLCBlbGVtZW50TnVtLCAidGggZWxlbWVu dCdzICIsIGluZGV4LCAidGggaW5kZXggaXMgIiwgZnVuY3Rpb25JbmRleCwgIiB3aGljaCBleGNl ZWRzIHRoZSBmdW5jdGlvbiBpbmRleCBzcGFjZSBzaXplIG9mICIsIG1fcmVzdWx0LmZ1bmN0aW9u SW5kZXhTcGFjZS5zaXplKCkpOworICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5j dGlvbkluZGV4ID49IG1fcmVzdWx0Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpLCAi RWxlbWVudCBzZWN0aW9uJ3MgIiwgZWxlbWVudE51bSwgInRoIGVsZW1lbnQncyAiLCBpbmRleCwg InRoIGluZGV4IGlzICIsIGZ1bmN0aW9uSW5kZXgsICIgd2hpY2ggZXhjZWVkcyB0aGUgZnVuY3Rp b24gaW5kZXggc3BhY2Ugc2l6ZSBvZiAiLCBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhT cGFjZVNpemUoKSk7CiAKICAgICAgICAgICAgIGVsZW1lbnQuZnVuY3Rpb25JbmRpY2VzLnVuY2hl Y2tlZEFwcGVuZChmdW5jdGlvbkluZGV4KTsKICAgICAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5oIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5oCmluZGV4IGUzYjc1YTcuLjdlMDI2YzkgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuaAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmgKQEAgLTM2 LDggKzM2LDggQEAgbmFtZXNwYWNlIEpTQyB7IG5hbWVzcGFjZSBXYXNtIHsKIAogc3RydWN0IE1v ZHVsZVBhcnNlclJlc3VsdCB7CiAgICAgc3RkOjp1bmlxdWVfcHRyPE1vZHVsZUluZm9ybWF0aW9u PiBtb2R1bGU7Ci0gICAgRnVuY3Rpb25JbmRleFNwYWNlIGZ1bmN0aW9uSW5kZXhTcGFjZTsKICAg ICBWZWN0b3I8RnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5PiBmdW5jdGlvbkxvY2F0aW9uSW5CaW5h cnk7CisgICAgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiBtb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9V bmlxdWVkU2lnbmF0dXJlSW5kaWNlczsKIH07CiAKIGNsYXNzIE1vZHVsZVBhcnNlciA6IHB1Ymxp YyBQYXJzZXI8TW9kdWxlUGFyc2VyUmVzdWx0PiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtUGFnZUNvdW50LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21QYWdlQ291bnQuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LjRiODc3MDUKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9X YXNtUGFnZUNvdW50LmNwcApAQCAtMCwwICsxLDQ1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDE2IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlv biBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAq IG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcg Y29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2Ug Y29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBS ZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3Ro ZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAq IEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRF RCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBO TyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZP UiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFS WSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1Mg T0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVS IElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5F R0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UK KyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIldh c21QYWdlQ291bnQuaCIKKworI2lmIEVOQUJMRShXRUJBU1NFTUJMWSkKKworI2luY2x1ZGUgPHd0 Zi9QcmludFN0cmVhbS5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgorCituYW1l c3BhY2UgSlNDIHsgbmFtZXNwYWNlIFdhc20geworCit2b2lkIFBhZ2VDb3VudDo6ZHVtcChQcmlu dFN0cmVhbSYgb3V0KSBjb25zdAoreworICAgIG91dC5wcmludChTdHJpbmc6Om51bWJlcihieXRl cygpKSwgIkIiKTsKK30KKworfSAvLyBuYW1lc3BhY2UgSlNDCisKK30gLy8gbmFtZXNwYWNlIFdh c20KKworI2VuZGlmIC8vIEVOQUJMRShXRUJBU1NFTUJMWSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21QYWdlQ291bnQuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL1dhc21QYWdlQ291bnQuaAppbmRleCBhMTVkNTA1Li42N2RiYjU1IDEwMDY0NAotLS0g YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFnZUNvdW50LmgKKysrIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBhZ2VDb3VudC5oCkBAIC0yNyw2ICsyNywxMCBAQAog CiAjaWYgRU5BQkxFKFdFQkFTU0VNQkxZKQogCituYW1lc3BhY2UgV1RGIHsKK2NsYXNzIFByaW50 U3RyZWFtOworfQorCiBuYW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIFdhc20gewogCiBjbGFzcyBQ YWdlQ291bnQgewpAQCAtNDIsNiArNDYsOCBAQCBwdWJsaWM6CiAgICAgICAgIDogbV9wYWdlQ291 bnQocGFnZUNvdW50KQogICAgIHsgfQogCisgICAgdm9pZCBkdW1wKFdURjo6UHJpbnRTdHJlYW0m KSBjb25zdDsKKwogICAgIHVpbnQ2NF90IGJ5dGVzKCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nh c3Q8dWludDY0X3Q+KG1fcGFnZUNvdW50KSAqIHN0YXRpY19jYXN0PHVpbnQ2NF90PihwYWdlU2l6 ZSk7IH0KICAgICB1aW50MzJfdCBwYWdlQ291bnQoKSBjb25zdCB7IHJldHVybiBtX3BhZ2VDb3Vu dDsgfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5j cHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5jcHAKaW5kZXggZWQyOGJi Yy4uMmQzNDIyZiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBs YW4uY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmNwcApAQCAt NzYsOCArNzYsNyBAQCBib29sIFBsYW46OnBhcnNlQW5kVmFsaWRhdGVNb2R1bGUoKQogICAgICAg ICB9CiAgICAgICAgIG1fbW9kdWxlSW5mb3JtYXRpb24gPSBXVEZNb3ZlKHBhcnNlUmVzdWx0LT5t b2R1bGUpOwogICAgICAgICBtX2Z1bmN0aW9uTG9jYXRpb25JbkJpbmFyeSA9IFdURk1vdmUocGFy c2VSZXN1bHQtPmZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeSk7Ci0gICAgICAgIG1fZnVuY3Rpb25J bmRleFNwYWNlLnNpemUgPSBwYXJzZVJlc3VsdC0+ZnVuY3Rpb25JbmRleFNwYWNlLnNpemUoKTsK LSAgICAgICAgbV9mdW5jdGlvbkluZGV4U3BhY2UuYnVmZmVyID0gcGFyc2VSZXN1bHQtPmZ1bmN0 aW9uSW5kZXhTcGFjZS5yZWxlYXNlQnVmZmVyKCk7CisgICAgICAgIG1fbW9kdWxlU2lnbmF0dXJl SW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMgPSBXVEZNb3ZlKHBhcnNlUmVzdWx0LT5t b2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcyk7CiAgICAgfQog CiAgICAgZm9yICh1bnNpZ25lZCBmdW5jdGlvbkluZGV4ID0gMDsgZnVuY3Rpb25JbmRleCA8IG1f ZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5LnNpemUoKTsgKytmdW5jdGlvbkluZGV4KSB7CkBAIC04 OSw3ICs4OCw3IEBAIGJvb2wgUGxhbjo6cGFyc2VBbmRWYWxpZGF0ZU1vZHVsZSgpCiAgICAgICAg IFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9tb2R1bGVJbmZvcm1hdGlvbi0+aW50 ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXNbZnVuY3Rpb25JbmRleF07CiAgICAgICAgIGNv bnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlID0gU2lnbmF0dXJlSW5mb3JtYXRpb246OmdldChtX3Zt LCBzaWduYXR1cmVJbmRleCk7CiAKLSAgICAgICAgYXV0byB2YWxpZGF0aW9uUmVzdWx0ID0gdmFs aWRhdGVGdW5jdGlvbihtX3ZtLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0 dXJlLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZSwgKm1fbW9kdWxlSW5mb3JtYXRpb24pOworICAgICAg ICBhdXRvIHZhbGlkYXRpb25SZXN1bHQgPSB2YWxpZGF0ZUZ1bmN0aW9uKG1fdm0sIGZ1bmN0aW9u U3RhcnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWduYXR1cmUsICptX21vZHVsZUluZm9ybWF0aW9uLCBt X21vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzKTsKICAgICAg ICAgaWYgKCF2YWxpZGF0aW9uUmVzdWx0KSB7CiAgICAgICAgICAgICBpZiAodmVyYm9zZSkgewog ICAgICAgICAgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBmdW5jdGlvbkxlbmd0aDsg KytpKQpAQCAtMTI3LDcgKzEyNiw3IEBAIHZvaWQgUGxhbjo6cnVuKCkKICAgICAgICAgcmV0dXJu IHRydWU7CiAgICAgfTsKIAotICAgIGlmICghdHJ5UmVzZXJ2ZUNhcGFjaXR5KG1fd2FzbVRvSlNT dHVicywgbV9tb2R1bGVJbmZvcm1hdGlvbi0+aW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2Vz LnNpemUoKSwgIiBXZWJBc3NlbWJseSB0byBKYXZhU2NyaXB0IHN0dWJzIikKKyAgICBpZiAoIXRy eVJlc2VydmVDYXBhY2l0eShtX3dhc21FeGl0U3R1YnMsIG1fbW9kdWxlSW5mb3JtYXRpb24tPmlt cG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICIgV2ViQXNzZW1ibHkgdG8gSmF2 YVNjcmlwdCBzdHVicyIpCiAgICAgICAgIHx8ICF0cnlSZXNlcnZlQ2FwYWNpdHkobV91bmxpbmtl ZFdhc21Ub1dhc21DYWxscywgbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgpLCAiIHVu bGlua2VkIFdlYkFzc2VtYmx5IHRvIFdlYkFzc2VtYmx5IGNhbGxzIikKICAgICAgICAgfHwgIXRy eVJlc2VydmVDYXBhY2l0eShtX3dhc21JbnRlcm5hbEZ1bmN0aW9ucywgbV9mdW5jdGlvbkxvY2F0 aW9uSW5CaW5hcnkuc2l6ZSgpLCAiIFdlYkFzc2VtYmx5IGZ1bmN0aW9ucyIpCiAgICAgICAgIHx8 ICF0cnlSZXNlcnZlQ2FwYWNpdHkobV9jb21waWxhdGlvbkNvbnRleHRzLCBtX2Z1bmN0aW9uTG9j YXRpb25JbkJpbmFyeS5zaXplKCksICIgY29tcGlsYXRpb24gY29udGV4dHMiKSkKQEAgLTE0MSwx MiArMTQwLDExIEBAIHZvaWQgUGxhbjo6cnVuKCkKICAgICAgICAgSW1wb3J0KiBpbXBvcnQgPSAm bV9tb2R1bGVJbmZvcm1hdGlvbi0+aW1wb3J0c1tpbXBvcnRJbmRleF07CiAgICAgICAgIGlmIChp bXBvcnQtPmtpbmQgIT0gRXh0ZXJuYWxLaW5kOjpGdW5jdGlvbikKICAgICAgICAgICAgIGNvbnRp bnVlOwotICAgICAgICB1bnNpZ25lZCBpbXBvcnRGdW5jdGlvbkluZGV4ID0gbV93YXNtVG9KU1N0 dWJzLnNpemUoKTsKKyAgICAgICAgdW5zaWduZWQgaW1wb3J0RnVuY3Rpb25JbmRleCA9IG1fd2Fz bUV4aXRTdHVicy5zaXplKCk7CiAgICAgICAgIGlmICh2ZXJib3NlKQogICAgICAgICAgICAgZGF0 YUxvZ0xuKCJQcm9jZXNzaW5nIGltcG9ydCBmdW5jdGlvbiBudW1iZXIgIiwgaW1wb3J0RnVuY3Rp b25JbmRleCwgIjogIiwgaW1wb3J0LT5tb2R1bGUsICI6ICIsIGltcG9ydC0+ZmllbGQpOwogICAg ICAgICBTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1fbW9kdWxlSW5mb3JtYXRpb24t PmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5hdChpbXBvcnQtPmtpbmRJbmRleCk7Ci0g ICAgICAgIG1fd2FzbVRvSlNTdHVicy51bmNoZWNrZWRBcHBlbmQoaW1wb3J0U3R1YkdlbmVyYXRv cihtX3ZtLCBtX2NhbGxMaW5rSW5mb3MsIHNpZ25hdHVyZUluZGV4LCBpbXBvcnRGdW5jdGlvbklu ZGV4KSk7Ci0gICAgICAgIG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtpbXBvcnRG dW5jdGlvbkluZGV4XS5jb2RlID0gbV93YXNtVG9KU1N0dWJzW2ltcG9ydEZ1bmN0aW9uSW5kZXhd LmNvZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpOworICAgICAgICBtX3dhc21FeGl0U3R1YnMudW5j aGVja2VkQXBwZW5kKGV4aXRTdHViR2VuZXJhdG9yKG1fdm0sIG1fY2FsbExpbmtJbmZvcywgc2ln bmF0dXJlSW5kZXgsIGltcG9ydEZ1bmN0aW9uSW5kZXgpKTsKICAgICB9CiAKICAgICBtX2N1cnJl bnRJbmRleCA9IDA7CkBAIC0xNjcsMTIgKzE2NSwxMiBAQCB2b2lkIFBsYW46OnJ1bigpCiAgICAg ICAgICAgICBBU1NFUlQoZnVuY3Rpb25MZW5ndGggPD0gbV9zb3VyY2VMZW5ndGgpOwogICAgICAg ICAgICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtX21vZHVsZUluZm9ybWF0aW9u LT5pbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4XTsKICAgICAg ICAgICAgIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlID0gU2lnbmF0dXJlSW5mb3JtYXRpb246 OmdldChtX3ZtLCBzaWduYXR1cmVJbmRleCk7Ci0gICAgICAgICAgICB1bnNpZ25lZCBmdW5jdGlv bkluZGV4U3BhY2UgPSBtX3dhc21Ub0pTU3R1YnMuc2l6ZSgpICsgZnVuY3Rpb25JbmRleDsKLSAg ICAgICAgICAgIEFTU0VSVF9VTlVTRUQoZnVuY3Rpb25JbmRleFNwYWNlLCBtX2Z1bmN0aW9uSW5k ZXhTcGFjZS5idWZmZXIuZ2V0KClbZnVuY3Rpb25JbmRleFNwYWNlXS5zaWduYXR1cmVJbmRleCA9 PSBzaWduYXR1cmVJbmRleCk7Ci0gICAgICAgICAgICBBU1NFUlQodmFsaWRhdGVGdW5jdGlvbiht X3ZtLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBtX2Z1bmN0aW9u SW5kZXhTcGFjZSwgKm1fbW9kdWxlSW5mb3JtYXRpb24pKTsKKyAgICAgICAgICAgIHVuc2lnbmVk IGZ1bmN0aW9uSW5kZXhTcGFjZSA9IG1fd2FzbUV4aXRTdHVicy5zaXplKCkgKyBmdW5jdGlvbklu ZGV4OworICAgICAgICAgICAgQVNTRVJUX1VOVVNFRChmdW5jdGlvbkluZGV4U3BhY2UsIG1fbW9k dWxlSW5mb3JtYXRpb24tPnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5j dGlvbkluZGV4U3BhY2UpID09IHNpZ25hdHVyZUluZGV4KTsKKyAgICAgICAgICAgIEFTU0VSVCh2 YWxpZGF0ZUZ1bmN0aW9uKG1fdm0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWdu YXR1cmUsICptX21vZHVsZUluZm9ybWF0aW9uLCBtX21vZHVsZVNpZ25hdHVyZUluZGljZXNUb1Vu aXF1ZWRTaWduYXR1cmVJbmRpY2VzKSk7CiAKICAgICAgICAgICAgIG1fdW5saW5rZWRXYXNtVG9X YXNtQ2FsbHNbZnVuY3Rpb25JbmRleF0gPSBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4o KTsKLSAgICAgICAgICAgIGF1dG8gcGFyc2VBbmRDb21waWxlUmVzdWx0ID0gcGFyc2VBbmRDb21w aWxlKCptX3ZtLCBtX2NvbXBpbGF0aW9uQ29udGV4dHNbZnVuY3Rpb25JbmRleF0sIGZ1bmN0aW9u U3RhcnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWduYXR1cmUsIG1fdW5saW5rZWRXYXNtVG9XYXNtQ2Fs bHNbZnVuY3Rpb25JbmRleF0sIG1fZnVuY3Rpb25JbmRleFNwYWNlLCAqbV9tb2R1bGVJbmZvcm1h dGlvbik7CisgICAgICAgICAgICBhdXRvIHBhcnNlQW5kQ29tcGlsZVJlc3VsdCA9IHBhcnNlQW5k Q29tcGlsZSgqbV92bSwgbV9jb21waWxhdGlvbkNvbnRleHRzW2Z1bmN0aW9uSW5kZXhdLCBmdW5j dGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBtX3VubGlua2VkV2FzbVRvV2Fz bUNhbGxzW2Z1bmN0aW9uSW5kZXhdLCAqbV9tb2R1bGVJbmZvcm1hdGlvbiwgbV9tb2R1bGVTaWdu YXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcyk7CiAKICAgICAgICAgICAgIGlm IChVTkxJS0VMWSghcGFyc2VBbmRDb21waWxlUmVzdWx0KSkgewogICAgICAgICAgICAgICAgIGF1 dG8gbG9ja2VyID0gaG9sZExvY2sobV9sb2NrKTsKQEAgLTIwOSwxMCArMjA3LDEyIEBAIHZvaWQg UGxhbjo6cnVuKCkKICAgICBmb3IgKHVpbnQzMl90IGZ1bmN0aW9uSW5kZXggPSAwOyBmdW5jdGlv bkluZGV4IDwgbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgpOyBmdW5jdGlvbkluZGV4 KyspIHsKICAgICAgICAgewogICAgICAgICAgICAgQ29tcGlsYXRpb25Db250ZXh0JiBjb250ZXh0 ID0gbV9jb21waWxhdGlvbkNvbnRleHRzW2Z1bmN0aW9uSW5kZXhdOworICAgICAgICAgICAgU2ln bmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtX21vZHVsZUluZm9ybWF0aW9uLT5pbnRlcm5h bEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4XTsKKyAgICAgICAgICAgIFN0 cmluZyBzaWduYXR1cmVEZXNjcmlwdGlvbiA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92 bSwgc2lnbmF0dXJlSW5kZXgpLT50b1N0cmluZygpOwogICAgICAgICAgICAgewogICAgICAgICAg ICAgICAgIExpbmtCdWZmZXIgbGlua0J1ZmZlcigqbV92bSwgKmNvbnRleHQud2FzbUVudHJ5cG9p bnRKSVQsIG51bGxwdHIpOwogICAgICAgICAgICAgICAgIG1fd2FzbUludGVybmFsRnVuY3Rpb25z W2Z1bmN0aW9uSW5kZXhdLT53YXNtRW50cnlwb2ludC5jb21waWxhdGlvbiA9Ci0gICAgICAgICAg ICAgICAgICAgIHN0ZDo6bWFrZV91bmlxdWU8QjM6OkNvbXBpbGF0aW9uPihGSU5BTElaRV9DT0RF KGxpbmtCdWZmZXIsICgiV2FzbSBmdW5jdGlvbiIpKSwgV1RGTW92ZShjb250ZXh0Lndhc21FbnRy eXBvaW50Qnlwcm9kdWN0cykpOworICAgICAgICAgICAgICAgICAgICBzdGQ6Om1ha2VfdW5pcXVl PEIzOjpDb21waWxhdGlvbj4oRklOQUxJWkVfQ09ERShsaW5rQnVmZmVyLCAoIldlYkFzc2VtYmx5 IGZ1bmN0aW9uWyVpXSAlcyIsIGZ1bmN0aW9uSW5kZXgsIHNpZ25hdHVyZURlc2NyaXB0aW9uLmFz Y2lpKCkuZGF0YSgpKSksIFdURk1vdmUoY29udGV4dC53YXNtRW50cnlwb2ludEJ5cHJvZHVjdHMp KTsKICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAgewpAQCAtMjIwLDEyICsyMjAsOSBAQCB2 b2lkIFBsYW46OnJ1bigpCiAgICAgICAgICAgICAgICAgbGlua0J1ZmZlci5saW5rKGNvbnRleHQu anNFbnRyeXBvaW50VG9XYXNtRW50cnlwb2ludENhbGwsIEZ1bmN0aW9uUHRyKG1fd2FzbUludGVy bmFsRnVuY3Rpb25zW2Z1bmN0aW9uSW5kZXhdLT53YXNtRW50cnlwb2ludC5jb21waWxhdGlvbi0+ Y29kZSgpLmV4ZWN1dGFibGVBZGRyZXNzKCkpKTsKIAogICAgICAgICAgICAgICAgIG1fd2FzbUlu dGVybmFsRnVuY3Rpb25zW2Z1bmN0aW9uSW5kZXhdLT5qc1RvV2FzbUVudHJ5cG9pbnQuY29tcGls YXRpb24gPQotICAgICAgICAgICAgICAgICAgICBzdGQ6Om1ha2VfdW5pcXVlPEIzOjpDb21waWxh dGlvbj4oRklOQUxJWkVfQ09ERShsaW5rQnVmZmVyLCAoIldhc20gSlMgZW50cnlwb2ludCIpKSwg V1RGTW92ZShjb250ZXh0LmpzRW50cnlwb2ludEJ5cHJvZHVjdHMpKTsKKyAgICAgICAgICAgICAg ICAgICAgc3RkOjptYWtlX3VuaXF1ZTxCMzo6Q29tcGlsYXRpb24+KEZJTkFMSVpFX0NPREUobGlu a0J1ZmZlciwgKCJKYXZhU2NyaXB0LT5XZWJBc3NlbWJseSBlbnRyeXBvaW50WyVpXSAlcyIsIGZ1 bmN0aW9uSW5kZXgsIHNpZ25hdHVyZURlc2NyaXB0aW9uLmFzY2lpKCkuZGF0YSgpKSksIFdURk1v dmUoY29udGV4dC5qc0VudHJ5cG9pbnRCeXByb2R1Y3RzKSk7CiAgICAgICAgICAgICB9CiAgICAg ICAgIH0KLQotICAgICAgICB1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2UgPSBtX3dhc21Ub0pT U3R1YnMuc2l6ZSgpICsgZnVuY3Rpb25JbmRleDsKLSAgICAgICAgbV9mdW5jdGlvbkluZGV4U3Bh Y2UuYnVmZmVyLmdldCgpW2Z1bmN0aW9uSW5kZXhTcGFjZV0uY29kZSA9IG1fd2FzbUludGVybmFs RnVuY3Rpb25zW2Z1bmN0aW9uSW5kZXhdLT53YXNtRW50cnlwb2ludC5jb21waWxhdGlvbi0+Y29k ZSgpLmV4ZWN1dGFibGVBZGRyZXNzKCk7CiAgICAgfQogCiAgICAgaWYgKHZlcmJvc2UgfHwgT3B0 aW9uczo6cmVwb3J0Q29tcGlsZVRpbWVzKCkpIHsKQEAgLTIzNSw4ICsyMzIsMTkgQEAgdm9pZCBQ bGFuOjpydW4oKQogCiAgICAgLy8gUGF0Y2ggdGhlIGNhbGwgc2l0ZXMgZm9yIGVhY2ggV2ViQXNz ZW1ibHkgZnVuY3Rpb24uCiAgICAgZm9yIChhdXRvJiB1bmxpbmtlZCA6IG1fdW5saW5rZWRXYXNt VG9XYXNtQ2FsbHMpIHsKLSAgICAgICAgZm9yIChhdXRvJiBjYWxsIDogdW5saW5rZWQpCi0gICAg ICAgICAgICBNYWNyb0Fzc2VtYmxlcjo6cmVwYXRjaENhbGwoY2FsbC5jYWxsTG9jYXRpb24sIENv ZGVMb2NhdGlvbkxhYmVsKG1fZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtjYWxsLmZ1 bmN0aW9uSW5kZXhdLmNvZGUpKTsKKyAgICAgICAgZm9yIChhdXRvJiBjYWxsIDogdW5saW5rZWQp IHsKKyAgICAgICAgICAgIHZvaWQqIGV4ZWN1dGFibGVBZGRyZXNzOworICAgICAgICAgICAgaWYg KG1fbW9kdWxlSW5mb3JtYXRpb24tPmlzSW1wb3J0ZWRGdW5jdGlvbkZyb21GdW5jdGlvbkluZGV4 U3BhY2UoY2FsbC5mdW5jdGlvbkluZGV4KSkgeworICAgICAgICAgICAgICAgIC8vIEZJWE1FIGlt cG9ydHMgY291bGQgaGF2ZSBiZWVuIGxpbmtlZCBpbiBCMywgaW5zdGVhZCBvZiBnZW5lcmF0aW5n IGEgcGF0Y2hwb2ludC4gVGhpcyBjb25kaXRpb24gc2hvdWxkIGJlIHJlcGxhY2VkIGJ5IGEgUkVM RUFTRV9BU1NFUlQuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjY0 NjIKKyAgICAgICAgICAgICAgICBleGVjdXRhYmxlQWRkcmVzcyA9IGNhbGwudGFyZ2V0ID09IFVu bGlua2VkV2FzbVRvV2FzbUNhbGw6OlRhcmdldDo6dG9KUworICAgICAgICAgICAgICAgICAgICA/ IG1fd2FzbUV4aXRTdHVicy5hdChjYWxsLmZ1bmN0aW9uSW5kZXgpLndhc21Ub0pTLmNvZGUoKS5l eGVjdXRhYmxlQWRkcmVzcygpCisgICAgICAgICAgICAgICAgICAgIDogbV93YXNtRXhpdFN0dWJz LmF0KGNhbGwuZnVuY3Rpb25JbmRleCkud2FzbVRvV2FzbS5jb2RlKCkuZXhlY3V0YWJsZUFkZHJl c3MoKTsKKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgQVNTRVJUKGNhbGwu dGFyZ2V0ICE9IFVubGlua2VkV2FzbVRvV2FzbUNhbGw6OlRhcmdldDo6dG9KUyk7CisgICAgICAg ICAgICAgICAgZXhlY3V0YWJsZUFkZHJlc3MgPSBtX3dhc21JbnRlcm5hbEZ1bmN0aW9ucy5hdChj YWxsLmZ1bmN0aW9uSW5kZXggLSBtX3dhc21FeGl0U3R1YnMuc2l6ZSgpKS0+d2FzbUVudHJ5cG9p bnQuY29tcGlsYXRpb24tPmNvZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpOworICAgICAgICAgICAg fQorICAgICAgICAgICAgTWFjcm9Bc3NlbWJsZXI6OnJlcGF0Y2hDYWxsKGNhbGwuY2FsbExvY2F0 aW9uLCBDb2RlTG9jYXRpb25MYWJlbChleGVjdXRhYmxlQWRkcmVzcykpOworICAgICAgICB9CiAg ICAgfQogCiAgICAgbV9mYWlsZWQgPSBmYWxzZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21QbGFuLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt UGxhbi5oCmluZGV4IDNiYjAxYzguLjY5ODBiZGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21QbGFuLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbVBsYW4uaApAQCAtODYsMjYgKzg2LDIwIEBAIHB1YmxpYzoKICAgICAgICAgcmV0dXJuIFdU Rk1vdmUobV9jYWxsTGlua0luZm9zKTsKICAgICB9CiAKLSAgICBWZWN0b3I8V2FzbVRvSlNTdHVi PiYmIHRha2VXYXNtVG9KU1N0dWJzKCkKKyAgICBWZWN0b3I8V2FzbUV4aXRTdHVicz4mJiB0YWtl V2FzbUV4aXRTdHVicygpCiAgICAgewogICAgICAgICBSRUxFQVNFX0FTU0VSVCghZmFpbGVkKCkp OwotICAgICAgICByZXR1cm4gV1RGTW92ZShtX3dhc21Ub0pTU3R1YnMpOwotICAgIH0KLQotICAg IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmIHRha2VGdW5jdGlvbkluZGV4U3BhY2UoKQot ICAgIHsKLSAgICAgICAgUkVMRUFTRV9BU1NFUlQoIWZhaWxlZCgpKTsKLSAgICAgICAgcmV0dXJu IFdURk1vdmUobV9mdW5jdGlvbkluZGV4U3BhY2UpOworICAgICAgICByZXR1cm4gV1RGTW92ZSht X3dhc21FeGl0U3R1YnMpOwogICAgIH0KIAogcHJpdmF0ZToKICAgICBzdGQ6OnVuaXF1ZV9wdHI8 TW9kdWxlSW5mb3JtYXRpb24+IG1fbW9kdWxlSW5mb3JtYXRpb247CiAgICAgVmVjdG9yPEZ1bmN0 aW9uTG9jYXRpb25JbkJpbmFyeT4gbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnk7CisgICAgVmVj dG9yPFNpZ25hdHVyZUluZGV4PiBtX21vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWdu YXR1cmVJbmRpY2VzOwogICAgIEJhZzxDYWxsTGlua0luZm8+IG1fY2FsbExpbmtJbmZvczsKLSAg ICBWZWN0b3I8V2FzbVRvSlNTdHViPiBtX3dhc21Ub0pTU3R1YnM7CisgICAgVmVjdG9yPFdhc21F eGl0U3R1YnM+IG1fd2FzbUV4aXRTdHViczsKICAgICBWZWN0b3I8c3RkOjp1bmlxdWVfcHRyPFdh c21JbnRlcm5hbEZ1bmN0aW9uPj4gbV93YXNtSW50ZXJuYWxGdW5jdGlvbnM7CiAgICAgVmVjdG9y PENvbXBpbGF0aW9uQ29udGV4dD4gbV9jb21waWxhdGlvbkNvbnRleHRzOwotICAgIEltbXV0YWJs ZUZ1bmN0aW9uSW5kZXhTcGFjZSBtX2Z1bmN0aW9uSW5kZXhTcGFjZTsKIAogICAgIFZNKiBtX3Zt OwogICAgIFZlY3RvcjxWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4+IG1fdW5saW5rZWRX YXNtVG9XYXNtQ2FsbHM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9X YXNtU2lnbmF0dXJlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1 cmUuY3BwCmluZGV4IDZkNWIxZjYuLjA5NjZkYWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL1dhc21TaWduYXR1cmUuY3BwCkBAIC00MSwxMiArNDEsMjIgQEAgY29uc3QgYm9vbCB2 ZXJib3NlID0gZmFsc2U7CiAKIGNvbnN0IGNvbnN0ZXhwciBTaWduYXR1cmVJbmRleCBTaWduYXR1 cmU6OmludmFsaWRJbmRleDsKIAorU3RyaW5nIFNpZ25hdHVyZTo6dG9TdHJpbmcoKSBjb25zdAor eworICAgIFN0cmluZyByZXN1bHQobWFrZVN0cmluZyhyZXR1cm5UeXBlKCkpKTsKKyAgICByZXN1 bHQuYXBwZW5kKCIgKCIpOworICAgIGZvciAoU2lnbmF0dXJlQXJnQ291bnQgYXJnID0gMDsgYXJn IDwgYXJndW1lbnRDb3VudCgpOyArK2FyZykgeworICAgICAgICBpZiAoYXJnKQorICAgICAgICAg ICAgcmVzdWx0LmFwcGVuZCgiLCAiKTsKKyAgICAgICAgcmVzdWx0LmFwcGVuZChtYWtlU3RyaW5n KGFyZ3VtZW50KGFyZykpKTsKKyAgICB9CisgICAgcmVzdWx0LmFwcGVuZCgnKScpOworICAgIHJl dHVybiByZXN1bHQ7Cit9CisKIHZvaWQgU2lnbmF0dXJlOjpkdW1wKFByaW50U3RyZWFtJiBvdXQp IGNvbnN0CiB7Ci0gICAgb3V0LnByaW50KG1ha2VTdHJpbmcocmV0dXJuVHlwZSgpKSwgIiAoIik7 Ci0gICAgZm9yIChTaWduYXR1cmVBcmdDb3VudCBhcmcgPSAwOyBhcmcgPCBhcmd1bWVudENvdW50 KCk7ICsrYXJnKQotICAgICAgICBvdXQucHJpbnQoKGFyZyA/ICIsICIgOiAiIiksIG1ha2VTdHJp bmcoYXJndW1lbnQoYXJnKSkpOwotICAgIG91dC5wcmludCgiKSIpOworICAgIG91dC5wcmludCh0 b1N0cmluZygpKTsKIH0KIAogdW5zaWduZWQgU2lnbmF0dXJlOjpoYXNoKCkgY29uc3QKZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuaCBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuaAppbmRleCAwZDZjN2I1Li40ZDQz ZmZjIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJl LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5oCkBAIC04 Miw2ICs4Miw3IEBAIHB1YmxpYzoKICAgICB9CiAgICAgVHlwZSBhcmd1bWVudChTaWduYXR1cmVB cmdDb3VudCBpKSBjb25zdCB7IHJldHVybiBjb25zdF9jYXN0PFNpZ25hdHVyZSo+KHRoaXMpLT5h cmd1bWVudChpKTsgfQogCisgICAgV1RGOjpTdHJpbmcgdG9TdHJpbmcoKSBjb25zdDsKICAgICB2 b2lkIGR1bXAoV1RGOjpQcmludFN0cmVhbSYgb3V0KSBjb25zdDsKICAgICBib29sIG9wZXJhdG9y PT0oY29uc3QgU2lnbmF0dXJlJiByaHMpIGNvbnN0CiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5jcHAKaW5kZXggZTMyMTYxMy4uNzVkMzgyNiAxMDA2NDQK LS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmNwcAorKysgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwCkBAIC0zODEsMTAgKzM4 MSwxMCBAQCB2b2lkIFZhbGlkYXRlOjpkdW1wKGNvbnN0IFZlY3RvcjxDb250cm9sRW50cnk+JiBj b250cm9sU3RhY2ssIGNvbnN0IEV4cHJlc3Npb25MaQogICAgIGRhdGFMb2dMbigpOwogfQogCi1F eHBlY3RlZDx2b2lkLCBTdHJpbmc+IHZhbGlkYXRlRnVuY3Rpb24oVk0qIHZtLCBjb25zdCB1aW50 OF90KiBzb3VyY2UsIHNpemVfdCBsZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBj b25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIGZ1bmN0aW9uSW5kZXhTcGFjZSwgY29u c3QgTW9kdWxlSW5mb3JtYXRpb24mIG1vZHVsZSkKK0V4cGVjdGVkPHZvaWQsIFN0cmluZz4gdmFs aWRhdGVGdW5jdGlvbihWTSogdm0sIGNvbnN0IHVpbnQ4X3QqIHNvdXJjZSwgc2l6ZV90IGxlbmd0 aCwgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBt b2R1bGUsIGNvbnN0IFZlY3RvcjxTaWduYXR1cmVJbmRleD4mIG1vZHVsZVNpZ25hdHVyZUluZGlj ZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzKQogewogICAgIFZhbGlkYXRlIGNvbnRleHQobW9k dWxlKTsKLSAgICBGdW5jdGlvblBhcnNlcjxWYWxpZGF0ZT4gdmFsaWRhdG9yKHZtLCBjb250ZXh0 LCBzb3VyY2UsIGxlbmd0aCwgc2lnbmF0dXJlLCBmdW5jdGlvbkluZGV4U3BhY2UsIG1vZHVsZSk7 CisgICAgRnVuY3Rpb25QYXJzZXI8VmFsaWRhdGU+IHZhbGlkYXRvcih2bSwgY29udGV4dCwgc291 cmNlLCBsZW5ndGgsIHNpZ25hdHVyZSwgbW9kdWxlLCBtb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9V bmlxdWVkU2lnbmF0dXJlSW5kaWNlcyk7CiAgICAgV0FTTV9GQUlMX0lGX0hFTFBFUl9GQUlMUyh2 YWxpZGF0b3IucGFyc2UoKSk7CiAgICAgcmV0dXJuIHsgfTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5oIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbVZhbGlkYXRlLmgKaW5kZXggMTQ4MjFmMi4uNzNlN2Q4NyAxMDA2NDQKLS0t IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmgKKysrIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmgKQEAgLTM2LDcgKzM2LDcgQEAgY2xh c3MgVk07CiAKIG5hbWVzcGFjZSBXYXNtIHsKIAotRXhwZWN0ZWQ8dm9pZCwgU3RyaW5nPiB2YWxp ZGF0ZUZ1bmN0aW9uKFZNKiwgY29uc3QgdWludDhfdCosIHNpemVfdCwgY29uc3QgU2lnbmF0dXJl KiwgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiwgY29uc3QgTW9kdWxlSW5mb3Jt YXRpb24mKTsKK0V4cGVjdGVkPHZvaWQsIFN0cmluZz4gdmFsaWRhdGVGdW5jdGlvbihWTSosIGNv bnN0IHVpbnQ4X3QqLCBzaXplX3QsIGNvbnN0IFNpZ25hdHVyZSosIGNvbnN0IE1vZHVsZUluZm9y bWF0aW9uJiwgY29uc3QgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiYpOwogCiB9IH0gLy8gbmFtZXNw YWNlIEpTQzo6V2FzbQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9q cy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pz L0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5oCmluZGV4IDkyOGY0MjMuLjk5YTJjOTAgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5o CisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5j ZS5oCkBAIC04Niw5ICs4NiwxMSBAQCBwdWJsaWM6CiAgICAgICAgIHJldHVybiBvZmZzZXRPZklt cG9ydEZ1bmN0aW9ucygpICsgc2l6ZW9mKFdyaXRlQmFycmllcjxKU0NlbGw+KSAqIGlkeDsKICAg ICB9CiAKLSAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mVGFibGUoKSB7IHJldHVybiBPQkpF Q1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseUluc3RhbmNlLCBtX3RhYmxlKTsgfQogICAgIHN0YXRp YyBwdHJkaWZmX3Qgb2Zmc2V0T2ZNZW1vcnkoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNX ZWJBc3NlbWJseUluc3RhbmNlLCBtX21lbW9yeSk7IH0KKyAgICBzdGF0aWMgcHRyZGlmZl90IG9m ZnNldE9mVGFibGUoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseUluc3Rh bmNlLCBtX3RhYmxlKTsgfQogICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZHbG9iYWxzKCkg eyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKEpTV2ViQXNzZW1ibHlJbnN0YW5jZSwgbV9nbG9iYWxz KTsgfQorICAgIHN0YXRpYyBzaXplX3Qgb2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbnMoKSB7IHJldHVy biBXVEY6OnJvdW5kVXBUb011bHRpcGxlT2Y8c2l6ZW9mKFdyaXRlQmFycmllcjxKU0NlbGw+KT4o c2l6ZW9mKEpTV2ViQXNzZW1ibHlJbnN0YW5jZSkpOyB9CisgICAgc3RhdGljIHNpemVfdCBvZmZz ZXRPZkltcG9ydEZ1bmN0aW9uKHNpemVfdCBpbXBvcnRGdW5jdGlvbk51bSkgeyByZXR1cm4gb2Zm c2V0T2ZJbXBvcnRGdW5jdGlvbnMoKSArIGltcG9ydEZ1bmN0aW9uTnVtICogc2l6ZW9mKHNpemVv ZihXcml0ZUJhcnJpZXI8SlNDZWxsPikpOyB9CiAKIHByb3RlY3RlZDoKICAgICBKU1dlYkFzc2Vt Ymx5SW5zdGFuY2UoVk0mLCBTdHJ1Y3R1cmUqLCB1bnNpZ25lZCBudW1JbXBvcnRGdW5jdGlvbnMp OwpAQCAtOTYsMTEgKzk4LDYgQEAgcHJvdGVjdGVkOgogICAgIHN0YXRpYyB2b2lkIGRlc3Ryb3ko SlNDZWxsKik7CiAgICAgc3RhdGljIHZvaWQgdmlzaXRDaGlsZHJlbihKU0NlbGwqLCBTbG90Vmlz aXRvciYpOwogCi0gICAgc3RhdGljIHNpemVfdCBvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucygpCi0g ICAgewotICAgICAgICByZXR1cm4gV1RGOjpyb3VuZFVwVG9NdWx0aXBsZU9mPHNpemVvZihXcml0 ZUJhcnJpZXI8SlNDZWxsPik+KHNpemVvZihKU1dlYkFzc2VtYmx5SW5zdGFuY2UpKTsKLSAgICB9 Ci0KICAgICBzdGF0aWMgc2l6ZV90IGFsbG9jYXRpb25TaXplKHVuc2lnbmVkIG51bUltcG9ydEZ1 bmN0aW9ucykKICAgICB7CiAgICAgICAgIHJldHVybiBvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucygp ICsgc2l6ZW9mKFdyaXRlQmFycmllcjxKU0NlbGw+KSAqIG51bUltcG9ydEZ1bmN0aW9uczsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1v cnkuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9y eS5jcHAKaW5kZXggNTI4YWI2OS4uNGM0Y2MzZSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5jcHAKKysrIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5jcHAKQEAgLTM3LDkgKzM3LDkg QEAgbmFtZXNwYWNlIEpTQyB7CiAKIGNvbnN0IENsYXNzSW5mbyBKU1dlYkFzc2VtYmx5TWVtb3J5 OjpzX2luZm8gPSB7ICJXZWJBc3NlbWJseS5NZW1vcnkiLCAmQmFzZTo6c19pbmZvLCAwLCBDUkVB VEVfTUVUSE9EX1RBQkxFKEpTV2ViQXNzZW1ibHlNZW1vcnkpIH07CiAKLUpTV2ViQXNzZW1ibHlN ZW1vcnkqIEpTV2ViQXNzZW1ibHlNZW1vcnk6OmNyZWF0ZShWTSYgdm0sIFN0cnVjdHVyZSogc3Ry dWN0dXJlLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiYmIG1lbW9yeSkKK0pTV2ViQXNz ZW1ibHlNZW1vcnkqIEpTV2ViQXNzZW1ibHlNZW1vcnk6OmNyZWF0ZShWTSYgdm0sIFN0cnVjdHVy ZSogc3RydWN0dXJlLCBXYXNtOjpNZW1vcnkmJiBtZW1vcnkpCiB7Ci0gICAgYXV0byogaW5zdGFu Y2UgPSBuZXcgKE5vdE51bGwsIGFsbG9jYXRlQ2VsbDxKU1dlYkFzc2VtYmx5TWVtb3J5Pih2bS5o ZWFwKSkgSlNXZWJBc3NlbWJseU1lbW9yeSh2bSwgc3RydWN0dXJlLCBXVEZNb3ZlKG1lbW9yeSkp OworICAgIGF1dG8qIGluc3RhbmNlID0gbmV3IChOb3ROdWxsLCBhbGxvY2F0ZUNlbGw8SlNXZWJB c3NlbWJseU1lbW9yeT4odm0uaGVhcCkpIEpTV2ViQXNzZW1ibHlNZW1vcnkodm0sIHN0cnVjdHVy ZSwgc3RkOjpmb3J3YXJkPFdhc206Ok1lbW9yeT4obWVtb3J5KSk7CiAgICAgaW5zdGFuY2UtPmZp bmlzaENyZWF0aW9uKHZtKTsKICAgICByZXR1cm4gaW5zdGFuY2U7CiB9CkBAIC00OSw3ICs0OSw3 IEBAIFN0cnVjdHVyZSogSlNXZWJBc3NlbWJseU1lbW9yeTo6Y3JlYXRlU3RydWN0dXJlKFZNJiB2 bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iCiAgICAgcmV0dXJuIFN0cnVjdHVyZTo6Y3JlYXRl KHZtLCBnbG9iYWxPYmplY3QsIHByb3RvdHlwZSwgVHlwZUluZm8oT2JqZWN0VHlwZSwgU3RydWN0 dXJlRmxhZ3MpLCBpbmZvKCkpOwogfQogCi1KU1dlYkFzc2VtYmx5TWVtb3J5OjpKU1dlYkFzc2Vt Ymx5TWVtb3J5KFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0cjxX YXNtOjpNZW1vcnk+JiYgbWVtb3J5KQorSlNXZWJBc3NlbWJseU1lbW9yeTo6SlNXZWJBc3NlbWJs eU1lbW9yeShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBXYXNtOjpNZW1vcnkmJiBtZW1v cnkpCiAgICAgOiBCYXNlKHZtLCBzdHJ1Y3R1cmUpCiAgICAgLCBtX21lbW9yeShXVEZNb3ZlKG1l bW9yeSkpCiB7CkBAIC03Miw3ICs3Miw3IEBAIEpTQXJyYXlCdWZmZXIqIEpTV2ViQXNzZW1ibHlN ZW1vcnk6OmJ1ZmZlcihWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QpCiAgICAg YXV0byBkZXN0cnVjdG9yID0gW10gKHZvaWQqKSB7CiAgICAgICAgIC8vIFdlIGRvbid0IG5lZWQg dG8gZG8gYW55dGhpbmcgaGVyZSB0byBkZXN0cm95IHRoZSBtZW1vcnkuCiAgICAgICAgIC8vIFRo ZSBBcnJheUJ1ZmZlciBiYWNraW5nIHRoZSBKU0FycmF5QnVmZmVyIGlzIG9ubHkgb3duZWQgYnkg dXMsCi0gICAgICAgIC8vIHNvIHdlIGd1YXJhbnRlZSBpdHMgbGlmZWN5bGNlLgorICAgICAgICAv LyBzbyB3ZSBndWFyYW50ZWUgaXRzIGxpZmVjeWNsZS4KICAgICB9OwogICAgIG1fYnVmZmVyID0g QXJyYXlCdWZmZXI6OmNyZWF0ZUZyb21CeXRlcyhtZW1vcnkoKS0+bWVtb3J5KCksIG1lbW9yeSgp LT5zaXplKCksIFdURk1vdmUoZGVzdHJ1Y3RvcikpOwogICAgIG1fYnVmZmVyV3JhcHBlci5zZXQo dm0sIHRoaXMsIEpTQXJyYXlCdWZmZXI6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LT5tX2FycmF5 QnVmZmVyU3RydWN0dXJlLmdldCgpLCBtX2J1ZmZlci5nZXQoKSkpOwpAQCAtODUsNyArODUsNyBA QCBXYXNtOjpQYWdlQ291bnQgSlNXZWJBc3NlbWJseU1lbW9yeTo6Z3JvdyhFeGVjU3RhdGUqIGV4 ZWMsIHVpbnQzMl90IGRlbHRhLCBib29sCiAgICAgVk0mIHZtID0gZXhlYy0+dm0oKTsKICAgICBh dXRvIHRocm93U2NvcGUgPSBERUNMQVJFX1RIUk9XX1NDT1BFKHZtKTsKIAotICAgIFdhc206OlBh Z2VDb3VudCBvbGRQYWdlQ291bnQgPSBtX21lbW9yeS0+c2l6ZUluUGFnZXMoKTsKKyAgICBXYXNt OjpQYWdlQ291bnQgb2xkUGFnZUNvdW50ID0gbWVtb3J5KCktPnNpemVJblBhZ2VzKCk7CiAKICAg ICBpZiAoIVdhc206OlBhZ2VDb3VudDo6aXNWYWxpZChkZWx0YSkpIHsKICAgICAgICAgaWYgKHNo b3VsZFRocm93RXhjZXB0aW9uc09uRmFpbHVyZSkKQEAgLTEwMSw3ICsxMDEsNyBAQCBXYXNtOjpQ YWdlQ291bnQgSlNXZWJBc3NlbWJseU1lbW9yeTo6Z3JvdyhFeGVjU3RhdGUqIGV4ZWMsIHVpbnQz Ml90IGRlbHRhLCBib29sCiAgICAgfQogCiAgICAgaWYgKGRlbHRhKSB7Ci0gICAgICAgIGJvb2wg c3VjY2VzcyA9IG1fbWVtb3J5LT5ncm93KG5ld1NpemUpOworICAgICAgICBib29sIHN1Y2Nlc3Mg PSBtZW1vcnkoKS0+Z3JvdyhuZXdTaXplKTsKICAgICAgICAgaWYgKCFzdWNjZXNzKSB7CiAgICAg ICAgICAgICBpZiAoc2hvdWxkVGhyb3dFeGNlcHRpb25zT25GYWlsdXJlKQogICAgICAgICAgICAg ICAgIHRocm93RXhjZXB0aW9uKGV4ZWMsIHRocm93U2NvcGUsIGNyZWF0ZU91dE9mTWVtb3J5RXJy b3IoZXhlYykpOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNX ZWJBc3NlbWJseU1lbW9yeS5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJB c3NlbWJseU1lbW9yeS5oCmluZGV4IDI4Nzk3YzYuLmI0MjJmNDggMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuaAorKysgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmgKQEAgLTQxLDI1 ICs0MSwyNiBAQCBjbGFzcyBKU1dlYkFzc2VtYmx5TWVtb3J5IDogcHVibGljIEpTRGVzdHJ1Y3Rp YmxlT2JqZWN0IHsKIHB1YmxpYzoKICAgICB0eXBlZGVmIEpTRGVzdHJ1Y3RpYmxlT2JqZWN0IEJh c2U7CiAKLSAgICBzdGF0aWMgSlNXZWJBc3NlbWJseU1lbW9yeSogY3JlYXRlKFZNJiwgU3RydWN0 dXJlKiwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1lbW9yeT4mJik7CisgICAgc3RhdGljIEpTV2Vi QXNzZW1ibHlNZW1vcnkqIGNyZWF0ZShWTSYsIFN0cnVjdHVyZSosIFdhc206Ok1lbW9yeSYmKTsK ICAgICBzdGF0aWMgU3RydWN0dXJlKiBjcmVhdGVTdHJ1Y3R1cmUoVk0mLCBKU0dsb2JhbE9iamVj dCosIEpTVmFsdWUpOwogCiAgICAgREVDTEFSRV9JTkZPOwogCi0gICAgV2FzbTo6TWVtb3J5KiBt ZW1vcnkoKSB7IHJldHVybiBtX21lbW9yeS5nZXQoKTsgfQorICAgIFdhc206Ok1lbW9yeSogbWVt b3J5KCkgeyByZXR1cm4gJm1fbWVtb3J5OyB9CiAgICAgSlNBcnJheUJ1ZmZlciogYnVmZmVyKFZN JiB2bSwgSlNHbG9iYWxPYmplY3QqKTsKICAgICBXYXNtOjpQYWdlQ291bnQgZ3JvdyhFeGVjU3Rh dGUqLCB1aW50MzJfdCBkZWx0YSwgYm9vbCBzaG91bGRUaHJvd0V4Y2VwdGlvbnNPbkZhaWx1cmUp OwogCi0gICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZk1lbW9yeSgpIHsgcmV0dXJuIE9CSkVD VF9PRkZTRVRPRihKU1dlYkFzc2VtYmx5TWVtb3J5LCBtX21lbW9yeSk7IH0KKyAgICBzdGF0aWMg cHRyZGlmZl90IG9mZnNldE9mTWVtb3J5KCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKEpTV2Vi QXNzZW1ibHlNZW1vcnksIG1fbWVtb3J5KSArIFdhc206Ok1lbW9yeTo6b2Zmc2V0T2ZNZW1vcnko KTsgfQorICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZTaXplKCkgeyByZXR1cm4gT0JKRUNU X09GRlNFVE9GKEpTV2ViQXNzZW1ibHlNZW1vcnksIG1fbWVtb3J5KSArIFdhc206Ok1lbW9yeTo6 b2Zmc2V0T2ZTaXplKCk7IH0KIAogcHJvdGVjdGVkOgotICAgIEpTV2ViQXNzZW1ibHlNZW1vcnko Vk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiYmKTsKKyAgICBK U1dlYkFzc2VtYmx5TWVtb3J5KFZNJiwgU3RydWN0dXJlKiwgV2FzbTo6TWVtb3J5JiYpOwogICAg IH5KU1dlYkFzc2VtYmx5TWVtb3J5KCk7CiAgICAgdm9pZCBmaW5pc2hDcmVhdGlvbihWTSYpOwog ICAgIHN0YXRpYyB2b2lkIGRlc3Ryb3koSlNDZWxsKik7CiAgICAgc3RhdGljIHZvaWQgdmlzaXRD aGlsZHJlbihKU0NlbGwqLCBTbG90VmlzaXRvciYpOwogCi0gICAgc3RkOjp1bmlxdWVfcHRyPFdh c206Ok1lbW9yeT4gbV9tZW1vcnk7CisgICAgV2FzbTo6TWVtb3J5IG1fbWVtb3J5OwogICAgIFdy aXRlQmFycmllcjxKU0FycmF5QnVmZmVyPiBtX2J1ZmZlcldyYXBwZXI7CiAgICAgUmVmUHRyPEFy cmF5QnVmZmVyPiBtX2J1ZmZlcjsKIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUuY3BwCmluZGV4IGQ2NTI0YzUuLmZhMGU4NTkg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlN b2R1bGUuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1i bHlNb2R1bGUuY3BwCkBAIC0zOCw5ICszOCw5IEBAIG5hbWVzcGFjZSBKU0MgewogCiBjb25zdCBD bGFzc0luZm8gSlNXZWJBc3NlbWJseU1vZHVsZTo6c19pbmZvID0geyAiV2ViQXNzZW1ibHkuTW9k dWxlIiwgJkJhc2U6OnNfaW5mbywgbnVsbHB0ciwgQ1JFQVRFX01FVEhPRF9UQUJMRShKU1dlYkFz c2VtYmx5TW9kdWxlKSB9OwogCi1KU1dlYkFzc2VtYmx5TW9kdWxlKiBKU1dlYkFzc2VtYmx5TW9k dWxlOjpjcmVhdGUoVk0mIHZtLCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVfcHRy PFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPiYmIG1vZHVsZUluZm9ybWF0aW9uLCBCYWc8Q2FsbExp bmtJbmZvPiYmIGNhbGxMaW5rSW5mb3MsIFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0dWI+JiYgd2Fz bVRvSlNTdHVicywgV2FzbTo6SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiYgZnVuY3Rpb25J bmRleFNwYWNlLCBTeW1ib2xUYWJsZSogZXhwb3J0U3ltYm9sVGFibGUsIHVuc2lnbmVkIGNhbGxl ZUNvdW50KQorSlNXZWJBc3NlbWJseU1vZHVsZSogSlNXZWJBc3NlbWJseU1vZHVsZTo6Y3JlYXRl KFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1 bGVJbmZvcm1hdGlvbj4mJiBtb2R1bGVJbmZvcm1hdGlvbiwgQmFnPENhbGxMaW5rSW5mbz4mJiBj YWxsTGlua0luZm9zLCBWZWN0b3I8V2FzbTo6V2FzbUV4aXRTdHVicz4mJiB3YXNtRXhpdFN0dWJz LCBTeW1ib2xUYWJsZSogZXhwb3J0U3ltYm9sVGFibGUsIHVuc2lnbmVkIGNhbGxlZUNvdW50KQog ewotICAgIGF1dG8qIGluc3RhbmNlID0gbmV3IChOb3ROdWxsLCBhbGxvY2F0ZUNlbGw8SlNXZWJB c3NlbWJseU1vZHVsZT4odm0uaGVhcCwgYWxsb2NhdGlvblNpemUoY2FsbGVlQ291bnQpKSkgSlNX ZWJBc3NlbWJseU1vZHVsZSh2bSwgc3RydWN0dXJlLCBzdGQ6OmZvcndhcmQ8c3RkOjp1bmlxdWVf cHRyPFdhc206Ok1vZHVsZUluZm9ybWF0aW9uPj4obW9kdWxlSW5mb3JtYXRpb24pLCBzdGQ6OmZv cndhcmQ8QmFnPENhbGxMaW5rSW5mbz4+KGNhbGxMaW5rSW5mb3MpLCBzdGQ6OmZvcndhcmQ8VmVj dG9yPFdhc206Oldhc21Ub0pTU3R1Yj4+KHdhc21Ub0pTU3R1YnMpLCBzdGQ6OmZvcndhcmQ8V2Fz bTo6SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlPihmdW5jdGlvbkluZGV4U3BhY2UpLCBjYWxs ZWVDb3VudCk7CisgICAgYXV0byogaW5zdGFuY2UgPSBuZXcgKE5vdE51bGwsIGFsbG9jYXRlQ2Vs bDxKU1dlYkFzc2VtYmx5TW9kdWxlPih2bS5oZWFwLCBhbGxvY2F0aW9uU2l6ZShjYWxsZWVDb3Vu dCkpKSBKU1dlYkFzc2VtYmx5TW9kdWxlKHZtLCBzdHJ1Y3R1cmUsIHN0ZDo6Zm9yd2FyZDxzdGQ6 OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+Pihtb2R1bGVJbmZvcm1hdGlvbiks IHN0ZDo6Zm9yd2FyZDxCYWc8Q2FsbExpbmtJbmZvPj4oY2FsbExpbmtJbmZvcyksIHN0ZDo6Zm9y d2FyZDxWZWN0b3I8V2FzbTo6V2FzbUV4aXRTdHVicz4+KHdhc21FeGl0U3R1YnMpLCBjYWxsZWVD b3VudCk7CiAgICAgaW5zdGFuY2UtPmZpbmlzaENyZWF0aW9uKHZtLCBleHBvcnRTeW1ib2xUYWJs ZSk7CiAgICAgcmV0dXJuIGluc3RhbmNlOwogfQpAQCAtNTAsMTIgKzUwLDExIEBAIFN0cnVjdHVy ZSogSlNXZWJBc3NlbWJseU1vZHVsZTo6Y3JlYXRlU3RydWN0dXJlKFZNJiB2bSwgSlNHbG9iYWxP YmplY3QqIGdsb2JhbE9iCiAgICAgcmV0dXJuIFN0cnVjdHVyZTo6Y3JlYXRlKHZtLCBnbG9iYWxP YmplY3QsIHByb3RvdHlwZSwgVHlwZUluZm8oT2JqZWN0VHlwZSwgU3RydWN0dXJlRmxhZ3MpLCBp bmZvKCkpOwogfQogCi1KU1dlYkFzc2VtYmx5TW9kdWxlOjpKU1dlYkFzc2VtYmx5TW9kdWxlKFZN JiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJ bmZvcm1hdGlvbj4mJiBtb2R1bGVJbmZvcm1hdGlvbiwgQmFnPENhbGxMaW5rSW5mbz4mJiBjYWxs TGlua0luZm9zLCBWZWN0b3I8V2FzbTo6V2FzbVRvSlNTdHViPiYmIHdhc21Ub0pTU3R1YnMsIFdh c206OkltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmIGZ1bmN0aW9uSW5kZXhTcGFjZSwgdW5z aWduZWQgY2FsbGVlQ291bnQpCitKU1dlYkFzc2VtYmx5TW9kdWxlOjpKU1dlYkFzc2VtYmx5TW9k dWxlKFZNJiB2bSwgU3RydWN0dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpN b2R1bGVJbmZvcm1hdGlvbj4mJiBtb2R1bGVJbmZvcm1hdGlvbiwgQmFnPENhbGxMaW5rSW5mbz4m JiBjYWxsTGlua0luZm9zLCBWZWN0b3I8V2FzbTo6V2FzbUV4aXRTdHVicz4mJiB3YXNtRXhpdFN0 dWJzLCB1bnNpZ25lZCBjYWxsZWVDb3VudCkKICAgICA6IEJhc2Uodm0sIHN0cnVjdHVyZSkKICAg ICAsIG1fbW9kdWxlSW5mb3JtYXRpb24oV1RGTW92ZShtb2R1bGVJbmZvcm1hdGlvbikpCiAgICAg LCBtX2NhbGxMaW5rSW5mb3MoV1RGTW92ZShjYWxsTGlua0luZm9zKSkKLSAgICAsIG1fd2FzbVRv SlNTdHVicyhXVEZNb3ZlKHdhc21Ub0pTU3R1YnMpKQotICAgICwgbV9mdW5jdGlvbkluZGV4U3Bh Y2UoV1RGTW92ZShmdW5jdGlvbkluZGV4U3BhY2UpKQorICAgICwgbV93YXNtRXhpdFN0dWJzKFdU Rk1vdmUod2FzbUV4aXRTdHVicykpCiAgICAgLCBtX2NhbGxlZUNvdW50KGNhbGxlZUNvdW50KQog ewogICAgIG1lbXNldChjYWxsZWVzKCksIDAsIG1fY2FsbGVlQ291bnQgKiBzaXplb2YoV3JpdGVC YXJyaWVyPEpTV2ViQXNzZW1ibHlDYWxsZWU+KSAqIDIpOwpkaWZmIC0tZ2l0IGEvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5oIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5oCmluZGV4IGZlYzRlZWQuLjdl MDUxZjU3IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFz c2VtYmx5TW9kdWxlLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJB c3NlbWJseU1vZHVsZS5oCkBAIC00MywxOSArNDMsMTggQEAgY2xhc3MgSlNXZWJBc3NlbWJseU1v ZHVsZSA6IHB1YmxpYyBKU0Rlc3RydWN0aWJsZU9iamVjdCB7CiBwdWJsaWM6CiAgICAgdHlwZWRl ZiBKU0Rlc3RydWN0aWJsZU9iamVjdCBCYXNlOwogCi0gICAgc3RhdGljIEpTV2ViQXNzZW1ibHlN b2R1bGUqIGNyZWF0ZShWTSYsIFN0cnVjdHVyZSosIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1 bGVJbmZvcm1hdGlvbj4mJiwgQmFnPENhbGxMaW5rSW5mbz4mJiwgVmVjdG9yPFdhc206Oldhc21U b0pTU3R1Yj4mJiwgV2FzbTo6SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiYsIFN5bWJvbFRh YmxlKiwgdW5zaWduZWQpOworICAgIHN0YXRpYyBKU1dlYkFzc2VtYmx5TW9kdWxlKiBjcmVhdGUo Vk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+ JiYsIEJhZzxDYWxsTGlua0luZm8+JiYsIFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPiYmLCBT eW1ib2xUYWJsZSosIHVuc2lnbmVkKTsKICAgICBzdGF0aWMgU3RydWN0dXJlKiBjcmVhdGVTdHJ1 Y3R1cmUoVk0mLCBKU0dsb2JhbE9iamVjdCosIEpTVmFsdWUpOwogCiAgICAgREVDTEFSRV9JTkZP OwogCiAgICAgY29uc3QgV2FzbTo6TW9kdWxlSW5mb3JtYXRpb24mIG1vZHVsZUluZm9ybWF0aW9u KCkgY29uc3QgeyByZXR1cm4gKm1fbW9kdWxlSW5mb3JtYXRpb24uZ2V0KCk7IH0KICAgICBTeW1i b2xUYWJsZSogZXhwb3J0U3ltYm9sVGFibGUoKSBjb25zdCB7IHJldHVybiBtX2V4cG9ydFN5bWJv bFRhYmxlLmdldCgpOyB9Ci0gICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlRm9yRnVu Y3Rpb25JbmRleFNwYWNlKHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFjZSkgY29uc3QKKyAgICBX YXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2Uo dW5zaWduZWQgZnVuY3Rpb25JbmRleFNwYWNlKSBjb25zdAogICAgIHsKLSAgICAgICAgQVNTRVJU KGZ1bmN0aW9uSW5kZXhTcGFjZSA8IG1fZnVuY3Rpb25JbmRleFNwYWNlLnNpemUpOwotICAgICAg ICByZXR1cm4gbV9mdW5jdGlvbkluZGV4U3BhY2UuYnVmZmVyLmdldCgpW2Z1bmN0aW9uSW5kZXhT cGFjZV0uc2lnbmF0dXJlSW5kZXg7CisgICAgICAgIHJldHVybiBtX21vZHVsZUluZm9ybWF0aW9u LT5zaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleFNwYWNl KTsKICAgICB9Ci0gICAgdW5zaWduZWQgZnVuY3Rpb25JbXBvcnRDb3VudCgpIGNvbnN0IHsgcmV0 dXJuIG1fd2FzbVRvSlNTdHVicy5zaXplKCk7IH0KKyAgICB1bnNpZ25lZCBmdW5jdGlvbkltcG9y dENvdW50KCkgY29uc3QgeyByZXR1cm4gbV93YXNtRXhpdFN0dWJzLnNpemUoKTsgfQogCiAgICAg SlNXZWJBc3NlbWJseUNhbGxlZSoganNFbnRyeXBvaW50Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhT cGFjZSh1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2UpCiAgICAgewpAQCAtOTAsMTAgKzg5LDgg QEAgcHVibGljOgogICAgICAgICByZXR1cm4gYml0d2lzZV9jYXN0PFdyaXRlQmFycmllcjxKU1dl YkFzc2VtYmx5Q2FsbGVlPio+KGJpdHdpc2VfY2FzdDxjaGFyKj4odGhpcykgKyBvZmZzZXRPZkNh bGxlZXMoKSk7CiAgICAgfQogCi0gICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZkZ1bmN0aW9u SW5kZXhTcGFjZSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFzc2VtYmx5TW9kdWxl LCBtX2Z1bmN0aW9uSW5kZXhTcGFjZSk7IH0KLQogcHJvdGVjdGVkOgotICAgIEpTV2ViQXNzZW1i bHlNb2R1bGUoVk0mLCBTdHJ1Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5m b3JtYXRpb24+JiYsIEJhZzxDYWxsTGlua0luZm8+JiYsIFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0 dWI+JiYsIFdhc206OkltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmLCB1bnNpZ25lZCBjYWxs ZWVDb3VudCk7CisgICAgSlNXZWJBc3NlbWJseU1vZHVsZShWTSYsIFN0cnVjdHVyZSosIHN0ZDo6 dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4mJiwgQmFnPENhbGxMaW5rSW5mbz4m JiwgVmVjdG9yPFdhc206Oldhc21FeGl0U3R1YnM+JiYsIHVuc2lnbmVkIGNhbGxlZUNvdW50KTsK ICAgICB2b2lkIGZpbmlzaENyZWF0aW9uKFZNJiwgU3ltYm9sVGFibGUqKTsKICAgICBzdGF0aWMg dm9pZCBkZXN0cm95KEpTQ2VsbCopOwogICAgIHN0YXRpYyB2b2lkIHZpc2l0Q2hpbGRyZW4oSlND ZWxsKiwgU2xvdFZpc2l0b3ImKTsKQEAgLTExNyw4ICsxMTQsNyBAQCBwcml2YXRlOgogICAgIHN0 ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4gbV9tb2R1bGVJbmZvcm1hdGlv bjsKICAgICBCYWc8Q2FsbExpbmtJbmZvPiBtX2NhbGxMaW5rSW5mb3M7CiAgICAgV3JpdGVCYXJy aWVyPFN5bWJvbFRhYmxlPiBtX2V4cG9ydFN5bWJvbFRhYmxlOwotICAgIFZlY3RvcjxXYXNtOjpX YXNtVG9KU1N0dWI+IG1fd2FzbVRvSlNTdHViczsKLSAgICBjb25zdCBXYXNtOjpJbW11dGFibGVG dW5jdGlvbkluZGV4U3BhY2UgbV9mdW5jdGlvbkluZGV4U3BhY2U7CisgICAgVmVjdG9yPFdhc206 Oldhc21FeGl0U3R1YnM+IG1fd2FzbUV4aXRTdHViczsKICAgICB1bnNpZ25lZCBtX2NhbGxlZUNv dW50OwogfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2Vi QXNzZW1ibHlGdW5jdGlvbi5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJB c3NlbWJseUZ1bmN0aW9uLmNwcAppbmRleCBiZTI3ZjU3Li5iY2E0NzkyIDEwMDY0NAotLS0gYS9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNwcAorKysg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNwcApA QCAtMTE5LDYgKzExOSw3IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGNh bGxXZWJBc3NlbWJseUZ1bmN0aW9uKEV4ZWNTdGF0ZSogZXhlYykKICAgICBQcm90b0NhbGxGcmFt ZSBwcm90b0NhbGxGcmFtZTsKICAgICBwcm90b0NhbGxGcmFtZS5pbml0KG51bGxwdHIsIHdhc21G dW5jdGlvbiwgZmlyc3RBcmd1bWVudCwgYXJnQ291bnQsIHJlbWFpbmluZ0FyZ3MpOwogCisgICAg Ly8gRklYTUUgRG8gYXdheSB3aXRoIHRoaXMgZW50aXJlIGZ1bmN0aW9uLCBhbmQgb25seSB1c2Ug dGhlIGVudHJ5cG9pbnQgZ2VuZXJhdGVkIGJ5IEIzLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTY2NDg2CiAgICAgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBwcmV2SlNX ZWJBc3NlbWJseUluc3RhbmNlID0gdm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlOwogICAgIHZt LnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZSA9IHdhc21GdW5jdGlvbi0+aW5zdGFuY2UoKTsKICAg ICBBU1NFUlQod2FzbUZ1bmN0aW9uLT5pbnN0YW5jZSgpKTsKQEAgLTE0OSw3ICsxNTAsNyBAQCBX ZWJBc3NlbWJseUZ1bmN0aW9uKiBXZWJBc3NlbWJseUZ1bmN0aW9uOjpjcmVhdGUoVk0mIHZtLCBK U0dsb2JhbE9iamVjdCogZ2xvYmFsTwogewogICAgIE5hdGl2ZUV4ZWN1dGFibGUqIGV4ZWN1dGFi bGUgPSB2bS5nZXRIb3N0RnVuY3Rpb24oY2FsbFdlYkFzc2VtYmx5RnVuY3Rpb24sIE5vSW50cmlu c2ljLCBjYWxsSG9zdEZ1bmN0aW9uQXNDb25zdHJ1Y3RvciwgbnVsbHB0ciwgbmFtZSk7CiAgICAg U3RydWN0dXJlKiBzdHJ1Y3R1cmUgPSBnbG9iYWxPYmplY3QtPndlYkFzc2VtYmx5RnVuY3Rpb25T dHJ1Y3R1cmUoKTsKLSAgICBXZWJBc3NlbWJseUZ1bmN0aW9uKiBmdW5jdGlvbiA9IG5ldyAoTm90 TnVsbCwgYWxsb2NhdGVDZWxsPFdlYkFzc2VtYmx5RnVuY3Rpb24+KHZtLmhlYXApKSBXZWJBc3Nl bWJseUZ1bmN0aW9uKHZtLCBnbG9iYWxPYmplY3QsIHN0cnVjdHVyZSwgc2lnbmF0dXJlSW5kZXgp OworICAgIFdlYkFzc2VtYmx5RnVuY3Rpb24qIGZ1bmN0aW9uID0gbmV3IChOb3ROdWxsLCBhbGxv Y2F0ZUNlbGw8V2ViQXNzZW1ibHlGdW5jdGlvbj4odm0uaGVhcCkpIFdlYkFzc2VtYmx5RnVuY3Rp b24odm0sIGdsb2JhbE9iamVjdCwgc3RydWN0dXJlLCBzaWduYXR1cmVJbmRleCwgd2FzbUVudHJ5 cG9pbnQtPmVudHJ5cG9pbnQoKSk7CiAgICAgZnVuY3Rpb24tPmZpbmlzaENyZWF0aW9uKHZtLCBl eGVjdXRhYmxlLCBsZW5ndGgsIG5hbWUsIGluc3RhbmNlLCBqc0VudHJ5cG9pbnQsIHdhc21FbnRy eXBvaW50KTsKICAgICByZXR1cm4gZnVuY3Rpb247CiB9CkBAIC0xNTcsMTEgKzE1OCwxMiBAQCBX ZWJBc3NlbWJseUZ1bmN0aW9uKiBXZWJBc3NlbWJseUZ1bmN0aW9uOjpjcmVhdGUoVk0mIHZtLCBK U0dsb2JhbE9iamVjdCogZ2xvYmFsTwogU3RydWN0dXJlKiBXZWJBc3NlbWJseUZ1bmN0aW9uOjpj cmVhdGVTdHJ1Y3R1cmUoVk0mIHZtLCBKU0dsb2JhbE9iamVjdCogZ2xvYmFsT2JqZWN0LCBKU1Zh bHVlIHByb3RvdHlwZSkKIHsKICAgICBBU1NFUlQoZ2xvYmFsT2JqZWN0KTsKLSAgICByZXR1cm4g U3RydWN0dXJlOjpjcmVhdGUodm0sIGdsb2JhbE9iamVjdCwgcHJvdG90eXBlLCBUeXBlSW5mbyhK U0Z1bmN0aW9uVHlwZSwgU3RydWN0dXJlRmxhZ3MpLCBpbmZvKCkpOworICAgIHJldHVybiBTdHJ1 Y3R1cmU6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LCBwcm90b3R5cGUsIFR5cGVJbmZvKFdlYkFz c2VtYmx5RnVuY3Rpb25UeXBlLCBTdHJ1Y3R1cmVGbGFncyksIGluZm8oKSk7CiB9CiAKLVdlYkFz c2VtYmx5RnVuY3Rpb246OldlYkFzc2VtYmx5RnVuY3Rpb24oVk0mIHZtLCBKU0dsb2JhbE9iamVj dCogZ2xvYmFsT2JqZWN0LCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgV2FzbTo6U2lnbmF0dXJlSW5k ZXggc2lnbmF0dXJlSW5kZXgpCitXZWJBc3NlbWJseUZ1bmN0aW9uOjpXZWJBc3NlbWJseUZ1bmN0 aW9uKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCwgU3RydWN0dXJlKiBzdHJ1 Y3R1cmUsIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4LCB2b2lkKiB3YXNtRW50 cnlwb2ludCkKICAgICA6IEJhc2Uodm0sIGdsb2JhbE9iamVjdCwgc3RydWN0dXJlKQorICAgICwg bV93YXNtRW50cnlQb2ludENvZGUod2FzbUVudHJ5cG9pbnQpCiAgICAgLCBtX3NpZ25hdHVyZUlu ZGV4KHNpZ25hdHVyZUluZGV4KQogeyB9CiAKQEAgLTE4Myw2ICsxODUsNyBAQCB2b2lkIFdlYkFz c2VtYmx5RnVuY3Rpb246OmZpbmlzaENyZWF0aW9uKFZNJiB2bSwgTmF0aXZlRXhlY3V0YWJsZSog ZXhlY3V0YWJsZSwgdQogICAgIEFTU0VSVChqc0VudHJ5cG9pbnQgIT0gd2FzbUVudHJ5cG9pbnQp OwogICAgIG1fanNFbnRyeXBvaW50LnNldCh2bSwgdGhpcywganNFbnRyeXBvaW50KTsKICAgICBt X3dhc21FbnRyeXBvaW50LnNldCh2bSwgdGhpcywgd2FzbUVudHJ5cG9pbnQpOworICAgIEFTU0VS VChtX3dhc21FbnRyeXBvaW50LT5lbnRyeXBvaW50KCkgPT0gbV93YXNtRW50cnlQb2ludENvZGUp OwogfQogCiB9IC8vIG5hbWVzcGFjZSBKU0MKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uaAppbmRleCAzNDkwNTAyLi4zODc3YTAyIDEw MDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0 aW9uLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlGdW5j dGlvbi5oCkBAIC01NCwxOCArNTQsMjIgQEAgcHVibGljOgogCiAgICAgSlNXZWJBc3NlbWJseUlu c3RhbmNlKiBpbnN0YW5jZSgpIGNvbnN0IHsgcmV0dXJuIG1faW5zdGFuY2UuZ2V0KCk7IH0KICAg ICBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCgpIGNvbnN0IHsgcmV0dXJuIG1f c2lnbmF0dXJlSW5kZXg7IH0KLSAgICB2b2lkKiB3YXNtRW50cnlwb2ludCgpIHsgcmV0dXJuIG1f d2FzbUVudHJ5cG9pbnQtPmVudHJ5cG9pbnQoKTsgfQorICAgIHZvaWQqIHdhc21FbnRyeXBvaW50 KCkgeyByZXR1cm4gbV93YXNtRW50cnlQb2ludENvZGU7IH0KICAgICB2b2lkKiBqc0VudHJ5cG9p bnQoKSB7IHJldHVybiBtX2pzRW50cnlwb2ludC0+ZW50cnlwb2ludCgpOyB9CiAKKyAgICBzdGF0 aWMgcHRyZGlmZl90IG9mZnNldE9mSW5zdGFuY2UoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0Yo V2ViQXNzZW1ibHlGdW5jdGlvbiwgbV9pbnN0YW5jZSk7IH0KKyAgICBzdGF0aWMgcHRyZGlmZl90 IG9mZnNldE9mV2FzbUVudHJ5UG9pbnRDb2RlKCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKFdl YkFzc2VtYmx5RnVuY3Rpb24sIG1fd2FzbUVudHJ5UG9pbnRDb2RlKTsgfQorCiBwcm90ZWN0ZWQ6 CiAgICAgc3RhdGljIHZvaWQgdmlzaXRDaGlsZHJlbihKU0NlbGwqLCBTbG90VmlzaXRvciYpOwog CiAgICAgdm9pZCBmaW5pc2hDcmVhdGlvbihWTSYsIE5hdGl2ZUV4ZWN1dGFibGUqLCB1bnNpZ25l ZCBsZW5ndGgsIGNvbnN0IFN0cmluZyYgbmFtZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlKiwgSlNX ZWJBc3NlbWJseUNhbGxlZSoganNFbnRyeXBvaW50LCBKU1dlYkFzc2VtYmx5Q2FsbGVlKiB3YXNt RW50cnlwb2ludCk7CiAKIHByaXZhdGU6Ci0gICAgV2ViQXNzZW1ibHlGdW5jdGlvbihWTSYsIEpT R2xvYmFsT2JqZWN0KiwgU3RydWN0dXJlKiwgV2FzbTo6U2lnbmF0dXJlSW5kZXgpOworICAgIFdl YkFzc2VtYmx5RnVuY3Rpb24oVk0mLCBKU0dsb2JhbE9iamVjdCosIFN0cnVjdHVyZSosIFdhc206 OlNpZ25hdHVyZUluZGV4LCB2b2lkKik7CiAKICAgICBXcml0ZUJhcnJpZXI8SlNXZWJBc3NlbWJs eUluc3RhbmNlPiBtX2luc3RhbmNlOworICAgIHZvaWQqIG1fd2FzbUVudHJ5UG9pbnRDb2RlOyAv LyBSZW1vdmUgaW5kaXJlY3Rpb25zIGZvciB3YXNtIC0+IHdhc20gY2FsbHMuCiAgICAgV3JpdGVC YXJyaWVyPEpTV2ViQXNzZW1ibHlDYWxsZWU+IG1fanNFbnRyeXBvaW50OwogICAgIFdyaXRlQmFy cmllcjxKU1dlYkFzc2VtYmx5Q2FsbGVlPiBtX3dhc21FbnRyeXBvaW50OwogICAgIFdhc206OlNp Z25hdHVyZUluZGV4IG1fc2lnbmF0dXJlSW5kZXg7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUluc3RhbmNlQ29uc3RydWN0b3IuY3BwIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVjdG9y LmNwcAppbmRleCBkNjBmNDBlLi4xYjQ2MTEyIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUluc3RhbmNlQ29uc3RydWN0b3IuY3BwCisrKyBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5SW5zdGFuY2VDb25zdHJ1Y3Rv ci5jcHAKQEAgLTg0LDYgKzg0LDExIEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9D QUxMIGNvbnN0cnVjdEpTV2ViQXNzZW1ibHlJbnN0YW5jZShFeGVjU3RhdGUqIGV4CiAKICAgICBK U1dlYkFzc2VtYmx5SW5zdGFuY2UqIGluc3RhbmNlID0gSlNXZWJBc3NlbWJseUluc3RhbmNlOjpj cmVhdGUodm0sIGluc3RhbmNlU3RydWN0dXJlLCBqc01vZHVsZSwgbW9kdWxlUmVjb3JkLT5nZXRN b2R1bGVOYW1lc3BhY2UoZXhlYykpOwogICAgIFJFVFVSTl9JRl9FWENFUFRJT04odGhyb3dTY29w ZSwgZW5jb2RlZEpTVmFsdWUoKSk7CisgICAgeworICAgICAgICAvLyBBbHdheXMgc3RhcnQgd2l0 aCBhIGR1bW15IE1lbW9yeSwgc28gdGhhdCB3YXNtIC0+IHdhc20gdGh1bmtzIGF2b2lkIGNoZWNr aW5nIGZvciBhIG51bGxwdHIgTWVtb3J5IHdoZW4gdHJ5aW5nIHRvIHNldCBwaW5uZWQgcmVnaXN0 ZXJzLgorICAgICAgICBXYXNtOjpNZW1vcnkgbWVtb3J5OworICAgICAgICBpbnN0YW5jZS0+c2V0 TWVtb3J5KHZtLCBKU1dlYkFzc2VtYmx5TWVtb3J5OjpjcmVhdGUodm0sIGV4ZWMtPmxleGljYWxH bG9iYWxPYmplY3QoKS0+V2ViQXNzZW1ibHlNZW1vcnlTdHJ1Y3R1cmUoKSwgV1RGTW92ZShtZW1v cnkpKSk7CisgICAgfQogCiAgICAgLy8gTGV0IGZ1bmNzLCBtZW1vcmllcyBhbmQgdGFibGVzIGJl IGluaXRpYWxseS1lbXB0eSBsaXN0cyBvZiBjYWxsYWJsZSBKYXZhU2NyaXB0IG9iamVjdHMsIFdl YkFzc2VtYmx5Lk1lbW9yeSBvYmplY3RzIGFuZCBXZWJBc3NlbWJseS5UYWJsZSBvYmplY3RzLCBy ZXNwZWN0aXZlbHkuCiAgICAgLy8gTGV0IGltcG9ydHMgYmUgYW4gaW5pdGlhbGx5LWVtcHR5IGxp c3Qgb2YgZXh0ZXJuYWwgdmFsdWVzLgpAQCAtMTE0LDE4ICsxMTksMTkgQEAgc3RhdGljIEVuY29k ZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwgY29uc3RydWN0SlNXZWJBc3NlbWJseUluc3RhbmNlKEV4 ZWNTdGF0ZSogZXgKICAgICAgICAgICAgICAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKHRocm93 RXhjZXB0aW9uKGV4ZWMsIHRocm93U2NvcGUsIGNyZWF0ZUpTV2ViQXNzZW1ibHlMaW5rRXJyb3Io ZXhlYywgdm0sIEFTQ0lJTGl0ZXJhbCgiaW1wb3J0IGZ1bmN0aW9uIG11c3QgYmUgY2FsbGFibGUi KSkpKTsKICAgICAgICAgICAgIEpTQ2VsbCogY2VsbCA9IHZhbHVlLmFzQ2VsbCgpOwogICAgICAg ICAgICAgLy8gaWkuIElmIHYgaXMgYW4gRXhwb3J0ZWQgRnVuY3Rpb24gRXhvdGljIE9iamVjdDoK LSAgICAgICAgICAgIGlmIChXZWJBc3NlbWJseUZ1bmN0aW9uKiBpbXBvcnRlZEV4cG9ydHMgPSBq c0R5bmFtaWNDYXN0PFdlYkFzc2VtYmx5RnVuY3Rpb24qPihvYmplY3QpKSB7Ci0gICAgICAgICAg ICAgICAgLy8gRklYTUUgaGFuZGxlIEZ1bmN0aW9uIEV4b3RpYyBPYmplY3QgcHJvcGVybHkuIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjUyODIKLSAgICAgICAgICAg ICAgICAvLyBhLiBJZiB0aGUgc2lnbmF0dXJlIG9mIHYgZG9lcyBub3QgbWF0Y2ggdGhlIHNpZ25h dHVyZSBvZiBpLCB0aHJvdyBhIFR5cGVFcnJvci4KKyAgICAgICAgICAgIGlmIChXZWJBc3NlbWJs eUZ1bmN0aW9uKiBpbXBvcnRlZEV4cG9ydCA9IGpzRHluYW1pY0Nhc3Q8V2ViQXNzZW1ibHlGdW5j dGlvbio+KGNlbGwpKSB7CisgICAgICAgICAgICAgICAgLy8gYS4gSWYgdGhlIHNpZ25hdHVyZSBv ZiB2IGRvZXMgbm90IG1hdGNoIHRoZSBzaWduYXR1cmUgb2YgaSwgdGhyb3cgYSBXZWJBc3NlbWJs eS5MaW5rRXJyb3IuCisgICAgICAgICAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggaW1wb3J0 ZWRTaWduYXR1cmVJbmRleCA9IGltcG9ydGVkRXhwb3J0LT5zaWduYXR1cmVJbmRleCgpOworICAg ICAgICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IGV4cGVjdGVkU2lnbmF0dXJlSW5kZXgg PSBtb2R1bGVJbmZvcm1hdGlvbi5pbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGljZXNbaW1wb3J0 LmtpbmRJbmRleF07CisgICAgICAgICAgICAgICAgaWYgKGltcG9ydGVkU2lnbmF0dXJlSW5kZXgg IT0gZXhwZWN0ZWRTaWduYXR1cmVJbmRleCkKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIEpT VmFsdWU6OmVuY29kZSh0aHJvd0V4Y2VwdGlvbihleGVjLCB0aHJvd1Njb3BlLCBjcmVhdGVKU1dl YkFzc2VtYmx5TGlua0Vycm9yKGV4ZWMsIHZtLCBBU0NJSUxpdGVyYWwoImltcG9ydGVkIGZ1bmN0 aW9uJ3Mgc2lnbmF0dXJlIGRvZXNuJ3QgbWF0Y2ggdGhlIHByb3ZpZGVkIFdlYkFzc2VtYmx5IGZ1 bmN0aW9uJ3Mgc2lnbmF0dXJlIikpKSk7CiAgICAgICAgICAgICAgICAgLy8gYi4gTGV0IGNsb3N1 cmUgYmUgdi5bW0Nsb3N1cmVdXS4KLSAgICAgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVF9OT1Rf UkVBQ0hFRCgpOwotICAgICAgICAgICAgICAgIFVOVVNFRF9QQVJBTShpbXBvcnRlZEV4cG9ydHMp OwotICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICAgfQogICAgICAgICAgICAgLy8g aWlpLiBPdGhlcndpc2U6CiAgICAgICAgICAgICAvLyBhLiBMZXQgY2xvc3VyZSBiZSBhIG5ldyBo b3N0IGZ1bmN0aW9uIG9mIHRoZSBnaXZlbiBzaWduYXR1cmUgd2hpY2ggY2FsbHMgdiBieSBjb2Vy Y2luZyBXZWJBc3NlbWJseSBhcmd1bWVudHMgdG8gSmF2YVNjcmlwdCBhcmd1bWVudHMgdmlhIFRv SlNWYWx1ZSBhbmQgcmV0dXJucyB0aGUgcmVzdWx0LCBpZiBhbnksIGJ5IGNvZXJjaW5nIHZpYSBU b1dlYkFzc2VtYmx5VmFsdWUuCiAgICAgICAgICAgICAvLyBOb3RlOiBkb25lIGFzIHBhcnQgb2Yg UGxhbiBjb21waWxhdGlvbi4KICAgICAgICAgICAgIC8vIGl2LiBBcHBlbmQgdiB0byBmdW5jcy4K KyAgICAgICAgICAgIC8vIE5vdGU6IGFkZGluZyB0aGUgSlNDZWxsIHRvIHRoZSBpbnN0YW5jZSBs aXN0IGZ1bGZpbGxzIGNsb3N1cmUgcmVxdWlyZW1lbnRzIGIuIGFib3ZlICh0aGUgV2ViQXNzZW1i bHkuSW5zdGFuY2Ugd2lsIGJlIGtlcHQgYWxpdmUpIGFuZCB2LiBiZWxvdyAodGhlIEpTRnVuY3Rp b24pLgogICAgICAgICAgICAgaW5zdGFuY2UtPnNldEltcG9ydEZ1bmN0aW9uKHZtLCBjZWxsLCBu dW1JbXBvcnRGdW5jdGlvbnMrKyk7CiAgICAgICAgICAgICAvLyB2LiBBcHBlbmQgY2xvc3VyZSB0 byBpbXBvcnRzLgogICAgICAgICAgICAgYnJlYWs7CkBAIC0yMzAsNyArMjM2LDcgQEAgc3RhdGlj IEVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwgY29uc3RydWN0SlNXZWJBc3NlbWJseUluc3Rh bmNlKEV4ZWNTdGF0ZSogZXgKICAgICAgICAgICAgIFJFTEVBU0VfQVNTRVJUKCFtb2R1bGVJbmZv cm1hdGlvbi5tZW1vcnkuaXNJbXBvcnQoKSk7CiAgICAgICAgICAgICAvLyBXZSBjcmVhdGUgYSBt ZW1vcnkgd2hlbiBpdCdzIGEgbWVtb3J5IGRlZmluaXRpb24uCiAgICAgICAgICAgICBib29sIGZh aWxlZDsKLSAgICAgICAgICAgIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+IG1lbW9yeSA9 IHN0ZDo6bWFrZV91bmlxdWU8V2FzbTo6TWVtb3J5Pihtb2R1bGVJbmZvcm1hdGlvbi5tZW1vcnku aW5pdGlhbCgpLCBtb2R1bGVJbmZvcm1hdGlvbi5tZW1vcnkubWF4aW11bSgpLCBmYWlsZWQpOwor ICAgICAgICAgICAgV2FzbTo6TWVtb3J5IG1lbW9yeShtb2R1bGVJbmZvcm1hdGlvbi5tZW1vcnku aW5pdGlhbCgpLCBtb2R1bGVJbmZvcm1hdGlvbi5tZW1vcnkubWF4aW11bSgpLCBmYWlsZWQpOwog ICAgICAgICAgICAgaWYgKGZhaWxlZCkKICAgICAgICAgICAgICAgICByZXR1cm4gSlNWYWx1ZTo6 ZW5jb2RlKHRocm93RXhjZXB0aW9uKGV4ZWMsIHRocm93U2NvcGUsIGNyZWF0ZU91dE9mTWVtb3J5 RXJyb3IoZXhlYykpKTsKICAgICAgICAgICAgIGluc3RhbmNlLT5zZXRNZW1vcnkodm0sCmRpZmYg LS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1lbW9yeUNv bnN0cnVjdG9yLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5 TWVtb3J5Q29uc3RydWN0b3IuY3BwCmluZGV4IDVkNWE2Y2QuLjZjODg3YWYgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TWVtb3J5Q29uc3RydWN0 b3IuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TWVt b3J5Q29uc3RydWN0b3IuY3BwCkBAIC05Nyw3ICs5Nyw3IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1 ZSBKU0NfSE9TVF9DQUxMIGNvbnN0cnVjdEpTV2ViQXNzZW1ibHlNZW1vcnkoRXhlY1N0YXRlKiBl eGVjCiAgICAgfQogCiAgICAgYm9vbCBmYWlsZWQ7Ci0gICAgc3RkOjp1bmlxdWVfcHRyPFdhc206 Ok1lbW9yeT4gbWVtb3J5ID0gc3RkOjptYWtlX3VuaXF1ZTxXYXNtOjpNZW1vcnk+KGluaXRpYWxQ YWdlQ291bnQsIG1heGltdW1QYWdlQ291bnQsIGZhaWxlZCk7CisgICAgV2FzbTo6TWVtb3J5IG1l bW9yeShpbml0aWFsUGFnZUNvdW50LCBtYXhpbXVtUGFnZUNvdW50LCBmYWlsZWQpOwogICAgIGlm IChmYWlsZWQpCiAgICAgICAgIHJldHVybiBKU1ZhbHVlOjplbmNvZGUodGhyb3dFeGNlcHRpb24o ZXhlYywgdGhyb3dTY29wZSwgY3JlYXRlT3V0T2ZNZW1vcnlFcnJvcihleGVjKSkpOwogCmRpZmYg LS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNv bnN0cnVjdG9yLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5 TW9kdWxlQ29uc3RydWN0b3IuY3BwCmluZGV4IDM4ZWRiOGMuLjgxMjk1OTIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlQ29uc3RydWN0 b3IuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9k dWxlQ29uc3RydWN0b3IuY3BwCkBAIC05Nyw3ICs5Nyw3IEBAIEpTVmFsdWUgV2ViQXNzZW1ibHlN b2R1bGVDb25zdHJ1Y3Rvcjo6Y3JlYXRlTW9kdWxlKEV4ZWNTdGF0ZSogc3RhdGUsIFN0cnVjdHVy ZSoKIAogICAgIC8vIE9ubHkgd2FzbS1pbnRlcm5hbCBmdW5jdGlvbnMgaGF2ZSBhIGNhbGxlZSwg c3R1YnMgdG8gSlMgZG8gbm90LgogICAgIHVuc2lnbmVkIGNhbGxlZUNvdW50ID0gcGxhbi5pbnRl cm5hbEZ1bmN0aW9uQ291bnQoKTsKLSAgICBKU1dlYkFzc2VtYmx5TW9kdWxlKiByZXN1bHQgPSBK U1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGUodm0sIHN0cnVjdHVyZSwgcGxhbi50YWtlTW9kdWxl SW5mb3JtYXRpb24oKSwgcGxhbi50YWtlQ2FsbExpbmtJbmZvcygpLCBwbGFuLnRha2VXYXNtVG9K U1N0dWJzKCksIHBsYW4udGFrZUZ1bmN0aW9uSW5kZXhTcGFjZSgpLCBleHBvcnRTeW1ib2xUYWJs ZSwgY2FsbGVlQ291bnQpOworICAgIEpTV2ViQXNzZW1ibHlNb2R1bGUqIHJlc3VsdCA9IEpTV2Vi QXNzZW1ibHlNb2R1bGU6OmNyZWF0ZSh2bSwgc3RydWN0dXJlLCBwbGFuLnRha2VNb2R1bGVJbmZv cm1hdGlvbigpLCBwbGFuLnRha2VDYWxsTGlua0luZm9zKCksIHBsYW4udGFrZVdhc21FeGl0U3R1 YnMoKSwgZXhwb3J0U3ltYm9sVGFibGUsIGNhbGxlZUNvdW50KTsKICAgICBwbGFuLmluaXRpYWxp emVDYWxsZWVzKHN0YXRlLT5qc0NhbGxlZSgpLT5nbG9iYWxPYmplY3QoKSwgCiAgICAgICAgIFsm XSAodW5zaWduZWQgY2FsbGVlSW5kZXgsIEpTV2ViQXNzZW1ibHlDYWxsZWUqIGpzRW50cnlwb2lu dENhbGxlZSwgSlNXZWJBc3NlbWJseUNhbGxlZSogd2FzbUVudHJ5cG9pbnRDYWxsZWUpIHsKICAg ICAgICAgICAgIHJlc3VsdC0+c2V0SlNFbnRyeXBvaW50Q2FsbGVlKHZtLCBjYWxsZWVJbmRleCwg anNFbnRyeXBvaW50Q2FsbGVlKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmNwcAppbmRleCBjMWJkODIwLi45ZWZm NGM0IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJs eU1vZHVsZVJlY29yZC5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2Vi QXNzZW1ibHlNb2R1bGVSZWNvcmQuY3BwCkBAIC0xMTgsNyArMTE4LDcgQEAgdm9pZCBXZWJBc3Nl bWJseU1vZHVsZVJlY29yZDo6bGluayhFeGVjU3RhdGUqIHN0YXRlLCBKU1dlYkFzc2VtYmx5SW5z dGFuY2UqIGluc3QKICAgICAgICAgICAgIC8vICAgICBjLiBSZXR1cm4gZnVuYy4KICAgICAgICAg ICAgIEpTV2ViQXNzZW1ibHlDYWxsZWUqIGpzRW50cnlwb2ludENhbGxlZSA9IG1vZHVsZS0+anNF bnRyeXBvaW50Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShleHAua2luZEluZGV4KTsKICAg ICAgICAgICAgIEpTV2ViQXNzZW1ibHlDYWxsZWUqIHdhc21FbnRyeXBvaW50Q2FsbGVlID0gbW9k dWxlLT53YXNtRW50cnlwb2ludENhbGxlZUZyb21GdW5jdGlvbkluZGV4U3BhY2UoZXhwLmtpbmRJ bmRleCk7Ci0gICAgICAgICAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9 IG1vZHVsZS0+c2lnbmF0dXJlRm9yRnVuY3Rpb25JbmRleFNwYWNlKGV4cC5raW5kSW5kZXgpOwor ICAgICAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUt PnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShleHAua2luZEluZGV4KTsKICAg ICAgICAgICAgIGNvbnN0IFdhc206OlNpZ25hdHVyZSogc2lnbmF0dXJlID0gV2FzbTo6U2lnbmF0 dXJlSW5mb3JtYXRpb246OmdldCgmdm0sIHNpZ25hdHVyZUluZGV4KTsKICAgICAgICAgICAgIFdl YkFzc2VtYmx5RnVuY3Rpb24qIGZ1bmN0aW9uID0gV2ViQXNzZW1ibHlGdW5jdGlvbjo6Y3JlYXRl KHZtLCBnbG9iYWxPYmplY3QsIHNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpLCBleHAuZmllbGQu c3RyaW5nKCksIGluc3RhbmNlLCBqc0VudHJ5cG9pbnRDYWxsZWUsIHdhc21FbnRyeXBvaW50Q2Fs bGVlLCBzaWduYXR1cmVJbmRleCk7CiAgICAgICAgICAgICBleHBvcnRlZFZhbHVlID0gZnVuY3Rp b247CkBAIC0xMzMsOCArMTMzLDYgQEAgdm9pZCBXZWJBc3NlbWJseU1vZHVsZVJlY29yZDo6bGlu ayhFeGVjU3RhdGUqIHN0YXRlLCBKU1dlYkFzc2VtYmx5SW5zdGFuY2UqIGluc3QKICAgICAgICAg ICAgIGJyZWFrOwogICAgICAgICB9CiAgICAgICAgIGNhc2UgV2FzbTo6RXh0ZXJuYWxLaW5kOjpN ZW1vcnk6IHsKLSAgICAgICAgICAgIC8vIFRoaXMgc2hvdWxkIGJlIGd1YXJhbnRlZWQgYnkgbW9k dWxlIHZlcmlmaWNhdGlvbi4KLSAgICAgICAgICAgIFJFTEVBU0VfQVNTRVJUKGluc3RhbmNlLT5t ZW1vcnkoKSk7IAogICAgICAgICAgICAgQVNTRVJUKGV4cC5raW5kSW5kZXggPT0gMCk7CiAKICAg ICAgICAgICAgIGV4cG9ydGVkVmFsdWUgPSBpbnN0YW5jZS0+bWVtb3J5KCk7CkBAIC0xNzUsNyAr MTczLDcgQEAgdm9pZCBXZWJBc3NlbWJseU1vZHVsZVJlY29yZDo6bGluayhFeGVjU3RhdGUqIHN0 YXRlLCBKU1dlYkFzc2VtYmx5SW5zdGFuY2UqIGluc3QKICAgICBib29sIGhhc1N0YXJ0ID0gISFt b2R1bGVJbmZvcm1hdGlvbi5zdGFydEZ1bmN0aW9uSW5kZXhTcGFjZTsKICAgICBpZiAoaGFzU3Rh cnQpIHsKICAgICAgICAgYXV0byBzdGFydEZ1bmN0aW9uSW5kZXhTcGFjZSA9IG1vZHVsZUluZm9y bWF0aW9uLnN0YXJ0RnVuY3Rpb25JbmRleFNwYWNlLnZhbHVlX29yKDApOwotICAgICAgICBXYXNt OjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1vZHVsZS0+c2lnbmF0dXJlRm9yRnVu Y3Rpb25JbmRleFNwYWNlKHN0YXJ0RnVuY3Rpb25JbmRleFNwYWNlKTsKKyAgICAgICAgV2FzbTo6 U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVyZUluZGV4RnJv bUZ1bmN0aW9uSW5kZXhTcGFjZShzdGFydEZ1bmN0aW9uSW5kZXhTcGFjZSk7CiAgICAgICAgIGNv bnN0IFdhc206OlNpZ25hdHVyZSogc2lnbmF0dXJlID0gV2FzbTo6U2lnbmF0dXJlSW5mb3JtYXRp b246OmdldCgmdm0sIHNpZ25hdHVyZUluZGV4KTsKICAgICAgICAgLy8gVGhlIHN0YXJ0IGZ1bmN0 aW9uIG11c3Qgbm90IHRha2UgYW55IGFyZ3VtZW50cyBvciByZXR1cm4gYW55dGhpbmcuIFRoaXMg aXMgZW5mb3JjZWQgYnkgdGhlIHBhcnNlci4KICAgICAgICAgQVNTRVJUKCFzaWduYXR1cmUtPmFy Z3VtZW50Q291bnQoKSk7CkBAIC0yMzgsNyArMjM2LDcgQEAgSlNWYWx1ZSBXZWJBc3NlbWJseU1v ZHVsZVJlY29yZDo6ZXZhbHVhdGUoRXhlY1N0YXRlKiBzdGF0ZSkKIAogICAgICAgICAgICAgICAg IEpTV2ViQXNzZW1ibHlDYWxsZWUqIGpzRW50cnlwb2ludENhbGxlZSA9IG1vZHVsZS0+anNFbnRy eXBvaW50Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KTsKICAgICAg ICAgICAgICAgICBKU1dlYkFzc2VtYmx5Q2FsbGVlKiB3YXNtRW50cnlwb2ludENhbGxlZSA9IG1v ZHVsZS0+d2FzbUVudHJ5cG9pbnRDYWxsZWVGcm9tRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9u SW5kZXgpOwotICAgICAgICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUlu ZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVGb3JGdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRl eCk7CisgICAgICAgICAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXgg PSBtb2R1bGUtPnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbklu ZGV4KTsKICAgICAgICAgICAgICAgICBjb25zdCBXYXNtOjpTaWduYXR1cmUqIHNpZ25hdHVyZSA9 IFdhc206OlNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQoJnZtLCBzaWduYXR1cmVJbmRleCk7CiAg ICAgICAgICAgICAgICAgLy8gRklYTUU6IFNheSB3ZSBleHBvcnQgbG9jYWwgZnVuY3Rpb24gImZv byIgYXQgZnVuY2l0b24gaW5kZXggMC4KICAgICAgICAgICAgICAgICAvLyBXaGF0IGlmIHdlIGFs c28gc2V0IGl0IHRvIHRoZSB0YWJsZSBhbiBFbGVtZW50IHcvIGluZGV4IDAuCkBAIC0yNTcsNyAr MjU1LDYgQEAgSlNWYWx1ZSBXZWJBc3NlbWJseU1vZHVsZVJlY29yZDo6ZXZhbHVhdGUoRXhlY1N0 YXRlKiBzdGF0ZSkKICAgICAgICAgY29uc3QgVmVjdG9yPFdhc206OlNlZ21lbnQ6OlB0cj4mIGRh dGEgPSBtX2luc3RhbmNlLT5tb2R1bGUoKS0+bW9kdWxlSW5mb3JtYXRpb24oKS5kYXRhOwogICAg ICAgICBKU1dlYkFzc2VtYmx5TWVtb3J5KiBqc01lbW9yeSA9IG1faW5zdGFuY2UtPm1lbW9yeSgp OwogICAgICAgICBpZiAoIWRhdGEuaXNFbXB0eSgpKSB7Ci0gICAgICAgICAgICBSRUxFQVNFX0FT U0VSVChqc01lbW9yeSk7IC8vIEl0IGlzIGEgdmFsaWRhdGlvbiBlcnJvciBmb3IgYSBEYXRhIHNl Y3Rpb24gdG8gZXhpc3Qgd2l0aG91dCBhIE1lbW9yeSBzZWN0aW9uIG9yIGltcG9ydC4KICAgICAg ICAgICAgIHVpbnQ4X3QqIG1lbW9yeSA9IHJlaW50ZXJwcmV0X2Nhc3Q8dWludDhfdCo+KGpzTWVt b3J5LT5tZW1vcnkoKS0+bWVtb3J5KCkpOwogICAgICAgICAgICAgdWludDY0X3Qgc2l6ZUluQnl0 ZXMgPSBqc01lbW9yeS0+bWVtb3J5KCktPnNpemUoKTsKICAgICAgICAgICAgIGZvciAoYXV0byYg c2VnbWVudCA6IGRhdGEpIHsKLS0gCjIuMTAuMQoK 297918 2017-01-02 17:01:52 -0800 2017-01-02 17:58:36 -0800 patch 0001-wasm-wasm.patch text/plain 149223 jfbastien RnJvbSAyY2FlZTJiYzExZDYyOGIzYzZmNjY5Y2ZiZjcyZGVkNzMxOWZkZDlmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBXZWQsIDIxIERlYyAyMDE2IDE1OjU5OjU2IC0wODAwClN1YmplY3Q6IFtQQVRDSF0gd2FzbS0+ d2FzbQoKQ2hhbmdlcyB0byB0aGUgV2ViQXNzZW1ibHkgaW1wbGVtZW50YXRpb246CgogIC0gQWRk IGEgbmV3IEpTVHlwZSBmb3IgV2ViQXNzZW1ibHlGdW5jdGlvbiwgYW5kIHVzZSBpdCB3aGVuIGNy ZWF0aW5nIGl0cwogICAgc3RydWN0dXJlLiBUaGlzIHdpbGwgYmUgdXNlZCB0byBxdWlja2x5IGRl dGVjdCBmcm9tIHdhc20gd2hldGhlciB0aGUgaW1wb3J0CiAgICBjYWxsIGlzIHRvIGFub3RoZXIg d2FzbSBtb2R1bGUsIG9yIHdoZXRoZXIgaXQncyB0byBKUy4KICAtIFVzZSBjZWxsIGluc3RlYWQg b2Ygb2JqZWN0cyB0byBkZXRlY3Qgd2FzbS0+d2FzbSwgdGhlIHByZXZpb3VzIGNvZGUgd2FzIHdy b25nLgogIC0gSW1wcm92ZSBkaWFnbm9zdGljIHByaW50b3V0IGZvciB3YXNtIHN0dWJzOiBwcmlu dCB0aGUgZnVsbCBzaWduYXR1cmUuCiAgLSBQcm9wZXJseSBjaGVjayB0aGF0IHdhc20gLT4gd2Fz bSBjYWxscyBoYXZlIG1hdGNoaW5nIHNpZ25hdHVyZXMuIEFkZCB0ZXN0aW5nIGZvciB0aGlzLgog IC0gVGVzdCBzb21lIG9mIHRoZSB3YXNtIC0+IHdhc20gY2FsbHMsIG5vdCB3b3JraW5nIHlldCwg YW5kIG1vcmUgdGVzdHMgbmVlZCB0bwogICAgZ2V0IGltcGxlbWVudGVkLgogIC0gR2VuZXJhdGUg dHdvIHN0dWJzIGZyb20gdGhlIGltcG9ydCBzdHViIGdlbmVyYXRvcjogb25lIGZvciB3YXNtLT5K UyBhbmQgb25lCiAgICBmb3Igd2FzbSAtPiB3YXNtLiBUaGlzIGlzIGRvbmUgYXQgTW9kdWxlIHRp bWUuIFdoaWNoIGlzIGNhbGxlZCB3aWxsIG9ubHkgYmUKICAgIGtub3duIGF0IEluc3RhbmNlIHRp bWUsIG9uY2Ugd2UndmUgcmVjZWl2ZWQgdGhlIGltcG9ydCBvYmplY3QuIFdlIHdhbnQgdG8KICAg IGF2b2lkIGNvZGVnZW4gYXQgSW5zdGFuY2UgdGltZSwgc28gaGF2aW5nIGJvdGggYXJvdW5kIGlz IGdyZWF0LgogIC0gUmVzdG9yZSB0aGUgV2ViQXNzZW1ibHkgZ2xvYmFsIHN0YXRlIChWTSB0b3Ag SW5zdGFuY2UsIGFuZCBwaW5uZWQgcmVnaXN0ZXJzKQogICAgYWZ0ZXIgY2FsbCAvIGNhbGxfaW5k aXJlY3QsIGFuZCBpbiB0aGUgSlMtPndhc20gZW50cnkgc3R1Yi4KICAtIFBpbm5lZCByZWdpc3Rl cnMgYXJlIG5vdyBhIGdsb2JhbCB0aGluZywgbm90IHBlci1NZW1vcnksIGJlY2F1c2UgdGhlIHdh c20gLT4KICAgIHdhc20gc3R1YnMgYXJlIGdlbmVyYXRlZCBhdCBNb2R1bGUgdGltZSB3aGVyZSB3 ZSBkb24ndCByZWFsbHkgaGF2ZSBlbm91Z2gKICAgIGluZm9ybWF0aW9uIHRvIGRvIHRoZSByaWdo dCB0aGluZyAoZG9pbmcgc28gd291bGQgZ2VuZXJhdGUgdG9vIG11Y2ggY29kZSkuCgpTdXBwb3J0 IGNoYW5nZXM6CgogIC0gQWRkIGEgUHJveHkgdG8gQnVpbGRlci5qcywgd2hpY2ggaW50ZXJjZXB0 cyB1bmtub3duIHByb3BlcnR5IGxvb2t1cHMuIFRoaXMKICAgIGNyZWF0ZXMgd2F5IGJldHRlciBl cnJvciBtZXNzYWdlcyBvbiB0eXBvcyB0aGFuICd1bmRlZmluZWQgaXMgbm90IGEKICAgIGZ1bmN0 aW9uJywgd2hpY2ggaGFwcGVucyBzZW1pLWZyZXF1ZW50bHkgYXMgSSB0eXBvIG9wY29kZSBuYW1l cyAoYW5kIHdoaWNoCiAgICBvbmUgaXMgYSB0eXBvIGlzIGhhcmQgdG8gZmluZCBiZWNhdXNlIHdl IGNoYWluIGJ1aWxkZXJzKS4KICAtIEFkZCBsaW1pdGVkIHN1cHBvcnQgZm9yIHZhcnt1fWludDY0 IChvbmx5IHRoZSAzMi1iaXQgdmFsdWVzKS4KICAtIEdldCByaWQgb2YgbXVjaCBvZiB0aGUgZnVu Y3Rpb24gaW5kZXggc3BhY2U6IHdlIGFscmVhZHkgaGF2ZSBhbGwgb2YgaXRzCiAgICBpbmZvcm1h dGlvbiBlbHNld2hlcmUsIGFuZCBhcy1pcyBpdCBwcm92aWRlcyBubyBleHRyYSBlZmZpY2llbmN5 LgogIC0gU3RvcmUgV2FzbTo6TWVtb3J5IGRpcmVjdGx5IG9uIEpTV2ViQXNzZW1ibHlNZW1vcnks IGluc3RlYWQgb2YgdGhyb3VnaCBhCiAgICB1bmlxdWVfcHRyLiBUaGlzIHJlbW92ZXMgYW4gaW5k aXJlY3Rpb24gYW5kIHVzZWxlc3MgYWxsb2NhdGlvbi4KICAtIFJlbW92ZSBWTSdhIFdlYkFzc2Vt Ymx5IG1lbW9yeSAvIHNpemUsIGFuZCBvYnRhaW4gdGhlbSBmcm9tIEluc3RhbmNlCiAgICBpbnN0 ZWFkLiBUaGlzIHJlcXVpcmVzIGFuIGV4dHJhIGluZGlyZWN0aW9uLCBidXQgaXMgY2xlYW5lci4K ICAtIENhY2hlIHRoZSB3YXNtIGVudHJ5cG9pbnQgY29kZSdzIGxvY2F0aW9uIG9uIFdlYkFzc2Vt Ymx5RnVuY3Rpb24gZm9yIGZhc3RlcgogICAgYWNjZXNzLgogIC0gQWxsIEluc3RhbmNlIG5vdyBo YXZlIGEgdmFsaWQgSlNXZWJBc3NlbWJseU1lbW9yeSB3aGVuIGNyZWF0ZWQsIHdoaWNoIGFsbG93 cwogICAgdGhlIHdhc20gLT4gd2FzbSBzdHViIHRvIGFzc3VtZSBpdCBpc24ndCBudWxsIHdoZW4g dHJ5aW5nIHRvIHNldCB0aGUgcGlubmVkCiAgICByZWdpc3RlcnMuCiAgLSBBbHdheXMgcGluIHJl Z2lzdGVycywgZXZlbiBpZiBubyBNZW1vcnkgaXMgcHJlc2VudCBhbmQgd2UgZG9uJ3QgdGVjaG5p Y2FsbHkKICAgIG5lZWQgdG8gcGluIHRoZW0uCi0tLQogSlNUZXN0cy9DaGFuZ2VMb2cgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMzUgKysrKwogSlNUZXN0cy93YXNtL0J1aWxk ZXIuanMgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgOTEgKysrKystLS0tCiBKU1Rlc3Rz L3dhc20vTG93TGV2ZWxCaW5hcnkuanMgICAgICAgICAgICAgICAgICAgICB8ICAxMiArKwogSlNU ZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMgICAgICAgICAgfCAgIDYgKy0K IEpTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMgICAgICAgICAgIHwgICAy ICstCiBKU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5qcyAgICAgICAgICB8 ICAgMiArLQogSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20tYmFkLXNpZ25hdHVyZS5q cyAgfCAxMDUgKysrKysrKysrKwogSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMg ICAgICAgICAgICAgICAgfCAgNzIgKysrKysrKwogU291cmNlL0phdmFTY3JpcHRDb3JlL0NNYWtl TGlzdHMudHh0ICAgICAgICAgICAgICAgfCAgIDEgKwogU291cmNlL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZyAgICAgICAgICAgICAgICAgICAgfCAxMjUgKysrKysrKysrKysrCiAuLi4vSmF2YVNj cmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiAgICAgICB8ICAgOCArLQogU291cmNl L0phdmFTY3JpcHRDb3JlL2pzYy5jcHAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgLQogU291 cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmggICAgICAgICAgICAgfCAgIDIgKwog U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuY3BwICAgfCAyMjIg KysrKysrKysrKysrKy0tLS0tLS0tCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQjNJ UkdlbmVyYXRvci5oICAgICB8ICAgMiArLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bUJpbmRpbmcuY3BwICAgICAgICAgfCAgNjcgKysrKysrLQogU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbUJpbmRpbmcuaCAgICAgICAgICAgfCAgIDIgKy0KIFNvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21Gb3JtYXQuaCAgICAgICAgICAgIHwgIDI4ICsrLQogU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmggICAgfCAgMTYgKy0KIFNvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuY3BwICAgICAgICAgIHwgIDU3ICsrKysrLQog U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5oICAgICAgICAgICAgfCAgMzEg KystCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5SW5mb3JtYXRpb24uY3BwICB8 ICA1OSArKysrLS0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnlJbmZvcm1h dGlvbi5oIHwgICA5ICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFy c2VyLmNwcCAgICB8ICAyNyArLS0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1 bGVQYXJzZXIuaCAgICAgIHwgICAyICstCiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt UGFnZUNvdW50LmNwcCAgICAgICB8ICA0NSArKysrKwogU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbVBhZ2VDb3VudC5oICAgICAgICAgfCAgIDYgKwogU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbVBsYW4uY3BwICAgICAgICAgICAgfCAgNDQgKystLQogU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbVBsYW4uaCAgICAgICAgICAgICAgfCAgMTQgKy0KIFNvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuY3BwICAgICAgIHwgIDE4ICstCiBTb3VyY2Uv SmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmggICAgICAgICB8ICAgMSArCiBTb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwICAgICAgICB8ICAgNCArLQog U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmggICAgICAgICAgfCAgIDIg Ky0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5oIHwg ICA5ICstCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNw cCB8ICAxMiArLQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9y eS5oICAgfCAgMTEgKy0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlN b2R1bGUuY3BwIHwgICA5ICstCiAuLi4vSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2Vt Ymx5TW9kdWxlLmggICB8ICAxNiArLQogLi4uL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNz ZW1ibHlGdW5jdGlvbi5jcHAgfCAgIDkgKy0KIC4uLi9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dl YkFzc2VtYmx5RnVuY3Rpb24uaCAgIHwgICA4ICstCiAuLi4vd2FzbS9qcy9XZWJBc3NlbWJseUlu c3RhbmNlQ29uc3RydWN0b3IuY3BwICAgICB8ICAyMCArLQogLi4uL3dhc20vanMvV2ViQXNzZW1i bHlNZW1vcnlDb25zdHJ1Y3Rvci5jcHAgICAgICAgfCAgIDIgKy0KIC4uLi93YXNtL2pzL1dlYkFz c2VtYmx5TW9kdWxlQ29uc3RydWN0b3IuY3BwICAgICAgIHwgICAyICstCiAuLi4vd2FzbS9qcy9X ZWJBc3NlbWJseU1vZHVsZVJlY29yZC5jcHAgICAgICAgICAgICB8ICAgOSArLQogNDQgZmlsZXMg Y2hhbmdlZCwgOTI3IGluc2VydGlvbnMoKyksIDI5OCBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2Rl IDEwMDY0NCBKU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS1iYWQtc2lnbmF0dXJlLmpz CiBjcmVhdGUgbW9kZSAxMDA2NDQgSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanMK IGNyZWF0ZSBtb2RlIDEwMDY0NCBTb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFnZUNv dW50LmNwcAoKZGlmZiAtLWdpdCBhL0pTVGVzdHMvQ2hhbmdlTG9nIGIvSlNUZXN0cy9DaGFuZ2VM b2cKaW5kZXggMDBmZDQ5OC4uOTBhN2NhNiAxMDA2NDQKLS0tIGEvSlNUZXN0cy9DaGFuZ2VMb2cK KysrIGIvSlNUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzOCBAQAorMjAxNi0xMi0zMCAgSkYg QmFzdGllbiAgPGpmYmFzdGllbkBhcHBsZS5jb20+CisKKyAgICAgICAgV2ViQXNzZW1ibHk6IGhh bmRsZSBhbmQgb3B0aW1pemUgd2FzbSBleHBvcnQg4oaSIHdhc20gaW1wb3J0IGNhbGxzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjUyODIKKworICAg ICAgICBSZXZpZXdlZCBieSBTYWFtIEJhcmF0aS4KKworICAgICAgICAqIHdhc20vQnVpbGRlci5q czogQWRkIGEgUHJveHkgdG8gQnVpbGRlci5qcywgd2hpY2ggaW50ZXJjZXB0cworICAgICAgICB1 bmtub3duIHByb3BlcnR5IGxvb2t1cHMuIFRoaXMgY3JlYXRlcyB3YXkgYmV0dGVyIGVycm9yIG1l c3NhZ2VzCisgICAgICAgIG9uIHR5cG9zIHRoYW4gJ3VuZGVmaW5lZCBpcyBub3QgYSBmdW5jdGlv bicsIHdoaWNoIGhhcHBlbnMKKyAgICAgICAgc2VtaS1mcmVxdWVudGx5IGFzIEkgdHlwbyBvcGNv ZGUgbmFtZXMgKGFuZCB3aGljaCBvbmUgaXMgYSB0eXBvIGlzCisgICAgICAgIGhhcmQgdG8gZmlu ZCBiZWNhdXNlIHdlIGNoYWluIGJ1aWxkZXJzKS4KKyAgICAgICAgKGNvbnN0Ll9pc1ZhbGlkVmFs dWUpOgorICAgICAgICAoZ2V0IHRhcmdldCk6CisgICAgICAgIChjb25zdC5faW1wb3J0RnVuY3Rp b25Db250aW51YXRpb24pOgorICAgICAgICAoY29uc3QuX2ltcG9ydE1lbW9yeUNvbnRpbnVhdGlv bik6CisgICAgICAgIChjb25zdC5faW1wb3J0VGFibGVDb250aW51YXRpb24pOgorICAgICAgICAo Y29uc3QuX2V4cG9ydEZ1bmN0aW9uQ29udGludWF0aW9uKToKKyAgICAgICAgKGV4cG9ydC5kZWZh dWx0LkJ1aWxkZXIucHJvdG90eXBlLl9yZWdpc3RlclNlY3Rpb25CdWlsZGVycy5jb25zdC5zZWN0 aW9uLmluLldBU00uZGVzY3JpcHRpb24uc2VjdGlvbi5zd2l0Y2guc2VjdGlvbi5jYXNlLnN0cmlu Z19hcHBlYXJlZF9oZXJlLnRoaXMuc2VjdGlvbik6CisgICAgICAgIChleHBvcnQuZGVmYXVsdC5C dWlsZGVyLnByb3RvdHlwZS5fcmVnaXN0ZXJTZWN0aW9uQnVpbGRlcnMudGhpcy5Vbmtub3duKToK KyAgICAgICAgKiB3YXNtL0xvd0xldmVsQmluYXJ5LmpzOiBBZGQgbGltaXRlZCBzdXBwb3J0IGZv ciB2YXJ7dX1pbnQ2NCAob25seSB0aGUgMzItYml0IHZhbHVlcykKKyAgICAgICAgKGV4cG9ydC5k ZWZhdWx0Lkxvd0xldmVsQmluYXJ5LnByb3RvdHlwZS52YXJpbnQzMik6CisgICAgICAgIChleHBv cnQuZGVmYXVsdC5Mb3dMZXZlbEJpbmFyeS5wcm90b3R5cGUudmFydWludDY0KToKKyAgICAgICAg KGV4cG9ydC5kZWZhdWx0Lkxvd0xldmVsQmluYXJ5LnByb3RvdHlwZS52YXJpbnQ2NCk6CisgICAg ICAgICogd2FzbS9mdW5jdGlvbi10ZXN0cy9leGNlcHRpb25zLmpzOiB1cGRhdGUgZXJyb3IgbWVz c2FnZQorICAgICAgICAqIHdhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpzOiB1cGRhdGUg ZXJyb3IgbWVzc2FnZQorICAgICAgICAqIHdhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5q czogdXBkYXRlIGVycm9yIG1lc3NhZ2UKKyAgICAgICAgKiB3YXNtL2pzLWFwaS93YXNtLXRvLXdh c20tYmFkLXNpZ25hdHVyZS5qczogQWRkZWQuIFRlc3QgYSBidW5jaCBvZiBiYWQgd2FzbS0+d2Fz bSBpbXBvcnQgc2lnbmF0dXJlcworICAgICAgICAoY29uc3QubWFrZUltcG9ydGVlLnNpZ25hdHVy ZS5zd2l0Y2gpOgorICAgICAgICAoQmFkU2lnbmF0dXJlRHJvcFN0YXJ0UGFyYW1zKToKKyAgICAg ICAgKiB3YXNtL2pzLWFwaS93YXNtLXRvLXdhc20uanM6IEFkZGVkLiBUZXN0IDY0LWJpdCB3YXNt LT53YXNtIGltcG9ydCBjYWxscworICAgICAgICAoY29uc3QuY2FsbGVyTW9kdWxlKToKKyAgICAg ICAgKGNvbnN0LmNhbGxlZU1vZHVsZSk6CisgICAgICAgIChXYXNtVG9XYXNtKToKKwogMjAxNi0x Mi0yOSAgU2FhbSBCYXJhdGkgIDxzYmFyYXRpQGFwcGxlLmNvbT4KIAogICAgICAgICBXZWJBc3Nl bWJseTogUmViYXNlIHNwZWMtdGVzdHMgbm93IHRoYXQgd2FidCBoYXMgYmVlbiB1cGRhdGVkIHRv IHByb2R1Y2UgY2VydGFpbiBraW5kcyBvZiBpbnZhbGlkIG1vZHVsZXMKZGlmZiAtLWdpdCBhL0pT VGVzdHMvd2FzbS9CdWlsZGVyLmpzIGIvSlNUZXN0cy93YXNtL0J1aWxkZXIuanMKaW5kZXggZGE1 ODRjNC4uMjZiYTY2ZSAxMDA2NDQKLS0tIGEvSlNUZXN0cy93YXNtL0J1aWxkZXIuanMKKysrIGIv SlNUZXN0cy93YXNtL0J1aWxkZXIuanMKQEAgLTM4LDcgKzM4LDcgQEAgY29uc3QgX2lzVmFsaWRW YWx1ZSA9ICh2YWx1ZSwgdHlwZSkgPT4gewogICAgIHN3aXRjaCAodHlwZSkgewogICAgIC8vIFdl IGFsbG93IGJvdGggc2lnbmVkIGFuZCB1bnNpZ25lZCBudW1iZXJzLgogICAgIGNhc2UgImkzMiI6 IHJldHVybiBNYXRoLnJvdW5kKHZhbHVlKSA9PT0gdmFsdWUgJiYgTExCLnZhcmludDMyTWluIDw9 IHZhbHVlICYmIHZhbHVlIDw9IExMQi52YXJ1aW50MzJNYXg7Ci0gICAgY2FzZSAiaTY0IjogdGhy b3cgbmV3IEVycm9yKGBVbmltcGxlbWVudGVkOiB2YWx1ZSBjaGVjayBmb3IgJHt0eXBlfWApOyAv LyBGSVhNRSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNDIwIDY0 LWJpdCB2YWx1ZXMKKyAgICBjYXNlICJpNjQiOiByZXR1cm4gdHJ1ZTsgLy8gRklYTUUgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MzQyMCA2NC1iaXQgdmFsdWVzCiAg ICAgY2FzZSAiZjMyIjogcmV0dXJuIHR5cGVvZih2YWx1ZSkgPT09ICJudW1iZXIiICYmIGlzRmlu aXRlKHZhbHVlKTsKICAgICBjYXNlICJmNjQiOiByZXR1cm4gdHlwZW9mKHZhbHVlKSA9PT0gIm51 bWJlciIgJiYgaXNGaW5pdGUodmFsdWUpOwogICAgIGRlZmF1bHQ6IHRocm93IG5ldyBFcnJvcihg SW1wbGVtZW50YXRpb24gcHJvYmxlbTogdW5rbm93biB0eXBlICR7dHlwZX1gKTsKQEAgLTU3LDYg KzU3LDE2IEBAIGNvbnN0IF9ub3JtYWxpemVGdW5jdGlvblNpZ25hdHVyZSA9IChwYXJhbXMsIHJl dCkgPT4gewogICAgIHJldHVybiBbcGFyYW1zLCByZXRdOwogfTsKIAorY29uc3QgX2Vycm9ySGFu ZGxpbmdQcm94eUZvciA9IGJ1aWxkZXIgPT4gYnVpbGRlclsiX19pc1Byb3h5Il0gPyBidWlsZGVy IDogbmV3IFByb3h5KGJ1aWxkZXIsIHsKKyAgICBnZXQ6ICh0YXJnZXQsIHByb3BlcnR5LCByZWNl aXZlcikgPT4geworICAgICAgICBpZiAocHJvcGVydHkgPT09ICJfX2lzUHJveHkiKQorICAgICAg ICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIGlmICh0YXJnZXRbcHJvcGVydHldID09PSB1bmRl ZmluZWQpCisgICAgICAgICAgICB0aHJvdyBuZXcgRXJyb3IoYFdlYkFzc2VtYmx5IGJ1aWxkZXIg cmVjZWl2ZWQgdW5rbm93biBwcm9wZXJ0eSAnJHtwcm9wZXJ0eX0nYCk7CisgICAgICAgIHJldHVy biB0YXJnZXRbcHJvcGVydHldOworICAgIH0KK30pOworCiBjb25zdCBfbWF5YmVSZWdpc3RlclR5 cGUgPSAoYnVpbGRlciwgdHlwZSkgPT4gewogICAgIGNvbnN0IHR5cGVTZWN0aW9uID0gYnVpbGRl ci5fZ2V0U2VjdGlvbigiVHlwZSIpOwogICAgIGlmICh0eXBlb2YodHlwZSkgPT09ICJudW1iZXIi KSB7CkBAIC0xMDAsNyArMTEwLDcgQEAgY29uc3QgX2ltcG9ydEZ1bmN0aW9uQ29udGludWF0aW9u ID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAgIHNlY3Rpb24u ZGF0YS5wdXNoKHsgZmllbGQ6IGZpZWxkLCB0eXBlOiB0eXBlLCBraW5kOiAiRnVuY3Rpb24iLCBt b2R1bGU6IG1vZHVsZSB9KTsKICAgICAgICAgLy8gSW1wb3J0cyBhbHNvIGNvdW50IGluIHRoZSBm dW5jdGlvbiBpbmRleCBzcGFjZS4gTWFwIHRoZW0gYXMgb2JqZWN0cyB0byBhdm9pZCBjbGFzaGlu ZyB3aXRoIENvZGUgZnVuY3Rpb25zJyBuYW1lcy4KICAgICAgICAgYnVpbGRlci5fcmVnaXN0ZXJG dW5jdGlvblRvSW5kZXhTcGFjZSh7IG1vZHVsZTogbW9kdWxlLCBmaWVsZDogZmllbGQgfSk7Ci0g ICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5n UHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH07CiB9OwogCkBAIC0xMDksNyArMTE5LDcgQEAg Y29uc3QgX2ltcG9ydE1lbW9yeUNvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0 QnVpbGRlcikgPT4gewogICAgICAgICBhc3NlcnQuaXNTdHJpbmcobW9kdWxlLCBgSW1wb3J0IE1l bW9yeSBtb2R1bGUgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7bW9kdWxlfSJgKTsKICAgICAg ICAgYXNzZXJ0LmlzU3RyaW5nKGZpZWxkLCBgSW1wb3J0IE1lbW9yeSBmaWVsZCBzaG91bGQgYmUg YSBzdHJpbmcsIGdvdCAiJHtmaWVsZH0iYCk7CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNoKHtt b2R1bGUsIGZpZWxkLCBraW5kOiAiTWVtb3J5IiwgbWVtb3J5RGVzY3JpcHRpb246IHtpbml0aWFs LCBtYXhpbXVtfX0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVy biBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9OwogfTsKIApAQCAt MTE4LDcgKzEyOCw3IEBAIGNvbnN0IF9pbXBvcnRUYWJsZUNvbnRpbnVhdGlvbiA9IChidWlsZGVy LCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgICAgICBhc3NlcnQuaXNTdHJpbmcobW9k dWxlLCBgSW1wb3J0IFRhYmxlIG1vZHVsZSBzaG91bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHttb2R1 bGV9ImApOwogICAgICAgICBhc3NlcnQuaXNTdHJpbmcoZmllbGQsIGBJbXBvcnQgVGFibGUgZmll bGQgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7ZmllbGR9ImApOwogICAgICAgICBzZWN0aW9u LmRhdGEucHVzaCh7bW9kdWxlLCBmaWVsZCwga2luZDogIlRhYmxlIiwgdGFibGVEZXNjcmlwdGlv bjoge2luaXRpYWwsIG1heGltdW0sIGVsZW1lbnR9fSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVp bGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIp OwogICAgIH07CiB9OwogCkBAIC0xNzIsNyArMTgyLDcgQEAgY29uc3QgX2V4cG9ydEZ1bmN0aW9u Q29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAg ICAgICAgICAgICAgYXNzZXJ0LmVxKHR5cGUsIGV4cG9ydGVkSW1wb3J0LnR5cGUsIGBSZS1leHBv cnRpbmcgaW1wb3J0ICIke2V4cG9ydGVkSW1wb3J0LmZpZWxkfSIgYXMgIiR7ZmllbGR9IiBoYXMg bWlzbWF0Y2hpbmcgdHlwZWApOwogICAgICAgICB9CiAgICAgICAgIHNlY3Rpb24uZGF0YS5wdXNo KHsgZmllbGQ6IGZpZWxkLCB0eXBlOiB0eXBlLCBraW5kOiAiRnVuY3Rpb24iLCBpbmRleDogaW5k ZXggfSk7Ci0gICAgICAgIHJldHVybiBuZXh0QnVpbGRlcjsKKyAgICAgICAgcmV0dXJuIF9lcnJv ckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIpOwogICAgIH07CiB9OwogCkBAIC0xODksNyAr MTk5LDcgQEAgY29uc3QgX2V4cG9ydEdsb2JhbENvbnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0 aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgIHJldHVybiAoZmllbGQsIGluZGV4KSA9PiB7CiAg ICAgICAgIGFzc2VydC5pc051bWJlcihpbmRleCwgYEdsb2JhbCBleHBvcnRzIG9ubHkgc3VwcG9y dCBudW1iZXIgaW5kaWNlcyByaWdodCBub3dgKTsKICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2go eyBmaWVsZCwga2luZDogIkdsb2JhbCIsIGluZGV4IH0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1 aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVy KTsKICAgICB9CiB9OwogCkBAIC0xOTcsNyArMjA3LDcgQEAgY29uc3QgX2V4cG9ydE1lbW9yeUNv bnRpbnVhdGlvbiA9IChidWlsZGVyLCBzZWN0aW9uLCBuZXh0QnVpbGRlcikgPT4gewogICAgIHJl dHVybiAoZmllbGQsIGluZGV4KSA9PiB7CiAgICAgICAgIGFzc2VydC5pc051bWJlcihpbmRleCwg YE1lbW9yeSBleHBvcnRzIG9ubHkgc3VwcG9ydCBudW1iZXIgaW5kaWNlc2ApOwogICAgICAgICBz ZWN0aW9uLmRhdGEucHVzaCh7ZmllbGQsIGtpbmQ6ICJNZW1vcnkiLCBpbmRleH0pOwotICAgICAg ICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5 Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9CiB9OwogCkBAIC0yMDUsNyArMjE1LDcgQEAgY29uc3Qg X2V4cG9ydFRhYmxlQ29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rpb24sIG5leHRCdWlsZGVy KSA9PiB7CiAgICAgcmV0dXJuIChmaWVsZCwgaW5kZXgpID0+IHsKICAgICAgICAgYXNzZXJ0Lmlz TnVtYmVyKGluZGV4LCBgVGFibGUgZXhwb3J0cyBvbmx5IHN1cHBvcnQgbnVtYmVyIGluZGljZXNg KTsKICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2goe2ZpZWxkLCBraW5kOiAiVGFibGUiLCBpbmRl eH0pOwotICAgICAgICByZXR1cm4gbmV4dEJ1aWxkZXI7CisgICAgICAgIHJldHVybiBfZXJyb3JI YW5kbGluZ1Byb3h5Rm9yKG5leHRCdWlsZGVyKTsKICAgICB9CiB9OwogCkBAIC0yMjAsMTAgKzIz MCwxMCBAQCBjb25zdCBfaW1wb3J0R2xvYmFsQ29udGludWF0aW9uID0gKGJ1aWxkZXIsIHNlY3Rp b24sIG5leHRCdWlsZGVyKSA9PiB7CiAgICAgICAgICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKGZp ZWxkLCBgSW1wb3J0IGdsb2JhbCBmaWVsZCBzaG91bGQgYmUgYSBzdHJpbmcsIGdvdCAiJHtmaWVs ZH0iYCk7CiAgICAgICAgICAgICAgICAgYXNzZXJ0LmlzU3RyaW5nKG11dGFiaWxpdHksIGBJbXBv cnQgZ2xvYmFsIG11dGFiaWxpdHkgc2hvdWxkIGJlIGEgc3RyaW5nLCBnb3QgIiR7bXV0YWJpbGl0 eX0iYCk7CiAgICAgICAgICAgICAgICAgc2VjdGlvbi5kYXRhLnB1c2goeyBnbG9iYWxEZXNjcmlw dGlvbjogeyB0eXBlOiBvcCwgbXV0YWJpbGl0eTogX25vcm1hbGl6ZU11dGFiaWxpdHkobXV0YWJp bGl0eSkgfSwgbW9kdWxlLCBmaWVsZCwga2luZDogIkdsb2JhbCIgfSk7Ci0gICAgICAgICAgICAg ICAgcmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhh bmRsaW5nUHJveHlGb3IoZ2xvYmFsQnVpbGRlcik7CiAgICAgICAgICAgICB9OwogICAgICAgICB9 Ci0gICAgICAgIHJldHVybiBnbG9iYWxCdWlsZGVyOworICAgICAgICByZXR1cm4gX2Vycm9ySGFu ZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICB9OwogfTsKIApAQCAtMzI0LDExICsz MzQsMTEgQEAgY29uc3QgX2NyZWF0ZUZ1bmN0aW9uQnVpbGRlciA9IChmdW5jLCBidWlsZGVyLCBw cmV2aW91c0J1aWxkZXIpID0+IHsKICAgICAgICAgICAgIGRlZmF1bHQ6CiAgICAgICAgICAgICAg ICAgbmV4dEJ1aWxkZXIgPSBmdW5jdGlvbkJ1aWxkZXI7CiAgICAgICAgICAgICAgICAgYnJlYWs7 Ci0gICAgICAgICAgICAgICAgY2FzZSAiRW5kIjoKKyAgICAgICAgICAgIGNhc2UgIkVuZCI6CiAg ICAgICAgICAgICAgICAgbmV4dEJ1aWxkZXIgPSBwcmV2aW91c0J1aWxkZXI7Ci0gICAgICAgICAg ICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICAgY2Fz ZSAiQmxvY2siOgotICAgICAgICAgICAgICAgIGNhc2UgIkxvb3AiOgorICAgICAgICAgICAgY2Fz ZSAiTG9vcCI6CiAgICAgICAgICAgICBjYXNlICJJZiI6CiAgICAgICAgICAgICAgICAgbmV4dEJ1 aWxkZXIgPSBfY3JlYXRlRnVuY3Rpb25CdWlsZGVyKGZ1bmMsIGJ1aWxkZXIsIGZ1bmN0aW9uQnVp bGRlcik7CiAgICAgICAgICAgICAgICAgYnJlYWs7CkBAIC0zNDQsMTEgKzM1NCwxMiBAQCBjb25z dCBfY3JlYXRlRnVuY3Rpb25CdWlsZGVyID0gKGZ1bmMsIGJ1aWxkZXIsIHByZXZpb3VzQnVpbGRl cikgPT4gewogICAgICAgICAgICAgY29uc3Qgc3RhY2tBcmdzID0gW107IC8vIEZJWE1FIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjI3MDYKICAgICAgICAgICAgIGZ1 bmMuY29kZS5wdXNoKHsgbmFtZTogb3AsIHZhbHVlOiB2YWx1ZSwgYXJndW1lbnRzOiBzdGFja0Fy Z3MsIGltbWVkaWF0ZXM6IGltbXMgfSk7CiAgICAgICAgICAgICBpZiAoaGFzQ29udGludWF0aW9u KQotICAgICAgICAgICAgICAgIHJldHVybiBjb250aW51YXRpb24obmV4dEJ1aWxkZXIpLkVuZCgp OwotICAgICAgICAgICAgcmV0dXJuIG5leHRCdWlsZGVyOworICAgICAgICAgICAgICAgIHJldHVy biBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGNvbnRpbnVhdGlvbihuZXh0QnVpbGRlcikuRW5kKCkp OworICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3IobmV4dEJ1aWxkZXIp OwogICAgICAgICB9OwotICAgIH0KLSAgICByZXR1cm4gZnVuY3Rpb25CdWlsZGVyOworICAgIH07 CisKKyAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihmdW5jdGlvbkJ1aWxkZXIpOwog fQogCiBjb25zdCBfY3JlYXRlRnVuY3Rpb24gPSAoc2VjdGlvbiwgYnVpbGRlciwgcHJldmlvdXNC dWlsZGVyKSA9PiB7CkBAIC00NDksMTAgKzQ2MCwxMCBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBC dWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgIEZ1bmM6IChwYXJhbXMsIHJldCkgPT4g ewogICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtwYXJhbXMsIHJldF0gPSBfbm9ybWFsaXpl RnVuY3Rpb25TaWduYXR1cmUocGFyYW1zLCByZXQpOwogICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHMuZGF0YS5wdXNoKHsgcGFyYW1zOiBwYXJhbXMsIHJldDogcmV0IH0pOwotICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHJldHVybiB0eXBlQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICByZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcih0eXBlQnVpbGRlcik7CiAg ICAgICAgICAgICAgICAgICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICB9OwotICAgICAg ICAgICAgICAgICAgICByZXR1cm4gdHlwZUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJl dHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHR5cGVCdWlsZGVyKTsKICAgICAgICAgICAgICAg ICB9OwogICAgICAgICAgICAgICAgIGJyZWFrOwogCkBAIC00NjYsNyArNDc3LDcgQEAgZXhwb3J0 IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgIGltcG9ydEJ1aWxk ZXIuRnVuY3Rpb24gPSBfaW1wb3J0RnVuY3Rpb25Db250aW51YXRpb24odGhpcywgcywgaW1wb3J0 QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgIGltcG9ydEJ1aWxkZXIuTWVtb3J5ID0gX2lt cG9ydE1lbW9yeUNvbnRpbnVhdGlvbih0aGlzLCBzLCBpbXBvcnRCdWlsZGVyKTsKICAgICAgICAg ICAgICAgICAgICAgaW1wb3J0QnVpbGRlci5UYWJsZSA9IF9pbXBvcnRUYWJsZUNvbnRpbnVhdGlv bih0aGlzLCBzLCBpbXBvcnRCdWlsZGVyKTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGlt cG9ydEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1By b3h5Rm9yKGltcG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAg ICAgYnJlYWs7CiAKQEAgLTQ3Nyw3ICs0ODgsNyBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWls ZGVyIHsKICAgICAgICAgICAgICAgICAgICAgICAgIEVuZDogKCkgPT4gdGhpcwogICAgICAgICAg ICAgICAgICAgICAgICAgLy8gRklYTUU6IGFkZCBhYmlsaXR5IHRvIGFkZCB0aGlzIHdpdGggd2hh dGV2ZXIuCiAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAgICAgICAgICAgICAgICAgIHJldHVy biBmdW5jdGlvbkJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5k bGluZ1Byb3h5Rm9yKGZ1bmN0aW9uQnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAg ICAgICAgICAgICBicmVhazsKIApAQCAtNDg4LDEwICs0OTksMTAgQEAgZXhwb3J0IGRlZmF1bHQg Y2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBFbmQ6ICgpID0+IHRoaXMs CiAgICAgICAgICAgICAgICAgICAgICAgICBUYWJsZTogKHtpbml0aWFsLCBtYXhpbXVtLCBlbGVt ZW50fSkgPT4gewogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKHt0YWJs ZURlc2NyaXB0aW9uOiB7aW5pdGlhbCwgbWF4aW11bSwgZWxlbWVudH19KTsKLSAgICAgICAgICAg ICAgICAgICAgICAgICAgICByZXR1cm4gdGFibGVCdWlsZGVyOworICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHRhYmxlQnVpbGRlcik7CiAg ICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgIH07Ci0gICAgICAg ICAgICAgICAgICAgIHJldHVybiB0YWJsZUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJl dHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHRhYmxlQnVpbGRlcik7CiAgICAgICAgICAgICAg ICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNTAyLDEwICs1MTMsMTAgQEAgZXhw b3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICBFbmQ6 ICgpID0+IHRoaXMsCiAgICAgICAgICAgICAgICAgICAgICAgICBJbml0aWFsTWF4UGFnZXM6IChp bml0aWFsLCBtYXgpID0+IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVz aCh7IGluaXRpYWwsIG1heCB9KTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4g bWVtb3J5QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gX2Vycm9y SGFuZGxpbmdQcm94eUZvcihtZW1vcnlCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAg IH0KICAgICAgICAgICAgICAgICAgICAgfTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIG1l bW9yeUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1By b3h5Rm9yKG1lbW9yeUJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAg ICAgYnJlYWs7CiAKQEAgLTUxNiwxNiArNTI3LDE2IEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1 aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRW5kOiAoKSA9PiB0aGlzLAogICAgICAg ICAgICAgICAgICAgICAgICAgR2V0R2xvYmFsOiAodHlwZSwgaW5pdFZhbHVlLCBtdXRhYmlsaXR5 KSA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcy5kYXRhLnB1c2goeyB0eXBlLCBv cDogImdldF9nbG9iYWwiLCBtdXRhYmlsaXR5OiBfbm9ybWFsaXplTXV0YWJpbGl0eShtdXRhYmls aXR5KSwgaW5pdFZhbHVlIH0pOwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBn bG9iYWxCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JI YW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgICAgICAgICAg fQogICAgICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgICAgICBmb3IgKGxldCBv cCBvZiBXQVNNLmRlc2NyaXB0aW9uLnZhbHVlX3R5cGUpIHsKICAgICAgICAgICAgICAgICAgICAg ICAgIGdsb2JhbEJ1aWxkZXJbX3RvSmF2YVNjcmlwdE5hbWUob3ApXSA9IChpbml0VmFsdWUsIG11 dGFiaWxpdHkpID0+IHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzLmRhdGEucHVzaCh7 IHR5cGU6IG9wLCBvcDogb3AgKyAiLmNvbnN0IiwgbXV0YWJpbGl0eTogX25vcm1hbGl6ZU11dGFi aWxpdHkobXV0YWJpbGl0eSksIGluaXRWYWx1ZSB9KTsKLSAgICAgICAgICAgICAgICAgICAgICAg ICAgICByZXR1cm4gZ2xvYmFsQnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihnbG9iYWxCdWlsZGVyKTsKICAgICAgICAgICAg ICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgICAgICAg ICAgcmV0dXJuIGdsb2JhbEJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJy b3JIYW5kbGluZ1Byb3h5Rm9yKGdsb2JhbEJ1aWxkZXIpOwogICAgICAgICAgICAgICAgIH07CiAg ICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTUzOSw3ICs1NTAsNyBAQCBleHBvcnQgZGVmYXVs dCBjbGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICAgICAgZXhwb3J0QnVpbGRlci5GdW5j dGlvbiA9IF9leHBvcnRGdW5jdGlvbkNvbnRpbnVhdGlvbih0aGlzLCBzLCBleHBvcnRCdWlsZGVy KTsKICAgICAgICAgICAgICAgICAgICAgZXhwb3J0QnVpbGRlci5NZW1vcnkgPSBfZXhwb3J0TWVt b3J5Q29udGludWF0aW9uKHRoaXMsIHMsIGV4cG9ydEJ1aWxkZXIpOwogICAgICAgICAgICAgICAg ICAgICBleHBvcnRCdWlsZGVyLlRhYmxlID0gX2V4cG9ydFRhYmxlQ29udGludWF0aW9uKHRoaXMs IHMsIGV4cG9ydEJ1aWxkZXIpOwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gZXhwb3J0QnVp bGRlcjsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3Io ZXhwb3J0QnVpbGRlcik7CiAgICAgICAgICAgICAgICAgfTsKICAgICAgICAgICAgICAgICBicmVh azsKIApAQCAtNTUyLDcgKzU2Myw3IEBAIGV4cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewog ICAgICAgICAgICAgICAgICAgICBpZiAodHlwZW9mKGZ1bmN0aW9uSW5kZXhPck5hbWUpICE9PSAi bnVtYmVyIiAmJiB0eXBlb2YoZnVuY3Rpb25JbmRleE9yTmFtZSkgIT09ICJzdHJpbmciKQogICAg ICAgICAgICAgICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBTdGFydCBzZWN0aW9uJ3MgZnVu Y3Rpb24gaW5kZXggIG11c3QgZWl0aGVyIGJlIGEgbnVtYmVyIG9yIGEgc3RyaW5nYCk7CiAgICAg ICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKGZ1bmN0aW9uSW5kZXhPck5hbWUpOwotICAgICAg ICAgICAgICAgICAgICByZXR1cm4gc3RhcnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihzdGFydEJ1aWxkZXIpOwogICAgICAgICAgICAg ICAgIH07CiAgICAgICAgICAgICAgICAgYnJlYWs7CiAKQEAgLTU2MywxMSArNTc0LDExIEBAIGV4 cG9ydCBkZWZhdWx0IGNsYXNzIEJ1aWxkZXIgewogICAgICAgICAgICAgICAgICAgICAgICAgRW5k OiAoKSA9PiB0aGlzLAogICAgICAgICAgICAgICAgICAgICAgICAgRWxlbWVudDogKHt0YWJsZUlu ZGV4ID0gMCwgb2Zmc2V0LCBmdW5jdGlvbkluZGljZXN9KSA9PiB7CiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgcy5kYXRhLnB1c2goe3RhYmxlSW5kZXgsIG9mZnNldCwgZnVuY3Rpb25JbmRp Y2VzfSk7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGVsZW1lbnRCdWlsZGVy OworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5 Rm9yKGVsZW1lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAg ICAgICAgICAgICAgfTsKIAotICAgICAgICAgICAgICAgICAgICByZXR1cm4gZWxlbWVudEJ1aWxk ZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKGVs ZW1lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAgICAgICAgICAgIGJyZWFr OwogCkBAIC02MzIsMTIgKzY0MywxMiBAQCBleHBvcnQgZGVmYXVsdCBjbGFzcyBCdWlsZGVyIHsK ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIEZJWE1FIGluIGNoZWNrZWQg bW9kZSwgdGVzdCB0aGF0IHRoZSB0eXBlIGlzIGFjY2VwdGFibGUgZm9yIHN0YXJ0IGZ1bmN0aW9u LiBXZSBwcm9iYWJseSB3YW50IF9yZWdpc3RlckZ1bmN0aW9uVG9JbmRleFNwYWNlIHRvIGFsc28g cmVnaXN0ZXIgdHlwZXMgcGVyIGluZGV4LiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MTY1NjU4CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAg ICAgICAgICAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0 dXJuIGJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhh bmRsaW5nUHJveHlGb3IoYnVpbGRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgICB9LAogCiAg ICAgICAgICAgICAgICAgICAgIH07CiAgICAgICAgICAgICAgICAgICAgIGNvZGVCdWlsZGVyLkZ1 bmN0aW9uID0gX2NyZWF0ZUZ1bmN0aW9uKHMsIGJ1aWxkZXIsIGNvZGVCdWlsZGVyKTsKLSAgICAg ICAgICAgICAgICAgICAgcmV0dXJuIGNvZGVCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihjb2RlQnVpbGRlcik7CiAgICAgICAgICAgICAg ICAgfTsKICAgICAgICAgICAgICAgICBicmVhazsKIApAQCAtNjYwLDE5ICs2NzEsMTkgQEAgZXhw b3J0IGRlZmF1bHQgY2xhc3MgQnVpbGRlciB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIEluZGV4OiBpbmRleCA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBhc3NlcnQuZXEoaW5kZXgsIDApOyAvLyBMaW5lYXIgbWVtb3J5IGluZGV4IG11c3QgYmUgemVy byBpbiBNVlAuCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0aGlzU2VnbWVu dC5pbmRleCA9IGluZGV4OwotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0 dXJuIHNlZ21lbnRCdWlsZGVyOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg cmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3Ioc2VnbWVudEJ1aWxkZXIpOwogICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBPZmZzZXQ6IG9mZnNldCA9PiB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAvLyBGSVhNRSBhbGxvdyBjb21wbGV4IGluaXRfZXhwciBoZXJlLiBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1NzAwCiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBhc3NlcnQuaXNOdW1iZXIob2Zmc2V0KTsKICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHRoaXNTZWdtZW50Lm9mZnNldCA9IG9mZnNldDsKLSAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBzZWdtZW50QnVpbGRlcjsKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9y KHNlZ21lbnRCdWlsZGVyKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfSwKICAg ICAgICAgICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAgICAgICAgICAgICAgICAgICAg IHJldHVybiBzZWdtZW50QnVpbGRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1 cm4gX2Vycm9ySGFuZGxpbmdQcm94eUZvcihzZWdtZW50QnVpbGRlcik7CiAgICAgICAgICAgICAg ICAgICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICB9OwotICAgICAgICAgICAgICAgICAg ICByZXR1cm4gZGF0YUJ1aWxkZXI7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBfZXJyb3JI YW5kbGluZ1Byb3h5Rm9yKGRhdGFCdWlsZGVyKTsKICAgICAgICAgICAgICAgICB9OwogICAgICAg ICAgICAgICAgIGJyZWFrOwogCkBAIC02OTAsMTAgKzcwMSwxMCBAQCBleHBvcnQgZGVmYXVsdCBj bGFzcyBCdWlsZGVyIHsKICAgICAgICAgICAgICAgICBCeXRlOiBiID0+IHsKICAgICAgICAgICAg ICAgICAgICAgYXNzZXJ0LmVxKGIgJiAweEZGLCBiLCBgVW5rbm93biBzZWN0aW9uIGV4cGVjdGVk IGJ5dGUsIGdvdDogIiR7Yn0iYCk7CiAgICAgICAgICAgICAgICAgICAgIHMuZGF0YS5wdXNoKGIp OwotICAgICAgICAgICAgICAgICAgICByZXR1cm4gdW5rbm93bkJ1aWxkZXI7CisgICAgICAgICAg ICAgICAgICAgIHJldHVybiBfZXJyb3JIYW5kbGluZ1Byb3h5Rm9yKHVua25vd25CdWlsZGVyKTsK ICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9OwotICAgICAgICAgICAgcmV0dXJuIHVu a25vd25CdWlsZGVyOworICAgICAgICAgICAgcmV0dXJuIF9lcnJvckhhbmRsaW5nUHJveHlGb3Io dW5rbm93bkJ1aWxkZXIpOwogICAgICAgICB9OwogICAgIH0KICAgICBfYWRkU2VjdGlvbihuYW1l T3JOdW1iZXIsIGV4dHJhT2JqZWN0KSB7CmRpZmYgLS1naXQgYS9KU1Rlc3RzL3dhc20vTG93TGV2 ZWxCaW5hcnkuanMgYi9KU1Rlc3RzL3dhc20vTG93TGV2ZWxCaW5hcnkuanMKaW5kZXggNjExYTI2 ZC4uZjliYzhhMyAxMDA2NDQKLS0tIGEvSlNUZXN0cy93YXNtL0xvd0xldmVsQmluYXJ5LmpzCisr KyBiL0pTVGVzdHMvd2FzbS9Mb3dMZXZlbEJpbmFyeS5qcwpAQCAtMTcwLDYgKzE3MCwxOCBAQCBl eHBvcnQgZGVmYXVsdCBjbGFzcyBMb3dMZXZlbEJpbmFyeSB7CiAgICAgICAgICAgICB0aGlzLnVp bnQ4KDB4ODAgfCBiKTsKICAgICAgICAgfSB3aGlsZSAodHJ1ZSk7CiAgICAgfQorICAgIHZhcnVp bnQ2NCh2KSB7CisgICAgICAgIGFzc2VydC5pc051bWJlcih2KTsKKyAgICAgICAgaWYgKHYgPCB2 YXJ1aW50MzJNaW4gfHwgdmFydWludDMyTWF4IDwgdikKKyAgICAgICAgICAgIHRocm93IG5ldyBS YW5nZUVycm9yKGB1bmltcGxlbWVudGVkOiB2YXJ1aW50NjQgbGFyZ2VyIHRoYW4gMzItYml0YCk7 CisgICAgICAgIHRoaXMudmFydWludDMyKHYpOyAvLyBGSVhNRSBpbXBsZW1lbnQgNjQtYml0IHZh cnt1fWludCBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNDIwCisg ICAgfQorICAgIHZhcmludDY0KHYpIHsKKyAgICAgICAgYXNzZXJ0LmlzTnVtYmVyKHYpOworICAg ICAgICBpZiAodiA8IHZhcmludDMyTWluIHx8IHZhcmludDMyTWF4IDwgdikKKyAgICAgICAgICAg IHRocm93IG5ldyBSYW5nZUVycm9yKGB1bmltcGxlbWVudGVkOiB2YXJpbnQ2NCBsYXJnZXIgdGhh biAzMi1iaXRgKTsKKyAgICAgICAgdGhpcy52YXJpbnQzMih2KTsgLy8gRklYTUUgaW1wbGVtZW50 IDY0LWJpdCB2YXJ7dX1pbnQgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE2MzQyMAorICAgIH0KICAgICB2YXJ1aW50MSh2KSB7CiAgICAgICAgIGlmICh2ICE9PSAwICYm IHYgIT09IDEpCiAgICAgICAgICAgICB0aHJvdyBuZXcgUmFuZ2VFcnJvcihgSW52YWxpZCB2YXJ1 aW50MSAke3Z9IHJhbmdlIGlzIFswLCAxXWApOwpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2Z1 bmN0aW9uLXRlc3RzL2V4Y2VwdGlvbnMuanMgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMv ZXhjZXB0aW9ucy5qcwppbmRleCBkMmIzYTQ5Li45NTI1MTNmIDEwMDY0NAotLS0gYS9KU1Rlc3Rz L3dhc20vZnVuY3Rpb24tdGVzdHMvZXhjZXB0aW9ucy5qcworKysgYi9KU1Rlc3RzL3dhc20vZnVu Y3Rpb24tdGVzdHMvZXhjZXB0aW9ucy5qcwpAQCAtNDUsMTggKzQ1LDE4IEBAIGZ1bmN0aW9uIG1h a2VJbnN0YW5jZSgpIHsKICAgICBhc3NlcnQuZXEodGFibGUuZ2V0KDApLCBudWxsKTsKIAogICAg IGZvciAobGV0IGkgPSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0gICAgICAgIGFzc2VydC50aHJvd3Mo KCkgPT4gZm9vKDAsIGkpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJjYWxsX2luZGlyZWN0 IHRvIGEgbnVsbCB0YWJsZSBlbnRyeSAoZXZhbHVhdGluZyAnZnVuYyguLi5hcmdzKScpIik7Cisg ICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDAsIGkpLCBXZWJBc3NlbWJseS5SdW50aW1l RXJyb3IsICJjYWxsX2luZGlyZWN0IHRvIGEgbnVsbCB0YWJsZSBlbnRyeSIpOwogICAgIH0KIAog ICAgIHRhYmxlLnNldCgwLCBmb28pOwogICAgIGFzc2VydC5lcSh0YWJsZS5nZXQoMCksIGZvbyk7 CiAKICAgICBmb3IgKGxldCBpID0gMDsgaSA8IDEwMDA7IGkrKykgewotICAgICAgICBhc3NlcnQu dGhyb3dzKCgpID0+IGZvbygxICsgaSwgaSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgIk91 dCBvZiBib3VuZHMgY2FsbF9pbmRpcmVjdCAoZXZhbHVhdGluZyAnZnVuYyguLi5hcmdzKScpIik7 CisgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDEgKyBpLCBpKSwgV2ViQXNzZW1ibHku UnVudGltZUVycm9yLCAiT3V0IG9mIGJvdW5kcyBjYWxsX2luZGlyZWN0Iik7CiAgICAgfQogCiAg ICAgZm9yIChsZXQgaSA9IDA7IGkgPCAxMDAwOyBpKyspIHsKLSAgICAgICAgYXNzZXJ0LnRocm93 cygoKSA9PiBmb28oMCwgaSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgImNhbGxfaW5kaXJl Y3QgdG8gYSBzaWduYXR1cmUgdGhhdCBkb2VzIG5vdCBtYXRjaCAoZXZhbHVhdGluZyAnZnVuYygu Li5hcmdzKScpIik7CisgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gZm9vKDAsIGkpLCBXZWJB c3NlbWJseS5SdW50aW1lRXJyb3IsICJjYWxsX2luZGlyZWN0IHRvIGEgc2lnbmF0dXJlIHRoYXQg ZG9lcyBub3QgbWF0Y2giKTsKICAgICB9CiAKICAgICB0YWJsZS5zZXQoMCwgYmFyKTsKZGlmZiAt LWdpdCBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMgYi9KU1Rlc3Rz L3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1sb2FkLmpzCmluZGV4IDRkZDgyZGMuLjEyMzFlMDMg MTAwNjQ0Ci0tLSBhL0pTVGVzdHMvd2FzbS9mdW5jdGlvbi10ZXN0cy90cmFwLWxvYWQuanMKKysr IGIvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtbG9hZC5qcwpAQCAtMjksNiArMjks NiBAQCBmdW5jdGlvbiB3YXNtRnJhbWVDb3VudEZyb21FcnJvcihlKSB7CiB9CiAKIGZvciAobGV0 IGkgPSAwOyBpIDwgMTAwMDsgaSsrKSB7Ci0gICAgY29uc3QgZSA9IGFzc2VydC50aHJvd3MoKCkg PT4gZm9vKG51bVBhZ2VzICogcGFnZVNpemUgKyAxKSwgV2ViQXNzZW1ibHkuUnVudGltZUVycm9y LCAiT3V0IG9mIGJvdW5kcyBtZW1vcnkgYWNjZXNzIChldmFsdWF0aW5nICdmdW5jKC4uLmFyZ3Mp JykiKTsKKyAgICBjb25zdCBlID0gYXNzZXJ0LnRocm93cygoKSA9PiBmb28obnVtUGFnZXMgKiBw YWdlU2l6ZSArIDEpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJyb3IsICJPdXQgb2YgYm91bmRzIG1l bW9yeSBhY2Nlc3MiKTsKICAgICBhc3NlcnQuZXEod2FzbUZyYW1lQ291bnRGcm9tRXJyb3IoZSks IDIpOwogfQpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2Z1bmN0aW9uLXRlc3RzL3RyYXAtc3Rv cmUuanMgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9yZS5qcwppbmRleCA1 NTk4N2MyLi4zNjU3MTNhIDEwMDY0NAotLS0gYS9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMv dHJhcC1zdG9yZS5qcworKysgYi9KU1Rlc3RzL3dhc20vZnVuY3Rpb24tdGVzdHMvdHJhcC1zdG9y ZS5qcwpAQCAtMjUsNSArMjUsNSBAQCBjb25zdCBudW1QYWdlcyA9IDEwOwogICAgIGNvbnN0IGZv byA9IG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShtb2R1bGUsIHthOiB7YjogbmV3IFdlYkFzc2Vt Ymx5Lk1lbW9yeSh7aW5pdGlhbDogbnVtUGFnZXN9KX19KS5leHBvcnRzLmZvbzsKIAogICAgIGZv ciAobGV0IGkgPSAwOyBpIDwgMTAwMDA7IGkrKykKLSAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9 PiBmb28oaSwgbnVtUGFnZXMgKiBwYWdlU2l6ZSArIDEpLCBXZWJBc3NlbWJseS5SdW50aW1lRXJy b3IsICJPdXQgb2YgYm91bmRzIG1lbW9yeSBhY2Nlc3MgKGV2YWx1YXRpbmcgJ2Z1bmMoLi4uYXJn cyknKSIpOworICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IGZvbyhpLCBudW1QYWdlcyAqIHBh Z2VTaXplICsgMSksIFdlYkFzc2VtYmx5LlJ1bnRpbWVFcnJvciwgIk91dCBvZiBib3VuZHMgbWVt b3J5IGFjY2VzcyIpOwogfQpkaWZmIC0tZ2l0IGEvSlNUZXN0cy93YXNtL2pzLWFwaS93YXNtLXRv LXdhc20tYmFkLXNpZ25hdHVyZS5qcyBiL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNt LWJhZC1zaWduYXR1cmUuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZDY5 YmEyYwotLS0gL2Rldi9udWxsCisrKyBiL0pTVGVzdHMvd2FzbS9qcy1hcGkvd2FzbS10by13YXNt LWJhZC1zaWduYXR1cmUuanMKQEAgLTAsMCArMSwxMDUgQEAKK2ltcG9ydCAqIGFzIGFzc2VydCBm cm9tICcuLi9hc3NlcnQuanMnOworaW1wb3J0IEJ1aWxkZXIgZnJvbSAnLi4vQnVpbGRlci5qcyc7 CisKK2NvbnN0IGltcG9ydE5hbWUgPSAicGllck9uZSI7Citjb25zdCB0eXBlcyA9IFsiaTMyIiwg Imk2NCIsICJmMzIiLCAiZjY0IiwgInZvaWQiXTsKK2NvbnN0IHR5cGVzTm9uVm9pZCA9IFsiaTMy IiwgImk2NCIsICJmMzIiLCAiZjY0Il07Citjb25zdCBzd2FwVHlwZSA9ICh0eXBlLCBpbmRleCkg PT4gdHlwZXNbKHR5cGVzLmluZGV4T2YodHlwZSkgKyBpbmRleCkgJSB0eXBlcy5sZW5ndGhdOwor Y29uc3Qgc3dhcFR5cGVOb25Wb2lkID0gKHR5cGUsIGluZGV4KSA9PiB0eXBlc05vblZvaWRbKHR5 cGVzTm9uVm9pZC5pbmRleE9mKHR5cGUpICsgaW5kZXgpICUgdHlwZXNOb25Wb2lkLmxlbmd0aF07 CisKK2NvbnN0IHNpZ25hdHVyZXMgPSBbCisgICAgeyBwYXJhbXM6IFsiaTMyIl0sIHJldDogInZv aWQiIH0sCisgICAgeyBwYXJhbXM6IFsiaTY0Il0sIHJldDogInZvaWQiIH0sCisgICAgeyBwYXJh bXM6IFsiZjMyIl0sIHJldDogInZvaWQiIH0sCisgICAgeyBwYXJhbXM6IFsiZjY0Il0sIHJldDog InZvaWQiIH0sCisgICAgeyBwYXJhbXM6IFsiaTMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7IHBh cmFtczogWyJpNjQiXSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBbImYzMiJdLCByZXQ6 ICJmMzIiIH0sCisgICAgeyBwYXJhbXM6IFsiZjY0Il0sIHJldDogImY2NCIgfSwKKyAgICB7IHBh cmFtczogWyJpMzIiLCAiZjMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7IHBhcmFtczogWyJmMzIi LCAiaTMyIl0sIHJldDogImkzMiIgfSwKKyAgICB7IHBhcmFtczogWyJpNjQiLCAiZjY0Il0sIHJl dDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogWyJmNjQiLCAiaTY0Il0sIHJldDogImk2NCIgfSwK KyAgICB7IHBhcmFtczogWyJpMzIiLCAiZjMyIiwgImkzMiJdLCByZXQ6ICJpMzIiIH0sCisgICAg eyBwYXJhbXM6IFsiaTMyIiwgImYzMiIsICJpMzIiXSwgcmV0OiAiaTMyIiB9LAorICAgIHsgcGFy YW1zOiBbImk2NCIsICJmNjQiLCAiaTY0Il0sIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczog WyJpNjQiLCAiZjY0IiwgImk2NCJdLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IEFycmF5 KDMyKS5maWxsKCJpMzIiKSwgcmV0OiAiaTY0IiB9LAorICAgIHsgcGFyYW1zOiBBcnJheSgzMiku ZmlsbCgiaTY0IiksIHJldDogImk2NCIgfSwKKyAgICB7IHBhcmFtczogQXJyYXkoMzIpLmZpbGwo ImYzMiIpLCByZXQ6ICJpNjQiIH0sCisgICAgeyBwYXJhbXM6IEFycmF5KDMyKS5maWxsKCJmNjQi KSwgcmV0OiAiaTY0IiB9LAorXTsKKworY29uc3QgbWFrZUltcG9ydGVyID0gc2lnbmF0dXJlID0+ IHsKKyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAgIC5UeXBlKCku RW5kKCkKKyAgICAgICAgLkltcG9ydCgpLkZ1bmN0aW9uKCJleHBvcnRzIiwgaW1wb3J0TmFtZSwg c2lnbmF0dXJlKS5FbmQoKTsKKyAgICByZXR1cm4gbmV3IFdlYkFzc2VtYmx5Lk1vZHVsZShidWls ZGVyLldlYkFzc2VtYmx5KCkuZ2V0KCkpOworfTsKKworY29uc3QgbWFrZUltcG9ydGVlID0gc2ln bmF0dXJlID0+IHsKKyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAg IC5UeXBlKCkuRW5kKCkKKyAgICAgICAgLkZ1bmN0aW9uKCkuRW5kKCkKKyAgICAgICAgLkV4cG9y dCgpCisgICAgICAgICAgICAuRnVuY3Rpb24oaW1wb3J0TmFtZSkKKyAgICAgICAgLkVuZCgpCisg ICAgICAgIC5Db2RlKCkKKyAgICAgICAgICAgIC5GdW5jdGlvbihpbXBvcnROYW1lLCBzaWduYXR1 cmUpOworICAgIHN3aXRjaCAoc2lnbmF0dXJlLnJldCkgeworICAgIGNhc2UgImkzMiI6IGJ1aWxk ZXIuSTMyQ29uc3QoMCk7IGJyZWFrOworICAgIGNhc2UgImk2NCI6IGJ1aWxkZXIuSTY0Q29uc3Qo MCk7IGJyZWFrOworICAgIGNhc2UgImYzMiI6IGJ1aWxkZXIuRjMyQ29uc3QoMCk7IGJyZWFrOwor ICAgIGNhc2UgImY2NCI6IGJ1aWxkZXIuRjY0Q29uc3QoMCk7IGJyZWFrOworICAgIGNhc2UgInZv aWQiOiBicmVhazsKKyAgICB9CisgICAgcmV0dXJuIG5ldyBXZWJBc3NlbWJseS5JbnN0YW5jZShu ZXcgV2ViQXNzZW1ibHkuTW9kdWxlKGJ1aWxkZXIuUmV0dXJuKCkuRW5kKCkuRW5kKCkuV2ViQXNz ZW1ibHkoKS5nZXQoKSkpOworfTsKKworKGZ1bmN0aW9uIEJhZFNpZ25hdHVyZURyb3BTdGFydFBh cmFtcygpIHsKKyAgICBmb3IgKGxldCBzaWduYXR1cmUgb2Ygc2lnbmF0dXJlcykgeworICAgICAg ICBjb25zdCBpbXBvcnRlZSA9IG1ha2VJbXBvcnRlZShzaWduYXR1cmUpOworICAgICAgICBmb3Ig KGxldCBpID0gMTsgaSA8PSBzaWduYXR1cmUucGFyYW1zLmxlbmd0aDsgKytpKSB7CisgICAgICAg ICAgICBjb25zdCBiYWRQYXJhbVNpZ25hdHVyZSA9IHsgcGFyYW1zOiBzaWduYXR1cmUucGFyYW1z LnNsaWNlKGksIHNpZ25hdHVyZS5wYXJhbXMubGVuZ3RoKSwgcmV0OiBzaWduYXR1cmUucmV0IH07 CisgICAgICAgICAgICBjb25zdCBpbXBvcnRlciA9IG1ha2VJbXBvcnRlcihiYWRQYXJhbVNpZ25h dHVyZSk7CisgICAgICAgICAgICBhc3NlcnQudGhyb3dzKCgpID0+IG5ldyBXZWJBc3NlbWJseS5J bnN0YW5jZShpbXBvcnRlciwgaW1wb3J0ZWUpLCBXZWJBc3NlbWJseS5MaW5rRXJyb3IsIGBpbXBv cnRlZCBmdW5jdGlvbidzIHNpZ25hdHVyZSBkb2Vzbid0IG1hdGNoIHRoZSBwcm92aWRlZCBXZWJB c3NlbWJseSBmdW5jdGlvbidzIHNpZ25hdHVyZSAoZXZhbHVhdGluZyAnbmV3IFdlYkFzc2VtYmx5 Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSknKWApOworICAgICAgICB9CisgICAgfQorfSko KTsKKworKGZ1bmN0aW9uIEJhZFNpZ25hdHVyZURyb3BFbmRQYXJhbXMoKSB7CisgICAgZm9yIChs ZXQgc2lnbmF0dXJlIG9mIHNpZ25hdHVyZXMpIHsKKyAgICAgICAgY29uc3QgaW1wb3J0ZWUgPSBt YWtlSW1wb3J0ZWUoc2lnbmF0dXJlKTsKKyAgICAgICAgZm9yIChsZXQgaSA9IDE7IGkgPCBzaWdu YXR1cmUucGFyYW1zLmxlbmd0aDsgKytpKSB7CisgICAgICAgICAgICBjb25zdCBiYWRQYXJhbVNp Z25hdHVyZSA9IHsgcGFyYW1zOiBzaWduYXR1cmUucGFyYW1zLnNsaWNlKDAsIGkpLCByZXQ6IHNp Z25hdHVyZS5yZXQgfTsKKyAgICAgICAgICAgIGNvbnN0IGltcG9ydGVyID0gbWFrZUltcG9ydGVy KGJhZFBhcmFtU2lnbmF0dXJlKTsKKyAgICAgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gbmV3 IFdlYkFzc2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSksIFdlYkFzc2VtYmx5Lkxp bmtFcnJvciwgYGltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIGRvZXNuJ3QgbWF0Y2ggdGhl IHByb3ZpZGVkIFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIChldmFsdWF0aW5nICdu ZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKScpYCk7CisgICAgICAg IH0KKyAgICB9Cit9KSgpOworCisoZnVuY3Rpb24gQmFkU2lnbmF0dXJlU3dhcFBhcmFtKCkgewor ICAgIGZvciAobGV0IHNpZ25hdHVyZSBvZiBzaWduYXR1cmVzKSB7CisgICAgICAgIGNvbnN0IGlt cG9ydGVlID0gbWFrZUltcG9ydGVlKHNpZ25hdHVyZSk7CisgICAgICAgIGZvciAobGV0IHNpZ25h dHVyZUluZGV4ID0gMDsgc2lnbmF0dXJlSW5kZXggPCBzaWduYXR1cmUubGVuZ3RoOyArK3NpZ25h dHVyZUluZGV4KSB7CisgICAgICAgICAgICBmb3IgKGxldCB0eXBlSW5kZXggPSAxOyB0eXBlSW5k ZXggPCB0eXBlc05vblZvaWQubGVuZ3RoOyArK3R5cGVJbmRleCkgeworICAgICAgICAgICAgICAg IGxldCBiYWRQYXJhbXMgPSBzaWduYXR1cmUucGFyYW1zLnNsaWNlKCk7CisgICAgICAgICAgICAg ICAgYmFkUGFyYW1zW3NpZ25hdHVyZUluZGV4XSA9IHN3YXBUeXBlTm9uVm9pZChiYWRQYXJhbXNb c2lnbmF0dXJlSW5kZXhdLCB0eXBlSW5kZXgpOworICAgICAgICAgICAgICAgIGNvbnN0IGJhZFBh cmFtU2lnbmF0dXJlID0geyBwYXJhbXM6IGJhZFBhcmFtcywgcmV0OiBzaWduYXR1cmUucmV0IH07 CisgICAgICAgICAgICAgICAgY29uc3QgaW1wb3J0ZXIgPSBtYWtlSW1wb3J0ZXIoYmFkUGFyYW1T aWduYXR1cmUpOworICAgICAgICAgICAgICAgIGFzc2VydC50aHJvd3MoKCkgPT4gbmV3IFdlYkFz c2VtYmx5Lkluc3RhbmNlKGltcG9ydGVyLCBpbXBvcnRlZSksIFdlYkFzc2VtYmx5LkxpbmtFcnJv ciwgYGltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIGRvZXNuJ3QgbWF0Y2ggdGhlIHByb3Zp ZGVkIFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIChldmFsdWF0aW5nICduZXcgV2Vi QXNzZW1ibHkuSW5zdGFuY2UoaW1wb3J0ZXIsIGltcG9ydGVlKScpYCk7CisgICAgICAgICAgICB9 CisgICAgICAgIH0KKyAgICB9Cit9KSgpOworCisoZnVuY3Rpb24gQmFkU2lnbmF0dXJlUmV0KCkg eworICAgIGZvciAobGV0IHNpZ25hdHVyZSBvZiBzaWduYXR1cmVzKSB7CisgICAgICAgIGNvbnN0 IGltcG9ydGVlID0gbWFrZUltcG9ydGVlKHNpZ25hdHVyZSk7CisgICAgICAgIGZvciAobGV0IHR5 cGVJbmRleCA9IDE7IHR5cGVJbmRleCA8IHR5cGVzLmxlbmd0aDsgKyt0eXBlSW5kZXgpIHsKKyAg ICAgICAgICAgIGNvbnN0IGJhZFBhcmFtU2lnbmF0dXJlID0geyBwYXJhbXM6IHNpZ25hdHVyZS5w YXJhbXMsIHJldDogc3dhcFR5cGUoc2lnbmF0dXJlLnJldCwgdHlwZUluZGV4KSB9OworICAgICAg ICAgICAgY29uc3QgaW1wb3J0ZXIgPSBtYWtlSW1wb3J0ZXIoYmFkUGFyYW1TaWduYXR1cmUpOwor ICAgICAgICAgICAgYXNzZXJ0LnRocm93cygoKSA9PiBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2Uo aW1wb3J0ZXIsIGltcG9ydGVlKSwgV2ViQXNzZW1ibHkuTGlua0Vycm9yLCBgaW1wb3J0ZWQgZnVu Y3Rpb24ncyBzaWduYXR1cmUgZG9lc24ndCBtYXRjaCB0aGUgcHJvdmlkZWQgV2ViQXNzZW1ibHkg ZnVuY3Rpb24ncyBzaWduYXR1cmUgKGV2YWx1YXRpbmcgJ25ldyBXZWJBc3NlbWJseS5JbnN0YW5j ZShpbXBvcnRlciwgaW1wb3J0ZWUpJylgKTsKKyAgICAgICAgfQorICAgIH0KK30pKCk7CmRpZmYg LS1naXQgYS9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20tdG8td2FzbS5qcyBiL0pTVGVzdHMvd2Fz bS9qcy1hcGkvd2FzbS10by13YXNtLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLjJkZjQ2ZTYKLS0tIC9kZXYvbnVsbAorKysgYi9KU1Rlc3RzL3dhc20vanMtYXBpL3dhc20t dG8td2FzbS5qcwpAQCAtMCwwICsxLDcyIEBACitpbXBvcnQgKiBhcyBhc3NlcnQgZnJvbSAnLi4v YXNzZXJ0LmpzJzsKK2ltcG9ydCBCdWlsZGVyIGZyb20gJy4uL0J1aWxkZXIuanMnOworCitjb25z dCBjYWxsZXJUb3BCaXRzID0gMHhDMEZFQkVFRjsKK2NvbnN0IGlubmVyUmV0dXJuSGkgPSAweERF QURGQUNFOworY29uc3QgaW5uZXJSZXR1cm5MbyA9IDB4QzBGRUMwRkU7CisKK2NvbnN0IGNhbGxl ck1vZHVsZSA9ICgpID0+IHsKKyAgICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVyKCkpCisg ICAgICAgIC5UeXBlKCkuRW5kKCkKKyAgICAgICAgLkltcG9ydCgpCisgICAgICAgICAgICAuRnVu Y3Rpb24oImV4cG9ydHMiLCAiY2FsbE1lIiwgeyBwYXJhbXM6IFsiaTY0Il0sIHJldDogImk2NCIg fSkKKyAgICAgICAgLkVuZCgpCisgICAgICAgIC5GdW5jdGlvbigpLkVuZCgpCisgICAgICAgIC5F eHBvcnQoKQorICAgICAgICAgICAgLkZ1bmN0aW9uKCJlbnRyeSIpCisgICAgICAgIC5FbmQoKQor ICAgICAgICAuQ29kZSgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImVudHJ5IiwgeyBwYXJhbXM6 IFsiaTMyIl0sIHJldDogImkzMiIgfSwgWyJpNjQiXSkKKyAgICAgICAgICAgICAgICAuSTMyQ29u c3QoY2FsbGVyVG9wQml0cykuSTY0RXh0ZW5kVUkzMigpLkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRV STMyKCkuSTY0U2hsKCkgLy8gKChpNjQpY2FsbGVyVG9wQml0cykgPDwgMzIKKyAgICAgICAgICAg ICAgICAuR2V0TG9jYWwoMCkuSTY0RXh0ZW5kVUkzMigpCisgICAgICAgICAgICAgICAgLkk2NE9y KCkgLy8gdmFsdWU6IHBhcmFtIHwgKCgoaTY0KWNhbGxlclRvcEJpdHMgPDwgMzIpKQorICAgICAg ICAgICAgICAgIC5DYWxsKDApIC8vIENhbGxzIGV4cG9ydHMuY2FsbE1lKHBhcmFtIHwgKCgoaTY0 KWNhbGxlclRvcEJpdHMpIDw8IDMyKSkuCisgICAgICAgICAgICAgICAgLlRlZUxvY2FsKDEpLkkz MldyYXBJNjQoKSAvLyBsbzogKGkzMiljYWxsUmVzdWx0CisgICAgICAgICAgICAgICAgLkdldExv Y2FsKDEpLkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRVSTMyKCkuSTY0U2hyVSgpLkkzMldyYXBJNjQo KSAvLyBoaTogKGkzMikoY2FsbFJlc3VsdCA+PiAzMikKKyAgICAgICAgICAgICAgICAuSTMyWG9y KCkKKyAgICAgICAgICAgICAgICAuUmV0dXJuKCkKKyAgICAgICAgICAgIC5FbmQoKQorICAgICAg ICAuRW5kKCk7CisgICAgcmV0dXJuIG5ldyBXZWJBc3NlbWJseS5Nb2R1bGUoYnVpbGRlci5XZWJB c3NlbWJseSgpLmdldCgpKTsKK307CisKK2NvbnN0IGNhbGxlZU1vZHVsZSA9ICgpID0+IHsKKyAg ICBjb25zdCBidWlsZGVyID0gKG5ldyBCdWlsZGVyKCkpCisgICAgICAgIC5UeXBlKCkuRW5kKCkK KyAgICAgICAgLkltcG9ydCgpCisgICAgICAgICAgICAuRnVuY3Rpb24oImltcCIsICJmdW5jIiwg eyBwYXJhbXM6IFsiaTMyIiwgImkzMiJdLCByZXQ6ICJpMzIiIH0pCisgICAgICAgIC5FbmQoKQor ICAgICAgICAuRnVuY3Rpb24oKS5FbmQoKQorICAgICAgICAuRXhwb3J0KCkKKyAgICAgICAgICAg IC5GdW5jdGlvbigiY2FsbE1lIikKKyAgICAgICAgLkVuZCgpCisgICAgICAgIC5Db2RlKCkKKyAg ICAgICAgICAgIC5GdW5jdGlvbigiY2FsbE1lIiwgeyBwYXJhbXM6IFsiaTY0Il0sIHJldDogImk2 NCIgfSkKKyAgICAgICAgICAgICAgICAuR2V0TG9jYWwoMCkuSTMyV3JhcEk2NCgpIC8vIGxvOiAo aTMyKXBhcmFtCisgICAgICAgICAgICAgICAgLkdldExvY2FsKDApLkkzMkNvbnN0KDMyKS5JNjRF eHRlbmRVSTMyKCkuSTY0U2hyVSgpLkkzMldyYXBJNjQoKSAvLyBoaTogKGkzMikocGFyYW0gPj4g MzIpCisgICAgICAgICAgICAgICAgLkNhbGwoMCkgLy8gQ2FsbHMgaW1wLmZ1bmMgd2l0aCB0aGUg NjQtYml0IHZhbHVlIGFzIGkzMiB7IGhpLCBsbyB9LgorICAgICAgICAgICAgICAgIC5Ecm9wKCkK KyAgICAgICAgICAgICAgICAuSTMyQ29uc3QoaW5uZXJSZXR1cm5IaSkuSTY0RXh0ZW5kVUkzMigp LkkzMkNvbnN0KDMyKS5JNjRFeHRlbmRVSTMyKCkuSTY0U2hsKCkuSTMyQ29uc3QoaW5uZXJSZXR1 cm5MbykuSTY0RXh0ZW5kVUkzMigpLkk2NE9yKCkgLy8gKChpNjQpaGkgPDwgMzIpIHwgKGk2NCls bworICAgICAgICAgICAgICAgIC5SZXR1cm4oKQorICAgICAgICAgICAgLkVuZCgpCisgICAgICAg IC5FbmQoKTsKKyAgICByZXR1cm4gbmV3IFdlYkFzc2VtYmx5Lk1vZHVsZShidWlsZGVyLldlYkFz c2VtYmx5KCkuZ2V0KCkpOworfTsKKworKGZ1bmN0aW9uIFdhc21Ub1dhc20oKSB7CisgICAgbGV0 IHZhbHVlOworICAgIGNvbnN0IGZ1bmMgPSAoaGksIGxvKSA9PiB7IHZhbHVlID0geyBoaTogaGks IGxvOiBsbyB9OyByZXR1cm4gaGkgXiBsbzsgfTsKKyAgICBjb25zdCBjYWxsZWUgPSBuZXcgV2Vi QXNzZW1ibHkuSW5zdGFuY2UoY2FsbGVlTW9kdWxlKCksIHsgaW1wOiB7IGZ1bmM6IGZ1bmMgfSB9 KTsKKyAgICBjb25zdCBjYWxsZXIgPSBuZXcgV2ViQXNzZW1ibHkuSW5zdGFuY2UoY2FsbGVyTW9k dWxlKCksIGNhbGxlZSk7CisgICAgZm9yIChsZXQgaSA9IDA7IGkgPCA0MDk2OyArK2kpIHsKKyAg ICAgICAgYXNzZXJ0LmVxKGNhbGxlci5leHBvcnRzLmVudHJ5KGkpLCBpbm5lclJldHVybkhpIF4g aW5uZXJSZXR1cm5Mbyk7CisgICAgICAgIGFzc2VydC5lcSh2YWx1ZS5sbyA+Pj4gMCwgY2FsbGVy VG9wQml0cyk7CisgICAgICAgIGFzc2VydC5lcSh2YWx1ZS5oaSA+Pj4gMCwgaSk7CisgICAgfQor fSkoKTsKKworLy8gRklYTUUgdGVzdCB0aGUgZm9sbG93aW5nIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xNjY2MjUKKy8vIC0gd2FzbS0+d2FzbSB1c2luZyAzMi1iaXQg dGhpbmdzIChpbmNsdWRpbmcgZmxvYXQpLCBhcyB3ZWxsIGFzIDY0LWJpdCBOYU5zIHRoYXQgZG9u J3QgZ2V0IGNhbm9uaWNhbGl6ZWQKKy8vIC0gRG8gYSB0aHJvdyB0d28tZGVlcAorLy8gLSBDaGVj ayB0aGF0IHRoZSBmaXJzdCB3YXNtJ3MgaW5zdGFuY2UgaXMgYmFjayBpbiBPSyBzdGF0ZSAod2l0 aCB0YWJsZSBvciBnbG9iYWw/KQorLy8gLSBUZXN0IGNhbGxpbmcgdGhyb3VnaCBhIFRhYmxlCmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ01ha2VMaXN0cy50eHQgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvQ01ha2VMaXN0cy50eHQKaW5kZXggOTY5YTEyMy4uOWRlMWEzYSAxMDA2 NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NNYWtlTGlzdHMudHh0CisrKyBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9DTWFrZUxpc3RzLnR4dApAQCAtOTA1LDYgKzkwNSw3IEBAIHNldChK YXZhU2NyaXB0Q29yZV9TT1VSQ0VTCiAgICAgd2FzbS9XYXNtTWVtb3J5LmNwcAogICAgIHdhc20v V2FzbU1lbW9yeUluZm9ybWF0aW9uLmNwcAogICAgIHdhc20vV2FzbU1vZHVsZVBhcnNlci5jcHAK KyAgICB3YXNtL1dhc21QYWdlQ291bnQuY3BwCiAgICAgd2FzbS9XYXNtUGxhbi5jcHAKICAgICB3 YXNtL1dhc21TaWduYXR1cmUuY3BwCiAgICAgd2FzbS9XYXNtVmFsaWRhdGUuY3BwCmRpZmYgLS1n aXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL0NoYW5nZUxvZwppbmRleCAzNjQxZGEyLi41MjE2OTYwIDEwMDY0NAotLS0gYS9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFu Z2VMb2cKQEAgLTEsMyArMSwxMjggQEAKKzIwMTYtMTItMzAgIEpGIEJhc3RpZW4gIDxqZmJhc3Rp ZW5AYXBwbGUuY29tPgorCisgICAgICAgIFdlYkFzc2VtYmx5OiBoYW5kbGUgYW5kIG9wdGltaXpl IHdhc20gZXhwb3J0IOKGkiB3YXNtIGltcG9ydCBjYWxscworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1MjgyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkg U2FhbSBCYXJhdGkuCisKKyAgICAgICAgICAtIEFkZCBhIG5ldyBKU1R5cGUgZm9yIFdlYkFzc2Vt Ymx5RnVuY3Rpb24sIGFuZCB1c2UgaXQgd2hlbiBjcmVhdGluZyBpdHMKKyAgICAgICAgICAgIHN0 cnVjdHVyZS4gVGhpcyB3aWxsIGlzIHVzZWQgdG8gcXVpY2tseSBkZXRlY3QgZnJvbSB3YXNtIHdo ZXRoZXIgdGhlIGltcG9ydAorICAgICAgICAgICAgY2FsbCBpcyB0byBhbm90aGVyIHdhc20gbW9k dWxlLCBvciB3aGV0aGVyIGl0J3MgdG8gSlMuCisgICAgICAgICAgLSBHZW5lcmF0ZSB0d28gc3R1 YnMgZnJvbSB0aGUgaW1wb3J0IHN0dWIgZ2VuZXJhdG9yOiBvbmUgZm9yIHdhc20tPkpTIGFuZCBv bmUKKyAgICAgICAgICAgIGZvciB3YXNtIC0+IHdhc20uIFRoaXMgaXMgZG9uZSBhdCBNb2R1bGUg dGltZS4gV2hpY2ggaXMgY2FsbGVkIHdpbGwgb25seSBiZQorICAgICAgICAgICAga25vd24gYXQg SW5zdGFuY2UgdGltZSwgb25jZSB3ZSd2ZSByZWNlaXZlZCB0aGUgaW1wb3J0IG9iamVjdC4gV2Ug d2FudCB0bworICAgICAgICAgICAgYXZvaWQgY29kZWdlbiBhdCBJbnN0YW5jZSB0aW1lLCBzbyBo YXZpbmcgYm90aCBhcm91bmQgaXMgZ3JlYXQuCisgICAgICAgICAgLSBSZXN0b3JlIHRoZSBXZWJB c3NlbWJseSBnbG9iYWwgc3RhdGUgKFZNIHRvcCBJbnN0YW5jZSwgYW5kIHBpbm5lZCByZWdpc3Rl cnMpCisgICAgICAgICAgICBhZnRlciBjYWxsIC8gY2FsbF9pbmRpcmVjdCwgYW5kIGluIHRoZSBK Uy0+d2FzbSBlbnRyeSBzdHViLgorICAgICAgICAgIC0gUGlubmVkIHJlZ2lzdGVycyBhcmUgbm93 IGEgZ2xvYmFsIHRoaW5nLCBub3QgcGVyLU1lbW9yeSwgYmVjYXVzZSB0aGUgd2FzbSAtPgorICAg ICAgICAgICAgd2FzbSBzdHVicyBhcmUgZ2VuZXJhdGVkIGF0IE1vZHVsZSB0aW1lIHdoZXJlIHdl IGRvbid0IHJlYWxseSBoYXZlIGVub3VnaAorICAgICAgICAgICAgaW5mb3JtYXRpb24gdG8gZG8g dGhlIHJpZ2h0IHRoaW5nIChkb2luZyBzbyB3b3VsZCBnZW5lcmF0ZSB0b28gbXVjaCBjb2RlKS4K KworICAgICAgICAqIENNYWtlTGlzdHMudHh0OgorICAgICAgICAqIEphdmFTY3JpcHRDb3JlLnhj b2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogcnVudGltZS9KU1R5cGUuaDogYWRk IFdlYkFzc2VtYmx5RnVuY3Rpb25UeXBlIGFzIGEgSlNUeXBlCisgICAgICAgICogd2FzbS9XYXNt QjNJUkdlbmVyYXRvci5jcHA6IHNpZ25pZmljYW50bHkgcmV3b3JrIGhvdyBjYWxscyB3aGljaAor ICAgICAgICBjb3VsZCBiZSBleHRlcm5hbCB3b3JrLCBhbmQgaG93IHdlIHNhdmUgLyByZXN0b3Jl IGdsb2JhbCBzdGF0ZToKKyAgICAgICAgVk0ncyB0b3AgSW5zdGFuY2UsIGFuZCBwaW5uZWQgcmVn aXN0ZXJzCisgICAgICAgIChKU0M6Oldhc206OkIzSVJHZW5lcmF0b3I6OkIzSVJHZW5lcmF0b3Ip OgorICAgICAgICAoSlNDOjpXYXNtOjpnZXRNZW1vcnlCYXNlQW5kU2l6ZSk6CisgICAgICAgIChK U0M6Oldhc206OnJlc3RvcmVXZWJBc3NlbWJseUdsb2JhbFN0YXRlKToKKyAgICAgICAgKEpTQzo6 V2FzbTo6Y3JlYXRlSlNUb1dhc21XcmFwcGVyKToKKyAgICAgICAgKEpTQzo6V2FzbTo6cGFyc2VB bmRDb21waWxlKToKKyAgICAgICAgKiB3YXNtL1dhc21CM0lSR2VuZXJhdG9yLmg6CisgICAgICAg ICogd2FzbS9XYXNtQmluZGluZy5jcHA6CisgICAgICAgIChKU0M6Oldhc206Om1hdGVyaWFsaXpl SW1wb3J0SlNDZWxsKToKKyAgICAgICAgKEpTQzo6V2FzbTo6d2FzbVRvSlMpOgorICAgICAgICAo SlNDOjpXYXNtOjp3YXNtVG9XYXNtKTogdGhlIG1haW4gZ29hbCBvZiB0aGlzIHBhdGNoIHdhcyBh ZGRpbmcgdGhpcyBmdW5jdGlvbgorICAgICAgICAoSlNDOjpXYXNtOjpleGl0U3R1YkdlbmVyYXRv cik6CisgICAgICAgICogd2FzbS9XYXNtQmluZGluZy5oOgorICAgICAgICAqIHdhc20vV2FzbUZv cm1hdC5oOiBHZXQgcmlkIG9mIG11Y2ggb2YgdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlOgorICAg ICAgICB3ZSBhbHJlYWR5IGhhdmUgYWxsIG9mIGl0cyBpbmZvcm1hdGlvbiBlbHNld2hlcmUsIGFu ZCBhcy1pcyBpdAorICAgICAgICBwcm92aWRlcyBubyBleHRyYSBlZmZpY2llbmN5LgorICAgICAg ICAoSlNDOjpXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbjo6ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSk6 CisgICAgICAgIChKU0M6Oldhc206Ok1vZHVsZUluZm9ybWF0aW9uOjppc0ltcG9ydGVkRnVuY3Rp b25Gcm9tRnVuY3Rpb25JbmRleFNwYWNlKToKKyAgICAgICAgKEpTQzo6V2FzbTo6TW9kdWxlSW5m b3JtYXRpb246OnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZSk6CisgICAgICAg ICogd2FzbS9XYXNtRnVuY3Rpb25QYXJzZXIuaDoKKyAgICAgICAgKEpTQzo6V2FzbTo6RnVuY3Rp b25QYXJzZXI8Q29udGV4dD46OkZ1bmN0aW9uUGFyc2VyKToKKyAgICAgICAgKiB3YXNtL1dhc21N ZW1vcnkuY3BwOiBBZGQgc29tZSBsb2dnaW5nLgorICAgICAgICAoSlNDOjpXYXNtOjpNZW1vcnk6 OmR1bXApOiB0aGlzIHdhcyBuaWNlIHdoZW4gZGVidWdnaW5nCisgICAgICAgIChKU0M6Oldhc206 Ok1lbW9yeTo6bWFrZVN0cmluZyk6CisgICAgICAgIChKU0M6Oldhc206Ok1lbW9yeTo6TWVtb3J5 KToKKyAgICAgICAgKEpTQzo6V2FzbTo6TWVtb3J5Ojp+TWVtb3J5KToKKyAgICAgICAgKEpTQzo6 V2FzbTo6TWVtb3J5Ojpncm93KToKKyAgICAgICAgKiB3YXNtL1dhc21NZW1vcnkuaDogZG9uJ3Qg dXNlIGV4dHJhIGluZGlyZWN0aW9uLCBpdCB3YXNuJ3QKKyAgICAgICAgbmVlZGVkLiBSZW9yZGVy IHNvbWUgb2YgdGhlIGZpZWxkcyB3aGljaCBhcmUgbG9va2VkIHVwIGF0IHJ1bnRpbWUKKyAgICAg ICAgc28gdGhleSdyZSBtb3JlIGNhY2hlLWZyaWVuZGx5LgorICAgICAgICAoSlNDOjpXYXNtOjpN ZW1vcnk6Ok1lbW9yeSk6CisgICAgICAgIChKU0M6Oldhc206Ok1lbW9yeTo6bW9kZSk6CisgICAg ICAgIChKU0M6Oldhc206Ok1lbW9yeTo6b2Zmc2V0T2ZTaXplKToKKyAgICAgICAgKiB3YXNtL1dh c21NZW1vcnlJbmZvcm1hdGlvbi5jcHA6IFBpbm5lZCByZWdpc3RlcnMgYXJlIG5vdyBhCisgICAg ICAgIGdsb2JhbCB0aGluZyBmb3IgYWxsIG9mIEpTQywgbm90IGEgcGVyLU1lbW9yeSB0aGluZwor ICAgICAgICBhbnltb3JlLiB3YXNtLT53YXNtIGNhbGxzIGFyZSBtb3JlIGNvbXBsZXggb3RoZXJ3 aXNlOiB0aGV5IGhhdmUgdG8KKyAgICAgICAgZmlndXJlIG91dCBob3cgdG8gYnJpZGdlIGJldHdl ZW4gdGhlIGNhbGxlciBhbmQgY2FsbGVlJ3MKKyAgICAgICAgc3BlY2lhbC1zbm93Zmxha2UgcGlu bmluZy4KKyAgICAgICAgKEpTQzo6V2FzbTo6UGlubmVkUmVnaXN0ZXJJbmZvOjpnZXQpOgorICAg ICAgICAoSlNDOjpXYXNtOjpQaW5uZWRSZWdpc3RlckluZm86OlBpbm5lZFJlZ2lzdGVySW5mbyk6 CisgICAgICAgIChKU0M6Oldhc206Ok1lbW9yeUluZm9ybWF0aW9uOjpNZW1vcnlJbmZvcm1hdGlv bik6CisgICAgICAgICogd2FzbS9XYXNtTWVtb3J5SW5mb3JtYXRpb24uaDoKKyAgICAgICAgKiB3 YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwOgorICAgICAgICAqIHdhc20vV2FzbU1vZHVsZVBhcnNl ci5oOgorICAgICAgICAqIHdhc20vV2FzbVBhZ2VDb3VudC5jcHA6IENvcGllZCBmcm9tIFNvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmguCisgICAgICAgIChKU0M6Oldhc206 OlBhZ2VDb3VudDo6ZHVtcCk6IG5pY2UgZm9yIGRlYnVnZ2luZworICAgICAgICAqIHdhc20vV2Fz bVBhZ2VDb3VudC5oOgorICAgICAgICAqIHdhc20vV2FzbVBsYW4uY3BwOgorICAgICAgICAoSlND OjpXYXNtOjpQbGFuOjpwYXJzZUFuZFZhbGlkYXRlTW9kdWxlKToKKyAgICAgICAgKEpTQzo6V2Fz bTo6UGxhbjo6cnVuKToKKyAgICAgICAgKiB3YXNtL1dhc21QbGFuLmg6CisgICAgICAgIChKU0M6 Oldhc206OlBsYW46OnRha2VXYXNtRXhpdFN0dWJzKToKKyAgICAgICAgKiB3YXNtL1dhc21TaWdu YXR1cmUuY3BwOgorICAgICAgICAoSlNDOjpXYXNtOjpTaWduYXR1cmU6OnRvU3RyaW5nKToKKyAg ICAgICAgKEpTQzo6V2FzbTo6U2lnbmF0dXJlOjpkdW1wKToKKyAgICAgICAgKiB3YXNtL1dhc21T aWduYXR1cmUuaDoKKyAgICAgICAgKiB3YXNtL1dhc21WYWxpZGF0ZS5jcHA6CisgICAgICAgIChK U0M6Oldhc206OnZhbGlkYXRlRnVuY3Rpb24pOgorICAgICAgICAqIHdhc20vV2FzbVZhbGlkYXRl Lmg6CisgICAgICAgICogd2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5zdGFuY2UuaDoKKyAgICAgICAg KEpTQzo6SlNXZWJBc3NlbWJseUluc3RhbmNlOjpvZmZzZXRPZlRhYmxlKToKKyAgICAgICAgKEpT Qzo6SlNXZWJBc3NlbWJseUluc3RhbmNlOjpvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucyk6CisgICAg ICAgIChKU0M6OkpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbik6 CisgICAgICAgICogd2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmNwcDoKKyAgICAgICAgKEpT Qzo6SlNXZWJBc3NlbWJseU1lbW9yeTo6Y3JlYXRlKToKKyAgICAgICAgKEpTQzo6SlNXZWJBc3Nl bWJseU1lbW9yeTo6SlNXZWJBc3NlbWJseU1lbW9yeSk6CisgICAgICAgIChKU0M6OkpTV2ViQXNz ZW1ibHlNZW1vcnk6OmJ1ZmZlcik6CisgICAgICAgIChKU0M6OkpTV2ViQXNzZW1ibHlNZW1vcnk6 Omdyb3cpOgorICAgICAgICAqIHdhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5oOgorICAgICAg ICAoSlNDOjpKU1dlYkFzc2VtYmx5TWVtb3J5OjptZW1vcnkpOgorICAgICAgICAoSlNDOjpKU1dl YkFzc2VtYmx5TWVtb3J5OjpvZmZzZXRPZk1lbW9yeSk6CisgICAgICAgIChKU0M6OkpTV2ViQXNz ZW1ibHlNZW1vcnk6Om9mZnNldE9mU2l6ZSk6CisgICAgICAgICogd2FzbS9qcy9KU1dlYkFzc2Vt Ymx5TW9kdWxlLmNwcDoKKyAgICAgICAgKEpTQzo6SlNXZWJBc3NlbWJseU1vZHVsZTo6Y3JlYXRl KToKKyAgICAgICAgKEpTQzo6SlNXZWJBc3NlbWJseU1vZHVsZTo6SlNXZWJBc3NlbWJseU1vZHVs ZSk6CisgICAgICAgICogd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmg6CisgICAgICAgIChK U0M6OkpTV2ViQXNzZW1ibHlNb2R1bGU6OnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhT cGFjZSk6CisgICAgICAgIChKU0M6OkpTV2ViQXNzZW1ibHlNb2R1bGU6OmZ1bmN0aW9uSW1wb3J0 Q291bnQpOgorICAgICAgICAqIHdhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlvbi5jcHA6CisgICAg ICAgIChKU0M6OmNhbGxXZWJBc3NlbWJseUZ1bmN0aW9uKToKKyAgICAgICAgKEpTQzo6V2ViQXNz ZW1ibHlGdW5jdGlvbjo6Y3JlYXRlKToKKyAgICAgICAgKEpTQzo6V2ViQXNzZW1ibHlGdW5jdGlv bjo6Y3JlYXRlU3RydWN0dXJlKToKKyAgICAgICAgKEpTQzo6V2ViQXNzZW1ibHlGdW5jdGlvbjo6 V2ViQXNzZW1ibHlGdW5jdGlvbik6CisgICAgICAgIChKU0M6OldlYkFzc2VtYmx5RnVuY3Rpb246 OmZpbmlzaENyZWF0aW9uKToKKyAgICAgICAgKiB3YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24u aDoKKyAgICAgICAgKEpTQzo6V2ViQXNzZW1ibHlGdW5jdGlvbjo6d2FzbUVudHJ5cG9pbnQpOgor ICAgICAgICAoSlNDOjpXZWJBc3NlbWJseUZ1bmN0aW9uOjpvZmZzZXRPZkluc3RhbmNlKToKKyAg ICAgICAgKEpTQzo6V2ViQXNzZW1ibHlGdW5jdGlvbjo6b2Zmc2V0T2ZXYXNtRW50cnlQb2ludENv ZGUpOgorICAgICAgICAqIHdhc20vanMvV2ViQXNzZW1ibHlJbnN0YW5jZUNvbnN0cnVjdG9yLmNw cDoKKyAgICAgICAgKEpTQzo6Y29uc3RydWN0SlNXZWJBc3NlbWJseUluc3RhbmNlKTogYWx3YXlz IHN0YXJ0IHdpdGggYSBkdW1teQorICAgICAgICBtZW1vcnksIHNvIHdhc20tPndhc20gY2FsbHMg ZG9uJ3QgbmVlZCB0byBudWxsLWNoZWNrCisgICAgICAgICogd2FzbS9qcy9XZWJBc3NlbWJseU1l bW9yeUNvbnN0cnVjdG9yLmNwcDoKKyAgICAgICAgKEpTQzo6Y29uc3RydWN0SlNXZWJBc3NlbWJs eU1lbW9yeSk6CisgICAgICAgICogd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9y LmNwcDoKKyAgICAgICAgKEpTQzo6V2ViQXNzZW1ibHlNb2R1bGVDb25zdHJ1Y3Rvcjo6Y3JlYXRl TW9kdWxlKToKKyAgICAgICAgKiB3YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmNwcDoK KyAgICAgICAgKEpTQzo6V2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQ6OmxpbmspOgorICAgICAgICAo SlNDOjpXZWJBc3NlbWJseU1vZHVsZVJlY29yZDo6ZXZhbHVhdGUpOgorICAgICAgICAqIHdhc20v anMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQuaDoKKwogMjAxNi0xMi0yOCAgU2FhbSBCYXJhdGkg IDxzYmFyYXRpQGFwcGxlLmNvbT4KIAogICAgICAgICBXZWJBc3NlbWJseTogRG9uJ3QgYWxsb3cg ZHVwbGljYXRlIGV4cG9ydCBuYW1lcwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvSmF2YVNjcmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCBk OTMyNTZiLi4xMTYzNjllIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvSmF2YVNj cmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvSmF2YVNjcmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMTIzNSw2 ICsxMjM1LDcgQEAKIAkJMkFERkEyNjMxOEVGMzU0MDAwNEY5RkNDIC8qIEdDTG9nZ2luZy5jcHAg aW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAyQURGQTI2MjE4 RUYzNTQwMDA0RjlGQ0MgLyogR0NMb2dnaW5nLmNwcCAqLzsgfTsKIAkJMkFGNzM4MkMxOEJCQkY5 MjAwOEE1QTM3IC8qIFN0cnVjdHVyZUlEVGFibGUuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMkFGNzM4MkExOEJCQkY5MjAwOEE1QTM3IC8qIFN0cnVj dHVyZUlEVGFibGUuY3BwICovOyB9OwogCQkyQUY3MzgyRDE4QkJCRjkyMDA4QTVBMzcgLyogU3Ry dWN0dXJlSURUYWJsZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gMkFGNzM4MkIxOEJCQkY5MjAwOEE1QTM3IC8qIFN0cnVjdHVyZUlEVGFibGUuaCAqLzsg c2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQkyRDM0MkYzNkY3 MjQ0MDk2ODA0QURCMjQgLyogU291cmNlT3JpZ2luLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0MjVCQTEzMzdFNDM0NEUxQjI2OUE2NzEgLyogU291cmNl T3JpZ2luLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsK IAkJMzcxRDg0MkQxN0M5OEI2RTAwRUNGOTk0IC8qIGxpYnouZHlsaWIgaW4gRnJhbWV3b3JrcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAzNzFEODQyQzE3Qzk4QjZFMDBFQ0Y5 OTQgLyogbGliei5keWxpYiAqLzsgfTsKIAkJNDEyOTUyNzcxRDJDRjZCQzAwRTc4Qjg5IC8qIGJ1 aWx0aW5zX2dlbmVyYXRlX2ludGVybmFsc193cmFwcGVyX2hlYWRlci5weSBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQxMjk1MjczMUQyQ0Y2QUMwMEU3OEI4 OSAvKiBidWlsdGluc19nZW5lcmF0ZV9pbnRlcm5hbHNfd3JhcHBlcl9oZWFkZXIucHkgKi87IHNl dHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDEyOTUyNzgxRDJD RjZCQzAwRTc4Qjg5IC8qIGJ1aWx0aW5zX2dlbmVyYXRlX2ludGVybmFsc193cmFwcGVyX2ltcGxl bWVudGF0aW9uLnB5IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gNDEyOTUyNzQxRDJDRjZBQzAwRTc4Qjg5IC8qIGJ1aWx0aW5zX2dlbmVyYXRlX2ludGVybmFs c193cmFwcGVyX2ltcGxlbWVudGF0aW9uLnB5ICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0g KFByaXZhdGUsICk7IH07IH07CkBAIC0yMDI1LDYgKzIwMjYsNyBAQAogCQlBRDc0MzhDMDFFMDQ1 N0E0MDBGRDBDMkEgLyogV2FzbVNpZ25hdHVyZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gQUQ3NDM4QkYxRTA0NTc5MjAwRkQwQzJBIC8qIFdhc21TaWdu YXR1cmUuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9Owog CQlBRDc0MzhDMTFFMDQ1N0FBMDBGRDBDMkEgLyogV2FzbVNpZ25hdHVyZS5jcHAgaW4gU291cmNl cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBRDc0MzhCRTFFMDQ1NzkyMDBG RDBDMkEgLyogV2FzbVNpZ25hdHVyZS5jcHAgKi87IH07CiAJCUFEODZBOTNFMUFBNEQ4OEQwMDJG RTc3RiAvKiBXZWFrR0NNYXBJbmxpbmVzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSBBRDg2QTkzRDFBQTREODdDMDAyRkU3N0YgLyogV2Vha0dDTWFwSW5s aW5lcy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CisJ CUFEQjZGNjdEMUUxNUQ3NjAwMDgyRjM4NCAvKiBXYXNtUGFnZUNvdW50LmNwcCBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEFEQjZGNjdDMUUxNUQ3NTAwMDgy RjM4NCAvKiBXYXNtUGFnZUNvdW50LmNwcCAqLzsgfTsKIAkJQURCQzU0RDQxREY4RUEyQjAwNUJG NzM4IC8qIFdlYkFzc2VtYmx5VG9KU0NhbGxlZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBREJDNTREMjFERjhFQTAwMDA1QkY3MzggLyogV2ViQXNz ZW1ibHlUb0pTQ2FsbGVlLmNwcCAqLzsgfTsKIAkJQURCQzU0RDUxREY4RUEyQjAwNUJGNzM4IC8q IFdlYkFzc2VtYmx5VG9KU0NhbGxlZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gQURCQzU0RDMxREY4RUEwMDAwNUJGNzM4IC8qIFdlYkFzc2VtYmx5VG9K U0NhbGxlZS5oICovOyB9OwogCQlBRERCMUY2MzE4RDc3REJFMDA5QjU4QTggLyogT3BhcXVlUm9v dFNldC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQURE QjFGNjIxOEQ3N0RCNzAwOUI1OEE4IC8qIE9wYXF1ZVJvb3RTZXQuaCAqLzsgc2V0dGluZ3MgPSB7 QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAtMjM2MSw3ICsyMzYzLDYgQEAKIAkJ RkVEOTRGMkYxNzFFM0UyMzAwQkU3N0E0IC8qIFdhdGNoZG9nLmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGRUQ5NEYyQzE3MUUzRTIzMDBCRTc3QTQgLyog V2F0Y2hkb2cuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9 OwogCQlGRUYwNDA1MTFBQUU2NjJEMDBCRDI4QjAgLyogQ29tcGFyZUFuZFN3YXBUZXN0LmNwcCBp biBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZFRjA0MDUwMUFB RTY2MkQwMEJEMjhCMCAvKiBDb21wYXJlQW5kU3dhcFRlc3QuY3BwICovOyB9OwogCQlGRUZENkZD NjFENUU3OTkyMDA4RjJGMEIgLyogSlNTdHJpbmdJbmxpbmVzLmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGRUZENkZDNTFENUU3OTcwMDA4RjJGMEIgLyog SlNTdHJpbmdJbmxpbmVzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwg KTsgfTsgfTsKLQkJMkQzNDJGMzZGNzI0NDA5NjgwNEFEQjI0IC8qIFNvdXJjZU9yaWdpbi5oIGlu IEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDI1QkExMzM3RTQz NDRFMUIyNjlBNjcxIC8qIFNvdXJjZU9yaWdpbi5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVT ID0gKFByaXZhdGUsICk7IH07IH07CiAvKiBFbmQgUEJYQnVpbGRGaWxlIHNlY3Rpb24gKi8KIAog LyogQmVnaW4gUEJYQ29udGFpbmVySXRlbVByb3h5IHNlY3Rpb24gKi8KQEAgLTM2MzgsNiArMzYz OSw3IEBACiAJCTQxMjk1Mjc1MUQyQ0Y2QUMwMEU3OEI4OSAvKiBidWlsdGluc19nZW5lcmF0ZV93 cmFwcGVyX2hlYWRlci5weSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuc2NyaXB0LnB5dGhvbjsgcGF0aCA9IGJ1 aWx0aW5zX2dlbmVyYXRlX3dyYXBwZXJfaGVhZGVyLnB5OyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQk0MTI5NTI3NjFEMkNGNkFDMDBFNzhCODkgLyogYnVpbHRpbnNfZ2VuZXJhdGVfd3Jh cHBlcl9pbXBsZW1lbnRhdGlvbi5weSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuc2NyaXB0LnB5dGhvbjsgcGF0 aCA9IGJ1aWx0aW5zX2dlbmVyYXRlX3dyYXBwZXJfaW1wbGVtZW50YXRpb24ucHk7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQxREVBMTMxMUI5RjMxNTQwMDZENjVERCAvKiBCdWlsdGlu VXRpbHMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQnVpbHRpblV0aWxzLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTQyNUJBMTMzN0U0MzQ0RTFCMjY5QTY3MSAv KiBTb3VyY2VPcmlnaW4uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gU291cmNl T3JpZ2luLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQzMTlEQTAxMUMxQkUzQzEw MDFEMjYwQiAvKiBCM0xvd2VyTWFjcm9zQWZ0ZXJPcHRpbWl6YXRpb25zLmNwcCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuY3BwLmNwcDsgbmFtZSA9IEIzTG93ZXJNYWNyb3NBZnRlck9wdGltaXphdGlv bnMuY3BwOyBwYXRoID0gYjMvQjNMb3dlck1hY3Jvc0FmdGVyT3B0aW1pemF0aW9ucy5jcHA7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQzMTlEQTAyMUMxQkUzQzEwMDFEMjYwQiAvKiBC M0xvd2VyTWFjcm9zQWZ0ZXJPcHRpbWl6YXRpb25zLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMu aDsgbmFtZSA9IEIzTG93ZXJNYWNyb3NBZnRlck9wdGltaXphdGlvbnMuaDsgcGF0aCA9IGIzL0Iz TG93ZXJNYWNyb3NBZnRlck9wdGltaXphdGlvbnMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJNDM0MEE0ODIxQTkwNTFBRjAwRDczQ0NBIC8qIE1hdGhDb21tb24uY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gTWF0aENvbW1vbi5jcHA7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CkBAIC00NTEwLDYgKzQ1MTIsNyBAQAogCQlBRDc0MzhCRTFFMDQ1Nzky MDBGRDBDMkEgLyogV2FzbVNpZ25hdHVyZS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5j cHA7IHBhdGggPSBXYXNtU2lnbmF0dXJlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK IAkJQUQ3NDM4QkYxRTA0NTc5MjAwRkQwQzJBIC8qIFdhc21TaWduYXR1cmUuaCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gV2FzbVNpZ25hdHVyZS5oOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQlBRDg2QTkzRDFBQTREODdDMDAyRkU3N0YgLyogV2Vha0dDTWFwSW5saW5l cy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXZWFrR0NNYXBJbmxpbmVzLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUFEQjZGNjdDMUUxNUQ3NTAwMDgyRjM4NCAv KiBXYXNtUGFnZUNvdW50LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9 IFdhc21QYWdlQ291bnQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBREJDNTRE MjFERjhFQTAwMDA1QkY3MzggLyogV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmNwcCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuY3BwLmNwcDsgbmFtZSA9IFdlYkFzc2VtYmx5VG9KU0NhbGxlZS5jcHA7IHBh dGggPSBqcy9XZWJBc3NlbWJseVRvSlNDYWxsZWUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQlBREJDNTREMzFERjhFQTAwMDA1QkY3MzggLyogV2ViQXNzZW1ibHlUb0pTQ2FsbGVl LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFdlYkFzc2VtYmx5VG9KU0NhbGxl ZS5oOyBwYXRoID0ganMvV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCUFEREIxRjYyMThENzdEQjcwMDlCNThBOCAvKiBPcGFxdWVSb290U2V0Lmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE9wYXF1ZVJvb3RTZXQuaDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTQ4NzksNyArNDg4Miw2IEBACiAJCUZFRjA0MDUwMUFB RTY2MkQwMEJEMjhCMCAvKiBDb21wYXJlQW5kU3dhcFRlc3QuY3BwICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jcHAuY3BwOyBuYW1lID0gQ29tcGFyZUFuZFN3YXBUZXN0LmNwcDsgcGF0aCA9IEFQSS90 ZXN0cy9Db21wYXJlQW5kU3dhcFRlc3QuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQlGRUYwNDA1MjFBQUVDNEVEMDBCRDI4QjAgLyogQ29tcGFyZUFuZFN3YXBUZXN0LmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IENvbXBhcmVBbmRTd2FwVGVzdC5oOyBwYXRoID0g QVBJL3Rlc3RzL0NvbXBhcmVBbmRTd2FwVGVzdC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQlGRUZENkZDNTFENUU3OTcwMDA4RjJGMEIgLyogSlNTdHJpbmdJbmxpbmVzLmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpTU3RyaW5nSW5saW5lcy5oOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwotCQk0MjVCQTEzMzdFNDM0NEUxQjI2OUE2NzEgLyogU291cmNlT3Jp Z2luLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFNvdXJjZU9yaWdpbi5oOyBw YXRoID0gU291cmNlT3JpZ2luLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAvKiBFbmQg UEJYRmlsZVJlZmVyZW5jZSBzZWN0aW9uICovCiAKIC8qIEJlZ2luIFBCWEZyYW1ld29ya3NCdWls ZFBoYXNlIHNlY3Rpb24gKi8KQEAgLTYwNDcsNiArNjA0OSw3IEBACiAJCQkJNzlCNzU5NzIxREZB NEM2MDAwNTIxNzRDIC8qIFdhc21NZW1vcnlJbmZvcm1hdGlvbi5oICovLAogCQkJCTUzRjQwRTk2 MUQ1QTdCRUMwMDk5QTFCNiAvKiBXYXNtTW9kdWxlUGFyc2VyLmNwcCAqLywKIAkJCQk1M0Y0MEU5 NDFENUE3QUVGMDA5OUExQjYgLyogV2FzbU1vZHVsZVBhcnNlci5oICovLAorCQkJCUFEQjZGNjdD MUUxNUQ3NTAwMDgyRjM4NCAvKiBXYXNtUGFnZUNvdW50LmNwcCAqLywKIAkJCQk3OUI3NTk3MzFE RkE0QzYwMDA1MjE3NEMgLyogV2FzbVBhZ2VDb3VudC5oICovLAogCQkJCTUzRjQwRThDMUQ1OTAx RjIwMDk5QTFCNiAvKiBXYXNtUGFyc2VyLmggKi8sCiAJCQkJNTMxMzc0QkUxRDVDRTk1MDAwQUY3 QTBCIC8qIFdhc21QbGFuLmNwcCAqLywKQEAgLTk3MDMsNiArOTcwNiw3IEBACiAJCQkJMEY2NEIy NzExQTc4NEJBRjAwNkU0RTY2IC8qIEJpbmFyeVN3aXRjaC5jcHAgaW4gU291cmNlcyAqLywKIAkJ CQkxNDI4MDg2MzEwN0VDMTFBMDAxM0U3QjIgLyogQm9vbGVhbkNvbnN0cnVjdG9yLmNwcCBpbiBT b3VyY2VzICovLAogCQkJCTE0MjgwODY0MTA3RUMxMUEwMDEzRTdCMiAvKiBCb29sZWFuT2JqZWN0 LmNwcCBpbiBTb3VyY2VzICovLAorCQkJCUFEQjZGNjdEMUUxNUQ3NjAwMDgyRjM4NCAvKiBXYXNt UGFnZUNvdW50LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTE0MjgwODY1MTA3RUMxMUEwMDEzRTdC MiAvKiBCb29sZWFuUHJvdG90eXBlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCURFMjZFOTA3MUNC NURFRkIwMEQyQkU4MiAvKiBCdWlsdGluRXhlY3V0YWJsZUNyZWF0b3IuY3BwIGluIFNvdXJjZXMg Ki8sCiAJCQkJQTdEODAxQTQxODgwRDY2RTAwMjZDMzlCIC8qIEJ1aWx0aW5FeGVjdXRhYmxlcy5j cHAgaW4gU291cmNlcyAqLywKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9qc2Mu Y3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2pzYy5jcHAKaW5kZXggM2VhZjRhMC4uM2E3YTNm NCAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2pzYy5jcHAKKysrIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL2pzYy5jcHAKQEAgLTI2NDcsNyArMjY0Nyw2IEBAIHN0YXRpYyBFbmNv ZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGZ1bmN0aW9uVGVzdFdhc21Nb2R1bGVGdW5jdGlvbnMo RXhlY1N0YXRlKiBlCiAgICAgICAgICAgICAgICAgbGFzdEluZGV4ID0gY2FsbGVlSW5kZXg7CiAg ICAgICAgICAgICB9KTsKICAgICB9Ci0KICAgICBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxl SW5mb3JtYXRpb24+IG1vZHVsZUluZm9ybWF0aW9uID0gcGxhbi50YWtlTW9kdWxlSW5mb3JtYXRp b24oKTsKICAgICBSRUxFQVNFX0FTU0VSVCghbW9kdWxlSW5mb3JtYXRpb24tPm1lbW9yeSk7CiAK ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTVHlwZS5oIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmgKaW5kZXggMDUyMDJmMy4uYWM1MDlk NyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmgKKysr IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNUeXBlLmgKQEAgLTkzLDYgKzkzLDgg QEAgZW51bSBKU1R5cGUgOiB1aW50OF90IHsKICAgICBKU01hcFR5cGUsCiAgICAgSlNTZXRUeXBl LAogCisgICAgV2ViQXNzZW1ibHlGdW5jdGlvblR5cGUsCisKICAgICBMYXN0SlNDT2JqZWN0VHlw ZSA9IEpTU2V0VHlwZSwKICAgICBNYXhKU1R5cGUgPSAwYjExMTExMTExLAogfTsKZGlmZiAtLWdp dCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcCBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcAppbmRleCAxMTdk NzY0Li44MzgwYmQ2IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt QjNJUkdlbmVyYXRvci5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIz SVJHZW5lcmF0b3IuY3BwCkBAIC0xNTUsNyArMTU1LDcgQEAgcHVibGljOgogICAgICAgICAgICAg cmV0dXJuIGZhaWwoX19WQV9BUkdTX18pOyAgICAgICAgICAgICBcCiAgICAgfSB3aGlsZSAoMCkK IAotICAgIEIzSVJHZW5lcmF0b3IoVk0mLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYsIFByb2Nl ZHVyZSYsIFdhc21JbnRlcm5hbEZ1bmN0aW9uKiwgVmVjdG9yPFVubGlua2VkV2FzbVRvV2FzbUNh bGw+JiwgY29uc3QgSW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJik7CisgICAgQjNJUkdlbmVy YXRvcihWTSYsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiwgUHJvY2VkdXJlJiwgV2FzbUludGVy bmFsRnVuY3Rpb24qLCBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mKTsKIAogICAgIFBh cnRpYWxSZXN1bHQgV0FSTl9VTlVTRURfUkVUVVJOIGFkZEFyZ3VtZW50cyhjb25zdCBTaWduYXR1 cmUqKTsKICAgICBQYXJ0aWFsUmVzdWx0IFdBUk5fVU5VU0VEX1JFVFVSTiBhZGRMb2NhbChUeXBl LCB1aW50MzJfdCk7CkBAIC0yMDUsOCArMjA1LDYgQEAgcHVibGljOgogCiAgICAgdm9pZCBlbWl0 RXhjZXB0aW9uQ2hlY2soQ0NhbGxIZWxwZXJzJiwgRXhjZXB0aW9uVHlwZSk7CiAKLSAgICB2b2lk IGVtaXRSZWxvYWRQaW5uZWRSZWdpc3RlcnMoKTsKLQogcHJpdmF0ZToKICAgICBFeHByZXNzaW9u VHlwZSBlbWl0Q2hlY2tBbmRQcmVwYXJlUG9pbnRlcihFeHByZXNzaW9uVHlwZSBwb2ludGVyLCB1 aW50MzJfdCBvZmZzZXQsIHVpbnQzMl90IHNpemVPZk9wKTsKICAgICBFeHByZXNzaW9uVHlwZSBl bWl0TG9hZE9wKExvYWRPcFR5cGUsIE9yaWdpbiwgRXhwcmVzc2lvblR5cGUgcG9pbnRlciwgdWlu dDMyX3Qgb2Zmc2V0KTsKQEAgLTIxOSw3ICsyMTcsNiBAQCBwcml2YXRlOgogICAgIHZvaWQgZW1p dENoZWNrc0Zvck1vZE9yRGl2KEIzOjpPcGNvZGUsIEV4cHJlc3Npb25UeXBlIGxlZnQsIEV4cHJl c3Npb25UeXBlIHJpZ2h0KTsKIAogICAgIFZNJiBtX3ZtOwotICAgIGNvbnN0IEltbXV0YWJsZUZ1 bmN0aW9uSW5kZXhTcGFjZSYgbV9mdW5jdGlvbkluZGV4U3BhY2U7CiAgICAgY29uc3QgTW9kdWxl SW5mb3JtYXRpb24mIG1faW5mbzsKICAgICBQcm9jZWR1cmUmIG1fcHJvYzsKICAgICBCYXNpY0Js b2NrKiBtX2N1cnJlbnRCbG9jazsKQEAgLTIzMSw5ICsyMjgsOCBAQCBwcml2YXRlOgogICAgIFZh bHVlKiBtX2luc3RhbmNlVmFsdWU7CiB9OwogCi1CM0lSR2VuZXJhdG9yOjpCM0lSR2VuZXJhdG9y KFZNJiB2bSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFByb2NlZHVyZSYgcHJvY2Vk dXJlLCBXYXNtSW50ZXJuYWxGdW5jdGlvbiogY29tcGlsYXRpb24sIFZlY3RvcjxVbmxpbmtlZFdh c21Ub1dhc21DYWxsPiYgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGNvbnN0IEltbXV0YWJsZUZ1 bmN0aW9uSW5kZXhTcGFjZSYgZnVuY3Rpb25JbmRleFNwYWNlKQorQjNJUkdlbmVyYXRvcjo6QjNJ UkdlbmVyYXRvcihWTSYgdm0sIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBpbmZvLCBQcm9jZWR1 cmUmIHByb2NlZHVyZSwgV2FzbUludGVybmFsRnVuY3Rpb24qIGNvbXBpbGF0aW9uLCBWZWN0b3I8 VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4mIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzKQogICAgIDog bV92bSh2bSkKLSAgICAsIG1fZnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXhTcGFjZSkK ICAgICAsIG1faW5mbyhpbmZvKQogICAgICwgbV9wcm9jKHByb2NlZHVyZSkKICAgICAsIG1fdW5s aW5rZWRXYXNtVG9XYXNtQ2FsbHModW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMpCkBAIC0yNTQsMTQg KzI1MCwxNiBAQCBCM0lSR2VuZXJhdG9yOjpCM0lSR2VuZXJhdG9yKFZNJiB2bSwgY29uc3QgTW9k dWxlSW5mb3JtYXRpb24mIGluZm8sIFByb2NlZHVyZSYgcAogICAgICAgICB9CiAgICAgfQogCi0g ICAgaWYgKGluZm8uaGFzTWVtb3J5KCkpIHsKLSAgICAgICAgbV9tZW1vcnlCYXNlR1BSID0gaW5m by5tZW1vcnkucGlubmVkUmVnaXN0ZXJzKCkuYmFzZU1lbW9yeVBvaW50ZXI7Ci0gICAgICAgIG1f cHJvYy5waW5SZWdpc3RlcihtX21lbW9yeUJhc2VHUFIpOwotICAgICAgICBBU1NFUlQoIWluZm8u bWVtb3J5LnBpbm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnNbMF0uc2l6ZU9mZnNldCk7Ci0g ICAgICAgIG1fbWVtb3J5U2l6ZUdQUiA9IGluZm8ubWVtb3J5LnBpbm5lZFJlZ2lzdGVycygpLnNp emVSZWdpc3RlcnNbMF0uc2l6ZVJlZ2lzdGVyOwotICAgICAgICBmb3IgKGNvbnN0IFBpbm5lZFNp emVSZWdpc3RlckluZm8mIHJlZ0luZm8gOiBpbmZvLm1lbW9yeS5waW5uZWRSZWdpc3RlcnMoKS5z aXplUmVnaXN0ZXJzKQotICAgICAgICAgICAgbV9wcm9jLnBpblJlZ2lzdGVyKHJlZ0luZm8uc2l6 ZVJlZ2lzdGVyKTsKKyAgICAvLyBGSVhNRSB3ZSBkb24ndCByZWFsbHkgbmVlZCB0byBwaW4gcmVn aXN0ZXJzIGhlcmUgaWYgdGhlcmUncyBubyBtZW1vcnkuIEl0IG1ha2VzIHdhc20gLT4gd2FzbSB0 aHVua3Mgc2ltcGxlciBmb3Igbm93LiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MTY2NjIzCisgICAgY29uc3QgUGlubmVkUmVnaXN0ZXJJbmZvJiBwaW5uZWRSZWdzID0g UGlubmVkUmVnaXN0ZXJJbmZvOjpnZXQoKTsKKyAgICBtX21lbW9yeUJhc2VHUFIgPSBwaW5uZWRS ZWdzLmJhc2VNZW1vcnlQb2ludGVyOworICAgIG1fcHJvYy5waW5SZWdpc3RlcihtX21lbW9yeUJh c2VHUFIpOworICAgIEFTU0VSVCghcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzWzBdLnNpemVPZmZz ZXQpOworICAgIG1fbWVtb3J5U2l6ZUdQUiA9IHBpbm5lZFJlZ3Muc2l6ZVJlZ2lzdGVyc1swXS5z aXplUmVnaXN0ZXI7CisgICAgZm9yIChjb25zdCBQaW5uZWRTaXplUmVnaXN0ZXJJbmZvJiByZWdJ bmZvIDogcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzKQorICAgICAgICBtX3Byb2MucGluUmVnaXN0 ZXIocmVnSW5mby5zaXplUmVnaXN0ZXIpOwogCisgICAgaWYgKGluZm8uaGFzTWVtb3J5KCkpIHsK ICAgICAgICAgbV9wcm9jLnNldFdhc21Cb3VuZHNDaGVja0dlbmVyYXRvcihbPV0gKENDYWxsSGVs cGVycyYgaml0LCBHUFJSZWcgcGlubmVkR1BSLCB1bnNpZ25lZCkgewogICAgICAgICAgICAgQWxs b3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdlIGFsbG93U2NyYXRjaChqaXQpOwogICAgICAgICAg ICAgQVNTRVJUX1VOVVNFRChwaW5uZWRHUFIsIG1fbWVtb3J5U2l6ZUdQUiA9PSBwaW5uZWRHUFIp OwpAQCAtMjc1LDYgKzI3Myw1NiBAQCBCM0lSR2VuZXJhdG9yOjpCM0lSR2VuZXJhdG9yKFZNJiB2 bSwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGluZm8sIFByb2NlZHVyZSYgcAogICAgICAgICBt X2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KG1fcHJvYywgT3JpZ2luKCks ICZtX3ZtLnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZSkpOwogfQogCitzdHJ1Y3QgTWVtb3J5QmFz ZUFuZFNpemUgeworICAgIFZhbHVlKiBiYXNlOworICAgIFZhbHVlKiBzaXplOworfTsKKworc3Rh dGljIE1lbW9yeUJhc2VBbmRTaXplIGdldE1lbW9yeUJhc2VBbmRTaXplKFZNJiB2bSwgVmFsdWUq IGluc3RhbmNlLCBQcm9jZWR1cmUmIHByb2MsIEJhc2ljQmxvY2sqIGJsb2NrKQoreworICAgIFZh bHVlKiBtZW1vcnlPYmplY3QgPSBibG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihwcm9jLCBM b2FkLCBwb2ludGVyVHlwZSgpLCBPcmlnaW4oKSwgaW5zdGFuY2UsIEpTV2ViQXNzZW1ibHlJbnN0 YW5jZTo6b2Zmc2V0T2ZNZW1vcnkoKSk7CisKKyAgICBzdGF0aWNfYXNzZXJ0KHNpemVvZihkZWNs dHlwZSh2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UtPm1lbW9yeSgpLT5tZW1vcnkoKS0+bWVt b3J5KCkpKSA9PSBzaXplb2Yodm9pZCopLCAiY29kZWdlbiByZWxpZXMgb24gdGhpcyBzaXplIik7 CisgICAgc3RhdGljX2Fzc2VydChzaXplb2YoZGVjbHR5cGUodm0udG9wSlNXZWJBc3NlbWJseUlu c3RhbmNlLT5tZW1vcnkoKS0+bWVtb3J5KCktPnNpemUoKSkpID09IHNpemVvZih1aW50NjRfdCks ICJjb2RlZ2VuIHJlbGllcyBvbiB0aGlzIHNpemUiKTsKKyAgICBNZW1vcnlCYXNlQW5kU2l6ZSBy ZXN1bHQ7CisgICAgcmVzdWx0LmJhc2UgPSBibG9jay0+YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihw cm9jLCBMb2FkLCBwb2ludGVyVHlwZSgpLCBPcmlnaW4oKSwgbWVtb3J5T2JqZWN0LCBKU1dlYkFz c2VtYmx5TWVtb3J5OjpvZmZzZXRPZk1lbW9yeSgpKTsKKyAgICByZXN1bHQuc2l6ZSA9IGJsb2Nr LT5hcHBlbmROZXc8TWVtb3J5VmFsdWU+KHByb2MsIExvYWQsIEludDY0LCBPcmlnaW4oKSwgbWVt b3J5T2JqZWN0LCBKU1dlYkFzc2VtYmx5TWVtb3J5OjpvZmZzZXRPZlNpemUoKSk7CisKKyAgICBy ZXR1cm4gcmVzdWx0OworfQorCitzdGF0aWMgdm9pZCByZXN0b3JlV2ViQXNzZW1ibHlHbG9iYWxT dGF0ZShWTSYgdm0sIGNvbnN0IE1lbW9yeUluZm9ybWF0aW9uJiBtZW1vcnksIFZhbHVlKiBpbnN0 YW5jZSwgUHJvY2VkdXJlJiBwcm9jLCBCYXNpY0Jsb2NrKiBibG9jaykKK3sKKyAgICBibG9jay0+ YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihwcm9jLCBTdG9yZSwgT3JpZ2luKCksIGluc3RhbmNlLCBi bG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KHByb2MsIE9yaWdpbigpLCAmdm0udG9wSlNX ZWJBc3NlbWJseUluc3RhbmNlKSk7CisKKyAgICBpZiAoISFtZW1vcnkpIHsKKyAgICAgICAgY29u c3QgUGlubmVkUmVnaXN0ZXJJbmZvKiBwaW5uZWRSZWdzID0gJlBpbm5lZFJlZ2lzdGVySW5mbzo6 Z2V0KCk7CisgICAgICAgIFJlZ2lzdGVyU2V0IGNsb2JiZXJzOworICAgICAgICBjbG9iYmVycy5z ZXQocGlubmVkUmVncy0+YmFzZU1lbW9yeVBvaW50ZXIpOworICAgICAgICBmb3IgKGF1dG8gaW5m byA6IHBpbm5lZFJlZ3MtPnNpemVSZWdpc3RlcnMpCisgICAgICAgICAgICBjbG9iYmVycy5zZXQo aW5mby5zaXplUmVnaXN0ZXIpOworCisgICAgICAgIEIzOjpQYXRjaHBvaW50VmFsdWUqIHBhdGNo cG9pbnQgPSBibG9jay0+YXBwZW5kTmV3PEIzOjpQYXRjaHBvaW50VmFsdWU+KHByb2MsIEIzOjpW b2lkLCBPcmlnaW4oKSk7CisgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMgPSBFZmZlY3RzOjpu b25lKCk7CisgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsK KyAgICAgICAgcGF0Y2hwb2ludC0+Y2xvYmJlcihjbG9iYmVycyk7CisKKyAgICAgICAgcGF0Y2hw b2ludC0+YXBwZW5kKGluc3RhbmNlLCBWYWx1ZVJlcDo6U29tZVJlZ2lzdGVyKTsKKworICAgICAg ICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3Bpbm5lZFJlZ3NdIChDQ2FsbEhlbHBlcnMmIGpp dCwgY29uc3QgQjM6OlN0YWNrbWFwR2VuZXJhdGlvblBhcmFtcyYgcGFyYW1zKSB7CisgICAgICAg ICAgICBHUFJSZWcgYmFzZU1lbW9yeSA9IHBpbm5lZFJlZ3MtPmJhc2VNZW1vcnlQb2ludGVyOwor ICAgICAgICAgICAgaml0LmxvYWRQdHIoQ0NhbGxIZWxwZXJzOjpBZGRyZXNzKHBhcmFtc1swXS5n cHIoKSwgSlNXZWJBc3NlbWJseUluc3RhbmNlOjpvZmZzZXRPZk1lbW9yeSgpKSwgYmFzZU1lbW9y eSk7CisgICAgICAgICAgICBjb25zdCBhdXRvJiBzaXplUmVncyA9IHBpbm5lZFJlZ3MtPnNpemVS ZWdpc3RlcnM7CisgICAgICAgICAgICBBU1NFUlQoc2l6ZVJlZ3Muc2l6ZSgpID49IDEpOworICAg ICAgICAgICAgQVNTRVJUKCFzaXplUmVnc1swXS5zaXplT2Zmc2V0KTsgLy8gVGhlIGZvbGxvd2lu ZyBjb2RlIGFzc3VtZXMgd2Ugc3RhcnQgYXQgMCwgYW5kIGNhbGN1bGF0ZXMgc3Vic2VxdWVudCBz aXplIHJlZ2lzdGVycyByZWxhdGl2ZSB0byAwLgorICAgICAgICAgICAgaml0LmxvYWRQdHIoQ0Nh bGxIZWxwZXJzOjpBZGRyZXNzKGJhc2VNZW1vcnksIEpTV2ViQXNzZW1ibHlNZW1vcnk6Om9mZnNl dE9mU2l6ZSgpKSwgc2l6ZVJlZ3NbMF0uc2l6ZVJlZ2lzdGVyKTsKKyAgICAgICAgICAgIGppdC5s b2FkUHRyKENDYWxsSGVscGVyczo6QWRkcmVzcyhiYXNlTWVtb3J5LCBKU1dlYkFzc2VtYmx5TWVt b3J5OjpvZmZzZXRPZk1lbW9yeSgpKSwgYmFzZU1lbW9yeSk7CisgICAgICAgICAgICBmb3IgKHVu c2lnbmVkIGkgPSAxOyBpIDwgc2l6ZVJlZ3Muc2l6ZSgpOyArK2kpCisgICAgICAgICAgICAgICAg aml0LmFkZDY0KENDYWxsSGVscGVyczo6VHJ1c3RlZEltbTMyKC1zaXplUmVnc1tpXS5zaXplT2Zm c2V0KSwgc2l6ZVJlZ3NbMF0uc2l6ZVJlZ2lzdGVyLCBzaXplUmVnc1tpXS5zaXplUmVnaXN0ZXIp OworICAgICAgICB9KTsKKyAgICB9Cit9CisKIHZvaWQgQjNJUkdlbmVyYXRvcjo6ZW1pdEV4Y2Vw dGlvbkNoZWNrKENDYWxsSGVscGVycyYgaml0LCBFeGNlcHRpb25UeXBlIHR5cGUpCiB7CiAgICAg aml0Lm1vdmUoQ0NhbGxIZWxwZXJzOjpUcnVzdGVkSW1tMzIoc3RhdGljX2Nhc3Q8dWludDMyX3Q+ KHR5cGUpKSwgR1BSSW5mbzo6YXJndW1lbnRHUFIxKTsKQEAgLTMzOCw0OSArMzg2LDYgQEAgYXV0 byBCM0lSR2VuZXJhdG9yOjphZGRVbnJlYWNoYWJsZSgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICBy ZXR1cm4geyB9OwogfQogCi1zdGF0aWMgdm9pZCByZWxvYWRQaW5uZWRSZWdpc3RlcnMoUHJvY2Vk dXJlJiBwcm9jLCBCYXNpY0Jsb2NrKiBibG9jaywgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIGlu Zm8sIFZhbHVlKiBpbnN0YW5jZSkKLXsKLSAgICBpZiAoIWluZm8uaGFzTWVtb3J5KCkpCi0gICAg ICAgIHJldHVybjsKLQotICAgIGNvbnN0IE1lbW9yeUluZm9ybWF0aW9uKiBtZW1vcnkgPSAmaW5m by5tZW1vcnk7Ci0KLSAgICBSZWdpc3RlclNldCBjbG9iYmVyczsKLSAgICBjbG9iYmVycy5zZXQo bWVtb3J5LT5waW5uZWRSZWdpc3RlcnMoKS5iYXNlTWVtb3J5UG9pbnRlcik7Ci0gICAgZm9yIChh dXRvIGluZm8gOiBtZW1vcnktPnBpbm5lZFJlZ2lzdGVycygpLnNpemVSZWdpc3RlcnMpCi0gICAg ICAgIGNsb2JiZXJzLnNldChpbmZvLnNpemVSZWdpc3Rlcik7Ci0KLSAgICBCMzo6UGF0Y2hwb2lu dFZhbHVlKiBwYXRjaHBvaW50ID0gYmxvY2stPmFwcGVuZE5ldzxCMzo6UGF0Y2hwb2ludFZhbHVl Pihwcm9jLCBCMzo6Vm9pZCwgT3JpZ2luKCkpOwotICAgIHBhdGNocG9pbnQtPmVmZmVjdHMgPSBF ZmZlY3RzOjpub25lKCk7Ci0gICAgcGF0Y2hwb2ludC0+ZWZmZWN0cy53cml0ZXNQaW5uZWQgPSB0 cnVlOwotICAgIHBhdGNocG9pbnQtPmNsb2JiZXIoY2xvYmJlcnMpOwotICAgIHBhdGNocG9pbnQt Pm51bUdQU2NyYXRjaFJlZ2lzdGVycyA9IDE7Ci0KLSAgICBwYXRjaHBvaW50LT5hcHBlbmQoaW5z dGFuY2UsIFZhbHVlUmVwOjpTb21lUmVnaXN0ZXIpOwotCi0gICAgcGF0Y2hwb2ludC0+c2V0R2Vu ZXJhdG9yKFttZW1vcnldIChDQ2FsbEhlbHBlcnMmIGppdCwgY29uc3QgQjM6OlN0YWNrbWFwR2Vu ZXJhdGlvblBhcmFtcyYgcGFyYW1zKSB7Ci0gICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0 ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKLQotICAgICAgICBHUFJSZWcgc2NyYXRjaCA9IHBh cmFtcy5ncFNjcmF0Y2goMCk7Ci0gICAgICAgIGppdC5sb2FkUHRyKENDYWxsSGVscGVyczo6QWRk cmVzcyhwYXJhbXNbMF0uZ3ByKCksIEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZNZW1v cnkoKSksIHNjcmF0Y2gpOwotICAgICAgICBqaXQubG9hZFB0cihDQ2FsbEhlbHBlcnM6OkFkZHJl c3Moc2NyYXRjaCwgSlNXZWJBc3NlbWJseU1lbW9yeTo6b2Zmc2V0T2ZNZW1vcnkoKSksIHNjcmF0 Y2gpOwotICAgICAgICBqaXQubG9hZFB0cihDQ2FsbEhlbHBlcnM6OkFkZHJlc3Moc2NyYXRjaCwg TWVtb3J5OjpvZmZzZXRPZk1lbW9yeSgpKSwgbWVtb3J5LT5waW5uZWRSZWdpc3RlcnMoKS5iYXNl TWVtb3J5UG9pbnRlcik7Ci0KLSAgICAgICAgaml0LmxvYWQ2NChDQ2FsbEhlbHBlcnM6OkFkZHJl c3Moc2NyYXRjaCwgTWVtb3J5OjpvZmZzZXRPZlNpemUoKSksIHNjcmF0Y2gpOwotICAgICAgICBm b3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbWVtb3J5LT5waW5uZWRSZWdpc3RlcnMoKS5zaXplUmVn aXN0ZXJzLnNpemUoKTsgaSsrKSB7Ci0gICAgICAgICAgICBHUFJSZWcgc2l6ZVJlZyA9IG1lbW9y eS0+cGlubmVkUmVnaXN0ZXJzKCkuc2l6ZVJlZ2lzdGVyc1tpXS5zaXplUmVnaXN0ZXI7Ci0gICAg ICAgICAgICBqaXQubW92ZShzY3JhdGNoLCBzaXplUmVnKTsKLSAgICAgICAgICAgIGppdC5zdWI2 NChDQ2FsbEhlbHBlcnM6OlRydXN0ZWRJbW0zMihtZW1vcnktPnBpbm5lZFJlZ2lzdGVycygpLnNp emVSZWdpc3RlcnNbaV0uc2l6ZU9mZnNldCksIHNpemVSZWcpOwotICAgICAgICB9Ci0gICAgfSk7 Ci19Ci0KLXZvaWQgQjNJUkdlbmVyYXRvcjo6ZW1pdFJlbG9hZFBpbm5lZFJlZ2lzdGVycygpCi17 Ci0gICAgcmVsb2FkUGlubmVkUmVnaXN0ZXJzKG1fcHJvYywgbV9jdXJyZW50QmxvY2ssIG1faW5m bywgbV9pbnN0YW5jZVZhbHVlKTsKLX0KLQotCiBhdXRvIEIzSVJHZW5lcmF0b3I6OmFkZEdyb3dN ZW1vcnkoRXhwcmVzc2lvblR5cGUgZGVsdGEsIEV4cHJlc3Npb25UeXBlJiByZXN1bHQpIC0+IFBh cnRpYWxSZXN1bHQKIHsKICAgICBpbnQzMl90ICgqZ3Jvd01lbW9yeSkgKEV4ZWNTdGF0ZSosIGlu dDMyX3QpID0gW10gKEV4ZWNTdGF0ZSogZXhlYywgaW50MzJfdCBkZWx0YSkgLT4gaW50MzJfdCB7 CkBAIC0zODksNyArMzk0LDYgQEAgYXV0byBCM0lSR2VuZXJhdG9yOjphZGRHcm93TWVtb3J5KEV4 cHJlc3Npb25UeXBlIGRlbHRhLCBFeHByZXNzaW9uVHlwZSYgcmVzdWx0KQogCiAgICAgICAgIEpT V2ViQXNzZW1ibHlJbnN0YW5jZSogaW5zdGFuY2UgPSB2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFu Y2U7CiAgICAgICAgIEpTV2ViQXNzZW1ibHlNZW1vcnkqIHdhc21NZW1vcnkgPSBpbnN0YW5jZS0+ bWVtb3J5KCk7Ci0gICAgICAgIFJFTEVBU0VfQVNTRVJUKHdhc21NZW1vcnkpOyAvLyBUaGlzIHdv dWxkIGZhaWwgdmFsaWRhdGlvbiBvdGhlcndpc2UuCiAKICAgICAgICAgaWYgKGRlbHRhIDwgMCkK ICAgICAgICAgICAgIHJldHVybiAtMTsKQEAgLTQwNywyMSArNDExLDE5IEBAIGF1dG8gQjNJUkdl bmVyYXRvcjo6YWRkR3Jvd01lbW9yeShFeHByZXNzaW9uVHlwZSBkZWx0YSwgRXhwcmVzc2lvblR5 cGUmIHJlc3VsdCkKICAgICAgICAgbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxDb25zdFB0clZh bHVlPihtX3Byb2MsIE9yaWdpbigpLCBiaXR3aXNlX2Nhc3Q8dm9pZCo+KGdyb3dNZW1vcnkpKSwK ICAgICAgICAgbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxCMzo6VmFsdWU+KG1fcHJvYywgQjM6 OkZyYW1lUG9pbnRlciwgT3JpZ2luKCkpLCBkZWx0YSk7CiAKLSAgICBlbWl0UmVsb2FkUGlubmVk UmVnaXN0ZXJzKCk7CisgICAgcmVzdG9yZVdlYkFzc2VtYmx5R2xvYmFsU3RhdGUobV92bSwgbV9p bmZvLm1lbW9yeSwgbV9pbnN0YW5jZVZhbHVlLCBtX3Byb2MsIG1fY3VycmVudEJsb2NrKTsKIAog ICAgIHJldHVybiB7IH07CiB9CiAKIGF1dG8gQjNJUkdlbmVyYXRvcjo6YWRkQ3VycmVudE1lbW9y eShFeHByZXNzaW9uVHlwZSYgcmVzdWx0KSAtPiBQYXJ0aWFsUmVzdWx0CiB7Ci0gICAgVmFsdWUq IGpzTWVtb3J5ID0gbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4obV9wcm9j LCBMb2FkLCBwb2ludGVyVHlwZSgpLCBPcmlnaW4oKSwgbV9pbnN0YW5jZVZhbHVlLCBKU1dlYkFz c2VtYmx5SW5zdGFuY2U6Om9mZnNldE9mTWVtb3J5KCkpOwotICAgIFZhbHVlKiB3YXNtTWVtb3J5 ID0gbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4obV9wcm9jLCBMb2FkLCBw b2ludGVyVHlwZSgpLCBPcmlnaW4oKSwganNNZW1vcnksIEpTV2ViQXNzZW1ibHlNZW1vcnk6Om9m ZnNldE9mTWVtb3J5KCkpOwotICAgIFZhbHVlKiBzaXplID0gbV9jdXJyZW50QmxvY2stPmFwcGVu ZE5ldzxNZW1vcnlWYWx1ZT4obV9wcm9jLCBMb2FkLCBCMzo6SW50NjQsIE9yaWdpbigpLCB3YXNt TWVtb3J5LCBNZW1vcnk6Om9mZnNldE9mU2l6ZSgpKTsKKyAgICBhdXRvIG1lbW9yeVZhbHVlID0g Z2V0TWVtb3J5QmFzZUFuZFNpemUobV92bSwgbV9pbnN0YW5jZVZhbHVlLCBtX3Byb2MsIG1fY3Vy cmVudEJsb2NrKTsKIAogICAgIGNvbnN0ZXhwciB1aW50MzJfdCBzaGlmdFZhbHVlID0gMTY7CiAg ICAgc3RhdGljX2Fzc2VydChQYWdlQ291bnQ6OnBhZ2VTaXplID09IDEgPDwgc2hpZnRWYWx1ZSwg IlRoaXMgbXVzdCBob2xkIGZvciB0aGUgY29kZSBiZWxvdyB0byBiZSBjb3JyZWN0LiIpOwogICAg IFZhbHVlKiBudW1QYWdlcyA9IG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8VmFsdWU+KG1fcHJv YywgWlNociwgT3JpZ2luKCksCi0gICAgICAgIHNpemUsIG1fY3VycmVudEJsb2NrLT5hcHBlbmRO ZXc8Q29uc3QzMlZhbHVlPihtX3Byb2MsIE9yaWdpbigpLCBzaGlmdFZhbHVlKSk7CisgICAgICAg IG1lbW9yeVZhbHVlLnNpemUsIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8Q29uc3QzMlZhbHVl PihtX3Byb2MsIE9yaWdpbigpLCBzaGlmdFZhbHVlKSk7CiAKICAgICByZXN1bHQgPSBtX2N1cnJl bnRCbG9jay0+YXBwZW5kTmV3PFZhbHVlPihtX3Byb2MsIFRydW5jLCBPcmlnaW4oKSwgbnVtUGFn ZXMpOwogCkBAIC04MzIsMjYgKzgzNCw3NSBAQCBhdXRvIEIzSVJHZW5lcmF0b3I6OmFkZENhbGwo dWludDMyX3QgZnVuY3Rpb25JbmRleCwgY29uc3QgU2lnbmF0dXJlKiBzaWduYXR1cmUsCiAgICAg QVNTRVJUKHNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpID09IGFyZ3Muc2l6ZSgpKTsKIAogICAg IFR5cGUgcmV0dXJuVHlwZSA9IHNpZ25hdHVyZS0+cmV0dXJuVHlwZSgpOworICAgIFZlY3RvcjxV bmxpbmtlZFdhc21Ub1dhc21DYWxsPiogdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMgPSAmbV91bmxp bmtlZFdhc21Ub1dhc21DYWxsczsKIAotICAgIHJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlv bigpLnNldHVwQ2FsbChtX3Byb2MsIG1fY3VycmVudEJsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9C M1R5cGUocmV0dXJuVHlwZSksCi0gICAgICAgIFsmXSAoUGF0Y2hwb2ludFZhbHVlKiBwYXRjaHBv aW50KSB7Ci0gICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLndyaXRlc1Bpbm5lZCA9IHRy dWU7Ci0gICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsK KyAgICBpZiAobV9pbmZvLmlzSW1wb3J0ZWRGdW5jdGlvbkZyb21GdW5jdGlvbkluZGV4U3BhY2Uo ZnVuY3Rpb25JbmRleCkpIHsKKyAgICAgICAgLy8gRklYTUUgaW1wb3J0cyBjYW4gYmUgbGlua2Vk IGhlcmUsIGluc3RlYWQgb2YgZ2VuZXJhdGluZyBhIHBhdGNocG9pbnQsIGJlY2F1c2UgYWxsIGlt cG9ydCBzdHVicyBhcmUgZ2VuZXJhdGVkIGJlZm9yZSBCMyBjb21waWxhdGlvbiBzdGFydHMuIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjY0NjIKKyAgICAgICAgVmFs dWUqIGZ1bmN0aW9uSW1wb3J0ID0gbV9jdXJyZW50QmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1 ZT4obV9wcm9jLCBMb2FkLCBwb2ludGVyVHlwZSgpLCBPcmlnaW4oKSwgbV9pbnN0YW5jZVZhbHVl LCBKU1dlYkFzc2VtYmx5SW5zdGFuY2U6Om9mZnNldE9mSW1wb3J0RnVuY3Rpb24oZnVuY3Rpb25J bmRleCkpOworICAgICAgICBWYWx1ZSoganNUeXBlT2ZJbXBvcnQgPSBtX2N1cnJlbnRCbG9jay0+ YXBwZW5kTmV3PE1lbW9yeVZhbHVlPihtX3Byb2MsIExvYWQ4WiwgT3JpZ2luKCksIGZ1bmN0aW9u SW1wb3J0LCBKU0NlbGw6OnR5cGVJbmZvVHlwZU9mZnNldCgpKTsKKyAgICAgICAgVmFsdWUqIGlz V2FzbUNhbGwgPSBtX2N1cnJlbnRCbG9jay0+YXBwZW5kTmV3PFZhbHVlPihtX3Byb2MsIEVxdWFs LCBPcmlnaW4oKSwganNUeXBlT2ZJbXBvcnQsIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXc8Q29u c3QzMlZhbHVlPihtX3Byb2MsIE9yaWdpbigpLCBXZWJBc3NlbWJseUZ1bmN0aW9uVHlwZSkpOwog Ci0gICAgICAgICAgICBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4qIHVubGlua2VkV2Fz bVRvV2FzbUNhbGxzID0gJm1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHM7Ci0gICAgICAgICAgICBw YXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlv bkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25Q YXJhbXMmKSB7Ci0gICAgICAgICAgICAgICAgQWxsb3dNYWNyb1NjcmF0Y2hSZWdpc3RlclVzYWdl IGFsbG93U2NyYXRjaChqaXQpOworICAgICAgICBCYXNpY0Jsb2NrKiBpc1dhc21CbG9jayA9IG1f cHJvYy5hZGRCbG9jaygpOworICAgICAgICBCYXNpY0Jsb2NrKiBpc0pTQmxvY2sgPSBtX3Byb2Mu YWRkQmxvY2soKTsKKyAgICAgICAgQmFzaWNCbG9jayogY29udGludWF0aW9uID0gbV9wcm9jLmFk ZEJsb2NrKCk7CisgICAgICAgIG1fY3VycmVudEJsb2NrLT5hcHBlbmROZXdDb250cm9sVmFsdWUo bV9wcm9jLCBCMzo6QnJhbmNoLCBPcmlnaW4oKSwgaXNXYXNtQ2FsbCwgRnJlcXVlbnRlZEJsb2Nr KGlzV2FzbUJsb2NrKSwgRnJlcXVlbnRlZEJsb2NrKGlzSlNCbG9jaykpOworCisgICAgICAgIFZh bHVlKiB3YXNtQ2FsbFJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigpLnNldHVwQ2FsbCht X3Byb2MsIGlzV2FzbUJsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUocmV0dXJuVHlwZSks CisgICAgICAgICAgICBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2ludCkgeworICAgICAg ICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKKyAgICAg ICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICAg ICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNh bGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21h cEdlbmVyYXRpb25QYXJhbXMmKSB7CisgICAgICAgICAgICAgICAgICAgIEFsbG93TWFjcm9TY3Jh dGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAgICAgICAgICAgICAg Q0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICAgICAgICAgICAg ICBqaXQuYWRkTGlua1Rhc2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlv bkluZGV4XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZlcikgeworICAgICAgICAgICAgICAgICAgICAg ICAgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZmZXIubG9jYXRpb25P ZihjYWxsKSwgZnVuY3Rpb25JbmRleCwgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbDo6VGFyZ2V0OjpU b1dhc20gfSk7CisgICAgICAgICAgICAgICAgICAgIH0pOworICAgICAgICAgICAgICAgIH0pOwor ICAgICAgICAgICAgfSk7CisgICAgICAgIFVwc2lsb25WYWx1ZSogd2FzbUNhbGxSZXN1bHRVcHNp bG9uID0gcmV0dXJuVHlwZSA9PSBWb2lkID8gbnVsbHB0ciA6IGlzV2FzbUJsb2NrLT5hcHBlbmRO ZXc8VXBzaWxvblZhbHVlPihtX3Byb2MsIE9yaWdpbigpLCB3YXNtQ2FsbFJlc3VsdCk7CisgICAg ICAgIGlzV2FzbUJsb2NrLT5hcHBlbmROZXdDb250cm9sVmFsdWUobV9wcm9jLCBKdW1wLCBPcmln aW4oKSwgY29udGludWF0aW9uKTsKKworICAgICAgICBWYWx1ZSoganNDYWxsUmVzdWx0ID0gd2Fz bUNhbGxpbmdDb252ZW50aW9uKCkuc2V0dXBDYWxsKG1fcHJvYywgaXNKU0Jsb2NrLCBPcmlnaW4o KSwgYXJncywgdG9CM1R5cGUocmV0dXJuVHlwZSksCisgICAgICAgICAgICBbJl0gKFBhdGNocG9p bnRWYWx1ZSogcGF0Y2hwb2ludCkgeworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVj dHMud3JpdGVzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZl Y3RzLnJlYWRzUGlubmVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRH ZW5lcmF0b3IoW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxI ZWxwZXJzJiBqaXQsIGNvbnN0IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7CisgICAg ICAgICAgICAgICAgICAgIEFsbG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0 Y2goaml0KTsKKyAgICAgICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBq aXQuY2FsbCgpOworICAgICAgICAgICAgICAgICAgICBqaXQuYWRkTGlua1Rhc2soW3VubGlua2Vk V2FzbVRvV2FzbUNhbGxzLCBjYWxsLCBmdW5jdGlvbkluZGV4XSAoTGlua0J1ZmZlciYgbGlua0J1 ZmZlcikgeworICAgICAgICAgICAgICAgICAgICAgICAgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMt PmFwcGVuZCh7IGxpbmtCdWZmZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rpb25JbmRleCwgVW5s aW5rZWRXYXNtVG9XYXNtQ2FsbDo6VGFyZ2V0OjpUb0pzIH0pOworICAgICAgICAgICAgICAgICAg ICB9KTsKKyAgICAgICAgICAgICAgICB9KTsKKyAgICAgICAgICAgIH0pOworICAgICAgICBVcHNp bG9uVmFsdWUqIGpzQ2FsbFJlc3VsdFVwc2lsb24gPSByZXR1cm5UeXBlID09IFZvaWQgPyBudWxs cHRyIDogaXNKU0Jsb2NrLT5hcHBlbmROZXc8VXBzaWxvblZhbHVlPihtX3Byb2MsIE9yaWdpbigp LCBqc0NhbGxSZXN1bHQpOworICAgICAgICBpc0pTQmxvY2stPmFwcGVuZE5ld0NvbnRyb2xWYWx1 ZShtX3Byb2MsIEp1bXAsIE9yaWdpbigpLCBjb250aW51YXRpb24pOworCisgICAgICAgIG1fY3Vy cmVudEJsb2NrID0gY29udGludWF0aW9uOwogCi0gICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJz OjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAgICBpZiAocmV0dXJuVHlwZSA9PSBWb2lk KQorICAgICAgICAgICAgcmVzdWx0ID0gbnVsbHB0cjsKKyAgICAgICAgZWxzZSB7CisgICAgICAg ICAgICByZXN1bHQgPSBjb250aW51YXRpb24tPmFwcGVuZE5ldzxWYWx1ZT4obV9wcm9jLCBQaGks IHRvQjNUeXBlKHJldHVyblR5cGUpLCBPcmlnaW4oKSk7CisgICAgICAgICAgICB3YXNtQ2FsbFJl c3VsdFVwc2lsb24tPnNldFBoaShyZXN1bHQpOworICAgICAgICAgICAganNDYWxsUmVzdWx0VXBz aWxvbi0+c2V0UGhpKHJlc3VsdCk7CisgICAgICAgIH0KIAotICAgICAgICAgICAgICAgIGppdC5h ZGRMaW5rVGFzayhbdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMsIGNhbGwsIGZ1bmN0aW9uSW5kZXhd IChMaW5rQnVmZmVyJiBsaW5rQnVmZmVyKSB7Ci0gICAgICAgICAgICAgICAgICAgIHVubGlua2Vk V2FzbVRvV2FzbUNhbGxzLT5hcHBlbmQoeyBsaW5rQnVmZmVyLmxvY2F0aW9uT2YoY2FsbCksIGZ1 bmN0aW9uSW5kZXggfSk7CisgICAgICAgIC8vIFRoZSBjYWxsIGNvdWxkIGhhdmUgYmVlbiB0byBh bm90aGVyIFdlYkFzc2VtYmx5IGluc3RhbmNlLCBhbmQgLyBvciBjb3VsZCBoYXZlIG1vZGlmaWVk IG91ciBNZW1vcnkuCisgICAgICAgIHJlc3RvcmVXZWJBc3NlbWJseUdsb2JhbFN0YXRlKG1fdm0s IG1faW5mby5tZW1vcnksIG1faW5zdGFuY2VWYWx1ZSwgbV9wcm9jLCBjb250aW51YXRpb24pOwor ICAgIH0gZWxzZSB7CisgICAgICAgIHJlc3VsdCA9IHdhc21DYWxsaW5nQ29udmVudGlvbigpLnNl dHVwQ2FsbChtX3Byb2MsIG1fY3VycmVudEJsb2NrLCBPcmlnaW4oKSwgYXJncywgdG9CM1R5cGUo cmV0dXJuVHlwZSksCisgICAgICAgICAgICBbJl0gKFBhdGNocG9pbnRWYWx1ZSogcGF0Y2hwb2lu dCkgeworICAgICAgICAgICAgICAgIHBhdGNocG9pbnQtPmVmZmVjdHMud3JpdGVzUGlubmVkID0g dHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5lZmZlY3RzLnJlYWRzUGlubmVkID0g dHJ1ZTsKKyAgICAgICAgICAgICAgICBwYXRjaHBvaW50LT5zZXRHZW5lcmF0b3IoW3VubGlua2Vk V2FzbVRvV2FzbUNhbGxzLCBmdW5jdGlvbkluZGV4XSAoQ0NhbGxIZWxwZXJzJiBqaXQsIGNvbnN0 IEIzOjpTdGFja21hcEdlbmVyYXRpb25QYXJhbXMmKSB7CisgICAgICAgICAgICAgICAgICAgIEFs bG93TWFjcm9TY3JhdGNoUmVnaXN0ZXJVc2FnZSBhbGxvd1NjcmF0Y2goaml0KTsKKyAgICAgICAg ICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpDYWxsIGNhbGwgPSBqaXQuY2FsbCgpOworICAgICAg ICAgICAgICAgICAgICBqaXQuYWRkTGlua1Rhc2soW3VubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBj YWxsLCBmdW5jdGlvbkluZGV4XSAoTGlua0J1ZmZlciYgbGlua0J1ZmZlcikgeworICAgICAgICAg ICAgICAgICAgICAgICAgdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMtPmFwcGVuZCh7IGxpbmtCdWZm ZXIubG9jYXRpb25PZihjYWxsKSwgZnVuY3Rpb25JbmRleCwgVW5saW5rZWRXYXNtVG9XYXNtQ2Fs bDo6VGFyZ2V0OjpUb1dhc20gfSk7CisgICAgICAgICAgICAgICAgICAgIH0pOwogICAgICAgICAg ICAgICAgIH0pOwogICAgICAgICAgICAgfSk7Ci0gICAgICAgIH0pOwotCi0gICAgaWYgKGZ1bmN0 aW9uSW5kZXggPCBtX2luZm8uaW1wb3J0RnVuY3Rpb25Db3VudCgpKQotICAgICAgICBlbWl0UmVs b2FkUGlubmVkUmVnaXN0ZXJzKCk7CisgICAgfQogCiAgICAgcmV0dXJuIHsgfTsKIH0KQEAgLTky OSw3ICs5ODAsOCBAQCBhdXRvIEIzSVJHZW5lcmF0b3I6OmFkZENhbGxJbmRpcmVjdChjb25zdCBT aWduYXR1cmUqIHNpZ25hdHVyZSwgU2lnbmF0dXJlSW5kZXggcwogICAgICAgICAgICAgfSk7CiAg ICAgICAgIH0pOwogCi0gICAgZW1pdFJlbG9hZFBpbm5lZFJlZ2lzdGVycygpOworICAgIC8vIFRo ZSBjYWxsIGNvdWxkIGhhdmUgYmVlbiB0byBhbm90aGVyIFdlYkFzc2VtYmx5IGluc3RhbmNlLCBh bmQgLyBvciBjb3VsZCBoYXZlIG1vZGlmaWVkIG91ciBNZW1vcnkuCisgICAgcmVzdG9yZVdlYkFz c2VtYmx5R2xvYmFsU3RhdGUobV92bSwgbV9pbmZvLm1lbW9yeSwgbV9pbnN0YW5jZVZhbHVlLCBt X3Byb2MsIG1fY3VycmVudEJsb2NrKTsKIAogICAgIHJldHVybiB7IH07CiB9CkBAIC05OTgsMTIg KzEwNTAsMTAgQEAgc3RhdGljIHZvaWQgY3JlYXRlSlNUb1dhc21XcmFwcGVyKFZNJiB2bSwgQ29t cGlsYXRpb25Db250ZXh0JiBjb21waWxhdGlvbkNvbnRleHQKICAgICAgICAgfSk7CiAgICAgfQog Ci0gICAgLy8gTW92ZSBtZW1vcnkgdmFsdWVzIHRvIHRoZSBhcHByb3JpYXRlIHBsYWNlcywgaWYg bmVlZGVkLgotICAgIHsKLSAgICAgICAgVmFsdWUqIGluc3RhbmNlID0gYmxvY2stPmFwcGVuZE5l dzxNZW1vcnlWYWx1ZT4ocHJvYywgTG9hZCwgcG9pbnRlclR5cGUoKSwgT3JpZ2luKCksCi0gICAg ICAgICAgICBibG9jay0+YXBwZW5kTmV3PENvbnN0UHRyVmFsdWU+KHByb2MsIE9yaWdpbigpLCAm dm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlKSk7Ci0gICAgICAgIHJlbG9hZFBpbm5lZFJlZ2lz dGVycyhwcm9jLCBibG9jaywgaW5mbywgaW5zdGFuY2UpOwotICAgIH0KKyAgICAvLyBGSVhNRSBU aGUgaW5zdGFuY2UgaXMgY3VycmVudGx5IHNldCBieSB0aGUgQysrIGNvZGUgaW4gV2ViQXNzZW1i bHlGdW5jdGlvbjo6Y2FsbC4gV2Ugc2hvdWxkbid0IGdvIHRocm91Z2ggdGhlIGV4dHJhIEMrKyBo b29wLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY2NDg2CisgICAg VmFsdWUqIGluc3RhbmNlID0gYmxvY2stPmFwcGVuZE5ldzxNZW1vcnlWYWx1ZT4ocHJvYywgTG9h ZCwgcG9pbnRlclR5cGUoKSwgT3JpZ2luKCksCisgICAgICAgIGJsb2NrLT5hcHBlbmROZXc8Q29u c3RQdHJWYWx1ZT4ocHJvYywgT3JpZ2luKCksICZ2bS50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2Up KTsKKyAgICByZXN0b3JlV2ViQXNzZW1ibHlHbG9iYWxTdGF0ZSh2bSwgaW5mby5tZW1vcnksIGlu c3RhbmNlLCBwcm9jLCBibG9jayk7CiAKICAgICAvLyBHZXQgb3VyIGFyZ3VtZW50cy4KICAgICBW ZWN0b3I8VmFsdWUqPiBhcmd1bWVudHM7CkBAIC0xMDQ2LDcgKzEwOTYsNyBAQCBzdGF0aWMgdm9p ZCBjcmVhdGVKU1RvV2FzbVdyYXBwZXIoVk0mIHZtLCBDb21waWxhdGlvbkNvbnRleHQmIGNvbXBp bGF0aW9uQ29udGV4dAogICAgIGZ1bmN0aW9uLmpzVG9XYXNtRW50cnlwb2ludC5jYWxsZWVTYXZl UmVnaXN0ZXJzID0gcHJvYy5jYWxsZWVTYXZlUmVnaXN0ZXJzKCk7CiB9CiAKLUV4cGVjdGVkPHN0 ZDo6dW5pcXVlX3B0cjxXYXNtSW50ZXJuYWxGdW5jdGlvbj4sIFN0cmluZz4gcGFyc2VBbmRDb21w aWxlKFZNJiB2bSwgQ29tcGlsYXRpb25Db250ZXh0JiBjb21waWxhdGlvbkNvbnRleHQsIGNvbnN0 IHVpbnQ4X3QqIGZ1bmN0aW9uU3RhcnQsIHNpemVfdCBmdW5jdGlvbkxlbmd0aCwgY29uc3QgU2ln bmF0dXJlKiBzaWduYXR1cmUsIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYgdW5saW5r ZWRXYXNtVG9XYXNtQ2FsbHMsIGNvbnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYgZnVu Y3Rpb25JbmRleFNwYWNlLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgdW5zaWduZWQg b3B0TGV2ZWwpCitFeHBlY3RlZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbUludGVybmFsRnVuY3Rpb24+ LCBTdHJpbmc+IHBhcnNlQW5kQ29tcGlsZShWTSYgdm0sIENvbXBpbGF0aW9uQ29udGV4dCYgY29t cGlsYXRpb25Db250ZXh0LCBjb25zdCB1aW50OF90KiBmdW5jdGlvblN0YXJ0LCBzaXplX3QgZnVu Y3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBWZWN0b3I8VW5saW5rZWRX YXNtVG9XYXNtQ2FsbD4mIHVubGlua2VkV2FzbVRvV2FzbUNhbGxzLCBjb25zdCBNb2R1bGVJbmZv cm1hdGlvbiYgaW5mbywgY29uc3QgVmVjdG9yPFNpZ25hdHVyZUluZGV4PiYgbW9kdWxlU2lnbmF0 dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMsIHVuc2lnbmVkIG9wdExldmVsKQog ewogICAgIGF1dG8gcmVzdWx0ID0gc3RkOjptYWtlX3VuaXF1ZTxXYXNtSW50ZXJuYWxGdW5jdGlv bj4oKTsKIApAQCAtMTA1NCw4ICsxMTA0LDggQEAgRXhwZWN0ZWQ8c3RkOjp1bmlxdWVfcHRyPFdh c21JbnRlcm5hbEZ1bmN0aW9uPiwgU3RyaW5nPiBwYXJzZUFuZENvbXBpbGUoVk0mIHZtLAogICAg IGNvbXBpbGF0aW9uQ29udGV4dC53YXNtRW50cnlwb2ludEpJVCA9IHN0ZDo6bWFrZV91bmlxdWU8 Q0NhbGxIZWxwZXJzPigmdm0pOwogCiAgICAgUHJvY2VkdXJlIHByb2NlZHVyZTsKLSAgICBCM0lS R2VuZXJhdG9yIGNvbnRleHQodm0sIGluZm8sIHByb2NlZHVyZSwgcmVzdWx0LmdldCgpLCB1bmxp bmtlZFdhc21Ub1dhc21DYWxscywgZnVuY3Rpb25JbmRleFNwYWNlKTsKLSAgICBGdW5jdGlvblBh cnNlcjxCM0lSR2VuZXJhdG9yPiBwYXJzZXIoJnZtLCBjb250ZXh0LCBmdW5jdGlvblN0YXJ0LCBm dW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBmdW5jdGlvbkluZGV4U3BhY2UsIGluZm8pOworICAg IEIzSVJHZW5lcmF0b3IgY29udGV4dCh2bSwgaW5mbywgcHJvY2VkdXJlLCByZXN1bHQuZ2V0KCks IHVubGlua2VkV2FzbVRvV2FzbUNhbGxzKTsKKyAgICBGdW5jdGlvblBhcnNlcjxCM0lSR2VuZXJh dG9yPiBwYXJzZXIoJnZtLCBjb250ZXh0LCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwg c2lnbmF0dXJlLCBpbmZvLCBtb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJl SW5kaWNlcyk7CiAgICAgV0FTTV9GQUlMX0lGX0hFTFBFUl9GQUlMUyhwYXJzZXIucGFyc2UoKSk7 CiAKICAgICBwcm9jZWR1cmUucmVzZXRSZWFjaGFiaWxpdHkoKTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmggYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5oCmluZGV4IGI1YzlmNDYuLjI0OWQ1Nzgg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9y LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0b3IuaApA QCAtNDcsNyArNDcsNyBAQCBzdHJ1Y3QgQ29tcGlsYXRpb25Db250ZXh0IHsKICAgICBDQ2FsbEhl bHBlcnM6OkNhbGwganNFbnRyeXBvaW50VG9XYXNtRW50cnlwb2ludENhbGw7CiB9OwogCi1FeHBl Y3RlZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbUludGVybmFsRnVuY3Rpb24+LCBTdHJpbmc+IHBhcnNl QW5kQ29tcGlsZShWTSYsIENvbXBpbGF0aW9uQ29udGV4dCYsIGNvbnN0IHVpbnQ4X3QqLCBzaXpl X3QsIGNvbnN0IFNpZ25hdHVyZSosIFZlY3RvcjxVbmxpbmtlZFdhc21Ub1dhc21DYWxsPiYsIGNv bnN0IEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9u JiwgdW5zaWduZWQgb3B0TGV2ZWwgPSAxKTsKK0V4cGVjdGVkPHN0ZDo6dW5pcXVlX3B0cjxXYXNt SW50ZXJuYWxGdW5jdGlvbj4sIFN0cmluZz4gcGFyc2VBbmRDb21waWxlKFZNJiwgQ29tcGlsYXRp b25Db250ZXh0JiwgY29uc3QgdWludDhfdCosIHNpemVfdCwgY29uc3QgU2lnbmF0dXJlKiwgVmVj dG9yPFVubGlua2VkV2FzbVRvV2FzbUNhbGw+JiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mLCBj b25zdCBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+JiwgdW5zaWduZWQgb3B0TGV2ZWwgPSAxKTsKIAog fSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbUJpbmRpbmcuY3BwCmluZGV4IDBlNTkyNDcuLjk5NzAyZWMgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5jcHAKQEAgLTM2LDEzICszNiwyMSBAQAogCiBuYW1l c3BhY2UgSlNDIHsgbmFtZXNwYWNlIFdhc20gewogCi1XYXNtVG9KU1N0dWIgaW1wb3J0U3R1Ykdl bmVyYXRvcihWTSogdm0sIEJhZzxDYWxsTGlua0luZm8+JiBjYWxsTGlua0luZm9zLCBTaWduYXR1 cmVJbmRleCBzaWduYXR1cmVJbmRleCwgdW5zaWduZWQgaW1wb3J0SW5kZXgpCit0eXBlZGVmIEFz c2VtYmx5SGVscGVycyBKSVQ7CisKK3N0YXRpYyB2b2lkIG1hdGVyaWFsaXplSW1wb3J0SlNDZWxs KFZNKiB2bSwgSklUJiBqaXQsIHVuc2lnbmVkIGltcG9ydEluZGV4LCBHUFJSZWcgcmVzdWx0KQor eworICAgIC8vIFdlJ3JlIGNhbGxpbmcgb3V0IG9mIHRoZSBjdXJyZW50IFdlYkFzc2VtYmx5Lklu c3RhbmNlLCB3aGljaCBpcyBpZGVudGlmaWVkIG9uIFZNLiBUaGF0IEluc3RhbmNlIGhhcyBhIGxp c3Qgb2YgYWxsIGl0cyBpbXBvcnQgZnVuY3Rpb25zLgorICAgIGppdC5sb2FkUHRyKCZ2bS0+dG9w SlNXZWJBc3NlbWJseUluc3RhbmNlLCByZXN1bHQpOworICAgIGppdC5sb2FkUHRyKEpJVDo6QWRk cmVzcyhyZXN1bHQsIEpTV2ViQXNzZW1ibHlJbnN0YW5jZTo6b2Zmc2V0T2ZJbXBvcnRGdW5jdGlv bihpbXBvcnRJbmRleCkpLCByZXN1bHQpOworfQorCitzdGF0aWMgTWFjcm9Bc3NlbWJsZXJDb2Rl UmVmIHdhc21Ub0pzKFZNKiB2bSwgQmFnPENhbGxMaW5rSW5mbz4mIGNhbGxMaW5rSW5mb3MsIFNp Z25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4LCB1bnNpZ25lZCBpbXBvcnRJbmRleCkKIHsKICAg ICBjb25zdCBXYXNtQ2FsbGluZ0NvbnZlbnRpb24mIHdhc21DQyA9IHdhc21DYWxsaW5nQ29udmVu dGlvbigpOwogICAgIGNvbnN0IEpTQ0NhbGxpbmdDb252ZW50aW9uJiBqc0NDID0ganNjQ2FsbGlu Z0NvbnZlbnRpb24oKTsKICAgICBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFNpZ25hdHVy ZUluZm9ybWF0aW9uOjpnZXQodm0sIHNpZ25hdHVyZUluZGV4KTsKICAgICB1bnNpZ25lZCBhcmdD b3VudCA9IHNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpOwotICAgIHR5cGVkZWYgQXNzZW1ibHlI ZWxwZXJzIEpJVDsKICAgICBKSVQgaml0KHZtLCBudWxscHRyKTsKIAogICAgIC8vIEJlbG93LCB3 ZSBhc3N1bWUgdGhhdCB0aGUgSlMgY2FsbGluZyBjb252ZW50aW9uIGlzIGFsd2F5cyBvbiB0aGUg c3RhY2suCkBAIC0xMzgsOSArMTQ2LDcgQEAgV2FzbVRvSlNTdHViIGltcG9ydFN0dWJHZW5lcmF0 b3IoVk0qIHZtLCBCYWc8Q2FsbExpbmtJbmZvPiYgY2FsbExpbmtJbmZvcywgU2lnbmEKICAgICBH UFJSZWcgaW1wb3J0SlNDZWxsR1BSUmVnID0gR1BSSW5mbzo6cmVnVDA7IC8vIENhbGxlZSBuZWVk cyB0byBiZSBpbiByZWdUMCBmb3Igc2xvdyBwYXRoIGJlbG93LgogICAgIEFTU0VSVCghd2FzbUND Lm1fY2FsbGVlU2F2ZVJlZ2lzdGVycy5nZXQoaW1wb3J0SlNDZWxsR1BSUmVnKSk7CiAKLSAgICAv LyBFYWNoIEpTIC0+IHdhc20gZW50cnkgc2V0cyB0aGUgV2ViQXNzZW1ibHkuSW5zdGFuY2Ugd2hv c2UgZXhwb3J0IGlzIGJlaW5nIGNhbGxlZC4gV2UncmUgY2FsbGluZyBvdXQgb2YgdGhpcyBJbnN0 YW5jZSwgYW5kIGNhbiB0aGVyZWZvcmUgZmlndXJlIG91dCB0aGUgaW1wb3J0IGJlaW5nIGNhbGxl ZC4KLSAgICBqaXQubG9hZFB0cigmdm0tPnRvcEpTV2ViQXNzZW1ibHlJbnN0YW5jZSwgaW1wb3J0 SlNDZWxsR1BSUmVnKTsKLSAgICBqaXQubG9hZFB0cihKSVQ6OkFkZHJlc3MoaW1wb3J0SlNDZWxs R1BSUmVnLCBKU1dlYkFzc2VtYmx5SW5zdGFuY2U6Om9mZnNldE9mSW1wb3J0RnVuY3Rpb24oaW1w b3J0SW5kZXgpKSwgaW1wb3J0SlNDZWxsR1BSUmVnKTsKKyAgICBtYXRlcmlhbGl6ZUltcG9ydEpT Q2VsbCh2bSwgaml0LCBpbXBvcnRJbmRleCwgaW1wb3J0SlNDZWxsR1BSUmVnKTsKIAogICAgIHVp bnQ2NF90IHRoaXNBcmd1bWVudCA9IFZhbHVlVW5kZWZpbmVkOyAvLyBGSVhNRSB3aGF0IGRvZXMg dGhlIFdlYkFzc2VtYmx5IHNwZWMgc2F5IHRoaXMgc2hvdWxkIGJlPyBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY1NDcxCiAgICAgaml0LnN0b3JlNjQoaW1wb3J0SlND ZWxsR1BSUmVnLCBjYWxsZWVGcmFtZS53aXRoT2Zmc2V0KENhbGxGcmFtZVNsb3Q6OmNhbGxlZSAq IHN0YXRpY19jYXN0PGludD4oc2l6ZW9mKFJlZ2lzdGVyKSkpKTsKQEAgLTIzMSw3ICsyMzcsNTYg QEAgV2FzbVRvSlNTdHViIGltcG9ydFN0dWJHZW5lcmF0b3IoVk0qIHZtLCBCYWc8Q2FsbExpbmtJ bmZvPiYgY2FsbExpbmtJbmZvcywgU2lnbmEKICAgICBDb2RlTG9jYXRpb25MYWJlbCBob3RQYXRo QmVnaW4ocGF0Y2hCdWZmZXIubG9jYXRpb25PZih0YXJnZXRUb0NoZWNrKSk7CiAgICAgQ29kZUxv Y2F0aW9uTmVhckNhbGwgaG90UGF0aE90aGVyID0gcGF0Y2hCdWZmZXIubG9jYXRpb25PZk5lYXJD YWxsKGZhc3RDYWxsKTsKICAgICBjYWxsTGlua0luZm8tPnNldENhbGxMb2NhdGlvbnMoY2FsbFJl dHVybkxvY2F0aW9uLCBob3RQYXRoQmVnaW4sIGhvdFBhdGhPdGhlcik7Ci0gICAgcmV0dXJuIEZJ TkFMSVpFX0NPREUocGF0Y2hCdWZmZXIsICgiV2ViQXNzZW1ibHkgaW1wb3J0WyVpXSBzdHViIGZv ciBzaWduYXR1cmUgJWkiLCBpbXBvcnRJbmRleCwgc2lnbmF0dXJlSW5kZXgpKTsKKyAgICBTdHJp bmcgc2lnbmF0dXJlRGVzY3JpcHRpb24gPSBTaWduYXR1cmVJbmZvcm1hdGlvbjo6Z2V0KHZtLCBz aWduYXR1cmVJbmRleCktPnRvU3RyaW5nKCk7CisgICAgcmV0dXJuIEZJTkFMSVpFX0NPREUocGF0 Y2hCdWZmZXIsICgiV2ViQXNzZW1ibHktPkphdmFTY3JpcHQgaW1wb3J0WyVpXSAlcyIsIGltcG9y dEluZGV4LCBzaWduYXR1cmVEZXNjcmlwdGlvbi5hc2NpaSgpLmRhdGEoKSkpOworfQorCitzdGF0 aWMgTWFjcm9Bc3NlbWJsZXJDb2RlUmVmIHdhc21Ub1dhc20oVk0qIHZtLCB1bnNpZ25lZCBpbXBv cnRJbmRleCkKK3sKKyAgICBjb25zdCBQaW5uZWRSZWdpc3RlckluZm8mIHBpbm5lZFJlZ3MgPSBQ aW5uZWRSZWdpc3RlckluZm86OmdldCgpOworICAgIEpJVCBqaXQodm0sIG51bGxwdHIpOworCisg ICAgR1BSUmVnIHNjcmF0Y2ggPSBHUFJJbmZvOjpub25QcmVzZXJ2ZWROb25Bcmd1bWVudEdQUjsK KworICAgIC8vIEIzJ3MgY2FsbCBjb2RlZ2VuIGVuc3VyZXMgdGhhdCB0aGUgSlNDZWxsIGlzIGEg V2ViQXNzZW1ibHlGdW5jdGlvbi4KKyAgICBtYXRlcmlhbGl6ZUltcG9ydEpTQ2VsbCh2bSwgaml0 LCBpbXBvcnRJbmRleCwgc2NyYXRjaCk7CisKKyAgICAvLyBHZXQgdGhlIGNhbGxlZSdzIFdlYkFz c2VtYmx5Lkluc3RhbmNlIGFuZCBzZXQgaXQgYXMgdm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNl LiBUaGUgY2FsbGVyIHdpbGwgdGFrZSBjYXJlIG9mIHJlc3RvcmluZyBpdHMgb3duIEluc3RhbmNl LgorICAgIEdQUlJlZyBiYXNlTWVtb3J5ID0gcGlubmVkUmVncy5iYXNlTWVtb3J5UG9pbnRlcjsK KyAgICBBU1NFUlQoYmFzZU1lbW9yeSAhPSBzY3JhdGNoKTsKKyAgICBqaXQubG9hZFB0cihKSVQ6 OkFkZHJlc3Moc2NyYXRjaCwgV2ViQXNzZW1ibHlGdW5jdGlvbjo6b2Zmc2V0T2ZJbnN0YW5jZSgp KSwgYmFzZU1lbW9yeSk7IC8vIEluc3RhbmNlKi4KKyAgICBqaXQuc3RvcmVQdHIoYmFzZU1lbW9y eSwgJnZtLT50b3BKU1dlYkFzc2VtYmx5SW5zdGFuY2UpOworCisgICAgLy8gRklYTUUgdGhlIGZv bGxvd2luZyBjb2RlIGFzc3VtZXMgdGhhdCBhbGwgV2ViQXNzZW1ibHkuSW5zdGFuY2UgaGF2ZSB0 aGUgc2FtZSBwaW5uZWQgcmVnaXN0ZXJzLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MTYyOTUyCisgICAgLy8gU2V0IHVwIHRoZSBjYWxsZWUncyBiYXNlTWVtb3J5IHJl Z2lzdGVyIGFzIHdlbGwgYXMgdGhlIG1lbW9yeSBzaXplIHJlZ2lzdGVycy4KKyAgICBqaXQubG9h ZFB0cihKSVQ6OkFkZHJlc3MoYmFzZU1lbW9yeSwgSlNXZWJBc3NlbWJseUluc3RhbmNlOjpvZmZz ZXRPZk1lbW9yeSgpKSwgYmFzZU1lbW9yeSk7IC8vIEpTV2ViQXNzZW1ibHlNZW1vcnkqLgorICAg IGNvbnN0IGF1dG8mIHNpemVSZWdzID0gcGlubmVkUmVncy5zaXplUmVnaXN0ZXJzOworICAgIEFT U0VSVChzaXplUmVncy5zaXplKCkgPj0gMSk7CisgICAgQVNTRVJUKHNpemVSZWdzWzBdLnNpemVS ZWdpc3RlciAhPSBiYXNlTWVtb3J5KTsKKyAgICBBU1NFUlQoc2l6ZVJlZ3NbMF0uc2l6ZVJlZ2lz dGVyICE9IHNjcmF0Y2gpOworICAgIEFTU0VSVCghc2l6ZVJlZ3NbMF0uc2l6ZU9mZnNldCk7IC8v IFRoZSBmb2xsb3dpbmcgY29kZSBhc3N1bWVzIHdlIHN0YXJ0IGF0IDAsIGFuZCBjYWxjdWxhdGVz IHN1YnNlcXVlbnQgc2l6ZSByZWdpc3RlcnMgcmVsYXRpdmUgdG8gMC4KKyAgICBqaXQubG9hZFB0 cihKSVQ6OkFkZHJlc3MoYmFzZU1lbW9yeSwgSlNXZWJBc3NlbWJseU1lbW9yeTo6b2Zmc2V0T2ZT aXplKCkpLCBzaXplUmVnc1swXS5zaXplUmVnaXN0ZXIpOyAvLyBNZW1vcnkgc2l6ZS4KKyAgICBq aXQubG9hZFB0cihKSVQ6OkFkZHJlc3MoYmFzZU1lbW9yeSwgSlNXZWJBc3NlbWJseU1lbW9yeTo6 b2Zmc2V0T2ZNZW1vcnkoKSksIGJhc2VNZW1vcnkpOyAvLyBXYXNtTWVtb3J5Ojp2b2lkKi4KKyAg ICBmb3IgKHVuc2lnbmVkIGkgPSAxOyBpIDwgc2l6ZVJlZ3Muc2l6ZSgpOyArK2kpIHsKKyAgICAg ICAgQVNTRVJUKHNpemVSZWdzW2ldLnNpemVSZWdpc3RlciAhPSBiYXNlTWVtb3J5KTsKKyAgICAg ICAgQVNTRVJUKHNpemVSZWdzW2ldLnNpemVSZWdpc3RlciAhPSBzY3JhdGNoKTsKKyAgICAgICAg aml0LmFkZDY0KEpJVDo6VHJ1c3RlZEltbTMyKC1zaXplUmVnc1tpXS5zaXplT2Zmc2V0KSwgc2l6 ZVJlZ3NbMF0uc2l6ZVJlZ2lzdGVyLCBzaXplUmVnc1tpXS5zaXplUmVnaXN0ZXIpOworICAgIH0K KworICAgIC8vIFRhaWwgY2FsbCBpbnRvIHRoZSBjYWxsZWUgV2ViQXNzZW1ibHkgZnVuY3Rpb24u CisgICAgaml0LmxvYWRQdHIoSklUOjpBZGRyZXNzKHNjcmF0Y2gsIFdlYkFzc2VtYmx5RnVuY3Rp b246Om9mZnNldE9mV2FzbUVudHJ5UG9pbnRDb2RlKCkpLCBzY3JhdGNoKTsKKyAgICBqaXQuanVt cChzY3JhdGNoKTsKKworICAgIExpbmtCdWZmZXIgcGF0Y2hCdWZmZXIoKnZtLCBqaXQsIEdMT0JB TF9USFVOS19JRCk7CisgICAgcmV0dXJuIEZJTkFMSVpFX0NPREUocGF0Y2hCdWZmZXIsICgiV2Vi QXNzZW1ibHktPldlYkFzc2VtYmx5IGltcG9ydFslaV0iLCBpbXBvcnRJbmRleCkpOworfQorCitX YXNtRXhpdFN0dWJzIGV4aXRTdHViR2VuZXJhdG9yKFZNKiB2bSwgQmFnPENhbGxMaW5rSW5mbz4m IGNhbGxMaW5rSW5mb3MsIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4LCB1bnNpZ25lZCBp bXBvcnRJbmRleCkKK3sKKyAgICBXYXNtRXhpdFN0dWJzIHN0dWJzOworICAgIHN0dWJzLndhc21U b0pzID0gd2FzbVRvSnModm0sIGNhbGxMaW5rSW5mb3MsIHNpZ25hdHVyZUluZGV4LCBpbXBvcnRJ bmRleCk7CisgICAgc3R1YnMud2FzbVRvV2FzbSA9IHdhc21Ub1dhc20odm0sIGltcG9ydEluZGV4 KTsKKyAgICByZXR1cm4gc3R1YnM7CiB9CiAKIH0gfSAvLyBuYW1lc3BhY2UgSlNDOjpXYXNtCmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5oIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUJpbmRpbmcuaAppbmRleCBmZDdlMDNkLi40MDIx ZjE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQmluZGluZy5o CisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21CaW5kaW5nLmgKQEAgLTM4LDcg KzM4LDcgQEAgY2xhc3MgQ2FsbExpbmtJbmZvOwogCiBuYW1lc3BhY2UgV2FzbSB7CiAKLVdhc21U b0pTU3R1YiBpbXBvcnRTdHViR2VuZXJhdG9yKFZNKiwgQmFnPENhbGxMaW5rSW5mbz4mLCBTaWdu YXR1cmVJbmRleCwgdW5zaWduZWQpOworV2FzbUV4aXRTdHVicyBleGl0U3R1YkdlbmVyYXRvcihW TSosIEJhZzxDYWxsTGlua0luZm8+JiwgU2lnbmF0dXJlSW5kZXgsIHVuc2lnbmVkKTsKIAogfSB9 IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbUZvcm1hdC5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZv cm1hdC5oCmluZGV4IGNiMmJlNTUuLjBkN2UwYTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21Gb3JtYXQuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtRm9ybWF0LmgKQEAgLTIyMiw3ICsyMjIsNiBAQCBwcml2YXRlOgogfTsKIAogc3RydWN0 IE1vZHVsZUluZm9ybWF0aW9uIHsKLSAgICBWZWN0b3I8U2lnbmF0dXJlSW5kZXg+IHNpZ25hdHVy ZUluZGljZXM7CiAgICAgVmVjdG9yPEltcG9ydD4gaW1wb3J0czsKICAgICBWZWN0b3I8U2lnbmF0 dXJlSW5kZXg+IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlczsKICAgICBWZWN0b3I8U2ln bmF0dXJlSW5kZXg+IGludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzOwpAQCAtMjM2LDYg KzIzNSwxOCBAQCBzdHJ1Y3QgTW9kdWxlSW5mb3JtYXRpb24gewogICAgIFRhYmxlSW5mb3JtYXRp b24gdGFibGVJbmZvcm1hdGlvbjsKICAgICBWZWN0b3I8R2xvYmFsPiBnbG9iYWxzOwogICAgIHVu c2lnbmVkIGZpcnN0SW50ZXJuYWxHbG9iYWwgeyAwIH07CisgICAgc2l6ZV90IGZ1bmN0aW9uSW5k ZXhTcGFjZVNpemUoKSBjb25zdCB7IHJldHVybiBpbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGlj ZXMuc2l6ZSgpICsgaW50ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXMuc2l6ZSgpOyB9Cisg ICAgYm9vbCBpc0ltcG9ydGVkRnVuY3Rpb25Gcm9tRnVuY3Rpb25JbmRleFNwYWNlKHNpemVfdCBm dW5jdGlvbkluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgQVNTRVJUKGZ1bmN0aW9uSW5kZXgg PCBmdW5jdGlvbkluZGV4U3BhY2VTaXplKCkpOworICAgICAgICByZXR1cm4gZnVuY3Rpb25JbmRl eCA8IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCk7CisgICAgfQorICAgIFNp Z25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShzaXplX3Qg ZnVuY3Rpb25JbmRleCkgY29uc3QKKyAgICB7CisgICAgICAgIHJldHVybiBpc0ltcG9ydGVkRnVu Y3Rpb25Gcm9tRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgpCisgICAgICAgICAgICA/ IGltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4XQorICAgICAgICAg ICAgOiBpbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4IC0gaW1w b3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnNpemUoKV07CisgICAgfQogCiAgICAgdWludDMy X3QgaW1wb3J0RnVuY3Rpb25Db3VudCgpIGNvbnN0IHsgcmV0dXJuIGltcG9ydEZ1bmN0aW9uU2ln bmF0dXJlSW5kaWNlcy5zaXplKCk7IH0KICAgICBib29sIGhhc01lbW9yeSgpIGNvbnN0IHsgcmV0 dXJuICEhbWVtb3J5OyB9CkBAIC0yNDYsNiArMjU3LDEwIEBAIHN0cnVjdCBNb2R1bGVJbmZvcm1h dGlvbiB7CiBzdHJ1Y3QgVW5saW5rZWRXYXNtVG9XYXNtQ2FsbCB7CiAgICAgQ29kZUxvY2F0aW9u Q2FsbCBjYWxsTG9jYXRpb247CiAgICAgc2l6ZV90IGZ1bmN0aW9uSW5kZXg7CisgICAgZW51bSBj bGFzcyBUYXJnZXQgOiB1aW50OF90IHsKKyAgICAgICAgVG9KcywKKyAgICAgICAgVG9XYXNtLAor ICAgIH0gdGFyZ2V0OwogfTsKIAogc3RydWN0IEVudHJ5cG9pbnQgewpAQCAtMjYxLDcgKzI3Niwx MCBAQCBzdHJ1Y3QgV2FzbUludGVybmFsRnVuY3Rpb24gewogICAgIEVudHJ5cG9pbnQganNUb1dh c21FbnRyeXBvaW50OwogfTsKIAotdHlwZWRlZiBNYWNyb0Fzc2VtYmxlckNvZGVSZWYgV2FzbVRv SlNTdHViOworc3RydWN0IFdhc21FeGl0U3R1YnMgeworICAgIE1hY3JvQXNzZW1ibGVyQ29kZVJl ZiB3YXNtVG9KczsKKyAgICBNYWNyb0Fzc2VtYmxlckNvZGVSZWYgd2FzbVRvV2FzbTsKK307CiAK IC8vIFdlYkFzc2VtYmx5IGRpcmVjdCBjYWxscyBhbmQgY2FsbF9pbmRpcmVjdCB1c2UgaW5kaWNl cyBpbnRvICJmdW5jdGlvbiBpbmRleCBzcGFjZSIuIFRoaXMgc3BhY2Ugc3RhcnRzIHdpdGggYWxs IGltcG9ydHMsIGFuZCB0aGVuIGFsbCBpbnRlcm5hbCBmdW5jdGlvbnMuCiAvLyBDYWxsYWJsZUZ1 bmN0aW9uIGFuZCBGdW5jdGlvbkluZGV4U3BhY2UgYXJlIG9ubHkgbWVhbnQgYXMgZmFzdCBsb29r dXAgdGFibGVzIGZvciB0aGVzZSBvcGNvZGVzLCBhbmQgZG8gbm90IG93biBjb2RlLgpAQCAtMjgw LDEyICsyOTgsNiBAQCBzdHJ1Y3QgQ2FsbGFibGVGdW5jdGlvbiB7CiB9OwogdHlwZWRlZiBWZWN0 b3I8Q2FsbGFibGVGdW5jdGlvbj4gRnVuY3Rpb25JbmRleFNwYWNlOwogCi0KLXN0cnVjdCBJbW11 dGFibGVGdW5jdGlvbkluZGV4U3BhY2UgewotICAgIE1hbGxvY1B0cjxDYWxsYWJsZUZ1bmN0aW9u PiBidWZmZXI7Ci0gICAgc2l6ZV90IHNpemU7Ci19OwotCiB9IH0gLy8gbmFtZXNwYWNlIEpTQzo6 V2FzbQogCiAjZW5kaWYgLy8gRU5BQkxFKFdFQkFTU0VNQkxZKQpkaWZmIC0tZ2l0IGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmggYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rpb25QYXJzZXIuaAppbmRleCA1MjAxMGRjLi4zMTEwNWQ4 IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rpb25QYXJz ZXIuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rpb25QYXJzZXIu aApAQCAtNDYsNyArNDYsNyBAQCBwdWJsaWM6CiAgICAgdHlwZWRlZiB0eXBlbmFtZSBDb250ZXh0 OjpDb250cm9sVHlwZSBDb250cm9sVHlwZTsKICAgICB0eXBlZGVmIHR5cGVuYW1lIENvbnRleHQ6 OkV4cHJlc3Npb25MaXN0IEV4cHJlc3Npb25MaXN0OwogCi0gICAgRnVuY3Rpb25QYXJzZXIoVk0q LCBDb250ZXh0JiwgY29uc3QgdWludDhfdCogZnVuY3Rpb25TdGFydCwgc2l6ZV90IGZ1bmN0aW9u TGVuZ3RoLCBjb25zdCBTaWduYXR1cmUqLCBjb25zdCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3Bh Y2UmLCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYpOworICAgIEZ1bmN0aW9uUGFyc2VyKFZNKiwg Q29udGV4dCYsIGNvbnN0IHVpbnQ4X3QqIGZ1bmN0aW9uU3RhcnQsIHNpemVfdCBmdW5jdGlvbkxl bmd0aCwgY29uc3QgU2lnbmF0dXJlKiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mLCBjb25zdCBW ZWN0b3I8U2lnbmF0dXJlSW5kZXg+Jik7CiAKICAgICBSZXN1bHQgV0FSTl9VTlVTRURfUkVUVVJO IHBhcnNlKCk7CiAKQEAgLTgyLDE4ICs4MiwxOCBAQCBwcml2YXRlOgogICAgIEV4cHJlc3Npb25M aXN0IG1fZXhwcmVzc2lvblN0YWNrOwogICAgIFZlY3RvcjxDb250cm9sRW50cnk+IG1fY29udHJv bFN0YWNrOwogICAgIGNvbnN0IFNpZ25hdHVyZSogbV9zaWduYXR1cmU7Ci0gICAgY29uc3QgSW1t dXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiBtX2Z1bmN0aW9uSW5kZXhTcGFjZTsKICAgICBjb25z dCBNb2R1bGVJbmZvcm1hdGlvbiYgbV9pbmZvOworICAgIGNvbnN0IFZlY3RvcjxTaWduYXR1cmVJ bmRleD4mIG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXM7 CiAgICAgdW5zaWduZWQgbV91bnJlYWNoYWJsZUJsb2NrcyB7IDAgfTsKIH07CiAKIHRlbXBsYXRl PHR5cGVuYW1lIENvbnRleHQ+Ci1GdW5jdGlvblBhcnNlcjxDb250ZXh0Pjo6RnVuY3Rpb25QYXJz ZXIoVk0qIHZtLCBDb250ZXh0JiBjb250ZXh0LCBjb25zdCB1aW50OF90KiBmdW5jdGlvblN0YXJ0 LCBzaXplX3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBjb25z dCBJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2UmIGZ1bmN0aW9uSW5kZXhTcGFjZSwgY29uc3Qg TW9kdWxlSW5mb3JtYXRpb24mIGluZm8pCitGdW5jdGlvblBhcnNlcjxDb250ZXh0Pjo6RnVuY3Rp b25QYXJzZXIoVk0qIHZtLCBDb250ZXh0JiBjb250ZXh0LCBjb25zdCB1aW50OF90KiBmdW5jdGlv blN0YXJ0LCBzaXplX3QgZnVuY3Rpb25MZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJl LCBjb25zdCBNb2R1bGVJbmZvcm1hdGlvbiYgaW5mbywgY29uc3QgVmVjdG9yPFNpZ25hdHVyZUlu ZGV4PiYgbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMpCiAg ICAgOiBQYXJzZXIodm0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoKQogICAgICwgbV9j b250ZXh0KGNvbnRleHQpCiAgICAgLCBtX3NpZ25hdHVyZShzaWduYXR1cmUpCi0gICAgLCBtX2Z1 bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4U3BhY2UpCiAgICAgLCBtX2luZm8oaW5mbykK KyAgICAsIG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMo bW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMpCiB7CiAgICAg aWYgKHZlcmJvc2UpCiAgICAgICAgIGRhdGFMb2dMbigiUGFyc2luZyBmdW5jdGlvbiBzdGFydGlu ZyBhdDogIiwgKHVpbnRwdHJfdClmdW5jdGlvblN0YXJ0LCAiIG9mIGxlbmd0aDogIiwgZnVuY3Rp b25MZW5ndGgpOwpAQCAtMzA4LDkgKzMwOCw5IEBAIGF1dG8gRnVuY3Rpb25QYXJzZXI8Q29udGV4 dD46OnBhcnNlRXhwcmVzc2lvbihPcFR5cGUgb3ApIC0+IFBhcnRpYWxSZXN1bHQKICAgICBjYXNl IENhbGw6IHsKICAgICAgICAgdWludDMyX3QgZnVuY3Rpb25JbmRleDsKICAgICAgICAgV0FTTV9Q QVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoZnVuY3Rpb25JbmRleCksICJjYW4ndCBwYXJz ZSBjYWxsJ3MgZnVuY3Rpb24gaW5kZXgiKTsKLSAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihm dW5jdGlvbkluZGV4ID49IG1fZnVuY3Rpb25JbmRleFNwYWNlLnNpemUsICJjYWxsIGZ1bmN0aW9u IGluZGV4ICIsIGZ1bmN0aW9uSW5kZXgsICIgZXhjZWVkcyBmdW5jdGlvbiBpbmRleCBzcGFjZSAi LCBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5zaXplKTsKKyAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9J RihmdW5jdGlvbkluZGV4ID49IG1faW5mby5mdW5jdGlvbkluZGV4U3BhY2VTaXplKCksICJjYWxs IGZ1bmN0aW9uIGluZGV4ICIsIGZ1bmN0aW9uSW5kZXgsICIgZXhjZWVkcyBmdW5jdGlvbiBpbmRl eCBzcGFjZSAiLCBtX2luZm8uZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpKTsKIAotICAgICAgICBT aWduYXR1cmVJbmRleCBjYWxsZWVTaWduYXR1cmVJbmRleCA9IG1fZnVuY3Rpb25JbmRleFNwYWNl LmJ1ZmZlci5nZXQoKVtmdW5jdGlvbkluZGV4XS5zaWduYXR1cmVJbmRleDsKKyAgICAgICAgU2ln bmF0dXJlSW5kZXggY2FsbGVlU2lnbmF0dXJlSW5kZXggPSBtX2luZm8uc2lnbmF0dXJlSW5kZXhG cm9tRnVuY3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgpOwogICAgICAgICBjb25zdCBTaWdu YXR1cmUqIGNhbGxlZVNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwg Y2FsbGVlU2lnbmF0dXJlSW5kZXgpOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGNhbGxl ZVNpZ25hdHVyZS0+YXJndW1lbnRDb3VudCgpID4gbV9leHByZXNzaW9uU3RhY2suc2l6ZSgpLCAi Y2FsbCBmdW5jdGlvbiBpbmRleCAiLCBmdW5jdGlvbkluZGV4LCAiIGhhcyAiLCBjYWxsZWVTaWdu YXR1cmUtPmFyZ3VtZW50Q291bnQoKSwgIiBhcmd1bWVudHMsIGJ1dCB0aGUgZXhwcmVzc2lvbiBz dGFjayBjdXJyZW50bHkgaG9sZHMgIiwgbV9leHByZXNzaW9uU3RhY2suc2l6ZSgpLCAiIHZhbHVl cyIpOwogCkBAIC0zMzcsOSArMzM3LDkgQEAgYXV0byBGdW5jdGlvblBhcnNlcjxDb250ZXh0Pjo6 cGFyc2VFeHByZXNzaW9uKE9wVHlwZSBvcCkgLT4gUGFydGlhbFJlc3VsdAogICAgICAgICBXQVNN X1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihzaWduYXR1cmVJbmRleCksICJjYW4ndCBn ZXQgY2FsbF9pbmRpcmVjdCdzIHNpZ25hdHVyZSBpbmRleCIpOwogICAgICAgICBXQVNNX1BBUlNF Ul9GQUlMX0lGKCFwYXJzZVZhclVJbnQxKHJlc2VydmVkKSwgImNhbid0IGdldCBjYWxsX2luZGly ZWN0J3MgcmVzZXJ2ZWQgYnl0ZSIpOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHJlc2Vy dmVkLCAiY2FsbF9pbmRpcmVjdCdzICdyZXNlcnZlZCcgdmFydWludDEgbXVzdCBiZSAweDAiKTsK LSAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihtX2luZm8uc2lnbmF0dXJlSW5kaWNlcy5zaXpl KCkgPD0gc2lnbmF0dXJlSW5kZXgsICJjYWxsX2luZGlyZWN0J3Mgc2lnbmF0dXJlIGluZGV4ICIs IHNpZ25hdHVyZUluZGV4LCAiIGV4Y2VlZHMga25vd24gc2lnbmF0dXJlcyAiLCBtX2luZm8uc2ln bmF0dXJlSW5kaWNlcy5zaXplKCkpOworICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKG1fbW9k dWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMuc2l6ZSgpIDw9IHNp Z25hdHVyZUluZGV4LCAiY2FsbF9pbmRpcmVjdCdzIHNpZ25hdHVyZSBpbmRleCAiLCBzaWduYXR1 cmVJbmRleCwgIiBleGNlZWRzIGtub3duIHNpZ25hdHVyZXMgIiwgbV9tb2R1bGVTaWduYXR1cmVJ bmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXplKCkpOwogCi0gICAgICAgIFNpZ25h dHVyZUluZGV4IGNhbGxlZVNpZ25hdHVyZUluZGV4ID0gbV9pbmZvLnNpZ25hdHVyZUluZGljZXNb c2lnbmF0dXJlSW5kZXhdOworICAgICAgICBTaWduYXR1cmVJbmRleCBjYWxsZWVTaWduYXR1cmVJ bmRleCA9IG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXNb c2lnbmF0dXJlSW5kZXhdOwogICAgICAgICBjb25zdCBTaWduYXR1cmUqIGNhbGxlZVNpZ25hdHVy ZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgY2FsbGVlU2lnbmF0dXJlSW5kZXgp OwogICAgICAgICBzaXplX3QgYXJndW1lbnRDb3VudCA9IGNhbGxlZVNpZ25hdHVyZS0+YXJndW1l bnRDb3VudCgpICsgMTsgLy8gQWRkIHRoZSBjYWxsZWUncyBpbmRleC4KICAgICAgICAgV0FTTV9Q QVJTRVJfRkFJTF9JRihhcmd1bWVudENvdW50ID4gbV9leHByZXNzaW9uU3RhY2suc2l6ZSgpLCAi Y2FsbF9pbmRpcmVjdCBleHBlY3RzICIsIGFyZ3VtZW50Q291bnQsICIgYXJndW1lbnRzLCBidXQg dGhlIGV4cHJlc3Npb24gc3RhY2sgY3VycmVudGx5IGhvbGRzICIsIG1fZXhwcmVzc2lvblN0YWNr LnNpemUoKSwgIiB2YWx1ZXMiKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21NZW1vcnkuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9y eS5jcHAKaW5kZXggNzAwZTNhYy4uYWFkOTFjMSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbU1lbW9yeS5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbU1lbW9yeS5jcHAKQEAgLTI4LDE1ICsyOCwzOSBAQAogCiAjaWYgRU5BQkxFKFdFQkFT U0VNQkxZKQogCisjaW5jbHVkZSA8d3RmL0hleE51bWJlci5oPgorI2luY2x1ZGUgPHd0Zi9Qcmlu dFN0cmVhbS5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgorCiBuYW1lc3BhY2Ug SlNDIHsgbmFtZXNwYWNlIFdhc20gewogCituYW1lc3BhY2UgeworY29uc3QgYm9vbCB2ZXJib3Nl ID0gZmFsc2U7Cit9CisKK3ZvaWQgTWVtb3J5OjpkdW1wKFByaW50U3RyZWFtJiBvdXQpIGNvbnN0 Cit7CisgICAgU3RyaW5nIG1lbW9yeUhleDsKKyAgICBXVEY6OmFwcGVuZFVuc2lnbmVkNjRBc0hl eCgodWludDY0X3QpKHVpbnRwdHJfdCltX21lbW9yeSwgbWVtb3J5SGV4KTsKKyAgICBvdXQucHJp bnQoIk1lbW9yeSBhdCAweCIsIG1lbW9yeUhleCwgIiwgc2l6ZSAiLCBtX3NpemUsICJCIGNhcGFj aXR5ICIsIG1fbWFwcGVkQ2FwYWNpdHksICJCLCBpbml0aWFsICIsIG1faW5pdGlhbCwgIiBtYXhp bXVtICIsIG1fbWF4aW11bSwgIiBtb2RlICIsIG1ha2VTdHJpbmcobV9tb2RlKSk7Cit9CisKK2Nv bnN0IGNoYXIqIE1lbW9yeTo6bWFrZVN0cmluZyhNb2RlIG1vZGUpIGNvbnN0Cit7CisgICAgc3dp dGNoIChtb2RlKSB7CisgICAgY2FzZSBNb2RlOjpCb3VuZHNDaGVja2luZzogcmV0dXJuICJCb3Vu ZHNDaGVja2luZyI7CisgICAgfQorICAgIFJFTEVBU0VfQVNTRVJUX05PVF9SRUFDSEVEKCk7Cisg ICAgcmV0dXJuICIiOworfQorCiBzdGF0aWNfYXNzZXJ0KHNpemVvZih1aW50NjRfdCkgPT0gc2l6 ZW9mKHNpemVfdCksICJXZSByZWx5IG9uIGFsbG93aW5nIHRoZSBtYXhpbXVtIHNpemUgb2YgTWVt b3J5IHdlIG1hcCB0byBiZSAyXjMyIHdoaWNoIGlzIGxhcmdlciB0aGFuIGZpdHMgaW4gYSAzMi1i aXQgaW50ZWdlciB0aGF0IHdlJ2QgcGFzcyB0byBtcHJvdGVjdCBpZiB0aGlzIGRpZG4ndCBob2xk LiIpOwogCiBNZW1vcnk6Ok1lbW9yeShQYWdlQ291bnQgaW5pdGlhbCwgUGFnZUNvdW50IG1heGlt dW0sIGJvb2wmIGZhaWxlZCkKLSAgICA6IG1fbW9kZShNb2RlOjpCb3VuZHNDaGVja2luZykKKyAg ICA6IG1fc2l6ZShpbml0aWFsLmJ5dGVzKCkpCiAgICAgLCBtX2luaXRpYWwoaW5pdGlhbCkKICAg ICAsIG1fbWF4aW11bShtYXhpbXVtKQotICAgICwgbV9zaXplKGluaXRpYWwuYnl0ZXMoKSkKKyAg ICAsIG1fbW9kZShNb2RlOjpCb3VuZHNDaGVja2luZykKICAgICAvLyBGSVhNRTogSWYgd2UgYWRk IHNpZ25hbCBiYXNlZCBib3VuZHMgY2hlY2tpbmcgdGhlbiB3ZSBuZWVkIGV4dHJhIHNwYWNlIGZv ciBvdmVyZmxvdyBvbiBsb2FkLgogICAgIC8vIHNlZTogaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE2MjY5MwogewpAQCAtNDYsOSArNzAsMTEgQEAgTWVtb3J5OjpNZW1v cnkoUGFnZUNvdW50IGluaXRpYWwsIFBhZ2VDb3VudCBtYXhpbXVtLCBib29sJiBmYWlsZWQpCiAg ICAgaWYgKCFtX21hcHBlZENhcGFjaXR5KSB7CiAgICAgICAgIC8vIFRoaXMgbWVhbnMgd2Ugc3Bl Y2lmaWVkIGEgemVybyBhcyBtYXhpbXVtICh3aGljaCBtZWFucyB3ZSBhbHNvIGhhdmUgemVybyBh cyBpbml0aWFsIHNpemUpLgogICAgICAgICBSRUxFQVNFX0FTU0VSVChtX3NpemUgPT0gMCk7Ci0g ICAgICAgIG1fbWFwcGVkQ2FwYWNpdHkgPSAwOwogICAgICAgICBtX21lbW9yeSA9IG51bGxwdHI7 CisgICAgICAgIG1fbWFwcGVkQ2FwYWNpdHkgPSAwOwogICAgICAgICBmYWlsZWQgPSBmYWxzZTsK KyAgICAgICAgaWYgKHZlcmJvc2UpCisgICAgICAgICAgICBkYXRhTG9nTG4oIk1lbW9yeTo6TWVt b3J5IGFsbG9jYXRpbmcgbm90aGluZyAiLCAqdGhpcyk7CiAgICAgICAgIHJldHVybjsKICAgICB9 CiAKQEAgLTU2LDE1ICs4MiwyMSBAQCBNZW1vcnk6Ok1lbW9yeShQYWdlQ291bnQgaW5pdGlhbCwg UGFnZUNvdW50IG1heGltdW0sIGJvb2wmIGZhaWxlZCkKICAgICB2b2lkKiByZXN1bHQgPSBPcHRp b25zOjpzaW11bGF0ZVdlYkFzc2VtYmx5TG93TWVtb3J5KCkgPyBNQVBfRkFJTEVEIDogbW1hcChu dWxscHRyLCBtX21hcHBlZENhcGFjaXR5LCBQUk9UX05PTkUsIE1BUF9QUklWQVRFIHwgTUFQX0FO T04sIC0xLCAwKTsKICAgICBpZiAocmVzdWx0ID09IE1BUF9GQUlMRUQpIHsKICAgICAgICAgLy8g VHJ5IGFnYWluIHdpdGggYSBkaWZmZXJlbnQgbnVtYmVyLgorICAgICAgICBpZiAodmVyYm9zZSkK KyAgICAgICAgICAgIGRhdGFMb2dMbigiTWVtb3J5OjpNZW1vcnkgbW1hcCBmYWlsZWQgb25jZSBm b3IgY2FwYWNpdHksIHRyeWluZyBhZ2FpbiIsICp0aGlzKTsKICAgICAgICAgbV9tYXBwZWRDYXBh Y2l0eSA9IG1fc2l6ZTsKICAgICAgICAgaWYgKCFtX21hcHBlZENhcGFjaXR5KSB7CiAgICAgICAg ICAgICBtX21lbW9yeSA9IG51bGxwdHI7CiAgICAgICAgICAgICBmYWlsZWQgPSBmYWxzZTsKKyAg ICAgICAgICAgIGlmICh2ZXJib3NlKQorICAgICAgICAgICAgICAgIGRhdGFMb2dMbigiTWVtb3J5 OjpNZW1vcnkgbW1hcCBub3QgdHJ5aW5nIGFnYWluIGJlY2F1c2Ugc2l6ZSBpcyB6ZXJvICIsICp0 aGlzKTsKICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgfQogCiAgICAgICAgIHJlc3VsdCA9 IG1tYXAobnVsbHB0ciwgbV9tYXBwZWRDYXBhY2l0eSwgUFJPVF9OT05FLCBNQVBfUFJJVkFURSB8 IE1BUF9BTk9OLCAtMSwgMCk7CiAgICAgICAgIGlmIChyZXN1bHQgPT0gTUFQX0ZBSUxFRCkgewor ICAgICAgICAgICAgaWYgKHZlcmJvc2UpCisgICAgICAgICAgICAgICAgZGF0YUxvZ0xuKCJNZW1v cnk6Ok1lbW9yeSBtbWFwIGZhaWxlZCB0d2ljZSAiLCAqdGhpcyk7CiAgICAgICAgICAgICBmYWls ZWQgPSB0cnVlOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CkBAIC03OCwxMiArMTEw LDI3IEBAIE1lbW9yeTo6TWVtb3J5KFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQgbWF4aW11 bSwgYm9vbCYgZmFpbGVkKQogCiAgICAgbV9tZW1vcnkgPSByZXN1bHQ7CiAgICAgZmFpbGVkID0g ZmFsc2U7CisgICAgaWYgKHZlcmJvc2UpCisgICAgICAgIGRhdGFMb2dMbigiTWVtb3J5OjpNZW1v cnkgbW1hcCBzdWNjZWVkZWQgIiwgKnRoaXMpOworfQorCitNZW1vcnk6On5NZW1vcnkoKQorewor ICAgIGlmICh2ZXJib3NlKQorICAgICAgICBkYXRhTG9nTG4oIk1lbW9yeTo6fk1lbW9yeSAiLCAq dGhpcyk7CisgICAgaWYgKG1fbWVtb3J5KSB7CisgICAgICAgIGlmIChtdW5tYXAobV9tZW1vcnks IG1fbWFwcGVkQ2FwYWNpdHkpKQorICAgICAgICAgICAgQ1JBU0goKTsKKyAgICB9CiB9CiAKIGJv b2wgTWVtb3J5Ojpncm93KFBhZ2VDb3VudCBuZXdTaXplKQogewogICAgIFJFTEVBU0VfQVNTRVJU KG5ld1NpemUgPiBQYWdlQ291bnQ6OmZyb21CeXRlcyhtX3NpemUpKTsKIAorICAgIGlmICh2ZXJi b3NlKQorICAgICAgICBkYXRhTG9nTG4oIk1lbW9yeTo6Z3JvdyB0byAiLCBuZXdTaXplLCAiIGZy b20gIiwgKnRoaXMpOworCiAgICAgaWYgKG1heGltdW0oKSAmJiBuZXdTaXplID4gbWF4aW11bSgp KQogICAgICAgICByZXR1cm4gZmFsc2U7CiAKQEAgLTkzLDYgKzE0MCw4IEBAIGJvb2wgTWVtb3J5 Ojpncm93KFBhZ2VDb3VudCBuZXdTaXplKQogICAgICAgICBib29sIHN1Y2Nlc3MgPSAhbXByb3Rl Y3Qoc3RhdGljX2Nhc3Q8dWludDhfdCo+KG1fbWVtb3J5KSArIG1fc2l6ZSwgc3RhdGljX2Nhc3Q8 c2l6ZV90PihkZXNpcmVkU2l6ZSAtIG1fc2l6ZSksIFBST1RfUkVBRCB8IFBST1RfV1JJVEUpOwog ICAgICAgICBSRUxFQVNFX0FTU0VSVChzdWNjZXNzKTsKICAgICAgICAgbV9zaXplID0gZGVzaXJl ZFNpemU7CisgICAgICAgIGlmICh2ZXJib3NlKQorICAgICAgICAgICAgZGF0YUxvZ0xuKCJNZW1v cnk6Omdyb3cgaW4tcGxhY2UgIiwgKnRoaXMpOwogICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICB9 CiAKQEAgLTExMCw2ICsxNTksOCBAQCBib29sIE1lbW9yeTo6Z3JvdyhQYWdlQ291bnQgbmV3U2l6 ZSkKICAgICBtX21hcHBlZENhcGFjaXR5ID0gZGVzaXJlZFNpemU7CiAgICAgbV9zaXplID0gZGVz aXJlZFNpemU7CiAKKyAgICBpZiAodmVyYm9zZSkKKyAgICAgICAgZGF0YUxvZ0xuKCJNZW1vcnk6 Omdyb3cgIiwgKnRoaXMpOwogICAgIHJldHVybiB0cnVlOwogfQogCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtTWVtb3J5LmgKaW5kZXggNGU1ZWUzNi4uMjM2YmY4NSAxMDA2NDQKLS0tIGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeS5oCisrKyBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnkuaApAQCAtMzAsNyArMzAsOSBAQAogI2luY2x1ZGUg Ildhc21DYWxsaW5nQ29udmVudGlvbi5oIgogI2luY2x1ZGUgIldhc21QYWdlQ291bnQuaCIKIAot I2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KK25hbWVzcGFjZSBXVEYgeworY2xhc3MgUHJpbnRTdHJl YW07Cit9CiAKIG5hbWVzcGFjZSBKU0MgeyBuYW1lc3BhY2UgV2FzbSB7CiAKQEAgLTM4LDQxICs0 MCw1MCBAQCBjbGFzcyBNZW1vcnkgewogICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKE1lbW9yeSk7 CiAgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CiBwdWJsaWM6CisgICAgdm9pZCBkdW1wKFdU Rjo6UHJpbnRTdHJlYW0mKSBjb25zdDsKIAogICAgIC8vIEZJWE1FOiBXZSBzaG91bGQgc3VwcG9y dCBvdGhlciBtb2Rlcy4gc2VlOiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTYyNjkzCiAgICAgZW51bSBjbGFzcyBNb2RlIHsKICAgICAgICAgQm91bmRzQ2hlY2tpbmcK ICAgICB9OworICAgIGNvbnN0IGNoYXIqIG1ha2VTdHJpbmcoTW9kZSkgY29uc3Q7CiAKKyAgICBN ZW1vcnkoKSA9IGRlZmF1bHQ7CiAgICAgSlNfRVhQT1JUX1BSSVZBVEUgTWVtb3J5KFBhZ2VDb3Vu dCBpbml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSwgYm9vbCYgZmFpbGVkKTsKLQotICAgIH5NZW1v cnkoKQorICAgIE1lbW9yeShNZW1vcnkmJiBvdGhlcikKKyAgICAgICAgOiBtX21lbW9yeShvdGhl ci5tX21lbW9yeSkKKyAgICAgICAgLCBtX3NpemUob3RoZXIubV9zaXplKQorICAgICAgICAsIG1f aW5pdGlhbChvdGhlci5tX2luaXRpYWwpCisgICAgICAgICwgbV9tYXhpbXVtKG90aGVyLm1fbWF4 aW11bSkKKyAgICAgICAgLCBtX21hcHBlZENhcGFjaXR5KG90aGVyLm1fbWFwcGVkQ2FwYWNpdHkp CisgICAgICAgICwgbV9tb2RlKG90aGVyLm1fbW9kZSkKICAgICB7Ci0gICAgICAgIGlmIChtX21l bW9yeSkKLSAgICAgICAgICAgIG11bm1hcChtX21lbW9yeSwgbV9tYXBwZWRDYXBhY2l0eSk7Cisg ICAgICAgIC8vIE1vdmluZyB0cmFuc2ZlcnMgb3duZXJzaGlwIG9mIHRoZSBhbGxvY2F0ZWQgbWVt b3J5LgorICAgICAgICBvdGhlci5tX21lbW9yeSA9IG51bGxwdHI7CiAgICAgfQorICAgIH5NZW1v cnkoKTsKIAogICAgIHZvaWQqIG1lbW9yeSgpIGNvbnN0IHsgcmV0dXJuIG1fbWVtb3J5OyB9CiAg ICAgdWludDY0X3Qgc2l6ZSgpIGNvbnN0IHsgcmV0dXJuIG1fc2l6ZTsgfQogICAgIFBhZ2VDb3Vu dCBzaXplSW5QYWdlcygpIGNvbnN0IHsgcmV0dXJuIFBhZ2VDb3VudDo6ZnJvbUJ5dGVzKG1fc2l6 ZSk7IH0KIAotICAgIE1vZGUgbW9kZSgpIGNvbnN0IHsgcmV0dXJuIG1fbW9kZTsgfQotCiAgICAg UGFnZUNvdW50IGluaXRpYWwoKSBjb25zdCB7IHJldHVybiBtX2luaXRpYWw7IH0KICAgICBQYWdl Q291bnQgbWF4aW11bSgpIGNvbnN0IHsgcmV0dXJuIG1fbWF4aW11bTsgfQogCisgICAgTW9kZSBt b2RlKCkgY29uc3QgeyByZXR1cm4gbV9tb2RlOyB9CisKICAgICBib29sIGdyb3coUGFnZUNvdW50 KTsKIAotICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZTaXplKCkgeyByZXR1cm4gT0JKRUNU X09GRlNFVE9GKE1lbW9yeSwgbV9zaXplKTsgfQogICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0 T2ZNZW1vcnkoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoTWVtb3J5LCBtX21lbW9yeSk7IH0K KyAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mU2l6ZSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZT RVRPRihNZW1vcnksIG1fc2l6ZSk7IH0KICAgICAKIHByaXZhdGU6CiAgICAgdm9pZCogbV9tZW1v cnkgeyBudWxscHRyIH07Ci0gICAgTW9kZSBtX21vZGU7CisgICAgdWludDY0X3QgbV9zaXplIHsg MCB9OwogICAgIFBhZ2VDb3VudCBtX2luaXRpYWw7CiAgICAgUGFnZUNvdW50IG1fbWF4aW11bTsK LSAgICB1aW50NjRfdCBtX3NpemUgeyAwIH07CiAgICAgdWludDY0X3QgbV9tYXBwZWRDYXBhY2l0 eSB7IDAgfTsKKyAgICBNb2RlIG1fbW9kZSB7IE1vZGU6OkJvdW5kc0NoZWNraW5nIH07CiB9Owog CiB9IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2FzbQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21NZW1vcnlJbmZvcm1hdGlvbi5jcHAKaW5kZXggMmUxZDMwYS4uNmIwNjNk MyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9y bWF0aW9uLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTWVtb3J5SW5m b3JtYXRpb24uY3BwCkBAIC0yNiwxMyArMjYsNTIgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNp bmNsdWRlICJXYXNtTWVtb3J5SW5mb3JtYXRpb24uaCIKIAotI2luY2x1ZGUgIldhc21DYWxsaW5n Q29udmVudGlvbi5oIgotCiAjaWYgRU5BQkxFKFdFQkFTU0VNQkxZKQogCisjaW5jbHVkZSAiV2Fz bUNhbGxpbmdDb252ZW50aW9uLmgiCisjaW5jbHVkZSA8d3RmL05ldmVyRGVzdHJveWVkLmg+CisK IG5hbWVzcGFjZSBKU0MgeyBuYW1lc3BhY2UgV2FzbSB7CiAKLU1lbW9yeUluZm9ybWF0aW9uOjpN ZW1vcnlJbmZvcm1hdGlvbihQYWdlQ291bnQgaW5pdGlhbCwgUGFnZUNvdW50IG1heGltdW0sICBj b25zdCBWZWN0b3I8dW5zaWduZWQ+JiBwaW5uZWRTaXplUmVnaXN0ZXJzLCBib29sIGlzSW1wb3J0 KQorY29uc3QgUGlubmVkUmVnaXN0ZXJJbmZvJiBQaW5uZWRSZWdpc3RlckluZm86OmdldCgpCit7 CisgICAgc3RhdGljIExhenlOZXZlckRlc3Ryb3llZDxQaW5uZWRSZWdpc3RlckluZm8+IHN0YXRp Y1Bpbm5lZFJlZ2lzdGVySW5mbzsKKyAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgc3RhdGljUGlu bmVkUmVnaXN0ZXJJbmZvRmxhZzsKKyAgICBzdGQ6OmNhbGxfb25jZShzdGF0aWNQaW5uZWRSZWdp c3RlckluZm9GbGFnLCBbXSAoKSB7CisgICAgICAgIFZlY3RvcjxQaW5uZWRTaXplUmVnaXN0ZXJJ bmZvPiBzaXplUmVnaXN0ZXJzOworICAgICAgICBHUFJSZWcgYmFzZU1lbW9yeVBvaW50ZXI7CisK KyAgICAgICAgLy8gRklYTUU6IFdlIHNob3VsZCBzdXBwb3J0IG1vcmUgdGhhbiBvbmUgbWVtb3J5 IHNpemUgcmVnaXN0ZXIsIGFuZCB3ZSBzaG91bGQgYWxsb3cgZGlmZmVyZW50CisgICAgICAgIC8v ICAgICAgICBXZWJBc3NlbWJseS5JbnN0YW5jZSB0byBoYXZlIGRpZmZlcmVudCBwaW5zLiBSaWdo dCBub3cgd2UgdGFrZSBhIHZlY3RvciB3aXRoIG9ubHkgb25lIGVudHJ5LgorICAgICAgICAvLyAg ICAgICAgSWYgd2UgaGF2ZSBtb3JlIHRoYW4gb25lIHNpemUgcmVnaXN0ZXIsIHdlIGNhbiBoYXZl IG9uZSBmb3IgZWFjaCBsb2FkIHNpemUgY2xhc3MuCisgICAgICAgIC8vICAgICAgICBzZWU6IGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjI5NTIKKyAgICAgICAgVmVj dG9yPHVuc2lnbmVkPiBwaW5uZWRTaXplcyA9IHsgMCB9OworICAgICAgICB1bnNpZ25lZCByZW1h aW5pbmdQaW5uZWRSZWdpc3RlcnMgPSBwaW5uZWRTaXplcy5zaXplKCkgKyAxOworICAgICAgICBq c2NDYWxsaW5nQ29udmVudGlvbigpLm1fY2FsbGVlU2F2ZVJlZ2lzdGVycy5mb3JFYWNoKFsmXSAo UmVnIHJlZykgeworICAgICAgICAgICAgR1BSUmVnIGdwciA9IHJlZy5ncHIoKTsKKyAgICAgICAg ICAgIGlmICghcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzIHx8IFJlZ2lzdGVyU2V0OjpzdGFja1Jl Z2lzdGVycygpLmdldChyZWcpKQorICAgICAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgICAg IGlmIChyZW1haW5pbmdQaW5uZWRSZWdpc3RlcnMgPT0gMSkgeworICAgICAgICAgICAgICAgIGJh c2VNZW1vcnlQb2ludGVyID0gZ3ByOworICAgICAgICAgICAgICAgIHJlbWFpbmluZ1Bpbm5lZFJl Z2lzdGVycy0tOworICAgICAgICAgICAgfSBlbHNlCisgICAgICAgICAgICAgICAgc2l6ZVJlZ2lz dGVycy5hcHBlbmQoeyBncHIsIHBpbm5lZFNpemVzWy0tcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJz IC0gMV0gfSk7CisgICAgICAgIH0pOworCisgICAgICAgIEFTU0VSVCghcmVtYWluaW5nUGlubmVk UmVnaXN0ZXJzKTsKKyAgICAgICAgc3RhdGljUGlubmVkUmVnaXN0ZXJJbmZvLmNvbnN0cnVjdChX VEZNb3ZlKHNpemVSZWdpc3RlcnMpLCBiYXNlTWVtb3J5UG9pbnRlcik7CisgICAgfSk7CisKKyAg ICByZXR1cm4gc3RhdGljUGlubmVkUmVnaXN0ZXJJbmZvLmdldCgpOworfQorCitQaW5uZWRSZWdp c3RlckluZm86OlBpbm5lZFJlZ2lzdGVySW5mbyhWZWN0b3I8UGlubmVkU2l6ZVJlZ2lzdGVySW5m bz4mJiBzaXplUmVnaXN0ZXJzLCBHUFJSZWcgYmFzZU1lbW9yeVBvaW50ZXIpCisgICAgOiBzaXpl UmVnaXN0ZXJzKFdURk1vdmUoc2l6ZVJlZ2lzdGVycykpCisgICAgLCBiYXNlTWVtb3J5UG9pbnRl cihiYXNlTWVtb3J5UG9pbnRlcikKK3sKK30KKworTWVtb3J5SW5mb3JtYXRpb246Ok1lbW9yeUlu Zm9ybWF0aW9uKFBhZ2VDb3VudCBpbml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSwgIGJvb2wgaXNJ bXBvcnQpCiAgICAgOiBtX2luaXRpYWwoaW5pdGlhbCkKICAgICAsIG1fbWF4aW11bShtYXhpbXVt KQogICAgICwgbV9pc0ltcG9ydChpc0ltcG9ydCkKQEAgLTQwLDIwICs3OSw2IEBAIE1lbW9yeUlu Zm9ybWF0aW9uOjpNZW1vcnlJbmZvcm1hdGlvbihQYWdlQ291bnQgaW5pdGlhbCwgUGFnZUNvdW50 IG1heGltdW0sICBjb25zCiAgICAgUkVMRUFTRV9BU1NFUlQoISFtX2luaXRpYWwpOwogICAgIFJF TEVBU0VfQVNTRVJUKCFtX21heGltdW0gfHwgbV9tYXhpbXVtID49IG1faW5pdGlhbCk7CiAgICAg QVNTRVJUKCEhKnRoaXMpOwotCi0gICAgdW5zaWduZWQgcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJz ID0gcGlubmVkU2l6ZVJlZ2lzdGVycy5zaXplKCkgKyAxOwotICAgIGpzY0NhbGxpbmdDb252ZW50 aW9uKCkubV9jYWxsZWVTYXZlUmVnaXN0ZXJzLmZvckVhY2goWyZdIChSZWcgcmVnKSB7Ci0gICAg ICAgIEdQUlJlZyBncHIgPSByZWcuZ3ByKCk7Ci0gICAgICAgIGlmICghcmVtYWluaW5nUGlubmVk UmVnaXN0ZXJzIHx8IFJlZ2lzdGVyU2V0OjpzdGFja1JlZ2lzdGVycygpLmdldChyZWcpKQotICAg ICAgICAgICAgcmV0dXJuOwotICAgICAgICBpZiAocmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzID09 IDEpIHsKLSAgICAgICAgICAgIG1fcGlubmVkUmVnaXN0ZXJzLmJhc2VNZW1vcnlQb2ludGVyID0g Z3ByOwotICAgICAgICAgICAgcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzLS07Ci0gICAgICAgIH0g ZWxzZQotICAgICAgICAgICAgbV9waW5uZWRSZWdpc3RlcnMuc2l6ZVJlZ2lzdGVycy5hcHBlbmQo eyBncHIsIHBpbm5lZFNpemVSZWdpc3RlcnNbLS1yZW1haW5pbmdQaW5uZWRSZWdpc3RlcnMgLSAx XSB9KTsKLSAgICB9KTsKLQotICAgIEFTU0VSVCghcmVtYWluaW5nUGlubmVkUmVnaXN0ZXJzKTsK IH0KIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21NZW1vcnlJbmZvcm1hdGlvbi5oIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9ybWF0aW9uLmgKaW5kZXggZWU2M2Q5ZS4uNmU3ZjUy MSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9y bWF0aW9uLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1lbW9yeUluZm9y bWF0aW9uLmgKQEAgLTM4LDEyICszOCwxMSBAQCBzdHJ1Y3QgUGlubmVkU2l6ZVJlZ2lzdGVySW5m byB7CiAgICAgdW5zaWduZWQgc2l6ZU9mZnNldDsKIH07CiAKLS8vIEZJWE1FOiBXZSBzaG91bGQg c3VwcG9ydCBtb3JlIHRoYW4gb25lIG1lbW9yeSBzaXplIHJlZ2lzdGVyLiBSaWdodCBub3cgd2Ug dGFrZSBhIHZlY3RvciB3aXRoIG9ubHkgb25lCi0vLyBlbnRyeS4gU3BlY2lmaWNhbGx5IGFuIGVu dHJ5IHdoZXJlIHRoZSBzaXplT2Zmc2V0ID09IDAuIElmIHdlIGhhdmUgbW9yZSB0aGFuIG9uZSBz aXplIHJlZ2lzdGVyLAotLy8gd2UgY2FuIGhhdmUgb25lIGZvciBlYWNoIGxvYWQgc2l6ZSBjbGFz cy4gc2VlOiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYyOTUyCiBz dHJ1Y3QgUGlubmVkUmVnaXN0ZXJJbmZvIHsKICAgICBWZWN0b3I8UGlubmVkU2l6ZVJlZ2lzdGVy SW5mbz4gc2l6ZVJlZ2lzdGVyczsKICAgICBHUFJSZWcgYmFzZU1lbW9yeVBvaW50ZXI7CisgICAg c3RhdGljIGNvbnN0IFBpbm5lZFJlZ2lzdGVySW5mbyYgZ2V0KCk7CisgICAgUGlubmVkUmVnaXN0 ZXJJbmZvKFZlY3RvcjxQaW5uZWRTaXplUmVnaXN0ZXJJbmZvPiYmLCBHUFJSZWcpOwogfTsKIAog Y2xhc3MgTWVtb3J5SW5mb3JtYXRpb24gewpAQCAtNTMsOSArNTIsOCBAQCBwdWJsaWM6CiAgICAg ICAgIEFTU0VSVCghKnRoaXMpOwogICAgIH0KIAotICAgIE1lbW9yeUluZm9ybWF0aW9uKFBhZ2VD b3VudCBpbml0aWFsLCBQYWdlQ291bnQgbWF4aW11bSwgY29uc3QgVmVjdG9yPHVuc2lnbmVkPiYg cGlubmVkU2l6ZVJlZ2lzdGVycywgYm9vbCBpc0ltcG9ydCk7CisgICAgTWVtb3J5SW5mb3JtYXRp b24oUGFnZUNvdW50IGluaXRpYWwsIFBhZ2VDb3VudCBtYXhpbXVtLCBib29sIGlzSW1wb3J0KTsK IAotICAgIGNvbnN0IFBpbm5lZFJlZ2lzdGVySW5mbyYgcGlubmVkUmVnaXN0ZXJzKCkgY29uc3Qg eyByZXR1cm4gbV9waW5uZWRSZWdpc3RlcnM7IH0KICAgICBQYWdlQ291bnQgaW5pdGlhbCgpIGNv bnN0IHsgcmV0dXJuIG1faW5pdGlhbDsgfQogICAgIFBhZ2VDb3VudCBtYXhpbXVtKCkgY29uc3Qg eyByZXR1cm4gbV9tYXhpbXVtOyB9CiAgICAgYm9vbCBpc0ltcG9ydCgpIGNvbnN0IHsgcmV0dXJu IG1faXNJbXBvcnQ7IH0KQEAgLTY1LDcgKzYzLDYgQEAgcHVibGljOgogcHJpdmF0ZToKICAgICBQ YWdlQ291bnQgbV9pbml0aWFsIHsgfTsKICAgICBQYWdlQ291bnQgbV9tYXhpbXVtIHsgfTsKLSAg ICBQaW5uZWRSZWdpc3RlckluZm8gbV9waW5uZWRSZWdpc3RlcnMgeyB9OwogICAgIGJvb2wgbV9p c0ltcG9ydCB7IGZhbHNlIH07CiB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21Nb2R1bGVQYXJzZXIuY3BwCmluZGV4IDYyNjFlN2YuLjMwMTFjODkgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCisrKyBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCkBAIC0xMDcsNyAr MTA3LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlVHlwZSgpIC0+IFBhcnRpYWxSZXN1bHQK IAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKGNvdW50KSwgImNhbid0 IGdldCBUeXBlIHNlY3Rpb24ncyBjb3VudCIpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoY291 bnQgPT0gc3RkOjpudW1lcmljX2xpbWl0czx1aW50MzJfdD46Om1heCgpLCAiVHlwZSBzZWN0aW9u J3MgY291bnQgaXMgdG9vIGJpZyAiLCBjb3VudCk7Ci0gICAgV0FTTV9QQVJTRVJfRkFJTF9JRigh bV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnRyeVJlc2VydmVDYXBhY2l0eShjb3Vu dCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciBUeXBlIHNlY3Rpb24ncyAiLCBj b3VudCwgIiBlbnRyaWVzIik7CisgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9k dWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25hdHVyZUluZGljZXMudHJ5UmVzZXJ2ZUNh cGFjaXR5KGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yIFR5cGUgc2Vj dGlvbidzICIsIGNvdW50LCAiIGVudHJpZXMiKTsKIAogICAgIGZvciAodWludDMyX3QgaSA9IDA7 IGkgPCBjb3VudDsgKytpKSB7CiAgICAgICAgIGludDhfdCB0eXBlOwpAQCAtMTM5LDcgKzEzOSw3 IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZVR5cGUoKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAg ICAgIHNpZ25hdHVyZS0+cmV0dXJuVHlwZSgpID0gcmV0dXJuVHlwZTsKIAogICAgICAgICBTaWdu YXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjphZG9wdCht X3ZtLCBzaWduYXR1cmUucmVsZWFzZSgpKTsKLSAgICAgICAgbV9yZXN1bHQubW9kdWxlLT5zaWdu YXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7CisgICAgICAgIG1f cmVzdWx0Lm1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzLnVu Y2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7CiAgICAgfQogICAgIHJldHVybiB7IH07CiB9 CkBAIC0xNTIsNyArMTUyLDYgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlSW1wb3J0KCkgLT4g UGFydGlhbFJlc3VsdAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0Lm1vZHVsZS0+ Z2xvYmFscy50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2NhdGUg ZW5vdWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIgZ2xvYmFscyIpOyAvLyBGSVhNRSB0 aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBGSVhNRXMgYmVsb3cuCiAgICAgV0FT TV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQubW9kdWxlLT5pbXBvcnRzLnRyeVJlc2VydmVDYXBh Y2l0eShpbXBvcnRDb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBp bXBvcnRDb3VudCwgIiBpbXBvcnRzIik7IC8vIEZJWE1FIHRoaXMgb3Zlci1hbGxvY2F0ZXMgd2hl biB3ZSBmaXggdGhlIEZJWE1FcyBiZWxvdy4KICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX3Jl c3VsdC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy50cnlSZXNlcnZlQ2Fw YWNpdHkoaW1wb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwg aW1wb3J0Q291bnQsICIgaW1wb3J0IGZ1bmN0aW9uIHNpZ25hdHVyZXMiKTsgLy8gRklYTUUgdGhp cyBvdmVyLWFsbG9jYXRlcyB3aGVuIHdlIGZpeCB0aGUgRklYTUVzIGJlbG93LgotICAgIFdBU01f UEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS50cnlSZXNlcnZlQ2Fw YWNpdHkoaW1wb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwg aW1wb3J0Q291bnQsICIgZnVuY3Rpb25zIGluIHRoZSBpbmRleCBzcGFjZSIpOyAvLyBGSVhNRSB0 aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBGSVhNRXMgYmVsb3cuIFdlJ2xsIGFs bG9jYXRlIHNvbWUgbW9yZSBoZXJlIHdoZW4gd2Uga25vdyBob3cgbWFueSBmdW5jdGlvbnMgdG8g ZXhwZWN0LgogCiAgICAgZm9yICh1aW50MzJfdCBpbXBvcnROdW1iZXIgPSAwOyBpbXBvcnROdW1i ZXIgPCBpbXBvcnRDb3VudDsgKytpbXBvcnROdW1iZXIpIHsKICAgICAgICAgSW1wb3J0IGltcDsK QEAgLTE3NCwxMSArMTczLDEwIEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZUltcG9ydCgpIC0+ IFBhcnRpYWxSZXN1bHQKICAgICAgICAgY2FzZSBFeHRlcm5hbEtpbmQ6OkZ1bmN0aW9uOiB7CiAg ICAgICAgICAgICB1aW50MzJfdCBmdW5jdGlvblNpZ25hdHVyZUluZGV4OwogICAgICAgICAgICAg V0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoZnVuY3Rpb25TaWduYXR1cmVJbmRl eCksICJjYW4ndCBnZXQgIiwgaW1wb3J0TnVtYmVyLCAidGggSW1wb3J0J3MgZnVuY3Rpb24gc2ln bmF0dXJlIGluIG1vZHVsZSAnIiwgbW9kdWxlU3RyaW5nLCAiJyBmaWVsZCAnIiwgZmllbGRTdHJp bmcsICInIik7Ci0gICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGZ1bmN0aW9uU2lnbmF0 dXJlSW5kZXggPj0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzLnNpemUoKSwgImlu dmFsaWQgZnVuY3Rpb24gc2lnbmF0dXJlIGZvciAiLCBpbXBvcnROdW1iZXIsICJ0aCBJbXBvcnQs ICIsIGZ1bmN0aW9uU2lnbmF0dXJlSW5kZXgsICIgaXMgb3V0IG9mIHJhbmdlIG9mICIsIG1fcmVz dWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICIgaW4gbW9kdWxlICciLCBtb2R1 bGVTdHJpbmcsICInIGZpZWxkICciLCBmaWVsZFN0cmluZywgIiciKTsKKyAgICAgICAgICAgIFdB U01fUEFSU0VSX0ZBSUxfSUYoZnVuY3Rpb25TaWduYXR1cmVJbmRleCA+PSBtX3Jlc3VsdC5tb2R1 bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXplKCksICJpbnZh bGlkIGZ1bmN0aW9uIHNpZ25hdHVyZSBmb3IgIiwgaW1wb3J0TnVtYmVyLCAidGggSW1wb3J0LCAi LCBmdW5jdGlvblNpZ25hdHVyZUluZGV4LCAiIGlzIG91dCBvZiByYW5nZSBvZiAiLCBtX3Jlc3Vs dC5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5zaXplKCks ICIgaW4gbW9kdWxlICciLCBtb2R1bGVTdHJpbmcsICInIGZpZWxkICciLCBmaWVsZFN0cmluZywg IiciKTsKICAgICAgICAgICAgIGltcC5raW5kSW5kZXggPSBtX3Jlc3VsdC5tb2R1bGUtPmltcG9y dEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy5zaXplKCk7Ci0gICAgICAgICAgICBTaWduYXR1cmVJ bmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZS0+c2lnbmF0dXJlSW5kaWNlc1tm dW5jdGlvblNpZ25hdHVyZUluZGV4XTsKKyAgICAgICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25h dHVyZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNpZ25h dHVyZUluZGljZXNbZnVuY3Rpb25TaWduYXR1cmVJbmRleF07CiAgICAgICAgICAgICBtX3Jlc3Vs dC5tb2R1bGUtPmltcG9ydEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy51bmNoZWNrZWRBcHBlbmQo c2lnbmF0dXJlSW5kZXgpOwotICAgICAgICAgICAgbV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNl LnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRleCk7CiAgICAgICAgICAgICBicmVhazsKICAg ICAgICAgfQogICAgICAgICBjYXNlIEV4dGVybmFsS2luZDo6VGFibGU6IHsKQEAgLTIyMCwyMCAr MjE4LDE4IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZUZ1bmN0aW9uKCkgLT4gUGFydGlhbFJl c3VsdAogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoY291bnQgPT0gc3RkOjpudW1lcmljX2xpbWl0 czx1aW50MzJfdD46Om1heCgpLCAiRnVuY3Rpb24gc2VjdGlvbidzIGNvdW50IGlzIHRvbyBiaWcg IiwgY291bnQpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1fcmVzdWx0Lm1vZHVsZS0+aW50 ZXJuYWxGdW5jdGlvblNpZ25hdHVyZUluZGljZXMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50KSwg ImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGNvdW50LCAiIEZ1bmN0aW9uIHNp Z25hdHVyZXMiKTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX3Jlc3VsdC5mdW5jdGlvbkxv Y2F0aW9uSW5CaW5hcnkudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50KSwgImNhbid0IGFsbG9jYXRl IGVub3VnaCBtZW1vcnkgZm9yICIsIGNvdW50LCAiRnVuY3Rpb24gbG9jYXRpb25zIik7Ci0gICAg V0FTTV9QQVJTRVJfRkFJTF9JRighbV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnRyeVJlc2Vy dmVDYXBhY2l0eShtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpICsgY291bnQpLCAi Y2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgY291bnQsICIgbW9yZSBmdW5jdGlv bnMgaW4gdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlIik7CiAKICAgICBmb3IgKHVpbnQzMl90IGkg PSAwOyBpIDwgY291bnQ7ICsraSkgewogICAgICAgICB1aW50MzJfdCB0eXBlTnVtYmVyOwogICAg ICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMih0eXBlTnVtYmVyKSwgImNh bid0IGdldCAiLCBpLCAidGggRnVuY3Rpb24ncyB0eXBlIG51bWJlciIpOwotICAgICAgICBXQVNN X1BBUlNFUl9GQUlMX0lGKHR5cGVOdW1iZXIgPj0gbV9yZXN1bHQubW9kdWxlLT5zaWduYXR1cmVJ bmRpY2VzLnNpemUoKSwgaSwgInRoIEZ1bmN0aW9uIHR5cGUgbnVtYmVyIGlzIGludmFsaWQgIiwg dHlwZU51bWJlcik7CisgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYodHlwZU51bWJlciA+PSBt X3Jlc3VsdC5tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcy5z aXplKCksIGksICJ0aCBGdW5jdGlvbiB0eXBlIG51bWJlciBpcyBpbnZhbGlkICIsIHR5cGVOdW1i ZXIpOwogCi0gICAgICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9yZXN1bHQu bW9kdWxlLT5zaWduYXR1cmVJbmRpY2VzW3R5cGVOdW1iZXJdOworICAgICAgICBTaWduYXR1cmVJ bmRleCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0Lm1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1Vu aXF1ZWRTaWduYXR1cmVJbmRpY2VzW3R5cGVOdW1iZXJdOwogICAgICAgICAvLyBUaGUgQ29kZSBz ZWN0aW9uIGZpeGVzIHVwIHN0YXJ0IGFuZCBlbmQuCiAgICAgICAgIHNpemVfdCBzdGFydCA9IDA7 CiAgICAgICAgIHNpemVfdCBlbmQgPSAwOwogICAgICAgICBtX3Jlc3VsdC5tb2R1bGUtPmludGVy bmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChzaWduYXR1cmVJbmRl eCk7CiAgICAgICAgIG1fcmVzdWx0LmZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeS51bmNoZWNrZWRB cHBlbmQoeyBzdGFydCwgZW5kIH0pOwotICAgICAgICBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3Bh Y2UudW5jaGVja2VkQXBwZW5kKHNpZ25hdHVyZUluZGV4KTsKICAgICB9CiAKICAgICByZXR1cm4g eyB9OwpAQCAtMzIwLDggKzMxNiw3IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZU1lbW9yeUhl bHBlcihib29sIGlzSW1wb3J0KSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgQVNTRVJUKGluaXRpYWxQ YWdlQ291bnQpOwogICAgIEFTU0VSVCghbWF4aW11bVBhZ2VDb3VudCB8fCBtYXhpbXVtUGFnZUNv dW50ID49IGluaXRpYWxQYWdlQ291bnQpOwogCi0gICAgVmVjdG9yPHVuc2lnbmVkPiBwaW5uZWRT aXplcyA9IHsgMCB9OwotICAgIG1fcmVzdWx0Lm1vZHVsZS0+bWVtb3J5ID0gTWVtb3J5SW5mb3Jt YXRpb24oaW5pdGlhbFBhZ2VDb3VudCwgbWF4aW11bVBhZ2VDb3VudCwgcGlubmVkU2l6ZXMsIGlz SW1wb3J0KTsKKyAgICBtX3Jlc3VsdC5tb2R1bGUtPm1lbW9yeSA9IE1lbW9yeUluZm9ybWF0aW9u KGluaXRpYWxQYWdlQ291bnQsIG1heGltdW1QYWdlQ291bnQsIGlzSW1wb3J0KTsKICAgICByZXR1 cm4geyB9OwogfQogCkBAIC0zODcsNyArMzgyLDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNl RXhwb3J0KCkgLT4gUGFydGlhbFJlc3VsdAogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFw YXJzZVZhclVJbnQzMihleHAua2luZEluZGV4KSwgImNhbid0IGdldCAiLCBleHBvcnROdW1iZXIs ICJ0aCBFeHBvcnQncyBraW5kIGluZGV4LCBuYW1lZCAnIiwgZmllbGRTdHJpbmcsICInIik7CiAg ICAgICAgIHN3aXRjaCAoZXhwLmtpbmQpIHsKICAgICAgICAgY2FzZSBFeHRlcm5hbEtpbmQ6OkZ1 bmN0aW9uOiB7Ci0gICAgICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGV4cC5raW5kSW5kZXgg Pj0gbV9yZXN1bHQuZnVuY3Rpb25JbmRleFNwYWNlLnNpemUoKSwgZXhwb3J0TnVtYmVyLCAidGgg RXhwb3J0IGhhcyBpbnZhbGlkIGZ1bmN0aW9uIG51bWJlciAiLCBleHAua2luZEluZGV4LCAiIGl0 IGV4Y2VlZHMgdGhlIGZ1bmN0aW9uIGluZGV4IHNwYWNlICIsIG1fcmVzdWx0LmZ1bmN0aW9uSW5k ZXhTcGFjZS5zaXplKCksICIsIG5hbWVkICciLCBmaWVsZFN0cmluZywgIiciKTsKKyAgICAgICAg ICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZXhwLmtpbmRJbmRleCA+PSBtX3Jlc3VsdC5tb2R1bGUt PmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSwgZXhwb3J0TnVtYmVyLCAidGggRXhwb3J0IGhhcyBp bnZhbGlkIGZ1bmN0aW9uIG51bWJlciAiLCBleHAua2luZEluZGV4LCAiIGl0IGV4Y2VlZHMgdGhl IGZ1bmN0aW9uIGluZGV4IHNwYWNlICIsIG1fcmVzdWx0Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNw YWNlU2l6ZSgpLCAiLCBuYW1lZCAnIiwgZmllbGRTdHJpbmcsICInIik7CiAgICAgICAgICAgICBi cmVhazsKICAgICAgICAgfQogICAgICAgICBjYXNlIEV4dGVybmFsS2luZDo6VGFibGU6IHsKQEAg LTQxNyw4ICs0MTIsOCBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VTdGFydCgpIC0+IFBhcnRp YWxSZXN1bHQKIHsKICAgICB1aW50MzJfdCBzdGFydEZ1bmN0aW9uSW5kZXg7CiAgICAgV0FTTV9Q QVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoc3RhcnRGdW5jdGlvbkluZGV4KSwgImNhbid0 IGdldCBTdGFydCBpbmRleCIpOwotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc3RhcnRGdW5jdGlv bkluZGV4ID49IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCksICJTdGFydCBpbmRl eCAiLCBzdGFydEZ1bmN0aW9uSW5kZXgsICIgZXhjZWVkcyBmdW5jdGlvbiBpbmRleCBzcGFjZSAi LCBtX3Jlc3VsdC5mdW5jdGlvbkluZGV4U3BhY2Uuc2l6ZSgpKTsKLSAgICBTaWduYXR1cmVJbmRl eCBzaWduYXR1cmVJbmRleCA9IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZVtzdGFydEZ1bmN0 aW9uSW5kZXhdLnNpZ25hdHVyZUluZGV4OworICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc3RhcnRG dW5jdGlvbkluZGV4ID49IG1fcmVzdWx0Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgp LCAiU3RhcnQgaW5kZXggIiwgc3RhcnRGdW5jdGlvbkluZGV4LCAiIGV4Y2VlZHMgZnVuY3Rpb24g aW5kZXggc3BhY2UgIiwgbV9yZXN1bHQubW9kdWxlLT5mdW5jdGlvbkluZGV4U3BhY2VTaXplKCkp OworICAgIFNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbV9yZXN1bHQubW9kdWxlLT5z aWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2Uoc3RhcnRGdW5jdGlvbkluZGV4KTsK ICAgICBjb25zdCBTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpn ZXQobV92bSwgc2lnbmF0dXJlSW5kZXgpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc2lnbmF0 dXJlLT5hcmd1bWVudENvdW50KCksICJTdGFydCBmdW5jdGlvbiBjYW4ndCBoYXZlIGFyZ3VtZW50 cyIpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc2lnbmF0dXJlLT5yZXR1cm5UeXBlKCkgIT0g Vm9pZCwgIlN0YXJ0IGZ1bmN0aW9uIGNhbid0IHJldHVybiBhIHZhbHVlIik7CkBAIC00NjksNyAr NDY0LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlRWxlbWVudCgpIC0+IFBhcnRpYWxSZXN1 bHQKICAgICAgICAgZm9yICh1bnNpZ25lZCBpbmRleCA9IDA7IGluZGV4IDwgaW5kZXhDb3VudDsg KytpbmRleCkgewogICAgICAgICAgICAgdWludDMyX3QgZnVuY3Rpb25JbmRleDsKICAgICAgICAg ICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKGZ1bmN0aW9uSW5kZXgpLCAi Y2FuJ3QgZ2V0IEVsZW1lbnQgc2VjdGlvbidzICIsIGVsZW1lbnROdW0sICJ0aCBlbGVtZW50J3Mg IiwgaW5kZXgsICJ0aCBpbmRleCIpOwotICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihm dW5jdGlvbkluZGV4ID49IG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCksICJFbGVt ZW50IHNlY3Rpb24ncyAiLCBlbGVtZW50TnVtLCAidGggZWxlbWVudCdzICIsIGluZGV4LCAidGgg aW5kZXggaXMgIiwgZnVuY3Rpb25JbmRleCwgIiB3aGljaCBleGNlZWRzIHRoZSBmdW5jdGlvbiBp bmRleCBzcGFjZSBzaXplIG9mICIsIG1fcmVzdWx0LmZ1bmN0aW9uSW5kZXhTcGFjZS5zaXplKCkp OworICAgICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvbkluZGV4ID49IG1fcmVz dWx0Lm1vZHVsZS0+ZnVuY3Rpb25JbmRleFNwYWNlU2l6ZSgpLCAiRWxlbWVudCBzZWN0aW9uJ3Mg IiwgZWxlbWVudE51bSwgInRoIGVsZW1lbnQncyAiLCBpbmRleCwgInRoIGluZGV4IGlzICIsIGZ1 bmN0aW9uSW5kZXgsICIgd2hpY2ggZXhjZWVkcyB0aGUgZnVuY3Rpb24gaW5kZXggc3BhY2Ugc2l6 ZSBvZiAiLCBtX3Jlc3VsdC5tb2R1bGUtPmZ1bmN0aW9uSW5kZXhTcGFjZVNpemUoKSk7CiAKICAg ICAgICAgICAgIGVsZW1lbnQuZnVuY3Rpb25JbmRpY2VzLnVuY2hlY2tlZEFwcGVuZChmdW5jdGlv bkluZGV4KTsKICAgICAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbU1vZHVsZVBhcnNlci5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbU1v ZHVsZVBhcnNlci5oCmluZGV4IGUzYjc1YTcuLjdlMDI2YzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuaAorKysgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmgKQEAgLTM2LDggKzM2LDggQEAgbmFtZXNw YWNlIEpTQyB7IG5hbWVzcGFjZSBXYXNtIHsKIAogc3RydWN0IE1vZHVsZVBhcnNlclJlc3VsdCB7 CiAgICAgc3RkOjp1bmlxdWVfcHRyPE1vZHVsZUluZm9ybWF0aW9uPiBtb2R1bGU7Ci0gICAgRnVu Y3Rpb25JbmRleFNwYWNlIGZ1bmN0aW9uSW5kZXhTcGFjZTsKICAgICBWZWN0b3I8RnVuY3Rpb25M b2NhdGlvbkluQmluYXJ5PiBmdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnk7CisgICAgVmVjdG9yPFNp Z25hdHVyZUluZGV4PiBtb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5k aWNlczsKIH07CiAKIGNsYXNzIE1vZHVsZVBhcnNlciA6IHB1YmxpYyBQYXJzZXI8TW9kdWxlUGFy c2VyUmVzdWx0PiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt UGFnZUNvdW50LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QYWdlQ291bnQu Y3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjRiODc3MDUKLS0tIC9kZXYv bnVsbAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGFnZUNvdW50LmNwcApA QCAtMCwwICsxLDQ1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE2IEFwcGxlIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJl IG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy IGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3Zp ZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJ REVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElF RCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBM SUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBM RSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJ UkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElB TCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5U IE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgor ICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQg T04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJ Q1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJX SVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdB UkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisg Ki8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIldhc21QYWdlQ291bnQuaCIKKwor I2lmIEVOQUJMRShXRUJBU1NFTUJMWSkKKworI2luY2x1ZGUgPHd0Zi9QcmludFN0cmVhbS5oPgor I2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgorCituYW1lc3BhY2UgSlNDIHsgbmFtZXNw YWNlIFdhc20geworCit2b2lkIFBhZ2VDb3VudDo6ZHVtcChQcmludFN0cmVhbSYgb3V0KSBjb25z dAoreworICAgIG91dC5wcmludChTdHJpbmc6Om51bWJlcihieXRlcygpKSwgIkIiKTsKK30KKwor fSAvLyBuYW1lc3BhY2UgSlNDCisKK30gLy8gbmFtZXNwYWNlIFdhc20KKworI2VuZGlmIC8vIEVO QUJMRShXRUJBU1NFTUJMWSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNt L1dhc21QYWdlQ291bnQuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QYWdlQ291 bnQuaAppbmRleCBhMTVkNTA1Li42N2RiYjU1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtUGFnZUNvdW50LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbVBhZ2VDb3VudC5oCkBAIC0yNyw2ICsyNywxMCBAQAogCiAjaWYgRU5BQkxFKFdFQkFT U0VNQkxZKQogCituYW1lc3BhY2UgV1RGIHsKK2NsYXNzIFByaW50U3RyZWFtOworfQorCiBuYW1l c3BhY2UgSlNDIHsgbmFtZXNwYWNlIFdhc20gewogCiBjbGFzcyBQYWdlQ291bnQgewpAQCAtNDIs NiArNDYsOCBAQCBwdWJsaWM6CiAgICAgICAgIDogbV9wYWdlQ291bnQocGFnZUNvdW50KQogICAg IHsgfQogCisgICAgdm9pZCBkdW1wKFdURjo6UHJpbnRTdHJlYW0mKSBjb25zdDsKKwogICAgIHVp bnQ2NF90IGJ5dGVzKCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8dWludDY0X3Q+KG1fcGFn ZUNvdW50KSAqIHN0YXRpY19jYXN0PHVpbnQ2NF90PihwYWdlU2l6ZSk7IH0KICAgICB1aW50MzJf dCBwYWdlQ291bnQoKSBjb25zdCB7IHJldHVybiBtX3BhZ2VDb3VudDsgfQogCmRpZmYgLS1naXQg YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5jcHAgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtUGxhbi5jcHAKaW5kZXggZWQyOGJiYy4uNTk4MGI1MSAxMDA2NDQK LS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uY3BwCisrKyBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QbGFuLmNwcApAQCAtNzYsOCArNzYsNyBAQCBib29s IFBsYW46OnBhcnNlQW5kVmFsaWRhdGVNb2R1bGUoKQogICAgICAgICB9CiAgICAgICAgIG1fbW9k dWxlSW5mb3JtYXRpb24gPSBXVEZNb3ZlKHBhcnNlUmVzdWx0LT5tb2R1bGUpOwogICAgICAgICBt X2Z1bmN0aW9uTG9jYXRpb25JbkJpbmFyeSA9IFdURk1vdmUocGFyc2VSZXN1bHQtPmZ1bmN0aW9u TG9jYXRpb25JbkJpbmFyeSk7Ci0gICAgICAgIG1fZnVuY3Rpb25JbmRleFNwYWNlLnNpemUgPSBw YXJzZVJlc3VsdC0+ZnVuY3Rpb25JbmRleFNwYWNlLnNpemUoKTsKLSAgICAgICAgbV9mdW5jdGlv bkluZGV4U3BhY2UuYnVmZmVyID0gcGFyc2VSZXN1bHQtPmZ1bmN0aW9uSW5kZXhTcGFjZS5yZWxl YXNlQnVmZmVyKCk7CisgICAgICAgIG1fbW9kdWxlU2lnbmF0dXJlSW5kaWNlc1RvVW5pcXVlZFNp Z25hdHVyZUluZGljZXMgPSBXVEZNb3ZlKHBhcnNlUmVzdWx0LT5tb2R1bGVTaWduYXR1cmVJbmRp Y2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5kaWNlcyk7CiAgICAgfQogCiAgICAgZm9yICh1bnNpZ25l ZCBmdW5jdGlvbkluZGV4ID0gMDsgZnVuY3Rpb25JbmRleCA8IG1fZnVuY3Rpb25Mb2NhdGlvbklu QmluYXJ5LnNpemUoKTsgKytmdW5jdGlvbkluZGV4KSB7CkBAIC04OSw3ICs4OCw3IEBAIGJvb2wg UGxhbjo6cGFyc2VBbmRWYWxpZGF0ZU1vZHVsZSgpCiAgICAgICAgIFNpZ25hdHVyZUluZGV4IHNp Z25hdHVyZUluZGV4ID0gbV9tb2R1bGVJbmZvcm1hdGlvbi0+aW50ZXJuYWxGdW5jdGlvblNpZ25h dHVyZUluZGljZXNbZnVuY3Rpb25JbmRleF07CiAgICAgICAgIGNvbnN0IFNpZ25hdHVyZSogc2ln bmF0dXJlID0gU2lnbmF0dXJlSW5mb3JtYXRpb246OmdldChtX3ZtLCBzaWduYXR1cmVJbmRleCk7 CiAKLSAgICAgICAgYXV0byB2YWxpZGF0aW9uUmVzdWx0ID0gdmFsaWRhdGVGdW5jdGlvbihtX3Zt LCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBtX2Z1bmN0aW9uSW5k ZXhTcGFjZSwgKm1fbW9kdWxlSW5mb3JtYXRpb24pOworICAgICAgICBhdXRvIHZhbGlkYXRpb25S ZXN1bHQgPSB2YWxpZGF0ZUZ1bmN0aW9uKG1fdm0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVu Z3RoLCBzaWduYXR1cmUsICptX21vZHVsZUluZm9ybWF0aW9uLCBtX21vZHVsZVNpZ25hdHVyZUlu ZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzKTsKICAgICAgICAgaWYgKCF2YWxpZGF0aW9u UmVzdWx0KSB7CiAgICAgICAgICAgICBpZiAodmVyYm9zZSkgewogICAgICAgICAgICAgICAgIGZv ciAodW5zaWduZWQgaSA9IDA7IGkgPCBmdW5jdGlvbkxlbmd0aDsgKytpKQpAQCAtMTI3LDcgKzEy Niw3IEBAIHZvaWQgUGxhbjo6cnVuKCkKICAgICAgICAgcmV0dXJuIHRydWU7CiAgICAgfTsKIAot ICAgIGlmICghdHJ5UmVzZXJ2ZUNhcGFjaXR5KG1fd2FzbVRvSlNTdHVicywgbV9tb2R1bGVJbmZv cm1hdGlvbi0+aW1wb3J0RnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnNpemUoKSwgIiBXZWJBc3Nl bWJseSB0byBKYXZhU2NyaXB0IHN0dWJzIikKKyAgICBpZiAoIXRyeVJlc2VydmVDYXBhY2l0eSht X3dhc21FeGl0U3R1YnMsIG1fbW9kdWxlSW5mb3JtYXRpb24tPmltcG9ydEZ1bmN0aW9uU2lnbmF0 dXJlSW5kaWNlcy5zaXplKCksICIgV2ViQXNzZW1ibHkgdG8gSmF2YVNjcmlwdCBzdHVicyIpCiAg ICAgICAgIHx8ICF0cnlSZXNlcnZlQ2FwYWNpdHkobV91bmxpbmtlZFdhc21Ub1dhc21DYWxscywg bV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgpLCAiIHVubGlua2VkIFdlYkFzc2VtYmx5 IHRvIFdlYkFzc2VtYmx5IGNhbGxzIikKICAgICAgICAgfHwgIXRyeVJlc2VydmVDYXBhY2l0eSht X3dhc21JbnRlcm5hbEZ1bmN0aW9ucywgbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgp LCAiIFdlYkFzc2VtYmx5IGZ1bmN0aW9ucyIpCiAgICAgICAgIHx8ICF0cnlSZXNlcnZlQ2FwYWNp dHkobV9jb21waWxhdGlvbkNvbnRleHRzLCBtX2Z1bmN0aW9uTG9jYXRpb25JbkJpbmFyeS5zaXpl KCksICIgY29tcGlsYXRpb24gY29udGV4dHMiKSkKQEAgLTE0MSwxMiArMTQwLDExIEBAIHZvaWQg UGxhbjo6cnVuKCkKICAgICAgICAgSW1wb3J0KiBpbXBvcnQgPSAmbV9tb2R1bGVJbmZvcm1hdGlv bi0+aW1wb3J0c1tpbXBvcnRJbmRleF07CiAgICAgICAgIGlmIChpbXBvcnQtPmtpbmQgIT0gRXh0 ZXJuYWxLaW5kOjpGdW5jdGlvbikKICAgICAgICAgICAgIGNvbnRpbnVlOwotICAgICAgICB1bnNp Z25lZCBpbXBvcnRGdW5jdGlvbkluZGV4ID0gbV93YXNtVG9KU1N0dWJzLnNpemUoKTsKKyAgICAg ICAgdW5zaWduZWQgaW1wb3J0RnVuY3Rpb25JbmRleCA9IG1fd2FzbUV4aXRTdHVicy5zaXplKCk7 CiAgICAgICAgIGlmICh2ZXJib3NlKQogICAgICAgICAgICAgZGF0YUxvZ0xuKCJQcm9jZXNzaW5n IGltcG9ydCBmdW5jdGlvbiBudW1iZXIgIiwgaW1wb3J0RnVuY3Rpb25JbmRleCwgIjogIiwgaW1w b3J0LT5tb2R1bGUsICI6ICIsIGltcG9ydC0+ZmllbGQpOwogICAgICAgICBTaWduYXR1cmVJbmRl eCBzaWduYXR1cmVJbmRleCA9IG1fbW9kdWxlSW5mb3JtYXRpb24tPmltcG9ydEZ1bmN0aW9uU2ln bmF0dXJlSW5kaWNlcy5hdChpbXBvcnQtPmtpbmRJbmRleCk7Ci0gICAgICAgIG1fd2FzbVRvSlNT dHVicy51bmNoZWNrZWRBcHBlbmQoaW1wb3J0U3R1YkdlbmVyYXRvcihtX3ZtLCBtX2NhbGxMaW5r SW5mb3MsIHNpZ25hdHVyZUluZGV4LCBpbXBvcnRGdW5jdGlvbkluZGV4KSk7Ci0gICAgICAgIG1f ZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtpbXBvcnRGdW5jdGlvbkluZGV4XS5jb2Rl ID0gbV93YXNtVG9KU1N0dWJzW2ltcG9ydEZ1bmN0aW9uSW5kZXhdLmNvZGUoKS5leGVjdXRhYmxl QWRkcmVzcygpOworICAgICAgICBtX3dhc21FeGl0U3R1YnMudW5jaGVja2VkQXBwZW5kKGV4aXRT dHViR2VuZXJhdG9yKG1fdm0sIG1fY2FsbExpbmtJbmZvcywgc2lnbmF0dXJlSW5kZXgsIGltcG9y dEZ1bmN0aW9uSW5kZXgpKTsKICAgICB9CiAKICAgICBtX2N1cnJlbnRJbmRleCA9IDA7CkBAIC0x NjcsMTIgKzE2NSwxMiBAQCB2b2lkIFBsYW46OnJ1bigpCiAgICAgICAgICAgICBBU1NFUlQoZnVu Y3Rpb25MZW5ndGggPD0gbV9zb3VyY2VMZW5ndGgpOwogICAgICAgICAgICAgU2lnbmF0dXJlSW5k ZXggc2lnbmF0dXJlSW5kZXggPSBtX21vZHVsZUluZm9ybWF0aW9uLT5pbnRlcm5hbEZ1bmN0aW9u U2lnbmF0dXJlSW5kaWNlc1tmdW5jdGlvbkluZGV4XTsKICAgICAgICAgICAgIGNvbnN0IFNpZ25h dHVyZSogc2lnbmF0dXJlID0gU2lnbmF0dXJlSW5mb3JtYXRpb246OmdldChtX3ZtLCBzaWduYXR1 cmVJbmRleCk7Ci0gICAgICAgICAgICB1bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2UgPSBtX3dh c21Ub0pTU3R1YnMuc2l6ZSgpICsgZnVuY3Rpb25JbmRleDsKLSAgICAgICAgICAgIEFTU0VSVF9V TlVTRUQoZnVuY3Rpb25JbmRleFNwYWNlLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZS5idWZmZXIuZ2V0 KClbZnVuY3Rpb25JbmRleFNwYWNlXS5zaWduYXR1cmVJbmRleCA9PSBzaWduYXR1cmVJbmRleCk7 Ci0gICAgICAgICAgICBBU1NFUlQodmFsaWRhdGVGdW5jdGlvbihtX3ZtLCBmdW5jdGlvblN0YXJ0 LCBmdW5jdGlvbkxlbmd0aCwgc2lnbmF0dXJlLCBtX2Z1bmN0aW9uSW5kZXhTcGFjZSwgKm1fbW9k dWxlSW5mb3JtYXRpb24pKTsKKyAgICAgICAgICAgIHVuc2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFj ZSA9IG1fd2FzbUV4aXRTdHVicy5zaXplKCkgKyBmdW5jdGlvbkluZGV4OworICAgICAgICAgICAg QVNTRVJUX1VOVVNFRChmdW5jdGlvbkluZGV4U3BhY2UsIG1fbW9kdWxlSW5mb3JtYXRpb24tPnNp Z25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4U3BhY2UpID09 IHNpZ25hdHVyZUluZGV4KTsKKyAgICAgICAgICAgIEFTU0VSVCh2YWxpZGF0ZUZ1bmN0aW9uKG1f dm0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVuZ3RoLCBzaWduYXR1cmUsICptX21vZHVsZUlu Zm9ybWF0aW9uLCBtX21vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRp Y2VzKSk7CiAKICAgICAgICAgICAgIG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHNbZnVuY3Rpb25J bmRleF0gPSBWZWN0b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4oKTsKLSAgICAgICAgICAgIGF1 dG8gcGFyc2VBbmRDb21waWxlUmVzdWx0ID0gcGFyc2VBbmRDb21waWxlKCptX3ZtLCBtX2NvbXBp bGF0aW9uQ29udGV4dHNbZnVuY3Rpb25JbmRleF0sIGZ1bmN0aW9uU3RhcnQsIGZ1bmN0aW9uTGVu Z3RoLCBzaWduYXR1cmUsIG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHNbZnVuY3Rpb25JbmRleF0s IG1fZnVuY3Rpb25JbmRleFNwYWNlLCAqbV9tb2R1bGVJbmZvcm1hdGlvbik7CisgICAgICAgICAg ICBhdXRvIHBhcnNlQW5kQ29tcGlsZVJlc3VsdCA9IHBhcnNlQW5kQ29tcGlsZSgqbV92bSwgbV9j b21waWxhdGlvbkNvbnRleHRzW2Z1bmN0aW9uSW5kZXhdLCBmdW5jdGlvblN0YXJ0LCBmdW5jdGlv bkxlbmd0aCwgc2lnbmF0dXJlLCBtX3VubGlua2VkV2FzbVRvV2FzbUNhbGxzW2Z1bmN0aW9uSW5k ZXhdLCAqbV9tb2R1bGVJbmZvcm1hdGlvbiwgbV9tb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9Vbmlx dWVkU2lnbmF0dXJlSW5kaWNlcyk7CiAKICAgICAgICAgICAgIGlmIChVTkxJS0VMWSghcGFyc2VB bmRDb21waWxlUmVzdWx0KSkgewogICAgICAgICAgICAgICAgIGF1dG8gbG9ja2VyID0gaG9sZExv Y2sobV9sb2NrKTsKQEAgLTIwOSwxMCArMjA3LDEyIEBAIHZvaWQgUGxhbjo6cnVuKCkKICAgICBm b3IgKHVpbnQzMl90IGZ1bmN0aW9uSW5kZXggPSAwOyBmdW5jdGlvbkluZGV4IDwgbV9mdW5jdGlv bkxvY2F0aW9uSW5CaW5hcnkuc2l6ZSgpOyBmdW5jdGlvbkluZGV4KyspIHsKICAgICAgICAgewog ICAgICAgICAgICAgQ29tcGlsYXRpb25Db250ZXh0JiBjb250ZXh0ID0gbV9jb21waWxhdGlvbkNv bnRleHRzW2Z1bmN0aW9uSW5kZXhdOworICAgICAgICAgICAgU2lnbmF0dXJlSW5kZXggc2lnbmF0 dXJlSW5kZXggPSBtX21vZHVsZUluZm9ybWF0aW9uLT5pbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJl SW5kaWNlc1tmdW5jdGlvbkluZGV4XTsKKyAgICAgICAgICAgIFN0cmluZyBzaWduYXR1cmVEZXNj cmlwdGlvbiA9IFNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQobV92bSwgc2lnbmF0dXJlSW5kZXgp LT50b1N0cmluZygpOwogICAgICAgICAgICAgewogICAgICAgICAgICAgICAgIExpbmtCdWZmZXIg bGlua0J1ZmZlcigqbV92bSwgKmNvbnRleHQud2FzbUVudHJ5cG9pbnRKSVQsIG51bGxwdHIpOwog ICAgICAgICAgICAgICAgIG1fd2FzbUludGVybmFsRnVuY3Rpb25zW2Z1bmN0aW9uSW5kZXhdLT53 YXNtRW50cnlwb2ludC5jb21waWxhdGlvbiA9Ci0gICAgICAgICAgICAgICAgICAgIHN0ZDo6bWFr ZV91bmlxdWU8QjM6OkNvbXBpbGF0aW9uPihGSU5BTElaRV9DT0RFKGxpbmtCdWZmZXIsICgiV2Fz bSBmdW5jdGlvbiIpKSwgV1RGTW92ZShjb250ZXh0Lndhc21FbnRyeXBvaW50Qnlwcm9kdWN0cykp OworICAgICAgICAgICAgICAgICAgICBzdGQ6Om1ha2VfdW5pcXVlPEIzOjpDb21waWxhdGlvbj4o RklOQUxJWkVfQ09ERShsaW5rQnVmZmVyLCAoIldlYkFzc2VtYmx5IGZ1bmN0aW9uWyVpXSAlcyIs IGZ1bmN0aW9uSW5kZXgsIHNpZ25hdHVyZURlc2NyaXB0aW9uLmFzY2lpKCkuZGF0YSgpKSksIFdU Rk1vdmUoY29udGV4dC53YXNtRW50cnlwb2ludEJ5cHJvZHVjdHMpKTsKICAgICAgICAgICAgIH0K IAogICAgICAgICAgICAgewpAQCAtMjIwLDEyICsyMjAsOSBAQCB2b2lkIFBsYW46OnJ1bigpCiAg ICAgICAgICAgICAgICAgbGlua0J1ZmZlci5saW5rKGNvbnRleHQuanNFbnRyeXBvaW50VG9XYXNt RW50cnlwb2ludENhbGwsIEZ1bmN0aW9uUHRyKG1fd2FzbUludGVybmFsRnVuY3Rpb25zW2Z1bmN0 aW9uSW5kZXhdLT53YXNtRW50cnlwb2ludC5jb21waWxhdGlvbi0+Y29kZSgpLmV4ZWN1dGFibGVB ZGRyZXNzKCkpKTsKIAogICAgICAgICAgICAgICAgIG1fd2FzbUludGVybmFsRnVuY3Rpb25zW2Z1 bmN0aW9uSW5kZXhdLT5qc1RvV2FzbUVudHJ5cG9pbnQuY29tcGlsYXRpb24gPQotICAgICAgICAg ICAgICAgICAgICBzdGQ6Om1ha2VfdW5pcXVlPEIzOjpDb21waWxhdGlvbj4oRklOQUxJWkVfQ09E RShsaW5rQnVmZmVyLCAoIldhc20gSlMgZW50cnlwb2ludCIpKSwgV1RGTW92ZShjb250ZXh0Lmpz RW50cnlwb2ludEJ5cHJvZHVjdHMpKTsKKyAgICAgICAgICAgICAgICAgICAgc3RkOjptYWtlX3Vu aXF1ZTxCMzo6Q29tcGlsYXRpb24+KEZJTkFMSVpFX0NPREUobGlua0J1ZmZlciwgKCJKYXZhU2Ny aXB0LT5XZWJBc3NlbWJseSBlbnRyeXBvaW50WyVpXSAlcyIsIGZ1bmN0aW9uSW5kZXgsIHNpZ25h dHVyZURlc2NyaXB0aW9uLmFzY2lpKCkuZGF0YSgpKSksIFdURk1vdmUoY29udGV4dC5qc0VudHJ5 cG9pbnRCeXByb2R1Y3RzKSk7CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KLQotICAgICAgICB1 bnNpZ25lZCBmdW5jdGlvbkluZGV4U3BhY2UgPSBtX3dhc21Ub0pTU3R1YnMuc2l6ZSgpICsgZnVu Y3Rpb25JbmRleDsKLSAgICAgICAgbV9mdW5jdGlvbkluZGV4U3BhY2UuYnVmZmVyLmdldCgpW2Z1 bmN0aW9uSW5kZXhTcGFjZV0uY29kZSA9IG1fd2FzbUludGVybmFsRnVuY3Rpb25zW2Z1bmN0aW9u SW5kZXhdLT53YXNtRW50cnlwb2ludC5jb21waWxhdGlvbi0+Y29kZSgpLmV4ZWN1dGFibGVBZGRy ZXNzKCk7CiAgICAgfQogCiAgICAgaWYgKHZlcmJvc2UgfHwgT3B0aW9uczo6cmVwb3J0Q29tcGls ZVRpbWVzKCkpIHsKQEAgLTIzNSw4ICsyMzIsMTkgQEAgdm9pZCBQbGFuOjpydW4oKQogCiAgICAg Ly8gUGF0Y2ggdGhlIGNhbGwgc2l0ZXMgZm9yIGVhY2ggV2ViQXNzZW1ibHkgZnVuY3Rpb24uCiAg ICAgZm9yIChhdXRvJiB1bmxpbmtlZCA6IG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHMpIHsKLSAg ICAgICAgZm9yIChhdXRvJiBjYWxsIDogdW5saW5rZWQpCi0gICAgICAgICAgICBNYWNyb0Fzc2Vt Ymxlcjo6cmVwYXRjaENhbGwoY2FsbC5jYWxsTG9jYXRpb24sIENvZGVMb2NhdGlvbkxhYmVsKG1f ZnVuY3Rpb25JbmRleFNwYWNlLmJ1ZmZlci5nZXQoKVtjYWxsLmZ1bmN0aW9uSW5kZXhdLmNvZGUp KTsKKyAgICAgICAgZm9yIChhdXRvJiBjYWxsIDogdW5saW5rZWQpIHsKKyAgICAgICAgICAgIHZv aWQqIGV4ZWN1dGFibGVBZGRyZXNzOworICAgICAgICAgICAgaWYgKG1fbW9kdWxlSW5mb3JtYXRp b24tPmlzSW1wb3J0ZWRGdW5jdGlvbkZyb21GdW5jdGlvbkluZGV4U3BhY2UoY2FsbC5mdW5jdGlv bkluZGV4KSkgeworICAgICAgICAgICAgICAgIC8vIEZJWE1FIGltcG9ydHMgY291bGQgaGF2ZSBi ZWVuIGxpbmtlZCBpbiBCMywgaW5zdGVhZCBvZiBnZW5lcmF0aW5nIGEgcGF0Y2hwb2ludC4gVGhp cyBjb25kaXRpb24gc2hvdWxkIGJlIHJlcGxhY2VkIGJ5IGEgUkVMRUFTRV9BU1NFUlQuIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjY0NjIKKyAgICAgICAgICAgICAg ICBleGVjdXRhYmxlQWRkcmVzcyA9IGNhbGwudGFyZ2V0ID09IFVubGlua2VkV2FzbVRvV2FzbUNh bGw6OlRhcmdldDo6VG9KcworICAgICAgICAgICAgICAgICAgICA/IG1fd2FzbUV4aXRTdHVicy5h dChjYWxsLmZ1bmN0aW9uSW5kZXgpLndhc21Ub0pzLmNvZGUoKS5leGVjdXRhYmxlQWRkcmVzcygp CisgICAgICAgICAgICAgICAgICAgIDogbV93YXNtRXhpdFN0dWJzLmF0KGNhbGwuZnVuY3Rpb25J bmRleCkud2FzbVRvV2FzbS5jb2RlKCkuZXhlY3V0YWJsZUFkZHJlc3MoKTsKKyAgICAgICAgICAg IH0gZWxzZSB7CisgICAgICAgICAgICAgICAgQVNTRVJUKGNhbGwudGFyZ2V0ICE9IFVubGlua2Vk V2FzbVRvV2FzbUNhbGw6OlRhcmdldDo6VG9Kcyk7CisgICAgICAgICAgICAgICAgZXhlY3V0YWJs ZUFkZHJlc3MgPSBtX3dhc21JbnRlcm5hbEZ1bmN0aW9ucy5hdChjYWxsLmZ1bmN0aW9uSW5kZXgg LSBtX3dhc21FeGl0U3R1YnMuc2l6ZSgpKS0+d2FzbUVudHJ5cG9pbnQuY29tcGlsYXRpb24tPmNv ZGUoKS5leGVjdXRhYmxlQWRkcmVzcygpOworICAgICAgICAgICAgfQorICAgICAgICAgICAgTWFj cm9Bc3NlbWJsZXI6OnJlcGF0Y2hDYWxsKGNhbGwuY2FsbExvY2F0aW9uLCBDb2RlTG9jYXRpb25M YWJlbChleGVjdXRhYmxlQWRkcmVzcykpOworICAgICAgICB9CiAgICAgfQogCiAgICAgbV9mYWls ZWQgPSBmYWxzZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Q bGFuLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtUGxhbi5oCmluZGV4IDNiYjAx YzguLjY5ODBiZGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Q bGFuLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBsYW4uaApAQCAtODYs MjYgKzg2LDIwIEBAIHB1YmxpYzoKICAgICAgICAgcmV0dXJuIFdURk1vdmUobV9jYWxsTGlua0lu Zm9zKTsKICAgICB9CiAKLSAgICBWZWN0b3I8V2FzbVRvSlNTdHViPiYmIHRha2VXYXNtVG9KU1N0 dWJzKCkKKyAgICBWZWN0b3I8V2FzbUV4aXRTdHVicz4mJiB0YWtlV2FzbUV4aXRTdHVicygpCiAg ICAgewogICAgICAgICBSRUxFQVNFX0FTU0VSVCghZmFpbGVkKCkpOwotICAgICAgICByZXR1cm4g V1RGTW92ZShtX3dhc21Ub0pTU3R1YnMpOwotICAgIH0KLQotICAgIEltbXV0YWJsZUZ1bmN0aW9u SW5kZXhTcGFjZSYmIHRha2VGdW5jdGlvbkluZGV4U3BhY2UoKQotICAgIHsKLSAgICAgICAgUkVM RUFTRV9BU1NFUlQoIWZhaWxlZCgpKTsKLSAgICAgICAgcmV0dXJuIFdURk1vdmUobV9mdW5jdGlv bkluZGV4U3BhY2UpOworICAgICAgICByZXR1cm4gV1RGTW92ZShtX3dhc21FeGl0U3R1YnMpOwog ICAgIH0KIAogcHJpdmF0ZToKICAgICBzdGQ6OnVuaXF1ZV9wdHI8TW9kdWxlSW5mb3JtYXRpb24+ IG1fbW9kdWxlSW5mb3JtYXRpb247CiAgICAgVmVjdG9yPEZ1bmN0aW9uTG9jYXRpb25JbkJpbmFy eT4gbV9mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnk7CisgICAgVmVjdG9yPFNpZ25hdHVyZUluZGV4 PiBtX21vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1cmVJbmRpY2VzOwogICAg IEJhZzxDYWxsTGlua0luZm8+IG1fY2FsbExpbmtJbmZvczsKLSAgICBWZWN0b3I8V2FzbVRvSlNT dHViPiBtX3dhc21Ub0pTU3R1YnM7CisgICAgVmVjdG9yPFdhc21FeGl0U3R1YnM+IG1fd2FzbUV4 aXRTdHViczsKICAgICBWZWN0b3I8c3RkOjp1bmlxdWVfcHRyPFdhc21JbnRlcm5hbEZ1bmN0aW9u Pj4gbV93YXNtSW50ZXJuYWxGdW5jdGlvbnM7CiAgICAgVmVjdG9yPENvbXBpbGF0aW9uQ29udGV4 dD4gbV9jb21waWxhdGlvbkNvbnRleHRzOwotICAgIEltbXV0YWJsZUZ1bmN0aW9uSW5kZXhTcGFj ZSBtX2Z1bmN0aW9uSW5kZXhTcGFjZTsKIAogICAgIFZNKiBtX3ZtOwogICAgIFZlY3RvcjxWZWN0 b3I8VW5saW5rZWRXYXNtVG9XYXNtQ2FsbD4+IG1fdW5saW5rZWRXYXNtVG9XYXNtQ2FsbHM7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmNwcCBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuY3BwCmluZGV4IDZkNWIx ZjYuLjA5NjZkYWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21T aWduYXR1cmUuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1 cmUuY3BwCkBAIC00MSwxMiArNDEsMjIgQEAgY29uc3QgYm9vbCB2ZXJib3NlID0gZmFsc2U7CiAK IGNvbnN0IGNvbnN0ZXhwciBTaWduYXR1cmVJbmRleCBTaWduYXR1cmU6OmludmFsaWRJbmRleDsK IAorU3RyaW5nIFNpZ25hdHVyZTo6dG9TdHJpbmcoKSBjb25zdAoreworICAgIFN0cmluZyByZXN1 bHQobWFrZVN0cmluZyhyZXR1cm5UeXBlKCkpKTsKKyAgICByZXN1bHQuYXBwZW5kKCIgKCIpOwor ICAgIGZvciAoU2lnbmF0dXJlQXJnQ291bnQgYXJnID0gMDsgYXJnIDwgYXJndW1lbnRDb3VudCgp OyArK2FyZykgeworICAgICAgICBpZiAoYXJnKQorICAgICAgICAgICAgcmVzdWx0LmFwcGVuZCgi LCAiKTsKKyAgICAgICAgcmVzdWx0LmFwcGVuZChtYWtlU3RyaW5nKGFyZ3VtZW50KGFyZykpKTsK KyAgICB9CisgICAgcmVzdWx0LmFwcGVuZCgnKScpOworICAgIHJldHVybiByZXN1bHQ7Cit9CisK IHZvaWQgU2lnbmF0dXJlOjpkdW1wKFByaW50U3RyZWFtJiBvdXQpIGNvbnN0CiB7Ci0gICAgb3V0 LnByaW50KG1ha2VTdHJpbmcocmV0dXJuVHlwZSgpKSwgIiAoIik7Ci0gICAgZm9yIChTaWduYXR1 cmVBcmdDb3VudCBhcmcgPSAwOyBhcmcgPCBhcmd1bWVudENvdW50KCk7ICsrYXJnKQotICAgICAg ICBvdXQucHJpbnQoKGFyZyA/ICIsICIgOiAiIiksIG1ha2VTdHJpbmcoYXJndW1lbnQoYXJnKSkp OwotICAgIG91dC5wcmludCgiKSIpOworICAgIG91dC5wcmludCh0b1N0cmluZygpKTsKIH0KIAog dW5zaWduZWQgU2lnbmF0dXJlOjpoYXNoKCkgY29uc3QKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21TaWduYXR1cmUuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21TaWduYXR1cmUuaAppbmRleCAwZDZjN2I1Li40ZDQzZmZjIDEwMDY0NAotLS0gYS9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtU2lnbmF0dXJlLmgKKysrIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vV2FzbVNpZ25hdHVyZS5oCkBAIC04Miw2ICs4Miw3IEBAIHB1Ymxp YzoKICAgICB9CiAgICAgVHlwZSBhcmd1bWVudChTaWduYXR1cmVBcmdDb3VudCBpKSBjb25zdCB7 IHJldHVybiBjb25zdF9jYXN0PFNpZ25hdHVyZSo+KHRoaXMpLT5hcmd1bWVudChpKTsgfQogCisg ICAgV1RGOjpTdHJpbmcgdG9TdHJpbmcoKSBjb25zdDsKICAgICB2b2lkIGR1bXAoV1RGOjpQcmlu dFN0cmVhbSYgb3V0KSBjb25zdDsKICAgICBib29sIG9wZXJhdG9yPT0oY29uc3QgU2lnbmF0dXJl JiByaHMpIGNvbnN0CiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbVZhbGlkYXRlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxp ZGF0ZS5jcHAKaW5kZXggZTMyMTYxMy4uNzVkMzgyNiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwCkBAIC0zODEsMTAgKzM4MSwxMCBAQCB2b2lkIFZhbGlk YXRlOjpkdW1wKGNvbnN0IFZlY3RvcjxDb250cm9sRW50cnk+JiBjb250cm9sU3RhY2ssIGNvbnN0 IEV4cHJlc3Npb25MaQogICAgIGRhdGFMb2dMbigpOwogfQogCi1FeHBlY3RlZDx2b2lkLCBTdHJp bmc+IHZhbGlkYXRlRnVuY3Rpb24oVk0qIHZtLCBjb25zdCB1aW50OF90KiBzb3VyY2UsIHNpemVf dCBsZW5ndGgsIGNvbnN0IFNpZ25hdHVyZSogc2lnbmF0dXJlLCBjb25zdCBJbW11dGFibGVGdW5j dGlvbkluZGV4U3BhY2UmIGZ1bmN0aW9uSW5kZXhTcGFjZSwgY29uc3QgTW9kdWxlSW5mb3JtYXRp b24mIG1vZHVsZSkKK0V4cGVjdGVkPHZvaWQsIFN0cmluZz4gdmFsaWRhdGVGdW5jdGlvbihWTSog dm0sIGNvbnN0IHVpbnQ4X3QqIHNvdXJjZSwgc2l6ZV90IGxlbmd0aCwgY29uc3QgU2lnbmF0dXJl KiBzaWduYXR1cmUsIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiBtb2R1bGUsIGNvbnN0IFZlY3Rv cjxTaWduYXR1cmVJbmRleD4mIG1vZHVsZVNpZ25hdHVyZUluZGljZXNUb1VuaXF1ZWRTaWduYXR1 cmVJbmRpY2VzKQogewogICAgIFZhbGlkYXRlIGNvbnRleHQobW9kdWxlKTsKLSAgICBGdW5jdGlv blBhcnNlcjxWYWxpZGF0ZT4gdmFsaWRhdG9yKHZtLCBjb250ZXh0LCBzb3VyY2UsIGxlbmd0aCwg c2lnbmF0dXJlLCBmdW5jdGlvbkluZGV4U3BhY2UsIG1vZHVsZSk7CisgICAgRnVuY3Rpb25QYXJz ZXI8VmFsaWRhdGU+IHZhbGlkYXRvcih2bSwgY29udGV4dCwgc291cmNlLCBsZW5ndGgsIHNpZ25h dHVyZSwgbW9kdWxlLCBtb2R1bGVTaWduYXR1cmVJbmRpY2VzVG9VbmlxdWVkU2lnbmF0dXJlSW5k aWNlcyk7CiAgICAgV0FTTV9GQUlMX0lGX0hFTFBFUl9GQUlMUyh2YWxpZGF0b3IucGFyc2UoKSk7 CiAgICAgcmV0dXJuIHsgfTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21WYWxpZGF0ZS5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlk YXRlLmgKaW5kZXggMTQ4MjFmMi4uNzNlN2Q4NyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbVZhbGlkYXRlLmgKQEAgLTM2LDcgKzM2LDcgQEAgY2xhc3MgVk07CiAKIG5hbWVzcGFj ZSBXYXNtIHsKIAotRXhwZWN0ZWQ8dm9pZCwgU3RyaW5nPiB2YWxpZGF0ZUZ1bmN0aW9uKFZNKiwg Y29uc3QgdWludDhfdCosIHNpemVfdCwgY29uc3QgU2lnbmF0dXJlKiwgY29uc3QgSW1tdXRhYmxl RnVuY3Rpb25JbmRleFNwYWNlJiwgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mKTsKK0V4cGVjdGVk PHZvaWQsIFN0cmluZz4gdmFsaWRhdGVGdW5jdGlvbihWTSosIGNvbnN0IHVpbnQ4X3QqLCBzaXpl X3QsIGNvbnN0IFNpZ25hdHVyZSosIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9uJiwgY29uc3QgVmVj dG9yPFNpZ25hdHVyZUluZGV4PiYpOwogCiB9IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2FzbQogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5SW5z dGFuY2UuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0 YW5jZS5oCmluZGV4IDkyOGY0MjMuLjk5YTJjOTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5oCisrKyBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlJbnN0YW5jZS5oCkBAIC04Niw5ICs4Niwx MSBAQCBwdWJsaWM6CiAgICAgICAgIHJldHVybiBvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucygpICsg c2l6ZW9mKFdyaXRlQmFycmllcjxKU0NlbGw+KSAqIGlkeDsKICAgICB9CiAKLSAgICBzdGF0aWMg cHRyZGlmZl90IG9mZnNldE9mVGFibGUoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJB c3NlbWJseUluc3RhbmNlLCBtX3RhYmxlKTsgfQogICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0 T2ZNZW1vcnkoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseUluc3RhbmNl LCBtX21lbW9yeSk7IH0KKyAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9mVGFibGUoKSB7IHJl dHVybiBPQkpFQ1RfT0ZGU0VUT0YoSlNXZWJBc3NlbWJseUluc3RhbmNlLCBtX3RhYmxlKTsgfQog ICAgIHN0YXRpYyBwdHJkaWZmX3Qgb2Zmc2V0T2ZHbG9iYWxzKCkgeyByZXR1cm4gT0JKRUNUX09G RlNFVE9GKEpTV2ViQXNzZW1ibHlJbnN0YW5jZSwgbV9nbG9iYWxzKTsgfQorICAgIHN0YXRpYyBz aXplX3Qgb2Zmc2V0T2ZJbXBvcnRGdW5jdGlvbnMoKSB7IHJldHVybiBXVEY6OnJvdW5kVXBUb011 bHRpcGxlT2Y8c2l6ZW9mKFdyaXRlQmFycmllcjxKU0NlbGw+KT4oc2l6ZW9mKEpTV2ViQXNzZW1i bHlJbnN0YW5jZSkpOyB9CisgICAgc3RhdGljIHNpemVfdCBvZmZzZXRPZkltcG9ydEZ1bmN0aW9u KHNpemVfdCBpbXBvcnRGdW5jdGlvbk51bSkgeyByZXR1cm4gb2Zmc2V0T2ZJbXBvcnRGdW5jdGlv bnMoKSArIGltcG9ydEZ1bmN0aW9uTnVtICogc2l6ZW9mKHNpemVvZihXcml0ZUJhcnJpZXI8SlND ZWxsPikpOyB9CiAKIHByb3RlY3RlZDoKICAgICBKU1dlYkFzc2VtYmx5SW5zdGFuY2UoVk0mLCBT dHJ1Y3R1cmUqLCB1bnNpZ25lZCBudW1JbXBvcnRGdW5jdGlvbnMpOwpAQCAtOTYsMTEgKzk4LDYg QEAgcHJvdGVjdGVkOgogICAgIHN0YXRpYyB2b2lkIGRlc3Ryb3koSlNDZWxsKik7CiAgICAgc3Rh dGljIHZvaWQgdmlzaXRDaGlsZHJlbihKU0NlbGwqLCBTbG90VmlzaXRvciYpOwogCi0gICAgc3Rh dGljIHNpemVfdCBvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucygpCi0gICAgewotICAgICAgICByZXR1 cm4gV1RGOjpyb3VuZFVwVG9NdWx0aXBsZU9mPHNpemVvZihXcml0ZUJhcnJpZXI8SlNDZWxsPik+ KHNpemVvZihKU1dlYkFzc2VtYmx5SW5zdGFuY2UpKTsKLSAgICB9Ci0KICAgICBzdGF0aWMgc2l6 ZV90IGFsbG9jYXRpb25TaXplKHVuc2lnbmVkIG51bUltcG9ydEZ1bmN0aW9ucykKICAgICB7CiAg ICAgICAgIHJldHVybiBvZmZzZXRPZkltcG9ydEZ1bmN0aW9ucygpICsgc2l6ZW9mKFdyaXRlQmFy cmllcjxKU0NlbGw+KSAqIG51bUltcG9ydEZ1bmN0aW9uczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuY3BwIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5jcHAKaW5kZXggNTI4YWI2 OS4uNGM0Y2MzZSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNX ZWJBc3NlbWJseU1lbW9yeS5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMv SlNXZWJBc3NlbWJseU1lbW9yeS5jcHAKQEAgLTM3LDkgKzM3LDkgQEAgbmFtZXNwYWNlIEpTQyB7 CiAKIGNvbnN0IENsYXNzSW5mbyBKU1dlYkFzc2VtYmx5TWVtb3J5OjpzX2luZm8gPSB7ICJXZWJB c3NlbWJseS5NZW1vcnkiLCAmQmFzZTo6c19pbmZvLCAwLCBDUkVBVEVfTUVUSE9EX1RBQkxFKEpT V2ViQXNzZW1ibHlNZW1vcnkpIH07CiAKLUpTV2ViQXNzZW1ibHlNZW1vcnkqIEpTV2ViQXNzZW1i bHlNZW1vcnk6OmNyZWF0ZShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBzdGQ6OnVuaXF1 ZV9wdHI8V2FzbTo6TWVtb3J5PiYmIG1lbW9yeSkKK0pTV2ViQXNzZW1ibHlNZW1vcnkqIEpTV2Vi QXNzZW1ibHlNZW1vcnk6OmNyZWF0ZShWTSYgdm0sIFN0cnVjdHVyZSogc3RydWN0dXJlLCBXYXNt OjpNZW1vcnkmJiBtZW1vcnkpCiB7Ci0gICAgYXV0byogaW5zdGFuY2UgPSBuZXcgKE5vdE51bGws IGFsbG9jYXRlQ2VsbDxKU1dlYkFzc2VtYmx5TWVtb3J5Pih2bS5oZWFwKSkgSlNXZWJBc3NlbWJs eU1lbW9yeSh2bSwgc3RydWN0dXJlLCBXVEZNb3ZlKG1lbW9yeSkpOworICAgIGF1dG8qIGluc3Rh bmNlID0gbmV3IChOb3ROdWxsLCBhbGxvY2F0ZUNlbGw8SlNXZWJBc3NlbWJseU1lbW9yeT4odm0u aGVhcCkpIEpTV2ViQXNzZW1ibHlNZW1vcnkodm0sIHN0cnVjdHVyZSwgc3RkOjpmb3J3YXJkPFdh c206Ok1lbW9yeT4obWVtb3J5KSk7CiAgICAgaW5zdGFuY2UtPmZpbmlzaENyZWF0aW9uKHZtKTsK ICAgICByZXR1cm4gaW5zdGFuY2U7CiB9CkBAIC00OSw3ICs0OSw3IEBAIFN0cnVjdHVyZSogSlNX ZWJBc3NlbWJseU1lbW9yeTo6Y3JlYXRlU3RydWN0dXJlKFZNJiB2bSwgSlNHbG9iYWxPYmplY3Qq IGdsb2JhbE9iCiAgICAgcmV0dXJuIFN0cnVjdHVyZTo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3Qs IHByb3RvdHlwZSwgVHlwZUluZm8oT2JqZWN0VHlwZSwgU3RydWN0dXJlRmxhZ3MpLCBpbmZvKCkp OwogfQogCi1KU1dlYkFzc2VtYmx5TWVtb3J5OjpKU1dlYkFzc2VtYmx5TWVtb3J5KFZNJiB2bSwg U3RydWN0dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNZW1vcnk+JiYgbWVt b3J5KQorSlNXZWJBc3NlbWJseU1lbW9yeTo6SlNXZWJBc3NlbWJseU1lbW9yeShWTSYgdm0sIFN0 cnVjdHVyZSogc3RydWN0dXJlLCBXYXNtOjpNZW1vcnkmJiBtZW1vcnkpCiAgICAgOiBCYXNlKHZt LCBzdHJ1Y3R1cmUpCiAgICAgLCBtX21lbW9yeShXVEZNb3ZlKG1lbW9yeSkpCiB7CkBAIC03Miw3 ICs3Miw3IEBAIEpTQXJyYXlCdWZmZXIqIEpTV2ViQXNzZW1ibHlNZW1vcnk6OmJ1ZmZlcihWTSYg dm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QpCiAgICAgYXV0byBkZXN0cnVjdG9yID0g W10gKHZvaWQqKSB7CiAgICAgICAgIC8vIFdlIGRvbid0IG5lZWQgdG8gZG8gYW55dGhpbmcgaGVy ZSB0byBkZXN0cm95IHRoZSBtZW1vcnkuCiAgICAgICAgIC8vIFRoZSBBcnJheUJ1ZmZlciBiYWNr aW5nIHRoZSBKU0FycmF5QnVmZmVyIGlzIG9ubHkgb3duZWQgYnkgdXMsCi0gICAgICAgIC8vIHNv IHdlIGd1YXJhbnRlZSBpdHMgbGlmZWN5bGNlLgorICAgICAgICAvLyBzbyB3ZSBndWFyYW50ZWUg aXRzIGxpZmVjeWNsZS4KICAgICB9OwogICAgIG1fYnVmZmVyID0gQXJyYXlCdWZmZXI6OmNyZWF0 ZUZyb21CeXRlcyhtZW1vcnkoKS0+bWVtb3J5KCksIG1lbW9yeSgpLT5zaXplKCksIFdURk1vdmUo ZGVzdHJ1Y3RvcikpOwogICAgIG1fYnVmZmVyV3JhcHBlci5zZXQodm0sIHRoaXMsIEpTQXJyYXlC dWZmZXI6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0LT5tX2FycmF5QnVmZmVyU3RydWN0dXJlLmdl dCgpLCBtX2J1ZmZlci5nZXQoKSkpOwpAQCAtODUsNyArODUsNyBAQCBXYXNtOjpQYWdlQ291bnQg SlNXZWJBc3NlbWJseU1lbW9yeTo6Z3JvdyhFeGVjU3RhdGUqIGV4ZWMsIHVpbnQzMl90IGRlbHRh LCBib29sCiAgICAgVk0mIHZtID0gZXhlYy0+dm0oKTsKICAgICBhdXRvIHRocm93U2NvcGUgPSBE RUNMQVJFX1RIUk9XX1NDT1BFKHZtKTsKIAotICAgIFdhc206OlBhZ2VDb3VudCBvbGRQYWdlQ291 bnQgPSBtX21lbW9yeS0+c2l6ZUluUGFnZXMoKTsKKyAgICBXYXNtOjpQYWdlQ291bnQgb2xkUGFn ZUNvdW50ID0gbWVtb3J5KCktPnNpemVJblBhZ2VzKCk7CiAKICAgICBpZiAoIVdhc206OlBhZ2VD b3VudDo6aXNWYWxpZChkZWx0YSkpIHsKICAgICAgICAgaWYgKHNob3VsZFRocm93RXhjZXB0aW9u c09uRmFpbHVyZSkKQEAgLTEwMSw3ICsxMDEsNyBAQCBXYXNtOjpQYWdlQ291bnQgSlNXZWJBc3Nl bWJseU1lbW9yeTo6Z3JvdyhFeGVjU3RhdGUqIGV4ZWMsIHVpbnQzMl90IGRlbHRhLCBib29sCiAg ICAgfQogCiAgICAgaWYgKGRlbHRhKSB7Ci0gICAgICAgIGJvb2wgc3VjY2VzcyA9IG1fbWVtb3J5 LT5ncm93KG5ld1NpemUpOworICAgICAgICBib29sIHN1Y2Nlc3MgPSBtZW1vcnkoKS0+Z3Jvdyhu ZXdTaXplKTsKICAgICAgICAgaWYgKCFzdWNjZXNzKSB7CiAgICAgICAgICAgICBpZiAoc2hvdWxk VGhyb3dFeGNlcHRpb25zT25GYWlsdXJlKQogICAgICAgICAgICAgICAgIHRocm93RXhjZXB0aW9u KGV4ZWMsIHRocm93U2NvcGUsIGNyZWF0ZU91dE9mTWVtb3J5RXJyb3IoZXhlYykpOwpkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5o IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1lbW9yeS5oCmlu ZGV4IDI4Nzk3YzYuLmI0MjJmNDggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL2pzL0pTV2ViQXNzZW1ibHlNZW1vcnkuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9qcy9KU1dlYkFzc2VtYmx5TWVtb3J5LmgKQEAgLTQxLDI1ICs0MSwyNiBAQCBjbGFzcyBK U1dlYkFzc2VtYmx5TWVtb3J5IDogcHVibGljIEpTRGVzdHJ1Y3RpYmxlT2JqZWN0IHsKIHB1Ymxp YzoKICAgICB0eXBlZGVmIEpTRGVzdHJ1Y3RpYmxlT2JqZWN0IEJhc2U7CiAKLSAgICBzdGF0aWMg SlNXZWJBc3NlbWJseU1lbW9yeSogY3JlYXRlKFZNJiwgU3RydWN0dXJlKiwgc3RkOjp1bmlxdWVf cHRyPFdhc206Ok1lbW9yeT4mJik7CisgICAgc3RhdGljIEpTV2ViQXNzZW1ibHlNZW1vcnkqIGNy ZWF0ZShWTSYsIFN0cnVjdHVyZSosIFdhc206Ok1lbW9yeSYmKTsKICAgICBzdGF0aWMgU3RydWN0 dXJlKiBjcmVhdGVTdHJ1Y3R1cmUoVk0mLCBKU0dsb2JhbE9iamVjdCosIEpTVmFsdWUpOwogCiAg ICAgREVDTEFSRV9JTkZPOwogCi0gICAgV2FzbTo6TWVtb3J5KiBtZW1vcnkoKSB7IHJldHVybiBt X21lbW9yeS5nZXQoKTsgfQorICAgIFdhc206Ok1lbW9yeSogbWVtb3J5KCkgeyByZXR1cm4gJm1f bWVtb3J5OyB9CiAgICAgSlNBcnJheUJ1ZmZlciogYnVmZmVyKFZNJiB2bSwgSlNHbG9iYWxPYmpl Y3QqKTsKICAgICBXYXNtOjpQYWdlQ291bnQgZ3JvdyhFeGVjU3RhdGUqLCB1aW50MzJfdCBkZWx0 YSwgYm9vbCBzaG91bGRUaHJvd0V4Y2VwdGlvbnNPbkZhaWx1cmUpOwogCi0gICAgc3RhdGljIHB0 cmRpZmZfdCBvZmZzZXRPZk1lbW9yeSgpIHsgcmV0dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFz c2VtYmx5TWVtb3J5LCBtX21lbW9yeSk7IH0KKyAgICBzdGF0aWMgcHRyZGlmZl90IG9mZnNldE9m TWVtb3J5KCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKEpTV2ViQXNzZW1ibHlNZW1vcnksIG1f bWVtb3J5KSArIFdhc206Ok1lbW9yeTo6b2Zmc2V0T2ZNZW1vcnkoKTsgfQorICAgIHN0YXRpYyBw dHJkaWZmX3Qgb2Zmc2V0T2ZTaXplKCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKEpTV2ViQXNz ZW1ibHlNZW1vcnksIG1fbWVtb3J5KSArIFdhc206Ok1lbW9yeTo6b2Zmc2V0T2ZTaXplKCk7IH0K IAogcHJvdGVjdGVkOgotICAgIEpTV2ViQXNzZW1ibHlNZW1vcnkoVk0mLCBTdHJ1Y3R1cmUqLCBz dGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TWVtb3J5PiYmKTsKKyAgICBKU1dlYkFzc2VtYmx5TWVtb3J5 KFZNJiwgU3RydWN0dXJlKiwgV2FzbTo6TWVtb3J5JiYpOwogICAgIH5KU1dlYkFzc2VtYmx5TWVt b3J5KCk7CiAgICAgdm9pZCBmaW5pc2hDcmVhdGlvbihWTSYpOwogICAgIHN0YXRpYyB2b2lkIGRl c3Ryb3koSlNDZWxsKik7CiAgICAgc3RhdGljIHZvaWQgdmlzaXRDaGlsZHJlbihKU0NlbGwqLCBT bG90VmlzaXRvciYpOwogCi0gICAgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1lbW9yeT4gbV9tZW1v cnk7CisgICAgV2FzbTo6TWVtb3J5IG1fbWVtb3J5OwogICAgIFdyaXRlQmFycmllcjxKU0FycmF5 QnVmZmVyPiBtX2J1ZmZlcldyYXBwZXI7CiAgICAgUmVmUHRyPEFycmF5QnVmZmVyPiBtX2J1ZmZl cjsKIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFz c2VtYmx5TW9kdWxlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNz ZW1ibHlNb2R1bGUuY3BwCmluZGV4IGQ2NTI0YzUuLmZhMGU4NTkgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUuY3BwCisrKyBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL0pTV2ViQXNzZW1ibHlNb2R1bGUuY3BwCkBAIC0z OCw5ICszOCw5IEBAIG5hbWVzcGFjZSBKU0MgewogCiBjb25zdCBDbGFzc0luZm8gSlNXZWJBc3Nl bWJseU1vZHVsZTo6c19pbmZvID0geyAiV2ViQXNzZW1ibHkuTW9kdWxlIiwgJkJhc2U6OnNfaW5m bywgbnVsbHB0ciwgQ1JFQVRFX01FVEhPRF9UQUJMRShKU1dlYkFzc2VtYmx5TW9kdWxlKSB9Owog Ci1KU1dlYkFzc2VtYmx5TW9kdWxlKiBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGUoVk0mIHZt LCBTdHJ1Y3R1cmUqIHN0cnVjdHVyZSwgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUluZm9y bWF0aW9uPiYmIG1vZHVsZUluZm9ybWF0aW9uLCBCYWc8Q2FsbExpbmtJbmZvPiYmIGNhbGxMaW5r SW5mb3MsIFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0dWI+JiYgd2FzbVRvSlNTdHVicywgV2FzbTo6 SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiYgZnVuY3Rpb25JbmRleFNwYWNlLCBTeW1ib2xU YWJsZSogZXhwb3J0U3ltYm9sVGFibGUsIHVuc2lnbmVkIGNhbGxlZUNvdW50KQorSlNXZWJBc3Nl bWJseU1vZHVsZSogSlNXZWJBc3NlbWJseU1vZHVsZTo6Y3JlYXRlKFZNJiB2bSwgU3RydWN0dXJl KiBzdHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4mJiBt b2R1bGVJbmZvcm1hdGlvbiwgQmFnPENhbGxMaW5rSW5mbz4mJiBjYWxsTGlua0luZm9zLCBWZWN0 b3I8V2FzbTo6V2FzbUV4aXRTdHVicz4mJiB3YXNtRXhpdFN0dWJzLCBTeW1ib2xUYWJsZSogZXhw b3J0U3ltYm9sVGFibGUsIHVuc2lnbmVkIGNhbGxlZUNvdW50KQogewotICAgIGF1dG8qIGluc3Rh bmNlID0gbmV3IChOb3ROdWxsLCBhbGxvY2F0ZUNlbGw8SlNXZWJBc3NlbWJseU1vZHVsZT4odm0u aGVhcCwgYWxsb2NhdGlvblNpemUoY2FsbGVlQ291bnQpKSkgSlNXZWJBc3NlbWJseU1vZHVsZSh2 bSwgc3RydWN0dXJlLCBzdGQ6OmZvcndhcmQ8c3RkOjp1bmlxdWVfcHRyPFdhc206Ok1vZHVsZUlu Zm9ybWF0aW9uPj4obW9kdWxlSW5mb3JtYXRpb24pLCBzdGQ6OmZvcndhcmQ8QmFnPENhbGxMaW5r SW5mbz4+KGNhbGxMaW5rSW5mb3MpLCBzdGQ6OmZvcndhcmQ8VmVjdG9yPFdhc206Oldhc21Ub0pT U3R1Yj4+KHdhc21Ub0pTU3R1YnMpLCBzdGQ6OmZvcndhcmQ8V2FzbTo6SW1tdXRhYmxlRnVuY3Rp b25JbmRleFNwYWNlPihmdW5jdGlvbkluZGV4U3BhY2UpLCBjYWxsZWVDb3VudCk7CisgICAgYXV0 byogaW5zdGFuY2UgPSBuZXcgKE5vdE51bGwsIGFsbG9jYXRlQ2VsbDxKU1dlYkFzc2VtYmx5TW9k dWxlPih2bS5oZWFwLCBhbGxvY2F0aW9uU2l6ZShjYWxsZWVDb3VudCkpKSBKU1dlYkFzc2VtYmx5 TW9kdWxlKHZtLCBzdHJ1Y3R1cmUsIHN0ZDo6Zm9yd2FyZDxzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6 TW9kdWxlSW5mb3JtYXRpb24+Pihtb2R1bGVJbmZvcm1hdGlvbiksIHN0ZDo6Zm9yd2FyZDxCYWc8 Q2FsbExpbmtJbmZvPj4oY2FsbExpbmtJbmZvcyksIHN0ZDo6Zm9yd2FyZDxWZWN0b3I8V2FzbTo6 V2FzbUV4aXRTdHVicz4+KHdhc21FeGl0U3R1YnMpLCBjYWxsZWVDb3VudCk7CiAgICAgaW5zdGFu Y2UtPmZpbmlzaENyZWF0aW9uKHZtLCBleHBvcnRTeW1ib2xUYWJsZSk7CiAgICAgcmV0dXJuIGlu c3RhbmNlOwogfQpAQCAtNTAsMTIgKzUwLDExIEBAIFN0cnVjdHVyZSogSlNXZWJBc3NlbWJseU1v ZHVsZTo6Y3JlYXRlU3RydWN0dXJlKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iCiAg ICAgcmV0dXJuIFN0cnVjdHVyZTo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3QsIHByb3RvdHlwZSwg VHlwZUluZm8oT2JqZWN0VHlwZSwgU3RydWN0dXJlRmxhZ3MpLCBpbmZvKCkpOwogfQogCi1KU1dl YkFzc2VtYmx5TW9kdWxlOjpKU1dlYkFzc2VtYmx5TW9kdWxlKFZNJiB2bSwgU3RydWN0dXJlKiBz dHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4mJiBtb2R1 bGVJbmZvcm1hdGlvbiwgQmFnPENhbGxMaW5rSW5mbz4mJiBjYWxsTGlua0luZm9zLCBWZWN0b3I8 V2FzbTo6V2FzbVRvSlNTdHViPiYmIHdhc21Ub0pTU3R1YnMsIFdhc206OkltbXV0YWJsZUZ1bmN0 aW9uSW5kZXhTcGFjZSYmIGZ1bmN0aW9uSW5kZXhTcGFjZSwgdW5zaWduZWQgY2FsbGVlQ291bnQp CitKU1dlYkFzc2VtYmx5TW9kdWxlOjpKU1dlYkFzc2VtYmx5TW9kdWxlKFZNJiB2bSwgU3RydWN0 dXJlKiBzdHJ1Y3R1cmUsIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4m JiBtb2R1bGVJbmZvcm1hdGlvbiwgQmFnPENhbGxMaW5rSW5mbz4mJiBjYWxsTGlua0luZm9zLCBW ZWN0b3I8V2FzbTo6V2FzbUV4aXRTdHVicz4mJiB3YXNtRXhpdFN0dWJzLCB1bnNpZ25lZCBjYWxs ZWVDb3VudCkKICAgICA6IEJhc2Uodm0sIHN0cnVjdHVyZSkKICAgICAsIG1fbW9kdWxlSW5mb3Jt YXRpb24oV1RGTW92ZShtb2R1bGVJbmZvcm1hdGlvbikpCiAgICAgLCBtX2NhbGxMaW5rSW5mb3Mo V1RGTW92ZShjYWxsTGlua0luZm9zKSkKLSAgICAsIG1fd2FzbVRvSlNTdHVicyhXVEZNb3ZlKHdh c21Ub0pTU3R1YnMpKQotICAgICwgbV9mdW5jdGlvbkluZGV4U3BhY2UoV1RGTW92ZShmdW5jdGlv bkluZGV4U3BhY2UpKQorICAgICwgbV93YXNtRXhpdFN0dWJzKFdURk1vdmUod2FzbUV4aXRTdHVi cykpCiAgICAgLCBtX2NhbGxlZUNvdW50KGNhbGxlZUNvdW50KQogewogICAgIG1lbXNldChjYWxs ZWVzKCksIDAsIG1fY2FsbGVlQ291bnQgKiBzaXplb2YoV3JpdGVCYXJyaWVyPEpTV2ViQXNzZW1i bHlDYWxsZWU+KSAqIDIpOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v anMvSlNXZWJBc3NlbWJseU1vZHVsZS5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMv SlNXZWJBc3NlbWJseU1vZHVsZS5oCmluZGV4IGZlYzRlZWQuLjdlMDUxZjU3IDEwMDY0NAotLS0g YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9KU1dlYkFzc2VtYmx5TW9kdWxlLmgKKysr IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvSlNXZWJBc3NlbWJseU1vZHVsZS5oCkBA IC00MywxOSArNDMsMTggQEAgY2xhc3MgSlNXZWJBc3NlbWJseU1vZHVsZSA6IHB1YmxpYyBKU0Rl c3RydWN0aWJsZU9iamVjdCB7CiBwdWJsaWM6CiAgICAgdHlwZWRlZiBKU0Rlc3RydWN0aWJsZU9i amVjdCBCYXNlOwogCi0gICAgc3RhdGljIEpTV2ViQXNzZW1ibHlNb2R1bGUqIGNyZWF0ZShWTSYs IFN0cnVjdHVyZSosIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpNb2R1bGVJbmZvcm1hdGlvbj4mJiwg QmFnPENhbGxMaW5rSW5mbz4mJiwgVmVjdG9yPFdhc206Oldhc21Ub0pTU3R1Yj4mJiwgV2FzbTo6 SW1tdXRhYmxlRnVuY3Rpb25JbmRleFNwYWNlJiYsIFN5bWJvbFRhYmxlKiwgdW5zaWduZWQpOwor ICAgIHN0YXRpYyBKU1dlYkFzc2VtYmx5TW9kdWxlKiBjcmVhdGUoVk0mLCBTdHJ1Y3R1cmUqLCBz dGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYsIEJhZzxDYWxsTGlua0lu Zm8+JiYsIFZlY3RvcjxXYXNtOjpXYXNtRXhpdFN0dWJzPiYmLCBTeW1ib2xUYWJsZSosIHVuc2ln bmVkKTsKICAgICBzdGF0aWMgU3RydWN0dXJlKiBjcmVhdGVTdHJ1Y3R1cmUoVk0mLCBKU0dsb2Jh bE9iamVjdCosIEpTVmFsdWUpOwogCiAgICAgREVDTEFSRV9JTkZPOwogCiAgICAgY29uc3QgV2Fz bTo6TW9kdWxlSW5mb3JtYXRpb24mIG1vZHVsZUluZm9ybWF0aW9uKCkgY29uc3QgeyByZXR1cm4g Km1fbW9kdWxlSW5mb3JtYXRpb24uZ2V0KCk7IH0KICAgICBTeW1ib2xUYWJsZSogZXhwb3J0U3lt Ym9sVGFibGUoKSBjb25zdCB7IHJldHVybiBtX2V4cG9ydFN5bWJvbFRhYmxlLmdldCgpOyB9Ci0g ICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlRm9yRnVuY3Rpb25JbmRleFNwYWNlKHVu c2lnbmVkIGZ1bmN0aW9uSW5kZXhTcGFjZSkgY29uc3QKKyAgICBXYXNtOjpTaWduYXR1cmVJbmRl eCBzaWduYXR1cmVJbmRleEZyb21GdW5jdGlvbkluZGV4U3BhY2UodW5zaWduZWQgZnVuY3Rpb25J bmRleFNwYWNlKSBjb25zdAogICAgIHsKLSAgICAgICAgQVNTRVJUKGZ1bmN0aW9uSW5kZXhTcGFj ZSA8IG1fZnVuY3Rpb25JbmRleFNwYWNlLnNpemUpOwotICAgICAgICByZXR1cm4gbV9mdW5jdGlv bkluZGV4U3BhY2UuYnVmZmVyLmdldCgpW2Z1bmN0aW9uSW5kZXhTcGFjZV0uc2lnbmF0dXJlSW5k ZXg7CisgICAgICAgIHJldHVybiBtX21vZHVsZUluZm9ybWF0aW9uLT5zaWduYXR1cmVJbmRleEZy b21GdW5jdGlvbkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleFNwYWNlKTsKICAgICB9Ci0gICAgdW5z aWduZWQgZnVuY3Rpb25JbXBvcnRDb3VudCgpIGNvbnN0IHsgcmV0dXJuIG1fd2FzbVRvSlNTdHVi cy5zaXplKCk7IH0KKyAgICB1bnNpZ25lZCBmdW5jdGlvbkltcG9ydENvdW50KCkgY29uc3QgeyBy ZXR1cm4gbV93YXNtRXhpdFN0dWJzLnNpemUoKTsgfQogCiAgICAgSlNXZWJBc3NlbWJseUNhbGxl ZSoganNFbnRyeXBvaW50Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhTcGFjZSh1bnNpZ25lZCBmdW5j dGlvbkluZGV4U3BhY2UpCiAgICAgewpAQCAtOTAsMTAgKzg5LDggQEAgcHVibGljOgogICAgICAg ICByZXR1cm4gYml0d2lzZV9jYXN0PFdyaXRlQmFycmllcjxKU1dlYkFzc2VtYmx5Q2FsbGVlPio+ KGJpdHdpc2VfY2FzdDxjaGFyKj4odGhpcykgKyBvZmZzZXRPZkNhbGxlZXMoKSk7CiAgICAgfQog Ci0gICAgc3RhdGljIHB0cmRpZmZfdCBvZmZzZXRPZkZ1bmN0aW9uSW5kZXhTcGFjZSgpIHsgcmV0 dXJuIE9CSkVDVF9PRkZTRVRPRihKU1dlYkFzc2VtYmx5TW9kdWxlLCBtX2Z1bmN0aW9uSW5kZXhT cGFjZSk7IH0KLQogcHJvdGVjdGVkOgotICAgIEpTV2ViQXNzZW1ibHlNb2R1bGUoVk0mLCBTdHJ1 Y3R1cmUqLCBzdGQ6OnVuaXF1ZV9wdHI8V2FzbTo6TW9kdWxlSW5mb3JtYXRpb24+JiYsIEJhZzxD YWxsTGlua0luZm8+JiYsIFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0dWI+JiYsIFdhc206OkltbXV0 YWJsZUZ1bmN0aW9uSW5kZXhTcGFjZSYmLCB1bnNpZ25lZCBjYWxsZWVDb3VudCk7CisgICAgSlNX ZWJBc3NlbWJseU1vZHVsZShWTSYsIFN0cnVjdHVyZSosIHN0ZDo6dW5pcXVlX3B0cjxXYXNtOjpN b2R1bGVJbmZvcm1hdGlvbj4mJiwgQmFnPENhbGxMaW5rSW5mbz4mJiwgVmVjdG9yPFdhc206Oldh c21FeGl0U3R1YnM+JiYsIHVuc2lnbmVkIGNhbGxlZUNvdW50KTsKICAgICB2b2lkIGZpbmlzaENy ZWF0aW9uKFZNJiwgU3ltYm9sVGFibGUqKTsKICAgICBzdGF0aWMgdm9pZCBkZXN0cm95KEpTQ2Vs bCopOwogICAgIHN0YXRpYyB2b2lkIHZpc2l0Q2hpbGRyZW4oSlNDZWxsKiwgU2xvdFZpc2l0b3Im KTsKQEAgLTExNyw4ICsxMTQsNyBAQCBwcml2YXRlOgogICAgIHN0ZDo6dW5pcXVlX3B0cjxXYXNt OjpNb2R1bGVJbmZvcm1hdGlvbj4gbV9tb2R1bGVJbmZvcm1hdGlvbjsKICAgICBCYWc8Q2FsbExp bmtJbmZvPiBtX2NhbGxMaW5rSW5mb3M7CiAgICAgV3JpdGVCYXJyaWVyPFN5bWJvbFRhYmxlPiBt X2V4cG9ydFN5bWJvbFRhYmxlOwotICAgIFZlY3RvcjxXYXNtOjpXYXNtVG9KU1N0dWI+IG1fd2Fz bVRvSlNTdHViczsKLSAgICBjb25zdCBXYXNtOjpJbW11dGFibGVGdW5jdGlvbkluZGV4U3BhY2Ug bV9mdW5jdGlvbkluZGV4U3BhY2U7CisgICAgVmVjdG9yPFdhc206Oldhc21FeGl0U3R1YnM+IG1f d2FzbUV4aXRTdHViczsKICAgICB1bnNpZ25lZCBtX2NhbGxlZUNvdW50OwogfTsKIApkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlvbi5j cHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNw cAppbmRleCBiZTI3ZjU3Li5iODEwMTg5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9uLmNwcApAQCAtMTE5LDYgKzExOSw3IEBA IHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGNhbGxXZWJBc3NlbWJseUZ1bmN0 aW9uKEV4ZWNTdGF0ZSogZXhlYykKICAgICBQcm90b0NhbGxGcmFtZSBwcm90b0NhbGxGcmFtZTsK ICAgICBwcm90b0NhbGxGcmFtZS5pbml0KG51bGxwdHIsIHdhc21GdW5jdGlvbiwgZmlyc3RBcmd1 bWVudCwgYXJnQ291bnQsIHJlbWFpbmluZ0FyZ3MpOwogCisgICAgLy8gRklYTUUgRG8gYXdheSB3 aXRoIHRoaXMgZW50aXJlIGZ1bmN0aW9uLCBhbmQgb25seSB1c2UgdGhlIGVudHJ5cG9pbnQgZ2Vu ZXJhdGVkIGJ5IEIzLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY2 NDg2CiAgICAgSlNXZWJBc3NlbWJseUluc3RhbmNlKiBwcmV2SlNXZWJBc3NlbWJseUluc3RhbmNl ID0gdm0udG9wSlNXZWJBc3NlbWJseUluc3RhbmNlOwogICAgIHZtLnRvcEpTV2ViQXNzZW1ibHlJ bnN0YW5jZSA9IHdhc21GdW5jdGlvbi0+aW5zdGFuY2UoKTsKICAgICBBU1NFUlQod2FzbUZ1bmN0 aW9uLT5pbnN0YW5jZSgpKTsKQEAgLTE0OSw3ICsxNTAsNyBAQCBXZWJBc3NlbWJseUZ1bmN0aW9u KiBXZWJBc3NlbWJseUZ1bmN0aW9uOjpjcmVhdGUoVk0mIHZtLCBKU0dsb2JhbE9iamVjdCogZ2xv YmFsTwogewogICAgIE5hdGl2ZUV4ZWN1dGFibGUqIGV4ZWN1dGFibGUgPSB2bS5nZXRIb3N0RnVu Y3Rpb24oY2FsbFdlYkFzc2VtYmx5RnVuY3Rpb24sIE5vSW50cmluc2ljLCBjYWxsSG9zdEZ1bmN0 aW9uQXNDb25zdHJ1Y3RvciwgbnVsbHB0ciwgbmFtZSk7CiAgICAgU3RydWN0dXJlKiBzdHJ1Y3R1 cmUgPSBnbG9iYWxPYmplY3QtPndlYkFzc2VtYmx5RnVuY3Rpb25TdHJ1Y3R1cmUoKTsKLSAgICBX ZWJBc3NlbWJseUZ1bmN0aW9uKiBmdW5jdGlvbiA9IG5ldyAoTm90TnVsbCwgYWxsb2NhdGVDZWxs PFdlYkFzc2VtYmx5RnVuY3Rpb24+KHZtLmhlYXApKSBXZWJBc3NlbWJseUZ1bmN0aW9uKHZtLCBn bG9iYWxPYmplY3QsIHN0cnVjdHVyZSwgc2lnbmF0dXJlSW5kZXgpOworICAgIFdlYkFzc2VtYmx5 RnVuY3Rpb24qIGZ1bmN0aW9uID0gbmV3IChOb3ROdWxsLCBhbGxvY2F0ZUNlbGw8V2ViQXNzZW1i bHlGdW5jdGlvbj4odm0uaGVhcCkpIFdlYkFzc2VtYmx5RnVuY3Rpb24odm0sIGdsb2JhbE9iamVj dCwgc3RydWN0dXJlLCB3YXNtRW50cnlwb2ludCwgc2lnbmF0dXJlSW5kZXgpOwogICAgIGZ1bmN0 aW9uLT5maW5pc2hDcmVhdGlvbih2bSwgZXhlY3V0YWJsZSwgbGVuZ3RoLCBuYW1lLCBpbnN0YW5j ZSwganNFbnRyeXBvaW50LCB3YXNtRW50cnlwb2ludCk7CiAgICAgcmV0dXJuIGZ1bmN0aW9uOwog fQpAQCAtMTU3LDExICsxNTgsMTIgQEAgV2ViQXNzZW1ibHlGdW5jdGlvbiogV2ViQXNzZW1ibHlG dW5jdGlvbjo6Y3JlYXRlKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE8KIFN0cnVjdHVy ZSogV2ViQXNzZW1ibHlGdW5jdGlvbjo6Y3JlYXRlU3RydWN0dXJlKFZNJiB2bSwgSlNHbG9iYWxP YmplY3QqIGdsb2JhbE9iamVjdCwgSlNWYWx1ZSBwcm90b3R5cGUpCiB7CiAgICAgQVNTRVJUKGds b2JhbE9iamVjdCk7Ci0gICAgcmV0dXJuIFN0cnVjdHVyZTo6Y3JlYXRlKHZtLCBnbG9iYWxPYmpl Y3QsIHByb3RvdHlwZSwgVHlwZUluZm8oSlNGdW5jdGlvblR5cGUsIFN0cnVjdHVyZUZsYWdzKSwg aW5mbygpKTsKKyAgICByZXR1cm4gU3RydWN0dXJlOjpjcmVhdGUodm0sIGdsb2JhbE9iamVjdCwg cHJvdG90eXBlLCBUeXBlSW5mbyhXZWJBc3NlbWJseUZ1bmN0aW9uVHlwZSwgU3RydWN0dXJlRmxh Z3MpLCBpbmZvKCkpOwogfQogCi1XZWJBc3NlbWJseUZ1bmN0aW9uOjpXZWJBc3NlbWJseUZ1bmN0 aW9uKFZNJiB2bSwgSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCwgU3RydWN0dXJlKiBzdHJ1 Y3R1cmUsIFdhc206OlNpZ25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4KQorV2ViQXNzZW1ibHlG dW5jdGlvbjo6V2ViQXNzZW1ibHlGdW5jdGlvbihWTSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9i YWxPYmplY3QsIFN0cnVjdHVyZSogc3RydWN0dXJlLCBKU1dlYkFzc2VtYmx5Q2FsbGVlKiB3YXNt RW50cnlwb2ludCwgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXgpCiAgICAgOiBC YXNlKHZtLCBnbG9iYWxPYmplY3QsIHN0cnVjdHVyZSkKKyAgICAsIG1fd2FzbUVudHJ5UG9pbnRD b2RlKHdhc21FbnRyeXBvaW50LT5lbnRyeXBvaW50KCkpCiAgICAgLCBtX3NpZ25hdHVyZUluZGV4 KHNpZ25hdHVyZUluZGV4KQogeyB9CiAKQEAgLTE4Myw2ICsxODUsNyBAQCB2b2lkIFdlYkFzc2Vt Ymx5RnVuY3Rpb246OmZpbmlzaENyZWF0aW9uKFZNJiB2bSwgTmF0aXZlRXhlY3V0YWJsZSogZXhl Y3V0YWJsZSwgdQogICAgIEFTU0VSVChqc0VudHJ5cG9pbnQgIT0gd2FzbUVudHJ5cG9pbnQpOwog ICAgIG1fanNFbnRyeXBvaW50LnNldCh2bSwgdGhpcywganNFbnRyeXBvaW50KTsKICAgICBtX3dh c21FbnRyeXBvaW50LnNldCh2bSwgdGhpcywgd2FzbUVudHJ5cG9pbnQpOworICAgIEFTU0VSVCht X3dhc21FbnRyeXBvaW50LT5lbnRyeXBvaW50KCkgPT0gbV93YXNtRW50cnlQb2ludENvZGUpOwog fQogCiB9IC8vIG5hbWVzcGFjZSBKU0MKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL2pzL1dlYkFzc2VtYmx5RnVuY3Rpb24uaAppbmRleCAzNDkwNTAyLi4yNjY5NGMxIDEwMDY0 NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUZ1bmN0aW9u LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlGdW5jdGlv bi5oCkBAIC01NCwxOCArNTQsMjIgQEAgcHVibGljOgogCiAgICAgSlNXZWJBc3NlbWJseUluc3Rh bmNlKiBpbnN0YW5jZSgpIGNvbnN0IHsgcmV0dXJuIG1faW5zdGFuY2UuZ2V0KCk7IH0KICAgICBX YXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCgpIGNvbnN0IHsgcmV0dXJuIG1fc2ln bmF0dXJlSW5kZXg7IH0KLSAgICB2b2lkKiB3YXNtRW50cnlwb2ludCgpIHsgcmV0dXJuIG1fd2Fz bUVudHJ5cG9pbnQtPmVudHJ5cG9pbnQoKTsgfQorICAgIHZvaWQqIHdhc21FbnRyeXBvaW50KCkg eyByZXR1cm4gbV93YXNtRW50cnlQb2ludENvZGU7IH0KICAgICB2b2lkKiBqc0VudHJ5cG9pbnQo KSB7IHJldHVybiBtX2pzRW50cnlwb2ludC0+ZW50cnlwb2ludCgpOyB9CiAKKyAgICBzdGF0aWMg cHRyZGlmZl90IG9mZnNldE9mSW5zdGFuY2UoKSB7IHJldHVybiBPQkpFQ1RfT0ZGU0VUT0YoV2Vi QXNzZW1ibHlGdW5jdGlvbiwgbV9pbnN0YW5jZSk7IH0KKyAgICBzdGF0aWMgcHRyZGlmZl90IG9m ZnNldE9mV2FzbUVudHJ5UG9pbnRDb2RlKCkgeyByZXR1cm4gT0JKRUNUX09GRlNFVE9GKFdlYkFz c2VtYmx5RnVuY3Rpb24sIG1fd2FzbUVudHJ5UG9pbnRDb2RlKTsgfQorCiBwcm90ZWN0ZWQ6CiAg ICAgc3RhdGljIHZvaWQgdmlzaXRDaGlsZHJlbihKU0NlbGwqLCBTbG90VmlzaXRvciYpOwogCiAg ICAgdm9pZCBmaW5pc2hDcmVhdGlvbihWTSYsIE5hdGl2ZUV4ZWN1dGFibGUqLCB1bnNpZ25lZCBs ZW5ndGgsIGNvbnN0IFN0cmluZyYgbmFtZSwgSlNXZWJBc3NlbWJseUluc3RhbmNlKiwgSlNXZWJB c3NlbWJseUNhbGxlZSoganNFbnRyeXBvaW50LCBKU1dlYkFzc2VtYmx5Q2FsbGVlKiB3YXNtRW50 cnlwb2ludCk7CiAKIHByaXZhdGU6Ci0gICAgV2ViQXNzZW1ibHlGdW5jdGlvbihWTSYsIEpTR2xv YmFsT2JqZWN0KiwgU3RydWN0dXJlKiwgV2FzbTo6U2lnbmF0dXJlSW5kZXgpOworICAgIFdlYkFz c2VtYmx5RnVuY3Rpb24oVk0mLCBKU0dsb2JhbE9iamVjdCosIFN0cnVjdHVyZSosIEpTV2ViQXNz ZW1ibHlDYWxsZWUqLCBXYXNtOjpTaWduYXR1cmVJbmRleCk7CiAKICAgICBXcml0ZUJhcnJpZXI8 SlNXZWJBc3NlbWJseUluc3RhbmNlPiBtX2luc3RhbmNlOworICAgIHZvaWQqIG1fd2FzbUVudHJ5 UG9pbnRDb2RlOyAvLyBDYWNoZSBjb2RlIHBvaW50ZXI6IGFsbG93cyB0aGUgd2FzbSAtPiB3YXNt IHN0dWIgdG8gZG8gYSBzaW5nbGUgbG9hZCBhbmQganVtcCBpbnN0ZWFkIG9mIGhhdmluZyBkZXBl bmRlbnQgbG9hZHMuCiAgICAgV3JpdGVCYXJyaWVyPEpTV2ViQXNzZW1ibHlDYWxsZWU+IG1fanNF bnRyeXBvaW50OwogICAgIFdyaXRlQmFycmllcjxKU1dlYkFzc2VtYmx5Q2FsbGVlPiBtX3dhc21F bnRyeXBvaW50OwogICAgIFdhc206OlNpZ25hdHVyZUluZGV4IG1fc2lnbmF0dXJlSW5kZXg7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUluc3Rh bmNlQ29uc3RydWN0b3IuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNz ZW1ibHlJbnN0YW5jZUNvbnN0cnVjdG9yLmNwcAppbmRleCBkNjBmNDBlLi4xYjQ2MTEyIDEwMDY0 NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseUluc3RhbmNl Q29uc3RydWN0b3IuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFz c2VtYmx5SW5zdGFuY2VDb25zdHJ1Y3Rvci5jcHAKQEAgLTg0LDYgKzg0LDExIEBAIHN0YXRpYyBF bmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGNvbnN0cnVjdEpTV2ViQXNzZW1ibHlJbnN0YW5j ZShFeGVjU3RhdGUqIGV4CiAKICAgICBKU1dlYkFzc2VtYmx5SW5zdGFuY2UqIGluc3RhbmNlID0g SlNXZWJBc3NlbWJseUluc3RhbmNlOjpjcmVhdGUodm0sIGluc3RhbmNlU3RydWN0dXJlLCBqc01v ZHVsZSwgbW9kdWxlUmVjb3JkLT5nZXRNb2R1bGVOYW1lc3BhY2UoZXhlYykpOwogICAgIFJFVFVS Tl9JRl9FWENFUFRJT04odGhyb3dTY29wZSwgZW5jb2RlZEpTVmFsdWUoKSk7CisgICAgeworICAg ICAgICAvLyBBbHdheXMgc3RhcnQgd2l0aCBhIGR1bW15IE1lbW9yeSwgc28gdGhhdCB3YXNtIC0+ IHdhc20gdGh1bmtzIGF2b2lkIGNoZWNraW5nIGZvciBhIG51bGxwdHIgTWVtb3J5IHdoZW4gdHJ5 aW5nIHRvIHNldCBwaW5uZWQgcmVnaXN0ZXJzLgorICAgICAgICBXYXNtOjpNZW1vcnkgbWVtb3J5 OworICAgICAgICBpbnN0YW5jZS0+c2V0TWVtb3J5KHZtLCBKU1dlYkFzc2VtYmx5TWVtb3J5Ojpj cmVhdGUodm0sIGV4ZWMtPmxleGljYWxHbG9iYWxPYmplY3QoKS0+V2ViQXNzZW1ibHlNZW1vcnlT dHJ1Y3R1cmUoKSwgV1RGTW92ZShtZW1vcnkpKSk7CisgICAgfQogCiAgICAgLy8gTGV0IGZ1bmNz LCBtZW1vcmllcyBhbmQgdGFibGVzIGJlIGluaXRpYWxseS1lbXB0eSBsaXN0cyBvZiBjYWxsYWJs ZSBKYXZhU2NyaXB0IG9iamVjdHMsIFdlYkFzc2VtYmx5Lk1lbW9yeSBvYmplY3RzIGFuZCBXZWJB c3NlbWJseS5UYWJsZSBvYmplY3RzLCByZXNwZWN0aXZlbHkuCiAgICAgLy8gTGV0IGltcG9ydHMg YmUgYW4gaW5pdGlhbGx5LWVtcHR5IGxpc3Qgb2YgZXh0ZXJuYWwgdmFsdWVzLgpAQCAtMTE0LDE4 ICsxMTksMTkgQEAgc3RhdGljIEVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwgY29uc3RydWN0 SlNXZWJBc3NlbWJseUluc3RhbmNlKEV4ZWNTdGF0ZSogZXgKICAgICAgICAgICAgICAgICByZXR1 cm4gSlNWYWx1ZTo6ZW5jb2RlKHRocm93RXhjZXB0aW9uKGV4ZWMsIHRocm93U2NvcGUsIGNyZWF0 ZUpTV2ViQXNzZW1ibHlMaW5rRXJyb3IoZXhlYywgdm0sIEFTQ0lJTGl0ZXJhbCgiaW1wb3J0IGZ1 bmN0aW9uIG11c3QgYmUgY2FsbGFibGUiKSkpKTsKICAgICAgICAgICAgIEpTQ2VsbCogY2VsbCA9 IHZhbHVlLmFzQ2VsbCgpOwogICAgICAgICAgICAgLy8gaWkuIElmIHYgaXMgYW4gRXhwb3J0ZWQg RnVuY3Rpb24gRXhvdGljIE9iamVjdDoKLSAgICAgICAgICAgIGlmIChXZWJBc3NlbWJseUZ1bmN0 aW9uKiBpbXBvcnRlZEV4cG9ydHMgPSBqc0R5bmFtaWNDYXN0PFdlYkFzc2VtYmx5RnVuY3Rpb24q PihvYmplY3QpKSB7Ci0gICAgICAgICAgICAgICAgLy8gRklYTUUgaGFuZGxlIEZ1bmN0aW9uIEV4 b3RpYyBPYmplY3QgcHJvcGVybHkuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xNjUyODIKLSAgICAgICAgICAgICAgICAvLyBhLiBJZiB0aGUgc2lnbmF0dXJlIG9mIHYg ZG9lcyBub3QgbWF0Y2ggdGhlIHNpZ25hdHVyZSBvZiBpLCB0aHJvdyBhIFR5cGVFcnJvci4KKyAg ICAgICAgICAgIGlmIChXZWJBc3NlbWJseUZ1bmN0aW9uKiBpbXBvcnRlZEV4cG9ydCA9IGpzRHlu YW1pY0Nhc3Q8V2ViQXNzZW1ibHlGdW5jdGlvbio+KGNlbGwpKSB7CisgICAgICAgICAgICAgICAg Ly8gYS4gSWYgdGhlIHNpZ25hdHVyZSBvZiB2IGRvZXMgbm90IG1hdGNoIHRoZSBzaWduYXR1cmUg b2YgaSwgdGhyb3cgYSBXZWJBc3NlbWJseS5MaW5rRXJyb3IuCisgICAgICAgICAgICAgICAgV2Fz bTo6U2lnbmF0dXJlSW5kZXggaW1wb3J0ZWRTaWduYXR1cmVJbmRleCA9IGltcG9ydGVkRXhwb3J0 LT5zaWduYXR1cmVJbmRleCgpOworICAgICAgICAgICAgICAgIFdhc206OlNpZ25hdHVyZUluZGV4 IGV4cGVjdGVkU2lnbmF0dXJlSW5kZXggPSBtb2R1bGVJbmZvcm1hdGlvbi5pbXBvcnRGdW5jdGlv blNpZ25hdHVyZUluZGljZXNbaW1wb3J0LmtpbmRJbmRleF07CisgICAgICAgICAgICAgICAgaWYg KGltcG9ydGVkU2lnbmF0dXJlSW5kZXggIT0gZXhwZWN0ZWRTaWduYXR1cmVJbmRleCkKKyAgICAg ICAgICAgICAgICAgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29kZSh0aHJvd0V4Y2VwdGlvbihleGVj LCB0aHJvd1Njb3BlLCBjcmVhdGVKU1dlYkFzc2VtYmx5TGlua0Vycm9yKGV4ZWMsIHZtLCBBU0NJ SUxpdGVyYWwoImltcG9ydGVkIGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIGRvZXNuJ3QgbWF0Y2ggdGhl IHByb3ZpZGVkIFdlYkFzc2VtYmx5IGZ1bmN0aW9uJ3Mgc2lnbmF0dXJlIikpKSk7CiAgICAgICAg ICAgICAgICAgLy8gYi4gTGV0IGNsb3N1cmUgYmUgdi5bW0Nsb3N1cmVdXS4KLSAgICAgICAgICAg ICAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOwotICAgICAgICAgICAgICAgIFVOVVNF RF9QQVJBTShpbXBvcnRlZEV4cG9ydHMpOwotICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAg ICAgICAgfQogICAgICAgICAgICAgLy8gaWlpLiBPdGhlcndpc2U6CiAgICAgICAgICAgICAvLyBh LiBMZXQgY2xvc3VyZSBiZSBhIG5ldyBob3N0IGZ1bmN0aW9uIG9mIHRoZSBnaXZlbiBzaWduYXR1 cmUgd2hpY2ggY2FsbHMgdiBieSBjb2VyY2luZyBXZWJBc3NlbWJseSBhcmd1bWVudHMgdG8gSmF2 YVNjcmlwdCBhcmd1bWVudHMgdmlhIFRvSlNWYWx1ZSBhbmQgcmV0dXJucyB0aGUgcmVzdWx0LCBp ZiBhbnksIGJ5IGNvZXJjaW5nIHZpYSBUb1dlYkFzc2VtYmx5VmFsdWUuCiAgICAgICAgICAgICAv LyBOb3RlOiBkb25lIGFzIHBhcnQgb2YgUGxhbiBjb21waWxhdGlvbi4KICAgICAgICAgICAgIC8v IGl2LiBBcHBlbmQgdiB0byBmdW5jcy4KKyAgICAgICAgICAgIC8vIE5vdGU6IGFkZGluZyB0aGUg SlNDZWxsIHRvIHRoZSBpbnN0YW5jZSBsaXN0IGZ1bGZpbGxzIGNsb3N1cmUgcmVxdWlyZW1lbnRz IGIuIGFib3ZlICh0aGUgV2ViQXNzZW1ibHkuSW5zdGFuY2Ugd2lsIGJlIGtlcHQgYWxpdmUpIGFu ZCB2LiBiZWxvdyAodGhlIEpTRnVuY3Rpb24pLgogICAgICAgICAgICAgaW5zdGFuY2UtPnNldElt cG9ydEZ1bmN0aW9uKHZtLCBjZWxsLCBudW1JbXBvcnRGdW5jdGlvbnMrKyk7CiAgICAgICAgICAg ICAvLyB2LiBBcHBlbmQgY2xvc3VyZSB0byBpbXBvcnRzLgogICAgICAgICAgICAgYnJlYWs7CkBA IC0yMzAsNyArMjM2LDcgQEAgc3RhdGljIEVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwgY29u c3RydWN0SlNXZWJBc3NlbWJseUluc3RhbmNlKEV4ZWNTdGF0ZSogZXgKICAgICAgICAgICAgIFJF TEVBU0VfQVNTRVJUKCFtb2R1bGVJbmZvcm1hdGlvbi5tZW1vcnkuaXNJbXBvcnQoKSk7CiAgICAg ICAgICAgICAvLyBXZSBjcmVhdGUgYSBtZW1vcnkgd2hlbiBpdCdzIGEgbWVtb3J5IGRlZmluaXRp b24uCiAgICAgICAgICAgICBib29sIGZhaWxlZDsKLSAgICAgICAgICAgIHN0ZDo6dW5pcXVlX3B0 cjxXYXNtOjpNZW1vcnk+IG1lbW9yeSA9IHN0ZDo6bWFrZV91bmlxdWU8V2FzbTo6TWVtb3J5Piht b2R1bGVJbmZvcm1hdGlvbi5tZW1vcnkuaW5pdGlhbCgpLCBtb2R1bGVJbmZvcm1hdGlvbi5tZW1v cnkubWF4aW11bSgpLCBmYWlsZWQpOworICAgICAgICAgICAgV2FzbTo6TWVtb3J5IG1lbW9yeSht b2R1bGVJbmZvcm1hdGlvbi5tZW1vcnkuaW5pdGlhbCgpLCBtb2R1bGVJbmZvcm1hdGlvbi5tZW1v cnkubWF4aW11bSgpLCBmYWlsZWQpOwogICAgICAgICAgICAgaWYgKGZhaWxlZCkKICAgICAgICAg ICAgICAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKHRocm93RXhjZXB0aW9uKGV4ZWMsIHRocm93 U2NvcGUsIGNyZWF0ZU91dE9mTWVtb3J5RXJyb3IoZXhlYykpKTsKICAgICAgICAgICAgIGluc3Rh bmNlLT5zZXRNZW1vcnkodm0sCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9qcy9XZWJBc3NlbWJseU1lbW9yeUNvbnN0cnVjdG9yLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TWVtb3J5Q29uc3RydWN0b3IuY3BwCmluZGV4IDVkNWE2 Y2QuLjZjODg3YWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dl YkFzc2VtYmx5TWVtb3J5Q29uc3RydWN0b3IuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL2pzL1dlYkFzc2VtYmx5TWVtb3J5Q29uc3RydWN0b3IuY3BwCkBAIC05Nyw3ICs5Nyw3 IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGNvbnN0cnVjdEpTV2ViQXNz ZW1ibHlNZW1vcnkoRXhlY1N0YXRlKiBleGVjCiAgICAgfQogCiAgICAgYm9vbCBmYWlsZWQ7Ci0g ICAgc3RkOjp1bmlxdWVfcHRyPFdhc206Ok1lbW9yeT4gbWVtb3J5ID0gc3RkOjptYWtlX3VuaXF1 ZTxXYXNtOjpNZW1vcnk+KGluaXRpYWxQYWdlQ291bnQsIG1heGltdW1QYWdlQ291bnQsIGZhaWxl ZCk7CisgICAgV2FzbTo6TWVtb3J5IG1lbW9yeShpbml0aWFsUGFnZUNvdW50LCBtYXhpbXVtUGFn ZUNvdW50LCBmYWlsZWQpOwogICAgIGlmIChmYWlsZWQpCiAgICAgICAgIHJldHVybiBKU1ZhbHVl OjplbmNvZGUodGhyb3dFeGNlcHRpb24oZXhlYywgdGhyb3dTY29wZSwgY3JlYXRlT3V0T2ZNZW1v cnlFcnJvcihleGVjKSkpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9qcy9XZWJBc3NlbWJseU1vZHVsZUNvbnN0cnVjdG9yLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlQ29uc3RydWN0b3IuY3BwCmluZGV4IDM4ZWRi OGMuLjgxMjk1OTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dl YkFzc2VtYmx5TW9kdWxlQ29uc3RydWN0b3IuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlQ29uc3RydWN0b3IuY3BwCkBAIC05Nyw3ICs5Nyw3 IEBAIEpTVmFsdWUgV2ViQXNzZW1ibHlNb2R1bGVDb25zdHJ1Y3Rvcjo6Y3JlYXRlTW9kdWxlKEV4 ZWNTdGF0ZSogc3RhdGUsIFN0cnVjdHVyZSoKIAogICAgIC8vIE9ubHkgd2FzbS1pbnRlcm5hbCBm dW5jdGlvbnMgaGF2ZSBhIGNhbGxlZSwgc3R1YnMgdG8gSlMgZG8gbm90LgogICAgIHVuc2lnbmVk IGNhbGxlZUNvdW50ID0gcGxhbi5pbnRlcm5hbEZ1bmN0aW9uQ291bnQoKTsKLSAgICBKU1dlYkFz c2VtYmx5TW9kdWxlKiByZXN1bHQgPSBKU1dlYkFzc2VtYmx5TW9kdWxlOjpjcmVhdGUodm0sIHN0 cnVjdHVyZSwgcGxhbi50YWtlTW9kdWxlSW5mb3JtYXRpb24oKSwgcGxhbi50YWtlQ2FsbExpbmtJ bmZvcygpLCBwbGFuLnRha2VXYXNtVG9KU1N0dWJzKCksIHBsYW4udGFrZUZ1bmN0aW9uSW5kZXhT cGFjZSgpLCBleHBvcnRTeW1ib2xUYWJsZSwgY2FsbGVlQ291bnQpOworICAgIEpTV2ViQXNzZW1i bHlNb2R1bGUqIHJlc3VsdCA9IEpTV2ViQXNzZW1ibHlNb2R1bGU6OmNyZWF0ZSh2bSwgc3RydWN0 dXJlLCBwbGFuLnRha2VNb2R1bGVJbmZvcm1hdGlvbigpLCBwbGFuLnRha2VDYWxsTGlua0luZm9z KCksIHBsYW4udGFrZVdhc21FeGl0U3R1YnMoKSwgZXhwb3J0U3ltYm9sVGFibGUsIGNhbGxlZUNv dW50KTsKICAgICBwbGFuLmluaXRpYWxpemVDYWxsZWVzKHN0YXRlLT5qc0NhbGxlZSgpLT5nbG9i YWxPYmplY3QoKSwgCiAgICAgICAgIFsmXSAodW5zaWduZWQgY2FsbGVlSW5kZXgsIEpTV2ViQXNz ZW1ibHlDYWxsZWUqIGpzRW50cnlwb2ludENhbGxlZSwgSlNXZWJBc3NlbWJseUNhbGxlZSogd2Fz bUVudHJ5cG9pbnRDYWxsZWUpIHsKICAgICAgICAgICAgIHJlc3VsdC0+c2V0SlNFbnRyeXBvaW50 Q2FsbGVlKHZtLCBjYWxsZWVJbmRleCwganNFbnRyeXBvaW50Q2FsbGVlKTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3JkLmNw cCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dlYkFzc2VtYmx5TW9kdWxlUmVjb3Jk LmNwcAppbmRleCBjMWJkODIwLi45ZWZmNGM0IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9qcy9XZWJBc3NlbWJseU1vZHVsZVJlY29yZC5jcHAKKysrIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL3dhc20vanMvV2ViQXNzZW1ibHlNb2R1bGVSZWNvcmQuY3BwCkBAIC0xMTgs NyArMTE4LDcgQEAgdm9pZCBXZWJBc3NlbWJseU1vZHVsZVJlY29yZDo6bGluayhFeGVjU3RhdGUq IHN0YXRlLCBKU1dlYkFzc2VtYmx5SW5zdGFuY2UqIGluc3QKICAgICAgICAgICAgIC8vICAgICBj LiBSZXR1cm4gZnVuYy4KICAgICAgICAgICAgIEpTV2ViQXNzZW1ibHlDYWxsZWUqIGpzRW50cnlw b2ludENhbGxlZSA9IG1vZHVsZS0+anNFbnRyeXBvaW50Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhT cGFjZShleHAua2luZEluZGV4KTsKICAgICAgICAgICAgIEpTV2ViQXNzZW1ibHlDYWxsZWUqIHdh c21FbnRyeXBvaW50Q2FsbGVlID0gbW9kdWxlLT53YXNtRW50cnlwb2ludENhbGxlZUZyb21GdW5j dGlvbkluZGV4U3BhY2UoZXhwLmtpbmRJbmRleCk7Ci0gICAgICAgICAgICBXYXNtOjpTaWduYXR1 cmVJbmRleCBzaWduYXR1cmVJbmRleCA9IG1vZHVsZS0+c2lnbmF0dXJlRm9yRnVuY3Rpb25JbmRl eFNwYWNlKGV4cC5raW5kSW5kZXgpOworICAgICAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXgg c2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhT cGFjZShleHAua2luZEluZGV4KTsKICAgICAgICAgICAgIGNvbnN0IFdhc206OlNpZ25hdHVyZSog c2lnbmF0dXJlID0gV2FzbTo6U2lnbmF0dXJlSW5mb3JtYXRpb246OmdldCgmdm0sIHNpZ25hdHVy ZUluZGV4KTsKICAgICAgICAgICAgIFdlYkFzc2VtYmx5RnVuY3Rpb24qIGZ1bmN0aW9uID0gV2Vi QXNzZW1ibHlGdW5jdGlvbjo6Y3JlYXRlKHZtLCBnbG9iYWxPYmplY3QsIHNpZ25hdHVyZS0+YXJn dW1lbnRDb3VudCgpLCBleHAuZmllbGQuc3RyaW5nKCksIGluc3RhbmNlLCBqc0VudHJ5cG9pbnRD YWxsZWUsIHdhc21FbnRyeXBvaW50Q2FsbGVlLCBzaWduYXR1cmVJbmRleCk7CiAgICAgICAgICAg ICBleHBvcnRlZFZhbHVlID0gZnVuY3Rpb247CkBAIC0xMzMsOCArMTMzLDYgQEAgdm9pZCBXZWJB c3NlbWJseU1vZHVsZVJlY29yZDo6bGluayhFeGVjU3RhdGUqIHN0YXRlLCBKU1dlYkFzc2VtYmx5 SW5zdGFuY2UqIGluc3QKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICB9CiAgICAgICAgIGNh c2UgV2FzbTo6RXh0ZXJuYWxLaW5kOjpNZW1vcnk6IHsKLSAgICAgICAgICAgIC8vIFRoaXMgc2hv dWxkIGJlIGd1YXJhbnRlZWQgYnkgbW9kdWxlIHZlcmlmaWNhdGlvbi4KLSAgICAgICAgICAgIFJF TEVBU0VfQVNTRVJUKGluc3RhbmNlLT5tZW1vcnkoKSk7IAogICAgICAgICAgICAgQVNTRVJUKGV4 cC5raW5kSW5kZXggPT0gMCk7CiAKICAgICAgICAgICAgIGV4cG9ydGVkVmFsdWUgPSBpbnN0YW5j ZS0+bWVtb3J5KCk7CkBAIC0xNzUsNyArMTczLDcgQEAgdm9pZCBXZWJBc3NlbWJseU1vZHVsZVJl Y29yZDo6bGluayhFeGVjU3RhdGUqIHN0YXRlLCBKU1dlYkFzc2VtYmx5SW5zdGFuY2UqIGluc3QK ICAgICBib29sIGhhc1N0YXJ0ID0gISFtb2R1bGVJbmZvcm1hdGlvbi5zdGFydEZ1bmN0aW9uSW5k ZXhTcGFjZTsKICAgICBpZiAoaGFzU3RhcnQpIHsKICAgICAgICAgYXV0byBzdGFydEZ1bmN0aW9u SW5kZXhTcGFjZSA9IG1vZHVsZUluZm9ybWF0aW9uLnN0YXJ0RnVuY3Rpb25JbmRleFNwYWNlLnZh bHVlX29yKDApOwotICAgICAgICBXYXNtOjpTaWduYXR1cmVJbmRleCBzaWduYXR1cmVJbmRleCA9 IG1vZHVsZS0+c2lnbmF0dXJlRm9yRnVuY3Rpb25JbmRleFNwYWNlKHN0YXJ0RnVuY3Rpb25JbmRl eFNwYWNlKTsKKyAgICAgICAgV2FzbTo6U2lnbmF0dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBt b2R1bGUtPnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0aW9uSW5kZXhTcGFjZShzdGFydEZ1bmN0aW9u SW5kZXhTcGFjZSk7CiAgICAgICAgIGNvbnN0IFdhc206OlNpZ25hdHVyZSogc2lnbmF0dXJlID0g V2FzbTo6U2lnbmF0dXJlSW5mb3JtYXRpb246OmdldCgmdm0sIHNpZ25hdHVyZUluZGV4KTsKICAg ICAgICAgLy8gVGhlIHN0YXJ0IGZ1bmN0aW9uIG11c3Qgbm90IHRha2UgYW55IGFyZ3VtZW50cyBv ciByZXR1cm4gYW55dGhpbmcuIFRoaXMgaXMgZW5mb3JjZWQgYnkgdGhlIHBhcnNlci4KICAgICAg ICAgQVNTRVJUKCFzaWduYXR1cmUtPmFyZ3VtZW50Q291bnQoKSk7CkBAIC0yMzgsNyArMjM2LDcg QEAgSlNWYWx1ZSBXZWJBc3NlbWJseU1vZHVsZVJlY29yZDo6ZXZhbHVhdGUoRXhlY1N0YXRlKiBz dGF0ZSkKIAogICAgICAgICAgICAgICAgIEpTV2ViQXNzZW1ibHlDYWxsZWUqIGpzRW50cnlwb2lu dENhbGxlZSA9IG1vZHVsZS0+anNFbnRyeXBvaW50Q2FsbGVlRnJvbUZ1bmN0aW9uSW5kZXhTcGFj ZShmdW5jdGlvbkluZGV4KTsKICAgICAgICAgICAgICAgICBKU1dlYkFzc2VtYmx5Q2FsbGVlKiB3 YXNtRW50cnlwb2ludENhbGxlZSA9IG1vZHVsZS0+d2FzbUVudHJ5cG9pbnRDYWxsZWVGcm9tRnVu Y3Rpb25JbmRleFNwYWNlKGZ1bmN0aW9uSW5kZXgpOwotICAgICAgICAgICAgICAgIFdhc206OlNp Z25hdHVyZUluZGV4IHNpZ25hdHVyZUluZGV4ID0gbW9kdWxlLT5zaWduYXR1cmVGb3JGdW5jdGlv bkluZGV4U3BhY2UoZnVuY3Rpb25JbmRleCk7CisgICAgICAgICAgICAgICAgV2FzbTo6U2lnbmF0 dXJlSW5kZXggc2lnbmF0dXJlSW5kZXggPSBtb2R1bGUtPnNpZ25hdHVyZUluZGV4RnJvbUZ1bmN0 aW9uSW5kZXhTcGFjZShmdW5jdGlvbkluZGV4KTsKICAgICAgICAgICAgICAgICBjb25zdCBXYXNt OjpTaWduYXR1cmUqIHNpZ25hdHVyZSA9IFdhc206OlNpZ25hdHVyZUluZm9ybWF0aW9uOjpnZXQo JnZtLCBzaWduYXR1cmVJbmRleCk7CiAgICAgICAgICAgICAgICAgLy8gRklYTUU6IFNheSB3ZSBl eHBvcnQgbG9jYWwgZnVuY3Rpb24gImZvbyIgYXQgZnVuY2l0b24gaW5kZXggMC4KICAgICAgICAg ICAgICAgICAvLyBXaGF0IGlmIHdlIGFsc28gc2V0IGl0IHRvIHRoZSB0YWJsZSBhbiBFbGVtZW50 IHcvIGluZGV4IDAuCkBAIC0yNTcsNyArMjU1LDYgQEAgSlNWYWx1ZSBXZWJBc3NlbWJseU1vZHVs ZVJlY29yZDo6ZXZhbHVhdGUoRXhlY1N0YXRlKiBzdGF0ZSkKICAgICAgICAgY29uc3QgVmVjdG9y PFdhc206OlNlZ21lbnQ6OlB0cj4mIGRhdGEgPSBtX2luc3RhbmNlLT5tb2R1bGUoKS0+bW9kdWxl SW5mb3JtYXRpb24oKS5kYXRhOwogICAgICAgICBKU1dlYkFzc2VtYmx5TWVtb3J5KiBqc01lbW9y eSA9IG1faW5zdGFuY2UtPm1lbW9yeSgpOwogICAgICAgICBpZiAoIWRhdGEuaXNFbXB0eSgpKSB7 Ci0gICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChqc01lbW9yeSk7IC8vIEl0IGlzIGEgdmFsaWRh dGlvbiBlcnJvciBmb3IgYSBEYXRhIHNlY3Rpb24gdG8gZXhpc3Qgd2l0aG91dCBhIE1lbW9yeSBz ZWN0aW9uIG9yIGltcG9ydC4KICAgICAgICAgICAgIHVpbnQ4X3QqIG1lbW9yeSA9IHJlaW50ZXJw cmV0X2Nhc3Q8dWludDhfdCo+KGpzTWVtb3J5LT5tZW1vcnkoKS0+bWVtb3J5KCkpOwogICAgICAg ICAgICAgdWludDY0X3Qgc2l6ZUluQnl0ZXMgPSBqc01lbW9yeS0+bWVtb3J5KCktPnNpemUoKTsK ICAgICAgICAgICAgIGZvciAoYXV0byYgc2VnbWVudCA6IGRhdGEpIHsKLS0gCjIuMTAuMQoK