117103 2013-05-31 19:23:45 -0700 DFG should populate frame bytecodeOffsets on OSR exit 2013-06-04 14:32:09 -0700 1 1 1 Unclassified WebKit JavaScriptCore 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 mark.lam mark.lam fpizlo ggaren mhahnenberg msaboff oliver oldest_to_newest 896045 0 mark.lam 2013-05-31 19:23:45 -0700 There are 2 bugs: 1. OSR exit doesn't currently populate the bytecodeOffset field in the CallFrame when it reifies the inlined frames as well as in the outermost (a.k.a. "machine") frame. 2. OSR exit is computing the return PC with the assumption that the caller's call opcode is op_call. If the caller's opcode is op_call_varargs, then the computed return PC will be incorrect. Patch for the fix coming soon. ref: <rdar://problem/14039335>. 896050 1 203479 mark.lam 2013-05-31 20:39:04 -0700 Created attachment 203479 the patch. 896107 2 203479 fpizlo 2013-06-01 09:46:52 -0700 Comment on attachment 203479 the patch. View in context: https://bugs.webkit.org/attachment.cgi?id=203479&action=review R=me with those changes. > Source/JavaScriptCore/bytecode/Opcode.h:282 > inline size_t opcodeLength(OpcodeID opcode) > { > - switch (opcode) { > -#define OPCODE_ID_LENGTHS(id, length) case id: return OPCODE_LENGTH(id); > - FOR_EACH_OPCODE_ID(OPCODE_ID_LENGTHS) > -#undef OPCODE_ID_LENGTHS > - } > - RELEASE_ASSERT_NOT_REACHED(); > - return 0; > + return opcodeLengths[opcode]; > } Why? The intuition for this method is that it gives the compiler a better opportunity to constant fold. We were expecting that if you call opcodeLength() with a constant then the call will be folded to a constant. I think that's harder if you do an array lookup instead. If you have a good reason for this change and it doesn't affect performance, then I'm fine with it - I just want to make sure that you had a reason for this change. > Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp:41 > + return opcodeLength(opcodeID); This call is another example of where a switch is better than an array lookup: with a switch statement, a C++ compiler backend will either choose to use a lookup table (transforming a switch with all cases that return a constant into an array lookup) or branches depending on what it thinks is most profitable for the given target. > Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp:657 > + unsigned returnBytecodeIndex = inlineCallFrame->caller.bytecodeIndex > + + opcodeLengthForBytecodeIndex(m_jit.vm(), baselineCodeBlockForCaller, inlineCallFrame->caller.bytecodeIndex); I would love to have this assert that the caller bytecode index is in fact a call of some kind. I would prefer a RELEASE_ASSERT. Can you refiddle this code to do such an assertion? I know it's awkward since you've got this helper, but the assertion is more important than having a nice helper. > Source/JavaScriptCore/dfg/DFGOSRExitCompiler64.cpp:621 > + unsigned returnBytecodeIndex = inlineCallFrame->caller.bytecodeIndex > + + opcodeLengthForBytecodeIndex(m_jit.vm(), baselineCodeBlockForCaller, inlineCallFrame->caller.bytecodeIndex); Ditto. 896111 3 mark.lam 2013-06-01 10:20:13 -0700 Thanks for the review. (In reply to comment #2) > > Source/JavaScriptCore/bytecode/Opcode.h:282 > > inline size_t opcodeLength(OpcodeID opcode) > > { > > - switch (opcode) { > > -#define OPCODE_ID_LENGTHS(id, length) case id: return OPCODE_LENGTH(id); > > - FOR_EACH_OPCODE_ID(OPCODE_ID_LENGTHS) > > -#undef OPCODE_ID_LENGTHS > > - } > > - RELEASE_ASSERT_NOT_REACHED(); > > - return 0; > > + return opcodeLengths[opcode]; > > } > > Why? > > The intuition for this method is that it gives the compiler a better opportunity to constant fold. We were expecting that if you call opcodeLength() with a constant then the call will be folded to a constant. I think that's harder if you do an array lookup instead. > > If you have a good reason for this change and it doesn't affect performance, then I'm fine with it - I just want to make sure that you had a reason for this change. Good point. I didn't think of constant folding. Will revert this change. Code that wants to do a length look up of a variable opcodeID should use opcodeLengths[] explicitly instead. > > Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp:41 > > + return opcodeLength(opcodeID); > > This call is another example of where a switch is better than an array lookup: with a switch statement, a C++ compiler backend will either choose to use a lookup table (transforming a switch with all cases that return a constant into an array lookup) or branches depending on what it thinks is most profitable for the given target. The opcodeID is variable in this case. Hence, the C++ compiler won't be able to constant fold. This is the reason I didn't want to use the switch statement over the entire OpcodeID space (as implemented in opcodeLength()) in the first place. Initially, I wasn't sure if the helper should be called for the top frame as well. But, now that we've determined that we should not call it for the top frame (and know that the opcode ID has to be some call opcode), we can reduce this to a simple "?:" statement that checks for op_call_varargs. > > Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp:657 > > + unsigned returnBytecodeIndex = inlineCallFrame->caller.bytecodeIndex > > + + opcodeLengthForBytecodeIndex(m_jit.vm(), baselineCodeBlockForCaller, inlineCallFrame->caller.bytecodeIndex); > > I would love to have this assert that the caller bytecode index is in fact a call of some kind. I would prefer a RELEASE_ASSERT. Can you refiddle this code to do such an assertion? I know it's awkward since you've got this helper, but the assertion is more important than having a nice helper. I will add the RELEASE_ASSERT in the helper since it is guaranteed to see a call opcode of some sort. Will also rename the helper to "callOpcodeLength()" for brevity and more clearly declare its intent. 896112 4 fpizlo 2013-06-01 10:26:37 -0700 (In reply to comment #3) > Thanks for the review. > > (In reply to comment #2) > > > Source/JavaScriptCore/bytecode/Opcode.h:282 > > > inline size_t opcodeLength(OpcodeID opcode) > > > { > > > - switch (opcode) { > > > -#define OPCODE_ID_LENGTHS(id, length) case id: return OPCODE_LENGTH(id); > > > - FOR_EACH_OPCODE_ID(OPCODE_ID_LENGTHS) > > > -#undef OPCODE_ID_LENGTHS > > > - } > > > - RELEASE_ASSERT_NOT_REACHED(); > > > - return 0; > > > + return opcodeLengths[opcode]; > > > } > > > > Why? > > > > The intuition for this method is that it gives the compiler a better opportunity to constant fold. We were expecting that if you call opcodeLength() with a constant then the call will be folded to a constant. I think that's harder if you do an array lookup instead. > > > > If you have a good reason for this change and it doesn't affect performance, then I'm fine with it - I just want to make sure that you had a reason for this change. > > Good point. I didn't think of constant folding. Will revert this change. Code that wants to do a length look up of a variable opcodeID should use opcodeLengths[] explicitly instead. > > > > Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp:41 > > > + return opcodeLength(opcodeID); > > > > This call is another example of where a switch is better than an array lookup: with a switch statement, a C++ compiler backend will either choose to use a lookup table (transforming a switch with all cases that return a constant into an array lookup) or branches depending on what it thinks is most profitable for the given target. > > The opcodeID is variable in this case. Hence, the C++ compiler won't be able to constant fold. This is the reason I didn't want to use the switch statement over the entire OpcodeID space (as implemented in opcodeLength()) in the first place. Let me say this differently. This is a *different* example of why switch is better, and it *isn't* related to constant folding. A switch statement where all cases have a return of a constant will be turned into an array lookup, just like opcodeLength[blah]. The compiler will turn it into such an array lookup precisely when it thinks it is profitable. Hence, your change will never result in better code. It may result in worse code, if the compiler decides that an array lookup was less efficient - for example if the target it's compiling for has faster branches than loads, or something. > > Initially, I wasn't sure if the helper should be called for the top frame as well. But, now that we've determined that we should not call it for the top frame (and know that the opcode ID has to be some call opcode), we can reduce this to a simple "?:" statement that checks for op_call_varargs. > > > > Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp:657 > > > + unsigned returnBytecodeIndex = inlineCallFrame->caller.bytecodeIndex > > > + + opcodeLengthForBytecodeIndex(m_jit.vm(), baselineCodeBlockForCaller, inlineCallFrame->caller.bytecodeIndex); > > > > I would love to have this assert that the caller bytecode index is in fact a call of some kind. I would prefer a RELEASE_ASSERT. Can you refiddle this code to do such an assertion? I know it's awkward since you've got this helper, but the assertion is more important than having a nice helper. > > I will add the RELEASE_ASSERT in the helper since it is guaranteed to see a call opcode of some sort. Will also rename the helper to "callOpcodeLength()" for brevity and more clearly declare its intent. Really? If the helper is called for the top call frame, it may see any opcode. 896113 5 mark.lam 2013-06-01 10:44:31 -0700 (In reply to comment #4) > > > > Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp:41 > > > > + return opcodeLength(opcodeID); > > > > > > This call is another example of where a switch is better than an array lookup: with a switch statement, a C++ compiler backend will either choose to use a lookup table (transforming a switch with all cases that return a constant into an array lookup) or branches depending on what it thinks is most profitable for the given target. > > > > The opcodeID is variable in this case. Hence, the C++ compiler won't be able to constant fold. This is the reason I didn't want to use the switch statement over the entire OpcodeID space (as implemented in opcodeLength()) in the first place. > > Let me say this differently. This is a *different* example of why switch is better, and it *isn't* related to constant folding. > > A switch statement where all cases have a return of a constant will be turned into an array lookup, just like opcodeLength[blah]. The compiler will turn it into such an array lookup precisely when it thinks it is profitable. > > Hence, your change will never result in better code. It may result in worse code, if the compiler decides that an array lookup was less efficient - for example if the target it's compiling for has faster branches than loads, or something. OK, understood. But I knew that there's already an opcodeLengths[] array, and I didn't want the compiler to potentially instantiate a new one for the inlined opcodeLength() function. Anyway, here's the new code: static size_t callOpcodeLength(VM* vm, CodeBlock* codeBlock, unsigned bytecodeIndex) { Opcode opcode = codeBlock->instructions()[bytecodeIndex].u.opcode; OpcodeID opcodeID = vm->interpreter->getOpcodeID(opcode); RELEASE_ASSERT(opcodeID == op_call || opcodeID == op_call_eval || opcodeID == op_call_varargs); ASSERT(OPCODE_LENGTH(op_call) == OPCODE_LENGTH(op_call_eval)); return UNLIKELY(opcodeID == op_call_varargs) ? OPCODE_LENGTH(op_call_varargs) : OPCODE_LENGTH(op_call); } > > Initially, I wasn't sure if the helper should be called for the top frame as well. But, now that we've determined that we should not call it for the top frame (and know that the opcode ID has to be some call opcode), we can reduce this to a simple "?:" statement that checks for op_call_varargs. > > > > > > Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp:657 > > > > + unsigned returnBytecodeIndex = inlineCallFrame->caller.bytecodeIndex > > > > + + opcodeLengthForBytecodeIndex(m_jit.vm(), baselineCodeBlockForCaller, inlineCallFrame->caller.bytecodeIndex); > > > > > > I would love to have this assert that the caller bytecode index is in fact a call of some kind. I would prefer a RELEASE_ASSERT. Can you refiddle this code to do such an assertion? I know it's awkward since you've got this helper, but the assertion is more important than having a nice helper. > > > > I will add the RELEASE_ASSERT in the helper since it is guaranteed to see a call opcode of some sort. Will also rename the helper to "callOpcodeLength()" for brevity and more clearly declare its intent. > > Really? If the helper is called for the top call frame, it may see any opcode. Let me clarify. The helper should be and is called for the top call frame to compute the bytecodeOffset of the returnPC, and this case should always see call opcodes. However, back before I determined that we shouldn't call it for computing the bytecodeOffset of the opcode that we're OSR exiting to, I was also calling the helper there. Hence, I was seeing whatever opcodes were triggering the OSR exit. But that is an invalid scenario, and we don't make that call anymore. Hence, the helper will never see any opcodes other than call opcodes. 896114 6 fpizlo 2013-06-01 10:47:27 -0700 (In reply to comment #5) > (In reply to comment #4) > > > > > Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp:41 > > > > > + return opcodeLength(opcodeID); > > > > > > > > This call is another example of where a switch is better than an array lookup: with a switch statement, a C++ compiler backend will either choose to use a lookup table (transforming a switch with all cases that return a constant into an array lookup) or branches depending on what it thinks is most profitable for the given target. > > > > > > The opcodeID is variable in this case. Hence, the C++ compiler won't be able to constant fold. This is the reason I didn't want to use the switch statement over the entire OpcodeID space (as implemented in opcodeLength()) in the first place. > > > > Let me say this differently. This is a *different* example of why switch is better, and it *isn't* related to constant folding. > > > > A switch statement where all cases have a return of a constant will be turned into an array lookup, just like opcodeLength[blah]. The compiler will turn it into such an array lookup precisely when it thinks it is profitable. > > > > Hence, your change will never result in better code. It may result in worse code, if the compiler decides that an array lookup was less efficient - for example if the target it's compiling for has faster branches than loads, or something. > > OK, understood. But I knew that there's already an opcodeLengths[] array, and I didn't want the compiler to potentially instantiate a new one for the inlined opcodeLength() function. > > Anyway, here's the new code: > > static size_t callOpcodeLength(VM* vm, CodeBlock* codeBlock, unsigned bytecodeIndex) > { > Opcode opcode = codeBlock->instructions()[bytecodeIndex].u.opcode; > OpcodeID opcodeID = vm->interpreter->getOpcodeID(opcode); > RELEASE_ASSERT(opcodeID == op_call || opcodeID == op_call_eval || opcodeID == op_call_varargs); > ASSERT(OPCODE_LENGTH(op_call) == OPCODE_LENGTH(op_call_eval)); > return UNLIKELY(opcodeID == op_call_varargs) ? OPCODE_LENGTH(op_call_varargs) : OPCODE_LENGTH(op_call); > } > > > > Initially, I wasn't sure if the helper should be called for the top frame as well. But, now that we've determined that we should not call it for the top frame (and know that the opcode ID has to be some call opcode), we can reduce this to a simple "?:" statement that checks for op_call_varargs. > > > > > > > > Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp:657 > > > > > + unsigned returnBytecodeIndex = inlineCallFrame->caller.bytecodeIndex > > > > > + + opcodeLengthForBytecodeIndex(m_jit.vm(), baselineCodeBlockForCaller, inlineCallFrame->caller.bytecodeIndex); > > > > > > > > I would love to have this assert that the caller bytecode index is in fact a call of some kind. I would prefer a RELEASE_ASSERT. Can you refiddle this code to do such an assertion? I know it's awkward since you've got this helper, but the assertion is more important than having a nice helper. > > > > > > I will add the RELEASE_ASSERT in the helper since it is guaranteed to see a call opcode of some sort. Will also rename the helper to "callOpcodeLength()" for brevity and more clearly declare its intent. > > > > Really? If the helper is called for the top call frame, it may see any opcode. > > Let me clarify. The helper should be and is called for the top call frame to compute the bytecodeOffset of the returnPC, and this case should always see call opcodes. > > However, back before I determined that we shouldn't call it for computing the bytecodeOffset of the opcode that we're OSR exiting to, I was also calling the helper there. Hence, I was seeing whatever opcodes were triggering the OSR exit. But that is an invalid scenario, and we don't make that call anymore. Hence, the helper will never see any opcodes other than call opcodes. OK! Let me take a peek at the new patch before you land. 896115 7 203492 mark.lam 2013-06-01 11:01:29 -0700 Created attachment 203492 updated patch. 896116 8 203492 fpizlo 2013-06-01 11:03:36 -0700 Comment on attachment 203492 updated patch. View in context: https://bugs.webkit.org/attachment.cgi?id=203492&action=review > Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp:44 > +static size_t callOpcodeLength(VM* vm, CodeBlock* codeBlock, unsigned bytecodeIndex) > +{ > + Opcode opcode = codeBlock->instructions()[bytecodeIndex].u.opcode; > + OpcodeID opcodeID = vm->interpreter->getOpcodeID(opcode); > + RELEASE_ASSERT(opcodeID == op_call || opcodeID == op_call_eval || opcodeID == op_call_varargs); > + ASSERT(OPCODE_LENGTH(op_call) == OPCODE_LENGTH(op_call_eval)); > + return UNLIKELY(opcodeID == op_call_varargs) ? OPCODE_LENGTH(op_call_varargs) : OPCODE_LENGTH(op_call); > +} This is wrong. You forgot about op_construct. Also the name "callOpcodeLength" is really weird. Think of a better name. > Source/JavaScriptCore/dfg/DFGOSRExitCompiler64.cpp:44 > +static size_t callOpcodeLength(VM* vm, CodeBlock* codeBlock, unsigned bytecodeIndex) > +{ > + Opcode opcode = codeBlock->instructions()[bytecodeIndex].u.opcode; > + OpcodeID opcodeID = vm->interpreter->getOpcodeID(opcode); > + RELEASE_ASSERT(opcodeID == op_call || opcodeID == op_call_eval || opcodeID == op_call_varargs); > + ASSERT(OPCODE_LENGTH(op_call) == OPCODE_LENGTH(op_call_eval)); > + return UNLIKELY(opcodeID == op_call_varargs) ? OPCODE_LENGTH(op_call_varargs) : OPCODE_LENGTH(op_call); > +} Ditto. 896120 9 mark.lam 2013-06-01 11:28:41 -0700 (In reply to comment #8) > (From update of attachment 203492 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=203492&action=review > > > + RELEASE_ASSERT(opcodeID == op_call || opcodeID == op_call_eval || opcodeID == op_call_varargs); > > This is wrong. You forgot about op_construct. Dope! I had it right yesterday when I was testing this assert (but unfortunately, removed it), but botch it this time (when I re-added it). Will fix. > Also the name "callOpcodeLength" is really weird. Think of a better name. I presume it sounds weird because it can imply "calling" something called an "OpcodeLength". How about "lengthOfCallOpcodeAt"? Here's an example how it appears in use: bytecodeIndex += lengthOfCallOpcodeAt(m_jit.vm(), baselineCodeBlock, codeOrigin.bytecodeIndex); 896121 10 203493 mark.lam 2013-06-01 11:35:36 -0700 Created attachment 203493 updated patch #2. 896122 11 203493 fpizlo 2013-06-01 12:36:17 -0700 Comment on attachment 203493 updated patch #2. Actually, would it be possible to add a test? Like throw an exception after OSR exiting from inlined code and then check the stack trace. Make sure that this fails on trunk. 896281 12 mark.lam 2013-06-02 16:14:43 -0700 (In reply to comment #11) > (From update of attachment 203493 [details]) > Actually, would it be possible to add a test? Like throw an exception after OSR exiting from inlined code and then check the stack trace. Make sure that this fails on trunk. Strange. I can get a crash in fast/js/stack-trace.html quite easily with the flt branch (debug build, unmodified), but I can't seem to reproduce the error on trunk. I'm also not seeing any line number errors in the stack traces. Still investigating. 896288 13 mark.lam 2013-06-02 19:59:06 -0700 (In reply to comment #12) > Strange. I can get a crash in fast/js/stack-trace.html quite easily with the flt branch (debug build, unmodified), but I can't seem to reproduce the error on trunk. I'm also not seeing any line number errors in the stack traces. Still investigating. The reason that the ftl branch crashed and that ToT did not is because ToT has a fix by Oliver (http://trac.webkit.org/changeset/149404) that was not merged into the ftl branch. Next, I'll see if I can alter the test to defeat that fix by Oliver. 896296 14 mark.lam 2013-06-02 21:48:53 -0700 For this OSR exit case, we won't be able to construct a stack trace test that fails without the patch. The reason is because we've OSR'ed exited to the baseline JIT, and the CodeBlock uses the baselineJIT code's callReturnIndexVector to map the return PC to the bytecodeOffset. It does not rely on the bytecodeOffset in the ArgumentCount tag. Hence, it won't fail. 896542 15 ggaren 2013-06-03 10:51:15 -0700 > I can't seem to reproduce the error on trunk. Sounds like this patch should land only on the branch, then. 896543 16 fpizlo 2013-06-03 10:54:06 -0700 (In reply to comment #15) > > I can't seem to reproduce the error on trunk. > > Sounds like this patch should land only on the branch, then. Sure does sound like it. 897009 17 203719 mark.lam 2013-06-04 13:18:16 -0700 Created attachment 203719 reworked patch for ftl branch With this new patch, we no longer need to opcode length to the bytecode offset because that's how the ftl branch rolls. 897010 18 mark.lam 2013-06-04 13:18:53 -0700 (In reply to comment #17) > Created an attachment (id=203719) [details] > reworked patch for ftl branch > > With this new patch, we no longer need to opcode length to the bytecode offset because that's how the ftl branch rolls. … no longer need to add opcode length ... 897039 19 203719 ggaren 2013-06-04 14:26:18 -0700 Comment on attachment 203719 reworked patch for ftl branch r=me 897041 20 mark.lam 2013-06-04 14:32:09 -0700 Thanks for the review. Landed in r151184: <http://trac.webkit.org/changeset/151184>. 203479 2013-05-31 20:39:04 -0700 2013-06-01 11:01:29 -0700 the patch. bug-117103.patch text/plain 9855 mark.lam SW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMTUxMDYzKQorKysgU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDIzIEBA CisyMDEzLTA1LTMxICBNYXJrIExhbSAgPG1hcmsubGFtQGFwcGxlLmNvbT4KKworICAgICAgICBE Rkcgc2hvdWxkIHBvcHVsYXRlIGZyYW1lIGJ5dGVjb2RlT2Zmc2V0cyBvbiBPU1IgZXhpdC4KKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTExNzEwMy4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBbHNvIGZpeGVk IGEgYnVnIGluIHRoZSBjb21wdXRhdGlvbiBvZiB0aGUgcmV0dXJuIFBDIHdoZXJlIHRoZSBPU1Ig ZXhpdAorICAgICAgICBjb2RlIHdhcyBhc3N1bWluZyB0aGF0IHRoZSBjYWxsIG9wY29kZSBpbiB0 aGUgY2FsbGVyIGhhcyB0aGUgbGVuZ3RoIG9mCisgICAgICAgIG9wX2NhbGwuIFRoaXMgd291bGQg YmUgaW5jb3JyZWN0IGlmIHRoZSBjYWxsIG9wY29kZSBpcyBvcF9jYWxsX3ZhcmFyZ3MuCisKKyAg ICAgICAgKiBieXRlY29kZS9PcGNvZGUuaDoKKyAgICAgICAgKEpTQzo6b3Bjb2RlTGVuZ3RoKToK KyAgICAgICAgKiBkZmcvREZHT1NSRXhpdENvbXBpbGVyMzJfNjQuY3BwOgorICAgICAgICAoSlND OjpERkc6Om9wY29kZUxlbmd0aEZvckJ5dGVjb2RlSW5kZXgpOgorICAgICAgICAoSlNDOjpERkc6 Ok9TUkV4aXRDb21waWxlcjo6Y29tcGlsZUV4aXQpOgorICAgICAgICAqIGRmZy9ERkdPU1JFeGl0 Q29tcGlsZXI2NC5jcHA6CisgICAgICAgIChKU0M6OkRGRzo6b3Bjb2RlTGVuZ3RoRm9yQnl0ZWNv ZGVJbmRleCk6CisgICAgICAgIChKU0M6OkRGRzo6T1NSRXhpdENvbXBpbGVyOjpjb21waWxlRXhp dCk6CisKIDIwMTMtMDUtMzEgIEZpbGlwIFBpemxvICA8ZnBpemxvQGFwcGxlLmNvbT4KIAogICAg ICAgICBJbmNvcnJlY3QgYXNzZXJ0aW9uIGluIERGRzo6R3JhcGg6OnVuY2hlY2tlZEFjdGl2YXRp b25SZWdpc3RlckZvcigpCkluZGV4OiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvYnl0ZWNvZGUvT3Bj b2RlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3JlL2J5dGVjb2RlL09wY29k ZS5oCShyZXZpc2lvbiAxNTEwNTgpCisrKyBTb3VyY2UvSmF2YVNjcmlwdENvcmUvYnl0ZWNvZGUv T3Bjb2RlLmgJKHdvcmtpbmcgY29weSkKQEAgLTI3OCwxMyArMjc4LDcgQEAgc3RydWN0IE9wY29k ZVN0YXRzIHsKIAogaW5saW5lIHNpemVfdCBvcGNvZGVMZW5ndGgoT3Bjb2RlSUQgb3Bjb2RlKQog ewotICAgIHN3aXRjaCAob3Bjb2RlKSB7Ci0jZGVmaW5lIE9QQ09ERV9JRF9MRU5HVEhTKGlkLCBs ZW5ndGgpIGNhc2UgaWQ6IHJldHVybiBPUENPREVfTEVOR1RIKGlkKTsKLSAgICAgICAgIEZPUl9F QUNIX09QQ09ERV9JRChPUENPREVfSURfTEVOR1RIUykKLSN1bmRlZiBPUENPREVfSURfTEVOR1RI UwotICAgIH0KLSAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOwotICAgIHJldHVybiAw OworICAgIHJldHVybiBvcGNvZGVMZW5ndGhzW29wY29kZV07CiB9CiAKIH0gLy8gbmFtZXNwYWNl IEpTQwpJbmRleDogU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdPU1JFeGl0Q29tcGlsZXIz Ml82NC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdPU1JF eGl0Q29tcGlsZXIzMl82NC5jcHAJKHJldmlzaW9uIDE1MTA1OCkKKysrIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS9kZmcvREZHT1NSRXhpdENvbXBpbGVyMzJfNjQuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC0zNCw2ICszNCwxMyBAQAogCiBuYW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIERGRyB7CiAKK3N0 YXRpYyBzaXplX3Qgb3Bjb2RlTGVuZ3RoRm9yQnl0ZWNvZGVJbmRleChWTSogdm0sIENvZGVCbG9j ayogY29kZUJsb2NrLCB1bnNpZ25lZCBieXRlY29kZUluZGV4KQoreworICAgIE9wY29kZSBvcGNv ZGUgPSBjb2RlQmxvY2stPmluc3RydWN0aW9ucygpW2J5dGVjb2RlSW5kZXhdLnUub3Bjb2RlOwor ICAgIE9wY29kZUlEIG9wY29kZUlEID0gdm0tPmludGVycHJldGVyLT5nZXRPcGNvZGVJRChvcGNv ZGUpOworICAgIHJldHVybiBvcGNvZGVMZW5ndGgob3Bjb2RlSUQpOworfQorCiB2b2lkIE9TUkV4 aXRDb21waWxlcjo6Y29tcGlsZUV4aXQoY29uc3QgT1NSRXhpdCYgZXhpdCwgY29uc3QgT3BlcmFu ZHM8VmFsdWVSZWNvdmVyeT4mIG9wZXJhbmRzLCBTcGVjdWxhdGlvblJlY292ZXJ5KiByZWNvdmVy eSkKIHsKICAgICAvLyAxKSBQcm8tZm9ybWEgc3R1ZmYuCkBAIC02MzQsMTMgKzY0MSwyMCBAQCB2 b2lkIE9TUkV4aXRDb21waWxlcjo6Y29tcGlsZUV4aXQoY29uc3QgCiAgICAgCiAgICAgQVNTRVJU KG1faml0LmJhc2VsaW5lQ29kZUJsb2NrKCktPmdldEpJVFR5cGUoKSA9PSBKSVRDb2RlOjpCYXNl bGluZUpJVCk7CiAgICAgbV9qaXQuc3RvcmVQdHIoQXNzZW1ibHlIZWxwZXJzOjpUcnVzdGVkSW1t UHRyKG1faml0LmJhc2VsaW5lQ29kZUJsb2NrKCkpLCBBc3NlbWJseUhlbHBlcnM6OmFkZHJlc3NG b3IoKFZpcnR1YWxSZWdpc3RlcilKU1N0YWNrOjpDb2RlQmxvY2spKTsKLSAgICAKLSAgICBmb3Ig KENvZGVPcmlnaW4gY29kZU9yaWdpbiA9IGV4aXQubV9jb2RlT3JpZ2luOyBjb2RlT3JpZ2luLmlu bGluZUNhbGxGcmFtZTsgY29kZU9yaWdpbiA9IGNvZGVPcmlnaW4uaW5saW5lQ2FsbEZyYW1lLT5j YWxsZXIpIHsKKworICAgIENvZGVPcmlnaW4gY29kZU9yaWdpbjsKKyAgICBib29sIGlzVG9wRnJh bWUgPSB0cnVlOworICAgIGZvciAoY29kZU9yaWdpbiA9IGV4aXQubV9jb2RlT3JpZ2luOyBjb2Rl T3JpZ2luLmlubGluZUNhbGxGcmFtZTsgY29kZU9yaWdpbiA9IGNvZGVPcmlnaW4uaW5saW5lQ2Fs bEZyYW1lLT5jYWxsZXIpIHsKICAgICAgICAgSW5saW5lQ2FsbEZyYW1lKiBpbmxpbmVDYWxsRnJh bWUgPSBjb2RlT3JpZ2luLmlubGluZUNhbGxGcmFtZTsKICAgICAgICAgQ29kZUJsb2NrKiBiYXNl bGluZUNvZGVCbG9jayA9IG1faml0LmJhc2VsaW5lQ29kZUJsb2NrRm9yKGNvZGVPcmlnaW4pOwog ICAgICAgICBDb2RlQmxvY2sqIGJhc2VsaW5lQ29kZUJsb2NrRm9yQ2FsbGVyID0gbV9qaXQuYmFz ZWxpbmVDb2RlQmxvY2tGb3IoaW5saW5lQ2FsbEZyYW1lLT5jYWxsZXIpOwogICAgICAgICBWZWN0 b3I8Qnl0ZWNvZGVBbmRNYWNoaW5lT2Zmc2V0PiYgZGVjb2RlZENvZGVNYXAgPSBtX2ppdC5kZWNv ZGVkQ29kZU1hcEZvcihiYXNlbGluZUNvZGVCbG9ja0ZvckNhbGxlcik7Ci0gICAgICAgIHVuc2ln bmVkIHJldHVybkJ5dGVjb2RlSW5kZXggPSBpbmxpbmVDYWxsRnJhbWUtPmNhbGxlci5ieXRlY29k ZUluZGV4ICsgT1BDT0RFX0xFTkdUSChvcF9jYWxsKTsKKyAgICAgICAgdW5zaWduZWQgYnl0ZWNv ZGVJbmRleCA9IGNvZGVPcmlnaW4uYnl0ZWNvZGVJbmRleDsKKyAgICAgICAgaWYgKCFpc1RvcEZy YW1lKQorICAgICAgICAgICAgYnl0ZWNvZGVJbmRleCArPSBvcGNvZGVMZW5ndGhGb3JCeXRlY29k ZUluZGV4KG1faml0LnZtKCksIGJhc2VsaW5lQ29kZUJsb2NrLCBjb2RlT3JpZ2luLmJ5dGVjb2Rl SW5kZXgpOworICAgICAgICBpc1RvcEZyYW1lID0gZmFsc2U7CisgICAgICAgIHVuc2lnbmVkIHJl dHVybkJ5dGVjb2RlSW5kZXggPSBpbmxpbmVDYWxsRnJhbWUtPmNhbGxlci5ieXRlY29kZUluZGV4 CisgICAgICAgICAgICArIG9wY29kZUxlbmd0aEZvckJ5dGVjb2RlSW5kZXgobV9qaXQudm0oKSwg YmFzZWxpbmVDb2RlQmxvY2tGb3JDYWxsZXIsIGlubGluZUNhbGxGcmFtZS0+Y2FsbGVyLmJ5dGVj b2RlSW5kZXgpOwogICAgICAgICBCeXRlY29kZUFuZE1hY2hpbmVPZmZzZXQqIG1hcHBpbmcgPSBi aW5hcnlTZWFyY2g8Qnl0ZWNvZGVBbmRNYWNoaW5lT2Zmc2V0LCB1bnNpZ25lZD4oZGVjb2RlZENv ZGVNYXAsIGRlY29kZWRDb2RlTWFwLnNpemUoKSwgcmV0dXJuQnl0ZWNvZGVJbmRleCwgQnl0ZWNv ZGVBbmRNYWNoaW5lT2Zmc2V0OjpnZXRCeXRlY29kZUluZGV4KTsKICAgICAgICAgCiAgICAgICAg IEFTU0VSVChtYXBwaW5nKTsKQEAgLTY2MywxMCArNjc3LDE2IEBAIHZvaWQgT1NSRXhpdENvbXBp bGVyOjpjb21waWxlRXhpdChjb25zdCAKICAgICAgICAgbV9qaXQuc3RvcmVQdHIoY2FsbGVyRnJh bWVHUFIsIEFzc2VtYmx5SGVscGVyczo6cGF5bG9hZEZvcigoVmlydHVhbFJlZ2lzdGVyKShpbmxp bmVDYWxsRnJhbWUtPnN0YWNrT2Zmc2V0ICsgSlNTdGFjazo6Q2FsbGVyRnJhbWUpKSk7CiAgICAg ICAgIG1faml0LnN0b3JlUHRyKEFzc2VtYmx5SGVscGVyczo6VHJ1c3RlZEltbVB0cihqdW1wVGFy Z2V0KSwgQXNzZW1ibHlIZWxwZXJzOjpwYXlsb2FkRm9yKChWaXJ0dWFsUmVnaXN0ZXIpKGlubGlu ZUNhbGxGcmFtZS0+c3RhY2tPZmZzZXQgKyBKU1N0YWNrOjpSZXR1cm5QQykpKTsKICAgICAgICAg bV9qaXQuc3RvcmUzMihBc3NlbWJseUhlbHBlcnM6OlRydXN0ZWRJbW0zMihpbmxpbmVDYWxsRnJh bWUtPmFyZ3VtZW50cy5zaXplKCkpLCBBc3NlbWJseUhlbHBlcnM6OnBheWxvYWRGb3IoKFZpcnR1 YWxSZWdpc3RlcikoaW5saW5lQ2FsbEZyYW1lLT5zdGFja09mZnNldCArIEpTU3RhY2s6OkFyZ3Vt ZW50Q291bnQpKSk7CisgICAgICAgIG1faml0LnN0b3JlMzIoQXNzZW1ibHlIZWxwZXJzOjpUcnVz dGVkSW1tMzIoYnl0ZWNvZGVJbmRleCksIEFzc2VtYmx5SGVscGVyczo6dGFnRm9yKChWaXJ0dWFs UmVnaXN0ZXIpKGlubGluZUNhbGxGcmFtZS0+c3RhY2tPZmZzZXQgKyBKU1N0YWNrOjpBcmd1bWVu dENvdW50KSkpOwogICAgICAgICBtX2ppdC5zdG9yZTMyKEFzc2VtYmx5SGVscGVyczo6VHJ1c3Rl ZEltbTMyKEpTVmFsdWU6OkNlbGxUYWcpLCBBc3NlbWJseUhlbHBlcnM6OnRhZ0ZvcigoVmlydHVh bFJlZ2lzdGVyKShpbmxpbmVDYWxsRnJhbWUtPnN0YWNrT2Zmc2V0ICsgSlNTdGFjazo6Q2FsbGVl KSkpOwogICAgICAgICBpZiAoIWlubGluZUNhbGxGcmFtZS0+aXNDbG9zdXJlQ2FsbCgpKQogICAg ICAgICAgICAgbV9qaXQuc3RvcmVQdHIoQXNzZW1ibHlIZWxwZXJzOjpUcnVzdGVkSW1tUHRyKGlu bGluZUNhbGxGcmFtZS0+Y2FsbGVlLmdldCgpKSwgQXNzZW1ibHlIZWxwZXJzOjpwYXlsb2FkRm9y KChWaXJ0dWFsUmVnaXN0ZXIpKGlubGluZUNhbGxGcmFtZS0+c3RhY2tPZmZzZXQgKyBKU1N0YWNr OjpDYWxsZWUpKSk7CiAgICAgfQorCisgICAgdW5zaWduZWQgYnl0ZWNvZGVJbmRleCA9IGNvZGVP cmlnaW4uYnl0ZWNvZGVJbmRleDsKKyAgICBpZiAoIWlzVG9wRnJhbWUpCisgICAgICAgIGJ5dGVj b2RlSW5kZXggKz0gb3Bjb2RlTGVuZ3RoRm9yQnl0ZWNvZGVJbmRleChtX2ppdC52bSgpLCBtX2pp dC5iYXNlbGluZUNvZGVCbG9jaygpLCBjb2RlT3JpZ2luLmJ5dGVjb2RlSW5kZXgpOworICAgIG1f aml0LnN0b3JlMzIoQXNzZW1ibHlIZWxwZXJzOjpUcnVzdGVkSW1tMzIoYnl0ZWNvZGVJbmRleCks IEFzc2VtYmx5SGVscGVyczo6dGFnRm9yKChWaXJ0dWFsUmVnaXN0ZXIpKEpTU3RhY2s6OkFyZ3Vt ZW50Q291bnQpKSk7CiAgICAgCiAgICAgLy8gMTQpIENyZWF0ZSBhcmd1bWVudHMgaWYgbmVjZXNz YXJ5IGFuZCBwbGFjZSB0aGVtIGludG8gdGhlIGFwcHJvcHJpYXRlIGFsaWFzZWQKICAgICAvLyAg ICAgcmVnaXN0ZXJzLgpJbmRleDogU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdPU1JFeGl0 Q29tcGlsZXI2NC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9E RkdPU1JFeGl0Q29tcGlsZXI2NC5jcHAJKHJldmlzaW9uIDE1MTA1OCkKKysrIFNvdXJjZS9KYXZh U2NyaXB0Q29yZS9kZmcvREZHT1NSRXhpdENvbXBpbGVyNjQuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC0zNCw2ICszNCwxMyBAQAogCiBuYW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIERGRyB7CiAKK3N0 YXRpYyBzaXplX3Qgb3Bjb2RlTGVuZ3RoRm9yQnl0ZWNvZGVJbmRleChWTSogdm0sIENvZGVCbG9j ayogY29kZUJsb2NrLCB1bnNpZ25lZCBieXRlY29kZUluZGV4KQoreworICAgIE9wY29kZSBvcGNv ZGUgPSBjb2RlQmxvY2stPmluc3RydWN0aW9ucygpW2J5dGVjb2RlSW5kZXhdLnUub3Bjb2RlOwor ICAgIE9wY29kZUlEIG9wY29kZUlEID0gdm0tPmludGVycHJldGVyLT5nZXRPcGNvZGVJRChvcGNv ZGUpOworICAgIHJldHVybiBvcGNvZGVMZW5ndGgob3Bjb2RlSUQpOworfQorCiB2b2lkIE9TUkV4 aXRDb21waWxlcjo6Y29tcGlsZUV4aXQoY29uc3QgT1NSRXhpdCYgZXhpdCwgY29uc3QgT3BlcmFu ZHM8VmFsdWVSZWNvdmVyeT4mIG9wZXJhbmRzLCBTcGVjdWxhdGlvblJlY292ZXJ5KiByZWNvdmVy eSkKIHsKICAgICAvLyAxKSBQcm8tZm9ybWEgc3R1ZmYuCkBAIC01OTgsMTMgKzYwNSwyMCBAQCB2 b2lkIE9TUkV4aXRDb21waWxlcjo6Y29tcGlsZUV4aXQoY29uc3QgCiAgICAgCiAgICAgQVNTRVJU KG1faml0LmJhc2VsaW5lQ29kZUJsb2NrKCktPmdldEpJVFR5cGUoKSA9PSBKSVRDb2RlOjpCYXNl bGluZUpJVCk7CiAgICAgbV9qaXQuc3RvcmVQdHIoQXNzZW1ibHlIZWxwZXJzOjpUcnVzdGVkSW1t UHRyKG1faml0LmJhc2VsaW5lQ29kZUJsb2NrKCkpLCBBc3NlbWJseUhlbHBlcnM6OmFkZHJlc3NG b3IoKFZpcnR1YWxSZWdpc3RlcilKU1N0YWNrOjpDb2RlQmxvY2spKTsKLSAgICAKLSAgICBmb3Ig KENvZGVPcmlnaW4gY29kZU9yaWdpbiA9IGV4aXQubV9jb2RlT3JpZ2luOyBjb2RlT3JpZ2luLmlu bGluZUNhbGxGcmFtZTsgY29kZU9yaWdpbiA9IGNvZGVPcmlnaW4uaW5saW5lQ2FsbEZyYW1lLT5j YWxsZXIpIHsKKworICAgIENvZGVPcmlnaW4gY29kZU9yaWdpbjsKKyAgICBib29sIGlzVG9wRnJh bWUgPSB0cnVlOworICAgIGZvciAoY29kZU9yaWdpbiA9IGV4aXQubV9jb2RlT3JpZ2luOyBjb2Rl T3JpZ2luLmlubGluZUNhbGxGcmFtZTsgY29kZU9yaWdpbiA9IGNvZGVPcmlnaW4uaW5saW5lQ2Fs bEZyYW1lLT5jYWxsZXIpIHsKICAgICAgICAgSW5saW5lQ2FsbEZyYW1lKiBpbmxpbmVDYWxsRnJh bWUgPSBjb2RlT3JpZ2luLmlubGluZUNhbGxGcmFtZTsKICAgICAgICAgQ29kZUJsb2NrKiBiYXNl bGluZUNvZGVCbG9jayA9IG1faml0LmJhc2VsaW5lQ29kZUJsb2NrRm9yKGNvZGVPcmlnaW4pOwog ICAgICAgICBDb2RlQmxvY2sqIGJhc2VsaW5lQ29kZUJsb2NrRm9yQ2FsbGVyID0gbV9qaXQuYmFz ZWxpbmVDb2RlQmxvY2tGb3IoaW5saW5lQ2FsbEZyYW1lLT5jYWxsZXIpOwogICAgICAgICBWZWN0 b3I8Qnl0ZWNvZGVBbmRNYWNoaW5lT2Zmc2V0PiYgZGVjb2RlZENvZGVNYXAgPSBtX2ppdC5kZWNv ZGVkQ29kZU1hcEZvcihiYXNlbGluZUNvZGVCbG9ja0ZvckNhbGxlcik7Ci0gICAgICAgIHVuc2ln bmVkIHJldHVybkJ5dGVjb2RlSW5kZXggPSBpbmxpbmVDYWxsRnJhbWUtPmNhbGxlci5ieXRlY29k ZUluZGV4ICsgT1BDT0RFX0xFTkdUSChvcF9jYWxsKTsKKyAgICAgICAgdW5zaWduZWQgYnl0ZWNv ZGVJbmRleCA9IGNvZGVPcmlnaW4uYnl0ZWNvZGVJbmRleDsKKyAgICAgICAgaWYgKCFpc1RvcEZy YW1lKQorICAgICAgICAgICAgYnl0ZWNvZGVJbmRleCArPSBvcGNvZGVMZW5ndGhGb3JCeXRlY29k ZUluZGV4KG1faml0LnZtKCksIGJhc2VsaW5lQ29kZUJsb2NrLCBjb2RlT3JpZ2luLmJ5dGVjb2Rl SW5kZXgpOworICAgICAgICBpc1RvcEZyYW1lID0gZmFsc2U7CisgICAgICAgIHVuc2lnbmVkIHJl dHVybkJ5dGVjb2RlSW5kZXggPSBpbmxpbmVDYWxsRnJhbWUtPmNhbGxlci5ieXRlY29kZUluZGV4 CisgICAgICAgICAgICArIG9wY29kZUxlbmd0aEZvckJ5dGVjb2RlSW5kZXgobV9qaXQudm0oKSwg YmFzZWxpbmVDb2RlQmxvY2tGb3JDYWxsZXIsIGlubGluZUNhbGxGcmFtZS0+Y2FsbGVyLmJ5dGVj b2RlSW5kZXgpOwogICAgICAgICBCeXRlY29kZUFuZE1hY2hpbmVPZmZzZXQqIG1hcHBpbmcgPSBi aW5hcnlTZWFyY2g8Qnl0ZWNvZGVBbmRNYWNoaW5lT2Zmc2V0LCB1bnNpZ25lZD4oZGVjb2RlZENv ZGVNYXAsIGRlY29kZWRDb2RlTWFwLnNpemUoKSwgcmV0dXJuQnl0ZWNvZGVJbmRleCwgQnl0ZWNv ZGVBbmRNYWNoaW5lT2Zmc2V0OjpnZXRCeXRlY29kZUluZGV4KTsKICAgICAgICAgCiAgICAgICAg IEFTU0VSVChtYXBwaW5nKTsKQEAgLTYyNSwxMCArNjM5LDE2IEBAIHZvaWQgT1NSRXhpdENvbXBp bGVyOjpjb21waWxlRXhpdChjb25zdCAKICAgICAgICAgbV9qaXQuc3RvcmU2NChjYWxsZXJGcmFt ZUdQUiwgQXNzZW1ibHlIZWxwZXJzOjphZGRyZXNzRm9yKChWaXJ0dWFsUmVnaXN0ZXIpKGlubGlu ZUNhbGxGcmFtZS0+c3RhY2tPZmZzZXQgKyBKU1N0YWNrOjpDYWxsZXJGcmFtZSkpKTsKICAgICAg ICAgbV9qaXQuc3RvcmVQdHIoQXNzZW1ibHlIZWxwZXJzOjpUcnVzdGVkSW1tUHRyKGp1bXBUYXJn ZXQpLCBBc3NlbWJseUhlbHBlcnM6OmFkZHJlc3NGb3IoKFZpcnR1YWxSZWdpc3RlcikoaW5saW5l Q2FsbEZyYW1lLT5zdGFja09mZnNldCArIEpTU3RhY2s6OlJldHVyblBDKSkpOwogICAgICAgICBt X2ppdC5zdG9yZTMyKEFzc2VtYmx5SGVscGVyczo6VHJ1c3RlZEltbTMyKGlubGluZUNhbGxGcmFt ZS0+YXJndW1lbnRzLnNpemUoKSksIEFzc2VtYmx5SGVscGVyczo6cGF5bG9hZEZvcigoVmlydHVh bFJlZ2lzdGVyKShpbmxpbmVDYWxsRnJhbWUtPnN0YWNrT2Zmc2V0ICsgSlNTdGFjazo6QXJndW1l bnRDb3VudCkpKTsKKyAgICAgICAgbV9qaXQuc3RvcmUzMihBc3NlbWJseUhlbHBlcnM6OlRydXN0 ZWRJbW0zMihieXRlY29kZUluZGV4KSwgQXNzZW1ibHlIZWxwZXJzOjp0YWdGb3IoKFZpcnR1YWxS ZWdpc3RlcikoaW5saW5lQ2FsbEZyYW1lLT5zdGFja09mZnNldCArIEpTU3RhY2s6OkFyZ3VtZW50 Q291bnQpKSk7CiAgICAgICAgIGlmICghaW5saW5lQ2FsbEZyYW1lLT5pc0Nsb3N1cmVDYWxsKCkp CiAgICAgICAgICAgICBtX2ppdC5zdG9yZTY0KEFzc2VtYmx5SGVscGVyczo6VHJ1c3RlZEltbTY0 KEpTVmFsdWU6OmVuY29kZShKU1ZhbHVlKGlubGluZUNhbGxGcmFtZS0+Y2FsbGVlLmdldCgpKSkp LCBBc3NlbWJseUhlbHBlcnM6OmFkZHJlc3NGb3IoKFZpcnR1YWxSZWdpc3RlcikoaW5saW5lQ2Fs bEZyYW1lLT5zdGFja09mZnNldCArIEpTU3RhY2s6OkNhbGxlZSkpKTsKICAgICB9Ci0gICAgCisK KyAgICB1bnNpZ25lZCBieXRlY29kZUluZGV4ID0gY29kZU9yaWdpbi5ieXRlY29kZUluZGV4Owor ICAgIGlmICghaXNUb3BGcmFtZSkKKyAgICAgICAgYnl0ZWNvZGVJbmRleCArPSBvcGNvZGVMZW5n dGhGb3JCeXRlY29kZUluZGV4KG1faml0LnZtKCksIG1faml0LmJhc2VsaW5lQ29kZUJsb2NrKCks IGNvZGVPcmlnaW4uYnl0ZWNvZGVJbmRleCk7CisgICAgbV9qaXQuc3RvcmUzMihBc3NlbWJseUhl bHBlcnM6OlRydXN0ZWRJbW0zMihieXRlY29kZUluZGV4KSwgQXNzZW1ibHlIZWxwZXJzOjp0YWdG b3IoKFZpcnR1YWxSZWdpc3RlcikoSlNTdGFjazo6QXJndW1lbnRDb3VudCkpKTsKKwogICAgIC8v IDE1KSBDcmVhdGUgYXJndW1lbnRzIGlmIG5lY2Vzc2FyeSBhbmQgcGxhY2UgdGhlbSBpbnRvIHRo ZSBhcHByb3ByaWF0ZSBhbGlhc2VkCiAgICAgLy8gICAgIHJlZ2lzdGVycy4KICAgICAK 203492 2013-06-01 11:01:29 -0700 2013-06-01 11:35:36 -0700 updated patch. bug-117103.patch text/plain 9564 mark.lam SW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMTUxMDYzKQorKysgU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDIxIEBA CisyMDEzLTA2LTAxICBNYXJrIExhbSAgPG1hcmsubGFtQGFwcGxlLmNvbT4KKworICAgICAgICBE Rkcgc2hvdWxkIHBvcHVsYXRlIGZyYW1lIGJ5dGVjb2RlT2Zmc2V0cyBvbiBPU1IgZXhpdC4KKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTExNzEwMy4KKwor ICAgICAgICBSZXZpZXdlZCBieSBGaWxpcCBQaXpsby4KKworICAgICAgICBBbHNvIGZpeGVkIGEg YnVnIGluIHRoZSBjb21wdXRhdGlvbiBvZiB0aGUgcmV0dXJuIFBDIHdoZXJlIHRoZSBPU1IgZXhp dAorICAgICAgICBjb2RlIHdhcyBhc3N1bWluZyB0aGF0IHRoZSBjYWxsIG9wY29kZSBpbiB0aGUg Y2FsbGVyIGhhcyB0aGUgbGVuZ3RoIG9mCisgICAgICAgIG9wX2NhbGwuIFRoaXMgd291bGQgYmUg aW5jb3JyZWN0IGlmIHRoZSBjYWxsIG9wY29kZSBpcyBvcF9jYWxsX3ZhcmFyZ3MuCisKKyAgICAg ICAgKiBkZmcvREZHT1NSRXhpdENvbXBpbGVyMzJfNjQuY3BwOgorICAgICAgICAoSlNDOjpERkc6 Om9wY29kZUxlbmd0aEZvckJ5dGVjb2RlSW5kZXgpOgorICAgICAgICAoSlNDOjpERkc6Ok9TUkV4 aXRDb21waWxlcjo6Y29tcGlsZUV4aXQpOgorICAgICAgICAqIGRmZy9ERkdPU1JFeGl0Q29tcGls ZXI2NC5jcHA6CisgICAgICAgIChKU0M6OkRGRzo6b3Bjb2RlTGVuZ3RoRm9yQnl0ZWNvZGVJbmRl eCk6CisgICAgICAgIChKU0M6OkRGRzo6T1NSRXhpdENvbXBpbGVyOjpjb21waWxlRXhpdCk6CisK IDIwMTMtMDUtMzEgIEZpbGlwIFBpemxvICA8ZnBpemxvQGFwcGxlLmNvbT4KIAogICAgICAgICBJ bmNvcnJlY3QgYXNzZXJ0aW9uIGluIERGRzo6R3JhcGg6OnVuY2hlY2tlZEFjdGl2YXRpb25SZWdp c3RlckZvcigpCkluZGV4OiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR09TUkV4aXRDb21w aWxlcjMyXzY0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RG R09TUkV4aXRDb21waWxlcjMyXzY0LmNwcAkocmV2aXNpb24gMTUxMDU4KQorKysgU291cmNlL0ph dmFTY3JpcHRDb3JlL2RmZy9ERkdPU1JFeGl0Q29tcGlsZXIzMl82NC5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTM0LDYgKzM0LDE1IEBACiAKIG5hbWVzcGFjZSBKU0MgeyBuYW1lc3BhY2UgREZHIHsK IAorc3RhdGljIHNpemVfdCBjYWxsT3Bjb2RlTGVuZ3RoKFZNKiB2bSwgQ29kZUJsb2NrKiBjb2Rl QmxvY2ssIHVuc2lnbmVkIGJ5dGVjb2RlSW5kZXgpCit7CisgICAgT3Bjb2RlIG9wY29kZSA9IGNv ZGVCbG9jay0+aW5zdHJ1Y3Rpb25zKClbYnl0ZWNvZGVJbmRleF0udS5vcGNvZGU7CisgICAgT3Bj b2RlSUQgb3Bjb2RlSUQgPSB2bS0+aW50ZXJwcmV0ZXItPmdldE9wY29kZUlEKG9wY29kZSk7Cisg ICAgUkVMRUFTRV9BU1NFUlQob3Bjb2RlSUQgPT0gb3BfY2FsbCB8fCBvcGNvZGVJRCA9PSBvcF9j YWxsX2V2YWwgfHwgb3Bjb2RlSUQgPT0gb3BfY2FsbF92YXJhcmdzKTsKKyAgICBBU1NFUlQoT1BD T0RFX0xFTkdUSChvcF9jYWxsKSA9PSBPUENPREVfTEVOR1RIKG9wX2NhbGxfZXZhbCkpOworICAg IHJldHVybiBVTkxJS0VMWShvcGNvZGVJRCA9PSBvcF9jYWxsX3ZhcmFyZ3MpID8gT1BDT0RFX0xF TkdUSChvcF9jYWxsX3ZhcmFyZ3MpIDogT1BDT0RFX0xFTkdUSChvcF9jYWxsKTsKK30KKwogdm9p ZCBPU1JFeGl0Q29tcGlsZXI6OmNvbXBpbGVFeGl0KGNvbnN0IE9TUkV4aXQmIGV4aXQsIGNvbnN0 IE9wZXJhbmRzPFZhbHVlUmVjb3Zlcnk+JiBvcGVyYW5kcywgU3BlY3VsYXRpb25SZWNvdmVyeSog cmVjb3ZlcnkpCiB7CiAgICAgLy8gMSkgUHJvLWZvcm1hIHN0dWZmLgpAQCAtNjM0LDEzICs2NDMs MjAgQEAgdm9pZCBPU1JFeGl0Q29tcGlsZXI6OmNvbXBpbGVFeGl0KGNvbnN0IAogICAgIAogICAg IEFTU0VSVChtX2ppdC5iYXNlbGluZUNvZGVCbG9jaygpLT5nZXRKSVRUeXBlKCkgPT0gSklUQ29k ZTo6QmFzZWxpbmVKSVQpOwogICAgIG1faml0LnN0b3JlUHRyKEFzc2VtYmx5SGVscGVyczo6VHJ1 c3RlZEltbVB0cihtX2ppdC5iYXNlbGluZUNvZGVCbG9jaygpKSwgQXNzZW1ibHlIZWxwZXJzOjph ZGRyZXNzRm9yKChWaXJ0dWFsUmVnaXN0ZXIpSlNTdGFjazo6Q29kZUJsb2NrKSk7Ci0gICAgCi0g ICAgZm9yIChDb2RlT3JpZ2luIGNvZGVPcmlnaW4gPSBleGl0Lm1fY29kZU9yaWdpbjsgY29kZU9y aWdpbi5pbmxpbmVDYWxsRnJhbWU7IGNvZGVPcmlnaW4gPSBjb2RlT3JpZ2luLmlubGluZUNhbGxG cmFtZS0+Y2FsbGVyKSB7CisKKyAgICBDb2RlT3JpZ2luIGNvZGVPcmlnaW47CisgICAgYm9vbCBp c1RvcEZyYW1lID0gdHJ1ZTsKKyAgICBmb3IgKGNvZGVPcmlnaW4gPSBleGl0Lm1fY29kZU9yaWdp bjsgY29kZU9yaWdpbi5pbmxpbmVDYWxsRnJhbWU7IGNvZGVPcmlnaW4gPSBjb2RlT3JpZ2luLmlu bGluZUNhbGxGcmFtZS0+Y2FsbGVyKSB7CiAgICAgICAgIElubGluZUNhbGxGcmFtZSogaW5saW5l Q2FsbEZyYW1lID0gY29kZU9yaWdpbi5pbmxpbmVDYWxsRnJhbWU7CiAgICAgICAgIENvZGVCbG9j ayogYmFzZWxpbmVDb2RlQmxvY2sgPSBtX2ppdC5iYXNlbGluZUNvZGVCbG9ja0Zvcihjb2RlT3Jp Z2luKTsKICAgICAgICAgQ29kZUJsb2NrKiBiYXNlbGluZUNvZGVCbG9ja0ZvckNhbGxlciA9IG1f aml0LmJhc2VsaW5lQ29kZUJsb2NrRm9yKGlubGluZUNhbGxGcmFtZS0+Y2FsbGVyKTsKICAgICAg ICAgVmVjdG9yPEJ5dGVjb2RlQW5kTWFjaGluZU9mZnNldD4mIGRlY29kZWRDb2RlTWFwID0gbV9q aXQuZGVjb2RlZENvZGVNYXBGb3IoYmFzZWxpbmVDb2RlQmxvY2tGb3JDYWxsZXIpOwotICAgICAg ICB1bnNpZ25lZCByZXR1cm5CeXRlY29kZUluZGV4ID0gaW5saW5lQ2FsbEZyYW1lLT5jYWxsZXIu Ynl0ZWNvZGVJbmRleCArIE9QQ09ERV9MRU5HVEgob3BfY2FsbCk7CisgICAgICAgIHVuc2lnbmVk IGJ5dGVjb2RlSW5kZXggPSBjb2RlT3JpZ2luLmJ5dGVjb2RlSW5kZXg7CisgICAgICAgIGlmICgh aXNUb3BGcmFtZSkKKyAgICAgICAgICAgIGJ5dGVjb2RlSW5kZXggKz0gY2FsbE9wY29kZUxlbmd0 aChtX2ppdC52bSgpLCBiYXNlbGluZUNvZGVCbG9jaywgY29kZU9yaWdpbi5ieXRlY29kZUluZGV4 KTsKKyAgICAgICAgaXNUb3BGcmFtZSA9IGZhbHNlOworICAgICAgICB1bnNpZ25lZCByZXR1cm5C eXRlY29kZUluZGV4ID0gaW5saW5lQ2FsbEZyYW1lLT5jYWxsZXIuYnl0ZWNvZGVJbmRleAorICAg ICAgICAgICAgKyBjYWxsT3Bjb2RlTGVuZ3RoKG1faml0LnZtKCksIGJhc2VsaW5lQ29kZUJsb2Nr Rm9yQ2FsbGVyLCBpbmxpbmVDYWxsRnJhbWUtPmNhbGxlci5ieXRlY29kZUluZGV4KTsKICAgICAg ICAgQnl0ZWNvZGVBbmRNYWNoaW5lT2Zmc2V0KiBtYXBwaW5nID0gYmluYXJ5U2VhcmNoPEJ5dGVj b2RlQW5kTWFjaGluZU9mZnNldCwgdW5zaWduZWQ+KGRlY29kZWRDb2RlTWFwLCBkZWNvZGVkQ29k ZU1hcC5zaXplKCksIHJldHVybkJ5dGVjb2RlSW5kZXgsIEJ5dGVjb2RlQW5kTWFjaGluZU9mZnNl dDo6Z2V0Qnl0ZWNvZGVJbmRleCk7CiAgICAgICAgIAogICAgICAgICBBU1NFUlQobWFwcGluZyk7 CkBAIC02NjMsMTAgKzY3OSwxNiBAQCB2b2lkIE9TUkV4aXRDb21waWxlcjo6Y29tcGlsZUV4aXQo Y29uc3QgCiAgICAgICAgIG1faml0LnN0b3JlUHRyKGNhbGxlckZyYW1lR1BSLCBBc3NlbWJseUhl bHBlcnM6OnBheWxvYWRGb3IoKFZpcnR1YWxSZWdpc3RlcikoaW5saW5lQ2FsbEZyYW1lLT5zdGFj a09mZnNldCArIEpTU3RhY2s6OkNhbGxlckZyYW1lKSkpOwogICAgICAgICBtX2ppdC5zdG9yZVB0 cihBc3NlbWJseUhlbHBlcnM6OlRydXN0ZWRJbW1QdHIoanVtcFRhcmdldCksIEFzc2VtYmx5SGVs cGVyczo6cGF5bG9hZEZvcigoVmlydHVhbFJlZ2lzdGVyKShpbmxpbmVDYWxsRnJhbWUtPnN0YWNr T2Zmc2V0ICsgSlNTdGFjazo6UmV0dXJuUEMpKSk7CiAgICAgICAgIG1faml0LnN0b3JlMzIoQXNz ZW1ibHlIZWxwZXJzOjpUcnVzdGVkSW1tMzIoaW5saW5lQ2FsbEZyYW1lLT5hcmd1bWVudHMuc2l6 ZSgpKSwgQXNzZW1ibHlIZWxwZXJzOjpwYXlsb2FkRm9yKChWaXJ0dWFsUmVnaXN0ZXIpKGlubGlu ZUNhbGxGcmFtZS0+c3RhY2tPZmZzZXQgKyBKU1N0YWNrOjpBcmd1bWVudENvdW50KSkpOworICAg ICAgICBtX2ppdC5zdG9yZTMyKEFzc2VtYmx5SGVscGVyczo6VHJ1c3RlZEltbTMyKGJ5dGVjb2Rl SW5kZXgpLCBBc3NlbWJseUhlbHBlcnM6OnRhZ0ZvcigoVmlydHVhbFJlZ2lzdGVyKShpbmxpbmVD YWxsRnJhbWUtPnN0YWNrT2Zmc2V0ICsgSlNTdGFjazo6QXJndW1lbnRDb3VudCkpKTsKICAgICAg ICAgbV9qaXQuc3RvcmUzMihBc3NlbWJseUhlbHBlcnM6OlRydXN0ZWRJbW0zMihKU1ZhbHVlOjpD ZWxsVGFnKSwgQXNzZW1ibHlIZWxwZXJzOjp0YWdGb3IoKFZpcnR1YWxSZWdpc3RlcikoaW5saW5l Q2FsbEZyYW1lLT5zdGFja09mZnNldCArIEpTU3RhY2s6OkNhbGxlZSkpKTsKICAgICAgICAgaWYg KCFpbmxpbmVDYWxsRnJhbWUtPmlzQ2xvc3VyZUNhbGwoKSkKICAgICAgICAgICAgIG1faml0LnN0 b3JlUHRyKEFzc2VtYmx5SGVscGVyczo6VHJ1c3RlZEltbVB0cihpbmxpbmVDYWxsRnJhbWUtPmNh bGxlZS5nZXQoKSksIEFzc2VtYmx5SGVscGVyczo6cGF5bG9hZEZvcigoVmlydHVhbFJlZ2lzdGVy KShpbmxpbmVDYWxsRnJhbWUtPnN0YWNrT2Zmc2V0ICsgSlNTdGFjazo6Q2FsbGVlKSkpOwogICAg IH0KKworICAgIHVuc2lnbmVkIGJ5dGVjb2RlSW5kZXggPSBjb2RlT3JpZ2luLmJ5dGVjb2RlSW5k ZXg7CisgICAgaWYgKCFpc1RvcEZyYW1lKQorICAgICAgICBieXRlY29kZUluZGV4ICs9IGNhbGxP cGNvZGVMZW5ndGgobV9qaXQudm0oKSwgbV9qaXQuYmFzZWxpbmVDb2RlQmxvY2soKSwgY29kZU9y aWdpbi5ieXRlY29kZUluZGV4KTsKKyAgICBtX2ppdC5zdG9yZTMyKEFzc2VtYmx5SGVscGVyczo6 VHJ1c3RlZEltbTMyKGJ5dGVjb2RlSW5kZXgpLCBBc3NlbWJseUhlbHBlcnM6OnRhZ0ZvcigoVmly dHVhbFJlZ2lzdGVyKShKU1N0YWNrOjpBcmd1bWVudENvdW50KSkpOwogICAgIAogICAgIC8vIDE0 KSBDcmVhdGUgYXJndW1lbnRzIGlmIG5lY2Vzc2FyeSBhbmQgcGxhY2UgdGhlbSBpbnRvIHRoZSBh cHByb3ByaWF0ZSBhbGlhc2VkCiAgICAgLy8gICAgIHJlZ2lzdGVycy4KSW5kZXg6IFNvdXJjZS9K YXZhU2NyaXB0Q29yZS9kZmcvREZHT1NSRXhpdENvbXBpbGVyNjQuY3BwCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHT1NSRXhpdENvbXBpbGVyNjQuY3BwCShyZXZp c2lvbiAxNTEwNTgpCisrKyBTb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR09TUkV4aXRDb21w aWxlcjY0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzQsNiArMzQsMTUgQEAKIAogbmFtZXNwYWNl IEpTQyB7IG5hbWVzcGFjZSBERkcgewogCitzdGF0aWMgc2l6ZV90IGNhbGxPcGNvZGVMZW5ndGgo Vk0qIHZtLCBDb2RlQmxvY2sqIGNvZGVCbG9jaywgdW5zaWduZWQgYnl0ZWNvZGVJbmRleCkKK3sK KyAgICBPcGNvZGUgb3Bjb2RlID0gY29kZUJsb2NrLT5pbnN0cnVjdGlvbnMoKVtieXRlY29kZUlu ZGV4XS51Lm9wY29kZTsKKyAgICBPcGNvZGVJRCBvcGNvZGVJRCA9IHZtLT5pbnRlcnByZXRlci0+ Z2V0T3Bjb2RlSUQob3Bjb2RlKTsKKyAgICBSRUxFQVNFX0FTU0VSVChvcGNvZGVJRCA9PSBvcF9j YWxsIHx8IG9wY29kZUlEID09IG9wX2NhbGxfZXZhbCB8fCBvcGNvZGVJRCA9PSBvcF9jYWxsX3Zh cmFyZ3MpOworICAgIEFTU0VSVChPUENPREVfTEVOR1RIKG9wX2NhbGwpID09IE9QQ09ERV9MRU5H VEgob3BfY2FsbF9ldmFsKSk7CisgICAgcmV0dXJuIFVOTElLRUxZKG9wY29kZUlEID09IG9wX2Nh bGxfdmFyYXJncykgPyBPUENPREVfTEVOR1RIKG9wX2NhbGxfdmFyYXJncykgOiBPUENPREVfTEVO R1RIKG9wX2NhbGwpOworfQorCiB2b2lkIE9TUkV4aXRDb21waWxlcjo6Y29tcGlsZUV4aXQoY29u c3QgT1NSRXhpdCYgZXhpdCwgY29uc3QgT3BlcmFuZHM8VmFsdWVSZWNvdmVyeT4mIG9wZXJhbmRz LCBTcGVjdWxhdGlvblJlY292ZXJ5KiByZWNvdmVyeSkKIHsKICAgICAvLyAxKSBQcm8tZm9ybWEg c3R1ZmYuCkBAIC01OTgsMTMgKzYwNywyMCBAQCB2b2lkIE9TUkV4aXRDb21waWxlcjo6Y29tcGls ZUV4aXQoY29uc3QgCiAgICAgCiAgICAgQVNTRVJUKG1faml0LmJhc2VsaW5lQ29kZUJsb2NrKCkt PmdldEpJVFR5cGUoKSA9PSBKSVRDb2RlOjpCYXNlbGluZUpJVCk7CiAgICAgbV9qaXQuc3RvcmVQ dHIoQXNzZW1ibHlIZWxwZXJzOjpUcnVzdGVkSW1tUHRyKG1faml0LmJhc2VsaW5lQ29kZUJsb2Nr KCkpLCBBc3NlbWJseUhlbHBlcnM6OmFkZHJlc3NGb3IoKFZpcnR1YWxSZWdpc3RlcilKU1N0YWNr OjpDb2RlQmxvY2spKTsKLSAgICAKLSAgICBmb3IgKENvZGVPcmlnaW4gY29kZU9yaWdpbiA9IGV4 aXQubV9jb2RlT3JpZ2luOyBjb2RlT3JpZ2luLmlubGluZUNhbGxGcmFtZTsgY29kZU9yaWdpbiA9 IGNvZGVPcmlnaW4uaW5saW5lQ2FsbEZyYW1lLT5jYWxsZXIpIHsKKworICAgIENvZGVPcmlnaW4g Y29kZU9yaWdpbjsKKyAgICBib29sIGlzVG9wRnJhbWUgPSB0cnVlOworICAgIGZvciAoY29kZU9y aWdpbiA9IGV4aXQubV9jb2RlT3JpZ2luOyBjb2RlT3JpZ2luLmlubGluZUNhbGxGcmFtZTsgY29k ZU9yaWdpbiA9IGNvZGVPcmlnaW4uaW5saW5lQ2FsbEZyYW1lLT5jYWxsZXIpIHsKICAgICAgICAg SW5saW5lQ2FsbEZyYW1lKiBpbmxpbmVDYWxsRnJhbWUgPSBjb2RlT3JpZ2luLmlubGluZUNhbGxG cmFtZTsKICAgICAgICAgQ29kZUJsb2NrKiBiYXNlbGluZUNvZGVCbG9jayA9IG1faml0LmJhc2Vs aW5lQ29kZUJsb2NrRm9yKGNvZGVPcmlnaW4pOwogICAgICAgICBDb2RlQmxvY2sqIGJhc2VsaW5l Q29kZUJsb2NrRm9yQ2FsbGVyID0gbV9qaXQuYmFzZWxpbmVDb2RlQmxvY2tGb3IoaW5saW5lQ2Fs bEZyYW1lLT5jYWxsZXIpOwogICAgICAgICBWZWN0b3I8Qnl0ZWNvZGVBbmRNYWNoaW5lT2Zmc2V0 PiYgZGVjb2RlZENvZGVNYXAgPSBtX2ppdC5kZWNvZGVkQ29kZU1hcEZvcihiYXNlbGluZUNvZGVC bG9ja0ZvckNhbGxlcik7Ci0gICAgICAgIHVuc2lnbmVkIHJldHVybkJ5dGVjb2RlSW5kZXggPSBp bmxpbmVDYWxsRnJhbWUtPmNhbGxlci5ieXRlY29kZUluZGV4ICsgT1BDT0RFX0xFTkdUSChvcF9j YWxsKTsKKyAgICAgICAgdW5zaWduZWQgYnl0ZWNvZGVJbmRleCA9IGNvZGVPcmlnaW4uYnl0ZWNv ZGVJbmRleDsKKyAgICAgICAgaWYgKCFpc1RvcEZyYW1lKQorICAgICAgICAgICAgYnl0ZWNvZGVJ bmRleCArPSBjYWxsT3Bjb2RlTGVuZ3RoKG1faml0LnZtKCksIGJhc2VsaW5lQ29kZUJsb2NrLCBj b2RlT3JpZ2luLmJ5dGVjb2RlSW5kZXgpOworICAgICAgICBpc1RvcEZyYW1lID0gZmFsc2U7Cisg ICAgICAgIHVuc2lnbmVkIHJldHVybkJ5dGVjb2RlSW5kZXggPSBpbmxpbmVDYWxsRnJhbWUtPmNh bGxlci5ieXRlY29kZUluZGV4CisgICAgICAgICAgICArIGNhbGxPcGNvZGVMZW5ndGgobV9qaXQu dm0oKSwgYmFzZWxpbmVDb2RlQmxvY2tGb3JDYWxsZXIsIGlubGluZUNhbGxGcmFtZS0+Y2FsbGVy LmJ5dGVjb2RlSW5kZXgpOwogICAgICAgICBCeXRlY29kZUFuZE1hY2hpbmVPZmZzZXQqIG1hcHBp bmcgPSBiaW5hcnlTZWFyY2g8Qnl0ZWNvZGVBbmRNYWNoaW5lT2Zmc2V0LCB1bnNpZ25lZD4oZGVj b2RlZENvZGVNYXAsIGRlY29kZWRDb2RlTWFwLnNpemUoKSwgcmV0dXJuQnl0ZWNvZGVJbmRleCwg Qnl0ZWNvZGVBbmRNYWNoaW5lT2Zmc2V0OjpnZXRCeXRlY29kZUluZGV4KTsKICAgICAgICAgCiAg ICAgICAgIEFTU0VSVChtYXBwaW5nKTsKQEAgLTYyNSwxMCArNjQxLDE2IEBAIHZvaWQgT1NSRXhp dENvbXBpbGVyOjpjb21waWxlRXhpdChjb25zdCAKICAgICAgICAgbV9qaXQuc3RvcmU2NChjYWxs ZXJGcmFtZUdQUiwgQXNzZW1ibHlIZWxwZXJzOjphZGRyZXNzRm9yKChWaXJ0dWFsUmVnaXN0ZXIp KGlubGluZUNhbGxGcmFtZS0+c3RhY2tPZmZzZXQgKyBKU1N0YWNrOjpDYWxsZXJGcmFtZSkpKTsK ICAgICAgICAgbV9qaXQuc3RvcmVQdHIoQXNzZW1ibHlIZWxwZXJzOjpUcnVzdGVkSW1tUHRyKGp1 bXBUYXJnZXQpLCBBc3NlbWJseUhlbHBlcnM6OmFkZHJlc3NGb3IoKFZpcnR1YWxSZWdpc3Rlciko aW5saW5lQ2FsbEZyYW1lLT5zdGFja09mZnNldCArIEpTU3RhY2s6OlJldHVyblBDKSkpOwogICAg ICAgICBtX2ppdC5zdG9yZTMyKEFzc2VtYmx5SGVscGVyczo6VHJ1c3RlZEltbTMyKGlubGluZUNh bGxGcmFtZS0+YXJndW1lbnRzLnNpemUoKSksIEFzc2VtYmx5SGVscGVyczo6cGF5bG9hZEZvcigo VmlydHVhbFJlZ2lzdGVyKShpbmxpbmVDYWxsRnJhbWUtPnN0YWNrT2Zmc2V0ICsgSlNTdGFjazo6 QXJndW1lbnRDb3VudCkpKTsKKyAgICAgICAgbV9qaXQuc3RvcmUzMihBc3NlbWJseUhlbHBlcnM6 OlRydXN0ZWRJbW0zMihieXRlY29kZUluZGV4KSwgQXNzZW1ibHlIZWxwZXJzOjp0YWdGb3IoKFZp cnR1YWxSZWdpc3RlcikoaW5saW5lQ2FsbEZyYW1lLT5zdGFja09mZnNldCArIEpTU3RhY2s6OkFy Z3VtZW50Q291bnQpKSk7CiAgICAgICAgIGlmICghaW5saW5lQ2FsbEZyYW1lLT5pc0Nsb3N1cmVD YWxsKCkpCiAgICAgICAgICAgICBtX2ppdC5zdG9yZTY0KEFzc2VtYmx5SGVscGVyczo6VHJ1c3Rl ZEltbTY0KEpTVmFsdWU6OmVuY29kZShKU1ZhbHVlKGlubGluZUNhbGxGcmFtZS0+Y2FsbGVlLmdl dCgpKSkpLCBBc3NlbWJseUhlbHBlcnM6OmFkZHJlc3NGb3IoKFZpcnR1YWxSZWdpc3RlcikoaW5s aW5lQ2FsbEZyYW1lLT5zdGFja09mZnNldCArIEpTU3RhY2s6OkNhbGxlZSkpKTsKICAgICB9Ci0g ICAgCisKKyAgICB1bnNpZ25lZCBieXRlY29kZUluZGV4ID0gY29kZU9yaWdpbi5ieXRlY29kZUlu ZGV4OworICAgIGlmICghaXNUb3BGcmFtZSkKKyAgICAgICAgYnl0ZWNvZGVJbmRleCArPSBjYWxs T3Bjb2RlTGVuZ3RoKG1faml0LnZtKCksIG1faml0LmJhc2VsaW5lQ29kZUJsb2NrKCksIGNvZGVP cmlnaW4uYnl0ZWNvZGVJbmRleCk7CisgICAgbV9qaXQuc3RvcmUzMihBc3NlbWJseUhlbHBlcnM6 OlRydXN0ZWRJbW0zMihieXRlY29kZUluZGV4KSwgQXNzZW1ibHlIZWxwZXJzOjp0YWdGb3IoKFZp cnR1YWxSZWdpc3RlcikoSlNTdGFjazo6QXJndW1lbnRDb3VudCkpKTsKKwogICAgIC8vIDE1KSBD cmVhdGUgYXJndW1lbnRzIGlmIG5lY2Vzc2FyeSBhbmQgcGxhY2UgdGhlbSBpbnRvIHRoZSBhcHBy b3ByaWF0ZSBhbGlhc2VkCiAgICAgLy8gICAgIHJlZ2lzdGVycy4KICAgICAK 203493 2013-06-01 11:35:36 -0700 2013-06-04 13:18:16 -0700 updated patch #2. bug-117103.patch text/plain 9790 mark.lam SW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMTUxMDYzKQorKysgU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDIxIEBA CisyMDEzLTA2LTAxICBNYXJrIExhbSAgPG1hcmsubGFtQGFwcGxlLmNvbT4KKworICAgICAgICBE Rkcgc2hvdWxkIHBvcHVsYXRlIGZyYW1lIGJ5dGVjb2RlT2Zmc2V0cyBvbiBPU1IgZXhpdC4KKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTExNzEwMy4KKwor ICAgICAgICBSZXZpZXdlZCBieSBGaWxpcCBQaXpsby4KKworICAgICAgICBBbHNvIGZpeGVkIGEg YnVnIGluIHRoZSBjb21wdXRhdGlvbiBvZiB0aGUgcmV0dXJuIFBDIHdoZXJlIHRoZSBPU1IgZXhp dAorICAgICAgICBjb2RlIHdhcyBhc3N1bWluZyB0aGF0IHRoZSBjYWxsIG9wY29kZSBpbiB0aGUg Y2FsbGVyIGhhcyB0aGUgbGVuZ3RoIG9mCisgICAgICAgIG9wX2NhbGwuIFRoaXMgd291bGQgYmUg aW5jb3JyZWN0IGlmIHRoZSBjYWxsIG9wY29kZSBpcyBvcF9jYWxsX3ZhcmFyZ3MuCisKKyAgICAg ICAgKiBkZmcvREZHT1NSRXhpdENvbXBpbGVyMzJfNjQuY3BwOgorICAgICAgICAoSlNDOjpERkc6 Om9wY29kZUxlbmd0aEZvckJ5dGVjb2RlSW5kZXgpOgorICAgICAgICAoSlNDOjpERkc6Ok9TUkV4 aXRDb21waWxlcjo6Y29tcGlsZUV4aXQpOgorICAgICAgICAqIGRmZy9ERkdPU1JFeGl0Q29tcGls ZXI2NC5jcHA6CisgICAgICAgIChKU0M6OkRGRzo6b3Bjb2RlTGVuZ3RoRm9yQnl0ZWNvZGVJbmRl eCk6CisgICAgICAgIChKU0M6OkRGRzo6T1NSRXhpdENvbXBpbGVyOjpjb21waWxlRXhpdCk6CisK IDIwMTMtMDUtMzEgIEZpbGlwIFBpemxvICA8ZnBpemxvQGFwcGxlLmNvbT4KIAogICAgICAgICBJ bmNvcnJlY3QgYXNzZXJ0aW9uIGluIERGRzo6R3JhcGg6OnVuY2hlY2tlZEFjdGl2YXRpb25SZWdp c3RlckZvcigpCkluZGV4OiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR09TUkV4aXRDb21w aWxlcjMyXzY0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RG R09TUkV4aXRDb21waWxlcjMyXzY0LmNwcAkocmV2aXNpb24gMTUxMDU4KQorKysgU291cmNlL0ph dmFTY3JpcHRDb3JlL2RmZy9ERkdPU1JFeGl0Q29tcGlsZXIzMl82NC5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTM0LDYgKzM0LDE2IEBACiAKIG5hbWVzcGFjZSBKU0MgeyBuYW1lc3BhY2UgREZHIHsK IAorc3RhdGljIHNpemVfdCBsZW5ndGhPZkNhbGxPcGNvZGVBdChWTSogdm0sIENvZGVCbG9jayog Y29kZUJsb2NrLCB1bnNpZ25lZCBieXRlY29kZUluZGV4KQoreworICAgIE9wY29kZSBvcGNvZGUg PSBjb2RlQmxvY2stPmluc3RydWN0aW9ucygpW2J5dGVjb2RlSW5kZXhdLnUub3Bjb2RlOworICAg IE9wY29kZUlEIG9wY29kZUlEID0gdm0tPmludGVycHJldGVyLT5nZXRPcGNvZGVJRChvcGNvZGUp OworICAgIFJFTEVBU0VfQVNTRVJUKG9wY29kZUlEID09IG9wX2NhbGwgfHwgb3Bjb2RlSUQgPT0g b3BfY2FsbF9ldmFsIHx8IG9wY29kZUlEID09IG9wX2NhbGxfdmFyYXJncyAgfHwgb3Bjb2RlSUQg PT0gb3BfY29uc3RydWN0KTsKKyAgICBBU1NFUlQoT1BDT0RFX0xFTkdUSChvcF9jYWxsKSA9PSBP UENPREVfTEVOR1RIKG9wX2NhbGxfZXZhbCkpOworICAgIEFTU0VSVChPUENPREVfTEVOR1RIKG9w X2NhbGwpID09IE9QQ09ERV9MRU5HVEgob3BfY29uc3RydWN0KSk7CisgICAgcmV0dXJuIFVOTElL RUxZKG9wY29kZUlEID09IG9wX2NhbGxfdmFyYXJncykgPyBPUENPREVfTEVOR1RIKG9wX2NhbGxf dmFyYXJncykgOiBPUENPREVfTEVOR1RIKG9wX2NhbGwpOworfQorCiB2b2lkIE9TUkV4aXRDb21w aWxlcjo6Y29tcGlsZUV4aXQoY29uc3QgT1NSRXhpdCYgZXhpdCwgY29uc3QgT3BlcmFuZHM8VmFs dWVSZWNvdmVyeT4mIG9wZXJhbmRzLCBTcGVjdWxhdGlvblJlY292ZXJ5KiByZWNvdmVyeSkKIHsK ICAgICAvLyAxKSBQcm8tZm9ybWEgc3R1ZmYuCkBAIC02MzQsMTMgKzY0NCwyMCBAQCB2b2lkIE9T UkV4aXRDb21waWxlcjo6Y29tcGlsZUV4aXQoY29uc3QgCiAgICAgCiAgICAgQVNTRVJUKG1faml0 LmJhc2VsaW5lQ29kZUJsb2NrKCktPmdldEpJVFR5cGUoKSA9PSBKSVRDb2RlOjpCYXNlbGluZUpJ VCk7CiAgICAgbV9qaXQuc3RvcmVQdHIoQXNzZW1ibHlIZWxwZXJzOjpUcnVzdGVkSW1tUHRyKG1f aml0LmJhc2VsaW5lQ29kZUJsb2NrKCkpLCBBc3NlbWJseUhlbHBlcnM6OmFkZHJlc3NGb3IoKFZp cnR1YWxSZWdpc3RlcilKU1N0YWNrOjpDb2RlQmxvY2spKTsKLSAgICAKLSAgICBmb3IgKENvZGVP cmlnaW4gY29kZU9yaWdpbiA9IGV4aXQubV9jb2RlT3JpZ2luOyBjb2RlT3JpZ2luLmlubGluZUNh bGxGcmFtZTsgY29kZU9yaWdpbiA9IGNvZGVPcmlnaW4uaW5saW5lQ2FsbEZyYW1lLT5jYWxsZXIp IHsKKworICAgIENvZGVPcmlnaW4gY29kZU9yaWdpbjsKKyAgICBib29sIGlzVG9wRnJhbWUgPSB0 cnVlOworICAgIGZvciAoY29kZU9yaWdpbiA9IGV4aXQubV9jb2RlT3JpZ2luOyBjb2RlT3JpZ2lu LmlubGluZUNhbGxGcmFtZTsgY29kZU9yaWdpbiA9IGNvZGVPcmlnaW4uaW5saW5lQ2FsbEZyYW1l LT5jYWxsZXIpIHsKICAgICAgICAgSW5saW5lQ2FsbEZyYW1lKiBpbmxpbmVDYWxsRnJhbWUgPSBj b2RlT3JpZ2luLmlubGluZUNhbGxGcmFtZTsKICAgICAgICAgQ29kZUJsb2NrKiBiYXNlbGluZUNv ZGVCbG9jayA9IG1faml0LmJhc2VsaW5lQ29kZUJsb2NrRm9yKGNvZGVPcmlnaW4pOwogICAgICAg ICBDb2RlQmxvY2sqIGJhc2VsaW5lQ29kZUJsb2NrRm9yQ2FsbGVyID0gbV9qaXQuYmFzZWxpbmVD b2RlQmxvY2tGb3IoaW5saW5lQ2FsbEZyYW1lLT5jYWxsZXIpOwogICAgICAgICBWZWN0b3I8Qnl0 ZWNvZGVBbmRNYWNoaW5lT2Zmc2V0PiYgZGVjb2RlZENvZGVNYXAgPSBtX2ppdC5kZWNvZGVkQ29k ZU1hcEZvcihiYXNlbGluZUNvZGVCbG9ja0ZvckNhbGxlcik7Ci0gICAgICAgIHVuc2lnbmVkIHJl dHVybkJ5dGVjb2RlSW5kZXggPSBpbmxpbmVDYWxsRnJhbWUtPmNhbGxlci5ieXRlY29kZUluZGV4 ICsgT1BDT0RFX0xFTkdUSChvcF9jYWxsKTsKKyAgICAgICAgdW5zaWduZWQgYnl0ZWNvZGVJbmRl eCA9IGNvZGVPcmlnaW4uYnl0ZWNvZGVJbmRleDsKKyAgICAgICAgaWYgKCFpc1RvcEZyYW1lKQor ICAgICAgICAgICAgYnl0ZWNvZGVJbmRleCArPSBsZW5ndGhPZkNhbGxPcGNvZGVBdChtX2ppdC52 bSgpLCBiYXNlbGluZUNvZGVCbG9jaywgY29kZU9yaWdpbi5ieXRlY29kZUluZGV4KTsKKyAgICAg ICAgaXNUb3BGcmFtZSA9IGZhbHNlOworICAgICAgICB1bnNpZ25lZCByZXR1cm5CeXRlY29kZUlu ZGV4ID0gaW5saW5lQ2FsbEZyYW1lLT5jYWxsZXIuYnl0ZWNvZGVJbmRleAorICAgICAgICAgICAg KyBsZW5ndGhPZkNhbGxPcGNvZGVBdChtX2ppdC52bSgpLCBiYXNlbGluZUNvZGVCbG9ja0ZvckNh bGxlciwgaW5saW5lQ2FsbEZyYW1lLT5jYWxsZXIuYnl0ZWNvZGVJbmRleCk7CiAgICAgICAgIEJ5 dGVjb2RlQW5kTWFjaGluZU9mZnNldCogbWFwcGluZyA9IGJpbmFyeVNlYXJjaDxCeXRlY29kZUFu ZE1hY2hpbmVPZmZzZXQsIHVuc2lnbmVkPihkZWNvZGVkQ29kZU1hcCwgZGVjb2RlZENvZGVNYXAu c2l6ZSgpLCByZXR1cm5CeXRlY29kZUluZGV4LCBCeXRlY29kZUFuZE1hY2hpbmVPZmZzZXQ6Omdl dEJ5dGVjb2RlSW5kZXgpOwogICAgICAgICAKICAgICAgICAgQVNTRVJUKG1hcHBpbmcpOwpAQCAt NjYzLDEwICs2ODAsMTYgQEAgdm9pZCBPU1JFeGl0Q29tcGlsZXI6OmNvbXBpbGVFeGl0KGNvbnN0 IAogICAgICAgICBtX2ppdC5zdG9yZVB0cihjYWxsZXJGcmFtZUdQUiwgQXNzZW1ibHlIZWxwZXJz OjpwYXlsb2FkRm9yKChWaXJ0dWFsUmVnaXN0ZXIpKGlubGluZUNhbGxGcmFtZS0+c3RhY2tPZmZz ZXQgKyBKU1N0YWNrOjpDYWxsZXJGcmFtZSkpKTsKICAgICAgICAgbV9qaXQuc3RvcmVQdHIoQXNz ZW1ibHlIZWxwZXJzOjpUcnVzdGVkSW1tUHRyKGp1bXBUYXJnZXQpLCBBc3NlbWJseUhlbHBlcnM6 OnBheWxvYWRGb3IoKFZpcnR1YWxSZWdpc3RlcikoaW5saW5lQ2FsbEZyYW1lLT5zdGFja09mZnNl dCArIEpTU3RhY2s6OlJldHVyblBDKSkpOwogICAgICAgICBtX2ppdC5zdG9yZTMyKEFzc2VtYmx5 SGVscGVyczo6VHJ1c3RlZEltbTMyKGlubGluZUNhbGxGcmFtZS0+YXJndW1lbnRzLnNpemUoKSks IEFzc2VtYmx5SGVscGVyczo6cGF5bG9hZEZvcigoVmlydHVhbFJlZ2lzdGVyKShpbmxpbmVDYWxs RnJhbWUtPnN0YWNrT2Zmc2V0ICsgSlNTdGFjazo6QXJndW1lbnRDb3VudCkpKTsKKyAgICAgICAg bV9qaXQuc3RvcmUzMihBc3NlbWJseUhlbHBlcnM6OlRydXN0ZWRJbW0zMihieXRlY29kZUluZGV4 KSwgQXNzZW1ibHlIZWxwZXJzOjp0YWdGb3IoKFZpcnR1YWxSZWdpc3RlcikoaW5saW5lQ2FsbEZy YW1lLT5zdGFja09mZnNldCArIEpTU3RhY2s6OkFyZ3VtZW50Q291bnQpKSk7CiAgICAgICAgIG1f aml0LnN0b3JlMzIoQXNzZW1ibHlIZWxwZXJzOjpUcnVzdGVkSW1tMzIoSlNWYWx1ZTo6Q2VsbFRh ZyksIEFzc2VtYmx5SGVscGVyczo6dGFnRm9yKChWaXJ0dWFsUmVnaXN0ZXIpKGlubGluZUNhbGxG cmFtZS0+c3RhY2tPZmZzZXQgKyBKU1N0YWNrOjpDYWxsZWUpKSk7CiAgICAgICAgIGlmICghaW5s aW5lQ2FsbEZyYW1lLT5pc0Nsb3N1cmVDYWxsKCkpCiAgICAgICAgICAgICBtX2ppdC5zdG9yZVB0 cihBc3NlbWJseUhlbHBlcnM6OlRydXN0ZWRJbW1QdHIoaW5saW5lQ2FsbEZyYW1lLT5jYWxsZWUu Z2V0KCkpLCBBc3NlbWJseUhlbHBlcnM6OnBheWxvYWRGb3IoKFZpcnR1YWxSZWdpc3RlcikoaW5s aW5lQ2FsbEZyYW1lLT5zdGFja09mZnNldCArIEpTU3RhY2s6OkNhbGxlZSkpKTsKICAgICB9CisK KyAgICB1bnNpZ25lZCBieXRlY29kZUluZGV4ID0gY29kZU9yaWdpbi5ieXRlY29kZUluZGV4Owor ICAgIGlmICghaXNUb3BGcmFtZSkKKyAgICAgICAgYnl0ZWNvZGVJbmRleCArPSBsZW5ndGhPZkNh bGxPcGNvZGVBdChtX2ppdC52bSgpLCBtX2ppdC5iYXNlbGluZUNvZGVCbG9jaygpLCBjb2RlT3Jp Z2luLmJ5dGVjb2RlSW5kZXgpOworICAgIG1faml0LnN0b3JlMzIoQXNzZW1ibHlIZWxwZXJzOjpU cnVzdGVkSW1tMzIoYnl0ZWNvZGVJbmRleCksIEFzc2VtYmx5SGVscGVyczo6dGFnRm9yKChWaXJ0 dWFsUmVnaXN0ZXIpKEpTU3RhY2s6OkFyZ3VtZW50Q291bnQpKSk7CiAgICAgCiAgICAgLy8gMTQp IENyZWF0ZSBhcmd1bWVudHMgaWYgbmVjZXNzYXJ5IGFuZCBwbGFjZSB0aGVtIGludG8gdGhlIGFw cHJvcHJpYXRlIGFsaWFzZWQKICAgICAvLyAgICAgcmVnaXN0ZXJzLgpJbmRleDogU291cmNlL0ph dmFTY3JpcHRDb3JlL2RmZy9ERkdPU1JFeGl0Q29tcGlsZXI2NC5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g U291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdPU1JFeGl0Q29tcGlsZXI2NC5jcHAJKHJldmlz aW9uIDE1MTA1OCkKKysrIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHT1NSRXhpdENvbXBp bGVyNjQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zNCw2ICszNCwxNiBAQAogCiBuYW1lc3BhY2Ug SlNDIHsgbmFtZXNwYWNlIERGRyB7CiAKK3N0YXRpYyBzaXplX3QgbGVuZ3RoT2ZDYWxsT3Bjb2Rl QXQoVk0qIHZtLCBDb2RlQmxvY2sqIGNvZGVCbG9jaywgdW5zaWduZWQgYnl0ZWNvZGVJbmRleCkK K3sKKyAgICBPcGNvZGUgb3Bjb2RlID0gY29kZUJsb2NrLT5pbnN0cnVjdGlvbnMoKVtieXRlY29k ZUluZGV4XS51Lm9wY29kZTsKKyAgICBPcGNvZGVJRCBvcGNvZGVJRCA9IHZtLT5pbnRlcnByZXRl ci0+Z2V0T3Bjb2RlSUQob3Bjb2RlKTsKKyAgICBSRUxFQVNFX0FTU0VSVChvcGNvZGVJRCA9PSBv cF9jYWxsIHx8IG9wY29kZUlEID09IG9wX2NhbGxfZXZhbCB8fCBvcGNvZGVJRCA9PSBvcF9jYWxs X3ZhcmFyZ3MgIHx8IG9wY29kZUlEID09IG9wX2NvbnN0cnVjdCk7CisgICAgQVNTRVJUKE9QQ09E RV9MRU5HVEgob3BfY2FsbCkgPT0gT1BDT0RFX0xFTkdUSChvcF9jYWxsX2V2YWwpKTsKKyAgICBB U1NFUlQoT1BDT0RFX0xFTkdUSChvcF9jYWxsKSA9PSBPUENPREVfTEVOR1RIKG9wX2NvbnN0cnVj dCkpOworICAgIHJldHVybiBVTkxJS0VMWShvcGNvZGVJRCA9PSBvcF9jYWxsX3ZhcmFyZ3MpID8g T1BDT0RFX0xFTkdUSChvcF9jYWxsX3ZhcmFyZ3MpIDogT1BDT0RFX0xFTkdUSChvcF9jYWxsKTsK K30KKwogdm9pZCBPU1JFeGl0Q29tcGlsZXI6OmNvbXBpbGVFeGl0KGNvbnN0IE9TUkV4aXQmIGV4 aXQsIGNvbnN0IE9wZXJhbmRzPFZhbHVlUmVjb3Zlcnk+JiBvcGVyYW5kcywgU3BlY3VsYXRpb25S ZWNvdmVyeSogcmVjb3ZlcnkpCiB7CiAgICAgLy8gMSkgUHJvLWZvcm1hIHN0dWZmLgpAQCAtNTk4 LDEzICs2MDgsMjAgQEAgdm9pZCBPU1JFeGl0Q29tcGlsZXI6OmNvbXBpbGVFeGl0KGNvbnN0IAog ICAgIAogICAgIEFTU0VSVChtX2ppdC5iYXNlbGluZUNvZGVCbG9jaygpLT5nZXRKSVRUeXBlKCkg PT0gSklUQ29kZTo6QmFzZWxpbmVKSVQpOwogICAgIG1faml0LnN0b3JlUHRyKEFzc2VtYmx5SGVs cGVyczo6VHJ1c3RlZEltbVB0cihtX2ppdC5iYXNlbGluZUNvZGVCbG9jaygpKSwgQXNzZW1ibHlI ZWxwZXJzOjphZGRyZXNzRm9yKChWaXJ0dWFsUmVnaXN0ZXIpSlNTdGFjazo6Q29kZUJsb2NrKSk7 Ci0gICAgCi0gICAgZm9yIChDb2RlT3JpZ2luIGNvZGVPcmlnaW4gPSBleGl0Lm1fY29kZU9yaWdp bjsgY29kZU9yaWdpbi5pbmxpbmVDYWxsRnJhbWU7IGNvZGVPcmlnaW4gPSBjb2RlT3JpZ2luLmlu bGluZUNhbGxGcmFtZS0+Y2FsbGVyKSB7CisKKyAgICBDb2RlT3JpZ2luIGNvZGVPcmlnaW47Cisg ICAgYm9vbCBpc1RvcEZyYW1lID0gdHJ1ZTsKKyAgICBmb3IgKGNvZGVPcmlnaW4gPSBleGl0Lm1f Y29kZU9yaWdpbjsgY29kZU9yaWdpbi5pbmxpbmVDYWxsRnJhbWU7IGNvZGVPcmlnaW4gPSBjb2Rl T3JpZ2luLmlubGluZUNhbGxGcmFtZS0+Y2FsbGVyKSB7CiAgICAgICAgIElubGluZUNhbGxGcmFt ZSogaW5saW5lQ2FsbEZyYW1lID0gY29kZU9yaWdpbi5pbmxpbmVDYWxsRnJhbWU7CiAgICAgICAg IENvZGVCbG9jayogYmFzZWxpbmVDb2RlQmxvY2sgPSBtX2ppdC5iYXNlbGluZUNvZGVCbG9ja0Zv cihjb2RlT3JpZ2luKTsKICAgICAgICAgQ29kZUJsb2NrKiBiYXNlbGluZUNvZGVCbG9ja0ZvckNh bGxlciA9IG1faml0LmJhc2VsaW5lQ29kZUJsb2NrRm9yKGlubGluZUNhbGxGcmFtZS0+Y2FsbGVy KTsKICAgICAgICAgVmVjdG9yPEJ5dGVjb2RlQW5kTWFjaGluZU9mZnNldD4mIGRlY29kZWRDb2Rl TWFwID0gbV9qaXQuZGVjb2RlZENvZGVNYXBGb3IoYmFzZWxpbmVDb2RlQmxvY2tGb3JDYWxsZXIp OwotICAgICAgICB1bnNpZ25lZCByZXR1cm5CeXRlY29kZUluZGV4ID0gaW5saW5lQ2FsbEZyYW1l LT5jYWxsZXIuYnl0ZWNvZGVJbmRleCArIE9QQ09ERV9MRU5HVEgob3BfY2FsbCk7CisgICAgICAg IHVuc2lnbmVkIGJ5dGVjb2RlSW5kZXggPSBjb2RlT3JpZ2luLmJ5dGVjb2RlSW5kZXg7CisgICAg ICAgIGlmICghaXNUb3BGcmFtZSkKKyAgICAgICAgICAgIGJ5dGVjb2RlSW5kZXggKz0gbGVuZ3Ro T2ZDYWxsT3Bjb2RlQXQobV9qaXQudm0oKSwgYmFzZWxpbmVDb2RlQmxvY2ssIGNvZGVPcmlnaW4u Ynl0ZWNvZGVJbmRleCk7CisgICAgICAgIGlzVG9wRnJhbWUgPSBmYWxzZTsKKyAgICAgICAgdW5z aWduZWQgcmV0dXJuQnl0ZWNvZGVJbmRleCA9IGlubGluZUNhbGxGcmFtZS0+Y2FsbGVyLmJ5dGVj b2RlSW5kZXgKKyAgICAgICAgICAgICsgbGVuZ3RoT2ZDYWxsT3Bjb2RlQXQobV9qaXQudm0oKSwg YmFzZWxpbmVDb2RlQmxvY2tGb3JDYWxsZXIsIGlubGluZUNhbGxGcmFtZS0+Y2FsbGVyLmJ5dGVj b2RlSW5kZXgpOwogICAgICAgICBCeXRlY29kZUFuZE1hY2hpbmVPZmZzZXQqIG1hcHBpbmcgPSBi aW5hcnlTZWFyY2g8Qnl0ZWNvZGVBbmRNYWNoaW5lT2Zmc2V0LCB1bnNpZ25lZD4oZGVjb2RlZENv ZGVNYXAsIGRlY29kZWRDb2RlTWFwLnNpemUoKSwgcmV0dXJuQnl0ZWNvZGVJbmRleCwgQnl0ZWNv ZGVBbmRNYWNoaW5lT2Zmc2V0OjpnZXRCeXRlY29kZUluZGV4KTsKICAgICAgICAgCiAgICAgICAg IEFTU0VSVChtYXBwaW5nKTsKQEAgLTYyNSwxMCArNjQyLDE2IEBAIHZvaWQgT1NSRXhpdENvbXBp bGVyOjpjb21waWxlRXhpdChjb25zdCAKICAgICAgICAgbV9qaXQuc3RvcmU2NChjYWxsZXJGcmFt ZUdQUiwgQXNzZW1ibHlIZWxwZXJzOjphZGRyZXNzRm9yKChWaXJ0dWFsUmVnaXN0ZXIpKGlubGlu ZUNhbGxGcmFtZS0+c3RhY2tPZmZzZXQgKyBKU1N0YWNrOjpDYWxsZXJGcmFtZSkpKTsKICAgICAg ICAgbV9qaXQuc3RvcmVQdHIoQXNzZW1ibHlIZWxwZXJzOjpUcnVzdGVkSW1tUHRyKGp1bXBUYXJn ZXQpLCBBc3NlbWJseUhlbHBlcnM6OmFkZHJlc3NGb3IoKFZpcnR1YWxSZWdpc3RlcikoaW5saW5l Q2FsbEZyYW1lLT5zdGFja09mZnNldCArIEpTU3RhY2s6OlJldHVyblBDKSkpOwogICAgICAgICBt X2ppdC5zdG9yZTMyKEFzc2VtYmx5SGVscGVyczo6VHJ1c3RlZEltbTMyKGlubGluZUNhbGxGcmFt ZS0+YXJndW1lbnRzLnNpemUoKSksIEFzc2VtYmx5SGVscGVyczo6cGF5bG9hZEZvcigoVmlydHVh bFJlZ2lzdGVyKShpbmxpbmVDYWxsRnJhbWUtPnN0YWNrT2Zmc2V0ICsgSlNTdGFjazo6QXJndW1l bnRDb3VudCkpKTsKKyAgICAgICAgbV9qaXQuc3RvcmUzMihBc3NlbWJseUhlbHBlcnM6OlRydXN0 ZWRJbW0zMihieXRlY29kZUluZGV4KSwgQXNzZW1ibHlIZWxwZXJzOjp0YWdGb3IoKFZpcnR1YWxS ZWdpc3RlcikoaW5saW5lQ2FsbEZyYW1lLT5zdGFja09mZnNldCArIEpTU3RhY2s6OkFyZ3VtZW50 Q291bnQpKSk7CiAgICAgICAgIGlmICghaW5saW5lQ2FsbEZyYW1lLT5pc0Nsb3N1cmVDYWxsKCkp CiAgICAgICAgICAgICBtX2ppdC5zdG9yZTY0KEFzc2VtYmx5SGVscGVyczo6VHJ1c3RlZEltbTY0 KEpTVmFsdWU6OmVuY29kZShKU1ZhbHVlKGlubGluZUNhbGxGcmFtZS0+Y2FsbGVlLmdldCgpKSkp LCBBc3NlbWJseUhlbHBlcnM6OmFkZHJlc3NGb3IoKFZpcnR1YWxSZWdpc3RlcikoaW5saW5lQ2Fs bEZyYW1lLT5zdGFja09mZnNldCArIEpTU3RhY2s6OkNhbGxlZSkpKTsKICAgICB9Ci0gICAgCisK KyAgICB1bnNpZ25lZCBieXRlY29kZUluZGV4ID0gY29kZU9yaWdpbi5ieXRlY29kZUluZGV4Owor ICAgIGlmICghaXNUb3BGcmFtZSkKKyAgICAgICAgYnl0ZWNvZGVJbmRleCArPSBsZW5ndGhPZkNh bGxPcGNvZGVBdChtX2ppdC52bSgpLCBtX2ppdC5iYXNlbGluZUNvZGVCbG9jaygpLCBjb2RlT3Jp Z2luLmJ5dGVjb2RlSW5kZXgpOworICAgIG1faml0LnN0b3JlMzIoQXNzZW1ibHlIZWxwZXJzOjpU cnVzdGVkSW1tMzIoYnl0ZWNvZGVJbmRleCksIEFzc2VtYmx5SGVscGVyczo6dGFnRm9yKChWaXJ0 dWFsUmVnaXN0ZXIpKEpTU3RhY2s6OkFyZ3VtZW50Q291bnQpKSk7CisKICAgICAvLyAxNSkgQ3Jl YXRlIGFyZ3VtZW50cyBpZiBuZWNlc3NhcnkgYW5kIHBsYWNlIHRoZW0gaW50byB0aGUgYXBwcm9w cmlhdGUgYWxpYXNlZAogICAgIC8vICAgICByZWdpc3RlcnMuCiAgICAgCg== 203719 2013-06-04 13:18:16 -0700 2013-06-04 14:26:18 -0700 reworked patch for ftl branch bug-117103.patch text/plain 2541 mark.lam SW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMTUxMTgwKQorKysgU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDEzIEBA CisyMDEzLTA2LTA0ICBNYXJrIExhbSAgPG1hcmsubGFtQGFwcGxlLmNvbT4KKworICAgICAgICBU aGUgREZHIEpJVCBzaG91bGQgcG9wdWxhdGUgZnJhbWUgYnl0ZWNvZGVPZmZzZXRzIG9uIE9TUiBl eGl0LgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTE3 MTAzLgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICog ZGZnL0RGR09TUkV4aXRDb21waWxlckNvbW1vbi5jcHA6CisgICAgICAgIChKU0M6OkRGRzo6cmVp ZnlJbmxpbmVkQ2FsbEZyYW1lcyk6CisKIDIwMTMtMDYtMDQgIE1hcmsgTGFtICA8bWFyay5sYW1A YXBwbGUuY29tPgogCiAgICAgICAgIE1lcmdlZCBmcm9tIGh0dHA6Ly9zdm4ud2Via2l0Lm9yZy9y ZXBvc2l0b3J5L3dlYmtpdC90cnVuawpJbmRleDogU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9E RkdPU1JFeGl0Q29tcGlsZXJDb21tb24uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS9kZmcvREZHT1NSRXhpdENvbXBpbGVyQ29tbW9uLmNwcAkocmV2aXNpb24gMTUxMTgw KQorKysgU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdPU1JFeGl0Q29tcGlsZXJDb21tb24u Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC03OCw4ICs3OCw5IEBAIHZvaWQgcmVpZnlJbmxpbmVkQ2Fs bEZyYW1lcyhDQ2FsbEhlbHBlcnMKIHsKICAgICBBU1NFUlQoaml0LmJhc2VsaW5lQ29kZUJsb2Nr KCktPmppdFR5cGUoKSA9PSBKSVRDb2RlOjpCYXNlbGluZUpJVCk7CiAgICAgaml0LnN0b3JlUHRy KEFzc2VtYmx5SGVscGVyczo6VHJ1c3RlZEltbVB0cihqaXQuYmFzZWxpbmVDb2RlQmxvY2soKSks IEFzc2VtYmx5SGVscGVyczo6YWRkcmVzc0ZvcigoVmlydHVhbFJlZ2lzdGVyKUpTU3RhY2s6OkNv ZGVCbG9jaykpOwotICAgIAotICAgIGZvciAoQ29kZU9yaWdpbiBjb2RlT3JpZ2luID0gZXhpdC5t X2NvZGVPcmlnaW47IGNvZGVPcmlnaW4uaW5saW5lQ2FsbEZyYW1lOyBjb2RlT3JpZ2luID0gY29k ZU9yaWdpbi5pbmxpbmVDYWxsRnJhbWUtPmNhbGxlcikgeworCisgICAgQ29kZU9yaWdpbiBjb2Rl T3JpZ2luOworICAgIGZvciAoY29kZU9yaWdpbiA9IGV4aXQubV9jb2RlT3JpZ2luOyBjb2RlT3Jp Z2luLmlubGluZUNhbGxGcmFtZTsgY29kZU9yaWdpbiA9IGNvZGVPcmlnaW4uaW5saW5lQ2FsbEZy YW1lLT5jYWxsZXIpIHsKICAgICAgICAgSW5saW5lQ2FsbEZyYW1lKiBpbmxpbmVDYWxsRnJhbWUg PSBjb2RlT3JpZ2luLmlubGluZUNhbGxGcmFtZTsKICAgICAgICAgQ29kZUJsb2NrKiBiYXNlbGlu ZUNvZGVCbG9jayA9IGppdC5iYXNlbGluZUNvZGVCbG9ja0Zvcihjb2RlT3JpZ2luKTsKICAgICAg ICAgQ29kZUJsb2NrKiBiYXNlbGluZUNvZGVCbG9ja0ZvckNhbGxlciA9IGppdC5iYXNlbGluZUNv ZGVCbG9ja0ZvcihpbmxpbmVDYWxsRnJhbWUtPmNhbGxlcik7CkBAIC0xMjQsNyArMTI1LDExIEBA IHZvaWQgcmVpZnlJbmxpbmVkQ2FsbEZyYW1lcyhDQ2FsbEhlbHBlcnMKICAgICAgICAgaWYgKCFp bmxpbmVDYWxsRnJhbWUtPmlzQ2xvc3VyZUNhbGwoKSkKICAgICAgICAgICAgIGppdC5zdG9yZVB0 cihBc3NlbWJseUhlbHBlcnM6OlRydXN0ZWRJbW1QdHIoaW5saW5lQ2FsbEZyYW1lLT5jYWxsZWUu Z2V0KCkpLCBBc3NlbWJseUhlbHBlcnM6OnBheWxvYWRGb3IoKFZpcnR1YWxSZWdpc3RlcikoaW5s aW5lQ2FsbEZyYW1lLT5zdGFja09mZnNldCArIEpTU3RhY2s6OkNhbGxlZSkpKTsKICNlbmRpZiAv LyBVU0UoSlNWQUxVRTY0KSAvLyBlbmRpbmcgdGhlICNlbHNlIHBhcnQsIHNvIGRpcmVjdGx5IGFi b3ZlIGlzIHRoZSAzMi1iaXQgcGFydAorCisgICAgICAgIGppdC5zdG9yZTMyKEFzc2VtYmx5SGVs cGVyczo6VHJ1c3RlZEltbTMyKGNvZGVPcmlnaW4uYnl0ZWNvZGVJbmRleCksIEFzc2VtYmx5SGVs cGVyczo6dGFnRm9yKChWaXJ0dWFsUmVnaXN0ZXIpKGlubGluZUNhbGxGcmFtZS0+c3RhY2tPZmZz ZXQgKyBKU1N0YWNrOjpBcmd1bWVudENvdW50KSkpOwogICAgIH0KKworICAgIGppdC5zdG9yZTMy KEFzc2VtYmx5SGVscGVyczo6VHJ1c3RlZEltbTMyKGNvZGVPcmlnaW4uYnl0ZWNvZGVJbmRleCks IEFzc2VtYmx5SGVscGVyczo6dGFnRm9yKChWaXJ0dWFsUmVnaXN0ZXIpKEpTU3RhY2s6OkFyZ3Vt ZW50Q291bnQpKSk7CiB9CiAKIHZvaWQgYWRqdXN0QW5kSnVtcFRvVGFyZ2V0KENDYWxsSGVscGVy cyYgaml0LCBjb25zdCBPU1JFeGl0QmFzZSYgZXhpdCkK