20141 2008-07-23 06:20:48 -0700 Web Inspector: cannot call unbound reference to console.log 2016-05-02 18:07:48 -0700 1 1 1 Unclassified WebKit Web Inspector 528+ (Nightly build) All All RESOLVED DUPLICATE 157286 InRadar P2 Normal --- 1 wdm webkit-unassigned aandrey ap aroben arv burg chrisjshull commit-queue costan darin eflews.bot esprehn+autocc getify glenn graouts gyuyoung.kim joepeck kangax mathias ojan.autocc oliver sindresorhus timothy webkit-bug-importer oldest_to_newest 86725 0 wdm 2008-07-23 06:20:48 -0700 I'm trying to do cross-browser logging, so I set the variable 'log' to point to the browser-specific log function, in WebKit's case, console.log: var log = console.log; log('ff'); --> TypeError: Type error console.log() works fine, but log() is broken. 86735 1 22453 ap 2008-07-23 09:01:34 -0700 Created attachment 22453 test case 86736 2 ap 2008-07-23 09:06:38 -0700 That's because logging as currently implemented in WebKit requires a page pointer, which is stored in the console object. So, the console.log function cannot be called on any other object. 86741 3 sam 2008-07-23 10:04:14 -0700 I do not think this is a bug. One cannot expect a generic function to work without a this object. You would not expect, for instance, var g = document.getElementsById; g("foo"); to work. 86806 4 aroben 2008-07-23 20:35:50 -0700 A possible solution would be: var log = function() { console.log(arguments) } I agree that this doesn't really seem like a bug, though it is perhaps a little surprising. 86817 5 wdm 2008-07-23 23:17:57 -0700 Thanks guys, my approach worked in both FF+Firebug and Opera so I assumed it was a WebKit bug. The error message was also confusing. But your explanation makes complete sense. @Adam: your example always outputs the string 'Arguments' - works fine in FF though ;-) This works: var log = function() { console.log.apply(console,arguments) }; 86818 6 ap 2008-07-23 23:46:37 -0700 (In reply to comment #3) > I do not think this is a bug. One cannot expect a generic function to work > without a this object. Well, you can expect that from a function that is documented as being generic, or one that is not formally specified, but is generic in other implementations. 316975 7 glenn 2010-12-03 12:49:08 -0800 Please reevaluate this. Creating a wrapper causes an annoying problem: every stack trace from console logs ends at the wrapper you created, instead of the actual point of the log. For example, console.log("test 1"); var x = function() { console.log.apply(console, arguments); } x("test 2"); x("test 3"); x("test 4"); usually shows: test 1 logging.js:1 test 2 logging.js:2 test 3 logging.js:2 test 4 logging.js:2 It renders the stack frame useless in console summaries--every log using that function will always say "logging.js:2". Making the logging functions not depend on the this avoids this problem. Console should just be a namespace, and the functions in it should be closures on any objects they need access to. (The more general fix for this is to add a parameter to the logging functions, giving a hint of how many stack frames should be ignored. That's particularly useful when you really do need to wrap logging, eg. to intercept and tee the log somewhere else.) 340915 8 kangax 2011-01-27 10:21:49 -0800 Would love to see this behavior changed as well. It is indeed quite inconvenient to have to `function(){console.log.apply(console, arguments)}` or `console.log.bind(console)` all the time. 873579 9 costan 2013-04-10 23:37:09 -0700 *** Bug 114406 has been marked as a duplicate of this bug. *** 873582 10 197513 costan 2013-04-10 23:56:51 -0700 Created attachment 197513 Patch 873583 11 commit-queue 2013-04-10 23:59:21 -0700 Attachment 197513 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/fast/dom/Window/console-unbound-functions-expected.txt', u'LayoutTests/fast/dom/Window/console-unbound-functions.html', u'Source/WebCore/ChangeLog', u'Source/WebCore/bindings/scripts/CodeGeneratorJS.pm', u'Source/WebCore/bindings/scripts/IDLAttributes.txt', u'Source/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.cpp', u'Source/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.h', u'Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.cpp', u'Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.h', u'Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp', u'Source/WebCore/bindings/scripts/test/JS/JSTestObj.h', u'Source/WebCore/bindings/scripts/test/ObjC/DOMTestObj.h', u'Source/WebCore/bindings/scripts/test/ObjC/DOMTestObj.mm', u'Source/WebCore/bindings/scripts/test/TestObj.idl', u'Source/WebCore/page/Console.cpp', u'Source/WebCore/page/Console.h', u'Source/WebCore/page/Console.idl']" exit_code: 1 Source/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.h:188: The parameter name "str" adds no information, so it should be removed. [readability/parameter_name] [5] Total errors found: 1 in 18 files If any of these errors are false positives, please file a bug against check-webkit-style. 873584 12 costan 2013-04-10 23:59:37 -0700 (copied from the description of #114406) In order to achieve this, the patch introduces the [LenientThis] WebKitIDL attribute, which is heavily inspired from the LenientThis WebIDL. http://www.w3.org/TR/WebIDL/#LenientThis I implemented LenientThis for methods. I figured the only way to not require a specific type for "this" is to completely ignore the value, so a LenientThis method calls a static method in WebCore. A LenientMethod is similar to a static method, but it can be accessed as a property of the interface instances, instead of being a property of the interface object. I hope this makes sense, and I look forward to feedback. 873988 13 197513 darin 2013-04-11 11:08:40 -0700 Comment on attachment 197513 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=197513&action=review I’m going to say review+ but I think we can improve this further. > Source/WebCore/bindings/scripts/CodeGeneratorJS.pm:191 > - > + It’s strange to do all this whitespace stripping. I’m not sure we normally encourage that sort of thing. >> Source/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.h:188 >> + void lenientThisMethod(const WebDOMString& str); > > The parameter name "str" adds no information, so it should be removed. [readability/parameter_name] [5] The style queue complaint is not new to the patch, and not important. The best way to fix it would be to omit argument names entirely in these automatically generated declarations. I don’t think we need the names in these files. But this is specific to the C++ binding. I don’t even know the status of that binding. Who is using it? Can we remove it? Worth discussing. > Source/WebCore/page/Console.cpp:272 > +Page* Console::pageFromScriptState(ScriptState* state) This should be a free function at the top of the file, not a Console member function. > Source/WebCore/page/Console.cpp:280 > + Console* console = window->console(); > + if (!console) > + return 0; > + return console->page(); This seems strange. To get from DOMWindow to page, I would not suggest going through the console. It will work, but it’s not the right way to do things, even inside the Console class. The right way is to walk from DOMWindow to Page, staying with the core classes such as Document, Frame, and Page. > Source/WebCore/page/Console.h:88 > + inline static Page* pageFromScriptState(ScriptState*); I believe the inline here is non-helpful and should be omitted. I suggest having this be a free function, not a Console member function. 874183 14 197675 costan 2013-04-11 14:46:25 -0700 Created attachment 197675 Patch 874185 15 commit-queue 2013-04-11 14:47:59 -0700 Attachment 197675 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/fast/dom/Window/console-unbound-functions-expected.txt', u'LayoutTests/fast/dom/Window/console-unbound-functions.html', u'Source/WebCore/ChangeLog', u'Source/WebCore/bindings/scripts/CodeGeneratorJS.pm', u'Source/WebCore/bindings/scripts/IDLAttributes.txt', u'Source/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.cpp', u'Source/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.h', u'Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.cpp', u'Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.h', u'Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp', u'Source/WebCore/bindings/scripts/test/JS/JSTestObj.h', u'Source/WebCore/bindings/scripts/test/ObjC/DOMTestObj.h', u'Source/WebCore/bindings/scripts/test/ObjC/DOMTestObj.mm', u'Source/WebCore/bindings/scripts/test/TestObj.idl', u'Source/WebCore/page/Console.cpp', u'Source/WebCore/page/Console.h', u'Source/WebCore/page/Console.idl']" exit_code: 1 Source/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.h:188: The parameter name "str" adds no information, so it should be removed. [readability/parameter_name] [5] Total errors found: 1 in 18 files If any of these errors are false positives, please file a bug against check-webkit-style. 874187 16 197676 costan 2013-04-11 14:52:20 -0700 Created attachment 197676 Patch 874190 17 commit-queue 2013-04-11 14:55:14 -0700 Attachment 197676 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/fast/dom/Window/console-unbound-functions-expected.txt', u'LayoutTests/fast/dom/Window/console-unbound-functions.html', u'Source/WebCore/ChangeLog', u'Source/WebCore/bindings/scripts/CodeGeneratorJS.pm', u'Source/WebCore/bindings/scripts/IDLAttributes.txt', u'Source/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.cpp', u'Source/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.h', u'Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.cpp', u'Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.h', u'Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp', u'Source/WebCore/bindings/scripts/test/JS/JSTestObj.h', u'Source/WebCore/bindings/scripts/test/ObjC/DOMTestObj.h', u'Source/WebCore/bindings/scripts/test/ObjC/DOMTestObj.mm', u'Source/WebCore/bindings/scripts/test/TestObj.idl', u'Source/WebCore/page/Console.cpp', u'Source/WebCore/page/Console.h', u'Source/WebCore/page/Console.idl']" exit_code: 1 Source/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.h:188: The parameter name "str" adds no information, so it should be removed. [readability/parameter_name] [5] Total errors found: 1 in 18 files If any of these errors are false positives, please file a bug against check-webkit-style. 874191 18 costan 2013-04-11 14:56:06 -0700 Darin, thank you very much for your feedback! I uploaded a new patch that addresses most of it. Regarding the style error in the bindings, I'm new to WebKit, so I wouldn't know who uses which bindings :) Still, I can look into changing the code generator. I think that the change will cause a big diff in the test outputs, so I'd prefer to do it in a separate patch. Do you think this makes sense? 874332 19 glenn 2013-04-11 19:18:01 -0700 This shouldn't work. Comment #7 is solved simply by using bind(); calling a bound console function does work as expected (it may not have back in 2010, but it does today). You can't pull random member functions off of objects and have it work. You can't say "g = document.getElementById; g('foo')". That's what bind() is for. This might make a little sense if console.log acted like a static function (eg. if it didn't actually care about the console object), but it doesn't; which console.log you call determines which console it goes to. Please don't add new weird things to the web. (In reply to comment #12) > In order to achieve this, the patch introduces the [LenientThis] WebKitIDL attribute, which is heavily inspired from the LenientThis WebIDL. > http://www.w3.org/TR/WebIDL/#LenientThis Notice that WebIDL has a big angry red box explicitly warning against this. 874341 20 costan 2013-04-11 20:13:17 -0700 Glenn, thank you vey much for your feedback! I hope you will reconsider your opinion, based on the following arguments. (1) I think there is great value in having developers be able to use "console.log" in a bound form while debugging any Web page / application. Changing the source code of the page I'm debugging might be a hassle. Also, if I'm debugging a library using its unit tests page, I wouldn't want to mess with the browser environment. bind works, but having to use it breaks the "I'll just type this one-liner in the Web Inspector" flow. (1') All the developers that I talked to were happy to hear about this possible change. I think this is worth a bit of extra complexity in the code. Being able to pass console.{log, warn, error....} as an async is a nice little useful debugging tool, and having to do some setup from it detracts from this. (2) "console" is a singleton, so we don't really need "this" to decide what to do. To a Web developer, the TypeError seems like being fussy for no reason. To the best of my knowledge, getElementById works for any Document and DocumentFragment instance, so calling it without a value for "this" would be ambiguous. (3) The WebIDL warning mentions specifications, and WebKit is an implementation. (4) The WebIDL warning also mentions "unless for compatibility reasons". Using console.log unbound works in Firefox, so one could argue that this helps compatibility. The complaints in this Chromium bug, though unverified, seem to indicate that some developers assume console.log will work. http://crbug.com/167911 Sorry for the long response, and thank you very much for reading it! 874343 21 glenn 2013-04-11 20:44:17 -0700 (In reply to comment #20) > Glenn, thank you vey much for your feedback! I hope you will reconsider your opinion, based on the following arguments. > > (1) I think there is great value in having developers be able to use "console.log" in a bound form while debugging any Web page / application. Changing the source code of the page I'm debugging might be a hassle. Also, if I'm debugging a library using its unit tests page, I wouldn't want to mess with the browser environment. bind works, but having to use it breaks the "I'll just type this one-liner in the Web Inspector" flow. Sorry, I don't know what you're referring to. You can just call console.log in web consoles, and anywhere you might say "x = console.log" you can say "x = console.log.bind(console)". > (1') All the developers that I talked to were happy to hear about this possible change. I thought this was a good idea a couple years ago, too (comment #7). I was mistaken. Unless those people join the conversation and make technical arguments one way or the other, popularity contests aren't useful. > I think this is worth a bit of extra complexity in the code. Being able to pass console.{log, warn, error....} as an async is a nice little useful debugging tool, and having to do some setup from it detracts from this. Having to say ".bind(something)" if you want to take a reference to a function and use it as a standalone function is universal to the platform. Having to do the same thing here that you have to do everywhere else enhances, not detracts from, the platform. > (2) "console" is a singleton, so we don't really need "this" to decide what to do. To a Web developer, the TypeError seems like being fussy for no reason. To the best of my knowledge, getElementById works for any Document and DocumentFragment instance, so calling it without a value for "this" would be ambiguous. No, console is definitely not a singleton. https://zewt.org/~glenn/test-window-console.html Here, we have two console objects, one for each window, and logs to each go to the corresponding window's console. > (3) The WebIDL warning mentions specifications, and WebKit is an implementation. Do you think that APIs that lack a specification should do things which are considered bad practice for those that do? > (4) The WebIDL warning also mentions "unless for compatibility reasons". Using console.log unbound works in Firefox, so one could argue that this helps compatibility. This change wasn't proposed for web-compatibility reasons. I think you're hunting for arguments. > The complaints in this Chromium bug, though unverified, seem to indicate that some developers assume console.log will work. This incorrect assumption can be made for every single API on the platform. You can just as easily try "create = document.createElement; create('div')", or any of the hundreds of other functions on objects. Making it work for console isn't going to reduce confusion; it'll only make the platform more inconsistent, and make people even more confused when they find that this works with console, but pretty much nothing else. 874490 22 costan 2013-04-12 05:56:59 -0700 Glenn, I'm obviously going to defer to you on this, but here are a couple more thoughts. First, the main goal of console.log and its cousins is to speed up development. It's already very different from the other Web APIs, because it "talks" to another world (the debugging console), and it has "superpowers" (e.g., it can enumerate all the properties of an object when dumping it). I think that making console.log as useful as possible should trump consistency with DOM APIs, because it's not really a DOM API. (for example, it's in node.js as well). At the same time, I recognize I'm really biased, because I think that speeding up Web development would give us cool new toys to play with :) Also, since you brought up the issue of a specification, I think console should have been Console, and Console.log should have behaved like IDBKeyRange.upperBound, which is a static method. I also think that being able to log to another window's console is a bit confusing, but at least that's self-inflicted pain. Last, having a Console singleton would justify exposing it to Web Workers. (it'd work in an obvious way for dedicated workers, shared workers are a bit more difficult) But that's water under the bridge now, since console.log is a de-facto standard. Second, in my experience teaching Web development to MIT students, people learning JavaScript are thoroughly confused by "this" anyway, because of the way it's bound in DOM events. I conjecture that by the time they figure out "this", people would be able to handle the console inconsistency, and be grateful that the browser developers tried to make console.log more useful for async APIs. In summary, I think Firefox got this right. Last, if you're really against special-casing console.{log, info, error, ...}, would you be willing to entertain the idea of supplying bound console functions, in a manner similar to "dir", in the Inspector? Once again, sorry for the long answer, and thank you very much for reading it! 874530 23 glenn 2013-04-12 06:18:08 -0700 (In reply to comment #22) > Glenn, I'm obviously going to defer to you on this, but here are a couple more thoughts. I'm just another web developer offering his input--the decision is up to WebKit folks. > First, the main goal of console.log and its cousins is to speed up development. It's already very different from the other Web APIs, because it "talks" to another world (the debugging console), and it has "superpowers" (e.g., it can enumerate all the properties of an object when dumping it). I think that making console.log as useful as possible should trump consistency with DOM APIs, because it's not really a DOM API. (for example, it's in node.js as well). At the same time, I recognize I'm really biased, because I think that speeding up Web development would give us cool new toys to play with :) If console.log was actually inconvenient, I might agree, but I don't think it is. > Also, since you brought up the issue of a specification, I think console should have been Console, and Console.log should have behaved like IDBKeyRange.upperBound, which is a static method. I also think that being able to log to another window's console is a bit confusing, but at least that's self-inflicted pain. Last, having a Console singleton would justify exposing it to Web Workers. (it'd work in an obvious way for dedicated workers, shared workers are a bit more difficult) But that's water under the bridge now, since console.log is a de-facto standard. Web Workers can still support console (and really, really needs to), but it'll take some thought to figure out which window's console logs should go to. That's simple for dedicated workers, but shared workers are trickier. (This is a more general problem, see http://lists.w3.org/Archives/Public/public-whatwg-archive/2013Mar/0283.html, so maybe a general solution will be found.) > Second, in my experience teaching Web development to MIT students, people learning JavaScript are thoroughly confused by "this" anyway, because of the way it's bound in DOM events. I conjecture that by the time they figure out "this", people would be able to handle the console inconsistency, and be grateful that the browser developers tried to make console.log more useful for async APIs. In summary, I think Firefox got this right. I think this is a case of "everyone agrees consistency is good, and everyone thinks their case is the exception". Adding inconsistencies to the platform is bad, since it's a big, complex system, and I don't see the justification for this one. Where is console.log not useful for async APIs? > Last, if you're really against special-casing console.{log, info, error, ...}, would you be willing to entertain the idea of supplying bound console functions, in a manner similar to "dir", in the Inspector? I won't be too bothered by things WebKit does in web consoles, since it doesn't affect the Web--it's an implementation detail. But, I still don't understand the use case. I've never had to say "console.log.bind(console)" in a console. 874562 24 kangax 2013-04-12 06:28:58 -0700 (In reply to comment #19) > This shouldn't work. Comment #7 is solved simply by using bind(); calling a bound console function does work as expected (it may not have back in 2010, but it does today). > > You can't pull random member functions off of objects and have it work. You can't say "g = document.getElementById; g('foo')". That's what bind() is for. > > This might make a little sense if console.log acted like a static function (eg. if it didn't actually care about the console object), but it doesn't; which console.log you call determines which console it goes to. Please don't add new weird things to the web. I don't see anything new and weird about `log` being bound to its console. Host objects returning "unknown" typeof in IE and blowing up on simple property access — that was weird. And even that was allowed by the spec. The binding is not a deal breaker but it's certainly a slight inconvenience to bind it manually in cases when it's not called as a method of console (e.g. `someArray.forEach(console.log)`). And if it is bound, which problems does it cause? Maybe I'm missing something? FWIW, both Firefox and Opera make it bound. IE10 doesn't. So that makes it 2-vs-2, and — once Opera switches to webkit — 3-vs-1. 874765 25 arv 2013-04-12 08:49:42 -0700 It is not necessarily bad to make it bound by default but it is an inconsistency that I don't think pays the price. Lets base this on real world compat issues instead. For example if x% of the Alexa top 500 breaks due to this we should add this wart. 874841 26 costan 2013-04-12 10:43:57 -0700 @Glenn: The use case is exploring or debugging APIs. For example, if I want to see how DOM level 3 IME input events work, I can enter something along the lines of "document.querySelector('#id').oncompositionupdate = console.log" in the Web Inspector and start interacting with the field. An example of using asynchronous APIs is reading a file from someone's Dropbox using my dropbox.js library. The easiest way to see how that works is to type the line below in the Web Inspector. client.readFile("/path/to/file", console.log) Another example is learning / debugging jQuery's XHR behavior. jQuery.ajax({url: "/path/to/json", dataType: "json", success: console.info, error: console.warn) @Erik: I would hope that the sites with the most traffic have a release process that ensures they wouldn't break in WebKit browsers, and I would assume that at least some have their own logging mechanism built on top of console.log. At most, some small sites will have short outages until people complain and the logging statements get fixed / removed. The biggest share of the price of the current console.log isn't site breakage. It is slowing down the people who build sites, by not being as versatile as it could be. My story below (which you can skip) illustrates this. <blahblah> The first time I tried to use console.log as a callback, I was happy for realizing that it should work as a callback, since JavaScript is a functional language. Then I saw the Type error and realized what was going on. I was immediately curious if Firefox works the same way, so I opened it up and tried it there. Afterwards I figured I'm not going to bother writing "function(x) { console.log(x); }" (didn't think of bind() on the spot, it's not that much easier to type though). So I moved back to my editor, added a logging statement, and refreshed the page. By the end of this, my flow was interrupted. Next time (a few months later) I bumped into another case where I'd have liked to pass console.log to a callback, I checked quickly to see if it still throws a TypeError, grumbled and moved on. Later, I stumbled upon the Chromium bug, and a few days ago I stumbled upon the issue again, and was in a good position to address it. </blahblah> The main takeaway here is that most developers running into this won't consider it serious enough to complain about. It's just a tiny hurdle, but removing tiny hurdles can add up to quite a bit in the long run. 874930 27 getify 2013-04-12 13:30:34 -0700 would the browsers allow `console.log = console.log.bind(console)`, basically just overwriting the built-in one with a hard-bound version, so that it can be passed around at will? you could even feature-detect which browsers this was necessary in via a try/catch. 875257 28 glenn 2013-04-13 17:38:10 -0700 Note that if we want console.log, etc., to act like they're pre-bound (as if you did "console.log = console.log.bind(this)", then it doesn't look like this is the right patch. This patch is described as making console.log a static function, which is quite different and means the logging functions can no longer go to the console for the window they're invoked on. I don't know of any WebIDL feature that describes "prebinding", but I don't think this is LenientThis. (In reply to comment #26) > "document.querySelector('#id').oncompositionupdate = console.log" Saving people 14 characters of typing--".bind(console)"--isn't a good reason. There are lots of things that slow down development, but this isn't one of them. > Host objects returning "unknown" typeof in IE and blowing up on simple property access — that was weird. And even that was allowed by the spec. The inconsistencies and weirdnesses already in the platform should never be used as an argument to add more of them. (In reply to comment #24) > FWIW, both Firefox and Opera make it bound. IE10 doesn't. So that makes it 2-vs-2, and — once Opera switches to webkit — 3-vs-1. (2 vs. 1, actually--Opera won't count as a separate browser any more than Chrome does.) IE9 did what Firefox does, and if that hadn't changed I'd probably agree that WebKit should just follow suit for the sake of interop, but IE10 matches WebKit. With the current versions of IE and WebKit agreeing on behavior here, hopefully Firefox will change to match. 875391 29 getify 2013-04-14 12:41:21 -0700 I really can't think of any reason for the `log()` function (and all the other console.*) to be "unbound", or rather, rebindable, to other objects. Why wouldn't you just want all of them to act as if they're hard bound to the console and/or window object? What use case would it serve to leave them re-bindable (whereas several use-cases in this thread have already pointed out shorter typing and nicer abstractability as reasons why the defaulted hard-binding would be nice)? I understand the general argument of "so it works like all other methods", but in JS in general, there's lots of usefulness to be able to borrow functions and manually set their `this` object... except in the specific case of the console.* functions, I'm just not seeing that usefulness. Am I missing something we'd want to preserve? Seems to me like the lesser evil would be to remove some surprises from the use cases stated here, at the almost zero cost/risk of surprising someone who's intentionally doing something very strange like trying to rebind `log()` to some other object. 875394 30 glenn 2013-04-14 13:30:31 -0700 (In reply to comment #29) > I really can't think of any reason for the `log()` function (and all the other console.*) to be "unbound", or rather, rebindable, to other objects. Why wouldn't you just want all of them to act as if they're hard bound to the console and/or window object? What use case would it serve to leave them re-bindable (whereas several use-cases in this thread have already pointed out shorter typing and nicer abstractability as reasons why the defaulted hard-binding would be nice)? The burden of showing use cases is on people arguing to do something unusual, not on the ones saying we shouldn't, just as you don't get to say "what are the use cases for *not* implementing my feature proposal?". ("Shorter typing" to save 14 characters in uncommon scenarios isn't something that I can take seriously, and I don't know what you mean by "nicer abstractability".) > I understand the general argument of "so it works like all other methods", but in JS in general, there's lots of usefulness to be able to borrow functions and manually set their `this` object... except in the specific case of the console.* functions, I'm just not seeing that usefulness. Am I missing something we'd want to preserve? Am I missing something that makes the console functions special and different from everything else? It's just another API like any other, and a particularly simple and mundane one at that. > Seems to me like the lesser evil would be to remove some surprises from the use cases stated here, at the almost zero cost/risk of surprising someone who's intentionally doing something very strange like trying to rebind `log()` to some other object. This is a non-argument, since you could make it for pretty much every API on the platform. 875397 31 costan 2013-04-14 13:59:51 -0700 Kyle, yes, the statement that you suggested would work. I'm not sure how to do the feature detection without risking spamming the log, though. If this patch doesn't work out, I might have to write some extension that effectively does that in the developer tools. Glenn, I'm sorry, I'm having a really hard time following your argument. "There are lots of things that slow down development, but this isn't one of them." seems to imply that this change won't make developers' life better. The fact that I took the time to figure out how console works in WebKit and put together this patch means that it would make _my_ life better. Also, my experience (and the stars on the Chromium bug) indicate that there is a class of people whose lives will be better, which is why I'm trying to get WebKit fixed instead of implementing a personal solution. Given that this change would make some people's lives better, I would like to understand how it would make your life worse, so we can see if there's a way to make things work for everyone. You can still use "console" the way you used to. I think that consistency is a good goal to aim for, because it helps us learn the platform faster, which makes us more productive. At the same time, it's important to remember that consistency is a means to achieve efficiency, not a goal on its own. Also, sorry for repeating myself, but this change doesn't cripple console.log, so it still works in the way that you'd expect, based on DOM APIs. It only makes console.log more powerful than the DOM APIs. I think it's reasonable to expect that a debugger is more powerful than the platform APIs. For example, I will expect the Web Inspector to show me an object's ES6 private name properties and their values, even though the (draft) specification clearly says that they shouldn't be visible without the names. Last point on consistency: I don't think IE's behavior is very relevant. During my Web development classes at MIT, the Microsoft folks admitted that they develop on Chrome and test on IE, so I don't think IE sets a good example for developer friendliness. FWIW, node.js's console.log is a function, but again I think this patch should be considered based on usefulness. I think the real cost of this patch is the extra complexity in the WebKit code. I also think it's hard to objectively assess whether the complexity is worth the efficiency boost I mentioned above. For whatever it's worth, I plan to help with any necessary follow-up work (like I did in #111255), and to help revert this change if ends up being a major pain down the line. 875398 32 costan 2013-04-14 14:01:23 -0700 Erik, I'm a bit confused by your position. The equivalent bug in Chromium (http://crbug.com/167911) is tagged M28, so I thought Chromium is planning to adopt this change. 875399 33 timothy 2013-04-14 14:02:05 -0700 There is no reason to feature detect. You can unconditionally do `console.log = console.log.bind(console)`. 875401 34 getify 2013-04-14 14:15:09 -0700 (In reply to comment #30) >> What use case would it serve to leave them re-bindable...? > > The burden of showing use cases is on people arguing to do something unusual, not on the ones saying we shouldn't, just as you don't get to say "what are the use cases for *not* implementing my feature proposal?". Fortunately, several use cases have already been presented in this thread, so I don't really feel the burden to repeat them. That you don't like or agree with them is not sufficient grounds to imply that none have been presented. I was merely pointing out that some use-cases do exist where this hard-binding would be nice (as listed), and asking if there are any contrary use-cases that I was missing. Sounds like there are none, or you don't care to spend the time to illustrate any. > ("Shorter typing" to save 14 characters in uncommon scenarios isn't something that I can take seriously It's a little deeper than "shorter typing" because what we're actually suggesting is that there cases where people are using `console.log()` without understanding the caveats that `console` is not just a namespace for the generic `log()` name, but a critical contextual component to identifying which place the log output should be directed. I get that, and I wish everyone did, but I think many (maybe even most) don't understand that subtlety, so the loss of context breaking `log()` is confusing and surprising. I myself even worked at Firefox for 9 months, on the developer tools team, and it hadn't occurred to me until reading this thread that there could quite possibly be multiple targets for console output. You can't seriously think that this is a detail that all JS developers just readily and automatically understand. That's *especially* true if you don't do any `this` style programming at all in JS, where you prefer for instance module patterns and closures, and you almost never deal with loss of `this` context. You can be quite an experienced and prolific JS coder and never run into those issues, and then you merrily come along and try to deal with `console.log()` for some debugging, and you may get surprised. Point being, it's not just about the characters, and I think you're being a bit too glib in suggesting that is the main point of this thread. ------- That having been said, I cannot deny that saving the characters in this specific sort of usage (which I do *all the time*) would also be really nice: `Object.keys(myobj).forEach(console.log)` as opposed to: `Object.keys(myobj).forEach(console.log.bind(console))` > I don't know what you mean by "nicer abstractability".) I thought there was already some implication of "logging abstractions" earlier in the thread, but I'll give one example to put slightly more concrete on it. Imagine I have a multi-purpose logger utility in JS... in some circumstances, such as production, I don't want logs going to the JS console, but instead want to capture and transmit them to the server. In other cases, like dev, I do want them to go to the console (and maybe also get logged offsite). Now, imagine, this API passes around a `log` function through my various contexts, that all my devs use to write out. It would be nicer, in terms of abstraction (and even narrowly, for performance), if I could pass around an actual reference to the console.log() function, for dev purposes, and only do a wrapped form of it when I need to hijack in production. But importantly, it'd be nice if the devs writing these `log(..)` statements didn't know those details, and didn't have to care whether the real or fake `log()` was in play. We can go down the rabbit hole further if you still don't think there's any cases where log abstractions exist or are useful, but this is just one of many ways I could see a defaulted hard-binding being slightly nicer. > > I understand the general argument of "so it works like all other methods", but in JS in general, there's lots of usefulness to be able to borrow functions and manually set their `this` object... except in the specific case of the console.* functions, I'm just not seeing that usefulness. Am I missing something we'd want to preserve? > > Am I missing something that makes the console functions special and different from everything else? It's just another API like any other, and a particularly simple and mundane one at that. Yes, I guess you are missing what makes them special. I thought that was self-obvious so I didn't get specific at first. In normal `this` style JS programming, if there's a function like: ``` var obj = { me: "obj", identify: function() { alert(this.me); } }; ``` There's a variety of ways that I can borrow that `obj.identify()` and use him against my own objects (overriding his `this`), so it's nice that, by default, `obj.identify()` has this re-bindability, through `call()` & `apply()`, as well as `new`. Of course, you could come along and hard-bind the reference with `obj.identify = obj.identify.bind(obj)`, but by default, his unbound nature can be quite useful and flexible. However, by contrast, the core implementation of the `log()` function, as far as I'm aware, could not possibly be borrowed and reused against any random JS object in any useful way, as certainly rebinding `log()`'s `this` to something other than the legitimate `console` object in a specific window context would NOT result in any successful logging. At best it would silently fail, but it seems pretty likely it would error in an ugly way. Point being, in normal JS, methods of objects default to being non-hard-bound so that they can more flexibly be reused and borrowed and such, but the console.* methods really have no value in being borrowed, because their very nature constricts them to use against a well defined window context. Hence, my core argument that since these methods are not like all other JS methods, then having them, by default, hard-bound to the context they need to be bound to, **might** be justifiable. > > Seems to me like the lesser evil would be to remove some surprises from the use cases stated here, at the almost zero cost/risk of surprising someone who's intentionally doing something very strange like trying to rebind `log()` to some other object. > > This is a non-argument, since you could make it for pretty much every API on the platform. No, not any API. Most APIs exposed to JS benefit from re-bindability. These console ones don't seem to have any re-bindability benefit, so I think they're at least potential candidates for special handling. 875403 35 glenn 2013-04-14 14:59:31 -0700 > However, by contrast, the core implementation of the `log()` function, as far as I'm aware, could not possibly be borrowed and reused against any random JS object in any useful way, Two problems: - This isn't something special about console. Calling Element.prototype.appendChild on something that isn't an Element, or Worker.prototype.terminate on something that isn't a Worker, doesn't make any more sense than calling console.log on something that isn't a console. If we take "not useful to call on random objects" as a reason to do this, then we'll be doing it with tons of APIs--which is why we shouldn't. - This isn't a reason why methods on other APIs aren't bound to their object. After all, if you do want to call a method--say, appendChild--on an interface on something other than an instance of the object, you wouldn't say "document.appendChild.call(otherObject, node)", you get the method from the interface: "HTMLElement.prototype.appendChild.call(otherObject, node)". Binding the functions wouldn't prevent this, but we still don't do it. I'm running low on time and energy for this, and if the discussion so far hasn't convinced whoever in WebKit's process needs to be convinced, I don't think another five pages of discussion will help. So, unless new information arises, I'll be winding down in this discussion for now. 875416 36 costan 2013-04-14 16:17:18 -0700 Darin, I prepared a patch for getting rid of the style errors in the C++ bindings. https://bugs.webkit.org/show_bug.cgi?id=114596 880131 37 197676 eflews.bot 2013-04-23 14:33:43 -0700 Comment on attachment 197676 Patch Attachment 197676 did not pass efl-wk2-ews (efl-wk2): Output: http://webkit-queues.appspot.com/results/168145 967053 38 webkit-bug-importer 2014-01-12 15:21:49 -0800 <rdar://problem/15801400> 976997 39 197676 kling 2014-02-05 11:22:24 -0800 Comment on attachment 197676 Patch Clearing review flag on patches from before 2014. If this patch is still relevant, please reset the r? flag. 1002861 40 aandrey 2014-04-22 03:53:22 -0700 IMO "console.log" is no more special than, for example, "performance.now", which also does not work being called unbound. Actually, "performance.now" does seem even more confusing to me, since there is a similar static "Date.now" that works if called unbound. For example, the following code, that did happen in my practice, will not work as expected in WebKit: var tick = (window.webkitPerformance || window.performance || Date).now; var start = tick(); //... var time = tick() - start; I don't have a strong position whether to allow unbound console.log or not, but at least we'd better be consistent with similar APIs, like performance.now 1056640 41 burg 2014-12-17 17:19:53 -0800 I recommend resolving this as WONTFIX. It adds complexity and solves a tiny use case. If adding console.log = console.log.bind(console) is seriously slowing down or complicating someone's development, then I'm really curious why that is so. And besides, what browsers don't support console.log in 2014? 1154921 42 sindresorhus 2016-01-12 15:16:19 -0800 Relevant whatwg/console issue: https://github.com/whatwg/console/issues/3 1189489 43 timothy 2016-05-02 13:15:54 -0700 Chrome/V8 will soon do this. https://codereview.chromium.org/1859293002 1189561 44 joepeck 2016-05-02 16:45:09 -0700 I agree. I'm going to address this in: <https://webkit.org/b/157286> Make console a namespace object (like Math/JSON), allowing functions to be called unbound 1189595 45 darin 2016-05-02 18:07:48 -0700 *** This bug has been marked as a duplicate of bug 157286 *** 22453 2008-07-23 09:01:34 -0700 2008-07-23 09:01:34 -0700 test case log.html text/html 159 ap PHNjcmlwdD4KdHJ5IHsKICAgIHZhciBsb2dnID0gY29uc29sZS5sb2c7CiAgICBsb2dnKCdmZicp OwogICAgY29uc29sZS5sb2cuY2FsbCh3aW5kb3csICJmb28iKTsKICAgIGFsZXJ0KCJTVUNDRVNT Iik7Cn0gY2F0Y2ggKGV4KSB7CiAgICBhbGVydChleCkKfQo8L3NjcmlwdD4K 197513 2013-04-10 23:56:51 -0700 2013-04-11 14:46:19 -0700 Patch bug-20141-20130411025631.patch text/plain 36682 costan SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDE0ODE1OSkKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDQ5IEBACisyMDEzLTA0LTEwICBWaWN0b3Ig Q29zdGFuICA8Y29zdGFuQGdtYWlsLmNvbT4KKworICAgICAgICBDYWxsaW5nIGNvbnNvbGUue2xv ZywgaW5mbywgZXJyb3IsIC4uLn0gc2hvdWxkIG5vdCByZXF1aXJlIHRoaXMgPT09IGNvbnNvbGUK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTExNDQwNgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRlc3Q6IGZh c3QvZG9tL1dpbmRvdy9jb25zb2xlLXVuYm91bmQtZnVuY3Rpb25zLmh0bWwKKworICAgICAgICAq IGJpbmRpbmdzL3NjcmlwdHMvQ29kZUdlbmVyYXRvckpTLnBtOiBpbXBsZW1lbnRlZCB0aGUgW0xl bmllbnRUaGlzXSBtZXRob2QgYXR0cmlidXRlCisgICAgICAgIChBZGRJbmNsdWRlc0ZvclR5cGVJ bkltcGwpOiB3aGl0ZXNwYWNlIHJlbW92YWwKKyAgICAgICAgKEFkZEluY2x1ZGVzRm9yVHlwZUlu SGVhZGVyKTogd2hpdGVzcGFjZSByZW1vdmFsCisgICAgICAgIChHZW5lcmF0ZUdldE93blByb3Bl cnR5RGVzY3JpcHRvckJvZHkpOiB3aGl0ZXNwYWNlIHJlbW92YWwKKyAgICAgICAgKEdlbmVyYXRl SGVhZGVyKTogW0xlbmllbnRUaGlzXSBtZXRob2RzIGFyZSBzdGF0aWMKKyAgICAgICAgKEdlbmVy YXRlQXR0cmlidXRlc0hhc2hUYWJsZSk6IHdoaXRlc3BhY2UgcmVtb3ZhbAorICAgICAgICAoR2Vu ZXJhdGVJbXBsZW1lbnRhdGlvbik6IFtMZW5pZW50VGhpc10gbWV0aG9kIHNob3VsZCBiZSBpbnZv a2VkIHVzaW5nIHRoZSBzdGF0aWMgbWV0aG9kIHN5bnRheAorICAgICAgICAoR2VuZXJhdGVQYXJh bWV0ZXJzQ2hlY2spOiBbTGVuaWVudFRoaXNdIG1ldGhvZCBzaG91bGQgYmUgaW52b2tlZCB1c2lu ZyB0aGUgc3RhdGljIG1ldGhvZCBzeW50YXggCisgICAgICAgIChHZW5lcmF0ZUltcGxlbWVudGF0 aW9uRnVuY3Rpb25DYWxsKTogd2hpdGVzcGFjZSByZW1vdmFsCisgICAgICAgIChHZXRTVkdQcm9w ZXJ0eVR5cGVzKTogd2hpdGVzcGFjZSByZW1vdmFsCisgICAgICAgIChHZW5lcmF0ZUhhc2hUYWJs ZSk6IHdoaXRlc3BhY2UgcmVtb3ZhbAorICAgICAgICAoTWFrZXNTdGF0aWNDYWxsKTogcmV0dXJu cyB0cnVlIGZvciBtZXRob2RzIHRoYXQgZ2VuZXJhdGUgc3RhdGljIGNhbGxzIGluIFdlYkNvcmUK KyAgICAgICAgKiBiaW5kaW5ncy9zY3JpcHRzL0lETEF0dHJpYnV0ZXMudHh0OiBhZGRlZCB0aGUg W0xlbmllbnRUaGlzXSBtZXRob2QgYXR0cmlidXRlCisgICAgICAgICogYmluZGluZ3Mvc2NyaXB0 cy90ZXN0L0NQUC9XZWJET01UZXN0T2JqLmNwcDogcmVnZW5lcmF0ZWQgdGVzdAorICAgICAgICAq IGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9DUFAvV2ViRE9NVGVzdE9iai5oOiByZWdlbmVyYXRlZCB0 ZXN0CisgICAgICAgICogYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0dPYmplY3QvV2ViS2l0RE9NVGVz dE9iai5jcHA6IHJlZ2VuZXJhdGVkIHRlc3QKKyAgICAgICAgKiBiaW5kaW5ncy9zY3JpcHRzL3Rl c3QvR09iamVjdC9XZWJLaXRET01UZXN0T2JqLmg6IHJlZ2VuZXJhdGVkIHRlc3QKKyAgICAgICAg KiBiaW5kaW5ncy9zY3JpcHRzL3Rlc3QvSlMvSlNUZXN0T2JqLmNwcDogcmVnZW5lcmF0ZWQgdGVz dAorICAgICAgICAqIGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9KUy9KU1Rlc3RPYmouaDogcmVnZW5l cmF0ZWQgdGVzdAorICAgICAgICAqIGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9PYmpDL0RPTVRlc3RP YmouaDogcmVnZW5lcmF0ZWQgdGVzdAorICAgICAgICAqIGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9P YmpDL0RPTVRlc3RPYmoubW06IHJlZ2VuZXJhdGVkIHRlc3QKKyAgICAgICAgKiBiaW5kaW5ncy9z Y3JpcHRzL3Rlc3QvVGVzdE9iai5pZGw6IGFkZGVkIG1ldGhvZCB0aGF0IHRlc3RzIHRoZSBbTGVu aWVudFRoaXNdIGF0dHJpYnV0ZQorICAgICAgICAqIHBhZ2UvQ29uc29sZS5jcHA6IG1hZGUgYSBi dW5jaCBvZiBjb25zb2xlIG1ldGhvZHMgc3RhdGljCisgICAgICAgIChXZWJDb3JlOjpDb25zb2xl OjpkZWJ1Zyk6IGJlY2FtZSBzdGF0aWMKKyAgICAgICAgKFdlYkNvcmU6OkNvbnNvbGU6OmVycm9y KTogYmVjYW1lIHN0YXRpYworICAgICAgICAoV2ViQ29yZTo6Q29uc29sZTo6bG9nKTogYmVjYW1l IHN0YXRpYworICAgICAgICAoV2ViQ29yZTo6Q29uc29sZTo6d2Fybik6IGJlY2FtZSBzdGF0aWMK KyAgICAgICAgKFdlYkNvcmU6OkNvbnNvbGU6OmRpcik6IGJlY2FtZSBzdGF0aWMKKyAgICAgICAg KFdlYkNvcmU6OkNvbnNvbGU6OmRpcnhtbCk6IGJlY2FtZSBzdGF0aWMKKyAgICAgICAgKFdlYkNv cmU6OkNvbnNvbGU6OnRhYmxlKTogYmVjYW1lIHN0YXRpYworICAgICAgICAoV2ViQ29yZTo6Q29u c29sZTo6Y2xlYXIpOiBiZWNhbWUgc3RhdGljCisgICAgICAgIChXZWJDb3JlOjpDb25zb2xlOjp0 cmFjZSk6IGJlY2FtZSBzdGF0aWMKKyAgICAgICAgKFdlYkNvcmU6OkNvbnNvbGU6OmNvdW50KTog YmVjYW1lIHN0YXRpYworICAgICAgICAoV2ViQ29yZTo6Q29uc29sZTo6cGFnZUZyb21TY3JpcHRT dGF0ZSk6IHJlY292ZXJzIENvbnNvbGUgZGF0YSBmcm9tIHRoZSBTY3JpcHRTdGF0ZQorICAgICAg ICAqIHBhZ2UvQ29uc29sZS5oOiBkZWNsYXJlZCB0aGUgbWV0aG9kcyBhYm92ZSB0byBiZSBzdGF0 aWMKKyAgICAgICAgKiBwYWdlL0NvbnNvbGUuaWRsOiBhZGRlZCB0aGUgW0xlbmllbnRUaGlzXSBh dHRyaWJ1dGUgdG8gdGhlIGNvbnNvbGUgbWV0aG9kcyBsaXN0ZWQgYWJvdmUKKwogMjAxMy0wNC0x MCAgQmVuamFtaW4gUG91bGFpbiAgPGJwb3VsYWluQGFwcGxlLmNvbT4KIAogICAgICAgICBNYXNz IHJlbW92ZSBhbGwgdGhlIGVtcHR5IGRpcmVjdG9yaWVzCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9i aW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5lcmF0b3JKUy5wbQo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2Uv V2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5lcmF0b3JKUy5wbQkocmV2aXNpb24gMTQ4 MTA1KQorKysgU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9Db2RlR2VuZXJhdG9ySlMu cG0JKHdvcmtpbmcgY29weSkKQEAgLTE4OCw5ICsxODgsOSBAQCBzdWIgQWRkSW5jbHVkZXNGb3JU eXBlSW5JbXBsCiB7CiAgICAgbXkgJHR5cGUgPSBzaGlmdDsKICAgICBteSAkaXNDYWxsYmFjayA9 IEBfID8gc2hpZnQgOiAwOwotICAgIAorCiAgICAgQWRkSW5jbHVkZXNGb3JUeXBlKCR0eXBlLCAk aXNDYWxsYmFjaywgXCVpbXBsSW5jbHVkZXMpOwotICAgIAorCiAgICAgIyBhZGRpdGlvbmFsIGlu Y2x1ZGVzICh0aGluZ3MgbmVlZGVkIHRvIGNvbXBpbGUgdGhlIGJpbmRpbmdzIGJ1dCBub3QgdGhl IGhlYWRlcikKICAgICBpZiAoJHR5cGUgZXEgIkNhbnZhc1JlbmRlcmluZ0NvbnRleHQyRCIpIHsK ICAgICAgICAgJGltcGxJbmNsdWRlc3siQ2FudmFzR3JhZGllbnQuaCJ9ID0gMTsKQEAgLTIxNSw3 ICsyMTUsNyBAQCBzdWIgQWRkSW5jbHVkZXNGb3JUeXBlSW5IZWFkZXIKIHsKICAgICBteSAkdHlw ZSA9IHNoaWZ0OwogICAgIG15ICRpc0NhbGxiYWNrID0gQF8gPyBzaGlmdCA6IDA7Ci0gICAgCisK ICAgICBBZGRJbmNsdWRlc0ZvclR5cGUoJHR5cGUsICRpc0NhbGxiYWNrLCBcJWhlYWRlckluY2x1 ZGVzKTsKIH0KIApAQCAtNDY0LDkgKzQ2NCw5IEBAIHN1YiBHZW5lcmF0ZUdldE93blByb3BlcnR5 U2xvdEJvZHkKIHN1YiBHZW5lcmF0ZUdldE93blByb3BlcnR5RGVzY3JpcHRvckJvZHkKIHsKICAg ICBteSAoJGludGVyZmFjZSwgJGludGVyZmFjZU5hbWUsICRjbGFzc05hbWUsICRoYXNBdHRyaWJ1 dGVzLCAkaW5saW5lZCkgPSBAXzsKLSAgICAKKwogICAgIG15ICRuYW1lc3BhY2VNYXliZSA9ICgk aW5saW5lZCA/ICJKU0M6OiIgOiAiIik7Ci0gICAgCisKICAgICBteSBAZ2V0T3duUHJvcGVydHlE ZXNjcmlwdG9ySW1wbCA9ICgpOwogICAgIGlmICgkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJpYnV0 ZXMtPnsiQ2hlY2tTZWN1cml0eSJ9KSB7CiAgICAgICAgIGlmICgkaW50ZXJmYWNlTmFtZSBlcSAi RE9NV2luZG93IikgewpAQCAtNDc3LDEzICs0NzcsMTMgQEAgc3ViIEdlbmVyYXRlR2V0T3duUHJv cGVydHlEZXNjcmlwdG9yQm9keQogICAgICAgICB9CiAgICAgICAgIHB1c2goQGltcGxDb250ZW50 LCAiICAgICAgICByZXR1cm4gZmFsc2U7XG4iKTsKICAgICB9Ci0gICAgCisKICAgICBpZiAoJGlu dGVyZmFjZU5hbWUgZXEgIk5hbWVkTm9kZU1hcCIgb3IgJGludGVyZmFjZU5hbWUgPX4gL15IVE1M XHcqQ29sbGVjdGlvbiQvKSB7CiAgICAgICAgIHB1c2goQGdldE93blByb3BlcnR5RGVzY3JpcHRv ckltcGwsICIgICAgJHtuYW1lc3BhY2VNYXliZX1KU1ZhbHVlIHByb3RvID0gdGhpc09iamVjdC0+ cHJvdG90eXBlKCk7XG4iKTsKICAgICAgICAgcHVzaChAZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9y SW1wbCwgIiAgICBpZiAocHJvdG8uaXNPYmplY3QoKSAmJiBqc0Nhc3Q8JHtuYW1lc3BhY2VNYXli ZX1KU09iamVjdCo+KGFzT2JqZWN0KHByb3RvKSktPmhhc1Byb3BlcnR5KGV4ZWMsIHByb3BlcnR5 TmFtZSkpXG4iKTsKICAgICAgICAgcHVzaChAZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9ySW1wbCwg IiAgICAgICAgcmV0dXJuIGZhbHNlO1xuXG4iKTsKICAgICB9Ci0gICAgCisKICAgICBteSAkbWFu dWFsTG9va3VwR2V0dGVyR2VuZXJhdGlvbiA9IHN1YiB7CiAgICAgICAgIG15ICRyZXF1aXJlc01h bnVhbExvb2t1cCA9ICRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJJbmRleGVkR2V0 dGVyIn0gfHwgJGludGVyZmFjZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57Ik5hbWVkR2V0dGVyIn07 CiAgICAgICAgIGlmICgkcmVxdWlyZXNNYW51YWxMb29rdXApIHsKQEAgLTU1OCw3ICs1NTgsNyBA QCBzdWIgR2VuZXJhdGVHZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JCb2R5CiAgICAgfSBlbHNlIHsK ICAgICAgICAgcHVzaChAZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9ySW1wbCwgIiAgICByZXR1cm4g QmFzZTo6Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9yKHRoaXNPYmplY3QsIGV4ZWMsIHByb3BlcnR5 TmFtZSwgZGVzY3JpcHRvcik7XG4iKTsKICAgICB9Ci0gICAgCisKICAgICByZXR1cm4gQGdldE93 blByb3BlcnR5RGVzY3JpcHRvckltcGw7CiB9CiAKQEAgLTY5NSw3ICs2OTUsNyBAQCBzdWIgR2Vu ZXJhdGVIZWFkZXIKICAgICAgICAgICAgICRoZWFkZXJJbmNsdWRlc3siJGludGVyZmFjZU5hbWUu aCJ9ID0gMTsKICAgICAgICAgfQogICAgIH0KLSAgICAKKwogICAgICRoZWFkZXJJbmNsdWRlc3si PHJ1bnRpbWUvSlNPYmplY3QuaD4ifSA9IDE7CiAgICAgJGhlYWRlckluY2x1ZGVzeyJTVkdFbGVt ZW50LmgifSA9IDEgaWYgJGNsYXNzTmFtZSA9fiAvXkpTU1ZHLzsKIApAQCAtNzg3LDcgKzc4Nyw3 IEBAIHN1YiBHZW5lcmF0ZUhlYWRlcgogICAgICAgICB8fCAkaW50ZXJmYWNlLT5leHRlbmRlZEF0 dHJpYnV0ZXMtPnsiTnVtZXJpY0luZGV4ZWRHZXR0ZXIifQogICAgICAgICB8fCAkaW50ZXJmYWNl LT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiSlNDdXN0b21HZXRPd25Qcm9wZXJ0eVNsb3RBbmREZXNj cmlwdG9yIn0KICAgICAgICAgfHwgJGhhc0ltcHVyZU5hbWVkR2V0dGVyOwotICAgIAorCiAgICAg bXkgJGhhc0dldHRlciA9ICRudW1BdHRyaWJ1dGVzID4gMCB8fCAhJGludGVyZmFjZS0+ZXh0ZW5k ZWRBdHRyaWJ1dGVzLT57Ik9taXRDb25zdHJ1Y3RvciJ9IHx8ICRoYXNDb21wbGV4R2V0dGVyOwog CiAgICAgaWYgKCRoYXNJbXB1cmVOYW1lZEdldHRlcikgewpAQCAtODE3LDcgKzgxNyw3IEBAIHN1 YiBHZW5lcmF0ZUhlYWRlcgogICAgICAgICAkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJpYnV0ZXMt PnsiQ3VzdG9tUHV0RnVuY3Rpb24ifQogICAgICAgICB8fCAkaW50ZXJmYWNlLT5leHRlbmRlZEF0 dHJpYnV0ZXMtPnsiQ3VzdG9tTmFtZWRTZXR0ZXIifQogICAgICAgICB8fCAkaW50ZXJmYWNlLT5l eHRlbmRlZEF0dHJpYnV0ZXMtPnsiQ3VzdG9tSW5kZXhlZFNldHRlciJ9OwotICAgICAgICAKKwog ICAgIG15ICRoYXNTZXR0ZXIgPSAkaGFzUmVhZFdyaXRlUHJvcGVydGllcyB8fCAkaGFzQ29tcGxl eFNldHRlcjsKIAogICAgICMgR2V0dGVycwpAQCAtODcwLDcgKzg3MCw3IEBAIHN1YiBHZW5lcmF0 ZUhlYWRlcgogICAgICMgQ3VzdG9tIGdldE93blByb3BlcnR5TmFtZXMgZnVuY3Rpb24KICAgICBp ZiAoJGludGVyZmFjZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57IkN1c3RvbUVudW1lcmF0ZVByb3Bl cnR5In0gfHwgJGludGVyZmFjZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57IkluZGV4ZWRHZXR0ZXIi fSB8fCAkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiTnVtZXJpY0luZGV4ZWRHZXR0 ZXIifSkgewogICAgICAgICBwdXNoKEBoZWFkZXJDb250ZW50LCAiICAgIHN0YXRpYyB2b2lkIGdl dE93blByb3BlcnR5TmFtZXMoSlNDOjpKU09iamVjdCosIEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpQ cm9wZXJ0eU5hbWVBcnJheSYsIEpTQzo6RW51bWVyYXRpb25Nb2RlIG1vZGUgPSBKU0M6OkV4Y2x1 ZGVEb250RW51bVByb3BlcnRpZXMpO1xuIik7Ci0gICAgICAgICRzdHJ1Y3R1cmVGbGFnc3siSlND OjpPdmVycmlkZXNHZXRQcm9wZXJ0eU5hbWVzIn0gPSAxOyAgICAgICAKKyAgICAgICAgJHN0cnVj dHVyZUZsYWdzeyJKU0M6Ok92ZXJyaWRlc0dldFByb3BlcnR5TmFtZXMifSA9IDE7CiAgICAgfQog CiAgICAgIyBDdXN0b20gZGVmaW5lT3duUHJvcGVydHkgZnVuY3Rpb24KQEAgLTk0MSw3ICs5NDEs NyBAQCBzdWIgR2VuZXJhdGVIZWFkZXIKICAgICAgICAgICAgIG15ICRjb25kaXRpb25hbFN0cmlu ZyA9ICRjb2RlR2VuZXJhdG9yLT5HZW5lcmF0ZUNvbmRpdGlvbmFsU3RyaW5nKCRmdW5jdGlvbi0+ c2lnbmF0dXJlKTsKICAgICAgICAgICAgIHB1c2goQGhlYWRlckNvbnRlbnQsICIjaWYgJHtjb25k aXRpb25hbFN0cmluZ31cbiIpIGlmICRjb25kaXRpb25hbFN0cmluZzsKICAgICAgICAgICAgIG15 ICRmdW5jdGlvbkltcGxlbWVudGF0aW9uTmFtZSA9ICRmdW5jdGlvbi0+c2lnbmF0dXJlLT5leHRl bmRlZEF0dHJpYnV0ZXMtPnsiSW1wbGVtZW50ZWRBcyJ9IHx8ICRjb2RlR2VuZXJhdG9yLT5XS19s Y2ZpcnN0KCRmdW5jdGlvbi0+c2lnbmF0dXJlLT5uYW1lKTsKLSAgICAgICAgICAgIHB1c2goQGhl YWRlckNvbnRlbnQsICIgICAgIiAuICgkZnVuY3Rpb24tPmlzU3RhdGljID8gInN0YXRpYyAiIDog IiIpIC4gIkpTQzo6SlNWYWx1ZSAiIC4gJGZ1bmN0aW9uSW1wbGVtZW50YXRpb25OYW1lIC4gIihK U0M6OkV4ZWNTdGF0ZSopO1xuIik7CisgICAgICAgICAgICBwdXNoKEBoZWFkZXJDb250ZW50LCAi ICAgICIgLiAoTWFrZXNTdGF0aWNDYWxsKCRmdW5jdGlvbikgPyAic3RhdGljICIgOiAiIikgLiAi SlNDOjpKU1ZhbHVlICIgLiAkZnVuY3Rpb25JbXBsZW1lbnRhdGlvbk5hbWUgLiAiKEpTQzo6RXhl Y1N0YXRlKik7XG4iKTsKICAgICAgICAgICAgIHB1c2goQGhlYWRlckNvbnRlbnQsICIjZW5kaWZc biIpIGlmICRjb25kaXRpb25hbFN0cmluZzsKICAgICAgICAgfQogICAgIH0KQEAgLTEwNzIsNyAr MTA3Miw3IEBAIHN1YiBHZW5lcmF0ZUhlYWRlcgogICAgIGlmICgkdXNlc1RvSlNOZXdseUNyZWF0 ZWR7JGludGVyZmFjZU5hbWV9KSB7CiAgICAgICAgIHB1c2goQGhlYWRlckNvbnRlbnQsICJKU0M6 OkpTVmFsdWUgdG9KU05ld2x5Q3JlYXRlZChKU0M6OkV4ZWNTdGF0ZSosIEpTRE9NR2xvYmFsT2Jq ZWN0KiwgJGludGVyZmFjZU5hbWUqKTtcbiIpOwogICAgIH0KLSAgICAKKwogICAgIHB1c2goQGhl YWRlckNvbnRlbnQsICJcbiIpOwogCiAgICAgIyBBZGQgcHJvdG90eXBlIGRlY2xhcmF0aW9uLgpA QCAtMTE1Niw3ICsxMTU2LDcgQEAgc3ViIEdlbmVyYXRlSGVhZGVyCiAgICAgICAgICAgICB9CiAg ICAgICAgICAgICBwdXNoKEBoZWFkZXJDb250ZW50LCAiI2VuZGlmXG4iKSBpZiAkY29uZGl0aW9u YWxTdHJpbmc7CiAgICAgICAgIH0KLSAgICAgICAgCisKICAgICAgICAgaWYgKCEkaW50ZXJmYWNl LT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiT21pdENvbnN0cnVjdG9yIn0pIHsKICAgICAgICAgICAg IG15ICRnZXR0ZXIgPSAianMiIC4gJGludGVyZmFjZU5hbWUgLiAiQ29uc3RydWN0b3IiOwogICAg ICAgICAgICAgcHVzaChAaGVhZGVyQ29udGVudCwgIkpTQzo6SlNWYWx1ZSAke2dldHRlcn0oSlND OjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIEpTQzo6UHJvcGVydHlOYW1lKTtcbiIpOwpAQCAt MTE4Nyw3ICsxMTg3LDcgQEAgc3ViIEdlbmVyYXRlSGVhZGVyCiAgICAgIyAtIEdlbmVyYXRlIGRl cGVuZGVuY2llcy4KICAgICBpZiAoJHdyaXRlRGVwZW5kZW5jaWVzICYmIEBhbmNlc3RvckludGVy ZmFjZU5hbWVzKSB7CiAgICAgICAgIHB1c2goQGRlcHNDb250ZW50LCAiJGNsYXNzTmFtZS5oIDog Iiwgam9pbigiICIsIG1hcCB7ICIkXy5pZGwiIH0gQGFuY2VzdG9ySW50ZXJmYWNlTmFtZXMpLCAi XG4iKTsKLSAgICAgICAgcHVzaChAZGVwc0NvbnRlbnQsIG1hcCB7ICIkXy5pZGwgOlxuIiB9IEBh bmNlc3RvckludGVyZmFjZU5hbWVzKTsgCisgICAgICAgIHB1c2goQGRlcHNDb250ZW50LCBtYXAg eyAiJF8uaWRsIDpcbiIgfSBAYW5jZXN0b3JJbnRlcmZhY2VOYW1lcyk7CiAgICAgfQogfQogCkBA IC0xMTk4LDcgKzExOTgsNyBAQCBzdWIgR2VuZXJhdGVBdHRyaWJ1dGVzSGFzaFRhYmxlKCQkKQog ICAgICMgRklYTUU6IFRoZXNlIHNob3VsZCBiZSBmdW5jdGlvbnMgb24gJGludGVyZmFjZS4KICAg ICBteSAkaW50ZXJmYWNlTmFtZSA9ICRpbnRlcmZhY2UtPm5hbWU7CiAgICAgbXkgJGNsYXNzTmFt ZSA9ICJKUyRpbnRlcmZhY2VOYW1lIjsKLSAgICAKKwogICAgICMgLSBBZGQgYWxsIGF0dHJpYnV0 ZXMgaW4gYSBoYXNodGFibGUgZGVmaW5pdGlvbgogICAgIG15ICRudW1BdHRyaWJ1dGVzID0gQHsk aW50ZXJmYWNlLT5hdHRyaWJ1dGVzfTsKICAgICAkbnVtQXR0cmlidXRlcysrIGlmICEkaW50ZXJm YWNlLT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiT21pdENvbnN0cnVjdG9yIn07CkBAIC0xMjUyLDcg KzEyNTIsNyBAQCBzdWIgR2VuZXJhdGVBdHRyaWJ1dGVzSGFzaFRhYmxlKCQkKQogICAgICAgICAg ICAgbXkgJHNldHRlciA9ICJzZXRKUyIgLiAkaW50ZXJmYWNlTmFtZSAuICJDb25zdHJ1Y3RvciI7 CiAgICAgICAgICAgICBwdXNoKEBoYXNoVmFsdWUyLCAkc2V0dGVyKTsKICAgICAgICAgICAgIHB1 c2goQGhhc2hTcGVjaWFscywgIkRvbnRFbnVtIHwgRG9udERlbGV0ZSIpOwotICAgICAgICB9IGVs c2UgeyAgICAgICAgICAgIAorICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgcHVzaChAaGFz aFZhbHVlMiwgIjAiKTsKICAgICAgICAgICAgIHB1c2goQGhhc2hTcGVjaWFscywgIkRvbnRFbnVt IHwgUmVhZE9ubHkiKTsKICAgICAgICAgfQpAQCAtMTYwMyw3ICsxNjAzLDcgQEAgc3ViIEdlbmVy YXRlSW1wbGVtZW50YXRpb24KICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQsICIgICAgJHtjbGFz c05hbWV9UHJvdG90eXBlKiB0aGlzT2JqZWN0ID0ganNDYXN0PCR7Y2xhc3NOYW1lfVByb3RvdHlw ZSo+KGNlbGwpO1xuIik7CiAKICAgICAgICAgaWYgKCRudW1Db25zdGFudHMgZXEgMCAmJiAkbnVt RnVuY3Rpb25zIGVxIDApIHsKLSAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAiICAgIHJl dHVybiBCYXNlOjpnZXRPd25Qcm9wZXJ0eVNsb3QodGhpc09iamVjdCwgZXhlYywgcHJvcGVydHlO YW1lLCBzbG90KTtcbiIpOyAgICAgICAgCisgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwg IiAgICByZXR1cm4gQmFzZTo6Z2V0T3duUHJvcGVydHlTbG90KHRoaXNPYmplY3QsIGV4ZWMsIHBy b3BlcnR5TmFtZSwgc2xvdCk7XG4iKTsKICAgICAgICAgfSBlbHNpZiAoJG51bUNvbnN0YW50cyBl cSAwKSB7CiAgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAgICByZXR1cm4gZ2V0U3Rh dGljRnVuY3Rpb25TbG90PEpTT2JqZWN0PihleGVjLCAiIC4gcHJvdG90eXBlSGFzaFRhYmxlQWNj ZXNzb3IoJGludGVyZmFjZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57IkpTTm9TdGF0aWNUYWJsZXMi fSwgJGNsYXNzTmFtZSkgLiAiLCB0aGlzT2JqZWN0LCBwcm9wZXJ0eU5hbWUsIHNsb3QpO1xuIik7 CiAgICAgICAgIH0gZWxzaWYgKCRudW1GdW5jdGlvbnMgZXEgMCkgewpAQCAtMTYxOCw3ICsxNjE4 LDcgQEAgc3ViIEdlbmVyYXRlSW1wbGVtZW50YXRpb24KICAgICAgICAgcHVzaChAaW1wbENvbnRl bnQsICIgICAgJHtjbGFzc05hbWV9UHJvdG90eXBlKiB0aGlzT2JqZWN0ID0ganNDYXN0PCR7Y2xh c3NOYW1lfVByb3RvdHlwZSo+KG9iamVjdCk7XG4iKTsKIAogICAgICAgICBpZiAoJG51bUNvbnN0 YW50cyBlcSAwICYmICRudW1GdW5jdGlvbnMgZXEgMCkgewotICAgICAgICAgICAgcHVzaChAaW1w bENvbnRlbnQsICIgICAgcmV0dXJuIEJhc2U6OmdldE93blByb3BlcnR5RGVzY3JpcHRvcih0aGlz T2JqZWN0LCBleGVjLCBwcm9wZXJ0eU5hbWUsIGRlc2NyaXB0b3IpO1xuIik7ICAgICAgICAKKyAg ICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAiICAgIHJldHVybiBCYXNlOjpnZXRPd25Qcm9w ZXJ0eURlc2NyaXB0b3IodGhpc09iamVjdCwgZXhlYywgcHJvcGVydHlOYW1lLCBkZXNjcmlwdG9y KTtcbiIpOwogICAgICAgICB9IGVsc2lmICgkbnVtQ29uc3RhbnRzIGVxIDApIHsKICAgICAgICAg ICAgIHB1c2goQGltcGxDb250ZW50LCAiICAgIHJldHVybiBnZXRTdGF0aWNGdW5jdGlvbkRlc2Ny aXB0b3I8SlNPYmplY3Q+KGV4ZWMsICIgLiBwcm90b3R5cGVIYXNoVGFibGVBY2Nlc3NvcigkaW50 ZXJmYWNlLT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiSlNOb1N0YXRpY1RhYmxlcyJ9LCAkY2xhc3NO YW1lKSAuICIsIHRoaXNPYmplY3QsIHByb3BlcnR5TmFtZSwgZGVzY3JpcHRvcik7XG4iKTsKICAg ICAgICAgfSBlbHNpZiAoJG51bUZ1bmN0aW9ucyBlcSAwKSB7CkBAIC0xNzE5LDcgKzE3MTksNyBA QCBzdWIgR2VuZXJhdGVJbXBsZW1lbnRhdGlvbgogICAgIH0KIAogICAgIGlmICghJGhhc1BhcmVu dCkgewotICAgICAgICAjIEZJWE1FOiBUaGlzIGRlc3Ryb3kgZnVuY3Rpb24gc2hvdWxkIG5vdCBi ZSBuZWNlc3NhcnksIGFzIAorICAgICAgICAjIEZJWE1FOiBUaGlzIGRlc3Ryb3kgZnVuY3Rpb24g c2hvdWxkIG5vdCBiZSBuZWNlc3NhcnksIGFzCiAgICAgICAgICMgYSBmaW5hbGl6ZXIgc2hvdWxk IGJlIGNhbGxlZCBmb3IgZWFjaCBET00gb2JqZWN0IHdyYXBwZXIuCiAgICAgICAgICMgSG93ZXZl ciwgdGhhdCBzZWVtcyBub3QgdG8gYmUgdGhlIGNhc2UsIHNvIHRoaXMgaGFzIGJlZW4KICAgICAg ICAgIyBhZGRlZCBiYWNrIHRvIGF2b2lkIGxlYWtpbmcgd2hpbGUgd2UgZmlndXJlIG91dCB3aHkg dGhlCkBAIC0xNzQwLDcgKzE3NDAsNyBAQCBzdWIgR2VuZXJhdGVJbXBsZW1lbnRhdGlvbgogICAg IH0KIAogICAgIG15ICRoYXNHZXR0ZXIgPSAkbnVtQXR0cmlidXRlcyA+IDAKLSAgICAgICAgICAg ICAgICAgfHwgISRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJPbWl0Q29uc3RydWN0 b3IifSAKKyAgICAgICAgICAgICAgICAgfHwgISRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRl cy0+eyJPbWl0Q29uc3RydWN0b3IifQogICAgICAgICAgICAgICAgICB8fCAkaW50ZXJmYWNlLT5l eHRlbmRlZEF0dHJpYnV0ZXMtPnsiSW5kZXhlZEdldHRlciJ9CiAgICAgICAgICAgICAgICAgIHx8 ICRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJOdW1lcmljSW5kZXhlZEdldHRlciJ9 CiAgICAgICAgICAgICAgICAgIHx8ICRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJK U0N1c3RvbUdldE93blByb3BlcnR5U2xvdEFuZERlc2NyaXB0b3IifQpAQCAtMjAyOCw3ICsyMDI4 LDcgQEAgc3ViIEdlbmVyYXRlSW1wbGVtZW50YXRpb24KICAgICAgICAgICAgICAgICAgICAgcHVz aChAaW1wbENvbnRlbnQsICIgICAgQmFzZTo6cHV0KHRoaXNPYmplY3QsIGV4ZWMsIHByb3BlcnR5 TmFtZSwgdmFsdWUsIHNsb3QpO1xuIik7CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAg ICAgIHB1c2goQGltcGxDb250ZW50LCAifVxuXG4iKTsKLSAgICAgICAgICAgICAgICAKKwogICAg ICAgICAgICAgICAgIGlmICgkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiQ3VzdG9t SW5kZXhlZFNldHRlciJ9IHx8ICRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJDdXN0 b21OYW1lZFNldHRlciJ9KSB7CiAgICAgICAgICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50 LCAidm9pZCAke2NsYXNzTmFtZX06OnB1dEJ5SW5kZXgoSlNDZWxsKiBjZWxsLCBFeGVjU3RhdGUq IGV4ZWMsIHVuc2lnbmVkIGluZGV4LCBKU1ZhbHVlIHZhbHVlLCBib29sIHNob3VsZFRocm93KVxu Iik7CiAgICAgICAgICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAie1xuIik7CkBAIC0y MDQxLDE0ICsyMDQxLDE0IEBAIHN1YiBHZW5lcmF0ZUltcGxlbWVudGF0aW9uCiAgICAgICAgICAg ICAgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAgICAgICAgcmV0dXJuO1xuIik7CiAg ICAgICAgICAgICAgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAgICB9XG4iKTsKICAg ICAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgICAgICAKKwogICAgICAgICAgICAg ICAgICAgICBpZiAoJGludGVyZmFjZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57IkN1c3RvbU5hbWVk U2V0dGVyIn0pIHsKICAgICAgICAgICAgICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAi ICAgIFByb3BlcnR5TmFtZSBwcm9wZXJ0eU5hbWUgPSBJZGVudGlmaWVyOjpmcm9tKGV4ZWMsIGlu ZGV4KTtcbiIpOwogICAgICAgICAgICAgICAgICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQsICIg ICAgUHV0UHJvcGVydHlTbG90IHNsb3Qoc2hvdWxkVGhyb3cpO1xuIik7CiAgICAgICAgICAgICAg ICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAgICBpZiAodGhpc09iamVjdC0+cHV0RGVs ZWdhdGUoZXhlYywgcHJvcGVydHlOYW1lLCB2YWx1ZSwgc2xvdCkpXG4iKTsKICAgICAgICAgICAg ICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAiICAgICAgICByZXR1cm47XG4iKTsKICAg ICAgICAgICAgICAgICAgICAgfQotICAgIAorCiAgICAgICAgICAgICAgICAgICAgIHB1c2goQGlt cGxDb250ZW50LCAiICAgIEJhc2U6OnB1dEJ5SW5kZXgoY2VsbCwgZXhlYywgaW5kZXgsIHZhbHVl LCBzaG91bGRUaHJvdyk7XG4iKTsKICAgICAgICAgICAgICAgICAgICAgcHVzaChAaW1wbENvbnRl bnQsICJ9XG5cbiIpOwogICAgICAgICAgICAgICAgIH0KQEAgLTIyMzMsNyArMjIzMyw3IEBAIHN1 YiBHZW5lcmF0ZUltcGxlbWVudGF0aW9uCiAgICAgICAgICAgICAgICAgICAgIGRpZSAiTm8gd2F5 IHRvIGhhbmRsZSBpbnRlcmZhY2Ugd2l0aCBSZXBsYWNlYWJsZUNvbnN0cnVjdG9yIGV4dGVuZGVk IGF0dHJpYnV0ZTogJGludGVyZmFjZU5hbWUiOwogICAgICAgICAgICAgICAgIH0KICAgICAgICAg ICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIn1cblxuIik7Ci0gICAgICAgICAgICB9ICAgICAg ICAKKyAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0KIApAQCAtMjI5MCw3ICsyMjkwLDcg QEAgc3ViIEdlbmVyYXRlSW1wbGVtZW50YXRpb24KIAogICAgICAgICAgICAgJGltcGxJbmNsdWRl c3siPHJ1bnRpbWUvRXJyb3IuaD4ifSA9IDE7CiAKLSAgICAgICAgICAgIGlmICgkZnVuY3Rpb24t PmlzU3RhdGljKSB7CisgICAgICAgICAgICBpZiAoTWFrZXNTdGF0aWNDYWxsKCRmdW5jdGlvbikp IHsKICAgICAgICAgICAgICAgICBpZiAoJGlzQ3VzdG9tKSB7CiAgICAgICAgICAgICAgICAgICAg IEdlbmVyYXRlQXJndW1lbnRzQ291bnRDaGVjayhcQGltcGxDb250ZW50LCAkZnVuY3Rpb24sICRp bnRlcmZhY2UpOwogICAgICAgICAgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAgICBy ZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKCR7Y2xhc3NOYW1lfTo6IiAuICRmdW5jdGlvbkltcGxlbWVu dGF0aW9uTmFtZSAuICIoZXhlYykpO1xuIik7CkBAIC0yNjY5LDkgKzI2NjksOSBAQCBzdWIgR2Vu ZXJhdGVQYXJhbWV0ZXJzQ2hlY2sKICAgICBteSAkaW1wbGVtZW50ZWRCeSA9ICRmdW5jdGlvbi0+ c2lnbmF0dXJlLT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiSW1wbGVtZW50ZWRCeSJ9OwogICAgIGlm ICgkaW1wbGVtZW50ZWRCeSkgewogICAgICAgICBBZGRUb0ltcGxJbmNsdWRlcygiJHtpbXBsZW1l bnRlZEJ5fS5oIik7Ci0gICAgICAgIHVuc2hpZnQoQGFyZ3VtZW50cywgImltcGwiKSBpZiAhJGZ1 bmN0aW9uLT5pc1N0YXRpYzsKKyAgICAgICAgdW5zaGlmdChAYXJndW1lbnRzLCAiaW1wbCIpIGlm ICFNYWtlc1N0YXRpY0NhbGwoJGZ1bmN0aW9uKTsKICAgICAgICAgJGZ1bmN0aW9uTmFtZSA9ICIk e2ltcGxlbWVudGVkQnl9Ojoke2Z1bmN0aW9uSW1wbGVtZW50YXRpb25OYW1lfSI7Ci0gICAgfSBl bHNpZiAoJGZ1bmN0aW9uLT5pc1N0YXRpYykgeworICAgIH0gZWxzaWYgKE1ha2VzU3RhdGljQ2Fs bCgkZnVuY3Rpb24pKSB7CiAgICAgICAgICRmdW5jdGlvbk5hbWUgPSAiJHtpbnRlcmZhY2VOYW1l fTo6JHtmdW5jdGlvbkltcGxlbWVudGF0aW9uTmFtZX0iOwogICAgIH0gZWxzaWYgKCRzdmdQcm9w ZXJ0eU9yTGlzdFByb3BlcnR5VHlwZSBhbmQgISRzdmdMaXN0UHJvcGVydHlUeXBlKSB7CiAgICAg ICAgICRmdW5jdGlvbk5hbWUgPSAicG9kSW1wbC4ke2Z1bmN0aW9uSW1wbGVtZW50YXRpb25OYW1l fSI7CkBAIC0zMDU0LDcgKzMwNTQsNyBAQCBzdWIgR2VuZXJhdGVJbXBsZW1lbnRhdGlvbkZ1bmN0 aW9uQ2FsbCgpCiAKICAgICAgICAgaWYgKCRzdmdQcm9wZXJ0eVR5cGUgYW5kICEkZnVuY3Rpb24t PmlzU3RhdGljKSB7CiAgICAgICAgICAgICBpZiAoQHskZnVuY3Rpb24tPnJhaXNlc0V4Y2VwdGlv bnN9KSB7Ci0gICAgICAgICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQsICRpbmRlbnQgLiAiaWYg KCFlYylcbiIpOyAKKyAgICAgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgJGluZGVudCAu ICJpZiAoIWVjKVxuIik7CiAgICAgICAgICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQsICRpbmRl bnQgLiAiICAgIGltcGwtPmNvbW1pdENoYW5nZSgpO1xuIik7CiAgICAgICAgICAgICB9IGVsc2Ug ewogICAgICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAkaW5kZW50IC4gImltcGwtPmNv bW1pdENoYW5nZSgpO1xuIik7CkBAIC0zMTA3LDcgKzMxMDcsNyBAQCBteSAlbmF0aXZlVHlwZSA9 ICgKICAgICAibG9uZyBsb25nIiA9PiAibG9uZyBsb25nIiwKICAgICAidW5zaWduZWQgbG9uZyBs b25nIiA9PiAidW5zaWduZWQgbG9uZyBsb25nIiwKICAgICAiTWVkaWFRdWVyeUxpc3RMaXN0ZW5l ciIgPT4gIlJlZlB0cjxNZWRpYVF1ZXJ5TGlzdExpc3RlbmVyPiIsCi0gICAgIkRPTVRpbWVTdGFt cCIgPT4gIkRPTVRpbWVTdGFtcCIsICAgIAorICAgICJET01UaW1lU3RhbXAiID0+ICJET01UaW1l U3RhbXAiLAogKTsKIAogc3ViIEdldE5hdGl2ZVR5cGUKQEAgLTMxNjAsNyArMzE2MCw3IEBAIHN1 YiBHZXRTVkdQcm9wZXJ0eVR5cGVzCiAgICAgbXkgJHN2Z05hdGl2ZVR5cGU7CiAKICAgICByZXR1 cm4gKCRzdmdQcm9wZXJ0eVR5cGUsICRzdmdMaXN0UHJvcGVydHlUeXBlLCAkc3ZnTmF0aXZlVHlw ZSkgaWYgbm90ICRpbXBsVHlwZSA9fiAvU1ZHLzsKLSAgICAKKwogICAgICRzdmdOYXRpdmVUeXBl ID0gJGNvZGVHZW5lcmF0b3ItPkdldFNWR1R5cGVOZWVkaW5nVGVhck9mZigkaW1wbFR5cGUpOwog ICAgIHJldHVybiAoJHN2Z1Byb3BlcnR5VHlwZSwgJHN2Z0xpc3RQcm9wZXJ0eVR5cGUsICRzdmdO YXRpdmVUeXBlKSBpZiBub3QgJHN2Z05hdGl2ZVR5cGU7CiAKQEAgLTM1MzAsNyArMzUzMCw3IEBA IHN1YiBHZW5lcmF0ZUhhc2hUYWJsZQogICAgICAgICAgICAgbXkgJGNvbmRpdGlvbmFsU3RyaW5n ID0gJGNvZGVHZW5lcmF0b3ItPkdlbmVyYXRlQ29uZGl0aW9uYWxTdHJpbmdGcm9tQXR0cmlidXRl VmFsdWUoJGNvbmRpdGlvbmFsKTsKICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAiI2lm ICR7Y29uZGl0aW9uYWxTdHJpbmd9XG4iKTsKICAgICAgICAgfQotICAgICAgICAKKwogICAgICAg ICBpZiAoIkAkc3BlY2lhbHNbJGldIiA9fiBtL0Z1bmN0aW9uLykgewogICAgICAgICAgICAgJHRh cmdldFR5cGUgPSAic3RhdGljX2Nhc3Q8TmF0aXZlRnVuY3Rpb24+IjsKICAgICAgICAgfSBlbHNl IHsKQEAgLTQwOTAsNiArNDA5MCwxMiBAQCBzdWIgSGFzQ3VzdG9tTWV0aG9kCiAgICAgcmV0dXJu ICRhdHRyRXh0LT57IkN1c3RvbSJ9IHx8ICRhdHRyRXh0LT57IkpTQ3VzdG9tIn07CiB9CiAKK3N1 YiBNYWtlc1N0YXRpY0NhbGwKK3sKKyAgICBteSAkZnVuY3Rpb24gPSBzaGlmdDsKKyAgICByZXR1 cm4gJGZ1bmN0aW9uLT5pc1N0YXRpYyB8fCAkZnVuY3Rpb24tPnNpZ25hdHVyZS0+ZXh0ZW5kZWRB dHRyaWJ1dGVzLT57IkxlbmllbnRUaGlzIn07Cit9CisKIHN1YiBJc0NvbnN0cnVjdGFibGUKIHsK ICAgICBteSAkaW50ZXJmYWNlID0gc2hpZnQ7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9iaW5kaW5n cy9zY3JpcHRzL0lETEF0dHJpYnV0ZXMudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3Jl L2JpbmRpbmdzL3NjcmlwdHMvSURMQXR0cmlidXRlcy50eHQJKHJldmlzaW9uIDE0ODEwNSkKKysr IFNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvSURMQXR0cmlidXRlcy50eHQJKHdvcmtp bmcgY29weSkKQEAgLTg3LDYgKzg3LDcgQEAgSlNJbmxpbmVHZXRPd25Qcm9wZXJ0eVNsb3QKIEpT TGVnYWN5UGFyZW50PSoKIEpTTm9TdGF0aWNUYWJsZXMKIEpTV2luZG93RXZlbnRMaXN0ZW5lcgor TGVuaWVudFRoaXMKIE1hc3F1ZXJhZGVzQXNVbmRlZmluZWQKIE5hbWVkQ29uc3RydWN0b3I9Kgog TmFtZWRHZXR0ZXIKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9U ZXN0T2JqLmlkbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRz L3Rlc3QvVGVzdE9iai5pZGwJKHJldmlzaW9uIDE0ODEwNSkKKysrIFNvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL3NjcmlwdHMvdGVzdC9UZXN0T2JqLmlkbAkod29ya2luZyBjb3B5KQpAQCAtMTAwLDEx ICsxMDAsMTEgQEAgZW51bSBUZXN0RW51bVR5cGUgeyAiIiwgIkVudW1WYWx1ZTEiLCAiRQogICAg IFtDdXN0b21dIHZvaWQgY3VzdG9tTWV0aG9kKCk7CiAgICAgW0N1c3RvbV0gdm9pZCBjdXN0b21N ZXRob2RXaXRoQXJncyhpbiBsb25nIGxvbmdBcmcsIGluIERPTVN0cmluZyBzdHJBcmcsIGluIFRl c3RPYmogb2JqQXJnKTsKIAotICAgIHZvaWQgYWRkRXZlbnRMaXN0ZW5lcihpbiBET01TdHJpbmcg dHlwZSwgCi0gICAgICAgICAgICAgICAgICAgICAgICAgIGluIEV2ZW50TGlzdGVuZXIgbGlzdGVu ZXIsIAorICAgIHZvaWQgYWRkRXZlbnRMaXN0ZW5lcihpbiBET01TdHJpbmcgdHlwZSwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgaW4gRXZlbnRMaXN0ZW5lciBsaXN0ZW5lciwKICAgICAgICAg ICAgICAgICAgICAgICAgICAgaW4gW09wdGlvbmFsXSBib29sZWFuIHVzZUNhcHR1cmUpOwotICAg IHZvaWQgcmVtb3ZlRXZlbnRMaXN0ZW5lcihpbiBET01TdHJpbmcgdHlwZSwgCi0gICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGluIEV2ZW50TGlzdGVuZXIgbGlzdGVuZXIsIAorICAgIHZvaWQg cmVtb3ZlRXZlbnRMaXN0ZW5lcihpbiBET01TdHJpbmcgdHlwZSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgaW4gRXZlbnRMaXN0ZW5lciBsaXN0ZW5lciwKICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgaW4gW09wdGlvbmFsXSBib29sZWFuIHVzZUNhcHR1cmUpOwogCiAgICAgLy8g J0NhbGxXaXRoJyBleHRlbmRlZCBhdHRyaWJ1dGUKQEAgLTE3MSw3ICsxNzEsNyBAQCBlbnVtIFRl c3RFbnVtVHlwZSB7ICIiLCAiRW51bVZhbHVlMSIsICJFCiAgICAgW0NhY2hlZEF0dHJpYnV0ZV0g cmVhZG9ubHkgYXR0cmlidXRlIGFueSBjYWNoZWRBdHRyaWJ1dGUxOwogICAgIFtDYWNoZWRBdHRy aWJ1dGVdIHJlYWRvbmx5IGF0dHJpYnV0ZSBhbnkgY2FjaGVkQXR0cmlidXRlMjsKICNlbmRpZgot ICAgIAorCiAgICAgYXR0cmlidXRlIGFueSBhbnlBdHRyaWJ1dGU7CiAKICNpZiBkZWZpbmVkKFRF U1RJTkdfSlMpCkBAIC0xOTQsNiArMTk0LDkgQEAgZW51bSBUZXN0RW51bVR5cGUgeyAiIiwgIkVu dW1WYWx1ZTEiLCAiRQogICAgIHN0YXRpYyBsb25nIGNsYXNzTWV0aG9kV2l0aE9wdGlvbmFsKGlu IFtPcHRpb25hbF0gbG9uZyBhcmcpOwogICAgIFtDdXN0b21dIHN0YXRpYyB2b2lkIGNsYXNzTWV0 aG9kMihpbiBsb25nIGFyZyk7CiAKKyAgICAvLyBTdGF0aWMgbWV0aG9kcyBkZWZpbmVkIG9uIGlu c3RhbmNlcyAobGlrZSBjb25zb2xlLmxvZykuCisgICAgW0xlbmllbnRUaGlzXSB2b2lkIGxlbmll bnRUaGlzTWV0aG9kKGluIERPTVN0cmluZyBzdHIpOworCiAgICAgLy8gU3RhdGljIG1ldGhvZCB3 aXRoIGNvbmRpdGlvbmFsIG9uIG92ZXJsb2FkZWQgbWV0aG9kcwogICAgIFtDb25kaXRpb25hbD1D b25kaXRpb24xXSBzdGF0aWMgdm9pZCBvdmVybG9hZGVkTWV0aG9kMShpbiBsb25nIGFyZyk7CiAg ICAgW0NvbmRpdGlvbmFsPUNvbmRpdGlvbjFdIHN0YXRpYyB2b2lkIG92ZXJsb2FkZWRNZXRob2Qx KGluIFtTdHJpY3RUeXBlQ2hlY2tpbmddIERPTVN0cmluZyB0eXBlKTsKSW5kZXg6IFNvdXJjZS9X ZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9DUFAvV2ViRE9NVGVzdE9iai5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0NQUC9XZWJET01U ZXN0T2JqLmNwcAkocmV2aXNpb24gMTQ4MTA1KQorKysgU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv c2NyaXB0cy90ZXN0L0NQUC9XZWJET01UZXN0T2JqLmNwcAkod29ya2luZyBjb3B5KQpAQCAtOTQ4 LDYgKzk0OCwxNCBAQCBpbnQgV2ViRE9NVGVzdE9iajo6Y2xhc3NNZXRob2RXaXRoT3B0aW9uCiAg ICAgcmV0dXJuIGltcGwoKS0+Y2xhc3NNZXRob2RXaXRoT3B0aW9uYWwoYXJnKTsKIH0KIAordm9p ZCBXZWJET01UZXN0T2JqOjpsZW5pZW50VGhpc01ldGhvZChjb25zdCBXZWJET01TdHJpbmcmIHN0 cikKK3sKKyAgICBpZiAoIWltcGwoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaW1wbCgpLT5s ZW5pZW50VGhpc01ldGhvZChzdHIpOworfQorCiAKICNpZiBFTkFCTEUoQ29uZGl0aW9uMSkKIHZv aWQgV2ViRE9NVGVzdE9iajo6b3ZlcmxvYWRlZE1ldGhvZDEoaW50IGFyZykKSW5kZXg6IFNvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9DUFAvV2ViRE9NVGVzdE9iai5oCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9DUFAvV2ViRE9N VGVzdE9iai5oCShyZXZpc2lvbiAxNDgxMDUpCisrKyBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9z Y3JpcHRzL3Rlc3QvQ1BQL1dlYkRPTVRlc3RPYmouaAkod29ya2luZyBjb3B5KQpAQCAtMTg1LDYg KzE4NSw3IEBAIHB1YmxpYzoKICNlbmRpZgogICAgIHZvaWQgY2xhc3NNZXRob2QoKTsKICAgICBp bnQgY2xhc3NNZXRob2RXaXRoT3B0aW9uYWwoaW50IGFyZyk7CisgICAgdm9pZCBsZW5pZW50VGhp c01ldGhvZChjb25zdCBXZWJET01TdHJpbmcmIHN0cik7CiAjaWYgRU5BQkxFKENvbmRpdGlvbjEp CiAgICAgdm9pZCBvdmVybG9hZGVkTWV0aG9kMShpbnQgYXJnKTsKICNlbmRpZgpJbmRleDogU291 cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0dPYmplY3QvV2ViS2l0RE9NVGVzdE9i ai5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0 L0dPYmplY3QvV2ViS2l0RE9NVGVzdE9iai5jcHAJKHJldmlzaW9uIDE0ODEwNSkKKysrIFNvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9HT2JqZWN0L1dlYktpdERPTVRlc3RPYmou Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMzUyLDYgKzEzNTIsMTcgQEAgd2Via2l0X2RvbV90ZXN0 X29ial9jbGFzc19tZXRob2Rfd2l0aF9vcAogfQogCiB2b2lkCit3ZWJraXRfZG9tX3Rlc3Rfb2Jq X2xlbmllbnRfdGhpc19tZXRob2QoV2ViS2l0RE9NVGVzdE9iaiogc2VsZiwgY29uc3QgZ2NoYXIq IHN0cikKK3sKKyAgICBXZWJDb3JlOjpKU01haW5UaHJlYWROdWxsU3RhdGUgc3RhdGU7CisgICAg Z19yZXR1cm5faWZfZmFpbChXRUJLSVRfRE9NX0lTX1RFU1RfT0JKKHNlbGYpKTsKKyAgICBnX3Jl dHVybl9pZl9mYWlsKHN0cik7CisgICAgV2ViQ29yZTo6VGVzdE9iaiogaXRlbSA9IFdlYktpdDo6 Y29yZShzZWxmKTsKKyAgICBXVEY6OlN0cmluZyBjb252ZXJ0ZWRTdHIgPSBXVEY6OlN0cmluZzo6 ZnJvbVVURjgoc3RyKTsKKyAgICBpdGVtLT5sZW5pZW50VGhpc01ldGhvZChjb252ZXJ0ZWRTdHIp OworfQorCit2b2lkCiB3ZWJraXRfZG9tX3Rlc3Rfb2JqX292ZXJsb2FkZWRfbWV0aG9kMShXZWJL aXRET01UZXN0T2JqKiBzZWxmLCBnbG9uZyBhcmcpCiB7CiAjaWYgRU5BQkxFKENvbmRpdGlvbjEp CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvR09iamVjdC9XZWJL aXRET01UZXN0T2JqLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2Ny aXB0cy90ZXN0L0dPYmplY3QvV2ViS2l0RE9NVGVzdE9iai5oCShyZXZpc2lvbiAxNDgxMDUpCisr KyBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvR09iamVjdC9XZWJLaXRET01U ZXN0T2JqLmgJKHdvcmtpbmcgY29weSkKQEAgLTM4MCw2ICszODAsMTcgQEAgV0VCS0lUX0FQSSBn bG9uZwogd2Via2l0X2RvbV90ZXN0X29ial9jbGFzc19tZXRob2Rfd2l0aF9vcHRpb25hbChXZWJL aXRET01UZXN0T2JqKiBzZWxmLCBnbG9uZyBhcmcpOwogCiAvKioKKyAqIHdlYmtpdF9kb21fdGVz dF9vYmpfbGVuaWVudF90aGlzX21ldGhvZDoKKyAqIEBzZWxmOiBBICNXZWJLaXRET01UZXN0T2Jq CisgKiBAc3RyOiBBICNnY2hhcgorICoKKyAqIFJldHVybnM6CisgKgorKiovCitXRUJLSVRfQVBJ IHZvaWQKK3dlYmtpdF9kb21fdGVzdF9vYmpfbGVuaWVudF90aGlzX21ldGhvZChXZWJLaXRET01U ZXN0T2JqKiBzZWxmLCBjb25zdCBnY2hhciogc3RyKTsKKworLyoqCiAgKiB3ZWJraXRfZG9tX3Rl c3Rfb2JqX292ZXJsb2FkZWRfbWV0aG9kMToKICAqIEBzZWxmOiBBICNXZWJLaXRET01UZXN0T2Jq CiAgKiBAYXJnOiBBICNnbG9uZwpJbmRleDogU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0 cy90ZXN0L0pTL0pTVGVzdE9iai5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvYmlu ZGluZ3Mvc2NyaXB0cy90ZXN0L0pTL0pTVGVzdE9iai5jcHAJKHJldmlzaW9uIDE0ODEwNSkKKysr IFNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9KUy9KU1Rlc3RPYmouY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC0zMTQsNiArMzE0LDcgQEAgc3RhdGljIGNvbnN0IEhhc2hUYWJsZVZh bHVlIEpTVGVzdE9ialBybwogICAgIHsgImNvbmRpdGlvbmFsTWV0aG9kMyIsIERvbnREZWxldGUg fCBKU0M6OkZ1bmN0aW9uLCAoaW50cHRyX3Qpc3RhdGljX2Nhc3Q8TmF0aXZlRnVuY3Rpb24+KGpz VGVzdE9ialByb3RvdHlwZUZ1bmN0aW9uQ29uZGl0aW9uYWxNZXRob2QzKSwgKGludHB0cl90KTAs IE5vSW50cmluc2ljIH0sCiAjZW5kaWYKICAgICB7ICJvdmVybG9hZGVkTWV0aG9kIiwgRG9udERl bGV0ZSB8IEpTQzo6RnVuY3Rpb24sIChpbnRwdHJfdClzdGF0aWNfY2FzdDxOYXRpdmVGdW5jdGlv bj4oanNUZXN0T2JqUHJvdG90eXBlRnVuY3Rpb25PdmVybG9hZGVkTWV0aG9kKSwgKGludHB0cl90 KTIsIE5vSW50cmluc2ljIH0sCisgICAgeyAibGVuaWVudFRoaXNNZXRob2QiLCBEb250RGVsZXRl IHwgSlNDOjpGdW5jdGlvbiwgKGludHB0cl90KXN0YXRpY19jYXN0PE5hdGl2ZUZ1bmN0aW9uPihq c1Rlc3RPYmpQcm90b3R5cGVGdW5jdGlvbkxlbmllbnRUaGlzTWV0aG9kKSwgKGludHB0cl90KTEs IE5vSW50cmluc2ljIH0sCiAgICAgeyAiY2xhc3NNZXRob2RXaXRoQ2xhbXAiLCBEb250RGVsZXRl IHwgSlNDOjpGdW5jdGlvbiwgKGludHB0cl90KXN0YXRpY19jYXN0PE5hdGl2ZUZ1bmN0aW9uPihq c1Rlc3RPYmpQcm90b3R5cGVGdW5jdGlvbkNsYXNzTWV0aG9kV2l0aENsYW1wKSwgKGludHB0cl90 KTIsIE5vSW50cmluc2ljIH0sCiAgICAgeyAibWV0aG9kV2l0aFVuc2lnbmVkTG9uZ1NlcXVlbmNl IiwgRG9udERlbGV0ZSB8IEpTQzo6RnVuY3Rpb24sIChpbnRwdHJfdClzdGF0aWNfY2FzdDxOYXRp dmVGdW5jdGlvbj4oanNUZXN0T2JqUHJvdG90eXBlRnVuY3Rpb25NZXRob2RXaXRoVW5zaWduZWRM b25nU2VxdWVuY2UpLCAoaW50cHRyX3QpMSwgTm9JbnRyaW5zaWMgfSwKICAgICB7ICJzdHJpbmdB cnJheUZ1bmN0aW9uIiwgRG9udERlbGV0ZSB8IEpTQzo6RnVuY3Rpb24sIChpbnRwdHJfdClzdGF0 aWNfY2FzdDxOYXRpdmVGdW5jdGlvbj4oanNUZXN0T2JqUHJvdG90eXBlRnVuY3Rpb25TdHJpbmdB cnJheUZ1bmN0aW9uKSwgKGludHB0cl90KTEsIE5vSW50cmluc2ljIH0sCkBAIC0yNjI1LDYgKzI2 MjYsMTcgQEAgRW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBqc1Rlc3RPYmpDbwogICAgIHJl dHVybiBKU1ZhbHVlOjplbmNvZGUoSlNUZXN0T2JqOjpjbGFzc01ldGhvZDIoZXhlYykpOwogfQog CitFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGpzVGVzdE9ialByb3RvdHlwZUZ1bmN0aW9u TGVuaWVudFRoaXNNZXRob2QoRXhlY1N0YXRlKiBleGVjKQoreworICAgIGlmIChleGVjLT5hcmd1 bWVudENvdW50KCkgPCAxKQorICAgICAgICByZXR1cm4gdGhyb3dWTUVycm9yKGV4ZWMsIGNyZWF0 ZU5vdEVub3VnaEFyZ3VtZW50c0Vycm9yKGV4ZWMpKTsKKyAgICBjb25zdCBTdHJpbmcmIHN0cihl eGVjLT5hcmd1bWVudCgwKS5pc0VtcHR5KCkgPyBTdHJpbmcoKSA6IGV4ZWMtPmFyZ3VtZW50KDAp LnRvU3RyaW5nKGV4ZWMpLT52YWx1ZShleGVjKSk7CisgICAgaWYgKGV4ZWMtPmhhZEV4Y2VwdGlv bigpKQorICAgICAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKGpzVW5kZWZpbmVkKCkpOworICAg IFRlc3RPYmo6OmxlbmllbnRUaGlzTWV0aG9kKHN0cik7CisgICAgcmV0dXJuIEpTVmFsdWU6OmVu Y29kZShqc1VuZGVmaW5lZCgpKTsKK30KKwogI2lmIEVOQUJMRShDb25kaXRpb24xKQogc3RhdGlj IEVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwganNUZXN0T2JqQ29uc3RydWN0b3JGdW5jdGlv bk92ZXJsb2FkZWRNZXRob2QxMShFeGVjU3RhdGUqIGV4ZWMpCiB7CkluZGV4OiBTb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvSlMvSlNUZXN0T2JqLmgKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g U291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0pTL0pTVGVzdE9iai5oCShyZXZp c2lvbiAxNDgxMDUpCisrKyBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvSlMv SlNUZXN0T2JqLmgJKHdvcmtpbmcgY29weSkKQEAgLTIwMyw2ICsyMDMsNyBAQCBKU0M6OkVuY29k ZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwganNUZXN0CiBKU0M6OkVuY29kZWRKU1ZhbHVlIEpTQ19I T1NUX0NBTEwganNUZXN0T2JqQ29uc3RydWN0b3JGdW5jdGlvbkNsYXNzTWV0aG9kKEpTQzo6RXhl Y1N0YXRlKik7CiBKU0M6OkVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwganNUZXN0T2JqQ29u c3RydWN0b3JGdW5jdGlvbkNsYXNzTWV0aG9kV2l0aE9wdGlvbmFsKEpTQzo6RXhlY1N0YXRlKik7 CiBKU0M6OkVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwganNUZXN0T2JqQ29uc3RydWN0b3JG dW5jdGlvbkNsYXNzTWV0aG9kMihKU0M6OkV4ZWNTdGF0ZSopOworSlNDOjpFbmNvZGVkSlNWYWx1 ZSBKU0NfSE9TVF9DQUxMIGpzVGVzdE9ialByb3RvdHlwZUZ1bmN0aW9uTGVuaWVudFRoaXNNZXRo b2QoSlNDOjpFeGVjU3RhdGUqKTsKICNpZiBFTkFCTEUoQ29uZGl0aW9uMSkKIEpTQzo6RW5jb2Rl ZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBqc1Rlc3RPYmpDb25zdHJ1Y3RvckZ1bmN0aW9uT3Zlcmxv YWRlZE1ldGhvZDEoSlNDOjpFeGVjU3RhdGUqKTsKICNlbmRpZgpJbmRleDogU291cmNlL1dlYkNv cmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L09iakMvRE9NVGVzdE9iai5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9PYmpDL0RPTVRlc3RPYmouaAko cmV2aXNpb24gMTQ4MTA1KQorKysgU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0 L09iakMvRE9NVGVzdE9iai5oCSh3b3JraW5nIGNvcHkpCkBAIC0xNjUsNiArMTY1LDcgQEAgZW51 bSB7CiAtICh2b2lkKWNsYXNzTWV0aG9kOwogLSAoaW50KWNsYXNzTWV0aG9kV2l0aE9wdGlvbmFs OihpbnQpYXJnOwogLSAodm9pZCljbGFzc01ldGhvZDI6KGludClhcmc7CistICh2b2lkKWxlbmll bnRUaGlzTWV0aG9kOihOU1N0cmluZyAqKXN0cjsKICNpZiBFTkFCTEUoQ29uZGl0aW9uMSkKIC0g KHZvaWQpb3ZlcmxvYWRlZE1ldGhvZDE6KGludClhcmc7CiAjZW5kaWYKSW5kZXg6IFNvdXJjZS9X ZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9PYmpDL0RPTVRlc3RPYmoubW0KPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L09iakMvRE9NVGVzdE9i ai5tbQkocmV2aXNpb24gMTQ4MTA1KQorKysgU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0 cy90ZXN0L09iakMvRE9NVGVzdE9iai5tbQkod29ya2luZyBjb3B5KQpAQCAtMTAxMiw2ICsxMDEy LDEyIEBAIC0gKHZvaWQpY2xhc3NNZXRob2QyOihpbnQpYXJnCiAgICAgSU1QTC0+Y2xhc3NNZXRo b2QyKGFyZyk7CiB9CiAKKy0gKHZvaWQpbGVuaWVudFRoaXNNZXRob2Q6KE5TU3RyaW5nICopc3Ry Cit7CisgICAgV2ViQ29yZTo6SlNNYWluVGhyZWFkTnVsbFN0YXRlIHN0YXRlOworICAgIElNUEwt PmxlbmllbnRUaGlzTWV0aG9kKHN0cik7Cit9CisKIAogI2lmIEVOQUJMRShDb25kaXRpb24xKQog LSAodm9pZClvdmVybG9hZGVkTWV0aG9kMTooaW50KWFyZwpJbmRleDogU291cmNlL1dlYkNvcmUv cGFnZS9Db25zb2xlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wYWdlL0NvbnNv bGUuY3BwCShyZXZpc2lvbiAxNDgxMDUpCisrKyBTb3VyY2UvV2ViQ29yZS9wYWdlL0NvbnNvbGUu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMTUsMTIgKzExNSwxMiBAQCBzdGF0aWMgdm9pZCBpbnRl cm5hbEFkZE1lc3NhZ2UoUGFnZSogcGFnCiAKIHZvaWQgQ29uc29sZTo6ZGVidWcoU2NyaXB0U3Rh dGUqIHN0YXRlLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4gYXJndW1lbnRzKQogewotICAg IGludGVybmFsQWRkTWVzc2FnZShwYWdlKCksIExvZ01lc3NhZ2VUeXBlLCBEZWJ1Z01lc3NhZ2VM ZXZlbCwgc3RhdGUsIGFyZ3VtZW50cyk7CisgICAgaW50ZXJuYWxBZGRNZXNzYWdlKHBhZ2VGcm9t U2NyaXB0U3RhdGUoc3RhdGUpLCBMb2dNZXNzYWdlVHlwZSwgRGVidWdNZXNzYWdlTGV2ZWwsIHN0 YXRlLCBhcmd1bWVudHMpOwogfQogCiB2b2lkIENvbnNvbGU6OmVycm9yKFNjcmlwdFN0YXRlKiBz dGF0ZSwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+IGFyZ3VtZW50cykKIHsKLSAgICBpbnRl cm5hbEFkZE1lc3NhZ2UocGFnZSgpLCBMb2dNZXNzYWdlVHlwZSwgRXJyb3JNZXNzYWdlTGV2ZWws IHN0YXRlLCBhcmd1bWVudHMpOworICAgIGludGVybmFsQWRkTWVzc2FnZShwYWdlRnJvbVNjcmlw dFN0YXRlKHN0YXRlKSwgTG9nTWVzc2FnZVR5cGUsIEVycm9yTWVzc2FnZUxldmVsLCBzdGF0ZSwg YXJndW1lbnRzKTsKIH0KIAogdm9pZCBDb25zb2xlOjppbmZvKFNjcmlwdFN0YXRlKiBzdGF0ZSwg UGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+IGFyZ3VtZW50cykKQEAgLTEzMCwzNyArMTMwLDM3 IEBAIHZvaWQgQ29uc29sZTo6aW5mbyhTY3JpcHRTdGF0ZSogc3RhdGUsIFAKIAogdm9pZCBDb25z b2xlOjpsb2coU2NyaXB0U3RhdGUqIHN0YXRlLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4g YXJndW1lbnRzKQogewotICAgIGludGVybmFsQWRkTWVzc2FnZShwYWdlKCksIExvZ01lc3NhZ2VU eXBlLCBMb2dNZXNzYWdlTGV2ZWwsIHN0YXRlLCBhcmd1bWVudHMpOworICAgIGludGVybmFsQWRk TWVzc2FnZShwYWdlRnJvbVNjcmlwdFN0YXRlKHN0YXRlKSwgTG9nTWVzc2FnZVR5cGUsIExvZ01l c3NhZ2VMZXZlbCwgc3RhdGUsIGFyZ3VtZW50cyk7CiB9CiAKIHZvaWQgQ29uc29sZTo6d2FybihT Y3JpcHRTdGF0ZSogc3RhdGUsIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPiBhcmd1bWVudHMp CiB7Ci0gICAgaW50ZXJuYWxBZGRNZXNzYWdlKHBhZ2UoKSwgTG9nTWVzc2FnZVR5cGUsIFdhcm5p bmdNZXNzYWdlTGV2ZWwsIHN0YXRlLCBhcmd1bWVudHMpOworICAgIGludGVybmFsQWRkTWVzc2Fn ZShwYWdlRnJvbVNjcmlwdFN0YXRlKHN0YXRlKSwgTG9nTWVzc2FnZVR5cGUsIFdhcm5pbmdNZXNz YWdlTGV2ZWwsIHN0YXRlLCBhcmd1bWVudHMpOwogfQogCiB2b2lkIENvbnNvbGU6OmRpcihTY3Jp cHRTdGF0ZSogc3RhdGUsIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPiBhcmd1bWVudHMpCiB7 Ci0gICAgaW50ZXJuYWxBZGRNZXNzYWdlKHBhZ2UoKSwgRGlyTWVzc2FnZVR5cGUsIExvZ01lc3Nh Z2VMZXZlbCwgc3RhdGUsIGFyZ3VtZW50cyk7CisgICAgaW50ZXJuYWxBZGRNZXNzYWdlKHBhZ2VG cm9tU2NyaXB0U3RhdGUoc3RhdGUpLCBEaXJNZXNzYWdlVHlwZSwgTG9nTWVzc2FnZUxldmVsLCBz dGF0ZSwgYXJndW1lbnRzKTsKIH0KIAogdm9pZCBDb25zb2xlOjpkaXJ4bWwoU2NyaXB0U3RhdGUq IHN0YXRlLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4gYXJndW1lbnRzKQogewotICAgIGlu dGVybmFsQWRkTWVzc2FnZShwYWdlKCksIERpclhNTE1lc3NhZ2VUeXBlLCBMb2dNZXNzYWdlTGV2 ZWwsIHN0YXRlLCBhcmd1bWVudHMpOworICAgIGludGVybmFsQWRkTWVzc2FnZShwYWdlRnJvbVNj cmlwdFN0YXRlKHN0YXRlKSwgRGlyWE1MTWVzc2FnZVR5cGUsIExvZ01lc3NhZ2VMZXZlbCwgc3Rh dGUsIGFyZ3VtZW50cyk7CiB9CiAKIHZvaWQgQ29uc29sZTo6dGFibGUoU2NyaXB0U3RhdGUqIHN0 YXRlLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4gYXJndW1lbnRzKQogewotICAgIGludGVy bmFsQWRkTWVzc2FnZShwYWdlKCksIFRhYmxlTWVzc2FnZVR5cGUsIExvZ01lc3NhZ2VMZXZlbCwg c3RhdGUsIGFyZ3VtZW50cyk7CisgICAgaW50ZXJuYWxBZGRNZXNzYWdlKHBhZ2VGcm9tU2NyaXB0 U3RhdGUoc3RhdGUpLCBUYWJsZU1lc3NhZ2VUeXBlLCBMb2dNZXNzYWdlTGV2ZWwsIHN0YXRlLCBh cmd1bWVudHMpOwogfQogCiB2b2lkIENvbnNvbGU6OmNsZWFyKFNjcmlwdFN0YXRlKiBzdGF0ZSwg UGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+IGFyZ3VtZW50cykKIHsKLSAgICBpbnRlcm5hbEFk ZE1lc3NhZ2UocGFnZSgpLCBDbGVhck1lc3NhZ2VUeXBlLCBMb2dNZXNzYWdlTGV2ZWwsIHN0YXRl LCBhcmd1bWVudHMsIHRydWUpOworICAgIGludGVybmFsQWRkTWVzc2FnZShwYWdlRnJvbVNjcmlw dFN0YXRlKHN0YXRlKSwgQ2xlYXJNZXNzYWdlVHlwZSwgTG9nTWVzc2FnZUxldmVsLCBzdGF0ZSwg YXJndW1lbnRzLCB0cnVlKTsKIH0KIAogdm9pZCBDb25zb2xlOjp0cmFjZShTY3JpcHRTdGF0ZSog c3RhdGUsIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPiBhcmd1bWVudHMpCiB7Ci0gICAgaW50 ZXJuYWxBZGRNZXNzYWdlKHBhZ2UoKSwgVHJhY2VNZXNzYWdlVHlwZSwgTG9nTWVzc2FnZUxldmVs LCBzdGF0ZSwgYXJndW1lbnRzLCB0cnVlLCB0cnVlKTsKKyAgICBpbnRlcm5hbEFkZE1lc3NhZ2Uo cGFnZUZyb21TY3JpcHRTdGF0ZShzdGF0ZSksIFRyYWNlTWVzc2FnZVR5cGUsIExvZ01lc3NhZ2VM ZXZlbCwgc3RhdGUsIGFyZ3VtZW50cywgdHJ1ZSwgdHJ1ZSk7CiB9CiAKIHZvaWQgQ29uc29sZTo6 YXNzZXJ0Q29uZGl0aW9uKFNjcmlwdFN0YXRlKiBzdGF0ZSwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1 bWVudHM+IGFyZ3VtZW50cywgYm9vbCBjb25kaXRpb24pCkBAIC0xNzMsNyArMTczLDcgQEAgdm9p ZCBDb25zb2xlOjphc3NlcnRDb25kaXRpb24oU2NyaXB0U3RhdAogCiB2b2lkIENvbnNvbGU6OmNv dW50KFNjcmlwdFN0YXRlKiBzdGF0ZSwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+IGFyZ3Vt ZW50cykKIHsKLSAgICBJbnNwZWN0b3JJbnN0cnVtZW50YXRpb246OmNvbnNvbGVDb3VudChwYWdl KCksIHN0YXRlLCBhcmd1bWVudHMpOworICAgIEluc3BlY3Rvckluc3RydW1lbnRhdGlvbjo6Y29u c29sZUNvdW50KHBhZ2VGcm9tU2NyaXB0U3RhdGUoc3RhdGUpLCBzdGF0ZSwgYXJndW1lbnRzKTsK IH0KIAogdm9pZCBDb25zb2xlOjptYXJrVGltZWxpbmUoUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVu dHM+IGFyZ3VtZW50cykKQEAgLTI2OSw0ICsyNjksMTUgQEAgUGFnZSogQ29uc29sZTo6cGFnZSgp IGNvbnN0CiAgICAgcmV0dXJuIG1fZnJhbWUtPnBhZ2UoKTsKIH0KIAorUGFnZSogQ29uc29sZTo6 cGFnZUZyb21TY3JpcHRTdGF0ZShTY3JpcHRTdGF0ZSogc3RhdGUpCit7CisgICAgRE9NV2luZG93 KiB3aW5kb3cgPSBkb21XaW5kb3dGcm9tU2NyaXB0U3RhdGUoc3RhdGUpOworICAgIGlmICghd2lu ZG93KQorICAgICAgICByZXR1cm4gMDsKKyAgICBDb25zb2xlKiBjb25zb2xlID0gd2luZG93LT5j b25zb2xlKCk7CisgICAgaWYgKCFjb25zb2xlKQorICAgICAgICByZXR1cm4gMDsKKyAgICByZXR1 cm4gY29uc29sZS0+cGFnZSgpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBT b3VyY2UvV2ViQ29yZS9wYWdlL0NvbnNvbGUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29y ZS9wYWdlL0NvbnNvbGUuaAkocmV2aXNpb24gMTQ4MTA1KQorKysgU291cmNlL1dlYkNvcmUvcGFn ZS9Db25zb2xlLmgJKHdvcmtpbmcgY29weSkKQEAgLTUzLDE4ICs1MywxOCBAQCBwdWJsaWM6CiAg ICAgc3RhdGljIFBhc3NSZWZQdHI8Q29uc29sZT4gY3JlYXRlKEZyYW1lKiBmcmFtZSkgeyByZXR1 cm4gYWRvcHRSZWYobmV3IENvbnNvbGUoZnJhbWUpKTsgfQogICAgIHZpcnR1YWwgfkNvbnNvbGUo KTsKIAotICAgIHZvaWQgZGVidWcoU2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3Vt ZW50cz4pOwotICAgIHZvaWQgZXJyb3IoU2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFy Z3VtZW50cz4pOwotICAgIHZvaWQgaW5mbyhTY3JpcHRTdGF0ZSosIFBhc3NSZWZQdHI8U2NyaXB0 QXJndW1lbnRzPik7Ci0gICAgdm9pZCBsb2coU2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRyPFNjcmlw dEFyZ3VtZW50cz4pOwotICAgIHZvaWQgY2xlYXIoU2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRyPFNj cmlwdEFyZ3VtZW50cz4pOwotICAgIHZvaWQgd2FybihTY3JpcHRTdGF0ZSosIFBhc3NSZWZQdHI8 U2NyaXB0QXJndW1lbnRzPik7Ci0gICAgdm9pZCBkaXIoU2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRy PFNjcmlwdEFyZ3VtZW50cz4pOwotICAgIHZvaWQgZGlyeG1sKFNjcmlwdFN0YXRlKiwgUGFzc1Jl ZlB0cjxTY3JpcHRBcmd1bWVudHM+KTsKLSAgICB2b2lkIHRhYmxlKFNjcmlwdFN0YXRlKiwgUGFz c1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+KTsKLSAgICB2b2lkIHRyYWNlKFNjcmlwdFN0YXRlKiwg UGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+KTsKKyAgICBzdGF0aWMgdm9pZCBkZWJ1ZyhTY3Jp cHRTdGF0ZSosIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7CisgICAgc3RhdGljIHZvaWQg ZXJyb3IoU2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4pOworICAgIHN0 YXRpYyB2b2lkIGluZm8oU2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4p OworICAgIHN0YXRpYyB2b2lkIGxvZyhTY3JpcHRTdGF0ZSosIFBhc3NSZWZQdHI8U2NyaXB0QXJn dW1lbnRzPik7CisgICAgc3RhdGljIHZvaWQgY2xlYXIoU2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRy PFNjcmlwdEFyZ3VtZW50cz4pOworICAgIHN0YXRpYyB2b2lkIHdhcm4oU2NyaXB0U3RhdGUqLCBQ YXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4pOworICAgIHN0YXRpYyB2b2lkIGRpcihTY3JpcHRT dGF0ZSosIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7CisgICAgc3RhdGljIHZvaWQgZGly eG1sKFNjcmlwdFN0YXRlKiwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+KTsKKyAgICBzdGF0 aWMgdm9pZCB0YWJsZShTY3JpcHRTdGF0ZSosIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7 CisgICAgc3RhdGljIHZvaWQgdHJhY2UoU2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFy Z3VtZW50cz4pOwogICAgIHZvaWQgYXNzZXJ0Q29uZGl0aW9uKFNjcmlwdFN0YXRlKiwgUGFzc1Jl ZlB0cjxTY3JpcHRBcmd1bWVudHM+LCBib29sIGNvbmRpdGlvbik7Ci0gICAgdm9pZCBjb3VudChT Y3JpcHRTdGF0ZSosIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7CisgICAgc3RhdGljIHZv aWQgY291bnQoU2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4pOwogICAg IHZvaWQgbWFya1RpbWVsaW5lKFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7CiAjaWYgRU5B QkxFKEpBVkFTQ1JJUFRfREVCVUdHRVIpCiAgICAgY29uc3QgUHJvZmlsZXNBcnJheSYgcHJvZmls ZXMoKSBjb25zdCB7IHJldHVybiBtX3Byb2ZpbGVzOyB9CkBAIC04NSw2ICs4NSw4IEBAIHByaXZh dGU6CiAKICAgICBleHBsaWNpdCBDb25zb2xlKEZyYW1lKik7CiAKKyAgICBpbmxpbmUgc3RhdGlj IFBhZ2UqIHBhZ2VGcm9tU2NyaXB0U3RhdGUoU2NyaXB0U3RhdGUqKTsKKwogI2lmIEVOQUJMRShK QVZBU0NSSVBUX0RFQlVHR0VSKQogICAgIFByb2ZpbGVzQXJyYXkgbV9wcm9maWxlczsKICNlbmRp ZgpJbmRleDogU291cmNlL1dlYkNvcmUvcGFnZS9Db25zb2xlLmlkbAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBT b3VyY2UvV2ViQ29yZS9wYWdlL0NvbnNvbGUuaWRsCShyZXZpc2lvbiAxNDgxMDUpCisrKyBTb3Vy Y2UvV2ViQ29yZS9wYWdlL0NvbnNvbGUuaWRsCSh3b3JraW5nIGNvcHkpCkBAIC0zMSwxNSArMzEs MTUgQEAKICAgICBPbWl0Q29uc3RydWN0b3IKIF0gaW50ZXJmYWNlIENvbnNvbGUgewogCi0gICAg W0NhbGxXaXRoPVNjcmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZV0gdm9pZCBkZWJ1ZygpOwotICAg IFtDYWxsV2l0aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0U3RhdGVdIHZvaWQgZXJyb3IoKTsKLSAg ICBbQ2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlXSB2b2lkIGluZm8oKTsKLSAg ICBbQ2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlXSB2b2lkIGxvZygpOwotICAg IFtDYWxsV2l0aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0U3RhdGVdIHZvaWQgd2FybigpOwotICAg IFtDYWxsV2l0aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0U3RhdGVdIHZvaWQgZGlyKCk7Ci0gICAg W0NhbGxXaXRoPVNjcmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZV0gdm9pZCBkaXJ4bWwoKTsKLSAg ICBbQ2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlXSB2b2lkIHRhYmxlKCk7Ci0g ICAgW0NhbGxXaXRoPVNjcmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZV0gdm9pZCB0cmFjZSgpOwor ICAgIFtDYWxsV2l0aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0U3RhdGUsIExlbmllbnRUaGlzXSB2 b2lkIGRlYnVnKCk7CisgICAgW0NhbGxXaXRoPVNjcmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZSwg TGVuaWVudFRoaXNdIHZvaWQgZXJyb3IoKTsKKyAgICBbQ2FsbFdpdGg9U2NyaXB0QXJndW1lbnRz fFNjcmlwdFN0YXRlLCBMZW5pZW50VGhpc10gdm9pZCBpbmZvKCk7CisgICAgW0NhbGxXaXRoPVNj cmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZSwgTGVuaWVudFRoaXNdIHZvaWQgbG9nKCk7CisgICAg W0NhbGxXaXRoPVNjcmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZSwgTGVuaWVudFRoaXNdIHZvaWQg d2FybigpOworICAgIFtDYWxsV2l0aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0U3RhdGUsIExlbmll bnRUaGlzXSB2b2lkIGRpcigpOworICAgIFtDYWxsV2l0aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0 U3RhdGUsIExlbmllbnRUaGlzXSB2b2lkIGRpcnhtbCgpOworICAgIFtDYWxsV2l0aD1TY3JpcHRB cmd1bWVudHN8U2NyaXB0U3RhdGUsIExlbmllbnRUaGlzXSB2b2lkIHRhYmxlKCk7CisgICAgW0Nh bGxXaXRoPVNjcmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZSwgTGVuaWVudFRoaXNdIHZvaWQgdHJh Y2UoKTsKICAgICBbQ2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlLCBJbXBsZW1l bnRlZEFzPWFzc2VydENvbmRpdGlvbl0gdm9pZCBhc3NlcnQoaW4gYm9vbGVhbiBjb25kaXRpb24p OwogICAgIFtDYWxsV2l0aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0U3RhdGVdIHZvaWQgY291bnQo KTsKICAgICBbQ2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzXSB2b2lkIG1hcmtUaW1lbGluZSgpOwpA QCAtNTksNyArNTksNyBAQAogICAgIFtDYWxsV2l0aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0U3Rh dGVdIHZvaWQgZ3JvdXAoKTsKICAgICBbQ2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0 YXRlXSB2b2lkIGdyb3VwQ29sbGFwc2VkKCk7CiAgICAgdm9pZCBncm91cEVuZCgpOwotICAgIFtD YWxsV2l0aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0U3RhdGVdIHZvaWQgY2xlYXIoKTsKKyAgICBb Q2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlLCBMZW5pZW50VGhpc10gdm9pZCBj bGVhcigpOwogCiAgICAgcmVhZG9ubHkgYXR0cmlidXRlIE1lbW9yeUluZm8gbWVtb3J5OwogfTsK SW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9D aGFuZ2VMb2cJKHJldmlzaW9uIDE0ODE1OSkKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29y a2luZyBjb3B5KQpAQCAtMSwzICsxLDEzIEBACisyMDEzLTA0LTEwICBWaWN0b3IgQ29zdGFuICA8 Y29zdGFuQGdtYWlsLmNvbT4KKworICAgICAgICBDYWxsaW5nIGNvbnNvbGUue2xvZywgaW5mbywg ZXJyb3IsIC4uLn0gc2hvdWxkIG5vdCByZXF1aXJlIHRoaXMgPT09IGNvbnNvbGUKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTExNDQwNgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogZmFzdC9kb20vV2luZG93 L2NvbnNvbGUtdW5ib3VuZC1mdW5jdGlvbnMtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAg KiBmYXN0L2RvbS9XaW5kb3cvY29uc29sZS11bmJvdW5kLWZ1bmN0aW9ucy5odG1sOiBBZGRlZC4K KwogMjAxMy0wNC0xMCAgQmVuamFtaW4gUG91bGFpbiAgPGJwb3VsYWluQGFwcGxlLmNvbT4KIAog ICAgICAgICBNYXNzIHJlbW92ZSBhbGwgdGhlIGVtcHR5IGRpcmVjdG9yaWVzCkluZGV4OiBMYXlv dXRUZXN0cy9mYXN0L2RvbS9XaW5kb3cvY29uc29sZS11bmJvdW5kLWZ1bmN0aW9ucy1leHBlY3Rl ZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9kb20vV2luZG93L2NvbnNvbGUt dW5ib3VuZC1mdW5jdGlvbnMtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVz dHMvZmFzdC9kb20vV2luZG93L2NvbnNvbGUtdW5ib3VuZC1mdW5jdGlvbnMtZXhwZWN0ZWQudHh0 CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDEwIEBACitDT05TT0xFIE1FU1NBR0U6IGxpbmUgMTE6 IGNvbnNvbGUubG9nKCkgY2FsbGVkLgorQ09OU09MRSBNRVNTQUdFOiBsaW5lIDEzOiBjb25zb2xl LmluZm8oKSBjYWxsZWQuCitDT05TT0xFIE1FU1NBR0U6IGxpbmUgMTU6IGNvbnNvbGUud2Fybigp IGNhbGxlZC4KK0NPTlNPTEUgTUVTU0FHRTogbGluZSAxNzogY29uc29sZS5lcnJvcigpIGNhbGxl ZC4KK1Rlc3RzIHdpbmRvdy5jb25zb2xlIGZ1bmN0aW9ucyB3aGVuICJ0aGlzIiBpcyBub3Qgc2V0 IHRvIGNvbnNvbGUuIFRvIG1ha2Ugc3VyZSB0aGlzIHRlc3QgcGFzc2VkIHlvdSBtdXN0IGNoZWNr IHRoZSBjb25zb2xlIGZvciB0aGUgZm9sbG93aW5nIDQgbWVzc2FnZXM6CisKK2NvbnNvbGUubG9n KCkgY2FsbGVkLgorY29uc29sZS5pbmZvKCkgY2FsbGVkLgorY29uc29sZS53YXJuKCkgY2FsbGVk LgorY29uc29sZS5lcnJvcigpIGNhbGxlZC4KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZG9tL1dp bmRvdy9jb25zb2xlLXVuYm91bmQtZnVuY3Rpb25zLmh0bWwKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0 VGVzdHMvZmFzdC9kb20vV2luZG93L2NvbnNvbGUtdW5ib3VuZC1mdW5jdGlvbnMuaHRtbAkocmV2 aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL1dpbmRvdy9jb25zb2xlLXVuYm91bmQt ZnVuY3Rpb25zLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMzAgQEAKKzwhRE9DVFlQRSBo dG1sPgorPGh0bWw+Cis8aGVhZD4KKyAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+ CisgICAgICAgIGZ1bmN0aW9uIHJ1blRlc3RzKCkKKyAgICAgICAgeworICAgICAgICAgICAgaWYg KHdpbmRvdy50ZXN0UnVubmVyKQorICAgICAgICAgICAgICAgIHRlc3RSdW5uZXIuZHVtcEFzVGV4 dCgpOworCisgICAgICAgICAgICB2YXIgbG9nID0gY29uc29sZS5sb2c7CisgICAgICAgICAgICBs b2coImNvbnNvbGUubG9nKCkgY2FsbGVkLiIpOworICAgICAgICAgICAgdmFyIGluZm8gPSBjb25z b2xlLmluZm87CisgICAgICAgICAgICBpbmZvKCJjb25zb2xlLmluZm8oKSBjYWxsZWQuIik7Cisg ICAgICAgICAgICB2YXIgd2FybiA9IGNvbnNvbGUud2FybjsKKyAgICAgICAgICAgIHdhcm4oImNv bnNvbGUud2FybigpIGNhbGxlZC4iKTsKKyAgICAgICAgICAgIHZhciBlcnJvciA9IGNvbnNvbGUu ZXJyb3I7CisgICAgICAgICAgICBlcnJvcigiY29uc29sZS5lcnJvcigpIGNhbGxlZC4iKTsKKyAg ICAgICAgfQorICAgIDwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHkgb25sb2FkPSJydW5UZXN0cygp OyI+CisgICAgPHA+VGVzdHMgd2luZG93LmNvbnNvbGUgZnVuY3Rpb25zIHdoZW4gInRoaXMiIGlz IG5vdCBzZXQgdG8gY29uc29sZS4gIFRvIG1ha2Ugc3VyZSB0aGlzIHRlc3QgcGFzc2VkIHlvdSBt dXN0IGNoZWNrIHRoZSBjb25zb2xlIGZvciB0aGUgZm9sbG93aW5nIDQgbWVzc2FnZXM6PC9wPgor ICAgIDx1bD4KKyAgICAgICAgPGxpPmNvbnNvbGUubG9nKCkgY2FsbGVkLjwvbGk+CisgICAgICAg IDxsaT5jb25zb2xlLmluZm8oKSBjYWxsZWQuPC9saT4KKyAgICAgICAgPGxpPmNvbnNvbGUud2Fy bigpIGNhbGxlZC48L2xpPgorICAgICAgICA8bGk+Y29uc29sZS5lcnJvcigpIGNhbGxlZC48L2xp PgorICAgIDwvdWw+Cis8L2JvZHk+Cis8L2h0bWw+Cg== 197675 2013-04-11 14:46:25 -0700 2013-04-11 14:52:14 -0700 Patch bug-20141-20130411174604.patch text/plain 36567 costan SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDE0ODE4MSkKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDQ5IEBACisyMDEzLTA0LTEwICBWaWN0b3Ig Q29zdGFuICA8Y29zdGFuQGdtYWlsLmNvbT4KKworICAgICAgICBDYWxsaW5nIGNvbnNvbGUue2xv ZywgaW5mbywgZXJyb3IsIC4uLn0gc2hvdWxkIG5vdCByZXF1aXJlIHRoaXMgPT09IGNvbnNvbGUK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTExNDQwNgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRlc3Q6IGZh c3QvZG9tL1dpbmRvdy9jb25zb2xlLXVuYm91bmQtZnVuY3Rpb25zLmh0bWwKKworICAgICAgICAq IGJpbmRpbmdzL3NjcmlwdHMvQ29kZUdlbmVyYXRvckpTLnBtOiBpbXBsZW1lbnRlZCB0aGUgW0xl bmllbnRUaGlzXSBtZXRob2QgYXR0cmlidXRlCisgICAgICAgIChBZGRJbmNsdWRlc0ZvclR5cGVJ bkltcGwpOiB3aGl0ZXNwYWNlIHJlbW92YWwKKyAgICAgICAgKEFkZEluY2x1ZGVzRm9yVHlwZUlu SGVhZGVyKTogd2hpdGVzcGFjZSByZW1vdmFsCisgICAgICAgIChHZW5lcmF0ZUdldE93blByb3Bl cnR5RGVzY3JpcHRvckJvZHkpOiB3aGl0ZXNwYWNlIHJlbW92YWwKKyAgICAgICAgKEdlbmVyYXRl SGVhZGVyKTogW0xlbmllbnRUaGlzXSBtZXRob2RzIGFyZSBzdGF0aWMKKyAgICAgICAgKEdlbmVy YXRlQXR0cmlidXRlc0hhc2hUYWJsZSk6IHdoaXRlc3BhY2UgcmVtb3ZhbAorICAgICAgICAoR2Vu ZXJhdGVJbXBsZW1lbnRhdGlvbik6IFtMZW5pZW50VGhpc10gbWV0aG9kIHNob3VsZCBiZSBpbnZv a2VkIHVzaW5nIHRoZSBzdGF0aWMgbWV0aG9kIHN5bnRheAorICAgICAgICAoR2VuZXJhdGVQYXJh bWV0ZXJzQ2hlY2spOiBbTGVuaWVudFRoaXNdIG1ldGhvZCBzaG91bGQgYmUgaW52b2tlZCB1c2lu ZyB0aGUgc3RhdGljIG1ldGhvZCBzeW50YXggCisgICAgICAgIChHZW5lcmF0ZUltcGxlbWVudGF0 aW9uRnVuY3Rpb25DYWxsKTogd2hpdGVzcGFjZSByZW1vdmFsCisgICAgICAgIChHZXRTVkdQcm9w ZXJ0eVR5cGVzKTogd2hpdGVzcGFjZSByZW1vdmFsCisgICAgICAgIChHZW5lcmF0ZUhhc2hUYWJs ZSk6IHdoaXRlc3BhY2UgcmVtb3ZhbAorICAgICAgICAoTWFrZXNTdGF0aWNDYWxsKTogcmV0dXJu cyB0cnVlIGZvciBtZXRob2RzIHRoYXQgZ2VuZXJhdGUgc3RhdGljIGNhbGxzIGluIFdlYkNvcmUK KyAgICAgICAgKiBiaW5kaW5ncy9zY3JpcHRzL0lETEF0dHJpYnV0ZXMudHh0OiBhZGRlZCB0aGUg W0xlbmllbnRUaGlzXSBtZXRob2QgYXR0cmlidXRlCisgICAgICAgICogYmluZGluZ3Mvc2NyaXB0 cy90ZXN0L0NQUC9XZWJET01UZXN0T2JqLmNwcDogcmVnZW5lcmF0ZWQgdGVzdAorICAgICAgICAq IGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9DUFAvV2ViRE9NVGVzdE9iai5oOiByZWdlbmVyYXRlZCB0 ZXN0CisgICAgICAgICogYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0dPYmplY3QvV2ViS2l0RE9NVGVz dE9iai5jcHA6IHJlZ2VuZXJhdGVkIHRlc3QKKyAgICAgICAgKiBiaW5kaW5ncy9zY3JpcHRzL3Rl c3QvR09iamVjdC9XZWJLaXRET01UZXN0T2JqLmg6IHJlZ2VuZXJhdGVkIHRlc3QKKyAgICAgICAg KiBiaW5kaW5ncy9zY3JpcHRzL3Rlc3QvSlMvSlNUZXN0T2JqLmNwcDogcmVnZW5lcmF0ZWQgdGVz dAorICAgICAgICAqIGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9KUy9KU1Rlc3RPYmouaDogcmVnZW5l cmF0ZWQgdGVzdAorICAgICAgICAqIGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9PYmpDL0RPTVRlc3RP YmouaDogcmVnZW5lcmF0ZWQgdGVzdAorICAgICAgICAqIGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9P YmpDL0RPTVRlc3RPYmoubW06IHJlZ2VuZXJhdGVkIHRlc3QKKyAgICAgICAgKiBiaW5kaW5ncy9z Y3JpcHRzL3Rlc3QvVGVzdE9iai5pZGw6IGFkZGVkIG1ldGhvZCB0aGF0IHRlc3RzIHRoZSBbTGVu aWVudFRoaXNdIGF0dHJpYnV0ZQorICAgICAgICAqIHBhZ2UvQ29uc29sZS5jcHA6IG1hZGUgYSBi dW5jaCBvZiBjb25zb2xlIG1ldGhvZHMgc3RhdGljCisgICAgICAgIChXZWJDb3JlOjpDb25zb2xl OjpkZWJ1Zyk6IGJlY2FtZSBzdGF0aWMKKyAgICAgICAgKFdlYkNvcmU6OkNvbnNvbGU6OmVycm9y KTogYmVjYW1lIHN0YXRpYworICAgICAgICAoV2ViQ29yZTo6Q29uc29sZTo6bG9nKTogYmVjYW1l IHN0YXRpYworICAgICAgICAoV2ViQ29yZTo6Q29uc29sZTo6d2Fybik6IGJlY2FtZSBzdGF0aWMK KyAgICAgICAgKFdlYkNvcmU6OkNvbnNvbGU6OmRpcik6IGJlY2FtZSBzdGF0aWMKKyAgICAgICAg KFdlYkNvcmU6OkNvbnNvbGU6OmRpcnhtbCk6IGJlY2FtZSBzdGF0aWMKKyAgICAgICAgKFdlYkNv cmU6OkNvbnNvbGU6OnRhYmxlKTogYmVjYW1lIHN0YXRpYworICAgICAgICAoV2ViQ29yZTo6Q29u c29sZTo6Y2xlYXIpOiBiZWNhbWUgc3RhdGljCisgICAgICAgIChXZWJDb3JlOjpDb25zb2xlOjp0 cmFjZSk6IGJlY2FtZSBzdGF0aWMKKyAgICAgICAgKFdlYkNvcmU6OkNvbnNvbGU6OmNvdW50KTog YmVjYW1lIHN0YXRpYworICAgICAgICAoV2ViQ29yZTo6Q29uc29sZTo6cGFnZUZyb21TY3JpcHRT dGF0ZSk6IHJlY292ZXJzIENvbnNvbGUgZGF0YSBmcm9tIHRoZSBTY3JpcHRTdGF0ZQorICAgICAg ICAqIHBhZ2UvQ29uc29sZS5oOiBkZWNsYXJlZCB0aGUgbWV0aG9kcyBhYm92ZSB0byBiZSBzdGF0 aWMKKyAgICAgICAgKiBwYWdlL0NvbnNvbGUuaWRsOiBhZGRlZCB0aGUgW0xlbmllbnRUaGlzXSBh dHRyaWJ1dGUgdG8gdGhlIGNvbnNvbGUgbWV0aG9kcyBsaXN0ZWQgYWJvdmUKKwogMjAxMy0wNC0x MCAgQWxleGV5IFByb3NrdXJ5YWtvdiAgPGFwQGFwcGxlLmNvbT4KIAogICAgICAgICBSZW1vdmUg c29tZSBpbmNsdWRlcyBvZiBDYWNoZWRJbWFnZS5oCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9iaW5k aW5ncy9zY3JpcHRzL0NvZGVHZW5lcmF0b3JKUy5wbQo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5lcmF0b3JKUy5wbQkocmV2aXNpb24gMTQ4MTgx KQorKysgU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9Db2RlR2VuZXJhdG9ySlMucG0J KHdvcmtpbmcgY29weSkKQEAgLTE4OCw5ICsxODgsOSBAQCBzdWIgQWRkSW5jbHVkZXNGb3JUeXBl SW5JbXBsCiB7CiAgICAgbXkgJHR5cGUgPSBzaGlmdDsKICAgICBteSAkaXNDYWxsYmFjayA9IEBf ID8gc2hpZnQgOiAwOwotICAgIAorCiAgICAgQWRkSW5jbHVkZXNGb3JUeXBlKCR0eXBlLCAkaXND YWxsYmFjaywgXCVpbXBsSW5jbHVkZXMpOwotICAgIAorCiAgICAgIyBhZGRpdGlvbmFsIGluY2x1 ZGVzICh0aGluZ3MgbmVlZGVkIHRvIGNvbXBpbGUgdGhlIGJpbmRpbmdzIGJ1dCBub3QgdGhlIGhl YWRlcikKICAgICBpZiAoJHR5cGUgZXEgIkNhbnZhc1JlbmRlcmluZ0NvbnRleHQyRCIpIHsKICAg ICAgICAgJGltcGxJbmNsdWRlc3siQ2FudmFzR3JhZGllbnQuaCJ9ID0gMTsKQEAgLTIxNSw3ICsy MTUsNyBAQCBzdWIgQWRkSW5jbHVkZXNGb3JUeXBlSW5IZWFkZXIKIHsKICAgICBteSAkdHlwZSA9 IHNoaWZ0OwogICAgIG15ICRpc0NhbGxiYWNrID0gQF8gPyBzaGlmdCA6IDA7Ci0gICAgCisKICAg ICBBZGRJbmNsdWRlc0ZvclR5cGUoJHR5cGUsICRpc0NhbGxiYWNrLCBcJWhlYWRlckluY2x1ZGVz KTsKIH0KIApAQCAtNDY0LDkgKzQ2NCw5IEBAIHN1YiBHZW5lcmF0ZUdldE93blByb3BlcnR5U2xv dEJvZHkKIHN1YiBHZW5lcmF0ZUdldE93blByb3BlcnR5RGVzY3JpcHRvckJvZHkKIHsKICAgICBt eSAoJGludGVyZmFjZSwgJGludGVyZmFjZU5hbWUsICRjbGFzc05hbWUsICRoYXNBdHRyaWJ1dGVz LCAkaW5saW5lZCkgPSBAXzsKLSAgICAKKwogICAgIG15ICRuYW1lc3BhY2VNYXliZSA9ICgkaW5s aW5lZCA/ICJKU0M6OiIgOiAiIik7Ci0gICAgCisKICAgICBteSBAZ2V0T3duUHJvcGVydHlEZXNj cmlwdG9ySW1wbCA9ICgpOwogICAgIGlmICgkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJpYnV0ZXMt PnsiQ2hlY2tTZWN1cml0eSJ9KSB7CiAgICAgICAgIGlmICgkaW50ZXJmYWNlTmFtZSBlcSAiRE9N V2luZG93IikgewpAQCAtNDc3LDEzICs0NzcsMTMgQEAgc3ViIEdlbmVyYXRlR2V0T3duUHJvcGVy dHlEZXNjcmlwdG9yQm9keQogICAgICAgICB9CiAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAi ICAgICAgICByZXR1cm4gZmFsc2U7XG4iKTsKICAgICB9Ci0gICAgCisKICAgICBpZiAoJGludGVy ZmFjZU5hbWUgZXEgIk5hbWVkTm9kZU1hcCIgb3IgJGludGVyZmFjZU5hbWUgPX4gL15IVE1MXHcq Q29sbGVjdGlvbiQvKSB7CiAgICAgICAgIHB1c2goQGdldE93blByb3BlcnR5RGVzY3JpcHRvcklt cGwsICIgICAgJHtuYW1lc3BhY2VNYXliZX1KU1ZhbHVlIHByb3RvID0gdGhpc09iamVjdC0+cHJv dG90eXBlKCk7XG4iKTsKICAgICAgICAgcHVzaChAZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9ySW1w bCwgIiAgICBpZiAocHJvdG8uaXNPYmplY3QoKSAmJiBqc0Nhc3Q8JHtuYW1lc3BhY2VNYXliZX1K U09iamVjdCo+KGFzT2JqZWN0KHByb3RvKSktPmhhc1Byb3BlcnR5KGV4ZWMsIHByb3BlcnR5TmFt ZSkpXG4iKTsKICAgICAgICAgcHVzaChAZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9ySW1wbCwgIiAg ICAgICAgcmV0dXJuIGZhbHNlO1xuXG4iKTsKICAgICB9Ci0gICAgCisKICAgICBteSAkbWFudWFs TG9va3VwR2V0dGVyR2VuZXJhdGlvbiA9IHN1YiB7CiAgICAgICAgIG15ICRyZXF1aXJlc01hbnVh bExvb2t1cCA9ICRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJJbmRleGVkR2V0dGVy In0gfHwgJGludGVyZmFjZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57Ik5hbWVkR2V0dGVyIn07CiAg ICAgICAgIGlmICgkcmVxdWlyZXNNYW51YWxMb29rdXApIHsKQEAgLTU1OCw3ICs1NTgsNyBAQCBz dWIgR2VuZXJhdGVHZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JCb2R5CiAgICAgfSBlbHNlIHsKICAg ICAgICAgcHVzaChAZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9ySW1wbCwgIiAgICByZXR1cm4gQmFz ZTo6Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9yKHRoaXNPYmplY3QsIGV4ZWMsIHByb3BlcnR5TmFt ZSwgZGVzY3JpcHRvcik7XG4iKTsKICAgICB9Ci0gICAgCisKICAgICByZXR1cm4gQGdldE93blBy b3BlcnR5RGVzY3JpcHRvckltcGw7CiB9CiAKQEAgLTY5NSw3ICs2OTUsNyBAQCBzdWIgR2VuZXJh dGVIZWFkZXIKICAgICAgICAgICAgICRoZWFkZXJJbmNsdWRlc3siJGludGVyZmFjZU5hbWUuaCJ9 ID0gMTsKICAgICAgICAgfQogICAgIH0KLSAgICAKKwogICAgICRoZWFkZXJJbmNsdWRlc3siPHJ1 bnRpbWUvSlNPYmplY3QuaD4ifSA9IDE7CiAgICAgJGhlYWRlckluY2x1ZGVzeyJTVkdFbGVtZW50 LmgifSA9IDEgaWYgJGNsYXNzTmFtZSA9fiAvXkpTU1ZHLzsKIApAQCAtNzg3LDcgKzc4Nyw3IEBA IHN1YiBHZW5lcmF0ZUhlYWRlcgogICAgICAgICB8fCAkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJp YnV0ZXMtPnsiTnVtZXJpY0luZGV4ZWRHZXR0ZXIifQogICAgICAgICB8fCAkaW50ZXJmYWNlLT5l eHRlbmRlZEF0dHJpYnV0ZXMtPnsiSlNDdXN0b21HZXRPd25Qcm9wZXJ0eVNsb3RBbmREZXNjcmlw dG9yIn0KICAgICAgICAgfHwgJGhhc0ltcHVyZU5hbWVkR2V0dGVyOwotICAgIAorCiAgICAgbXkg JGhhc0dldHRlciA9ICRudW1BdHRyaWJ1dGVzID4gMCB8fCAhJGludGVyZmFjZS0+ZXh0ZW5kZWRB dHRyaWJ1dGVzLT57Ik9taXRDb25zdHJ1Y3RvciJ9IHx8ICRoYXNDb21wbGV4R2V0dGVyOwogCiAg ICAgaWYgKCRoYXNJbXB1cmVOYW1lZEdldHRlcikgewpAQCAtODE3LDcgKzgxNyw3IEBAIHN1YiBH ZW5lcmF0ZUhlYWRlcgogICAgICAgICAkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsi Q3VzdG9tUHV0RnVuY3Rpb24ifQogICAgICAgICB8fCAkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJp YnV0ZXMtPnsiQ3VzdG9tTmFtZWRTZXR0ZXIifQogICAgICAgICB8fCAkaW50ZXJmYWNlLT5leHRl bmRlZEF0dHJpYnV0ZXMtPnsiQ3VzdG9tSW5kZXhlZFNldHRlciJ9OwotICAgICAgICAKKwogICAg IG15ICRoYXNTZXR0ZXIgPSAkaGFzUmVhZFdyaXRlUHJvcGVydGllcyB8fCAkaGFzQ29tcGxleFNl dHRlcjsKIAogICAgICMgR2V0dGVycwpAQCAtODcwLDcgKzg3MCw3IEBAIHN1YiBHZW5lcmF0ZUhl YWRlcgogICAgICMgQ3VzdG9tIGdldE93blByb3BlcnR5TmFtZXMgZnVuY3Rpb24KICAgICBpZiAo JGludGVyZmFjZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57IkN1c3RvbUVudW1lcmF0ZVByb3BlcnR5 In0gfHwgJGludGVyZmFjZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57IkluZGV4ZWRHZXR0ZXIifSB8 fCAkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiTnVtZXJpY0luZGV4ZWRHZXR0ZXIi fSkgewogICAgICAgICBwdXNoKEBoZWFkZXJDb250ZW50LCAiICAgIHN0YXRpYyB2b2lkIGdldE93 blByb3BlcnR5TmFtZXMoSlNDOjpKU09iamVjdCosIEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpQcm9w ZXJ0eU5hbWVBcnJheSYsIEpTQzo6RW51bWVyYXRpb25Nb2RlIG1vZGUgPSBKU0M6OkV4Y2x1ZGVE b250RW51bVByb3BlcnRpZXMpO1xuIik7Ci0gICAgICAgICRzdHJ1Y3R1cmVGbGFnc3siSlNDOjpP dmVycmlkZXNHZXRQcm9wZXJ0eU5hbWVzIn0gPSAxOyAgICAgICAKKyAgICAgICAgJHN0cnVjdHVy ZUZsYWdzeyJKU0M6Ok92ZXJyaWRlc0dldFByb3BlcnR5TmFtZXMifSA9IDE7CiAgICAgfQogCiAg ICAgIyBDdXN0b20gZGVmaW5lT3duUHJvcGVydHkgZnVuY3Rpb24KQEAgLTk0MSw3ICs5NDEsNyBA QCBzdWIgR2VuZXJhdGVIZWFkZXIKICAgICAgICAgICAgIG15ICRjb25kaXRpb25hbFN0cmluZyA9 ICRjb2RlR2VuZXJhdG9yLT5HZW5lcmF0ZUNvbmRpdGlvbmFsU3RyaW5nKCRmdW5jdGlvbi0+c2ln bmF0dXJlKTsKICAgICAgICAgICAgIHB1c2goQGhlYWRlckNvbnRlbnQsICIjaWYgJHtjb25kaXRp b25hbFN0cmluZ31cbiIpIGlmICRjb25kaXRpb25hbFN0cmluZzsKICAgICAgICAgICAgIG15ICRm dW5jdGlvbkltcGxlbWVudGF0aW9uTmFtZSA9ICRmdW5jdGlvbi0+c2lnbmF0dXJlLT5leHRlbmRl ZEF0dHJpYnV0ZXMtPnsiSW1wbGVtZW50ZWRBcyJ9IHx8ICRjb2RlR2VuZXJhdG9yLT5XS19sY2Zp cnN0KCRmdW5jdGlvbi0+c2lnbmF0dXJlLT5uYW1lKTsKLSAgICAgICAgICAgIHB1c2goQGhlYWRl ckNvbnRlbnQsICIgICAgIiAuICgkZnVuY3Rpb24tPmlzU3RhdGljID8gInN0YXRpYyAiIDogIiIp IC4gIkpTQzo6SlNWYWx1ZSAiIC4gJGZ1bmN0aW9uSW1wbGVtZW50YXRpb25OYW1lIC4gIihKU0M6 OkV4ZWNTdGF0ZSopO1xuIik7CisgICAgICAgICAgICBwdXNoKEBoZWFkZXJDb250ZW50LCAiICAg ICIgLiAoTWFrZXNTdGF0aWNDYWxsKCRmdW5jdGlvbikgPyAic3RhdGljICIgOiAiIikgLiAiSlND OjpKU1ZhbHVlICIgLiAkZnVuY3Rpb25JbXBsZW1lbnRhdGlvbk5hbWUgLiAiKEpTQzo6RXhlY1N0 YXRlKik7XG4iKTsKICAgICAgICAgICAgIHB1c2goQGhlYWRlckNvbnRlbnQsICIjZW5kaWZcbiIp IGlmICRjb25kaXRpb25hbFN0cmluZzsKICAgICAgICAgfQogICAgIH0KQEAgLTEwNzIsNyArMTA3 Miw3IEBAIHN1YiBHZW5lcmF0ZUhlYWRlcgogICAgIGlmICgkdXNlc1RvSlNOZXdseUNyZWF0ZWR7 JGludGVyZmFjZU5hbWV9KSB7CiAgICAgICAgIHB1c2goQGhlYWRlckNvbnRlbnQsICJKU0M6OkpT VmFsdWUgdG9KU05ld2x5Q3JlYXRlZChKU0M6OkV4ZWNTdGF0ZSosIEpTRE9NR2xvYmFsT2JqZWN0 KiwgJGludGVyZmFjZU5hbWUqKTtcbiIpOwogICAgIH0KLSAgICAKKwogICAgIHB1c2goQGhlYWRl ckNvbnRlbnQsICJcbiIpOwogCiAgICAgIyBBZGQgcHJvdG90eXBlIGRlY2xhcmF0aW9uLgpAQCAt MTE1Niw3ICsxMTU2LDcgQEAgc3ViIEdlbmVyYXRlSGVhZGVyCiAgICAgICAgICAgICB9CiAgICAg ICAgICAgICBwdXNoKEBoZWFkZXJDb250ZW50LCAiI2VuZGlmXG4iKSBpZiAkY29uZGl0aW9uYWxT dHJpbmc7CiAgICAgICAgIH0KLSAgICAgICAgCisKICAgICAgICAgaWYgKCEkaW50ZXJmYWNlLT5l eHRlbmRlZEF0dHJpYnV0ZXMtPnsiT21pdENvbnN0cnVjdG9yIn0pIHsKICAgICAgICAgICAgIG15 ICRnZXR0ZXIgPSAianMiIC4gJGludGVyZmFjZU5hbWUgLiAiQ29uc3RydWN0b3IiOwogICAgICAg ICAgICAgcHVzaChAaGVhZGVyQ29udGVudCwgIkpTQzo6SlNWYWx1ZSAke2dldHRlcn0oSlNDOjpF eGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIEpTQzo6UHJvcGVydHlOYW1lKTtcbiIpOwpAQCAtMTE4 Nyw3ICsxMTg3LDcgQEAgc3ViIEdlbmVyYXRlSGVhZGVyCiAgICAgIyAtIEdlbmVyYXRlIGRlcGVu ZGVuY2llcy4KICAgICBpZiAoJHdyaXRlRGVwZW5kZW5jaWVzICYmIEBhbmNlc3RvckludGVyZmFj ZU5hbWVzKSB7CiAgICAgICAgIHB1c2goQGRlcHNDb250ZW50LCAiJGNsYXNzTmFtZS5oIDogIiwg am9pbigiICIsIG1hcCB7ICIkXy5pZGwiIH0gQGFuY2VzdG9ySW50ZXJmYWNlTmFtZXMpLCAiXG4i KTsKLSAgICAgICAgcHVzaChAZGVwc0NvbnRlbnQsIG1hcCB7ICIkXy5pZGwgOlxuIiB9IEBhbmNl c3RvckludGVyZmFjZU5hbWVzKTsgCisgICAgICAgIHB1c2goQGRlcHNDb250ZW50LCBtYXAgeyAi JF8uaWRsIDpcbiIgfSBAYW5jZXN0b3JJbnRlcmZhY2VOYW1lcyk7CiAgICAgfQogfQogCkBAIC0x MTk4LDcgKzExOTgsNyBAQCBzdWIgR2VuZXJhdGVBdHRyaWJ1dGVzSGFzaFRhYmxlKCQkKQogICAg ICMgRklYTUU6IFRoZXNlIHNob3VsZCBiZSBmdW5jdGlvbnMgb24gJGludGVyZmFjZS4KICAgICBt eSAkaW50ZXJmYWNlTmFtZSA9ICRpbnRlcmZhY2UtPm5hbWU7CiAgICAgbXkgJGNsYXNzTmFtZSA9 ICJKUyRpbnRlcmZhY2VOYW1lIjsKLSAgICAKKwogICAgICMgLSBBZGQgYWxsIGF0dHJpYnV0ZXMg aW4gYSBoYXNodGFibGUgZGVmaW5pdGlvbgogICAgIG15ICRudW1BdHRyaWJ1dGVzID0gQHskaW50 ZXJmYWNlLT5hdHRyaWJ1dGVzfTsKICAgICAkbnVtQXR0cmlidXRlcysrIGlmICEkaW50ZXJmYWNl LT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiT21pdENvbnN0cnVjdG9yIn07CkBAIC0xMjUyLDcgKzEy NTIsNyBAQCBzdWIgR2VuZXJhdGVBdHRyaWJ1dGVzSGFzaFRhYmxlKCQkKQogICAgICAgICAgICAg bXkgJHNldHRlciA9ICJzZXRKUyIgLiAkaW50ZXJmYWNlTmFtZSAuICJDb25zdHJ1Y3RvciI7CiAg ICAgICAgICAgICBwdXNoKEBoYXNoVmFsdWUyLCAkc2V0dGVyKTsKICAgICAgICAgICAgIHB1c2go QGhhc2hTcGVjaWFscywgIkRvbnRFbnVtIHwgRG9udERlbGV0ZSIpOwotICAgICAgICB9IGVsc2Ug eyAgICAgICAgICAgIAorICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgcHVzaChAaGFzaFZh bHVlMiwgIjAiKTsKICAgICAgICAgICAgIHB1c2goQGhhc2hTcGVjaWFscywgIkRvbnRFbnVtIHwg UmVhZE9ubHkiKTsKICAgICAgICAgfQpAQCAtMTYwMyw3ICsxNjAzLDcgQEAgc3ViIEdlbmVyYXRl SW1wbGVtZW50YXRpb24KICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQsICIgICAgJHtjbGFzc05h bWV9UHJvdG90eXBlKiB0aGlzT2JqZWN0ID0ganNDYXN0PCR7Y2xhc3NOYW1lfVByb3RvdHlwZSo+ KGNlbGwpO1xuIik7CiAKICAgICAgICAgaWYgKCRudW1Db25zdGFudHMgZXEgMCAmJiAkbnVtRnVu Y3Rpb25zIGVxIDApIHsKLSAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAiICAgIHJldHVy biBCYXNlOjpnZXRPd25Qcm9wZXJ0eVNsb3QodGhpc09iamVjdCwgZXhlYywgcHJvcGVydHlOYW1l LCBzbG90KTtcbiIpOyAgICAgICAgCisgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAg ICByZXR1cm4gQmFzZTo6Z2V0T3duUHJvcGVydHlTbG90KHRoaXNPYmplY3QsIGV4ZWMsIHByb3Bl cnR5TmFtZSwgc2xvdCk7XG4iKTsKICAgICAgICAgfSBlbHNpZiAoJG51bUNvbnN0YW50cyBlcSAw KSB7CiAgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAgICByZXR1cm4gZ2V0U3RhdGlj RnVuY3Rpb25TbG90PEpTT2JqZWN0PihleGVjLCAiIC4gcHJvdG90eXBlSGFzaFRhYmxlQWNjZXNz b3IoJGludGVyZmFjZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57IkpTTm9TdGF0aWNUYWJsZXMifSwg JGNsYXNzTmFtZSkgLiAiLCB0aGlzT2JqZWN0LCBwcm9wZXJ0eU5hbWUsIHNsb3QpO1xuIik7CiAg ICAgICAgIH0gZWxzaWYgKCRudW1GdW5jdGlvbnMgZXEgMCkgewpAQCAtMTYxOCw3ICsxNjE4LDcg QEAgc3ViIEdlbmVyYXRlSW1wbGVtZW50YXRpb24KICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQs ICIgICAgJHtjbGFzc05hbWV9UHJvdG90eXBlKiB0aGlzT2JqZWN0ID0ganNDYXN0PCR7Y2xhc3NO YW1lfVByb3RvdHlwZSo+KG9iamVjdCk7XG4iKTsKIAogICAgICAgICBpZiAoJG51bUNvbnN0YW50 cyBlcSAwICYmICRudW1GdW5jdGlvbnMgZXEgMCkgewotICAgICAgICAgICAgcHVzaChAaW1wbENv bnRlbnQsICIgICAgcmV0dXJuIEJhc2U6OmdldE93blByb3BlcnR5RGVzY3JpcHRvcih0aGlzT2Jq ZWN0LCBleGVjLCBwcm9wZXJ0eU5hbWUsIGRlc2NyaXB0b3IpO1xuIik7ICAgICAgICAKKyAgICAg ICAgICAgIHB1c2goQGltcGxDb250ZW50LCAiICAgIHJldHVybiBCYXNlOjpnZXRPd25Qcm9wZXJ0 eURlc2NyaXB0b3IodGhpc09iamVjdCwgZXhlYywgcHJvcGVydHlOYW1lLCBkZXNjcmlwdG9yKTtc biIpOwogICAgICAgICB9IGVsc2lmICgkbnVtQ29uc3RhbnRzIGVxIDApIHsKICAgICAgICAgICAg IHB1c2goQGltcGxDb250ZW50LCAiICAgIHJldHVybiBnZXRTdGF0aWNGdW5jdGlvbkRlc2NyaXB0 b3I8SlNPYmplY3Q+KGV4ZWMsICIgLiBwcm90b3R5cGVIYXNoVGFibGVBY2Nlc3NvcigkaW50ZXJm YWNlLT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiSlNOb1N0YXRpY1RhYmxlcyJ9LCAkY2xhc3NOYW1l KSAuICIsIHRoaXNPYmplY3QsIHByb3BlcnR5TmFtZSwgZGVzY3JpcHRvcik7XG4iKTsKICAgICAg ICAgfSBlbHNpZiAoJG51bUZ1bmN0aW9ucyBlcSAwKSB7CkBAIC0xNzE5LDcgKzE3MTksNyBAQCBz dWIgR2VuZXJhdGVJbXBsZW1lbnRhdGlvbgogICAgIH0KIAogICAgIGlmICghJGhhc1BhcmVudCkg ewotICAgICAgICAjIEZJWE1FOiBUaGlzIGRlc3Ryb3kgZnVuY3Rpb24gc2hvdWxkIG5vdCBiZSBu ZWNlc3NhcnksIGFzIAorICAgICAgICAjIEZJWE1FOiBUaGlzIGRlc3Ryb3kgZnVuY3Rpb24gc2hv dWxkIG5vdCBiZSBuZWNlc3NhcnksIGFzCiAgICAgICAgICMgYSBmaW5hbGl6ZXIgc2hvdWxkIGJl IGNhbGxlZCBmb3IgZWFjaCBET00gb2JqZWN0IHdyYXBwZXIuCiAgICAgICAgICMgSG93ZXZlciwg dGhhdCBzZWVtcyBub3QgdG8gYmUgdGhlIGNhc2UsIHNvIHRoaXMgaGFzIGJlZW4KICAgICAgICAg IyBhZGRlZCBiYWNrIHRvIGF2b2lkIGxlYWtpbmcgd2hpbGUgd2UgZmlndXJlIG91dCB3aHkgdGhl CkBAIC0xNzQwLDcgKzE3NDAsNyBAQCBzdWIgR2VuZXJhdGVJbXBsZW1lbnRhdGlvbgogICAgIH0K IAogICAgIG15ICRoYXNHZXR0ZXIgPSAkbnVtQXR0cmlidXRlcyA+IDAKLSAgICAgICAgICAgICAg ICAgfHwgISRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJPbWl0Q29uc3RydWN0b3Ii fSAKKyAgICAgICAgICAgICAgICAgfHwgISRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+ eyJPbWl0Q29uc3RydWN0b3IifQogICAgICAgICAgICAgICAgICB8fCAkaW50ZXJmYWNlLT5leHRl bmRlZEF0dHJpYnV0ZXMtPnsiSW5kZXhlZEdldHRlciJ9CiAgICAgICAgICAgICAgICAgIHx8ICRp bnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJOdW1lcmljSW5kZXhlZEdldHRlciJ9CiAg ICAgICAgICAgICAgICAgIHx8ICRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJKU0N1 c3RvbUdldE93blByb3BlcnR5U2xvdEFuZERlc2NyaXB0b3IifQpAQCAtMjAyOCw3ICsyMDI4LDcg QEAgc3ViIEdlbmVyYXRlSW1wbGVtZW50YXRpb24KICAgICAgICAgICAgICAgICAgICAgcHVzaChA aW1wbENvbnRlbnQsICIgICAgQmFzZTo6cHV0KHRoaXNPYmplY3QsIGV4ZWMsIHByb3BlcnR5TmFt ZSwgdmFsdWUsIHNsb3QpO1xuIik7CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAg IHB1c2goQGltcGxDb250ZW50LCAifVxuXG4iKTsKLSAgICAgICAgICAgICAgICAKKwogICAgICAg ICAgICAgICAgIGlmICgkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiQ3VzdG9tSW5k ZXhlZFNldHRlciJ9IHx8ICRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJDdXN0b21O YW1lZFNldHRlciJ9KSB7CiAgICAgICAgICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAi dm9pZCAke2NsYXNzTmFtZX06OnB1dEJ5SW5kZXgoSlNDZWxsKiBjZWxsLCBFeGVjU3RhdGUqIGV4 ZWMsIHVuc2lnbmVkIGluZGV4LCBKU1ZhbHVlIHZhbHVlLCBib29sIHNob3VsZFRocm93KVxuIik7 CiAgICAgICAgICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAie1xuIik7CkBAIC0yMDQx LDE0ICsyMDQxLDE0IEBAIHN1YiBHZW5lcmF0ZUltcGxlbWVudGF0aW9uCiAgICAgICAgICAgICAg ICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAgICAgICAgcmV0dXJuO1xuIik7CiAgICAg ICAgICAgICAgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAgICB9XG4iKTsKICAgICAg ICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgICAgICAKKwogICAgICAgICAgICAgICAg ICAgICBpZiAoJGludGVyZmFjZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57IkN1c3RvbU5hbWVkU2V0 dGVyIn0pIHsKICAgICAgICAgICAgICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAiICAg IFByb3BlcnR5TmFtZSBwcm9wZXJ0eU5hbWUgPSBJZGVudGlmaWVyOjpmcm9tKGV4ZWMsIGluZGV4 KTtcbiIpOwogICAgICAgICAgICAgICAgICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQsICIgICAg UHV0UHJvcGVydHlTbG90IHNsb3Qoc2hvdWxkVGhyb3cpO1xuIik7CiAgICAgICAgICAgICAgICAg ICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAgICBpZiAodGhpc09iamVjdC0+cHV0RGVsZWdh dGUoZXhlYywgcHJvcGVydHlOYW1lLCB2YWx1ZSwgc2xvdCkpXG4iKTsKICAgICAgICAgICAgICAg ICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAiICAgICAgICByZXR1cm47XG4iKTsKICAgICAg ICAgICAgICAgICAgICAgfQotICAgIAorCiAgICAgICAgICAgICAgICAgICAgIHB1c2goQGltcGxD b250ZW50LCAiICAgIEJhc2U6OnB1dEJ5SW5kZXgoY2VsbCwgZXhlYywgaW5kZXgsIHZhbHVlLCBz aG91bGRUaHJvdyk7XG4iKTsKICAgICAgICAgICAgICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQs ICJ9XG5cbiIpOwogICAgICAgICAgICAgICAgIH0KQEAgLTIyMzMsNyArMjIzMyw3IEBAIHN1YiBH ZW5lcmF0ZUltcGxlbWVudGF0aW9uCiAgICAgICAgICAgICAgICAgICAgIGRpZSAiTm8gd2F5IHRv IGhhbmRsZSBpbnRlcmZhY2Ugd2l0aCBSZXBsYWNlYWJsZUNvbnN0cnVjdG9yIGV4dGVuZGVkIGF0 dHJpYnV0ZTogJGludGVyZmFjZU5hbWUiOwogICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAg ICAgICBwdXNoKEBpbXBsQ29udGVudCwgIn1cblxuIik7Ci0gICAgICAgICAgICB9ICAgICAgICAK KyAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0KIApAQCAtMjI5MCw3ICsyMjkwLDcgQEAg c3ViIEdlbmVyYXRlSW1wbGVtZW50YXRpb24KIAogICAgICAgICAgICAgJGltcGxJbmNsdWRlc3si PHJ1bnRpbWUvRXJyb3IuaD4ifSA9IDE7CiAKLSAgICAgICAgICAgIGlmICgkZnVuY3Rpb24tPmlz U3RhdGljKSB7CisgICAgICAgICAgICBpZiAoTWFrZXNTdGF0aWNDYWxsKCRmdW5jdGlvbikpIHsK ICAgICAgICAgICAgICAgICBpZiAoJGlzQ3VzdG9tKSB7CiAgICAgICAgICAgICAgICAgICAgIEdl bmVyYXRlQXJndW1lbnRzQ291bnRDaGVjayhcQGltcGxDb250ZW50LCAkZnVuY3Rpb24sICRpbnRl cmZhY2UpOwogICAgICAgICAgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAgICByZXR1 cm4gSlNWYWx1ZTo6ZW5jb2RlKCR7Y2xhc3NOYW1lfTo6IiAuICRmdW5jdGlvbkltcGxlbWVudGF0 aW9uTmFtZSAuICIoZXhlYykpO1xuIik7CkBAIC0yNjY5LDkgKzI2NjksOSBAQCBzdWIgR2VuZXJh dGVQYXJhbWV0ZXJzQ2hlY2sKICAgICBteSAkaW1wbGVtZW50ZWRCeSA9ICRmdW5jdGlvbi0+c2ln bmF0dXJlLT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiSW1wbGVtZW50ZWRCeSJ9OwogICAgIGlmICgk aW1wbGVtZW50ZWRCeSkgewogICAgICAgICBBZGRUb0ltcGxJbmNsdWRlcygiJHtpbXBsZW1lbnRl ZEJ5fS5oIik7Ci0gICAgICAgIHVuc2hpZnQoQGFyZ3VtZW50cywgImltcGwiKSBpZiAhJGZ1bmN0 aW9uLT5pc1N0YXRpYzsKKyAgICAgICAgdW5zaGlmdChAYXJndW1lbnRzLCAiaW1wbCIpIGlmICFN YWtlc1N0YXRpY0NhbGwoJGZ1bmN0aW9uKTsKICAgICAgICAgJGZ1bmN0aW9uTmFtZSA9ICIke2lt cGxlbWVudGVkQnl9Ojoke2Z1bmN0aW9uSW1wbGVtZW50YXRpb25OYW1lfSI7Ci0gICAgfSBlbHNp ZiAoJGZ1bmN0aW9uLT5pc1N0YXRpYykgeworICAgIH0gZWxzaWYgKE1ha2VzU3RhdGljQ2FsbCgk ZnVuY3Rpb24pKSB7CiAgICAgICAgICRmdW5jdGlvbk5hbWUgPSAiJHtpbnRlcmZhY2VOYW1lfTo6 JHtmdW5jdGlvbkltcGxlbWVudGF0aW9uTmFtZX0iOwogICAgIH0gZWxzaWYgKCRzdmdQcm9wZXJ0 eU9yTGlzdFByb3BlcnR5VHlwZSBhbmQgISRzdmdMaXN0UHJvcGVydHlUeXBlKSB7CiAgICAgICAg ICRmdW5jdGlvbk5hbWUgPSAicG9kSW1wbC4ke2Z1bmN0aW9uSW1wbGVtZW50YXRpb25OYW1lfSI7 CkBAIC0zMDU0LDcgKzMwNTQsNyBAQCBzdWIgR2VuZXJhdGVJbXBsZW1lbnRhdGlvbkZ1bmN0aW9u Q2FsbCgpCiAKICAgICAgICAgaWYgKCRzdmdQcm9wZXJ0eVR5cGUgYW5kICEkZnVuY3Rpb24tPmlz U3RhdGljKSB7CiAgICAgICAgICAgICBpZiAoQHskZnVuY3Rpb24tPnJhaXNlc0V4Y2VwdGlvbnN9 KSB7Ci0gICAgICAgICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQsICRpbmRlbnQgLiAiaWYgKCFl YylcbiIpOyAKKyAgICAgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgJGluZGVudCAuICJp ZiAoIWVjKVxuIik7CiAgICAgICAgICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQsICRpbmRlbnQg LiAiICAgIGltcGwtPmNvbW1pdENoYW5nZSgpO1xuIik7CiAgICAgICAgICAgICB9IGVsc2Ugewog ICAgICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAkaW5kZW50IC4gImltcGwtPmNvbW1p dENoYW5nZSgpO1xuIik7CkBAIC0zMTA3LDcgKzMxMDcsNyBAQCBteSAlbmF0aXZlVHlwZSA9ICgK ICAgICAibG9uZyBsb25nIiA9PiAibG9uZyBsb25nIiwKICAgICAidW5zaWduZWQgbG9uZyBsb25n IiA9PiAidW5zaWduZWQgbG9uZyBsb25nIiwKICAgICAiTWVkaWFRdWVyeUxpc3RMaXN0ZW5lciIg PT4gIlJlZlB0cjxNZWRpYVF1ZXJ5TGlzdExpc3RlbmVyPiIsCi0gICAgIkRPTVRpbWVTdGFtcCIg PT4gIkRPTVRpbWVTdGFtcCIsICAgIAorICAgICJET01UaW1lU3RhbXAiID0+ICJET01UaW1lU3Rh bXAiLAogKTsKIAogc3ViIEdldE5hdGl2ZVR5cGUKQEAgLTMxNjAsNyArMzE2MCw3IEBAIHN1YiBH ZXRTVkdQcm9wZXJ0eVR5cGVzCiAgICAgbXkgJHN2Z05hdGl2ZVR5cGU7CiAKICAgICByZXR1cm4g KCRzdmdQcm9wZXJ0eVR5cGUsICRzdmdMaXN0UHJvcGVydHlUeXBlLCAkc3ZnTmF0aXZlVHlwZSkg aWYgbm90ICRpbXBsVHlwZSA9fiAvU1ZHLzsKLSAgICAKKwogICAgICRzdmdOYXRpdmVUeXBlID0g JGNvZGVHZW5lcmF0b3ItPkdldFNWR1R5cGVOZWVkaW5nVGVhck9mZigkaW1wbFR5cGUpOwogICAg IHJldHVybiAoJHN2Z1Byb3BlcnR5VHlwZSwgJHN2Z0xpc3RQcm9wZXJ0eVR5cGUsICRzdmdOYXRp dmVUeXBlKSBpZiBub3QgJHN2Z05hdGl2ZVR5cGU7CiAKQEAgLTM1MzAsNyArMzUzMCw3IEBAIHN1 YiBHZW5lcmF0ZUhhc2hUYWJsZQogICAgICAgICAgICAgbXkgJGNvbmRpdGlvbmFsU3RyaW5nID0g JGNvZGVHZW5lcmF0b3ItPkdlbmVyYXRlQ29uZGl0aW9uYWxTdHJpbmdGcm9tQXR0cmlidXRlVmFs dWUoJGNvbmRpdGlvbmFsKTsKICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAiI2lmICR7 Y29uZGl0aW9uYWxTdHJpbmd9XG4iKTsKICAgICAgICAgfQotICAgICAgICAKKwogICAgICAgICBp ZiAoIkAkc3BlY2lhbHNbJGldIiA9fiBtL0Z1bmN0aW9uLykgewogICAgICAgICAgICAgJHRhcmdl dFR5cGUgPSAic3RhdGljX2Nhc3Q8TmF0aXZlRnVuY3Rpb24+IjsKICAgICAgICAgfSBlbHNlIHsK QEAgLTQwOTAsNiArNDA5MCwxMiBAQCBzdWIgSGFzQ3VzdG9tTWV0aG9kCiAgICAgcmV0dXJuICRh dHRyRXh0LT57IkN1c3RvbSJ9IHx8ICRhdHRyRXh0LT57IkpTQ3VzdG9tIn07CiB9CiAKK3N1YiBN YWtlc1N0YXRpY0NhbGwKK3sKKyAgICBteSAkZnVuY3Rpb24gPSBzaGlmdDsKKyAgICByZXR1cm4g JGZ1bmN0aW9uLT5pc1N0YXRpYyB8fCAkZnVuY3Rpb24tPnNpZ25hdHVyZS0+ZXh0ZW5kZWRBdHRy aWJ1dGVzLT57IkxlbmllbnRUaGlzIn07Cit9CisKIHN1YiBJc0NvbnN0cnVjdGFibGUKIHsKICAg ICBteSAkaW50ZXJmYWNlID0gc2hpZnQ7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9z Y3JpcHRzL0lETEF0dHJpYnV0ZXMudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL3NjcmlwdHMvSURMQXR0cmlidXRlcy50eHQJKHJldmlzaW9uIDE0ODE4MSkKKysrIFNv dXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvSURMQXR0cmlidXRlcy50eHQJKHdvcmtpbmcg Y29weSkKQEAgLTg3LDYgKzg3LDcgQEAgSlNJbmxpbmVHZXRPd25Qcm9wZXJ0eVNsb3QKIEpTTGVn YWN5UGFyZW50PSoKIEpTTm9TdGF0aWNUYWJsZXMKIEpTV2luZG93RXZlbnRMaXN0ZW5lcgorTGVu aWVudFRoaXMKIE1hc3F1ZXJhZGVzQXNVbmRlZmluZWQKIE5hbWVkQ29uc3RydWN0b3I9KgogTmFt ZWRHZXR0ZXIKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9UZXN0 T2JqLmlkbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rl c3QvVGVzdE9iai5pZGwJKHJldmlzaW9uIDE0ODE4MSkKKysrIFNvdXJjZS9XZWJDb3JlL2JpbmRp bmdzL3NjcmlwdHMvdGVzdC9UZXN0T2JqLmlkbAkod29ya2luZyBjb3B5KQpAQCAtMTAwLDExICsx MDAsMTEgQEAgZW51bSBUZXN0RW51bVR5cGUgeyAiIiwgIkVudW1WYWx1ZTEiLCAiRQogICAgIFtD dXN0b21dIHZvaWQgY3VzdG9tTWV0aG9kKCk7CiAgICAgW0N1c3RvbV0gdm9pZCBjdXN0b21NZXRo b2RXaXRoQXJncyhpbiBsb25nIGxvbmdBcmcsIGluIERPTVN0cmluZyBzdHJBcmcsIGluIFRlc3RP Ymogb2JqQXJnKTsKIAotICAgIHZvaWQgYWRkRXZlbnRMaXN0ZW5lcihpbiBET01TdHJpbmcgdHlw ZSwgCi0gICAgICAgICAgICAgICAgICAgICAgICAgIGluIEV2ZW50TGlzdGVuZXIgbGlzdGVuZXIs IAorICAgIHZvaWQgYWRkRXZlbnRMaXN0ZW5lcihpbiBET01TdHJpbmcgdHlwZSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgaW4gRXZlbnRMaXN0ZW5lciBsaXN0ZW5lciwKICAgICAgICAgICAg ICAgICAgICAgICAgICAgaW4gW09wdGlvbmFsXSBib29sZWFuIHVzZUNhcHR1cmUpOwotICAgIHZv aWQgcmVtb3ZlRXZlbnRMaXN0ZW5lcihpbiBET01TdHJpbmcgdHlwZSwgCi0gICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGluIEV2ZW50TGlzdGVuZXIgbGlzdGVuZXIsIAorICAgIHZvaWQgcmVt b3ZlRXZlbnRMaXN0ZW5lcihpbiBET01TdHJpbmcgdHlwZSwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgaW4gRXZlbnRMaXN0ZW5lciBsaXN0ZW5lciwKICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgaW4gW09wdGlvbmFsXSBib29sZWFuIHVzZUNhcHR1cmUpOwogCiAgICAgLy8gJ0Nh bGxXaXRoJyBleHRlbmRlZCBhdHRyaWJ1dGUKQEAgLTE3MSw3ICsxNzEsNyBAQCBlbnVtIFRlc3RF bnVtVHlwZSB7ICIiLCAiRW51bVZhbHVlMSIsICJFCiAgICAgW0NhY2hlZEF0dHJpYnV0ZV0gcmVh ZG9ubHkgYXR0cmlidXRlIGFueSBjYWNoZWRBdHRyaWJ1dGUxOwogICAgIFtDYWNoZWRBdHRyaWJ1 dGVdIHJlYWRvbmx5IGF0dHJpYnV0ZSBhbnkgY2FjaGVkQXR0cmlidXRlMjsKICNlbmRpZgotICAg IAorCiAgICAgYXR0cmlidXRlIGFueSBhbnlBdHRyaWJ1dGU7CiAKICNpZiBkZWZpbmVkKFRFU1RJ TkdfSlMpCkBAIC0xOTQsNiArMTk0LDkgQEAgZW51bSBUZXN0RW51bVR5cGUgeyAiIiwgIkVudW1W YWx1ZTEiLCAiRQogICAgIHN0YXRpYyBsb25nIGNsYXNzTWV0aG9kV2l0aE9wdGlvbmFsKGluIFtP cHRpb25hbF0gbG9uZyBhcmcpOwogICAgIFtDdXN0b21dIHN0YXRpYyB2b2lkIGNsYXNzTWV0aG9k MihpbiBsb25nIGFyZyk7CiAKKyAgICAvLyBTdGF0aWMgbWV0aG9kcyBkZWZpbmVkIG9uIGluc3Rh bmNlcyAobGlrZSBjb25zb2xlLmxvZykuCisgICAgW0xlbmllbnRUaGlzXSB2b2lkIGxlbmllbnRU aGlzTWV0aG9kKGluIERPTVN0cmluZyBzdHIpOworCiAgICAgLy8gU3RhdGljIG1ldGhvZCB3aXRo IGNvbmRpdGlvbmFsIG9uIG92ZXJsb2FkZWQgbWV0aG9kcwogICAgIFtDb25kaXRpb25hbD1Db25k aXRpb24xXSBzdGF0aWMgdm9pZCBvdmVybG9hZGVkTWV0aG9kMShpbiBsb25nIGFyZyk7CiAgICAg W0NvbmRpdGlvbmFsPUNvbmRpdGlvbjFdIHN0YXRpYyB2b2lkIG92ZXJsb2FkZWRNZXRob2QxKGlu IFtTdHJpY3RUeXBlQ2hlY2tpbmddIERPTVN0cmluZyB0eXBlKTsKSW5kZXg6IFNvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9DUFAvV2ViRE9NVGVzdE9iai5jcHAKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0NQUC9XZWJET01UZXN0 T2JqLmNwcAkocmV2aXNpb24gMTQ4MTgxKQorKysgU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2Ny aXB0cy90ZXN0L0NQUC9XZWJET01UZXN0T2JqLmNwcAkod29ya2luZyBjb3B5KQpAQCAtOTQ4LDYg Kzk0OCwxNCBAQCBpbnQgV2ViRE9NVGVzdE9iajo6Y2xhc3NNZXRob2RXaXRoT3B0aW9uCiAgICAg cmV0dXJuIGltcGwoKS0+Y2xhc3NNZXRob2RXaXRoT3B0aW9uYWwoYXJnKTsKIH0KIAordm9pZCBX ZWJET01UZXN0T2JqOjpsZW5pZW50VGhpc01ldGhvZChjb25zdCBXZWJET01TdHJpbmcmIHN0cikK K3sKKyAgICBpZiAoIWltcGwoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaW1wbCgpLT5sZW5p ZW50VGhpc01ldGhvZChzdHIpOworfQorCiAKICNpZiBFTkFCTEUoQ29uZGl0aW9uMSkKIHZvaWQg V2ViRE9NVGVzdE9iajo6b3ZlcmxvYWRlZE1ldGhvZDEoaW50IGFyZykKSW5kZXg6IFNvdXJjZS9X ZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9DUFAvV2ViRE9NVGVzdE9iai5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9DUFAvV2ViRE9NVGVz dE9iai5oCShyZXZpc2lvbiAxNDgxODEpCisrKyBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3Jp cHRzL3Rlc3QvQ1BQL1dlYkRPTVRlc3RPYmouaAkod29ya2luZyBjb3B5KQpAQCAtMTg1LDYgKzE4 NSw3IEBAIHB1YmxpYzoKICNlbmRpZgogICAgIHZvaWQgY2xhc3NNZXRob2QoKTsKICAgICBpbnQg Y2xhc3NNZXRob2RXaXRoT3B0aW9uYWwoaW50IGFyZyk7CisgICAgdm9pZCBsZW5pZW50VGhpc01l dGhvZChjb25zdCBXZWJET01TdHJpbmcmIHN0cik7CiAjaWYgRU5BQkxFKENvbmRpdGlvbjEpCiAg ICAgdm9pZCBvdmVybG9hZGVkTWV0aG9kMShpbnQgYXJnKTsKICNlbmRpZgpJbmRleDogU291cmNl L1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0dPYmplY3QvV2ViS2l0RE9NVGVzdE9iai5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0dP YmplY3QvV2ViS2l0RE9NVGVzdE9iai5jcHAJKHJldmlzaW9uIDE0ODE4MSkKKysrIFNvdXJjZS9X ZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9HT2JqZWN0L1dlYktpdERPTVRlc3RPYmouY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC0xMzUyLDYgKzEzNTIsMTcgQEAgd2Via2l0X2RvbV90ZXN0X29i al9jbGFzc19tZXRob2Rfd2l0aF9vcAogfQogCiB2b2lkCit3ZWJraXRfZG9tX3Rlc3Rfb2JqX2xl bmllbnRfdGhpc19tZXRob2QoV2ViS2l0RE9NVGVzdE9iaiogc2VsZiwgY29uc3QgZ2NoYXIqIHN0 cikKK3sKKyAgICBXZWJDb3JlOjpKU01haW5UaHJlYWROdWxsU3RhdGUgc3RhdGU7CisgICAgZ19y ZXR1cm5faWZfZmFpbChXRUJLSVRfRE9NX0lTX1RFU1RfT0JKKHNlbGYpKTsKKyAgICBnX3JldHVy bl9pZl9mYWlsKHN0cik7CisgICAgV2ViQ29yZTo6VGVzdE9iaiogaXRlbSA9IFdlYktpdDo6Y29y ZShzZWxmKTsKKyAgICBXVEY6OlN0cmluZyBjb252ZXJ0ZWRTdHIgPSBXVEY6OlN0cmluZzo6ZnJv bVVURjgoc3RyKTsKKyAgICBpdGVtLT5sZW5pZW50VGhpc01ldGhvZChjb252ZXJ0ZWRTdHIpOwor fQorCit2b2lkCiB3ZWJraXRfZG9tX3Rlc3Rfb2JqX292ZXJsb2FkZWRfbWV0aG9kMShXZWJLaXRE T01UZXN0T2JqKiBzZWxmLCBnbG9uZyBhcmcpCiB7CiAjaWYgRU5BQkxFKENvbmRpdGlvbjEpCklu ZGV4OiBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvR09iamVjdC9XZWJLaXRE T01UZXN0T2JqLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0 cy90ZXN0L0dPYmplY3QvV2ViS2l0RE9NVGVzdE9iai5oCShyZXZpc2lvbiAxNDgxODEpCisrKyBT b3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvR09iamVjdC9XZWJLaXRET01UZXN0 T2JqLmgJKHdvcmtpbmcgY29weSkKQEAgLTM4MCw2ICszODAsMTcgQEAgV0VCS0lUX0FQSSBnbG9u Zwogd2Via2l0X2RvbV90ZXN0X29ial9jbGFzc19tZXRob2Rfd2l0aF9vcHRpb25hbChXZWJLaXRE T01UZXN0T2JqKiBzZWxmLCBnbG9uZyBhcmcpOwogCiAvKioKKyAqIHdlYmtpdF9kb21fdGVzdF9v YmpfbGVuaWVudF90aGlzX21ldGhvZDoKKyAqIEBzZWxmOiBBICNXZWJLaXRET01UZXN0T2JqCisg KiBAc3RyOiBBICNnY2hhcgorICoKKyAqIFJldHVybnM6CisgKgorKiovCitXRUJLSVRfQVBJIHZv aWQKK3dlYmtpdF9kb21fdGVzdF9vYmpfbGVuaWVudF90aGlzX21ldGhvZChXZWJLaXRET01UZXN0 T2JqKiBzZWxmLCBjb25zdCBnY2hhciogc3RyKTsKKworLyoqCiAgKiB3ZWJraXRfZG9tX3Rlc3Rf b2JqX292ZXJsb2FkZWRfbWV0aG9kMToKICAqIEBzZWxmOiBBICNXZWJLaXRET01UZXN0T2JqCiAg KiBAYXJnOiBBICNnbG9uZwpJbmRleDogU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90 ZXN0L0pTL0pTVGVzdE9iai5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvYmluZGlu Z3Mvc2NyaXB0cy90ZXN0L0pTL0pTVGVzdE9iai5jcHAJKHJldmlzaW9uIDE0ODE4MSkKKysrIFNv dXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9KUy9KU1Rlc3RPYmouY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC0zMTQsNiArMzE0LDcgQEAgc3RhdGljIGNvbnN0IEhhc2hUYWJsZVZhbHVl IEpTVGVzdE9ialBybwogICAgIHsgImNvbmRpdGlvbmFsTWV0aG9kMyIsIERvbnREZWxldGUgfCBK U0M6OkZ1bmN0aW9uLCAoaW50cHRyX3Qpc3RhdGljX2Nhc3Q8TmF0aXZlRnVuY3Rpb24+KGpzVGVz dE9ialByb3RvdHlwZUZ1bmN0aW9uQ29uZGl0aW9uYWxNZXRob2QzKSwgKGludHB0cl90KTAsIE5v SW50cmluc2ljIH0sCiAjZW5kaWYKICAgICB7ICJvdmVybG9hZGVkTWV0aG9kIiwgRG9udERlbGV0 ZSB8IEpTQzo6RnVuY3Rpb24sIChpbnRwdHJfdClzdGF0aWNfY2FzdDxOYXRpdmVGdW5jdGlvbj4o anNUZXN0T2JqUHJvdG90eXBlRnVuY3Rpb25PdmVybG9hZGVkTWV0aG9kKSwgKGludHB0cl90KTIs IE5vSW50cmluc2ljIH0sCisgICAgeyAibGVuaWVudFRoaXNNZXRob2QiLCBEb250RGVsZXRlIHwg SlNDOjpGdW5jdGlvbiwgKGludHB0cl90KXN0YXRpY19jYXN0PE5hdGl2ZUZ1bmN0aW9uPihqc1Rl c3RPYmpQcm90b3R5cGVGdW5jdGlvbkxlbmllbnRUaGlzTWV0aG9kKSwgKGludHB0cl90KTEsIE5v SW50cmluc2ljIH0sCiAgICAgeyAiY2xhc3NNZXRob2RXaXRoQ2xhbXAiLCBEb250RGVsZXRlIHwg SlNDOjpGdW5jdGlvbiwgKGludHB0cl90KXN0YXRpY19jYXN0PE5hdGl2ZUZ1bmN0aW9uPihqc1Rl c3RPYmpQcm90b3R5cGVGdW5jdGlvbkNsYXNzTWV0aG9kV2l0aENsYW1wKSwgKGludHB0cl90KTIs IE5vSW50cmluc2ljIH0sCiAgICAgeyAibWV0aG9kV2l0aFVuc2lnbmVkTG9uZ1NlcXVlbmNlIiwg RG9udERlbGV0ZSB8IEpTQzo6RnVuY3Rpb24sIChpbnRwdHJfdClzdGF0aWNfY2FzdDxOYXRpdmVG dW5jdGlvbj4oanNUZXN0T2JqUHJvdG90eXBlRnVuY3Rpb25NZXRob2RXaXRoVW5zaWduZWRMb25n U2VxdWVuY2UpLCAoaW50cHRyX3QpMSwgTm9JbnRyaW5zaWMgfSwKICAgICB7ICJzdHJpbmdBcnJh eUZ1bmN0aW9uIiwgRG9udERlbGV0ZSB8IEpTQzo6RnVuY3Rpb24sIChpbnRwdHJfdClzdGF0aWNf Y2FzdDxOYXRpdmVGdW5jdGlvbj4oanNUZXN0T2JqUHJvdG90eXBlRnVuY3Rpb25TdHJpbmdBcnJh eUZ1bmN0aW9uKSwgKGludHB0cl90KTEsIE5vSW50cmluc2ljIH0sCkBAIC0yNjI1LDYgKzI2MjYs MTcgQEAgRW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBqc1Rlc3RPYmpDbwogICAgIHJldHVy biBKU1ZhbHVlOjplbmNvZGUoSlNUZXN0T2JqOjpjbGFzc01ldGhvZDIoZXhlYykpOwogfQogCitF bmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGpzVGVzdE9ialByb3RvdHlwZUZ1bmN0aW9uTGVu aWVudFRoaXNNZXRob2QoRXhlY1N0YXRlKiBleGVjKQoreworICAgIGlmIChleGVjLT5hcmd1bWVu dENvdW50KCkgPCAxKQorICAgICAgICByZXR1cm4gdGhyb3dWTUVycm9yKGV4ZWMsIGNyZWF0ZU5v dEVub3VnaEFyZ3VtZW50c0Vycm9yKGV4ZWMpKTsKKyAgICBjb25zdCBTdHJpbmcmIHN0cihleGVj LT5hcmd1bWVudCgwKS5pc0VtcHR5KCkgPyBTdHJpbmcoKSA6IGV4ZWMtPmFyZ3VtZW50KDApLnRv U3RyaW5nKGV4ZWMpLT52YWx1ZShleGVjKSk7CisgICAgaWYgKGV4ZWMtPmhhZEV4Y2VwdGlvbigp KQorICAgICAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKGpzVW5kZWZpbmVkKCkpOworICAgIFRl c3RPYmo6OmxlbmllbnRUaGlzTWV0aG9kKHN0cik7CisgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29k ZShqc1VuZGVmaW5lZCgpKTsKK30KKwogI2lmIEVOQUJMRShDb25kaXRpb24xKQogc3RhdGljIEVu Y29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwganNUZXN0T2JqQ29uc3RydWN0b3JGdW5jdGlvbk92 ZXJsb2FkZWRNZXRob2QxMShFeGVjU3RhdGUqIGV4ZWMpCiB7CkluZGV4OiBTb3VyY2UvV2ViQ29y ZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvSlMvSlNUZXN0T2JqLmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0pTL0pTVGVzdE9iai5oCShyZXZpc2lv biAxNDgxODEpCisrKyBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvSlMvSlNU ZXN0T2JqLmgJKHdvcmtpbmcgY29weSkKQEAgLTIwMyw2ICsyMDMsNyBAQCBKU0M6OkVuY29kZWRK U1ZhbHVlIEpTQ19IT1NUX0NBTEwganNUZXN0CiBKU0M6OkVuY29kZWRKU1ZhbHVlIEpTQ19IT1NU X0NBTEwganNUZXN0T2JqQ29uc3RydWN0b3JGdW5jdGlvbkNsYXNzTWV0aG9kKEpTQzo6RXhlY1N0 YXRlKik7CiBKU0M6OkVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwganNUZXN0T2JqQ29uc3Ry dWN0b3JGdW5jdGlvbkNsYXNzTWV0aG9kV2l0aE9wdGlvbmFsKEpTQzo6RXhlY1N0YXRlKik7CiBK U0M6OkVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwganNUZXN0T2JqQ29uc3RydWN0b3JGdW5j dGlvbkNsYXNzTWV0aG9kMihKU0M6OkV4ZWNTdGF0ZSopOworSlNDOjpFbmNvZGVkSlNWYWx1ZSBK U0NfSE9TVF9DQUxMIGpzVGVzdE9ialByb3RvdHlwZUZ1bmN0aW9uTGVuaWVudFRoaXNNZXRob2Qo SlNDOjpFeGVjU3RhdGUqKTsKICNpZiBFTkFCTEUoQ29uZGl0aW9uMSkKIEpTQzo6RW5jb2RlZEpT VmFsdWUgSlNDX0hPU1RfQ0FMTCBqc1Rlc3RPYmpDb25zdHJ1Y3RvckZ1bmN0aW9uT3ZlcmxvYWRl ZE1ldGhvZDEoSlNDOjpFeGVjU3RhdGUqKTsKICNlbmRpZgpJbmRleDogU291cmNlL1dlYkNvcmUv YmluZGluZ3Mvc2NyaXB0cy90ZXN0L09iakMvRE9NVGVzdE9iai5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9PYmpDL0RPTVRlc3RPYmouaAkocmV2 aXNpb24gMTQ4MTgxKQorKysgU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L09i akMvRE9NVGVzdE9iai5oCSh3b3JraW5nIGNvcHkpCkBAIC0xNjUsNiArMTY1LDcgQEAgZW51bSB7 CiAtICh2b2lkKWNsYXNzTWV0aG9kOwogLSAoaW50KWNsYXNzTWV0aG9kV2l0aE9wdGlvbmFsOihp bnQpYXJnOwogLSAodm9pZCljbGFzc01ldGhvZDI6KGludClhcmc7CistICh2b2lkKWxlbmllbnRU aGlzTWV0aG9kOihOU1N0cmluZyAqKXN0cjsKICNpZiBFTkFCTEUoQ29uZGl0aW9uMSkKIC0gKHZv aWQpb3ZlcmxvYWRlZE1ldGhvZDE6KGludClhcmc7CiAjZW5kaWYKSW5kZXg6IFNvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9PYmpDL0RPTVRlc3RPYmoubW0KPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L09iakMvRE9NVGVzdE9iai5t bQkocmV2aXNpb24gMTQ4MTgxKQorKysgU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90 ZXN0L09iakMvRE9NVGVzdE9iai5tbQkod29ya2luZyBjb3B5KQpAQCAtMTAxMiw2ICsxMDEyLDEy IEBAIC0gKHZvaWQpY2xhc3NNZXRob2QyOihpbnQpYXJnCiAgICAgSU1QTC0+Y2xhc3NNZXRob2Qy KGFyZyk7CiB9CiAKKy0gKHZvaWQpbGVuaWVudFRoaXNNZXRob2Q6KE5TU3RyaW5nICopc3RyCit7 CisgICAgV2ViQ29yZTo6SlNNYWluVGhyZWFkTnVsbFN0YXRlIHN0YXRlOworICAgIElNUEwtPmxl bmllbnRUaGlzTWV0aG9kKHN0cik7Cit9CisKIAogI2lmIEVOQUJMRShDb25kaXRpb24xKQogLSAo dm9pZClvdmVybG9hZGVkTWV0aG9kMTooaW50KWFyZwpJbmRleDogU291cmNlL1dlYkNvcmUvcGFn ZS9Db25zb2xlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wYWdlL0NvbnNvbGUu Y3BwCShyZXZpc2lvbiAxNDgxODEpCisrKyBTb3VyY2UvV2ViQ29yZS9wYWdlL0NvbnNvbGUuY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC01Niw4ICs1NiwyMCBAQAogI2luY2x1ZGUgPHd0Zi90ZXh0L0NT dHJpbmcuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KIAorCiBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKK3N0YXRpYyBpbmxpbmUgUGFnZSogcGFnZUZyb21TY3JpcHRTdGF0ZShTY3Jp cHRTdGF0ZSogc3RhdGUpCit7CisgICAgRE9NV2luZG93KiB3aW5kb3cgPSBkb21XaW5kb3dGcm9t U2NyaXB0U3RhdGUoc3RhdGUpOworICAgIGlmICghd2luZG93KQorICAgICAgICByZXR1cm4gMDsK KyAgICBEb2N1bWVudCogZG9jdW1lbnQgPSB3aW5kb3ctPmRvY3VtZW50KCk7CisgICAgaWYgKCFk b2N1bWVudCkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgcmV0dXJuIGRvY3VtZW50LT5wYWdlKCk7 Cit9CisKIENvbnNvbGU6OkNvbnNvbGUoRnJhbWUqIGZyYW1lKQogICAgIDogRE9NV2luZG93UHJv cGVydHkoZnJhbWUpCiB7CkBAIC0xMTUsMTIgKzEyNywxMiBAQCBzdGF0aWMgdm9pZCBpbnRlcm5h bEFkZE1lc3NhZ2UoUGFnZSogcGFnCiAKIHZvaWQgQ29uc29sZTo6ZGVidWcoU2NyaXB0U3RhdGUq IHN0YXRlLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4gYXJndW1lbnRzKQogewotICAgIGlu dGVybmFsQWRkTWVzc2FnZShwYWdlKCksIExvZ01lc3NhZ2VUeXBlLCBEZWJ1Z01lc3NhZ2VMZXZl bCwgc3RhdGUsIGFyZ3VtZW50cyk7CisgICAgaW50ZXJuYWxBZGRNZXNzYWdlKHBhZ2VGcm9tU2Ny aXB0U3RhdGUoc3RhdGUpLCBMb2dNZXNzYWdlVHlwZSwgRGVidWdNZXNzYWdlTGV2ZWwsIHN0YXRl LCBhcmd1bWVudHMpOwogfQogCiB2b2lkIENvbnNvbGU6OmVycm9yKFNjcmlwdFN0YXRlKiBzdGF0 ZSwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+IGFyZ3VtZW50cykKIHsKLSAgICBpbnRlcm5h bEFkZE1lc3NhZ2UocGFnZSgpLCBMb2dNZXNzYWdlVHlwZSwgRXJyb3JNZXNzYWdlTGV2ZWwsIHN0 YXRlLCBhcmd1bWVudHMpOworICAgIGludGVybmFsQWRkTWVzc2FnZShwYWdlRnJvbVNjcmlwdFN0 YXRlKHN0YXRlKSwgTG9nTWVzc2FnZVR5cGUsIEVycm9yTWVzc2FnZUxldmVsLCBzdGF0ZSwgYXJn dW1lbnRzKTsKIH0KIAogdm9pZCBDb25zb2xlOjppbmZvKFNjcmlwdFN0YXRlKiBzdGF0ZSwgUGFz c1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+IGFyZ3VtZW50cykKQEAgLTEzMCwzNyArMTQyLDM3IEBA IHZvaWQgQ29uc29sZTo6aW5mbyhTY3JpcHRTdGF0ZSogc3RhdGUsIFAKIAogdm9pZCBDb25zb2xl Ojpsb2coU2NyaXB0U3RhdGUqIHN0YXRlLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4gYXJn dW1lbnRzKQogewotICAgIGludGVybmFsQWRkTWVzc2FnZShwYWdlKCksIExvZ01lc3NhZ2VUeXBl LCBMb2dNZXNzYWdlTGV2ZWwsIHN0YXRlLCBhcmd1bWVudHMpOworICAgIGludGVybmFsQWRkTWVz c2FnZShwYWdlRnJvbVNjcmlwdFN0YXRlKHN0YXRlKSwgTG9nTWVzc2FnZVR5cGUsIExvZ01lc3Nh Z2VMZXZlbCwgc3RhdGUsIGFyZ3VtZW50cyk7CiB9CiAKIHZvaWQgQ29uc29sZTo6d2FybihTY3Jp cHRTdGF0ZSogc3RhdGUsIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPiBhcmd1bWVudHMpCiB7 Ci0gICAgaW50ZXJuYWxBZGRNZXNzYWdlKHBhZ2UoKSwgTG9nTWVzc2FnZVR5cGUsIFdhcm5pbmdN ZXNzYWdlTGV2ZWwsIHN0YXRlLCBhcmd1bWVudHMpOworICAgIGludGVybmFsQWRkTWVzc2FnZShw YWdlRnJvbVNjcmlwdFN0YXRlKHN0YXRlKSwgTG9nTWVzc2FnZVR5cGUsIFdhcm5pbmdNZXNzYWdl TGV2ZWwsIHN0YXRlLCBhcmd1bWVudHMpOwogfQogCiB2b2lkIENvbnNvbGU6OmRpcihTY3JpcHRT dGF0ZSogc3RhdGUsIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPiBhcmd1bWVudHMpCiB7Ci0g ICAgaW50ZXJuYWxBZGRNZXNzYWdlKHBhZ2UoKSwgRGlyTWVzc2FnZVR5cGUsIExvZ01lc3NhZ2VM ZXZlbCwgc3RhdGUsIGFyZ3VtZW50cyk7CisgICAgaW50ZXJuYWxBZGRNZXNzYWdlKHBhZ2VGcm9t U2NyaXB0U3RhdGUoc3RhdGUpLCBEaXJNZXNzYWdlVHlwZSwgTG9nTWVzc2FnZUxldmVsLCBzdGF0 ZSwgYXJndW1lbnRzKTsKIH0KIAogdm9pZCBDb25zb2xlOjpkaXJ4bWwoU2NyaXB0U3RhdGUqIHN0 YXRlLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4gYXJndW1lbnRzKQogewotICAgIGludGVy bmFsQWRkTWVzc2FnZShwYWdlKCksIERpclhNTE1lc3NhZ2VUeXBlLCBMb2dNZXNzYWdlTGV2ZWws IHN0YXRlLCBhcmd1bWVudHMpOworICAgIGludGVybmFsQWRkTWVzc2FnZShwYWdlRnJvbVNjcmlw dFN0YXRlKHN0YXRlKSwgRGlyWE1MTWVzc2FnZVR5cGUsIExvZ01lc3NhZ2VMZXZlbCwgc3RhdGUs IGFyZ3VtZW50cyk7CiB9CiAKIHZvaWQgQ29uc29sZTo6dGFibGUoU2NyaXB0U3RhdGUqIHN0YXRl LCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4gYXJndW1lbnRzKQogewotICAgIGludGVybmFs QWRkTWVzc2FnZShwYWdlKCksIFRhYmxlTWVzc2FnZVR5cGUsIExvZ01lc3NhZ2VMZXZlbCwgc3Rh dGUsIGFyZ3VtZW50cyk7CisgICAgaW50ZXJuYWxBZGRNZXNzYWdlKHBhZ2VGcm9tU2NyaXB0U3Rh dGUoc3RhdGUpLCBUYWJsZU1lc3NhZ2VUeXBlLCBMb2dNZXNzYWdlTGV2ZWwsIHN0YXRlLCBhcmd1 bWVudHMpOwogfQogCiB2b2lkIENvbnNvbGU6OmNsZWFyKFNjcmlwdFN0YXRlKiBzdGF0ZSwgUGFz c1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+IGFyZ3VtZW50cykKIHsKLSAgICBpbnRlcm5hbEFkZE1l c3NhZ2UocGFnZSgpLCBDbGVhck1lc3NhZ2VUeXBlLCBMb2dNZXNzYWdlTGV2ZWwsIHN0YXRlLCBh cmd1bWVudHMsIHRydWUpOworICAgIGludGVybmFsQWRkTWVzc2FnZShwYWdlRnJvbVNjcmlwdFN0 YXRlKHN0YXRlKSwgQ2xlYXJNZXNzYWdlVHlwZSwgTG9nTWVzc2FnZUxldmVsLCBzdGF0ZSwgYXJn dW1lbnRzLCB0cnVlKTsKIH0KIAogdm9pZCBDb25zb2xlOjp0cmFjZShTY3JpcHRTdGF0ZSogc3Rh dGUsIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPiBhcmd1bWVudHMpCiB7Ci0gICAgaW50ZXJu YWxBZGRNZXNzYWdlKHBhZ2UoKSwgVHJhY2VNZXNzYWdlVHlwZSwgTG9nTWVzc2FnZUxldmVsLCBz dGF0ZSwgYXJndW1lbnRzLCB0cnVlLCB0cnVlKTsKKyAgICBpbnRlcm5hbEFkZE1lc3NhZ2UocGFn ZUZyb21TY3JpcHRTdGF0ZShzdGF0ZSksIFRyYWNlTWVzc2FnZVR5cGUsIExvZ01lc3NhZ2VMZXZl bCwgc3RhdGUsIGFyZ3VtZW50cywgdHJ1ZSwgdHJ1ZSk7CiB9CiAKIHZvaWQgQ29uc29sZTo6YXNz ZXJ0Q29uZGl0aW9uKFNjcmlwdFN0YXRlKiBzdGF0ZSwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVu dHM+IGFyZ3VtZW50cywgYm9vbCBjb25kaXRpb24pCkBAIC0xNzMsNyArMTg1LDcgQEAgdm9pZCBD b25zb2xlOjphc3NlcnRDb25kaXRpb24oU2NyaXB0U3RhdAogCiB2b2lkIENvbnNvbGU6OmNvdW50 KFNjcmlwdFN0YXRlKiBzdGF0ZSwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+IGFyZ3VtZW50 cykKIHsKLSAgICBJbnNwZWN0b3JJbnN0cnVtZW50YXRpb246OmNvbnNvbGVDb3VudChwYWdlKCks IHN0YXRlLCBhcmd1bWVudHMpOworICAgIEluc3BlY3Rvckluc3RydW1lbnRhdGlvbjo6Y29uc29s ZUNvdW50KHBhZ2VGcm9tU2NyaXB0U3RhdGUoc3RhdGUpLCBzdGF0ZSwgYXJndW1lbnRzKTsKIH0K IAogdm9pZCBDb25zb2xlOjptYXJrVGltZWxpbmUoUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+ IGFyZ3VtZW50cykKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BhZ2UvQ29uc29sZS5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BhZ2UvQ29uc29sZS5oCShyZXZpc2lvbiAxNDgxODEpCisr KyBTb3VyY2UvV2ViQ29yZS9wYWdlL0NvbnNvbGUuaAkod29ya2luZyBjb3B5KQpAQCAtNTMsMTgg KzUzLDE4IEBAIHB1YmxpYzoKICAgICBzdGF0aWMgUGFzc1JlZlB0cjxDb25zb2xlPiBjcmVhdGUo RnJhbWUqIGZyYW1lKSB7IHJldHVybiBhZG9wdFJlZihuZXcgQ29uc29sZShmcmFtZSkpOyB9CiAg ICAgdmlydHVhbCB+Q29uc29sZSgpOwogCi0gICAgdm9pZCBkZWJ1ZyhTY3JpcHRTdGF0ZSosIFBh c3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7Ci0gICAgdm9pZCBlcnJvcihTY3JpcHRTdGF0ZSos IFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7Ci0gICAgdm9pZCBpbmZvKFNjcmlwdFN0YXRl KiwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+KTsKLSAgICB2b2lkIGxvZyhTY3JpcHRTdGF0 ZSosIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7Ci0gICAgdm9pZCBjbGVhcihTY3JpcHRT dGF0ZSosIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7Ci0gICAgdm9pZCB3YXJuKFNjcmlw dFN0YXRlKiwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+KTsKLSAgICB2b2lkIGRpcihTY3Jp cHRTdGF0ZSosIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7Ci0gICAgdm9pZCBkaXJ4bWwo U2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4pOwotICAgIHZvaWQgdGFi bGUoU2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4pOwotICAgIHZvaWQg dHJhY2UoU2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4pOworICAgIHN0 YXRpYyB2b2lkIGRlYnVnKFNjcmlwdFN0YXRlKiwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+ KTsKKyAgICBzdGF0aWMgdm9pZCBlcnJvcihTY3JpcHRTdGF0ZSosIFBhc3NSZWZQdHI8U2NyaXB0 QXJndW1lbnRzPik7CisgICAgc3RhdGljIHZvaWQgaW5mbyhTY3JpcHRTdGF0ZSosIFBhc3NSZWZQ dHI8U2NyaXB0QXJndW1lbnRzPik7CisgICAgc3RhdGljIHZvaWQgbG9nKFNjcmlwdFN0YXRlKiwg UGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+KTsKKyAgICBzdGF0aWMgdm9pZCBjbGVhcihTY3Jp cHRTdGF0ZSosIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7CisgICAgc3RhdGljIHZvaWQg d2FybihTY3JpcHRTdGF0ZSosIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7CisgICAgc3Rh dGljIHZvaWQgZGlyKFNjcmlwdFN0YXRlKiwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+KTsK KyAgICBzdGF0aWMgdm9pZCBkaXJ4bWwoU2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFy Z3VtZW50cz4pOworICAgIHN0YXRpYyB2b2lkIHRhYmxlKFNjcmlwdFN0YXRlKiwgUGFzc1JlZlB0 cjxTY3JpcHRBcmd1bWVudHM+KTsKKyAgICBzdGF0aWMgdm9pZCB0cmFjZShTY3JpcHRTdGF0ZSos IFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7CiAgICAgdm9pZCBhc3NlcnRDb25kaXRpb24o U2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4sIGJvb2wgY29uZGl0aW9u KTsKLSAgICB2b2lkIGNvdW50KFNjcmlwdFN0YXRlKiwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVu dHM+KTsKKyAgICBzdGF0aWMgdm9pZCBjb3VudChTY3JpcHRTdGF0ZSosIFBhc3NSZWZQdHI8U2Ny aXB0QXJndW1lbnRzPik7CiAgICAgdm9pZCBtYXJrVGltZWxpbmUoUGFzc1JlZlB0cjxTY3JpcHRB cmd1bWVudHM+KTsKICNpZiBFTkFCTEUoSkFWQVNDUklQVF9ERUJVR0dFUikKICAgICBjb25zdCBQ cm9maWxlc0FycmF5JiBwcm9maWxlcygpIGNvbnN0IHsgcmV0dXJuIG1fcHJvZmlsZXM7IH0KSW5k ZXg6IFNvdXJjZS9XZWJDb3JlL3BhZ2UvQ29uc29sZS5pZGwKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNl L1dlYkNvcmUvcGFnZS9Db25zb2xlLmlkbAkocmV2aXNpb24gMTQ4MTgxKQorKysgU291cmNlL1dl YkNvcmUvcGFnZS9Db25zb2xlLmlkbAkod29ya2luZyBjb3B5KQpAQCAtMzEsMTUgKzMxLDE1IEBA CiAgICAgT21pdENvbnN0cnVjdG9yCiBdIGludGVyZmFjZSBDb25zb2xlIHsKIAotICAgIFtDYWxs V2l0aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0U3RhdGVdIHZvaWQgZGVidWcoKTsKLSAgICBbQ2Fs bFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlXSB2b2lkIGVycm9yKCk7Ci0gICAgW0Nh bGxXaXRoPVNjcmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZV0gdm9pZCBpbmZvKCk7Ci0gICAgW0Nh bGxXaXRoPVNjcmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZV0gdm9pZCBsb2coKTsKLSAgICBbQ2Fs bFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlXSB2b2lkIHdhcm4oKTsKLSAgICBbQ2Fs bFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlXSB2b2lkIGRpcigpOwotICAgIFtDYWxs V2l0aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0U3RhdGVdIHZvaWQgZGlyeG1sKCk7Ci0gICAgW0Nh bGxXaXRoPVNjcmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZV0gdm9pZCB0YWJsZSgpOwotICAgIFtD YWxsV2l0aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0U3RhdGVdIHZvaWQgdHJhY2UoKTsKKyAgICBb Q2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlLCBMZW5pZW50VGhpc10gdm9pZCBk ZWJ1ZygpOworICAgIFtDYWxsV2l0aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0U3RhdGUsIExlbmll bnRUaGlzXSB2b2lkIGVycm9yKCk7CisgICAgW0NhbGxXaXRoPVNjcmlwdEFyZ3VtZW50c3xTY3Jp cHRTdGF0ZSwgTGVuaWVudFRoaXNdIHZvaWQgaW5mbygpOworICAgIFtDYWxsV2l0aD1TY3JpcHRB cmd1bWVudHN8U2NyaXB0U3RhdGUsIExlbmllbnRUaGlzXSB2b2lkIGxvZygpOworICAgIFtDYWxs V2l0aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0U3RhdGUsIExlbmllbnRUaGlzXSB2b2lkIHdhcm4o KTsKKyAgICBbQ2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlLCBMZW5pZW50VGhp c10gdm9pZCBkaXIoKTsKKyAgICBbQ2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRl LCBMZW5pZW50VGhpc10gdm9pZCBkaXJ4bWwoKTsKKyAgICBbQ2FsbFdpdGg9U2NyaXB0QXJndW1l bnRzfFNjcmlwdFN0YXRlLCBMZW5pZW50VGhpc10gdm9pZCB0YWJsZSgpOworICAgIFtDYWxsV2l0 aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0U3RhdGUsIExlbmllbnRUaGlzXSB2b2lkIHRyYWNlKCk7 CiAgICAgW0NhbGxXaXRoPVNjcmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZSwgSW1wbGVtZW50ZWRB cz1hc3NlcnRDb25kaXRpb25dIHZvaWQgYXNzZXJ0KGluIGJvb2xlYW4gY29uZGl0aW9uKTsKICAg ICBbQ2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlXSB2b2lkIGNvdW50KCk7CiAg ICAgW0NhbGxXaXRoPVNjcmlwdEFyZ3VtZW50c10gdm9pZCBtYXJrVGltZWxpbmUoKTsKQEAgLTU3 LDcgKzU3LDcgQEAKICAgICBbQ2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlXSB2 b2lkIGdyb3VwKCk7CiAgICAgW0NhbGxXaXRoPVNjcmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZV0g dm9pZCBncm91cENvbGxhcHNlZCgpOwogICAgIHZvaWQgZ3JvdXBFbmQoKTsKLSAgICBbQ2FsbFdp dGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlXSB2b2lkIGNsZWFyKCk7CisgICAgW0NhbGxX aXRoPVNjcmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZSwgTGVuaWVudFRoaXNdIHZvaWQgY2xlYXIo KTsKIAogICAgIHJlYWRvbmx5IGF0dHJpYnV0ZSBNZW1vcnlJbmZvIG1lbW9yeTsKIH07CkluZGV4 OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCShyZXZpc2lvbiAxNDgxODEpCisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcg Y29weSkKQEAgLTEsMyArMSwxMyBAQAorMjAxMy0wNC0xMCAgVmljdG9yIENvc3RhbiAgPGNvc3Rh bkBnbWFpbC5jb20+CisKKyAgICAgICAgQ2FsbGluZyBjb25zb2xlLntsb2csIGluZm8sIGVycm9y LCAuLi59IHNob3VsZCBub3QgcmVxdWlyZSB0aGlzID09PSBjb25zb2xlCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTQ0MDYKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGZhc3QvZG9tL1dpbmRvdy9jb25z b2xlLXVuYm91bmQtZnVuY3Rpb25zLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFz dC9kb20vV2luZG93L2NvbnNvbGUtdW5ib3VuZC1mdW5jdGlvbnMuaHRtbDogQWRkZWQuCisKIDIw MTMtMDQtMTAgIE5vJ2FtIFJvc2VudGhhbCAgPG5vYW1Ad2Via2l0Lm9yZz4KIAogICAgICAgICBB bGxvdyBkaXJlY3QgY29tcG9zaXRpbmcgb2YgYmFja2dyb3VuZCBpbWFnZXMKSW5kZXg6IExheW91 dFRlc3RzL2Zhc3QvZG9tL1dpbmRvdy9jb25zb2xlLXVuYm91bmQtZnVuY3Rpb25zLWV4cGVjdGVk LnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9XaW5kb3cvY29uc29sZS11 bmJvdW5kLWZ1bmN0aW9ucy1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0 cy9mYXN0L2RvbS9XaW5kb3cvY29uc29sZS11bmJvdW5kLWZ1bmN0aW9ucy1leHBlY3RlZC50eHQJ KHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTAgQEAKK0NPTlNPTEUgTUVTU0FHRTogbGluZSAxMTog Y29uc29sZS5sb2coKSBjYWxsZWQuCitDT05TT0xFIE1FU1NBR0U6IGxpbmUgMTM6IGNvbnNvbGUu aW5mbygpIGNhbGxlZC4KK0NPTlNPTEUgTUVTU0FHRTogbGluZSAxNTogY29uc29sZS53YXJuKCkg Y2FsbGVkLgorQ09OU09MRSBNRVNTQUdFOiBsaW5lIDE3OiBjb25zb2xlLmVycm9yKCkgY2FsbGVk LgorVGVzdHMgd2luZG93LmNvbnNvbGUgZnVuY3Rpb25zIHdoZW4gInRoaXMiIGlzIG5vdCBzZXQg dG8gY29uc29sZS4gVG8gbWFrZSBzdXJlIHRoaXMgdGVzdCBwYXNzZWQgeW91IG11c3QgY2hlY2sg dGhlIGNvbnNvbGUgZm9yIHRoZSBmb2xsb3dpbmcgNCBtZXNzYWdlczoKKworY29uc29sZS5sb2co KSBjYWxsZWQuCitjb25zb2xlLmluZm8oKSBjYWxsZWQuCitjb25zb2xlLndhcm4oKSBjYWxsZWQu Citjb25zb2xlLmVycm9yKCkgY2FsbGVkLgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9kb20vV2lu ZG93L2NvbnNvbGUtdW5ib3VuZC1mdW5jdGlvbnMuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRU ZXN0cy9mYXN0L2RvbS9XaW5kb3cvY29uc29sZS11bmJvdW5kLWZ1bmN0aW9ucy5odG1sCShyZXZp c2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9kb20vV2luZG93L2NvbnNvbGUtdW5ib3VuZC1m dW5jdGlvbnMuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzMCBAQAorPCFET0NUWVBFIGh0 bWw+Cis8aHRtbD4KKzxoZWFkPgorICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4K KyAgICAgICAgZnVuY3Rpb24gcnVuVGVzdHMoKQorICAgICAgICB7CisgICAgICAgICAgICBpZiAo d2luZG93LnRlc3RSdW5uZXIpCisgICAgICAgICAgICAgICAgdGVzdFJ1bm5lci5kdW1wQXNUZXh0 KCk7CisKKyAgICAgICAgICAgIHZhciBsb2cgPSBjb25zb2xlLmxvZzsKKyAgICAgICAgICAgIGxv ZygiY29uc29sZS5sb2coKSBjYWxsZWQuIik7CisgICAgICAgICAgICB2YXIgaW5mbyA9IGNvbnNv bGUuaW5mbzsKKyAgICAgICAgICAgIGluZm8oImNvbnNvbGUuaW5mbygpIGNhbGxlZC4iKTsKKyAg ICAgICAgICAgIHZhciB3YXJuID0gY29uc29sZS53YXJuOworICAgICAgICAgICAgd2FybigiY29u c29sZS53YXJuKCkgY2FsbGVkLiIpOworICAgICAgICAgICAgdmFyIGVycm9yID0gY29uc29sZS5l cnJvcjsKKyAgICAgICAgICAgIGVycm9yKCJjb25zb2xlLmVycm9yKCkgY2FsbGVkLiIpOworICAg ICAgICB9CisgICAgPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keSBvbmxvYWQ9InJ1blRlc3RzKCk7 Ij4KKyAgICA8cD5UZXN0cyB3aW5kb3cuY29uc29sZSBmdW5jdGlvbnMgd2hlbiAidGhpcyIgaXMg bm90IHNldCB0byBjb25zb2xlLiAgVG8gbWFrZSBzdXJlIHRoaXMgdGVzdCBwYXNzZWQgeW91IG11 c3QgY2hlY2sgdGhlIGNvbnNvbGUgZm9yIHRoZSBmb2xsb3dpbmcgNCBtZXNzYWdlczo8L3A+Cisg ICAgPHVsPgorICAgICAgICA8bGk+Y29uc29sZS5sb2coKSBjYWxsZWQuPC9saT4KKyAgICAgICAg PGxpPmNvbnNvbGUuaW5mbygpIGNhbGxlZC48L2xpPgorICAgICAgICA8bGk+Y29uc29sZS53YXJu KCkgY2FsbGVkLjwvbGk+CisgICAgICAgIDxsaT5jb25zb2xlLmVycm9yKCkgY2FsbGVkLjwvbGk+ CisgICAgPC91bD4KKzwvYm9keT4KKzwvaHRtbD4K 197676 2013-04-11 14:52:20 -0700 2014-02-05 11:22:24 -0800 Patch bug-20141-20130411175159.patch text/plain 36501 costan SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDE0ODE4MSkKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDQ5IEBACisyMDEzLTA0LTEwICBWaWN0b3Ig Q29zdGFuICA8Y29zdGFuQGdtYWlsLmNvbT4KKworICAgICAgICBDYWxsaW5nIGNvbnNvbGUue2xv ZywgaW5mbywgZXJyb3IsIC4uLn0gc2hvdWxkIG5vdCByZXF1aXJlIHRoaXMgPT09IGNvbnNvbGUK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTExNDQwNgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRlc3Q6IGZh c3QvZG9tL1dpbmRvdy9jb25zb2xlLXVuYm91bmQtZnVuY3Rpb25zLmh0bWwKKworICAgICAgICAq IGJpbmRpbmdzL3NjcmlwdHMvQ29kZUdlbmVyYXRvckpTLnBtOiBpbXBsZW1lbnRlZCB0aGUgW0xl bmllbnRUaGlzXSBtZXRob2QgYXR0cmlidXRlCisgICAgICAgIChBZGRJbmNsdWRlc0ZvclR5cGVJ bkltcGwpOiB3aGl0ZXNwYWNlIHJlbW92YWwKKyAgICAgICAgKEFkZEluY2x1ZGVzRm9yVHlwZUlu SGVhZGVyKTogd2hpdGVzcGFjZSByZW1vdmFsCisgICAgICAgIChHZW5lcmF0ZUdldE93blByb3Bl cnR5RGVzY3JpcHRvckJvZHkpOiB3aGl0ZXNwYWNlIHJlbW92YWwKKyAgICAgICAgKEdlbmVyYXRl SGVhZGVyKTogW0xlbmllbnRUaGlzXSBtZXRob2RzIGFyZSBzdGF0aWMKKyAgICAgICAgKEdlbmVy YXRlQXR0cmlidXRlc0hhc2hUYWJsZSk6IHdoaXRlc3BhY2UgcmVtb3ZhbAorICAgICAgICAoR2Vu ZXJhdGVJbXBsZW1lbnRhdGlvbik6IFtMZW5pZW50VGhpc10gbWV0aG9kIHNob3VsZCBiZSBpbnZv a2VkIHVzaW5nIHRoZSBzdGF0aWMgbWV0aG9kIHN5bnRheAorICAgICAgICAoR2VuZXJhdGVQYXJh bWV0ZXJzQ2hlY2spOiBbTGVuaWVudFRoaXNdIG1ldGhvZCBzaG91bGQgYmUgaW52b2tlZCB1c2lu ZyB0aGUgc3RhdGljIG1ldGhvZCBzeW50YXggCisgICAgICAgIChHZW5lcmF0ZUltcGxlbWVudGF0 aW9uRnVuY3Rpb25DYWxsKTogd2hpdGVzcGFjZSByZW1vdmFsCisgICAgICAgIChHZXRTVkdQcm9w ZXJ0eVR5cGVzKTogd2hpdGVzcGFjZSByZW1vdmFsCisgICAgICAgIChHZW5lcmF0ZUhhc2hUYWJs ZSk6IHdoaXRlc3BhY2UgcmVtb3ZhbAorICAgICAgICAoTWFrZXNTdGF0aWNDYWxsKTogcmV0dXJu cyB0cnVlIGZvciBtZXRob2RzIHRoYXQgZ2VuZXJhdGUgc3RhdGljIGNhbGxzIGluIFdlYkNvcmUK KyAgICAgICAgKiBiaW5kaW5ncy9zY3JpcHRzL0lETEF0dHJpYnV0ZXMudHh0OiBhZGRlZCB0aGUg W0xlbmllbnRUaGlzXSBtZXRob2QgYXR0cmlidXRlCisgICAgICAgICogYmluZGluZ3Mvc2NyaXB0 cy90ZXN0L0NQUC9XZWJET01UZXN0T2JqLmNwcDogcmVnZW5lcmF0ZWQgdGVzdAorICAgICAgICAq IGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9DUFAvV2ViRE9NVGVzdE9iai5oOiByZWdlbmVyYXRlZCB0 ZXN0CisgICAgICAgICogYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0dPYmplY3QvV2ViS2l0RE9NVGVz dE9iai5jcHA6IHJlZ2VuZXJhdGVkIHRlc3QKKyAgICAgICAgKiBiaW5kaW5ncy9zY3JpcHRzL3Rl c3QvR09iamVjdC9XZWJLaXRET01UZXN0T2JqLmg6IHJlZ2VuZXJhdGVkIHRlc3QKKyAgICAgICAg KiBiaW5kaW5ncy9zY3JpcHRzL3Rlc3QvSlMvSlNUZXN0T2JqLmNwcDogcmVnZW5lcmF0ZWQgdGVz dAorICAgICAgICAqIGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9KUy9KU1Rlc3RPYmouaDogcmVnZW5l cmF0ZWQgdGVzdAorICAgICAgICAqIGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9PYmpDL0RPTVRlc3RP YmouaDogcmVnZW5lcmF0ZWQgdGVzdAorICAgICAgICAqIGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9P YmpDL0RPTVRlc3RPYmoubW06IHJlZ2VuZXJhdGVkIHRlc3QKKyAgICAgICAgKiBiaW5kaW5ncy9z Y3JpcHRzL3Rlc3QvVGVzdE9iai5pZGw6IGFkZGVkIG1ldGhvZCB0aGF0IHRlc3RzIHRoZSBbTGVu aWVudFRoaXNdIGF0dHJpYnV0ZQorICAgICAgICAqIHBhZ2UvQ29uc29sZS5jcHA6IG1hZGUgYSBi dW5jaCBvZiBjb25zb2xlIG1ldGhvZHMgc3RhdGljCisgICAgICAgIChXZWJDb3JlOjpDb25zb2xl OjpkZWJ1Zyk6IGJlY2FtZSBzdGF0aWMKKyAgICAgICAgKFdlYkNvcmU6OkNvbnNvbGU6OmVycm9y KTogYmVjYW1lIHN0YXRpYworICAgICAgICAoV2ViQ29yZTo6Q29uc29sZTo6bG9nKTogYmVjYW1l IHN0YXRpYworICAgICAgICAoV2ViQ29yZTo6Q29uc29sZTo6d2Fybik6IGJlY2FtZSBzdGF0aWMK KyAgICAgICAgKFdlYkNvcmU6OkNvbnNvbGU6OmRpcik6IGJlY2FtZSBzdGF0aWMKKyAgICAgICAg KFdlYkNvcmU6OkNvbnNvbGU6OmRpcnhtbCk6IGJlY2FtZSBzdGF0aWMKKyAgICAgICAgKFdlYkNv cmU6OkNvbnNvbGU6OnRhYmxlKTogYmVjYW1lIHN0YXRpYworICAgICAgICAoV2ViQ29yZTo6Q29u c29sZTo6Y2xlYXIpOiBiZWNhbWUgc3RhdGljCisgICAgICAgIChXZWJDb3JlOjpDb25zb2xlOjp0 cmFjZSk6IGJlY2FtZSBzdGF0aWMKKyAgICAgICAgKFdlYkNvcmU6OkNvbnNvbGU6OmNvdW50KTog YmVjYW1lIHN0YXRpYworICAgICAgICAoV2ViQ29yZTo6Q29uc29sZTo6cGFnZUZyb21TY3JpcHRT dGF0ZSk6IHJlY292ZXJzIENvbnNvbGUgZGF0YSBmcm9tIHRoZSBTY3JpcHRTdGF0ZQorICAgICAg ICAqIHBhZ2UvQ29uc29sZS5oOiBkZWNsYXJlZCB0aGUgbWV0aG9kcyBhYm92ZSB0byBiZSBzdGF0 aWMKKyAgICAgICAgKiBwYWdlL0NvbnNvbGUuaWRsOiBhZGRlZCB0aGUgW0xlbmllbnRUaGlzXSBh dHRyaWJ1dGUgdG8gdGhlIGNvbnNvbGUgbWV0aG9kcyBsaXN0ZWQgYWJvdmUKKwogMjAxMy0wNC0x MCAgQWxleGV5IFByb3NrdXJ5YWtvdiAgPGFwQGFwcGxlLmNvbT4KIAogICAgICAgICBSZW1vdmUg c29tZSBpbmNsdWRlcyBvZiBDYWNoZWRJbWFnZS5oCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9iaW5k aW5ncy9zY3JpcHRzL0NvZGVHZW5lcmF0b3JKUy5wbQo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5lcmF0b3JKUy5wbQkocmV2aXNpb24gMTQ4MTgx KQorKysgU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9Db2RlR2VuZXJhdG9ySlMucG0J KHdvcmtpbmcgY29weSkKQEAgLTE4OCw5ICsxODgsOSBAQCBzdWIgQWRkSW5jbHVkZXNGb3JUeXBl SW5JbXBsCiB7CiAgICAgbXkgJHR5cGUgPSBzaGlmdDsKICAgICBteSAkaXNDYWxsYmFjayA9IEBf ID8gc2hpZnQgOiAwOwotICAgIAorCiAgICAgQWRkSW5jbHVkZXNGb3JUeXBlKCR0eXBlLCAkaXND YWxsYmFjaywgXCVpbXBsSW5jbHVkZXMpOwotICAgIAorCiAgICAgIyBhZGRpdGlvbmFsIGluY2x1 ZGVzICh0aGluZ3MgbmVlZGVkIHRvIGNvbXBpbGUgdGhlIGJpbmRpbmdzIGJ1dCBub3QgdGhlIGhl YWRlcikKICAgICBpZiAoJHR5cGUgZXEgIkNhbnZhc1JlbmRlcmluZ0NvbnRleHQyRCIpIHsKICAg ICAgICAgJGltcGxJbmNsdWRlc3siQ2FudmFzR3JhZGllbnQuaCJ9ID0gMTsKQEAgLTIxNSw3ICsy MTUsNyBAQCBzdWIgQWRkSW5jbHVkZXNGb3JUeXBlSW5IZWFkZXIKIHsKICAgICBteSAkdHlwZSA9 IHNoaWZ0OwogICAgIG15ICRpc0NhbGxiYWNrID0gQF8gPyBzaGlmdCA6IDA7Ci0gICAgCisKICAg ICBBZGRJbmNsdWRlc0ZvclR5cGUoJHR5cGUsICRpc0NhbGxiYWNrLCBcJWhlYWRlckluY2x1ZGVz KTsKIH0KIApAQCAtNDY0LDkgKzQ2NCw5IEBAIHN1YiBHZW5lcmF0ZUdldE93blByb3BlcnR5U2xv dEJvZHkKIHN1YiBHZW5lcmF0ZUdldE93blByb3BlcnR5RGVzY3JpcHRvckJvZHkKIHsKICAgICBt eSAoJGludGVyZmFjZSwgJGludGVyZmFjZU5hbWUsICRjbGFzc05hbWUsICRoYXNBdHRyaWJ1dGVz LCAkaW5saW5lZCkgPSBAXzsKLSAgICAKKwogICAgIG15ICRuYW1lc3BhY2VNYXliZSA9ICgkaW5s aW5lZCA/ICJKU0M6OiIgOiAiIik7Ci0gICAgCisKICAgICBteSBAZ2V0T3duUHJvcGVydHlEZXNj cmlwdG9ySW1wbCA9ICgpOwogICAgIGlmICgkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJpYnV0ZXMt PnsiQ2hlY2tTZWN1cml0eSJ9KSB7CiAgICAgICAgIGlmICgkaW50ZXJmYWNlTmFtZSBlcSAiRE9N V2luZG93IikgewpAQCAtNDc3LDEzICs0NzcsMTMgQEAgc3ViIEdlbmVyYXRlR2V0T3duUHJvcGVy dHlEZXNjcmlwdG9yQm9keQogICAgICAgICB9CiAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAi ICAgICAgICByZXR1cm4gZmFsc2U7XG4iKTsKICAgICB9Ci0gICAgCisKICAgICBpZiAoJGludGVy ZmFjZU5hbWUgZXEgIk5hbWVkTm9kZU1hcCIgb3IgJGludGVyZmFjZU5hbWUgPX4gL15IVE1MXHcq Q29sbGVjdGlvbiQvKSB7CiAgICAgICAgIHB1c2goQGdldE93blByb3BlcnR5RGVzY3JpcHRvcklt cGwsICIgICAgJHtuYW1lc3BhY2VNYXliZX1KU1ZhbHVlIHByb3RvID0gdGhpc09iamVjdC0+cHJv dG90eXBlKCk7XG4iKTsKICAgICAgICAgcHVzaChAZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9ySW1w bCwgIiAgICBpZiAocHJvdG8uaXNPYmplY3QoKSAmJiBqc0Nhc3Q8JHtuYW1lc3BhY2VNYXliZX1K U09iamVjdCo+KGFzT2JqZWN0KHByb3RvKSktPmhhc1Byb3BlcnR5KGV4ZWMsIHByb3BlcnR5TmFt ZSkpXG4iKTsKICAgICAgICAgcHVzaChAZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9ySW1wbCwgIiAg ICAgICAgcmV0dXJuIGZhbHNlO1xuXG4iKTsKICAgICB9Ci0gICAgCisKICAgICBteSAkbWFudWFs TG9va3VwR2V0dGVyR2VuZXJhdGlvbiA9IHN1YiB7CiAgICAgICAgIG15ICRyZXF1aXJlc01hbnVh bExvb2t1cCA9ICRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJJbmRleGVkR2V0dGVy In0gfHwgJGludGVyZmFjZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57Ik5hbWVkR2V0dGVyIn07CiAg ICAgICAgIGlmICgkcmVxdWlyZXNNYW51YWxMb29rdXApIHsKQEAgLTU1OCw3ICs1NTgsNyBAQCBz dWIgR2VuZXJhdGVHZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JCb2R5CiAgICAgfSBlbHNlIHsKICAg ICAgICAgcHVzaChAZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9ySW1wbCwgIiAgICByZXR1cm4gQmFz ZTo6Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9yKHRoaXNPYmplY3QsIGV4ZWMsIHByb3BlcnR5TmFt ZSwgZGVzY3JpcHRvcik7XG4iKTsKICAgICB9Ci0gICAgCisKICAgICByZXR1cm4gQGdldE93blBy b3BlcnR5RGVzY3JpcHRvckltcGw7CiB9CiAKQEAgLTY5NSw3ICs2OTUsNyBAQCBzdWIgR2VuZXJh dGVIZWFkZXIKICAgICAgICAgICAgICRoZWFkZXJJbmNsdWRlc3siJGludGVyZmFjZU5hbWUuaCJ9 ID0gMTsKICAgICAgICAgfQogICAgIH0KLSAgICAKKwogICAgICRoZWFkZXJJbmNsdWRlc3siPHJ1 bnRpbWUvSlNPYmplY3QuaD4ifSA9IDE7CiAgICAgJGhlYWRlckluY2x1ZGVzeyJTVkdFbGVtZW50 LmgifSA9IDEgaWYgJGNsYXNzTmFtZSA9fiAvXkpTU1ZHLzsKIApAQCAtNzg3LDcgKzc4Nyw3IEBA IHN1YiBHZW5lcmF0ZUhlYWRlcgogICAgICAgICB8fCAkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJp YnV0ZXMtPnsiTnVtZXJpY0luZGV4ZWRHZXR0ZXIifQogICAgICAgICB8fCAkaW50ZXJmYWNlLT5l eHRlbmRlZEF0dHJpYnV0ZXMtPnsiSlNDdXN0b21HZXRPd25Qcm9wZXJ0eVNsb3RBbmREZXNjcmlw dG9yIn0KICAgICAgICAgfHwgJGhhc0ltcHVyZU5hbWVkR2V0dGVyOwotICAgIAorCiAgICAgbXkg JGhhc0dldHRlciA9ICRudW1BdHRyaWJ1dGVzID4gMCB8fCAhJGludGVyZmFjZS0+ZXh0ZW5kZWRB dHRyaWJ1dGVzLT57Ik9taXRDb25zdHJ1Y3RvciJ9IHx8ICRoYXNDb21wbGV4R2V0dGVyOwogCiAg ICAgaWYgKCRoYXNJbXB1cmVOYW1lZEdldHRlcikgewpAQCAtODE3LDcgKzgxNyw3IEBAIHN1YiBH ZW5lcmF0ZUhlYWRlcgogICAgICAgICAkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsi Q3VzdG9tUHV0RnVuY3Rpb24ifQogICAgICAgICB8fCAkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJp YnV0ZXMtPnsiQ3VzdG9tTmFtZWRTZXR0ZXIifQogICAgICAgICB8fCAkaW50ZXJmYWNlLT5leHRl bmRlZEF0dHJpYnV0ZXMtPnsiQ3VzdG9tSW5kZXhlZFNldHRlciJ9OwotICAgICAgICAKKwogICAg IG15ICRoYXNTZXR0ZXIgPSAkaGFzUmVhZFdyaXRlUHJvcGVydGllcyB8fCAkaGFzQ29tcGxleFNl dHRlcjsKIAogICAgICMgR2V0dGVycwpAQCAtODcwLDcgKzg3MCw3IEBAIHN1YiBHZW5lcmF0ZUhl YWRlcgogICAgICMgQ3VzdG9tIGdldE93blByb3BlcnR5TmFtZXMgZnVuY3Rpb24KICAgICBpZiAo JGludGVyZmFjZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57IkN1c3RvbUVudW1lcmF0ZVByb3BlcnR5 In0gfHwgJGludGVyZmFjZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57IkluZGV4ZWRHZXR0ZXIifSB8 fCAkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiTnVtZXJpY0luZGV4ZWRHZXR0ZXIi fSkgewogICAgICAgICBwdXNoKEBoZWFkZXJDb250ZW50LCAiICAgIHN0YXRpYyB2b2lkIGdldE93 blByb3BlcnR5TmFtZXMoSlNDOjpKU09iamVjdCosIEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpQcm9w ZXJ0eU5hbWVBcnJheSYsIEpTQzo6RW51bWVyYXRpb25Nb2RlIG1vZGUgPSBKU0M6OkV4Y2x1ZGVE b250RW51bVByb3BlcnRpZXMpO1xuIik7Ci0gICAgICAgICRzdHJ1Y3R1cmVGbGFnc3siSlNDOjpP dmVycmlkZXNHZXRQcm9wZXJ0eU5hbWVzIn0gPSAxOyAgICAgICAKKyAgICAgICAgJHN0cnVjdHVy ZUZsYWdzeyJKU0M6Ok92ZXJyaWRlc0dldFByb3BlcnR5TmFtZXMifSA9IDE7CiAgICAgfQogCiAg ICAgIyBDdXN0b20gZGVmaW5lT3duUHJvcGVydHkgZnVuY3Rpb24KQEAgLTk0MSw3ICs5NDEsNyBA QCBzdWIgR2VuZXJhdGVIZWFkZXIKICAgICAgICAgICAgIG15ICRjb25kaXRpb25hbFN0cmluZyA9 ICRjb2RlR2VuZXJhdG9yLT5HZW5lcmF0ZUNvbmRpdGlvbmFsU3RyaW5nKCRmdW5jdGlvbi0+c2ln bmF0dXJlKTsKICAgICAgICAgICAgIHB1c2goQGhlYWRlckNvbnRlbnQsICIjaWYgJHtjb25kaXRp b25hbFN0cmluZ31cbiIpIGlmICRjb25kaXRpb25hbFN0cmluZzsKICAgICAgICAgICAgIG15ICRm dW5jdGlvbkltcGxlbWVudGF0aW9uTmFtZSA9ICRmdW5jdGlvbi0+c2lnbmF0dXJlLT5leHRlbmRl ZEF0dHJpYnV0ZXMtPnsiSW1wbGVtZW50ZWRBcyJ9IHx8ICRjb2RlR2VuZXJhdG9yLT5XS19sY2Zp cnN0KCRmdW5jdGlvbi0+c2lnbmF0dXJlLT5uYW1lKTsKLSAgICAgICAgICAgIHB1c2goQGhlYWRl ckNvbnRlbnQsICIgICAgIiAuICgkZnVuY3Rpb24tPmlzU3RhdGljID8gInN0YXRpYyAiIDogIiIp IC4gIkpTQzo6SlNWYWx1ZSAiIC4gJGZ1bmN0aW9uSW1wbGVtZW50YXRpb25OYW1lIC4gIihKU0M6 OkV4ZWNTdGF0ZSopO1xuIik7CisgICAgICAgICAgICBwdXNoKEBoZWFkZXJDb250ZW50LCAiICAg ICIgLiAoTWFrZXNTdGF0aWNDYWxsKCRmdW5jdGlvbikgPyAic3RhdGljICIgOiAiIikgLiAiSlND OjpKU1ZhbHVlICIgLiAkZnVuY3Rpb25JbXBsZW1lbnRhdGlvbk5hbWUgLiAiKEpTQzo6RXhlY1N0 YXRlKik7XG4iKTsKICAgICAgICAgICAgIHB1c2goQGhlYWRlckNvbnRlbnQsICIjZW5kaWZcbiIp IGlmICRjb25kaXRpb25hbFN0cmluZzsKICAgICAgICAgfQogICAgIH0KQEAgLTEwNzIsNyArMTA3 Miw3IEBAIHN1YiBHZW5lcmF0ZUhlYWRlcgogICAgIGlmICgkdXNlc1RvSlNOZXdseUNyZWF0ZWR7 JGludGVyZmFjZU5hbWV9KSB7CiAgICAgICAgIHB1c2goQGhlYWRlckNvbnRlbnQsICJKU0M6OkpT VmFsdWUgdG9KU05ld2x5Q3JlYXRlZChKU0M6OkV4ZWNTdGF0ZSosIEpTRE9NR2xvYmFsT2JqZWN0 KiwgJGludGVyZmFjZU5hbWUqKTtcbiIpOwogICAgIH0KLSAgICAKKwogICAgIHB1c2goQGhlYWRl ckNvbnRlbnQsICJcbiIpOwogCiAgICAgIyBBZGQgcHJvdG90eXBlIGRlY2xhcmF0aW9uLgpAQCAt MTE1Niw3ICsxMTU2LDcgQEAgc3ViIEdlbmVyYXRlSGVhZGVyCiAgICAgICAgICAgICB9CiAgICAg ICAgICAgICBwdXNoKEBoZWFkZXJDb250ZW50LCAiI2VuZGlmXG4iKSBpZiAkY29uZGl0aW9uYWxT dHJpbmc7CiAgICAgICAgIH0KLSAgICAgICAgCisKICAgICAgICAgaWYgKCEkaW50ZXJmYWNlLT5l eHRlbmRlZEF0dHJpYnV0ZXMtPnsiT21pdENvbnN0cnVjdG9yIn0pIHsKICAgICAgICAgICAgIG15 ICRnZXR0ZXIgPSAianMiIC4gJGludGVyZmFjZU5hbWUgLiAiQ29uc3RydWN0b3IiOwogICAgICAg ICAgICAgcHVzaChAaGVhZGVyQ29udGVudCwgIkpTQzo6SlNWYWx1ZSAke2dldHRlcn0oSlNDOjpF eGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIEpTQzo6UHJvcGVydHlOYW1lKTtcbiIpOwpAQCAtMTE4 Nyw3ICsxMTg3LDcgQEAgc3ViIEdlbmVyYXRlSGVhZGVyCiAgICAgIyAtIEdlbmVyYXRlIGRlcGVu ZGVuY2llcy4KICAgICBpZiAoJHdyaXRlRGVwZW5kZW5jaWVzICYmIEBhbmNlc3RvckludGVyZmFj ZU5hbWVzKSB7CiAgICAgICAgIHB1c2goQGRlcHNDb250ZW50LCAiJGNsYXNzTmFtZS5oIDogIiwg am9pbigiICIsIG1hcCB7ICIkXy5pZGwiIH0gQGFuY2VzdG9ySW50ZXJmYWNlTmFtZXMpLCAiXG4i KTsKLSAgICAgICAgcHVzaChAZGVwc0NvbnRlbnQsIG1hcCB7ICIkXy5pZGwgOlxuIiB9IEBhbmNl c3RvckludGVyZmFjZU5hbWVzKTsgCisgICAgICAgIHB1c2goQGRlcHNDb250ZW50LCBtYXAgeyAi JF8uaWRsIDpcbiIgfSBAYW5jZXN0b3JJbnRlcmZhY2VOYW1lcyk7CiAgICAgfQogfQogCkBAIC0x MTk4LDcgKzExOTgsNyBAQCBzdWIgR2VuZXJhdGVBdHRyaWJ1dGVzSGFzaFRhYmxlKCQkKQogICAg ICMgRklYTUU6IFRoZXNlIHNob3VsZCBiZSBmdW5jdGlvbnMgb24gJGludGVyZmFjZS4KICAgICBt eSAkaW50ZXJmYWNlTmFtZSA9ICRpbnRlcmZhY2UtPm5hbWU7CiAgICAgbXkgJGNsYXNzTmFtZSA9 ICJKUyRpbnRlcmZhY2VOYW1lIjsKLSAgICAKKwogICAgICMgLSBBZGQgYWxsIGF0dHJpYnV0ZXMg aW4gYSBoYXNodGFibGUgZGVmaW5pdGlvbgogICAgIG15ICRudW1BdHRyaWJ1dGVzID0gQHskaW50 ZXJmYWNlLT5hdHRyaWJ1dGVzfTsKICAgICAkbnVtQXR0cmlidXRlcysrIGlmICEkaW50ZXJmYWNl LT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiT21pdENvbnN0cnVjdG9yIn07CkBAIC0xMjUyLDcgKzEy NTIsNyBAQCBzdWIgR2VuZXJhdGVBdHRyaWJ1dGVzSGFzaFRhYmxlKCQkKQogICAgICAgICAgICAg bXkgJHNldHRlciA9ICJzZXRKUyIgLiAkaW50ZXJmYWNlTmFtZSAuICJDb25zdHJ1Y3RvciI7CiAg ICAgICAgICAgICBwdXNoKEBoYXNoVmFsdWUyLCAkc2V0dGVyKTsKICAgICAgICAgICAgIHB1c2go QGhhc2hTcGVjaWFscywgIkRvbnRFbnVtIHwgRG9udERlbGV0ZSIpOwotICAgICAgICB9IGVsc2Ug eyAgICAgICAgICAgIAorICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgcHVzaChAaGFzaFZh bHVlMiwgIjAiKTsKICAgICAgICAgICAgIHB1c2goQGhhc2hTcGVjaWFscywgIkRvbnRFbnVtIHwg UmVhZE9ubHkiKTsKICAgICAgICAgfQpAQCAtMTYwMyw3ICsxNjAzLDcgQEAgc3ViIEdlbmVyYXRl SW1wbGVtZW50YXRpb24KICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQsICIgICAgJHtjbGFzc05h bWV9UHJvdG90eXBlKiB0aGlzT2JqZWN0ID0ganNDYXN0PCR7Y2xhc3NOYW1lfVByb3RvdHlwZSo+ KGNlbGwpO1xuIik7CiAKICAgICAgICAgaWYgKCRudW1Db25zdGFudHMgZXEgMCAmJiAkbnVtRnVu Y3Rpb25zIGVxIDApIHsKLSAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAiICAgIHJldHVy biBCYXNlOjpnZXRPd25Qcm9wZXJ0eVNsb3QodGhpc09iamVjdCwgZXhlYywgcHJvcGVydHlOYW1l LCBzbG90KTtcbiIpOyAgICAgICAgCisgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAg ICByZXR1cm4gQmFzZTo6Z2V0T3duUHJvcGVydHlTbG90KHRoaXNPYmplY3QsIGV4ZWMsIHByb3Bl cnR5TmFtZSwgc2xvdCk7XG4iKTsKICAgICAgICAgfSBlbHNpZiAoJG51bUNvbnN0YW50cyBlcSAw KSB7CiAgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAgICByZXR1cm4gZ2V0U3RhdGlj RnVuY3Rpb25TbG90PEpTT2JqZWN0PihleGVjLCAiIC4gcHJvdG90eXBlSGFzaFRhYmxlQWNjZXNz b3IoJGludGVyZmFjZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57IkpTTm9TdGF0aWNUYWJsZXMifSwg JGNsYXNzTmFtZSkgLiAiLCB0aGlzT2JqZWN0LCBwcm9wZXJ0eU5hbWUsIHNsb3QpO1xuIik7CiAg ICAgICAgIH0gZWxzaWYgKCRudW1GdW5jdGlvbnMgZXEgMCkgewpAQCAtMTYxOCw3ICsxNjE4LDcg QEAgc3ViIEdlbmVyYXRlSW1wbGVtZW50YXRpb24KICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQs ICIgICAgJHtjbGFzc05hbWV9UHJvdG90eXBlKiB0aGlzT2JqZWN0ID0ganNDYXN0PCR7Y2xhc3NO YW1lfVByb3RvdHlwZSo+KG9iamVjdCk7XG4iKTsKIAogICAgICAgICBpZiAoJG51bUNvbnN0YW50 cyBlcSAwICYmICRudW1GdW5jdGlvbnMgZXEgMCkgewotICAgICAgICAgICAgcHVzaChAaW1wbENv bnRlbnQsICIgICAgcmV0dXJuIEJhc2U6OmdldE93blByb3BlcnR5RGVzY3JpcHRvcih0aGlzT2Jq ZWN0LCBleGVjLCBwcm9wZXJ0eU5hbWUsIGRlc2NyaXB0b3IpO1xuIik7ICAgICAgICAKKyAgICAg ICAgICAgIHB1c2goQGltcGxDb250ZW50LCAiICAgIHJldHVybiBCYXNlOjpnZXRPd25Qcm9wZXJ0 eURlc2NyaXB0b3IodGhpc09iamVjdCwgZXhlYywgcHJvcGVydHlOYW1lLCBkZXNjcmlwdG9yKTtc biIpOwogICAgICAgICB9IGVsc2lmICgkbnVtQ29uc3RhbnRzIGVxIDApIHsKICAgICAgICAgICAg IHB1c2goQGltcGxDb250ZW50LCAiICAgIHJldHVybiBnZXRTdGF0aWNGdW5jdGlvbkRlc2NyaXB0 b3I8SlNPYmplY3Q+KGV4ZWMsICIgLiBwcm90b3R5cGVIYXNoVGFibGVBY2Nlc3NvcigkaW50ZXJm YWNlLT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiSlNOb1N0YXRpY1RhYmxlcyJ9LCAkY2xhc3NOYW1l KSAuICIsIHRoaXNPYmplY3QsIHByb3BlcnR5TmFtZSwgZGVzY3JpcHRvcik7XG4iKTsKICAgICAg ICAgfSBlbHNpZiAoJG51bUZ1bmN0aW9ucyBlcSAwKSB7CkBAIC0xNzE5LDcgKzE3MTksNyBAQCBz dWIgR2VuZXJhdGVJbXBsZW1lbnRhdGlvbgogICAgIH0KIAogICAgIGlmICghJGhhc1BhcmVudCkg ewotICAgICAgICAjIEZJWE1FOiBUaGlzIGRlc3Ryb3kgZnVuY3Rpb24gc2hvdWxkIG5vdCBiZSBu ZWNlc3NhcnksIGFzIAorICAgICAgICAjIEZJWE1FOiBUaGlzIGRlc3Ryb3kgZnVuY3Rpb24gc2hv dWxkIG5vdCBiZSBuZWNlc3NhcnksIGFzCiAgICAgICAgICMgYSBmaW5hbGl6ZXIgc2hvdWxkIGJl IGNhbGxlZCBmb3IgZWFjaCBET00gb2JqZWN0IHdyYXBwZXIuCiAgICAgICAgICMgSG93ZXZlciwg dGhhdCBzZWVtcyBub3QgdG8gYmUgdGhlIGNhc2UsIHNvIHRoaXMgaGFzIGJlZW4KICAgICAgICAg IyBhZGRlZCBiYWNrIHRvIGF2b2lkIGxlYWtpbmcgd2hpbGUgd2UgZmlndXJlIG91dCB3aHkgdGhl CkBAIC0xNzQwLDcgKzE3NDAsNyBAQCBzdWIgR2VuZXJhdGVJbXBsZW1lbnRhdGlvbgogICAgIH0K IAogICAgIG15ICRoYXNHZXR0ZXIgPSAkbnVtQXR0cmlidXRlcyA+IDAKLSAgICAgICAgICAgICAg ICAgfHwgISRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJPbWl0Q29uc3RydWN0b3Ii fSAKKyAgICAgICAgICAgICAgICAgfHwgISRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+ eyJPbWl0Q29uc3RydWN0b3IifQogICAgICAgICAgICAgICAgICB8fCAkaW50ZXJmYWNlLT5leHRl bmRlZEF0dHJpYnV0ZXMtPnsiSW5kZXhlZEdldHRlciJ9CiAgICAgICAgICAgICAgICAgIHx8ICRp bnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJOdW1lcmljSW5kZXhlZEdldHRlciJ9CiAg ICAgICAgICAgICAgICAgIHx8ICRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJKU0N1 c3RvbUdldE93blByb3BlcnR5U2xvdEFuZERlc2NyaXB0b3IifQpAQCAtMjAyOCw3ICsyMDI4LDcg QEAgc3ViIEdlbmVyYXRlSW1wbGVtZW50YXRpb24KICAgICAgICAgICAgICAgICAgICAgcHVzaChA aW1wbENvbnRlbnQsICIgICAgQmFzZTo6cHV0KHRoaXNPYmplY3QsIGV4ZWMsIHByb3BlcnR5TmFt ZSwgdmFsdWUsIHNsb3QpO1xuIik7CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAg IHB1c2goQGltcGxDb250ZW50LCAifVxuXG4iKTsKLSAgICAgICAgICAgICAgICAKKwogICAgICAg ICAgICAgICAgIGlmICgkaW50ZXJmYWNlLT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiQ3VzdG9tSW5k ZXhlZFNldHRlciJ9IHx8ICRpbnRlcmZhY2UtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJDdXN0b21O YW1lZFNldHRlciJ9KSB7CiAgICAgICAgICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAi dm9pZCAke2NsYXNzTmFtZX06OnB1dEJ5SW5kZXgoSlNDZWxsKiBjZWxsLCBFeGVjU3RhdGUqIGV4 ZWMsIHVuc2lnbmVkIGluZGV4LCBKU1ZhbHVlIHZhbHVlLCBib29sIHNob3VsZFRocm93KVxuIik7 CiAgICAgICAgICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAie1xuIik7CkBAIC0yMDQx LDE0ICsyMDQxLDE0IEBAIHN1YiBHZW5lcmF0ZUltcGxlbWVudGF0aW9uCiAgICAgICAgICAgICAg ICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAgICAgICAgcmV0dXJuO1xuIik7CiAgICAg ICAgICAgICAgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAgICB9XG4iKTsKICAgICAg ICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgICAgICAKKwogICAgICAgICAgICAgICAg ICAgICBpZiAoJGludGVyZmFjZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57IkN1c3RvbU5hbWVkU2V0 dGVyIn0pIHsKICAgICAgICAgICAgICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAiICAg IFByb3BlcnR5TmFtZSBwcm9wZXJ0eU5hbWUgPSBJZGVudGlmaWVyOjpmcm9tKGV4ZWMsIGluZGV4 KTtcbiIpOwogICAgICAgICAgICAgICAgICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQsICIgICAg UHV0UHJvcGVydHlTbG90IHNsb3Qoc2hvdWxkVGhyb3cpO1xuIik7CiAgICAgICAgICAgICAgICAg ICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAgICBpZiAodGhpc09iamVjdC0+cHV0RGVsZWdh dGUoZXhlYywgcHJvcGVydHlOYW1lLCB2YWx1ZSwgc2xvdCkpXG4iKTsKICAgICAgICAgICAgICAg ICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAiICAgICAgICByZXR1cm47XG4iKTsKICAgICAg ICAgICAgICAgICAgICAgfQotICAgIAorCiAgICAgICAgICAgICAgICAgICAgIHB1c2goQGltcGxD b250ZW50LCAiICAgIEJhc2U6OnB1dEJ5SW5kZXgoY2VsbCwgZXhlYywgaW5kZXgsIHZhbHVlLCBz aG91bGRUaHJvdyk7XG4iKTsKICAgICAgICAgICAgICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQs ICJ9XG5cbiIpOwogICAgICAgICAgICAgICAgIH0KQEAgLTIyMzMsNyArMjIzMyw3IEBAIHN1YiBH ZW5lcmF0ZUltcGxlbWVudGF0aW9uCiAgICAgICAgICAgICAgICAgICAgIGRpZSAiTm8gd2F5IHRv IGhhbmRsZSBpbnRlcmZhY2Ugd2l0aCBSZXBsYWNlYWJsZUNvbnN0cnVjdG9yIGV4dGVuZGVkIGF0 dHJpYnV0ZTogJGludGVyZmFjZU5hbWUiOwogICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAg ICAgICBwdXNoKEBpbXBsQ29udGVudCwgIn1cblxuIik7Ci0gICAgICAgICAgICB9ICAgICAgICAK KyAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0KIApAQCAtMjI5MCw3ICsyMjkwLDcgQEAg c3ViIEdlbmVyYXRlSW1wbGVtZW50YXRpb24KIAogICAgICAgICAgICAgJGltcGxJbmNsdWRlc3si PHJ1bnRpbWUvRXJyb3IuaD4ifSA9IDE7CiAKLSAgICAgICAgICAgIGlmICgkZnVuY3Rpb24tPmlz U3RhdGljKSB7CisgICAgICAgICAgICBpZiAoTWFrZXNTdGF0aWNDYWxsKCRmdW5jdGlvbikpIHsK ICAgICAgICAgICAgICAgICBpZiAoJGlzQ3VzdG9tKSB7CiAgICAgICAgICAgICAgICAgICAgIEdl bmVyYXRlQXJndW1lbnRzQ291bnRDaGVjayhcQGltcGxDb250ZW50LCAkZnVuY3Rpb24sICRpbnRl cmZhY2UpOwogICAgICAgICAgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgIiAgICByZXR1 cm4gSlNWYWx1ZTo6ZW5jb2RlKCR7Y2xhc3NOYW1lfTo6IiAuICRmdW5jdGlvbkltcGxlbWVudGF0 aW9uTmFtZSAuICIoZXhlYykpO1xuIik7CkBAIC0yNjY5LDkgKzI2NjksOSBAQCBzdWIgR2VuZXJh dGVQYXJhbWV0ZXJzQ2hlY2sKICAgICBteSAkaW1wbGVtZW50ZWRCeSA9ICRmdW5jdGlvbi0+c2ln bmF0dXJlLT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiSW1wbGVtZW50ZWRCeSJ9OwogICAgIGlmICgk aW1wbGVtZW50ZWRCeSkgewogICAgICAgICBBZGRUb0ltcGxJbmNsdWRlcygiJHtpbXBsZW1lbnRl ZEJ5fS5oIik7Ci0gICAgICAgIHVuc2hpZnQoQGFyZ3VtZW50cywgImltcGwiKSBpZiAhJGZ1bmN0 aW9uLT5pc1N0YXRpYzsKKyAgICAgICAgdW5zaGlmdChAYXJndW1lbnRzLCAiaW1wbCIpIGlmICFN YWtlc1N0YXRpY0NhbGwoJGZ1bmN0aW9uKTsKICAgICAgICAgJGZ1bmN0aW9uTmFtZSA9ICIke2lt cGxlbWVudGVkQnl9Ojoke2Z1bmN0aW9uSW1wbGVtZW50YXRpb25OYW1lfSI7Ci0gICAgfSBlbHNp ZiAoJGZ1bmN0aW9uLT5pc1N0YXRpYykgeworICAgIH0gZWxzaWYgKE1ha2VzU3RhdGljQ2FsbCgk ZnVuY3Rpb24pKSB7CiAgICAgICAgICRmdW5jdGlvbk5hbWUgPSAiJHtpbnRlcmZhY2VOYW1lfTo6 JHtmdW5jdGlvbkltcGxlbWVudGF0aW9uTmFtZX0iOwogICAgIH0gZWxzaWYgKCRzdmdQcm9wZXJ0 eU9yTGlzdFByb3BlcnR5VHlwZSBhbmQgISRzdmdMaXN0UHJvcGVydHlUeXBlKSB7CiAgICAgICAg ICRmdW5jdGlvbk5hbWUgPSAicG9kSW1wbC4ke2Z1bmN0aW9uSW1wbGVtZW50YXRpb25OYW1lfSI7 CkBAIC0zMDU0LDcgKzMwNTQsNyBAQCBzdWIgR2VuZXJhdGVJbXBsZW1lbnRhdGlvbkZ1bmN0aW9u Q2FsbCgpCiAKICAgICAgICAgaWYgKCRzdmdQcm9wZXJ0eVR5cGUgYW5kICEkZnVuY3Rpb24tPmlz U3RhdGljKSB7CiAgICAgICAgICAgICBpZiAoQHskZnVuY3Rpb24tPnJhaXNlc0V4Y2VwdGlvbnN9 KSB7Ci0gICAgICAgICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQsICRpbmRlbnQgLiAiaWYgKCFl YylcbiIpOyAKKyAgICAgICAgICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgJGluZGVudCAuICJp ZiAoIWVjKVxuIik7CiAgICAgICAgICAgICAgICAgcHVzaChAaW1wbENvbnRlbnQsICRpbmRlbnQg LiAiICAgIGltcGwtPmNvbW1pdENoYW5nZSgpO1xuIik7CiAgICAgICAgICAgICB9IGVsc2Ugewog ICAgICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAkaW5kZW50IC4gImltcGwtPmNvbW1p dENoYW5nZSgpO1xuIik7CkBAIC0zMTA3LDcgKzMxMDcsNyBAQCBteSAlbmF0aXZlVHlwZSA9ICgK ICAgICAibG9uZyBsb25nIiA9PiAibG9uZyBsb25nIiwKICAgICAidW5zaWduZWQgbG9uZyBsb25n IiA9PiAidW5zaWduZWQgbG9uZyBsb25nIiwKICAgICAiTWVkaWFRdWVyeUxpc3RMaXN0ZW5lciIg PT4gIlJlZlB0cjxNZWRpYVF1ZXJ5TGlzdExpc3RlbmVyPiIsCi0gICAgIkRPTVRpbWVTdGFtcCIg PT4gIkRPTVRpbWVTdGFtcCIsICAgIAorICAgICJET01UaW1lU3RhbXAiID0+ICJET01UaW1lU3Rh bXAiLAogKTsKIAogc3ViIEdldE5hdGl2ZVR5cGUKQEAgLTMxNjAsNyArMzE2MCw3IEBAIHN1YiBH ZXRTVkdQcm9wZXJ0eVR5cGVzCiAgICAgbXkgJHN2Z05hdGl2ZVR5cGU7CiAKICAgICByZXR1cm4g KCRzdmdQcm9wZXJ0eVR5cGUsICRzdmdMaXN0UHJvcGVydHlUeXBlLCAkc3ZnTmF0aXZlVHlwZSkg aWYgbm90ICRpbXBsVHlwZSA9fiAvU1ZHLzsKLSAgICAKKwogICAgICRzdmdOYXRpdmVUeXBlID0g JGNvZGVHZW5lcmF0b3ItPkdldFNWR1R5cGVOZWVkaW5nVGVhck9mZigkaW1wbFR5cGUpOwogICAg IHJldHVybiAoJHN2Z1Byb3BlcnR5VHlwZSwgJHN2Z0xpc3RQcm9wZXJ0eVR5cGUsICRzdmdOYXRp dmVUeXBlKSBpZiBub3QgJHN2Z05hdGl2ZVR5cGU7CiAKQEAgLTM1MzAsNyArMzUzMCw3IEBAIHN1 YiBHZW5lcmF0ZUhhc2hUYWJsZQogICAgICAgICAgICAgbXkgJGNvbmRpdGlvbmFsU3RyaW5nID0g JGNvZGVHZW5lcmF0b3ItPkdlbmVyYXRlQ29uZGl0aW9uYWxTdHJpbmdGcm9tQXR0cmlidXRlVmFs dWUoJGNvbmRpdGlvbmFsKTsKICAgICAgICAgICAgIHB1c2goQGltcGxDb250ZW50LCAiI2lmICR7 Y29uZGl0aW9uYWxTdHJpbmd9XG4iKTsKICAgICAgICAgfQotICAgICAgICAKKwogICAgICAgICBp ZiAoIkAkc3BlY2lhbHNbJGldIiA9fiBtL0Z1bmN0aW9uLykgewogICAgICAgICAgICAgJHRhcmdl dFR5cGUgPSAic3RhdGljX2Nhc3Q8TmF0aXZlRnVuY3Rpb24+IjsKICAgICAgICAgfSBlbHNlIHsK QEAgLTQwOTAsNiArNDA5MCwxMiBAQCBzdWIgSGFzQ3VzdG9tTWV0aG9kCiAgICAgcmV0dXJuICRh dHRyRXh0LT57IkN1c3RvbSJ9IHx8ICRhdHRyRXh0LT57IkpTQ3VzdG9tIn07CiB9CiAKK3N1YiBN YWtlc1N0YXRpY0NhbGwKK3sKKyAgICBteSAkZnVuY3Rpb24gPSBzaGlmdDsKKyAgICByZXR1cm4g JGZ1bmN0aW9uLT5pc1N0YXRpYyB8fCAkZnVuY3Rpb24tPnNpZ25hdHVyZS0+ZXh0ZW5kZWRBdHRy aWJ1dGVzLT57IkxlbmllbnRUaGlzIn07Cit9CisKIHN1YiBJc0NvbnN0cnVjdGFibGUKIHsKICAg ICBteSAkaW50ZXJmYWNlID0gc2hpZnQ7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9z Y3JpcHRzL0lETEF0dHJpYnV0ZXMudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL3NjcmlwdHMvSURMQXR0cmlidXRlcy50eHQJKHJldmlzaW9uIDE0ODE4MSkKKysrIFNv dXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvSURMQXR0cmlidXRlcy50eHQJKHdvcmtpbmcg Y29weSkKQEAgLTg3LDYgKzg3LDcgQEAgSlNJbmxpbmVHZXRPd25Qcm9wZXJ0eVNsb3QKIEpTTGVn YWN5UGFyZW50PSoKIEpTTm9TdGF0aWNUYWJsZXMKIEpTV2luZG93RXZlbnRMaXN0ZW5lcgorTGVu aWVudFRoaXMKIE1hc3F1ZXJhZGVzQXNVbmRlZmluZWQKIE5hbWVkQ29uc3RydWN0b3I9KgogTmFt ZWRHZXR0ZXIKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9UZXN0 T2JqLmlkbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rl c3QvVGVzdE9iai5pZGwJKHJldmlzaW9uIDE0ODE4MSkKKysrIFNvdXJjZS9XZWJDb3JlL2JpbmRp bmdzL3NjcmlwdHMvdGVzdC9UZXN0T2JqLmlkbAkod29ya2luZyBjb3B5KQpAQCAtMTAwLDExICsx MDAsMTEgQEAgZW51bSBUZXN0RW51bVR5cGUgeyAiIiwgIkVudW1WYWx1ZTEiLCAiRQogICAgIFtD dXN0b21dIHZvaWQgY3VzdG9tTWV0aG9kKCk7CiAgICAgW0N1c3RvbV0gdm9pZCBjdXN0b21NZXRo b2RXaXRoQXJncyhpbiBsb25nIGxvbmdBcmcsIGluIERPTVN0cmluZyBzdHJBcmcsIGluIFRlc3RP Ymogb2JqQXJnKTsKIAotICAgIHZvaWQgYWRkRXZlbnRMaXN0ZW5lcihpbiBET01TdHJpbmcgdHlw ZSwgCi0gICAgICAgICAgICAgICAgICAgICAgICAgIGluIEV2ZW50TGlzdGVuZXIgbGlzdGVuZXIs IAorICAgIHZvaWQgYWRkRXZlbnRMaXN0ZW5lcihpbiBET01TdHJpbmcgdHlwZSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgaW4gRXZlbnRMaXN0ZW5lciBsaXN0ZW5lciwKICAgICAgICAgICAg ICAgICAgICAgICAgICAgaW4gW09wdGlvbmFsXSBib29sZWFuIHVzZUNhcHR1cmUpOwotICAgIHZv aWQgcmVtb3ZlRXZlbnRMaXN0ZW5lcihpbiBET01TdHJpbmcgdHlwZSwgCi0gICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGluIEV2ZW50TGlzdGVuZXIgbGlzdGVuZXIsIAorICAgIHZvaWQgcmVt b3ZlRXZlbnRMaXN0ZW5lcihpbiBET01TdHJpbmcgdHlwZSwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgaW4gRXZlbnRMaXN0ZW5lciBsaXN0ZW5lciwKICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgaW4gW09wdGlvbmFsXSBib29sZWFuIHVzZUNhcHR1cmUpOwogCiAgICAgLy8gJ0Nh bGxXaXRoJyBleHRlbmRlZCBhdHRyaWJ1dGUKQEAgLTE3MSw3ICsxNzEsNyBAQCBlbnVtIFRlc3RF bnVtVHlwZSB7ICIiLCAiRW51bVZhbHVlMSIsICJFCiAgICAgW0NhY2hlZEF0dHJpYnV0ZV0gcmVh ZG9ubHkgYXR0cmlidXRlIGFueSBjYWNoZWRBdHRyaWJ1dGUxOwogICAgIFtDYWNoZWRBdHRyaWJ1 dGVdIHJlYWRvbmx5IGF0dHJpYnV0ZSBhbnkgY2FjaGVkQXR0cmlidXRlMjsKICNlbmRpZgotICAg IAorCiAgICAgYXR0cmlidXRlIGFueSBhbnlBdHRyaWJ1dGU7CiAKICNpZiBkZWZpbmVkKFRFU1RJ TkdfSlMpCkBAIC0xOTQsNiArMTk0LDkgQEAgZW51bSBUZXN0RW51bVR5cGUgeyAiIiwgIkVudW1W YWx1ZTEiLCAiRQogICAgIHN0YXRpYyBsb25nIGNsYXNzTWV0aG9kV2l0aE9wdGlvbmFsKGluIFtP cHRpb25hbF0gbG9uZyBhcmcpOwogICAgIFtDdXN0b21dIHN0YXRpYyB2b2lkIGNsYXNzTWV0aG9k MihpbiBsb25nIGFyZyk7CiAKKyAgICAvLyBTdGF0aWMgbWV0aG9kcyBkZWZpbmVkIG9uIGluc3Rh bmNlcyAobGlrZSBjb25zb2xlLmxvZykuCisgICAgW0xlbmllbnRUaGlzXSB2b2lkIGxlbmllbnRU aGlzTWV0aG9kKGluIERPTVN0cmluZyBzdHIpOworCiAgICAgLy8gU3RhdGljIG1ldGhvZCB3aXRo IGNvbmRpdGlvbmFsIG9uIG92ZXJsb2FkZWQgbWV0aG9kcwogICAgIFtDb25kaXRpb25hbD1Db25k aXRpb24xXSBzdGF0aWMgdm9pZCBvdmVybG9hZGVkTWV0aG9kMShpbiBsb25nIGFyZyk7CiAgICAg W0NvbmRpdGlvbmFsPUNvbmRpdGlvbjFdIHN0YXRpYyB2b2lkIG92ZXJsb2FkZWRNZXRob2QxKGlu IFtTdHJpY3RUeXBlQ2hlY2tpbmddIERPTVN0cmluZyB0eXBlKTsKSW5kZXg6IFNvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9DUFAvV2ViRE9NVGVzdE9iai5jcHAKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0NQUC9XZWJET01UZXN0 T2JqLmNwcAkocmV2aXNpb24gMTQ4MTgxKQorKysgU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2Ny aXB0cy90ZXN0L0NQUC9XZWJET01UZXN0T2JqLmNwcAkod29ya2luZyBjb3B5KQpAQCAtOTQ4LDYg Kzk0OCwxNCBAQCBpbnQgV2ViRE9NVGVzdE9iajo6Y2xhc3NNZXRob2RXaXRoT3B0aW9uCiAgICAg cmV0dXJuIGltcGwoKS0+Y2xhc3NNZXRob2RXaXRoT3B0aW9uYWwoYXJnKTsKIH0KIAordm9pZCBX ZWJET01UZXN0T2JqOjpsZW5pZW50VGhpc01ldGhvZChjb25zdCBXZWJET01TdHJpbmcmIHN0cikK K3sKKyAgICBpZiAoIWltcGwoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaW1wbCgpLT5sZW5p ZW50VGhpc01ldGhvZChzdHIpOworfQorCiAKICNpZiBFTkFCTEUoQ29uZGl0aW9uMSkKIHZvaWQg V2ViRE9NVGVzdE9iajo6b3ZlcmxvYWRlZE1ldGhvZDEoaW50IGFyZykKSW5kZXg6IFNvdXJjZS9X ZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9DUFAvV2ViRE9NVGVzdE9iai5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9DUFAvV2ViRE9NVGVz dE9iai5oCShyZXZpc2lvbiAxNDgxODEpCisrKyBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3Jp cHRzL3Rlc3QvQ1BQL1dlYkRPTVRlc3RPYmouaAkod29ya2luZyBjb3B5KQpAQCAtMTg1LDYgKzE4 NSw3IEBAIHB1YmxpYzoKICNlbmRpZgogICAgIHZvaWQgY2xhc3NNZXRob2QoKTsKICAgICBpbnQg Y2xhc3NNZXRob2RXaXRoT3B0aW9uYWwoaW50IGFyZyk7CisgICAgdm9pZCBsZW5pZW50VGhpc01l dGhvZChjb25zdCBXZWJET01TdHJpbmcmIHN0cik7CiAjaWYgRU5BQkxFKENvbmRpdGlvbjEpCiAg ICAgdm9pZCBvdmVybG9hZGVkTWV0aG9kMShpbnQgYXJnKTsKICNlbmRpZgpJbmRleDogU291cmNl L1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0dPYmplY3QvV2ViS2l0RE9NVGVzdE9iai5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0dP YmplY3QvV2ViS2l0RE9NVGVzdE9iai5jcHAJKHJldmlzaW9uIDE0ODE4MSkKKysrIFNvdXJjZS9X ZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9HT2JqZWN0L1dlYktpdERPTVRlc3RPYmouY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC0xMzUyLDYgKzEzNTIsMTcgQEAgd2Via2l0X2RvbV90ZXN0X29i al9jbGFzc19tZXRob2Rfd2l0aF9vcAogfQogCiB2b2lkCit3ZWJraXRfZG9tX3Rlc3Rfb2JqX2xl bmllbnRfdGhpc19tZXRob2QoV2ViS2l0RE9NVGVzdE9iaiogc2VsZiwgY29uc3QgZ2NoYXIqIHN0 cikKK3sKKyAgICBXZWJDb3JlOjpKU01haW5UaHJlYWROdWxsU3RhdGUgc3RhdGU7CisgICAgZ19y ZXR1cm5faWZfZmFpbChXRUJLSVRfRE9NX0lTX1RFU1RfT0JKKHNlbGYpKTsKKyAgICBnX3JldHVy bl9pZl9mYWlsKHN0cik7CisgICAgV2ViQ29yZTo6VGVzdE9iaiogaXRlbSA9IFdlYktpdDo6Y29y ZShzZWxmKTsKKyAgICBXVEY6OlN0cmluZyBjb252ZXJ0ZWRTdHIgPSBXVEY6OlN0cmluZzo6ZnJv bVVURjgoc3RyKTsKKyAgICBpdGVtLT5sZW5pZW50VGhpc01ldGhvZChjb252ZXJ0ZWRTdHIpOwor fQorCit2b2lkCiB3ZWJraXRfZG9tX3Rlc3Rfb2JqX292ZXJsb2FkZWRfbWV0aG9kMShXZWJLaXRE T01UZXN0T2JqKiBzZWxmLCBnbG9uZyBhcmcpCiB7CiAjaWYgRU5BQkxFKENvbmRpdGlvbjEpCklu ZGV4OiBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvR09iamVjdC9XZWJLaXRE T01UZXN0T2JqLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0 cy90ZXN0L0dPYmplY3QvV2ViS2l0RE9NVGVzdE9iai5oCShyZXZpc2lvbiAxNDgxODEpCisrKyBT b3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvR09iamVjdC9XZWJLaXRET01UZXN0 T2JqLmgJKHdvcmtpbmcgY29weSkKQEAgLTM4MCw2ICszODAsMTcgQEAgV0VCS0lUX0FQSSBnbG9u Zwogd2Via2l0X2RvbV90ZXN0X29ial9jbGFzc19tZXRob2Rfd2l0aF9vcHRpb25hbChXZWJLaXRE T01UZXN0T2JqKiBzZWxmLCBnbG9uZyBhcmcpOwogCiAvKioKKyAqIHdlYmtpdF9kb21fdGVzdF9v YmpfbGVuaWVudF90aGlzX21ldGhvZDoKKyAqIEBzZWxmOiBBICNXZWJLaXRET01UZXN0T2JqCisg KiBAc3RyOiBBICNnY2hhcgorICoKKyAqIFJldHVybnM6CisgKgorKiovCitXRUJLSVRfQVBJIHZv aWQKK3dlYmtpdF9kb21fdGVzdF9vYmpfbGVuaWVudF90aGlzX21ldGhvZChXZWJLaXRET01UZXN0 T2JqKiBzZWxmLCBjb25zdCBnY2hhciogc3RyKTsKKworLyoqCiAgKiB3ZWJraXRfZG9tX3Rlc3Rf b2JqX292ZXJsb2FkZWRfbWV0aG9kMToKICAqIEBzZWxmOiBBICNXZWJLaXRET01UZXN0T2JqCiAg KiBAYXJnOiBBICNnbG9uZwpJbmRleDogU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90 ZXN0L0pTL0pTVGVzdE9iai5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvYmluZGlu Z3Mvc2NyaXB0cy90ZXN0L0pTL0pTVGVzdE9iai5jcHAJKHJldmlzaW9uIDE0ODE4MSkKKysrIFNv dXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9KUy9KU1Rlc3RPYmouY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC0zMTQsNiArMzE0LDcgQEAgc3RhdGljIGNvbnN0IEhhc2hUYWJsZVZhbHVl IEpTVGVzdE9ialBybwogICAgIHsgImNvbmRpdGlvbmFsTWV0aG9kMyIsIERvbnREZWxldGUgfCBK U0M6OkZ1bmN0aW9uLCAoaW50cHRyX3Qpc3RhdGljX2Nhc3Q8TmF0aXZlRnVuY3Rpb24+KGpzVGVz dE9ialByb3RvdHlwZUZ1bmN0aW9uQ29uZGl0aW9uYWxNZXRob2QzKSwgKGludHB0cl90KTAsIE5v SW50cmluc2ljIH0sCiAjZW5kaWYKICAgICB7ICJvdmVybG9hZGVkTWV0aG9kIiwgRG9udERlbGV0 ZSB8IEpTQzo6RnVuY3Rpb24sIChpbnRwdHJfdClzdGF0aWNfY2FzdDxOYXRpdmVGdW5jdGlvbj4o anNUZXN0T2JqUHJvdG90eXBlRnVuY3Rpb25PdmVybG9hZGVkTWV0aG9kKSwgKGludHB0cl90KTIs IE5vSW50cmluc2ljIH0sCisgICAgeyAibGVuaWVudFRoaXNNZXRob2QiLCBEb250RGVsZXRlIHwg SlNDOjpGdW5jdGlvbiwgKGludHB0cl90KXN0YXRpY19jYXN0PE5hdGl2ZUZ1bmN0aW9uPihqc1Rl c3RPYmpQcm90b3R5cGVGdW5jdGlvbkxlbmllbnRUaGlzTWV0aG9kKSwgKGludHB0cl90KTEsIE5v SW50cmluc2ljIH0sCiAgICAgeyAiY2xhc3NNZXRob2RXaXRoQ2xhbXAiLCBEb250RGVsZXRlIHwg SlNDOjpGdW5jdGlvbiwgKGludHB0cl90KXN0YXRpY19jYXN0PE5hdGl2ZUZ1bmN0aW9uPihqc1Rl c3RPYmpQcm90b3R5cGVGdW5jdGlvbkNsYXNzTWV0aG9kV2l0aENsYW1wKSwgKGludHB0cl90KTIs IE5vSW50cmluc2ljIH0sCiAgICAgeyAibWV0aG9kV2l0aFVuc2lnbmVkTG9uZ1NlcXVlbmNlIiwg RG9udERlbGV0ZSB8IEpTQzo6RnVuY3Rpb24sIChpbnRwdHJfdClzdGF0aWNfY2FzdDxOYXRpdmVG dW5jdGlvbj4oanNUZXN0T2JqUHJvdG90eXBlRnVuY3Rpb25NZXRob2RXaXRoVW5zaWduZWRMb25n U2VxdWVuY2UpLCAoaW50cHRyX3QpMSwgTm9JbnRyaW5zaWMgfSwKICAgICB7ICJzdHJpbmdBcnJh eUZ1bmN0aW9uIiwgRG9udERlbGV0ZSB8IEpTQzo6RnVuY3Rpb24sIChpbnRwdHJfdClzdGF0aWNf Y2FzdDxOYXRpdmVGdW5jdGlvbj4oanNUZXN0T2JqUHJvdG90eXBlRnVuY3Rpb25TdHJpbmdBcnJh eUZ1bmN0aW9uKSwgKGludHB0cl90KTEsIE5vSW50cmluc2ljIH0sCkBAIC0yNjI1LDYgKzI2MjYs MTcgQEAgRW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBqc1Rlc3RPYmpDbwogICAgIHJldHVy biBKU1ZhbHVlOjplbmNvZGUoSlNUZXN0T2JqOjpjbGFzc01ldGhvZDIoZXhlYykpOwogfQogCitF bmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGpzVGVzdE9ialByb3RvdHlwZUZ1bmN0aW9uTGVu aWVudFRoaXNNZXRob2QoRXhlY1N0YXRlKiBleGVjKQoreworICAgIGlmIChleGVjLT5hcmd1bWVu dENvdW50KCkgPCAxKQorICAgICAgICByZXR1cm4gdGhyb3dWTUVycm9yKGV4ZWMsIGNyZWF0ZU5v dEVub3VnaEFyZ3VtZW50c0Vycm9yKGV4ZWMpKTsKKyAgICBjb25zdCBTdHJpbmcmIHN0cihleGVj LT5hcmd1bWVudCgwKS5pc0VtcHR5KCkgPyBTdHJpbmcoKSA6IGV4ZWMtPmFyZ3VtZW50KDApLnRv U3RyaW5nKGV4ZWMpLT52YWx1ZShleGVjKSk7CisgICAgaWYgKGV4ZWMtPmhhZEV4Y2VwdGlvbigp KQorICAgICAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKGpzVW5kZWZpbmVkKCkpOworICAgIFRl c3RPYmo6OmxlbmllbnRUaGlzTWV0aG9kKHN0cik7CisgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29k ZShqc1VuZGVmaW5lZCgpKTsKK30KKwogI2lmIEVOQUJMRShDb25kaXRpb24xKQogc3RhdGljIEVu Y29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwganNUZXN0T2JqQ29uc3RydWN0b3JGdW5jdGlvbk92 ZXJsb2FkZWRNZXRob2QxMShFeGVjU3RhdGUqIGV4ZWMpCiB7CkluZGV4OiBTb3VyY2UvV2ViQ29y ZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvSlMvSlNUZXN0T2JqLmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0pTL0pTVGVzdE9iai5oCShyZXZpc2lv biAxNDgxODEpCisrKyBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvSlMvSlNU ZXN0T2JqLmgJKHdvcmtpbmcgY29weSkKQEAgLTIwMyw2ICsyMDMsNyBAQCBKU0M6OkVuY29kZWRK U1ZhbHVlIEpTQ19IT1NUX0NBTEwganNUZXN0CiBKU0M6OkVuY29kZWRKU1ZhbHVlIEpTQ19IT1NU X0NBTEwganNUZXN0T2JqQ29uc3RydWN0b3JGdW5jdGlvbkNsYXNzTWV0aG9kKEpTQzo6RXhlY1N0 YXRlKik7CiBKU0M6OkVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwganNUZXN0T2JqQ29uc3Ry dWN0b3JGdW5jdGlvbkNsYXNzTWV0aG9kV2l0aE9wdGlvbmFsKEpTQzo6RXhlY1N0YXRlKik7CiBK U0M6OkVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwganNUZXN0T2JqQ29uc3RydWN0b3JGdW5j dGlvbkNsYXNzTWV0aG9kMihKU0M6OkV4ZWNTdGF0ZSopOworSlNDOjpFbmNvZGVkSlNWYWx1ZSBK U0NfSE9TVF9DQUxMIGpzVGVzdE9ialByb3RvdHlwZUZ1bmN0aW9uTGVuaWVudFRoaXNNZXRob2Qo SlNDOjpFeGVjU3RhdGUqKTsKICNpZiBFTkFCTEUoQ29uZGl0aW9uMSkKIEpTQzo6RW5jb2RlZEpT VmFsdWUgSlNDX0hPU1RfQ0FMTCBqc1Rlc3RPYmpDb25zdHJ1Y3RvckZ1bmN0aW9uT3ZlcmxvYWRl ZE1ldGhvZDEoSlNDOjpFeGVjU3RhdGUqKTsKICNlbmRpZgpJbmRleDogU291cmNlL1dlYkNvcmUv YmluZGluZ3Mvc2NyaXB0cy90ZXN0L09iakMvRE9NVGVzdE9iai5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9PYmpDL0RPTVRlc3RPYmouaAkocmV2 aXNpb24gMTQ4MTgxKQorKysgU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L09i akMvRE9NVGVzdE9iai5oCSh3b3JraW5nIGNvcHkpCkBAIC0xNjUsNiArMTY1LDcgQEAgZW51bSB7 CiAtICh2b2lkKWNsYXNzTWV0aG9kOwogLSAoaW50KWNsYXNzTWV0aG9kV2l0aE9wdGlvbmFsOihp bnQpYXJnOwogLSAodm9pZCljbGFzc01ldGhvZDI6KGludClhcmc7CistICh2b2lkKWxlbmllbnRU aGlzTWV0aG9kOihOU1N0cmluZyAqKXN0cjsKICNpZiBFTkFCTEUoQ29uZGl0aW9uMSkKIC0gKHZv aWQpb3ZlcmxvYWRlZE1ldGhvZDE6KGludClhcmc7CiAjZW5kaWYKSW5kZXg6IFNvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9PYmpDL0RPTVRlc3RPYmoubW0KPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L09iakMvRE9NVGVzdE9iai5t bQkocmV2aXNpb24gMTQ4MTgxKQorKysgU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90 ZXN0L09iakMvRE9NVGVzdE9iai5tbQkod29ya2luZyBjb3B5KQpAQCAtMTAxMiw2ICsxMDEyLDEy IEBAIC0gKHZvaWQpY2xhc3NNZXRob2QyOihpbnQpYXJnCiAgICAgSU1QTC0+Y2xhc3NNZXRob2Qy KGFyZyk7CiB9CiAKKy0gKHZvaWQpbGVuaWVudFRoaXNNZXRob2Q6KE5TU3RyaW5nICopc3RyCit7 CisgICAgV2ViQ29yZTo6SlNNYWluVGhyZWFkTnVsbFN0YXRlIHN0YXRlOworICAgIElNUEwtPmxl bmllbnRUaGlzTWV0aG9kKHN0cik7Cit9CisKIAogI2lmIEVOQUJMRShDb25kaXRpb24xKQogLSAo dm9pZClvdmVybG9hZGVkTWV0aG9kMTooaW50KWFyZwpJbmRleDogU291cmNlL1dlYkNvcmUvcGFn ZS9Db25zb2xlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wYWdlL0NvbnNvbGUu Y3BwCShyZXZpc2lvbiAxNDgxODEpCisrKyBTb3VyY2UvV2ViQ29yZS9wYWdlL0NvbnNvbGUuY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC01OCw2ICs1OCwxNyBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAKK3N0YXRpYyBpbmxpbmUgUGFnZSogcGFnZUZyb21TY3JpcHRTdGF0ZShTY3JpcHRTdGF0ZSog c3RhdGUpCit7CisgICAgRE9NV2luZG93KiB3aW5kb3cgPSBkb21XaW5kb3dGcm9tU2NyaXB0U3Rh dGUoc3RhdGUpOworICAgIGlmICghd2luZG93KQorICAgICAgICByZXR1cm4gMDsKKyAgICBEb2N1 bWVudCogZG9jdW1lbnQgPSB3aW5kb3ctPmRvY3VtZW50KCk7CisgICAgaWYgKCFkb2N1bWVudCkK KyAgICAgICAgcmV0dXJuIDA7CisgICAgcmV0dXJuIGRvY3VtZW50LT5wYWdlKCk7Cit9CisKIENv bnNvbGU6OkNvbnNvbGUoRnJhbWUqIGZyYW1lKQogICAgIDogRE9NV2luZG93UHJvcGVydHkoZnJh bWUpCiB7CkBAIC0xMTUsMTIgKzEyNiwxMiBAQCBzdGF0aWMgdm9pZCBpbnRlcm5hbEFkZE1lc3Nh Z2UoUGFnZSogcGFnCiAKIHZvaWQgQ29uc29sZTo6ZGVidWcoU2NyaXB0U3RhdGUqIHN0YXRlLCBQ YXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4gYXJndW1lbnRzKQogewotICAgIGludGVybmFsQWRk TWVzc2FnZShwYWdlKCksIExvZ01lc3NhZ2VUeXBlLCBEZWJ1Z01lc3NhZ2VMZXZlbCwgc3RhdGUs IGFyZ3VtZW50cyk7CisgICAgaW50ZXJuYWxBZGRNZXNzYWdlKHBhZ2VGcm9tU2NyaXB0U3RhdGUo c3RhdGUpLCBMb2dNZXNzYWdlVHlwZSwgRGVidWdNZXNzYWdlTGV2ZWwsIHN0YXRlLCBhcmd1bWVu dHMpOwogfQogCiB2b2lkIENvbnNvbGU6OmVycm9yKFNjcmlwdFN0YXRlKiBzdGF0ZSwgUGFzc1Jl ZlB0cjxTY3JpcHRBcmd1bWVudHM+IGFyZ3VtZW50cykKIHsKLSAgICBpbnRlcm5hbEFkZE1lc3Nh Z2UocGFnZSgpLCBMb2dNZXNzYWdlVHlwZSwgRXJyb3JNZXNzYWdlTGV2ZWwsIHN0YXRlLCBhcmd1 bWVudHMpOworICAgIGludGVybmFsQWRkTWVzc2FnZShwYWdlRnJvbVNjcmlwdFN0YXRlKHN0YXRl KSwgTG9nTWVzc2FnZVR5cGUsIEVycm9yTWVzc2FnZUxldmVsLCBzdGF0ZSwgYXJndW1lbnRzKTsK IH0KIAogdm9pZCBDb25zb2xlOjppbmZvKFNjcmlwdFN0YXRlKiBzdGF0ZSwgUGFzc1JlZlB0cjxT Y3JpcHRBcmd1bWVudHM+IGFyZ3VtZW50cykKQEAgLTEzMCwzNyArMTQxLDM3IEBAIHZvaWQgQ29u c29sZTo6aW5mbyhTY3JpcHRTdGF0ZSogc3RhdGUsIFAKIAogdm9pZCBDb25zb2xlOjpsb2coU2Ny aXB0U3RhdGUqIHN0YXRlLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4gYXJndW1lbnRzKQog ewotICAgIGludGVybmFsQWRkTWVzc2FnZShwYWdlKCksIExvZ01lc3NhZ2VUeXBlLCBMb2dNZXNz YWdlTGV2ZWwsIHN0YXRlLCBhcmd1bWVudHMpOworICAgIGludGVybmFsQWRkTWVzc2FnZShwYWdl RnJvbVNjcmlwdFN0YXRlKHN0YXRlKSwgTG9nTWVzc2FnZVR5cGUsIExvZ01lc3NhZ2VMZXZlbCwg c3RhdGUsIGFyZ3VtZW50cyk7CiB9CiAKIHZvaWQgQ29uc29sZTo6d2FybihTY3JpcHRTdGF0ZSog c3RhdGUsIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPiBhcmd1bWVudHMpCiB7Ci0gICAgaW50 ZXJuYWxBZGRNZXNzYWdlKHBhZ2UoKSwgTG9nTWVzc2FnZVR5cGUsIFdhcm5pbmdNZXNzYWdlTGV2 ZWwsIHN0YXRlLCBhcmd1bWVudHMpOworICAgIGludGVybmFsQWRkTWVzc2FnZShwYWdlRnJvbVNj cmlwdFN0YXRlKHN0YXRlKSwgTG9nTWVzc2FnZVR5cGUsIFdhcm5pbmdNZXNzYWdlTGV2ZWwsIHN0 YXRlLCBhcmd1bWVudHMpOwogfQogCiB2b2lkIENvbnNvbGU6OmRpcihTY3JpcHRTdGF0ZSogc3Rh dGUsIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPiBhcmd1bWVudHMpCiB7Ci0gICAgaW50ZXJu YWxBZGRNZXNzYWdlKHBhZ2UoKSwgRGlyTWVzc2FnZVR5cGUsIExvZ01lc3NhZ2VMZXZlbCwgc3Rh dGUsIGFyZ3VtZW50cyk7CisgICAgaW50ZXJuYWxBZGRNZXNzYWdlKHBhZ2VGcm9tU2NyaXB0U3Rh dGUoc3RhdGUpLCBEaXJNZXNzYWdlVHlwZSwgTG9nTWVzc2FnZUxldmVsLCBzdGF0ZSwgYXJndW1l bnRzKTsKIH0KIAogdm9pZCBDb25zb2xlOjpkaXJ4bWwoU2NyaXB0U3RhdGUqIHN0YXRlLCBQYXNz UmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4gYXJndW1lbnRzKQogewotICAgIGludGVybmFsQWRkTWVz c2FnZShwYWdlKCksIERpclhNTE1lc3NhZ2VUeXBlLCBMb2dNZXNzYWdlTGV2ZWwsIHN0YXRlLCBh cmd1bWVudHMpOworICAgIGludGVybmFsQWRkTWVzc2FnZShwYWdlRnJvbVNjcmlwdFN0YXRlKHN0 YXRlKSwgRGlyWE1MTWVzc2FnZVR5cGUsIExvZ01lc3NhZ2VMZXZlbCwgc3RhdGUsIGFyZ3VtZW50 cyk7CiB9CiAKIHZvaWQgQ29uc29sZTo6dGFibGUoU2NyaXB0U3RhdGUqIHN0YXRlLCBQYXNzUmVm UHRyPFNjcmlwdEFyZ3VtZW50cz4gYXJndW1lbnRzKQogewotICAgIGludGVybmFsQWRkTWVzc2Fn ZShwYWdlKCksIFRhYmxlTWVzc2FnZVR5cGUsIExvZ01lc3NhZ2VMZXZlbCwgc3RhdGUsIGFyZ3Vt ZW50cyk7CisgICAgaW50ZXJuYWxBZGRNZXNzYWdlKHBhZ2VGcm9tU2NyaXB0U3RhdGUoc3RhdGUp LCBUYWJsZU1lc3NhZ2VUeXBlLCBMb2dNZXNzYWdlTGV2ZWwsIHN0YXRlLCBhcmd1bWVudHMpOwog fQogCiB2b2lkIENvbnNvbGU6OmNsZWFyKFNjcmlwdFN0YXRlKiBzdGF0ZSwgUGFzc1JlZlB0cjxT Y3JpcHRBcmd1bWVudHM+IGFyZ3VtZW50cykKIHsKLSAgICBpbnRlcm5hbEFkZE1lc3NhZ2UocGFn ZSgpLCBDbGVhck1lc3NhZ2VUeXBlLCBMb2dNZXNzYWdlTGV2ZWwsIHN0YXRlLCBhcmd1bWVudHMs IHRydWUpOworICAgIGludGVybmFsQWRkTWVzc2FnZShwYWdlRnJvbVNjcmlwdFN0YXRlKHN0YXRl KSwgQ2xlYXJNZXNzYWdlVHlwZSwgTG9nTWVzc2FnZUxldmVsLCBzdGF0ZSwgYXJndW1lbnRzLCB0 cnVlKTsKIH0KIAogdm9pZCBDb25zb2xlOjp0cmFjZShTY3JpcHRTdGF0ZSogc3RhdGUsIFBhc3NS ZWZQdHI8U2NyaXB0QXJndW1lbnRzPiBhcmd1bWVudHMpCiB7Ci0gICAgaW50ZXJuYWxBZGRNZXNz YWdlKHBhZ2UoKSwgVHJhY2VNZXNzYWdlVHlwZSwgTG9nTWVzc2FnZUxldmVsLCBzdGF0ZSwgYXJn dW1lbnRzLCB0cnVlLCB0cnVlKTsKKyAgICBpbnRlcm5hbEFkZE1lc3NhZ2UocGFnZUZyb21TY3Jp cHRTdGF0ZShzdGF0ZSksIFRyYWNlTWVzc2FnZVR5cGUsIExvZ01lc3NhZ2VMZXZlbCwgc3RhdGUs IGFyZ3VtZW50cywgdHJ1ZSwgdHJ1ZSk7CiB9CiAKIHZvaWQgQ29uc29sZTo6YXNzZXJ0Q29uZGl0 aW9uKFNjcmlwdFN0YXRlKiBzdGF0ZSwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+IGFyZ3Vt ZW50cywgYm9vbCBjb25kaXRpb24pCkBAIC0xNzMsNyArMTg0LDcgQEAgdm9pZCBDb25zb2xlOjph c3NlcnRDb25kaXRpb24oU2NyaXB0U3RhdAogCiB2b2lkIENvbnNvbGU6OmNvdW50KFNjcmlwdFN0 YXRlKiBzdGF0ZSwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+IGFyZ3VtZW50cykKIHsKLSAg ICBJbnNwZWN0b3JJbnN0cnVtZW50YXRpb246OmNvbnNvbGVDb3VudChwYWdlKCksIHN0YXRlLCBh cmd1bWVudHMpOworICAgIEluc3BlY3Rvckluc3RydW1lbnRhdGlvbjo6Y29uc29sZUNvdW50KHBh Z2VGcm9tU2NyaXB0U3RhdGUoc3RhdGUpLCBzdGF0ZSwgYXJndW1lbnRzKTsKIH0KIAogdm9pZCBD b25zb2xlOjptYXJrVGltZWxpbmUoUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+IGFyZ3VtZW50 cykKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BhZ2UvQ29uc29sZS5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJDb3JlL3BhZ2UvQ29uc29sZS5oCShyZXZpc2lvbiAxNDgxODEpCisrKyBTb3VyY2Uv V2ViQ29yZS9wYWdlL0NvbnNvbGUuaAkod29ya2luZyBjb3B5KQpAQCAtNTMsMTggKzUzLDE4IEBA IHB1YmxpYzoKICAgICBzdGF0aWMgUGFzc1JlZlB0cjxDb25zb2xlPiBjcmVhdGUoRnJhbWUqIGZy YW1lKSB7IHJldHVybiBhZG9wdFJlZihuZXcgQ29uc29sZShmcmFtZSkpOyB9CiAgICAgdmlydHVh bCB+Q29uc29sZSgpOwogCi0gICAgdm9pZCBkZWJ1ZyhTY3JpcHRTdGF0ZSosIFBhc3NSZWZQdHI8 U2NyaXB0QXJndW1lbnRzPik7Ci0gICAgdm9pZCBlcnJvcihTY3JpcHRTdGF0ZSosIFBhc3NSZWZQ dHI8U2NyaXB0QXJndW1lbnRzPik7Ci0gICAgdm9pZCBpbmZvKFNjcmlwdFN0YXRlKiwgUGFzc1Jl ZlB0cjxTY3JpcHRBcmd1bWVudHM+KTsKLSAgICB2b2lkIGxvZyhTY3JpcHRTdGF0ZSosIFBhc3NS ZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7Ci0gICAgdm9pZCBjbGVhcihTY3JpcHRTdGF0ZSosIFBh c3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7Ci0gICAgdm9pZCB3YXJuKFNjcmlwdFN0YXRlKiwg UGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+KTsKLSAgICB2b2lkIGRpcihTY3JpcHRTdGF0ZSos IFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7Ci0gICAgdm9pZCBkaXJ4bWwoU2NyaXB0U3Rh dGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4pOwotICAgIHZvaWQgdGFibGUoU2NyaXB0 U3RhdGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4pOwotICAgIHZvaWQgdHJhY2UoU2Ny aXB0U3RhdGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4pOworICAgIHN0YXRpYyB2b2lk IGRlYnVnKFNjcmlwdFN0YXRlKiwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+KTsKKyAgICBz dGF0aWMgdm9pZCBlcnJvcihTY3JpcHRTdGF0ZSosIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRz Pik7CisgICAgc3RhdGljIHZvaWQgaW5mbyhTY3JpcHRTdGF0ZSosIFBhc3NSZWZQdHI8U2NyaXB0 QXJndW1lbnRzPik7CisgICAgc3RhdGljIHZvaWQgbG9nKFNjcmlwdFN0YXRlKiwgUGFzc1JlZlB0 cjxTY3JpcHRBcmd1bWVudHM+KTsKKyAgICBzdGF0aWMgdm9pZCBjbGVhcihTY3JpcHRTdGF0ZSos IFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7CisgICAgc3RhdGljIHZvaWQgd2FybihTY3Jp cHRTdGF0ZSosIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1lbnRzPik7CisgICAgc3RhdGljIHZvaWQg ZGlyKFNjcmlwdFN0YXRlKiwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+KTsKKyAgICBzdGF0 aWMgdm9pZCBkaXJ4bWwoU2NyaXB0U3RhdGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4p OworICAgIHN0YXRpYyB2b2lkIHRhYmxlKFNjcmlwdFN0YXRlKiwgUGFzc1JlZlB0cjxTY3JpcHRB cmd1bWVudHM+KTsKKyAgICBzdGF0aWMgdm9pZCB0cmFjZShTY3JpcHRTdGF0ZSosIFBhc3NSZWZQ dHI8U2NyaXB0QXJndW1lbnRzPik7CiAgICAgdm9pZCBhc3NlcnRDb25kaXRpb24oU2NyaXB0U3Rh dGUqLCBQYXNzUmVmUHRyPFNjcmlwdEFyZ3VtZW50cz4sIGJvb2wgY29uZGl0aW9uKTsKLSAgICB2 b2lkIGNvdW50KFNjcmlwdFN0YXRlKiwgUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+KTsKKyAg ICBzdGF0aWMgdm9pZCBjb3VudChTY3JpcHRTdGF0ZSosIFBhc3NSZWZQdHI8U2NyaXB0QXJndW1l bnRzPik7CiAgICAgdm9pZCBtYXJrVGltZWxpbmUoUGFzc1JlZlB0cjxTY3JpcHRBcmd1bWVudHM+ KTsKICNpZiBFTkFCTEUoSkFWQVNDUklQVF9ERUJVR0dFUikKICAgICBjb25zdCBQcm9maWxlc0Fy cmF5JiBwcm9maWxlcygpIGNvbnN0IHsgcmV0dXJuIG1fcHJvZmlsZXM7IH0KSW5kZXg6IFNvdXJj ZS9XZWJDb3JlL3BhZ2UvQ29uc29sZS5pZGwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUv cGFnZS9Db25zb2xlLmlkbAkocmV2aXNpb24gMTQ4MTgxKQorKysgU291cmNlL1dlYkNvcmUvcGFn ZS9Db25zb2xlLmlkbAkod29ya2luZyBjb3B5KQpAQCAtMzEsMTUgKzMxLDE1IEBACiAgICAgT21p dENvbnN0cnVjdG9yCiBdIGludGVyZmFjZSBDb25zb2xlIHsKIAotICAgIFtDYWxsV2l0aD1TY3Jp cHRBcmd1bWVudHN8U2NyaXB0U3RhdGVdIHZvaWQgZGVidWcoKTsKLSAgICBbQ2FsbFdpdGg9U2Ny aXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlXSB2b2lkIGVycm9yKCk7Ci0gICAgW0NhbGxXaXRoPVNj cmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZV0gdm9pZCBpbmZvKCk7Ci0gICAgW0NhbGxXaXRoPVNj cmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZV0gdm9pZCBsb2coKTsKLSAgICBbQ2FsbFdpdGg9U2Ny aXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlXSB2b2lkIHdhcm4oKTsKLSAgICBbQ2FsbFdpdGg9U2Ny aXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlXSB2b2lkIGRpcigpOwotICAgIFtDYWxsV2l0aD1TY3Jp cHRBcmd1bWVudHN8U2NyaXB0U3RhdGVdIHZvaWQgZGlyeG1sKCk7Ci0gICAgW0NhbGxXaXRoPVNj cmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZV0gdm9pZCB0YWJsZSgpOwotICAgIFtDYWxsV2l0aD1T Y3JpcHRBcmd1bWVudHN8U2NyaXB0U3RhdGVdIHZvaWQgdHJhY2UoKTsKKyAgICBbQ2FsbFdpdGg9 U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlLCBMZW5pZW50VGhpc10gdm9pZCBkZWJ1ZygpOwor ICAgIFtDYWxsV2l0aD1TY3JpcHRBcmd1bWVudHN8U2NyaXB0U3RhdGUsIExlbmllbnRUaGlzXSB2 b2lkIGVycm9yKCk7CisgICAgW0NhbGxXaXRoPVNjcmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZSwg TGVuaWVudFRoaXNdIHZvaWQgaW5mbygpOworICAgIFtDYWxsV2l0aD1TY3JpcHRBcmd1bWVudHN8 U2NyaXB0U3RhdGUsIExlbmllbnRUaGlzXSB2b2lkIGxvZygpOworICAgIFtDYWxsV2l0aD1TY3Jp cHRBcmd1bWVudHN8U2NyaXB0U3RhdGUsIExlbmllbnRUaGlzXSB2b2lkIHdhcm4oKTsKKyAgICBb Q2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlLCBMZW5pZW50VGhpc10gdm9pZCBk aXIoKTsKKyAgICBbQ2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlLCBMZW5pZW50 VGhpc10gdm9pZCBkaXJ4bWwoKTsKKyAgICBbQ2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlw dFN0YXRlLCBMZW5pZW50VGhpc10gdm9pZCB0YWJsZSgpOworICAgIFtDYWxsV2l0aD1TY3JpcHRB cmd1bWVudHN8U2NyaXB0U3RhdGUsIExlbmllbnRUaGlzXSB2b2lkIHRyYWNlKCk7CiAgICAgW0Nh bGxXaXRoPVNjcmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZSwgSW1wbGVtZW50ZWRBcz1hc3NlcnRD b25kaXRpb25dIHZvaWQgYXNzZXJ0KGluIGJvb2xlYW4gY29uZGl0aW9uKTsKICAgICBbQ2FsbFdp dGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlXSB2b2lkIGNvdW50KCk7CiAgICAgW0NhbGxX aXRoPVNjcmlwdEFyZ3VtZW50c10gdm9pZCBtYXJrVGltZWxpbmUoKTsKQEAgLTU3LDcgKzU3LDcg QEAKICAgICBbQ2FsbFdpdGg9U2NyaXB0QXJndW1lbnRzfFNjcmlwdFN0YXRlXSB2b2lkIGdyb3Vw KCk7CiAgICAgW0NhbGxXaXRoPVNjcmlwdEFyZ3VtZW50c3xTY3JpcHRTdGF0ZV0gdm9pZCBncm91 cENvbGxhcHNlZCgpOwogICAgIHZvaWQgZ3JvdXBFbmQoKTsKLSAgICBbQ2FsbFdpdGg9U2NyaXB0 QXJndW1lbnRzfFNjcmlwdFN0YXRlXSB2b2lkIGNsZWFyKCk7CisgICAgW0NhbGxXaXRoPVNjcmlw dEFyZ3VtZW50c3xTY3JpcHRTdGF0ZSwgTGVuaWVudFRoaXNdIHZvaWQgY2xlYXIoKTsKIAogICAg IHJlYWRvbmx5IGF0dHJpYnV0ZSBNZW1vcnlJbmZvIG1lbW9yeTsKIH07CkluZGV4OiBMYXlvdXRU ZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZp c2lvbiAxNDgxODEpCisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAg LTEsMyArMSwxMyBAQAorMjAxMy0wNC0xMCAgVmljdG9yIENvc3RhbiAgPGNvc3RhbkBnbWFpbC5j b20+CisKKyAgICAgICAgQ2FsbGluZyBjb25zb2xlLntsb2csIGluZm8sIGVycm9yLCAuLi59IHNo b3VsZCBub3QgcmVxdWlyZSB0aGlzID09PSBjb25zb2xlCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTQ0MDYKKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGZhc3QvZG9tL1dpbmRvdy9jb25zb2xlLXVuYm91 bmQtZnVuY3Rpb25zLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vV2lu ZG93L2NvbnNvbGUtdW5ib3VuZC1mdW5jdGlvbnMuaHRtbDogQWRkZWQuCisKIDIwMTMtMDQtMTAg IE5vJ2FtIFJvc2VudGhhbCAgPG5vYW1Ad2Via2l0Lm9yZz4KIAogICAgICAgICBBbGxvdyBkaXJl Y3QgY29tcG9zaXRpbmcgb2YgYmFja2dyb3VuZCBpbWFnZXMKSW5kZXg6IExheW91dFRlc3RzL2Zh c3QvZG9tL1dpbmRvdy9jb25zb2xlLXVuYm91bmQtZnVuY3Rpb25zLWV4cGVjdGVkLnR4dAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9XaW5kb3cvY29uc29sZS11bmJvdW5kLWZ1 bmN0aW9ucy1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2Rv bS9XaW5kb3cvY29uc29sZS11bmJvdW5kLWZ1bmN0aW9ucy1leHBlY3RlZC50eHQJKHJldmlzaW9u IDApCkBAIC0wLDAgKzEsMTAgQEAKK0NPTlNPTEUgTUVTU0FHRTogbGluZSAxMTogY29uc29sZS5s b2coKSBjYWxsZWQuCitDT05TT0xFIE1FU1NBR0U6IGxpbmUgMTM6IGNvbnNvbGUuaW5mbygpIGNh bGxlZC4KK0NPTlNPTEUgTUVTU0FHRTogbGluZSAxNTogY29uc29sZS53YXJuKCkgY2FsbGVkLgor Q09OU09MRSBNRVNTQUdFOiBsaW5lIDE3OiBjb25zb2xlLmVycm9yKCkgY2FsbGVkLgorVGVzdHMg d2luZG93LmNvbnNvbGUgZnVuY3Rpb25zIHdoZW4gInRoaXMiIGlzIG5vdCBzZXQgdG8gY29uc29s ZS4gVG8gbWFrZSBzdXJlIHRoaXMgdGVzdCBwYXNzZWQgeW91IG11c3QgY2hlY2sgdGhlIGNvbnNv bGUgZm9yIHRoZSBmb2xsb3dpbmcgNCBtZXNzYWdlczoKKworY29uc29sZS5sb2coKSBjYWxsZWQu Citjb25zb2xlLmluZm8oKSBjYWxsZWQuCitjb25zb2xlLndhcm4oKSBjYWxsZWQuCitjb25zb2xl LmVycm9yKCkgY2FsbGVkLgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9kb20vV2luZG93L2NvbnNv bGUtdW5ib3VuZC1mdW5jdGlvbnMuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0 L2RvbS9XaW5kb3cvY29uc29sZS11bmJvdW5kLWZ1bmN0aW9ucy5odG1sCShyZXZpc2lvbiAwKQor KysgTGF5b3V0VGVzdHMvZmFzdC9kb20vV2luZG93L2NvbnNvbGUtdW5ib3VuZC1mdW5jdGlvbnMu aHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzMCBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRt bD4KKzxoZWFkPgorICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KKyAgICAgICAg ZnVuY3Rpb24gcnVuVGVzdHMoKQorICAgICAgICB7CisgICAgICAgICAgICBpZiAod2luZG93LnRl c3RSdW5uZXIpCisgICAgICAgICAgICAgICAgdGVzdFJ1bm5lci5kdW1wQXNUZXh0KCk7CisKKyAg ICAgICAgICAgIHZhciBsb2cgPSBjb25zb2xlLmxvZzsKKyAgICAgICAgICAgIGxvZygiY29uc29s ZS5sb2coKSBjYWxsZWQuIik7CisgICAgICAgICAgICB2YXIgaW5mbyA9IGNvbnNvbGUuaW5mbzsK KyAgICAgICAgICAgIGluZm8oImNvbnNvbGUuaW5mbygpIGNhbGxlZC4iKTsKKyAgICAgICAgICAg IHZhciB3YXJuID0gY29uc29sZS53YXJuOworICAgICAgICAgICAgd2FybigiY29uc29sZS53YXJu KCkgY2FsbGVkLiIpOworICAgICAgICAgICAgdmFyIGVycm9yID0gY29uc29sZS5lcnJvcjsKKyAg ICAgICAgICAgIGVycm9yKCJjb25zb2xlLmVycm9yKCkgY2FsbGVkLiIpOworICAgICAgICB9Cisg ICAgPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keSBvbmxvYWQ9InJ1blRlc3RzKCk7Ij4KKyAgICA8 cD5UZXN0cyB3aW5kb3cuY29uc29sZSBmdW5jdGlvbnMgd2hlbiAidGhpcyIgaXMgbm90IHNldCB0 byBjb25zb2xlLiAgVG8gbWFrZSBzdXJlIHRoaXMgdGVzdCBwYXNzZWQgeW91IG11c3QgY2hlY2sg dGhlIGNvbnNvbGUgZm9yIHRoZSBmb2xsb3dpbmcgNCBtZXNzYWdlczo8L3A+CisgICAgPHVsPgor ICAgICAgICA8bGk+Y29uc29sZS5sb2coKSBjYWxsZWQuPC9saT4KKyAgICAgICAgPGxpPmNvbnNv bGUuaW5mbygpIGNhbGxlZC48L2xpPgorICAgICAgICA8bGk+Y29uc29sZS53YXJuKCkgY2FsbGVk LjwvbGk+CisgICAgICAgIDxsaT5jb25zb2xlLmVycm9yKCkgY2FsbGVkLjwvbGk+CisgICAgPC91 bD4KKzwvYm9keT4KKzwvaHRtbD4K