21943 2008-10-28 22:54:21 -0700 Avoid needless reads of temporary values in CTI code 2008-11-13 03:27:50 -0800 1 1 1 Unclassified WebKit JavaScriptCore 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 20813 1 zwarich zwarich mjs oldest_to_newest 96950 0 zwarich 2008-10-28 22:54:21 -0700 We currently read a value back from a temporary register in the register file to put it in eax even if it is still in a machine register (which is usually eax). We should avoid these extra reads. The problem of avoiding writes is similarly important, but will require a bit more work. 98603 1 25120 zwarich 2008-11-13 02:24:30 -0800 Created attachment 25120 Proposed patch 98605 2 25120 mjs 2008-11-13 03:02:43 -0800 Comment on attachment 25120 Proposed patch r=me > Index: ChangeLog > =================================================================== > --- ChangeLog (revision 38367) > +++ ChangeLog (working copy) > @@ -1,3 +1,64 @@ > +2008-11-13 Cameron Zwarich <zwarich@apple.com> > + > + Reviewed by NOBODY (OOPS!). > + > + Bug 21943: Avoid needless reads of temporary values in CTI code > + <https://bugs.webkit.org/show_bug.cgi?id=21943> > + > + If we are writing a value to a temporary register file, we should not > + immediately read it back into the same machine register. This patch > + implements this optimization. > + > + In order to perform this optimization, we need to know the possible > + jump tagets in the CodeBlock. For temporaries, the only problematic > + jump targets are binary logical operators and the ternary conditional > + operator. However, if this optimization were to be extended to local > + variable registers as well, other jump targets would need to be > + included, like switch statement cases and the beginnings of catch > + blocks. > + > + This optimization also requires that the fast case and the slow case > + of an opcode use emitPutResult() on the same register, which we have > + chosen to be eax, as that is the register into which we read the first > + operand of opcodes. In order to make this the case, we needed to add > + some mov instructions to some slow cases of instructions. > + > + The function compileBinaryArithOp() uses distinct machine registers for > + its final result. While it seems possible to modify this code so that > + the same machine register is always used, we disabled the optimization > + for the moment. Also, this optimization is disabled when generating slow > + cases, because some fast cases overwrite the value of eax before jumping > + to the slow case. In the future, it may be possible to perform this > + optimization in slow cases as well, but it did not seem to be a speedup > + when testing an early version of this patch. > + > + * VM/CTI.cpp: > + (JSC::CTI::invalidatePeepholeOptimizations): > + (JSC::CTI::emitGetArg): > + (JSC::CTI::emitGetPutArg): > + (JSC::CTI::emitPutArg): > + (JSC::CTI::emitPutArgConstant): > + (JSC::CTI::emitPutCTIParam): > + (JSC::CTI::emitGetCTIParam): > + (JSC::CTI::emitPutToCallFrameHeader): > + (JSC::CTI::emitGetFromCallFrameHeader): > + (JSC::CTI::emitPutResult): > + (JSC::CTI::emitCTICall): > + (JSC::CTI::CTI): > + (JSC::CTI::compileOpCall): > + (JSC::CTI::compileOpStrictEq): > + (JSC::CTI::emitSlowScriptCheck): > + (JSC::CTI::compileBinaryArithOp): > + (JSC::CTI::privateCompileMainPass): > + (JSC::CTI::privateCompileSlowCases): > + (JSC::CTI::privateCompileGetByIdProto): > + (JSC::CTI::privateCompilePatchGetArrayLength): > + * VM/CTI.h: > + * VM/CodeBlock.h: > + (JSC::CodeBlock::isTemporaryRegisterIndex): > + * bytecompiler/CodeGenerator.cpp: > + (JSC::CodeGenerator::emitLabel): > + > 2008-11-12 Alp Toker <alp@nuanti.com> > > autotools build system fix-up only. Add FloatQuad.h to the source > Index: VM/CTI.cpp > =================================================================== > --- VM/CTI.cpp (revision 38367) > +++ VM/CTI.cpp (working copy) > @@ -173,15 +173,38 @@ static ALWAYS_INLINE uintptr_t asInteger > return reinterpret_cast<uintptr_t>(value); > } > > +ALWAYS_INLINE void CTI::invalidatePeepholeOptimizations() > +{ > + m_lastResultBytecodeRegister = std::numeric_limits<int>::max(); > +} > + > // get arg puts an arg from the SF register array into a h/w register > -ALWAYS_INLINE void CTI::emitGetArg(int src, X86Assembler::RegisterID dst) > +ALWAYS_INLINE void CTI::emitGetArg(int src, X86Assembler::RegisterID dst, unsigned currentInstructionIndex) > { > // TODO: we want to reuse values that are already in registers if we can - add a register allocator! > if (m_codeBlock->isConstantRegisterIndex(src)) { > JSValue* value = m_codeBlock->getConstant(src); > m_jit.movl_i32r(asInteger(value), dst); > - } else > - m_jit.movl_mr(src * sizeof(Register), X86::edi, dst); > + invalidatePeepholeOptimizations(); > + return; > + } > + > + if (src == m_lastResultBytecodeRegister && dst == X86::eax && m_codeBlock->isTemporaryRegisterIndex(src)) { > + bool atJumpTarget = false; > + while (m_jumpTargetsPosition < m_codeBlock->jumpTargets.size() && m_codeBlock->jumpTargets[m_jumpTargetsPosition] <= currentInstructionIndex) { > + if (m_codeBlock->jumpTargets[m_jumpTargetsPosition] == currentInstructionIndex) > + atJumpTarget = true; > + m_jumpTargetsPosition++; > + } > + > + if (!atJumpTarget) { > + invalidatePeepholeOptimizations(); > + return; > + } > + } > + > + m_jit.movl_mr(src * sizeof(Register), X86::edi, dst); > + invalidatePeepholeOptimizations(); > } > > // get arg puts an arg from the SF register array onto the stack, as an arg to a context threaded function. > @@ -194,17 +217,21 @@ ALWAYS_INLINE void CTI::emitGetPutArg(un > m_jit.movl_mr(src * sizeof(Register), X86::edi, scratch); > m_jit.movl_rm(scratch, offset + sizeof(void*), X86::esp); > } > + > + invalidatePeepholeOptimizations(); > } > > // puts an arg onto the stack, as an arg to a context threaded function. > ALWAYS_INLINE void CTI::emitPutArg(X86Assembler::RegisterID src, unsigned offset) > { > m_jit.movl_rm(src, offset + sizeof(void*), X86::esp); > + invalidatePeepholeOptimizations(); > } > > ALWAYS_INLINE void CTI::emitPutArgConstant(unsigned value, unsigned offset) > { > m_jit.movl_i32m(value, offset + sizeof(void*), X86::esp); > + invalidatePeepholeOptimizations(); > } > > ALWAYS_INLINE JSValue* CTI::getConstantImmediateNumericArg(unsigned src) > @@ -219,31 +246,37 @@ ALWAYS_INLINE JSValue* CTI::getConstantI > ALWAYS_INLINE void CTI::emitPutCTIParam(void* value, unsigned name) > { > m_jit.movl_i32m(reinterpret_cast<intptr_t>(value), name * sizeof(void*), X86::esp); > + invalidatePeepholeOptimizations(); > } > > ALWAYS_INLINE void CTI::emitPutCTIParam(X86Assembler::RegisterID from, unsigned name) > { > m_jit.movl_rm(from, name * sizeof(void*), X86::esp); > + invalidatePeepholeOptimizations(); > } > > ALWAYS_INLINE void CTI::emitGetCTIParam(unsigned name, X86Assembler::RegisterID to) > { > m_jit.movl_mr(name * sizeof(void*), X86::esp, to); > + invalidatePeepholeOptimizations(); > } > > ALWAYS_INLINE void CTI::emitPutToCallFrameHeader(X86Assembler::RegisterID from, RegisterFile::CallFrameHeaderEntry entry) > { > m_jit.movl_rm(from, entry * sizeof(Register), X86::edi); > + invalidatePeepholeOptimizations(); > } > > ALWAYS_INLINE void CTI::emitGetFromCallFrameHeader(RegisterFile::CallFrameHeaderEntry entry, X86Assembler::RegisterID to) > { > m_jit.movl_mr(entry * sizeof(Register), X86::edi, to); > + invalidatePeepholeOptimizations(); > } > > ALWAYS_INLINE void CTI::emitPutResult(unsigned dst, X86Assembler::RegisterID from) > { > m_jit.movl_rm(from, dst * sizeof(Register), X86::edi); > + m_lastResultBytecodeRegister = (from == X86::eax) ? dst : std::numeric_limits<int>::max(); > // FIXME: #ifndef NDEBUG, Write the correct m_type to the register. > } > > @@ -351,6 +384,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI:: > #if ENABLE(OPCODE_SAMPLING) > m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot()); > #endif > + invalidatePeepholeOptimizations(); > > return call; > } > @@ -369,6 +403,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI:: > #if ENABLE(OPCODE_SAMPLING) > m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot()); > #endif > + invalidatePeepholeOptimizations(); > > return call; > } > @@ -387,6 +422,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI:: > #if ENABLE(OPCODE_SAMPLING) > m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot()); > #endif > + invalidatePeepholeOptimizations(); > > return call; > } > @@ -405,6 +441,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI:: > #if ENABLE(OPCODE_SAMPLING) > m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot()); > #endif > + invalidatePeepholeOptimizations(); > > return call; > } > @@ -423,6 +460,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI:: > #if ENABLE(OPCODE_SAMPLING) > m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot()); > #endif > + invalidatePeepholeOptimizations(); > > return call; > } > @@ -441,6 +479,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI:: > #if ENABLE(OPCODE_SAMPLING) > m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot()); > #endif > + invalidatePeepholeOptimizations(); > > return call; > } > @@ -459,6 +498,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI:: > #if ENABLE(OPCODE_SAMPLING) > m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot()); > #endif > + invalidatePeepholeOptimizations(); > > return call; > } > @@ -549,6 +589,8 @@ CTI::CTI(JSGlobalData* globalData, CodeB > , m_labels(codeBlock ? codeBlock->instructions.size() : 0) > , m_propertyAccessCompilationInfo(codeBlock ? codeBlock->propertyAccessInstructions.size() : 0) > , m_callStructureStubCompilationInfo(codeBlock ? codeBlock->callLinkInfos.size() : 0) > + , m_lastResultBytecodeRegister(std::numeric_limits<int>::max()) > + , m_jumpTargetsPosition(0) > { > } > > @@ -637,7 +679,7 @@ void CTI::compileOpCall(OpcodeID opcodeI > // Handle eval > X86Assembler::JmpSrc wasEval; > if (opcodeID == op_call_eval) { > - emitGetArg(callee, X86::ecx); > + emitGetArg(callee, X86::ecx, i); > compileOpCallEvalSetupArgs(instruction); > > emitCTICall(instruction, i, Machine::cti_op_call_eval); > @@ -647,7 +689,7 @@ void CTI::compileOpCall(OpcodeID opcodeI > > // This plants a check for a cached JSFunction value, so we can plant a fast link to the callee. > // This deliberately leaves the callee in ecx, used when setting up the stack frame below > - emitGetArg(callee, X86::ecx); > + emitGetArg(callee, X86::ecx, i); > m_jit.cmpl_i32r(asInteger(JSImmediate::impossibleValue()), X86::ecx); > X86Assembler::JmpDst addressOfLinkedFunctionCheck = m_jit.label(); > m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i)); > @@ -665,7 +707,7 @@ void CTI::compileOpCall(OpcodeID opcodeI > emitGetPutArg(proto, 12, X86::eax); > emitCTICall(instruction, i, Machine::cti_op_construct_JSConstruct); > emitPutResult(thisRegister); > - emitGetArg(callee, X86::ecx); > + emitGetArg(callee, X86::ecx, i); > } > > // Fast version of stack frame initialization, directly relative to edi. > @@ -700,8 +742,8 @@ void CTI::compileOpStrictEq(Instruction* > unsigned src1 = instruction[2].u.operand; > unsigned src2 = instruction[3].u.operand; > > - emitGetArg(src1, X86::eax); > - emitGetArg(src2, X86::edx); > + emitGetArg(src1, X86::eax, i); > + emitGetArg(src2, X86::edx, i); > > m_jit.testl_i32r(JSImmediate::TagMask, X86::eax); > X86Assembler::JmpSrc firstNotImmediate = m_jit.emitUnlinkedJe(); > @@ -758,6 +800,8 @@ void CTI::emitSlowScriptCheck(Instructio > m_jit.movl_mr(OBJECT_OFFSET(JSGlobalData, machine), X86::ecx, X86::ecx); > m_jit.movl_mr(OBJECT_OFFSET(Machine, m_ticksUntilNextTimeoutCheck), X86::ecx, X86::esi); > m_jit.link(skipTimeout, m_jit.label()); > + > + invalidatePeepholeOptimizations(); > } > > /* > @@ -806,8 +850,8 @@ void CTI::compileBinaryArithOp(OpcodeID > X86Assembler::JmpSrc wasJSNumberCell2; > X86Assembler::JmpSrc wasJSNumberCell2b; > > - emitGetArg(src1, X86::eax); > - emitGetArg(src2, X86::edx); > + emitGetArg(src1, X86::eax, i); > + emitGetArg(src2, X86::edx, i); > > if (types.second().isReusable() && isSSE2Present()) { > ASSERT(types.second().mightBeNumber()); > @@ -946,6 +990,10 @@ void CTI::compileBinaryArithOp(OpcodeID > m_jit.link(wasJSNumberCell1, m_jit.label()); > m_jit.link(wasJSNumberCell1b, m_jit.label()); > } > + > + // FIXME: make the different cases of this function all use eax as the > + // destination register and enable the register caching optimization. > + invalidatePeepholeOptimizations(); > } > > void CTI::compileBinaryArithOpSlowCase(Instruction* vPC, OpcodeID opcodeID, Vector<SlowCaseEntry>::iterator& iter, unsigned dst, unsigned src1, unsigned src2, OperandTypes types, unsigned i) > @@ -1016,7 +1064,7 @@ void CTI::privateCompileMainPass() > if (m_codeBlock->isConstantRegisterIndex(src)) > m_jit.movl_i32r(asInteger(m_codeBlock->getConstant(src)), X86::eax); > else > - emitGetArg(src, X86::eax); > + emitGetArg(src, X86::eax, i); > emitPutResult(instruction[i + 1].u.operand); > i += 3; > break; > @@ -1027,13 +1075,13 @@ void CTI::privateCompileMainPass() > unsigned src2 = instruction[i + 3].u.operand; > > if (JSValue* value = getConstantImmediateNumericArg(src1)) { > - emitGetArg(src2, X86::edx); > + emitGetArg(src2, X86::edx, i); > emitJumpSlowCaseIfNotImmNum(X86::edx, i); > m_jit.addl_i32r(getDeTaggedConstantImmediate(value), X86::edx); > m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), i)); > emitPutResult(dst, X86::edx); > } else if (JSValue* value = getConstantImmediateNumericArg(src2)) { > - emitGetArg(src1, X86::eax); > + emitGetArg(src1, X86::eax, i); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > m_jit.addl_i32r(getDeTaggedConstantImmediate(value), X86::eax); > m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), i)); > @@ -1056,7 +1104,7 @@ void CTI::privateCompileMainPass() > case op_end: { > if (m_codeBlock->needsFullScopeChain) > emitCTICall(instruction + i, i, Machine::cti_op_end); > - emitGetArg(instruction[i + 1].u.operand, X86::eax); > + emitGetArg(instruction[i + 1].u.operand, X86::eax, i); > m_jit.pushl_m(RegisterFile::ReturnPC * static_cast<int>(sizeof(Register)), X86::edi); > m_jit.ret(); > i += 2; > @@ -1070,7 +1118,7 @@ void CTI::privateCompileMainPass() > } > case op_pre_inc: { > int srcDst = instruction[i + 1].u.operand; > - emitGetArg(srcDst, X86::eax); > + emitGetArg(srcDst, X86::eax, i); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > m_jit.addl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::eax); > m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), i)); > @@ -1092,13 +1140,13 @@ void CTI::privateCompileMainPass() > unsigned target = instruction[i + 3].u.operand; > JSValue* src2imm = getConstantImmediateNumericArg(instruction[i + 2].u.operand); > if (src2imm) { > - emitGetArg(instruction[i + 1].u.operand, X86::edx); > + emitGetArg(instruction[i + 1].u.operand, X86::edx, i); > emitJumpSlowCaseIfNotImmNum(X86::edx, i); > m_jit.cmpl_i32r(asInteger(src2imm), X86::edx); > m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJl(), i + 3 + target)); > } else { > - emitGetArg(instruction[i + 1].u.operand, X86::eax); > - emitGetArg(instruction[i + 2].u.operand, X86::edx); > + emitGetArg(instruction[i + 1].u.operand, X86::eax, i); > + emitGetArg(instruction[i + 2].u.operand, X86::edx, i); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > emitJumpSlowCaseIfNotImmNum(X86::edx, i); > m_jit.cmpl_rr(X86::edx, X86::eax); > @@ -1113,13 +1161,13 @@ void CTI::privateCompileMainPass() > unsigned target = instruction[i + 3].u.operand; > JSValue* src2imm = getConstantImmediateNumericArg(instruction[i + 2].u.operand); > if (src2imm) { > - emitGetArg(instruction[i + 1].u.operand, X86::edx); > + emitGetArg(instruction[i + 1].u.operand, X86::edx, i); > emitJumpSlowCaseIfNotImmNum(X86::edx, i); > m_jit.cmpl_i32r(asInteger(src2imm), X86::edx); > m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJle(), i + 3 + target)); > } else { > - emitGetArg(instruction[i + 1].u.operand, X86::eax); > - emitGetArg(instruction[i + 2].u.operand, X86::edx); > + emitGetArg(instruction[i + 1].u.operand, X86::eax, i); > + emitGetArg(instruction[i + 2].u.operand, X86::edx, i); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > emitJumpSlowCaseIfNotImmNum(X86::edx, i); > m_jit.cmpl_rr(X86::edx, X86::eax); > @@ -1139,8 +1187,8 @@ void CTI::privateCompileMainPass() > // to just after the arguments have been loaded into registers 'hotPathBegin', and we generate code > // such that the StructureID & offset are always at the same distance from this. > > - emitGetArg(instruction[i + 1].u.operand, X86::eax); > - emitGetArg(instruction[i + 3].u.operand, X86::edx); > + emitGetArg(instruction[i + 1].u.operand, X86::eax, i); > + emitGetArg(instruction[i + 3].u.operand, X86::edx, i); > > ASSERT(m_codeBlock->propertyAccessInstructions[propertyAccessInstructionIndex].opcodeIndex == i); > X86Assembler::JmpDst hotPathBegin = m_jit.label(); > @@ -1168,7 +1216,7 @@ void CTI::privateCompileMainPass() > // to array-length / prototype access tranpolines, and finally we also the the property-map access offset as a label > // to jump back to if one of these trampolies finds a match. > > - emitGetArg(instruction[i + 2].u.operand, X86::eax); > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); > > ASSERT(m_codeBlock->propertyAccessInstructions[propertyAccessInstructionIndex].opcodeIndex == i); > > @@ -1183,17 +1231,17 @@ void CTI::privateCompileMainPass() > ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, m_jit.label()) == repatchOffsetGetByIdBranchToSlowCase); > > m_jit.movl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax); > - m_jit.movl_mr(repatchGetByIdDefaultOffset, X86::eax, X86::ecx); > + m_jit.movl_mr(repatchGetByIdDefaultOffset, X86::eax, X86::eax); > ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, m_jit.label()) == repatchOffsetGetByIdPropertyMapOffset); > - emitPutResult(instruction[i + 1].u.operand, X86::ecx); > + emitPutResult(instruction[i + 1].u.operand); > > i += 8; > break; > } > case op_instanceof: { > - emitGetArg(instruction[i + 2].u.operand, X86::eax); // value > - emitGetArg(instruction[i + 3].u.operand, X86::ecx); // baseVal > - emitGetArg(instruction[i + 4].u.operand, X86::edx); // proto > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); // value > + emitGetArg(instruction[i + 3].u.operand, X86::ecx, i); // baseVal > + emitGetArg(instruction[i + 4].u.operand, X86::edx, i); // proto > > // check if any are immediates > m_jit.orl_rr(X86::eax, X86::ecx); > @@ -1210,7 +1258,7 @@ void CTI::privateCompileMainPass() > m_jit.movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::edx, X86::edx); > m_jit.subl_mr(OBJECT_OFFSET(StructureID, m_typeInfo.m_type), X86::eax, X86::ecx); > m_jit.subl_mr(OBJECT_OFFSET(StructureID, m_typeInfo.m_type), X86::edx, X86::ecx); > - emitGetArg(instruction[i + 3].u.operand, X86::edx); // reload baseVal > + emitGetArg(instruction[i + 3].u.operand, X86::edx, i); // reload baseVal > m_jit.movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::edx, X86::edx); > m_jit.cmpl_rm(X86::ecx, OBJECT_OFFSET(StructureID, m_typeInfo.m_type), X86::edx); > > @@ -1223,8 +1271,8 @@ void CTI::privateCompileMainPass() > > m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i)); > > - emitGetArg(instruction[i + 2].u.operand, X86::ecx); // reload value > - emitGetArg(instruction[i + 4].u.operand, X86::edx); // reload proto > + emitGetArg(instruction[i + 2].u.operand, X86::ecx, i); // reload value > + emitGetArg(instruction[i + 4].u.operand, X86::edx, i); // reload proto > > // optimistically load true result > m_jit.movl_i32r(asInteger(jsBoolean(true)), X86::eax); > @@ -1270,7 +1318,7 @@ void CTI::privateCompileMainPass() > JSValue* src2Value = getConstantImmediateNumericArg(src2); > int32_t value; > if (src1Value && ((value = JSImmediate::intValue(src1Value)) > 0)) { > - emitGetArg(src2, X86::eax); > + emitGetArg(src2, X86::eax, i); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > emitFastArithDeTagImmediate(X86::eax); > m_jit.imull_i32r(X86::eax, value, X86::eax); > @@ -1278,7 +1326,7 @@ void CTI::privateCompileMainPass() > emitFastArithReTagImmediate(X86::eax); > emitPutResult(dst); > } else if (src2Value && ((value = JSImmediate::intValue(src2Value)) > 0)) { > - emitGetArg(src1, X86::eax); > + emitGetArg(src1, X86::eax, i); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > emitFastArithDeTagImmediate(X86::eax); > m_jit.imull_i32r(X86::eax, value, X86::eax); > @@ -1317,7 +1365,7 @@ void CTI::privateCompileMainPass() > case op_put_global_var: { > JSVariableObject* globalObject = static_cast<JSVariableObject*>(instruction[i + 1].u.jsCell); > m_jit.movl_i32r(asInteger(globalObject), X86::eax); > - emitGetArg(instruction[i + 3].u.operand, X86::edx); > + emitGetArg(instruction[i + 3].u.operand, X86::edx, i); > emitPutVariableObjectRegister(X86::edx, X86::eax, instruction[i + 2].u.operand); > i += 4; > break; > @@ -1325,7 +1373,7 @@ void CTI::privateCompileMainPass() > case op_get_scoped_var: { > int skip = instruction[i + 3].u.operand + m_codeBlock->needsFullScopeChain; > > - emitGetArg(RegisterFile::ScopeChain, X86::eax); > + emitGetArg(RegisterFile::ScopeChain, X86::eax, i); > while (skip--) > m_jit.movl_mr(OBJECT_OFFSET(ScopeChainNode, next), X86::eax, X86::eax); > > @@ -1338,8 +1386,8 @@ void CTI::privateCompileMainPass() > case op_put_scoped_var: { > int skip = instruction[i + 2].u.operand + m_codeBlock->needsFullScopeChain; > > - emitGetArg(RegisterFile::ScopeChain, X86::edx); > - emitGetArg(instruction[i + 3].u.operand, X86::eax); > + emitGetArg(RegisterFile::ScopeChain, X86::edx, i); > + emitGetArg(instruction[i + 3].u.operand, X86::eax, i); > while (skip--) > m_jit.movl_mr(OBJECT_OFFSET(ScopeChainNode, next), X86::edx, X86::edx); > > @@ -1365,13 +1413,13 @@ void CTI::privateCompileMainPass() > emitCTICall(instruction + i, i, Machine::cti_op_ret_scopeChain); > > // Return the result in %eax. > - emitGetArg(instruction[i + 1].u.operand, X86::eax); > + emitGetArg(instruction[i + 1].u.operand, X86::eax, i); > > // Grab the return address. > - emitGetArg(RegisterFile::ReturnPC, X86::edx); > + emitGetArg(RegisterFile::ReturnPC, X86::edx, i); > > // Restore our caller's "r". > - emitGetArg(RegisterFile::CallerFrame, X86::edi); > + emitGetArg(RegisterFile::CallerFrame, X86::edi, i); > > // Return. > m_jit.pushl_r(X86::edx); > @@ -1398,8 +1446,8 @@ void CTI::privateCompileMainPass() > break; > } > case op_construct_verify: { > - emitGetArg(instruction[i + 1].u.operand, X86::eax); > - > + emitGetArg(instruction[i + 1].u.operand, X86::eax, i); > + > m_jit.testl_i32r(JSImmediate::TagMask, X86::eax); > X86Assembler::JmpSrc isImmediate = m_jit.emitUnlinkedJne(); > m_jit.movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::eax, X86::ecx); > @@ -1407,7 +1455,7 @@ void CTI::privateCompileMainPass() > X86Assembler::JmpSrc isObject = m_jit.emitUnlinkedJe(); > > m_jit.link(isImmediate, m_jit.label()); > - emitGetArg(instruction[i + 2].u.operand, X86::eax); > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); > emitPutResult(instruction[i + 1].u.operand); > m_jit.link(isObject, m_jit.label()); > > @@ -1415,8 +1463,8 @@ void CTI::privateCompileMainPass() > break; > } > case op_get_by_val: { > - emitGetArg(instruction[i + 2].u.operand, X86::eax); > - emitGetArg(instruction[i + 3].u.operand, X86::edx); > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); > + emitGetArg(instruction[i + 3].u.operand, X86::edx, i); > emitJumpSlowCaseIfNotImmNum(X86::edx, i); > emitFastArithImmToInt(X86::edx); > m_jit.testl_i32r(JSImmediate::TagMask, X86::eax); > @@ -1450,8 +1498,8 @@ void CTI::privateCompileMainPass() > break; > } > case op_put_by_val: { > - emitGetArg(instruction[i + 1].u.operand, X86::eax); > - emitGetArg(instruction[i + 2].u.operand, X86::edx); > + emitGetArg(instruction[i + 1].u.operand, X86::eax, i); > + emitGetArg(instruction[i + 2].u.operand, X86::edx, i); > emitJumpSlowCaseIfNotImmNum(X86::edx, i); > emitFastArithImmToInt(X86::edx); > m_jit.testl_i32r(JSImmediate::TagMask, X86::eax); > @@ -1474,7 +1522,7 @@ void CTI::privateCompileMainPass() > > // All good - put the value into the array. > m_jit.link(inFastVector, m_jit.label()); > - emitGetArg(instruction[i + 3].u.operand, X86::eax); > + emitGetArg(instruction[i + 3].u.operand, X86::eax, i); > m_jit.movl_rm(X86::eax, OBJECT_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*)); > i += 4; > break; > @@ -1484,7 +1532,7 @@ void CTI::privateCompileMainPass() > emitSlowScriptCheck(instruction + i, i); > > unsigned target = instruction[i + 2].u.operand; > - emitGetArg(instruction[i + 1].u.operand, X86::eax); > + emitGetArg(instruction[i + 1].u.operand, X86::eax, i); > > m_jit.cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::eax); > X86Assembler::JmpSrc isZero = m_jit.emitUnlinkedJe(); > @@ -1509,7 +1557,7 @@ void CTI::privateCompileMainPass() > break; > } > case op_negate: { > - emitGetArg(instruction[i + 2].u.operand, X86::eax); > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); > m_jit.testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax); > X86Assembler::JmpSrc notImmediate = m_jit.emitUnlinkedJe(); > > @@ -1599,7 +1647,7 @@ void CTI::privateCompileMainPass() > CTI_COMPILE_BINARY_OP(op_div) > case op_pre_dec: { > int srcDst = instruction[i + 1].u.operand; > - emitGetArg(srcDst, X86::eax); > + emitGetArg(srcDst, X86::eax, i); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > m_jit.subl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::eax); > m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), i)); > @@ -1611,13 +1659,13 @@ void CTI::privateCompileMainPass() > unsigned target = instruction[i + 3].u.operand; > JSValue* src2imm = getConstantImmediateNumericArg(instruction[i + 2].u.operand); > if (src2imm) { > - emitGetArg(instruction[i + 1].u.operand, X86::edx); > + emitGetArg(instruction[i + 1].u.operand, X86::edx, i); > emitJumpSlowCaseIfNotImmNum(X86::edx, i); > m_jit.cmpl_i32r(asInteger(src2imm), X86::edx); > m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJge(), i + 3 + target)); > } else { > - emitGetArg(instruction[i + 1].u.operand, X86::eax); > - emitGetArg(instruction[i + 2].u.operand, X86::edx); > + emitGetArg(instruction[i + 1].u.operand, X86::eax, i); > + emitGetArg(instruction[i + 2].u.operand, X86::edx, i); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > emitJumpSlowCaseIfNotImmNum(X86::edx, i); > m_jit.cmpl_rr(X86::edx, X86::eax); > @@ -1627,7 +1675,7 @@ void CTI::privateCompileMainPass() > break; > } > case op_not: { > - emitGetArg(instruction[i + 2].u.operand, X86::eax); > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); > m_jit.xorl_i8r(JSImmediate::FullTagTypeBool, X86::eax); > m_jit.testl_i32r(JSImmediate::FullTagTypeMask, X86::eax); // i8? > m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i)); > @@ -1638,7 +1686,7 @@ void CTI::privateCompileMainPass() > } > case op_jfalse: { > unsigned target = instruction[i + 2].u.operand; > - emitGetArg(instruction[i + 1].u.operand, X86::eax); > + emitGetArg(instruction[i + 1].u.operand, X86::eax, i); > > m_jit.cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::eax); > m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJe(), i + 2 + target)); > @@ -1658,7 +1706,7 @@ void CTI::privateCompileMainPass() > unsigned src = instruction[i + 1].u.operand; > unsigned target = instruction[i + 2].u.operand; > > - emitGetArg(src, X86::eax); > + emitGetArg(src, X86::eax, i); > m_jit.testl_i32r(JSImmediate::TagMask, X86::eax); > X86Assembler::JmpSrc isImmediate = m_jit.emitUnlinkedJnz(); > > @@ -1688,7 +1736,7 @@ void CTI::privateCompileMainPass() > unsigned src = instruction[i + 1].u.operand; > unsigned target = instruction[i + 2].u.operand; > > - emitGetArg(src, X86::eax); > + emitGetArg(src, X86::eax, i); > m_jit.testl_i32r(JSImmediate::TagMask, X86::eax); > X86Assembler::JmpSrc isImmediate = m_jit.emitUnlinkedJnz(); > > @@ -1716,7 +1764,7 @@ void CTI::privateCompileMainPass() > } > case op_post_inc: { > int srcDst = instruction[i + 2].u.operand; > - emitGetArg(srcDst, X86::eax); > + emitGetArg(srcDst, X86::eax, i); > m_jit.movl_rr(X86::eax, X86::edx); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > m_jit.addl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::edx); > @@ -1750,8 +1798,8 @@ void CTI::privateCompileMainPass() > break; > } > case op_eq: { > - emitGetArg(instruction[i + 2].u.operand, X86::eax); > - emitGetArg(instruction[i + 3].u.operand, X86::edx); > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); > + emitGetArg(instruction[i + 3].u.operand, X86::edx, i); > emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, i); > m_jit.cmpl_rr(X86::edx, X86::eax); > m_jit.sete_r(X86::eax); > @@ -1762,8 +1810,8 @@ void CTI::privateCompileMainPass() > break; > } > case op_lshift: { > - emitGetArg(instruction[i + 2].u.operand, X86::eax); > - emitGetArg(instruction[i + 3].u.operand, X86::ecx); > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); > + emitGetArg(instruction[i + 3].u.operand, X86::ecx, i); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > emitJumpSlowCaseIfNotImmNum(X86::ecx, i); > emitFastArithImmToInt(X86::eax); > @@ -1779,18 +1827,18 @@ void CTI::privateCompileMainPass() > unsigned src2 = instruction[i + 3].u.operand; > unsigned dst = instruction[i + 1].u.operand; > if (JSValue* value = getConstantImmediateNumericArg(src1)) { > - emitGetArg(src2, X86::eax); > + emitGetArg(src2, X86::eax, i); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > m_jit.andl_i32r(asInteger(value), X86::eax); // FIXME: make it more obvious this is relying on the format of JSImmediate > emitPutResult(dst); > } else if (JSValue* value = getConstantImmediateNumericArg(src2)) { > - emitGetArg(src1, X86::eax); > + emitGetArg(src1, X86::eax, i); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > m_jit.andl_i32r(asInteger(value), X86::eax); > emitPutResult(dst); > } else { > - emitGetArg(src1, X86::eax); > - emitGetArg(src2, X86::edx); > + emitGetArg(src1, X86::eax, i); > + emitGetArg(src2, X86::edx, i); > m_jit.andl_rr(X86::edx, X86::eax); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > emitPutResult(dst); > @@ -1799,8 +1847,8 @@ void CTI::privateCompileMainPass() > break; > } > case op_rshift: { > - emitGetArg(instruction[i + 2].u.operand, X86::eax); > - emitGetArg(instruction[i + 3].u.operand, X86::ecx); > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); > + emitGetArg(instruction[i + 3].u.operand, X86::ecx, i); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > emitJumpSlowCaseIfNotImmNum(X86::ecx, i); > emitFastArithImmToInt(X86::ecx); > @@ -1811,7 +1859,7 @@ void CTI::privateCompileMainPass() > break; > } > case op_bitnot: { > - emitGetArg(instruction[i + 2].u.operand, X86::eax); > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > m_jit.xorl_i8r(~JSImmediate::TagBitTypeInteger, X86::eax); > emitPutResult(instruction[i + 1].u.operand); > @@ -1836,8 +1884,8 @@ void CTI::privateCompileMainPass() > break; > } > case op_mod: { > - emitGetArg(instruction[i + 2].u.operand, X86::eax); > - emitGetArg(instruction[i + 3].u.operand, X86::ecx); > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); > + emitGetArg(instruction[i + 3].u.operand, X86::ecx, i); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > emitJumpSlowCaseIfNotImmNum(X86::ecx, i); > emitFastArithDeTagImmediate(X86::eax); > @@ -1852,7 +1900,7 @@ void CTI::privateCompileMainPass() > } > case op_jtrue: { > unsigned target = instruction[i + 2].u.operand; > - emitGetArg(instruction[i + 1].u.operand, X86::eax); > + emitGetArg(instruction[i + 1].u.operand, X86::eax, i); > > m_jit.cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::eax); > X86Assembler::JmpSrc isZero = m_jit.emitUnlinkedJe(); > @@ -1870,8 +1918,8 @@ void CTI::privateCompileMainPass() > } > CTI_COMPILE_BINARY_OP(op_less) > case op_neq: { > - emitGetArg(instruction[i + 2].u.operand, X86::eax); > - emitGetArg(instruction[i + 3].u.operand, X86::edx); > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); > + emitGetArg(instruction[i + 3].u.operand, X86::edx, i); > emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, i); > m_jit.cmpl_rr(X86::eax, X86::edx); > > @@ -1886,7 +1934,7 @@ void CTI::privateCompileMainPass() > } > case op_post_dec: { > int srcDst = instruction[i + 2].u.operand; > - emitGetArg(srcDst, X86::eax); > + emitGetArg(srcDst, X86::eax, i); > m_jit.movl_rr(X86::eax, X86::edx); > emitJumpSlowCaseIfNotImmNum(X86::eax, i); > m_jit.subl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::edx); > @@ -1898,8 +1946,8 @@ void CTI::privateCompileMainPass() > } > CTI_COMPILE_BINARY_OP(op_urshift) > case op_bitxor: { > - emitGetArg(instruction[i + 2].u.operand, X86::eax); > - emitGetArg(instruction[i + 3].u.operand, X86::edx); > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); > + emitGetArg(instruction[i + 3].u.operand, X86::edx, i); > emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, i); > m_jit.xorl_rr(X86::edx, X86::eax); > emitFastArithReTagImmediate(X86::eax); > @@ -1916,8 +1964,8 @@ void CTI::privateCompileMainPass() > break; > } > case op_bitor: { > - emitGetArg(instruction[i + 2].u.operand, X86::eax); > - emitGetArg(instruction[i + 3].u.operand, X86::edx); > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); > + emitGetArg(instruction[i + 3].u.operand, X86::edx, i); > emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, i); > m_jit.orl_rr(X86::edx, X86::eax); > emitPutResult(instruction[i + 1].u.operand); > @@ -1983,7 +2031,7 @@ void CTI::privateCompileMainPass() > break; > } > case op_to_jsnumber: { > - emitGetArg(instruction[i + 2].u.operand, X86::eax); > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); > > m_jit.testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax); > X86Assembler::JmpSrc wasImmediate = m_jit.emitUnlinkedJnz(); > @@ -2139,7 +2187,7 @@ void CTI::privateCompileMainPass() > unsigned dst = instruction[i + 1].u.operand; > unsigned src1 = instruction[i + 2].u.operand; > > - emitGetArg(src1, X86::eax); > + emitGetArg(src1, X86::eax, i); > m_jit.testl_i32r(JSImmediate::TagMask, X86::eax); > X86Assembler::JmpSrc isImmediate = m_jit.emitUnlinkedJnz(); > > @@ -2169,7 +2217,7 @@ void CTI::privateCompileMainPass() > unsigned dst = instruction[i + 1].u.operand; > unsigned src1 = instruction[i + 2].u.operand; > > - emitGetArg(src1, X86::eax); > + emitGetArg(src1, X86::eax, i); > m_jit.testl_i32r(JSImmediate::TagMask, X86::eax); > X86Assembler::JmpSrc isImmediate = m_jit.emitUnlinkedJnz(); > > @@ -2226,7 +2274,7 @@ void CTI::privateCompileMainPass() > break; > } > case op_convert_this: { > - emitGetArg(instruction[i + 1].u.operand, X86::eax); > + emitGetArg(instruction[i + 1].u.operand, X86::eax, i); > > emitJumpSlowCaseIfNotJSCell(X86::eax, i); > m_jit.movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::eax, X86::edx); > @@ -2302,6 +2350,9 @@ void CTI::privateCompileSlowCases() > > Instruction* instruction = m_codeBlock->instructions.begin(); > for (Vector<SlowCaseEntry>::iterator iter = m_slowCases.begin(); iter != m_slowCases.end(); ++iter) { > + // FIXME: enable peephole optimizations for slow cases when applicable > + invalidatePeepholeOptimizations(); > + > unsigned i = iter->to; > switch (OpcodeID opcodeID = m_machine->getOpcodeID(instruction[i].u.opcode)) { > case op_convert_this: { > @@ -2372,8 +2423,9 @@ void CTI::privateCompileSlowCases() > // Check whether the value loaded is zero; if so we need to return undefined. > m_jit.testl_rr(X86::ecx, X86::ecx); > m_jit.link(m_jit.emitUnlinkedJe(), beginGetByValSlow); > - emitPutResult(instruction[i + 1].u.operand, X86::ecx); > - > + m_jit.movl_rr(X86::ecx, X86::eax); > + emitPutResult(instruction[i + 1].u.operand, X86::eax); > + > i += 4; > break; > } > @@ -2404,8 +2456,8 @@ void CTI::privateCompileSlowCases() > X86Assembler::JmpSrc notImm1 = iter->from; > X86Assembler::JmpSrc notImm2 = (++iter)->from; > m_jit.link((++iter)->from, m_jit.label()); > - emitGetArg(instruction[i + 2].u.operand, X86::eax); > - emitGetArg(instruction[i + 3].u.operand, X86::ecx); > + emitGetArg(instruction[i + 2].u.operand, X86::eax, i); > + emitGetArg(instruction[i + 3].u.operand, X86::ecx, i); > m_jit.link(notImm1, m_jit.label()); > m_jit.link(notImm2, m_jit.label()); > emitPutArg(X86::eax, 0); > @@ -2528,7 +2580,7 @@ void CTI::privateCompileSlowCases() > m_jit.link((++iter)->from, m_jit.label()); > emitFastArithIntToImmNoCheck(X86::edx); > m_jit.link(notImm, m_jit.label()); > - emitGetArg(instruction[i + 3].u.operand, X86::ecx); > + emitGetArg(instruction[i + 3].u.operand, X86::ecx, i); > emitPutArg(X86::eax, 0); > emitPutArg(X86::edx, 4); > emitPutArg(X86::ecx, 8); > @@ -2538,7 +2590,7 @@ void CTI::privateCompileSlowCases() > // slow cases for immediate int accesses to arrays > m_jit.link((++iter)->from, m_jit.label()); > m_jit.link((++iter)->from, m_jit.label()); > - emitGetArg(instruction[i + 3].u.operand, X86::ecx); > + emitGetArg(instruction[i + 3].u.operand, X86::ecx, i); > emitPutArg(X86::eax, 0); > emitPutArg(X86::edx, 4); > emitPutArg(X86::ecx, 8); > @@ -2618,8 +2670,8 @@ void CTI::privateCompileSlowCases() > m_jit.link((++iter)->from, m_jit.label()); > emitPutArg(X86::eax, 0); > emitCTICall(instruction + i, i, Machine::cti_op_post_inc); > - emitPutResult(instruction[i + 1].u.operand); > emitPutResult(srcDst, X86::edx); > + emitPutResult(instruction[i + 1].u.operand); > i += 3; > break; > } > @@ -2673,8 +2725,8 @@ void CTI::privateCompileSlowCases() > m_jit.link((++iter)->from, m_jit.label()); > emitPutArg(X86::eax, 0); > emitCTICall(instruction + i, i, Machine::cti_op_post_dec); > - emitPutResult(instruction[i + 1].u.operand); > emitPutResult(srcDst, X86::edx); > + emitPutResult(instruction[i + 1].u.operand); > i += 3; > break; > } > @@ -2794,7 +2846,7 @@ void CTI::privateCompileSlowCases() > if (opcodeID == op_construct) { > emitCTICall(instruction, i, Machine::cti_op_construct_JSConstruct); > emitPutResult(registerOffset - RegisterFile::CallFrameHeaderSize - argCount); > - emitGetArg(callee, X86::ecx); > + emitGetArg(callee, X86::ecx, i); > } > > // Load the callee CodeBlock* into eax > @@ -2803,7 +2855,7 @@ void CTI::privateCompileSlowCases() > m_jit.testl_rr(X86::eax, X86::eax); > X86Assembler::JmpSrc hasCodeBlockForLink = m_jit.emitUnlinkedJne(); > emitCTICall(instruction + i, i, Machine::cti_op_call_JSFunction); > - emitGetArg(callee, X86::ecx); > + emitGetArg(callee, X86::ecx, i); > m_jit.link(hasCodeBlockForLink, m_jit.label()); > > // Speculatively roll the callframe, assuming argCount will match the arity. > @@ -2815,7 +2867,7 @@ void CTI::privateCompileSlowCases() > X86Assembler::JmpSrc arityCheckOkayForLink = m_jit.emitUnlinkedJe(); > emitPutArg(X86::eax, 12); > emitCTICall(instruction + i, i, Machine::cti_op_call_arityCheck); > - emitGetArg(callee - registerOffset, X86::ecx); > + emitGetArg(callee - registerOffset, X86::ecx, i); > m_jit.movl_rr(X86::edx, X86::edi); > m_jit.link(arityCheckOkayForLink, m_jit.label()); > > @@ -2860,7 +2912,7 @@ void CTI::privateCompileSlowCases() > if (opcodeID == op_construct) { > emitCTICall(instruction, i, Machine::cti_op_construct_JSConstruct); > emitPutResult(registerOffset - RegisterFile::CallFrameHeaderSize - argCount); > - emitGetArg(callee, X86::ecx); > + emitGetArg(callee, X86::ecx, i); > } > > // Load the callee CodeBlock* into eax > @@ -2869,7 +2921,7 @@ void CTI::privateCompileSlowCases() > m_jit.testl_rr(X86::eax, X86::eax); > X86Assembler::JmpSrc hasCodeBlock = m_jit.emitUnlinkedJne(); > emitCTICall(instruction + i, i, Machine::cti_op_call_JSFunction); > - emitGetArg(callee, X86::ecx); > + emitGetArg(callee, X86::ecx, i); > m_jit.link(hasCodeBlock, m_jit.label()); > > // Speculatively roll the callframe, assuming argCount will match the arity. > @@ -2881,7 +2933,7 @@ void CTI::privateCompileSlowCases() > X86Assembler::JmpSrc arityCheckOkay = m_jit.emitUnlinkedJe(); > emitPutArg(X86::eax, 12); > emitCTICall(instruction + i, i, Machine::cti_op_call_arityCheck); > - emitGetArg(callee - registerOffset, X86::ecx); > + emitGetArg(callee - registerOffset, X86::ecx, i); > m_jit.movl_rr(X86::edx, X86::edi); > m_jit.link(arityCheckOkay, m_jit.label()); > > @@ -3080,7 +3132,7 @@ void CTI::privateCompileGetByIdProto(Str > X86Assembler::JmpSrc failureCases3 = m_jit.emitUnlinkedJne(); > > // Checks out okay! - getDirectOffset > - m_jit.movl_mr(cachedOffset * sizeof(JSValue*), X86::edx, X86::ecx); > + m_jit.movl_mr(cachedOffset * sizeof(JSValue*), X86::edx, X86::eax); > > X86Assembler::JmpSrc success = m_jit.emitUnlinkedJmp(); > > @@ -3441,6 +3493,7 @@ void CTI::privateCompilePatchGetArrayLen > > m_jit.addl_rr(X86::ecx, X86::ecx); > m_jit.addl_i8r(1, X86::ecx); > + m_jit.movl_rr(X86::ecx, X86::eax); > X86Assembler::JmpSrc success = m_jit.emitUnlinkedJmp(); > > void* code = m_jit.copy(); > Index: VM/CTI.h > =================================================================== > --- VM/CTI.h (revision 38367) > +++ VM/CTI.h (working copy) > @@ -374,7 +374,7 @@ namespace JSC { > void compileBinaryArithOp(OpcodeID, unsigned dst, unsigned src1, unsigned src2, OperandTypes opi, unsigned i); > void compileBinaryArithOpSlowCase(Instruction*, OpcodeID, Vector<SlowCaseEntry>::iterator& iter, unsigned dst, unsigned src1, unsigned src2, OperandTypes opi, unsigned i); > > - void emitGetArg(int src, X86Assembler::RegisterID dst); > + void emitGetArg(int src, X86Assembler::RegisterID dst, unsigned i); > void emitGetPutArg(unsigned src, unsigned offset, X86Assembler::RegisterID scratch); > void emitPutArg(X86Assembler::RegisterID src, unsigned offset); > void emitPutArgConstant(unsigned value, unsigned offset); > @@ -430,6 +430,8 @@ namespace JSC { > void printOpcodeOperandTypes(unsigned src1, unsigned src2); > #endif > > + void invalidatePeepholeOptimizations(); > + > X86Assembler m_jit; > Machine* m_machine; > JSGlobalData* m_globalData; > @@ -456,9 +458,11 @@ namespace JSC { > Vector<SlowCaseEntry> m_slowCases; > Vector<SwitchRecord> m_switches; > > + int m_lastResultBytecodeRegister; > + unsigned m_jumpTargetsPosition; > + > // This limit comes from the limit set in PCRE > static const int MaxPatternSize = (1 << 16); > - > }; > } > > Index: VM/CodeBlock.h > =================================================================== > --- VM/CodeBlock.h (revision 38367) > +++ VM/CodeBlock.h (working copy) > @@ -265,6 +265,11 @@ namespace JSC { > return constantRegisters[index - numVars].getJSValue(); > } > > + ALWAYS_INLINE bool isTemporaryRegisterIndex(int index) > + { > + return index >= numVars + numConstants; > + } > + > #if !defined(NDEBUG) || ENABLE_OPCODE_SAMPLING > void dump(ExecState*) const; > void printStructureIDs(const Instruction*) const; > @@ -332,6 +337,8 @@ namespace JSC { > HashMap<void*, unsigned> ctiReturnAddressVPCMap; > #endif > > + Vector<unsigned> jumpTargets; > + > EvalCodeCache evalCodeCache; > > private: > Index: bytecompiler/CodeGenerator.cpp > =================================================================== > --- bytecompiler/CodeGenerator.cpp (revision 38367) > +++ bytecompiler/CodeGenerator.cpp (working copy) > @@ -497,11 +497,22 @@ PassRefPtr<LabelID> CodeGenerator::newLa > > PassRefPtr<LabelID> CodeGenerator::emitLabel(LabelID* l0) > { > - l0->setLocation(instructions().size()); > - > + unsigned newLabelIndex = instructions().size(); > + l0->setLocation(newLabelIndex); > + > + if (m_codeBlock->jumpTargets.size() != 0) { > + unsigned lastLabelIndex = m_codeBlock->jumpTargets.last(); > + ASSERT(lastLabelIndex <= newLabelIndex); > + if (newLabelIndex == lastLabelIndex) { > + // Peephole optimization has already been disabled by emitting the last label > + return l0; > + } > + } > + > + m_codeBlock->jumpTargets.append(newLabelIndex); > + > // This disables peephole optimizations when an instruction is a jump target > m_lastOpcodeID = op_end; > - > return l0; > } > 98606 3 zwarich 2008-11-13 03:27:17 -0800 Landed in r38368. 25120 2008-11-13 02:24:30 -0800 2008-11-13 03:02:43 -0800 Proposed patch temps.diff text/plain 49440 zwarich SW5kZXg6IENoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBDaGFuZ2VMb2cJKHJldmlzaW9uIDM4MzY3 KQorKysgQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsNjQgQEAKKzIwMDgtMTEt MTMgIENhbWVyb24gWndhcmljaCAgPHp3YXJpY2hAYXBwbGUuY29tPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEJ1ZyAyMTk0MzogQXZvaWQgbmVlZGxl c3MgcmVhZHMgb2YgdGVtcG9yYXJ5IHZhbHVlcyBpbiBDVEkgY29kZQorICAgICAgICA8aHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxOTQzPgorCisgICAgICAgIElmIHdl IGFyZSB3cml0aW5nIGEgdmFsdWUgdG8gYSB0ZW1wb3JhcnkgcmVnaXN0ZXIgZmlsZSwgd2Ugc2hv dWxkIG5vdAorICAgICAgICBpbW1lZGlhdGVseSByZWFkIGl0IGJhY2sgaW50byB0aGUgc2FtZSBt YWNoaW5lIHJlZ2lzdGVyLiBUaGlzIHBhdGNoCisgICAgICAgIGltcGxlbWVudHMgdGhpcyBvcHRp bWl6YXRpb24uCisKKyAgICAgICAgSW4gb3JkZXIgdG8gcGVyZm9ybSB0aGlzIG9wdGltaXphdGlv biwgd2UgbmVlZCB0byBrbm93IHRoZSBwb3NzaWJsZQorICAgICAgICBqdW1wIHRhZ2V0cyBpbiB0 aGUgQ29kZUJsb2NrLiBGb3IgdGVtcG9yYXJpZXMsIHRoZSBvbmx5IHByb2JsZW1hdGljCisgICAg ICAgIGp1bXAgdGFyZ2V0cyBhcmUgYmluYXJ5IGxvZ2ljYWwgb3BlcmF0b3JzIGFuZCB0aGUgdGVy bmFyeSBjb25kaXRpb25hbAorICAgICAgICBvcGVyYXRvci4gSG93ZXZlciwgaWYgdGhpcyBvcHRp bWl6YXRpb24gd2VyZSB0byBiZSBleHRlbmRlZCB0byBsb2NhbCAKKyAgICAgICAgdmFyaWFibGUg cmVnaXN0ZXJzIGFzIHdlbGwsIG90aGVyIGp1bXAgdGFyZ2V0cyB3b3VsZCBuZWVkIHRvIGJlCisg ICAgICAgIGluY2x1ZGVkLCBsaWtlIHN3aXRjaCBzdGF0ZW1lbnQgY2FzZXMgYW5kIHRoZSBiZWdp bm5pbmdzIG9mIGNhdGNoCisgICAgICAgIGJsb2Nrcy4KKworICAgICAgICBUaGlzIG9wdGltaXph dGlvbiBhbHNvIHJlcXVpcmVzIHRoYXQgdGhlIGZhc3QgY2FzZSBhbmQgdGhlIHNsb3cgY2FzZQor ICAgICAgICBvZiBhbiBvcGNvZGUgdXNlIGVtaXRQdXRSZXN1bHQoKSBvbiB0aGUgc2FtZSByZWdp c3Rlciwgd2hpY2ggd2UgaGF2ZQorICAgICAgICBjaG9zZW4gdG8gYmUgZWF4LCBhcyB0aGF0IGlz IHRoZSByZWdpc3RlciBpbnRvIHdoaWNoIHdlIHJlYWQgdGhlIGZpcnN0CisgICAgICAgIG9wZXJh bmQgb2Ygb3Bjb2Rlcy4gSW4gb3JkZXIgdG8gbWFrZSB0aGlzIHRoZSBjYXNlLCB3ZSBuZWVkZWQg dG8gYWRkCisgICAgICAgIHNvbWUgbW92IGluc3RydWN0aW9ucyB0byBzb21lIHNsb3cgY2FzZXMg b2YgaW5zdHJ1Y3Rpb25zLgorCisgICAgICAgIFRoZSBmdW5jdGlvbiBjb21waWxlQmluYXJ5QXJp dGhPcCgpIHVzZXMgZGlzdGluY3QgbWFjaGluZSByZWdpc3RlcnMgZm9yCisgICAgICAgIGl0cyBm aW5hbCByZXN1bHQuIFdoaWxlIGl0IHNlZW1zIHBvc3NpYmxlIHRvIG1vZGlmeSB0aGlzIGNvZGUg c28gdGhhdAorICAgICAgICB0aGUgc2FtZSBtYWNoaW5lIHJlZ2lzdGVyIGlzIGFsd2F5cyB1c2Vk LCB3ZSBkaXNhYmxlZCB0aGUgb3B0aW1pemF0aW9uCisgICAgICAgIGZvciB0aGUgbW9tZW50LiBB bHNvLCB0aGlzIG9wdGltaXphdGlvbiBpcyBkaXNhYmxlZCB3aGVuIGdlbmVyYXRpbmcgc2xvdwor ICAgICAgICBjYXNlcywgYmVjYXVzZSBzb21lIGZhc3QgY2FzZXMgb3ZlcndyaXRlIHRoZSB2YWx1 ZSBvZiBlYXggYmVmb3JlIGp1bXBpbmcKKyAgICAgICAgdG8gdGhlIHNsb3cgY2FzZS4gSW4gdGhl IGZ1dHVyZSwgaXQgbWF5IGJlIHBvc3NpYmxlIHRvIHBlcmZvcm0gdGhpcworICAgICAgICBvcHRp bWl6YXRpb24gaW4gc2xvdyBjYXNlcyBhcyB3ZWxsLCBidXQgaXQgZGlkIG5vdCBzZWVtIHRvIGJl IGEgc3BlZWR1cAorICAgICAgICB3aGVuIHRlc3RpbmcgYW4gZWFybHkgdmVyc2lvbiBvZiB0aGlz IHBhdGNoLgorCisgICAgICAgICogVk0vQ1RJLmNwcDoKKyAgICAgICAgKEpTQzo6Q1RJOjppbnZh bGlkYXRlUGVlcGhvbGVPcHRpbWl6YXRpb25zKToKKyAgICAgICAgKEpTQzo6Q1RJOjplbWl0R2V0 QXJnKToKKyAgICAgICAgKEpTQzo6Q1RJOjplbWl0R2V0UHV0QXJnKToKKyAgICAgICAgKEpTQzo6 Q1RJOjplbWl0UHV0QXJnKToKKyAgICAgICAgKEpTQzo6Q1RJOjplbWl0UHV0QXJnQ29uc3RhbnQp OgorICAgICAgICAoSlNDOjpDVEk6OmVtaXRQdXRDVElQYXJhbSk6CisgICAgICAgIChKU0M6OkNU STo6ZW1pdEdldENUSVBhcmFtKToKKyAgICAgICAgKEpTQzo6Q1RJOjplbWl0UHV0VG9DYWxsRnJh bWVIZWFkZXIpOgorICAgICAgICAoSlNDOjpDVEk6OmVtaXRHZXRGcm9tQ2FsbEZyYW1lSGVhZGVy KToKKyAgICAgICAgKEpTQzo6Q1RJOjplbWl0UHV0UmVzdWx0KToKKyAgICAgICAgKEpTQzo6Q1RJ OjplbWl0Q1RJQ2FsbCk6CisgICAgICAgIChKU0M6OkNUSTo6Q1RJKToKKyAgICAgICAgKEpTQzo6 Q1RJOjpjb21waWxlT3BDYWxsKToKKyAgICAgICAgKEpTQzo6Q1RJOjpjb21waWxlT3BTdHJpY3RF cSk6CisgICAgICAgIChKU0M6OkNUSTo6ZW1pdFNsb3dTY3JpcHRDaGVjayk6CisgICAgICAgIChK U0M6OkNUSTo6Y29tcGlsZUJpbmFyeUFyaXRoT3ApOgorICAgICAgICAoSlNDOjpDVEk6OnByaXZh dGVDb21waWxlTWFpblBhc3MpOgorICAgICAgICAoSlNDOjpDVEk6OnByaXZhdGVDb21waWxlU2xv d0Nhc2VzKToKKyAgICAgICAgKEpTQzo6Q1RJOjpwcml2YXRlQ29tcGlsZUdldEJ5SWRQcm90byk6 CisgICAgICAgIChKU0M6OkNUSTo6cHJpdmF0ZUNvbXBpbGVQYXRjaEdldEFycmF5TGVuZ3RoKToK KyAgICAgICAgKiBWTS9DVEkuaDoKKyAgICAgICAgKiBWTS9Db2RlQmxvY2suaDoKKyAgICAgICAg KEpTQzo6Q29kZUJsb2NrOjppc1RlbXBvcmFyeVJlZ2lzdGVySW5kZXgpOgorICAgICAgICAqIGJ5 dGVjb21waWxlci9Db2RlR2VuZXJhdG9yLmNwcDoKKyAgICAgICAgKEpTQzo6Q29kZUdlbmVyYXRv cjo6ZW1pdExhYmVsKToKKwogMjAwOC0xMS0xMiAgQWxwIFRva2VyICA8YWxwQG51YW50aS5jb20+ CiAKICAgICAgICAgYXV0b3Rvb2xzIGJ1aWxkIHN5c3RlbSBmaXgtdXAgb25seS4gQWRkIEZsb2F0 UXVhZC5oIHRvIHRoZSBzb3VyY2UKSW5kZXg6IFZNL0NUSS5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVk0v Q1RJLmNwcAkocmV2aXNpb24gMzgzNjcpCisrKyBWTS9DVEkuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC0xNzMsMTUgKzE3MywzOCBAQCBzdGF0aWMgQUxXQVlTX0lOTElORSB1aW50cHRyX3QgYXNJbnRl Z2VyCiAgICAgcmV0dXJuIHJlaW50ZXJwcmV0X2Nhc3Q8dWludHB0cl90Pih2YWx1ZSk7CiB9CiAK K0FMV0FZU19JTkxJTkUgdm9pZCBDVEk6OmludmFsaWRhdGVQZWVwaG9sZU9wdGltaXphdGlvbnMo KQoreworICAgIG1fbGFzdFJlc3VsdEJ5dGVjb2RlUmVnaXN0ZXIgPSBzdGQ6Om51bWVyaWNfbGlt aXRzPGludD46Om1heCgpOworfQorCiAvLyBnZXQgYXJnIHB1dHMgYW4gYXJnIGZyb20gdGhlIFNG IHJlZ2lzdGVyIGFycmF5IGludG8gYSBoL3cgcmVnaXN0ZXIKLUFMV0FZU19JTkxJTkUgdm9pZCBD VEk6OmVtaXRHZXRBcmcoaW50IHNyYywgWDg2QXNzZW1ibGVyOjpSZWdpc3RlcklEIGRzdCkKK0FM V0FZU19JTkxJTkUgdm9pZCBDVEk6OmVtaXRHZXRBcmcoaW50IHNyYywgWDg2QXNzZW1ibGVyOjpS ZWdpc3RlcklEIGRzdCwgdW5zaWduZWQgY3VycmVudEluc3RydWN0aW9uSW5kZXgpCiB7CiAgICAg Ly8gVE9ETzogd2Ugd2FudCB0byByZXVzZSB2YWx1ZXMgdGhhdCBhcmUgYWxyZWFkeSBpbiByZWdp c3RlcnMgaWYgd2UgY2FuIC0gYWRkIGEgcmVnaXN0ZXIgYWxsb2NhdG9yIQogICAgIGlmIChtX2Nv ZGVCbG9jay0+aXNDb25zdGFudFJlZ2lzdGVySW5kZXgoc3JjKSkgewogICAgICAgICBKU1ZhbHVl KiB2YWx1ZSA9IG1fY29kZUJsb2NrLT5nZXRDb25zdGFudChzcmMpOwogICAgICAgICBtX2ppdC5t b3ZsX2kzMnIoYXNJbnRlZ2VyKHZhbHVlKSwgZHN0KTsKLSAgICB9IGVsc2UKLSAgICAgICAgbV9q aXQubW92bF9tcihzcmMgKiBzaXplb2YoUmVnaXN0ZXIpLCBYODY6OmVkaSwgZHN0KTsKKyAgICAg ICAgaW52YWxpZGF0ZVBlZXBob2xlT3B0aW1pemF0aW9ucygpOworICAgICAgICByZXR1cm47Cisg ICAgfQorCisgICAgaWYgKHNyYyA9PSBtX2xhc3RSZXN1bHRCeXRlY29kZVJlZ2lzdGVyICYmIGRz dCA9PSBYODY6OmVheCAmJiBtX2NvZGVCbG9jay0+aXNUZW1wb3JhcnlSZWdpc3RlckluZGV4KHNy YykpIHsKKyAgICAgICAgYm9vbCBhdEp1bXBUYXJnZXQgPSBmYWxzZTsKKyAgICAgICAgd2hpbGUg KG1fanVtcFRhcmdldHNQb3NpdGlvbiA8IG1fY29kZUJsb2NrLT5qdW1wVGFyZ2V0cy5zaXplKCkg JiYgbV9jb2RlQmxvY2stPmp1bXBUYXJnZXRzW21fanVtcFRhcmdldHNQb3NpdGlvbl0gPD0gY3Vy cmVudEluc3RydWN0aW9uSW5kZXgpIHsKKyAgICAgICAgICAgIGlmIChtX2NvZGVCbG9jay0+anVt cFRhcmdldHNbbV9qdW1wVGFyZ2V0c1Bvc2l0aW9uXSA9PSBjdXJyZW50SW5zdHJ1Y3Rpb25JbmRl eCkKKyAgICAgICAgICAgICAgICBhdEp1bXBUYXJnZXQgPSB0cnVlOworICAgICAgICAgICAgbV9q dW1wVGFyZ2V0c1Bvc2l0aW9uKys7CisgICAgICAgIH0KKyAgICAgICAgCisgICAgICAgIGlmICgh YXRKdW1wVGFyZ2V0KSB7CisgICAgICAgICAgICBpbnZhbGlkYXRlUGVlcGhvbGVPcHRpbWl6YXRp b25zKCk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CisgICAgCisgICAg bV9qaXQubW92bF9tcihzcmMgKiBzaXplb2YoUmVnaXN0ZXIpLCBYODY6OmVkaSwgZHN0KTsKKyAg ICBpbnZhbGlkYXRlUGVlcGhvbGVPcHRpbWl6YXRpb25zKCk7CiB9CiAKIC8vIGdldCBhcmcgcHV0 cyBhbiBhcmcgZnJvbSB0aGUgU0YgcmVnaXN0ZXIgYXJyYXkgb250byB0aGUgc3RhY2ssIGFzIGFu IGFyZyB0byBhIGNvbnRleHQgdGhyZWFkZWQgZnVuY3Rpb24uCkBAIC0xOTQsMTcgKzIxNywyMSBA QCBBTFdBWVNfSU5MSU5FIHZvaWQgQ1RJOjplbWl0R2V0UHV0QXJnKHVuCiAgICAgICAgIG1faml0 Lm1vdmxfbXIoc3JjICogc2l6ZW9mKFJlZ2lzdGVyKSwgWDg2OjplZGksIHNjcmF0Y2gpOwogICAg ICAgICBtX2ppdC5tb3ZsX3JtKHNjcmF0Y2gsIG9mZnNldCArIHNpemVvZih2b2lkKiksIFg4Njo6 ZXNwKTsKICAgICB9CisKKyAgICBpbnZhbGlkYXRlUGVlcGhvbGVPcHRpbWl6YXRpb25zKCk7CiB9 CiAKIC8vIHB1dHMgYW4gYXJnIG9udG8gdGhlIHN0YWNrLCBhcyBhbiBhcmcgdG8gYSBjb250ZXh0 IHRocmVhZGVkIGZ1bmN0aW9uLgogQUxXQVlTX0lOTElORSB2b2lkIENUSTo6ZW1pdFB1dEFyZyhY ODZBc3NlbWJsZXI6OlJlZ2lzdGVySUQgc3JjLCB1bnNpZ25lZCBvZmZzZXQpCiB7CiAgICAgbV9q aXQubW92bF9ybShzcmMsIG9mZnNldCArIHNpemVvZih2b2lkKiksIFg4Njo6ZXNwKTsKKyAgICBp bnZhbGlkYXRlUGVlcGhvbGVPcHRpbWl6YXRpb25zKCk7CiB9CiAKIEFMV0FZU19JTkxJTkUgdm9p ZCBDVEk6OmVtaXRQdXRBcmdDb25zdGFudCh1bnNpZ25lZCB2YWx1ZSwgdW5zaWduZWQgb2Zmc2V0 KQogewogICAgIG1faml0Lm1vdmxfaTMybSh2YWx1ZSwgb2Zmc2V0ICsgc2l6ZW9mKHZvaWQqKSwg WDg2Ojplc3ApOworICAgIGludmFsaWRhdGVQZWVwaG9sZU9wdGltaXphdGlvbnMoKTsKIH0KIAog QUxXQVlTX0lOTElORSBKU1ZhbHVlKiBDVEk6OmdldENvbnN0YW50SW1tZWRpYXRlTnVtZXJpY0Fy Zyh1bnNpZ25lZCBzcmMpCkBAIC0yMTksMzEgKzI0NiwzNyBAQCBBTFdBWVNfSU5MSU5FIEpTVmFs dWUqIENUSTo6Z2V0Q29uc3RhbnRJCiBBTFdBWVNfSU5MSU5FIHZvaWQgQ1RJOjplbWl0UHV0Q1RJ UGFyYW0odm9pZCogdmFsdWUsIHVuc2lnbmVkIG5hbWUpCiB7CiAgICAgbV9qaXQubW92bF9pMzJt KHJlaW50ZXJwcmV0X2Nhc3Q8aW50cHRyX3Q+KHZhbHVlKSwgbmFtZSAqIHNpemVvZih2b2lkKiks IFg4Njo6ZXNwKTsKKyAgICBpbnZhbGlkYXRlUGVlcGhvbGVPcHRpbWl6YXRpb25zKCk7CiB9CiAK IEFMV0FZU19JTkxJTkUgdm9pZCBDVEk6OmVtaXRQdXRDVElQYXJhbShYODZBc3NlbWJsZXI6OlJl Z2lzdGVySUQgZnJvbSwgdW5zaWduZWQgbmFtZSkKIHsKICAgICBtX2ppdC5tb3ZsX3JtKGZyb20s IG5hbWUgKiBzaXplb2Yodm9pZCopLCBYODY6OmVzcCk7CisgICAgaW52YWxpZGF0ZVBlZXBob2xl T3B0aW1pemF0aW9ucygpOwogfQogCiBBTFdBWVNfSU5MSU5FIHZvaWQgQ1RJOjplbWl0R2V0Q1RJ UGFyYW0odW5zaWduZWQgbmFtZSwgWDg2QXNzZW1ibGVyOjpSZWdpc3RlcklEIHRvKQogewogICAg IG1faml0Lm1vdmxfbXIobmFtZSAqIHNpemVvZih2b2lkKiksIFg4Njo6ZXNwLCB0byk7CisgICAg aW52YWxpZGF0ZVBlZXBob2xlT3B0aW1pemF0aW9ucygpOwogfQogCiBBTFdBWVNfSU5MSU5FIHZv aWQgQ1RJOjplbWl0UHV0VG9DYWxsRnJhbWVIZWFkZXIoWDg2QXNzZW1ibGVyOjpSZWdpc3RlcklE IGZyb20sIFJlZ2lzdGVyRmlsZTo6Q2FsbEZyYW1lSGVhZGVyRW50cnkgZW50cnkpCiB7CiAgICAg bV9qaXQubW92bF9ybShmcm9tLCBlbnRyeSAqIHNpemVvZihSZWdpc3RlciksIFg4Njo6ZWRpKTsK KyAgICBpbnZhbGlkYXRlUGVlcGhvbGVPcHRpbWl6YXRpb25zKCk7CiB9CiAKIEFMV0FZU19JTkxJ TkUgdm9pZCBDVEk6OmVtaXRHZXRGcm9tQ2FsbEZyYW1lSGVhZGVyKFJlZ2lzdGVyRmlsZTo6Q2Fs bEZyYW1lSGVhZGVyRW50cnkgZW50cnksIFg4NkFzc2VtYmxlcjo6UmVnaXN0ZXJJRCB0bykKIHsK ICAgICBtX2ppdC5tb3ZsX21yKGVudHJ5ICogc2l6ZW9mKFJlZ2lzdGVyKSwgWDg2OjplZGksIHRv KTsKKyAgICBpbnZhbGlkYXRlUGVlcGhvbGVPcHRpbWl6YXRpb25zKCk7CiB9CiAKIEFMV0FZU19J TkxJTkUgdm9pZCBDVEk6OmVtaXRQdXRSZXN1bHQodW5zaWduZWQgZHN0LCBYODZBc3NlbWJsZXI6 OlJlZ2lzdGVySUQgZnJvbSkKIHsKICAgICBtX2ppdC5tb3ZsX3JtKGZyb20sIGRzdCAqIHNpemVv ZihSZWdpc3RlciksIFg4Njo6ZWRpKTsKKyAgICBtX2xhc3RSZXN1bHRCeXRlY29kZVJlZ2lzdGVy ID0gKGZyb20gPT0gWDg2OjplYXgpID8gZHN0IDogc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+Ojpt YXgoKTsKICAgICAvLyBGSVhNRTogI2lmbmRlZiBOREVCVUcsIFdyaXRlIHRoZSBjb3JyZWN0IG1f dHlwZSB0byB0aGUgcmVnaXN0ZXIuCiB9CiAKQEAgLTM1MSw2ICszODQsNyBAQCBBTFdBWVNfSU5M SU5FIFg4NkFzc2VtYmxlcjo6Sm1wU3JjIENUSTo6CiAjaWYgRU5BQkxFKE9QQ09ERV9TQU1QTElO RykKICAgICBtX2ppdC5tb3ZsX2kzMm0obV9tYWNoaW5lLT5zYW1wbGVyKCktPmVuY29kZVNhbXBs ZSh2UEMsIGZhbHNlKSwgbV9tYWNoaW5lLT5zYW1wbGVyKCktPnNhbXBsZVNsb3QoKSk7CiAjZW5k aWYKKyAgICBpbnZhbGlkYXRlUGVlcGhvbGVPcHRpbWl6YXRpb25zKCk7CiAKICAgICByZXR1cm4g Y2FsbDsKIH0KQEAgLTM2OSw2ICs0MDMsNyBAQCBBTFdBWVNfSU5MSU5FIFg4NkFzc2VtYmxlcjo6 Sm1wU3JjIENUSTo6CiAjaWYgRU5BQkxFKE9QQ09ERV9TQU1QTElORykKICAgICBtX2ppdC5tb3Zs X2kzMm0obV9tYWNoaW5lLT5zYW1wbGVyKCktPmVuY29kZVNhbXBsZSh2UEMsIGZhbHNlKSwgbV9t YWNoaW5lLT5zYW1wbGVyKCktPnNhbXBsZVNsb3QoKSk7CiAjZW5kaWYKKyAgICBpbnZhbGlkYXRl UGVlcGhvbGVPcHRpbWl6YXRpb25zKCk7CiAKICAgICByZXR1cm4gY2FsbDsKIH0KQEAgLTM4Nyw2 ICs0MjIsNyBAQCBBTFdBWVNfSU5MSU5FIFg4NkFzc2VtYmxlcjo6Sm1wU3JjIENUSTo6CiAjaWYg RU5BQkxFKE9QQ09ERV9TQU1QTElORykKICAgICBtX2ppdC5tb3ZsX2kzMm0obV9tYWNoaW5lLT5z YW1wbGVyKCktPmVuY29kZVNhbXBsZSh2UEMsIGZhbHNlKSwgbV9tYWNoaW5lLT5zYW1wbGVyKCkt PnNhbXBsZVNsb3QoKSk7CiAjZW5kaWYKKyAgICBpbnZhbGlkYXRlUGVlcGhvbGVPcHRpbWl6YXRp b25zKCk7CiAKICAgICByZXR1cm4gY2FsbDsKIH0KQEAgLTQwNSw2ICs0NDEsNyBAQCBBTFdBWVNf SU5MSU5FIFg4NkFzc2VtYmxlcjo6Sm1wU3JjIENUSTo6CiAjaWYgRU5BQkxFKE9QQ09ERV9TQU1Q TElORykKICAgICBtX2ppdC5tb3ZsX2kzMm0obV9tYWNoaW5lLT5zYW1wbGVyKCktPmVuY29kZVNh bXBsZSh2UEMsIGZhbHNlKSwgbV9tYWNoaW5lLT5zYW1wbGVyKCktPnNhbXBsZVNsb3QoKSk7CiAj ZW5kaWYKKyAgICBpbnZhbGlkYXRlUGVlcGhvbGVPcHRpbWl6YXRpb25zKCk7CiAKICAgICByZXR1 cm4gY2FsbDsKIH0KQEAgLTQyMyw2ICs0NjAsNyBAQCBBTFdBWVNfSU5MSU5FIFg4NkFzc2VtYmxl cjo6Sm1wU3JjIENUSTo6CiAjaWYgRU5BQkxFKE9QQ09ERV9TQU1QTElORykKICAgICBtX2ppdC5t b3ZsX2kzMm0obV9tYWNoaW5lLT5zYW1wbGVyKCktPmVuY29kZVNhbXBsZSh2UEMsIGZhbHNlKSwg bV9tYWNoaW5lLT5zYW1wbGVyKCktPnNhbXBsZVNsb3QoKSk7CiAjZW5kaWYKKyAgICBpbnZhbGlk YXRlUGVlcGhvbGVPcHRpbWl6YXRpb25zKCk7CiAKICAgICByZXR1cm4gY2FsbDsKIH0KQEAgLTQ0 MSw2ICs0NzksNyBAQCBBTFdBWVNfSU5MSU5FIFg4NkFzc2VtYmxlcjo6Sm1wU3JjIENUSTo6CiAj aWYgRU5BQkxFKE9QQ09ERV9TQU1QTElORykKICAgICBtX2ppdC5tb3ZsX2kzMm0obV9tYWNoaW5l LT5zYW1wbGVyKCktPmVuY29kZVNhbXBsZSh2UEMsIGZhbHNlKSwgbV9tYWNoaW5lLT5zYW1wbGVy KCktPnNhbXBsZVNsb3QoKSk7CiAjZW5kaWYKKyAgICBpbnZhbGlkYXRlUGVlcGhvbGVPcHRpbWl6 YXRpb25zKCk7CiAKICAgICByZXR1cm4gY2FsbDsKIH0KQEAgLTQ1OSw2ICs0OTgsNyBAQCBBTFdB WVNfSU5MSU5FIFg4NkFzc2VtYmxlcjo6Sm1wU3JjIENUSTo6CiAjaWYgRU5BQkxFKE9QQ09ERV9T QU1QTElORykKICAgICBtX2ppdC5tb3ZsX2kzMm0obV9tYWNoaW5lLT5zYW1wbGVyKCktPmVuY29k ZVNhbXBsZSh2UEMsIGZhbHNlKSwgbV9tYWNoaW5lLT5zYW1wbGVyKCktPnNhbXBsZVNsb3QoKSk7 CiAjZW5kaWYKKyAgICBpbnZhbGlkYXRlUGVlcGhvbGVPcHRpbWl6YXRpb25zKCk7CiAKICAgICBy ZXR1cm4gY2FsbDsKIH0KQEAgLTU0OSw2ICs1ODksOCBAQCBDVEk6OkNUSShKU0dsb2JhbERhdGEq IGdsb2JhbERhdGEsIENvZGVCCiAgICAgLCBtX2xhYmVscyhjb2RlQmxvY2sgPyBjb2RlQmxvY2st Pmluc3RydWN0aW9ucy5zaXplKCkgOiAwKQogICAgICwgbV9wcm9wZXJ0eUFjY2Vzc0NvbXBpbGF0 aW9uSW5mbyhjb2RlQmxvY2sgPyBjb2RlQmxvY2stPnByb3BlcnR5QWNjZXNzSW5zdHJ1Y3Rpb25z LnNpemUoKSA6IDApCiAgICAgLCBtX2NhbGxTdHJ1Y3R1cmVTdHViQ29tcGlsYXRpb25JbmZvKGNv ZGVCbG9jayA/IGNvZGVCbG9jay0+Y2FsbExpbmtJbmZvcy5zaXplKCkgOiAwKQorICAgICwgbV9s YXN0UmVzdWx0Qnl0ZWNvZGVSZWdpc3RlcihzdGQ6Om51bWVyaWNfbGltaXRzPGludD46Om1heCgp KQorICAgICwgbV9qdW1wVGFyZ2V0c1Bvc2l0aW9uKDApCiB7CiB9CiAKQEAgLTYzNyw3ICs2Nzks NyBAQCB2b2lkIENUSTo6Y29tcGlsZU9wQ2FsbChPcGNvZGVJRCBvcGNvZGVJCiAgICAgLy8gSGFu ZGxlIGV2YWwKICAgICBYODZBc3NlbWJsZXI6OkptcFNyYyB3YXNFdmFsOwogICAgIGlmIChvcGNv ZGVJRCA9PSBvcF9jYWxsX2V2YWwpIHsKLSAgICAgICAgZW1pdEdldEFyZyhjYWxsZWUsIFg4Njo6 ZWN4KTsKKyAgICAgICAgZW1pdEdldEFyZyhjYWxsZWUsIFg4Njo6ZWN4LCBpKTsKICAgICAgICAg Y29tcGlsZU9wQ2FsbEV2YWxTZXR1cEFyZ3MoaW5zdHJ1Y3Rpb24pOwogCiAgICAgICAgIGVtaXRD VElDYWxsKGluc3RydWN0aW9uLCBpLCBNYWNoaW5lOjpjdGlfb3BfY2FsbF9ldmFsKTsKQEAgLTY0 Nyw3ICs2ODksNyBAQCB2b2lkIENUSTo6Y29tcGlsZU9wQ2FsbChPcGNvZGVJRCBvcGNvZGVJCiAK ICAgICAvLyBUaGlzIHBsYW50cyBhIGNoZWNrIGZvciBhIGNhY2hlZCBKU0Z1bmN0aW9uIHZhbHVl LCBzbyB3ZSBjYW4gcGxhbnQgYSBmYXN0IGxpbmsgdG8gdGhlIGNhbGxlZS4KICAgICAvLyBUaGlz IGRlbGliZXJhdGVseSBsZWF2ZXMgdGhlIGNhbGxlZSBpbiBlY3gsIHVzZWQgd2hlbiBzZXR0aW5n IHVwIHRoZSBzdGFjayBmcmFtZSBiZWxvdwotICAgIGVtaXRHZXRBcmcoY2FsbGVlLCBYODY6OmVj eCk7CisgICAgZW1pdEdldEFyZyhjYWxsZWUsIFg4Njo6ZWN4LCBpKTsKICAgICBtX2ppdC5jbXBs X2kzMnIoYXNJbnRlZ2VyKEpTSW1tZWRpYXRlOjppbXBvc3NpYmxlVmFsdWUoKSksIFg4Njo6ZWN4 KTsKICAgICBYODZBc3NlbWJsZXI6OkptcERzdCBhZGRyZXNzT2ZMaW5rZWRGdW5jdGlvbkNoZWNr ID0gbV9qaXQubGFiZWwoKTsKICAgICBtX3Nsb3dDYXNlcy5hcHBlbmQoU2xvd0Nhc2VFbnRyeSht X2ppdC5lbWl0VW5saW5rZWRKbmUoKSwgaSkpOwpAQCAtNjY1LDcgKzcwNyw3IEBAIHZvaWQgQ1RJ Ojpjb21waWxlT3BDYWxsKE9wY29kZUlEIG9wY29kZUkKICAgICAgICAgZW1pdEdldFB1dEFyZyhw cm90bywgMTIsIFg4Njo6ZWF4KTsKICAgICAgICAgZW1pdENUSUNhbGwoaW5zdHJ1Y3Rpb24sIGks IE1hY2hpbmU6OmN0aV9vcF9jb25zdHJ1Y3RfSlNDb25zdHJ1Y3QpOwogICAgICAgICBlbWl0UHV0 UmVzdWx0KHRoaXNSZWdpc3Rlcik7Ci0gICAgICAgIGVtaXRHZXRBcmcoY2FsbGVlLCBYODY6OmVj eCk7CisgICAgICAgIGVtaXRHZXRBcmcoY2FsbGVlLCBYODY6OmVjeCwgaSk7CiAgICAgfQogCiAg ICAgLy8gRmFzdCB2ZXJzaW9uIG9mIHN0YWNrIGZyYW1lIGluaXRpYWxpemF0aW9uLCBkaXJlY3Rs eSByZWxhdGl2ZSB0byBlZGkuCkBAIC03MDAsOCArNzQyLDggQEAgdm9pZCBDVEk6OmNvbXBpbGVP cFN0cmljdEVxKEluc3RydWN0aW9uKgogICAgIHVuc2lnbmVkIHNyYzEgPSBpbnN0cnVjdGlvblsy XS51Lm9wZXJhbmQ7CiAgICAgdW5zaWduZWQgc3JjMiA9IGluc3RydWN0aW9uWzNdLnUub3BlcmFu ZDsKIAotICAgIGVtaXRHZXRBcmcoc3JjMSwgWDg2OjplYXgpOwotICAgIGVtaXRHZXRBcmcoc3Jj MiwgWDg2OjplZHgpOworICAgIGVtaXRHZXRBcmcoc3JjMSwgWDg2OjplYXgsIGkpOworICAgIGVt aXRHZXRBcmcoc3JjMiwgWDg2OjplZHgsIGkpOwogCiAgICAgbV9qaXQudGVzdGxfaTMycihKU0lt bWVkaWF0ZTo6VGFnTWFzaywgWDg2OjplYXgpOwogICAgIFg4NkFzc2VtYmxlcjo6Sm1wU3JjIGZp cnN0Tm90SW1tZWRpYXRlID0gbV9qaXQuZW1pdFVubGlua2VkSmUoKTsKQEAgLTc1OCw2ICs4MDAs OCBAQCB2b2lkIENUSTo6ZW1pdFNsb3dTY3JpcHRDaGVjayhJbnN0cnVjdGlvCiAgICAgbV9qaXQu bW92bF9tcihPQkpFQ1RfT0ZGU0VUKEpTR2xvYmFsRGF0YSwgbWFjaGluZSksIFg4Njo6ZWN4LCBY ODY6OmVjeCk7CiAgICAgbV9qaXQubW92bF9tcihPQkpFQ1RfT0ZGU0VUKE1hY2hpbmUsIG1fdGlj a3NVbnRpbE5leHRUaW1lb3V0Q2hlY2spLCBYODY6OmVjeCwgWDg2Ojplc2kpOwogICAgIG1faml0 Lmxpbmsoc2tpcFRpbWVvdXQsIG1faml0LmxhYmVsKCkpOworCisgICAgaW52YWxpZGF0ZVBlZXBo b2xlT3B0aW1pemF0aW9ucygpOwogfQogCiAvKgpAQCAtODA2LDggKzg1MCw4IEBAIHZvaWQgQ1RJ Ojpjb21waWxlQmluYXJ5QXJpdGhPcChPcGNvZGVJRCAKICAgICBYODZBc3NlbWJsZXI6OkptcFNy YyB3YXNKU051bWJlckNlbGwyOwogICAgIFg4NkFzc2VtYmxlcjo6Sm1wU3JjIHdhc0pTTnVtYmVy Q2VsbDJiOwogCi0gICAgZW1pdEdldEFyZyhzcmMxLCBYODY6OmVheCk7Ci0gICAgZW1pdEdldEFy ZyhzcmMyLCBYODY6OmVkeCk7CisgICAgZW1pdEdldEFyZyhzcmMxLCBYODY6OmVheCwgaSk7Cisg ICAgZW1pdEdldEFyZyhzcmMyLCBYODY6OmVkeCwgaSk7CiAKICAgICBpZiAodHlwZXMuc2Vjb25k KCkuaXNSZXVzYWJsZSgpICYmIGlzU1NFMlByZXNlbnQoKSkgewogICAgICAgICBBU1NFUlQodHlw ZXMuc2Vjb25kKCkubWlnaHRCZU51bWJlcigpKTsKQEAgLTk0Niw2ICs5OTAsMTAgQEAgdm9pZCBD VEk6OmNvbXBpbGVCaW5hcnlBcml0aE9wKE9wY29kZUlEIAogICAgICAgICBtX2ppdC5saW5rKHdh c0pTTnVtYmVyQ2VsbDEsIG1faml0LmxhYmVsKCkpOwogICAgICAgICBtX2ppdC5saW5rKHdhc0pT TnVtYmVyQ2VsbDFiLCBtX2ppdC5sYWJlbCgpKTsKICAgICB9CisKKyAgICAvLyBGSVhNRTogbWFr ZSB0aGUgZGlmZmVyZW50IGNhc2VzIG9mIHRoaXMgZnVuY3Rpb24gYWxsIHVzZSBlYXggYXMgdGhl IAorICAgIC8vIGRlc3RpbmF0aW9uIHJlZ2lzdGVyIGFuZCBlbmFibGUgdGhlIHJlZ2lzdGVyIGNh Y2hpbmcgb3B0aW1pemF0aW9uLgorICAgIGludmFsaWRhdGVQZWVwaG9sZU9wdGltaXphdGlvbnMo KTsKIH0KIAogdm9pZCBDVEk6OmNvbXBpbGVCaW5hcnlBcml0aE9wU2xvd0Nhc2UoSW5zdHJ1Y3Rp b24qIHZQQywgT3Bjb2RlSUQgb3Bjb2RlSUQsIFZlY3RvcjxTbG93Q2FzZUVudHJ5Pjo6aXRlcmF0 b3ImIGl0ZXIsIHVuc2lnbmVkIGRzdCwgdW5zaWduZWQgc3JjMSwgdW5zaWduZWQgc3JjMiwgT3Bl cmFuZFR5cGVzIHR5cGVzLCB1bnNpZ25lZCBpKQpAQCAtMTAxNiw3ICsxMDY0LDcgQEAgdm9pZCBD VEk6OnByaXZhdGVDb21waWxlTWFpblBhc3MoKQogICAgICAgICAgICAgaWYgKG1fY29kZUJsb2Nr LT5pc0NvbnN0YW50UmVnaXN0ZXJJbmRleChzcmMpKQogICAgICAgICAgICAgICAgIG1faml0Lm1v dmxfaTMycihhc0ludGVnZXIobV9jb2RlQmxvY2stPmdldENvbnN0YW50KHNyYykpLCBYODY6OmVh eCk7CiAgICAgICAgICAgICBlbHNlCi0gICAgICAgICAgICAgICAgZW1pdEdldEFyZyhzcmMsIFg4 Njo6ZWF4KTsKKyAgICAgICAgICAgICAgICBlbWl0R2V0QXJnKHNyYywgWDg2OjplYXgsIGkpOwog ICAgICAgICAgICAgZW1pdFB1dFJlc3VsdChpbnN0cnVjdGlvbltpICsgMV0udS5vcGVyYW5kKTsK ICAgICAgICAgICAgIGkgKz0gMzsKICAgICAgICAgICAgIGJyZWFrOwpAQCAtMTAyNywxMyArMTA3 NSwxMyBAQCB2b2lkIENUSTo6cHJpdmF0ZUNvbXBpbGVNYWluUGFzcygpCiAgICAgICAgICAgICB1 bnNpZ25lZCBzcmMyID0gaW5zdHJ1Y3Rpb25baSArIDNdLnUub3BlcmFuZDsKIAogICAgICAgICAg ICAgaWYgKEpTVmFsdWUqIHZhbHVlID0gZ2V0Q29uc3RhbnRJbW1lZGlhdGVOdW1lcmljQXJnKHNy YzEpKSB7Ci0gICAgICAgICAgICAgICAgZW1pdEdldEFyZyhzcmMyLCBYODY6OmVkeCk7CisgICAg ICAgICAgICAgICAgZW1pdEdldEFyZyhzcmMyLCBYODY6OmVkeCwgaSk7CiAgICAgICAgICAgICAg ICAgZW1pdEp1bXBTbG93Q2FzZUlmTm90SW1tTnVtKFg4Njo6ZWR4LCBpKTsKICAgICAgICAgICAg ICAgICBtX2ppdC5hZGRsX2kzMnIoZ2V0RGVUYWdnZWRDb25zdGFudEltbWVkaWF0ZSh2YWx1ZSks IFg4Njo6ZWR4KTsKICAgICAgICAgICAgICAgICBtX3Nsb3dDYXNlcy5hcHBlbmQoU2xvd0Nhc2VF bnRyeShtX2ppdC5lbWl0VW5saW5rZWRKbygpLCBpKSk7CiAgICAgICAgICAgICAgICAgZW1pdFB1 dFJlc3VsdChkc3QsIFg4Njo6ZWR4KTsKICAgICAgICAgICAgIH0gZWxzZSBpZiAoSlNWYWx1ZSog dmFsdWUgPSBnZXRDb25zdGFudEltbWVkaWF0ZU51bWVyaWNBcmcoc3JjMikpIHsKLSAgICAgICAg ICAgICAgICBlbWl0R2V0QXJnKHNyYzEsIFg4Njo6ZWF4KTsKKyAgICAgICAgICAgICAgICBlbWl0 R2V0QXJnKHNyYzEsIFg4Njo6ZWF4LCBpKTsKICAgICAgICAgICAgICAgICBlbWl0SnVtcFNsb3dD YXNlSWZOb3RJbW1OdW0oWDg2OjplYXgsIGkpOwogICAgICAgICAgICAgICAgIG1faml0LmFkZGxf aTMycihnZXREZVRhZ2dlZENvbnN0YW50SW1tZWRpYXRlKHZhbHVlKSwgWDg2OjplYXgpOwogICAg ICAgICAgICAgICAgIG1fc2xvd0Nhc2VzLmFwcGVuZChTbG93Q2FzZUVudHJ5KG1faml0LmVtaXRV bmxpbmtlZEpvKCksIGkpKTsKQEAgLTEwNTYsNyArMTEwNCw3IEBAIHZvaWQgQ1RJOjpwcml2YXRl Q29tcGlsZU1haW5QYXNzKCkKICAgICAgICAgY2FzZSBvcF9lbmQ6IHsKICAgICAgICAgICAgIGlm IChtX2NvZGVCbG9jay0+bmVlZHNGdWxsU2NvcGVDaGFpbikKICAgICAgICAgICAgICAgICBlbWl0 Q1RJQ2FsbChpbnN0cnVjdGlvbiArIGksIGksIE1hY2hpbmU6OmN0aV9vcF9lbmQpOwotICAgICAg ICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgMV0udS5vcGVyYW5kLCBYODY6OmVheCk7 CisgICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAxXS51Lm9wZXJhbmQsIFg4 Njo6ZWF4LCBpKTsKICAgICAgICAgICAgIG1faml0LnB1c2hsX20oUmVnaXN0ZXJGaWxlOjpSZXR1 cm5QQyAqIHN0YXRpY19jYXN0PGludD4oc2l6ZW9mKFJlZ2lzdGVyKSksIFg4Njo6ZWRpKTsKICAg ICAgICAgICAgIG1faml0LnJldCgpOwogICAgICAgICAgICAgaSArPSAyOwpAQCAtMTA3MCw3ICsx MTE4LDcgQEAgdm9pZCBDVEk6OnByaXZhdGVDb21waWxlTWFpblBhc3MoKQogICAgICAgICB9CiAg ICAgICAgIGNhc2Ugb3BfcHJlX2luYzogewogICAgICAgICAgICAgaW50IHNyY0RzdCA9IGluc3Ry dWN0aW9uW2kgKyAxXS51Lm9wZXJhbmQ7Ci0gICAgICAgICAgICBlbWl0R2V0QXJnKHNyY0RzdCwg WDg2OjplYXgpOworICAgICAgICAgICAgZW1pdEdldEFyZyhzcmNEc3QsIFg4Njo6ZWF4LCBpKTsK ICAgICAgICAgICAgIGVtaXRKdW1wU2xvd0Nhc2VJZk5vdEltbU51bShYODY6OmVheCwgaSk7CiAg ICAgICAgICAgICBtX2ppdC5hZGRsX2k4cihnZXREZVRhZ2dlZENvbnN0YW50SW1tZWRpYXRlKEpT SW1tZWRpYXRlOjpvbmVJbW1lZGlhdGUoKSksIFg4Njo6ZWF4KTsKICAgICAgICAgICAgIG1fc2xv d0Nhc2VzLmFwcGVuZChTbG93Q2FzZUVudHJ5KG1faml0LmVtaXRVbmxpbmtlZEpvKCksIGkpKTsK QEAgLTEwOTIsMTMgKzExNDAsMTMgQEAgdm9pZCBDVEk6OnByaXZhdGVDb21waWxlTWFpblBhc3Mo KQogICAgICAgICAgICAgdW5zaWduZWQgdGFyZ2V0ID0gaW5zdHJ1Y3Rpb25baSArIDNdLnUub3Bl cmFuZDsKICAgICAgICAgICAgIEpTVmFsdWUqIHNyYzJpbW0gPSBnZXRDb25zdGFudEltbWVkaWF0 ZU51bWVyaWNBcmcoaW5zdHJ1Y3Rpb25baSArIDJdLnUub3BlcmFuZCk7CiAgICAgICAgICAgICBp ZiAoc3JjMmltbSkgewotICAgICAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSAr IDFdLnUub3BlcmFuZCwgWDg2OjplZHgpOworICAgICAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5z dHJ1Y3Rpb25baSArIDFdLnUub3BlcmFuZCwgWDg2OjplZHgsIGkpOwogICAgICAgICAgICAgICAg IGVtaXRKdW1wU2xvd0Nhc2VJZk5vdEltbU51bShYODY6OmVkeCwgaSk7CiAgICAgICAgICAgICAg ICAgbV9qaXQuY21wbF9pMzJyKGFzSW50ZWdlcihzcmMyaW1tKSwgWDg2OjplZHgpOwogICAgICAg ICAgICAgICAgIG1fam1wVGFibGUuYXBwZW5kKEptcFRhYmxlKG1faml0LmVtaXRVbmxpbmtlZEps KCksIGkgKyAzICsgdGFyZ2V0KSk7CiAgICAgICAgICAgICB9IGVsc2UgewotICAgICAgICAgICAg ICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDFdLnUub3BlcmFuZCwgWDg2OjplYXgpOwot ICAgICAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDJdLnUub3BlcmFuZCwg WDg2OjplZHgpOworICAgICAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDFd LnUub3BlcmFuZCwgWDg2OjplYXgsIGkpOworICAgICAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5z dHJ1Y3Rpb25baSArIDJdLnUub3BlcmFuZCwgWDg2OjplZHgsIGkpOwogICAgICAgICAgICAgICAg IGVtaXRKdW1wU2xvd0Nhc2VJZk5vdEltbU51bShYODY6OmVheCwgaSk7CiAgICAgICAgICAgICAg ICAgZW1pdEp1bXBTbG93Q2FzZUlmTm90SW1tTnVtKFg4Njo6ZWR4LCBpKTsKICAgICAgICAgICAg ICAgICBtX2ppdC5jbXBsX3JyKFg4Njo6ZWR4LCBYODY6OmVheCk7CkBAIC0xMTEzLDEzICsxMTYx LDEzIEBAIHZvaWQgQ1RJOjpwcml2YXRlQ29tcGlsZU1haW5QYXNzKCkKICAgICAgICAgICAgIHVu c2lnbmVkIHRhcmdldCA9IGluc3RydWN0aW9uW2kgKyAzXS51Lm9wZXJhbmQ7CiAgICAgICAgICAg ICBKU1ZhbHVlKiBzcmMyaW1tID0gZ2V0Q29uc3RhbnRJbW1lZGlhdGVOdW1lcmljQXJnKGluc3Ry dWN0aW9uW2kgKyAyXS51Lm9wZXJhbmQpOwogICAgICAgICAgICAgaWYgKHNyYzJpbW0pIHsKLSAg ICAgICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAxXS51Lm9wZXJhbmQsIFg4 Njo6ZWR4KTsKKyAgICAgICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAxXS51 Lm9wZXJhbmQsIFg4Njo6ZWR4LCBpKTsKICAgICAgICAgICAgICAgICBlbWl0SnVtcFNsb3dDYXNl SWZOb3RJbW1OdW0oWDg2OjplZHgsIGkpOwogICAgICAgICAgICAgICAgIG1faml0LmNtcGxfaTMy cihhc0ludGVnZXIoc3JjMmltbSksIFg4Njo6ZWR4KTsKICAgICAgICAgICAgICAgICBtX2ptcFRh YmxlLmFwcGVuZChKbXBUYWJsZShtX2ppdC5lbWl0VW5saW5rZWRKbGUoKSwgaSArIDMgKyB0YXJn ZXQpKTsKICAgICAgICAgICAgIH0gZWxzZSB7Ci0gICAgICAgICAgICAgICAgZW1pdEdldEFyZyhp bnN0cnVjdGlvbltpICsgMV0udS5vcGVyYW5kLCBYODY6OmVheCk7Ci0gICAgICAgICAgICAgICAg ZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgMl0udS5vcGVyYW5kLCBYODY6OmVkeCk7CisgICAg ICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgMV0udS5vcGVyYW5kLCBYODY6 OmVheCwgaSk7CisgICAgICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgMl0u dS5vcGVyYW5kLCBYODY6OmVkeCwgaSk7CiAgICAgICAgICAgICAgICAgZW1pdEp1bXBTbG93Q2Fz ZUlmTm90SW1tTnVtKFg4Njo6ZWF4LCBpKTsKICAgICAgICAgICAgICAgICBlbWl0SnVtcFNsb3dD YXNlSWZOb3RJbW1OdW0oWDg2OjplZHgsIGkpOwogICAgICAgICAgICAgICAgIG1faml0LmNtcGxf cnIoWDg2OjplZHgsIFg4Njo6ZWF4KTsKQEAgLTExMzksOCArMTE4Nyw4IEBAIHZvaWQgQ1RJOjpw cml2YXRlQ29tcGlsZU1haW5QYXNzKCkKICAgICAgICAgICAgIC8vIHRvIGp1c3QgYWZ0ZXIgdGhl IGFyZ3VtZW50cyBoYXZlIGJlZW4gbG9hZGVkIGludG8gcmVnaXN0ZXJzICdob3RQYXRoQmVnaW4n LCBhbmQgd2UgZ2VuZXJhdGUgY29kZQogICAgICAgICAgICAgLy8gc3VjaCB0aGF0IHRoZSBTdHJ1 Y3R1cmVJRCAmIG9mZnNldCBhcmUgYWx3YXlzIGF0IHRoZSBzYW1lIGRpc3RhbmNlIGZyb20gdGhp cy4KIAotICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgMV0udS5vcGVyYW5k LCBYODY6OmVheCk7Ci0gICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAzXS51 Lm9wZXJhbmQsIFg4Njo6ZWR4KTsKKyAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25b aSArIDFdLnUub3BlcmFuZCwgWDg2OjplYXgsIGkpOworICAgICAgICAgICAgZW1pdEdldEFyZyhp bnN0cnVjdGlvbltpICsgM10udS5vcGVyYW5kLCBYODY6OmVkeCwgaSk7CiAKICAgICAgICAgICAg IEFTU0VSVChtX2NvZGVCbG9jay0+cHJvcGVydHlBY2Nlc3NJbnN0cnVjdGlvbnNbcHJvcGVydHlB Y2Nlc3NJbnN0cnVjdGlvbkluZGV4XS5vcGNvZGVJbmRleCA9PSBpKTsKICAgICAgICAgICAgIFg4 NkFzc2VtYmxlcjo6Sm1wRHN0IGhvdFBhdGhCZWdpbiA9IG1faml0LmxhYmVsKCk7CkBAIC0xMTY4 LDcgKzEyMTYsNyBAQCB2b2lkIENUSTo6cHJpdmF0ZUNvbXBpbGVNYWluUGFzcygpCiAgICAgICAg ICAgICAvLyB0byBhcnJheS1sZW5ndGggLyBwcm90b3R5cGUgYWNjZXNzIHRyYW5wb2xpbmVzLCBh bmQgZmluYWxseSB3ZSBhbHNvIHRoZSB0aGUgcHJvcGVydHktbWFwIGFjY2VzcyBvZmZzZXQgYXMg YSBsYWJlbAogICAgICAgICAgICAgLy8gdG8ganVtcCBiYWNrIHRvIGlmIG9uZSBvZiB0aGVzZSB0 cmFtcG9saWVzIGZpbmRzIGEgbWF0Y2guCiAKLSAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1 Y3Rpb25baSArIDJdLnUub3BlcmFuZCwgWDg2OjplYXgpOworICAgICAgICAgICAgZW1pdEdldEFy ZyhpbnN0cnVjdGlvbltpICsgMl0udS5vcGVyYW5kLCBYODY6OmVheCwgaSk7CiAKICAgICAgICAg ICAgIEFTU0VSVChtX2NvZGVCbG9jay0+cHJvcGVydHlBY2Nlc3NJbnN0cnVjdGlvbnNbcHJvcGVy dHlBY2Nlc3NJbnN0cnVjdGlvbkluZGV4XS5vcGNvZGVJbmRleCA9PSBpKTsKIApAQCAtMTE4Mywx NyArMTIzMSwxNyBAQCB2b2lkIENUSTo6cHJpdmF0ZUNvbXBpbGVNYWluUGFzcygpCiAgICAgICAg ICAgICBBU1NFUlQoWDg2QXNzZW1ibGVyOjpnZXREaWZmZXJlbmNlQmV0d2VlbkxhYmVscyhob3RQ YXRoQmVnaW4sIG1faml0LmxhYmVsKCkpID09IHJlcGF0Y2hPZmZzZXRHZXRCeUlkQnJhbmNoVG9T bG93Q2FzZSk7CiAKICAgICAgICAgICAgIG1faml0Lm1vdmxfbXIoT0JKRUNUX09GRlNFVChKU09i amVjdCwgbV9wcm9wZXJ0eVN0b3JhZ2UpLCBYODY6OmVheCwgWDg2OjplYXgpOwotICAgICAgICAg ICAgbV9qaXQubW92bF9tcihyZXBhdGNoR2V0QnlJZERlZmF1bHRPZmZzZXQsIFg4Njo6ZWF4LCBY ODY6OmVjeCk7CisgICAgICAgICAgICBtX2ppdC5tb3ZsX21yKHJlcGF0Y2hHZXRCeUlkRGVmYXVs dE9mZnNldCwgWDg2OjplYXgsIFg4Njo6ZWF4KTsKICAgICAgICAgICAgIEFTU0VSVChYODZBc3Nl bWJsZXI6OmdldERpZmZlcmVuY2VCZXR3ZWVuTGFiZWxzKGhvdFBhdGhCZWdpbiwgbV9qaXQubGFi ZWwoKSkgPT0gcmVwYXRjaE9mZnNldEdldEJ5SWRQcm9wZXJ0eU1hcE9mZnNldCk7Ci0gICAgICAg ICAgICBlbWl0UHV0UmVzdWx0KGluc3RydWN0aW9uW2kgKyAxXS51Lm9wZXJhbmQsIFg4Njo6ZWN4 KTsKKyAgICAgICAgICAgIGVtaXRQdXRSZXN1bHQoaW5zdHJ1Y3Rpb25baSArIDFdLnUub3BlcmFu ZCk7CiAKICAgICAgICAgICAgIGkgKz0gODsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICB9 CiAgICAgICAgIGNhc2Ugb3BfaW5zdGFuY2VvZjogewotICAgICAgICAgICAgZW1pdEdldEFyZyhp bnN0cnVjdGlvbltpICsgMl0udS5vcGVyYW5kLCBYODY6OmVheCk7IC8vIHZhbHVlCi0gICAgICAg ICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAzXS51Lm9wZXJhbmQsIFg4Njo6ZWN4KTsg Ly8gYmFzZVZhbAotICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgNF0udS5v cGVyYW5kLCBYODY6OmVkeCk7IC8vIHByb3RvCisgICAgICAgICAgICBlbWl0R2V0QXJnKGluc3Ry dWN0aW9uW2kgKyAyXS51Lm9wZXJhbmQsIFg4Njo6ZWF4LCBpKTsgLy8gdmFsdWUKKyAgICAgICAg ICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDNdLnUub3BlcmFuZCwgWDg2OjplY3gsIGkp OyAvLyBiYXNlVmFsCisgICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyA0XS51 Lm9wZXJhbmQsIFg4Njo6ZWR4LCBpKTsgLy8gcHJvdG8KIAogICAgICAgICAgICAgLy8gY2hlY2sg aWYgYW55IGFyZSBpbW1lZGlhdGVzCiAgICAgICAgICAgICBtX2ppdC5vcmxfcnIoWDg2OjplYXgs IFg4Njo6ZWN4KTsKQEAgLTEyMTAsNyArMTI1OCw3IEBAIHZvaWQgQ1RJOjpwcml2YXRlQ29tcGls ZU1haW5QYXNzKCkKICAgICAgICAgICAgIG1faml0Lm1vdmxfbXIoT0JKRUNUX09GRlNFVChKU0Nl bGwsIG1fc3RydWN0dXJlSUQpLCBYODY6OmVkeCwgWDg2OjplZHgpOwogICAgICAgICAgICAgbV9q aXQuc3VibF9tcihPQkpFQ1RfT0ZGU0VUKFN0cnVjdHVyZUlELCBtX3R5cGVJbmZvLm1fdHlwZSks IFg4Njo6ZWF4LCBYODY6OmVjeCk7CiAgICAgICAgICAgICBtX2ppdC5zdWJsX21yKE9CSkVDVF9P RkZTRVQoU3RydWN0dXJlSUQsIG1fdHlwZUluZm8ubV90eXBlKSwgWDg2OjplZHgsIFg4Njo6ZWN4 KTsKLSAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDNdLnUub3BlcmFuZCwg WDg2OjplZHgpOyAvLyByZWxvYWQgYmFzZVZhbAorICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0 cnVjdGlvbltpICsgM10udS5vcGVyYW5kLCBYODY6OmVkeCwgaSk7IC8vIHJlbG9hZCBiYXNlVmFs CiAgICAgICAgICAgICBtX2ppdC5tb3ZsX21yKE9CSkVDVF9PRkZTRVQoSlNDZWxsLCBtX3N0cnVj dHVyZUlEKSwgWDg2OjplZHgsIFg4Njo6ZWR4KTsKICAgICAgICAgICAgIG1faml0LmNtcGxfcm0o WDg2OjplY3gsIE9CSkVDVF9PRkZTRVQoU3RydWN0dXJlSUQsIG1fdHlwZUluZm8ubV90eXBlKSwg WDg2OjplZHgpOwogCkBAIC0xMjIzLDggKzEyNzEsOCBAQCB2b2lkIENUSTo6cHJpdmF0ZUNvbXBp bGVNYWluUGFzcygpCiAKICAgICAgICAgICAgIG1fc2xvd0Nhc2VzLmFwcGVuZChTbG93Q2FzZUVu dHJ5KG1faml0LmVtaXRVbmxpbmtlZEpuZSgpLCBpKSk7CiAKLSAgICAgICAgICAgIGVtaXRHZXRB cmcoaW5zdHJ1Y3Rpb25baSArIDJdLnUub3BlcmFuZCwgWDg2OjplY3gpOyAvLyByZWxvYWQgdmFs dWUKLSAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDRdLnUub3BlcmFuZCwg WDg2OjplZHgpOyAvLyByZWxvYWQgcHJvdG8KKyAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1 Y3Rpb25baSArIDJdLnUub3BlcmFuZCwgWDg2OjplY3gsIGkpOyAvLyByZWxvYWQgdmFsdWUKKyAg ICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDRdLnUub3BlcmFuZCwgWDg2Ojpl ZHgsIGkpOyAvLyByZWxvYWQgcHJvdG8KIAogICAgICAgICAgICAgLy8gb3B0aW1pc3RpY2FsbHkg bG9hZCB0cnVlIHJlc3VsdAogICAgICAgICAgICAgbV9qaXQubW92bF9pMzJyKGFzSW50ZWdlcihq c0Jvb2xlYW4odHJ1ZSkpLCBYODY6OmVheCk7CkBAIC0xMjcwLDcgKzEzMTgsNyBAQCB2b2lkIENU STo6cHJpdmF0ZUNvbXBpbGVNYWluUGFzcygpCiAgICAgICAgICAgICBKU1ZhbHVlKiBzcmMyVmFs dWUgPSBnZXRDb25zdGFudEltbWVkaWF0ZU51bWVyaWNBcmcoc3JjMik7CiAgICAgICAgICAgICBp bnQzMl90IHZhbHVlOwogICAgICAgICAgICAgaWYgKHNyYzFWYWx1ZSAmJiAoKHZhbHVlID0gSlNJ bW1lZGlhdGU6OmludFZhbHVlKHNyYzFWYWx1ZSkpID4gMCkpIHsKLSAgICAgICAgICAgICAgICBl bWl0R2V0QXJnKHNyYzIsIFg4Njo6ZWF4KTsKKyAgICAgICAgICAgICAgICBlbWl0R2V0QXJnKHNy YzIsIFg4Njo6ZWF4LCBpKTsKICAgICAgICAgICAgICAgICBlbWl0SnVtcFNsb3dDYXNlSWZOb3RJ bW1OdW0oWDg2OjplYXgsIGkpOwogICAgICAgICAgICAgICAgIGVtaXRGYXN0QXJpdGhEZVRhZ0lt bWVkaWF0ZShYODY6OmVheCk7CiAgICAgICAgICAgICAgICAgbV9qaXQuaW11bGxfaTMycihYODY6 OmVheCwgdmFsdWUsIFg4Njo6ZWF4KTsKQEAgLTEyNzgsNyArMTMyNiw3IEBAIHZvaWQgQ1RJOjpw cml2YXRlQ29tcGlsZU1haW5QYXNzKCkKICAgICAgICAgICAgICAgICBlbWl0RmFzdEFyaXRoUmVU YWdJbW1lZGlhdGUoWDg2OjplYXgpOwogICAgICAgICAgICAgICAgIGVtaXRQdXRSZXN1bHQoZHN0 KTsKICAgICAgICAgICAgIH0gZWxzZSBpZiAoc3JjMlZhbHVlICYmICgodmFsdWUgPSBKU0ltbWVk aWF0ZTo6aW50VmFsdWUoc3JjMlZhbHVlKSkgPiAwKSkgewotICAgICAgICAgICAgICAgIGVtaXRH ZXRBcmcoc3JjMSwgWDg2OjplYXgpOworICAgICAgICAgICAgICAgIGVtaXRHZXRBcmcoc3JjMSwg WDg2OjplYXgsIGkpOwogICAgICAgICAgICAgICAgIGVtaXRKdW1wU2xvd0Nhc2VJZk5vdEltbU51 bShYODY6OmVheCwgaSk7CiAgICAgICAgICAgICAgICAgZW1pdEZhc3RBcml0aERlVGFnSW1tZWRp YXRlKFg4Njo6ZWF4KTsKICAgICAgICAgICAgICAgICBtX2ppdC5pbXVsbF9pMzJyKFg4Njo6ZWF4 LCB2YWx1ZSwgWDg2OjplYXgpOwpAQCAtMTMxNyw3ICsxMzY1LDcgQEAgdm9pZCBDVEk6OnByaXZh dGVDb21waWxlTWFpblBhc3MoKQogICAgICAgICBjYXNlIG9wX3B1dF9nbG9iYWxfdmFyOiB7CiAg ICAgICAgICAgICBKU1ZhcmlhYmxlT2JqZWN0KiBnbG9iYWxPYmplY3QgPSBzdGF0aWNfY2FzdDxK U1ZhcmlhYmxlT2JqZWN0Kj4oaW5zdHJ1Y3Rpb25baSArIDFdLnUuanNDZWxsKTsKICAgICAgICAg ICAgIG1faml0Lm1vdmxfaTMycihhc0ludGVnZXIoZ2xvYmFsT2JqZWN0KSwgWDg2OjplYXgpOwot ICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgM10udS5vcGVyYW5kLCBYODY6 OmVkeCk7CisgICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAzXS51Lm9wZXJh bmQsIFg4Njo6ZWR4LCBpKTsKICAgICAgICAgICAgIGVtaXRQdXRWYXJpYWJsZU9iamVjdFJlZ2lz dGVyKFg4Njo6ZWR4LCBYODY6OmVheCwgaW5zdHJ1Y3Rpb25baSArIDJdLnUub3BlcmFuZCk7CiAg ICAgICAgICAgICBpICs9IDQ7CiAgICAgICAgICAgICBicmVhazsKQEAgLTEzMjUsNyArMTM3Myw3 IEBAIHZvaWQgQ1RJOjpwcml2YXRlQ29tcGlsZU1haW5QYXNzKCkKICAgICAgICAgY2FzZSBvcF9n ZXRfc2NvcGVkX3ZhcjogewogICAgICAgICAgICAgaW50IHNraXAgPSBpbnN0cnVjdGlvbltpICsg M10udS5vcGVyYW5kICsgbV9jb2RlQmxvY2stPm5lZWRzRnVsbFNjb3BlQ2hhaW47CiAKLSAgICAg ICAgICAgIGVtaXRHZXRBcmcoUmVnaXN0ZXJGaWxlOjpTY29wZUNoYWluLCBYODY6OmVheCk7Cisg ICAgICAgICAgICBlbWl0R2V0QXJnKFJlZ2lzdGVyRmlsZTo6U2NvcGVDaGFpbiwgWDg2OjplYXgs IGkpOwogICAgICAgICAgICAgd2hpbGUgKHNraXAtLSkKICAgICAgICAgICAgICAgICBtX2ppdC5t b3ZsX21yKE9CSkVDVF9PRkZTRVQoU2NvcGVDaGFpbk5vZGUsIG5leHQpLCBYODY6OmVheCwgWDg2 OjplYXgpOwogCkBAIC0xMzM4LDggKzEzODYsOCBAQCB2b2lkIENUSTo6cHJpdmF0ZUNvbXBpbGVN YWluUGFzcygpCiAgICAgICAgIGNhc2Ugb3BfcHV0X3Njb3BlZF92YXI6IHsKICAgICAgICAgICAg IGludCBza2lwID0gaW5zdHJ1Y3Rpb25baSArIDJdLnUub3BlcmFuZCArIG1fY29kZUJsb2NrLT5u ZWVkc0Z1bGxTY29wZUNoYWluOwogCi0gICAgICAgICAgICBlbWl0R2V0QXJnKFJlZ2lzdGVyRmls ZTo6U2NvcGVDaGFpbiwgWDg2OjplZHgpOwotICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVj dGlvbltpICsgM10udS5vcGVyYW5kLCBYODY6OmVheCk7CisgICAgICAgICAgICBlbWl0R2V0QXJn KFJlZ2lzdGVyRmlsZTo6U2NvcGVDaGFpbiwgWDg2OjplZHgsIGkpOworICAgICAgICAgICAgZW1p dEdldEFyZyhpbnN0cnVjdGlvbltpICsgM10udS5vcGVyYW5kLCBYODY6OmVheCwgaSk7CiAgICAg ICAgICAgICB3aGlsZSAoc2tpcC0tKQogICAgICAgICAgICAgICAgIG1faml0Lm1vdmxfbXIoT0JK RUNUX09GRlNFVChTY29wZUNoYWluTm9kZSwgbmV4dCksIFg4Njo6ZWR4LCBYODY6OmVkeCk7CiAK QEAgLTEzNjUsMTMgKzE0MTMsMTMgQEAgdm9pZCBDVEk6OnByaXZhdGVDb21waWxlTWFpblBhc3Mo KQogICAgICAgICAgICAgICAgIGVtaXRDVElDYWxsKGluc3RydWN0aW9uICsgaSwgaSwgTWFjaGlu ZTo6Y3RpX29wX3JldF9zY29wZUNoYWluKTsKIAogICAgICAgICAgICAgLy8gUmV0dXJuIHRoZSBy ZXN1bHQgaW4gJWVheC4KLSAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDFd LnUub3BlcmFuZCwgWDg2OjplYXgpOworICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlv bltpICsgMV0udS5vcGVyYW5kLCBYODY6OmVheCwgaSk7CiAKICAgICAgICAgICAgIC8vIEdyYWIg dGhlIHJldHVybiBhZGRyZXNzLgotICAgICAgICAgICAgZW1pdEdldEFyZyhSZWdpc3RlckZpbGU6 OlJldHVyblBDLCBYODY6OmVkeCk7CisgICAgICAgICAgICBlbWl0R2V0QXJnKFJlZ2lzdGVyRmls ZTo6UmV0dXJuUEMsIFg4Njo6ZWR4LCBpKTsKIAogICAgICAgICAgICAgLy8gUmVzdG9yZSBvdXIg Y2FsbGVyJ3MgInIiLgotICAgICAgICAgICAgZW1pdEdldEFyZyhSZWdpc3RlckZpbGU6OkNhbGxl ckZyYW1lLCBYODY6OmVkaSk7CisgICAgICAgICAgICBlbWl0R2V0QXJnKFJlZ2lzdGVyRmlsZTo6 Q2FsbGVyRnJhbWUsIFg4Njo6ZWRpLCBpKTsKIAogICAgICAgICAgICAgLy8gUmV0dXJuLgogICAg ICAgICAgICAgbV9qaXQucHVzaGxfcihYODY6OmVkeCk7CkBAIC0xMzk4LDggKzE0NDYsOCBAQCB2 b2lkIENUSTo6cHJpdmF0ZUNvbXBpbGVNYWluUGFzcygpCiAgICAgICAgICAgICBicmVhazsKICAg ICAgICAgfQogICAgICAgICBjYXNlIG9wX2NvbnN0cnVjdF92ZXJpZnk6IHsKLSAgICAgICAgICAg IGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDFdLnUub3BlcmFuZCwgWDg2OjplYXgpOwotICAg ICAgICAgICAgCisgICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAxXS51Lm9w ZXJhbmQsIFg4Njo6ZWF4LCBpKTsKKwogICAgICAgICAgICAgbV9qaXQudGVzdGxfaTMycihKU0lt bWVkaWF0ZTo6VGFnTWFzaywgWDg2OjplYXgpOwogICAgICAgICAgICAgWDg2QXNzZW1ibGVyOjpK bXBTcmMgaXNJbW1lZGlhdGUgPSBtX2ppdC5lbWl0VW5saW5rZWRKbmUoKTsKICAgICAgICAgICAg IG1faml0Lm1vdmxfbXIoT0JKRUNUX09GRlNFVChKU0NlbGwsIG1fc3RydWN0dXJlSUQpLCBYODY6 OmVheCwgWDg2OjplY3gpOwpAQCAtMTQwNyw3ICsxNDU1LDcgQEAgdm9pZCBDVEk6OnByaXZhdGVD b21waWxlTWFpblBhc3MoKQogICAgICAgICAgICAgWDg2QXNzZW1ibGVyOjpKbXBTcmMgaXNPYmpl Y3QgPSBtX2ppdC5lbWl0VW5saW5rZWRKZSgpOwogCiAgICAgICAgICAgICBtX2ppdC5saW5rKGlz SW1tZWRpYXRlLCBtX2ppdC5sYWJlbCgpKTsKLSAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1 Y3Rpb25baSArIDJdLnUub3BlcmFuZCwgWDg2OjplYXgpOworICAgICAgICAgICAgZW1pdEdldEFy ZyhpbnN0cnVjdGlvbltpICsgMl0udS5vcGVyYW5kLCBYODY6OmVheCwgaSk7CiAgICAgICAgICAg ICBlbWl0UHV0UmVzdWx0KGluc3RydWN0aW9uW2kgKyAxXS51Lm9wZXJhbmQpOwogICAgICAgICAg ICAgbV9qaXQubGluayhpc09iamVjdCwgbV9qaXQubGFiZWwoKSk7CiAKQEAgLTE0MTUsOCArMTQ2 Myw4IEBAIHZvaWQgQ1RJOjpwcml2YXRlQ29tcGlsZU1haW5QYXNzKCkKICAgICAgICAgICAgIGJy ZWFrOwogICAgICAgICB9CiAgICAgICAgIGNhc2Ugb3BfZ2V0X2J5X3ZhbDogewotICAgICAgICAg ICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgMl0udS5vcGVyYW5kLCBYODY6OmVheCk7Ci0g ICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAzXS51Lm9wZXJhbmQsIFg4Njo6 ZWR4KTsKKyAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDJdLnUub3BlcmFu ZCwgWDg2OjplYXgsIGkpOworICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsg M10udS5vcGVyYW5kLCBYODY6OmVkeCwgaSk7CiAgICAgICAgICAgICBlbWl0SnVtcFNsb3dDYXNl SWZOb3RJbW1OdW0oWDg2OjplZHgsIGkpOwogICAgICAgICAgICAgZW1pdEZhc3RBcml0aEltbVRv SW50KFg4Njo6ZWR4KTsKICAgICAgICAgICAgIG1faml0LnRlc3RsX2kzMnIoSlNJbW1lZGlhdGU6 OlRhZ01hc2ssIFg4Njo6ZWF4KTsKQEAgLTE0NTAsOCArMTQ5OCw4IEBAIHZvaWQgQ1RJOjpwcml2 YXRlQ29tcGlsZU1haW5QYXNzKCkKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICB9CiAgICAg ICAgIGNhc2Ugb3BfcHV0X2J5X3ZhbDogewotICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVj dGlvbltpICsgMV0udS5vcGVyYW5kLCBYODY6OmVheCk7Ci0gICAgICAgICAgICBlbWl0R2V0QXJn KGluc3RydWN0aW9uW2kgKyAyXS51Lm9wZXJhbmQsIFg4Njo6ZWR4KTsKKyAgICAgICAgICAgIGVt aXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDFdLnUub3BlcmFuZCwgWDg2OjplYXgsIGkpOworICAg ICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgMl0udS5vcGVyYW5kLCBYODY6OmVk eCwgaSk7CiAgICAgICAgICAgICBlbWl0SnVtcFNsb3dDYXNlSWZOb3RJbW1OdW0oWDg2OjplZHgs IGkpOwogICAgICAgICAgICAgZW1pdEZhc3RBcml0aEltbVRvSW50KFg4Njo6ZWR4KTsKICAgICAg ICAgICAgIG1faml0LnRlc3RsX2kzMnIoSlNJbW1lZGlhdGU6OlRhZ01hc2ssIFg4Njo6ZWF4KTsK QEAgLTE0NzQsNyArMTUyMiw3IEBAIHZvaWQgQ1RJOjpwcml2YXRlQ29tcGlsZU1haW5QYXNzKCkK IAogICAgICAgICAgICAgLy8gQWxsIGdvb2QgLSBwdXQgdGhlIHZhbHVlIGludG8gdGhlIGFycmF5 LgogICAgICAgICAgICAgbV9qaXQubGluayhpbkZhc3RWZWN0b3IsIG1faml0LmxhYmVsKCkpOwot ICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgM10udS5vcGVyYW5kLCBYODY6 OmVheCk7CisgICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAzXS51Lm9wZXJh bmQsIFg4Njo6ZWF4LCBpKTsKICAgICAgICAgICAgIG1faml0Lm1vdmxfcm0oWDg2OjplYXgsIE9C SkVDVF9PRkZTRVQoQXJyYXlTdG9yYWdlLCBtX3ZlY3RvclswXSksIFg4Njo6ZWN4LCBYODY6OmVk eCwgc2l6ZW9mKEpTVmFsdWUqKSk7CiAgICAgICAgICAgICBpICs9IDQ7CiAgICAgICAgICAgICBi cmVhazsKQEAgLTE0ODQsNyArMTUzMiw3IEBAIHZvaWQgQ1RJOjpwcml2YXRlQ29tcGlsZU1haW5Q YXNzKCkKICAgICAgICAgICAgIGVtaXRTbG93U2NyaXB0Q2hlY2soaW5zdHJ1Y3Rpb24gKyBpLCBp KTsKIAogICAgICAgICAgICAgdW5zaWduZWQgdGFyZ2V0ID0gaW5zdHJ1Y3Rpb25baSArIDJdLnUu b3BlcmFuZDsKLSAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDFdLnUub3Bl cmFuZCwgWDg2OjplYXgpOworICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsg MV0udS5vcGVyYW5kLCBYODY6OmVheCwgaSk7CiAKICAgICAgICAgICAgIG1faml0LmNtcGxfaTMy cihhc0ludGVnZXIoSlNJbW1lZGlhdGU6Onplcm9JbW1lZGlhdGUoKSksIFg4Njo6ZWF4KTsKICAg ICAgICAgICAgIFg4NkFzc2VtYmxlcjo6Sm1wU3JjIGlzWmVybyA9IG1faml0LmVtaXRVbmxpbmtl ZEplKCk7CkBAIC0xNTA5LDcgKzE1NTcsNyBAQCB2b2lkIENUSTo6cHJpdmF0ZUNvbXBpbGVNYWlu UGFzcygpCiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQogICAgICAgICBjYXNlIG9wX25l Z2F0ZTogewotICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgMl0udS5vcGVy YW5kLCBYODY6OmVheCk7CisgICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAy XS51Lm9wZXJhbmQsIFg4Njo6ZWF4LCBpKTsKICAgICAgICAgICAgIG1faml0LnRlc3RsX2kzMnIo SlNJbW1lZGlhdGU6OlRhZ0JpdFR5cGVJbnRlZ2VyLCBYODY6OmVheCk7CiAgICAgICAgICAgICBY ODZBc3NlbWJsZXI6OkptcFNyYyBub3RJbW1lZGlhdGUgPSBtX2ppdC5lbWl0VW5saW5rZWRKZSgp OwogCkBAIC0xNTk5LDcgKzE2NDcsNyBAQCB2b2lkIENUSTo6cHJpdmF0ZUNvbXBpbGVNYWluUGFz cygpCiAgICAgICAgIENUSV9DT01QSUxFX0JJTkFSWV9PUChvcF9kaXYpCiAgICAgICAgIGNhc2Ug b3BfcHJlX2RlYzogewogICAgICAgICAgICAgaW50IHNyY0RzdCA9IGluc3RydWN0aW9uW2kgKyAx XS51Lm9wZXJhbmQ7Ci0gICAgICAgICAgICBlbWl0R2V0QXJnKHNyY0RzdCwgWDg2OjplYXgpOwor ICAgICAgICAgICAgZW1pdEdldEFyZyhzcmNEc3QsIFg4Njo6ZWF4LCBpKTsKICAgICAgICAgICAg IGVtaXRKdW1wU2xvd0Nhc2VJZk5vdEltbU51bShYODY6OmVheCwgaSk7CiAgICAgICAgICAgICBt X2ppdC5zdWJsX2k4cihnZXREZVRhZ2dlZENvbnN0YW50SW1tZWRpYXRlKEpTSW1tZWRpYXRlOjpv bmVJbW1lZGlhdGUoKSksIFg4Njo6ZWF4KTsKICAgICAgICAgICAgIG1fc2xvd0Nhc2VzLmFwcGVu ZChTbG93Q2FzZUVudHJ5KG1faml0LmVtaXRVbmxpbmtlZEpvKCksIGkpKTsKQEAgLTE2MTEsMTMg KzE2NTksMTMgQEAgdm9pZCBDVEk6OnByaXZhdGVDb21waWxlTWFpblBhc3MoKQogICAgICAgICAg ICAgdW5zaWduZWQgdGFyZ2V0ID0gaW5zdHJ1Y3Rpb25baSArIDNdLnUub3BlcmFuZDsKICAgICAg ICAgICAgIEpTVmFsdWUqIHNyYzJpbW0gPSBnZXRDb25zdGFudEltbWVkaWF0ZU51bWVyaWNBcmco aW5zdHJ1Y3Rpb25baSArIDJdLnUub3BlcmFuZCk7CiAgICAgICAgICAgICBpZiAoc3JjMmltbSkg ewotICAgICAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDFdLnUub3BlcmFu ZCwgWDg2OjplZHgpOworICAgICAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSAr IDFdLnUub3BlcmFuZCwgWDg2OjplZHgsIGkpOwogICAgICAgICAgICAgICAgIGVtaXRKdW1wU2xv d0Nhc2VJZk5vdEltbU51bShYODY6OmVkeCwgaSk7CiAgICAgICAgICAgICAgICAgbV9qaXQuY21w bF9pMzJyKGFzSW50ZWdlcihzcmMyaW1tKSwgWDg2OjplZHgpOwogICAgICAgICAgICAgICAgIG1f am1wVGFibGUuYXBwZW5kKEptcFRhYmxlKG1faml0LmVtaXRVbmxpbmtlZEpnZSgpLCBpICsgMyAr IHRhcmdldCkpOwogICAgICAgICAgICAgfSBlbHNlIHsKLSAgICAgICAgICAgICAgICBlbWl0R2V0 QXJnKGluc3RydWN0aW9uW2kgKyAxXS51Lm9wZXJhbmQsIFg4Njo6ZWF4KTsKLSAgICAgICAgICAg ICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAyXS51Lm9wZXJhbmQsIFg4Njo6ZWR4KTsK KyAgICAgICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAxXS51Lm9wZXJhbmQs IFg4Njo6ZWF4LCBpKTsKKyAgICAgICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kg KyAyXS51Lm9wZXJhbmQsIFg4Njo6ZWR4LCBpKTsKICAgICAgICAgICAgICAgICBlbWl0SnVtcFNs b3dDYXNlSWZOb3RJbW1OdW0oWDg2OjplYXgsIGkpOwogICAgICAgICAgICAgICAgIGVtaXRKdW1w U2xvd0Nhc2VJZk5vdEltbU51bShYODY6OmVkeCwgaSk7CiAgICAgICAgICAgICAgICAgbV9qaXQu Y21wbF9ycihYODY6OmVkeCwgWDg2OjplYXgpOwpAQCAtMTYyNyw3ICsxNjc1LDcgQEAgdm9pZCBD VEk6OnByaXZhdGVDb21waWxlTWFpblBhc3MoKQogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAg IH0KICAgICAgICAgY2FzZSBvcF9ub3Q6IHsKLSAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1 Y3Rpb25baSArIDJdLnUub3BlcmFuZCwgWDg2OjplYXgpOworICAgICAgICAgICAgZW1pdEdldEFy ZyhpbnN0cnVjdGlvbltpICsgMl0udS5vcGVyYW5kLCBYODY6OmVheCwgaSk7CiAgICAgICAgICAg ICBtX2ppdC54b3JsX2k4cihKU0ltbWVkaWF0ZTo6RnVsbFRhZ1R5cGVCb29sLCBYODY6OmVheCk7 CiAgICAgICAgICAgICBtX2ppdC50ZXN0bF9pMzJyKEpTSW1tZWRpYXRlOjpGdWxsVGFnVHlwZU1h c2ssIFg4Njo6ZWF4KTsgLy8gaTg/CiAgICAgICAgICAgICBtX3Nsb3dDYXNlcy5hcHBlbmQoU2xv d0Nhc2VFbnRyeShtX2ppdC5lbWl0VW5saW5rZWRKbmUoKSwgaSkpOwpAQCAtMTYzOCw3ICsxNjg2 LDcgQEAgdm9pZCBDVEk6OnByaXZhdGVDb21waWxlTWFpblBhc3MoKQogICAgICAgICB9CiAgICAg ICAgIGNhc2Ugb3BfamZhbHNlOiB7CiAgICAgICAgICAgICB1bnNpZ25lZCB0YXJnZXQgPSBpbnN0 cnVjdGlvbltpICsgMl0udS5vcGVyYW5kOwotICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVj dGlvbltpICsgMV0udS5vcGVyYW5kLCBYODY6OmVheCk7CisgICAgICAgICAgICBlbWl0R2V0QXJn KGluc3RydWN0aW9uW2kgKyAxXS51Lm9wZXJhbmQsIFg4Njo6ZWF4LCBpKTsKIAogICAgICAgICAg ICAgbV9qaXQuY21wbF9pMzJyKGFzSW50ZWdlcihKU0ltbWVkaWF0ZTo6emVyb0ltbWVkaWF0ZSgp KSwgWDg2OjplYXgpOwogICAgICAgICAgICAgbV9qbXBUYWJsZS5hcHBlbmQoSm1wVGFibGUobV9q aXQuZW1pdFVubGlua2VkSmUoKSwgaSArIDIgKyB0YXJnZXQpKTsKQEAgLTE2NTgsNyArMTcwNiw3 IEBAIHZvaWQgQ1RJOjpwcml2YXRlQ29tcGlsZU1haW5QYXNzKCkKICAgICAgICAgICAgIHVuc2ln bmVkIHNyYyA9IGluc3RydWN0aW9uW2kgKyAxXS51Lm9wZXJhbmQ7CiAgICAgICAgICAgICB1bnNp Z25lZCB0YXJnZXQgPSBpbnN0cnVjdGlvbltpICsgMl0udS5vcGVyYW5kOwogCi0gICAgICAgICAg ICBlbWl0R2V0QXJnKHNyYywgWDg2OjplYXgpOworICAgICAgICAgICAgZW1pdEdldEFyZyhzcmMs IFg4Njo6ZWF4LCBpKTsKICAgICAgICAgICAgIG1faml0LnRlc3RsX2kzMnIoSlNJbW1lZGlhdGU6 OlRhZ01hc2ssIFg4Njo6ZWF4KTsKICAgICAgICAgICAgIFg4NkFzc2VtYmxlcjo6Sm1wU3JjIGlz SW1tZWRpYXRlID0gbV9qaXQuZW1pdFVubGlua2VkSm56KCk7CiAKQEAgLTE2ODgsNyArMTczNiw3 IEBAIHZvaWQgQ1RJOjpwcml2YXRlQ29tcGlsZU1haW5QYXNzKCkKICAgICAgICAgICAgIHVuc2ln bmVkIHNyYyA9IGluc3RydWN0aW9uW2kgKyAxXS51Lm9wZXJhbmQ7CiAgICAgICAgICAgICB1bnNp Z25lZCB0YXJnZXQgPSBpbnN0cnVjdGlvbltpICsgMl0udS5vcGVyYW5kOwogCi0gICAgICAgICAg ICBlbWl0R2V0QXJnKHNyYywgWDg2OjplYXgpOworICAgICAgICAgICAgZW1pdEdldEFyZyhzcmMs IFg4Njo6ZWF4LCBpKTsKICAgICAgICAgICAgIG1faml0LnRlc3RsX2kzMnIoSlNJbW1lZGlhdGU6 OlRhZ01hc2ssIFg4Njo6ZWF4KTsKICAgICAgICAgICAgIFg4NkFzc2VtYmxlcjo6Sm1wU3JjIGlz SW1tZWRpYXRlID0gbV9qaXQuZW1pdFVubGlua2VkSm56KCk7CiAKQEAgLTE3MTYsNyArMTc2NCw3 IEBAIHZvaWQgQ1RJOjpwcml2YXRlQ29tcGlsZU1haW5QYXNzKCkKICAgICAgICAgfQogICAgICAg ICBjYXNlIG9wX3Bvc3RfaW5jOiB7CiAgICAgICAgICAgICBpbnQgc3JjRHN0ID0gaW5zdHJ1Y3Rp b25baSArIDJdLnUub3BlcmFuZDsKLSAgICAgICAgICAgIGVtaXRHZXRBcmcoc3JjRHN0LCBYODY6 OmVheCk7CisgICAgICAgICAgICBlbWl0R2V0QXJnKHNyY0RzdCwgWDg2OjplYXgsIGkpOwogICAg ICAgICAgICAgbV9qaXQubW92bF9ycihYODY6OmVheCwgWDg2OjplZHgpOwogICAgICAgICAgICAg ZW1pdEp1bXBTbG93Q2FzZUlmTm90SW1tTnVtKFg4Njo6ZWF4LCBpKTsKICAgICAgICAgICAgIG1f aml0LmFkZGxfaThyKGdldERlVGFnZ2VkQ29uc3RhbnRJbW1lZGlhdGUoSlNJbW1lZGlhdGU6Om9u ZUltbWVkaWF0ZSgpKSwgWDg2OjplZHgpOwpAQCAtMTc1MCw4ICsxNzk4LDggQEAgdm9pZCBDVEk6 OnByaXZhdGVDb21waWxlTWFpblBhc3MoKQogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIH0K ICAgICAgICAgY2FzZSBvcF9lcTogewotICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlv bltpICsgMl0udS5vcGVyYW5kLCBYODY6OmVheCk7Ci0gICAgICAgICAgICBlbWl0R2V0QXJnKGlu c3RydWN0aW9uW2kgKyAzXS51Lm9wZXJhbmQsIFg4Njo6ZWR4KTsKKyAgICAgICAgICAgIGVtaXRH ZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDJdLnUub3BlcmFuZCwgWDg2OjplYXgsIGkpOworICAgICAg ICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgM10udS5vcGVyYW5kLCBYODY6OmVkeCwg aSk7CiAgICAgICAgICAgICBlbWl0SnVtcFNsb3dDYXNlSWZOb3RJbW1OdW1zKFg4Njo6ZWF4LCBY ODY6OmVkeCwgaSk7CiAgICAgICAgICAgICBtX2ppdC5jbXBsX3JyKFg4Njo6ZWR4LCBYODY6OmVh eCk7CiAgICAgICAgICAgICBtX2ppdC5zZXRlX3IoWDg2OjplYXgpOwpAQCAtMTc2Miw4ICsxODEw LDggQEAgdm9pZCBDVEk6OnByaXZhdGVDb21waWxlTWFpblBhc3MoKQogICAgICAgICAgICAgYnJl YWs7CiAgICAgICAgIH0KICAgICAgICAgY2FzZSBvcF9sc2hpZnQ6IHsKLSAgICAgICAgICAgIGVt aXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDJdLnUub3BlcmFuZCwgWDg2OjplYXgpOwotICAgICAg ICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgM10udS5vcGVyYW5kLCBYODY6OmVjeCk7 CisgICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAyXS51Lm9wZXJhbmQsIFg4 Njo6ZWF4LCBpKTsKKyAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDNdLnUu b3BlcmFuZCwgWDg2OjplY3gsIGkpOwogICAgICAgICAgICAgZW1pdEp1bXBTbG93Q2FzZUlmTm90 SW1tTnVtKFg4Njo6ZWF4LCBpKTsKICAgICAgICAgICAgIGVtaXRKdW1wU2xvd0Nhc2VJZk5vdElt bU51bShYODY6OmVjeCwgaSk7CiAgICAgICAgICAgICBlbWl0RmFzdEFyaXRoSW1tVG9JbnQoWDg2 OjplYXgpOwpAQCAtMTc3OSwxOCArMTgyNywxOCBAQCB2b2lkIENUSTo6cHJpdmF0ZUNvbXBpbGVN YWluUGFzcygpCiAgICAgICAgICAgICB1bnNpZ25lZCBzcmMyID0gaW5zdHJ1Y3Rpb25baSArIDNd LnUub3BlcmFuZDsKICAgICAgICAgICAgIHVuc2lnbmVkIGRzdCA9IGluc3RydWN0aW9uW2kgKyAx XS51Lm9wZXJhbmQ7CiAgICAgICAgICAgICBpZiAoSlNWYWx1ZSogdmFsdWUgPSBnZXRDb25zdGFu dEltbWVkaWF0ZU51bWVyaWNBcmcoc3JjMSkpIHsKLSAgICAgICAgICAgICAgICBlbWl0R2V0QXJn KHNyYzIsIFg4Njo6ZWF4KTsKKyAgICAgICAgICAgICAgICBlbWl0R2V0QXJnKHNyYzIsIFg4Njo6 ZWF4LCBpKTsKICAgICAgICAgICAgICAgICBlbWl0SnVtcFNsb3dDYXNlSWZOb3RJbW1OdW0oWDg2 OjplYXgsIGkpOwogICAgICAgICAgICAgICAgIG1faml0LmFuZGxfaTMycihhc0ludGVnZXIodmFs dWUpLCBYODY6OmVheCk7IC8vIEZJWE1FOiBtYWtlIGl0IG1vcmUgb2J2aW91cyB0aGlzIGlzIHJl bHlpbmcgb24gdGhlIGZvcm1hdCBvZiBKU0ltbWVkaWF0ZQogICAgICAgICAgICAgICAgIGVtaXRQ dXRSZXN1bHQoZHN0KTsKICAgICAgICAgICAgIH0gZWxzZSBpZiAoSlNWYWx1ZSogdmFsdWUgPSBn ZXRDb25zdGFudEltbWVkaWF0ZU51bWVyaWNBcmcoc3JjMikpIHsKLSAgICAgICAgICAgICAgICBl bWl0R2V0QXJnKHNyYzEsIFg4Njo6ZWF4KTsKKyAgICAgICAgICAgICAgICBlbWl0R2V0QXJnKHNy YzEsIFg4Njo6ZWF4LCBpKTsKICAgICAgICAgICAgICAgICBlbWl0SnVtcFNsb3dDYXNlSWZOb3RJ bW1OdW0oWDg2OjplYXgsIGkpOwogICAgICAgICAgICAgICAgIG1faml0LmFuZGxfaTMycihhc0lu dGVnZXIodmFsdWUpLCBYODY6OmVheCk7CiAgICAgICAgICAgICAgICAgZW1pdFB1dFJlc3VsdChk c3QpOwogICAgICAgICAgICAgfSBlbHNlIHsKLSAgICAgICAgICAgICAgICBlbWl0R2V0QXJnKHNy YzEsIFg4Njo6ZWF4KTsKLSAgICAgICAgICAgICAgICBlbWl0R2V0QXJnKHNyYzIsIFg4Njo6ZWR4 KTsKKyAgICAgICAgICAgICAgICBlbWl0R2V0QXJnKHNyYzEsIFg4Njo6ZWF4LCBpKTsKKyAgICAg ICAgICAgICAgICBlbWl0R2V0QXJnKHNyYzIsIFg4Njo6ZWR4LCBpKTsKICAgICAgICAgICAgICAg ICBtX2ppdC5hbmRsX3JyKFg4Njo6ZWR4LCBYODY6OmVheCk7CiAgICAgICAgICAgICAgICAgZW1p dEp1bXBTbG93Q2FzZUlmTm90SW1tTnVtKFg4Njo6ZWF4LCBpKTsKICAgICAgICAgICAgICAgICBl bWl0UHV0UmVzdWx0KGRzdCk7CkBAIC0xNzk5LDggKzE4NDcsOCBAQCB2b2lkIENUSTo6cHJpdmF0 ZUNvbXBpbGVNYWluUGFzcygpCiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQogICAgICAg ICBjYXNlIG9wX3JzaGlmdDogewotICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltp ICsgMl0udS5vcGVyYW5kLCBYODY6OmVheCk7Ci0gICAgICAgICAgICBlbWl0R2V0QXJnKGluc3Ry dWN0aW9uW2kgKyAzXS51Lm9wZXJhbmQsIFg4Njo6ZWN4KTsKKyAgICAgICAgICAgIGVtaXRHZXRB cmcoaW5zdHJ1Y3Rpb25baSArIDJdLnUub3BlcmFuZCwgWDg2OjplYXgsIGkpOworICAgICAgICAg ICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgM10udS5vcGVyYW5kLCBYODY6OmVjeCwgaSk7 CiAgICAgICAgICAgICBlbWl0SnVtcFNsb3dDYXNlSWZOb3RJbW1OdW0oWDg2OjplYXgsIGkpOwog ICAgICAgICAgICAgZW1pdEp1bXBTbG93Q2FzZUlmTm90SW1tTnVtKFg4Njo6ZWN4LCBpKTsKICAg ICAgICAgICAgIGVtaXRGYXN0QXJpdGhJbW1Ub0ludChYODY6OmVjeCk7CkBAIC0xODExLDcgKzE4 NTksNyBAQCB2b2lkIENUSTo6cHJpdmF0ZUNvbXBpbGVNYWluUGFzcygpCiAgICAgICAgICAgICBi cmVhazsKICAgICAgICAgfQogICAgICAgICBjYXNlIG9wX2JpdG5vdDogewotICAgICAgICAgICAg ZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgMl0udS5vcGVyYW5kLCBYODY6OmVheCk7CisgICAg ICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAyXS51Lm9wZXJhbmQsIFg4Njo6ZWF4 LCBpKTsKICAgICAgICAgICAgIGVtaXRKdW1wU2xvd0Nhc2VJZk5vdEltbU51bShYODY6OmVheCwg aSk7CiAgICAgICAgICAgICBtX2ppdC54b3JsX2k4cih+SlNJbW1lZGlhdGU6OlRhZ0JpdFR5cGVJ bnRlZ2VyLCBYODY6OmVheCk7CiAgICAgICAgICAgICBlbWl0UHV0UmVzdWx0KGluc3RydWN0aW9u W2kgKyAxXS51Lm9wZXJhbmQpOwpAQCAtMTgzNiw4ICsxODg0LDggQEAgdm9pZCBDVEk6OnByaXZh dGVDb21waWxlTWFpblBhc3MoKQogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIH0KICAgICAg ICAgY2FzZSBvcF9tb2Q6IHsKLSAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSAr IDJdLnUub3BlcmFuZCwgWDg2OjplYXgpOwotICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVj dGlvbltpICsgM10udS5vcGVyYW5kLCBYODY6OmVjeCk7CisgICAgICAgICAgICBlbWl0R2V0QXJn KGluc3RydWN0aW9uW2kgKyAyXS51Lm9wZXJhbmQsIFg4Njo6ZWF4LCBpKTsKKyAgICAgICAgICAg IGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDNdLnUub3BlcmFuZCwgWDg2OjplY3gsIGkpOwog ICAgICAgICAgICAgZW1pdEp1bXBTbG93Q2FzZUlmTm90SW1tTnVtKFg4Njo6ZWF4LCBpKTsKICAg ICAgICAgICAgIGVtaXRKdW1wU2xvd0Nhc2VJZk5vdEltbU51bShYODY6OmVjeCwgaSk7CiAgICAg ICAgICAgICBlbWl0RmFzdEFyaXRoRGVUYWdJbW1lZGlhdGUoWDg2OjplYXgpOwpAQCAtMTg1Miw3 ICsxOTAwLDcgQEAgdm9pZCBDVEk6OnByaXZhdGVDb21waWxlTWFpblBhc3MoKQogICAgICAgICB9 CiAgICAgICAgIGNhc2Ugb3BfanRydWU6IHsKICAgICAgICAgICAgIHVuc2lnbmVkIHRhcmdldCA9 IGluc3RydWN0aW9uW2kgKyAyXS51Lm9wZXJhbmQ7Ci0gICAgICAgICAgICBlbWl0R2V0QXJnKGlu c3RydWN0aW9uW2kgKyAxXS51Lm9wZXJhbmQsIFg4Njo6ZWF4KTsKKyAgICAgICAgICAgIGVtaXRH ZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDFdLnUub3BlcmFuZCwgWDg2OjplYXgsIGkpOwogCiAgICAg ICAgICAgICBtX2ppdC5jbXBsX2kzMnIoYXNJbnRlZ2VyKEpTSW1tZWRpYXRlOjp6ZXJvSW1tZWRp YXRlKCkpLCBYODY6OmVheCk7CiAgICAgICAgICAgICBYODZBc3NlbWJsZXI6OkptcFNyYyBpc1pl cm8gPSBtX2ppdC5lbWl0VW5saW5rZWRKZSgpOwpAQCAtMTg3MCw4ICsxOTE4LDggQEAgdm9pZCBD VEk6OnByaXZhdGVDb21waWxlTWFpblBhc3MoKQogICAgICAgICB9CiAgICAgICAgIENUSV9DT01Q SUxFX0JJTkFSWV9PUChvcF9sZXNzKQogICAgICAgICBjYXNlIG9wX25lcTogewotICAgICAgICAg ICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgMl0udS5vcGVyYW5kLCBYODY6OmVheCk7Ci0g ICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAzXS51Lm9wZXJhbmQsIFg4Njo6 ZWR4KTsKKyAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDJdLnUub3BlcmFu ZCwgWDg2OjplYXgsIGkpOworICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsg M10udS5vcGVyYW5kLCBYODY6OmVkeCwgaSk7CiAgICAgICAgICAgICBlbWl0SnVtcFNsb3dDYXNl SWZOb3RJbW1OdW1zKFg4Njo6ZWF4LCBYODY6OmVkeCwgaSk7CiAgICAgICAgICAgICBtX2ppdC5j bXBsX3JyKFg4Njo6ZWF4LCBYODY6OmVkeCk7CiAKQEAgLTE4ODYsNyArMTkzNCw3IEBAIHZvaWQg Q1RJOjpwcml2YXRlQ29tcGlsZU1haW5QYXNzKCkKICAgICAgICAgfQogICAgICAgICBjYXNlIG9w X3Bvc3RfZGVjOiB7CiAgICAgICAgICAgICBpbnQgc3JjRHN0ID0gaW5zdHJ1Y3Rpb25baSArIDJd LnUub3BlcmFuZDsKLSAgICAgICAgICAgIGVtaXRHZXRBcmcoc3JjRHN0LCBYODY6OmVheCk7Cisg ICAgICAgICAgICBlbWl0R2V0QXJnKHNyY0RzdCwgWDg2OjplYXgsIGkpOwogICAgICAgICAgICAg bV9qaXQubW92bF9ycihYODY6OmVheCwgWDg2OjplZHgpOwogICAgICAgICAgICAgZW1pdEp1bXBT bG93Q2FzZUlmTm90SW1tTnVtKFg4Njo6ZWF4LCBpKTsKICAgICAgICAgICAgIG1faml0LnN1Ymxf aThyKGdldERlVGFnZ2VkQ29uc3RhbnRJbW1lZGlhdGUoSlNJbW1lZGlhdGU6Om9uZUltbWVkaWF0 ZSgpKSwgWDg2OjplZHgpOwpAQCAtMTg5OCw4ICsxOTQ2LDggQEAgdm9pZCBDVEk6OnByaXZhdGVD b21waWxlTWFpblBhc3MoKQogICAgICAgICB9CiAgICAgICAgIENUSV9DT01QSUxFX0JJTkFSWV9P UChvcF91cnNoaWZ0KQogICAgICAgICBjYXNlIG9wX2JpdHhvcjogewotICAgICAgICAgICAgZW1p dEdldEFyZyhpbnN0cnVjdGlvbltpICsgMl0udS5vcGVyYW5kLCBYODY6OmVheCk7Ci0gICAgICAg ICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAzXS51Lm9wZXJhbmQsIFg4Njo6ZWR4KTsK KyAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDJdLnUub3BlcmFuZCwgWDg2 OjplYXgsIGkpOworICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgM10udS5v cGVyYW5kLCBYODY6OmVkeCwgaSk7CiAgICAgICAgICAgICBlbWl0SnVtcFNsb3dDYXNlSWZOb3RJ bW1OdW1zKFg4Njo6ZWF4LCBYODY6OmVkeCwgaSk7CiAgICAgICAgICAgICBtX2ppdC54b3JsX3Jy KFg4Njo6ZWR4LCBYODY6OmVheCk7CiAgICAgICAgICAgICBlbWl0RmFzdEFyaXRoUmVUYWdJbW1l ZGlhdGUoWDg2OjplYXgpOwpAQCAtMTkxNiw4ICsxOTY0LDggQEAgdm9pZCBDVEk6OnByaXZhdGVD b21waWxlTWFpblBhc3MoKQogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIH0KICAgICAgICAg Y2FzZSBvcF9iaXRvcjogewotICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsg Ml0udS5vcGVyYW5kLCBYODY6OmVheCk7Ci0gICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0 aW9uW2kgKyAzXS51Lm9wZXJhbmQsIFg4Njo6ZWR4KTsKKyAgICAgICAgICAgIGVtaXRHZXRBcmco aW5zdHJ1Y3Rpb25baSArIDJdLnUub3BlcmFuZCwgWDg2OjplYXgsIGkpOworICAgICAgICAgICAg ZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgM10udS5vcGVyYW5kLCBYODY6OmVkeCwgaSk7CiAg ICAgICAgICAgICBlbWl0SnVtcFNsb3dDYXNlSWZOb3RJbW1OdW1zKFg4Njo6ZWF4LCBYODY6OmVk eCwgaSk7CiAgICAgICAgICAgICBtX2ppdC5vcmxfcnIoWDg2OjplZHgsIFg4Njo6ZWF4KTsKICAg ICAgICAgICAgIGVtaXRQdXRSZXN1bHQoaW5zdHJ1Y3Rpb25baSArIDFdLnUub3BlcmFuZCk7CkBA IC0xOTgzLDcgKzIwMzEsNyBAQCB2b2lkIENUSTo6cHJpdmF0ZUNvbXBpbGVNYWluUGFzcygpCiAg ICAgICAgICAgICBicmVhazsKICAgICAgICAgfQogICAgICAgICBjYXNlIG9wX3RvX2pzbnVtYmVy OiB7Ci0gICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAyXS51Lm9wZXJhbmQs IFg4Njo6ZWF4KTsKKyAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDJdLnUu b3BlcmFuZCwgWDg2OjplYXgsIGkpOwogICAgICAgICAgICAgCiAgICAgICAgICAgICBtX2ppdC50 ZXN0bF9pMzJyKEpTSW1tZWRpYXRlOjpUYWdCaXRUeXBlSW50ZWdlciwgWDg2OjplYXgpOwogICAg ICAgICAgICAgWDg2QXNzZW1ibGVyOjpKbXBTcmMgd2FzSW1tZWRpYXRlID0gbV9qaXQuZW1pdFVu bGlua2VkSm56KCk7CkBAIC0yMTM5LDcgKzIxODcsNyBAQCB2b2lkIENUSTo6cHJpdmF0ZUNvbXBp bGVNYWluUGFzcygpCiAgICAgICAgICAgICB1bnNpZ25lZCBkc3QgPSBpbnN0cnVjdGlvbltpICsg MV0udS5vcGVyYW5kOwogICAgICAgICAgICAgdW5zaWduZWQgc3JjMSA9IGluc3RydWN0aW9uW2kg KyAyXS51Lm9wZXJhbmQ7CiAKLSAgICAgICAgICAgIGVtaXRHZXRBcmcoc3JjMSwgWDg2OjplYXgp OworICAgICAgICAgICAgZW1pdEdldEFyZyhzcmMxLCBYODY6OmVheCwgaSk7CiAgICAgICAgICAg ICBtX2ppdC50ZXN0bF9pMzJyKEpTSW1tZWRpYXRlOjpUYWdNYXNrLCBYODY6OmVheCk7CiAgICAg ICAgICAgICBYODZBc3NlbWJsZXI6OkptcFNyYyBpc0ltbWVkaWF0ZSA9IG1faml0LmVtaXRVbmxp bmtlZEpueigpOwogCkBAIC0yMTY5LDcgKzIyMTcsNyBAQCB2b2lkIENUSTo6cHJpdmF0ZUNvbXBp bGVNYWluUGFzcygpCiAgICAgICAgICAgICB1bnNpZ25lZCBkc3QgPSBpbnN0cnVjdGlvbltpICsg MV0udS5vcGVyYW5kOwogICAgICAgICAgICAgdW5zaWduZWQgc3JjMSA9IGluc3RydWN0aW9uW2kg KyAyXS51Lm9wZXJhbmQ7CiAKLSAgICAgICAgICAgIGVtaXRHZXRBcmcoc3JjMSwgWDg2OjplYXgp OworICAgICAgICAgICAgZW1pdEdldEFyZyhzcmMxLCBYODY6OmVheCwgaSk7CiAgICAgICAgICAg ICBtX2ppdC50ZXN0bF9pMzJyKEpTSW1tZWRpYXRlOjpUYWdNYXNrLCBYODY6OmVheCk7CiAgICAg ICAgICAgICBYODZBc3NlbWJsZXI6OkptcFNyYyBpc0ltbWVkaWF0ZSA9IG1faml0LmVtaXRVbmxp bmtlZEpueigpOwogCkBAIC0yMjI2LDcgKzIyNzQsNyBAQCB2b2lkIENUSTo6cHJpdmF0ZUNvbXBp bGVNYWluUGFzcygpCiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQogICAgICAgICBjYXNl IG9wX2NvbnZlcnRfdGhpczogewotICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltp ICsgMV0udS5vcGVyYW5kLCBYODY6OmVheCk7CisgICAgICAgICAgICBlbWl0R2V0QXJnKGluc3Ry dWN0aW9uW2kgKyAxXS51Lm9wZXJhbmQsIFg4Njo6ZWF4LCBpKTsKIAogICAgICAgICAgICAgZW1p dEp1bXBTbG93Q2FzZUlmTm90SlNDZWxsKFg4Njo6ZWF4LCBpKTsKICAgICAgICAgICAgIG1faml0 Lm1vdmxfbXIoT0JKRUNUX09GRlNFVChKU0NlbGwsIG1fc3RydWN0dXJlSUQpLCBYODY6OmVheCwg WDg2OjplZHgpOwpAQCAtMjMwMiw2ICsyMzUwLDkgQEAgdm9pZCBDVEk6OnByaXZhdGVDb21waWxl U2xvd0Nhc2VzKCkKIAogICAgIEluc3RydWN0aW9uKiBpbnN0cnVjdGlvbiA9IG1fY29kZUJsb2Nr LT5pbnN0cnVjdGlvbnMuYmVnaW4oKTsKICAgICBmb3IgKFZlY3RvcjxTbG93Q2FzZUVudHJ5Pjo6 aXRlcmF0b3IgaXRlciA9IG1fc2xvd0Nhc2VzLmJlZ2luKCk7IGl0ZXIgIT0gbV9zbG93Q2FzZXMu ZW5kKCk7ICsraXRlcikgeworICAgICAgICAvLyBGSVhNRTogZW5hYmxlIHBlZXBob2xlIG9wdGlt aXphdGlvbnMgZm9yIHNsb3cgY2FzZXMgd2hlbiBhcHBsaWNhYmxlCisgICAgICAgIGludmFsaWRh dGVQZWVwaG9sZU9wdGltaXphdGlvbnMoKTsKKwogICAgICAgICB1bnNpZ25lZCBpID0gaXRlci0+ dG87CiAgICAgICAgIHN3aXRjaCAoT3Bjb2RlSUQgb3Bjb2RlSUQgPSBtX21hY2hpbmUtPmdldE9w Y29kZUlEKGluc3RydWN0aW9uW2ldLnUub3Bjb2RlKSkgewogICAgICAgICBjYXNlIG9wX2NvbnZl cnRfdGhpczogewpAQCAtMjM3Miw4ICsyNDIzLDkgQEAgdm9pZCBDVEk6OnByaXZhdGVDb21waWxl U2xvd0Nhc2VzKCkKICAgICAgICAgICAgIC8vIENoZWNrIHdoZXRoZXIgdGhlIHZhbHVlIGxvYWRl ZCBpcyB6ZXJvOyBpZiBzbyB3ZSBuZWVkIHRvIHJldHVybiB1bmRlZmluZWQuCiAgICAgICAgICAg ICBtX2ppdC50ZXN0bF9ycihYODY6OmVjeCwgWDg2OjplY3gpOwogICAgICAgICAgICAgbV9qaXQu bGluayhtX2ppdC5lbWl0VW5saW5rZWRKZSgpLCBiZWdpbkdldEJ5VmFsU2xvdyk7Ci0gICAgICAg ICAgICBlbWl0UHV0UmVzdWx0KGluc3RydWN0aW9uW2kgKyAxXS51Lm9wZXJhbmQsIFg4Njo6ZWN4 KTsKLSAgICAgICAgICAgIAorICAgICAgICAgICAgbV9qaXQubW92bF9ycihYODY6OmVjeCwgWDg2 OjplYXgpOworICAgICAgICAgICAgZW1pdFB1dFJlc3VsdChpbnN0cnVjdGlvbltpICsgMV0udS5v cGVyYW5kLCBYODY6OmVheCk7CisKICAgICAgICAgICAgIGkgKz0gNDsKICAgICAgICAgICAgIGJy ZWFrOwogICAgICAgICB9CkBAIC0yNDA0LDggKzI0NTYsOCBAQCB2b2lkIENUSTo6cHJpdmF0ZUNv bXBpbGVTbG93Q2FzZXMoKQogICAgICAgICAgICAgWDg2QXNzZW1ibGVyOjpKbXBTcmMgbm90SW1t MSA9IGl0ZXItPmZyb207CiAgICAgICAgICAgICBYODZBc3NlbWJsZXI6OkptcFNyYyBub3RJbW0y ID0gKCsraXRlciktPmZyb207CiAgICAgICAgICAgICBtX2ppdC5saW5rKCgrK2l0ZXIpLT5mcm9t LCBtX2ppdC5sYWJlbCgpKTsKLSAgICAgICAgICAgIGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSAr IDJdLnUub3BlcmFuZCwgWDg2OjplYXgpOwotICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVj dGlvbltpICsgM10udS5vcGVyYW5kLCBYODY6OmVjeCk7CisgICAgICAgICAgICBlbWl0R2V0QXJn KGluc3RydWN0aW9uW2kgKyAyXS51Lm9wZXJhbmQsIFg4Njo6ZWF4LCBpKTsKKyAgICAgICAgICAg IGVtaXRHZXRBcmcoaW5zdHJ1Y3Rpb25baSArIDNdLnUub3BlcmFuZCwgWDg2OjplY3gsIGkpOwog ICAgICAgICAgICAgbV9qaXQubGluayhub3RJbW0xLCBtX2ppdC5sYWJlbCgpKTsKICAgICAgICAg ICAgIG1faml0Lmxpbmsobm90SW1tMiwgbV9qaXQubGFiZWwoKSk7CiAgICAgICAgICAgICBlbWl0 UHV0QXJnKFg4Njo6ZWF4LCAwKTsKQEAgLTI1MjgsNyArMjU4MCw3IEBAIHZvaWQgQ1RJOjpwcml2 YXRlQ29tcGlsZVNsb3dDYXNlcygpCiAgICAgICAgICAgICBtX2ppdC5saW5rKCgrK2l0ZXIpLT5m cm9tLCBtX2ppdC5sYWJlbCgpKTsKICAgICAgICAgICAgIGVtaXRGYXN0QXJpdGhJbnRUb0ltbU5v Q2hlY2soWDg2OjplZHgpOwogICAgICAgICAgICAgbV9qaXQubGluayhub3RJbW0sIG1faml0Lmxh YmVsKCkpOwotICAgICAgICAgICAgZW1pdEdldEFyZyhpbnN0cnVjdGlvbltpICsgM10udS5vcGVy YW5kLCBYODY6OmVjeCk7CisgICAgICAgICAgICBlbWl0R2V0QXJnKGluc3RydWN0aW9uW2kgKyAz XS51Lm9wZXJhbmQsIFg4Njo6ZWN4LCBpKTsKICAgICAgICAgICAgIGVtaXRQdXRBcmcoWDg2Ojpl YXgsIDApOwogICAgICAgICAgICAgZW1pdFB1dEFyZyhYODY6OmVkeCwgNCk7CiAgICAgICAgICAg ICBlbWl0UHV0QXJnKFg4Njo6ZWN4LCA4KTsKQEAgLTI1MzgsNyArMjU5MCw3IEBAIHZvaWQgQ1RJ Ojpwcml2YXRlQ29tcGlsZVNsb3dDYXNlcygpCiAgICAgICAgICAgICAvLyBzbG93IGNhc2VzIGZv ciBpbW1lZGlhdGUgaW50IGFjY2Vzc2VzIHRvIGFycmF5cwogICAgICAgICAgICAgbV9qaXQubGlu aygoKytpdGVyKS0+ZnJvbSwgbV9qaXQubGFiZWwoKSk7CiAgICAgICAgICAgICBtX2ppdC5saW5r KCgrK2l0ZXIpLT5mcm9tLCBtX2ppdC5sYWJlbCgpKTsKLSAgICAgICAgICAgIGVtaXRHZXRBcmco aW5zdHJ1Y3Rpb25baSArIDNdLnUub3BlcmFuZCwgWDg2OjplY3gpOworICAgICAgICAgICAgZW1p dEdldEFyZyhpbnN0cnVjdGlvbltpICsgM10udS5vcGVyYW5kLCBYODY6OmVjeCwgaSk7CiAgICAg ICAgICAgICBlbWl0UHV0QXJnKFg4Njo6ZWF4LCAwKTsKICAgICAgICAgICAgIGVtaXRQdXRBcmco WDg2OjplZHgsIDQpOwogICAgICAgICAgICAgZW1pdFB1dEFyZyhYODY6OmVjeCwgOCk7CkBAIC0y NjE4LDggKzI2NzAsOCBAQCB2b2lkIENUSTo6cHJpdmF0ZUNvbXBpbGVTbG93Q2FzZXMoKQogICAg ICAgICAgICAgbV9qaXQubGluaygoKytpdGVyKS0+ZnJvbSwgbV9qaXQubGFiZWwoKSk7CiAgICAg ICAgICAgICBlbWl0UHV0QXJnKFg4Njo6ZWF4LCAwKTsKICAgICAgICAgICAgIGVtaXRDVElDYWxs KGluc3RydWN0aW9uICsgaSwgaSwgTWFjaGluZTo6Y3RpX29wX3Bvc3RfaW5jKTsKLSAgICAgICAg ICAgIGVtaXRQdXRSZXN1bHQoaW5zdHJ1Y3Rpb25baSArIDFdLnUub3BlcmFuZCk7CiAgICAgICAg ICAgICBlbWl0UHV0UmVzdWx0KHNyY0RzdCwgWDg2OjplZHgpOworICAgICAgICAgICAgZW1pdFB1 dFJlc3VsdChpbnN0cnVjdGlvbltpICsgMV0udS5vcGVyYW5kKTsKICAgICAgICAgICAgIGkgKz0g MzsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICB9CkBAIC0yNjczLDggKzI3MjUsOCBAQCB2 b2lkIENUSTo6cHJpdmF0ZUNvbXBpbGVTbG93Q2FzZXMoKQogICAgICAgICAgICAgbV9qaXQubGlu aygoKytpdGVyKS0+ZnJvbSwgbV9qaXQubGFiZWwoKSk7CiAgICAgICAgICAgICBlbWl0UHV0QXJn KFg4Njo6ZWF4LCAwKTsKICAgICAgICAgICAgIGVtaXRDVElDYWxsKGluc3RydWN0aW9uICsgaSwg aSwgTWFjaGluZTo6Y3RpX29wX3Bvc3RfZGVjKTsKLSAgICAgICAgICAgIGVtaXRQdXRSZXN1bHQo aW5zdHJ1Y3Rpb25baSArIDFdLnUub3BlcmFuZCk7CiAgICAgICAgICAgICBlbWl0UHV0UmVzdWx0 KHNyY0RzdCwgWDg2OjplZHgpOworICAgICAgICAgICAgZW1pdFB1dFJlc3VsdChpbnN0cnVjdGlv bltpICsgMV0udS5vcGVyYW5kKTsKICAgICAgICAgICAgIGkgKz0gMzsKICAgICAgICAgICAgIGJy ZWFrOwogICAgICAgICB9CkBAIC0yNzk0LDcgKzI4NDYsNyBAQCB2b2lkIENUSTo6cHJpdmF0ZUNv bXBpbGVTbG93Q2FzZXMoKQogICAgICAgICAgICAgaWYgKG9wY29kZUlEID09IG9wX2NvbnN0cnVj dCkgewogICAgICAgICAgICAgICAgIGVtaXRDVElDYWxsKGluc3RydWN0aW9uLCBpLCBNYWNoaW5l OjpjdGlfb3BfY29uc3RydWN0X0pTQ29uc3RydWN0KTsKICAgICAgICAgICAgICAgICBlbWl0UHV0 UmVzdWx0KHJlZ2lzdGVyT2Zmc2V0IC0gUmVnaXN0ZXJGaWxlOjpDYWxsRnJhbWVIZWFkZXJTaXpl IC0gYXJnQ291bnQpOwotICAgICAgICAgICAgICAgIGVtaXRHZXRBcmcoY2FsbGVlLCBYODY6OmVj eCk7CisgICAgICAgICAgICAgICAgZW1pdEdldEFyZyhjYWxsZWUsIFg4Njo6ZWN4LCBpKTsKICAg ICAgICAgICAgIH0KIAogICAgICAgICAgICAgLy8gTG9hZCB0aGUgY2FsbGVlIENvZGVCbG9jayog aW50byBlYXgKQEAgLTI4MDMsNyArMjg1NSw3IEBAIHZvaWQgQ1RJOjpwcml2YXRlQ29tcGlsZVNs b3dDYXNlcygpCiAgICAgICAgICAgICBtX2ppdC50ZXN0bF9ycihYODY6OmVheCwgWDg2OjplYXgp OwogICAgICAgICAgICAgWDg2QXNzZW1ibGVyOjpKbXBTcmMgaGFzQ29kZUJsb2NrRm9yTGluayA9 IG1faml0LmVtaXRVbmxpbmtlZEpuZSgpOwogICAgICAgICAgICAgZW1pdENUSUNhbGwoaW5zdHJ1 Y3Rpb24gKyBpLCBpLCBNYWNoaW5lOjpjdGlfb3BfY2FsbF9KU0Z1bmN0aW9uKTsKLSAgICAgICAg ICAgIGVtaXRHZXRBcmcoY2FsbGVlLCBYODY6OmVjeCk7CisgICAgICAgICAgICBlbWl0R2V0QXJn KGNhbGxlZSwgWDg2OjplY3gsIGkpOwogICAgICAgICAgICAgbV9qaXQubGluayhoYXNDb2RlQmxv Y2tGb3JMaW5rLCBtX2ppdC5sYWJlbCgpKTsKIAogICAgICAgICAgICAgLy8gU3BlY3VsYXRpdmVs eSByb2xsIHRoZSBjYWxsZnJhbWUsIGFzc3VtaW5nIGFyZ0NvdW50IHdpbGwgbWF0Y2ggdGhlIGFy aXR5LgpAQCAtMjgxNSw3ICsyODY3LDcgQEAgdm9pZCBDVEk6OnByaXZhdGVDb21waWxlU2xvd0Nh c2VzKCkKICAgICAgICAgICAgIFg4NkFzc2VtYmxlcjo6Sm1wU3JjIGFyaXR5Q2hlY2tPa2F5Rm9y TGluayA9IG1faml0LmVtaXRVbmxpbmtlZEplKCk7CiAgICAgICAgICAgICBlbWl0UHV0QXJnKFg4 Njo6ZWF4LCAxMik7CiAgICAgICAgICAgICBlbWl0Q1RJQ2FsbChpbnN0cnVjdGlvbiArIGksIGks IE1hY2hpbmU6OmN0aV9vcF9jYWxsX2FyaXR5Q2hlY2spOwotICAgICAgICAgICAgZW1pdEdldEFy ZyhjYWxsZWUgLSByZWdpc3Rlck9mZnNldCwgWDg2OjplY3gpOworICAgICAgICAgICAgZW1pdEdl dEFyZyhjYWxsZWUgLSByZWdpc3Rlck9mZnNldCwgWDg2OjplY3gsIGkpOwogICAgICAgICAgICAg bV9qaXQubW92bF9ycihYODY6OmVkeCwgWDg2OjplZGkpOwogICAgICAgICAgICAgbV9qaXQubGlu ayhhcml0eUNoZWNrT2theUZvckxpbmssIG1faml0LmxhYmVsKCkpOwogCkBAIC0yODYwLDcgKzI5 MTIsNyBAQCB2b2lkIENUSTo6cHJpdmF0ZUNvbXBpbGVTbG93Q2FzZXMoKQogICAgICAgICAgICAg aWYgKG9wY29kZUlEID09IG9wX2NvbnN0cnVjdCkgewogICAgICAgICAgICAgICAgIGVtaXRDVElD YWxsKGluc3RydWN0aW9uLCBpLCBNYWNoaW5lOjpjdGlfb3BfY29uc3RydWN0X0pTQ29uc3RydWN0 KTsKICAgICAgICAgICAgICAgICBlbWl0UHV0UmVzdWx0KHJlZ2lzdGVyT2Zmc2V0IC0gUmVnaXN0 ZXJGaWxlOjpDYWxsRnJhbWVIZWFkZXJTaXplIC0gYXJnQ291bnQpOwotICAgICAgICAgICAgICAg IGVtaXRHZXRBcmcoY2FsbGVlLCBYODY6OmVjeCk7CisgICAgICAgICAgICAgICAgZW1pdEdldEFy ZyhjYWxsZWUsIFg4Njo6ZWN4LCBpKTsKICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAgLy8g TG9hZCB0aGUgY2FsbGVlIENvZGVCbG9jayogaW50byBlYXgKQEAgLTI4NjksNyArMjkyMSw3IEBA IHZvaWQgQ1RJOjpwcml2YXRlQ29tcGlsZVNsb3dDYXNlcygpCiAgICAgICAgICAgICBtX2ppdC50 ZXN0bF9ycihYODY6OmVheCwgWDg2OjplYXgpOwogICAgICAgICAgICAgWDg2QXNzZW1ibGVyOjpK bXBTcmMgaGFzQ29kZUJsb2NrID0gbV9qaXQuZW1pdFVubGlua2VkSm5lKCk7CiAgICAgICAgICAg ICBlbWl0Q1RJQ2FsbChpbnN0cnVjdGlvbiArIGksIGksIE1hY2hpbmU6OmN0aV9vcF9jYWxsX0pT RnVuY3Rpb24pOwotICAgICAgICAgICAgZW1pdEdldEFyZyhjYWxsZWUsIFg4Njo6ZWN4KTsKKyAg ICAgICAgICAgIGVtaXRHZXRBcmcoY2FsbGVlLCBYODY6OmVjeCwgaSk7CiAgICAgICAgICAgICBt X2ppdC5saW5rKGhhc0NvZGVCbG9jaywgbV9qaXQubGFiZWwoKSk7CiAKICAgICAgICAgICAgIC8v IFNwZWN1bGF0aXZlbHkgcm9sbCB0aGUgY2FsbGZyYW1lLCBhc3N1bWluZyBhcmdDb3VudCB3aWxs IG1hdGNoIHRoZSBhcml0eS4KQEAgLTI4ODEsNyArMjkzMyw3IEBAIHZvaWQgQ1RJOjpwcml2YXRl Q29tcGlsZVNsb3dDYXNlcygpCiAgICAgICAgICAgICBYODZBc3NlbWJsZXI6OkptcFNyYyBhcml0 eUNoZWNrT2theSA9IG1faml0LmVtaXRVbmxpbmtlZEplKCk7CiAgICAgICAgICAgICBlbWl0UHV0 QXJnKFg4Njo6ZWF4LCAxMik7CiAgICAgICAgICAgICBlbWl0Q1RJQ2FsbChpbnN0cnVjdGlvbiAr IGksIGksIE1hY2hpbmU6OmN0aV9vcF9jYWxsX2FyaXR5Q2hlY2spOwotICAgICAgICAgICAgZW1p dEdldEFyZyhjYWxsZWUgLSByZWdpc3Rlck9mZnNldCwgWDg2OjplY3gpOworICAgICAgICAgICAg ZW1pdEdldEFyZyhjYWxsZWUgLSByZWdpc3Rlck9mZnNldCwgWDg2OjplY3gsIGkpOwogICAgICAg ICAgICAgbV9qaXQubW92bF9ycihYODY6OmVkeCwgWDg2OjplZGkpOwogICAgICAgICAgICAgbV9q aXQubGluayhhcml0eUNoZWNrT2theSwgbV9qaXQubGFiZWwoKSk7CiAKQEAgLTMwODAsNyArMzEz Miw3IEBAIHZvaWQgQ1RJOjpwcml2YXRlQ29tcGlsZUdldEJ5SWRQcm90byhTdHIKICAgICBYODZB c3NlbWJsZXI6OkptcFNyYyBmYWlsdXJlQ2FzZXMzID0gbV9qaXQuZW1pdFVubGlua2VkSm5lKCk7 CiAKICAgICAvLyBDaGVja3Mgb3V0IG9rYXkhIC0gZ2V0RGlyZWN0T2Zmc2V0Ci0gICAgbV9qaXQu bW92bF9tcihjYWNoZWRPZmZzZXQgKiBzaXplb2YoSlNWYWx1ZSopLCBYODY6OmVkeCwgWDg2Ojpl Y3gpOworICAgIG1faml0Lm1vdmxfbXIoY2FjaGVkT2Zmc2V0ICogc2l6ZW9mKEpTVmFsdWUqKSwg WDg2OjplZHgsIFg4Njo6ZWF4KTsKIAogICAgIFg4NkFzc2VtYmxlcjo6Sm1wU3JjIHN1Y2Nlc3Mg PSBtX2ppdC5lbWl0VW5saW5rZWRKbXAoKTsKIApAQCAtMzQ0MSw2ICszNDkzLDcgQEAgdm9pZCBD VEk6OnByaXZhdGVDb21waWxlUGF0Y2hHZXRBcnJheUxlbgogCiAgICAgbV9qaXQuYWRkbF9ycihY ODY6OmVjeCwgWDg2OjplY3gpOwogICAgIG1faml0LmFkZGxfaThyKDEsIFg4Njo6ZWN4KTsKKyAg ICBtX2ppdC5tb3ZsX3JyKFg4Njo6ZWN4LCBYODY6OmVheCk7CiAgICAgWDg2QXNzZW1ibGVyOjpK bXBTcmMgc3VjY2VzcyA9IG1faml0LmVtaXRVbmxpbmtlZEptcCgpOwogCiAgICAgdm9pZCogY29k ZSA9IG1faml0LmNvcHkoKTsKSW5kZXg6IFZNL0NUSS5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFZNL0NUSS5o CShyZXZpc2lvbiAzODM2NykKKysrIFZNL0NUSS5oCSh3b3JraW5nIGNvcHkpCkBAIC0zNzQsNyAr Mzc0LDcgQEAgbmFtZXNwYWNlIEpTQyB7CiAgICAgICAgIHZvaWQgY29tcGlsZUJpbmFyeUFyaXRo T3AoT3Bjb2RlSUQsIHVuc2lnbmVkIGRzdCwgdW5zaWduZWQgc3JjMSwgdW5zaWduZWQgc3JjMiwg T3BlcmFuZFR5cGVzIG9waSwgdW5zaWduZWQgaSk7CiAgICAgICAgIHZvaWQgY29tcGlsZUJpbmFy eUFyaXRoT3BTbG93Q2FzZShJbnN0cnVjdGlvbiosIE9wY29kZUlELCBWZWN0b3I8U2xvd0Nhc2VF bnRyeT46Oml0ZXJhdG9yJiBpdGVyLCB1bnNpZ25lZCBkc3QsIHVuc2lnbmVkIHNyYzEsIHVuc2ln bmVkIHNyYzIsIE9wZXJhbmRUeXBlcyBvcGksIHVuc2lnbmVkIGkpOwogCi0gICAgICAgIHZvaWQg ZW1pdEdldEFyZyhpbnQgc3JjLCBYODZBc3NlbWJsZXI6OlJlZ2lzdGVySUQgZHN0KTsKKyAgICAg ICAgdm9pZCBlbWl0R2V0QXJnKGludCBzcmMsIFg4NkFzc2VtYmxlcjo6UmVnaXN0ZXJJRCBkc3Qs IHVuc2lnbmVkIGkpOwogICAgICAgICB2b2lkIGVtaXRHZXRQdXRBcmcodW5zaWduZWQgc3JjLCB1 bnNpZ25lZCBvZmZzZXQsIFg4NkFzc2VtYmxlcjo6UmVnaXN0ZXJJRCBzY3JhdGNoKTsKICAgICAg ICAgdm9pZCBlbWl0UHV0QXJnKFg4NkFzc2VtYmxlcjo6UmVnaXN0ZXJJRCBzcmMsIHVuc2lnbmVk IG9mZnNldCk7CiAgICAgICAgIHZvaWQgZW1pdFB1dEFyZ0NvbnN0YW50KHVuc2lnbmVkIHZhbHVl LCB1bnNpZ25lZCBvZmZzZXQpOwpAQCAtNDMwLDYgKzQzMCw4IEBAIG5hbWVzcGFjZSBKU0Mgewog ICAgICAgICB2b2lkIHByaW50T3Bjb2RlT3BlcmFuZFR5cGVzKHVuc2lnbmVkIHNyYzEsIHVuc2ln bmVkIHNyYzIpOwogI2VuZGlmCiAKKyAgICAgICAgdm9pZCBpbnZhbGlkYXRlUGVlcGhvbGVPcHRp bWl6YXRpb25zKCk7CisKICAgICAgICAgWDg2QXNzZW1ibGVyIG1faml0OwogICAgICAgICBNYWNo aW5lKiBtX21hY2hpbmU7CiAgICAgICAgIEpTR2xvYmFsRGF0YSogbV9nbG9iYWxEYXRhOwpAQCAt NDU2LDkgKzQ1OCwxMSBAQCBuYW1lc3BhY2UgSlNDIHsKICAgICAgICAgVmVjdG9yPFNsb3dDYXNl RW50cnk+IG1fc2xvd0Nhc2VzOwogICAgICAgICBWZWN0b3I8U3dpdGNoUmVjb3JkPiBtX3N3aXRj aGVzOwogCisgICAgICAgIGludCBtX2xhc3RSZXN1bHRCeXRlY29kZVJlZ2lzdGVyOworICAgICAg ICB1bnNpZ25lZCBtX2p1bXBUYXJnZXRzUG9zaXRpb247CisKICAgICAgICAgLy8gVGhpcyBsaW1p dCBjb21lcyBmcm9tIHRoZSBsaW1pdCBzZXQgaW4gUENSRQogICAgICAgICBzdGF0aWMgY29uc3Qg aW50IE1heFBhdHRlcm5TaXplID0gKDEgPDwgMTYpOwotCiAgICAgfTsKIH0KIApJbmRleDogVk0v Q29kZUJsb2NrLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gVk0vQ29kZUJsb2NrLmgJKHJldmlzaW9uIDM4MzY3 KQorKysgVk0vQ29kZUJsb2NrLmgJKHdvcmtpbmcgY29weSkKQEAgLTI2NSw2ICsyNjUsMTEgQEAg bmFtZXNwYWNlIEpTQyB7CiAgICAgICAgICAgICByZXR1cm4gY29uc3RhbnRSZWdpc3RlcnNbaW5k ZXggLSBudW1WYXJzXS5nZXRKU1ZhbHVlKCk7CiAgICAgICAgIH0KIAorICAgICAgICBBTFdBWVNf SU5MSU5FIGJvb2wgaXNUZW1wb3JhcnlSZWdpc3RlckluZGV4KGludCBpbmRleCkKKyAgICAgICAg eworICAgICAgICAgICAgcmV0dXJuIGluZGV4ID49IG51bVZhcnMgKyBudW1Db25zdGFudHM7Cisg ICAgICAgIH0KKwogI2lmICFkZWZpbmVkKE5ERUJVRykgfHwgRU5BQkxFX09QQ09ERV9TQU1QTElO RwogICAgICAgICB2b2lkIGR1bXAoRXhlY1N0YXRlKikgY29uc3Q7CiAgICAgICAgIHZvaWQgcHJp bnRTdHJ1Y3R1cmVJRHMoY29uc3QgSW5zdHJ1Y3Rpb24qKSBjb25zdDsKQEAgLTMzMiw2ICszMzcs OCBAQCBuYW1lc3BhY2UgSlNDIHsKICAgICAgICAgSGFzaE1hcDx2b2lkKiwgdW5zaWduZWQ+IGN0 aVJldHVybkFkZHJlc3NWUENNYXA7CiAjZW5kaWYKIAorICAgICAgICBWZWN0b3I8dW5zaWduZWQ+ IGp1bXBUYXJnZXRzOworCiAgICAgICAgIEV2YWxDb2RlQ2FjaGUgZXZhbENvZGVDYWNoZTsKIAog ICAgIHByaXZhdGU6CkluZGV4OiBieXRlY29tcGlsZXIvQ29kZUdlbmVyYXRvci5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gYnl0ZWNvbXBpbGVyL0NvZGVHZW5lcmF0b3IuY3BwCShyZXZpc2lvbiAzODM2NykK KysrIGJ5dGVjb21waWxlci9Db2RlR2VuZXJhdG9yLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDk3 LDExICs0OTcsMjIgQEAgUGFzc1JlZlB0cjxMYWJlbElEPiBDb2RlR2VuZXJhdG9yOjpuZXdMYQog CiBQYXNzUmVmUHRyPExhYmVsSUQ+IENvZGVHZW5lcmF0b3I6OmVtaXRMYWJlbChMYWJlbElEKiBs MCkKIHsKLSAgICBsMC0+c2V0TG9jYXRpb24oaW5zdHJ1Y3Rpb25zKCkuc2l6ZSgpKTsKLSAgICAK KyAgICB1bnNpZ25lZCBuZXdMYWJlbEluZGV4ID0gaW5zdHJ1Y3Rpb25zKCkuc2l6ZSgpOworICAg IGwwLT5zZXRMb2NhdGlvbihuZXdMYWJlbEluZGV4KTsKKworICAgIGlmIChtX2NvZGVCbG9jay0+ anVtcFRhcmdldHMuc2l6ZSgpICE9IDApIHsKKyAgICAgICAgdW5zaWduZWQgbGFzdExhYmVsSW5k ZXggPSBtX2NvZGVCbG9jay0+anVtcFRhcmdldHMubGFzdCgpOworICAgICAgICBBU1NFUlQobGFz dExhYmVsSW5kZXggPD0gbmV3TGFiZWxJbmRleCk7CisgICAgICAgIGlmIChuZXdMYWJlbEluZGV4 ID09IGxhc3RMYWJlbEluZGV4KSB7CisgICAgICAgICAgICAvLyBQZWVwaG9sZSBvcHRpbWl6YXRp b24gaGFzIGFscmVhZHkgYmVlbiBkaXNhYmxlZCBieSBlbWl0dGluZyB0aGUgbGFzdCBsYWJlbAor ICAgICAgICAgICAgcmV0dXJuIGwwOyAgICAgICAgICAgIAorICAgICAgICB9CisgICAgfQorCisg ICAgbV9jb2RlQmxvY2stPmp1bXBUYXJnZXRzLmFwcGVuZChuZXdMYWJlbEluZGV4KTsKKwogICAg IC8vIFRoaXMgZGlzYWJsZXMgcGVlcGhvbGUgb3B0aW1pemF0aW9ucyB3aGVuIGFuIGluc3RydWN0 aW9uIGlzIGEganVtcCB0YXJnZXQKICAgICBtX2xhc3RPcGNvZGVJRCA9IG9wX2VuZDsKLSAgICAK ICAgICByZXR1cm4gbDA7CiB9CiAK