21322 2008-10-02 17:09:58 -0700 DumpRenderTree pixel test improvements 2009-03-02 11:51:55 -0800 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) Mac OS X 10.5 RESOLVED FIXED P2 Normal --- 21912 21913 21914 21915 21916 21821 21910 21911 22062 1 simon.fraser webkit-unassigned aroben mitz oldest_to_newest 93832 0 simon.fraser 2008-10-02 17:09:58 -0700 There are a number of improvements that we would like to make in DRT, related to the pixel tests: 1. Clean up the view snapshot code 2. Avoid dumping the PNG image when running pixel tests if we can detect that the checksum is equal to the expected checksum (for performance) 3. Improve the code that sets/restores the screen color profile 4. Make the code more cross-platformy with std::string goodness 93833 1 24037 simon.fraser 2008-10-02 17:12:49 -0700 Created attachment 24037 Patch With this patch, clean pixel tests on fast/css when from 18.77 to 7.59s, so it's a big perf win. 93837 2 simon.fraser 2008-10-02 17:21:19 -0700 This patch includes the change in bug 21323. 93843 3 pol 2008-10-02 19:17:14 -0700 A few other minor things in the patch: - rendering is always in premultiplied RGBA8 to avoid endian issues and guarantee consistent hash values - ensure font smoothing is disabled (this is also called LCD anti-aliasing and is different from regular font CG anti-aliasing) as font-smoothing settings depends on the display and can also be changed by the user - use a new cleared buffer for each test instead of the reusing same one to avoid potential result corruption across tests - DRT can now receives the expected pixel hash as a suffix to the test path or url as "path|hash" 93845 4 mitz 2008-10-02 20:18:43 -0700 This patch includes several significant changes and I will not have time to review it tonight, but I was wondering about this: +// We also need to ensure font smoothing (i.e. LCD Antialiasing) has been disabled, but +// NSGraphicsContext seems to be overriding CGContextSetShouldSmoothFonts()... +// +// Since there's no public API to force disable font smoothing, we work around it by using a +// 'bitmapInfo' incompatible with font smoothing i.e. not matching pixels on screen as +// (kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host). In setDefaultsToConsistentValuesForTesting() in DumpRenderTree.mm, we call [defaults setInteger:MediumFontSmoothing forKey:@"AppleFontSmoothing"]; I believe that setting it to 0 instead of MediumFontSmoothing (2) is a far better way to accomplish this, especially since since there is code in WebCore that looks directly at that user default. For Windows, there should be a similar way to do it, which is how Safari's appearance preferences work. 93903 5 pol 2008-10-03 09:56:58 -0700 We were indeed wondering if there was a NS default for font smoothing. But actually, it doesn't really matter: It seems simpler to generate the same pixels on PPC or X86, so that the MD5 hashes match. That's why it now renders to RGBA8 independently of the endianness. A side effect of this is that because CG font smoothing is only supported for (kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host), you can't have a common pixel format and font smoothing. On a side note, RGBA8 is also matching the PNG 32bits pixel format, except for alpha being premultiplied in CG and not in PNG. 93905 6 mitz 2008-10-03 10:41:49 -0700 (In reply to comment #5) > It seems simpler to generate the same pixels on PPC or X86, so that the MD5 > hashes match. That's why it now renders to RGBA8 independently of the > endianness. A side effect of this is that because CG font smoothing is only > supported for (kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host), you > can't have a common pixel format and font smoothing. I see. Still, I would remove the discussion of font smoothing from the comment and change the font smoothing setting in setDefaultsToConsistentValuesForTesting(). It also looks like you removed the code path that reads pixels back from the window backing store, and instead you always have the view paint itself directly into your bitmap context. Does that not break the invalidation tests that use layoutTestController.display() (many of the tests in fast/repaint)? 93923 7 pol 2008-10-03 11:54:57 -0700 (In reply to comment #6) > It also looks like you removed the > code path that reads pixels back from the window backing store, and instead you > always have the view paint itself directly into your bitmap context. Does that > not break the invalidation tests that use layoutTestController.display() (many > of the tests in fast/repaint)? Indeed, this created a problem in this code path: I'll revert this part of the patch. I guess there's nothing to change regarding the "AppleFontSmoothing" default since rendering happens to the window backbuffer no matter what and font smoothing will work there. The advantage is that base images don't need to be regenerated. However, there's still an issue with the --repaint option for the DRT tool: the previous code path that was rendering directly to the CGContext hasn't changed. So either 1) you have font smoothing and different hashes for PPC / X86, 2) no font smoothing, but consistent hashes or 3) change this code path to also go through the window backbuffer. Is this option used? If yes, in which tests? 93924 8 mitz 2008-10-03 12:00:10 -0700 (In reply to comment #7) > Is this option used? If yes, in which tests? It is available through a run-webkit-tests command-line option for any test and programatically through layoutTestController, with a few fast/repaint tests using it. I think it is fine to make changes that will require all pixel results to be regenerated, so if font smoothing contributes to inter-configuration variance, we should still consider turning it off. 93967 9 pol 2008-10-03 13:37:39 -0700 On side note, on X86 w/ 10.5.4 + WK TOT, it seems all pixel tests in fast/repaint do fail (I don't specify a threshold). I looked at a few failures and minor differences in font rendering seem to be the reason. 93986 10 mitz 2008-10-03 14:39:33 -0700 (In reply to comment #9) > On side note, on X86 w/ 10.5.4 + WK TOT, it seems all pixel tests in > fast/repaint do fail (I don't specify a threshold). I looked at a few failures > and minor differences in font rendering seem to be the reason. Yes, this is the state for most tests currently. 93990 11 pol 2008-10-03 14:46:34 -0700 (In reply to comment #10) > Yes, this is the state for most tests currently. Is this a temporary thing because of a regression somewhere, or all base images need to be re-generated no matter what? 93993 12 pol 2008-10-03 15:00:49 -0700 I found an interesting issue: this method of reading back the pixels from the backing store basically strips any alpha as the returned NSBitmapImageRep is in RGB8. 93997 13 mitz 2008-10-03 15:13:28 -0700 (In reply to comment #12) > I found an interesting issue: this method of reading back the pixels from the > backing store basically strips any alpha as the returned NSBitmapImageRep is in > RGB8. I wonder if that is true for transparent windows as well. WebKit supports transparent WebViews and you can use them in windows (Safari's Debug menu has an option to use a transparent window). Anyway, we currently don't test drawing in transparent WebViews, so I don't think this is an issue. 94001 14 pol 2008-10-03 15:20:15 -0700 (In reply to comment #13) > I wonder if that is true for transparent windows as well. Actually, it is not, if you set your NSWindow properly for transparency, reading back from the backing with produce an RGBA8 bitmap. So I'm trying to get this to work in DRT as well. Even if alpha is not tested today, it probably doesn't hurt to be able to. 94004 15 mitz 2008-10-03 15:34:29 -0700 (In reply to comment #14) > Actually, it is not, if you set your NSWindow properly for transparency, > reading back from the backing with produce an RGBA8 bitmap. So I'm trying to > get this to work in DRT as well. Even if alpha is not tested today, it probably > doesn't hurt to be able to. Sounds like a good option to have, but I am not sure it is a good idea to use a transparent window by default. 94007 16 pol 2008-10-03 16:15:59 -0700 (In reply to comment #15) > Sounds like a good option to have, but I am not sure it is a good idea to use a > transparent window by default. More investigation shows that the only way to have the backing of the window to be considered to have alpha information is 1) to have it visible on screen and 2) have -setOpaque:NO and -setBackgroundColor:[NSColor clearColor] on the window 3) have the webview properly draw with transparency. So in a nutshell, it's a complex fix for an unclear reward. 94012 17 mitz 2008-10-03 16:54:37 -0700 (In reply to comment #11) > (In reply to comment #10) > > Yes, this is the state for most tests currently. > > Is this a temporary thing because of a regression somewhere, or all base images > need to be re-generated no matter what? > Most base images were generated on Tiger and do not match results on Leopard. I think those will need to be re-generated on Leopard, but perhaps some Leopard-based results will need to be regenerated as well as a result of this patch. 94488 18 24166 pol 2008-10-07 19:11:58 -0700 Created attachment 24166 Revised patch 94490 19 pol 2008-10-07 19:13:28 -0700 (In reply to comment #18) > Created an attachment (id=24166) [edit] > Revised patch Please make the previous patch obsolete (for some reason, I could not). Note that with this new patch, font smoothing is always off, so pretty much all pixel tests fail as the bases need to be updated. 94576 20 simon.fraser 2008-10-08 11:00:36 -0700 The patch needs testing on Windows. 94579 21 24166 mitz 2008-10-08 11:16:08 -0700 Comment on attachment 24166 Revised patch Thanks for working on making pixel tests better! A general comment: Propagating knowledge of the test's URL or path even deeper into DumpRenderTree is not a good thing in my opinion. I think it would actually be good to move in the opposite direction: since you are adding the ability to pass metadata (the expected hash) along with the test path/URL, you should consider passing custom WebView dimensions in a similar fashion and making it the responsibility of run-webkit-tests to decide the dimensions based on the path (maybe in an even nicer way than hard-coding "svg/W3C-SVG-1.1"). I am not sure it makes sense to add the expected hash as a LayoutTestController member. We mostly use DumpRenderTree globals for things like that. 34 #include <ctype.h> 35 #include <algorithm> Those should be in ASCII order along with the rest of the #includes, so just before #include <wtf/Assertions.h>. 91 snprintf(hashString, 33, "%s%02x", hashString, hash[i]); That is not pretty! (But you did not write it.) 38 typedef struct CGContext* CGContextRef; 39 40 41 class BitmapContext : public RefCounted<BitmapContext> Extra newline there. 78 , m_context(AdoptCF, context) That makes for a very unusual calling convention where BitmapContext::create() takes ownership of the passed-in CGContext. I would rather avoid it. 92 PassRefPtr<BitmapContext> getBitmapContextFromWebView(bool incrementalRepaint, bool sweepHorizontally, bool drawSelectionRect); This is an unfortunate name for a function with "create" semantics. Again, not your fault. 195 if (URLString.compare(URLString.length() - curIgnore.length(), curIgnore.length(), curIgnore) == 0) WebKit coding style is to avoid comparison with 0, NULL and nil, so the above should be written as 195 if (!URLString.compare(URLString.length() - curIgnore.length(), curIgnore.length(), curIgnore)) 353 #if PLATFORM(MAC) 354 restoreMainDisplayColorProfile(0); 355 #endif This is a Mac-only file, so you don't need the #if. 530 #if PLATFORM(MAC) 528531 if (dumpPixels) 529 restoreColorSpace(0); 532 restoreMainDisplayColorProfile(0); 533 #endif Ditto. 967 // Look for '|' as a separator between the path or URL, and the pixel dump hash that follows. 968 // FIXME: this is a valid URL characters. Use a different separator? Typo: "characters". I think this is a problem. While | is a valid URL character and almost any character is valid in a path in some platform, but the single quote (') is not valid in the scheme part of a URL, so a format like 'expectedhash'path/or/URL will be unambiguous for the URL case, and only problematic for paths that begin with a '. 978 NSString* pathOrURLString = [NSString stringWithUTF8String:pathOrURL.c_str()]; WebKit coding style is for Objective-C objects to put the space before the *, so "NSString *pathOrURLString = ...". 984 NSURL* url; Ditto. 990 fprintf(stderr, "Failed to parse \"%s\" as an url\n", pathOrURL.c_str()); Typo: "an url" instead of "a URL". 84 NSURL* url = [NSURL fileURLWithPath:[NSString stringWithUTF8String:PROFILE_PATH]]; Again, the * should be next to "url". 88 if(error == noErr) Missing space after "if". I think you can write this as if (!error). 130 size_t rowBytes = (4 * pixelsWide + 63) & ~63; // Use a multiple of 64 bytes to improve CG performances Typo? "performances". 146 NSGraphicsContext* nsContext = [NSGraphicsContext graphicsContextWithGraphicsPort:context flipped:NO]; "*" misplaced, through no fault of your own. 157 } 158 else { This should be all on one line as "} else {" 172 NSView* documentView = [[mainFrame frameView] documentView]; Another * placement issue. 644 } elsif (/BaselineHash: ([a-f0-9]{32})/) { 659 } elsif (/ExpectedHash: ([a-f0-9]{32})/) { Is this change correct? What is it fixing? Is that code even used? r- for now, as I think you should address at least some of the comments. 94587 22 pol 2008-10-08 11:55:11 -0700 (In reply to comment #21) > A general comment: > Propagating knowledge of the test's URL or path even deeper into DumpRenderTree > is not a good thing in my opinion. I think it would actually be good to move in > the opposite direction: since you are adding the ability to pass metadata (the > expected hash) along with the test path/URL, you should consider passing custom > WebView dimensions in a similar fashion and making it the responsibility of > run-webkit-tests to decide the dimensions based on the path (maybe in an even > nicer way than hard-coding "svg/W3C-SVG-1.1"). I actually haven't touched this part of the DRT logic, it behaves the same as before. The difference is that the path to the test is now stored in the layout controller along with optional hash instead of being in a global. The issue you raise make sense but I'd rather have it addressed in a separate bug: the patch is already pretty big as is :) > I am not sure it makes sense to add the expected hash as a LayoutTestController > member. We mostly use DumpRenderTree globals for things like that. gLayoutTestController is created / destroyed for each test, which I like as this way you know you don't have "stalled" parameters or data. > 34 #include <ctype.h> > 35 #include <algorithm> > > Those should be in ASCII order along with the rest of the #includes, so just > before #include <wtf/Assertions.h>. Fixed > 91 snprintf(hashString, 33, "%s%02x", hashString, hash[i]); > > That is not pretty! (But you did not write it.) Yeah, I noticed too ;) > 38 typedef struct CGContext* CGContextRef; > 39 > 40 > 41 class BitmapContext : public RefCounted<BitmapContext> > > Extra newline there. Fixed > 78 , m_context(AdoptCF, context) > > That makes for a very unusual calling convention where BitmapContext::create() > takes ownership of the passed-in CGContext. I would rather avoid it. I'd rather not put the CGContext creation code in BitmapContext as it is closely coupled to getBitmapContextFromWebView(): having all this setup code in a single place makes it easier to maintain it (especially when you have to properly deal with colorspace, endianness, pixel format and whatnot). > 92 PassRefPtr<BitmapContext> getBitmapContextFromWebView(bool > incrementalRepaint, bool sweepHorizontally, bool drawSelectionRect); > > This is an unfortunate name for a function with "create" semantics. Again, not > your fault. Agreed, fixed > 195 if (URLString.compare(URLString.length() - curIgnore.length(), > curIgnore.length(), curIgnore) == 0) > > WebKit coding style is to avoid comparison with 0, NULL and nil, so the above > should be written as > > 195 if (!URLString.compare(URLString.length() - curIgnore.length(), > curIgnore.length(), curIgnore)) I hadn't touched this part but fixed anyway > 353 #if PLATFORM(MAC) > 354 restoreMainDisplayColorProfile(0); > 355 #endif > > This is a Mac-only file, so you don't need the #if. Fixed > 967 // Look for '|' as a separator between the path or URL, and the pixel > dump hash that follows. > 968 // FIXME: this is a valid URL characters. Use a different separator? > > Typo: "characters". I think this is a problem. While | is a valid URL character > and almost any character is valid in a path in some platform, but the single > quote (') is not valid in the scheme part of a URL, so a format like > 'expectedhash'path/or/URL > will be unambiguous for the URL case, and only problematic for paths that begin > with a '. OK, changed > 978 NSString* pathOrURLString = [NSString > stringWithUTF8String:pathOrURL.c_str()]; > > WebKit coding style is for Objective-C objects to put the space before the *, > so "NSString *pathOrURLString = ...". > > 984 NSURL* url; Fixed > 990 fprintf(stderr, "Failed to parse \"%s\" as an url\n", > pathOrURL.c_str()); > > Typo: "an url" instead of "a URL". Fixed > 84 NSURL* url = [NSURL fileURLWithPath:[NSString > stringWithUTF8String:PROFILE_PATH]]; > > Again, the * should be next to "url". Fixed > 88 if(error == noErr) > > Missing space after "if". I think you can write this as if (!error). Fixed > 130 size_t rowBytes = (4 * pixelsWide + 63) & ~63; // Use a multiple of 64 > bytes to improve CG performances > > Typo? "performances". Fixed > 146 NSGraphicsContext* nsContext = [NSGraphicsContext > graphicsContextWithGraphicsPort:context flipped:NO]; > > "*" misplaced, through no fault of your own. Fixed > 157 } > 158 else { > > This should be all on one line as "} else {" Fixed > 172 NSView* documentView = [[mainFrame frameView] documentView]; > > Another * placement issue. Fixed > 644 } elsif (/BaselineHash: ([a-f0-9]{32})/) { > 659 } elsif (/ExpectedHash: ([a-f0-9]{32})/) { > > Is this change correct? What is it fixing? Is that code even used? Yes, this is a required change: the script expects DRT to outputs the expected MD5 (even if the same script passes it to DRT in the first place), so I fixed DRT and for consistency also fixed the script to use "expected" as everywhere else in the pixel test system. 94589 23 24196 pol 2008-10-08 12:15:42 -0700 Created attachment 24196 Re-revised patch 94590 24 pol 2008-10-08 12:19:00 -0700 (In reply to comment #23) > Created an attachment (id=24196) [edit] > Re-revised patch Note that as explained earlier, a number of pixel now fail because of font smoothing always being disabled. Although, many were already failing anyway because of small differences in font rendering. So basically all bases need to be regenerated, but I'd rather not do it as part of this patch as we have at least one other change to get in: https://bugs.webkit.org/show_bug.cgi?id=21458 94672 25 pol 2008-10-08 19:10:08 -0700 Another improvement we would need: https://bugs.webkit.org/show_bug.cgi?id=21495 After that, I think we're done :) 96290 26 24588 pol 2008-10-22 21:06:24 -0700 Created attachment 24588 Complete patch v1 Primary changes in DumpRenderTree: - Ensure font smoothing is disabled (this is also called LCD anti-aliasing and is different from regular font CG anti-aliasing) as font-smoothing settings depends on the display and can also be changed by the user - Use a new cleared buffer for each test instead of the reusing same one to avoid potential result corruption across tests - Can now receive the expected pixel hash as a suffix to the test path or url as "path'hash" - Make sure hash is computed in a endian-independent way - Improve the code that sets/restores the screen color profile - Make the code more cross-platformy with std::string goodness - Added an "on-screen" mode where the snapshot will take into account surfaces on the window (like OpenGL content): this uses the new CG APIs on 10.5 or reading from the display framebuffer on 10.4. This mode is not active by default for performance reason, but must be explicitly activated from the test file using the new "testOnscreen()" JS API. Primary changes in ImageDiff: - Provide a new comparison algorithm that is more tolerant to "acceptable" failures (i.e. very small differences in font rendering, which --threshold is not really good at handling) - Generate normalized intensity-only diff images Primary changes in run-webkit-tests: - Take advantage of hashes for pixel tests which makes them much faster by minimizing image comparisons - Removed repaint options as these should be set from within test files using JS API - Replaced "threshold" option in by "tolerance" expressed in percents - Added more logging when in "verbose" mode Notes: - Tested on various PPC and X86 machines running 10.5.4 as well as PPC running 10.4.11 and X86 running SnowLeopard - Made sure WebKit still builds on Windows - This patch will require to redo all reference images in LayoutTests to really take advantage of the new features Finally, the current version of this patch does not include the ChangeLog, since there will likely be changes to be made anyway. 96365 27 24588 mitz 2008-10-23 11:50:04 -0700 Comment on attachment 24588 Complete patch v1 > #include <wtf/RefCounted.h> > +#include <string> Those are in the wrong order. > #if PLATFORM(WIN) > +#define strtof(x, y) strtod(x, y) > +#define roundf(x) ((x-floorf(x)) > 0.5 ? ceilf(x) : floorf(x)) > static const CFStringRef kUTTypePNG = CFSTR("public.png"); > #endif I'd like Adam to comment on that. > + RetainPtr<CGColorSpaceRef> colorSpace(AdoptCF, CGColorSpaceCreateDeviceRGB()); Can this be a static? > + void *baseBuffer = calloc(height, rowBytes); The * should go next to "void". > + void *buffer = calloc(height, rowBytes); Ditto. > + void *diffBuffer = malloc(width * height); Ditto. I think it might be better to hang on to these buffers and only reallocate them as size changes. > + unsigned char *basePixel = (unsigned char*)baseBuffer; > + unsigned char *pixel = (unsigned char*)buffer; > + unsigned char *diff = (unsigned char*)diffBuffer; More misplaced *s. > + if (distance > top) > + top = distance; Perhaps "maxDistance" is a better name than "top". > + // Compute the difference as a percentage combining both the number of different pixels and their difference amount > + if (count > 0.0f) > + difference = 100.0f * (count / ((float)width * (float)height)) * (sum / count); I am not sure the two "count" terms improve clarity. "100 * sum / (width * height)" is more understandable, and will do floating point division and multiplication because sum is a float. Given that the "count" terms cancel each other out, I think it is a little misleading to say that the formula is "combining both the number of different pixels and their difference amount". It is simply the average distance over the entire image. > + if (top < 1.0f) { > + diff = (unsigned char*)diffBuffer; > + for(size_t p = 0; p < height * width; ++p, ++diff) > + *diff = (float)*diff / top; > + } The body of the for statement should be indented. The cast to float is redundant because top is a float. I think not incrementing diff and using diff[p] instead would read better. > + CGImageAlphaInfo info = CGImageGetAlphaInfo(image); Extra spaces there. > + difference = roundf(difference * 100.0f) / 100.0f; > + difference = max(difference, 0.01f); // round to 2 decimal places Artificially changing the rounding rule near 0 is kind of dubious. If people specify a tolerance of less than .01, then they probably higher precision anyway. > + } > + else > + fprintf(stdout, "diff: %01.2f%% passed\n", difference); The else should go on the same line with the brace. > + // On PPC the bitmap context will be in ARGB8 instead of BGRA8 as on X86, so we need to swap the bytes to ensure consistent hashes It's better to get the bitmap format from the context than to decide at compile-time based on endianness. > + for (unsigned column = 0; column < pixelsWide; column++) { > + buffer[column] = OSReadLittleInt32(bitmapData, 4 * column); > + } A one-line body should not have braces. > + ASSERT(context.get()); The get() is redundant. > + // Look for "'" as a separator between the path or URL, and the pixel dump hash that follows. I thought you were going to make the hash come before the URL, to avoid the problem with URLs containing the separator character. > + fprintf(stderr, "Failed to parse \"%s\" as a url\n", pathOrURL.c_str()); "url" should be uppercase. > + void *flipBuffer = calloc(pixelsHigh, rowBytes); Misplaced "*". > + } > + else > + ASSERT_NOT_REACHED(); The else should go on the same line with the brace. But it would be better to make an explicit ASSERT([documentView conformsToProtocol:@protocol(WebDocumentSelection)]) before the if statement instead. 96371 28 24588 aroben 2008-10-23 12:32:34 -0700 Comment on attachment 24588 Complete patch v1 It's exciting to see someone new working on the pixel tests! This patch would be a lot easier to review if it were split up into a number of smaller changes (e.g., the move to use std::string in more places could have been its own patch). It's hard to review large patches, and when there's a straightforward way to break the work up into smaller pieces it's almost always better to do so. Normally in .cpp files we use using directives rather than continuing to use namespace scope operators. For example, in LayoutTestController.cpp, you could put "using namespace std;" just after all the #include directives, then all the places where you have "std::string" in that file could just become "string". (We don't use using directives in headers, however, so you'd still need the "std::" prefix there.) Even though this is a patch-in-progress that will probably be further revised, having a detailed ChangeLog is still important. It makes the reviewer's job much easier because it explains *why* each change was made, not just *how* (which is all the code tells you). I also find it helpful as a patch writer to write a detailed ChangeLog before sending my patch out for review because it forces me to think about the approach I took as a whole. Sometimes I end up changing parts of my patch because of things I realized while writing my own ChangeLog, even before sending the patch out for review. > +++ b/WebKitTools/DumpRenderTree/cg/ImageDiffCG.cpp > @@ -54,6 +54,8 @@ typedef float CGFloat; > using namespace std; > > #if PLATFORM(WIN) > +#define strtof(x, y) strtod(x, y) > +#define roundf(x) ((x-floorf(x)) > 0.5 ? ceilf(x) : floorf(x)) > static const CFStringRef kUTTypePNG = CFSTR("public.png"); > #endif You should use wtf/MathExtras.h to get a definition of roundf() for Windows. I think a static inline function would be better than a macro for strtof. > +static RetainPtr<CGImageRef> compareImages(CGImageRef baseImage, CGImageRef testImage, float& difference) I find the "compareImages" name a bit confusing. Maybe something like createDifferenceImage would be clearer? Or if the main purpose is to produce the difference value and the image is more of a side-effect, perhaps the image should be an out parameter and the difference value should be the return value. > +void dumpWebViewAsPixelsAndCompareWithExpected(const std::string& expectedHash) > { > - RetainPtr<CGContextRef> context = getBitmapContextFromWebView(); > - > + RefPtr<BitmapContext> context; > + > #if PLATFORM(MAC) > - if (gLayoutTestController->testRepaint()) > - repaintWebView(context.get(), gLayoutTestController->testRepaintSweepHorizontally()); > - else > - paintWebView(context.get()); > - > - if (gLayoutTestController->dumpSelectionRect()) > - drawSelectionRect(context.get(), getSelectionRect()); > + context = createBitmapContextFromWebView(gLayoutTestController->testOnscreen(), gLayoutTestController->testRepaint(), gLayoutTestController->testRepaintSweepHorizontally(), gLayoutTestController->dumpSelectionRect()); There's no need to pre-declare the context variable. You can just do: RefPtr<BitmapContext> context = createBitmapContextFromWebView(...); > +class BitmapContext : public RefCounted<BitmapContext> > +{ This brace should go on the previous line. > +#if PLATFORM(MAC) > + BitmapContext(void* pixelData, CGContextRef context) > + : m_pixelData(pixelData) > +#elif PLATFORM(WIN) > + BitmapContext(HBITMAP bitmap, CGContextRef context) > + : m_bitmap(bitmap) > +#endif > + , m_context(AdoptCF, context) > + { > + } > + > +#if PLATFORM(MAC) > + void* m_pixelData; > +#elif PLATFORM(WIN) > + HBITMAP m_bitmap; > +#endif > + RetainPtr<CGContextRef> m_context; > + > +}; It might be cleaner to make a typedef that is void* on Mac and HBITMAP on Windows. > +void setupMainDisplayColorProfile() > { > - fprintf(stderr, "Failed to get current color profile. I will not be able to restore your current profile, thus I'm not changing it. Many pixel tests may fail as a result. (Error: %i)\n", error); > -} > - > -static void setDefaultColorProfileToRGB() > -{ > - CMProfileRef genericProfile = (CMProfileRef)[[NSColorSpace genericRGBColorSpace] colorSyncProfile]; > - CMProfileLocation genericProfileLocation; > - UInt32 locationSize = sizeof(genericProfileLocation); > - int error = NCMGetProfileLocation(genericProfile, &genericProfileLocation, &locationSize); > - if (error) { > - failedGettingCurrentProfile(error); > - return; > + const CMDeviceScope scope = { kCFPreferencesCurrentUser, kCFPreferencesCurrentHost }; > + int error; > + > + CMProfileRef profile = NULL; We use 0 instead of NULL in C++ and Obj-C++ code. > + CGContextRef context = CGBitmapContextCreate(buffer, pixelsWide, pixelsHigh, 8, rowBytes, colorSpace, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host); // Use ARGB8 on PPC or BGRA8 on X86 to improve CG performance > + if (!context) { > + free(buffer); > + return 0; > } > > - [NSGraphicsContext setCurrentContext:savedContext.get()]; > -} > + // The BitmapContext keeps the CGContextRef and the pixel buffer alive > + RefPtr<BitmapContext> bitmapContext = BitmapContext::create(buffer, context); I believe you're leaking the CGContext here. BitmapContext retains the context you pass in, so you need to call CGContextRelease to balance the CGBitmapContextCreate. > @@ -63,6 +61,8 @@ RetainPtr<CGContextRef> getBitmapContextFromWebView() > ASSERT(info.bmBitsPixel == 32); > > RetainPtr<CGColorSpaceRef> colorSpace(AdoptCF, CGColorSpaceCreateDeviceRGB()); > - return RetainPtr<CGContextRef>(AdoptCF, CGBitmapContextCreate(info.bmBits, info.bmWidth, info.bmHeight, 8, > - info.bmWidthBytes, colorSpace.get(), kCGBitmapByteOrder32Little | kCGImageAlphaPremultipliedFirst)); > + CGContextRef context = CGBitmapContextCreate(info.bmBits, info.bmWidth, info.bmHeight, 8, > + info.bmWidthBytes, colorSpace.get(), kCGBitmapByteOrder32Little | kCGImageAlphaPremultipliedFirst); > + > + return BitmapContext::create(bitmap, context); You're leaking context here, too. > @@ -658,42 +658,58 @@ for my $test (@tests) { > } > } > > - # If we got some PNG data, diff with expected > + if($verbose && $pixelTests && !$resetResults && $actualPNGSize) { You're missing a space after "if". We'll at least need to fix the leaks before we land this. Fixing the other suggestions Dan and I gave you would be good, too. 96377 29 aroben 2008-10-23 12:59:25 -0700 (In reply to comment #28) > > + CGContextRef context = CGBitmapContextCreate(buffer, pixelsWide, pixelsHigh, 8, rowBytes, colorSpace, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host); // Use ARGB8 on PPC or BGRA8 on X86 to improve CG performance > > + if (!context) { > > + free(buffer); > > + return 0; > > } > > > > - [NSGraphicsContext setCurrentContext:savedContext.get()]; > > -} > > + // The BitmapContext keeps the CGContextRef and the pixel buffer alive > > + RefPtr<BitmapContext> bitmapContext = BitmapContext::create(buffer, context); > > I believe you're leaking the CGContext here. BitmapContext retains the context > you pass in, so you need to call CGContextRelease to balance the > CGBitmapContextCreate. Dan has pointed out to me that BitmapContext's constructor adopts the CGContext. I think that is quite confusing (as he said in comment 21). I think it would be clearer to get rid of the adoption in the constructor and just add a release at the callsites. 96381 30 pol 2008-10-23 13:19:03 -0700 (In reply to comment #27) > (From update of attachment 24588 [edit]) > > #include <wtf/RefCounted.h> > > +#include <string> > > Those are in the wrong order. Fixed > > + RetainPtr<CGColorSpaceRef> colorSpace(AdoptCF, CGColorSpaceCreateDeviceRGB()); > > Can this be a static? Fixed > > + void *baseBuffer = calloc(height, rowBytes); > > + void *buffer = calloc(height, rowBytes); > > + void *diffBuffer = malloc(width * height); Fixed > I think it might be better to hang on to these buffers and only reallocate them > as size changes. I'd rather re-allocate zero'ed new buffers each time, to ensure you don't get any corruption due to previous results . If you hit the DiffTool, then you're already on the comparison slow path anyway (hash comparison failed), so it's not like it's gonna make a difference. > > + unsigned char *basePixel = (unsigned char*)baseBuffer; > > + unsigned char *pixel = (unsigned char*)buffer; > > + unsigned char *diff = (unsigned char*)diffBuffer; Fixed > > + if (distance > top) > > + top = distance; > > Perhaps "maxDistance" is a better name than "top". Fixed > > + // Compute the difference as a percentage combining both the number of different pixels and their difference amount > > + if (count > 0.0f) > > + difference = 100.0f * (count / ((float)width * (float)height)) * (sum / count); > > I am not sure the two "count" terms improve clarity. "100 * sum / (width * > height)" is more understandable, and will do floating point division and > multiplication because sum is a float. Given that the "count" terms cancel each > other out, I think it is a little misleading to say that the formula is > "combining both the number of different pixels and their difference amount". It > is simply the average distance over the entire image. Fixed > > + if (top < 1.0f) { > > + diff = (unsigned char*)diffBuffer; > > + for(size_t p = 0; p < height * width; ++p, ++diff) > > + *diff = (float)*diff / top; > > + } > > The body of the for statement should be indented. The cast to float is > redundant because top is a float. I think not incrementing diff and using > diff[p] instead would read better. Fixed > > + CGImageAlphaInfo info = CGImageGetAlphaInfo(image); > > Extra spaces there. Fixed > > + difference = roundf(difference * 100.0f) / 100.0f; > > + difference = max(difference, 0.01f); // round to 2 decimal places > > Artificially changing the rounding rule near 0 is kind of dubious. If people > specify a tolerance of less than .01, then they probably higher precision > anyway. That's what I had initially, but realized after that you actually don't want this: fundamentally, if the image differ, the tool should not return 0.0 no matter what. > > + } > > + else > > + fprintf(stdout, "diff: %01.2f%% passed\n", difference); > > The else should go on the same line with the brace. Fixed > > + // On PPC the bitmap context will be in ARGB8 instead of BGRA8 as on X86, so we need to swap the bytes to ensure consistent hashes > > It's better to get the bitmap format from the context than to decide at > compile-time based on endianness. Fixed > > + for (unsigned column = 0; column < pixelsWide; column++) { > > + buffer[column] = OSReadLittleInt32(bitmapData, 4 * column); > > + } > > A one-line body should not have braces. Fixed > > + ASSERT(context.get()); > > The get() is redundant. Fixed > > + // Look for "'" as a separator between the path or URL, and the pixel dump hash that follows. > > I thought you were going to make the hash come before the URL, to avoid the > problem with URLs containing the separator character. I got confused, I thought we just want to use a different separator. > > + fprintf(stderr, "Failed to parse \"%s\" as a url\n", pathOrURL.c_str()); > > "url" should be uppercase. Fixed > > + void *flipBuffer = calloc(pixelsHigh, rowBytes); > > Misplaced "*". Fixed > > + } > > + else > > + ASSERT_NOT_REACHED(); > > The else should go on the same line with the brace. But it would be better to > make an explicit ASSERT([documentView > conformsToProtocol:@protocol(WebDocumentSelection)]) before the if statement > instead. Fixed 96382 31 pol 2008-10-23 13:21:21 -0700 (In reply to comment #29) > > I believe you're leaking the CGContext here. BitmapContext retains the context > > you pass in, so you need to call CGContextRelease to balance the > > CGBitmapContextCreate. > > Dan has pointed out to me that BitmapContext's constructor adopts the > CGContext. I think that is quite confusing (as he said in comment 21). I think > it would be clearer to get rid of the adoption in the constructor and just add > a release at the callsites. You cannot do this because the CGBitmapContext does not retain its backing, which is also different on Mac vs Windows. That's why we had to create this wrapper class that owns the context and the backing. 96404 32 aroben 2008-10-23 13:39:15 -0700 (In reply to comment #31) > (In reply to comment #29) > > > I believe you're leaking the CGContext here. BitmapContext retains the context > > > you pass in, so you need to call CGContextRelease to balance the > > > CGBitmapContextCreate. > > > > Dan has pointed out to me that BitmapContext's constructor adopts the > > CGContext. I think that is quite confusing (as he said in comment 21). I think > > it would be clearer to get rid of the adoption in the constructor and just add > > a release at the callsites. > > You cannot do this because the CGBitmapContext does not retain its backing, > which is also different on Mac vs Windows. That's why we had to create this > wrapper class that owns the context and the backing. I don't think I understand why retaining is not possible when adopting is possible. All I'm suggesting is that the BitmapContext constructor retain the passed-in CGContext, where today it adopts it. 96406 33 pol 2008-10-23 13:44:38 -0700 (In reply to comment #28) > This patch would be a lot easier to review if it were split up into a number of > smaller changes (e.g., the move to use std::string in more places could have > been its own patch). It's hard to review large patches, and when there's a > straightforward way to break the work up into smaller pieces it's almost always > better to do so. That's how I had started, but unfortunately, everything became inter-dependent rapidly. > Normally in .cpp files we use using directives rather than continuing to use > namespace scope operators. For example, in LayoutTestController.cpp, you could > put "using namespace std;" just after all the #include directives, then all the > places where you have "std::string" in that file could just become "string". > (We don't use using directives in headers, however, so you'd still need the > "std::" prefix there.) Fixed > Even though this is a patch-in-progress that will probably be further revised, > having a detailed ChangeLog is still important. It makes the reviewer's job > much easier because it explains *why* each change was made, not just *how* > (which is all the code tells you). I have one this time :) > > +++ b/WebKitTools/DumpRenderTree/cg/ImageDiffCG.cpp > > @@ -54,6 +54,8 @@ typedef float CGFloat; > > using namespace std; > > > > #if PLATFORM(WIN) > > +#define strtof(x, y) strtod(x, y) > > +#define roundf(x) ((x-floorf(x)) > 0.5 ? ceilf(x) : floorf(x)) > > static const CFStringRef kUTTypePNG = CFSTR("public.png"); > > #endif > > You should use wtf/MathExtras.h to get a definition of roundf() for Windows. I > think a static inline function would be better than a macro for strtof. Fixed > > +static RetainPtr<CGImageRef> compareImages(CGImageRef baseImage, CGImageRef testImage, float& difference) > > I find the "compareImages" name a bit confusing. Maybe something like > createDifferenceImage would be clearer? Or if the main purpose is to produce > the difference value and the image is more of a side-effect, perhaps the image > should be an out parameter and the difference value should be the return value. There are both as important, so I just renamed the function > There's no need to pre-declare the context variable. You can just do: > > RefPtr<BitmapContext> context = createBitmapContextFromWebView(...); The exact code (which I assume wasn't visible in the diff) is: RefPtr<BitmapContext> context; #if PLATFORM(MAC) context = createBitmapContextFromWebView(gLayoutTestController->testOnscreen(), gLayoutTestController->testRepaint(), gLayoutTestController->testRepaintSweepHorizontally(), gLayoutTestController->dumpSelectionRect()); #endif ASSERT(context); > > +class BitmapContext : public RefCounted<BitmapContext> > > +{ > > This brace should go on the previous line. Fixed > It might be cleaner to make a typedef that is void* on Mac and HBITMAP on > Windows. Fixed > We use 0 instead of NULL in C++ and Obj-C++ code. Fixed > > - # If we got some PNG data, diff with expected > > + if($verbose && $pixelTests && !$resetResults && $actualPNGSize) { > > You're missing a space after "if". Fixed 96407 34 pol 2008-10-23 13:45:47 -0700 > > > Dan has pointed out to me that BitmapContext's constructor adopts the > > > CGContext. I think that is quite confusing (as he said in comment 21). I think > > > it would be clearer to get rid of the adoption in the constructor and just add > > > a release at the callsites. > > > > You cannot do this because the CGBitmapContext does not retain its backing, > > which is also different on Mac vs Windows. That's why we had to create this > > wrapper class that owns the context and the backing. > > I don't think I understand why retaining is not possible when adopting is > possible. > > All I'm suggesting is that the BitmapContext constructor retain the passed-in > CGContext, where today it adopts it. So you're ok with a constructor that adopts one argument but retains the other? 96419 35 aroben 2008-10-23 14:18:32 -0700 (In reply to comment #34) > > > > Dan has pointed out to me that BitmapContext's constructor adopts the > > > > CGContext. I think that is quite confusing (as he said in comment 21). I think > > > > it would be clearer to get rid of the adoption in the constructor and just add > > > > a release at the callsites. > > > > > > You cannot do this because the CGBitmapContext does not retain its backing, > > > which is also different on Mac vs Windows. That's why we had to create this > > > wrapper class that owns the context and the backing. > > > > I don't think I understand why retaining is not possible when adopting is > > possible. > > > > All I'm suggesting is that the BitmapContext constructor retain the passed-in > > CGContext, where today it adopts it. > > So you're ok with a constructor that adopts one argument but retains the other? Ah, I see what you mean now. OK, what if we changed BitmapContext::create to something like BitmapContext::createByAdoptingBitmapAndContext? 96437 36 pol 2008-10-23 16:01:47 -0700 > Ah, I see what you mean now. OK, what if we changed BitmapContext::create to > something like BitmapContext::createByAdoptingBitmapAndContext? Deal! 96475 37 24631 pol 2008-10-23 19:33:18 -0700 Created attachment 24631 Updated patch 96723 38 24631 mitz 2008-10-26 23:11:02 -0700 Comment on attachment 24631 Updated patch > + - Ensure font smoothing is disabled (this is also called LCD anti-aliasing and > + is different from regular font CG anti-aliasing) as font-smoothing settings > + depends on the display and can also be changed by the user The user setting was overridden by the old code by setting the user default value to MediumFontSmoothing, so I don't think that was part of the problem. > + - Use a new cleared buffer for each test instead of the reusing same one to > + avoid potential result corruption across tests Is there any evidence that such corruption occurred or that it could occur? It is OK to make this change, but it is not clear that it is solving a problem, not even a potential one. > + } > + } > + else > + fputs("error, test and reference image have different properties.\n", stderr); The else should go on the same line with the brace. > + static PassRefPtr<BitmapContext> createByAdoptingBitmapAndContext(BitmapContextBacking backing, CGContextRef context) I think "BitmapContextBacking" and "backing" are not ideal names. Variable names should almost always be nouns, and the noun meaning of "backing" (the gerund) does not make sense here. "Backing buffer" or "backing store" seem better for the variable names, while something "PlatformBitmapBuffer" might be better as the type name. These are minor comments so I am going to say r=me. 96748 39 pol 2008-10-27 11:50:31 -0700 (In reply to comment #38) > (From update of attachment 24631 [edit]) > > + - Ensure font smoothing is disabled (this is also called LCD anti-aliasing and > > + is different from regular font CG anti-aliasing) as font-smoothing settings > > + depends on the display and can also be changed by the user > > The user setting was overridden by the old code by setting the user default > value to MediumFontSmoothing, so I don't think that was part of the problem. Actually, it's better not to have any font smoothing at all, as it's only available in some circumstances and can change across OS releases. There were also some bases that were checked in with no font smoothing, while the majority has it. > > + - Use a new cleared buffer for each test instead of the reusing same one to > > + avoid potential result corruption across tests > > Is there any evidence that such corruption occurred or that it could occur? It > is OK to make this change, but it is not clear that it is solving a problem, > not even a potential one. No evidence, but if for whatever reason a test page doesn't full paint opaquely the context, it will blend with the previous result. > > + } > > + } > > + else > > + fputs("error, test and reference image have different properties.\n", stderr); > > The else should go on the same line with the brace. Fixed > > + static PassRefPtr<BitmapContext> createByAdoptingBitmapAndContext(BitmapContextBacking backing, CGContextRef context) > > I think "BitmapContextBacking" and "backing" are not ideal names. Variable > names should almost always be nouns, and the noun meaning of "backing" (the > gerund) does not make sense here. "Backing buffer" or "backing store" seem > better for the variable names, while something "PlatformBitmapBuffer" might be > better as the type name. Fixed 96750 40 24689 pol 2008-10-27 11:58:25 -0700 Created attachment 24689 Final patch 96816 41 24702 pol 2008-10-27 17:57:20 -0700 Created attachment 24702 Final patch (for real) 96820 42 24702 mitz 2008-10-27 18:04:04 -0700 Comment on attachment 24702 Final patch (for real) r=me 96880 43 simon.fraser 2008-10-28 10:27:36 -0700 M WebKitTools/DumpRenderTree/DumpRenderTree.xcodeproj/project.pbxproj M WebKitTools/DumpRenderTree/cg/PixelDumpSupportCG.cpp M WebKitTools/DumpRenderTree/cg/PixelDumpSupportCG.h M WebKitTools/DumpRenderTree/cg/ImageDiffCG.cpp M WebKitTools/DumpRenderTree/PixelDumpSupport.h M WebKitTools/DumpRenderTree/win/PixelDumpSupportWin.cpp M WebKitTools/DumpRenderTree/win/DumpRenderTree.cpp A WebKitTools/DumpRenderTree/ForwardingHeaders/wtf/PassRefPtr.h A WebKitTools/DumpRenderTree/ForwardingHeaders/wtf/RefPtr.h M WebKitTools/DumpRenderTree/mac/PixelDumpSupportMac.mm M WebKitTools/DumpRenderTree/mac/DumpRenderTree.mm M WebKitTools/DumpRenderTree/LayoutTestController.cpp M WebKitTools/DumpRenderTree/LayoutTestController.h M WebKitTools/ChangeLog M WebKitTools/Scripts/run-webkit-tests r37928 = bdbd3f773d48b595c1cd282f048638dbf65b677e (trunk) 24037 2008-10-02 17:12:49 -0700 2008-10-07 19:45:02 -0700 Patch 21322_patch.txt text/plain 39583 simon.fraser ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0ZvcndhcmRpbmdIZWFkZXJz L3d0Zi9QYXNzUmVmUHRyLmggYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5n SGVhZGVycy93dGYvUGFzc1JlZlB0ci5oDW5ldyBmaWxlIG1vZGUgMTAwNjQ0DWluZGV4IDAwMDAw MDAuLmFhZmQxYTINLS0tIC9kZXYvbnVsbA0rKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUGFzc1JlZlB0ci5oDUBAIC0wLDAgKzEgQEANKyNpbmNs dWRlIDxKYXZhU2NyaXB0Q29yZS9QYXNzUmVmUHRyLmg+DWRpZmYgLS1naXQgYS9XZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUmVmUHRyLmggYi9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUmVmUHRyLmgNbmV3IGZp bGUgbW9kZSAxMDA2NDQNaW5kZXggMDAwMDAwMC4uMGZmNjIxMw0tLS0gL2Rldi9udWxsDSsrKyBi L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0ZvcndhcmRpbmdIZWFkZXJzL3d0Zi9SZWZQdHIu aA1AQCAtMCwwICsxIEBADSsjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvUmVmUHRyLmg+DWRpZmYg LS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5j cHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAN aW5kZXggZjBhZThkMy4uMzZiYzNkOSAxMDA2NDQNLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwDSsrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcA1AQCAtMzQsNyArMzQsNyBAQA0gI2luY2x1 ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+DSAjaW5jbHVkZSA8d3RmL01hdGhFeHRyYXMuaD4NIA0tTGF5 b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRlc3RDb250cm9sbGVyKGJvb2wgdGVzdFJlcGFpbnRE ZWZhdWx0LCBib29sIHRlc3RSZXBhaW50U3dlZXBIb3Jpem9udGFsbHlEZWZhdWx0KQ0rTGF5b3V0 VGVzdENvbnRyb2xsZXI6OkxheW91dFRlc3RDb250cm9sbGVyKGNvbnN0IHN0ZDo6c3RyaW5nJiB0 ZXN0UGF0aE9yVVJMLCBjb25zdCBzdGQ6OnN0cmluZyYgZXhwZWN0ZWRQaXhlbEhhc2gsIGJvb2wg dGVzdFJlcGFpbnREZWZhdWx0LCBib29sIHRlc3RSZXBhaW50U3dlZXBIb3Jpem9udGFsbHlEZWZh dWx0KQ0gICAgIDogbV9kdW1wQXNUZXh0KGZhbHNlKQ0gICAgICwgbV9kdW1wQXNQREYoZmFsc2Up DSAgICAgLCBtX2R1bXBCYWNrRm9yd2FyZExpc3QoZmFsc2UpDUBAIC01OSw2ICs1OSw4IEBAIExh eW91dFRlc3RDb250cm9sbGVyOjpMYXlvdXRUZXN0Q29udHJvbGxlcihib29sIHRlc3RSZXBhaW50 RGVmYXVsdCwgYm9vbCB0ZXN0UmVwDSAgICAgLCBtX3dhaXRUb0R1bXAoZmFsc2UpDSAgICAgLCBt X3dpbmRvd0lzS2V5KHRydWUpDSAgICAgLCBtX2dsb2JhbEZsYWcoZmFsc2UpDSsgICAgLCBtX3Rl c3RQYXRoT3JVUkwodGVzdFBhdGhPclVSTCkNKyAgICAsIG1fZXhwZWN0ZWRQaXhlbEhhc2goZXhw ZWN0ZWRQaXhlbEhhc2gpDSB7DSB9DSANZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmggYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oDWluZGV4IDVlMzAzYzguLjYwYjcxNTggMTAwNjQ0DS0t LSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgNKysr IGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaA1AQCAt MzEsMTAgKzMxLDExIEBADSANICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9KU09iamVjdFJlZi5o Pg0gI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+DSsjaW5jbHVkZSA8c3RyaW5nPg0gDSBjbGFz cyBMYXlvdXRUZXN0Q29udHJvbGxlciA6IHB1YmxpYyBSZWZDb3VudGVkPExheW91dFRlc3RDb250 cm9sbGVyPiB7DSBwdWJsaWM6DS0gICAgTGF5b3V0VGVzdENvbnRyb2xsZXIoYm9vbCB0ZXN0UmVw YWludERlZmF1bHQsIGJvb2wgdGVzdFJlcGFpbnRTd2VlcEhvcml6b250YWxseURlZmF1bHQpOw0r ICAgIExheW91dFRlc3RDb250cm9sbGVyKGNvbnN0IHN0ZDo6c3RyaW5nJiB0ZXN0UGF0aE9yVVJM LCBjb25zdCBzdGQ6OnN0cmluZyYgZXhwZWN0ZWRQaXhlbEhhc2gsIGJvb2wgdGVzdFJlcGFpbnRE ZWZhdWx0LCBib29sIHRlc3RSZXBhaW50U3dlZXBIb3Jpem9udGFsbHlEZWZhdWx0KTsNICAgICB+ TGF5b3V0VGVzdENvbnRyb2xsZXIoKTsNIA0gICAgIHZvaWQgbWFrZVdpbmRvd09iamVjdChKU0Nv bnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgd2luZG93T2JqZWN0LCBKU1ZhbHVlUmVmKiBl eGNlcHRpb24pOw1AQCAtMTQzLDcgKzE0NCwxMSBAQCBwdWJsaWM6DSANICAgICBib29sIGdsb2Jh bEZsYWcoKSBjb25zdCB7IHJldHVybiBtX2dsb2JhbEZsYWc7IH0NICAgICB2b2lkIHNldEdsb2Jh bEZsYWcoYm9vbCBnbG9iYWxGbGFnKSB7IG1fZ2xvYmFsRmxhZyA9IGdsb2JhbEZsYWc7IH0NLQ0r ICAgIA0rICAgIGNvbnN0IHN0ZDo6c3RyaW5nJiB0ZXN0UGF0aE9yVVJMKCkgY29uc3QgeyByZXR1 cm4gbV90ZXN0UGF0aE9yVVJMOyB9DSsgICAgY29uc3Qgc3RkOjpzdHJpbmcmIGV4cGVjdGVkUGl4 ZWxIYXNoKCkgY29uc3QgeyByZXR1cm4gbV9leHBlY3RlZFBpeGVsSGFzaDsgfQ0rICAgIGJvb2wg ZXhwZWN0ZWRQaXhlbEhhc2hLbm93bigpIGNvbnN0IHsgcmV0dXJuICFtX2V4cGVjdGVkUGl4ZWxI YXNoLmVtcHR5KCkgO30NKyAgICANIHByaXZhdGU6DSAgICAgYm9vbCBtX2R1bXBBc1RleHQ7DSAg ICAgYm9vbCBtX2R1bXBBc1BERjsNQEAgLTE3MSw2ICsxNzYsOSBAQCBwcml2YXRlOg0gDSAgICAg Ym9vbCBtX2dsb2JhbEZsYWc7DSANKyAgICBzdGQ6OnN0cmluZyBtX3Rlc3RQYXRoT3JVUkw7DSsg ICAgc3RkOjpzdHJpbmcgbV9leHBlY3RlZFBpeGVsSGFzaDsgICAgLy8gZW1wdHkgc3RyaW5nIGlm IG5vIGhhc2gNKyAgICANICAgICBzdGF0aWMgSlNDbGFzc1JlZiBnZXRKU0NsYXNzKCk7DSAgICAg c3RhdGljIEpTU3RhdGljVmFsdWUqIHN0YXRpY1ZhbHVlcygpOw0gICAgIHN0YXRpYyBKU1N0YXRp Y0Z1bmN0aW9uKiBzdGF0aWNGdW5jdGlvbnMoKTsNZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL1BpeGVsRHVtcFN1cHBvcnQuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL1BpeGVsRHVtcFN1cHBvcnQuaA1pbmRleCAzMjE0ZDA0Li5kNGY4OTQ4IDEwMDY0NA0tLS0g YS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9QaXhlbER1bXBTdXBwb3J0LmgNKysrIGIvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvUGl4ZWxEdW1wU3VwcG9ydC5oDUBAIC0yOSwxMiArMjks MTggQEANICNpZm5kZWYgUGl4ZWxEdW1wU3VwcG9ydF9oDSAjZGVmaW5lIFBpeGVsRHVtcFN1cHBv cnRfaA0gDS12b2lkIGR1bXBXZWJWaWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4cGVjdGVkKGNv bnN0IGNoYXIqIGN1cnJlbnRUZXN0LCBib29sIGZvcmNlQWxsVGVzdHNUb0R1bXBQaXhlbHMpOw0r I2luY2x1ZGUgPHN0cmluZz4NKw0rdm9pZCBkdW1wV2ViVmlld0FzUGl4ZWxzQW5kQ29tcGFyZVdp dGhFeHBlY3RlZChjb25zdCBzdGQ6OnN0cmluZyYgZXhwZWN0ZWRIYXNoKTsNKw0rI2lmIFBMQVRG T1JNKE1BQykNIA0gLy8gQ2FuIGJlIHVzZWQgYXMgYSBzaWduYWwgaGFuZGxlcg0tdm9pZCByZXN0 b3JlQ29sb3JTcGFjZShpbnQgaWdub3JlZCk7DSt2b2lkIHJlc3RvcmVNYWluRGlzcGxheUNvbG9y UHJvZmlsZShpbnQgaWdub3JlZCk7DSsNKy8vIE1heSBjaGFuZ2UgeW91ciBjb2xvciBzcGFjZSwg cmVxdWlyaW5nIGEgY2FsbCB0byByZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUNK3ZvaWQg c2V0dXBNYWluRGlzcGxheUNvbG9yUHJvZmlsZSgpOw0gDS0vLyBNYXkgY2hhbmdlIHlvdXIgY29s b3Igc3BhY2UsIHJlcXVpcmluZyBhIGNhbGwgdG8gcmVzdG9yZUNvbG9yU3BhY2UNLXZvaWQgaW5p dGlhbGl6ZUNvbG9yU3BhY2VBbmRTY3JlZUJ1ZmZlckZvclBpeGVsVGVzdHMoKTsNKyNlbmRpZg0g DSAjZW5kaWYgLy8gUGl4ZWxEdW1wU3VwcG9ydF9oDWRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9jZy9QaXhlbER1bXBTdXBwb3J0Q0cuY3BwIGIvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1wU3VwcG9ydENHLmNwcA1pbmRleCA5MDZlMjc0Li5mZGVm NGQ5IDEwMDY0NA0tLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9jZy9QaXhlbER1bXBT dXBwb3J0Q0cuY3BwDSsrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVt cFN1cHBvcnRDRy5jcHANQEAgLTMxLDkgKzMxLDEzIEBADSAjaW5jbHVkZSAiRHVtcFJlbmRlclRy ZWUuaCINICNpbmNsdWRlICJQaXhlbER1bXBTdXBwb3J0Q0cuaCINIA0rI2luY2x1ZGUgPGN0eXBl Lmg+DSsjaW5jbHVkZSA8YWxnb3JpdGhtPg0rDSAjaW5jbHVkZSAiTGF5b3V0VGVzdENvbnRyb2xs ZXIuaCINICNpbmNsdWRlIDxJbWFnZUlPL0NHSW1hZ2VEZXN0aW5hdGlvbi5oPg0gI2luY2x1ZGUg PHd0Zi9Bc3NlcnRpb25zLmg+DSsjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPg0gI2luY2x1ZGUgPHd0 Zi9SZXRhaW5QdHIuaD4NICNpbmNsdWRlIDx3dGYvU3RyaW5nRXh0cmFzLmg+DSANQEAgLTUzLDc0 ICs1Nyw2OSBAQCBzdGF0aWMgdm9pZCBwcmludFBORyhDR0ltYWdlUmVmIGltYWdlKQ0gew0gICAg IFJldGFpblB0cjxDRk11dGFibGVEYXRhUmVmPiBpbWFnZURhdGEoQWRvcHRDRiwgQ0ZEYXRhQ3Jl YXRlTXV0YWJsZSgwLCAwKSk7DSAgICAgUmV0YWluUHRyPENHSW1hZ2VEZXN0aW5hdGlvblJlZj4g aW1hZ2VEZXN0KEFkb3B0Q0YsIENHSW1hZ2VEZXN0aW5hdGlvbkNyZWF0ZVdpdGhEYXRhKGltYWdl RGF0YS5nZXQoKSwga1VUVHlwZVBORywgMSwgMCkpOw0rDSAgICAgQ0dJbWFnZURlc3RpbmF0aW9u QWRkSW1hZ2UoaW1hZ2VEZXN0LmdldCgpLCBpbWFnZSwgMCk7DSAgICAgQ0dJbWFnZURlc3RpbmF0 aW9uRmluYWxpemUoaW1hZ2VEZXN0LmdldCgpKTsNKw0gICAgIHByaW50ZigiQ29udGVudC1MZW5n dGg6ICVsdVxuIiwgQ0ZEYXRhR2V0TGVuZ3RoKGltYWdlRGF0YS5nZXQoKSkpOw0gICAgIGZ3cml0 ZShDRkRhdGFHZXRCeXRlUHRyKGltYWdlRGF0YS5nZXQoKSksIDEsIENGRGF0YUdldExlbmd0aChp bWFnZURhdGEuZ2V0KCkpLCBzdGRvdXQpOw0gfQ0gDS1zdGF0aWMgdm9pZCBnZXRNRDVIYXNoU3Ry aW5nRm9yQml0bWFwKENHQ29udGV4dFJlZiBiaXRtYXAsIGNoYXIgc3RyaW5nWzMzXSkNK3N0YXRp YyB2b2lkIGNvbXB1dGVNRDVIYXNoU3RyaW5nRm9yQml0bWFwQ29udGV4dChDR0NvbnRleHRSZWYg Yml0bWFwQ29udGV4dCwgY2hhciBoYXNoU3RyaW5nWzMzXSkNIHsNLSAgICBNRDVfQ1RYIG1kNUNv bnRleHQ7DS0gICAgdW5zaWduZWQgY2hhciBoYXNoWzE2XTsNLQ0tICAgIHNpemVfdCBiaXRzUGVy UGl4ZWwgPSBDR0JpdG1hcENvbnRleHRHZXRCaXRzUGVyUGl4ZWwoYml0bWFwKTsNKyAgICBzaXpl X3QgYml0c1BlclBpeGVsID0gQ0dCaXRtYXBDb250ZXh0R2V0Qml0c1BlclBpeGVsKGJpdG1hcENv bnRleHQpOw0gICAgIEFTU0VSVChiaXRzUGVyUGl4ZWwgPT0gMzIpOyAvLyBJbWFnZURpZmYgYXNz dW1lcyAzMiBiaXQgUkdCQSwgd2UgbXVzdCBhcyB3ZWxsLg0gICAgIHNpemVfdCBieXRlc1BlclBp eGVsID0gYml0c1BlclBpeGVsIC8gODsNLSAgICBzaXplX3QgcGl4ZWxzSGlnaCA9IENHQml0bWFw Q29udGV4dEdldEhlaWdodChiaXRtYXApOw0tICAgIHNpemVfdCBwaXhlbHNXaWRlID0gQ0dCaXRt YXBDb250ZXh0R2V0V2lkdGgoYml0bWFwKTsNLSAgICBzaXplX3QgYnl0ZXNQZXJSb3cgPSBDR0Jp dG1hcENvbnRleHRHZXRCeXRlc1BlclJvdyhiaXRtYXApOw0rICAgIHNpemVfdCBwaXhlbHNIaWdo ID0gQ0dCaXRtYXBDb250ZXh0R2V0SGVpZ2h0KGJpdG1hcENvbnRleHQpOw0rICAgIHNpemVfdCBw aXhlbHNXaWRlID0gQ0dCaXRtYXBDb250ZXh0R2V0V2lkdGgoYml0bWFwQ29udGV4dCk7DSsgICAg c2l6ZV90IGJ5dGVzUGVyUm93ID0gQ0dCaXRtYXBDb250ZXh0R2V0Qnl0ZXNQZXJSb3coYml0bWFw Q29udGV4dCk7DSAgICAgQVNTRVJUKGJ5dGVzUGVyUm93ID49IChwaXhlbHNXaWRlICogYnl0ZXNQ ZXJQaXhlbCkpOw0gDSsgICAgTUQ1X0NUWCBtZDVDb250ZXh0Ow0gICAgIE1ENV9Jbml0KCZtZDVD b250ZXh0KTsNLSAgICB1bnNpZ25lZCBjaGFyKiBiaXRtYXBEYXRhID0gc3RhdGljX2Nhc3Q8dW5z aWduZWQgY2hhcio+KENHQml0bWFwQ29udGV4dEdldERhdGEoYml0bWFwKSk7DSsgICAgdW5zaWdu ZWQgY2hhciogYml0bWFwRGF0YSA9IHN0YXRpY19jYXN0PHVuc2lnbmVkIGNoYXIqPihDR0JpdG1h cENvbnRleHRHZXREYXRhKGJpdG1hcENvbnRleHQpKTsNICAgICBmb3IgKHVuc2lnbmVkIHJvdyA9 IDA7IHJvdyA8IHBpeGVsc0hpZ2g7IHJvdysrKSB7DSAgICAgICAgIE1ENV9VcGRhdGUoJm1kNUNv bnRleHQsIGJpdG1hcERhdGEsIHN0YXRpY19jYXN0PHVuc2lnbmVkPihwaXhlbHNXaWRlICogYnl0 ZXNQZXJQaXhlbCkpOw0gICAgICAgICBiaXRtYXBEYXRhICs9IGJ5dGVzUGVyUm93Ow0gICAgIH0N Kw0rICAgIHVuc2lnbmVkIGNoYXIgaGFzaFsxNl07DSAgICAgTUQ1X0ZpbmFsKGhhc2gsICZtZDVD b250ZXh0KTsNIA0tICAgIHN0cmluZ1swXSA9ICdcMCc7DSsgICAgaGFzaFN0cmluZ1swXSA9ICdc MCc7DSAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCAxNjsgaSsrKQ0tICAgICAgICBzbnByaW50Zihz dHJpbmcsIDMzLCAiJXMlMDJ4Iiwgc3RyaW5nLCBoYXNoW2ldKTsNKyAgICAgICAgc25wcmludGYo aGFzaFN0cmluZywgMzMsICIlcyUwMngiLCBoYXNoU3RyaW5nLCBoYXNoW2ldKTsNIH0NIA0tdm9p ZCBkcmF3U2VsZWN0aW9uUmVjdChDR0NvbnRleHRSZWYgY29udGV4dCwgY29uc3QgQ0dSZWN0JiBy ZWN0KQ0rdm9pZCBkdW1wV2ViVmlld0FzUGl4ZWxzQW5kQ29tcGFyZVdpdGhFeHBlY3RlZChjb25z dCBzdGQ6OnN0cmluZyYgZXhwZWN0ZWRIYXNoKQ0gew0tICAgIENHQ29udGV4dFNhdmVHU3RhdGUo Y29udGV4dCk7DS0gICAgQ0dDb250ZXh0U2V0UkdCU3Ryb2tlQ29sb3IoY29udGV4dCwgMS4wLCAw LjAsIDAuMCwgMS4wKTsNLSAgICBDR0NvbnRleHRTdHJva2VSZWN0KGNvbnRleHQsIHJlY3QpOw0t ICAgIENHQ29udGV4dFJlc3RvcmVHU3RhdGUoY29udGV4dCk7DS19DS0NLXZvaWQgZHVtcFdlYlZp ZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0ZWQoY29uc3QgY2hhciogLypjdXJyZW50VGVz dCovLCBib29sIC8qZm9yY2VBbGxUZXN0c1RvRHVtcFBpeGVscyovKQ0tew0tICAgIFJldGFpblB0 cjxDR0NvbnRleHRSZWY+IGNvbnRleHQgPSBnZXRCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoKTsN LQ0rICAgIFJlZlB0cjxCaXRtYXBDb250ZXh0PiBjb250ZXh0Ow0rICAgIA0gI2lmIFBMQVRGT1JN KE1BQykNLSAgICBpZiAoZ0xheW91dFRlc3RDb250cm9sbGVyLT50ZXN0UmVwYWludCgpKQ0tICAg ICAgICByZXBhaW50V2ViVmlldyhjb250ZXh0LmdldCgpLCBnTGF5b3V0VGVzdENvbnRyb2xsZXIt PnRlc3RSZXBhaW50U3dlZXBIb3Jpem9udGFsbHkoKSk7DS0gICAgZWxzZSANLSAgICAgICAgcGFp bnRXZWJWaWV3KGNvbnRleHQuZ2V0KCkpOw0tDS0gICAgaWYgKGdMYXlvdXRUZXN0Q29udHJvbGxl ci0+ZHVtcFNlbGVjdGlvblJlY3QoKSkNLSAgICAgICAgZHJhd1NlbGVjdGlvblJlY3QoY29udGV4 dC5nZXQoKSwgZ2V0U2VsZWN0aW9uUmVjdCgpKTsNKyAgICBjb250ZXh0ID0gZ2V0Qml0bWFwQ29u dGV4dEZyb21XZWJWaWV3KGdMYXlvdXRUZXN0Q29udHJvbGxlci0+dGVzdFJlcGFpbnQoKSwgZ0xh eW91dFRlc3RDb250cm9sbGVyLT50ZXN0UmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5KCksIGdMYXlv dXRUZXN0Q29udHJvbGxlci0+ZHVtcFNlbGVjdGlvblJlY3QoKSk7DSAjZW5kaWYNLQ0tICAgIC8v IENvbXB1dGUgdGhlIGFjdHVhbCBoYXNoIHRvIGNvbXBhcmUgdG8gdGhlIGV4cGVjdGVkIGltYWdl J3MgaGFzaC4NKyAgICBBU1NFUlQoY29udGV4dC5nZXQoKSk7DSsgICAgDSsgICAgLy8gQ29tcHV0 ZSB0aGUgaGFzaCBvZiB0aGUgYml0bWFwIGNvbnRleHQgcGl4ZWxzDSAgICAgY2hhciBhY3R1YWxI YXNoWzMzXTsNLSAgICBnZXRNRDVIYXNoU3RyaW5nRm9yQml0bWFwKGNvbnRleHQuZ2V0KCksIGFj dHVhbEhhc2gpOw0rICAgIGNvbXB1dGVNRDVIYXNoU3RyaW5nRm9yQml0bWFwQ29udGV4dChjb250 ZXh0LT5jZ0NvbnRleHQoKSwgYWN0dWFsSGFzaCk7DSAgICAgcHJpbnRmKCJcbkFjdHVhbEhhc2g6 ICVzXG4iLCBhY3R1YWxIYXNoKTsNLQ0tICAgIC8vIEZJWE1FOiBXZSBzaG91bGQgY29tcGFyZSB0 aGUgYWN0dWFsSGFzaCB0byB0aGUgZXhwZWN0ZWQgaGFzaCBoZXJlIGFuZA0tICAgIC8vIG9ubHkg c2V0IGR1bXBJbWFnZSB0byB0cnVlIGlmIHRoZXkgZG9uJ3QgbWF0Y2gsIGJ1dCBEUlQgZG9lc24n dCBoYXZlDS0gICAgLy8gZW5vdWdoIGluZm9ybWF0aW9uIGN1cnJlbnRseSB0byBmaW5kIHRoZSBl eHBlY3RlZCBjaGVja3N1bSBmaWxlLg0rICAgIA0rICAgIC8vIENoZWNrIHRoZSBjb21wdXRlZCBo YXNoIGFnYWluc3QgdGhlIGV4cGVjdGVkIG9uZSBhbmQgZHVtcCBpbWFnZSBvbiBtaXNtYXRjaA0g ICAgIGJvb2wgZHVtcEltYWdlID0gdHJ1ZTsNLQ0rICAgIGlmIChleHBlY3RlZEhhc2gubGVuZ3Ro KCkgPiAwKSB7DSsgICAgICAgIEFTU0VSVChleHBlY3RlZEhhc2gubGVuZ3RoKCkgPT0gMzIpOw0r ICAgICAgICANKyAgICAgICAgcHJpbnRmKCJcbkV4cGVjdGVkSGFzaDogJXNcbiIsIGV4cGVjdGVk SGFzaC5jX3N0cigpKTsNKyAgICAgICAgDSsgICAgICAgIGlmIChleHBlY3RlZEhhc2ggPT0gYWN0 dWFsSGFzaCkgICAgIC8vIEZJWE1FOiBkbyBjYXNlIGluc2Vuc2l0aXZlIGNvbXBhcmUNKyAgICAg ICAgICAgIGR1bXBJbWFnZSA9IGZhbHNlOw0rICAgIH0NKyAgICANICAgICBpZiAoZHVtcEltYWdl KSB7DS0gICAgICAgIFJldGFpblB0cjxDR0ltYWdlUmVmPiBpbWFnZShBZG9wdENGLCBDR0JpdG1h cENvbnRleHRDcmVhdGVJbWFnZShjb250ZXh0LmdldCgpKSk7DSsgICAgICAgIFJldGFpblB0cjxD R0ltYWdlUmVmPiBpbWFnZShBZG9wdENGLCBDR0JpdG1hcENvbnRleHRDcmVhdGVJbWFnZShjb250 ZXh0LT5jZ0NvbnRleHQoKSkpOw0gICAgICAgICBwcmludFBORyhpbWFnZS5nZXQoKSk7DSAgICAg fQ0tDSsgICAgDSAgICAgcHJpbnRmKCIjRU9GXG4iKTsNIH0NZGlmZiAtLWdpdCBhL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5oIGIvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1wU3VwcG9ydENHLmgNaW5kZXggMGFiZGVhNi4uNWI5 MjRkMCAxMDA2NDQNLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1w U3VwcG9ydENHLmgNKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1w U3VwcG9ydENHLmgNQEAgLTMxLDI1ICszMSw2NCBAQA0gI2lmbmRlZiBQaXhlbER1bXBTdXBwb3J0 Q0dfaA0gI2RlZmluZSBQaXhlbER1bXBTdXBwb3J0Q0dfaA0gDSsjaW5jbHVkZSA8d3RmL1Bhc3NS ZWZQdHIuaD4NKyNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPg0gI2luY2x1ZGUgPHd0Zi9SZXRh aW5QdHIuaD4NIA0tI2lmbmRlZiBDR0ZMT0FUX0RFRklORUQNLSNpZmRlZiBfX0xQNjRfXw0tdHlw ZWRlZiBkb3VibGUgQ0dGbG9hdDsNLSNlbHNlDS10eXBlZGVmIGZsb2F0IENHRmxvYXQ7DSt0eXBl ZGVmIHN0cnVjdCBDR0NvbnRleHQqIENHQ29udGV4dFJlZjsNKw0rDStjbGFzcyBCaXRtYXBDb250 ZXh0IDogcHVibGljIFJlZkNvdW50ZWQ8Qml0bWFwQ29udGV4dD4NK3sNK3B1YmxpYzoNKyNpZiBQ TEFURk9STShNQUMpDSsgICAgc3RhdGljIFBhc3NSZWZQdHI8Qml0bWFwQ29udGV4dD4gY3JlYXRl KHZvaWQqIHBpeGVsRGF0YSwgQ0dDb250ZXh0UmVmIGNvbnRleHQpDSsgICAgew0rICAgICAgICBy ZXR1cm4gYWRvcHRSZWYobmV3IEJpdG1hcENvbnRleHQocGl4ZWxEYXRhLCBjb250ZXh0KSk7DSsg ICAgfQ0rI2VsaWYgUExBVEZPUk0oV0lOKQ0rICAgIHN0YXRpYyBQYXNzUmVmUHRyPEJpdG1hcENv bnRleHQ+IGNyZWF0ZShIQklUTUFQIGJpdG1hcCwgQ0dDb250ZXh0UmVmIGNvbnRleHQpDSsgICAg ew0rICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IEJpdG1hcENvbnRleHQoYml0bWFwLCBjb250 ZXh0KSk7DSsgICAgfQ0gI2VuZGlmDS0jZGVmaW5lIENHRkxPQVRfREVGSU5FRCAxDSsNKyAgICB+ Qml0bWFwQ29udGV4dCgpDSsgICAgew0rI2lmIFBMQVRGT1JNKE1BQykNKyAgICAgICAgaWYgKG1f cGl4ZWxEYXRhKQ0rICAgICAgICAgICAgZnJlZShtX3BpeGVsRGF0YSk7DSsjZWxpZiBQTEFURk9S TShXSU4pDSsgICAgICAgIGlmIChtX2JpdG1hcCkNKyAgICAgICAgICAgIERlbGV0ZU9iamVjdCht X2JpdG1hcCk7DSAjZW5kaWYNKyAgICB9DSANLXR5cGVkZWYgc3RydWN0IENHQ29udGV4dCogQ0dD b250ZXh0UmVmOw0tc3RydWN0IENHUmVjdDsNKyAgICBDR0NvbnRleHRSZWYgY2dDb250ZXh0KCkg Y29uc3QgeyByZXR1cm4gbV9jb250ZXh0LmdldCgpOyB9DSsNK3ByaXZhdGU6DSsNKyNpZiBQTEFU Rk9STShNQUMpDSsgICAgQml0bWFwQ29udGV4dCh2b2lkKiBwaXhlbERhdGEsIENHQ29udGV4dFJl ZiBjb250ZXh0KQ0rICAgICAgICA6IG1fcGl4ZWxEYXRhKHBpeGVsRGF0YSkNKyNlbGlmIFBMQVRG T1JNKFdJTikNKyAgICBCaXRtYXBDb250ZXh0KEhCSVRNQVAgYml0bWFwLCBDR0NvbnRleHRSZWYg Y29udGV4dCkNKyAgICAgICAgOiBtX2JpdG1hcChiaXRtYXApDSsjZW5kaWYNKyAgICAgICAgLCBt X2NvbnRleHQoQWRvcHRDRiwgY29udGV4dCkNKyAgICB7DSsgICAgfQ0rICAgIA0rI2lmIFBMQVRG T1JNKE1BQykNKyAgICB2b2lkKiBtX3BpeGVsRGF0YTsNKyNlbGlmIFBMQVRGT1JNKFdJTikNKyAg ICBIQklUTUFQIG1fYml0bWFwOw0rI2VuZGlmICAgIA0rICAgIFJldGFpblB0cjxDR0NvbnRleHRS ZWY+IG1fY29udGV4dDsNKw0rfTsNIA0tUmV0YWluUHRyPENHQ29udGV4dFJlZj4gZ2V0Qml0bWFw Q29udGV4dEZyb21XZWJWaWV3KCk7DS1DR1JlY3QgZ2V0U2VsZWN0aW9uUmVjdCgpOw0gDS12b2lk IHBhaW50V2ViVmlldyhDR0NvbnRleHRSZWYpOw0tdm9pZCByZXBhaW50V2ViVmlldyhDR0NvbnRl eHRSZWYgY29udGV4dCwgYm9vbCBob3Jpem9udGFsKTsNLXZvaWQgZHJhd1NlbGVjdGlvblJlY3Qo Q0dDb250ZXh0UmVmLCBjb25zdCBDR1JlY3QmKTsNK1Bhc3NSZWZQdHI8Qml0bWFwQ29udGV4dD4g Z2V0Qml0bWFwQ29udGV4dEZyb21XZWJWaWV3KGJvb2wgaW5jcmVtZW50YWxSZXBhaW50LCBib29s IHN3ZWVwSG9yaXpvbnRhbGx5LCBib29sIGRyYXdTZWxlY3Rpb25SZWN0KTsNIA0gI2VuZGlmIC8v IFBpeGVsRHVtcFN1cHBvcnRDR19oDWRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0gYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9t YWMvRHVtcFJlbmRlclRyZWUubW0NaW5kZXggYjQ3MDRmOC4uYjY2OTg3NyAxMDA2NDQNLS0tIGEv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tDSsrKyBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQ1AQCAtNzgsNyAr NzgsNyBAQA0gQGludGVyZmFjZSBEdW1wUmVuZGVyVHJlZUV2ZW50IDogTlNFdmVudA0gQGVuZA0g DS1zdGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0IGNoYXIgKnBhdGhPclVSTCk7DStzdGF0aWMgdm9p ZCBydW5UZXN0KGNvbnN0IHN0ZDo6c3RyaW5nJiB0ZXN0UGF0aE9yVVJMKTsNIA0gLy8gRGVjaWRp bmcgd2hlbiBpdCdzIE9LIHRvIGR1bXAgb3V0IHRoZSBzdGF0ZSBpcyBhIGJpdCB0cmlja3kuICBB bGwgdGhlc2UgbXVzdCBiZSB0cnVlOg0gLy8gLSBUaGVyZSBpcyBubyBsb2FkIGluIHByb2dyZXNz DUBAIC0xMTgsNyArMTE4LDYgQEAgc3RhdGljIGludCByZXBhaW50U3dlZXBIb3Jpem9udGFsbHlE ZWZhdWx0Ow0gc3RhdGljIGludCBkdW1wVHJlZSA9IFlFUzsNIHN0YXRpYyBpbnQgZm9yY2VDb21w bGV4VGV4dDsNIHN0YXRpYyBCT09MIHByaW50U2VwYXJhdG9yczsNLXN0YXRpYyBOU1N0cmluZyAq Y3VycmVudFRlc3QgPSBuaWw7DSBzdGF0aWMgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBwZXJzaXN0 ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbjsNIA0gc3RhdGljIFdlYkhpc3RvcnlJdGVtICpwcmV2 VGVzdEJGSXRlbSA9IG5pbDsgIC8vIGN1cnJlbnQgYi9mIGl0ZW0gYXQgdGhlIGVuZCBvZiB0aGUg cHJldmlvdXMgdGVzdA1AQCAtMTgxLDIxICsxODAsMjIgQEAgdm9pZCBzZXRQZXJzaXN0ZW50VXNl clN0eWxlU2hlZXRMb2NhdGlvbihDRlN0cmluZ1JlZiB1cmwpDSAgICAgcGVyc2lzdGVudFVzZXJT dHlsZVNoZWV0TG9jYXRpb24gPSB1cmw7DSB9DSANLXN0YXRpYyBCT09MIHNob3VsZElnbm9yZVdl YkNvcmVOb2RlTGVha3MoQ0ZTdHJpbmdSZWYgVVJMU3RyaW5nKQ0rc3RhdGljIGJvb2wgc2hvdWxk SWdub3JlV2ViQ29yZU5vZGVMZWFrcyhjb25zdCBzdGQ6OnN0cmluZyYgVVJMU3RyaW5nKQ0gew0t ICAgIHN0YXRpYyBDRlN0cmluZ1JlZiBjb25zdCBpZ25vcmVTZXRbXSA9IHsNKyAgICBzdGF0aWMg Y2hhciogY29uc3QgaWdub3JlU2V0W10gPSB7DSAgICAgICAgIC8vIEtlZXBpbmcgdGhpcyBpbmZy YXN0cnVjdHVyZSBhcm91bmQgaW4gY2FzZSB3ZSBldmVyIG5lZWQgaXQgYWdhaW4uDSAgICAgfTsN LSAgICBzdGF0aWMgY29uc3QgaW50IGlnbm9yZVNldENvdW50ID0gc2l6ZW9mKGlnbm9yZVNldCkg LyBzaXplb2YoQ0ZTdHJpbmdSZWYpOw0rICAgIHN0YXRpYyBjb25zdCBpbnQgaWdub3JlU2V0Q291 bnQgPSBzaXplb2YoaWdub3JlU2V0KSAvIHNpemVvZihjaGFyKik7DSAgICAgDSAgICAgZm9yIChp bnQgaSA9IDA7IGkgPCBpZ25vcmVTZXRDb3VudDsgaSsrKSB7DS0gICAgICAgIENGU3RyaW5nUmVm IGlnbm9yZVN0cmluZyA9IGlnbm9yZVNldFtpXTsNLSAgICAgICAgQ0ZSYW5nZSByYW5nZSA9IENG UmFuZ2VNYWtlKDAsIENGU3RyaW5nR2V0TGVuZ3RoKFVSTFN0cmluZykpOw0tICAgICAgICBDRk9w dGlvbkZsYWdzIGZsYWdzID0ga0NGQ29tcGFyZUFuY2hvcmVkIHwga0NGQ29tcGFyZUJhY2t3YXJk cyB8IGtDRkNvbXBhcmVDYXNlSW5zZW5zaXRpdmU7DS0gICAgICAgIGlmIChDRlN0cmluZ0ZpbmRX aXRoT3B0aW9ucyhVUkxTdHJpbmcsIGlnbm9yZVN0cmluZywgcmFuZ2UsIGZsYWdzLCBOVUxMKSkN LSAgICAgICAgICAgIHJldHVybiBZRVM7DSsNKyAgICAgICAgLy8gRklYTUU6IGlnbm9yZSBjYXNl DSsgICAgICAgIHN0ZDo6c3RyaW5nIGN1cklnbm9yZShpZ25vcmVTZXRbaV0pOw0rICAgICAgICAv LyBNYXRjaCBhdCB0aGUgZW5kIG9mIHRoZSBVUkxTdHJpbmcNKyAgICAgICAgaWYgKFVSTFN0cmlu Zy5jb21wYXJlKFVSTFN0cmluZy5sZW5ndGgoKSAtIGN1cklnbm9yZS5sZW5ndGgoKSwgY3VySWdu b3JlLmxlbmd0aCgpLCBjdXJJZ25vcmUpID09IDApDSsgICAgICAgICAgICByZXR1cm4gdHJ1ZTsN ICAgICB9DS0gICAgcmV0dXJuIE5POw0rICAgIHJldHVybiBmYWxzZTsNIH0NIA0gc3RhdGljIHZv aWQgYWN0aXZhdGVGb250cygpDUBAIC0zNTAsNyArMzUwLDkgQEAgc3RhdGljIHZvaWQgY3Jhc2hI YW5kbGVyKGludCBzaWcpDSAgICAgY2hhciAqc2lnbmFsTmFtZSA9IHN0cnNpZ25hbChzaWcpOw0g ICAgIHdyaXRlKFNUREVSUl9GSUxFTk8sIHNpZ25hbE5hbWUsIHN0cmxlbihzaWduYWxOYW1lKSk7 DSAgICAgd3JpdGUoU1RERVJSX0ZJTEVOTywgIlxuIiwgMSk7DS0gICAgcmVzdG9yZUNvbG9yU3Bh Y2UoMCk7DSsjaWYgUExBVEZPUk0oTUFDKQ0rICAgIHJlc3RvcmVNYWluRGlzcGxheUNvbG9yUHJv ZmlsZSgwKTsNKyNlbmRpZg0gICAgIGV4aXQoMTI4ICsgc2lnKTsNIH0NIA1AQCAtNDYwLDcgKzQ2 Miw3IEBAIHN0YXRpYyB2b2lkIHByZXBhcmVDb25zaXN0ZW50VGVzdGluZ0Vudmlyb25tZW50KCkN ICAgICBhY3RpdmF0ZUZvbnRzKCk7DSAgICAgDSAgICAgaWYgKGR1bXBQaXhlbHMpDS0gICAgICAg IGluaXRpYWxpemVDb2xvclNwYWNlQW5kU2NyZWVCdWZmZXJGb3JQaXhlbFRlc3RzKCk7DSsgICAg ICAgIHNldHVwTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUoKTsNICAgICBhbGxvY2F0ZUdsb2JhbENv bnRyb2xsZXJzKCk7DSAgICAgDSAgICAgbWFrZUxhcmdlTWFsbG9jRmFpbFNpbGVudGx5KCk7DUBA IC01MjUsOCArNTI3LDEwIEBAIHZvaWQgZHVtcFJlbmRlclRyZWUoaW50IGFyZ2MsIGNvbnN0IGNo YXIgKmFyZ3ZbXSkNICAgICAgICAgZGlzYWxsb3dlZFVSTHMgPSAwOw0gICAgIH0NIA0rI2lmIFBM QVRGT1JNKE1BQykNICAgICBpZiAoZHVtcFBpeGVscykNLSAgICAgICAgcmVzdG9yZUNvbG9yU3Bh Y2UoMCk7DSsgICAgICAgIHJlc3RvcmVNYWluRGlzcGxheUNvbG9yUHJvZmlsZSgwKTsNKyNlbmRp Zg0gfQ0gDSBpbnQgbWFpbihpbnQgYXJnYywgY29uc3QgY2hhciAqYXJndltdKQ1AQCAtODE4LDE2 ICs4MjIsNiBAQCBzdGF0aWMgdm9pZCBkdW1wQmFja0ZvcndhcmRMaXN0Rm9yV2ViVmlldyhXZWJW aWV3ICp2aWV3KQ0gICAgIHByaW50ZigiPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT1cbiIpOw0gfQ0gDS1zdGF0aWMgdm9pZCBzaXplV2ViVmlld0ZvckN1cnJl bnRUZXN0KCkNLXsNLSAgICAvLyBXM0MgU1ZHIHRlc3RzIGV4cGVjdCB0byBiZSA0ODB4MzYwDS0g ICAgYm9vbCBpc1NWR1czQ1Rlc3QgPSAoW2N1cnJlbnRUZXN0IHJhbmdlT2ZTdHJpbmc6QCJzdmcv VzNDLVNWRy0xLjEiXS5sZW5ndGgpOw0tICAgIGlmIChpc1NWR1czQ1Rlc3QpDS0gICAgICAgIFtb bWFpbkZyYW1lIHdlYlZpZXddIHNldEZyYW1lU2l6ZTpOU01ha2VTaXplKDQ4MCwgMzYwKV07DS0g ICAgZWxzZQ0tICAgICAgICBbW21haW5GcmFtZSB3ZWJWaWV3XSBzZXRGcmFtZVNpemU6TlNNYWtl U2l6ZShtYXhWaWV3V2lkdGgsIG1heFZpZXdIZWlnaHQpXTsNLX0NLQ0gc3RhdGljIGNvbnN0IGNo YXIgKm1ldGhvZE5hbWVTdHJpbmdGb3JGYWlsZWRUZXN0KCkNIHsNICAgICBjb25zdCBjaGFyICpl cnJvck1lc3NhZ2U7DUBAIC04ODksNyArODgzLDEyIEBAIHZvaWQgZHVtcCgpDSAgICAgICAgICAg ICByZXN1bHRTdHJpbmcgPSBzZXJpYWxpemVXZWJBcmNoaXZlVG9YTUwod2ViQXJjaGl2ZSk7DSAg ICAgICAgICAgICByZXN1bHRNaW1lVHlwZSA9IEAiYXBwbGljYXRpb24veC13ZWJhcmNoaXZlIjsN ICAgICAgICAgfSBlbHNlIHsNLSAgICAgICAgICAgIHNpemVXZWJWaWV3Rm9yQ3VycmVudFRlc3Qo KTsNKyAgICAgICAgICAgIC8vIFczQyBTVkcgdGVzdHMgZXhwZWN0IHRvIGJlIDQ4MHgzNjANKyAg ICAgICAgICAgIGlmIChnTGF5b3V0VGVzdENvbnRyb2xsZXItPnRlc3RQYXRoT3JVUkwoKS5maW5k KCJzdmcvVzNDLVNWRy0xLjEiKSAhPSBzdGQ6OnN0cmluZzo6bnBvcykNKyAgICAgICAgICAgICAg ICBbW21haW5GcmFtZSB3ZWJWaWV3XSBzZXRGcmFtZVNpemU6TlNNYWtlU2l6ZSg0ODAsIDM2MCld Ow0rICAgICAgICAgICAgZWxzZQ0rICAgICAgICAgICAgICAgIFtbbWFpbkZyYW1lIHdlYlZpZXdd IHNldEZyYW1lU2l6ZTpOU01ha2VTaXplKG1heFZpZXdXaWR0aCwgbWF4Vmlld0hlaWdodCldOw0r ICAgICAgICAgICAgDSAgICAgICAgICAgICByZXN1bHRTdHJpbmcgPSBbbWFpbkZyYW1lIHJlbmRl clRyZWVBc0V4dGVybmFsUmVwcmVzZW50YXRpb25dOw0gICAgICAgICB9DSANQEAgLTkxNiw3ICs5 MTUsNyBAQCB2b2lkIGR1bXAoKQ0gICAgIH0NICAgICANICAgICBpZiAoZHVtcEFsbFBpeGVscyB8 fCAoZHVtcFBpeGVscyAmJiAhZHVtcEFzVGV4dCkpDS0gICAgICAgIGR1bXBXZWJWaWV3QXNQaXhl bHNBbmRDb21wYXJlV2l0aEV4cGVjdGVkKFtjdXJyZW50VGVzdCBVVEY4U3RyaW5nXSwgZHVtcEFs bFBpeGVscyk7DSsgICAgICAgIGR1bXBXZWJWaWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4cGVj dGVkKGdMYXlvdXRUZXN0Q29udHJvbGxlci0+ZXhwZWN0ZWRQaXhlbEhhc2goKSk7DSANICAgICBm Zmx1c2goc3Rkb3V0KTsNICAgICBmZmx1c2goc3RkZXJyKTsNQEAgLTkyOSwxNiArOTI4LDYgQEAg c3RhdGljIGJvb2wgc2hvdWxkTG9nRnJhbWVMb2FkRGVsZWdhdGVzKGNvbnN0IGNoYXIgKnBhdGhP clVSTCkNICAgICByZXR1cm4gc3Ryc3RyKHBhdGhPclVSTCwgImxvYWRpbmcvIik7DSB9DSANLXN0 YXRpYyBDRlVSTFJlZiBjcmVhdGVDRlVSTEZyb21QYXRoT3JVUkwoQ0ZTdHJpbmdSZWYgcGF0aE9y VVJMU3RyaW5nKQ0tew0tICAgIENGVVJMUmVmIFVSTDsNLSAgICBpZiAoQ0ZTdHJpbmdIYXNQcmVm aXgocGF0aE9yVVJMU3RyaW5nLCBDRlNUUigiaHR0cDovLyIpKSB8fCBDRlN0cmluZ0hhc1ByZWZp eChwYXRoT3JVUkxTdHJpbmcsIENGU1RSKCJodHRwczovLyIpKSkNLSAgICAgICAgVVJMID0gQ0ZV UkxDcmVhdGVXaXRoU3RyaW5nKE5VTEwsIHBhdGhPclVSTFN0cmluZywgTlVMTCk7DS0gICAgZWxz ZQ0tICAgICAgICBVUkwgPSBDRlVSTENyZWF0ZVdpdGhGaWxlU3lzdGVtUGF0aChOVUxMLCBwYXRo T3JVUkxTdHJpbmcsIGtDRlVSTFBPU0lYUGF0aFN0eWxlLCBGQUxTRSk7DS0gICAgcmV0dXJuIFVS TDsNLX0NLQ0gc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdGVCZWZvcmVU ZXN0aW5nKCkNIHsNICAgICBXZWJWaWV3ICp3ZWJWaWV3ID0gW21haW5GcmFtZSB3ZWJWaWV3XTsN QEAgLTk2Niw1MyArOTU1LDY4IEBAIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVu dFN0YXRlQmVmb3JlVGVzdGluZygpDSAgICAgW1dlYlZpZXcgX3NldFVzZXNUZXN0TW9kZUZvY3Vz UmluZ0NvbG9yOllFU107DSB9DSANLXN0YXRpYyB2b2lkIHJ1blRlc3QoY29uc3QgY2hhciAqcGF0 aE9yVVJMKQ0rc3RhdGljIHZvaWQgcnVuVGVzdChjb25zdCBzdGQ6OnN0cmluZyYgdGVzdFBhdGhP clVSTCkNIHsNLSAgICBDRlN0cmluZ1JlZiBwYXRoT3JVUkxTdHJpbmcgPSBDRlN0cmluZ0NyZWF0 ZVdpdGhDU3RyaW5nKE5VTEwsIHBhdGhPclVSTCwga0NGU3RyaW5nRW5jb2RpbmdVVEY4KTsNKyAg ICBBU1NFUlQoIXRlc3RQYXRoT3JVUkwuZW1wdHkoKSk7DSsgICAgDSsgICAgLy8gTG9vayBmb3Ig J3wnIGFzIGEgc2VwYXJhdG9yIGJldHdlZW4gdGhlIHBhdGggb3IgVVJMLCBhbmQgdGhlIHBpeGVs IGR1bXAgaGFzaCB0aGF0IGZvbGxvd3MuDSsgICAgLy8gRklYTUU6IHRoaXMgaXMgYSB2YWxpZCBV UkwgY2hhcmFjdGVycy4gVXNlIGEgZGlmZmVyZW50IHNlcGFyYXRvcj8gIA0rICAgIHN0ZDo6c3Ry aW5nIHBhdGhPclVSTCh0ZXN0UGF0aE9yVVJMKTsNKyAgICBzdGQ6OnN0cmluZyBleHBlY3RlZFBp eGVsSGFzaDsNKyAgICANKyAgICBzaXplX3Qgc2VwYXJhdG9yUG9zID0gcGF0aE9yVVJMLmZpbmQo InwiKTsNKyAgICBpZiAoc2VwYXJhdG9yUG9zICE9IHN0ZDo6c3RyaW5nOjpucG9zKSB7DSsgICAg ICAgIHBhdGhPclVSTCA9IHN0ZDo6c3RyaW5nKHRlc3RQYXRoT3JVUkwsIDAsIHNlcGFyYXRvclBv cyk7DSsgICAgICAgIGV4cGVjdGVkUGl4ZWxIYXNoID0gc3RkOjpzdHJpbmcodGVzdFBhdGhPclVS TCwgc2VwYXJhdG9yUG9zICsgMSk7DSsgICAgfQ0rDSsgICAgTlNTdHJpbmcqIHBhdGhPclVSTFN0 cmluZyA9IFtOU1N0cmluZyBzdHJpbmdXaXRoVVRGOFN0cmluZzpwYXRoT3JVUkwuY19zdHIoKV07 DSAgICAgaWYgKCFwYXRoT3JVUkxTdHJpbmcpIHsNLSAgICAgICAgZnByaW50ZihzdGRlcnIsICJG YWlsZWQgdG8gcGFyc2UgZmlsZW5hbWUgYXMgVVRGLTg6ICVzXG4iLCBwYXRoT3JVUkwpOw0rICAg ICAgICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byBwYXJzZSBcIiVzXCIgYXMgVVRGLThcbiIs IHBhdGhPclVSTC5jX3N0cigpKTsNICAgICAgICAgcmV0dXJuOw0gICAgIH0NIA0tICAgIENGVVJM UmVmIFVSTCA9IGNyZWF0ZUNGVVJMRnJvbVBhdGhPclVSTChwYXRoT3JVUkxTdHJpbmcpOw0tICAg IGlmICghVVJMKSB7DS0gICAgICAgIENGUmVsZWFzZShwYXRoT3JVUkxTdHJpbmcpOw0tICAgICAg ICBmcHJpbnRmKHN0ZGVyciwgIkNhbid0IHR1cm4gJXMgaW50byBhIENGVVJMXG4iLCBwYXRoT3JV UkwpOw0rICAgIE5TVVJMKiB1cmw7DSsgICAgaWYgKFtwYXRoT3JVUkxTdHJpbmcgaGFzUHJlZml4 OkAiaHR0cDovLyJdIHx8IFtwYXRoT3JVUkxTdHJpbmcgaGFzUHJlZml4OkAiaHR0cHM6Ly8iXSkN KyAgICAgICAgdXJsID0gW05TVVJMIFVSTFdpdGhTdHJpbmc6cGF0aE9yVVJMU3RyaW5nXTsNKyAg ICBlbHNlDSsgICAgICAgIHVybCA9IFtOU1VSTCBmaWxlVVJMV2l0aFBhdGg6cGF0aE9yVVJMU3Ry aW5nXTsNKyAgICBpZiAoIXVybCkgew0rICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0 byBwYXJzZSBcIiVzXCIgYXMgYW4gdXJsXG4iLCBwYXRoT3JVUkwuY19zdHIoKSk7DSAgICAgICAg IHJldHVybjsNICAgICB9DSANKyAgICBjb25zdCBzdGQ6OnN0cmluZyB0ZXN0VVJMKFtbdXJsIGFi c29sdXRlU3RyaW5nXSBVVEY4U3RyaW5nXSk7DSsgICAgDSAgICAgcmVzZXRXZWJWaWV3VG9Db25z aXN0ZW50U3RhdGVCZWZvcmVUZXN0aW5nKCk7DSANLSAgICBnTGF5b3V0VGVzdENvbnRyb2xsZXIg PSBuZXcgTGF5b3V0VGVzdENvbnRyb2xsZXIodGVzdFJlcGFpbnREZWZhdWx0LCByZXBhaW50U3dl ZXBIb3Jpem9udGFsbHlEZWZhdWx0KTsNKyAgICBnTGF5b3V0VGVzdENvbnRyb2xsZXIgPSBuZXcg TGF5b3V0VGVzdENvbnRyb2xsZXIodGVzdFVSTCwgZXhwZWN0ZWRQaXhlbEhhc2gsIHRlc3RSZXBh aW50RGVmYXVsdCwgcmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5RGVmYXVsdCk7DSAgICAgdG9wTG9h ZGluZ0ZyYW1lID0gbmlsOw0gICAgIGRvbmUgPSBOTzsNIA0gICAgIGlmIChkaXNhbGxvd2VkVVJM cykNICAgICAgICAgQ0ZTZXRSZW1vdmVBbGxWYWx1ZXMoZGlzYWxsb3dlZFVSTHMpOw0tICAgIGlm IChzaG91bGRMb2dGcmFtZUxvYWREZWxlZ2F0ZXMocGF0aE9yVVJMKSkNKyAgICBpZiAoc2hvdWxk TG9nRnJhbWVMb2FkRGVsZWdhdGVzKHBhdGhPclVSTC5jX3N0cigpKSkNICAgICAgICAgZ0xheW91 dFRlc3RDb250cm9sbGVyLT5zZXREdW1wRnJhbWVMb2FkQ2FsbGJhY2tzKHRydWUpOw0gDSAgICAg aWYgKFtXZWJIaXN0b3J5IG9wdGlvbmFsU2hhcmVkSGlzdG9yeV0pDSAgICAgICAgIFtXZWJIaXN0 b3J5IHNldE9wdGlvbmFsU2hhcmVkSGlzdG9yeTpuaWxdOw0rDSAgICAgbGFzdE1vdXNlUG9zaXRp b24gPSBOU1plcm9Qb2ludDsNICAgICBsYXN0Q2xpY2tQb3NpdGlvbiA9IE5TWmVyb1BvaW50Ow0g DS0gICAgaWYgKGN1cnJlbnRUZXN0ICE9IG5pbCkNLSAgICAgICAgQ0ZSZWxlYXNlKGN1cnJlbnRU ZXN0KTsNLSAgICBjdXJyZW50VGVzdCA9IChOU1N0cmluZyAqKXBhdGhPclVSTFN0cmluZzsNICAg ICBbcHJldlRlc3RCRkl0ZW0gcmVsZWFzZV07DSAgICAgcHJldlRlc3RCRkl0ZW0gPSBbW1tbbWFp bkZyYW1lIHdlYlZpZXddIGJhY2tGb3J3YXJkTGlzdF0gY3VycmVudEl0ZW1dIHJldGFpbl07DSAN ICAgICBXb3JrUXVldWU6OnNoYXJlZCgpLT5jbGVhcigpOw0gICAgIFdvcmtRdWV1ZTo6c2hhcmVk KCktPnNldEZyb3plbihmYWxzZSk7DSANLSAgICBCT09MIF9zaG91bGRJZ25vcmVXZWJDb3JlTm9k ZUxlYWtzID0gc2hvdWxkSWdub3JlV2ViQ29yZU5vZGVMZWFrcyhDRlVSTEdldFN0cmluZyhVUkwp KTsNLSAgICBpZiAoX3Nob3VsZElnbm9yZVdlYkNvcmVOb2RlTGVha3MpDSsgICAgYm9vbCBpZ25v cmVXZWJDb3JlTm9kZUxlYWtzID0gc2hvdWxkSWdub3JlV2ViQ29yZU5vZGVMZWFrcyh0ZXN0VVJM KTsNKyAgICBpZiAoaWdub3JlV2ViQ29yZU5vZGVMZWFrcykNICAgICAgICAgW1dlYkNvcmVTdGF0 aXN0aWNzIHN0YXJ0SWdub3JpbmdXZWJDb3JlTm9kZUxlYWtzXTsNIA0gICAgIE5TQXV0b3JlbGVh c2VQb29sICpwb29sID0gW1tOU0F1dG9yZWxlYXNlUG9vbCBhbGxvY10gaW5pdF07DS0gICAgW21h aW5GcmFtZSBsb2FkUmVxdWVzdDpbTlNVUkxSZXF1ZXN0IHJlcXVlc3RXaXRoVVJMOihOU1VSTCAq KVVSTF1dOw0tICAgIENGUmVsZWFzZShVUkwpOw0rICAgIFttYWluRnJhbWUgbG9hZFJlcXVlc3Q6 W05TVVJMUmVxdWVzdCByZXF1ZXN0V2l0aFVSTDp1cmxdXTsNICAgICBbcG9vbCByZWxlYXNlXTsN ICAgICB3aGlsZSAoIWRvbmUpIHsNICAgICAgICAgcG9vbCA9IFtbTlNBdXRvcmVsZWFzZVBvb2wg YWxsb2NdIGluaXRdOw1AQCAtMTA1NCw4ICsxMDU4LDggQEAgc3RhdGljIHZvaWQgcnVuVGVzdChj b25zdCBjaGFyICpwYXRoT3JVUkwpDSANICAgICBnTGF5b3V0VGVzdENvbnRyb2xsZXItPmRlcmVm KCk7DSAgICAgZ0xheW91dFRlc3RDb250cm9sbGVyID0gMDsNLQ0tICAgIGlmIChfc2hvdWxkSWdu b3JlV2ViQ29yZU5vZGVMZWFrcykNKyAgICANKyAgICBpZiAoaWdub3JlV2ViQ29yZU5vZGVMZWFr cykNICAgICAgICAgW1dlYkNvcmVTdGF0aXN0aWNzIHN0b3BJZ25vcmluZ1dlYkNvcmVOb2RlTGVh a3NdOw0gfQ0gDWRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVt cFJlbmRlclRyZWVNYWMuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVu ZGVyVHJlZU1hYy5oDWluZGV4IDAzZDM1NGQuLjdiMzliMDAgMTAwNjQ0DS0tLSBhL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZU1hYy5oDSsrKyBiL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZU1hYy5oDUBAIC0zNiw2ICszNiw4 IEBADSAjZGVmaW5lIEJVSUxESU5HX09OX1RJR0VSIDENICNlbGlmIE1BQ19PU19YX1ZFUlNJT05f TUFYX0FMTE9XRUQgPD0gTUFDX09TX1hfVkVSU0lPTl8xMF81DSAjZGVmaW5lIEJVSUxESU5HX09O X0xFT1BBUkQgMQ0rI2VsaWYgTUFDX09TX1hfVkVSU0lPTl9NQVhfQUxMT1dFRCA8PSBNQUNfT1Nf WF9WRVJTSU9OXzEwXzYNKyNkZWZpbmUgQlVJTERJTkdfT05fU05PV0xFT1BBUkQgMQ0gI2VuZGlm DSANIEBjbGFzcyBEdW1wUmVuZGVyVHJlZURyYWdnaW5nSW5mbzsNZGlmZiAtLWdpdCBhL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9QaXhlbER1bXBTdXBwb3J0TWFjLm1tIGIvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL1BpeGVsRHVtcFN1cHBvcnRNYWMubW0NaW5kZXggOWRk YmEzMS4uYTc5OGZmNSAxMDA2NDQNLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFj L1BpeGVsRHVtcFN1cHBvcnRNYWMubW0NKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv bWFjL1BpeGVsRHVtcFN1cHBvcnRNYWMubW0NQEAgLTM1LDE1MiArMzUsMTQ3IEBADSAjaW5jbHVk ZSAiTGF5b3V0VGVzdENvbnRyb2xsZXIuaCINICNpbmNsdWRlIDxDb3JlR3JhcGhpY3MvQ0dCaXRt YXBDb250ZXh0Lmg+DSAjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4NLSNpbmNsdWRlIDx3dGYv UmV0YWluUHRyLmg+DSsjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPg0gDSAjaW1wb3J0IDxXZWJLaXQv V2ViRG9jdW1lbnRQcml2YXRlLmg+DSAjaW1wb3J0IDxXZWJLaXQvV2ViS2l0Lmg+DSANLXN0YXRp YyB1bnNpZ25lZCBjaGFyKiBzY3JlZW5DYXB0dXJlQnVmZmVyOw0rI2lmZGVmIEJVSUxESU5HX09O X1NOT1dMRU9QQVJEDSsjZGVmaW5lIFBST0ZJTEVfUEFUSCAiL1N5c3RlbS9MaWJyYXJ5L0NvbG9y U3luYy9Qcm9maWxlcy9zUkdCIFByb2ZpbGUuaWNjIg0rI2Vsc2UNKyNkZWZpbmUgUFJPRklMRV9Q QVRIICIvU3lzdGVtL0xpYnJhcnkvQ29sb3JTeW5jL1Byb2ZpbGVzL0dlbmVyaWMgUkdCIFByb2Zp bGUuaWNjIg0rI2VuZGlmDSANLXN0YXRpYyBib29sIGNoYW5nZWRDb2xvclByb2ZpbGUgPSBmYWxz ZTsNLXN0YXRpYyBDTVByb2ZpbGVMb2NhdGlvbiBjdXJyZW50Q29sb3JQcm9maWxlTG9jYXRpb247 DS1zdGF0aWMgQ0dDb2xvclNwYWNlUmVmIHNoYXJlZENvbG9yU3BhY2U7DStzdGF0aWMgQ01Qcm9m aWxlTG9jYXRpb24gc0luaXRpYWxQcm9maWxlTG9jYXRpb24gPSB7Y21Ob1Byb2ZpbGVCYXNlLCB7 MCwwLDB9fTsNIA0tdm9pZCByZXN0b3JlQ29sb3JTcGFjZShpbnQgaWdub3JlZCkNK3ZvaWQgcmVz dG9yZU1haW5EaXNwbGF5Q29sb3JQcm9maWxlKGludCBpZ25vcmVkKQ0gew0gICAgIC8vIFRoaXMg aXMgdXNlZCBhcyBhIHNpZ25hbCBoYW5kbGVyLCBhbmQgdGh1cyB0aGUgY2FsbHMgaW50byBDb2xv clN5bmMgYXJlIHVuc2FmZQ0gICAgIC8vIEJ1dCB3ZSBtaWdodCBhcyB3ZWxsIHRyeSB0byByZXN0 b3JlIHRoZSB1c2VyJ3MgY29sb3IgcHJvZmlsZSwgd2UncmUgZ29pbmcgZG93biBhbnl3YXkuLi4N LSAgICBpZiAoY2hhbmdlZENvbG9yUHJvZmlsZSkgew0tICAgICAgICBDTURldmljZVNjb3BlIHNj b3BlID0geyBrQ0ZQcmVmZXJlbmNlc0N1cnJlbnRVc2VyLCBrQ0ZQcmVmZXJlbmNlc0N1cnJlbnRI b3N0IH07DS0gICAgICAgIGludCBlcnJvciA9IENNU2V0RGV2aWNlUHJvZmlsZShjbURpc3BsYXlE ZXZpY2VDbGFzcywgY21EZWZhdWx0RGV2aWNlSUQsICZzY29wZSwgY21EZWZhdWx0UHJvZmlsZUlE LCAmY3VycmVudENvbG9yUHJvZmlsZUxvY2F0aW9uKTsNKyAgICBpZiAoc0luaXRpYWxQcm9maWxl TG9jYXRpb24ubG9jVHlwZSAhPSBjbU5vUHJvZmlsZUJhc2UpIHsNKyAgICAgICAgY29uc3QgQ01E ZXZpY2VTY29wZSBzY29wZSA9IHsga0NGUHJlZmVyZW5jZXNDdXJyZW50VXNlciwga0NGUHJlZmVy ZW5jZXNDdXJyZW50SG9zdCB9Ow0rICAgICAgICBpbnQgZXJyb3IgPSBDTVNldERldmljZVByb2Zp bGUoY21EaXNwbGF5RGV2aWNlQ2xhc3MsIGtDR0RpcmVjdE1haW5EaXNwbGF5LCAmc2NvcGUsIGNt RGVmYXVsdFByb2ZpbGVJRCwgJnNJbml0aWFsUHJvZmlsZUxvY2F0aW9uKTsNICAgICAgICAgaWYg KGVycm9yKQ0tICAgICAgICAgICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gcmV0b3JlIHBy ZXZpb3VzIGNvbG9yIHByb2ZpbGUhICBZb3UgbWF5IG5lZWQgdG8gb3BlbiBTeXN0ZW0gUHJlZmVy ZW5jZXMgOiBEaXNwbGF5cyA6IENvbG9yIGFuZCBtYW51YWxseSByZXN0b3JlIHlvdXIgY29sb3Ig c2V0dGluZ3MuICAoRXJyb3I6ICVpKSIsIGVycm9yKTsNLSAgICAgICAgY2hhbmdlZENvbG9yUHJv ZmlsZSA9IGZhbHNlOw0rICAgICAgICAgICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gcmVz dG9yZSBpbml0aWFsIGNvbG9yIHByb2ZpbGUgZm9yIG1haW4gZGlzcGxheSEgT3BlbiBTeXN0ZW0g UHJlZmVyZW5jZXMgPiBEaXNwbGF5cyA+IENvbG9yIGFuZCBtYW51YWxseSByZS1zZWxlY3QgdGhl IHByb2ZpbGUuICAoRXJyb3I6ICVpKSIsIGVycm9yKTsNKyAgICAgICAgc0luaXRpYWxQcm9maWxl TG9jYXRpb24ubG9jVHlwZSA9IGNtTm9Qcm9maWxlQmFzZTsNICAgICB9DSB9DSANLXN0YXRpYyB2 b2lkIGZhaWxlZEdldHRpbmdDdXJyZW50UHJvZmlsZShpbnQgZXJyb3IpDSt2b2lkIHNldHVwTWFp bkRpc3BsYXlDb2xvclByb2ZpbGUoKQ0gew0tICAgIGZwcmludGYoc3RkZXJyLCAiRmFpbGVkIHRv IGdldCBjdXJyZW50IGNvbG9yIHByb2ZpbGUuICBJIHdpbGwgbm90IGJlIGFibGUgdG8gcmVzdG9y ZSB5b3VyIGN1cnJlbnQgcHJvZmlsZSwgdGh1cyBJJ20gbm90IGNoYW5naW5nIGl0LiAgTWFueSBw aXhlbCB0ZXN0cyBtYXkgZmFpbCBhcyBhIHJlc3VsdC4gIChFcnJvcjogJWkpXG4iLCBlcnJvcik7 DS19DS0NLXN0YXRpYyB2b2lkIHNldERlZmF1bHRDb2xvclByb2ZpbGVUb1JHQigpDS17DS0gICAg Q01Qcm9maWxlUmVmIGdlbmVyaWNQcm9maWxlID0gKENNUHJvZmlsZVJlZilbW05TQ29sb3JTcGFj ZSBnZW5lcmljUkdCQ29sb3JTcGFjZV0gY29sb3JTeW5jUHJvZmlsZV07DS0gICAgQ01Qcm9maWxl TG9jYXRpb24gZ2VuZXJpY1Byb2ZpbGVMb2NhdGlvbjsNLSAgICBVSW50MzIgbG9jYXRpb25TaXpl ID0gc2l6ZW9mKGdlbmVyaWNQcm9maWxlTG9jYXRpb24pOw0tICAgIGludCBlcnJvciA9IE5DTUdl dFByb2ZpbGVMb2NhdGlvbihnZW5lcmljUHJvZmlsZSwgJmdlbmVyaWNQcm9maWxlTG9jYXRpb24s ICZsb2NhdGlvblNpemUpOw0tICAgIGlmIChlcnJvcikgew0tICAgICAgICBmYWlsZWRHZXR0aW5n Q3VycmVudFByb2ZpbGUoZXJyb3IpOw0tICAgICAgICByZXR1cm47DSsgICAgY29uc3QgQ01EZXZp Y2VTY29wZSBzY29wZSA9IHsga0NGUHJlZmVyZW5jZXNDdXJyZW50VXNlciwga0NGUHJlZmVyZW5j ZXNDdXJyZW50SG9zdCB9Ow0rICAgIGludCBlcnJvcjsNKyAgICANKyAgICBDTVByb2ZpbGVSZWYg cHJvZmlsZSA9IE5VTEw7DSsgICAgZXJyb3IgPSBDTUdldFByb2ZpbGVCeUFWSUQoa0NHRGlyZWN0 TWFpbkRpc3BsYXksICZwcm9maWxlKTsNKyAgICBpZiAoIWVycm9yKSB7DSsgICAgICAgIFVJbnQz MiBzaXplID0gc2l6ZW9mKENNUHJvZmlsZUxvY2F0aW9uKTsNKyAgICAgICAgZXJyb3IgPSBOQ01H ZXRQcm9maWxlTG9jYXRpb24ocHJvZmlsZSwgJnNJbml0aWFsUHJvZmlsZUxvY2F0aW9uLCAmc2l6 ZSk7DSsgICAgICAgIENNQ2xvc2VQcm9maWxlKHByb2ZpbGUpOw0gICAgIH0NLQ0tICAgIENNUHJv ZmlsZUxvY2F0aW9uIHByZXZpb3VzUHJvZmlsZUxvY2F0aW9uOw0tICAgIGVycm9yID0gQ01HZXRE ZXZpY2VQcm9maWxlKGNtRGlzcGxheURldmljZUNsYXNzLCBjbURlZmF1bHREZXZpY2VJRCwgY21E ZWZhdWx0UHJvZmlsZUlELCAmcHJldmlvdXNQcm9maWxlTG9jYXRpb24pOw0gICAgIGlmIChlcnJv cikgew0tICAgICAgICBmYWlsZWRHZXR0aW5nQ3VycmVudFByb2ZpbGUoZXJyb3IpOw0rICAgICAg ICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byByZXRyaWV2ZSBjdXJyZW50IGNvbG9yIHByb2Zp bGUgZm9yIG1haW4gZGlzcGxheSwgdGh1cyBpdCB3b24ndCBiZSBjaGFuZ2VkLiAgTWFueSBwaXhl bCB0ZXN0cyBtYXkgZmFpbCBhcyBhIHJlc3VsdC4gIChFcnJvcjogJWkpIiwgZXJyb3IpOw0rICAg ICAgICBzSW5pdGlhbFByb2ZpbGVMb2NhdGlvbi5sb2NUeXBlID0gY21Ob1Byb2ZpbGVCYXNlOw0g ICAgICAgICByZXR1cm47DSAgICAgfQ0rICAgIA0rICAgIENNUHJvZmlsZUxvY2F0aW9uIGxvY2F0 aW9uOw0rICAgIGxvY2F0aW9uLmxvY1R5cGUgPSBjbUZpbGVCYXNlZFByb2ZpbGU7DSsgICAgTlNV UkwqIHVybCA9IFtOU1VSTCBmaWxlVVJMV2l0aFBhdGg6W05TU3RyaW5nIHN0cmluZ1dpdGhVVEY4 U3RyaW5nOlBST0ZJTEVfUEFUSF1dOw0rICAgIEZTUmVmIGZzUmVmOw0rICAgIGlmICh1cmwgJiYg Q0ZVUkxHZXRGU1JlZigoQ0ZVUkxSZWYpdXJsLCAmZnNSZWYpKSB7DSsgICAgICAgIGVycm9yID0g RlNHZXRDYXRhbG9nSW5mbygmZnNSZWYsIDAsIE5VTEwsIE5VTEwsICZsb2NhdGlvbi51LmZpbGVM b2Muc3BlYywgTlVMTCk7DSsgICAgICAgIGlmKGVycm9yID09IG5vRXJyKQ0rICAgICAgICBlcnJv ciA9IENNU2V0RGV2aWNlUHJvZmlsZShjbURpc3BsYXlEZXZpY2VDbGFzcywga0NHRGlyZWN0TWFp bkRpc3BsYXksICZzY29wZSwgY21EZWZhdWx0UHJvZmlsZUlELCAmbG9jYXRpb24pOw0rICAgIH0N KyAgICBlbHNlDSsgICAgICAgIGVycm9yID0gLTE7DSANLSAgICBDTVByb2ZpbGVSZWYgcHJldmlv dXNQcm9maWxlOw0tICAgIGVycm9yID0gQ01PcGVuUHJvZmlsZSgmcHJldmlvdXNQcm9maWxlLCAm cHJldmlvdXNQcm9maWxlTG9jYXRpb24pOw0gICAgIGlmIChlcnJvcikgew0tICAgICAgICBmYWls ZWRHZXR0aW5nQ3VycmVudFByb2ZpbGUoZXJyb3IpOw0rICAgICAgICBmcHJpbnRmKHN0ZGVyciwg IkZhaWxlZCB0byBzZXQgY29sb3IgcHJvZmlsZSBmb3IgbWFpbiBkaXNwbGF5ISAgTWFueSBwaXhl bCB0ZXN0cyBtYXkgZmFpbCBhcyBhIHJlc3VsdC4gIChFcnJvcjogJWkpIiwgZXJyb3IpOw0rICAg ICAgICBzSW5pdGlhbFByb2ZpbGVMb2NhdGlvbi5sb2NUeXBlID0gY21Ob1Byb2ZpbGVCYXNlOw0g ICAgICAgICByZXR1cm47DSAgICAgfQ0tDS0gICAgQ0ZTdHJpbmdSZWYgcHJldmlvdXNQcm9maWxl TmFtZTsNLSAgICBDRlN0cmluZ1JlZiBnZW5lcmljUHJvZmlsZU5hbWU7DS0gICAgY2hhciBwcmV2 aW91c1Byb2ZpbGVOYW1lU3RyaW5nWzEwMjRdOw0tICAgIGNoYXIgZ2VuZXJpY1Byb2ZpbGVOYW1l U3RyaW5nWzEwMjRdOw0tICAgIENNQ29weVByb2ZpbGVEZXNjcmlwdGlvblN0cmluZyhwcmV2aW91 c1Byb2ZpbGUsICZwcmV2aW91c1Byb2ZpbGVOYW1lKTsNLSAgICBDTUNvcHlQcm9maWxlRGVzY3Jp cHRpb25TdHJpbmcoZ2VuZXJpY1Byb2ZpbGUsICZnZW5lcmljUHJvZmlsZU5hbWUpOw0tICAgIENG U3RyaW5nR2V0Q1N0cmluZyhwcmV2aW91c1Byb2ZpbGVOYW1lLCBwcmV2aW91c1Byb2ZpbGVOYW1l U3RyaW5nLCBzaXplb2YocHJldmlvdXNQcm9maWxlTmFtZVN0cmluZyksIGtDRlN0cmluZ0VuY29k aW5nVVRGOCk7DS0gICAgQ0ZTdHJpbmdHZXRDU3RyaW5nKGdlbmVyaWNQcm9maWxlTmFtZSwgZ2Vu ZXJpY1Byb2ZpbGVOYW1lU3RyaW5nLCBzaXplb2YocHJldmlvdXNQcm9maWxlTmFtZVN0cmluZyks IGtDRlN0cmluZ0VuY29kaW5nVVRGOCk7DS0gICAgQ0ZSZWxlYXNlKHByZXZpb3VzUHJvZmlsZU5h bWUpOw0tICAgIENGUmVsZWFzZShnZW5lcmljUHJvZmlsZU5hbWUpOw0tDS0gICAgQ01DbG9zZVBy b2ZpbGUocHJldmlvdXNQcm9maWxlKTsNLQ0tICAgIGZwcmludGYoc3RkZXJyLCAiXG5cbldBUk5J Tkc6IFRlbXBvcmFyaWx5IGNoYW5naW5nIHlvdXIgc3lzdGVtIGNvbG9yIHByb2ZpbGUgZnJvbSBc IiVzXCIgdG8gXCIlc1wiLlxuIiwgcHJldmlvdXNQcm9maWxlTmFtZVN0cmluZywgZ2VuZXJpY1By b2ZpbGVOYW1lU3RyaW5nKTsNKyAgICANKyAgICAvLyBPdGhlciBzaWduYWxzIGFyZSBoYW5kbGVk IGluIGluc3RhbGxTaWduYWxIYW5kbGVycygpIHdoaWNoIGFsc28gY2FsbHMgcmVzdG9yZU1haW5E aXNwbGF5Q29sb3JQcm9maWxlKCkNKyAgICBzaWduYWwoU0lHSU5ULCByZXN0b3JlTWFpbkRpc3Bs YXlDb2xvclByb2ZpbGUpOw0rICAgIHNpZ25hbChTSUdIVVAsIHJlc3RvcmVNYWluRGlzcGxheUNv bG9yUHJvZmlsZSk7DSsgICAgc2lnbmFsKFNJR1RFUk0sIHJlc3RvcmVNYWluRGlzcGxheUNvbG9y UHJvZmlsZSk7DSsgICAgDSsgICAgZnByaW50ZihzdGRlcnIsICJcblxuV0FSTklORzogVGVtcG9y YXJpbHkgY2hhbmdpbmcgdGhlIG1haW4gZGlzcGxheSBjb2xvciBwcm9maWxlIHRvIFwiJXNcIjog dGhlIGNvbG9ycyBvbiB5b3VyIHNjcmVlbiB3aWxsIGNoYW5nZSBmb3IgdGhlIGR1cmF0aW9uIG9m IHRoZSB0ZXN0aW5nLlxuIiwgUFJPRklMRV9QQVRIKTsNICAgICBmcHJpbnRmKHN0ZGVyciwgIlRo aXMgYWxsb3dzIHRoZSBXZWJLaXQgcGl4ZWwtYmFzZWQgcmVncmVzc2lvbiB0ZXN0cyB0byBoYXZl IGNvbnNpc3RlbnQgY29sb3IgdmFsdWVzIGFjcm9zcyBhbGwgbWFjaGluZXMuXG4iKTsNLSAgICBm cHJpbnRmKHN0ZGVyciwgIlRoZSBjb2xvcnMgb24geW91ciBzY3JlZW4gd2lsbCBjaGFuZ2UgZm9y IHRoZSBkdXJhdGlvbiBvZiB0aGUgdGVzdGluZy5cblxuIik7DS0NLSAgICBDTURldmljZVNjb3Bl IHNjb3BlID0geyBrQ0ZQcmVmZXJlbmNlc0N1cnJlbnRVc2VyLCBrQ0ZQcmVmZXJlbmNlc0N1cnJl bnRIb3N0IH07DS0gICAgaWYgKChlcnJvciA9IENNU2V0RGV2aWNlUHJvZmlsZShjbURpc3BsYXlE ZXZpY2VDbGFzcywgY21EZWZhdWx0RGV2aWNlSUQsICZzY29wZSwgY21EZWZhdWx0UHJvZmlsZUlE LCAmZ2VuZXJpY1Byb2ZpbGVMb2NhdGlvbikpKSB7DS0gICAgICAgIGZwcmludGYoc3RkZXJyLCAi RmFpbGVkIHRvIHNldCBjb2xvciBwcm9maWxlIHRvIFwiJXNcIiEgTWFueSBwaXhlbCB0ZXN0cyB3 aWxsIGZhaWwgYXMgYSByZXN1bHQuICAoRXJyb3I6ICVpKSIsDS0gICAgICAgICAgICBnZW5lcmlj UHJvZmlsZU5hbWVTdHJpbmcsIGVycm9yKTsNLSAgICB9IGVsc2Ugew0tICAgICAgICBjdXJyZW50 Q29sb3JQcm9maWxlTG9jYXRpb24gPSBwcmV2aW91c1Byb2ZpbGVMb2NhdGlvbjsNLSAgICAgICAg Y2hhbmdlZENvbG9yUHJvZmlsZSA9IHRydWU7DS0gICAgICAgIHNpZ25hbChTSUdJTlQsIHJlc3Rv cmVDb2xvclNwYWNlKTsNLSAgICAgICAgc2lnbmFsKFNJR0hVUCwgcmVzdG9yZUNvbG9yU3BhY2Up Ow0tICAgICAgICBzaWduYWwoU0lHVEVSTSwgcmVzdG9yZUNvbG9yU3BhY2UpOw0tICAgIH0NLX0N LQ0tdm9pZCBpbml0aWFsaXplQ29sb3JTcGFjZUFuZFNjcmVlQnVmZmVyRm9yUGl4ZWxUZXN0cygp DS17DS0gICAgc2V0RGVmYXVsdENvbG9yUHJvZmlsZVRvUkdCKCk7DS0gICAgc2NyZWVuQ2FwdHVy ZUJ1ZmZlciA9ICh1bnNpZ25lZCBjaGFyICopbWFsbG9jKG1heFZpZXdIZWlnaHQgKiBtYXhWaWV3 V2lkdGggKiA0KTsNLSAgICBzaGFyZWRDb2xvclNwYWNlID0gQ0dDb2xvclNwYWNlQ3JlYXRlRGV2 aWNlUkdCKCk7DS19DS0NLS8vIERlY2xhcmVkIGluIFBpeGVsRHVtcFN1cHBvcnRDRy5oDS0NLVJl dGFpblB0cjxDR0NvbnRleHRSZWY+IGdldEJpdG1hcENvbnRleHRGcm9tV2ViVmlldygpDS17DS0g ICAgTlNTaXplIHdlYlZpZXdTaXplID0gW1ttYWluRnJhbWUgd2ViVmlld10gZnJhbWVdLnNpemU7 DS0gICAgcmV0dXJuIFJldGFpblB0cjxDR0NvbnRleHRSZWY+KEFkb3B0Q0YsIENHQml0bWFwQ29u dGV4dENyZWF0ZShzY3JlZW5DYXB0dXJlQnVmZmVyLCBzdGF0aWNfY2FzdDxzaXplX3Q+KHdlYlZp ZXdTaXplLndpZHRoKSwgc3RhdGljX2Nhc3Q8c2l6ZV90Pih3ZWJWaWV3U2l6ZS5oZWlnaHQpLCA4 LCBzdGF0aWNfY2FzdDxzaXplX3Q+KHdlYlZpZXdTaXplLndpZHRoKSAqIDQsIHNoYXJlZENvbG9y U3BhY2UsIGtDR0JpdG1hcEJ5dGVPcmRlcjMySG9zdCB8IGtDR0ltYWdlQWxwaGFQcmVtdWx0aXBs aWVkTGFzdCkpOw0gfQ0gDS12b2lkIHBhaW50V2ViVmlldyhDR0NvbnRleHRSZWYgY29udGV4dCkN Ky8vIFdlYktpdCB2aWV3IHNlZW1zIHRvIGlnbm9yZSB0aGUgY29sb3JzcGFjZSBvZiB0aGUgZGVz dGluYXRpb24gQ0dDb250ZXh0IGJ1dCBpbnN0ZWFkIHJlbmRlciB1c2luZw0rLy8gdGhlIG9uZSBv ZiB0aGUgbWFpbiBkaXNwbGF5Lg0rLy8gDSsvLyBUaGlzIGltcGxpZXMgd2UgaGF2ZSB0byB0ZW1w b3JhcmlseSBjaGFuZ2UgdGhlIHByb2ZpbGUgb2YgdGhlIG1haW4gZGlzcGxheSB0byB0aGUgY29s b3JzcGFjZSB3ZSB3YW50DSsvLyB0byByZW5kZXIgaW50by4NKy8vIA0rLy8gVGhlbiB3ZSBjcmVh dGUgdGhlIENHQ29udGV4dCBpbiBEZXZpY2VSR0IgY29sb3JzcGFjZSB3aGljaCBiYXNpY2FsbHkg bWVhbnMgc2FtZSBhcyBtYWluIGRpc3BsYXkNKy8vIGNvbG9yc3BhY2UgKG9uIDEwLjUgYW5kIGxh dGVyLCB3ZSBjb3VsZCBpbnN0ZWFkIHVzZSB0aGUgbmV3IENHRGlzcGxheUNvcHlDb2xvclNwYWNl KCkgQVBJKS4NKy8vIA0rLy8gV2UgYWxzbyBuZWVkIHRvIGVuc3VyZSBmb250IHNtb290aGluZyAo aS5lLiBMQ0QgQW50aWFsaWFzaW5nKSBoYXMgYmVlbiBkaXNhYmxlZCwgYnV0DSsvLyBOU0dyYXBo aWNzQ29udGV4dCBzZWVtcyB0byBiZSBvdmVycmlkaW5nIENHQ29udGV4dFNldFNob3VsZFNtb290 aEZvbnRzKCkuLi4NKy8vIA0rLy8gU2luY2UgdGhlcmUncyBubyBwdWJsaWMgQVBJIHRvIGZvcmNl IGRpc2FibGUgZm9udCBzbW9vdGhpbmcsIHdlIHdvcmsgYXJvdW5kIGl0IGJ5IHVzaW5nIGENKy8v ICdiaXRtYXBJbmZvJyBpbmNvbXBhdGlibGUgd2l0aCBmb250IHNtb290aGluZyBpLmUuIG5vdCBt YXRjaGluZyBwaXhlbHMgb24gc2NyZWVuIGFzDSsvLyAoa0NHSW1hZ2VBbHBoYVByZW11bHRpcGxp ZWRGaXJzdCB8IGtDR0JpdG1hcEJ5dGVPcmRlcjMySG9zdCkuDSsvLyANKy8vIEZpbmFsbHksIHdl IHdhbnQgdGhlIHJlbmRlcmVkIGJpdG1hcCB0byBhbHdheXMgYmUgaW4gcHJlbXVsdGlwbGllZCBS R0JBOCB0byBlbnN1cmUgZW5kaWFuDSsvLyBpbmRlcGVuZGVuY3kgYW5kIGhhdmUgY29uc2lzdGVu dCBNRDUgaGFzaGVzDSsNK1Bhc3NSZWZQdHI8Qml0bWFwQ29udGV4dD4gZ2V0Qml0bWFwQ29udGV4 dEZyb21XZWJWaWV3KGJvb2wgaW5jcmVtZW50YWxSZXBhaW50LCBib29sIHN3ZWVwSG9yaXpvbnRh bGx5LCBib29sIGRyYXdTZWxlY3Rpb25SZWN0KQ0gew0tICAgIFJldGFpblB0cjxOU0dyYXBoaWNz Q29udGV4dD4gc2F2ZWRDb250ZXh0ID0gW05TR3JhcGhpY3NDb250ZXh0IGN1cnJlbnRDb250ZXh0 XTsNLQ0tICAgIE5TR3JhcGhpY3NDb250ZXh0KiBuc0NvbnRleHQgPSBbTlNHcmFwaGljc0NvbnRl eHQgZ3JhcGhpY3NDb250ZXh0V2l0aEdyYXBoaWNzUG9ydDpjb250ZXh0IGZsaXBwZWQ6Tk9dOw0t ICAgIFtOU0dyYXBoaWNzQ29udGV4dCBzZXRDdXJyZW50Q29udGV4dDpuc0NvbnRleHRdOw0tDSAg ICAgV2ViVmlldyogdmlldyA9IFttYWluRnJhbWUgd2ViVmlld107DS0gICAgW3ZpZXcgZGlzcGxh eUlmTmVlZGVkXTsNLSAgICBbdmlldyBsb2NrRm9jdXNdOw0tICAgIE5TQml0bWFwSW1hZ2VSZXAg KmltYWdlUmVwID0gW1tOU0JpdG1hcEltYWdlUmVwIGFsbG9jXSBpbml0V2l0aEZvY3VzZWRWaWV3 UmVjdDpbdmlldyBmcmFtZV1dOw0tICAgIFt2aWV3IHVubG9ja0ZvY3VzXTsNLSAgICBbaW1hZ2VS ZXAgZHJhd107DS0gICAgW2ltYWdlUmVwIHJlbGVhc2VdOw0tDS0gICAgW05TR3JhcGhpY3NDb250 ZXh0IHNldEN1cnJlbnRDb250ZXh0OnNhdmVkQ29udGV4dC5nZXQoKV07DS19DS0NLXZvaWQgcmVw YWludFdlYlZpZXcoQ0dDb250ZXh0UmVmIGNvbnRleHQsIGJvb2wgaG9yaXpvbnRhbCkNLXsNLSAg ICBSZXRhaW5QdHI8TlNHcmFwaGljc0NvbnRleHQ+IHNhdmVkQ29udGV4dCA9IFtOU0dyYXBoaWNz Q29udGV4dCBjdXJyZW50Q29udGV4dF07DS0NLSAgICBOU0dyYXBoaWNzQ29udGV4dCogbnNDb250 ZXh0ID0gW05TR3JhcGhpY3NDb250ZXh0IGdyYXBoaWNzQ29udGV4dFdpdGhHcmFwaGljc1BvcnQ6 Y29udGV4dCBmbGlwcGVkOk5PXTsNLSAgICBbTlNHcmFwaGljc0NvbnRleHQgc2V0Q3VycmVudENv bnRleHQ6bnNDb250ZXh0XTsNLQ0tICAgIFdlYlZpZXcgKnZpZXcgPSBbbWFpbkZyYW1lIHdlYlZp ZXddOw0gICAgIE5TU2l6ZSB3ZWJWaWV3U2l6ZSA9IFt2aWV3IGZyYW1lXS5zaXplOw0tDS0gICAg aWYgKGhvcml6b250YWwpIHsNLSAgICAgICAgZm9yIChOU1JlY3QgY29sdW1uID0gTlNNYWtlUmVj dCgwLCAwLCAxLCB3ZWJWaWV3U2l6ZS5oZWlnaHQpOyBjb2x1bW4ub3JpZ2luLnggPCB3ZWJWaWV3 U2l6ZS53aWR0aDsgY29sdW1uLm9yaWdpbi54KyspDS0gICAgICAgICAgICBbdmlldyBkaXNwbGF5 UmVjdElnbm9yaW5nT3BhY2l0eTpjb2x1bW4gaW5Db250ZXh0Om5zQ29udGV4dF07DS0gICAgfSBl bHNlIHsNLSAgICAgICAgZm9yIChOU1JlY3QgbGluZSA9IE5TTWFrZVJlY3QoMCwgMCwgd2ViVmll d1NpemUud2lkdGgsIDEpOyBsaW5lLm9yaWdpbi55IDwgd2ViVmlld1NpemUuaGVpZ2h0OyBsaW5l Lm9yaWdpbi55KyspDS0gICAgICAgICAgICBbdmlldyBkaXNwbGF5UmVjdElnbm9yaW5nT3BhY2l0 eTpsaW5lIGluQ29udGV4dDpuc0NvbnRleHRdOw0rICAgIHNpemVfdCBwaXhlbHNXaWRlID0gc3Rh dGljX2Nhc3Q8c2l6ZV90Pih3ZWJWaWV3U2l6ZS53aWR0aCk7DSsgICAgc2l6ZV90IHBpeGVsc0hp Z2ggPSBzdGF0aWNfY2FzdDxzaXplX3Q+KHdlYlZpZXdTaXplLmhlaWdodCk7DSsgICAgc2l6ZV90 IHJvd0J5dGVzID0gKDQgKiBwaXhlbHNXaWRlICsgNjMpICYgfjYzOyAvLyBVc2UgYSBtdWx0aXBs ZSBvZiA2NCBieXRlcyB0byBpbXByb3ZlIENHIHBlcmZvcm1hbmNlcw0rDSsgICAgdm9pZCogYnVm ZmVyID0gY2FsbG9jKHBpeGVsc0hpZ2gsIHJvd0J5dGVzKTsNKyAgICBpZiAoIWJ1ZmZlcikNKyAg ICAgICAgcmV0dXJuIDA7DSsgICAgDSsgICAgUmV0YWluUHRyPENHQ29sb3JTcGFjZVJlZj4gY29s b3JTcGFjZShBZG9wdENGLCBDR0NvbG9yU3BhY2VDcmVhdGVEZXZpY2VSR0IoKSk7DSsgICAgQ0dD b250ZXh0UmVmIGNvbnRleHQgPSBDR0JpdG1hcENvbnRleHRDcmVhdGUoYnVmZmVyLCBwaXhlbHNX aWRlLCBwaXhlbHNIaWdoLCA4LCByb3dCeXRlcywgY29sb3JTcGFjZS5nZXQoKSwga0NHSW1hZ2VB bHBoYVByZW11bHRpcGxpZWRMYXN0IHwga0NHQml0bWFwQnl0ZU9yZGVyMzJCaWcpOw0rICAgIGlm ICghY29udGV4dCkgew0rICAgICAgICBmcmVlKGJ1ZmZlcik7DSsgICAgICAgIHJldHVybiAwOw0g ICAgIH0NIA0tICAgIFtOU0dyYXBoaWNzQ29udGV4dCBzZXRDdXJyZW50Q29udGV4dDpzYXZlZENv bnRleHQuZ2V0KCldOw0tfQ0tDS1DR1JlY3QgZ2V0U2VsZWN0aW9uUmVjdCgpDS17DS0gICAgTlNW aWV3ICpkb2N1bWVudFZpZXcgPSBbW21haW5GcmFtZSBmcmFtZVZpZXddIGRvY3VtZW50Vmlld107 DS0gICAgaWYgKFtkb2N1bWVudFZpZXcgY29uZm9ybXNUb1Byb3RvY29sOkBwcm90b2NvbChXZWJE b2N1bWVudFNlbGVjdGlvbildKSB7DS0gICAgICAgIE5TUmVjdCByZWN0ID0gW2RvY3VtZW50Vmll dyBjb252ZXJ0UmVjdDpbKGlkIDxXZWJEb2N1bWVudFNlbGVjdGlvbj4pZG9jdW1lbnRWaWV3IHNl bGVjdGlvblJlY3RdIGZyb21WaWV3Om5pbF07DS0gICAgICAgIHJldHVybiBDR1JlY3RNYWtlKHJl Y3Qub3JpZ2luLngsIHJlY3Qub3JpZ2luLnksIHJlY3Quc2l6ZS53aWR0aCwgcmVjdC5zaXplLmhl aWdodCk7DSsgICAgLy8gVGhlIEJpdG1hcENvbnRleHQga2VlcHMgdGhlIENHQ29udGV4dFJlZiBh bmQgdGhlIHBpeGVsIGJ1ZmZlciBhbGl2ZQ0rICAgIFJlZlB0cjxCaXRtYXBDb250ZXh0PiBiaXRt YXBDb250ZXh0ID0gQml0bWFwQ29udGV4dDo6Y3JlYXRlKGJ1ZmZlciwgY29udGV4dCk7DSsgICAg DSsgICAgTlNHcmFwaGljc0NvbnRleHQqIG5zQ29udGV4dCA9IFtOU0dyYXBoaWNzQ29udGV4dCBn cmFwaGljc0NvbnRleHRXaXRoR3JhcGhpY3NQb3J0OmNvbnRleHQgZmxpcHBlZDpOT107DSsgICAg QVNTRVJUKG5zQ29udGV4dCk7DSsgICAgDSsgICAgaWYgKGluY3JlbWVudGFsUmVwYWludCkgew0r ICAgICAgICBpZiAoc3dlZXBIb3Jpem9udGFsbHkpIHsNKyAgICAgICAgICAgIGZvciAoTlNSZWN0 IGNvbHVtbiA9IE5TTWFrZVJlY3QoMCwgMCwgMSwgd2ViVmlld1NpemUuaGVpZ2h0KTsgY29sdW1u Lm9yaWdpbi54IDwgd2ViVmlld1NpemUud2lkdGg7IGNvbHVtbi5vcmlnaW4ueCsrKQ0rICAgICAg ICAgICAgICAgIFt2aWV3IGRpc3BsYXlSZWN0SWdub3JpbmdPcGFjaXR5OmNvbHVtbiBpbkNvbnRl eHQ6bnNDb250ZXh0XTsNKyAgICAgICAgfSBlbHNlIHsNKyAgICAgICAgICAgIGZvciAoTlNSZWN0 IGxpbmUgPSBOU01ha2VSZWN0KDAsIDAsIHdlYlZpZXdTaXplLndpZHRoLCAxKTsgbGluZS5vcmln aW4ueSA8IHdlYlZpZXdTaXplLmhlaWdodDsgbGluZS5vcmlnaW4ueSsrKQ0rICAgICAgICAgICAg ICAgIFt2aWV3IGRpc3BsYXlSZWN0SWdub3JpbmdPcGFjaXR5OmxpbmUgaW5Db250ZXh0Om5zQ29u dGV4dF07DSsgICAgICAgIH0NICAgICB9DS0NLSAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsNLSAg ICByZXR1cm4gQ0dSZWN0WmVybzsNKyAgICBlbHNlDSsgICAgICAgIFt2aWV3IGRpc3BsYXlSZWN0 SWdub3JpbmdPcGFjaXR5Ok5TTWFrZVJlY3QoMCwgMCwgd2ViVmlld1NpemUud2lkdGgsIHdlYlZp ZXdTaXplLmhlaWdodCkgaW5Db250ZXh0Om5zQ29udGV4dF07DSsgICAgDSsgICAgaWYgKGRyYXdT ZWxlY3Rpb25SZWN0KSB7DSsgICAgICAgIE5TVmlldyogZG9jdW1lbnRWaWV3ID0gW1ttYWluRnJh bWUgZnJhbWVWaWV3XSBkb2N1bWVudFZpZXddOw0rICAgICAgICBpZiAoW2RvY3VtZW50VmlldyBj b25mb3Jtc1RvUHJvdG9jb2w6QHByb3RvY29sKFdlYkRvY3VtZW50U2VsZWN0aW9uKV0pIHsNKyAg ICAgICAgICAgIE5TUmVjdCByZWN0ID0gW2RvY3VtZW50VmlldyBjb252ZXJ0UmVjdDpbKGlkIDxX ZWJEb2N1bWVudFNlbGVjdGlvbj4pZG9jdW1lbnRWaWV3IHNlbGVjdGlvblJlY3RdIGZyb21WaWV3 Om5pbF07DSsgICAgICAgICAgICANKyAgICAgICAgICAgIENHQ29udGV4dFNhdmVHU3RhdGUoY29u dGV4dCk7DSsgICAgICAgICAgICBDR0NvbnRleHRTZXRMaW5lV2lkdGgoY29udGV4dCwgMS4wKTsN KyAgICAgICAgICAgIENHQ29udGV4dFNldFJHQlN0cm9rZUNvbG9yKGNvbnRleHQsIDEuMCwgMC4w LCAwLjAsIDEuMCk7DSsgICAgICAgICAgICBDR0NvbnRleHRTdHJva2VSZWN0KGNvbnRleHQsIENH UmVjdE1ha2UocmVjdC5vcmlnaW4ueCwgcmVjdC5vcmlnaW4ueSwgcmVjdC5zaXplLndpZHRoLCBy ZWN0LnNpemUuaGVpZ2h0KSk7DSsgICAgICAgICAgICBDR0NvbnRleHRSZXN0b3JlR1N0YXRlKGNv bnRleHQpOw0rICAgICAgICB9DSsgICAgICAgIGVsc2UNKyAgICAgICAgICAgIEFTU0VSVF9OT1Rf UkVBQ0hFRCgpOw0rICAgIH0NKyAgICANKyAgICByZXR1cm4gYml0bWFwQ29udGV4dC5yZWxlYXNl KCk7DSB9DWRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJl bmRlclRyZWUuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJU cmVlLmNwcA1pbmRleCA5M2RiMWQ5Li43NmYxNjg3IDEwMDY0NA0tLS0gYS9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwDSsrKyBiL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHANQEAgLTc2LDcgKzc2LDcgQEAgc3Rh dGljIGJvb2wgbGVha0NoZWNraW5nID0gZmFsc2U7DSBzdGF0aWMgYm9vbCB0aHJlYWRlZCA9IGZh bHNlOw0gc3RhdGljIFJldGFpblB0cjxDRlN0cmluZ1JlZj4gcGVyc2lzdGVudFVzZXJTdHlsZVNo ZWV0TG9jYXRpb247DSANLXN0YXRpYyBjb25zdCBjaGFyKiBjdXJyZW50VGVzdDsNK3N0YXRpYyBz dGQ6OnN0cmluZyBnQ3VycmVudFRlc3Q7DSANIHZvbGF0aWxlIGJvb2wgZG9uZTsNIC8vIFRoaXMg aXMgdGhlIHRvcG1vc3QgZnJhbWUgdGhhdCBpcyBsb2FkaW5nLCBkdXJpbmcgYSBnaXZlbiBsb2Fk LCBvciBuaWwgd2hlbiBubyBsb2FkIGlzIA1AQCAtNTYwLDcgKzU2MCw3IEBAIHZvaWQgZHVtcCgp DSAgICAgICAgICAgICB3c3RyaW5nIHJlc3VsdCA9IGR1bXBGcmFtZXNBc1RleHQoZnJhbWUpOw0g ICAgICAgICAgICAgcmVzdWx0U3RyaW5nID0gU3lzQWxsb2NTdHJpbmdMZW4ocmVzdWx0LmRhdGEo KSwgcmVzdWx0LnNpemUoKSk7DSAgICAgICAgIH0gZWxzZSB7DS0gICAgICAgICAgICBib29sIGlz U1ZHVzNDVGVzdCA9IHN0cnN0cihjdXJyZW50VGVzdCwgInN2Z1xcVzNDLVNWRy0xLjEiKTsNKyAg ICAgICAgICAgIGJvb2wgaXNTVkdXM0NUZXN0ID0gKGdDdXJyZW50VGVzdC5maW5kKCJzdmdcXFcz Qy1TVkctMS4xIikgIT0gc3RyaW5nOjpucG9zKTsNICAgICAgICAgICAgIHVuc2lnbmVkIHdpZHRo Ow0gICAgICAgICAgICAgdW5zaWduZWQgaGVpZ2h0Ow0gICAgICAgICAgICAgaWYgKGlzU1ZHVzND VGVzdCkgew1AQCAtNjA4LDcgKzYwOCw3IEBAIHZvaWQgZHVtcCgpDSAgICAgICAgIGlmIChnTGF5 b3V0VGVzdENvbnRyb2xsZXItPmR1bXBBc1RleHQoKSB8fCBnTGF5b3V0VGVzdENvbnRyb2xsZXIt PmR1bXBET01Bc1dlYkFyY2hpdmUoKSB8fCBnTGF5b3V0VGVzdENvbnRyb2xsZXItPmR1bXBTb3Vy Y2VBc1dlYkFyY2hpdmUoKSkNICAgICAgICAgICAgIHByaW50ZigiI0VPRlxuIik7DSAgICAgICAg IGVsc2UNLSAgICAgICAgICAgIGR1bXBXZWJWaWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4cGVj dGVkKGN1cnJlbnRUZXN0LCBkdW1wQWxsUGl4ZWxzKTsNKyAgICAgICAgICAgIGR1bXBXZWJWaWV3 QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4cGVjdGVkKGdMYXlvdXRUZXN0Q29udHJvbGxlci0+ZXhw ZWN0ZWRQaXhlbEhhc2goKSk7DSAgICAgICAgIGZmbHVzaChzdGRvdXQpOw0gICAgIH0NIA1AQCAt Njk0LDcgKzY5NCw3IEBAIHN0YXRpYyB2b2lkIHJ1blRlc3QoY29uc3QgY2hhciogcGF0aE9yVVJM KQ0gDSAgICAgQ0ZSZWxlYXNlKHVybCk7DSANLSAgICBjdXJyZW50VGVzdCA9IHBhdGhPclVSTDsN KyAgICBnQ3VycmVudFRlc3QgPSBwYXRoT3JVUkw7DSANICAgICA6OmdMYXlvdXRUZXN0Q29udHJv bGxlciA9IG5ldyBMYXlvdXRUZXN0Q29udHJvbGxlcihmYWxzZSwgZmFsc2UpOw0gICAgIGRvbmUg PSBmYWxzZTsNZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9QaXhl bER1bXBTdXBwb3J0V2luLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9QaXhl bER1bXBTdXBwb3J0V2luLmNwcA1pbmRleCBmNmRkODJkLi42YzcxOTFlIDEwMDY0NA0tLS0gYS9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vUGl4ZWxEdW1wU3VwcG9ydFdpbi5jcHANKysr IGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL1BpeGVsRHVtcFN1cHBvcnRXaW4uY3Bw DUBAIC0zMyw3ICszMyw3IEBADSAjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4NICNpbmNsdWRl IDx3dGYvUmV0YWluUHRyLmg+DSANLVJldGFpblB0cjxDR0NvbnRleHRSZWY+IGdldEJpdG1hcENv bnRleHRGcm9tV2ViVmlldygpDStQYXNzUmVmUHRyPEJpdG1hcENvbnRleHQ+IGdldEJpdG1hcENv bnRleHRGcm9tV2ViVmlldyhib29sIGluY3JlbWVudGFsUmVwYWludCwgYm9vbCBzd2VlcEhvcml6 b250YWxseSwgYm9vbCBkcmF3U2VsZWN0aW9uUmVjdCkNIHsNICAgICBSRUNUIGZyYW1lOw0gICAg IGlmICghR2V0V2luZG93UmVjdCh3ZWJWaWV3V2luZG93LCAmZnJhbWUpKQ1AQCAtNDcsOCArNDcs NiBAQCBSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPiBnZXRCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXco KQ0gICAgIGJtcC5ibWlIZWFkZXIuYmlCaXRDb3VudCA9IDMyOw0gICAgIGJtcC5ibWlIZWFkZXIu YmlDb21wcmVzc2lvbiA9IEJJX1JHQjsNIA0tICAgIC8vIEZJWE1FOiBDdXJyZW50bHkgd2UgbGVh ayB0aGlzIEhCSVRNQVAgYmVjYXVzZSB3ZSBkb24ndCBoYXZlIGEgZ29vZCB3YXkNLSAgICAvLyB0 byBkZXN0cm95IGl0IHdoZW4gdGhlIENHQml0bWFwQ29udGV4dCBnZXRzIGRlc3Ryb3llZC4NICAg ICB2b2lkKiBiaXRzID0gMDsNICAgICBIQklUTUFQIGJpdG1hcCA9IENyZWF0ZURJQlNlY3Rpb24o MCwgJmJtcCwgRElCX1JHQl9DT0xPUlMsICZiaXRzLCAwLCAwKTsNIA1AQCAtNjIsNiArNjAsOCBA QCBSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPiBnZXRCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoKQ0g ICAgIEFTU0VSVChpbmZvLmJtQml0c1BpeGVsID09IDMyKTsNIA0gICAgIFJldGFpblB0cjxDR0Nv bG9yU3BhY2VSZWY+IGNvbG9yU3BhY2UoQWRvcHRDRiwgQ0dDb2xvclNwYWNlQ3JlYXRlRGV2aWNl UkdCKCkpOw0tICAgIHJldHVybiBSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPihBZG9wdENGLCBDR0Jp dG1hcENvbnRleHRDcmVhdGUoaW5mby5ibUJpdHMsIGluZm8uYm1XaWR0aCwgaW5mby5ibUhlaWdo dCwgOCwNLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlu Zm8uYm1XaWR0aEJ5dGVzLCBjb2xvclNwYWNlLmdldCgpLCBrQ0dCaXRtYXBCeXRlT3JkZXIzMkxp dHRsZSB8IGtDR0ltYWdlQWxwaGFQcmVtdWx0aXBsaWVkRmlyc3QpKTsNKyAgICBDR0NvbnRleHRS ZWYgY29udGV4dCA9IENHQml0bWFwQ29udGV4dENyZWF0ZShpbmZvLmJtQml0cywgaW5mby5ibVdp ZHRoLCBpbmZvLmJtSGVpZ2h0LCA4LA0rICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgaW5mby5ibVdpZHRoQnl0ZXMsIGNvbG9yU3BhY2UuZ2V0KCksIGtDR0Jp dG1hcEJ5dGVPcmRlcjMyTGl0dGxlIHwga0NHSW1hZ2VBbHBoYVByZW11bHRpcGxpZWRGaXJzdCk7 DSsNKyAgICByZXR1cm4gQml0bWFwQ29udGV4dDo6Y3JlYXRlKGJpdG1hcCwgY29udGV4dCk7DSB9 DWRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3J1bi13ZWJraXQtdGVzdHMgYi9XZWJL aXRUb29scy9TY3JpcHRzL3J1bi13ZWJraXQtdGVzdHMNaW5kZXggZmI2ZTlkOS4uODRmZjFkYSAx MDA3NTUNLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy9ydW4td2Via2l0LXRlc3RzDSsrKyBiL1dl YktpdFRvb2xzL1NjcmlwdHMvcnVuLXdlYmtpdC10ZXN0cw1AQCAtNTUzLDcgKzU1MywyMiBAQCBm b3IgbXkgJHRlc3QgKEB0ZXN0cykgew0gICAgICAgICB9IGVsc2Ugew0gICAgICAgICAgICAgJHRl c3RQYXRoID0gY2Fub25wYXRoKCR0ZXN0UGF0aCk7DSAgICAgICAgIH0NLSAgICAgICAgcHJpbnQg T1VUICIkdGVzdFBhdGhcbiI7DSsgICAgICAgIA0rICAgICAgICBpZiAoJHBpeGVsVGVzdHMgJiYg ISRyZXNldFJlc3VsdHMpIHsNKyAgICAgICAgICAgIG15ICRleHBlY3RlZFBpeGVsRGlyID0gZXhw ZWN0ZWREaXJlY3RvcnlGb3JUZXN0KCRiYXNlLCAwLCAicG5nIik7DSsgICAgICAgICAgICAjIFRy eSB0byByZWFkIGV4cGVjdGVkIGhhc2ggZmlsZQ0rICAgICAgICAgICAgaWYgKG9wZW4gRVhQRUNU RURIQVNILCAiJGV4cGVjdGVkUGl4ZWxEaXIvJGJhc2UtJGV4cGVjdGVkVGFnLmNoZWNrc3VtIikg ew0rICAgICAgICAgICAgICAgIG15ICRleHBlY3RlZEhhc2ggPSA8RVhQRUNURURIQVNIPjsNKyAg ICAgICAgICAgICAgICBjaG9tcCgkZXhwZWN0ZWRIYXNoKTsNKyAgICAgICAgICAgICAgICBjbG9z ZSBFWFBFQ1RFREhBU0g7DSsgICAgICAgICAgICAgICAgIyBTZW5kIHRlc3R8aGFzaCB0byB0aGUg dG9vbA0rICAgICAgICAgICAgICAgIHByaW50IE9VVCAiJHRlc3RQYXRofCRleHBlY3RlZEhhc2hc biI7DSsgICAgICAgICAgICB9IGVsc2Ugew0rICAgICAgICAgICAgICAgIHByaW50IE9VVCAiJHRl c3RQYXRoXG4iOw0rICAgICAgICAgICAgfQ0rICAgICAgICB9IGVsc2Ugew0rICAgICAgICAgICAg cHJpbnQgT1VUICIkdGVzdFBhdGhcbiI7DSsgICAgICAgIH0NICAgICB9IGVsc2Ugew0gICAgICAg ICBvcGVuSFRUUERJZk5lZWRlZCgpOw0gICAgICAgICBpZiAoJHRlc3QgIX4gL15odHRwXC90ZXN0 c1wvbG9jYWxcLy8gJiYgJHRlc3QgIX4gL15odHRwXC90ZXN0c1wvc3NsXC8vICYmICR0ZXN0ICF+ IC9eaHR0cFwvdGVzdHNcL21lZGlhXC8vKSB7DUBAIC02NDEsNyArNjU2LDcgQEAgZm9yIG15ICR0 ZXN0IChAdGVzdHMpIHsNICAgICAgICAgICAgIGxhc3QgaWYgLyNFT0YvOw0gICAgICAgICAgICAg aWYgKC9BY3R1YWxIYXNoOiAoW2EtZjAtOV17MzJ9KS8pIHsNICAgICAgICAgICAgICAgICAkYWN0 dWFsSGFzaCA9ICQxOw0tICAgICAgICAgICAgfSBlbHNpZiAoL0Jhc2VsaW5lSGFzaDogKFthLWYw LTldezMyfSkvKSB7DSsgICAgICAgICAgICB9IGVsc2lmICgvRXhwZWN0ZWRIYXNoOiAoW2EtZjAt OV17MzJ9KS8pIHsNICAgICAgICAgICAgICAgICAkZXhwZWN0ZWRIYXNoID0gJDE7DSAgICAgICAg ICAgICB9IGVsc2lmICgvQ29udGVudC1MZW5ndGg6IChcZCspXHMqLykgew0gICAgICAgICAgICAg ICAgICRhY3R1YWxQTkdTaXplID0gJDE7DQ== 24166 2008-10-07 19:11:58 -0700 2008-10-08 12:15:42 -0700 Revised patch PATCH_FILE.txt text/plain 42560 pol ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCAxYmQwMWM1Li5mMjM0MTNlIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjIgQEAKKzIwMDgtMTAt MDcgIFBpZXJyZS1PbGl2aWVyIExhdG91ciAgPHBvbEBhcHBsZS5jb20+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVuZGVyaW5nIGlzIGFsd2F5cyBp biBwcmVtdWx0aXBsaWVkIFJHQkE4IHRvIGF2b2lkIGVuZGlhbiBpc3N1ZXMgYW5kIAorICAgICAg ICBndWFyYW50ZWUgY29uc2lzdGVudCBoYXNoIHZhbHVlcy4KKworICAgICAgICBFbnN1cmUgZm9u dCBzbW9vdGhpbmcgaXMgZGlzYWJsZWQuCisKKyAgICAgICAgRFJUIGNhbiBub3cgcmVjZWl2ZXMg dGhlIGV4cGVjdGVkIHBpeGVsIGhhc2ggYXMgYSBzdWZmaXggdG8gdGhlIHRlc3QgcGF0aAorICAg ICAgICBvciB1cmwgYXMgInBhdGh8aGFzaCIuCisKKyAgICAgICAgQXZvaWQgZHVtcGluZyB0aGUg UE5HIGltYWdlIHdoZW4gcnVubmluZyBwaXhlbCB0ZXN0cyBpZiB3ZSBjYW4gZGV0ZWN0IHRoYXQK KyAgICAgICAgdGhlIGNoZWNrc3VtIGlzIGVxdWFsIHRvIHRoZSBleHBlY3RlZCBjaGVja3N1bSAo Zm9yIHBlcmZvcm1hbmNlKS4KKworICAgICAgICBWYXJpb3VzIG1pbm9yIGltcHJvdmVtZW50cyAo YmV0dGVyIHNldHRpbmcgLyByZXN0b3Jpbmcgc2NyZWVuIGNvbG9yIHByb2ZpbGUsCisgICAgICAg IHVzZSBvZiBzdGQ6OnN0cmluZywgY2xlYW5lciB2aWV3IHNuYXBzaG90IGNvZGUsIGV0Yy4uLiku CisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMzIy CisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUGFzc1Jl ZlB0ci5oOiBBZGRlZC4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5nSGVhZGVy cy93dGYvUmVmUHRyLmg6IEFkZGVkLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRl c3RDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpMYXlvdXRU ZXN0Q29udHJvbGxlcik6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRy b2xsZXIuaDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjp0ZXN0UGF0aE9yVVJMKToK KyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpleHBlY3RlZFBpeGVsSGFzaCk6CisgICAg ICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6ZXhwZWN0ZWRQaXhlbEhhc2hLbm93bik6CisgICAg ICAgICogRHVtcFJlbmRlclRyZWUvUGl4ZWxEdW1wU3VwcG9ydC5oOgorICAgICAgICAqIER1bXBS ZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5jcHA6CisgICAgICAgIChwcmludFBORyk6 CisgICAgICAgIChjb21wdXRlTUQ1SGFzaFN0cmluZ0ZvckJpdG1hcENvbnRleHQpOgorICAgICAg ICAoZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0ZWQpOgorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5oOgorICAgICAgICAoQml0bWFw Q29udGV4dDo6Y3JlYXRlKToKKyAgICAgICAgKEJpdG1hcENvbnRleHQ6On5CaXRtYXBDb250ZXh0 KToKKyAgICAgICAgKEJpdG1hcENvbnRleHQ6OmNnQ29udGV4dCk6CisgICAgICAgIChCaXRtYXBD b250ZXh0OjpCaXRtYXBDb250ZXh0KToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMvRHVt cFJlbmRlclRyZWUubW06CisgICAgICAgIChzaG91bGRJZ25vcmVXZWJDb3JlTm9kZUxlYWtzKToK KyAgICAgICAgKHNldERlZmF1bHRzVG9Db25zaXN0ZW50VmFsdWVzRm9yVGVzdGluZyk6CisgICAg ICAgIChjcmFzaEhhbmRsZXIpOgorICAgICAgICAocHJlcGFyZUNvbnNpc3RlbnRUZXN0aW5nRW52 aXJvbm1lbnQpOgorICAgICAgICAoZHVtcFJlbmRlclRyZWUpOgorICAgICAgICAoc2l6ZVdlYlZp ZXdGb3JDdXJyZW50VGVzdCk6CisgICAgICAgIChkdW1wKToKKyAgICAgICAgKHJ1blRlc3QpOgor ICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZU1hYy5oOgorICAgICAg ICAqIER1bXBSZW5kZXJUcmVlL21hYy9QaXhlbER1bXBTdXBwb3J0TWFjLm1tOgorICAgICAgICAo cmVzdG9yZU1haW5EaXNwbGF5Q29sb3JQcm9maWxlKToKKyAgICAgICAgKHNldHVwTWFpbkRpc3Bs YXlDb2xvclByb2ZpbGUpOgorICAgICAgICAoZ2V0Qml0bWFwQ29udGV4dEZyb21XZWJWaWV3KToK KyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwOgorICAgICAg ICAoZHVtcCk6CisgICAgICAgIChydW5UZXN0KToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS93 aW4vUGl4ZWxEdW1wU3VwcG9ydFdpbi5jcHA6CisgICAgICAgIChnZXRCaXRtYXBDb250ZXh0RnJv bVdlYlZpZXcpOgorICAgICAgICAqIFNjcmlwdHMvcnVuLXdlYmtpdC10ZXN0czoKKwogMjAwOC0x MC0wNyAgQWRhbSBSb2JlbiAgPGFyb2JlbkBhcHBsZS5jb20+CiAKICAgICAgICAgTWFrZSBzdXJl IHNob3J0IGZ1bmN0aW9ucyBnZXQgaW5jbHVkZWQgaW4gQ2hhbmdlTG9nIG91dHB1dCBmb3IgZ2l0 CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5nSGVhZGVy cy93dGYvUGFzc1JlZlB0ci5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvRm9yd2FyZGlu Z0hlYWRlcnMvd3RmL1Bhc3NSZWZQdHIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwLi5hYWZkMWEyCi0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1Bhc3NSZWZQdHIuaApAQCAtMCwwICsxIEBACisjaW5j bHVkZSA8SmF2YVNjcmlwdENvcmUvUGFzc1JlZlB0ci5oPgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1JlZlB0ci5oIGIvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1JlZlB0ci5oCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjBmZjYyMTMKLS0tIC9kZXYvbnVsbAorKysg Yi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUmVmUHRy LmgKQEAgLTAsMCArMSBAQAorI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL1JlZlB0ci5oPgpkaWZm IC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIu Y3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3Bw CmluZGV4IGYwYWU4ZDMuLjM2YmMzZDkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKQEAgLTM0LDcgKzM0LDcgQEAKICNpbmNs dWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgogI2luY2x1ZGUgPHd0Zi9NYXRoRXh0cmFzLmg+CiAKLUxh eW91dFRlc3RDb250cm9sbGVyOjpMYXlvdXRUZXN0Q29udHJvbGxlcihib29sIHRlc3RSZXBhaW50 RGVmYXVsdCwgYm9vbCB0ZXN0UmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5RGVmYXVsdCkKK0xheW91 dFRlc3RDb250cm9sbGVyOjpMYXlvdXRUZXN0Q29udHJvbGxlcihjb25zdCBzdGQ6OnN0cmluZyYg dGVzdFBhdGhPclVSTCwgY29uc3Qgc3RkOjpzdHJpbmcmIGV4cGVjdGVkUGl4ZWxIYXNoLCBib29s IHRlc3RSZXBhaW50RGVmYXVsdCwgYm9vbCB0ZXN0UmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5RGVm YXVsdCkKICAgICA6IG1fZHVtcEFzVGV4dChmYWxzZSkKICAgICAsIG1fZHVtcEFzUERGKGZhbHNl KQogICAgICwgbV9kdW1wQmFja0ZvcndhcmRMaXN0KGZhbHNlKQpAQCAtNTksNiArNTksOCBAQCBM YXlvdXRUZXN0Q29udHJvbGxlcjo6TGF5b3V0VGVzdENvbnRyb2xsZXIoYm9vbCB0ZXN0UmVwYWlu dERlZmF1bHQsIGJvb2wgdGVzdFJlcAogICAgICwgbV93YWl0VG9EdW1wKGZhbHNlKQogICAgICwg bV93aW5kb3dJc0tleSh0cnVlKQogICAgICwgbV9nbG9iYWxGbGFnKGZhbHNlKQorICAgICwgbV90 ZXN0UGF0aE9yVVJMKHRlc3RQYXRoT3JVUkwpCisgICAgLCBtX2V4cGVjdGVkUGl4ZWxIYXNoKGV4 cGVjdGVkUGl4ZWxIYXNoKQogewogfQogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAppbmRleCA1ZTMwM2M4Li42MGI3MTU4IDEwMDY0NAot LS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCisr KyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKQEAg LTMxLDEwICszMSwxMSBAQAogCiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSlNPYmplY3RSZWYu aD4KICNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgorI2luY2x1ZGUgPHN0cmluZz4KIAogY2xh c3MgTGF5b3V0VGVzdENvbnRyb2xsZXIgOiBwdWJsaWMgUmVmQ291bnRlZDxMYXlvdXRUZXN0Q29u dHJvbGxlcj4gewogcHVibGljOgotICAgIExheW91dFRlc3RDb250cm9sbGVyKGJvb2wgdGVzdFJl cGFpbnREZWZhdWx0LCBib29sIHRlc3RSZXBhaW50U3dlZXBIb3Jpem9udGFsbHlEZWZhdWx0KTsK KyAgICBMYXlvdXRUZXN0Q29udHJvbGxlcihjb25zdCBzdGQ6OnN0cmluZyYgdGVzdFBhdGhPclVS TCwgY29uc3Qgc3RkOjpzdHJpbmcmIGV4cGVjdGVkUGl4ZWxIYXNoLCBib29sIHRlc3RSZXBhaW50 RGVmYXVsdCwgYm9vbCB0ZXN0UmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5RGVmYXVsdCk7CiAgICAg fkxheW91dFRlc3RDb250cm9sbGVyKCk7CiAKICAgICB2b2lkIG1ha2VXaW5kb3dPYmplY3QoSlND b250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIHdpbmRvd09iamVjdCwgSlNWYWx1ZVJlZiog ZXhjZXB0aW9uKTsKQEAgLTE0Myw3ICsxNDQsMTEgQEAgcHVibGljOgogCiAgICAgYm9vbCBnbG9i YWxGbGFnKCkgY29uc3QgeyByZXR1cm4gbV9nbG9iYWxGbGFnOyB9CiAgICAgdm9pZCBzZXRHbG9i YWxGbGFnKGJvb2wgZ2xvYmFsRmxhZykgeyBtX2dsb2JhbEZsYWcgPSBnbG9iYWxGbGFnOyB9Ci0K KyAgICAKKyAgICBjb25zdCBzdGQ6OnN0cmluZyYgdGVzdFBhdGhPclVSTCgpIGNvbnN0IHsgcmV0 dXJuIG1fdGVzdFBhdGhPclVSTDsgfQorICAgIGNvbnN0IHN0ZDo6c3RyaW5nJiBleHBlY3RlZFBp eGVsSGFzaCgpIGNvbnN0IHsgcmV0dXJuIG1fZXhwZWN0ZWRQaXhlbEhhc2g7IH0KKyAgICBib29s IGV4cGVjdGVkUGl4ZWxIYXNoS25vd24oKSBjb25zdCB7IHJldHVybiAhbV9leHBlY3RlZFBpeGVs SGFzaC5lbXB0eSgpIDt9CisgICAgCiBwcml2YXRlOgogICAgIGJvb2wgbV9kdW1wQXNUZXh0Owog ICAgIGJvb2wgbV9kdW1wQXNQREY7CkBAIC0xNzEsNiArMTc2LDkgQEAgcHJpdmF0ZToKIAogICAg IGJvb2wgbV9nbG9iYWxGbGFnOwogCisgICAgc3RkOjpzdHJpbmcgbV90ZXN0UGF0aE9yVVJMOwor ICAgIHN0ZDo6c3RyaW5nIG1fZXhwZWN0ZWRQaXhlbEhhc2g7ICAgIC8vIGVtcHR5IHN0cmluZyBp ZiBubyBoYXNoCisgICAgCiAgICAgc3RhdGljIEpTQ2xhc3NSZWYgZ2V0SlNDbGFzcygpOwogICAg IHN0YXRpYyBKU1N0YXRpY1ZhbHVlKiBzdGF0aWNWYWx1ZXMoKTsKICAgICBzdGF0aWMgSlNTdGF0 aWNGdW5jdGlvbiogc3RhdGljRnVuY3Rpb25zKCk7CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9QaXhlbER1bXBTdXBwb3J0LmggYi9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9QaXhlbER1bXBTdXBwb3J0LmgKaW5kZXggMzIxNGQwNC4uZDRmODk0OCAxMDA2NDQKLS0t IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvUGl4ZWxEdW1wU3VwcG9ydC5oCisrKyBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL1BpeGVsRHVtcFN1cHBvcnQuaApAQCAtMjksMTIgKzI5 LDE4IEBACiAjaWZuZGVmIFBpeGVsRHVtcFN1cHBvcnRfaAogI2RlZmluZSBQaXhlbER1bXBTdXBw b3J0X2gKIAotdm9pZCBkdW1wV2ViVmlld0FzUGl4ZWxzQW5kQ29tcGFyZVdpdGhFeHBlY3RlZChj b25zdCBjaGFyKiBjdXJyZW50VGVzdCwgYm9vbCBmb3JjZUFsbFRlc3RzVG9EdW1wUGl4ZWxzKTsK KyNpbmNsdWRlIDxzdHJpbmc+CisKK3ZvaWQgZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVX aXRoRXhwZWN0ZWQoY29uc3Qgc3RkOjpzdHJpbmcmIGV4cGVjdGVkSGFzaCk7CisKKyNpZiBQTEFU Rk9STShNQUMpCiAKIC8vIENhbiBiZSB1c2VkIGFzIGEgc2lnbmFsIGhhbmRsZXIKLXZvaWQgcmVz dG9yZUNvbG9yU3BhY2UoaW50IGlnbm9yZWQpOwordm9pZCByZXN0b3JlTWFpbkRpc3BsYXlDb2xv clByb2ZpbGUoaW50IGlnbm9yZWQpOworCisvLyBNYXkgY2hhbmdlIHlvdXIgY29sb3Igc3BhY2Us IHJlcXVpcmluZyBhIGNhbGwgdG8gcmVzdG9yZU1haW5EaXNwbGF5Q29sb3JQcm9maWxlCit2b2lk IHNldHVwTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUoKTsKIAotLy8gTWF5IGNoYW5nZSB5b3VyIGNv bG9yIHNwYWNlLCByZXF1aXJpbmcgYSBjYWxsIHRvIHJlc3RvcmVDb2xvclNwYWNlCi12b2lkIGlu aXRpYWxpemVDb2xvclNwYWNlQW5kU2NyZWVCdWZmZXJGb3JQaXhlbFRlc3RzKCk7CisjZW5kaWYK IAogI2VuZGlmIC8vIFBpeGVsRHVtcFN1cHBvcnRfaApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1wU3VwcG9ydENHLmNwcCBiL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5jcHAKaW5kZXggOTA2ZTI3NC4uZmRl ZjRkOSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1w U3VwcG9ydENHLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9jZy9QaXhlbER1 bXBTdXBwb3J0Q0cuY3BwCkBAIC0zMSw5ICszMSwxMyBAQAogI2luY2x1ZGUgIkR1bXBSZW5kZXJU cmVlLmgiCiAjaW5jbHVkZSAiUGl4ZWxEdW1wU3VwcG9ydENHLmgiCiAKKyNpbmNsdWRlIDxjdHlw ZS5oPgorI2luY2x1ZGUgPGFsZ29yaXRobT4KKwogI2luY2x1ZGUgIkxheW91dFRlc3RDb250cm9s bGVyLmgiCiAjaW5jbHVkZSA8SW1hZ2VJTy9DR0ltYWdlRGVzdGluYXRpb24uaD4KICNpbmNsdWRl IDx3dGYvQXNzZXJ0aW9ucy5oPgorI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KICNpbmNsdWRlIDx3 dGYvUmV0YWluUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1N0cmluZ0V4dHJhcy5oPgogCkBAIC01Myw3 NCArNTcsNjkgQEAgc3RhdGljIHZvaWQgcHJpbnRQTkcoQ0dJbWFnZVJlZiBpbWFnZSkKIHsKICAg ICBSZXRhaW5QdHI8Q0ZNdXRhYmxlRGF0YVJlZj4gaW1hZ2VEYXRhKEFkb3B0Q0YsIENGRGF0YUNy ZWF0ZU11dGFibGUoMCwgMCkpOwogICAgIFJldGFpblB0cjxDR0ltYWdlRGVzdGluYXRpb25SZWY+ IGltYWdlRGVzdChBZG9wdENGLCBDR0ltYWdlRGVzdGluYXRpb25DcmVhdGVXaXRoRGF0YShpbWFn ZURhdGEuZ2V0KCksIGtVVFR5cGVQTkcsIDEsIDApKTsKKwogICAgIENHSW1hZ2VEZXN0aW5hdGlv bkFkZEltYWdlKGltYWdlRGVzdC5nZXQoKSwgaW1hZ2UsIDApOwogICAgIENHSW1hZ2VEZXN0aW5h dGlvbkZpbmFsaXplKGltYWdlRGVzdC5nZXQoKSk7CisKICAgICBwcmludGYoIkNvbnRlbnQtTGVu Z3RoOiAlbHVcbiIsIENGRGF0YUdldExlbmd0aChpbWFnZURhdGEuZ2V0KCkpKTsKICAgICBmd3Jp dGUoQ0ZEYXRhR2V0Qnl0ZVB0cihpbWFnZURhdGEuZ2V0KCkpLCAxLCBDRkRhdGFHZXRMZW5ndGgo aW1hZ2VEYXRhLmdldCgpKSwgc3Rkb3V0KTsKIH0KIAotc3RhdGljIHZvaWQgZ2V0TUQ1SGFzaFN0 cmluZ0ZvckJpdG1hcChDR0NvbnRleHRSZWYgYml0bWFwLCBjaGFyIHN0cmluZ1szM10pCitzdGF0 aWMgdm9pZCBjb21wdXRlTUQ1SGFzaFN0cmluZ0ZvckJpdG1hcENvbnRleHQoQ0dDb250ZXh0UmVm IGJpdG1hcENvbnRleHQsIGNoYXIgaGFzaFN0cmluZ1szM10pCiB7Ci0gICAgTUQ1X0NUWCBtZDVD b250ZXh0OwotICAgIHVuc2lnbmVkIGNoYXIgaGFzaFsxNl07Ci0KLSAgICBzaXplX3QgYml0c1Bl clBpeGVsID0gQ0dCaXRtYXBDb250ZXh0R2V0Qml0c1BlclBpeGVsKGJpdG1hcCk7CisgICAgc2l6 ZV90IGJpdHNQZXJQaXhlbCA9IENHQml0bWFwQ29udGV4dEdldEJpdHNQZXJQaXhlbChiaXRtYXBD b250ZXh0KTsKICAgICBBU1NFUlQoYml0c1BlclBpeGVsID09IDMyKTsgLy8gSW1hZ2VEaWZmIGFz c3VtZXMgMzIgYml0IFJHQkEsIHdlIG11c3QgYXMgd2VsbC4KICAgICBzaXplX3QgYnl0ZXNQZXJQ aXhlbCA9IGJpdHNQZXJQaXhlbCAvIDg7Ci0gICAgc2l6ZV90IHBpeGVsc0hpZ2ggPSBDR0JpdG1h cENvbnRleHRHZXRIZWlnaHQoYml0bWFwKTsKLSAgICBzaXplX3QgcGl4ZWxzV2lkZSA9IENHQml0 bWFwQ29udGV4dEdldFdpZHRoKGJpdG1hcCk7Ci0gICAgc2l6ZV90IGJ5dGVzUGVyUm93ID0gQ0dC aXRtYXBDb250ZXh0R2V0Qnl0ZXNQZXJSb3coYml0bWFwKTsKKyAgICBzaXplX3QgcGl4ZWxzSGln aCA9IENHQml0bWFwQ29udGV4dEdldEhlaWdodChiaXRtYXBDb250ZXh0KTsKKyAgICBzaXplX3Qg cGl4ZWxzV2lkZSA9IENHQml0bWFwQ29udGV4dEdldFdpZHRoKGJpdG1hcENvbnRleHQpOworICAg IHNpemVfdCBieXRlc1BlclJvdyA9IENHQml0bWFwQ29udGV4dEdldEJ5dGVzUGVyUm93KGJpdG1h cENvbnRleHQpOwogICAgIEFTU0VSVChieXRlc1BlclJvdyA+PSAocGl4ZWxzV2lkZSAqIGJ5dGVz UGVyUGl4ZWwpKTsKIAorICAgIE1ENV9DVFggbWQ1Q29udGV4dDsKICAgICBNRDVfSW5pdCgmbWQ1 Q29udGV4dCk7Ci0gICAgdW5zaWduZWQgY2hhciogYml0bWFwRGF0YSA9IHN0YXRpY19jYXN0PHVu c2lnbmVkIGNoYXIqPihDR0JpdG1hcENvbnRleHRHZXREYXRhKGJpdG1hcCkpOworICAgIHVuc2ln bmVkIGNoYXIqIGJpdG1hcERhdGEgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyKj4oQ0dCaXRt YXBDb250ZXh0R2V0RGF0YShiaXRtYXBDb250ZXh0KSk7CiAgICAgZm9yICh1bnNpZ25lZCByb3cg PSAwOyByb3cgPCBwaXhlbHNIaWdoOyByb3crKykgewogICAgICAgICBNRDVfVXBkYXRlKCZtZDVD b250ZXh0LCBiaXRtYXBEYXRhLCBzdGF0aWNfY2FzdDx1bnNpZ25lZD4ocGl4ZWxzV2lkZSAqIGJ5 dGVzUGVyUGl4ZWwpKTsKICAgICAgICAgYml0bWFwRGF0YSArPSBieXRlc1BlclJvdzsKICAgICB9 CisKKyAgICB1bnNpZ25lZCBjaGFyIGhhc2hbMTZdOwogICAgIE1ENV9GaW5hbChoYXNoLCAmbWQ1 Q29udGV4dCk7CiAKLSAgICBzdHJpbmdbMF0gPSAnXDAnOworICAgIGhhc2hTdHJpbmdbMF0gPSAn XDAnOwogICAgIGZvciAoaW50IGkgPSAwOyBpIDwgMTY7IGkrKykKLSAgICAgICAgc25wcmludGYo c3RyaW5nLCAzMywgIiVzJTAyeCIsIHN0cmluZywgaGFzaFtpXSk7CisgICAgICAgIHNucHJpbnRm KGhhc2hTdHJpbmcsIDMzLCAiJXMlMDJ4IiwgaGFzaFN0cmluZywgaGFzaFtpXSk7CiB9CiAKLXZv aWQgZHJhd1NlbGVjdGlvblJlY3QoQ0dDb250ZXh0UmVmIGNvbnRleHQsIGNvbnN0IENHUmVjdCYg cmVjdCkKK3ZvaWQgZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0ZWQoY29u c3Qgc3RkOjpzdHJpbmcmIGV4cGVjdGVkSGFzaCkKIHsKLSAgICBDR0NvbnRleHRTYXZlR1N0YXRl KGNvbnRleHQpOwotICAgIENHQ29udGV4dFNldFJHQlN0cm9rZUNvbG9yKGNvbnRleHQsIDEuMCwg MC4wLCAwLjAsIDEuMCk7Ci0gICAgQ0dDb250ZXh0U3Ryb2tlUmVjdChjb250ZXh0LCByZWN0KTsK LSAgICBDR0NvbnRleHRSZXN0b3JlR1N0YXRlKGNvbnRleHQpOwotfQotCi12b2lkIGR1bXBXZWJW aWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4cGVjdGVkKGNvbnN0IGNoYXIqIC8qY3VycmVudFRl c3QqLywgYm9vbCAvKmZvcmNlQWxsVGVzdHNUb0R1bXBQaXhlbHMqLykKLXsKLSAgICBSZXRhaW5Q dHI8Q0dDb250ZXh0UmVmPiBjb250ZXh0ID0gZ2V0Qml0bWFwQ29udGV4dEZyb21XZWJWaWV3KCk7 Ci0KKyAgICBSZWZQdHI8Qml0bWFwQ29udGV4dD4gY29udGV4dDsKKyAgICAKICNpZiBQTEFURk9S TShNQUMpCi0gICAgaWYgKGdMYXlvdXRUZXN0Q29udHJvbGxlci0+dGVzdFJlcGFpbnQoKSkKLSAg ICAgICAgcmVwYWludFdlYlZpZXcoY29udGV4dC5nZXQoKSwgZ0xheW91dFRlc3RDb250cm9sbGVy LT50ZXN0UmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5KCkpOwotICAgIGVsc2UgCi0gICAgICAgIHBh aW50V2ViVmlldyhjb250ZXh0LmdldCgpKTsKLQotICAgIGlmIChnTGF5b3V0VGVzdENvbnRyb2xs ZXItPmR1bXBTZWxlY3Rpb25SZWN0KCkpCi0gICAgICAgIGRyYXdTZWxlY3Rpb25SZWN0KGNvbnRl eHQuZ2V0KCksIGdldFNlbGVjdGlvblJlY3QoKSk7CisgICAgY29udGV4dCA9IGdldEJpdG1hcENv bnRleHRGcm9tV2ViVmlldyhnTGF5b3V0VGVzdENvbnRyb2xsZXItPnRlc3RSZXBhaW50KCksIGdM YXlvdXRUZXN0Q29udHJvbGxlci0+dGVzdFJlcGFpbnRTd2VlcEhvcml6b250YWxseSgpLCBnTGF5 b3V0VGVzdENvbnRyb2xsZXItPmR1bXBTZWxlY3Rpb25SZWN0KCkpOwogI2VuZGlmCi0KLSAgICAv LyBDb21wdXRlIHRoZSBhY3R1YWwgaGFzaCB0byBjb21wYXJlIHRvIHRoZSBleHBlY3RlZCBpbWFn ZSdzIGhhc2guCisgICAgQVNTRVJUKGNvbnRleHQuZ2V0KCkpOworICAgIAorICAgIC8vIENvbXB1 dGUgdGhlIGhhc2ggb2YgdGhlIGJpdG1hcCBjb250ZXh0IHBpeGVscwogICAgIGNoYXIgYWN0dWFs SGFzaFszM107Ci0gICAgZ2V0TUQ1SGFzaFN0cmluZ0ZvckJpdG1hcChjb250ZXh0LmdldCgpLCBh Y3R1YWxIYXNoKTsKKyAgICBjb21wdXRlTUQ1SGFzaFN0cmluZ0ZvckJpdG1hcENvbnRleHQoY29u dGV4dC0+Y2dDb250ZXh0KCksIGFjdHVhbEhhc2gpOwogICAgIHByaW50ZigiXG5BY3R1YWxIYXNo OiAlc1xuIiwgYWN0dWFsSGFzaCk7Ci0KLSAgICAvLyBGSVhNRTogV2Ugc2hvdWxkIGNvbXBhcmUg dGhlIGFjdHVhbEhhc2ggdG8gdGhlIGV4cGVjdGVkIGhhc2ggaGVyZSBhbmQKLSAgICAvLyBvbmx5 IHNldCBkdW1wSW1hZ2UgdG8gdHJ1ZSBpZiB0aGV5IGRvbid0IG1hdGNoLCBidXQgRFJUIGRvZXNu J3QgaGF2ZQotICAgIC8vIGVub3VnaCBpbmZvcm1hdGlvbiBjdXJyZW50bHkgdG8gZmluZCB0aGUg ZXhwZWN0ZWQgY2hlY2tzdW0gZmlsZS4KKyAgICAKKyAgICAvLyBDaGVjayB0aGUgY29tcHV0ZWQg aGFzaCBhZ2FpbnN0IHRoZSBleHBlY3RlZCBvbmUgYW5kIGR1bXAgaW1hZ2Ugb24gbWlzbWF0Y2gK ICAgICBib29sIGR1bXBJbWFnZSA9IHRydWU7Ci0KKyAgICBpZiAoZXhwZWN0ZWRIYXNoLmxlbmd0 aCgpID4gMCkgeworICAgICAgICBBU1NFUlQoZXhwZWN0ZWRIYXNoLmxlbmd0aCgpID09IDMyKTsK KyAgICAgICAgCisgICAgICAgIHByaW50ZigiXG5FeHBlY3RlZEhhc2g6ICVzXG4iLCBleHBlY3Rl ZEhhc2guY19zdHIoKSk7CisgICAgICAgIAorICAgICAgICBpZiAoZXhwZWN0ZWRIYXNoID09IGFj dHVhbEhhc2gpICAgICAvLyBGSVhNRTogZG8gY2FzZSBpbnNlbnNpdGl2ZSBjb21wYXJlCisgICAg ICAgICAgICBkdW1wSW1hZ2UgPSBmYWxzZTsKKyAgICB9CisgICAgCiAgICAgaWYgKGR1bXBJbWFn ZSkgewotICAgICAgICBSZXRhaW5QdHI8Q0dJbWFnZVJlZj4gaW1hZ2UoQWRvcHRDRiwgQ0dCaXRt YXBDb250ZXh0Q3JlYXRlSW1hZ2UoY29udGV4dC5nZXQoKSkpOworICAgICAgICBSZXRhaW5QdHI8 Q0dJbWFnZVJlZj4gaW1hZ2UoQWRvcHRDRiwgQ0dCaXRtYXBDb250ZXh0Q3JlYXRlSW1hZ2UoY29u dGV4dC0+Y2dDb250ZXh0KCkpKTsKICAgICAgICAgcHJpbnRQTkcoaW1hZ2UuZ2V0KCkpOwogICAg IH0KLQorICAgIAogICAgIHByaW50ZigiI0VPRlxuIik7CiB9CmRpZmYgLS1naXQgYS9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9jZy9QaXhlbER1bXBTdXBwb3J0Q0cuaCBiL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5oCmluZGV4IDBhYmRlYTYuLjVi OTI0ZDAgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVt cFN1cHBvcnRDRy5oCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVt cFN1cHBvcnRDRy5oCkBAIC0zMSwyNSArMzEsNjQgQEAKICNpZm5kZWYgUGl4ZWxEdW1wU3VwcG9y dENHX2gKICNkZWZpbmUgUGl4ZWxEdW1wU3VwcG9ydENHX2gKIAorI2luY2x1ZGUgPHd0Zi9QYXNz UmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4KICNpbmNsdWRlIDx3dGYvUmV0 YWluUHRyLmg+CiAKLSNpZm5kZWYgQ0dGTE9BVF9ERUZJTkVECi0jaWZkZWYgX19MUDY0X18KLXR5 cGVkZWYgZG91YmxlIENHRmxvYXQ7Ci0jZWxzZQotdHlwZWRlZiBmbG9hdCBDR0Zsb2F0OwordHlw ZWRlZiBzdHJ1Y3QgQ0dDb250ZXh0KiBDR0NvbnRleHRSZWY7CisKKworY2xhc3MgQml0bWFwQ29u dGV4dCA6IHB1YmxpYyBSZWZDb3VudGVkPEJpdG1hcENvbnRleHQ+Cit7CitwdWJsaWM6CisjaWYg UExBVEZPUk0oTUFDKQorICAgIHN0YXRpYyBQYXNzUmVmUHRyPEJpdG1hcENvbnRleHQ+IGNyZWF0 ZSh2b2lkKiBwaXhlbERhdGEsIENHQ29udGV4dFJlZiBjb250ZXh0KQorICAgIHsKKyAgICAgICAg cmV0dXJuIGFkb3B0UmVmKG5ldyBCaXRtYXBDb250ZXh0KHBpeGVsRGF0YSwgY29udGV4dCkpOwor ICAgIH0KKyNlbGlmIFBMQVRGT1JNKFdJTikKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxCaXRtYXBD b250ZXh0PiBjcmVhdGUoSEJJVE1BUCBiaXRtYXAsIENHQ29udGV4dFJlZiBjb250ZXh0KQorICAg IHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBCaXRtYXBDb250ZXh0KGJpdG1hcCwgY29u dGV4dCkpOworICAgIH0KICNlbmRpZgotI2RlZmluZSBDR0ZMT0FUX0RFRklORUQgMQorCisgICAg fkJpdG1hcENvbnRleHQoKQorICAgIHsKKyNpZiBQTEFURk9STShNQUMpCisgICAgICAgIGlmICht X3BpeGVsRGF0YSkKKyAgICAgICAgICAgIGZyZWUobV9waXhlbERhdGEpOworI2VsaWYgUExBVEZP Uk0oV0lOKQorICAgICAgICBpZiAobV9iaXRtYXApCisgICAgICAgICAgICBEZWxldGVPYmplY3Qo bV9iaXRtYXApOwogI2VuZGlmCisgICAgfQogCi10eXBlZGVmIHN0cnVjdCBDR0NvbnRleHQqIENH Q29udGV4dFJlZjsKLXN0cnVjdCBDR1JlY3Q7CisgICAgQ0dDb250ZXh0UmVmIGNnQ29udGV4dCgp IGNvbnN0IHsgcmV0dXJuIG1fY29udGV4dC5nZXQoKTsgfQorCitwcml2YXRlOgorCisjaWYgUExB VEZPUk0oTUFDKQorICAgIEJpdG1hcENvbnRleHQodm9pZCogcGl4ZWxEYXRhLCBDR0NvbnRleHRS ZWYgY29udGV4dCkKKyAgICAgICAgOiBtX3BpeGVsRGF0YShwaXhlbERhdGEpCisjZWxpZiBQTEFU Rk9STShXSU4pCisgICAgQml0bWFwQ29udGV4dChIQklUTUFQIGJpdG1hcCwgQ0dDb250ZXh0UmVm IGNvbnRleHQpCisgICAgICAgIDogbV9iaXRtYXAoYml0bWFwKQorI2VuZGlmCisgICAgICAgICwg bV9jb250ZXh0KEFkb3B0Q0YsIGNvbnRleHQpCisgICAgeworICAgIH0KKyAgICAKKyNpZiBQTEFU Rk9STShNQUMpCisgICAgdm9pZCogbV9waXhlbERhdGE7CisjZWxpZiBQTEFURk9STShXSU4pCisg ICAgSEJJVE1BUCBtX2JpdG1hcDsKKyNlbmRpZiAgICAKKyAgICBSZXRhaW5QdHI8Q0dDb250ZXh0 UmVmPiBtX2NvbnRleHQ7CisKK307CiAKLVJldGFpblB0cjxDR0NvbnRleHRSZWY+IGdldEJpdG1h cENvbnRleHRGcm9tV2ViVmlldygpOwotQ0dSZWN0IGdldFNlbGVjdGlvblJlY3QoKTsKIAotdm9p ZCBwYWludFdlYlZpZXcoQ0dDb250ZXh0UmVmKTsKLXZvaWQgcmVwYWludFdlYlZpZXcoQ0dDb250 ZXh0UmVmIGNvbnRleHQsIGJvb2wgaG9yaXpvbnRhbCk7Ci12b2lkIGRyYXdTZWxlY3Rpb25SZWN0 KENHQ29udGV4dFJlZiwgY29uc3QgQ0dSZWN0Jik7CitQYXNzUmVmUHRyPEJpdG1hcENvbnRleHQ+ IGdldEJpdG1hcENvbnRleHRGcm9tV2ViVmlldyhib29sIGluY3JlbWVudGFsUmVwYWludCwgYm9v bCBzd2VlcEhvcml6b250YWxseSwgYm9vbCBkcmF3U2VsZWN0aW9uUmVjdCk7CiAKICNlbmRpZiAv LyBQaXhlbER1bXBTdXBwb3J0Q0dfaApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv bWFjL0R1bXBSZW5kZXJUcmVlLm1tCmluZGV4IGI0NzA0ZjguLjUwNTg5NTggMTAwNjQ0Ci0tLSBh L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQorKysgYi9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KQEAgLTc4LDcg Kzc4LDcgQEAKIEBpbnRlcmZhY2UgRHVtcFJlbmRlclRyZWVFdmVudCA6IE5TRXZlbnQKIEBlbmQK IAotc3RhdGljIHZvaWQgcnVuVGVzdChjb25zdCBjaGFyICpwYXRoT3JVUkwpOworc3RhdGljIHZv aWQgcnVuVGVzdChjb25zdCBzdGQ6OnN0cmluZyYgdGVzdFBhdGhPclVSTCk7CiAKIC8vIERlY2lk aW5nIHdoZW4gaXQncyBPSyB0byBkdW1wIG91dCB0aGUgc3RhdGUgaXMgYSBiaXQgdHJpY2t5LiAg QWxsIHRoZXNlIG11c3QgYmUgdHJ1ZToKIC8vIC0gVGhlcmUgaXMgbm8gbG9hZCBpbiBwcm9ncmVz cwpAQCAtMTE4LDcgKzExOCw2IEBAIHN0YXRpYyBpbnQgcmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5 RGVmYXVsdDsKIHN0YXRpYyBpbnQgZHVtcFRyZWUgPSBZRVM7CiBzdGF0aWMgaW50IGZvcmNlQ29t cGxleFRleHQ7CiBzdGF0aWMgQk9PTCBwcmludFNlcGFyYXRvcnM7Ci1zdGF0aWMgTlNTdHJpbmcg KmN1cnJlbnRUZXN0ID0gbmlsOwogc3RhdGljIFJldGFpblB0cjxDRlN0cmluZ1JlZj4gcGVyc2lz dGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb247CiAKIHN0YXRpYyBXZWJIaXN0b3J5SXRlbSAqcHJl dlRlc3RCRkl0ZW0gPSBuaWw7ICAvLyBjdXJyZW50IGIvZiBpdGVtIGF0IHRoZSBlbmQgb2YgdGhl IHByZXZpb3VzIHRlc3QKQEAgLTE4MSwyMSArMTgwLDIyIEBAIHZvaWQgc2V0UGVyc2lzdGVudFVz ZXJTdHlsZVNoZWV0TG9jYXRpb24oQ0ZTdHJpbmdSZWYgdXJsKQogICAgIHBlcnNpc3RlbnRVc2Vy U3R5bGVTaGVldExvY2F0aW9uID0gdXJsOwogfQogCi1zdGF0aWMgQk9PTCBzaG91bGRJZ25vcmVX ZWJDb3JlTm9kZUxlYWtzKENGU3RyaW5nUmVmIFVSTFN0cmluZykKK3N0YXRpYyBib29sIHNob3Vs ZElnbm9yZVdlYkNvcmVOb2RlTGVha3MoY29uc3Qgc3RkOjpzdHJpbmcmIFVSTFN0cmluZykKIHsK LSAgICBzdGF0aWMgQ0ZTdHJpbmdSZWYgY29uc3QgaWdub3JlU2V0W10gPSB7CisgICAgc3RhdGlj IGNoYXIqIGNvbnN0IGlnbm9yZVNldFtdID0gewogICAgICAgICAvLyBLZWVwaW5nIHRoaXMgaW5m cmFzdHJ1Y3R1cmUgYXJvdW5kIGluIGNhc2Ugd2UgZXZlciBuZWVkIGl0IGFnYWluLgogICAgIH07 Ci0gICAgc3RhdGljIGNvbnN0IGludCBpZ25vcmVTZXRDb3VudCA9IHNpemVvZihpZ25vcmVTZXQp IC8gc2l6ZW9mKENGU3RyaW5nUmVmKTsKKyAgICBzdGF0aWMgY29uc3QgaW50IGlnbm9yZVNldENv dW50ID0gc2l6ZW9mKGlnbm9yZVNldCkgLyBzaXplb2YoY2hhciopOwogICAgIAogICAgIGZvciAo aW50IGkgPSAwOyBpIDwgaWdub3JlU2V0Q291bnQ7IGkrKykgewotICAgICAgICBDRlN0cmluZ1Jl ZiBpZ25vcmVTdHJpbmcgPSBpZ25vcmVTZXRbaV07Ci0gICAgICAgIENGUmFuZ2UgcmFuZ2UgPSBD RlJhbmdlTWFrZSgwLCBDRlN0cmluZ0dldExlbmd0aChVUkxTdHJpbmcpKTsKLSAgICAgICAgQ0ZP cHRpb25GbGFncyBmbGFncyA9IGtDRkNvbXBhcmVBbmNob3JlZCB8IGtDRkNvbXBhcmVCYWNrd2Fy ZHMgfCBrQ0ZDb21wYXJlQ2FzZUluc2Vuc2l0aXZlOwotICAgICAgICBpZiAoQ0ZTdHJpbmdGaW5k V2l0aE9wdGlvbnMoVVJMU3RyaW5nLCBpZ25vcmVTdHJpbmcsIHJhbmdlLCBmbGFncywgTlVMTCkp Ci0gICAgICAgICAgICByZXR1cm4gWUVTOworCisgICAgICAgIC8vIEZJWE1FOiBpZ25vcmUgY2Fz ZQorICAgICAgICBzdGQ6OnN0cmluZyBjdXJJZ25vcmUoaWdub3JlU2V0W2ldKTsKKyAgICAgICAg Ly8gTWF0Y2ggYXQgdGhlIGVuZCBvZiB0aGUgVVJMU3RyaW5nCisgICAgICAgIGlmIChVUkxTdHJp bmcuY29tcGFyZShVUkxTdHJpbmcubGVuZ3RoKCkgLSBjdXJJZ25vcmUubGVuZ3RoKCksIGN1ckln bm9yZS5sZW5ndGgoKSwgY3VySWdub3JlKSA9PSAwKQorICAgICAgICAgICAgcmV0dXJuIHRydWU7 CiAgICAgfQotICAgIHJldHVybiBOTzsKKyAgICByZXR1cm4gZmFsc2U7CiB9CiAKIHN0YXRpYyB2 b2lkIGFjdGl2YXRlRm9udHMoKQpAQCAtMzA3LDEzICszMDcsMTMgQEAgdm9pZCB0ZXN0U3RyaW5n QnlFdmFsdWF0aW5nSmF2YVNjcmlwdEZyb21TdHJpbmcoKQogc3RhdGljIHZvaWQgc2V0RGVmYXVs dHNUb0NvbnNpc3RlbnRWYWx1ZXNGb3JUZXN0aW5nKCkKIHsKICAgICAvLyBHaXZlIHNvbWUgY2xl YXIgdG8gdW5kb2N1bWVudGVkIGRlZmF1bHRzIHZhbHVlcwotICAgIHN0YXRpYyBjb25zdCBpbnQg TWVkaXVtRm9udFNtb290aGluZyA9IDI7CisgICAgc3RhdGljIGNvbnN0IGludCBOb0ZvbnRTbW9v dGhpbmcgPSAwOwogICAgIHN0YXRpYyBjb25zdCBpbnQgQmx1ZVRpbnRlZEFwcGVhcmFuY2UgPSAx OwogCiAgICAgTlNVc2VyRGVmYXVsdHMgKmRlZmF1bHRzID0gW05TVXNlckRlZmF1bHRzIHN0YW5k YXJkVXNlckRlZmF1bHRzXTsKICAgICBbZGVmYXVsdHMgc2V0T2JqZWN0OkAiRG91YmxlTWF4IiBm b3JLZXk6QCJBcHBsZVNjcm9sbEJhclZhcmlhbnQiXTsKICAgICBbZGVmYXVsdHMgc2V0SW50ZWdl cjo0IGZvcktleTpAIkFwcGxlQW50aUFsaWFzaW5nVGhyZXNob2xkIl07IC8vIHNtYWxsZXN0IGZv bnQgc2l6ZSB0byBDRyBzaG91bGQgcGVyZm9ybSBhbnRpYWxpYXNpbmcgb24KLSAgICBbZGVmYXVs dHMgc2V0SW50ZWdlcjpNZWRpdW1Gb250U21vb3RoaW5nIGZvcktleTpAIkFwcGxlRm9udFNtb290 aGluZyJdOworICAgIFtkZWZhdWx0cyBzZXRJbnRlZ2VyOk5vRm9udFNtb290aGluZyBmb3JLZXk6 QCJBcHBsZUZvbnRTbW9vdGhpbmciXTsKICAgICBbZGVmYXVsdHMgc2V0SW50ZWdlcjpCbHVlVGlu dGVkQXBwZWFyYW5jZSBmb3JLZXk6QCJBcHBsZUFxdWFDb2xvclZhcmlhbnQiXTsKICAgICBbZGVm YXVsdHMgc2V0T2JqZWN0OkAiMC43MDk4MDAgMC44MzUzMDAgMS4wMDAwMDAiIGZvcktleTpAIkFw cGxlSGlnaGxpZ2h0Q29sb3IiXTsKICAgICBbZGVmYXVsdHMgc2V0T2JqZWN0OkAiMC41MDAwMDAg MC41MDAwMDAgMC41MDAwMDAiIGZvcktleTpAIkFwcGxlT3RoZXJIaWdobGlnaHRDb2xvciJdOwpA QCAtMzUwLDcgKzM1MCw5IEBAIHN0YXRpYyB2b2lkIGNyYXNoSGFuZGxlcihpbnQgc2lnKQogICAg IGNoYXIgKnNpZ25hbE5hbWUgPSBzdHJzaWduYWwoc2lnKTsKICAgICB3cml0ZShTVERFUlJfRklM RU5PLCBzaWduYWxOYW1lLCBzdHJsZW4oc2lnbmFsTmFtZSkpOwogICAgIHdyaXRlKFNUREVSUl9G SUxFTk8sICJcbiIsIDEpOwotICAgIHJlc3RvcmVDb2xvclNwYWNlKDApOworI2lmIFBMQVRGT1JN KE1BQykKKyAgICByZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUoMCk7CisjZW5kaWYKICAg ICBleGl0KDEyOCArIHNpZyk7CiB9CiAKQEAgLTQ2MCw3ICs0NjIsNyBAQCBzdGF0aWMgdm9pZCBw cmVwYXJlQ29uc2lzdGVudFRlc3RpbmdFbnZpcm9ubWVudCgpCiAgICAgYWN0aXZhdGVGb250cygp OwogICAgIAogICAgIGlmIChkdW1wUGl4ZWxzKQotICAgICAgICBpbml0aWFsaXplQ29sb3JTcGFj ZUFuZFNjcmVlQnVmZmVyRm9yUGl4ZWxUZXN0cygpOworICAgICAgICBzZXR1cE1haW5EaXNwbGF5 Q29sb3JQcm9maWxlKCk7CiAgICAgYWxsb2NhdGVHbG9iYWxDb250cm9sbGVycygpOwogICAgIAog ICAgIG1ha2VMYXJnZU1hbGxvY0ZhaWxTaWxlbnRseSgpOwpAQCAtNTI1LDggKzUyNywxMCBAQCB2 b2lkIGR1bXBSZW5kZXJUcmVlKGludCBhcmdjLCBjb25zdCBjaGFyICphcmd2W10pCiAgICAgICAg IGRpc2FsbG93ZWRVUkxzID0gMDsKICAgICB9CiAKKyNpZiBQTEFURk9STShNQUMpCiAgICAgaWYg KGR1bXBQaXhlbHMpCi0gICAgICAgIHJlc3RvcmVDb2xvclNwYWNlKDApOworICAgICAgICByZXN0 b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUoMCk7CisjZW5kaWYKIH0KIAogaW50IG1haW4oaW50 IGFyZ2MsIGNvbnN0IGNoYXIgKmFyZ3ZbXSkKQEAgLTgyMSw3ICs4MjUsNyBAQCBzdGF0aWMgdm9p ZCBkdW1wQmFja0ZvcndhcmRMaXN0Rm9yV2ViVmlldyhXZWJWaWV3ICp2aWV3KQogc3RhdGljIHZv aWQgc2l6ZVdlYlZpZXdGb3JDdXJyZW50VGVzdCgpCiB7CiAgICAgLy8gVzNDIFNWRyB0ZXN0cyBl eHBlY3QgdG8gYmUgNDgweDM2MAotICAgIGJvb2wgaXNTVkdXM0NUZXN0ID0gKFtjdXJyZW50VGVz dCByYW5nZU9mU3RyaW5nOkAic3ZnL1czQy1TVkctMS4xIl0ubGVuZ3RoKTsKKyAgICBib29sIGlz U1ZHVzNDVGVzdCA9IChnTGF5b3V0VGVzdENvbnRyb2xsZXItPnRlc3RQYXRoT3JVUkwoKS5maW5k KCJzdmcvVzNDLVNWRy0xLjEiKSAhPSBzdGQ6OnN0cmluZzo6bnBvcyk7CiAgICAgaWYgKGlzU1ZH VzNDVGVzdCkKICAgICAgICAgW1ttYWluRnJhbWUgd2ViVmlld10gc2V0RnJhbWVTaXplOk5TTWFr ZVNpemUoNDgwLCAzNjApXTsKICAgICBlbHNlCkBAIC05MTYsNyArOTIwLDcgQEAgdm9pZCBkdW1w KCkKICAgICB9CiAgICAgCiAgICAgaWYgKGR1bXBBbGxQaXhlbHMgfHwgKGR1bXBQaXhlbHMgJiYg IWR1bXBBc1RleHQpKQotICAgICAgICBkdW1wV2ViVmlld0FzUGl4ZWxzQW5kQ29tcGFyZVdpdGhF eHBlY3RlZChbY3VycmVudFRlc3QgVVRGOFN0cmluZ10sIGR1bXBBbGxQaXhlbHMpOworICAgICAg ICBkdW1wV2ViVmlld0FzUGl4ZWxzQW5kQ29tcGFyZVdpdGhFeHBlY3RlZChnTGF5b3V0VGVzdENv bnRyb2xsZXItPmV4cGVjdGVkUGl4ZWxIYXNoKCkpOwogCiAgICAgZmZsdXNoKHN0ZG91dCk7CiAg ICAgZmZsdXNoKHN0ZGVycik7CkBAIC05MjksMTYgKzkzMyw2IEBAIHN0YXRpYyBib29sIHNob3Vs ZExvZ0ZyYW1lTG9hZERlbGVnYXRlcyhjb25zdCBjaGFyICpwYXRoT3JVUkwpCiAgICAgcmV0dXJu IHN0cnN0cihwYXRoT3JVUkwsICJsb2FkaW5nLyIpOwogfQogCi1zdGF0aWMgQ0ZVUkxSZWYgY3Jl YXRlQ0ZVUkxGcm9tUGF0aE9yVVJMKENGU3RyaW5nUmVmIHBhdGhPclVSTFN0cmluZykKLXsKLSAg ICBDRlVSTFJlZiBVUkw7Ci0gICAgaWYgKENGU3RyaW5nSGFzUHJlZml4KHBhdGhPclVSTFN0cmlu ZywgQ0ZTVFIoImh0dHA6Ly8iKSkgfHwgQ0ZTdHJpbmdIYXNQcmVmaXgocGF0aE9yVVJMU3RyaW5n LCBDRlNUUigiaHR0cHM6Ly8iKSkpCi0gICAgICAgIFVSTCA9IENGVVJMQ3JlYXRlV2l0aFN0cmlu ZyhOVUxMLCBwYXRoT3JVUkxTdHJpbmcsIE5VTEwpOwotICAgIGVsc2UKLSAgICAgICAgVVJMID0g Q0ZVUkxDcmVhdGVXaXRoRmlsZVN5c3RlbVBhdGgoTlVMTCwgcGF0aE9yVVJMU3RyaW5nLCBrQ0ZV UkxQT1NJWFBhdGhTdHlsZSwgRkFMU0UpOwotICAgIHJldHVybiBVUkw7Ci19Ci0KIHN0YXRpYyB2 b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGluZygpCiB7CiAgICAg V2ViVmlldyAqd2ViVmlldyA9IFttYWluRnJhbWUgd2ViVmlld107CkBAIC05NjYsNTMgKzk2MCw2 OCBAQCBzdGF0aWMgdm9pZCByZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0ZUJlZm9yZVRlc3Rp bmcoKQogICAgIFtXZWJWaWV3IF9zZXRVc2VzVGVzdE1vZGVGb2N1c1JpbmdDb2xvcjpZRVNdOwog fQogCi1zdGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0IGNoYXIgKnBhdGhPclVSTCkKK3N0YXRpYyB2 b2lkIHJ1blRlc3QoY29uc3Qgc3RkOjpzdHJpbmcmIHRlc3RQYXRoT3JVUkwpCiB7Ci0gICAgQ0ZT dHJpbmdSZWYgcGF0aE9yVVJMU3RyaW5nID0gQ0ZTdHJpbmdDcmVhdGVXaXRoQ1N0cmluZyhOVUxM LCBwYXRoT3JVUkwsIGtDRlN0cmluZ0VuY29kaW5nVVRGOCk7CisgICAgQVNTRVJUKCF0ZXN0UGF0 aE9yVVJMLmVtcHR5KCkpOworICAgIAorICAgIC8vIExvb2sgZm9yICd8JyBhcyBhIHNlcGFyYXRv ciBiZXR3ZWVuIHRoZSBwYXRoIG9yIFVSTCwgYW5kIHRoZSBwaXhlbCBkdW1wIGhhc2ggdGhhdCBm b2xsb3dzLgorICAgIC8vIEZJWE1FOiB0aGlzIGlzIGEgdmFsaWQgVVJMIGNoYXJhY3RlcnMuIFVz ZSBhIGRpZmZlcmVudCBzZXBhcmF0b3I/ICAKKyAgICBzdGQ6OnN0cmluZyBwYXRoT3JVUkwodGVz dFBhdGhPclVSTCk7CisgICAgc3RkOjpzdHJpbmcgZXhwZWN0ZWRQaXhlbEhhc2g7CisgICAgCisg ICAgc2l6ZV90IHNlcGFyYXRvclBvcyA9IHBhdGhPclVSTC5maW5kKCJ8Iik7CisgICAgaWYgKHNl cGFyYXRvclBvcyAhPSBzdGQ6OnN0cmluZzo6bnBvcykgeworICAgICAgICBwYXRoT3JVUkwgPSBz dGQ6OnN0cmluZyh0ZXN0UGF0aE9yVVJMLCAwLCBzZXBhcmF0b3JQb3MpOworICAgICAgICBleHBl Y3RlZFBpeGVsSGFzaCA9IHN0ZDo6c3RyaW5nKHRlc3RQYXRoT3JVUkwsIHNlcGFyYXRvclBvcyAr IDEpOworICAgIH0KKworICAgIE5TU3RyaW5nKiBwYXRoT3JVUkxTdHJpbmcgPSBbTlNTdHJpbmcg c3RyaW5nV2l0aFVURjhTdHJpbmc6cGF0aE9yVVJMLmNfc3RyKCldOwogICAgIGlmICghcGF0aE9y VVJMU3RyaW5nKSB7Ci0gICAgICAgIGZwcmludGYoc3RkZXJyLCAiRmFpbGVkIHRvIHBhcnNlIGZp bGVuYW1lIGFzIFVURi04OiAlc1xuIiwgcGF0aE9yVVJMKTsKKyAgICAgICAgZnByaW50ZihzdGRl cnIsICJGYWlsZWQgdG8gcGFyc2UgXCIlc1wiIGFzIFVURi04XG4iLCBwYXRoT3JVUkwuY19zdHIo KSk7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBDRlVSTFJlZiBVUkwgPSBjcmVhdGVD RlVSTEZyb21QYXRoT3JVUkwocGF0aE9yVVJMU3RyaW5nKTsKLSAgICBpZiAoIVVSTCkgewotICAg ICAgICBDRlJlbGVhc2UocGF0aE9yVVJMU3RyaW5nKTsKLSAgICAgICAgZnByaW50ZihzdGRlcnIs ICJDYW4ndCB0dXJuICVzIGludG8gYSBDRlVSTFxuIiwgcGF0aE9yVVJMKTsKKyAgICBOU1VSTCog dXJsOworICAgIGlmIChbcGF0aE9yVVJMU3RyaW5nIGhhc1ByZWZpeDpAImh0dHA6Ly8iXSB8fCBb cGF0aE9yVVJMU3RyaW5nIGhhc1ByZWZpeDpAImh0dHBzOi8vIl0pCisgICAgICAgIHVybCA9IFtO U1VSTCBVUkxXaXRoU3RyaW5nOnBhdGhPclVSTFN0cmluZ107CisgICAgZWxzZQorICAgICAgICB1 cmwgPSBbTlNVUkwgZmlsZVVSTFdpdGhQYXRoOnBhdGhPclVSTFN0cmluZ107CisgICAgaWYgKCF1 cmwpIHsKKyAgICAgICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gcGFyc2UgXCIlc1wiIGFz IGFuIHVybFxuIiwgcGF0aE9yVVJMLmNfc3RyKCkpOwogICAgICAgICByZXR1cm47CiAgICAgfQog CisgICAgY29uc3Qgc3RkOjpzdHJpbmcgdGVzdFVSTChbW3VybCBhYnNvbHV0ZVN0cmluZ10gVVRG OFN0cmluZ10pOworICAgIAogICAgIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3Jl VGVzdGluZygpOwogCi0gICAgZ0xheW91dFRlc3RDb250cm9sbGVyID0gbmV3IExheW91dFRlc3RD b250cm9sbGVyKHRlc3RSZXBhaW50RGVmYXVsdCwgcmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5RGVm YXVsdCk7CisgICAgZ0xheW91dFRlc3RDb250cm9sbGVyID0gbmV3IExheW91dFRlc3RDb250cm9s bGVyKHRlc3RVUkwsIGV4cGVjdGVkUGl4ZWxIYXNoLCB0ZXN0UmVwYWludERlZmF1bHQsIHJlcGFp bnRTd2VlcEhvcml6b250YWxseURlZmF1bHQpOwogICAgIHRvcExvYWRpbmdGcmFtZSA9IG5pbDsK ICAgICBkb25lID0gTk87CiAKICAgICBpZiAoZGlzYWxsb3dlZFVSTHMpCiAgICAgICAgIENGU2V0 UmVtb3ZlQWxsVmFsdWVzKGRpc2FsbG93ZWRVUkxzKTsKLSAgICBpZiAoc2hvdWxkTG9nRnJhbWVM b2FkRGVsZWdhdGVzKHBhdGhPclVSTCkpCisgICAgaWYgKHNob3VsZExvZ0ZyYW1lTG9hZERlbGVn YXRlcyhwYXRoT3JVUkwuY19zdHIoKSkpCiAgICAgICAgIGdMYXlvdXRUZXN0Q29udHJvbGxlci0+ c2V0RHVtcEZyYW1lTG9hZENhbGxiYWNrcyh0cnVlKTsKIAogICAgIGlmIChbV2ViSGlzdG9yeSBv cHRpb25hbFNoYXJlZEhpc3RvcnldKQogICAgICAgICBbV2ViSGlzdG9yeSBzZXRPcHRpb25hbFNo YXJlZEhpc3Rvcnk6bmlsXTsKKwogICAgIGxhc3RNb3VzZVBvc2l0aW9uID0gTlNaZXJvUG9pbnQ7 CiAgICAgbGFzdENsaWNrUG9zaXRpb24gPSBOU1plcm9Qb2ludDsKIAotICAgIGlmIChjdXJyZW50 VGVzdCAhPSBuaWwpCi0gICAgICAgIENGUmVsZWFzZShjdXJyZW50VGVzdCk7Ci0gICAgY3VycmVu dFRlc3QgPSAoTlNTdHJpbmcgKilwYXRoT3JVUkxTdHJpbmc7CiAgICAgW3ByZXZUZXN0QkZJdGVt IHJlbGVhc2VdOwogICAgIHByZXZUZXN0QkZJdGVtID0gW1tbW21haW5GcmFtZSB3ZWJWaWV3XSBi YWNrRm9yd2FyZExpc3RdIGN1cnJlbnRJdGVtXSByZXRhaW5dOwogCiAgICAgV29ya1F1ZXVlOjpz aGFyZWQoKS0+Y2xlYXIoKTsKICAgICBXb3JrUXVldWU6OnNoYXJlZCgpLT5zZXRGcm96ZW4oZmFs c2UpOwogCi0gICAgQk9PTCBfc2hvdWxkSWdub3JlV2ViQ29yZU5vZGVMZWFrcyA9IHNob3VsZEln bm9yZVdlYkNvcmVOb2RlTGVha3MoQ0ZVUkxHZXRTdHJpbmcoVVJMKSk7Ci0gICAgaWYgKF9zaG91 bGRJZ25vcmVXZWJDb3JlTm9kZUxlYWtzKQorICAgIGJvb2wgaWdub3JlV2ViQ29yZU5vZGVMZWFr cyA9IHNob3VsZElnbm9yZVdlYkNvcmVOb2RlTGVha3ModGVzdFVSTCk7CisgICAgaWYgKGlnbm9y ZVdlYkNvcmVOb2RlTGVha3MpCiAgICAgICAgIFtXZWJDb3JlU3RhdGlzdGljcyBzdGFydElnbm9y aW5nV2ViQ29yZU5vZGVMZWFrc107CiAKICAgICBOU0F1dG9yZWxlYXNlUG9vbCAqcG9vbCA9IFtb TlNBdXRvcmVsZWFzZVBvb2wgYWxsb2NdIGluaXRdOwotICAgIFttYWluRnJhbWUgbG9hZFJlcXVl c3Q6W05TVVJMUmVxdWVzdCByZXF1ZXN0V2l0aFVSTDooTlNVUkwgKilVUkxdXTsKLSAgICBDRlJl bGVhc2UoVVJMKTsKKyAgICBbbWFpbkZyYW1lIGxvYWRSZXF1ZXN0OltOU1VSTFJlcXVlc3QgcmVx dWVzdFdpdGhVUkw6dXJsXV07CiAgICAgW3Bvb2wgcmVsZWFzZV07CiAgICAgd2hpbGUgKCFkb25l KSB7CiAgICAgICAgIHBvb2wgPSBbW05TQXV0b3JlbGVhc2VQb29sIGFsbG9jXSBpbml0XTsKQEAg LTEwNTQsOCArMTA2Myw4IEBAIHN0YXRpYyB2b2lkIHJ1blRlc3QoY29uc3QgY2hhciAqcGF0aE9y VVJMKQogCiAgICAgZ0xheW91dFRlc3RDb250cm9sbGVyLT5kZXJlZigpOwogICAgIGdMYXlvdXRU ZXN0Q29udHJvbGxlciA9IDA7Ci0KLSAgICBpZiAoX3Nob3VsZElnbm9yZVdlYkNvcmVOb2RlTGVh a3MpCisgICAgCisgICAgaWYgKGlnbm9yZVdlYkNvcmVOb2RlTGVha3MpCiAgICAgICAgIFtXZWJD b3JlU3RhdGlzdGljcyBzdG9wSWdub3JpbmdXZWJDb3JlTm9kZUxlYWtzXTsKIH0KIApkaWZmIC0t Z2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlTWFjLmgg Yi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWVNYWMuaAppbmRl eCAwM2QzNTRkLi43YjM5YjAwIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9tYWMvRHVtcFJlbmRlclRyZWVNYWMuaAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9tYWMvRHVtcFJlbmRlclRyZWVNYWMuaApAQCAtMzYsNiArMzYsOCBAQAogI2RlZmluZSBCVUlM RElOR19PTl9USUdFUiAxCiAjZWxpZiBNQUNfT1NfWF9WRVJTSU9OX01BWF9BTExPV0VEIDw9IE1B Q19PU19YX1ZFUlNJT05fMTBfNQogI2RlZmluZSBCVUlMRElOR19PTl9MRU9QQVJEIDEKKyNlbGlm IE1BQ19PU19YX1ZFUlNJT05fTUFYX0FMTE9XRUQgPD0gTUFDX09TX1hfVkVSU0lPTl8xMF82Cisj ZGVmaW5lIEJVSUxESU5HX09OX1NOT1dMRU9QQVJEIDEKICNlbmRpZgogCiBAY2xhc3MgRHVtcFJl bmRlclRyZWVEcmFnZ2luZ0luZm87CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9tYWMvUGl4ZWxEdW1wU3VwcG9ydE1hYy5tbSBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL21hYy9QaXhlbER1bXBTdXBwb3J0TWFjLm1tCmluZGV4IDlkZGJhMzEuLjgzNGZlODYgMTAw NjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9QaXhlbER1bXBTdXBwb3J0 TWFjLm1tCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9QaXhlbER1bXBTdXBw b3J0TWFjLm1tCkBAIC0zNSwxNTIgKzM1LDE1MyBAQAogI2luY2x1ZGUgIkxheW91dFRlc3RDb250 cm9sbGVyLmgiCiAjaW5jbHVkZSA8Q29yZUdyYXBoaWNzL0NHQml0bWFwQ29udGV4dC5oPgogI2lu Y2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+Ci0jaW5jbHVkZSA8d3RmL1JldGFpblB0ci5oPgorI2lu Y2x1ZGUgPHd0Zi9SZWZQdHIuaD4KIAogI2ltcG9ydCA8V2ViS2l0L1dlYkRvY3VtZW50UHJpdmF0 ZS5oPgogI2ltcG9ydCA8V2ViS2l0L1dlYktpdC5oPgogCi1zdGF0aWMgdW5zaWduZWQgY2hhciog c2NyZWVuQ2FwdHVyZUJ1ZmZlcjsKKyNpZmRlZiBCVUlMRElOR19PTl9TTk9XTEVPUEFSRAorI2Rl ZmluZSBQUk9GSUxFX1BBVEggIi9TeXN0ZW0vTGlicmFyeS9Db2xvclN5bmMvUHJvZmlsZXMvc1JH QiBQcm9maWxlLmljYyIKKyNlbHNlCisjZGVmaW5lIFBST0ZJTEVfUEFUSCAiL1N5c3RlbS9MaWJy YXJ5L0NvbG9yU3luYy9Qcm9maWxlcy9HZW5lcmljIFJHQiBQcm9maWxlLmljYyIKKyNlbmRpZgog Ci1zdGF0aWMgYm9vbCBjaGFuZ2VkQ29sb3JQcm9maWxlID0gZmFsc2U7Ci1zdGF0aWMgQ01Qcm9m aWxlTG9jYXRpb24gY3VycmVudENvbG9yUHJvZmlsZUxvY2F0aW9uOwotc3RhdGljIENHQ29sb3JT cGFjZVJlZiBzaGFyZWRDb2xvclNwYWNlOworc3RhdGljIENNUHJvZmlsZUxvY2F0aW9uIHNJbml0 aWFsUHJvZmlsZUxvY2F0aW9uID0ge2NtTm9Qcm9maWxlQmFzZSwgezAsMCwwfX07CiAKLXZvaWQg cmVzdG9yZUNvbG9yU3BhY2UoaW50IGlnbm9yZWQpCit2b2lkIHJlc3RvcmVNYWluRGlzcGxheUNv bG9yUHJvZmlsZShpbnQgaWdub3JlZCkKIHsKICAgICAvLyBUaGlzIGlzIHVzZWQgYXMgYSBzaWdu YWwgaGFuZGxlciwgYW5kIHRodXMgdGhlIGNhbGxzIGludG8gQ29sb3JTeW5jIGFyZSB1bnNhZmUK ICAgICAvLyBCdXQgd2UgbWlnaHQgYXMgd2VsbCB0cnkgdG8gcmVzdG9yZSB0aGUgdXNlcidzIGNv bG9yIHByb2ZpbGUsIHdlJ3JlIGdvaW5nIGRvd24gYW55d2F5Li4uCi0gICAgaWYgKGNoYW5nZWRD b2xvclByb2ZpbGUpIHsKLSAgICAgICAgQ01EZXZpY2VTY29wZSBzY29wZSA9IHsga0NGUHJlZmVy ZW5jZXNDdXJyZW50VXNlciwga0NGUHJlZmVyZW5jZXNDdXJyZW50SG9zdCB9OwotICAgICAgICBp bnQgZXJyb3IgPSBDTVNldERldmljZVByb2ZpbGUoY21EaXNwbGF5RGV2aWNlQ2xhc3MsIGNtRGVm YXVsdERldmljZUlELCAmc2NvcGUsIGNtRGVmYXVsdFByb2ZpbGVJRCwgJmN1cnJlbnRDb2xvclBy b2ZpbGVMb2NhdGlvbik7CisgICAgaWYgKHNJbml0aWFsUHJvZmlsZUxvY2F0aW9uLmxvY1R5cGUg IT0gY21Ob1Byb2ZpbGVCYXNlKSB7CisgICAgICAgIGNvbnN0IENNRGV2aWNlU2NvcGUgc2NvcGUg PSB7IGtDRlByZWZlcmVuY2VzQ3VycmVudFVzZXIsIGtDRlByZWZlcmVuY2VzQ3VycmVudEhvc3Qg fTsKKyAgICAgICAgaW50IGVycm9yID0gQ01TZXREZXZpY2VQcm9maWxlKGNtRGlzcGxheURldmlj ZUNsYXNzLCBrQ0dEaXJlY3RNYWluRGlzcGxheSwgJnNjb3BlLCBjbURlZmF1bHRQcm9maWxlSUQs ICZzSW5pdGlhbFByb2ZpbGVMb2NhdGlvbik7CiAgICAgICAgIGlmIChlcnJvcikKLSAgICAgICAg ICAgIGZwcmludGYoc3RkZXJyLCAiRmFpbGVkIHRvIHJldG9yZSBwcmV2aW91cyBjb2xvciBwcm9m aWxlISAgWW91IG1heSBuZWVkIHRvIG9wZW4gU3lzdGVtIFByZWZlcmVuY2VzIDogRGlzcGxheXMg OiBDb2xvciBhbmQgbWFudWFsbHkgcmVzdG9yZSB5b3VyIGNvbG9yIHNldHRpbmdzLiAgKEVycm9y OiAlaSkiLCBlcnJvcik7Ci0gICAgICAgIGNoYW5nZWRDb2xvclByb2ZpbGUgPSBmYWxzZTsKKyAg ICAgICAgICAgIGZwcmludGYoc3RkZXJyLCAiRmFpbGVkIHRvIHJlc3RvcmUgaW5pdGlhbCBjb2xv ciBwcm9maWxlIGZvciBtYWluIGRpc3BsYXkhIE9wZW4gU3lzdGVtIFByZWZlcmVuY2VzID4gRGlz cGxheXMgPiBDb2xvciBhbmQgbWFudWFsbHkgcmUtc2VsZWN0IHRoZSBwcm9maWxlLiAgKEVycm9y OiAlaSkiLCBlcnJvcik7CisgICAgICAgIHNJbml0aWFsUHJvZmlsZUxvY2F0aW9uLmxvY1R5cGUg PSBjbU5vUHJvZmlsZUJhc2U7CiAgICAgfQogfQogCi1zdGF0aWMgdm9pZCBmYWlsZWRHZXR0aW5n Q3VycmVudFByb2ZpbGUoaW50IGVycm9yKQordm9pZCBzZXR1cE1haW5EaXNwbGF5Q29sb3JQcm9m aWxlKCkKIHsKLSAgICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byBnZXQgY3VycmVudCBjb2xv ciBwcm9maWxlLiAgSSB3aWxsIG5vdCBiZSBhYmxlIHRvIHJlc3RvcmUgeW91ciBjdXJyZW50IHBy b2ZpbGUsIHRodXMgSSdtIG5vdCBjaGFuZ2luZyBpdC4gIE1hbnkgcGl4ZWwgdGVzdHMgbWF5IGZh aWwgYXMgYSByZXN1bHQuICAoRXJyb3I6ICVpKVxuIiwgZXJyb3IpOwotfQotCi1zdGF0aWMgdm9p ZCBzZXREZWZhdWx0Q29sb3JQcm9maWxlVG9SR0IoKQotewotICAgIENNUHJvZmlsZVJlZiBnZW5l cmljUHJvZmlsZSA9IChDTVByb2ZpbGVSZWYpW1tOU0NvbG9yU3BhY2UgZ2VuZXJpY1JHQkNvbG9y U3BhY2VdIGNvbG9yU3luY1Byb2ZpbGVdOwotICAgIENNUHJvZmlsZUxvY2F0aW9uIGdlbmVyaWNQ cm9maWxlTG9jYXRpb247Ci0gICAgVUludDMyIGxvY2F0aW9uU2l6ZSA9IHNpemVvZihnZW5lcmlj UHJvZmlsZUxvY2F0aW9uKTsKLSAgICBpbnQgZXJyb3IgPSBOQ01HZXRQcm9maWxlTG9jYXRpb24o Z2VuZXJpY1Byb2ZpbGUsICZnZW5lcmljUHJvZmlsZUxvY2F0aW9uLCAmbG9jYXRpb25TaXplKTsK LSAgICBpZiAoZXJyb3IpIHsKLSAgICAgICAgZmFpbGVkR2V0dGluZ0N1cnJlbnRQcm9maWxlKGVy cm9yKTsKLSAgICAgICAgcmV0dXJuOworICAgIGNvbnN0IENNRGV2aWNlU2NvcGUgc2NvcGUgPSB7 IGtDRlByZWZlcmVuY2VzQ3VycmVudFVzZXIsIGtDRlByZWZlcmVuY2VzQ3VycmVudEhvc3QgfTsK KyAgICBpbnQgZXJyb3I7CisgICAgCisgICAgQ01Qcm9maWxlUmVmIHByb2ZpbGUgPSBOVUxMOwor ICAgIGVycm9yID0gQ01HZXRQcm9maWxlQnlBVklEKGtDR0RpcmVjdE1haW5EaXNwbGF5LCAmcHJv ZmlsZSk7CisgICAgaWYgKCFlcnJvcikgeworICAgICAgICBVSW50MzIgc2l6ZSA9IHNpemVvZihD TVByb2ZpbGVMb2NhdGlvbik7CisgICAgICAgIGVycm9yID0gTkNNR2V0UHJvZmlsZUxvY2F0aW9u KHByb2ZpbGUsICZzSW5pdGlhbFByb2ZpbGVMb2NhdGlvbiwgJnNpemUpOworICAgICAgICBDTUNs b3NlUHJvZmlsZShwcm9maWxlKTsKICAgICB9Ci0KLSAgICBDTVByb2ZpbGVMb2NhdGlvbiBwcmV2 aW91c1Byb2ZpbGVMb2NhdGlvbjsKLSAgICBlcnJvciA9IENNR2V0RGV2aWNlUHJvZmlsZShjbURp c3BsYXlEZXZpY2VDbGFzcywgY21EZWZhdWx0RGV2aWNlSUQsIGNtRGVmYXVsdFByb2ZpbGVJRCwg JnByZXZpb3VzUHJvZmlsZUxvY2F0aW9uKTsKICAgICBpZiAoZXJyb3IpIHsKLSAgICAgICAgZmFp bGVkR2V0dGluZ0N1cnJlbnRQcm9maWxlKGVycm9yKTsKKyAgICAgICAgZnByaW50ZihzdGRlcnIs ICJGYWlsZWQgdG8gcmV0cmlldmUgY3VycmVudCBjb2xvciBwcm9maWxlIGZvciBtYWluIGRpc3Bs YXksIHRodXMgaXQgd29uJ3QgYmUgY2hhbmdlZC4gIE1hbnkgcGl4ZWwgdGVzdHMgbWF5IGZhaWwg YXMgYSByZXN1bHQuICAoRXJyb3I6ICVpKSIsIGVycm9yKTsKKyAgICAgICAgc0luaXRpYWxQcm9m aWxlTG9jYXRpb24ubG9jVHlwZSA9IGNtTm9Qcm9maWxlQmFzZTsKICAgICAgICAgcmV0dXJuOwog ICAgIH0KKyAgICAKKyAgICBDTVByb2ZpbGVMb2NhdGlvbiBsb2NhdGlvbjsKKyAgICBsb2NhdGlv bi5sb2NUeXBlID0gY21GaWxlQmFzZWRQcm9maWxlOworICAgIE5TVVJMKiB1cmwgPSBbTlNVUkwg ZmlsZVVSTFdpdGhQYXRoOltOU1N0cmluZyBzdHJpbmdXaXRoVVRGOFN0cmluZzpQUk9GSUxFX1BB VEhdXTsKKyAgICBGU1JlZiBmc1JlZjsKKyAgICBpZiAodXJsICYmIENGVVJMR2V0RlNSZWYoKENG VVJMUmVmKXVybCwgJmZzUmVmKSkgeworICAgICAgICBlcnJvciA9IEZTR2V0Q2F0YWxvZ0luZm8o JmZzUmVmLCAwLCBOVUxMLCBOVUxMLCAmbG9jYXRpb24udS5maWxlTG9jLnNwZWMsIE5VTEwpOwor ICAgICAgICBpZihlcnJvciA9PSBub0VycikKKyAgICAgICAgZXJyb3IgPSBDTVNldERldmljZVBy b2ZpbGUoY21EaXNwbGF5RGV2aWNlQ2xhc3MsIGtDR0RpcmVjdE1haW5EaXNwbGF5LCAmc2NvcGUs IGNtRGVmYXVsdFByb2ZpbGVJRCwgJmxvY2F0aW9uKTsKKyAgICB9CisgICAgZWxzZQorICAgICAg ICBlcnJvciA9IC0xOwogCi0gICAgQ01Qcm9maWxlUmVmIHByZXZpb3VzUHJvZmlsZTsKLSAgICBl cnJvciA9IENNT3BlblByb2ZpbGUoJnByZXZpb3VzUHJvZmlsZSwgJnByZXZpb3VzUHJvZmlsZUxv Y2F0aW9uKTsKICAgICBpZiAoZXJyb3IpIHsKLSAgICAgICAgZmFpbGVkR2V0dGluZ0N1cnJlbnRQ cm9maWxlKGVycm9yKTsKKyAgICAgICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gc2V0IGNv bG9yIHByb2ZpbGUgZm9yIG1haW4gZGlzcGxheSEgIE1hbnkgcGl4ZWwgdGVzdHMgbWF5IGZhaWwg YXMgYSByZXN1bHQuICAoRXJyb3I6ICVpKSIsIGVycm9yKTsKKyAgICAgICAgc0luaXRpYWxQcm9m aWxlTG9jYXRpb24ubG9jVHlwZSA9IGNtTm9Qcm9maWxlQmFzZTsKICAgICAgICAgcmV0dXJuOwog ICAgIH0KLQotICAgIENGU3RyaW5nUmVmIHByZXZpb3VzUHJvZmlsZU5hbWU7Ci0gICAgQ0ZTdHJp bmdSZWYgZ2VuZXJpY1Byb2ZpbGVOYW1lOwotICAgIGNoYXIgcHJldmlvdXNQcm9maWxlTmFtZVN0 cmluZ1sxMDI0XTsKLSAgICBjaGFyIGdlbmVyaWNQcm9maWxlTmFtZVN0cmluZ1sxMDI0XTsKLSAg ICBDTUNvcHlQcm9maWxlRGVzY3JpcHRpb25TdHJpbmcocHJldmlvdXNQcm9maWxlLCAmcHJldmlv dXNQcm9maWxlTmFtZSk7Ci0gICAgQ01Db3B5UHJvZmlsZURlc2NyaXB0aW9uU3RyaW5nKGdlbmVy aWNQcm9maWxlLCAmZ2VuZXJpY1Byb2ZpbGVOYW1lKTsKLSAgICBDRlN0cmluZ0dldENTdHJpbmco cHJldmlvdXNQcm9maWxlTmFtZSwgcHJldmlvdXNQcm9maWxlTmFtZVN0cmluZywgc2l6ZW9mKHBy ZXZpb3VzUHJvZmlsZU5hbWVTdHJpbmcpLCBrQ0ZTdHJpbmdFbmNvZGluZ1VURjgpOwotICAgIENG U3RyaW5nR2V0Q1N0cmluZyhnZW5lcmljUHJvZmlsZU5hbWUsIGdlbmVyaWNQcm9maWxlTmFtZVN0 cmluZywgc2l6ZW9mKHByZXZpb3VzUHJvZmlsZU5hbWVTdHJpbmcpLCBrQ0ZTdHJpbmdFbmNvZGlu Z1VURjgpOwotICAgIENGUmVsZWFzZShwcmV2aW91c1Byb2ZpbGVOYW1lKTsKLSAgICBDRlJlbGVh c2UoZ2VuZXJpY1Byb2ZpbGVOYW1lKTsKLQotICAgIENNQ2xvc2VQcm9maWxlKHByZXZpb3VzUHJv ZmlsZSk7Ci0KLSAgICBmcHJpbnRmKHN0ZGVyciwgIlxuXG5XQVJOSU5HOiBUZW1wb3JhcmlseSBj aGFuZ2luZyB5b3VyIHN5c3RlbSBjb2xvciBwcm9maWxlIGZyb20gXCIlc1wiIHRvIFwiJXNcIi5c biIsIHByZXZpb3VzUHJvZmlsZU5hbWVTdHJpbmcsIGdlbmVyaWNQcm9maWxlTmFtZVN0cmluZyk7 CisgICAgCisgICAgLy8gT3RoZXIgc2lnbmFscyBhcmUgaGFuZGxlZCBpbiBpbnN0YWxsU2lnbmFs SGFuZGxlcnMoKSB3aGljaCBhbHNvIGNhbGxzIHJlc3RvcmVNYWluRGlzcGxheUNvbG9yUHJvZmls ZSgpCisgICAgc2lnbmFsKFNJR0lOVCwgcmVzdG9yZU1haW5EaXNwbGF5Q29sb3JQcm9maWxlKTsK KyAgICBzaWduYWwoU0lHSFVQLCByZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUpOworICAg IHNpZ25hbChTSUdURVJNLCByZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUpOworICAgIAor ICAgIGZwcmludGYoc3RkZXJyLCAiXG5cbldBUk5JTkc6IFRlbXBvcmFyaWx5IGNoYW5naW5nIHRo ZSBtYWluIGRpc3BsYXkgY29sb3IgcHJvZmlsZSB0byBcIiVzXCI6IHRoZSBjb2xvcnMgb24geW91 ciBzY3JlZW4gd2lsbCBjaGFuZ2UgZm9yIHRoZSBkdXJhdGlvbiBvZiB0aGUgdGVzdGluZy5cbiIs IFBST0ZJTEVfUEFUSCk7CiAgICAgZnByaW50ZihzdGRlcnIsICJUaGlzIGFsbG93cyB0aGUgV2Vi S2l0IHBpeGVsLWJhc2VkIHJlZ3Jlc3Npb24gdGVzdHMgdG8gaGF2ZSBjb25zaXN0ZW50IGNvbG9y IHZhbHVlcyBhY3Jvc3MgYWxsIG1hY2hpbmVzLlxuIik7Ci0gICAgZnByaW50ZihzdGRlcnIsICJU aGUgY29sb3JzIG9uIHlvdXIgc2NyZWVuIHdpbGwgY2hhbmdlIGZvciB0aGUgZHVyYXRpb24gb2Yg dGhlIHRlc3RpbmcuXG5cbiIpOwotCi0gICAgQ01EZXZpY2VTY29wZSBzY29wZSA9IHsga0NGUHJl ZmVyZW5jZXNDdXJyZW50VXNlciwga0NGUHJlZmVyZW5jZXNDdXJyZW50SG9zdCB9OwotICAgIGlm ICgoZXJyb3IgPSBDTVNldERldmljZVByb2ZpbGUoY21EaXNwbGF5RGV2aWNlQ2xhc3MsIGNtRGVm YXVsdERldmljZUlELCAmc2NvcGUsIGNtRGVmYXVsdFByb2ZpbGVJRCwgJmdlbmVyaWNQcm9maWxl TG9jYXRpb24pKSkgewotICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byBzZXQgY29s b3IgcHJvZmlsZSB0byBcIiVzXCIhIE1hbnkgcGl4ZWwgdGVzdHMgd2lsbCBmYWlsIGFzIGEgcmVz dWx0LiAgKEVycm9yOiAlaSkiLAotICAgICAgICAgICAgZ2VuZXJpY1Byb2ZpbGVOYW1lU3RyaW5n LCBlcnJvcik7Ci0gICAgfSBlbHNlIHsKLSAgICAgICAgY3VycmVudENvbG9yUHJvZmlsZUxvY2F0 aW9uID0gcHJldmlvdXNQcm9maWxlTG9jYXRpb247Ci0gICAgICAgIGNoYW5nZWRDb2xvclByb2Zp bGUgPSB0cnVlOwotICAgICAgICBzaWduYWwoU0lHSU5ULCByZXN0b3JlQ29sb3JTcGFjZSk7Ci0g ICAgICAgIHNpZ25hbChTSUdIVVAsIHJlc3RvcmVDb2xvclNwYWNlKTsKLSAgICAgICAgc2lnbmFs KFNJR1RFUk0sIHJlc3RvcmVDb2xvclNwYWNlKTsKLSAgICB9Ci19Ci0KLXZvaWQgaW5pdGlhbGl6 ZUNvbG9yU3BhY2VBbmRTY3JlZUJ1ZmZlckZvclBpeGVsVGVzdHMoKQotewotICAgIHNldERlZmF1 bHRDb2xvclByb2ZpbGVUb1JHQigpOwotICAgIHNjcmVlbkNhcHR1cmVCdWZmZXIgPSAodW5zaWdu ZWQgY2hhciAqKW1hbGxvYyhtYXhWaWV3SGVpZ2h0ICogbWF4Vmlld1dpZHRoICogNCk7Ci0gICAg c2hhcmVkQ29sb3JTcGFjZSA9IENHQ29sb3JTcGFjZUNyZWF0ZURldmljZVJHQigpOwotfQotCi0v LyBEZWNsYXJlZCBpbiBQaXhlbER1bXBTdXBwb3J0Q0cuaAotCi1SZXRhaW5QdHI8Q0dDb250ZXh0 UmVmPiBnZXRCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoKQotewotICAgIE5TU2l6ZSB3ZWJWaWV3 U2l6ZSA9IFtbbWFpbkZyYW1lIHdlYlZpZXddIGZyYW1lXS5zaXplOwotICAgIHJldHVybiBSZXRh aW5QdHI8Q0dDb250ZXh0UmVmPihBZG9wdENGLCBDR0JpdG1hcENvbnRleHRDcmVhdGUoc2NyZWVu Q2FwdHVyZUJ1ZmZlciwgc3RhdGljX2Nhc3Q8c2l6ZV90Pih3ZWJWaWV3U2l6ZS53aWR0aCksIHN0 YXRpY19jYXN0PHNpemVfdD4od2ViVmlld1NpemUuaGVpZ2h0KSwgOCwgc3RhdGljX2Nhc3Q8c2l6 ZV90Pih3ZWJWaWV3U2l6ZS53aWR0aCkgKiA0LCBzaGFyZWRDb2xvclNwYWNlLCBrQ0dCaXRtYXBC eXRlT3JkZXIzMkhvc3QgfCBrQ0dJbWFnZUFscGhhUHJlbXVsdGlwbGllZExhc3QpKTsKIH0KIAot dm9pZCBwYWludFdlYlZpZXcoQ0dDb250ZXh0UmVmIGNvbnRleHQpCisvLyBCZWNhdXNlIG9mIEFw cEtpdCAvIFdlYktpdCBjb25zdHJhaW50cywgd2UgY2FuJ3QgcmVuZGVyIGRpcmVjdGx5IGluIHRo ZQorLy8gY29sb3JzcGFjZSBvZiBvdXIgY2hvaWNlLgorLy8gCisvLyBTbyB3ZSBoYXZlIHRvIHJl bmRlciB0byBEZXZpY2VSR0IsIHdoaWNoIGJhc2ljYWxseSBtZWFucyBzYW1lIGFzIG1haW4gZGlz cGxheQorLy8gY29sb3JzcGFjZS4KKy8vIAorLy8gVGhpcyBpbXBsaWVzIHdlIGhhdmUgdG8gdGVt cG9yYXJpbHkgY2hhbmdlIHRoZSBwcm9maWxlIG9mIHRoZSBtYWluIGRpc3BsYXkgdG8KKy8vIHRo ZSBjb2xvcnNwYWNlIHdlIHdhbnQgdG8gcmVuZGVyIGludG8uCisvLyAKKy8vIEZpbmFsbHksIHdl IHdhbnQgdGhlIHJlbmRlcmVkIGJpdG1hcCB0byBhbHdheXMgYmUgaW4gcHJlbXVsdGlwbGllZCBS R0JBOCB0bworLy8gZW5zdXJlIGVuZGlhbiBpbmRlcGVuZGVuY3kgYW5kIGhhdmUgY29uc2lzdGVu dCBNRDUgaGFzaGVzCisvLyAKKy8vIE5vdGUgdGhhdCByZW5kZXJpbmcgdG8gUkdCQTggaW5kaXJl Y3RseSBkaXNhYmxlcyBDRyBmb250IHNtb290aGluZyBhcyBpdCdzIG9ubHkKKy8vIHN1cHBvcnRl ZCBmb3IgKGtDR0ltYWdlQWxwaGFQcmVtdWx0aXBsaWVkRmlyc3QgfCBrQ0dCaXRtYXBCeXRlT3Jk ZXIzMkhvc3QpLgorCitQYXNzUmVmUHRyPEJpdG1hcENvbnRleHQ+IGdldEJpdG1hcENvbnRleHRG cm9tV2ViVmlldyhib29sIGluY3JlbWVudGFsUmVwYWludCwgYm9vbCBzd2VlcEhvcml6b250YWxs eSwgYm9vbCBkcmF3U2VsZWN0aW9uUmVjdCkKIHsKLSAgICBSZXRhaW5QdHI8TlNHcmFwaGljc0Nv bnRleHQ+IHNhdmVkQ29udGV4dCA9IFtOU0dyYXBoaWNzQ29udGV4dCBjdXJyZW50Q29udGV4dF07 Ci0KLSAgICBOU0dyYXBoaWNzQ29udGV4dCogbnNDb250ZXh0ID0gW05TR3JhcGhpY3NDb250ZXh0 IGdyYXBoaWNzQ29udGV4dFdpdGhHcmFwaGljc1BvcnQ6Y29udGV4dCBmbGlwcGVkOk5PXTsKLSAg ICBbTlNHcmFwaGljc0NvbnRleHQgc2V0Q3VycmVudENvbnRleHQ6bnNDb250ZXh0XTsKLQogICAg IFdlYlZpZXcqIHZpZXcgPSBbbWFpbkZyYW1lIHdlYlZpZXddOwotICAgIFt2aWV3IGRpc3BsYXlJ Zk5lZWRlZF07Ci0gICAgW3ZpZXcgbG9ja0ZvY3VzXTsKLSAgICBOU0JpdG1hcEltYWdlUmVwICpp bWFnZVJlcCA9IFtbTlNCaXRtYXBJbWFnZVJlcCBhbGxvY10gaW5pdFdpdGhGb2N1c2VkVmlld1Jl Y3Q6W3ZpZXcgZnJhbWVdXTsKLSAgICBbdmlldyB1bmxvY2tGb2N1c107Ci0gICAgW2ltYWdlUmVw IGRyYXddOwotICAgIFtpbWFnZVJlcCByZWxlYXNlXTsKLQotICAgIFtOU0dyYXBoaWNzQ29udGV4 dCBzZXRDdXJyZW50Q29udGV4dDpzYXZlZENvbnRleHQuZ2V0KCldOwotfQotCi12b2lkIHJlcGFp bnRXZWJWaWV3KENHQ29udGV4dFJlZiBjb250ZXh0LCBib29sIGhvcml6b250YWwpCi17Ci0gICAg UmV0YWluUHRyPE5TR3JhcGhpY3NDb250ZXh0PiBzYXZlZENvbnRleHQgPSBbTlNHcmFwaGljc0Nv bnRleHQgY3VycmVudENvbnRleHRdOwotCi0gICAgTlNHcmFwaGljc0NvbnRleHQqIG5zQ29udGV4 dCA9IFtOU0dyYXBoaWNzQ29udGV4dCBncmFwaGljc0NvbnRleHRXaXRoR3JhcGhpY3NQb3J0OmNv bnRleHQgZmxpcHBlZDpOT107Ci0gICAgW05TR3JhcGhpY3NDb250ZXh0IHNldEN1cnJlbnRDb250 ZXh0Om5zQ29udGV4dF07Ci0KLSAgICBXZWJWaWV3ICp2aWV3ID0gW21haW5GcmFtZSB3ZWJWaWV3 XTsKICAgICBOU1NpemUgd2ViVmlld1NpemUgPSBbdmlldyBmcmFtZV0uc2l6ZTsKLQotICAgIGlm IChob3Jpem9udGFsKSB7Ci0gICAgICAgIGZvciAoTlNSZWN0IGNvbHVtbiA9IE5TTWFrZVJlY3Qo MCwgMCwgMSwgd2ViVmlld1NpemUuaGVpZ2h0KTsgY29sdW1uLm9yaWdpbi54IDwgd2ViVmlld1Np emUud2lkdGg7IGNvbHVtbi5vcmlnaW4ueCsrKQotICAgICAgICAgICAgW3ZpZXcgZGlzcGxheVJl Y3RJZ25vcmluZ09wYWNpdHk6Y29sdW1uIGluQ29udGV4dDpuc0NvbnRleHRdOwotICAgIH0gZWxz ZSB7Ci0gICAgICAgIGZvciAoTlNSZWN0IGxpbmUgPSBOU01ha2VSZWN0KDAsIDAsIHdlYlZpZXdT aXplLndpZHRoLCAxKTsgbGluZS5vcmlnaW4ueSA8IHdlYlZpZXdTaXplLmhlaWdodDsgbGluZS5v cmlnaW4ueSsrKQotICAgICAgICAgICAgW3ZpZXcgZGlzcGxheVJlY3RJZ25vcmluZ09wYWNpdHk6 bGluZSBpbkNvbnRleHQ6bnNDb250ZXh0XTsKKyAgICBzaXplX3QgcGl4ZWxzV2lkZSA9IHN0YXRp Y19jYXN0PHNpemVfdD4od2ViVmlld1NpemUud2lkdGgpOworICAgIHNpemVfdCBwaXhlbHNIaWdo ID0gc3RhdGljX2Nhc3Q8c2l6ZV90Pih3ZWJWaWV3U2l6ZS5oZWlnaHQpOworICAgIHNpemVfdCBy b3dCeXRlcyA9ICg0ICogcGl4ZWxzV2lkZSArIDYzKSAmIH42MzsgLy8gVXNlIGEgbXVsdGlwbGUg b2YgNjQgYnl0ZXMgdG8gaW1wcm92ZSBDRyBwZXJmb3JtYW5jZXMKKworICAgIHZvaWQqIGJ1ZmZl ciA9IGNhbGxvYyhwaXhlbHNIaWdoLCByb3dCeXRlcyk7CisgICAgaWYgKCFidWZmZXIpCisgICAg ICAgIHJldHVybiAwOworICAgIAorICAgIFJldGFpblB0cjxDR0NvbG9yU3BhY2VSZWY+IGNvbG9y U3BhY2UoQWRvcHRDRiwgQ0dDb2xvclNwYWNlQ3JlYXRlRGV2aWNlUkdCKCkpOworICAgIENHQ29u dGV4dFJlZiBjb250ZXh0ID0gQ0dCaXRtYXBDb250ZXh0Q3JlYXRlKGJ1ZmZlciwgcGl4ZWxzV2lk ZSwgcGl4ZWxzSGlnaCwgOCwgcm93Qnl0ZXMsIGNvbG9yU3BhY2UuZ2V0KCksIGtDR0ltYWdlQWxw aGFQcmVtdWx0aXBsaWVkTGFzdCB8IGtDR0JpdG1hcEJ5dGVPcmRlcjMyQmlnKTsKKyAgICBpZiAo IWNvbnRleHQpIHsKKyAgICAgICAgZnJlZShidWZmZXIpOworICAgICAgICByZXR1cm4gMDsKICAg ICB9CiAKLSAgICBbTlNHcmFwaGljc0NvbnRleHQgc2V0Q3VycmVudENvbnRleHQ6c2F2ZWRDb250 ZXh0LmdldCgpXTsKLX0KLQotQ0dSZWN0IGdldFNlbGVjdGlvblJlY3QoKQotewotICAgIE5TVmll dyAqZG9jdW1lbnRWaWV3ID0gW1ttYWluRnJhbWUgZnJhbWVWaWV3XSBkb2N1bWVudFZpZXddOwot ICAgIGlmIChbZG9jdW1lbnRWaWV3IGNvbmZvcm1zVG9Qcm90b2NvbDpAcHJvdG9jb2woV2ViRG9j dW1lbnRTZWxlY3Rpb24pXSkgewotICAgICAgICBOU1JlY3QgcmVjdCA9IFtkb2N1bWVudFZpZXcg Y29udmVydFJlY3Q6WyhpZCA8V2ViRG9jdW1lbnRTZWxlY3Rpb24+KWRvY3VtZW50VmlldyBzZWxl Y3Rpb25SZWN0XSBmcm9tVmlldzpuaWxdOwotICAgICAgICByZXR1cm4gQ0dSZWN0TWFrZShyZWN0 Lm9yaWdpbi54LCByZWN0Lm9yaWdpbi55LCByZWN0LnNpemUud2lkdGgsIHJlY3Quc2l6ZS5oZWln aHQpOworICAgIC8vIFRoZSBCaXRtYXBDb250ZXh0IGtlZXBzIHRoZSBDR0NvbnRleHRSZWYgYW5k IHRoZSBwaXhlbCBidWZmZXIgYWxpdmUKKyAgICBSZWZQdHI8Qml0bWFwQ29udGV4dD4gYml0bWFw Q29udGV4dCA9IEJpdG1hcENvbnRleHQ6OmNyZWF0ZShidWZmZXIsIGNvbnRleHQpOworICAgIAor ICAgIE5TR3JhcGhpY3NDb250ZXh0KiBuc0NvbnRleHQgPSBbTlNHcmFwaGljc0NvbnRleHQgZ3Jh cGhpY3NDb250ZXh0V2l0aEdyYXBoaWNzUG9ydDpjb250ZXh0IGZsaXBwZWQ6Tk9dOworICAgIEFT U0VSVChuc0NvbnRleHQpOworICAgIAorICAgIGlmIChpbmNyZW1lbnRhbFJlcGFpbnQpIHsKKyAg ICAgICAgaWYgKHN3ZWVwSG9yaXpvbnRhbGx5KSB7CisgICAgICAgICAgICBmb3IgKE5TUmVjdCBj b2x1bW4gPSBOU01ha2VSZWN0KDAsIDAsIDEsIHdlYlZpZXdTaXplLmhlaWdodCk7IGNvbHVtbi5v cmlnaW4ueCA8IHdlYlZpZXdTaXplLndpZHRoOyBjb2x1bW4ub3JpZ2luLngrKykKKyAgICAgICAg ICAgICAgICBbdmlldyBkaXNwbGF5UmVjdElnbm9yaW5nT3BhY2l0eTpjb2x1bW4gaW5Db250ZXh0 Om5zQ29udGV4dF07CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICBmb3IgKE5TUmVjdCBs aW5lID0gTlNNYWtlUmVjdCgwLCAwLCB3ZWJWaWV3U2l6ZS53aWR0aCwgMSk7IGxpbmUub3JpZ2lu LnkgPCB3ZWJWaWV3U2l6ZS5oZWlnaHQ7IGxpbmUub3JpZ2luLnkrKykKKyAgICAgICAgICAgICAg ICBbdmlldyBkaXNwbGF5UmVjdElnbm9yaW5nT3BhY2l0eTpsaW5lIGluQ29udGV4dDpuc0NvbnRl eHRdOworICAgICAgICB9CisgICAgfQorICAgIGVsc2UgeworICAgICAgICAvLyBGSVhNRTogVGhp cyBwYXRoIGlzIHN1Ym9wdGltYWw6IGRhdGEgaXMgcmVhZCBmcm9tIHdpbmRvdyBiYWNraW5nIHN0 b3JlLCBjb252ZXJ0ZWQgdG8gUkdCOCB0aGVuIGRyYXduIGFnYWluIGludG8gYW4gUkdCQTggYml0 bWFwCisgICAgICAgIFt2aWV3IGRpc3BsYXlJZk5lZWRlZF07CisgICAgICAgIFt2aWV3IGxvY2tG b2N1c107CisgICAgICAgIE5TQml0bWFwSW1hZ2VSZXAgKmltYWdlUmVwID0gW1tbTlNCaXRtYXBJ bWFnZVJlcCBhbGxvY10gaW5pdFdpdGhGb2N1c2VkVmlld1JlY3Q6W3ZpZXcgZnJhbWVdXSBhdXRv cmVsZWFzZV07CisgICAgICAgIFt2aWV3IHVubG9ja0ZvY3VzXTsKKworICAgICAgICBSZXRhaW5Q dHI8TlNHcmFwaGljc0NvbnRleHQ+IHNhdmVkQ29udGV4dCA9IFtOU0dyYXBoaWNzQ29udGV4dCBj dXJyZW50Q29udGV4dF07CisgICAgICAgIFtOU0dyYXBoaWNzQ29udGV4dCBzZXRDdXJyZW50Q29u dGV4dDpuc0NvbnRleHRdOworICAgICAgICBbaW1hZ2VSZXAgZHJhd107CisgICAgICAgIFtOU0dy YXBoaWNzQ29udGV4dCBzZXRDdXJyZW50Q29udGV4dDpzYXZlZENvbnRleHQuZ2V0KCldOwogICAg IH0KIAotICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwotICAgIHJldHVybiBDR1JlY3RaZXJvOwor ICAgIGlmIChkcmF3U2VsZWN0aW9uUmVjdCkgeworICAgICAgICBOU1ZpZXcqIGRvY3VtZW50Vmll dyA9IFtbbWFpbkZyYW1lIGZyYW1lVmlld10gZG9jdW1lbnRWaWV3XTsKKyAgICAgICAgaWYgKFtk b2N1bWVudFZpZXcgY29uZm9ybXNUb1Byb3RvY29sOkBwcm90b2NvbChXZWJEb2N1bWVudFNlbGVj dGlvbildKSB7CisgICAgICAgICAgICBOU1JlY3QgcmVjdCA9IFtkb2N1bWVudFZpZXcgY29udmVy dFJlY3Q6WyhpZCA8V2ViRG9jdW1lbnRTZWxlY3Rpb24+KWRvY3VtZW50VmlldyBzZWxlY3Rpb25S ZWN0XSBmcm9tVmlldzpuaWxdOworICAgICAgICAgICAgCisgICAgICAgICAgICBDR0NvbnRleHRT YXZlR1N0YXRlKGNvbnRleHQpOworICAgICAgICAgICAgQ0dDb250ZXh0U2V0TGluZVdpZHRoKGNv bnRleHQsIDEuMCk7CisgICAgICAgICAgICBDR0NvbnRleHRTZXRSR0JTdHJva2VDb2xvcihjb250 ZXh0LCAxLjAsIDAuMCwgMC4wLCAxLjApOworICAgICAgICAgICAgQ0dDb250ZXh0U3Ryb2tlUmVj dChjb250ZXh0LCBDR1JlY3RNYWtlKHJlY3Qub3JpZ2luLngsIHJlY3Qub3JpZ2luLnksIHJlY3Qu c2l6ZS53aWR0aCwgcmVjdC5zaXplLmhlaWdodCkpOworICAgICAgICAgICAgQ0dDb250ZXh0UmVz dG9yZUdTdGF0ZShjb250ZXh0KTsKKyAgICAgICAgfQorICAgICAgICBlbHNlCisgICAgICAgICAg ICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisgICAgCisgICAgcmV0dXJuIGJpdG1hcENv bnRleHQucmVsZWFzZSgpOwogfQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dp bi9EdW1wUmVuZGVyVHJlZS5jcHAKaW5kZXggOTNkYjFkOS4uNzZmMTY4NyAxMDA2NDQKLS0tIGEv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcAorKysgYi9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCkBAIC03Niw3 ICs3Niw3IEBAIHN0YXRpYyBib29sIGxlYWtDaGVja2luZyA9IGZhbHNlOwogc3RhdGljIGJvb2wg dGhyZWFkZWQgPSBmYWxzZTsKIHN0YXRpYyBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IHBlcnNpc3Rl bnRVc2VyU3R5bGVTaGVldExvY2F0aW9uOwogCi1zdGF0aWMgY29uc3QgY2hhciogY3VycmVudFRl c3Q7CitzdGF0aWMgc3RkOjpzdHJpbmcgZ0N1cnJlbnRUZXN0OwogCiB2b2xhdGlsZSBib29sIGRv bmU7CiAvLyBUaGlzIGlzIHRoZSB0b3Btb3N0IGZyYW1lIHRoYXQgaXMgbG9hZGluZywgZHVyaW5n IGEgZ2l2ZW4gbG9hZCwgb3IgbmlsIHdoZW4gbm8gbG9hZCBpcyAKQEAgLTU2MCw3ICs1NjAsNyBA QCB2b2lkIGR1bXAoKQogICAgICAgICAgICAgd3N0cmluZyByZXN1bHQgPSBkdW1wRnJhbWVzQXNU ZXh0KGZyYW1lKTsKICAgICAgICAgICAgIHJlc3VsdFN0cmluZyA9IFN5c0FsbG9jU3RyaW5nTGVu KHJlc3VsdC5kYXRhKCksIHJlc3VsdC5zaXplKCkpOwogICAgICAgICB9IGVsc2UgewotICAgICAg ICAgICAgYm9vbCBpc1NWR1czQ1Rlc3QgPSBzdHJzdHIoY3VycmVudFRlc3QsICJzdmdcXFczQy1T VkctMS4xIik7CisgICAgICAgICAgICBib29sIGlzU1ZHVzNDVGVzdCA9IChnQ3VycmVudFRlc3Qu ZmluZCgic3ZnXFxXM0MtU1ZHLTEuMSIpICE9IHN0cmluZzo6bnBvcyk7CiAgICAgICAgICAgICB1 bnNpZ25lZCB3aWR0aDsKICAgICAgICAgICAgIHVuc2lnbmVkIGhlaWdodDsKICAgICAgICAgICAg IGlmIChpc1NWR1czQ1Rlc3QpIHsKQEAgLTYwOCw3ICs2MDgsNyBAQCB2b2lkIGR1bXAoKQogICAg ICAgICBpZiAoZ0xheW91dFRlc3RDb250cm9sbGVyLT5kdW1wQXNUZXh0KCkgfHwgZ0xheW91dFRl c3RDb250cm9sbGVyLT5kdW1wRE9NQXNXZWJBcmNoaXZlKCkgfHwgZ0xheW91dFRlc3RDb250cm9s bGVyLT5kdW1wU291cmNlQXNXZWJBcmNoaXZlKCkpCiAgICAgICAgICAgICBwcmludGYoIiNFT0Zc biIpOwogICAgICAgICBlbHNlCi0gICAgICAgICAgICBkdW1wV2ViVmlld0FzUGl4ZWxzQW5kQ29t cGFyZVdpdGhFeHBlY3RlZChjdXJyZW50VGVzdCwgZHVtcEFsbFBpeGVscyk7CisgICAgICAgICAg ICBkdW1wV2ViVmlld0FzUGl4ZWxzQW5kQ29tcGFyZVdpdGhFeHBlY3RlZChnTGF5b3V0VGVzdENv bnRyb2xsZXItPmV4cGVjdGVkUGl4ZWxIYXNoKCkpOwogICAgICAgICBmZmx1c2goc3Rkb3V0KTsK ICAgICB9CiAKQEAgLTY5NCw3ICs2OTQsNyBAQCBzdGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0IGNo YXIqIHBhdGhPclVSTCkKIAogICAgIENGUmVsZWFzZSh1cmwpOwogCi0gICAgY3VycmVudFRlc3Qg PSBwYXRoT3JVUkw7CisgICAgZ0N1cnJlbnRUZXN0ID0gcGF0aE9yVVJMOwogCiAgICAgOjpnTGF5 b3V0VGVzdENvbnRyb2xsZXIgPSBuZXcgTGF5b3V0VGVzdENvbnRyb2xsZXIoZmFsc2UsIGZhbHNl KTsKICAgICBkb25lID0gZmFsc2U7CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS93aW4vUGl4ZWxEdW1wU3VwcG9ydFdpbi5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS93aW4vUGl4ZWxEdW1wU3VwcG9ydFdpbi5jcHAKaW5kZXggZjZkZDgyZC4uNmM3MTkxZSAx MDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL1BpeGVsRHVtcFN1cHBv cnRXaW4uY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9QaXhlbER1bXBT dXBwb3J0V2luLmNwcApAQCAtMzMsNyArMzMsNyBAQAogI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25z Lmg+CiAjaW5jbHVkZSA8d3RmL1JldGFpblB0ci5oPgogCi1SZXRhaW5QdHI8Q0dDb250ZXh0UmVm PiBnZXRCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoKQorUGFzc1JlZlB0cjxCaXRtYXBDb250ZXh0 PiBnZXRCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoYm9vbCBpbmNyZW1lbnRhbFJlcGFpbnQsIGJv b2wgc3dlZXBIb3Jpem9udGFsbHksIGJvb2wgZHJhd1NlbGVjdGlvblJlY3QpCiB7CiAgICAgUkVD VCBmcmFtZTsKICAgICBpZiAoIUdldFdpbmRvd1JlY3Qod2ViVmlld1dpbmRvdywgJmZyYW1lKSkK QEAgLTQ3LDggKzQ3LDYgQEAgUmV0YWluUHRyPENHQ29udGV4dFJlZj4gZ2V0Qml0bWFwQ29udGV4 dEZyb21XZWJWaWV3KCkKICAgICBibXAuYm1pSGVhZGVyLmJpQml0Q291bnQgPSAzMjsKICAgICBi bXAuYm1pSGVhZGVyLmJpQ29tcHJlc3Npb24gPSBCSV9SR0I7CiAKLSAgICAvLyBGSVhNRTogQ3Vy cmVudGx5IHdlIGxlYWsgdGhpcyBIQklUTUFQIGJlY2F1c2Ugd2UgZG9uJ3QgaGF2ZSBhIGdvb2Qg d2F5Ci0gICAgLy8gdG8gZGVzdHJveSBpdCB3aGVuIHRoZSBDR0JpdG1hcENvbnRleHQgZ2V0cyBk ZXN0cm95ZWQuCiAgICAgdm9pZCogYml0cyA9IDA7CiAgICAgSEJJVE1BUCBiaXRtYXAgPSBDcmVh dGVESUJTZWN0aW9uKDAsICZibXAsIERJQl9SR0JfQ09MT1JTLCAmYml0cywgMCwgMCk7CiAKQEAg LTYyLDYgKzYwLDggQEAgUmV0YWluUHRyPENHQ29udGV4dFJlZj4gZ2V0Qml0bWFwQ29udGV4dEZy b21XZWJWaWV3KCkKICAgICBBU1NFUlQoaW5mby5ibUJpdHNQaXhlbCA9PSAzMik7CiAKICAgICBS ZXRhaW5QdHI8Q0dDb2xvclNwYWNlUmVmPiBjb2xvclNwYWNlKEFkb3B0Q0YsIENHQ29sb3JTcGFj ZUNyZWF0ZURldmljZVJHQigpKTsKLSAgICByZXR1cm4gUmV0YWluUHRyPENHQ29udGV4dFJlZj4o QWRvcHRDRiwgQ0dCaXRtYXBDb250ZXh0Q3JlYXRlKGluZm8uYm1CaXRzLCBpbmZvLmJtV2lkdGgs IGluZm8uYm1IZWlnaHQsIDgsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBpbmZvLmJtV2lkdGhCeXRlcywgY29sb3JTcGFjZS5nZXQoKSwga0NHQml0bWFw Qnl0ZU9yZGVyMzJMaXR0bGUgfCBrQ0dJbWFnZUFscGhhUHJlbXVsdGlwbGllZEZpcnN0KSk7Cisg ICAgQ0dDb250ZXh0UmVmIGNvbnRleHQgPSBDR0JpdG1hcENvbnRleHRDcmVhdGUoaW5mby5ibUJp dHMsIGluZm8uYm1XaWR0aCwgaW5mby5ibUhlaWdodCwgOCwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGluZm8uYm1XaWR0aEJ5dGVzLCBjb2xvclNwYWNl LmdldCgpLCBrQ0dCaXRtYXBCeXRlT3JkZXIzMkxpdHRsZSB8IGtDR0ltYWdlQWxwaGFQcmVtdWx0 aXBsaWVkRmlyc3QpOworCisgICAgcmV0dXJuIEJpdG1hcENvbnRleHQ6OmNyZWF0ZShiaXRtYXAs IGNvbnRleHQpOwogfQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy9ydW4td2Via2l0 LXRlc3RzIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy9ydW4td2Via2l0LXRlc3RzCmluZGV4IGZiNmU5 ZDkuLjg0ZmYxZGEgMTAwNzU1Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvcnVuLXdlYmtpdC10 ZXN0cworKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3J1bi13ZWJraXQtdGVzdHMKQEAgLTU1Myw3 ICs1NTMsMjIgQEAgZm9yIG15ICR0ZXN0IChAdGVzdHMpIHsKICAgICAgICAgfSBlbHNlIHsKICAg ICAgICAgICAgICR0ZXN0UGF0aCA9IGNhbm9ucGF0aCgkdGVzdFBhdGgpOwogICAgICAgICB9Ci0g ICAgICAgIHByaW50IE9VVCAiJHRlc3RQYXRoXG4iOworICAgICAgICAKKyAgICAgICAgaWYgKCRw aXhlbFRlc3RzICYmICEkcmVzZXRSZXN1bHRzKSB7CisgICAgICAgICAgICBteSAkZXhwZWN0ZWRQ aXhlbERpciA9IGV4cGVjdGVkRGlyZWN0b3J5Rm9yVGVzdCgkYmFzZSwgMCwgInBuZyIpOworICAg ICAgICAgICAgIyBUcnkgdG8gcmVhZCBleHBlY3RlZCBoYXNoIGZpbGUKKyAgICAgICAgICAgIGlm IChvcGVuIEVYUEVDVEVESEFTSCwgIiRleHBlY3RlZFBpeGVsRGlyLyRiYXNlLSRleHBlY3RlZFRh Zy5jaGVja3N1bSIpIHsKKyAgICAgICAgICAgICAgICBteSAkZXhwZWN0ZWRIYXNoID0gPEVYUEVD VEVESEFTSD47CisgICAgICAgICAgICAgICAgY2hvbXAoJGV4cGVjdGVkSGFzaCk7CisgICAgICAg ICAgICAgICAgY2xvc2UgRVhQRUNURURIQVNIOworICAgICAgICAgICAgICAgICMgU2VuZCB0ZXN0 fGhhc2ggdG8gdGhlIHRvb2wKKyAgICAgICAgICAgICAgICBwcmludCBPVVQgIiR0ZXN0UGF0aHwk ZXhwZWN0ZWRIYXNoXG4iOworICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICBw cmludCBPVVQgIiR0ZXN0UGF0aFxuIjsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSBlbHNlIHsK KyAgICAgICAgICAgIHByaW50IE9VVCAiJHRlc3RQYXRoXG4iOworICAgICAgICB9CiAgICAgfSBl bHNlIHsKICAgICAgICAgb3BlbkhUVFBESWZOZWVkZWQoKTsKICAgICAgICAgaWYgKCR0ZXN0ICF+ IC9eaHR0cFwvdGVzdHNcL2xvY2FsXC8vICYmICR0ZXN0ICF+IC9eaHR0cFwvdGVzdHNcL3NzbFwv LyAmJiAkdGVzdCAhfiAvXmh0dHBcL3Rlc3RzXC9tZWRpYVwvLykgewpAQCAtNjQxLDcgKzY1Niw3 IEBAIGZvciBteSAkdGVzdCAoQHRlc3RzKSB7CiAgICAgICAgICAgICBsYXN0IGlmIC8jRU9GLzsK ICAgICAgICAgICAgIGlmICgvQWN0dWFsSGFzaDogKFthLWYwLTldezMyfSkvKSB7CiAgICAgICAg ICAgICAgICAgJGFjdHVhbEhhc2ggPSAkMTsKLSAgICAgICAgICAgIH0gZWxzaWYgKC9CYXNlbGlu ZUhhc2g6IChbYS1mMC05XXszMn0pLykgeworICAgICAgICAgICAgfSBlbHNpZiAoL0V4cGVjdGVk SGFzaDogKFthLWYwLTldezMyfSkvKSB7CiAgICAgICAgICAgICAgICAgJGV4cGVjdGVkSGFzaCA9 ICQxOwogICAgICAgICAgICAgfSBlbHNpZiAoL0NvbnRlbnQtTGVuZ3RoOiAoXGQrKVxzKi8pIHsK ICAgICAgICAgICAgICAgICAkYWN0dWFsUE5HU2l6ZSA9ICQxOwo= 24196 2008-10-08 12:15:42 -0700 2008-10-22 21:06:24 -0700 Re-revised patch PATCH_FILE.txt text/plain 42185 pol ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCAxYmQwMWM1Li4wYTNjN2Y1IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjEgQEAKKzIwMDgtMTAt MDggIFBpZXJyZS1PbGl2aWVyIExhdG91ciAgPHBvbEBhcHBsZS5jb20+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVuZGVyaW5nIGlzIGFsd2F5cyBp biBwcmVtdWx0aXBsaWVkIFJHQkE4IHRvIGF2b2lkIGVuZGlhbiBpc3N1ZXMgYW5kIAorICAgICAg ICBndWFyYW50ZWUgY29uc2lzdGVudCBoYXNoIHZhbHVlcy4KKworICAgICAgICBFbnN1cmUgZm9u dCBzbW9vdGhpbmcgaXMgZGlzYWJsZWQuCisKKyAgICAgICAgRFJUIGNhbiBub3cgcmVjZWl2ZXMg dGhlIGV4cGVjdGVkIHBpeGVsIGhhc2ggYXMgYSBzdWZmaXggdG8gdGhlIHRlc3QgcGF0aAorICAg ICAgICBvciB1cmwgYXMgInBhdGh8aGFzaCIuCisKKyAgICAgICAgQXZvaWQgZHVtcGluZyB0aGUg UE5HIGltYWdlIHdoZW4gcnVubmluZyBwaXhlbCB0ZXN0cyBpZiB3ZSBjYW4gZGV0ZWN0IHRoYXQK KyAgICAgICAgdGhlIGNoZWNrc3VtIGlzIGVxdWFsIHRvIHRoZSBleHBlY3RlZCBjaGVja3N1bSAo Zm9yIHBlcmZvcm1hbmNlKS4KKworICAgICAgICBWYXJpb3VzIG1pbm9yIGltcHJvdmVtZW50cyAo YmV0dGVyIHNldHRpbmcgLyByZXN0b3Jpbmcgc2NyZWVuIGNvbG9yIHByb2ZpbGUsCisgICAgICAg IHVzZSBvZiBzdGQ6OnN0cmluZywgY2xlYW5lciB2aWV3IHNuYXBzaG90IGNvZGUsIGV0Yy4uLiku CisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMzIy CisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUGFzc1Jl ZlB0ci5oOiBBZGRlZC4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5nSGVhZGVy cy93dGYvUmVmUHRyLmg6IEFkZGVkLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRl c3RDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpMYXlvdXRU ZXN0Q29udHJvbGxlcik6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRy b2xsZXIuaDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjp0ZXN0UGF0aE9yVVJMKToK KyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpleHBlY3RlZFBpeGVsSGFzaCk6CisgICAg ICAgICogRHVtcFJlbmRlclRyZWUvUGl4ZWxEdW1wU3VwcG9ydC5oOgorICAgICAgICAqIER1bXBS ZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5jcHA6CisgICAgICAgIChwcmludFBORyk6 CisgICAgICAgIChjb21wdXRlTUQ1SGFzaFN0cmluZ0ZvckJpdG1hcENvbnRleHQpOgorICAgICAg ICAoZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0ZWQpOgorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5oOgorICAgICAgICAoQml0bWFw Q29udGV4dDo6Y3JlYXRlKToKKyAgICAgICAgKEJpdG1hcENvbnRleHQ6On5CaXRtYXBDb250ZXh0 KToKKyAgICAgICAgKEJpdG1hcENvbnRleHQ6OmNnQ29udGV4dCk6CisgICAgICAgIChCaXRtYXBD b250ZXh0OjpCaXRtYXBDb250ZXh0KToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMvRHVt cFJlbmRlclRyZWUubW06CisgICAgICAgIChzaG91bGRJZ25vcmVXZWJDb3JlTm9kZUxlYWtzKToK KyAgICAgICAgKHNldERlZmF1bHRzVG9Db25zaXN0ZW50VmFsdWVzRm9yVGVzdGluZyk6CisgICAg ICAgIChjcmFzaEhhbmRsZXIpOgorICAgICAgICAocHJlcGFyZUNvbnNpc3RlbnRUZXN0aW5nRW52 aXJvbm1lbnQpOgorICAgICAgICAoZHVtcFJlbmRlclRyZWUpOgorICAgICAgICAoc2l6ZVdlYlZp ZXdGb3JDdXJyZW50VGVzdCk6CisgICAgICAgIChkdW1wKToKKyAgICAgICAgKHJ1blRlc3QpOgor ICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZU1hYy5oOgorICAgICAg ICAqIER1bXBSZW5kZXJUcmVlL21hYy9QaXhlbER1bXBTdXBwb3J0TWFjLm1tOgorICAgICAgICAo cmVzdG9yZU1haW5EaXNwbGF5Q29sb3JQcm9maWxlKToKKyAgICAgICAgKHNldHVwTWFpbkRpc3Bs YXlDb2xvclByb2ZpbGUpOgorICAgICAgICAoY3JlYXRlQml0bWFwQ29udGV4dEZyb21XZWJWaWV3 KToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwOgorICAg ICAgICAoZHVtcCk6CisgICAgICAgIChydW5UZXN0KToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJl ZS93aW4vUGl4ZWxEdW1wU3VwcG9ydFdpbi5jcHA6CisgICAgICAgIChnZXRCaXRtYXBDb250ZXh0 RnJvbVdlYlZpZXcpOgorICAgICAgICAqIFNjcmlwdHMvcnVuLXdlYmtpdC10ZXN0czoKKwogMjAw OC0xMC0wNyAgQWRhbSBSb2JlbiAgPGFyb2JlbkBhcHBsZS5jb20+CiAKICAgICAgICAgTWFrZSBz dXJlIHNob3J0IGZ1bmN0aW9ucyBnZXQgaW5jbHVkZWQgaW4gQ2hhbmdlTG9nIG91dHB1dCBmb3Ig Z2l0CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5nSGVh ZGVycy93dGYvUGFzc1JlZlB0ci5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvRm9yd2Fy ZGluZ0hlYWRlcnMvd3RmL1Bhc3NSZWZQdHIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwLi5hYWZkMWEyCi0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1Bhc3NSZWZQdHIuaApAQCAtMCwwICsxIEBACisj aW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvUGFzc1JlZlB0ci5oPgpkaWZmIC0tZ2l0IGEvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1JlZlB0ci5oIGIvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1JlZlB0ci5oCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjBmZjYyMTMKLS0tIC9kZXYvbnVsbAor KysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUmVm UHRyLmgKQEAgLTAsMCArMSBAQAorI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL1JlZlB0ci5oPgpk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xs ZXIuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIu Y3BwCmluZGV4IGYwYWU4ZDMuLjM2YmMzZDkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKQEAgLTM0LDcgKzM0LDcgQEAKICNp bmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgogI2luY2x1ZGUgPHd0Zi9NYXRoRXh0cmFzLmg+CiAK LUxheW91dFRlc3RDb250cm9sbGVyOjpMYXlvdXRUZXN0Q29udHJvbGxlcihib29sIHRlc3RSZXBh aW50RGVmYXVsdCwgYm9vbCB0ZXN0UmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5RGVmYXVsdCkKK0xh eW91dFRlc3RDb250cm9sbGVyOjpMYXlvdXRUZXN0Q29udHJvbGxlcihjb25zdCBzdGQ6OnN0cmlu ZyYgdGVzdFBhdGhPclVSTCwgY29uc3Qgc3RkOjpzdHJpbmcmIGV4cGVjdGVkUGl4ZWxIYXNoLCBi b29sIHRlc3RSZXBhaW50RGVmYXVsdCwgYm9vbCB0ZXN0UmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5 RGVmYXVsdCkKICAgICA6IG1fZHVtcEFzVGV4dChmYWxzZSkKICAgICAsIG1fZHVtcEFzUERGKGZh bHNlKQogICAgICwgbV9kdW1wQmFja0ZvcndhcmRMaXN0KGZhbHNlKQpAQCAtNTksNiArNTksOCBA QCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6TGF5b3V0VGVzdENvbnRyb2xsZXIoYm9vbCB0ZXN0UmVw YWludERlZmF1bHQsIGJvb2wgdGVzdFJlcAogICAgICwgbV93YWl0VG9EdW1wKGZhbHNlKQogICAg ICwgbV93aW5kb3dJc0tleSh0cnVlKQogICAgICwgbV9nbG9iYWxGbGFnKGZhbHNlKQorICAgICwg bV90ZXN0UGF0aE9yVVJMKHRlc3RQYXRoT3JVUkwpCisgICAgLCBtX2V4cGVjdGVkUGl4ZWxIYXNo KGV4cGVjdGVkUGl4ZWxIYXNoKQogewogfQogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAppbmRleCA1ZTMwM2M4Li4zOTUwZTY2IDEwMDY0 NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5o CisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgK QEAgLTMxLDEwICszMSwxMSBAQAogCiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSlNPYmplY3RS ZWYuaD4KICNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgorI2luY2x1ZGUgPHN0cmluZz4KIAog Y2xhc3MgTGF5b3V0VGVzdENvbnRyb2xsZXIgOiBwdWJsaWMgUmVmQ291bnRlZDxMYXlvdXRUZXN0 Q29udHJvbGxlcj4gewogcHVibGljOgotICAgIExheW91dFRlc3RDb250cm9sbGVyKGJvb2wgdGVz dFJlcGFpbnREZWZhdWx0LCBib29sIHRlc3RSZXBhaW50U3dlZXBIb3Jpem9udGFsbHlEZWZhdWx0 KTsKKyAgICBMYXlvdXRUZXN0Q29udHJvbGxlcihjb25zdCBzdGQ6OnN0cmluZyYgdGVzdFBhdGhP clVSTCwgY29uc3Qgc3RkOjpzdHJpbmcmIGV4cGVjdGVkUGl4ZWxIYXNoLCBib29sIHRlc3RSZXBh aW50RGVmYXVsdCwgYm9vbCB0ZXN0UmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5RGVmYXVsdCk7CiAg ICAgfkxheW91dFRlc3RDb250cm9sbGVyKCk7CiAKICAgICB2b2lkIG1ha2VXaW5kb3dPYmplY3Qo SlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIHdpbmRvd09iamVjdCwgSlNWYWx1ZVJl ZiogZXhjZXB0aW9uKTsKQEAgLTE0Myw3ICsxNDQsMTAgQEAgcHVibGljOgogCiAgICAgYm9vbCBn bG9iYWxGbGFnKCkgY29uc3QgeyByZXR1cm4gbV9nbG9iYWxGbGFnOyB9CiAgICAgdm9pZCBzZXRH bG9iYWxGbGFnKGJvb2wgZ2xvYmFsRmxhZykgeyBtX2dsb2JhbEZsYWcgPSBnbG9iYWxGbGFnOyB9 Ci0KKyAgICAKKyAgICBjb25zdCBzdGQ6OnN0cmluZyYgdGVzdFBhdGhPclVSTCgpIGNvbnN0IHsg cmV0dXJuIG1fdGVzdFBhdGhPclVSTDsgfQorICAgIGNvbnN0IHN0ZDo6c3RyaW5nJiBleHBlY3Rl ZFBpeGVsSGFzaCgpIGNvbnN0IHsgcmV0dXJuIG1fZXhwZWN0ZWRQaXhlbEhhc2g7IH0KKyAgICAK IHByaXZhdGU6CiAgICAgYm9vbCBtX2R1bXBBc1RleHQ7CiAgICAgYm9vbCBtX2R1bXBBc1BERjsK QEAgLTE3MSw2ICsxNzUsOSBAQCBwcml2YXRlOgogCiAgICAgYm9vbCBtX2dsb2JhbEZsYWc7CiAK KyAgICBzdGQ6OnN0cmluZyBtX3Rlc3RQYXRoT3JVUkw7CisgICAgc3RkOjpzdHJpbmcgbV9leHBl Y3RlZFBpeGVsSGFzaDsgICAgLy8gZW1wdHkgc3RyaW5nIGlmIG5vIGhhc2gKKyAgICAKICAgICBz dGF0aWMgSlNDbGFzc1JlZiBnZXRKU0NsYXNzKCk7CiAgICAgc3RhdGljIEpTU3RhdGljVmFsdWUq IHN0YXRpY1ZhbHVlcygpOwogICAgIHN0YXRpYyBKU1N0YXRpY0Z1bmN0aW9uKiBzdGF0aWNGdW5j dGlvbnMoKTsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL1BpeGVsRHVt cFN1cHBvcnQuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL1BpeGVsRHVtcFN1cHBvcnQu aAppbmRleCAzMjE0ZDA0Li5kNGY4OTQ4IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9QaXhlbER1bXBTdXBwb3J0LmgKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvUGl4ZWxEdW1wU3VwcG9ydC5oCkBAIC0yOSwxMiArMjksMTggQEAKICNpZm5kZWYgUGl4ZWxE dW1wU3VwcG9ydF9oCiAjZGVmaW5lIFBpeGVsRHVtcFN1cHBvcnRfaAogCi12b2lkIGR1bXBXZWJW aWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4cGVjdGVkKGNvbnN0IGNoYXIqIGN1cnJlbnRUZXN0 LCBib29sIGZvcmNlQWxsVGVzdHNUb0R1bXBQaXhlbHMpOworI2luY2x1ZGUgPHN0cmluZz4KKwor dm9pZCBkdW1wV2ViVmlld0FzUGl4ZWxzQW5kQ29tcGFyZVdpdGhFeHBlY3RlZChjb25zdCBzdGQ6 OnN0cmluZyYgZXhwZWN0ZWRIYXNoKTsKKworI2lmIFBMQVRGT1JNKE1BQykKIAogLy8gQ2FuIGJl IHVzZWQgYXMgYSBzaWduYWwgaGFuZGxlcgotdm9pZCByZXN0b3JlQ29sb3JTcGFjZShpbnQgaWdu b3JlZCk7Cit2b2lkIHJlc3RvcmVNYWluRGlzcGxheUNvbG9yUHJvZmlsZShpbnQgaWdub3JlZCk7 CisKKy8vIE1heSBjaGFuZ2UgeW91ciBjb2xvciBzcGFjZSwgcmVxdWlyaW5nIGEgY2FsbCB0byBy ZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUKK3ZvaWQgc2V0dXBNYWluRGlzcGxheUNvbG9y UHJvZmlsZSgpOwogCi0vLyBNYXkgY2hhbmdlIHlvdXIgY29sb3Igc3BhY2UsIHJlcXVpcmluZyBh IGNhbGwgdG8gcmVzdG9yZUNvbG9yU3BhY2UKLXZvaWQgaW5pdGlhbGl6ZUNvbG9yU3BhY2VBbmRT Y3JlZUJ1ZmZlckZvclBpeGVsVGVzdHMoKTsKKyNlbmRpZgogCiAjZW5kaWYgLy8gUGl4ZWxEdW1w U3VwcG9ydF9oCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9jZy9QaXhl bER1bXBTdXBwb3J0Q0cuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxE dW1wU3VwcG9ydENHLmNwcAppbmRleCA5MDZlMjc0Li43NzFkOGFjIDEwMDY0NAotLS0gYS9XZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9jZy9QaXhlbER1bXBTdXBwb3J0Q0cuY3BwCisrKyBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5jcHAKQEAgLTMz LDcgKzMzLDEwIEBACiAKICNpbmNsdWRlICJMYXlvdXRUZXN0Q29udHJvbGxlci5oIgogI2luY2x1 ZGUgPEltYWdlSU8vQ0dJbWFnZURlc3RpbmF0aW9uLmg+CisjaW5jbHVkZSA8YWxnb3JpdGhtPgor I2luY2x1ZGUgPGN0eXBlLmg+CiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KKyNpbmNsdWRl IDx3dGYvUmVmUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1JldGFpblB0ci5oPgogI2luY2x1ZGUgPHd0 Zi9TdHJpbmdFeHRyYXMuaD4KIApAQCAtNTMsNzQgKzU2LDY5IEBAIHN0YXRpYyB2b2lkIHByaW50 UE5HKENHSW1hZ2VSZWYgaW1hZ2UpCiB7CiAgICAgUmV0YWluUHRyPENGTXV0YWJsZURhdGFSZWY+ IGltYWdlRGF0YShBZG9wdENGLCBDRkRhdGFDcmVhdGVNdXRhYmxlKDAsIDApKTsKICAgICBSZXRh aW5QdHI8Q0dJbWFnZURlc3RpbmF0aW9uUmVmPiBpbWFnZURlc3QoQWRvcHRDRiwgQ0dJbWFnZURl c3RpbmF0aW9uQ3JlYXRlV2l0aERhdGEoaW1hZ2VEYXRhLmdldCgpLCBrVVRUeXBlUE5HLCAxLCAw KSk7CisKICAgICBDR0ltYWdlRGVzdGluYXRpb25BZGRJbWFnZShpbWFnZURlc3QuZ2V0KCksIGlt YWdlLCAwKTsKICAgICBDR0ltYWdlRGVzdGluYXRpb25GaW5hbGl6ZShpbWFnZURlc3QuZ2V0KCkp OworCiAgICAgcHJpbnRmKCJDb250ZW50LUxlbmd0aDogJWx1XG4iLCBDRkRhdGFHZXRMZW5ndGgo aW1hZ2VEYXRhLmdldCgpKSk7CiAgICAgZndyaXRlKENGRGF0YUdldEJ5dGVQdHIoaW1hZ2VEYXRh LmdldCgpKSwgMSwgQ0ZEYXRhR2V0TGVuZ3RoKGltYWdlRGF0YS5nZXQoKSksIHN0ZG91dCk7CiB9 CiAKLXN0YXRpYyB2b2lkIGdldE1ENUhhc2hTdHJpbmdGb3JCaXRtYXAoQ0dDb250ZXh0UmVmIGJp dG1hcCwgY2hhciBzdHJpbmdbMzNdKQorc3RhdGljIHZvaWQgY29tcHV0ZU1ENUhhc2hTdHJpbmdG b3JCaXRtYXBDb250ZXh0KENHQ29udGV4dFJlZiBiaXRtYXBDb250ZXh0LCBjaGFyIGhhc2hTdHJp bmdbMzNdKQogewotICAgIE1ENV9DVFggbWQ1Q29udGV4dDsKLSAgICB1bnNpZ25lZCBjaGFyIGhh c2hbMTZdOwotCi0gICAgc2l6ZV90IGJpdHNQZXJQaXhlbCA9IENHQml0bWFwQ29udGV4dEdldEJp dHNQZXJQaXhlbChiaXRtYXApOworICAgIHNpemVfdCBiaXRzUGVyUGl4ZWwgPSBDR0JpdG1hcENv bnRleHRHZXRCaXRzUGVyUGl4ZWwoYml0bWFwQ29udGV4dCk7CiAgICAgQVNTRVJUKGJpdHNQZXJQ aXhlbCA9PSAzMik7IC8vIEltYWdlRGlmZiBhc3N1bWVzIDMyIGJpdCBSR0JBLCB3ZSBtdXN0IGFz IHdlbGwuCiAgICAgc2l6ZV90IGJ5dGVzUGVyUGl4ZWwgPSBiaXRzUGVyUGl4ZWwgLyA4OwotICAg IHNpemVfdCBwaXhlbHNIaWdoID0gQ0dCaXRtYXBDb250ZXh0R2V0SGVpZ2h0KGJpdG1hcCk7Ci0g ICAgc2l6ZV90IHBpeGVsc1dpZGUgPSBDR0JpdG1hcENvbnRleHRHZXRXaWR0aChiaXRtYXApOwot ICAgIHNpemVfdCBieXRlc1BlclJvdyA9IENHQml0bWFwQ29udGV4dEdldEJ5dGVzUGVyUm93KGJp dG1hcCk7CisgICAgc2l6ZV90IHBpeGVsc0hpZ2ggPSBDR0JpdG1hcENvbnRleHRHZXRIZWlnaHQo Yml0bWFwQ29udGV4dCk7CisgICAgc2l6ZV90IHBpeGVsc1dpZGUgPSBDR0JpdG1hcENvbnRleHRH ZXRXaWR0aChiaXRtYXBDb250ZXh0KTsKKyAgICBzaXplX3QgYnl0ZXNQZXJSb3cgPSBDR0JpdG1h cENvbnRleHRHZXRCeXRlc1BlclJvdyhiaXRtYXBDb250ZXh0KTsKICAgICBBU1NFUlQoYnl0ZXNQ ZXJSb3cgPj0gKHBpeGVsc1dpZGUgKiBieXRlc1BlclBpeGVsKSk7CiAKKyAgICBNRDVfQ1RYIG1k NUNvbnRleHQ7CiAgICAgTUQ1X0luaXQoJm1kNUNvbnRleHQpOwotICAgIHVuc2lnbmVkIGNoYXIq IGJpdG1hcERhdGEgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyKj4oQ0dCaXRtYXBDb250ZXh0 R2V0RGF0YShiaXRtYXApKTsKKyAgICB1bnNpZ25lZCBjaGFyKiBiaXRtYXBEYXRhID0gc3RhdGlj X2Nhc3Q8dW5zaWduZWQgY2hhcio+KENHQml0bWFwQ29udGV4dEdldERhdGEoYml0bWFwQ29udGV4 dCkpOwogICAgIGZvciAodW5zaWduZWQgcm93ID0gMDsgcm93IDwgcGl4ZWxzSGlnaDsgcm93Kysp IHsKICAgICAgICAgTUQ1X1VwZGF0ZSgmbWQ1Q29udGV4dCwgYml0bWFwRGF0YSwgc3RhdGljX2Nh c3Q8dW5zaWduZWQ+KHBpeGVsc1dpZGUgKiBieXRlc1BlclBpeGVsKSk7CiAgICAgICAgIGJpdG1h cERhdGEgKz0gYnl0ZXNQZXJSb3c7CiAgICAgfQorCisgICAgdW5zaWduZWQgY2hhciBoYXNoWzE2 XTsKICAgICBNRDVfRmluYWwoaGFzaCwgJm1kNUNvbnRleHQpOwogCi0gICAgc3RyaW5nWzBdID0g J1wwJzsKKyAgICBoYXNoU3RyaW5nWzBdID0gJ1wwJzsKICAgICBmb3IgKGludCBpID0gMDsgaSA8 IDE2OyBpKyspCi0gICAgICAgIHNucHJpbnRmKHN0cmluZywgMzMsICIlcyUwMngiLCBzdHJpbmcs IGhhc2hbaV0pOwotfQotCi12b2lkIGRyYXdTZWxlY3Rpb25SZWN0KENHQ29udGV4dFJlZiBjb250 ZXh0LCBjb25zdCBDR1JlY3QmIHJlY3QpCi17Ci0gICAgQ0dDb250ZXh0U2F2ZUdTdGF0ZShjb250 ZXh0KTsKLSAgICBDR0NvbnRleHRTZXRSR0JTdHJva2VDb2xvcihjb250ZXh0LCAxLjAsIDAuMCwg MC4wLCAxLjApOwotICAgIENHQ29udGV4dFN0cm9rZVJlY3QoY29udGV4dCwgcmVjdCk7Ci0gICAg Q0dDb250ZXh0UmVzdG9yZUdTdGF0ZShjb250ZXh0KTsKKyAgICAgICAgc25wcmludGYoaGFzaFN0 cmluZywgMzMsICIlcyUwMngiLCBoYXNoU3RyaW5nLCBoYXNoW2ldKTsKIH0KIAotdm9pZCBkdW1w V2ViVmlld0FzUGl4ZWxzQW5kQ29tcGFyZVdpdGhFeHBlY3RlZChjb25zdCBjaGFyKiAvKmN1cnJl bnRUZXN0Ki8sIGJvb2wgLypmb3JjZUFsbFRlc3RzVG9EdW1wUGl4ZWxzKi8pCit2b2lkIGR1bXBX ZWJWaWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4cGVjdGVkKGNvbnN0IHN0ZDo6c3RyaW5nJiBl eHBlY3RlZEhhc2gpCiB7Ci0gICAgUmV0YWluUHRyPENHQ29udGV4dFJlZj4gY29udGV4dCA9IGdl dEJpdG1hcENvbnRleHRGcm9tV2ViVmlldygpOwotCisgICAgUmVmUHRyPEJpdG1hcENvbnRleHQ+ IGNvbnRleHQ7CisgICAgCiAjaWYgUExBVEZPUk0oTUFDKQotICAgIGlmIChnTGF5b3V0VGVzdENv bnRyb2xsZXItPnRlc3RSZXBhaW50KCkpCi0gICAgICAgIHJlcGFpbnRXZWJWaWV3KGNvbnRleHQu Z2V0KCksIGdMYXlvdXRUZXN0Q29udHJvbGxlci0+dGVzdFJlcGFpbnRTd2VlcEhvcml6b250YWxs eSgpKTsKLSAgICBlbHNlIAotICAgICAgICBwYWludFdlYlZpZXcoY29udGV4dC5nZXQoKSk7Ci0K LSAgICBpZiAoZ0xheW91dFRlc3RDb250cm9sbGVyLT5kdW1wU2VsZWN0aW9uUmVjdCgpKQotICAg ICAgICBkcmF3U2VsZWN0aW9uUmVjdChjb250ZXh0LmdldCgpLCBnZXRTZWxlY3Rpb25SZWN0KCkp OworICAgIGNvbnRleHQgPSBjcmVhdGVCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoZ0xheW91dFRl c3RDb250cm9sbGVyLT50ZXN0UmVwYWludCgpLCBnTGF5b3V0VGVzdENvbnRyb2xsZXItPnRlc3RS ZXBhaW50U3dlZXBIb3Jpem9udGFsbHkoKSwgZ0xheW91dFRlc3RDb250cm9sbGVyLT5kdW1wU2Vs ZWN0aW9uUmVjdCgpKTsKICNlbmRpZgotCi0gICAgLy8gQ29tcHV0ZSB0aGUgYWN0dWFsIGhhc2gg dG8gY29tcGFyZSB0byB0aGUgZXhwZWN0ZWQgaW1hZ2UncyBoYXNoLgorICAgIEFTU0VSVChjb250 ZXh0LmdldCgpKTsKKyAgICAKKyAgICAvLyBDb21wdXRlIHRoZSBoYXNoIG9mIHRoZSBiaXRtYXAg Y29udGV4dCBwaXhlbHMKICAgICBjaGFyIGFjdHVhbEhhc2hbMzNdOwotICAgIGdldE1ENUhhc2hT dHJpbmdGb3JCaXRtYXAoY29udGV4dC5nZXQoKSwgYWN0dWFsSGFzaCk7CisgICAgY29tcHV0ZU1E NUhhc2hTdHJpbmdGb3JCaXRtYXBDb250ZXh0KGNvbnRleHQtPmNnQ29udGV4dCgpLCBhY3R1YWxI YXNoKTsKICAgICBwcmludGYoIlxuQWN0dWFsSGFzaDogJXNcbiIsIGFjdHVhbEhhc2gpOwotCi0g ICAgLy8gRklYTUU6IFdlIHNob3VsZCBjb21wYXJlIHRoZSBhY3R1YWxIYXNoIHRvIHRoZSBleHBl Y3RlZCBoYXNoIGhlcmUgYW5kCi0gICAgLy8gb25seSBzZXQgZHVtcEltYWdlIHRvIHRydWUgaWYg dGhleSBkb24ndCBtYXRjaCwgYnV0IERSVCBkb2Vzbid0IGhhdmUKLSAgICAvLyBlbm91Z2ggaW5m b3JtYXRpb24gY3VycmVudGx5IHRvIGZpbmQgdGhlIGV4cGVjdGVkIGNoZWNrc3VtIGZpbGUuCisg ICAgCisgICAgLy8gQ2hlY2sgdGhlIGNvbXB1dGVkIGhhc2ggYWdhaW5zdCB0aGUgZXhwZWN0ZWQg b25lIGFuZCBkdW1wIGltYWdlIG9uIG1pc21hdGNoCiAgICAgYm9vbCBkdW1wSW1hZ2UgPSB0cnVl OwotCisgICAgaWYgKGV4cGVjdGVkSGFzaC5sZW5ndGgoKSA+IDApIHsKKyAgICAgICAgQVNTRVJU KGV4cGVjdGVkSGFzaC5sZW5ndGgoKSA9PSAzMik7CisgICAgICAgIAorICAgICAgICBwcmludGYo IlxuRXhwZWN0ZWRIYXNoOiAlc1xuIiwgZXhwZWN0ZWRIYXNoLmNfc3RyKCkpOworICAgICAgICAK KyAgICAgICAgaWYgKGV4cGVjdGVkSGFzaCA9PSBhY3R1YWxIYXNoKSAgICAgLy8gRklYTUU6IGRv IGNhc2UgaW5zZW5zaXRpdmUgY29tcGFyZQorICAgICAgICAgICAgZHVtcEltYWdlID0gZmFsc2U7 CisgICAgfQorICAgIAogICAgIGlmIChkdW1wSW1hZ2UpIHsKLSAgICAgICAgUmV0YWluUHRyPENH SW1hZ2VSZWY+IGltYWdlKEFkb3B0Q0YsIENHQml0bWFwQ29udGV4dENyZWF0ZUltYWdlKGNvbnRl eHQuZ2V0KCkpKTsKKyAgICAgICAgUmV0YWluUHRyPENHSW1hZ2VSZWY+IGltYWdlKEFkb3B0Q0Ys IENHQml0bWFwQ29udGV4dENyZWF0ZUltYWdlKGNvbnRleHQtPmNnQ29udGV4dCgpKSk7CiAgICAg ICAgIHByaW50UE5HKGltYWdlLmdldCgpKTsKICAgICB9Ci0KKyAgICAKICAgICBwcmludGYoIiNF T0ZcbiIpOwogfQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvUGl4 ZWxEdW1wU3VwcG9ydENHLmggYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9jZy9QaXhlbER1 bXBTdXBwb3J0Q0cuaAppbmRleCAwYWJkZWE2Li40NDdkOTI5IDEwMDY0NAotLS0gYS9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9jZy9QaXhlbER1bXBTdXBwb3J0Q0cuaAorKysgYi9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9jZy9QaXhlbER1bXBTdXBwb3J0Q0cuaApAQCAtMzEsMjUgKzMx LDYzIEBACiAjaWZuZGVmIFBpeGVsRHVtcFN1cHBvcnRDR19oCiAjZGVmaW5lIFBpeGVsRHVtcFN1 cHBvcnRDR19oCiAKKyNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9S ZWZDb3VudGVkLmg+CiAjaW5jbHVkZSA8d3RmL1JldGFpblB0ci5oPgogCi0jaWZuZGVmIENHRkxP QVRfREVGSU5FRAotI2lmZGVmIF9fTFA2NF9fCi10eXBlZGVmIGRvdWJsZSBDR0Zsb2F0OwotI2Vs c2UKLXR5cGVkZWYgZmxvYXQgQ0dGbG9hdDsKK3R5cGVkZWYgc3RydWN0IENHQ29udGV4dCogQ0dD b250ZXh0UmVmOworCitjbGFzcyBCaXRtYXBDb250ZXh0IDogcHVibGljIFJlZkNvdW50ZWQ8Qml0 bWFwQ29udGV4dD4KK3sKK3B1YmxpYzoKKyNpZiBQTEFURk9STShNQUMpCisgICAgc3RhdGljIFBh c3NSZWZQdHI8Qml0bWFwQ29udGV4dD4gY3JlYXRlKHZvaWQqIHBpeGVsRGF0YSwgQ0dDb250ZXh0 UmVmIGNvbnRleHQpCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IEJpdG1hcENv bnRleHQocGl4ZWxEYXRhLCBjb250ZXh0KSk7CisgICAgfQorI2VsaWYgUExBVEZPUk0oV0lOKQor ICAgIHN0YXRpYyBQYXNzUmVmUHRyPEJpdG1hcENvbnRleHQ+IGNyZWF0ZShIQklUTUFQIGJpdG1h cCwgQ0dDb250ZXh0UmVmIGNvbnRleHQpCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRSZWYo bmV3IEJpdG1hcENvbnRleHQoYml0bWFwLCBjb250ZXh0KSk7CisgICAgfQogI2VuZGlmCi0jZGVm aW5lIENHRkxPQVRfREVGSU5FRCAxCisKKyAgICB+Qml0bWFwQ29udGV4dCgpCisgICAgeworI2lm IFBMQVRGT1JNKE1BQykKKyAgICAgICAgaWYgKG1fcGl4ZWxEYXRhKQorICAgICAgICAgICAgZnJl ZShtX3BpeGVsRGF0YSk7CisjZWxpZiBQTEFURk9STShXSU4pCisgICAgICAgIGlmIChtX2JpdG1h cCkKKyAgICAgICAgICAgIERlbGV0ZU9iamVjdChtX2JpdG1hcCk7CiAjZW5kaWYKKyAgICB9CiAK LXR5cGVkZWYgc3RydWN0IENHQ29udGV4dCogQ0dDb250ZXh0UmVmOwotc3RydWN0IENHUmVjdDsK KyAgICBDR0NvbnRleHRSZWYgY2dDb250ZXh0KCkgY29uc3QgeyByZXR1cm4gbV9jb250ZXh0Lmdl dCgpOyB9CisKK3ByaXZhdGU6CisKKyNpZiBQTEFURk9STShNQUMpCisgICAgQml0bWFwQ29udGV4 dCh2b2lkKiBwaXhlbERhdGEsIENHQ29udGV4dFJlZiBjb250ZXh0KQorICAgICAgICA6IG1fcGl4 ZWxEYXRhKHBpeGVsRGF0YSkKKyNlbGlmIFBMQVRGT1JNKFdJTikKKyAgICBCaXRtYXBDb250ZXh0 KEhCSVRNQVAgYml0bWFwLCBDR0NvbnRleHRSZWYgY29udGV4dCkKKyAgICAgICAgOiBtX2JpdG1h cChiaXRtYXApCisjZW5kaWYKKyAgICAgICAgLCBtX2NvbnRleHQoQWRvcHRDRiwgY29udGV4dCkK KyAgICB7CisgICAgfQorICAgIAorI2lmIFBMQVRGT1JNKE1BQykKKyAgICB2b2lkKiBtX3BpeGVs RGF0YTsKKyNlbGlmIFBMQVRGT1JNKFdJTikKKyAgICBIQklUTUFQIG1fYml0bWFwOworI2VuZGlm ICAgIAorICAgIFJldGFpblB0cjxDR0NvbnRleHRSZWY+IG1fY29udGV4dDsKKworfTsKIAotUmV0 YWluUHRyPENHQ29udGV4dFJlZj4gZ2V0Qml0bWFwQ29udGV4dEZyb21XZWJWaWV3KCk7Ci1DR1Jl Y3QgZ2V0U2VsZWN0aW9uUmVjdCgpOwogCi12b2lkIHBhaW50V2ViVmlldyhDR0NvbnRleHRSZWYp Owotdm9pZCByZXBhaW50V2ViVmlldyhDR0NvbnRleHRSZWYgY29udGV4dCwgYm9vbCBob3Jpem9u dGFsKTsKLXZvaWQgZHJhd1NlbGVjdGlvblJlY3QoQ0dDb250ZXh0UmVmLCBjb25zdCBDR1JlY3Qm KTsKK1Bhc3NSZWZQdHI8Qml0bWFwQ29udGV4dD4gY3JlYXRlQml0bWFwQ29udGV4dEZyb21XZWJW aWV3KGJvb2wgaW5jcmVtZW50YWxSZXBhaW50LCBib29sIHN3ZWVwSG9yaXpvbnRhbGx5LCBib29s IGRyYXdTZWxlY3Rpb25SZWN0KTsKIAogI2VuZGlmIC8vIFBpeGVsRHVtcFN1cHBvcnRDR19oCmRp ZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUu bW0gYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KaW5k ZXggYjQ3MDRmOC4uZTNmZGJlNiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L21hYy9EdW1wUmVuZGVyVHJlZS5tbQpAQCAtNzgsNyArNzgsNyBAQAogQGludGVyZmFjZSBEdW1w UmVuZGVyVHJlZUV2ZW50IDogTlNFdmVudAogQGVuZAogCi1zdGF0aWMgdm9pZCBydW5UZXN0KGNv bnN0IGNoYXIgKnBhdGhPclVSTCk7CitzdGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0IHN0ZDo6c3Ry aW5nJiB0ZXN0UGF0aE9yVVJMKTsKIAogLy8gRGVjaWRpbmcgd2hlbiBpdCdzIE9LIHRvIGR1bXAg b3V0IHRoZSBzdGF0ZSBpcyBhIGJpdCB0cmlja3kuICBBbGwgdGhlc2UgbXVzdCBiZSB0cnVlOgog Ly8gLSBUaGVyZSBpcyBubyBsb2FkIGluIHByb2dyZXNzCkBAIC0xMTgsNyArMTE4LDYgQEAgc3Rh dGljIGludCByZXBhaW50U3dlZXBIb3Jpem9udGFsbHlEZWZhdWx0Owogc3RhdGljIGludCBkdW1w VHJlZSA9IFlFUzsKIHN0YXRpYyBpbnQgZm9yY2VDb21wbGV4VGV4dDsKIHN0YXRpYyBCT09MIHBy aW50U2VwYXJhdG9yczsKLXN0YXRpYyBOU1N0cmluZyAqY3VycmVudFRlc3QgPSBuaWw7CiBzdGF0 aWMgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBwZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlv bjsKIAogc3RhdGljIFdlYkhpc3RvcnlJdGVtICpwcmV2VGVzdEJGSXRlbSA9IG5pbDsgIC8vIGN1 cnJlbnQgYi9mIGl0ZW0gYXQgdGhlIGVuZCBvZiB0aGUgcHJldmlvdXMgdGVzdApAQCAtMTgxLDIx ICsxODAsMjIgQEAgdm9pZCBzZXRQZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbihDRlN0 cmluZ1JlZiB1cmwpCiAgICAgcGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24gPSB1cmw7 CiB9CiAKLXN0YXRpYyBCT09MIHNob3VsZElnbm9yZVdlYkNvcmVOb2RlTGVha3MoQ0ZTdHJpbmdS ZWYgVVJMU3RyaW5nKQorc3RhdGljIGJvb2wgc2hvdWxkSWdub3JlV2ViQ29yZU5vZGVMZWFrcyhj b25zdCBzdGQ6OnN0cmluZyYgVVJMU3RyaW5nKQogewotICAgIHN0YXRpYyBDRlN0cmluZ1JlZiBj b25zdCBpZ25vcmVTZXRbXSA9IHsKKyAgICBzdGF0aWMgY2hhciogY29uc3QgaWdub3JlU2V0W10g PSB7CiAgICAgICAgIC8vIEtlZXBpbmcgdGhpcyBpbmZyYXN0cnVjdHVyZSBhcm91bmQgaW4gY2Fz ZSB3ZSBldmVyIG5lZWQgaXQgYWdhaW4uCiAgICAgfTsKLSAgICBzdGF0aWMgY29uc3QgaW50IGln bm9yZVNldENvdW50ID0gc2l6ZW9mKGlnbm9yZVNldCkgLyBzaXplb2YoQ0ZTdHJpbmdSZWYpOwor ICAgIHN0YXRpYyBjb25zdCBpbnQgaWdub3JlU2V0Q291bnQgPSBzaXplb2YoaWdub3JlU2V0KSAv IHNpemVvZihjaGFyKik7CiAgICAgCiAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBpZ25vcmVTZXRD b3VudDsgaSsrKSB7Ci0gICAgICAgIENGU3RyaW5nUmVmIGlnbm9yZVN0cmluZyA9IGlnbm9yZVNl dFtpXTsKLSAgICAgICAgQ0ZSYW5nZSByYW5nZSA9IENGUmFuZ2VNYWtlKDAsIENGU3RyaW5nR2V0 TGVuZ3RoKFVSTFN0cmluZykpOwotICAgICAgICBDRk9wdGlvbkZsYWdzIGZsYWdzID0ga0NGQ29t cGFyZUFuY2hvcmVkIHwga0NGQ29tcGFyZUJhY2t3YXJkcyB8IGtDRkNvbXBhcmVDYXNlSW5zZW5z aXRpdmU7Ci0gICAgICAgIGlmIChDRlN0cmluZ0ZpbmRXaXRoT3B0aW9ucyhVUkxTdHJpbmcsIGln bm9yZVN0cmluZywgcmFuZ2UsIGZsYWdzLCBOVUxMKSkKLSAgICAgICAgICAgIHJldHVybiBZRVM7 CisKKyAgICAgICAgLy8gRklYTUU6IGlnbm9yZSBjYXNlCisgICAgICAgIHN0ZDo6c3RyaW5nIGN1 cklnbm9yZShpZ25vcmVTZXRbaV0pOworICAgICAgICAvLyBNYXRjaCBhdCB0aGUgZW5kIG9mIHRo ZSBVUkxTdHJpbmcKKyAgICAgICAgaWYgKCFVUkxTdHJpbmcuY29tcGFyZShVUkxTdHJpbmcubGVu Z3RoKCkgLSBjdXJJZ25vcmUubGVuZ3RoKCksIGN1cklnbm9yZS5sZW5ndGgoKSwgY3VySWdub3Jl KSkKKyAgICAgICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KLSAgICByZXR1cm4gTk87CisgICAg cmV0dXJuIGZhbHNlOwogfQogCiBzdGF0aWMgdm9pZCBhY3RpdmF0ZUZvbnRzKCkKQEAgLTMwNywx MyArMzA3LDEzIEBAIHZvaWQgdGVzdFN0cmluZ0J5RXZhbHVhdGluZ0phdmFTY3JpcHRGcm9tU3Ry aW5nKCkKIHN0YXRpYyB2b2lkIHNldERlZmF1bHRzVG9Db25zaXN0ZW50VmFsdWVzRm9yVGVzdGlu ZygpCiB7CiAgICAgLy8gR2l2ZSBzb21lIGNsZWFyIHRvIHVuZG9jdW1lbnRlZCBkZWZhdWx0cyB2 YWx1ZXMKLSAgICBzdGF0aWMgY29uc3QgaW50IE1lZGl1bUZvbnRTbW9vdGhpbmcgPSAyOworICAg IHN0YXRpYyBjb25zdCBpbnQgTm9Gb250U21vb3RoaW5nID0gMDsKICAgICBzdGF0aWMgY29uc3Qg aW50IEJsdWVUaW50ZWRBcHBlYXJhbmNlID0gMTsKIAogICAgIE5TVXNlckRlZmF1bHRzICpkZWZh dWx0cyA9IFtOU1VzZXJEZWZhdWx0cyBzdGFuZGFyZFVzZXJEZWZhdWx0c107CiAgICAgW2RlZmF1 bHRzIHNldE9iamVjdDpAIkRvdWJsZU1heCIgZm9yS2V5OkAiQXBwbGVTY3JvbGxCYXJWYXJpYW50 Il07CiAgICAgW2RlZmF1bHRzIHNldEludGVnZXI6NCBmb3JLZXk6QCJBcHBsZUFudGlBbGlhc2lu Z1RocmVzaG9sZCJdOyAvLyBzbWFsbGVzdCBmb250IHNpemUgdG8gQ0cgc2hvdWxkIHBlcmZvcm0g YW50aWFsaWFzaW5nIG9uCi0gICAgW2RlZmF1bHRzIHNldEludGVnZXI6TWVkaXVtRm9udFNtb290 aGluZyBmb3JLZXk6QCJBcHBsZUZvbnRTbW9vdGhpbmciXTsKKyAgICBbZGVmYXVsdHMgc2V0SW50 ZWdlcjpOb0ZvbnRTbW9vdGhpbmcgZm9yS2V5OkAiQXBwbGVGb250U21vb3RoaW5nIl07CiAgICAg W2RlZmF1bHRzIHNldEludGVnZXI6Qmx1ZVRpbnRlZEFwcGVhcmFuY2UgZm9yS2V5OkAiQXBwbGVB cXVhQ29sb3JWYXJpYW50Il07CiAgICAgW2RlZmF1bHRzIHNldE9iamVjdDpAIjAuNzA5ODAwIDAu ODM1MzAwIDEuMDAwMDAwIiBmb3JLZXk6QCJBcHBsZUhpZ2hsaWdodENvbG9yIl07CiAgICAgW2Rl ZmF1bHRzIHNldE9iamVjdDpAIjAuNTAwMDAwIDAuNTAwMDAwIDAuNTAwMDAwIiBmb3JLZXk6QCJB cHBsZU90aGVySGlnaGxpZ2h0Q29sb3IiXTsKQEAgLTM1MCw3ICszNTAsNyBAQCBzdGF0aWMgdm9p ZCBjcmFzaEhhbmRsZXIoaW50IHNpZykKICAgICBjaGFyICpzaWduYWxOYW1lID0gc3Ryc2lnbmFs KHNpZyk7CiAgICAgd3JpdGUoU1RERVJSX0ZJTEVOTywgc2lnbmFsTmFtZSwgc3RybGVuKHNpZ25h bE5hbWUpKTsKICAgICB3cml0ZShTVERFUlJfRklMRU5PLCAiXG4iLCAxKTsKLSAgICByZXN0b3Jl Q29sb3JTcGFjZSgwKTsKKyAgICByZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUoMCk7CiAg ICAgZXhpdCgxMjggKyBzaWcpOwogfQogCkBAIC00NjAsNyArNDYwLDcgQEAgc3RhdGljIHZvaWQg cHJlcGFyZUNvbnNpc3RlbnRUZXN0aW5nRW52aXJvbm1lbnQoKQogICAgIGFjdGl2YXRlRm9udHMo KTsKICAgICAKICAgICBpZiAoZHVtcFBpeGVscykKLSAgICAgICAgaW5pdGlhbGl6ZUNvbG9yU3Bh Y2VBbmRTY3JlZUJ1ZmZlckZvclBpeGVsVGVzdHMoKTsKKyAgICAgICAgc2V0dXBNYWluRGlzcGxh eUNvbG9yUHJvZmlsZSgpOwogICAgIGFsbG9jYXRlR2xvYmFsQ29udHJvbGxlcnMoKTsKICAgICAK ICAgICBtYWtlTGFyZ2VNYWxsb2NGYWlsU2lsZW50bHkoKTsKQEAgLTUyNiw3ICs1MjYsNyBAQCB2 b2lkIGR1bXBSZW5kZXJUcmVlKGludCBhcmdjLCBjb25zdCBjaGFyICphcmd2W10pCiAgICAgfQog CiAgICAgaWYgKGR1bXBQaXhlbHMpCi0gICAgICAgIHJlc3RvcmVDb2xvclNwYWNlKDApOworICAg ICAgICByZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUoMCk7CiB9CiAKIGludCBtYWluKGlu dCBhcmdjLCBjb25zdCBjaGFyICphcmd2W10pCkBAIC04MjEsNyArODIxLDcgQEAgc3RhdGljIHZv aWQgZHVtcEJhY2tGb3J3YXJkTGlzdEZvcldlYlZpZXcoV2ViVmlldyAqdmlldykKIHN0YXRpYyB2 b2lkIHNpemVXZWJWaWV3Rm9yQ3VycmVudFRlc3QoKQogewogICAgIC8vIFczQyBTVkcgdGVzdHMg ZXhwZWN0IHRvIGJlIDQ4MHgzNjAKLSAgICBib29sIGlzU1ZHVzNDVGVzdCA9IChbY3VycmVudFRl c3QgcmFuZ2VPZlN0cmluZzpAInN2Zy9XM0MtU1ZHLTEuMSJdLmxlbmd0aCk7CisgICAgYm9vbCBp c1NWR1czQ1Rlc3QgPSAoZ0xheW91dFRlc3RDb250cm9sbGVyLT50ZXN0UGF0aE9yVVJMKCkuZmlu ZCgic3ZnL1czQy1TVkctMS4xIikgIT0gc3RkOjpzdHJpbmc6Om5wb3MpOwogICAgIGlmIChpc1NW R1czQ1Rlc3QpCiAgICAgICAgIFtbbWFpbkZyYW1lIHdlYlZpZXddIHNldEZyYW1lU2l6ZTpOU01h a2VTaXplKDQ4MCwgMzYwKV07CiAgICAgZWxzZQpAQCAtOTE2LDcgKzkxNiw3IEBAIHZvaWQgZHVt cCgpCiAgICAgfQogICAgIAogICAgIGlmIChkdW1wQWxsUGl4ZWxzIHx8IChkdW1wUGl4ZWxzICYm ICFkdW1wQXNUZXh0KSkKLSAgICAgICAgZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRo RXhwZWN0ZWQoW2N1cnJlbnRUZXN0IFVURjhTdHJpbmddLCBkdW1wQWxsUGl4ZWxzKTsKKyAgICAg ICAgZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0ZWQoZ0xheW91dFRlc3RD b250cm9sbGVyLT5leHBlY3RlZFBpeGVsSGFzaCgpKTsKIAogICAgIGZmbHVzaChzdGRvdXQpOwog ICAgIGZmbHVzaChzdGRlcnIpOwpAQCAtOTI5LDE2ICs5MjksNiBAQCBzdGF0aWMgYm9vbCBzaG91 bGRMb2dGcmFtZUxvYWREZWxlZ2F0ZXMoY29uc3QgY2hhciAqcGF0aE9yVVJMKQogICAgIHJldHVy biBzdHJzdHIocGF0aE9yVVJMLCAibG9hZGluZy8iKTsKIH0KIAotc3RhdGljIENGVVJMUmVmIGNy ZWF0ZUNGVVJMRnJvbVBhdGhPclVSTChDRlN0cmluZ1JlZiBwYXRoT3JVUkxTdHJpbmcpCi17Ci0g ICAgQ0ZVUkxSZWYgVVJMOwotICAgIGlmIChDRlN0cmluZ0hhc1ByZWZpeChwYXRoT3JVUkxTdHJp bmcsIENGU1RSKCJodHRwOi8vIikpIHx8IENGU3RyaW5nSGFzUHJlZml4KHBhdGhPclVSTFN0cmlu ZywgQ0ZTVFIoImh0dHBzOi8vIikpKQotICAgICAgICBVUkwgPSBDRlVSTENyZWF0ZVdpdGhTdHJp bmcoTlVMTCwgcGF0aE9yVVJMU3RyaW5nLCBOVUxMKTsKLSAgICBlbHNlCi0gICAgICAgIFVSTCA9 IENGVVJMQ3JlYXRlV2l0aEZpbGVTeXN0ZW1QYXRoKE5VTEwsIHBhdGhPclVSTFN0cmluZywga0NG VVJMUE9TSVhQYXRoU3R5bGUsIEZBTFNFKTsKLSAgICByZXR1cm4gVVJMOwotfQotCiBzdGF0aWMg dm9pZCByZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0ZUJlZm9yZVRlc3RpbmcoKQogewogICAg IFdlYlZpZXcgKndlYlZpZXcgPSBbbWFpbkZyYW1lIHdlYlZpZXddOwpAQCAtOTY2LDUzICs5NTYs NjcgQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdGVCZWZvcmVUZXN0 aW5nKCkKICAgICBbV2ViVmlldyBfc2V0VXNlc1Rlc3RNb2RlRm9jdXNSaW5nQ29sb3I6WUVTXTsK IH0KIAotc3RhdGljIHZvaWQgcnVuVGVzdChjb25zdCBjaGFyICpwYXRoT3JVUkwpCitzdGF0aWMg dm9pZCBydW5UZXN0KGNvbnN0IHN0ZDo6c3RyaW5nJiB0ZXN0UGF0aE9yVVJMKQogewotICAgIENG U3RyaW5nUmVmIHBhdGhPclVSTFN0cmluZyA9IENGU3RyaW5nQ3JlYXRlV2l0aENTdHJpbmcoTlVM TCwgcGF0aE9yVVJMLCBrQ0ZTdHJpbmdFbmNvZGluZ1VURjgpOworICAgIEFTU0VSVCghdGVzdFBh dGhPclVSTC5lbXB0eSgpKTsKKyAgICAKKyAgICAvLyBMb29rIGZvciAiJyIgYXMgYSBzZXBhcmF0 b3IgYmV0d2VlbiB0aGUgcGF0aCBvciBVUkwsIGFuZCB0aGUgcGl4ZWwgZHVtcCBoYXNoIHRoYXQg Zm9sbG93cy4KKyAgICBzdGQ6OnN0cmluZyBwYXRoT3JVUkwodGVzdFBhdGhPclVSTCk7CisgICAg c3RkOjpzdHJpbmcgZXhwZWN0ZWRQaXhlbEhhc2g7CisgICAgCisgICAgc2l6ZV90IHNlcGFyYXRv clBvcyA9IHBhdGhPclVSTC5maW5kKCInIik7CisgICAgaWYgKHNlcGFyYXRvclBvcyAhPSBzdGQ6 OnN0cmluZzo6bnBvcykgeworICAgICAgICBwYXRoT3JVUkwgPSBzdGQ6OnN0cmluZyh0ZXN0UGF0 aE9yVVJMLCAwLCBzZXBhcmF0b3JQb3MpOworICAgICAgICBleHBlY3RlZFBpeGVsSGFzaCA9IHN0 ZDo6c3RyaW5nKHRlc3RQYXRoT3JVUkwsIHNlcGFyYXRvclBvcyArIDEpOworICAgIH0KKworICAg IE5TU3RyaW5nICpwYXRoT3JVUkxTdHJpbmcgPSBbTlNTdHJpbmcgc3RyaW5nV2l0aFVURjhTdHJp bmc6cGF0aE9yVVJMLmNfc3RyKCldOwogICAgIGlmICghcGF0aE9yVVJMU3RyaW5nKSB7Ci0gICAg ICAgIGZwcmludGYoc3RkZXJyLCAiRmFpbGVkIHRvIHBhcnNlIGZpbGVuYW1lIGFzIFVURi04OiAl c1xuIiwgcGF0aE9yVVJMKTsKKyAgICAgICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gcGFy c2UgXCIlc1wiIGFzIFVURi04XG4iLCBwYXRoT3JVUkwuY19zdHIoKSk7CiAgICAgICAgIHJldHVy bjsKICAgICB9CiAKLSAgICBDRlVSTFJlZiBVUkwgPSBjcmVhdGVDRlVSTEZyb21QYXRoT3JVUkwo cGF0aE9yVVJMU3RyaW5nKTsKLSAgICBpZiAoIVVSTCkgewotICAgICAgICBDRlJlbGVhc2UocGF0 aE9yVVJMU3RyaW5nKTsKLSAgICAgICAgZnByaW50ZihzdGRlcnIsICJDYW4ndCB0dXJuICVzIGlu dG8gYSBDRlVSTFxuIiwgcGF0aE9yVVJMKTsKKyAgICBOU1VSTCAqdXJsOworICAgIGlmIChbcGF0 aE9yVVJMU3RyaW5nIGhhc1ByZWZpeDpAImh0dHA6Ly8iXSB8fCBbcGF0aE9yVVJMU3RyaW5nIGhh c1ByZWZpeDpAImh0dHBzOi8vIl0pCisgICAgICAgIHVybCA9IFtOU1VSTCBVUkxXaXRoU3RyaW5n OnBhdGhPclVSTFN0cmluZ107CisgICAgZWxzZQorICAgICAgICB1cmwgPSBbTlNVUkwgZmlsZVVS TFdpdGhQYXRoOnBhdGhPclVSTFN0cmluZ107CisgICAgaWYgKCF1cmwpIHsKKyAgICAgICAgZnBy aW50ZihzdGRlcnIsICJGYWlsZWQgdG8gcGFyc2UgXCIlc1wiIGFzIGEgdXJsXG4iLCBwYXRoT3JV UkwuY19zdHIoKSk7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAKKyAgICBjb25zdCBzdGQ6OnN0 cmluZyB0ZXN0VVJMKFtbdXJsIGFic29sdXRlU3RyaW5nXSBVVEY4U3RyaW5nXSk7CisgICAgCiAg ICAgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdGVCZWZvcmVUZXN0aW5nKCk7CiAKLSAgICBn TGF5b3V0VGVzdENvbnRyb2xsZXIgPSBuZXcgTGF5b3V0VGVzdENvbnRyb2xsZXIodGVzdFJlcGFp bnREZWZhdWx0LCByZXBhaW50U3dlZXBIb3Jpem9udGFsbHlEZWZhdWx0KTsKKyAgICBnTGF5b3V0 VGVzdENvbnRyb2xsZXIgPSBuZXcgTGF5b3V0VGVzdENvbnRyb2xsZXIodGVzdFVSTCwgZXhwZWN0 ZWRQaXhlbEhhc2gsIHRlc3RSZXBhaW50RGVmYXVsdCwgcmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5 RGVmYXVsdCk7CiAgICAgdG9wTG9hZGluZ0ZyYW1lID0gbmlsOwogICAgIGRvbmUgPSBOTzsKIAog ICAgIGlmIChkaXNhbGxvd2VkVVJMcykKICAgICAgICAgQ0ZTZXRSZW1vdmVBbGxWYWx1ZXMoZGlz YWxsb3dlZFVSTHMpOwotICAgIGlmIChzaG91bGRMb2dGcmFtZUxvYWREZWxlZ2F0ZXMocGF0aE9y VVJMKSkKKyAgICBpZiAoc2hvdWxkTG9nRnJhbWVMb2FkRGVsZWdhdGVzKHBhdGhPclVSTC5jX3N0 cigpKSkKICAgICAgICAgZ0xheW91dFRlc3RDb250cm9sbGVyLT5zZXREdW1wRnJhbWVMb2FkQ2Fs bGJhY2tzKHRydWUpOwogCiAgICAgaWYgKFtXZWJIaXN0b3J5IG9wdGlvbmFsU2hhcmVkSGlzdG9y eV0pCiAgICAgICAgIFtXZWJIaXN0b3J5IHNldE9wdGlvbmFsU2hhcmVkSGlzdG9yeTpuaWxdOwor CiAgICAgbGFzdE1vdXNlUG9zaXRpb24gPSBOU1plcm9Qb2ludDsKICAgICBsYXN0Q2xpY2tQb3Np dGlvbiA9IE5TWmVyb1BvaW50OwogCi0gICAgaWYgKGN1cnJlbnRUZXN0ICE9IG5pbCkKLSAgICAg ICAgQ0ZSZWxlYXNlKGN1cnJlbnRUZXN0KTsKLSAgICBjdXJyZW50VGVzdCA9IChOU1N0cmluZyAq KXBhdGhPclVSTFN0cmluZzsKICAgICBbcHJldlRlc3RCRkl0ZW0gcmVsZWFzZV07CiAgICAgcHJl dlRlc3RCRkl0ZW0gPSBbW1tbbWFpbkZyYW1lIHdlYlZpZXddIGJhY2tGb3J3YXJkTGlzdF0gY3Vy cmVudEl0ZW1dIHJldGFpbl07CiAKICAgICBXb3JrUXVldWU6OnNoYXJlZCgpLT5jbGVhcigpOwog ICAgIFdvcmtRdWV1ZTo6c2hhcmVkKCktPnNldEZyb3plbihmYWxzZSk7CiAKLSAgICBCT09MIF9z aG91bGRJZ25vcmVXZWJDb3JlTm9kZUxlYWtzID0gc2hvdWxkSWdub3JlV2ViQ29yZU5vZGVMZWFr cyhDRlVSTEdldFN0cmluZyhVUkwpKTsKLSAgICBpZiAoX3Nob3VsZElnbm9yZVdlYkNvcmVOb2Rl TGVha3MpCisgICAgYm9vbCBpZ25vcmVXZWJDb3JlTm9kZUxlYWtzID0gc2hvdWxkSWdub3JlV2Vi Q29yZU5vZGVMZWFrcyh0ZXN0VVJMKTsKKyAgICBpZiAoaWdub3JlV2ViQ29yZU5vZGVMZWFrcykK ICAgICAgICAgW1dlYkNvcmVTdGF0aXN0aWNzIHN0YXJ0SWdub3JpbmdXZWJDb3JlTm9kZUxlYWtz XTsKIAogICAgIE5TQXV0b3JlbGVhc2VQb29sICpwb29sID0gW1tOU0F1dG9yZWxlYXNlUG9vbCBh bGxvY10gaW5pdF07Ci0gICAgW21haW5GcmFtZSBsb2FkUmVxdWVzdDpbTlNVUkxSZXF1ZXN0IHJl cXVlc3RXaXRoVVJMOihOU1VSTCAqKVVSTF1dOwotICAgIENGUmVsZWFzZShVUkwpOworICAgIFtt YWluRnJhbWUgbG9hZFJlcXVlc3Q6W05TVVJMUmVxdWVzdCByZXF1ZXN0V2l0aFVSTDp1cmxdXTsK ICAgICBbcG9vbCByZWxlYXNlXTsKICAgICB3aGlsZSAoIWRvbmUpIHsKICAgICAgICAgcG9vbCA9 IFtbTlNBdXRvcmVsZWFzZVBvb2wgYWxsb2NdIGluaXRdOwpAQCAtMTA1NCw4ICsxMDU4LDggQEAg c3RhdGljIHZvaWQgcnVuVGVzdChjb25zdCBjaGFyICpwYXRoT3JVUkwpCiAKICAgICBnTGF5b3V0 VGVzdENvbnRyb2xsZXItPmRlcmVmKCk7CiAgICAgZ0xheW91dFRlc3RDb250cm9sbGVyID0gMDsK LQotICAgIGlmIChfc2hvdWxkSWdub3JlV2ViQ29yZU5vZGVMZWFrcykKKyAgICAKKyAgICBpZiAo aWdub3JlV2ViQ29yZU5vZGVMZWFrcykKICAgICAgICAgW1dlYkNvcmVTdGF0aXN0aWNzIHN0b3BJ Z25vcmluZ1dlYkNvcmVOb2RlTGVha3NdOwogfQogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWVNYWMuaCBiL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZU1hYy5oCmluZGV4IDAzZDM1NGQuLjdiMzliMDAg MTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJl ZU1hYy5oCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJl ZU1hYy5oCkBAIC0zNiw2ICszNiw4IEBACiAjZGVmaW5lIEJVSUxESU5HX09OX1RJR0VSIDEKICNl bGlmIE1BQ19PU19YX1ZFUlNJT05fTUFYX0FMTE9XRUQgPD0gTUFDX09TX1hfVkVSU0lPTl8xMF81 CiAjZGVmaW5lIEJVSUxESU5HX09OX0xFT1BBUkQgMQorI2VsaWYgTUFDX09TX1hfVkVSU0lPTl9N QVhfQUxMT1dFRCA8PSBNQUNfT1NfWF9WRVJTSU9OXzEwXzYKKyNkZWZpbmUgQlVJTERJTkdfT05f U05PV0xFT1BBUkQgMQogI2VuZGlmCiAKIEBjbGFzcyBEdW1wUmVuZGVyVHJlZURyYWdnaW5nSW5m bzsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9QaXhlbER1bXBT dXBwb3J0TWFjLm1tIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL1BpeGVsRHVtcFN1 cHBvcnRNYWMubW0KaW5kZXggOWRkYmEzMS4uODM2YzA5MyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvbWFjL1BpeGVsRHVtcFN1cHBvcnRNYWMubW0KKysrIGIvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL1BpeGVsRHVtcFN1cHBvcnRNYWMubW0KQEAgLTM1LDE1 MiArMzUsMTUyIEBACiAjaW5jbHVkZSAiTGF5b3V0VGVzdENvbnRyb2xsZXIuaCIKICNpbmNsdWRl IDxDb3JlR3JhcGhpY3MvQ0dCaXRtYXBDb250ZXh0Lmg+CiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlv bnMuaD4KLSNpbmNsdWRlIDx3dGYvUmV0YWluUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5o PgogCiAjaW1wb3J0IDxXZWJLaXQvV2ViRG9jdW1lbnRQcml2YXRlLmg+CiAjaW1wb3J0IDxXZWJL aXQvV2ViS2l0Lmg+CiAKLXN0YXRpYyB1bnNpZ25lZCBjaGFyKiBzY3JlZW5DYXB0dXJlQnVmZmVy OworI2lmZGVmIEJVSUxESU5HX09OX1NOT1dMRU9QQVJECisjZGVmaW5lIFBST0ZJTEVfUEFUSCAi L1N5c3RlbS9MaWJyYXJ5L0NvbG9yU3luYy9Qcm9maWxlcy9zUkdCIFByb2ZpbGUuaWNjIgorI2Vs c2UKKyNkZWZpbmUgUFJPRklMRV9QQVRIICIvU3lzdGVtL0xpYnJhcnkvQ29sb3JTeW5jL1Byb2Zp bGVzL0dlbmVyaWMgUkdCIFByb2ZpbGUuaWNjIgorI2VuZGlmCiAKLXN0YXRpYyBib29sIGNoYW5n ZWRDb2xvclByb2ZpbGUgPSBmYWxzZTsKLXN0YXRpYyBDTVByb2ZpbGVMb2NhdGlvbiBjdXJyZW50 Q29sb3JQcm9maWxlTG9jYXRpb247Ci1zdGF0aWMgQ0dDb2xvclNwYWNlUmVmIHNoYXJlZENvbG9y U3BhY2U7CitzdGF0aWMgQ01Qcm9maWxlTG9jYXRpb24gc0luaXRpYWxQcm9maWxlTG9jYXRpb24g PSB7Y21Ob1Byb2ZpbGVCYXNlLCB7MCwwLDB9fTsKIAotdm9pZCByZXN0b3JlQ29sb3JTcGFjZShp bnQgaWdub3JlZCkKK3ZvaWQgcmVzdG9yZU1haW5EaXNwbGF5Q29sb3JQcm9maWxlKGludCBpZ25v cmVkKQogewogICAgIC8vIFRoaXMgaXMgdXNlZCBhcyBhIHNpZ25hbCBoYW5kbGVyLCBhbmQgdGh1 cyB0aGUgY2FsbHMgaW50byBDb2xvclN5bmMgYXJlIHVuc2FmZQogICAgIC8vIEJ1dCB3ZSBtaWdo dCBhcyB3ZWxsIHRyeSB0byByZXN0b3JlIHRoZSB1c2VyJ3MgY29sb3IgcHJvZmlsZSwgd2UncmUg Z29pbmcgZG93biBhbnl3YXkuLi4KLSAgICBpZiAoY2hhbmdlZENvbG9yUHJvZmlsZSkgewotICAg ICAgICBDTURldmljZVNjb3BlIHNjb3BlID0geyBrQ0ZQcmVmZXJlbmNlc0N1cnJlbnRVc2VyLCBr Q0ZQcmVmZXJlbmNlc0N1cnJlbnRIb3N0IH07Ci0gICAgICAgIGludCBlcnJvciA9IENNU2V0RGV2 aWNlUHJvZmlsZShjbURpc3BsYXlEZXZpY2VDbGFzcywgY21EZWZhdWx0RGV2aWNlSUQsICZzY29w ZSwgY21EZWZhdWx0UHJvZmlsZUlELCAmY3VycmVudENvbG9yUHJvZmlsZUxvY2F0aW9uKTsKKyAg ICBpZiAoc0luaXRpYWxQcm9maWxlTG9jYXRpb24ubG9jVHlwZSAhPSBjbU5vUHJvZmlsZUJhc2Up IHsKKyAgICAgICAgY29uc3QgQ01EZXZpY2VTY29wZSBzY29wZSA9IHsga0NGUHJlZmVyZW5jZXND dXJyZW50VXNlciwga0NGUHJlZmVyZW5jZXNDdXJyZW50SG9zdCB9OworICAgICAgICBpbnQgZXJy b3IgPSBDTVNldERldmljZVByb2ZpbGUoY21EaXNwbGF5RGV2aWNlQ2xhc3MsIGtDR0RpcmVjdE1h aW5EaXNwbGF5LCAmc2NvcGUsIGNtRGVmYXVsdFByb2ZpbGVJRCwgJnNJbml0aWFsUHJvZmlsZUxv Y2F0aW9uKTsKICAgICAgICAgaWYgKGVycm9yKQotICAgICAgICAgICAgZnByaW50ZihzdGRlcnIs ICJGYWlsZWQgdG8gcmV0b3JlIHByZXZpb3VzIGNvbG9yIHByb2ZpbGUhICBZb3UgbWF5IG5lZWQg dG8gb3BlbiBTeXN0ZW0gUHJlZmVyZW5jZXMgOiBEaXNwbGF5cyA6IENvbG9yIGFuZCBtYW51YWxs eSByZXN0b3JlIHlvdXIgY29sb3Igc2V0dGluZ3MuICAoRXJyb3I6ICVpKSIsIGVycm9yKTsKLSAg ICAgICAgY2hhbmdlZENvbG9yUHJvZmlsZSA9IGZhbHNlOworICAgICAgICAgICAgZnByaW50Zihz dGRlcnIsICJGYWlsZWQgdG8gcmVzdG9yZSBpbml0aWFsIGNvbG9yIHByb2ZpbGUgZm9yIG1haW4g ZGlzcGxheSEgT3BlbiBTeXN0ZW0gUHJlZmVyZW5jZXMgPiBEaXNwbGF5cyA+IENvbG9yIGFuZCBt YW51YWxseSByZS1zZWxlY3QgdGhlIHByb2ZpbGUuICAoRXJyb3I6ICVpKSIsIGVycm9yKTsKKyAg ICAgICAgc0luaXRpYWxQcm9maWxlTG9jYXRpb24ubG9jVHlwZSA9IGNtTm9Qcm9maWxlQmFzZTsK ICAgICB9CiB9CiAKLXN0YXRpYyB2b2lkIGZhaWxlZEdldHRpbmdDdXJyZW50UHJvZmlsZShpbnQg ZXJyb3IpCit2b2lkIHNldHVwTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUoKQogewotICAgIGZwcmlu dGYoc3RkZXJyLCAiRmFpbGVkIHRvIGdldCBjdXJyZW50IGNvbG9yIHByb2ZpbGUuICBJIHdpbGwg bm90IGJlIGFibGUgdG8gcmVzdG9yZSB5b3VyIGN1cnJlbnQgcHJvZmlsZSwgdGh1cyBJJ20gbm90 IGNoYW5naW5nIGl0LiAgTWFueSBwaXhlbCB0ZXN0cyBtYXkgZmFpbCBhcyBhIHJlc3VsdC4gIChF cnJvcjogJWkpXG4iLCBlcnJvcik7Ci19Ci0KLXN0YXRpYyB2b2lkIHNldERlZmF1bHRDb2xvclBy b2ZpbGVUb1JHQigpCi17Ci0gICAgQ01Qcm9maWxlUmVmIGdlbmVyaWNQcm9maWxlID0gKENNUHJv ZmlsZVJlZilbW05TQ29sb3JTcGFjZSBnZW5lcmljUkdCQ29sb3JTcGFjZV0gY29sb3JTeW5jUHJv ZmlsZV07Ci0gICAgQ01Qcm9maWxlTG9jYXRpb24gZ2VuZXJpY1Byb2ZpbGVMb2NhdGlvbjsKLSAg ICBVSW50MzIgbG9jYXRpb25TaXplID0gc2l6ZW9mKGdlbmVyaWNQcm9maWxlTG9jYXRpb24pOwot ICAgIGludCBlcnJvciA9IE5DTUdldFByb2ZpbGVMb2NhdGlvbihnZW5lcmljUHJvZmlsZSwgJmdl bmVyaWNQcm9maWxlTG9jYXRpb24sICZsb2NhdGlvblNpemUpOwotICAgIGlmIChlcnJvcikgewot ICAgICAgICBmYWlsZWRHZXR0aW5nQ3VycmVudFByb2ZpbGUoZXJyb3IpOwotICAgICAgICByZXR1 cm47CisgICAgY29uc3QgQ01EZXZpY2VTY29wZSBzY29wZSA9IHsga0NGUHJlZmVyZW5jZXNDdXJy ZW50VXNlciwga0NGUHJlZmVyZW5jZXNDdXJyZW50SG9zdCB9OworICAgIGludCBlcnJvcjsKKyAg ICAKKyAgICBDTVByb2ZpbGVSZWYgcHJvZmlsZSA9IE5VTEw7CisgICAgZXJyb3IgPSBDTUdldFBy b2ZpbGVCeUFWSUQoa0NHRGlyZWN0TWFpbkRpc3BsYXksICZwcm9maWxlKTsKKyAgICBpZiAoIWVy cm9yKSB7CisgICAgICAgIFVJbnQzMiBzaXplID0gc2l6ZW9mKENNUHJvZmlsZUxvY2F0aW9uKTsK KyAgICAgICAgZXJyb3IgPSBOQ01HZXRQcm9maWxlTG9jYXRpb24ocHJvZmlsZSwgJnNJbml0aWFs UHJvZmlsZUxvY2F0aW9uLCAmc2l6ZSk7CisgICAgICAgIENNQ2xvc2VQcm9maWxlKHByb2ZpbGUp OwogICAgIH0KLQotICAgIENNUHJvZmlsZUxvY2F0aW9uIHByZXZpb3VzUHJvZmlsZUxvY2F0aW9u OwotICAgIGVycm9yID0gQ01HZXREZXZpY2VQcm9maWxlKGNtRGlzcGxheURldmljZUNsYXNzLCBj bURlZmF1bHREZXZpY2VJRCwgY21EZWZhdWx0UHJvZmlsZUlELCAmcHJldmlvdXNQcm9maWxlTG9j YXRpb24pOwogICAgIGlmIChlcnJvcikgewotICAgICAgICBmYWlsZWRHZXR0aW5nQ3VycmVudFBy b2ZpbGUoZXJyb3IpOworICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byByZXRyaWV2 ZSBjdXJyZW50IGNvbG9yIHByb2ZpbGUgZm9yIG1haW4gZGlzcGxheSwgdGh1cyBpdCB3b24ndCBi ZSBjaGFuZ2VkLiAgTWFueSBwaXhlbCB0ZXN0cyBtYXkgZmFpbCBhcyBhIHJlc3VsdC4gIChFcnJv cjogJWkpIiwgZXJyb3IpOworICAgICAgICBzSW5pdGlhbFByb2ZpbGVMb2NhdGlvbi5sb2NUeXBl ID0gY21Ob1Byb2ZpbGVCYXNlOwogICAgICAgICByZXR1cm47CiAgICAgfQorICAgIAorICAgIENN UHJvZmlsZUxvY2F0aW9uIGxvY2F0aW9uOworICAgIGxvY2F0aW9uLmxvY1R5cGUgPSBjbUZpbGVC YXNlZFByb2ZpbGU7CisgICAgTlNVUkwgKnVybCA9IFtOU1VSTCBmaWxlVVJMV2l0aFBhdGg6W05T U3RyaW5nIHN0cmluZ1dpdGhVVEY4U3RyaW5nOlBST0ZJTEVfUEFUSF1dOworICAgIEZTUmVmIGZz UmVmOworICAgIGlmICh1cmwgJiYgQ0ZVUkxHZXRGU1JlZigoQ0ZVUkxSZWYpdXJsLCAmZnNSZWYp KSB7CisgICAgICAgIGVycm9yID0gRlNHZXRDYXRhbG9nSW5mbygmZnNSZWYsIDAsIE5VTEwsIE5V TEwsICZsb2NhdGlvbi51LmZpbGVMb2Muc3BlYywgTlVMTCk7CisgICAgICAgIGlmIChlcnJvciA9 PSBub0VycikKKyAgICAgICAgZXJyb3IgPSBDTVNldERldmljZVByb2ZpbGUoY21EaXNwbGF5RGV2 aWNlQ2xhc3MsIGtDR0RpcmVjdE1haW5EaXNwbGF5LCAmc2NvcGUsIGNtRGVmYXVsdFByb2ZpbGVJ RCwgJmxvY2F0aW9uKTsKKyAgICB9CisgICAgZWxzZQorICAgICAgICBlcnJvciA9IC0xOwogCi0g ICAgQ01Qcm9maWxlUmVmIHByZXZpb3VzUHJvZmlsZTsKLSAgICBlcnJvciA9IENNT3BlblByb2Zp bGUoJnByZXZpb3VzUHJvZmlsZSwgJnByZXZpb3VzUHJvZmlsZUxvY2F0aW9uKTsKICAgICBpZiAo ZXJyb3IpIHsKLSAgICAgICAgZmFpbGVkR2V0dGluZ0N1cnJlbnRQcm9maWxlKGVycm9yKTsKKyAg ICAgICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gc2V0IGNvbG9yIHByb2ZpbGUgZm9yIG1h aW4gZGlzcGxheSEgIE1hbnkgcGl4ZWwgdGVzdHMgbWF5IGZhaWwgYXMgYSByZXN1bHQuICAoRXJy b3I6ICVpKSIsIGVycm9yKTsKKyAgICAgICAgc0luaXRpYWxQcm9maWxlTG9jYXRpb24ubG9jVHlw ZSA9IGNtTm9Qcm9maWxlQmFzZTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KLQotICAgIENGU3Ry aW5nUmVmIHByZXZpb3VzUHJvZmlsZU5hbWU7Ci0gICAgQ0ZTdHJpbmdSZWYgZ2VuZXJpY1Byb2Zp bGVOYW1lOwotICAgIGNoYXIgcHJldmlvdXNQcm9maWxlTmFtZVN0cmluZ1sxMDI0XTsKLSAgICBj aGFyIGdlbmVyaWNQcm9maWxlTmFtZVN0cmluZ1sxMDI0XTsKLSAgICBDTUNvcHlQcm9maWxlRGVz Y3JpcHRpb25TdHJpbmcocHJldmlvdXNQcm9maWxlLCAmcHJldmlvdXNQcm9maWxlTmFtZSk7Ci0g ICAgQ01Db3B5UHJvZmlsZURlc2NyaXB0aW9uU3RyaW5nKGdlbmVyaWNQcm9maWxlLCAmZ2VuZXJp Y1Byb2ZpbGVOYW1lKTsKLSAgICBDRlN0cmluZ0dldENTdHJpbmcocHJldmlvdXNQcm9maWxlTmFt ZSwgcHJldmlvdXNQcm9maWxlTmFtZVN0cmluZywgc2l6ZW9mKHByZXZpb3VzUHJvZmlsZU5hbWVT dHJpbmcpLCBrQ0ZTdHJpbmdFbmNvZGluZ1VURjgpOwotICAgIENGU3RyaW5nR2V0Q1N0cmluZyhn ZW5lcmljUHJvZmlsZU5hbWUsIGdlbmVyaWNQcm9maWxlTmFtZVN0cmluZywgc2l6ZW9mKHByZXZp b3VzUHJvZmlsZU5hbWVTdHJpbmcpLCBrQ0ZTdHJpbmdFbmNvZGluZ1VURjgpOwotICAgIENGUmVs ZWFzZShwcmV2aW91c1Byb2ZpbGVOYW1lKTsKLSAgICBDRlJlbGVhc2UoZ2VuZXJpY1Byb2ZpbGVO YW1lKTsKLQotICAgIENNQ2xvc2VQcm9maWxlKHByZXZpb3VzUHJvZmlsZSk7Ci0KLSAgICBmcHJp bnRmKHN0ZGVyciwgIlxuXG5XQVJOSU5HOiBUZW1wb3JhcmlseSBjaGFuZ2luZyB5b3VyIHN5c3Rl bSBjb2xvciBwcm9maWxlIGZyb20gXCIlc1wiIHRvIFwiJXNcIi5cbiIsIHByZXZpb3VzUHJvZmls ZU5hbWVTdHJpbmcsIGdlbmVyaWNQcm9maWxlTmFtZVN0cmluZyk7CisgICAgCisgICAgLy8gT3Ro ZXIgc2lnbmFscyBhcmUgaGFuZGxlZCBpbiBpbnN0YWxsU2lnbmFsSGFuZGxlcnMoKSB3aGljaCBh bHNvIGNhbGxzIHJlc3RvcmVNYWluRGlzcGxheUNvbG9yUHJvZmlsZSgpCisgICAgc2lnbmFsKFNJ R0lOVCwgcmVzdG9yZU1haW5EaXNwbGF5Q29sb3JQcm9maWxlKTsKKyAgICBzaWduYWwoU0lHSFVQ LCByZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUpOworICAgIHNpZ25hbChTSUdURVJNLCBy ZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUpOworICAgIAorICAgIGZwcmludGYoc3RkZXJy LCAiXG5cbldBUk5JTkc6IFRlbXBvcmFyaWx5IGNoYW5naW5nIHRoZSBtYWluIGRpc3BsYXkgY29s b3IgcHJvZmlsZSB0byBcIiVzXCI6IHRoZSBjb2xvcnMgb24geW91ciBzY3JlZW4gd2lsbCBjaGFu Z2UgZm9yIHRoZSBkdXJhdGlvbiBvZiB0aGUgdGVzdGluZy5cbiIsIFBST0ZJTEVfUEFUSCk7CiAg ICAgZnByaW50ZihzdGRlcnIsICJUaGlzIGFsbG93cyB0aGUgV2ViS2l0IHBpeGVsLWJhc2VkIHJl Z3Jlc3Npb24gdGVzdHMgdG8gaGF2ZSBjb25zaXN0ZW50IGNvbG9yIHZhbHVlcyBhY3Jvc3MgYWxs IG1hY2hpbmVzLlxuIik7Ci0gICAgZnByaW50ZihzdGRlcnIsICJUaGUgY29sb3JzIG9uIHlvdXIg c2NyZWVuIHdpbGwgY2hhbmdlIGZvciB0aGUgZHVyYXRpb24gb2YgdGhlIHRlc3RpbmcuXG5cbiIp OwotCi0gICAgQ01EZXZpY2VTY29wZSBzY29wZSA9IHsga0NGUHJlZmVyZW5jZXNDdXJyZW50VXNl ciwga0NGUHJlZmVyZW5jZXNDdXJyZW50SG9zdCB9OwotICAgIGlmICgoZXJyb3IgPSBDTVNldERl dmljZVByb2ZpbGUoY21EaXNwbGF5RGV2aWNlQ2xhc3MsIGNtRGVmYXVsdERldmljZUlELCAmc2Nv cGUsIGNtRGVmYXVsdFByb2ZpbGVJRCwgJmdlbmVyaWNQcm9maWxlTG9jYXRpb24pKSkgewotICAg ICAgICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byBzZXQgY29sb3IgcHJvZmlsZSB0byBcIiVz XCIhIE1hbnkgcGl4ZWwgdGVzdHMgd2lsbCBmYWlsIGFzIGEgcmVzdWx0LiAgKEVycm9yOiAlaSki LAotICAgICAgICAgICAgZ2VuZXJpY1Byb2ZpbGVOYW1lU3RyaW5nLCBlcnJvcik7Ci0gICAgfSBl bHNlIHsKLSAgICAgICAgY3VycmVudENvbG9yUHJvZmlsZUxvY2F0aW9uID0gcHJldmlvdXNQcm9m aWxlTG9jYXRpb247Ci0gICAgICAgIGNoYW5nZWRDb2xvclByb2ZpbGUgPSB0cnVlOwotICAgICAg ICBzaWduYWwoU0lHSU5ULCByZXN0b3JlQ29sb3JTcGFjZSk7Ci0gICAgICAgIHNpZ25hbChTSUdI VVAsIHJlc3RvcmVDb2xvclNwYWNlKTsKLSAgICAgICAgc2lnbmFsKFNJR1RFUk0sIHJlc3RvcmVD b2xvclNwYWNlKTsKLSAgICB9CiB9CiAKLXZvaWQgaW5pdGlhbGl6ZUNvbG9yU3BhY2VBbmRTY3Jl ZUJ1ZmZlckZvclBpeGVsVGVzdHMoKQotewotICAgIHNldERlZmF1bHRDb2xvclByb2ZpbGVUb1JH QigpOwotICAgIHNjcmVlbkNhcHR1cmVCdWZmZXIgPSAodW5zaWduZWQgY2hhciAqKW1hbGxvYyht YXhWaWV3SGVpZ2h0ICogbWF4Vmlld1dpZHRoICogNCk7Ci0gICAgc2hhcmVkQ29sb3JTcGFjZSA9 IENHQ29sb3JTcGFjZUNyZWF0ZURldmljZVJHQigpOwotfQotCi0vLyBEZWNsYXJlZCBpbiBQaXhl bER1bXBTdXBwb3J0Q0cuaAotCi1SZXRhaW5QdHI8Q0dDb250ZXh0UmVmPiBnZXRCaXRtYXBDb250 ZXh0RnJvbVdlYlZpZXcoKQorLy8gQmVjYXVzZSBvZiBBcHBLaXQgLyBXZWJLaXQgY29uc3RyYWlu dHMsIHdlIGNhbid0IHJlbmRlciBkaXJlY3RseSBpbiB0aGUKKy8vIGNvbG9yc3BhY2Ugb2Ygb3Vy IGNob2ljZS4KKy8vIAorLy8gU28gd2UgaGF2ZSB0byByZW5kZXIgdG8gRGV2aWNlUkdCLCB3aGlj aCBiYXNpY2FsbHkgbWVhbnMgc2FtZSBhcyBtYWluIGRpc3BsYXkKKy8vIGNvbG9yc3BhY2UuCisv LyAKKy8vIFRoaXMgaW1wbGllcyB3ZSBoYXZlIHRvIHRlbXBvcmFyaWx5IGNoYW5nZSB0aGUgcHJv ZmlsZSBvZiB0aGUgbWFpbiBkaXNwbGF5IHRvCisvLyB0aGUgY29sb3JzcGFjZSB3ZSB3YW50IHRv IHJlbmRlciBpbnRvLgorLy8gCisvLyBGaW5hbGx5LCB3ZSB3YW50IHRoZSByZW5kZXJlZCBiaXRt YXAgdG8gYWx3YXlzIGJlIGluIHByZW11bHRpcGxpZWQgUkdCQTggdG8KKy8vIGVuc3VyZSBlbmRp YW4gaW5kZXBlbmRlbmN5IGFuZCBoYXZlIGNvbnNpc3RlbnQgTUQ1IGhhc2hlcworLy8gCisvLyBO b3RlIHRoYXQgcmVuZGVyaW5nIHRvIFJHQkE4IGluZGlyZWN0bHkgZGlzYWJsZXMgQ0cgZm9udCBz bW9vdGhpbmcgYXMgaXQncyBvbmx5CisvLyBzdXBwb3J0ZWQgZm9yIChrQ0dJbWFnZUFscGhhUHJl bXVsdGlwbGllZEZpcnN0IHwga0NHQml0bWFwQnl0ZU9yZGVyMzJIb3N0KS4KKworUGFzc1JlZlB0 cjxCaXRtYXBDb250ZXh0PiBjcmVhdGVCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoYm9vbCBpbmNy ZW1lbnRhbFJlcGFpbnQsIGJvb2wgc3dlZXBIb3Jpem9udGFsbHksIGJvb2wgZHJhd1NlbGVjdGlv blJlY3QpCiB7Ci0gICAgTlNTaXplIHdlYlZpZXdTaXplID0gW1ttYWluRnJhbWUgd2ViVmlld10g ZnJhbWVdLnNpemU7Ci0gICAgcmV0dXJuIFJldGFpblB0cjxDR0NvbnRleHRSZWY+KEFkb3B0Q0Ys IENHQml0bWFwQ29udGV4dENyZWF0ZShzY3JlZW5DYXB0dXJlQnVmZmVyLCBzdGF0aWNfY2FzdDxz aXplX3Q+KHdlYlZpZXdTaXplLndpZHRoKSwgc3RhdGljX2Nhc3Q8c2l6ZV90Pih3ZWJWaWV3U2l6 ZS5oZWlnaHQpLCA4LCBzdGF0aWNfY2FzdDxzaXplX3Q+KHdlYlZpZXdTaXplLndpZHRoKSAqIDQs IHNoYXJlZENvbG9yU3BhY2UsIGtDR0JpdG1hcEJ5dGVPcmRlcjMySG9zdCB8IGtDR0ltYWdlQWxw aGFQcmVtdWx0aXBsaWVkTGFzdCkpOwotfQotCi12b2lkIHBhaW50V2ViVmlldyhDR0NvbnRleHRS ZWYgY29udGV4dCkKLXsKLSAgICBSZXRhaW5QdHI8TlNHcmFwaGljc0NvbnRleHQ+IHNhdmVkQ29u dGV4dCA9IFtOU0dyYXBoaWNzQ29udGV4dCBjdXJyZW50Q29udGV4dF07Ci0KLSAgICBOU0dyYXBo aWNzQ29udGV4dCogbnNDb250ZXh0ID0gW05TR3JhcGhpY3NDb250ZXh0IGdyYXBoaWNzQ29udGV4 dFdpdGhHcmFwaGljc1BvcnQ6Y29udGV4dCBmbGlwcGVkOk5PXTsKLSAgICBbTlNHcmFwaGljc0Nv bnRleHQgc2V0Q3VycmVudENvbnRleHQ6bnNDb250ZXh0XTsKLQogICAgIFdlYlZpZXcqIHZpZXcg PSBbbWFpbkZyYW1lIHdlYlZpZXddOwotICAgIFt2aWV3IGRpc3BsYXlJZk5lZWRlZF07Ci0gICAg W3ZpZXcgbG9ja0ZvY3VzXTsKLSAgICBOU0JpdG1hcEltYWdlUmVwICppbWFnZVJlcCA9IFtbTlNC aXRtYXBJbWFnZVJlcCBhbGxvY10gaW5pdFdpdGhGb2N1c2VkVmlld1JlY3Q6W3ZpZXcgZnJhbWVd XTsKLSAgICBbdmlldyB1bmxvY2tGb2N1c107Ci0gICAgW2ltYWdlUmVwIGRyYXddOwotICAgIFtp bWFnZVJlcCByZWxlYXNlXTsKLQotICAgIFtOU0dyYXBoaWNzQ29udGV4dCBzZXRDdXJyZW50Q29u dGV4dDpzYXZlZENvbnRleHQuZ2V0KCldOwotfQotCi12b2lkIHJlcGFpbnRXZWJWaWV3KENHQ29u dGV4dFJlZiBjb250ZXh0LCBib29sIGhvcml6b250YWwpCi17Ci0gICAgUmV0YWluUHRyPE5TR3Jh cGhpY3NDb250ZXh0PiBzYXZlZENvbnRleHQgPSBbTlNHcmFwaGljc0NvbnRleHQgY3VycmVudENv bnRleHRdOwotCi0gICAgTlNHcmFwaGljc0NvbnRleHQqIG5zQ29udGV4dCA9IFtOU0dyYXBoaWNz Q29udGV4dCBncmFwaGljc0NvbnRleHRXaXRoR3JhcGhpY3NQb3J0OmNvbnRleHQgZmxpcHBlZDpO T107Ci0gICAgW05TR3JhcGhpY3NDb250ZXh0IHNldEN1cnJlbnRDb250ZXh0Om5zQ29udGV4dF07 Ci0KLSAgICBXZWJWaWV3ICp2aWV3ID0gW21haW5GcmFtZSB3ZWJWaWV3XTsKICAgICBOU1NpemUg d2ViVmlld1NpemUgPSBbdmlldyBmcmFtZV0uc2l6ZTsKKyAgICBzaXplX3QgcGl4ZWxzV2lkZSA9 IHN0YXRpY19jYXN0PHNpemVfdD4od2ViVmlld1NpemUud2lkdGgpOworICAgIHNpemVfdCBwaXhl bHNIaWdoID0gc3RhdGljX2Nhc3Q8c2l6ZV90Pih3ZWJWaWV3U2l6ZS5oZWlnaHQpOworICAgIHNp emVfdCByb3dCeXRlcyA9ICg0ICogcGl4ZWxzV2lkZSArIDYzKSAmIH42MzsgLy8gVXNlIGEgbXVs dGlwbGUgb2YgNjQgYnl0ZXMgdG8gaW1wcm92ZSBDRyBwZXJmb3JtYW5jZQorCisgICAgdm9pZCog YnVmZmVyID0gY2FsbG9jKHBpeGVsc0hpZ2gsIHJvd0J5dGVzKTsKKyAgICBpZiAoIWJ1ZmZlcikK KyAgICAgICAgcmV0dXJuIDA7CisgICAgCisgICAgUmV0YWluUHRyPENHQ29sb3JTcGFjZVJlZj4g Y29sb3JTcGFjZShBZG9wdENGLCBDR0NvbG9yU3BhY2VDcmVhdGVEZXZpY2VSR0IoKSk7CisgICAg Q0dDb250ZXh0UmVmIGNvbnRleHQgPSBDR0JpdG1hcENvbnRleHRDcmVhdGUoYnVmZmVyLCBwaXhl bHNXaWRlLCBwaXhlbHNIaWdoLCA4LCByb3dCeXRlcywgY29sb3JTcGFjZS5nZXQoKSwga0NHSW1h Z2VBbHBoYVByZW11bHRpcGxpZWRMYXN0IHwga0NHQml0bWFwQnl0ZU9yZGVyMzJCaWcpOworICAg IGlmICghY29udGV4dCkgeworICAgICAgICBmcmVlKGJ1ZmZlcik7CisgICAgICAgIHJldHVybiAw OworICAgIH0KIAotICAgIGlmIChob3Jpem9udGFsKSB7Ci0gICAgICAgIGZvciAoTlNSZWN0IGNv bHVtbiA9IE5TTWFrZVJlY3QoMCwgMCwgMSwgd2ViVmlld1NpemUuaGVpZ2h0KTsgY29sdW1uLm9y aWdpbi54IDwgd2ViVmlld1NpemUud2lkdGg7IGNvbHVtbi5vcmlnaW4ueCsrKQotICAgICAgICAg ICAgW3ZpZXcgZGlzcGxheVJlY3RJZ25vcmluZ09wYWNpdHk6Y29sdW1uIGluQ29udGV4dDpuc0Nv bnRleHRdOworICAgIC8vIFRoZSBCaXRtYXBDb250ZXh0IGtlZXBzIHRoZSBDR0NvbnRleHRSZWYg YW5kIHRoZSBwaXhlbCBidWZmZXIgYWxpdmUKKyAgICBSZWZQdHI8Qml0bWFwQ29udGV4dD4gYml0 bWFwQ29udGV4dCA9IEJpdG1hcENvbnRleHQ6OmNyZWF0ZShidWZmZXIsIGNvbnRleHQpOworICAg IAorICAgIE5TR3JhcGhpY3NDb250ZXh0ICpuc0NvbnRleHQgPSBbTlNHcmFwaGljc0NvbnRleHQg Z3JhcGhpY3NDb250ZXh0V2l0aEdyYXBoaWNzUG9ydDpjb250ZXh0IGZsaXBwZWQ6Tk9dOworICAg IEFTU0VSVChuc0NvbnRleHQpOworICAgIAorICAgIGlmIChpbmNyZW1lbnRhbFJlcGFpbnQpIHsK KyAgICAgICAgaWYgKHN3ZWVwSG9yaXpvbnRhbGx5KSB7CisgICAgICAgICAgICBmb3IgKE5TUmVj dCBjb2x1bW4gPSBOU01ha2VSZWN0KDAsIDAsIDEsIHdlYlZpZXdTaXplLmhlaWdodCk7IGNvbHVt bi5vcmlnaW4ueCA8IHdlYlZpZXdTaXplLndpZHRoOyBjb2x1bW4ub3JpZ2luLngrKykKKyAgICAg ICAgICAgICAgICBbdmlldyBkaXNwbGF5UmVjdElnbm9yaW5nT3BhY2l0eTpjb2x1bW4gaW5Db250 ZXh0Om5zQ29udGV4dF07CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICBmb3IgKE5TUmVj dCBsaW5lID0gTlNNYWtlUmVjdCgwLCAwLCB3ZWJWaWV3U2l6ZS53aWR0aCwgMSk7IGxpbmUub3Jp Z2luLnkgPCB3ZWJWaWV3U2l6ZS5oZWlnaHQ7IGxpbmUub3JpZ2luLnkrKykKKyAgICAgICAgICAg ICAgICBbdmlldyBkaXNwbGF5UmVjdElnbm9yaW5nT3BhY2l0eTpsaW5lIGluQ29udGV4dDpuc0Nv bnRleHRdOworICAgICAgICB9CiAgICAgfSBlbHNlIHsKLSAgICAgICAgZm9yIChOU1JlY3QgbGlu ZSA9IE5TTWFrZVJlY3QoMCwgMCwgd2ViVmlld1NpemUud2lkdGgsIDEpOyBsaW5lLm9yaWdpbi55 IDwgd2ViVmlld1NpemUuaGVpZ2h0OyBsaW5lLm9yaWdpbi55KyspCi0gICAgICAgICAgICBbdmll dyBkaXNwbGF5UmVjdElnbm9yaW5nT3BhY2l0eTpsaW5lIGluQ29udGV4dDpuc0NvbnRleHRdOwor ICAgICAgICAvLyBGSVhNRTogVGhpcyBwYXRoIGlzIHN1Ym9wdGltYWw6IGRhdGEgaXMgcmVhZCBm cm9tIHdpbmRvdyBiYWNraW5nIHN0b3JlLCBjb252ZXJ0ZWQgdG8gUkdCOCB0aGVuIGRyYXduIGFn YWluIGludG8gYW4gUkdCQTggYml0bWFwCisgICAgICAgIFt2aWV3IGRpc3BsYXlJZk5lZWRlZF07 CisgICAgICAgIFt2aWV3IGxvY2tGb2N1c107CisgICAgICAgIE5TQml0bWFwSW1hZ2VSZXAgKmlt YWdlUmVwID0gW1tbTlNCaXRtYXBJbWFnZVJlcCBhbGxvY10gaW5pdFdpdGhGb2N1c2VkVmlld1Jl Y3Q6W3ZpZXcgZnJhbWVdXSBhdXRvcmVsZWFzZV07CisgICAgICAgIFt2aWV3IHVubG9ja0ZvY3Vz XTsKKworICAgICAgICBSZXRhaW5QdHI8TlNHcmFwaGljc0NvbnRleHQ+IHNhdmVkQ29udGV4dCA9 IFtOU0dyYXBoaWNzQ29udGV4dCBjdXJyZW50Q29udGV4dF07CisgICAgICAgIFtOU0dyYXBoaWNz Q29udGV4dCBzZXRDdXJyZW50Q29udGV4dDpuc0NvbnRleHRdOworICAgICAgICBbaW1hZ2VSZXAg ZHJhd107CisgICAgICAgIFtOU0dyYXBoaWNzQ29udGV4dCBzZXRDdXJyZW50Q29udGV4dDpzYXZl ZENvbnRleHQuZ2V0KCldOwogICAgIH0KIAotICAgIFtOU0dyYXBoaWNzQ29udGV4dCBzZXRDdXJy ZW50Q29udGV4dDpzYXZlZENvbnRleHQuZ2V0KCldOwotfQotCi1DR1JlY3QgZ2V0U2VsZWN0aW9u UmVjdCgpCi17Ci0gICAgTlNWaWV3ICpkb2N1bWVudFZpZXcgPSBbW21haW5GcmFtZSBmcmFtZVZp ZXddIGRvY3VtZW50Vmlld107Ci0gICAgaWYgKFtkb2N1bWVudFZpZXcgY29uZm9ybXNUb1Byb3Rv Y29sOkBwcm90b2NvbChXZWJEb2N1bWVudFNlbGVjdGlvbildKSB7Ci0gICAgICAgIE5TUmVjdCBy ZWN0ID0gW2RvY3VtZW50VmlldyBjb252ZXJ0UmVjdDpbKGlkIDxXZWJEb2N1bWVudFNlbGVjdGlv bj4pZG9jdW1lbnRWaWV3IHNlbGVjdGlvblJlY3RdIGZyb21WaWV3Om5pbF07Ci0gICAgICAgIHJl dHVybiBDR1JlY3RNYWtlKHJlY3Qub3JpZ2luLngsIHJlY3Qub3JpZ2luLnksIHJlY3Quc2l6ZS53 aWR0aCwgcmVjdC5zaXplLmhlaWdodCk7CisgICAgaWYgKGRyYXdTZWxlY3Rpb25SZWN0KSB7Cisg ICAgICAgIE5TVmlldyAqZG9jdW1lbnRWaWV3ID0gW1ttYWluRnJhbWUgZnJhbWVWaWV3XSBkb2N1 bWVudFZpZXddOworICAgICAgICBpZiAoW2RvY3VtZW50VmlldyBjb25mb3Jtc1RvUHJvdG9jb2w6 QHByb3RvY29sKFdlYkRvY3VtZW50U2VsZWN0aW9uKV0pIHsKKyAgICAgICAgICAgIE5TUmVjdCBy ZWN0ID0gW2RvY3VtZW50VmlldyBjb252ZXJ0UmVjdDpbKGlkIDxXZWJEb2N1bWVudFNlbGVjdGlv bj4pZG9jdW1lbnRWaWV3IHNlbGVjdGlvblJlY3RdIGZyb21WaWV3Om5pbF07CisgICAgICAgICAg ICAKKyAgICAgICAgICAgIENHQ29udGV4dFNhdmVHU3RhdGUoY29udGV4dCk7CisgICAgICAgICAg ICBDR0NvbnRleHRTZXRMaW5lV2lkdGgoY29udGV4dCwgMS4wKTsKKyAgICAgICAgICAgIENHQ29u dGV4dFNldFJHQlN0cm9rZUNvbG9yKGNvbnRleHQsIDEuMCwgMC4wLCAwLjAsIDEuMCk7CisgICAg ICAgICAgICBDR0NvbnRleHRTdHJva2VSZWN0KGNvbnRleHQsIENHUmVjdE1ha2UocmVjdC5vcmln aW4ueCwgcmVjdC5vcmlnaW4ueSwgcmVjdC5zaXplLndpZHRoLCByZWN0LnNpemUuaGVpZ2h0KSk7 CisgICAgICAgICAgICBDR0NvbnRleHRSZXN0b3JlR1N0YXRlKGNvbnRleHQpOworICAgICAgICB9 CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwogICAgIH0K LQotICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwotICAgIHJldHVybiBDR1JlY3RaZXJvOworICAg IAorICAgIHJldHVybiBiaXRtYXBDb250ZXh0LnJlbGVhc2UoKTsKIH0KZGlmZiAtLWdpdCBhL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAgYi9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCmluZGV4IDkzZGIxZDku Ljc2ZjE2ODcgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1w UmVuZGVyVHJlZS5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBS ZW5kZXJUcmVlLmNwcApAQCAtNzYsNyArNzYsNyBAQCBzdGF0aWMgYm9vbCBsZWFrQ2hlY2tpbmcg PSBmYWxzZTsKIHN0YXRpYyBib29sIHRocmVhZGVkID0gZmFsc2U7CiBzdGF0aWMgUmV0YWluUHRy PENGU3RyaW5nUmVmPiBwZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbjsKIAotc3RhdGlj IGNvbnN0IGNoYXIqIGN1cnJlbnRUZXN0Oworc3RhdGljIHN0ZDo6c3RyaW5nIGdDdXJyZW50VGVz dDsKIAogdm9sYXRpbGUgYm9vbCBkb25lOwogLy8gVGhpcyBpcyB0aGUgdG9wbW9zdCBmcmFtZSB0 aGF0IGlzIGxvYWRpbmcsIGR1cmluZyBhIGdpdmVuIGxvYWQsIG9yIG5pbCB3aGVuIG5vIGxvYWQg aXMgCkBAIC01NjAsNyArNTYwLDcgQEAgdm9pZCBkdW1wKCkKICAgICAgICAgICAgIHdzdHJpbmcg cmVzdWx0ID0gZHVtcEZyYW1lc0FzVGV4dChmcmFtZSk7CiAgICAgICAgICAgICByZXN1bHRTdHJp bmcgPSBTeXNBbGxvY1N0cmluZ0xlbihyZXN1bHQuZGF0YSgpLCByZXN1bHQuc2l6ZSgpKTsKICAg ICAgICAgfSBlbHNlIHsKLSAgICAgICAgICAgIGJvb2wgaXNTVkdXM0NUZXN0ID0gc3Ryc3RyKGN1 cnJlbnRUZXN0LCAic3ZnXFxXM0MtU1ZHLTEuMSIpOworICAgICAgICAgICAgYm9vbCBpc1NWR1cz Q1Rlc3QgPSAoZ0N1cnJlbnRUZXN0LmZpbmQoInN2Z1xcVzNDLVNWRy0xLjEiKSAhPSBzdHJpbmc6 Om5wb3MpOwogICAgICAgICAgICAgdW5zaWduZWQgd2lkdGg7CiAgICAgICAgICAgICB1bnNpZ25l ZCBoZWlnaHQ7CiAgICAgICAgICAgICBpZiAoaXNTVkdXM0NUZXN0KSB7CkBAIC02MDgsNyArNjA4 LDcgQEAgdm9pZCBkdW1wKCkKICAgICAgICAgaWYgKGdMYXlvdXRUZXN0Q29udHJvbGxlci0+ZHVt cEFzVGV4dCgpIHx8IGdMYXlvdXRUZXN0Q29udHJvbGxlci0+ZHVtcERPTUFzV2ViQXJjaGl2ZSgp IHx8IGdMYXlvdXRUZXN0Q29udHJvbGxlci0+ZHVtcFNvdXJjZUFzV2ViQXJjaGl2ZSgpKQogICAg ICAgICAgICAgcHJpbnRmKCIjRU9GXG4iKTsKICAgICAgICAgZWxzZQotICAgICAgICAgICAgZHVt cFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0ZWQoY3VycmVudFRlc3QsIGR1bXBB bGxQaXhlbHMpOworICAgICAgICAgICAgZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRo RXhwZWN0ZWQoZ0xheW91dFRlc3RDb250cm9sbGVyLT5leHBlY3RlZFBpeGVsSGFzaCgpKTsKICAg ICAgICAgZmZsdXNoKHN0ZG91dCk7CiAgICAgfQogCkBAIC02OTQsNyArNjk0LDcgQEAgc3RhdGlj IHZvaWQgcnVuVGVzdChjb25zdCBjaGFyKiBwYXRoT3JVUkwpCiAKICAgICBDRlJlbGVhc2UodXJs KTsKIAotICAgIGN1cnJlbnRUZXN0ID0gcGF0aE9yVVJMOworICAgIGdDdXJyZW50VGVzdCA9IHBh dGhPclVSTDsKIAogICAgIDo6Z0xheW91dFRlc3RDb250cm9sbGVyID0gbmV3IExheW91dFRlc3RD b250cm9sbGVyKGZhbHNlLCBmYWxzZSk7CiAgICAgZG9uZSA9IGZhbHNlOwpkaWZmIC0tZ2l0IGEv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL1BpeGVsRHVtcFN1cHBvcnRXaW4uY3BwIGIv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL1BpeGVsRHVtcFN1cHBvcnRXaW4uY3BwCmlu ZGV4IGY2ZGQ4MmQuLjZjNzE5MWUgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL3dpbi9QaXhlbER1bXBTdXBwb3J0V2luLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS93aW4vUGl4ZWxEdW1wU3VwcG9ydFdpbi5jcHAKQEAgLTMzLDcgKzMzLDcgQEAKICNp bmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgogI2luY2x1ZGUgPHd0Zi9SZXRhaW5QdHIuaD4KIAot UmV0YWluUHRyPENHQ29udGV4dFJlZj4gZ2V0Qml0bWFwQ29udGV4dEZyb21XZWJWaWV3KCkKK1Bh c3NSZWZQdHI8Qml0bWFwQ29udGV4dD4gZ2V0Qml0bWFwQ29udGV4dEZyb21XZWJWaWV3KGJvb2wg aW5jcmVtZW50YWxSZXBhaW50LCBib29sIHN3ZWVwSG9yaXpvbnRhbGx5LCBib29sIGRyYXdTZWxl Y3Rpb25SZWN0KQogewogICAgIFJFQ1QgZnJhbWU7CiAgICAgaWYgKCFHZXRXaW5kb3dSZWN0KHdl YlZpZXdXaW5kb3csICZmcmFtZSkpCkBAIC00Nyw4ICs0Nyw2IEBAIFJldGFpblB0cjxDR0NvbnRl eHRSZWY+IGdldEJpdG1hcENvbnRleHRGcm9tV2ViVmlldygpCiAgICAgYm1wLmJtaUhlYWRlci5i aUJpdENvdW50ID0gMzI7CiAgICAgYm1wLmJtaUhlYWRlci5iaUNvbXByZXNzaW9uID0gQklfUkdC OwogCi0gICAgLy8gRklYTUU6IEN1cnJlbnRseSB3ZSBsZWFrIHRoaXMgSEJJVE1BUCBiZWNhdXNl IHdlIGRvbid0IGhhdmUgYSBnb29kIHdheQotICAgIC8vIHRvIGRlc3Ryb3kgaXQgd2hlbiB0aGUg Q0dCaXRtYXBDb250ZXh0IGdldHMgZGVzdHJveWVkLgogICAgIHZvaWQqIGJpdHMgPSAwOwogICAg IEhCSVRNQVAgYml0bWFwID0gQ3JlYXRlRElCU2VjdGlvbigwLCAmYm1wLCBESUJfUkdCX0NPTE9S UywgJmJpdHMsIDAsIDApOwogCkBAIC02Miw2ICs2MCw4IEBAIFJldGFpblB0cjxDR0NvbnRleHRS ZWY+IGdldEJpdG1hcENvbnRleHRGcm9tV2ViVmlldygpCiAgICAgQVNTRVJUKGluZm8uYm1CaXRz UGl4ZWwgPT0gMzIpOwogCiAgICAgUmV0YWluUHRyPENHQ29sb3JTcGFjZVJlZj4gY29sb3JTcGFj ZShBZG9wdENGLCBDR0NvbG9yU3BhY2VDcmVhdGVEZXZpY2VSR0IoKSk7Ci0gICAgcmV0dXJuIFJl dGFpblB0cjxDR0NvbnRleHRSZWY+KEFkb3B0Q0YsIENHQml0bWFwQ29udGV4dENyZWF0ZShpbmZv LmJtQml0cywgaW5mby5ibVdpZHRoLCBpbmZvLmJtSGVpZ2h0LCA4LAotICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW5mby5ibVdpZHRoQnl0ZXMsIGNvbG9y U3BhY2UuZ2V0KCksIGtDR0JpdG1hcEJ5dGVPcmRlcjMyTGl0dGxlIHwga0NHSW1hZ2VBbHBoYVBy ZW11bHRpcGxpZWRGaXJzdCkpOworICAgIENHQ29udGV4dFJlZiBjb250ZXh0ID0gQ0dCaXRtYXBD b250ZXh0Q3JlYXRlKGluZm8uYm1CaXRzLCBpbmZvLmJtV2lkdGgsIGluZm8uYm1IZWlnaHQsIDgs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbmZvLmJt V2lkdGhCeXRlcywgY29sb3JTcGFjZS5nZXQoKSwga0NHQml0bWFwQnl0ZU9yZGVyMzJMaXR0bGUg fCBrQ0dJbWFnZUFscGhhUHJlbXVsdGlwbGllZEZpcnN0KTsKKworICAgIHJldHVybiBCaXRtYXBD b250ZXh0OjpjcmVhdGUoYml0bWFwLCBjb250ZXh0KTsKIH0KZGlmZiAtLWdpdCBhL1dlYktpdFRv b2xzL1NjcmlwdHMvcnVuLXdlYmtpdC10ZXN0cyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvcnVuLXdl YmtpdC10ZXN0cwppbmRleCBmYjZlOWQ5Li41ZjQyOGNkIDEwMDc1NQotLS0gYS9XZWJLaXRUb29s cy9TY3JpcHRzL3J1bi13ZWJraXQtdGVzdHMKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy9ydW4t d2Via2l0LXRlc3RzCkBAIC01NTMsNyArNTUzLDIyIEBAIGZvciBteSAkdGVzdCAoQHRlc3RzKSB7 CiAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAkdGVzdFBhdGggPSBjYW5vbnBhdGgoJHRl c3RQYXRoKTsKICAgICAgICAgfQotICAgICAgICBwcmludCBPVVQgIiR0ZXN0UGF0aFxuIjsKKyAg ICAgICAgCisgICAgICAgIGlmICgkcGl4ZWxUZXN0cyAmJiAhJHJlc2V0UmVzdWx0cykgeworICAg ICAgICAgICAgbXkgJGV4cGVjdGVkUGl4ZWxEaXIgPSBleHBlY3RlZERpcmVjdG9yeUZvclRlc3Qo JGJhc2UsIDAsICJwbmciKTsKKyAgICAgICAgICAgICMgVHJ5IHRvIHJlYWQgZXhwZWN0ZWQgaGFz aCBmaWxlCisgICAgICAgICAgICBpZiAob3BlbiBFWFBFQ1RFREhBU0gsICIkZXhwZWN0ZWRQaXhl bERpci8kYmFzZS0kZXhwZWN0ZWRUYWcuY2hlY2tzdW0iKSB7CisgICAgICAgICAgICAgICAgbXkg JGV4cGVjdGVkSGFzaCA9IDxFWFBFQ1RFREhBU0g+OworICAgICAgICAgICAgICAgIGNob21wKCRl eHBlY3RlZEhhc2gpOworICAgICAgICAgICAgICAgIGNsb3NlIEVYUEVDVEVESEFTSDsKKyAgICAg ICAgICAgICAgICAjIFNlbmQgInRlc3QnaGFzaCIgdG8gdGhlIHRvb2wKKyAgICAgICAgICAgICAg ICBwcmludCBPVVQgIiR0ZXN0UGF0aCckZXhwZWN0ZWRIYXNoXG4iOworICAgICAgICAgICAgfSBl bHNlIHsKKyAgICAgICAgICAgICAgICBwcmludCBPVVQgIiR0ZXN0UGF0aFxuIjsKKyAgICAgICAg ICAgIH0KKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIHByaW50IE9VVCAiJHRlc3RQYXRo XG4iOworICAgICAgICB9CiAgICAgfSBlbHNlIHsKICAgICAgICAgb3BlbkhUVFBESWZOZWVkZWQo KTsKICAgICAgICAgaWYgKCR0ZXN0ICF+IC9eaHR0cFwvdGVzdHNcL2xvY2FsXC8vICYmICR0ZXN0 ICF+IC9eaHR0cFwvdGVzdHNcL3NzbFwvLyAmJiAkdGVzdCAhfiAvXmh0dHBcL3Rlc3RzXC9tZWRp YVwvLykgewpAQCAtNjQxLDcgKzY1Niw3IEBAIGZvciBteSAkdGVzdCAoQHRlc3RzKSB7CiAgICAg ICAgICAgICBsYXN0IGlmIC8jRU9GLzsKICAgICAgICAgICAgIGlmICgvQWN0dWFsSGFzaDogKFth LWYwLTldezMyfSkvKSB7CiAgICAgICAgICAgICAgICAgJGFjdHVhbEhhc2ggPSAkMTsKLSAgICAg ICAgICAgIH0gZWxzaWYgKC9CYXNlbGluZUhhc2g6IChbYS1mMC05XXszMn0pLykgeworICAgICAg ICAgICAgfSBlbHNpZiAoL0V4cGVjdGVkSGFzaDogKFthLWYwLTldezMyfSkvKSB7CiAgICAgICAg ICAgICAgICAgJGV4cGVjdGVkSGFzaCA9ICQxOwogICAgICAgICAgICAgfSBlbHNpZiAoL0NvbnRl bnQtTGVuZ3RoOiAoXGQrKVxzKi8pIHsKICAgICAgICAgICAgICAgICAkYWN0dWFsUE5HU2l6ZSA9 ICQxOwo= 24588 2008-10-22 21:06:24 -0700 2008-10-23 19:33:18 -0700 Complete patch v1 patch.txt text/plain 75267 pol ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0R1bXBSZW5kZXJUcmVlLnhj b2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9EdW1w UmVuZGVyVHJlZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDM0ODA2OWMuLmJmYzc1 MDAgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0R1bXBSZW5kZXJUcmVl Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvRHVtcFJlbmRlclRyZWUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMzMsNiArMzMs NyBAQAogCQkxQUM2Qzg0OTBEMDc2Mzg2MDBDRDMxNjEgLyogbWFpbi5jcHAgaW4gU291cmNlcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAxQUM2Qzc3RjBEMDc1ODlCMDBDRDMx NjEgLyogbWFpbi5jcHAgKi87IH07CiAJCTFBQzZDODRBMEQwNzYzODYwMENEMzE2MSAvKiBQbHVn aW5PYmplY3QuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gMUFDNkM3ODAwRDA3NTg5QjAwQ0QzMTYxIC8qIFBsdWdpbk9iamVjdC5jcHAgKi87IH07CiAJ CTFBQzZDODRCMEQwNzYzODYwMENEMzE2MSAvKiBUZXN0T2JqZWN0LmNwcCBpbiBTb3VyY2VzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDFBQzZDNzgxMEQwNzU4OUIwMENEMzE2 MSAvKiBUZXN0T2JqZWN0LmNwcCAqLzsgfTsKKwkJMjNCQ0I4OTAwRUE1NzYyMzAwM0M2Mjg5IC8q IE9wZW5HTC5mcmFtZXdvcmsgaW4gRnJhbWV3b3JrcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSAyM0JDQjg4RjBFQTU3NjIzMDAzQzYyODkgLyogT3BlbkdMLmZyYW1ld29yayAq LzsgfTsKIAkJOTM0MDk5NEMwODU0MENBRTAwN0YzQkM4IC8qIER1bXBSZW5kZXJUcmVlUHJlZml4 LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAzMkE3MEFB QjAzNzA1RTFGMDBDOTE3ODMgLyogRHVtcFJlbmRlclRyZWVQcmVmaXguaCAqLzsgfTsKIAkJOTM0 MDk5NTEwODU0MENBRTAwN0YzQkM4IC8qIFdlYktpdC5mcmFtZXdvcmsgaW4gRnJhbWV3b3JrcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzM1NDM1RjAzRDc1NTAyMDA4NjM1 Q0UgLyogV2ViS2l0LmZyYW1ld29yayAqLzsgfTsKIAkJQTgxNzA5MDAwOEIxNjNFRjAwQ0NCOUZC IC8qIENvY29hLmZyYW1ld29yayBpbiBGcmFtZXdvcmtzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IEE4NEY2MDg5MDhCMTM2REEwMEU5NzQ1RiAvKiBDb2NvYS5mcmFtZXdvcmsg Ki87IH07CkBAIC0xMzEsNiArMTMyLDcgQEAKIAkJMUFDNkM3N0YwRDA3NTg5QjAwQ0QzMTYxIC8q IG1haW4uY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gbWFpbi5jcHA7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTFBQzZDNzgwMEQwNzU4OUIwMENEMzE2MSAv KiBQbHVnaW5PYmplY3QuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0g UGx1Z2luT2JqZWN0LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMUFDNkM3ODEw RDA3NTg5QjAwQ0QzMTYxIC8qIFRlc3RPYmplY3QuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBwYXRoID0gVGVzdE9iamVjdC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCTIzQkNCODhGMEVBNTc2MjMwMDNDNjI4OSAvKiBPcGVuR0wuZnJhbWV3b3JrICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gd3JhcHBlci5mcmFtZXdv cms7IG5hbWUgPSBPcGVuR0wuZnJhbWV3b3JrOyBwYXRoID0gL1N5c3RlbS9MaWJyYXJ5L0ZyYW1l d29ya3MvT3BlbkdMLmZyYW1ld29yazsgc291cmNlVHJlZSA9ICI8YWJzb2x1dGU+IjsgfTsKIAkJ MzJBNzBBQUIwMzcwNUUxRjAwQzkxNzgzIC8qIER1bXBSZW5kZXJUcmVlUHJlZml4LmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IER1bXBSZW5kZXJUcmVlUHJlZml4Lmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTM3NUYwOTcxMERBQzNDQjYwMEM4QjRFNSAvKiBXZWJL aXRXZWlnaHRXYXRjaGVyMTAwLnR0ZiAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0 S25vd25GaWxlVHlwZSA9IGZpbGU7IG5hbWUgPSBXZWJLaXRXZWlnaHRXYXRjaGVyMTAwLnR0Zjsg cGF0aCA9IGZvbnRzL1dlYktpdFdlaWdodFdhdGNoZXIxMDAudHRmOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQkzNzVGMDk3MjBEQUMzQ0I2MDBDOEI0RTUgLyogV2ViS2l0V2VpZ2h0V2F0 Y2hlcjIwMC50dGYgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5 cGUgPSBmaWxlOyBuYW1lID0gV2ViS2l0V2VpZ2h0V2F0Y2hlcjIwMC50dGY7IHBhdGggPSBmb250 cy9XZWJLaXRXZWlnaHRXYXRjaGVyMjAwLnR0Zjsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK QEAgLTIzNCw2ICsyMzYsNyBAQAogCQkJCUE4NEY2MDhBMDhCMTM2REEwMEU5NzQ1RiAvKiBDb2Nv YS5mcmFtZXdvcmsgaW4gRnJhbWV3b3JrcyAqLywKIAkJCQlBODE3MDkwNDA4QjE2NEQzMDBDQ0I5 RkIgLyogSmF2YVNjcmlwdENvcmUuZnJhbWV3b3JrIGluIEZyYW1ld29ya3MgKi8sCiAJCQkJOTM0 MDk5NTEwODU0MENBRTAwN0YzQkM4IC8qIFdlYktpdC5mcmFtZXdvcmsgaW4gRnJhbWV3b3JrcyAq LywKKwkJCQkyM0JDQjg5MDBFQTU3NjIzMDAzQzYyODkgLyogT3BlbkdMLmZyYW1ld29yayBpbiBG cmFtZXdvcmtzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3Np bmcgPSAwOwogCQl9OwpAQCAtMzc1LDYgKzM3OCw3IEBACiAJCQkJQTgxNzA5MDMwOEIxNjREMzAw Q0NCOUZCIC8qIEphdmFTY3JpcHRDb3JlLmZyYW1ld29yayAqLywKIAkJCQlCNUE3NTJBMTA4QUY1 RDFGMDAxMzhFNDUgLyogUXVhcnR6Q29yZS5mcmFtZXdvcmsgKi8sCiAJCQkJOTMzNTQzNUYwM0Q3 NTUwMjAwODYzNUNFIC8qIFdlYktpdC5mcmFtZXdvcmsgKi8sCisJCQkJMjNCQ0I4OEYwRUE1NzYy MzAwM0M2Mjg5IC8qIE9wZW5HTC5mcmFtZXdvcmsgKi8sCiAJCQkpOwogCQkJbmFtZSA9IEZyYW1l d29ya3M7CiAJCQlzb3VyY2VUcmVlID0gIjxncm91cD4iOwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1Bhc3NSZWZQdHIuaCBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0ZvcndhcmRpbmdIZWFkZXJzL3d0Zi9QYXNzUmVmUHRy LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYWFmZDFhMgotLS0gL2Rldi9u dWxsCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0ZvcndhcmRpbmdIZWFkZXJzL3d0 Zi9QYXNzUmVmUHRyLmgKQEAgLTAsMCArMSBAQAorI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL1Bh c3NSZWZQdHIuaD4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0Zvcndh cmRpbmdIZWFkZXJzL3d0Zi9SZWZQdHIuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0Zv cndhcmRpbmdIZWFkZXJzL3d0Zi9SZWZQdHIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwLi4wZmY2MjEzCi0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1JlZlB0ci5oCkBAIC0wLDAgKzEgQEAKKyNpbmNs dWRlIDxKYXZhU2NyaXB0Q29yZS9SZWZQdHIuaD4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAppbmRleCA2YzZhMjczLi5hYTcxN2Y0 IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJv bGxlci5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRy b2xsZXIuY3BwCkBAIC0zNCw3ICszNCw3IEBACiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4K ICNpbmNsdWRlIDx3dGYvTWF0aEV4dHJhcy5oPgogCi1MYXlvdXRUZXN0Q29udHJvbGxlcjo6TGF5 b3V0VGVzdENvbnRyb2xsZXIoYm9vbCB0ZXN0UmVwYWludERlZmF1bHQsIGJvb2wgdGVzdFJlcGFp bnRTd2VlcEhvcml6b250YWxseURlZmF1bHQpCitMYXlvdXRUZXN0Q29udHJvbGxlcjo6TGF5b3V0 VGVzdENvbnRyb2xsZXIoY29uc3Qgc3RkOjpzdHJpbmcmIHRlc3RQYXRoT3JVUkwsIGNvbnN0IHN0 ZDo6c3RyaW5nJiBleHBlY3RlZFBpeGVsSGFzaCkKICAgICA6IG1fZHVtcEFzVGV4dChmYWxzZSkK ICAgICAsIG1fZHVtcEFzUERGKGZhbHNlKQogICAgICwgbV9kdW1wQmFja0ZvcndhcmRMaXN0KGZh bHNlKQpAQCAtNTQsMTEgKzU0LDE0IEBAIExheW91dFRlc3RDb250cm9sbGVyOjpMYXlvdXRUZXN0 Q29udHJvbGxlcihib29sIHRlc3RSZXBhaW50RGVmYXVsdCwgYm9vbCB0ZXN0UmVwCiAgICAgLCBt X2Nhbk9wZW5XaW5kb3dzKGZhbHNlKQogICAgICwgbV9jbG9zZVJlbWFpbmluZ1dpbmRvd3NXaGVu Q29tcGxldGUodHJ1ZSkKICAgICAsIG1fc3RvcFByb3Zpc2lvbmFsRnJhbWVMb2FkcyhmYWxzZSkK LSAgICAsIG1fdGVzdFJlcGFpbnQodGVzdFJlcGFpbnREZWZhdWx0KQotICAgICwgbV90ZXN0UmVw YWludFN3ZWVwSG9yaXpvbnRhbGx5KHRlc3RSZXBhaW50U3dlZXBIb3Jpem9udGFsbHlEZWZhdWx0 KQorICAgICwgbV90ZXN0T25zY3JlZW4oZmFsc2UpCisgICAgLCBtX3Rlc3RSZXBhaW50KGZhbHNl KQorICAgICwgbV90ZXN0UmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5KGZhbHNlKQogICAgICwgbV93 YWl0VG9EdW1wKGZhbHNlKQogICAgICwgbV93aW5kb3dJc0tleSh0cnVlKQogICAgICwgbV9nbG9i YWxGbGFnKGZhbHNlKQorICAgICwgbV90ZXN0UGF0aE9yVVJMKHRlc3RQYXRoT3JVUkwpCisgICAg LCBtX2V4cGVjdGVkUGl4ZWxIYXNoKGV4cGVjdGVkUGl4ZWxIYXNoKQogewogfQogCkBAIC0yMDUs NiArMjA4LDEzIEBAIHN0YXRpYyBKU1ZhbHVlUmVmIHNldENsb3NlUmVtYWluaW5nV2luZG93c1do ZW5Db21wbGV0ZUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250CiAgICAgcmV0dXJuIEpTVmFsdWVN YWtlVW5kZWZpbmVkKGNvbnRleHQpOwogfQogCitzdGF0aWMgSlNWYWx1ZVJlZiB0ZXN0T25zY3Jl ZW5DYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpT T2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVl UmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pCit7CisgICAgTGF5b3V0VGVz dENvbnRyb2xsZXIqIGNvbnRyb2xsZXIgPSByZWludGVycHJldF9jYXN0PExheW91dFRlc3RDb250 cm9sbGVyKj4oSlNPYmplY3RHZXRQcml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBjb250cm9sbGVy LT5zZXRUZXN0T25zY3JlZW4odHJ1ZSk7CisgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVk KGNvbnRleHQpOworfQorCiBzdGF0aWMgSlNWYWx1ZVJlZiB0ZXN0UmVwYWludENhbGxiYWNrKEpT Q29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBmdW5jdGlvbiwgSlNPYmplY3RSZWYgdGhp c09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRz W10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKIHsKICAgICBMYXlvdXRUZXN0Q29udHJvbGxlciog Y29udHJvbGxlciA9IHJlaW50ZXJwcmV0X2Nhc3Q8TGF5b3V0VGVzdENvbnRyb2xsZXIqPihKU09i amVjdEdldFByaXZhdGUodGhpc09iamVjdCkpOwpAQCAtNzQ1LDYgKzc1NSw3IEBAIEpTU3RhdGlj RnVuY3Rpb24qIExheW91dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMoKQogICAgICAg ICB7ICJzZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQiLCBzZXRVc2VyU3R5bGVTaGVldEVuYWJsZWRD YWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmli dXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uIiwg c2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbkNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJl YWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInNl dFdpbmRvd0lzS2V5Iiwgc2V0V2luZG93SXNLZXlDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1 dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAorICAgICAgICB7 ICJ0ZXN0T25zY3JlZW4iLCB0ZXN0T25zY3JlZW5DYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1 dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7 ICJ0ZXN0UmVwYWludCIsIHRlc3RSZXBhaW50Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRl UmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAi d2FpdFVudGlsRG9uZSIsIHdhaXRVbnRpbERvbmVDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1 dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7 ICJ3aW5kb3dDb3VudCIsIHdpbmRvd0NvdW50Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRl UmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKZGlmZiAtLWdpdCBh L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmggYi9XZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCmluZGV4IDhlMzNl MDkuLjY0OWRiN2EgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91 dFRlc3RDb250cm9sbGVyLmgKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0 VGVzdENvbnRyb2xsZXIuaApAQCAtMzEsMTAgKzMxLDExIEBACiAKICNpbmNsdWRlIDxKYXZhU2Ny aXB0Q29yZS9KU09iamVjdFJlZi5oPgogI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CisjaW5j bHVkZSA8c3RyaW5nPgogCiBjbGFzcyBMYXlvdXRUZXN0Q29udHJvbGxlciA6IHB1YmxpYyBSZWZD b3VudGVkPExheW91dFRlc3RDb250cm9sbGVyPiB7CiBwdWJsaWM6Ci0gICAgTGF5b3V0VGVzdENv bnRyb2xsZXIoYm9vbCB0ZXN0UmVwYWludERlZmF1bHQsIGJvb2wgdGVzdFJlcGFpbnRTd2VlcEhv cml6b250YWxseURlZmF1bHQpOworICAgIExheW91dFRlc3RDb250cm9sbGVyKGNvbnN0IHN0ZDo6 c3RyaW5nJiB0ZXN0UGF0aE9yVVJMLCBjb25zdCBzdGQ6OnN0cmluZyYgZXhwZWN0ZWRQaXhlbEhh c2gpOwogICAgIH5MYXlvdXRUZXN0Q29udHJvbGxlcigpOwogCiAgICAgdm9pZCBtYWtlV2luZG93 T2JqZWN0KEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiB3aW5kb3dPYmplY3QsIEpT VmFsdWVSZWYqIGV4Y2VwdGlvbik7CkBAIC0xMzAsNiArMTMxLDkgQEAgcHVibGljOgogICAgIGJv b2wgc3RvcFByb3Zpc2lvbmFsRnJhbWVMb2FkcygpIGNvbnN0IHsgcmV0dXJuIG1fc3RvcFByb3Zp c2lvbmFsRnJhbWVMb2FkczsgfQogICAgIHZvaWQgc2V0U3RvcFByb3Zpc2lvbmFsRnJhbWVMb2Fk cyhib29sIHN0b3BQcm92aXNpb25hbEZyYW1lTG9hZHMpIHsgbV9zdG9wUHJvdmlzaW9uYWxGcmFt ZUxvYWRzID0gc3RvcFByb3Zpc2lvbmFsRnJhbWVMb2FkczsgfQogCisgICAgYm9vbCB0ZXN0T25z Y3JlZW4oKSBjb25zdCB7IHJldHVybiBtX3Rlc3RPbnNjcmVlbjsgfQorICAgIHZvaWQgc2V0VGVz dE9uc2NyZWVuKGJvb2wgdGVzdE9uc2NyZWVuKSB7IG1fdGVzdE9uc2NyZWVuID0gdGVzdE9uc2Ny ZWVuOyB9CisKICAgICBib29sIHRlc3RSZXBhaW50KCkgY29uc3QgeyByZXR1cm4gbV90ZXN0UmVw YWludDsgfQogICAgIHZvaWQgc2V0VGVzdFJlcGFpbnQoYm9vbCB0ZXN0UmVwYWludCkgeyBtX3Rl c3RSZXBhaW50ID0gdGVzdFJlcGFpbnQ7IH0KIApAQCAtMTQ0LDcgKzE0OCwxMCBAQCBwdWJsaWM6 CiAKICAgICBib29sIGdsb2JhbEZsYWcoKSBjb25zdCB7IHJldHVybiBtX2dsb2JhbEZsYWc7IH0K ICAgICB2b2lkIHNldEdsb2JhbEZsYWcoYm9vbCBnbG9iYWxGbGFnKSB7IG1fZ2xvYmFsRmxhZyA9 IGdsb2JhbEZsYWc7IH0KLQorICAgIAorICAgIGNvbnN0IHN0ZDo6c3RyaW5nJiB0ZXN0UGF0aE9y VVJMKCkgY29uc3QgeyByZXR1cm4gbV90ZXN0UGF0aE9yVVJMOyB9CisgICAgY29uc3Qgc3RkOjpz dHJpbmcmIGV4cGVjdGVkUGl4ZWxIYXNoKCkgY29uc3QgeyByZXR1cm4gbV9leHBlY3RlZFBpeGVs SGFzaDsgfQorICAgIAogcHJpdmF0ZToKICAgICBib29sIG1fZHVtcEFzVGV4dDsKICAgICBib29s IG1fZHVtcEFzUERGOwpAQCAtMTY1LDYgKzE3Miw3IEBAIHByaXZhdGU6CiAgICAgYm9vbCBtX2Nh bk9wZW5XaW5kb3dzOwogICAgIGJvb2wgbV9jbG9zZVJlbWFpbmluZ1dpbmRvd3NXaGVuQ29tcGxl dGU7CiAgICAgYm9vbCBtX3N0b3BQcm92aXNpb25hbEZyYW1lTG9hZHM7CisgICAgYm9vbCBtX3Rl c3RPbnNjcmVlbjsKICAgICBib29sIG1fdGVzdFJlcGFpbnQ7CiAgICAgYm9vbCBtX3Rlc3RSZXBh aW50U3dlZXBIb3Jpem9udGFsbHk7CiAgICAgYm9vbCBtX3dhaXRUb0R1bXA7IC8vIFRydWUgaWYg d2FpdFVudGlsRG9uZSgpIGhhcyBiZWVuIGNhbGxlZCwgYnV0IG5vdGlmeURvbmUoKSBoYXMgbm90 IHlldCBiZWVuIGNhbGxlZC4KQEAgLTE3Miw2ICsxODAsOSBAQCBwcml2YXRlOgogCiAgICAgYm9v bCBtX2dsb2JhbEZsYWc7CiAKKyAgICBzdGQ6OnN0cmluZyBtX3Rlc3RQYXRoT3JVUkw7CisgICAg c3RkOjpzdHJpbmcgbV9leHBlY3RlZFBpeGVsSGFzaDsgICAgLy8gZW1wdHkgc3RyaW5nIGlmIG5v IGhhc2gKKyAgICAKICAgICBzdGF0aWMgSlNDbGFzc1JlZiBnZXRKU0NsYXNzKCk7CiAgICAgc3Rh dGljIEpTU3RhdGljVmFsdWUqIHN0YXRpY1ZhbHVlcygpOwogICAgIHN0YXRpYyBKU1N0YXRpY0Z1 bmN0aW9uKiBzdGF0aWNGdW5jdGlvbnMoKTsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL1BpeGVsRHVtcFN1cHBvcnQuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L1BpeGVsRHVtcFN1cHBvcnQuaAppbmRleCAzMjE0ZDA0Li5kNGY4OTQ4IDEwMDY0NAotLS0gYS9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9QaXhlbER1bXBTdXBwb3J0LmgKKysrIGIvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvUGl4ZWxEdW1wU3VwcG9ydC5oCkBAIC0yOSwxMiArMjksMTgg QEAKICNpZm5kZWYgUGl4ZWxEdW1wU3VwcG9ydF9oCiAjZGVmaW5lIFBpeGVsRHVtcFN1cHBvcnRf aAogCi12b2lkIGR1bXBXZWJWaWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4cGVjdGVkKGNvbnN0 IGNoYXIqIGN1cnJlbnRUZXN0LCBib29sIGZvcmNlQWxsVGVzdHNUb0R1bXBQaXhlbHMpOworI2lu Y2x1ZGUgPHN0cmluZz4KKwordm9pZCBkdW1wV2ViVmlld0FzUGl4ZWxzQW5kQ29tcGFyZVdpdGhF eHBlY3RlZChjb25zdCBzdGQ6OnN0cmluZyYgZXhwZWN0ZWRIYXNoKTsKKworI2lmIFBMQVRGT1JN KE1BQykKIAogLy8gQ2FuIGJlIHVzZWQgYXMgYSBzaWduYWwgaGFuZGxlcgotdm9pZCByZXN0b3Jl Q29sb3JTcGFjZShpbnQgaWdub3JlZCk7Cit2b2lkIHJlc3RvcmVNYWluRGlzcGxheUNvbG9yUHJv ZmlsZShpbnQgaWdub3JlZCk7CisKKy8vIE1heSBjaGFuZ2UgeW91ciBjb2xvciBzcGFjZSwgcmVx dWlyaW5nIGEgY2FsbCB0byByZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUKK3ZvaWQgc2V0 dXBNYWluRGlzcGxheUNvbG9yUHJvZmlsZSgpOwogCi0vLyBNYXkgY2hhbmdlIHlvdXIgY29sb3Ig c3BhY2UsIHJlcXVpcmluZyBhIGNhbGwgdG8gcmVzdG9yZUNvbG9yU3BhY2UKLXZvaWQgaW5pdGlh bGl6ZUNvbG9yU3BhY2VBbmRTY3JlZUJ1ZmZlckZvclBpeGVsVGVzdHMoKTsKKyNlbmRpZgogCiAj ZW5kaWYgLy8gUGl4ZWxEdW1wU3VwcG9ydF9oCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9jZy9JbWFnZURpZmZDRy5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9jZy9JbWFnZURpZmZDRy5jcHAKaW5kZXggYzM5MzkxMy4uZGY0NDE2OCAxMDA2NDQKLS0tIGEv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvSW1hZ2VEaWZmQ0cuY3BwCisrKyBiL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL2NnL0ltYWdlRGlmZkNHLmNwcApAQCAtNTQsNiArNTQsOCBA QCB0eXBlZGVmIGZsb2F0IENHRmxvYXQ7CiB1c2luZyBuYW1lc3BhY2Ugc3RkOwogCiAjaWYgUExB VEZPUk0oV0lOKQorI2RlZmluZSBzdHJ0b2YoeCwgeSkgc3RydG9kKHgsIHkpCisjZGVmaW5lIHJv dW5kZih4KSAoKHgtZmxvb3JmKHgpKSA+IDAuNSA/IGNlaWxmKHgpIDogZmxvb3JmKHgpKQogc3Rh dGljIGNvbnN0IENGU3RyaW5nUmVmIGtVVFR5cGVQTkcgPSBDRlNUUigicHVibGljLnBuZyIpOwog I2VuZGlmCiAKQEAgLTcyLDk5ICs3NCw5OSBAQCBzdGF0aWMgUmV0YWluUHRyPENHSW1hZ2VSZWY+ IGNyZWF0ZUltYWdlRnJvbVN0ZGluKGludCBieXRlc1JlbWFpbmluZykKICAgICByZXR1cm4gUmV0 YWluUHRyPENHSW1hZ2VSZWY+KEFkb3B0Q0YsIENHSW1hZ2VDcmVhdGVXaXRoUE5HRGF0YVByb3Zp ZGVyKGRhdGFQcm92aWRlci5nZXQoKSwgMCwgZmFsc2UsIGtDR1JlbmRlcmluZ0ludGVudERlZmF1 bHQpKTsKIH0KIAotLy8gR2VuZXJhdGVzIGFuIFJHQkE4IGJpdG1hcCBpbiB0aGUgcmVmZXJlbmNl IGltYWdlIGNvbG9yc3BhY2UgY29udGFpbmluZyB0aGUgZGlmZmVyZW5jZXMgYmV0d2VlbiB0aGUg MiBpbWFnZXMKLXN0YXRpYyBSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPiBjcmVhdGVEaWZmZXJlbmNl Qml0bWFwKENHSW1hZ2VSZWYgdGVzdEltYWdlLCBDR0ltYWdlUmVmIHJlZmVyZW5jZUltYWdlKQor c3RhdGljIHZvaWQgcmVsZWFzZU1hbGxvY0J1ZmZlcih2b2lkKiBpbmZvLCBjb25zdCB2b2lkKiBk YXRhLCBzaXplX3Qgc2l6ZSkKIHsKLSAgICAvLyB3ZSBtdXN0IGhhdmUgYm90aCBpbWFnZXMgdG8g dGFrZSBkaWZmCi0gICAgaWYgKCF0ZXN0SW1hZ2UgfHwgIXJlZmVyZW5jZUltYWdlKSB7Ci0gICAg ICAgIGZwcmludGYoc3RkZXJyLCAidGVzdCBvciByZWZlcmVuY2UgaW1hZ2UgaXMgbWlzc2luZyEi KTsKLSAgICAgICAgcmV0dXJuIDA7Ci0gICAgfQotCi0gICAgLy8gd2UgbXVzdCBoYXZlIGJvdGgg aW1hZ2VzIGJlIHRoZSBzYW1lIGRpbWVuc2lvbnMKLSAgICBpZiAoKENHSW1hZ2VHZXRXaWR0aCh0 ZXN0SW1hZ2UpICE9IENHSW1hZ2VHZXRXaWR0aChyZWZlcmVuY2VJbWFnZSkpIHx8IChDR0ltYWdl R2V0SGVpZ2h0KHRlc3RJbWFnZSkgIT0gQ0dJbWFnZUdldEhlaWdodChyZWZlcmVuY2VJbWFnZSkp KSB7Ci0gICAgICAgIGZwcmludGYoc3RkZXJyLCAidGVzdCBhbmQgcmVmZXJlbmNlIGltYWdlIGRp bWVuc2lvbnMgZG9uJ3QgbWF0Y2ghIik7Ci0gICAgICAgIHJldHVybiAwOwotICAgIH0KLQotICAg IC8vIHdlIG11c3QgaGF2ZSBib3RoIGltYWdlcyBpbiB0aGUgc2FtZSBjb2xvcnNwYWNlCi0gICAg aWYgKCFDRkVxdWFsKENHSW1hZ2VHZXRDb2xvclNwYWNlKHRlc3RJbWFnZSksIENHSW1hZ2VHZXRD b2xvclNwYWNlKHJlZmVyZW5jZUltYWdlKSkpIHsKLSAgICAgICAgZnByaW50ZihzdGRlcnIsICJ0 ZXN0IGFuZCByZWZlcmVuY2UgaW1hZ2UgY29sb3JzcGFjZXMgZG9uJ3QgbWF0Y2ghIik7Ci0gICAg ICAgIHJldHVybiAwOwotICAgIH0KLQotICAgIHN0YXRpYyBDRk11dGFibGVEYXRhUmVmIGRhdGEg PSBDRkRhdGFDcmVhdGVNdXRhYmxlKGtDRkFsbG9jYXRvckRlZmF1bHQsIDApOwotICAgIHNpemVf dCByb3dCeXRlcyA9ICg0ICogQ0dJbWFnZUdldFdpZHRoKHJlZmVyZW5jZUltYWdlKSArIDYzKSAm IH42MzsgLy8gVXNlIGEgbXVsdGlwbGUgb2YgNjQgYnl0ZXMgdG8gaW1wcm92ZSBDRyBwZXJmb3Jt YW5jZQotICAgIENGRGF0YVNldExlbmd0aChkYXRhLCBDR0ltYWdlR2V0SGVpZ2h0KHJlZmVyZW5j ZUltYWdlKSAqIHJvd0J5dGVzKTsKLSAgICBSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPiBjb250ZXh0 KEFkb3B0Q0YsIENHQml0bWFwQ29udGV4dENyZWF0ZShDRkRhdGFHZXRNdXRhYmxlQnl0ZVB0cihk YXRhKSwgQ0dJbWFnZUdldFdpZHRoKHJlZmVyZW5jZUltYWdlKSwgQ0dJbWFnZUdldEhlaWdodChy ZWZlcmVuY2VJbWFnZSksIDgsIHJvd0J5dGVzLCBDR0ltYWdlR2V0Q29sb3JTcGFjZShyZWZlcmVu Y2VJbWFnZSksIGtDR0ltYWdlQWxwaGFQcmVtdWx0aXBsaWVkTGFzdCB8IGtDR0JpdG1hcEJ5dGVP cmRlcjMyQmlnKSk7Ci0KLSAgICBDR0NvbnRleHRTZXRCbGVuZE1vZGUoY29udGV4dC5nZXQoKSwg a0NHQmxlbmRNb2RlTm9ybWFsKTsKLSAgICBDR0NvbnRleHREcmF3SW1hZ2UoY29udGV4dC5nZXQo KSwgQ0dSZWN0TWFrZSgwLCAwLCBzdGF0aWNfY2FzdDxDR0Zsb2F0PihDR0ltYWdlR2V0V2lkdGgo dGVzdEltYWdlKSksIHN0YXRpY19jYXN0PENHRmxvYXQ+KENHSW1hZ2VHZXRIZWlnaHQodGVzdElt YWdlKSkpLCB0ZXN0SW1hZ2UpOwotICAgIENHQ29udGV4dFNldEJsZW5kTW9kZShjb250ZXh0Lmdl dCgpLCBrQ0dCbGVuZE1vZGVEaWZmZXJlbmNlKTsKLSAgICBDR0NvbnRleHREcmF3SW1hZ2UoY29u dGV4dC5nZXQoKSwgQ0dSZWN0TWFrZSgwLCAwLCBzdGF0aWNfY2FzdDxDR0Zsb2F0PihDR0ltYWdl R2V0V2lkdGgocmVmZXJlbmNlSW1hZ2UpKSwgc3RhdGljX2Nhc3Q8Q0dGbG9hdD4oQ0dJbWFnZUdl dEhlaWdodChyZWZlcmVuY2VJbWFnZSkpKSwgcmVmZXJlbmNlSW1hZ2UpOwotCi0gICAgcmV0dXJu IGNvbnRleHQ7CisgICAgZnJlZSgodm9pZCopZGF0YSk7CiB9CiAKLS8vIENvdW50cyB0aGUgbnVt YmVyIG9mIG5vbi1ibGFjayBwaXhlbHMsIGFuZCByZXR1cm5zIHRoZSBwZXJjZW50YWdlIG9mIG5v bi1ibGFjayBwaXhlbHMgdG8gdG90YWwgcGl4ZWxzIGluIHRoZSBpbWFnZS4KLXN0YXRpYyBmbG9h dCBjb21wdXRlUGVyY2VudGFnZURpZmZlcmVudChDR0NvbnRleHRSZWYgZGlmZkJpdG1hcCwgdW5z aWduZWQgdGhyZXNob2xkKQorc3RhdGljIFJldGFpblB0cjxDR0ltYWdlUmVmPiBjb21wYXJlSW1h Z2VzKENHSW1hZ2VSZWYgYmFzZUltYWdlLCBDR0ltYWdlUmVmIHRlc3RJbWFnZSwgZmxvYXQmIGRp ZmZlcmVuY2UpCiB7Ci0gICAgLy8gaWYgZGlmZkJpdG1hcCBpcyBuaWwsIHRoZW4gdGhlcmUgd2Fz IGFuIGVycm9yLCBhbmQgaXQgZGlkbid0IG1hdGNoLgotICAgIGlmICghZGlmZkJpdG1hcCkKLSAg ICAgICAgcmV0dXJuIDEwMC4wZjsKLQotICAgIHNpemVfdCBwaXhlbHNIaWdoID0gQ0dCaXRtYXBD b250ZXh0R2V0SGVpZ2h0KGRpZmZCaXRtYXApOwotICAgIHNpemVfdCBwaXhlbHNXaWRlID0gQ0dC aXRtYXBDb250ZXh0R2V0V2lkdGgoZGlmZkJpdG1hcCk7Ci0gICAgc2l6ZV90IGJ5dGVzUGVyUm93 ID0gQ0dCaXRtYXBDb250ZXh0R2V0Qnl0ZXNQZXJSb3coZGlmZkJpdG1hcCk7Ci0gICAgdW5zaWdu ZWQgY2hhciogcGl4ZWxSb3dEYXRhID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcio+KENHQml0 bWFwQ29udGV4dEdldERhdGEoZGlmZkJpdG1hcCkpOwotICAgIHVuc2lnbmVkIGRpZmZlcmVuY2Vz ID0gMDsKLQotICAgIGZvciAodW5zaWduZWQgcm93ID0gMDsgcm93IDwgcGl4ZWxzSGlnaDsgcm93 KyspIHsKLSAgICAgICAgZm9yICh1bnNpZ25lZCBjb2wgPSAwOyBjb2wgPCAocGl4ZWxzV2lkZSAq IDQpOyBjb2wgKz0gNCkgewotICAgICAgICAgICAgdW5zaWduZWQgY2hhciogcmVkID0gcGl4ZWxS b3dEYXRhICsgY29sOwotICAgICAgICAgICAgdW5zaWduZWQgY2hhciogZ3JlZW4gPSByZWQgKyAx OwotICAgICAgICAgICAgdW5zaWduZWQgY2hhciogYmx1ZSA9IHJlZCArIDI7Ci0gICAgICAgICAg ICB1bnNpZ25lZCBkaXN0YW5jZSA9ICpyZWQgKyAqZ3JlZW4gKyAqYmx1ZTsKLSAgICAgICAgICAg IGlmIChkaXN0YW5jZSA+IHRocmVzaG9sZCkgewotICAgICAgICAgICAgICAgIGRpZmZlcmVuY2Vz Kys7Ci0gICAgICAgICAgICAgICAgLy8gc2hpZnQgdGhlIHBpeGVscyB0b3dhcmRzIHdoaXRlIHRv IG1ha2UgdGhlbSBtb3JlIHZpc2libGUKLSAgICAgICAgICAgICAgICAqcmVkID0gc3RhdGljX2Nh c3Q8dW5zaWduZWQgY2hhcj4obWluKFVDSEFSX01BWCwgKnJlZCArIDEwMCkpOwotICAgICAgICAg ICAgICAgICpncmVlbiA9IHN0YXRpY19jYXN0PHVuc2lnbmVkIGNoYXI+KG1pbihVQ0hBUl9NQVgs ICpncmVlbiArIDEwMCkpOwotICAgICAgICAgICAgICAgICpibHVlID0gc3RhdGljX2Nhc3Q8dW5z aWduZWQgY2hhcj4obWluKFVDSEFSX01BWCwgKmJsdWUgKyAxMDApKTsKKyAgICBSZXRhaW5QdHI8 Q0dDb2xvclNwYWNlUmVmPiBjb2xvclNwYWNlKEFkb3B0Q0YsIENHQ29sb3JTcGFjZUNyZWF0ZURl dmljZVJHQigpKTsKKyAgICBSZXRhaW5QdHI8Q0dJbWFnZVJlZj4gZGlmZkltYWdlOworICAgIAor ICAgIHNpemVfdCB3aWR0aCA9IENHSW1hZ2VHZXRXaWR0aChiYXNlSW1hZ2UpOworICAgIHNpemVf dCBoZWlnaHQgPSBDR0ltYWdlR2V0SGVpZ2h0KGJhc2VJbWFnZSk7CisgICAgc2l6ZV90IHJvd0J5 dGVzID0gd2lkdGggKiA0OworICAgIAorICAgIC8vIERyYXcgYmFzZSBpbWFnZSBpbiBiaXRtYXAg Y29udGV4dAorICAgIHZvaWQgKmJhc2VCdWZmZXIgPSBjYWxsb2MoaGVpZ2h0LCByb3dCeXRlcyk7 CisgICAgQ0dDb250ZXh0UmVmIGJhc2VDb250ZXh0ID0gQ0dCaXRtYXBDb250ZXh0Q3JlYXRlKGJh c2VCdWZmZXIsIHdpZHRoLCBoZWlnaHQsIDgsIHJvd0J5dGVzLCBjb2xvclNwYWNlLmdldCgpLCBr Q0dJbWFnZUFscGhhUHJlbXVsdGlwbGllZEZpcnN0IHwga0NHQml0bWFwQnl0ZU9yZGVyMzJIb3N0 KTsKKyAgICBDR0NvbnRleHREcmF3SW1hZ2UoYmFzZUNvbnRleHQsIENHUmVjdE1ha2UoMCwgMCwg d2lkdGgsIGhlaWdodCksIGJhc2VJbWFnZSk7CisgICAgQ0dDb250ZXh0UmVsZWFzZShiYXNlQ29u dGV4dCk7CisgICAgCisgICAgLy8gRHJhdyB0ZXN0IGltYWdlIGluIGJpdG1hcCBjb250ZXh0Cisg ICAgdm9pZCAqYnVmZmVyID0gY2FsbG9jKGhlaWdodCwgcm93Qnl0ZXMpOworICAgIENHQ29udGV4 dFJlZiBjb250ZXh0ID0gQ0dCaXRtYXBDb250ZXh0Q3JlYXRlKGJ1ZmZlciwgd2lkdGgsIGhlaWdo dCwgOCwgcm93Qnl0ZXMsIGNvbG9yU3BhY2UuZ2V0KCksIGtDR0ltYWdlQWxwaGFQcmVtdWx0aXBs aWVkRmlyc3QgfCBrQ0dCaXRtYXBCeXRlT3JkZXIzMkhvc3QpOworICAgIENHQ29udGV4dERyYXdJ bWFnZShjb250ZXh0LCBDR1JlY3RNYWtlKDAsIDAsIHdpZHRoLCBoZWlnaHQpLCB0ZXN0SW1hZ2Up OworICAgIENHQ29udGV4dFJlbGVhc2UoY29udGV4dCk7CisgICAgCisgICAgLy8gQ29tcGFyZSB0 aGUgY29udGVudCBvZiB0aGUgMiBiaXRtYXBzCisgICAgdm9pZCAqZGlmZkJ1ZmZlciA9IG1hbGxv Yyh3aWR0aCAqIGhlaWdodCk7CisgICAgZmxvYXQgY291bnQgPSAwLjBmOworICAgIGZsb2F0IHN1 bSA9IDAuMGY7CisgICAgZmxvYXQgdG9wID0gMC4wZjsKKyAgICB1bnNpZ25lZCBjaGFyICpiYXNl UGl4ZWwgPSAodW5zaWduZWQgY2hhciopYmFzZUJ1ZmZlcjsKKyAgICB1bnNpZ25lZCBjaGFyICpw aXhlbCA9ICh1bnNpZ25lZCBjaGFyKilidWZmZXI7CisgICAgdW5zaWduZWQgY2hhciAqZGlmZiA9 ICh1bnNpZ25lZCBjaGFyKilkaWZmQnVmZmVyOworICAgIGZvciAoc2l6ZV90IHkgPSAwOyB5IDwg aGVpZ2h0OyArK3kpIHsKKyAgICAgICAgZm9yIChzaXplX3QgeCA9IDA7IHggPCB3aWR0aDsgKyt4 KSB7CisgICAgICAgICAgICBmbG9hdCByZWQgPSAoKGZsb2F0KXBpeGVsWzBdIC0gKGZsb2F0KWJh c2VQaXhlbFswXSkgLyBtYXgoMjU1LjBmIC0gKGZsb2F0KWJhc2VQaXhlbFswXSwgKGZsb2F0KWJh c2VQaXhlbFswXSk7CisgICAgICAgICAgICBmbG9hdCBncmVlbiA9ICgoZmxvYXQpcGl4ZWxbMV0g LSAoZmxvYXQpYmFzZVBpeGVsWzFdKSAvIG1heCgyNTUuMGYgLSAoZmxvYXQpYmFzZVBpeGVsWzFd LCAoZmxvYXQpYmFzZVBpeGVsWzFdKTsKKyAgICAgICAgICAgIGZsb2F0IGJsdWUgPSAoKGZsb2F0 KXBpeGVsWzJdIC0gKGZsb2F0KWJhc2VQaXhlbFsyXSkgLyBtYXgoMjU1LjBmIC0gKGZsb2F0KWJh c2VQaXhlbFsyXSwgKGZsb2F0KWJhc2VQaXhlbFsyXSk7CisgICAgICAgICAgICBmbG9hdCBhbHBo YSA9ICgoZmxvYXQpcGl4ZWxbM10gLSAoZmxvYXQpYmFzZVBpeGVsWzNdKSAvIG1heCgyNTUuMGYg LSAoZmxvYXQpYmFzZVBpeGVsWzNdLCAoZmxvYXQpYmFzZVBpeGVsWzNdKTsKKyAgICAgICAgICAg IGZsb2F0IGRpc3RhbmNlID0gc3FydGYocmVkICogcmVkICsgZ3JlZW4gKiBncmVlbiArIGJsdWUg KiBibHVlICsgYWxwaGEgKiBhbHBoYSkgLyAyLjBmOworICAgICAgICAgICAgCisgICAgICAgICAg ICAqZGlmZisrID0gKHVuc2lnbmVkIGNoYXIpKGRpc3RhbmNlICogMjU1LjBmKTsKKyAgICAgICAg ICAgIAorICAgICAgICAgICAgaWYgKGRpc3RhbmNlID49IDEuMGYgLyAyNTUuMGYpIHsKKyAgICAg ICAgICAgICAgICBjb3VudCArPSAxLjBmOworICAgICAgICAgICAgICAgIHN1bSArPSBkaXN0YW5j ZTsKKyAgICAgICAgICAgICAgICBpZiAoZGlzdGFuY2UgPiB0b3ApCisgICAgICAgICAgICAgICAg ICAgIHRvcCA9IGRpc3RhbmNlOwogICAgICAgICAgICAgfQorICAgICAgICAgICAgCisgICAgICAg ICAgICBiYXNlUGl4ZWwgKz0gNDsKKyAgICAgICAgICAgIHBpeGVsICs9IDQ7CiAgICAgICAgIH0K LSAgICAgICAgcGl4ZWxSb3dEYXRhICs9IGJ5dGVzUGVyUm93OwogICAgIH0KLQotICAgIGZsb2F0 IHRvdGFsUGl4ZWxzID0gc3RhdGljX2Nhc3Q8ZmxvYXQ+KHBpeGVsc0hpZ2ggKiBwaXhlbHNXaWRl KTsKLSAgICByZXR1cm4gKGRpZmZlcmVuY2VzICogMTAwLmYpIC8gdG90YWxQaXhlbHM7CisgICAg CisgICAgLy8gQ29tcHV0ZSB0aGUgZGlmZmVyZW5jZSBhcyBhIHBlcmNlbnRhZ2UgY29tYmluaW5n IGJvdGggdGhlIG51bWJlciBvZiBkaWZmZXJlbnQgcGl4ZWxzIGFuZCB0aGVpciBkaWZmZXJlbmNl IGFtb3VudAorICAgIGlmIChjb3VudCA+IDAuMGYpCisgICAgICAgIGRpZmZlcmVuY2UgPSAxMDAu MGYgKiAoY291bnQgLyAoKGZsb2F0KXdpZHRoICogKGZsb2F0KWhlaWdodCkpICogKHN1bSAvIGNv dW50KTsKKyAgICBlbHNlCisgICAgICAgIGRpZmZlcmVuY2UgPSAwLjBmOworICAgIAorICAgIC8v IEdlbmVyYXRlIGEgbm9ybWFsaXplZCBkaWZmIGltYWdlIGlmIHRoZXJlIGlzIGFueSBkaWZmZXJl bmNlCisgICAgaWYgKGRpZmZlcmVuY2UgPiAwLjBmKSB7CisgICAgICAgIGlmICh0b3AgPCAxLjBm KSB7CisgICAgICAgICAgICBkaWZmID0gKHVuc2lnbmVkIGNoYXIqKWRpZmZCdWZmZXI7CisgICAg ICAgICAgICBmb3Ioc2l6ZV90IHAgPSAwOyBwIDwgaGVpZ2h0ICogd2lkdGg7ICsrcCwgKytkaWZm KQorICAgICAgICAgICAgKmRpZmYgPSAoZmxvYXQpKmRpZmYgLyB0b3A7CisgICAgICAgIH0KKyAg ICAgICAgCisgICAgICAgIENHRGF0YVByb3ZpZGVyUmVmIHByb3ZpZGVyID0gQ0dEYXRhUHJvdmlk ZXJDcmVhdGVXaXRoRGF0YSgwLCBkaWZmQnVmZmVyLCB3aWR0aCAqIGhlaWdodCwgcmVsZWFzZU1h bGxvY0J1ZmZlcik7CisgICAgICAgIENHQ29sb3JTcGFjZVJlZiBkaWZmQ29sb3JzcGFjZSA9IENH Q29sb3JTcGFjZUNyZWF0ZURldmljZUdyYXkoKTsKKyAgICAgICAgZGlmZkltYWdlLmFkb3B0Q0Yo Q0dJbWFnZUNyZWF0ZSh3aWR0aCwgaGVpZ2h0LCA4LCA4LCB3aWR0aCwgZGlmZkNvbG9yc3BhY2Us IDAsIHByb3ZpZGVyLCAwLCBmYWxzZSwga0NHUmVuZGVyaW5nSW50ZW50RGVmYXVsdCkpOworICAg ICAgICBDR0NvbG9yU3BhY2VSZWxlYXNlKGRpZmZDb2xvcnNwYWNlKTsKKyAgICAgICAgQ0dEYXRh UHJvdmlkZXJSZWxlYXNlKHByb3ZpZGVyKTsKKyAgICB9CisgICAgZWxzZQorICAgICAgICBmcmVl KGRpZmZCdWZmZXIpOworICAgIAorICAgIC8vIERlc3Ryb3kgZHJhd2luZyBidWZmZXJzCisgICAg aWYgKGJ1ZmZlcikKKyAgICAgICAgZnJlZShidWZmZXIpOworICAgIGlmIChiYXNlQnVmZmVyKQor ICAgICAgICBmcmVlKGJhc2VCdWZmZXIpOworICAgIAorICAgIHJldHVybiBkaWZmSW1hZ2U7CiB9 CiAKLXN0YXRpYyB2b2lkIGNvbXBhcmVJbWFnZXMoQ0dJbWFnZVJlZiB0ZXN0SW1hZ2UsIENHSW1h Z2VSZWYgcmVmZXJlbmNlSW1hZ2UsIHVuc2lnbmVkIHRocmVzaG9sZCkKK3N0YXRpYyBpbmxpbmUg Ym9vbCBpbWFnZUhhc0FscGhhKENHSW1hZ2VSZWYgaW1hZ2UpCiB7Ci0gICAgLy8gcHJlcGFyZSB0 aGUgZGlmZmVyZW5jZSBibGVuZCB0byBjaGVjayBmb3IgcGl4ZWwgdmFyaWF0aW9ucwotICAgIFJl dGFpblB0cjxDR0NvbnRleHRSZWY+IGRpZmZCaXRtYXAgPSBjcmVhdGVEaWZmZXJlbmNlQml0bWFw KHRlc3RJbWFnZSwgcmVmZXJlbmNlSW1hZ2UpOwotCi0gICAgZmxvYXQgcGVyY2VudGFnZSA9IGNv bXB1dGVQZXJjZW50YWdlRGlmZmVyZW50KGRpZmZCaXRtYXAuZ2V0KCksIHRocmVzaG9sZCk7Ci0K LSAgICBwZXJjZW50YWdlID0gKGZsb2F0KSgoaW50KShwZXJjZW50YWdlICogMTAwLjBmKSkgLyAx MDAuMGY7IC8vIHJvdW5kIHRvIDIgZGVjaW1hbCBwbGFjZXMKLQotICAgIC8vIHNlbmQgbWVzc2Fn ZSB0byBsZXQgdGhlbSBrbm93IGlmIGFuIGltYWdlIHdhcyB3cm9uZwotICAgIGlmIChwZXJjZW50 YWdlID4gMC4wZikgewotICAgICAgICAvLyBzaW5jZSB0aGUgZGlmZiBtaWdodCBhY3R1YWxseSBz aG93IHNvbWV0aGluZywgc2VuZCBpdCB0byBzdGRvdXQKLSAgICAgICAgaWYgKGRpZmZCaXRtYXAp IHsKLSAgICAgICAgICAgIFJldGFpblB0cjxDR0ltYWdlUmVmPiBpbWFnZShBZG9wdENGLCBDR0Jp dG1hcENvbnRleHRDcmVhdGVJbWFnZShkaWZmQml0bWFwLmdldCgpKSk7Ci0gICAgICAgICAgICBS ZXRhaW5QdHI8Q0ZNdXRhYmxlRGF0YVJlZj4gaW1hZ2VEYXRhKEFkb3B0Q0YsIENGRGF0YUNyZWF0 ZU11dGFibGUoMCwgMCkpOwotICAgICAgICAgICAgUmV0YWluUHRyPENHSW1hZ2VEZXN0aW5hdGlv blJlZj4gaW1hZ2VEZXN0KEFkb3B0Q0YsIENHSW1hZ2VEZXN0aW5hdGlvbkNyZWF0ZVdpdGhEYXRh KGltYWdlRGF0YS5nZXQoKSwga1VUVHlwZVBORywgMSwgMCkpOwotICAgICAgICAgICAgQ0dJbWFn ZURlc3RpbmF0aW9uQWRkSW1hZ2UoaW1hZ2VEZXN0LmdldCgpLCBpbWFnZS5nZXQoKSwgMCk7Ci0g ICAgICAgICAgICBDR0ltYWdlRGVzdGluYXRpb25GaW5hbGl6ZShpbWFnZURlc3QuZ2V0KCkpOwot ICAgICAgICAgICAgcHJpbnRmKCJDb250ZW50LUxlbmd0aDogJWx1XG4iLCBDRkRhdGFHZXRMZW5n dGgoaW1hZ2VEYXRhLmdldCgpKSk7Ci0gICAgICAgICAgICBmd3JpdGUoQ0ZEYXRhR2V0Qnl0ZVB0 cihpbWFnZURhdGEuZ2V0KCkpLCAxLCBDRkRhdGFHZXRMZW5ndGgoaW1hZ2VEYXRhLmdldCgpKSwg c3Rkb3V0KTsKLSAgICAgICAgfQotICAgICAgICAKLSAgICAgICAgZnByaW50ZihzdGRvdXQsICJk aWZmOiAlMDEuMmYlJSBmYWlsZWRcbiIsIHBlcmNlbnRhZ2UpOwotICAgIH0gZWxzZQotICAgICAg ICBmcHJpbnRmKHN0ZG91dCwgImRpZmY6ICUwMS4yZiUlIHBhc3NlZFxuIiwgcGVyY2VudGFnZSk7 CisgICAgQ0dJbWFnZUFscGhhSW5mbyAgICAgICAgICAgIGluZm8gPSBDR0ltYWdlR2V0QWxwaGFJ bmZvKGltYWdlKTsKKyAgICAKKyAgICByZXR1cm4gKGluZm8gPj0ga0NHSW1hZ2VBbHBoYVByZW11 bHRpcGxpZWRMYXN0KSAmJiAoaW5mbyA8PSBrQ0dJbWFnZUFscGhhRmlyc3QpOwogfQogCiBpbnQg bWFpbihpbnQgYXJnYywgY29uc3QgY2hhciogYXJndltdKQpAQCAtMTc0LDEzICsxNzYsMTMgQEAg aW50IG1haW4oaW50IGFyZ2MsIGNvbnN0IGNoYXIqIGFyZ3ZbXSkKICAgICBfc2V0bW9kZSgxLCBf T19CSU5BUlkpOwogI2VuZGlmCiAKLSAgICB1bnNpZ25lZCB0aHJlc2hvbGQgPSAwOworICAgIGZs b2F0IHRvbGVyYW5jZSA9IDAuMGY7CiAKICAgICBmb3IgKGludCBpID0gMTsgaSA8IGFyZ2M7ICsr aSkgewotICAgICAgICBpZiAoIXN0cmNtcChhcmd2W2ldLCAiLXQiKSB8fCAhc3RyY21wKGFyZ3Zb aV0sICItLXRocmVzaG9sZCIpKSB7CisgICAgICAgIGlmICghc3RyY21wKGFyZ3ZbaV0sICItdCIp IHx8ICFzdHJjbXAoYXJndltpXSwgIi0tdG9sZXJhbmNlIikpIHsKICAgICAgICAgICAgIGlmIChp ID49IGFyZ2MgLSAxKQogICAgICAgICAgICAgICAgIGV4aXQoMSk7Ci0gICAgICAgICAgICB0aHJl c2hvbGQgPSBzdHJ0b2woYXJndltpICsgMV0sIDAsIDApOworICAgICAgICAgICAgdG9sZXJhbmNl ID0gc3RydG9mKGFyZ3ZbaSArIDFdLCAwKTsKICAgICAgICAgICAgICsraTsKICAgICAgICAgICAg IGNvbnRpbnVlOwogICAgICAgICB9CkBAIC0yMDksNyArMjExLDM2IEBAIGludCBtYWluKGludCBh cmdjLCBjb25zdCBjaGFyKiBhcmd2W10pCiAgICAgICAgIH0KIAogICAgICAgICBpZiAoYWN0dWFs SW1hZ2UgJiYgYmFzZWxpbmVJbWFnZSkgewotICAgICAgICAgICAgY29tcGFyZUltYWdlcyhhY3R1 YWxJbWFnZS5nZXQoKSwgYmFzZWxpbmVJbWFnZS5nZXQoKSwgdGhyZXNob2xkKTsKKyAgICAgICAg ICAgIFJldGFpblB0cjxDR0ltYWdlUmVmPiBkaWZmSW1hZ2U7CisgICAgICAgICAgICBmbG9hdCBk aWZmZXJlbmNlID0gMTAwLjBmOworICAgICAgICAgICAgCisgICAgICAgICAgICBpZiAoKENHSW1h Z2VHZXRXaWR0aChhY3R1YWxJbWFnZS5nZXQoKSkgPT0gQ0dJbWFnZUdldFdpZHRoKGJhc2VsaW5l SW1hZ2UuZ2V0KCkpKSAmJiAoQ0dJbWFnZUdldEhlaWdodChhY3R1YWxJbWFnZS5nZXQoKSkgPT0g Q0dJbWFnZUdldEhlaWdodChiYXNlbGluZUltYWdlLmdldCgpKSkgJiYgKGltYWdlSGFzQWxwaGEo YWN0dWFsSW1hZ2UuZ2V0KCkpID09IGltYWdlSGFzQWxwaGEoYmFzZWxpbmVJbWFnZS5nZXQoKSkp KSB7CisgICAgICAgICAgICAgICAgZGlmZkltYWdlID0gY29tcGFyZUltYWdlcyhhY3R1YWxJbWFn ZS5nZXQoKSwgYmFzZWxpbmVJbWFnZS5nZXQoKSwgZGlmZmVyZW5jZSk7IC8vIGRpZmZlcmVuY2Ug aXMgcGFzc2VkIGJ5IHJlZmVyZW5jZQorICAgICAgICAgICAgICAgIGlmIChkaWZmZXJlbmNlIDw9 IHRvbGVyYW5jZSkKKyAgICAgICAgICAgICAgICAgICAgZGlmZmVyZW5jZSA9IDAuMGY7CisgICAg ICAgICAgICAgICAgZWxzZSB7CisgICAgICAgICAgICAgICAgICAgIGRpZmZlcmVuY2UgPSByb3Vu ZGYoZGlmZmVyZW5jZSAqIDEwMC4wZikgLyAxMDAuMGY7CisgICAgICAgICAgICAgICAgICAgIGRp ZmZlcmVuY2UgPSBtYXgoZGlmZmVyZW5jZSwgMC4wMWYpOyAvLyByb3VuZCB0byAyIGRlY2ltYWwg cGxhY2VzCisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorICAgICAgICAgICAgZWxz ZQorICAgICAgICAgICAgICAgIGZwdXRzKCJlcnJvciwgdGVzdCBhbmQgcmVmZXJlbmNlIGltYWdl IGhhdmUgZGlmZmVyZW50IHByb3BlcnRpZXMuXG4iLCBzdGRlcnIpOworICAgICAgICAgICAgICAg IAorICAgICAgICAgICAgaWYgKGRpZmZlcmVuY2UgPiAwLjBmKSB7CisgICAgICAgICAgICAgICAg aWYgKGRpZmZJbWFnZSkgeworICAgICAgICAgICAgICAgICAgICBSZXRhaW5QdHI8Q0ZNdXRhYmxl RGF0YVJlZj4gaW1hZ2VEYXRhKEFkb3B0Q0YsIENGRGF0YUNyZWF0ZU11dGFibGUoMCwgMCkpOwor ICAgICAgICAgICAgICAgICAgICBSZXRhaW5QdHI8Q0dJbWFnZURlc3RpbmF0aW9uUmVmPiBpbWFn ZURlc3QoQWRvcHRDRiwgQ0dJbWFnZURlc3RpbmF0aW9uQ3JlYXRlV2l0aERhdGEoaW1hZ2VEYXRh LmdldCgpLCBrVVRUeXBlUE5HLCAxLCAwKSk7CisgICAgICAgICAgICAgICAgICAgIENHSW1hZ2VE ZXN0aW5hdGlvbkFkZEltYWdlKGltYWdlRGVzdC5nZXQoKSwgZGlmZkltYWdlLmdldCgpLCAwKTsK KyAgICAgICAgICAgICAgICAgICAgQ0dJbWFnZURlc3RpbmF0aW9uRmluYWxpemUoaW1hZ2VEZXN0 LmdldCgpKTsKKyAgICAgICAgICAgICAgICAgICAgcHJpbnRmKCJDb250ZW50LUxlbmd0aDogJWx1 XG4iLCBDRkRhdGFHZXRMZW5ndGgoaW1hZ2VEYXRhLmdldCgpKSk7CisgICAgICAgICAgICAgICAg ICAgIGZ3cml0ZShDRkRhdGFHZXRCeXRlUHRyKGltYWdlRGF0YS5nZXQoKSksIDEsIENGRGF0YUdl dExlbmd0aChpbWFnZURhdGEuZ2V0KCkpLCBzdGRvdXQpOworICAgICAgICAgICAgICAgIH0KKyAg ICAgICAgICAgICAgICAKKyAgICAgICAgICAgICAgICBmcHJpbnRmKHN0ZG91dCwgImRpZmY6ICUw MS4yZiUlIGZhaWxlZFxuIiwgZGlmZmVyZW5jZSk7CisgICAgICAgICAgICB9CisgICAgICAgICAg ICBlbHNlCisgICAgICAgICAgICAgICAgZnByaW50ZihzdGRvdXQsICJkaWZmOiAlMDEuMmYlJSBw YXNzZWRcbiIsIGRpZmZlcmVuY2UpOworICAgICAgICAgICAgCiAgICAgICAgICAgICBhY3R1YWxJ bWFnZSA9IDA7CiAgICAgICAgICAgICBiYXNlbGluZUltYWdlID0gMDsKICAgICAgICAgfQpkaWZm IC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1wU3VwcG9ydENH LmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5j cHAKaW5kZXggMjYwYTk0ZS4uNTZjMmYwOCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJl bmRlclRyZWUvY2cvUGl4ZWxEdW1wU3VwcG9ydENHLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9jZy9QaXhlbER1bXBTdXBwb3J0Q0cuY3BwCkBAIC0zNCw3ICszNCwxMCBAQAog I2luY2x1ZGUgIkR1bXBSZW5kZXJUcmVlLmgiCiAjaW5jbHVkZSAiTGF5b3V0VGVzdENvbnRyb2xs ZXIuaCIKICNpbmNsdWRlIDxJbWFnZUlPL0NHSW1hZ2VEZXN0aW5hdGlvbi5oPgorI2luY2x1ZGUg PGFsZ29yaXRobT4KKyNpbmNsdWRlIDxjdHlwZS5oPgogI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25z Lmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZXRhaW5QdHIuaD4K ICNpbmNsdWRlIDx3dGYvU3RyaW5nRXh0cmFzLmg+CiAKQEAgLTYzLDY2ICs2Niw2NSBAQCBzdGF0 aWMgdm9pZCBwcmludFBORyhDR0ltYWdlUmVmIGltYWdlKQogICAgIGZ3cml0ZShDRkRhdGFHZXRC eXRlUHRyKGltYWdlRGF0YS5nZXQoKSksIDEsIENGRGF0YUdldExlbmd0aChpbWFnZURhdGEuZ2V0 KCkpLCBzdGRvdXQpOwogfQogCi1zdGF0aWMgdm9pZCBnZXRNRDVIYXNoU3RyaW5nRm9yQml0bWFw KENHQ29udGV4dFJlZiBiaXRtYXAsIGNoYXIgc3RyaW5nWzMzXSkKK3N0YXRpYyB2b2lkIGNvbXB1 dGVNRDVIYXNoU3RyaW5nRm9yQml0bWFwQ29udGV4dChDR0NvbnRleHRSZWYgYml0bWFwQ29udGV4 dCwgY2hhciBoYXNoU3RyaW5nWzMzXSkKIHsKLSAgICBNRDVfQ1RYIG1kNUNvbnRleHQ7Ci0gICAg dW5zaWduZWQgY2hhciBoYXNoWzE2XTsKLQotICAgIHNpemVfdCBiaXRzUGVyUGl4ZWwgPSBDR0Jp dG1hcENvbnRleHRHZXRCaXRzUGVyUGl4ZWwoYml0bWFwKTsKLSAgICBBU1NFUlQoYml0c1BlclBp eGVsID09IDMyKTsgLy8gSW1hZ2VEaWZmIGFzc3VtZXMgMzIgYml0IFJHQkEsIHdlIG11c3QgYXMg d2VsbC4KLSAgICBzaXplX3QgYnl0ZXNQZXJQaXhlbCA9IGJpdHNQZXJQaXhlbCAvIDg7Ci0gICAg c2l6ZV90IHBpeGVsc0hpZ2ggPSBDR0JpdG1hcENvbnRleHRHZXRIZWlnaHQoYml0bWFwKTsKLSAg ICBzaXplX3QgcGl4ZWxzV2lkZSA9IENHQml0bWFwQ29udGV4dEdldFdpZHRoKGJpdG1hcCk7Ci0g ICAgc2l6ZV90IGJ5dGVzUGVyUm93ID0gQ0dCaXRtYXBDb250ZXh0R2V0Qnl0ZXNQZXJSb3coYml0 bWFwKTsKLSAgICBBU1NFUlQoYnl0ZXNQZXJSb3cgPj0gKHBpeGVsc1dpZGUgKiBieXRlc1BlclBp eGVsKSk7CisgICAgQVNTRVJUKENHQml0bWFwQ29udGV4dEdldEJpdHNQZXJQaXhlbChiaXRtYXBD b250ZXh0KSA9PSAzMik7IC8vIEltYWdlRGlmZiBhc3N1bWVzIDMyIGJpdCBSR0JBLCB3ZSBtdXN0 IGFzIHdlbGwuCisgICAgc2l6ZV90IHBpeGVsc0hpZ2ggPSBDR0JpdG1hcENvbnRleHRHZXRIZWln aHQoYml0bWFwQ29udGV4dCk7CisgICAgc2l6ZV90IHBpeGVsc1dpZGUgPSBDR0JpdG1hcENvbnRl eHRHZXRXaWR0aChiaXRtYXBDb250ZXh0KTsKKyAgICBzaXplX3QgYnl0ZXNQZXJSb3cgPSBDR0Jp dG1hcENvbnRleHRHZXRCeXRlc1BlclJvdyhiaXRtYXBDb250ZXh0KTsKIAorICAgIC8vIE9uIFBQ QyB0aGUgYml0bWFwIGNvbnRleHQgd2lsbCBiZSBpbiBBUkdCOCBpbnN0ZWFkIG9mIEJHUkE4IGFz IG9uIFg4Niwgc28gd2UgbmVlZCB0byBzd2FwIHRoZSBieXRlcyB0byBlbnN1cmUgY29uc2lzdGVu dCBoYXNoZXMKKyAgICBNRDVfQ1RYIG1kNUNvbnRleHQ7CiAgICAgTUQ1X0luaXQoJm1kNUNvbnRl eHQpOwotICAgIHVuc2lnbmVkIGNoYXIqIGJpdG1hcERhdGEgPSBzdGF0aWNfY2FzdDx1bnNpZ25l ZCBjaGFyKj4oQ0dCaXRtYXBDb250ZXh0R2V0RGF0YShiaXRtYXApKTsKKyAgICB1bnNpZ25lZCBj aGFyKiBiaXRtYXBEYXRhID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcio+KENHQml0bWFwQ29u dGV4dEdldERhdGEoYml0bWFwQ29udGV4dCkpOwogICAgIGZvciAodW5zaWduZWQgcm93ID0gMDsg cm93IDwgcGl4ZWxzSGlnaDsgcm93KyspIHsKLSAgICAgICAgTUQ1X1VwZGF0ZSgmbWQ1Q29udGV4 dCwgYml0bWFwRGF0YSwgc3RhdGljX2Nhc3Q8dW5zaWduZWQ+KHBpeGVsc1dpZGUgKiBieXRlc1Bl clBpeGVsKSk7CisjaWYgX19CSUdfRU5ESUFOX18KKyAgICAgICAgdWludDMyX3QgYnVmZmVyW3Bp eGVsc1dpZGVdOworICAgICAgICBmb3IgKHVuc2lnbmVkIGNvbHVtbiA9IDA7IGNvbHVtbiA8IHBp eGVsc1dpZGU7IGNvbHVtbisrKSB7CisgICAgICAgICAgICBidWZmZXJbY29sdW1uXSA9IE9TUmVh ZExpdHRsZUludDMyKGJpdG1hcERhdGEsIDQgKiBjb2x1bW4pOworICAgICAgICB9CisgICAgICAg IE1ENV9VcGRhdGUoJm1kNUNvbnRleHQsIGJ1ZmZlciwgNCAqIHBpeGVsc1dpZGUpOworI2Vsc2UK KyAgICAgICAgTUQ1X1VwZGF0ZSgmbWQ1Q29udGV4dCwgYml0bWFwRGF0YSwgNCAqIHBpeGVsc1dp ZGUpOworI2VuZGlmCiAgICAgICAgIGJpdG1hcERhdGEgKz0gYnl0ZXNQZXJSb3c7CiAgICAgfQor CisgICAgdW5zaWduZWQgY2hhciBoYXNoWzE2XTsKICAgICBNRDVfRmluYWwoaGFzaCwgJm1kNUNv bnRleHQpOwogCi0gICAgc3RyaW5nWzBdID0gJ1wwJzsKKyAgICBoYXNoU3RyaW5nWzBdID0gJ1ww JzsKICAgICBmb3IgKGludCBpID0gMDsgaSA8IDE2OyBpKyspCi0gICAgICAgIHNucHJpbnRmKHN0 cmluZywgMzMsICIlcyUwMngiLCBzdHJpbmcsIGhhc2hbaV0pOwotfQotCi12b2lkIGRyYXdTZWxl Y3Rpb25SZWN0KENHQ29udGV4dFJlZiBjb250ZXh0LCBjb25zdCBDR1JlY3QmIHJlY3QpCi17Ci0g ICAgQ0dDb250ZXh0U2F2ZUdTdGF0ZShjb250ZXh0KTsKLSAgICBDR0NvbnRleHRTZXRSR0JTdHJv a2VDb2xvcihjb250ZXh0LCAxLjAsIDAuMCwgMC4wLCAxLjApOwotICAgIENHQ29udGV4dFN0cm9r ZVJlY3QoY29udGV4dCwgcmVjdCk7Ci0gICAgQ0dDb250ZXh0UmVzdG9yZUdTdGF0ZShjb250ZXh0 KTsKKyAgICAgICAgc25wcmludGYoaGFzaFN0cmluZywgMzMsICIlcyUwMngiLCBoYXNoU3RyaW5n LCBoYXNoW2ldKTsKIH0KIAotdm9pZCBkdW1wV2ViVmlld0FzUGl4ZWxzQW5kQ29tcGFyZVdpdGhF eHBlY3RlZChjb25zdCBjaGFyKiAvKmN1cnJlbnRUZXN0Ki8sIGJvb2wgLypmb3JjZUFsbFRlc3Rz VG9EdW1wUGl4ZWxzKi8pCit2b2lkIGR1bXBXZWJWaWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4 cGVjdGVkKGNvbnN0IHN0ZDo6c3RyaW5nJiBleHBlY3RlZEhhc2gpCiB7Ci0gICAgUmV0YWluUHRy PENHQ29udGV4dFJlZj4gY29udGV4dCA9IGdldEJpdG1hcENvbnRleHRGcm9tV2ViVmlldygpOwot CisgICAgUmVmUHRyPEJpdG1hcENvbnRleHQ+IGNvbnRleHQ7CisgICAgCiAjaWYgUExBVEZPUk0o TUFDKQotICAgIGlmIChnTGF5b3V0VGVzdENvbnRyb2xsZXItPnRlc3RSZXBhaW50KCkpCi0gICAg ICAgIHJlcGFpbnRXZWJWaWV3KGNvbnRleHQuZ2V0KCksIGdMYXlvdXRUZXN0Q29udHJvbGxlci0+ dGVzdFJlcGFpbnRTd2VlcEhvcml6b250YWxseSgpKTsKLSAgICBlbHNlIAotICAgICAgICBwYWlu dFdlYlZpZXcoY29udGV4dC5nZXQoKSk7Ci0KLSAgICBpZiAoZ0xheW91dFRlc3RDb250cm9sbGVy LT5kdW1wU2VsZWN0aW9uUmVjdCgpKQotICAgICAgICBkcmF3U2VsZWN0aW9uUmVjdChjb250ZXh0 LmdldCgpLCBnZXRTZWxlY3Rpb25SZWN0KCkpOworICAgIGNvbnRleHQgPSBjcmVhdGVCaXRtYXBD b250ZXh0RnJvbVdlYlZpZXcoZ0xheW91dFRlc3RDb250cm9sbGVyLT50ZXN0T25zY3JlZW4oKSwg Z0xheW91dFRlc3RDb250cm9sbGVyLT50ZXN0UmVwYWludCgpLCBnTGF5b3V0VGVzdENvbnRyb2xs ZXItPnRlc3RSZXBhaW50U3dlZXBIb3Jpem9udGFsbHkoKSwgZ0xheW91dFRlc3RDb250cm9sbGVy LT5kdW1wU2VsZWN0aW9uUmVjdCgpKTsKICNlbmRpZgotCi0gICAgLy8gQ29tcHV0ZSB0aGUgYWN0 dWFsIGhhc2ggdG8gY29tcGFyZSB0byB0aGUgZXhwZWN0ZWQgaW1hZ2UncyBoYXNoLgorICAgIEFT U0VSVChjb250ZXh0LmdldCgpKTsKKyAgICAKKyAgICAvLyBDb21wdXRlIHRoZSBoYXNoIG9mIHRo ZSBiaXRtYXAgY29udGV4dCBwaXhlbHMKICAgICBjaGFyIGFjdHVhbEhhc2hbMzNdOwotICAgIGdl dE1ENUhhc2hTdHJpbmdGb3JCaXRtYXAoY29udGV4dC5nZXQoKSwgYWN0dWFsSGFzaCk7CisgICAg Y29tcHV0ZU1ENUhhc2hTdHJpbmdGb3JCaXRtYXBDb250ZXh0KGNvbnRleHQtPmNnQ29udGV4dCgp LCBhY3R1YWxIYXNoKTsKICAgICBwcmludGYoIlxuQWN0dWFsSGFzaDogJXNcbiIsIGFjdHVhbEhh c2gpOwotCi0gICAgLy8gRklYTUU6IFdlIHNob3VsZCBjb21wYXJlIHRoZSBhY3R1YWxIYXNoIHRv IHRoZSBleHBlY3RlZCBoYXNoIGhlcmUgYW5kCi0gICAgLy8gb25seSBzZXQgZHVtcEltYWdlIHRv IHRydWUgaWYgdGhleSBkb24ndCBtYXRjaCwgYnV0IERSVCBkb2Vzbid0IGhhdmUKLSAgICAvLyBl bm91Z2ggaW5mb3JtYXRpb24gY3VycmVudGx5IHRvIGZpbmQgdGhlIGV4cGVjdGVkIGNoZWNrc3Vt IGZpbGUuCisgICAgCisgICAgLy8gQ2hlY2sgdGhlIGNvbXB1dGVkIGhhc2ggYWdhaW5zdCB0aGUg ZXhwZWN0ZWQgb25lIGFuZCBkdW1wIGltYWdlIG9uIG1pc21hdGNoCiAgICAgYm9vbCBkdW1wSW1h Z2UgPSB0cnVlOwotCisgICAgaWYgKGV4cGVjdGVkSGFzaC5sZW5ndGgoKSA+IDApIHsKKyAgICAg ICAgQVNTRVJUKGV4cGVjdGVkSGFzaC5sZW5ndGgoKSA9PSAzMik7CisgICAgICAgIAorICAgICAg ICBwcmludGYoIlxuRXhwZWN0ZWRIYXNoOiAlc1xuIiwgZXhwZWN0ZWRIYXNoLmNfc3RyKCkpOwor ICAgICAgICAKKyAgICAgICAgaWYgKGV4cGVjdGVkSGFzaCA9PSBhY3R1YWxIYXNoKSAgICAgLy8g RklYTUU6IGRvIGNhc2UgaW5zZW5zaXRpdmUgY29tcGFyZQorICAgICAgICAgICAgZHVtcEltYWdl ID0gZmFsc2U7CisgICAgfQorICAgIAogICAgIGlmIChkdW1wSW1hZ2UpIHsKLSAgICAgICAgUmV0 YWluUHRyPENHSW1hZ2VSZWY+IGltYWdlKEFkb3B0Q0YsIENHQml0bWFwQ29udGV4dENyZWF0ZUlt YWdlKGNvbnRleHQuZ2V0KCkpKTsKKyAgICAgICAgUmV0YWluUHRyPENHSW1hZ2VSZWY+IGltYWdl KEFkb3B0Q0YsIENHQml0bWFwQ29udGV4dENyZWF0ZUltYWdlKGNvbnRleHQtPmNnQ29udGV4dCgp KSk7CiAgICAgICAgIHByaW50UE5HKGltYWdlLmdldCgpKTsKICAgICB9CiB9CmRpZmYgLS1naXQg YS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9jZy9QaXhlbER1bXBTdXBwb3J0Q0cuaCBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5oCmluZGV4IDBh YmRlYTYuLjU2NjM2NTYgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2Nn L1BpeGVsRHVtcFN1cHBvcnRDRy5oCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2Nn L1BpeGVsRHVtcFN1cHBvcnRDRy5oCkBAIC0zMSwyNSArMzEsNjMgQEAKICNpZm5kZWYgUGl4ZWxE dW1wU3VwcG9ydENHX2gKICNkZWZpbmUgUGl4ZWxEdW1wU3VwcG9ydENHX2gKIAorI2luY2x1ZGUg PHd0Zi9QYXNzUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4KICNpbmNsdWRl IDx3dGYvUmV0YWluUHRyLmg+CiAKLSNpZm5kZWYgQ0dGTE9BVF9ERUZJTkVECi0jaWZkZWYgX19M UDY0X18KLXR5cGVkZWYgZG91YmxlIENHRmxvYXQ7Ci0jZWxzZQotdHlwZWRlZiBmbG9hdCBDR0Zs b2F0OwordHlwZWRlZiBzdHJ1Y3QgQ0dDb250ZXh0KiBDR0NvbnRleHRSZWY7CisKK2NsYXNzIEJp dG1hcENvbnRleHQgOiBwdWJsaWMgUmVmQ291bnRlZDxCaXRtYXBDb250ZXh0PgoreworcHVibGlj OgorI2lmIFBMQVRGT1JNKE1BQykKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxCaXRtYXBDb250ZXh0 PiBjcmVhdGUodm9pZCogcGl4ZWxEYXRhLCBDR0NvbnRleHRSZWYgY29udGV4dCkKKyAgICB7Cisg ICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgQml0bWFwQ29udGV4dChwaXhlbERhdGEsIGNvbnRl eHQpKTsKKyAgICB9CisjZWxpZiBQTEFURk9STShXSU4pCisgICAgc3RhdGljIFBhc3NSZWZQdHI8 Qml0bWFwQ29udGV4dD4gY3JlYXRlKEhCSVRNQVAgYml0bWFwLCBDR0NvbnRleHRSZWYgY29udGV4 dCkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgQml0bWFwQ29udGV4dChiaXRt YXAsIGNvbnRleHQpKTsKKyAgICB9CiAjZW5kaWYKLSNkZWZpbmUgQ0dGTE9BVF9ERUZJTkVEIDEK KworICAgIH5CaXRtYXBDb250ZXh0KCkKKyAgICB7CisjaWYgUExBVEZPUk0oTUFDKQorICAgICAg ICBpZiAobV9waXhlbERhdGEpCisgICAgICAgICAgICBmcmVlKG1fcGl4ZWxEYXRhKTsKKyNlbGlm IFBMQVRGT1JNKFdJTikKKyAgICAgICAgaWYgKG1fYml0bWFwKQorICAgICAgICAgICAgRGVsZXRl T2JqZWN0KG1fYml0bWFwKTsKICNlbmRpZgorICAgIH0KIAotdHlwZWRlZiBzdHJ1Y3QgQ0dDb250 ZXh0KiBDR0NvbnRleHRSZWY7Ci1zdHJ1Y3QgQ0dSZWN0OworICAgIENHQ29udGV4dFJlZiBjZ0Nv bnRleHQoKSBjb25zdCB7IHJldHVybiBtX2NvbnRleHQuZ2V0KCk7IH0KKworcHJpdmF0ZToKKwor I2lmIFBMQVRGT1JNKE1BQykKKyAgICBCaXRtYXBDb250ZXh0KHZvaWQqIHBpeGVsRGF0YSwgQ0dD b250ZXh0UmVmIGNvbnRleHQpCisgICAgICAgIDogbV9waXhlbERhdGEocGl4ZWxEYXRhKQorI2Vs aWYgUExBVEZPUk0oV0lOKQorICAgIEJpdG1hcENvbnRleHQoSEJJVE1BUCBiaXRtYXAsIENHQ29u dGV4dFJlZiBjb250ZXh0KQorICAgICAgICA6IG1fYml0bWFwKGJpdG1hcCkKKyNlbmRpZgorICAg ICAgICAsIG1fY29udGV4dChBZG9wdENGLCBjb250ZXh0KQorICAgIHsKKyAgICB9CisgICAgCisj aWYgUExBVEZPUk0oTUFDKQorICAgIHZvaWQqIG1fcGl4ZWxEYXRhOworI2VsaWYgUExBVEZPUk0o V0lOKQorICAgIEhCSVRNQVAgbV9iaXRtYXA7CisjZW5kaWYgICAgCisgICAgUmV0YWluUHRyPENH Q29udGV4dFJlZj4gbV9jb250ZXh0OworCit9OwogCi1SZXRhaW5QdHI8Q0dDb250ZXh0UmVmPiBn ZXRCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoKTsKLUNHUmVjdCBnZXRTZWxlY3Rpb25SZWN0KCk7 CiAKLXZvaWQgcGFpbnRXZWJWaWV3KENHQ29udGV4dFJlZik7Ci12b2lkIHJlcGFpbnRXZWJWaWV3 KENHQ29udGV4dFJlZiBjb250ZXh0LCBib29sIGhvcml6b250YWwpOwotdm9pZCBkcmF3U2VsZWN0 aW9uUmVjdChDR0NvbnRleHRSZWYsIGNvbnN0IENHUmVjdCYpOworUGFzc1JlZlB0cjxCaXRtYXBD b250ZXh0PiBjcmVhdGVCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoYm9vbCBvbnNjcmVlbiwgYm9v bCBpbmNyZW1lbnRhbFJlcGFpbnQsIGJvb2wgc3dlZXBIb3Jpem9udGFsbHksIGJvb2wgZHJhd1Nl bGVjdGlvblJlY3QpOwogCiAjZW5kaWYgLy8gUGl4ZWxEdW1wU3VwcG9ydENHX2gKZGlmZiAtLWdp dCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbSBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQppbmRleCBiZWNl OTA2Li5mZDNmZGQwIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMv RHVtcFJlbmRlclRyZWUubW0KKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1 bXBSZW5kZXJUcmVlLm1tCkBAIC03OCw3ICs3OCw3IEBACiBAaW50ZXJmYWNlIER1bXBSZW5kZXJU cmVlRXZlbnQgOiBOU0V2ZW50CiBAZW5kCiAKLXN0YXRpYyB2b2lkIHJ1blRlc3QoY29uc3QgY2hh ciAqcGF0aE9yVVJMKTsKK3N0YXRpYyB2b2lkIHJ1blRlc3QoY29uc3Qgc3RkOjpzdHJpbmcmIHRl c3RQYXRoT3JVUkwpOwogCiAvLyBEZWNpZGluZyB3aGVuIGl0J3MgT0sgdG8gZHVtcCBvdXQgdGhl IHN0YXRlIGlzIGEgYml0IHRyaWNreS4gIEFsbCB0aGVzZSBtdXN0IGJlIHRydWU6CiAvLyAtIFRo ZXJlIGlzIG5vIGxvYWQgaW4gcHJvZ3Jlc3MKQEAgLTExMSwxNCArMTExLDEwIEBAIHN0YXRpYyBS ZXNvdXJjZUxvYWREZWxlZ2F0ZSAqcmVzb3VyY2VMb2FkRGVsZWdhdGU7CiBQb2xpY3lEZWxlZ2F0 ZSAqcG9saWN5RGVsZWdhdGU7CiAKIHN0YXRpYyBpbnQgZHVtcFBpeGVsczsKLXN0YXRpYyBpbnQg ZHVtcEFsbFBpeGVsczsKIHN0YXRpYyBpbnQgdGhyZWFkZWQ7Ci1zdGF0aWMgaW50IHRlc3RSZXBh aW50RGVmYXVsdDsKLXN0YXRpYyBpbnQgcmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5RGVmYXVsdDsK IHN0YXRpYyBpbnQgZHVtcFRyZWUgPSBZRVM7CiBzdGF0aWMgaW50IGZvcmNlQ29tcGxleFRleHQ7 CiBzdGF0aWMgQk9PTCBwcmludFNlcGFyYXRvcnM7Ci1zdGF0aWMgTlNTdHJpbmcgKmN1cnJlbnRU ZXN0ID0gbmlsOwogc3RhdGljIFJldGFpblB0cjxDRlN0cmluZ1JlZj4gcGVyc2lzdGVudFVzZXJT dHlsZVNoZWV0TG9jYXRpb247CiAKIHN0YXRpYyBXZWJIaXN0b3J5SXRlbSAqcHJldlRlc3RCRkl0 ZW0gPSBuaWw7ICAvLyBjdXJyZW50IGIvZiBpdGVtIGF0IHRoZSBlbmQgb2YgdGhlIHByZXZpb3Vz IHRlc3QKQEAgLTE4MSwyMSArMTc3LDIxIEBAIHZvaWQgc2V0UGVyc2lzdGVudFVzZXJTdHlsZVNo ZWV0TG9jYXRpb24oQ0ZTdHJpbmdSZWYgdXJsKQogICAgIHBlcnNpc3RlbnRVc2VyU3R5bGVTaGVl dExvY2F0aW9uID0gdXJsOwogfQogCi1zdGF0aWMgQk9PTCBzaG91bGRJZ25vcmVXZWJDb3JlTm9k ZUxlYWtzKENGU3RyaW5nUmVmIFVSTFN0cmluZykKK3N0YXRpYyBib29sIHNob3VsZElnbm9yZVdl YkNvcmVOb2RlTGVha3MoY29uc3Qgc3RkOjpzdHJpbmcmIFVSTFN0cmluZykKIHsKLSAgICBzdGF0 aWMgQ0ZTdHJpbmdSZWYgY29uc3QgaWdub3JlU2V0W10gPSB7CisgICAgc3RhdGljIGNoYXIqIGNv bnN0IGlnbm9yZVNldFtdID0gewogICAgICAgICAvLyBLZWVwaW5nIHRoaXMgaW5mcmFzdHJ1Y3R1 cmUgYXJvdW5kIGluIGNhc2Ugd2UgZXZlciBuZWVkIGl0IGFnYWluLgogICAgIH07Ci0gICAgc3Rh dGljIGNvbnN0IGludCBpZ25vcmVTZXRDb3VudCA9IHNpemVvZihpZ25vcmVTZXQpIC8gc2l6ZW9m KENGU3RyaW5nUmVmKTsKKyAgICBzdGF0aWMgY29uc3QgaW50IGlnbm9yZVNldENvdW50ID0gc2l6 ZW9mKGlnbm9yZVNldCkgLyBzaXplb2YoY2hhciopOwogICAgIAogICAgIGZvciAoaW50IGkgPSAw OyBpIDwgaWdub3JlU2V0Q291bnQ7IGkrKykgewotICAgICAgICBDRlN0cmluZ1JlZiBpZ25vcmVT dHJpbmcgPSBpZ25vcmVTZXRbaV07Ci0gICAgICAgIENGUmFuZ2UgcmFuZ2UgPSBDRlJhbmdlTWFr ZSgwLCBDRlN0cmluZ0dldExlbmd0aChVUkxTdHJpbmcpKTsKLSAgICAgICAgQ0ZPcHRpb25GbGFn cyBmbGFncyA9IGtDRkNvbXBhcmVBbmNob3JlZCB8IGtDRkNvbXBhcmVCYWNrd2FyZHMgfCBrQ0ZD b21wYXJlQ2FzZUluc2Vuc2l0aXZlOwotICAgICAgICBpZiAoQ0ZTdHJpbmdGaW5kV2l0aE9wdGlv bnMoVVJMU3RyaW5nLCBpZ25vcmVTdHJpbmcsIHJhbmdlLCBmbGFncywgTlVMTCkpCi0gICAgICAg ICAgICByZXR1cm4gWUVTOworICAgICAgICAvLyBGSVhNRTogaWdub3JlIGNhc2UKKyAgICAgICAg c3RkOjpzdHJpbmcgY3VySWdub3JlKGlnbm9yZVNldFtpXSk7CisgICAgICAgIC8vIE1hdGNoIGF0 IHRoZSBlbmQgb2YgdGhlIFVSTFN0cmluZworICAgICAgICBpZiAoIVVSTFN0cmluZy5jb21wYXJl KFVSTFN0cmluZy5sZW5ndGgoKSAtIGN1cklnbm9yZS5sZW5ndGgoKSwgY3VySWdub3JlLmxlbmd0 aCgpLCBjdXJJZ25vcmUpKQorICAgICAgICAgICAgcmV0dXJuIHRydWU7CiAgICAgfQotICAgIHJl dHVybiBOTzsKKyAgICByZXR1cm4gZmFsc2U7CiB9CiAKIHN0YXRpYyB2b2lkIGFjdGl2YXRlRm9u dHMoKQpAQCAtMzA3LDEzICszMDMsMTMgQEAgdm9pZCB0ZXN0U3RyaW5nQnlFdmFsdWF0aW5nSmF2 YVNjcmlwdEZyb21TdHJpbmcoKQogc3RhdGljIHZvaWQgc2V0RGVmYXVsdHNUb0NvbnNpc3RlbnRW YWx1ZXNGb3JUZXN0aW5nKCkKIHsKICAgICAvLyBHaXZlIHNvbWUgY2xlYXIgdG8gdW5kb2N1bWVu dGVkIGRlZmF1bHRzIHZhbHVlcwotICAgIHN0YXRpYyBjb25zdCBpbnQgTWVkaXVtRm9udFNtb290 aGluZyA9IDI7CisgICAgc3RhdGljIGNvbnN0IGludCBOb0ZvbnRTbW9vdGhpbmcgPSAwOwogICAg IHN0YXRpYyBjb25zdCBpbnQgQmx1ZVRpbnRlZEFwcGVhcmFuY2UgPSAxOwogCiAgICAgTlNVc2Vy RGVmYXVsdHMgKmRlZmF1bHRzID0gW05TVXNlckRlZmF1bHRzIHN0YW5kYXJkVXNlckRlZmF1bHRz XTsKICAgICBbZGVmYXVsdHMgc2V0T2JqZWN0OkAiRG91YmxlTWF4IiBmb3JLZXk6QCJBcHBsZVNj cm9sbEJhclZhcmlhbnQiXTsKICAgICBbZGVmYXVsdHMgc2V0SW50ZWdlcjo0IGZvcktleTpAIkFw cGxlQW50aUFsaWFzaW5nVGhyZXNob2xkIl07IC8vIHNtYWxsZXN0IGZvbnQgc2l6ZSB0byBDRyBz aG91bGQgcGVyZm9ybSBhbnRpYWxpYXNpbmcgb24KLSAgICBbZGVmYXVsdHMgc2V0SW50ZWdlcjpN ZWRpdW1Gb250U21vb3RoaW5nIGZvcktleTpAIkFwcGxlRm9udFNtb290aGluZyJdOworICAgIFtk ZWZhdWx0cyBzZXRJbnRlZ2VyOk5vRm9udFNtb290aGluZyBmb3JLZXk6QCJBcHBsZUZvbnRTbW9v dGhpbmciXTsKICAgICBbZGVmYXVsdHMgc2V0SW50ZWdlcjpCbHVlVGludGVkQXBwZWFyYW5jZSBm b3JLZXk6QCJBcHBsZUFxdWFDb2xvclZhcmlhbnQiXTsKICAgICBbZGVmYXVsdHMgc2V0T2JqZWN0 OkAiMC43MDk4MDAgMC44MzUzMDAgMS4wMDAwMDAiIGZvcktleTpAIkFwcGxlSGlnaGxpZ2h0Q29s b3IiXTsKICAgICBbZGVmYXVsdHMgc2V0T2JqZWN0OkAiMC41MDAwMDAgMC41MDAwMDAgMC41MDAw MDAiIGZvcktleTpAIkFwcGxlT3RoZXJIaWdobGlnaHRDb2xvciJdOwpAQCAtMzUwLDcgKzM0Niw3 IEBAIHN0YXRpYyB2b2lkIGNyYXNoSGFuZGxlcihpbnQgc2lnKQogICAgIGNoYXIgKnNpZ25hbE5h bWUgPSBzdHJzaWduYWwoc2lnKTsKICAgICB3cml0ZShTVERFUlJfRklMRU5PLCBzaWduYWxOYW1l LCBzdHJsZW4oc2lnbmFsTmFtZSkpOwogICAgIHdyaXRlKFNUREVSUl9GSUxFTk8sICJcbiIsIDEp OwotICAgIHJlc3RvcmVDb2xvclNwYWNlKDApOworICAgIHJlc3RvcmVNYWluRGlzcGxheUNvbG9y UHJvZmlsZSgwKTsKICAgICBleGl0KDEyOCArIHNpZyk7CiB9CiAKQEAgLTM5OSwxMSArMzk1LDgg QEAgc3RhdGljIHZvaWQgcmVsZWFzZUdsb2JhbENvbnRyb2xsZXJzKCkKIHN0YXRpYyB2b2lkIGlu aXRpYWxpemVHbG9iYWxzRnJvbUNvbW1hbmRMaW5lT3B0aW9ucyhpbnQgYXJnYywgY29uc3QgY2hh ciAqYXJndltdKQogewogICAgIHN0cnVjdCBvcHRpb24gb3B0aW9uc1tdID0gewotICAgICAgICB7 ImR1bXAtYWxsLXBpeGVscyIsIG5vX2FyZ3VtZW50LCAmZHVtcEFsbFBpeGVscywgWUVTfSwKLSAg ICAgICAgeyJob3Jpem9udGFsLXN3ZWVwIiwgbm9fYXJndW1lbnQsICZyZXBhaW50U3dlZXBIb3Jp em9udGFsbHlEZWZhdWx0LCBZRVN9LAogICAgICAgICB7Im5vdHJlZSIsIG5vX2FyZ3VtZW50LCAm ZHVtcFRyZWUsIE5PfSwKICAgICAgICAgeyJwaXhlbC10ZXN0cyIsIG5vX2FyZ3VtZW50LCAmZHVt cFBpeGVscywgWUVTfSwKLSAgICAgICAgeyJyZXBhaW50Iiwgbm9fYXJndW1lbnQsICZ0ZXN0UmVw YWludERlZmF1bHQsIFlFU30sCiAgICAgICAgIHsidHJlZSIsIG5vX2FyZ3VtZW50LCAmZHVtcFRy ZWUsIFlFU30sCiAgICAgICAgIHsidGhyZWFkZWQiLCBub19hcmd1bWVudCwgJnRocmVhZGVkLCBZ RVN9LAogICAgICAgICB7ImNvbXBsZXgtdGV4dCIsIG5vX2FyZ3VtZW50LCAmZm9yY2VDb21wbGV4 VGV4dCwgWUVTfSwKQEAgLTQ2MCw3ICs0NTMsNyBAQCBzdGF0aWMgdm9pZCBwcmVwYXJlQ29uc2lz dGVudFRlc3RpbmdFbnZpcm9ubWVudCgpCiAgICAgYWN0aXZhdGVGb250cygpOwogICAgIAogICAg IGlmIChkdW1wUGl4ZWxzKQotICAgICAgICBpbml0aWFsaXplQ29sb3JTcGFjZUFuZFNjcmVlQnVm ZmVyRm9yUGl4ZWxUZXN0cygpOworICAgICAgICBzZXR1cE1haW5EaXNwbGF5Q29sb3JQcm9maWxl KCk7CiAgICAgYWxsb2NhdGVHbG9iYWxDb250cm9sbGVycygpOwogICAgIAogICAgIG1ha2VMYXJn ZU1hbGxvY0ZhaWxTaWxlbnRseSgpOwpAQCAtNTI2LDcgKzUxOSw3IEBAIHZvaWQgZHVtcFJlbmRl clRyZWUoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKmFyZ3ZbXSkKICAgICB9CiAKICAgICBpZiAoZHVt cFBpeGVscykKLSAgICAgICAgcmVzdG9yZUNvbG9yU3BhY2UoMCk7CisgICAgICAgIHJlc3RvcmVN YWluRGlzcGxheUNvbG9yUHJvZmlsZSgwKTsKIH0KIAogaW50IG1haW4oaW50IGFyZ2MsIGNvbnN0 IGNoYXIgKmFyZ3ZbXSkKQEAgLTgyMSw3ICs4MTQsNyBAQCBzdGF0aWMgdm9pZCBkdW1wQmFja0Zv cndhcmRMaXN0Rm9yV2ViVmlldyhXZWJWaWV3ICp2aWV3KQogc3RhdGljIHZvaWQgc2l6ZVdlYlZp ZXdGb3JDdXJyZW50VGVzdCgpCiB7CiAgICAgLy8gVzNDIFNWRyB0ZXN0cyBleHBlY3QgdG8gYmUg NDgweDM2MAotICAgIGJvb2wgaXNTVkdXM0NUZXN0ID0gKFtjdXJyZW50VGVzdCByYW5nZU9mU3Ry aW5nOkAic3ZnL1czQy1TVkctMS4xIl0ubGVuZ3RoKTsKKyAgICBib29sIGlzU1ZHVzNDVGVzdCA9 IChnTGF5b3V0VGVzdENvbnRyb2xsZXItPnRlc3RQYXRoT3JVUkwoKS5maW5kKCJzdmcvVzNDLVNW Ry0xLjEiKSAhPSBzdGQ6OnN0cmluZzo6bnBvcyk7CiAgICAgaWYgKGlzU1ZHVzNDVGVzdCkKICAg ICAgICAgW1ttYWluRnJhbWUgd2ViVmlld10gc2V0RnJhbWVTaXplOk5TTWFrZVNpemUoNDgwLCAz NjApXTsKICAgICBlbHNlCkBAIC05MTUsOCArOTA4LDggQEAgdm9pZCBkdW1wKCkKICAgICAgICAg fSAgICAgICAgICAgIAogICAgIH0KICAgICAKLSAgICBpZiAoZHVtcEFsbFBpeGVscyB8fCAoZHVt cFBpeGVscyAmJiAhZHVtcEFzVGV4dCkpCi0gICAgICAgIGR1bXBXZWJWaWV3QXNQaXhlbHNBbmRD b21wYXJlV2l0aEV4cGVjdGVkKFtjdXJyZW50VGVzdCBVVEY4U3RyaW5nXSwgZHVtcEFsbFBpeGVs cyk7CisgICAgaWYgKGR1bXBQaXhlbHMgJiYgIWR1bXBBc1RleHQpCisgICAgICAgIGR1bXBXZWJW aWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4cGVjdGVkKGdMYXlvdXRUZXN0Q29udHJvbGxlci0+ ZXhwZWN0ZWRQaXhlbEhhc2goKSk7CiAgICAgCiAgICAgcHV0cygiI0VPRiIpOyAgIC8vIHRlcm1p bmF0ZSB0aGUgKHBvc3NpYmx5IGVtcHR5KSBwaXhlbHMgYmxvY2sKIApAQCAtOTMxLDE2ICs5MjQs NiBAQCBzdGF0aWMgYm9vbCBzaG91bGRMb2dGcmFtZUxvYWREZWxlZ2F0ZXMoY29uc3QgY2hhciAq cGF0aE9yVVJMKQogICAgIHJldHVybiBzdHJzdHIocGF0aE9yVVJMLCAibG9hZGluZy8iKTsKIH0K IAotc3RhdGljIENGVVJMUmVmIGNyZWF0ZUNGVVJMRnJvbVBhdGhPclVSTChDRlN0cmluZ1JlZiBw YXRoT3JVUkxTdHJpbmcpCi17Ci0gICAgQ0ZVUkxSZWYgVVJMOwotICAgIGlmIChDRlN0cmluZ0hh c1ByZWZpeChwYXRoT3JVUkxTdHJpbmcsIENGU1RSKCJodHRwOi8vIikpIHx8IENGU3RyaW5nSGFz UHJlZml4KHBhdGhPclVSTFN0cmluZywgQ0ZTVFIoImh0dHBzOi8vIikpKQotICAgICAgICBVUkwg PSBDRlVSTENyZWF0ZVdpdGhTdHJpbmcoTlVMTCwgcGF0aE9yVVJMU3RyaW5nLCBOVUxMKTsKLSAg ICBlbHNlCi0gICAgICAgIFVSTCA9IENGVVJMQ3JlYXRlV2l0aEZpbGVTeXN0ZW1QYXRoKE5VTEws IHBhdGhPclVSTFN0cmluZywga0NGVVJMUE9TSVhQYXRoU3R5bGUsIEZBTFNFKTsKLSAgICByZXR1 cm4gVVJMOwotfQotCiBzdGF0aWMgdm9pZCByZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0ZUJl Zm9yZVRlc3RpbmcoKQogewogICAgIFdlYlZpZXcgKndlYlZpZXcgPSBbbWFpbkZyYW1lIHdlYlZp ZXddOwpAQCAtOTY5LDMwICs5NTIsNDcgQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25z aXN0ZW50U3RhdGVCZWZvcmVUZXN0aW5nKCkKICAgICBbV2ViVmlldyBfc2V0VXNlc1Rlc3RNb2Rl Rm9jdXNSaW5nQ29sb3I6WUVTXTsKIH0KIAotc3RhdGljIHZvaWQgcnVuVGVzdChjb25zdCBjaGFy ICpwYXRoT3JVUkwpCitzdGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0IHN0ZDo6c3RyaW5nJiB0ZXN0 UGF0aE9yVVJMKQogewotICAgIENGU3RyaW5nUmVmIHBhdGhPclVSTFN0cmluZyA9IENGU3RyaW5n Q3JlYXRlV2l0aENTdHJpbmcoTlVMTCwgcGF0aE9yVVJMLCBrQ0ZTdHJpbmdFbmNvZGluZ1VURjgp OworICAgIEFTU0VSVCghdGVzdFBhdGhPclVSTC5lbXB0eSgpKTsKKyAgICAKKyAgICAvLyBMb29r IGZvciAiJyIgYXMgYSBzZXBhcmF0b3IgYmV0d2VlbiB0aGUgcGF0aCBvciBVUkwsIGFuZCB0aGUg cGl4ZWwgZHVtcCBoYXNoIHRoYXQgZm9sbG93cy4KKyAgICBzdGQ6OnN0cmluZyBwYXRoT3JVUkwo dGVzdFBhdGhPclVSTCk7CisgICAgc3RkOjpzdHJpbmcgZXhwZWN0ZWRQaXhlbEhhc2g7CisgICAg CisgICAgc2l6ZV90IHNlcGFyYXRvclBvcyA9IHBhdGhPclVSTC5maW5kKCInIik7CisgICAgaWYg KHNlcGFyYXRvclBvcyAhPSBzdGQ6OnN0cmluZzo6bnBvcykgeworICAgICAgICBwYXRoT3JVUkwg PSBzdGQ6OnN0cmluZyh0ZXN0UGF0aE9yVVJMLCAwLCBzZXBhcmF0b3JQb3MpOworICAgICAgICBl eHBlY3RlZFBpeGVsSGFzaCA9IHN0ZDo6c3RyaW5nKHRlc3RQYXRoT3JVUkwsIHNlcGFyYXRvclBv cyArIDEpOworICAgIH0KKworICAgIE5TU3RyaW5nICpwYXRoT3JVUkxTdHJpbmcgPSBbTlNTdHJp bmcgc3RyaW5nV2l0aFVURjhTdHJpbmc6cGF0aE9yVVJMLmNfc3RyKCldOwogICAgIGlmICghcGF0 aE9yVVJMU3RyaW5nKSB7Ci0gICAgICAgIGZwcmludGYoc3RkZXJyLCAiRmFpbGVkIHRvIHBhcnNl IGZpbGVuYW1lIGFzIFVURi04OiAlc1xuIiwgcGF0aE9yVVJMKTsKKyAgICAgICAgZnByaW50Zihz dGRlcnIsICJGYWlsZWQgdG8gcGFyc2UgXCIlc1wiIGFzIFVURi04XG4iLCBwYXRoT3JVUkwuY19z dHIoKSk7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBDRlVSTFJlZiBVUkwgPSBjcmVh dGVDRlVSTEZyb21QYXRoT3JVUkwocGF0aE9yVVJMU3RyaW5nKTsKLSAgICBpZiAoIVVSTCkgewot ICAgICAgICBDRlJlbGVhc2UocGF0aE9yVVJMU3RyaW5nKTsKLSAgICAgICAgZnByaW50ZihzdGRl cnIsICJDYW4ndCB0dXJuICVzIGludG8gYSBDRlVSTFxuIiwgcGF0aE9yVVJMKTsKKyAgICBOU1VS TCAqdXJsOworICAgIGlmIChbcGF0aE9yVVJMU3RyaW5nIGhhc1ByZWZpeDpAImh0dHA6Ly8iXSB8 fCBbcGF0aE9yVVJMU3RyaW5nIGhhc1ByZWZpeDpAImh0dHBzOi8vIl0pCisgICAgICAgIHVybCA9 IFtOU1VSTCBVUkxXaXRoU3RyaW5nOnBhdGhPclVSTFN0cmluZ107CisgICAgZWxzZQorICAgICAg ICB1cmwgPSBbTlNVUkwgZmlsZVVSTFdpdGhQYXRoOnBhdGhPclVSTFN0cmluZ107CisgICAgaWYg KCF1cmwpIHsKKyAgICAgICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gcGFyc2UgXCIlc1wi IGFzIGEgdXJsXG4iLCBwYXRoT3JVUkwuY19zdHIoKSk7CiAgICAgICAgIHJldHVybjsKICAgICB9 CiAKKyAgICBjb25zdCBzdGQ6OnN0cmluZyB0ZXN0VVJMKFtbdXJsIGFic29sdXRlU3RyaW5nXSBV VEY4U3RyaW5nXSk7CisgICAgCiAgICAgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdGVCZWZv cmVUZXN0aW5nKCk7CiAKLSAgICBnTGF5b3V0VGVzdENvbnRyb2xsZXIgPSBuZXcgTGF5b3V0VGVz dENvbnRyb2xsZXIodGVzdFJlcGFpbnREZWZhdWx0LCByZXBhaW50U3dlZXBIb3Jpem9udGFsbHlE ZWZhdWx0KTsKKyAgICBnTGF5b3V0VGVzdENvbnRyb2xsZXIgPSBuZXcgTGF5b3V0VGVzdENvbnRy b2xsZXIodGVzdFVSTCwgZXhwZWN0ZWRQaXhlbEhhc2gpOwogICAgIHRvcExvYWRpbmdGcmFtZSA9 IG5pbDsKICAgICBkb25lID0gTk87CiAKICAgICBpZiAoZGlzYWxsb3dlZFVSTHMpCiAgICAgICAg IENGU2V0UmVtb3ZlQWxsVmFsdWVzKGRpc2FsbG93ZWRVUkxzKTsKLSAgICBpZiAoc2hvdWxkTG9n RnJhbWVMb2FkRGVsZWdhdGVzKHBhdGhPclVSTCkpCisgICAgaWYgKHNob3VsZExvZ0ZyYW1lTG9h ZERlbGVnYXRlcyhwYXRoT3JVUkwuY19zdHIoKSkpCiAgICAgICAgIGdMYXlvdXRUZXN0Q29udHJv bGxlci0+c2V0RHVtcEZyYW1lTG9hZENhbGxiYWNrcyh0cnVlKTsKIAogICAgIGlmIChbV2ViSGlz dG9yeSBvcHRpb25hbFNoYXJlZEhpc3RvcnldKQpAQCAtMTAwMCwyMiArMTAwMCwxOCBAQCBzdGF0 aWMgdm9pZCBydW5UZXN0KGNvbnN0IGNoYXIgKnBhdGhPclVSTCkKICAgICBsYXN0TW91c2VQb3Np dGlvbiA9IE5TWmVyb1BvaW50OwogICAgIGxhc3RDbGlja1Bvc2l0aW9uID0gTlNaZXJvUG9pbnQ7 CiAKLSAgICBpZiAoY3VycmVudFRlc3QgIT0gbmlsKQotICAgICAgICBDRlJlbGVhc2UoY3VycmVu dFRlc3QpOwotICAgIGN1cnJlbnRUZXN0ID0gKE5TU3RyaW5nICopcGF0aE9yVVJMU3RyaW5nOwog ICAgIFtwcmV2VGVzdEJGSXRlbSByZWxlYXNlXTsKICAgICBwcmV2VGVzdEJGSXRlbSA9IFtbW1tt YWluRnJhbWUgd2ViVmlld10gYmFja0ZvcndhcmRMaXN0XSBjdXJyZW50SXRlbV0gcmV0YWluXTsK IAogICAgIFdvcmtRdWV1ZTo6c2hhcmVkKCktPmNsZWFyKCk7CiAgICAgV29ya1F1ZXVlOjpzaGFy ZWQoKS0+c2V0RnJvemVuKGZhbHNlKTsKIAotICAgIEJPT0wgX3Nob3VsZElnbm9yZVdlYkNvcmVO b2RlTGVha3MgPSBzaG91bGRJZ25vcmVXZWJDb3JlTm9kZUxlYWtzKENGVVJMR2V0U3RyaW5nKFVS TCkpOwotICAgIGlmIChfc2hvdWxkSWdub3JlV2ViQ29yZU5vZGVMZWFrcykKKyAgICBib29sIGln bm9yZVdlYkNvcmVOb2RlTGVha3MgPSBzaG91bGRJZ25vcmVXZWJDb3JlTm9kZUxlYWtzKHRlc3RV UkwpOworICAgIGlmIChpZ25vcmVXZWJDb3JlTm9kZUxlYWtzKQogICAgICAgICBbV2ViQ29yZVN0 YXRpc3RpY3Mgc3RhcnRJZ25vcmluZ1dlYkNvcmVOb2RlTGVha3NdOwogCiAgICAgTlNBdXRvcmVs ZWFzZVBvb2wgKnBvb2wgPSBbW05TQXV0b3JlbGVhc2VQb29sIGFsbG9jXSBpbml0XTsKLSAgICBb bWFpbkZyYW1lIGxvYWRSZXF1ZXN0OltOU1VSTFJlcXVlc3QgcmVxdWVzdFdpdGhVUkw6KE5TVVJM ICopVVJMXV07Ci0gICAgQ0ZSZWxlYXNlKFVSTCk7CisgICAgW21haW5GcmFtZSBsb2FkUmVxdWVz dDpbTlNVUkxSZXF1ZXN0IHJlcXVlc3RXaXRoVVJMOnVybF1dOwogICAgIFtwb29sIHJlbGVhc2Vd OwogICAgIHdoaWxlICghZG9uZSkgewogICAgICAgICBwb29sID0gW1tOU0F1dG9yZWxlYXNlUG9v bCBhbGxvY10gaW5pdF07CkBAIC0xMDU4LDcgKzEwNTQsNyBAQCBzdGF0aWMgdm9pZCBydW5UZXN0 KGNvbnN0IGNoYXIgKnBhdGhPclVSTCkKICAgICBnTGF5b3V0VGVzdENvbnRyb2xsZXItPmRlcmVm KCk7CiAgICAgZ0xheW91dFRlc3RDb250cm9sbGVyID0gMDsKIAotICAgIGlmIChfc2hvdWxkSWdu b3JlV2ViQ29yZU5vZGVMZWFrcykKKyAgICBpZiAoaWdub3JlV2ViQ29yZU5vZGVMZWFrcykKICAg ICAgICAgW1dlYkNvcmVTdGF0aXN0aWNzIHN0b3BJZ25vcmluZ1dlYkNvcmVOb2RlTGVha3NdOwog fQogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvUGl4ZWxEdW1w U3VwcG9ydE1hYy5tbSBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9QaXhlbER1bXBT dXBwb3J0TWFjLm1tCmluZGV4IDlkZGJhMzEuLjI1ZDg5NDUgMTAwNjQ0Ci0tLSBhL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL21hYy9QaXhlbER1bXBTdXBwb3J0TWFjLm1tCisrKyBiL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9QaXhlbER1bXBTdXBwb3J0TWFjLm1tCkBAIC0zNCwx NTMgKzM0LDIyNSBAQAogCiAjaW5jbHVkZSAiTGF5b3V0VGVzdENvbnRyb2xsZXIuaCIKICNpbmNs dWRlIDxDb3JlR3JhcGhpY3MvQ0dCaXRtYXBDb250ZXh0Lmg+CisjaWZuZGVmIEJVSUxESU5HX09O X0xFT1BBUkQKKyNpbmNsdWRlIDxPcGVuR0wvT3BlbkdMLmg+CisjaW5jbHVkZSA8T3BlbkdML0NH TE1hY3JvLmg+CisjZW5kaWYKICNpbmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgotI2luY2x1ZGUg PHd0Zi9SZXRhaW5QdHIuaD4KKyNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CiAKICNpbXBvcnQgPFdl YktpdC9XZWJEb2N1bWVudFByaXZhdGUuaD4KICNpbXBvcnQgPFdlYktpdC9XZWJLaXQuaD4KIAot c3RhdGljIHVuc2lnbmVkIGNoYXIqIHNjcmVlbkNhcHR1cmVCdWZmZXI7CisvLyBUbyBlbnN1cmUg cGl4ZWwgdGVzdHMgY29uc2lzdGVuY3ksIHdlIG5lZWQgdG8gYWx3YXlzIHJlbmRlciBpbiB0aGUg c2FtZSBjb2xvcnNwYWNlLgorLy8gVW5mb3J0dW5hdGVseSwgYmVjYXVzZSBvZiBBcHBLaXQgLyBX ZWJLaXQgY29uc3RyYWludHMsIHdlIGNhbid0IHJlbmRlciBkaXJlY3RseSBpbiB0aGUgY29sb3Jz cGFjZSBvZiBvdXIgY2hvaWNlLgorLy8gVGhpcyBpbXBsaWVzIHdlIGhhdmUgdG8gdGVtcG9yYXJp bHkgY2hhbmdlIHRoZSBwcm9maWxlIG9mIHRoZSBtYWluIGRpc3BsYXkgdG8gdGhlIGNvbG9yc3Bh Y2Ugd2Ugd2FudCB0byByZW5kZXIgaW50by4KKy8vIFdlIGFsc28gbmVlZCB0byBtYWtlIHN1cmUg dGhlIENHQml0bWFwQ29udGV4dCB3ZSByZXR1cm4gaXMgaW4gdGhhdCBzYW1lIGNvbG9yc3BhY2Uu CiAKLXN0YXRpYyBib29sIGNoYW5nZWRDb2xvclByb2ZpbGUgPSBmYWxzZTsKLXN0YXRpYyBDTVBy b2ZpbGVMb2NhdGlvbiBjdXJyZW50Q29sb3JQcm9maWxlTG9jYXRpb247Ci1zdGF0aWMgQ0dDb2xv clNwYWNlUmVmIHNoYXJlZENvbG9yU3BhY2U7CisjZGVmaW5lIFBST0ZJTEVfUEFUSCAiL1N5c3Rl bS9MaWJyYXJ5L0NvbG9yU3luYy9Qcm9maWxlcy9HZW5lcmljIFJHQiBQcm9maWxlLmljYyIgLy8g RklYTUU6IFNob3VsZCB3ZSBiZSB1c2luZyAiL1N5c3RlbS9MaWJyYXJ5L0NvbG9yU3luYy9Qcm9m aWxlcy9zUkdCIFByb2ZpbGUuaWNjIj8KIAotdm9pZCByZXN0b3JlQ29sb3JTcGFjZShpbnQgaWdu b3JlZCkKK3N0YXRpYyBDTVByb2ZpbGVMb2NhdGlvbiBzSW5pdGlhbFByb2ZpbGVMb2NhdGlvbjsg Ly8gVGhlIGxvY1R5cGUgZmllbGQgaXMgaW5pdGlhbGl6ZWQgdG8gMCB3aGljaCBpcyB0aGUgc2Ft ZSBhcyBjbU5vUHJvZmlsZUJhc2UKKwordm9pZCByZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2Zp bGUoaW50IGlnbm9yZWQpCiB7CiAgICAgLy8gVGhpcyBpcyB1c2VkIGFzIGEgc2lnbmFsIGhhbmRs ZXIsIGFuZCB0aHVzIHRoZSBjYWxscyBpbnRvIENvbG9yU3luYyBhcmUgdW5zYWZlCiAgICAgLy8g QnV0IHdlIG1pZ2h0IGFzIHdlbGwgdHJ5IHRvIHJlc3RvcmUgdGhlIHVzZXIncyBjb2xvciBwcm9m aWxlLCB3ZSdyZSBnb2luZyBkb3duIGFueXdheS4uLgotICAgIGlmIChjaGFuZ2VkQ29sb3JQcm9m aWxlKSB7Ci0gICAgICAgIENNRGV2aWNlU2NvcGUgc2NvcGUgPSB7IGtDRlByZWZlcmVuY2VzQ3Vy cmVudFVzZXIsIGtDRlByZWZlcmVuY2VzQ3VycmVudEhvc3QgfTsKLSAgICAgICAgaW50IGVycm9y ID0gQ01TZXREZXZpY2VQcm9maWxlKGNtRGlzcGxheURldmljZUNsYXNzLCBjbURlZmF1bHREZXZp Y2VJRCwgJnNjb3BlLCBjbURlZmF1bHRQcm9maWxlSUQsICZjdXJyZW50Q29sb3JQcm9maWxlTG9j YXRpb24pOworICAgIGlmIChzSW5pdGlhbFByb2ZpbGVMb2NhdGlvbi5sb2NUeXBlICE9IGNtTm9Q cm9maWxlQmFzZSkgeworICAgICAgICBjb25zdCBDTURldmljZVNjb3BlIHNjb3BlID0geyBrQ0ZQ cmVmZXJlbmNlc0N1cnJlbnRVc2VyLCBrQ0ZQcmVmZXJlbmNlc0N1cnJlbnRIb3N0IH07CisgICAg ICAgIGludCBlcnJvciA9IENNU2V0RGV2aWNlUHJvZmlsZShjbURpc3BsYXlEZXZpY2VDbGFzcywg KENNRGV2aWNlSUQpa0NHRGlyZWN0TWFpbkRpc3BsYXksICZzY29wZSwgY21EZWZhdWx0UHJvZmls ZUlELCAmc0luaXRpYWxQcm9maWxlTG9jYXRpb24pOwogICAgICAgICBpZiAoZXJyb3IpCi0gICAg ICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byByZXRvcmUgcHJldmlvdXMgY29sb3Ig cHJvZmlsZSEgIFlvdSBtYXkgbmVlZCB0byBvcGVuIFN5c3RlbSBQcmVmZXJlbmNlcyA6IERpc3Bs YXlzIDogQ29sb3IgYW5kIG1hbnVhbGx5IHJlc3RvcmUgeW91ciBjb2xvciBzZXR0aW5ncy4gIChF cnJvcjogJWkpIiwgZXJyb3IpOwotICAgICAgICBjaGFuZ2VkQ29sb3JQcm9maWxlID0gZmFsc2U7 CisgICAgICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byByZXN0b3JlIGluaXRpYWwg Y29sb3IgcHJvZmlsZSBmb3IgbWFpbiBkaXNwbGF5ISBPcGVuIFN5c3RlbSBQcmVmZXJlbmNlcyA+ IERpc3BsYXlzID4gQ29sb3IgYW5kIG1hbnVhbGx5IHJlLXNlbGVjdCB0aGUgcHJvZmlsZS4gIChF cnJvcjogJWkpIiwgZXJyb3IpOworICAgICAgICBzSW5pdGlhbFByb2ZpbGVMb2NhdGlvbi5sb2NU eXBlID0gY21Ob1Byb2ZpbGVCYXNlOwogICAgIH0KIH0KIAotc3RhdGljIHZvaWQgZmFpbGVkR2V0 dGluZ0N1cnJlbnRQcm9maWxlKGludCBlcnJvcikKK3ZvaWQgc2V0dXBNYWluRGlzcGxheUNvbG9y UHJvZmlsZSgpCiB7Ci0gICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gZ2V0IGN1cnJlbnQg Y29sb3IgcHJvZmlsZS4gIEkgd2lsbCBub3QgYmUgYWJsZSB0byByZXN0b3JlIHlvdXIgY3VycmVu dCBwcm9maWxlLCB0aHVzIEknbSBub3QgY2hhbmdpbmcgaXQuICBNYW55IHBpeGVsIHRlc3RzIG1h eSBmYWlsIGFzIGEgcmVzdWx0LiAgKEVycm9yOiAlaSlcbiIsIGVycm9yKTsKLX0KLQotc3RhdGlj IHZvaWQgc2V0RGVmYXVsdENvbG9yUHJvZmlsZVRvUkdCKCkKLXsKLSAgICBDTVByb2ZpbGVSZWYg Z2VuZXJpY1Byb2ZpbGUgPSAoQ01Qcm9maWxlUmVmKVtbTlNDb2xvclNwYWNlIGdlbmVyaWNSR0JD b2xvclNwYWNlXSBjb2xvclN5bmNQcm9maWxlXTsKLSAgICBDTVByb2ZpbGVMb2NhdGlvbiBnZW5l cmljUHJvZmlsZUxvY2F0aW9uOwotICAgIFVJbnQzMiBsb2NhdGlvblNpemUgPSBzaXplb2YoZ2Vu ZXJpY1Byb2ZpbGVMb2NhdGlvbik7Ci0gICAgaW50IGVycm9yID0gTkNNR2V0UHJvZmlsZUxvY2F0 aW9uKGdlbmVyaWNQcm9maWxlLCAmZ2VuZXJpY1Byb2ZpbGVMb2NhdGlvbiwgJmxvY2F0aW9uU2l6 ZSk7Ci0gICAgaWYgKGVycm9yKSB7Ci0gICAgICAgIGZhaWxlZEdldHRpbmdDdXJyZW50UHJvZmls ZShlcnJvcik7Ci0gICAgICAgIHJldHVybjsKKyAgICBjb25zdCBDTURldmljZVNjb3BlIHNjb3Bl ID0geyBrQ0ZQcmVmZXJlbmNlc0N1cnJlbnRVc2VyLCBrQ0ZQcmVmZXJlbmNlc0N1cnJlbnRIb3N0 IH07CisgICAgaW50IGVycm9yOworICAgIAorICAgIENNUHJvZmlsZVJlZiBwcm9maWxlID0gTlVM TDsKKyAgICBlcnJvciA9IENNR2V0UHJvZmlsZUJ5QVZJRCgoQ01EaXNwbGF5SURUeXBlKWtDR0Rp cmVjdE1haW5EaXNwbGF5LCAmcHJvZmlsZSk7CisgICAgaWYgKCFlcnJvcikgeworICAgICAgICBV SW50MzIgc2l6ZSA9IHNpemVvZihDTVByb2ZpbGVMb2NhdGlvbik7CisgICAgICAgIGVycm9yID0g TkNNR2V0UHJvZmlsZUxvY2F0aW9uKHByb2ZpbGUsICZzSW5pdGlhbFByb2ZpbGVMb2NhdGlvbiwg JnNpemUpOworICAgICAgICBDTUNsb3NlUHJvZmlsZShwcm9maWxlKTsKICAgICB9Ci0KLSAgICBD TVByb2ZpbGVMb2NhdGlvbiBwcmV2aW91c1Byb2ZpbGVMb2NhdGlvbjsKLSAgICBlcnJvciA9IENN R2V0RGV2aWNlUHJvZmlsZShjbURpc3BsYXlEZXZpY2VDbGFzcywgY21EZWZhdWx0RGV2aWNlSUQs IGNtRGVmYXVsdFByb2ZpbGVJRCwgJnByZXZpb3VzUHJvZmlsZUxvY2F0aW9uKTsKICAgICBpZiAo ZXJyb3IpIHsKLSAgICAgICAgZmFpbGVkR2V0dGluZ0N1cnJlbnRQcm9maWxlKGVycm9yKTsKKyAg ICAgICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gcmV0cmlldmUgY3VycmVudCBjb2xvciBw cm9maWxlIGZvciBtYWluIGRpc3BsYXksIHRodXMgaXQgd29uJ3QgYmUgY2hhbmdlZC4gIE1hbnkg cGl4ZWwgdGVzdHMgbWF5IGZhaWwgYXMgYSByZXN1bHQuICAoRXJyb3I6ICVpKSIsIGVycm9yKTsK KyAgICAgICAgc0luaXRpYWxQcm9maWxlTG9jYXRpb24ubG9jVHlwZSA9IGNtTm9Qcm9maWxlQmFz ZTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KKyAgICAKKyAgICBDTVByb2ZpbGVMb2NhdGlvbiBs b2NhdGlvbjsKKyAgICBsb2NhdGlvbi5sb2NUeXBlID0gY21GaWxlQmFzZWRQcm9maWxlOworICAg IE5TVVJMICp1cmwgPSBbTlNVUkwgZmlsZVVSTFdpdGhQYXRoOltOU1N0cmluZyBzdHJpbmdXaXRo VVRGOFN0cmluZzpQUk9GSUxFX1BBVEhdXTsKKyAgICBGU1JlZiBmc1JlZjsKKyAgICBpZiAodXJs ICYmIENGVVJMR2V0RlNSZWYoKENGVVJMUmVmKXVybCwgJmZzUmVmKSkgeworICAgICAgICBlcnJv ciA9IEZTR2V0Q2F0YWxvZ0luZm8oJmZzUmVmLCAwLCBOVUxMLCBOVUxMLCAmbG9jYXRpb24udS5m aWxlTG9jLnNwZWMsIE5VTEwpOworICAgICAgICBpZiAoZXJyb3IgPT0gbm9FcnIpCisgICAgICAg IGVycm9yID0gQ01TZXREZXZpY2VQcm9maWxlKGNtRGlzcGxheURldmljZUNsYXNzLCAoQ01EZXZp Y2VJRClrQ0dEaXJlY3RNYWluRGlzcGxheSwgJnNjb3BlLCBjbURlZmF1bHRQcm9maWxlSUQsICZs b2NhdGlvbik7CisgICAgfQorICAgIGVsc2UKKyAgICAgICAgZXJyb3IgPSAtMTsKIAotICAgIENN UHJvZmlsZVJlZiBwcmV2aW91c1Byb2ZpbGU7Ci0gICAgZXJyb3IgPSBDTU9wZW5Qcm9maWxlKCZw cmV2aW91c1Byb2ZpbGUsICZwcmV2aW91c1Byb2ZpbGVMb2NhdGlvbik7CiAgICAgaWYgKGVycm9y KSB7Ci0gICAgICAgIGZhaWxlZEdldHRpbmdDdXJyZW50UHJvZmlsZShlcnJvcik7CisgICAgICAg IGZwcmludGYoc3RkZXJyLCAiRmFpbGVkIHRvIHNldCBjb2xvciBwcm9maWxlIGZvciBtYWluIGRp c3BsYXkhICBNYW55IHBpeGVsIHRlc3RzIG1heSBmYWlsIGFzIGEgcmVzdWx0LiAgKEVycm9yOiAl aSkiLCBlcnJvcik7CisgICAgICAgIHNJbml0aWFsUHJvZmlsZUxvY2F0aW9uLmxvY1R5cGUgPSBj bU5vUHJvZmlsZUJhc2U7CiAgICAgICAgIHJldHVybjsKICAgICB9Ci0KLSAgICBDRlN0cmluZ1Jl ZiBwcmV2aW91c1Byb2ZpbGVOYW1lOwotICAgIENGU3RyaW5nUmVmIGdlbmVyaWNQcm9maWxlTmFt ZTsKLSAgICBjaGFyIHByZXZpb3VzUHJvZmlsZU5hbWVTdHJpbmdbMTAyNF07Ci0gICAgY2hhciBn ZW5lcmljUHJvZmlsZU5hbWVTdHJpbmdbMTAyNF07Ci0gICAgQ01Db3B5UHJvZmlsZURlc2NyaXB0 aW9uU3RyaW5nKHByZXZpb3VzUHJvZmlsZSwgJnByZXZpb3VzUHJvZmlsZU5hbWUpOwotICAgIENN Q29weVByb2ZpbGVEZXNjcmlwdGlvblN0cmluZyhnZW5lcmljUHJvZmlsZSwgJmdlbmVyaWNQcm9m aWxlTmFtZSk7Ci0gICAgQ0ZTdHJpbmdHZXRDU3RyaW5nKHByZXZpb3VzUHJvZmlsZU5hbWUsIHBy ZXZpb3VzUHJvZmlsZU5hbWVTdHJpbmcsIHNpemVvZihwcmV2aW91c1Byb2ZpbGVOYW1lU3RyaW5n KSwga0NGU3RyaW5nRW5jb2RpbmdVVEY4KTsKLSAgICBDRlN0cmluZ0dldENTdHJpbmcoZ2VuZXJp Y1Byb2ZpbGVOYW1lLCBnZW5lcmljUHJvZmlsZU5hbWVTdHJpbmcsIHNpemVvZihwcmV2aW91c1By b2ZpbGVOYW1lU3RyaW5nKSwga0NGU3RyaW5nRW5jb2RpbmdVVEY4KTsKLSAgICBDRlJlbGVhc2Uo cHJldmlvdXNQcm9maWxlTmFtZSk7Ci0gICAgQ0ZSZWxlYXNlKGdlbmVyaWNQcm9maWxlTmFtZSk7 Ci0KLSAgICBDTUNsb3NlUHJvZmlsZShwcmV2aW91c1Byb2ZpbGUpOwotCi0gICAgZnByaW50Zihz dGRlcnIsICJcblxuV0FSTklORzogVGVtcG9yYXJpbHkgY2hhbmdpbmcgeW91ciBzeXN0ZW0gY29s b3IgcHJvZmlsZSBmcm9tIFwiJXNcIiB0byBcIiVzXCIuXG4iLCBwcmV2aW91c1Byb2ZpbGVOYW1l U3RyaW5nLCBnZW5lcmljUHJvZmlsZU5hbWVTdHJpbmcpOworICAgIAorICAgIC8vIE90aGVyIHNp Z25hbHMgYXJlIGhhbmRsZWQgaW4gaW5zdGFsbFNpZ25hbEhhbmRsZXJzKCkgd2hpY2ggYWxzbyBj YWxscyByZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUoKQorICAgIHNpZ25hbChTSUdJTlQs IHJlc3RvcmVNYWluRGlzcGxheUNvbG9yUHJvZmlsZSk7CisgICAgc2lnbmFsKFNJR0hVUCwgcmVz dG9yZU1haW5EaXNwbGF5Q29sb3JQcm9maWxlKTsKKyAgICBzaWduYWwoU0lHVEVSTSwgcmVzdG9y ZU1haW5EaXNwbGF5Q29sb3JQcm9maWxlKTsKKyAgICAKKyAgICBmcHJpbnRmKHN0ZGVyciwgIlxu XG5XQVJOSU5HOiBUZW1wb3JhcmlseSBjaGFuZ2luZyB0aGUgbWFpbiBkaXNwbGF5IGNvbG9yIHBy b2ZpbGUgdG8gXCIlc1wiOiB0aGUgY29sb3JzIG9uIHlvdXIgc2NyZWVuIHdpbGwgY2hhbmdlIGZv ciB0aGUgZHVyYXRpb24gb2YgdGhlIHRlc3RpbmcuXG4iLCBQUk9GSUxFX1BBVEgpOwogICAgIGZw cmludGYoc3RkZXJyLCAiVGhpcyBhbGxvd3MgdGhlIFdlYktpdCBwaXhlbC1iYXNlZCByZWdyZXNz aW9uIHRlc3RzIHRvIGhhdmUgY29uc2lzdGVudCBjb2xvciB2YWx1ZXMgYWNyb3NzIGFsbCBtYWNo aW5lcy5cbiIpOwotICAgIGZwcmludGYoc3RkZXJyLCAiVGhlIGNvbG9ycyBvbiB5b3VyIHNjcmVl biB3aWxsIGNoYW5nZSBmb3IgdGhlIGR1cmF0aW9uIG9mIHRoZSB0ZXN0aW5nLlxuXG4iKTsKLQot ICAgIENNRGV2aWNlU2NvcGUgc2NvcGUgPSB7IGtDRlByZWZlcmVuY2VzQ3VycmVudFVzZXIsIGtD RlByZWZlcmVuY2VzQ3VycmVudEhvc3QgfTsKLSAgICBpZiAoKGVycm9yID0gQ01TZXREZXZpY2VQ cm9maWxlKGNtRGlzcGxheURldmljZUNsYXNzLCBjbURlZmF1bHREZXZpY2VJRCwgJnNjb3BlLCBj bURlZmF1bHRQcm9maWxlSUQsICZnZW5lcmljUHJvZmlsZUxvY2F0aW9uKSkpIHsKLSAgICAgICAg ZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gc2V0IGNvbG9yIHByb2ZpbGUgdG8gXCIlc1wiISBN YW55IHBpeGVsIHRlc3RzIHdpbGwgZmFpbCBhcyBhIHJlc3VsdC4gIChFcnJvcjogJWkpIiwKLSAg ICAgICAgICAgIGdlbmVyaWNQcm9maWxlTmFtZVN0cmluZywgZXJyb3IpOwotICAgIH0gZWxzZSB7 Ci0gICAgICAgIGN1cnJlbnRDb2xvclByb2ZpbGVMb2NhdGlvbiA9IHByZXZpb3VzUHJvZmlsZUxv Y2F0aW9uOwotICAgICAgICBjaGFuZ2VkQ29sb3JQcm9maWxlID0gdHJ1ZTsKLSAgICAgICAgc2ln bmFsKFNJR0lOVCwgcmVzdG9yZUNvbG9yU3BhY2UpOwotICAgICAgICBzaWduYWwoU0lHSFVQLCBy ZXN0b3JlQ29sb3JTcGFjZSk7Ci0gICAgICAgIHNpZ25hbChTSUdURVJNLCByZXN0b3JlQ29sb3JT cGFjZSk7Ci0gICAgfQogfQogCi12b2lkIGluaXRpYWxpemVDb2xvclNwYWNlQW5kU2NyZWVCdWZm ZXJGb3JQaXhlbFRlc3RzKCkKLXsKLSAgICBzZXREZWZhdWx0Q29sb3JQcm9maWxlVG9SR0IoKTsK LSAgICBzY3JlZW5DYXB0dXJlQnVmZmVyID0gKHVuc2lnbmVkIGNoYXIgKiltYWxsb2MobWF4Vmll d0hlaWdodCAqIG1heFZpZXdXaWR0aCAqIDQpOwotICAgIHNoYXJlZENvbG9yU3BhY2UgPSBDR0Nv bG9yU3BhY2VDcmVhdGVEZXZpY2VSR0IoKTsKLX0KLQotLy8gRGVjbGFyZWQgaW4gUGl4ZWxEdW1w U3VwcG9ydENHLmgKLQotUmV0YWluUHRyPENHQ29udGV4dFJlZj4gZ2V0Qml0bWFwQ29udGV4dEZy b21XZWJWaWV3KCkKK1Bhc3NSZWZQdHI8Qml0bWFwQ29udGV4dD4gY3JlYXRlQml0bWFwQ29udGV4 dEZyb21XZWJWaWV3KGJvb2wgb25zY3JlZW4sIGJvb2wgaW5jcmVtZW50YWxSZXBhaW50LCBib29s IHN3ZWVwSG9yaXpvbnRhbGx5LCBib29sIGRyYXdTZWxlY3Rpb25SZWN0KQogewotICAgIE5TU2l6 ZSB3ZWJWaWV3U2l6ZSA9IFtbbWFpbkZyYW1lIHdlYlZpZXddIGZyYW1lXS5zaXplOwotICAgIHJl dHVybiBSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPihBZG9wdENGLCBDR0JpdG1hcENvbnRleHRDcmVh dGUoc2NyZWVuQ2FwdHVyZUJ1ZmZlciwgc3RhdGljX2Nhc3Q8c2l6ZV90Pih3ZWJWaWV3U2l6ZS53 aWR0aCksIHN0YXRpY19jYXN0PHNpemVfdD4od2ViVmlld1NpemUuaGVpZ2h0KSwgOCwgc3RhdGlj X2Nhc3Q8c2l6ZV90Pih3ZWJWaWV3U2l6ZS53aWR0aCkgKiA0LCBzaGFyZWRDb2xvclNwYWNlLCBr Q0dCaXRtYXBCeXRlT3JkZXIzMkhvc3QgfCBrQ0dJbWFnZUFscGhhUHJlbXVsdGlwbGllZExhc3Qp KTsKLX0KLQotdm9pZCBwYWludFdlYlZpZXcoQ0dDb250ZXh0UmVmIGNvbnRleHQpCi17Ci0gICAg UmV0YWluUHRyPE5TR3JhcGhpY3NDb250ZXh0PiBzYXZlZENvbnRleHQgPSBbTlNHcmFwaGljc0Nv bnRleHQgY3VycmVudENvbnRleHRdOwotCi0gICAgTlNHcmFwaGljc0NvbnRleHQqIG5zQ29udGV4 dCA9IFtOU0dyYXBoaWNzQ29udGV4dCBncmFwaGljc0NvbnRleHRXaXRoR3JhcGhpY3NQb3J0OmNv bnRleHQgZmxpcHBlZDpOT107Ci0gICAgW05TR3JhcGhpY3NDb250ZXh0IHNldEN1cnJlbnRDb250 ZXh0Om5zQ29udGV4dF07Ci0KICAgICBXZWJWaWV3KiB2aWV3ID0gW21haW5GcmFtZSB3ZWJWaWV3 XTsKLSAgICBbdmlldyBkaXNwbGF5SWZOZWVkZWRdOwotICAgIFt2aWV3IGxvY2tGb2N1c107Ci0g ICAgTlNCaXRtYXBJbWFnZVJlcCAqaW1hZ2VSZXAgPSBbW05TQml0bWFwSW1hZ2VSZXAgYWxsb2Nd IGluaXRXaXRoRm9jdXNlZFZpZXdSZWN0Olt2aWV3IGZyYW1lXV07Ci0gICAgW3ZpZXcgdW5sb2Nr Rm9jdXNdOwotICAgIFtpbWFnZVJlcCBkcmF3XTsKLSAgICBbaW1hZ2VSZXAgcmVsZWFzZV07Ci0K LSAgICBbTlNHcmFwaGljc0NvbnRleHQgc2V0Q3VycmVudENvbnRleHQ6c2F2ZWRDb250ZXh0Lmdl dCgpXTsKLX0KLQotdm9pZCByZXBhaW50V2ViVmlldyhDR0NvbnRleHRSZWYgY29udGV4dCwgYm9v bCBob3Jpem9udGFsKQotewotICAgIFJldGFpblB0cjxOU0dyYXBoaWNzQ29udGV4dD4gc2F2ZWRD b250ZXh0ID0gW05TR3JhcGhpY3NDb250ZXh0IGN1cnJlbnRDb250ZXh0XTsKLQotICAgIE5TR3Jh cGhpY3NDb250ZXh0KiBuc0NvbnRleHQgPSBbTlNHcmFwaGljc0NvbnRleHQgZ3JhcGhpY3NDb250 ZXh0V2l0aEdyYXBoaWNzUG9ydDpjb250ZXh0IGZsaXBwZWQ6Tk9dOwotICAgIFtOU0dyYXBoaWNz Q29udGV4dCBzZXRDdXJyZW50Q29udGV4dDpuc0NvbnRleHRdOwotCi0gICAgV2ViVmlldyAqdmll dyA9IFttYWluRnJhbWUgd2ViVmlld107CiAgICAgTlNTaXplIHdlYlZpZXdTaXplID0gW3ZpZXcg ZnJhbWVdLnNpemU7CisgICAgc2l6ZV90IHBpeGVsc1dpZGUgPSBzdGF0aWNfY2FzdDxzaXplX3Q+ KHdlYlZpZXdTaXplLndpZHRoKTsKKyAgICBzaXplX3QgcGl4ZWxzSGlnaCA9IHN0YXRpY19jYXN0 PHNpemVfdD4od2ViVmlld1NpemUuaGVpZ2h0KTsKKyAgICBzaXplX3Qgcm93Qnl0ZXMgPSAoNCAq IHBpeGVsc1dpZGUgKyA2MykgJiB+NjM7IC8vIFVzZSBhIG11bHRpcGxlIG9mIDY0IGJ5dGVzIHRv IGltcHJvdmUgQ0cgcGVyZm9ybWFuY2UKIAotICAgIGlmIChob3Jpem9udGFsKSB7Ci0gICAgICAg IGZvciAoTlNSZWN0IGNvbHVtbiA9IE5TTWFrZVJlY3QoMCwgMCwgMSwgd2ViVmlld1NpemUuaGVp Z2h0KTsgY29sdW1uLm9yaWdpbi54IDwgd2ViVmlld1NpemUud2lkdGg7IGNvbHVtbi5vcmlnaW4u eCsrKQotICAgICAgICAgICAgW3ZpZXcgZGlzcGxheVJlY3RJZ25vcmluZ09wYWNpdHk6Y29sdW1u IGluQ29udGV4dDpuc0NvbnRleHRdOwotICAgIH0gZWxzZSB7Ci0gICAgICAgIGZvciAoTlNSZWN0 IGxpbmUgPSBOU01ha2VSZWN0KDAsIDAsIHdlYlZpZXdTaXplLndpZHRoLCAxKTsgbGluZS5vcmln aW4ueSA8IHdlYlZpZXdTaXplLmhlaWdodDsgbGluZS5vcmlnaW4ueSsrKQotICAgICAgICAgICAg W3ZpZXcgZGlzcGxheVJlY3RJZ25vcmluZ09wYWNpdHk6bGluZSBpbkNvbnRleHQ6bnNDb250ZXh0 XTsKKyAgICB2b2lkKiBidWZmZXIgPSBjYWxsb2MocGl4ZWxzSGlnaCwgcm93Qnl0ZXMpOworICAg IGlmICghYnVmZmVyKQorICAgICAgICByZXR1cm4gMDsKKyAgICAKKyAgICBzdGF0aWMgQ0dDb2xv clNwYWNlUmVmIGNvbG9yU3BhY2UgPSAwOworICAgIGlmICghY29sb3JTcGFjZSkgeworICAgICAg ICBDTVByb2ZpbGVMb2NhdGlvbiBsb2NhdGlvbjsKKyAgICAgICAgbG9jYXRpb24ubG9jVHlwZSA9 IGNtRmlsZUJhc2VkUHJvZmlsZTsKKyAgICAgICAgTlNVUkwgKnVybCA9IFtOU1VSTCBmaWxlVVJM V2l0aFBhdGg6W05TU3RyaW5nIHN0cmluZ1dpdGhVVEY4U3RyaW5nOlBST0ZJTEVfUEFUSF1dOwor ICAgICAgICBGU1JlZiBmc1JlZjsKKyAgICAgICAgaWYgKHVybCAmJiBDRlVSTEdldEZTUmVmKChD RlVSTFJlZil1cmwsICZmc1JlZikpIHsKKyAgICAgICAgICAgIGlmIChGU0dldENhdGFsb2dJbmZv KCZmc1JlZiwgMCwgTlVMTCwgTlVMTCwgJmxvY2F0aW9uLnUuZmlsZUxvYy5zcGVjLCBOVUxMKSA9 PSBub0VycikgeworICAgICAgICAgICAgICAgIENNUHJvZmlsZVJlZiBwcm9maWxlOworICAgICAg ICAgICAgICAgIGlmIChDTU9wZW5Qcm9maWxlKCZwcm9maWxlLCAmbG9jYXRpb24pID09IG5vRXJy KSB7CisgICAgICAgICAgICAgICAgICAgIGNvbG9yU3BhY2UgPSBDR0NvbG9yU3BhY2VDcmVhdGVX aXRoUGxhdGZvcm1Db2xvclNwYWNlKHByb2ZpbGUpOworICAgICAgICAgICAgICAgICAgICBDTUNs b3NlUHJvZmlsZShwcm9maWxlKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9Cisg ICAgICAgIH0KKyAgICB9CisgICAgCisgICAgQ0dDb250ZXh0UmVmIGNvbnRleHQgPSBDR0JpdG1h cENvbnRleHRDcmVhdGUoYnVmZmVyLCBwaXhlbHNXaWRlLCBwaXhlbHNIaWdoLCA4LCByb3dCeXRl cywgY29sb3JTcGFjZSwga0NHSW1hZ2VBbHBoYVByZW11bHRpcGxpZWRGaXJzdCB8IGtDR0JpdG1h cEJ5dGVPcmRlcjMySG9zdCk7IC8vIFVzZSBBUkdCOCBvbiBQUEMgb3IgQkdSQTggb24gWDg2IHRv IGltcHJvdmUgQ0cgcGVyZm9ybWFuY2UKKyAgICBpZiAoIWNvbnRleHQpIHsKKyAgICAgICAgZnJl ZShidWZmZXIpOworICAgICAgICByZXR1cm4gMDsKICAgICB9CiAKLSAgICBbTlNHcmFwaGljc0Nv bnRleHQgc2V0Q3VycmVudENvbnRleHQ6c2F2ZWRDb250ZXh0LmdldCgpXTsKLX0KKyAgICAvLyBU aGUgQml0bWFwQ29udGV4dCBrZWVwcyB0aGUgQ0dDb250ZXh0UmVmIGFuZCB0aGUgcGl4ZWwgYnVm ZmVyIGFsaXZlCisgICAgUmVmUHRyPEJpdG1hcENvbnRleHQ+IGJpdG1hcENvbnRleHQgPSBCaXRt YXBDb250ZXh0OjpjcmVhdGUoYnVmZmVyLCBjb250ZXh0KTsKKyAgICAKKyAgICBOU0dyYXBoaWNz Q29udGV4dCAqbnNDb250ZXh0ID0gW05TR3JhcGhpY3NDb250ZXh0IGdyYXBoaWNzQ29udGV4dFdp dGhHcmFwaGljc1BvcnQ6Y29udGV4dCBmbGlwcGVkOk5PXTsKKyAgICBBU1NFUlQobnNDb250ZXh0 KTsKKyAgICAKKyAgICBpZiAoaW5jcmVtZW50YWxSZXBhaW50KSB7CisgICAgICAgIGlmIChzd2Vl cEhvcml6b250YWxseSkgeworICAgICAgICAgICAgZm9yIChOU1JlY3QgY29sdW1uID0gTlNNYWtl UmVjdCgwLCAwLCAxLCB3ZWJWaWV3U2l6ZS5oZWlnaHQpOyBjb2x1bW4ub3JpZ2luLnggPCB3ZWJW aWV3U2l6ZS53aWR0aDsgY29sdW1uLm9yaWdpbi54KyspCisgICAgICAgICAgICAgICAgW3ZpZXcg ZGlzcGxheVJlY3RJZ25vcmluZ09wYWNpdHk6Y29sdW1uIGluQ29udGV4dDpuc0NvbnRleHRdOwor ICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgZm9yIChOU1JlY3QgbGluZSA9IE5TTWFrZVJl Y3QoMCwgMCwgd2ViVmlld1NpemUud2lkdGgsIDEpOyBsaW5lLm9yaWdpbi55IDwgd2ViVmlld1Np emUuaGVpZ2h0OyBsaW5lLm9yaWdpbi55KyspCisgICAgICAgICAgICAgICAgW3ZpZXcgZGlzcGxh eVJlY3RJZ25vcmluZ09wYWNpdHk6bGluZSBpbkNvbnRleHQ6bnNDb250ZXh0XTsKKyAgICAgICAg fQorICAgIH0gZWxzZSB7CisgICAgICAgIGlmIChvbnNjcmVlbikgeworI2lmZGVmIEJVSUxESU5H X09OX0xFT1BBUkQKKyAgICAgICAgICAgIC8vIEFzayB0aGUgd2luZG93IHNlcnZlciB0byBwcm92 aWRlIHVzIGEgY29tcG9zaXRlZCB2ZXJzaW9uIG9mIHRoZSAqcmVhbCogd2luZG93IGNvbnRlbnQg aW5jbHVkaW5nIHN1cmZhY2VzIChpLmUuIE9wZW5HTCBjb250ZW50KQorICAgICAgICAgICAgLy8g Tm90ZSB0aGF0IHRoZSByZXR1cm5lZCBpbWFnZSBtaWdodCBkaWZmZXIgdmVyeSBzbGlnaHRseSBm cm9tIHRoZSB3aW5kb3cgYmFja2luZyBiZWNhdXNlIG9mIGRpdGhlcmluZyBhcnRpZmFjdHMgaW4g dGhlIHdpbmRvdyBzZXJ2ZXIgY29tcG9zaXRvcgorICAgICAgICAgICAgCisgICAgICAgICAgICBD R0ltYWdlUmVmIGltYWdlID0gQ0dXaW5kb3dMaXN0Q3JlYXRlSW1hZ2UoQ0dSZWN0TnVsbCwga0NH V2luZG93TGlzdE9wdGlvbkluY2x1ZGluZ1dpbmRvdywgW1t2aWV3IHdpbmRvd10gd2luZG93TnVt YmVyXSwga0NHV2luZG93SW1hZ2VCb3VuZHNJZ25vcmVGcmFtaW5nIHwga0NHV2luZG93SW1hZ2VT aG91bGRCZU9wYXF1ZSk7CisgICAgICAgICAgICBDR0NvbnRleHREcmF3SW1hZ2UoY29udGV4dCwg Q0dSZWN0TWFrZSgwLCAwLCBDR0ltYWdlR2V0V2lkdGgoaW1hZ2UpLCBDR0ltYWdlR2V0SGVpZ2h0 KGltYWdlKSksIGltYWdlKTsKKyAgICAgICAgICAgIENHSW1hZ2VSZWxlYXNlKGltYWdlKTsKKyNl bHNlCisgICAgICAgICAgICAvLyBPbiAxMC40IGFuZCBlYXJsaWVyLCB3ZSBoYXZlIHRvIG1vdmUg dGhlIHdpbmRvdyB0ZW1wb3JhcmlseSAib25zY3JlZW4iIGFuZCByZWFkIGRpcmVjdGx5IGZyb20g dGhlIGRpc3BsYXkgZnJhbWVidWZmZXIgdXNpbmcgT3BlbkdMCisgICAgICAgICAgICAvLyBJbiB0 aGlzIGNvZGUgcGF0aCwgd2UgbmVlZCB0byBlbnN1cmUgdGhlIHdpbmRvdyBpcyBhYm92ZSBhbnkg b3RoZXIgd2luZG93IG9yIGNhcHR1cmVkIHJlc3VsdCB3aWxsIGJlIGNvcnJ1cHRlZAorICAgICAg ICAgICAgCisgICAgICAgICAgICBOU1dpbmRvdyAqd2luZG93ID0gW3ZpZXcgd2luZG93XTsKKyAg ICAgICAgICAgIGludCBvbGRMZXZlbCA9IFt3aW5kb3cgbGV2ZWxdOworICAgICAgICAgICAgTlNS ZWN0IG9sZEZyYW1lID0gW3dpbmRvdyBmcmFtZV07CisgICAgICAgICAgICAKKyAgICAgICAgICAg IE5TUmVjdCBuZXdGcmFtZSA9IFtbW05TU2NyZWVuIHNjcmVlbnNdIG9iamVjdEF0SW5kZXg6MF0g ZnJhbWVdOworICAgICAgICAgICAgbmV3RnJhbWUgPSBOU01ha2VSZWN0KG5ld0ZyYW1lLm9yaWdp bi54ICsgKG5ld0ZyYW1lLnNpemUud2lkdGggLSBvbGRGcmFtZS5zaXplLndpZHRoKSAvIDIsIG5l d0ZyYW1lLm9yaWdpbi55ICsgKG5ld0ZyYW1lLnNpemUuaGVpZ2h0IC0gb2xkRnJhbWUuc2l6ZS5o ZWlnaHQpIC8gMiwgb2xkRnJhbWUuc2l6ZS53aWR0aCwgb2xkRnJhbWUuc2l6ZS5oZWlnaHQpOwor ICAgICAgICAgICAgW3dpbmRvdyBzZXRMZXZlbDpOU1NjcmVlblNhdmVyV2luZG93TGV2ZWxdOwor ICAgICAgICAgICAgW3dpbmRvdyBzZXRGcmFtZTpuZXdGcmFtZSBkaXNwbGF5Ok5PIGFuaW1hdGU6 Tk9dOworICAgICAgICAgICAgCisgICAgICAgICAgICBDR1JlY3QgcmVjdCA9IENHUmVjdE1ha2Uo bmV3RnJhbWUub3JpZ2luLngsIG5ld0ZyYW1lLm9yaWdpbi55LCB3ZWJWaWV3U2l6ZS53aWR0aCwg d2ViVmlld1NpemUuaGVpZ2h0KTsKKyAgICAgICAgICAgIENHRGlyZWN0RGlzcGxheUlEIGRpc3Bs YXlJRDsKKyAgICAgICAgICAgIENHRGlzcGxheUNvdW50IGNvdW50OworICAgICAgICAgICAgaWYg KENHR2V0RGlzcGxheXNXaXRoUmVjdChyZWN0LCAxLCAmZGlzcGxheUlELCAmY291bnQpID09IGtD R0Vycm9yU3VjY2VzcykgeworICAgICAgICAgICAgICAgIENHUmVjdCBib3VuZHMgPSBDR0Rpc3Bs YXlCb3VuZHMoZGlzcGxheUlEKTsKKyAgICAgICAgICAgICAgICByZWN0Lm9yaWdpbi54IC09IGJv dW5kcy5vcmlnaW4ueDsKKyAgICAgICAgICAgICAgICByZWN0Lm9yaWdpbi55IC09IGJvdW5kcy5v cmlnaW4ueTsKKyAgICAgICAgICAgICAgICAKKyAgICAgICAgICAgICAgICBDR0xQaXhlbEZvcm1h dEF0dHJpYnV0ZSBhdHRyaWJ1dGVzW10gPSB7a0NHTFBGQUFjY2VsZXJhdGVkLCBrQ0dMUEZBTm9S ZWNvdmVyeSwga0NHTFBGQUZ1bGxTY3JlZW4sIGtDR0xQRkFEaXNwbGF5TWFzaywgKENHTFBpeGVs Rm9ybWF0QXR0cmlidXRlKUNHRGlzcGxheUlEVG9PcGVuR0xEaXNwbGF5TWFzayhkaXNwbGF5SUQp LCAoQ0dMUGl4ZWxGb3JtYXRBdHRyaWJ1dGUpMH07CisgICAgICAgICAgICAgICAgQ0dMUGl4ZWxG b3JtYXRPYmogcGl4ZWxGb3JtYXQ7CisgICAgICAgICAgICAgICAgR0xpbnQgbnVtOworICAgICAg ICAgICAgICAgIGlmIChDR0xDaG9vc2VQaXhlbEZvcm1hdChhdHRyaWJ1dGVzLCAmcGl4ZWxGb3Jt YXQsICZudW0pID09IGtDR0xOb0Vycm9yKSB7CisgICAgICAgICAgICAgICAgICAgIENHTENvbnRl eHRPYmogY2dsX2N0eDsKKyAgICAgICAgICAgICAgICAgICAgaWYgKENHTENyZWF0ZUNvbnRleHQo cGl4ZWxGb3JtYXQsIE5VTEwsICZjZ2xfY3R4KSA9PSBrQ0dMTm9FcnJvcikgeworICAgICAgICAg ICAgICAgICAgICAgICAgaWYgKENHTFNldEZ1bGxTY3JlZW4oY2dsX2N0eCkgPT0ga0NHTE5vRXJy b3IpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICB2b2lkICpmbGlwQnVmZmVyID0gY2Fs bG9jKHBpeGVsc0hpZ2gsIHJvd0J5dGVzKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBp ZiAoZmxpcEJ1ZmZlcikgeworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnbFBpeGVs U3RvcmVpKEdMX1BBQ0tfUk9XX0xFTkdUSCwgcm93Qnl0ZXMgLyA0KTsKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgZ2xQaXhlbFN0b3JlaShHTF9QQUNLX0FMSUdOTUVOVCwgNCk7Cisj aWYgX19CSUdfRU5ESUFOX18KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2xSZWFk UGl4ZWxzKHJlY3Qub3JpZ2luLngsIHJlY3Qub3JpZ2luLnksIHJlY3Quc2l6ZS53aWR0aCwgcmVj dC5zaXplLmhlaWdodCwgR0xfUkdCQSwgR0xfVU5TSUdORURfSU5UXzhfOF84XzgsIGZsaXBCdWZm ZXIpOworI2Vsc2UKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2xSZWFkUGl4ZWxz KHJlY3Qub3JpZ2luLngsIHJlY3Qub3JpZ2luLnksIHJlY3Quc2l6ZS53aWR0aCwgcmVjdC5zaXpl LmhlaWdodCwgR0xfUkdCQSwgR0xfVU5TSUdORURfSU5UXzhfOF84XzhfUkVWLCBmbGlwQnVmZmVy KTsKKyNlbmRpZgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpZiAoIWdsR2V0RXJy b3IoKSkgeworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZm9yKHNpemVfdCBp ID0gMDsgaSA8IHBpeGVsc0hpZ2g7ICsraSkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGJjb3B5KChjaGFyKilmbGlwQnVmZmVyICsgcm93Qnl0ZXMgKiBpLCAoY2hhciopYnVm ZmVyICsgcm93Qnl0ZXMgKiAocGl4ZWxzSGlnaCAtIGkgLSAxKSwgcGl4ZWxzV2lkZSAqIDQpOwor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmcmVlKGZsaXBCdWZm ZXIpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAg ICAgIH0KKyAgICAgICAgICAgICAgICAgICAgICAgIENHTERlc3Ryb3lDb250ZXh0KGNnbF9jdHgp OworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgIENHTERlc3Ryb3lQ aXhlbEZvcm1hdChwaXhlbEZvcm1hdCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAg fQorICAgICAgICAgICAgCisgICAgICAgICAgICBbd2luZG93IHNldEZyYW1lOm9sZEZyYW1lIGRp c3BsYXk6Tk8gYW5pbWF0ZTpOT107CisgICAgICAgICAgICBbd2luZG93IHNldExldmVsOm9sZExl dmVsXTsKKyNlbmRpZgorICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgLy8gR3JhYiBkaXJl Y3RseSB0aGUgY29udGVudHMgb2YgdGhlIHdpbmRvdyBiYWNraW5nIGJ1ZmZlciAodGhpcyBpZ25v cmVzIGFueSBzdXJmYWNlcyBvbiB0aGUgd2luZG93KQorICAgICAgICAgICAgLy8gRklYTUU6IFRo aXMgcGF0aCBpcyBzdWJvcHRpbWFsOiBkYXRhIGlzIHJlYWQgZnJvbSB3aW5kb3cgYmFja2luZyBz dG9yZSwgY29udmVydGVkIHRvIFJHQjggdGhlbiBkcmF3biBhZ2FpbiBpbnRvIGFuIFJHQkE4IGJp dG1hcAorICAgICAgICAgICAgCisgICAgICAgICAgICBbdmlldyBkaXNwbGF5SWZOZWVkZWRdOwor ICAgICAgICAgICAgW3ZpZXcgbG9ja0ZvY3VzXTsKKyAgICAgICAgICAgIE5TQml0bWFwSW1hZ2VS ZXAgKmltYWdlUmVwID0gW1tbTlNCaXRtYXBJbWFnZVJlcCBhbGxvY10gaW5pdFdpdGhGb2N1c2Vk Vmlld1JlY3Q6W3ZpZXcgZnJhbWVdXSBhdXRvcmVsZWFzZV07CisgICAgICAgICAgICBbdmlldyB1 bmxvY2tGb2N1c107CiAKLUNHUmVjdCBnZXRTZWxlY3Rpb25SZWN0KCkKLXsKLSAgICBOU1ZpZXcg KmRvY3VtZW50VmlldyA9IFtbbWFpbkZyYW1lIGZyYW1lVmlld10gZG9jdW1lbnRWaWV3XTsKLSAg ICBpZiAoW2RvY3VtZW50VmlldyBjb25mb3Jtc1RvUHJvdG9jb2w6QHByb3RvY29sKFdlYkRvY3Vt ZW50U2VsZWN0aW9uKV0pIHsKLSAgICAgICAgTlNSZWN0IHJlY3QgPSBbZG9jdW1lbnRWaWV3IGNv bnZlcnRSZWN0OlsoaWQgPFdlYkRvY3VtZW50U2VsZWN0aW9uPilkb2N1bWVudFZpZXcgc2VsZWN0 aW9uUmVjdF0gZnJvbVZpZXc6bmlsXTsKLSAgICAgICAgcmV0dXJuIENHUmVjdE1ha2UocmVjdC5v cmlnaW4ueCwgcmVjdC5vcmlnaW4ueSwgcmVjdC5zaXplLndpZHRoLCByZWN0LnNpemUuaGVpZ2h0 KTsKKyAgICAgICAgICAgIFJldGFpblB0cjxOU0dyYXBoaWNzQ29udGV4dD4gc2F2ZWRDb250ZXh0 ID0gW05TR3JhcGhpY3NDb250ZXh0IGN1cnJlbnRDb250ZXh0XTsKKyAgICAgICAgICAgIFtOU0dy YXBoaWNzQ29udGV4dCBzZXRDdXJyZW50Q29udGV4dDpuc0NvbnRleHRdOworICAgICAgICAgICAg W2ltYWdlUmVwIGRyYXddOworICAgICAgICAgICAgW05TR3JhcGhpY3NDb250ZXh0IHNldEN1cnJl bnRDb250ZXh0OnNhdmVkQ29udGV4dC5nZXQoKV07CisgICAgICAgIH0KICAgICB9CiAKLSAgICBB U1NFUlRfTk9UX1JFQUNIRUQoKTsKLSAgICByZXR1cm4gQ0dSZWN0WmVybzsKKyAgICBpZiAoZHJh d1NlbGVjdGlvblJlY3QpIHsKKyAgICAgICAgTlNWaWV3ICpkb2N1bWVudFZpZXcgPSBbW21haW5G cmFtZSBmcmFtZVZpZXddIGRvY3VtZW50Vmlld107CisgICAgICAgIGlmIChbZG9jdW1lbnRWaWV3 IGNvbmZvcm1zVG9Qcm90b2NvbDpAcHJvdG9jb2woV2ViRG9jdW1lbnRTZWxlY3Rpb24pXSkgewor ICAgICAgICAgICAgTlNSZWN0IHJlY3QgPSBbZG9jdW1lbnRWaWV3IGNvbnZlcnRSZWN0OlsoaWQg PFdlYkRvY3VtZW50U2VsZWN0aW9uPilkb2N1bWVudFZpZXcgc2VsZWN0aW9uUmVjdF0gZnJvbVZp ZXc6bmlsXTsKKyAgICAgICAgICAgIAorICAgICAgICAgICAgQ0dDb250ZXh0U2F2ZUdTdGF0ZShj b250ZXh0KTsKKyAgICAgICAgICAgIENHQ29udGV4dFNldExpbmVXaWR0aChjb250ZXh0LCAxLjAp OworICAgICAgICAgICAgQ0dDb250ZXh0U2V0UkdCU3Ryb2tlQ29sb3IoY29udGV4dCwgMS4wLCAw LjAsIDAuMCwgMS4wKTsKKyAgICAgICAgICAgIENHQ29udGV4dFN0cm9rZVJlY3QoY29udGV4dCwg Q0dSZWN0TWFrZShyZWN0Lm9yaWdpbi54LCByZWN0Lm9yaWdpbi55LCByZWN0LnNpemUud2lkdGgs IHJlY3Quc2l6ZS5oZWlnaHQpKTsKKyAgICAgICAgICAgIENHQ29udGV4dFJlc3RvcmVHU3RhdGUo Y29udGV4dCk7CisgICAgICAgIH0KKyAgICAgICAgZWxzZQorICAgICAgICAgICAgQVNTRVJUX05P VF9SRUFDSEVEKCk7CisgICAgfQorICAgIAorICAgIHJldHVybiBiaXRtYXBDb250ZXh0LnJlbGVh c2UoKTsKIH0KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1w UmVuZGVyVHJlZS5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRl clRyZWUuY3BwCmluZGV4IDFjZTMxZGUuLjJjYmJkYTEgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAKKysrIGIvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcApAQCAtNDYsNyArNDYsNyBAQAog I2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmg+CiAjaW5jbHVkZSA8bWF0 aC5oPgogI2luY2x1ZGUgPHB0aHJlYWQuaD4KLSNpbmNsdWRlIDxzdHJpbmc+CisjaW5jbHVkZSA8 c3RyaW5nLmg+CiAjaW5jbHVkZSA8dGNoYXIuaD4KICNpbmNsdWRlIDxXZWJLaXQvRm9yRWFjaENv Q2xhc3MuaD4KICNpbmNsdWRlIDxXZWJLaXQvV2ViS2l0Lmg+CkBAIC03OCw4ICs3OCw2IEBAIHN0 YXRpYyBib29sIHRocmVhZGVkID0gZmFsc2U7CiBzdGF0aWMgYm9vbCBmb3JjZUNvbXBsZXhUZXh0 ID0gZmFsc2U7CiBzdGF0aWMgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBwZXJzaXN0ZW50VXNlclN0 eWxlU2hlZXRMb2NhdGlvbjsKIAotc3RhdGljIGNvbnN0IGNoYXIqIGN1cnJlbnRUZXN0OwotCiB2 b2xhdGlsZSBib29sIGRvbmU7CiAvLyBUaGlzIGlzIHRoZSB0b3Btb3N0IGZyYW1lIHRoYXQgaXMg bG9hZGluZywgZHVyaW5nIGEgZ2l2ZW4gbG9hZCwgb3IgbmlsIHdoZW4gbm8gbG9hZCBpcyAKIC8v IGluIHByb2dyZXNzLiAgVXN1YWxseSB0aGlzIGlzIHRoZSBzYW1lIGFzIHRoZSBtYWluIGZyYW1l LCBidXQgbm90IGFsd2F5cy4gIEluIHRoZSBjYXNlCkBAIC01NjIsNyArNTYwLDcgQEAgdm9pZCBk dW1wKCkKICAgICAgICAgICAgIHdzdHJpbmcgcmVzdWx0ID0gZHVtcEZyYW1lc0FzVGV4dChmcmFt ZSk7CiAgICAgICAgICAgICByZXN1bHRTdHJpbmcgPSBTeXNBbGxvY1N0cmluZ0xlbihyZXN1bHQu ZGF0YSgpLCByZXN1bHQuc2l6ZSgpKTsKICAgICAgICAgfSBlbHNlIHsKLSAgICAgICAgICAgIGJv b2wgaXNTVkdXM0NUZXN0ID0gc3Ryc3RyKGN1cnJlbnRUZXN0LCAic3ZnXFxXM0MtU1ZHLTEuMSIp OworICAgICAgICAgICAgYm9vbCBpc1NWR1czQ1Rlc3QgPSAoZ0xheW91dFRlc3RDb250cm9sbGVy LT50ZXN0UGF0aE9yVVJMKCkuZmluZCgic3ZnXFxXM0MtU1ZHLTEuMSIpICE9IHN0ZDo6c3RyaW5n OjpucG9zKTsKICAgICAgICAgICAgIHVuc2lnbmVkIHdpZHRoOwogICAgICAgICAgICAgdW5zaWdu ZWQgaGVpZ2h0OwogICAgICAgICAgICAgaWYgKGlzU1ZHVzNDVGVzdCkgewpAQCAtNjA4LDcgKzYw Niw3IEBAIHZvaWQgZHVtcCgpCiAKICAgICBpZiAoZHVtcFBpeGVscykgewogICAgICAgICBpZiAo IWdMYXlvdXRUZXN0Q29udHJvbGxlci0+ZHVtcEFzVGV4dCgpICYmICFnTGF5b3V0VGVzdENvbnRy b2xsZXItPmR1bXBET01Bc1dlYkFyY2hpdmUoKSAmJiAhZ0xheW91dFRlc3RDb250cm9sbGVyLT5k dW1wU291cmNlQXNXZWJBcmNoaXZlKCkpCi0gICAgICAgICAgICBkdW1wV2ViVmlld0FzUGl4ZWxz QW5kQ29tcGFyZVdpdGhFeHBlY3RlZChjdXJyZW50VGVzdCwgZHVtcEFsbFBpeGVscyk7CisgICAg ICAgICAgICBkdW1wV2ViVmlld0FzUGl4ZWxzQW5kQ29tcGFyZVdpdGhFeHBlY3RlZChnTGF5b3V0 VGVzdENvbnRyb2xsZXItPmV4cGVjdGVkUGl4ZWxIYXNoKCkpOwogICAgIH0KIAogICAgIHByaW50 ZigiI0VPRlxuIik7ICAgLy8gdGVybWluYXRlIHRoZSAocG9zc2libHkgZW1wdHkpIHBpeGVscyBi bG9jawpAQCAtNjc1LDEzICs2NzMsMjMgQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25z aXN0ZW50U3RhdGVCZWZvcmVUZXN0aW5nKCkKICAgICB3ZWJWaWV3UHJpdmF0ZS0+Y2xlYXJNYWlu RnJhbWVOYW1lKCk7CiB9CiAKLXN0YXRpYyB2b2lkIHJ1blRlc3QoY29uc3QgY2hhciogcGF0aE9y VVJMKQorc3RhdGljIHZvaWQgcnVuVGVzdChjb25zdCBzdGQ6OnN0cmluZyYgdGVzdFBhdGhPclVS TCkKIHsKICAgICBzdGF0aWMgQlNUUiBtZXRob2RCU3RyID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgi R0VUIikpOwogCisgICAgLy8gTG9vayBmb3IgIiciIGFzIGEgc2VwYXJhdG9yIGJldHdlZW4gdGhl IHBhdGggb3IgVVJMLCBhbmQgdGhlIHBpeGVsIGR1bXAgaGFzaCB0aGF0IGZvbGxvd3MuCisgICAg c3RkOjpzdHJpbmcgcGF0aE9yVVJMKHRlc3RQYXRoT3JVUkwpOworICAgIHN0ZDo6c3RyaW5nIGV4 cGVjdGVkUGl4ZWxIYXNoOworICAgIAorICAgIHNpemVfdCBzZXBhcmF0b3JQb3MgPSBwYXRoT3JV UkwuZmluZCgiJyIpOworICAgIGlmIChzZXBhcmF0b3JQb3MgIT0gc3RkOjpzdHJpbmc6Om5wb3Mp IHsKKyAgICAgICAgcGF0aE9yVVJMID0gc3RkOjpzdHJpbmcodGVzdFBhdGhPclVSTCwgMCwgc2Vw YXJhdG9yUG9zKTsKKyAgICAgICAgZXhwZWN0ZWRQaXhlbEhhc2ggPSBzdGQ6OnN0cmluZyh0ZXN0 UGF0aE9yVVJMLCBzZXBhcmF0b3JQb3MgKyAxKTsKKyAgICB9CisgICAgCiAgICAgQlNUUiB1cmxC U3RyOwogIAotICAgIENGU3RyaW5nUmVmIHN0ciA9IENGU3RyaW5nQ3JlYXRlV2l0aENTdHJpbmco MCwgcGF0aE9yVVJMLCBrQ0ZTdHJpbmdFbmNvZGluZ1dpbmRvd3NMYXRpbjEpOworICAgIENGU3Ry aW5nUmVmIHN0ciA9IENGU3RyaW5nQ3JlYXRlV2l0aENTdHJpbmcoMCwgcGF0aE9yVVJMLmNfc3Ry KCksIGtDRlN0cmluZ0VuY29kaW5nV2luZG93c0xhdGluMSk7CiAgICAgQ0ZVUkxSZWYgdXJsID0g Q0ZVUkxDcmVhdGVXaXRoU3RyaW5nKDAsIHN0ciwgMCk7CiAKICAgICBpZiAoIXVybCkKQEAgLTcw MCwxMyArNzA4LDExIEBAIHN0YXRpYyB2b2lkIHJ1blRlc3QoY29uc3QgY2hhciogcGF0aE9yVVJM KQogCiAgICAgQ0ZSZWxlYXNlKHVybCk7CiAKLSAgICBjdXJyZW50VGVzdCA9IHBhdGhPclVSTDsK LQotICAgIDo6Z0xheW91dFRlc3RDb250cm9sbGVyID0gbmV3IExheW91dFRlc3RDb250cm9sbGVy KGZhbHNlLCBmYWxzZSk7CisgICAgOjpnTGF5b3V0VGVzdENvbnRyb2xsZXIgPSBuZXcgTGF5b3V0 VGVzdENvbnRyb2xsZXIocGF0aE9yVVJMLCBleHBlY3RlZFBpeGVsSGFzaCk7CiAgICAgZG9uZSA9 IGZhbHNlOwogICAgIHRvcExvYWRpbmdGcmFtZSA9IDA7CiAKLSAgICBpZiAoc2hvdWxkTG9nRnJh bWVMb2FkRGVsZWdhdGVzKHBhdGhPclVSTCkpCisgICAgaWYgKHNob3VsZExvZ0ZyYW1lTG9hZERl bGVnYXRlcyhwYXRoT3JVUkwuY19zdHIoKSkpCiAgICAgICAgIGdMYXlvdXRUZXN0Q29udHJvbGxl ci0+c2V0RHVtcEZyYW1lTG9hZENhbGxiYWNrcyh0cnVlKTsKIAogICAgIENPTVB0cjxJV2ViSGlz dG9yeT4gaGlzdG9yeShDcmVhdGUsIENMU0lEX1dlYkhpc3RvcnkpOwpkaWZmIC0tZ2l0IGEvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL1BpeGVsRHVtcFN1cHBvcnRXaW4uY3BwIGIvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL1BpeGVsRHVtcFN1cHBvcnRXaW4uY3BwCmluZGV4 IDJmMjMxNTguLmJmZDE1MzMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L3dpbi9QaXhlbER1bXBTdXBwb3J0V2luLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS93aW4vUGl4ZWxEdW1wU3VwcG9ydFdpbi5jcHAKQEAgLTM0LDcgKzM0LDcgQEAKICNpbmNs dWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgogI2luY2x1ZGUgPHd0Zi9SZXRhaW5QdHIuaD4KIAotUmV0 YWluUHRyPENHQ29udGV4dFJlZj4gZ2V0Qml0bWFwQ29udGV4dEZyb21XZWJWaWV3KCkKK1Bhc3NS ZWZQdHI8Qml0bWFwQ29udGV4dD4gZ2V0Qml0bWFwQ29udGV4dEZyb21XZWJWaWV3KGJvb2wgb25z Y3JlZW4sIGJvb2wgaW5jcmVtZW50YWxSZXBhaW50LCBib29sIHN3ZWVwSG9yaXpvbnRhbGx5LCBi b29sIGRyYXdTZWxlY3Rpb25SZWN0KQogewogICAgIFJFQ1QgZnJhbWU7CiAgICAgaWYgKCFHZXRX aW5kb3dSZWN0KHdlYlZpZXdXaW5kb3csICZmcmFtZSkpCkBAIC00OCw4ICs0OCw2IEBAIFJldGFp blB0cjxDR0NvbnRleHRSZWY+IGdldEJpdG1hcENvbnRleHRGcm9tV2ViVmlldygpCiAgICAgYm1w LmJtaUhlYWRlci5iaUJpdENvdW50ID0gMzI7CiAgICAgYm1wLmJtaUhlYWRlci5iaUNvbXByZXNz aW9uID0gQklfUkdCOwogCi0gICAgLy8gRklYTUU6IEN1cnJlbnRseSB3ZSBsZWFrIHRoaXMgSEJJ VE1BUCBiZWNhdXNlIHdlIGRvbid0IGhhdmUgYSBnb29kIHdheQotICAgIC8vIHRvIGRlc3Ryb3kg aXQgd2hlbiB0aGUgQ0dCaXRtYXBDb250ZXh0IGdldHMgZGVzdHJveWVkLgogICAgIHZvaWQqIGJp dHMgPSAwOwogICAgIEhCSVRNQVAgYml0bWFwID0gQ3JlYXRlRElCU2VjdGlvbigwLCAmYm1wLCBE SUJfUkdCX0NPTE9SUywgJmJpdHMsIDAsIDApOwogCkBAIC02Myw2ICs2MSw4IEBAIFJldGFpblB0 cjxDR0NvbnRleHRSZWY+IGdldEJpdG1hcENvbnRleHRGcm9tV2ViVmlldygpCiAgICAgQVNTRVJU KGluZm8uYm1CaXRzUGl4ZWwgPT0gMzIpOwogCiAgICAgUmV0YWluUHRyPENHQ29sb3JTcGFjZVJl Zj4gY29sb3JTcGFjZShBZG9wdENGLCBDR0NvbG9yU3BhY2VDcmVhdGVEZXZpY2VSR0IoKSk7Ci0g ICAgcmV0dXJuIFJldGFpblB0cjxDR0NvbnRleHRSZWY+KEFkb3B0Q0YsIENHQml0bWFwQ29udGV4 dENyZWF0ZShpbmZvLmJtQml0cywgaW5mby5ibVdpZHRoLCBpbmZvLmJtSGVpZ2h0LCA4LAotICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW5mby5ibVdpZHRo Qnl0ZXMsIGNvbG9yU3BhY2UuZ2V0KCksIGtDR0JpdG1hcEJ5dGVPcmRlcjMyTGl0dGxlIHwga0NH SW1hZ2VBbHBoYVByZW11bHRpcGxpZWRGaXJzdCkpOworICAgIENHQ29udGV4dFJlZiBjb250ZXh0 ID0gQ0dCaXRtYXBDb250ZXh0Q3JlYXRlKGluZm8uYm1CaXRzLCBpbmZvLmJtV2lkdGgsIGluZm8u Ym1IZWlnaHQsIDgsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBpbmZvLmJtV2lkdGhCeXRlcywgY29sb3JTcGFjZS5nZXQoKSwga0NHQml0bWFwQnl0ZU9y ZGVyMzJMaXR0bGUgfCBrQ0dJbWFnZUFscGhhUHJlbXVsdGlwbGllZEZpcnN0KTsKKworICAgIHJl dHVybiBCaXRtYXBDb250ZXh0OjpjcmVhdGUoYml0bWFwLCBjb250ZXh0KTsKIH0KZGlmZiAtLWdp dCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvcnVuLXdlYmtpdC10ZXN0cyBiL1dlYktpdFRvb2xzL1Nj cmlwdHMvcnVuLXdlYmtpdC10ZXN0cwppbmRleCAyYmIxMDk2Li41MzIzNTRhIDEwMDc1NQotLS0g YS9XZWJLaXRUb29scy9TY3JpcHRzL3J1bi13ZWJraXQtdGVzdHMKKysrIGIvV2ViS2l0VG9vbHMv U2NyaXB0cy9ydW4td2Via2l0LXRlc3RzCkBAIC0xMTIsOCArMTEyLDYgQEAgbXkgJGxhdW5jaFNh ZmFyaSA9IDE7CiBteSAkcGxhdGZvcm07CiBteSAkcGl4ZWxUZXN0cyA9ICcnOwogbXkgJHF1aWV0 ID0gJyc7Ci1teSAkcmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5ID0gJyc7Ci1teSAkcmVwYWludFRl c3RzID0gJyc7CiBteSAkcmVwb3J0MTBTbG93ZXN0ID0gMDsKIG15ICRyZXNldFJlc3VsdHMgPSAw OwogbXkgJHNob3VsZENoZWNrTGVha3MgPSAwOwpAQCAtMTIzLDcgKzEyMSw3IEBAIG15ICR0ZXN0 SFRUUCA9IDE7CiBteSAkdGVzdE1lZGlhID0gMTsKIG15ICR0ZXN0UmVzdWx0c0RpcmVjdG9yeSA9 ICIvdG1wL2xheW91dC10ZXN0LXJlc3VsdHMiOwogbXkgJHRocmVhZGVkID0gMDsKLW15ICR0aHJl c2hvbGQgPSAwOworbXkgJHRvbGVyYW5jZSA9IDA7CiBteSAkdHJlYXRTa2lwcGVkID0gImRlZmF1 bHQiOwogbXkgJHZlcmJvc2UgPSAwOwogbXkgJHVzZVZhbGdyaW5kID0gMDsKQEAgLTE4MCwxNyAr MTc4LDE2IEBAIFVzYWdlOiAkcHJvZ3JhbU5hbWUgW29wdGlvbnNdIFt0ZXN0ZGlyfHRlc3RwYXRo IC4uLl0KICAgLWN8LS1jb25maWd1cmF0aW9uIGNvbmZpZyAgICAgICBTZXQgRHVtcFJlbmRlclRy ZWUgYnVpbGQgY29uZmlndXJhdGlvbgogICAtZ3wtLWd1YXJkLW1hbGxvYyAgICAgICAgICAgICAg IEVuYWJsZSBtYWxsb2MgZ3VhcmQKICAgLS1oZWxwICAgICAgICAgICAgICAgICAgICAgICAgICBT aG93IHRoaXMgaGVscCBtZXNzYWdlCi0gIC1ofC0taG9yaXpvbnRhbC1zd2VlcCAgICAgICAgICAg Q2hhbmdlIHJlcGFpbnQgdG8gc3dlZXAgaG9yaXpvbnRhbGx5IGluc3RlYWQgb2YgdmVydGljYWxs eSAoaW1wbGllcyAtLXJlcGFpbnQtdGVzdHMpCiAgIC0tW25vLV1odHRwICAgICAgICAgICAgICAg ICAgICAgUnVuIChvciBkbyBub3QgcnVuKSBodHRwIHRlc3RzIChkZWZhdWx0OiAkaHR0cERlZmF1 bHQpCiAgIC1pfC0taWdub3JlLXRlc3RzICAgICAgICAgICAgICAgQ29tbWEtc2VwYXJhdGVkIGxp c3Qgb2YgZGlyZWN0b3JpZXMgb3IgdGVzdHMgdG8gaWdub3JlCiAgIC0tW25vLV1sYXVuY2gtc2Fm YXJpICAgICAgICAgICAgTGF1bmNoIChvciBkbyBub3QgbGF1bmNoKSBTYWZhcmkgdG8gZGlzcGxh eSB0ZXN0IHJlc3VsdHMgKGRlZmF1bHQ6ICRsYXVuY2hTYWZhcmlEZWZhdWx0KQogICAtbHwtLWxl YWtzICAgICAgICAgICAgICAgICAgICAgIEVuYWJsZSBsZWFrcyBjaGVja2luZwogICAtLVtuby1d bmV3LXRlc3QtcmVzdWx0cyAgICAgICAgIEdlbmVyYXRlIHJlc3VsdHMgZm9yIG5ldyB0ZXN0cwog ICAtcHwtLXBpeGVsLXRlc3RzICAgICAgICAgICAgICAgIEVuYWJsZSBwaXhlbCB0ZXN0cworICAt LXRvbGVyYW5jZSB0ICAgICAgICAgICAgICAgICAgIElnbm9yZSBpbWFnZSBkaWZmZXJlbmNlcyBs ZXNzIHRoYW4gdGhpcyBwZXJjZW50YWdlIChpbXBsaWVzIC0tcGl4ZWwtdGVzdHMpCiAgIC0tcGxh dGZvcm0gICAgICAgICAgICAgICAgICAgICAgT3ZlcnJpZGUgdGhlIGRldGVjdGVkIHBsYXRmb3Jt IHRvIHVzZSBmb3IgdGVzdHMgYW5kIHJlc3VsdHMgKGRlZmF1bHQ6ICRwbGF0Zm9ybSkKICAgLS1w b3J0ICAgICAgICAgICAgICAgICAgICAgICAgICBXZWIgc2VydmVyIHBvcnQgdG8gdXNlIHdpdGgg aHR0cCB0ZXN0cwogICAtcXwtLXF1aWV0ICAgICAgICAgICAgICAgICAgICAgIExlc3MgdmVyYm9z ZSBvdXRwdXQKLSAgLXJ8LS1yZXBhaW50LXRlc3RzICAgICAgICAgICAgICBSdW4gcmVwYWludCB0 ZXN0cyAoaW1wbGllcyAtLXBpeGVsLXRlc3RzKQogICAtLXJlc2V0LXJlc3VsdHMgICAgICAgICAg ICAgICAgIFJlc2V0IEFMTCByZXN1bHRzIChpbmNsdWRpbmcgcGl4ZWwgdGVzdHMgaWYgLS1waXhl bC10ZXN0cyBpcyBzZXQpCiAgIC1vfC0tcmVzdWx0cy1kaXJlY3RvcnkgICAgICAgICAgT3V0cHV0 IHJlc3VsdHMgZGlyZWN0b3J5IChkZWZhdWx0OiAkdGVzdFJlc3VsdHNEaXJlY3RvcnkpCiAgIC0t cmFuZG9tICAgICAgICAgICAgICAgICAgICAgICAgUnVuIHRoZSB0ZXN0cyBpbiBhIHJhbmRvbSBv cmRlcgpAQCAtMjA2LDcgKzIwMyw2IEBAIFVzYWdlOiAkcHJvZ3JhbU5hbWUgW29wdGlvbnNdIFt0 ZXN0ZGlyfHRlc3RwYXRoIC4uLl0KICAgLS1zdHJpY3QgICAgICAgICAgICAgICAgICAgICAgICBE byBhIGNvbXBhcmlzb24gd2l0aCB0aGUgb3V0cHV0IG9uIE1hYyAoUXQgb25seSkKICAgLS1bbm8t XXN0cmlwLWVkaXRpbmctY2FsbGJhY2tzICBSZW1vdmUgZWRpdGluZyBjYWxsYmFja3MgZnJvbSBl eHBlY3RlZCByZXN1bHRzCiAgIC10fC0tdGhyZWFkZWQgICAgICAgICAgICAgICAgICAgUnVuIGEg Y29uY3VycmVudCBKYXZhU2NyaXB0IHRoZWFkIHdpdGggZWFjaCB0ZXN0Ci0gIC0tdGhyZXNob2xk IHQgICAgICAgICAgICAgICAgICAgSWdub3JlIHBpeGVsIHZhbHVlIGRldmlhdGlvbnMgbGVzcyB0 aGFuIG9yIGVxdWFsIHRvIHQKICAgLS12YWxncmluZCAgICAgICAgICAgICAgICAgICAgICBSdW4g RHVtcFJlbmRlclRyZWUgaW5zaWRlIHZhbGdyaW5kIChRdC9MaW51eCBvbmx5KQogICAtdnwtLXZl cmJvc2UgICAgICAgICAgICAgICAgICAgIE1vcmUgdmVyYm9zZSBvdXRwdXQgKG92ZXJyaWRlcyAt LXF1aWV0KQogICAtbXwtLW1lcmdlLWxlYWstZGVwdGggYXJnICAgICAgIE1lcmdlcyBsZWFrIGNh bGxTdGFja3MgYW5kIHByaW50cyB0aGUgbnVtYmVyIG9mIHVuaXF1ZSBsZWFrcyBiZW5lYXRoIGEg Y2FsbHN0YWNrIGRlcHRoIG9mIGFyZy4gIERlZmF1bHRzIHRvIDUuCkBAIC0yMjEsNyArMjE3LDYg QEAgbXkgJGdldE9wdGlvbnNSZXN1bHQgPSBHZXRPcHRpb25zKAogICAgICdjfGNvbmZpZ3VyYXRp b249cycgPT4gXCRjb25maWd1cmF0aW9uLAogICAgICdndWFyZC1tYWxsb2N8ZycgPT4gXCRndWFy ZE1hbGxvYywKICAgICAnaGVscCcgPT4gXCRzaG93SGVscCwKLSAgICAnaG9yaXpvbnRhbC1zd2Vl cHxoJyA9PiBcJHJlcGFpbnRTd2VlcEhvcml6b250YWxseSwKICAgICAnaHR0cCEnID0+IFwkdGVz dEhUVFAsCiAgICAgJ2lnbm9yZS10ZXN0c3xpPXMnID0+IFwkaWdub3JlVGVzdHMsCiAgICAgJ2xh dW5jaC1zYWZhcmkhJyA9PiBcJGxhdW5jaFNhZmFyaSwKQEAgLTIzMCw3ICsyMjUsNiBAQCBteSAk Z2V0T3B0aW9uc1Jlc3VsdCA9IEdldE9wdGlvbnMoCiAgICAgJ3BsYXRmb3JtPXMnID0+IFwkcGxh dGZvcm0sCiAgICAgJ3BvcnQ9aScgPT4gXCRodHRwZFBvcnQsCiAgICAgJ3F1aWV0fHEnID0+IFwk cXVpZXQsCi0gICAgJ3JlcGFpbnQtdGVzdHN8cicgPT4gXCRyZXBhaW50VGVzdHMsCiAgICAgJ3Jl c2V0LXJlc3VsdHMnID0+IFwkcmVzZXRSZXN1bHRzLAogICAgICduZXctdGVzdC1yZXN1bHRzIScg PT4gXCRnZW5lcmF0ZU5ld1Jlc3VsdHMsCiAgICAgJ3Jlc3VsdHMtZGlyZWN0b3J5fG89cycgPT4g XCR0ZXN0UmVzdWx0c0RpcmVjdG9yeSwKQEAgLTIzOSw3ICsyMzMsNyBAQCBteSAkZ2V0T3B0aW9u c1Jlc3VsdCA9IEdldE9wdGlvbnMoCiAgICAgJ3NraXBwZWQ9cycgPT4gXCZ2YWxpZGF0ZVNraXBw ZWRBcmcsCiAgICAgJ3Nsb3dlc3QnID0+IFwkcmVwb3J0MTBTbG93ZXN0LAogICAgICd0aHJlYWRl ZHx0JyA9PiBcJHRocmVhZGVkLAotICAgICd0aHJlc2hvbGQ9aScgPT4gXCR0aHJlc2hvbGQsCisg ICAgJ3RvbGVyYW5jZT1mJyA9PiBcJHRvbGVyYW5jZSwKICAgICAndmVyYm9zZXx2JyA9PiBcJHZl cmJvc2UsCiAgICAgJ3ZhbGdyaW5kJyA9PiBcJHVzZVZhbGdyaW5kLAogICAgICdzYW1wbGUtb24t dGltZW91dCEnID0+IFwkcnVuU2FtcGxlLApAQCAtMjY3LDEwICsyNjEsNyBAQCBzZXRDb25maWd1 cmF0aW9uKCRjb25maWd1cmF0aW9uKTsKIAogbXkgJGNvbmZpZ3VyYXRpb25PcHRpb24gPSAiLS0i IC4gbGMoJGNvbmZpZ3VyYXRpb24pOwogCi0kcmVwYWludFRlc3RzID0gMSBpZiAkcmVwYWludFN3 ZWVwSG9yaXpvbnRhbGx5OwotCi0kcGl4ZWxUZXN0cyA9IDEgaWYgJHJlcGFpbnRUZXN0czsKLSRw aXhlbFRlc3RzID0gMSBpZiAkdGhyZXNob2xkID4gMDsKKyRwaXhlbFRlc3RzID0gMSBpZiAkdG9s ZXJhbmNlID4gMDsKIAogJHRlc3RzUGVyRHVtcFRvb2wgPSAxMDAwIGlmICEkdGVzdHNQZXJEdW1w VG9vbDsKIApAQCAtNDU0LDE5ICs0NDUsMTUgQEAgbXkgJWR1cmF0aW9uczsKIG15ICRjb3VudCA9 IDA7CiBteSAkbGVha3NPdXRwdXRGaWxlTnVtYmVyID0gMTsKIG15ICR0b3RhbExlYWtzID0gMDsK LW15ICRkdW1wQWxsUGl4ZWxzID0gJHBpeGVsVGVzdHMgJiYgJHJlc2V0UmVzdWx0czsKIAogbXkg QHRvb2xBcmdzID0gKCk7Ci1wdXNoIEB0b29sQXJncywgIi0tZHVtcC1hbGwtcGl4ZWxzIiBpZiAk ZHVtcEFsbFBpeGVsczsKIHB1c2ggQHRvb2xBcmdzLCAiLS1waXhlbC10ZXN0cyIgaWYgJHBpeGVs VGVzdHM7Ci1wdXNoIEB0b29sQXJncywgIi0tcmVwYWludCIgaWYgJHJlcGFpbnRUZXN0czsKLXB1 c2ggQHRvb2xBcmdzLCAiLS1ob3Jpem9udGFsLXN3ZWVwIiBpZiAkcmVwYWludFN3ZWVwSG9yaXpv bnRhbGx5OwogcHVzaCBAdG9vbEFyZ3MsICItLXRocmVhZGVkIiBpZiAkdGhyZWFkZWQ7CiBwdXNo IEB0b29sQXJncywgIi0tY29tcGxleC10ZXh0IiBpZiAkY29tcGxleFRleHQ7CiBwdXNoIEB0b29s QXJncywgIi0iOwogCiBteSBAZGlmZlRvb2xBcmdzID0gKCk7Ci1wdXNoIEBkaWZmVG9vbEFyZ3Ms ICItLXRocmVzaG9sZCIsICR0aHJlc2hvbGQ7CitwdXNoIEBkaWZmVG9vbEFyZ3MsICItLXRvbGVy YW5jZSIsICR0b2xlcmFuY2U7CiAKICR8ID0gMTsKIApAQCAtNTUzLDYgKzU0MCwyMCBAQCBmb3Ig bXkgJHRlc3QgKEB0ZXN0cykgewogCiAgICAgbXkgJHN0YXJ0VGltZSA9IHRpbWUgaWYgJHJlcG9y dDEwU2xvd2VzdDsKIAorICAgICMgVHJ5IHRvIHJlYWQgZXhwZWN0ZWQgaGFzaCBmaWxlIGZvciBw aXhlbCB0ZXN0cworICAgIG15ICRzdWZmaXhFeHBlY3RlZEhhc2ggPSAiIjsKKyAgICBpZiAoJHBp eGVsVGVzdHMgJiYgISRyZXNldFJlc3VsdHMpIHsKKyAgICAgICAgbXkgJGV4cGVjdGVkUGl4ZWxE aXIgPSBleHBlY3RlZERpcmVjdG9yeUZvclRlc3QoJGJhc2UsIDAsICJwbmciKTsKKyAgICAgICAg aWYgKG9wZW4gRVhQRUNURURIQVNILCAiJGV4cGVjdGVkUGl4ZWxEaXIvJGJhc2UtJGV4cGVjdGVk VGFnLmNoZWNrc3VtIikgeworICAgICAgICAgICAgbXkgJGV4cGVjdGVkSGFzaCA9IDxFWFBFQ1RF REhBU0g+OworICAgICAgICAgICAgY2hvbXAoJGV4cGVjdGVkSGFzaCk7CisgICAgICAgICAgICBj bG9zZSBFWFBFQ1RFREhBU0g7CisgICAgICAgICAgICAKKyAgICAgICAgICAgICMgRm9ybWF0IGV4 cGVjdGVkIGhhc2ggaW50byBhIHN1ZmZpeCBzdHJpbmcgdGhhdCBpcyBhcHBlbmRlZCB0byB0aGUg cGF0aCAvIFVSTCBwYXNzZWQgdG8gRFJUCisgICAgICAgICAgICAkc3VmZml4RXhwZWN0ZWRIYXNo ID0gIickZXhwZWN0ZWRIYXNoIjsKKyAgICAgICAgfQorICAgIH0KKwogICAgIGlmICgkdGVzdCAh fiAvXmh0dHBcLy8pIHsKICAgICAgICAgbXkgJHRlc3RQYXRoID0gIiR0ZXN0RGlyZWN0b3J5LyR0 ZXN0IjsKICAgICAgICAgaWYgKGlzQ3lnd2luKCkpIHsKQEAgLTU2MCwxNyArNTYxLDE3IEBAIGZv ciBteSAkdGVzdCAoQHRlc3RzKSB7CiAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAkdGVz dFBhdGggPSBjYW5vbnBhdGgoJHRlc3RQYXRoKTsKICAgICAgICAgfQotICAgICAgICBwcmludCBP VVQgIiR0ZXN0UGF0aFxuIjsKKyAgICAgICAgcHJpbnQgT1VUICIkdGVzdFBhdGgkc3VmZml4RXhw ZWN0ZWRIYXNoXG4iOwogICAgIH0gZWxzZSB7CiAgICAgICAgIG9wZW5IVFRQRElmTmVlZGVkKCk7 CiAgICAgICAgIGlmICgkdGVzdCAhfiAvXmh0dHBcL3Rlc3RzXC9sb2NhbFwvLyAmJiAkdGVzdCAh fiAvXmh0dHBcL3Rlc3RzXC9zc2xcLy8gJiYgJHRlc3QgIX4gL15odHRwXC90ZXN0c1wvbWVkaWFc Ly8pIHsKICAgICAgICAgICAgIG15ICRwYXRoID0gY2Fub25wYXRoKCR0ZXN0KTsKICAgICAgICAg ICAgICRwYXRoID1+IHMvXmh0dHBcL3Rlc3RzXC8vLzsKLSAgICAgICAgICAgIHByaW50IE9VVCAi aHR0cDovLzEyNy4wLjAuMTokaHR0cGRQb3J0LyRwYXRoXG4iOworICAgICAgICAgICAgcHJpbnQg T1VUICJodHRwOi8vMTI3LjAuMC4xOiRodHRwZFBvcnQvJHBhdGgkc3VmZml4RXhwZWN0ZWRIYXNo XG4iOwogICAgICAgICB9IGVsc2lmICgkdGVzdCA9fiAvXmh0dHBcL3Rlc3RzXC9zc2xcLy8pIHsK ICAgICAgICAgICAgIG15ICRwYXRoID0gY2Fub25wYXRoKCR0ZXN0KTsKICAgICAgICAgICAgICRw YXRoID1+IHMvXmh0dHBcL3Rlc3RzXC8vLzsKLSAgICAgICAgICAgIHByaW50IE9VVCAiaHR0cHM6 Ly8xMjcuMC4wLjE6JGh0dHBkU1NMUG9ydC8kcGF0aFxuIjsKKyAgICAgICAgICAgIHByaW50IE9V VCAiaHR0cHM6Ly8xMjcuMC4wLjE6JGh0dHBkU1NMUG9ydC8kcGF0aCRzdWZmaXhFeHBlY3RlZEhh c2hcbiI7CiAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICBteSAkdGVzdFBhdGggPSAiJHRl c3REaXJlY3RvcnkvJHRlc3QiOwogICAgICAgICAgICAgaWYgKGlzQ3lnd2luKCkpIHsKQEAgLTU3 OCw3ICs1NzksNyBAQCBmb3IgbXkgJHRlc3QgKEB0ZXN0cykgewogICAgICAgICAgICAgfSBlbHNl IHsKICAgICAgICAgICAgICAgICAkdGVzdFBhdGggPSBjYW5vbnBhdGgoJHRlc3RQYXRoKTsKICAg ICAgICAgICAgIH0KLSAgICAgICAgICAgIHByaW50IE9VVCAiJHRlc3RQYXRoXG4iOworICAgICAg ICAgICAgcHJpbnQgT1VUICIkdGVzdFBhdGgkc3VmZml4RXhwZWN0ZWRIYXNoXG4iOwogICAgICAg ICB9CiAgICAgfQogCkBAIC02NDEsNyArNjQyLDYgQEAgZm9yIG15ICR0ZXN0IChAdGVzdHMpIHsK ICAgICBteSAkZGlmZlBlcmNlbnRhZ2UgPSAiIjsKICAgICBteSAkZGlmZlJlc3VsdCA9ICJwYXNz ZWQiOwogCi0gICAgIyBMb29rIGZvciB0aGUgcGl4ZWwgYmxvY2ssIGFuZCBkbyBhbiBpbWFnZSBk aWZmIGlmIHdlIGZpbmQgb25lCiAgICAgbXkgJGFjdHVhbEhhc2ggPSAiIjsKICAgICBteSAkZXhw ZWN0ZWRIYXNoID0gIiI7CiAgICAgbXkgJGFjdHVhbFBOR1NpemUgPSAwOwpAQCAtNjUwLDcgKzY1 MCw3IEBAIGZvciBteSAkdGVzdCAoQHRlc3RzKSB7CiAgICAgICAgIGxhc3QgaWYgLyNFT0YvOwog ICAgICAgICBpZiAoL0FjdHVhbEhhc2g6IChbYS1mMC05XXszMn0pLykgewogICAgICAgICAgICAg JGFjdHVhbEhhc2ggPSAkMTsKLSAgICAgICAgfSBlbHNpZiAoL0Jhc2VsaW5lSGFzaDogKFthLWYw LTldezMyfSkvKSB7CisgICAgICAgIH0gZWxzaWYgKC9FeHBlY3RlZEhhc2g6IChbYS1mMC05XXsz Mn0pLykgewogICAgICAgICAgICAgJGV4cGVjdGVkSGFzaCA9ICQxOwogICAgICAgICB9IGVsc2lm ICgvQ29udGVudC1MZW5ndGg6IChcZCspXHMqLykgewogICAgICAgICAgICAgJGFjdHVhbFBOR1Np emUgPSAkMTsKQEAgLTY1OCw0MiArNjU4LDU4IEBAIGZvciBteSAkdGVzdCAoQHRlc3RzKSB7CiAg ICAgICAgIH0KICAgICB9CiAKLSAgICAjIElmIHdlIGdvdCBzb21lIFBORyBkYXRhLCBkaWZmIHdp dGggZXhwZWN0ZWQKKyAgICBpZigkdmVyYm9zZSAmJiAkcGl4ZWxUZXN0cyAmJiAhJHJlc2V0UmVz dWx0cyAmJiAkYWN0dWFsUE5HU2l6ZSkgeworICAgICAgICBpZiAoJGFjdHVhbEhhc2ggZXEgIiIg JiYgJGV4cGVjdGVkSGFzaCBlcSAiIikgeworICAgICAgICAgICAgcHJpbnRGYWlsdXJlTWVzc2Fn ZUZvclRlc3QoJHRlc3QsICJXQVJOSU5HOiBhY3R1YWwgJiBleHBlY3RlZCBwaXhlbCBoYXNoZXMg YXJlIG1pc3NpbmchIik7CisgICAgICAgIH0gZWxzaWYgKCRhY3R1YWxIYXNoIGVxICIiKSB7Cisg ICAgICAgICAgICBwcmludEZhaWx1cmVNZXNzYWdlRm9yVGVzdCgkdGVzdCwgIldBUk5JTkc6IGFj dHVhbCBwaXhlbCBoYXNoIGlzIG1pc3NpbmchIik7CisgICAgICAgIH0gZWxzaWYgKCRleHBlY3Rl ZEhhc2ggZXEgIiIpIHsKKyAgICAgICAgICAgIHByaW50RmFpbHVyZU1lc3NhZ2VGb3JUZXN0KCR0 ZXN0LCAiV0FSTklORzogZXhwZWN0ZWQgcGl4ZWwgaGFzaCBpcyBtaXNzaW5nISIpOworICAgICAg ICB9CisgICAgfQorCiAgICAgaWYgKCRhY3R1YWxQTkdTaXplID4gMCkgewogICAgICAgICBteSAk ZXhwZWN0ZWRQaXhlbERpciA9IGV4cGVjdGVkRGlyZWN0b3J5Rm9yVGVzdCgkYmFzZSwgJGlzVGV4 dCwgInBuZyIpOwogCi0gICAgICAgIGlmICgkZXhwZWN0ZWRIYXNoIG5lICRhY3R1YWxIYXNoICYm IC1mICIkZXhwZWN0ZWRQaXhlbERpci8kYmFzZS0kZXhwZWN0ZWRUYWcucG5nIikgewotICAgICAg ICAgICAgbXkgJGV4cGVjdGVkUE5HU2l6ZSA9IC1zICIkZXhwZWN0ZWRQaXhlbERpci8kYmFzZS0k ZXhwZWN0ZWRUYWcucG5nIjsKLSAgICAgICAgICAgIG15ICRleHBlY3RlZFBORyA9ICIiOwotICAg ICAgICAgICAgb3BlbiBFWFBFQ1RFRFBORywgIiRleHBlY3RlZFBpeGVsRGlyLyRiYXNlLSRleHBl Y3RlZFRhZy5wbmciOwotICAgICAgICAgICAgcmVhZChFWFBFQ1RFRFBORywgJGV4cGVjdGVkUE5H LCAkZXhwZWN0ZWRQTkdTaXplKTsKKyAgICAgICAgaWYgKCEkcmVzZXRSZXN1bHRzICYmICgkZXhw ZWN0ZWRIYXNoIG5lICRhY3R1YWxIYXNoIHx8ICgkYWN0dWFsSGFzaCBlcSAiIiAmJiAkZXhwZWN0 ZWRIYXNoIGVxICIiKSkpIHsKKyAgICAgICAgICAgIGlmICgtZiAiJGV4cGVjdGVkUGl4ZWxEaXIv JGJhc2UtJGV4cGVjdGVkVGFnLnBuZyIpIHsKKyAgICAgICAgICAgICAgICBteSAkZXhwZWN0ZWRQ TkdTaXplID0gLXMgIiRleHBlY3RlZFBpeGVsRGlyLyRiYXNlLSRleHBlY3RlZFRhZy5wbmciOwor ICAgICAgICAgICAgICAgIG15ICRleHBlY3RlZFBORyA9ICIiOworICAgICAgICAgICAgICAgIG9w ZW4gRVhQRUNURURQTkcsICIkZXhwZWN0ZWRQaXhlbERpci8kYmFzZS0kZXhwZWN0ZWRUYWcucG5n IjsKKyAgICAgICAgICAgICAgICByZWFkKEVYUEVDVEVEUE5HLCAkZXhwZWN0ZWRQTkcsICRleHBl Y3RlZFBOR1NpemUpOwogCi0gICAgICAgICAgICBwcmludCBESUZGT1VUICJDb250ZW50LUxlbmd0 aDogJGFjdHVhbFBOR1NpemVcbiI7Ci0gICAgICAgICAgICBwcmludCBESUZGT1VUICRhY3R1YWxQ Tkc7CisgICAgICAgICAgICAgICAgcHJpbnQgRElGRk9VVCAiQ29udGVudC1MZW5ndGg6ICRhY3R1 YWxQTkdTaXplXG4iOworICAgICAgICAgICAgICAgIHByaW50IERJRkZPVVQgJGFjdHVhbFBORzsK IAotICAgICAgICAgICAgcHJpbnQgRElGRk9VVCAiQ29udGVudC1MZW5ndGg6ICRleHBlY3RlZFBO R1NpemVcbiI7Ci0gICAgICAgICAgICBwcmludCBESUZGT1VUICRleHBlY3RlZFBORzsKKyAgICAg ICAgICAgICAgICBwcmludCBESUZGT1VUICJDb250ZW50LUxlbmd0aDogJGV4cGVjdGVkUE5HU2l6 ZVxuIjsKKyAgICAgICAgICAgICAgICBwcmludCBESUZGT1VUICRleHBlY3RlZFBORzsKIAotICAg ICAgICAgICAgd2hpbGUgKDxESUZGSU4+KSB7Ci0gICAgICAgICAgICAgICAgbGFzdCBpZiAvXmVy cm9yLyB8fCAvXmRpZmY6LzsKLSAgICAgICAgICAgICAgICBpZiAoL0NvbnRlbnQtTGVuZ3RoOiAo XGQrKVxzKi8pIHsKLSAgICAgICAgICAgICAgICAgICAgcmVhZChESUZGSU4sICRkaWZmUE5HLCAk MSk7CisgICAgICAgICAgICAgICAgd2hpbGUgKDxESUZGSU4+KSB7CisgICAgICAgICAgICAgICAg ICAgIGxhc3QgaWYgL15lcnJvci8gfHwgL15kaWZmOi87CisgICAgICAgICAgICAgICAgICAgIGlm ICgvQ29udGVudC1MZW5ndGg6IChcZCspXHMqLykgeworICAgICAgICAgICAgICAgICAgICAgICAg cmVhZChESUZGSU4sICRkaWZmUE5HLCAkMSk7CisgICAgICAgICAgICAgICAgICAgIH0KICAgICAg ICAgICAgICAgICB9Ci0gICAgICAgICAgICB9CiAKLSAgICAgICAgICAgIGlmICgvXmRpZmY6ICgu KyklIChwYXNzZWR8ZmFpbGVkKS8pIHsKLSAgICAgICAgICAgICAgICAkZGlmZlBlcmNlbnRhZ2Ug PSAkMTsKLSAgICAgICAgICAgICAgICAkaW1hZ2VEaWZmZXJlbmNlc3skYmFzZX0gPSAkZGlmZlBl cmNlbnRhZ2U7Ci0gICAgICAgICAgICAgICAgJGRpZmZSZXN1bHQgPSAkMjsKKyAgICAgICAgICAg ICAgICBpZiAoL15kaWZmOiAoLispJSAocGFzc2VkfGZhaWxlZCkvKSB7CisgICAgICAgICAgICAg ICAgICAgICRkaWZmUGVyY2VudGFnZSA9ICQxOworICAgICAgICAgICAgICAgICAgICAkaW1hZ2VE aWZmZXJlbmNlc3skYmFzZX0gPSAkZGlmZlBlcmNlbnRhZ2U7CisgICAgICAgICAgICAgICAgICAg ICRkaWZmUmVzdWx0ID0gJDI7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIAor ICAgICAgICAgICAgICAgIGlmICgkZGlmZlBlcmNlbnRhZ2UgPT0gMCkgeworICAgICAgICAgICAg ICAgICAgICBwcmludEZhaWx1cmVNZXNzYWdlRm9yVGVzdCgkdGVzdCwgInBpeGVsIGhhc2ggZmFp bGVkIChidXQgcGl4ZWwgdGVzdCBzdGlsbCBwYXNzZXMpIik7CisgICAgICAgICAgICAgICAgfQor ICAgICAgICAgICAgfSBlbHNpZiAoJHZlcmJvc2UpIHsKKyAgICAgICAgICAgICAgICBwcmludEZh aWx1cmVNZXNzYWdlRm9yVGVzdCgkdGVzdCwgIldBUk5JTkc6IGV4cGVjdGVkIGltYWdlIGlzIG1p c3NpbmchIik7CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KIAotICAgICAgICBpZiAoJGFjdHVh bFBOR1NpemUgJiYgKCRyZXNldFJlc3VsdHMgfHwgIS1mICIkZXhwZWN0ZWRQaXhlbERpci8kYmFz ZS0kZXhwZWN0ZWRUYWcucG5nIikpIHsKKyAgICAgICAgaWYgKCRyZXNldFJlc3VsdHMgfHwgIS1m ICIkZXhwZWN0ZWRQaXhlbERpci8kYmFzZS0kZXhwZWN0ZWRUYWcucG5nIikgewogICAgICAgICAg ICAgbWtwYXRoIGNhdGZpbGUoJGV4cGVjdGVkUGl4ZWxEaXIsIGRpcm5hbWUoJGJhc2UpKSBpZiAk dGVzdERpcmVjdG9yeSBuZSAkZXhwZWN0ZWRQaXhlbERpcjsKICAgICAgICAgICAgIHdyaXRlVG9G aWxlKCIkZXhwZWN0ZWRQaXhlbERpci8kYmFzZS0kZXhwZWN0ZWRUYWcucG5nIiwgJGFjdHVhbFBO Ryk7CiAgICAgICAgIH0KIAotICAgICAgICAjIHVwZGF0ZSB0aGUgZXhwZWN0ZWQgaGFzaCBpZiB0 aGUgaW1hZ2UgZGlmZiBzYWlkIHRoYXQgdGhlcmUgd2FzIG5vIGRpZmZlcmVuY2UKICAgICAgICAg aWYgKCRhY3R1YWxIYXNoIG5lICIiICYmICgkcmVzZXRSZXN1bHRzIHx8ICEtZiAiJGV4cGVjdGVk UGl4ZWxEaXIvJGJhc2UtJGV4cGVjdGVkVGFnLmNoZWNrc3VtIikpIHsKICAgICAgICAgICAgIHdy aXRlVG9GaWxlKCIkZXhwZWN0ZWRQaXhlbERpci8kYmFzZS0kZXhwZWN0ZWRUYWcuY2hlY2tzdW0i LCAkYWN0dWFsSGFzaCk7CiAgICAgICAgIH0K 24631 2008-10-23 19:33:18 -0700 2008-10-27 11:58:25 -0700 Updated patch PATCH_FILE.txt text/plain 80713 pol ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCA5ZTU2N2VjLi41OWFkM2M3IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsODggQEAKKzIwMDgtMTAt MjMgIFBpZXJyZS1PbGl2aWVyIExhdG91ciAgPHBvbEBhcHBsZS5jb20+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUHJpbWFyeSBjaGFuZ2VzIGluIER1 bXBSZW5kZXJUcmVlOgorICAgICAgICAtIEVuc3VyZSBmb250IHNtb290aGluZyBpcyBkaXNhYmxl ZCAodGhpcyBpcyBhbHNvIGNhbGxlZCBMQ0QgYW50aS1hbGlhc2luZyBhbmQKKyAgICAgICAgaXMg ZGlmZmVyZW50IGZyb20gcmVndWxhciBmb250IENHIGFudGktYWxpYXNpbmcpIGFzIGZvbnQtc21v b3RoaW5nIHNldHRpbmdzCisgICAgICAgIGRlcGVuZHMgb24gdGhlIGRpc3BsYXkgYW5kIGNhbiBh bHNvIGJlIGNoYW5nZWQgYnkgdGhlIHVzZXIKKyAgICAgICAgLSBVc2UgYSBuZXcgY2xlYXJlZCBi dWZmZXIgZm9yIGVhY2ggdGVzdCBpbnN0ZWFkIG9mIHRoZSByZXVzaW5nIHNhbWUgb25lIHRvCisg ICAgICAgIGF2b2lkIHBvdGVudGlhbCByZXN1bHQgY29ycnVwdGlvbiBhY3Jvc3MgdGVzdHMKKyAg ICAgICAgLSBDYW4gbm93IHJlY2VpdmUgdGhlIGV4cGVjdGVkIHBpeGVsIGhhc2ggYXMgYSBzdWZm aXggdG8gdGhlIHRlc3QgcGF0aCBvcgorICAgICAgICB1cmwgYXMgInBhdGgnaGFzaCIKKyAgICAg ICAgLSBNYWtlIHN1cmUgaGFzaCBpcyBjb21wdXRlZCBpbiBhIGVuZGlhbi1pbmRlcGVuZGVudCB3 YXkKKyAgICAgICAgLSBJbXByb3ZlIHRoZSBjb2RlIHRoYXQgc2V0cy9yZXN0b3JlcyB0aGUgc2Ny ZWVuIGNvbG9yIHByb2ZpbGUKKyAgICAgICAgLSBNYWtlIHRoZSBjb2RlIG1vcmUgY3Jvc3MtcGxh dGZvcm15IHdpdGggc3RkOjpzdHJpbmcgZ29vZG5lc3MKKyAgICAgICAgLSBBZGRlZCBhbiAib24t c2NyZWVuIiBtb2RlIHdoZXJlIHRoZSBzbmFwc2hvdCB3aWxsIHRha2UgaW50byBhY2NvdW50IHN1 cmZhY2VzCisgICAgICAgIG9uIHRoZSB3aW5kb3cgKGxpa2UgT3BlbkdMIGNvbnRlbnQpOiB0aGlz IHVzZXMgdGhlIG5ldyBDRyBBUElzIG9uIDEwLjUgb3IKKyAgICAgICAgcmVhZGluZyBmcm9tIHRo ZSBkaXNwbGF5IGZyYW1lYnVmZmVyIG9uIDEwLjQuIFRoaXMgbW9kZSBpcyBub3QgYWN0aXZlIGJ5 CisgICAgICAgIGRlZmF1bHQgZm9yIHBlcmZvcm1hbmNlIHJlYXNvbiwgYnV0IG11c3QgYmUgZXhw bGljaXRseSBhY3RpdmF0ZWQgZnJvbSB0aGUgdGVzdAorICAgICAgICBmaWxlIHVzaW5nIHRoZSBu ZXcgInRlc3RPbnNjcmVlbigpIiBKUyBBUEkuCisKKyAgICAgICAgUHJpbWFyeSBjaGFuZ2VzIGlu IEltYWdlRGlmZjoKKyAgICAgICAgLSBQcm92aWRlIGEgbmV3IGNvbXBhcmlzb24gYWxnb3JpdGht IHRoYXQgaXMgbW9yZSB0b2xlcmFudCB0byAiYWNjZXB0YWJsZSIKKyAgICAgICAgZmFpbHVyZXMg KGkuZS4gdmVyeSBzbWFsbCBkaWZmZXJlbmNlcyBpbiBmb250IHJlbmRlcmluZywgd2hpY2ggLS10 aHJlc2hvbGQgaXMKKyAgICAgICAgbm90IHJlYWxseSBnb29kIGF0IGhhbmRsaW5nKQorICAgICAg ICAtIEdlbmVyYXRlIG5vcm1hbGl6ZWQgaW50ZW5zaXR5LW9ubHkgZGlmZiBpbWFnZXMKKworICAg ICAgICBQcmltYXJ5IGNoYW5nZXMgaW4gcnVuLXdlYmtpdC10ZXN0czoKKyAgICAgICAgLSBUYWtl IGFkdmFudGFnZSBvZiBoYXNoZXMgZm9yIHBpeGVsIHRlc3RzIHdoaWNoIG1ha2VzIHRoZW0gbXVj aCBmYXN0ZXIgYnkKKyAgICAgICAgbWluaW1pemluZyBpbWFnZSBjb21wYXJpc29ucworICAgICAg ICAtIFJlbW92ZWQgcmVwYWludCBvcHRpb25zIGFzIHRoZXNlIHNob3VsZCBiZSBzZXQgZnJvbSB3 aXRoaW4gdGVzdCBmaWxlcyB1c2luZworICAgICAgICBKUyBBUEkKKyAgICAgICAgLSBSZXBsYWNl ZCAidGhyZXNob2xkIiBvcHRpb24gaW4gIGJ5ICJ0b2xlcmFuY2UiIGV4cHJlc3NlZCBpbiBwZXJj ZW50cworICAgICAgICAtIEFkZGVkIG1vcmUgbG9nZ2luZyB3aGVuIGluICJ2ZXJib3NlIiBtb2Rl CisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMzIy CisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9EdW1wUmVuZGVyVHJlZS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0ZvcndhcmRpbmdIZWFkZXJz L3d0Zi9QYXNzUmVmUHRyLmg6IEFkZGVkLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0Zvcndh cmRpbmdIZWFkZXJzL3d0Zi9SZWZQdHIuaDogQWRkZWQuCisgICAgICAgICogRHVtcFJlbmRlclRy ZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xs ZXI6OkxheW91dFRlc3RDb250cm9sbGVyKToKKyAgICAgICAgKHRlc3RPbnNjcmVlbkNhbGxiYWNr KToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMpOgorICAg ICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmg6CisgICAgICAgIChM YXlvdXRUZXN0Q29udHJvbGxlcjo6dGVzdE9uc2NyZWVuKToKKyAgICAgICAgKExheW91dFRlc3RD b250cm9sbGVyOjpzZXRUZXN0T25zY3JlZW4pOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xs ZXI6OnRlc3RQYXRoT3JVUkwpOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OmV4cGVj dGVkUGl4ZWxIYXNoKToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9QaXhlbER1bXBTdXBwb3J0 Lmg6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2cvSW1hZ2VEaWZmQ0cuY3BwOgorICAgICAg ICAoc3RydG9mKToKKyAgICAgICAgKHJlbGVhc2VNYWxsb2NCdWZmZXIpOgorICAgICAgICAoY3Jl YXRlRGlmZmVyZW5jZUltYWdlKToKKyAgICAgICAgKGltYWdlSGFzQWxwaGEpOgorICAgICAgICAo bWFpbik6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1wU3VwcG9ydENHLmNw cDoKKyAgICAgICAgKGNvbXB1dGVNRDVIYXNoU3RyaW5nRm9yQml0bWFwQ29udGV4dCk6CisgICAg ICAgIChkdW1wV2ViVmlld0FzUGl4ZWxzQW5kQ29tcGFyZVdpdGhFeHBlY3RlZCk6CisgICAgICAg ICogRHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1wU3VwcG9ydENHLmg6CisgICAgICAgIChCaXRt YXBDb250ZXh0OjpjcmVhdGVCeUFkb3B0aW5nQml0bWFwQW5kQ29udGV4dCk6CisgICAgICAgIChC aXRtYXBDb250ZXh0Ojp+Qml0bWFwQ29udGV4dCk6CisgICAgICAgIChCaXRtYXBDb250ZXh0Ojpj Z0NvbnRleHQpOgorICAgICAgICAoQml0bWFwQ29udGV4dDo6Qml0bWFwQ29udGV4dCk6CisgICAg ICAgICogRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tOgorICAgICAgICAoc2hv dWxkSWdub3JlV2ViQ29yZU5vZGVMZWFrcyk6CisgICAgICAgIChzZXREZWZhdWx0c1RvQ29uc2lz dGVudFZhbHVlc0ZvclRlc3RpbmcpOgorICAgICAgICAoY3Jhc2hIYW5kbGVyKToKKyAgICAgICAg KGluaXRpYWxpemVHbG9iYWxzRnJvbUNvbW1hbmRMaW5lT3B0aW9ucyk6CisgICAgICAgIChwcmVw YXJlQ29uc2lzdGVudFRlc3RpbmdFbnZpcm9ubWVudCk6CisgICAgICAgIChkdW1wUmVuZGVyVHJl ZSk6CisgICAgICAgIChzaXplV2ViVmlld0ZvckN1cnJlbnRUZXN0KToKKyAgICAgICAgKGR1bXAp OgorICAgICAgICAocnVuVGVzdCk6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFjL1BpeGVs RHVtcFN1cHBvcnRNYWMubW06CisgICAgICAgIChyZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2Zp bGUpOgorICAgICAgICAoc2V0dXBNYWluRGlzcGxheUNvbG9yUHJvZmlsZSk6CisgICAgICAgIChj cmVhdGVCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVl L3dpbi9EdW1wUmVuZGVyVHJlZS5jcHA6CisgICAgICAgIChkdW1wKToKKyAgICAgICAgKHJ1blRl c3QpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3dpbi9QaXhlbER1bXBTdXBwb3J0V2luLmNw cDoKKyAgICAgICAgKGdldEJpdG1hcENvbnRleHRGcm9tV2ViVmlldyk6CisgICAgICAgICogU2Ny aXB0cy9ydW4td2Via2l0LXRlc3RzOgorCiAyMDA4LTEwLTIyICBCcmFkeSBFaWRzb24gIDxiZWlk c29uQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBBZGFtIFJvYmVuCmRpZmYgLS1n aXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9EdW1wUmVuZGVyVHJlZS54Y29kZXByb2ov cHJvamVjdC5wYnhwcm9qIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvRHVtcFJlbmRlclRy ZWUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCAzNDgwNjljLi5iZmM3NTAwIDEwMDY0 NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9EdW1wUmVuZGVyVHJlZS54Y29kZXBy b2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0R1bXBS ZW5kZXJUcmVlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTMzLDYgKzMzLDcgQEAKIAkJ MUFDNkM4NDkwRDA3NjM4NjAwQ0QzMTYxIC8qIG1haW4uY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMUFDNkM3N0YwRDA3NTg5QjAwQ0QzMTYxIC8qIG1h aW4uY3BwICovOyB9OwogCQkxQUM2Qzg0QTBEMDc2Mzg2MDBDRDMxNjEgLyogUGx1Z2luT2JqZWN0 LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDFBQzZD NzgwMEQwNzU4OUIwMENEMzE2MSAvKiBQbHVnaW5PYmplY3QuY3BwICovOyB9OwogCQkxQUM2Qzg0 QjBEMDc2Mzg2MDBDRDMxNjEgLyogVGVzdE9iamVjdC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAxQUM2Qzc4MTBEMDc1ODlCMDBDRDMxNjEgLyogVGVz dE9iamVjdC5jcHAgKi87IH07CisJCTIzQkNCODkwMEVBNTc2MjMwMDNDNjI4OSAvKiBPcGVuR0wu ZnJhbWV3b3JrIGluIEZyYW1ld29ya3MgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gMjNCQ0I4OEYwRUE1NzYyMzAwM0M2Mjg5IC8qIE9wZW5HTC5mcmFtZXdvcmsgKi87IH07CiAJ CTkzNDA5OTRDMDg1NDBDQUUwMDdGM0JDOCAvKiBEdW1wUmVuZGVyVHJlZVByZWZpeC5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMzJBNzBBQUIwMzcwNUUx RjAwQzkxNzgzIC8qIER1bXBSZW5kZXJUcmVlUHJlZml4LmggKi87IH07CiAJCTkzNDA5OTUxMDg1 NDBDQUUwMDdGM0JDOCAvKiBXZWJLaXQuZnJhbWV3b3JrIGluIEZyYW1ld29ya3MgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTMzNTQzNUYwM0Q3NTUwMjAwODYzNUNFIC8qIFdl YktpdC5mcmFtZXdvcmsgKi87IH07CiAJCUE4MTcwOTAwMDhCMTYzRUYwMENDQjlGQiAvKiBDb2Nv YS5mcmFtZXdvcmsgaW4gRnJhbWV3b3JrcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSBBODRGNjA4OTA4QjEzNkRBMDBFOTc0NUYgLyogQ29jb2EuZnJhbWV3b3JrICovOyB9OwpA QCAtMTMxLDYgKzEzMiw3IEBACiAJCTFBQzZDNzdGMEQwNzU4OUIwMENEMzE2MSAvKiBtYWluLmNw cCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IG1haW4uY3BwOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQkxQUM2Qzc4MDBEMDc1ODlCMDBDRDMxNjEgLyogUGx1Z2lu T2JqZWN0LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFBsdWdpbk9i amVjdC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTFBQzZDNzgxMEQwNzU4OUIw MENEMzE2MSAvKiBUZXN0T2JqZWN0LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsg cGF0aCA9IFRlc3RPYmplY3QuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQkyM0JD Qjg4RjBFQTU3NjIzMDAzQzYyODkgLyogT3BlbkdMLmZyYW1ld29yayAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHdyYXBwZXIuZnJhbWV3b3JrOyBuYW1l ID0gT3BlbkdMLmZyYW1ld29yazsgcGF0aCA9IC9TeXN0ZW0vTGlicmFyeS9GcmFtZXdvcmtzL09w ZW5HTC5mcmFtZXdvcms7IHNvdXJjZVRyZWUgPSAiPGFic29sdXRlPiI7IH07CiAJCTMyQTcwQUFC MDM3MDVFMUYwMEM5MTc4MyAvKiBEdW1wUmVuZGVyVHJlZVByZWZpeC5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jLmg7IHBhdGggPSBEdW1wUmVuZGVyVHJlZVByZWZpeC5oOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQkzNzVGMDk3MTBEQUMzQ0I2MDBDOEI0RTUgLyogV2ViS2l0V2VpZ2h0 V2F0Y2hlcjEwMC50dGYgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmls ZVR5cGUgPSBmaWxlOyBuYW1lID0gV2ViS2l0V2VpZ2h0V2F0Y2hlcjEwMC50dGY7IHBhdGggPSBm b250cy9XZWJLaXRXZWlnaHRXYXRjaGVyMTAwLnR0Zjsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJMzc1RjA5NzIwREFDM0NCNjAwQzhCNEU1IC8qIFdlYktpdFdlaWdodFdhdGNoZXIyMDAu dHRmICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gZmls ZTsgbmFtZSA9IFdlYktpdFdlaWdodFdhdGNoZXIyMDAudHRmOyBwYXRoID0gZm9udHMvV2ViS2l0 V2VpZ2h0V2F0Y2hlcjIwMC50dGY7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0yMzQs NiArMjM2LDcgQEAKIAkJCQlBODRGNjA4QTA4QjEzNkRBMDBFOTc0NUYgLyogQ29jb2EuZnJhbWV3 b3JrIGluIEZyYW1ld29ya3MgKi8sCiAJCQkJQTgxNzA5MDQwOEIxNjREMzAwQ0NCOUZCIC8qIEph dmFTY3JpcHRDb3JlLmZyYW1ld29yayBpbiBGcmFtZXdvcmtzICovLAogCQkJCTkzNDA5OTUxMDg1 NDBDQUUwMDdGM0JDOCAvKiBXZWJLaXQuZnJhbWV3b3JrIGluIEZyYW1ld29ya3MgKi8sCisJCQkJ MjNCQ0I4OTAwRUE1NzYyMzAwM0M2Mjg5IC8qIE9wZW5HTC5mcmFtZXdvcmsgaW4gRnJhbWV3b3Jr cyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsK IAkJfTsKQEAgLTM3NSw2ICszNzgsNyBAQAogCQkJCUE4MTcwOTAzMDhCMTY0RDMwMENDQjlGQiAv KiBKYXZhU2NyaXB0Q29yZS5mcmFtZXdvcmsgKi8sCiAJCQkJQjVBNzUyQTEwOEFGNUQxRjAwMTM4 RTQ1IC8qIFF1YXJ0ekNvcmUuZnJhbWV3b3JrICovLAogCQkJCTkzMzU0MzVGMDNENzU1MDIwMDg2 MzVDRSAvKiBXZWJLaXQuZnJhbWV3b3JrICovLAorCQkJCTIzQkNCODhGMEVBNTc2MjMwMDNDNjI4 OSAvKiBPcGVuR0wuZnJhbWV3b3JrICovLAogCQkJKTsKIAkJCW5hbWUgPSBGcmFtZXdvcmtzOwog CQkJc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL0ZvcndhcmRpbmdIZWFkZXJzL3d0Zi9QYXNzUmVmUHRyLmggYi9XZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUGFzc1JlZlB0ci5oCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmFhZmQxYTIKLS0tIC9kZXYvbnVsbAorKysg Yi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUGFzc1Jl ZlB0ci5oCkBAIC0wLDAgKzEgQEAKKyNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9QYXNzUmVmUHRy Lmg+CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5nSGVh ZGVycy93dGYvUmVmUHRyLmggYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5n SGVhZGVycy93dGYvUmVmUHRyLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u MGZmNjIxMwotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0Zv cndhcmRpbmdIZWFkZXJzL3d0Zi9SZWZQdHIuaApAQCAtMCwwICsxIEBACisjaW5jbHVkZSA8SmF2 YVNjcmlwdENvcmUvUmVmUHRyLmg+CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKaW5kZXggNmM2YTI3My4uYWE3MTdmNCAxMDA2NDQK LS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3Bw CisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNw cApAQCAtMzQsNyArMzQsNyBAQAogI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW5jbHVk ZSA8d3RmL01hdGhFeHRyYXMuaD4KIAotTGF5b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRlc3RD b250cm9sbGVyKGJvb2wgdGVzdFJlcGFpbnREZWZhdWx0LCBib29sIHRlc3RSZXBhaW50U3dlZXBI b3Jpem9udGFsbHlEZWZhdWx0KQorTGF5b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRlc3RDb250 cm9sbGVyKGNvbnN0IHN0ZDo6c3RyaW5nJiB0ZXN0UGF0aE9yVVJMLCBjb25zdCBzdGQ6OnN0cmlu ZyYgZXhwZWN0ZWRQaXhlbEhhc2gpCiAgICAgOiBtX2R1bXBBc1RleHQoZmFsc2UpCiAgICAgLCBt X2R1bXBBc1BERihmYWxzZSkKICAgICAsIG1fZHVtcEJhY2tGb3J3YXJkTGlzdChmYWxzZSkKQEAg LTU0LDExICs1NCwxNCBAQCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6TGF5b3V0VGVzdENvbnRyb2xs ZXIoYm9vbCB0ZXN0UmVwYWludERlZmF1bHQsIGJvb2wgdGVzdFJlcAogICAgICwgbV9jYW5PcGVu V2luZG93cyhmYWxzZSkKICAgICAsIG1fY2xvc2VSZW1haW5pbmdXaW5kb3dzV2hlbkNvbXBsZXRl KHRydWUpCiAgICAgLCBtX3N0b3BQcm92aXNpb25hbEZyYW1lTG9hZHMoZmFsc2UpCi0gICAgLCBt X3Rlc3RSZXBhaW50KHRlc3RSZXBhaW50RGVmYXVsdCkKLSAgICAsIG1fdGVzdFJlcGFpbnRTd2Vl cEhvcml6b250YWxseSh0ZXN0UmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5RGVmYXVsdCkKKyAgICAs IG1fdGVzdE9uc2NyZWVuKGZhbHNlKQorICAgICwgbV90ZXN0UmVwYWludChmYWxzZSkKKyAgICAs IG1fdGVzdFJlcGFpbnRTd2VlcEhvcml6b250YWxseShmYWxzZSkKICAgICAsIG1fd2FpdFRvRHVt cChmYWxzZSkKICAgICAsIG1fd2luZG93SXNLZXkodHJ1ZSkKICAgICAsIG1fZ2xvYmFsRmxhZyhm YWxzZSkKKyAgICAsIG1fdGVzdFBhdGhPclVSTCh0ZXN0UGF0aE9yVVJMKQorICAgICwgbV9leHBl Y3RlZFBpeGVsSGFzaChleHBlY3RlZFBpeGVsSGFzaCkKIHsKIH0KIApAQCAtMjA1LDYgKzIwOCwx MyBAQCBzdGF0aWMgSlNWYWx1ZVJlZiBzZXRDbG9zZVJlbWFpbmluZ1dpbmRvd3NXaGVuQ29tcGxl dGVDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udAogICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVm aW5lZChjb250ZXh0KTsKIH0KIAorc3RhdGljIEpTVmFsdWVSZWYgdGVzdE9uc2NyZWVuQ2FsbGJh Y2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJl ZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1 bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQoreworICAgIExheW91dFRlc3RDb250cm9s bGVyKiBjb250cm9sbGVyID0gcmVpbnRlcnByZXRfY2FzdDxMYXlvdXRUZXN0Q29udHJvbGxlcio+ KEpTT2JqZWN0R2V0UHJpdmF0ZSh0aGlzT2JqZWN0KSk7CisgICAgY29udHJvbGxlci0+c2V0VGVz dE9uc2NyZWVuKHRydWUpOworICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0 KTsKK30KKwogc3RhdGljIEpTVmFsdWVSZWYgdGVzdFJlcGFpbnRDYWxsYmFjayhKU0NvbnRleHRS ZWYgY29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpTT2JqZWN0UmVmIHRoaXNPYmplY3Qs IHNpemVfdCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50c1tdLCBKU1Zh bHVlUmVmKiBleGNlcHRpb24pCiB7CiAgICAgTGF5b3V0VGVzdENvbnRyb2xsZXIqIGNvbnRyb2xs ZXIgPSByZWludGVycHJldF9jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNPYmplY3RHZXRQ cml2YXRlKHRoaXNPYmplY3QpKTsKQEAgLTc0NSw2ICs3NTUsNyBAQCBKU1N0YXRpY0Z1bmN0aW9u KiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c3RhdGljRnVuY3Rpb25zKCkKICAgICAgICAgeyAic2V0 VXNlclN0eWxlU2hlZXRFbmFibGVkIiwgc2V0VXNlclN0eWxlU2hlZXRFbmFibGVkQ2FsbGJhY2ss IGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnRE ZWxldGUgfSwKICAgICAgICAgeyAic2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbiIsIHNldFVzZXJT dHlsZVNoZWV0TG9jYXRpb25DYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8 IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJzZXRXaW5kb3dJ c0tleSIsIHNldFdpbmRvd0lzS2V5Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9u bHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAgICAgICAgeyAidGVzdE9u c2NyZWVuIiwgdGVzdE9uc2NyZWVuQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9u bHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAidGVzdFJl cGFpbnQiLCB0ZXN0UmVwYWludENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5 IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgIndhaXRVbnRp bERvbmUiLCB3YWl0VW50aWxEb25lQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9u bHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAid2luZG93 Q291bnQiLCB3aW5kb3dDb3VudENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5 IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCmRpZmYgLS1naXQgYS9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oIGIvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAppbmRleCA4ZTMzZTA5Li42NDlk YjdhIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29u dHJvbGxlci5oCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250 cm9sbGVyLmgKQEAgLTMxLDEwICszMSwxMSBAQAogCiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUv SlNPYmplY3RSZWYuaD4KICNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgorI2luY2x1ZGUgPHN0 cmluZz4KIAogY2xhc3MgTGF5b3V0VGVzdENvbnRyb2xsZXIgOiBwdWJsaWMgUmVmQ291bnRlZDxM YXlvdXRUZXN0Q29udHJvbGxlcj4gewogcHVibGljOgotICAgIExheW91dFRlc3RDb250cm9sbGVy KGJvb2wgdGVzdFJlcGFpbnREZWZhdWx0LCBib29sIHRlc3RSZXBhaW50U3dlZXBIb3Jpem9udGFs bHlEZWZhdWx0KTsKKyAgICBMYXlvdXRUZXN0Q29udHJvbGxlcihjb25zdCBzdGQ6OnN0cmluZyYg dGVzdFBhdGhPclVSTCwgY29uc3Qgc3RkOjpzdHJpbmcmIGV4cGVjdGVkUGl4ZWxIYXNoKTsKICAg ICB+TGF5b3V0VGVzdENvbnRyb2xsZXIoKTsKIAogICAgIHZvaWQgbWFrZVdpbmRvd09iamVjdChK U0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgd2luZG93T2JqZWN0LCBKU1ZhbHVlUmVm KiBleGNlcHRpb24pOwpAQCAtMTMwLDYgKzEzMSw5IEBAIHB1YmxpYzoKICAgICBib29sIHN0b3BQ cm92aXNpb25hbEZyYW1lTG9hZHMoKSBjb25zdCB7IHJldHVybiBtX3N0b3BQcm92aXNpb25hbEZy YW1lTG9hZHM7IH0KICAgICB2b2lkIHNldFN0b3BQcm92aXNpb25hbEZyYW1lTG9hZHMoYm9vbCBz dG9wUHJvdmlzaW9uYWxGcmFtZUxvYWRzKSB7IG1fc3RvcFByb3Zpc2lvbmFsRnJhbWVMb2FkcyA9 IHN0b3BQcm92aXNpb25hbEZyYW1lTG9hZHM7IH0KIAorICAgIGJvb2wgdGVzdE9uc2NyZWVuKCkg Y29uc3QgeyByZXR1cm4gbV90ZXN0T25zY3JlZW47IH0KKyAgICB2b2lkIHNldFRlc3RPbnNjcmVl bihib29sIHRlc3RPbnNjcmVlbikgeyBtX3Rlc3RPbnNjcmVlbiA9IHRlc3RPbnNjcmVlbjsgfQor CiAgICAgYm9vbCB0ZXN0UmVwYWludCgpIGNvbnN0IHsgcmV0dXJuIG1fdGVzdFJlcGFpbnQ7IH0K ICAgICB2b2lkIHNldFRlc3RSZXBhaW50KGJvb2wgdGVzdFJlcGFpbnQpIHsgbV90ZXN0UmVwYWlu dCA9IHRlc3RSZXBhaW50OyB9CiAKQEAgLTE0NCw3ICsxNDgsMTAgQEAgcHVibGljOgogCiAgICAg Ym9vbCBnbG9iYWxGbGFnKCkgY29uc3QgeyByZXR1cm4gbV9nbG9iYWxGbGFnOyB9CiAgICAgdm9p ZCBzZXRHbG9iYWxGbGFnKGJvb2wgZ2xvYmFsRmxhZykgeyBtX2dsb2JhbEZsYWcgPSBnbG9iYWxG bGFnOyB9Ci0KKyAgICAKKyAgICBjb25zdCBzdGQ6OnN0cmluZyYgdGVzdFBhdGhPclVSTCgpIGNv bnN0IHsgcmV0dXJuIG1fdGVzdFBhdGhPclVSTDsgfQorICAgIGNvbnN0IHN0ZDo6c3RyaW5nJiBl eHBlY3RlZFBpeGVsSGFzaCgpIGNvbnN0IHsgcmV0dXJuIG1fZXhwZWN0ZWRQaXhlbEhhc2g7IH0K KyAgICAKIHByaXZhdGU6CiAgICAgYm9vbCBtX2R1bXBBc1RleHQ7CiAgICAgYm9vbCBtX2R1bXBB c1BERjsKQEAgLTE2NSw2ICsxNzIsNyBAQCBwcml2YXRlOgogICAgIGJvb2wgbV9jYW5PcGVuV2lu ZG93czsKICAgICBib29sIG1fY2xvc2VSZW1haW5pbmdXaW5kb3dzV2hlbkNvbXBsZXRlOwogICAg IGJvb2wgbV9zdG9wUHJvdmlzaW9uYWxGcmFtZUxvYWRzOworICAgIGJvb2wgbV90ZXN0T25zY3Jl ZW47CiAgICAgYm9vbCBtX3Rlc3RSZXBhaW50OwogICAgIGJvb2wgbV90ZXN0UmVwYWludFN3ZWVw SG9yaXpvbnRhbGx5OwogICAgIGJvb2wgbV93YWl0VG9EdW1wOyAvLyBUcnVlIGlmIHdhaXRVbnRp bERvbmUoKSBoYXMgYmVlbiBjYWxsZWQsIGJ1dCBub3RpZnlEb25lKCkgaGFzIG5vdCB5ZXQgYmVl biBjYWxsZWQuCkBAIC0xNzIsNiArMTgwLDkgQEAgcHJpdmF0ZToKIAogICAgIGJvb2wgbV9nbG9i YWxGbGFnOwogCisgICAgc3RkOjpzdHJpbmcgbV90ZXN0UGF0aE9yVVJMOworICAgIHN0ZDo6c3Ry aW5nIG1fZXhwZWN0ZWRQaXhlbEhhc2g7ICAgIC8vIGVtcHR5IHN0cmluZyBpZiBubyBoYXNoCisg ICAgCiAgICAgc3RhdGljIEpTQ2xhc3NSZWYgZ2V0SlNDbGFzcygpOwogICAgIHN0YXRpYyBKU1N0 YXRpY1ZhbHVlKiBzdGF0aWNWYWx1ZXMoKTsKICAgICBzdGF0aWMgSlNTdGF0aWNGdW5jdGlvbiog c3RhdGljRnVuY3Rpb25zKCk7CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9QaXhlbER1bXBTdXBwb3J0LmggYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9QaXhlbER1 bXBTdXBwb3J0LmgKaW5kZXggMzIxNGQwNC4uZDRmODk0OCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvUGl4ZWxEdW1wU3VwcG9ydC5oCisrKyBiL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL1BpeGVsRHVtcFN1cHBvcnQuaApAQCAtMjksMTIgKzI5LDE4IEBACiAjaWZu ZGVmIFBpeGVsRHVtcFN1cHBvcnRfaAogI2RlZmluZSBQaXhlbER1bXBTdXBwb3J0X2gKIAotdm9p ZCBkdW1wV2ViVmlld0FzUGl4ZWxzQW5kQ29tcGFyZVdpdGhFeHBlY3RlZChjb25zdCBjaGFyKiBj dXJyZW50VGVzdCwgYm9vbCBmb3JjZUFsbFRlc3RzVG9EdW1wUGl4ZWxzKTsKKyNpbmNsdWRlIDxz dHJpbmc+CisKK3ZvaWQgZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0ZWQo Y29uc3Qgc3RkOjpzdHJpbmcmIGV4cGVjdGVkSGFzaCk7CisKKyNpZiBQTEFURk9STShNQUMpCiAK IC8vIENhbiBiZSB1c2VkIGFzIGEgc2lnbmFsIGhhbmRsZXIKLXZvaWQgcmVzdG9yZUNvbG9yU3Bh Y2UoaW50IGlnbm9yZWQpOwordm9pZCByZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUoaW50 IGlnbm9yZWQpOworCisvLyBNYXkgY2hhbmdlIHlvdXIgY29sb3Igc3BhY2UsIHJlcXVpcmluZyBh IGNhbGwgdG8gcmVzdG9yZU1haW5EaXNwbGF5Q29sb3JQcm9maWxlCit2b2lkIHNldHVwTWFpbkRp c3BsYXlDb2xvclByb2ZpbGUoKTsKIAotLy8gTWF5IGNoYW5nZSB5b3VyIGNvbG9yIHNwYWNlLCBy ZXF1aXJpbmcgYSBjYWxsIHRvIHJlc3RvcmVDb2xvclNwYWNlCi12b2lkIGluaXRpYWxpemVDb2xv clNwYWNlQW5kU2NyZWVCdWZmZXJGb3JQaXhlbFRlc3RzKCk7CisjZW5kaWYKIAogI2VuZGlmIC8v IFBpeGVsRHVtcFN1cHBvcnRfaApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvY2cvSW1hZ2VEaWZmQ0cuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvSW1h Z2VEaWZmQ0cuY3BwCmluZGV4IGMzOTM5MTMuLmQ4MGYwNTIgMTAwNjQ0Ci0tLSBhL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL2NnL0ltYWdlRGlmZkNHLmNwcAorKysgYi9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9jZy9JbWFnZURpZmZDRy5jcHAKQEAgLTM2LDYgKzM2LDcgQEAKICNpZiBQ TEFURk9STShXSU4pCiAjaW5jbHVkZSA8ZmNudGwuaD4KICNpbmNsdWRlIDxpby5oPgorI2luY2x1 ZGUgPHd0Zi9NYXRoRXh0cmFzLmg+CiAjZW5kaWYKIAogI2lmIFBMQVRGT1JNKE1BQykKQEAgLTU0 LDYgKzU1LDEwIEBAIHR5cGVkZWYgZmxvYXQgQ0dGbG9hdDsKIHVzaW5nIG5hbWVzcGFjZSBzdGQ7 CiAKICNpZiBQTEFURk9STShXSU4pCitzdGF0aWMgaW5saW5lIGZsb2F0IHN0cnRvZihjb25zdCBj aGFyICpucHRyLCBjaGFyICoqZW5kcHRyKQoreworICAgIHJldHVybiBzdHJ0b2QobnB0ciwgZW5k cHRyKTsKK30KIHN0YXRpYyBjb25zdCBDRlN0cmluZ1JlZiBrVVRUeXBlUE5HID0gQ0ZTVFIoInB1 YmxpYy5wbmciKTsKICNlbmRpZgogCkBAIC03Miw5OSArNzcsOTkgQEAgc3RhdGljIFJldGFpblB0 cjxDR0ltYWdlUmVmPiBjcmVhdGVJbWFnZUZyb21TdGRpbihpbnQgYnl0ZXNSZW1haW5pbmcpCiAg ICAgcmV0dXJuIFJldGFpblB0cjxDR0ltYWdlUmVmPihBZG9wdENGLCBDR0ltYWdlQ3JlYXRlV2l0 aFBOR0RhdGFQcm92aWRlcihkYXRhUHJvdmlkZXIuZ2V0KCksIDAsIGZhbHNlLCBrQ0dSZW5kZXJp bmdJbnRlbnREZWZhdWx0KSk7CiB9CiAKLS8vIEdlbmVyYXRlcyBhbiBSR0JBOCBiaXRtYXAgaW4g dGhlIHJlZmVyZW5jZSBpbWFnZSBjb2xvcnNwYWNlIGNvbnRhaW5pbmcgdGhlIGRpZmZlcmVuY2Vz IGJldHdlZW4gdGhlIDIgaW1hZ2VzCi1zdGF0aWMgUmV0YWluUHRyPENHQ29udGV4dFJlZj4gY3Jl YXRlRGlmZmVyZW5jZUJpdG1hcChDR0ltYWdlUmVmIHRlc3RJbWFnZSwgQ0dJbWFnZVJlZiByZWZl cmVuY2VJbWFnZSkKK3N0YXRpYyB2b2lkIHJlbGVhc2VNYWxsb2NCdWZmZXIodm9pZCogaW5mbywg Y29uc3Qgdm9pZCogZGF0YSwgc2l6ZV90IHNpemUpCiB7Ci0gICAgLy8gd2UgbXVzdCBoYXZlIGJv dGggaW1hZ2VzIHRvIHRha2UgZGlmZgotICAgIGlmICghdGVzdEltYWdlIHx8ICFyZWZlcmVuY2VJ bWFnZSkgewotICAgICAgICBmcHJpbnRmKHN0ZGVyciwgInRlc3Qgb3IgcmVmZXJlbmNlIGltYWdl IGlzIG1pc3NpbmchIik7Ci0gICAgICAgIHJldHVybiAwOwotICAgIH0KLQotICAgIC8vIHdlIG11 c3QgaGF2ZSBib3RoIGltYWdlcyBiZSB0aGUgc2FtZSBkaW1lbnNpb25zCi0gICAgaWYgKChDR0lt YWdlR2V0V2lkdGgodGVzdEltYWdlKSAhPSBDR0ltYWdlR2V0V2lkdGgocmVmZXJlbmNlSW1hZ2Up KSB8fCAoQ0dJbWFnZUdldEhlaWdodCh0ZXN0SW1hZ2UpICE9IENHSW1hZ2VHZXRIZWlnaHQocmVm ZXJlbmNlSW1hZ2UpKSkgewotICAgICAgICBmcHJpbnRmKHN0ZGVyciwgInRlc3QgYW5kIHJlZmVy ZW5jZSBpbWFnZSBkaW1lbnNpb25zIGRvbid0IG1hdGNoISIpOwotICAgICAgICByZXR1cm4gMDsK LSAgICB9Ci0KLSAgICAvLyB3ZSBtdXN0IGhhdmUgYm90aCBpbWFnZXMgaW4gdGhlIHNhbWUgY29s b3JzcGFjZQotICAgIGlmICghQ0ZFcXVhbChDR0ltYWdlR2V0Q29sb3JTcGFjZSh0ZXN0SW1hZ2Up LCBDR0ltYWdlR2V0Q29sb3JTcGFjZShyZWZlcmVuY2VJbWFnZSkpKSB7Ci0gICAgICAgIGZwcmlu dGYoc3RkZXJyLCAidGVzdCBhbmQgcmVmZXJlbmNlIGltYWdlIGNvbG9yc3BhY2VzIGRvbid0IG1h dGNoISIpOwotICAgICAgICByZXR1cm4gMDsKLSAgICB9Ci0KLSAgICBzdGF0aWMgQ0ZNdXRhYmxl RGF0YVJlZiBkYXRhID0gQ0ZEYXRhQ3JlYXRlTXV0YWJsZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCAw KTsKLSAgICBzaXplX3Qgcm93Qnl0ZXMgPSAoNCAqIENHSW1hZ2VHZXRXaWR0aChyZWZlcmVuY2VJ bWFnZSkgKyA2MykgJiB+NjM7IC8vIFVzZSBhIG11bHRpcGxlIG9mIDY0IGJ5dGVzIHRvIGltcHJv dmUgQ0cgcGVyZm9ybWFuY2UKLSAgICBDRkRhdGFTZXRMZW5ndGgoZGF0YSwgQ0dJbWFnZUdldEhl aWdodChyZWZlcmVuY2VJbWFnZSkgKiByb3dCeXRlcyk7Ci0gICAgUmV0YWluUHRyPENHQ29udGV4 dFJlZj4gY29udGV4dChBZG9wdENGLCBDR0JpdG1hcENvbnRleHRDcmVhdGUoQ0ZEYXRhR2V0TXV0 YWJsZUJ5dGVQdHIoZGF0YSksIENHSW1hZ2VHZXRXaWR0aChyZWZlcmVuY2VJbWFnZSksIENHSW1h Z2VHZXRIZWlnaHQocmVmZXJlbmNlSW1hZ2UpLCA4LCByb3dCeXRlcywgQ0dJbWFnZUdldENvbG9y U3BhY2UocmVmZXJlbmNlSW1hZ2UpLCBrQ0dJbWFnZUFscGhhUHJlbXVsdGlwbGllZExhc3QgfCBr Q0dCaXRtYXBCeXRlT3JkZXIzMkJpZykpOwotCi0gICAgQ0dDb250ZXh0U2V0QmxlbmRNb2RlKGNv bnRleHQuZ2V0KCksIGtDR0JsZW5kTW9kZU5vcm1hbCk7Ci0gICAgQ0dDb250ZXh0RHJhd0ltYWdl KGNvbnRleHQuZ2V0KCksIENHUmVjdE1ha2UoMCwgMCwgc3RhdGljX2Nhc3Q8Q0dGbG9hdD4oQ0dJ bWFnZUdldFdpZHRoKHRlc3RJbWFnZSkpLCBzdGF0aWNfY2FzdDxDR0Zsb2F0PihDR0ltYWdlR2V0 SGVpZ2h0KHRlc3RJbWFnZSkpKSwgdGVzdEltYWdlKTsKLSAgICBDR0NvbnRleHRTZXRCbGVuZE1v ZGUoY29udGV4dC5nZXQoKSwga0NHQmxlbmRNb2RlRGlmZmVyZW5jZSk7Ci0gICAgQ0dDb250ZXh0 RHJhd0ltYWdlKGNvbnRleHQuZ2V0KCksIENHUmVjdE1ha2UoMCwgMCwgc3RhdGljX2Nhc3Q8Q0dG bG9hdD4oQ0dJbWFnZUdldFdpZHRoKHJlZmVyZW5jZUltYWdlKSksIHN0YXRpY19jYXN0PENHRmxv YXQ+KENHSW1hZ2VHZXRIZWlnaHQocmVmZXJlbmNlSW1hZ2UpKSksIHJlZmVyZW5jZUltYWdlKTsK LQotICAgIHJldHVybiBjb250ZXh0OworICAgIGZyZWUoKHZvaWQqKWRhdGEpOwogfQogCi0vLyBD b3VudHMgdGhlIG51bWJlciBvZiBub24tYmxhY2sgcGl4ZWxzLCBhbmQgcmV0dXJucyB0aGUgcGVy Y2VudGFnZSBvZiBub24tYmxhY2sgcGl4ZWxzIHRvIHRvdGFsIHBpeGVscyBpbiB0aGUgaW1hZ2Uu Ci1zdGF0aWMgZmxvYXQgY29tcHV0ZVBlcmNlbnRhZ2VEaWZmZXJlbnQoQ0dDb250ZXh0UmVmIGRp ZmZCaXRtYXAsIHVuc2lnbmVkIHRocmVzaG9sZCkKK3N0YXRpYyBSZXRhaW5QdHI8Q0dJbWFnZVJl Zj4gY3JlYXRlRGlmZmVyZW5jZUltYWdlKENHSW1hZ2VSZWYgYmFzZUltYWdlLCBDR0ltYWdlUmVm IHRlc3RJbWFnZSwgZmxvYXQmIGRpZmZlcmVuY2UpCiB7Ci0gICAgLy8gaWYgZGlmZkJpdG1hcCBp cyBuaWwsIHRoZW4gdGhlcmUgd2FzIGFuIGVycm9yLCBhbmQgaXQgZGlkbid0IG1hdGNoLgotICAg IGlmICghZGlmZkJpdG1hcCkKLSAgICAgICAgcmV0dXJuIDEwMC4wZjsKLQotICAgIHNpemVfdCBw aXhlbHNIaWdoID0gQ0dCaXRtYXBDb250ZXh0R2V0SGVpZ2h0KGRpZmZCaXRtYXApOwotICAgIHNp emVfdCBwaXhlbHNXaWRlID0gQ0dCaXRtYXBDb250ZXh0R2V0V2lkdGgoZGlmZkJpdG1hcCk7Ci0g ICAgc2l6ZV90IGJ5dGVzUGVyUm93ID0gQ0dCaXRtYXBDb250ZXh0R2V0Qnl0ZXNQZXJSb3coZGlm ZkJpdG1hcCk7Ci0gICAgdW5zaWduZWQgY2hhciogcGl4ZWxSb3dEYXRhID0gc3RhdGljX2Nhc3Q8 dW5zaWduZWQgY2hhcio+KENHQml0bWFwQ29udGV4dEdldERhdGEoZGlmZkJpdG1hcCkpOwotICAg IHVuc2lnbmVkIGRpZmZlcmVuY2VzID0gMDsKLQotICAgIGZvciAodW5zaWduZWQgcm93ID0gMDsg cm93IDwgcGl4ZWxzSGlnaDsgcm93KyspIHsKLSAgICAgICAgZm9yICh1bnNpZ25lZCBjb2wgPSAw OyBjb2wgPCAocGl4ZWxzV2lkZSAqIDQpOyBjb2wgKz0gNCkgewotICAgICAgICAgICAgdW5zaWdu ZWQgY2hhciogcmVkID0gcGl4ZWxSb3dEYXRhICsgY29sOwotICAgICAgICAgICAgdW5zaWduZWQg Y2hhciogZ3JlZW4gPSByZWQgKyAxOwotICAgICAgICAgICAgdW5zaWduZWQgY2hhciogYmx1ZSA9 IHJlZCArIDI7Ci0gICAgICAgICAgICB1bnNpZ25lZCBkaXN0YW5jZSA9ICpyZWQgKyAqZ3JlZW4g KyAqYmx1ZTsKLSAgICAgICAgICAgIGlmIChkaXN0YW5jZSA+IHRocmVzaG9sZCkgewotICAgICAg ICAgICAgICAgIGRpZmZlcmVuY2VzKys7Ci0gICAgICAgICAgICAgICAgLy8gc2hpZnQgdGhlIHBp eGVscyB0b3dhcmRzIHdoaXRlIHRvIG1ha2UgdGhlbSBtb3JlIHZpc2libGUKLSAgICAgICAgICAg ICAgICAqcmVkID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcj4obWluKFVDSEFSX01BWCwgKnJl ZCArIDEwMCkpOwotICAgICAgICAgICAgICAgICpncmVlbiA9IHN0YXRpY19jYXN0PHVuc2lnbmVk IGNoYXI+KG1pbihVQ0hBUl9NQVgsICpncmVlbiArIDEwMCkpOwotICAgICAgICAgICAgICAgICpi bHVlID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcj4obWluKFVDSEFSX01BWCwgKmJsdWUgKyAx MDApKTsKKyAgICBzdGF0aWMgUmV0YWluUHRyPENHQ29sb3JTcGFjZVJlZj4gY29sb3JTcGFjZShB ZG9wdENGLCBDR0NvbG9yU3BhY2VDcmVhdGVEZXZpY2VSR0IoKSk7CisgICAgUmV0YWluUHRyPENH SW1hZ2VSZWY+IGRpZmZJbWFnZTsKKyAgICAKKyAgICBzaXplX3Qgd2lkdGggPSBDR0ltYWdlR2V0 V2lkdGgoYmFzZUltYWdlKTsKKyAgICBzaXplX3QgaGVpZ2h0ID0gQ0dJbWFnZUdldEhlaWdodChi YXNlSW1hZ2UpOworICAgIHNpemVfdCByb3dCeXRlcyA9IHdpZHRoICogNDsKKyAgICAKKyAgICAv LyBEcmF3IGJhc2UgaW1hZ2UgaW4gYml0bWFwIGNvbnRleHQKKyAgICB2b2lkKiBiYXNlQnVmZmVy ID0gY2FsbG9jKGhlaWdodCwgcm93Qnl0ZXMpOworICAgIENHQ29udGV4dFJlZiBiYXNlQ29udGV4 dCA9IENHQml0bWFwQ29udGV4dENyZWF0ZShiYXNlQnVmZmVyLCB3aWR0aCwgaGVpZ2h0LCA4LCBy b3dCeXRlcywgY29sb3JTcGFjZS5nZXQoKSwga0NHSW1hZ2VBbHBoYVByZW11bHRpcGxpZWRGaXJz dCB8IGtDR0JpdG1hcEJ5dGVPcmRlcjMySG9zdCk7CisgICAgQ0dDb250ZXh0RHJhd0ltYWdlKGJh c2VDb250ZXh0LCBDR1JlY3RNYWtlKDAsIDAsIHdpZHRoLCBoZWlnaHQpLCBiYXNlSW1hZ2UpOwor ICAgIENHQ29udGV4dFJlbGVhc2UoYmFzZUNvbnRleHQpOworICAgIAorICAgIC8vIERyYXcgdGVz dCBpbWFnZSBpbiBiaXRtYXAgY29udGV4dAorICAgIHZvaWQqIGJ1ZmZlciA9IGNhbGxvYyhoZWln aHQsIHJvd0J5dGVzKTsKKyAgICBDR0NvbnRleHRSZWYgY29udGV4dCA9IENHQml0bWFwQ29udGV4 dENyZWF0ZShidWZmZXIsIHdpZHRoLCBoZWlnaHQsIDgsIHJvd0J5dGVzLCBjb2xvclNwYWNlLmdl dCgpLCBrQ0dJbWFnZUFscGhhUHJlbXVsdGlwbGllZEZpcnN0IHwga0NHQml0bWFwQnl0ZU9yZGVy MzJIb3N0KTsKKyAgICBDR0NvbnRleHREcmF3SW1hZ2UoY29udGV4dCwgQ0dSZWN0TWFrZSgwLCAw LCB3aWR0aCwgaGVpZ2h0KSwgdGVzdEltYWdlKTsKKyAgICBDR0NvbnRleHRSZWxlYXNlKGNvbnRl eHQpOworICAgIAorICAgIC8vIENvbXBhcmUgdGhlIGNvbnRlbnQgb2YgdGhlIDIgYml0bWFwcwor ICAgIHZvaWQqIGRpZmZCdWZmZXIgPSBtYWxsb2Mod2lkdGggKiBoZWlnaHQpOworICAgIGZsb2F0 IGNvdW50ID0gMC4wZjsKKyAgICBmbG9hdCBzdW0gPSAwLjBmOworICAgIGZsb2F0IG1heERpc3Rh bmNlID0gMC4wZjsKKyAgICB1bnNpZ25lZCBjaGFyKiBiYXNlUGl4ZWwgPSAodW5zaWduZWQgY2hh ciopYmFzZUJ1ZmZlcjsKKyAgICB1bnNpZ25lZCBjaGFyKiBwaXhlbCA9ICh1bnNpZ25lZCBjaGFy KilidWZmZXI7CisgICAgdW5zaWduZWQgY2hhciogZGlmZiA9ICh1bnNpZ25lZCBjaGFyKilkaWZm QnVmZmVyOworICAgIGZvciAoc2l6ZV90IHkgPSAwOyB5IDwgaGVpZ2h0OyArK3kpIHsKKyAgICAg ICAgZm9yIChzaXplX3QgeCA9IDA7IHggPCB3aWR0aDsgKyt4KSB7CisgICAgICAgICAgICBmbG9h dCByZWQgPSAocGl4ZWxbMF0gLSBiYXNlUGl4ZWxbMF0pIC8gbWF4PGZsb2F0PigyNTUgLSBiYXNl UGl4ZWxbMF0sIGJhc2VQaXhlbFswXSk7CisgICAgICAgICAgICBmbG9hdCBncmVlbiA9IChwaXhl bFsxXSAtIGJhc2VQaXhlbFsxXSkgLyBtYXg8ZmxvYXQ+KDI1NSAtIGJhc2VQaXhlbFsxXSwgYmFz ZVBpeGVsWzFdKTsKKyAgICAgICAgICAgIGZsb2F0IGJsdWUgPSAocGl4ZWxbMl0gLSBiYXNlUGl4 ZWxbMl0pIC8gbWF4PGZsb2F0PigyNTUgLSBiYXNlUGl4ZWxbMl0sIGJhc2VQaXhlbFsyXSk7Cisg ICAgICAgICAgICBmbG9hdCBhbHBoYSA9IChwaXhlbFszXSAtIGJhc2VQaXhlbFszXSkgLyBtYXg8 ZmxvYXQ+KDI1NSAtIGJhc2VQaXhlbFszXSwgYmFzZVBpeGVsWzNdKTsKKyAgICAgICAgICAgIGZs b2F0IGRpc3RhbmNlID0gc3FydGYocmVkICogcmVkICsgZ3JlZW4gKiBncmVlbiArIGJsdWUgKiBi bHVlICsgYWxwaGEgKiBhbHBoYSkgLyAyLjBmOworICAgICAgICAgICAgCisgICAgICAgICAgICAq ZGlmZisrID0gKHVuc2lnbmVkIGNoYXIpKGRpc3RhbmNlICogMjU1LjBmKTsKKyAgICAgICAgICAg IAorICAgICAgICAgICAgaWYgKGRpc3RhbmNlID49IDEuMGYgLyAyNTUuMGYpIHsKKyAgICAgICAg ICAgICAgICBjb3VudCArPSAxLjBmOworICAgICAgICAgICAgICAgIHN1bSArPSBkaXN0YW5jZTsK KyAgICAgICAgICAgICAgICBpZiAoZGlzdGFuY2UgPiBtYXhEaXN0YW5jZSkKKyAgICAgICAgICAg ICAgICAgICAgbWF4RGlzdGFuY2UgPSBkaXN0YW5jZTsKICAgICAgICAgICAgIH0KKyAgICAgICAg ICAgIAorICAgICAgICAgICAgYmFzZVBpeGVsICs9IDQ7CisgICAgICAgICAgICBwaXhlbCArPSA0 OwogICAgICAgICB9Ci0gICAgICAgIHBpeGVsUm93RGF0YSArPSBieXRlc1BlclJvdzsKICAgICB9 Ci0KLSAgICBmbG9hdCB0b3RhbFBpeGVscyA9IHN0YXRpY19jYXN0PGZsb2F0PihwaXhlbHNIaWdo ICogcGl4ZWxzV2lkZSk7Ci0gICAgcmV0dXJuIChkaWZmZXJlbmNlcyAqIDEwMC5mKSAvIHRvdGFs UGl4ZWxzOworICAgIAorICAgIC8vIENvbXB1dGUgdGhlIGRpZmZlcmVuY2UgYXMgYSBwZXJjZW50 YWdlIGNvbWJpbmluZyBib3RoIHRoZSBudW1iZXIgb2YgZGlmZmVyZW50IHBpeGVscyBhbmQgdGhl aXIgZGlmZmVyZW5jZSBhbW91bnQgaS5lLiB0aGUgYXZlcmFnZSBkaXN0YW5jZSBvdmVyIHRoZSBl bnRpcmUgaW1hZ2UKKyAgICBpZiAoY291bnQgPiAwLjBmKQorICAgICAgICBkaWZmZXJlbmNlID0g MTAwLjBmICogc3VtIC8gKGhlaWdodCAqIHdpZHRoKTsKKyAgICBlbHNlCisgICAgICAgIGRpZmZl cmVuY2UgPSAwLjBmOworICAgIAorICAgIC8vIEdlbmVyYXRlIGEgbm9ybWFsaXplZCBkaWZmIGlt YWdlIGlmIHRoZXJlIGlzIGFueSBkaWZmZXJlbmNlCisgICAgaWYgKGRpZmZlcmVuY2UgPiAwLjBm KSB7CisgICAgICAgIGlmIChtYXhEaXN0YW5jZSA8IDEuMGYpIHsKKyAgICAgICAgICAgIGRpZmYg PSAodW5zaWduZWQgY2hhciopZGlmZkJ1ZmZlcjsKKyAgICAgICAgICAgIGZvcihzaXplX3QgcCA9 IDA7IHAgPCBoZWlnaHQgKiB3aWR0aDsgKytwKQorICAgICAgICAgICAgICAgIGRpZmZbcF0gPSBk aWZmW3BdIC8gbWF4RGlzdGFuY2U7CisgICAgICAgIH0KKyAgICAgICAgCisgICAgICAgIENHRGF0 YVByb3ZpZGVyUmVmIHByb3ZpZGVyID0gQ0dEYXRhUHJvdmlkZXJDcmVhdGVXaXRoRGF0YSgwLCBk aWZmQnVmZmVyLCB3aWR0aCAqIGhlaWdodCwgcmVsZWFzZU1hbGxvY0J1ZmZlcik7CisgICAgICAg IENHQ29sb3JTcGFjZVJlZiBkaWZmQ29sb3JzcGFjZSA9IENHQ29sb3JTcGFjZUNyZWF0ZURldmlj ZUdyYXkoKTsKKyAgICAgICAgZGlmZkltYWdlLmFkb3B0Q0YoQ0dJbWFnZUNyZWF0ZSh3aWR0aCwg aGVpZ2h0LCA4LCA4LCB3aWR0aCwgZGlmZkNvbG9yc3BhY2UsIDAsIHByb3ZpZGVyLCAwLCBmYWxz ZSwga0NHUmVuZGVyaW5nSW50ZW50RGVmYXVsdCkpOworICAgICAgICBDR0NvbG9yU3BhY2VSZWxl YXNlKGRpZmZDb2xvcnNwYWNlKTsKKyAgICAgICAgQ0dEYXRhUHJvdmlkZXJSZWxlYXNlKHByb3Zp ZGVyKTsKKyAgICB9CisgICAgZWxzZQorICAgICAgICBmcmVlKGRpZmZCdWZmZXIpOworICAgIAor ICAgIC8vIERlc3Ryb3kgZHJhd2luZyBidWZmZXJzCisgICAgaWYgKGJ1ZmZlcikKKyAgICAgICAg ZnJlZShidWZmZXIpOworICAgIGlmIChiYXNlQnVmZmVyKQorICAgICAgICBmcmVlKGJhc2VCdWZm ZXIpOworICAgIAorICAgIHJldHVybiBkaWZmSW1hZ2U7CiB9CiAKLXN0YXRpYyB2b2lkIGNvbXBh cmVJbWFnZXMoQ0dJbWFnZVJlZiB0ZXN0SW1hZ2UsIENHSW1hZ2VSZWYgcmVmZXJlbmNlSW1hZ2Us IHVuc2lnbmVkIHRocmVzaG9sZCkKK3N0YXRpYyBpbmxpbmUgYm9vbCBpbWFnZUhhc0FscGhhKENH SW1hZ2VSZWYgaW1hZ2UpCiB7Ci0gICAgLy8gcHJlcGFyZSB0aGUgZGlmZmVyZW5jZSBibGVuZCB0 byBjaGVjayBmb3IgcGl4ZWwgdmFyaWF0aW9ucwotICAgIFJldGFpblB0cjxDR0NvbnRleHRSZWY+ IGRpZmZCaXRtYXAgPSBjcmVhdGVEaWZmZXJlbmNlQml0bWFwKHRlc3RJbWFnZSwgcmVmZXJlbmNl SW1hZ2UpOwotCi0gICAgZmxvYXQgcGVyY2VudGFnZSA9IGNvbXB1dGVQZXJjZW50YWdlRGlmZmVy ZW50KGRpZmZCaXRtYXAuZ2V0KCksIHRocmVzaG9sZCk7Ci0KLSAgICBwZXJjZW50YWdlID0gKGZs b2F0KSgoaW50KShwZXJjZW50YWdlICogMTAwLjBmKSkgLyAxMDAuMGY7IC8vIHJvdW5kIHRvIDIg ZGVjaW1hbCBwbGFjZXMKLQotICAgIC8vIHNlbmQgbWVzc2FnZSB0byBsZXQgdGhlbSBrbm93IGlm IGFuIGltYWdlIHdhcyB3cm9uZwotICAgIGlmIChwZXJjZW50YWdlID4gMC4wZikgewotICAgICAg ICAvLyBzaW5jZSB0aGUgZGlmZiBtaWdodCBhY3R1YWxseSBzaG93IHNvbWV0aGluZywgc2VuZCBp dCB0byBzdGRvdXQKLSAgICAgICAgaWYgKGRpZmZCaXRtYXApIHsKLSAgICAgICAgICAgIFJldGFp blB0cjxDR0ltYWdlUmVmPiBpbWFnZShBZG9wdENGLCBDR0JpdG1hcENvbnRleHRDcmVhdGVJbWFn ZShkaWZmQml0bWFwLmdldCgpKSk7Ci0gICAgICAgICAgICBSZXRhaW5QdHI8Q0ZNdXRhYmxlRGF0 YVJlZj4gaW1hZ2VEYXRhKEFkb3B0Q0YsIENGRGF0YUNyZWF0ZU11dGFibGUoMCwgMCkpOwotICAg ICAgICAgICAgUmV0YWluUHRyPENHSW1hZ2VEZXN0aW5hdGlvblJlZj4gaW1hZ2VEZXN0KEFkb3B0 Q0YsIENHSW1hZ2VEZXN0aW5hdGlvbkNyZWF0ZVdpdGhEYXRhKGltYWdlRGF0YS5nZXQoKSwga1VU VHlwZVBORywgMSwgMCkpOwotICAgICAgICAgICAgQ0dJbWFnZURlc3RpbmF0aW9uQWRkSW1hZ2Uo aW1hZ2VEZXN0LmdldCgpLCBpbWFnZS5nZXQoKSwgMCk7Ci0gICAgICAgICAgICBDR0ltYWdlRGVz dGluYXRpb25GaW5hbGl6ZShpbWFnZURlc3QuZ2V0KCkpOwotICAgICAgICAgICAgcHJpbnRmKCJD b250ZW50LUxlbmd0aDogJWx1XG4iLCBDRkRhdGFHZXRMZW5ndGgoaW1hZ2VEYXRhLmdldCgpKSk7 Ci0gICAgICAgICAgICBmd3JpdGUoQ0ZEYXRhR2V0Qnl0ZVB0cihpbWFnZURhdGEuZ2V0KCkpLCAx LCBDRkRhdGFHZXRMZW5ndGgoaW1hZ2VEYXRhLmdldCgpKSwgc3Rkb3V0KTsKLSAgICAgICAgfQot ICAgICAgICAKLSAgICAgICAgZnByaW50ZihzdGRvdXQsICJkaWZmOiAlMDEuMmYlJSBmYWlsZWRc biIsIHBlcmNlbnRhZ2UpOwotICAgIH0gZWxzZQotICAgICAgICBmcHJpbnRmKHN0ZG91dCwgImRp ZmY6ICUwMS4yZiUlIHBhc3NlZFxuIiwgcGVyY2VudGFnZSk7CisgICAgQ0dJbWFnZUFscGhhSW5m byBpbmZvID0gQ0dJbWFnZUdldEFscGhhSW5mbyhpbWFnZSk7CisgICAgCisgICAgcmV0dXJuIChp bmZvID49IGtDR0ltYWdlQWxwaGFQcmVtdWx0aXBsaWVkTGFzdCkgJiYgKGluZm8gPD0ga0NHSW1h Z2VBbHBoYUZpcnN0KTsKIH0KIAogaW50IG1haW4oaW50IGFyZ2MsIGNvbnN0IGNoYXIqIGFyZ3Zb XSkKQEAgLTE3NCwxMyArMTc5LDEzIEBAIGludCBtYWluKGludCBhcmdjLCBjb25zdCBjaGFyKiBh cmd2W10pCiAgICAgX3NldG1vZGUoMSwgX09fQklOQVJZKTsKICNlbmRpZgogCi0gICAgdW5zaWdu ZWQgdGhyZXNob2xkID0gMDsKKyAgICBmbG9hdCB0b2xlcmFuY2UgPSAwLjBmOwogCiAgICAgZm9y IChpbnQgaSA9IDE7IGkgPCBhcmdjOyArK2kpIHsKLSAgICAgICAgaWYgKCFzdHJjbXAoYXJndltp XSwgIi10IikgfHwgIXN0cmNtcChhcmd2W2ldLCAiLS10aHJlc2hvbGQiKSkgeworICAgICAgICBp ZiAoIXN0cmNtcChhcmd2W2ldLCAiLXQiKSB8fCAhc3RyY21wKGFyZ3ZbaV0sICItLXRvbGVyYW5j ZSIpKSB7CiAgICAgICAgICAgICBpZiAoaSA+PSBhcmdjIC0gMSkKICAgICAgICAgICAgICAgICBl eGl0KDEpOwotICAgICAgICAgICAgdGhyZXNob2xkID0gc3RydG9sKGFyZ3ZbaSArIDFdLCAwLCAw KTsKKyAgICAgICAgICAgIHRvbGVyYW5jZSA9IHN0cnRvZihhcmd2W2kgKyAxXSwgMCk7CiAgICAg ICAgICAgICArK2k7CiAgICAgICAgICAgICBjb250aW51ZTsKICAgICAgICAgfQpAQCAtMjA5LDcg KzIxNCwzNSBAQCBpbnQgbWFpbihpbnQgYXJnYywgY29uc3QgY2hhciogYXJndltdKQogICAgICAg ICB9CiAKICAgICAgICAgaWYgKGFjdHVhbEltYWdlICYmIGJhc2VsaW5lSW1hZ2UpIHsKLSAgICAg ICAgICAgIGNvbXBhcmVJbWFnZXMoYWN0dWFsSW1hZ2UuZ2V0KCksIGJhc2VsaW5lSW1hZ2UuZ2V0 KCksIHRocmVzaG9sZCk7CisgICAgICAgICAgICBSZXRhaW5QdHI8Q0dJbWFnZVJlZj4gZGlmZklt YWdlOworICAgICAgICAgICAgZmxvYXQgZGlmZmVyZW5jZSA9IDEwMC4wZjsKKyAgICAgICAgICAg IAorICAgICAgICAgICAgaWYgKChDR0ltYWdlR2V0V2lkdGgoYWN0dWFsSW1hZ2UuZ2V0KCkpID09 IENHSW1hZ2VHZXRXaWR0aChiYXNlbGluZUltYWdlLmdldCgpKSkgJiYgKENHSW1hZ2VHZXRIZWln aHQoYWN0dWFsSW1hZ2UuZ2V0KCkpID09IENHSW1hZ2VHZXRIZWlnaHQoYmFzZWxpbmVJbWFnZS5n ZXQoKSkpICYmIChpbWFnZUhhc0FscGhhKGFjdHVhbEltYWdlLmdldCgpKSA9PSBpbWFnZUhhc0Fs cGhhKGJhc2VsaW5lSW1hZ2UuZ2V0KCkpKSkgeworICAgICAgICAgICAgICAgIGRpZmZJbWFnZSA9 IGNyZWF0ZURpZmZlcmVuY2VJbWFnZShhY3R1YWxJbWFnZS5nZXQoKSwgYmFzZWxpbmVJbWFnZS5n ZXQoKSwgZGlmZmVyZW5jZSk7IC8vIGRpZmZlcmVuY2UgaXMgcGFzc2VkIGJ5IHJlZmVyZW5jZQor ICAgICAgICAgICAgICAgIGlmIChkaWZmZXJlbmNlIDw9IHRvbGVyYW5jZSkKKyAgICAgICAgICAg ICAgICAgICAgZGlmZmVyZW5jZSA9IDAuMGY7CisgICAgICAgICAgICAgICAgZWxzZSB7CisgICAg ICAgICAgICAgICAgICAgIGRpZmZlcmVuY2UgPSByb3VuZGYoZGlmZmVyZW5jZSAqIDEwMC4wZikg LyAxMDAuMGY7CisgICAgICAgICAgICAgICAgICAgIGRpZmZlcmVuY2UgPSBtYXgoZGlmZmVyZW5j ZSwgMC4wMWYpOyAvLyByb3VuZCB0byAyIGRlY2ltYWwgcGxhY2VzCisgICAgICAgICAgICAgICAg fQorICAgICAgICAgICAgfQorICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIGZwdXRz KCJlcnJvciwgdGVzdCBhbmQgcmVmZXJlbmNlIGltYWdlIGhhdmUgZGlmZmVyZW50IHByb3BlcnRp ZXMuXG4iLCBzdGRlcnIpOworICAgICAgICAgICAgICAgIAorICAgICAgICAgICAgaWYgKGRpZmZl cmVuY2UgPiAwLjBmKSB7CisgICAgICAgICAgICAgICAgaWYgKGRpZmZJbWFnZSkgeworICAgICAg ICAgICAgICAgICAgICBSZXRhaW5QdHI8Q0ZNdXRhYmxlRGF0YVJlZj4gaW1hZ2VEYXRhKEFkb3B0 Q0YsIENGRGF0YUNyZWF0ZU11dGFibGUoMCwgMCkpOworICAgICAgICAgICAgICAgICAgICBSZXRh aW5QdHI8Q0dJbWFnZURlc3RpbmF0aW9uUmVmPiBpbWFnZURlc3QoQWRvcHRDRiwgQ0dJbWFnZURl c3RpbmF0aW9uQ3JlYXRlV2l0aERhdGEoaW1hZ2VEYXRhLmdldCgpLCBrVVRUeXBlUE5HLCAxLCAw KSk7CisgICAgICAgICAgICAgICAgICAgIENHSW1hZ2VEZXN0aW5hdGlvbkFkZEltYWdlKGltYWdl RGVzdC5nZXQoKSwgZGlmZkltYWdlLmdldCgpLCAwKTsKKyAgICAgICAgICAgICAgICAgICAgQ0dJ bWFnZURlc3RpbmF0aW9uRmluYWxpemUoaW1hZ2VEZXN0LmdldCgpKTsKKyAgICAgICAgICAgICAg ICAgICAgcHJpbnRmKCJDb250ZW50LUxlbmd0aDogJWx1XG4iLCBDRkRhdGFHZXRMZW5ndGgoaW1h Z2VEYXRhLmdldCgpKSk7CisgICAgICAgICAgICAgICAgICAgIGZ3cml0ZShDRkRhdGFHZXRCeXRl UHRyKGltYWdlRGF0YS5nZXQoKSksIDEsIENGRGF0YUdldExlbmd0aChpbWFnZURhdGEuZ2V0KCkp LCBzdGRvdXQpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAKKyAgICAgICAg ICAgICAgICBmcHJpbnRmKHN0ZG91dCwgImRpZmY6ICUwMS4yZiUlIGZhaWxlZFxuIiwgZGlmZmVy ZW5jZSk7CisgICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgICAgICBmcHJpbnRmKHN0ZG91 dCwgImRpZmY6ICUwMS4yZiUlIHBhc3NlZFxuIiwgZGlmZmVyZW5jZSk7CisgICAgICAgICAgICAK ICAgICAgICAgICAgIGFjdHVhbEltYWdlID0gMDsKICAgICAgICAgICAgIGJhc2VsaW5lSW1hZ2Ug PSAwOwogICAgICAgICB9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9j Zy9QaXhlbER1bXBTdXBwb3J0Q0cuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cv UGl4ZWxEdW1wU3VwcG9ydENHLmNwcAppbmRleCAyNjBhOTRlLi4yMzIwZTE5IDEwMDY0NAotLS0g YS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9jZy9QaXhlbER1bXBTdXBwb3J0Q0cuY3BwCisr KyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5jcHAK QEAgLTM0LDcgKzM0LDEwIEBACiAjaW5jbHVkZSAiRHVtcFJlbmRlclRyZWUuaCIKICNpbmNsdWRl ICJMYXlvdXRUZXN0Q29udHJvbGxlci5oIgogI2luY2x1ZGUgPEltYWdlSU8vQ0dJbWFnZURlc3Rp bmF0aW9uLmg+CisjaW5jbHVkZSA8YWxnb3JpdGhtPgorI2luY2x1ZGUgPGN0eXBlLmg+CiAjaW5j bHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KKyNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CiAjaW5jbHVk ZSA8d3RmL1JldGFpblB0ci5oPgogI2luY2x1ZGUgPHd0Zi9TdHJpbmdFeHRyYXMuaD4KIApAQCAt NjMsNjYgKzY2LDY5IEBAIHN0YXRpYyB2b2lkIHByaW50UE5HKENHSW1hZ2VSZWYgaW1hZ2UpCiAg ICAgZndyaXRlKENGRGF0YUdldEJ5dGVQdHIoaW1hZ2VEYXRhLmdldCgpKSwgMSwgQ0ZEYXRhR2V0 TGVuZ3RoKGltYWdlRGF0YS5nZXQoKSksIHN0ZG91dCk7CiB9CiAKLXN0YXRpYyB2b2lkIGdldE1E NUhhc2hTdHJpbmdGb3JCaXRtYXAoQ0dDb250ZXh0UmVmIGJpdG1hcCwgY2hhciBzdHJpbmdbMzNd KQorc3RhdGljIHZvaWQgY29tcHV0ZU1ENUhhc2hTdHJpbmdGb3JCaXRtYXBDb250ZXh0KENHQ29u dGV4dFJlZiBiaXRtYXBDb250ZXh0LCBjaGFyIGhhc2hTdHJpbmdbMzNdKQogewotICAgIE1ENV9D VFggbWQ1Q29udGV4dDsKLSAgICB1bnNpZ25lZCBjaGFyIGhhc2hbMTZdOwotCi0gICAgc2l6ZV90 IGJpdHNQZXJQaXhlbCA9IENHQml0bWFwQ29udGV4dEdldEJpdHNQZXJQaXhlbChiaXRtYXApOwot ICAgIEFTU0VSVChiaXRzUGVyUGl4ZWwgPT0gMzIpOyAvLyBJbWFnZURpZmYgYXNzdW1lcyAzMiBi aXQgUkdCQSwgd2UgbXVzdCBhcyB3ZWxsLgotICAgIHNpemVfdCBieXRlc1BlclBpeGVsID0gYml0 c1BlclBpeGVsIC8gODsKLSAgICBzaXplX3QgcGl4ZWxzSGlnaCA9IENHQml0bWFwQ29udGV4dEdl dEhlaWdodChiaXRtYXApOwotICAgIHNpemVfdCBwaXhlbHNXaWRlID0gQ0dCaXRtYXBDb250ZXh0 R2V0V2lkdGgoYml0bWFwKTsKLSAgICBzaXplX3QgYnl0ZXNQZXJSb3cgPSBDR0JpdG1hcENvbnRl eHRHZXRCeXRlc1BlclJvdyhiaXRtYXApOwotICAgIEFTU0VSVChieXRlc1BlclJvdyA+PSAocGl4 ZWxzV2lkZSAqIGJ5dGVzUGVyUGl4ZWwpKTsKKyAgICBBU1NFUlQoQ0dCaXRtYXBDb250ZXh0R2V0 Qml0c1BlclBpeGVsKGJpdG1hcENvbnRleHQpID09IDMyKTsgLy8gSW1hZ2VEaWZmIGFzc3VtZXMg MzIgYml0IFJHQkEsIHdlIG11c3QgYXMgd2VsbC4KKyAgICBzaXplX3QgcGl4ZWxzSGlnaCA9IENH Qml0bWFwQ29udGV4dEdldEhlaWdodChiaXRtYXBDb250ZXh0KTsKKyAgICBzaXplX3QgcGl4ZWxz V2lkZSA9IENHQml0bWFwQ29udGV4dEdldFdpZHRoKGJpdG1hcENvbnRleHQpOworICAgIHNpemVf dCBieXRlc1BlclJvdyA9IENHQml0bWFwQ29udGV4dEdldEJ5dGVzUGVyUm93KGJpdG1hcENvbnRl eHQpOwogCisgICAgLy8gV2UgbmVlZCB0byBzd2FwIHRoZSBieXRlcyB0byBlbnN1cmUgY29uc2lz dGVudCBoYXNoZXMgaW5kZXBlbmRlbnRseSBvZiBlbmRpYW5uZXNzCisgICAgTUQ1X0NUWCBtZDVD b250ZXh0OwogICAgIE1ENV9Jbml0KCZtZDVDb250ZXh0KTsKLSAgICB1bnNpZ25lZCBjaGFyKiBi aXRtYXBEYXRhID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcio+KENHQml0bWFwQ29udGV4dEdl dERhdGEoYml0bWFwKSk7Ci0gICAgZm9yICh1bnNpZ25lZCByb3cgPSAwOyByb3cgPCBwaXhlbHNI aWdoOyByb3crKykgewotICAgICAgICBNRDVfVXBkYXRlKCZtZDVDb250ZXh0LCBiaXRtYXBEYXRh LCBzdGF0aWNfY2FzdDx1bnNpZ25lZD4ocGl4ZWxzV2lkZSAqIGJ5dGVzUGVyUGl4ZWwpKTsKLSAg ICAgICAgYml0bWFwRGF0YSArPSBieXRlc1BlclJvdzsKKyAgICB1bnNpZ25lZCBjaGFyKiBiaXRt YXBEYXRhID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcio+KENHQml0bWFwQ29udGV4dEdldERh dGEoYml0bWFwQ29udGV4dCkpOworI2lmIFBMQVRGT1JNKE1BQykKKyAgICBpZiAoKENHQml0bWFw Q29udGV4dEdldEJpdG1hcEluZm8oYml0bWFwQ29udGV4dCkgJiBrQ0dCaXRtYXBCeXRlT3JkZXJN YXNrKSA9PSBrQ0dCaXRtYXBCeXRlT3JkZXIzMkJpZykgeworICAgICAgICBmb3IgKHVuc2lnbmVk IHJvdyA9IDA7IHJvdyA8IHBpeGVsc0hpZ2g7IHJvdysrKSB7CisgICAgICAgICAgICB1aW50MzJf dCBidWZmZXJbcGl4ZWxzV2lkZV07CisgICAgICAgICAgICBmb3IgKHVuc2lnbmVkIGNvbHVtbiA9 IDA7IGNvbHVtbiA8IHBpeGVsc1dpZGU7IGNvbHVtbisrKQorICAgICAgICAgICAgICAgIGJ1ZmZl cltjb2x1bW5dID0gT1NSZWFkTGl0dGxlSW50MzIoYml0bWFwRGF0YSwgNCAqIGNvbHVtbik7Cisg ICAgICAgICAgICBNRDVfVXBkYXRlKCZtZDVDb250ZXh0LCBidWZmZXIsIDQgKiBwaXhlbHNXaWRl KTsKKyAgICAgICAgICAgIGJpdG1hcERhdGEgKz0gYnl0ZXNQZXJSb3c7CisgICAgICAgIH0KKyAg ICB9IGVsc2UKKyNlbmRpZgorICAgIHsKKyAgICAgICAgZm9yICh1bnNpZ25lZCByb3cgPSAwOyBy b3cgPCBwaXhlbHNIaWdoOyByb3crKykgeworICAgICAgICAgICAgTUQ1X1VwZGF0ZSgmbWQ1Q29u dGV4dCwgYml0bWFwRGF0YSwgNCAqIHBpeGVsc1dpZGUpOworICAgICAgICAgICAgYml0bWFwRGF0 YSArPSBieXRlc1BlclJvdzsKKyAgICAgICAgfQogICAgIH0KKyAgICB1bnNpZ25lZCBjaGFyIGhh c2hbMTZdOwogICAgIE1ENV9GaW5hbChoYXNoLCAmbWQ1Q29udGV4dCk7CiAKLSAgICBzdHJpbmdb MF0gPSAnXDAnOworICAgIGhhc2hTdHJpbmdbMF0gPSAnXDAnOwogICAgIGZvciAoaW50IGkgPSAw OyBpIDwgMTY7IGkrKykKLSAgICAgICAgc25wcmludGYoc3RyaW5nLCAzMywgIiVzJTAyeCIsIHN0 cmluZywgaGFzaFtpXSk7Ci19Ci0KLXZvaWQgZHJhd1NlbGVjdGlvblJlY3QoQ0dDb250ZXh0UmVm IGNvbnRleHQsIGNvbnN0IENHUmVjdCYgcmVjdCkKLXsKLSAgICBDR0NvbnRleHRTYXZlR1N0YXRl KGNvbnRleHQpOwotICAgIENHQ29udGV4dFNldFJHQlN0cm9rZUNvbG9yKGNvbnRleHQsIDEuMCwg MC4wLCAwLjAsIDEuMCk7Ci0gICAgQ0dDb250ZXh0U3Ryb2tlUmVjdChjb250ZXh0LCByZWN0KTsK LSAgICBDR0NvbnRleHRSZXN0b3JlR1N0YXRlKGNvbnRleHQpOworICAgICAgICBzbnByaW50Ziho YXNoU3RyaW5nLCAzMywgIiVzJTAyeCIsIGhhc2hTdHJpbmcsIGhhc2hbaV0pOwogfQogCi12b2lk IGR1bXBXZWJWaWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4cGVjdGVkKGNvbnN0IGNoYXIqIC8q Y3VycmVudFRlc3QqLywgYm9vbCAvKmZvcmNlQWxsVGVzdHNUb0R1bXBQaXhlbHMqLykKK3ZvaWQg ZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0ZWQoY29uc3Qgc3RkOjpzdHJp bmcmIGV4cGVjdGVkSGFzaCkKIHsKLSAgICBSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPiBjb250ZXh0 ID0gZ2V0Qml0bWFwQ29udGV4dEZyb21XZWJWaWV3KCk7Ci0KKyAgICBSZWZQdHI8Qml0bWFwQ29u dGV4dD4gY29udGV4dDsKKyAgICAKICNpZiBQTEFURk9STShNQUMpCi0gICAgaWYgKGdMYXlvdXRU ZXN0Q29udHJvbGxlci0+dGVzdFJlcGFpbnQoKSkKLSAgICAgICAgcmVwYWludFdlYlZpZXcoY29u dGV4dC5nZXQoKSwgZ0xheW91dFRlc3RDb250cm9sbGVyLT50ZXN0UmVwYWludFN3ZWVwSG9yaXpv bnRhbGx5KCkpOwotICAgIGVsc2UgCi0gICAgICAgIHBhaW50V2ViVmlldyhjb250ZXh0LmdldCgp KTsKLQotICAgIGlmIChnTGF5b3V0VGVzdENvbnRyb2xsZXItPmR1bXBTZWxlY3Rpb25SZWN0KCkp Ci0gICAgICAgIGRyYXdTZWxlY3Rpb25SZWN0KGNvbnRleHQuZ2V0KCksIGdldFNlbGVjdGlvblJl Y3QoKSk7CisgICAgY29udGV4dCA9IGNyZWF0ZUJpdG1hcENvbnRleHRGcm9tV2ViVmlldyhnTGF5 b3V0VGVzdENvbnRyb2xsZXItPnRlc3RPbnNjcmVlbigpLCBnTGF5b3V0VGVzdENvbnRyb2xsZXIt PnRlc3RSZXBhaW50KCksIGdMYXlvdXRUZXN0Q29udHJvbGxlci0+dGVzdFJlcGFpbnRTd2VlcEhv cml6b250YWxseSgpLCBnTGF5b3V0VGVzdENvbnRyb2xsZXItPmR1bXBTZWxlY3Rpb25SZWN0KCkp OwogI2VuZGlmCi0KLSAgICAvLyBDb21wdXRlIHRoZSBhY3R1YWwgaGFzaCB0byBjb21wYXJlIHRv IHRoZSBleHBlY3RlZCBpbWFnZSdzIGhhc2guCisgICAgQVNTRVJUKGNvbnRleHQpOworICAgIAor ICAgIC8vIENvbXB1dGUgdGhlIGhhc2ggb2YgdGhlIGJpdG1hcCBjb250ZXh0IHBpeGVscwogICAg IGNoYXIgYWN0dWFsSGFzaFszM107Ci0gICAgZ2V0TUQ1SGFzaFN0cmluZ0ZvckJpdG1hcChjb250 ZXh0LmdldCgpLCBhY3R1YWxIYXNoKTsKKyAgICBjb21wdXRlTUQ1SGFzaFN0cmluZ0ZvckJpdG1h cENvbnRleHQoY29udGV4dC0+Y2dDb250ZXh0KCksIGFjdHVhbEhhc2gpOwogICAgIHByaW50Zigi XG5BY3R1YWxIYXNoOiAlc1xuIiwgYWN0dWFsSGFzaCk7Ci0KLSAgICAvLyBGSVhNRTogV2Ugc2hv dWxkIGNvbXBhcmUgdGhlIGFjdHVhbEhhc2ggdG8gdGhlIGV4cGVjdGVkIGhhc2ggaGVyZSBhbmQK LSAgICAvLyBvbmx5IHNldCBkdW1wSW1hZ2UgdG8gdHJ1ZSBpZiB0aGV5IGRvbid0IG1hdGNoLCBi dXQgRFJUIGRvZXNuJ3QgaGF2ZQotICAgIC8vIGVub3VnaCBpbmZvcm1hdGlvbiBjdXJyZW50bHkg dG8gZmluZCB0aGUgZXhwZWN0ZWQgY2hlY2tzdW0gZmlsZS4KKyAgICAKKyAgICAvLyBDaGVjayB0 aGUgY29tcHV0ZWQgaGFzaCBhZ2FpbnN0IHRoZSBleHBlY3RlZCBvbmUgYW5kIGR1bXAgaW1hZ2Ug b24gbWlzbWF0Y2gKICAgICBib29sIGR1bXBJbWFnZSA9IHRydWU7Ci0KKyAgICBpZiAoZXhwZWN0 ZWRIYXNoLmxlbmd0aCgpID4gMCkgeworICAgICAgICBBU1NFUlQoZXhwZWN0ZWRIYXNoLmxlbmd0 aCgpID09IDMyKTsKKyAgICAgICAgCisgICAgICAgIHByaW50ZigiXG5FeHBlY3RlZEhhc2g6ICVz XG4iLCBleHBlY3RlZEhhc2guY19zdHIoKSk7CisgICAgICAgIAorICAgICAgICBpZiAoZXhwZWN0 ZWRIYXNoID09IGFjdHVhbEhhc2gpICAgICAvLyBGSVhNRTogZG8gY2FzZSBpbnNlbnNpdGl2ZSBj b21wYXJlCisgICAgICAgICAgICBkdW1wSW1hZ2UgPSBmYWxzZTsKKyAgICB9CisgICAgCiAgICAg aWYgKGR1bXBJbWFnZSkgewotICAgICAgICBSZXRhaW5QdHI8Q0dJbWFnZVJlZj4gaW1hZ2UoQWRv cHRDRiwgQ0dCaXRtYXBDb250ZXh0Q3JlYXRlSW1hZ2UoY29udGV4dC5nZXQoKSkpOworICAgICAg ICBSZXRhaW5QdHI8Q0dJbWFnZVJlZj4gaW1hZ2UoQWRvcHRDRiwgQ0dCaXRtYXBDb250ZXh0Q3Jl YXRlSW1hZ2UoY29udGV4dC0+Y2dDb250ZXh0KCkpKTsKICAgICAgICAgcHJpbnRQTkcoaW1hZ2Uu Z2V0KCkpOwogICAgIH0KIH0KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cv UGl4ZWxEdW1wU3VwcG9ydENHLmgKaW5kZXggMGFiZGVhNi4uMzI3MjcxMSAxMDA2NDQKLS0tIGEv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1wU3VwcG9ydENHLmgKKysrIGIv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1wU3VwcG9ydENHLmgKQEAgLTMx LDI1ICszMSw1MCBAQAogI2lmbmRlZiBQaXhlbER1bXBTdXBwb3J0Q0dfaAogI2RlZmluZSBQaXhl bER1bXBTdXBwb3J0Q0dfaAogCisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRl IDx3dGYvUmVmQ291bnRlZC5oPgogI2luY2x1ZGUgPHd0Zi9SZXRhaW5QdHIuaD4KIAotI2lmbmRl ZiBDR0ZMT0FUX0RFRklORUQKLSNpZmRlZiBfX0xQNjRfXwotdHlwZWRlZiBkb3VibGUgQ0dGbG9h dDsKLSNlbHNlCi10eXBlZGVmIGZsb2F0IENHRmxvYXQ7Cit0eXBlZGVmIHN0cnVjdCBDR0NvbnRl eHQqIENHQ29udGV4dFJlZjsKKworI2lmIFBMQVRGT1JNKE1BQykKK3R5cGVkZWYgdm9pZCogQml0 bWFwQ29udGV4dEJhY2tpbmc7CisjZWxpZiBQTEFURk9STShXSU4pCit0eXBlZGVmIEhCSVRNQVAg Qml0bWFwQ29udGV4dEJhY2tpbmc7CiAjZW5kaWYKLSNkZWZpbmUgQ0dGTE9BVF9ERUZJTkVEIDEK KworY2xhc3MgQml0bWFwQ29udGV4dCA6IHB1YmxpYyBSZWZDb3VudGVkPEJpdG1hcENvbnRleHQ+ IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxCaXRtYXBDb250ZXh0PiBjcmVhdGVC eUFkb3B0aW5nQml0bWFwQW5kQ29udGV4dChCaXRtYXBDb250ZXh0QmFja2luZyBiYWNraW5nLCBD R0NvbnRleHRSZWYgY29udGV4dCkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcg Qml0bWFwQ29udGV4dChiYWNraW5nLCBjb250ZXh0KSk7CisgICAgfQorCisgICAgfkJpdG1hcENv bnRleHQoKQorICAgIHsKKyAgICAgICAgaWYgKG1fYmFja2luZykKKyNpZiBQTEFURk9STShNQUMp CisgICAgICAgICAgICBmcmVlKG1fYmFja2luZyk7CisjZWxpZiBQTEFURk9STShXSU4pCisgICAg ICAgICAgICBEZWxldGVPYmplY3QobV9iYWNraW5nKTsKICNlbmRpZgorICAgIH0KIAotdHlwZWRl ZiBzdHJ1Y3QgQ0dDb250ZXh0KiBDR0NvbnRleHRSZWY7Ci1zdHJ1Y3QgQ0dSZWN0OworICAgIENH Q29udGV4dFJlZiBjZ0NvbnRleHQoKSBjb25zdCB7IHJldHVybiBtX2NvbnRleHQuZ2V0KCk7IH0K KworcHJpdmF0ZToKKworICAgIEJpdG1hcENvbnRleHQoQml0bWFwQ29udGV4dEJhY2tpbmcgYmFj a2luZywgQ0dDb250ZXh0UmVmIGNvbnRleHQpCisgICAgICAgIDogbV9iYWNraW5nKGJhY2tpbmcp CisgICAgICAgICwgbV9jb250ZXh0KEFkb3B0Q0YsIGNvbnRleHQpCisgICAgeworICAgIH0KKwor ICAgIEJpdG1hcENvbnRleHRCYWNraW5nIG1fYmFja2luZzsKKyAgICBSZXRhaW5QdHI8Q0dDb250 ZXh0UmVmPiBtX2NvbnRleHQ7CiAKLVJldGFpblB0cjxDR0NvbnRleHRSZWY+IGdldEJpdG1hcENv bnRleHRGcm9tV2ViVmlldygpOwotQ0dSZWN0IGdldFNlbGVjdGlvblJlY3QoKTsKK307CiAKLXZv aWQgcGFpbnRXZWJWaWV3KENHQ29udGV4dFJlZik7Ci12b2lkIHJlcGFpbnRXZWJWaWV3KENHQ29u dGV4dFJlZiBjb250ZXh0LCBib29sIGhvcml6b250YWwpOwotdm9pZCBkcmF3U2VsZWN0aW9uUmVj dChDR0NvbnRleHRSZWYsIGNvbnN0IENHUmVjdCYpOworUGFzc1JlZlB0cjxCaXRtYXBDb250ZXh0 PiBjcmVhdGVCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoYm9vbCBvbnNjcmVlbiwgYm9vbCBpbmNy ZW1lbnRhbFJlcGFpbnQsIGJvb2wgc3dlZXBIb3Jpem9udGFsbHksIGJvb2wgZHJhd1NlbGVjdGlv blJlY3QpOwogCiAjZW5kaWYgLy8gUGl4ZWxEdW1wU3VwcG9ydENHX2gKZGlmZiAtLWdpdCBhL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbSBiL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQppbmRleCBiZWNlOTA2Li41 OTZiZjY5IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJl bmRlclRyZWUubW0KKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5k ZXJUcmVlLm1tCkBAIC03NSwxMCArNzUsMTIgQEAKICNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4K ICNpbXBvcnQgPHd0Zi9Pd25QdHIuaD4KIAordXNpbmcgbmFtZXNwYWNlIHN0ZDsKKwogQGludGVy ZmFjZSBEdW1wUmVuZGVyVHJlZUV2ZW50IDogTlNFdmVudAogQGVuZAogCi1zdGF0aWMgdm9pZCBy dW5UZXN0KGNvbnN0IGNoYXIgKnBhdGhPclVSTCk7CitzdGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0 IHN0cmluZyYgdGVzdFBhdGhPclVSTCk7CiAKIC8vIERlY2lkaW5nIHdoZW4gaXQncyBPSyB0byBk dW1wIG91dCB0aGUgc3RhdGUgaXMgYSBiaXQgdHJpY2t5LiAgQWxsIHRoZXNlIG11c3QgYmUgdHJ1 ZToKIC8vIC0gVGhlcmUgaXMgbm8gbG9hZCBpbiBwcm9ncmVzcwpAQCAtMTExLDE0ICsxMTMsMTAg QEAgc3RhdGljIFJlc291cmNlTG9hZERlbGVnYXRlICpyZXNvdXJjZUxvYWREZWxlZ2F0ZTsKIFBv bGljeURlbGVnYXRlICpwb2xpY3lEZWxlZ2F0ZTsKIAogc3RhdGljIGludCBkdW1wUGl4ZWxzOwot c3RhdGljIGludCBkdW1wQWxsUGl4ZWxzOwogc3RhdGljIGludCB0aHJlYWRlZDsKLXN0YXRpYyBp bnQgdGVzdFJlcGFpbnREZWZhdWx0Owotc3RhdGljIGludCByZXBhaW50U3dlZXBIb3Jpem9udGFs bHlEZWZhdWx0Owogc3RhdGljIGludCBkdW1wVHJlZSA9IFlFUzsKIHN0YXRpYyBpbnQgZm9yY2VD b21wbGV4VGV4dDsKIHN0YXRpYyBCT09MIHByaW50U2VwYXJhdG9yczsKLXN0YXRpYyBOU1N0cmlu ZyAqY3VycmVudFRlc3QgPSBuaWw7CiBzdGF0aWMgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBwZXJz aXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbjsKIAogc3RhdGljIFdlYkhpc3RvcnlJdGVtICpw cmV2VGVzdEJGSXRlbSA9IG5pbDsgIC8vIGN1cnJlbnQgYi9mIGl0ZW0gYXQgdGhlIGVuZCBvZiB0 aGUgcHJldmlvdXMgdGVzdApAQCAtMTgxLDIxICsxNzksMjEgQEAgdm9pZCBzZXRQZXJzaXN0ZW50 VXNlclN0eWxlU2hlZXRMb2NhdGlvbihDRlN0cmluZ1JlZiB1cmwpCiAgICAgcGVyc2lzdGVudFVz ZXJTdHlsZVNoZWV0TG9jYXRpb24gPSB1cmw7CiB9CiAKLXN0YXRpYyBCT09MIHNob3VsZElnbm9y ZVdlYkNvcmVOb2RlTGVha3MoQ0ZTdHJpbmdSZWYgVVJMU3RyaW5nKQorc3RhdGljIGJvb2wgc2hv dWxkSWdub3JlV2ViQ29yZU5vZGVMZWFrcyhjb25zdCBzdHJpbmcmIFVSTFN0cmluZykKIHsKLSAg ICBzdGF0aWMgQ0ZTdHJpbmdSZWYgY29uc3QgaWdub3JlU2V0W10gPSB7CisgICAgc3RhdGljIGNo YXIqIGNvbnN0IGlnbm9yZVNldFtdID0gewogICAgICAgICAvLyBLZWVwaW5nIHRoaXMgaW5mcmFz dHJ1Y3R1cmUgYXJvdW5kIGluIGNhc2Ugd2UgZXZlciBuZWVkIGl0IGFnYWluLgogICAgIH07Ci0g ICAgc3RhdGljIGNvbnN0IGludCBpZ25vcmVTZXRDb3VudCA9IHNpemVvZihpZ25vcmVTZXQpIC8g c2l6ZW9mKENGU3RyaW5nUmVmKTsKKyAgICBzdGF0aWMgY29uc3QgaW50IGlnbm9yZVNldENvdW50 ID0gc2l6ZW9mKGlnbm9yZVNldCkgLyBzaXplb2YoY2hhciopOwogICAgIAogICAgIGZvciAoaW50 IGkgPSAwOyBpIDwgaWdub3JlU2V0Q291bnQ7IGkrKykgewotICAgICAgICBDRlN0cmluZ1JlZiBp Z25vcmVTdHJpbmcgPSBpZ25vcmVTZXRbaV07Ci0gICAgICAgIENGUmFuZ2UgcmFuZ2UgPSBDRlJh bmdlTWFrZSgwLCBDRlN0cmluZ0dldExlbmd0aChVUkxTdHJpbmcpKTsKLSAgICAgICAgQ0ZPcHRp b25GbGFncyBmbGFncyA9IGtDRkNvbXBhcmVBbmNob3JlZCB8IGtDRkNvbXBhcmVCYWNrd2FyZHMg fCBrQ0ZDb21wYXJlQ2FzZUluc2Vuc2l0aXZlOwotICAgICAgICBpZiAoQ0ZTdHJpbmdGaW5kV2l0 aE9wdGlvbnMoVVJMU3RyaW5nLCBpZ25vcmVTdHJpbmcsIHJhbmdlLCBmbGFncywgTlVMTCkpCi0g ICAgICAgICAgICByZXR1cm4gWUVTOworICAgICAgICAvLyBGSVhNRTogaWdub3JlIGNhc2UKKyAg ICAgICAgc3RyaW5nIGN1cklnbm9yZShpZ25vcmVTZXRbaV0pOworICAgICAgICAvLyBNYXRjaCBh dCB0aGUgZW5kIG9mIHRoZSBVUkxTdHJpbmcKKyAgICAgICAgaWYgKCFVUkxTdHJpbmcuY29tcGFy ZShVUkxTdHJpbmcubGVuZ3RoKCkgLSBjdXJJZ25vcmUubGVuZ3RoKCksIGN1cklnbm9yZS5sZW5n dGgoKSwgY3VySWdub3JlKSkKKyAgICAgICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KLSAgICBy ZXR1cm4gTk87CisgICAgcmV0dXJuIGZhbHNlOwogfQogCiBzdGF0aWMgdm9pZCBhY3RpdmF0ZUZv bnRzKCkKQEAgLTMwNywxMyArMzA1LDEzIEBAIHZvaWQgdGVzdFN0cmluZ0J5RXZhbHVhdGluZ0ph dmFTY3JpcHRGcm9tU3RyaW5nKCkKIHN0YXRpYyB2b2lkIHNldERlZmF1bHRzVG9Db25zaXN0ZW50 VmFsdWVzRm9yVGVzdGluZygpCiB7CiAgICAgLy8gR2l2ZSBzb21lIGNsZWFyIHRvIHVuZG9jdW1l bnRlZCBkZWZhdWx0cyB2YWx1ZXMKLSAgICBzdGF0aWMgY29uc3QgaW50IE1lZGl1bUZvbnRTbW9v dGhpbmcgPSAyOworICAgIHN0YXRpYyBjb25zdCBpbnQgTm9Gb250U21vb3RoaW5nID0gMDsKICAg ICBzdGF0aWMgY29uc3QgaW50IEJsdWVUaW50ZWRBcHBlYXJhbmNlID0gMTsKIAogICAgIE5TVXNl ckRlZmF1bHRzICpkZWZhdWx0cyA9IFtOU1VzZXJEZWZhdWx0cyBzdGFuZGFyZFVzZXJEZWZhdWx0 c107CiAgICAgW2RlZmF1bHRzIHNldE9iamVjdDpAIkRvdWJsZU1heCIgZm9yS2V5OkAiQXBwbGVT Y3JvbGxCYXJWYXJpYW50Il07CiAgICAgW2RlZmF1bHRzIHNldEludGVnZXI6NCBmb3JLZXk6QCJB cHBsZUFudGlBbGlhc2luZ1RocmVzaG9sZCJdOyAvLyBzbWFsbGVzdCBmb250IHNpemUgdG8gQ0cg c2hvdWxkIHBlcmZvcm0gYW50aWFsaWFzaW5nIG9uCi0gICAgW2RlZmF1bHRzIHNldEludGVnZXI6 TWVkaXVtRm9udFNtb290aGluZyBmb3JLZXk6QCJBcHBsZUZvbnRTbW9vdGhpbmciXTsKKyAgICBb ZGVmYXVsdHMgc2V0SW50ZWdlcjpOb0ZvbnRTbW9vdGhpbmcgZm9yS2V5OkAiQXBwbGVGb250U21v b3RoaW5nIl07CiAgICAgW2RlZmF1bHRzIHNldEludGVnZXI6Qmx1ZVRpbnRlZEFwcGVhcmFuY2Ug Zm9yS2V5OkAiQXBwbGVBcXVhQ29sb3JWYXJpYW50Il07CiAgICAgW2RlZmF1bHRzIHNldE9iamVj dDpAIjAuNzA5ODAwIDAuODM1MzAwIDEuMDAwMDAwIiBmb3JLZXk6QCJBcHBsZUhpZ2hsaWdodENv bG9yIl07CiAgICAgW2RlZmF1bHRzIHNldE9iamVjdDpAIjAuNTAwMDAwIDAuNTAwMDAwIDAuNTAw MDAwIiBmb3JLZXk6QCJBcHBsZU90aGVySGlnaGxpZ2h0Q29sb3IiXTsKQEAgLTM1MCw3ICszNDgs NyBAQCBzdGF0aWMgdm9pZCBjcmFzaEhhbmRsZXIoaW50IHNpZykKICAgICBjaGFyICpzaWduYWxO YW1lID0gc3Ryc2lnbmFsKHNpZyk7CiAgICAgd3JpdGUoU1RERVJSX0ZJTEVOTywgc2lnbmFsTmFt ZSwgc3RybGVuKHNpZ25hbE5hbWUpKTsKICAgICB3cml0ZShTVERFUlJfRklMRU5PLCAiXG4iLCAx KTsKLSAgICByZXN0b3JlQ29sb3JTcGFjZSgwKTsKKyAgICByZXN0b3JlTWFpbkRpc3BsYXlDb2xv clByb2ZpbGUoMCk7CiAgICAgZXhpdCgxMjggKyBzaWcpOwogfQogCkBAIC0zOTksMTEgKzM5Nyw4 IEBAIHN0YXRpYyB2b2lkIHJlbGVhc2VHbG9iYWxDb250cm9sbGVycygpCiBzdGF0aWMgdm9pZCBp bml0aWFsaXplR2xvYmFsc0Zyb21Db21tYW5kTGluZU9wdGlvbnMoaW50IGFyZ2MsIGNvbnN0IGNo YXIgKmFyZ3ZbXSkKIHsKICAgICBzdHJ1Y3Qgb3B0aW9uIG9wdGlvbnNbXSA9IHsKLSAgICAgICAg eyJkdW1wLWFsbC1waXhlbHMiLCBub19hcmd1bWVudCwgJmR1bXBBbGxQaXhlbHMsIFlFU30sCi0g ICAgICAgIHsiaG9yaXpvbnRhbC1zd2VlcCIsIG5vX2FyZ3VtZW50LCAmcmVwYWludFN3ZWVwSG9y aXpvbnRhbGx5RGVmYXVsdCwgWUVTfSwKICAgICAgICAgeyJub3RyZWUiLCBub19hcmd1bWVudCwg JmR1bXBUcmVlLCBOT30sCiAgICAgICAgIHsicGl4ZWwtdGVzdHMiLCBub19hcmd1bWVudCwgJmR1 bXBQaXhlbHMsIFlFU30sCi0gICAgICAgIHsicmVwYWludCIsIG5vX2FyZ3VtZW50LCAmdGVzdFJl cGFpbnREZWZhdWx0LCBZRVN9LAogICAgICAgICB7InRyZWUiLCBub19hcmd1bWVudCwgJmR1bXBU cmVlLCBZRVN9LAogICAgICAgICB7InRocmVhZGVkIiwgbm9fYXJndW1lbnQsICZ0aHJlYWRlZCwg WUVTfSwKICAgICAgICAgeyJjb21wbGV4LXRleHQiLCBub19hcmd1bWVudCwgJmZvcmNlQ29tcGxl eFRleHQsIFlFU30sCkBAIC00NjAsNyArNDU1LDcgQEAgc3RhdGljIHZvaWQgcHJlcGFyZUNvbnNp c3RlbnRUZXN0aW5nRW52aXJvbm1lbnQoKQogICAgIGFjdGl2YXRlRm9udHMoKTsKICAgICAKICAg ICBpZiAoZHVtcFBpeGVscykKLSAgICAgICAgaW5pdGlhbGl6ZUNvbG9yU3BhY2VBbmRTY3JlZUJ1 ZmZlckZvclBpeGVsVGVzdHMoKTsKKyAgICAgICAgc2V0dXBNYWluRGlzcGxheUNvbG9yUHJvZmls ZSgpOwogICAgIGFsbG9jYXRlR2xvYmFsQ29udHJvbGxlcnMoKTsKICAgICAKICAgICBtYWtlTGFy Z2VNYWxsb2NGYWlsU2lsZW50bHkoKTsKQEAgLTUyNiw3ICs1MjEsNyBAQCB2b2lkIGR1bXBSZW5k ZXJUcmVlKGludCBhcmdjLCBjb25zdCBjaGFyICphcmd2W10pCiAgICAgfQogCiAgICAgaWYgKGR1 bXBQaXhlbHMpCi0gICAgICAgIHJlc3RvcmVDb2xvclNwYWNlKDApOworICAgICAgICByZXN0b3Jl TWFpbkRpc3BsYXlDb2xvclByb2ZpbGUoMCk7CiB9CiAKIGludCBtYWluKGludCBhcmdjLCBjb25z dCBjaGFyICphcmd2W10pCkBAIC04MjEsNyArODE2LDcgQEAgc3RhdGljIHZvaWQgZHVtcEJhY2tG b3J3YXJkTGlzdEZvcldlYlZpZXcoV2ViVmlldyAqdmlldykKIHN0YXRpYyB2b2lkIHNpemVXZWJW aWV3Rm9yQ3VycmVudFRlc3QoKQogewogICAgIC8vIFczQyBTVkcgdGVzdHMgZXhwZWN0IHRvIGJl IDQ4MHgzNjAKLSAgICBib29sIGlzU1ZHVzNDVGVzdCA9IChbY3VycmVudFRlc3QgcmFuZ2VPZlN0 cmluZzpAInN2Zy9XM0MtU1ZHLTEuMSJdLmxlbmd0aCk7CisgICAgYm9vbCBpc1NWR1czQ1Rlc3Qg PSAoZ0xheW91dFRlc3RDb250cm9sbGVyLT50ZXN0UGF0aE9yVVJMKCkuZmluZCgic3ZnL1czQy1T VkctMS4xIikgIT0gc3RyaW5nOjpucG9zKTsKICAgICBpZiAoaXNTVkdXM0NUZXN0KQogICAgICAg ICBbW21haW5GcmFtZSB3ZWJWaWV3XSBzZXRGcmFtZVNpemU6TlNNYWtlU2l6ZSg0ODAsIDM2MCld OwogICAgIGVsc2UKQEAgLTkxNSw4ICs5MTAsOCBAQCB2b2lkIGR1bXAoKQogICAgICAgICB9ICAg ICAgICAgICAgCiAgICAgfQogICAgIAotICAgIGlmIChkdW1wQWxsUGl4ZWxzIHx8IChkdW1wUGl4 ZWxzICYmICFkdW1wQXNUZXh0KSkKLSAgICAgICAgZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENvbXBh cmVXaXRoRXhwZWN0ZWQoW2N1cnJlbnRUZXN0IFVURjhTdHJpbmddLCBkdW1wQWxsUGl4ZWxzKTsK KyAgICBpZiAoZHVtcFBpeGVscyAmJiAhZHVtcEFzVGV4dCkKKyAgICAgICAgZHVtcFdlYlZpZXdB c1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0ZWQoZ0xheW91dFRlc3RDb250cm9sbGVyLT5leHBl Y3RlZFBpeGVsSGFzaCgpKTsKICAgICAKICAgICBwdXRzKCIjRU9GIik7ICAgLy8gdGVybWluYXRl IHRoZSAocG9zc2libHkgZW1wdHkpIHBpeGVscyBibG9jawogCkBAIC05MzEsMTYgKzkyNiw2IEBA IHN0YXRpYyBib29sIHNob3VsZExvZ0ZyYW1lTG9hZERlbGVnYXRlcyhjb25zdCBjaGFyICpwYXRo T3JVUkwpCiAgICAgcmV0dXJuIHN0cnN0cihwYXRoT3JVUkwsICJsb2FkaW5nLyIpOwogfQogCi1z dGF0aWMgQ0ZVUkxSZWYgY3JlYXRlQ0ZVUkxGcm9tUGF0aE9yVVJMKENGU3RyaW5nUmVmIHBhdGhP clVSTFN0cmluZykKLXsKLSAgICBDRlVSTFJlZiBVUkw7Ci0gICAgaWYgKENGU3RyaW5nSGFzUHJl Zml4KHBhdGhPclVSTFN0cmluZywgQ0ZTVFIoImh0dHA6Ly8iKSkgfHwgQ0ZTdHJpbmdIYXNQcmVm aXgocGF0aE9yVVJMU3RyaW5nLCBDRlNUUigiaHR0cHM6Ly8iKSkpCi0gICAgICAgIFVSTCA9IENG VVJMQ3JlYXRlV2l0aFN0cmluZyhOVUxMLCBwYXRoT3JVUkxTdHJpbmcsIE5VTEwpOwotICAgIGVs c2UKLSAgICAgICAgVVJMID0gQ0ZVUkxDcmVhdGVXaXRoRmlsZVN5c3RlbVBhdGgoTlVMTCwgcGF0 aE9yVVJMU3RyaW5nLCBrQ0ZVUkxQT1NJWFBhdGhTdHlsZSwgRkFMU0UpOwotICAgIHJldHVybiBV Ukw7Ci19Ci0KIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3Jl VGVzdGluZygpCiB7CiAgICAgV2ViVmlldyAqd2ViVmlldyA9IFttYWluRnJhbWUgd2ViVmlld107 CkBAIC05NjksMzAgKzk1NCw0NyBAQCBzdGF0aWMgdm9pZCByZXNldFdlYlZpZXdUb0NvbnNpc3Rl bnRTdGF0ZUJlZm9yZVRlc3RpbmcoKQogICAgIFtXZWJWaWV3IF9zZXRVc2VzVGVzdE1vZGVGb2N1 c1JpbmdDb2xvcjpZRVNdOwogfQogCi1zdGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0IGNoYXIgKnBh dGhPclVSTCkKK3N0YXRpYyB2b2lkIHJ1blRlc3QoY29uc3Qgc3RyaW5nJiB0ZXN0UGF0aE9yVVJM KQogewotICAgIENGU3RyaW5nUmVmIHBhdGhPclVSTFN0cmluZyA9IENGU3RyaW5nQ3JlYXRlV2l0 aENTdHJpbmcoTlVMTCwgcGF0aE9yVVJMLCBrQ0ZTdHJpbmdFbmNvZGluZ1VURjgpOworICAgIEFT U0VSVCghdGVzdFBhdGhPclVSTC5lbXB0eSgpKTsKKyAgICAKKyAgICAvLyBMb29rIGZvciAiJyIg YXMgYSBzZXBhcmF0b3IgYmV0d2VlbiB0aGUgcGF0aCBvciBVUkwsIGFuZCB0aGUgcGl4ZWwgZHVt cCBoYXNoIHRoYXQgZm9sbG93cy4KKyAgICBzdHJpbmcgcGF0aE9yVVJMKHRlc3RQYXRoT3JVUkwp OworICAgIHN0cmluZyBleHBlY3RlZFBpeGVsSGFzaDsKKyAgICAKKyAgICBzaXplX3Qgc2VwYXJh dG9yUG9zID0gcGF0aE9yVVJMLmZpbmQoIiciKTsKKyAgICBpZiAoc2VwYXJhdG9yUG9zICE9IHN0 cmluZzo6bnBvcykgeworICAgICAgICBwYXRoT3JVUkwgPSBzdHJpbmcodGVzdFBhdGhPclVSTCwg MCwgc2VwYXJhdG9yUG9zKTsKKyAgICAgICAgZXhwZWN0ZWRQaXhlbEhhc2ggPSBzdHJpbmcodGVz dFBhdGhPclVSTCwgc2VwYXJhdG9yUG9zICsgMSk7CisgICAgfQorCisgICAgTlNTdHJpbmcgKnBh dGhPclVSTFN0cmluZyA9IFtOU1N0cmluZyBzdHJpbmdXaXRoVVRGOFN0cmluZzpwYXRoT3JVUkwu Y19zdHIoKV07CiAgICAgaWYgKCFwYXRoT3JVUkxTdHJpbmcpIHsKLSAgICAgICAgZnByaW50Zihz dGRlcnIsICJGYWlsZWQgdG8gcGFyc2UgZmlsZW5hbWUgYXMgVVRGLTg6ICVzXG4iLCBwYXRoT3JV UkwpOworICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byBwYXJzZSBcIiVzXCIgYXMg VVRGLThcbiIsIHBhdGhPclVSTC5jX3N0cigpKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAot ICAgIENGVVJMUmVmIFVSTCA9IGNyZWF0ZUNGVVJMRnJvbVBhdGhPclVSTChwYXRoT3JVUkxTdHJp bmcpOwotICAgIGlmICghVVJMKSB7Ci0gICAgICAgIENGUmVsZWFzZShwYXRoT3JVUkxTdHJpbmcp OwotICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIkNhbid0IHR1cm4gJXMgaW50byBhIENGVVJMXG4i LCBwYXRoT3JVUkwpOworICAgIE5TVVJMICp1cmw7CisgICAgaWYgKFtwYXRoT3JVUkxTdHJpbmcg aGFzUHJlZml4OkAiaHR0cDovLyJdIHx8IFtwYXRoT3JVUkxTdHJpbmcgaGFzUHJlZml4OkAiaHR0 cHM6Ly8iXSkKKyAgICAgICAgdXJsID0gW05TVVJMIFVSTFdpdGhTdHJpbmc6cGF0aE9yVVJMU3Ry aW5nXTsKKyAgICBlbHNlCisgICAgICAgIHVybCA9IFtOU1VSTCBmaWxlVVJMV2l0aFBhdGg6cGF0 aE9yVVJMU3RyaW5nXTsKKyAgICBpZiAoIXVybCkgeworICAgICAgICBmcHJpbnRmKHN0ZGVyciwg IkZhaWxlZCB0byBwYXJzZSBcIiVzXCIgYXMgYSBVUkxcbiIsIHBhdGhPclVSTC5jX3N0cigpKTsK ICAgICAgICAgcmV0dXJuOwogICAgIH0KIAorICAgIGNvbnN0IHN0cmluZyB0ZXN0VVJMKFtbdXJs IGFic29sdXRlU3RyaW5nXSBVVEY4U3RyaW5nXSk7CisgICAgCiAgICAgcmVzZXRXZWJWaWV3VG9D b25zaXN0ZW50U3RhdGVCZWZvcmVUZXN0aW5nKCk7CiAKLSAgICBnTGF5b3V0VGVzdENvbnRyb2xs ZXIgPSBuZXcgTGF5b3V0VGVzdENvbnRyb2xsZXIodGVzdFJlcGFpbnREZWZhdWx0LCByZXBhaW50 U3dlZXBIb3Jpem9udGFsbHlEZWZhdWx0KTsKKyAgICBnTGF5b3V0VGVzdENvbnRyb2xsZXIgPSBu ZXcgTGF5b3V0VGVzdENvbnRyb2xsZXIodGVzdFVSTCwgZXhwZWN0ZWRQaXhlbEhhc2gpOwogICAg IHRvcExvYWRpbmdGcmFtZSA9IG5pbDsKICAgICBkb25lID0gTk87CiAKICAgICBpZiAoZGlzYWxs b3dlZFVSTHMpCiAgICAgICAgIENGU2V0UmVtb3ZlQWxsVmFsdWVzKGRpc2FsbG93ZWRVUkxzKTsK LSAgICBpZiAoc2hvdWxkTG9nRnJhbWVMb2FkRGVsZWdhdGVzKHBhdGhPclVSTCkpCisgICAgaWYg KHNob3VsZExvZ0ZyYW1lTG9hZERlbGVnYXRlcyhwYXRoT3JVUkwuY19zdHIoKSkpCiAgICAgICAg IGdMYXlvdXRUZXN0Q29udHJvbGxlci0+c2V0RHVtcEZyYW1lTG9hZENhbGxiYWNrcyh0cnVlKTsK IAogICAgIGlmIChbV2ViSGlzdG9yeSBvcHRpb25hbFNoYXJlZEhpc3RvcnldKQpAQCAtMTAwMCwy MiArMTAwMiwxOCBAQCBzdGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0IGNoYXIgKnBhdGhPclVSTCkK ICAgICBsYXN0TW91c2VQb3NpdGlvbiA9IE5TWmVyb1BvaW50OwogICAgIGxhc3RDbGlja1Bvc2l0 aW9uID0gTlNaZXJvUG9pbnQ7CiAKLSAgICBpZiAoY3VycmVudFRlc3QgIT0gbmlsKQotICAgICAg ICBDRlJlbGVhc2UoY3VycmVudFRlc3QpOwotICAgIGN1cnJlbnRUZXN0ID0gKE5TU3RyaW5nICop cGF0aE9yVVJMU3RyaW5nOwogICAgIFtwcmV2VGVzdEJGSXRlbSByZWxlYXNlXTsKICAgICBwcmV2 VGVzdEJGSXRlbSA9IFtbW1ttYWluRnJhbWUgd2ViVmlld10gYmFja0ZvcndhcmRMaXN0XSBjdXJy ZW50SXRlbV0gcmV0YWluXTsKIAogICAgIFdvcmtRdWV1ZTo6c2hhcmVkKCktPmNsZWFyKCk7CiAg ICAgV29ya1F1ZXVlOjpzaGFyZWQoKS0+c2V0RnJvemVuKGZhbHNlKTsKIAotICAgIEJPT0wgX3No b3VsZElnbm9yZVdlYkNvcmVOb2RlTGVha3MgPSBzaG91bGRJZ25vcmVXZWJDb3JlTm9kZUxlYWtz KENGVVJMR2V0U3RyaW5nKFVSTCkpOwotICAgIGlmIChfc2hvdWxkSWdub3JlV2ViQ29yZU5vZGVM ZWFrcykKKyAgICBib29sIGlnbm9yZVdlYkNvcmVOb2RlTGVha3MgPSBzaG91bGRJZ25vcmVXZWJD b3JlTm9kZUxlYWtzKHRlc3RVUkwpOworICAgIGlmIChpZ25vcmVXZWJDb3JlTm9kZUxlYWtzKQog ICAgICAgICBbV2ViQ29yZVN0YXRpc3RpY3Mgc3RhcnRJZ25vcmluZ1dlYkNvcmVOb2RlTGVha3Nd OwogCiAgICAgTlNBdXRvcmVsZWFzZVBvb2wgKnBvb2wgPSBbW05TQXV0b3JlbGVhc2VQb29sIGFs bG9jXSBpbml0XTsKLSAgICBbbWFpbkZyYW1lIGxvYWRSZXF1ZXN0OltOU1VSTFJlcXVlc3QgcmVx dWVzdFdpdGhVUkw6KE5TVVJMICopVVJMXV07Ci0gICAgQ0ZSZWxlYXNlKFVSTCk7CisgICAgW21h aW5GcmFtZSBsb2FkUmVxdWVzdDpbTlNVUkxSZXF1ZXN0IHJlcXVlc3RXaXRoVVJMOnVybF1dOwog ICAgIFtwb29sIHJlbGVhc2VdOwogICAgIHdoaWxlICghZG9uZSkgewogICAgICAgICBwb29sID0g W1tOU0F1dG9yZWxlYXNlUG9vbCBhbGxvY10gaW5pdF07CkBAIC0xMDU4LDcgKzEwNTYsNyBAQCBz dGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0IGNoYXIgKnBhdGhPclVSTCkKICAgICBnTGF5b3V0VGVz dENvbnRyb2xsZXItPmRlcmVmKCk7CiAgICAgZ0xheW91dFRlc3RDb250cm9sbGVyID0gMDsKIAot ICAgIGlmIChfc2hvdWxkSWdub3JlV2ViQ29yZU5vZGVMZWFrcykKKyAgICBpZiAoaWdub3JlV2Vi Q29yZU5vZGVMZWFrcykKICAgICAgICAgW1dlYkNvcmVTdGF0aXN0aWNzIHN0b3BJZ25vcmluZ1dl YkNvcmVOb2RlTGVha3NdOwogfQogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9tYWMvUGl4ZWxEdW1wU3VwcG9ydE1hYy5tbSBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL21hYy9QaXhlbER1bXBTdXBwb3J0TWFjLm1tCmluZGV4IDlkZGJhMzEuLmViMjlmZmEgMTAw NjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9QaXhlbER1bXBTdXBwb3J0 TWFjLm1tCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9QaXhlbER1bXBTdXBw b3J0TWFjLm1tCkBAIC0zNCwxNTMgKzM0LDIyMSBAQAogCiAjaW5jbHVkZSAiTGF5b3V0VGVzdENv bnRyb2xsZXIuaCIKICNpbmNsdWRlIDxDb3JlR3JhcGhpY3MvQ0dCaXRtYXBDb250ZXh0Lmg+Cisj aWZuZGVmIEJVSUxESU5HX09OX0xFT1BBUkQKKyNpbmNsdWRlIDxPcGVuR0wvT3BlbkdMLmg+Cisj aW5jbHVkZSA8T3BlbkdML0NHTE1hY3JvLmg+CisjZW5kaWYKICNpbmNsdWRlIDx3dGYvQXNzZXJ0 aW9ucy5oPgotI2luY2x1ZGUgPHd0Zi9SZXRhaW5QdHIuaD4KKyNpbmNsdWRlIDx3dGYvUmVmUHRy Lmg+CiAKICNpbXBvcnQgPFdlYktpdC9XZWJEb2N1bWVudFByaXZhdGUuaD4KICNpbXBvcnQgPFdl YktpdC9XZWJLaXQuaD4KIAotc3RhdGljIHVuc2lnbmVkIGNoYXIqIHNjcmVlbkNhcHR1cmVCdWZm ZXI7CisvLyBUbyBlbnN1cmUgcGl4ZWwgdGVzdHMgY29uc2lzdGVuY3ksIHdlIG5lZWQgdG8gYWx3 YXlzIHJlbmRlciBpbiB0aGUgc2FtZSBjb2xvcnNwYWNlLgorLy8gVW5mb3J0dW5hdGVseSwgYmVj YXVzZSBvZiBBcHBLaXQgLyBXZWJLaXQgY29uc3RyYWludHMsIHdlIGNhbid0IHJlbmRlciBkaXJl Y3RseSBpbiB0aGUgY29sb3JzcGFjZSBvZiBvdXIgY2hvaWNlLgorLy8gVGhpcyBpbXBsaWVzIHdl IGhhdmUgdG8gdGVtcG9yYXJpbHkgY2hhbmdlIHRoZSBwcm9maWxlIG9mIHRoZSBtYWluIGRpc3Bs YXkgdG8gdGhlIGNvbG9yc3BhY2Ugd2Ugd2FudCB0byByZW5kZXIgaW50by4KKy8vIFdlIGFsc28g bmVlZCB0byBtYWtlIHN1cmUgdGhlIENHQml0bWFwQ29udGV4dCB3ZSByZXR1cm4gaXMgaW4gdGhh dCBzYW1lIGNvbG9yc3BhY2UuCiAKLXN0YXRpYyBib29sIGNoYW5nZWRDb2xvclByb2ZpbGUgPSBm YWxzZTsKLXN0YXRpYyBDTVByb2ZpbGVMb2NhdGlvbiBjdXJyZW50Q29sb3JQcm9maWxlTG9jYXRp b247Ci1zdGF0aWMgQ0dDb2xvclNwYWNlUmVmIHNoYXJlZENvbG9yU3BhY2U7CisjZGVmaW5lIFBS T0ZJTEVfUEFUSCAiL1N5c3RlbS9MaWJyYXJ5L0NvbG9yU3luYy9Qcm9maWxlcy9HZW5lcmljIFJH QiBQcm9maWxlLmljYyIgLy8gRklYTUU6IFNob3VsZCB3ZSBiZSB1c2luZyAiL1N5c3RlbS9MaWJy YXJ5L0NvbG9yU3luYy9Qcm9maWxlcy9zUkdCIFByb2ZpbGUuaWNjIj8KIAotdm9pZCByZXN0b3Jl Q29sb3JTcGFjZShpbnQgaWdub3JlZCkKK3N0YXRpYyBDTVByb2ZpbGVMb2NhdGlvbiBzSW5pdGlh bFByb2ZpbGVMb2NhdGlvbjsgLy8gVGhlIGxvY1R5cGUgZmllbGQgaXMgaW5pdGlhbGl6ZWQgdG8g MCB3aGljaCBpcyB0aGUgc2FtZSBhcyBjbU5vUHJvZmlsZUJhc2UKKwordm9pZCByZXN0b3JlTWFp bkRpc3BsYXlDb2xvclByb2ZpbGUoaW50IGlnbm9yZWQpCiB7CiAgICAgLy8gVGhpcyBpcyB1c2Vk IGFzIGEgc2lnbmFsIGhhbmRsZXIsIGFuZCB0aHVzIHRoZSBjYWxscyBpbnRvIENvbG9yU3luYyBh cmUgdW5zYWZlCiAgICAgLy8gQnV0IHdlIG1pZ2h0IGFzIHdlbGwgdHJ5IHRvIHJlc3RvcmUgdGhl IHVzZXIncyBjb2xvciBwcm9maWxlLCB3ZSdyZSBnb2luZyBkb3duIGFueXdheS4uLgotICAgIGlm IChjaGFuZ2VkQ29sb3JQcm9maWxlKSB7Ci0gICAgICAgIENNRGV2aWNlU2NvcGUgc2NvcGUgPSB7 IGtDRlByZWZlcmVuY2VzQ3VycmVudFVzZXIsIGtDRlByZWZlcmVuY2VzQ3VycmVudEhvc3QgfTsK LSAgICAgICAgaW50IGVycm9yID0gQ01TZXREZXZpY2VQcm9maWxlKGNtRGlzcGxheURldmljZUNs YXNzLCBjbURlZmF1bHREZXZpY2VJRCwgJnNjb3BlLCBjbURlZmF1bHRQcm9maWxlSUQsICZjdXJy ZW50Q29sb3JQcm9maWxlTG9jYXRpb24pOworICAgIGlmIChzSW5pdGlhbFByb2ZpbGVMb2NhdGlv bi5sb2NUeXBlICE9IGNtTm9Qcm9maWxlQmFzZSkgeworICAgICAgICBjb25zdCBDTURldmljZVNj b3BlIHNjb3BlID0geyBrQ0ZQcmVmZXJlbmNlc0N1cnJlbnRVc2VyLCBrQ0ZQcmVmZXJlbmNlc0N1 cnJlbnRIb3N0IH07CisgICAgICAgIGludCBlcnJvciA9IENNU2V0RGV2aWNlUHJvZmlsZShjbURp c3BsYXlEZXZpY2VDbGFzcywgKENNRGV2aWNlSUQpa0NHRGlyZWN0TWFpbkRpc3BsYXksICZzY29w ZSwgY21EZWZhdWx0UHJvZmlsZUlELCAmc0luaXRpYWxQcm9maWxlTG9jYXRpb24pOwogICAgICAg ICBpZiAoZXJyb3IpCi0gICAgICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byByZXRv cmUgcHJldmlvdXMgY29sb3IgcHJvZmlsZSEgIFlvdSBtYXkgbmVlZCB0byBvcGVuIFN5c3RlbSBQ cmVmZXJlbmNlcyA6IERpc3BsYXlzIDogQ29sb3IgYW5kIG1hbnVhbGx5IHJlc3RvcmUgeW91ciBj b2xvciBzZXR0aW5ncy4gIChFcnJvcjogJWkpIiwgZXJyb3IpOwotICAgICAgICBjaGFuZ2VkQ29s b3JQcm9maWxlID0gZmFsc2U7CisgICAgICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0 byByZXN0b3JlIGluaXRpYWwgY29sb3IgcHJvZmlsZSBmb3IgbWFpbiBkaXNwbGF5ISBPcGVuIFN5 c3RlbSBQcmVmZXJlbmNlcyA+IERpc3BsYXlzID4gQ29sb3IgYW5kIG1hbnVhbGx5IHJlLXNlbGVj dCB0aGUgcHJvZmlsZS4gIChFcnJvcjogJWkpIiwgZXJyb3IpOworICAgICAgICBzSW5pdGlhbFBy b2ZpbGVMb2NhdGlvbi5sb2NUeXBlID0gY21Ob1Byb2ZpbGVCYXNlOwogICAgIH0KIH0KIAotc3Rh dGljIHZvaWQgZmFpbGVkR2V0dGluZ0N1cnJlbnRQcm9maWxlKGludCBlcnJvcikKK3ZvaWQgc2V0 dXBNYWluRGlzcGxheUNvbG9yUHJvZmlsZSgpCiB7Ci0gICAgZnByaW50ZihzdGRlcnIsICJGYWls ZWQgdG8gZ2V0IGN1cnJlbnQgY29sb3IgcHJvZmlsZS4gIEkgd2lsbCBub3QgYmUgYWJsZSB0byBy ZXN0b3JlIHlvdXIgY3VycmVudCBwcm9maWxlLCB0aHVzIEknbSBub3QgY2hhbmdpbmcgaXQuICBN YW55IHBpeGVsIHRlc3RzIG1heSBmYWlsIGFzIGEgcmVzdWx0LiAgKEVycm9yOiAlaSlcbiIsIGVy cm9yKTsKLX0KLQotc3RhdGljIHZvaWQgc2V0RGVmYXVsdENvbG9yUHJvZmlsZVRvUkdCKCkKLXsK LSAgICBDTVByb2ZpbGVSZWYgZ2VuZXJpY1Byb2ZpbGUgPSAoQ01Qcm9maWxlUmVmKVtbTlNDb2xv clNwYWNlIGdlbmVyaWNSR0JDb2xvclNwYWNlXSBjb2xvclN5bmNQcm9maWxlXTsKLSAgICBDTVBy b2ZpbGVMb2NhdGlvbiBnZW5lcmljUHJvZmlsZUxvY2F0aW9uOwotICAgIFVJbnQzMiBsb2NhdGlv blNpemUgPSBzaXplb2YoZ2VuZXJpY1Byb2ZpbGVMb2NhdGlvbik7Ci0gICAgaW50IGVycm9yID0g TkNNR2V0UHJvZmlsZUxvY2F0aW9uKGdlbmVyaWNQcm9maWxlLCAmZ2VuZXJpY1Byb2ZpbGVMb2Nh dGlvbiwgJmxvY2F0aW9uU2l6ZSk7Ci0gICAgaWYgKGVycm9yKSB7Ci0gICAgICAgIGZhaWxlZEdl dHRpbmdDdXJyZW50UHJvZmlsZShlcnJvcik7Ci0gICAgICAgIHJldHVybjsKKyAgICBjb25zdCBD TURldmljZVNjb3BlIHNjb3BlID0geyBrQ0ZQcmVmZXJlbmNlc0N1cnJlbnRVc2VyLCBrQ0ZQcmVm ZXJlbmNlc0N1cnJlbnRIb3N0IH07CisgICAgaW50IGVycm9yOworICAgIAorICAgIENNUHJvZmls ZVJlZiBwcm9maWxlID0gMDsKKyAgICBlcnJvciA9IENNR2V0UHJvZmlsZUJ5QVZJRCgoQ01EaXNw bGF5SURUeXBlKWtDR0RpcmVjdE1haW5EaXNwbGF5LCAmcHJvZmlsZSk7CisgICAgaWYgKCFlcnJv cikgeworICAgICAgICBVSW50MzIgc2l6ZSA9IHNpemVvZihDTVByb2ZpbGVMb2NhdGlvbik7Cisg ICAgICAgIGVycm9yID0gTkNNR2V0UHJvZmlsZUxvY2F0aW9uKHByb2ZpbGUsICZzSW5pdGlhbFBy b2ZpbGVMb2NhdGlvbiwgJnNpemUpOworICAgICAgICBDTUNsb3NlUHJvZmlsZShwcm9maWxlKTsK ICAgICB9Ci0KLSAgICBDTVByb2ZpbGVMb2NhdGlvbiBwcmV2aW91c1Byb2ZpbGVMb2NhdGlvbjsK LSAgICBlcnJvciA9IENNR2V0RGV2aWNlUHJvZmlsZShjbURpc3BsYXlEZXZpY2VDbGFzcywgY21E ZWZhdWx0RGV2aWNlSUQsIGNtRGVmYXVsdFByb2ZpbGVJRCwgJnByZXZpb3VzUHJvZmlsZUxvY2F0 aW9uKTsKICAgICBpZiAoZXJyb3IpIHsKLSAgICAgICAgZmFpbGVkR2V0dGluZ0N1cnJlbnRQcm9m aWxlKGVycm9yKTsKKyAgICAgICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gcmV0cmlldmUg Y3VycmVudCBjb2xvciBwcm9maWxlIGZvciBtYWluIGRpc3BsYXksIHRodXMgaXQgd29uJ3QgYmUg Y2hhbmdlZC4gIE1hbnkgcGl4ZWwgdGVzdHMgbWF5IGZhaWwgYXMgYSByZXN1bHQuICAoRXJyb3I6 ICVpKSIsIGVycm9yKTsKKyAgICAgICAgc0luaXRpYWxQcm9maWxlTG9jYXRpb24ubG9jVHlwZSA9 IGNtTm9Qcm9maWxlQmFzZTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KKyAgICAKKyAgICBDTVBy b2ZpbGVMb2NhdGlvbiBsb2NhdGlvbjsKKyAgICBsb2NhdGlvbi5sb2NUeXBlID0gY21GaWxlQmFz ZWRQcm9maWxlOworICAgIE5TVVJMICp1cmwgPSBbTlNVUkwgZmlsZVVSTFdpdGhQYXRoOltOU1N0 cmluZyBzdHJpbmdXaXRoVVRGOFN0cmluZzpQUk9GSUxFX1BBVEhdXTsKKyAgICBGU1JlZiBmc1Jl ZjsKKyAgICBpZiAodXJsICYmIENGVVJMR2V0RlNSZWYoKENGVVJMUmVmKXVybCwgJmZzUmVmKSkg eworICAgICAgICBlcnJvciA9IEZTR2V0Q2F0YWxvZ0luZm8oJmZzUmVmLCAwLCAwLCAwLCAmbG9j YXRpb24udS5maWxlTG9jLnNwZWMsIDApOworICAgICAgICBpZiAoZXJyb3IgPT0gbm9FcnIpCisg ICAgICAgIGVycm9yID0gQ01TZXREZXZpY2VQcm9maWxlKGNtRGlzcGxheURldmljZUNsYXNzLCAo Q01EZXZpY2VJRClrQ0dEaXJlY3RNYWluRGlzcGxheSwgJnNjb3BlLCBjbURlZmF1bHRQcm9maWxl SUQsICZsb2NhdGlvbik7CisgICAgfQorICAgIGVsc2UKKyAgICAgICAgZXJyb3IgPSAtMTsKIAot ICAgIENNUHJvZmlsZVJlZiBwcmV2aW91c1Byb2ZpbGU7Ci0gICAgZXJyb3IgPSBDTU9wZW5Qcm9m aWxlKCZwcmV2aW91c1Byb2ZpbGUsICZwcmV2aW91c1Byb2ZpbGVMb2NhdGlvbik7CiAgICAgaWYg KGVycm9yKSB7Ci0gICAgICAgIGZhaWxlZEdldHRpbmdDdXJyZW50UHJvZmlsZShlcnJvcik7Cisg ICAgICAgIGZwcmludGYoc3RkZXJyLCAiRmFpbGVkIHRvIHNldCBjb2xvciBwcm9maWxlIGZvciBt YWluIGRpc3BsYXkhICBNYW55IHBpeGVsIHRlc3RzIG1heSBmYWlsIGFzIGEgcmVzdWx0LiAgKEVy cm9yOiAlaSkiLCBlcnJvcik7CisgICAgICAgIHNJbml0aWFsUHJvZmlsZUxvY2F0aW9uLmxvY1R5 cGUgPSBjbU5vUHJvZmlsZUJhc2U7CiAgICAgICAgIHJldHVybjsKICAgICB9Ci0KLSAgICBDRlN0 cmluZ1JlZiBwcmV2aW91c1Byb2ZpbGVOYW1lOwotICAgIENGU3RyaW5nUmVmIGdlbmVyaWNQcm9m aWxlTmFtZTsKLSAgICBjaGFyIHByZXZpb3VzUHJvZmlsZU5hbWVTdHJpbmdbMTAyNF07Ci0gICAg Y2hhciBnZW5lcmljUHJvZmlsZU5hbWVTdHJpbmdbMTAyNF07Ci0gICAgQ01Db3B5UHJvZmlsZURl c2NyaXB0aW9uU3RyaW5nKHByZXZpb3VzUHJvZmlsZSwgJnByZXZpb3VzUHJvZmlsZU5hbWUpOwot ICAgIENNQ29weVByb2ZpbGVEZXNjcmlwdGlvblN0cmluZyhnZW5lcmljUHJvZmlsZSwgJmdlbmVy aWNQcm9maWxlTmFtZSk7Ci0gICAgQ0ZTdHJpbmdHZXRDU3RyaW5nKHByZXZpb3VzUHJvZmlsZU5h bWUsIHByZXZpb3VzUHJvZmlsZU5hbWVTdHJpbmcsIHNpemVvZihwcmV2aW91c1Byb2ZpbGVOYW1l U3RyaW5nKSwga0NGU3RyaW5nRW5jb2RpbmdVVEY4KTsKLSAgICBDRlN0cmluZ0dldENTdHJpbmco Z2VuZXJpY1Byb2ZpbGVOYW1lLCBnZW5lcmljUHJvZmlsZU5hbWVTdHJpbmcsIHNpemVvZihwcmV2 aW91c1Byb2ZpbGVOYW1lU3RyaW5nKSwga0NGU3RyaW5nRW5jb2RpbmdVVEY4KTsKLSAgICBDRlJl bGVhc2UocHJldmlvdXNQcm9maWxlTmFtZSk7Ci0gICAgQ0ZSZWxlYXNlKGdlbmVyaWNQcm9maWxl TmFtZSk7Ci0KLSAgICBDTUNsb3NlUHJvZmlsZShwcmV2aW91c1Byb2ZpbGUpOwotCi0gICAgZnBy aW50ZihzdGRlcnIsICJcblxuV0FSTklORzogVGVtcG9yYXJpbHkgY2hhbmdpbmcgeW91ciBzeXN0 ZW0gY29sb3IgcHJvZmlsZSBmcm9tIFwiJXNcIiB0byBcIiVzXCIuXG4iLCBwcmV2aW91c1Byb2Zp bGVOYW1lU3RyaW5nLCBnZW5lcmljUHJvZmlsZU5hbWVTdHJpbmcpOworICAgIAorICAgIC8vIE90 aGVyIHNpZ25hbHMgYXJlIGhhbmRsZWQgaW4gaW5zdGFsbFNpZ25hbEhhbmRsZXJzKCkgd2hpY2gg YWxzbyBjYWxscyByZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUoKQorICAgIHNpZ25hbChT SUdJTlQsIHJlc3RvcmVNYWluRGlzcGxheUNvbG9yUHJvZmlsZSk7CisgICAgc2lnbmFsKFNJR0hV UCwgcmVzdG9yZU1haW5EaXNwbGF5Q29sb3JQcm9maWxlKTsKKyAgICBzaWduYWwoU0lHVEVSTSwg cmVzdG9yZU1haW5EaXNwbGF5Q29sb3JQcm9maWxlKTsKKyAgICAKKyAgICBmcHJpbnRmKHN0ZGVy ciwgIlxuXG5XQVJOSU5HOiBUZW1wb3JhcmlseSBjaGFuZ2luZyB0aGUgbWFpbiBkaXNwbGF5IGNv bG9yIHByb2ZpbGUgdG8gXCIlc1wiOiB0aGUgY29sb3JzIG9uIHlvdXIgc2NyZWVuIHdpbGwgY2hh bmdlIGZvciB0aGUgZHVyYXRpb24gb2YgdGhlIHRlc3RpbmcuXG4iLCBQUk9GSUxFX1BBVEgpOwog ICAgIGZwcmludGYoc3RkZXJyLCAiVGhpcyBhbGxvd3MgdGhlIFdlYktpdCBwaXhlbC1iYXNlZCBy ZWdyZXNzaW9uIHRlc3RzIHRvIGhhdmUgY29uc2lzdGVudCBjb2xvciB2YWx1ZXMgYWNyb3NzIGFs bCBtYWNoaW5lcy5cbiIpOwotICAgIGZwcmludGYoc3RkZXJyLCAiVGhlIGNvbG9ycyBvbiB5b3Vy IHNjcmVlbiB3aWxsIGNoYW5nZSBmb3IgdGhlIGR1cmF0aW9uIG9mIHRoZSB0ZXN0aW5nLlxuXG4i KTsKLQotICAgIENNRGV2aWNlU2NvcGUgc2NvcGUgPSB7IGtDRlByZWZlcmVuY2VzQ3VycmVudFVz ZXIsIGtDRlByZWZlcmVuY2VzQ3VycmVudEhvc3QgfTsKLSAgICBpZiAoKGVycm9yID0gQ01TZXRE ZXZpY2VQcm9maWxlKGNtRGlzcGxheURldmljZUNsYXNzLCBjbURlZmF1bHREZXZpY2VJRCwgJnNj b3BlLCBjbURlZmF1bHRQcm9maWxlSUQsICZnZW5lcmljUHJvZmlsZUxvY2F0aW9uKSkpIHsKLSAg ICAgICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gc2V0IGNvbG9yIHByb2ZpbGUgdG8gXCIl c1wiISBNYW55IHBpeGVsIHRlc3RzIHdpbGwgZmFpbCBhcyBhIHJlc3VsdC4gIChFcnJvcjogJWkp IiwKLSAgICAgICAgICAgIGdlbmVyaWNQcm9maWxlTmFtZVN0cmluZywgZXJyb3IpOwotICAgIH0g ZWxzZSB7Ci0gICAgICAgIGN1cnJlbnRDb2xvclByb2ZpbGVMb2NhdGlvbiA9IHByZXZpb3VzUHJv ZmlsZUxvY2F0aW9uOwotICAgICAgICBjaGFuZ2VkQ29sb3JQcm9maWxlID0gdHJ1ZTsKLSAgICAg ICAgc2lnbmFsKFNJR0lOVCwgcmVzdG9yZUNvbG9yU3BhY2UpOwotICAgICAgICBzaWduYWwoU0lH SFVQLCByZXN0b3JlQ29sb3JTcGFjZSk7Ci0gICAgICAgIHNpZ25hbChTSUdURVJNLCByZXN0b3Jl Q29sb3JTcGFjZSk7Ci0gICAgfQogfQogCi12b2lkIGluaXRpYWxpemVDb2xvclNwYWNlQW5kU2Ny ZWVCdWZmZXJGb3JQaXhlbFRlc3RzKCkKLXsKLSAgICBzZXREZWZhdWx0Q29sb3JQcm9maWxlVG9S R0IoKTsKLSAgICBzY3JlZW5DYXB0dXJlQnVmZmVyID0gKHVuc2lnbmVkIGNoYXIgKiltYWxsb2Mo bWF4Vmlld0hlaWdodCAqIG1heFZpZXdXaWR0aCAqIDQpOwotICAgIHNoYXJlZENvbG9yU3BhY2Ug PSBDR0NvbG9yU3BhY2VDcmVhdGVEZXZpY2VSR0IoKTsKLX0KLQotLy8gRGVjbGFyZWQgaW4gUGl4 ZWxEdW1wU3VwcG9ydENHLmgKLQotUmV0YWluUHRyPENHQ29udGV4dFJlZj4gZ2V0Qml0bWFwQ29u dGV4dEZyb21XZWJWaWV3KCkKK1Bhc3NSZWZQdHI8Qml0bWFwQ29udGV4dD4gY3JlYXRlQml0bWFw Q29udGV4dEZyb21XZWJWaWV3KGJvb2wgb25zY3JlZW4sIGJvb2wgaW5jcmVtZW50YWxSZXBhaW50 LCBib29sIHN3ZWVwSG9yaXpvbnRhbGx5LCBib29sIGRyYXdTZWxlY3Rpb25SZWN0KQogewotICAg IE5TU2l6ZSB3ZWJWaWV3U2l6ZSA9IFtbbWFpbkZyYW1lIHdlYlZpZXddIGZyYW1lXS5zaXplOwot ICAgIHJldHVybiBSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPihBZG9wdENGLCBDR0JpdG1hcENvbnRl eHRDcmVhdGUoc2NyZWVuQ2FwdHVyZUJ1ZmZlciwgc3RhdGljX2Nhc3Q8c2l6ZV90Pih3ZWJWaWV3 U2l6ZS53aWR0aCksIHN0YXRpY19jYXN0PHNpemVfdD4od2ViVmlld1NpemUuaGVpZ2h0KSwgOCwg c3RhdGljX2Nhc3Q8c2l6ZV90Pih3ZWJWaWV3U2l6ZS53aWR0aCkgKiA0LCBzaGFyZWRDb2xvclNw YWNlLCBrQ0dCaXRtYXBCeXRlT3JkZXIzMkhvc3QgfCBrQ0dJbWFnZUFscGhhUHJlbXVsdGlwbGll ZExhc3QpKTsKLX0KLQotdm9pZCBwYWludFdlYlZpZXcoQ0dDb250ZXh0UmVmIGNvbnRleHQpCi17 Ci0gICAgUmV0YWluUHRyPE5TR3JhcGhpY3NDb250ZXh0PiBzYXZlZENvbnRleHQgPSBbTlNHcmFw aGljc0NvbnRleHQgY3VycmVudENvbnRleHRdOwotCi0gICAgTlNHcmFwaGljc0NvbnRleHQqIG5z Q29udGV4dCA9IFtOU0dyYXBoaWNzQ29udGV4dCBncmFwaGljc0NvbnRleHRXaXRoR3JhcGhpY3NQ b3J0OmNvbnRleHQgZmxpcHBlZDpOT107Ci0gICAgW05TR3JhcGhpY3NDb250ZXh0IHNldEN1cnJl bnRDb250ZXh0Om5zQ29udGV4dF07Ci0KICAgICBXZWJWaWV3KiB2aWV3ID0gW21haW5GcmFtZSB3 ZWJWaWV3XTsKLSAgICBbdmlldyBkaXNwbGF5SWZOZWVkZWRdOwotICAgIFt2aWV3IGxvY2tGb2N1 c107Ci0gICAgTlNCaXRtYXBJbWFnZVJlcCAqaW1hZ2VSZXAgPSBbW05TQml0bWFwSW1hZ2VSZXAg YWxsb2NdIGluaXRXaXRoRm9jdXNlZFZpZXdSZWN0Olt2aWV3IGZyYW1lXV07Ci0gICAgW3ZpZXcg dW5sb2NrRm9jdXNdOwotICAgIFtpbWFnZVJlcCBkcmF3XTsKLSAgICBbaW1hZ2VSZXAgcmVsZWFz ZV07Ci0KLSAgICBbTlNHcmFwaGljc0NvbnRleHQgc2V0Q3VycmVudENvbnRleHQ6c2F2ZWRDb250 ZXh0LmdldCgpXTsKLX0KLQotdm9pZCByZXBhaW50V2ViVmlldyhDR0NvbnRleHRSZWYgY29udGV4 dCwgYm9vbCBob3Jpem9udGFsKQotewotICAgIFJldGFpblB0cjxOU0dyYXBoaWNzQ29udGV4dD4g c2F2ZWRDb250ZXh0ID0gW05TR3JhcGhpY3NDb250ZXh0IGN1cnJlbnRDb250ZXh0XTsKLQotICAg IE5TR3JhcGhpY3NDb250ZXh0KiBuc0NvbnRleHQgPSBbTlNHcmFwaGljc0NvbnRleHQgZ3JhcGhp Y3NDb250ZXh0V2l0aEdyYXBoaWNzUG9ydDpjb250ZXh0IGZsaXBwZWQ6Tk9dOwotICAgIFtOU0dy YXBoaWNzQ29udGV4dCBzZXRDdXJyZW50Q29udGV4dDpuc0NvbnRleHRdOwotCi0gICAgV2ViVmll dyAqdmlldyA9IFttYWluRnJhbWUgd2ViVmlld107CiAgICAgTlNTaXplIHdlYlZpZXdTaXplID0g W3ZpZXcgZnJhbWVdLnNpemU7CisgICAgc2l6ZV90IHBpeGVsc1dpZGUgPSBzdGF0aWNfY2FzdDxz aXplX3Q+KHdlYlZpZXdTaXplLndpZHRoKTsKKyAgICBzaXplX3QgcGl4ZWxzSGlnaCA9IHN0YXRp Y19jYXN0PHNpemVfdD4od2ViVmlld1NpemUuaGVpZ2h0KTsKKyAgICBzaXplX3Qgcm93Qnl0ZXMg PSAoNCAqIHBpeGVsc1dpZGUgKyA2MykgJiB+NjM7IC8vIFVzZSBhIG11bHRpcGxlIG9mIDY0IGJ5 dGVzIHRvIGltcHJvdmUgQ0cgcGVyZm9ybWFuY2UKKworICAgIHZvaWQgKmJ1ZmZlciA9IGNhbGxv YyhwaXhlbHNIaWdoLCByb3dCeXRlcyk7CisgICAgaWYgKCFidWZmZXIpCisgICAgICAgIHJldHVy biAwOworICAgIAorICAgIHN0YXRpYyBDR0NvbG9yU3BhY2VSZWYgY29sb3JTcGFjZSA9IDA7Cisg ICAgaWYgKCFjb2xvclNwYWNlKSB7CisgICAgICAgIENNUHJvZmlsZUxvY2F0aW9uIGxvY2F0aW9u OworICAgICAgICBsb2NhdGlvbi5sb2NUeXBlID0gY21GaWxlQmFzZWRQcm9maWxlOworICAgICAg ICBOU1VSTCAqdXJsID0gW05TVVJMIGZpbGVVUkxXaXRoUGF0aDpbTlNTdHJpbmcgc3RyaW5nV2l0 aFVURjhTdHJpbmc6UFJPRklMRV9QQVRIXV07CisgICAgICAgIEZTUmVmIGZzUmVmOworICAgICAg ICBpZiAodXJsICYmIENGVVJMR2V0RlNSZWYoKENGVVJMUmVmKXVybCwgJmZzUmVmKSkgeworICAg ICAgICAgICAgaWYgKEZTR2V0Q2F0YWxvZ0luZm8oJmZzUmVmLCAwLCAwLCAwLCAmbG9jYXRpb24u dS5maWxlTG9jLnNwZWMsIDApID09IG5vRXJyKSB7CisgICAgICAgICAgICAgICAgQ01Qcm9maWxl UmVmIHByb2ZpbGU7CisgICAgICAgICAgICAgICAgaWYgKENNT3BlblByb2ZpbGUoJnByb2ZpbGUs ICZsb2NhdGlvbikgPT0gbm9FcnIpIHsKKyAgICAgICAgICAgICAgICAgICAgY29sb3JTcGFjZSA9 IENHQ29sb3JTcGFjZUNyZWF0ZVdpdGhQbGF0Zm9ybUNvbG9yU3BhY2UocHJvZmlsZSk7CisgICAg ICAgICAgICAgICAgICAgIENNQ2xvc2VQcm9maWxlKHByb2ZpbGUpOworICAgICAgICAgICAgICAg IH0KKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICBDR0NvbnRleHRS ZWYgY29udGV4dCA9IENHQml0bWFwQ29udGV4dENyZWF0ZShidWZmZXIsIHBpeGVsc1dpZGUsIHBp eGVsc0hpZ2gsIDgsIHJvd0J5dGVzLCBjb2xvclNwYWNlLCBrQ0dJbWFnZUFscGhhUHJlbXVsdGlw bGllZEZpcnN0IHwga0NHQml0bWFwQnl0ZU9yZGVyMzJIb3N0KTsgLy8gVXNlIEFSR0I4IG9uIFBQ QyBvciBCR1JBOCBvbiBYODYgdG8gaW1wcm92ZSBDRyBwZXJmb3JtYW5jZQorICAgIGlmICghY29u dGV4dCkgeworICAgICAgICBmcmVlKGJ1ZmZlcik7CisgICAgICAgIHJldHVybiAwOworICAgIH0K IAotICAgIGlmIChob3Jpem9udGFsKSB7Ci0gICAgICAgIGZvciAoTlNSZWN0IGNvbHVtbiA9IE5T TWFrZVJlY3QoMCwgMCwgMSwgd2ViVmlld1NpemUuaGVpZ2h0KTsgY29sdW1uLm9yaWdpbi54IDwg d2ViVmlld1NpemUud2lkdGg7IGNvbHVtbi5vcmlnaW4ueCsrKQotICAgICAgICAgICAgW3ZpZXcg ZGlzcGxheVJlY3RJZ25vcmluZ09wYWNpdHk6Y29sdW1uIGluQ29udGV4dDpuc0NvbnRleHRdOwor ICAgIC8vIFRoZSBCaXRtYXBDb250ZXh0IGtlZXBzIHRoZSBDR0NvbnRleHRSZWYgYW5kIHRoZSBw aXhlbCBidWZmZXIgYWxpdmUKKyAgICBSZWZQdHI8Qml0bWFwQ29udGV4dD4gYml0bWFwQ29udGV4 dCA9IEJpdG1hcENvbnRleHQ6OmNyZWF0ZUJ5QWRvcHRpbmdCaXRtYXBBbmRDb250ZXh0KGJ1ZmZl ciwgY29udGV4dCk7CisgICAgCisgICAgTlNHcmFwaGljc0NvbnRleHQgKm5zQ29udGV4dCA9IFtO U0dyYXBoaWNzQ29udGV4dCBncmFwaGljc0NvbnRleHRXaXRoR3JhcGhpY3NQb3J0OmNvbnRleHQg ZmxpcHBlZDpOT107CisgICAgQVNTRVJUKG5zQ29udGV4dCk7CisgICAgCisgICAgaWYgKGluY3Jl bWVudGFsUmVwYWludCkgeworICAgICAgICBpZiAoc3dlZXBIb3Jpem9udGFsbHkpIHsKKyAgICAg ICAgICAgIGZvciAoTlNSZWN0IGNvbHVtbiA9IE5TTWFrZVJlY3QoMCwgMCwgMSwgd2ViVmlld1Np emUuaGVpZ2h0KTsgY29sdW1uLm9yaWdpbi54IDwgd2ViVmlld1NpemUud2lkdGg7IGNvbHVtbi5v cmlnaW4ueCsrKQorICAgICAgICAgICAgICAgIFt2aWV3IGRpc3BsYXlSZWN0SWdub3JpbmdPcGFj aXR5OmNvbHVtbiBpbkNvbnRleHQ6bnNDb250ZXh0XTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAg ICAgICAgIGZvciAoTlNSZWN0IGxpbmUgPSBOU01ha2VSZWN0KDAsIDAsIHdlYlZpZXdTaXplLndp ZHRoLCAxKTsgbGluZS5vcmlnaW4ueSA8IHdlYlZpZXdTaXplLmhlaWdodDsgbGluZS5vcmlnaW4u eSsrKQorICAgICAgICAgICAgICAgIFt2aWV3IGRpc3BsYXlSZWN0SWdub3JpbmdPcGFjaXR5Omxp bmUgaW5Db250ZXh0Om5zQ29udGV4dF07CisgICAgICAgIH0KICAgICB9IGVsc2UgewotICAgICAg ICBmb3IgKE5TUmVjdCBsaW5lID0gTlNNYWtlUmVjdCgwLCAwLCB3ZWJWaWV3U2l6ZS53aWR0aCwg MSk7IGxpbmUub3JpZ2luLnkgPCB3ZWJWaWV3U2l6ZS5oZWlnaHQ7IGxpbmUub3JpZ2luLnkrKykK LSAgICAgICAgICAgIFt2aWV3IGRpc3BsYXlSZWN0SWdub3JpbmdPcGFjaXR5OmxpbmUgaW5Db250 ZXh0Om5zQ29udGV4dF07CisgICAgICAgIGlmIChvbnNjcmVlbikgeworI2lmZGVmIEJVSUxESU5H X09OX0xFT1BBUkQKKyAgICAgICAgICAgIC8vIEFzayB0aGUgd2luZG93IHNlcnZlciB0byBwcm92 aWRlIHVzIGEgY29tcG9zaXRlZCB2ZXJzaW9uIG9mIHRoZSAqcmVhbCogd2luZG93IGNvbnRlbnQg aW5jbHVkaW5nIHN1cmZhY2VzIChpLmUuIE9wZW5HTCBjb250ZW50KQorICAgICAgICAgICAgLy8g Tm90ZSB0aGF0IHRoZSByZXR1cm5lZCBpbWFnZSBtaWdodCBkaWZmZXIgdmVyeSBzbGlnaHRseSBm cm9tIHRoZSB3aW5kb3cgYmFja2luZyBiZWNhdXNlIG9mIGRpdGhlcmluZyBhcnRpZmFjdHMgaW4g dGhlIHdpbmRvdyBzZXJ2ZXIgY29tcG9zaXRvcgorICAgICAgICAgICAgCisgICAgICAgICAgICBD R0ltYWdlUmVmIGltYWdlID0gQ0dXaW5kb3dMaXN0Q3JlYXRlSW1hZ2UoQ0dSZWN0TnVsbCwga0NH V2luZG93TGlzdE9wdGlvbkluY2x1ZGluZ1dpbmRvdywgW1t2aWV3IHdpbmRvd10gd2luZG93TnVt YmVyXSwga0NHV2luZG93SW1hZ2VCb3VuZHNJZ25vcmVGcmFtaW5nIHwga0NHV2luZG93SW1hZ2VT aG91bGRCZU9wYXF1ZSk7CisgICAgICAgICAgICBDR0NvbnRleHREcmF3SW1hZ2UoY29udGV4dCwg Q0dSZWN0TWFrZSgwLCAwLCBDR0ltYWdlR2V0V2lkdGgoaW1hZ2UpLCBDR0ltYWdlR2V0SGVpZ2h0 KGltYWdlKSksIGltYWdlKTsKKyAgICAgICAgICAgIENHSW1hZ2VSZWxlYXNlKGltYWdlKTsKKyNl bHNlCisgICAgICAgICAgICAvLyBPbiAxMC40IGFuZCBlYXJsaWVyLCB3ZSBoYXZlIHRvIG1vdmUg dGhlIHdpbmRvdyB0ZW1wb3JhcmlseSAib25zY3JlZW4iIGFuZCByZWFkIGRpcmVjdGx5IGZyb20g dGhlIGRpc3BsYXkgZnJhbWVidWZmZXIgdXNpbmcgT3BlbkdMCisgICAgICAgICAgICAvLyBJbiB0 aGlzIGNvZGUgcGF0aCwgd2UgbmVlZCB0byBlbnN1cmUgdGhlIHdpbmRvdyBpcyBhYm92ZSBhbnkg b3RoZXIgd2luZG93IG9yIGNhcHR1cmVkIHJlc3VsdCB3aWxsIGJlIGNvcnJ1cHRlZAorICAgICAg ICAgICAgCisgICAgICAgICAgICBOU1dpbmRvdyAqd2luZG93ID0gW3ZpZXcgd2luZG93XTsKKyAg ICAgICAgICAgIGludCBvbGRMZXZlbCA9IFt3aW5kb3cgbGV2ZWxdOworICAgICAgICAgICAgTlNS ZWN0IG9sZEZyYW1lID0gW3dpbmRvdyBmcmFtZV07CisgICAgICAgICAgICAKKyAgICAgICAgICAg IE5TUmVjdCBuZXdGcmFtZSA9IFtbW05TU2NyZWVuIHNjcmVlbnNdIG9iamVjdEF0SW5kZXg6MF0g ZnJhbWVdOworICAgICAgICAgICAgbmV3RnJhbWUgPSBOU01ha2VSZWN0KG5ld0ZyYW1lLm9yaWdp bi54ICsgKG5ld0ZyYW1lLnNpemUud2lkdGggLSBvbGRGcmFtZS5zaXplLndpZHRoKSAvIDIsIG5l d0ZyYW1lLm9yaWdpbi55ICsgKG5ld0ZyYW1lLnNpemUuaGVpZ2h0IC0gb2xkRnJhbWUuc2l6ZS5o ZWlnaHQpIC8gMiwgb2xkRnJhbWUuc2l6ZS53aWR0aCwgb2xkRnJhbWUuc2l6ZS5oZWlnaHQpOwor ICAgICAgICAgICAgW3dpbmRvdyBzZXRMZXZlbDpOU1NjcmVlblNhdmVyV2luZG93TGV2ZWxdOwor ICAgICAgICAgICAgW3dpbmRvdyBzZXRGcmFtZTpuZXdGcmFtZSBkaXNwbGF5Ok5PIGFuaW1hdGU6 Tk9dOworICAgICAgICAgICAgCisgICAgICAgICAgICBDR1JlY3QgcmVjdCA9IENHUmVjdE1ha2Uo bmV3RnJhbWUub3JpZ2luLngsIG5ld0ZyYW1lLm9yaWdpbi55LCB3ZWJWaWV3U2l6ZS53aWR0aCwg d2ViVmlld1NpemUuaGVpZ2h0KTsKKyAgICAgICAgICAgIENHRGlyZWN0RGlzcGxheUlEIGRpc3Bs YXlJRDsKKyAgICAgICAgICAgIENHRGlzcGxheUNvdW50IGNvdW50OworICAgICAgICAgICAgaWYg KENHR2V0RGlzcGxheXNXaXRoUmVjdChyZWN0LCAxLCAmZGlzcGxheUlELCAmY291bnQpID09IGtD R0Vycm9yU3VjY2VzcykgeworICAgICAgICAgICAgICAgIENHUmVjdCBib3VuZHMgPSBDR0Rpc3Bs YXlCb3VuZHMoZGlzcGxheUlEKTsKKyAgICAgICAgICAgICAgICByZWN0Lm9yaWdpbi54IC09IGJv dW5kcy5vcmlnaW4ueDsKKyAgICAgICAgICAgICAgICByZWN0Lm9yaWdpbi55IC09IGJvdW5kcy5v cmlnaW4ueTsKKyAgICAgICAgICAgICAgICAKKyAgICAgICAgICAgICAgICBDR0xQaXhlbEZvcm1h dEF0dHJpYnV0ZSBhdHRyaWJ1dGVzW10gPSB7a0NHTFBGQUFjY2VsZXJhdGVkLCBrQ0dMUEZBTm9S ZWNvdmVyeSwga0NHTFBGQUZ1bGxTY3JlZW4sIGtDR0xQRkFEaXNwbGF5TWFzaywgKENHTFBpeGVs Rm9ybWF0QXR0cmlidXRlKUNHRGlzcGxheUlEVG9PcGVuR0xEaXNwbGF5TWFzayhkaXNwbGF5SUQp LCAoQ0dMUGl4ZWxGb3JtYXRBdHRyaWJ1dGUpMH07CisgICAgICAgICAgICAgICAgQ0dMUGl4ZWxG b3JtYXRPYmogcGl4ZWxGb3JtYXQ7CisgICAgICAgICAgICAgICAgR0xpbnQgbnVtOworICAgICAg ICAgICAgICAgIGlmIChDR0xDaG9vc2VQaXhlbEZvcm1hdChhdHRyaWJ1dGVzLCAmcGl4ZWxGb3Jt YXQsICZudW0pID09IGtDR0xOb0Vycm9yKSB7CisgICAgICAgICAgICAgICAgICAgIENHTENvbnRl eHRPYmogY2dsX2N0eDsKKyAgICAgICAgICAgICAgICAgICAgaWYgKENHTENyZWF0ZUNvbnRleHQo cGl4ZWxGb3JtYXQsIDAsICZjZ2xfY3R4KSA9PSBrQ0dMTm9FcnJvcikgeworICAgICAgICAgICAg ICAgICAgICAgICAgaWYgKENHTFNldEZ1bGxTY3JlZW4oY2dsX2N0eCkgPT0ga0NHTE5vRXJyb3Ip IHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICB2b2lkICpmbGlwQnVmZmVyID0gY2FsbG9j KHBpeGVsc0hpZ2gsIHJvd0J5dGVzKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBpZiAo ZmxpcEJ1ZmZlcikgeworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnbFBpeGVsU3Rv cmVpKEdMX1BBQ0tfUk9XX0xFTkdUSCwgcm93Qnl0ZXMgLyA0KTsKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgZ2xQaXhlbFN0b3JlaShHTF9QQUNLX0FMSUdOTUVOVCwgNCk7CisjaWYg X19CSUdfRU5ESUFOX18KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2xSZWFkUGl4 ZWxzKHJlY3Qub3JpZ2luLngsIHJlY3Qub3JpZ2luLnksIHJlY3Quc2l6ZS53aWR0aCwgcmVjdC5z aXplLmhlaWdodCwgR0xfUkdCQSwgR0xfVU5TSUdORURfSU5UXzhfOF84XzgsIGZsaXBCdWZmZXIp OworI2Vsc2UKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2xSZWFkUGl4ZWxzKHJl Y3Qub3JpZ2luLngsIHJlY3Qub3JpZ2luLnksIHJlY3Quc2l6ZS53aWR0aCwgcmVjdC5zaXplLmhl aWdodCwgR0xfUkdCQSwgR0xfVU5TSUdORURfSU5UXzhfOF84XzhfUkVWLCBmbGlwQnVmZmVyKTsK KyNlbmRpZgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpZiAoIWdsR2V0RXJyb3Io KSkgeworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZm9yKHNpemVfdCBpID0g MDsgaSA8IHBpeGVsc0hpZ2g7ICsraSkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGJjb3B5KChjaGFyKilmbGlwQnVmZmVyICsgcm93Qnl0ZXMgKiBpLCAoY2hhciopYnVmZmVy ICsgcm93Qnl0ZXMgKiAocGl4ZWxzSGlnaCAtIGkgLSAxKSwgcGl4ZWxzV2lkZSAqIDQpOworICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmcmVlKGZsaXBCdWZmZXIp OworICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgICAg IH0KKyAgICAgICAgICAgICAgICAgICAgICAgIENHTERlc3Ryb3lDb250ZXh0KGNnbF9jdHgpOwor ICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgIENHTERlc3Ryb3lQaXhl bEZvcm1hdChwaXhlbEZvcm1hdCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQor ICAgICAgICAgICAgCisgICAgICAgICAgICBbd2luZG93IHNldEZyYW1lOm9sZEZyYW1lIGRpc3Bs YXk6Tk8gYW5pbWF0ZTpOT107CisgICAgICAgICAgICBbd2luZG93IHNldExldmVsOm9sZExldmVs XTsKKyNlbmRpZgorICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgLy8gR3JhYiBkaXJlY3Rs eSB0aGUgY29udGVudHMgb2YgdGhlIHdpbmRvdyBiYWNraW5nIGJ1ZmZlciAodGhpcyBpZ25vcmVz IGFueSBzdXJmYWNlcyBvbiB0aGUgd2luZG93KQorICAgICAgICAgICAgLy8gRklYTUU6IFRoaXMg cGF0aCBpcyBzdWJvcHRpbWFsOiBkYXRhIGlzIHJlYWQgZnJvbSB3aW5kb3cgYmFja2luZyBzdG9y ZSwgY29udmVydGVkIHRvIFJHQjggdGhlbiBkcmF3biBhZ2FpbiBpbnRvIGFuIFJHQkE4IGJpdG1h cAorICAgICAgICAgICAgCisgICAgICAgICAgICBbdmlldyBkaXNwbGF5SWZOZWVkZWRdOworICAg ICAgICAgICAgW3ZpZXcgbG9ja0ZvY3VzXTsKKyAgICAgICAgICAgIE5TQml0bWFwSW1hZ2VSZXAg KmltYWdlUmVwID0gW1tbTlNCaXRtYXBJbWFnZVJlcCBhbGxvY10gaW5pdFdpdGhGb2N1c2VkVmll d1JlY3Q6W3ZpZXcgZnJhbWVdXSBhdXRvcmVsZWFzZV07CisgICAgICAgICAgICBbdmlldyB1bmxv Y2tGb2N1c107CisKKyAgICAgICAgICAgIFJldGFpblB0cjxOU0dyYXBoaWNzQ29udGV4dD4gc2F2 ZWRDb250ZXh0ID0gW05TR3JhcGhpY3NDb250ZXh0IGN1cnJlbnRDb250ZXh0XTsKKyAgICAgICAg ICAgIFtOU0dyYXBoaWNzQ29udGV4dCBzZXRDdXJyZW50Q29udGV4dDpuc0NvbnRleHRdOworICAg ICAgICAgICAgW2ltYWdlUmVwIGRyYXddOworICAgICAgICAgICAgW05TR3JhcGhpY3NDb250ZXh0 IHNldEN1cnJlbnRDb250ZXh0OnNhdmVkQ29udGV4dC5nZXQoKV07CisgICAgICAgIH0KICAgICB9 CiAKLSAgICBbTlNHcmFwaGljc0NvbnRleHQgc2V0Q3VycmVudENvbnRleHQ6c2F2ZWRDb250ZXh0 LmdldCgpXTsKLX0KLQotQ0dSZWN0IGdldFNlbGVjdGlvblJlY3QoKQotewotICAgIE5TVmlldyAq ZG9jdW1lbnRWaWV3ID0gW1ttYWluRnJhbWUgZnJhbWVWaWV3XSBkb2N1bWVudFZpZXddOwotICAg IGlmIChbZG9jdW1lbnRWaWV3IGNvbmZvcm1zVG9Qcm90b2NvbDpAcHJvdG9jb2woV2ViRG9jdW1l bnRTZWxlY3Rpb24pXSkgeworICAgIGlmIChkcmF3U2VsZWN0aW9uUmVjdCkgeworICAgICAgICBO U1ZpZXcgKmRvY3VtZW50VmlldyA9IFtbbWFpbkZyYW1lIGZyYW1lVmlld10gZG9jdW1lbnRWaWV3 XTsKKyAgICAgICAgQVNTRVJUKFtkb2N1bWVudFZpZXcgY29uZm9ybXNUb1Byb3RvY29sOkBwcm90 b2NvbChXZWJEb2N1bWVudFNlbGVjdGlvbildKTsKICAgICAgICAgTlNSZWN0IHJlY3QgPSBbZG9j dW1lbnRWaWV3IGNvbnZlcnRSZWN0OlsoaWQgPFdlYkRvY3VtZW50U2VsZWN0aW9uPilkb2N1bWVu dFZpZXcgc2VsZWN0aW9uUmVjdF0gZnJvbVZpZXc6bmlsXTsKLSAgICAgICAgcmV0dXJuIENHUmVj dE1ha2UocmVjdC5vcmlnaW4ueCwgcmVjdC5vcmlnaW4ueSwgcmVjdC5zaXplLndpZHRoLCByZWN0 LnNpemUuaGVpZ2h0KTsKKyAgICAgICAgQ0dDb250ZXh0U2F2ZUdTdGF0ZShjb250ZXh0KTsKKyAg ICAgICAgQ0dDb250ZXh0U2V0TGluZVdpZHRoKGNvbnRleHQsIDEuMCk7CisgICAgICAgIENHQ29u dGV4dFNldFJHQlN0cm9rZUNvbG9yKGNvbnRleHQsIDEuMCwgMC4wLCAwLjAsIDEuMCk7CisgICAg ICAgIENHQ29udGV4dFN0cm9rZVJlY3QoY29udGV4dCwgQ0dSZWN0TWFrZShyZWN0Lm9yaWdpbi54 LCByZWN0Lm9yaWdpbi55LCByZWN0LnNpemUud2lkdGgsIHJlY3Quc2l6ZS5oZWlnaHQpKTsKKyAg ICAgICAgQ0dDb250ZXh0UmVzdG9yZUdTdGF0ZShjb250ZXh0KTsKICAgICB9Ci0KLSAgICBBU1NF UlRfTk9UX1JFQUNIRUQoKTsKLSAgICByZXR1cm4gQ0dSZWN0WmVybzsKKyAgICAKKyAgICByZXR1 cm4gYml0bWFwQ29udGV4dC5yZWxlYXNlKCk7CiB9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJl bmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcAppbmRleCAxY2UzMWRlLi43NDJiZDdmIDEw MDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUu Y3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5j cHAKQEAgLTM4LDI1ICszOCwyNiBAQAogI2luY2x1ZGUgIlVJRGVsZWdhdGUuaCIKICNpbmNsdWRl ICJXb3JrUXVldWVJdGVtLmgiCiAjaW5jbHVkZSAiV29ya1F1ZXVlLmgiCisKKyNpbmNsdWRlIDxm Y250bC5oPgorI2luY2x1ZGUgPGlvLmg+CisjaW5jbHVkZSA8bWF0aC5oPgorI2luY2x1ZGUgPHB0 aHJlYWQuaD4KKyNpbmNsdWRlIDxzaGx3YXBpLmg+CisjaW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNs dWRlIDxzdHJpbmcuaD4KKyNpbmNsdWRlIDx0Y2hhci5oPgogI2luY2x1ZGUgPHd0Zi9SZXRhaW5Q dHIuaD4KICNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+Ci0jaW5jbHVkZSA8V2ViQ29yZS9DT01QdHIu aD4KLSNpbmNsdWRlIDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgorI2luY2x1ZGUg PHdpbmRvd3MuaD4KICNpbmNsdWRlIDxDRk5ldHdvcmsvQ0ZVUkxDYWNoZVByaXYuaD4KKyNpbmNs dWRlIDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgogI2luY2x1ZGUgPEphdmFTY3Jp cHRDb3JlL0phdmFTY3JpcHRDb3JlLmg+Ci0jaW5jbHVkZSA8bWF0aC5oPgotI2luY2x1ZGUgPHB0 aHJlYWQuaD4KLSNpbmNsdWRlIDxzdHJpbmc+Ci0jaW5jbHVkZSA8dGNoYXIuaD4KKyNpbmNsdWRl IDxXZWJDb3JlL0NPTVB0ci5oPgogI2luY2x1ZGUgPFdlYktpdC9Gb3JFYWNoQ29DbGFzcy5oPgog I2luY2x1ZGUgPFdlYktpdC9XZWJLaXQuaD4KLSNpbmNsdWRlIDxmY250bC5oPgotI2luY2x1ZGUg PGlvLmg+Ci0jaW5jbHVkZSA8d2luZG93cy5oPgotI2luY2x1ZGUgPHN0ZGlvLmg+Ci0jaW5jbHVk ZSA8c2hsd2FwaS5oPgogCi11c2luZyBzdGQ6OndzdHJpbmc7Cit1c2luZyBuYW1lc3BhY2Ugc3Rk OwogCiAjaWZuZGVmIE5ERUJVRwogY29uc3QgTFBXU1RSIFRlc3RQbHVnaW5EaXIgPSBMIlRlc3RO ZXRzY2FwZVBsdWdpbl9EZWJ1ZyI7CkBAIC03OCw4ICs3OSw2IEBAIHN0YXRpYyBib29sIHRocmVh ZGVkID0gZmFsc2U7CiBzdGF0aWMgYm9vbCBmb3JjZUNvbXBsZXhUZXh0ID0gZmFsc2U7CiBzdGF0 aWMgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBwZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlv bjsKIAotc3RhdGljIGNvbnN0IGNoYXIqIGN1cnJlbnRUZXN0OwotCiB2b2xhdGlsZSBib29sIGRv bmU7CiAvLyBUaGlzIGlzIHRoZSB0b3Btb3N0IGZyYW1lIHRoYXQgaXMgbG9hZGluZywgZHVyaW5n IGEgZ2l2ZW4gbG9hZCwgb3IgbmlsIHdoZW4gbm8gbG9hZCBpcyAKIC8vIGluIHByb2dyZXNzLiAg VXN1YWxseSB0aGlzIGlzIHRoZSBzYW1lIGFzIHRoZSBtYWluIGZyYW1lLCBidXQgbm90IGFsd2F5 cy4gIEluIHRoZSBjYXNlCkBAIC01NjIsNyArNTYxLDcgQEAgdm9pZCBkdW1wKCkKICAgICAgICAg ICAgIHdzdHJpbmcgcmVzdWx0ID0gZHVtcEZyYW1lc0FzVGV4dChmcmFtZSk7CiAgICAgICAgICAg ICByZXN1bHRTdHJpbmcgPSBTeXNBbGxvY1N0cmluZ0xlbihyZXN1bHQuZGF0YSgpLCByZXN1bHQu c2l6ZSgpKTsKICAgICAgICAgfSBlbHNlIHsKLSAgICAgICAgICAgIGJvb2wgaXNTVkdXM0NUZXN0 ID0gc3Ryc3RyKGN1cnJlbnRUZXN0LCAic3ZnXFxXM0MtU1ZHLTEuMSIpOworICAgICAgICAgICAg Ym9vbCBpc1NWR1czQ1Rlc3QgPSAoZ0xheW91dFRlc3RDb250cm9sbGVyLT50ZXN0UGF0aE9yVVJM KCkuZmluZCgic3ZnXFxXM0MtU1ZHLTEuMSIpICE9IHN0cmluZzo6bnBvcyk7CiAgICAgICAgICAg ICB1bnNpZ25lZCB3aWR0aDsKICAgICAgICAgICAgIHVuc2lnbmVkIGhlaWdodDsKICAgICAgICAg ICAgIGlmIChpc1NWR1czQ1Rlc3QpIHsKQEAgLTYwOCw3ICs2MDcsNyBAQCB2b2lkIGR1bXAoKQog CiAgICAgaWYgKGR1bXBQaXhlbHMpIHsKICAgICAgICAgaWYgKCFnTGF5b3V0VGVzdENvbnRyb2xs ZXItPmR1bXBBc1RleHQoKSAmJiAhZ0xheW91dFRlc3RDb250cm9sbGVyLT5kdW1wRE9NQXNXZWJB cmNoaXZlKCkgJiYgIWdMYXlvdXRUZXN0Q29udHJvbGxlci0+ZHVtcFNvdXJjZUFzV2ViQXJjaGl2 ZSgpKQotICAgICAgICAgICAgZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0 ZWQoY3VycmVudFRlc3QsIGR1bXBBbGxQaXhlbHMpOworICAgICAgICAgICAgZHVtcFdlYlZpZXdB c1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0ZWQoZ0xheW91dFRlc3RDb250cm9sbGVyLT5leHBl Y3RlZFBpeGVsSGFzaCgpKTsKICAgICB9CiAKICAgICBwcmludGYoIiNFT0ZcbiIpOyAgIC8vIHRl cm1pbmF0ZSB0aGUgKHBvc3NpYmx5IGVtcHR5KSBwaXhlbHMgYmxvY2sKQEAgLTY3NSwxMyArNjc0 LDIzIEBAIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVz dGluZygpCiAgICAgd2ViVmlld1ByaXZhdGUtPmNsZWFyTWFpbkZyYW1lTmFtZSgpOwogfQogCi1z dGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0IGNoYXIqIHBhdGhPclVSTCkKK3N0YXRpYyB2b2lkIHJ1 blRlc3QoY29uc3Qgc3RyaW5nJiB0ZXN0UGF0aE9yVVJMKQogewogICAgIHN0YXRpYyBCU1RSIG1l dGhvZEJTdHIgPSBTeXNBbGxvY1N0cmluZyhURVhUKCJHRVQiKSk7CiAKKyAgICAvLyBMb29rIGZv ciAiJyIgYXMgYSBzZXBhcmF0b3IgYmV0d2VlbiB0aGUgcGF0aCBvciBVUkwsIGFuZCB0aGUgcGl4 ZWwgZHVtcCBoYXNoIHRoYXQgZm9sbG93cy4KKyAgICBzdHJpbmcgcGF0aE9yVVJMKHRlc3RQYXRo T3JVUkwpOworICAgIHN0cmluZyBleHBlY3RlZFBpeGVsSGFzaDsKKyAgICAKKyAgICBzaXplX3Qg c2VwYXJhdG9yUG9zID0gcGF0aE9yVVJMLmZpbmQoIiciKTsKKyAgICBpZiAoc2VwYXJhdG9yUG9z ICE9IHN0cmluZzo6bnBvcykgeworICAgICAgICBwYXRoT3JVUkwgPSBzdHJpbmcodGVzdFBhdGhP clVSTCwgMCwgc2VwYXJhdG9yUG9zKTsKKyAgICAgICAgZXhwZWN0ZWRQaXhlbEhhc2ggPSBzdHJp bmcodGVzdFBhdGhPclVSTCwgc2VwYXJhdG9yUG9zICsgMSk7CisgICAgfQorICAgIAogICAgIEJT VFIgdXJsQlN0cjsKICAKLSAgICBDRlN0cmluZ1JlZiBzdHIgPSBDRlN0cmluZ0NyZWF0ZVdpdGhD U3RyaW5nKDAsIHBhdGhPclVSTCwga0NGU3RyaW5nRW5jb2RpbmdXaW5kb3dzTGF0aW4xKTsKKyAg ICBDRlN0cmluZ1JlZiBzdHIgPSBDRlN0cmluZ0NyZWF0ZVdpdGhDU3RyaW5nKDAsIHBhdGhPclVS TC5jX3N0cigpLCBrQ0ZTdHJpbmdFbmNvZGluZ1dpbmRvd3NMYXRpbjEpOwogICAgIENGVVJMUmVm IHVybCA9IENGVVJMQ3JlYXRlV2l0aFN0cmluZygwLCBzdHIsIDApOwogCiAgICAgaWYgKCF1cmwp CkBAIC03MDAsMTMgKzcwOSwxMSBAQCBzdGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0IGNoYXIqIHBh dGhPclVSTCkKIAogICAgIENGUmVsZWFzZSh1cmwpOwogCi0gICAgY3VycmVudFRlc3QgPSBwYXRo T3JVUkw7Ci0KLSAgICA6OmdMYXlvdXRUZXN0Q29udHJvbGxlciA9IG5ldyBMYXlvdXRUZXN0Q29u dHJvbGxlcihmYWxzZSwgZmFsc2UpOworICAgIDo6Z0xheW91dFRlc3RDb250cm9sbGVyID0gbmV3 IExheW91dFRlc3RDb250cm9sbGVyKHBhdGhPclVSTCwgZXhwZWN0ZWRQaXhlbEhhc2gpOwogICAg IGRvbmUgPSBmYWxzZTsKICAgICB0b3BMb2FkaW5nRnJhbWUgPSAwOwogCi0gICAgaWYgKHNob3Vs ZExvZ0ZyYW1lTG9hZERlbGVnYXRlcyhwYXRoT3JVUkwpKQorICAgIGlmIChzaG91bGRMb2dGcmFt ZUxvYWREZWxlZ2F0ZXMocGF0aE9yVVJMLmNfc3RyKCkpKQogICAgICAgICBnTGF5b3V0VGVzdENv bnRyb2xsZXItPnNldER1bXBGcmFtZUxvYWRDYWxsYmFja3ModHJ1ZSk7CiAKICAgICBDT01QdHI8 SVdlYkhpc3Rvcnk+IGhpc3RvcnkoQ3JlYXRlLCBDTFNJRF9XZWJIaXN0b3J5KTsKZGlmZiAtLWdp dCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9QaXhlbER1bXBTdXBwb3J0V2luLmNw cCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9QaXhlbER1bXBTdXBwb3J0V2luLmNw cAppbmRleCAyZjIzMTU4Li5kMGI3OWUxIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS93aW4vUGl4ZWxEdW1wU3VwcG9ydFdpbi5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvd2luL1BpeGVsRHVtcFN1cHBvcnRXaW4uY3BwCkBAIC0zNCw3ICszNCw3IEBA CiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KICNpbmNsdWRlIDx3dGYvUmV0YWluUHRyLmg+ CiAKLVJldGFpblB0cjxDR0NvbnRleHRSZWY+IGdldEJpdG1hcENvbnRleHRGcm9tV2ViVmlldygp CitQYXNzUmVmUHRyPEJpdG1hcENvbnRleHQ+IGdldEJpdG1hcENvbnRleHRGcm9tV2ViVmlldyhi b29sIG9uc2NyZWVuLCBib29sIGluY3JlbWVudGFsUmVwYWludCwgYm9vbCBzd2VlcEhvcml6b250 YWxseSwgYm9vbCBkcmF3U2VsZWN0aW9uUmVjdCkKIHsKICAgICBSRUNUIGZyYW1lOwogICAgIGlm ICghR2V0V2luZG93UmVjdCh3ZWJWaWV3V2luZG93LCAmZnJhbWUpKQpAQCAtNDgsOCArNDgsNiBA QCBSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPiBnZXRCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoKQog ICAgIGJtcC5ibWlIZWFkZXIuYmlCaXRDb3VudCA9IDMyOwogICAgIGJtcC5ibWlIZWFkZXIuYmlD b21wcmVzc2lvbiA9IEJJX1JHQjsKIAotICAgIC8vIEZJWE1FOiBDdXJyZW50bHkgd2UgbGVhayB0 aGlzIEhCSVRNQVAgYmVjYXVzZSB3ZSBkb24ndCBoYXZlIGEgZ29vZCB3YXkKLSAgICAvLyB0byBk ZXN0cm95IGl0IHdoZW4gdGhlIENHQml0bWFwQ29udGV4dCBnZXRzIGRlc3Ryb3llZC4KICAgICB2 b2lkKiBiaXRzID0gMDsKICAgICBIQklUTUFQIGJpdG1hcCA9IENyZWF0ZURJQlNlY3Rpb24oMCwg JmJtcCwgRElCX1JHQl9DT0xPUlMsICZiaXRzLCAwLCAwKTsKIApAQCAtNjMsNiArNjEsOCBAQCBS ZXRhaW5QdHI8Q0dDb250ZXh0UmVmPiBnZXRCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoKQogICAg IEFTU0VSVChpbmZvLmJtQml0c1BpeGVsID09IDMyKTsKIAogICAgIFJldGFpblB0cjxDR0NvbG9y U3BhY2VSZWY+IGNvbG9yU3BhY2UoQWRvcHRDRiwgQ0dDb2xvclNwYWNlQ3JlYXRlRGV2aWNlUkdC KCkpOwotICAgIHJldHVybiBSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPihBZG9wdENGLCBDR0JpdG1h cENvbnRleHRDcmVhdGUoaW5mby5ibUJpdHMsIGluZm8uYm1XaWR0aCwgaW5mby5ibUhlaWdodCwg OCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGluZm8u Ym1XaWR0aEJ5dGVzLCBjb2xvclNwYWNlLmdldCgpLCBrQ0dCaXRtYXBCeXRlT3JkZXIzMkxpdHRs ZSB8IGtDR0ltYWdlQWxwaGFQcmVtdWx0aXBsaWVkRmlyc3QpKTsKKyAgICBDR0NvbnRleHRSZWYg Y29udGV4dCA9IENHQml0bWFwQ29udGV4dENyZWF0ZShpbmZvLmJtQml0cywgaW5mby5ibVdpZHRo LCBpbmZvLmJtSGVpZ2h0LCA4LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgaW5mby5ibVdpZHRoQnl0ZXMsIGNvbG9yU3BhY2UuZ2V0KCksIGtDR0JpdG1h cEJ5dGVPcmRlcjMyTGl0dGxlIHwga0NHSW1hZ2VBbHBoYVByZW11bHRpcGxpZWRGaXJzdCk7CisK KyAgICByZXR1cm4gQml0bWFwQ29udGV4dDo6Y3JlYXRlQnlBZG9wdGluZ0JpdG1hcEFuZENvbnRl eHQoYml0bWFwLCBjb250ZXh0KTsKIH0KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMv cnVuLXdlYmtpdC10ZXN0cyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvcnVuLXdlYmtpdC10ZXN0cwpp bmRleCAyYmIxMDk2Li5jMDEyNzI0IDEwMDc1NQotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3J1 bi13ZWJraXQtdGVzdHMKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy9ydW4td2Via2l0LXRlc3Rz CkBAIC0xMTIsOCArMTEyLDYgQEAgbXkgJGxhdW5jaFNhZmFyaSA9IDE7CiBteSAkcGxhdGZvcm07 CiBteSAkcGl4ZWxUZXN0cyA9ICcnOwogbXkgJHF1aWV0ID0gJyc7Ci1teSAkcmVwYWludFN3ZWVw SG9yaXpvbnRhbGx5ID0gJyc7Ci1teSAkcmVwYWludFRlc3RzID0gJyc7CiBteSAkcmVwb3J0MTBT bG93ZXN0ID0gMDsKIG15ICRyZXNldFJlc3VsdHMgPSAwOwogbXkgJHNob3VsZENoZWNrTGVha3Mg PSAwOwpAQCAtMTIzLDcgKzEyMSw3IEBAIG15ICR0ZXN0SFRUUCA9IDE7CiBteSAkdGVzdE1lZGlh ID0gMTsKIG15ICR0ZXN0UmVzdWx0c0RpcmVjdG9yeSA9ICIvdG1wL2xheW91dC10ZXN0LXJlc3Vs dHMiOwogbXkgJHRocmVhZGVkID0gMDsKLW15ICR0aHJlc2hvbGQgPSAwOworbXkgJHRvbGVyYW5j ZSA9IDA7CiBteSAkdHJlYXRTa2lwcGVkID0gImRlZmF1bHQiOwogbXkgJHZlcmJvc2UgPSAwOwog bXkgJHVzZVZhbGdyaW5kID0gMDsKQEAgLTE4MCwxNyArMTc4LDE2IEBAIFVzYWdlOiAkcHJvZ3Jh bU5hbWUgW29wdGlvbnNdIFt0ZXN0ZGlyfHRlc3RwYXRoIC4uLl0KICAgLWN8LS1jb25maWd1cmF0 aW9uIGNvbmZpZyAgICAgICBTZXQgRHVtcFJlbmRlclRyZWUgYnVpbGQgY29uZmlndXJhdGlvbgog ICAtZ3wtLWd1YXJkLW1hbGxvYyAgICAgICAgICAgICAgIEVuYWJsZSBtYWxsb2MgZ3VhcmQKICAg LS1oZWxwICAgICAgICAgICAgICAgICAgICAgICAgICBTaG93IHRoaXMgaGVscCBtZXNzYWdlCi0g IC1ofC0taG9yaXpvbnRhbC1zd2VlcCAgICAgICAgICAgQ2hhbmdlIHJlcGFpbnQgdG8gc3dlZXAg aG9yaXpvbnRhbGx5IGluc3RlYWQgb2YgdmVydGljYWxseSAoaW1wbGllcyAtLXJlcGFpbnQtdGVz dHMpCiAgIC0tW25vLV1odHRwICAgICAgICAgICAgICAgICAgICAgUnVuIChvciBkbyBub3QgcnVu KSBodHRwIHRlc3RzIChkZWZhdWx0OiAkaHR0cERlZmF1bHQpCiAgIC1pfC0taWdub3JlLXRlc3Rz ICAgICAgICAgICAgICAgQ29tbWEtc2VwYXJhdGVkIGxpc3Qgb2YgZGlyZWN0b3JpZXMgb3IgdGVz dHMgdG8gaWdub3JlCiAgIC0tW25vLV1sYXVuY2gtc2FmYXJpICAgICAgICAgICAgTGF1bmNoIChv ciBkbyBub3QgbGF1bmNoKSBTYWZhcmkgdG8gZGlzcGxheSB0ZXN0IHJlc3VsdHMgKGRlZmF1bHQ6 ICRsYXVuY2hTYWZhcmlEZWZhdWx0KQogICAtbHwtLWxlYWtzICAgICAgICAgICAgICAgICAgICAg IEVuYWJsZSBsZWFrcyBjaGVja2luZwogICAtLVtuby1dbmV3LXRlc3QtcmVzdWx0cyAgICAgICAg IEdlbmVyYXRlIHJlc3VsdHMgZm9yIG5ldyB0ZXN0cwogICAtcHwtLXBpeGVsLXRlc3RzICAgICAg ICAgICAgICAgIEVuYWJsZSBwaXhlbCB0ZXN0cworICAtLXRvbGVyYW5jZSB0ICAgICAgICAgICAg ICAgICAgIElnbm9yZSBpbWFnZSBkaWZmZXJlbmNlcyBsZXNzIHRoYW4gdGhpcyBwZXJjZW50YWdl IChpbXBsaWVzIC0tcGl4ZWwtdGVzdHMpCiAgIC0tcGxhdGZvcm0gICAgICAgICAgICAgICAgICAg ICAgT3ZlcnJpZGUgdGhlIGRldGVjdGVkIHBsYXRmb3JtIHRvIHVzZSBmb3IgdGVzdHMgYW5kIHJl c3VsdHMgKGRlZmF1bHQ6ICRwbGF0Zm9ybSkKICAgLS1wb3J0ICAgICAgICAgICAgICAgICAgICAg ICAgICBXZWIgc2VydmVyIHBvcnQgdG8gdXNlIHdpdGggaHR0cCB0ZXN0cwogICAtcXwtLXF1aWV0 ICAgICAgICAgICAgICAgICAgICAgIExlc3MgdmVyYm9zZSBvdXRwdXQKLSAgLXJ8LS1yZXBhaW50 LXRlc3RzICAgICAgICAgICAgICBSdW4gcmVwYWludCB0ZXN0cyAoaW1wbGllcyAtLXBpeGVsLXRl c3RzKQogICAtLXJlc2V0LXJlc3VsdHMgICAgICAgICAgICAgICAgIFJlc2V0IEFMTCByZXN1bHRz IChpbmNsdWRpbmcgcGl4ZWwgdGVzdHMgaWYgLS1waXhlbC10ZXN0cyBpcyBzZXQpCiAgIC1vfC0t cmVzdWx0cy1kaXJlY3RvcnkgICAgICAgICAgT3V0cHV0IHJlc3VsdHMgZGlyZWN0b3J5IChkZWZh dWx0OiAkdGVzdFJlc3VsdHNEaXJlY3RvcnkpCiAgIC0tcmFuZG9tICAgICAgICAgICAgICAgICAg ICAgICAgUnVuIHRoZSB0ZXN0cyBpbiBhIHJhbmRvbSBvcmRlcgpAQCAtMjA2LDcgKzIwMyw2IEBA IFVzYWdlOiAkcHJvZ3JhbU5hbWUgW29wdGlvbnNdIFt0ZXN0ZGlyfHRlc3RwYXRoIC4uLl0KICAg LS1zdHJpY3QgICAgICAgICAgICAgICAgICAgICAgICBEbyBhIGNvbXBhcmlzb24gd2l0aCB0aGUg b3V0cHV0IG9uIE1hYyAoUXQgb25seSkKICAgLS1bbm8tXXN0cmlwLWVkaXRpbmctY2FsbGJhY2tz ICBSZW1vdmUgZWRpdGluZyBjYWxsYmFja3MgZnJvbSBleHBlY3RlZCByZXN1bHRzCiAgIC10fC0t dGhyZWFkZWQgICAgICAgICAgICAgICAgICAgUnVuIGEgY29uY3VycmVudCBKYXZhU2NyaXB0IHRo ZWFkIHdpdGggZWFjaCB0ZXN0Ci0gIC0tdGhyZXNob2xkIHQgICAgICAgICAgICAgICAgICAgSWdu b3JlIHBpeGVsIHZhbHVlIGRldmlhdGlvbnMgbGVzcyB0aGFuIG9yIGVxdWFsIHRvIHQKICAgLS12 YWxncmluZCAgICAgICAgICAgICAgICAgICAgICBSdW4gRHVtcFJlbmRlclRyZWUgaW5zaWRlIHZh bGdyaW5kIChRdC9MaW51eCBvbmx5KQogICAtdnwtLXZlcmJvc2UgICAgICAgICAgICAgICAgICAg IE1vcmUgdmVyYm9zZSBvdXRwdXQgKG92ZXJyaWRlcyAtLXF1aWV0KQogICAtbXwtLW1lcmdlLWxl YWstZGVwdGggYXJnICAgICAgIE1lcmdlcyBsZWFrIGNhbGxTdGFja3MgYW5kIHByaW50cyB0aGUg bnVtYmVyIG9mIHVuaXF1ZSBsZWFrcyBiZW5lYXRoIGEgY2FsbHN0YWNrIGRlcHRoIG9mIGFyZy4g IERlZmF1bHRzIHRvIDUuCkBAIC0yMjEsNyArMjE3LDYgQEAgbXkgJGdldE9wdGlvbnNSZXN1bHQg PSBHZXRPcHRpb25zKAogICAgICdjfGNvbmZpZ3VyYXRpb249cycgPT4gXCRjb25maWd1cmF0aW9u LAogICAgICdndWFyZC1tYWxsb2N8ZycgPT4gXCRndWFyZE1hbGxvYywKICAgICAnaGVscCcgPT4g XCRzaG93SGVscCwKLSAgICAnaG9yaXpvbnRhbC1zd2VlcHxoJyA9PiBcJHJlcGFpbnRTd2VlcEhv cml6b250YWxseSwKICAgICAnaHR0cCEnID0+IFwkdGVzdEhUVFAsCiAgICAgJ2lnbm9yZS10ZXN0 c3xpPXMnID0+IFwkaWdub3JlVGVzdHMsCiAgICAgJ2xhdW5jaC1zYWZhcmkhJyA9PiBcJGxhdW5j aFNhZmFyaSwKQEAgLTIzMCw3ICsyMjUsNiBAQCBteSAkZ2V0T3B0aW9uc1Jlc3VsdCA9IEdldE9w dGlvbnMoCiAgICAgJ3BsYXRmb3JtPXMnID0+IFwkcGxhdGZvcm0sCiAgICAgJ3BvcnQ9aScgPT4g XCRodHRwZFBvcnQsCiAgICAgJ3F1aWV0fHEnID0+IFwkcXVpZXQsCi0gICAgJ3JlcGFpbnQtdGVz dHN8cicgPT4gXCRyZXBhaW50VGVzdHMsCiAgICAgJ3Jlc2V0LXJlc3VsdHMnID0+IFwkcmVzZXRS ZXN1bHRzLAogICAgICduZXctdGVzdC1yZXN1bHRzIScgPT4gXCRnZW5lcmF0ZU5ld1Jlc3VsdHMs CiAgICAgJ3Jlc3VsdHMtZGlyZWN0b3J5fG89cycgPT4gXCR0ZXN0UmVzdWx0c0RpcmVjdG9yeSwK QEAgLTIzOSw3ICsyMzMsNyBAQCBteSAkZ2V0T3B0aW9uc1Jlc3VsdCA9IEdldE9wdGlvbnMoCiAg ICAgJ3NraXBwZWQ9cycgPT4gXCZ2YWxpZGF0ZVNraXBwZWRBcmcsCiAgICAgJ3Nsb3dlc3QnID0+ IFwkcmVwb3J0MTBTbG93ZXN0LAogICAgICd0aHJlYWRlZHx0JyA9PiBcJHRocmVhZGVkLAotICAg ICd0aHJlc2hvbGQ9aScgPT4gXCR0aHJlc2hvbGQsCisgICAgJ3RvbGVyYW5jZT1mJyA9PiBcJHRv bGVyYW5jZSwKICAgICAndmVyYm9zZXx2JyA9PiBcJHZlcmJvc2UsCiAgICAgJ3ZhbGdyaW5kJyA9 PiBcJHVzZVZhbGdyaW5kLAogICAgICdzYW1wbGUtb24tdGltZW91dCEnID0+IFwkcnVuU2FtcGxl LApAQCAtMjY3LDEwICsyNjEsNyBAQCBzZXRDb25maWd1cmF0aW9uKCRjb25maWd1cmF0aW9uKTsK IAogbXkgJGNvbmZpZ3VyYXRpb25PcHRpb24gPSAiLS0iIC4gbGMoJGNvbmZpZ3VyYXRpb24pOwog Ci0kcmVwYWludFRlc3RzID0gMSBpZiAkcmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5OwotCi0kcGl4 ZWxUZXN0cyA9IDEgaWYgJHJlcGFpbnRUZXN0czsKLSRwaXhlbFRlc3RzID0gMSBpZiAkdGhyZXNo b2xkID4gMDsKKyRwaXhlbFRlc3RzID0gMSBpZiAkdG9sZXJhbmNlID4gMDsKIAogJHRlc3RzUGVy RHVtcFRvb2wgPSAxMDAwIGlmICEkdGVzdHNQZXJEdW1wVG9vbDsKIApAQCAtMjkxLDcgKzI4Miw3 IEBAIHNldFJ1bjY0Qml0KCRydW42NEJpdCk7CiAKIGNoZGlyV2ViS2l0KCk7CiAKLWlmKCFkZWZp bmVkKCRyb290KSl7CitpZiAoIWRlZmluZWQoJHJvb3QpKSB7CiAgICAgIyBQdXNoIHRoZSBwYXJh bWV0ZXJzIHRvIGJ1aWxkLWR1bXByZW5kZXJ0cmVlIGFzIGFuIGFycmF5CiAgICAgbXkgQGFyZ3M7 CiAgICAgcHVzaChAYXJncywgJGNvbmZpZ3VyYXRpb25PcHRpb24pOwpAQCAtNDU0LDE5ICs0NDUs MTUgQEAgbXkgJWR1cmF0aW9uczsKIG15ICRjb3VudCA9IDA7CiBteSAkbGVha3NPdXRwdXRGaWxl TnVtYmVyID0gMTsKIG15ICR0b3RhbExlYWtzID0gMDsKLW15ICRkdW1wQWxsUGl4ZWxzID0gJHBp eGVsVGVzdHMgJiYgJHJlc2V0UmVzdWx0czsKIAogbXkgQHRvb2xBcmdzID0gKCk7Ci1wdXNoIEB0 b29sQXJncywgIi0tZHVtcC1hbGwtcGl4ZWxzIiBpZiAkZHVtcEFsbFBpeGVsczsKIHB1c2ggQHRv b2xBcmdzLCAiLS1waXhlbC10ZXN0cyIgaWYgJHBpeGVsVGVzdHM7Ci1wdXNoIEB0b29sQXJncywg Ii0tcmVwYWludCIgaWYgJHJlcGFpbnRUZXN0czsKLXB1c2ggQHRvb2xBcmdzLCAiLS1ob3Jpem9u dGFsLXN3ZWVwIiBpZiAkcmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5OwogcHVzaCBAdG9vbEFyZ3Ms ICItLXRocmVhZGVkIiBpZiAkdGhyZWFkZWQ7CiBwdXNoIEB0b29sQXJncywgIi0tY29tcGxleC10 ZXh0IiBpZiAkY29tcGxleFRleHQ7CiBwdXNoIEB0b29sQXJncywgIi0iOwogCiBteSBAZGlmZlRv b2xBcmdzID0gKCk7Ci1wdXNoIEBkaWZmVG9vbEFyZ3MsICItLXRocmVzaG9sZCIsICR0aHJlc2hv bGQ7CitwdXNoIEBkaWZmVG9vbEFyZ3MsICItLXRvbGVyYW5jZSIsICR0b2xlcmFuY2U7CiAKICR8 ID0gMTsKIApAQCAtNTUzLDYgKzU0MCwyMCBAQCBmb3IgbXkgJHRlc3QgKEB0ZXN0cykgewogCiAg ICAgbXkgJHN0YXJ0VGltZSA9IHRpbWUgaWYgJHJlcG9ydDEwU2xvd2VzdDsKIAorICAgICMgVHJ5 IHRvIHJlYWQgZXhwZWN0ZWQgaGFzaCBmaWxlIGZvciBwaXhlbCB0ZXN0cworICAgIG15ICRzdWZm aXhFeHBlY3RlZEhhc2ggPSAiIjsKKyAgICBpZiAoJHBpeGVsVGVzdHMgJiYgISRyZXNldFJlc3Vs dHMpIHsKKyAgICAgICAgbXkgJGV4cGVjdGVkUGl4ZWxEaXIgPSBleHBlY3RlZERpcmVjdG9yeUZv clRlc3QoJGJhc2UsIDAsICJwbmciKTsKKyAgICAgICAgaWYgKG9wZW4gRVhQRUNURURIQVNILCAi JGV4cGVjdGVkUGl4ZWxEaXIvJGJhc2UtJGV4cGVjdGVkVGFnLmNoZWNrc3VtIikgeworICAgICAg ICAgICAgbXkgJGV4cGVjdGVkSGFzaCA9IDxFWFBFQ1RFREhBU0g+OworICAgICAgICAgICAgY2hv bXAoJGV4cGVjdGVkSGFzaCk7CisgICAgICAgICAgICBjbG9zZSBFWFBFQ1RFREhBU0g7CisgICAg ICAgICAgICAKKyAgICAgICAgICAgICMgRm9ybWF0IGV4cGVjdGVkIGhhc2ggaW50byBhIHN1ZmZp eCBzdHJpbmcgdGhhdCBpcyBhcHBlbmRlZCB0byB0aGUgcGF0aCAvIFVSTCBwYXNzZWQgdG8gRFJU CisgICAgICAgICAgICAkc3VmZml4RXhwZWN0ZWRIYXNoID0gIickZXhwZWN0ZWRIYXNoIjsKKyAg ICAgICAgfQorICAgIH0KKwogICAgIGlmICgkdGVzdCAhfiAvXmh0dHBcLy8pIHsKICAgICAgICAg bXkgJHRlc3RQYXRoID0gIiR0ZXN0RGlyZWN0b3J5LyR0ZXN0IjsKICAgICAgICAgaWYgKGlzQ3ln d2luKCkpIHsKQEAgLTU2MCwxNyArNTYxLDE3IEBAIGZvciBteSAkdGVzdCAoQHRlc3RzKSB7CiAg ICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAkdGVzdFBhdGggPSBjYW5vbnBhdGgoJHRlc3RQ YXRoKTsKICAgICAgICAgfQotICAgICAgICBwcmludCBPVVQgIiR0ZXN0UGF0aFxuIjsKKyAgICAg ICAgcHJpbnQgT1VUICIkdGVzdFBhdGgkc3VmZml4RXhwZWN0ZWRIYXNoXG4iOwogICAgIH0gZWxz ZSB7CiAgICAgICAgIG9wZW5IVFRQRElmTmVlZGVkKCk7CiAgICAgICAgIGlmICgkdGVzdCAhfiAv Xmh0dHBcL3Rlc3RzXC9sb2NhbFwvLyAmJiAkdGVzdCAhfiAvXmh0dHBcL3Rlc3RzXC9zc2xcLy8g JiYgJHRlc3QgIX4gL15odHRwXC90ZXN0c1wvbWVkaWFcLy8pIHsKICAgICAgICAgICAgIG15ICRw YXRoID0gY2Fub25wYXRoKCR0ZXN0KTsKICAgICAgICAgICAgICRwYXRoID1+IHMvXmh0dHBcL3Rl c3RzXC8vLzsKLSAgICAgICAgICAgIHByaW50IE9VVCAiaHR0cDovLzEyNy4wLjAuMTokaHR0cGRQ b3J0LyRwYXRoXG4iOworICAgICAgICAgICAgcHJpbnQgT1VUICJodHRwOi8vMTI3LjAuMC4xOiRo dHRwZFBvcnQvJHBhdGgkc3VmZml4RXhwZWN0ZWRIYXNoXG4iOwogICAgICAgICB9IGVsc2lmICgk dGVzdCA9fiAvXmh0dHBcL3Rlc3RzXC9zc2xcLy8pIHsKICAgICAgICAgICAgIG15ICRwYXRoID0g Y2Fub25wYXRoKCR0ZXN0KTsKICAgICAgICAgICAgICRwYXRoID1+IHMvXmh0dHBcL3Rlc3RzXC8v LzsKLSAgICAgICAgICAgIHByaW50IE9VVCAiaHR0cHM6Ly8xMjcuMC4wLjE6JGh0dHBkU1NMUG9y dC8kcGF0aFxuIjsKKyAgICAgICAgICAgIHByaW50IE9VVCAiaHR0cHM6Ly8xMjcuMC4wLjE6JGh0 dHBkU1NMUG9ydC8kcGF0aCRzdWZmaXhFeHBlY3RlZEhhc2hcbiI7CiAgICAgICAgIH0gZWxzZSB7 CiAgICAgICAgICAgICBteSAkdGVzdFBhdGggPSAiJHRlc3REaXJlY3RvcnkvJHRlc3QiOwogICAg ICAgICAgICAgaWYgKGlzQ3lnd2luKCkpIHsKQEAgLTU3OCw3ICs1NzksNyBAQCBmb3IgbXkgJHRl c3QgKEB0ZXN0cykgewogICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgICAkdGVz dFBhdGggPSBjYW5vbnBhdGgoJHRlc3RQYXRoKTsKICAgICAgICAgICAgIH0KLSAgICAgICAgICAg IHByaW50IE9VVCAiJHRlc3RQYXRoXG4iOworICAgICAgICAgICAgcHJpbnQgT1VUICIkdGVzdFBh dGgkc3VmZml4RXhwZWN0ZWRIYXNoXG4iOwogICAgICAgICB9CiAgICAgfQogCkBAIC02NDEsNyAr NjQyLDYgQEAgZm9yIG15ICR0ZXN0IChAdGVzdHMpIHsKICAgICBteSAkZGlmZlBlcmNlbnRhZ2Ug PSAiIjsKICAgICBteSAkZGlmZlJlc3VsdCA9ICJwYXNzZWQiOwogCi0gICAgIyBMb29rIGZvciB0 aGUgcGl4ZWwgYmxvY2ssIGFuZCBkbyBhbiBpbWFnZSBkaWZmIGlmIHdlIGZpbmQgb25lCiAgICAg bXkgJGFjdHVhbEhhc2ggPSAiIjsKICAgICBteSAkZXhwZWN0ZWRIYXNoID0gIiI7CiAgICAgbXkg JGFjdHVhbFBOR1NpemUgPSAwOwpAQCAtNjUwLDcgKzY1MCw3IEBAIGZvciBteSAkdGVzdCAoQHRl c3RzKSB7CiAgICAgICAgIGxhc3QgaWYgLyNFT0YvOwogICAgICAgICBpZiAoL0FjdHVhbEhhc2g6 IChbYS1mMC05XXszMn0pLykgewogICAgICAgICAgICAgJGFjdHVhbEhhc2ggPSAkMTsKLSAgICAg ICAgfSBlbHNpZiAoL0Jhc2VsaW5lSGFzaDogKFthLWYwLTldezMyfSkvKSB7CisgICAgICAgIH0g ZWxzaWYgKC9FeHBlY3RlZEhhc2g6IChbYS1mMC05XXszMn0pLykgewogICAgICAgICAgICAgJGV4 cGVjdGVkSGFzaCA9ICQxOwogICAgICAgICB9IGVsc2lmICgvQ29udGVudC1MZW5ndGg6IChcZCsp XHMqLykgewogICAgICAgICAgICAgJGFjdHVhbFBOR1NpemUgPSAkMTsKQEAgLTY1OCw0MiArNjU4 LDU4IEBAIGZvciBteSAkdGVzdCAoQHRlc3RzKSB7CiAgICAgICAgIH0KICAgICB9CiAKLSAgICAj IElmIHdlIGdvdCBzb21lIFBORyBkYXRhLCBkaWZmIHdpdGggZXhwZWN0ZWQKKyAgICBpZiAoJHZl cmJvc2UgJiYgJHBpeGVsVGVzdHMgJiYgISRyZXNldFJlc3VsdHMgJiYgJGFjdHVhbFBOR1NpemUp IHsKKyAgICAgICAgaWYgKCRhY3R1YWxIYXNoIGVxICIiICYmICRleHBlY3RlZEhhc2ggZXEgIiIp IHsKKyAgICAgICAgICAgIHByaW50RmFpbHVyZU1lc3NhZ2VGb3JUZXN0KCR0ZXN0LCAiV0FSTklO RzogYWN0dWFsICYgZXhwZWN0ZWQgcGl4ZWwgaGFzaGVzIGFyZSBtaXNzaW5nISIpOworICAgICAg ICB9IGVsc2lmICgkYWN0dWFsSGFzaCBlcSAiIikgeworICAgICAgICAgICAgcHJpbnRGYWlsdXJl TWVzc2FnZUZvclRlc3QoJHRlc3QsICJXQVJOSU5HOiBhY3R1YWwgcGl4ZWwgaGFzaCBpcyBtaXNz aW5nISIpOworICAgICAgICB9IGVsc2lmICgkZXhwZWN0ZWRIYXNoIGVxICIiKSB7CisgICAgICAg ICAgICBwcmludEZhaWx1cmVNZXNzYWdlRm9yVGVzdCgkdGVzdCwgIldBUk5JTkc6IGV4cGVjdGVk IHBpeGVsIGhhc2ggaXMgbWlzc2luZyEiKTsKKyAgICAgICAgfQorICAgIH0KKwogICAgIGlmICgk YWN0dWFsUE5HU2l6ZSA+IDApIHsKICAgICAgICAgbXkgJGV4cGVjdGVkUGl4ZWxEaXIgPSBleHBl Y3RlZERpcmVjdG9yeUZvclRlc3QoJGJhc2UsICRpc1RleHQsICJwbmciKTsKIAotICAgICAgICBp ZiAoJGV4cGVjdGVkSGFzaCBuZSAkYWN0dWFsSGFzaCAmJiAtZiAiJGV4cGVjdGVkUGl4ZWxEaXIv JGJhc2UtJGV4cGVjdGVkVGFnLnBuZyIpIHsKLSAgICAgICAgICAgIG15ICRleHBlY3RlZFBOR1Np emUgPSAtcyAiJGV4cGVjdGVkUGl4ZWxEaXIvJGJhc2UtJGV4cGVjdGVkVGFnLnBuZyI7Ci0gICAg ICAgICAgICBteSAkZXhwZWN0ZWRQTkcgPSAiIjsKLSAgICAgICAgICAgIG9wZW4gRVhQRUNURURQ TkcsICIkZXhwZWN0ZWRQaXhlbERpci8kYmFzZS0kZXhwZWN0ZWRUYWcucG5nIjsKLSAgICAgICAg ICAgIHJlYWQoRVhQRUNURURQTkcsICRleHBlY3RlZFBORywgJGV4cGVjdGVkUE5HU2l6ZSk7Cisg ICAgICAgIGlmICghJHJlc2V0UmVzdWx0cyAmJiAoJGV4cGVjdGVkSGFzaCBuZSAkYWN0dWFsSGFz aCB8fCAoJGFjdHVhbEhhc2ggZXEgIiIgJiYgJGV4cGVjdGVkSGFzaCBlcSAiIikpKSB7CisgICAg ICAgICAgICBpZiAoLWYgIiRleHBlY3RlZFBpeGVsRGlyLyRiYXNlLSRleHBlY3RlZFRhZy5wbmci KSB7CisgICAgICAgICAgICAgICAgbXkgJGV4cGVjdGVkUE5HU2l6ZSA9IC1zICIkZXhwZWN0ZWRQ aXhlbERpci8kYmFzZS0kZXhwZWN0ZWRUYWcucG5nIjsKKyAgICAgICAgICAgICAgICBteSAkZXhw ZWN0ZWRQTkcgPSAiIjsKKyAgICAgICAgICAgICAgICBvcGVuIEVYUEVDVEVEUE5HLCAiJGV4cGVj dGVkUGl4ZWxEaXIvJGJhc2UtJGV4cGVjdGVkVGFnLnBuZyI7CisgICAgICAgICAgICAgICAgcmVh ZChFWFBFQ1RFRFBORywgJGV4cGVjdGVkUE5HLCAkZXhwZWN0ZWRQTkdTaXplKTsKIAotICAgICAg ICAgICAgcHJpbnQgRElGRk9VVCAiQ29udGVudC1MZW5ndGg6ICRhY3R1YWxQTkdTaXplXG4iOwot ICAgICAgICAgICAgcHJpbnQgRElGRk9VVCAkYWN0dWFsUE5HOworICAgICAgICAgICAgICAgIHBy aW50IERJRkZPVVQgIkNvbnRlbnQtTGVuZ3RoOiAkYWN0dWFsUE5HU2l6ZVxuIjsKKyAgICAgICAg ICAgICAgICBwcmludCBESUZGT1VUICRhY3R1YWxQTkc7CiAKLSAgICAgICAgICAgIHByaW50IERJ RkZPVVQgIkNvbnRlbnQtTGVuZ3RoOiAkZXhwZWN0ZWRQTkdTaXplXG4iOwotICAgICAgICAgICAg cHJpbnQgRElGRk9VVCAkZXhwZWN0ZWRQTkc7CisgICAgICAgICAgICAgICAgcHJpbnQgRElGRk9V VCAiQ29udGVudC1MZW5ndGg6ICRleHBlY3RlZFBOR1NpemVcbiI7CisgICAgICAgICAgICAgICAg cHJpbnQgRElGRk9VVCAkZXhwZWN0ZWRQTkc7CiAKLSAgICAgICAgICAgIHdoaWxlICg8RElGRklO PikgewotICAgICAgICAgICAgICAgIGxhc3QgaWYgL15lcnJvci8gfHwgL15kaWZmOi87Ci0gICAg ICAgICAgICAgICAgaWYgKC9Db250ZW50LUxlbmd0aDogKFxkKylccyovKSB7Ci0gICAgICAgICAg ICAgICAgICAgIHJlYWQoRElGRklOLCAkZGlmZlBORywgJDEpOworICAgICAgICAgICAgICAgIHdo aWxlICg8RElGRklOPikgeworICAgICAgICAgICAgICAgICAgICBsYXN0IGlmIC9eZXJyb3IvIHx8 IC9eZGlmZjovOworICAgICAgICAgICAgICAgICAgICBpZiAoL0NvbnRlbnQtTGVuZ3RoOiAoXGQr KVxzKi8pIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIHJlYWQoRElGRklOLCAkZGlmZlBORywg JDEpOworICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgfQotICAgICAgICAg ICAgfQogCi0gICAgICAgICAgICBpZiAoL15kaWZmOiAoLispJSAocGFzc2VkfGZhaWxlZCkvKSB7 Ci0gICAgICAgICAgICAgICAgJGRpZmZQZXJjZW50YWdlID0gJDE7Ci0gICAgICAgICAgICAgICAg JGltYWdlRGlmZmVyZW5jZXN7JGJhc2V9ID0gJGRpZmZQZXJjZW50YWdlOwotICAgICAgICAgICAg ICAgICRkaWZmUmVzdWx0ID0gJDI7CisgICAgICAgICAgICAgICAgaWYgKC9eZGlmZjogKC4rKSUg KHBhc3NlZHxmYWlsZWQpLykgeworICAgICAgICAgICAgICAgICAgICAkZGlmZlBlcmNlbnRhZ2Ug PSAkMTsKKyAgICAgICAgICAgICAgICAgICAgJGltYWdlRGlmZmVyZW5jZXN7JGJhc2V9ID0gJGRp ZmZQZXJjZW50YWdlOworICAgICAgICAgICAgICAgICAgICAkZGlmZlJlc3VsdCA9ICQyOworICAg ICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAKKyAgICAgICAgICAgICAgICBpZiAoJGRp ZmZQZXJjZW50YWdlID09IDApIHsKKyAgICAgICAgICAgICAgICAgICAgcHJpbnRGYWlsdXJlTWVz c2FnZUZvclRlc3QoJHRlc3QsICJwaXhlbCBoYXNoIGZhaWxlZCAoYnV0IHBpeGVsIHRlc3Qgc3Rp bGwgcGFzc2VzKSIpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0gZWxzaWYgKCR2 ZXJib3NlKSB7CisgICAgICAgICAgICAgICAgcHJpbnRGYWlsdXJlTWVzc2FnZUZvclRlc3QoJHRl c3QsICJXQVJOSU5HOiBleHBlY3RlZCBpbWFnZSBpcyBtaXNzaW5nISIpOwogICAgICAgICAgICAg fQogICAgICAgICB9CiAKLSAgICAgICAgaWYgKCRhY3R1YWxQTkdTaXplICYmICgkcmVzZXRSZXN1 bHRzIHx8ICEtZiAiJGV4cGVjdGVkUGl4ZWxEaXIvJGJhc2UtJGV4cGVjdGVkVGFnLnBuZyIpKSB7 CisgICAgICAgIGlmICgkcmVzZXRSZXN1bHRzIHx8ICEtZiAiJGV4cGVjdGVkUGl4ZWxEaXIvJGJh c2UtJGV4cGVjdGVkVGFnLnBuZyIpIHsKICAgICAgICAgICAgIG1rcGF0aCBjYXRmaWxlKCRleHBl Y3RlZFBpeGVsRGlyLCBkaXJuYW1lKCRiYXNlKSkgaWYgJHRlc3REaXJlY3RvcnkgbmUgJGV4cGVj dGVkUGl4ZWxEaXI7CiAgICAgICAgICAgICB3cml0ZVRvRmlsZSgiJGV4cGVjdGVkUGl4ZWxEaXIv JGJhc2UtJGV4cGVjdGVkVGFnLnBuZyIsICRhY3R1YWxQTkcpOwogICAgICAgICB9CiAKLSAgICAg ICAgIyB1cGRhdGUgdGhlIGV4cGVjdGVkIGhhc2ggaWYgdGhlIGltYWdlIGRpZmYgc2FpZCB0aGF0 IHRoZXJlIHdhcyBubyBkaWZmZXJlbmNlCiAgICAgICAgIGlmICgkYWN0dWFsSGFzaCBuZSAiIiAm JiAoJHJlc2V0UmVzdWx0cyB8fCAhLWYgIiRleHBlY3RlZFBpeGVsRGlyLyRiYXNlLSRleHBlY3Rl ZFRhZy5jaGVja3N1bSIpKSB7CiAgICAgICAgICAgICB3cml0ZVRvRmlsZSgiJGV4cGVjdGVkUGl4 ZWxEaXIvJGJhc2UtJGV4cGVjdGVkVGFnLmNoZWNrc3VtIiwgJGFjdHVhbEhhc2gpOwogICAgICAg ICB9CkBAIC03NDEsNyArNzU3LDcgQEAgZm9yIG15ICR0ZXN0IChAdGVzdHMpIHsKICAgICAgICAg ICBzeXN0ZW0gImRpZmYgLXUgXCIvdG1wL2V4cGVjdGVkLnR4dFwiIFwiL3RtcC9hY3R1YWwudHh0 XCIgPiBcIi90bXAvc2ltcGxpZmllZC5kaWZmXCIiOwogCiAgICAgICAgICAgJGRpZmZSZXN1bHQg PSAiZmFpbGVkIjsKLSAgICAgICAgICBpZigkdmVyYm9zZSkgeworICAgICAgICAgIGlmICgkdmVy Ym9zZSkgewogICAgICAgICAgICAgcHJpbnQgIlxuIjsKICAgICAgICAgICAgIHN5c3RlbSAiY2F0 IC90bXAvc2ltcGxpZmllZC5kaWZmIjsKICAgICAgICAgICAgIHByaW50ICJmYWlsZWQhISEhISI7 Cg== 24689 2008-10-27 11:58:25 -0700 2008-10-27 17:57:20 -0700 Final patch Final-Patch.txt text/plain 80701 pol ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCAxOGIwY2VkLi40NmUzNTJhIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsODggQEAKKzIwMDgtMTAt MjcgIFBpZXJyZS1PbGl2aWVyIExhdG91ciAgPHBvbEBhcHBsZS5jb20+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUHJpbWFyeSBjaGFuZ2VzIGluIER1 bXBSZW5kZXJUcmVlOgorICAgICAgICAtIEVuc3VyZSBmb250IHNtb290aGluZyBpcyBkaXNhYmxl ZCAodGhpcyBpcyBhbHNvIGNhbGxlZCBMQ0QgYW50aS1hbGlhc2luZyBhbmQKKyAgICAgICAgaXMg ZGlmZmVyZW50IGZyb20gcmVndWxhciBmb250IENHIGFudGktYWxpYXNpbmcpIGFzIGZvbnQtc21v b3RoaW5nIHNldHRpbmdzCisgICAgICAgIGRlcGVuZHMgb24gdGhlIGRpc3BsYXkgYW5kIGNhbiBh bHNvIGJlIGNoYW5nZWQgYnkgdGhlIHVzZXIKKyAgICAgICAgLSBVc2UgYSBuZXcgY2xlYXJlZCBi dWZmZXIgZm9yIGVhY2ggdGVzdCBpbnN0ZWFkIG9mIHRoZSByZXVzaW5nIHNhbWUgb25lIHRvCisg ICAgICAgIGF2b2lkIHBvdGVudGlhbCByZXN1bHQgY29ycnVwdGlvbiBhY3Jvc3MgdGVzdHMKKyAg ICAgICAgLSBDYW4gbm93IHJlY2VpdmUgdGhlIGV4cGVjdGVkIHBpeGVsIGhhc2ggYXMgYSBzdWZm aXggdG8gdGhlIHRlc3QgcGF0aCBvcgorICAgICAgICB1cmwgYXMgInBhdGgnaGFzaCIKKyAgICAg ICAgLSBNYWtlIHN1cmUgaGFzaCBpcyBjb21wdXRlZCBpbiBhIGVuZGlhbi1pbmRlcGVuZGVudCB3 YXkKKyAgICAgICAgLSBJbXByb3ZlIHRoZSBjb2RlIHRoYXQgc2V0cy9yZXN0b3JlcyB0aGUgc2Ny ZWVuIGNvbG9yIHByb2ZpbGUKKyAgICAgICAgLSBNYWtlIHRoZSBjb2RlIG1vcmUgY3Jvc3MtcGxh dGZvcm15IHdpdGggc3RkOjpzdHJpbmcgZ29vZG5lc3MKKyAgICAgICAgLSBBZGRlZCBhbiAib24t c2NyZWVuIiBtb2RlIHdoZXJlIHRoZSBzbmFwc2hvdCB3aWxsIHRha2UgaW50byBhY2NvdW50IHN1 cmZhY2VzCisgICAgICAgIG9uIHRoZSB3aW5kb3cgKGxpa2UgT3BlbkdMIGNvbnRlbnQpOiB0aGlz IHVzZXMgdGhlIG5ldyBDRyBBUElzIG9uIDEwLjUgb3IKKyAgICAgICAgcmVhZGluZyBmcm9tIHRo ZSBkaXNwbGF5IGZyYW1lYnVmZmVyIG9uIDEwLjQuIFRoaXMgbW9kZSBpcyBub3QgYWN0aXZlIGJ5 CisgICAgICAgIGRlZmF1bHQgZm9yIHBlcmZvcm1hbmNlIHJlYXNvbiwgYnV0IG11c3QgYmUgZXhw bGljaXRseSBhY3RpdmF0ZWQgZnJvbSB0aGUgdGVzdAorICAgICAgICBmaWxlIHVzaW5nIHRoZSBu ZXcgInRlc3RPbnNjcmVlbigpIiBKUyBBUEkuCisKKyAgICAgICAgUHJpbWFyeSBjaGFuZ2VzIGlu IEltYWdlRGlmZjoKKyAgICAgICAgLSBQcm92aWRlIGEgbmV3IGNvbXBhcmlzb24gYWxnb3JpdGht IHRoYXQgaXMgbW9yZSB0b2xlcmFudCB0byAiYWNjZXB0YWJsZSIKKyAgICAgICAgZmFpbHVyZXMg KGkuZS4gdmVyeSBzbWFsbCBkaWZmZXJlbmNlcyBpbiBmb250IHJlbmRlcmluZywgd2hpY2ggLS10 aHJlc2hvbGQgaXMKKyAgICAgICAgbm90IHJlYWxseSBnb29kIGF0IGhhbmRsaW5nKQorICAgICAg ICAtIEdlbmVyYXRlIG5vcm1hbGl6ZWQgaW50ZW5zaXR5LW9ubHkgZGlmZiBpbWFnZXMKKworICAg ICAgICBQcmltYXJ5IGNoYW5nZXMgaW4gcnVuLXdlYmtpdC10ZXN0czoKKyAgICAgICAgLSBUYWtl IGFkdmFudGFnZSBvZiBoYXNoZXMgZm9yIHBpeGVsIHRlc3RzIHdoaWNoIG1ha2VzIHRoZW0gbXVj aCBmYXN0ZXIgYnkKKyAgICAgICAgbWluaW1pemluZyBpbWFnZSBjb21wYXJpc29ucworICAgICAg ICAtIFJlbW92ZWQgcmVwYWludCBvcHRpb25zIGFzIHRoZXNlIHNob3VsZCBiZSBzZXQgZnJvbSB3 aXRoaW4gdGVzdCBmaWxlcyB1c2luZworICAgICAgICBKUyBBUEkKKyAgICAgICAgLSBSZXBsYWNl ZCAidGhyZXNob2xkIiBvcHRpb24gaW4gIGJ5ICJ0b2xlcmFuY2UiIGV4cHJlc3NlZCBpbiBwZXJj ZW50cworICAgICAgICAtIEFkZGVkIG1vcmUgbG9nZ2luZyB3aGVuIGluICJ2ZXJib3NlIiBtb2Rl CisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMzIy CisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9EdW1wUmVuZGVyVHJlZS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0ZvcndhcmRpbmdIZWFkZXJz L3d0Zi9QYXNzUmVmUHRyLmg6IEFkZGVkLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0Zvcndh cmRpbmdIZWFkZXJzL3d0Zi9SZWZQdHIuaDogQWRkZWQuCisgICAgICAgICogRHVtcFJlbmRlclRy ZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xs ZXI6OkxheW91dFRlc3RDb250cm9sbGVyKToKKyAgICAgICAgKHRlc3RPbnNjcmVlbkNhbGxiYWNr KToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMpOgorICAg ICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmg6CisgICAgICAgIChM YXlvdXRUZXN0Q29udHJvbGxlcjo6dGVzdE9uc2NyZWVuKToKKyAgICAgICAgKExheW91dFRlc3RD b250cm9sbGVyOjpzZXRUZXN0T25zY3JlZW4pOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xs ZXI6OnRlc3RQYXRoT3JVUkwpOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OmV4cGVj dGVkUGl4ZWxIYXNoKToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9QaXhlbER1bXBTdXBwb3J0 Lmg6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2cvSW1hZ2VEaWZmQ0cuY3BwOgorICAgICAg ICAoc3RydG9mKToKKyAgICAgICAgKHJlbGVhc2VNYWxsb2NCdWZmZXIpOgorICAgICAgICAoY3Jl YXRlRGlmZmVyZW5jZUltYWdlKToKKyAgICAgICAgKGltYWdlSGFzQWxwaGEpOgorICAgICAgICAo bWFpbik6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1wU3VwcG9ydENHLmNw cDoKKyAgICAgICAgKGNvbXB1dGVNRDVIYXNoU3RyaW5nRm9yQml0bWFwQ29udGV4dCk6CisgICAg ICAgIChkdW1wV2ViVmlld0FzUGl4ZWxzQW5kQ29tcGFyZVdpdGhFeHBlY3RlZCk6CisgICAgICAg ICogRHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1wU3VwcG9ydENHLmg6CisgICAgICAgIChCaXRt YXBDb250ZXh0OjpjcmVhdGVCeUFkb3B0aW5nQml0bWFwQW5kQ29udGV4dCk6CisgICAgICAgIChC aXRtYXBDb250ZXh0Ojp+Qml0bWFwQ29udGV4dCk6CisgICAgICAgIChCaXRtYXBDb250ZXh0Ojpj Z0NvbnRleHQpOgorICAgICAgICAoQml0bWFwQ29udGV4dDo6Qml0bWFwQ29udGV4dCk6CisgICAg ICAgICogRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tOgorICAgICAgICAoc2hv dWxkSWdub3JlV2ViQ29yZU5vZGVMZWFrcyk6CisgICAgICAgIChzZXREZWZhdWx0c1RvQ29uc2lz dGVudFZhbHVlc0ZvclRlc3RpbmcpOgorICAgICAgICAoY3Jhc2hIYW5kbGVyKToKKyAgICAgICAg KGluaXRpYWxpemVHbG9iYWxzRnJvbUNvbW1hbmRMaW5lT3B0aW9ucyk6CisgICAgICAgIChwcmVw YXJlQ29uc2lzdGVudFRlc3RpbmdFbnZpcm9ubWVudCk6CisgICAgICAgIChkdW1wUmVuZGVyVHJl ZSk6CisgICAgICAgIChzaXplV2ViVmlld0ZvckN1cnJlbnRUZXN0KToKKyAgICAgICAgKGR1bXAp OgorICAgICAgICAocnVuVGVzdCk6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFjL1BpeGVs RHVtcFN1cHBvcnRNYWMubW06CisgICAgICAgIChyZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2Zp bGUpOgorICAgICAgICAoc2V0dXBNYWluRGlzcGxheUNvbG9yUHJvZmlsZSk6CisgICAgICAgIChj cmVhdGVCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVl L3dpbi9EdW1wUmVuZGVyVHJlZS5jcHA6CisgICAgICAgIChkdW1wKToKKyAgICAgICAgKHJ1blRl c3QpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3dpbi9QaXhlbER1bXBTdXBwb3J0V2luLmNw cDoKKyAgICAgICAgKGdldEJpdG1hcENvbnRleHRGcm9tV2ViVmlldyk6CisgICAgICAgICogU2Ny aXB0cy9ydW4td2Via2l0LXRlc3RzOgorCiAyMDA4LTEwLTI0ICBBbmRlcnMgQ2FybHNzb24gIDxh bmRlcnNjYUBhcHBsZS5jb20+CiAKICAgICAgICAgVHJ5IGZpeGluZyB0aGUgNjQtYml0IGJ1aWxk LgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvRHVtcFJlbmRlclRyZWUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0R1 bXBSZW5kZXJUcmVlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggMzQ4MDY5Yy4uYmZj NzUwMCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvRHVtcFJlbmRlclRy ZWUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9EdW1wUmVuZGVyVHJlZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0zMyw2ICsz Myw3IEBACiAJCTFBQzZDODQ5MEQwNzYzODYwMENEMzE2MSAvKiBtYWluLmNwcCBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDFBQzZDNzdGMEQwNzU4OUIwMENE MzE2MSAvKiBtYWluLmNwcCAqLzsgfTsKIAkJMUFDNkM4NEEwRDA3NjM4NjAwQ0QzMTYxIC8qIFBs dWdpbk9iamVjdC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSAxQUM2Qzc4MDBEMDc1ODlCMDBDRDMxNjEgLyogUGx1Z2luT2JqZWN0LmNwcCAqLzsgfTsK IAkJMUFDNkM4NEIwRDA3NjM4NjAwQ0QzMTYxIC8qIFRlc3RPYmplY3QuY3BwIGluIFNvdXJjZXMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMUFDNkM3ODEwRDA3NTg5QjAwQ0Qz MTYxIC8qIFRlc3RPYmplY3QuY3BwICovOyB9OworCQkyM0JDQjg5MDBFQTU3NjIzMDAzQzYyODkg LyogT3BlbkdMLmZyYW1ld29yayBpbiBGcmFtZXdvcmtzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDIzQkNCODhGMEVBNTc2MjMwMDNDNjI4OSAvKiBPcGVuR0wuZnJhbWV3b3Jr ICovOyB9OwogCQk5MzQwOTk0QzA4NTQwQ0FFMDA3RjNCQzggLyogRHVtcFJlbmRlclRyZWVQcmVm aXguaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDMyQTcw QUFCMDM3MDVFMUYwMEM5MTc4MyAvKiBEdW1wUmVuZGVyVHJlZVByZWZpeC5oICovOyB9OwogCQk5 MzQwOTk1MTA4NTQwQ0FFMDA3RjNCQzggLyogV2ViS2l0LmZyYW1ld29yayBpbiBGcmFtZXdvcmtz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzMzU0MzVGMDNENzU1MDIwMDg2 MzVDRSAvKiBXZWJLaXQuZnJhbWV3b3JrICovOyB9OwogCQlBODE3MDkwMDA4QjE2M0VGMDBDQ0I5 RkIgLyogQ29jb2EuZnJhbWV3b3JrIGluIEZyYW1ld29ya3MgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gQTg0RjYwODkwOEIxMzZEQTAwRTk3NDVGIC8qIENvY29hLmZyYW1ld29y ayAqLzsgfTsKQEAgLTEzMSw2ICsxMzIsNyBAQAogCQkxQUM2Qzc3RjBEMDc1ODlCMDBDRDMxNjEg LyogbWFpbi5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBtYWluLmNw cDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMUFDNkM3ODAwRDA3NTg5QjAwQ0QzMTYx IC8qIFBsdWdpbk9iamVjdC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGgg PSBQbHVnaW5PYmplY3QuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkxQUM2Qzc4 MTBEMDc1ODlCMDBDRDMxNjEgLyogVGVzdE9iamVjdC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmNwcC5jcHA7IHBhdGggPSBUZXN0T2JqZWN0LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKKwkJMjNCQ0I4OEYwRUE1NzYyMzAwM0M2Mjg5IC8qIE9wZW5HTC5mcmFtZXdvcmsgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSB3cmFwcGVyLmZyYW1l d29yazsgbmFtZSA9IE9wZW5HTC5mcmFtZXdvcms7IHBhdGggPSAvU3lzdGVtL0xpYnJhcnkvRnJh bWV3b3Jrcy9PcGVuR0wuZnJhbWV3b3JrOyBzb3VyY2VUcmVlID0gIjxhYnNvbHV0ZT4iOyB9Owog CQkzMkE3MEFBQjAzNzA1RTFGMDBDOTE3ODMgLyogRHVtcFJlbmRlclRyZWVQcmVmaXguaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRHVtcFJlbmRlclRyZWVQcmVmaXguaDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMzc1RjA5NzEwREFDM0NCNjAwQzhCNEU1IC8qIFdl YktpdFdlaWdodFdhdGNoZXIxMDAudHRmICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxh c3RLbm93bkZpbGVUeXBlID0gZmlsZTsgbmFtZSA9IFdlYktpdFdlaWdodFdhdGNoZXIxMDAudHRm OyBwYXRoID0gZm9udHMvV2ViS2l0V2VpZ2h0V2F0Y2hlcjEwMC50dGY7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCTM3NUYwOTcyMERBQzNDQjYwMEM4QjRFNSAvKiBXZWJLaXRXZWlnaHRX YXRjaGVyMjAwLnR0ZiAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxl VHlwZSA9IGZpbGU7IG5hbWUgPSBXZWJLaXRXZWlnaHRXYXRjaGVyMjAwLnR0ZjsgcGF0aCA9IGZv bnRzL1dlYktpdFdlaWdodFdhdGNoZXIyMDAudHRmOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwpAQCAtMjM0LDYgKzIzNiw3IEBACiAJCQkJQTg0RjYwOEEwOEIxMzZEQTAwRTk3NDVGIC8qIENv Y29hLmZyYW1ld29yayBpbiBGcmFtZXdvcmtzICovLAogCQkJCUE4MTcwOTA0MDhCMTY0RDMwMEND QjlGQiAvKiBKYXZhU2NyaXB0Q29yZS5mcmFtZXdvcmsgaW4gRnJhbWV3b3JrcyAqLywKIAkJCQk5 MzQwOTk1MTA4NTQwQ0FFMDA3RjNCQzggLyogV2ViS2l0LmZyYW1ld29yayBpbiBGcmFtZXdvcmtz ICovLAorCQkJCTIzQkNCODkwMEVBNTc2MjMwMDNDNjI4OSAvKiBPcGVuR0wuZnJhbWV3b3JrIGlu IEZyYW1ld29ya3MgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vz c2luZyA9IDA7CiAJCX07CkBAIC0zNzUsNiArMzc4LDcgQEAKIAkJCQlBODE3MDkwMzA4QjE2NEQz MDBDQ0I5RkIgLyogSmF2YVNjcmlwdENvcmUuZnJhbWV3b3JrICovLAogCQkJCUI1QTc1MkExMDhB RjVEMUYwMDEzOEU0NSAvKiBRdWFydHpDb3JlLmZyYW1ld29yayAqLywKIAkJCQk5MzM1NDM1RjAz RDc1NTAyMDA4NjM1Q0UgLyogV2ViS2l0LmZyYW1ld29yayAqLywKKwkJCQkyM0JDQjg4RjBFQTU3 NjIzMDAzQzYyODkgLyogT3BlbkdMLmZyYW1ld29yayAqLywKIAkJCSk7CiAJCQluYW1lID0gRnJh bWV3b3JrczsKIAkJCXNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7CmRpZmYgLS1naXQgYS9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUGFzc1JlZlB0ci5oIGIv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1Bhc3NSZWZQ dHIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hYWZkMWEyCi0tLSAvZGV2 L251bGwKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvRm9yd2FyZGluZ0hlYWRlcnMv d3RmL1Bhc3NSZWZQdHIuaApAQCAtMCwwICsxIEBACisjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUv UGFzc1JlZlB0ci5oPgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvRm9y d2FyZGluZ0hlYWRlcnMvd3RmL1JlZlB0ci5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv Rm9yd2FyZGluZ0hlYWRlcnMvd3RmL1JlZlB0ci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAuLjBmZjYyMTMKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUmVmUHRyLmgKQEAgLTAsMCArMSBAQAorI2lu Y2x1ZGUgPEphdmFTY3JpcHRDb3JlL1JlZlB0ci5oPgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwIGIvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCmluZGV4IDZjNmEyNzMuLmFhNzE3 ZjQgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250 cm9sbGVyLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29u dHJvbGxlci5jcHAKQEAgLTM0LDcgKzM0LDcgQEAKICNpbmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5o PgogI2luY2x1ZGUgPHd0Zi9NYXRoRXh0cmFzLmg+CiAKLUxheW91dFRlc3RDb250cm9sbGVyOjpM YXlvdXRUZXN0Q29udHJvbGxlcihib29sIHRlc3RSZXBhaW50RGVmYXVsdCwgYm9vbCB0ZXN0UmVw YWludFN3ZWVwSG9yaXpvbnRhbGx5RGVmYXVsdCkKK0xheW91dFRlc3RDb250cm9sbGVyOjpMYXlv dXRUZXN0Q29udHJvbGxlcihjb25zdCBzdGQ6OnN0cmluZyYgdGVzdFBhdGhPclVSTCwgY29uc3Qg c3RkOjpzdHJpbmcmIGV4cGVjdGVkUGl4ZWxIYXNoKQogICAgIDogbV9kdW1wQXNUZXh0KGZhbHNl KQogICAgICwgbV9kdW1wQXNQREYoZmFsc2UpCiAgICAgLCBtX2R1bXBCYWNrRm9yd2FyZExpc3Qo ZmFsc2UpCkBAIC01NCwxMSArNTQsMTQgQEAgTGF5b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRl c3RDb250cm9sbGVyKGJvb2wgdGVzdFJlcGFpbnREZWZhdWx0LCBib29sIHRlc3RSZXAKICAgICAs IG1fY2FuT3BlbldpbmRvd3MoZmFsc2UpCiAgICAgLCBtX2Nsb3NlUmVtYWluaW5nV2luZG93c1do ZW5Db21wbGV0ZSh0cnVlKQogICAgICwgbV9zdG9wUHJvdmlzaW9uYWxGcmFtZUxvYWRzKGZhbHNl KQotICAgICwgbV90ZXN0UmVwYWludCh0ZXN0UmVwYWludERlZmF1bHQpCi0gICAgLCBtX3Rlc3RS ZXBhaW50U3dlZXBIb3Jpem9udGFsbHkodGVzdFJlcGFpbnRTd2VlcEhvcml6b250YWxseURlZmF1 bHQpCisgICAgLCBtX3Rlc3RPbnNjcmVlbihmYWxzZSkKKyAgICAsIG1fdGVzdFJlcGFpbnQoZmFs c2UpCisgICAgLCBtX3Rlc3RSZXBhaW50U3dlZXBIb3Jpem9udGFsbHkoZmFsc2UpCiAgICAgLCBt X3dhaXRUb0R1bXAoZmFsc2UpCiAgICAgLCBtX3dpbmRvd0lzS2V5KHRydWUpCiAgICAgLCBtX2ds b2JhbEZsYWcoZmFsc2UpCisgICAgLCBtX3Rlc3RQYXRoT3JVUkwodGVzdFBhdGhPclVSTCkKKyAg ICAsIG1fZXhwZWN0ZWRQaXhlbEhhc2goZXhwZWN0ZWRQaXhlbEhhc2gpCiB7CiB9CiAKQEAgLTIw NSw2ICsyMDgsMTMgQEAgc3RhdGljIEpTVmFsdWVSZWYgc2V0Q2xvc2VSZW1haW5pbmdXaW5kb3dz V2hlbkNvbXBsZXRlQ2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnQKICAgICByZXR1cm4gSlNWYWx1 ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CiB9CiAKK3N0YXRpYyBKU1ZhbHVlUmVmIHRlc3RPbnNj cmVlbkNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBmdW5jdGlvbiwg SlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFs dWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKK3sKKyAgICBMYXlvdXRU ZXN0Q29udHJvbGxlciogY29udHJvbGxlciA9IHJlaW50ZXJwcmV0X2Nhc3Q8TGF5b3V0VGVzdENv bnRyb2xsZXIqPihKU09iamVjdEdldFByaXZhdGUodGhpc09iamVjdCkpOworICAgIGNvbnRyb2xs ZXItPnNldFRlc3RPbnNjcmVlbih0cnVlKTsKKyAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmlu ZWQoY29udGV4dCk7Cit9CisKIHN0YXRpYyBKU1ZhbHVlUmVmIHRlc3RSZXBhaW50Q2FsbGJhY2so SlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJlZiB0 aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVu dHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQogewogICAgIExheW91dFRlc3RDb250cm9sbGVy KiBjb250cm9sbGVyID0gcmVpbnRlcnByZXRfY2FzdDxMYXlvdXRUZXN0Q29udHJvbGxlcio+KEpT T2JqZWN0R2V0UHJpdmF0ZSh0aGlzT2JqZWN0KSk7CkBAIC03NDUsNiArNzU1LDcgQEAgSlNTdGF0 aWNGdW5jdGlvbiogTGF5b3V0VGVzdENvbnRyb2xsZXI6OnN0YXRpY0Z1bmN0aW9ucygpCiAgICAg ICAgIHsgInNldFVzZXJTdHlsZVNoZWV0RW5hYmxlZCIsIHNldFVzZXJTdHlsZVNoZWV0RW5hYmxl ZENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRy aWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb24i LCBzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRl UmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAi c2V0V2luZG93SXNLZXkiLCBzZXRXaW5kb3dJc0tleUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJp YnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCisgICAgICAg IHsgInRlc3RPbnNjcmVlbiIsIHRlc3RPbnNjcmVlbkNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJp YnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAg IHsgInRlc3RSZXBhaW50IiwgdGVzdFJlcGFpbnRDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1 dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7 ICJ3YWl0VW50aWxEb25lIiwgd2FpdFVudGlsRG9uZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJp YnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAg IHsgIndpbmRvd0NvdW50Iiwgd2luZG93Q291bnRDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1 dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LApkaWZmIC0tZ2l0 IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaCBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKaW5kZXggOGUz M2UwOS4uNjQ5ZGI3YSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5 b3V0VGVzdENvbnRyb2xsZXIuaAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlv dXRUZXN0Q29udHJvbGxlci5oCkBAIC0zMSwxMCArMzEsMTEgQEAKIAogI2luY2x1ZGUgPEphdmFT Y3JpcHRDb3JlL0pTT2JqZWN0UmVmLmg+CiAjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4KKyNp bmNsdWRlIDxzdHJpbmc+CiAKIGNsYXNzIExheW91dFRlc3RDb250cm9sbGVyIDogcHVibGljIFJl ZkNvdW50ZWQ8TGF5b3V0VGVzdENvbnRyb2xsZXI+IHsKIHB1YmxpYzoKLSAgICBMYXlvdXRUZXN0 Q29udHJvbGxlcihib29sIHRlc3RSZXBhaW50RGVmYXVsdCwgYm9vbCB0ZXN0UmVwYWludFN3ZWVw SG9yaXpvbnRhbGx5RGVmYXVsdCk7CisgICAgTGF5b3V0VGVzdENvbnRyb2xsZXIoY29uc3Qgc3Rk OjpzdHJpbmcmIHRlc3RQYXRoT3JVUkwsIGNvbnN0IHN0ZDo6c3RyaW5nJiBleHBlY3RlZFBpeGVs SGFzaCk7CiAgICAgfkxheW91dFRlc3RDb250cm9sbGVyKCk7CiAKICAgICB2b2lkIG1ha2VXaW5k b3dPYmplY3QoSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIHdpbmRvd09iamVjdCwg SlNWYWx1ZVJlZiogZXhjZXB0aW9uKTsKQEAgLTEzMCw2ICsxMzEsOSBAQCBwdWJsaWM6CiAgICAg Ym9vbCBzdG9wUHJvdmlzaW9uYWxGcmFtZUxvYWRzKCkgY29uc3QgeyByZXR1cm4gbV9zdG9wUHJv dmlzaW9uYWxGcmFtZUxvYWRzOyB9CiAgICAgdm9pZCBzZXRTdG9wUHJvdmlzaW9uYWxGcmFtZUxv YWRzKGJvb2wgc3RvcFByb3Zpc2lvbmFsRnJhbWVMb2FkcykgeyBtX3N0b3BQcm92aXNpb25hbEZy YW1lTG9hZHMgPSBzdG9wUHJvdmlzaW9uYWxGcmFtZUxvYWRzOyB9CiAKKyAgICBib29sIHRlc3RP bnNjcmVlbigpIGNvbnN0IHsgcmV0dXJuIG1fdGVzdE9uc2NyZWVuOyB9CisgICAgdm9pZCBzZXRU ZXN0T25zY3JlZW4oYm9vbCB0ZXN0T25zY3JlZW4pIHsgbV90ZXN0T25zY3JlZW4gPSB0ZXN0T25z Y3JlZW47IH0KKwogICAgIGJvb2wgdGVzdFJlcGFpbnQoKSBjb25zdCB7IHJldHVybiBtX3Rlc3RS ZXBhaW50OyB9CiAgICAgdm9pZCBzZXRUZXN0UmVwYWludChib29sIHRlc3RSZXBhaW50KSB7IG1f dGVzdFJlcGFpbnQgPSB0ZXN0UmVwYWludDsgfQogCkBAIC0xNDQsNyArMTQ4LDEwIEBAIHB1Ymxp YzoKIAogICAgIGJvb2wgZ2xvYmFsRmxhZygpIGNvbnN0IHsgcmV0dXJuIG1fZ2xvYmFsRmxhZzsg fQogICAgIHZvaWQgc2V0R2xvYmFsRmxhZyhib29sIGdsb2JhbEZsYWcpIHsgbV9nbG9iYWxGbGFn ID0gZ2xvYmFsRmxhZzsgfQotCisgICAgCisgICAgY29uc3Qgc3RkOjpzdHJpbmcmIHRlc3RQYXRo T3JVUkwoKSBjb25zdCB7IHJldHVybiBtX3Rlc3RQYXRoT3JVUkw7IH0KKyAgICBjb25zdCBzdGQ6 OnN0cmluZyYgZXhwZWN0ZWRQaXhlbEhhc2goKSBjb25zdCB7IHJldHVybiBtX2V4cGVjdGVkUGl4 ZWxIYXNoOyB9CisgICAgCiBwcml2YXRlOgogICAgIGJvb2wgbV9kdW1wQXNUZXh0OwogICAgIGJv b2wgbV9kdW1wQXNQREY7CkBAIC0xNjUsNiArMTcyLDcgQEAgcHJpdmF0ZToKICAgICBib29sIG1f Y2FuT3BlbldpbmRvd3M7CiAgICAgYm9vbCBtX2Nsb3NlUmVtYWluaW5nV2luZG93c1doZW5Db21w bGV0ZTsKICAgICBib29sIG1fc3RvcFByb3Zpc2lvbmFsRnJhbWVMb2FkczsKKyAgICBib29sIG1f dGVzdE9uc2NyZWVuOwogICAgIGJvb2wgbV90ZXN0UmVwYWludDsKICAgICBib29sIG1fdGVzdFJl cGFpbnRTd2VlcEhvcml6b250YWxseTsKICAgICBib29sIG1fd2FpdFRvRHVtcDsgLy8gVHJ1ZSBp ZiB3YWl0VW50aWxEb25lKCkgaGFzIGJlZW4gY2FsbGVkLCBidXQgbm90aWZ5RG9uZSgpIGhhcyBu b3QgeWV0IGJlZW4gY2FsbGVkLgpAQCAtMTcyLDYgKzE4MCw5IEBAIHByaXZhdGU6CiAKICAgICBi b29sIG1fZ2xvYmFsRmxhZzsKIAorICAgIHN0ZDo6c3RyaW5nIG1fdGVzdFBhdGhPclVSTDsKKyAg ICBzdGQ6OnN0cmluZyBtX2V4cGVjdGVkUGl4ZWxIYXNoOyAgICAvLyBlbXB0eSBzdHJpbmcgaWYg bm8gaGFzaAorICAgIAogICAgIHN0YXRpYyBKU0NsYXNzUmVmIGdldEpTQ2xhc3MoKTsKICAgICBz dGF0aWMgSlNTdGF0aWNWYWx1ZSogc3RhdGljVmFsdWVzKCk7CiAgICAgc3RhdGljIEpTU3RhdGlj RnVuY3Rpb24qIHN0YXRpY0Z1bmN0aW9ucygpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvUGl4ZWxEdW1wU3VwcG9ydC5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvUGl4ZWxEdW1wU3VwcG9ydC5oCmluZGV4IDMyMTRkMDQuLmQ0Zjg5NDggMTAwNjQ0Ci0tLSBh L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL1BpeGVsRHVtcFN1cHBvcnQuaAorKysgYi9XZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9QaXhlbER1bXBTdXBwb3J0LmgKQEAgLTI5LDEyICsyOSwx OCBAQAogI2lmbmRlZiBQaXhlbER1bXBTdXBwb3J0X2gKICNkZWZpbmUgUGl4ZWxEdW1wU3VwcG9y dF9oCiAKLXZvaWQgZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0ZWQoY29u c3QgY2hhciogY3VycmVudFRlc3QsIGJvb2wgZm9yY2VBbGxUZXN0c1RvRHVtcFBpeGVscyk7Cisj aW5jbHVkZSA8c3RyaW5nPgorCit2b2lkIGR1bXBXZWJWaWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0 aEV4cGVjdGVkKGNvbnN0IHN0ZDo6c3RyaW5nJiBleHBlY3RlZEhhc2gpOworCisjaWYgUExBVEZP Uk0oTUFDKQogCiAvLyBDYW4gYmUgdXNlZCBhcyBhIHNpZ25hbCBoYW5kbGVyCi12b2lkIHJlc3Rv cmVDb2xvclNwYWNlKGludCBpZ25vcmVkKTsKK3ZvaWQgcmVzdG9yZU1haW5EaXNwbGF5Q29sb3JQ cm9maWxlKGludCBpZ25vcmVkKTsKKworLy8gTWF5IGNoYW5nZSB5b3VyIGNvbG9yIHNwYWNlLCBy ZXF1aXJpbmcgYSBjYWxsIHRvIHJlc3RvcmVNYWluRGlzcGxheUNvbG9yUHJvZmlsZQordm9pZCBz ZXR1cE1haW5EaXNwbGF5Q29sb3JQcm9maWxlKCk7CiAKLS8vIE1heSBjaGFuZ2UgeW91ciBjb2xv ciBzcGFjZSwgcmVxdWlyaW5nIGEgY2FsbCB0byByZXN0b3JlQ29sb3JTcGFjZQotdm9pZCBpbml0 aWFsaXplQ29sb3JTcGFjZUFuZFNjcmVlQnVmZmVyRm9yUGl4ZWxUZXN0cygpOworI2VuZGlmCiAK ICNlbmRpZiAvLyBQaXhlbER1bXBTdXBwb3J0X2gKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL2NnL0ltYWdlRGlmZkNHLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL2NnL0ltYWdlRGlmZkNHLmNwcAppbmRleCBjMzkzOTEzLi4xZTU1ZTc4IDEwMDY0NAotLS0g YS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9jZy9JbWFnZURpZmZDRy5jcHAKKysrIGIvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvSW1hZ2VEaWZmQ0cuY3BwCkBAIC0zNiw2ICszNiw3 IEBACiAjaWYgUExBVEZPUk0oV0lOKQogI2luY2x1ZGUgPGZjbnRsLmg+CiAjaW5jbHVkZSA8aW8u aD4KKyNpbmNsdWRlIDx3dGYvTWF0aEV4dHJhcy5oPgogI2VuZGlmCiAKICNpZiBQTEFURk9STShN QUMpCkBAIC01NCw2ICs1NSwxMCBAQCB0eXBlZGVmIGZsb2F0IENHRmxvYXQ7CiB1c2luZyBuYW1l c3BhY2Ugc3RkOwogCiAjaWYgUExBVEZPUk0oV0lOKQorc3RhdGljIGlubGluZSBmbG9hdCBzdHJ0 b2YoY29uc3QgY2hhciAqbnB0ciwgY2hhciAqKmVuZHB0cikKK3sKKyAgICByZXR1cm4gc3RydG9k KG5wdHIsIGVuZHB0cik7Cit9CiBzdGF0aWMgY29uc3QgQ0ZTdHJpbmdSZWYga1VUVHlwZVBORyA9 IENGU1RSKCJwdWJsaWMucG5nIik7CiAjZW5kaWYKIApAQCAtNzIsOTkgKzc3LDk5IEBAIHN0YXRp YyBSZXRhaW5QdHI8Q0dJbWFnZVJlZj4gY3JlYXRlSW1hZ2VGcm9tU3RkaW4oaW50IGJ5dGVzUmVt YWluaW5nKQogICAgIHJldHVybiBSZXRhaW5QdHI8Q0dJbWFnZVJlZj4oQWRvcHRDRiwgQ0dJbWFn ZUNyZWF0ZVdpdGhQTkdEYXRhUHJvdmlkZXIoZGF0YVByb3ZpZGVyLmdldCgpLCAwLCBmYWxzZSwg a0NHUmVuZGVyaW5nSW50ZW50RGVmYXVsdCkpOwogfQogCi0vLyBHZW5lcmF0ZXMgYW4gUkdCQTgg Yml0bWFwIGluIHRoZSByZWZlcmVuY2UgaW1hZ2UgY29sb3JzcGFjZSBjb250YWluaW5nIHRoZSBk aWZmZXJlbmNlcyBiZXR3ZWVuIHRoZSAyIGltYWdlcwotc3RhdGljIFJldGFpblB0cjxDR0NvbnRl eHRSZWY+IGNyZWF0ZURpZmZlcmVuY2VCaXRtYXAoQ0dJbWFnZVJlZiB0ZXN0SW1hZ2UsIENHSW1h Z2VSZWYgcmVmZXJlbmNlSW1hZ2UpCitzdGF0aWMgdm9pZCByZWxlYXNlTWFsbG9jQnVmZmVyKHZv aWQqIGluZm8sIGNvbnN0IHZvaWQqIGRhdGEsIHNpemVfdCBzaXplKQogewotICAgIC8vIHdlIG11 c3QgaGF2ZSBib3RoIGltYWdlcyB0byB0YWtlIGRpZmYKLSAgICBpZiAoIXRlc3RJbWFnZSB8fCAh cmVmZXJlbmNlSW1hZ2UpIHsKLSAgICAgICAgZnByaW50ZihzdGRlcnIsICJ0ZXN0IG9yIHJlZmVy ZW5jZSBpbWFnZSBpcyBtaXNzaW5nISIpOwotICAgICAgICByZXR1cm4gMDsKLSAgICB9Ci0KLSAg ICAvLyB3ZSBtdXN0IGhhdmUgYm90aCBpbWFnZXMgYmUgdGhlIHNhbWUgZGltZW5zaW9ucwotICAg IGlmICgoQ0dJbWFnZUdldFdpZHRoKHRlc3RJbWFnZSkgIT0gQ0dJbWFnZUdldFdpZHRoKHJlZmVy ZW5jZUltYWdlKSkgfHwgKENHSW1hZ2VHZXRIZWlnaHQodGVzdEltYWdlKSAhPSBDR0ltYWdlR2V0 SGVpZ2h0KHJlZmVyZW5jZUltYWdlKSkpIHsKLSAgICAgICAgZnByaW50ZihzdGRlcnIsICJ0ZXN0 IGFuZCByZWZlcmVuY2UgaW1hZ2UgZGltZW5zaW9ucyBkb24ndCBtYXRjaCEiKTsKLSAgICAgICAg cmV0dXJuIDA7Ci0gICAgfQotCi0gICAgLy8gd2UgbXVzdCBoYXZlIGJvdGggaW1hZ2VzIGluIHRo ZSBzYW1lIGNvbG9yc3BhY2UKLSAgICBpZiAoIUNGRXF1YWwoQ0dJbWFnZUdldENvbG9yU3BhY2Uo dGVzdEltYWdlKSwgQ0dJbWFnZUdldENvbG9yU3BhY2UocmVmZXJlbmNlSW1hZ2UpKSkgewotICAg ICAgICBmcHJpbnRmKHN0ZGVyciwgInRlc3QgYW5kIHJlZmVyZW5jZSBpbWFnZSBjb2xvcnNwYWNl cyBkb24ndCBtYXRjaCEiKTsKLSAgICAgICAgcmV0dXJuIDA7Ci0gICAgfQotCi0gICAgc3RhdGlj IENGTXV0YWJsZURhdGFSZWYgZGF0YSA9IENGRGF0YUNyZWF0ZU11dGFibGUoa0NGQWxsb2NhdG9y RGVmYXVsdCwgMCk7Ci0gICAgc2l6ZV90IHJvd0J5dGVzID0gKDQgKiBDR0ltYWdlR2V0V2lkdGgo cmVmZXJlbmNlSW1hZ2UpICsgNjMpICYgfjYzOyAvLyBVc2UgYSBtdWx0aXBsZSBvZiA2NCBieXRl cyB0byBpbXByb3ZlIENHIHBlcmZvcm1hbmNlCi0gICAgQ0ZEYXRhU2V0TGVuZ3RoKGRhdGEsIENH SW1hZ2VHZXRIZWlnaHQocmVmZXJlbmNlSW1hZ2UpICogcm93Qnl0ZXMpOwotICAgIFJldGFpblB0 cjxDR0NvbnRleHRSZWY+IGNvbnRleHQoQWRvcHRDRiwgQ0dCaXRtYXBDb250ZXh0Q3JlYXRlKENG RGF0YUdldE11dGFibGVCeXRlUHRyKGRhdGEpLCBDR0ltYWdlR2V0V2lkdGgocmVmZXJlbmNlSW1h Z2UpLCBDR0ltYWdlR2V0SGVpZ2h0KHJlZmVyZW5jZUltYWdlKSwgOCwgcm93Qnl0ZXMsIENHSW1h Z2VHZXRDb2xvclNwYWNlKHJlZmVyZW5jZUltYWdlKSwga0NHSW1hZ2VBbHBoYVByZW11bHRpcGxp ZWRMYXN0IHwga0NHQml0bWFwQnl0ZU9yZGVyMzJCaWcpKTsKLQotICAgIENHQ29udGV4dFNldEJs ZW5kTW9kZShjb250ZXh0LmdldCgpLCBrQ0dCbGVuZE1vZGVOb3JtYWwpOwotICAgIENHQ29udGV4 dERyYXdJbWFnZShjb250ZXh0LmdldCgpLCBDR1JlY3RNYWtlKDAsIDAsIHN0YXRpY19jYXN0PENH RmxvYXQ+KENHSW1hZ2VHZXRXaWR0aCh0ZXN0SW1hZ2UpKSwgc3RhdGljX2Nhc3Q8Q0dGbG9hdD4o Q0dJbWFnZUdldEhlaWdodCh0ZXN0SW1hZ2UpKSksIHRlc3RJbWFnZSk7Ci0gICAgQ0dDb250ZXh0 U2V0QmxlbmRNb2RlKGNvbnRleHQuZ2V0KCksIGtDR0JsZW5kTW9kZURpZmZlcmVuY2UpOwotICAg IENHQ29udGV4dERyYXdJbWFnZShjb250ZXh0LmdldCgpLCBDR1JlY3RNYWtlKDAsIDAsIHN0YXRp Y19jYXN0PENHRmxvYXQ+KENHSW1hZ2VHZXRXaWR0aChyZWZlcmVuY2VJbWFnZSkpLCBzdGF0aWNf Y2FzdDxDR0Zsb2F0PihDR0ltYWdlR2V0SGVpZ2h0KHJlZmVyZW5jZUltYWdlKSkpLCByZWZlcmVu Y2VJbWFnZSk7Ci0KLSAgICByZXR1cm4gY29udGV4dDsKKyAgICBmcmVlKCh2b2lkKilkYXRhKTsK IH0KIAotLy8gQ291bnRzIHRoZSBudW1iZXIgb2Ygbm9uLWJsYWNrIHBpeGVscywgYW5kIHJldHVy bnMgdGhlIHBlcmNlbnRhZ2Ugb2Ygbm9uLWJsYWNrIHBpeGVscyB0byB0b3RhbCBwaXhlbHMgaW4g dGhlIGltYWdlLgotc3RhdGljIGZsb2F0IGNvbXB1dGVQZXJjZW50YWdlRGlmZmVyZW50KENHQ29u dGV4dFJlZiBkaWZmQml0bWFwLCB1bnNpZ25lZCB0aHJlc2hvbGQpCitzdGF0aWMgUmV0YWluUHRy PENHSW1hZ2VSZWY+IGNyZWF0ZURpZmZlcmVuY2VJbWFnZShDR0ltYWdlUmVmIGJhc2VJbWFnZSwg Q0dJbWFnZVJlZiB0ZXN0SW1hZ2UsIGZsb2F0JiBkaWZmZXJlbmNlKQogewotICAgIC8vIGlmIGRp ZmZCaXRtYXAgaXMgbmlsLCB0aGVuIHRoZXJlIHdhcyBhbiBlcnJvciwgYW5kIGl0IGRpZG4ndCBt YXRjaC4KLSAgICBpZiAoIWRpZmZCaXRtYXApCi0gICAgICAgIHJldHVybiAxMDAuMGY7Ci0KLSAg ICBzaXplX3QgcGl4ZWxzSGlnaCA9IENHQml0bWFwQ29udGV4dEdldEhlaWdodChkaWZmQml0bWFw KTsKLSAgICBzaXplX3QgcGl4ZWxzV2lkZSA9IENHQml0bWFwQ29udGV4dEdldFdpZHRoKGRpZmZC aXRtYXApOwotICAgIHNpemVfdCBieXRlc1BlclJvdyA9IENHQml0bWFwQ29udGV4dEdldEJ5dGVz UGVyUm93KGRpZmZCaXRtYXApOwotICAgIHVuc2lnbmVkIGNoYXIqIHBpeGVsUm93RGF0YSA9IHN0 YXRpY19jYXN0PHVuc2lnbmVkIGNoYXIqPihDR0JpdG1hcENvbnRleHRHZXREYXRhKGRpZmZCaXRt YXApKTsKLSAgICB1bnNpZ25lZCBkaWZmZXJlbmNlcyA9IDA7Ci0KLSAgICBmb3IgKHVuc2lnbmVk IHJvdyA9IDA7IHJvdyA8IHBpeGVsc0hpZ2g7IHJvdysrKSB7Ci0gICAgICAgIGZvciAodW5zaWdu ZWQgY29sID0gMDsgY29sIDwgKHBpeGVsc1dpZGUgKiA0KTsgY29sICs9IDQpIHsKLSAgICAgICAg ICAgIHVuc2lnbmVkIGNoYXIqIHJlZCA9IHBpeGVsUm93RGF0YSArIGNvbDsKLSAgICAgICAgICAg IHVuc2lnbmVkIGNoYXIqIGdyZWVuID0gcmVkICsgMTsKLSAgICAgICAgICAgIHVuc2lnbmVkIGNo YXIqIGJsdWUgPSByZWQgKyAyOwotICAgICAgICAgICAgdW5zaWduZWQgZGlzdGFuY2UgPSAqcmVk ICsgKmdyZWVuICsgKmJsdWU7Ci0gICAgICAgICAgICBpZiAoZGlzdGFuY2UgPiB0aHJlc2hvbGQp IHsKLSAgICAgICAgICAgICAgICBkaWZmZXJlbmNlcysrOwotICAgICAgICAgICAgICAgIC8vIHNo aWZ0IHRoZSBwaXhlbHMgdG93YXJkcyB3aGl0ZSB0byBtYWtlIHRoZW0gbW9yZSB2aXNpYmxlCi0g ICAgICAgICAgICAgICAgKnJlZCA9IHN0YXRpY19jYXN0PHVuc2lnbmVkIGNoYXI+KG1pbihVQ0hB Ul9NQVgsICpyZWQgKyAxMDApKTsKLSAgICAgICAgICAgICAgICAqZ3JlZW4gPSBzdGF0aWNfY2Fz dDx1bnNpZ25lZCBjaGFyPihtaW4oVUNIQVJfTUFYLCAqZ3JlZW4gKyAxMDApKTsKLSAgICAgICAg ICAgICAgICAqYmx1ZSA9IHN0YXRpY19jYXN0PHVuc2lnbmVkIGNoYXI+KG1pbihVQ0hBUl9NQVgs ICpibHVlICsgMTAwKSk7CisgICAgc3RhdGljIFJldGFpblB0cjxDR0NvbG9yU3BhY2VSZWY+IGNv bG9yU3BhY2UoQWRvcHRDRiwgQ0dDb2xvclNwYWNlQ3JlYXRlRGV2aWNlUkdCKCkpOworICAgIFJl dGFpblB0cjxDR0ltYWdlUmVmPiBkaWZmSW1hZ2U7CisgICAgCisgICAgc2l6ZV90IHdpZHRoID0g Q0dJbWFnZUdldFdpZHRoKGJhc2VJbWFnZSk7CisgICAgc2l6ZV90IGhlaWdodCA9IENHSW1hZ2VH ZXRIZWlnaHQoYmFzZUltYWdlKTsKKyAgICBzaXplX3Qgcm93Qnl0ZXMgPSB3aWR0aCAqIDQ7Cisg ICAgCisgICAgLy8gRHJhdyBiYXNlIGltYWdlIGluIGJpdG1hcCBjb250ZXh0CisgICAgdm9pZCog YmFzZUJ1ZmZlciA9IGNhbGxvYyhoZWlnaHQsIHJvd0J5dGVzKTsKKyAgICBDR0NvbnRleHRSZWYg YmFzZUNvbnRleHQgPSBDR0JpdG1hcENvbnRleHRDcmVhdGUoYmFzZUJ1ZmZlciwgd2lkdGgsIGhl aWdodCwgOCwgcm93Qnl0ZXMsIGNvbG9yU3BhY2UuZ2V0KCksIGtDR0ltYWdlQWxwaGFQcmVtdWx0 aXBsaWVkRmlyc3QgfCBrQ0dCaXRtYXBCeXRlT3JkZXIzMkhvc3QpOworICAgIENHQ29udGV4dERy YXdJbWFnZShiYXNlQ29udGV4dCwgQ0dSZWN0TWFrZSgwLCAwLCB3aWR0aCwgaGVpZ2h0KSwgYmFz ZUltYWdlKTsKKyAgICBDR0NvbnRleHRSZWxlYXNlKGJhc2VDb250ZXh0KTsKKyAgICAKKyAgICAv LyBEcmF3IHRlc3QgaW1hZ2UgaW4gYml0bWFwIGNvbnRleHQKKyAgICB2b2lkKiBidWZmZXIgPSBj YWxsb2MoaGVpZ2h0LCByb3dCeXRlcyk7CisgICAgQ0dDb250ZXh0UmVmIGNvbnRleHQgPSBDR0Jp dG1hcENvbnRleHRDcmVhdGUoYnVmZmVyLCB3aWR0aCwgaGVpZ2h0LCA4LCByb3dCeXRlcywgY29s b3JTcGFjZS5nZXQoKSwga0NHSW1hZ2VBbHBoYVByZW11bHRpcGxpZWRGaXJzdCB8IGtDR0JpdG1h cEJ5dGVPcmRlcjMySG9zdCk7CisgICAgQ0dDb250ZXh0RHJhd0ltYWdlKGNvbnRleHQsIENHUmVj dE1ha2UoMCwgMCwgd2lkdGgsIGhlaWdodCksIHRlc3RJbWFnZSk7CisgICAgQ0dDb250ZXh0UmVs ZWFzZShjb250ZXh0KTsKKyAgICAKKyAgICAvLyBDb21wYXJlIHRoZSBjb250ZW50IG9mIHRoZSAy IGJpdG1hcHMKKyAgICB2b2lkKiBkaWZmQnVmZmVyID0gbWFsbG9jKHdpZHRoICogaGVpZ2h0KTsK KyAgICBmbG9hdCBjb3VudCA9IDAuMGY7CisgICAgZmxvYXQgc3VtID0gMC4wZjsKKyAgICBmbG9h dCBtYXhEaXN0YW5jZSA9IDAuMGY7CisgICAgdW5zaWduZWQgY2hhciogYmFzZVBpeGVsID0gKHVu c2lnbmVkIGNoYXIqKWJhc2VCdWZmZXI7CisgICAgdW5zaWduZWQgY2hhciogcGl4ZWwgPSAodW5z aWduZWQgY2hhciopYnVmZmVyOworICAgIHVuc2lnbmVkIGNoYXIqIGRpZmYgPSAodW5zaWduZWQg Y2hhciopZGlmZkJ1ZmZlcjsKKyAgICBmb3IgKHNpemVfdCB5ID0gMDsgeSA8IGhlaWdodDsgKyt5 KSB7CisgICAgICAgIGZvciAoc2l6ZV90IHggPSAwOyB4IDwgd2lkdGg7ICsreCkgeworICAgICAg ICAgICAgZmxvYXQgcmVkID0gKHBpeGVsWzBdIC0gYmFzZVBpeGVsWzBdKSAvIG1heDxmbG9hdD4o MjU1IC0gYmFzZVBpeGVsWzBdLCBiYXNlUGl4ZWxbMF0pOworICAgICAgICAgICAgZmxvYXQgZ3Jl ZW4gPSAocGl4ZWxbMV0gLSBiYXNlUGl4ZWxbMV0pIC8gbWF4PGZsb2F0PigyNTUgLSBiYXNlUGl4 ZWxbMV0sIGJhc2VQaXhlbFsxXSk7CisgICAgICAgICAgICBmbG9hdCBibHVlID0gKHBpeGVsWzJd IC0gYmFzZVBpeGVsWzJdKSAvIG1heDxmbG9hdD4oMjU1IC0gYmFzZVBpeGVsWzJdLCBiYXNlUGl4 ZWxbMl0pOworICAgICAgICAgICAgZmxvYXQgYWxwaGEgPSAocGl4ZWxbM10gLSBiYXNlUGl4ZWxb M10pIC8gbWF4PGZsb2F0PigyNTUgLSBiYXNlUGl4ZWxbM10sIGJhc2VQaXhlbFszXSk7CisgICAg ICAgICAgICBmbG9hdCBkaXN0YW5jZSA9IHNxcnRmKHJlZCAqIHJlZCArIGdyZWVuICogZ3JlZW4g KyBibHVlICogYmx1ZSArIGFscGhhICogYWxwaGEpIC8gMi4wZjsKKyAgICAgICAgICAgIAorICAg ICAgICAgICAgKmRpZmYrKyA9ICh1bnNpZ25lZCBjaGFyKShkaXN0YW5jZSAqIDI1NS4wZik7Cisg ICAgICAgICAgICAKKyAgICAgICAgICAgIGlmIChkaXN0YW5jZSA+PSAxLjBmIC8gMjU1LjBmKSB7 CisgICAgICAgICAgICAgICAgY291bnQgKz0gMS4wZjsKKyAgICAgICAgICAgICAgICBzdW0gKz0g ZGlzdGFuY2U7CisgICAgICAgICAgICAgICAgaWYgKGRpc3RhbmNlID4gbWF4RGlzdGFuY2UpCisg ICAgICAgICAgICAgICAgICAgIG1heERpc3RhbmNlID0gZGlzdGFuY2U7CiAgICAgICAgICAgICB9 CisgICAgICAgICAgICAKKyAgICAgICAgICAgIGJhc2VQaXhlbCArPSA0OworICAgICAgICAgICAg cGl4ZWwgKz0gNDsKICAgICAgICAgfQotICAgICAgICBwaXhlbFJvd0RhdGEgKz0gYnl0ZXNQZXJS b3c7CiAgICAgfQotCi0gICAgZmxvYXQgdG90YWxQaXhlbHMgPSBzdGF0aWNfY2FzdDxmbG9hdD4o cGl4ZWxzSGlnaCAqIHBpeGVsc1dpZGUpOwotICAgIHJldHVybiAoZGlmZmVyZW5jZXMgKiAxMDAu ZikgLyB0b3RhbFBpeGVsczsKKyAgICAKKyAgICAvLyBDb21wdXRlIHRoZSBkaWZmZXJlbmNlIGFz IGEgcGVyY2VudGFnZSBjb21iaW5pbmcgYm90aCB0aGUgbnVtYmVyIG9mIGRpZmZlcmVudCBwaXhl bHMgYW5kIHRoZWlyIGRpZmZlcmVuY2UgYW1vdW50IGkuZS4gdGhlIGF2ZXJhZ2UgZGlzdGFuY2Ug b3ZlciB0aGUgZW50aXJlIGltYWdlCisgICAgaWYgKGNvdW50ID4gMC4wZikKKyAgICAgICAgZGlm ZmVyZW5jZSA9IDEwMC4wZiAqIHN1bSAvIChoZWlnaHQgKiB3aWR0aCk7CisgICAgZWxzZQorICAg ICAgICBkaWZmZXJlbmNlID0gMC4wZjsKKyAgICAKKyAgICAvLyBHZW5lcmF0ZSBhIG5vcm1hbGl6 ZWQgZGlmZiBpbWFnZSBpZiB0aGVyZSBpcyBhbnkgZGlmZmVyZW5jZQorICAgIGlmIChkaWZmZXJl bmNlID4gMC4wZikgeworICAgICAgICBpZiAobWF4RGlzdGFuY2UgPCAxLjBmKSB7CisgICAgICAg ICAgICBkaWZmID0gKHVuc2lnbmVkIGNoYXIqKWRpZmZCdWZmZXI7CisgICAgICAgICAgICBmb3Io c2l6ZV90IHAgPSAwOyBwIDwgaGVpZ2h0ICogd2lkdGg7ICsrcCkKKyAgICAgICAgICAgICAgICBk aWZmW3BdID0gZGlmZltwXSAvIG1heERpc3RhbmNlOworICAgICAgICB9CisgICAgICAgIAorICAg ICAgICBDR0RhdGFQcm92aWRlclJlZiBwcm92aWRlciA9IENHRGF0YVByb3ZpZGVyQ3JlYXRlV2l0 aERhdGEoMCwgZGlmZkJ1ZmZlciwgd2lkdGggKiBoZWlnaHQsIHJlbGVhc2VNYWxsb2NCdWZmZXIp OworICAgICAgICBDR0NvbG9yU3BhY2VSZWYgZGlmZkNvbG9yc3BhY2UgPSBDR0NvbG9yU3BhY2VD cmVhdGVEZXZpY2VHcmF5KCk7CisgICAgICAgIGRpZmZJbWFnZS5hZG9wdENGKENHSW1hZ2VDcmVh dGUod2lkdGgsIGhlaWdodCwgOCwgOCwgd2lkdGgsIGRpZmZDb2xvcnNwYWNlLCAwLCBwcm92aWRl ciwgMCwgZmFsc2UsIGtDR1JlbmRlcmluZ0ludGVudERlZmF1bHQpKTsKKyAgICAgICAgQ0dDb2xv clNwYWNlUmVsZWFzZShkaWZmQ29sb3JzcGFjZSk7CisgICAgICAgIENHRGF0YVByb3ZpZGVyUmVs ZWFzZShwcm92aWRlcik7CisgICAgfQorICAgIGVsc2UKKyAgICAgICAgZnJlZShkaWZmQnVmZmVy KTsKKyAgICAKKyAgICAvLyBEZXN0cm95IGRyYXdpbmcgYnVmZmVycworICAgIGlmIChidWZmZXIp CisgICAgICAgIGZyZWUoYnVmZmVyKTsKKyAgICBpZiAoYmFzZUJ1ZmZlcikKKyAgICAgICAgZnJl ZShiYXNlQnVmZmVyKTsKKyAgICAKKyAgICByZXR1cm4gZGlmZkltYWdlOwogfQogCi1zdGF0aWMg dm9pZCBjb21wYXJlSW1hZ2VzKENHSW1hZ2VSZWYgdGVzdEltYWdlLCBDR0ltYWdlUmVmIHJlZmVy ZW5jZUltYWdlLCB1bnNpZ25lZCB0aHJlc2hvbGQpCitzdGF0aWMgaW5saW5lIGJvb2wgaW1hZ2VI YXNBbHBoYShDR0ltYWdlUmVmIGltYWdlKQogewotICAgIC8vIHByZXBhcmUgdGhlIGRpZmZlcmVu Y2UgYmxlbmQgdG8gY2hlY2sgZm9yIHBpeGVsIHZhcmlhdGlvbnMKLSAgICBSZXRhaW5QdHI8Q0dD b250ZXh0UmVmPiBkaWZmQml0bWFwID0gY3JlYXRlRGlmZmVyZW5jZUJpdG1hcCh0ZXN0SW1hZ2Us IHJlZmVyZW5jZUltYWdlKTsKLQotICAgIGZsb2F0IHBlcmNlbnRhZ2UgPSBjb21wdXRlUGVyY2Vu dGFnZURpZmZlcmVudChkaWZmQml0bWFwLmdldCgpLCB0aHJlc2hvbGQpOwotCi0gICAgcGVyY2Vu dGFnZSA9IChmbG9hdCkoKGludCkocGVyY2VudGFnZSAqIDEwMC4wZikpIC8gMTAwLjBmOyAvLyBy b3VuZCB0byAyIGRlY2ltYWwgcGxhY2VzCi0KLSAgICAvLyBzZW5kIG1lc3NhZ2UgdG8gbGV0IHRo ZW0ga25vdyBpZiBhbiBpbWFnZSB3YXMgd3JvbmcKLSAgICBpZiAocGVyY2VudGFnZSA+IDAuMGYp IHsKLSAgICAgICAgLy8gc2luY2UgdGhlIGRpZmYgbWlnaHQgYWN0dWFsbHkgc2hvdyBzb21ldGhp bmcsIHNlbmQgaXQgdG8gc3Rkb3V0Ci0gICAgICAgIGlmIChkaWZmQml0bWFwKSB7Ci0gICAgICAg ICAgICBSZXRhaW5QdHI8Q0dJbWFnZVJlZj4gaW1hZ2UoQWRvcHRDRiwgQ0dCaXRtYXBDb250ZXh0 Q3JlYXRlSW1hZ2UoZGlmZkJpdG1hcC5nZXQoKSkpOwotICAgICAgICAgICAgUmV0YWluUHRyPENG TXV0YWJsZURhdGFSZWY+IGltYWdlRGF0YShBZG9wdENGLCBDRkRhdGFDcmVhdGVNdXRhYmxlKDAs IDApKTsKLSAgICAgICAgICAgIFJldGFpblB0cjxDR0ltYWdlRGVzdGluYXRpb25SZWY+IGltYWdl RGVzdChBZG9wdENGLCBDR0ltYWdlRGVzdGluYXRpb25DcmVhdGVXaXRoRGF0YShpbWFnZURhdGEu Z2V0KCksIGtVVFR5cGVQTkcsIDEsIDApKTsKLSAgICAgICAgICAgIENHSW1hZ2VEZXN0aW5hdGlv bkFkZEltYWdlKGltYWdlRGVzdC5nZXQoKSwgaW1hZ2UuZ2V0KCksIDApOwotICAgICAgICAgICAg Q0dJbWFnZURlc3RpbmF0aW9uRmluYWxpemUoaW1hZ2VEZXN0LmdldCgpKTsKLSAgICAgICAgICAg IHByaW50ZigiQ29udGVudC1MZW5ndGg6ICVsdVxuIiwgQ0ZEYXRhR2V0TGVuZ3RoKGltYWdlRGF0 YS5nZXQoKSkpOwotICAgICAgICAgICAgZndyaXRlKENGRGF0YUdldEJ5dGVQdHIoaW1hZ2VEYXRh LmdldCgpKSwgMSwgQ0ZEYXRhR2V0TGVuZ3RoKGltYWdlRGF0YS5nZXQoKSksIHN0ZG91dCk7Ci0g ICAgICAgIH0KLSAgICAgICAgCi0gICAgICAgIGZwcmludGYoc3Rkb3V0LCAiZGlmZjogJTAxLjJm JSUgZmFpbGVkXG4iLCBwZXJjZW50YWdlKTsKLSAgICB9IGVsc2UKLSAgICAgICAgZnByaW50Zihz dGRvdXQsICJkaWZmOiAlMDEuMmYlJSBwYXNzZWRcbiIsIHBlcmNlbnRhZ2UpOworICAgIENHSW1h Z2VBbHBoYUluZm8gaW5mbyA9IENHSW1hZ2VHZXRBbHBoYUluZm8oaW1hZ2UpOworICAgIAorICAg IHJldHVybiAoaW5mbyA+PSBrQ0dJbWFnZUFscGhhUHJlbXVsdGlwbGllZExhc3QpICYmIChpbmZv IDw9IGtDR0ltYWdlQWxwaGFGaXJzdCk7CiB9CiAKIGludCBtYWluKGludCBhcmdjLCBjb25zdCBj aGFyKiBhcmd2W10pCkBAIC0xNzQsMTMgKzE3OSwxMyBAQCBpbnQgbWFpbihpbnQgYXJnYywgY29u c3QgY2hhciogYXJndltdKQogICAgIF9zZXRtb2RlKDEsIF9PX0JJTkFSWSk7CiAjZW5kaWYKIAot ICAgIHVuc2lnbmVkIHRocmVzaG9sZCA9IDA7CisgICAgZmxvYXQgdG9sZXJhbmNlID0gMC4wZjsK IAogICAgIGZvciAoaW50IGkgPSAxOyBpIDwgYXJnYzsgKytpKSB7Ci0gICAgICAgIGlmICghc3Ry Y21wKGFyZ3ZbaV0sICItdCIpIHx8ICFzdHJjbXAoYXJndltpXSwgIi0tdGhyZXNob2xkIikpIHsK KyAgICAgICAgaWYgKCFzdHJjbXAoYXJndltpXSwgIi10IikgfHwgIXN0cmNtcChhcmd2W2ldLCAi LS10b2xlcmFuY2UiKSkgewogICAgICAgICAgICAgaWYgKGkgPj0gYXJnYyAtIDEpCiAgICAgICAg ICAgICAgICAgZXhpdCgxKTsKLSAgICAgICAgICAgIHRocmVzaG9sZCA9IHN0cnRvbChhcmd2W2kg KyAxXSwgMCwgMCk7CisgICAgICAgICAgICB0b2xlcmFuY2UgPSBzdHJ0b2YoYXJndltpICsgMV0s IDApOwogICAgICAgICAgICAgKytpOwogICAgICAgICAgICAgY29udGludWU7CiAgICAgICAgIH0K QEAgLTIwOSw3ICsyMTQsMzQgQEAgaW50IG1haW4oaW50IGFyZ2MsIGNvbnN0IGNoYXIqIGFyZ3Zb XSkKICAgICAgICAgfQogCiAgICAgICAgIGlmIChhY3R1YWxJbWFnZSAmJiBiYXNlbGluZUltYWdl KSB7Ci0gICAgICAgICAgICBjb21wYXJlSW1hZ2VzKGFjdHVhbEltYWdlLmdldCgpLCBiYXNlbGlu ZUltYWdlLmdldCgpLCB0aHJlc2hvbGQpOworICAgICAgICAgICAgUmV0YWluUHRyPENHSW1hZ2VS ZWY+IGRpZmZJbWFnZTsKKyAgICAgICAgICAgIGZsb2F0IGRpZmZlcmVuY2UgPSAxMDAuMGY7Cisg ICAgICAgICAgICAKKyAgICAgICAgICAgIGlmICgoQ0dJbWFnZUdldFdpZHRoKGFjdHVhbEltYWdl LmdldCgpKSA9PSBDR0ltYWdlR2V0V2lkdGgoYmFzZWxpbmVJbWFnZS5nZXQoKSkpICYmIChDR0lt YWdlR2V0SGVpZ2h0KGFjdHVhbEltYWdlLmdldCgpKSA9PSBDR0ltYWdlR2V0SGVpZ2h0KGJhc2Vs aW5lSW1hZ2UuZ2V0KCkpKSAmJiAoaW1hZ2VIYXNBbHBoYShhY3R1YWxJbWFnZS5nZXQoKSkgPT0g aW1hZ2VIYXNBbHBoYShiYXNlbGluZUltYWdlLmdldCgpKSkpIHsKKyAgICAgICAgICAgICAgICBk aWZmSW1hZ2UgPSBjcmVhdGVEaWZmZXJlbmNlSW1hZ2UoYWN0dWFsSW1hZ2UuZ2V0KCksIGJhc2Vs aW5lSW1hZ2UuZ2V0KCksIGRpZmZlcmVuY2UpOyAvLyBkaWZmZXJlbmNlIGlzIHBhc3NlZCBieSBy ZWZlcmVuY2UKKyAgICAgICAgICAgICAgICBpZiAoZGlmZmVyZW5jZSA8PSB0b2xlcmFuY2UpCisg ICAgICAgICAgICAgICAgICAgIGRpZmZlcmVuY2UgPSAwLjBmOworICAgICAgICAgICAgICAgIGVs c2UgeworICAgICAgICAgICAgICAgICAgICBkaWZmZXJlbmNlID0gcm91bmRmKGRpZmZlcmVuY2Ug KiAxMDAuMGYpIC8gMTAwLjBmOworICAgICAgICAgICAgICAgICAgICBkaWZmZXJlbmNlID0gbWF4 KGRpZmZlcmVuY2UsIDAuMDFmKTsgLy8gcm91bmQgdG8gMiBkZWNpbWFsIHBsYWNlcworICAgICAg ICAgICAgICAgIH0KKyAgICAgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgICAgIGZwdXRzKCJl cnJvciwgdGVzdCBhbmQgcmVmZXJlbmNlIGltYWdlIGhhdmUgZGlmZmVyZW50IHByb3BlcnRpZXMu XG4iLCBzdGRlcnIpOworICAgICAgICAgICAgICAgIAorICAgICAgICAgICAgaWYgKGRpZmZlcmVu Y2UgPiAwLjBmKSB7CisgICAgICAgICAgICAgICAgaWYgKGRpZmZJbWFnZSkgeworICAgICAgICAg ICAgICAgICAgICBSZXRhaW5QdHI8Q0ZNdXRhYmxlRGF0YVJlZj4gaW1hZ2VEYXRhKEFkb3B0Q0Ys IENGRGF0YUNyZWF0ZU11dGFibGUoMCwgMCkpOworICAgICAgICAgICAgICAgICAgICBSZXRhaW5Q dHI8Q0dJbWFnZURlc3RpbmF0aW9uUmVmPiBpbWFnZURlc3QoQWRvcHRDRiwgQ0dJbWFnZURlc3Rp bmF0aW9uQ3JlYXRlV2l0aERhdGEoaW1hZ2VEYXRhLmdldCgpLCBrVVRUeXBlUE5HLCAxLCAwKSk7 CisgICAgICAgICAgICAgICAgICAgIENHSW1hZ2VEZXN0aW5hdGlvbkFkZEltYWdlKGltYWdlRGVz dC5nZXQoKSwgZGlmZkltYWdlLmdldCgpLCAwKTsKKyAgICAgICAgICAgICAgICAgICAgQ0dJbWFn ZURlc3RpbmF0aW9uRmluYWxpemUoaW1hZ2VEZXN0LmdldCgpKTsKKyAgICAgICAgICAgICAgICAg ICAgcHJpbnRmKCJDb250ZW50LUxlbmd0aDogJWx1XG4iLCBDRkRhdGFHZXRMZW5ndGgoaW1hZ2VE YXRhLmdldCgpKSk7CisgICAgICAgICAgICAgICAgICAgIGZ3cml0ZShDRkRhdGFHZXRCeXRlUHRy KGltYWdlRGF0YS5nZXQoKSksIDEsIENGRGF0YUdldExlbmd0aChpbWFnZURhdGEuZ2V0KCkpLCBz dGRvdXQpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAKKyAgICAgICAgICAg ICAgICBmcHJpbnRmKHN0ZG91dCwgImRpZmY6ICUwMS4yZiUlIGZhaWxlZFxuIiwgZGlmZmVyZW5j ZSk7CisgICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgICAgICBmcHJpbnRmKHN0ZG91dCwg ImRpZmY6ICUwMS4yZiUlIHBhc3NlZFxuIiwgZGlmZmVyZW5jZSk7CisgICAgICAgICAgICAKICAg ICAgICAgICAgIGFjdHVhbEltYWdlID0gMDsKICAgICAgICAgICAgIGJhc2VsaW5lSW1hZ2UgPSAw OwogICAgICAgICB9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9jZy9Q aXhlbER1bXBTdXBwb3J0Q0cuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvUGl4 ZWxEdW1wU3VwcG9ydENHLmNwcAppbmRleCAyNjBhOTRlLi4yMzIwZTE5IDEwMDY0NAotLS0gYS9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9jZy9QaXhlbER1bXBTdXBwb3J0Q0cuY3BwCisrKyBi L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5jcHAKQEAg LTM0LDcgKzM0LDEwIEBACiAjaW5jbHVkZSAiRHVtcFJlbmRlclRyZWUuaCIKICNpbmNsdWRlICJM YXlvdXRUZXN0Q29udHJvbGxlci5oIgogI2luY2x1ZGUgPEltYWdlSU8vQ0dJbWFnZURlc3RpbmF0 aW9uLmg+CisjaW5jbHVkZSA8YWxnb3JpdGhtPgorI2luY2x1ZGUgPGN0eXBlLmg+CiAjaW5jbHVk ZSA8d3RmL0Fzc2VydGlvbnMuaD4KKyNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CiAjaW5jbHVkZSA8 d3RmL1JldGFpblB0ci5oPgogI2luY2x1ZGUgPHd0Zi9TdHJpbmdFeHRyYXMuaD4KIApAQCAtNjMs NjYgKzY2LDY5IEBAIHN0YXRpYyB2b2lkIHByaW50UE5HKENHSW1hZ2VSZWYgaW1hZ2UpCiAgICAg ZndyaXRlKENGRGF0YUdldEJ5dGVQdHIoaW1hZ2VEYXRhLmdldCgpKSwgMSwgQ0ZEYXRhR2V0TGVu Z3RoKGltYWdlRGF0YS5nZXQoKSksIHN0ZG91dCk7CiB9CiAKLXN0YXRpYyB2b2lkIGdldE1ENUhh c2hTdHJpbmdGb3JCaXRtYXAoQ0dDb250ZXh0UmVmIGJpdG1hcCwgY2hhciBzdHJpbmdbMzNdKQor c3RhdGljIHZvaWQgY29tcHV0ZU1ENUhhc2hTdHJpbmdGb3JCaXRtYXBDb250ZXh0KENHQ29udGV4 dFJlZiBiaXRtYXBDb250ZXh0LCBjaGFyIGhhc2hTdHJpbmdbMzNdKQogewotICAgIE1ENV9DVFgg bWQ1Q29udGV4dDsKLSAgICB1bnNpZ25lZCBjaGFyIGhhc2hbMTZdOwotCi0gICAgc2l6ZV90IGJp dHNQZXJQaXhlbCA9IENHQml0bWFwQ29udGV4dEdldEJpdHNQZXJQaXhlbChiaXRtYXApOwotICAg IEFTU0VSVChiaXRzUGVyUGl4ZWwgPT0gMzIpOyAvLyBJbWFnZURpZmYgYXNzdW1lcyAzMiBiaXQg UkdCQSwgd2UgbXVzdCBhcyB3ZWxsLgotICAgIHNpemVfdCBieXRlc1BlclBpeGVsID0gYml0c1Bl clBpeGVsIC8gODsKLSAgICBzaXplX3QgcGl4ZWxzSGlnaCA9IENHQml0bWFwQ29udGV4dEdldEhl aWdodChiaXRtYXApOwotICAgIHNpemVfdCBwaXhlbHNXaWRlID0gQ0dCaXRtYXBDb250ZXh0R2V0 V2lkdGgoYml0bWFwKTsKLSAgICBzaXplX3QgYnl0ZXNQZXJSb3cgPSBDR0JpdG1hcENvbnRleHRH ZXRCeXRlc1BlclJvdyhiaXRtYXApOwotICAgIEFTU0VSVChieXRlc1BlclJvdyA+PSAocGl4ZWxz V2lkZSAqIGJ5dGVzUGVyUGl4ZWwpKTsKKyAgICBBU1NFUlQoQ0dCaXRtYXBDb250ZXh0R2V0Qml0 c1BlclBpeGVsKGJpdG1hcENvbnRleHQpID09IDMyKTsgLy8gSW1hZ2VEaWZmIGFzc3VtZXMgMzIg Yml0IFJHQkEsIHdlIG11c3QgYXMgd2VsbC4KKyAgICBzaXplX3QgcGl4ZWxzSGlnaCA9IENHQml0 bWFwQ29udGV4dEdldEhlaWdodChiaXRtYXBDb250ZXh0KTsKKyAgICBzaXplX3QgcGl4ZWxzV2lk ZSA9IENHQml0bWFwQ29udGV4dEdldFdpZHRoKGJpdG1hcENvbnRleHQpOworICAgIHNpemVfdCBi eXRlc1BlclJvdyA9IENHQml0bWFwQ29udGV4dEdldEJ5dGVzUGVyUm93KGJpdG1hcENvbnRleHQp OwogCisgICAgLy8gV2UgbmVlZCB0byBzd2FwIHRoZSBieXRlcyB0byBlbnN1cmUgY29uc2lzdGVu dCBoYXNoZXMgaW5kZXBlbmRlbnRseSBvZiBlbmRpYW5uZXNzCisgICAgTUQ1X0NUWCBtZDVDb250 ZXh0OwogICAgIE1ENV9Jbml0KCZtZDVDb250ZXh0KTsKLSAgICB1bnNpZ25lZCBjaGFyKiBiaXRt YXBEYXRhID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcio+KENHQml0bWFwQ29udGV4dEdldERh dGEoYml0bWFwKSk7Ci0gICAgZm9yICh1bnNpZ25lZCByb3cgPSAwOyByb3cgPCBwaXhlbHNIaWdo OyByb3crKykgewotICAgICAgICBNRDVfVXBkYXRlKCZtZDVDb250ZXh0LCBiaXRtYXBEYXRhLCBz dGF0aWNfY2FzdDx1bnNpZ25lZD4ocGl4ZWxzV2lkZSAqIGJ5dGVzUGVyUGl4ZWwpKTsKLSAgICAg ICAgYml0bWFwRGF0YSArPSBieXRlc1BlclJvdzsKKyAgICB1bnNpZ25lZCBjaGFyKiBiaXRtYXBE YXRhID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcio+KENHQml0bWFwQ29udGV4dEdldERhdGEo Yml0bWFwQ29udGV4dCkpOworI2lmIFBMQVRGT1JNKE1BQykKKyAgICBpZiAoKENHQml0bWFwQ29u dGV4dEdldEJpdG1hcEluZm8oYml0bWFwQ29udGV4dCkgJiBrQ0dCaXRtYXBCeXRlT3JkZXJNYXNr KSA9PSBrQ0dCaXRtYXBCeXRlT3JkZXIzMkJpZykgeworICAgICAgICBmb3IgKHVuc2lnbmVkIHJv dyA9IDA7IHJvdyA8IHBpeGVsc0hpZ2g7IHJvdysrKSB7CisgICAgICAgICAgICB1aW50MzJfdCBi dWZmZXJbcGl4ZWxzV2lkZV07CisgICAgICAgICAgICBmb3IgKHVuc2lnbmVkIGNvbHVtbiA9IDA7 IGNvbHVtbiA8IHBpeGVsc1dpZGU7IGNvbHVtbisrKQorICAgICAgICAgICAgICAgIGJ1ZmZlcltj b2x1bW5dID0gT1NSZWFkTGl0dGxlSW50MzIoYml0bWFwRGF0YSwgNCAqIGNvbHVtbik7CisgICAg ICAgICAgICBNRDVfVXBkYXRlKCZtZDVDb250ZXh0LCBidWZmZXIsIDQgKiBwaXhlbHNXaWRlKTsK KyAgICAgICAgICAgIGJpdG1hcERhdGEgKz0gYnl0ZXNQZXJSb3c7CisgICAgICAgIH0KKyAgICB9 IGVsc2UKKyNlbmRpZgorICAgIHsKKyAgICAgICAgZm9yICh1bnNpZ25lZCByb3cgPSAwOyByb3cg PCBwaXhlbHNIaWdoOyByb3crKykgeworICAgICAgICAgICAgTUQ1X1VwZGF0ZSgmbWQ1Q29udGV4 dCwgYml0bWFwRGF0YSwgNCAqIHBpeGVsc1dpZGUpOworICAgICAgICAgICAgYml0bWFwRGF0YSAr PSBieXRlc1BlclJvdzsKKyAgICAgICAgfQogICAgIH0KKyAgICB1bnNpZ25lZCBjaGFyIGhhc2hb MTZdOwogICAgIE1ENV9GaW5hbChoYXNoLCAmbWQ1Q29udGV4dCk7CiAKLSAgICBzdHJpbmdbMF0g PSAnXDAnOworICAgIGhhc2hTdHJpbmdbMF0gPSAnXDAnOwogICAgIGZvciAoaW50IGkgPSAwOyBp IDwgMTY7IGkrKykKLSAgICAgICAgc25wcmludGYoc3RyaW5nLCAzMywgIiVzJTAyeCIsIHN0cmlu ZywgaGFzaFtpXSk7Ci19Ci0KLXZvaWQgZHJhd1NlbGVjdGlvblJlY3QoQ0dDb250ZXh0UmVmIGNv bnRleHQsIGNvbnN0IENHUmVjdCYgcmVjdCkKLXsKLSAgICBDR0NvbnRleHRTYXZlR1N0YXRlKGNv bnRleHQpOwotICAgIENHQ29udGV4dFNldFJHQlN0cm9rZUNvbG9yKGNvbnRleHQsIDEuMCwgMC4w LCAwLjAsIDEuMCk7Ci0gICAgQ0dDb250ZXh0U3Ryb2tlUmVjdChjb250ZXh0LCByZWN0KTsKLSAg ICBDR0NvbnRleHRSZXN0b3JlR1N0YXRlKGNvbnRleHQpOworICAgICAgICBzbnByaW50ZihoYXNo U3RyaW5nLCAzMywgIiVzJTAyeCIsIGhhc2hTdHJpbmcsIGhhc2hbaV0pOwogfQogCi12b2lkIGR1 bXBXZWJWaWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4cGVjdGVkKGNvbnN0IGNoYXIqIC8qY3Vy cmVudFRlc3QqLywgYm9vbCAvKmZvcmNlQWxsVGVzdHNUb0R1bXBQaXhlbHMqLykKK3ZvaWQgZHVt cFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0ZWQoY29uc3Qgc3RkOjpzdHJpbmcm IGV4cGVjdGVkSGFzaCkKIHsKLSAgICBSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPiBjb250ZXh0ID0g Z2V0Qml0bWFwQ29udGV4dEZyb21XZWJWaWV3KCk7Ci0KKyAgICBSZWZQdHI8Qml0bWFwQ29udGV4 dD4gY29udGV4dDsKKyAgICAKICNpZiBQTEFURk9STShNQUMpCi0gICAgaWYgKGdMYXlvdXRUZXN0 Q29udHJvbGxlci0+dGVzdFJlcGFpbnQoKSkKLSAgICAgICAgcmVwYWludFdlYlZpZXcoY29udGV4 dC5nZXQoKSwgZ0xheW91dFRlc3RDb250cm9sbGVyLT50ZXN0UmVwYWludFN3ZWVwSG9yaXpvbnRh bGx5KCkpOwotICAgIGVsc2UgCi0gICAgICAgIHBhaW50V2ViVmlldyhjb250ZXh0LmdldCgpKTsK LQotICAgIGlmIChnTGF5b3V0VGVzdENvbnRyb2xsZXItPmR1bXBTZWxlY3Rpb25SZWN0KCkpCi0g ICAgICAgIGRyYXdTZWxlY3Rpb25SZWN0KGNvbnRleHQuZ2V0KCksIGdldFNlbGVjdGlvblJlY3Qo KSk7CisgICAgY29udGV4dCA9IGNyZWF0ZUJpdG1hcENvbnRleHRGcm9tV2ViVmlldyhnTGF5b3V0 VGVzdENvbnRyb2xsZXItPnRlc3RPbnNjcmVlbigpLCBnTGF5b3V0VGVzdENvbnRyb2xsZXItPnRl c3RSZXBhaW50KCksIGdMYXlvdXRUZXN0Q29udHJvbGxlci0+dGVzdFJlcGFpbnRTd2VlcEhvcml6 b250YWxseSgpLCBnTGF5b3V0VGVzdENvbnRyb2xsZXItPmR1bXBTZWxlY3Rpb25SZWN0KCkpOwog I2VuZGlmCi0KLSAgICAvLyBDb21wdXRlIHRoZSBhY3R1YWwgaGFzaCB0byBjb21wYXJlIHRvIHRo ZSBleHBlY3RlZCBpbWFnZSdzIGhhc2guCisgICAgQVNTRVJUKGNvbnRleHQpOworICAgIAorICAg IC8vIENvbXB1dGUgdGhlIGhhc2ggb2YgdGhlIGJpdG1hcCBjb250ZXh0IHBpeGVscwogICAgIGNo YXIgYWN0dWFsSGFzaFszM107Ci0gICAgZ2V0TUQ1SGFzaFN0cmluZ0ZvckJpdG1hcChjb250ZXh0 LmdldCgpLCBhY3R1YWxIYXNoKTsKKyAgICBjb21wdXRlTUQ1SGFzaFN0cmluZ0ZvckJpdG1hcENv bnRleHQoY29udGV4dC0+Y2dDb250ZXh0KCksIGFjdHVhbEhhc2gpOwogICAgIHByaW50ZigiXG5B Y3R1YWxIYXNoOiAlc1xuIiwgYWN0dWFsSGFzaCk7Ci0KLSAgICAvLyBGSVhNRTogV2Ugc2hvdWxk IGNvbXBhcmUgdGhlIGFjdHVhbEhhc2ggdG8gdGhlIGV4cGVjdGVkIGhhc2ggaGVyZSBhbmQKLSAg ICAvLyBvbmx5IHNldCBkdW1wSW1hZ2UgdG8gdHJ1ZSBpZiB0aGV5IGRvbid0IG1hdGNoLCBidXQg RFJUIGRvZXNuJ3QgaGF2ZQotICAgIC8vIGVub3VnaCBpbmZvcm1hdGlvbiBjdXJyZW50bHkgdG8g ZmluZCB0aGUgZXhwZWN0ZWQgY2hlY2tzdW0gZmlsZS4KKyAgICAKKyAgICAvLyBDaGVjayB0aGUg Y29tcHV0ZWQgaGFzaCBhZ2FpbnN0IHRoZSBleHBlY3RlZCBvbmUgYW5kIGR1bXAgaW1hZ2Ugb24g bWlzbWF0Y2gKICAgICBib29sIGR1bXBJbWFnZSA9IHRydWU7Ci0KKyAgICBpZiAoZXhwZWN0ZWRI YXNoLmxlbmd0aCgpID4gMCkgeworICAgICAgICBBU1NFUlQoZXhwZWN0ZWRIYXNoLmxlbmd0aCgp ID09IDMyKTsKKyAgICAgICAgCisgICAgICAgIHByaW50ZigiXG5FeHBlY3RlZEhhc2g6ICVzXG4i LCBleHBlY3RlZEhhc2guY19zdHIoKSk7CisgICAgICAgIAorICAgICAgICBpZiAoZXhwZWN0ZWRI YXNoID09IGFjdHVhbEhhc2gpICAgICAvLyBGSVhNRTogZG8gY2FzZSBpbnNlbnNpdGl2ZSBjb21w YXJlCisgICAgICAgICAgICBkdW1wSW1hZ2UgPSBmYWxzZTsKKyAgICB9CisgICAgCiAgICAgaWYg KGR1bXBJbWFnZSkgewotICAgICAgICBSZXRhaW5QdHI8Q0dJbWFnZVJlZj4gaW1hZ2UoQWRvcHRD RiwgQ0dCaXRtYXBDb250ZXh0Q3JlYXRlSW1hZ2UoY29udGV4dC5nZXQoKSkpOworICAgICAgICBS ZXRhaW5QdHI8Q0dJbWFnZVJlZj4gaW1hZ2UoQWRvcHRDRiwgQ0dCaXRtYXBDb250ZXh0Q3JlYXRl SW1hZ2UoY29udGV4dC0+Y2dDb250ZXh0KCkpKTsKICAgICAgICAgcHJpbnRQTkcoaW1hZ2UuZ2V0 KCkpOwogICAgIH0KIH0KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2Nn L1BpeGVsRHVtcFN1cHBvcnRDRy5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvUGl4 ZWxEdW1wU3VwcG9ydENHLmgKaW5kZXggMGFiZGVhNi4uODQzNTBlOCAxMDA2NDQKLS0tIGEvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1wU3VwcG9ydENHLmgKKysrIGIvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1wU3VwcG9ydENHLmgKQEAgLTMxLDI1 ICszMSw1MCBAQAogI2lmbmRlZiBQaXhlbER1bXBTdXBwb3J0Q0dfaAogI2RlZmluZSBQaXhlbER1 bXBTdXBwb3J0Q0dfaAogCisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3 dGYvUmVmQ291bnRlZC5oPgogI2luY2x1ZGUgPHd0Zi9SZXRhaW5QdHIuaD4KIAotI2lmbmRlZiBD R0ZMT0FUX0RFRklORUQKLSNpZmRlZiBfX0xQNjRfXwotdHlwZWRlZiBkb3VibGUgQ0dGbG9hdDsK LSNlbHNlCi10eXBlZGVmIGZsb2F0IENHRmxvYXQ7Cit0eXBlZGVmIHN0cnVjdCBDR0NvbnRleHQq IENHQ29udGV4dFJlZjsKKworI2lmIFBMQVRGT1JNKE1BQykKK3R5cGVkZWYgdm9pZCogUGxhdGZv cm1CaXRtYXBCdWZmZXI7CisjZWxpZiBQTEFURk9STShXSU4pCit0eXBlZGVmIEhCSVRNQVAgUGxh dGZvcm1CaXRtYXBCdWZmZXI7CiAjZW5kaWYKLSNkZWZpbmUgQ0dGTE9BVF9ERUZJTkVEIDEKKwor Y2xhc3MgQml0bWFwQ29udGV4dCA6IHB1YmxpYyBSZWZDb3VudGVkPEJpdG1hcENvbnRleHQ+IHsK K3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxCaXRtYXBDb250ZXh0PiBjcmVhdGVCeUFk b3B0aW5nQml0bWFwQW5kQ29udGV4dChQbGF0Zm9ybUJpdG1hcEJ1ZmZlciBidWZmZXIsIENHQ29u dGV4dFJlZiBjb250ZXh0KQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBCaXRt YXBDb250ZXh0KGJ1ZmZlciwgY29udGV4dCkpOworICAgIH0KKworICAgIH5CaXRtYXBDb250ZXh0 KCkKKyAgICB7CisgICAgICAgIGlmIChtX2J1ZmZlcikKKyNpZiBQTEFURk9STShNQUMpCisgICAg ICAgICAgICBmcmVlKG1fYnVmZmVyKTsKKyNlbGlmIFBMQVRGT1JNKFdJTikKKyAgICAgICAgICAg IERlbGV0ZU9iamVjdChtX2J1ZmZlcik7CiAjZW5kaWYKKyAgICB9CiAKLXR5cGVkZWYgc3RydWN0 IENHQ29udGV4dCogQ0dDb250ZXh0UmVmOwotc3RydWN0IENHUmVjdDsKKyAgICBDR0NvbnRleHRS ZWYgY2dDb250ZXh0KCkgY29uc3QgeyByZXR1cm4gbV9jb250ZXh0LmdldCgpOyB9CisKK3ByaXZh dGU6CisKKyAgICBCaXRtYXBDb250ZXh0KFBsYXRmb3JtQml0bWFwQnVmZmVyIGJ1ZmZlciwgQ0dD b250ZXh0UmVmIGNvbnRleHQpCisgICAgICAgIDogbV9idWZmZXIoYnVmZmVyKQorICAgICAgICAs IG1fY29udGV4dChBZG9wdENGLCBjb250ZXh0KQorICAgIHsKKyAgICB9CisKKyAgICBQbGF0Zm9y bUJpdG1hcEJ1ZmZlciBtX2J1ZmZlcjsKKyAgICBSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPiBtX2Nv bnRleHQ7CiAKLVJldGFpblB0cjxDR0NvbnRleHRSZWY+IGdldEJpdG1hcENvbnRleHRGcm9tV2Vi VmlldygpOwotQ0dSZWN0IGdldFNlbGVjdGlvblJlY3QoKTsKK307CiAKLXZvaWQgcGFpbnRXZWJW aWV3KENHQ29udGV4dFJlZik7Ci12b2lkIHJlcGFpbnRXZWJWaWV3KENHQ29udGV4dFJlZiBjb250 ZXh0LCBib29sIGhvcml6b250YWwpOwotdm9pZCBkcmF3U2VsZWN0aW9uUmVjdChDR0NvbnRleHRS ZWYsIGNvbnN0IENHUmVjdCYpOworUGFzc1JlZlB0cjxCaXRtYXBDb250ZXh0PiBjcmVhdGVCaXRt YXBDb250ZXh0RnJvbVdlYlZpZXcoYm9vbCBvbnNjcmVlbiwgYm9vbCBpbmNyZW1lbnRhbFJlcGFp bnQsIGJvb2wgc3dlZXBIb3Jpem9udGFsbHksIGJvb2wgZHJhd1NlbGVjdGlvblJlY3QpOwogCiAj ZW5kaWYgLy8gUGl4ZWxEdW1wU3VwcG9ydENHX2gKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbSBiL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQppbmRleCBiZWNlOTA2Li41OTZiZjY5IDEwMDY0 NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0K KysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCkBA IC03NSwxMCArNzUsMTIgQEAKICNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4KICNpbXBvcnQgPHd0 Zi9Pd25QdHIuaD4KIAordXNpbmcgbmFtZXNwYWNlIHN0ZDsKKwogQGludGVyZmFjZSBEdW1wUmVu ZGVyVHJlZUV2ZW50IDogTlNFdmVudAogQGVuZAogCi1zdGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0 IGNoYXIgKnBhdGhPclVSTCk7CitzdGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0IHN0cmluZyYgdGVz dFBhdGhPclVSTCk7CiAKIC8vIERlY2lkaW5nIHdoZW4gaXQncyBPSyB0byBkdW1wIG91dCB0aGUg c3RhdGUgaXMgYSBiaXQgdHJpY2t5LiAgQWxsIHRoZXNlIG11c3QgYmUgdHJ1ZToKIC8vIC0gVGhl cmUgaXMgbm8gbG9hZCBpbiBwcm9ncmVzcwpAQCAtMTExLDE0ICsxMTMsMTAgQEAgc3RhdGljIFJl c291cmNlTG9hZERlbGVnYXRlICpyZXNvdXJjZUxvYWREZWxlZ2F0ZTsKIFBvbGljeURlbGVnYXRl ICpwb2xpY3lEZWxlZ2F0ZTsKIAogc3RhdGljIGludCBkdW1wUGl4ZWxzOwotc3RhdGljIGludCBk dW1wQWxsUGl4ZWxzOwogc3RhdGljIGludCB0aHJlYWRlZDsKLXN0YXRpYyBpbnQgdGVzdFJlcGFp bnREZWZhdWx0Owotc3RhdGljIGludCByZXBhaW50U3dlZXBIb3Jpem9udGFsbHlEZWZhdWx0Owog c3RhdGljIGludCBkdW1wVHJlZSA9IFlFUzsKIHN0YXRpYyBpbnQgZm9yY2VDb21wbGV4VGV4dDsK IHN0YXRpYyBCT09MIHByaW50U2VwYXJhdG9yczsKLXN0YXRpYyBOU1N0cmluZyAqY3VycmVudFRl c3QgPSBuaWw7CiBzdGF0aWMgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBwZXJzaXN0ZW50VXNlclN0 eWxlU2hlZXRMb2NhdGlvbjsKIAogc3RhdGljIFdlYkhpc3RvcnlJdGVtICpwcmV2VGVzdEJGSXRl bSA9IG5pbDsgIC8vIGN1cnJlbnQgYi9mIGl0ZW0gYXQgdGhlIGVuZCBvZiB0aGUgcHJldmlvdXMg dGVzdApAQCAtMTgxLDIxICsxNzksMjEgQEAgdm9pZCBzZXRQZXJzaXN0ZW50VXNlclN0eWxlU2hl ZXRMb2NhdGlvbihDRlN0cmluZ1JlZiB1cmwpCiAgICAgcGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0 TG9jYXRpb24gPSB1cmw7CiB9CiAKLXN0YXRpYyBCT09MIHNob3VsZElnbm9yZVdlYkNvcmVOb2Rl TGVha3MoQ0ZTdHJpbmdSZWYgVVJMU3RyaW5nKQorc3RhdGljIGJvb2wgc2hvdWxkSWdub3JlV2Vi Q29yZU5vZGVMZWFrcyhjb25zdCBzdHJpbmcmIFVSTFN0cmluZykKIHsKLSAgICBzdGF0aWMgQ0ZT dHJpbmdSZWYgY29uc3QgaWdub3JlU2V0W10gPSB7CisgICAgc3RhdGljIGNoYXIqIGNvbnN0IGln bm9yZVNldFtdID0gewogICAgICAgICAvLyBLZWVwaW5nIHRoaXMgaW5mcmFzdHJ1Y3R1cmUgYXJv dW5kIGluIGNhc2Ugd2UgZXZlciBuZWVkIGl0IGFnYWluLgogICAgIH07Ci0gICAgc3RhdGljIGNv bnN0IGludCBpZ25vcmVTZXRDb3VudCA9IHNpemVvZihpZ25vcmVTZXQpIC8gc2l6ZW9mKENGU3Ry aW5nUmVmKTsKKyAgICBzdGF0aWMgY29uc3QgaW50IGlnbm9yZVNldENvdW50ID0gc2l6ZW9mKGln bm9yZVNldCkgLyBzaXplb2YoY2hhciopOwogICAgIAogICAgIGZvciAoaW50IGkgPSAwOyBpIDwg aWdub3JlU2V0Q291bnQ7IGkrKykgewotICAgICAgICBDRlN0cmluZ1JlZiBpZ25vcmVTdHJpbmcg PSBpZ25vcmVTZXRbaV07Ci0gICAgICAgIENGUmFuZ2UgcmFuZ2UgPSBDRlJhbmdlTWFrZSgwLCBD RlN0cmluZ0dldExlbmd0aChVUkxTdHJpbmcpKTsKLSAgICAgICAgQ0ZPcHRpb25GbGFncyBmbGFn cyA9IGtDRkNvbXBhcmVBbmNob3JlZCB8IGtDRkNvbXBhcmVCYWNrd2FyZHMgfCBrQ0ZDb21wYXJl Q2FzZUluc2Vuc2l0aXZlOwotICAgICAgICBpZiAoQ0ZTdHJpbmdGaW5kV2l0aE9wdGlvbnMoVVJM U3RyaW5nLCBpZ25vcmVTdHJpbmcsIHJhbmdlLCBmbGFncywgTlVMTCkpCi0gICAgICAgICAgICBy ZXR1cm4gWUVTOworICAgICAgICAvLyBGSVhNRTogaWdub3JlIGNhc2UKKyAgICAgICAgc3RyaW5n IGN1cklnbm9yZShpZ25vcmVTZXRbaV0pOworICAgICAgICAvLyBNYXRjaCBhdCB0aGUgZW5kIG9m IHRoZSBVUkxTdHJpbmcKKyAgICAgICAgaWYgKCFVUkxTdHJpbmcuY29tcGFyZShVUkxTdHJpbmcu bGVuZ3RoKCkgLSBjdXJJZ25vcmUubGVuZ3RoKCksIGN1cklnbm9yZS5sZW5ndGgoKSwgY3VySWdu b3JlKSkKKyAgICAgICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KLSAgICByZXR1cm4gTk87Cisg ICAgcmV0dXJuIGZhbHNlOwogfQogCiBzdGF0aWMgdm9pZCBhY3RpdmF0ZUZvbnRzKCkKQEAgLTMw NywxMyArMzA1LDEzIEBAIHZvaWQgdGVzdFN0cmluZ0J5RXZhbHVhdGluZ0phdmFTY3JpcHRGcm9t U3RyaW5nKCkKIHN0YXRpYyB2b2lkIHNldERlZmF1bHRzVG9Db25zaXN0ZW50VmFsdWVzRm9yVGVz dGluZygpCiB7CiAgICAgLy8gR2l2ZSBzb21lIGNsZWFyIHRvIHVuZG9jdW1lbnRlZCBkZWZhdWx0 cyB2YWx1ZXMKLSAgICBzdGF0aWMgY29uc3QgaW50IE1lZGl1bUZvbnRTbW9vdGhpbmcgPSAyOwor ICAgIHN0YXRpYyBjb25zdCBpbnQgTm9Gb250U21vb3RoaW5nID0gMDsKICAgICBzdGF0aWMgY29u c3QgaW50IEJsdWVUaW50ZWRBcHBlYXJhbmNlID0gMTsKIAogICAgIE5TVXNlckRlZmF1bHRzICpk ZWZhdWx0cyA9IFtOU1VzZXJEZWZhdWx0cyBzdGFuZGFyZFVzZXJEZWZhdWx0c107CiAgICAgW2Rl ZmF1bHRzIHNldE9iamVjdDpAIkRvdWJsZU1heCIgZm9yS2V5OkAiQXBwbGVTY3JvbGxCYXJWYXJp YW50Il07CiAgICAgW2RlZmF1bHRzIHNldEludGVnZXI6NCBmb3JLZXk6QCJBcHBsZUFudGlBbGlh c2luZ1RocmVzaG9sZCJdOyAvLyBzbWFsbGVzdCBmb250IHNpemUgdG8gQ0cgc2hvdWxkIHBlcmZv cm0gYW50aWFsaWFzaW5nIG9uCi0gICAgW2RlZmF1bHRzIHNldEludGVnZXI6TWVkaXVtRm9udFNt b290aGluZyBmb3JLZXk6QCJBcHBsZUZvbnRTbW9vdGhpbmciXTsKKyAgICBbZGVmYXVsdHMgc2V0 SW50ZWdlcjpOb0ZvbnRTbW9vdGhpbmcgZm9yS2V5OkAiQXBwbGVGb250U21vb3RoaW5nIl07CiAg ICAgW2RlZmF1bHRzIHNldEludGVnZXI6Qmx1ZVRpbnRlZEFwcGVhcmFuY2UgZm9yS2V5OkAiQXBw bGVBcXVhQ29sb3JWYXJpYW50Il07CiAgICAgW2RlZmF1bHRzIHNldE9iamVjdDpAIjAuNzA5ODAw IDAuODM1MzAwIDEuMDAwMDAwIiBmb3JLZXk6QCJBcHBsZUhpZ2hsaWdodENvbG9yIl07CiAgICAg W2RlZmF1bHRzIHNldE9iamVjdDpAIjAuNTAwMDAwIDAuNTAwMDAwIDAuNTAwMDAwIiBmb3JLZXk6 QCJBcHBsZU90aGVySGlnaGxpZ2h0Q29sb3IiXTsKQEAgLTM1MCw3ICszNDgsNyBAQCBzdGF0aWMg dm9pZCBjcmFzaEhhbmRsZXIoaW50IHNpZykKICAgICBjaGFyICpzaWduYWxOYW1lID0gc3Ryc2ln bmFsKHNpZyk7CiAgICAgd3JpdGUoU1RERVJSX0ZJTEVOTywgc2lnbmFsTmFtZSwgc3RybGVuKHNp Z25hbE5hbWUpKTsKICAgICB3cml0ZShTVERFUlJfRklMRU5PLCAiXG4iLCAxKTsKLSAgICByZXN0 b3JlQ29sb3JTcGFjZSgwKTsKKyAgICByZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUoMCk7 CiAgICAgZXhpdCgxMjggKyBzaWcpOwogfQogCkBAIC0zOTksMTEgKzM5Nyw4IEBAIHN0YXRpYyB2 b2lkIHJlbGVhc2VHbG9iYWxDb250cm9sbGVycygpCiBzdGF0aWMgdm9pZCBpbml0aWFsaXplR2xv YmFsc0Zyb21Db21tYW5kTGluZU9wdGlvbnMoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKmFyZ3ZbXSkK IHsKICAgICBzdHJ1Y3Qgb3B0aW9uIG9wdGlvbnNbXSA9IHsKLSAgICAgICAgeyJkdW1wLWFsbC1w aXhlbHMiLCBub19hcmd1bWVudCwgJmR1bXBBbGxQaXhlbHMsIFlFU30sCi0gICAgICAgIHsiaG9y aXpvbnRhbC1zd2VlcCIsIG5vX2FyZ3VtZW50LCAmcmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5RGVm YXVsdCwgWUVTfSwKICAgICAgICAgeyJub3RyZWUiLCBub19hcmd1bWVudCwgJmR1bXBUcmVlLCBO T30sCiAgICAgICAgIHsicGl4ZWwtdGVzdHMiLCBub19hcmd1bWVudCwgJmR1bXBQaXhlbHMsIFlF U30sCi0gICAgICAgIHsicmVwYWludCIsIG5vX2FyZ3VtZW50LCAmdGVzdFJlcGFpbnREZWZhdWx0 LCBZRVN9LAogICAgICAgICB7InRyZWUiLCBub19hcmd1bWVudCwgJmR1bXBUcmVlLCBZRVN9LAog ICAgICAgICB7InRocmVhZGVkIiwgbm9fYXJndW1lbnQsICZ0aHJlYWRlZCwgWUVTfSwKICAgICAg ICAgeyJjb21wbGV4LXRleHQiLCBub19hcmd1bWVudCwgJmZvcmNlQ29tcGxleFRleHQsIFlFU30s CkBAIC00NjAsNyArNDU1LDcgQEAgc3RhdGljIHZvaWQgcHJlcGFyZUNvbnNpc3RlbnRUZXN0aW5n RW52aXJvbm1lbnQoKQogICAgIGFjdGl2YXRlRm9udHMoKTsKICAgICAKICAgICBpZiAoZHVtcFBp eGVscykKLSAgICAgICAgaW5pdGlhbGl6ZUNvbG9yU3BhY2VBbmRTY3JlZUJ1ZmZlckZvclBpeGVs VGVzdHMoKTsKKyAgICAgICAgc2V0dXBNYWluRGlzcGxheUNvbG9yUHJvZmlsZSgpOwogICAgIGFs bG9jYXRlR2xvYmFsQ29udHJvbGxlcnMoKTsKICAgICAKICAgICBtYWtlTGFyZ2VNYWxsb2NGYWls U2lsZW50bHkoKTsKQEAgLTUyNiw3ICs1MjEsNyBAQCB2b2lkIGR1bXBSZW5kZXJUcmVlKGludCBh cmdjLCBjb25zdCBjaGFyICphcmd2W10pCiAgICAgfQogCiAgICAgaWYgKGR1bXBQaXhlbHMpCi0g ICAgICAgIHJlc3RvcmVDb2xvclNwYWNlKDApOworICAgICAgICByZXN0b3JlTWFpbkRpc3BsYXlD b2xvclByb2ZpbGUoMCk7CiB9CiAKIGludCBtYWluKGludCBhcmdjLCBjb25zdCBjaGFyICphcmd2 W10pCkBAIC04MjEsNyArODE2LDcgQEAgc3RhdGljIHZvaWQgZHVtcEJhY2tGb3J3YXJkTGlzdEZv cldlYlZpZXcoV2ViVmlldyAqdmlldykKIHN0YXRpYyB2b2lkIHNpemVXZWJWaWV3Rm9yQ3VycmVu dFRlc3QoKQogewogICAgIC8vIFczQyBTVkcgdGVzdHMgZXhwZWN0IHRvIGJlIDQ4MHgzNjAKLSAg ICBib29sIGlzU1ZHVzNDVGVzdCA9IChbY3VycmVudFRlc3QgcmFuZ2VPZlN0cmluZzpAInN2Zy9X M0MtU1ZHLTEuMSJdLmxlbmd0aCk7CisgICAgYm9vbCBpc1NWR1czQ1Rlc3QgPSAoZ0xheW91dFRl c3RDb250cm9sbGVyLT50ZXN0UGF0aE9yVVJMKCkuZmluZCgic3ZnL1czQy1TVkctMS4xIikgIT0g c3RyaW5nOjpucG9zKTsKICAgICBpZiAoaXNTVkdXM0NUZXN0KQogICAgICAgICBbW21haW5GcmFt ZSB3ZWJWaWV3XSBzZXRGcmFtZVNpemU6TlNNYWtlU2l6ZSg0ODAsIDM2MCldOwogICAgIGVsc2UK QEAgLTkxNSw4ICs5MTAsOCBAQCB2b2lkIGR1bXAoKQogICAgICAgICB9ICAgICAgICAgICAgCiAg ICAgfQogICAgIAotICAgIGlmIChkdW1wQWxsUGl4ZWxzIHx8IChkdW1wUGl4ZWxzICYmICFkdW1w QXNUZXh0KSkKLSAgICAgICAgZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0 ZWQoW2N1cnJlbnRUZXN0IFVURjhTdHJpbmddLCBkdW1wQWxsUGl4ZWxzKTsKKyAgICBpZiAoZHVt cFBpeGVscyAmJiAhZHVtcEFzVGV4dCkKKyAgICAgICAgZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENv bXBhcmVXaXRoRXhwZWN0ZWQoZ0xheW91dFRlc3RDb250cm9sbGVyLT5leHBlY3RlZFBpeGVsSGFz aCgpKTsKICAgICAKICAgICBwdXRzKCIjRU9GIik7ICAgLy8gdGVybWluYXRlIHRoZSAocG9zc2li bHkgZW1wdHkpIHBpeGVscyBibG9jawogCkBAIC05MzEsMTYgKzkyNiw2IEBAIHN0YXRpYyBib29s IHNob3VsZExvZ0ZyYW1lTG9hZERlbGVnYXRlcyhjb25zdCBjaGFyICpwYXRoT3JVUkwpCiAgICAg cmV0dXJuIHN0cnN0cihwYXRoT3JVUkwsICJsb2FkaW5nLyIpOwogfQogCi1zdGF0aWMgQ0ZVUkxS ZWYgY3JlYXRlQ0ZVUkxGcm9tUGF0aE9yVVJMKENGU3RyaW5nUmVmIHBhdGhPclVSTFN0cmluZykK LXsKLSAgICBDRlVSTFJlZiBVUkw7Ci0gICAgaWYgKENGU3RyaW5nSGFzUHJlZml4KHBhdGhPclVS TFN0cmluZywgQ0ZTVFIoImh0dHA6Ly8iKSkgfHwgQ0ZTdHJpbmdIYXNQcmVmaXgocGF0aE9yVVJM U3RyaW5nLCBDRlNUUigiaHR0cHM6Ly8iKSkpCi0gICAgICAgIFVSTCA9IENGVVJMQ3JlYXRlV2l0 aFN0cmluZyhOVUxMLCBwYXRoT3JVUkxTdHJpbmcsIE5VTEwpOwotICAgIGVsc2UKLSAgICAgICAg VVJMID0gQ0ZVUkxDcmVhdGVXaXRoRmlsZVN5c3RlbVBhdGgoTlVMTCwgcGF0aE9yVVJMU3RyaW5n LCBrQ0ZVUkxQT1NJWFBhdGhTdHlsZSwgRkFMU0UpOwotICAgIHJldHVybiBVUkw7Ci19Ci0KIHN0 YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGluZygpCiB7 CiAgICAgV2ViVmlldyAqd2ViVmlldyA9IFttYWluRnJhbWUgd2ViVmlld107CkBAIC05NjksMzAg Kzk1NCw0NyBAQCBzdGF0aWMgdm9pZCByZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0ZUJlZm9y ZVRlc3RpbmcoKQogICAgIFtXZWJWaWV3IF9zZXRVc2VzVGVzdE1vZGVGb2N1c1JpbmdDb2xvcjpZ RVNdOwogfQogCi1zdGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0IGNoYXIgKnBhdGhPclVSTCkKK3N0 YXRpYyB2b2lkIHJ1blRlc3QoY29uc3Qgc3RyaW5nJiB0ZXN0UGF0aE9yVVJMKQogewotICAgIENG U3RyaW5nUmVmIHBhdGhPclVSTFN0cmluZyA9IENGU3RyaW5nQ3JlYXRlV2l0aENTdHJpbmcoTlVM TCwgcGF0aE9yVVJMLCBrQ0ZTdHJpbmdFbmNvZGluZ1VURjgpOworICAgIEFTU0VSVCghdGVzdFBh dGhPclVSTC5lbXB0eSgpKTsKKyAgICAKKyAgICAvLyBMb29rIGZvciAiJyIgYXMgYSBzZXBhcmF0 b3IgYmV0d2VlbiB0aGUgcGF0aCBvciBVUkwsIGFuZCB0aGUgcGl4ZWwgZHVtcCBoYXNoIHRoYXQg Zm9sbG93cy4KKyAgICBzdHJpbmcgcGF0aE9yVVJMKHRlc3RQYXRoT3JVUkwpOworICAgIHN0cmlu ZyBleHBlY3RlZFBpeGVsSGFzaDsKKyAgICAKKyAgICBzaXplX3Qgc2VwYXJhdG9yUG9zID0gcGF0 aE9yVVJMLmZpbmQoIiciKTsKKyAgICBpZiAoc2VwYXJhdG9yUG9zICE9IHN0cmluZzo6bnBvcykg eworICAgICAgICBwYXRoT3JVUkwgPSBzdHJpbmcodGVzdFBhdGhPclVSTCwgMCwgc2VwYXJhdG9y UG9zKTsKKyAgICAgICAgZXhwZWN0ZWRQaXhlbEhhc2ggPSBzdHJpbmcodGVzdFBhdGhPclVSTCwg c2VwYXJhdG9yUG9zICsgMSk7CisgICAgfQorCisgICAgTlNTdHJpbmcgKnBhdGhPclVSTFN0cmlu ZyA9IFtOU1N0cmluZyBzdHJpbmdXaXRoVVRGOFN0cmluZzpwYXRoT3JVUkwuY19zdHIoKV07CiAg ICAgaWYgKCFwYXRoT3JVUkxTdHJpbmcpIHsKLSAgICAgICAgZnByaW50ZihzdGRlcnIsICJGYWls ZWQgdG8gcGFyc2UgZmlsZW5hbWUgYXMgVVRGLTg6ICVzXG4iLCBwYXRoT3JVUkwpOworICAgICAg ICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byBwYXJzZSBcIiVzXCIgYXMgVVRGLThcbiIsIHBh dGhPclVSTC5jX3N0cigpKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAgIENGVVJMUmVm IFVSTCA9IGNyZWF0ZUNGVVJMRnJvbVBhdGhPclVSTChwYXRoT3JVUkxTdHJpbmcpOwotICAgIGlm ICghVVJMKSB7Ci0gICAgICAgIENGUmVsZWFzZShwYXRoT3JVUkxTdHJpbmcpOwotICAgICAgICBm cHJpbnRmKHN0ZGVyciwgIkNhbid0IHR1cm4gJXMgaW50byBhIENGVVJMXG4iLCBwYXRoT3JVUkwp OworICAgIE5TVVJMICp1cmw7CisgICAgaWYgKFtwYXRoT3JVUkxTdHJpbmcgaGFzUHJlZml4OkAi aHR0cDovLyJdIHx8IFtwYXRoT3JVUkxTdHJpbmcgaGFzUHJlZml4OkAiaHR0cHM6Ly8iXSkKKyAg ICAgICAgdXJsID0gW05TVVJMIFVSTFdpdGhTdHJpbmc6cGF0aE9yVVJMU3RyaW5nXTsKKyAgICBl bHNlCisgICAgICAgIHVybCA9IFtOU1VSTCBmaWxlVVJMV2l0aFBhdGg6cGF0aE9yVVJMU3RyaW5n XTsKKyAgICBpZiAoIXVybCkgeworICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byBw YXJzZSBcIiVzXCIgYXMgYSBVUkxcbiIsIHBhdGhPclVSTC5jX3N0cigpKTsKICAgICAgICAgcmV0 dXJuOwogICAgIH0KIAorICAgIGNvbnN0IHN0cmluZyB0ZXN0VVJMKFtbdXJsIGFic29sdXRlU3Ry aW5nXSBVVEY4U3RyaW5nXSk7CisgICAgCiAgICAgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3Rh dGVCZWZvcmVUZXN0aW5nKCk7CiAKLSAgICBnTGF5b3V0VGVzdENvbnRyb2xsZXIgPSBuZXcgTGF5 b3V0VGVzdENvbnRyb2xsZXIodGVzdFJlcGFpbnREZWZhdWx0LCByZXBhaW50U3dlZXBIb3Jpem9u dGFsbHlEZWZhdWx0KTsKKyAgICBnTGF5b3V0VGVzdENvbnRyb2xsZXIgPSBuZXcgTGF5b3V0VGVz dENvbnRyb2xsZXIodGVzdFVSTCwgZXhwZWN0ZWRQaXhlbEhhc2gpOwogICAgIHRvcExvYWRpbmdG cmFtZSA9IG5pbDsKICAgICBkb25lID0gTk87CiAKICAgICBpZiAoZGlzYWxsb3dlZFVSTHMpCiAg ICAgICAgIENGU2V0UmVtb3ZlQWxsVmFsdWVzKGRpc2FsbG93ZWRVUkxzKTsKLSAgICBpZiAoc2hv dWxkTG9nRnJhbWVMb2FkRGVsZWdhdGVzKHBhdGhPclVSTCkpCisgICAgaWYgKHNob3VsZExvZ0Zy YW1lTG9hZERlbGVnYXRlcyhwYXRoT3JVUkwuY19zdHIoKSkpCiAgICAgICAgIGdMYXlvdXRUZXN0 Q29udHJvbGxlci0+c2V0RHVtcEZyYW1lTG9hZENhbGxiYWNrcyh0cnVlKTsKIAogICAgIGlmIChb V2ViSGlzdG9yeSBvcHRpb25hbFNoYXJlZEhpc3RvcnldKQpAQCAtMTAwMCwyMiArMTAwMiwxOCBA QCBzdGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0IGNoYXIgKnBhdGhPclVSTCkKICAgICBsYXN0TW91 c2VQb3NpdGlvbiA9IE5TWmVyb1BvaW50OwogICAgIGxhc3RDbGlja1Bvc2l0aW9uID0gTlNaZXJv UG9pbnQ7CiAKLSAgICBpZiAoY3VycmVudFRlc3QgIT0gbmlsKQotICAgICAgICBDRlJlbGVhc2Uo Y3VycmVudFRlc3QpOwotICAgIGN1cnJlbnRUZXN0ID0gKE5TU3RyaW5nICopcGF0aE9yVVJMU3Ry aW5nOwogICAgIFtwcmV2VGVzdEJGSXRlbSByZWxlYXNlXTsKICAgICBwcmV2VGVzdEJGSXRlbSA9 IFtbW1ttYWluRnJhbWUgd2ViVmlld10gYmFja0ZvcndhcmRMaXN0XSBjdXJyZW50SXRlbV0gcmV0 YWluXTsKIAogICAgIFdvcmtRdWV1ZTo6c2hhcmVkKCktPmNsZWFyKCk7CiAgICAgV29ya1F1ZXVl OjpzaGFyZWQoKS0+c2V0RnJvemVuKGZhbHNlKTsKIAotICAgIEJPT0wgX3Nob3VsZElnbm9yZVdl YkNvcmVOb2RlTGVha3MgPSBzaG91bGRJZ25vcmVXZWJDb3JlTm9kZUxlYWtzKENGVVJMR2V0U3Ry aW5nKFVSTCkpOwotICAgIGlmIChfc2hvdWxkSWdub3JlV2ViQ29yZU5vZGVMZWFrcykKKyAgICBi b29sIGlnbm9yZVdlYkNvcmVOb2RlTGVha3MgPSBzaG91bGRJZ25vcmVXZWJDb3JlTm9kZUxlYWtz KHRlc3RVUkwpOworICAgIGlmIChpZ25vcmVXZWJDb3JlTm9kZUxlYWtzKQogICAgICAgICBbV2Vi Q29yZVN0YXRpc3RpY3Mgc3RhcnRJZ25vcmluZ1dlYkNvcmVOb2RlTGVha3NdOwogCiAgICAgTlNB dXRvcmVsZWFzZVBvb2wgKnBvb2wgPSBbW05TQXV0b3JlbGVhc2VQb29sIGFsbG9jXSBpbml0XTsK LSAgICBbbWFpbkZyYW1lIGxvYWRSZXF1ZXN0OltOU1VSTFJlcXVlc3QgcmVxdWVzdFdpdGhVUkw6 KE5TVVJMICopVVJMXV07Ci0gICAgQ0ZSZWxlYXNlKFVSTCk7CisgICAgW21haW5GcmFtZSBsb2Fk UmVxdWVzdDpbTlNVUkxSZXF1ZXN0IHJlcXVlc3RXaXRoVVJMOnVybF1dOwogICAgIFtwb29sIHJl bGVhc2VdOwogICAgIHdoaWxlICghZG9uZSkgewogICAgICAgICBwb29sID0gW1tOU0F1dG9yZWxl YXNlUG9vbCBhbGxvY10gaW5pdF07CkBAIC0xMDU4LDcgKzEwNTYsNyBAQCBzdGF0aWMgdm9pZCBy dW5UZXN0KGNvbnN0IGNoYXIgKnBhdGhPclVSTCkKICAgICBnTGF5b3V0VGVzdENvbnRyb2xsZXIt PmRlcmVmKCk7CiAgICAgZ0xheW91dFRlc3RDb250cm9sbGVyID0gMDsKIAotICAgIGlmIChfc2hv dWxkSWdub3JlV2ViQ29yZU5vZGVMZWFrcykKKyAgICBpZiAoaWdub3JlV2ViQ29yZU5vZGVMZWFr cykKICAgICAgICAgW1dlYkNvcmVTdGF0aXN0aWNzIHN0b3BJZ25vcmluZ1dlYkNvcmVOb2RlTGVh a3NdOwogfQogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvUGl4 ZWxEdW1wU3VwcG9ydE1hYy5tbSBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9QaXhl bER1bXBTdXBwb3J0TWFjLm1tCmluZGV4IDlkZGJhMzEuLmViMjlmZmEgMTAwNjQ0Ci0tLSBhL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9QaXhlbER1bXBTdXBwb3J0TWFjLm1tCisrKyBi L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9QaXhlbER1bXBTdXBwb3J0TWFjLm1tCkBA IC0zNCwxNTMgKzM0LDIyMSBAQAogCiAjaW5jbHVkZSAiTGF5b3V0VGVzdENvbnRyb2xsZXIuaCIK ICNpbmNsdWRlIDxDb3JlR3JhcGhpY3MvQ0dCaXRtYXBDb250ZXh0Lmg+CisjaWZuZGVmIEJVSUxE SU5HX09OX0xFT1BBUkQKKyNpbmNsdWRlIDxPcGVuR0wvT3BlbkdMLmg+CisjaW5jbHVkZSA8T3Bl bkdML0NHTE1hY3JvLmg+CisjZW5kaWYKICNpbmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgotI2lu Y2x1ZGUgPHd0Zi9SZXRhaW5QdHIuaD4KKyNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CiAKICNpbXBv cnQgPFdlYktpdC9XZWJEb2N1bWVudFByaXZhdGUuaD4KICNpbXBvcnQgPFdlYktpdC9XZWJLaXQu aD4KIAotc3RhdGljIHVuc2lnbmVkIGNoYXIqIHNjcmVlbkNhcHR1cmVCdWZmZXI7CisvLyBUbyBl bnN1cmUgcGl4ZWwgdGVzdHMgY29uc2lzdGVuY3ksIHdlIG5lZWQgdG8gYWx3YXlzIHJlbmRlciBp biB0aGUgc2FtZSBjb2xvcnNwYWNlLgorLy8gVW5mb3J0dW5hdGVseSwgYmVjYXVzZSBvZiBBcHBL aXQgLyBXZWJLaXQgY29uc3RyYWludHMsIHdlIGNhbid0IHJlbmRlciBkaXJlY3RseSBpbiB0aGUg Y29sb3JzcGFjZSBvZiBvdXIgY2hvaWNlLgorLy8gVGhpcyBpbXBsaWVzIHdlIGhhdmUgdG8gdGVt cG9yYXJpbHkgY2hhbmdlIHRoZSBwcm9maWxlIG9mIHRoZSBtYWluIGRpc3BsYXkgdG8gdGhlIGNv bG9yc3BhY2Ugd2Ugd2FudCB0byByZW5kZXIgaW50by4KKy8vIFdlIGFsc28gbmVlZCB0byBtYWtl IHN1cmUgdGhlIENHQml0bWFwQ29udGV4dCB3ZSByZXR1cm4gaXMgaW4gdGhhdCBzYW1lIGNvbG9y c3BhY2UuCiAKLXN0YXRpYyBib29sIGNoYW5nZWRDb2xvclByb2ZpbGUgPSBmYWxzZTsKLXN0YXRp YyBDTVByb2ZpbGVMb2NhdGlvbiBjdXJyZW50Q29sb3JQcm9maWxlTG9jYXRpb247Ci1zdGF0aWMg Q0dDb2xvclNwYWNlUmVmIHNoYXJlZENvbG9yU3BhY2U7CisjZGVmaW5lIFBST0ZJTEVfUEFUSCAi L1N5c3RlbS9MaWJyYXJ5L0NvbG9yU3luYy9Qcm9maWxlcy9HZW5lcmljIFJHQiBQcm9maWxlLmlj YyIgLy8gRklYTUU6IFNob3VsZCB3ZSBiZSB1c2luZyAiL1N5c3RlbS9MaWJyYXJ5L0NvbG9yU3lu Yy9Qcm9maWxlcy9zUkdCIFByb2ZpbGUuaWNjIj8KIAotdm9pZCByZXN0b3JlQ29sb3JTcGFjZShp bnQgaWdub3JlZCkKK3N0YXRpYyBDTVByb2ZpbGVMb2NhdGlvbiBzSW5pdGlhbFByb2ZpbGVMb2Nh dGlvbjsgLy8gVGhlIGxvY1R5cGUgZmllbGQgaXMgaW5pdGlhbGl6ZWQgdG8gMCB3aGljaCBpcyB0 aGUgc2FtZSBhcyBjbU5vUHJvZmlsZUJhc2UKKwordm9pZCByZXN0b3JlTWFpbkRpc3BsYXlDb2xv clByb2ZpbGUoaW50IGlnbm9yZWQpCiB7CiAgICAgLy8gVGhpcyBpcyB1c2VkIGFzIGEgc2lnbmFs IGhhbmRsZXIsIGFuZCB0aHVzIHRoZSBjYWxscyBpbnRvIENvbG9yU3luYyBhcmUgdW5zYWZlCiAg ICAgLy8gQnV0IHdlIG1pZ2h0IGFzIHdlbGwgdHJ5IHRvIHJlc3RvcmUgdGhlIHVzZXIncyBjb2xv ciBwcm9maWxlLCB3ZSdyZSBnb2luZyBkb3duIGFueXdheS4uLgotICAgIGlmIChjaGFuZ2VkQ29s b3JQcm9maWxlKSB7Ci0gICAgICAgIENNRGV2aWNlU2NvcGUgc2NvcGUgPSB7IGtDRlByZWZlcmVu Y2VzQ3VycmVudFVzZXIsIGtDRlByZWZlcmVuY2VzQ3VycmVudEhvc3QgfTsKLSAgICAgICAgaW50 IGVycm9yID0gQ01TZXREZXZpY2VQcm9maWxlKGNtRGlzcGxheURldmljZUNsYXNzLCBjbURlZmF1 bHREZXZpY2VJRCwgJnNjb3BlLCBjbURlZmF1bHRQcm9maWxlSUQsICZjdXJyZW50Q29sb3JQcm9m aWxlTG9jYXRpb24pOworICAgIGlmIChzSW5pdGlhbFByb2ZpbGVMb2NhdGlvbi5sb2NUeXBlICE9 IGNtTm9Qcm9maWxlQmFzZSkgeworICAgICAgICBjb25zdCBDTURldmljZVNjb3BlIHNjb3BlID0g eyBrQ0ZQcmVmZXJlbmNlc0N1cnJlbnRVc2VyLCBrQ0ZQcmVmZXJlbmNlc0N1cnJlbnRIb3N0IH07 CisgICAgICAgIGludCBlcnJvciA9IENNU2V0RGV2aWNlUHJvZmlsZShjbURpc3BsYXlEZXZpY2VD bGFzcywgKENNRGV2aWNlSUQpa0NHRGlyZWN0TWFpbkRpc3BsYXksICZzY29wZSwgY21EZWZhdWx0 UHJvZmlsZUlELCAmc0luaXRpYWxQcm9maWxlTG9jYXRpb24pOwogICAgICAgICBpZiAoZXJyb3Ip Ci0gICAgICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byByZXRvcmUgcHJldmlvdXMg Y29sb3IgcHJvZmlsZSEgIFlvdSBtYXkgbmVlZCB0byBvcGVuIFN5c3RlbSBQcmVmZXJlbmNlcyA6 IERpc3BsYXlzIDogQ29sb3IgYW5kIG1hbnVhbGx5IHJlc3RvcmUgeW91ciBjb2xvciBzZXR0aW5n cy4gIChFcnJvcjogJWkpIiwgZXJyb3IpOwotICAgICAgICBjaGFuZ2VkQ29sb3JQcm9maWxlID0g ZmFsc2U7CisgICAgICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byByZXN0b3JlIGlu aXRpYWwgY29sb3IgcHJvZmlsZSBmb3IgbWFpbiBkaXNwbGF5ISBPcGVuIFN5c3RlbSBQcmVmZXJl bmNlcyA+IERpc3BsYXlzID4gQ29sb3IgYW5kIG1hbnVhbGx5IHJlLXNlbGVjdCB0aGUgcHJvZmls ZS4gIChFcnJvcjogJWkpIiwgZXJyb3IpOworICAgICAgICBzSW5pdGlhbFByb2ZpbGVMb2NhdGlv bi5sb2NUeXBlID0gY21Ob1Byb2ZpbGVCYXNlOwogICAgIH0KIH0KIAotc3RhdGljIHZvaWQgZmFp bGVkR2V0dGluZ0N1cnJlbnRQcm9maWxlKGludCBlcnJvcikKK3ZvaWQgc2V0dXBNYWluRGlzcGxh eUNvbG9yUHJvZmlsZSgpCiB7Ci0gICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gZ2V0IGN1 cnJlbnQgY29sb3IgcHJvZmlsZS4gIEkgd2lsbCBub3QgYmUgYWJsZSB0byByZXN0b3JlIHlvdXIg Y3VycmVudCBwcm9maWxlLCB0aHVzIEknbSBub3QgY2hhbmdpbmcgaXQuICBNYW55IHBpeGVsIHRl c3RzIG1heSBmYWlsIGFzIGEgcmVzdWx0LiAgKEVycm9yOiAlaSlcbiIsIGVycm9yKTsKLX0KLQot c3RhdGljIHZvaWQgc2V0RGVmYXVsdENvbG9yUHJvZmlsZVRvUkdCKCkKLXsKLSAgICBDTVByb2Zp bGVSZWYgZ2VuZXJpY1Byb2ZpbGUgPSAoQ01Qcm9maWxlUmVmKVtbTlNDb2xvclNwYWNlIGdlbmVy aWNSR0JDb2xvclNwYWNlXSBjb2xvclN5bmNQcm9maWxlXTsKLSAgICBDTVByb2ZpbGVMb2NhdGlv biBnZW5lcmljUHJvZmlsZUxvY2F0aW9uOwotICAgIFVJbnQzMiBsb2NhdGlvblNpemUgPSBzaXpl b2YoZ2VuZXJpY1Byb2ZpbGVMb2NhdGlvbik7Ci0gICAgaW50IGVycm9yID0gTkNNR2V0UHJvZmls ZUxvY2F0aW9uKGdlbmVyaWNQcm9maWxlLCAmZ2VuZXJpY1Byb2ZpbGVMb2NhdGlvbiwgJmxvY2F0 aW9uU2l6ZSk7Ci0gICAgaWYgKGVycm9yKSB7Ci0gICAgICAgIGZhaWxlZEdldHRpbmdDdXJyZW50 UHJvZmlsZShlcnJvcik7Ci0gICAgICAgIHJldHVybjsKKyAgICBjb25zdCBDTURldmljZVNjb3Bl IHNjb3BlID0geyBrQ0ZQcmVmZXJlbmNlc0N1cnJlbnRVc2VyLCBrQ0ZQcmVmZXJlbmNlc0N1cnJl bnRIb3N0IH07CisgICAgaW50IGVycm9yOworICAgIAorICAgIENNUHJvZmlsZVJlZiBwcm9maWxl ID0gMDsKKyAgICBlcnJvciA9IENNR2V0UHJvZmlsZUJ5QVZJRCgoQ01EaXNwbGF5SURUeXBlKWtD R0RpcmVjdE1haW5EaXNwbGF5LCAmcHJvZmlsZSk7CisgICAgaWYgKCFlcnJvcikgeworICAgICAg ICBVSW50MzIgc2l6ZSA9IHNpemVvZihDTVByb2ZpbGVMb2NhdGlvbik7CisgICAgICAgIGVycm9y ID0gTkNNR2V0UHJvZmlsZUxvY2F0aW9uKHByb2ZpbGUsICZzSW5pdGlhbFByb2ZpbGVMb2NhdGlv biwgJnNpemUpOworICAgICAgICBDTUNsb3NlUHJvZmlsZShwcm9maWxlKTsKICAgICB9Ci0KLSAg ICBDTVByb2ZpbGVMb2NhdGlvbiBwcmV2aW91c1Byb2ZpbGVMb2NhdGlvbjsKLSAgICBlcnJvciA9 IENNR2V0RGV2aWNlUHJvZmlsZShjbURpc3BsYXlEZXZpY2VDbGFzcywgY21EZWZhdWx0RGV2aWNl SUQsIGNtRGVmYXVsdFByb2ZpbGVJRCwgJnByZXZpb3VzUHJvZmlsZUxvY2F0aW9uKTsKICAgICBp ZiAoZXJyb3IpIHsKLSAgICAgICAgZmFpbGVkR2V0dGluZ0N1cnJlbnRQcm9maWxlKGVycm9yKTsK KyAgICAgICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gcmV0cmlldmUgY3VycmVudCBjb2xv ciBwcm9maWxlIGZvciBtYWluIGRpc3BsYXksIHRodXMgaXQgd29uJ3QgYmUgY2hhbmdlZC4gIE1h bnkgcGl4ZWwgdGVzdHMgbWF5IGZhaWwgYXMgYSByZXN1bHQuICAoRXJyb3I6ICVpKSIsIGVycm9y KTsKKyAgICAgICAgc0luaXRpYWxQcm9maWxlTG9jYXRpb24ubG9jVHlwZSA9IGNtTm9Qcm9maWxl QmFzZTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KKyAgICAKKyAgICBDTVByb2ZpbGVMb2NhdGlv biBsb2NhdGlvbjsKKyAgICBsb2NhdGlvbi5sb2NUeXBlID0gY21GaWxlQmFzZWRQcm9maWxlOwor ICAgIE5TVVJMICp1cmwgPSBbTlNVUkwgZmlsZVVSTFdpdGhQYXRoOltOU1N0cmluZyBzdHJpbmdX aXRoVVRGOFN0cmluZzpQUk9GSUxFX1BBVEhdXTsKKyAgICBGU1JlZiBmc1JlZjsKKyAgICBpZiAo dXJsICYmIENGVVJMR2V0RlNSZWYoKENGVVJMUmVmKXVybCwgJmZzUmVmKSkgeworICAgICAgICBl cnJvciA9IEZTR2V0Q2F0YWxvZ0luZm8oJmZzUmVmLCAwLCAwLCAwLCAmbG9jYXRpb24udS5maWxl TG9jLnNwZWMsIDApOworICAgICAgICBpZiAoZXJyb3IgPT0gbm9FcnIpCisgICAgICAgIGVycm9y ID0gQ01TZXREZXZpY2VQcm9maWxlKGNtRGlzcGxheURldmljZUNsYXNzLCAoQ01EZXZpY2VJRClr Q0dEaXJlY3RNYWluRGlzcGxheSwgJnNjb3BlLCBjbURlZmF1bHRQcm9maWxlSUQsICZsb2NhdGlv bik7CisgICAgfQorICAgIGVsc2UKKyAgICAgICAgZXJyb3IgPSAtMTsKIAotICAgIENNUHJvZmls ZVJlZiBwcmV2aW91c1Byb2ZpbGU7Ci0gICAgZXJyb3IgPSBDTU9wZW5Qcm9maWxlKCZwcmV2aW91 c1Byb2ZpbGUsICZwcmV2aW91c1Byb2ZpbGVMb2NhdGlvbik7CiAgICAgaWYgKGVycm9yKSB7Ci0g ICAgICAgIGZhaWxlZEdldHRpbmdDdXJyZW50UHJvZmlsZShlcnJvcik7CisgICAgICAgIGZwcmlu dGYoc3RkZXJyLCAiRmFpbGVkIHRvIHNldCBjb2xvciBwcm9maWxlIGZvciBtYWluIGRpc3BsYXkh ICBNYW55IHBpeGVsIHRlc3RzIG1heSBmYWlsIGFzIGEgcmVzdWx0LiAgKEVycm9yOiAlaSkiLCBl cnJvcik7CisgICAgICAgIHNJbml0aWFsUHJvZmlsZUxvY2F0aW9uLmxvY1R5cGUgPSBjbU5vUHJv ZmlsZUJhc2U7CiAgICAgICAgIHJldHVybjsKICAgICB9Ci0KLSAgICBDRlN0cmluZ1JlZiBwcmV2 aW91c1Byb2ZpbGVOYW1lOwotICAgIENGU3RyaW5nUmVmIGdlbmVyaWNQcm9maWxlTmFtZTsKLSAg ICBjaGFyIHByZXZpb3VzUHJvZmlsZU5hbWVTdHJpbmdbMTAyNF07Ci0gICAgY2hhciBnZW5lcmlj UHJvZmlsZU5hbWVTdHJpbmdbMTAyNF07Ci0gICAgQ01Db3B5UHJvZmlsZURlc2NyaXB0aW9uU3Ry aW5nKHByZXZpb3VzUHJvZmlsZSwgJnByZXZpb3VzUHJvZmlsZU5hbWUpOwotICAgIENNQ29weVBy b2ZpbGVEZXNjcmlwdGlvblN0cmluZyhnZW5lcmljUHJvZmlsZSwgJmdlbmVyaWNQcm9maWxlTmFt ZSk7Ci0gICAgQ0ZTdHJpbmdHZXRDU3RyaW5nKHByZXZpb3VzUHJvZmlsZU5hbWUsIHByZXZpb3Vz UHJvZmlsZU5hbWVTdHJpbmcsIHNpemVvZihwcmV2aW91c1Byb2ZpbGVOYW1lU3RyaW5nKSwga0NG U3RyaW5nRW5jb2RpbmdVVEY4KTsKLSAgICBDRlN0cmluZ0dldENTdHJpbmcoZ2VuZXJpY1Byb2Zp bGVOYW1lLCBnZW5lcmljUHJvZmlsZU5hbWVTdHJpbmcsIHNpemVvZihwcmV2aW91c1Byb2ZpbGVO YW1lU3RyaW5nKSwga0NGU3RyaW5nRW5jb2RpbmdVVEY4KTsKLSAgICBDRlJlbGVhc2UocHJldmlv dXNQcm9maWxlTmFtZSk7Ci0gICAgQ0ZSZWxlYXNlKGdlbmVyaWNQcm9maWxlTmFtZSk7Ci0KLSAg ICBDTUNsb3NlUHJvZmlsZShwcmV2aW91c1Byb2ZpbGUpOwotCi0gICAgZnByaW50ZihzdGRlcnIs ICJcblxuV0FSTklORzogVGVtcG9yYXJpbHkgY2hhbmdpbmcgeW91ciBzeXN0ZW0gY29sb3IgcHJv ZmlsZSBmcm9tIFwiJXNcIiB0byBcIiVzXCIuXG4iLCBwcmV2aW91c1Byb2ZpbGVOYW1lU3RyaW5n LCBnZW5lcmljUHJvZmlsZU5hbWVTdHJpbmcpOworICAgIAorICAgIC8vIE90aGVyIHNpZ25hbHMg YXJlIGhhbmRsZWQgaW4gaW5zdGFsbFNpZ25hbEhhbmRsZXJzKCkgd2hpY2ggYWxzbyBjYWxscyBy ZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUoKQorICAgIHNpZ25hbChTSUdJTlQsIHJlc3Rv cmVNYWluRGlzcGxheUNvbG9yUHJvZmlsZSk7CisgICAgc2lnbmFsKFNJR0hVUCwgcmVzdG9yZU1h aW5EaXNwbGF5Q29sb3JQcm9maWxlKTsKKyAgICBzaWduYWwoU0lHVEVSTSwgcmVzdG9yZU1haW5E aXNwbGF5Q29sb3JQcm9maWxlKTsKKyAgICAKKyAgICBmcHJpbnRmKHN0ZGVyciwgIlxuXG5XQVJO SU5HOiBUZW1wb3JhcmlseSBjaGFuZ2luZyB0aGUgbWFpbiBkaXNwbGF5IGNvbG9yIHByb2ZpbGUg dG8gXCIlc1wiOiB0aGUgY29sb3JzIG9uIHlvdXIgc2NyZWVuIHdpbGwgY2hhbmdlIGZvciB0aGUg ZHVyYXRpb24gb2YgdGhlIHRlc3RpbmcuXG4iLCBQUk9GSUxFX1BBVEgpOwogICAgIGZwcmludGYo c3RkZXJyLCAiVGhpcyBhbGxvd3MgdGhlIFdlYktpdCBwaXhlbC1iYXNlZCByZWdyZXNzaW9uIHRl c3RzIHRvIGhhdmUgY29uc2lzdGVudCBjb2xvciB2YWx1ZXMgYWNyb3NzIGFsbCBtYWNoaW5lcy5c biIpOwotICAgIGZwcmludGYoc3RkZXJyLCAiVGhlIGNvbG9ycyBvbiB5b3VyIHNjcmVlbiB3aWxs IGNoYW5nZSBmb3IgdGhlIGR1cmF0aW9uIG9mIHRoZSB0ZXN0aW5nLlxuXG4iKTsKLQotICAgIENN RGV2aWNlU2NvcGUgc2NvcGUgPSB7IGtDRlByZWZlcmVuY2VzQ3VycmVudFVzZXIsIGtDRlByZWZl cmVuY2VzQ3VycmVudEhvc3QgfTsKLSAgICBpZiAoKGVycm9yID0gQ01TZXREZXZpY2VQcm9maWxl KGNtRGlzcGxheURldmljZUNsYXNzLCBjbURlZmF1bHREZXZpY2VJRCwgJnNjb3BlLCBjbURlZmF1 bHRQcm9maWxlSUQsICZnZW5lcmljUHJvZmlsZUxvY2F0aW9uKSkpIHsKLSAgICAgICAgZnByaW50 ZihzdGRlcnIsICJGYWlsZWQgdG8gc2V0IGNvbG9yIHByb2ZpbGUgdG8gXCIlc1wiISBNYW55IHBp eGVsIHRlc3RzIHdpbGwgZmFpbCBhcyBhIHJlc3VsdC4gIChFcnJvcjogJWkpIiwKLSAgICAgICAg ICAgIGdlbmVyaWNQcm9maWxlTmFtZVN0cmluZywgZXJyb3IpOwotICAgIH0gZWxzZSB7Ci0gICAg ICAgIGN1cnJlbnRDb2xvclByb2ZpbGVMb2NhdGlvbiA9IHByZXZpb3VzUHJvZmlsZUxvY2F0aW9u OwotICAgICAgICBjaGFuZ2VkQ29sb3JQcm9maWxlID0gdHJ1ZTsKLSAgICAgICAgc2lnbmFsKFNJ R0lOVCwgcmVzdG9yZUNvbG9yU3BhY2UpOwotICAgICAgICBzaWduYWwoU0lHSFVQLCByZXN0b3Jl Q29sb3JTcGFjZSk7Ci0gICAgICAgIHNpZ25hbChTSUdURVJNLCByZXN0b3JlQ29sb3JTcGFjZSk7 Ci0gICAgfQogfQogCi12b2lkIGluaXRpYWxpemVDb2xvclNwYWNlQW5kU2NyZWVCdWZmZXJGb3JQ aXhlbFRlc3RzKCkKLXsKLSAgICBzZXREZWZhdWx0Q29sb3JQcm9maWxlVG9SR0IoKTsKLSAgICBz Y3JlZW5DYXB0dXJlQnVmZmVyID0gKHVuc2lnbmVkIGNoYXIgKiltYWxsb2MobWF4Vmlld0hlaWdo dCAqIG1heFZpZXdXaWR0aCAqIDQpOwotICAgIHNoYXJlZENvbG9yU3BhY2UgPSBDR0NvbG9yU3Bh Y2VDcmVhdGVEZXZpY2VSR0IoKTsKLX0KLQotLy8gRGVjbGFyZWQgaW4gUGl4ZWxEdW1wU3VwcG9y dENHLmgKLQotUmV0YWluUHRyPENHQ29udGV4dFJlZj4gZ2V0Qml0bWFwQ29udGV4dEZyb21XZWJW aWV3KCkKK1Bhc3NSZWZQdHI8Qml0bWFwQ29udGV4dD4gY3JlYXRlQml0bWFwQ29udGV4dEZyb21X ZWJWaWV3KGJvb2wgb25zY3JlZW4sIGJvb2wgaW5jcmVtZW50YWxSZXBhaW50LCBib29sIHN3ZWVw SG9yaXpvbnRhbGx5LCBib29sIGRyYXdTZWxlY3Rpb25SZWN0KQogewotICAgIE5TU2l6ZSB3ZWJW aWV3U2l6ZSA9IFtbbWFpbkZyYW1lIHdlYlZpZXddIGZyYW1lXS5zaXplOwotICAgIHJldHVybiBS ZXRhaW5QdHI8Q0dDb250ZXh0UmVmPihBZG9wdENGLCBDR0JpdG1hcENvbnRleHRDcmVhdGUoc2Ny ZWVuQ2FwdHVyZUJ1ZmZlciwgc3RhdGljX2Nhc3Q8c2l6ZV90Pih3ZWJWaWV3U2l6ZS53aWR0aCks IHN0YXRpY19jYXN0PHNpemVfdD4od2ViVmlld1NpemUuaGVpZ2h0KSwgOCwgc3RhdGljX2Nhc3Q8 c2l6ZV90Pih3ZWJWaWV3U2l6ZS53aWR0aCkgKiA0LCBzaGFyZWRDb2xvclNwYWNlLCBrQ0dCaXRt YXBCeXRlT3JkZXIzMkhvc3QgfCBrQ0dJbWFnZUFscGhhUHJlbXVsdGlwbGllZExhc3QpKTsKLX0K LQotdm9pZCBwYWludFdlYlZpZXcoQ0dDb250ZXh0UmVmIGNvbnRleHQpCi17Ci0gICAgUmV0YWlu UHRyPE5TR3JhcGhpY3NDb250ZXh0PiBzYXZlZENvbnRleHQgPSBbTlNHcmFwaGljc0NvbnRleHQg Y3VycmVudENvbnRleHRdOwotCi0gICAgTlNHcmFwaGljc0NvbnRleHQqIG5zQ29udGV4dCA9IFtO U0dyYXBoaWNzQ29udGV4dCBncmFwaGljc0NvbnRleHRXaXRoR3JhcGhpY3NQb3J0OmNvbnRleHQg ZmxpcHBlZDpOT107Ci0gICAgW05TR3JhcGhpY3NDb250ZXh0IHNldEN1cnJlbnRDb250ZXh0Om5z Q29udGV4dF07Ci0KICAgICBXZWJWaWV3KiB2aWV3ID0gW21haW5GcmFtZSB3ZWJWaWV3XTsKLSAg ICBbdmlldyBkaXNwbGF5SWZOZWVkZWRdOwotICAgIFt2aWV3IGxvY2tGb2N1c107Ci0gICAgTlNC aXRtYXBJbWFnZVJlcCAqaW1hZ2VSZXAgPSBbW05TQml0bWFwSW1hZ2VSZXAgYWxsb2NdIGluaXRX aXRoRm9jdXNlZFZpZXdSZWN0Olt2aWV3IGZyYW1lXV07Ci0gICAgW3ZpZXcgdW5sb2NrRm9jdXNd OwotICAgIFtpbWFnZVJlcCBkcmF3XTsKLSAgICBbaW1hZ2VSZXAgcmVsZWFzZV07Ci0KLSAgICBb TlNHcmFwaGljc0NvbnRleHQgc2V0Q3VycmVudENvbnRleHQ6c2F2ZWRDb250ZXh0LmdldCgpXTsK LX0KLQotdm9pZCByZXBhaW50V2ViVmlldyhDR0NvbnRleHRSZWYgY29udGV4dCwgYm9vbCBob3Jp em9udGFsKQotewotICAgIFJldGFpblB0cjxOU0dyYXBoaWNzQ29udGV4dD4gc2F2ZWRDb250ZXh0 ID0gW05TR3JhcGhpY3NDb250ZXh0IGN1cnJlbnRDb250ZXh0XTsKLQotICAgIE5TR3JhcGhpY3ND b250ZXh0KiBuc0NvbnRleHQgPSBbTlNHcmFwaGljc0NvbnRleHQgZ3JhcGhpY3NDb250ZXh0V2l0 aEdyYXBoaWNzUG9ydDpjb250ZXh0IGZsaXBwZWQ6Tk9dOwotICAgIFtOU0dyYXBoaWNzQ29udGV4 dCBzZXRDdXJyZW50Q29udGV4dDpuc0NvbnRleHRdOwotCi0gICAgV2ViVmlldyAqdmlldyA9IFtt YWluRnJhbWUgd2ViVmlld107CiAgICAgTlNTaXplIHdlYlZpZXdTaXplID0gW3ZpZXcgZnJhbWVd LnNpemU7CisgICAgc2l6ZV90IHBpeGVsc1dpZGUgPSBzdGF0aWNfY2FzdDxzaXplX3Q+KHdlYlZp ZXdTaXplLndpZHRoKTsKKyAgICBzaXplX3QgcGl4ZWxzSGlnaCA9IHN0YXRpY19jYXN0PHNpemVf dD4od2ViVmlld1NpemUuaGVpZ2h0KTsKKyAgICBzaXplX3Qgcm93Qnl0ZXMgPSAoNCAqIHBpeGVs c1dpZGUgKyA2MykgJiB+NjM7IC8vIFVzZSBhIG11bHRpcGxlIG9mIDY0IGJ5dGVzIHRvIGltcHJv dmUgQ0cgcGVyZm9ybWFuY2UKKworICAgIHZvaWQgKmJ1ZmZlciA9IGNhbGxvYyhwaXhlbHNIaWdo LCByb3dCeXRlcyk7CisgICAgaWYgKCFidWZmZXIpCisgICAgICAgIHJldHVybiAwOworICAgIAor ICAgIHN0YXRpYyBDR0NvbG9yU3BhY2VSZWYgY29sb3JTcGFjZSA9IDA7CisgICAgaWYgKCFjb2xv clNwYWNlKSB7CisgICAgICAgIENNUHJvZmlsZUxvY2F0aW9uIGxvY2F0aW9uOworICAgICAgICBs b2NhdGlvbi5sb2NUeXBlID0gY21GaWxlQmFzZWRQcm9maWxlOworICAgICAgICBOU1VSTCAqdXJs ID0gW05TVVJMIGZpbGVVUkxXaXRoUGF0aDpbTlNTdHJpbmcgc3RyaW5nV2l0aFVURjhTdHJpbmc6 UFJPRklMRV9QQVRIXV07CisgICAgICAgIEZTUmVmIGZzUmVmOworICAgICAgICBpZiAodXJsICYm IENGVVJMR2V0RlNSZWYoKENGVVJMUmVmKXVybCwgJmZzUmVmKSkgeworICAgICAgICAgICAgaWYg KEZTR2V0Q2F0YWxvZ0luZm8oJmZzUmVmLCAwLCAwLCAwLCAmbG9jYXRpb24udS5maWxlTG9jLnNw ZWMsIDApID09IG5vRXJyKSB7CisgICAgICAgICAgICAgICAgQ01Qcm9maWxlUmVmIHByb2ZpbGU7 CisgICAgICAgICAgICAgICAgaWYgKENNT3BlblByb2ZpbGUoJnByb2ZpbGUsICZsb2NhdGlvbikg PT0gbm9FcnIpIHsKKyAgICAgICAgICAgICAgICAgICAgY29sb3JTcGFjZSA9IENHQ29sb3JTcGFj ZUNyZWF0ZVdpdGhQbGF0Zm9ybUNvbG9yU3BhY2UocHJvZmlsZSk7CisgICAgICAgICAgICAgICAg ICAgIENNQ2xvc2VQcm9maWxlKHByb2ZpbGUpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAg ICAgIH0KKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICBDR0NvbnRleHRSZWYgY29udGV4dCA9 IENHQml0bWFwQ29udGV4dENyZWF0ZShidWZmZXIsIHBpeGVsc1dpZGUsIHBpeGVsc0hpZ2gsIDgs IHJvd0J5dGVzLCBjb2xvclNwYWNlLCBrQ0dJbWFnZUFscGhhUHJlbXVsdGlwbGllZEZpcnN0IHwg a0NHQml0bWFwQnl0ZU9yZGVyMzJIb3N0KTsgLy8gVXNlIEFSR0I4IG9uIFBQQyBvciBCR1JBOCBv biBYODYgdG8gaW1wcm92ZSBDRyBwZXJmb3JtYW5jZQorICAgIGlmICghY29udGV4dCkgeworICAg ICAgICBmcmVlKGJ1ZmZlcik7CisgICAgICAgIHJldHVybiAwOworICAgIH0KIAotICAgIGlmICho b3Jpem9udGFsKSB7Ci0gICAgICAgIGZvciAoTlNSZWN0IGNvbHVtbiA9IE5TTWFrZVJlY3QoMCwg MCwgMSwgd2ViVmlld1NpemUuaGVpZ2h0KTsgY29sdW1uLm9yaWdpbi54IDwgd2ViVmlld1NpemUu d2lkdGg7IGNvbHVtbi5vcmlnaW4ueCsrKQotICAgICAgICAgICAgW3ZpZXcgZGlzcGxheVJlY3RJ Z25vcmluZ09wYWNpdHk6Y29sdW1uIGluQ29udGV4dDpuc0NvbnRleHRdOworICAgIC8vIFRoZSBC aXRtYXBDb250ZXh0IGtlZXBzIHRoZSBDR0NvbnRleHRSZWYgYW5kIHRoZSBwaXhlbCBidWZmZXIg YWxpdmUKKyAgICBSZWZQdHI8Qml0bWFwQ29udGV4dD4gYml0bWFwQ29udGV4dCA9IEJpdG1hcENv bnRleHQ6OmNyZWF0ZUJ5QWRvcHRpbmdCaXRtYXBBbmRDb250ZXh0KGJ1ZmZlciwgY29udGV4dCk7 CisgICAgCisgICAgTlNHcmFwaGljc0NvbnRleHQgKm5zQ29udGV4dCA9IFtOU0dyYXBoaWNzQ29u dGV4dCBncmFwaGljc0NvbnRleHRXaXRoR3JhcGhpY3NQb3J0OmNvbnRleHQgZmxpcHBlZDpOT107 CisgICAgQVNTRVJUKG5zQ29udGV4dCk7CisgICAgCisgICAgaWYgKGluY3JlbWVudGFsUmVwYWlu dCkgeworICAgICAgICBpZiAoc3dlZXBIb3Jpem9udGFsbHkpIHsKKyAgICAgICAgICAgIGZvciAo TlNSZWN0IGNvbHVtbiA9IE5TTWFrZVJlY3QoMCwgMCwgMSwgd2ViVmlld1NpemUuaGVpZ2h0KTsg Y29sdW1uLm9yaWdpbi54IDwgd2ViVmlld1NpemUud2lkdGg7IGNvbHVtbi5vcmlnaW4ueCsrKQor ICAgICAgICAgICAgICAgIFt2aWV3IGRpc3BsYXlSZWN0SWdub3JpbmdPcGFjaXR5OmNvbHVtbiBp bkNvbnRleHQ6bnNDb250ZXh0XTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIGZvciAo TlNSZWN0IGxpbmUgPSBOU01ha2VSZWN0KDAsIDAsIHdlYlZpZXdTaXplLndpZHRoLCAxKTsgbGlu ZS5vcmlnaW4ueSA8IHdlYlZpZXdTaXplLmhlaWdodDsgbGluZS5vcmlnaW4ueSsrKQorICAgICAg ICAgICAgICAgIFt2aWV3IGRpc3BsYXlSZWN0SWdub3JpbmdPcGFjaXR5OmxpbmUgaW5Db250ZXh0 Om5zQ29udGV4dF07CisgICAgICAgIH0KICAgICB9IGVsc2UgewotICAgICAgICBmb3IgKE5TUmVj dCBsaW5lID0gTlNNYWtlUmVjdCgwLCAwLCB3ZWJWaWV3U2l6ZS53aWR0aCwgMSk7IGxpbmUub3Jp Z2luLnkgPCB3ZWJWaWV3U2l6ZS5oZWlnaHQ7IGxpbmUub3JpZ2luLnkrKykKLSAgICAgICAgICAg IFt2aWV3IGRpc3BsYXlSZWN0SWdub3JpbmdPcGFjaXR5OmxpbmUgaW5Db250ZXh0Om5zQ29udGV4 dF07CisgICAgICAgIGlmIChvbnNjcmVlbikgeworI2lmZGVmIEJVSUxESU5HX09OX0xFT1BBUkQK KyAgICAgICAgICAgIC8vIEFzayB0aGUgd2luZG93IHNlcnZlciB0byBwcm92aWRlIHVzIGEgY29t cG9zaXRlZCB2ZXJzaW9uIG9mIHRoZSAqcmVhbCogd2luZG93IGNvbnRlbnQgaW5jbHVkaW5nIHN1 cmZhY2VzIChpLmUuIE9wZW5HTCBjb250ZW50KQorICAgICAgICAgICAgLy8gTm90ZSB0aGF0IHRo ZSByZXR1cm5lZCBpbWFnZSBtaWdodCBkaWZmZXIgdmVyeSBzbGlnaHRseSBmcm9tIHRoZSB3aW5k b3cgYmFja2luZyBiZWNhdXNlIG9mIGRpdGhlcmluZyBhcnRpZmFjdHMgaW4gdGhlIHdpbmRvdyBz ZXJ2ZXIgY29tcG9zaXRvcgorICAgICAgICAgICAgCisgICAgICAgICAgICBDR0ltYWdlUmVmIGlt YWdlID0gQ0dXaW5kb3dMaXN0Q3JlYXRlSW1hZ2UoQ0dSZWN0TnVsbCwga0NHV2luZG93TGlzdE9w dGlvbkluY2x1ZGluZ1dpbmRvdywgW1t2aWV3IHdpbmRvd10gd2luZG93TnVtYmVyXSwga0NHV2lu ZG93SW1hZ2VCb3VuZHNJZ25vcmVGcmFtaW5nIHwga0NHV2luZG93SW1hZ2VTaG91bGRCZU9wYXF1 ZSk7CisgICAgICAgICAgICBDR0NvbnRleHREcmF3SW1hZ2UoY29udGV4dCwgQ0dSZWN0TWFrZSgw LCAwLCBDR0ltYWdlR2V0V2lkdGgoaW1hZ2UpLCBDR0ltYWdlR2V0SGVpZ2h0KGltYWdlKSksIGlt YWdlKTsKKyAgICAgICAgICAgIENHSW1hZ2VSZWxlYXNlKGltYWdlKTsKKyNlbHNlCisgICAgICAg ICAgICAvLyBPbiAxMC40IGFuZCBlYXJsaWVyLCB3ZSBoYXZlIHRvIG1vdmUgdGhlIHdpbmRvdyB0 ZW1wb3JhcmlseSAib25zY3JlZW4iIGFuZCByZWFkIGRpcmVjdGx5IGZyb20gdGhlIGRpc3BsYXkg ZnJhbWVidWZmZXIgdXNpbmcgT3BlbkdMCisgICAgICAgICAgICAvLyBJbiB0aGlzIGNvZGUgcGF0 aCwgd2UgbmVlZCB0byBlbnN1cmUgdGhlIHdpbmRvdyBpcyBhYm92ZSBhbnkgb3RoZXIgd2luZG93 IG9yIGNhcHR1cmVkIHJlc3VsdCB3aWxsIGJlIGNvcnJ1cHRlZAorICAgICAgICAgICAgCisgICAg ICAgICAgICBOU1dpbmRvdyAqd2luZG93ID0gW3ZpZXcgd2luZG93XTsKKyAgICAgICAgICAgIGlu dCBvbGRMZXZlbCA9IFt3aW5kb3cgbGV2ZWxdOworICAgICAgICAgICAgTlNSZWN0IG9sZEZyYW1l ID0gW3dpbmRvdyBmcmFtZV07CisgICAgICAgICAgICAKKyAgICAgICAgICAgIE5TUmVjdCBuZXdG cmFtZSA9IFtbW05TU2NyZWVuIHNjcmVlbnNdIG9iamVjdEF0SW5kZXg6MF0gZnJhbWVdOworICAg ICAgICAgICAgbmV3RnJhbWUgPSBOU01ha2VSZWN0KG5ld0ZyYW1lLm9yaWdpbi54ICsgKG5ld0Zy YW1lLnNpemUud2lkdGggLSBvbGRGcmFtZS5zaXplLndpZHRoKSAvIDIsIG5ld0ZyYW1lLm9yaWdp bi55ICsgKG5ld0ZyYW1lLnNpemUuaGVpZ2h0IC0gb2xkRnJhbWUuc2l6ZS5oZWlnaHQpIC8gMiwg b2xkRnJhbWUuc2l6ZS53aWR0aCwgb2xkRnJhbWUuc2l6ZS5oZWlnaHQpOworICAgICAgICAgICAg W3dpbmRvdyBzZXRMZXZlbDpOU1NjcmVlblNhdmVyV2luZG93TGV2ZWxdOworICAgICAgICAgICAg W3dpbmRvdyBzZXRGcmFtZTpuZXdGcmFtZSBkaXNwbGF5Ok5PIGFuaW1hdGU6Tk9dOworICAgICAg ICAgICAgCisgICAgICAgICAgICBDR1JlY3QgcmVjdCA9IENHUmVjdE1ha2UobmV3RnJhbWUub3Jp Z2luLngsIG5ld0ZyYW1lLm9yaWdpbi55LCB3ZWJWaWV3U2l6ZS53aWR0aCwgd2ViVmlld1NpemUu aGVpZ2h0KTsKKyAgICAgICAgICAgIENHRGlyZWN0RGlzcGxheUlEIGRpc3BsYXlJRDsKKyAgICAg ICAgICAgIENHRGlzcGxheUNvdW50IGNvdW50OworICAgICAgICAgICAgaWYgKENHR2V0RGlzcGxh eXNXaXRoUmVjdChyZWN0LCAxLCAmZGlzcGxheUlELCAmY291bnQpID09IGtDR0Vycm9yU3VjY2Vz cykgeworICAgICAgICAgICAgICAgIENHUmVjdCBib3VuZHMgPSBDR0Rpc3BsYXlCb3VuZHMoZGlz cGxheUlEKTsKKyAgICAgICAgICAgICAgICByZWN0Lm9yaWdpbi54IC09IGJvdW5kcy5vcmlnaW4u eDsKKyAgICAgICAgICAgICAgICByZWN0Lm9yaWdpbi55IC09IGJvdW5kcy5vcmlnaW4ueTsKKyAg ICAgICAgICAgICAgICAKKyAgICAgICAgICAgICAgICBDR0xQaXhlbEZvcm1hdEF0dHJpYnV0ZSBh dHRyaWJ1dGVzW10gPSB7a0NHTFBGQUFjY2VsZXJhdGVkLCBrQ0dMUEZBTm9SZWNvdmVyeSwga0NH TFBGQUZ1bGxTY3JlZW4sIGtDR0xQRkFEaXNwbGF5TWFzaywgKENHTFBpeGVsRm9ybWF0QXR0cmli dXRlKUNHRGlzcGxheUlEVG9PcGVuR0xEaXNwbGF5TWFzayhkaXNwbGF5SUQpLCAoQ0dMUGl4ZWxG b3JtYXRBdHRyaWJ1dGUpMH07CisgICAgICAgICAgICAgICAgQ0dMUGl4ZWxGb3JtYXRPYmogcGl4 ZWxGb3JtYXQ7CisgICAgICAgICAgICAgICAgR0xpbnQgbnVtOworICAgICAgICAgICAgICAgIGlm IChDR0xDaG9vc2VQaXhlbEZvcm1hdChhdHRyaWJ1dGVzLCAmcGl4ZWxGb3JtYXQsICZudW0pID09 IGtDR0xOb0Vycm9yKSB7CisgICAgICAgICAgICAgICAgICAgIENHTENvbnRleHRPYmogY2dsX2N0 eDsKKyAgICAgICAgICAgICAgICAgICAgaWYgKENHTENyZWF0ZUNvbnRleHQocGl4ZWxGb3JtYXQs IDAsICZjZ2xfY3R4KSA9PSBrQ0dMTm9FcnJvcikgeworICAgICAgICAgICAgICAgICAgICAgICAg aWYgKENHTFNldEZ1bGxTY3JlZW4oY2dsX2N0eCkgPT0ga0NHTE5vRXJyb3IpIHsKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICB2b2lkICpmbGlwQnVmZmVyID0gY2FsbG9jKHBpeGVsc0hpZ2gs IHJvd0J5dGVzKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBpZiAoZmxpcEJ1ZmZlcikg eworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnbFBpeGVsU3RvcmVpKEdMX1BBQ0tf Uk9XX0xFTkdUSCwgcm93Qnl0ZXMgLyA0KTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgZ2xQaXhlbFN0b3JlaShHTF9QQUNLX0FMSUdOTUVOVCwgNCk7CisjaWYgX19CSUdfRU5ESUFO X18KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2xSZWFkUGl4ZWxzKHJlY3Qub3Jp Z2luLngsIHJlY3Qub3JpZ2luLnksIHJlY3Quc2l6ZS53aWR0aCwgcmVjdC5zaXplLmhlaWdodCwg R0xfUkdCQSwgR0xfVU5TSUdORURfSU5UXzhfOF84XzgsIGZsaXBCdWZmZXIpOworI2Vsc2UKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2xSZWFkUGl4ZWxzKHJlY3Qub3JpZ2luLngs IHJlY3Qub3JpZ2luLnksIHJlY3Quc2l6ZS53aWR0aCwgcmVjdC5zaXplLmhlaWdodCwgR0xfUkdC QSwgR0xfVU5TSUdORURfSU5UXzhfOF84XzhfUkVWLCBmbGlwQnVmZmVyKTsKKyNlbmRpZgorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpZiAoIWdsR2V0RXJyb3IoKSkgeworICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZm9yKHNpemVfdCBpID0gMDsgaSA8IHBpeGVs c0hpZ2g7ICsraSkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJjb3B5KChj aGFyKilmbGlwQnVmZmVyICsgcm93Qnl0ZXMgKiBpLCAoY2hhciopYnVmZmVyICsgcm93Qnl0ZXMg KiAocGl4ZWxzSGlnaCAtIGkgLSAxKSwgcGl4ZWxzV2lkZSAqIDQpOworICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmcmVlKGZsaXBCdWZmZXIpOworICAgICAgICAg ICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAg ICAgICAgICAgICAgICAgIENHTERlc3Ryb3lDb250ZXh0KGNnbF9jdHgpOworICAgICAgICAgICAg ICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgIENHTERlc3Ryb3lQaXhlbEZvcm1hdChwaXhl bEZvcm1hdCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorICAgICAgICAgICAg CisgICAgICAgICAgICBbd2luZG93IHNldEZyYW1lOm9sZEZyYW1lIGRpc3BsYXk6Tk8gYW5pbWF0 ZTpOT107CisgICAgICAgICAgICBbd2luZG93IHNldExldmVsOm9sZExldmVsXTsKKyNlbmRpZgor ICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgLy8gR3JhYiBkaXJlY3RseSB0aGUgY29udGVu dHMgb2YgdGhlIHdpbmRvdyBiYWNraW5nIGJ1ZmZlciAodGhpcyBpZ25vcmVzIGFueSBzdXJmYWNl cyBvbiB0aGUgd2luZG93KQorICAgICAgICAgICAgLy8gRklYTUU6IFRoaXMgcGF0aCBpcyBzdWJv cHRpbWFsOiBkYXRhIGlzIHJlYWQgZnJvbSB3aW5kb3cgYmFja2luZyBzdG9yZSwgY29udmVydGVk IHRvIFJHQjggdGhlbiBkcmF3biBhZ2FpbiBpbnRvIGFuIFJHQkE4IGJpdG1hcAorICAgICAgICAg ICAgCisgICAgICAgICAgICBbdmlldyBkaXNwbGF5SWZOZWVkZWRdOworICAgICAgICAgICAgW3Zp ZXcgbG9ja0ZvY3VzXTsKKyAgICAgICAgICAgIE5TQml0bWFwSW1hZ2VSZXAgKmltYWdlUmVwID0g W1tbTlNCaXRtYXBJbWFnZVJlcCBhbGxvY10gaW5pdFdpdGhGb2N1c2VkVmlld1JlY3Q6W3ZpZXcg ZnJhbWVdXSBhdXRvcmVsZWFzZV07CisgICAgICAgICAgICBbdmlldyB1bmxvY2tGb2N1c107CisK KyAgICAgICAgICAgIFJldGFpblB0cjxOU0dyYXBoaWNzQ29udGV4dD4gc2F2ZWRDb250ZXh0ID0g W05TR3JhcGhpY3NDb250ZXh0IGN1cnJlbnRDb250ZXh0XTsKKyAgICAgICAgICAgIFtOU0dyYXBo aWNzQ29udGV4dCBzZXRDdXJyZW50Q29udGV4dDpuc0NvbnRleHRdOworICAgICAgICAgICAgW2lt YWdlUmVwIGRyYXddOworICAgICAgICAgICAgW05TR3JhcGhpY3NDb250ZXh0IHNldEN1cnJlbnRD b250ZXh0OnNhdmVkQ29udGV4dC5nZXQoKV07CisgICAgICAgIH0KICAgICB9CiAKLSAgICBbTlNH cmFwaGljc0NvbnRleHQgc2V0Q3VycmVudENvbnRleHQ6c2F2ZWRDb250ZXh0LmdldCgpXTsKLX0K LQotQ0dSZWN0IGdldFNlbGVjdGlvblJlY3QoKQotewotICAgIE5TVmlldyAqZG9jdW1lbnRWaWV3 ID0gW1ttYWluRnJhbWUgZnJhbWVWaWV3XSBkb2N1bWVudFZpZXddOwotICAgIGlmIChbZG9jdW1l bnRWaWV3IGNvbmZvcm1zVG9Qcm90b2NvbDpAcHJvdG9jb2woV2ViRG9jdW1lbnRTZWxlY3Rpb24p XSkgeworICAgIGlmIChkcmF3U2VsZWN0aW9uUmVjdCkgeworICAgICAgICBOU1ZpZXcgKmRvY3Vt ZW50VmlldyA9IFtbbWFpbkZyYW1lIGZyYW1lVmlld10gZG9jdW1lbnRWaWV3XTsKKyAgICAgICAg QVNTRVJUKFtkb2N1bWVudFZpZXcgY29uZm9ybXNUb1Byb3RvY29sOkBwcm90b2NvbChXZWJEb2N1 bWVudFNlbGVjdGlvbildKTsKICAgICAgICAgTlNSZWN0IHJlY3QgPSBbZG9jdW1lbnRWaWV3IGNv bnZlcnRSZWN0OlsoaWQgPFdlYkRvY3VtZW50U2VsZWN0aW9uPilkb2N1bWVudFZpZXcgc2VsZWN0 aW9uUmVjdF0gZnJvbVZpZXc6bmlsXTsKLSAgICAgICAgcmV0dXJuIENHUmVjdE1ha2UocmVjdC5v cmlnaW4ueCwgcmVjdC5vcmlnaW4ueSwgcmVjdC5zaXplLndpZHRoLCByZWN0LnNpemUuaGVpZ2h0 KTsKKyAgICAgICAgQ0dDb250ZXh0U2F2ZUdTdGF0ZShjb250ZXh0KTsKKyAgICAgICAgQ0dDb250 ZXh0U2V0TGluZVdpZHRoKGNvbnRleHQsIDEuMCk7CisgICAgICAgIENHQ29udGV4dFNldFJHQlN0 cm9rZUNvbG9yKGNvbnRleHQsIDEuMCwgMC4wLCAwLjAsIDEuMCk7CisgICAgICAgIENHQ29udGV4 dFN0cm9rZVJlY3QoY29udGV4dCwgQ0dSZWN0TWFrZShyZWN0Lm9yaWdpbi54LCByZWN0Lm9yaWdp bi55LCByZWN0LnNpemUud2lkdGgsIHJlY3Quc2l6ZS5oZWlnaHQpKTsKKyAgICAgICAgQ0dDb250 ZXh0UmVzdG9yZUdTdGF0ZShjb250ZXh0KTsKICAgICB9Ci0KLSAgICBBU1NFUlRfTk9UX1JFQUNI RUQoKTsKLSAgICByZXR1cm4gQ0dSZWN0WmVybzsKKyAgICAKKyAgICByZXR1cm4gYml0bWFwQ29u dGV4dC5yZWxlYXNlKCk7CiB9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2lu L0R1bXBSZW5kZXJUcmVlLmNwcAppbmRleCAxY2UzMWRlLi43NDJiZDdmIDEwMDY0NAotLS0gYS9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCisrKyBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAKQEAgLTM4LDI1 ICszOCwyNiBAQAogI2luY2x1ZGUgIlVJRGVsZWdhdGUuaCIKICNpbmNsdWRlICJXb3JrUXVldWVJ dGVtLmgiCiAjaW5jbHVkZSAiV29ya1F1ZXVlLmgiCisKKyNpbmNsdWRlIDxmY250bC5oPgorI2lu Y2x1ZGUgPGlvLmg+CisjaW5jbHVkZSA8bWF0aC5oPgorI2luY2x1ZGUgPHB0aHJlYWQuaD4KKyNp bmNsdWRlIDxzaGx3YXBpLmg+CisjaW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNsdWRlIDxzdHJpbmcu aD4KKyNpbmNsdWRlIDx0Y2hhci5oPgogI2luY2x1ZGUgPHd0Zi9SZXRhaW5QdHIuaD4KICNpbmNs dWRlIDx3dGYvVmVjdG9yLmg+Ci0jaW5jbHVkZSA8V2ViQ29yZS9DT01QdHIuaD4KLSNpbmNsdWRl IDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgorI2luY2x1ZGUgPHdpbmRvd3MuaD4K ICNpbmNsdWRlIDxDRk5ldHdvcmsvQ0ZVUkxDYWNoZVByaXYuaD4KKyNpbmNsdWRlIDxDb3JlRm91 bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0phdmFT Y3JpcHRDb3JlLmg+Ci0jaW5jbHVkZSA8bWF0aC5oPgotI2luY2x1ZGUgPHB0aHJlYWQuaD4KLSNp bmNsdWRlIDxzdHJpbmc+Ci0jaW5jbHVkZSA8dGNoYXIuaD4KKyNpbmNsdWRlIDxXZWJDb3JlL0NP TVB0ci5oPgogI2luY2x1ZGUgPFdlYktpdC9Gb3JFYWNoQ29DbGFzcy5oPgogI2luY2x1ZGUgPFdl YktpdC9XZWJLaXQuaD4KLSNpbmNsdWRlIDxmY250bC5oPgotI2luY2x1ZGUgPGlvLmg+Ci0jaW5j bHVkZSA8d2luZG93cy5oPgotI2luY2x1ZGUgPHN0ZGlvLmg+Ci0jaW5jbHVkZSA8c2hsd2FwaS5o PgogCi11c2luZyBzdGQ6OndzdHJpbmc7Cit1c2luZyBuYW1lc3BhY2Ugc3RkOwogCiAjaWZuZGVm IE5ERUJVRwogY29uc3QgTFBXU1RSIFRlc3RQbHVnaW5EaXIgPSBMIlRlc3ROZXRzY2FwZVBsdWdp bl9EZWJ1ZyI7CkBAIC03OCw4ICs3OSw2IEBAIHN0YXRpYyBib29sIHRocmVhZGVkID0gZmFsc2U7 CiBzdGF0aWMgYm9vbCBmb3JjZUNvbXBsZXhUZXh0ID0gZmFsc2U7CiBzdGF0aWMgUmV0YWluUHRy PENGU3RyaW5nUmVmPiBwZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbjsKIAotc3RhdGlj IGNvbnN0IGNoYXIqIGN1cnJlbnRUZXN0OwotCiB2b2xhdGlsZSBib29sIGRvbmU7CiAvLyBUaGlz IGlzIHRoZSB0b3Btb3N0IGZyYW1lIHRoYXQgaXMgbG9hZGluZywgZHVyaW5nIGEgZ2l2ZW4gbG9h ZCwgb3IgbmlsIHdoZW4gbm8gbG9hZCBpcyAKIC8vIGluIHByb2dyZXNzLiAgVXN1YWxseSB0aGlz IGlzIHRoZSBzYW1lIGFzIHRoZSBtYWluIGZyYW1lLCBidXQgbm90IGFsd2F5cy4gIEluIHRoZSBj YXNlCkBAIC01NjIsNyArNTYxLDcgQEAgdm9pZCBkdW1wKCkKICAgICAgICAgICAgIHdzdHJpbmcg cmVzdWx0ID0gZHVtcEZyYW1lc0FzVGV4dChmcmFtZSk7CiAgICAgICAgICAgICByZXN1bHRTdHJp bmcgPSBTeXNBbGxvY1N0cmluZ0xlbihyZXN1bHQuZGF0YSgpLCByZXN1bHQuc2l6ZSgpKTsKICAg ICAgICAgfSBlbHNlIHsKLSAgICAgICAgICAgIGJvb2wgaXNTVkdXM0NUZXN0ID0gc3Ryc3RyKGN1 cnJlbnRUZXN0LCAic3ZnXFxXM0MtU1ZHLTEuMSIpOworICAgICAgICAgICAgYm9vbCBpc1NWR1cz Q1Rlc3QgPSAoZ0xheW91dFRlc3RDb250cm9sbGVyLT50ZXN0UGF0aE9yVVJMKCkuZmluZCgic3Zn XFxXM0MtU1ZHLTEuMSIpICE9IHN0cmluZzo6bnBvcyk7CiAgICAgICAgICAgICB1bnNpZ25lZCB3 aWR0aDsKICAgICAgICAgICAgIHVuc2lnbmVkIGhlaWdodDsKICAgICAgICAgICAgIGlmIChpc1NW R1czQ1Rlc3QpIHsKQEAgLTYwOCw3ICs2MDcsNyBAQCB2b2lkIGR1bXAoKQogCiAgICAgaWYgKGR1 bXBQaXhlbHMpIHsKICAgICAgICAgaWYgKCFnTGF5b3V0VGVzdENvbnRyb2xsZXItPmR1bXBBc1Rl eHQoKSAmJiAhZ0xheW91dFRlc3RDb250cm9sbGVyLT5kdW1wRE9NQXNXZWJBcmNoaXZlKCkgJiYg IWdMYXlvdXRUZXN0Q29udHJvbGxlci0+ZHVtcFNvdXJjZUFzV2ViQXJjaGl2ZSgpKQotICAgICAg ICAgICAgZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0ZWQoY3VycmVudFRl c3QsIGR1bXBBbGxQaXhlbHMpOworICAgICAgICAgICAgZHVtcFdlYlZpZXdBc1BpeGVsc0FuZENv bXBhcmVXaXRoRXhwZWN0ZWQoZ0xheW91dFRlc3RDb250cm9sbGVyLT5leHBlY3RlZFBpeGVsSGFz aCgpKTsKICAgICB9CiAKICAgICBwcmludGYoIiNFT0ZcbiIpOyAgIC8vIHRlcm1pbmF0ZSB0aGUg KHBvc3NpYmx5IGVtcHR5KSBwaXhlbHMgYmxvY2sKQEAgLTY3NSwxMyArNjc0LDIzIEBAIHN0YXRp YyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGluZygpCiAgICAg d2ViVmlld1ByaXZhdGUtPmNsZWFyTWFpbkZyYW1lTmFtZSgpOwogfQogCi1zdGF0aWMgdm9pZCBy dW5UZXN0KGNvbnN0IGNoYXIqIHBhdGhPclVSTCkKK3N0YXRpYyB2b2lkIHJ1blRlc3QoY29uc3Qg c3RyaW5nJiB0ZXN0UGF0aE9yVVJMKQogewogICAgIHN0YXRpYyBCU1RSIG1ldGhvZEJTdHIgPSBT eXNBbGxvY1N0cmluZyhURVhUKCJHRVQiKSk7CiAKKyAgICAvLyBMb29rIGZvciAiJyIgYXMgYSBz ZXBhcmF0b3IgYmV0d2VlbiB0aGUgcGF0aCBvciBVUkwsIGFuZCB0aGUgcGl4ZWwgZHVtcCBoYXNo IHRoYXQgZm9sbG93cy4KKyAgICBzdHJpbmcgcGF0aE9yVVJMKHRlc3RQYXRoT3JVUkwpOworICAg IHN0cmluZyBleHBlY3RlZFBpeGVsSGFzaDsKKyAgICAKKyAgICBzaXplX3Qgc2VwYXJhdG9yUG9z ID0gcGF0aE9yVVJMLmZpbmQoIiciKTsKKyAgICBpZiAoc2VwYXJhdG9yUG9zICE9IHN0cmluZzo6 bnBvcykgeworICAgICAgICBwYXRoT3JVUkwgPSBzdHJpbmcodGVzdFBhdGhPclVSTCwgMCwgc2Vw YXJhdG9yUG9zKTsKKyAgICAgICAgZXhwZWN0ZWRQaXhlbEhhc2ggPSBzdHJpbmcodGVzdFBhdGhP clVSTCwgc2VwYXJhdG9yUG9zICsgMSk7CisgICAgfQorICAgIAogICAgIEJTVFIgdXJsQlN0cjsK ICAKLSAgICBDRlN0cmluZ1JlZiBzdHIgPSBDRlN0cmluZ0NyZWF0ZVdpdGhDU3RyaW5nKDAsIHBh dGhPclVSTCwga0NGU3RyaW5nRW5jb2RpbmdXaW5kb3dzTGF0aW4xKTsKKyAgICBDRlN0cmluZ1Jl ZiBzdHIgPSBDRlN0cmluZ0NyZWF0ZVdpdGhDU3RyaW5nKDAsIHBhdGhPclVSTC5jX3N0cigpLCBr Q0ZTdHJpbmdFbmNvZGluZ1dpbmRvd3NMYXRpbjEpOwogICAgIENGVVJMUmVmIHVybCA9IENGVVJM Q3JlYXRlV2l0aFN0cmluZygwLCBzdHIsIDApOwogCiAgICAgaWYgKCF1cmwpCkBAIC03MDAsMTMg KzcwOSwxMSBAQCBzdGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0IGNoYXIqIHBhdGhPclVSTCkKIAog ICAgIENGUmVsZWFzZSh1cmwpOwogCi0gICAgY3VycmVudFRlc3QgPSBwYXRoT3JVUkw7Ci0KLSAg ICA6OmdMYXlvdXRUZXN0Q29udHJvbGxlciA9IG5ldyBMYXlvdXRUZXN0Q29udHJvbGxlcihmYWxz ZSwgZmFsc2UpOworICAgIDo6Z0xheW91dFRlc3RDb250cm9sbGVyID0gbmV3IExheW91dFRlc3RD b250cm9sbGVyKHBhdGhPclVSTCwgZXhwZWN0ZWRQaXhlbEhhc2gpOwogICAgIGRvbmUgPSBmYWxz ZTsKICAgICB0b3BMb2FkaW5nRnJhbWUgPSAwOwogCi0gICAgaWYgKHNob3VsZExvZ0ZyYW1lTG9h ZERlbGVnYXRlcyhwYXRoT3JVUkwpKQorICAgIGlmIChzaG91bGRMb2dGcmFtZUxvYWREZWxlZ2F0 ZXMocGF0aE9yVVJMLmNfc3RyKCkpKQogICAgICAgICBnTGF5b3V0VGVzdENvbnRyb2xsZXItPnNl dER1bXBGcmFtZUxvYWRDYWxsYmFja3ModHJ1ZSk7CiAKICAgICBDT01QdHI8SVdlYkhpc3Rvcnk+ IGhpc3RvcnkoQ3JlYXRlLCBDTFNJRF9XZWJIaXN0b3J5KTsKZGlmZiAtLWdpdCBhL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9QaXhlbER1bXBTdXBwb3J0V2luLmNwcCBiL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9QaXhlbER1bXBTdXBwb3J0V2luLmNwcAppbmRleCAyZjIz MTU4Li5kMGI3OWUxIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4v UGl4ZWxEdW1wU3VwcG9ydFdpbi5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv d2luL1BpeGVsRHVtcFN1cHBvcnRXaW4uY3BwCkBAIC0zNCw3ICszNCw3IEBACiAjaW5jbHVkZSA8 d3RmL0Fzc2VydGlvbnMuaD4KICNpbmNsdWRlIDx3dGYvUmV0YWluUHRyLmg+CiAKLVJldGFpblB0 cjxDR0NvbnRleHRSZWY+IGdldEJpdG1hcENvbnRleHRGcm9tV2ViVmlldygpCitQYXNzUmVmUHRy PEJpdG1hcENvbnRleHQ+IGdldEJpdG1hcENvbnRleHRGcm9tV2ViVmlldyhib29sIG9uc2NyZWVu LCBib29sIGluY3JlbWVudGFsUmVwYWludCwgYm9vbCBzd2VlcEhvcml6b250YWxseSwgYm9vbCBk cmF3U2VsZWN0aW9uUmVjdCkKIHsKICAgICBSRUNUIGZyYW1lOwogICAgIGlmICghR2V0V2luZG93 UmVjdCh3ZWJWaWV3V2luZG93LCAmZnJhbWUpKQpAQCAtNDgsOCArNDgsNiBAQCBSZXRhaW5QdHI8 Q0dDb250ZXh0UmVmPiBnZXRCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoKQogICAgIGJtcC5ibWlI ZWFkZXIuYmlCaXRDb3VudCA9IDMyOwogICAgIGJtcC5ibWlIZWFkZXIuYmlDb21wcmVzc2lvbiA9 IEJJX1JHQjsKIAotICAgIC8vIEZJWE1FOiBDdXJyZW50bHkgd2UgbGVhayB0aGlzIEhCSVRNQVAg YmVjYXVzZSB3ZSBkb24ndCBoYXZlIGEgZ29vZCB3YXkKLSAgICAvLyB0byBkZXN0cm95IGl0IHdo ZW4gdGhlIENHQml0bWFwQ29udGV4dCBnZXRzIGRlc3Ryb3llZC4KICAgICB2b2lkKiBiaXRzID0g MDsKICAgICBIQklUTUFQIGJpdG1hcCA9IENyZWF0ZURJQlNlY3Rpb24oMCwgJmJtcCwgRElCX1JH Ql9DT0xPUlMsICZiaXRzLCAwLCAwKTsKIApAQCAtNjMsNiArNjEsOCBAQCBSZXRhaW5QdHI8Q0dD b250ZXh0UmVmPiBnZXRCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoKQogICAgIEFTU0VSVChpbmZv LmJtQml0c1BpeGVsID09IDMyKTsKIAogICAgIFJldGFpblB0cjxDR0NvbG9yU3BhY2VSZWY+IGNv bG9yU3BhY2UoQWRvcHRDRiwgQ0dDb2xvclNwYWNlQ3JlYXRlRGV2aWNlUkdCKCkpOwotICAgIHJl dHVybiBSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPihBZG9wdENGLCBDR0JpdG1hcENvbnRleHRDcmVh dGUoaW5mby5ibUJpdHMsIGluZm8uYm1XaWR0aCwgaW5mby5ibUhlaWdodCwgOCwKLSAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGluZm8uYm1XaWR0aEJ5dGVz LCBjb2xvclNwYWNlLmdldCgpLCBrQ0dCaXRtYXBCeXRlT3JkZXIzMkxpdHRsZSB8IGtDR0ltYWdl QWxwaGFQcmVtdWx0aXBsaWVkRmlyc3QpKTsKKyAgICBDR0NvbnRleHRSZWYgY29udGV4dCA9IENH Qml0bWFwQ29udGV4dENyZWF0ZShpbmZvLmJtQml0cywgaW5mby5ibVdpZHRoLCBpbmZvLmJtSGVp Z2h0LCA4LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg aW5mby5ibVdpZHRoQnl0ZXMsIGNvbG9yU3BhY2UuZ2V0KCksIGtDR0JpdG1hcEJ5dGVPcmRlcjMy TGl0dGxlIHwga0NHSW1hZ2VBbHBoYVByZW11bHRpcGxpZWRGaXJzdCk7CisKKyAgICByZXR1cm4g Qml0bWFwQ29udGV4dDo6Y3JlYXRlQnlBZG9wdGluZ0JpdG1hcEFuZENvbnRleHQoYml0bWFwLCBj b250ZXh0KTsKIH0KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvcnVuLXdlYmtpdC10 ZXN0cyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvcnVuLXdlYmtpdC10ZXN0cwppbmRleCAyYmIxMDk2 Li5jMDEyNzI0IDEwMDc1NQotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3J1bi13ZWJraXQtdGVz dHMKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy9ydW4td2Via2l0LXRlc3RzCkBAIC0xMTIsOCAr MTEyLDYgQEAgbXkgJGxhdW5jaFNhZmFyaSA9IDE7CiBteSAkcGxhdGZvcm07CiBteSAkcGl4ZWxU ZXN0cyA9ICcnOwogbXkgJHF1aWV0ID0gJyc7Ci1teSAkcmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5 ID0gJyc7Ci1teSAkcmVwYWludFRlc3RzID0gJyc7CiBteSAkcmVwb3J0MTBTbG93ZXN0ID0gMDsK IG15ICRyZXNldFJlc3VsdHMgPSAwOwogbXkgJHNob3VsZENoZWNrTGVha3MgPSAwOwpAQCAtMTIz LDcgKzEyMSw3IEBAIG15ICR0ZXN0SFRUUCA9IDE7CiBteSAkdGVzdE1lZGlhID0gMTsKIG15ICR0 ZXN0UmVzdWx0c0RpcmVjdG9yeSA9ICIvdG1wL2xheW91dC10ZXN0LXJlc3VsdHMiOwogbXkgJHRo cmVhZGVkID0gMDsKLW15ICR0aHJlc2hvbGQgPSAwOworbXkgJHRvbGVyYW5jZSA9IDA7CiBteSAk dHJlYXRTa2lwcGVkID0gImRlZmF1bHQiOwogbXkgJHZlcmJvc2UgPSAwOwogbXkgJHVzZVZhbGdy aW5kID0gMDsKQEAgLTE4MCwxNyArMTc4LDE2IEBAIFVzYWdlOiAkcHJvZ3JhbU5hbWUgW29wdGlv bnNdIFt0ZXN0ZGlyfHRlc3RwYXRoIC4uLl0KICAgLWN8LS1jb25maWd1cmF0aW9uIGNvbmZpZyAg ICAgICBTZXQgRHVtcFJlbmRlclRyZWUgYnVpbGQgY29uZmlndXJhdGlvbgogICAtZ3wtLWd1YXJk LW1hbGxvYyAgICAgICAgICAgICAgIEVuYWJsZSBtYWxsb2MgZ3VhcmQKICAgLS1oZWxwICAgICAg ICAgICAgICAgICAgICAgICAgICBTaG93IHRoaXMgaGVscCBtZXNzYWdlCi0gIC1ofC0taG9yaXpv bnRhbC1zd2VlcCAgICAgICAgICAgQ2hhbmdlIHJlcGFpbnQgdG8gc3dlZXAgaG9yaXpvbnRhbGx5 IGluc3RlYWQgb2YgdmVydGljYWxseSAoaW1wbGllcyAtLXJlcGFpbnQtdGVzdHMpCiAgIC0tW25v LV1odHRwICAgICAgICAgICAgICAgICAgICAgUnVuIChvciBkbyBub3QgcnVuKSBodHRwIHRlc3Rz IChkZWZhdWx0OiAkaHR0cERlZmF1bHQpCiAgIC1pfC0taWdub3JlLXRlc3RzICAgICAgICAgICAg ICAgQ29tbWEtc2VwYXJhdGVkIGxpc3Qgb2YgZGlyZWN0b3JpZXMgb3IgdGVzdHMgdG8gaWdub3Jl CiAgIC0tW25vLV1sYXVuY2gtc2FmYXJpICAgICAgICAgICAgTGF1bmNoIChvciBkbyBub3QgbGF1 bmNoKSBTYWZhcmkgdG8gZGlzcGxheSB0ZXN0IHJlc3VsdHMgKGRlZmF1bHQ6ICRsYXVuY2hTYWZh cmlEZWZhdWx0KQogICAtbHwtLWxlYWtzICAgICAgICAgICAgICAgICAgICAgIEVuYWJsZSBsZWFr cyBjaGVja2luZwogICAtLVtuby1dbmV3LXRlc3QtcmVzdWx0cyAgICAgICAgIEdlbmVyYXRlIHJl c3VsdHMgZm9yIG5ldyB0ZXN0cwogICAtcHwtLXBpeGVsLXRlc3RzICAgICAgICAgICAgICAgIEVu YWJsZSBwaXhlbCB0ZXN0cworICAtLXRvbGVyYW5jZSB0ICAgICAgICAgICAgICAgICAgIElnbm9y ZSBpbWFnZSBkaWZmZXJlbmNlcyBsZXNzIHRoYW4gdGhpcyBwZXJjZW50YWdlIChpbXBsaWVzIC0t cGl4ZWwtdGVzdHMpCiAgIC0tcGxhdGZvcm0gICAgICAgICAgICAgICAgICAgICAgT3ZlcnJpZGUg dGhlIGRldGVjdGVkIHBsYXRmb3JtIHRvIHVzZSBmb3IgdGVzdHMgYW5kIHJlc3VsdHMgKGRlZmF1 bHQ6ICRwbGF0Zm9ybSkKICAgLS1wb3J0ICAgICAgICAgICAgICAgICAgICAgICAgICBXZWIgc2Vy dmVyIHBvcnQgdG8gdXNlIHdpdGggaHR0cCB0ZXN0cwogICAtcXwtLXF1aWV0ICAgICAgICAgICAg ICAgICAgICAgIExlc3MgdmVyYm9zZSBvdXRwdXQKLSAgLXJ8LS1yZXBhaW50LXRlc3RzICAgICAg ICAgICAgICBSdW4gcmVwYWludCB0ZXN0cyAoaW1wbGllcyAtLXBpeGVsLXRlc3RzKQogICAtLXJl c2V0LXJlc3VsdHMgICAgICAgICAgICAgICAgIFJlc2V0IEFMTCByZXN1bHRzIChpbmNsdWRpbmcg cGl4ZWwgdGVzdHMgaWYgLS1waXhlbC10ZXN0cyBpcyBzZXQpCiAgIC1vfC0tcmVzdWx0cy1kaXJl Y3RvcnkgICAgICAgICAgT3V0cHV0IHJlc3VsdHMgZGlyZWN0b3J5IChkZWZhdWx0OiAkdGVzdFJl c3VsdHNEaXJlY3RvcnkpCiAgIC0tcmFuZG9tICAgICAgICAgICAgICAgICAgICAgICAgUnVuIHRo ZSB0ZXN0cyBpbiBhIHJhbmRvbSBvcmRlcgpAQCAtMjA2LDcgKzIwMyw2IEBAIFVzYWdlOiAkcHJv Z3JhbU5hbWUgW29wdGlvbnNdIFt0ZXN0ZGlyfHRlc3RwYXRoIC4uLl0KICAgLS1zdHJpY3QgICAg ICAgICAgICAgICAgICAgICAgICBEbyBhIGNvbXBhcmlzb24gd2l0aCB0aGUgb3V0cHV0IG9uIE1h YyAoUXQgb25seSkKICAgLS1bbm8tXXN0cmlwLWVkaXRpbmctY2FsbGJhY2tzICBSZW1vdmUgZWRp dGluZyBjYWxsYmFja3MgZnJvbSBleHBlY3RlZCByZXN1bHRzCiAgIC10fC0tdGhyZWFkZWQgICAg ICAgICAgICAgICAgICAgUnVuIGEgY29uY3VycmVudCBKYXZhU2NyaXB0IHRoZWFkIHdpdGggZWFj aCB0ZXN0Ci0gIC0tdGhyZXNob2xkIHQgICAgICAgICAgICAgICAgICAgSWdub3JlIHBpeGVsIHZh bHVlIGRldmlhdGlvbnMgbGVzcyB0aGFuIG9yIGVxdWFsIHRvIHQKICAgLS12YWxncmluZCAgICAg ICAgICAgICAgICAgICAgICBSdW4gRHVtcFJlbmRlclRyZWUgaW5zaWRlIHZhbGdyaW5kIChRdC9M aW51eCBvbmx5KQogICAtdnwtLXZlcmJvc2UgICAgICAgICAgICAgICAgICAgIE1vcmUgdmVyYm9z ZSBvdXRwdXQgKG92ZXJyaWRlcyAtLXF1aWV0KQogICAtbXwtLW1lcmdlLWxlYWstZGVwdGggYXJn ICAgICAgIE1lcmdlcyBsZWFrIGNhbGxTdGFja3MgYW5kIHByaW50cyB0aGUgbnVtYmVyIG9mIHVu aXF1ZSBsZWFrcyBiZW5lYXRoIGEgY2FsbHN0YWNrIGRlcHRoIG9mIGFyZy4gIERlZmF1bHRzIHRv IDUuCkBAIC0yMjEsNyArMjE3LDYgQEAgbXkgJGdldE9wdGlvbnNSZXN1bHQgPSBHZXRPcHRpb25z KAogICAgICdjfGNvbmZpZ3VyYXRpb249cycgPT4gXCRjb25maWd1cmF0aW9uLAogICAgICdndWFy ZC1tYWxsb2N8ZycgPT4gXCRndWFyZE1hbGxvYywKICAgICAnaGVscCcgPT4gXCRzaG93SGVscCwK LSAgICAnaG9yaXpvbnRhbC1zd2VlcHxoJyA9PiBcJHJlcGFpbnRTd2VlcEhvcml6b250YWxseSwK ICAgICAnaHR0cCEnID0+IFwkdGVzdEhUVFAsCiAgICAgJ2lnbm9yZS10ZXN0c3xpPXMnID0+IFwk aWdub3JlVGVzdHMsCiAgICAgJ2xhdW5jaC1zYWZhcmkhJyA9PiBcJGxhdW5jaFNhZmFyaSwKQEAg LTIzMCw3ICsyMjUsNiBAQCBteSAkZ2V0T3B0aW9uc1Jlc3VsdCA9IEdldE9wdGlvbnMoCiAgICAg J3BsYXRmb3JtPXMnID0+IFwkcGxhdGZvcm0sCiAgICAgJ3BvcnQ9aScgPT4gXCRodHRwZFBvcnQs CiAgICAgJ3F1aWV0fHEnID0+IFwkcXVpZXQsCi0gICAgJ3JlcGFpbnQtdGVzdHN8cicgPT4gXCRy ZXBhaW50VGVzdHMsCiAgICAgJ3Jlc2V0LXJlc3VsdHMnID0+IFwkcmVzZXRSZXN1bHRzLAogICAg ICduZXctdGVzdC1yZXN1bHRzIScgPT4gXCRnZW5lcmF0ZU5ld1Jlc3VsdHMsCiAgICAgJ3Jlc3Vs dHMtZGlyZWN0b3J5fG89cycgPT4gXCR0ZXN0UmVzdWx0c0RpcmVjdG9yeSwKQEAgLTIzOSw3ICsy MzMsNyBAQCBteSAkZ2V0T3B0aW9uc1Jlc3VsdCA9IEdldE9wdGlvbnMoCiAgICAgJ3NraXBwZWQ9 cycgPT4gXCZ2YWxpZGF0ZVNraXBwZWRBcmcsCiAgICAgJ3Nsb3dlc3QnID0+IFwkcmVwb3J0MTBT bG93ZXN0LAogICAgICd0aHJlYWRlZHx0JyA9PiBcJHRocmVhZGVkLAotICAgICd0aHJlc2hvbGQ9 aScgPT4gXCR0aHJlc2hvbGQsCisgICAgJ3RvbGVyYW5jZT1mJyA9PiBcJHRvbGVyYW5jZSwKICAg ICAndmVyYm9zZXx2JyA9PiBcJHZlcmJvc2UsCiAgICAgJ3ZhbGdyaW5kJyA9PiBcJHVzZVZhbGdy aW5kLAogICAgICdzYW1wbGUtb24tdGltZW91dCEnID0+IFwkcnVuU2FtcGxlLApAQCAtMjY3LDEw ICsyNjEsNyBAQCBzZXRDb25maWd1cmF0aW9uKCRjb25maWd1cmF0aW9uKTsKIAogbXkgJGNvbmZp Z3VyYXRpb25PcHRpb24gPSAiLS0iIC4gbGMoJGNvbmZpZ3VyYXRpb24pOwogCi0kcmVwYWludFRl c3RzID0gMSBpZiAkcmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5OwotCi0kcGl4ZWxUZXN0cyA9IDEg aWYgJHJlcGFpbnRUZXN0czsKLSRwaXhlbFRlc3RzID0gMSBpZiAkdGhyZXNob2xkID4gMDsKKyRw aXhlbFRlc3RzID0gMSBpZiAkdG9sZXJhbmNlID4gMDsKIAogJHRlc3RzUGVyRHVtcFRvb2wgPSAx MDAwIGlmICEkdGVzdHNQZXJEdW1wVG9vbDsKIApAQCAtMjkxLDcgKzI4Miw3IEBAIHNldFJ1bjY0 Qml0KCRydW42NEJpdCk7CiAKIGNoZGlyV2ViS2l0KCk7CiAKLWlmKCFkZWZpbmVkKCRyb290KSl7 CitpZiAoIWRlZmluZWQoJHJvb3QpKSB7CiAgICAgIyBQdXNoIHRoZSBwYXJhbWV0ZXJzIHRvIGJ1 aWxkLWR1bXByZW5kZXJ0cmVlIGFzIGFuIGFycmF5CiAgICAgbXkgQGFyZ3M7CiAgICAgcHVzaChA YXJncywgJGNvbmZpZ3VyYXRpb25PcHRpb24pOwpAQCAtNDU0LDE5ICs0NDUsMTUgQEAgbXkgJWR1 cmF0aW9uczsKIG15ICRjb3VudCA9IDA7CiBteSAkbGVha3NPdXRwdXRGaWxlTnVtYmVyID0gMTsK IG15ICR0b3RhbExlYWtzID0gMDsKLW15ICRkdW1wQWxsUGl4ZWxzID0gJHBpeGVsVGVzdHMgJiYg JHJlc2V0UmVzdWx0czsKIAogbXkgQHRvb2xBcmdzID0gKCk7Ci1wdXNoIEB0b29sQXJncywgIi0t ZHVtcC1hbGwtcGl4ZWxzIiBpZiAkZHVtcEFsbFBpeGVsczsKIHB1c2ggQHRvb2xBcmdzLCAiLS1w aXhlbC10ZXN0cyIgaWYgJHBpeGVsVGVzdHM7Ci1wdXNoIEB0b29sQXJncywgIi0tcmVwYWludCIg aWYgJHJlcGFpbnRUZXN0czsKLXB1c2ggQHRvb2xBcmdzLCAiLS1ob3Jpem9udGFsLXN3ZWVwIiBp ZiAkcmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5OwogcHVzaCBAdG9vbEFyZ3MsICItLXRocmVhZGVk IiBpZiAkdGhyZWFkZWQ7CiBwdXNoIEB0b29sQXJncywgIi0tY29tcGxleC10ZXh0IiBpZiAkY29t cGxleFRleHQ7CiBwdXNoIEB0b29sQXJncywgIi0iOwogCiBteSBAZGlmZlRvb2xBcmdzID0gKCk7 Ci1wdXNoIEBkaWZmVG9vbEFyZ3MsICItLXRocmVzaG9sZCIsICR0aHJlc2hvbGQ7CitwdXNoIEBk aWZmVG9vbEFyZ3MsICItLXRvbGVyYW5jZSIsICR0b2xlcmFuY2U7CiAKICR8ID0gMTsKIApAQCAt NTUzLDYgKzU0MCwyMCBAQCBmb3IgbXkgJHRlc3QgKEB0ZXN0cykgewogCiAgICAgbXkgJHN0YXJ0 VGltZSA9IHRpbWUgaWYgJHJlcG9ydDEwU2xvd2VzdDsKIAorICAgICMgVHJ5IHRvIHJlYWQgZXhw ZWN0ZWQgaGFzaCBmaWxlIGZvciBwaXhlbCB0ZXN0cworICAgIG15ICRzdWZmaXhFeHBlY3RlZEhh c2ggPSAiIjsKKyAgICBpZiAoJHBpeGVsVGVzdHMgJiYgISRyZXNldFJlc3VsdHMpIHsKKyAgICAg ICAgbXkgJGV4cGVjdGVkUGl4ZWxEaXIgPSBleHBlY3RlZERpcmVjdG9yeUZvclRlc3QoJGJhc2Us IDAsICJwbmciKTsKKyAgICAgICAgaWYgKG9wZW4gRVhQRUNURURIQVNILCAiJGV4cGVjdGVkUGl4 ZWxEaXIvJGJhc2UtJGV4cGVjdGVkVGFnLmNoZWNrc3VtIikgeworICAgICAgICAgICAgbXkgJGV4 cGVjdGVkSGFzaCA9IDxFWFBFQ1RFREhBU0g+OworICAgICAgICAgICAgY2hvbXAoJGV4cGVjdGVk SGFzaCk7CisgICAgICAgICAgICBjbG9zZSBFWFBFQ1RFREhBU0g7CisgICAgICAgICAgICAKKyAg ICAgICAgICAgICMgRm9ybWF0IGV4cGVjdGVkIGhhc2ggaW50byBhIHN1ZmZpeCBzdHJpbmcgdGhh dCBpcyBhcHBlbmRlZCB0byB0aGUgcGF0aCAvIFVSTCBwYXNzZWQgdG8gRFJUCisgICAgICAgICAg ICAkc3VmZml4RXhwZWN0ZWRIYXNoID0gIickZXhwZWN0ZWRIYXNoIjsKKyAgICAgICAgfQorICAg IH0KKwogICAgIGlmICgkdGVzdCAhfiAvXmh0dHBcLy8pIHsKICAgICAgICAgbXkgJHRlc3RQYXRo ID0gIiR0ZXN0RGlyZWN0b3J5LyR0ZXN0IjsKICAgICAgICAgaWYgKGlzQ3lnd2luKCkpIHsKQEAg LTU2MCwxNyArNTYxLDE3IEBAIGZvciBteSAkdGVzdCAoQHRlc3RzKSB7CiAgICAgICAgIH0gZWxz ZSB7CiAgICAgICAgICAgICAkdGVzdFBhdGggPSBjYW5vbnBhdGgoJHRlc3RQYXRoKTsKICAgICAg ICAgfQotICAgICAgICBwcmludCBPVVQgIiR0ZXN0UGF0aFxuIjsKKyAgICAgICAgcHJpbnQgT1VU ICIkdGVzdFBhdGgkc3VmZml4RXhwZWN0ZWRIYXNoXG4iOwogICAgIH0gZWxzZSB7CiAgICAgICAg IG9wZW5IVFRQRElmTmVlZGVkKCk7CiAgICAgICAgIGlmICgkdGVzdCAhfiAvXmh0dHBcL3Rlc3Rz XC9sb2NhbFwvLyAmJiAkdGVzdCAhfiAvXmh0dHBcL3Rlc3RzXC9zc2xcLy8gJiYgJHRlc3QgIX4g L15odHRwXC90ZXN0c1wvbWVkaWFcLy8pIHsKICAgICAgICAgICAgIG15ICRwYXRoID0gY2Fub25w YXRoKCR0ZXN0KTsKICAgICAgICAgICAgICRwYXRoID1+IHMvXmh0dHBcL3Rlc3RzXC8vLzsKLSAg ICAgICAgICAgIHByaW50IE9VVCAiaHR0cDovLzEyNy4wLjAuMTokaHR0cGRQb3J0LyRwYXRoXG4i OworICAgICAgICAgICAgcHJpbnQgT1VUICJodHRwOi8vMTI3LjAuMC4xOiRodHRwZFBvcnQvJHBh dGgkc3VmZml4RXhwZWN0ZWRIYXNoXG4iOwogICAgICAgICB9IGVsc2lmICgkdGVzdCA9fiAvXmh0 dHBcL3Rlc3RzXC9zc2xcLy8pIHsKICAgICAgICAgICAgIG15ICRwYXRoID0gY2Fub25wYXRoKCR0 ZXN0KTsKICAgICAgICAgICAgICRwYXRoID1+IHMvXmh0dHBcL3Rlc3RzXC8vLzsKLSAgICAgICAg ICAgIHByaW50IE9VVCAiaHR0cHM6Ly8xMjcuMC4wLjE6JGh0dHBkU1NMUG9ydC8kcGF0aFxuIjsK KyAgICAgICAgICAgIHByaW50IE9VVCAiaHR0cHM6Ly8xMjcuMC4wLjE6JGh0dHBkU1NMUG9ydC8k cGF0aCRzdWZmaXhFeHBlY3RlZEhhc2hcbiI7CiAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAg ICBteSAkdGVzdFBhdGggPSAiJHRlc3REaXJlY3RvcnkvJHRlc3QiOwogICAgICAgICAgICAgaWYg KGlzQ3lnd2luKCkpIHsKQEAgLTU3OCw3ICs1NzksNyBAQCBmb3IgbXkgJHRlc3QgKEB0ZXN0cykg ewogICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgICAkdGVzdFBhdGggPSBjYW5v bnBhdGgoJHRlc3RQYXRoKTsKICAgICAgICAgICAgIH0KLSAgICAgICAgICAgIHByaW50IE9VVCAi JHRlc3RQYXRoXG4iOworICAgICAgICAgICAgcHJpbnQgT1VUICIkdGVzdFBhdGgkc3VmZml4RXhw ZWN0ZWRIYXNoXG4iOwogICAgICAgICB9CiAgICAgfQogCkBAIC02NDEsNyArNjQyLDYgQEAgZm9y IG15ICR0ZXN0IChAdGVzdHMpIHsKICAgICBteSAkZGlmZlBlcmNlbnRhZ2UgPSAiIjsKICAgICBt eSAkZGlmZlJlc3VsdCA9ICJwYXNzZWQiOwogCi0gICAgIyBMb29rIGZvciB0aGUgcGl4ZWwgYmxv Y2ssIGFuZCBkbyBhbiBpbWFnZSBkaWZmIGlmIHdlIGZpbmQgb25lCiAgICAgbXkgJGFjdHVhbEhh c2ggPSAiIjsKICAgICBteSAkZXhwZWN0ZWRIYXNoID0gIiI7CiAgICAgbXkgJGFjdHVhbFBOR1Np emUgPSAwOwpAQCAtNjUwLDcgKzY1MCw3IEBAIGZvciBteSAkdGVzdCAoQHRlc3RzKSB7CiAgICAg ICAgIGxhc3QgaWYgLyNFT0YvOwogICAgICAgICBpZiAoL0FjdHVhbEhhc2g6IChbYS1mMC05XXsz Mn0pLykgewogICAgICAgICAgICAgJGFjdHVhbEhhc2ggPSAkMTsKLSAgICAgICAgfSBlbHNpZiAo L0Jhc2VsaW5lSGFzaDogKFthLWYwLTldezMyfSkvKSB7CisgICAgICAgIH0gZWxzaWYgKC9FeHBl Y3RlZEhhc2g6IChbYS1mMC05XXszMn0pLykgewogICAgICAgICAgICAgJGV4cGVjdGVkSGFzaCA9 ICQxOwogICAgICAgICB9IGVsc2lmICgvQ29udGVudC1MZW5ndGg6IChcZCspXHMqLykgewogICAg ICAgICAgICAgJGFjdHVhbFBOR1NpemUgPSAkMTsKQEAgLTY1OCw0MiArNjU4LDU4IEBAIGZvciBt eSAkdGVzdCAoQHRlc3RzKSB7CiAgICAgICAgIH0KICAgICB9CiAKLSAgICAjIElmIHdlIGdvdCBz b21lIFBORyBkYXRhLCBkaWZmIHdpdGggZXhwZWN0ZWQKKyAgICBpZiAoJHZlcmJvc2UgJiYgJHBp eGVsVGVzdHMgJiYgISRyZXNldFJlc3VsdHMgJiYgJGFjdHVhbFBOR1NpemUpIHsKKyAgICAgICAg aWYgKCRhY3R1YWxIYXNoIGVxICIiICYmICRleHBlY3RlZEhhc2ggZXEgIiIpIHsKKyAgICAgICAg ICAgIHByaW50RmFpbHVyZU1lc3NhZ2VGb3JUZXN0KCR0ZXN0LCAiV0FSTklORzogYWN0dWFsICYg ZXhwZWN0ZWQgcGl4ZWwgaGFzaGVzIGFyZSBtaXNzaW5nISIpOworICAgICAgICB9IGVsc2lmICgk YWN0dWFsSGFzaCBlcSAiIikgeworICAgICAgICAgICAgcHJpbnRGYWlsdXJlTWVzc2FnZUZvclRl c3QoJHRlc3QsICJXQVJOSU5HOiBhY3R1YWwgcGl4ZWwgaGFzaCBpcyBtaXNzaW5nISIpOworICAg ICAgICB9IGVsc2lmICgkZXhwZWN0ZWRIYXNoIGVxICIiKSB7CisgICAgICAgICAgICBwcmludEZh aWx1cmVNZXNzYWdlRm9yVGVzdCgkdGVzdCwgIldBUk5JTkc6IGV4cGVjdGVkIHBpeGVsIGhhc2gg aXMgbWlzc2luZyEiKTsKKyAgICAgICAgfQorICAgIH0KKwogICAgIGlmICgkYWN0dWFsUE5HU2l6 ZSA+IDApIHsKICAgICAgICAgbXkgJGV4cGVjdGVkUGl4ZWxEaXIgPSBleHBlY3RlZERpcmVjdG9y eUZvclRlc3QoJGJhc2UsICRpc1RleHQsICJwbmciKTsKIAotICAgICAgICBpZiAoJGV4cGVjdGVk SGFzaCBuZSAkYWN0dWFsSGFzaCAmJiAtZiAiJGV4cGVjdGVkUGl4ZWxEaXIvJGJhc2UtJGV4cGVj dGVkVGFnLnBuZyIpIHsKLSAgICAgICAgICAgIG15ICRleHBlY3RlZFBOR1NpemUgPSAtcyAiJGV4 cGVjdGVkUGl4ZWxEaXIvJGJhc2UtJGV4cGVjdGVkVGFnLnBuZyI7Ci0gICAgICAgICAgICBteSAk ZXhwZWN0ZWRQTkcgPSAiIjsKLSAgICAgICAgICAgIG9wZW4gRVhQRUNURURQTkcsICIkZXhwZWN0 ZWRQaXhlbERpci8kYmFzZS0kZXhwZWN0ZWRUYWcucG5nIjsKLSAgICAgICAgICAgIHJlYWQoRVhQ RUNURURQTkcsICRleHBlY3RlZFBORywgJGV4cGVjdGVkUE5HU2l6ZSk7CisgICAgICAgIGlmICgh JHJlc2V0UmVzdWx0cyAmJiAoJGV4cGVjdGVkSGFzaCBuZSAkYWN0dWFsSGFzaCB8fCAoJGFjdHVh bEhhc2ggZXEgIiIgJiYgJGV4cGVjdGVkSGFzaCBlcSAiIikpKSB7CisgICAgICAgICAgICBpZiAo LWYgIiRleHBlY3RlZFBpeGVsRGlyLyRiYXNlLSRleHBlY3RlZFRhZy5wbmciKSB7CisgICAgICAg ICAgICAgICAgbXkgJGV4cGVjdGVkUE5HU2l6ZSA9IC1zICIkZXhwZWN0ZWRQaXhlbERpci8kYmFz ZS0kZXhwZWN0ZWRUYWcucG5nIjsKKyAgICAgICAgICAgICAgICBteSAkZXhwZWN0ZWRQTkcgPSAi IjsKKyAgICAgICAgICAgICAgICBvcGVuIEVYUEVDVEVEUE5HLCAiJGV4cGVjdGVkUGl4ZWxEaXIv JGJhc2UtJGV4cGVjdGVkVGFnLnBuZyI7CisgICAgICAgICAgICAgICAgcmVhZChFWFBFQ1RFRFBO RywgJGV4cGVjdGVkUE5HLCAkZXhwZWN0ZWRQTkdTaXplKTsKIAotICAgICAgICAgICAgcHJpbnQg RElGRk9VVCAiQ29udGVudC1MZW5ndGg6ICRhY3R1YWxQTkdTaXplXG4iOwotICAgICAgICAgICAg cHJpbnQgRElGRk9VVCAkYWN0dWFsUE5HOworICAgICAgICAgICAgICAgIHByaW50IERJRkZPVVQg IkNvbnRlbnQtTGVuZ3RoOiAkYWN0dWFsUE5HU2l6ZVxuIjsKKyAgICAgICAgICAgICAgICBwcmlu dCBESUZGT1VUICRhY3R1YWxQTkc7CiAKLSAgICAgICAgICAgIHByaW50IERJRkZPVVQgIkNvbnRl bnQtTGVuZ3RoOiAkZXhwZWN0ZWRQTkdTaXplXG4iOwotICAgICAgICAgICAgcHJpbnQgRElGRk9V VCAkZXhwZWN0ZWRQTkc7CisgICAgICAgICAgICAgICAgcHJpbnQgRElGRk9VVCAiQ29udGVudC1M ZW5ndGg6ICRleHBlY3RlZFBOR1NpemVcbiI7CisgICAgICAgICAgICAgICAgcHJpbnQgRElGRk9V VCAkZXhwZWN0ZWRQTkc7CiAKLSAgICAgICAgICAgIHdoaWxlICg8RElGRklOPikgewotICAgICAg ICAgICAgICAgIGxhc3QgaWYgL15lcnJvci8gfHwgL15kaWZmOi87Ci0gICAgICAgICAgICAgICAg aWYgKC9Db250ZW50LUxlbmd0aDogKFxkKylccyovKSB7Ci0gICAgICAgICAgICAgICAgICAgIHJl YWQoRElGRklOLCAkZGlmZlBORywgJDEpOworICAgICAgICAgICAgICAgIHdoaWxlICg8RElGRklO PikgeworICAgICAgICAgICAgICAgICAgICBsYXN0IGlmIC9eZXJyb3IvIHx8IC9eZGlmZjovOwor ICAgICAgICAgICAgICAgICAgICBpZiAoL0NvbnRlbnQtTGVuZ3RoOiAoXGQrKVxzKi8pIHsKKyAg ICAgICAgICAgICAgICAgICAgICAgIHJlYWQoRElGRklOLCAkZGlmZlBORywgJDEpOworICAgICAg ICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgfQogCi0gICAg ICAgICAgICBpZiAoL15kaWZmOiAoLispJSAocGFzc2VkfGZhaWxlZCkvKSB7Ci0gICAgICAgICAg ICAgICAgJGRpZmZQZXJjZW50YWdlID0gJDE7Ci0gICAgICAgICAgICAgICAgJGltYWdlRGlmZmVy ZW5jZXN7JGJhc2V9ID0gJGRpZmZQZXJjZW50YWdlOwotICAgICAgICAgICAgICAgICRkaWZmUmVz dWx0ID0gJDI7CisgICAgICAgICAgICAgICAgaWYgKC9eZGlmZjogKC4rKSUgKHBhc3NlZHxmYWls ZWQpLykgeworICAgICAgICAgICAgICAgICAgICAkZGlmZlBlcmNlbnRhZ2UgPSAkMTsKKyAgICAg ICAgICAgICAgICAgICAgJGltYWdlRGlmZmVyZW5jZXN7JGJhc2V9ID0gJGRpZmZQZXJjZW50YWdl OworICAgICAgICAgICAgICAgICAgICAkZGlmZlJlc3VsdCA9ICQyOworICAgICAgICAgICAgICAg IH0KKyAgICAgICAgICAgICAgICAKKyAgICAgICAgICAgICAgICBpZiAoJGRpZmZQZXJjZW50YWdl ID09IDApIHsKKyAgICAgICAgICAgICAgICAgICAgcHJpbnRGYWlsdXJlTWVzc2FnZUZvclRlc3Qo JHRlc3QsICJwaXhlbCBoYXNoIGZhaWxlZCAoYnV0IHBpeGVsIHRlc3Qgc3RpbGwgcGFzc2VzKSIp OworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0gZWxzaWYgKCR2ZXJib3NlKSB7Cisg ICAgICAgICAgICAgICAgcHJpbnRGYWlsdXJlTWVzc2FnZUZvclRlc3QoJHRlc3QsICJXQVJOSU5H OiBleHBlY3RlZCBpbWFnZSBpcyBtaXNzaW5nISIpOwogICAgICAgICAgICAgfQogICAgICAgICB9 CiAKLSAgICAgICAgaWYgKCRhY3R1YWxQTkdTaXplICYmICgkcmVzZXRSZXN1bHRzIHx8ICEtZiAi JGV4cGVjdGVkUGl4ZWxEaXIvJGJhc2UtJGV4cGVjdGVkVGFnLnBuZyIpKSB7CisgICAgICAgIGlm ICgkcmVzZXRSZXN1bHRzIHx8ICEtZiAiJGV4cGVjdGVkUGl4ZWxEaXIvJGJhc2UtJGV4cGVjdGVk VGFnLnBuZyIpIHsKICAgICAgICAgICAgIG1rcGF0aCBjYXRmaWxlKCRleHBlY3RlZFBpeGVsRGly LCBkaXJuYW1lKCRiYXNlKSkgaWYgJHRlc3REaXJlY3RvcnkgbmUgJGV4cGVjdGVkUGl4ZWxEaXI7 CiAgICAgICAgICAgICB3cml0ZVRvRmlsZSgiJGV4cGVjdGVkUGl4ZWxEaXIvJGJhc2UtJGV4cGVj dGVkVGFnLnBuZyIsICRhY3R1YWxQTkcpOwogICAgICAgICB9CiAKLSAgICAgICAgIyB1cGRhdGUg dGhlIGV4cGVjdGVkIGhhc2ggaWYgdGhlIGltYWdlIGRpZmYgc2FpZCB0aGF0IHRoZXJlIHdhcyBu byBkaWZmZXJlbmNlCiAgICAgICAgIGlmICgkYWN0dWFsSGFzaCBuZSAiIiAmJiAoJHJlc2V0UmVz dWx0cyB8fCAhLWYgIiRleHBlY3RlZFBpeGVsRGlyLyRiYXNlLSRleHBlY3RlZFRhZy5jaGVja3N1 bSIpKSB7CiAgICAgICAgICAgICB3cml0ZVRvRmlsZSgiJGV4cGVjdGVkUGl4ZWxEaXIvJGJhc2Ut JGV4cGVjdGVkVGFnLmNoZWNrc3VtIiwgJGFjdHVhbEhhc2gpOwogICAgICAgICB9CkBAIC03NDEs NyArNzU3LDcgQEAgZm9yIG15ICR0ZXN0IChAdGVzdHMpIHsKICAgICAgICAgICBzeXN0ZW0gImRp ZmYgLXUgXCIvdG1wL2V4cGVjdGVkLnR4dFwiIFwiL3RtcC9hY3R1YWwudHh0XCIgPiBcIi90bXAv c2ltcGxpZmllZC5kaWZmXCIiOwogCiAgICAgICAgICAgJGRpZmZSZXN1bHQgPSAiZmFpbGVkIjsK LSAgICAgICAgICBpZigkdmVyYm9zZSkgeworICAgICAgICAgIGlmICgkdmVyYm9zZSkgewogICAg ICAgICAgICAgcHJpbnQgIlxuIjsKICAgICAgICAgICAgIHN5c3RlbSAiY2F0IC90bXAvc2ltcGxp ZmllZC5kaWZmIjsKICAgICAgICAgICAgIHByaW50ICJmYWlsZWQhISEhISI7Cg== 24702 2008-10-27 17:57:20 -0700 2008-10-27 18:04:04 -0700 Final patch (for real) Final-Patch-2.txt text/plain 81452 pol ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCAxOGIwY2VkLi5mNjc0YmI4IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsODcgQEAKKzIwMDgtMTAt MjcgIFBpZXJyZS1PbGl2aWVyIExhdG91ciAgPHBvbEBhcHBsZS5jb20+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUHJpbWFyeSBjaGFuZ2VzIGluIER1 bXBSZW5kZXJUcmVlOgorICAgICAgICAtIEVuc3VyZSBmb250IHNtb290aGluZyBpcyBkaXNhYmxl ZCAodGhpcyBpcyBhbHNvIGNhbGxlZCBMQ0QgYW50aS1hbGlhc2luZyBhbmQKKyAgICAgICAgaXMg ZGlmZmVyZW50IGZyb20gcmVndWxhciBmb250IENHIGFudGktYWxpYXNpbmcpIGFzIGZvbnQtc21v b3RoaW5nIHNldHRpbmdzCisgICAgICAgIGRlcGVuZHMgb24gdGhlIGRpc3BsYXkgYW5kIGNhbiBh bHNvIGJlIGNoYW5nZWQgYnkgdGhlIHVzZXIKKyAgICAgICAgLSBVc2UgYSBuZXcgY2xlYXJlZCBi dWZmZXIgZm9yIGVhY2ggdGVzdCBpbnN0ZWFkIG9mIHRoZSByZXVzaW5nIHNhbWUgb25lIHRvCisg ICAgICAgIGF2b2lkIHBvdGVudGlhbCByZXN1bHQgY29ycnVwdGlvbiBhY3Jvc3MgdGVzdHMKKyAg ICAgICAgLSBDYW4gbm93IHJlY2VpdmUgdGhlIGV4cGVjdGVkIHBpeGVsIGhhc2ggYXMgYSBzdWZm aXggdG8gdGhlIHRlc3QgcGF0aCBvcgorICAgICAgICB1cmwgYXMgInBhdGgnaGFzaCIKKyAgICAg ICAgLSBNYWtlIHN1cmUgaGFzaCBpcyBjb21wdXRlZCBpbiBhIGVuZGlhbi1pbmRlcGVuZGVudCB3 YXkKKyAgICAgICAgLSBJbXByb3ZlIHRoZSBjb2RlIHRoYXQgc2V0cy9yZXN0b3JlcyB0aGUgc2Ny ZWVuIGNvbG9yIHByb2ZpbGUKKyAgICAgICAgLSBNYWtlIHRoZSBjb2RlIG1vcmUgY3Jvc3MtcGxh dGZvcm15IHdpdGggc3RkOjpzdHJpbmcgZ29vZG5lc3MKKyAgICAgICAgLSBBZGRlZCBhbiAib24t c2NyZWVuIiBtb2RlIHdoZXJlIHRoZSBzbmFwc2hvdCB3aWxsIHRha2UgaW50byBhY2NvdW50IHN1 cmZhY2VzCisgICAgICAgIG9uIHRoZSB3aW5kb3cgKGxpa2UgT3BlbkdMIGNvbnRlbnQpOiB0aGlz IHVzZXMgdGhlIG5ldyBDRyBBUElzIG9uIDEwLjUgb3IKKyAgICAgICAgcmVhZGluZyBmcm9tIHRo ZSBkaXNwbGF5IGZyYW1lYnVmZmVyIG9uIDEwLjQuIFRoaXMgbW9kZSBpcyBub3QgYWN0aXZlIGJ5 CisgICAgICAgIGRlZmF1bHQgZm9yIHBlcmZvcm1hbmNlIHJlYXNvbiwgYnV0IG11c3QgYmUgZXhw bGljaXRseSBhY3RpdmF0ZWQgZnJvbSB0aGUgdGVzdAorICAgICAgICBmaWxlIHVzaW5nIHRoZSBu ZXcgInRlc3RPbnNjcmVlbigpIiBKUyBBUEkuCisKKyAgICAgICAgUHJpbWFyeSBjaGFuZ2VzIGlu IEltYWdlRGlmZjoKKyAgICAgICAgLSBQcm92aWRlIGEgbmV3IGNvbXBhcmlzb24gYWxnb3JpdGht IHRoYXQgaXMgbW9yZSB0b2xlcmFudCB0byAiYWNjZXB0YWJsZSIKKyAgICAgICAgZmFpbHVyZXMg KGkuZS4gdmVyeSBzbWFsbCBkaWZmZXJlbmNlcyBpbiBmb250IHJlbmRlcmluZywgd2hpY2ggLS10 aHJlc2hvbGQgaXMKKyAgICAgICAgbm90IHJlYWxseSBnb29kIGF0IGhhbmRsaW5nKQorICAgICAg ICAtIEdlbmVyYXRlIG5vcm1hbGl6ZWQgaW50ZW5zaXR5LW9ubHkgZGlmZiBpbWFnZXMKKworICAg ICAgICBQcmltYXJ5IGNoYW5nZXMgaW4gcnVuLXdlYmtpdC10ZXN0czoKKyAgICAgICAgLSBUYWtl IGFkdmFudGFnZSBvZiBoYXNoZXMgZm9yIHBpeGVsIHRlc3RzIHdoaWNoIG1ha2VzIHRoZW0gbXVj aCBmYXN0ZXIgYnkKKyAgICAgICAgbWluaW1pemluZyBpbWFnZSBjb21wYXJpc29ucworICAgICAg ICAtIFJlbW92ZWQgcmVwYWludCBvcHRpb25zIGFzIHRoZXNlIHNob3VsZCBiZSBzZXQgZnJvbSB3 aXRoaW4gdGVzdCBmaWxlcyB1c2luZworICAgICAgICBKUyBBUEkKKyAgICAgICAgLSBSZXBsYWNl ZCAidGhyZXNob2xkIiBvcHRpb24gaW4gIGJ5ICJ0b2xlcmFuY2UiIGV4cHJlc3NlZCBpbiBwZXJj ZW50cworICAgICAgICAtIEFkZGVkIG1vcmUgbG9nZ2luZyB3aGVuIGluICJ2ZXJib3NlIiBtb2Rl CisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMzIy CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvRHVtcFJlbmRlclRyZWUueGNvZGVwcm9qL3Byb2pl Y3QucGJ4cHJvajoKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9Gb3J3YXJkaW5nSGVhZGVycy93 dGYvUGFzc1JlZlB0ci5oOiBDb3BpZWQgZnJvbSBKYXZhU2NyaXB0R2x1ZS9Gb3J3YXJkaW5nSGVh ZGVycy93dGYvUGFzc1JlZlB0ci5oLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0ZvcndhcmRp bmdIZWFkZXJzL3d0Zi9SZWZQdHIuaDogQ29waWVkIGZyb20gSmF2YVNjcmlwdEdsdWUvRm9yd2Fy ZGluZ0hlYWRlcnMvd3RmL1JlZlB0ci5oLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91 dFRlc3RDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpMYXlv dXRUZXN0Q29udHJvbGxlcik6CisgICAgICAgICh0ZXN0T25zY3JlZW5DYWxsYmFjayk6CisgICAg ICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6c3RhdGljRnVuY3Rpb25zKToKKyAgICAgICAgKiBE dW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oOgorICAgICAgICAoTGF5b3V0VGVz dENvbnRyb2xsZXI6OnRlc3RPbnNjcmVlbik6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxl cjo6c2V0VGVzdE9uc2NyZWVuKToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjp0ZXN0 UGF0aE9yVVJMKToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpleHBlY3RlZFBpeGVs SGFzaCk6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvUGl4ZWxEdW1wU3VwcG9ydC5oOgorICAg ICAgICAqIER1bXBSZW5kZXJUcmVlL2NnL0ltYWdlRGlmZkNHLmNwcDoKKyAgICAgICAgKHN0cnRv Zik6CisgICAgICAgIChyZWxlYXNlTWFsbG9jQnVmZmVyKToKKyAgICAgICAgKGNyZWF0ZURpZmZl cmVuY2VJbWFnZSk6CisgICAgICAgIChpbWFnZUhhc0FscGhhKToKKyAgICAgICAgKG1haW4pOgor ICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5jcHA6CisgICAg ICAgIChjb21wdXRlTUQ1SGFzaFN0cmluZ0ZvckJpdG1hcENvbnRleHQpOgorICAgICAgICAoZHVt cFdlYlZpZXdBc1BpeGVsc0FuZENvbXBhcmVXaXRoRXhwZWN0ZWQpOgorICAgICAgICAqIER1bXBS ZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5oOgorICAgICAgICAoQml0bWFwQ29udGV4 dDo6Y3JlYXRlQnlBZG9wdGluZ0JpdG1hcEFuZENvbnRleHQpOgorICAgICAgICAoQml0bWFwQ29u dGV4dDo6fkJpdG1hcENvbnRleHQpOgorICAgICAgICAoQml0bWFwQ29udGV4dDo6Y2dDb250ZXh0 KToKKyAgICAgICAgKEJpdG1hcENvbnRleHQ6OkJpdG1hcENvbnRleHQpOgorICAgICAgICAqIER1 bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbToKKyAgICAgICAgKHNob3VsZElnbm9y ZVdlYkNvcmVOb2RlTGVha3MpOgorICAgICAgICAoc2V0RGVmYXVsdHNUb0NvbnNpc3RlbnRWYWx1 ZXNGb3JUZXN0aW5nKToKKyAgICAgICAgKGNyYXNoSGFuZGxlcik6CisgICAgICAgIChpbml0aWFs aXplR2xvYmFsc0Zyb21Db21tYW5kTGluZU9wdGlvbnMpOgorICAgICAgICAocHJlcGFyZUNvbnNp c3RlbnRUZXN0aW5nRW52aXJvbm1lbnQpOgorICAgICAgICAoZHVtcFJlbmRlclRyZWUpOgorICAg ICAgICAoc2l6ZVdlYlZpZXdGb3JDdXJyZW50VGVzdCk6CisgICAgICAgIChkdW1wKToKKyAgICAg ICAgKHJ1blRlc3QpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9QaXhlbER1bXBTdXBw b3J0TWFjLm1tOgorICAgICAgICAocmVzdG9yZU1haW5EaXNwbGF5Q29sb3JQcm9maWxlKToKKyAg ICAgICAgKHNldHVwTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUpOgorICAgICAgICAoY3JlYXRlQml0 bWFwQ29udGV4dEZyb21XZWJWaWV3KToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS93aW4vRHVt cFJlbmRlclRyZWUuY3BwOgorICAgICAgICAoZHVtcCk6CisgICAgICAgIChydW5UZXN0KToKKyAg ICAgICAgKiBEdW1wUmVuZGVyVHJlZS93aW4vUGl4ZWxEdW1wU3VwcG9ydFdpbi5jcHA6CisgICAg ICAgIChnZXRCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcpOgorICAgICAgICAqIFNjcmlwdHMvcnVu LXdlYmtpdC10ZXN0czoKKwogMjAwOC0xMC0yNCAgQW5kZXJzIENhcmxzc29uICA8YW5kZXJzY2FA YXBwbGUuY29tPgogCiAgICAgICAgIFRyeSBmaXhpbmcgdGhlIDY0LWJpdCBidWlsZC4KZGlmZiAt LWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0R1bXBSZW5kZXJUcmVlLnhjb2RlcHJv ai9wcm9qZWN0LnBieHByb2ogYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9EdW1wUmVuZGVy VHJlZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDM0ODA2OWMuLmJmYzc1MDAgMTAw NjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0R1bXBSZW5kZXJUcmVlLnhjb2Rl cHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvRHVt cFJlbmRlclRyZWUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMzMsNiArMzMsNyBAQAog CQkxQUM2Qzg0OTBEMDc2Mzg2MDBDRDMxNjEgLyogbWFpbi5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAxQUM2Qzc3RjBEMDc1ODlCMDBDRDMxNjEgLyog bWFpbi5jcHAgKi87IH07CiAJCTFBQzZDODRBMEQwNzYzODYwMENEMzE2MSAvKiBQbHVnaW5PYmpl Y3QuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMUFD NkM3ODAwRDA3NTg5QjAwQ0QzMTYxIC8qIFBsdWdpbk9iamVjdC5jcHAgKi87IH07CiAJCTFBQzZD ODRCMEQwNzYzODYwMENEMzE2MSAvKiBUZXN0T2JqZWN0LmNwcCBpbiBTb3VyY2VzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDFBQzZDNzgxMEQwNzU4OUIwMENEMzE2MSAvKiBU ZXN0T2JqZWN0LmNwcCAqLzsgfTsKKwkJMjNCQ0I4OTAwRUE1NzYyMzAwM0M2Mjg5IC8qIE9wZW5H TC5mcmFtZXdvcmsgaW4gRnJhbWV3b3JrcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSAyM0JDQjg4RjBFQTU3NjIzMDAzQzYyODkgLyogT3BlbkdMLmZyYW1ld29yayAqLzsgfTsK IAkJOTM0MDk5NEMwODU0MENBRTAwN0YzQkM4IC8qIER1bXBSZW5kZXJUcmVlUHJlZml4LmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAzMkE3MEFBQjAzNzA1 RTFGMDBDOTE3ODMgLyogRHVtcFJlbmRlclRyZWVQcmVmaXguaCAqLzsgfTsKIAkJOTM0MDk5NTEw ODU0MENBRTAwN0YzQkM4IC8qIFdlYktpdC5mcmFtZXdvcmsgaW4gRnJhbWV3b3JrcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzM1NDM1RjAzRDc1NTAyMDA4NjM1Q0UgLyog V2ViS2l0LmZyYW1ld29yayAqLzsgfTsKIAkJQTgxNzA5MDAwOEIxNjNFRjAwQ0NCOUZCIC8qIENv Y29hLmZyYW1ld29yayBpbiBGcmFtZXdvcmtzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IEE4NEY2MDg5MDhCMTM2REEwMEU5NzQ1RiAvKiBDb2NvYS5mcmFtZXdvcmsgKi87IH07 CkBAIC0xMzEsNiArMTMyLDcgQEAKIAkJMUFDNkM3N0YwRDA3NTg5QjAwQ0QzMTYxIC8qIG1haW4u Y3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gbWFpbi5jcHA7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTFBQzZDNzgwMEQwNzU4OUIwMENEMzE2MSAvKiBQbHVn aW5PYmplY3QuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUGx1Z2lu T2JqZWN0LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMUFDNkM3ODEwRDA3NTg5 QjAwQ0QzMTYxIC8qIFRlc3RPYmplY3QuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3Bw OyBwYXRoID0gVGVzdE9iamVjdC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTIz QkNCODhGMEVBNTc2MjMwMDNDNjI4OSAvKiBPcGVuR0wuZnJhbWV3b3JrICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gd3JhcHBlci5mcmFtZXdvcms7IG5h bWUgPSBPcGVuR0wuZnJhbWV3b3JrOyBwYXRoID0gL1N5c3RlbS9MaWJyYXJ5L0ZyYW1ld29ya3Mv T3BlbkdMLmZyYW1ld29yazsgc291cmNlVHJlZSA9ICI8YWJzb2x1dGU+IjsgfTsKIAkJMzJBNzBB QUIwMzcwNUUxRjAwQzkxNzgzIC8qIER1bXBSZW5kZXJUcmVlUHJlZml4LmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IER1bXBSZW5kZXJUcmVlUHJlZml4Lmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCTM3NUYwOTcxMERBQzNDQjYwMEM4QjRFNSAvKiBXZWJLaXRXZWln aHRXYXRjaGVyMTAwLnR0ZiAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25G aWxlVHlwZSA9IGZpbGU7IG5hbWUgPSBXZWJLaXRXZWlnaHRXYXRjaGVyMTAwLnR0ZjsgcGF0aCA9 IGZvbnRzL1dlYktpdFdlaWdodFdhdGNoZXIxMDAudHRmOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQkzNzVGMDk3MjBEQUMzQ0I2MDBDOEI0RTUgLyogV2ViS2l0V2VpZ2h0V2F0Y2hlcjIw MC50dGYgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBm aWxlOyBuYW1lID0gV2ViS2l0V2VpZ2h0V2F0Y2hlcjIwMC50dGY7IHBhdGggPSBmb250cy9XZWJL aXRXZWlnaHRXYXRjaGVyMjAwLnR0Zjsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTIz NCw2ICsyMzYsNyBAQAogCQkJCUE4NEY2MDhBMDhCMTM2REEwMEU5NzQ1RiAvKiBDb2NvYS5mcmFt ZXdvcmsgaW4gRnJhbWV3b3JrcyAqLywKIAkJCQlBODE3MDkwNDA4QjE2NEQzMDBDQ0I5RkIgLyog SmF2YVNjcmlwdENvcmUuZnJhbWV3b3JrIGluIEZyYW1ld29ya3MgKi8sCiAJCQkJOTM0MDk5NTEw ODU0MENBRTAwN0YzQkM4IC8qIFdlYktpdC5mcmFtZXdvcmsgaW4gRnJhbWV3b3JrcyAqLywKKwkJ CQkyM0JDQjg5MDBFQTU3NjIzMDAzQzYyODkgLyogT3BlbkdMLmZyYW1ld29yayBpbiBGcmFtZXdv cmtzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAw OwogCQl9OwpAQCAtMzc1LDYgKzM3OCw3IEBACiAJCQkJQTgxNzA5MDMwOEIxNjREMzAwQ0NCOUZC IC8qIEphdmFTY3JpcHRDb3JlLmZyYW1ld29yayAqLywKIAkJCQlCNUE3NTJBMTA4QUY1RDFGMDAx MzhFNDUgLyogUXVhcnR6Q29yZS5mcmFtZXdvcmsgKi8sCiAJCQkJOTMzNTQzNUYwM0Q3NTUwMjAw ODYzNUNFIC8qIFdlYktpdC5mcmFtZXdvcmsgKi8sCisJCQkJMjNCQ0I4OEYwRUE1NzYyMzAwM0M2 Mjg5IC8qIE9wZW5HTC5mcmFtZXdvcmsgKi8sCiAJCQkpOwogCQkJbmFtZSA9IEZyYW1ld29ya3M7 CiAJCQlzb3VyY2VUcmVlID0gIjxncm91cD4iOwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1Bhc3NSZWZQdHIuaCBiL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL0ZvcndhcmRpbmdIZWFkZXJzL3d0Zi9QYXNzUmVmUHRyLmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYWFmZDFhMgotLS0gL2Rldi9udWxsCisr KyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0ZvcndhcmRpbmdIZWFkZXJzL3d0Zi9QYXNz UmVmUHRyLmgKQEAgLTAsMCArMSBAQAorI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL1Bhc3NSZWZQ dHIuaD4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0ZvcndhcmRpbmdI ZWFkZXJzL3d0Zi9SZWZQdHIuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0ZvcndhcmRp bmdIZWFkZXJzL3d0Zi9SZWZQdHIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw Li4wZmY2MjEzCi0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv Rm9yd2FyZGluZ0hlYWRlcnMvd3RmL1JlZlB0ci5oCkBAIC0wLDAgKzEgQEAKKyNpbmNsdWRlIDxK YXZhU2NyaXB0Q29yZS9SZWZQdHIuaD4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAppbmRleCA2YzZhMjczLi5hYTcxN2Y0IDEwMDY0 NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5j cHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIu Y3BwCkBAIC0zNCw3ICszNCw3IEBACiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KICNpbmNs dWRlIDx3dGYvTWF0aEV4dHJhcy5oPgogCi1MYXlvdXRUZXN0Q29udHJvbGxlcjo6TGF5b3V0VGVz dENvbnRyb2xsZXIoYm9vbCB0ZXN0UmVwYWludERlZmF1bHQsIGJvb2wgdGVzdFJlcGFpbnRTd2Vl cEhvcml6b250YWxseURlZmF1bHQpCitMYXlvdXRUZXN0Q29udHJvbGxlcjo6TGF5b3V0VGVzdENv bnRyb2xsZXIoY29uc3Qgc3RkOjpzdHJpbmcmIHRlc3RQYXRoT3JVUkwsIGNvbnN0IHN0ZDo6c3Ry aW5nJiBleHBlY3RlZFBpeGVsSGFzaCkKICAgICA6IG1fZHVtcEFzVGV4dChmYWxzZSkKICAgICAs IG1fZHVtcEFzUERGKGZhbHNlKQogICAgICwgbV9kdW1wQmFja0ZvcndhcmRMaXN0KGZhbHNlKQpA QCAtNTQsMTEgKzU0LDE0IEBAIExheW91dFRlc3RDb250cm9sbGVyOjpMYXlvdXRUZXN0Q29udHJv bGxlcihib29sIHRlc3RSZXBhaW50RGVmYXVsdCwgYm9vbCB0ZXN0UmVwCiAgICAgLCBtX2Nhbk9w ZW5XaW5kb3dzKGZhbHNlKQogICAgICwgbV9jbG9zZVJlbWFpbmluZ1dpbmRvd3NXaGVuQ29tcGxl dGUodHJ1ZSkKICAgICAsIG1fc3RvcFByb3Zpc2lvbmFsRnJhbWVMb2FkcyhmYWxzZSkKLSAgICAs IG1fdGVzdFJlcGFpbnQodGVzdFJlcGFpbnREZWZhdWx0KQotICAgICwgbV90ZXN0UmVwYWludFN3 ZWVwSG9yaXpvbnRhbGx5KHRlc3RSZXBhaW50U3dlZXBIb3Jpem9udGFsbHlEZWZhdWx0KQorICAg ICwgbV90ZXN0T25zY3JlZW4oZmFsc2UpCisgICAgLCBtX3Rlc3RSZXBhaW50KGZhbHNlKQorICAg ICwgbV90ZXN0UmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5KGZhbHNlKQogICAgICwgbV93YWl0VG9E dW1wKGZhbHNlKQogICAgICwgbV93aW5kb3dJc0tleSh0cnVlKQogICAgICwgbV9nbG9iYWxGbGFn KGZhbHNlKQorICAgICwgbV90ZXN0UGF0aE9yVVJMKHRlc3RQYXRoT3JVUkwpCisgICAgLCBtX2V4 cGVjdGVkUGl4ZWxIYXNoKGV4cGVjdGVkUGl4ZWxIYXNoKQogewogfQogCkBAIC0yMDUsNiArMjA4 LDEzIEBAIHN0YXRpYyBKU1ZhbHVlUmVmIHNldENsb3NlUmVtYWluaW5nV2luZG93c1doZW5Db21w bGV0ZUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250CiAgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5k ZWZpbmVkKGNvbnRleHQpOwogfQogCitzdGF0aWMgSlNWYWx1ZVJlZiB0ZXN0T25zY3JlZW5DYWxs YmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpTT2JqZWN0 UmVmIHRoaXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVlUmVmIGFy Z3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pCit7CisgICAgTGF5b3V0VGVzdENvbnRy b2xsZXIqIGNvbnRyb2xsZXIgPSByZWludGVycHJldF9jYXN0PExheW91dFRlc3RDb250cm9sbGVy Kj4oSlNPYmplY3RHZXRQcml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBjb250cm9sbGVyLT5zZXRU ZXN0T25zY3JlZW4odHJ1ZSk7CisgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRl eHQpOworfQorCiBzdGF0aWMgSlNWYWx1ZVJlZiB0ZXN0UmVwYWludENhbGxiYWNrKEpTQ29udGV4 dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBmdW5jdGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVj dCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpT VmFsdWVSZWYqIGV4Y2VwdGlvbikKIHsKICAgICBMYXlvdXRUZXN0Q29udHJvbGxlciogY29udHJv bGxlciA9IHJlaW50ZXJwcmV0X2Nhc3Q8TGF5b3V0VGVzdENvbnRyb2xsZXIqPihKU09iamVjdEdl dFByaXZhdGUodGhpc09iamVjdCkpOwpAQCAtNzQ1LDYgKzc1NSw3IEBAIEpTU3RhdGljRnVuY3Rp b24qIExheW91dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMoKQogICAgICAgICB7ICJz ZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQiLCBzZXRVc2VyU3R5bGVTaGVldEVuYWJsZWRDYWxsYmFj aywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9u dERlbGV0ZSB9LAogICAgICAgICB7ICJzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uIiwgc2V0VXNl clN0eWxlU2hlZXRMb2NhdGlvbkNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5 IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInNldFdpbmRv d0lzS2V5Iiwgc2V0V2luZG93SXNLZXlDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFk T25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAorICAgICAgICB7ICJ0ZXN0 T25zY3JlZW4iLCB0ZXN0T25zY3JlZW5DYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFk T25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJ0ZXN0 UmVwYWludCIsIHRlc3RSZXBhaW50Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9u bHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAid2FpdFVu dGlsRG9uZSIsIHdhaXRVbnRpbERvbmVDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFk T25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJ3aW5k b3dDb3VudCIsIHdpbmRvd0NvdW50Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9u bHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKZGlmZiAtLWdpdCBhL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmggYi9XZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCmluZGV4IDhlMzNlMDkuLjY0 OWRiN2EgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RD b250cm9sbGVyLmgKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENv bnRyb2xsZXIuaApAQCAtMzEsMTAgKzMxLDExIEBACiAKICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29y ZS9KU09iamVjdFJlZi5oPgogI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CisjaW5jbHVkZSA8 c3RyaW5nPgogCiBjbGFzcyBMYXlvdXRUZXN0Q29udHJvbGxlciA6IHB1YmxpYyBSZWZDb3VudGVk PExheW91dFRlc3RDb250cm9sbGVyPiB7CiBwdWJsaWM6Ci0gICAgTGF5b3V0VGVzdENvbnRyb2xs ZXIoYm9vbCB0ZXN0UmVwYWludERlZmF1bHQsIGJvb2wgdGVzdFJlcGFpbnRTd2VlcEhvcml6b250 YWxseURlZmF1bHQpOworICAgIExheW91dFRlc3RDb250cm9sbGVyKGNvbnN0IHN0ZDo6c3RyaW5n JiB0ZXN0UGF0aE9yVVJMLCBjb25zdCBzdGQ6OnN0cmluZyYgZXhwZWN0ZWRQaXhlbEhhc2gpOwog ICAgIH5MYXlvdXRUZXN0Q29udHJvbGxlcigpOwogCiAgICAgdm9pZCBtYWtlV2luZG93T2JqZWN0 KEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiB3aW5kb3dPYmplY3QsIEpTVmFsdWVS ZWYqIGV4Y2VwdGlvbik7CkBAIC0xMzAsNiArMTMxLDkgQEAgcHVibGljOgogICAgIGJvb2wgc3Rv cFByb3Zpc2lvbmFsRnJhbWVMb2FkcygpIGNvbnN0IHsgcmV0dXJuIG1fc3RvcFByb3Zpc2lvbmFs RnJhbWVMb2FkczsgfQogICAgIHZvaWQgc2V0U3RvcFByb3Zpc2lvbmFsRnJhbWVMb2Fkcyhib29s IHN0b3BQcm92aXNpb25hbEZyYW1lTG9hZHMpIHsgbV9zdG9wUHJvdmlzaW9uYWxGcmFtZUxvYWRz ID0gc3RvcFByb3Zpc2lvbmFsRnJhbWVMb2FkczsgfQogCisgICAgYm9vbCB0ZXN0T25zY3JlZW4o KSBjb25zdCB7IHJldHVybiBtX3Rlc3RPbnNjcmVlbjsgfQorICAgIHZvaWQgc2V0VGVzdE9uc2Ny ZWVuKGJvb2wgdGVzdE9uc2NyZWVuKSB7IG1fdGVzdE9uc2NyZWVuID0gdGVzdE9uc2NyZWVuOyB9 CisKICAgICBib29sIHRlc3RSZXBhaW50KCkgY29uc3QgeyByZXR1cm4gbV90ZXN0UmVwYWludDsg fQogICAgIHZvaWQgc2V0VGVzdFJlcGFpbnQoYm9vbCB0ZXN0UmVwYWludCkgeyBtX3Rlc3RSZXBh aW50ID0gdGVzdFJlcGFpbnQ7IH0KIApAQCAtMTQ0LDcgKzE0OCwxMCBAQCBwdWJsaWM6CiAKICAg ICBib29sIGdsb2JhbEZsYWcoKSBjb25zdCB7IHJldHVybiBtX2dsb2JhbEZsYWc7IH0KICAgICB2 b2lkIHNldEdsb2JhbEZsYWcoYm9vbCBnbG9iYWxGbGFnKSB7IG1fZ2xvYmFsRmxhZyA9IGdsb2Jh bEZsYWc7IH0KLQorICAgIAorICAgIGNvbnN0IHN0ZDo6c3RyaW5nJiB0ZXN0UGF0aE9yVVJMKCkg Y29uc3QgeyByZXR1cm4gbV90ZXN0UGF0aE9yVVJMOyB9CisgICAgY29uc3Qgc3RkOjpzdHJpbmcm IGV4cGVjdGVkUGl4ZWxIYXNoKCkgY29uc3QgeyByZXR1cm4gbV9leHBlY3RlZFBpeGVsSGFzaDsg fQorICAgIAogcHJpdmF0ZToKICAgICBib29sIG1fZHVtcEFzVGV4dDsKICAgICBib29sIG1fZHVt cEFzUERGOwpAQCAtMTY1LDYgKzE3Miw3IEBAIHByaXZhdGU6CiAgICAgYm9vbCBtX2Nhbk9wZW5X aW5kb3dzOwogICAgIGJvb2wgbV9jbG9zZVJlbWFpbmluZ1dpbmRvd3NXaGVuQ29tcGxldGU7CiAg ICAgYm9vbCBtX3N0b3BQcm92aXNpb25hbEZyYW1lTG9hZHM7CisgICAgYm9vbCBtX3Rlc3RPbnNj cmVlbjsKICAgICBib29sIG1fdGVzdFJlcGFpbnQ7CiAgICAgYm9vbCBtX3Rlc3RSZXBhaW50U3dl ZXBIb3Jpem9udGFsbHk7CiAgICAgYm9vbCBtX3dhaXRUb0R1bXA7IC8vIFRydWUgaWYgd2FpdFVu dGlsRG9uZSgpIGhhcyBiZWVuIGNhbGxlZCwgYnV0IG5vdGlmeURvbmUoKSBoYXMgbm90IHlldCBi ZWVuIGNhbGxlZC4KQEAgLTE3Miw2ICsxODAsOSBAQCBwcml2YXRlOgogCiAgICAgYm9vbCBtX2ds b2JhbEZsYWc7CiAKKyAgICBzdGQ6OnN0cmluZyBtX3Rlc3RQYXRoT3JVUkw7CisgICAgc3RkOjpz dHJpbmcgbV9leHBlY3RlZFBpeGVsSGFzaDsgICAgLy8gZW1wdHkgc3RyaW5nIGlmIG5vIGhhc2gK KyAgICAKICAgICBzdGF0aWMgSlNDbGFzc1JlZiBnZXRKU0NsYXNzKCk7CiAgICAgc3RhdGljIEpT U3RhdGljVmFsdWUqIHN0YXRpY1ZhbHVlcygpOwogICAgIHN0YXRpYyBKU1N0YXRpY0Z1bmN0aW9u KiBzdGF0aWNGdW5jdGlvbnMoKTsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL1BpeGVsRHVtcFN1cHBvcnQuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL1BpeGVs RHVtcFN1cHBvcnQuaAppbmRleCAzMjE0ZDA0Li5kNGY4OTQ4IDEwMDY0NAotLS0gYS9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9QaXhlbER1bXBTdXBwb3J0LmgKKysrIGIvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvUGl4ZWxEdW1wU3VwcG9ydC5oCkBAIC0yOSwxMiArMjksMTggQEAKICNp Zm5kZWYgUGl4ZWxEdW1wU3VwcG9ydF9oCiAjZGVmaW5lIFBpeGVsRHVtcFN1cHBvcnRfaAogCi12 b2lkIGR1bXBXZWJWaWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4cGVjdGVkKGNvbnN0IGNoYXIq IGN1cnJlbnRUZXN0LCBib29sIGZvcmNlQWxsVGVzdHNUb0R1bXBQaXhlbHMpOworI2luY2x1ZGUg PHN0cmluZz4KKwordm9pZCBkdW1wV2ViVmlld0FzUGl4ZWxzQW5kQ29tcGFyZVdpdGhFeHBlY3Rl ZChjb25zdCBzdGQ6OnN0cmluZyYgZXhwZWN0ZWRIYXNoKTsKKworI2lmIFBMQVRGT1JNKE1BQykK IAogLy8gQ2FuIGJlIHVzZWQgYXMgYSBzaWduYWwgaGFuZGxlcgotdm9pZCByZXN0b3JlQ29sb3JT cGFjZShpbnQgaWdub3JlZCk7Cit2b2lkIHJlc3RvcmVNYWluRGlzcGxheUNvbG9yUHJvZmlsZShp bnQgaWdub3JlZCk7CisKKy8vIE1heSBjaGFuZ2UgeW91ciBjb2xvciBzcGFjZSwgcmVxdWlyaW5n IGEgY2FsbCB0byByZXN0b3JlTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUKK3ZvaWQgc2V0dXBNYWlu RGlzcGxheUNvbG9yUHJvZmlsZSgpOwogCi0vLyBNYXkgY2hhbmdlIHlvdXIgY29sb3Igc3BhY2Us IHJlcXVpcmluZyBhIGNhbGwgdG8gcmVzdG9yZUNvbG9yU3BhY2UKLXZvaWQgaW5pdGlhbGl6ZUNv bG9yU3BhY2VBbmRTY3JlZUJ1ZmZlckZvclBpeGVsVGVzdHMoKTsKKyNlbmRpZgogCiAjZW5kaWYg Ly8gUGl4ZWxEdW1wU3VwcG9ydF9oCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9jZy9JbWFnZURpZmZDRy5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9jZy9J bWFnZURpZmZDRy5jcHAKaW5kZXggYzM5MzkxMy4uMWU1NWU3OCAxMDA2NDQKLS0tIGEvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvSW1hZ2VEaWZmQ0cuY3BwCisrKyBiL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL2NnL0ltYWdlRGlmZkNHLmNwcApAQCAtMzYsNiArMzYsNyBAQAogI2lm IFBMQVRGT1JNKFdJTikKICNpbmNsdWRlIDxmY250bC5oPgogI2luY2x1ZGUgPGlvLmg+CisjaW5j bHVkZSA8d3RmL01hdGhFeHRyYXMuaD4KICNlbmRpZgogCiAjaWYgUExBVEZPUk0oTUFDKQpAQCAt NTQsNiArNTUsMTAgQEAgdHlwZWRlZiBmbG9hdCBDR0Zsb2F0OwogdXNpbmcgbmFtZXNwYWNlIHN0 ZDsKIAogI2lmIFBMQVRGT1JNKFdJTikKK3N0YXRpYyBpbmxpbmUgZmxvYXQgc3RydG9mKGNvbnN0 IGNoYXIgKm5wdHIsIGNoYXIgKiplbmRwdHIpCit7CisgICAgcmV0dXJuIHN0cnRvZChucHRyLCBl bmRwdHIpOworfQogc3RhdGljIGNvbnN0IENGU3RyaW5nUmVmIGtVVFR5cGVQTkcgPSBDRlNUUigi cHVibGljLnBuZyIpOwogI2VuZGlmCiAKQEAgLTcyLDk5ICs3Nyw5OSBAQCBzdGF0aWMgUmV0YWlu UHRyPENHSW1hZ2VSZWY+IGNyZWF0ZUltYWdlRnJvbVN0ZGluKGludCBieXRlc1JlbWFpbmluZykK ICAgICByZXR1cm4gUmV0YWluUHRyPENHSW1hZ2VSZWY+KEFkb3B0Q0YsIENHSW1hZ2VDcmVhdGVX aXRoUE5HRGF0YVByb3ZpZGVyKGRhdGFQcm92aWRlci5nZXQoKSwgMCwgZmFsc2UsIGtDR1JlbmRl cmluZ0ludGVudERlZmF1bHQpKTsKIH0KIAotLy8gR2VuZXJhdGVzIGFuIFJHQkE4IGJpdG1hcCBp biB0aGUgcmVmZXJlbmNlIGltYWdlIGNvbG9yc3BhY2UgY29udGFpbmluZyB0aGUgZGlmZmVyZW5j ZXMgYmV0d2VlbiB0aGUgMiBpbWFnZXMKLXN0YXRpYyBSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPiBj cmVhdGVEaWZmZXJlbmNlQml0bWFwKENHSW1hZ2VSZWYgdGVzdEltYWdlLCBDR0ltYWdlUmVmIHJl ZmVyZW5jZUltYWdlKQorc3RhdGljIHZvaWQgcmVsZWFzZU1hbGxvY0J1ZmZlcih2b2lkKiBpbmZv LCBjb25zdCB2b2lkKiBkYXRhLCBzaXplX3Qgc2l6ZSkKIHsKLSAgICAvLyB3ZSBtdXN0IGhhdmUg Ym90aCBpbWFnZXMgdG8gdGFrZSBkaWZmCi0gICAgaWYgKCF0ZXN0SW1hZ2UgfHwgIXJlZmVyZW5j ZUltYWdlKSB7Ci0gICAgICAgIGZwcmludGYoc3RkZXJyLCAidGVzdCBvciByZWZlcmVuY2UgaW1h Z2UgaXMgbWlzc2luZyEiKTsKLSAgICAgICAgcmV0dXJuIDA7Ci0gICAgfQotCi0gICAgLy8gd2Ug bXVzdCBoYXZlIGJvdGggaW1hZ2VzIGJlIHRoZSBzYW1lIGRpbWVuc2lvbnMKLSAgICBpZiAoKENH SW1hZ2VHZXRXaWR0aCh0ZXN0SW1hZ2UpICE9IENHSW1hZ2VHZXRXaWR0aChyZWZlcmVuY2VJbWFn ZSkpIHx8IChDR0ltYWdlR2V0SGVpZ2h0KHRlc3RJbWFnZSkgIT0gQ0dJbWFnZUdldEhlaWdodChy ZWZlcmVuY2VJbWFnZSkpKSB7Ci0gICAgICAgIGZwcmludGYoc3RkZXJyLCAidGVzdCBhbmQgcmVm ZXJlbmNlIGltYWdlIGRpbWVuc2lvbnMgZG9uJ3QgbWF0Y2ghIik7Ci0gICAgICAgIHJldHVybiAw OwotICAgIH0KLQotICAgIC8vIHdlIG11c3QgaGF2ZSBib3RoIGltYWdlcyBpbiB0aGUgc2FtZSBj b2xvcnNwYWNlCi0gICAgaWYgKCFDRkVxdWFsKENHSW1hZ2VHZXRDb2xvclNwYWNlKHRlc3RJbWFn ZSksIENHSW1hZ2VHZXRDb2xvclNwYWNlKHJlZmVyZW5jZUltYWdlKSkpIHsKLSAgICAgICAgZnBy aW50ZihzdGRlcnIsICJ0ZXN0IGFuZCByZWZlcmVuY2UgaW1hZ2UgY29sb3JzcGFjZXMgZG9uJ3Qg bWF0Y2ghIik7Ci0gICAgICAgIHJldHVybiAwOwotICAgIH0KLQotICAgIHN0YXRpYyBDRk11dGFi bGVEYXRhUmVmIGRhdGEgPSBDRkRhdGFDcmVhdGVNdXRhYmxlKGtDRkFsbG9jYXRvckRlZmF1bHQs IDApOwotICAgIHNpemVfdCByb3dCeXRlcyA9ICg0ICogQ0dJbWFnZUdldFdpZHRoKHJlZmVyZW5j ZUltYWdlKSArIDYzKSAmIH42MzsgLy8gVXNlIGEgbXVsdGlwbGUgb2YgNjQgYnl0ZXMgdG8gaW1w cm92ZSBDRyBwZXJmb3JtYW5jZQotICAgIENGRGF0YVNldExlbmd0aChkYXRhLCBDR0ltYWdlR2V0 SGVpZ2h0KHJlZmVyZW5jZUltYWdlKSAqIHJvd0J5dGVzKTsKLSAgICBSZXRhaW5QdHI8Q0dDb250 ZXh0UmVmPiBjb250ZXh0KEFkb3B0Q0YsIENHQml0bWFwQ29udGV4dENyZWF0ZShDRkRhdGFHZXRN dXRhYmxlQnl0ZVB0cihkYXRhKSwgQ0dJbWFnZUdldFdpZHRoKHJlZmVyZW5jZUltYWdlKSwgQ0dJ bWFnZUdldEhlaWdodChyZWZlcmVuY2VJbWFnZSksIDgsIHJvd0J5dGVzLCBDR0ltYWdlR2V0Q29s b3JTcGFjZShyZWZlcmVuY2VJbWFnZSksIGtDR0ltYWdlQWxwaGFQcmVtdWx0aXBsaWVkTGFzdCB8 IGtDR0JpdG1hcEJ5dGVPcmRlcjMyQmlnKSk7Ci0KLSAgICBDR0NvbnRleHRTZXRCbGVuZE1vZGUo Y29udGV4dC5nZXQoKSwga0NHQmxlbmRNb2RlTm9ybWFsKTsKLSAgICBDR0NvbnRleHREcmF3SW1h Z2UoY29udGV4dC5nZXQoKSwgQ0dSZWN0TWFrZSgwLCAwLCBzdGF0aWNfY2FzdDxDR0Zsb2F0PihD R0ltYWdlR2V0V2lkdGgodGVzdEltYWdlKSksIHN0YXRpY19jYXN0PENHRmxvYXQ+KENHSW1hZ2VH ZXRIZWlnaHQodGVzdEltYWdlKSkpLCB0ZXN0SW1hZ2UpOwotICAgIENHQ29udGV4dFNldEJsZW5k TW9kZShjb250ZXh0LmdldCgpLCBrQ0dCbGVuZE1vZGVEaWZmZXJlbmNlKTsKLSAgICBDR0NvbnRl eHREcmF3SW1hZ2UoY29udGV4dC5nZXQoKSwgQ0dSZWN0TWFrZSgwLCAwLCBzdGF0aWNfY2FzdDxD R0Zsb2F0PihDR0ltYWdlR2V0V2lkdGgocmVmZXJlbmNlSW1hZ2UpKSwgc3RhdGljX2Nhc3Q8Q0dG bG9hdD4oQ0dJbWFnZUdldEhlaWdodChyZWZlcmVuY2VJbWFnZSkpKSwgcmVmZXJlbmNlSW1hZ2Up OwotCi0gICAgcmV0dXJuIGNvbnRleHQ7CisgICAgZnJlZSgodm9pZCopZGF0YSk7CiB9CiAKLS8v IENvdW50cyB0aGUgbnVtYmVyIG9mIG5vbi1ibGFjayBwaXhlbHMsIGFuZCByZXR1cm5zIHRoZSBw ZXJjZW50YWdlIG9mIG5vbi1ibGFjayBwaXhlbHMgdG8gdG90YWwgcGl4ZWxzIGluIHRoZSBpbWFn ZS4KLXN0YXRpYyBmbG9hdCBjb21wdXRlUGVyY2VudGFnZURpZmZlcmVudChDR0NvbnRleHRSZWYg ZGlmZkJpdG1hcCwgdW5zaWduZWQgdGhyZXNob2xkKQorc3RhdGljIFJldGFpblB0cjxDR0ltYWdl UmVmPiBjcmVhdGVEaWZmZXJlbmNlSW1hZ2UoQ0dJbWFnZVJlZiBiYXNlSW1hZ2UsIENHSW1hZ2VS ZWYgdGVzdEltYWdlLCBmbG9hdCYgZGlmZmVyZW5jZSkKIHsKLSAgICAvLyBpZiBkaWZmQml0bWFw IGlzIG5pbCwgdGhlbiB0aGVyZSB3YXMgYW4gZXJyb3IsIGFuZCBpdCBkaWRuJ3QgbWF0Y2guCi0g ICAgaWYgKCFkaWZmQml0bWFwKQotICAgICAgICByZXR1cm4gMTAwLjBmOwotCi0gICAgc2l6ZV90 IHBpeGVsc0hpZ2ggPSBDR0JpdG1hcENvbnRleHRHZXRIZWlnaHQoZGlmZkJpdG1hcCk7Ci0gICAg c2l6ZV90IHBpeGVsc1dpZGUgPSBDR0JpdG1hcENvbnRleHRHZXRXaWR0aChkaWZmQml0bWFwKTsK LSAgICBzaXplX3QgYnl0ZXNQZXJSb3cgPSBDR0JpdG1hcENvbnRleHRHZXRCeXRlc1BlclJvdyhk aWZmQml0bWFwKTsKLSAgICB1bnNpZ25lZCBjaGFyKiBwaXhlbFJvd0RhdGEgPSBzdGF0aWNfY2Fz dDx1bnNpZ25lZCBjaGFyKj4oQ0dCaXRtYXBDb250ZXh0R2V0RGF0YShkaWZmQml0bWFwKSk7Ci0g ICAgdW5zaWduZWQgZGlmZmVyZW5jZXMgPSAwOwotCi0gICAgZm9yICh1bnNpZ25lZCByb3cgPSAw OyByb3cgPCBwaXhlbHNIaWdoOyByb3crKykgewotICAgICAgICBmb3IgKHVuc2lnbmVkIGNvbCA9 IDA7IGNvbCA8IChwaXhlbHNXaWRlICogNCk7IGNvbCArPSA0KSB7Ci0gICAgICAgICAgICB1bnNp Z25lZCBjaGFyKiByZWQgPSBwaXhlbFJvd0RhdGEgKyBjb2w7Ci0gICAgICAgICAgICB1bnNpZ25l ZCBjaGFyKiBncmVlbiA9IHJlZCArIDE7Ci0gICAgICAgICAgICB1bnNpZ25lZCBjaGFyKiBibHVl ID0gcmVkICsgMjsKLSAgICAgICAgICAgIHVuc2lnbmVkIGRpc3RhbmNlID0gKnJlZCArICpncmVl biArICpibHVlOwotICAgICAgICAgICAgaWYgKGRpc3RhbmNlID4gdGhyZXNob2xkKSB7Ci0gICAg ICAgICAgICAgICAgZGlmZmVyZW5jZXMrKzsKLSAgICAgICAgICAgICAgICAvLyBzaGlmdCB0aGUg cGl4ZWxzIHRvd2FyZHMgd2hpdGUgdG8gbWFrZSB0aGVtIG1vcmUgdmlzaWJsZQotICAgICAgICAg ICAgICAgICpyZWQgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyPihtaW4oVUNIQVJfTUFYLCAq cmVkICsgMTAwKSk7Ci0gICAgICAgICAgICAgICAgKmdyZWVuID0gc3RhdGljX2Nhc3Q8dW5zaWdu ZWQgY2hhcj4obWluKFVDSEFSX01BWCwgKmdyZWVuICsgMTAwKSk7Ci0gICAgICAgICAgICAgICAg KmJsdWUgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyPihtaW4oVUNIQVJfTUFYLCAqYmx1ZSAr IDEwMCkpOworICAgIHN0YXRpYyBSZXRhaW5QdHI8Q0dDb2xvclNwYWNlUmVmPiBjb2xvclNwYWNl KEFkb3B0Q0YsIENHQ29sb3JTcGFjZUNyZWF0ZURldmljZVJHQigpKTsKKyAgICBSZXRhaW5QdHI8 Q0dJbWFnZVJlZj4gZGlmZkltYWdlOworICAgIAorICAgIHNpemVfdCB3aWR0aCA9IENHSW1hZ2VH ZXRXaWR0aChiYXNlSW1hZ2UpOworICAgIHNpemVfdCBoZWlnaHQgPSBDR0ltYWdlR2V0SGVpZ2h0 KGJhc2VJbWFnZSk7CisgICAgc2l6ZV90IHJvd0J5dGVzID0gd2lkdGggKiA0OworICAgIAorICAg IC8vIERyYXcgYmFzZSBpbWFnZSBpbiBiaXRtYXAgY29udGV4dAorICAgIHZvaWQqIGJhc2VCdWZm ZXIgPSBjYWxsb2MoaGVpZ2h0LCByb3dCeXRlcyk7CisgICAgQ0dDb250ZXh0UmVmIGJhc2VDb250 ZXh0ID0gQ0dCaXRtYXBDb250ZXh0Q3JlYXRlKGJhc2VCdWZmZXIsIHdpZHRoLCBoZWlnaHQsIDgs IHJvd0J5dGVzLCBjb2xvclNwYWNlLmdldCgpLCBrQ0dJbWFnZUFscGhhUHJlbXVsdGlwbGllZEZp cnN0IHwga0NHQml0bWFwQnl0ZU9yZGVyMzJIb3N0KTsKKyAgICBDR0NvbnRleHREcmF3SW1hZ2Uo YmFzZUNvbnRleHQsIENHUmVjdE1ha2UoMCwgMCwgd2lkdGgsIGhlaWdodCksIGJhc2VJbWFnZSk7 CisgICAgQ0dDb250ZXh0UmVsZWFzZShiYXNlQ29udGV4dCk7CisgICAgCisgICAgLy8gRHJhdyB0 ZXN0IGltYWdlIGluIGJpdG1hcCBjb250ZXh0CisgICAgdm9pZCogYnVmZmVyID0gY2FsbG9jKGhl aWdodCwgcm93Qnl0ZXMpOworICAgIENHQ29udGV4dFJlZiBjb250ZXh0ID0gQ0dCaXRtYXBDb250 ZXh0Q3JlYXRlKGJ1ZmZlciwgd2lkdGgsIGhlaWdodCwgOCwgcm93Qnl0ZXMsIGNvbG9yU3BhY2Uu Z2V0KCksIGtDR0ltYWdlQWxwaGFQcmVtdWx0aXBsaWVkRmlyc3QgfCBrQ0dCaXRtYXBCeXRlT3Jk ZXIzMkhvc3QpOworICAgIENHQ29udGV4dERyYXdJbWFnZShjb250ZXh0LCBDR1JlY3RNYWtlKDAs IDAsIHdpZHRoLCBoZWlnaHQpLCB0ZXN0SW1hZ2UpOworICAgIENHQ29udGV4dFJlbGVhc2UoY29u dGV4dCk7CisgICAgCisgICAgLy8gQ29tcGFyZSB0aGUgY29udGVudCBvZiB0aGUgMiBiaXRtYXBz CisgICAgdm9pZCogZGlmZkJ1ZmZlciA9IG1hbGxvYyh3aWR0aCAqIGhlaWdodCk7CisgICAgZmxv YXQgY291bnQgPSAwLjBmOworICAgIGZsb2F0IHN1bSA9IDAuMGY7CisgICAgZmxvYXQgbWF4RGlz dGFuY2UgPSAwLjBmOworICAgIHVuc2lnbmVkIGNoYXIqIGJhc2VQaXhlbCA9ICh1bnNpZ25lZCBj aGFyKiliYXNlQnVmZmVyOworICAgIHVuc2lnbmVkIGNoYXIqIHBpeGVsID0gKHVuc2lnbmVkIGNo YXIqKWJ1ZmZlcjsKKyAgICB1bnNpZ25lZCBjaGFyKiBkaWZmID0gKHVuc2lnbmVkIGNoYXIqKWRp ZmZCdWZmZXI7CisgICAgZm9yIChzaXplX3QgeSA9IDA7IHkgPCBoZWlnaHQ7ICsreSkgeworICAg ICAgICBmb3IgKHNpemVfdCB4ID0gMDsgeCA8IHdpZHRoOyArK3gpIHsKKyAgICAgICAgICAgIGZs b2F0IHJlZCA9IChwaXhlbFswXSAtIGJhc2VQaXhlbFswXSkgLyBtYXg8ZmxvYXQ+KDI1NSAtIGJh c2VQaXhlbFswXSwgYmFzZVBpeGVsWzBdKTsKKyAgICAgICAgICAgIGZsb2F0IGdyZWVuID0gKHBp eGVsWzFdIC0gYmFzZVBpeGVsWzFdKSAvIG1heDxmbG9hdD4oMjU1IC0gYmFzZVBpeGVsWzFdLCBi YXNlUGl4ZWxbMV0pOworICAgICAgICAgICAgZmxvYXQgYmx1ZSA9IChwaXhlbFsyXSAtIGJhc2VQ aXhlbFsyXSkgLyBtYXg8ZmxvYXQ+KDI1NSAtIGJhc2VQaXhlbFsyXSwgYmFzZVBpeGVsWzJdKTsK KyAgICAgICAgICAgIGZsb2F0IGFscGhhID0gKHBpeGVsWzNdIC0gYmFzZVBpeGVsWzNdKSAvIG1h eDxmbG9hdD4oMjU1IC0gYmFzZVBpeGVsWzNdLCBiYXNlUGl4ZWxbM10pOworICAgICAgICAgICAg ZmxvYXQgZGlzdGFuY2UgPSBzcXJ0ZihyZWQgKiByZWQgKyBncmVlbiAqIGdyZWVuICsgYmx1ZSAq IGJsdWUgKyBhbHBoYSAqIGFscGhhKSAvIDIuMGY7CisgICAgICAgICAgICAKKyAgICAgICAgICAg ICpkaWZmKysgPSAodW5zaWduZWQgY2hhcikoZGlzdGFuY2UgKiAyNTUuMGYpOworICAgICAgICAg ICAgCisgICAgICAgICAgICBpZiAoZGlzdGFuY2UgPj0gMS4wZiAvIDI1NS4wZikgeworICAgICAg ICAgICAgICAgIGNvdW50ICs9IDEuMGY7CisgICAgICAgICAgICAgICAgc3VtICs9IGRpc3RhbmNl OworICAgICAgICAgICAgICAgIGlmIChkaXN0YW5jZSA+IG1heERpc3RhbmNlKQorICAgICAgICAg ICAgICAgICAgICBtYXhEaXN0YW5jZSA9IGRpc3RhbmNlOwogICAgICAgICAgICAgfQorICAgICAg ICAgICAgCisgICAgICAgICAgICBiYXNlUGl4ZWwgKz0gNDsKKyAgICAgICAgICAgIHBpeGVsICs9 IDQ7CiAgICAgICAgIH0KLSAgICAgICAgcGl4ZWxSb3dEYXRhICs9IGJ5dGVzUGVyUm93OwogICAg IH0KLQotICAgIGZsb2F0IHRvdGFsUGl4ZWxzID0gc3RhdGljX2Nhc3Q8ZmxvYXQ+KHBpeGVsc0hp Z2ggKiBwaXhlbHNXaWRlKTsKLSAgICByZXR1cm4gKGRpZmZlcmVuY2VzICogMTAwLmYpIC8gdG90 YWxQaXhlbHM7CisgICAgCisgICAgLy8gQ29tcHV0ZSB0aGUgZGlmZmVyZW5jZSBhcyBhIHBlcmNl bnRhZ2UgY29tYmluaW5nIGJvdGggdGhlIG51bWJlciBvZiBkaWZmZXJlbnQgcGl4ZWxzIGFuZCB0 aGVpciBkaWZmZXJlbmNlIGFtb3VudCBpLmUuIHRoZSBhdmVyYWdlIGRpc3RhbmNlIG92ZXIgdGhl IGVudGlyZSBpbWFnZQorICAgIGlmIChjb3VudCA+IDAuMGYpCisgICAgICAgIGRpZmZlcmVuY2Ug PSAxMDAuMGYgKiBzdW0gLyAoaGVpZ2h0ICogd2lkdGgpOworICAgIGVsc2UKKyAgICAgICAgZGlm ZmVyZW5jZSA9IDAuMGY7CisgICAgCisgICAgLy8gR2VuZXJhdGUgYSBub3JtYWxpemVkIGRpZmYg aW1hZ2UgaWYgdGhlcmUgaXMgYW55IGRpZmZlcmVuY2UKKyAgICBpZiAoZGlmZmVyZW5jZSA+IDAu MGYpIHsKKyAgICAgICAgaWYgKG1heERpc3RhbmNlIDwgMS4wZikgeworICAgICAgICAgICAgZGlm ZiA9ICh1bnNpZ25lZCBjaGFyKilkaWZmQnVmZmVyOworICAgICAgICAgICAgZm9yKHNpemVfdCBw ID0gMDsgcCA8IGhlaWdodCAqIHdpZHRoOyArK3ApCisgICAgICAgICAgICAgICAgZGlmZltwXSA9 IGRpZmZbcF0gLyBtYXhEaXN0YW5jZTsKKyAgICAgICAgfQorICAgICAgICAKKyAgICAgICAgQ0dE YXRhUHJvdmlkZXJSZWYgcHJvdmlkZXIgPSBDR0RhdGFQcm92aWRlckNyZWF0ZVdpdGhEYXRhKDAs IGRpZmZCdWZmZXIsIHdpZHRoICogaGVpZ2h0LCByZWxlYXNlTWFsbG9jQnVmZmVyKTsKKyAgICAg ICAgQ0dDb2xvclNwYWNlUmVmIGRpZmZDb2xvcnNwYWNlID0gQ0dDb2xvclNwYWNlQ3JlYXRlRGV2 aWNlR3JheSgpOworICAgICAgICBkaWZmSW1hZ2UuYWRvcHRDRihDR0ltYWdlQ3JlYXRlKHdpZHRo LCBoZWlnaHQsIDgsIDgsIHdpZHRoLCBkaWZmQ29sb3JzcGFjZSwgMCwgcHJvdmlkZXIsIDAsIGZh bHNlLCBrQ0dSZW5kZXJpbmdJbnRlbnREZWZhdWx0KSk7CisgICAgICAgIENHQ29sb3JTcGFjZVJl bGVhc2UoZGlmZkNvbG9yc3BhY2UpOworICAgICAgICBDR0RhdGFQcm92aWRlclJlbGVhc2UocHJv dmlkZXIpOworICAgIH0KKyAgICBlbHNlCisgICAgICAgIGZyZWUoZGlmZkJ1ZmZlcik7CisgICAg CisgICAgLy8gRGVzdHJveSBkcmF3aW5nIGJ1ZmZlcnMKKyAgICBpZiAoYnVmZmVyKQorICAgICAg ICBmcmVlKGJ1ZmZlcik7CisgICAgaWYgKGJhc2VCdWZmZXIpCisgICAgICAgIGZyZWUoYmFzZUJ1 ZmZlcik7CisgICAgCisgICAgcmV0dXJuIGRpZmZJbWFnZTsKIH0KIAotc3RhdGljIHZvaWQgY29t cGFyZUltYWdlcyhDR0ltYWdlUmVmIHRlc3RJbWFnZSwgQ0dJbWFnZVJlZiByZWZlcmVuY2VJbWFn ZSwgdW5zaWduZWQgdGhyZXNob2xkKQorc3RhdGljIGlubGluZSBib29sIGltYWdlSGFzQWxwaGEo Q0dJbWFnZVJlZiBpbWFnZSkKIHsKLSAgICAvLyBwcmVwYXJlIHRoZSBkaWZmZXJlbmNlIGJsZW5k IHRvIGNoZWNrIGZvciBwaXhlbCB2YXJpYXRpb25zCi0gICAgUmV0YWluUHRyPENHQ29udGV4dFJl Zj4gZGlmZkJpdG1hcCA9IGNyZWF0ZURpZmZlcmVuY2VCaXRtYXAodGVzdEltYWdlLCByZWZlcmVu Y2VJbWFnZSk7Ci0KLSAgICBmbG9hdCBwZXJjZW50YWdlID0gY29tcHV0ZVBlcmNlbnRhZ2VEaWZm ZXJlbnQoZGlmZkJpdG1hcC5nZXQoKSwgdGhyZXNob2xkKTsKLQotICAgIHBlcmNlbnRhZ2UgPSAo ZmxvYXQpKChpbnQpKHBlcmNlbnRhZ2UgKiAxMDAuMGYpKSAvIDEwMC4wZjsgLy8gcm91bmQgdG8g MiBkZWNpbWFsIHBsYWNlcwotCi0gICAgLy8gc2VuZCBtZXNzYWdlIHRvIGxldCB0aGVtIGtub3cg aWYgYW4gaW1hZ2Ugd2FzIHdyb25nCi0gICAgaWYgKHBlcmNlbnRhZ2UgPiAwLjBmKSB7Ci0gICAg ICAgIC8vIHNpbmNlIHRoZSBkaWZmIG1pZ2h0IGFjdHVhbGx5IHNob3cgc29tZXRoaW5nLCBzZW5k IGl0IHRvIHN0ZG91dAotICAgICAgICBpZiAoZGlmZkJpdG1hcCkgewotICAgICAgICAgICAgUmV0 YWluUHRyPENHSW1hZ2VSZWY+IGltYWdlKEFkb3B0Q0YsIENHQml0bWFwQ29udGV4dENyZWF0ZUlt YWdlKGRpZmZCaXRtYXAuZ2V0KCkpKTsKLSAgICAgICAgICAgIFJldGFpblB0cjxDRk11dGFibGVE YXRhUmVmPiBpbWFnZURhdGEoQWRvcHRDRiwgQ0ZEYXRhQ3JlYXRlTXV0YWJsZSgwLCAwKSk7Ci0g ICAgICAgICAgICBSZXRhaW5QdHI8Q0dJbWFnZURlc3RpbmF0aW9uUmVmPiBpbWFnZURlc3QoQWRv cHRDRiwgQ0dJbWFnZURlc3RpbmF0aW9uQ3JlYXRlV2l0aERhdGEoaW1hZ2VEYXRhLmdldCgpLCBr VVRUeXBlUE5HLCAxLCAwKSk7Ci0gICAgICAgICAgICBDR0ltYWdlRGVzdGluYXRpb25BZGRJbWFn ZShpbWFnZURlc3QuZ2V0KCksIGltYWdlLmdldCgpLCAwKTsKLSAgICAgICAgICAgIENHSW1hZ2VE ZXN0aW5hdGlvbkZpbmFsaXplKGltYWdlRGVzdC5nZXQoKSk7Ci0gICAgICAgICAgICBwcmludGYo IkNvbnRlbnQtTGVuZ3RoOiAlbHVcbiIsIENGRGF0YUdldExlbmd0aChpbWFnZURhdGEuZ2V0KCkp KTsKLSAgICAgICAgICAgIGZ3cml0ZShDRkRhdGFHZXRCeXRlUHRyKGltYWdlRGF0YS5nZXQoKSks IDEsIENGRGF0YUdldExlbmd0aChpbWFnZURhdGEuZ2V0KCkpLCBzdGRvdXQpOwotICAgICAgICB9 Ci0gICAgICAgIAotICAgICAgICBmcHJpbnRmKHN0ZG91dCwgImRpZmY6ICUwMS4yZiUlIGZhaWxl ZFxuIiwgcGVyY2VudGFnZSk7Ci0gICAgfSBlbHNlCi0gICAgICAgIGZwcmludGYoc3Rkb3V0LCAi ZGlmZjogJTAxLjJmJSUgcGFzc2VkXG4iLCBwZXJjZW50YWdlKTsKKyAgICBDR0ltYWdlQWxwaGFJ bmZvIGluZm8gPSBDR0ltYWdlR2V0QWxwaGFJbmZvKGltYWdlKTsKKyAgICAKKyAgICByZXR1cm4g KGluZm8gPj0ga0NHSW1hZ2VBbHBoYVByZW11bHRpcGxpZWRMYXN0KSAmJiAoaW5mbyA8PSBrQ0dJ bWFnZUFscGhhRmlyc3QpOwogfQogCiBpbnQgbWFpbihpbnQgYXJnYywgY29uc3QgY2hhciogYXJn dltdKQpAQCAtMTc0LDEzICsxNzksMTMgQEAgaW50IG1haW4oaW50IGFyZ2MsIGNvbnN0IGNoYXIq IGFyZ3ZbXSkKICAgICBfc2V0bW9kZSgxLCBfT19CSU5BUlkpOwogI2VuZGlmCiAKLSAgICB1bnNp Z25lZCB0aHJlc2hvbGQgPSAwOworICAgIGZsb2F0IHRvbGVyYW5jZSA9IDAuMGY7CiAKICAgICBm b3IgKGludCBpID0gMTsgaSA8IGFyZ2M7ICsraSkgewotICAgICAgICBpZiAoIXN0cmNtcChhcmd2 W2ldLCAiLXQiKSB8fCAhc3RyY21wKGFyZ3ZbaV0sICItLXRocmVzaG9sZCIpKSB7CisgICAgICAg IGlmICghc3RyY21wKGFyZ3ZbaV0sICItdCIpIHx8ICFzdHJjbXAoYXJndltpXSwgIi0tdG9sZXJh bmNlIikpIHsKICAgICAgICAgICAgIGlmIChpID49IGFyZ2MgLSAxKQogICAgICAgICAgICAgICAg IGV4aXQoMSk7Ci0gICAgICAgICAgICB0aHJlc2hvbGQgPSBzdHJ0b2woYXJndltpICsgMV0sIDAs IDApOworICAgICAgICAgICAgdG9sZXJhbmNlID0gc3RydG9mKGFyZ3ZbaSArIDFdLCAwKTsKICAg ICAgICAgICAgICsraTsKICAgICAgICAgICAgIGNvbnRpbnVlOwogICAgICAgICB9CkBAIC0yMDks NyArMjE0LDM0IEBAIGludCBtYWluKGludCBhcmdjLCBjb25zdCBjaGFyKiBhcmd2W10pCiAgICAg ICAgIH0KIAogICAgICAgICBpZiAoYWN0dWFsSW1hZ2UgJiYgYmFzZWxpbmVJbWFnZSkgewotICAg ICAgICAgICAgY29tcGFyZUltYWdlcyhhY3R1YWxJbWFnZS5nZXQoKSwgYmFzZWxpbmVJbWFnZS5n ZXQoKSwgdGhyZXNob2xkKTsKKyAgICAgICAgICAgIFJldGFpblB0cjxDR0ltYWdlUmVmPiBkaWZm SW1hZ2U7CisgICAgICAgICAgICBmbG9hdCBkaWZmZXJlbmNlID0gMTAwLjBmOworICAgICAgICAg ICAgCisgICAgICAgICAgICBpZiAoKENHSW1hZ2VHZXRXaWR0aChhY3R1YWxJbWFnZS5nZXQoKSkg PT0gQ0dJbWFnZUdldFdpZHRoKGJhc2VsaW5lSW1hZ2UuZ2V0KCkpKSAmJiAoQ0dJbWFnZUdldEhl aWdodChhY3R1YWxJbWFnZS5nZXQoKSkgPT0gQ0dJbWFnZUdldEhlaWdodChiYXNlbGluZUltYWdl LmdldCgpKSkgJiYgKGltYWdlSGFzQWxwaGEoYWN0dWFsSW1hZ2UuZ2V0KCkpID09IGltYWdlSGFz QWxwaGEoYmFzZWxpbmVJbWFnZS5nZXQoKSkpKSB7CisgICAgICAgICAgICAgICAgZGlmZkltYWdl ID0gY3JlYXRlRGlmZmVyZW5jZUltYWdlKGFjdHVhbEltYWdlLmdldCgpLCBiYXNlbGluZUltYWdl LmdldCgpLCBkaWZmZXJlbmNlKTsgLy8gZGlmZmVyZW5jZSBpcyBwYXNzZWQgYnkgcmVmZXJlbmNl CisgICAgICAgICAgICAgICAgaWYgKGRpZmZlcmVuY2UgPD0gdG9sZXJhbmNlKQorICAgICAgICAg ICAgICAgICAgICBkaWZmZXJlbmNlID0gMC4wZjsKKyAgICAgICAgICAgICAgICBlbHNlIHsKKyAg ICAgICAgICAgICAgICAgICAgZGlmZmVyZW5jZSA9IHJvdW5kZihkaWZmZXJlbmNlICogMTAwLjBm KSAvIDEwMC4wZjsKKyAgICAgICAgICAgICAgICAgICAgZGlmZmVyZW5jZSA9IG1heChkaWZmZXJl bmNlLCAwLjAxZik7IC8vIHJvdW5kIHRvIDIgZGVjaW1hbCBwbGFjZXMKKyAgICAgICAgICAgICAg ICB9CisgICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgICAgICBmcHV0cygiZXJyb3IsIHRl c3QgYW5kIHJlZmVyZW5jZSBpbWFnZSBoYXZlIGRpZmZlcmVudCBwcm9wZXJ0aWVzLlxuIiwgc3Rk ZXJyKTsKKyAgICAgICAgICAgICAgICAKKyAgICAgICAgICAgIGlmIChkaWZmZXJlbmNlID4gMC4w ZikgeworICAgICAgICAgICAgICAgIGlmIChkaWZmSW1hZ2UpIHsKKyAgICAgICAgICAgICAgICAg ICAgUmV0YWluUHRyPENGTXV0YWJsZURhdGFSZWY+IGltYWdlRGF0YShBZG9wdENGLCBDRkRhdGFD cmVhdGVNdXRhYmxlKDAsIDApKTsKKyAgICAgICAgICAgICAgICAgICAgUmV0YWluUHRyPENHSW1h Z2VEZXN0aW5hdGlvblJlZj4gaW1hZ2VEZXN0KEFkb3B0Q0YsIENHSW1hZ2VEZXN0aW5hdGlvbkNy ZWF0ZVdpdGhEYXRhKGltYWdlRGF0YS5nZXQoKSwga1VUVHlwZVBORywgMSwgMCkpOworICAgICAg ICAgICAgICAgICAgICBDR0ltYWdlRGVzdGluYXRpb25BZGRJbWFnZShpbWFnZURlc3QuZ2V0KCks IGRpZmZJbWFnZS5nZXQoKSwgMCk7CisgICAgICAgICAgICAgICAgICAgIENHSW1hZ2VEZXN0aW5h dGlvbkZpbmFsaXplKGltYWdlRGVzdC5nZXQoKSk7CisgICAgICAgICAgICAgICAgICAgIHByaW50 ZigiQ29udGVudC1MZW5ndGg6ICVsdVxuIiwgQ0ZEYXRhR2V0TGVuZ3RoKGltYWdlRGF0YS5nZXQo KSkpOworICAgICAgICAgICAgICAgICAgICBmd3JpdGUoQ0ZEYXRhR2V0Qnl0ZVB0cihpbWFnZURh dGEuZ2V0KCkpLCAxLCBDRkRhdGFHZXRMZW5ndGgoaW1hZ2VEYXRhLmdldCgpKSwgc3Rkb3V0KTsK KyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgCisgICAgICAgICAgICAgICAgZnBy aW50ZihzdGRvdXQsICJkaWZmOiAlMDEuMmYlJSBmYWlsZWRcbiIsIGRpZmZlcmVuY2UpOworICAg ICAgICAgICAgfSBlbHNlCisgICAgICAgICAgICAgICAgZnByaW50ZihzdGRvdXQsICJkaWZmOiAl MDEuMmYlJSBwYXNzZWRcbiIsIGRpZmZlcmVuY2UpOworICAgICAgICAgICAgCiAgICAgICAgICAg ICBhY3R1YWxJbWFnZSA9IDA7CiAgICAgICAgICAgICBiYXNlbGluZUltYWdlID0gMDsKICAgICAg ICAgfQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1w U3VwcG9ydENHLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1 cHBvcnRDRy5jcHAKaW5kZXggMjYwYTk0ZS4uMjMyMGUxOSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvY2cvUGl4ZWxEdW1wU3VwcG9ydENHLmNwcAorKysgYi9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9jZy9QaXhlbER1bXBTdXBwb3J0Q0cuY3BwCkBAIC0zNCw3ICsz NCwxMCBAQAogI2luY2x1ZGUgIkR1bXBSZW5kZXJUcmVlLmgiCiAjaW5jbHVkZSAiTGF5b3V0VGVz dENvbnRyb2xsZXIuaCIKICNpbmNsdWRlIDxJbWFnZUlPL0NHSW1hZ2VEZXN0aW5hdGlvbi5oPgor I2luY2x1ZGUgPGFsZ29yaXRobT4KKyNpbmNsdWRlIDxjdHlwZS5oPgogI2luY2x1ZGUgPHd0Zi9B c3NlcnRpb25zLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZXRh aW5QdHIuaD4KICNpbmNsdWRlIDx3dGYvU3RyaW5nRXh0cmFzLmg+CiAKQEAgLTYzLDY2ICs2Niw2 OSBAQCBzdGF0aWMgdm9pZCBwcmludFBORyhDR0ltYWdlUmVmIGltYWdlKQogICAgIGZ3cml0ZShD RkRhdGFHZXRCeXRlUHRyKGltYWdlRGF0YS5nZXQoKSksIDEsIENGRGF0YUdldExlbmd0aChpbWFn ZURhdGEuZ2V0KCkpLCBzdGRvdXQpOwogfQogCi1zdGF0aWMgdm9pZCBnZXRNRDVIYXNoU3RyaW5n Rm9yQml0bWFwKENHQ29udGV4dFJlZiBiaXRtYXAsIGNoYXIgc3RyaW5nWzMzXSkKK3N0YXRpYyB2 b2lkIGNvbXB1dGVNRDVIYXNoU3RyaW5nRm9yQml0bWFwQ29udGV4dChDR0NvbnRleHRSZWYgYml0 bWFwQ29udGV4dCwgY2hhciBoYXNoU3RyaW5nWzMzXSkKIHsKLSAgICBNRDVfQ1RYIG1kNUNvbnRl eHQ7Ci0gICAgdW5zaWduZWQgY2hhciBoYXNoWzE2XTsKLQotICAgIHNpemVfdCBiaXRzUGVyUGl4 ZWwgPSBDR0JpdG1hcENvbnRleHRHZXRCaXRzUGVyUGl4ZWwoYml0bWFwKTsKLSAgICBBU1NFUlQo Yml0c1BlclBpeGVsID09IDMyKTsgLy8gSW1hZ2VEaWZmIGFzc3VtZXMgMzIgYml0IFJHQkEsIHdl IG11c3QgYXMgd2VsbC4KLSAgICBzaXplX3QgYnl0ZXNQZXJQaXhlbCA9IGJpdHNQZXJQaXhlbCAv IDg7Ci0gICAgc2l6ZV90IHBpeGVsc0hpZ2ggPSBDR0JpdG1hcENvbnRleHRHZXRIZWlnaHQoYml0 bWFwKTsKLSAgICBzaXplX3QgcGl4ZWxzV2lkZSA9IENHQml0bWFwQ29udGV4dEdldFdpZHRoKGJp dG1hcCk7Ci0gICAgc2l6ZV90IGJ5dGVzUGVyUm93ID0gQ0dCaXRtYXBDb250ZXh0R2V0Qnl0ZXNQ ZXJSb3coYml0bWFwKTsKLSAgICBBU1NFUlQoYnl0ZXNQZXJSb3cgPj0gKHBpeGVsc1dpZGUgKiBi eXRlc1BlclBpeGVsKSk7CisgICAgQVNTRVJUKENHQml0bWFwQ29udGV4dEdldEJpdHNQZXJQaXhl bChiaXRtYXBDb250ZXh0KSA9PSAzMik7IC8vIEltYWdlRGlmZiBhc3N1bWVzIDMyIGJpdCBSR0JB LCB3ZSBtdXN0IGFzIHdlbGwuCisgICAgc2l6ZV90IHBpeGVsc0hpZ2ggPSBDR0JpdG1hcENvbnRl eHRHZXRIZWlnaHQoYml0bWFwQ29udGV4dCk7CisgICAgc2l6ZV90IHBpeGVsc1dpZGUgPSBDR0Jp dG1hcENvbnRleHRHZXRXaWR0aChiaXRtYXBDb250ZXh0KTsKKyAgICBzaXplX3QgYnl0ZXNQZXJS b3cgPSBDR0JpdG1hcENvbnRleHRHZXRCeXRlc1BlclJvdyhiaXRtYXBDb250ZXh0KTsKIAorICAg IC8vIFdlIG5lZWQgdG8gc3dhcCB0aGUgYnl0ZXMgdG8gZW5zdXJlIGNvbnNpc3RlbnQgaGFzaGVz IGluZGVwZW5kZW50bHkgb2YgZW5kaWFubmVzcworICAgIE1ENV9DVFggbWQ1Q29udGV4dDsKICAg ICBNRDVfSW5pdCgmbWQ1Q29udGV4dCk7Ci0gICAgdW5zaWduZWQgY2hhciogYml0bWFwRGF0YSA9 IHN0YXRpY19jYXN0PHVuc2lnbmVkIGNoYXIqPihDR0JpdG1hcENvbnRleHRHZXREYXRhKGJpdG1h cCkpOwotICAgIGZvciAodW5zaWduZWQgcm93ID0gMDsgcm93IDwgcGl4ZWxzSGlnaDsgcm93Kysp IHsKLSAgICAgICAgTUQ1X1VwZGF0ZSgmbWQ1Q29udGV4dCwgYml0bWFwRGF0YSwgc3RhdGljX2Nh c3Q8dW5zaWduZWQ+KHBpeGVsc1dpZGUgKiBieXRlc1BlclBpeGVsKSk7Ci0gICAgICAgIGJpdG1h cERhdGEgKz0gYnl0ZXNQZXJSb3c7CisgICAgdW5zaWduZWQgY2hhciogYml0bWFwRGF0YSA9IHN0 YXRpY19jYXN0PHVuc2lnbmVkIGNoYXIqPihDR0JpdG1hcENvbnRleHRHZXREYXRhKGJpdG1hcENv bnRleHQpKTsKKyNpZiBQTEFURk9STShNQUMpCisgICAgaWYgKChDR0JpdG1hcENvbnRleHRHZXRC aXRtYXBJbmZvKGJpdG1hcENvbnRleHQpICYga0NHQml0bWFwQnl0ZU9yZGVyTWFzaykgPT0ga0NH Qml0bWFwQnl0ZU9yZGVyMzJCaWcpIHsKKyAgICAgICAgZm9yICh1bnNpZ25lZCByb3cgPSAwOyBy b3cgPCBwaXhlbHNIaWdoOyByb3crKykgeworICAgICAgICAgICAgdWludDMyX3QgYnVmZmVyW3Bp eGVsc1dpZGVdOworICAgICAgICAgICAgZm9yICh1bnNpZ25lZCBjb2x1bW4gPSAwOyBjb2x1bW4g PCBwaXhlbHNXaWRlOyBjb2x1bW4rKykKKyAgICAgICAgICAgICAgICBidWZmZXJbY29sdW1uXSA9 IE9TUmVhZExpdHRsZUludDMyKGJpdG1hcERhdGEsIDQgKiBjb2x1bW4pOworICAgICAgICAgICAg TUQ1X1VwZGF0ZSgmbWQ1Q29udGV4dCwgYnVmZmVyLCA0ICogcGl4ZWxzV2lkZSk7CisgICAgICAg ICAgICBiaXRtYXBEYXRhICs9IGJ5dGVzUGVyUm93OworICAgICAgICB9CisgICAgfSBlbHNlCisj ZW5kaWYKKyAgICB7CisgICAgICAgIGZvciAodW5zaWduZWQgcm93ID0gMDsgcm93IDwgcGl4ZWxz SGlnaDsgcm93KyspIHsKKyAgICAgICAgICAgIE1ENV9VcGRhdGUoJm1kNUNvbnRleHQsIGJpdG1h cERhdGEsIDQgKiBwaXhlbHNXaWRlKTsKKyAgICAgICAgICAgIGJpdG1hcERhdGEgKz0gYnl0ZXNQ ZXJSb3c7CisgICAgICAgIH0KICAgICB9CisgICAgdW5zaWduZWQgY2hhciBoYXNoWzE2XTsKICAg ICBNRDVfRmluYWwoaGFzaCwgJm1kNUNvbnRleHQpOwogCi0gICAgc3RyaW5nWzBdID0gJ1wwJzsK KyAgICBoYXNoU3RyaW5nWzBdID0gJ1wwJzsKICAgICBmb3IgKGludCBpID0gMDsgaSA8IDE2OyBp KyspCi0gICAgICAgIHNucHJpbnRmKHN0cmluZywgMzMsICIlcyUwMngiLCBzdHJpbmcsIGhhc2hb aV0pOwotfQotCi12b2lkIGRyYXdTZWxlY3Rpb25SZWN0KENHQ29udGV4dFJlZiBjb250ZXh0LCBj b25zdCBDR1JlY3QmIHJlY3QpCi17Ci0gICAgQ0dDb250ZXh0U2F2ZUdTdGF0ZShjb250ZXh0KTsK LSAgICBDR0NvbnRleHRTZXRSR0JTdHJva2VDb2xvcihjb250ZXh0LCAxLjAsIDAuMCwgMC4wLCAx LjApOwotICAgIENHQ29udGV4dFN0cm9rZVJlY3QoY29udGV4dCwgcmVjdCk7Ci0gICAgQ0dDb250 ZXh0UmVzdG9yZUdTdGF0ZShjb250ZXh0KTsKKyAgICAgICAgc25wcmludGYoaGFzaFN0cmluZywg MzMsICIlcyUwMngiLCBoYXNoU3RyaW5nLCBoYXNoW2ldKTsKIH0KIAotdm9pZCBkdW1wV2ViVmll d0FzUGl4ZWxzQW5kQ29tcGFyZVdpdGhFeHBlY3RlZChjb25zdCBjaGFyKiAvKmN1cnJlbnRUZXN0 Ki8sIGJvb2wgLypmb3JjZUFsbFRlc3RzVG9EdW1wUGl4ZWxzKi8pCit2b2lkIGR1bXBXZWJWaWV3 QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4cGVjdGVkKGNvbnN0IHN0ZDo6c3RyaW5nJiBleHBlY3Rl ZEhhc2gpCiB7Ci0gICAgUmV0YWluUHRyPENHQ29udGV4dFJlZj4gY29udGV4dCA9IGdldEJpdG1h cENvbnRleHRGcm9tV2ViVmlldygpOwotCisgICAgUmVmUHRyPEJpdG1hcENvbnRleHQ+IGNvbnRl eHQ7CisgICAgCiAjaWYgUExBVEZPUk0oTUFDKQotICAgIGlmIChnTGF5b3V0VGVzdENvbnRyb2xs ZXItPnRlc3RSZXBhaW50KCkpCi0gICAgICAgIHJlcGFpbnRXZWJWaWV3KGNvbnRleHQuZ2V0KCks IGdMYXlvdXRUZXN0Q29udHJvbGxlci0+dGVzdFJlcGFpbnRTd2VlcEhvcml6b250YWxseSgpKTsK LSAgICBlbHNlIAotICAgICAgICBwYWludFdlYlZpZXcoY29udGV4dC5nZXQoKSk7Ci0KLSAgICBp ZiAoZ0xheW91dFRlc3RDb250cm9sbGVyLT5kdW1wU2VsZWN0aW9uUmVjdCgpKQotICAgICAgICBk cmF3U2VsZWN0aW9uUmVjdChjb250ZXh0LmdldCgpLCBnZXRTZWxlY3Rpb25SZWN0KCkpOworICAg IGNvbnRleHQgPSBjcmVhdGVCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoZ0xheW91dFRlc3RDb250 cm9sbGVyLT50ZXN0T25zY3JlZW4oKSwgZ0xheW91dFRlc3RDb250cm9sbGVyLT50ZXN0UmVwYWlu dCgpLCBnTGF5b3V0VGVzdENvbnRyb2xsZXItPnRlc3RSZXBhaW50U3dlZXBIb3Jpem9udGFsbHko KSwgZ0xheW91dFRlc3RDb250cm9sbGVyLT5kdW1wU2VsZWN0aW9uUmVjdCgpKTsKICNlbmRpZgot Ci0gICAgLy8gQ29tcHV0ZSB0aGUgYWN0dWFsIGhhc2ggdG8gY29tcGFyZSB0byB0aGUgZXhwZWN0 ZWQgaW1hZ2UncyBoYXNoLgorICAgIEFTU0VSVChjb250ZXh0KTsKKyAgICAKKyAgICAvLyBDb21w dXRlIHRoZSBoYXNoIG9mIHRoZSBiaXRtYXAgY29udGV4dCBwaXhlbHMKICAgICBjaGFyIGFjdHVh bEhhc2hbMzNdOwotICAgIGdldE1ENUhhc2hTdHJpbmdGb3JCaXRtYXAoY29udGV4dC5nZXQoKSwg YWN0dWFsSGFzaCk7CisgICAgY29tcHV0ZU1ENUhhc2hTdHJpbmdGb3JCaXRtYXBDb250ZXh0KGNv bnRleHQtPmNnQ29udGV4dCgpLCBhY3R1YWxIYXNoKTsKICAgICBwcmludGYoIlxuQWN0dWFsSGFz aDogJXNcbiIsIGFjdHVhbEhhc2gpOwotCi0gICAgLy8gRklYTUU6IFdlIHNob3VsZCBjb21wYXJl IHRoZSBhY3R1YWxIYXNoIHRvIHRoZSBleHBlY3RlZCBoYXNoIGhlcmUgYW5kCi0gICAgLy8gb25s eSBzZXQgZHVtcEltYWdlIHRvIHRydWUgaWYgdGhleSBkb24ndCBtYXRjaCwgYnV0IERSVCBkb2Vz bid0IGhhdmUKLSAgICAvLyBlbm91Z2ggaW5mb3JtYXRpb24gY3VycmVudGx5IHRvIGZpbmQgdGhl IGV4cGVjdGVkIGNoZWNrc3VtIGZpbGUuCisgICAgCisgICAgLy8gQ2hlY2sgdGhlIGNvbXB1dGVk IGhhc2ggYWdhaW5zdCB0aGUgZXhwZWN0ZWQgb25lIGFuZCBkdW1wIGltYWdlIG9uIG1pc21hdGNo CiAgICAgYm9vbCBkdW1wSW1hZ2UgPSB0cnVlOwotCisgICAgaWYgKGV4cGVjdGVkSGFzaC5sZW5n dGgoKSA+IDApIHsKKyAgICAgICAgQVNTRVJUKGV4cGVjdGVkSGFzaC5sZW5ndGgoKSA9PSAzMik7 CisgICAgICAgIAorICAgICAgICBwcmludGYoIlxuRXhwZWN0ZWRIYXNoOiAlc1xuIiwgZXhwZWN0 ZWRIYXNoLmNfc3RyKCkpOworICAgICAgICAKKyAgICAgICAgaWYgKGV4cGVjdGVkSGFzaCA9PSBh Y3R1YWxIYXNoKSAgICAgLy8gRklYTUU6IGRvIGNhc2UgaW5zZW5zaXRpdmUgY29tcGFyZQorICAg ICAgICAgICAgZHVtcEltYWdlID0gZmFsc2U7CisgICAgfQorICAgIAogICAgIGlmIChkdW1wSW1h Z2UpIHsKLSAgICAgICAgUmV0YWluUHRyPENHSW1hZ2VSZWY+IGltYWdlKEFkb3B0Q0YsIENHQml0 bWFwQ29udGV4dENyZWF0ZUltYWdlKGNvbnRleHQuZ2V0KCkpKTsKKyAgICAgICAgUmV0YWluUHRy PENHSW1hZ2VSZWY+IGltYWdlKEFkb3B0Q0YsIENHQml0bWFwQ29udGV4dENyZWF0ZUltYWdlKGNv bnRleHQtPmNnQ29udGV4dCgpKSk7CiAgICAgICAgIHByaW50UE5HKGltYWdlLmdldCgpKTsKICAg ICB9CiB9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9jZy9QaXhlbER1 bXBTdXBwb3J0Q0cuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1 cHBvcnRDRy5oCmluZGV4IDBhYmRlYTYuLjg0MzUwZTggMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5oCisrKyBiL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL2NnL1BpeGVsRHVtcFN1cHBvcnRDRy5oCkBAIC0zMSwyNSArMzEsNTAg QEAKICNpZm5kZWYgUGl4ZWxEdW1wU3VwcG9ydENHX2gKICNkZWZpbmUgUGl4ZWxEdW1wU3VwcG9y dENHX2gKIAorI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZkNv dW50ZWQuaD4KICNpbmNsdWRlIDx3dGYvUmV0YWluUHRyLmg+CiAKLSNpZm5kZWYgQ0dGTE9BVF9E RUZJTkVECi0jaWZkZWYgX19MUDY0X18KLXR5cGVkZWYgZG91YmxlIENHRmxvYXQ7Ci0jZWxzZQot dHlwZWRlZiBmbG9hdCBDR0Zsb2F0OwordHlwZWRlZiBzdHJ1Y3QgQ0dDb250ZXh0KiBDR0NvbnRl eHRSZWY7CisKKyNpZiBQTEFURk9STShNQUMpCit0eXBlZGVmIHZvaWQqIFBsYXRmb3JtQml0bWFw QnVmZmVyOworI2VsaWYgUExBVEZPUk0oV0lOKQordHlwZWRlZiBIQklUTUFQIFBsYXRmb3JtQml0 bWFwQnVmZmVyOwogI2VuZGlmCi0jZGVmaW5lIENHRkxPQVRfREVGSU5FRCAxCisKK2NsYXNzIEJp dG1hcENvbnRleHQgOiBwdWJsaWMgUmVmQ291bnRlZDxCaXRtYXBDb250ZXh0PiB7CitwdWJsaWM6 CisgICAgc3RhdGljIFBhc3NSZWZQdHI8Qml0bWFwQ29udGV4dD4gY3JlYXRlQnlBZG9wdGluZ0Jp dG1hcEFuZENvbnRleHQoUGxhdGZvcm1CaXRtYXBCdWZmZXIgYnVmZmVyLCBDR0NvbnRleHRSZWYg Y29udGV4dCkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgQml0bWFwQ29udGV4 dChidWZmZXIsIGNvbnRleHQpKTsKKyAgICB9CisKKyAgICB+Qml0bWFwQ29udGV4dCgpCisgICAg eworICAgICAgICBpZiAobV9idWZmZXIpCisjaWYgUExBVEZPUk0oTUFDKQorICAgICAgICAgICAg ZnJlZShtX2J1ZmZlcik7CisjZWxpZiBQTEFURk9STShXSU4pCisgICAgICAgICAgICBEZWxldGVP YmplY3QobV9idWZmZXIpOwogI2VuZGlmCisgICAgfQogCi10eXBlZGVmIHN0cnVjdCBDR0NvbnRl eHQqIENHQ29udGV4dFJlZjsKLXN0cnVjdCBDR1JlY3Q7CisgICAgQ0dDb250ZXh0UmVmIGNnQ29u dGV4dCgpIGNvbnN0IHsgcmV0dXJuIG1fY29udGV4dC5nZXQoKTsgfQorCitwcml2YXRlOgorCisg ICAgQml0bWFwQ29udGV4dChQbGF0Zm9ybUJpdG1hcEJ1ZmZlciBidWZmZXIsIENHQ29udGV4dFJl ZiBjb250ZXh0KQorICAgICAgICA6IG1fYnVmZmVyKGJ1ZmZlcikKKyAgICAgICAgLCBtX2NvbnRl eHQoQWRvcHRDRiwgY29udGV4dCkKKyAgICB7CisgICAgfQorCisgICAgUGxhdGZvcm1CaXRtYXBC dWZmZXIgbV9idWZmZXI7CisgICAgUmV0YWluUHRyPENHQ29udGV4dFJlZj4gbV9jb250ZXh0Owog Ci1SZXRhaW5QdHI8Q0dDb250ZXh0UmVmPiBnZXRCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoKTsK LUNHUmVjdCBnZXRTZWxlY3Rpb25SZWN0KCk7Cit9OwogCi12b2lkIHBhaW50V2ViVmlldyhDR0Nv bnRleHRSZWYpOwotdm9pZCByZXBhaW50V2ViVmlldyhDR0NvbnRleHRSZWYgY29udGV4dCwgYm9v bCBob3Jpem9udGFsKTsKLXZvaWQgZHJhd1NlbGVjdGlvblJlY3QoQ0dDb250ZXh0UmVmLCBjb25z dCBDR1JlY3QmKTsKK1Bhc3NSZWZQdHI8Qml0bWFwQ29udGV4dD4gY3JlYXRlQml0bWFwQ29udGV4 dEZyb21XZWJWaWV3KGJvb2wgb25zY3JlZW4sIGJvb2wgaW5jcmVtZW50YWxSZXBhaW50LCBib29s IHN3ZWVwSG9yaXpvbnRhbGx5LCBib29sIGRyYXdTZWxlY3Rpb25SZWN0KTsKIAogI2VuZGlmIC8v IFBpeGVsRHVtcFN1cHBvcnRDR19oCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0gYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9t YWMvRHVtcFJlbmRlclRyZWUubW0KaW5kZXggYmVjZTkwNi4uNTk2YmY2OSAxMDA2NDQKLS0tIGEv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCisrKyBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQpAQCAtNzUsMTAg Kzc1LDEyIEBACiAjaW1wb3J0IDx3dGYvUmV0YWluUHRyLmg+CiAjaW1wb3J0IDx3dGYvT3duUHRy Lmg+CiAKK3VzaW5nIG5hbWVzcGFjZSBzdGQ7CisKIEBpbnRlcmZhY2UgRHVtcFJlbmRlclRyZWVF dmVudCA6IE5TRXZlbnQKIEBlbmQKIAotc3RhdGljIHZvaWQgcnVuVGVzdChjb25zdCBjaGFyICpw YXRoT3JVUkwpOworc3RhdGljIHZvaWQgcnVuVGVzdChjb25zdCBzdHJpbmcmIHRlc3RQYXRoT3JV UkwpOwogCiAvLyBEZWNpZGluZyB3aGVuIGl0J3MgT0sgdG8gZHVtcCBvdXQgdGhlIHN0YXRlIGlz IGEgYml0IHRyaWNreS4gIEFsbCB0aGVzZSBtdXN0IGJlIHRydWU6CiAvLyAtIFRoZXJlIGlzIG5v IGxvYWQgaW4gcHJvZ3Jlc3MKQEAgLTExMSwxNCArMTEzLDEwIEBAIHN0YXRpYyBSZXNvdXJjZUxv YWREZWxlZ2F0ZSAqcmVzb3VyY2VMb2FkRGVsZWdhdGU7CiBQb2xpY3lEZWxlZ2F0ZSAqcG9saWN5 RGVsZWdhdGU7CiAKIHN0YXRpYyBpbnQgZHVtcFBpeGVsczsKLXN0YXRpYyBpbnQgZHVtcEFsbFBp eGVsczsKIHN0YXRpYyBpbnQgdGhyZWFkZWQ7Ci1zdGF0aWMgaW50IHRlc3RSZXBhaW50RGVmYXVs dDsKLXN0YXRpYyBpbnQgcmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5RGVmYXVsdDsKIHN0YXRpYyBp bnQgZHVtcFRyZWUgPSBZRVM7CiBzdGF0aWMgaW50IGZvcmNlQ29tcGxleFRleHQ7CiBzdGF0aWMg Qk9PTCBwcmludFNlcGFyYXRvcnM7Ci1zdGF0aWMgTlNTdHJpbmcgKmN1cnJlbnRUZXN0ID0gbmls Owogc3RhdGljIFJldGFpblB0cjxDRlN0cmluZ1JlZj4gcGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0 TG9jYXRpb247CiAKIHN0YXRpYyBXZWJIaXN0b3J5SXRlbSAqcHJldlRlc3RCRkl0ZW0gPSBuaWw7 ICAvLyBjdXJyZW50IGIvZiBpdGVtIGF0IHRoZSBlbmQgb2YgdGhlIHByZXZpb3VzIHRlc3QKQEAg LTE4MSwyMSArMTc5LDIxIEBAIHZvaWQgc2V0UGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRp b24oQ0ZTdHJpbmdSZWYgdXJsKQogICAgIHBlcnNpc3RlbnRVc2VyU3R5bGVTaGVldExvY2F0aW9u ID0gdXJsOwogfQogCi1zdGF0aWMgQk9PTCBzaG91bGRJZ25vcmVXZWJDb3JlTm9kZUxlYWtzKENG U3RyaW5nUmVmIFVSTFN0cmluZykKK3N0YXRpYyBib29sIHNob3VsZElnbm9yZVdlYkNvcmVOb2Rl TGVha3MoY29uc3Qgc3RyaW5nJiBVUkxTdHJpbmcpCiB7Ci0gICAgc3RhdGljIENGU3RyaW5nUmVm IGNvbnN0IGlnbm9yZVNldFtdID0geworICAgIHN0YXRpYyBjaGFyKiBjb25zdCBpZ25vcmVTZXRb XSA9IHsKICAgICAgICAgLy8gS2VlcGluZyB0aGlzIGluZnJhc3RydWN0dXJlIGFyb3VuZCBpbiBj YXNlIHdlIGV2ZXIgbmVlZCBpdCBhZ2Fpbi4KICAgICB9OwotICAgIHN0YXRpYyBjb25zdCBpbnQg aWdub3JlU2V0Q291bnQgPSBzaXplb2YoaWdub3JlU2V0KSAvIHNpemVvZihDRlN0cmluZ1JlZik7 CisgICAgc3RhdGljIGNvbnN0IGludCBpZ25vcmVTZXRDb3VudCA9IHNpemVvZihpZ25vcmVTZXQp IC8gc2l6ZW9mKGNoYXIqKTsKICAgICAKICAgICBmb3IgKGludCBpID0gMDsgaSA8IGlnbm9yZVNl dENvdW50OyBpKyspIHsKLSAgICAgICAgQ0ZTdHJpbmdSZWYgaWdub3JlU3RyaW5nID0gaWdub3Jl U2V0W2ldOwotICAgICAgICBDRlJhbmdlIHJhbmdlID0gQ0ZSYW5nZU1ha2UoMCwgQ0ZTdHJpbmdH ZXRMZW5ndGgoVVJMU3RyaW5nKSk7Ci0gICAgICAgIENGT3B0aW9uRmxhZ3MgZmxhZ3MgPSBrQ0ZD b21wYXJlQW5jaG9yZWQgfCBrQ0ZDb21wYXJlQmFja3dhcmRzIHwga0NGQ29tcGFyZUNhc2VJbnNl bnNpdGl2ZTsKLSAgICAgICAgaWYgKENGU3RyaW5nRmluZFdpdGhPcHRpb25zKFVSTFN0cmluZywg aWdub3JlU3RyaW5nLCByYW5nZSwgZmxhZ3MsIE5VTEwpKQotICAgICAgICAgICAgcmV0dXJuIFlF UzsKKyAgICAgICAgLy8gRklYTUU6IGlnbm9yZSBjYXNlCisgICAgICAgIHN0cmluZyBjdXJJZ25v cmUoaWdub3JlU2V0W2ldKTsKKyAgICAgICAgLy8gTWF0Y2ggYXQgdGhlIGVuZCBvZiB0aGUgVVJM U3RyaW5nCisgICAgICAgIGlmICghVVJMU3RyaW5nLmNvbXBhcmUoVVJMU3RyaW5nLmxlbmd0aCgp IC0gY3VySWdub3JlLmxlbmd0aCgpLCBjdXJJZ25vcmUubGVuZ3RoKCksIGN1cklnbm9yZSkpCisg ICAgICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICB9Ci0gICAgcmV0dXJuIE5POworICAgIHJldHVy biBmYWxzZTsKIH0KIAogc3RhdGljIHZvaWQgYWN0aXZhdGVGb250cygpCkBAIC0zMDcsMTMgKzMw NSwxMyBAQCB2b2lkIHRlc3RTdHJpbmdCeUV2YWx1YXRpbmdKYXZhU2NyaXB0RnJvbVN0cmluZygp CiBzdGF0aWMgdm9pZCBzZXREZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVlc0ZvclRlc3RpbmcoKQog ewogICAgIC8vIEdpdmUgc29tZSBjbGVhciB0byB1bmRvY3VtZW50ZWQgZGVmYXVsdHMgdmFsdWVz Ci0gICAgc3RhdGljIGNvbnN0IGludCBNZWRpdW1Gb250U21vb3RoaW5nID0gMjsKKyAgICBzdGF0 aWMgY29uc3QgaW50IE5vRm9udFNtb290aGluZyA9IDA7CiAgICAgc3RhdGljIGNvbnN0IGludCBC bHVlVGludGVkQXBwZWFyYW5jZSA9IDE7CiAKICAgICBOU1VzZXJEZWZhdWx0cyAqZGVmYXVsdHMg PSBbTlNVc2VyRGVmYXVsdHMgc3RhbmRhcmRVc2VyRGVmYXVsdHNdOwogICAgIFtkZWZhdWx0cyBz ZXRPYmplY3Q6QCJEb3VibGVNYXgiIGZvcktleTpAIkFwcGxlU2Nyb2xsQmFyVmFyaWFudCJdOwog ICAgIFtkZWZhdWx0cyBzZXRJbnRlZ2VyOjQgZm9yS2V5OkAiQXBwbGVBbnRpQWxpYXNpbmdUaHJl c2hvbGQiXTsgLy8gc21hbGxlc3QgZm9udCBzaXplIHRvIENHIHNob3VsZCBwZXJmb3JtIGFudGlh bGlhc2luZyBvbgotICAgIFtkZWZhdWx0cyBzZXRJbnRlZ2VyOk1lZGl1bUZvbnRTbW9vdGhpbmcg Zm9yS2V5OkAiQXBwbGVGb250U21vb3RoaW5nIl07CisgICAgW2RlZmF1bHRzIHNldEludGVnZXI6 Tm9Gb250U21vb3RoaW5nIGZvcktleTpAIkFwcGxlRm9udFNtb290aGluZyJdOwogICAgIFtkZWZh dWx0cyBzZXRJbnRlZ2VyOkJsdWVUaW50ZWRBcHBlYXJhbmNlIGZvcktleTpAIkFwcGxlQXF1YUNv bG9yVmFyaWFudCJdOwogICAgIFtkZWZhdWx0cyBzZXRPYmplY3Q6QCIwLjcwOTgwMCAwLjgzNTMw MCAxLjAwMDAwMCIgZm9yS2V5OkAiQXBwbGVIaWdobGlnaHRDb2xvciJdOwogICAgIFtkZWZhdWx0 cyBzZXRPYmplY3Q6QCIwLjUwMDAwMCAwLjUwMDAwMCAwLjUwMDAwMCIgZm9yS2V5OkAiQXBwbGVP dGhlckhpZ2hsaWdodENvbG9yIl07CkBAIC0zNTAsNyArMzQ4LDcgQEAgc3RhdGljIHZvaWQgY3Jh c2hIYW5kbGVyKGludCBzaWcpCiAgICAgY2hhciAqc2lnbmFsTmFtZSA9IHN0cnNpZ25hbChzaWcp OwogICAgIHdyaXRlKFNUREVSUl9GSUxFTk8sIHNpZ25hbE5hbWUsIHN0cmxlbihzaWduYWxOYW1l KSk7CiAgICAgd3JpdGUoU1RERVJSX0ZJTEVOTywgIlxuIiwgMSk7Ci0gICAgcmVzdG9yZUNvbG9y U3BhY2UoMCk7CisgICAgcmVzdG9yZU1haW5EaXNwbGF5Q29sb3JQcm9maWxlKDApOwogICAgIGV4 aXQoMTI4ICsgc2lnKTsKIH0KIApAQCAtMzk5LDExICszOTcsOCBAQCBzdGF0aWMgdm9pZCByZWxl YXNlR2xvYmFsQ29udHJvbGxlcnMoKQogc3RhdGljIHZvaWQgaW5pdGlhbGl6ZUdsb2JhbHNGcm9t Q29tbWFuZExpbmVPcHRpb25zKGludCBhcmdjLCBjb25zdCBjaGFyICphcmd2W10pCiB7CiAgICAg c3RydWN0IG9wdGlvbiBvcHRpb25zW10gPSB7Ci0gICAgICAgIHsiZHVtcC1hbGwtcGl4ZWxzIiwg bm9fYXJndW1lbnQsICZkdW1wQWxsUGl4ZWxzLCBZRVN9LAotICAgICAgICB7Imhvcml6b250YWwt c3dlZXAiLCBub19hcmd1bWVudCwgJnJlcGFpbnRTd2VlcEhvcml6b250YWxseURlZmF1bHQsIFlF U30sCiAgICAgICAgIHsibm90cmVlIiwgbm9fYXJndW1lbnQsICZkdW1wVHJlZSwgTk99LAogICAg ICAgICB7InBpeGVsLXRlc3RzIiwgbm9fYXJndW1lbnQsICZkdW1wUGl4ZWxzLCBZRVN9LAotICAg ICAgICB7InJlcGFpbnQiLCBub19hcmd1bWVudCwgJnRlc3RSZXBhaW50RGVmYXVsdCwgWUVTfSwK ICAgICAgICAgeyJ0cmVlIiwgbm9fYXJndW1lbnQsICZkdW1wVHJlZSwgWUVTfSwKICAgICAgICAg eyJ0aHJlYWRlZCIsIG5vX2FyZ3VtZW50LCAmdGhyZWFkZWQsIFlFU30sCiAgICAgICAgIHsiY29t cGxleC10ZXh0Iiwgbm9fYXJndW1lbnQsICZmb3JjZUNvbXBsZXhUZXh0LCBZRVN9LApAQCAtNDYw LDcgKzQ1NSw3IEBAIHN0YXRpYyB2b2lkIHByZXBhcmVDb25zaXN0ZW50VGVzdGluZ0Vudmlyb25t ZW50KCkKICAgICBhY3RpdmF0ZUZvbnRzKCk7CiAgICAgCiAgICAgaWYgKGR1bXBQaXhlbHMpCi0g ICAgICAgIGluaXRpYWxpemVDb2xvclNwYWNlQW5kU2NyZWVCdWZmZXJGb3JQaXhlbFRlc3RzKCk7 CisgICAgICAgIHNldHVwTWFpbkRpc3BsYXlDb2xvclByb2ZpbGUoKTsKICAgICBhbGxvY2F0ZUds b2JhbENvbnRyb2xsZXJzKCk7CiAgICAgCiAgICAgbWFrZUxhcmdlTWFsbG9jRmFpbFNpbGVudGx5 KCk7CkBAIC01MjYsNyArNTIxLDcgQEAgdm9pZCBkdW1wUmVuZGVyVHJlZShpbnQgYXJnYywgY29u c3QgY2hhciAqYXJndltdKQogICAgIH0KIAogICAgIGlmIChkdW1wUGl4ZWxzKQotICAgICAgICBy ZXN0b3JlQ29sb3JTcGFjZSgwKTsKKyAgICAgICAgcmVzdG9yZU1haW5EaXNwbGF5Q29sb3JQcm9m aWxlKDApOwogfQogCiBpbnQgbWFpbihpbnQgYXJnYywgY29uc3QgY2hhciAqYXJndltdKQpAQCAt ODIxLDcgKzgxNiw3IEBAIHN0YXRpYyB2b2lkIGR1bXBCYWNrRm9yd2FyZExpc3RGb3JXZWJWaWV3 KFdlYlZpZXcgKnZpZXcpCiBzdGF0aWMgdm9pZCBzaXplV2ViVmlld0ZvckN1cnJlbnRUZXN0KCkK IHsKICAgICAvLyBXM0MgU1ZHIHRlc3RzIGV4cGVjdCB0byBiZSA0ODB4MzYwCi0gICAgYm9vbCBp c1NWR1czQ1Rlc3QgPSAoW2N1cnJlbnRUZXN0IHJhbmdlT2ZTdHJpbmc6QCJzdmcvVzNDLVNWRy0x LjEiXS5sZW5ndGgpOworICAgIGJvb2wgaXNTVkdXM0NUZXN0ID0gKGdMYXlvdXRUZXN0Q29udHJv bGxlci0+dGVzdFBhdGhPclVSTCgpLmZpbmQoInN2Zy9XM0MtU1ZHLTEuMSIpICE9IHN0cmluZzo6 bnBvcyk7CiAgICAgaWYgKGlzU1ZHVzNDVGVzdCkKICAgICAgICAgW1ttYWluRnJhbWUgd2ViVmll d10gc2V0RnJhbWVTaXplOk5TTWFrZVNpemUoNDgwLCAzNjApXTsKICAgICBlbHNlCkBAIC05MTUs OCArOTEwLDggQEAgdm9pZCBkdW1wKCkKICAgICAgICAgfSAgICAgICAgICAgIAogICAgIH0KICAg ICAKLSAgICBpZiAoZHVtcEFsbFBpeGVscyB8fCAoZHVtcFBpeGVscyAmJiAhZHVtcEFzVGV4dCkp Ci0gICAgICAgIGR1bXBXZWJWaWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4cGVjdGVkKFtjdXJy ZW50VGVzdCBVVEY4U3RyaW5nXSwgZHVtcEFsbFBpeGVscyk7CisgICAgaWYgKGR1bXBQaXhlbHMg JiYgIWR1bXBBc1RleHQpCisgICAgICAgIGR1bXBXZWJWaWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0 aEV4cGVjdGVkKGdMYXlvdXRUZXN0Q29udHJvbGxlci0+ZXhwZWN0ZWRQaXhlbEhhc2goKSk7CiAg ICAgCiAgICAgcHV0cygiI0VPRiIpOyAgIC8vIHRlcm1pbmF0ZSB0aGUgKHBvc3NpYmx5IGVtcHR5 KSBwaXhlbHMgYmxvY2sKIApAQCAtOTMxLDE2ICs5MjYsNiBAQCBzdGF0aWMgYm9vbCBzaG91bGRM b2dGcmFtZUxvYWREZWxlZ2F0ZXMoY29uc3QgY2hhciAqcGF0aE9yVVJMKQogICAgIHJldHVybiBz dHJzdHIocGF0aE9yVVJMLCAibG9hZGluZy8iKTsKIH0KIAotc3RhdGljIENGVVJMUmVmIGNyZWF0 ZUNGVVJMRnJvbVBhdGhPclVSTChDRlN0cmluZ1JlZiBwYXRoT3JVUkxTdHJpbmcpCi17Ci0gICAg Q0ZVUkxSZWYgVVJMOwotICAgIGlmIChDRlN0cmluZ0hhc1ByZWZpeChwYXRoT3JVUkxTdHJpbmcs IENGU1RSKCJodHRwOi8vIikpIHx8IENGU3RyaW5nSGFzUHJlZml4KHBhdGhPclVSTFN0cmluZywg Q0ZTVFIoImh0dHBzOi8vIikpKQotICAgICAgICBVUkwgPSBDRlVSTENyZWF0ZVdpdGhTdHJpbmco TlVMTCwgcGF0aE9yVVJMU3RyaW5nLCBOVUxMKTsKLSAgICBlbHNlCi0gICAgICAgIFVSTCA9IENG VVJMQ3JlYXRlV2l0aEZpbGVTeXN0ZW1QYXRoKE5VTEwsIHBhdGhPclVSTFN0cmluZywga0NGVVJM UE9TSVhQYXRoU3R5bGUsIEZBTFNFKTsKLSAgICByZXR1cm4gVVJMOwotfQotCiBzdGF0aWMgdm9p ZCByZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0ZUJlZm9yZVRlc3RpbmcoKQogewogICAgIFdl YlZpZXcgKndlYlZpZXcgPSBbbWFpbkZyYW1lIHdlYlZpZXddOwpAQCAtOTY5LDMwICs5NTQsNDcg QEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdGVCZWZvcmVUZXN0aW5n KCkKICAgICBbV2ViVmlldyBfc2V0VXNlc1Rlc3RNb2RlRm9jdXNSaW5nQ29sb3I6WUVTXTsKIH0K IAotc3RhdGljIHZvaWQgcnVuVGVzdChjb25zdCBjaGFyICpwYXRoT3JVUkwpCitzdGF0aWMgdm9p ZCBydW5UZXN0KGNvbnN0IHN0cmluZyYgdGVzdFBhdGhPclVSTCkKIHsKLSAgICBDRlN0cmluZ1Jl ZiBwYXRoT3JVUkxTdHJpbmcgPSBDRlN0cmluZ0NyZWF0ZVdpdGhDU3RyaW5nKE5VTEwsIHBhdGhP clVSTCwga0NGU3RyaW5nRW5jb2RpbmdVVEY4KTsKKyAgICBBU1NFUlQoIXRlc3RQYXRoT3JVUkwu ZW1wdHkoKSk7CisgICAgCisgICAgLy8gTG9vayBmb3IgIiciIGFzIGEgc2VwYXJhdG9yIGJldHdl ZW4gdGhlIHBhdGggb3IgVVJMLCBhbmQgdGhlIHBpeGVsIGR1bXAgaGFzaCB0aGF0IGZvbGxvd3Mu CisgICAgc3RyaW5nIHBhdGhPclVSTCh0ZXN0UGF0aE9yVVJMKTsKKyAgICBzdHJpbmcgZXhwZWN0 ZWRQaXhlbEhhc2g7CisgICAgCisgICAgc2l6ZV90IHNlcGFyYXRvclBvcyA9IHBhdGhPclVSTC5m aW5kKCInIik7CisgICAgaWYgKHNlcGFyYXRvclBvcyAhPSBzdHJpbmc6Om5wb3MpIHsKKyAgICAg ICAgcGF0aE9yVVJMID0gc3RyaW5nKHRlc3RQYXRoT3JVUkwsIDAsIHNlcGFyYXRvclBvcyk7Cisg ICAgICAgIGV4cGVjdGVkUGl4ZWxIYXNoID0gc3RyaW5nKHRlc3RQYXRoT3JVUkwsIHNlcGFyYXRv clBvcyArIDEpOworICAgIH0KKworICAgIE5TU3RyaW5nICpwYXRoT3JVUkxTdHJpbmcgPSBbTlNT dHJpbmcgc3RyaW5nV2l0aFVURjhTdHJpbmc6cGF0aE9yVVJMLmNfc3RyKCldOwogICAgIGlmICgh cGF0aE9yVVJMU3RyaW5nKSB7Ci0gICAgICAgIGZwcmludGYoc3RkZXJyLCAiRmFpbGVkIHRvIHBh cnNlIGZpbGVuYW1lIGFzIFVURi04OiAlc1xuIiwgcGF0aE9yVVJMKTsKKyAgICAgICAgZnByaW50 ZihzdGRlcnIsICJGYWlsZWQgdG8gcGFyc2UgXCIlc1wiIGFzIFVURi04XG4iLCBwYXRoT3JVUkwu Y19zdHIoKSk7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBDRlVSTFJlZiBVUkwgPSBj cmVhdGVDRlVSTEZyb21QYXRoT3JVUkwocGF0aE9yVVJMU3RyaW5nKTsKLSAgICBpZiAoIVVSTCkg ewotICAgICAgICBDRlJlbGVhc2UocGF0aE9yVVJMU3RyaW5nKTsKLSAgICAgICAgZnByaW50Zihz dGRlcnIsICJDYW4ndCB0dXJuICVzIGludG8gYSBDRlVSTFxuIiwgcGF0aE9yVVJMKTsKKyAgICBO U1VSTCAqdXJsOworICAgIGlmIChbcGF0aE9yVVJMU3RyaW5nIGhhc1ByZWZpeDpAImh0dHA6Ly8i XSB8fCBbcGF0aE9yVVJMU3RyaW5nIGhhc1ByZWZpeDpAImh0dHBzOi8vIl0pCisgICAgICAgIHVy bCA9IFtOU1VSTCBVUkxXaXRoU3RyaW5nOnBhdGhPclVSTFN0cmluZ107CisgICAgZWxzZQorICAg ICAgICB1cmwgPSBbTlNVUkwgZmlsZVVSTFdpdGhQYXRoOnBhdGhPclVSTFN0cmluZ107CisgICAg aWYgKCF1cmwpIHsKKyAgICAgICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gcGFyc2UgXCIl c1wiIGFzIGEgVVJMXG4iLCBwYXRoT3JVUkwuY19zdHIoKSk7CiAgICAgICAgIHJldHVybjsKICAg ICB9CiAKKyAgICBjb25zdCBzdHJpbmcgdGVzdFVSTChbW3VybCBhYnNvbHV0ZVN0cmluZ10gVVRG OFN0cmluZ10pOworICAgIAogICAgIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3Jl VGVzdGluZygpOwogCi0gICAgZ0xheW91dFRlc3RDb250cm9sbGVyID0gbmV3IExheW91dFRlc3RD b250cm9sbGVyKHRlc3RSZXBhaW50RGVmYXVsdCwgcmVwYWludFN3ZWVwSG9yaXpvbnRhbGx5RGVm YXVsdCk7CisgICAgZ0xheW91dFRlc3RDb250cm9sbGVyID0gbmV3IExheW91dFRlc3RDb250cm9s bGVyKHRlc3RVUkwsIGV4cGVjdGVkUGl4ZWxIYXNoKTsKICAgICB0b3BMb2FkaW5nRnJhbWUgPSBu aWw7CiAgICAgZG9uZSA9IE5POwogCiAgICAgaWYgKGRpc2FsbG93ZWRVUkxzKQogICAgICAgICBD RlNldFJlbW92ZUFsbFZhbHVlcyhkaXNhbGxvd2VkVVJMcyk7Ci0gICAgaWYgKHNob3VsZExvZ0Zy YW1lTG9hZERlbGVnYXRlcyhwYXRoT3JVUkwpKQorICAgIGlmIChzaG91bGRMb2dGcmFtZUxvYWRE ZWxlZ2F0ZXMocGF0aE9yVVJMLmNfc3RyKCkpKQogICAgICAgICBnTGF5b3V0VGVzdENvbnRyb2xs ZXItPnNldER1bXBGcmFtZUxvYWRDYWxsYmFja3ModHJ1ZSk7CiAKICAgICBpZiAoW1dlYkhpc3Rv cnkgb3B0aW9uYWxTaGFyZWRIaXN0b3J5XSkKQEAgLTEwMDAsMjIgKzEwMDIsMTggQEAgc3RhdGlj IHZvaWQgcnVuVGVzdChjb25zdCBjaGFyICpwYXRoT3JVUkwpCiAgICAgbGFzdE1vdXNlUG9zaXRp b24gPSBOU1plcm9Qb2ludDsKICAgICBsYXN0Q2xpY2tQb3NpdGlvbiA9IE5TWmVyb1BvaW50Owog Ci0gICAgaWYgKGN1cnJlbnRUZXN0ICE9IG5pbCkKLSAgICAgICAgQ0ZSZWxlYXNlKGN1cnJlbnRU ZXN0KTsKLSAgICBjdXJyZW50VGVzdCA9IChOU1N0cmluZyAqKXBhdGhPclVSTFN0cmluZzsKICAg ICBbcHJldlRlc3RCRkl0ZW0gcmVsZWFzZV07CiAgICAgcHJldlRlc3RCRkl0ZW0gPSBbW1tbbWFp bkZyYW1lIHdlYlZpZXddIGJhY2tGb3J3YXJkTGlzdF0gY3VycmVudEl0ZW1dIHJldGFpbl07CiAK ICAgICBXb3JrUXVldWU6OnNoYXJlZCgpLT5jbGVhcigpOwogICAgIFdvcmtRdWV1ZTo6c2hhcmVk KCktPnNldEZyb3plbihmYWxzZSk7CiAKLSAgICBCT09MIF9zaG91bGRJZ25vcmVXZWJDb3JlTm9k ZUxlYWtzID0gc2hvdWxkSWdub3JlV2ViQ29yZU5vZGVMZWFrcyhDRlVSTEdldFN0cmluZyhVUkwp KTsKLSAgICBpZiAoX3Nob3VsZElnbm9yZVdlYkNvcmVOb2RlTGVha3MpCisgICAgYm9vbCBpZ25v cmVXZWJDb3JlTm9kZUxlYWtzID0gc2hvdWxkSWdub3JlV2ViQ29yZU5vZGVMZWFrcyh0ZXN0VVJM KTsKKyAgICBpZiAoaWdub3JlV2ViQ29yZU5vZGVMZWFrcykKICAgICAgICAgW1dlYkNvcmVTdGF0 aXN0aWNzIHN0YXJ0SWdub3JpbmdXZWJDb3JlTm9kZUxlYWtzXTsKIAogICAgIE5TQXV0b3JlbGVh c2VQb29sICpwb29sID0gW1tOU0F1dG9yZWxlYXNlUG9vbCBhbGxvY10gaW5pdF07Ci0gICAgW21h aW5GcmFtZSBsb2FkUmVxdWVzdDpbTlNVUkxSZXF1ZXN0IHJlcXVlc3RXaXRoVVJMOihOU1VSTCAq KVVSTF1dOwotICAgIENGUmVsZWFzZShVUkwpOworICAgIFttYWluRnJhbWUgbG9hZFJlcXVlc3Q6 W05TVVJMUmVxdWVzdCByZXF1ZXN0V2l0aFVSTDp1cmxdXTsKICAgICBbcG9vbCByZWxlYXNlXTsK ICAgICB3aGlsZSAoIWRvbmUpIHsKICAgICAgICAgcG9vbCA9IFtbTlNBdXRvcmVsZWFzZVBvb2wg YWxsb2NdIGluaXRdOwpAQCAtMTA1OCw3ICsxMDU2LDcgQEAgc3RhdGljIHZvaWQgcnVuVGVzdChj b25zdCBjaGFyICpwYXRoT3JVUkwpCiAgICAgZ0xheW91dFRlc3RDb250cm9sbGVyLT5kZXJlZigp OwogICAgIGdMYXlvdXRUZXN0Q29udHJvbGxlciA9IDA7CiAKLSAgICBpZiAoX3Nob3VsZElnbm9y ZVdlYkNvcmVOb2RlTGVha3MpCisgICAgaWYgKGlnbm9yZVdlYkNvcmVOb2RlTGVha3MpCiAgICAg ICAgIFtXZWJDb3JlU3RhdGlzdGljcyBzdG9wSWdub3JpbmdXZWJDb3JlTm9kZUxlYWtzXTsKIH0K IApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL1BpeGVsRHVtcFN1 cHBvcnRNYWMubW0gYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvUGl4ZWxEdW1wU3Vw cG9ydE1hYy5tbQppbmRleCA5ZGRiYTMxLi5lYjI5ZmZhIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9tYWMvUGl4ZWxEdW1wU3VwcG9ydE1hYy5tbQorKysgYi9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9tYWMvUGl4ZWxEdW1wU3VwcG9ydE1hYy5tbQpAQCAtMzQsMTUz ICszNCwyMjEgQEAKIAogI2luY2x1ZGUgIkxheW91dFRlc3RDb250cm9sbGVyLmgiCiAjaW5jbHVk ZSA8Q29yZUdyYXBoaWNzL0NHQml0bWFwQ29udGV4dC5oPgorI2lmbmRlZiBCVUlMRElOR19PTl9M RU9QQVJECisjaW5jbHVkZSA8T3BlbkdML09wZW5HTC5oPgorI2luY2x1ZGUgPE9wZW5HTC9DR0xN YWNyby5oPgorI2VuZGlmCiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KLSNpbmNsdWRlIDx3 dGYvUmV0YWluUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgogCiAjaW1wb3J0IDxXZWJL aXQvV2ViRG9jdW1lbnRQcml2YXRlLmg+CiAjaW1wb3J0IDxXZWJLaXQvV2ViS2l0Lmg+CiAKLXN0 YXRpYyB1bnNpZ25lZCBjaGFyKiBzY3JlZW5DYXB0dXJlQnVmZmVyOworLy8gVG8gZW5zdXJlIHBp eGVsIHRlc3RzIGNvbnNpc3RlbmN5LCB3ZSBuZWVkIHRvIGFsd2F5cyByZW5kZXIgaW4gdGhlIHNh bWUgY29sb3JzcGFjZS4KKy8vIFVuZm9ydHVuYXRlbHksIGJlY2F1c2Ugb2YgQXBwS2l0IC8gV2Vi S2l0IGNvbnN0cmFpbnRzLCB3ZSBjYW4ndCByZW5kZXIgZGlyZWN0bHkgaW4gdGhlIGNvbG9yc3Bh Y2Ugb2Ygb3VyIGNob2ljZS4KKy8vIFRoaXMgaW1wbGllcyB3ZSBoYXZlIHRvIHRlbXBvcmFyaWx5 IGNoYW5nZSB0aGUgcHJvZmlsZSBvZiB0aGUgbWFpbiBkaXNwbGF5IHRvIHRoZSBjb2xvcnNwYWNl IHdlIHdhbnQgdG8gcmVuZGVyIGludG8uCisvLyBXZSBhbHNvIG5lZWQgdG8gbWFrZSBzdXJlIHRo ZSBDR0JpdG1hcENvbnRleHQgd2UgcmV0dXJuIGlzIGluIHRoYXQgc2FtZSBjb2xvcnNwYWNlLgog Ci1zdGF0aWMgYm9vbCBjaGFuZ2VkQ29sb3JQcm9maWxlID0gZmFsc2U7Ci1zdGF0aWMgQ01Qcm9m aWxlTG9jYXRpb24gY3VycmVudENvbG9yUHJvZmlsZUxvY2F0aW9uOwotc3RhdGljIENHQ29sb3JT cGFjZVJlZiBzaGFyZWRDb2xvclNwYWNlOworI2RlZmluZSBQUk9GSUxFX1BBVEggIi9TeXN0ZW0v TGlicmFyeS9Db2xvclN5bmMvUHJvZmlsZXMvR2VuZXJpYyBSR0IgUHJvZmlsZS5pY2MiIC8vIEZJ WE1FOiBTaG91bGQgd2UgYmUgdXNpbmcgIi9TeXN0ZW0vTGlicmFyeS9Db2xvclN5bmMvUHJvZmls ZXMvc1JHQiBQcm9maWxlLmljYyI/CiAKLXZvaWQgcmVzdG9yZUNvbG9yU3BhY2UoaW50IGlnbm9y ZWQpCitzdGF0aWMgQ01Qcm9maWxlTG9jYXRpb24gc0luaXRpYWxQcm9maWxlTG9jYXRpb247IC8v IFRoZSBsb2NUeXBlIGZpZWxkIGlzIGluaXRpYWxpemVkIHRvIDAgd2hpY2ggaXMgdGhlIHNhbWUg YXMgY21Ob1Byb2ZpbGVCYXNlCisKK3ZvaWQgcmVzdG9yZU1haW5EaXNwbGF5Q29sb3JQcm9maWxl KGludCBpZ25vcmVkKQogewogICAgIC8vIFRoaXMgaXMgdXNlZCBhcyBhIHNpZ25hbCBoYW5kbGVy LCBhbmQgdGh1cyB0aGUgY2FsbHMgaW50byBDb2xvclN5bmMgYXJlIHVuc2FmZQogICAgIC8vIEJ1 dCB3ZSBtaWdodCBhcyB3ZWxsIHRyeSB0byByZXN0b3JlIHRoZSB1c2VyJ3MgY29sb3IgcHJvZmls ZSwgd2UncmUgZ29pbmcgZG93biBhbnl3YXkuLi4KLSAgICBpZiAoY2hhbmdlZENvbG9yUHJvZmls ZSkgewotICAgICAgICBDTURldmljZVNjb3BlIHNjb3BlID0geyBrQ0ZQcmVmZXJlbmNlc0N1cnJl bnRVc2VyLCBrQ0ZQcmVmZXJlbmNlc0N1cnJlbnRIb3N0IH07Ci0gICAgICAgIGludCBlcnJvciA9 IENNU2V0RGV2aWNlUHJvZmlsZShjbURpc3BsYXlEZXZpY2VDbGFzcywgY21EZWZhdWx0RGV2aWNl SUQsICZzY29wZSwgY21EZWZhdWx0UHJvZmlsZUlELCAmY3VycmVudENvbG9yUHJvZmlsZUxvY2F0 aW9uKTsKKyAgICBpZiAoc0luaXRpYWxQcm9maWxlTG9jYXRpb24ubG9jVHlwZSAhPSBjbU5vUHJv ZmlsZUJhc2UpIHsKKyAgICAgICAgY29uc3QgQ01EZXZpY2VTY29wZSBzY29wZSA9IHsga0NGUHJl ZmVyZW5jZXNDdXJyZW50VXNlciwga0NGUHJlZmVyZW5jZXNDdXJyZW50SG9zdCB9OworICAgICAg ICBpbnQgZXJyb3IgPSBDTVNldERldmljZVByb2ZpbGUoY21EaXNwbGF5RGV2aWNlQ2xhc3MsIChD TURldmljZUlEKWtDR0RpcmVjdE1haW5EaXNwbGF5LCAmc2NvcGUsIGNtRGVmYXVsdFByb2ZpbGVJ RCwgJnNJbml0aWFsUHJvZmlsZUxvY2F0aW9uKTsKICAgICAgICAgaWYgKGVycm9yKQotICAgICAg ICAgICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gcmV0b3JlIHByZXZpb3VzIGNvbG9yIHBy b2ZpbGUhICBZb3UgbWF5IG5lZWQgdG8gb3BlbiBTeXN0ZW0gUHJlZmVyZW5jZXMgOiBEaXNwbGF5 cyA6IENvbG9yIGFuZCBtYW51YWxseSByZXN0b3JlIHlvdXIgY29sb3Igc2V0dGluZ3MuICAoRXJy b3I6ICVpKSIsIGVycm9yKTsKLSAgICAgICAgY2hhbmdlZENvbG9yUHJvZmlsZSA9IGZhbHNlOwor ICAgICAgICAgICAgZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gcmVzdG9yZSBpbml0aWFsIGNv bG9yIHByb2ZpbGUgZm9yIG1haW4gZGlzcGxheSEgT3BlbiBTeXN0ZW0gUHJlZmVyZW5jZXMgPiBE aXNwbGF5cyA+IENvbG9yIGFuZCBtYW51YWxseSByZS1zZWxlY3QgdGhlIHByb2ZpbGUuICAoRXJy b3I6ICVpKSIsIGVycm9yKTsKKyAgICAgICAgc0luaXRpYWxQcm9maWxlTG9jYXRpb24ubG9jVHlw ZSA9IGNtTm9Qcm9maWxlQmFzZTsKICAgICB9CiB9CiAKLXN0YXRpYyB2b2lkIGZhaWxlZEdldHRp bmdDdXJyZW50UHJvZmlsZShpbnQgZXJyb3IpCit2b2lkIHNldHVwTWFpbkRpc3BsYXlDb2xvclBy b2ZpbGUoKQogewotICAgIGZwcmludGYoc3RkZXJyLCAiRmFpbGVkIHRvIGdldCBjdXJyZW50IGNv bG9yIHByb2ZpbGUuICBJIHdpbGwgbm90IGJlIGFibGUgdG8gcmVzdG9yZSB5b3VyIGN1cnJlbnQg cHJvZmlsZSwgdGh1cyBJJ20gbm90IGNoYW5naW5nIGl0LiAgTWFueSBwaXhlbCB0ZXN0cyBtYXkg ZmFpbCBhcyBhIHJlc3VsdC4gIChFcnJvcjogJWkpXG4iLCBlcnJvcik7Ci19Ci0KLXN0YXRpYyB2 b2lkIHNldERlZmF1bHRDb2xvclByb2ZpbGVUb1JHQigpCi17Ci0gICAgQ01Qcm9maWxlUmVmIGdl bmVyaWNQcm9maWxlID0gKENNUHJvZmlsZVJlZilbW05TQ29sb3JTcGFjZSBnZW5lcmljUkdCQ29s b3JTcGFjZV0gY29sb3JTeW5jUHJvZmlsZV07Ci0gICAgQ01Qcm9maWxlTG9jYXRpb24gZ2VuZXJp Y1Byb2ZpbGVMb2NhdGlvbjsKLSAgICBVSW50MzIgbG9jYXRpb25TaXplID0gc2l6ZW9mKGdlbmVy aWNQcm9maWxlTG9jYXRpb24pOwotICAgIGludCBlcnJvciA9IE5DTUdldFByb2ZpbGVMb2NhdGlv bihnZW5lcmljUHJvZmlsZSwgJmdlbmVyaWNQcm9maWxlTG9jYXRpb24sICZsb2NhdGlvblNpemUp OwotICAgIGlmIChlcnJvcikgewotICAgICAgICBmYWlsZWRHZXR0aW5nQ3VycmVudFByb2ZpbGUo ZXJyb3IpOwotICAgICAgICByZXR1cm47CisgICAgY29uc3QgQ01EZXZpY2VTY29wZSBzY29wZSA9 IHsga0NGUHJlZmVyZW5jZXNDdXJyZW50VXNlciwga0NGUHJlZmVyZW5jZXNDdXJyZW50SG9zdCB9 OworICAgIGludCBlcnJvcjsKKyAgICAKKyAgICBDTVByb2ZpbGVSZWYgcHJvZmlsZSA9IDA7Cisg ICAgZXJyb3IgPSBDTUdldFByb2ZpbGVCeUFWSUQoKENNRGlzcGxheUlEVHlwZSlrQ0dEaXJlY3RN YWluRGlzcGxheSwgJnByb2ZpbGUpOworICAgIGlmICghZXJyb3IpIHsKKyAgICAgICAgVUludDMy IHNpemUgPSBzaXplb2YoQ01Qcm9maWxlTG9jYXRpb24pOworICAgICAgICBlcnJvciA9IE5DTUdl dFByb2ZpbGVMb2NhdGlvbihwcm9maWxlLCAmc0luaXRpYWxQcm9maWxlTG9jYXRpb24sICZzaXpl KTsKKyAgICAgICAgQ01DbG9zZVByb2ZpbGUocHJvZmlsZSk7CiAgICAgfQotCi0gICAgQ01Qcm9m aWxlTG9jYXRpb24gcHJldmlvdXNQcm9maWxlTG9jYXRpb247Ci0gICAgZXJyb3IgPSBDTUdldERl dmljZVByb2ZpbGUoY21EaXNwbGF5RGV2aWNlQ2xhc3MsIGNtRGVmYXVsdERldmljZUlELCBjbURl ZmF1bHRQcm9maWxlSUQsICZwcmV2aW91c1Byb2ZpbGVMb2NhdGlvbik7CiAgICAgaWYgKGVycm9y KSB7Ci0gICAgICAgIGZhaWxlZEdldHRpbmdDdXJyZW50UHJvZmlsZShlcnJvcik7CisgICAgICAg IGZwcmludGYoc3RkZXJyLCAiRmFpbGVkIHRvIHJldHJpZXZlIGN1cnJlbnQgY29sb3IgcHJvZmls ZSBmb3IgbWFpbiBkaXNwbGF5LCB0aHVzIGl0IHdvbid0IGJlIGNoYW5nZWQuICBNYW55IHBpeGVs IHRlc3RzIG1heSBmYWlsIGFzIGEgcmVzdWx0LiAgKEVycm9yOiAlaSkiLCBlcnJvcik7CisgICAg ICAgIHNJbml0aWFsUHJvZmlsZUxvY2F0aW9uLmxvY1R5cGUgPSBjbU5vUHJvZmlsZUJhc2U7CiAg ICAgICAgIHJldHVybjsKICAgICB9CisgICAgCisgICAgQ01Qcm9maWxlTG9jYXRpb24gbG9jYXRp b247CisgICAgbG9jYXRpb24ubG9jVHlwZSA9IGNtRmlsZUJhc2VkUHJvZmlsZTsKKyAgICBOU1VS TCAqdXJsID0gW05TVVJMIGZpbGVVUkxXaXRoUGF0aDpbTlNTdHJpbmcgc3RyaW5nV2l0aFVURjhT dHJpbmc6UFJPRklMRV9QQVRIXV07CisgICAgRlNSZWYgZnNSZWY7CisgICAgaWYgKHVybCAmJiBD RlVSTEdldEZTUmVmKChDRlVSTFJlZil1cmwsICZmc1JlZikpIHsKKyAgICAgICAgZXJyb3IgPSBG U0dldENhdGFsb2dJbmZvKCZmc1JlZiwgMCwgMCwgMCwgJmxvY2F0aW9uLnUuZmlsZUxvYy5zcGVj LCAwKTsKKyAgICAgICAgaWYgKGVycm9yID09IG5vRXJyKQorICAgICAgICBlcnJvciA9IENNU2V0 RGV2aWNlUHJvZmlsZShjbURpc3BsYXlEZXZpY2VDbGFzcywgKENNRGV2aWNlSUQpa0NHRGlyZWN0 TWFpbkRpc3BsYXksICZzY29wZSwgY21EZWZhdWx0UHJvZmlsZUlELCAmbG9jYXRpb24pOworICAg IH0KKyAgICBlbHNlCisgICAgICAgIGVycm9yID0gLTE7CiAKLSAgICBDTVByb2ZpbGVSZWYgcHJl dmlvdXNQcm9maWxlOwotICAgIGVycm9yID0gQ01PcGVuUHJvZmlsZSgmcHJldmlvdXNQcm9maWxl LCAmcHJldmlvdXNQcm9maWxlTG9jYXRpb24pOwogICAgIGlmIChlcnJvcikgewotICAgICAgICBm YWlsZWRHZXR0aW5nQ3VycmVudFByb2ZpbGUoZXJyb3IpOworICAgICAgICBmcHJpbnRmKHN0ZGVy ciwgIkZhaWxlZCB0byBzZXQgY29sb3IgcHJvZmlsZSBmb3IgbWFpbiBkaXNwbGF5ISAgTWFueSBw aXhlbCB0ZXN0cyBtYXkgZmFpbCBhcyBhIHJlc3VsdC4gIChFcnJvcjogJWkpIiwgZXJyb3IpOwor ICAgICAgICBzSW5pdGlhbFByb2ZpbGVMb2NhdGlvbi5sb2NUeXBlID0gY21Ob1Byb2ZpbGVCYXNl OwogICAgICAgICByZXR1cm47CiAgICAgfQotCi0gICAgQ0ZTdHJpbmdSZWYgcHJldmlvdXNQcm9m aWxlTmFtZTsKLSAgICBDRlN0cmluZ1JlZiBnZW5lcmljUHJvZmlsZU5hbWU7Ci0gICAgY2hhciBw cmV2aW91c1Byb2ZpbGVOYW1lU3RyaW5nWzEwMjRdOwotICAgIGNoYXIgZ2VuZXJpY1Byb2ZpbGVO YW1lU3RyaW5nWzEwMjRdOwotICAgIENNQ29weVByb2ZpbGVEZXNjcmlwdGlvblN0cmluZyhwcmV2 aW91c1Byb2ZpbGUsICZwcmV2aW91c1Byb2ZpbGVOYW1lKTsKLSAgICBDTUNvcHlQcm9maWxlRGVz Y3JpcHRpb25TdHJpbmcoZ2VuZXJpY1Byb2ZpbGUsICZnZW5lcmljUHJvZmlsZU5hbWUpOwotICAg IENGU3RyaW5nR2V0Q1N0cmluZyhwcmV2aW91c1Byb2ZpbGVOYW1lLCBwcmV2aW91c1Byb2ZpbGVO YW1lU3RyaW5nLCBzaXplb2YocHJldmlvdXNQcm9maWxlTmFtZVN0cmluZyksIGtDRlN0cmluZ0Vu Y29kaW5nVVRGOCk7Ci0gICAgQ0ZTdHJpbmdHZXRDU3RyaW5nKGdlbmVyaWNQcm9maWxlTmFtZSwg Z2VuZXJpY1Byb2ZpbGVOYW1lU3RyaW5nLCBzaXplb2YocHJldmlvdXNQcm9maWxlTmFtZVN0cmlu ZyksIGtDRlN0cmluZ0VuY29kaW5nVVRGOCk7Ci0gICAgQ0ZSZWxlYXNlKHByZXZpb3VzUHJvZmls ZU5hbWUpOwotICAgIENGUmVsZWFzZShnZW5lcmljUHJvZmlsZU5hbWUpOwotCi0gICAgQ01DbG9z ZVByb2ZpbGUocHJldmlvdXNQcm9maWxlKTsKLQotICAgIGZwcmludGYoc3RkZXJyLCAiXG5cbldB Uk5JTkc6IFRlbXBvcmFyaWx5IGNoYW5naW5nIHlvdXIgc3lzdGVtIGNvbG9yIHByb2ZpbGUgZnJv bSBcIiVzXCIgdG8gXCIlc1wiLlxuIiwgcHJldmlvdXNQcm9maWxlTmFtZVN0cmluZywgZ2VuZXJp Y1Byb2ZpbGVOYW1lU3RyaW5nKTsKKyAgICAKKyAgICAvLyBPdGhlciBzaWduYWxzIGFyZSBoYW5k bGVkIGluIGluc3RhbGxTaWduYWxIYW5kbGVycygpIHdoaWNoIGFsc28gY2FsbHMgcmVzdG9yZU1h aW5EaXNwbGF5Q29sb3JQcm9maWxlKCkKKyAgICBzaWduYWwoU0lHSU5ULCByZXN0b3JlTWFpbkRp c3BsYXlDb2xvclByb2ZpbGUpOworICAgIHNpZ25hbChTSUdIVVAsIHJlc3RvcmVNYWluRGlzcGxh eUNvbG9yUHJvZmlsZSk7CisgICAgc2lnbmFsKFNJR1RFUk0sIHJlc3RvcmVNYWluRGlzcGxheUNv bG9yUHJvZmlsZSk7CisgICAgCisgICAgZnByaW50ZihzdGRlcnIsICJcblxuV0FSTklORzogVGVt cG9yYXJpbHkgY2hhbmdpbmcgdGhlIG1haW4gZGlzcGxheSBjb2xvciBwcm9maWxlIHRvIFwiJXNc IjogdGhlIGNvbG9ycyBvbiB5b3VyIHNjcmVlbiB3aWxsIGNoYW5nZSBmb3IgdGhlIGR1cmF0aW9u IG9mIHRoZSB0ZXN0aW5nLlxuIiwgUFJPRklMRV9QQVRIKTsKICAgICBmcHJpbnRmKHN0ZGVyciwg IlRoaXMgYWxsb3dzIHRoZSBXZWJLaXQgcGl4ZWwtYmFzZWQgcmVncmVzc2lvbiB0ZXN0cyB0byBo YXZlIGNvbnNpc3RlbnQgY29sb3IgdmFsdWVzIGFjcm9zcyBhbGwgbWFjaGluZXMuXG4iKTsKLSAg ICBmcHJpbnRmKHN0ZGVyciwgIlRoZSBjb2xvcnMgb24geW91ciBzY3JlZW4gd2lsbCBjaGFuZ2Ug Zm9yIHRoZSBkdXJhdGlvbiBvZiB0aGUgdGVzdGluZy5cblxuIik7Ci0KLSAgICBDTURldmljZVNj b3BlIHNjb3BlID0geyBrQ0ZQcmVmZXJlbmNlc0N1cnJlbnRVc2VyLCBrQ0ZQcmVmZXJlbmNlc0N1 cnJlbnRIb3N0IH07Ci0gICAgaWYgKChlcnJvciA9IENNU2V0RGV2aWNlUHJvZmlsZShjbURpc3Bs YXlEZXZpY2VDbGFzcywgY21EZWZhdWx0RGV2aWNlSUQsICZzY29wZSwgY21EZWZhdWx0UHJvZmls ZUlELCAmZ2VuZXJpY1Byb2ZpbGVMb2NhdGlvbikpKSB7Ci0gICAgICAgIGZwcmludGYoc3RkZXJy LCAiRmFpbGVkIHRvIHNldCBjb2xvciBwcm9maWxlIHRvIFwiJXNcIiEgTWFueSBwaXhlbCB0ZXN0 cyB3aWxsIGZhaWwgYXMgYSByZXN1bHQuICAoRXJyb3I6ICVpKSIsCi0gICAgICAgICAgICBnZW5l cmljUHJvZmlsZU5hbWVTdHJpbmcsIGVycm9yKTsKLSAgICB9IGVsc2UgewotICAgICAgICBjdXJy ZW50Q29sb3JQcm9maWxlTG9jYXRpb24gPSBwcmV2aW91c1Byb2ZpbGVMb2NhdGlvbjsKLSAgICAg ICAgY2hhbmdlZENvbG9yUHJvZmlsZSA9IHRydWU7Ci0gICAgICAgIHNpZ25hbChTSUdJTlQsIHJl c3RvcmVDb2xvclNwYWNlKTsKLSAgICAgICAgc2lnbmFsKFNJR0hVUCwgcmVzdG9yZUNvbG9yU3Bh Y2UpOwotICAgICAgICBzaWduYWwoU0lHVEVSTSwgcmVzdG9yZUNvbG9yU3BhY2UpOwotICAgIH0K IH0KIAotdm9pZCBpbml0aWFsaXplQ29sb3JTcGFjZUFuZFNjcmVlQnVmZmVyRm9yUGl4ZWxUZXN0 cygpCi17Ci0gICAgc2V0RGVmYXVsdENvbG9yUHJvZmlsZVRvUkdCKCk7Ci0gICAgc2NyZWVuQ2Fw dHVyZUJ1ZmZlciA9ICh1bnNpZ25lZCBjaGFyICopbWFsbG9jKG1heFZpZXdIZWlnaHQgKiBtYXhW aWV3V2lkdGggKiA0KTsKLSAgICBzaGFyZWRDb2xvclNwYWNlID0gQ0dDb2xvclNwYWNlQ3JlYXRl RGV2aWNlUkdCKCk7Ci19Ci0KLS8vIERlY2xhcmVkIGluIFBpeGVsRHVtcFN1cHBvcnRDRy5oCi0K LVJldGFpblB0cjxDR0NvbnRleHRSZWY+IGdldEJpdG1hcENvbnRleHRGcm9tV2ViVmlldygpCitQ YXNzUmVmUHRyPEJpdG1hcENvbnRleHQ+IGNyZWF0ZUJpdG1hcENvbnRleHRGcm9tV2ViVmlldyhi b29sIG9uc2NyZWVuLCBib29sIGluY3JlbWVudGFsUmVwYWludCwgYm9vbCBzd2VlcEhvcml6b250 YWxseSwgYm9vbCBkcmF3U2VsZWN0aW9uUmVjdCkKIHsKLSAgICBOU1NpemUgd2ViVmlld1NpemUg PSBbW21haW5GcmFtZSB3ZWJWaWV3XSBmcmFtZV0uc2l6ZTsKLSAgICByZXR1cm4gUmV0YWluUHRy PENHQ29udGV4dFJlZj4oQWRvcHRDRiwgQ0dCaXRtYXBDb250ZXh0Q3JlYXRlKHNjcmVlbkNhcHR1 cmVCdWZmZXIsIHN0YXRpY19jYXN0PHNpemVfdD4od2ViVmlld1NpemUud2lkdGgpLCBzdGF0aWNf Y2FzdDxzaXplX3Q+KHdlYlZpZXdTaXplLmhlaWdodCksIDgsIHN0YXRpY19jYXN0PHNpemVfdD4o d2ViVmlld1NpemUud2lkdGgpICogNCwgc2hhcmVkQ29sb3JTcGFjZSwga0NHQml0bWFwQnl0ZU9y ZGVyMzJIb3N0IHwga0NHSW1hZ2VBbHBoYVByZW11bHRpcGxpZWRMYXN0KSk7Ci19Ci0KLXZvaWQg cGFpbnRXZWJWaWV3KENHQ29udGV4dFJlZiBjb250ZXh0KQotewotICAgIFJldGFpblB0cjxOU0dy YXBoaWNzQ29udGV4dD4gc2F2ZWRDb250ZXh0ID0gW05TR3JhcGhpY3NDb250ZXh0IGN1cnJlbnRD b250ZXh0XTsKLQotICAgIE5TR3JhcGhpY3NDb250ZXh0KiBuc0NvbnRleHQgPSBbTlNHcmFwaGlj c0NvbnRleHQgZ3JhcGhpY3NDb250ZXh0V2l0aEdyYXBoaWNzUG9ydDpjb250ZXh0IGZsaXBwZWQ6 Tk9dOwotICAgIFtOU0dyYXBoaWNzQ29udGV4dCBzZXRDdXJyZW50Q29udGV4dDpuc0NvbnRleHRd OwotCiAgICAgV2ViVmlldyogdmlldyA9IFttYWluRnJhbWUgd2ViVmlld107Ci0gICAgW3ZpZXcg ZGlzcGxheUlmTmVlZGVkXTsKLSAgICBbdmlldyBsb2NrRm9jdXNdOwotICAgIE5TQml0bWFwSW1h Z2VSZXAgKmltYWdlUmVwID0gW1tOU0JpdG1hcEltYWdlUmVwIGFsbG9jXSBpbml0V2l0aEZvY3Vz ZWRWaWV3UmVjdDpbdmlldyBmcmFtZV1dOwotICAgIFt2aWV3IHVubG9ja0ZvY3VzXTsKLSAgICBb aW1hZ2VSZXAgZHJhd107Ci0gICAgW2ltYWdlUmVwIHJlbGVhc2VdOwotCi0gICAgW05TR3JhcGhp Y3NDb250ZXh0IHNldEN1cnJlbnRDb250ZXh0OnNhdmVkQ29udGV4dC5nZXQoKV07Ci19Ci0KLXZv aWQgcmVwYWludFdlYlZpZXcoQ0dDb250ZXh0UmVmIGNvbnRleHQsIGJvb2wgaG9yaXpvbnRhbCkK LXsKLSAgICBSZXRhaW5QdHI8TlNHcmFwaGljc0NvbnRleHQ+IHNhdmVkQ29udGV4dCA9IFtOU0dy YXBoaWNzQ29udGV4dCBjdXJyZW50Q29udGV4dF07Ci0KLSAgICBOU0dyYXBoaWNzQ29udGV4dCog bnNDb250ZXh0ID0gW05TR3JhcGhpY3NDb250ZXh0IGdyYXBoaWNzQ29udGV4dFdpdGhHcmFwaGlj c1BvcnQ6Y29udGV4dCBmbGlwcGVkOk5PXTsKLSAgICBbTlNHcmFwaGljc0NvbnRleHQgc2V0Q3Vy cmVudENvbnRleHQ6bnNDb250ZXh0XTsKLQotICAgIFdlYlZpZXcgKnZpZXcgPSBbbWFpbkZyYW1l IHdlYlZpZXddOwogICAgIE5TU2l6ZSB3ZWJWaWV3U2l6ZSA9IFt2aWV3IGZyYW1lXS5zaXplOwor ICAgIHNpemVfdCBwaXhlbHNXaWRlID0gc3RhdGljX2Nhc3Q8c2l6ZV90Pih3ZWJWaWV3U2l6ZS53 aWR0aCk7CisgICAgc2l6ZV90IHBpeGVsc0hpZ2ggPSBzdGF0aWNfY2FzdDxzaXplX3Q+KHdlYlZp ZXdTaXplLmhlaWdodCk7CisgICAgc2l6ZV90IHJvd0J5dGVzID0gKDQgKiBwaXhlbHNXaWRlICsg NjMpICYgfjYzOyAvLyBVc2UgYSBtdWx0aXBsZSBvZiA2NCBieXRlcyB0byBpbXByb3ZlIENHIHBl cmZvcm1hbmNlCisKKyAgICB2b2lkICpidWZmZXIgPSBjYWxsb2MocGl4ZWxzSGlnaCwgcm93Qnl0 ZXMpOworICAgIGlmICghYnVmZmVyKQorICAgICAgICByZXR1cm4gMDsKKyAgICAKKyAgICBzdGF0 aWMgQ0dDb2xvclNwYWNlUmVmIGNvbG9yU3BhY2UgPSAwOworICAgIGlmICghY29sb3JTcGFjZSkg eworICAgICAgICBDTVByb2ZpbGVMb2NhdGlvbiBsb2NhdGlvbjsKKyAgICAgICAgbG9jYXRpb24u bG9jVHlwZSA9IGNtRmlsZUJhc2VkUHJvZmlsZTsKKyAgICAgICAgTlNVUkwgKnVybCA9IFtOU1VS TCBmaWxlVVJMV2l0aFBhdGg6W05TU3RyaW5nIHN0cmluZ1dpdGhVVEY4U3RyaW5nOlBST0ZJTEVf UEFUSF1dOworICAgICAgICBGU1JlZiBmc1JlZjsKKyAgICAgICAgaWYgKHVybCAmJiBDRlVSTEdl dEZTUmVmKChDRlVSTFJlZil1cmwsICZmc1JlZikpIHsKKyAgICAgICAgICAgIGlmIChGU0dldENh dGFsb2dJbmZvKCZmc1JlZiwgMCwgMCwgMCwgJmxvY2F0aW9uLnUuZmlsZUxvYy5zcGVjLCAwKSA9 PSBub0VycikgeworICAgICAgICAgICAgICAgIENNUHJvZmlsZVJlZiBwcm9maWxlOworICAgICAg ICAgICAgICAgIGlmIChDTU9wZW5Qcm9maWxlKCZwcm9maWxlLCAmbG9jYXRpb24pID09IG5vRXJy KSB7CisgICAgICAgICAgICAgICAgICAgIGNvbG9yU3BhY2UgPSBDR0NvbG9yU3BhY2VDcmVhdGVX aXRoUGxhdGZvcm1Db2xvclNwYWNlKHByb2ZpbGUpOworICAgICAgICAgICAgICAgICAgICBDTUNs b3NlUHJvZmlsZShwcm9maWxlKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9Cisg ICAgICAgIH0KKyAgICB9CisgICAgCisgICAgQ0dDb250ZXh0UmVmIGNvbnRleHQgPSBDR0JpdG1h cENvbnRleHRDcmVhdGUoYnVmZmVyLCBwaXhlbHNXaWRlLCBwaXhlbHNIaWdoLCA4LCByb3dCeXRl cywgY29sb3JTcGFjZSwga0NHSW1hZ2VBbHBoYVByZW11bHRpcGxpZWRGaXJzdCB8IGtDR0JpdG1h cEJ5dGVPcmRlcjMySG9zdCk7IC8vIFVzZSBBUkdCOCBvbiBQUEMgb3IgQkdSQTggb24gWDg2IHRv IGltcHJvdmUgQ0cgcGVyZm9ybWFuY2UKKyAgICBpZiAoIWNvbnRleHQpIHsKKyAgICAgICAgZnJl ZShidWZmZXIpOworICAgICAgICByZXR1cm4gMDsKKyAgICB9CiAKLSAgICBpZiAoaG9yaXpvbnRh bCkgewotICAgICAgICBmb3IgKE5TUmVjdCBjb2x1bW4gPSBOU01ha2VSZWN0KDAsIDAsIDEsIHdl YlZpZXdTaXplLmhlaWdodCk7IGNvbHVtbi5vcmlnaW4ueCA8IHdlYlZpZXdTaXplLndpZHRoOyBj b2x1bW4ub3JpZ2luLngrKykKLSAgICAgICAgICAgIFt2aWV3IGRpc3BsYXlSZWN0SWdub3JpbmdP cGFjaXR5OmNvbHVtbiBpbkNvbnRleHQ6bnNDb250ZXh0XTsKKyAgICAvLyBUaGUgQml0bWFwQ29u dGV4dCBrZWVwcyB0aGUgQ0dDb250ZXh0UmVmIGFuZCB0aGUgcGl4ZWwgYnVmZmVyIGFsaXZlCisg ICAgUmVmUHRyPEJpdG1hcENvbnRleHQ+IGJpdG1hcENvbnRleHQgPSBCaXRtYXBDb250ZXh0Ojpj cmVhdGVCeUFkb3B0aW5nQml0bWFwQW5kQ29udGV4dChidWZmZXIsIGNvbnRleHQpOworICAgIAor ICAgIE5TR3JhcGhpY3NDb250ZXh0ICpuc0NvbnRleHQgPSBbTlNHcmFwaGljc0NvbnRleHQgZ3Jh cGhpY3NDb250ZXh0V2l0aEdyYXBoaWNzUG9ydDpjb250ZXh0IGZsaXBwZWQ6Tk9dOworICAgIEFT U0VSVChuc0NvbnRleHQpOworICAgIAorICAgIGlmIChpbmNyZW1lbnRhbFJlcGFpbnQpIHsKKyAg ICAgICAgaWYgKHN3ZWVwSG9yaXpvbnRhbGx5KSB7CisgICAgICAgICAgICBmb3IgKE5TUmVjdCBj b2x1bW4gPSBOU01ha2VSZWN0KDAsIDAsIDEsIHdlYlZpZXdTaXplLmhlaWdodCk7IGNvbHVtbi5v cmlnaW4ueCA8IHdlYlZpZXdTaXplLndpZHRoOyBjb2x1bW4ub3JpZ2luLngrKykKKyAgICAgICAg ICAgICAgICBbdmlldyBkaXNwbGF5UmVjdElnbm9yaW5nT3BhY2l0eTpjb2x1bW4gaW5Db250ZXh0 Om5zQ29udGV4dF07CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICBmb3IgKE5TUmVjdCBs aW5lID0gTlNNYWtlUmVjdCgwLCAwLCB3ZWJWaWV3U2l6ZS53aWR0aCwgMSk7IGxpbmUub3JpZ2lu LnkgPCB3ZWJWaWV3U2l6ZS5oZWlnaHQ7IGxpbmUub3JpZ2luLnkrKykKKyAgICAgICAgICAgICAg ICBbdmlldyBkaXNwbGF5UmVjdElnbm9yaW5nT3BhY2l0eTpsaW5lIGluQ29udGV4dDpuc0NvbnRl eHRdOworICAgICAgICB9CiAgICAgfSBlbHNlIHsKLSAgICAgICAgZm9yIChOU1JlY3QgbGluZSA9 IE5TTWFrZVJlY3QoMCwgMCwgd2ViVmlld1NpemUud2lkdGgsIDEpOyBsaW5lLm9yaWdpbi55IDwg d2ViVmlld1NpemUuaGVpZ2h0OyBsaW5lLm9yaWdpbi55KyspCi0gICAgICAgICAgICBbdmlldyBk aXNwbGF5UmVjdElnbm9yaW5nT3BhY2l0eTpsaW5lIGluQ29udGV4dDpuc0NvbnRleHRdOworICAg ICAgICBpZiAob25zY3JlZW4pIHsKKyNpZmRlZiBCVUlMRElOR19PTl9MRU9QQVJECisgICAgICAg ICAgICAvLyBBc2sgdGhlIHdpbmRvdyBzZXJ2ZXIgdG8gcHJvdmlkZSB1cyBhIGNvbXBvc2l0ZWQg dmVyc2lvbiBvZiB0aGUgKnJlYWwqIHdpbmRvdyBjb250ZW50IGluY2x1ZGluZyBzdXJmYWNlcyAo aS5lLiBPcGVuR0wgY29udGVudCkKKyAgICAgICAgICAgIC8vIE5vdGUgdGhhdCB0aGUgcmV0dXJu ZWQgaW1hZ2UgbWlnaHQgZGlmZmVyIHZlcnkgc2xpZ2h0bHkgZnJvbSB0aGUgd2luZG93IGJhY2tp bmcgYmVjYXVzZSBvZiBkaXRoZXJpbmcgYXJ0aWZhY3RzIGluIHRoZSB3aW5kb3cgc2VydmVyIGNv bXBvc2l0b3IKKyAgICAgICAgICAgIAorICAgICAgICAgICAgQ0dJbWFnZVJlZiBpbWFnZSA9IENH V2luZG93TGlzdENyZWF0ZUltYWdlKENHUmVjdE51bGwsIGtDR1dpbmRvd0xpc3RPcHRpb25JbmNs dWRpbmdXaW5kb3csIFtbdmlldyB3aW5kb3ddIHdpbmRvd051bWJlcl0sIGtDR1dpbmRvd0ltYWdl Qm91bmRzSWdub3JlRnJhbWluZyB8IGtDR1dpbmRvd0ltYWdlU2hvdWxkQmVPcGFxdWUpOworICAg ICAgICAgICAgQ0dDb250ZXh0RHJhd0ltYWdlKGNvbnRleHQsIENHUmVjdE1ha2UoMCwgMCwgQ0dJ bWFnZUdldFdpZHRoKGltYWdlKSwgQ0dJbWFnZUdldEhlaWdodChpbWFnZSkpLCBpbWFnZSk7Cisg ICAgICAgICAgICBDR0ltYWdlUmVsZWFzZShpbWFnZSk7CisjZWxzZQorICAgICAgICAgICAgLy8g T24gMTAuNCBhbmQgZWFybGllciwgd2UgaGF2ZSB0byBtb3ZlIHRoZSB3aW5kb3cgdGVtcG9yYXJp bHkgIm9uc2NyZWVuIiBhbmQgcmVhZCBkaXJlY3RseSBmcm9tIHRoZSBkaXNwbGF5IGZyYW1lYnVm ZmVyIHVzaW5nIE9wZW5HTAorICAgICAgICAgICAgLy8gSW4gdGhpcyBjb2RlIHBhdGgsIHdlIG5l ZWQgdG8gZW5zdXJlIHRoZSB3aW5kb3cgaXMgYWJvdmUgYW55IG90aGVyIHdpbmRvdyBvciBjYXB0 dXJlZCByZXN1bHQgd2lsbCBiZSBjb3JydXB0ZWQKKyAgICAgICAgICAgIAorICAgICAgICAgICAg TlNXaW5kb3cgKndpbmRvdyA9IFt2aWV3IHdpbmRvd107CisgICAgICAgICAgICBpbnQgb2xkTGV2 ZWwgPSBbd2luZG93IGxldmVsXTsKKyAgICAgICAgICAgIE5TUmVjdCBvbGRGcmFtZSA9IFt3aW5k b3cgZnJhbWVdOworICAgICAgICAgICAgCisgICAgICAgICAgICBOU1JlY3QgbmV3RnJhbWUgPSBb W1tOU1NjcmVlbiBzY3JlZW5zXSBvYmplY3RBdEluZGV4OjBdIGZyYW1lXTsKKyAgICAgICAgICAg IG5ld0ZyYW1lID0gTlNNYWtlUmVjdChuZXdGcmFtZS5vcmlnaW4ueCArIChuZXdGcmFtZS5zaXpl LndpZHRoIC0gb2xkRnJhbWUuc2l6ZS53aWR0aCkgLyAyLCBuZXdGcmFtZS5vcmlnaW4ueSArIChu ZXdGcmFtZS5zaXplLmhlaWdodCAtIG9sZEZyYW1lLnNpemUuaGVpZ2h0KSAvIDIsIG9sZEZyYW1l LnNpemUud2lkdGgsIG9sZEZyYW1lLnNpemUuaGVpZ2h0KTsKKyAgICAgICAgICAgIFt3aW5kb3cg c2V0TGV2ZWw6TlNTY3JlZW5TYXZlcldpbmRvd0xldmVsXTsKKyAgICAgICAgICAgIFt3aW5kb3cg c2V0RnJhbWU6bmV3RnJhbWUgZGlzcGxheTpOTyBhbmltYXRlOk5PXTsKKyAgICAgICAgICAgIAor ICAgICAgICAgICAgQ0dSZWN0IHJlY3QgPSBDR1JlY3RNYWtlKG5ld0ZyYW1lLm9yaWdpbi54LCBu ZXdGcmFtZS5vcmlnaW4ueSwgd2ViVmlld1NpemUud2lkdGgsIHdlYlZpZXdTaXplLmhlaWdodCk7 CisgICAgICAgICAgICBDR0RpcmVjdERpc3BsYXlJRCBkaXNwbGF5SUQ7CisgICAgICAgICAgICBD R0Rpc3BsYXlDb3VudCBjb3VudDsKKyAgICAgICAgICAgIGlmIChDR0dldERpc3BsYXlzV2l0aFJl Y3QocmVjdCwgMSwgJmRpc3BsYXlJRCwgJmNvdW50KSA9PSBrQ0dFcnJvclN1Y2Nlc3MpIHsKKyAg ICAgICAgICAgICAgICBDR1JlY3QgYm91bmRzID0gQ0dEaXNwbGF5Qm91bmRzKGRpc3BsYXlJRCk7 CisgICAgICAgICAgICAgICAgcmVjdC5vcmlnaW4ueCAtPSBib3VuZHMub3JpZ2luLng7CisgICAg ICAgICAgICAgICAgcmVjdC5vcmlnaW4ueSAtPSBib3VuZHMub3JpZ2luLnk7CisgICAgICAgICAg ICAgICAgCisgICAgICAgICAgICAgICAgQ0dMUGl4ZWxGb3JtYXRBdHRyaWJ1dGUgYXR0cmlidXRl c1tdID0ge2tDR0xQRkFBY2NlbGVyYXRlZCwga0NHTFBGQU5vUmVjb3ZlcnksIGtDR0xQRkFGdWxs U2NyZWVuLCBrQ0dMUEZBRGlzcGxheU1hc2ssIChDR0xQaXhlbEZvcm1hdEF0dHJpYnV0ZSlDR0Rp c3BsYXlJRFRvT3BlbkdMRGlzcGxheU1hc2soZGlzcGxheUlEKSwgKENHTFBpeGVsRm9ybWF0QXR0 cmlidXRlKTB9OworICAgICAgICAgICAgICAgIENHTFBpeGVsRm9ybWF0T2JqIHBpeGVsRm9ybWF0 OworICAgICAgICAgICAgICAgIEdMaW50IG51bTsKKyAgICAgICAgICAgICAgICBpZiAoQ0dMQ2hv b3NlUGl4ZWxGb3JtYXQoYXR0cmlidXRlcywgJnBpeGVsRm9ybWF0LCAmbnVtKSA9PSBrQ0dMTm9F cnJvcikgeworICAgICAgICAgICAgICAgICAgICBDR0xDb250ZXh0T2JqIGNnbF9jdHg7CisgICAg ICAgICAgICAgICAgICAgIGlmIChDR0xDcmVhdGVDb250ZXh0KHBpeGVsRm9ybWF0LCAwLCAmY2ds X2N0eCkgPT0ga0NHTE5vRXJyb3IpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGlmIChDR0xT ZXRGdWxsU2NyZWVuKGNnbF9jdHgpID09IGtDR0xOb0Vycm9yKSB7CisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgdm9pZCAqZmxpcEJ1ZmZlciA9IGNhbGxvYyhwaXhlbHNIaWdoLCByb3dCeXRl cyk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgaWYgKGZsaXBCdWZmZXIpIHsKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2xQaXhlbFN0b3JlaShHTF9QQUNLX1JPV19MRU5H VEgsIHJvd0J5dGVzIC8gNCk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdsUGl4 ZWxTdG9yZWkoR0xfUEFDS19BTElHTk1FTlQsIDQpOworI2lmIF9fQklHX0VORElBTl9fCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdsUmVhZFBpeGVscyhyZWN0Lm9yaWdpbi54LCBy ZWN0Lm9yaWdpbi55LCByZWN0LnNpemUud2lkdGgsIHJlY3Quc2l6ZS5oZWlnaHQsIEdMX1JHQkEs IEdMX1VOU0lHTkVEX0lOVF84XzhfOF84LCBmbGlwQnVmZmVyKTsKKyNlbHNlCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGdsUmVhZFBpeGVscyhyZWN0Lm9yaWdpbi54LCByZWN0Lm9y aWdpbi55LCByZWN0LnNpemUud2lkdGgsIHJlY3Quc2l6ZS5oZWlnaHQsIEdMX1JHQkEsIEdMX1VO U0lHTkVEX0lOVF84XzhfOF84X1JFViwgZmxpcEJ1ZmZlcik7CisjZW5kaWYKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgaWYgKCFnbEdldEVycm9yKCkpIHsKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGZvcihzaXplX3QgaSA9IDA7IGkgPCBwaXhlbHNIaWdoOyAr K2kpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBiY29weSgoY2hhciopZmxp cEJ1ZmZlciArIHJvd0J5dGVzICogaSwgKGNoYXIqKWJ1ZmZlciArIHJvd0J5dGVzICogKHBpeGVs c0hpZ2ggLSBpIC0gMSksIHBpeGVsc1dpZGUgKiA0KTsKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgZnJlZShmbGlwQnVmZmVyKTsKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAg ICAgICAgICBDR0xEZXN0cm95Q29udGV4dChjZ2xfY3R4KTsKKyAgICAgICAgICAgICAgICAgICAg fQorICAgICAgICAgICAgICAgICAgICBDR0xEZXN0cm95UGl4ZWxGb3JtYXQocGl4ZWxGb3JtYXQp OworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIAorICAgICAg ICAgICAgW3dpbmRvdyBzZXRGcmFtZTpvbGRGcmFtZSBkaXNwbGF5Ok5PIGFuaW1hdGU6Tk9dOwor ICAgICAgICAgICAgW3dpbmRvdyBzZXRMZXZlbDpvbGRMZXZlbF07CisjZW5kaWYKKyAgICAgICAg fSBlbHNlIHsKKyAgICAgICAgICAgIC8vIEdyYWIgZGlyZWN0bHkgdGhlIGNvbnRlbnRzIG9mIHRo ZSB3aW5kb3cgYmFja2luZyBidWZmZXIgKHRoaXMgaWdub3JlcyBhbnkgc3VyZmFjZXMgb24gdGhl IHdpbmRvdykKKyAgICAgICAgICAgIC8vIEZJWE1FOiBUaGlzIHBhdGggaXMgc3Vib3B0aW1hbDog ZGF0YSBpcyByZWFkIGZyb20gd2luZG93IGJhY2tpbmcgc3RvcmUsIGNvbnZlcnRlZCB0byBSR0I4 IHRoZW4gZHJhd24gYWdhaW4gaW50byBhbiBSR0JBOCBiaXRtYXAKKyAgICAgICAgICAgIAorICAg ICAgICAgICAgW3ZpZXcgZGlzcGxheUlmTmVlZGVkXTsKKyAgICAgICAgICAgIFt2aWV3IGxvY2tG b2N1c107CisgICAgICAgICAgICBOU0JpdG1hcEltYWdlUmVwICppbWFnZVJlcCA9IFtbW05TQml0 bWFwSW1hZ2VSZXAgYWxsb2NdIGluaXRXaXRoRm9jdXNlZFZpZXdSZWN0Olt2aWV3IGZyYW1lXV0g YXV0b3JlbGVhc2VdOworICAgICAgICAgICAgW3ZpZXcgdW5sb2NrRm9jdXNdOworCisgICAgICAg ICAgICBSZXRhaW5QdHI8TlNHcmFwaGljc0NvbnRleHQ+IHNhdmVkQ29udGV4dCA9IFtOU0dyYXBo aWNzQ29udGV4dCBjdXJyZW50Q29udGV4dF07CisgICAgICAgICAgICBbTlNHcmFwaGljc0NvbnRl eHQgc2V0Q3VycmVudENvbnRleHQ6bnNDb250ZXh0XTsKKyAgICAgICAgICAgIFtpbWFnZVJlcCBk cmF3XTsKKyAgICAgICAgICAgIFtOU0dyYXBoaWNzQ29udGV4dCBzZXRDdXJyZW50Q29udGV4dDpz YXZlZENvbnRleHQuZ2V0KCldOworICAgICAgICB9CiAgICAgfQogCi0gICAgW05TR3JhcGhpY3ND b250ZXh0IHNldEN1cnJlbnRDb250ZXh0OnNhdmVkQ29udGV4dC5nZXQoKV07Ci19Ci0KLUNHUmVj dCBnZXRTZWxlY3Rpb25SZWN0KCkKLXsKLSAgICBOU1ZpZXcgKmRvY3VtZW50VmlldyA9IFtbbWFp bkZyYW1lIGZyYW1lVmlld10gZG9jdW1lbnRWaWV3XTsKLSAgICBpZiAoW2RvY3VtZW50VmlldyBj b25mb3Jtc1RvUHJvdG9jb2w6QHByb3RvY29sKFdlYkRvY3VtZW50U2VsZWN0aW9uKV0pIHsKKyAg ICBpZiAoZHJhd1NlbGVjdGlvblJlY3QpIHsKKyAgICAgICAgTlNWaWV3ICpkb2N1bWVudFZpZXcg PSBbW21haW5GcmFtZSBmcmFtZVZpZXddIGRvY3VtZW50Vmlld107CisgICAgICAgIEFTU0VSVChb ZG9jdW1lbnRWaWV3IGNvbmZvcm1zVG9Qcm90b2NvbDpAcHJvdG9jb2woV2ViRG9jdW1lbnRTZWxl Y3Rpb24pXSk7CiAgICAgICAgIE5TUmVjdCByZWN0ID0gW2RvY3VtZW50VmlldyBjb252ZXJ0UmVj dDpbKGlkIDxXZWJEb2N1bWVudFNlbGVjdGlvbj4pZG9jdW1lbnRWaWV3IHNlbGVjdGlvblJlY3Rd IGZyb21WaWV3Om5pbF07Ci0gICAgICAgIHJldHVybiBDR1JlY3RNYWtlKHJlY3Qub3JpZ2luLngs IHJlY3Qub3JpZ2luLnksIHJlY3Quc2l6ZS53aWR0aCwgcmVjdC5zaXplLmhlaWdodCk7CisgICAg ICAgIENHQ29udGV4dFNhdmVHU3RhdGUoY29udGV4dCk7CisgICAgICAgIENHQ29udGV4dFNldExp bmVXaWR0aChjb250ZXh0LCAxLjApOworICAgICAgICBDR0NvbnRleHRTZXRSR0JTdHJva2VDb2xv cihjb250ZXh0LCAxLjAsIDAuMCwgMC4wLCAxLjApOworICAgICAgICBDR0NvbnRleHRTdHJva2VS ZWN0KGNvbnRleHQsIENHUmVjdE1ha2UocmVjdC5vcmlnaW4ueCwgcmVjdC5vcmlnaW4ueSwgcmVj dC5zaXplLndpZHRoLCByZWN0LnNpemUuaGVpZ2h0KSk7CisgICAgICAgIENHQ29udGV4dFJlc3Rv cmVHU3RhdGUoY29udGV4dCk7CiAgICAgfQotCi0gICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7Ci0g ICAgcmV0dXJuIENHUmVjdFplcm87CisgICAgCisgICAgcmV0dXJuIGJpdG1hcENvbnRleHQucmVs ZWFzZSgpOwogfQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1 bXBSZW5kZXJUcmVlLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVu ZGVyVHJlZS5jcHAKaW5kZXggMWNlMzFkZS4uNzQyYmQ3ZiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcAorKysgYi9XZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCkBAIC0zOCwyNSArMzgsMjYg QEAKICNpbmNsdWRlICJVSURlbGVnYXRlLmgiCiAjaW5jbHVkZSAiV29ya1F1ZXVlSXRlbS5oIgog I2luY2x1ZGUgIldvcmtRdWV1ZS5oIgorCisjaW5jbHVkZSA8ZmNudGwuaD4KKyNpbmNsdWRlIDxp by5oPgorI2luY2x1ZGUgPG1hdGguaD4KKyNpbmNsdWRlIDxwdGhyZWFkLmg+CisjaW5jbHVkZSA8 c2hsd2FwaS5oPgorI2luY2x1ZGUgPHN0ZGlvLmg+CisjaW5jbHVkZSA8c3RyaW5nLmg+CisjaW5j bHVkZSA8dGNoYXIuaD4KICNpbmNsdWRlIDx3dGYvUmV0YWluUHRyLmg+CiAjaW5jbHVkZSA8d3Rm L1ZlY3Rvci5oPgotI2luY2x1ZGUgPFdlYkNvcmUvQ09NUHRyLmg+Ci0jaW5jbHVkZSA8Q29yZUZv dW5kYXRpb24vQ29yZUZvdW5kYXRpb24uaD4KKyNpbmNsdWRlIDx3aW5kb3dzLmg+CiAjaW5jbHVk ZSA8Q0ZOZXR3b3JrL0NGVVJMQ2FjaGVQcml2Lmg+CisjaW5jbHVkZSA8Q29yZUZvdW5kYXRpb24v Q29yZUZvdW5kYXRpb24uaD4KICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29y ZS5oPgotI2luY2x1ZGUgPG1hdGguaD4KLSNpbmNsdWRlIDxwdGhyZWFkLmg+Ci0jaW5jbHVkZSA8 c3RyaW5nPgotI2luY2x1ZGUgPHRjaGFyLmg+CisjaW5jbHVkZSA8V2ViQ29yZS9DT01QdHIuaD4K ICNpbmNsdWRlIDxXZWJLaXQvRm9yRWFjaENvQ2xhc3MuaD4KICNpbmNsdWRlIDxXZWJLaXQvV2Vi S2l0Lmg+Ci0jaW5jbHVkZSA8ZmNudGwuaD4KLSNpbmNsdWRlIDxpby5oPgotI2luY2x1ZGUgPHdp bmRvd3MuaD4KLSNpbmNsdWRlIDxzdGRpby5oPgotI2luY2x1ZGUgPHNobHdhcGkuaD4KIAotdXNp bmcgc3RkOjp3c3RyaW5nOwordXNpbmcgbmFtZXNwYWNlIHN0ZDsKIAogI2lmbmRlZiBOREVCVUcK IGNvbnN0IExQV1NUUiBUZXN0UGx1Z2luRGlyID0gTCJUZXN0TmV0c2NhcGVQbHVnaW5fRGVidWci OwpAQCAtNzgsOCArNzksNiBAQCBzdGF0aWMgYm9vbCB0aHJlYWRlZCA9IGZhbHNlOwogc3RhdGlj IGJvb2wgZm9yY2VDb21wbGV4VGV4dCA9IGZhbHNlOwogc3RhdGljIFJldGFpblB0cjxDRlN0cmlu Z1JlZj4gcGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb247CiAKLXN0YXRpYyBjb25zdCBj aGFyKiBjdXJyZW50VGVzdDsKLQogdm9sYXRpbGUgYm9vbCBkb25lOwogLy8gVGhpcyBpcyB0aGUg dG9wbW9zdCBmcmFtZSB0aGF0IGlzIGxvYWRpbmcsIGR1cmluZyBhIGdpdmVuIGxvYWQsIG9yIG5p bCB3aGVuIG5vIGxvYWQgaXMgCiAvLyBpbiBwcm9ncmVzcy4gIFVzdWFsbHkgdGhpcyBpcyB0aGUg c2FtZSBhcyB0aGUgbWFpbiBmcmFtZSwgYnV0IG5vdCBhbHdheXMuICBJbiB0aGUgY2FzZQpAQCAt NTYyLDcgKzU2MSw3IEBAIHZvaWQgZHVtcCgpCiAgICAgICAgICAgICB3c3RyaW5nIHJlc3VsdCA9 IGR1bXBGcmFtZXNBc1RleHQoZnJhbWUpOwogICAgICAgICAgICAgcmVzdWx0U3RyaW5nID0gU3lz QWxsb2NTdHJpbmdMZW4ocmVzdWx0LmRhdGEoKSwgcmVzdWx0LnNpemUoKSk7CiAgICAgICAgIH0g ZWxzZSB7Ci0gICAgICAgICAgICBib29sIGlzU1ZHVzNDVGVzdCA9IHN0cnN0cihjdXJyZW50VGVz dCwgInN2Z1xcVzNDLVNWRy0xLjEiKTsKKyAgICAgICAgICAgIGJvb2wgaXNTVkdXM0NUZXN0ID0g KGdMYXlvdXRUZXN0Q29udHJvbGxlci0+dGVzdFBhdGhPclVSTCgpLmZpbmQoInN2Z1xcVzNDLVNW Ry0xLjEiKSAhPSBzdHJpbmc6Om5wb3MpOwogICAgICAgICAgICAgdW5zaWduZWQgd2lkdGg7CiAg ICAgICAgICAgICB1bnNpZ25lZCBoZWlnaHQ7CiAgICAgICAgICAgICBpZiAoaXNTVkdXM0NUZXN0 KSB7CkBAIC02MDgsNyArNjA3LDcgQEAgdm9pZCBkdW1wKCkKIAogICAgIGlmIChkdW1wUGl4ZWxz KSB7CiAgICAgICAgIGlmICghZ0xheW91dFRlc3RDb250cm9sbGVyLT5kdW1wQXNUZXh0KCkgJiYg IWdMYXlvdXRUZXN0Q29udHJvbGxlci0+ZHVtcERPTUFzV2ViQXJjaGl2ZSgpICYmICFnTGF5b3V0 VGVzdENvbnRyb2xsZXItPmR1bXBTb3VyY2VBc1dlYkFyY2hpdmUoKSkKLSAgICAgICAgICAgIGR1 bXBXZWJWaWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0aEV4cGVjdGVkKGN1cnJlbnRUZXN0LCBkdW1w QWxsUGl4ZWxzKTsKKyAgICAgICAgICAgIGR1bXBXZWJWaWV3QXNQaXhlbHNBbmRDb21wYXJlV2l0 aEV4cGVjdGVkKGdMYXlvdXRUZXN0Q29udHJvbGxlci0+ZXhwZWN0ZWRQaXhlbEhhc2goKSk7CiAg ICAgfQogCiAgICAgcHJpbnRmKCIjRU9GXG4iKTsgICAvLyB0ZXJtaW5hdGUgdGhlIChwb3NzaWJs eSBlbXB0eSkgcGl4ZWxzIGJsb2NrCkBAIC02NzUsMTMgKzY3NCwyMyBAQCBzdGF0aWMgdm9pZCBy ZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0ZUJlZm9yZVRlc3RpbmcoKQogICAgIHdlYlZpZXdQ cml2YXRlLT5jbGVhck1haW5GcmFtZU5hbWUoKTsKIH0KIAotc3RhdGljIHZvaWQgcnVuVGVzdChj b25zdCBjaGFyKiBwYXRoT3JVUkwpCitzdGF0aWMgdm9pZCBydW5UZXN0KGNvbnN0IHN0cmluZyYg dGVzdFBhdGhPclVSTCkKIHsKICAgICBzdGF0aWMgQlNUUiBtZXRob2RCU3RyID0gU3lzQWxsb2NT dHJpbmcoVEVYVCgiR0VUIikpOwogCisgICAgLy8gTG9vayBmb3IgIiciIGFzIGEgc2VwYXJhdG9y IGJldHdlZW4gdGhlIHBhdGggb3IgVVJMLCBhbmQgdGhlIHBpeGVsIGR1bXAgaGFzaCB0aGF0IGZv bGxvd3MuCisgICAgc3RyaW5nIHBhdGhPclVSTCh0ZXN0UGF0aE9yVVJMKTsKKyAgICBzdHJpbmcg ZXhwZWN0ZWRQaXhlbEhhc2g7CisgICAgCisgICAgc2l6ZV90IHNlcGFyYXRvclBvcyA9IHBhdGhP clVSTC5maW5kKCInIik7CisgICAgaWYgKHNlcGFyYXRvclBvcyAhPSBzdHJpbmc6Om5wb3MpIHsK KyAgICAgICAgcGF0aE9yVVJMID0gc3RyaW5nKHRlc3RQYXRoT3JVUkwsIDAsIHNlcGFyYXRvclBv cyk7CisgICAgICAgIGV4cGVjdGVkUGl4ZWxIYXNoID0gc3RyaW5nKHRlc3RQYXRoT3JVUkwsIHNl cGFyYXRvclBvcyArIDEpOworICAgIH0KKyAgICAKICAgICBCU1RSIHVybEJTdHI7CiAgCi0gICAg Q0ZTdHJpbmdSZWYgc3RyID0gQ0ZTdHJpbmdDcmVhdGVXaXRoQ1N0cmluZygwLCBwYXRoT3JVUkws IGtDRlN0cmluZ0VuY29kaW5nV2luZG93c0xhdGluMSk7CisgICAgQ0ZTdHJpbmdSZWYgc3RyID0g Q0ZTdHJpbmdDcmVhdGVXaXRoQ1N0cmluZygwLCBwYXRoT3JVUkwuY19zdHIoKSwga0NGU3RyaW5n RW5jb2RpbmdXaW5kb3dzTGF0aW4xKTsKICAgICBDRlVSTFJlZiB1cmwgPSBDRlVSTENyZWF0ZVdp dGhTdHJpbmcoMCwgc3RyLCAwKTsKIAogICAgIGlmICghdXJsKQpAQCAtNzAwLDEzICs3MDksMTEg QEAgc3RhdGljIHZvaWQgcnVuVGVzdChjb25zdCBjaGFyKiBwYXRoT3JVUkwpCiAKICAgICBDRlJl bGVhc2UodXJsKTsKIAotICAgIGN1cnJlbnRUZXN0ID0gcGF0aE9yVVJMOwotCi0gICAgOjpnTGF5 b3V0VGVzdENvbnRyb2xsZXIgPSBuZXcgTGF5b3V0VGVzdENvbnRyb2xsZXIoZmFsc2UsIGZhbHNl KTsKKyAgICA6OmdMYXlvdXRUZXN0Q29udHJvbGxlciA9IG5ldyBMYXlvdXRUZXN0Q29udHJvbGxl cihwYXRoT3JVUkwsIGV4cGVjdGVkUGl4ZWxIYXNoKTsKICAgICBkb25lID0gZmFsc2U7CiAgICAg dG9wTG9hZGluZ0ZyYW1lID0gMDsKIAotICAgIGlmIChzaG91bGRMb2dGcmFtZUxvYWREZWxlZ2F0 ZXMocGF0aE9yVVJMKSkKKyAgICBpZiAoc2hvdWxkTG9nRnJhbWVMb2FkRGVsZWdhdGVzKHBhdGhP clVSTC5jX3N0cigpKSkKICAgICAgICAgZ0xheW91dFRlc3RDb250cm9sbGVyLT5zZXREdW1wRnJh bWVMb2FkQ2FsbGJhY2tzKHRydWUpOwogCiAgICAgQ09NUHRyPElXZWJIaXN0b3J5PiBoaXN0b3J5 KENyZWF0ZSwgQ0xTSURfV2ViSGlzdG9yeSk7CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS93aW4vUGl4ZWxEdW1wU3VwcG9ydFdpbi5jcHAgYi9XZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS93aW4vUGl4ZWxEdW1wU3VwcG9ydFdpbi5jcHAKaW5kZXggMmYyMzE1OC4uZDBi NzllMSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL1BpeGVsRHVt cFN1cHBvcnRXaW4uY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9QaXhl bER1bXBTdXBwb3J0V2luLmNwcApAQCAtMzQsNyArMzQsNyBAQAogI2luY2x1ZGUgPHd0Zi9Bc3Nl cnRpb25zLmg+CiAjaW5jbHVkZSA8d3RmL1JldGFpblB0ci5oPgogCi1SZXRhaW5QdHI8Q0dDb250 ZXh0UmVmPiBnZXRCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoKQorUGFzc1JlZlB0cjxCaXRtYXBD b250ZXh0PiBnZXRCaXRtYXBDb250ZXh0RnJvbVdlYlZpZXcoYm9vbCBvbnNjcmVlbiwgYm9vbCBp bmNyZW1lbnRhbFJlcGFpbnQsIGJvb2wgc3dlZXBIb3Jpem9udGFsbHksIGJvb2wgZHJhd1NlbGVj dGlvblJlY3QpCiB7CiAgICAgUkVDVCBmcmFtZTsKICAgICBpZiAoIUdldFdpbmRvd1JlY3Qod2Vi Vmlld1dpbmRvdywgJmZyYW1lKSkKQEAgLTQ4LDggKzQ4LDYgQEAgUmV0YWluUHRyPENHQ29udGV4 dFJlZj4gZ2V0Qml0bWFwQ29udGV4dEZyb21XZWJWaWV3KCkKICAgICBibXAuYm1pSGVhZGVyLmJp Qml0Q291bnQgPSAzMjsKICAgICBibXAuYm1pSGVhZGVyLmJpQ29tcHJlc3Npb24gPSBCSV9SR0I7 CiAKLSAgICAvLyBGSVhNRTogQ3VycmVudGx5IHdlIGxlYWsgdGhpcyBIQklUTUFQIGJlY2F1c2Ug d2UgZG9uJ3QgaGF2ZSBhIGdvb2Qgd2F5Ci0gICAgLy8gdG8gZGVzdHJveSBpdCB3aGVuIHRoZSBD R0JpdG1hcENvbnRleHQgZ2V0cyBkZXN0cm95ZWQuCiAgICAgdm9pZCogYml0cyA9IDA7CiAgICAg SEJJVE1BUCBiaXRtYXAgPSBDcmVhdGVESUJTZWN0aW9uKDAsICZibXAsIERJQl9SR0JfQ09MT1JT LCAmYml0cywgMCwgMCk7CiAKQEAgLTYzLDYgKzYxLDggQEAgUmV0YWluUHRyPENHQ29udGV4dFJl Zj4gZ2V0Qml0bWFwQ29udGV4dEZyb21XZWJWaWV3KCkKICAgICBBU1NFUlQoaW5mby5ibUJpdHNQ aXhlbCA9PSAzMik7CiAKICAgICBSZXRhaW5QdHI8Q0dDb2xvclNwYWNlUmVmPiBjb2xvclNwYWNl KEFkb3B0Q0YsIENHQ29sb3JTcGFjZUNyZWF0ZURldmljZVJHQigpKTsKLSAgICByZXR1cm4gUmV0 YWluUHRyPENHQ29udGV4dFJlZj4oQWRvcHRDRiwgQ0dCaXRtYXBDb250ZXh0Q3JlYXRlKGluZm8u Ym1CaXRzLCBpbmZvLmJtV2lkdGgsIGluZm8uYm1IZWlnaHQsIDgsCi0gICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbmZvLmJtV2lkdGhCeXRlcywgY29sb3JT cGFjZS5nZXQoKSwga0NHQml0bWFwQnl0ZU9yZGVyMzJMaXR0bGUgfCBrQ0dJbWFnZUFscGhhUHJl bXVsdGlwbGllZEZpcnN0KSk7CisgICAgQ0dDb250ZXh0UmVmIGNvbnRleHQgPSBDR0JpdG1hcENv bnRleHRDcmVhdGUoaW5mby5ibUJpdHMsIGluZm8uYm1XaWR0aCwgaW5mby5ibUhlaWdodCwgOCwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGluZm8uYm1X aWR0aEJ5dGVzLCBjb2xvclNwYWNlLmdldCgpLCBrQ0dCaXRtYXBCeXRlT3JkZXIzMkxpdHRsZSB8 IGtDR0ltYWdlQWxwaGFQcmVtdWx0aXBsaWVkRmlyc3QpOworCisgICAgcmV0dXJuIEJpdG1hcENv bnRleHQ6OmNyZWF0ZUJ5QWRvcHRpbmdCaXRtYXBBbmRDb250ZXh0KGJpdG1hcCwgY29udGV4dCk7 CiB9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3J1bi13ZWJraXQtdGVzdHMgYi9X ZWJLaXRUb29scy9TY3JpcHRzL3J1bi13ZWJraXQtdGVzdHMKaW5kZXggMmJiMTA5Ni4uNGYxMjli NyAxMDA3NTUKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy9ydW4td2Via2l0LXRlc3RzCisrKyBi L1dlYktpdFRvb2xzL1NjcmlwdHMvcnVuLXdlYmtpdC10ZXN0cwpAQCAtMTEyLDggKzExMiw2IEBA IG15ICRsYXVuY2hTYWZhcmkgPSAxOwogbXkgJHBsYXRmb3JtOwogbXkgJHBpeGVsVGVzdHMgPSAn JzsKIG15ICRxdWlldCA9ICcnOwotbXkgJHJlcGFpbnRTd2VlcEhvcml6b250YWxseSA9ICcnOwot bXkgJHJlcGFpbnRUZXN0cyA9ICcnOwogbXkgJHJlcG9ydDEwU2xvd2VzdCA9IDA7CiBteSAkcmVz ZXRSZXN1bHRzID0gMDsKIG15ICRzaG91bGRDaGVja0xlYWtzID0gMDsKQEAgLTEyMyw3ICsxMjEs NyBAQCBteSAkdGVzdEhUVFAgPSAxOwogbXkgJHRlc3RNZWRpYSA9IDE7CiBteSAkdGVzdFJlc3Vs dHNEaXJlY3RvcnkgPSAiL3RtcC9sYXlvdXQtdGVzdC1yZXN1bHRzIjsKIG15ICR0aHJlYWRlZCA9 IDA7Ci1teSAkdGhyZXNob2xkID0gMDsKK215ICR0b2xlcmFuY2UgPSAwOwogbXkgJHRyZWF0U2tp cHBlZCA9ICJkZWZhdWx0IjsKIG15ICR2ZXJib3NlID0gMDsKIG15ICR1c2VWYWxncmluZCA9IDA7 CkBAIC0xODAsMTcgKzE3OCwxNiBAQCBVc2FnZTogJHByb2dyYW1OYW1lIFtvcHRpb25zXSBbdGVz dGRpcnx0ZXN0cGF0aCAuLi5dCiAgIC1jfC0tY29uZmlndXJhdGlvbiBjb25maWcgICAgICAgU2V0 IER1bXBSZW5kZXJUcmVlIGJ1aWxkIGNvbmZpZ3VyYXRpb24KICAgLWd8LS1ndWFyZC1tYWxsb2Mg ICAgICAgICAgICAgICBFbmFibGUgbWFsbG9jIGd1YXJkCiAgIC0taGVscCAgICAgICAgICAgICAg ICAgICAgICAgICAgU2hvdyB0aGlzIGhlbHAgbWVzc2FnZQotICAtaHwtLWhvcml6b250YWwtc3dl ZXAgICAgICAgICAgIENoYW5nZSByZXBhaW50IHRvIHN3ZWVwIGhvcml6b250YWxseSBpbnN0ZWFk IG9mIHZlcnRpY2FsbHkgKGltcGxpZXMgLS1yZXBhaW50LXRlc3RzKQogICAtLVtuby1daHR0cCAg ICAgICAgICAgICAgICAgICAgIFJ1biAob3IgZG8gbm90IHJ1bikgaHR0cCB0ZXN0cyAoZGVmYXVs dDogJGh0dHBEZWZhdWx0KQogICAtaXwtLWlnbm9yZS10ZXN0cyAgICAgICAgICAgICAgIENvbW1h LXNlcGFyYXRlZCBsaXN0IG9mIGRpcmVjdG9yaWVzIG9yIHRlc3RzIHRvIGlnbm9yZQogICAtLVtu by1dbGF1bmNoLXNhZmFyaSAgICAgICAgICAgIExhdW5jaCAob3IgZG8gbm90IGxhdW5jaCkgU2Fm YXJpIHRvIGRpc3BsYXkgdGVzdCByZXN1bHRzIChkZWZhdWx0OiAkbGF1bmNoU2FmYXJpRGVmYXVs dCkKICAgLWx8LS1sZWFrcyAgICAgICAgICAgICAgICAgICAgICBFbmFibGUgbGVha3MgY2hlY2tp bmcKICAgLS1bbm8tXW5ldy10ZXN0LXJlc3VsdHMgICAgICAgICBHZW5lcmF0ZSByZXN1bHRzIGZv ciBuZXcgdGVzdHMKICAgLXB8LS1waXhlbC10ZXN0cyAgICAgICAgICAgICAgICBFbmFibGUgcGl4 ZWwgdGVzdHMKKyAgLS10b2xlcmFuY2UgdCAgICAgICAgICAgICAgICAgICBJZ25vcmUgaW1hZ2Ug ZGlmZmVyZW5jZXMgbGVzcyB0aGFuIHRoaXMgcGVyY2VudGFnZSAoaW1wbGllcyAtLXBpeGVsLXRl c3RzKQogICAtLXBsYXRmb3JtICAgICAgICAgICAgICAgICAgICAgIE92ZXJyaWRlIHRoZSBkZXRl Y3RlZCBwbGF0Zm9ybSB0byB1c2UgZm9yIHRlc3RzIGFuZCByZXN1bHRzIChkZWZhdWx0OiAkcGxh dGZvcm0pCiAgIC0tcG9ydCAgICAgICAgICAgICAgICAgICAgICAgICAgV2ViIHNlcnZlciBwb3J0 IHRvIHVzZSB3aXRoIGh0dHAgdGVzdHMKICAgLXF8LS1xdWlldCAgICAgICAgICAgICAgICAgICAg ICBMZXNzIHZlcmJvc2Ugb3V0cHV0Ci0gIC1yfC0tcmVwYWludC10ZXN0cyAgICAgICAgICAgICAg UnVuIHJlcGFpbnQgdGVzdHMgKGltcGxpZXMgLS1waXhlbC10ZXN0cykKICAgLS1yZXNldC1yZXN1 bHRzICAgICAgICAgICAgICAgICBSZXNldCBBTEwgcmVzdWx0cyAoaW5jbHVkaW5nIHBpeGVsIHRl c3RzIGlmIC0tcGl4ZWwtdGVzdHMgaXMgc2V0KQogICAtb3wtLXJlc3VsdHMtZGlyZWN0b3J5ICAg ICAgICAgIE91dHB1dCByZXN1bHRzIGRpcmVjdG9yeSAoZGVmYXVsdDogJHRlc3RSZXN1bHRzRGly ZWN0b3J5KQogICAtLXJhbmRvbSAgICAgICAgICAgICAgICAgICAgICAgIFJ1biB0aGUgdGVzdHMg aW4gYSByYW5kb20gb3JkZXIKQEAgLTIwNiw3ICsyMDMsNiBAQCBVc2FnZTogJHByb2dyYW1OYW1l IFtvcHRpb25zXSBbdGVzdGRpcnx0ZXN0cGF0aCAuLi5dCiAgIC0tc3RyaWN0ICAgICAgICAgICAg ICAgICAgICAgICAgRG8gYSBjb21wYXJpc29uIHdpdGggdGhlIG91dHB1dCBvbiBNYWMgKFF0IG9u bHkpCiAgIC0tW25vLV1zdHJpcC1lZGl0aW5nLWNhbGxiYWNrcyAgUmVtb3ZlIGVkaXRpbmcgY2Fs bGJhY2tzIGZyb20gZXhwZWN0ZWQgcmVzdWx0cwogICAtdHwtLXRocmVhZGVkICAgICAgICAgICAg ICAgICAgIFJ1biBhIGNvbmN1cnJlbnQgSmF2YVNjcmlwdCB0aGVhZCB3aXRoIGVhY2ggdGVzdAot ICAtLXRocmVzaG9sZCB0ICAgICAgICAgICAgICAgICAgIElnbm9yZSBwaXhlbCB2YWx1ZSBkZXZp YXRpb25zIGxlc3MgdGhhbiBvciBlcXVhbCB0byB0CiAgIC0tdmFsZ3JpbmQgICAgICAgICAgICAg ICAgICAgICAgUnVuIER1bXBSZW5kZXJUcmVlIGluc2lkZSB2YWxncmluZCAoUXQvTGludXggb25s eSkKICAgLXZ8LS12ZXJib3NlICAgICAgICAgICAgICAgICAgICBNb3JlIHZlcmJvc2Ugb3V0cHV0 IChvdmVycmlkZXMgLS1xdWlldCkKICAgLW18LS1tZXJnZS1sZWFrLWRlcHRoIGFyZyAgICAgICBN ZXJnZXMgbGVhayBjYWxsU3RhY2tzIGFuZCBwcmludHMgdGhlIG51bWJlciBvZiB1bmlxdWUgbGVh a3MgYmVuZWF0aCBhIGNhbGxzdGFjayBkZXB0aCBvZiBhcmcuICBEZWZhdWx0cyB0byA1LgpAQCAt MjIxLDcgKzIxNyw2IEBAIG15ICRnZXRPcHRpb25zUmVzdWx0ID0gR2V0T3B0aW9ucygKICAgICAn Y3xjb25maWd1cmF0aW9uPXMnID0+IFwkY29uZmlndXJhdGlvbiwKICAgICAnZ3VhcmQtbWFsbG9j fGcnID0+IFwkZ3VhcmRNYWxsb2MsCiAgICAgJ2hlbHAnID0+IFwkc2hvd0hlbHAsCi0gICAgJ2hv cml6b250YWwtc3dlZXB8aCcgPT4gXCRyZXBhaW50U3dlZXBIb3Jpem9udGFsbHksCiAgICAgJ2h0 dHAhJyA9PiBcJHRlc3RIVFRQLAogICAgICdpZ25vcmUtdGVzdHN8aT1zJyA9PiBcJGlnbm9yZVRl c3RzLAogICAgICdsYXVuY2gtc2FmYXJpIScgPT4gXCRsYXVuY2hTYWZhcmksCkBAIC0yMzAsNyAr MjI1LDYgQEAgbXkgJGdldE9wdGlvbnNSZXN1bHQgPSBHZXRPcHRpb25zKAogICAgICdwbGF0Zm9y bT1zJyA9PiBcJHBsYXRmb3JtLAogICAgICdwb3J0PWknID0+IFwkaHR0cGRQb3J0LAogICAgICdx dWlldHxxJyA9PiBcJHF1aWV0LAotICAgICdyZXBhaW50LXRlc3RzfHInID0+IFwkcmVwYWludFRl c3RzLAogICAgICdyZXNldC1yZXN1bHRzJyA9PiBcJHJlc2V0UmVzdWx0cywKICAgICAnbmV3LXRl c3QtcmVzdWx0cyEnID0+IFwkZ2VuZXJhdGVOZXdSZXN1bHRzLAogICAgICdyZXN1bHRzLWRpcmVj dG9yeXxvPXMnID0+IFwkdGVzdFJlc3VsdHNEaXJlY3RvcnksCkBAIC0yMzksNyArMjMzLDcgQEAg bXkgJGdldE9wdGlvbnNSZXN1bHQgPSBHZXRPcHRpb25zKAogICAgICdza2lwcGVkPXMnID0+IFwm dmFsaWRhdGVTa2lwcGVkQXJnLAogICAgICdzbG93ZXN0JyA9PiBcJHJlcG9ydDEwU2xvd2VzdCwK ICAgICAndGhyZWFkZWR8dCcgPT4gXCR0aHJlYWRlZCwKLSAgICAndGhyZXNob2xkPWknID0+IFwk dGhyZXNob2xkLAorICAgICd0b2xlcmFuY2U9ZicgPT4gXCR0b2xlcmFuY2UsCiAgICAgJ3ZlcmJv c2V8dicgPT4gXCR2ZXJib3NlLAogICAgICd2YWxncmluZCcgPT4gXCR1c2VWYWxncmluZCwKICAg ICAnc2FtcGxlLW9uLXRpbWVvdXQhJyA9PiBcJHJ1blNhbXBsZSwKQEAgLTI2NywxMCArMjYxLDcg QEAgc2V0Q29uZmlndXJhdGlvbigkY29uZmlndXJhdGlvbik7CiAKIG15ICRjb25maWd1cmF0aW9u T3B0aW9uID0gIi0tIiAuIGxjKCRjb25maWd1cmF0aW9uKTsKIAotJHJlcGFpbnRUZXN0cyA9IDEg aWYgJHJlcGFpbnRTd2VlcEhvcml6b250YWxseTsKLQotJHBpeGVsVGVzdHMgPSAxIGlmICRyZXBh aW50VGVzdHM7Ci0kcGl4ZWxUZXN0cyA9IDEgaWYgJHRocmVzaG9sZCA+IDA7CiskcGl4ZWxUZXN0 cyA9IDEgaWYgJHRvbGVyYW5jZSA+IDA7CiAKICR0ZXN0c1BlckR1bXBUb29sID0gMTAwMCBpZiAh JHRlc3RzUGVyRHVtcFRvb2w7CiAKQEAgLTI5MSw3ICsyODIsNyBAQCBzZXRSdW42NEJpdCgkcnVu NjRCaXQpOwogCiBjaGRpcldlYktpdCgpOwogCi1pZighZGVmaW5lZCgkcm9vdCkpeworaWYgKCFk ZWZpbmVkKCRyb290KSkgewogICAgICMgUHVzaCB0aGUgcGFyYW1ldGVycyB0byBidWlsZC1kdW1w cmVuZGVydHJlZSBhcyBhbiBhcnJheQogICAgIG15IEBhcmdzOwogICAgIHB1c2goQGFyZ3MsICRj b25maWd1cmF0aW9uT3B0aW9uKTsKQEAgLTQ1NCwxOSArNDQ1LDE1IEBAIG15ICVkdXJhdGlvbnM7 CiBteSAkY291bnQgPSAwOwogbXkgJGxlYWtzT3V0cHV0RmlsZU51bWJlciA9IDE7CiBteSAkdG90 YWxMZWFrcyA9IDA7Ci1teSAkZHVtcEFsbFBpeGVscyA9ICRwaXhlbFRlc3RzICYmICRyZXNldFJl c3VsdHM7CiAKIG15IEB0b29sQXJncyA9ICgpOwotcHVzaCBAdG9vbEFyZ3MsICItLWR1bXAtYWxs LXBpeGVscyIgaWYgJGR1bXBBbGxQaXhlbHM7CiBwdXNoIEB0b29sQXJncywgIi0tcGl4ZWwtdGVz dHMiIGlmICRwaXhlbFRlc3RzOwotcHVzaCBAdG9vbEFyZ3MsICItLXJlcGFpbnQiIGlmICRyZXBh aW50VGVzdHM7Ci1wdXNoIEB0b29sQXJncywgIi0taG9yaXpvbnRhbC1zd2VlcCIgaWYgJHJlcGFp bnRTd2VlcEhvcml6b250YWxseTsKIHB1c2ggQHRvb2xBcmdzLCAiLS10aHJlYWRlZCIgaWYgJHRo cmVhZGVkOwogcHVzaCBAdG9vbEFyZ3MsICItLWNvbXBsZXgtdGV4dCIgaWYgJGNvbXBsZXhUZXh0 OwogcHVzaCBAdG9vbEFyZ3MsICItIjsKIAogbXkgQGRpZmZUb29sQXJncyA9ICgpOwotcHVzaCBA ZGlmZlRvb2xBcmdzLCAiLS10aHJlc2hvbGQiLCAkdGhyZXNob2xkOworcHVzaCBAZGlmZlRvb2xB cmdzLCAiLS10b2xlcmFuY2UiLCAkdG9sZXJhbmNlOwogCiAkfCA9IDE7CiAKQEAgLTU1Myw2ICs1 NDAsMjAgQEAgZm9yIG15ICR0ZXN0IChAdGVzdHMpIHsKIAogICAgIG15ICRzdGFydFRpbWUgPSB0 aW1lIGlmICRyZXBvcnQxMFNsb3dlc3Q7CiAKKyAgICAjIFRyeSB0byByZWFkIGV4cGVjdGVkIGhh c2ggZmlsZSBmb3IgcGl4ZWwgdGVzdHMKKyAgICBteSAkc3VmZml4RXhwZWN0ZWRIYXNoID0gIiI7 CisgICAgaWYgKCRwaXhlbFRlc3RzICYmICEkcmVzZXRSZXN1bHRzKSB7CisgICAgICAgIG15ICRl eHBlY3RlZFBpeGVsRGlyID0gZXhwZWN0ZWREaXJlY3RvcnlGb3JUZXN0KCRiYXNlLCAwLCAicG5n Iik7CisgICAgICAgIGlmIChvcGVuIEVYUEVDVEVESEFTSCwgIiRleHBlY3RlZFBpeGVsRGlyLyRi YXNlLSRleHBlY3RlZFRhZy5jaGVja3N1bSIpIHsKKyAgICAgICAgICAgIG15ICRleHBlY3RlZEhh c2ggPSA8RVhQRUNURURIQVNIPjsKKyAgICAgICAgICAgIGNob21wKCRleHBlY3RlZEhhc2gpOwor ICAgICAgICAgICAgY2xvc2UgRVhQRUNURURIQVNIOworICAgICAgICAgICAgCisgICAgICAgICAg ICAjIEZvcm1hdCBleHBlY3RlZCBoYXNoIGludG8gYSBzdWZmaXggc3RyaW5nIHRoYXQgaXMgYXBw ZW5kZWQgdG8gdGhlIHBhdGggLyBVUkwgcGFzc2VkIHRvIERSVAorICAgICAgICAgICAgJHN1ZmZp eEV4cGVjdGVkSGFzaCA9ICInJGV4cGVjdGVkSGFzaCI7CisgICAgICAgIH0KKyAgICB9CisKICAg ICBpZiAoJHRlc3QgIX4gL15odHRwXC8vKSB7CiAgICAgICAgIG15ICR0ZXN0UGF0aCA9ICIkdGVz dERpcmVjdG9yeS8kdGVzdCI7CiAgICAgICAgIGlmIChpc0N5Z3dpbigpKSB7CkBAIC01NjAsMTcg KzU2MSwxNyBAQCBmb3IgbXkgJHRlc3QgKEB0ZXN0cykgewogICAgICAgICB9IGVsc2UgewogICAg ICAgICAgICAgJHRlc3RQYXRoID0gY2Fub25wYXRoKCR0ZXN0UGF0aCk7CiAgICAgICAgIH0KLSAg ICAgICAgcHJpbnQgT1VUICIkdGVzdFBhdGhcbiI7CisgICAgICAgIHByaW50IE9VVCAiJHRlc3RQ YXRoJHN1ZmZpeEV4cGVjdGVkSGFzaFxuIjsKICAgICB9IGVsc2UgewogICAgICAgICBvcGVuSFRU UERJZk5lZWRlZCgpOwogICAgICAgICBpZiAoJHRlc3QgIX4gL15odHRwXC90ZXN0c1wvbG9jYWxc Ly8gJiYgJHRlc3QgIX4gL15odHRwXC90ZXN0c1wvc3NsXC8vICYmICR0ZXN0ICF+IC9eaHR0cFwv dGVzdHNcL21lZGlhXC8vKSB7CiAgICAgICAgICAgICBteSAkcGF0aCA9IGNhbm9ucGF0aCgkdGVz dCk7CiAgICAgICAgICAgICAkcGF0aCA9fiBzL15odHRwXC90ZXN0c1wvLy87Ci0gICAgICAgICAg ICBwcmludCBPVVQgImh0dHA6Ly8xMjcuMC4wLjE6JGh0dHBkUG9ydC8kcGF0aFxuIjsKKyAgICAg ICAgICAgIHByaW50IE9VVCAiaHR0cDovLzEyNy4wLjAuMTokaHR0cGRQb3J0LyRwYXRoJHN1ZmZp eEV4cGVjdGVkSGFzaFxuIjsKICAgICAgICAgfSBlbHNpZiAoJHRlc3QgPX4gL15odHRwXC90ZXN0 c1wvc3NsXC8vKSB7CiAgICAgICAgICAgICBteSAkcGF0aCA9IGNhbm9ucGF0aCgkdGVzdCk7CiAg ICAgICAgICAgICAkcGF0aCA9fiBzL15odHRwXC90ZXN0c1wvLy87Ci0gICAgICAgICAgICBwcmlu dCBPVVQgImh0dHBzOi8vMTI3LjAuMC4xOiRodHRwZFNTTFBvcnQvJHBhdGhcbiI7CisgICAgICAg ICAgICBwcmludCBPVVQgImh0dHBzOi8vMTI3LjAuMC4xOiRodHRwZFNTTFBvcnQvJHBhdGgkc3Vm Zml4RXhwZWN0ZWRIYXNoXG4iOwogICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgbXkgJHRl c3RQYXRoID0gIiR0ZXN0RGlyZWN0b3J5LyR0ZXN0IjsKICAgICAgICAgICAgIGlmIChpc0N5Z3dp bigpKSB7CkBAIC01NzgsNyArNTc5LDcgQEAgZm9yIG15ICR0ZXN0IChAdGVzdHMpIHsKICAgICAg ICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAgJHRlc3RQYXRoID0gY2Fub25wYXRoKCR0 ZXN0UGF0aCk7CiAgICAgICAgICAgICB9Ci0gICAgICAgICAgICBwcmludCBPVVQgIiR0ZXN0UGF0 aFxuIjsKKyAgICAgICAgICAgIHByaW50IE9VVCAiJHRlc3RQYXRoJHN1ZmZpeEV4cGVjdGVkSGFz aFxuIjsKICAgICAgICAgfQogICAgIH0KIApAQCAtNjQxLDcgKzY0Miw2IEBAIGZvciBteSAkdGVz dCAoQHRlc3RzKSB7CiAgICAgbXkgJGRpZmZQZXJjZW50YWdlID0gIiI7CiAgICAgbXkgJGRpZmZS ZXN1bHQgPSAicGFzc2VkIjsKIAotICAgICMgTG9vayBmb3IgdGhlIHBpeGVsIGJsb2NrLCBhbmQg ZG8gYW4gaW1hZ2UgZGlmZiBpZiB3ZSBmaW5kIG9uZQogICAgIG15ICRhY3R1YWxIYXNoID0gIiI7 CiAgICAgbXkgJGV4cGVjdGVkSGFzaCA9ICIiOwogICAgIG15ICRhY3R1YWxQTkdTaXplID0gMDsK QEAgLTY1MCw3ICs2NTAsNyBAQCBmb3IgbXkgJHRlc3QgKEB0ZXN0cykgewogICAgICAgICBsYXN0 IGlmIC8jRU9GLzsKICAgICAgICAgaWYgKC9BY3R1YWxIYXNoOiAoW2EtZjAtOV17MzJ9KS8pIHsK ICAgICAgICAgICAgICRhY3R1YWxIYXNoID0gJDE7Ci0gICAgICAgIH0gZWxzaWYgKC9CYXNlbGlu ZUhhc2g6IChbYS1mMC05XXszMn0pLykgeworICAgICAgICB9IGVsc2lmICgvRXhwZWN0ZWRIYXNo OiAoW2EtZjAtOV17MzJ9KS8pIHsKICAgICAgICAgICAgICRleHBlY3RlZEhhc2ggPSAkMTsKICAg ICAgICAgfSBlbHNpZiAoL0NvbnRlbnQtTGVuZ3RoOiAoXGQrKVxzKi8pIHsKICAgICAgICAgICAg ICRhY3R1YWxQTkdTaXplID0gJDE7CkBAIC02NTgsNDIgKzY1OCw1OCBAQCBmb3IgbXkgJHRlc3Qg KEB0ZXN0cykgewogICAgICAgICB9CiAgICAgfQogCi0gICAgIyBJZiB3ZSBnb3Qgc29tZSBQTkcg ZGF0YSwgZGlmZiB3aXRoIGV4cGVjdGVkCisgICAgaWYgKCR2ZXJib3NlICYmICRwaXhlbFRlc3Rz ICYmICEkcmVzZXRSZXN1bHRzICYmICRhY3R1YWxQTkdTaXplKSB7CisgICAgICAgIGlmICgkYWN0 dWFsSGFzaCBlcSAiIiAmJiAkZXhwZWN0ZWRIYXNoIGVxICIiKSB7CisgICAgICAgICAgICBwcmlu dEZhaWx1cmVNZXNzYWdlRm9yVGVzdCgkdGVzdCwgIldBUk5JTkc6IGFjdHVhbCAmIGV4cGVjdGVk IHBpeGVsIGhhc2hlcyBhcmUgbWlzc2luZyEiKTsKKyAgICAgICAgfSBlbHNpZiAoJGFjdHVhbEhh c2ggZXEgIiIpIHsKKyAgICAgICAgICAgIHByaW50RmFpbHVyZU1lc3NhZ2VGb3JUZXN0KCR0ZXN0 LCAiV0FSTklORzogYWN0dWFsIHBpeGVsIGhhc2ggaXMgbWlzc2luZyEiKTsKKyAgICAgICAgfSBl bHNpZiAoJGV4cGVjdGVkSGFzaCBlcSAiIikgeworICAgICAgICAgICAgcHJpbnRGYWlsdXJlTWVz c2FnZUZvclRlc3QoJHRlc3QsICJXQVJOSU5HOiBleHBlY3RlZCBwaXhlbCBoYXNoIGlzIG1pc3Np bmchIik7CisgICAgICAgIH0KKyAgICB9CisKICAgICBpZiAoJGFjdHVhbFBOR1NpemUgPiAwKSB7 Ci0gICAgICAgIG15ICRleHBlY3RlZFBpeGVsRGlyID0gZXhwZWN0ZWREaXJlY3RvcnlGb3JUZXN0 KCRiYXNlLCAkaXNUZXh0LCAicG5nIik7CisgICAgICAgIG15ICRleHBlY3RlZFBpeGVsRGlyID0g ZXhwZWN0ZWREaXJlY3RvcnlGb3JUZXN0KCRiYXNlLCAwLCAicG5nIik7CiAKLSAgICAgICAgaWYg KCRleHBlY3RlZEhhc2ggbmUgJGFjdHVhbEhhc2ggJiYgLWYgIiRleHBlY3RlZFBpeGVsRGlyLyRi YXNlLSRleHBlY3RlZFRhZy5wbmciKSB7Ci0gICAgICAgICAgICBteSAkZXhwZWN0ZWRQTkdTaXpl ID0gLXMgIiRleHBlY3RlZFBpeGVsRGlyLyRiYXNlLSRleHBlY3RlZFRhZy5wbmciOwotICAgICAg ICAgICAgbXkgJGV4cGVjdGVkUE5HID0gIiI7Ci0gICAgICAgICAgICBvcGVuIEVYUEVDVEVEUE5H LCAiJGV4cGVjdGVkUGl4ZWxEaXIvJGJhc2UtJGV4cGVjdGVkVGFnLnBuZyI7Ci0gICAgICAgICAg ICByZWFkKEVYUEVDVEVEUE5HLCAkZXhwZWN0ZWRQTkcsICRleHBlY3RlZFBOR1NpemUpOworICAg ICAgICBpZiAoISRyZXNldFJlc3VsdHMgJiYgKCRleHBlY3RlZEhhc2ggbmUgJGFjdHVhbEhhc2gg fHwgKCRhY3R1YWxIYXNoIGVxICIiICYmICRleHBlY3RlZEhhc2ggZXEgIiIpKSkgeworICAgICAg ICAgICAgaWYgKC1mICIkZXhwZWN0ZWRQaXhlbERpci8kYmFzZS0kZXhwZWN0ZWRUYWcucG5nIikg eworICAgICAgICAgICAgICAgIG15ICRleHBlY3RlZFBOR1NpemUgPSAtcyAiJGV4cGVjdGVkUGl4 ZWxEaXIvJGJhc2UtJGV4cGVjdGVkVGFnLnBuZyI7CisgICAgICAgICAgICAgICAgbXkgJGV4cGVj dGVkUE5HID0gIiI7CisgICAgICAgICAgICAgICAgb3BlbiBFWFBFQ1RFRFBORywgIiRleHBlY3Rl ZFBpeGVsRGlyLyRiYXNlLSRleHBlY3RlZFRhZy5wbmciOworICAgICAgICAgICAgICAgIHJlYWQo RVhQRUNURURQTkcsICRleHBlY3RlZFBORywgJGV4cGVjdGVkUE5HU2l6ZSk7CiAKLSAgICAgICAg ICAgIHByaW50IERJRkZPVVQgIkNvbnRlbnQtTGVuZ3RoOiAkYWN0dWFsUE5HU2l6ZVxuIjsKLSAg ICAgICAgICAgIHByaW50IERJRkZPVVQgJGFjdHVhbFBORzsKKyAgICAgICAgICAgICAgICBwcmlu dCBESUZGT1VUICJDb250ZW50LUxlbmd0aDogJGFjdHVhbFBOR1NpemVcbiI7CisgICAgICAgICAg ICAgICAgcHJpbnQgRElGRk9VVCAkYWN0dWFsUE5HOwogCi0gICAgICAgICAgICBwcmludCBESUZG T1VUICJDb250ZW50LUxlbmd0aDogJGV4cGVjdGVkUE5HU2l6ZVxuIjsKLSAgICAgICAgICAgIHBy aW50IERJRkZPVVQgJGV4cGVjdGVkUE5HOworICAgICAgICAgICAgICAgIHByaW50IERJRkZPVVQg IkNvbnRlbnQtTGVuZ3RoOiAkZXhwZWN0ZWRQTkdTaXplXG4iOworICAgICAgICAgICAgICAgIHBy aW50IERJRkZPVVQgJGV4cGVjdGVkUE5HOwogCi0gICAgICAgICAgICB3aGlsZSAoPERJRkZJTj4p IHsKLSAgICAgICAgICAgICAgICBsYXN0IGlmIC9eZXJyb3IvIHx8IC9eZGlmZjovOwotICAgICAg ICAgICAgICAgIGlmICgvQ29udGVudC1MZW5ndGg6IChcZCspXHMqLykgewotICAgICAgICAgICAg ICAgICAgICByZWFkKERJRkZJTiwgJGRpZmZQTkcsICQxKTsKKyAgICAgICAgICAgICAgICB3aGls ZSAoPERJRkZJTj4pIHsKKyAgICAgICAgICAgICAgICAgICAgbGFzdCBpZiAvXmVycm9yLyB8fCAv XmRpZmY6LzsKKyAgICAgICAgICAgICAgICAgICAgaWYgKC9Db250ZW50LUxlbmd0aDogKFxkKylc cyovKSB7CisgICAgICAgICAgICAgICAgICAgICAgICByZWFkKERJRkZJTiwgJGRpZmZQTkcsICQx KTsKKyAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAg IH0KIAotICAgICAgICAgICAgaWYgKC9eZGlmZjogKC4rKSUgKHBhc3NlZHxmYWlsZWQpLykgewot ICAgICAgICAgICAgICAgICRkaWZmUGVyY2VudGFnZSA9ICQxOwotICAgICAgICAgICAgICAgICRp bWFnZURpZmZlcmVuY2VzeyRiYXNlfSA9ICRkaWZmUGVyY2VudGFnZTsKLSAgICAgICAgICAgICAg ICAkZGlmZlJlc3VsdCA9ICQyOworICAgICAgICAgICAgICAgIGlmICgvXmRpZmY6ICguKyklIChw YXNzZWR8ZmFpbGVkKS8pIHsKKyAgICAgICAgICAgICAgICAgICAgJGRpZmZQZXJjZW50YWdlID0g JDE7CisgICAgICAgICAgICAgICAgICAgICRpbWFnZURpZmZlcmVuY2VzeyRiYXNlfSA9ICRkaWZm UGVyY2VudGFnZTsKKyAgICAgICAgICAgICAgICAgICAgJGRpZmZSZXN1bHQgPSAkMjsKKyAgICAg ICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgCisgICAgICAgICAgICAgICAgaWYgKCRkaWZm UGVyY2VudGFnZSA9PSAwKSB7CisgICAgICAgICAgICAgICAgICAgIHByaW50RmFpbHVyZU1lc3Nh Z2VGb3JUZXN0KCR0ZXN0LCAicGl4ZWwgaGFzaCBmYWlsZWQgKGJ1dCBwaXhlbCB0ZXN0IHN0aWxs IHBhc3NlcykiKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9IGVsc2lmICgkdmVy Ym9zZSkgeworICAgICAgICAgICAgICAgIHByaW50RmFpbHVyZU1lc3NhZ2VGb3JUZXN0KCR0ZXN0 LCAiV0FSTklORzogZXhwZWN0ZWQgaW1hZ2UgaXMgbWlzc2luZyEiKTsKICAgICAgICAgICAgIH0K ICAgICAgICAgfQogCi0gICAgICAgIGlmICgkYWN0dWFsUE5HU2l6ZSAmJiAoJHJlc2V0UmVzdWx0 cyB8fCAhLWYgIiRleHBlY3RlZFBpeGVsRGlyLyRiYXNlLSRleHBlY3RlZFRhZy5wbmciKSkgewor ICAgICAgICBpZiAoJHJlc2V0UmVzdWx0cyB8fCAhLWYgIiRleHBlY3RlZFBpeGVsRGlyLyRiYXNl LSRleHBlY3RlZFRhZy5wbmciKSB7CiAgICAgICAgICAgICBta3BhdGggY2F0ZmlsZSgkZXhwZWN0 ZWRQaXhlbERpciwgZGlybmFtZSgkYmFzZSkpIGlmICR0ZXN0RGlyZWN0b3J5IG5lICRleHBlY3Rl ZFBpeGVsRGlyOwogICAgICAgICAgICAgd3JpdGVUb0ZpbGUoIiRleHBlY3RlZFBpeGVsRGlyLyRi YXNlLSRleHBlY3RlZFRhZy5wbmciLCAkYWN0dWFsUE5HKTsKICAgICAgICAgfQogCi0gICAgICAg ICMgdXBkYXRlIHRoZSBleHBlY3RlZCBoYXNoIGlmIHRoZSBpbWFnZSBkaWZmIHNhaWQgdGhhdCB0 aGVyZSB3YXMgbm8gZGlmZmVyZW5jZQogICAgICAgICBpZiAoJGFjdHVhbEhhc2ggbmUgIiIgJiYg KCRyZXNldFJlc3VsdHMgfHwgIS1mICIkZXhwZWN0ZWRQaXhlbERpci8kYmFzZS0kZXhwZWN0ZWRU YWcuY2hlY2tzdW0iKSkgewogICAgICAgICAgICAgd3JpdGVUb0ZpbGUoIiRleHBlY3RlZFBpeGVs RGlyLyRiYXNlLSRleHBlY3RlZFRhZy5jaGVja3N1bSIsICRhY3R1YWxIYXNoKTsKICAgICAgICAg fQpAQCAtNzQxLDcgKzc1Nyw3IEBAIGZvciBteSAkdGVzdCAoQHRlc3RzKSB7CiAgICAgICAgICAg c3lzdGVtICJkaWZmIC11IFwiL3RtcC9leHBlY3RlZC50eHRcIiBcIi90bXAvYWN0dWFsLnR4dFwi ID4gXCIvdG1wL3NpbXBsaWZpZWQuZGlmZlwiIjsKIAogICAgICAgICAgICRkaWZmUmVzdWx0ID0g ImZhaWxlZCI7Ci0gICAgICAgICAgaWYoJHZlcmJvc2UpIHsKKyAgICAgICAgICBpZiAoJHZlcmJv c2UpIHsKICAgICAgICAgICAgIHByaW50ICJcbiI7CiAgICAgICAgICAgICBzeXN0ZW0gImNhdCAv dG1wL3NpbXBsaWZpZWQuZGlmZiI7CiAgICAgICAgICAgICBwcmludCAiZmFpbGVkISEhISEiOwpA QCAtODE3LDcgKzgzMyw3IEBAIGZvciBteSAkdGVzdCAoQHRlc3RzKSB7CiAgICAgICAgICAgICB3 cml0ZVRvRmlsZSgiJHRlc3RSZXN1bHRzRGlyZWN0b3J5LyRiYXNlLSRhY3R1YWxUYWcucG5nIiwg JGFjdHVhbFBORyk7CiAgICAgICAgICAgICB3cml0ZVRvRmlsZSgiJHRlc3RSZXN1bHRzRGlyZWN0 b3J5LyRiYXNlLSRkaWZmc1RhZy5wbmciLCAkZGlmZlBORyk7CiAKLSAgICAgICAgICAgIG15ICRl eHBlY3RlZFBpeGVsRGlyID0gZXhwZWN0ZWREaXJlY3RvcnlGb3JUZXN0KCRiYXNlLCAkaXNUZXh0 LCAicG5nIik7CisgICAgICAgICAgICBteSAkZXhwZWN0ZWRQaXhlbERpciA9IGV4cGVjdGVkRGly ZWN0b3J5Rm9yVGVzdCgkYmFzZSwgMCwgInBuZyIpOwogICAgICAgICAgICAgY29weSgiJGV4cGVj dGVkUGl4ZWxEaXIvJGJhc2UtJGV4cGVjdGVkVGFnLnBuZyIsICIkdGVzdFJlc3VsdHNEaXJlY3Rv cnkvJGJhc2UtJGV4cGVjdGVkVGFnLnBuZyIpOwogCiAgICAgICAgICAgICBvcGVuIERJRkZIVE1M LCAiPiR0ZXN0UmVzdWx0c0RpcmVjdG9yeS8kYmFzZS0kZGlmZnNUYWcuaHRtbCIgb3IgZGllOwo=