231606 2021-10-12 12:19:11 -0700 ASSERT hit in surrogatePairAwareIndex and surrogatePairAwareStart lambdas for text with unpaired surrogates 2021-10-13 17:57:24 -0700 1 1 1 Unclassified WebKit Text WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 gnavamarino webkit-unassigned darin mmaxfield webkit-bug-importer zalan oldest_to_newest 1803300 0 gnavamarino 2021-10-12 12:19:11 -0700 surrogatePairAwareIndex and surrogatePairAwareStart lambdas in TextUtil::MidWordBreak TextUtil::midWordBreak are assuming there are no unpaired surrogates but that is not guaranteed as they don't always come in pairs. 1803382 1 440982 gnavamarino 2021-10-12 14:23:35 -0700 Created attachment 440982 Patch 1803396 2 440982 mmaxfield 2021-10-12 14:31:55 -0700 Comment on attachment 440982 Patch Awesome 💯 1803482 3 440982 darin 2021-10-12 15:36:11 -0700 Comment on attachment 440982 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=440982&action=review > Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:150 > + bool isLead = U16_IS_LEAD(text[index]) && (index + 1) < text.length() && U16_IS_TRAIL(text[index + 1]); Given that this is WTF::String, we don’t need the rang checks on index. The subscript operator does enough range checking. > Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:-152 > - RELEASE_ASSERT(index + 1 < text.length()); Why remove this? > Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:153 > return ++index; This is bizarre. It should return index + 1; why use ++? > Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:172 > + bool isTrail = index && U16_IS_LEAD(text[index - 1]) && index < text.length() && U16_IS_TRAIL(text[index]); Given that this is WTF::String, we don’t need the additional range checks on index. The subscript operator does enough range checking. > Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:176 > return --index; This is bizarre. It should return index - 1; why use --? 1803492 4 ews-feeder 2021-10-12 15:47:43 -0700 Committed r284050 (242879@main): <https://commits.webkit.org/242879@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 440982. 1803496 5 webkit-bug-importer 2021-10-12 15:48:39 -0700 <rdar://problem/84170185> 1803502 6 gnavamarino 2021-10-12 15:53:31 -0700 View in context: https://bugs.webkit.org/attachment.cgi?id=440982&action=review >> Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:150 >> + bool isLead = U16_IS_LEAD(text[index]) && (index + 1) < text.length() && U16_IS_TRAIL(text[index + 1]); > > Given that this is WTF::String, we don’t need the rang checks on index. The subscript operator does enough range checking. Thank you for the clarification. I will remove the range checks. >> Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:-152 >> - RELEASE_ASSERT(index + 1 < text.length()); > > Why remove this? This is enforced via early return in the if statement range check above. However, since I will remove the range checks, I will re-add this back here. >> Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:153 >> return ++index; > > This is bizarre. It should return index + 1; why use ++? I will update to use index + 1. >> Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:172 >> + bool isTrail = index && U16_IS_LEAD(text[index - 1]) && index < text.length() && U16_IS_TRAIL(text[index]); > > Given that this is WTF::String, we don’t need the additional range checks on index. The subscript operator does enough range checking. Thank you for the clarification. I will remove the range checks from here as well. >> Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:176 >> return --index; > > This is bizarre. It should return index - 1; why use --? I will update to use index - 1. 1803508 7 gnavamarino 2021-10-12 15:58:52 -0700 Reopened to address latest review comments. 1803520 8 440982 darin 2021-10-12 16:06:20 -0700 Comment on attachment 440982 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=440982&action=review > Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:178 > // When the substring does not fit, the right side is supposed to be the start of the surrogate pair if applicable. One other thought, not something we need to do, but maybe worth considering. The ICU library includes a macro for this specific operation, U16_SET_CP_START. We could just write: right = middle; U16_SET_CP_START(text, 0, right); Then we would not need to write the surrogatePairAwareStart function at all. Perhaps there is a suitable macro for the surrogatePairAwareIndex operation too; I didn’t find it. 1803563 9 gnavamarino 2021-10-12 16:50:47 -0700 (In reply to Darin Adler from comment #8) > Comment on attachment 440982 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=440982&action=review > > > Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:178 > > // When the substring does not fit, the right side is supposed to be the start of the surrogate pair if applicable. > > One other thought, not something we need to do, but maybe worth considering. > > The ICU library includes a macro for this specific operation, > U16_SET_CP_START. We could just write: > > right = middle; > U16_SET_CP_START(text, 0, right); > > Then we would not need to write the surrogatePairAwareStart function at all. Thank you for pointing this out. I will try it! > Perhaps there is a suitable macro for the surrogatePairAwareIndex operation > too; I didn’t find it. It looks like this could have been the closest one, but not quite: U16_SET_CP_LIMIT(s, start, i, length) 1803573 10 darin 2021-10-12 17:22:27 -0700 (In reply to Gabriel Nava Marino from comment #9) > It looks like this could have been the closest one, but not quite: > U16_SET_CP_LIMIT(s, start, i, length) Yes, I do think clients of surrogatePairAwareIndex can be rewritten to use U16_SET_CP_LIMIT. 1803574 11 darin 2021-10-12 17:22:39 -0700 (In reply to Darin Adler from comment #10) > (In reply to Gabriel Nava Marino from comment #9) > > It looks like this could have been the closest one, but not quite: > > U16_SET_CP_LIMIT(s, start, i, length) > > Yes, I do think clients of surrogatePairAwareIndex can be rewritten to use > U16_SET_CP_LIMIT. Simply and fairly elegantly. 1803587 12 440982 darin 2021-10-12 17:35:52 -0700 Comment on attachment 440982 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=440982&action=review > Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:155 > It would be: auto right = std::min<unsigned>(left + offset, (startPosition + length - 1)); U16_SET_CP_LIMIT(text, 0, right, text.length()); auto middle = surrogatePairAwareIndex((left + right) / 2); U16_SET_CP_LIMIT(text, 0, middle, text.length()); 1803588 13 gnavamarino 2021-10-12 17:46:42 -0700 (In reply to Darin Adler from comment #12) > Comment on attachment 440982 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=440982&action=review > > > Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:155 > > > > It would be: > > auto right = std::min<unsigned>(left + offset, (startPosition + length - > 1)); > U16_SET_CP_LIMIT(text, 0, right, text.length()); > > auto middle = surrogatePairAwareIndex((left + right) / 2); > U16_SET_CP_LIMIT(text, 0, middle, text.length()); Thank you, I will try this! Although I just notice that currently, surrogatePairAwareIndex returns the index at trail whereas U16_SET_CP_LIMIT returns the index past it: #define U16_SET_CP_LIMIT(s, start, i, length) UPRV_BLOCK_MACRO_BEGIN { \ if((start)<(i) && ((i)<(length) || (length)<0) && U16_IS_LEAD((s)[(i)-1]) && U16_IS_TRAIL((s)[i])) { \ ++(i); \ } \ } UPRV_BLOCK_MACRO_END 1803591 14 440982 darin 2021-10-12 17:50:54 -0700 Comment on attachment 440982 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=440982&action=review >>> Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:155 >>> >> >> It would be: >> >> auto right = std::min<unsigned>(left + offset, (startPosition + length - 1)); >> U16_SET_CP_LIMIT(text, 0, right, text.length()); >> >> auto middle = surrogatePairAwareIndex((left + right) / 2); >> U16_SET_CP_LIMIT(text, 0, middle, text.length()); > > Thank you, I will try this! Although I just notice that currently, surrogatePairAwareIndex returns the index at trail whereas U16_SET_CP_LIMIT returns the index past it: > > #define U16_SET_CP_LIMIT(s, start, i, length) UPRV_BLOCK_MACRO_BEGIN { \ > if((start)<(i) && ((i)<(length) || (length)<0) && U16_IS_LEAD((s)[(i)-1]) && U16_IS_TRAIL((s)[i])) { \ > ++(i); \ > } \ > } UPRV_BLOCK_MACRO_END Oh, OK, good point. So my code is wrong. It would be more like this: auto right = std::min<unsigned>(left + offset + 1, startPosition + length); U16_SET_CP_LIMIT(text, 0, right, text.length()); --right; 1803593 15 440982 darin 2021-10-12 17:53:08 -0700 Comment on attachment 440982 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=440982&action=review >>>> Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:155 >>>> >>> >>> It would be: >>> >>> auto right = std::min<unsigned>(left + offset, (startPosition + length - 1)); >>> U16_SET_CP_LIMIT(text, 0, right, text.length()); >>> >>> auto middle = surrogatePairAwareIndex((left + right) / 2); >>> U16_SET_CP_LIMIT(text, 0, middle, text.length()); >> >> Thank you, I will try this! Although I just notice that currently, surrogatePairAwareIndex returns the index at trail whereas U16_SET_CP_LIMIT returns the index past it: >> >> #define U16_SET_CP_LIMIT(s, start, i, length) UPRV_BLOCK_MACRO_BEGIN { \ >> if((start)<(i) && ((i)<(length) || (length)<0) && U16_IS_LEAD((s)[(i)-1]) && U16_IS_TRAIL((s)[i])) { \ >> ++(i); \ >> } \ >> } UPRV_BLOCK_MACRO_END > > Oh, OK, good point. So my code is wrong. It would be more like this: > > auto right = std::min<unsigned>(left + offset + 1, startPosition + length); > U16_SET_CP_LIMIT(text, 0, right, text.length()); > --right; And perhaps then could change the logic to get rid of the need for the "--right". Maybe a waste of time, but I do think that using the U16 macros is still a little easier to get correct than writing our own code. 1803596 16 gnavamarino 2021-10-12 18:07:21 -0700 (In reply to Darin Adler from comment #15) > Comment on attachment 440982 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=440982&action=review > > >>>> Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:155 > >>>> > >>> > >>> It would be: > >>> > >>> auto right = std::min<unsigned>(left + offset, (startPosition + length - 1)); > >>> U16_SET_CP_LIMIT(text, 0, right, text.length()); > >>> > >>> auto middle = surrogatePairAwareIndex((left + right) / 2); > >>> U16_SET_CP_LIMIT(text, 0, middle, text.length()); > >> > >> Thank you, I will try this! Although I just notice that currently, surrogatePairAwareIndex returns the index at trail whereas U16_SET_CP_LIMIT returns the index past it: > >> > >> #define U16_SET_CP_LIMIT(s, start, i, length) UPRV_BLOCK_MACRO_BEGIN { \ > >> if((start)<(i) && ((i)<(length) || (length)<0) && U16_IS_LEAD((s)[(i)-1]) && U16_IS_TRAIL((s)[i])) { \ > >> ++(i); \ > >> } \ > >> } UPRV_BLOCK_MACRO_END > > > > Oh, OK, good point. So my code is wrong. It would be more like this: > > > > auto right = std::min<unsigned>(left + offset + 1, startPosition + length); > > U16_SET_CP_LIMIT(text, 0, right, text.length()); > > --right; > > And perhaps then could change the logic to get rid of the need for the > "--right". I will work to update the logic to avoid the extra decrement. Thank you for the suggestion Darin. > > Maybe a waste of time, but I do think that using the U16 macros is still a > little easier to get correct than writing our own code. Yes, agreed! I will work to get this macro working. The upside being that the "safe" macro offers handling of unpaired surrogates and checks for string boundaries. 1804026 17 gnavamarino 2021-10-13 15:41:46 -0700 (In reply to Darin Adler from comment #15) > Comment on attachment 440982 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=440982&action=review > > >>>> Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:155 > >>>> > >>> > >>> It would be: > >>> > >>> auto right = std::min<unsigned>(left + offset, (startPosition + length - 1)); > >>> U16_SET_CP_LIMIT(text, 0, right, text.length()); > >>> > >>> auto middle = surrogatePairAwareIndex((left + right) / 2); > >>> U16_SET_CP_LIMIT(text, 0, middle, text.length()); > >> > >> Thank you, I will try this! Although I just notice that currently, surrogatePairAwareIndex returns the index at trail whereas U16_SET_CP_LIMIT returns the index past it: > >> > >> #define U16_SET_CP_LIMIT(s, start, i, length) UPRV_BLOCK_MACRO_BEGIN { \ > >> if((start)<(i) && ((i)<(length) || (length)<0) && U16_IS_LEAD((s)[(i)-1]) && U16_IS_TRAIL((s)[i])) { \ > >> ++(i); \ > >> } \ > >> } UPRV_BLOCK_MACRO_END > > > > Oh, OK, good point. So my code is wrong. It would be more like this: > > > > auto right = std::min<unsigned>(left + offset + 1, startPosition + length); > > U16_SET_CP_LIMIT(text, 0, right, text.length()); > > --right; > > And perhaps then could change the logic to get rid of the need for the > "--right". I tried adjusting the logic so that we could get rid of the need for the "--right". However, because of the loop condition "while (left < right)" and need for two U16_SET_CP_LIMIT calls and then the subsequent U16_SET_CP_START, we would need at least one "--right" after U16_SET_CP_START. To avoid this, I have opted to keep surrogatePairAwareIndex and return index - 1 instead. Although we are still using this lambda, it is only using the U16 U16_SET_CP_LIMIT macro now. > > Maybe a waste of time, but I do think that using the U16 macros is still a > little easier to get correct than writing our own code. 1804027 18 darin 2021-10-13 15:42:33 -0700 (In reply to Gabriel Nava Marino from comment #17) > To avoid this, I have opted to keep surrogatePairAwareIndex and return index > - 1 instead. Although we are still using this lambda, it is only using the > U16 U16_SET_CP_LIMIT macro now. OK, sounds pretty good. 1804030 19 441150 gnavamarino 2021-10-13 15:46:03 -0700 Created attachment 441150 Patch 1804043 20 441150 darin 2021-10-13 16:05:13 -0700 Comment on attachment 441150 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=441150&action=review Thanks for taking advantage of my suggestion to use higher level U16 macros instead of writing the code ourselves. I think it’s looking good. > Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:149 > + U16_SET_CP_LIMIT(text, 0, index, text.length()); I think it’s a little bit less clear to modify an argument, index, than to modify a copy of it. It’s an informal coding style rule in WebKit that we typically don’t use arguments that way, even when they are passed by value and can be used that way. > Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:159 > + auto right = surrogatePairAwareIndex(std::min<unsigned>(left + offset + 1, (startPosition + length))); Why add the + 1 for the the argument to surrogatePairAwareIndex at each place it’s called? Seems like the + 1 could be done inside that function. Maybe you think the function makes more sense with these semantics? If so, that’s OK, but if not, I’d do it there. 1804048 21 gnavamarino 2021-10-13 16:12:41 -0700 (In reply to Darin Adler from comment #20) > Comment on attachment 441150 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=441150&action=review > > Thanks for taking advantage of my suggestion to use higher level U16 macros > instead of writing the code ourselves. I think it’s looking good. > > > Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:149 > > + U16_SET_CP_LIMIT(text, 0, index, text.length()); > > I think it’s a little bit less clear to modify an argument, index, than to > modify a copy of it. It’s an informal coding style rule in WebKit that we > typically don’t use arguments that way, even when they are passed by value > and can be used that way. > Thank you for the suggestion. I will make a copy of the argument. > > Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:159 > > + auto right = surrogatePairAwareIndex(std::min<unsigned>(left + offset + 1, (startPosition + length))); > > Why add the + 1 for the the argument to surrogatePairAwareIndex at each > place it’s called? Seems like the + 1 could be done inside that function. > > Maybe you think the function makes more sense with these semantics? If so, > that’s OK, but if not, I’d do it there. It was done primarily to avoid doing the + 1 inside the function, but if we are also making a copy of the argument, then I will do the + 1 inside the function at the same time. Thank you for the suggestion. 1804050 22 441156 gnavamarino 2021-10-13 16:17:18 -0700 Created attachment 441156 Patch 1804056 23 441156 darin 2021-10-13 16:32:08 -0700 Comment on attachment 441156 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=441156&action=review > Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:151 > + RELEASE_ASSERT(offset - 1 < text.length()); Not 100% sure we need this RELEASE_ASSERT. 1804059 24 gnavamarino 2021-10-13 16:42:17 -0700 (In reply to Darin Adler from comment #23) > Comment on attachment 441156 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=441156&action=review > > > Source/WebCore/layout/formattingContexts/inline/text/TextUtil.cpp:151 > > + RELEASE_ASSERT(offset - 1 < text.length()); > > Not 100% sure we need this RELEASE_ASSERT. We don't need this. I will update this to remove it. Thank you. 1804060 25 441158 gnavamarino 2021-10-13 16:43:21 -0700 Created attachment 441158 Patch 1804109 26 ews-feeder 2021-10-13 17:57:22 -0700 Committed r284141 (242961@main): <https://commits.webkit.org/242961@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 441158. 440982 2021-10-12 14:23:35 -0700 2021-10-13 15:45:59 -0700 Patch bug-231606-20211012142334.patch text/plain 12637 gnavamarino U3VidmVyc2lvbiBSZXZpc2lvbjogMjgzNjMwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNmRmMjE1NWRmMDY1Yzc0 NDk4MmQ1NDA3MjFiYmU1YjEyZTBkYjRjMC4uOGJmZWE3NTI2MzJkMDYyZDMwMGUxMTdmYjBjNDI5 N2M3MzFlNzE1YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDIxLTEwLTEyICBHYWJy aWVsIE5hdmEgTWFyaW5vICA8Z25hdmFtYXJpbm9AYXBwbGUuY29tPgorCisgICAgICAgIEFTU0VS VCBoaXQgaW4gc3Vycm9nYXRlUGFpckF3YXJlSW5kZXggYW5kIHN1cnJvZ2F0ZVBhaXJBd2FyZVN0 YXJ0IGxhbWJkYXMgZm9yIHRleHQgd2l0aCB1bnBhaXJlZCBzdXJyb2dhdGVzCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzE2MDYKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUZXN0czogZmFzdC90ZXh0L3dv cmQtYnJlYWstY29sdW1uLWdhcC1kaXNwbGF5LWZsZXgtdXRmMTYtc3Vycm9nYXRlcy5odG1sCisg ICAgICAgICAgICAgICBmYXN0L3RleHQvd29yZC1icmVhay1sZXR0ZXItc3BhY2luZy11dGYxNi1z dXJyb2dhdGVzLmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvdGV4dC93b3JkLWJyZWFrLW1heC13 aWR0aC11dGYxNi1zdXJyb2dhdGVzLmh0bWwKKworICAgICAgICAqIGxheW91dC9mb3JtYXR0aW5n Q29udGV4dHMvaW5saW5lL3RleHQvVGV4dFV0aWwuY3BwOgorICAgICAgICAoV2ViQ29yZTo6TGF5 b3V0OjpUZXh0VXRpbDo6bWlkV29yZEJyZWFrKToKKyAgICAgICAgQWNjb3VudCBmb3IgdW5wYWly ZWQgc3Vycm9nYXRlcyBpbiBzdXJyb2dhdGVQYWlyQXdhcmVJbmRleCBhbmQgc3Vycm9nYXRlUGFp ckF3YXJlU3RhcnQgbGFtYmRhcworICAgICAgICBpbiBUZXh0VXRpbDo6TWlkV29yZEJyZWFrIFRl eHRVdGlsOjptaWRXb3JkQnJlYWsgCisKIDIwMjEtMTAtMDYgIFlvdWVubiBGYWJsZXQgIDx5b3Vl bm5AYXBwbGUuY29tPgogCiAgICAgICAgIENvcmVBdWRpb1NoYXJlZFVuaXQgc2hvdWxkIG5vdCBj bGVhciBpdHMgcGVyc2lzdGVudElEIHdoZW4gZGV2aWNlIGNhcHR1cmUgY2hhbmdlcwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvbGF5b3V0L2Zvcm1hdHRpbmdDb250ZXh0cy9pbmxpbmUvdGV4 dC9UZXh0VXRpbC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9sYXlvdXQvZm9ybWF0dGluZ0NvbnRleHRz L2lubGluZS90ZXh0L1RleHRVdGlsLmNwcAppbmRleCA4NGY4MzJmZTc2YmNkYzViNzlmMzFjZDQ4 MGFmMTBjMzY2YmMyYWM3Li4yODg4MDJiYTE2MjA1MGFiMGI1ZmEyZjBkYTM1MjljOGFkMzgzOTkz IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sYXlvdXQvZm9ybWF0dGluZ0NvbnRleHRzL2lu bGluZS90ZXh0L1RleHRVdGlsLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9sYXlvdXQvZm9ybWF0 dGluZ0NvbnRleHRzL2lubGluZS90ZXh0L1RleHRVdGlsLmNwcApAQCAtMTQ3LDEwICsxNDcsOSBA QCBUZXh0VXRpbDo6TWlkV29yZEJyZWFrIFRleHRVdGlsOjptaWRXb3JkQnJlYWsoY29uc3QgSW5s aW5lVGV4dEl0ZW0mIGlubGluZVRleHRJdAogICAgIGF1dG8gc3Vycm9nYXRlUGFpckF3YXJlSW5k ZXggPSBbJl0gKGF1dG8gaW5kZXgpIHsKICAgICAgICAgLy8gV2Ugc2hvdWxkIG5ldmVyIGJyZWFr IGluIHRoZSBtaWRkbGUgb2YgYSBzdXJyb2dhdGUgcGFpci4gVGhleSBhcmUgY29uc2lkZXJlZCBv bmUgam9pbnQgZW50aXR5LgogICAgICAgICBSRUxFQVNFX0FTU0VSVChpbmRleCA8IHRleHQubGVu Z3RoKCkpOwotICAgICAgICBpZiAoIVUxNl9JU19MRUFEKHRleHRbaW5kZXhdKSkKKyAgICAgICAg Ym9vbCBpc0xlYWQgPSBVMTZfSVNfTEVBRCh0ZXh0W2luZGV4XSkgJiYgKGluZGV4ICsgMSkgPCB0 ZXh0Lmxlbmd0aCgpICYmIFUxNl9JU19UUkFJTCh0ZXh0W2luZGV4ICsgMV0pOworICAgICAgICBp ZiAoIWlzTGVhZCkKICAgICAgICAgICAgIHJldHVybiBpbmRleDsKLSAgICAgICAgUkVMRUFTRV9B U1NFUlQoaW5kZXggKyAxIDwgdGV4dC5sZW5ndGgoKSk7Ci0gICAgICAgIEFTU0VSVChVMTZfSVNf VFJBSUwodGV4dFtpbmRleCArIDFdKSk7CiAgICAgICAgIHJldHVybiArK2luZGV4OwogICAgIH07 CiAKQEAgLTE3MCwxMCArMTY5LDEwIEBAIFRleHRVdGlsOjpNaWRXb3JkQnJlYWsgVGV4dFV0aWw6 Om1pZFdvcmRCcmVhayhjb25zdCBJbmxpbmVUZXh0SXRlbSYgaW5saW5lVGV4dEl0CiAgICAgICAg ICAgICBsZWZ0U2lkZVdpZHRoID0gd2lkdGg7CiAgICAgICAgIH0gZWxzZSBpZiAod2lkdGggPiBh dmFpbGFibGVXaWR0aCkgewogICAgICAgICAgICAgYXV0byBzdXJyb2dhdGVQYWlyQXdhcmVTdGFy dCA9IFsmXSAoYXV0byBpbmRleCkgewotICAgICAgICAgICAgICAgIGlmICghVTE2X0lTX1RSQUlM KHRleHRbbWlkZGxlXSkpCisgICAgICAgICAgICAgICAgYm9vbCBpc1RyYWlsID0gaW5kZXggJiYg VTE2X0lTX0xFQUQodGV4dFtpbmRleCAtIDFdKSAmJiBpbmRleCA8IHRleHQubGVuZ3RoKCkgJiYg VTE2X0lTX1RSQUlMKHRleHRbaW5kZXhdKTsKKyAgICAgICAgICAgICAgICBpZiAoIWlzVHJhaWwp CiAgICAgICAgICAgICAgICAgICAgIHJldHVybiBpbmRleDsKICAgICAgICAgICAgICAgICBSRUxF QVNFX0FTU0VSVChpbmRleCk7Ci0gICAgICAgICAgICAgICAgQVNTRVJUKFUxNl9JU19MRUFEKHRl eHRbaW5kZXggLSAxXSkpOwogICAgICAgICAgICAgICAgIHJldHVybiAtLWluZGV4OwogICAgICAg ICAgICAgfTsKICAgICAgICAgICAgIC8vIFdoZW4gdGhlIHN1YnN0cmluZyBkb2VzIG5vdCBmaXQs IHRoZSByaWdodCBzaWRlIGlzIHN1cHBvc2VkIHRvIGJlIHRoZSBzdGFydCBvZiB0aGUgc3Vycm9n YXRlIHBhaXIgaWYgYXBwbGljYWJsZS4gCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggMzIwNDZhNmVhYzJkMDVlYzU2NjZjMjY3 ODZiYTM5ZDM1Zjg0MTExNS4uYzA2OTgxZWVmN2RhYmUxMjBiMzQ4NGY3NGFiMmUyNjllMTM2ZjYw NyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3RzL0No YW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDIxLTEwLTEyICBHYWJyaWVsIE5hdmEgTWFyaW5v ICA8Z25hdmFtYXJpbm9AYXBwbGUuY29tPgorCisgICAgICAgIEFTU0VSVCBoaXQgaW4gc3Vycm9n YXRlUGFpckF3YXJlSW5kZXggYW5kIHN1cnJvZ2F0ZVBhaXJBd2FyZVN0YXJ0IGxhbWJkYXMgZm9y IHRleHQgd2l0aCB1bnBhaXJlZCBzdXJyb2dhdGVzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzE2MDYKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICAqIGZhc3QvdGV4dC93b3JkLWJyZWFrLWNvbHVtbi1nYXAt ZGlzcGxheS1mbGV4LXV0ZjE2LXN1cnJvZ2F0ZXMtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L3RleHQvd29yZC1icmVhay1jb2x1bW4tZ2FwLWRpc3BsYXktZmxleC11dGYxNi1z dXJyb2dhdGVzLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC93b3JkLWJyZWFrLWxl dHRlci1zcGFjaW5nLXV0ZjE2LXN1cnJvZ2F0ZXMtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L3RleHQvd29yZC1icmVhay1sZXR0ZXItc3BhY2luZy11dGYxNi1zdXJyb2dhdGVz Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC93b3JkLWJyZWFrLW1heC13aWR0aC11 dGYxNi1zdXJyb2dhdGVzLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0 L3dvcmQtYnJlYWstbWF4LXdpZHRoLXV0ZjE2LXN1cnJvZ2F0ZXMuaHRtbDogQWRkZWQuCisKIDIw MjEtMTAtMDYgIEF5dW1pIEtvamltYSAgPGF5dW1pX2tvamltYUBhcHBsZS5jb20+CiAKICAgICAg ICAgbWVkaWEvbW9kZXJuLW1lZGlhLWNvbnRyb2xzIHRlc3RzIGFyZSB0aW1pbmcgb3V0LgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0L3dvcmQtYnJlYWstY29sdW1uLWdhcC1kaXNw bGF5LWZsZXgtdXRmMTYtc3Vycm9nYXRlcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0 L3RleHQvd29yZC1icmVhay1jb2x1bW4tZ2FwLWRpc3BsYXktZmxleC11dGYxNi1zdXJyb2dhdGVz LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi42NTMxMmJjOTczNmU1OTBjNDZhMjUyMjFlNjJkMWNk YzE0YzhiNmE4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0L3dvcmQt YnJlYWstY29sdW1uLWdhcC1kaXNwbGF5LWZsZXgtdXRmMTYtc3Vycm9nYXRlcy1leHBlY3RlZC50 eHQKQEAgLTAsMCArMSwxNSBAQAor77+9Civvv70KK++/vXIKK++/vXIKK3Lvv70KK++/vQor8JCA gAorcu+/vXIKK3Lvv71yCivvv73vv70KK++/vXLvv70KK++/vXLvv70KK++/vfCQgIAKK/CQgIDv v70KK1BBU1MKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC93b3JkLWJyZWFrLWNv bHVtbi1nYXAtZGlzcGxheS1mbGV4LXV0ZjE2LXN1cnJvZ2F0ZXMuaHRtbCBiL0xheW91dFRlc3Rz L2Zhc3QvdGV4dC93b3JkLWJyZWFrLWNvbHVtbi1nYXAtZGlzcGxheS1mbGV4LXV0ZjE2LXN1cnJv Z2F0ZXMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lN2YyY2RiY2NkZmI0ZTA1ODRiY2JiNWNjOGZjOTA0MDdj ZWU4N2IwCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0L3dvcmQtYnJl YWstY29sdW1uLWdhcC1kaXNwbGF5LWZsZXgtdXRmMTYtc3Vycm9nYXRlcy5odG1sCkBAIC0wLDAg KzEsNzAgQEAKKzxzdHlsZT4KKyAgZGl2IHsKKyAgICB3b3JkLWJyZWFrOiBicmVhay13b3JkOwor ICAgIGNvbHVtbi1nYXA6IDEwMDBweDsKKyAgICBkaXNwbGF5OiBmbGV4OworICB9Cis8L3N0eWxl PgorPHNjcmlwdD4KKyAgb25sb2FkID0gKCkgPT4geworICAgIC8vIG9ubHkgc3Vycm9nYXRlIGxl YWQKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MSIpLmFwcGVuZCgiXHVkODAwIik7 CisKKyAgICAvLyBvbmx5IHN1cnJvZ2F0ZSB0cmFpbAorICAgIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJkaXYyIikuYXBwZW5kKCJcdWRjMDAiKTsKKworICAgIC8vIHN1cnJvZ2F0ZSBsZWFkICsg c2luZ2xlCisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjMiKS5hcHBlbmQoIlx1ZDgw MHIiKTsKKworICAgIC8vIHN1cnJvZ2F0ZSB0cmFpbCArIHNpbmdsZQorICAgIGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJkaXY0IikuYXBwZW5kKCJcdWRjMDByIik7CisKKyAgICAvLyBzaW5nbGUg KyBzdXJyb2dhdGUgbGVhZAorICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXY1IikuYXBw ZW5kKCJyXHVkODAwIik7CisKKyAgICAvLyBzaW5nbGUgKyBzdXJyb2dhdGUgdHJhaWwKKyAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2NiIpLmFwcGVuZCgiXHVkYzAwIik7CisKKyAgICAv LyBzdXJyb2dhdGUgbGVhZCArIHN1cnJvZ2F0ZSB0cmFpbAorICAgIGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJkaXY3IikuYXBwZW5kKCJcdWQ4MDBcdWRjMDAiKTsKKworICAgIC8vIHNpbmdsZSAr IHN1cnJvZ2F0ZSBsZWFkICsgc2luZ2xlCisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRp djgiKS5hcHBlbmQoInJcdWQ4MDByIik7CisKKyAgICAvLyBzaW5nbGUgKyBzdXJyb2dhdGUgdHJh aWwgKyBzaW5nbGUKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2OSIpLmFwcGVuZCgi clx1ZGMwMHIiKTsKKworICAgIC8vIHN1cnJvZ2F0ZSB0cmFpbCArIHN1cnJvZ2F0ZSBsZWFkCisg ICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjEwIikuYXBwZW5kKCJcdWRjMDBcdWQ4MDAi KTsKKworICAgIC8vIHN1cnJvZ2F0ZSBsZWFkICsgc2luZ2xlICsgc3Vycm9nYXRlIHRyYWlsCisg ICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjExIikuYXBwZW5kKCJcdWQ4MDByXHVkYzAw Iik7CisKKyAgICAvLyBzdXJyb2dhdGUgdHJhaWwgKyBzaW5nbGUgKyBzdXJyb2dhdGUgbGVhZAor ICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYxMiIpLmFwcGVuZCgiXHVkYzAwclx1ZDgw MCIpOworCisgICAgLy8gc3Vycm9nYXRlIHRyYWlsICsgc3Vycm9nYXRlIGxlYWQgKyBzdXJyb2dh dGUgdHJhaWwgCisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjEzIikuYXBwZW5kKCJc dWRjMDBcdWQ4MDBcdWRjMDAiKTsKKworICAgIC8vIHN1cnJvZ2F0ZSBsZWFkICsgc3Vycm9nYXRl IHRyYWlsICsgc3Vycm9nYXRlIGxlYWQKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2 MTQiKS5hcHBlbmQoIlx1ZDgwMFx1ZGMwMFx1ZDgwMCIpOworICAgCisgICAgaWYgKHdpbmRvdy50 ZXN0UnVubmVyKQorICAgICAgICB0ZXN0UnVubmVyLmR1bXBBc1RleHQoKTsKKyAgfTsKKzwvc2Ny aXB0PgorPGRpdiBpZD0iZGl2MSI+PC9kaXY+Cis8ZGl2IGlkPSJkaXYyIj48L2Rpdj4KKzxkaXYg aWQ9ImRpdjMiPjwvZGl2PgorPGRpdiBpZD0iZGl2NCI+PC9kaXY+Cis8ZGl2IGlkPSJkaXY1Ij48 L2Rpdj4KKzxkaXYgaWQ9ImRpdjYiPjwvZGl2PgorPGRpdiBpZD0iZGl2NyI+PC9kaXY+Cis8ZGl2 IGlkPSJkaXY4Ij48L2Rpdj4KKzxkaXYgaWQ9ImRpdjkiPjwvZGl2PgorPGRpdiBpZD0iZGl2MTAi PjwvZGl2PgorPGRpdiBpZD0iZGl2MTEiPjwvZGl2PgorPGRpdiBpZD0iZGl2MTIiPjwvZGl2Pgor PGRpdiBpZD0iZGl2MTMiPjwvZGl2PgorPGRpdiBpZD0iZGl2MTQiPjwvZGl2PgorUEFTUwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0L3dvcmQtYnJlYWstbGV0dGVyLXNwYWNpbmct dXRmMTYtc3Vycm9nYXRlcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQvd29y ZC1icmVhay1sZXR0ZXItc3BhY2luZy11dGYxNi1zdXJyb2dhdGVzLWV4cGVjdGVkLnR4dApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi42NTMxMmJjOTczNmU1OTBjNDZhMjUyMjFlNjJkMWNkYzE0YzhiNmE4Ci0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0L3dvcmQtYnJlYWstbGV0dGVyLXNwYWNp bmctdXRmMTYtc3Vycm9nYXRlcy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxNSBAQAor77+9Civv v70KK++/vXIKK++/vXIKK3Lvv70KK++/vQor8JCAgAorcu+/vXIKK3Lvv71yCivvv73vv70KK++/ vXLvv70KK++/vXLvv70KK++/vfCQgIAKK/CQgIDvv70KK1BBU1MKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvdGV4dC93b3JkLWJyZWFrLWxldHRlci1zcGFjaW5nLXV0ZjE2LXN1cnJvZ2F0 ZXMuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC93b3JkLWJyZWFrLWxldHRlci1zcGFjaW5n LXV0ZjE2LXN1cnJvZ2F0ZXMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5kMWNhYTBiNDVjMzdiNzZjYWQwYTgw MDAyZmU3YTYwNWVkMDE0N2UyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90 ZXh0L3dvcmQtYnJlYWstbGV0dGVyLXNwYWNpbmctdXRmMTYtc3Vycm9nYXRlcy5odG1sCkBAIC0w LDAgKzEsNjkgQEAKKzxzdHlsZT4KKyAgZGl2IHsKKyAgICB3b3JkLWJyZWFrOiBicmVhay13b3Jk OworICAgIGxldHRlci1zcGFjaW5nOiAxMDAwcHg7CisgIH0KKzwvc3R5bGU+Cis8c2NyaXB0Pgor ICBvbmxvYWQgPSAoKSA9PiB7CisgICAgLy8gb25seSBzdXJyb2dhdGUgbGVhZAorICAgIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJkaXYxIikuYXBwZW5kKCJcdWQ4MDAiKTsKKworICAgIC8vIG9u bHkgc3Vycm9nYXRlIHRyYWlsCisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5h cHBlbmQoIlx1ZGMwMCIpOworCisgICAgLy8gc3Vycm9nYXRlIGxlYWQgKyBzaW5nbGUKKyAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MyIpLmFwcGVuZCgiXHVkODAwciIpOworCisgICAg Ly8gc3Vycm9nYXRlIHRyYWlsICsgc2luZ2xlCisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo ImRpdjQiKS5hcHBlbmQoIlx1ZGMwMHIiKTsKKworICAgIC8vIHNpbmdsZSArIHN1cnJvZ2F0ZSBs ZWFkCisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjUiKS5hcHBlbmQoInJcdWQ4MDAi KTsKKworICAgIC8vIHNpbmdsZSArIHN1cnJvZ2F0ZSB0cmFpbAorICAgIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJkaXY2IikuYXBwZW5kKCJcdWRjMDAiKTsKKworICAgIC8vIHN1cnJvZ2F0ZSBs ZWFkICsgc3Vycm9nYXRlIHRyYWlsCisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjci KS5hcHBlbmQoIlx1ZDgwMFx1ZGMwMCIpOworCisgICAgLy8gc2luZ2xlICsgc3Vycm9nYXRlIGxl YWQgKyBzaW5nbGUKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2OCIpLmFwcGVuZCgi clx1ZDgwMHIiKTsKKworICAgIC8vIHNpbmdsZSArIHN1cnJvZ2F0ZSB0cmFpbCArIHNpbmdsZQor ICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXY5IikuYXBwZW5kKCJyXHVkYzAwciIpOwor CisgICAgLy8gc3Vycm9nYXRlIHRyYWlsICsgc3Vycm9nYXRlIGxlYWQKKyAgICBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgiZGl2MTAiKS5hcHBlbmQoIlx1ZGMwMFx1ZDgwMCIpOworCisgICAgLy8g c3Vycm9nYXRlIGxlYWQgKyBzaW5nbGUgKyBzdXJyb2dhdGUgdHJhaWwKKyAgICBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgiZGl2MTEiKS5hcHBlbmQoIlx1ZDgwMHJcdWRjMDAiKTsKKworICAgIC8v IHN1cnJvZ2F0ZSB0cmFpbCArIHNpbmdsZSArIHN1cnJvZ2F0ZSBsZWFkCisgICAgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoImRpdjEyIikuYXBwZW5kKCJcdWRjMDByXHVkODAwIik7CisKKyAgICAv LyBzdXJyb2dhdGUgdHJhaWwgKyBzdXJyb2dhdGUgbGVhZCArIHN1cnJvZ2F0ZSB0cmFpbCAKKyAg ICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MTMiKS5hcHBlbmQoIlx1ZGMwMFx1ZDgwMFx1 ZGMwMCIpOworCisgICAgLy8gc3Vycm9nYXRlIGxlYWQgKyBzdXJyb2dhdGUgdHJhaWwgKyBzdXJy b2dhdGUgbGVhZAorICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYxNCIpLmFwcGVuZCgi XHVkODAwXHVkYzAwXHVkODAwIik7CisKKyAgICBpZiAod2luZG93LnRlc3RSdW5uZXIpCisgICAg ICAgIHRlc3RSdW5uZXIuZHVtcEFzVGV4dCgpOworICB9OworPC9zY3JpcHQ+Cis8ZGl2IGlkPSJk aXYxIj48L2Rpdj4KKzxkaXYgaWQ9ImRpdjIiPjwvZGl2PgorPGRpdiBpZD0iZGl2MyI+PC9kaXY+ Cis8ZGl2IGlkPSJkaXY0Ij48L2Rpdj4KKzxkaXYgaWQ9ImRpdjUiPjwvZGl2PgorPGRpdiBpZD0i ZGl2NiI+PC9kaXY+Cis8ZGl2IGlkPSJkaXY3Ij48L2Rpdj4KKzxkaXYgaWQ9ImRpdjgiPjwvZGl2 PgorPGRpdiBpZD0iZGl2OSI+PC9kaXY+Cis8ZGl2IGlkPSJkaXYxMCI+PC9kaXY+Cis8ZGl2IGlk PSJkaXYxMSI+PC9kaXY+Cis8ZGl2IGlkPSJkaXYxMiI+PC9kaXY+Cis8ZGl2IGlkPSJkaXYxMyI+ PC9kaXY+Cis8ZGl2IGlkPSJkaXYxNCI+PC9kaXY+CitQQVNTCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L3RleHQvd29yZC1icmVhay1tYXgtd2lkdGgtdXRmMTYtc3Vycm9nYXRlcy1leHBl Y3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQvd29yZC1icmVhay1tYXgtd2lkdGgtdXRm MTYtc3Vycm9nYXRlcy1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNjUzMTJiYzk3MzZlNTkwYzQ2 YTI1MjIxZTYyZDFjZGMxNGM4YjZhOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zh c3QvdGV4dC93b3JkLWJyZWFrLW1heC13aWR0aC11dGYxNi1zdXJyb2dhdGVzLWV4cGVjdGVkLnR4 dApAQCAtMCwwICsxLDE1IEBACivvv70KK++/vQor77+9cgor77+9cgorcu+/vQor77+9CivwkICA City77+9cgorcu+/vXIKK++/ve+/vQor77+9cu+/vQor77+9cu+/vQor77+98JCAgAor8JCAgO+/ vQorUEFTUwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0L3dvcmQtYnJlYWstbWF4 LXdpZHRoLXV0ZjE2LXN1cnJvZ2F0ZXMuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC93b3Jk LWJyZWFrLW1heC13aWR0aC11dGYxNi1zdXJyb2dhdGVzLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNWM5YzE0 M2I2OGVkMTlhN2E3ZmI4YTdkODAyNDYwNjQ3YzY2MDE3YgotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2Zhc3QvdGV4dC93b3JkLWJyZWFrLW1heC13aWR0aC11dGYxNi1zdXJyb2dhdGVz Lmh0bWwKQEAgLTAsMCArMSw2OSBAQAorPHN0eWxlPgorICBkaXYgeworICAgIHdvcmQtYnJlYWs6 IGJyZWFrLXdvcmQ7CisgICAgbWF4LXdpZHRoOiAxcHg7CisgIH0KKzwvc3R5bGU+Cis8c2NyaXB0 PgorICBvbmxvYWQgPSAoKSA9PiB7CisgICAgLy8gb25seSBzdXJyb2dhdGUgbGVhZAorICAgIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYxIikuYXBwZW5kKCJcdWQ4MDAiKTsKKworICAgIC8v IG9ubHkgc3Vycm9nYXRlIHRyYWlsCisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIi KS5hcHBlbmQoIlx1ZGMwMCIpOworCisgICAgLy8gc3Vycm9nYXRlIGxlYWQgKyBzaW5nbGUKKyAg ICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MyIpLmFwcGVuZCgiXHVkODAwciIpOworCisg ICAgLy8gc3Vycm9nYXRlIHRyYWlsICsgc2luZ2xlCisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoImRpdjQiKS5hcHBlbmQoIlx1ZGMwMHIiKTsKKworICAgIC8vIHNpbmdsZSArIHN1cnJvZ2F0 ZSBsZWFkCisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjUiKS5hcHBlbmQoInJcdWQ4 MDAiKTsKKworICAgIC8vIHNpbmdsZSArIHN1cnJvZ2F0ZSB0cmFpbAorICAgIGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJkaXY2IikuYXBwZW5kKCJcdWRjMDAiKTsKKworICAgIC8vIHN1cnJvZ2F0 ZSBsZWFkICsgc3Vycm9nYXRlIHRyYWlsCisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRp djciKS5hcHBlbmQoIlx1ZDgwMFx1ZGMwMCIpOworCisgICAgLy8gc2luZ2xlICsgc3Vycm9nYXRl IGxlYWQgKyBzaW5nbGUKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2OCIpLmFwcGVu ZCgiclx1ZDgwMHIiKTsKKworICAgIC8vIHNpbmdsZSArIHN1cnJvZ2F0ZSB0cmFpbCArIHNpbmds ZQorICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXY5IikuYXBwZW5kKCJyXHVkYzAwciIp OworCisgICAgLy8gc3Vycm9nYXRlIHRyYWlsICsgc3Vycm9nYXRlIGxlYWQKKyAgICBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgiZGl2MTAiKS5hcHBlbmQoIlx1ZGMwMFx1ZDgwMCIpOworCisgICAg Ly8gc3Vycm9nYXRlIGxlYWQgKyBzaW5nbGUgKyBzdXJyb2dhdGUgdHJhaWwKKyAgICBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgiZGl2MTEiKS5hcHBlbmQoIlx1ZDgwMHJcdWRjMDAiKTsKKworICAg IC8vIHN1cnJvZ2F0ZSB0cmFpbCArIHNpbmdsZSArIHN1cnJvZ2F0ZSBsZWFkCisgICAgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoImRpdjEyIikuYXBwZW5kKCJcdWRjMDByXHVkODAwIik7CisKKyAg ICAvLyBzdXJyb2dhdGUgdHJhaWwgKyBzdXJyb2dhdGUgbGVhZCArIHN1cnJvZ2F0ZSB0cmFpbCAK KyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MTMiKS5hcHBlbmQoIlx1ZGMwMFx1ZDgw MFx1ZGMwMCIpOworCisgICAgLy8gc3Vycm9nYXRlIGxlYWQgKyBzdXJyb2dhdGUgdHJhaWwgKyBz dXJyb2dhdGUgbGVhZAorICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYxNCIpLmFwcGVu ZCgiXHVkODAwXHVkYzAwXHVkODAwIik7CisKKyAgICBpZiAod2luZG93LnRlc3RSdW5uZXIpCisg ICAgICAgIHRlc3RSdW5uZXIuZHVtcEFzVGV4dCgpOworICB9OworPC9zY3JpcHQ+Cis8ZGl2IGlk PSJkaXYxIj48L2Rpdj4KKzxkaXYgaWQ9ImRpdjIiPjwvZGl2PgorPGRpdiBpZD0iZGl2MyI+PC9k aXY+Cis8ZGl2IGlkPSJkaXY0Ij48L2Rpdj4KKzxkaXYgaWQ9ImRpdjUiPjwvZGl2PgorPGRpdiBp ZD0iZGl2NiI+PC9kaXY+Cis8ZGl2IGlkPSJkaXY3Ij48L2Rpdj4KKzxkaXYgaWQ9ImRpdjgiPjwv ZGl2PgorPGRpdiBpZD0iZGl2OSI+PC9kaXY+Cis8ZGl2IGlkPSJkaXYxMCI+PC9kaXY+Cis8ZGl2 IGlkPSJkaXYxMSI+PC9kaXY+Cis8ZGl2IGlkPSJkaXYxMiI+PC9kaXY+Cis8ZGl2IGlkPSJkaXYx MyI+PC9kaXY+Cis8ZGl2IGlkPSJkaXYxNCI+PC9kaXY+CitQQVNTCg== 441150 2021-10-13 15:46:03 -0700 2021-10-13 16:17:14 -0700 Patch bug-231606-20211013154602.patch text/plain 3959 gnavamarino U3VidmVyc2lvbiBSZXZpc2lvbjogMjg0MTE5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTM5ZjNjNzUxNzg2Mjlm NTRhMzg3ZmFjMmU0NzQ4YzM3MTM5YWE2My4uOTU3NjQ1YTM1YTIyZWZhYTM3MjYxMDg1MTkyOTA2 NDhiMWRjZjFjMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDIxLTEwLTEzICBHYWJy aWVsIE5hdmEgTWFyaW5vICA8Z25hdmFtYXJpbm9AYXBwbGUuY29tPgorCisgICAgICAgIEFTU0VS VCBoaXQgaW4gc3Vycm9nYXRlUGFpckF3YXJlSW5kZXggYW5kIHN1cnJvZ2F0ZVBhaXJBd2FyZVN0 YXJ0IGxhbWJkYXMgZm9yIHRleHQgd2l0aCB1bnBhaXJlZCBzdXJyb2dhdGVzLgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjMxNjA2IAorCisgICAgICAg IFJldmlld2VkIGJ5IERhcmluIEFkbGVyIGFuZCBNeWxlcyBDLiBNYXhmaWVsZC4KKworICAgICAg ICAqIGxheW91dC9mb3JtYXR0aW5nQ29udGV4dHMvaW5saW5lL3RleHQvVGV4dFV0aWwuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6TGF5b3V0OjpUZXh0VXRpbDo6bWlkV29yZEJyZWFrKToKKyAgICAg ICAgQWNjb3VudCBmb3IgdW5wYWlyZWQgc3Vycm9nYXRlcyBpbiBUZXh0VXRpbDo6TWlkV29yZEJy ZWFrIFRleHRVdGlsOjptaWRXb3JkQnJlYWsKKwogMjAyMS0xMC0xMyAgVGltIE5ndXllbiAgPG50 aW1AYXBwbGUuY29tPgogCiAgICAgICAgIEltcGxlbWVudCA8ZGlhbG9nPiBmb2N1c2luZyBzdGVw cwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbGF5b3V0L2Zvcm1hdHRpbmdDb250ZXh0cy9p bmxpbmUvdGV4dC9UZXh0VXRpbC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9sYXlvdXQvZm9ybWF0dGlu Z0NvbnRleHRzL2lubGluZS90ZXh0L1RleHRVdGlsLmNwcAppbmRleCBhMTQxMDE0YTQ0MjA5NGU2 NGM0YWQ5NDMxNTk3MzZiZDU4ZWE2MGM1Li44NWE2ZWRlNjI2ZTI4MzJlMDM0YTM0ZmM3YTlkODkx ZDI3M2U4ZmZkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sYXlvdXQvZm9ybWF0dGluZ0Nv bnRleHRzL2lubGluZS90ZXh0L1RleHRVdGlsLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9sYXlv dXQvZm9ybWF0dGluZ0NvbnRleHRzL2lubGluZS90ZXh0L1RleHRVdGlsLmNwcApAQCAtMTQ2LDEx ICsxNDYsOSBAQCBUZXh0VXRpbDo6TWlkV29yZEJyZWFrIFRleHRVdGlsOjptaWRXb3JkQnJlYWso Y29uc3QgSW5saW5lVGV4dEl0ZW0mIGlubGluZVRleHRJdAogICAgIGF1dG8gdGV4dCA9IGlubGlu ZVRleHRJdGVtLmlubGluZVRleHRCb3goKS5jb250ZW50KCk7CiAgICAgYXV0byBzdXJyb2dhdGVQ YWlyQXdhcmVJbmRleCA9IFsmXSAoYXV0byBpbmRleCkgewogICAgICAgICAvLyBXZSBzaG91bGQg bmV2ZXIgYnJlYWsgaW4gdGhlIG1pZGRsZSBvZiBhIHN1cnJvZ2F0ZSBwYWlyLiBUaGV5IGFyZSBj b25zaWRlcmVkIG9uZSBqb2ludCBlbnRpdHkuCi0gICAgICAgIFJFTEVBU0VfQVNTRVJUKGluZGV4 IDwgdGV4dC5sZW5ndGgoKSk7Ci0gICAgICAgIGJvb2wgaXNMZWFkID0gVTE2X0lTX0xFQUQodGV4 dFtpbmRleF0pICYmIChpbmRleCArIDEpIDwgdGV4dC5sZW5ndGgoKSAmJiBVMTZfSVNfVFJBSUwo dGV4dFtpbmRleCArIDFdKTsKLSAgICAgICAgaWYgKCFpc0xlYWQpCi0gICAgICAgICAgICByZXR1 cm4gaW5kZXg7Ci0gICAgICAgIHJldHVybiArK2luZGV4OworICAgICAgICBVMTZfU0VUX0NQX0xJ TUlUKHRleHQsIDAsIGluZGV4LCB0ZXh0Lmxlbmd0aCgpKTsKKyAgICAgICAgUkVMRUFTRV9BU1NF UlQoaW5kZXggLSAxIDwgdGV4dC5sZW5ndGgoKSk7CisgICAgICAgIHJldHVybiBpbmRleCAtIDE7 CiAgICAgfTsKIAogICAgIGF1dG8gbGVmdCA9IHN0YXJ0UG9zaXRpb247CkBAIC0xNTgsMjUgKzE1 NiwxOSBAQCBUZXh0VXRpbDo6TWlkV29yZEJyZWFrIFRleHRVdGlsOjptaWRXb3JkQnJlYWsoY29u c3QgSW5saW5lVGV4dEl0ZW0mIGlubGluZVRleHRJdAogICAgIC8vIEFkanVzdCB0aGUgcmFuZ2Ug c28gdGhhdCB3ZSBjYW4gcGljayBhIHJlYXNvbmFibGUgbWlkcG9pbnQuCiAgICAgYXV0byBhdmVy YWdlQ2hhcmFjdGVyV2lkdGggPSBJbmxpbmVMYXlvdXRVbml0IHsgdGV4dFdpZHRoIC8gbGVuZ3Ro IH07CiAgICAgdW5zaWduZWQgb2Zmc2V0ID0gdG9MYXlvdXRVbml0KDIgKiBhdmFpbGFibGVXaWR0 aCAvIGF2ZXJhZ2VDaGFyYWN0ZXJXaWR0aCkudG9VbnNpZ25lZCgpOwotICAgIGF1dG8gcmlnaHQg PSBzdXJyb2dhdGVQYWlyQXdhcmVJbmRleChzdGQ6Om1pbjx1bnNpZ25lZD4obGVmdCArIG9mZnNl dCwgKHN0YXJ0UG9zaXRpb24gKyBsZW5ndGggLSAxKSkpOworICAgIGF1dG8gcmlnaHQgPSBzdXJy b2dhdGVQYWlyQXdhcmVJbmRleChzdGQ6Om1pbjx1bnNpZ25lZD4obGVmdCArIG9mZnNldCArIDEs IChzdGFydFBvc2l0aW9uICsgbGVuZ3RoKSkpOwogICAgIC8vIFByZXNlcnZlIHRoZSBsZWZ0IHdp ZHRoIGZvciB0aGUgZmluYWwgc3BsaXQgcG9zaXRpb24gc28gdGhhdCB3ZSBkb24ndCBuZWVkIHRv IHJlbWVhc3VyZSB0aGUgbGVmdCBzaWRlIGFnYWluLgogICAgIGF1dG8gbGVmdFNpZGVXaWR0aCA9 IElubGluZUxheW91dFVuaXQgeyAwIH07CiAgICAgd2hpbGUgKGxlZnQgPCByaWdodCkgewotICAg ICAgICBhdXRvIG1pZGRsZSA9IHN1cnJvZ2F0ZVBhaXJBd2FyZUluZGV4KChsZWZ0ICsgcmlnaHQp IC8gMik7CisgICAgICAgIGF1dG8gbWlkZGxlID0gc3Vycm9nYXRlUGFpckF3YXJlSW5kZXgoKGxl ZnQgKyByaWdodCkgLyAyICsgMSk7CiAgICAgICAgIGF1dG8gd2lkdGggPSBUZXh0VXRpbDo6d2lk dGgoaW5saW5lVGV4dEl0ZW0sIGZvbnRDYXNjYWRlLCBzdGFydFBvc2l0aW9uLCBtaWRkbGUgKyAx LCBjb250ZW50TG9naWNhbExlZnQpOwogICAgICAgICBpZiAod2lkdGggPCBhdmFpbGFibGVXaWR0 aCkgewogICAgICAgICAgICAgbGVmdCA9IG1pZGRsZSArIDE7CiAgICAgICAgICAgICBsZWZ0U2lk ZVdpZHRoID0gd2lkdGg7CiAgICAgICAgIH0gZWxzZSBpZiAod2lkdGggPiBhdmFpbGFibGVXaWR0 aCkgewotICAgICAgICAgICAgYXV0byBzdXJyb2dhdGVQYWlyQXdhcmVTdGFydCA9IFsmXSAoYXV0 byBpbmRleCkgewotICAgICAgICAgICAgICAgIGJvb2wgaXNUcmFpbCA9IGluZGV4ICYmIFUxNl9J U19MRUFEKHRleHRbaW5kZXggLSAxXSkgJiYgaW5kZXggPCB0ZXh0Lmxlbmd0aCgpICYmIFUxNl9J U19UUkFJTCh0ZXh0W2luZGV4XSk7Ci0gICAgICAgICAgICAgICAgaWYgKCFpc1RyYWlsKQotICAg ICAgICAgICAgICAgICAgICByZXR1cm4gaW5kZXg7Ci0gICAgICAgICAgICAgICAgUkVMRUFTRV9B U1NFUlQoaW5kZXgpOwotICAgICAgICAgICAgICAgIHJldHVybiAtLWluZGV4OwotICAgICAgICAg ICAgfTsKLSAgICAgICAgICAgIC8vIFdoZW4gdGhlIHN1YnN0cmluZyBkb2VzIG5vdCBmaXQsIHRo ZSByaWdodCBzaWRlIGlzIHN1cHBvc2VkIHRvIGJlIHRoZSBzdGFydCBvZiB0aGUgc3Vycm9nYXRl IHBhaXIgaWYgYXBwbGljYWJsZS4gCi0gICAgICAgICAgICByaWdodCA9IHN1cnJvZ2F0ZVBhaXJB d2FyZVN0YXJ0KG1pZGRsZSk7CisgICAgICAgICAgICAvLyBXaGVuIHRoZSBzdWJzdHJpbmcgZG9l cyBub3QgZml0LCB0aGUgcmlnaHQgc2lkZSBpcyBzdXBwb3NlZCB0byBiZSB0aGUgc3RhcnQgb2Yg dGhlIHN1cnJvZ2F0ZSBwYWlyIGlmIGFwcGxpY2FibGUuCisgICAgICAgICAgICByaWdodCA9IG1p ZGRsZTsKKyAgICAgICAgICAgIFUxNl9TRVRfQ1BfU1RBUlQodGV4dCwgMCwgcmlnaHQpOwogICAg ICAgICB9IGVsc2UgewogICAgICAgICAgICAgcmlnaHQgPSBtaWRkbGUgKyAxOwogICAgICAgICAg ICAgbGVmdFNpZGVXaWR0aCA9IHdpZHRoOwo= 441156 2021-10-13 16:17:18 -0700 2021-10-13 16:43:17 -0700 Patch bug-231606-20211013161718.patch text/plain 3053 gnavamarino U3VidmVyc2lvbiBSZXZpc2lvbjogMjg0MTE5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTM5ZjNjNzUxNzg2Mjlm NTRhMzg3ZmFjMmU0NzQ4YzM3MTM5YWE2My4uNTdiMjY4ZTMzNThkZjBhMzZmNGQyNzNiYzU4NGY1 ZjExMzQwZmViYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDIxLTEwLTEzICBHYWJy aWVsIE5hdmEgTWFyaW5vICA8Z25hdmFtYXJpbm9AYXBwbGUuY29tPgorCisgICAgICAgIEFTU0VS VCBoaXQgaW4gc3Vycm9nYXRlUGFpckF3YXJlSW5kZXggYW5kIHN1cnJvZ2F0ZVBhaXJBd2FyZVN0 YXJ0IGxhbWJkYXMgZm9yIHRleHQgd2l0aCB1bnBhaXJlZCBzdXJyb2dhdGVzLgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjMxNjA2CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIgYW5kIE15bGVzIEMuIE1heGZpZWxkLgorCisgICAgICAg ICogbGF5b3V0L2Zvcm1hdHRpbmdDb250ZXh0cy9pbmxpbmUvdGV4dC9UZXh0VXRpbC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpMYXlvdXQ6OlRleHRVdGlsOjptaWRXb3JkQnJlYWspOgorICAgICAg ICBBY2NvdW50IGZvciB1bnBhaXJlZCBzdXJyb2dhdGVzIGluIFRleHRVdGlsOjpNaWRXb3JkQnJl YWsgVGV4dFV0aWw6Om1pZFdvcmRCcmVhaworCiAyMDIxLTEwLTEzICBUaW0gTmd1eWVuICA8bnRp bUBhcHBsZS5jb20+CiAKICAgICAgICAgSW1wbGVtZW50IDxkaWFsb2c+IGZvY3VzaW5nIHN0ZXBz CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9sYXlvdXQvZm9ybWF0dGluZ0NvbnRleHRzL2lu bGluZS90ZXh0L1RleHRVdGlsLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2xheW91dC9mb3JtYXR0aW5n Q29udGV4dHMvaW5saW5lL3RleHQvVGV4dFV0aWwuY3BwCmluZGV4IGExNDEwMTRhNDQyMDk0ZTY0 YzRhZDk0MzE1OTczNmJkNThlYTYwYzUuLjFlMTBkNjI0Zjc4Yjg5NDY4OGQzNmFlOTVkNjZlNWI2 YTU2ZjhmMmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xheW91dC9mb3JtYXR0aW5nQ29u dGV4dHMvaW5saW5lL3RleHQvVGV4dFV0aWwuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2xheW91 dC9mb3JtYXR0aW5nQ29udGV4dHMvaW5saW5lL3RleHQvVGV4dFV0aWwuY3BwCkBAIC0xNDYsMTEg KzE0NiwxMCBAQCBUZXh0VXRpbDo6TWlkV29yZEJyZWFrIFRleHRVdGlsOjptaWRXb3JkQnJlYWso Y29uc3QgSW5saW5lVGV4dEl0ZW0mIGlubGluZVRleHRJdAogICAgIGF1dG8gdGV4dCA9IGlubGlu ZVRleHRJdGVtLmlubGluZVRleHRCb3goKS5jb250ZW50KCk7CiAgICAgYXV0byBzdXJyb2dhdGVQ YWlyQXdhcmVJbmRleCA9IFsmXSAoYXV0byBpbmRleCkgewogICAgICAgICAvLyBXZSBzaG91bGQg bmV2ZXIgYnJlYWsgaW4gdGhlIG1pZGRsZSBvZiBhIHN1cnJvZ2F0ZSBwYWlyLiBUaGV5IGFyZSBj b25zaWRlcmVkIG9uZSBqb2ludCBlbnRpdHkuCi0gICAgICAgIFJFTEVBU0VfQVNTRVJUKGluZGV4 IDwgdGV4dC5sZW5ndGgoKSk7Ci0gICAgICAgIGJvb2wgaXNMZWFkID0gVTE2X0lTX0xFQUQodGV4 dFtpbmRleF0pICYmIChpbmRleCArIDEpIDwgdGV4dC5sZW5ndGgoKSAmJiBVMTZfSVNfVFJBSUwo dGV4dFtpbmRleCArIDFdKTsKLSAgICAgICAgaWYgKCFpc0xlYWQpCi0gICAgICAgICAgICByZXR1 cm4gaW5kZXg7Ci0gICAgICAgIHJldHVybiArK2luZGV4OworICAgICAgICBhdXRvIG9mZnNldCA9 IGluZGV4ICsgMTsKKyAgICAgICAgVTE2X1NFVF9DUF9MSU1JVCh0ZXh0LCAwLCBvZmZzZXQsIHRl eHQubGVuZ3RoKCkpOworICAgICAgICBSRUxFQVNFX0FTU0VSVChvZmZzZXQgLSAxIDwgdGV4dC5s ZW5ndGgoKSk7CisgICAgICAgIHJldHVybiBvZmZzZXQgLSAxOwogICAgIH07CiAKICAgICBhdXRv IGxlZnQgPSBzdGFydFBvc2l0aW9uOwpAQCAtMTY4LDE1ICsxNjcsOSBAQCBUZXh0VXRpbDo6TWlk V29yZEJyZWFrIFRleHRVdGlsOjptaWRXb3JkQnJlYWsoY29uc3QgSW5saW5lVGV4dEl0ZW0mIGlu bGluZVRleHRJdAogICAgICAgICAgICAgbGVmdCA9IG1pZGRsZSArIDE7CiAgICAgICAgICAgICBs ZWZ0U2lkZVdpZHRoID0gd2lkdGg7CiAgICAgICAgIH0gZWxzZSBpZiAod2lkdGggPiBhdmFpbGFi bGVXaWR0aCkgewotICAgICAgICAgICAgYXV0byBzdXJyb2dhdGVQYWlyQXdhcmVTdGFydCA9IFsm XSAoYXV0byBpbmRleCkgewotICAgICAgICAgICAgICAgIGJvb2wgaXNUcmFpbCA9IGluZGV4ICYm IFUxNl9JU19MRUFEKHRleHRbaW5kZXggLSAxXSkgJiYgaW5kZXggPCB0ZXh0Lmxlbmd0aCgpICYm IFUxNl9JU19UUkFJTCh0ZXh0W2luZGV4XSk7Ci0gICAgICAgICAgICAgICAgaWYgKCFpc1RyYWls KQotICAgICAgICAgICAgICAgICAgICByZXR1cm4gaW5kZXg7Ci0gICAgICAgICAgICAgICAgUkVM RUFTRV9BU1NFUlQoaW5kZXgpOwotICAgICAgICAgICAgICAgIHJldHVybiAtLWluZGV4OwotICAg ICAgICAgICAgfTsKLSAgICAgICAgICAgIC8vIFdoZW4gdGhlIHN1YnN0cmluZyBkb2VzIG5vdCBm aXQsIHRoZSByaWdodCBzaWRlIGlzIHN1cHBvc2VkIHRvIGJlIHRoZSBzdGFydCBvZiB0aGUgc3Vy cm9nYXRlIHBhaXIgaWYgYXBwbGljYWJsZS4gCi0gICAgICAgICAgICByaWdodCA9IHN1cnJvZ2F0 ZVBhaXJBd2FyZVN0YXJ0KG1pZGRsZSk7CisgICAgICAgICAgICAvLyBXaGVuIHRoZSBzdWJzdHJp bmcgZG9lcyBub3QgZml0LCB0aGUgcmlnaHQgc2lkZSBpcyBzdXBwb3NlZCB0byBiZSB0aGUgc3Rh cnQgb2YgdGhlIHN1cnJvZ2F0ZSBwYWlyIGlmIGFwcGxpY2FibGUuCisgICAgICAgICAgICByaWdo dCA9IG1pZGRsZTsKKyAgICAgICAgICAgIFUxNl9TRVRfQ1BfU1RBUlQodGV4dCwgMCwgcmlnaHQp OwogICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgcmlnaHQgPSBtaWRkbGUgKyAxOwogICAg ICAgICAgICAgbGVmdFNpZGVXaWR0aCA9IHdpZHRoOwo= 441158 2021-10-13 16:43:21 -0700 2021-10-13 17:57:23 -0700 Patch bug-231606-20211013164320.patch text/plain 2999 gnavamarino U3VidmVyc2lvbiBSZXZpc2lvbjogMjg0MTE5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTM5ZjNjNzUxNzg2Mjlm NTRhMzg3ZmFjMmU0NzQ4YzM3MTM5YWE2My4uNTdiMjY4ZTMzNThkZjBhMzZmNGQyNzNiYzU4NGY1 ZjExMzQwZmViYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDIxLTEwLTEzICBHYWJy aWVsIE5hdmEgTWFyaW5vICA8Z25hdmFtYXJpbm9AYXBwbGUuY29tPgorCisgICAgICAgIEFTU0VS VCBoaXQgaW4gc3Vycm9nYXRlUGFpckF3YXJlSW5kZXggYW5kIHN1cnJvZ2F0ZVBhaXJBd2FyZVN0 YXJ0IGxhbWJkYXMgZm9yIHRleHQgd2l0aCB1bnBhaXJlZCBzdXJyb2dhdGVzLgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjMxNjA2CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIgYW5kIE15bGVzIEMuIE1heGZpZWxkLgorCisgICAgICAg ICogbGF5b3V0L2Zvcm1hdHRpbmdDb250ZXh0cy9pbmxpbmUvdGV4dC9UZXh0VXRpbC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpMYXlvdXQ6OlRleHRVdGlsOjptaWRXb3JkQnJlYWspOgorICAgICAg ICBBY2NvdW50IGZvciB1bnBhaXJlZCBzdXJyb2dhdGVzIGluIFRleHRVdGlsOjpNaWRXb3JkQnJl YWsgVGV4dFV0aWw6Om1pZFdvcmRCcmVhaworCiAyMDIxLTEwLTEzICBUaW0gTmd1eWVuICA8bnRp bUBhcHBsZS5jb20+CiAKICAgICAgICAgSW1wbGVtZW50IDxkaWFsb2c+IGZvY3VzaW5nIHN0ZXBz CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9sYXlvdXQvZm9ybWF0dGluZ0NvbnRleHRzL2lu bGluZS90ZXh0L1RleHRVdGlsLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2xheW91dC9mb3JtYXR0aW5n Q29udGV4dHMvaW5saW5lL3RleHQvVGV4dFV0aWwuY3BwCmluZGV4IGExNDEwMTRhNDQyMDk0ZTY0 YzRhZDk0MzE1OTczNmJkNThlYTYwYzUuLmIxMzZlYzkwYjBkZjFjZDFhNTBiMmI1MjNlZTgzYmVm NTlhNjA0YjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xheW91dC9mb3JtYXR0aW5nQ29u dGV4dHMvaW5saW5lL3RleHQvVGV4dFV0aWwuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2xheW91 dC9mb3JtYXR0aW5nQ29udGV4dHMvaW5saW5lL3RleHQvVGV4dFV0aWwuY3BwCkBAIC0xNDYsMTEg KzE0Niw5IEBAIFRleHRVdGlsOjpNaWRXb3JkQnJlYWsgVGV4dFV0aWw6Om1pZFdvcmRCcmVhayhj b25zdCBJbmxpbmVUZXh0SXRlbSYgaW5saW5lVGV4dEl0CiAgICAgYXV0byB0ZXh0ID0gaW5saW5l VGV4dEl0ZW0uaW5saW5lVGV4dEJveCgpLmNvbnRlbnQoKTsKICAgICBhdXRvIHN1cnJvZ2F0ZVBh aXJBd2FyZUluZGV4ID0gWyZdIChhdXRvIGluZGV4KSB7CiAgICAgICAgIC8vIFdlIHNob3VsZCBu ZXZlciBicmVhayBpbiB0aGUgbWlkZGxlIG9mIGEgc3Vycm9nYXRlIHBhaXIuIFRoZXkgYXJlIGNv bnNpZGVyZWQgb25lIGpvaW50IGVudGl0eS4KLSAgICAgICAgUkVMRUFTRV9BU1NFUlQoaW5kZXgg PCB0ZXh0Lmxlbmd0aCgpKTsKLSAgICAgICAgYm9vbCBpc0xlYWQgPSBVMTZfSVNfTEVBRCh0ZXh0 W2luZGV4XSkgJiYgKGluZGV4ICsgMSkgPCB0ZXh0Lmxlbmd0aCgpICYmIFUxNl9JU19UUkFJTCh0 ZXh0W2luZGV4ICsgMV0pOwotICAgICAgICBpZiAoIWlzTGVhZCkKLSAgICAgICAgICAgIHJldHVy biBpbmRleDsKLSAgICAgICAgcmV0dXJuICsraW5kZXg7CisgICAgICAgIGF1dG8gb2Zmc2V0ID0g aW5kZXggKyAxOworICAgICAgICBVMTZfU0VUX0NQX0xJTUlUKHRleHQsIDAsIG9mZnNldCwgdGV4 dC5sZW5ndGgoKSk7CisgICAgICAgIHJldHVybiBvZmZzZXQgLSAxOwogICAgIH07CiAKICAgICBh dXRvIGxlZnQgPSBzdGFydFBvc2l0aW9uOwpAQCAtMTY4LDE1ICsxNjYsOSBAQCBUZXh0VXRpbDo6 TWlkV29yZEJyZWFrIFRleHRVdGlsOjptaWRXb3JkQnJlYWsoY29uc3QgSW5saW5lVGV4dEl0ZW0m IGlubGluZVRleHRJdAogICAgICAgICAgICAgbGVmdCA9IG1pZGRsZSArIDE7CiAgICAgICAgICAg ICBsZWZ0U2lkZVdpZHRoID0gd2lkdGg7CiAgICAgICAgIH0gZWxzZSBpZiAod2lkdGggPiBhdmFp bGFibGVXaWR0aCkgewotICAgICAgICAgICAgYXV0byBzdXJyb2dhdGVQYWlyQXdhcmVTdGFydCA9 IFsmXSAoYXV0byBpbmRleCkgewotICAgICAgICAgICAgICAgIGJvb2wgaXNUcmFpbCA9IGluZGV4 ICYmIFUxNl9JU19MRUFEKHRleHRbaW5kZXggLSAxXSkgJiYgaW5kZXggPCB0ZXh0Lmxlbmd0aCgp ICYmIFUxNl9JU19UUkFJTCh0ZXh0W2luZGV4XSk7Ci0gICAgICAgICAgICAgICAgaWYgKCFpc1Ry YWlsKQotICAgICAgICAgICAgICAgICAgICByZXR1cm4gaW5kZXg7Ci0gICAgICAgICAgICAgICAg UkVMRUFTRV9BU1NFUlQoaW5kZXgpOwotICAgICAgICAgICAgICAgIHJldHVybiAtLWluZGV4Owot ICAgICAgICAgICAgfTsKLSAgICAgICAgICAgIC8vIFdoZW4gdGhlIHN1YnN0cmluZyBkb2VzIG5v dCBmaXQsIHRoZSByaWdodCBzaWRlIGlzIHN1cHBvc2VkIHRvIGJlIHRoZSBzdGFydCBvZiB0aGUg c3Vycm9nYXRlIHBhaXIgaWYgYXBwbGljYWJsZS4gCi0gICAgICAgICAgICByaWdodCA9IHN1cnJv Z2F0ZVBhaXJBd2FyZVN0YXJ0KG1pZGRsZSk7CisgICAgICAgICAgICAvLyBXaGVuIHRoZSBzdWJz dHJpbmcgZG9lcyBub3QgZml0LCB0aGUgcmlnaHQgc2lkZSBpcyBzdXBwb3NlZCB0byBiZSB0aGUg c3RhcnQgb2YgdGhlIHN1cnJvZ2F0ZSBwYWlyIGlmIGFwcGxpY2FibGUuCisgICAgICAgICAgICBy aWdodCA9IG1pZGRsZTsKKyAgICAgICAgICAgIFUxNl9TRVRfQ1BfU1RBUlQodGV4dCwgMCwgcmln aHQpOwogICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgcmlnaHQgPSBtaWRkbGUgKyAxOwog ICAgICAgICAgICAgbGVmdFNpZGVXaWR0aCA9IHdpZHRoOwo=