171934 2017-05-10 11:16:01 -0700 Don't treat loopback addresses (127.0.0.0/8, ::1/128, localhost, .localhost) as mixed content 2026-04-29 19:36:15 -0700 1 1 1 Unclassified WebKit WebCore Misc. WebKit Nightly Build Mac macOS 10.12 NEW https://bugs.webkit.org/show_bug.cgi?id=186039 https://bugzilla.mozilla.org/show_bug.cgi?id=1220810 https://bugs.webkit.org/show_bug.cgi?id=160504 https://bugs.webkit.org/show_bug.cgi?id=218623 https://bugs.webkit.org/show_bug.cgi?id=272461 https://bugs.webkit.org/show_bug.cgi?id=281149 https://bugs.webkit.org/show_bug.cgi?id=279249 InRadar P2 Normal --- 127676 218623 218627 218795 219257 250607 140625 250776 1 birunthan webkit-unassigned 948508913 adomas.ven alexander alexandernst andrewmwhite antoine ap ashley ashokgelal beidson bfulgham bugzilla cdumez c.goossens changseok clindsay contact cwillisf cyb.ai.815 dbates d.koz.nyc dustin.nielson erik esprehn+autocc ews-watchlist fran fred.wang gianluca.varisco gizmo-bobcat6l gsnedders gyongyosimate1 gyuyoung.kim hi homakov hujialun jaffathecake jaime japhet jfernandez john.cuozzo jsearles julian karlcow kris l.cipriani lidel marco mattiasa mcatanzaro mcvey.rob me m.goleb+bugzilla mjs mkwst nsjames oeway007 pimento_trolls.0a pimterry rik seanboult slzfgs+1gpdcqish2o18 timothy titouan tobi tomac vincent.privat webkit-bug-importer webkit webkit wilander youennf oldest_to_newest 1306923 0 birunthan 2017-05-10 11:16:01 -0700 According to the spec, content from loopback addresses should no longer be treated as mixed content even in secure origins. See: - https://github.com/w3c/webappsec-mixed-content/commit/349501cdaa4b4dc1e2a8aacb216ced58fd316165 - https://w3c.github.io/webappsec-secure-contexts/#is-origin-trustworthy In other words, e.g. `fetch('http://127.0.0.1:1234/foo/bar')` on a HTTPS site should be allowed without triggering the mixed content blocker. Note Chrome (and soon Firefox) only whitelist '127.0.0.1' and '::1'. See: - https://chromium.googlesource.com/chromium/src.git/+/130ee686fa00b617bfc001ceb3bb49782da2cb4e - https://bugzilla.mozilla.org/show_bug.cgi?id=903966 1307172 1 ap 2017-05-10 21:07:17 -0700 We should consider blocking cross origin access to localhost completely, it's a pretty terrible security risk. 1307176 2 youennf 2017-05-10 21:23:52 -0700 (In reply to Alexey Proskuryakov from comment #1) > We should consider blocking cross origin access to localhost completely, > it's a pretty terrible security risk. Are you suggesting to block networking from a non-localhost web page to any localhost URL? What kind of risks are you envisioning? 1307184 3 ap 2017-05-10 22:12:57 -0700 > Are you suggesting to block networking from a non-localhost web page to any localhost URL? Correct. > What kind of risks are you envisioning? This opens up any service listening to connections on loopback interfaces to attacks of any kind. A web page can exploit request parsing bugs, or it can exfiltrate data that was meant to only be made available to a loopback counterpart. This is similar in spirit to attacks that were recently addressed by dropping support for HTTP/0.9. 1307186 4 birunthan 2017-05-10 22:23:54 -0700 (In reply to Alexey Proskuryakov from comment #1) > We should consider blocking cross origin access to localhost completely, > it's a pretty terrible security risk. That would be in violation of the spec. Also note that Chrome and Firefox Nightly allow cross origin access to 127.0.0.1 and ::1 from both HTTP and HTTPS sites. (In reply to Alexey Proskuryakov from comment #3) > This opens up any service listening to connections on loopback interfaces to > attacks of any kind. A web page can exploit request parsing bugs, or it can > exfiltrate data that was meant to only be made available to a loopback > counterpart. These are valid concerns, but please note that there are legitimate use cases localhost access. The Chromium commit message from comment 0 describes the what people have been forced to do for these legitimate cases: > Currently, mixed content checks block http://127.0.0.1 from loading in a > page delivered over TLS. I'm (belatedly) coming around to the idea that > that restriction does more harm than good. In particular, I'll note that > folks are installing new trusted roots and self-signing certs for that > IP address, exposing themselves to additional risk for minimal benefit. > Helpful locally installed software is doing the same, with even more > associated risk. Also see the discussion in https://bugs.chromium.org/p/chromium/issues/detail?id=607878 I think a better path forward would be to allow cross origin access to 127.0.0.1 and ::1 only if the loopback server sends back the CORS headers (i.e. Access-Control-Allow-Origin) even over HTTP. 1307187 5 youennf 2017-05-10 22:34:36 -0700 I am unsure of the compatibility risk of blocking. The same argument could somehow also be made for any internet web page trying to get access to LAN services, compatibility risk being even greater probably. I wonder how frequent it is for services accessible through the local loop to not be accessible from the LAN. 1307333 6 ap 2017-05-11 11:01:56 -0700 I don't see any explanation in the linked issues of why it's desirable for non-local pages to access localhost. It's incredibly unlikely to be a legitimate use of web technology. > I wonder how frequent it is for services accessible through the local loop to not be accessible from the LAN. That's pretty normal. Even when accessible from LAN, that's still a different security domain than any random webpage with random ad scripts. 1307361 7 youennf 2017-05-11 11:38:38 -0700 I haven't looked at the links but I guess this issue is somehow orthogonal. From a network perspective, a network intermediary will not be able to intercept any networking with localhost. 1314106 8 birunthan 2017-05-30 23:58:18 -0700 (In reply to Alexey Proskuryakov from comment #6) > I don't see any explanation in the linked issues of why it's desirable for > non-local pages to access localhost. It's incredibly unlikely to be a > legitimate use of web technology. Several popular desktop applications (e.g. Spotify) install a server that binds to a localhost port. The web application (e.g. spotify.com) then uses the localhost server to control the desktop application. In order to work around the mixed-content blocker, the web application connects over HTTPS to a host (e.g. *.spotilocal.com) that simply points to 127.0.0.1: For example: $ dig xkbyzltjth.spotilocal.com A +short 127.0.0.1 You can see the spotilocal.com requests e.g. on this page: https://developer.spotify.com/technologies/widgets/spotify-play-button/ This ugly hack suffers from a number of problems: it doesn't work when offline due to DNS resolution failure, it doesn't work through proxies, etc. Please keep in mind that Chrome and Firefox Nightly already allow plain HTTP connections to 127.0.0.1 without triggering the mixed content blocker. Edge is also planning to allow it (https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/11963735/). For web compatibility, please consider allowing it in Safari as well. 1314107 9 birunthan 2017-05-31 00:01:58 -0700 I forgot to mention that the hack also requires a HTTPS certificate. This means that the private key of the certificate is embedded in the desktop application... (I hear some applications have even resorted to installing a root CA so that they can use a self-signed certificate...) 1317623 10 ap 2017-06-09 14:13:16 -0700 *** Bug 173161 has been marked as a duplicate of this bug. *** 1317631 11 homakov 2017-06-09 14:34:11 -0700 >This opens up any service listening to connections on loopback interfaces to attacks of any kind. A web page can exploit request parsing bugs, or it can exfiltrate data that was meant to only be made available to a loopback counterpart. That's kind of true, but why not just open up localhost that opts-in to be accessed? Preflight? Why kill communication entirely when there are a ton of use cases when localhost actually wants to be available? 1317893 12 homakov 2017-06-10 05:55:29 -0700 Birunthan: hey if you're looking for more or less future-proof way to talk to localhost, try opening new window on http:// protocol. Here is how we do it now: https://medium.com/@homakov/how-securelogin-invented-browser-app-communication-38383f98ca99 1369905 13 bfulgham 2017-11-09 09:22:05 -0800 <rdar://problem/34510778> 1382872 14 bfulgham 2017-12-18 13:47:21 -0800 I do not support this requested change in behavior. Allowing HTTP from localhost to be included in a secure page is a terrible idea for a few reasons: 1. There is no guarantee that the server being used is the one the page content was expecting to connect to. E.g., a trojan server running as part of an application you installed intercepts file transfer information when you go to an external cloud storage server site. 2. Content served through the local HTTP server can pull insecure information from anywhere on the internet, serve it to the hosting page, and completely undermine the protections HTTPS is supposed to provide. We should do more to block this kind of poor design, not encourage it. 1382873 15 bfulgham 2017-12-18 13:48:07 -0800 (In reply to Brent Fulgham from comment #14) > I do not support this requested change in behavior. Allowing HTTP from > localhost to be included in a secure page is a terrible idea for a few > reasons: > > 1. There is no guarantee that the server being used is the one the page > content was expecting to connect to. E.g., a trojan server running as part > of an application you installed intercepts file transfer information when > you go to an external cloud storage server site. > > 2. Content served through the local HTTP server can pull insecure > information from anywhere on the internet, serve it to the hosting page, and > completely undermine the protections HTTPS is supposed to provide. > > We should do more to block this kind of poor design, not encourage it. Also: There's nothing to prevent /etc/hosts from directing a localhost address in the HTTPS application to some random place. 1383050 16 homakov 2017-12-18 20:43:35 -0800 There are people in the thread with real world use cases who you just called poor design and offered some strawman arguments on "localhost server being bad". >Also: There's nothing to prevent /etc/hosts from directing a localhost address in the HTTPS application to some random place. >1. There is no guarantee that the server being used is the one the page content was expecting to connect to. And how is this a problem for a localhost helper that verifies Origin and asks explicit confirmation to do an action for example? This design does not imply trusting 3rd party server. >2. Content served through the local HTTP server can pull insecure information from anywhere on the internet, serve it to the hosting page, and completely undermine the protections HTTPS is supposed to provide. Also, this localhost server can execute untrusted GET params, >this kind of poor design, not encourage it. Be've been happy with behavior of Chrome on this matter and will surely recommend users to use the browser that follows web standards. And what about all those helpers that run in localhost? Ever heard of Ethereum? New breed of authentication solutions? It is crucial to be able to talk to local daemons. A whole new range of use cases where you cannot upgrade the browser itself but you can install a standalone daemon and let the browser talk to it. 1388195 17 webkit 2018-01-11 04:59:18 -0800 > Also: There's nothing to prevent /etc/hosts from directing a localhost > address in the HTTPS application to some random place. For that reason, other browsers whitelist http://127.0.0.1, and not http://localhost. 1426547 18 l.cipriani 2018-05-23 05:53:30 -0700 Hello, Arduino officially speaking here. We do have a system that HAS to interact with a local server: https://github.com/arduino/arduino-create-agent This agent is installed already in a couple hundred thousand devices. Due to the blocking of 127.0.0.1 by webkit we are forced to create a Certificate Autority for Localhost and install it in the certificate chain, this is much worse than just allowing http://127.0.0.1/ (then obviously we remove the CA key permanently) if you read the w3c specs in details you can see that 127.0.0.1 is considered a priori authenticated and indeed this is what both Firefox and Chrome do, they just respect the w3c specs and do not think they are better than the committee Again here: https://w3c.github.io/webappsec-secure-contexts/#is-origin-trustworthy is correctly stated: If origin’s host component matches one of the CIDR notations 127.0.0.0/8 or ::1/128 [RFC4632], return "Potentially Trustworthy". So you are hereby declaring you do not want to comply to w3c specs which is a bit *strange* for a browser engine. 127.0.0.1 is trusted because it is the same network device of the user and the app has to call it (eventually with all the CORS option needed) and is responsible for calling the right server. In addition to that Firefox devs did a great job I think: https://dxr.mozilla.org/mozilla-central/source/dom/security/nsMixedContentBlocker.cpp#744 Now coming to your questions: 1. that only happens if the website explicitly calls a server in localhost, so there will some form of verification I hope, anyway it should not be a problem of the web engine to eventually block this apps but delegated to the web developer. 2. false, can only be done if the website which is calling localhost is passing some info, the master application is fully under control about the data will send to the 127.0.0.1:port application. 3. you should only allow 127.0.0.1 instead of localhost, I can agree on this. 4. Consider by TLS/SSL specification there is no way to create a valid https certificate for localhost nor for 127.0.0.1 (obviously, and that is good). 5. Please provide any other alternative to this very usual scenario: you have a web app that has to talk via http to a local device to (as Arduino does) connect the web page to a serial monitor or a USB device. Consider WebUSB is a draft: https://wicg.github.io/webusb/ and WebSerial does not really exists as of now. 6. So please, can you just try to respect public specifications? Users based their application on w3c specs. Thank you, Luca (In reply to Brent Fulgham from comment #14) > I do not support this requested change in behavior. Allowing HTTP from > localhost to be included in a secure page is a terrible idea for a few > reasons: > > 1. There is no guarantee that the server being used is the one the page > content was expecting to connect to. E.g., a trojan server running as part > of an application you installed intercepts file transfer information when > you go to an external cloud storage server site. > > 2. Content served through the local HTTP server can pull insecure > information from anywhere on the internet, serve it to the hosting page, and > completely undermine the protections HTTPS is supposed to provide. > > We should do more to block this kind of poor design, not encourage it. 1426554 19 l.cipriani 2018-05-23 06:37:57 -0700 Edge fixed the same issue few hours ago: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/11963735/ 1426610 20 ap 2018-05-23 09:33:38 -0700 Having web pages access (or enumerate) local devices would have to come with a meaningful permission model, which is unlikely to exist. Asking the user anything along the lines of "www.arduino.corp.trusted.myphishingpage.cc would like to access 127.0.0.1:23764 for an unknown reason with unknown consequences, Allow/Block" wouldn't make any security sense. 1426652 21 mcatanzaro 2018-05-23 11:21:33 -0700 (In reply to Luca Cipriani from comment #18) > Hello, Arduino officially speaking here. > > We do have a system that HAS to interact with a local server: > https://github.com/arduino/arduino-create-agent > > This agent is installed already in a couple hundred thousand devices. Due to > the blocking of 127.0.0.1 by webkit we are forced to create a Certificate > Autority for Localhost and install it in the certificate chain, this is much > worse than just allowing http://127.0.0.1/ (then obviously we remove the CA > key permanently) It seems like a pretty good argument in favor of reopening this issue and adopting the Firefox/Chrome behavior. Creating a certificate for 127.0.0.1 is surely worse than the alternative. And there really isn't much value in performing mixed content checks on localhost content. (In reply to Brent Fulgham from comment #14) > I do not support this requested change in behavior. Allowing HTTP from > localhost to be included in a secure page is a terrible idea for a few > reasons I'm pretty much satisfied by the responses to this above. (In reply to Alexey Proskuryakov from comment #20) > Having web pages access (or enumerate) local devices would have to come with > a meaningful permission model, which is unlikely to exist. Asking the user > anything along the lines of "www.arduino.corp.trusted.myphishingpage.cc > would like to access 127.0.0.1:23764 for an unknown reason with unknown > consequences, Allow/Block" wouldn't make any security sense. This makes more sense to me, but the problem is that such access is already allowed from http:// websites, right? Surely mixed content blocking is not the right way to enforce restrictions on accessing local content. Looking at https://bugs.chromium.org/p/chromium/issues/detail?id=607878, it looks like the mixed content spec developers have spent a lot of time thinking about this, including the link to https://mikewest.github.io/cors-rfc1918/ in comment 6. 1426723 22 ap 2018-05-23 13:49:54 -0700 As mentioned in comment 1, I think that we should block localhost access for http too. 1427906 23 l.cipriani 2018-05-28 03:34:29 -0700 (In reply to Alexey Proskuryakov from comment #1) > We should consider blocking cross origin access to localhost completely, > it's a pretty terrible security risk. Hi Alexey, I can partially agree on this but there should be an alternative. Please also look at how chrome is addressing it (being discussed since March 2014 https://bugs.chromium.org/p/chromium/issues/detail?id=378566 Now the fact you can easily screw up everything anyway by just calling a plain http website that calls http://127.0.0.1 does not mean with Mixed-Content cors you are increasing the overall security of your users. in fact you are decreasing security because to use this feature users installs CA certificates. This is what we are doing now: https://letsencrypt.org/docs/certificates-for-localhost/ plus signing every request coming from the web to verify they are coming from our specific servers, but this is a problem of the server running on localhost that needs some sort of security and authentication system. (I remember CUPS using username/pass of the root users on many systems since the early days.) In my opinion your are not solving the security issue enforcing mixed content error for 127.0.0.1, an attacker can still circumvent it by using a plain http webstie. You will do if you completely remove 127.0.0.1 to be contacted from the web but then please provide an api to let web application contact the hardware, we are no more in '90s. To mention Mike West which I believe is the main expert in the world about CORS policy for browsers: https://chromium.googlesource.com/chromium/src.git/+/130ee686fa00b617bfc001ceb3bb49782da2cb4e "Currently, mixed content checks block http://127.0.0.1 from loading in a page delivered over TLS. I'm (belatedly) coming around to the idea that that restriction does more harm than good. In particular, I'll note that folks are installing new trusted roots and self-signing certs for that IP address, exposing themselves to additional risk for minimal benefit. Helpful locally installed software is doing the same, with even more associated risk." Our alternative is to tell the user just use any other browser engine than WebKit. So please let us know if you want to include the change in the roadmap or at least let us know if it is going to be WONTFIX so we can phase WebKit out or not accordingly. Thank you! 1427934 24 mcatanzaro 2018-05-28 08:28:19 -0700 (In reply to Luca Cipriani from comment #23) > To mention Mike West which I believe is the main expert in the world about > CORS policy for browsers: I don't know much about CORS, but at least he's definitely the authority on mixed content. In bug #140625 I'm tracking other cases where WebKit's behavior diverges from his specs. If you see any other bugs related to mixed content, adding a dependency on bug #140625 would be appreciated. (In reply to Alexey Proskuryakov from comment #22) > As mentioned in comment 1, I think that we should block localhost access for > http too. I won't comment on that whether or not WebKit should do that. If you have a concrete plan to start blocking all localhost content in the near future, then obviously this should be WONTFIX. But I rather doubt that will really happen. So long as WebKit continues to allow localhost access for http://, I'm pretty sure it really does not make any sense to block mixed content from 127.0.0.1. So if we treat this solely as a mixed content issue, and assume WebKit will continue to allow loading content from localhost, then we should reopen this bug. 1427965 25 ap 2018-05-28 13:21:09 -0700 I actually think that getting users trust a certificate is better for multiple reasons. 1. It greatly reduces the impacted group, and makes it a less interesting target. 2. It requires doing something that would be a deterrent to proceeding, which is good. One may decide to limit the hack to a VM, or use a less secure secondary browser just for this purpose, or make the vendor change their approach, or decide to not work with this vendor at all. All of those are better for security. > I can partially agree on this but there should be an alternative. I'm not sure why you are insisting that a web browser ever needs to talk to locally installed software and hardware at all. This is low benefit and high risk. If we had to provide an opt-in, I would argue that it should be implemented in a way that discourages its use. Installing a trusted certificate doesn't sound so bad. Another alternative could be a Developer menu option that allows 127.0.0.1 access just for the currently open window. Or maybe one can take a clue from how NPAPI plug-ins are handled by each browser. > If you have a concrete plan to start blocking all localhost content in the near future, then obviously this should be WONTFIX. Good point, let's make it concrete in bug 186039. 1449253 26 nsjames 2018-08-10 04:01:08 -0700 > I'm not sure why you are insisting that a web browser ever needs to talk to locally installed software and hardware at all. This is low benefit and high risk. This is the root of the problem here. What you think devs/users might need it for is irrelevant, there are proven use-cases of this which have been causing users to search out other browsers, some of them included in this thread. This seems to be direct neglect of the standard guided by a single person. 1450421 27 antoine 2018-08-15 13:17:51 -0700 This issue of blocking localhost as well as not allowing mixed content is completely blocking Safari from multiple important use cases. The IoT field and the fintech/payments field are full of use cases for talking to localhost. Example: a point of sale running in the browser needs to talk to a server on localhost to send a payment request to a terminal on the network. Everything on the web being https nowadays, the browser needs to be able to talk to a http service on the machine. Self-signed certificates are non-sense in this context. I fail to understand the rationale to block localhost here. - Developers are giving you valid use cases - It's in the spec - Other browsers implement it - There are no workarounds If there were credible attacks based on this feature, you'd see Chrome and Firefox users being attacked left and right. This is not the case. Can we please allow this so that the Web doesn't take a step backwards, and so that we don't have to tell our users "oh you need to use Chrome or Firefox, this doesn't work on Safari". There's a spec - don't be an IE6 developer. 1450518 28 youennf 2018-08-15 16:29:03 -0700 It is unclear to me why we relate mixed content checks with localhost access. Attacks to localhost servers are currently easy to do no matter mixed content or not, I do not see what protection we get there. As for web sites that get data from localhost, they are doing the requests so they should know what the security model is. Some workarounds: - Self signed certificates :( - Deliver the web site through HTTP :( - Make the connection between browser and localhost server go through a proxy: HTTPS/WSS/WebRTC. The localhost server would need to keep a connection with this proxy so that it is available or it should be 'waken up' by making the browser navigating to it. We should think of the best way to protect Web apps/WebKit apps from these attacks (and probably LAN server access in general). Maybe an opt-in or content blockers could help there. It is reasonable to think that some WebKit applications will want to allow access to 127.0.0.1 and for good reasons. I do not see why mixed content checks should interfere with such apps. Aligning with the spec makes sense to me at this point. 1450568 29 homakov 2018-08-15 20:18:03 -0700 >I fail to understand the rationale to block localhost here. Antoine, you must be new here :) Arguments have no power in the land of this ticket. This is "Mr Proskuryakov against the world" thread. After getting dozens of reasons to make a sane default or at least follow the spec, even after getting a direct endorsement by a security expert like me, that it is indeed totally fine and safe (I fail to see he has any understanding of threat modeling and web security), nothing's changed. Now I keep this URL in my "this is why safari sucks" collection and to give websec friends a good laugh. 1450586 30 antoine 2018-08-15 21:52:06 -0700 Indeed “new” here but not new to web browser development - ex-Firefox dev here, back when IE was still dominant. :) I’m very proud of what we achieved in the past 20 years but disheartened when a read such a thread. I’m truly baffled by the “I myself personally didn’t encounter any use cases so it’s obviously useless to the world” argument. I thought the web community had moved past that. Im also baffled by some of the “security concerns” I read here. “If a Trojan is installed on the computer...”. If a Trojan is installed you have bigger things to worry about. If a decision is made in the name of security, shouldn’t a security body review it? And to that point... didn’t one ALREADY REVIEW this exact point? Have there been counter examples? Attacks in the wild? Zero day exploits? Or are we just thinking of the children? Even looking at the future of the web, there are drafts in development to actively let the browser talk to hardware - whether Bluetooth, USB, or even through raw tcp sockets. Thinking that browsers should be banned from hardware communication is curing the disease by killing the patient. And also going against a major trend in the future of the web. Yay for native apps? Once again: can we follow the spec and not break the web even further? Please? 1450934 31 antoine 2018-08-16 16:10:26 -0700 As an example of how much this is needed, the Chrome team even implemented a Native Messaging API. Presently available for extensions, but there is talk to bring it straight to web. https://developer.chrome.com/extensions/nativeMessaging Communication from web to native and back is a very real use case. It should be allowed in Webkit/Safari (with CORS to mitigate any concern), until you decide to supersede it with something better like Chrome's Native Messaging API. At least there will be a path for developers. 1451582 32 l.cipriani 2018-08-20 06:19:00 -0700 Firefox is going in the same direction. Better tell our users to just not use this browser. 1472674 33 oeway007 2018-10-27 01:49:02 -0700 I registered an account here just for this issue, hope it can be reconsidered and fixed in the near future. Right now, we have to instruct the user to use Chrome and FireFox, **not Safari**. 1495895 34 contact 2019-01-18 09:58:46 -0800 (In reply to Alexey Proskuryakov from comment #25) > I actually think that getting users trust a certificate is better for > multiple reasons. > > 1. It greatly reduces the impacted group, and makes it a less interesting > target. > > 2. It requires doing something that would be a deterrent to proceeding, > which is good. One may decide to limit the hack to a VM, or use a less > secure secondary browser just for this purpose, or make the vendor change > their approach, or decide to not work with this vendor at all. All of those > are better for security. > > > I can partially agree on this but there should be an alternative. > > I'm not sure why you are insisting that a web browser ever needs to talk to > locally installed software and hardware at all. This is low benefit and high > risk. > > If we had to provide an opt-in, I would argue that it should be implemented > in a way that discourages its use. Installing a trusted certificate doesn't > sound so bad. Another alternative could be a Developer menu option that > allows 127.0.0.1 access just for the currently open window. Or maybe one can > take a clue from how NPAPI plug-ins are handled by each browser. > > > If you have a concrete plan to start blocking all localhost content in the near future, then obviously this should be WONTFIX. > > Good point, let's make it concrete in bug 186039. Hi Alexey, This thread got pretty toxic, threats of recommending other browsers is definitely not helping in driving arguments. I also understand your point that allowing websites to talk to programs on the device does create additional security risks. However I would like to make an argument that not allowing them to talk to loopaback addresses does in fact create larger security risks: Matter of the fact is that today due to this restriction applications are forced to do something that is much worse. They create DNS records like `local.myapp 127.0.0.1` and bundle TLS certificate + keys with an application. Note that this does not require installing a trusted certificate root as you mentioned in the comment. Additionally you could consider doing something along the lines of `document.requestStorageAccess` say `document.requestLoopbackAccess` and provide similar user consent prompt https://webkit.org/blog/8311/intelligent-tracking-prevention-2-0/ Where instead of prompting user to give explicit access to site A when browsing site B, rephrase site A to "application A". 1497372 35 pimterry 2019-01-23 09:35:26 -0800 Just to chime in here too, my application (https://httptoolkit.tech) also requires localhost access from the web. My application consists of a hosted web UI which interacts with an installed desktop service, that's used to start & manage other local applications & servers. My app works in every modern browser except Safari, and unfortunately I'm going to have to simply tell that to users. I can still see objections here that there's no good use case for web to localhost communication. I'd like to reiterate the evidence from this thread against that, so we can clear that argument out of the way: * Major common applications like Spotify need this behaviour to interact with desktop applications from the web. They currently work suboptimally because of their workarounds for this (with spotilocal - see comment #8 above). * Many hardware companies use this behaviour to build web UIs that can interact with attached hardware, including Arduino, with software depending on this running on hundreds of thousands of devices. WebUSB may resolve this for USB devices, but not yet, and only for USB devices specifically. * There's a substantial ecosystem of Ethereum sites built entirely around localhost communication from the web: https://github.com/ethereum/web3.js * Many developers like myself in this thread, whose applications are broken by this behaviour, in Safari only. Imo all of these use cases are reasonable, so it's certainly not the case that there's no legitimate use cases at all. Could anybody summarize the outstanding security concerns around this? What specific attacks would this expose users to? It would be great to try & make progress here if possible, or to find concrete security issues that could be relevant to the other browsers that have implemented this if not. 1497745 36 mjs 2019-01-23 22:28:31 -0800 (In reply to youenn fablet from comment #28) > It is unclear to me why we relate mixed content checks with localhost access. > Attacks to localhost servers are currently easy to do no matter mixed > content or not, I do not see what protection we get there. Let's think through this. The mixed content policy is meant to protect users from being misled into thinking they are interacting with a secure page with content from a known source, but effectively it's not, because non-https content could have been tampered with in transit. We don't want to give users a false sense of security in this case. It might not be safe to type a credit card number or a password on such a page. The suggested risks of any access from remote pages to the loopback address are: (1) Pages could exploit local web services that weren't meant to be accessed from an untrusted source. (2) Trojan software could install a trap version of a local web service that aims to exploit the page making use of it. It seems to me these threats are not properly addressed by a failed mixed content check (which would either result in an insecure indicator or a failed resource load if the referring page is http:). The first attack could be performed from an http: page, or in any case the page performing it may not care about an "insecure" warning in the location field. By the time that shows up, the attack has likely already happened, and users would not expect "insecure" to put them on notice of this. A rogue service as in (2) could still exploit pages that deploy any of the many workarounds for this limitation. Furthermore, if malware can run an http server, it cn probably do other malicious things locally to interfere with the integrity of websites. So while it may make sense to consider limitations for remote access to local web servers, holding out on this tweak to the mixed content rules does not fulfill the purpose of mixed content rules, nor does it properly mitigate the attacks. Therefore reopening because I think this was closed based on an incorrect rationale. > As for web sites that get data from localhost, they are doing the requests > so they should know what the security model is. > > Some workarounds: > - Self signed certificates :( > - Deliver the web site through HTTP :( > - Make the connection between browser and localhost server go through a > proxy: HTTPS/WSS/WebRTC. The localhost server would need to keep a > connection with this proxy so that it is available or it should be 'waken > up' by making the browser navigating to it. > > We should think of the best way to protect Web apps/WebKit apps from these > attacks (and probably LAN server access in general). Maybe an opt-in or > content blockers could help there. > It is reasonable to think that some WebKit applications will want to allow > access to 127.0.0.1 and for good reasons. I do not see why mixed content > checks should interfere with such apps. > > Aligning with the spec makes sense to me at this point. 1497754 37 l.cipriani 2019-01-24 00:47:41 -0800 Thank you so much for reopening this issue. Let us know how we can help with the process and if you need more info on some use-cases. We have seen other projects having the same issue, here some of them: https://github.com/arduino/arduino-create-agent/network/members Thank you! 1497758 38 pimterry 2019-01-24 01:07:19 -0800 Totally agree with the above, thanks for reopening this! A couple of additional points on the two risks you pointed out, just to reinforce that they're not a concern: > Pages could exploit local web services that weren't meant to be accessed from an untrusted source. This same risk applies equally to any non-localhost web application. The real defence against this attack is for local web services to use CORS appropriately to manage cross-domain requests, like any other domain. That blocks these requests entirely and solves this issue (assuming localhost doesn't have any special CORS behaviour, which is true afaik). > Trojan software could install a trap version of a local web service that aims to exploit the page making use of it. You mentioned that malicious software running on your computer likely already poses a larger threat here, which is certainly true. In addition though, malicious software running on your computer could easily include a valid certificate for a real domain that resolves to localhost (localhost.evil.com), and then host a secure HTTPS service on localhost, to avoid all warnings. Even if your trojan does need to interact with a web session for some reason, it's very easy to defeat localhost mixed content protection like this. 1497798 39 homakov 2019-01-24 07:18:25 -0800 Happy to see this reopened. Safari has really been hitting many nerves with this unreasonable prohibition. It's been widely concluded there is no (new) security threat that otherwise wouldn't exist anyway. What stops from implementing it soon? Who needs to approve this? It must be a one-line change. 1497859 40 mcatanzaro 2019-01-24 10:00:07 -0800 I think this is probably a small change in MixedContentChecker::isMixedContent in Source/WebCore/loader/MixedContentChecker.cpp. The challenge is going to be layout tests. First, the change requires a layout test of its own. But also, all our mixed content layout tests use an Apache server running on 127.0.0.1, so all those tests would break if we fix this. I think, since we'd probably be allowing 127.0.0.1 and ::1 but not localhost, as per the spec, perhaps we could switch the URIs for all the existing mixed content tests to use localhost to verify that mixed content blocking still applies to localhost, and a new test for this bug could use 127.0.0.1 and ::1 to verify that the mixed content checks don't apply to the loopback addresses. P.S. If anyone is interested in contributing -- remember WebKit is an open source project after all -- see https://webkit.org/contributing-code/ for tips. Changes can be approved by any reviewer, though since this is a controversial issue we'd seek consensus first. 1497860 41 mcatanzaro 2019-01-24 10:04:09 -0800 BTW the tests are in LayoutTests/http/tests/security/mixedContent. For example, in LayoutTests/http/tests/security/mixedContent/resources/frame-with-insecure-image.html, we could try changing this: <img src="http://127.0.0.1:8080/security/resources/compass.jpg"> (which would be broken by this change), to this: <img src="http://localhost:8080/security/resources/compass.jpg"> (which should still be blocked). 1497861 42 mcatanzaro 2019-01-24 10:07:48 -0800 Hm, I've spent about two minutes looking at the spec, but it does say: If origin’s host component is "localhost" or falls within ".localhost", and the user agent conforms to the name resolution rules in [let-localhost-be-localhost], return "Potentially Trustworthy". So... plan probably foiled. 1498249 43 mcatanzaro 2019-01-25 08:19:57 -0800 I guess we'll need a new setting just for use by tests, and a TestController message to enable/disable it for testing purposes. 1524880 44 mcvey.rob 2019-04-05 16:06:27 -0700 Thanks for reopening this issue. Just saw the release notes for Safari 12.1 and it reminded me to check on the status of this. Any updates that can be provided on this issue? I see that it's still unassigned. I for one would really appreciate it if this could be prioritized. Thanks again! 1580753 45 antoine 2019-10-16 16:08:11 -0700 I'll echo the previous comment. Any progress on this will be greatly appreciated. 1581451 46 antoine 2019-10-18 10:25:56 -0700 Michael Catanzaro: I see that SecurityOrigin.cpp has this // FIXME: Ensure that localhost resolves to the loopback address. in bool SecurityOrigin::isLocalHostOrLoopbackIPAddress(StringView host) I would suggest that the fix to this bug not tackle "localhost" resolution but focus on the loopback address, and a separate bug be filed for localhost. In that context, the fix would only be changing the function MixedContentChecker::isMixedContent line 62: return !SecurityOrigin::isSecure(url); to return !(SecurityOrigin::isSecure(url) || SecurityOrigin::isLoopbackIPAddress(url)); Modifications to tests would involve replacing 127.0.0.1 to localhost at the appropriate places (which would then be modified as necessary as part of a separate bug to tackle localhost rules). Would a fix with those changes be acceptable? 1581689 47 mcatanzaro 2019-10-19 07:27:03 -0700 (In reply to antoine from comment #46) > Michael Catanzaro: I see that SecurityOrigin.cpp has this > > // FIXME: Ensure that localhost resolves to the loopback address. > > in > > bool SecurityOrigin::isLocalHostOrLoopbackIPAddress(StringView host) > > I would suggest that the fix to this bug not tackle "localhost" resolution > but focus on the loopback address, and a separate bug be filed for localhost. In fact, the FIXME is not fixable at the WebKit level. DNS resolution is performed by platform libraries. In the case of WebKitGTK and WPE, that's done by GIO, which we just fixed in https://gitlab.gnome.org/GNOME/glib/merge_requests/616. For Mac, probably either CoreFoundation or perhaps the system resolver, not sure. It would be appropriate to replace the FIXME with a comment indicating that WebKit assumes localhost is always really localhost. (In reply to antoine from comment #46) > In that context, the fix would only be changing the function > MixedContentChecker::isMixedContent line 62: > > return !SecurityOrigin::isSecure(url); > > to > > return !(SecurityOrigin::isSecure(url) || > SecurityOrigin::isLoopbackIPAddress(url)); Nice investigation! > Modifications to tests would involve replacing 127.0.0.1 to localhost at the > appropriate places (which would then be modified as necessary as part of a > separate bug to tackle localhost rules). I'm not sure if it will be that easy. E.g. this change will likely break all the mixed content tests. I think we will just need to have a setting that tests can use to choose which behavior they get. See my suggestion in comment #43 > Would a fix with those changes be acceptable? I *believe* we have consensus on this change at this point, so as long as there's a new test and it doesn't break old tests, I think so. Seems clear that the test work will be harder than the change itself. 1581690 48 mcatanzaro 2019-10-19 07:28:38 -0700 (In reply to Michael Catanzaro from comment #47) >It would be > appropriate to replace the FIXME with a comment indicating that WebKit > assumes localhost is always really localhost. Of course, it would be a good idea for someone familiar with macOS or iOS to check what really happens on Apple platforms before doing so. 1581763 49 antoine 2019-10-19 23:04:17 -0700 > > Modifications to tests would involve replacing 127.0.0.1 to localhost at the > > appropriate places (which would then be modified as necessary as part of a > > separate bug to tackle localhost rules). > > I'm not sure if it will be that easy. E.g. this change will likely break all > the mixed content tests. I think we will just need to have a setting that > tests can use to choose which behavior they get. See my suggestion in > comment #43 Makes sense - i actually got things to work by swapping 127.0.0.1 for localhost in the mixed content tests (along with the string in the expected result) but i guess the testcontroller is a cleaner approach. I'll give it a shot in a separate branch. Thanks Michael! 1581777 50 mcatanzaro 2019-10-20 10:03:10 -0700 (In reply to antoine from comment #49) > Makes sense - i actually got things to work by swapping 127.0.0.1 for > localhost in the mixed content tests (along with the string in the expected > result) but i guess the testcontroller is a cleaner approach. I'll give it a > shot in a separate branch. Thanks Michael! Oh, so you chose to whitelist only 127.0.0.1 and ::1, and not also localhost. In that case, modifying TestController is of course not required. If you want to whitelist localhost as well -- which I expect is desired -- then you will need to add a TestController setting to make the tests pass. But it's also fine to start out by whitelisting 127.0.0.1 and ::1, and leave localhost for a follow-up patch. (In reply to antoine from comment #46) > In that context, the fix would only be changing the function > MixedContentChecker::isMixedContent line 62: > > return !SecurityOrigin::isSecure(url); > > to > > return !(SecurityOrigin::isSecure(url) || > SecurityOrigin::isLoopbackIPAddress(url)); Actually, it would be better to change SecurityOrigin::isSecure directly instead, since loopback can be trusted for all purposes, not just mixed content checking. 1581779 51 antoine 2019-10-20 12:31:12 -0700 (In reply to Michael Catanzaro from comment #50) > Oh, so you chose to whitelist only 127.0.0.1 and ::1, and not also > localhost. In that case, modifying TestController is of course not required. > > If you want to whitelist localhost as well -- which I expect is desired -- > then you will need to add a TestController setting to make the tests pass. > > But it's also fine to start out by whitelisting 127.0.0.1 and ::1, and leave > localhost for a follow-up patch. Sounds good - that's the approach i'm more comfortable with as i'm not certain of the implications of whitelisting localhost (see https://www.w3.org/TR/secure-contexts/#localhost "Given that uncertainty, this document errs on the conservative side by special-casing 127.0.0.1, but not localhost."). > Actually, it would be better to change SecurityOrigin::isSecure directly > instead, since loopback can be trusted for all purposes, not just mixed > content checking. Makes sense - will make the modification. This should allow all present tests to pass. In terms of new tests - should we duplicate all of the mixed-content tests to check for 127.0.0.1 / ::1 or have only one test for that specific use case? 1582082 52 antoine 2019-10-21 15:29:12 -0700 Michael - i have a patch ready to go. Insights on any new tests to add would be appreciated as this is my first contribution to Webkit. Thanks! 1582245 53 mkwst 2019-10-21 21:50:03 -0700 (In reply to antoine from comment #51) > (In reply to Michael Catanzaro from comment #50) > > Oh, so you chose to whitelist only 127.0.0.1 and ::1, and not also > > localhost. In that case, modifying TestController is of course not required. > > > > If you want to whitelist localhost as well -- which I expect is desired -- > > then you will need to add a TestController setting to make the tests pass. > > > > But it's also fine to start out by whitelisting 127.0.0.1 and ::1, and leave > > localhost for a follow-up patch. > > Sounds good - that's the approach i'm more comfortable with as i'm not > certain of the implications of whitelisting localhost (see > https://www.w3.org/TR/secure-contexts/#localhost "Given that uncertainty, > this document errs on the conservative side by special-casing 127.0.0.1, but > not localhost."). Note that this changed several years ago: https://w3c.github.io/webappsec-secure-contexts/#localhost is the current text, which relies upon https://tools.ietf.org/html/draft-ietf-dnsop-let-localhost-be-localhost-02 to lock down `*.localhost` (which I wasn't able to successfully get through DNSOP, but which Chrome and Firefox implement). AFAIK, Chrome and Firefox both treat explicit loopback in the forms `127.0.0.1`, `[::1]`, and `*.localhost` as secure contexts. For tests that needed to distinguish the difference (and so that we can test multiple origins more clearly), we map arbitrary addresses (e.g. `http://layout.test/`) to loopback: see https://cs.chromium.org/chromium/src/content/shell/app/shell_main_delegate.cc?rcl=dfa06417b4ff75a88202b0359fa914212f52e7b0&l=262. That might be an approach that could work for WebKit as well? 1582336 54 mcatanzaro 2019-10-22 05:27:03 -0700 (In reply to antoine from comment #51) > This should allow all present tests to pass. In terms of new tests - should > we duplicate all of the mixed-content tests to check for 127.0.0.1 / ::1 or > have only one test for that specific use case? Well some developers might prefer duplicating all the tests in order to be thorough, but honestly I think that would create more maintenance effort than actual value. So after you've switched from 127.0.0.1 to localhost in the tests, I would duplicate only one really basic test, say insecure-image-in-main-frame.html, call it insecure-image-in-loopback-main-frame.html, and verify that the content is not blocked when using 127.0.0.1 instead of localhost. IMO the one test should suffice. Then we should create a follow-up bug to consider *.localhost as a secure context as well (which requires verifying that it is indeed secure when using the Cocoa and curl network backends, as it now is for the soup backend), since that's what Mike is clearly suggesting that we do, and that's what Firefox and Chrome already do. Of course, bonus points if you want to go all the way and do it this way initially, but not required IMO. 1582338 55 mkwst 2019-10-22 05:41:50 -0700 > that's what Mike is clearly suggesting that we do, and that's what Firefox and Chrome already do. For clarity, Mike is suggesting that y'all first implement the restrictions in https://tools.ietf.org/html/draft-ietf-dnsop-let-localhost-be-localhost-02 such that `localhost` and `*.localhost` always resolve to loopback, and never hit the internet (see https://cs.chromium.org/chromium/src/net/dns/host_resolver_manager.cc?rcl=905e57ccac6951efcfbc514fe33839c6ede4fee2&l=2751 for example). I expect this would require CFNetwork changes for macOS, and might not be trivially implementable right away. I don't think it's safe to treat `localhost` or `*.localhost` as secure contexts without that set of restrictions in place, as it's very unlikely that developers (or users!) understand that those names might resolve out to the internet in some cases. 1582351 56 antoine 2019-10-22 07:19:19 -0700 (In reply to Michael Catanzaro from comment #54 > Well some developers might prefer duplicating all the tests in order to be > thorough, but honestly I think that would create more maintenance effort > than actual value. So after you've switched from 127.0.0.1 to localhost in > the tests, I would duplicate only one really basic test, say > insecure-image-in-main-frame.html, call it > insecure-image-in-loopback-main-frame.html, and verify that the content is > not blocked when using 127.0.0.1 instead of localhost. IMO the one test > should suffice. Sounds good, thanks for the feedback. > Then we should create a follow-up bug to consider *.localhost as a secure > context as well (which requires verifying that it is indeed secure when > using the Cocoa and curl network backends, as it now is for the soup > backend), since that's what Mike is clearly suggesting that we do, and > that's what Firefox and Chrome already do. Of course, bonus points if you > want to go all the way and do it this way initially, but not required IMO. Agreed, fixing loopback as a first step is risk-free and will address the pains everyone expressed in this thread. Mike brought some great points and I’ll let a more experienced developer tackle localhost. I just ran the entire regression suite though and it seems like we can’t avoid a TestController for some tests that rely on 127.0.0.1 to be insecure and need a cross-domain origin from localhost. This testcontroller will anyways be useful the day localhost becomes trusted as well. 1656137 57 c.goossens 2020-05-26 12:53:07 -0700 Hi, we are using this to connect with a user installed application that runs a local websocket to stream some data that they entered in the webbrowser to their app on request. This currently works in all browsers (as it should per spec) by connecting to ws://127.0.0.1:[port]. Currently this is broken in the latest version of Safari. What's the status on this bug report? Will Webkit (and Safari) start following the Mixed-Content spec on this issue? Let me know. Thanks in advance. 1656138 58 c.goossens 2020-05-26 12:54:31 -0700 (In reply to c.goossens from comment #57) > Hi, we are using this to connect with a user installed application that runs > a local websocket to stream some data that they entered in the webbrowser to > their app on request. This currently works in all browsers (as it should per > spec) by connecting to ws://127.0.0.1:[port]. > > Currently this is broken in the latest version of Safari. What's the status > on this bug report? Will Webkit (and Safari) start following the > Mixed-Content spec on this issue? Let me know. Thanks in advance. At least, to be clear, can we allow requests to 127.0.0.1 and ::1? 1656153 59 mcatanzaro 2020-05-26 13:37:37 -0700 (In reply to Mike West from comment #55) > > that's what Mike is clearly suggesting that we do, and that's what Firefox and Chrome already do. > > For clarity, Mike is suggesting that y'all first implement the restrictions > in > https://tools.ietf.org/html/draft-ietf-dnsop-let-localhost-be-localhost-02 > such that `localhost` and `*.localhost` always resolve to loopback, and > never hit the internet (see > https://cs.chromium.org/chromium/src/net/dns/host_resolver_manager. > cc?rcl=905e57ccac6951efcfbc514fe33839c6ede4fee2&l=2751 for example). I > expect this would require CFNetwork changes for macOS, and might not be > trivially implementable right away. > > I don't think it's safe to treat `localhost` or `*.localhost` as secure > contexts without that set of restrictions in place, as it's very unlikely > that developers (or users!) understand that those names might resolve out to > the internet in some cases. Of course, with four different network backends, it's hard to guarantee they have all done this, and newer versions of WebKit are certain to be used against older network backends... but we've implemented this guarantee in GResolver a year ago, at your suggestion, so libsoup-based ports should be good: https://gitlab.gnome.org/GNOME/glib/-/merge_requests/616 (In reply to c.goossens from comment #57) > Hi, we are using this to connect with a user installed application that runs > a local websocket to stream some data that they entered in the webbrowser to > their app on request. This currently works in all browsers (as it should per > spec) by connecting to ws://127.0.0.1:[port]. > > Currently this is broken in the latest version of Safari. What's the status > on this bug report? Will Webkit (and Safari) start following the > Mixed-Content spec on this issue? Let me know. Thanks in advance. Nobody is working on this bug report, at least last we heard from Antoine was comment #56. But from comment #46, we see the actual code change here is a one-liner, so this is really just blocked on tests. Maybe review the comments above to see previous discussion on what's needed for the tests. I think we have consensus to accept this change, but the patch would need to include a test and ensure existing tests don't break. 1656166 60 c.goossens 2020-05-26 13:53:11 -0700 Thank you Michael for your quick response! I hope I have bumped this bugreport and someone can try the quick one-liner fix (and edit/run the tests). If that's not possible, I will see if we can make time in a sprint to submit a contribution to the project. I don't have any experience with the Webkit codebase however, so I would rather avoid that. 1656170 61 antoine 2020-05-26 14:07:16 -0700 (In reply to Christiaan Goossens from comment #60) > Thank you Michael for your quick response! I hope I have bumped this > bugreport and someone can try the quick one-liner fix (and edit/run the > tests). > > If that's not possible, I will see if we can make time in a sprint to submit > a contribution to the project. I don't have any experience with the Webkit > codebase however, so I would rather avoid that. I had made the fix and tested that it works a while back. Unfortunately i went down the wrong path for the tests, and as Michael mentioned, adapting all the tests to make sure they function correctly is actually a significant job. I had started but never found time to finish. Still on my todo list but would be happy if someone beats me to it. 1656231 62 ap 2020-05-26 17:21:42 -0700 With the recent reports of websites fingerprinting machines using loopback connections, it seems even more obvious that this is a technique that needs to be at least restricted. 1656238 63 homakov 2020-05-26 17:58:52 -0700 There is no danger in access to 127.0.0.1 as it was shown many times in this thread. To sum it up: 1. all other browsers behave correctly, Safari doesn’t 2. no serious attack was found that works on other browsers but doesnt in Safari 3. fingerprinting loopback services such as Redis or Mongodb is rather pointless against 99% users. The developers are powerusers and can handle it. 4. fingerprinting has nothing to do with the subject (https to localhost connection). You still can perfectly access localhost from http:// websites. Allowing it from https:// changes nothing. 5. the only reason Mixed content warnings exist is to prevent spoofing or leaking dat to a middle man, which is not the case when http:// points to 127.0.0.1 and not a remote server. There is no middle man between my browser and localhost. Or is there? 1656241 64 ap 2020-05-26 18:19:20 -0700 The fact that localhost connections need to be restricted is not what this bug is about. But it’s relevant context. 1656247 65 homakov 2020-05-26 18:51:09 -0700 Gotta love “the fact” part without any argumentation. Me and a few other people gave argumentations above. No, “fingerprinting threat” and other scriptkiddy attacks do not count as valid reasons to stop a range of use cases of browsers talking to 127.0.0.1 _some way, without forging self-signed SSL certs_ One more observation: you are the *only* person against. Please name any other person here who sees blocking localhost as the only solution, given to us as “a fact”? Not single one, I’m afraid. 1656252 66 antoine 2020-05-26 19:09:40 -0700 Gents we’ve beaten this dead horse. Let’s just get it done. 1656345 67 mcatanzaro 2020-05-27 06:02:55 -0700 (In reply to Alexey Proskuryakov from comment #62) > With the recent reports of websites fingerprinting machines using loopback > connections, it seems even more obvious that this is a technique that needs > to be at least restricted. I agree that's something we probably need to start thinking about, because we have agreed anti-fingerprinting is a priority for WebKit that may take precedence over web compat. But it really has nothing to do with mixed content. Mixed content checks are not a good anti-fingerprinting measure because they can be trivially circumvented by using an http:// URI as the main resource rather than an https:// URI. A rule like "only localhost URIs may access localhost" might make sense to propose in another bug, but even if we do that, the mixed content behavior should still be changed; i.e. there's no need to display a security warning when https://127.0.0.1 loads content from http://127.0.0.1. 1656408 68 ap 2020-05-27 10:11:09 -0700 Of course. We just need to implement the restrictions first, then look into this. 1661483 69 dustin.nielson 2020-06-10 20:19:13 -0700 These are just a few comments and observations about this bug. First there have been several discussions about localhost vs loopback that are outside the scope of this bug so let’s just not address that issue here as it’s going to involve OS level changes before the level of validation comes to the level that it can be trusted to be the exact same as loopback. The actual bug: Content from loopback addresses (e.g. 127.0.0.1) should not be considered mixed content I think a more appropriate description would be something like: “Safari mixed content handling does not comply with web specifications. “ As this more closely describes the actual issue and in my opinion is a critical bug as any change that doesn’t follow specifications is potentially a breaking bug as in this case. There is talk of needing to put restrictions in place before this fix can be implemented. I’m here to argue that fixes for this should not be a Safari specific implementation as it does not solve the potentially described problems for any other browser. My recommendation is those types of changes should be addressed at the application level with entitlements etc… So the fix is universal in nature and solves any potential issues for all browsers. Lastly let's examine the goal that the changed behaviour from spec was trying to address which was to potentially increase security. The actual outcome of this implementation is that web sites are having to recommend using essentially any other browser other than Safari and most likely posting something like this on the page: “We see you’re trying to access this page from Safari. Unfortunately Safari is currently out of web specifications and has limited our ability to support Safari. Please download (list of any other browser) to use this site as intended.” Leading the user to use another browser and bypassing the intended goal this bug was trying to resolve and bypassing all the other great features that Safari does support. This has led to references of Safari being the Internet Explorer of the modern age. In fact Internet Explorer extended web specifications and didn’t break them. It just added proprietary functionality that when implemented by web sites broke other browsers from being able to access the site but allowed I.E. to render (for the most part) any web spec compliant web site. I would love to see this bug resolved asap as I’m close to releasing an application that requires this functionality and I’d much rather push people to upgrade outdated Safari to one that has become spec compliant again vs telling my users they need to just use another browser. 1673088 70 fred.wang 2020-07-20 08:57:06 -0700 Hi. There are a lot of comments in this discussion, I'd just like to try to summarize things and see be sure I understand the situation. == Bug content == This bug is about not treating loopback adresses as mixed content: (1) Required by the specification: 127.0.0.1 and ::1 (2) Optional: localhost and *.localhost In addition for (2) (3) the spec adds the restriction that browsers must ensure they don't resolve to a non-loopback address. == Positions of people == * IIUC Mozilla and Chromium developers implemented (1)+(2)+(3) * Several users expressed their support for (1)+(2). * Maintainers of WebKit Linux ports (at least Michael, but I'm personally in favor too) expressed their support too for aligning with the spec. * Some maintainers of WebKit macOS/iOS ports find the proposed change sensible/ok (Youenn and Maciej) others expressed concerns (Brent and Alexey). Can you please elaborate whether these concerns apply to both (1)+(2) or just (2)? Also, would they be addressed by implementing (3) or do you think the current specs are still too lax and WebKit should keep departing from them? == Development == * Michael and Antonio have investigated this a bit (thanks!). Are you still actively working on this? Do you have patches to share? * Tests are likely to break. We can workaround this for (1) by relying on localhost instead of 127.0.0.1 but at the end we will still need a better solution when we implement (2) such as the one Michael sketched. * Implementing the restriction (3) might require change in low-level libraries. This is already done in GLib but for proprietary ports like macOS/iOS this will be up to Apple to handle it. However gecko and chromium developers implemented this, so it seems they could still be done at the web engine level? 1673096 71 fred.wang 2020-07-20 09:19:31 -0700 (In reply to Frédéric Wang (:fredw) from comment #70) > * IIUC Mozilla and Chromium developers implemented (1)+(2)+(3) Actually, Mozilla does not do (2)+(3) it seems, there is a WIP patch here: https://bugzilla.mozilla.org/show_bug.cgi?id=1220810 1673101 72 mcatanzaro 2020-07-20 09:27:46 -0700 (In reply to Frédéric Wang (:fredw) from comment #70) > Hi. There are a lot of comments in this discussion, I'd just like to try to > summarize things and see be sure I understand the situation. > > == Bug content == > > This bug is about not treating loopback adresses as mixed content: > > (1) Required by the specification: 127.0.0.1 and ::1 > (2) Optional: localhost and *.localhost > > In addition for (2) > > (3) the spec adds the restriction that browsers must ensure they don't > resolve to a non-loopback address. All correct, yes. > * Some maintainers of WebKit macOS/iOS ports find the proposed change > sensible/ok (Youenn and Maciej) others expressed concerns (Brent and > Alexey). Can you please elaborate whether these concerns apply to both > (1)+(2) or just (2)? Also, would they be addressed by implementing (3) or do > you think the current specs are still too lax and WebKit should keep > departing from them? Alexey wants to block non-localhost origins from loading any content from localhost, and he wants that to happen *before* we fix this issue. That's a controversial change that app developers are not going to like. Those concerns apply to both (1)+(2), and implementing (3) would not address them at all, because the goal there is to prevent websites from accessing localhost at all. (In reply to Frédéric Wang (:fredw) from comment #70) > * Michael and Antonio have investigated this a bit (thanks!). Are you still > actively working on this? Do you have patches to share? No, but the required code change for (1) is a one-liner (see comment #46). It's just tests that need work. > * Tests are likely to break. We can workaround this for (1) by relying on > localhost instead of 127.0.0.1 but at the end we will still need a better > solution when we implement (2) such as the one Michael sketched. I think it will need a new TestController setting, yes. Shouldn't be hard. > * Implementing the restriction (3) might require change in low-level > libraries. This is already done in GLib but for proprietary ports like > macOS/iOS this will be up to Apple to handle it. However gecko and chromium > developers implemented this, so it seems they could still be done at the web > engine level? Well Firefox and Chromium control their own network stack, including their own custom DNS resolution. WebKit uses the system network stack, so improvements necessarily have to happen there first. It's not architecturally possible for WebKit to guarantee (3); instead, we just have to assume that the system network stack implements the behavior we want. Currently that is true for the libsoup backend, but not true for Apple. I'm not sure if it's true for the curl backend, but since we haven't checked to see, we should assume not. Now, we could modify DNSResolveQueue to resolve localhost ourselves instead of passing that to the system network stack, but that change would only apply to prefetching. WebKit's actual resource loads are still going to use the system network stack, and changing that would not be desirable. So yes, (2) is blocked on Apple, because only Apple can fix (3). We can do (1), though. 1675920 73 mjs 2020-07-29 00:04:49 -0700 We have the ability to add hooks to know whether `localhost` resolves to a loopback address. We are gathering opinions from folks at Apple on the topic that is the main subject of this bug. 1696199 74 pimterry 2020-10-09 06:08:39 -0700 Any updates on this? Was there a conclusion from the opinion gathering at Apple? I still really need this supported for my application, and right now I still have to tell all Safari users to use a different browser. 1700575 75 pimterry 2020-10-22 02:00:38 -0700 Firefox just announced (https://groups.google.com/g/mozilla.dev.platform/c/sZdEYTiEBdE/m/PbGpLjcqAQAJ) their intent to ship a fix for this for 'localhost' (127.0.0.1 is already treated as trusted, according to https://bugzilla.mozilla.org/show_bug.cgi?id=903966). The Firefox bug for the new localhost fix is here: https://bugzilla.mozilla.org/show_bug.cgi?id=1488740. There's more feedback & use cases listed there that may be of interest. 1700579 76 fred.wang 2020-10-22 02:14:14 -0700 I don't know the status of the internal discussion at Apple, but speaking for Igalia, we plan to go back and check the status/plan again soon... and after we address the Firefox case. 1702305 77 fred.wang 2020-10-28 07:57:27 -0700 I had tried to summarize my understanding in comment 70, but just to be more specific about the spec: mixed content is defined here: https://w3c.github.io/webappsec-mixed-content/#mixed-content which relies on a priori authenticated URL: https://w3c.github.io/webappsec-mixed-content/#a-priori-authenticated-url which itself excludes "Potentially Trustworthy" URLs: https://w3c.github.io/webappsec-secure-contexts/#is-url-trustworthy which itself includes the definition here: https://w3c.github.io/webappsec-secure-contexts/#is-origin-trustworthy 4. includes loopback IP addresses e.g. 127.0.0.1 or ::1 (mentioned here in bug 171934) 5. includes domain names "localhost" and "*.localhost" (mentioned here but also in bug 160504) Point 5. is a MAY conditioned by "ensuring that localhost never resolves to a non-loopback address" see https://w3c.github.io/webappsec-secure-contexts/#localhost Finally DNS resolution of "localhost" and "*.localhost" rely on https://tools.ietf.org/html/draft-west-let-localhost-be-localhost-06#section-3 ; not sure exactly how that applies to WebKit but point 2. requires that applications treat "localhost" and "*.localhost" themselves (without passing by APIs or libraries) while point 3. requires the same for APIs and libraries (without passing by recursive DNS servers). Firefox and Chromium has treated loopback IP addresses as potentially trustworthy for a while and now also treat "localhost" and "*.localhost" specially (they implemented the special case for the resolution of these domains). 1702778 78 mjs 2020-10-29 10:41:29 -0700 For reference, the system DNS resolver on Apple platforms does not necessarily guarantee that localhost maps to loopback, so we do need to figure out how to do the bypass. Not 100% sure how to do this via NSURLSession. I thought it might work to remap http://localhost/ to http://127.0.0.1/ before invoking the HTTP stack, but this will alter the Host header, which may alter behavior. 1702800 79 mcatanzaro 2020-10-29 11:40:37 -0700 (In reply to Frédéric Wang (:fredw) from comment #77) > point 2. requires that > applications treat "localhost" and "*.localhost" themselves (without passing > by APIs or libraries) Note we currently have not implemented this for WPE/GTK, instead we just assume glib is new enough that the default GResolver will do what we want. 1703010 80 fred.wang 2020-10-30 03:01:06 -0700 So I think we are more or less on the same page about the importance of this. My proposal is to start with a simple approach: * Introduce two TrustworthyLoopbackIPAddresses and TrustworthyLocalhostAddresses preferences that can be disabled for the sake of mixed content tests or if we can't guarantee the used APIs don't map localhost adresses to loopback. * The TrustworthyLoopbackIPAddresses pref would do comment 46 i.e. point 4 of https://w3c.github.io/webappsec-secure-contexts/#is-origin-trustworthy * The TrustworthyLocalhostAddresses pref would do point 5 of https://w3c.github.io/webappsec-secure-contexts/#is-origin-trustworthy TrustworthyLoopbackIPAddresses would be enabled on all ports by default. For TrustworthyLocalhostAddresses, we can start as disabled by default and later conditionally enabled depending on the WebKit port or APIs. Note that this won't be following point 2. of https://tools.ietf.org/html/draft-west-let-localhost-be-localhost-06#section-3 since we would delegating the resolution to the APIs, but I'm not sure there is an easy alternative for now, IIUC what Michael and Maciej said. 1703121 81 412772 fred.wang 2020-10-30 10:35:05 -0700 Created attachment 412772 WIP Patch 1703318 82 412836 fred.wang 2020-10-30 23:36:57 -0700 Created attachment 412836 WIP Patch 1703337 83 412843 fred.wang 2020-10-31 08:21:56 -0700 Created attachment 412843 WIP Patch 1704411 84 413159 fred.wang 2020-11-04 07:15:03 -0800 Created attachment 413159 Patch 1704752 85 413263 fred.wang 2020-11-04 23:54:01 -0800 Created attachment 413263 Patch 1774076 86 titouan 2021-07-01 05:17:46 -0700 What's the status here? In Chromium we'd like to start requiring that websites be delivered HTTPS in order to make requests to localhost, but that presupposes that http://localhost is not blocked as mixed content. See also crbug.com/1211244. Also note that the Fetch spec has recently been updated to reflect let-localhost-be-localhost: https://github.com/whatwg/fetch/commit/d20e8c932a639d04fb8251eb6d647fcd54ef47fd 1774077 87 fred.wang 2021-07-01 05:30:02 -0700 (In reply to Titouan Rigoudy from comment #86) > What's the status here? I've personally not made any progress since the experiments done on GTK/WPE ports. AFAIK, these are the current issues: 1) The notion of "secure context" or "potentially trustworthy" implemented in WebKit does not clearly match what is in the spec and is not necessarily unified in one place. This is a non-blocking issue, but it can be a bit confusing and does not help review. 2) Many existing tests in WebKit rely on the fact that localhost/loopback are currently NOT treated as secure in order to check mixed content and similar features. See bug 127676 comment 15. 3) There are concerns discussed in the thread above about exposing more "local stuff" to the web. It seems to me this is orthogonal to the issue here but (IIUC) some Apple devs think this should be addressed first. See also bug 218623. 4) It's not really clear we can follow Firefox/Chromium's approach (as described in the let-localhost-be-localhost spec) which is to make the browser override any DNS or library resolution and force the "localhost" host name to really correspond to a loopback address. See also comment 78 In order to work around these issues, I experimented with GTK/WPE first ( https://bugs.webkit.org/show_bug.cgi?id=218627 and https://bugs.webkit.org/show_bug.cgi?id=219257 ). In particular, for these platforms we are sure libsoup resolves "localhost" to a loopback address, so (4) is not a problem. Regarding (3), it's possible that the "private network requests" spec you've been working on could help ; see bug 171934 comment 78. Maybe we should work on this first. But again, I can't speak for Apple... 1774101 88 mkwst 2021-07-01 07:09:53 -0700 +wilander@, since we talked about this on Twitter yesterday. 1774103 89 wilander 2021-07-01 07:15:12 -0700 (In reply to Titouan Rigoudy from comment #86) > What's the status here? > > In Chromium we'd like to start requiring that websites be delivered HTTPS in > order to make requests to localhost, but that presupposes that > http://localhost is not blocked as mixed content. See also crbug.com/1211244. > > Also note that the Fetch spec has recently been updated to reflect > let-localhost-be-localhost: > https://github.com/whatwg/fetch/commit/ > d20e8c932a639d04fb8251eb6d647fcd54ef47fd The status here is that what Chrome now wants to do is exactly what we argued should be done already in 2017 and Chrome, Firefox, and Edge didn’t want to do it at the time. We have always argued that the right step is to block localhost on non-localhost HTTP pages and only allow it on HTTPS pages or on pages from localhost itself. 1774104 90 mkwst 2021-07-01 07:19:40 -0700 I'm excited to hear that we have agreement on a path forward! 1774130 91 titouan 2021-07-01 08:47:38 -0700 That's great! I think it indeed means we agree on both points: 1) https://example.com should be able to make subresource requests to http://localhost 2) http://example.com should not This bug focuses on making #1 a reality in WebKit. Private Network Access focuses on fixing #2, but is experiencing difficulties because of this bug. It sounds like the next step is for a reviewer to work with Frederic to land his patches? 1774141 92 wilander 2021-07-01 09:24:50 -0700 (In reply to Titouan Rigoudy from comment #91) > That's great! I think it indeed means we agree on both points: > > 1) https://example.com should be able to make subresource requests to > http://localhost > > 2) http://example.com should not > > This bug focuses on making #1 a reality in WebKit. Private Network Access > focuses on fixing #2, but is experiencing difficulties because of this bug. > > It sounds like the next step is for a reviewer to work with Frederic to land > his patches? Nope. This may be a misunderstanding. For me and what I’ve communicated, these two go in tandem. We don’t want to “allow more localhost connections.” Allowing then on HTTPS pages without blocking them on HTTP is effectively “allow more localhost connections.” This is exactly why this isn’t moving. People come back and want 1) without 2) and that’s not the right move. That’s the 2017 disagreement all over again. 1774145 93 alexander 2021-07-01 09:47:52 -0700 The 2017 disagreement still exists because Webkit devs are failing to: 1) Understand that there are valid use cases for a website to want to communicate with localhost. Luca Cipriani gave an excellent example of a valid use case. More on that in a few lines. 2) Failing to provide any alternative method / suggestions about how to overcome the problems originated from preventing this bug / request to be fixed. You're sitting on the "no" position without trying to work with people which have valid reasons to be asking what they are asking. More on "1": I could give you another argument, yet very similar to Luca's: We're working on a webtool that should interact with a CLI tool running a server on localhost. There is absolutely no reason whatsoever for the webtool to be sending user information to a remote server so then the CLI tool can fetch that same data. It's literally less secure doing so rather than just allowing the webtool to send requests directly to the CLI tool's localhost server. And making users use our webtool on HTTP just defies any security practices, which is your main argument for not honouring this bug/request in the first place. To sum up, unless I've totally misunderstood this entire 4-years long conversation, you're suggestions so far are: 1) "Don't do that. I'm not sure why you want to do it, but don't do it because your use case is not valid." 2) "Serve your webtool over insecure HTTP, because we're concerned that allowing mixed content on requests to localhost from HTTPS context will be a security risk". 1774151 94 mcatanzaro 2021-07-01 10:16:17 -0700 (In reply to John Wilander from comment #89) > The status here is that what Chrome now wants to do is exactly what we > argued should be done already in 2017 and Chrome, Firefox, and Edge didn’t > want to do it at the time. We have always argued that the right step is to > block localhost on non-localhost HTTP pages and only allow it on HTTPS pages > or on pages from localhost itself. Blocking localhost access from http:// URIs seems entirely uncontroversial. There's no way that should continue to be allowed. Alexey's previous position in this bug was that *all* access to localhost from non-localhost origins should be blocked. That's the main reason this bug was stalled. If Apple is indeed now willing to allow access from non-localhost https:// origins, then there's no longer any substantial disagreement here. 1774399 95 titouan 2021-07-02 02:54:55 -0700 > Nope. This may be a misunderstanding. For me and what I’ve communicated, these two go in tandem. We don’t want to “allow more localhost connections.” Allowing then on HTTPS pages without blocking them on HTTP is effectively “allow more localhost connections.” I see. I guess I fail to understand the reasoning behind this stance. I could understand it if shipping #1 presented real risks to WebKit's ability to ship #2. Then indeed, one would not want to paint oneself in a corner. I believe the opposite is true, however. Shipping #1 (fixing this bug and aligning with the spec) would indeed effectively "allow more localhost connections", but only those you yourself want everyone to migrate towards. Web developers can then develop secure web applications that interact with loopback, and WebKit users' security is better off as a result. Reaching for a metaphor: digging a new, straighter canal will only reduce the flow through the existing riverbed you wish to seal off. This then enables you to ship #2: you can then tell web developers to upgrade their web apps to HTTPS if they want to keep making requests to loopback. Otherwise, if you try to ship #2, a lot of angry web developers will inevitably tell you there is no viable alternative to the behavior you are deprecating. I myself am trying to ship #2 in Chromium, where #1 has shipped for a while, and it already is hard enough compatibility-wise without this added hurdle. Please accept my cautionary tale! 1814022 96 gsnedders 2021-11-11 07:09:58 -0800 To try to summarise the disagreements here (I think bug 171934 comment 87 is a good summary of the technical aspects): 1. The Secure Context spec requires 127.0.0.1/8 and ::1/128 to be "Potentially Trustworthy", whereas in WebKit they are currently "Not Trustworthy". 1a. This means currently in WebKit http://example.com can run fetch("http://127.0.0.1") successfully, but https://example.com cannot, as in the latter case it is blocked as mixed content. Per spec both should succeed. 2. The Secure Context spec requires localhost to be "Potentially Trustworthy" *if the user agent conforms to the name resolution rules in [let-localhost-be-localhost]*, whereas in WebKit they are currently (unconditionally) "Not Trustworthy". 2a. To implement this correctly, WebKit needs to know whether the port-mediated DNS resolution layer (which, e.g., for Apple ports is in other system libraries) does conform to those rules. There are a variety of possible approaches here: either hardcoding knowledge of "this version-or-later of the library conforms", or the library exposing an API which tells us whether or not it does. 2b. This means currently in WebKit http://example.com can run fetch("http://localhost") successfully, but https://example.com cannot, as in the latter case it is blocked as mixed content. Per spec both should succeed. 3. We have seen a number of attacks (both security and privacy) against servers running on localhost, hence there's a strong incentive against extending the ability to access localhost from the public web. At the moment, it is possible to execute such attacks from sites served from HTTP, but this at least prevents the majority of page loads (which happen from HTTPS) from being able to exploit them. 3a. There are a number of proposals to mitigate this, most obviously the Private Network Access spec (https://wicg.github.io/private-network-access/) which only allows secure contexts to access private networks and only after a CORS preflight. I _believe_ the case is that people are fine with making progress on (1) and/or (2) if-and-only-if mitigation to (3) happens (and I believe the case is that the general view is Private Network Access is sufficient mitigation), and what we don't want to do is land (1) and/or (2) _before_ mitigation to (3) lands. (Or, at the very least, don't want to land them with them enabled-by-default. One could imagine them all landing in parts behind flags and then ultimately flipping the flags all at once.) 1814025 97 wilander 2021-11-11 07:36:24 -0800 That’s a good summary, except that I’d add that whatever specs say, we’ve been clear on this in the WebAppSec WG since when it was originally discussed. This is not a case of WebKit making excuses or coming up with explanations after the fact. History has also shown that we were right to suspect that *disabling* access to localhost from non-secure contexts would take a long time and not follow shortly if we just *enabled* access in secure contexts first. 1822590 98 fred.wang 2021-12-10 02:10:19 -0800 Removing myself from assignee since I'm not working on this anymore. 1896114 99 tobi 2022-09-04 01:41:21 -0700 Any updates on this? Seem to still be an issue today, in Safari 1896115 100 tobi 2022-09-04 01:49:39 -0700 Any updates on this? Is the only solution to this to proxy via a web server (just to support Safari) - I've resorted to doing this and it's super inefficient. 1896116 101 tobi 2022-09-04 01:53:50 -0700 How does Postman.com get around this issue on Mac OS? They run a local agent that sits behind a HTTP server at http://localhost:10533 1904807 102 pimento_trolls.0a 2022-10-11 09:54:48 -0700 Can we mark this as blocking 160504 as well? (https://bugs.webkit.org/show_bug.cgi?id=160504#add_comment) With the release of Safari 16, and the general push for passkeys adoption, having a stable, no-nonsense development environment for websites & apps to locally develop their passkey implementation is crucial. Being able to use `*.localhost` subdomains makes it extremely easy in Chrome/Firefox, since they tag the requests as being in a Secure Context; enabling WebAuthn. 1960097 103 jaime 2023-06-06 11:56:43 -0700 Hi everyone - now that Safari 17 Beta is out, are there any updates / planned work on this issue? Thank you! 1964376 104 slzfgs+1gpdcqish2o18 2023-06-29 17:33:10 -0700 Brave Browser added this bug as a feature: https://brave.com/privacy-updates/27-localhost-permission/ > As mentioned, most other browsers do not significantly prevent websites from accessing localhost resources. The desktop versions of Firefox and Chrome allow both secure and insecure public sites to access localhost resources, and seem to intend to allow public secure sites to access localhost resources indefinitely. > As a side-effect of security restrictions, Safari currently blocks requests to localhost resources (as do other WebKit browsers) from secure public websites. But to the best of our understanding, Safari does not explicitly intend to block these requests from public websites. > As far as we can tell, Brave is the only browser that will block requests to localhost resources from both secure and insecure public sites, while still maintaining a compatibility path for sites that users trust (in the form of the discussed localhost permission). 2074769 105 jaffathecake 2024-11-13 03:25:52 -0800 At Shopify we hit this issue when trying to offer a developer experience for "embedded apps", which are basically third party iframes embedded in admin.shopify.com. To help the development of these "embedded apps", we wanted to offer a way for developers to see their localhost app running within admin.shopify.com. This works in Chrome and Firefox but not Safari. 2074772 106 jaffathecake 2024-11-13 03:51:25 -0800 Fwiw, we are happy to use 127.0.0.1 rather than localhost, in case that makes a difference. 2075429 107 julian 2024-11-15 12:20:51 -0800 Just to keep this moving in the right direction. We have built a standalone app which allows professional photographers to sort their images before uploading them, this is really easy to do by having them specify a working directory that is then hosted by a local Kestral server on 127.0.0.1, then our main site which operates over https, can see the images on the user's local system. At the moment, we have to tell our users to use Chrome or Edge and not Safari. Thanks for listening! 2076340 108 adomas.ven 2024-11-19 22:44:22 -0800 To add to this, we are working on a Word JS extension to be run on Word for Mac for Zotero and like all existing Zotero integrations with Word processors, it needs to communicate to the Zotero application running a server on localhost to facilitate citing. This is both a performance and privacy concern, as remote alternatives would be much slower and require users to upload their research libraries to the cloud. Microsoft embeds WebKit into Microsoft Word for JS extension functionality, and requires the extensions to be hosted on HTTPS origins, which means that our Word JS extension running in Microsoft Word cannot communicate to our localhost Zotero server due to this WebKit restriction. Unlike in the browser case, our Word for Mac users have no alternative bar switching to a different OS. 2076341 109 adomas.ven 2024-11-19 22:47:12 -0800 The Zotero Word JS extension is also designed to work with Word Online, which means that while it works fine on all modern browsers (Chrome, Edge, Firefox and others), it doesn't on Safari due to the same restriction. While we have a workaround that we can offer to our users for Word Online, we would like it to work on Safari too. 2111429 110 ashokgelal 2025-04-16 19:31:01 -0700 My use case with https://msty.app is that we have a browser/pwa app that can connect to Ollama running locally at http://localhost:11434. This has no issue with other browsers but Safari. Users are asking why Safari is not supported and I've to point to this issue. Right now a work around is creating a free Cloudflare tunnel but that's a hassle and I don't think is any more secure. 2122324 111 bfulgham 2025-06-07 09:17:07 -0700 Interesting that despite the claims of safety by some in this thread, two very large tracking companies have been caught used this “feature” in Android to enable browser-to-app-to-browser data sharing. https://localmess.github.io/ 2122340 112 alexandernst 2025-06-07 14:01:39 -0700 (In reply to Brent Fulgham from comment #111) > Interesting that despite the claims of safety by some in this thread, two very large tracking companies have been caught used this “feature” in Android to enable browser-to-app-to-browser data sharing. As stated by the own researchers who discovered this bug, the issue is possible because Android allows apps to open sockets on lo and keep listening in the background (on the contrary, restrictions on iOS appear to have avoided this problem). Imho this is on Android, not web browsers allowing access to localhost (which is what I think you imply, Brent). Sending requests to localhost has valid use cases (several examples given in this thread). 2122343 113 wilander 2025-06-07 14:25:57 -0700 I believe Brent is commenting on the broader issue of allowing connections to localhost without any additional restrictions or safety measures. Back in 2015-2016 when this was discussed in W3C WebAppSec, we argued that we should have fewer connections to localhost, not more. Other browsers decided to open up more opportunities to connect to localhost by allowing it from both secure and non-secure contexts. Since then, we’ve kept arguing for restrictions on localhost connections, not in the least because it’s been found to be abused for port scanning, contributing to fingerprinting. At last year’s W3C TPAC, I felt there was finally some interest in our ideas, for instance a ”latch mode” where only one localhost port is allowed for some scope of access. We’d love to solve for legitimate use cases, but we’ve been pretty much alone in bringing up the privacy downsides and we didn’t get much traction early on on the security side either. 2122345 114 wilander 2025-06-07 14:29:47 -0700 ”According to spec” fails to acknowledge that we were opposed. The fact that two implementations provides a path to standardization does not mean all implementations are forced to adopt, especially when they raised issues before it became standard. 2122377 115 jaime 2025-06-07 23:57:40 -0700 There is a new proposal from the Chrome team requiring that the user grants permission to the initiating website (similar to the notifications or location prompts) to make connections to their local network. This could be a good standard solution across browsers that would satisfy Webkit's privacy and security focus while it solves for legitimate uses cases. https://github.com/explainers-by-googlers/local-network-access 2122390 116 wilander 2025-06-08 05:15:21 -0700 (In reply to Jaime Rivas from comment #115) > There is a new proposal from the Chrome team requiring that the user grants > permission to the initiating website (similar to the notifications or > location prompts) to make connections to their local network. This could be > a good standard solution across browsers that would satisfy Webkit's privacy > and security focus while it solves for legitimate uses cases. > https://github.com/explainers-by-googlers/local-network-access Prompting users is our last resort, and often not a solution to privacy and security problems. Regular users have no idea what the implications of allowing a connection are. They can’t judge whether it’s reasonable or not for a website to say it *has to* have access. Alternatives we like in general when prompts are brought up: • Restricting access so that legitimate use works but abuse doesn’t. That’s where the latch mode idea comes from. The site gets to access one port, and once it has made its choice, all other ports are blocked. That prevents port scanning and significantly reduces security exposure. It can be combined with prompts in several ways (prompt on the one port, prompt on subsequent ports) if user agents want. • A picker. Can the user be presented with a picker where they pick what they want to share? That is often much better than granting general, broad access. • Context-specific prompt. Can the prompt be made to trigger only when it makes sense? That helps users understand and make the right choice. To give a counter example, it’s almost never good to allow pages to prompt on load. • Limiting access and prompting to the first party. • Limiting access and prompting to sites where the user is logged in. This requires the Login Status API which we proposed in 2019. 2190472 117 948508913 2026-03-15 21:51:24 -0700 Is there any new progress on this issue? The current behavior creates practical problems for applications that need to communicate with local services. In the project I am currently working on, the web page needs to connect to two ports on a local client using ws. Treating localhost as a non-secure context makes it impossible for my local client to upgrade to wss. In practice, this would require an HTTPS domain pointing to the local machine (since a local IP cannot obtain an SSL certificate), and the HTTPS certificate would also need to be distributed together with the client application, which introduces additional security risks. As a result, I am forced to use nginx to detect whether the browser is Safari and downgrade the connection to HTTP for Safari specifically. Ironically, this means Safari ends up using a less secure setup compared to other browsers. 2193500 118 erik 2026-03-25 06:55:54 -0700 Hi everyone, not trying to add noise, just want to add another datapoint. At Spiideo (sports video streaming platform) we need to talk to appliances on the local network like video encoders of different kinds: USB, IP, etc. We also need to do this without internet access (PWA mode). Our strategy for this is a companion application that the web browser can talk to on 127.0.0.1. This works fine in Chrome and Firefox. Many of our users use macs and a significant amount of those use Safari. To be able to handle the connected appliances, we have to ask them to use Chrome. This adds friction for us, and it requires the users to move away from their preferred browser (Safari). We can probably adapt to whichever way this is solved in Safari, any of the proposed methods above would do, but currently we are blocked. 412772 2020-10-30 10:35:05 -0700 2020-10-30 23:36:57 -0700 WIP Patch 0001-localhost.patch text/plain 16304 fred.wang RnJvbSBjMGRmMmQ5ZmViNDdjYTViOGM1YmZhZjM2MmE3Njg2MjM5NWFiN2M2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBGcmVkZXJpYyBXYW5nIDxmd2FuZ0BpZ2FsaWEuY29tPgpEYXRl OiBGcmksIDMwIE9jdCAyMDIwIDE3OjQxOjMwICswMTAwClN1YmplY3Q6IFtQQVRDSCB4c2VydmVy XSBsb2NhbGhvc3QKCi0tLQogLi4uU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odHRw cy5odG1sIHwgIDIgKy0KIC4uLi9pbnNlY3VyZS1jc3Mtd2l0aC1zZWN1cmUtY29va2llcy5odG1s ICAgICB8ICAyICstCiAuLi5yZS1leGVjdXRhYmxlLWNzcy13aXRoLXNlY3VyZS1jb29raWVzLmh0 bWwgfCAgMiArLQogLi4uY3QtaHR0cHMtdG8taHR0cC1pZnJhbWUtaW4tbWFpbi1mcmFtZS5odG1s IHwgIDEgKwogLi4ucHMtdG8taHR0cC1pbWFnZS1zZWN1cmUtY29va2llcy1ibG9jay5odG1sIHwg IDIgKy0KIC4uLmN0LWh0dHBzLXRvLWh0dHAtaW1hZ2Utc2VjdXJlLWNvb2tpZXMuaHRtbCB8ICAy ICstCiAuLi5kaXJlY3QtaHR0cHMtdG8taHR0cC1zY3JpcHQtaW4taWZyYW1lLmh0bWwgfCAgMSAr CiAuLi4vaW5zZWN1cmUtd2Vic29ja2V0LWluLWlmcmFtZS5odG1sICAgICAgICAgfCAgMSArCiAu Li4vaW5zZWN1cmUtd2Vic29ja2V0LWluLW1haW4tZnJhbWUuaHRtbCAgICAgfCAgMSArCiAuLi4v V2ViUHJlZmVyZW5jZXNFeHBlcmltZW50YWwueWFtbCAgICAgICAgICAgfCAyNiArKysrKysrKysr KysrKysrCiBTb3VyY2UvV2ViQ29yZS9odG1sL3BhcnNlci9YU1NBdWRpdG9yLmNwcCAgICAgfCAg MiArLQogU291cmNlL1dlYkNvcmUvbG9hZGVyL01peGVkQ29udGVudENoZWNrZXIuY3BwIHwgMTMg KysrKy0tLS0KIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9NaXhlZENvbnRlbnRDaGVja2VyLmggICB8 ICAzICstCiBTb3VyY2UvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmNwcCAgICAgICAgfCAz MCArKysrKysrKysrKysrKysrKysrCiBTb3VyY2UvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2lu LmggICAgICAgICAgfCAgNiArKysrCiAxNSBmaWxlcyBjaGFuZ2VkLCA4MiBpbnNlcnRpb25zKCsp LCAxMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Nl Y3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1iYXNpYy1hdXRoLWltYWdlLWFsbG93Q3Jvc3NP cmlnaW5TdWJyZXNvdXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzLmh0dHBzLmh0bWwgYi9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1iYXNpYy1hdXRo LWltYWdlLWFsbG93Q3Jvc3NPcmlnaW5TdWJyZXNvdXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzLmh0 dHBzLmh0bWwKaW5kZXggZmQ5NzgzOTJiYzk1Li5jNjIwZDE4NTM0NTAgMTAwNjQ0Ci0tLSBhL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWJhc2lj LWF1dGgtaW1hZ2UtYWxsb3dDcm9zc09yaWdpblN1YnJlc291cmNlc1RvQXNrRm9yQ3JlZGVudGlh bHMuaHR0cHMuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVk Q29udGVudC9pbnNlY3VyZS1iYXNpYy1hdXRoLWltYWdlLWFsbG93Q3Jvc3NPcmlnaW5TdWJyZXNv dXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzLmh0dHBzLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURP Q1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIEFsbG93Q3Jvc3NPcmlnaW5TdWJy ZXNvdXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzPXRydWUgXSAtLT4KKzwhRE9DVFlQRSBodG1sPjwh LS0gd2Via2l0LXRlc3QtcnVubmVyIFsgQWxsb3dDcm9zc09yaWdpblN1YnJlc291cmNlc1RvQXNr Rm9yQ3JlZGVudGlhbHM9dHJ1ZSBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRk cmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8aGVhZD4KIDxzY3JpcHQgc3JjPSIv anMtdGVzdC1yZXNvdXJjZXMvanMtdGVzdC5qcyI+PC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1jc3Mtd2l0 aC1zZWN1cmUtY29va2llcy5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9t aXhlZENvbnRlbnQvaW5zZWN1cmUtY3NzLXdpdGgtc2VjdXJlLWNvb2tpZXMuaHRtbAppbmRleCA5 NDRiN2M1OGE5YjMuLjFlNDU3ZGNmMzc5OCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtY3NzLXdpdGgtc2VjdXJlLWNvb2tp ZXMuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVu dC9pbnNlY3VyZS1jc3Mtd2l0aC1zZWN1cmUtY29va2llcy5odG1sCkBAIC0xLDQgKzEsNCBAQAot PCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBb IGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNl IF0gLS0+CiA8aHRtbD4KIDxib2R5PgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWV4ZWN1dGFibGUtY3Nz LXdpdGgtc2VjdXJlLWNvb2tpZXMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJp dHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWV4ZWN1dGFibGUtY3NzLXdpdGgtc2VjdXJlLWNvb2tp ZXMuaHRtbAppbmRleCA0MTEzZDIzOWFjODkuLjM5MGE1OTk3YWUwZSAxMDA2NDQKLS0tIGEvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtZXhlY3V0 YWJsZS1jc3Mtd2l0aC1zZWN1cmUtY29va2llcy5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWV4ZWN1dGFibGUtY3NzLXdpdGgt c2VjdXJlLWNvb2tpZXMuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFE T0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3 b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8Ym9k eT4KIDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5 L21peGVkQ29udGVudC9yZWRpcmVjdC1odHRwcy10by1odHRwLWlmcmFtZS1pbi1tYWluLWZyYW1l Lmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRp cmVjdC1odHRwcy10by1odHRwLWlmcmFtZS1pbi1tYWluLWZyYW1lLmh0bWwKaW5kZXggOTkzNDY0 ZjhjYTY0Li4xM2I0OWU0ZmFmMGMgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv c2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHBzLXRvLWh0dHAtaWZyYW1lLWluLW1h aW4tZnJhbWUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVk Q29udGVudC9yZWRpcmVjdC1odHRwcy10by1odHRwLWlmcmFtZS1pbi1tYWluLWZyYW1lLmh0bWwK QEAgLTEsMyArMSw0IEBACis8IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpU cnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4K IDxib2R5PgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2Vj dXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHBzLXRvLWh0dHAtaW1hZ2Utc2VjdXJlLWNv b2tpZXMtYmxvY2suaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRD b250ZW50L3JlZGlyZWN0LWh0dHBzLXRvLWh0dHAtaW1hZ2Utc2VjdXJlLWNvb2tpZXMtYmxvY2su aHRtbAppbmRleCA4MTRmNjhiYTkzOTMuLjFlNGI2MmMwMThmNSAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cHMtdG8t aHR0cC1pbWFnZS1zZWN1cmUtY29va2llcy1ibG9jay5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHBzLXRvLWh0dHAtaW1h Z2Utc2VjdXJlLWNvb2tpZXMtYmxvY2suaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBo dG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50 YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0 bWw+CiA8Ym9keT4KIDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVjdC1odHRwcy10by1odHRwLWltYWdlLXNlY3Vy ZS1jb29raWVzLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29u dGVudC9yZWRpcmVjdC1odHRwcy10by1odHRwLWltYWdlLXNlY3VyZS1jb29raWVzLmh0bWwKaW5k ZXggY2RhODAyZDAzMGE5Li4wNTkxN2M4NjI4NDkgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHBzLXRvLWh0dHAtaW1h Z2Utc2VjdXJlLWNvb2tpZXMuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3Vy aXR5L21peGVkQ29udGVudC9yZWRpcmVjdC1odHRwcy10by1odHRwLWltYWdlLXNlY3VyZS1jb29r aWVzLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1s PjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJh Y2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGJvZHk+CiA8c2NyaXB0 PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRl bnQvcmVkaXJlY3QtaHR0cHMtdG8taHR0cC1zY3JpcHQtaW4taWZyYW1lLmh0bWwgYi9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVjdC1odHRwcy10by1o dHRwLXNjcmlwdC1pbi1pZnJhbWUuaHRtbAppbmRleCBhYTJhY2NlNzk5MTcuLmYyYjVkMTljYjE3 MSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRl bnQvcmVkaXJlY3QtaHR0cHMtdG8taHR0cC1zY3JpcHQtaW4taWZyYW1lLmh0bWwKKysrIGIvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cHMt dG8taHR0cC1zY3JpcHQtaW4taWZyYW1lLmh0bWwKQEAgLTEsMyArMSw0IEBACis8IS0tIHdlYmtp dC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNz ZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxib2R5PgogPHNjcmlwdD4KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3dlYnNvY2tl dC9pbnNlY3VyZS13ZWJzb2NrZXQtaW4taWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3NlY3VyaXR5L21peGVkQ29udGVudC93ZWJzb2NrZXQvaW5zZWN1cmUtd2Vic29ja2V0LWlu LWlmcmFtZS5odG1sCmluZGV4IDZiYzU0YzhkMzcyZi4uMmU1MGIzY2QzOTI5IDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC93ZWJzb2NrZXQv aW5zZWN1cmUtd2Vic29ja2V0LWluLWlmcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3dlYnNvY2tldC9pbnNlY3VyZS13ZWJzb2NrZXQt aW4taWZyYW1lLmh0bWwKQEAgLTEsMyArMSw0IEBACis8IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBb IGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNl IF0gLS0+CiA8c2NyaXB0PgogaWYgKHdpbmRvdy50ZXN0UnVubmVyKQogICAgIHRlc3RSdW5uZXIu ZHVtcEFzVGV4dCgpOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9taXhlZENvbnRlbnQvd2Vic29ja2V0L2luc2VjdXJlLXdlYnNvY2tldC1pbi1tYWluLWZyYW1l Lmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC93ZWJz b2NrZXQvaW5zZWN1cmUtd2Vic29ja2V0LWluLW1haW4tZnJhbWUuaHRtbAppbmRleCBkMzNkOTEz M2E4YWEuLmE1ZDE0NzYyY2RiZSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9z ZWN1cml0eS9taXhlZENvbnRlbnQvd2Vic29ja2V0L2luc2VjdXJlLXdlYnNvY2tldC1pbi1tYWlu LWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENv bnRlbnQvd2Vic29ja2V0L2luc2VjdXJlLXdlYnNvY2tldC1pbi1tYWluLWZyYW1lLmh0bWwKQEAg LTEsMyArMSw0IEBACis8IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVz dHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxi b2R5PgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvU2NyaXB0cy9QcmVmZXJlbmNl cy9XZWJQcmVmZXJlbmNlc0V4cGVyaW1lbnRhbC55YW1sIGIvU291cmNlL1dURi9TY3JpcHRzL1By ZWZlcmVuY2VzL1dlYlByZWZlcmVuY2VzRXhwZXJpbWVudGFsLnlhbWwKaW5kZXggNDVmYjBiNzk1 ODQ1Li5kMzVjMGI5M2NmYmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvU2NyaXB0cy9QcmVmZXJl bmNlcy9XZWJQcmVmZXJlbmNlc0V4cGVyaW1lbnRhbC55YW1sCisrKyBiL1NvdXJjZS9XVEYvU2Ny aXB0cy9QcmVmZXJlbmNlcy9XZWJQcmVmZXJlbmNlc0V4cGVyaW1lbnRhbC55YW1sCkBAIC04MDIs NiArODAyLDMyIEBAIFRyYW5zZm9ybVN0cmVhbUFQSUVuYWJsZWQ6CiAgICAgV2ViS2l0OgogICAg ICAgZGVmYXVsdDogdHJ1ZQogCisjIGh0dHBzOi8vdzNjLmdpdGh1Yi5pby93ZWJhcHBzZWMtc2Vj dXJlLWNvbnRleHRzLyNpcy1vcmlnaW4tdHJ1c3R3b3J0aHkKK1RydXN0d29ydGh5TG9jYWxob3N0 QWRkcmVzc2VzRW5hYmxlZDoKKyAgdHlwZTogYm9vbAorICBodW1hblJlYWRhYmxlTmFtZTogIlRy dXN0d29ydGh5IGxvY2FsaG9zdCBhZGRyZXNzZXMiCisgIGh1bWFuUmVhZGFibGVEZXNjcmlwdGlv bjogIlRyZWF0IGhvc3RzIG1hdGNoaW5nICdsb2NhbGhvc3QnLCBvciBmYWxsaW5nIHdpdGhpbiAn LmxvY2FsaG9zdCcsIGFzICdQb3RlbnRpYWxseSBUcnVzdHdvcnRoeScuIgorICBkZWZhdWx0VmFs dWU6CisgICAgV2ViS2l0TGVnYWN5OgorICAgICAgZGVmYXVsdDogZmFsc2UKKyAgICBXZWJLaXQ6 CisgICAgICBkZWZhdWx0OiBmYWxzZQorICAgIFdlYkNvcmU6CisgICAgICBkZWZhdWx0OiBmYWxz ZQorCisjIGh0dHBzOi8vdzNjLmdpdGh1Yi5pby93ZWJhcHBzZWMtc2VjdXJlLWNvbnRleHRzLyNp cy1vcmlnaW4tdHJ1c3R3b3J0aHkKK1RydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJs ZWQ6CisgIHR5cGU6IGJvb2wKKyAgaHVtYW5SZWFkYWJsZU5hbWU6ICJUcnVzdHdvcnRoeSBsb29w YmFjayBJUCBhZGRyZXNzZXMiCisgIGh1bWFuUmVhZGFibGVEZXNjcmlwdGlvbjogIlRyZWF0IGhv c3RzIG1hdGNoaW5nIG9uZSBvZiB0aGUgQ0lEUiBub3RhdGlvbnMgMTI3LjAuMC4wLzggb3IgOjox LzEyOCBhcyAnUG90ZW50aWFsbHkgVHJ1c3R3b3J0aHknLiIKKyAgZGVmYXVsdFZhbHVlOgorICAg IFdlYktpdExlZ2FjeToKKyAgICAgIGRlZmF1bHQ6IHRydWUKKyAgICBXZWJLaXQ6CisgICAgICBk ZWZhdWx0OiB0cnVlCisgICAgV2ViQ29yZToKKyAgICAgIGRlZmF1bHQ6IHRydWUKKwogVXNlckdl c3R1cmVQcm9taXNlUHJvcGFnYXRpb25FbmFibGVkOgogICB0eXBlOiBib29sCiAgIGh1bWFuUmVh ZGFibGVOYW1lOiAiVXNlckdlc3R1cmUgUHJvbWlzZSBQcm9wYWdhdGlvbiIKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2h0bWwvcGFyc2VyL1hTU0F1ZGl0b3IuY3BwIGIvU291cmNlL1dlYkNv cmUvaHRtbC9wYXJzZXIvWFNTQXVkaXRvci5jcHAKaW5kZXggYmNiODg1ZWFkZDczLi42NDEzYjhi YjMxYzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvcGFyc2VyL1hTU0F1ZGl0b3Iu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvcGFyc2VyL1hTU0F1ZGl0b3IuY3BwCkBAIC0z MjQsNyArMzI0LDcgQEAgdm9pZCBYU1NBdWRpdG9yOjppbml0KERvY3VtZW50KiBkb2N1bWVudCwg WFNTQXVkaXRvckRlbGVnYXRlKiBhdWRpdG9yRGVsZWdhdGUpCiAKICAgICAgICAgaWYgKChtX3hz c1Byb3RlY3Rpb24gPT0gWFNTUHJvdGVjdGlvbkRpc3Bvc2l0aW9uOjpFbmFibGVkIHx8IG1feHNz UHJvdGVjdGlvbiA9PSBYU1NQcm90ZWN0aW9uRGlzcG9zaXRpb246OkJsb2NrRW5hYmxlZCkgJiYg IXBhcnNlZFJlcG9ydFVSTC5pc0VtcHR5KCkpIHsKICAgICAgICAgICAgIHJlcG9ydFVSTCA9IGRv Y3VtZW50LT5jb21wbGV0ZVVSTChwYXJzZWRSZXBvcnRVUkwpOwotICAgICAgICAgICAgaWYgKE1p eGVkQ29udGVudENoZWNrZXI6OmlzTWl4ZWRDb250ZW50KGRvY3VtZW50LT5zZWN1cml0eU9yaWdp bigpLCByZXBvcnRVUkwpKSB7CisgICAgICAgICAgICBpZiAoTWl4ZWRDb250ZW50Q2hlY2tlcjo6 aXNNaXhlZENvbnRlbnQoZG9jdW1lbnQtPnNldHRpbmdzKCksIGRvY3VtZW50LT5zZWN1cml0eU9y aWdpbigpLCByZXBvcnRVUkwpKSB7CiAgICAgICAgICAgICAgICAgZXJyb3JEZXRhaWxzID0gImlu c2VjdXJlIHJlcG9ydGluZyBVUkwgZm9yIHNlY3VyZSBwYWdlIjsKICAgICAgICAgICAgICAgICBt X3hzc1Byb3RlY3Rpb24gPSBYU1NQcm90ZWN0aW9uRGlzcG9zaXRpb246OkludmFsaWQ7CiAgICAg ICAgICAgICAgICAgcmVwb3J0VVJMID0gVVJMKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9sb2FkZXIvTWl4ZWRDb250ZW50Q2hlY2tlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIv TWl4ZWRDb250ZW50Q2hlY2tlci5jcHAKaW5kZXggYTdiNmJmNjczYWQ2Li4zZmMwZTg0ZjZhYjkg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9NaXhlZENvbnRlbnRDaGVja2VyLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvTWl4ZWRDb250ZW50Q2hlY2tlci5jcHAKQEAg LTUzLDE4ICs1MywyMSBAQCBGcmFtZUxvYWRlckNsaWVudCYgTWl4ZWRDb250ZW50Q2hlY2tlcjo6 Y2xpZW50KCkgY29uc3QKIH0KIAogLy8gc3RhdGljCi1ib29sIE1peGVkQ29udGVudENoZWNrZXI6 OmlzTWl4ZWRDb250ZW50KFNlY3VyaXR5T3JpZ2luJiBzZWN1cml0eU9yaWdpbiwgY29uc3QgVVJM JiB1cmwpCitib29sIE1peGVkQ29udGVudENoZWNrZXI6OmlzTWl4ZWRDb250ZW50KGNvbnN0IFNl dHRpbmdzJiBzZXR0aW5ncywgU2VjdXJpdHlPcmlnaW4mIHNlY3VyaXR5T3JpZ2luLCBjb25zdCBV UkwmIHVybCkKIHsKICAgICBpZiAoc2VjdXJpdHlPcmlnaW4ucHJvdG9jb2woKSAhPSAiaHR0cHMi KQogICAgICAgICByZXR1cm4gZmFsc2U7IC8vIFdlIG9ubHkgY2FyZSBhYm91dCBIVFRQUyBzZWN1 cml0eSBvcmlnaW5zLgogCisgICAgaWYgKFNlY3VyaXR5T3JpZ2luOjppc0FQcmlvcml0eUF1dGhl bnRpY2F0ZWRVUkwoc2V0dGluZ3MsIHVybCkpCisgICAgICAgIHJldHVybiB0cnVlOyAvLyBhIHBy aW9yaSBhdXRoZW50aWNhdGVkIHVybHMgYXJlIG5vdCBtaXhlZCBjb250ZW50LgorCiAgICAgLy8g V2UncmUgaW4gYSBzZWN1cmUgY29udGV4dCwgc28gfHVybHwgaXMgbWl4ZWQgY29udGVudCBpZiBp dCdzIGluc2VjdXJlLgogICAgIHJldHVybiAhU2VjdXJpdHlPcmlnaW46OmlzU2VjdXJlKHVybCk7 CiB9CiAKIGJvb2wgTWl4ZWRDb250ZW50Q2hlY2tlcjo6Y2FuRGlzcGxheUluc2VjdXJlQ29udGVu dChTZWN1cml0eU9yaWdpbiYgc2VjdXJpdHlPcmlnaW4sIENvbnRlbnRUeXBlIHR5cGUsIGNvbnN0 IFVSTCYgdXJsLCBBbHdheXNEaXNwbGF5SW5Ob25TdHJpY3RNb2RlIGFsd2F5c0Rpc3BsYXlJbk5v blN0cmljdE1vZGUpIGNvbnN0CiB7Ci0gICAgaWYgKCFpc01peGVkQ29udGVudChzZWN1cml0eU9y aWdpbiwgdXJsKSkKKyAgICBpZiAoIWlzTWl4ZWRDb250ZW50KG1fZnJhbWUuc2V0dGluZ3MoKSwg c2VjdXJpdHlPcmlnaW4sIHVybCkpCiAgICAgICAgIHJldHVybiB0cnVlOwogCiAgICAgaWYgKCFt X2ZyYW1lLmRvY3VtZW50KCktPmNvbnRlbnRTZWN1cml0eVBvbGljeSgpLT5hbGxvd1J1bm5pbmdP ckRpc3BsYXlpbmdJbnNlY3VyZUNvbnRlbnQodXJsKSkKQEAgLTg3LDcgKzkwLDcgQEAgYm9vbCBN aXhlZENvbnRlbnRDaGVja2VyOjpjYW5EaXNwbGF5SW5zZWN1cmVDb250ZW50KFNlY3VyaXR5T3Jp Z2luJiBzZWN1cml0eU9yaWcKIAogYm9vbCBNaXhlZENvbnRlbnRDaGVja2VyOjpjYW5SdW5JbnNl Y3VyZUNvbnRlbnQoU2VjdXJpdHlPcmlnaW4mIHNlY3VyaXR5T3JpZ2luLCBjb25zdCBVUkwmIHVy bCkgY29uc3QKIHsKLSAgICBpZiAoIWlzTWl4ZWRDb250ZW50KHNlY3VyaXR5T3JpZ2luLCB1cmwp KQorICAgIGlmICghaXNNaXhlZENvbnRlbnQobV9mcmFtZS5zZXR0aW5ncygpLCBzZWN1cml0eU9y aWdpbiwgdXJsKSkKICAgICAgICAgcmV0dXJuIHRydWU7CiAKICAgICBpZiAoIW1fZnJhbWUuZG9j dW1lbnQoKS0+Y29udGVudFNlY3VyaXR5UG9saWN5KCktPmFsbG93UnVubmluZ09yRGlzcGxheWlu Z0luc2VjdXJlQ29udGVudCh1cmwpKQpAQCAtMTExLDcgKzExNCw3IEBAIHZvaWQgTWl4ZWRDb250 ZW50Q2hlY2tlcjo6Y2hlY2tGb3JtRm9yTWl4ZWRDb250ZW50KFNlY3VyaXR5T3JpZ2luJiBzZWN1 cml0eU9yaWdpCiAgICAgaWYgKHVybC5wcm90b2NvbElzSmF2YVNjcmlwdCgpKQogICAgICAgICBy ZXR1cm47CiAKLSAgICBpZiAoIWlzTWl4ZWRDb250ZW50KHNlY3VyaXR5T3JpZ2luLCB1cmwpKQor ICAgIGlmICghaXNNaXhlZENvbnRlbnQobV9mcmFtZS5zZXR0aW5ncygpLCBzZWN1cml0eU9yaWdp biwgdXJsKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgU3RyaW5nIG1lc3NhZ2UgPSBtYWtlU3Ry aW5nKCJUaGUgcGFnZSBhdCAiLCBtX2ZyYW1lLmRvY3VtZW50KCktPnVybCgpLnN0cmluZ0NlbnRl ckVsbGlwc2l6ZWRUb0xlbmd0aCgpLCAiIGNvbnRhaW5zIGEgZm9ybSB3aGljaCB0YXJnZXRzIGFu IGluc2VjdXJlIFVSTCAiLCB1cmwuc3RyaW5nQ2VudGVyRWxsaXBzaXplZFRvTGVuZ3RoKCksICIu XG4iKTsKQEAgLTEyOCw3ICsxMzEsNyBAQCBPcHRpb25hbDxTdHJpbmc+IE1peGVkQ29udGVudENo ZWNrZXI6OmNoZWNrRm9yTWl4ZWRDb250ZW50SW5GcmFtZVRyZWUoY29uc3QgVVJMJgogICAgICAg ICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UoZG9jdW1lbnQtPmZyYW1lKCksICJBbiB1bnBh cmVudGVkIGRvY3VtZW50IHRyaWVkIHRvIGNvbm5lY3QgdG8gYSB3ZWJzb2NrZXQgd2l0aCB1cmw6 ICVzIiwgdXJsLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOwogICAgICAgICAKICAgICAgICAgYXV0 byogZnJhbWUgPSBkb2N1bWVudC0+ZnJhbWUoKTsKLSAgICAgICAgaWYgKGlzTWl4ZWRDb250ZW50 KGRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpLCB1cmwpKQorICAgICAgICBpZiAoaXNNaXhlZENv bnRlbnQoZG9jdW1lbnQtPnNldHRpbmdzKCksIGRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpLCB1 cmwpKQogICAgICAgICAgICAgcmV0dXJuIG1ha2VTdHJpbmcoIlRoZSBwYWdlIGF0ICIsIGRvY3Vt ZW50LT51cmwoKS5zdHJpbmdDZW50ZXJFbGxpcHNpemVkVG9MZW5ndGgoKSwgIiB3YXMgYmxvY2tl ZCBmcm9tIGNvbm5lY3RpbmcgaW5zZWN1cmVseSB0byAiLCB1cmwuc3RyaW5nQ2VudGVyRWxsaXBz aXplZFRvTGVuZ3RoKCksICIgZWl0aGVyIGJlY2F1c2UgdGhlIHByb3RvY29sIGlzIGluc2VjdXJl IG9yIHRoZSBwYWdlIGlzIGVtYmVkZGVkIGZyb20gYW4gaW5zZWN1cmUgcGFnZS4iKTsKIAogICAg ICAgICBpZiAoZnJhbWUtPmlzTWFpbkZyYW1lKCkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9sb2FkZXIvTWl4ZWRDb250ZW50Q2hlY2tlci5oIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL01p eGVkQ29udGVudENoZWNrZXIuaAppbmRleCA2ODg5ZTVmNDE0YjIuLmIzZWIxZTE4YzAyNSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL01peGVkQ29udGVudENoZWNrZXIuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvTWl4ZWRDb250ZW50Q2hlY2tlci5oCkBAIC0zOCw2ICsz OCw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIGNsYXNzIEZyYW1lOwogY2xhc3MgRnJhbWVMb2Fk ZXJDbGllbnQ7CiBjbGFzcyBTZWN1cml0eU9yaWdpbjsKK2NsYXNzIFNldHRpbmdzOwogCiBjbGFz cyBNaXhlZENvbnRlbnRDaGVja2VyIHsKICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShNaXhlZENv bnRlbnRDaGVja2VyKTsKQEAgLTU3LDcgKzU4LDcgQEAgcHVibGljOgogICAgIGJvb2wgY2FuRGlz cGxheUluc2VjdXJlQ29udGVudChTZWN1cml0eU9yaWdpbiYsIENvbnRlbnRUeXBlLCBjb25zdCBV UkwmLCBBbHdheXNEaXNwbGF5SW5Ob25TdHJpY3RNb2RlID0gQWx3YXlzRGlzcGxheUluTm9uU3Ry aWN0TW9kZTo6Tm8pIGNvbnN0OwogICAgIGJvb2wgY2FuUnVuSW5zZWN1cmVDb250ZW50KFNlY3Vy aXR5T3JpZ2luJiwgY29uc3QgVVJMJikgY29uc3Q7CiAgICAgdm9pZCBjaGVja0Zvcm1Gb3JNaXhl ZENvbnRlbnQoU2VjdXJpdHlPcmlnaW4mLCBjb25zdCBVUkwmKSBjb25zdDsKLSAgICBzdGF0aWMg Ym9vbCBpc01peGVkQ29udGVudChTZWN1cml0eU9yaWdpbiYsIGNvbnN0IFVSTCYpOworICAgIHN0 YXRpYyBib29sIGlzTWl4ZWRDb250ZW50KGNvbnN0IFNldHRpbmdzJiwgU2VjdXJpdHlPcmlnaW4m LCBjb25zdCBVUkwmKTsKICAgICBPcHRpb25hbDxTdHJpbmc+IGNoZWNrRm9yTWl4ZWRDb250ZW50 SW5GcmFtZVRyZWUoY29uc3QgVVJMJik7CiAKIHByaXZhdGU6CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2Vj dXJpdHlPcmlnaW4uY3BwCmluZGV4IDEwN2MxODU2YTIxMS4uMDZlMjFkMGE3ZGE0IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmNwcApAQCAtMTMxLDYgKzEzMSwxMiBAQCBzdGF0 aWMgYm9vbCBpc0xvb3BiYWNrSVBBZGRyZXNzKFN0cmluZ1ZpZXcgaG9zdCkKICAgICByZXR1cm4g ZG90c0ZvdW5kID09IDM7CiB9CiAKK3N0YXRpYyBib29sIGlzTG9jYWxob3N0SVBBZGRyZXNzKFN0 cmluZ1ZpZXcgaG9zdCkKK3sKKyAgICByZXR1cm4gZXF1YWxMZXR0ZXJzSWdub3JpbmdBU0NJSUNh c2UoaG9zdCwgImxvY2FsaG9zdCIpCisgICAgICAgIHx8IGhvc3QuZW5kc1dpdGhJZ25vcmluZ0FT Q0lJQ2FzZSgiLmxvY2FsaG9zdCIpOworfQorCiAvLyBodHRwczovL3czYy5naXRodWIuaW8vd2Vi YXBwc2VjLXNlY3VyZS1jb250ZXh0cy8jaXMtb3JpZ2luLXRydXN0d29ydGh5IChFZGl0b3IncyBE cmFmdCwgMTcgTm92ZW1iZXIgMjAxNikKIHN0YXRpYyBib29sIHNob3VsZFRyZWF0QXNQb3RlbnRp YWxseVRydXN0d29ydGh5KGNvbnN0IFN0cmluZyYgcHJvdG9jb2wsIGNvbnN0IFN0cmluZyYgaG9z dCkKIHsKQEAgLTU5OSwxMiArNjA1LDM2IEBAIGJvb2wgU2VjdXJpdHlPcmlnaW46OmlzU2FtZVNj aGVtZUhvc3RQb3J0KGNvbnN0IFNlY3VyaXR5T3JpZ2luJiBvdGhlcikgY29uc3QKICAgICByZXR1 cm4gdHJ1ZTsKIH0KIAorYm9vbCBTZWN1cml0eU9yaWdpbjo6aXNBUHJpb3JpdHlBdXRoZW50aWNh dGVkVVJMKGNvbnN0IFNldHRpbmdzJiBzZXR0aW5ncywgY29uc3QgVVJMJiB1cmwpCit7CisgICAg Ly8gRklYTUU6IFRoaXMgc2hvdWxkIGp1c3QgYmUgcmV0dXJuaW5nIHNvbWV0aGluZyBsaWtlCisg ICAgLy8gc2hvdWxkVHJlYXRBc1BvdGVudGlhbGx5VHJ1c3R3b3J0aHkodXJsKSB8fCB1cmwucHJv dG9jb2woKSA9PSAiZGF0YSIKKyAgICAvLyBidXQgc2hvdWxkVHJlYXRBc1BvdGVudGlhbGx5VHJ1 c3R3b3J0aHkgaXMgbm90IHJlYWxseSB1cC10by1kYXRlIHdpdGgKKyAgICAvLyByZXNwZWN0IHRv IHRoZSBsYXRlc3Qgc3BlY2lmaWNhdGlvbi4gRm9yIG5vdywgd2UganVzdCBpbXBsZW1lbnQgYQor ICAgIC8vIHNpbXBsaWZpZWQgdmVyc2lvbiB0byBhbGxvdyBNaXhlZENvbnRlbnRDaGVja2VyOjpp c01peGVkQ29udGVudCB0byByZXR1cm4KKyAgICAvLyBmYWxzZSBmb3IgbG9vcGJhY2sgSVAgYWRk cmVzc2VzIGFuZCBsb2NhbGhvc3QgYWRkcmVzc2VzLgorICAgIGF1dG8gaG9zdCA9IHVybC5ob3N0 KCkudG9TdHJpbmdXaXRob3V0Q29weWluZygpOworCisgICAgLy8gaHR0cHM6Ly93M2MuZ2l0aHVi LmlvL3dlYmFwcHNlYy1zZWN1cmUtY29udGV4dHMvI2lzLW9yaWdpbi10cnVzdHdvcnRoeQorICAg IC8vIGhvc3QgY29tcG9uZW50IG1hdGNoZXMgb25lIG9mIHRoZSBDSURSIG5vdGF0aW9ucyAxMjcu MC4wLjAvOCBvciA6OjEvMTI4CisgICAgaWYgKHNldHRpbmdzLnRydXN0d29ydGh5TG9vcGJhY2tJ UEFkZHJlc3Nlc0VuYWJsZWQoKSAmJiBpc0xvb3BiYWNrSVBBZGRyZXNzKGhvc3QpKQorICAgICAg ICByZXR1cm4gdHJ1ZTsKKworICAgIC8vIGh0dHBzOi8vdzNjLmdpdGh1Yi5pby93ZWJhcHBzZWMt c2VjdXJlLWNvbnRleHRzLyNpcy1vcmlnaW4tdHJ1c3R3b3J0aHkKKyAgICAvLyBob3N0IGNvbXBv bmVudCBpcyAibG9jYWxob3N0IiBvciBmYWxscyB3aXRoaW4gIi5sb2NhbGhvc3QiCisgICAgaWYg KHNldHRpbmdzLnRydXN0d29ydGh5TG9jYWxob3N0QWRkcmVzc2VzRW5hYmxlZCgpICYmIGlzTG9j YWxob3N0SVBBZGRyZXNzKGhvc3QpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIHJldHVy biBmYWxzZTsKK30KKwogYm9vbCBTZWN1cml0eU9yaWdpbjo6aXNMb2NhbEhvc3RPckxvb3BiYWNr SVBBZGRyZXNzKFN0cmluZ1ZpZXcgaG9zdCkKIHsKICAgICBpZiAoaXNMb29wYmFja0lQQWRkcmVz cyhob3N0KSkKICAgICAgICAgcmV0dXJuIHRydWU7CiAKICAgICAvLyBGSVhNRTogRW5zdXJlIHRo YXQgbG9jYWxob3N0IHJlc29sdmVzIHRvIHRoZSBsb29wYmFjayBhZGRyZXNzLgorICAgIC8vIEZJ WE1FOiBVc2UgaXNMb2NhbGhvc3RJUEFkZHJlc3MoKS4KICAgICBpZiAoZXF1YWxMZXR0ZXJzSWdu b3JpbmdBU0NJSUNhc2UoaG9zdCwgImxvY2FsaG9zdCIpKQogICAgICAgICByZXR1cm4gdHJ1ZTsK IApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oIGIvU291 cmNlL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCmluZGV4IDIwN2Y4YThhYTYzOS4uM2Yz YzAxYWYxYjIzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2lu LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCkBAIC0zNSw2ICsz NSw4IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorY2xhc3MgU2V0dGluZ3M7CisKIGNsYXNz IFNlY3VyaXR5T3JpZ2luIDogcHVibGljIFRocmVhZFNhZmVSZWZDb3VudGVkPFNlY3VyaXR5T3Jp Z2luPiB7CiBwdWJsaWM6CiAgICAgZW51bSBQb2xpY3kgewpAQCAtMjE2LDYgKzIxOCwxMCBAQCBw dWJsaWM6CiAKICAgICBXRUJDT1JFX0VYUE9SVCBzdGF0aWMgYm9vbCBpc0xvY2FsSG9zdE9yTG9v cGJhY2tJUEFkZHJlc3MoU3RyaW5nVmlldyk7CiAKKyAgICAvLyBUaGlzIG1ldGhvZCBpbXBsZW1l bnRzIHRoZSBhIHByaW9yaSBhdXRoZW50aWNhdGVkIFVSTAorICAgIC8vIGh0dHBzOi8vdzNjLmdp dGh1Yi5pby93ZWJhcHBzZWMtbWl4ZWQtY29udGVudC8jYS1wcmlvcmktYXV0aGVudGljYXRlZC11 cmwKKyAgICBXRUJDT1JFX0VYUE9SVCBzdGF0aWMgYm9vbCBpc0FQcmlvcml0eUF1dGhlbnRpY2F0 ZWRVUkwoY29uc3QgU2V0dGluZ3MmLCBjb25zdCBVUkwmKTsKKwogICAgIGNvbnN0IFNlY3VyaXR5 T3JpZ2luRGF0YSYgZGF0YSgpIGNvbnN0IHsgcmV0dXJuIG1fZGF0YTsgfQogCiAgICAgdGVtcGxh dGU8Y2xhc3MgRW5jb2Rlcj4gdm9pZCBlbmNvZGUoRW5jb2RlciYpIGNvbnN0OwotLSAKMi4yOC4w Cgo= 412836 2020-10-30 23:36:57 -0700 2020-10-31 08:21:56 -0700 WIP Patch a.patch text/plain 9554 fred.wang ZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvU2NyaXB0cy9QcmVmZXJlbmNlcy9XZWJQcmVmZXJlbmNl c0V4cGVyaW1lbnRhbC55YW1sIGIvU291cmNlL1dURi9TY3JpcHRzL1ByZWZlcmVuY2VzL1dlYlBy ZWZlcmVuY2VzRXhwZXJpbWVudGFsLnlhbWwKaW5kZXggNDVmYjBiNzk1ODQ1Li41M2I2ZGEyMzRi NjcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvU2NyaXB0cy9QcmVmZXJlbmNlcy9XZWJQcmVmZXJl bmNlc0V4cGVyaW1lbnRhbC55YW1sCisrKyBiL1NvdXJjZS9XVEYvU2NyaXB0cy9QcmVmZXJlbmNl cy9XZWJQcmVmZXJlbmNlc0V4cGVyaW1lbnRhbC55YW1sCkBAIC04MDIsNiArODAyLDMyIEBAIFRy YW5zZm9ybVN0cmVhbUFQSUVuYWJsZWQ6CiAgICAgV2ViS2l0OgogICAgICAgZGVmYXVsdDogdHJ1 ZQogCisjIGh0dHBzOi8vdzNjLmdpdGh1Yi5pby93ZWJhcHBzZWMtc2VjdXJlLWNvbnRleHRzLyNp cy1vcmlnaW4tdHJ1c3R3b3J0aHkKK1RydXN0d29ydGh5TG9jYWxob3N0QWRkcmVzc2VzRW5hYmxl ZDoKKyAgdHlwZTogYm9vbAorICBodW1hblJlYWRhYmxlTmFtZTogIlRydXN0d29ydGh5IGxvY2Fs aG9zdCBhZGRyZXNzZXMiCisgIGh1bWFuUmVhZGFibGVEZXNjcmlwdGlvbjogIlRyZWF0IGhvc3Rz IG1hdGNoaW5nICdsb2NhbGhvc3QnLCBvciBmYWxsaW5nIHdpdGhpbiAnLmxvY2FsaG9zdCcsIGFz ICdQb3RlbnRpYWxseSBUcnVzdHdvcnRoeScuIgorICBkZWZhdWx0VmFsdWU6CisgICAgV2ViS2l0 TGVnYWN5OgorICAgICAgZGVmYXVsdDogZmFsc2UKKyAgICBXZWJLaXQ6CisgICAgICBkZWZhdWx0 OiBmYWxzZQorICAgIFdlYkNvcmU6CisgICAgICBkZWZhdWx0OiBmYWxzZQorCisjIGh0dHBzOi8v dzNjLmdpdGh1Yi5pby93ZWJhcHBzZWMtc2VjdXJlLWNvbnRleHRzLyNpcy1vcmlnaW4tdHJ1c3R3 b3J0aHkKK1RydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ6CisgIHR5cGU6IGJv b2wKKyAgaHVtYW5SZWFkYWJsZU5hbWU6ICJUcnVzdHdvcnRoeSBsb29wYmFjayBJUCBhZGRyZXNz ZXMiCisgIGh1bWFuUmVhZGFibGVEZXNjcmlwdGlvbjogIlRyZWF0IGhvc3RzIG1hdGNoaW5nIG9u ZSBvZiB0aGUgQ0lEUiBub3RhdGlvbnMgMTI3LjAuMC4wLzggb3IgOjoxLzEyOCBhcyAnUG90ZW50 aWFsbHkgVHJ1c3R3b3J0aHknLiIKKyAgZGVmYXVsdFZhbHVlOgorICAgIFdlYktpdExlZ2FjeToK KyAgICAgIGRlZmF1bHQ6IGZhbHNlCisgICAgV2ViS2l0OgorICAgICAgZGVmYXVsdDogdHJ1ZQor ICAgIFdlYkNvcmU6CisgICAgICBkZWZhdWx0OiBmYWxzZQorCiBVc2VyR2VzdHVyZVByb21pc2VQ cm9wYWdhdGlvbkVuYWJsZWQ6CiAgIHR5cGU6IGJvb2wKICAgaHVtYW5SZWFkYWJsZU5hbWU6ICJV c2VyR2VzdHVyZSBQcm9taXNlIFByb3BhZ2F0aW9uIgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvaHRtbC9wYXJzZXIvWFNTQXVkaXRvci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL3BhcnNl ci9YU1NBdWRpdG9yLmNwcAppbmRleCBiY2I4ODVlYWRkNzMuLjY0MTNiOGJiMzFjMyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9wYXJzZXIvWFNTQXVkaXRvci5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvaHRtbC9wYXJzZXIvWFNTQXVkaXRvci5jcHAKQEAgLTMyNCw3ICszMjQsNyBA QCB2b2lkIFhTU0F1ZGl0b3I6OmluaXQoRG9jdW1lbnQqIGRvY3VtZW50LCBYU1NBdWRpdG9yRGVs ZWdhdGUqIGF1ZGl0b3JEZWxlZ2F0ZSkKIAogICAgICAgICBpZiAoKG1feHNzUHJvdGVjdGlvbiA9 PSBYU1NQcm90ZWN0aW9uRGlzcG9zaXRpb246OkVuYWJsZWQgfHwgbV94c3NQcm90ZWN0aW9uID09 IFhTU1Byb3RlY3Rpb25EaXNwb3NpdGlvbjo6QmxvY2tFbmFibGVkKSAmJiAhcGFyc2VkUmVwb3J0 VVJMLmlzRW1wdHkoKSkgewogICAgICAgICAgICAgcmVwb3J0VVJMID0gZG9jdW1lbnQtPmNvbXBs ZXRlVVJMKHBhcnNlZFJlcG9ydFVSTCk7Ci0gICAgICAgICAgICBpZiAoTWl4ZWRDb250ZW50Q2hl Y2tlcjo6aXNNaXhlZENvbnRlbnQoZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCksIHJlcG9ydFVS TCkpIHsKKyAgICAgICAgICAgIGlmIChNaXhlZENvbnRlbnRDaGVja2VyOjppc01peGVkQ29udGVu dChkb2N1bWVudC0+c2V0dGluZ3MoKSwgZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCksIHJlcG9y dFVSTCkpIHsKICAgICAgICAgICAgICAgICBlcnJvckRldGFpbHMgPSAiaW5zZWN1cmUgcmVwb3J0 aW5nIFVSTCBmb3Igc2VjdXJlIHBhZ2UiOwogICAgICAgICAgICAgICAgIG1feHNzUHJvdGVjdGlv biA9IFhTU1Byb3RlY3Rpb25EaXNwb3NpdGlvbjo6SW52YWxpZDsKICAgICAgICAgICAgICAgICBy ZXBvcnRVUkwgPSBVUkwoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9NaXhl ZENvbnRlbnRDaGVja2VyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9NaXhlZENvbnRlbnRD aGVja2VyLmNwcAppbmRleCBhN2I2YmY2NzNhZDYuLjkyOTkwYmQ3NDk1ZiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvbG9hZGVyL01peGVkQ29udGVudENoZWNrZXIuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2xvYWRlci9NaXhlZENvbnRlbnRDaGVja2VyLmNwcApAQCAtNTMsMTggKzUzLDIx IEBAIEZyYW1lTG9hZGVyQ2xpZW50JiBNaXhlZENvbnRlbnRDaGVja2VyOjpjbGllbnQoKSBjb25z dAogfQogCiAvLyBzdGF0aWMKLWJvb2wgTWl4ZWRDb250ZW50Q2hlY2tlcjo6aXNNaXhlZENvbnRl bnQoU2VjdXJpdHlPcmlnaW4mIHNlY3VyaXR5T3JpZ2luLCBjb25zdCBVUkwmIHVybCkKK2Jvb2wg TWl4ZWRDb250ZW50Q2hlY2tlcjo6aXNNaXhlZENvbnRlbnQoY29uc3QgU2V0dGluZ3MmIHNldHRp bmdzLCBTZWN1cml0eU9yaWdpbiYgc2VjdXJpdHlPcmlnaW4sIGNvbnN0IFVSTCYgdXJsKQogewog ICAgIGlmIChzZWN1cml0eU9yaWdpbi5wcm90b2NvbCgpICE9ICJodHRwcyIpCiAgICAgICAgIHJl dHVybiBmYWxzZTsgLy8gV2Ugb25seSBjYXJlIGFib3V0IEhUVFBTIHNlY3VyaXR5IG9yaWdpbnMu CiAKKyAgICBpZiAoU2VjdXJpdHlPcmlnaW46OmlzQVByaW9yaXR5QXV0aGVudGljYXRlZFVSTChz ZXR0aW5ncywgdXJsKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOyAvLyBhIHByaW9yaSBhdXRoZW50 aWNhdGVkIHVybHMgYXJlIG5vdCBtaXhlZCBjb250ZW50LgorCiAgICAgLy8gV2UncmUgaW4gYSBz ZWN1cmUgY29udGV4dCwgc28gfHVybHwgaXMgbWl4ZWQgY29udGVudCBpZiBpdCdzIGluc2VjdXJl LgogICAgIHJldHVybiAhU2VjdXJpdHlPcmlnaW46OmlzU2VjdXJlKHVybCk7CiB9CiAKIGJvb2wg TWl4ZWRDb250ZW50Q2hlY2tlcjo6Y2FuRGlzcGxheUluc2VjdXJlQ29udGVudChTZWN1cml0eU9y aWdpbiYgc2VjdXJpdHlPcmlnaW4sIENvbnRlbnRUeXBlIHR5cGUsIGNvbnN0IFVSTCYgdXJsLCBB bHdheXNEaXNwbGF5SW5Ob25TdHJpY3RNb2RlIGFsd2F5c0Rpc3BsYXlJbk5vblN0cmljdE1vZGUp IGNvbnN0CiB7Ci0gICAgaWYgKCFpc01peGVkQ29udGVudChzZWN1cml0eU9yaWdpbiwgdXJsKSkK KyAgICBpZiAoIWlzTWl4ZWRDb250ZW50KG1fZnJhbWUuc2V0dGluZ3MoKSwgc2VjdXJpdHlPcmln aW4sIHVybCkpCiAgICAgICAgIHJldHVybiB0cnVlOwogCiAgICAgaWYgKCFtX2ZyYW1lLmRvY3Vt ZW50KCktPmNvbnRlbnRTZWN1cml0eVBvbGljeSgpLT5hbGxvd1J1bm5pbmdPckRpc3BsYXlpbmdJ bnNlY3VyZUNvbnRlbnQodXJsKSkKQEAgLTg3LDcgKzkwLDcgQEAgYm9vbCBNaXhlZENvbnRlbnRD aGVja2VyOjpjYW5EaXNwbGF5SW5zZWN1cmVDb250ZW50KFNlY3VyaXR5T3JpZ2luJiBzZWN1cml0 eU9yaWcKIAogYm9vbCBNaXhlZENvbnRlbnRDaGVja2VyOjpjYW5SdW5JbnNlY3VyZUNvbnRlbnQo U2VjdXJpdHlPcmlnaW4mIHNlY3VyaXR5T3JpZ2luLCBjb25zdCBVUkwmIHVybCkgY29uc3QKIHsK LSAgICBpZiAoIWlzTWl4ZWRDb250ZW50KHNlY3VyaXR5T3JpZ2luLCB1cmwpKQorICAgIGlmICgh aXNNaXhlZENvbnRlbnQobV9mcmFtZS5zZXR0aW5ncygpLCBzZWN1cml0eU9yaWdpbiwgdXJsKSkK ICAgICAgICAgcmV0dXJuIHRydWU7CiAKICAgICBpZiAoIW1fZnJhbWUuZG9jdW1lbnQoKS0+Y29u dGVudFNlY3VyaXR5UG9saWN5KCktPmFsbG93UnVubmluZ09yRGlzcGxheWluZ0luc2VjdXJlQ29u dGVudCh1cmwpKQpAQCAtMTExLDcgKzExNCw3IEBAIHZvaWQgTWl4ZWRDb250ZW50Q2hlY2tlcjo6 Y2hlY2tGb3JtRm9yTWl4ZWRDb250ZW50KFNlY3VyaXR5T3JpZ2luJiBzZWN1cml0eU9yaWdpCiAg ICAgaWYgKHVybC5wcm90b2NvbElzSmF2YVNjcmlwdCgpKQogICAgICAgICByZXR1cm47CiAKLSAg ICBpZiAoIWlzTWl4ZWRDb250ZW50KHNlY3VyaXR5T3JpZ2luLCB1cmwpKQorICAgIGlmICghaXNN aXhlZENvbnRlbnQobV9mcmFtZS5zZXR0aW5ncygpLCBzZWN1cml0eU9yaWdpbiwgdXJsKSkKICAg ICAgICAgcmV0dXJuOwogCiAgICAgU3RyaW5nIG1lc3NhZ2UgPSBtYWtlU3RyaW5nKCJUaGUgcGFn ZSBhdCAiLCBtX2ZyYW1lLmRvY3VtZW50KCktPnVybCgpLnN0cmluZ0NlbnRlckVsbGlwc2l6ZWRU b0xlbmd0aCgpLCAiIGNvbnRhaW5zIGEgZm9ybSB3aGljaCB0YXJnZXRzIGFuIGluc2VjdXJlIFVS TCAiLCB1cmwuc3RyaW5nQ2VudGVyRWxsaXBzaXplZFRvTGVuZ3RoKCksICIuXG4iKTsKQEAgLTEy OCw3ICsxMzEsNyBAQCBPcHRpb25hbDxTdHJpbmc+IE1peGVkQ29udGVudENoZWNrZXI6OmNoZWNr Rm9yTWl4ZWRDb250ZW50SW5GcmFtZVRyZWUoY29uc3QgVVJMJgogICAgICAgICBSRUxFQVNFX0FT U0VSVF9XSVRIX01FU1NBR0UoZG9jdW1lbnQtPmZyYW1lKCksICJBbiB1bnBhcmVudGVkIGRvY3Vt ZW50IHRyaWVkIHRvIGNvbm5lY3QgdG8gYSB3ZWJzb2NrZXQgd2l0aCB1cmw6ICVzIiwgdXJsLnN0 cmluZygpLnV0ZjgoKS5kYXRhKCkpOwogICAgICAgICAKICAgICAgICAgYXV0byogZnJhbWUgPSBk b2N1bWVudC0+ZnJhbWUoKTsKLSAgICAgICAgaWYgKGlzTWl4ZWRDb250ZW50KGRvY3VtZW50LT5z ZWN1cml0eU9yaWdpbigpLCB1cmwpKQorICAgICAgICBpZiAoaXNNaXhlZENvbnRlbnQoZG9jdW1l bnQtPnNldHRpbmdzKCksIGRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpLCB1cmwpKQogICAgICAg ICAgICAgcmV0dXJuIG1ha2VTdHJpbmcoIlRoZSBwYWdlIGF0ICIsIGRvY3VtZW50LT51cmwoKS5z dHJpbmdDZW50ZXJFbGxpcHNpemVkVG9MZW5ndGgoKSwgIiB3YXMgYmxvY2tlZCBmcm9tIGNvbm5l Y3RpbmcgaW5zZWN1cmVseSB0byAiLCB1cmwuc3RyaW5nQ2VudGVyRWxsaXBzaXplZFRvTGVuZ3Ro KCksICIgZWl0aGVyIGJlY2F1c2UgdGhlIHByb3RvY29sIGlzIGluc2VjdXJlIG9yIHRoZSBwYWdl IGlzIGVtYmVkZGVkIGZyb20gYW4gaW5zZWN1cmUgcGFnZS4iKTsKIAogICAgICAgICBpZiAoZnJh bWUtPmlzTWFpbkZyYW1lKCkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvTWl4 ZWRDb250ZW50Q2hlY2tlci5oIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL01peGVkQ29udGVudENo ZWNrZXIuaAppbmRleCA2ODg5ZTVmNDE0YjIuLmIzZWIxZTE4YzAyNSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvbG9hZGVyL01peGVkQ29udGVudENoZWNrZXIuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9sb2FkZXIvTWl4ZWRDb250ZW50Q2hlY2tlci5oCkBAIC0zOCw2ICszOCw3IEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKIGNsYXNzIEZyYW1lOwogY2xhc3MgRnJhbWVMb2FkZXJDbGllbnQ7CiBj bGFzcyBTZWN1cml0eU9yaWdpbjsKK2NsYXNzIFNldHRpbmdzOwogCiBjbGFzcyBNaXhlZENvbnRl bnRDaGVja2VyIHsKICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShNaXhlZENvbnRlbnRDaGVja2Vy KTsKQEAgLTU3LDcgKzU4LDcgQEAgcHVibGljOgogICAgIGJvb2wgY2FuRGlzcGxheUluc2VjdXJl Q29udGVudChTZWN1cml0eU9yaWdpbiYsIENvbnRlbnRUeXBlLCBjb25zdCBVUkwmLCBBbHdheXNE aXNwbGF5SW5Ob25TdHJpY3RNb2RlID0gQWx3YXlzRGlzcGxheUluTm9uU3RyaWN0TW9kZTo6Tm8p IGNvbnN0OwogICAgIGJvb2wgY2FuUnVuSW5zZWN1cmVDb250ZW50KFNlY3VyaXR5T3JpZ2luJiwg Y29uc3QgVVJMJikgY29uc3Q7CiAgICAgdm9pZCBjaGVja0Zvcm1Gb3JNaXhlZENvbnRlbnQoU2Vj dXJpdHlPcmlnaW4mLCBjb25zdCBVUkwmKSBjb25zdDsKLSAgICBzdGF0aWMgYm9vbCBpc01peGVk Q29udGVudChTZWN1cml0eU9yaWdpbiYsIGNvbnN0IFVSTCYpOworICAgIHN0YXRpYyBib29sIGlz TWl4ZWRDb250ZW50KGNvbnN0IFNldHRpbmdzJiwgU2VjdXJpdHlPcmlnaW4mLCBjb25zdCBVUkwm KTsKICAgICBPcHRpb25hbDxTdHJpbmc+IGNoZWNrRm9yTWl4ZWRDb250ZW50SW5GcmFtZVRyZWUo Y29uc3QgVVJMJik7CiAKIHByaXZhdGU6CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdl L1NlY3VyaXR5T3JpZ2luLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4u Y3BwCmluZGV4IDEwN2MxODU2YTIxMS4uMDZlMjFkMGE3ZGE0IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdl L1NlY3VyaXR5T3JpZ2luLmNwcApAQCAtMTMxLDYgKzEzMSwxMiBAQCBzdGF0aWMgYm9vbCBpc0xv b3BiYWNrSVBBZGRyZXNzKFN0cmluZ1ZpZXcgaG9zdCkKICAgICByZXR1cm4gZG90c0ZvdW5kID09 IDM7CiB9CiAKK3N0YXRpYyBib29sIGlzTG9jYWxob3N0SVBBZGRyZXNzKFN0cmluZ1ZpZXcgaG9z dCkKK3sKKyAgICByZXR1cm4gZXF1YWxMZXR0ZXJzSWdub3JpbmdBU0NJSUNhc2UoaG9zdCwgImxv Y2FsaG9zdCIpCisgICAgICAgIHx8IGhvc3QuZW5kc1dpdGhJZ25vcmluZ0FTQ0lJQ2FzZSgiLmxv Y2FsaG9zdCIpOworfQorCiAvLyBodHRwczovL3czYy5naXRodWIuaW8vd2ViYXBwc2VjLXNlY3Vy ZS1jb250ZXh0cy8jaXMtb3JpZ2luLXRydXN0d29ydGh5IChFZGl0b3IncyBEcmFmdCwgMTcgTm92 ZW1iZXIgMjAxNikKIHN0YXRpYyBib29sIHNob3VsZFRyZWF0QXNQb3RlbnRpYWxseVRydXN0d29y dGh5KGNvbnN0IFN0cmluZyYgcHJvdG9jb2wsIGNvbnN0IFN0cmluZyYgaG9zdCkKIHsKQEAgLTU5 OSwxMiArNjA1LDM2IEBAIGJvb2wgU2VjdXJpdHlPcmlnaW46OmlzU2FtZVNjaGVtZUhvc3RQb3J0 KGNvbnN0IFNlY3VyaXR5T3JpZ2luJiBvdGhlcikgY29uc3QKICAgICByZXR1cm4gdHJ1ZTsKIH0K IAorYm9vbCBTZWN1cml0eU9yaWdpbjo6aXNBUHJpb3JpdHlBdXRoZW50aWNhdGVkVVJMKGNvbnN0 IFNldHRpbmdzJiBzZXR0aW5ncywgY29uc3QgVVJMJiB1cmwpCit7CisgICAgLy8gRklYTUU6IFRo aXMgc2hvdWxkIGp1c3QgYmUgcmV0dXJuaW5nIHNvbWV0aGluZyBsaWtlCisgICAgLy8gc2hvdWxk VHJlYXRBc1BvdGVudGlhbGx5VHJ1c3R3b3J0aHkodXJsKSB8fCB1cmwucHJvdG9jb2woKSA9PSAi ZGF0YSIKKyAgICAvLyBidXQgc2hvdWxkVHJlYXRBc1BvdGVudGlhbGx5VHJ1c3R3b3J0aHkgaXMg bm90IHJlYWxseSB1cC10by1kYXRlIHdpdGgKKyAgICAvLyByZXNwZWN0IHRvIHRoZSBsYXRlc3Qg c3BlY2lmaWNhdGlvbi4gRm9yIG5vdywgd2UganVzdCBpbXBsZW1lbnQgYQorICAgIC8vIHNpbXBs aWZpZWQgdmVyc2lvbiB0byBhbGxvdyBNaXhlZENvbnRlbnRDaGVja2VyOjppc01peGVkQ29udGVu dCB0byByZXR1cm4KKyAgICAvLyBmYWxzZSBmb3IgbG9vcGJhY2sgSVAgYWRkcmVzc2VzIGFuZCBs b2NhbGhvc3QgYWRkcmVzc2VzLgorICAgIGF1dG8gaG9zdCA9IHVybC5ob3N0KCkudG9TdHJpbmdX aXRob3V0Q29weWluZygpOworCisgICAgLy8gaHR0cHM6Ly93M2MuZ2l0aHViLmlvL3dlYmFwcHNl Yy1zZWN1cmUtY29udGV4dHMvI2lzLW9yaWdpbi10cnVzdHdvcnRoeQorICAgIC8vIGhvc3QgY29t cG9uZW50IG1hdGNoZXMgb25lIG9mIHRoZSBDSURSIG5vdGF0aW9ucyAxMjcuMC4wLjAvOCBvciA6 OjEvMTI4CisgICAgaWYgKHNldHRpbmdzLnRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0Vu YWJsZWQoKSAmJiBpc0xvb3BiYWNrSVBBZGRyZXNzKGhvc3QpKQorICAgICAgICByZXR1cm4gdHJ1 ZTsKKworICAgIC8vIGh0dHBzOi8vdzNjLmdpdGh1Yi5pby93ZWJhcHBzZWMtc2VjdXJlLWNvbnRl eHRzLyNpcy1vcmlnaW4tdHJ1c3R3b3J0aHkKKyAgICAvLyBob3N0IGNvbXBvbmVudCBpcyAibG9j YWxob3N0IiBvciBmYWxscyB3aXRoaW4gIi5sb2NhbGhvc3QiCisgICAgaWYgKHNldHRpbmdzLnRy dXN0d29ydGh5TG9jYWxob3N0QWRkcmVzc2VzRW5hYmxlZCgpICYmIGlzTG9jYWxob3N0SVBBZGRy ZXNzKGhvc3QpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIHJldHVybiBmYWxzZTsKK30K KwogYm9vbCBTZWN1cml0eU9yaWdpbjo6aXNMb2NhbEhvc3RPckxvb3BiYWNrSVBBZGRyZXNzKFN0 cmluZ1ZpZXcgaG9zdCkKIHsKICAgICBpZiAoaXNMb29wYmFja0lQQWRkcmVzcyhob3N0KSkKICAg ICAgICAgcmV0dXJuIHRydWU7CiAKICAgICAvLyBGSVhNRTogRW5zdXJlIHRoYXQgbG9jYWxob3N0 IHJlc29sdmVzIHRvIHRoZSBsb29wYmFjayBhZGRyZXNzLgorICAgIC8vIEZJWE1FOiBVc2UgaXNM b2NhbGhvc3RJUEFkZHJlc3MoKS4KICAgICBpZiAoZXF1YWxMZXR0ZXJzSWdub3JpbmdBU0NJSUNh c2UoaG9zdCwgImxvY2FsaG9zdCIpKQogICAgICAgICByZXR1cm4gdHJ1ZTsKIApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oIGIvU291cmNlL1dlYkNvcmUv cGFnZS9TZWN1cml0eU9yaWdpbi5oCmluZGV4IDIwN2Y4YThhYTYzOS4uM2YzYzAxYWYxYjIzIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCkBAIC0zNSw2ICszNSw4IEBACiAKIG5h bWVzcGFjZSBXZWJDb3JlIHsKIAorY2xhc3MgU2V0dGluZ3M7CisKIGNsYXNzIFNlY3VyaXR5T3Jp Z2luIDogcHVibGljIFRocmVhZFNhZmVSZWZDb3VudGVkPFNlY3VyaXR5T3JpZ2luPiB7CiBwdWJs aWM6CiAgICAgZW51bSBQb2xpY3kgewpAQCAtMjE2LDYgKzIxOCwxMCBAQCBwdWJsaWM6CiAKICAg ICBXRUJDT1JFX0VYUE9SVCBzdGF0aWMgYm9vbCBpc0xvY2FsSG9zdE9yTG9vcGJhY2tJUEFkZHJl c3MoU3RyaW5nVmlldyk7CiAKKyAgICAvLyBUaGlzIG1ldGhvZCBpbXBsZW1lbnRzIHRoZSBhIHBy aW9yaSBhdXRoZW50aWNhdGVkIFVSTAorICAgIC8vIGh0dHBzOi8vdzNjLmdpdGh1Yi5pby93ZWJh cHBzZWMtbWl4ZWQtY29udGVudC8jYS1wcmlvcmktYXV0aGVudGljYXRlZC11cmwKKyAgICBXRUJD T1JFX0VYUE9SVCBzdGF0aWMgYm9vbCBpc0FQcmlvcml0eUF1dGhlbnRpY2F0ZWRVUkwoY29uc3Qg U2V0dGluZ3MmLCBjb25zdCBVUkwmKTsKKwogICAgIGNvbnN0IFNlY3VyaXR5T3JpZ2luRGF0YSYg ZGF0YSgpIGNvbnN0IHsgcmV0dXJuIG1fZGF0YTsgfQogCiAgICAgdGVtcGxhdGU8Y2xhc3MgRW5j b2Rlcj4gdm9pZCBlbmNvZGUoRW5jb2RlciYpIGNvbnN0Owo= 412843 2020-10-31 08:21:56 -0700 2020-11-04 07:15:03 -0800 WIP Patch WIP.patch text/plain 45836 fred.wang ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3Vy aXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWNzcy1pbi1pZnJhbWUt cmVwb3J0LW9ubHkuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVu dFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWNzcy1pbi1p ZnJhbWUtcmVwb3J0LW9ubHkuaHRtbAppbmRleCBiM2NhNjYwZjBhYTcuLjdmMWZjYzU2ZTA0ZSAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJp dHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtY3NzLWluLWlmcmFtZS1y ZXBvcnQtb25seS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29u dGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWNzcy1p bi1pZnJhbWUtcmVwb3J0LW9ubHkuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1s PgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6 VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+ CiA8aGVhZD4KIDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Nl Y3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNl Y3VyZS1jc3MtaW4taWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5 L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1j c3MtaW4taWZyYW1lLmh0bWwKaW5kZXggODg4ZGZjNjkzNzE4Li5mMGVjOTMwZDc2N2YgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9s aWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWNzcy1pbi1pZnJhbWUuaHRtbAor KysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGlj eS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1jc3MtaW4taWZyYW1lLmh0bWwKQEAg LTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0 LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nl c0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kv YmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtY3NzLWluLW1haW4tZnJhbWUuaHRtbCBi L0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Js b2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWNzcy1pbi1tYWluLWZyYW1lLmh0bWwKaW5k ZXggMWNmOGNlODI5MDVkLi5lMzY0ZWQwZWQ4MWIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1j b250ZW50L2luc2VjdXJlLWNzcy1pbi1tYWluLWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVk LWNvbnRlbnQvaW5zZWN1cmUtY3NzLWluLW1haW4tZnJhbWUuaHRtbApAQCAtMSw0ICsxLDQgQEAK LTwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZHVtcEpTQ29uc29sZUxv Z0luU3RkRXJyPXRydWUgXSAtLT4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVu bmVyIFsgZHVtcEpTQ29uc29sZUxvZ0luU3RkRXJyPXRydWUgZXhwZXJpbWVudGFsOlRydXN0d29y dGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+ CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9j b250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaWZy YW1lLWluLWlmcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250 ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaWZyYW1l LWluLWlmcmFtZS5odG1sCmluZGV4IDcyNjc5MTMwZDYxYi4uYjk0YmVjNWMzOWQ5IDEwMDY0NAot LS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGlj eS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pZnJhbWUtaW4taWZyYW1lLmh0bWwK KysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xp Y3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaWZyYW1lLWluLWlmcmFtZS5odG1s CkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdl YmtpdC10ZXN0LXJ1bm5lciBbIGR1bXBKU0NvbnNvbGVMb2dJblN0ZEVycj10cnVlIGV4cGVyaW1l bnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8 aHRtbD4KIDxoZWFkPgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50 L2luc2VjdXJlLWlmcmFtZS1pbi1tYWluLWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVu dC9pbnNlY3VyZS1pZnJhbWUtaW4tbWFpbi1mcmFtZS5odG1sCmluZGV4IDhjMzQ4NGRkNDRhOS4u NzUwM2NjM2VhMTI2IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5 L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1p ZnJhbWUtaW4tbWFpbi1mcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2Vj dXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2Vj dXJlLWlmcmFtZS1pbi1tYWluLWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUg aHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZHVtcEpTQ29u c29sZUxvZ0luU3RkRXJyPXRydWUgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFk ZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0PgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQ b2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4tYmxvYi11cmwt aWZyYW1lLWluLWlmcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9j b250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1h Z2UtaW4tYmxvYi11cmwtaWZyYW1lLWluLWlmcmFtZS5odG1sCmluZGV4IGJkZjdiYjdmZjhkZC4u NGY5ZWFlYWQ3ZjgyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5 L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1p bWFnZS1pbi1ibG9iLXVybC1pZnJhbWUtaW4taWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVk LWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4tYmxvYi11cmwtaWZyYW1lLWluLWlmcmFtZS5odG1s CkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdl YmtpdC10ZXN0LXJ1bm5lciBbIGR1bXBKU0NvbnNvbGVMb2dJblN0ZEVycj10cnVlIGV4cGVyaW1l bnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8 aHRtbD4KIDxoZWFkPgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50 L2luc2VjdXJlLWltYWdlLWluLWlmcmFtZS13aXRoLWVuZm9yY2VkLWFuZC1yZXBvcnQtcG9saWNp ZXMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5 UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWltYWdlLWluLWlmcmFtZS13 aXRoLWVuZm9yY2VkLWFuZC1yZXBvcnQtcG9saWNpZXMuaHRtbAppbmRleCBkN2E1MDFiNjdhYTYu LmQ5ZTg1YTNhZWJjNyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUt aW1hZ2UtaW4taWZyYW1lLXdpdGgtZW5mb3JjZWQtYW5kLXJlcG9ydC1wb2xpY2llcy5odG1sCisr KyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5 L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWltYWdlLWluLWlmcmFtZS13aXRoLWVu Zm9yY2VkLWFuZC1yZXBvcnQtcG9saWNpZXMuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQ RSBodG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmlt ZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgog PGh0bWw+CiA8aGVhZD4KIDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVu dC9pbnNlY3VyZS1pbWFnZS1pbi1pZnJhbWUtd2l0aC1pbmhlcml0ZWQtcG9saWN5Lmh0bWwgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9j ay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1pZnJhbWUtd2l0aC1pbmhlcml0 ZWQtcG9saWN5Lmh0bWwKaW5kZXggMjU2NTdjOWJjODYwLi42Y2NkMDZjOTQ2NTEgMTAwNjQ0Ci0t LSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5 L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWltYWdlLWluLWlmcmFtZS13aXRoLWlu aGVyaXRlZC1wb2xpY3kuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5 L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1p bWFnZS1pbi1pZnJhbWUtd2l0aC1pbmhlcml0ZWQtcG9saWN5Lmh0bWwKQEAgLTEsNCArMSw0IEBA Ci08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVy IFsgZHVtcEpTQ29uc29sZUxvZ0luU3RkRXJyPXRydWUgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5 TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8 bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNlY3VyaXR5LVBvbGljeSIgY29udGVudD0iYmxvY2st YWxsLW1peGVkLWNvbnRlbnQiPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9z ZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5z ZWN1cmUtaW1hZ2UtaW4taWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3Vy aXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3Vy ZS1pbWFnZS1pbi1pZnJhbWUuaHRtbAppbmRleCBhOWViYjdmZDk5M2IuLmNlMzNhYmMwODFkYSAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJp dHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4taWZyYW1l Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJp dHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4taWZyYW1l Lmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwh LS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJ UEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0Pgpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJp dHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4tamF2YXNj cmlwdC11cmwtaWZyYW1lLWluLWlmcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9z ZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5z ZWN1cmUtaW1hZ2UtaW4tamF2YXNjcmlwdC11cmwtaWZyYW1lLWluLWlmcmFtZS5odG1sCmluZGV4 IGJiOTUzMDEzNTJlZS4uNWIzNGQxMjE0M2IxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29u dGVudC9pbnNlY3VyZS1pbWFnZS1pbi1qYXZhc2NyaXB0LXVybC1pZnJhbWUtaW4taWZyYW1lLmh0 bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQ b2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4tamF2YXNjcmlw dC11cmwtaWZyYW1lLWluLWlmcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0 bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRh bDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRt bD4KIDxoZWFkPgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv c2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2lu c2VjdXJlLWltYWdlLWluLW1haW4tZnJhbWUuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv c2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2lu c2VjdXJlLWltYWdlLWluLW1haW4tZnJhbWUuaHRtbAppbmRleCBkMGUwZTg3Mjg0NTAuLjk0MzIy OTg1OTg4MSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250 ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2Ut aW4tbWFpbi1mcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkv Y29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWlt YWdlLWluLW1haW4tZnJhbWUuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgor PCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1 c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8 aGVhZD4KIDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3Vy aXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3Vy ZS1pbWFnZS1pbi14c2x0LWRvY3VtZW50LWluLWlmcmFtZS13aXRoLWluaGVyaXRlZC1wb2xpY3ku aHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9s aWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWltYWdlLWluLXhzbHQtZG9jdW1l bnQtaW4taWZyYW1lLXdpdGgtaW5oZXJpdGVkLXBvbGljeS5odG1sCmluZGV4IDhhYmY3ODQzZThm MS4uZjU3MzUyOTA2NTUyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3Vy aXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3Vy ZS1pbWFnZS1pbi14c2x0LWRvY3VtZW50LWluLWlmcmFtZS13aXRoLWluaGVyaXRlZC1wb2xpY3ku aHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0 eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi14c2x0LWRv Y3VtZW50LWluLWlmcmFtZS13aXRoLWluaGVyaXRlZC1wb2xpY3kuaHRtbApAQCAtMSw0ICsxLDQg QEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5u ZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1m YWxzZSBdIC0tPgogPGh0bWw+CiA8aGVhZD4KIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2Vj dXJpdHktUG9saWN5IiBjb250ZW50PSJibG9jay1hbGwtbWl4ZWQtY29udGVudCI+CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGlj eS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1wbHVnaW4taW4taWZyYW1lLmh0bWwg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9i bG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1wbHVnaW4taW4taWZyYW1lLmh0bWwKaW5k ZXggNTk1NWViOGQ1ZTVkLi44ZDUzNmI4NTVhYmQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1j b250ZW50L2luc2VjdXJlLXBsdWdpbi1pbi1pZnJhbWUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQt Y29udGVudC9pbnNlY3VyZS1wbHVnaW4taW4taWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0IEBACi08 IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsg ZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2Ug XSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVk LWNvbnRlbnQvaW5zZWN1cmUtcGx1Z2luLWluLW1haW4tZnJhbWUuaHRtbCBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhl ZC1jb250ZW50L2luc2VjdXJlLXBsdWdpbi1pbi1tYWluLWZyYW1lLmh0bWwKaW5kZXggZTJmMDZk Y2MwMzkyLi5iNzk1ZmM1ZDEyYTQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv c2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2lu c2VjdXJlLXBsdWdpbi1pbi1tYWluLWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRl bnQvaW5zZWN1cmUtcGx1Z2luLWluLW1haW4tZnJhbWUuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwh RE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBl eHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBd IC0tPgogPGh0bWw+CiA8aGVhZD4KIDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQt Y29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4taWZyYW1lLXdpdGgtaW5oZXJpdGVkLXBvbGljeS5o dG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xp Y3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtc2NyaXB0LWluLWlmcmFtZS13aXRo LWluaGVyaXRlZC1wb2xpY3kuaHRtbAppbmRleCA0YTQzMDljOTcyZmQuLjIwMjE5MGMxNjY3MiAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJp dHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtc2NyaXB0LWluLWlmcmFt ZS13aXRoLWluaGVyaXRlZC1wb2xpY3kuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9p bnNlY3VyZS1zY3JpcHQtaW4taWZyYW1lLXdpdGgtaW5oZXJpdGVkLXBvbGljeS5odG1sCkBAIC0x LDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10 ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNF bmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxoZWFkPgogPG1ldGEgaHR0cC1lcXVpdj0iQ29u dGVudC1TZWN1cml0eS1Qb2xpY3kiIGNvbnRlbnQ9ImJsb2NrLWFsbC1taXhlZC1jb250ZW50Ij4K ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3Vy aXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXNjcmlwdC1pbi1pZnJh bWUuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5 UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXNjcmlwdC1pbi1pZnJhbWUu aHRtbAppbmRleCA3NDNiMmYwMzg0ZjguLjYyYzc1MzNkOTIzNSAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxs LW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtc2NyaXB0LWluLWlmcmFtZS5odG1sCisrKyBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFs bC1taXhlZC1jb250ZW50L2luc2VjdXJlLXNjcmlwdC1pbi1pZnJhbWUuaHRtbApAQCAtMSw0ICsx LDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1y dW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxl ZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8aGVhZD4KIDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1h bGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4tbWFpbi1mcmFtZS5odG1sIGIvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2st YWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtc2NyaXB0LWluLW1haW4tZnJhbWUuaHRtbAppbmRl eCBkOWIwZmFmYzM3ZDYuLjYxODQ4MmUwZTQxYiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNv bnRlbnQvaW5zZWN1cmUtc2NyaXB0LWluLW1haW4tZnJhbWUuaHRtbAorKysgYi9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4 ZWQtY29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4tbWFpbi1mcmFtZS5odG1sCkBAIC0xLDQgKzEs NCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1 bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVk PWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxoZWFkPgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFs bC1taXhlZC1jb250ZW50L2luc2VjdXJlLXhoci1hc3luY2hyb25vdXMtaW4taWZyYW1lLmh0bWwg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9i bG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS14aHItYXN5bmNocm9ub3VzLWluLWlmcmFt ZS5odG1sCmluZGV4IDIzNjE2M2IyNTQzYS4uMWQ3OWU1MzYyYjAwIDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1h bGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS14aHItYXN5bmNocm9ub3VzLWluLWlmcmFtZS5odG1s CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9s aWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXhoci1hc3luY2hyb25vdXMtaW4t aWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBo dG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9v cGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8c2Ny aXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50 U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUteGhyLWFzeW5j aHJvbm91cy1pbi1tYWluLWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3Vy aXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3Vy ZS14aHItYXN5bmNocm9ub3VzLWluLW1haW4tZnJhbWUuaHRtbAppbmRleCAxZDk2NjQ1YzI3Njgu LmMxNGQ0NDBjYjUwZSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUt eGhyLWFzeW5jaHJvbm91cy1pbi1tYWluLWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNv bnRlbnQvaW5zZWN1cmUteGhyLWFzeW5jaHJvbm91cy1pbi1tYWluLWZyYW1lLmh0bWwKQEAgLTEs NCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRl c3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0Vu YWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxv Y2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUteGhyLXN5bmNocm9ub3VzLWluLWlmcmFtZS5o dG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xp Y3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUteGhyLXN5bmNocm9ub3VzLWluLWlm cmFtZS5odG1sCmluZGV4IGM1NDczMGQ2OGIzOC4uMWUyOTBhZTU2NjMwIDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9j ay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS14aHItc3luY2hyb25vdXMtaW4taWZyYW1lLmh0 bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQ b2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUteGhyLXN5bmNocm9ub3VzLWlu LWlmcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUg aHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxv b3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxoZWFkPgogPHNj cmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVu dFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXhoci1zeW5j aHJvbm91cy1pbi1tYWluLWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3Vy aXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3Vy ZS14aHItc3luY2hyb25vdXMtaW4tbWFpbi1mcmFtZS5odG1sCmluZGV4IDM2NGU0NWQ0MzlmMi4u Y2YxZTcyZjE3MGUwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5 L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS14 aHItc3luY2hyb25vdXMtaW4tbWFpbi1mcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250 ZW50L2luc2VjdXJlLXhoci1zeW5jaHJvbm91cy1pbi1tYWluLWZyYW1lLmh0bWwKQEAgLTEsNCAr MSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3Qt cnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJs ZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtYmFzaWMt YXV0aC1pbWFnZS1hbGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFs cy5odHRwcy5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRl bnQvaW5zZWN1cmUtYmFzaWMtYXV0aC1pbWFnZS1hbGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2Vz VG9Bc2tGb3JDcmVkZW50aWFscy5odHRwcy5odG1sCmluZGV4IGZkOTc4MzkyYmM5NS4uYzYyMGQx ODUzNDUwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVk Q29udGVudC9pbnNlY3VyZS1iYXNpYy1hdXRoLWltYWdlLWFsbG93Q3Jvc3NPcmlnaW5TdWJyZXNv dXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzLmh0dHBzLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtYmFzaWMtYXV0aC1pbWFnZS1h bGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odHRwcy5odG1s CkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIg WyBBbGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscz10cnVlIF0g LS0+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIEFsbG93Q3Jvc3NP cmlnaW5TdWJyZXNvdXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzPXRydWUgZXhwZXJpbWVudGFsOlRy dXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgog PGhlYWQ+CiA8c2NyaXB0IHNyYz0iL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3QuanMiPjwvc2Ny aXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENv bnRlbnQvaW5zZWN1cmUtYmFzaWMtYXV0aC1pbWFnZS5odHRwcy5odG1sIGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtYmFzaWMtYXV0aC1pbWFn ZS5odHRwcy5odG1sCmluZGV4IDgyMmNjZmI3NzUxNy4uYzE1MjUzOTg5MDkwIDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1i YXNpYy1hdXRoLWltYWdlLmh0dHBzLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9z ZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtYmFzaWMtYXV0aC1pbWFnZS5odHRwcy5odG1s CkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdl YmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRy ZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxoZWFkPgogPHNjcmlwdCBzcmM9Ii9q cy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LmpzIj48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWNzcy1pbi1p ZnJhbWUuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50 L2luc2VjdXJlLWNzcy1pbi1pZnJhbWUuaHRtbAppbmRleCA3OGI5ZjYxYWNlN2MuLmFiMWQ1M2Mw MzliOCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENv bnRlbnQvaW5zZWN1cmUtY3NzLWluLWlmcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWNzcy1pbi1pZnJhbWUuaHRtbApA QCAtMSw0ICsxLDQgQEAKLTxodG1sPgorPGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBl eHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBd IC0tPgogPGJvZHk+CiA8c2NyaXB0PgogaWYgKHdpbmRvdy50ZXN0UnVubmVyKSB7CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3Vy ZS1jc3MtaW4tbWFpbi1mcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtY3NzLWluLW1haW4tZnJhbWUuaHRtbAppbmRleCA4ZDc3 Yzg2ODQ5YWMuLjcyY2NmMWNjYjE0OCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtY3NzLWluLW1haW4tZnJhbWUuaHRtbAor KysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3Vy ZS1jc3MtaW4tbWFpbi1mcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48 IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNr SVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2lu ZG93LnRlc3RSdW5uZXIpIHsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2Vj dXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWV4ZWN1dGFibGUtY3NzLXdpdGgtc2VjdXJlLWNv b2tpZXMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50 L2luc2VjdXJlLWV4ZWN1dGFibGUtY3NzLXdpdGgtc2VjdXJlLWNvb2tpZXMuaHRtbAppbmRleCA0 MTEzZDIzOWFjODkuLjM5MGE1OTk3YWUwZSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtZXhlY3V0YWJsZS1jc3Mtd2l0aC1z ZWN1cmUtY29va2llcy5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkv bWl4ZWRDb250ZW50L2luc2VjdXJlLWV4ZWN1dGFibGUtY3NzLXdpdGgtc2VjdXJlLWNvb2tpZXMu aHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+PCEt LSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQ QWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8Ym9keT4KIDxzY3JpcHQ+CmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9p bnNlY3VyZS1mb3JtLWluLW1haW4tZnJhbWUuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv c2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWZvcm0taW4tbWFpbi1mcmFtZS5odG1sCmlu ZGV4IDA1N2Q1ZDA1NTg2NS4uYTE3OWNiZjkyODczIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1mb3JtLWluLW1haW4tZnJh bWUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVu dC9pbnNlY3VyZS1mb3JtLWluLW1haW4tZnJhbWUuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTxodG1s PgorPGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0 aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGJvZHk+CiA8c2NyaXB0 PgogaWYgKHdpbmRvdy50ZXN0UnVubmVyKSB7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1pZnJhbWUtaW4tbWFpbi1mcmFt ZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5z ZWN1cmUtaWZyYW1lLWluLW1haW4tZnJhbWUuaHRtbAppbmRleCA4YWI4MWUyMjNmMjEuLmRjMDY1 YTJhY2RiOCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhl ZENvbnRlbnQvaW5zZWN1cmUtaWZyYW1lLWluLW1haW4tZnJhbWUuaHRtbAorKysgYi9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1pZnJhbWUtaW4t bWFpbi1mcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdlYmtp dC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNz ZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRlc3RS dW5uZXIpIHsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4 ZWRDb250ZW50L2luc2VjdXJlLWltYWdlLWluLW1haW4tZnJhbWUuaHRtbCBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWltYWdlLWluLW1haW4t ZnJhbWUuaHRtbAppbmRleCA3MDNlYWM4Njc2ZWUuLjQ0MDViYTdkMGVhYyAxMDA2NDQKLS0tIGEv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtaW1h Z2UtaW4tbWFpbi1mcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJp dHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWltYWdlLWluLW1haW4tZnJhbWUuaHRtbApAQCAtMSw0 ICsxLDQgQEAKLTxodG1sPgorPGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmlt ZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgog PGJvZHk+CiA8c2NyaXB0PgogaWYgKHdpbmRvdy50ZXN0UnVubmVyKSB7CmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1pbWFn ZS1yZWRpcmVjdHMtdG8tYmFzaWMtYXV0aC1zZWN1cmUtaW1hZ2UtYWxsb3dDcm9zc09yaWdpblN1 YnJlc291cmNlc1RvQXNrRm9yQ3JlZGVudGlhbHMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWltYWdlLXJlZGlyZWN0cy10by1iYXNp Yy1hdXRoLXNlY3VyZS1pbWFnZS1hbGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JD cmVkZW50aWFscy5odG1sCmluZGV4IGI3OGU2NWQ0MjE1YS4uOTFlMjE1OWZkMmNjIDEwMDY0NAot LS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3Vy ZS1pbWFnZS1yZWRpcmVjdHMtdG8tYmFzaWMtYXV0aC1zZWN1cmUtaW1hZ2UtYWxsb3dDcm9zc09y aWdpblN1YnJlc291cmNlc1RvQXNrRm9yQ3JlZGVudGlhbHMuaHRtbAorKysgYi9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1pbWFnZS1yZWRpcmVj dHMtdG8tYmFzaWMtYXV0aC1zZWN1cmUtaW1hZ2UtYWxsb3dDcm9zc09yaWdpblN1YnJlc291cmNl c1RvQXNrRm9yQ3JlZGVudGlhbHMuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1s PjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgQWxsb3dDcm9zc09yaWdpblN1YnJlc291cmNlc1Rv QXNrRm9yQ3JlZGVudGlhbHM9dHJ1ZSBdIC0tPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQt dGVzdC1ydW5uZXIgWyBBbGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50 aWFscz10cnVlIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFi bGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxib2R5PgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWltYWdl LXJlZGlyZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1pbWFnZS5odG1sIGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtcmVkaXJlY3Rz LXRvLWJhc2ljLWF1dGgtc2VjdXJlLWltYWdlLmh0bWwKaW5kZXggZTY5ZWIyMjJjYmI2Li42ZDc3 M2NjNmQ3MTggMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4 ZWRDb250ZW50L2luc2VjdXJlLWltYWdlLXJlZGlyZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1p bWFnZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250 ZW50L2luc2VjdXJlLWltYWdlLXJlZGlyZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1pbWFnZS5o dG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0t IHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBB ZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxib2R5PgogPHNjcmlwdD4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2lu c2VjdXJlLWltYWdlLXdpdGgtc2VjdXJlY29va2llLWJsb2NrLmh0bWwgYi9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1pbWFnZS13aXRoLXNlY3Vy ZWNvb2tpZS1ibG9jay5odG1sCmluZGV4IGE1ZjIwMTc0MjZmNC4uOWIyZjU0ZTYxNTE3IDEwMDY0 NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNl Y3VyZS1pbWFnZS13aXRoLXNlY3VyZWNvb2tpZS1ibG9jay5odG1sCisrKyBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWltYWdlLXdpdGgtc2Vj dXJlY29va2llLWJsb2NrLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwh RE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0 d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGJv ZHk+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtaW1hZ2Utd2l0aC1zZWN1cmVjb29raWUuaHRtbCBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWltYWdl LXdpdGgtc2VjdXJlY29va2llLmh0bWwKaW5kZXggMDBkYjI3ZDE5OGQ0Li5lMzlkMGM2Mzk4M2Yg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50 L2luc2VjdXJlLWltYWdlLXdpdGgtc2VjdXJlY29va2llLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtaW1hZ2Utd2l0aC1zZWN1 cmVjb29raWUuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBF IGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlM b29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8Ym9keT4KIDxz Y3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVk Q29udGVudC9pbnNlY3VyZS1wbHVnaW4taW4taWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1wbHVnaW4taW4taWZyYW1lLmh0 bWwKaW5kZXggZjc1MjBiNmZlNWM4Li5mZTllNWMxOTdiOGYgMTAwNjQ0Ci0tLSBhL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXBsdWdpbi1pbi1p ZnJhbWUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29u dGVudC9pbnNlY3VyZS1wbHVnaW4taW4taWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0IEBACi08aHRt bD4KKzxodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29y dGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxib2R5PgogPHNjcmlw dD4KIGlmICh3aW5kb3cudGVzdFJ1bm5lcikKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXNjcmlwdC1pbi1kYXRhLWlmcmFt ZS1pbi1tYWluLWZyYW1lLWJsb2NrZWQuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2Vj dXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXNjcmlwdC1pbi1kYXRhLWlmcmFtZS1pbi1tYWlu LWZyYW1lLWJsb2NrZWQuaHRtbAppbmRleCBhNmFmOTY5ZDZiOGQuLjZkYzYxZmEyMDRkYSAxMDA2 NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5z ZWN1cmUtc2NyaXB0LWluLWRhdGEtaWZyYW1lLWluLW1haW4tZnJhbWUtYmxvY2tlZC5odG1sCisr KyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJl LXNjcmlwdC1pbi1kYXRhLWlmcmFtZS1pbi1tYWluLWZyYW1lLWJsb2NrZWQuaHRtbApAQCAtMSw0 ICsxLDQgQEAKLTxodG1sPgorPGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmlt ZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgog PGJvZHk+CiA8c2NyaXB0PgogaWYgKHdpbmRvdy50ZXN0UnVubmVyICYmIHdpbmRvdy5pbnRlcm5h bHMpIHsKQEAgLTIxLDQgKzIxLDQgQEAgZGF0YTogZnJhbWUgaGFzIGEgc2VwYXJhdGUgb3JpZ2lu LCB0aGUgc2NyaXB0IGNhbiBzdGlsbCBuYXZpZ2F0ZSB0b3AuCiB3aW5kb3cub3BlbigiaHR0cHM6 Ly8xMjcuMC4wLjE6ODQ0My9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVzb3VyY2VzL2ZyYW1lLXdp dGgtZGF0YS11cmwtZnJhbWUtd2l0aC1zY3JpcHQuaHRtbCIpOwogPC9zY3JpcHQ+CiA8L2JvZHk+ Ci08L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQorPC9odG1sPgpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUt c2NyaXB0LWluLWlmcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9t aXhlZENvbnRlbnQvaW5zZWN1cmUtc2NyaXB0LWluLWlmcmFtZS5odG1sCmluZGV4IDQ4MTgyMzc3 OGMzYy4uZGVkMDY3YzUxODJjIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Nl Y3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4taWZyYW1lLmh0bWwKKysrIGIv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtc2Ny aXB0LWluLWlmcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdl YmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRy ZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRl c3RSdW5uZXIpCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21p eGVkQ29udGVudC9pbnNlY3VyZS1zY3JpcHQtcmVkaXJlY3RzLXRvLWJhc2ljLWF1dGgtc2VjdXJl LXNjcmlwdC5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRl bnQvaW5zZWN1cmUtc2NyaXB0LXJlZGlyZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1zY3JpcHQu aHRtbAppbmRleCAyMTFiYTlmNWRjZTguLjE1ZDYzZmJjOWM3ZiAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtc2NyaXB0LXJl ZGlyZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1zY3JpcHQuaHRtbAorKysgYi9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1zY3JpcHQtcmVkaXJl Y3RzLXRvLWJhc2ljLWF1dGgtc2VjdXJlLXNjcmlwdC5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFE T0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4 cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0g LS0+CiA8aHRtbD4KIDxib2R5PgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXNjcmlwdC13aXRoLXNlY3Vy ZS1jb29raWVzLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29u dGVudC9pbnNlY3VyZS1zY3JpcHQtd2l0aC1zZWN1cmUtY29va2llcy5odG1sCmluZGV4IDkxMWRm NGE1NGVhZi4uYWEyODAwMTk1NDQ5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1zY3JpcHQtd2l0aC1zZWN1cmUtY29va2ll cy5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50 L2luc2VjdXJlLXNjcmlwdC13aXRoLXNlY3VyZS1jb29raWVzLmh0bWwKQEAgLTEsNCArMSw0IEBA Ci08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVy IFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFs c2UgXSAtLT4KIDxodG1sPgogPGJvZHk+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtc3R5bGVzaGVldC1y ZWRpcmVjdHMtdG8tYmFzaWMtYXV0aC1zZWN1cmUtc3R5bGVzaGVldC5odG1sIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtc3R5bGVzaGVldC1y ZWRpcmVjdHMtdG8tYmFzaWMtYXV0aC1zZWN1cmUtc3R5bGVzaGVldC5odG1sCmluZGV4IDNmYTcx MzJkNDgzMy4uYTk2ZDUxY2RiMGEzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1zdHlsZXNoZWV0LXJlZGlyZWN0cy10by1i YXNpYy1hdXRoLXNlY3VyZS1zdHlsZXNoZWV0Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtc3R5bGVzaGVldC1yZWRpcmVjdHMt dG8tYmFzaWMtYXV0aC1zZWN1cmUtc3R5bGVzaGVldC5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFE T0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4 cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0g LS0+CiA8aHRtbD4KIDxib2R5PgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXhoci1pbi1tYWluLWZyYW1l Lmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNl Y3VyZS14aHItaW4tbWFpbi1mcmFtZS5odG1sCmluZGV4IDY2MjFhYzBhYTI1MC4uODY3ODE2Nzg5 YjBmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29u dGVudC9pbnNlY3VyZS14aHItaW4tbWFpbi1mcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXhoci1pbi1tYWluLWZyYW1l Lmh0bWwKQEAgLTEsNCArMSw0IEBACi08aHRtbD4KKzxodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVu bmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9 ZmFsc2UgXSAtLT4KIDxib2R5PgogPHNjcmlwdD4KIGlmICh3aW5kb3cudGVzdFJ1bm5lcikgewpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQv aW5zZWN1cmUteGhyLXN5bmMtaW4tbWFpbi1mcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUteGhyLXN5bmMtaW4tbWFpbi1mcmFt ZS5odG1sCmluZGV4IDdjZjM5NGEwYzM3Mi4uYjdkY2YzNDJlMTM1IDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS14aHItc3lu Yy1pbi1tYWluLWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9taXhlZENvbnRlbnQvaW5zZWN1cmUteGhyLXN5bmMtaW4tbWFpbi1mcmFtZS5odG1sCkBAIC0x LDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVy aW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+ CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRlc3RSdW5uZXIpIHsKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0 dHAtdG8taHR0cHMtaWZyYW1lLWluLW1haW4tZnJhbWUuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHAtdG8taHR0cHMtaWZyYW1l LWluLW1haW4tZnJhbWUuaHRtbAppbmRleCA2Mzc3ZDU1MmJmYWYuLjFjZGNlM2Q4ODBmMyAxMDA2 NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVk aXJlY3QtaHR0cC10by1odHRwcy1pZnJhbWUtaW4tbWFpbi1mcmFtZS5odG1sCisrKyBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHAtdG8t aHR0cHMtaWZyYW1lLWluLW1haW4tZnJhbWUuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTxodG1sPgor PGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlM b29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGJvZHk+CiA8c2NyaXB0Pgog aWYgKHdpbmRvdy50ZXN0UnVubmVyKSB7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVjdC1odHRwLXRvLWh0dHBzLXNjcmlwdC1p bi1pZnJhbWUuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250 ZW50L3JlZGlyZWN0LWh0dHAtdG8taHR0cHMtc2NyaXB0LWluLWlmcmFtZS5odG1sCmluZGV4IDhj N2I2YzU2ZWU1Yy4uMjM0MTM4Nzg4MDY3IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVjdC1odHRwLXRvLWh0dHBzLXNjcmlwdC1p bi1pZnJhbWUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVk Q29udGVudC9yZWRpcmVjdC1odHRwLXRvLWh0dHBzLXNjcmlwdC1pbi1pZnJhbWUuaHRtbApAQCAt MSw0ICsxLDQgQEAKLTxodG1sPgorPGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBl cmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0t PgogPGJvZHk+CiA8c2NyaXB0PgogaWYgKHdpbmRvdy50ZXN0UnVubmVyKSB7CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVjdC1o dHRwcy10by1odHRwLWlmcmFtZS1pbi1tYWluLWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVjdC1odHRwcy10by1odHRwLWlmcmFt ZS1pbi1tYWluLWZyYW1lLmh0bWwKaW5kZXggOTkzNDY0ZjhjYTY0Li44YmFlZjQ4YzZjODcgMTAw NjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3Jl ZGlyZWN0LWh0dHBzLXRvLWh0dHAtaWZyYW1lLWluLW1haW4tZnJhbWUuaHRtbAorKysgYi9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVjdC1odHRwcy10 by1odHRwLWlmcmFtZS1pbi1tYWluLWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0IEBACi08aHRtbD4K KzxodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5 TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxib2R5PgogPHNjcmlwdD4K IGlmICh3aW5kb3cudGVzdFJ1bm5lcikgewpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cHMtdG8taHR0cC1pbWFnZS1z ZWN1cmUtY29va2llcy1ibG9jay5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cHMtdG8taHR0cC1pbWFnZS1zZWN1cmUtY29va2ll cy1ibG9jay5odG1sCmluZGV4IDgxNGY2OGJhOTM5My4uMWU0YjYyYzAxOGY1IDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVjdC1o dHRwcy10by1odHRwLWltYWdlLXNlY3VyZS1jb29raWVzLWJsb2NrLmh0bWwKKysrIGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cHMtdG8t aHR0cC1pbWFnZS1zZWN1cmUtY29va2llcy1ibG9jay5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFE T0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4 cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0g LS0+CiA8aHRtbD4KIDxib2R5PgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHBzLXRvLWh0dHAtaW1h Z2Utc2VjdXJlLWNvb2tpZXMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkv bWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHBzLXRvLWh0dHAtaW1hZ2Utc2VjdXJlLWNvb2tpZXMu aHRtbAppbmRleCBjZGE4MDJkMDMwYTkuLjA1OTE3Yzg2Mjg0OSAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cHMtdG8t aHR0cC1pbWFnZS1zZWN1cmUtY29va2llcy5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHBzLXRvLWh0dHAtaW1hZ2Utc2Vj dXJlLWNvb2tpZXMuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NU WVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0 aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8Ym9keT4K IDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21p eGVkQ29udGVudC9yZWRpcmVjdC1odHRwcy10by1odHRwLXNjcmlwdC1pbi1pZnJhbWUuaHRtbCBi L0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0 dHBzLXRvLWh0dHAtc2NyaXB0LWluLWlmcmFtZS5odG1sCmluZGV4IGFhMmFjY2U3OTkxNy4uNGJl ZGY1ZTQ4ZWViIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21p eGVkQ29udGVudC9yZWRpcmVjdC1odHRwcy10by1odHRwLXNjcmlwdC1pbi1pZnJhbWUuaHRtbAor KysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVj dC1odHRwcy10by1odHRwLXNjcmlwdC1pbi1pZnJhbWUuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTxo dG1sPgorPGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3 b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGJvZHk+CiA8c2Ny aXB0PgogaWYgKHdpbmRvdy50ZXN0UnVubmVyKSB7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9zZWN1cmUtcmVkaXJlY3QtdG8taW5zZWN1 cmUtcmVkaXJlY3QtdG8tYmFzaWMtYXV0aC1zZWN1cmUtaW1hZ2UtYWxsb3dDcm9zc09yaWdpblN1 YnJlc291cmNlc1RvQXNrRm9yQ3JlZGVudGlhbHMuaHR0cHMuaHRtbCBiL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3NlY3VyZS1yZWRpcmVjdC10by1pbnNlY3Vy ZS1yZWRpcmVjdC10by1iYXNpYy1hdXRoLXNlY3VyZS1pbWFnZS1hbGxvd0Nyb3NzT3JpZ2luU3Vi cmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odHRwcy5odG1sCmluZGV4IGY3ZGU2NjliNmVj Zi4uNjlhZDUzNzlhMDkzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3Vy aXR5L21peGVkQ29udGVudC9zZWN1cmUtcmVkaXJlY3QtdG8taW5zZWN1cmUtcmVkaXJlY3QtdG8t YmFzaWMtYXV0aC1zZWN1cmUtaW1hZ2UtYWxsb3dDcm9zc09yaWdpblN1YnJlc291cmNlc1RvQXNr Rm9yQ3JlZGVudGlhbHMuaHR0cHMuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Nl Y3VyaXR5L21peGVkQ29udGVudC9zZWN1cmUtcmVkaXJlY3QtdG8taW5zZWN1cmUtcmVkaXJlY3Qt dG8tYmFzaWMtYXV0aC1zZWN1cmUtaW1hZ2UtYWxsb3dDcm9zc09yaWdpblN1YnJlc291cmNlc1Rv QXNrRm9yQ3JlZGVudGlhbHMuaHR0cHMuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBo dG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgQWxsb3dDcm9zc09yaWdpblN1YnJlc291cmNl c1RvQXNrRm9yQ3JlZGVudGlhbHM9dHJ1ZSBdIC0tPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJr aXQtdGVzdC1ydW5uZXIgWyBBbGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVk ZW50aWFscz10cnVlIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNF bmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxib2R5PgogPHNjcmlwdCBzcmM9Ii9qcy10ZXN0 LXJlc291cmNlcy9qcy10ZXN0LmpzIj48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3NlY3VyZS1yZWRpcmVjdC10by1pbnNl Y3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRoLXNlY3VyZS1pbWFnZS5odHRwcy5odG1sIGIvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvc2VjdXJlLXJlZGlyZWN0 LXRvLWluc2VjdXJlLXJlZGlyZWN0LXRvLWJhc2ljLWF1dGgtc2VjdXJlLWltYWdlLmh0dHBzLmh0 bWwKaW5kZXggZWNiNjlmM2FjZGYwLi4wM2E2YjcyZDhiM2QgMTAwNjQ0Ci0tLSBhL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3NlY3VyZS1yZWRpcmVjdC10by1p bnNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRoLXNlY3VyZS1pbWFnZS5odHRwcy5odG1sCisr KyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3NlY3VyZS1y ZWRpcmVjdC10by1pbnNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRoLXNlY3VyZS1pbWFnZS5o dHRwcy5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRt bD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3Bi YWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxib2R5PgogPHNjcmlw dCBzcmM9Ii9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LmpzIj48L3NjcmlwdD4KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3NlY3VyZS1y ZWRpcmVjdC10by1zZWN1cmUtcmVkaXJlY3QtdG8tYmFzaWMtYXV0aC1pbnNlY3VyZS1pbWFnZS1h bGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odHRwcy5odG1s IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvc2VjdXJlLXJl ZGlyZWN0LXRvLXNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRoLWluc2VjdXJlLWltYWdlLWFs bG93Q3Jvc3NPcmlnaW5TdWJyZXNvdXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzLmh0dHBzLmh0bWwK aW5kZXggODM4NWI2NDEwMzUzLi5kOWQxM2E5NTEyYmEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3NlY3VyZS1yZWRpcmVjdC10by1zZWN1 cmUtcmVkaXJlY3QtdG8tYmFzaWMtYXV0aC1pbnNlY3VyZS1pbWFnZS1hbGxvd0Nyb3NzT3JpZ2lu U3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odHRwcy5odG1sCisrKyBiL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3NlY3VyZS1yZWRpcmVjdC10by1z ZWN1cmUtcmVkaXJlY3QtdG8tYmFzaWMtYXV0aC1pbnNlY3VyZS1pbWFnZS1hbGxvd0Nyb3NzT3Jp Z2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odHRwcy5odG1sCkBAIC0xLDQgKzEs NCBAQAotPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBBbGxvd0Nyb3Nz T3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscz10cnVlIF0gLS0+Cis8IURPQ1RZ UEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIEFsbG93Q3Jvc3NPcmlnaW5TdWJyZXNv dXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzPXRydWUgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9v cGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGJvZHk+CiA8c2Ny aXB0IHNyYz0iL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3QuanMiPjwvc2NyaXB0PgpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvc2VjdXJl LXJlZGlyZWN0LXRvLXNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRoLWluc2VjdXJlLWltYWdl Lmh0dHBzLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVu dC9zZWN1cmUtcmVkaXJlY3QtdG8tc2VjdXJlLXJlZGlyZWN0LXRvLWJhc2ljLWF1dGgtaW5zZWN1 cmUtaW1hZ2UuaHR0cHMuaHRtbAppbmRleCAzMGNjYzYwNTRjOTAuLmNjNjY5M2RiZTcwZSAxMDA2 NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvc2Vj dXJlLXJlZGlyZWN0LXRvLXNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRoLWluc2VjdXJlLWlt YWdlLmh0dHBzLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhl ZENvbnRlbnQvc2VjdXJlLXJlZGlyZWN0LXRvLXNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRo LWluc2VjdXJlLWltYWdlLmh0dHBzLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRt bD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFs OlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1s PgogPGJvZHk+CiA8c2NyaXB0IHNyYz0iL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3QuanMiPjwv c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhl ZGNvbnRlbnQtZ2VvbG9jYXRpb24tYmxvY2staW5zZWN1cmUtY29udGVudC5odG1sIGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZGNvbnRlbnQtZ2VvbG9jYXRpb24tYmxvY2st aW5zZWN1cmUtY29udGVudC5odG1sCmluZGV4IDdlMGExZDM0YzI2My4uMWFkZDNlMTg0YTk5IDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkY29udGVudC1n ZW9sb2NhdGlvbi1ibG9jay1pbnNlY3VyZS1jb250ZW50Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZGNvbnRlbnQtZ2VvbG9jYXRpb24tYmxvY2staW5zZWN1 cmUtY29udGVudC5odG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdlYmtp dC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNz ZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRlc3RS dW5uZXIpIHsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4 ZWRjb250ZW50LWdlb2xvY2F0aW9uLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3Vy aXR5L21peGVkY29udGVudC1nZW9sb2NhdGlvbi5odG1sCmluZGV4IDFkMjViMjZjY2Y4Zi4uZTMz OTY4ZjFmODYxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21p eGVkY29udGVudC1nZW9sb2NhdGlvbi5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv c2VjdXJpdHkvbWl4ZWRjb250ZW50LWdlb2xvY2F0aW9uLmh0bWwKQEAgLTEsNCArMSw0IEBACi08 aHRtbD4KKzxodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0 d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxib2R5PgogPHNj cmlwdD4KIGlmICh3aW5kb3cudGVzdFJ1bm5lcikgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi9T Y3JpcHRzL1ByZWZlcmVuY2VzL1dlYlByZWZlcmVuY2VzRXhwZXJpbWVudGFsLnlhbWwgYi9Tb3Vy Y2UvV1RGL1NjcmlwdHMvUHJlZmVyZW5jZXMvV2ViUHJlZmVyZW5jZXNFeHBlcmltZW50YWwueWFt bAppbmRleCA0NWZiMGI3OTU4NDUuLmQzNWMwYjkzY2ZiZCAxMDA2NDQKLS0tIGEvU291cmNlL1dU Ri9TY3JpcHRzL1ByZWZlcmVuY2VzL1dlYlByZWZlcmVuY2VzRXhwZXJpbWVudGFsLnlhbWwKKysr IGIvU291cmNlL1dURi9TY3JpcHRzL1ByZWZlcmVuY2VzL1dlYlByZWZlcmVuY2VzRXhwZXJpbWVu dGFsLnlhbWwKQEAgLTgwMiw2ICs4MDIsMzIgQEAgVHJhbnNmb3JtU3RyZWFtQVBJRW5hYmxlZDoK ICAgICBXZWJLaXQ6CiAgICAgICBkZWZhdWx0OiB0cnVlCiAKKyMgaHR0cHM6Ly93M2MuZ2l0aHVi LmlvL3dlYmFwcHNlYy1zZWN1cmUtY29udGV4dHMvI2lzLW9yaWdpbi10cnVzdHdvcnRoeQorVHJ1 c3R3b3J0aHlMb2NhbGhvc3RBZGRyZXNzZXNFbmFibGVkOgorICB0eXBlOiBib29sCisgIGh1bWFu UmVhZGFibGVOYW1lOiAiVHJ1c3R3b3J0aHkgbG9jYWxob3N0IGFkZHJlc3NlcyIKKyAgaHVtYW5S ZWFkYWJsZURlc2NyaXB0aW9uOiAiVHJlYXQgaG9zdHMgbWF0Y2hpbmcgJ2xvY2FsaG9zdCcsIG9y IGZhbGxpbmcgd2l0aGluICcubG9jYWxob3N0JywgYXMgJ1BvdGVudGlhbGx5IFRydXN0d29ydGh5 Jy4iCisgIGRlZmF1bHRWYWx1ZToKKyAgICBXZWJLaXRMZWdhY3k6CisgICAgICBkZWZhdWx0OiBm YWxzZQorICAgIFdlYktpdDoKKyAgICAgIGRlZmF1bHQ6IGZhbHNlCisgICAgV2ViQ29yZToKKyAg ICAgIGRlZmF1bHQ6IGZhbHNlCisKKyMgaHR0cHM6Ly93M2MuZ2l0aHViLmlvL3dlYmFwcHNlYy1z ZWN1cmUtY29udGV4dHMvI2lzLW9yaWdpbi10cnVzdHdvcnRoeQorVHJ1c3R3b3J0aHlMb29wYmFj a0lQQWRkcmVzc2VzRW5hYmxlZDoKKyAgdHlwZTogYm9vbAorICBodW1hblJlYWRhYmxlTmFtZTog IlRydXN0d29ydGh5IGxvb3BiYWNrIElQIGFkZHJlc3NlcyIKKyAgaHVtYW5SZWFkYWJsZURlc2Ny aXB0aW9uOiAiVHJlYXQgaG9zdHMgbWF0Y2hpbmcgb25lIG9mIHRoZSBDSURSIG5vdGF0aW9ucyAx MjcuMC4wLjAvOCBvciA6OjEvMTI4IGFzICdQb3RlbnRpYWxseSBUcnVzdHdvcnRoeScuIgorICBk ZWZhdWx0VmFsdWU6CisgICAgV2ViS2l0TGVnYWN5OgorICAgICAgZGVmYXVsdDogdHJ1ZQorICAg IFdlYktpdDoKKyAgICAgIGRlZmF1bHQ6IHRydWUKKyAgICBXZWJDb3JlOgorICAgICAgZGVmYXVs dDogdHJ1ZQorCiBVc2VyR2VzdHVyZVByb21pc2VQcm9wYWdhdGlvbkVuYWJsZWQ6CiAgIHR5cGU6 IGJvb2wKICAgaHVtYW5SZWFkYWJsZU5hbWU6ICJVc2VyR2VzdHVyZSBQcm9taXNlIFByb3BhZ2F0 aW9uIgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9wYXJzZXIvWFNTQXVkaXRvci5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL3BhcnNlci9YU1NBdWRpdG9yLmNwcAppbmRleCBiY2I4 ODVlYWRkNzMuLjY0MTNiOGJiMzFjMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9w YXJzZXIvWFNTQXVkaXRvci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9wYXJzZXIvWFNT QXVkaXRvci5jcHAKQEAgLTMyNCw3ICszMjQsNyBAQCB2b2lkIFhTU0F1ZGl0b3I6OmluaXQoRG9j dW1lbnQqIGRvY3VtZW50LCBYU1NBdWRpdG9yRGVsZWdhdGUqIGF1ZGl0b3JEZWxlZ2F0ZSkKIAog ICAgICAgICBpZiAoKG1feHNzUHJvdGVjdGlvbiA9PSBYU1NQcm90ZWN0aW9uRGlzcG9zaXRpb246 OkVuYWJsZWQgfHwgbV94c3NQcm90ZWN0aW9uID09IFhTU1Byb3RlY3Rpb25EaXNwb3NpdGlvbjo6 QmxvY2tFbmFibGVkKSAmJiAhcGFyc2VkUmVwb3J0VVJMLmlzRW1wdHkoKSkgewogICAgICAgICAg ICAgcmVwb3J0VVJMID0gZG9jdW1lbnQtPmNvbXBsZXRlVVJMKHBhcnNlZFJlcG9ydFVSTCk7Ci0g ICAgICAgICAgICBpZiAoTWl4ZWRDb250ZW50Q2hlY2tlcjo6aXNNaXhlZENvbnRlbnQoZG9jdW1l bnQtPnNlY3VyaXR5T3JpZ2luKCksIHJlcG9ydFVSTCkpIHsKKyAgICAgICAgICAgIGlmIChNaXhl ZENvbnRlbnRDaGVja2VyOjppc01peGVkQ29udGVudChkb2N1bWVudC0+c2V0dGluZ3MoKSwgZG9j dW1lbnQtPnNlY3VyaXR5T3JpZ2luKCksIHJlcG9ydFVSTCkpIHsKICAgICAgICAgICAgICAgICBl cnJvckRldGFpbHMgPSAiaW5zZWN1cmUgcmVwb3J0aW5nIFVSTCBmb3Igc2VjdXJlIHBhZ2UiOwog ICAgICAgICAgICAgICAgIG1feHNzUHJvdGVjdGlvbiA9IFhTU1Byb3RlY3Rpb25EaXNwb3NpdGlv bjo6SW52YWxpZDsKICAgICAgICAgICAgICAgICByZXBvcnRVUkwgPSBVUkwoKTsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9NaXhlZENvbnRlbnRDaGVja2VyLmNwcCBiL1NvdXJj ZS9XZWJDb3JlL2xvYWRlci9NaXhlZENvbnRlbnRDaGVja2VyLmNwcAppbmRleCBhN2I2YmY2NzNh ZDYuLjkyOTkwYmQ3NDk1ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL01peGVk Q29udGVudENoZWNrZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9NaXhlZENvbnRl bnRDaGVja2VyLmNwcApAQCAtNTMsMTggKzUzLDIxIEBAIEZyYW1lTG9hZGVyQ2xpZW50JiBNaXhl ZENvbnRlbnRDaGVja2VyOjpjbGllbnQoKSBjb25zdAogfQogCiAvLyBzdGF0aWMKLWJvb2wgTWl4 ZWRDb250ZW50Q2hlY2tlcjo6aXNNaXhlZENvbnRlbnQoU2VjdXJpdHlPcmlnaW4mIHNlY3VyaXR5 T3JpZ2luLCBjb25zdCBVUkwmIHVybCkKK2Jvb2wgTWl4ZWRDb250ZW50Q2hlY2tlcjo6aXNNaXhl ZENvbnRlbnQoY29uc3QgU2V0dGluZ3MmIHNldHRpbmdzLCBTZWN1cml0eU9yaWdpbiYgc2VjdXJp dHlPcmlnaW4sIGNvbnN0IFVSTCYgdXJsKQogewogICAgIGlmIChzZWN1cml0eU9yaWdpbi5wcm90 b2NvbCgpICE9ICJodHRwcyIpCiAgICAgICAgIHJldHVybiBmYWxzZTsgLy8gV2Ugb25seSBjYXJl IGFib3V0IEhUVFBTIHNlY3VyaXR5IG9yaWdpbnMuCiAKKyAgICBpZiAoU2VjdXJpdHlPcmlnaW46 OmlzQVByaW9yaXR5QXV0aGVudGljYXRlZFVSTChzZXR0aW5ncywgdXJsKSkKKyAgICAgICAgcmV0 dXJuIGZhbHNlOyAvLyBhIHByaW9yaSBhdXRoZW50aWNhdGVkIHVybHMgYXJlIG5vdCBtaXhlZCBj b250ZW50LgorCiAgICAgLy8gV2UncmUgaW4gYSBzZWN1cmUgY29udGV4dCwgc28gfHVybHwgaXMg bWl4ZWQgY29udGVudCBpZiBpdCdzIGluc2VjdXJlLgogICAgIHJldHVybiAhU2VjdXJpdHlPcmln aW46OmlzU2VjdXJlKHVybCk7CiB9CiAKIGJvb2wgTWl4ZWRDb250ZW50Q2hlY2tlcjo6Y2FuRGlz cGxheUluc2VjdXJlQ29udGVudChTZWN1cml0eU9yaWdpbiYgc2VjdXJpdHlPcmlnaW4sIENvbnRl bnRUeXBlIHR5cGUsIGNvbnN0IFVSTCYgdXJsLCBBbHdheXNEaXNwbGF5SW5Ob25TdHJpY3RNb2Rl IGFsd2F5c0Rpc3BsYXlJbk5vblN0cmljdE1vZGUpIGNvbnN0CiB7Ci0gICAgaWYgKCFpc01peGVk Q29udGVudChzZWN1cml0eU9yaWdpbiwgdXJsKSkKKyAgICBpZiAoIWlzTWl4ZWRDb250ZW50KG1f ZnJhbWUuc2V0dGluZ3MoKSwgc2VjdXJpdHlPcmlnaW4sIHVybCkpCiAgICAgICAgIHJldHVybiB0 cnVlOwogCiAgICAgaWYgKCFtX2ZyYW1lLmRvY3VtZW50KCktPmNvbnRlbnRTZWN1cml0eVBvbGlj eSgpLT5hbGxvd1J1bm5pbmdPckRpc3BsYXlpbmdJbnNlY3VyZUNvbnRlbnQodXJsKSkKQEAgLTg3 LDcgKzkwLDcgQEAgYm9vbCBNaXhlZENvbnRlbnRDaGVja2VyOjpjYW5EaXNwbGF5SW5zZWN1cmVD b250ZW50KFNlY3VyaXR5T3JpZ2luJiBzZWN1cml0eU9yaWcKIAogYm9vbCBNaXhlZENvbnRlbnRD aGVja2VyOjpjYW5SdW5JbnNlY3VyZUNvbnRlbnQoU2VjdXJpdHlPcmlnaW4mIHNlY3VyaXR5T3Jp Z2luLCBjb25zdCBVUkwmIHVybCkgY29uc3QKIHsKLSAgICBpZiAoIWlzTWl4ZWRDb250ZW50KHNl Y3VyaXR5T3JpZ2luLCB1cmwpKQorICAgIGlmICghaXNNaXhlZENvbnRlbnQobV9mcmFtZS5zZXR0 aW5ncygpLCBzZWN1cml0eU9yaWdpbiwgdXJsKSkKICAgICAgICAgcmV0dXJuIHRydWU7CiAKICAg ICBpZiAoIW1fZnJhbWUuZG9jdW1lbnQoKS0+Y29udGVudFNlY3VyaXR5UG9saWN5KCktPmFsbG93 UnVubmluZ09yRGlzcGxheWluZ0luc2VjdXJlQ29udGVudCh1cmwpKQpAQCAtMTExLDcgKzExNCw3 IEBAIHZvaWQgTWl4ZWRDb250ZW50Q2hlY2tlcjo6Y2hlY2tGb3JtRm9yTWl4ZWRDb250ZW50KFNl Y3VyaXR5T3JpZ2luJiBzZWN1cml0eU9yaWdpCiAgICAgaWYgKHVybC5wcm90b2NvbElzSmF2YVNj cmlwdCgpKQogICAgICAgICByZXR1cm47CiAKLSAgICBpZiAoIWlzTWl4ZWRDb250ZW50KHNlY3Vy aXR5T3JpZ2luLCB1cmwpKQorICAgIGlmICghaXNNaXhlZENvbnRlbnQobV9mcmFtZS5zZXR0aW5n cygpLCBzZWN1cml0eU9yaWdpbiwgdXJsKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgU3RyaW5n IG1lc3NhZ2UgPSBtYWtlU3RyaW5nKCJUaGUgcGFnZSBhdCAiLCBtX2ZyYW1lLmRvY3VtZW50KCkt PnVybCgpLnN0cmluZ0NlbnRlckVsbGlwc2l6ZWRUb0xlbmd0aCgpLCAiIGNvbnRhaW5zIGEgZm9y bSB3aGljaCB0YXJnZXRzIGFuIGluc2VjdXJlIFVSTCAiLCB1cmwuc3RyaW5nQ2VudGVyRWxsaXBz aXplZFRvTGVuZ3RoKCksICIuXG4iKTsKQEAgLTEyOCw3ICsxMzEsNyBAQCBPcHRpb25hbDxTdHJp bmc+IE1peGVkQ29udGVudENoZWNrZXI6OmNoZWNrRm9yTWl4ZWRDb250ZW50SW5GcmFtZVRyZWUo Y29uc3QgVVJMJgogICAgICAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UoZG9jdW1lbnQt PmZyYW1lKCksICJBbiB1bnBhcmVudGVkIGRvY3VtZW50IHRyaWVkIHRvIGNvbm5lY3QgdG8gYSB3 ZWJzb2NrZXQgd2l0aCB1cmw6ICVzIiwgdXJsLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOwogICAg ICAgICAKICAgICAgICAgYXV0byogZnJhbWUgPSBkb2N1bWVudC0+ZnJhbWUoKTsKLSAgICAgICAg aWYgKGlzTWl4ZWRDb250ZW50KGRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpLCB1cmwpKQorICAg ICAgICBpZiAoaXNNaXhlZENvbnRlbnQoZG9jdW1lbnQtPnNldHRpbmdzKCksIGRvY3VtZW50LT5z ZWN1cml0eU9yaWdpbigpLCB1cmwpKQogICAgICAgICAgICAgcmV0dXJuIG1ha2VTdHJpbmcoIlRo ZSBwYWdlIGF0ICIsIGRvY3VtZW50LT51cmwoKS5zdHJpbmdDZW50ZXJFbGxpcHNpemVkVG9MZW5n dGgoKSwgIiB3YXMgYmxvY2tlZCBmcm9tIGNvbm5lY3RpbmcgaW5zZWN1cmVseSB0byAiLCB1cmwu c3RyaW5nQ2VudGVyRWxsaXBzaXplZFRvTGVuZ3RoKCksICIgZWl0aGVyIGJlY2F1c2UgdGhlIHBy b3RvY29sIGlzIGluc2VjdXJlIG9yIHRoZSBwYWdlIGlzIGVtYmVkZGVkIGZyb20gYW4gaW5zZWN1 cmUgcGFnZS4iKTsKIAogICAgICAgICBpZiAoZnJhbWUtPmlzTWFpbkZyYW1lKCkpCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvTWl4ZWRDb250ZW50Q2hlY2tlci5oIGIvU291cmNl L1dlYkNvcmUvbG9hZGVyL01peGVkQ29udGVudENoZWNrZXIuaAppbmRleCA2ODg5ZTVmNDE0YjIu LmIzZWIxZTE4YzAyNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL01peGVkQ29u dGVudENoZWNrZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvTWl4ZWRDb250ZW50Q2hl Y2tlci5oCkBAIC0zOCw2ICszOCw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIGNsYXNzIEZyYW1l OwogY2xhc3MgRnJhbWVMb2FkZXJDbGllbnQ7CiBjbGFzcyBTZWN1cml0eU9yaWdpbjsKK2NsYXNz IFNldHRpbmdzOwogCiBjbGFzcyBNaXhlZENvbnRlbnRDaGVja2VyIHsKICAgICBXVEZfTUFLRV9O T05DT1BZQUJMRShNaXhlZENvbnRlbnRDaGVja2VyKTsKQEAgLTU3LDcgKzU4LDcgQEAgcHVibGlj OgogICAgIGJvb2wgY2FuRGlzcGxheUluc2VjdXJlQ29udGVudChTZWN1cml0eU9yaWdpbiYsIENv bnRlbnRUeXBlLCBjb25zdCBVUkwmLCBBbHdheXNEaXNwbGF5SW5Ob25TdHJpY3RNb2RlID0gQWx3 YXlzRGlzcGxheUluTm9uU3RyaWN0TW9kZTo6Tm8pIGNvbnN0OwogICAgIGJvb2wgY2FuUnVuSW5z ZWN1cmVDb250ZW50KFNlY3VyaXR5T3JpZ2luJiwgY29uc3QgVVJMJikgY29uc3Q7CiAgICAgdm9p ZCBjaGVja0Zvcm1Gb3JNaXhlZENvbnRlbnQoU2VjdXJpdHlPcmlnaW4mLCBjb25zdCBVUkwmKSBj b25zdDsKLSAgICBzdGF0aWMgYm9vbCBpc01peGVkQ29udGVudChTZWN1cml0eU9yaWdpbiYsIGNv bnN0IFVSTCYpOworICAgIHN0YXRpYyBib29sIGlzTWl4ZWRDb250ZW50KGNvbnN0IFNldHRpbmdz JiwgU2VjdXJpdHlPcmlnaW4mLCBjb25zdCBVUkwmKTsKICAgICBPcHRpb25hbDxTdHJpbmc+IGNo ZWNrRm9yTWl4ZWRDb250ZW50SW5GcmFtZVRyZWUoY29uc3QgVVJMJik7CiAKIHByaXZhdGU6CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmNwcCBiL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uY3BwCmluZGV4IDEwN2MxODU2YTIxMS4uMDZl MjFkMGE3ZGE0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2lu LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmNwcApAQCAtMTMx LDYgKzEzMSwxMiBAQCBzdGF0aWMgYm9vbCBpc0xvb3BiYWNrSVBBZGRyZXNzKFN0cmluZ1ZpZXcg aG9zdCkKICAgICByZXR1cm4gZG90c0ZvdW5kID09IDM7CiB9CiAKK3N0YXRpYyBib29sIGlzTG9j YWxob3N0SVBBZGRyZXNzKFN0cmluZ1ZpZXcgaG9zdCkKK3sKKyAgICByZXR1cm4gZXF1YWxMZXR0 ZXJzSWdub3JpbmdBU0NJSUNhc2UoaG9zdCwgImxvY2FsaG9zdCIpCisgICAgICAgIHx8IGhvc3Qu ZW5kc1dpdGhJZ25vcmluZ0FTQ0lJQ2FzZSgiLmxvY2FsaG9zdCIpOworfQorCiAvLyBodHRwczov L3czYy5naXRodWIuaW8vd2ViYXBwc2VjLXNlY3VyZS1jb250ZXh0cy8jaXMtb3JpZ2luLXRydXN0 d29ydGh5IChFZGl0b3IncyBEcmFmdCwgMTcgTm92ZW1iZXIgMjAxNikKIHN0YXRpYyBib29sIHNo b3VsZFRyZWF0QXNQb3RlbnRpYWxseVRydXN0d29ydGh5KGNvbnN0IFN0cmluZyYgcHJvdG9jb2ws IGNvbnN0IFN0cmluZyYgaG9zdCkKIHsKQEAgLTU5OSwxMiArNjA1LDM2IEBAIGJvb2wgU2VjdXJp dHlPcmlnaW46OmlzU2FtZVNjaGVtZUhvc3RQb3J0KGNvbnN0IFNlY3VyaXR5T3JpZ2luJiBvdGhl cikgY29uc3QKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAorYm9vbCBTZWN1cml0eU9yaWdpbjo6aXNB UHJpb3JpdHlBdXRoZW50aWNhdGVkVVJMKGNvbnN0IFNldHRpbmdzJiBzZXR0aW5ncywgY29uc3Qg VVJMJiB1cmwpCit7CisgICAgLy8gRklYTUU6IFRoaXMgc2hvdWxkIGp1c3QgYmUgcmV0dXJuaW5n IHNvbWV0aGluZyBsaWtlCisgICAgLy8gc2hvdWxkVHJlYXRBc1BvdGVudGlhbGx5VHJ1c3R3b3J0 aHkodXJsKSB8fCB1cmwucHJvdG9jb2woKSA9PSAiZGF0YSIKKyAgICAvLyBidXQgc2hvdWxkVHJl YXRBc1BvdGVudGlhbGx5VHJ1c3R3b3J0aHkgaXMgbm90IHJlYWxseSB1cC10by1kYXRlIHdpdGgK KyAgICAvLyByZXNwZWN0IHRvIHRoZSBsYXRlc3Qgc3BlY2lmaWNhdGlvbi4gRm9yIG5vdywgd2Ug anVzdCBpbXBsZW1lbnQgYQorICAgIC8vIHNpbXBsaWZpZWQgdmVyc2lvbiB0byBhbGxvdyBNaXhl ZENvbnRlbnRDaGVja2VyOjppc01peGVkQ29udGVudCB0byByZXR1cm4KKyAgICAvLyBmYWxzZSBm b3IgbG9vcGJhY2sgSVAgYWRkcmVzc2VzIGFuZCBsb2NhbGhvc3QgYWRkcmVzc2VzLgorICAgIGF1 dG8gaG9zdCA9IHVybC5ob3N0KCkudG9TdHJpbmdXaXRob3V0Q29weWluZygpOworCisgICAgLy8g aHR0cHM6Ly93M2MuZ2l0aHViLmlvL3dlYmFwcHNlYy1zZWN1cmUtY29udGV4dHMvI2lzLW9yaWdp bi10cnVzdHdvcnRoeQorICAgIC8vIGhvc3QgY29tcG9uZW50IG1hdGNoZXMgb25lIG9mIHRoZSBD SURSIG5vdGF0aW9ucyAxMjcuMC4wLjAvOCBvciA6OjEvMTI4CisgICAgaWYgKHNldHRpbmdzLnRy dXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQoKSAmJiBpc0xvb3BiYWNrSVBBZGRy ZXNzKGhvc3QpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIC8vIGh0dHBzOi8vdzNjLmdp dGh1Yi5pby93ZWJhcHBzZWMtc2VjdXJlLWNvbnRleHRzLyNpcy1vcmlnaW4tdHJ1c3R3b3J0aHkK KyAgICAvLyBob3N0IGNvbXBvbmVudCBpcyAibG9jYWxob3N0IiBvciBmYWxscyB3aXRoaW4gIi5s b2NhbGhvc3QiCisgICAgaWYgKHNldHRpbmdzLnRydXN0d29ydGh5TG9jYWxob3N0QWRkcmVzc2Vz RW5hYmxlZCgpICYmIGlzTG9jYWxob3N0SVBBZGRyZXNzKGhvc3QpKQorICAgICAgICByZXR1cm4g dHJ1ZTsKKworICAgIHJldHVybiBmYWxzZTsKK30KKwogYm9vbCBTZWN1cml0eU9yaWdpbjo6aXNM b2NhbEhvc3RPckxvb3BiYWNrSVBBZGRyZXNzKFN0cmluZ1ZpZXcgaG9zdCkKIHsKICAgICBpZiAo aXNMb29wYmFja0lQQWRkcmVzcyhob3N0KSkKICAgICAgICAgcmV0dXJuIHRydWU7CiAKICAgICAv LyBGSVhNRTogRW5zdXJlIHRoYXQgbG9jYWxob3N0IHJlc29sdmVzIHRvIHRoZSBsb29wYmFjayBh ZGRyZXNzLgorICAgIC8vIEZJWE1FOiBVc2UgaXNMb2NhbGhvc3RJUEFkZHJlc3MoKS4KICAgICBp ZiAoZXF1YWxMZXR0ZXJzSWdub3JpbmdBU0NJSUNhc2UoaG9zdCwgImxvY2FsaG9zdCIpKQogICAg ICAgICByZXR1cm4gdHJ1ZTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9TZWN1 cml0eU9yaWdpbi5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCmluZGV4 IDIwN2Y4YThhYTYzOS4uM2YzYzAxYWYxYjIzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w YWdlL1NlY3VyaXR5T3JpZ2luLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9y aWdpbi5oCkBAIC0zNSw2ICszNSw4IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorY2xhc3Mg U2V0dGluZ3M7CisKIGNsYXNzIFNlY3VyaXR5T3JpZ2luIDogcHVibGljIFRocmVhZFNhZmVSZWZD b3VudGVkPFNlY3VyaXR5T3JpZ2luPiB7CiBwdWJsaWM6CiAgICAgZW51bSBQb2xpY3kgewpAQCAt MjE2LDYgKzIxOCwxMCBAQCBwdWJsaWM6CiAKICAgICBXRUJDT1JFX0VYUE9SVCBzdGF0aWMgYm9v bCBpc0xvY2FsSG9zdE9yTG9vcGJhY2tJUEFkZHJlc3MoU3RyaW5nVmlldyk7CiAKKyAgICAvLyBU aGlzIG1ldGhvZCBpbXBsZW1lbnRzIHRoZSBhIHByaW9yaSBhdXRoZW50aWNhdGVkIFVSTAorICAg IC8vIGh0dHBzOi8vdzNjLmdpdGh1Yi5pby93ZWJhcHBzZWMtbWl4ZWQtY29udGVudC8jYS1wcmlv cmktYXV0aGVudGljYXRlZC11cmwKKyAgICBXRUJDT1JFX0VYUE9SVCBzdGF0aWMgYm9vbCBpc0FQ cmlvcml0eUF1dGhlbnRpY2F0ZWRVUkwoY29uc3QgU2V0dGluZ3MmLCBjb25zdCBVUkwmKTsKKwog ICAgIGNvbnN0IFNlY3VyaXR5T3JpZ2luRGF0YSYgZGF0YSgpIGNvbnN0IHsgcmV0dXJuIG1fZGF0 YTsgfQogCiAgICAgdGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4gdm9pZCBlbmNvZGUoRW5jb2RlciYp IGNvbnN0Owo= 413159 2020-11-04 07:15:03 -0800 2020-11-04 23:54:01 -0800 Patch mac.patch text/plain 71184 fred.wang RnJvbSA5Y2YzYTI3OWY4NzdkMjNjYzMxNGQ4YWUyNmRhMmEzMzlmNTJmMWUzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBGcmVkZXJpYyBXYW5nIDxmd2FuZ0BpZ2FsaWEuY29tPgpEYXRl OiBGcmksIDMwIE9jdCAyMDIwIDE3OjQxOjMwICswMTAwClN1YmplY3Q6IFtQQVRDSF0gbG9jYWxo b3N0CgotLS0KIC4uLi9sb2FkUmVzb3VyY2UtaW5zZWN1cmUtcmVzb3VyY2UtZXhwZWN0ZWQudHh0 ICAgIHwgIDQgKy0tCiAuLi4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0ICAg ICAgICAgICB8ICAyIC0tCiAuLi4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0 ICAgICAgICAgICB8ICAyIC0tCiAuLi4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQu dHh0ICAgICAgICAgICB8ICAyIC0tCiAuLi4vb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBz LWV4cGVjdGVkLnR4dCAgICB8ICAyIC0tCiAuLi4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhw ZWN0ZWQudHh0ICAgICAgICAgICB8ICAyIC0tCiAuLi4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMt ZXhwZWN0ZWQudHh0ICAgICAgICAgICB8ICAyIC0tCiAuLi4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0 cHMtZXhwZWN0ZWQudHh0ICAgICAgICAgICB8ICAyIC0tCiAuLi4vY3Jvc3Mtb3JpZ2luLWh0dHAu aHR0cHMtZXhwZWN0ZWQudHh0ICAgICAgICAgICB8ICAyIC0tCiAuLi4vY3Jvc3Mtb3JpZ2luLWh0 dHAuaHR0cHMtZXhwZWN0ZWQudHh0ICAgICAgICAgICB8ICAyIC0tCiAuLi4vY3Jvc3Mtb3JpZ2lu LWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0ICAgICAgICAgICB8ICAyIC0tCiAuLi4vY3Jvc3Mtb3Jp Z2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0ICAgICAgICAgICB8ICAyIC0tCiAuLi4vb3JpZ2lu L2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dCAgICB8ICAyIC0tCiAuLi4vY3Jv c3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0ICAgICAgICAgICB8ICAyIC0tCiAuLi4v Y3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0ICAgICAgICAgICB8ICAyIC0tCiAu Li4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0ICAgICAgICAgICB8ICAyIC0t CiAuLi4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0ICAgICAgICAgICB8ICAy IC0tCiAuLi4vaW5zZWN1cmUtY3NzLWluLWlmcmFtZS1yZXBvcnQtb25seS5odG1sICAgICAgICB8 ICAyICstCiAuLi4vaW5zZWN1cmUtY3NzLWluLWlmcmFtZS5odG1sICAgICAgICAgICAgICAgICAg ICB8ICAyICstCiAuLi4vaW5zZWN1cmUtY3NzLWluLW1haW4tZnJhbWUuaHRtbCAgICAgICAgICAg ICAgICB8ICAyICstCiAuLi4vaW5zZWN1cmUtaWZyYW1lLWluLWlmcmFtZS5odG1sICAgICAgICAg ICAgICAgICB8ICAyICstCiAuLi4vaW5zZWN1cmUtaWZyYW1lLWluLW1haW4tZnJhbWUuaHRtbCAg ICAgICAgICAgICB8ICAyICstCiAuLi5uc2VjdXJlLWltYWdlLWluLWJsb2ItdXJsLWlmcmFtZS1p bi1pZnJhbWUuaHRtbCB8ICAyICstCiAuLi5uLWlmcmFtZS13aXRoLWVuZm9yY2VkLWFuZC1yZXBv cnQtcG9saWNpZXMuaHRtbCB8ICAyICstCiAuLi5jdXJlLWltYWdlLWluLWlmcmFtZS13aXRoLWlu aGVyaXRlZC1wb2xpY3kuaHRtbCB8ICAyICstCiAuLi4vaW5zZWN1cmUtaW1hZ2UtaW4taWZyYW1l Lmh0bWwgICAgICAgICAgICAgICAgICB8ICAyICstCiAuLi5lLWltYWdlLWluLWphdmFzY3JpcHQt dXJsLWlmcmFtZS1pbi1pZnJhbWUuaHRtbCB8ICAyICstCiAuLi4vaW5zZWN1cmUtaW1hZ2UtaW4t bWFpbi1mcmFtZS5odG1sICAgICAgICAgICAgICB8ICAyICstCiAuLi50LWRvY3VtZW50LWluLWlm cmFtZS13aXRoLWluaGVyaXRlZC1wb2xpY3kuaHRtbCB8ICAyICstCiAuLi4vaW5zZWN1cmUtcGx1 Z2luLWluLWlmcmFtZS5odG1sICAgICAgICAgICAgICAgICB8ICAyICstCiAuLi4vaW5zZWN1cmUt cGx1Z2luLWluLW1haW4tZnJhbWUuaHRtbCAgICAgICAgICAgICB8ICAyICstCiAuLi51cmUtc2Ny aXB0LWluLWlmcmFtZS13aXRoLWluaGVyaXRlZC1wb2xpY3kuaHRtbCB8ICAyICstCiAuLi4vaW5z ZWN1cmUtc2NyaXB0LWluLWlmcmFtZS5odG1sICAgICAgICAgICAgICAgICB8ICAyICstCiAuLi4v aW5zZWN1cmUtc2NyaXB0LWluLW1haW4tZnJhbWUuaHRtbCAgICAgICAgICAgICB8ICAyICstCiAu Li4vaW5zZWN1cmUteGhyLWFzeW5jaHJvbm91cy1pbi1pZnJhbWUuaHRtbCAgICAgICB8ICAyICst CiAuLi4vaW5zZWN1cmUteGhyLWFzeW5jaHJvbm91cy1pbi1tYWluLWZyYW1lLmh0bWwgICB8ICAy ICstCiAuLi4vaW5zZWN1cmUteGhyLXN5bmNocm9ub3VzLWluLWlmcmFtZS5odG1sICAgICAgICB8 ICAyICstCiAuLi4vaW5zZWN1cmUteGhyLXN5bmNocm9ub3VzLWluLW1haW4tZnJhbWUuaHRtbCAg ICB8ICAyICstCiAuLi4vaWZyYW1lLXVwZ3JhZGUuaHR0cHMtZXhwZWN0ZWQudHh0ICAgICAgICAg ICAgICB8ICAyIC0tCiAuLi4vcHJvcGVyLW9wZW4td2luZG93LXVwZ3JhZGVzLWV4cGVjdGVkLnR4 dCAgICAgICB8ICAyIC0tCiAuLi4vaW1wb3J0LWluc2VjdXJlLXNjcmlwdC1pbi1pZnJhbWUuaHRt bCAgICAgICAgICB8ICAyICstCiAuLi4vaW5zZWN1cmUtYmFzaWMtYXV0aC1pbWFnZS5odHRwcy1l eHBlY3RlZC50eHQgICB8ICAyIC0tCiAuLi4vbWl4ZWRDb250ZW50L2luc2VjdXJlLWNzcy1pbi1p ZnJhbWUuaHRtbCAgICAgICB8ICAyICstCiAuLi4vbWl4ZWRDb250ZW50L2luc2VjdXJlLWNzcy1p bi1tYWluLWZyYW1lLmh0bWwgICB8ICAyICstCiAuLi5uc2VjdXJlLWV4ZWN1dGFibGUtY3NzLXdp dGgtc2VjdXJlLWNvb2tpZXMuaHRtbCB8ICAyICstCiAuLi4vbWl4ZWRDb250ZW50L2luc2VjdXJl LWZvcm0taW4tbWFpbi1mcmFtZS5odG1sICB8ICAyICstCiAuLi4vaW5zZWN1cmUtaWZyYW1lLWlu LW1haW4tZnJhbWUuaHRtbCAgICAgICAgICAgICB8ICAyICstCiAuLi4vbWl4ZWRDb250ZW50L2lu c2VjdXJlLWltYWdlLWluLW1haW4tZnJhbWUuaHRtbCB8ICAyICstCiAuLi5Dcm9zc09yaWdpblN1 YnJlc291cmNlc1RvQXNrRm9yQ3JlZGVudGlhbHMuaHRtbCB8ICAyICstCiAuLi5pbWFnZS1yZWRp cmVjdHMtdG8tYmFzaWMtYXV0aC1zZWN1cmUtaW1hZ2UuaHRtbCB8ICAyICstCiAuLi4vaW5zZWN1 cmUtaW1hZ2Utd2l0aC1zZWN1cmVjb29raWUtYmxvY2suaHRtbCAgICB8ICAyICstCiAuLi4vaW5z ZWN1cmUtaW1hZ2Utd2l0aC1zZWN1cmVjb29raWUuaHRtbCAgICAgICAgICB8ICAyICstCiAuLi4v bWl4ZWRDb250ZW50L2luc2VjdXJlLXBsdWdpbi1pbi1pZnJhbWUuaHRtbCAgICB8ICAyICstCiAu Li5jcmlwdC1pbi1kYXRhLWlmcmFtZS1pbi1tYWluLWZyYW1lLWJsb2NrZWQuaHRtbCB8ICA0ICst LQogLi4uL21peGVkQ29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4taWZyYW1lLmh0bWwgICAgfCAg MiArLQogLi4ucmlwdC1yZWRpcmVjdHMtdG8tYmFzaWMtYXV0aC1zZWN1cmUtc2NyaXB0Lmh0bWwg fCAgMiArLQogLi4uL2luc2VjdXJlLXNjcmlwdC13aXRoLXNlY3VyZS1jb29raWVzLmh0bWwgICAg ICAgfCAgMiArLQogLi4uLXJlZGlyZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1zdHlsZXNoZWV0 Lmh0bWwgfCAgMiArLQogLi4uL21peGVkQ29udGVudC9pbnNlY3VyZS14aHItaW4tbWFpbi1mcmFt ZS5odG1sICAgfCAgMiArLQogLi4uL2luc2VjdXJlLXhoci1zeW5jLWluLW1haW4tZnJhbWUuaHRt bCAgICAgICAgICAgfCAgMiArLQogLi4uZWRpcmVjdC1odHRwLXRvLWh0dHBzLWlmcmFtZS1pbi1t YWluLWZyYW1lLmh0bWwgfCAgMiArLQogLi4uL3JlZGlyZWN0LWh0dHAtdG8taHR0cHMtc2NyaXB0 LWluLWlmcmFtZS5odG1sICAgfCAgMiArLQogLi4uZWRpcmVjdC1odHRwcy10by1odHRwLWlmcmFt ZS1pbi1tYWluLWZyYW1lLmh0bWwgfCAgMiArLQogLi4udC1odHRwcy10by1odHRwLWltYWdlLXNl Y3VyZS1jb29raWVzLWJsb2NrLmh0bWwgfCAgMiArLQogLi4uZWRpcmVjdC1odHRwcy10by1odHRw LWltYWdlLXNlY3VyZS1jb29raWVzLmh0bWwgfCAgMiArLQogLi4uL3JlZGlyZWN0LWh0dHBzLXRv LWh0dHAtc2NyaXB0LWluLWlmcmFtZS5odG1sICAgfCAgMiArLQogLi4ucmlnaW5TdWJyZXNvdXJj ZXNUb0Fza0ZvckNyZWRlbnRpYWxzLmh0dHBzLmh0bWwgfCAgMiArLQogLi4uLXJlZGlyZWN0LXRv LWJhc2ljLWF1dGgtc2VjdXJlLWltYWdlLmh0dHBzLmh0bWwgfCAgMiArLQogLi4udG8tYmFzaWMt YXV0aC1pbnNlY3VyZS1pbWFnZS5odHRwcy1leHBlY3RlZC50eHQgfCAgMiAtLQogLi4uL3dlYnNv Y2tldC9pbnNlY3VyZS13ZWJzb2NrZXQtaW4taWZyYW1lLmh0bWwgICAgfCAgMiArLQogLi4uL2lu c2VjdXJlLXdlYnNvY2tldC1pbi1tYWluLWZyYW1lLmh0bWwgICAgICAgICAgfCAgMiArLQogLi4u Y29udGVudC1nZW9sb2NhdGlvbi1ibG9jay1pbnNlY3VyZS1jb250ZW50Lmh0bWwgfCAgMiArLQog Li4uL3Rlc3RzL3NlY3VyaXR5L21peGVkY29udGVudC1nZW9sb2NhdGlvbi5odG1sICAgfCAgMiAr LQogLi4ucmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odHRwcy1leHBlY3RlZC50eHQgfCAg MiAtLQogLi4ucmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odHRwcy1leHBlY3RlZC50eHQg fCAgMiAtLQogLi4uL1ByZWZlcmVuY2VzL1dlYlByZWZlcmVuY2VzRXhwZXJpbWVudGFsLnlhbWwg ICAgfCAyNiArKysrKysrKysrKysrKysrKysrCiBTb3VyY2UvV2ViQ29yZS9odG1sL3BhcnNlci9Y U1NBdWRpdG9yLmNwcCAgICAgICAgICB8ICAyICstCiBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvTWl4 ZWRDb250ZW50Q2hlY2tlci5jcHAgICAgICB8IDEzICsrKysrKy0tLS0KIFNvdXJjZS9XZWJDb3Jl L2xvYWRlci9NaXhlZENvbnRlbnRDaGVja2VyLmggICAgICAgIHwgIDMgKystCiBTb3VyY2UvV2Vi Q29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmNwcCAgICAgICAgICAgICB8IDMwICsrKysrKysrKysr KysrKysrKysrKysKIFNvdXJjZS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaCAgICAgICAg ICAgICAgIHwgIDYgKysrKysKIDgxIGZpbGVzIGNoYW5nZWQsIDEyNyBpbnNlcnRpb25zKCspLCAx MDcgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9pbnNw ZWN0b3IvbmV0d29yay9sb2FkUmVzb3VyY2UtaW5zZWN1cmUtcmVzb3VyY2UtZXhwZWN0ZWQudHh0 IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9pbnNwZWN0b3IvbmV0d29yay9sb2FkUmVzb3VyY2Ut aW5zZWN1cmUtcmVzb3VyY2UtZXhwZWN0ZWQudHh0CmluZGV4IGU4NjQ4MmY2YTcuLmNlN2E2NjFl OTMgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvaW5zcGVjdG9yL25ldHdvcmsv bG9hZFJlc291cmNlLWluc2VjdXJlLXJlc291cmNlLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL2luc3BlY3Rvci9uZXR3b3JrL2xvYWRSZXNvdXJjZS1pbnNlY3VyZS1y ZXNvdXJjZS1leHBlY3RlZC50eHQKQEAgLTEsNiArMSw0IEBACi1DT05TT0xFIE1FU1NBR0U6IFti bG9ja2VkXSBUaGUgcGFnZSBhdCBodHRwczovLzEyNy4wLjAuMTo4NDQzL2luc3BlY3Rvci9uZXR3 b3JrL2xvYWRSZXNvdXJjZS1pbnNlY3VyZS1yZXNvdXJjZS5odG1sIHdhcyBub3QgYWxsb3dlZCB0 byBkaXNwbGF5IGluc2VjdXJlIGNvbnRlbnQgZnJvbSBodHRwOi8vMTI3LjAuMC4wOjgwMDAvaW5z cGVjdG9yL25ldHdvcmsvcmVzb3VyY2VzL2RhdGEuanNvbj8yLgotCi1DT05TT0xFIE1FU1NBR0U6 IE5vdCBhbGxvd2VkIHRvIHJlcXVlc3QgcmVzb3VyY2UKK0Jsb2NrZWQgYWNjZXNzIHRvIGV4dGVy bmFsIFVSTCBodHRwOi8vMTI3LjAuMC4wOjgwMDAvaW5zcGVjdG9yL25ldHdvcmsvcmVzb3VyY2Vz L2RhdGEuanNvbj8yCiBDT05TT0xFIE1FU1NBR0U6IENhbm5vdCBsb2FkIGh0dHA6Ly8xMjcuMC4w LjA6ODAwMC9pbnNwZWN0b3IvbmV0d29yay9yZXNvdXJjZXMvZGF0YS5qc29uPzIgZHVlIHRvIGFj Y2VzcyBjb250cm9sIGNoZWNrcy4KIFRlc3RzIGxvYWRpbmcgcmVzb3VyY2VzIG9uIGEgc2VjdXJl IHBhZ2Ugd2l0aCBOZXR3b3JrLmxvYWRSZXNvdXJjZS4KIApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaWZyYW1lL25vLXJlZmVycmVyLXdoZW4tZG93 bmdyYWRlL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlmcmFtZS9uby1yZWZlcnJlci13aGVuLWRvd25n cmFkZS9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKaW5kZXggNWYyZjQxMDNj Zi4uMjU4MTg2NTE1YSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJl ci1wb2xpY3ktaWZyYW1lL25vLXJlZmVycmVyLXdoZW4tZG93bmdyYWRlL2Nyb3NzLW9yaWdpbi1o dHRwLmh0dHBzLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVy cmVyLXBvbGljeS1pZnJhbWUvbm8tcmVmZXJyZXItd2hlbi1kb3duZ3JhZGUvY3Jvc3Mtb3JpZ2lu LWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0xLDUgKzEsMyBAQAotQ09OU09MRSBNRVNTQUdF OiBUaGUgcGFnZSBhdCBhYm91dDpibGFuayB3YXMgYWxsb3dlZCB0byBkaXNwbGF5IGluc2VjdXJl IGNvbnRlbnQgZnJvbSBodHRwOi8vbG9jYWxob3N0OjgwMDAvcmVmZXJyZXItcG9saWN5L3Jlc291 cmNlcy9kb2N1bWVudC5odG1sLgotCiBUZXN0cyB0aGUgYmVoYXZpb3Igb2Ygbm8tcmVmZXJyZXIt d2hlbi1kb3duZ3JhZGUgcmVmZXJyZXIgcG9saWN5IHdoZW4gY3Jvc3Mgb3JpZ2luIGZyb20gSFRU UFMgdG8gSFRUUC4KIAogT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNT IiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaWZyYW1lL25vLXJlZmVycmVyL2Ny b3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvcmVmZXJyZXItcG9saWN5LWlmcmFtZS9uby1yZWZlcnJlci9jcm9zcy1vcmlnaW4taHR0cC5o dHRwcy1leHBlY3RlZC50eHQKaW5kZXggYTMwNmQ2YzgxNC4uZmRkNDhlZGM2YSAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaWZyYW1lL25vLXJlZmVy cmVyL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pZnJhbWUvbm8tcmVmZXJyZXIvY3Jvc3Mtb3Jp Z2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0xLDUgKzEsMyBAQAotQ09OU09MRSBNRVNT QUdFOiBUaGUgcGFnZSBhdCBhYm91dDpibGFuayB3YXMgYWxsb3dlZCB0byBkaXNwbGF5IGluc2Vj dXJlIGNvbnRlbnQgZnJvbSBodHRwOi8vbG9jYWxob3N0OjgwMDAvcmVmZXJyZXItcG9saWN5L3Jl c291cmNlcy9kb2N1bWVudC5odG1sLgotCiBUZXN0cyB0aGUgYmVoYXZpb3Igb2Ygbm8tcmVmZXJy ZXIgcmVmZXJyZXIgcG9saWN5IHdoZW4gY3Jvc3Mgb3JpZ2luIGZyb20gSFRUUFMgdG8gSFRUUC4K IAogT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywg Zm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaWZyYW1lL29yaWdpbi13aGVuLWNyb3NzLW9yaWdpbi9j cm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3JlZmVycmVyLXBvbGljeS1pZnJhbWUvb3JpZ2luLXdoZW4tY3Jvc3Mtb3JpZ2luL2Nyb3Nz LW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dAppbmRleCA1OWRiMjIwODlhLi4zMzAwZmJm NGFjIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1p ZnJhbWUvb3JpZ2luLXdoZW4tY3Jvc3Mtb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4 cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1p ZnJhbWUvb3JpZ2luLXdoZW4tY3Jvc3Mtb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4 cGVjdGVkLnR4dApAQCAtMSw1ICsxLDMgQEAKLUNPTlNPTEUgTUVTU0FHRTogVGhlIHBhZ2UgYXQg YWJvdXQ6Ymxhbmsgd2FzIGFsbG93ZWQgdG8gZGlzcGxheSBpbnNlY3VyZSBjb250ZW50IGZyb20g aHR0cDovL2xvY2FsaG9zdDo4MDAwL3JlZmVycmVyLXBvbGljeS9yZXNvdXJjZXMvZG9jdW1lbnQu aHRtbC4KLQogVGVzdHMgdGhlIGJlaGF2aW9yIG9mIG9yaWdpbi13aGVuLWNyb3NzLW9yaWdpbiBy ZWZlcnJlciBwb2xpY3kgd2hlbiBjcm9zcyBvcmlnaW4gZnJvbSBIVFRQUyB0byBIVFRQLgogCiBP biBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xs b3dlZCBieSAiVEVTVCBDT01QTEVURSIuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3JlZmVycmVyLXBvbGljeS1pZnJhbWUvb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBz LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlm cmFtZS9vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CmluZGV4IGZk ZDhiOTIwN2MuLjY0ODYyNjhkN2UgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv cmVmZXJyZXItcG9saWN5LWlmcmFtZS9vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhw ZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlm cmFtZS9vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0xLDUg KzEsMyBAQAotQ09OU09MRSBNRVNTQUdFOiBUaGUgcGFnZSBhdCBhYm91dDpibGFuayB3YXMgYWxs b3dlZCB0byBkaXNwbGF5IGluc2VjdXJlIGNvbnRlbnQgZnJvbSBodHRwOi8vbG9jYWxob3N0Ojgw MDAvcmVmZXJyZXItcG9saWN5L3Jlc291cmNlcy9kb2N1bWVudC5odG1sLgotCiBUZXN0cyB0aGUg YmVoYXZpb3Igb2Ygb3JpZ2luIHJlZmVycmVyIHBvbGljeSB3aGVuIGNyb3NzIG9yaWdpbiBmcm9t IEhUVFBTIHRvIEhUVFAuCiAKIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAi UEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlmcmFtZS9zYW1lLW9yaWdp bi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pZnJhbWUvc2FtZS1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0 dHAuaHR0cHMtZXhwZWN0ZWQudHh0CmluZGV4IDE5YTg1YTY2YWIuLmVjODFlOTUyMjQgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlmcmFtZS9zYW1l LW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaWZyYW1lL3NhbWUtb3JpZ2luL2Nyb3Nz LW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dApAQCAtMSw1ICsxLDMgQEAKLUNPTlNPTEUg TUVTU0FHRTogVGhlIHBhZ2UgYXQgYWJvdXQ6Ymxhbmsgd2FzIGFsbG93ZWQgdG8gZGlzcGxheSBp bnNlY3VyZSBjb250ZW50IGZyb20gaHR0cDovL2xvY2FsaG9zdDo4MDAwL3JlZmVycmVyLXBvbGlj eS9yZXNvdXJjZXMvZG9jdW1lbnQuaHRtbC4KLQogVGVzdHMgdGhlIGJlaGF2aW9yIG9mIHNhbWUt b3JpZ2luIHJlZmVycmVyIHBvbGljeSB3aGVuIGNyb3NzIG9yaWdpbiBmcm9tIEhUVFBTIHRvIEhU VFAuCiAKIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2Fn ZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlmcmFtZS9zdHJpY3Qtb3JpZ2luLXdoZW4tY3Jv c3Mtb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlmcmFtZS9zdHJpY3Qtb3JpZ2luLXdoZW4t Y3Jvc3Mtb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dAppbmRleCAy MTFiOWI3YjY2Li5hZDEwNjkwMTg0IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3JlZmVycmVyLXBvbGljeS1pZnJhbWUvc3RyaWN0LW9yaWdpbi13aGVuLWNyb3NzLW9yaWdpbi9j cm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaWZyYW1lL3N0cmljdC1vcmlnaW4td2hlbi1jcm9zcy1v cmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0xLDUgKzEsMyBA QAotQ09OU09MRSBNRVNTQUdFOiBUaGUgcGFnZSBhdCBhYm91dDpibGFuayB3YXMgYWxsb3dlZCB0 byBkaXNwbGF5IGluc2VjdXJlIGNvbnRlbnQgZnJvbSBodHRwOi8vbG9jYWxob3N0OjgwMDAvcmVm ZXJyZXItcG9saWN5L3Jlc291cmNlcy9kb2N1bWVudC5odG1sLgotCiBUZXN0cyB0aGUgYmVoYXZp b3Igb2Ygc3RyaWN0LW9yaWdpbi13aGVuLWNyb3NzLW9yaWdpbiByZWZlcnJlciBwb2xpY3kgd2hl biBjcm9zcyBvcmlnaW4gZnJvbSBIVFRQUyB0byBIVFRQLgogCiBPbiBzdWNjZXNzLCB5b3Ugd2ls bCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01Q TEVURSIuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGlj eS1pZnJhbWUvc3RyaWN0LW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50 eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pZnJhbWUvc3RyaWN0 LW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKaW5kZXggZGQ0MDEw NzcwMS4uNWI3OGE3ZTQ3MyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZl cnJlci1wb2xpY3ktaWZyYW1lL3N0cmljdC1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMt ZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5 LWlmcmFtZS9zdHJpY3Qtb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4 dApAQCAtMSw1ICsxLDMgQEAKLUNPTlNPTEUgTUVTU0FHRTogVGhlIHBhZ2UgYXQgYWJvdXQ6Ymxh bmsgd2FzIGFsbG93ZWQgdG8gZGlzcGxheSBpbnNlY3VyZSBjb250ZW50IGZyb20gaHR0cDovL2xv Y2FsaG9zdDo4MDAwL3JlZmVycmVyLXBvbGljeS9yZXNvdXJjZXMvZG9jdW1lbnQuaHRtbC4KLQog VGVzdHMgdGhlIGJlaGF2aW9yIG9mIHN0cmljdC1vcmlnaW4gcmVmZXJyZXIgcG9saWN5IHdoZW4g Y3Jvc3Mgb3JpZ2luIGZyb20gSFRUUFMgdG8gSFRUUC4KIAogT24gc3VjY2VzcywgeW91IHdpbGwg c2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExF VEUiLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3kt aWZyYW1lL3Vuc2FmZS11cmwvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0IGIv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaWZyYW1lL3Vuc2FmZS11cmwv Y3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CmluZGV4IDVhNzcyYTkxMDUuLmE5 MGY4MWM3MjggMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9s aWN5LWlmcmFtZS91bnNhZmUtdXJsL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4 dAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pZnJhbWUvdW5z YWZlLXVybC9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKQEAgLTEsNSArMSwz IEBACi1DT05TT0xFIE1FU1NBR0U6IFRoZSBwYWdlIGF0IGFib3V0OmJsYW5rIHdhcyBhbGxvd2Vk IHRvIGRpc3BsYXkgaW5zZWN1cmUgY29udGVudCBmcm9tIGh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC9y ZWZlcnJlci1wb2xpY3kvcmVzb3VyY2VzL2RvY3VtZW50Lmh0bWwuCi0KIFRlc3RzIHRoZSBiZWhh dmlvciBvZiB1bnNhZmUtdXJsIHJlZmVycmVyIHBvbGljeSB3aGVuIGNyb3NzIG9yaWdpbiBmcm9t IEhUVFBTIHRvIEhUVFAuCiAKIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAi UEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWltZy9uby1yZWZlcnJlci13 aGVuLWRvd25ncmFkZS9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQgYi9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pbWcvbm8tcmVmZXJyZXItd2hlbi1k b3duZ3JhZGUvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CmluZGV4IGEwZTFm NTc3YjEuLjI1ODE4NjUxNWEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVm ZXJyZXItcG9saWN5LWltZy9uby1yZWZlcnJlci13aGVuLWRvd25ncmFkZS9jcm9zcy1vcmlnaW4t aHR0cC5odHRwcy1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZl cnJlci1wb2xpY3ktaW1nL25vLXJlZmVycmVyLXdoZW4tZG93bmdyYWRlL2Nyb3NzLW9yaWdpbi1o dHRwLmh0dHBzLWV4cGVjdGVkLnR4dApAQCAtMSw1ICsxLDMgQEAKLUNPTlNPTEUgTUVTU0FHRTog VGhlIHBhZ2UgYXQgaHR0cHM6Ly8xMjcuMC4wLjE6ODQ0My9yZWZlcnJlci1wb2xpY3ktaW1nL25v LXJlZmVycmVyLXdoZW4tZG93bmdyYWRlL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLmh0bWwgd2Fz IGFsbG93ZWQgdG8gZGlzcGxheSBpbnNlY3VyZSBjb250ZW50IGZyb20gaHR0cDovLzEyNy4wLjAu MTo4MDAwL3JlZmVycmVyLXBvbGljeS9yZXNvdXJjZXMvaW1hZ2UucGhwP2V4cGVjdGVkPS4KLQog VGVzdHMgdGhlIGJlaGF2aW9yIG9mIG5vLXJlZmVycmVyLXdoZW4tZG93bmdyYWRlIHJlZmVycmVy IHBvbGljeSB3aGVuIGNyb3NzIG9yaWdpbiBmcm9tIEhUVFBTIHRvIEhUVFAuCiAKIE9uIHN1Y2Nl c3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5 ICJURVNUIENPTVBMRVRFIi4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVm ZXJyZXItcG9saWN5LWltZy9uby1yZWZlcnJlci9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBl Y3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pbWcvbm8t cmVmZXJyZXIvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CmluZGV4IGJhZGJh MDU3ZjguLmZkZDQ4ZWRjNmEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVm ZXJyZXItcG9saWN5LWltZy9uby1yZWZlcnJlci9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBl Y3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaW1n L25vLXJlZmVycmVyL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dApAQCAtMSw1 ICsxLDMgQEAKLUNPTlNPTEUgTUVTU0FHRTogVGhlIHBhZ2UgYXQgaHR0cHM6Ly8xMjcuMC4wLjE6 ODQ0My9yZWZlcnJlci1wb2xpY3ktaW1nL25vLXJlZmVycmVyL2Nyb3NzLW9yaWdpbi1odHRwLmh0 dHBzLmh0bWwgd2FzIGFsbG93ZWQgdG8gZGlzcGxheSBpbnNlY3VyZSBjb250ZW50IGZyb20gaHR0 cDovL2xvY2FsaG9zdDo4MDAwL3JlZmVycmVyLXBvbGljeS9yZXNvdXJjZXMvaW1hZ2UucGhwP2V4 cGVjdGVkPS4KLQogVGVzdHMgdGhlIGJlaGF2aW9yIG9mIG5vLXJlZmVycmVyIHJlZmVycmVyIHBv bGljeSB3aGVuIGNyb3NzIG9yaWdpbiBmcm9tIEhUVFBTIHRvIEhUVFAuCiAKIE9uIHN1Y2Nlc3Ms IHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJU RVNUIENPTVBMRVRFIi4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJy ZXItcG9saWN5LWltZy9vcmlnaW4td2hlbi1jcm9zcy1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAu aHR0cHMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xp Y3ktaW1nL29yaWdpbi13aGVuLWNyb3NzLW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1l eHBlY3RlZC50eHQKaW5kZXggZjg2YTk1NzMzNC4uMzMwMGZiZjRhYyAxMDA2NDQKLS0tIGEvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaW1nL29yaWdpbi13aGVuLWNyb3Nz LW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaW1nL29yaWdpbi13aGVuLWNyb3NzLW9y aWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKQEAgLTEsNSArMSwzIEBA Ci1DT05TT0xFIE1FU1NBR0U6IFRoZSBwYWdlIGF0IGh0dHBzOi8vMTI3LjAuMC4xOjg0NDMvcmVm ZXJyZXItcG9saWN5LWltZy9vcmlnaW4td2hlbi1jcm9zcy1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0 dHAuaHR0cHMuaHRtbCB3YXMgYWxsb3dlZCB0byBkaXNwbGF5IGluc2VjdXJlIGNvbnRlbnQgZnJv bSBodHRwOi8vbG9jYWxob3N0OjgwMDAvcmVmZXJyZXItcG9saWN5L3Jlc291cmNlcy9pbWFnZS5w aHA/ZXhwZWN0ZWQ9aHR0cHM6Ly8xMjcuMC4wLjE6ODQ0My8uCi0KIFRlc3RzIHRoZSBiZWhhdmlv ciBvZiBvcmlnaW4td2hlbi1jcm9zcy1vcmlnaW4gcmVmZXJyZXIgcG9saWN5IHdoZW4gY3Jvc3Mg b3JpZ2luIGZyb20gSFRUUFMgdG8gSFRUUC4KIAogT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEg c2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaW1nL29y aWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pbWcvb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0 dHBzLWV4cGVjdGVkLnR4dAppbmRleCAyNmU4ZDZkNmZmLi42NDg2MjY4ZDdlIDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pbWcvb3JpZ2luL2Nyb3Nz LW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3JlZmVycmVyLXBvbGljeS1pbWcvb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4 cGVjdGVkLnR4dApAQCAtMSw1ICsxLDMgQEAKLUNPTlNPTEUgTUVTU0FHRTogVGhlIHBhZ2UgYXQg aHR0cHM6Ly8xMjcuMC4wLjE6ODQ0My9yZWZlcnJlci1wb2xpY3ktaW1nL29yaWdpbi9jcm9zcy1v cmlnaW4taHR0cC5odHRwcy5odG1sIHdhcyBhbGxvd2VkIHRvIGRpc3BsYXkgaW5zZWN1cmUgY29u dGVudCBmcm9tIGh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9yZWZlcnJlci1wb2xpY3kvcmVzb3VyY2Vz L2ltYWdlLnBocD9leHBlY3RlZD1odHRwczovLzEyNy4wLjAuMTo4NDQzLy4KLQogVGVzdHMgdGhl IGJlaGF2aW9yIG9mIG9yaWdpbiByZWZlcnJlciBwb2xpY3kgd2hlbiBjcm9zcyBvcmlnaW4gZnJv bSBIVFRQUyB0byBIVFRQLgogCiBPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2Yg IlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pbWcvc2FtZS1vcmlnaW4v Y3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9yZWZlcnJlci1wb2xpY3ktaW1nL3NhbWUtb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0 dHBzLWV4cGVjdGVkLnR4dAppbmRleCA4MzZiYjA0ZmMyLi5lYzgxZTk1MjI0IDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pbWcvc2FtZS1vcmlnaW4v Y3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWltZy9zYW1lLW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0 cC5odHRwcy1leHBlY3RlZC50eHQKQEAgLTEsNSArMSwzIEBACi1DT05TT0xFIE1FU1NBR0U6IFRo ZSBwYWdlIGF0IGh0dHBzOi8vMTI3LjAuMC4xOjg0NDMvcmVmZXJyZXItcG9saWN5LWltZy9zYW1l LW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy5odG1sIHdhcyBhbGxvd2VkIHRvIGRpc3Bs YXkgaW5zZWN1cmUgY29udGVudCBmcm9tIGh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC9yZWZlcnJlci1w b2xpY3kvcmVzb3VyY2VzL2ltYWdlLnBocD9leHBlY3RlZD0uCi0KIFRlc3RzIHRoZSBiZWhhdmlv ciBvZiBzYW1lLW9yaWdpbiByZWZlcnJlciBwb2xpY3kgd2hlbiBjcm9zcyBvcmlnaW4gZnJvbSBI VFRQUyB0byBIVFRQLgogCiBPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBB U1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pbWcvc3RyaWN0LW9yaWdpbi13 aGVuLWNyb3NzLW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pbWcvc3RyaWN0LW9yaWdpbi13 aGVuLWNyb3NzLW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKaW5k ZXggYmJkNGY2ZTVlOS4uYWQxMDY5MDE4NCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9yZWZlcnJlci1wb2xpY3ktaW1nL3N0cmljdC1vcmlnaW4td2hlbi1jcm9zcy1vcmlnaW4v Y3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWltZy9zdHJpY3Qtb3JpZ2luLXdoZW4tY3Jvc3Mtb3Jp Z2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dApAQCAtMSw1ICsxLDMgQEAK LUNPTlNPTEUgTUVTU0FHRTogVGhlIHBhZ2UgYXQgaHR0cHM6Ly8xMjcuMC4wLjE6ODQ0My9yZWZl cnJlci1wb2xpY3ktaW1nL3N0cmljdC1vcmlnaW4td2hlbi1jcm9zcy1vcmlnaW4vY3Jvc3Mtb3Jp Z2luLWh0dHAuaHR0cHMuaHRtbCB3YXMgYWxsb3dlZCB0byBkaXNwbGF5IGluc2VjdXJlIGNvbnRl bnQgZnJvbSBodHRwOi8vbG9jYWxob3N0OjgwMDAvcmVmZXJyZXItcG9saWN5L3Jlc291cmNlcy9p bWFnZS5waHA/ZXhwZWN0ZWQ9LgotCiBUZXN0cyB0aGUgYmVoYXZpb3Igb2Ygc3RyaWN0LW9yaWdp bi13aGVuLWNyb3NzLW9yaWdpbiByZWZlcnJlciBwb2xpY3kgd2hlbiBjcm9zcyBvcmlnaW4gZnJv bSBIVFRQUyB0byBIVFRQLgogCiBPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2Yg IlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pbWcvc3RyaWN0LW9yaWdp bi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pbWcvc3RyaWN0LW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0 cC5odHRwcy1leHBlY3RlZC50eHQKaW5kZXggNjM1NjJjYjQyYi4uNWI3OGE3ZTQ3MyAxMDA2NDQK LS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaW1nL3N0cmljdC1v cmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWltZy9zdHJpY3Qtb3JpZ2luL2Nyb3NzLW9y aWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dApAQCAtMSw1ICsxLDMgQEAKLUNPTlNPTEUgTUVT U0FHRTogVGhlIHBhZ2UgYXQgaHR0cHM6Ly8xMjcuMC4wLjE6ODQ0My9yZWZlcnJlci1wb2xpY3kt aW1nL3N0cmljdC1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMuaHRtbCB3YXMgYWxsb3dl ZCB0byBkaXNwbGF5IGluc2VjdXJlIGNvbnRlbnQgZnJvbSBodHRwOi8vbG9jYWxob3N0OjgwMDAv cmVmZXJyZXItcG9saWN5L3Jlc291cmNlcy9pbWFnZS5waHA/ZXhwZWN0ZWQ9LgotCiBUZXN0cyB0 aGUgYmVoYXZpb3Igb2Ygc3RyaWN0LW9yaWdpbiByZWZlcnJlciBwb2xpY3kgd2hlbiBjcm9zcyBv cmlnaW4gZnJvbSBIVFRQUyB0byBIVFRQLgogCiBPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBz ZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pbWcvdW5z YWZlLXVybC9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pbWcvdW5zYWZlLXVybC9jcm9zcy1vcmlnaW4t aHR0cC5odHRwcy1leHBlY3RlZC50eHQKaW5kZXggMjE5NmEzZTJiOC4uYjFmNzJiNTc0NSAxMDA2 NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaW1nL3Vuc2Fm ZS11cmwvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWltZy91bnNhZmUtdXJsL2Nyb3NzLW9yaWdp bi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dApAQCAtMSw1ICsxLDMgQEAKLUNPTlNPTEUgTUVTU0FH RTogVGhlIHBhZ2UgYXQgaHR0cHM6Ly8xMjcuMC4wLjE6ODQ0My9yZWZlcnJlci1wb2xpY3ktaW1n L3Vuc2FmZS11cmwvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMuaHRtbCB3YXMgYWxsb3dlZCB0byBk aXNwbGF5IGluc2VjdXJlIGNvbnRlbnQgZnJvbSBodHRwOi8vbG9jYWxob3N0OjgwMDAvcmVmZXJy ZXItcG9saWN5L3Jlc291cmNlcy9pbWFnZS5waHA/ZXhwZWN0ZWQ9aHR0cHM6Ly8xMjcuMC4wLjE6 ODQ0My9yZWZlcnJlci1wb2xpY3ktaW1nL3Vuc2FmZS11cmwvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0 cHMuaHRtbC4KLQogVGVzdHMgdGhlIGJlaGF2aW9yIG9mIHVuc2FmZS11cmwgcmVmZXJyZXIgcG9s aWN5IHdoZW4gY3Jvc3Mgb3JpZ2luIGZyb20gSFRUUFMgdG8gSFRUUC4KIAogT24gc3VjY2Vzcywg eW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRF U1QgQ09NUExFVEUiLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUt Y3NzLWluLWlmcmFtZS1yZXBvcnQtb25seS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9z ZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5z ZWN1cmUtY3NzLWluLWlmcmFtZS1yZXBvcnQtb25seS5odG1sCmluZGV4IGIzY2E2NjBmMGEuLjdm MWZjYzU2ZTAgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29u dGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWNzcy1p bi1pZnJhbWUtcmVwb3J0LW9ubHkuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Nl Y3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNl Y3VyZS1jc3MtaW4taWZyYW1lLXJlcG9ydC1vbmx5Lmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURP Q1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhw ZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAt LT4KIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNv bnRlbnQvaW5zZWN1cmUtY3NzLWluLWlmcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQv aW5zZWN1cmUtY3NzLWluLWlmcmFtZS5odG1sCmluZGV4IDg4OGRmYzY5MzcuLmYwZWM5MzBkNzYg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3Vy aXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWNzcy1pbi1pZnJhbWUu aHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0 eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1jc3MtaW4taWZyYW1lLmh0 bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0g d2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFk ZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0PgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQ b2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtY3NzLWluLW1haW4tZnJhbWUu aHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9s aWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWNzcy1pbi1tYWluLWZyYW1lLmh0 bWwKaW5kZXggMWNmOGNlODI5MC4uZTM2NGVkMGVkOCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVk LWNvbnRlbnQvaW5zZWN1cmUtY3NzLWluLW1haW4tZnJhbWUuaHRtbAorKysgYi9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4 ZWQtY29udGVudC9pbnNlY3VyZS1jc3MtaW4tbWFpbi1mcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBA QAotPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBkdW1wSlNDb25zb2xl TG9nSW5TdGRFcnI9dHJ1ZSBdIC0tPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1y dW5uZXIgWyBkdW1wSlNDb25zb2xlTG9nSW5TdGRFcnI9dHJ1ZSBleHBlcmltZW50YWw6VHJ1c3R3 b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8aGVh ZD4KIDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5 L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1p ZnJhbWUtaW4taWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2Nv bnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pZnJh bWUtaW4taWZyYW1lLmh0bWwKaW5kZXggNzI2NzkxMzBkNi4uYjk0YmVjNWMzOSAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kv YmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaWZyYW1lLWluLWlmcmFtZS5odG1sCisr KyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5 L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWlmcmFtZS1pbi1pZnJhbWUuaHRtbApA QCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJr aXQtdGVzdC1ydW5uZXIgWyBkdW1wSlNDb25zb2xlTG9nSW5TdGRFcnI9dHJ1ZSBleHBlcmltZW50 YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0 bWw+CiA8aGVhZD4KIDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9p bnNlY3VyZS1pZnJhbWUtaW4tbWFpbi1mcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQv aW5zZWN1cmUtaWZyYW1lLWluLW1haW4tZnJhbWUuaHRtbAppbmRleCA4YzM0ODRkZDQ0Li43NTAz Y2MzZWExIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRl bnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pZnJhbWUt aW4tbWFpbi1mcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkv Y29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWlm cmFtZS1pbi1tYWluLWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4K KzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZHVtcEpTQ29uc29sZUxv Z0luU3RkRXJyPXRydWUgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nl c0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kv YmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4tYmxvYi11cmwtaWZyYW1l LWluLWlmcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50 U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4t YmxvYi11cmwtaWZyYW1lLWluLWlmcmFtZS5odG1sCmluZGV4IGJkZjdiYjdmZjguLjRmOWVhZWFk N2YgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNl Y3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWltYWdlLWluLWJs b2ItdXJsLWlmcmFtZS1pbi1pZnJhbWUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9p bnNlY3VyZS1pbWFnZS1pbi1ibG9iLXVybC1pZnJhbWUtaW4taWZyYW1lLmh0bWwKQEAgLTEsNCAr MSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3Qt cnVubmVyIFsgZHVtcEpTQ29uc29sZUxvZ0luU3RkRXJyPXRydWUgZXhwZXJpbWVudGFsOlRydXN0 d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhl YWQ+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUt aW1hZ2UtaW4taWZyYW1lLXdpdGgtZW5mb3JjZWQtYW5kLXJlcG9ydC1wb2xpY2llcy5odG1sIGIv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxv Y2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4taWZyYW1lLXdpdGgtZW5mb3Jj ZWQtYW5kLXJlcG9ydC1wb2xpY2llcy5odG1sCmluZGV4IGQ3YTUwMWI2N2EuLmQ5ZTg1YTNhZWIg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3Vy aXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWltYWdlLWluLWlmcmFt ZS13aXRoLWVuZm9yY2VkLWFuZC1yZXBvcnQtcG9saWNpZXMuaHRtbAorKysgYi9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4 ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1pZnJhbWUtd2l0aC1lbmZvcmNlZC1hbmQtcmVw b3J0LXBvbGljaWVzLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9D VFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29y dGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+ CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9j b250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1h Z2UtaW4taWZyYW1lLXdpdGgtaW5oZXJpdGVkLXBvbGljeS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNv bnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4taWZyYW1lLXdpdGgtaW5oZXJpdGVkLXBvbGljeS5odG1s CmluZGV4IDI1NjU3YzliYzguLjZjY2QwNmM5NDYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1j b250ZW50L2luc2VjdXJlLWltYWdlLWluLWlmcmFtZS13aXRoLWluaGVyaXRlZC1wb2xpY3kuaHRt bAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBv bGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1pZnJhbWUtd2l0 aC1pbmhlcml0ZWQtcG9saWN5Lmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4K KzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZHVtcEpTQ29uc29sZUxv Z0luU3RkRXJyPXRydWUgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nl c0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8bWV0YSBodHRwLWVxdWl2PSJD b250ZW50LVNlY3VyaXR5LVBvbGljeSIgY29udGVudD0iYmxvY2stYWxsLW1peGVkLWNvbnRlbnQi PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2Vj dXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4taWZy YW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0 eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1pZnJhbWUu aHRtbAppbmRleCBhOWViYjdmZDk5Li5jZTMzYWJjMDgxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4 ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1pZnJhbWUuaHRtbAorKysgYi9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4 ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1pZnJhbWUuaHRtbApAQCAtMSw0ICsxLDQgQEAK LTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIg WyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxz ZSBdIC0tPgogPGh0bWw+CiA8aGVhZD4KIDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4 ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1qYXZhc2NyaXB0LXVybC1pZnJhbWUtaW4taWZy YW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0 eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1qYXZhc2Ny aXB0LXVybC1pZnJhbWUtaW4taWZyYW1lLmh0bWwKaW5kZXggYmI5NTMwMTM1Mi4uNWIzNGQxMjE0 MyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2Vj dXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4tamF2 YXNjcmlwdC11cmwtaWZyYW1lLWluLWlmcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250 ZW50L2luc2VjdXJlLWltYWdlLWluLWphdmFzY3JpcHQtdXJsLWlmcmFtZS1pbi1pZnJhbWUuaHRt bApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3 ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRk cmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8aGVhZD4KIDxzY3JpcHQ+CmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBv bGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1tYWluLWZyYW1l Lmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBv bGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1tYWluLWZyYW1l Lmh0bWwKaW5kZXggZDBlMGU4NzI4NC4uOTQzMjI5ODU5OCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1p eGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4tbWFpbi1mcmFtZS5odG1sCisrKyBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFs bC1taXhlZC1jb250ZW50L2luc2VjdXJlLWltYWdlLWluLW1haW4tZnJhbWUuaHRtbApAQCAtMSw0 ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVz dC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5h YmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8aGVhZD4KIDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9j ay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi14c2x0LWRvY3VtZW50LWluLWlm cmFtZS13aXRoLWluaGVyaXRlZC1wb2xpY3kuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv c2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2lu c2VjdXJlLWltYWdlLWluLXhzbHQtZG9jdW1lbnQtaW4taWZyYW1lLXdpdGgtaW5oZXJpdGVkLXBv bGljeS5odG1sCmluZGV4IDhhYmY3ODQzZTguLmY1NzM1MjkwNjUgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFs bC1taXhlZC1jb250ZW50L2luc2VjdXJlLWltYWdlLWluLXhzbHQtZG9jdW1lbnQtaW4taWZyYW1l LXdpdGgtaW5oZXJpdGVkLXBvbGljeS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv c2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2lu c2VjdXJlLWltYWdlLWluLXhzbHQtZG9jdW1lbnQtaW4taWZyYW1lLXdpdGgtaW5oZXJpdGVkLXBv bGljeS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRt bD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3Bi YWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxoZWFkPgogPG1ldGEg aHR0cC1lcXVpdj0iQ29udGVudC1TZWN1cml0eS1Qb2xpY3kiIGNvbnRlbnQ9ImJsb2NrLWFsbC1t aXhlZC1jb250ZW50Ij4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJp dHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJl LXBsdWdpbi1pbi1pZnJhbWUuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkv Y29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXBs dWdpbi1pbi1pZnJhbWUuaHRtbAppbmRleCA1OTU1ZWI4ZDVlLi44ZDUzNmI4NTVhIDEwMDY0NAot LS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGlj eS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1wbHVnaW4taW4taWZyYW1lLmh0bWwK KysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xp Y3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtcGx1Z2luLWluLWlmcmFtZS5odG1s CkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdl YmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRy ZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxoZWFkPgogPHNjcmlwdD4KZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9s aWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXBsdWdpbi1pbi1tYWluLWZyYW1l Lmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBv bGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1wbHVnaW4taW4tbWFpbi1mcmFt ZS5odG1sCmluZGV4IGUyZjA2ZGNjMDMuLmI3OTVmYzVkMTIgMTAwNjQ0Ci0tLSBhL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1t aXhlZC1jb250ZW50L2luc2VjdXJlLXBsdWdpbi1pbi1tYWluLWZyYW1lLmh0bWwKKysrIGIvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2st YWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtcGx1Z2luLWluLW1haW4tZnJhbWUuaHRtbApAQCAt MSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQt dGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2Vz RW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8aGVhZD4KIDxzY3JpcHQ+CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9i bG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4taWZyYW1lLXdpdGgtaW5o ZXJpdGVkLXBvbGljeS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250 ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtc2NyaXB0 LWluLWlmcmFtZS13aXRoLWluaGVyaXRlZC1wb2xpY3kuaHRtbAppbmRleCA0YTQzMDljOTcyLi4y MDIxOTBjMTY2IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2Nv bnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1zY3Jp cHQtaW4taWZyYW1lLXdpdGgtaW5oZXJpdGVkLXBvbGljeS5odG1sCisrKyBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhl ZC1jb250ZW50L2luc2VjdXJlLXNjcmlwdC1pbi1pZnJhbWUtd2l0aC1pbmhlcml0ZWQtcG9saWN5 Lmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwh LS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJ UEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8bWV0YSBodHRw LWVxdWl2PSJDb250ZW50LVNlY3VyaXR5LVBvbGljeSIgY29udGVudD0iYmxvY2stYWxsLW1peGVk LWNvbnRlbnQiPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9j b250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtc2Ny aXB0LWluLWlmcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250 ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtc2NyaXB0 LWluLWlmcmFtZS5odG1sCmluZGV4IDc0M2IyZjAzODQuLjYyYzc1MzNkOTIgMTAwNjQ0Ci0tLSBh L0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Js b2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXNjcmlwdC1pbi1pZnJhbWUuaHRtbAorKysg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9i bG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4taWZyYW1lLmh0bWwKQEAg LTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0 LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nl c0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kv YmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtc2NyaXB0LWluLW1haW4tZnJhbWUuaHRt bCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5 L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXNjcmlwdC1pbi1tYWluLWZyYW1lLmh0 bWwKaW5kZXggZDliMGZhZmMzNy4uNjE4NDgyZTBlNCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVk LWNvbnRlbnQvaW5zZWN1cmUtc2NyaXB0LWluLW1haW4tZnJhbWUuaHRtbAorKysgYi9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwt bWl4ZWQtY29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4tbWFpbi1mcmFtZS5odG1sCkBAIC0xLDQg KzEsNCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0 LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFi bGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxoZWFkPgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2Nr LWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXhoci1hc3luY2hyb25vdXMtaW4taWZyYW1lLmh0 bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGlj eS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS14aHItYXN5bmNocm9ub3VzLWluLWlm cmFtZS5odG1sCmluZGV4IDIzNjE2M2IyNTQuLjFkNzllNTM2MmIgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFs bC1taXhlZC1jb250ZW50L2luc2VjdXJlLXhoci1hc3luY2hyb25vdXMtaW4taWZyYW1lLmh0bWwK KysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xp Y3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUteGhyLWFzeW5jaHJvbm91cy1pbi1p ZnJhbWUuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0 bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29w YmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8aGVhZD4KIDxzY3Jp cHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRT ZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS14aHItYXN5bmNo cm9ub3VzLWluLW1haW4tZnJhbWUuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJp dHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJl LXhoci1hc3luY2hyb25vdXMtaW4tbWFpbi1mcmFtZS5odG1sCmluZGV4IDFkOTY2NDVjMjcuLmMx NGQ0NDBjYjUgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29u dGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXhoci1h c3luY2hyb25vdXMtaW4tbWFpbi1mcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50 L2luc2VjdXJlLXhoci1hc3luY2hyb25vdXMtaW4tbWFpbi1mcmFtZS5odG1sCkBAIC0xLDQgKzEs NCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1 bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVk PWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxoZWFkPgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFs bC1taXhlZC1jb250ZW50L2luc2VjdXJlLXhoci1zeW5jaHJvbm91cy1pbi1pZnJhbWUuaHRtbCBi L0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Js b2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXhoci1zeW5jaHJvbm91cy1pbi1pZnJhbWUu aHRtbAppbmRleCBjNTQ3MzBkNjhiLi4xZTI5MGFlNTY2IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4 ZWQtY29udGVudC9pbnNlY3VyZS14aHItc3luY2hyb25vdXMtaW4taWZyYW1lLmh0bWwKKysrIGIv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxv Y2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUteGhyLXN5bmNocm9ub3VzLWluLWlmcmFtZS5o dG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0t IHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBB ZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxoZWFkPgogPHNjcmlwdD4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5 UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXhoci1zeW5jaHJvbm91cy1p bi1tYWluLWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRl bnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS14aHItc3lu Y2hyb25vdXMtaW4tbWFpbi1mcmFtZS5odG1sCmluZGV4IDM2NGU0NWQ0MzkuLmNmMWU3MmYxNzAg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3Vy aXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXhoci1zeW5jaHJvbm91 cy1pbi1tYWluLWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUt eGhyLXN5bmNocm9ub3VzLWluLW1haW4tZnJhbWUuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9D VFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBl cmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0t PgogPGh0bWw+CiA8aGVhZD4KIDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS91cGdyYWRlLWluc2VjdXJlLXJl cXVlc3RzL2lmcmFtZS11cGdyYWRlLmh0dHBzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L3VwZ3JhZGUtaW5zZWN1cmUt cmVxdWVzdHMvaWZyYW1lLXVwZ3JhZGUuaHR0cHMtZXhwZWN0ZWQudHh0CmluZGV4IDU2NDQwMTRh N2EuLjQxYmExMmJjN2MgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJp dHkvY29udGVudFNlY3VyaXR5UG9saWN5L3VwZ3JhZGUtaW5zZWN1cmUtcmVxdWVzdHMvaWZyYW1l LXVwZ3JhZGUuaHR0cHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv c2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L3VwZ3JhZGUtaW5zZWN1cmUtcmVxdWVzdHMv aWZyYW1lLXVwZ3JhZGUuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0xLDUgKzEsMyBAQAotQ09OU09M RSBNRVNTQUdFOiBUaGUgcGFnZSBhdCBhYm91dDpzcmNkb2Mgd2FzIGFsbG93ZWQgdG8gZGlzcGxh eSBpbnNlY3VyZSBjb250ZW50IGZyb20gaHR0cDovL2xvY2FsaG9zdDo4MDAwL3NlY3VyaXR5L3Jl c291cmNlcy9wb3N0LW9yaWdpbi10by1wYXJlbnQuaHRtbC4KLQogCiAKIFBBU1MgU2FtZS1ob3N0 IGZyYW1lcyBhcmUgdXBncmFkZWQuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS91cGdyYWRlLWluc2VjdXJlLXJlcXVlc3Rz L3Byb3Blci1vcGVuLXdpbmRvdy11cGdyYWRlcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS91cGdyYWRlLWluc2VjdXJl LXJlcXVlc3RzL3Byb3Blci1vcGVuLXdpbmRvdy11cGdyYWRlcy1leHBlY3RlZC50eHQKaW5kZXgg ZGUyZGQ5Y2Q1Zi4uYjZjZmUzM2NkNCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvdXBncmFkZS1pbnNlY3VyZS1yZXF1ZXN0 cy9wcm9wZXItb3Blbi13aW5kb3ctdXBncmFkZXMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L3VwZ3JhZGUtaW5z ZWN1cmUtcmVxdWVzdHMvcHJvcGVyLW9wZW4td2luZG93LXVwZ3JhZGVzLWV4cGVjdGVkLnR4dApA QCAtMSw3ICsxLDUgQEAKIEFMRVJUOiBQQVNTCiBBTEVSVDogUEFTUwotQ09OU09MRSBNRVNTQUdF OiBbYmxvY2tlZF0gVGhlIHBhZ2UgYXQgaHR0cHM6Ly8xMjcuMC4wLjE6ODQ0My9zZWN1cml0eS9j b250ZW50U2VjdXJpdHlQb2xpY3kvdXBncmFkZS1pbnNlY3VyZS1yZXF1ZXN0cy9yZXNvdXJjZXMv bmVzdGVkLW5lc3RlZC13aW5kb3cuaHRtbCB3YXMgbm90IGFsbG93ZWQgdG8gcnVuIGluc2VjdXJl IGNvbnRlbnQgZnJvbSBodHRwOi8vbG9jYWxob3N0Ojg0NDMvc2VjdXJpdHkvY29udGVudFNlY3Vy aXR5UG9saWN5L3Jlc291cmNlcy9hbGVydC1wYXNzLmpzLgotCiBUaGlzIHRlc3QgY2F1c2VzIGEg bmV3IHdpbmRvdyB0byBvcGVuIHBlcmZvcm1pbmcgYSBzZWN1cmUgbmF2aWdhdGlvbiB0byBhIGRv Y3VtZW50IHdpdGggdGhlICd1cGdyYWRlLWluc2VjdXJlLXJlcXVlc3RzJyBoZWFkZXIuIFRoZSBz ZWN1cmUgZG9jdW1lbnQgaGFzIGFuIGluc2VjdXJlIHNjcmlwdCByZWZlcmVuY2UsIHdoaWNoIHdp bGwgZ2V0IHVwZ3JhZGVkLiBUaGUgc2VjdXJlIGRvY3VtZW50IGRvZXMgYW4gaW5zZWN1cmUgbmF2 aWdhdGlvbiB0byBhIG5ldyB3aW5kb3cuIFRoaXMgbmV3IG5hdmlnYXRpb24gc2hvdWxkIG5vdCBi ZSB1cGdyYWRlZC4KIAogVGhlIG5ldyBkb2N1bWVudCBkb2VzIGFuIGluc2VjdXJlIG5hdmlnYXRp b24gdG8gYSBob3N0IHdlIGhhdmUgdmlzaXRlZCBiZWZvcmUuIFRoaXMgbmF2aWdhdGlvbiBzaG91 bGQgYmUgdXBncmFkZWQsIGV2ZW4gdGhvdWdoIHRoZSBzaXRlIGRvZXMgbm90IGhhdmUgdGhlICd1 cGRhdGUtaW5zZWN1cmUtcmVxdWVzdHMnIGhlYWRlci4gVGhlIG5ldyBkb2N1bWVudCBhbHNvIGRv ZXMgYW4gaW5zZWN1cmUgbmF2aWdhdGlvbiB0byBhIHNlY29uZCBkb21haW4sIHdoaWNoIGhhcyBu b3QgYmVlbiB1cGdyYWRlZCBiZWZvcmUuIFRoaXMgbmF2aWdhdGlvbiBzaG91bGQgbm90IGJlIHVw Z3JhZGVkLCBhbmQgd2lsbCBmYWlsIChpbiB0aGlzIHRlc3QpIGJlY2F1c2Ugd2Ugb25seSBwcm92 aWRlIHRoZSByZXNvdXJjZSB0byBsb2FkIHVuZGVyIHRoZSBIVFRQUyBzZXJ2ZXIuCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbXBvcnQt aW5zZWN1cmUtc2NyaXB0LWluLWlmcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9z ZWN1cml0eS9taXhlZENvbnRlbnQvaW1wb3J0LWluc2VjdXJlLXNjcmlwdC1pbi1pZnJhbWUuaHRt bAppbmRleCA3Njk0OGU4YWIzLi5mMDRmMzE3NmExIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbXBvcnQtaW5zZWN1cmUtc2NyaXB0LWlu LWlmcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRD b250ZW50L2ltcG9ydC1pbnNlY3VyZS1zY3JpcHQtaW4taWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0 IEBACi08aHRtbD4KKzxodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFs OlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxib2R5 PgogPHNjcmlwdCBzcmM9Ii4uLy4uL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+ CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9t aXhlZENvbnRlbnQvaW5zZWN1cmUtYmFzaWMtYXV0aC1pbWFnZS5odHRwcy1leHBlY3RlZC50eHQg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1i YXNpYy1hdXRoLWltYWdlLmh0dHBzLWV4cGVjdGVkLnR4dAppbmRleCA4NmFhYWUyYzBlLi4wOGM3 YjFhNGUxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVk Q29udGVudC9pbnNlY3VyZS1iYXNpYy1hdXRoLWltYWdlLmh0dHBzLWV4cGVjdGVkLnR4dAorKysg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1i YXNpYy1hdXRoLWltYWdlLmh0dHBzLWV4cGVjdGVkLnR4dApAQCAtMSw1ICsxLDMgQEAKLUNPTlNP TEUgTUVTU0FHRTogVGhlIHBhZ2UgYXQgaHR0cHM6Ly8xMjcuMC4wLjE6ODQ0My9zZWN1cml0eS9t aXhlZENvbnRlbnQvaW5zZWN1cmUtYmFzaWMtYXV0aC1pbWFnZS5odHRwcy5odG1sIHdhcyBhbGxv d2VkIHRvIGRpc3BsYXkgaW5zZWN1cmUgY29udGVudCBmcm9tIGh0dHA6Ly9sb2NhbGhvc3Q6ODAw MC9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVzb3VyY2VzL3N1YnJlc291cmNlMi9wcm90ZWN0ZWQt aW1hZ2UucGhwLgotCiBDT05TT0xFIE1FU1NBR0U6IEJsb2NrZWQgaHR0cDovL2xvY2FsaG9zdDo4 MDAwL3NlY3VyaXR5L21peGVkQ29udGVudC9yZXNvdXJjZXMvc3VicmVzb3VyY2UyL3Byb3RlY3Rl ZC1pbWFnZS5waHAgZnJvbSBhc2tpbmcgZm9yIGNyZWRlbnRpYWxzIGJlY2F1c2UgaXQgaXMgYSBj cm9zcy1vcmlnaW4gcmVxdWVzdC4KIFRlc3RzIHRoYXQgd2UgZG8gbm90IGFzayBmb3IgY3JlZGVu dGlhbHMgd2hlbiBsb2FkaW5nIGFuIGluc2VjdXJlIGltYWdlIHRoYXQgcmVxdWlyZXMgYmFzaWMg YXV0aGVudGljYXRpb24uCiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2Vj dXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWNzcy1pbi1pZnJhbWUuaHRtbCBiL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWNzcy1pbi1pZnJh bWUuaHRtbAppbmRleCA3OGI5ZjYxYWNlLi5hYjFkNTNjMDM5IDEwMDY0NAotLS0gYS9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1jc3MtaW4taWZy YW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRl bnQvaW5zZWN1cmUtY3NzLWluLWlmcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8 aHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxv b3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBp ZiAod2luZG93LnRlc3RSdW5uZXIpIHsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWNzcy1pbi1tYWluLWZyYW1lLmh0bWwg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1j c3MtaW4tbWFpbi1mcmFtZS5odG1sCmluZGV4IDhkNzdjODY4NDkuLjcyY2NmMWNjYjEgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2Vj dXJlLWNzcy1pbi1tYWluLWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9z ZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtY3NzLWluLW1haW4tZnJhbWUuaHRtbApAQCAt MSw0ICsxLDQgQEAKLTxodG1sPgorPGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBl cmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0t PgogPGJvZHk+CiA8c2NyaXB0PgogaWYgKHdpbmRvdy50ZXN0UnVubmVyKSB7CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1l eGVjdXRhYmxlLWNzcy13aXRoLXNlY3VyZS1jb29raWVzLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1leGVjdXRhYmxlLWNzcy13aXRo LXNlY3VyZS1jb29raWVzLmh0bWwKaW5kZXggNDExM2QyMzlhYy4uMzkwYTU5OTdhZSAxMDA2NDQK LS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1 cmUtZXhlY3V0YWJsZS1jc3Mtd2l0aC1zZWN1cmUtY29va2llcy5odG1sCisrKyBiL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWV4ZWN1dGFibGUt Y3NzLXdpdGgtc2VjdXJlLWNvb2tpZXMuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBo dG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50 YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0 bWw+CiA8Ym9keT4KIDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1mb3JtLWluLW1haW4tZnJhbWUuaHRtbCBi L0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWZv cm0taW4tbWFpbi1mcmFtZS5odG1sCmluZGV4IDA1N2Q1ZDA1NTguLmExNzljYmY5MjggMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2Vj dXJlLWZvcm0taW4tbWFpbi1mcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv c2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWZvcm0taW4tbWFpbi1mcmFtZS5odG1sCkBA IC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4 cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0g LS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRlc3RSdW5uZXIpIHsKZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJl LWlmcmFtZS1pbi1tYWluLWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3Vy aXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1pZnJhbWUtaW4tbWFpbi1mcmFtZS5odG1sCmluZGV4 IDhhYjgxZTIyM2YuLmRjMDY1YTJhY2QgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWlmcmFtZS1pbi1tYWluLWZyYW1lLmh0 bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5z ZWN1cmUtaWZyYW1lLWluLW1haW4tZnJhbWUuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTxodG1sPgor PGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlM b29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGJvZHk+CiA8c2NyaXB0Pgog aWYgKHdpbmRvdy50ZXN0UnVubmVyKSB7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1tYWluLWZyYW1lLmh0 bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3Vy ZS1pbWFnZS1pbi1tYWluLWZyYW1lLmh0bWwKaW5kZXggNzAzZWFjODY3Ni4uNDQwNWJhN2QwZSAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQv aW5zZWN1cmUtaW1hZ2UtaW4tbWFpbi1mcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWltYWdlLWluLW1haW4tZnJhbWUu aHRtbApAQCAtMSw0ICsxLDQgQEAKLTxodG1sPgorPGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5u ZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1m YWxzZSBdIC0tPgogPGJvZHk+CiA8c2NyaXB0PgogaWYgKHdpbmRvdy50ZXN0UnVubmVyKSB7CmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9p bnNlY3VyZS1pbWFnZS1yZWRpcmVjdHMtdG8tYmFzaWMtYXV0aC1zZWN1cmUtaW1hZ2UtYWxsb3dD cm9zc09yaWdpblN1YnJlc291cmNlc1RvQXNrRm9yQ3JlZGVudGlhbHMuaHRtbCBiL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWltYWdlLXJlZGly ZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1pbWFnZS1hbGxvd0Nyb3NzT3JpZ2luU3VicmVzb3Vy Y2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odG1sCmluZGV4IGI3OGU2NWQ0MjEuLjkxZTIxNTlmZDIg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50 L2luc2VjdXJlLWltYWdlLXJlZGlyZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1pbWFnZS1hbGxv d0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odG1sCisrKyBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWltYWdl LXJlZGlyZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1pbWFnZS1hbGxvd0Nyb3NzT3JpZ2luU3Vi cmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NU WVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBBbGxvd0Nyb3NzT3JpZ2luU3VicmVz b3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscz10cnVlIF0gLS0+Cis8IURPQ1RZUEUgaHRtbD48IS0t IHdlYmtpdC10ZXN0LXJ1bm5lciBbIEFsbG93Q3Jvc3NPcmlnaW5TdWJyZXNvdXJjZXNUb0Fza0Zv ckNyZWRlbnRpYWxzPXRydWUgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJl c3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGJvZHk+CiA8c2NyaXB0PgpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1 cmUtaW1hZ2UtcmVkaXJlY3RzLXRvLWJhc2ljLWF1dGgtc2VjdXJlLWltYWdlLmh0bWwgYi9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1pbWFnZS1y ZWRpcmVjdHMtdG8tYmFzaWMtYXV0aC1zZWN1cmUtaW1hZ2UuaHRtbAppbmRleCBlNjllYjIyMmNi Li42ZDc3M2NjNmQ3IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5 L21peGVkQ29udGVudC9pbnNlY3VyZS1pbWFnZS1yZWRpcmVjdHMtdG8tYmFzaWMtYXV0aC1zZWN1 cmUtaW1hZ2UuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVk Q29udGVudC9pbnNlY3VyZS1pbWFnZS1yZWRpcmVjdHMtdG8tYmFzaWMtYXV0aC1zZWN1cmUtaW1h Z2UuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+ PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFj a0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8Ym9keT4KIDxzY3JpcHQ+ CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVu dC9pbnNlY3VyZS1pbWFnZS13aXRoLXNlY3VyZWNvb2tpZS1ibG9jay5odG1sIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtaW1hZ2Utd2l0aC1z ZWN1cmVjb29raWUtYmxvY2suaHRtbAppbmRleCBhNWYyMDE3NDI2Li45YjJmNTRlNjE1IDEwMDY0 NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNl Y3VyZS1pbWFnZS13aXRoLXNlY3VyZWNvb2tpZS1ibG9jay5odG1sCisrKyBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWltYWdlLXdpdGgtc2Vj dXJlY29va2llLWJsb2NrLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwh RE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0 d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGJv ZHk+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtaW1hZ2Utd2l0aC1zZWN1cmVjb29raWUuaHRtbCBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWltYWdl LXdpdGgtc2VjdXJlY29va2llLmh0bWwKaW5kZXggMDBkYjI3ZDE5OC4uZTM5ZDBjNjM5OCAxMDA2 NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5z ZWN1cmUtaW1hZ2Utd2l0aC1zZWN1cmVjb29raWUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1pbWFnZS13aXRoLXNlY3VyZWNv b2tpZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRt bD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3Bi YWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxib2R5PgogPHNjcmlw dD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250 ZW50L2luc2VjdXJlLXBsdWdpbi1pbi1pZnJhbWUuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXBsdWdpbi1pbi1pZnJhbWUuaHRtbApp bmRleCBmNzUyMGI2ZmU1Li5mZTllNWMxOTdiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1wbHVnaW4taW4taWZyYW1lLmh0 bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5z ZWN1cmUtcGx1Z2luLWluLWlmcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRt bD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3Bi YWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAo d2luZG93LnRlc3RSdW5uZXIpCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Nl Y3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4tZGF0YS1pZnJhbWUtaW4tbWFp bi1mcmFtZS1ibG9ja2VkLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21p eGVkQ29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4tZGF0YS1pZnJhbWUtaW4tbWFpbi1mcmFtZS1i bG9ja2VkLmh0bWwKaW5kZXggYTZhZjk2OWQ2Yi4uNmRjNjFmYTIwNCAxMDA2NDQKLS0tIGEvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtc2NyaXB0 LWluLWRhdGEtaWZyYW1lLWluLW1haW4tZnJhbWUtYmxvY2tlZC5odG1sCisrKyBiL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXNjcmlwdC1pbi1k YXRhLWlmcmFtZS1pbi1tYWluLWZyYW1lLWJsb2NrZWQuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTxo dG1sPgorPGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3 b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGJvZHk+CiA8c2Ny aXB0PgogaWYgKHdpbmRvdy50ZXN0UnVubmVyICYmIHdpbmRvdy5pbnRlcm5hbHMpIHsKQEAgLTIx LDQgKzIxLDQgQEAgZGF0YTogZnJhbWUgaGFzIGEgc2VwYXJhdGUgb3JpZ2luLCB0aGUgc2NyaXB0 IGNhbiBzdGlsbCBuYXZpZ2F0ZSB0b3AuCiB3aW5kb3cub3BlbigiaHR0cHM6Ly8xMjcuMC4wLjE6 ODQ0My9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVzb3VyY2VzL2ZyYW1lLXdpdGgtZGF0YS11cmwt ZnJhbWUtd2l0aC1zY3JpcHQuaHRtbCIpOwogPC9zY3JpcHQ+CiA8L2JvZHk+Ci08L2h0bWw+Clwg Tm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtc2NyaXB0LWluLWlm cmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQv aW5zZWN1cmUtc2NyaXB0LWluLWlmcmFtZS5odG1sCmluZGV4IDQ4MTgyMzc3OGMuLmRlZDA2N2M1 MTggMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250 ZW50L2luc2VjdXJlLXNjcmlwdC1pbi1pZnJhbWUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4taWZyYW1lLmh0 bWwKQEAgLTEsNCArMSw0IEBACi08aHRtbD4KKzxodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVy IFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFs c2UgXSAtLT4KIDxib2R5PgogPHNjcmlwdD4KIGlmICh3aW5kb3cudGVzdFJ1bm5lcikKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2Vj dXJlLXNjcmlwdC1yZWRpcmVjdHMtdG8tYmFzaWMtYXV0aC1zZWN1cmUtc2NyaXB0Lmh0bWwgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1zY3Jp cHQtcmVkaXJlY3RzLXRvLWJhc2ljLWF1dGgtc2VjdXJlLXNjcmlwdC5odG1sCmluZGV4IDIxMWJh OWY1ZGMuLjE1ZDYzZmJjOWMgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2Vj dXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXNjcmlwdC1yZWRpcmVjdHMtdG8tYmFzaWMtYXV0 aC1zZWN1cmUtc2NyaXB0Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtc2NyaXB0LXJlZGlyZWN0cy10by1iYXNpYy1hdXRoLXNl Y3VyZS1zY3JpcHQuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NU WVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0 aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8Ym9keT4K IDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21p eGVkQ29udGVudC9pbnNlY3VyZS1zY3JpcHQtd2l0aC1zZWN1cmUtY29va2llcy5odG1sIGIvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtc2NyaXB0 LXdpdGgtc2VjdXJlLWNvb2tpZXMuaHRtbAppbmRleCA5MTFkZjRhNTRlLi5hYTI4MDAxOTU0IDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9p bnNlY3VyZS1zY3JpcHQtd2l0aC1zZWN1cmUtY29va2llcy5odG1sCisrKyBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXNjcmlwdC13aXRoLXNl Y3VyZS1jb29raWVzLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9D VFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29y dGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGJvZHk+ CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9t aXhlZENvbnRlbnQvaW5zZWN1cmUtc3R5bGVzaGVldC1yZWRpcmVjdHMtdG8tYmFzaWMtYXV0aC1z ZWN1cmUtc3R5bGVzaGVldC5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9t aXhlZENvbnRlbnQvaW5zZWN1cmUtc3R5bGVzaGVldC1yZWRpcmVjdHMtdG8tYmFzaWMtYXV0aC1z ZWN1cmUtc3R5bGVzaGVldC5odG1sCmluZGV4IDNmYTcxMzJkNDguLmE5NmQ1MWNkYjAgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2Vj dXJlLXN0eWxlc2hlZXQtcmVkaXJlY3RzLXRvLWJhc2ljLWF1dGgtc2VjdXJlLXN0eWxlc2hlZXQu aHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9p bnNlY3VyZS1zdHlsZXNoZWV0LXJlZGlyZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1zdHlsZXNo ZWV0Lmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1s PjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJh Y2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGJvZHk+CiA8c2NyaXB0 PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRl bnQvaW5zZWN1cmUteGhyLWluLW1haW4tZnJhbWUuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXhoci1pbi1tYWluLWZyYW1lLmh0bWwK aW5kZXggNjYyMWFjMGFhMi4uODY3ODE2Nzg5YiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUteGhyLWluLW1haW4tZnJhbWUu aHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9p bnNlY3VyZS14aHItaW4tbWFpbi1mcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8 aHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxv b3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBp ZiAod2luZG93LnRlc3RSdW5uZXIpIHsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXhoci1zeW5jLWluLW1haW4tZnJhbWUu aHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2Vj dXJlLXhoci1zeW5jLWluLW1haW4tZnJhbWUuaHRtbAppbmRleCA3Y2YzOTRhMGMzLi5iN2RjZjM0 MmUxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29u dGVudC9pbnNlY3VyZS14aHItc3luYy1pbi1tYWluLWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUteGhyLXN5bmMtaW4t bWFpbi1mcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdlYmtp dC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNz ZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRlc3RS dW5uZXIpIHsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4 ZWRDb250ZW50L3JlZGlyZWN0LWh0dHAtdG8taHR0cHMtaWZyYW1lLWluLW1haW4tZnJhbWUuaHRt bCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0 LWh0dHAtdG8taHR0cHMtaWZyYW1lLWluLW1haW4tZnJhbWUuaHRtbAppbmRleCA2Mzc3ZDU1MmJm Li4xY2RjZTNkODgwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5 L21peGVkQ29udGVudC9yZWRpcmVjdC1odHRwLXRvLWh0dHBzLWlmcmFtZS1pbi1tYWluLWZyYW1l Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQv cmVkaXJlY3QtaHR0cC10by1odHRwcy1pZnJhbWUtaW4tbWFpbi1mcmFtZS5odG1sCkBAIC0xLDQg KzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1l bnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8 Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRlc3RSdW5uZXIpIHsKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHAt dG8taHR0cHMtc2NyaXB0LWluLWlmcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9z ZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cC10by1odHRwcy1zY3JpcHQtaW4taWZy YW1lLmh0bWwKaW5kZXggOGM3YjZjNTZlZS4uMjM0MTM4Nzg4MCAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cC10by1o dHRwcy1zY3JpcHQtaW4taWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9z ZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cC10by1odHRwcy1zY3JpcHQtaW4taWZy YW1lLmh0bWwKQEAgLTEsNCArMSw0IEBACi08aHRtbD4KKzxodG1sPjwhLS0gd2Via2l0LXRlc3Qt cnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJs ZWQ9ZmFsc2UgXSAtLT4KIDxib2R5PgogPHNjcmlwdD4KIGlmICh3aW5kb3cudGVzdFJ1bm5lcikg ewpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRl bnQvcmVkaXJlY3QtaHR0cHMtdG8taHR0cC1pZnJhbWUtaW4tbWFpbi1mcmFtZS5odG1sIGIvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cHMt dG8taHR0cC1pZnJhbWUtaW4tbWFpbi1mcmFtZS5odG1sCmluZGV4IDk5MzQ2NGY4Y2EuLjhiYWVm NDhjNmMgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRD b250ZW50L3JlZGlyZWN0LWh0dHBzLXRvLWh0dHAtaWZyYW1lLWluLW1haW4tZnJhbWUuaHRtbAor KysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVj dC1odHRwcy10by1odHRwLWlmcmFtZS1pbi1tYWluLWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0IEBA Ci08aHRtbD4KKzxodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRy dXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxib2R5Pgog PHNjcmlwdD4KIGlmICh3aW5kb3cudGVzdFJ1bm5lcikgewpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cHMtdG8taHR0 cC1pbWFnZS1zZWN1cmUtY29va2llcy1ibG9jay5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cHMtdG8taHR0cC1pbWFnZS1zZWN1 cmUtY29va2llcy1ibG9jay5odG1sCmluZGV4IDgxNGY2OGJhOTMuLjFlNGI2MmMwMTggMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGly ZWN0LWh0dHBzLXRvLWh0dHAtaW1hZ2Utc2VjdXJlLWNvb2tpZXMtYmxvY2suaHRtbAorKysgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVjdC1odHRw cy10by1odHRwLWltYWdlLXNlY3VyZS1jb29raWVzLWJsb2NrLmh0bWwKQEAgLTEsNCArMSw0IEBA Ci08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVy IFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFs c2UgXSAtLT4KIDxodG1sPgogPGJvZHk+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cHMtdG8taHR0 cC1pbWFnZS1zZWN1cmUtY29va2llcy5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1 cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cHMtdG8taHR0cC1pbWFnZS1zZWN1cmUtY29v a2llcy5odG1sCmluZGV4IGNkYTgwMmQwMzAuLjA1OTE3Yzg2MjggMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHBzLXRv LWh0dHAtaW1hZ2Utc2VjdXJlLWNvb2tpZXMuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVjdC1odHRwcy10by1odHRwLWltYWdlLXNl Y3VyZS1jb29raWVzLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9D VFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29y dGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGJvZHk+ CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9t aXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cHMtdG8taHR0cC1zY3JpcHQtaW4taWZyYW1lLmh0bWwg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVjdC1o dHRwcy10by1odHRwLXNjcmlwdC1pbi1pZnJhbWUuaHRtbAppbmRleCBhYTJhY2NlNzk5Li40YmVk ZjVlNDhlIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVk Q29udGVudC9yZWRpcmVjdC1odHRwcy10by1odHRwLXNjcmlwdC1pbi1pZnJhbWUuaHRtbAorKysg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVjdC1o dHRwcy10by1odHRwLXNjcmlwdC1pbi1pZnJhbWUuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTxodG1s PgorPGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0 aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGJvZHk+CiA8c2NyaXB0 PgogaWYgKHdpbmRvdy50ZXN0UnVubmVyKSB7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9zZWN1cmUtcmVkaXJlY3QtdG8taW5zZWN1cmUt cmVkaXJlY3QtdG8tYmFzaWMtYXV0aC1zZWN1cmUtaW1hZ2UtYWxsb3dDcm9zc09yaWdpblN1YnJl c291cmNlc1RvQXNrRm9yQ3JlZGVudGlhbHMuaHR0cHMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3NlY3VyZS1yZWRpcmVjdC10by1pbnNlY3VyZS1y ZWRpcmVjdC10by1iYXNpYy1hdXRoLXNlY3VyZS1pbWFnZS1hbGxvd0Nyb3NzT3JpZ2luU3VicmVz b3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odHRwcy5odG1sCmluZGV4IGY3ZGU2NjliNmUuLjY5 YWQ1Mzc5YTAgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4 ZWRDb250ZW50L3NlY3VyZS1yZWRpcmVjdC10by1pbnNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1h dXRoLXNlY3VyZS1pbWFnZS1hbGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVk ZW50aWFscy5odHRwcy5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkv bWl4ZWRDb250ZW50L3NlY3VyZS1yZWRpcmVjdC10by1pbnNlY3VyZS1yZWRpcmVjdC10by1iYXNp Yy1hdXRoLXNlY3VyZS1pbWFnZS1hbGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JD cmVkZW50aWFscy5odHRwcy5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+PCEt LSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBBbGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tG b3JDcmVkZW50aWFscz10cnVlIF0gLS0+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0 LXJ1bm5lciBbIEFsbG93Q3Jvc3NPcmlnaW5TdWJyZXNvdXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxz PXRydWUgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9 ZmFsc2UgXSAtLT4KIDxodG1sPgogPGJvZHk+CiA8c2NyaXB0IHNyYz0iL2pzLXRlc3QtcmVzb3Vy Y2VzL2pzLXRlc3QuanMiPjwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvc2VjdXJlLXJlZGlyZWN0LXRvLWluc2VjdXJlLXJl ZGlyZWN0LXRvLWJhc2ljLWF1dGgtc2VjdXJlLWltYWdlLmh0dHBzLmh0bWwgYi9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9zZWN1cmUtcmVkaXJlY3QtdG8taW5z ZWN1cmUtcmVkaXJlY3QtdG8tYmFzaWMtYXV0aC1zZWN1cmUtaW1hZ2UuaHR0cHMuaHRtbAppbmRl eCBlY2I2OWYzYWNkLi4wM2E2YjcyZDhiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9zZWN1cmUtcmVkaXJlY3QtdG8taW5zZWN1cmUtcmVk aXJlY3QtdG8tYmFzaWMtYXV0aC1zZWN1cmUtaW1hZ2UuaHR0cHMuaHRtbAorKysgYi9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9zZWN1cmUtcmVkaXJlY3QtdG8t aW5zZWN1cmUtcmVkaXJlY3QtdG8tYmFzaWMtYXV0aC1zZWN1cmUtaW1hZ2UuaHR0cHMuaHRtbApA QCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJr aXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVz c2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8Ym9keT4KIDxzY3JpcHQgc3JjPSIvanMt dGVzdC1yZXNvdXJjZXMvanMtdGVzdC5qcyI+PC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9zZWN1cmUtcmVkaXJlY3QtdG8t c2VjdXJlLXJlZGlyZWN0LXRvLWJhc2ljLWF1dGgtaW5zZWN1cmUtaW1hZ2UuaHR0cHMtZXhwZWN0 ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvc2Vj dXJlLXJlZGlyZWN0LXRvLXNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRoLWluc2VjdXJlLWlt YWdlLmh0dHBzLWV4cGVjdGVkLnR4dAppbmRleCA5NGNmNzFhOTY1Li4yMmRmYWQ1ZDZjIDEwMDY0 NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9zZWN1 cmUtcmVkaXJlY3QtdG8tc2VjdXJlLXJlZGlyZWN0LXRvLWJhc2ljLWF1dGgtaW5zZWN1cmUtaW1h Z2UuaHR0cHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJp dHkvbWl4ZWRDb250ZW50L3NlY3VyZS1yZWRpcmVjdC10by1zZWN1cmUtcmVkaXJlY3QtdG8tYmFz aWMtYXV0aC1pbnNlY3VyZS1pbWFnZS5odHRwcy1leHBlY3RlZC50eHQKQEAgLTEsNSArMSwzIEBA Ci1DT05TT0xFIE1FU1NBR0U6IFRoZSBwYWdlIGF0IGh0dHBzOi8vMTI3LjAuMC4xOjg0NDMvc2Vj dXJpdHkvbWl4ZWRDb250ZW50L3NlY3VyZS1yZWRpcmVjdC10by1zZWN1cmUtcmVkaXJlY3QtdG8t YmFzaWMtYXV0aC1pbnNlY3VyZS1pbWFnZS5odHRwcy5odG1sIHdhcyBhbGxvd2VkIHRvIGRpc3Bs YXkgaW5zZWN1cmUgY29udGVudCBmcm9tIGh0dHA6Ly9sb2NhbGhvc3Q6ODA4MC9zZWN1cml0eS9t aXhlZENvbnRlbnQvcmVzb3VyY2VzL3N1YnJlc291cmNlL3Byb3RlY3RlZC1pbWFnZS5waHAuCi0K IENPTlNPTEUgTUVTU0FHRTogQmxvY2tlZCBodHRwOi8vbG9jYWxob3N0OjgwODAvc2VjdXJpdHkv bWl4ZWRDb250ZW50L3Jlc291cmNlcy9zdWJyZXNvdXJjZS9wcm90ZWN0ZWQtaW1hZ2UucGhwIGZy b20gYXNraW5nIGZvciBjcmVkZW50aWFscyBiZWNhdXNlIGl0IGlzIGEgY3Jvc3Mtb3JpZ2luIHJl cXVlc3QuCiBUaGlzIHRlc3QgbG9hZHMgYSBzZWN1cmUgaW1hZ2UgdGhhdCByZWRpcmVjdHMgdG8g YW4gc2VjdXJlIGltYWdlIHRoYXQgcmVkaXJlY3RzIHRvIGFuIGluc2VjdXJlIGltYWdlIGd1YXJk ZWQgYnkgYmFzaWMgYXV0aGVudGljYXRpb24uIFRoZSBpbnNlY3VyZSBpbWFnZSBzaG91bGQgYmUg YmxvY2tlZCBiZWNhdXNlIGl0IHJlcXVpcmVzIGNyZWRlbnRpYWxzLgogCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC93ZWJzb2NrZXQvaW5z ZWN1cmUtd2Vic29ja2V0LWluLWlmcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9z ZWN1cml0eS9taXhlZENvbnRlbnQvd2Vic29ja2V0L2luc2VjdXJlLXdlYnNvY2tldC1pbi1pZnJh bWUuaHRtbAppbmRleCA2YmM1NGM4ZDM3Li4xOGQwOTYzYWUxIDEwMDY0NAotLS0gYS9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC93ZWJzb2NrZXQvaW5zZWN1cmUt d2Vic29ja2V0LWluLWlmcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2Vj dXJpdHkvbWl4ZWRDb250ZW50L3dlYnNvY2tldC9pbnNlY3VyZS13ZWJzb2NrZXQtaW4taWZyYW1l Lmh0bWwKQEAgLTEsNCArMSw0IEBACi08c2NyaXB0PgorPHNjcmlwdD48IS0tIHdlYmtpdC10ZXN0 LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFi bGVkPWZhbHNlIF0gLS0+CiBpZiAod2luZG93LnRlc3RSdW5uZXIpCiAgICAgdGVzdFJ1bm5lci5k dW1wQXNUZXh0KCk7CiA8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3dlYnNvY2tldC9pbnNlY3VyZS13ZWJzb2NrZXQtaW4t bWFpbi1mcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENv bnRlbnQvd2Vic29ja2V0L2luc2VjdXJlLXdlYnNvY2tldC1pbi1tYWluLWZyYW1lLmh0bWwKaW5k ZXggZDMzZDkxMzNhOC4uNjhkMmE2YTkxMyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvd2Vic29ja2V0L2luc2VjdXJlLXdlYnNvY2tldC1p bi1tYWluLWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9t aXhlZENvbnRlbnQvd2Vic29ja2V0L2luc2VjdXJlLXdlYnNvY2tldC1pbi1tYWluLWZyYW1lLmh0 bWwKQEAgLTEsNCArMSw0IEBACi08aHRtbD4KKzxodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVy IFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFs c2UgXSAtLT4KIDxib2R5PgogPHNjcmlwdD4KIGlmICh3aW5kb3cudGVzdFJ1bm5lcikgewpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZGNvbnRlbnQtZ2Vv bG9jYXRpb24tYmxvY2staW5zZWN1cmUtY29udGVudC5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9zZWN1cml0eS9taXhlZGNvbnRlbnQtZ2VvbG9jYXRpb24tYmxvY2staW5zZWN1cmUtY29u dGVudC5odG1sCmluZGV4IDdlMGExZDM0YzIuLjFhZGQzZTE4NGEgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRjb250ZW50LWdlb2xvY2F0aW9uLWJsb2Nr LWluc2VjdXJlLWNvbnRlbnQuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3Vy aXR5L21peGVkY29udGVudC1nZW9sb2NhdGlvbi1ibG9jay1pbnNlY3VyZS1jb250ZW50Lmh0bWwK QEAgLTEsNCArMSw0IEBACi08aHRtbD4KKzxodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsg ZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2Ug XSAtLT4KIDxib2R5PgogPHNjcmlwdD4KIGlmICh3aW5kb3cudGVzdFJ1bm5lcikgewpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZGNvbnRlbnQtZ2VvbG9j YXRpb24uaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRjb250ZW50 LWdlb2xvY2F0aW9uLmh0bWwKaW5kZXggMWQyNWIyNmNjZi4uZTMzOTY4ZjFmOCAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZGNvbnRlbnQtZ2VvbG9jYXRp b24uaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkY29udGVu dC1nZW9sb2NhdGlvbi5odG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdl YmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRy ZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRl c3RSdW5uZXIpIHsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3drMi9odHRwL3Rl c3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1iYXNpYy1hdXRoLWltYWdlLWFsbG93 Q3Jvc3NPcmlnaW5TdWJyZXNvdXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzLmh0dHBzLWV4cGVjdGVk LnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3drMi9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVk Q29udGVudC9pbnNlY3VyZS1iYXNpYy1hdXRoLWltYWdlLWFsbG93Q3Jvc3NPcmlnaW5TdWJyZXNv dXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzLmh0dHBzLWV4cGVjdGVkLnR4dAppbmRleCBiZTdkMTIz YTdkLi5jMjhkMzcxZWRhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93azIvaHR0 cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtYmFzaWMtYXV0aC1pbWFnZS1h bGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odHRwcy1leHBl Y3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2syL2h0dHAvdGVzdHMvc2VjdXJp dHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWJhc2ljLWF1dGgtaW1hZ2UtYWxsb3dDcm9zc09yaWdp blN1YnJlc291cmNlc1RvQXNrRm9yQ3JlZGVudGlhbHMuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0x LDUgKzEsMyBAQAotQ09OU09MRSBNRVNTQUdFOiBUaGUgcGFnZSBhdCBodHRwczovLzEyNy4wLjAu MTo4NDQzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1iYXNpYy1hdXRoLWltYWdlLWFs bG93Q3Jvc3NPcmlnaW5TdWJyZXNvdXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzLmh0dHBzLmh0bWwg d2FzIGFsbG93ZWQgdG8gZGlzcGxheSBpbnNlY3VyZSBjb250ZW50IGZyb20gaHR0cDovL2xvY2Fs aG9zdDo4MDAwL3NlY3VyaXR5L21peGVkQ29udGVudC9yZXNvdXJjZXMvc3VicmVzb3VyY2UyL3By b3RlY3RlZC1pbWFnZS5waHAuCi0KIGxvY2FsaG9zdDo4MDAwIC0gZGlkUmVjZWl2ZUF1dGhlbnRp Y2F0aW9uQ2hhbGxlbmdlIC0gUHJvdGVjdGlvblNwYWNlQXV0aGVudGljYXRpb25TY2hlbWVIVFRQ QmFzaWMgLSBSZXNwb25kaW5nIHdpdGggdGVzdFVzZXI6dGVzdFBhc3N3b3JkCiBUZXN0cyB0aGF0 IHdlIGRvIG5vdCBhc2sgZm9yIGNyZWRlbnRpYWxzIHdoZW4gbG9hZGluZyBhbiBpbnNlY3VyZSBp bWFnZSB0aGF0IHJlcXVpcmVzIGJhc2ljIGF1dGhlbnRpY2F0aW9uLgogCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9wbGF0Zm9ybS93azIvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQv c2VjdXJlLXJlZGlyZWN0LXRvLXNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRoLWluc2VjdXJl LWltYWdlLWFsbG93Q3Jvc3NPcmlnaW5TdWJyZXNvdXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzLmh0 dHBzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3drMi9odHRwL3Rlc3RzL3Nl Y3VyaXR5L21peGVkQ29udGVudC9zZWN1cmUtcmVkaXJlY3QtdG8tc2VjdXJlLXJlZGlyZWN0LXRv LWJhc2ljLWF1dGgtaW5zZWN1cmUtaW1hZ2UtYWxsb3dDcm9zc09yaWdpblN1YnJlc291cmNlc1Rv QXNrRm9yQ3JlZGVudGlhbHMuaHR0cHMtZXhwZWN0ZWQudHh0CmluZGV4IGRkMDE1NjI4MjMuLjg4 NTI1NTY4M2YgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3drMi9odHRwL3Rlc3Rz L3NlY3VyaXR5L21peGVkQ29udGVudC9zZWN1cmUtcmVkaXJlY3QtdG8tc2VjdXJlLXJlZGlyZWN0 LXRvLWJhc2ljLWF1dGgtaW5zZWN1cmUtaW1hZ2UtYWxsb3dDcm9zc09yaWdpblN1YnJlc291cmNl c1RvQXNrRm9yQ3JlZGVudGlhbHMuaHR0cHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3Rz L3BsYXRmb3JtL3drMi9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9zZWN1cmUtcmVk aXJlY3QtdG8tc2VjdXJlLXJlZGlyZWN0LXRvLWJhc2ljLWF1dGgtaW5zZWN1cmUtaW1hZ2UtYWxs b3dDcm9zc09yaWdpblN1YnJlc291cmNlc1RvQXNrRm9yQ3JlZGVudGlhbHMuaHR0cHMtZXhwZWN0 ZWQudHh0CkBAIC0xLDUgKzEsMyBAQAotQ09OU09MRSBNRVNTQUdFOiBUaGUgcGFnZSBhdCBodHRw czovLzEyNy4wLjAuMTo4NDQzL3NlY3VyaXR5L21peGVkQ29udGVudC9zZWN1cmUtcmVkaXJlY3Qt dG8tc2VjdXJlLXJlZGlyZWN0LXRvLWJhc2ljLWF1dGgtaW5zZWN1cmUtaW1hZ2UtYWxsb3dDcm9z c09yaWdpblN1YnJlc291cmNlc1RvQXNrRm9yQ3JlZGVudGlhbHMuaHR0cHMuaHRtbCB3YXMgYWxs b3dlZCB0byBkaXNwbGF5IGluc2VjdXJlIGNvbnRlbnQgZnJvbSBodHRwOi8vbG9jYWxob3N0Ojgw ODAvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3Jlc291cmNlcy9zdWJyZXNvdXJjZS9wcm90ZWN0ZWQt aW1hZ2UucGhwLgotCiBsb2NhbGhvc3Q6ODA4MCAtIGRpZFJlY2VpdmVBdXRoZW50aWNhdGlvbkNo YWxsZW5nZSAtIFByb3RlY3Rpb25TcGFjZUF1dGhlbnRpY2F0aW9uU2NoZW1lSFRUUEJhc2ljIC0g UmVzcG9uZGluZyB3aXRoIHRlc3RVc2VyOnRlc3RQYXNzd29yZAogVGhpcyB0ZXN0IGxvYWRzIGEg c2VjdXJlIGltYWdlIHRoYXQgcmVkaXJlY3RzIHRvIGFuIHNlY3VyZSBpbWFnZSB0aGF0IHJlZGly ZWN0cyB0byBhbiBpbnNlY3VyZSBpbWFnZSBndWFyZGVkIGJ5IGJhc2ljIGF1dGhlbnRpY2F0aW9u LiBUaGUgaW1hZ2Ugc2hvdWxkIGxvYWQuCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvU2NyaXB0 cy9QcmVmZXJlbmNlcy9XZWJQcmVmZXJlbmNlc0V4cGVyaW1lbnRhbC55YW1sIGIvU291cmNlL1dU Ri9TY3JpcHRzL1ByZWZlcmVuY2VzL1dlYlByZWZlcmVuY2VzRXhwZXJpbWVudGFsLnlhbWwKaW5k ZXggNDVmYjBiNzk1OC4uZDM1YzBiOTNjZiAxMDA2NDQKLS0tIGEvU291cmNlL1dURi9TY3JpcHRz L1ByZWZlcmVuY2VzL1dlYlByZWZlcmVuY2VzRXhwZXJpbWVudGFsLnlhbWwKKysrIGIvU291cmNl L1dURi9TY3JpcHRzL1ByZWZlcmVuY2VzL1dlYlByZWZlcmVuY2VzRXhwZXJpbWVudGFsLnlhbWwK QEAgLTgwMiw2ICs4MDIsMzIgQEAgVHJhbnNmb3JtU3RyZWFtQVBJRW5hYmxlZDoKICAgICBXZWJL aXQ6CiAgICAgICBkZWZhdWx0OiB0cnVlCiAKKyMgaHR0cHM6Ly93M2MuZ2l0aHViLmlvL3dlYmFw cHNlYy1zZWN1cmUtY29udGV4dHMvI2lzLW9yaWdpbi10cnVzdHdvcnRoeQorVHJ1c3R3b3J0aHlM b2NhbGhvc3RBZGRyZXNzZXNFbmFibGVkOgorICB0eXBlOiBib29sCisgIGh1bWFuUmVhZGFibGVO YW1lOiAiVHJ1c3R3b3J0aHkgbG9jYWxob3N0IGFkZHJlc3NlcyIKKyAgaHVtYW5SZWFkYWJsZURl c2NyaXB0aW9uOiAiVHJlYXQgaG9zdHMgbWF0Y2hpbmcgJ2xvY2FsaG9zdCcsIG9yIGZhbGxpbmcg d2l0aGluICcubG9jYWxob3N0JywgYXMgJ1BvdGVudGlhbGx5IFRydXN0d29ydGh5Jy4iCisgIGRl ZmF1bHRWYWx1ZToKKyAgICBXZWJLaXRMZWdhY3k6CisgICAgICBkZWZhdWx0OiBmYWxzZQorICAg IFdlYktpdDoKKyAgICAgIGRlZmF1bHQ6IGZhbHNlCisgICAgV2ViQ29yZToKKyAgICAgIGRlZmF1 bHQ6IGZhbHNlCisKKyMgaHR0cHM6Ly93M2MuZ2l0aHViLmlvL3dlYmFwcHNlYy1zZWN1cmUtY29u dGV4dHMvI2lzLW9yaWdpbi10cnVzdHdvcnRoeQorVHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVz c2VzRW5hYmxlZDoKKyAgdHlwZTogYm9vbAorICBodW1hblJlYWRhYmxlTmFtZTogIlRydXN0d29y dGh5IGxvb3BiYWNrIElQIGFkZHJlc3NlcyIKKyAgaHVtYW5SZWFkYWJsZURlc2NyaXB0aW9uOiAi VHJlYXQgaG9zdHMgbWF0Y2hpbmcgb25lIG9mIHRoZSBDSURSIG5vdGF0aW9ucyAxMjcuMC4wLjAv OCBvciA6OjEvMTI4IGFzICdQb3RlbnRpYWxseSBUcnVzdHdvcnRoeScuIgorICBkZWZhdWx0VmFs dWU6CisgICAgV2ViS2l0TGVnYWN5OgorICAgICAgZGVmYXVsdDogdHJ1ZQorICAgIFdlYktpdDoK KyAgICAgIGRlZmF1bHQ6IHRydWUKKyAgICBXZWJDb3JlOgorICAgICAgZGVmYXVsdDogdHJ1ZQor CiBVc2VyR2VzdHVyZVByb21pc2VQcm9wYWdhdGlvbkVuYWJsZWQ6CiAgIHR5cGU6IGJvb2wKICAg aHVtYW5SZWFkYWJsZU5hbWU6ICJVc2VyR2VzdHVyZSBQcm9taXNlIFByb3BhZ2F0aW9uIgpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9wYXJzZXIvWFNTQXVkaXRvci5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL3BhcnNlci9YU1NBdWRpdG9yLmNwcAppbmRleCBiY2I4ODVlYWRkLi42 NDEzYjhiYjMxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL3BhcnNlci9YU1NBdWRp dG9yLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL3BhcnNlci9YU1NBdWRpdG9yLmNwcApA QCAtMzI0LDcgKzMyNCw3IEBAIHZvaWQgWFNTQXVkaXRvcjo6aW5pdChEb2N1bWVudCogZG9jdW1l bnQsIFhTU0F1ZGl0b3JEZWxlZ2F0ZSogYXVkaXRvckRlbGVnYXRlKQogCiAgICAgICAgIGlmICgo bV94c3NQcm90ZWN0aW9uID09IFhTU1Byb3RlY3Rpb25EaXNwb3NpdGlvbjo6RW5hYmxlZCB8fCBt X3hzc1Byb3RlY3Rpb24gPT0gWFNTUHJvdGVjdGlvbkRpc3Bvc2l0aW9uOjpCbG9ja0VuYWJsZWQp ICYmICFwYXJzZWRSZXBvcnRVUkwuaXNFbXB0eSgpKSB7CiAgICAgICAgICAgICByZXBvcnRVUkwg PSBkb2N1bWVudC0+Y29tcGxldGVVUkwocGFyc2VkUmVwb3J0VVJMKTsKLSAgICAgICAgICAgIGlm IChNaXhlZENvbnRlbnRDaGVja2VyOjppc01peGVkQ29udGVudChkb2N1bWVudC0+c2VjdXJpdHlP cmlnaW4oKSwgcmVwb3J0VVJMKSkgeworICAgICAgICAgICAgaWYgKE1peGVkQ29udGVudENoZWNr ZXI6OmlzTWl4ZWRDb250ZW50KGRvY3VtZW50LT5zZXR0aW5ncygpLCBkb2N1bWVudC0+c2VjdXJp dHlPcmlnaW4oKSwgcmVwb3J0VVJMKSkgewogICAgICAgICAgICAgICAgIGVycm9yRGV0YWlscyA9 ICJpbnNlY3VyZSByZXBvcnRpbmcgVVJMIGZvciBzZWN1cmUgcGFnZSI7CiAgICAgICAgICAgICAg ICAgbV94c3NQcm90ZWN0aW9uID0gWFNTUHJvdGVjdGlvbkRpc3Bvc2l0aW9uOjpJbnZhbGlkOwog ICAgICAgICAgICAgICAgIHJlcG9ydFVSTCA9IFVSTCgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvbG9hZGVyL01peGVkQ29udGVudENoZWNrZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvbG9h ZGVyL01peGVkQ29udGVudENoZWNrZXIuY3BwCmluZGV4IGE3YjZiZjY3M2EuLjkyOTkwYmQ3NDkg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9NaXhlZENvbnRlbnRDaGVja2VyLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvTWl4ZWRDb250ZW50Q2hlY2tlci5jcHAKQEAg LTUzLDE4ICs1MywyMSBAQCBGcmFtZUxvYWRlckNsaWVudCYgTWl4ZWRDb250ZW50Q2hlY2tlcjo6 Y2xpZW50KCkgY29uc3QKIH0KIAogLy8gc3RhdGljCi1ib29sIE1peGVkQ29udGVudENoZWNrZXI6 OmlzTWl4ZWRDb250ZW50KFNlY3VyaXR5T3JpZ2luJiBzZWN1cml0eU9yaWdpbiwgY29uc3QgVVJM JiB1cmwpCitib29sIE1peGVkQ29udGVudENoZWNrZXI6OmlzTWl4ZWRDb250ZW50KGNvbnN0IFNl dHRpbmdzJiBzZXR0aW5ncywgU2VjdXJpdHlPcmlnaW4mIHNlY3VyaXR5T3JpZ2luLCBjb25zdCBV UkwmIHVybCkKIHsKICAgICBpZiAoc2VjdXJpdHlPcmlnaW4ucHJvdG9jb2woKSAhPSAiaHR0cHMi KQogICAgICAgICByZXR1cm4gZmFsc2U7IC8vIFdlIG9ubHkgY2FyZSBhYm91dCBIVFRQUyBzZWN1 cml0eSBvcmlnaW5zLgogCisgICAgaWYgKFNlY3VyaXR5T3JpZ2luOjppc0FQcmlvcml0eUF1dGhl bnRpY2F0ZWRVUkwoc2V0dGluZ3MsIHVybCkpCisgICAgICAgIHJldHVybiBmYWxzZTsgLy8gYSBw cmlvcmkgYXV0aGVudGljYXRlZCB1cmxzIGFyZSBub3QgbWl4ZWQgY29udGVudC4KKwogICAgIC8v IFdlJ3JlIGluIGEgc2VjdXJlIGNvbnRleHQsIHNvIHx1cmx8IGlzIG1peGVkIGNvbnRlbnQgaWYg aXQncyBpbnNlY3VyZS4KICAgICByZXR1cm4gIVNlY3VyaXR5T3JpZ2luOjppc1NlY3VyZSh1cmwp OwogfQogCiBib29sIE1peGVkQ29udGVudENoZWNrZXI6OmNhbkRpc3BsYXlJbnNlY3VyZUNvbnRl bnQoU2VjdXJpdHlPcmlnaW4mIHNlY3VyaXR5T3JpZ2luLCBDb250ZW50VHlwZSB0eXBlLCBjb25z dCBVUkwmIHVybCwgQWx3YXlzRGlzcGxheUluTm9uU3RyaWN0TW9kZSBhbHdheXNEaXNwbGF5SW5O b25TdHJpY3RNb2RlKSBjb25zdAogewotICAgIGlmICghaXNNaXhlZENvbnRlbnQoc2VjdXJpdHlP cmlnaW4sIHVybCkpCisgICAgaWYgKCFpc01peGVkQ29udGVudChtX2ZyYW1lLnNldHRpbmdzKCks IHNlY3VyaXR5T3JpZ2luLCB1cmwpKQogICAgICAgICByZXR1cm4gdHJ1ZTsKIAogICAgIGlmICgh bV9mcmFtZS5kb2N1bWVudCgpLT5jb250ZW50U2VjdXJpdHlQb2xpY3koKS0+YWxsb3dSdW5uaW5n T3JEaXNwbGF5aW5nSW5zZWN1cmVDb250ZW50KHVybCkpCkBAIC04Nyw3ICs5MCw3IEBAIGJvb2wg TWl4ZWRDb250ZW50Q2hlY2tlcjo6Y2FuRGlzcGxheUluc2VjdXJlQ29udGVudChTZWN1cml0eU9y aWdpbiYgc2VjdXJpdHlPcmlnCiAKIGJvb2wgTWl4ZWRDb250ZW50Q2hlY2tlcjo6Y2FuUnVuSW5z ZWN1cmVDb250ZW50KFNlY3VyaXR5T3JpZ2luJiBzZWN1cml0eU9yaWdpbiwgY29uc3QgVVJMJiB1 cmwpIGNvbnN0CiB7Ci0gICAgaWYgKCFpc01peGVkQ29udGVudChzZWN1cml0eU9yaWdpbiwgdXJs KSkKKyAgICBpZiAoIWlzTWl4ZWRDb250ZW50KG1fZnJhbWUuc2V0dGluZ3MoKSwgc2VjdXJpdHlP cmlnaW4sIHVybCkpCiAgICAgICAgIHJldHVybiB0cnVlOwogCiAgICAgaWYgKCFtX2ZyYW1lLmRv Y3VtZW50KCktPmNvbnRlbnRTZWN1cml0eVBvbGljeSgpLT5hbGxvd1J1bm5pbmdPckRpc3BsYXlp bmdJbnNlY3VyZUNvbnRlbnQodXJsKSkKQEAgLTExMSw3ICsxMTQsNyBAQCB2b2lkIE1peGVkQ29u dGVudENoZWNrZXI6OmNoZWNrRm9ybUZvck1peGVkQ29udGVudChTZWN1cml0eU9yaWdpbiYgc2Vj dXJpdHlPcmlnaQogICAgIGlmICh1cmwucHJvdG9jb2xJc0phdmFTY3JpcHQoKSkKICAgICAgICAg cmV0dXJuOwogCi0gICAgaWYgKCFpc01peGVkQ29udGVudChzZWN1cml0eU9yaWdpbiwgdXJsKSkK KyAgICBpZiAoIWlzTWl4ZWRDb250ZW50KG1fZnJhbWUuc2V0dGluZ3MoKSwgc2VjdXJpdHlPcmln aW4sIHVybCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIFN0cmluZyBtZXNzYWdlID0gbWFrZVN0 cmluZygiVGhlIHBhZ2UgYXQgIiwgbV9mcmFtZS5kb2N1bWVudCgpLT51cmwoKS5zdHJpbmdDZW50 ZXJFbGxpcHNpemVkVG9MZW5ndGgoKSwgIiBjb250YWlucyBhIGZvcm0gd2hpY2ggdGFyZ2V0cyBh biBpbnNlY3VyZSBVUkwgIiwgdXJsLnN0cmluZ0NlbnRlckVsbGlwc2l6ZWRUb0xlbmd0aCgpLCAi LlxuIik7CkBAIC0xMjgsNyArMTMxLDcgQEAgT3B0aW9uYWw8U3RyaW5nPiBNaXhlZENvbnRlbnRD aGVja2VyOjpjaGVja0Zvck1peGVkQ29udGVudEluRnJhbWVUcmVlKGNvbnN0IFVSTCYKICAgICAg ICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKGRvY3VtZW50LT5mcmFtZSgpLCAiQW4gdW5w YXJlbnRlZCBkb2N1bWVudCB0cmllZCB0byBjb25uZWN0IHRvIGEgd2Vic29ja2V0IHdpdGggdXJs OiAlcyIsIHVybC5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKICAgICAgICAgCiAgICAgICAgIGF1 dG8qIGZyYW1lID0gZG9jdW1lbnQtPmZyYW1lKCk7Ci0gICAgICAgIGlmIChpc01peGVkQ29udGVu dChkb2N1bWVudC0+c2VjdXJpdHlPcmlnaW4oKSwgdXJsKSkKKyAgICAgICAgaWYgKGlzTWl4ZWRD b250ZW50KGRvY3VtZW50LT5zZXR0aW5ncygpLCBkb2N1bWVudC0+c2VjdXJpdHlPcmlnaW4oKSwg dXJsKSkKICAgICAgICAgICAgIHJldHVybiBtYWtlU3RyaW5nKCJUaGUgcGFnZSBhdCAiLCBkb2N1 bWVudC0+dXJsKCkuc3RyaW5nQ2VudGVyRWxsaXBzaXplZFRvTGVuZ3RoKCksICIgd2FzIGJsb2Nr ZWQgZnJvbSBjb25uZWN0aW5nIGluc2VjdXJlbHkgdG8gIiwgdXJsLnN0cmluZ0NlbnRlckVsbGlw c2l6ZWRUb0xlbmd0aCgpLCAiIGVpdGhlciBiZWNhdXNlIHRoZSBwcm90b2NvbCBpcyBpbnNlY3Vy ZSBvciB0aGUgcGFnZSBpcyBlbWJlZGRlZCBmcm9tIGFuIGluc2VjdXJlIHBhZ2UuIik7CiAKICAg ICAgICAgaWYgKGZyYW1lLT5pc01haW5GcmFtZSgpKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvbG9hZGVyL01peGVkQ29udGVudENoZWNrZXIuaCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9N aXhlZENvbnRlbnRDaGVja2VyLmgKaW5kZXggNjg4OWU1ZjQxNC4uYjNlYjFlMThjMCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL01peGVkQ29udGVudENoZWNrZXIuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9sb2FkZXIvTWl4ZWRDb250ZW50Q2hlY2tlci5oCkBAIC0zOCw2ICszOCw3 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIGNsYXNzIEZyYW1lOwogY2xhc3MgRnJhbWVMb2FkZXJD bGllbnQ7CiBjbGFzcyBTZWN1cml0eU9yaWdpbjsKK2NsYXNzIFNldHRpbmdzOwogCiBjbGFzcyBN aXhlZENvbnRlbnRDaGVja2VyIHsKICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShNaXhlZENvbnRl bnRDaGVja2VyKTsKQEAgLTU3LDcgKzU4LDcgQEAgcHVibGljOgogICAgIGJvb2wgY2FuRGlzcGxh eUluc2VjdXJlQ29udGVudChTZWN1cml0eU9yaWdpbiYsIENvbnRlbnRUeXBlLCBjb25zdCBVUkwm LCBBbHdheXNEaXNwbGF5SW5Ob25TdHJpY3RNb2RlID0gQWx3YXlzRGlzcGxheUluTm9uU3RyaWN0 TW9kZTo6Tm8pIGNvbnN0OwogICAgIGJvb2wgY2FuUnVuSW5zZWN1cmVDb250ZW50KFNlY3VyaXR5 T3JpZ2luJiwgY29uc3QgVVJMJikgY29uc3Q7CiAgICAgdm9pZCBjaGVja0Zvcm1Gb3JNaXhlZENv bnRlbnQoU2VjdXJpdHlPcmlnaW4mLCBjb25zdCBVUkwmKSBjb25zdDsKLSAgICBzdGF0aWMgYm9v bCBpc01peGVkQ29udGVudChTZWN1cml0eU9yaWdpbiYsIGNvbnN0IFVSTCYpOworICAgIHN0YXRp YyBib29sIGlzTWl4ZWRDb250ZW50KGNvbnN0IFNldHRpbmdzJiwgU2VjdXJpdHlPcmlnaW4mLCBj b25zdCBVUkwmKTsKICAgICBPcHRpb25hbDxTdHJpbmc+IGNoZWNrRm9yTWl4ZWRDb250ZW50SW5G cmFtZVRyZWUoY29uc3QgVVJMJik7CiAKIHByaXZhdGU6CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2VjdXJp dHlPcmlnaW4uY3BwCmluZGV4IDEwN2MxODU2YTIuLjA2ZTIxZDBhN2QgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvU2VjdXJpdHlPcmlnaW4uY3BwCkBAIC0xMzEsNiArMTMxLDEyIEBAIHN0YXRpYyBib29s IGlzTG9vcGJhY2tJUEFkZHJlc3MoU3RyaW5nVmlldyBob3N0KQogICAgIHJldHVybiBkb3RzRm91 bmQgPT0gMzsKIH0KIAorc3RhdGljIGJvb2wgaXNMb2NhbGhvc3RJUEFkZHJlc3MoU3RyaW5nVmll dyBob3N0KQoreworICAgIHJldHVybiBlcXVhbExldHRlcnNJZ25vcmluZ0FTQ0lJQ2FzZShob3N0 LCAibG9jYWxob3N0IikKKyAgICAgICAgfHwgaG9zdC5lbmRzV2l0aElnbm9yaW5nQVNDSUlDYXNl KCIubG9jYWxob3N0Iik7Cit9CisKIC8vIGh0dHBzOi8vdzNjLmdpdGh1Yi5pby93ZWJhcHBzZWMt c2VjdXJlLWNvbnRleHRzLyNpcy1vcmlnaW4tdHJ1c3R3b3J0aHkgKEVkaXRvcidzIERyYWZ0LCAx NyBOb3ZlbWJlciAyMDE2KQogc3RhdGljIGJvb2wgc2hvdWxkVHJlYXRBc1BvdGVudGlhbGx5VHJ1 c3R3b3J0aHkoY29uc3QgU3RyaW5nJiBwcm90b2NvbCwgY29uc3QgU3RyaW5nJiBob3N0KQogewpA QCAtNTk5LDEyICs2MDUsMzYgQEAgYm9vbCBTZWN1cml0eU9yaWdpbjo6aXNTYW1lU2NoZW1lSG9z dFBvcnQoY29uc3QgU2VjdXJpdHlPcmlnaW4mIG90aGVyKSBjb25zdAogICAgIHJldHVybiB0cnVl OwogfQogCitib29sIFNlY3VyaXR5T3JpZ2luOjppc0FQcmlvcml0eUF1dGhlbnRpY2F0ZWRVUkwo Y29uc3QgU2V0dGluZ3MmIHNldHRpbmdzLCBjb25zdCBVUkwmIHVybCkKK3sKKyAgICAvLyBGSVhN RTogVGhpcyBzaG91bGQganVzdCBiZSByZXR1cm5pbmcgc29tZXRoaW5nIGxpa2UKKyAgICAvLyBz aG91bGRUcmVhdEFzUG90ZW50aWFsbHlUcnVzdHdvcnRoeSh1cmwpIHx8IHVybC5wcm90b2NvbCgp ID09ICJkYXRhIgorICAgIC8vIGJ1dCBzaG91bGRUcmVhdEFzUG90ZW50aWFsbHlUcnVzdHdvcnRo eSBpcyBub3QgcmVhbGx5IHVwLXRvLWRhdGUgd2l0aAorICAgIC8vIHJlc3BlY3QgdG8gdGhlIGxh dGVzdCBzcGVjaWZpY2F0aW9uLiBGb3Igbm93LCB3ZSBqdXN0IGltcGxlbWVudCBhCisgICAgLy8g c2ltcGxpZmllZCB2ZXJzaW9uIHRvIGFsbG93IE1peGVkQ29udGVudENoZWNrZXI6OmlzTWl4ZWRD b250ZW50IHRvIHJldHVybgorICAgIC8vIGZhbHNlIGZvciBsb29wYmFjayBJUCBhZGRyZXNzZXMg YW5kIGxvY2FsaG9zdCBhZGRyZXNzZXMuCisgICAgYXV0byBob3N0ID0gdXJsLmhvc3QoKS50b1N0 cmluZ1dpdGhvdXRDb3B5aW5nKCk7CisKKyAgICAvLyBodHRwczovL3czYy5naXRodWIuaW8vd2Vi YXBwc2VjLXNlY3VyZS1jb250ZXh0cy8jaXMtb3JpZ2luLXRydXN0d29ydGh5CisgICAgLy8gaG9z dCBjb21wb25lbnQgbWF0Y2hlcyBvbmUgb2YgdGhlIENJRFIgbm90YXRpb25zIDEyNy4wLjAuMC84 IG9yIDo6MS8xMjgKKyAgICBpZiAoc2V0dGluZ3MudHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVz c2VzRW5hYmxlZCgpICYmIGlzTG9vcGJhY2tJUEFkZHJlc3MoaG9zdCkpCisgICAgICAgIHJldHVy biB0cnVlOworCisgICAgLy8gaHR0cHM6Ly93M2MuZ2l0aHViLmlvL3dlYmFwcHNlYy1zZWN1cmUt Y29udGV4dHMvI2lzLW9yaWdpbi10cnVzdHdvcnRoeQorICAgIC8vIGhvc3QgY29tcG9uZW50IGlz ICJsb2NhbGhvc3QiIG9yIGZhbGxzIHdpdGhpbiAiLmxvY2FsaG9zdCIKKyAgICBpZiAoc2V0dGlu Z3MudHJ1c3R3b3J0aHlMb2NhbGhvc3RBZGRyZXNzZXNFbmFibGVkKCkgJiYgaXNMb2NhbGhvc3RJ UEFkZHJlc3MoaG9zdCkpCisgICAgICAgIHJldHVybiB0cnVlOworCisgICAgcmV0dXJuIGZhbHNl OworfQorCiBib29sIFNlY3VyaXR5T3JpZ2luOjppc0xvY2FsSG9zdE9yTG9vcGJhY2tJUEFkZHJl c3MoU3RyaW5nVmlldyBob3N0KQogewogICAgIGlmIChpc0xvb3BiYWNrSVBBZGRyZXNzKGhvc3Qp KQogICAgICAgICByZXR1cm4gdHJ1ZTsKIAogICAgIC8vIEZJWE1FOiBFbnN1cmUgdGhhdCBsb2Nh bGhvc3QgcmVzb2x2ZXMgdG8gdGhlIGxvb3BiYWNrIGFkZHJlc3MuCisgICAgLy8gRklYTUU6IFVz ZSBpc0xvY2FsaG9zdElQQWRkcmVzcygpLgogICAgIGlmIChlcXVhbExldHRlcnNJZ25vcmluZ0FT Q0lJQ2FzZShob3N0LCAibG9jYWxob3N0IikpCiAgICAgICAgIHJldHVybiB0cnVlOwogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmggYi9Tb3VyY2UvV2Vi Q29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKaW5kZXggMjA3ZjhhOGFhNi4uM2YzYzAxYWYxYiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaApAQCAtMzUsNiArMzUsOCBAQAogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKK2NsYXNzIFNldHRpbmdzOworCiBjbGFzcyBTZWN1cml0eU9y aWdpbiA6IHB1YmxpYyBUaHJlYWRTYWZlUmVmQ291bnRlZDxTZWN1cml0eU9yaWdpbj4gewogcHVi bGljOgogICAgIGVudW0gUG9saWN5IHsKQEAgLTIxNiw2ICsyMTgsMTAgQEAgcHVibGljOgogCiAg ICAgV0VCQ09SRV9FWFBPUlQgc3RhdGljIGJvb2wgaXNMb2NhbEhvc3RPckxvb3BiYWNrSVBBZGRy ZXNzKFN0cmluZ1ZpZXcpOwogCisgICAgLy8gVGhpcyBtZXRob2QgaW1wbGVtZW50cyB0aGUgYSBw cmlvcmkgYXV0aGVudGljYXRlZCBVUkwKKyAgICAvLyBodHRwczovL3czYy5naXRodWIuaW8vd2Vi YXBwc2VjLW1peGVkLWNvbnRlbnQvI2EtcHJpb3JpLWF1dGhlbnRpY2F0ZWQtdXJsCisgICAgV0VC Q09SRV9FWFBPUlQgc3RhdGljIGJvb2wgaXNBUHJpb3JpdHlBdXRoZW50aWNhdGVkVVJMKGNvbnN0 IFNldHRpbmdzJiwgY29uc3QgVVJMJik7CisKICAgICBjb25zdCBTZWN1cml0eU9yaWdpbkRhdGEm IGRhdGEoKSBjb25zdCB7IHJldHVybiBtX2RhdGE7IH0KIAogICAgIHRlbXBsYXRlPGNsYXNzIEVu Y29kZXI+IHZvaWQgZW5jb2RlKEVuY29kZXImKSBjb25zdDsKLS0gCjIuMTQuMQoK 413263 2020-11-04 23:54:01 -0800 2020-11-05 10:44:30 -0800 Patch 0001-localhost.patch text/plain 83032 fred.wang RnJvbSAzY2ViZDcyMDY4OTUwNWE1ZGZjMGU1ODgxMzM3ZDljYmMwOWJkNmYzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBGcmVkZXJpYyBXYW5nIDxmd2FuZ0BpZ2FsaWEuY29tPgpEYXRl OiBGcmksIDMwIE9jdCAyMDIwIDE3OjQxOjMwICswMTAwClN1YmplY3Q6IFtQQVRDSCB4c2VydmVy XSBsb2NhbGhvc3QKCi0tLQogLi4ub2FkUmVzb3VyY2UtaW5zZWN1cmUtcmVzb3VyY2UtZXhwZWN0 ZWQudHh0IHwgIDQgKy0tCiAuLi4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0 ICAgICAgfCAgMiAtLQogLi4uL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dCAg ICAgIHwgIDIgLS0KIC4uLi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQgICAg ICB8ICAyIC0tCiAuLi4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0ICAgICAg fCAgMiAtLQogLi4uL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dCAgICAgIHwg IDIgLS0KIC4uLi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQgICAgICB8ICAy IC0tCiAuLi4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0ICAgICAgfCAgMiAt LQogLi4uL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dCAgICAgIHwgIDIgLS0K IC4uLi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQgICAgICB8ICAyIC0tCiAu Li4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0ICAgICAgfCAgMiAtLQogLi4u L2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dCAgICAgIHwgIDIgLS0KIC4uLi9j cm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQgICAgICB8ICAyIC0tCiAuLi4vY3Jv c3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0ICAgICAgfCAgMiAtLQogLi4uL2Nyb3Nz LW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dCAgICAgIHwgIDIgLS0KIC4uLi9jcm9zcy1v cmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQgICAgICB8ICAyIC0tCiAuLi4vY3Jvc3Mtb3Jp Z2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0ICAgICAgfCAgMiAtLQogLi4uL2Nyb3NzLW9yaWdp bi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dCAgICAgIHwgIDIgLS0KIC4uLi9jcm9zcy1vcmlnaW4t aHR0cC5odHRwcy1leHBlY3RlZC50eHQgICAgICB8ICAyIC0tCiAuLi4vY3Jvc3Mtb3JpZ2luLWh0 dHAuaHR0cHMtZXhwZWN0ZWQudHh0ICAgICAgfCAgMiAtLQogLi4uL2Nyb3NzLW9yaWdpbi1odHRw Lmh0dHBzLWV4cGVjdGVkLnR4dCAgICAgIHwgIDIgLS0KIC4uLi9jcm9zcy1vcmlnaW4taHR0cC5o dHRwcy1leHBlY3RlZC50eHQgICAgICB8ICAyIC0tCiAuLi4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0 cHMtZXhwZWN0ZWQudHh0ICAgICAgfCAgMiAtLQogLi4uL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBz LWV4cGVjdGVkLnR4dCAgICAgIHwgIDIgLS0KIC4uLi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1l eHBlY3RlZC50eHQgICAgICB8ICAyIC0tCiAuLi4vaW5zZWN1cmUtY3NzLWluLWlmcmFtZS1yZXBv cnQtb25seS5odG1sICAgfCAgMiArLQogLi4uL2luc2VjdXJlLWNzcy1pbi1pZnJhbWUuaHRtbCAg ICAgICAgICAgICAgIHwgIDIgKy0KIC4uLi9pbnNlY3VyZS1jc3MtaW4tbWFpbi1mcmFtZS5odG1s ICAgICAgICAgICB8ICAyICstCiAuLi4vaW5zZWN1cmUtaWZyYW1lLWluLWlmcmFtZS5odG1sICAg ICAgICAgICAgfCAgMiArLQogLi4uL2luc2VjdXJlLWlmcmFtZS1pbi1tYWluLWZyYW1lLmh0bWwg ICAgICAgIHwgIDIgKy0KIC4uLnJlLWltYWdlLWluLWJsb2ItdXJsLWlmcmFtZS1pbi1pZnJhbWUu aHRtbCB8ICAyICstCiAuLi5hbWUtd2l0aC1lbmZvcmNlZC1hbmQtcmVwb3J0LXBvbGljaWVzLmh0 bWwgfCAgMiArLQogLi4uaW1hZ2UtaW4taWZyYW1lLXdpdGgtaW5oZXJpdGVkLXBvbGljeS5odG1s IHwgIDIgKy0KIC4uLi9pbnNlY3VyZS1pbWFnZS1pbi1pZnJhbWUuaHRtbCAgICAgICAgICAgICB8 ICAyICstCiAuLi5nZS1pbi1qYXZhc2NyaXB0LXVybC1pZnJhbWUtaW4taWZyYW1lLmh0bWwgfCAg MiArLQogLi4uL2luc2VjdXJlLWltYWdlLWluLW1haW4tZnJhbWUuaHRtbCAgICAgICAgIHwgIDIg Ky0KIC4uLnVtZW50LWluLWlmcmFtZS13aXRoLWluaGVyaXRlZC1wb2xpY3kuaHRtbCB8ICAyICst CiAuLi4vaW5zZWN1cmUtcGx1Z2luLWluLWlmcmFtZS5odG1sICAgICAgICAgICAgfCAgMiArLQog Li4uL2luc2VjdXJlLXBsdWdpbi1pbi1tYWluLWZyYW1lLmh0bWwgICAgICAgIHwgIDIgKy0KIC4u LmNyaXB0LWluLWlmcmFtZS13aXRoLWluaGVyaXRlZC1wb2xpY3kuaHRtbCB8ICAyICstCiAuLi4v aW5zZWN1cmUtc2NyaXB0LWluLWlmcmFtZS5odG1sICAgICAgICAgICAgfCAgMiArLQogLi4uL2lu c2VjdXJlLXNjcmlwdC1pbi1tYWluLWZyYW1lLmh0bWwgICAgICAgIHwgIDIgKy0KIC4uLi9pbnNl Y3VyZS14aHItYXN5bmNocm9ub3VzLWluLWlmcmFtZS5odG1sICB8ICAyICstCiAuLi5zZWN1cmUt eGhyLWFzeW5jaHJvbm91cy1pbi1tYWluLWZyYW1lLmh0bWwgfCAgMiArLQogLi4uL2luc2VjdXJl LXhoci1zeW5jaHJvbm91cy1pbi1pZnJhbWUuaHRtbCAgIHwgIDIgKy0KIC4uLm5zZWN1cmUteGhy LXN5bmNocm9ub3VzLWluLW1haW4tZnJhbWUuaHRtbCB8ICAyICstCiAuLi4vcmVzb3VyY2VzL2Zy YW1lLXdpdGgtaW5zZWN1cmUtaWZyYW1lLmh0bWwgfCAgMiArLQogLi4uL2lmcmFtZS11cGdyYWRl Lmh0dHBzLWV4cGVjdGVkLnR4dCAgICAgICAgIHwgIDIgLS0KIC4uLi9wcm9wZXItb3Blbi13aW5k b3ctdXBncmFkZXMtZXhwZWN0ZWQudHh0ICB8ICAyIC0tCiAuLi4vaW1wb3J0LWluc2VjdXJlLXNj cmlwdC1pbi1pZnJhbWUuaHRtbCAgICAgfCAgMiArLQogLi4uc2VjdXJlLWJhc2ljLWF1dGgtaW1h Z2UuaHR0cHMtZXhwZWN0ZWQudHh0IHwgIDIgLS0KIC4uLi9taXhlZENvbnRlbnQvaW5zZWN1cmUt Y3NzLWluLWlmcmFtZS5odG1sICB8ICAyICstCiAuLi4vaW5zZWN1cmUtY3NzLWluLW1haW4tZnJh bWUuaHRtbCAgICAgICAgICAgfCAgMiArLQogLi4ucmUtZXhlY3V0YWJsZS1jc3Mtd2l0aC1zZWN1 cmUtY29va2llcy5odG1sIHwgIDIgKy0KIC4uLi9pbnNlY3VyZS1mb3JtLWluLW1haW4tZnJhbWUu aHRtbCAgICAgICAgICB8ICAyICstCiAuLi4vaW5zZWN1cmUtaWZyYW1lLWluLW1haW4tZnJhbWUu aHRtbCAgICAgICAgfCAgMiArLQogLi4uL2luc2VjdXJlLWltYWdlLWluLW1haW4tZnJhbWUuaHRt bCAgICAgICAgIHwgIDIgKy0KIC4uLk9yaWdpblN1YnJlc291cmNlc1RvQXNrRm9yQ3JlZGVudGlh bHMuaHRtbCB8ICAyICstCiAuLi4tcmVkaXJlY3RzLXRvLWJhc2ljLWF1dGgtc2VjdXJlLWltYWdl Lmh0bWwgfCAgMiArLQogLi4ubnNlY3VyZS1pbWFnZS13aXRoLXNlY3VyZWNvb2tpZS1ibG9jay5o dG1sIHwgIDIgKy0KIC4uLi9pbnNlY3VyZS1pbWFnZS13aXRoLXNlY3VyZWNvb2tpZS5odG1sICAg ICB8ICAyICstCiAuLi4vaW5zZWN1cmUtcGx1Z2luLWluLWlmcmFtZS5odG1sICAgICAgICAgICAg fCAgMiArLQogLi4uLWluLWRhdGEtaWZyYW1lLWluLW1haW4tZnJhbWUtYmxvY2tlZC5odG1sIHwg IDQgKy0tCiAuLi4vaW5zZWN1cmUtc2NyaXB0LWluLWlmcmFtZS5odG1sICAgICAgICAgICAgfCAg MiArLQogLi4ucmVkaXJlY3RzLXRvLWJhc2ljLWF1dGgtc2VjdXJlLXNjcmlwdC5odG1sIHwgIDIg Ky0KIC4uLi9pbnNlY3VyZS1zY3JpcHQtd2l0aC1zZWN1cmUtY29va2llcy5odG1sICB8ICAyICst CiAuLi5yZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1zdHlsZXNoZWV0Lmh0bWwgfCAgMiArLQog Li4uL2luc2VjdXJlLXhoci1pbi1tYWluLWZyYW1lLmh0bWwgICAgICAgICAgIHwgIDIgKy0KIC4u Li9pbnNlY3VyZS14aHItc3luYy1pbi1tYWluLWZyYW1lLmh0bWwgICAgICB8ICAyICstCiAuLi5j dC1odHRwLXRvLWh0dHBzLWlmcmFtZS1pbi1tYWluLWZyYW1lLmh0bWwgfCAgMiArLQogLi4uZGly ZWN0LWh0dHAtdG8taHR0cHMtc2NyaXB0LWluLWlmcmFtZS5odG1sIHwgIDIgKy0KIC4uLmN0LWh0 dHBzLXRvLWh0dHAtaWZyYW1lLWluLW1haW4tZnJhbWUuaHRtbCB8ICAyICstCiAuLi5wcy10by1o dHRwLWltYWdlLXNlY3VyZS1jb29raWVzLWJsb2NrLmh0bWwgfCAgMiArLQogLi4uY3QtaHR0cHMt dG8taHR0cC1pbWFnZS1zZWN1cmUtY29va2llcy5odG1sIHwgIDIgKy0KIC4uLmRpcmVjdC1odHRw cy10by1odHRwLXNjcmlwdC1pbi1pZnJhbWUuaHRtbCB8ICAyICstCiAuLi5TdWJyZXNvdXJjZXNU b0Fza0ZvckNyZWRlbnRpYWxzLmh0dHBzLmh0bWwgfCAgMiArLQogLi4ucmVjdC10by1iYXNpYy1h dXRoLXNlY3VyZS1pbWFnZS5odHRwcy5odG1sIHwgIDIgKy0KIC4uLnNpYy1hdXRoLWluc2VjdXJl LWltYWdlLmh0dHBzLWV4cGVjdGVkLnR4dCB8ICAyIC0tCiAuLi4vaW5zZWN1cmUtd2Vic29ja2V0 LWluLWlmcmFtZS5odG1sICAgICAgICAgfCAgMiArLQogLi4uL2luc2VjdXJlLXdlYnNvY2tldC1p bi1tYWluLWZyYW1lLmh0bWwgICAgIHwgIDIgKy0KIC4uLm50LWdlb2xvY2F0aW9uLWJsb2NrLWlu c2VjdXJlLWNvbnRlbnQuaHRtbCB8ICAyICstCiAuLi4vc2VjdXJpdHkvbWl4ZWRjb250ZW50LWdl b2xvY2F0aW9uLmh0bWwgICAgfCAgMiArLQogLi4uL29yaWdpbi1oZWFkZXItZm9yLWh0dHBzLWV4 cGVjdGVkLnR4dCAgICAgIHwgIDIgLS0KIC4uLi9zc2wvbWl4ZWRDb250ZW50L2luc2VjdXJlLXdl YnNvY2tldC5odG1sICB8ICAyICstCiAuLi5pdGgtZW1iZWRkZWQtaHR0cHMtd2l0aC1lbWJlZGRl ZC1odHRwLmh0bWwgfCAgMiArLQogLi4udGVudC1ibG9ja2VkLWh0dHAtd2l0aC1lbWJlZGRlZC1o dHRwcy5odG1sIHwgIDIgKy0KIC4uLmJlZGRlZC1odHRwLXdpdGgtZW1iZWRkZWQtaHR0cHMuaHR0 cHMuaHRtbCB8ICAyICstCiAuLi4tZG9jdW1lbnQtbWl4ZWQtY29udGVudC1ibG9ja2VkLmh0dHBz Lmh0bWwgfCAgMiArLQogLi4ucmNlc1RvQXNrRm9yQ3JlZGVudGlhbHMuaHR0cHMtZXhwZWN0ZWQu dHh0IHwgIDIgLS0KIC4uLnJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzLmh0dHBzLWV4cGVjdGVkLnR4 dCB8ICAyIC0tCiAuLi4vV2ViUHJlZmVyZW5jZXNFeHBlcmltZW50YWwueWFtbCAgICAgICAgICAg fCAyNiArKysrKysrKysrKysrKysrCiBTb3VyY2UvV2ViQ29yZS9odG1sL3BhcnNlci9YU1NBdWRp dG9yLmNwcCAgICAgfCAgMiArLQogU291cmNlL1dlYkNvcmUvbG9hZGVyL01peGVkQ29udGVudENo ZWNrZXIuY3BwIHwgMTMgKysrKy0tLS0KIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9NaXhlZENvbnRl bnRDaGVja2VyLmggICB8ICAzICstCiBTb3VyY2UvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2lu LmNwcCAgICAgICAgfCAzMCArKysrKysrKysrKysrKysrKysrCiBTb3VyY2UvV2ViQ29yZS9wYWdl L1NlY3VyaXR5T3JpZ2luLmggICAgICAgICAgfCAgNiArKysrCiA5NiBmaWxlcyBjaGFuZ2VkLCAx MzMgaW5zZXJ0aW9ucygrKSwgMTMxIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvaW5zcGVjdG9yL25ldHdvcmsvbG9hZFJlc291cmNlLWluc2VjdXJlLXJl c291cmNlLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvaW5zcGVjdG9yL25l dHdvcmsvbG9hZFJlc291cmNlLWluc2VjdXJlLXJlc291cmNlLWV4cGVjdGVkLnR4dAppbmRleCBl ODY0ODJmNmE3NWQuLmNlN2E2NjFlOTMwNiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9pbnNwZWN0b3IvbmV0d29yay9sb2FkUmVzb3VyY2UtaW5zZWN1cmUtcmVzb3VyY2UtZXhw ZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvaW5zcGVjdG9yL25ldHdvcmsv bG9hZFJlc291cmNlLWluc2VjdXJlLXJlc291cmNlLWV4cGVjdGVkLnR4dApAQCAtMSw2ICsxLDQg QEAKLUNPTlNPTEUgTUVTU0FHRTogW2Jsb2NrZWRdIFRoZSBwYWdlIGF0IGh0dHBzOi8vMTI3LjAu MC4xOjg0NDMvaW5zcGVjdG9yL25ldHdvcmsvbG9hZFJlc291cmNlLWluc2VjdXJlLXJlc291cmNl Lmh0bWwgd2FzIG5vdCBhbGxvd2VkIHRvIGRpc3BsYXkgaW5zZWN1cmUgY29udGVudCBmcm9tIGh0 dHA6Ly8xMjcuMC4wLjA6ODAwMC9pbnNwZWN0b3IvbmV0d29yay9yZXNvdXJjZXMvZGF0YS5qc29u PzIuCi0KLUNPTlNPTEUgTUVTU0FHRTogTm90IGFsbG93ZWQgdG8gcmVxdWVzdCByZXNvdXJjZQor QmxvY2tlZCBhY2Nlc3MgdG8gZXh0ZXJuYWwgVVJMIGh0dHA6Ly8xMjcuMC4wLjA6ODAwMC9pbnNw ZWN0b3IvbmV0d29yay9yZXNvdXJjZXMvZGF0YS5qc29uPzIKIENPTlNPTEUgTUVTU0FHRTogQ2Fu bm90IGxvYWQgaHR0cDovLzEyNy4wLjAuMDo4MDAwL2luc3BlY3Rvci9uZXR3b3JrL3Jlc291cmNl cy9kYXRhLmpzb24/MiBkdWUgdG8gYWNjZXNzIGNvbnRyb2wgY2hlY2tzLgogVGVzdHMgbG9hZGlu ZyByZXNvdXJjZXMgb24gYSBzZWN1cmUgcGFnZSB3aXRoIE5ldHdvcmsubG9hZFJlc291cmNlLgog CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pZnJh bWUvbm8tcmVmZXJyZXItd2hlbi1kb3duZ3JhZGUvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhw ZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaWZyYW1l L25vLXJlZmVycmVyLXdoZW4tZG93bmdyYWRlL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVj dGVkLnR4dAppbmRleCA1ZjJmNDEwM2NmYjYuLjI1ODE4NjUxNWFkMyAxMDA2NDQKLS0tIGEvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaWZyYW1lL25vLXJlZmVycmVyLXdo ZW4tZG93bmdyYWRlL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dAorKysgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pZnJhbWUvbm8tcmVmZXJyZXIt d2hlbi1kb3duZ3JhZGUvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0x LDUgKzEsMyBAQAotQ09OU09MRSBNRVNTQUdFOiBUaGUgcGFnZSBhdCBhYm91dDpibGFuayB3YXMg YWxsb3dlZCB0byBkaXNwbGF5IGluc2VjdXJlIGNvbnRlbnQgZnJvbSBodHRwOi8vbG9jYWxob3N0 OjgwMDAvcmVmZXJyZXItcG9saWN5L3Jlc291cmNlcy9kb2N1bWVudC5odG1sLgotCiBUZXN0cyB0 aGUgYmVoYXZpb3Igb2Ygbm8tcmVmZXJyZXItd2hlbi1kb3duZ3JhZGUgcmVmZXJyZXIgcG9saWN5 IHdoZW4gY3Jvc3Mgb3JpZ2luIGZyb20gSFRUUFMgdG8gSFRUUC4KIAogT24gc3VjY2VzcywgeW91 IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1Qg Q09NUExFVEUiLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1w b2xpY3ktaWZyYW1lL25vLXJlZmVycmVyL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVk LnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlmcmFtZS9uby1y ZWZlcnJlci9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKaW5kZXggYTMwNmQ2 YzgxNDFkLi5mZGQ0OGVkYzZhYTYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv cmVmZXJyZXItcG9saWN5LWlmcmFtZS9uby1yZWZlcnJlci9jcm9zcy1vcmlnaW4taHR0cC5odHRw cy1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xp Y3ktaWZyYW1lL25vLXJlZmVycmVyL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4 dApAQCAtMSw1ICsxLDMgQEAKLUNPTlNPTEUgTUVTU0FHRTogVGhlIHBhZ2UgYXQgYWJvdXQ6Ymxh bmsgd2FzIGFsbG93ZWQgdG8gZGlzcGxheSBpbnNlY3VyZSBjb250ZW50IGZyb20gaHR0cDovL2xv Y2FsaG9zdDo4MDAwL3JlZmVycmVyLXBvbGljeS9yZXNvdXJjZXMvZG9jdW1lbnQuaHRtbC4KLQog VGVzdHMgdGhlIGJlaGF2aW9yIG9mIG5vLXJlZmVycmVyIHJlZmVycmVyIHBvbGljeSB3aGVuIGNy b3NzIG9yaWdpbiBmcm9tIEhUVFBTIHRvIEhUVFAuCiAKIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNl ZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRF Ii4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlm cmFtZS9vcmlnaW4td2hlbi1jcm9zcy1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhw ZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaWZyYW1l L29yaWdpbi13aGVuLWNyb3NzLW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3Rl ZC50eHQKaW5kZXggNTlkYjIyMDg5YWI0Li4zMzAwZmJmNGFjNGEgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlmcmFtZS9vcmlnaW4td2hlbi1jcm9z cy1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlmcmFtZS9vcmlnaW4td2hlbi1jcm9z cy1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0xLDUgKzEs MyBAQAotQ09OU09MRSBNRVNTQUdFOiBUaGUgcGFnZSBhdCBhYm91dDpibGFuayB3YXMgYWxsb3dl ZCB0byBkaXNwbGF5IGluc2VjdXJlIGNvbnRlbnQgZnJvbSBodHRwOi8vbG9jYWxob3N0OjgwMDAv cmVmZXJyZXItcG9saWN5L3Jlc291cmNlcy9kb2N1bWVudC5odG1sLgotCiBUZXN0cyB0aGUgYmVo YXZpb3Igb2Ygb3JpZ2luLXdoZW4tY3Jvc3Mtb3JpZ2luIHJlZmVycmVyIHBvbGljeSB3aGVuIGNy b3NzIG9yaWdpbiBmcm9tIEhUVFBTIHRvIEhUVFAuCiAKIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNl ZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRF Ii4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlm cmFtZS9vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaWZyYW1lL29yaWdpbi9jcm9zcy1vcmln aW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKaW5kZXggZmRkOGI5MjA3YzQxLi42NDg2MjY4ZDdl ZjQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlm cmFtZS9vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CisrKyBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlmcmFtZS9vcmlnaW4vY3Jvc3Mt b3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0xLDUgKzEsMyBAQAotQ09OU09MRSBN RVNTQUdFOiBUaGUgcGFnZSBhdCBhYm91dDpibGFuayB3YXMgYWxsb3dlZCB0byBkaXNwbGF5IGlu c2VjdXJlIGNvbnRlbnQgZnJvbSBodHRwOi8vbG9jYWxob3N0OjgwMDAvcmVmZXJyZXItcG9saWN5 L3Jlc291cmNlcy9kb2N1bWVudC5odG1sLgotCiBUZXN0cyB0aGUgYmVoYXZpb3Igb2Ygb3JpZ2lu IHJlZmVycmVyIHBvbGljeSB3aGVuIGNyb3NzIG9yaWdpbiBmcm9tIEhUVFBTIHRvIEhUVFAuCiAK IE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZv bGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvcmVmZXJyZXItcG9saWN5LWlmcmFtZS9zYW1lLW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0 cC5odHRwcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBv bGljeS1pZnJhbWUvc2FtZS1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQu dHh0CmluZGV4IDE5YTg1YTY2YWIxMS4uZWM4MWU5NTIyNDQ3IDEwMDY0NAotLS0gYS9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pZnJhbWUvc2FtZS1vcmlnaW4vY3Jvc3Mt b3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvcmVmZXJyZXItcG9saWN5LWlmcmFtZS9zYW1lLW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5o dHRwcy1leHBlY3RlZC50eHQKQEAgLTEsNSArMSwzIEBACi1DT05TT0xFIE1FU1NBR0U6IFRoZSBw YWdlIGF0IGFib3V0OmJsYW5rIHdhcyBhbGxvd2VkIHRvIGRpc3BsYXkgaW5zZWN1cmUgY29udGVu dCBmcm9tIGh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC9yZWZlcnJlci1wb2xpY3kvcmVzb3VyY2VzL2Rv Y3VtZW50Lmh0bWwuCi0KIFRlc3RzIHRoZSBiZWhhdmlvciBvZiBzYW1lLW9yaWdpbiByZWZlcnJl ciBwb2xpY3kgd2hlbiBjcm9zcyBvcmlnaW4gZnJvbSBIVFRQUyB0byBIVFRQLgogCiBPbiBzdWNj ZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBi eSAiVEVTVCBDT01QTEVURSIuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Jl ZmVycmVyLXBvbGljeS1pZnJhbWUvc3RyaWN0LW9yaWdpbi13aGVuLWNyb3NzLW9yaWdpbi9jcm9z cy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3JlZmVycmVyLXBvbGljeS1pZnJhbWUvc3RyaWN0LW9yaWdpbi13aGVuLWNyb3NzLW9yaWdpbi9j cm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKaW5kZXggMjExYjliN2I2NjcwLi5h ZDEwNjkwMTg0YTcgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXIt cG9saWN5LWlmcmFtZS9zdHJpY3Qtb3JpZ2luLXdoZW4tY3Jvc3Mtb3JpZ2luL2Nyb3NzLW9yaWdp bi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Jl ZmVycmVyLXBvbGljeS1pZnJhbWUvc3RyaWN0LW9yaWdpbi13aGVuLWNyb3NzLW9yaWdpbi9jcm9z cy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKQEAgLTEsNSArMSwzIEBACi1DT05TT0xF IE1FU1NBR0U6IFRoZSBwYWdlIGF0IGFib3V0OmJsYW5rIHdhcyBhbGxvd2VkIHRvIGRpc3BsYXkg aW5zZWN1cmUgY29udGVudCBmcm9tIGh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC9yZWZlcnJlci1wb2xp Y3kvcmVzb3VyY2VzL2RvY3VtZW50Lmh0bWwuCi0KIFRlc3RzIHRoZSBiZWhhdmlvciBvZiBzdHJp Y3Qtb3JpZ2luLXdoZW4tY3Jvc3Mtb3JpZ2luIHJlZmVycmVyIHBvbGljeSB3aGVuIGNyb3NzIG9y aWdpbiBmcm9tIEhUVFBTIHRvIEhUVFAuCiAKIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNl cmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlmcmFtZS9z dHJpY3Qtb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlmcmFtZS9zdHJpY3Qtb3JpZ2luL2Ny b3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dAppbmRleCBkZDQwMTA3NzAxZTUuLjVi NzhhN2U0NzNiOSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1w b2xpY3ktaWZyYW1lL3N0cmljdC1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0 ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlmcmFt ZS9zdHJpY3Qtb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dApAQCAt MSw1ICsxLDMgQEAKLUNPTlNPTEUgTUVTU0FHRTogVGhlIHBhZ2UgYXQgYWJvdXQ6Ymxhbmsgd2Fz IGFsbG93ZWQgdG8gZGlzcGxheSBpbnNlY3VyZSBjb250ZW50IGZyb20gaHR0cDovL2xvY2FsaG9z dDo4MDAwL3JlZmVycmVyLXBvbGljeS9yZXNvdXJjZXMvZG9jdW1lbnQuaHRtbC4KLQogVGVzdHMg dGhlIGJlaGF2aW9yIG9mIHN0cmljdC1vcmlnaW4gcmVmZXJyZXIgcG9saWN5IHdoZW4gY3Jvc3Mg b3JpZ2luIGZyb20gSFRUUFMgdG8gSFRUUC4KIAogT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEg c2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaWZyYW1l L3Vuc2FmZS11cmwvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaWZyYW1lL3Vuc2FmZS11cmwvY3Jvc3Mt b3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CmluZGV4IDVhNzcyYTkxMDVhYy4uYTkwZjgx YzcyOGEzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGlj eS1pZnJhbWUvdW5zYWZlLXVybC9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQK KysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaWZyYW1lL3Vuc2Fm ZS11cmwvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0xLDUgKzEsMyBA QAotQ09OU09MRSBNRVNTQUdFOiBUaGUgcGFnZSBhdCBhYm91dDpibGFuayB3YXMgYWxsb3dlZCB0 byBkaXNwbGF5IGluc2VjdXJlIGNvbnRlbnQgZnJvbSBodHRwOi8vbG9jYWxob3N0OjgwMDAvcmVm ZXJyZXItcG9saWN5L3Jlc291cmNlcy9kb2N1bWVudC5odG1sLgotCiBUZXN0cyB0aGUgYmVoYXZp b3Igb2YgdW5zYWZlLXVybCByZWZlcnJlciBwb2xpY3kgd2hlbiBjcm9zcyBvcmlnaW4gZnJvbSBI VFRQUyB0byBIVFRQLgogCiBPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBB U1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pbWcvbm8tcmVmZXJyZXItd2hl bi1kb3duZ3JhZGUvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaW1nL25vLXJlZmVycmVyLXdoZW4tZG93 bmdyYWRlL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dAppbmRleCBhMGUxZjU3 N2IxOTQuLjI1ODE4NjUxNWFkMyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9y ZWZlcnJlci1wb2xpY3ktaW1nL25vLXJlZmVycmVyLXdoZW4tZG93bmdyYWRlL2Nyb3NzLW9yaWdp bi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Jl ZmVycmVyLXBvbGljeS1pbWcvbm8tcmVmZXJyZXItd2hlbi1kb3duZ3JhZGUvY3Jvc3Mtb3JpZ2lu LWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0xLDUgKzEsMyBAQAotQ09OU09MRSBNRVNTQUdF OiBUaGUgcGFnZSBhdCBodHRwczovLzEyNy4wLjAuMTo4NDQzL3JlZmVycmVyLXBvbGljeS1pbWcv bm8tcmVmZXJyZXItd2hlbi1kb3duZ3JhZGUvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMuaHRtbCB3 YXMgYWxsb3dlZCB0byBkaXNwbGF5IGluc2VjdXJlIGNvbnRlbnQgZnJvbSBodHRwOi8vMTI3LjAu MC4xOjgwMDAvcmVmZXJyZXItcG9saWN5L3Jlc291cmNlcy9pbWFnZS5waHA/ZXhwZWN0ZWQ9Lgot CiBUZXN0cyB0aGUgYmVoYXZpb3Igb2Ygbm8tcmVmZXJyZXItd2hlbi1kb3duZ3JhZGUgcmVmZXJy ZXIgcG9saWN5IHdoZW4gY3Jvc3Mgb3JpZ2luIGZyb20gSFRUUFMgdG8gSFRUUC4KIAogT24gc3Vj Y2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQg YnkgIlRFU1QgQ09NUExFVEUiLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9y ZWZlcnJlci1wb2xpY3ktaW1nL25vLXJlZmVycmVyL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4 cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWltZy9u by1yZWZlcnJlci9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKaW5kZXggYmFk YmEwNTdmODM5Li5mZGQ0OGVkYzZhYTYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvcmVmZXJyZXItcG9saWN5LWltZy9uby1yZWZlcnJlci9jcm9zcy1vcmlnaW4taHR0cC5odHRw cy1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xp Y3ktaW1nL25vLXJlZmVycmVyL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dApA QCAtMSw1ICsxLDMgQEAKLUNPTlNPTEUgTUVTU0FHRTogVGhlIHBhZ2UgYXQgaHR0cHM6Ly8xMjcu MC4wLjE6ODQ0My9yZWZlcnJlci1wb2xpY3ktaW1nL25vLXJlZmVycmVyL2Nyb3NzLW9yaWdpbi1o dHRwLmh0dHBzLmh0bWwgd2FzIGFsbG93ZWQgdG8gZGlzcGxheSBpbnNlY3VyZSBjb250ZW50IGZy b20gaHR0cDovL2xvY2FsaG9zdDo4MDAwL3JlZmVycmVyLXBvbGljeS9yZXNvdXJjZXMvaW1hZ2Uu cGhwP2V4cGVjdGVkPS4KLQogVGVzdHMgdGhlIGJlaGF2aW9yIG9mIG5vLXJlZmVycmVyIHJlZmVy cmVyIHBvbGljeSB3aGVuIGNyb3NzIG9yaWdpbiBmcm9tIEhUVFBTIHRvIEhUVFAuCiAKIE9uIHN1 Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2Vk IGJ5ICJURVNUIENPTVBMRVRFIi4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv cmVmZXJyZXItcG9saWN5LWltZy9vcmlnaW4td2hlbi1jcm9zcy1vcmlnaW4vY3Jvc3Mtb3JpZ2lu LWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJl ci1wb2xpY3ktaW1nL29yaWdpbi13aGVuLWNyb3NzLW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5o dHRwcy1leHBlY3RlZC50eHQKaW5kZXggZjg2YTk1NzMzNGZmLi4zMzAwZmJmNGFjNGEgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWltZy9vcmlnaW4t d2hlbi1jcm9zcy1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0Cisr KyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWltZy9vcmlnaW4td2hl bi1jcm9zcy1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0x LDUgKzEsMyBAQAotQ09OU09MRSBNRVNTQUdFOiBUaGUgcGFnZSBhdCBodHRwczovLzEyNy4wLjAu MTo4NDQzL3JlZmVycmVyLXBvbGljeS1pbWcvb3JpZ2luLXdoZW4tY3Jvc3Mtb3JpZ2luL2Nyb3Nz LW9yaWdpbi1odHRwLmh0dHBzLmh0bWwgd2FzIGFsbG93ZWQgdG8gZGlzcGxheSBpbnNlY3VyZSBj b250ZW50IGZyb20gaHR0cDovL2xvY2FsaG9zdDo4MDAwL3JlZmVycmVyLXBvbGljeS9yZXNvdXJj ZXMvaW1hZ2UucGhwP2V4cGVjdGVkPWh0dHBzOi8vMTI3LjAuMC4xOjg0NDMvLgotCiBUZXN0cyB0 aGUgYmVoYXZpb3Igb2Ygb3JpZ2luLXdoZW4tY3Jvc3Mtb3JpZ2luIHJlZmVycmVyIHBvbGljeSB3 aGVuIGNyb3NzIG9yaWdpbiBmcm9tIEhUVFBTIHRvIEhUVFAuCiAKIE9uIHN1Y2Nlc3MsIHlvdSB3 aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENP TVBMRVRFIi4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9s aWN5LWltZy9vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0IGIvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaW1nL29yaWdpbi9jcm9zcy1vcmln aW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKaW5kZXggMjZlOGQ2ZDZmZmMwLi42NDg2MjY4ZDdl ZjQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlt Zy9vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWltZy9vcmlnaW4vY3Jvc3Mtb3JpZ2lu LWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0xLDUgKzEsMyBAQAotQ09OU09MRSBNRVNTQUdF OiBUaGUgcGFnZSBhdCBodHRwczovLzEyNy4wLjAuMTo4NDQzL3JlZmVycmVyLXBvbGljeS1pbWcv b3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLmh0bWwgd2FzIGFsbG93ZWQgdG8gZGlzcGxh eSBpbnNlY3VyZSBjb250ZW50IGZyb20gaHR0cDovLzEyNy4wLjAuMTo4MDAwL3JlZmVycmVyLXBv bGljeS9yZXNvdXJjZXMvaW1hZ2UucGhwP2V4cGVjdGVkPWh0dHBzOi8vMTI3LjAuMC4xOjg0NDMv LgotCiBUZXN0cyB0aGUgYmVoYXZpb3Igb2Ygb3JpZ2luIHJlZmVycmVyIHBvbGljeSB3aGVuIGNy b3NzIG9yaWdpbiBmcm9tIEhUVFBTIHRvIEhUVFAuCiAKIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNl ZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRF Ii4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlt Zy9zYW1lLW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQgYi9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pbWcvc2FtZS1vcmlnaW4vY3Jvc3Mt b3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CmluZGV4IDgzNmJiMDRmYzJiMy4uZWM4MWU5 NTIyNDQ3IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGlj eS1pbWcvc2FtZS1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0Cisr KyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWltZy9zYW1lLW9yaWdp bi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKQEAgLTEsNSArMSwzIEBACi1D T05TT0xFIE1FU1NBR0U6IFRoZSBwYWdlIGF0IGh0dHBzOi8vMTI3LjAuMC4xOjg0NDMvcmVmZXJy ZXItcG9saWN5LWltZy9zYW1lLW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy5odG1sIHdh cyBhbGxvd2VkIHRvIGRpc3BsYXkgaW5zZWN1cmUgY29udGVudCBmcm9tIGh0dHA6Ly9sb2NhbGhv c3Q6ODAwMC9yZWZlcnJlci1wb2xpY3kvcmVzb3VyY2VzL2ltYWdlLnBocD9leHBlY3RlZD0uCi0K IFRlc3RzIHRoZSBiZWhhdmlvciBvZiBzYW1lLW9yaWdpbiByZWZlcnJlciBwb2xpY3kgd2hlbiBj cm9zcyBvcmlnaW4gZnJvbSBIVFRQUyB0byBIVFRQLgogCiBPbiBzdWNjZXNzLCB5b3Ugd2lsbCBz ZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVU RSIuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1p bWcvc3RyaWN0LW9yaWdpbi13aGVuLWNyb3NzLW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRw cy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1p bWcvc3RyaWN0LW9yaWdpbi13aGVuLWNyb3NzLW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRw cy1leHBlY3RlZC50eHQKaW5kZXggYmJkNGY2ZTVlOWQ3Li5hZDEwNjkwMTg0YTcgMTAwNjQ0Ci0t LSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWltZy9zdHJpY3Qtb3Jp Z2luLXdoZW4tY3Jvc3Mtb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4 dAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS1pbWcvc3RyaWN0 LW9yaWdpbi13aGVuLWNyb3NzLW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3Rl ZC50eHQKQEAgLTEsNSArMSwzIEBACi1DT05TT0xFIE1FU1NBR0U6IFRoZSBwYWdlIGF0IGh0dHBz Oi8vMTI3LjAuMC4xOjg0NDMvcmVmZXJyZXItcG9saWN5LWltZy9zdHJpY3Qtb3JpZ2luLXdoZW4t Y3Jvc3Mtb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLmh0bWwgd2FzIGFsbG93ZWQgdG8g ZGlzcGxheSBpbnNlY3VyZSBjb250ZW50IGZyb20gaHR0cDovL2xvY2FsaG9zdDo4MDAwL3JlZmVy cmVyLXBvbGljeS9yZXNvdXJjZXMvaW1hZ2UucGhwP2V4cGVjdGVkPS4KLQogVGVzdHMgdGhlIGJl aGF2aW9yIG9mIHN0cmljdC1vcmlnaW4td2hlbi1jcm9zcy1vcmlnaW4gcmVmZXJyZXIgcG9saWN5 IHdoZW4gY3Jvc3Mgb3JpZ2luIGZyb20gSFRUUFMgdG8gSFRUUC4KIAogT24gc3VjY2VzcywgeW91 IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1Qg Q09NUExFVEUiLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1w b2xpY3ktaW1nL3N0cmljdC1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQu dHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3ktaW1nL3N0cmljdC1v cmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CmluZGV4IDYzNTYyY2I0 MmI0OC4uNWI3OGE3ZTQ3M2I5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Jl ZmVycmVyLXBvbGljeS1pbWcvc3RyaWN0LW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1l eHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3kt aW1nL3N0cmljdC1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CkBA IC0xLDUgKzEsMyBAQAotQ09OU09MRSBNRVNTQUdFOiBUaGUgcGFnZSBhdCBodHRwczovLzEyNy4w LjAuMTo4NDQzL3JlZmVycmVyLXBvbGljeS1pbWcvc3RyaWN0LW9yaWdpbi9jcm9zcy1vcmlnaW4t aHR0cC5odHRwcy5odG1sIHdhcyBhbGxvd2VkIHRvIGRpc3BsYXkgaW5zZWN1cmUgY29udGVudCBm cm9tIGh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC9yZWZlcnJlci1wb2xpY3kvcmVzb3VyY2VzL2ltYWdl LnBocD9leHBlY3RlZD0uCi0KIFRlc3RzIHRoZSBiZWhhdmlvciBvZiBzdHJpY3Qtb3JpZ2luIHJl ZmVycmVyIHBvbGljeSB3aGVuIGNyb3NzIG9yaWdpbiBmcm9tIEhUVFBTIHRvIEhUVFAuCiAKIE9u IHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxv d2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvcmVmZXJyZXItcG9saWN5LWltZy91bnNhZmUtdXJsL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBz LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5LWlt Zy91bnNhZmUtdXJsL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dAppbmRleCAy MTk2YTNlMmI4ZmIuLmIxZjcyYjU3NDU1NSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9yZWZlcnJlci1wb2xpY3ktaW1nL3Vuc2FmZS11cmwvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0 cHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9s aWN5LWltZy91bnNhZmUtdXJsL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dApA QCAtMSw1ICsxLDMgQEAKLUNPTlNPTEUgTUVTU0FHRTogVGhlIHBhZ2UgYXQgaHR0cHM6Ly8xMjcu MC4wLjE6ODQ0My9yZWZlcnJlci1wb2xpY3ktaW1nL3Vuc2FmZS11cmwvY3Jvc3Mtb3JpZ2luLWh0 dHAuaHR0cHMuaHRtbCB3YXMgYWxsb3dlZCB0byBkaXNwbGF5IGluc2VjdXJlIGNvbnRlbnQgZnJv bSBodHRwOi8vbG9jYWxob3N0OjgwMDAvcmVmZXJyZXItcG9saWN5L3Jlc291cmNlcy9pbWFnZS5w aHA/ZXhwZWN0ZWQ9aHR0cHM6Ly8xMjcuMC4wLjE6ODQ0My9yZWZlcnJlci1wb2xpY3ktaW1nL3Vu c2FmZS11cmwvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMuaHRtbC4KLQogVGVzdHMgdGhlIGJlaGF2 aW9yIG9mIHVuc2FmZS11cmwgcmVmZXJyZXIgcG9saWN5IHdoZW4gY3Jvc3Mgb3JpZ2luIGZyb20g SFRUUFMgdG8gSFRUUC4KIAogT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQ QVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3kvbm8tcmVmZXJyZXItd2hlbi1k b3duZ3JhZGUvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3kvbm8tcmVmZXJyZXItd2hlbi1kb3duZ3JhZGUv Y3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CmluZGV4IDVmMmY0MTAzY2ZiNi4u MjU4MTg2NTE1YWQzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVy LXBvbGljeS9uby1yZWZlcnJlci13aGVuLWRvd25ncmFkZS9jcm9zcy1vcmlnaW4taHR0cC5odHRw cy1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xp Y3kvbm8tcmVmZXJyZXItd2hlbi1kb3duZ3JhZGUvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhw ZWN0ZWQudHh0CkBAIC0xLDUgKzEsMyBAQAotQ09OU09MRSBNRVNTQUdFOiBUaGUgcGFnZSBhdCBh Ym91dDpibGFuayB3YXMgYWxsb3dlZCB0byBkaXNwbGF5IGluc2VjdXJlIGNvbnRlbnQgZnJvbSBo dHRwOi8vbG9jYWxob3N0OjgwMDAvcmVmZXJyZXItcG9saWN5L3Jlc291cmNlcy9kb2N1bWVudC5o dG1sLgotCiBUZXN0cyB0aGUgYmVoYXZpb3Igb2Ygbm8tcmVmZXJyZXItd2hlbi1kb3duZ3JhZGUg cmVmZXJyZXIgcG9saWN5IHdoZW4gY3Jvc3Mgb3JpZ2luIGZyb20gSFRUUFMgdG8gSFRUUC4KIAog T24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9s bG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9yZWZlcnJlci1wb2xpY3kvbm8tcmVmZXJyZXIvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMt ZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3kvbm8t cmVmZXJyZXIvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CmluZGV4IGEzMDZk NmM4MTQxZC4uZmRkNDhlZGM2YWE2IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3JlZmVycmVyLXBvbGljeS9uby1yZWZlcnJlci9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBl Y3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3kvbm8t cmVmZXJyZXIvY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0xLDUgKzEs MyBAQAotQ09OU09MRSBNRVNTQUdFOiBUaGUgcGFnZSBhdCBhYm91dDpibGFuayB3YXMgYWxsb3dl ZCB0byBkaXNwbGF5IGluc2VjdXJlIGNvbnRlbnQgZnJvbSBodHRwOi8vbG9jYWxob3N0OjgwMDAv cmVmZXJyZXItcG9saWN5L3Jlc291cmNlcy9kb2N1bWVudC5odG1sLgotCiBUZXN0cyB0aGUgYmVo YXZpb3Igb2Ygbm8tcmVmZXJyZXIgcmVmZXJyZXIgcG9saWN5IHdoZW4gY3Jvc3Mgb3JpZ2luIGZy b20gSFRUUFMgdG8gSFRUUC4KIAogT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9m ICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3kvb3JpZ2luLXdoZW4tY3Jv c3Mtb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5L29yaWdpbi13aGVuLWNyb3NzLW9yaWdpbi9j cm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKaW5kZXggNTlkYjIyMDg5YWI0Li4z MzAwZmJmNGFjNGEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXIt cG9saWN5L29yaWdpbi13aGVuLWNyb3NzLW9yaWdpbi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1l eHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3kv b3JpZ2luLXdoZW4tY3Jvc3Mtb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVk LnR4dApAQCAtMSw1ICsxLDMgQEAKLUNPTlNPTEUgTUVTU0FHRTogVGhlIHBhZ2UgYXQgYWJvdXQ6 Ymxhbmsgd2FzIGFsbG93ZWQgdG8gZGlzcGxheSBpbnNlY3VyZSBjb250ZW50IGZyb20gaHR0cDov L2xvY2FsaG9zdDo4MDAwL3JlZmVycmVyLXBvbGljeS9yZXNvdXJjZXMvZG9jdW1lbnQuaHRtbC4K LQogVGVzdHMgdGhlIGJlaGF2aW9yIG9mIG9yaWdpbi13aGVuLWNyb3NzLW9yaWdpbiByZWZlcnJl ciBwb2xpY3kgd2hlbiBjcm9zcyBvcmlnaW4gZnJvbSBIVFRQUyB0byBIVFRQLgogCiBPbiBzdWNj ZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBi eSAiVEVTVCBDT01QTEVURSIuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Jl ZmVycmVyLXBvbGljeS9vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0 IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3kvb3JpZ2luL2Nyb3NzLW9y aWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dAppbmRleCBmZGQ4YjkyMDdjNDEuLjY0ODYyNjhk N2VmNCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3kv b3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS9vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAu aHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0xLDUgKzEsMyBAQAotQ09OU09MRSBNRVNTQUdFOiBUaGUg cGFnZSBhdCBhYm91dDpibGFuayB3YXMgYWxsb3dlZCB0byBkaXNwbGF5IGluc2VjdXJlIGNvbnRl bnQgZnJvbSBodHRwOi8vbG9jYWxob3N0OjgwMDAvcmVmZXJyZXItcG9saWN5L3Jlc291cmNlcy9k b2N1bWVudC5odG1sLgotCiBUZXN0cyB0aGUgYmVoYXZpb3Igb2Ygb3JpZ2luIHJlZmVycmVyIHBv bGljeSB3aGVuIGNyb3NzIG9yaWdpbiBmcm9tIEhUVFBTIHRvIEhUVFAuCiAKIE9uIHN1Y2Nlc3Ms IHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJU RVNUIENPTVBMRVRFIi4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJy ZXItcG9saWN5L3NhbWUtb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4 dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5L3NhbWUtb3JpZ2luL2Ny b3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dAppbmRleCAxOWE4NWE2NmFiMTEuLmVj ODFlOTUyMjQ0NyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1w b2xpY3kvc2FtZS1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0Cisr KyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5L3NhbWUtb3JpZ2luL2Ny b3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dApAQCAtMSw1ICsxLDMgQEAKLUNPTlNP TEUgTUVTU0FHRTogVGhlIHBhZ2UgYXQgYWJvdXQ6Ymxhbmsgd2FzIGFsbG93ZWQgdG8gZGlzcGxh eSBpbnNlY3VyZSBjb250ZW50IGZyb20gaHR0cDovL2xvY2FsaG9zdDo4MDAwL3JlZmVycmVyLXBv bGljeS9yZXNvdXJjZXMvZG9jdW1lbnQuaHRtbC4KLQogVGVzdHMgdGhlIGJlaGF2aW9yIG9mIHNh bWUtb3JpZ2luIHJlZmVycmVyIHBvbGljeSB3aGVuIGNyb3NzIG9yaWdpbiBmcm9tIEhUVFBTIHRv IEhUVFAuCiAKIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVz c2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvcmVmZXJyZXItcG9saWN5L3N0cmljdC1vcmlnaW4td2hlbi1jcm9zcy1v cmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3kvc3RyaWN0LW9yaWdpbi13aGVuLWNyb3NzLW9yaWdp bi9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKaW5kZXggMjExYjliN2I2Njcw Li5hZDEwNjkwMTg0YTcgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJy ZXItcG9saWN5L3N0cmljdC1vcmlnaW4td2hlbi1jcm9zcy1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0 dHAuaHR0cHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvcmVmZXJy ZXItcG9saWN5L3N0cmljdC1vcmlnaW4td2hlbi1jcm9zcy1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0 dHAuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0xLDUgKzEsMyBAQAotQ09OU09MRSBNRVNTQUdFOiBU aGUgcGFnZSBhdCBhYm91dDpibGFuayB3YXMgYWxsb3dlZCB0byBkaXNwbGF5IGluc2VjdXJlIGNv bnRlbnQgZnJvbSBodHRwOi8vbG9jYWxob3N0OjgwMDAvcmVmZXJyZXItcG9saWN5L3Jlc291cmNl cy9kb2N1bWVudC5odG1sLgotCiBUZXN0cyB0aGUgYmVoYXZpb3Igb2Ygc3RyaWN0LW9yaWdpbi13 aGVuLWNyb3NzLW9yaWdpbiByZWZlcnJlciBwb2xpY3kgd2hlbiBjcm9zcyBvcmlnaW4gZnJvbSBI VFRQUyB0byBIVFRQLgogCiBPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBB U1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS9zdHJpY3Qtb3JpZ2luL2Nyb3Nz LW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv cmVmZXJyZXItcG9saWN5L3N0cmljdC1vcmlnaW4vY3Jvc3Mtb3JpZ2luLWh0dHAuaHR0cHMtZXhw ZWN0ZWQudHh0CmluZGV4IGRkNDAxMDc3MDFlNS4uNWI3OGE3ZTQ3M2I5IDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS9zdHJpY3Qtb3JpZ2luL2Nyb3Nz LW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3JlZmVycmVyLXBvbGljeS9zdHJpY3Qtb3JpZ2luL2Nyb3NzLW9yaWdpbi1odHRwLmh0dHBz LWV4cGVjdGVkLnR4dApAQCAtMSw1ICsxLDMgQEAKLUNPTlNPTEUgTUVTU0FHRTogVGhlIHBhZ2Ug YXQgYWJvdXQ6Ymxhbmsgd2FzIGFsbG93ZWQgdG8gZGlzcGxheSBpbnNlY3VyZSBjb250ZW50IGZy b20gaHR0cDovL2xvY2FsaG9zdDo4MDAwL3JlZmVycmVyLXBvbGljeS9yZXNvdXJjZXMvZG9jdW1l bnQuaHRtbC4KLQogVGVzdHMgdGhlIGJlaGF2aW9yIG9mIHN0cmljdC1vcmlnaW4gcmVmZXJyZXIg cG9saWN5IHdoZW4gY3Jvc3Mgb3JpZ2luIGZyb20gSFRUUFMgdG8gSFRUUC4KIAogT24gc3VjY2Vz cywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkg IlRFU1QgQ09NUExFVEUiLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZl cnJlci1wb2xpY3kvdW5zYWZlLXVybC9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50 eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3JlZmVycmVyLXBvbGljeS91bnNhZmUtdXJsL2Ny b3NzLW9yaWdpbi1odHRwLmh0dHBzLWV4cGVjdGVkLnR4dAppbmRleCAyZDM0YmU3M2NiYzguLjJj ODhlYTcxODgwMSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1w b2xpY3kvdW5zYWZlLXVybC9jcm9zcy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKKysr IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9yZWZlcnJlci1wb2xpY3kvdW5zYWZlLXVybC9jcm9z cy1vcmlnaW4taHR0cC5odHRwcy1leHBlY3RlZC50eHQKQEAgLTEsNSArMSwzIEBACi1DT05TT0xF IE1FU1NBR0U6IFRoZSBwYWdlIGF0IGFib3V0OmJsYW5rIHdhcyBhbGxvd2VkIHRvIGRpc3BsYXkg aW5zZWN1cmUgY29udGVudCBmcm9tIGh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC9yZWZlcnJlci1wb2xp Y3kvcmVzb3VyY2VzL2RvY3VtZW50Lmh0bWwuCi0KIFRlc3RzIHRoZSBiZWhhdmlvciBvZiB1bnNh ZmUtdXJsIHJlZmVycmVyIHBvbGljeSB3aGVuIGNyb3NzIG9yaWdpbiBmcm9tIEhUVFBTIHRvIEhU VFAuCiAKIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2Fn ZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhl ZC1jb250ZW50L2luc2VjdXJlLWNzcy1pbi1pZnJhbWUtcmVwb3J0LW9ubHkuaHRtbCBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFs bC1taXhlZC1jb250ZW50L2luc2VjdXJlLWNzcy1pbi1pZnJhbWUtcmVwb3J0LW9ubHkuaHRtbApp bmRleCBiM2NhNjYwZjBhYTcuLjdmMWZjYzU2ZTA0ZSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVk LWNvbnRlbnQvaW5zZWN1cmUtY3NzLWluLWlmcmFtZS1yZXBvcnQtb25seS5odG1sCisrKyBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2Nr LWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWNzcy1pbi1pZnJhbWUtcmVwb3J0LW9ubHkuaHRt bApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3 ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRk cmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8aGVhZD4KIDxzY3JpcHQ+CmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBv bGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1jc3MtaW4taWZyYW1lLmh0bWwg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9i bG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1jc3MtaW4taWZyYW1lLmh0bWwKaW5kZXgg ODg4ZGZjNjkzNzE4Li5mMGVjOTMwZDc2N2YgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250 ZW50L2luc2VjdXJlLWNzcy1pbi1pZnJhbWUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVu dC9pbnNlY3VyZS1jc3MtaW4taWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUg aHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVu dGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxo dG1sPgogPGhlYWQ+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQv aW5zZWN1cmUtY3NzLWluLW1haW4tZnJhbWUuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv c2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2lu c2VjdXJlLWNzcy1pbi1tYWluLWZyYW1lLmh0bWwKaW5kZXggMWNmOGNlODI5MDVkLi5lMzY0ZWQw ZWQ4MWIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVu dFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWNzcy1pbi1t YWluLWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250 ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtY3NzLWlu LW1haW4tZnJhbWUuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPjwhLS0gd2Vi a2l0LXRlc3QtcnVubmVyIFsgZHVtcEpTQ29uc29sZUxvZ0luU3RkRXJyPXRydWUgXSAtLT4KKzwh RE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZHVtcEpTQ29uc29sZUxvZ0lu U3RkRXJyPXRydWUgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0Vu YWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxv Y2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaWZyYW1lLWluLWlmcmFtZS5odG1sIGIvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2st YWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaWZyYW1lLWluLWlmcmFtZS5odG1sCmluZGV4IDcy Njc5MTMwZDYxYi4uYjk0YmVjNWMzOWQ5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVu dC9pbnNlY3VyZS1pZnJhbWUtaW4taWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRl bnQvaW5zZWN1cmUtaWZyYW1lLWluLWlmcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NU WVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGR1bXBK U0NvbnNvbGVMb2dJblN0ZEVycj10cnVlIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNr SVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxoZWFkPgogPHNjcmlwdD4K ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3Vy aXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWlmcmFtZS1pbi1tYWlu LWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1 cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pZnJhbWUtaW4tbWFp bi1mcmFtZS5odG1sCmluZGV4IDhjMzQ4NGRkNDRhOS4uNzUwM2NjM2VhMTI2IDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9i bG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pZnJhbWUtaW4tbWFpbi1mcmFtZS5odG1s CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9s aWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWlmcmFtZS1pbi1tYWluLWZyYW1l Lmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwh LS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZHVtcEpTQ29uc29sZUxvZ0luU3RkRXJyPXRydWUgZXhw ZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAt LT4KIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNv bnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4tYmxvYi11cmwtaWZyYW1lLWluLWlmcmFtZS5odG1sIGIv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxv Y2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4tYmxvYi11cmwtaWZyYW1lLWlu LWlmcmFtZS5odG1sCmluZGV4IGJkZjdiYjdmZjhkZC4uNGY5ZWFlYWQ3ZjgyIDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9i bG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1ibG9iLXVybC1pZnJhbWUt aW4taWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250 ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2Ut aW4tYmxvYi11cmwtaWZyYW1lLWluLWlmcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NU WVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGR1bXBK U0NvbnNvbGVMb2dJblN0ZEVycj10cnVlIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNr SVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxoZWFkPgogPHNjcmlwdD4K ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3Vy aXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWltYWdlLWluLWlmcmFt ZS13aXRoLWVuZm9yY2VkLWFuZC1yZXBvcnQtcG9saWNpZXMuaHRtbCBiL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1j b250ZW50L2luc2VjdXJlLWltYWdlLWluLWlmcmFtZS13aXRoLWVuZm9yY2VkLWFuZC1yZXBvcnQt cG9saWNpZXMuaHRtbAppbmRleCBkN2E1MDFiNjdhYTYuLmQ5ZTg1YTNhZWJjNyAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kv YmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4taWZyYW1lLXdpdGgtZW5m b3JjZWQtYW5kLXJlcG9ydC1wb2xpY2llcy5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50 L2luc2VjdXJlLWltYWdlLWluLWlmcmFtZS13aXRoLWVuZm9yY2VkLWFuZC1yZXBvcnQtcG9saWNp ZXMuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+ PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFj a0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8aGVhZD4KIDxzY3JpcHQ+ CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1 cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1pZnJh bWUtd2l0aC1pbmhlcml0ZWQtcG9saWN5Lmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Nl Y3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNl Y3VyZS1pbWFnZS1pbi1pZnJhbWUtd2l0aC1pbmhlcml0ZWQtcG9saWN5Lmh0bWwKaW5kZXggMjU2 NTdjOWJjODYwLi42Y2NkMDZjOTQ2NTEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50 L2luc2VjdXJlLWltYWdlLWluLWlmcmFtZS13aXRoLWluaGVyaXRlZC1wb2xpY3kuaHRtbAorKysg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9i bG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1pZnJhbWUtd2l0aC1pbmhl cml0ZWQtcG9saWN5Lmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9D VFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZHVtcEpTQ29uc29sZUxvZ0luU3Rk RXJyPXRydWUgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJs ZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50 LVNlY3VyaXR5LVBvbGljeSIgY29udGVudD0iYmxvY2stYWxsLW1peGVkLWNvbnRlbnQiPgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQ b2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4taWZyYW1lLmh0 bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGlj eS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1pZnJhbWUuaHRtbApp bmRleCBhOWViYjdmZDk5M2IuLmNlMzNhYmMwODFkYSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVk LWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4taWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVk LWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4taWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0IEBACi08 IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsg ZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2Ug XSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVk LWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4tamF2YXNjcmlwdC11cmwtaWZyYW1lLWluLWlmcmFt ZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQ b2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4tamF2YXNjcmlw dC11cmwtaWZyYW1lLWluLWlmcmFtZS5odG1sCmluZGV4IGJiOTUzMDEzNTJlZS4uNWIzNGQxMjE0 M2IxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRT ZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1q YXZhc2NyaXB0LXVybC1pZnJhbWUtaW4taWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNv bnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4tamF2YXNjcmlwdC11cmwtaWZyYW1lLWluLWlmcmFtZS5o dG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0t IHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBB ZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxoZWFkPgogPHNjcmlwdD4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5 UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWltYWdlLWluLW1haW4tZnJh bWUuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5 UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWltYWdlLWluLW1haW4tZnJh bWUuaHRtbAppbmRleCBkMGUwZTg3Mjg0NTAuLjk0MzIyOTg1OTg4MSAxMDA2NDQKLS0tIGEvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2st YWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4tbWFpbi1mcmFtZS5odG1sCisrKyBi L0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Js b2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLWltYWdlLWluLW1haW4tZnJhbWUuaHRtbApA QCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJr aXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVz c2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8aGVhZD4KIDxzY3JpcHQ+CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGlj eS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi14c2x0LWRvY3VtZW50 LWluLWlmcmFtZS13aXRoLWluaGVyaXRlZC1wb2xpY3kuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250 ZW50L2luc2VjdXJlLWltYWdlLWluLXhzbHQtZG9jdW1lbnQtaW4taWZyYW1lLXdpdGgtaW5oZXJp dGVkLXBvbGljeS5odG1sCmluZGV4IDhhYmY3ODQzZThmMS4uZjU3MzUyOTA2NTUyIDEwMDY0NAot LS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGlj eS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi14c2x0LWRvY3VtZW50 LWluLWlmcmFtZS13aXRoLWluaGVyaXRlZC1wb2xpY3kuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQt Y29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi14c2x0LWRvY3VtZW50LWluLWlmcmFtZS13aXRoLWlu aGVyaXRlZC1wb2xpY3kuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFE T0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3 b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8aGVh ZD4KIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2VjdXJpdHktUG9saWN5IiBjb250ZW50PSJi bG9jay1hbGwtbWl4ZWQtY29udGVudCI+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVu dC9pbnNlY3VyZS1wbHVnaW4taW4taWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9p bnNlY3VyZS1wbHVnaW4taW4taWZyYW1lLmh0bWwKaW5kZXggNTk1NWViOGQ1ZTVkLi44ZDUzNmI4 NTVhYmQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVu dFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXBsdWdpbi1p bi1pZnJhbWUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRl bnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1wbHVnaW4t aW4taWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQ RSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5 TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8 c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250 ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtcGx1Z2lu LWluLW1haW4tZnJhbWUuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29u dGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXBsdWdp bi1pbi1tYWluLWZyYW1lLmh0bWwKaW5kZXggZTJmMDZkY2MwMzkyLi5iNzk1ZmM1ZDEyYTQgMTAw NjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5 UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXBsdWdpbi1pbi1tYWluLWZy YW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2Vj dXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtcGx1Z2luLWluLW1h aW4tZnJhbWUuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBF IGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlM b29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8aGVhZD4KIDxz Y3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRl bnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1zY3JpcHQt aW4taWZyYW1lLXdpdGgtaW5oZXJpdGVkLXBvbGljeS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRl bnQvaW5zZWN1cmUtc2NyaXB0LWluLWlmcmFtZS13aXRoLWluaGVyaXRlZC1wb2xpY3kuaHRtbApp bmRleCA0YTQzMDljOTcyZmQuLjIwMjE5MGMxNjY3MiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVk LWNvbnRlbnQvaW5zZWN1cmUtc2NyaXB0LWluLWlmcmFtZS13aXRoLWluaGVyaXRlZC1wb2xpY3ku aHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0 eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4taWZyYW1l LXdpdGgtaW5oZXJpdGVkLXBvbGljeS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0 bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRh bDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRt bD4KIDxoZWFkPgogPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TZWN1cml0eS1Qb2xpY3kiIGNv bnRlbnQ9ImJsb2NrLWFsbC1taXhlZC1jb250ZW50Ij4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhl ZC1jb250ZW50L2luc2VjdXJlLXNjcmlwdC1pbi1pZnJhbWUuaHRtbCBiL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1j b250ZW50L2luc2VjdXJlLXNjcmlwdC1pbi1pZnJhbWUuaHRtbAppbmRleCA3NDNiMmYwMzg0Zjgu LjYyYzc1MzNkOTIzNSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUt c2NyaXB0LWluLWlmcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJp dHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJl LXNjcmlwdC1pbi1pZnJhbWUuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgor PCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1 c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8 aGVhZD4KIDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3Vy aXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3Vy ZS1zY3JpcHQtaW4tbWFpbi1mcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1 cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1 cmUtc2NyaXB0LWluLW1haW4tZnJhbWUuaHRtbAppbmRleCBkOWIwZmFmYzM3ZDYuLjYxODQ4MmUw ZTQxYiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50 U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUtc2NyaXB0LWlu LW1haW4tZnJhbWUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2Nv bnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS1zY3Jp cHQtaW4tbWFpbi1mcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+Cis8 IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVz dHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxo ZWFkPgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJp dHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJl LXhoci1hc3luY2hyb25vdXMtaW4taWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9p bnNlY3VyZS14aHItYXN5bmNocm9ub3VzLWluLWlmcmFtZS5odG1sCmluZGV4IDIzNjE2M2IyNTQz YS4uMWQ3OWU1MzYyYjAwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3Vy aXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3Vy ZS14aHItYXN5bmNocm9ub3VzLWluLWlmcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250 ZW50L2luc2VjdXJlLXhoci1hc3luY2hyb25vdXMtaW4taWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0 IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVu bmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9 ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxs LW1peGVkLWNvbnRlbnQvaW5zZWN1cmUteGhyLWFzeW5jaHJvbm91cy1pbi1tYWluLWZyYW1lLmh0 bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGlj eS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS14aHItYXN5bmNocm9ub3VzLWluLW1h aW4tZnJhbWUuaHRtbAppbmRleCAxZDk2NjQ1YzI3NjguLmMxNGQ0NDBjYjUwZSAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kv YmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUteGhyLWFzeW5jaHJvbm91cy1pbi1tYWlu LWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50 U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5zZWN1cmUteGhyLWFzeW5j aHJvbm91cy1pbi1tYWluLWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRt bD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFs OlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1s PgogPGhlYWQ+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9z ZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvaW5z ZWN1cmUteGhyLXN5bmNocm9ub3VzLWluLWlmcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRl bnQvaW5zZWN1cmUteGhyLXN5bmNocm9ub3VzLWluLWlmcmFtZS5odG1sCmluZGV4IGM1NDczMGQ2 OGIzOC4uMWUyOTBhZTU2NjMwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Nl Y3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNl Y3VyZS14aHItc3luY2hyb25vdXMtaW4taWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNv bnRlbnQvaW5zZWN1cmUteGhyLXN5bmNocm9ub3VzLWluLWlmcmFtZS5odG1sCkBAIC0xLDQgKzEs NCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1 bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVk PWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxoZWFkPgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L2Jsb2NrLWFs bC1taXhlZC1jb250ZW50L2luc2VjdXJlLXhoci1zeW5jaHJvbm91cy1pbi1tYWluLWZyYW1lLmh0 bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGlj eS9ibG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS14aHItc3luY2hyb25vdXMtaW4tbWFp bi1mcmFtZS5odG1sCmluZGV4IDM2NGU0NWQ0MzlmMi4uY2YxZTcyZjE3MGUwIDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9i bG9jay1hbGwtbWl4ZWQtY29udGVudC9pbnNlY3VyZS14aHItc3luY2hyb25vdXMtaW4tbWFpbi1m cmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNl Y3VyaXR5UG9saWN5L2Jsb2NrLWFsbC1taXhlZC1jb250ZW50L2luc2VjdXJlLXhoci1zeW5jaHJv bm91cy1pbi1tYWluLWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4K KzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRy dXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgog PGhlYWQ+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1 cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvcmVzb3Vy Y2VzL2ZyYW1lLXdpdGgtaW5zZWN1cmUtaWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ibG9jay1hbGwtbWl4ZWQtY29udGVu dC9yZXNvdXJjZXMvZnJhbWUtd2l0aC1pbnNlY3VyZS1pZnJhbWUuaHRtbAppbmRleCA1Y2Y4NDNl YmE5YTEuLjg1OTViMTA4MTZjMyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9z ZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVkLWNvbnRlbnQvcmVz b3VyY2VzL2ZyYW1lLXdpdGgtaW5zZWN1cmUtaWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvYmxvY2stYWxsLW1peGVk LWNvbnRlbnQvcmVzb3VyY2VzL2ZyYW1lLXdpdGgtaW5zZWN1cmUtaWZyYW1lLmh0bWwKQEAgLTEs NCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRl c3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0Vu YWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGhlYWQ+CiA8bWV0YSBodHRwLWVxdWl2PSJDb250 ZW50LVNlY3VyaXR5LVBvbGljeSIgY29udGVudD0iYmxvY2stYWxsLW1peGVkLWNvbnRlbnQiPgpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJp dHlQb2xpY3kvdXBncmFkZS1pbnNlY3VyZS1yZXF1ZXN0cy9pZnJhbWUtdXBncmFkZS5odHRwcy1l eHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1 cml0eVBvbGljeS91cGdyYWRlLWluc2VjdXJlLXJlcXVlc3RzL2lmcmFtZS11cGdyYWRlLmh0dHBz LWV4cGVjdGVkLnR4dAppbmRleCA1NjQ0MDE0YTdhYTMuLjQxYmExMmJjN2NmNCAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kv dXBncmFkZS1pbnNlY3VyZS1yZXF1ZXN0cy9pZnJhbWUtdXBncmFkZS5odHRwcy1leHBlY3RlZC50 eHQKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQ b2xpY3kvdXBncmFkZS1pbnNlY3VyZS1yZXF1ZXN0cy9pZnJhbWUtdXBncmFkZS5odHRwcy1leHBl Y3RlZC50eHQKQEAgLTEsNSArMSwzIEBACi1DT05TT0xFIE1FU1NBR0U6IFRoZSBwYWdlIGF0IGFi b3V0OnNyY2RvYyB3YXMgYWxsb3dlZCB0byBkaXNwbGF5IGluc2VjdXJlIGNvbnRlbnQgZnJvbSBo dHRwOi8vbG9jYWxob3N0OjgwMDAvc2VjdXJpdHkvcmVzb3VyY2VzL3Bvc3Qtb3JpZ2luLXRvLXBh cmVudC5odG1sLgotCiAKIAogUEFTUyBTYW1lLWhvc3QgZnJhbWVzIGFyZSB1cGdyYWRlZC4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5 UG9saWN5L3VwZ3JhZGUtaW5zZWN1cmUtcmVxdWVzdHMvcHJvcGVyLW9wZW4td2luZG93LXVwZ3Jh ZGVzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvY29udGVu dFNlY3VyaXR5UG9saWN5L3VwZ3JhZGUtaW5zZWN1cmUtcmVxdWVzdHMvcHJvcGVyLW9wZW4td2lu ZG93LXVwZ3JhZGVzLWV4cGVjdGVkLnR4dAppbmRleCBkZTJkZDljZDVmZTcuLmI2Y2ZlMzNjZDQx YiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2Vj dXJpdHlQb2xpY3kvdXBncmFkZS1pbnNlY3VyZS1yZXF1ZXN0cy9wcm9wZXItb3Blbi13aW5kb3ct dXBncmFkZXMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJp dHkvY29udGVudFNlY3VyaXR5UG9saWN5L3VwZ3JhZGUtaW5zZWN1cmUtcmVxdWVzdHMvcHJvcGVy LW9wZW4td2luZG93LXVwZ3JhZGVzLWV4cGVjdGVkLnR4dApAQCAtMSw3ICsxLDUgQEAKIEFMRVJU OiBQQVNTCiBBTEVSVDogUEFTUwotQ09OU09MRSBNRVNTQUdFOiBbYmxvY2tlZF0gVGhlIHBhZ2Ug YXQgaHR0cHM6Ly8xMjcuMC4wLjE6ODQ0My9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kv dXBncmFkZS1pbnNlY3VyZS1yZXF1ZXN0cy9yZXNvdXJjZXMvbmVzdGVkLW5lc3RlZC13aW5kb3cu aHRtbCB3YXMgbm90IGFsbG93ZWQgdG8gcnVuIGluc2VjdXJlIGNvbnRlbnQgZnJvbSBodHRwOi8v bG9jYWxob3N0Ojg0NDMvc2VjdXJpdHkvY29udGVudFNlY3VyaXR5UG9saWN5L3Jlc291cmNlcy9h bGVydC1wYXNzLmpzLgotCiBUaGlzIHRlc3QgY2F1c2VzIGEgbmV3IHdpbmRvdyB0byBvcGVuIHBl cmZvcm1pbmcgYSBzZWN1cmUgbmF2aWdhdGlvbiB0byBhIGRvY3VtZW50IHdpdGggdGhlICd1cGdy YWRlLWluc2VjdXJlLXJlcXVlc3RzJyBoZWFkZXIuIFRoZSBzZWN1cmUgZG9jdW1lbnQgaGFzIGFu IGluc2VjdXJlIHNjcmlwdCByZWZlcmVuY2UsIHdoaWNoIHdpbGwgZ2V0IHVwZ3JhZGVkLiBUaGUg c2VjdXJlIGRvY3VtZW50IGRvZXMgYW4gaW5zZWN1cmUgbmF2aWdhdGlvbiB0byBhIG5ldyB3aW5k b3cuIFRoaXMgbmV3IG5hdmlnYXRpb24gc2hvdWxkIG5vdCBiZSB1cGdyYWRlZC4KIAogVGhlIG5l dyBkb2N1bWVudCBkb2VzIGFuIGluc2VjdXJlIG5hdmlnYXRpb24gdG8gYSBob3N0IHdlIGhhdmUg dmlzaXRlZCBiZWZvcmUuIFRoaXMgbmF2aWdhdGlvbiBzaG91bGQgYmUgdXBncmFkZWQsIGV2ZW4g dGhvdWdoIHRoZSBzaXRlIGRvZXMgbm90IGhhdmUgdGhlICd1cGRhdGUtaW5zZWN1cmUtcmVxdWVz dHMnIGhlYWRlci4gVGhlIG5ldyBkb2N1bWVudCBhbHNvIGRvZXMgYW4gaW5zZWN1cmUgbmF2aWdh dGlvbiB0byBhIHNlY29uZCBkb21haW4sIHdoaWNoIGhhcyBub3QgYmVlbiB1cGdyYWRlZCBiZWZv cmUuIFRoaXMgbmF2aWdhdGlvbiBzaG91bGQgbm90IGJlIHVwZ3JhZGVkLCBhbmQgd2lsbCBmYWls IChpbiB0aGlzIHRlc3QpIGJlY2F1c2Ugd2Ugb25seSBwcm92aWRlIHRoZSByZXNvdXJjZSB0byBs b2FkIHVuZGVyIHRoZSBIVFRQUyBzZXJ2ZXIuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbXBvcnQtaW5zZWN1cmUtc2NyaXB0LWluLWlm cmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQv aW1wb3J0LWluc2VjdXJlLXNjcmlwdC1pbi1pZnJhbWUuaHRtbAppbmRleCA3Njk0OGU4YWIzOWIu LmYwNGYzMTc2YTFiMyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9taXhlZENvbnRlbnQvaW1wb3J0LWluc2VjdXJlLXNjcmlwdC1pbi1pZnJhbWUuaHRtbAorKysg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbXBvcnQtaW5z ZWN1cmUtc2NyaXB0LWluLWlmcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRt bD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3Bi YWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQgc3JjPSIu Li8uLi9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgogPHNjcmlwdD4KZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2Vj dXJlLWJhc2ljLWF1dGgtaW1hZ2UuaHR0cHMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtYmFzaWMtYXV0aC1pbWFnZS5o dHRwcy1leHBlY3RlZC50eHQKaW5kZXggODZhYWFlMmMwZTk1Li4wOGM3YjFhNGUxOGMgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2Vj dXJlLWJhc2ljLWF1dGgtaW1hZ2UuaHR0cHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWJhc2ljLWF1dGgtaW1h Z2UuaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0xLDUgKzEsMyBAQAotQ09OU09MRSBNRVNTQUdFOiBU aGUgcGFnZSBhdCBodHRwczovLzEyNy4wLjAuMTo4NDQzL3NlY3VyaXR5L21peGVkQ29udGVudC9p bnNlY3VyZS1iYXNpYy1hdXRoLWltYWdlLmh0dHBzLmh0bWwgd2FzIGFsbG93ZWQgdG8gZGlzcGxh eSBpbnNlY3VyZSBjb250ZW50IGZyb20gaHR0cDovL2xvY2FsaG9zdDo4MDAwL3NlY3VyaXR5L21p eGVkQ29udGVudC9yZXNvdXJjZXMvc3VicmVzb3VyY2UyL3Byb3RlY3RlZC1pbWFnZS5waHAuCi0K IENPTlNPTEUgTUVTU0FHRTogQmxvY2tlZCBodHRwOi8vbG9jYWxob3N0OjgwMDAvc2VjdXJpdHkv bWl4ZWRDb250ZW50L3Jlc291cmNlcy9zdWJyZXNvdXJjZTIvcHJvdGVjdGVkLWltYWdlLnBocCBm cm9tIGFza2luZyBmb3IgY3JlZGVudGlhbHMgYmVjYXVzZSBpdCBpcyBhIGNyb3NzLW9yaWdpbiBy ZXF1ZXN0LgogVGVzdHMgdGhhdCB3ZSBkbyBub3QgYXNrIGZvciBjcmVkZW50aWFscyB3aGVuIGxv YWRpbmcgYW4gaW5zZWN1cmUgaW1hZ2UgdGhhdCByZXF1aXJlcyBiYXNpYyBhdXRoZW50aWNhdGlv bi4KIApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENv bnRlbnQvaW5zZWN1cmUtY3NzLWluLWlmcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtY3NzLWluLWlmcmFtZS5odG1sCmluZGV4 IDc4YjlmNjFhY2U3Yy4uYWIxZDUzYzAzOWI4IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1jc3MtaW4taWZyYW1lLmh0bWwK KysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1 cmUtY3NzLWluLWlmcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0t IHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBB ZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93 LnRlc3RSdW5uZXIpIHsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJp dHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWNzcy1pbi1tYWluLWZyYW1lLmh0bWwgYi9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1jc3MtaW4tbWFp bi1mcmFtZS5odG1sCmluZGV4IDhkNzdjODY4NDlhYy4uNzJjY2YxY2NiMTQ4IDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1j c3MtaW4tbWFpbi1mcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJp dHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWNzcy1pbi1tYWluLWZyYW1lLmh0bWwKQEAgLTEsNCAr MSw0IEBACi08aHRtbD4KKzxodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVu dGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxi b2R5PgogPHNjcmlwdD4KIGlmICh3aW5kb3cudGVzdFJ1bm5lcikgewpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtZXhlY3V0 YWJsZS1jc3Mtd2l0aC1zZWN1cmUtY29va2llcy5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtZXhlY3V0YWJsZS1jc3Mtd2l0aC1zZWN1 cmUtY29va2llcy5odG1sCmluZGV4IDQxMTNkMjM5YWM4OS4uMzkwYTU5OTdhZTBlIDEwMDY0NAot LS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3Vy ZS1leGVjdXRhYmxlLWNzcy13aXRoLXNlY3VyZS1jb29raWVzLmh0bWwKKysrIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtZXhlY3V0YWJsZS1j c3Mtd2l0aC1zZWN1cmUtY29va2llcy5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIGh0 bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRh bDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRt bD4KIDxib2R5PgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv c2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWZvcm0taW4tbWFpbi1mcmFtZS5odG1sIGIv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtZm9y bS1pbi1tYWluLWZyYW1lLmh0bWwKaW5kZXggMDU3ZDVkMDU1ODY1Li5hMTc5Y2JmOTI4NzMgMTAw NjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2lu c2VjdXJlLWZvcm0taW4tbWFpbi1mcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWZvcm0taW4tbWFpbi1mcmFtZS5odG1s CkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBb IGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNl IF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRlc3RSdW5uZXIpIHsKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2Vj dXJlLWlmcmFtZS1pbi1tYWluLWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Nl Y3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1pZnJhbWUtaW4tbWFpbi1mcmFtZS5odG1sCmlu ZGV4IDhhYjgxZTIyM2YyMS4uZGMwNjVhMmFjZGI4IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1pZnJhbWUtaW4tbWFpbi1m cmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250 ZW50L2luc2VjdXJlLWlmcmFtZS1pbi1tYWluLWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0IEBACi08 aHRtbD4KKzxodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0 d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxib2R5PgogPHNj cmlwdD4KIGlmICh3aW5kb3cudGVzdFJ1bm5lcikgewpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4tbWFpbi1m cmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQv aW5zZWN1cmUtaW1hZ2UtaW4tbWFpbi1mcmFtZS5odG1sCmluZGV4IDcwM2VhYzg2NzZlZS4uNDQw NWJhN2QwZWFjIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21p eGVkQ29udGVudC9pbnNlY3VyZS1pbWFnZS1pbi1tYWluLWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtaW4t bWFpbi1mcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdlYmtp dC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNz ZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRlc3RS dW5uZXIpIHsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4 ZWRDb250ZW50L2luc2VjdXJlLWltYWdlLXJlZGlyZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1p bWFnZS1hbGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odG1s IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUt aW1hZ2UtcmVkaXJlY3RzLXRvLWJhc2ljLWF1dGgtc2VjdXJlLWltYWdlLWFsbG93Q3Jvc3NPcmln aW5TdWJyZXNvdXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzLmh0bWwKaW5kZXggYjc4ZTY1ZDQyMTVh Li45MWUyMTU5ZmQyY2MgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJp dHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWltYWdlLXJlZGlyZWN0cy10by1iYXNpYy1hdXRoLXNl Y3VyZS1pbWFnZS1hbGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFs cy5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50 L2luc2VjdXJlLWltYWdlLXJlZGlyZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1pbWFnZS1hbGxv d0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odG1sCkBAIC0xLDQg KzEsNCBAQAotPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBBbGxvd0Ny b3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscz10cnVlIF0gLS0+Cis8IURP Q1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIEFsbG93Q3Jvc3NPcmlnaW5TdWJy ZXNvdXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzPXRydWUgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5 TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGJvZHk+CiA8 c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhl ZENvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtcmVkaXJlY3RzLXRvLWJhc2ljLWF1dGgtc2VjdXJlLWlt YWdlLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9p bnNlY3VyZS1pbWFnZS1yZWRpcmVjdHMtdG8tYmFzaWMtYXV0aC1zZWN1cmUtaW1hZ2UuaHRtbApp bmRleCBlNjllYjIyMmNiYjYuLjZkNzczY2M2ZDcxOCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtcmVkaXJlY3Rz LXRvLWJhc2ljLWF1dGgtc2VjdXJlLWltYWdlLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtaW1hZ2UtcmVkaXJlY3RzLXRvLWJh c2ljLWF1dGgtc2VjdXJlLWltYWdlLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRt bD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFs OlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1s PgogPGJvZHk+CiA8c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9z ZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtaW1hZ2Utd2l0aC1zZWN1cmVjb29raWUtYmxv Y2suaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2lu c2VjdXJlLWltYWdlLXdpdGgtc2VjdXJlY29va2llLWJsb2NrLmh0bWwKaW5kZXggYTVmMjAxNzQy NmY0Li45YjJmNTRlNjE1MTcgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2Vj dXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWltYWdlLXdpdGgtc2VjdXJlY29va2llLWJsb2Nr Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQv aW5zZWN1cmUtaW1hZ2Utd2l0aC1zZWN1cmVjb29raWUtYmxvY2suaHRtbApAQCAtMSw0ICsxLDQg QEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5u ZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1m YWxzZSBdIC0tPgogPGh0bWw+CiA8Ym9keT4KIDxzY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1pbWFnZS13aXRo LXNlY3VyZWNvb2tpZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhl ZENvbnRlbnQvaW5zZWN1cmUtaW1hZ2Utd2l0aC1zZWN1cmVjb29raWUuaHRtbAppbmRleCAwMGRi MjdkMTk4ZDQuLmUzOWQwYzYzOTgzZiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtaW1hZ2Utd2l0aC1zZWN1cmVjb29raWUu aHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9p bnNlY3VyZS1pbWFnZS13aXRoLXNlY3VyZWNvb2tpZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFE T0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4 cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0g LS0+CiA8aHRtbD4KIDxib2R5PgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXBsdWdpbi1pbi1pZnJhbWUu aHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2Vj dXJlLXBsdWdpbi1pbi1pZnJhbWUuaHRtbAppbmRleCBmNzUyMGI2ZmU1YzguLmZlOWU1YzE5N2I4 ZiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRl bnQvaW5zZWN1cmUtcGx1Z2luLWluLWlmcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXBsdWdpbi1pbi1pZnJhbWUuaHRt bApAQCAtMSw0ICsxLDQgQEAKLTxodG1sPgorPGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIg WyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxz ZSBdIC0tPgogPGJvZHk+CiA8c2NyaXB0PgogaWYgKHdpbmRvdy50ZXN0UnVubmVyKQpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1 cmUtc2NyaXB0LWluLWRhdGEtaWZyYW1lLWluLW1haW4tZnJhbWUtYmxvY2tlZC5odG1sIGIvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtc2NyaXB0 LWluLWRhdGEtaWZyYW1lLWluLW1haW4tZnJhbWUtYmxvY2tlZC5odG1sCmluZGV4IGE2YWY5Njlk NmI4ZC4uNmRjNjFmYTIwNGRhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Nl Y3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4tZGF0YS1pZnJhbWUtaW4tbWFp bi1mcmFtZS1ibG9ja2VkLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtc2NyaXB0LWluLWRhdGEtaWZyYW1lLWluLW1haW4tZnJh bWUtYmxvY2tlZC5odG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdlYmtp dC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNz ZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRlc3RS dW5uZXIgJiYgd2luZG93LmludGVybmFscykgewpAQCAtMjEsNCArMjEsNCBAQCBkYXRhOiBmcmFt ZSBoYXMgYSBzZXBhcmF0ZSBvcmlnaW4sIHRoZSBzY3JpcHQgY2FuIHN0aWxsIG5hdmlnYXRlIHRv cC4KIHdpbmRvdy5vcGVuKCJodHRwczovLzEyNy4wLjAuMTo4NDQzL3NlY3VyaXR5L21peGVkQ29u dGVudC9yZXNvdXJjZXMvZnJhbWUtd2l0aC1kYXRhLXVybC1mcmFtZS13aXRoLXNjcmlwdC5odG1s Iik7CiA8L3NjcmlwdD4KIDwvYm9keT4KLTwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBm aWxlCis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5 L21peGVkQ29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4taWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4taWZy YW1lLmh0bWwKaW5kZXggNDgxODIzNzc4YzNjLi5kZWQwNjdjNTE4MmMgMTAwNjQ0Ci0tLSBhL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXNjcmlw dC1pbi1pZnJhbWUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21p eGVkQ29udGVudC9pbnNlY3VyZS1zY3JpcHQtaW4taWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0IEBA Ci08aHRtbD4KKzxodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRy dXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxib2R5Pgog PHNjcmlwdD4KIGlmICh3aW5kb3cudGVzdFJ1bm5lcikKZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXNjcmlwdC1yZWRpcmVj dHMtdG8tYmFzaWMtYXV0aC1zZWN1cmUtc2NyaXB0Lmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS1zY3JpcHQtcmVkaXJlY3RzLXRvLWJh c2ljLWF1dGgtc2VjdXJlLXNjcmlwdC5odG1sCmluZGV4IDIxMWJhOWY1ZGNlOC4uMTVkNjNmYmM5 YzdmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29u dGVudC9pbnNlY3VyZS1zY3JpcHQtcmVkaXJlY3RzLXRvLWJhc2ljLWF1dGgtc2VjdXJlLXNjcmlw dC5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50 L2luc2VjdXJlLXNjcmlwdC1yZWRpcmVjdHMtdG8tYmFzaWMtYXV0aC1zZWN1cmUtc2NyaXB0Lmh0 bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0g d2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFk ZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGJvZHk+CiA8c2NyaXB0PgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5z ZWN1cmUtc2NyaXB0LXdpdGgtc2VjdXJlLWNvb2tpZXMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXNjcmlwdC13aXRoLXNlY3VyZS1j b29raWVzLmh0bWwKaW5kZXggOTExZGY0YTU0ZWFmLi5hYTI4MDAxOTU0NDkgMTAwNjQ0Ci0tLSBh L0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXNj cmlwdC13aXRoLXNlY3VyZS1jb29raWVzLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1cmUtc2NyaXB0LXdpdGgtc2VjdXJlLWNvb2tp ZXMuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQRSBodG1sPgorPCFET0NUWVBFIGh0bWw+ PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFj a0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGh0bWw+CiA8Ym9keT4KIDxzY3JpcHQ+ CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVu dC9pbnNlY3VyZS1zdHlsZXNoZWV0LXJlZGlyZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1zdHls ZXNoZWV0Lmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVu dC9pbnNlY3VyZS1zdHlsZXNoZWV0LXJlZGlyZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1zdHls ZXNoZWV0Lmh0bWwKaW5kZXggM2ZhNzEzMmQ0ODMzLi5hOTZkNTFjZGIwYTMgMTAwNjQ0Ci0tLSBh L0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXN0 eWxlc2hlZXQtcmVkaXJlY3RzLXRvLWJhc2ljLWF1dGgtc2VjdXJlLXN0eWxlc2hlZXQuaHRtbAor KysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3Vy ZS1zdHlsZXNoZWV0LXJlZGlyZWN0cy10by1iYXNpYy1hdXRoLXNlY3VyZS1zdHlsZXNoZWV0Lmh0 bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0g d2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFk ZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGJvZHk+CiA8c2NyaXB0PgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5z ZWN1cmUteGhyLWluLW1haW4tZnJhbWUuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2Vj dXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXhoci1pbi1tYWluLWZyYW1lLmh0bWwKaW5kZXgg NjYyMWFjMGFhMjUwLi44Njc4MTY3ODliMGYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLXhoci1pbi1tYWluLWZyYW1lLmh0 bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5z ZWN1cmUteGhyLWluLW1haW4tZnJhbWUuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTxodG1sPgorPGh0 bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29w YmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgogPGJvZHk+CiA8c2NyaXB0PgogaWYg KHdpbmRvdy50ZXN0UnVubmVyKSB7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS14aHItc3luYy1pbi1tYWluLWZyYW1lLmh0 bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3Vy ZS14aHItc3luYy1pbi1tYWluLWZyYW1lLmh0bWwKaW5kZXggN2NmMzk0YTBjMzcyLi5iN2RjZjM0 MmUxMzUgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRD b250ZW50L2luc2VjdXJlLXhoci1zeW5jLWluLW1haW4tZnJhbWUuaHRtbAorKysgYi9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3VyZS14aHItc3luYy1p bi1tYWluLWZyYW1lLmh0bWwKQEAgLTEsNCArMSw0IEBACi08aHRtbD4KKzxodG1sPjwhLS0gd2Vi a2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJl c3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxib2R5PgogPHNjcmlwdD4KIGlmICh3aW5kb3cudGVz dFJ1bm5lcikgewpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9t aXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cC10by1odHRwcy1pZnJhbWUtaW4tbWFpbi1mcmFtZS5o dG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJl Y3QtaHR0cC10by1odHRwcy1pZnJhbWUtaW4tbWFpbi1mcmFtZS5odG1sCmluZGV4IDYzNzdkNTUy YmZhZi4uMWNkY2UzZDg4MGYzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3Nl Y3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVjdC1odHRwLXRvLWh0dHBzLWlmcmFtZS1pbi1tYWlu LWZyYW1lLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENv bnRlbnQvcmVkaXJlY3QtaHR0cC10by1odHRwcy1pZnJhbWUtaW4tbWFpbi1mcmFtZS5odG1sCkBA IC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4 cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0g LS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRlc3RSdW5uZXIpIHsKZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0 LWh0dHAtdG8taHR0cHMtc2NyaXB0LWluLWlmcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cC10by1odHRwcy1zY3JpcHQt aW4taWZyYW1lLmh0bWwKaW5kZXggOGM3YjZjNTZlZTVjLi4yMzQxMzg3ODgwNjcgMTAwNjQ0Ci0t LSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0 LWh0dHAtdG8taHR0cHMtc2NyaXB0LWluLWlmcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHAtdG8taHR0cHMtc2Ny aXB0LWluLWlmcmFtZS5odG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdl YmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRy ZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRl c3RSdW5uZXIpIHsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkv bWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHBzLXRvLWh0dHAtaWZyYW1lLWluLW1haW4tZnJhbWUu aHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGly ZWN0LWh0dHBzLXRvLWh0dHAtaWZyYW1lLWluLW1haW4tZnJhbWUuaHRtbAppbmRleCA5OTM0NjRm OGNhNjQuLjhiYWVmNDhjNmM4NyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9z ZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cHMtdG8taHR0cC1pZnJhbWUtaW4tbWFp bi1mcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRD b250ZW50L3JlZGlyZWN0LWh0dHBzLXRvLWh0dHAtaWZyYW1lLWluLW1haW4tZnJhbWUuaHRtbApA QCAtMSw0ICsxLDQgQEAKLTxodG1sPgorPGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBl eHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBd IC0tPgogPGJvZHk+CiA8c2NyaXB0PgogaWYgKHdpbmRvdy50ZXN0UnVubmVyKSB7CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVj dC1odHRwcy10by1odHRwLWltYWdlLXNlY3VyZS1jb29raWVzLWJsb2NrLmh0bWwgYi9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9yZWRpcmVjdC1odHRwcy10by1o dHRwLWltYWdlLXNlY3VyZS1jb29raWVzLWJsb2NrLmh0bWwKaW5kZXggODE0ZjY4YmE5MzkzLi4x ZTRiNjJjMDE4ZjUgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkv bWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHBzLXRvLWh0dHAtaW1hZ2Utc2VjdXJlLWNvb2tpZXMt YmxvY2suaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29u dGVudC9yZWRpcmVjdC1odHRwcy10by1odHRwLWltYWdlLXNlY3VyZS1jb29raWVzLWJsb2NrLmh0 bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZUEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0g d2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJpbWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFk ZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGJvZHk+CiA8c2NyaXB0PgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVk aXJlY3QtaHR0cHMtdG8taHR0cC1pbWFnZS1zZWN1cmUtY29va2llcy5odG1sIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cHMtdG8taHR0 cC1pbWFnZS1zZWN1cmUtY29va2llcy5odG1sCmluZGV4IGNkYTgwMmQwMzBhOS4uMDU5MTdjODYy ODQ5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29u dGVudC9yZWRpcmVjdC1odHRwcy10by1odHRwLWltYWdlLXNlY3VyZS1jb29raWVzLmh0bWwKKysr IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVkaXJlY3Qt aHR0cHMtdG8taHR0cC1pbWFnZS1zZWN1cmUtY29va2llcy5odG1sCkBAIC0xLDQgKzEsNCBAQAot PCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBb IGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNl IF0gLS0+CiA8aHRtbD4KIDxib2R5PgogPHNjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHBzLXRvLWh0dHAt c2NyaXB0LWluLWlmcmFtZS5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9t aXhlZENvbnRlbnQvcmVkaXJlY3QtaHR0cHMtdG8taHR0cC1zY3JpcHQtaW4taWZyYW1lLmh0bWwK aW5kZXggYWEyYWNjZTc5OTE3Li40YmVkZjVlNDhlZWIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHBzLXRvLWh0dHAt c2NyaXB0LWluLWlmcmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJp dHkvbWl4ZWRDb250ZW50L3JlZGlyZWN0LWh0dHBzLXRvLWh0dHAtc2NyaXB0LWluLWlmcmFtZS5o dG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5l ciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZh bHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRlc3RSdW5uZXIpIHsKZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3Nl Y3VyZS1yZWRpcmVjdC10by1pbnNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRoLXNlY3VyZS1p bWFnZS1hbGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odHRw cy5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvc2Vj dXJlLXJlZGlyZWN0LXRvLWluc2VjdXJlLXJlZGlyZWN0LXRvLWJhc2ljLWF1dGgtc2VjdXJlLWlt YWdlLWFsbG93Q3Jvc3NPcmlnaW5TdWJyZXNvdXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzLmh0dHBz Lmh0bWwKaW5kZXggZjdkZTY2OWI2ZWNmLi42OWFkNTM3OWEwOTMgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3NlY3VyZS1yZWRpcmVjdC10 by1pbnNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRoLXNlY3VyZS1pbWFnZS1hbGxvd0Nyb3Nz T3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odHRwcy5odG1sCisrKyBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3NlY3VyZS1yZWRpcmVj dC10by1pbnNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRoLXNlY3VyZS1pbWFnZS1hbGxvd0Ny b3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscy5odHRwcy5odG1sCkBAIC0x LDQgKzEsNCBAQAotPCFET0NUWVBFIGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBBbGxv d0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JDcmVkZW50aWFscz10cnVlIF0gLS0+Cis8 IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIEFsbG93Q3Jvc3NPcmlnaW5T dWJyZXNvdXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzPXRydWUgZXhwZXJpbWVudGFsOlRydXN0d29y dGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4KIDxodG1sPgogPGJvZHk+ CiA8c2NyaXB0IHNyYz0iL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3QuanMiPjwvc2NyaXB0Pgpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQv c2VjdXJlLXJlZGlyZWN0LXRvLWluc2VjdXJlLXJlZGlyZWN0LXRvLWJhc2ljLWF1dGgtc2VjdXJl LWltYWdlLmh0dHBzLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVk Q29udGVudC9zZWN1cmUtcmVkaXJlY3QtdG8taW5zZWN1cmUtcmVkaXJlY3QtdG8tYmFzaWMtYXV0 aC1zZWN1cmUtaW1hZ2UuaHR0cHMuaHRtbAppbmRleCBlY2I2OWYzYWNkZjAuLjAzYTZiNzJkOGIz ZCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRl bnQvc2VjdXJlLXJlZGlyZWN0LXRvLWluc2VjdXJlLXJlZGlyZWN0LXRvLWJhc2ljLWF1dGgtc2Vj dXJlLWltYWdlLmh0dHBzLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9taXhlZENvbnRlbnQvc2VjdXJlLXJlZGlyZWN0LXRvLWluc2VjdXJlLXJlZGlyZWN0LXRvLWJh c2ljLWF1dGgtc2VjdXJlLWltYWdlLmh0dHBzLmh0bWwKQEAgLTEsNCArMSw0IEBACi08IURPQ1RZ UEUgaHRtbD4KKzwhRE9DVFlQRSBodG1sPjwhLS0gd2Via2l0LXRlc3QtcnVubmVyIFsgZXhwZXJp bWVudGFsOlRydXN0d29ydGh5TG9vcGJhY2tJUEFkZHJlc3Nlc0VuYWJsZWQ9ZmFsc2UgXSAtLT4K IDxodG1sPgogPGJvZHk+CiA8c2NyaXB0IHNyYz0iL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3Qu anMiPjwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0 eS9taXhlZENvbnRlbnQvc2VjdXJlLXJlZGlyZWN0LXRvLXNlY3VyZS1yZWRpcmVjdC10by1iYXNp Yy1hdXRoLWluc2VjdXJlLWltYWdlLmh0dHBzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3NlY3VyZS1yZWRpcmVjdC10by1zZWN1cmUt cmVkaXJlY3QtdG8tYmFzaWMtYXV0aC1pbnNlY3VyZS1pbWFnZS5odHRwcy1leHBlY3RlZC50eHQK aW5kZXggOTRjZjcxYTk2NWZiLi4yMmRmYWQ1ZDZjMzAgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3NlY3VyZS1yZWRpcmVjdC10by1zZWN1 cmUtcmVkaXJlY3QtdG8tYmFzaWMtYXV0aC1pbnNlY3VyZS1pbWFnZS5odHRwcy1leHBlY3RlZC50 eHQKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvc2Vj dXJlLXJlZGlyZWN0LXRvLXNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRoLWluc2VjdXJlLWlt YWdlLmh0dHBzLWV4cGVjdGVkLnR4dApAQCAtMSw1ICsxLDMgQEAKLUNPTlNPTEUgTUVTU0FHRTog VGhlIHBhZ2UgYXQgaHR0cHM6Ly8xMjcuMC4wLjE6ODQ0My9zZWN1cml0eS9taXhlZENvbnRlbnQv c2VjdXJlLXJlZGlyZWN0LXRvLXNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRoLWluc2VjdXJl LWltYWdlLmh0dHBzLmh0bWwgd2FzIGFsbG93ZWQgdG8gZGlzcGxheSBpbnNlY3VyZSBjb250ZW50 IGZyb20gaHR0cDovL2xvY2FsaG9zdDo4MDgwL3NlY3VyaXR5L21peGVkQ29udGVudC9yZXNvdXJj ZXMvc3VicmVzb3VyY2UvcHJvdGVjdGVkLWltYWdlLnBocC4KLQogQ09OU09MRSBNRVNTQUdFOiBC bG9ja2VkIGh0dHA6Ly9sb2NhbGhvc3Q6ODA4MC9zZWN1cml0eS9taXhlZENvbnRlbnQvcmVzb3Vy Y2VzL3N1YnJlc291cmNlL3Byb3RlY3RlZC1pbWFnZS5waHAgZnJvbSBhc2tpbmcgZm9yIGNyZWRl bnRpYWxzIGJlY2F1c2UgaXQgaXMgYSBjcm9zcy1vcmlnaW4gcmVxdWVzdC4KIFRoaXMgdGVzdCBs b2FkcyBhIHNlY3VyZSBpbWFnZSB0aGF0IHJlZGlyZWN0cyB0byBhbiBzZWN1cmUgaW1hZ2UgdGhh dCByZWRpcmVjdHMgdG8gYW4gaW5zZWN1cmUgaW1hZ2UgZ3VhcmRlZCBieSBiYXNpYyBhdXRoZW50 aWNhdGlvbi4gVGhlIGluc2VjdXJlIGltYWdlIHNob3VsZCBiZSBibG9ja2VkIGJlY2F1c2UgaXQg cmVxdWlyZXMgY3JlZGVudGlhbHMuCiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L3dlYnNvY2tldC9pbnNlY3VyZS13ZWJzb2NrZXQtaW4t aWZyYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVu dC93ZWJzb2NrZXQvaW5zZWN1cmUtd2Vic29ja2V0LWluLWlmcmFtZS5odG1sCmluZGV4IDZiYzU0 YzhkMzcyZi4uMThkMDk2M2FlMWRiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3NlY3VyaXR5L21peGVkQ29udGVudC93ZWJzb2NrZXQvaW5zZWN1cmUtd2Vic29ja2V0LWluLWlm cmFtZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250 ZW50L3dlYnNvY2tldC9pbnNlY3VyZS13ZWJzb2NrZXQtaW4taWZyYW1lLmh0bWwKQEAgLTEsNCAr MSw0IEBACi08c2NyaXB0PgorPHNjcmlwdD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVy aW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+ CiBpZiAod2luZG93LnRlc3RSdW5uZXIpCiAgICAgdGVzdFJ1bm5lci5kdW1wQXNUZXh0KCk7CiA8 L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4 ZWRDb250ZW50L3dlYnNvY2tldC9pbnNlY3VyZS13ZWJzb2NrZXQtaW4tbWFpbi1mcmFtZS5odG1s IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvd2Vic29ja2V0 L2luc2VjdXJlLXdlYnNvY2tldC1pbi1tYWluLWZyYW1lLmh0bWwKaW5kZXggZDMzZDkxMzNhOGFh Li42OGQyYTZhOTEzYTcgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJp dHkvbWl4ZWRDb250ZW50L3dlYnNvY2tldC9pbnNlY3VyZS13ZWJzb2NrZXQtaW4tbWFpbi1mcmFt ZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50 L3dlYnNvY2tldC9pbnNlY3VyZS13ZWJzb2NrZXQtaW4tbWFpbi1mcmFtZS5odG1sCkBAIC0xLDQg KzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1l bnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8 Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRlc3RSdW5uZXIpIHsKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRjb250ZW50LWdlb2xvY2F0aW9uLWJs b2NrLWluc2VjdXJlLWNvbnRlbnQuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJp dHkvbWl4ZWRjb250ZW50LWdlb2xvY2F0aW9uLWJsb2NrLWluc2VjdXJlLWNvbnRlbnQuaHRtbApp bmRleCA3ZTBhMWQzNGMyNjMuLjFhZGQzZTE4NGE5OSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZGNvbnRlbnQtZ2VvbG9jYXRpb24tYmxvY2staW5zZWN1 cmUtY29udGVudC5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4 ZWRjb250ZW50LWdlb2xvY2F0aW9uLWJsb2NrLWluc2VjdXJlLWNvbnRlbnQuaHRtbApAQCAtMSw0 ICsxLDQgQEAKLTxodG1sPgorPGh0bWw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmlt ZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgog PGJvZHk+CiA8c2NyaXB0PgogaWYgKHdpbmRvdy50ZXN0UnVubmVyKSB7CmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkY29udGVudC1nZW9sb2NhdGlvbi5o dG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZGNvbnRlbnQtZ2VvbG9j YXRpb24uaHRtbAppbmRleCAxZDI1YjI2Y2NmOGYuLmUzMzk2OGYxZjg2MSAxMDA2NDQKLS0tIGEv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZGNvbnRlbnQtZ2VvbG9jYXRpb24u aHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkY29udGVudC1n ZW9sb2NhdGlvbi5odG1sCkBAIC0xLDQgKzEsNCBAQAotPGh0bWw+Cis8aHRtbD48IS0tIHdlYmtp dC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNz ZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8Ym9keT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LnRlc3RS dW5uZXIpIHsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvb3Jp Z2luSGVhZGVyL29yaWdpbi1oZWFkZXItZm9yLWh0dHBzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvc2VjdXJpdHkvb3JpZ2luSGVhZGVyL29yaWdpbi1oZWFkZXItZm9yLWh0 dHBzLWV4cGVjdGVkLnR4dAppbmRleCAwNmEzM2M2M2ZlYmEuLjdhMDI5NDE0MDkwYSAxMDA2NDQK LS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zZWN1cml0eS9vcmlnaW5IZWFkZXIvb3JpZ2lu LWhlYWRlci1mb3ItaHR0cHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvc2VjdXJpdHkvb3JpZ2luSGVhZGVyL29yaWdpbi1oZWFkZXItZm9yLWh0dHBzLWV4cGVjdGVk LnR4dApAQCAtMSwzICsxIEBACi1DT05TT0xFIE1FU1NBR0U6IFRoZSBwYWdlIGF0IGh0dHBzOi8v MTI3LjAuMC4xOjg0NDMvc2VjdXJpdHkvb3JpZ2luSGVhZGVyL3Jlc291cmNlcy9vcmlnaW4taGVh ZGVyLXBvc3QtdG8taHR0cC5odG1sIGNvbnRhaW5zIGEgZm9ybSB3aGljaCB0YXJnZXRzIGFuIGlu c2VjdXJlIFVSTCBodHRwOi8vMTI3LjAuMC4xOjgwMDAvc2VjdXJpdHkvb3JpZ2luSGVhZGVyL3Jl c291cmNlcy9wcmludC1vcmlnaW4uY2dpLgotCiBIVFRQX09SSUdJTjogaHR0cHM6Ly8xMjcuMC4w LjE6ODQ0MwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zc2wvbWl4ZWRDb250 ZW50L2luc2VjdXJlLXdlYnNvY2tldC5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9zc2wv bWl4ZWRDb250ZW50L2luc2VjdXJlLXdlYnNvY2tldC5odG1sCmluZGV4IGQzOWJmYjY0MjIzNi4u MjhmZDA2MDExNjFmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3NzbC9taXhl ZENvbnRlbnQvaW5zZWN1cmUtd2Vic29ja2V0Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9zc2wvbWl4ZWRDb250ZW50L2luc2VjdXJlLXdlYnNvY2tldC5odG1sCkBAIC0xLDQgKzEs NCBAQAotPCFET0NUWVBFIGh0bWw+Cis8IURPQ1RZUEUgaHRtbD48IS0tIHdlYmtpdC10ZXN0LXJ1 bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVk PWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxoZWFkPgogICAgIDxzY3JpcHQgc3JjPSIvanMtdGVzdC1y ZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9ub24tZG9jdW1lbnQtbWl4ZWQtY29u dGVudC1ibG9ja2VkLWh0dHAtd2l0aC1lbWJlZGRlZC1odHRwcy13aXRoLWVtYmVkZGVkLWh0dHAu aHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvbm9uLWRv Y3VtZW50LW1peGVkLWNvbnRlbnQtYmxvY2tlZC1odHRwLXdpdGgtZW1iZWRkZWQtaHR0cHMtd2l0 aC1lbWJlZGRlZC1odHRwLmh0bWwKaW5kZXggMDM5NTM1OWQ5NzYxLi44M2RiNTFhYjJiOGUgMTAw NjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvbm9u LWRvY3VtZW50LW1peGVkLWNvbnRlbnQtYmxvY2tlZC1odHRwLXdpdGgtZW1iZWRkZWQtaHR0cHMt d2l0aC1lbWJlZGRlZC1odHRwLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy93ZWJz b2NrZXQvdGVzdHMvaHliaS9ub24tZG9jdW1lbnQtbWl4ZWQtY29udGVudC1ibG9ja2VkLWh0dHAt d2l0aC1lbWJlZGRlZC1odHRwcy13aXRoLWVtYmVkZGVkLWh0dHAuaHRtbApAQCAtMSw0ICsxLDQg QEAKLTwhRE9DVFlQRSBIVE1MPgorPCFET0NUWVBFIEhUTUw+PCEtLSB3ZWJraXQtdGVzdC1ydW5u ZXIgWyBleHBlcmltZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1m YWxzZSBdIC0tPgogPGh0bWw+CiA8aGVhZD48L2hlYWQ+CiA8Ym9keT4KZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvbm9uLWRvY3VtZW50LW1p eGVkLWNvbnRlbnQtYmxvY2tlZC1odHRwLXdpdGgtZW1iZWRkZWQtaHR0cHMuaHRtbCBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvbm9uLWRvY3VtZW50LW1peGVk LWNvbnRlbnQtYmxvY2tlZC1odHRwLXdpdGgtZW1iZWRkZWQtaHR0cHMuaHRtbAppbmRleCBiNDQ0 ZTcxODJhY2QuLjhkZWQ5YzU1NWQ2ZCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9ub24tZG9jdW1lbnQtbWl4ZWQtY29udGVudC1ibG9ja2Vk LWh0dHAtd2l0aC1lbWJlZGRlZC1odHRwcy5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvbm9uLWRvY3VtZW50LW1peGVkLWNvbnRlbnQtYmxvY2tl ZC1odHRwLXdpdGgtZW1iZWRkZWQtaHR0cHMuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTwhRE9DVFlQ RSBIVE1MPgorPCFET0NUWVBFIEhUTUw+PCEtLSB3ZWJraXQtdGVzdC1ydW5uZXIgWyBleHBlcmlt ZW50YWw6VHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZD1mYWxzZSBdIC0tPgog PGh0bWw+CiA8aGVhZD48L2hlYWQ+CiA8Ym9keT4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvbm9uLWRvY3VtZW50LW1peGVkLWNvbnRlbnQt YmxvY2tlZC1odHRwcy13aXRoLWVtYmVkZGVkLWh0dHAtd2l0aC1lbWJlZGRlZC1odHRwcy5odHRw cy5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9ub24t ZG9jdW1lbnQtbWl4ZWQtY29udGVudC1ibG9ja2VkLWh0dHBzLXdpdGgtZW1iZWRkZWQtaHR0cC13 aXRoLWVtYmVkZGVkLWh0dHBzLmh0dHBzLmh0bWwKaW5kZXggZjI4Y2ZmZjAyMDFiLi43ZWMwMjAz ZmM2ZTYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3Rz L2h5Ymkvbm9uLWRvY3VtZW50LW1peGVkLWNvbnRlbnQtYmxvY2tlZC1odHRwcy13aXRoLWVtYmVk ZGVkLWh0dHAtd2l0aC1lbWJlZGRlZC1odHRwcy5odHRwcy5odG1sCisrKyBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvbm9uLWRvY3VtZW50LW1peGVkLWNvbnRl bnQtYmxvY2tlZC1odHRwcy13aXRoLWVtYmVkZGVkLWh0dHAtd2l0aC1lbWJlZGRlZC1odHRwcy5o dHRwcy5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBFIEhUTUw+Cis8IURPQ1RZUEUgSFRN TD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1lbnRhbDpUcnVzdHdvcnRoeUxvb3Bi YWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8aHRtbD4KIDxoZWFkPgogPHNjcmlw dD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5 Ymkvbm9uLWRvY3VtZW50LW1peGVkLWNvbnRlbnQtYmxvY2tlZC5odHRwcy5odG1sIGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9ub24tZG9jdW1lbnQtbWl4ZWQt Y29udGVudC1ibG9ja2VkLmh0dHBzLmh0bWwKaW5kZXggZDg5M2UxYjJhMmViLi5iNWE4YzY3NzI0 ZjUgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5 Ymkvbm9uLWRvY3VtZW50LW1peGVkLWNvbnRlbnQtYmxvY2tlZC5odHRwcy5odG1sCisrKyBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvbm9uLWRvY3VtZW50LW1p eGVkLWNvbnRlbnQtYmxvY2tlZC5odHRwcy5odG1sCkBAIC0xLDQgKzEsNCBAQAotPCFET0NUWVBF IEhUTUw+Cis8IURPQ1RZUEUgSFRNTD48IS0tIHdlYmtpdC10ZXN0LXJ1bm5lciBbIGV4cGVyaW1l bnRhbDpUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkPWZhbHNlIF0gLS0+CiA8 aHRtbD4KIDxoZWFkPjwvaGVhZD4KIDxib2R5PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxh dGZvcm0vd2syL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWJhc2lj LWF1dGgtaW1hZ2UtYWxsb3dDcm9zc09yaWdpblN1YnJlc291cmNlc1RvQXNrRm9yQ3JlZGVudGlh bHMuaHR0cHMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2syL2h0dHAvdGVz dHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWJhc2ljLWF1dGgtaW1hZ2UtYWxsb3dD cm9zc09yaWdpblN1YnJlc291cmNlc1RvQXNrRm9yQ3JlZGVudGlhbHMuaHR0cHMtZXhwZWN0ZWQu dHh0CmluZGV4IGJlN2QxMjNhN2Q0YS4uYzI4ZDM3MWVkYWRiIDEwMDY0NAotLS0gYS9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS93azIvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvaW5zZWN1 cmUtYmFzaWMtYXV0aC1pbWFnZS1hbGxvd0Nyb3NzT3JpZ2luU3VicmVzb3VyY2VzVG9Bc2tGb3JD cmVkZW50aWFscy5odHRwcy1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0v d2syL2h0dHAvdGVzdHMvc2VjdXJpdHkvbWl4ZWRDb250ZW50L2luc2VjdXJlLWJhc2ljLWF1dGgt aW1hZ2UtYWxsb3dDcm9zc09yaWdpblN1YnJlc291cmNlc1RvQXNrRm9yQ3JlZGVudGlhbHMuaHR0 cHMtZXhwZWN0ZWQudHh0CkBAIC0xLDUgKzEsMyBAQAotQ09OU09MRSBNRVNTQUdFOiBUaGUgcGFn ZSBhdCBodHRwczovLzEyNy4wLjAuMTo4NDQzL3NlY3VyaXR5L21peGVkQ29udGVudC9pbnNlY3Vy ZS1iYXNpYy1hdXRoLWltYWdlLWFsbG93Q3Jvc3NPcmlnaW5TdWJyZXNvdXJjZXNUb0Fza0ZvckNy ZWRlbnRpYWxzLmh0dHBzLmh0bWwgd2FzIGFsbG93ZWQgdG8gZGlzcGxheSBpbnNlY3VyZSBjb250 ZW50IGZyb20gaHR0cDovL2xvY2FsaG9zdDo4MDAwL3NlY3VyaXR5L21peGVkQ29udGVudC9yZXNv dXJjZXMvc3VicmVzb3VyY2UyL3Byb3RlY3RlZC1pbWFnZS5waHAuCi0KIGxvY2FsaG9zdDo4MDAw IC0gZGlkUmVjZWl2ZUF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlIC0gUHJvdGVjdGlvblNwYWNlQXV0 aGVudGljYXRpb25TY2hlbWVIVFRQQmFzaWMgLSBSZXNwb25kaW5nIHdpdGggdGVzdFVzZXI6dGVz dFBhc3N3b3JkCiBUZXN0cyB0aGF0IHdlIGRvIG5vdCBhc2sgZm9yIGNyZWRlbnRpYWxzIHdoZW4g bG9hZGluZyBhbiBpbnNlY3VyZSBpbWFnZSB0aGF0IHJlcXVpcmVzIGJhc2ljIGF1dGhlbnRpY2F0 aW9uLgogCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93azIvaHR0cC90ZXN0cy9z ZWN1cml0eS9taXhlZENvbnRlbnQvc2VjdXJlLXJlZGlyZWN0LXRvLXNlY3VyZS1yZWRpcmVjdC10 by1iYXNpYy1hdXRoLWluc2VjdXJlLWltYWdlLWFsbG93Q3Jvc3NPcmlnaW5TdWJyZXNvdXJjZXNU b0Fza0ZvckNyZWRlbnRpYWxzLmh0dHBzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3BsYXRm b3JtL3drMi9odHRwL3Rlc3RzL3NlY3VyaXR5L21peGVkQ29udGVudC9zZWN1cmUtcmVkaXJlY3Qt dG8tc2VjdXJlLXJlZGlyZWN0LXRvLWJhc2ljLWF1dGgtaW5zZWN1cmUtaW1hZ2UtYWxsb3dDcm9z c09yaWdpblN1YnJlc291cmNlc1RvQXNrRm9yQ3JlZGVudGlhbHMuaHR0cHMtZXhwZWN0ZWQudHh0 CmluZGV4IGRkMDE1NjI4MjNjZS4uODg1MjU1NjgzZmY5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9wbGF0Zm9ybS93azIvaHR0cC90ZXN0cy9zZWN1cml0eS9taXhlZENvbnRlbnQvc2VjdXJlLXJl ZGlyZWN0LXRvLXNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRoLWluc2VjdXJlLWltYWdlLWFs bG93Q3Jvc3NPcmlnaW5TdWJyZXNvdXJjZXNUb0Fza0ZvckNyZWRlbnRpYWxzLmh0dHBzLWV4cGVj dGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93azIvaHR0cC90ZXN0cy9zZWN1cml0 eS9taXhlZENvbnRlbnQvc2VjdXJlLXJlZGlyZWN0LXRvLXNlY3VyZS1yZWRpcmVjdC10by1iYXNp Yy1hdXRoLWluc2VjdXJlLWltYWdlLWFsbG93Q3Jvc3NPcmlnaW5TdWJyZXNvdXJjZXNUb0Fza0Zv ckNyZWRlbnRpYWxzLmh0dHBzLWV4cGVjdGVkLnR4dApAQCAtMSw1ICsxLDMgQEAKLUNPTlNPTEUg TUVTU0FHRTogVGhlIHBhZ2UgYXQgaHR0cHM6Ly8xMjcuMC4wLjE6ODQ0My9zZWN1cml0eS9taXhl ZENvbnRlbnQvc2VjdXJlLXJlZGlyZWN0LXRvLXNlY3VyZS1yZWRpcmVjdC10by1iYXNpYy1hdXRo LWluc2VjdXJlLWltYWdlLWFsbG93Q3Jvc3NPcmlnaW5TdWJyZXNvdXJjZXNUb0Fza0ZvckNyZWRl bnRpYWxzLmh0dHBzLmh0bWwgd2FzIGFsbG93ZWQgdG8gZGlzcGxheSBpbnNlY3VyZSBjb250ZW50 IGZyb20gaHR0cDovL2xvY2FsaG9zdDo4MDgwL3NlY3VyaXR5L21peGVkQ29udGVudC9yZXNvdXJj ZXMvc3VicmVzb3VyY2UvcHJvdGVjdGVkLWltYWdlLnBocC4KLQogbG9jYWxob3N0OjgwODAgLSBk aWRSZWNlaXZlQXV0aGVudGljYXRpb25DaGFsbGVuZ2UgLSBQcm90ZWN0aW9uU3BhY2VBdXRoZW50 aWNhdGlvblNjaGVtZUhUVFBCYXNpYyAtIFJlc3BvbmRpbmcgd2l0aCB0ZXN0VXNlcjp0ZXN0UGFz c3dvcmQKIFRoaXMgdGVzdCBsb2FkcyBhIHNlY3VyZSBpbWFnZSB0aGF0IHJlZGlyZWN0cyB0byBh biBzZWN1cmUgaW1hZ2UgdGhhdCByZWRpcmVjdHMgdG8gYW4gaW5zZWN1cmUgaW1hZ2UgZ3VhcmRl ZCBieSBiYXNpYyBhdXRoZW50aWNhdGlvbi4gVGhlIGltYWdlIHNob3VsZCBsb2FkLgogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV1RGL1NjcmlwdHMvUHJlZmVyZW5jZXMvV2ViUHJlZmVyZW5jZXNFeHBl cmltZW50YWwueWFtbCBiL1NvdXJjZS9XVEYvU2NyaXB0cy9QcmVmZXJlbmNlcy9XZWJQcmVmZXJl bmNlc0V4cGVyaW1lbnRhbC55YW1sCmluZGV4IDI2MGYxMTA2MGZiYS4uNmI2ZmVkZDFjNjg1IDEw MDY0NAotLS0gYS9Tb3VyY2UvV1RGL1NjcmlwdHMvUHJlZmVyZW5jZXMvV2ViUHJlZmVyZW5jZXNF eHBlcmltZW50YWwueWFtbAorKysgYi9Tb3VyY2UvV1RGL1NjcmlwdHMvUHJlZmVyZW5jZXMvV2Vi UHJlZmVyZW5jZXNFeHBlcmltZW50YWwueWFtbApAQCAtODAyLDYgKzgwMiwzMiBAQCBUcmFuc2Zv cm1TdHJlYW1BUElFbmFibGVkOgogICAgIFdlYktpdDoKICAgICAgIGRlZmF1bHQ6IHRydWUKIAor IyBodHRwczovL3czYy5naXRodWIuaW8vd2ViYXBwc2VjLXNlY3VyZS1jb250ZXh0cy8jaXMtb3Jp Z2luLXRydXN0d29ydGh5CitUcnVzdHdvcnRoeUxvY2FsaG9zdEFkZHJlc3Nlc0VuYWJsZWQ6Cisg IHR5cGU6IGJvb2wKKyAgaHVtYW5SZWFkYWJsZU5hbWU6ICJUcnVzdHdvcnRoeSBsb2NhbGhvc3Qg YWRkcmVzc2VzIgorICBodW1hblJlYWRhYmxlRGVzY3JpcHRpb246ICJUcmVhdCBob3N0cyBtYXRj aGluZyAnbG9jYWxob3N0Jywgb3IgZmFsbGluZyB3aXRoaW4gJy5sb2NhbGhvc3QnLCBhcyAnUG90 ZW50aWFsbHkgVHJ1c3R3b3J0aHknLiIKKyAgZGVmYXVsdFZhbHVlOgorICAgIFdlYktpdExlZ2Fj eToKKyAgICAgIGRlZmF1bHQ6IGZhbHNlCisgICAgV2ViS2l0OgorICAgICAgZGVmYXVsdDogZmFs c2UKKyAgICBXZWJDb3JlOgorICAgICAgZGVmYXVsdDogZmFsc2UKKworIyBodHRwczovL3czYy5n aXRodWIuaW8vd2ViYXBwc2VjLXNlY3VyZS1jb250ZXh0cy8jaXMtb3JpZ2luLXRydXN0d29ydGh5 CitUcnVzdHdvcnRoeUxvb3BiYWNrSVBBZGRyZXNzZXNFbmFibGVkOgorICB0eXBlOiBib29sCisg IGh1bWFuUmVhZGFibGVOYW1lOiAiVHJ1c3R3b3J0aHkgbG9vcGJhY2sgSVAgYWRkcmVzc2VzIgor ICBodW1hblJlYWRhYmxlRGVzY3JpcHRpb246ICJUcmVhdCBob3N0cyBtYXRjaGluZyBvbmUgb2Yg dGhlIENJRFIgbm90YXRpb25zIDEyNy4wLjAuMC84IG9yIDo6MS8xMjggYXMgJ1BvdGVudGlhbGx5 IFRydXN0d29ydGh5Jy4iCisgIGRlZmF1bHRWYWx1ZToKKyAgICBXZWJLaXRMZWdhY3k6CisgICAg ICBkZWZhdWx0OiB0cnVlCisgICAgV2ViS2l0OgorICAgICAgZGVmYXVsdDogdHJ1ZQorICAgIFdl YkNvcmU6CisgICAgICBkZWZhdWx0OiB0cnVlCisKIFVzZXJHZXN0dXJlUHJvbWlzZVByb3BhZ2F0 aW9uRW5hYmxlZDoKICAgdHlwZTogYm9vbAogICBodW1hblJlYWRhYmxlTmFtZTogIlVzZXJHZXN0 dXJlIFByb21pc2UgUHJvcGFnYXRpb24iCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1s L3BhcnNlci9YU1NBdWRpdG9yLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvcGFyc2VyL1hTU0F1 ZGl0b3IuY3BwCmluZGV4IGJjYjg4NWVhZGQ3My4uNjQxM2I4YmIzMWMzIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9odG1sL3BhcnNlci9YU1NBdWRpdG9yLmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9odG1sL3BhcnNlci9YU1NBdWRpdG9yLmNwcApAQCAtMzI0LDcgKzMyNCw3IEBAIHZvaWQg WFNTQXVkaXRvcjo6aW5pdChEb2N1bWVudCogZG9jdW1lbnQsIFhTU0F1ZGl0b3JEZWxlZ2F0ZSog YXVkaXRvckRlbGVnYXRlKQogCiAgICAgICAgIGlmICgobV94c3NQcm90ZWN0aW9uID09IFhTU1By b3RlY3Rpb25EaXNwb3NpdGlvbjo6RW5hYmxlZCB8fCBtX3hzc1Byb3RlY3Rpb24gPT0gWFNTUHJv dGVjdGlvbkRpc3Bvc2l0aW9uOjpCbG9ja0VuYWJsZWQpICYmICFwYXJzZWRSZXBvcnRVUkwuaXNF bXB0eSgpKSB7CiAgICAgICAgICAgICByZXBvcnRVUkwgPSBkb2N1bWVudC0+Y29tcGxldGVVUkwo cGFyc2VkUmVwb3J0VVJMKTsKLSAgICAgICAgICAgIGlmIChNaXhlZENvbnRlbnRDaGVja2VyOjpp c01peGVkQ29udGVudChkb2N1bWVudC0+c2VjdXJpdHlPcmlnaW4oKSwgcmVwb3J0VVJMKSkgewor ICAgICAgICAgICAgaWYgKE1peGVkQ29udGVudENoZWNrZXI6OmlzTWl4ZWRDb250ZW50KGRvY3Vt ZW50LT5zZXR0aW5ncygpLCBkb2N1bWVudC0+c2VjdXJpdHlPcmlnaW4oKSwgcmVwb3J0VVJMKSkg ewogICAgICAgICAgICAgICAgIGVycm9yRGV0YWlscyA9ICJpbnNlY3VyZSByZXBvcnRpbmcgVVJM IGZvciBzZWN1cmUgcGFnZSI7CiAgICAgICAgICAgICAgICAgbV94c3NQcm90ZWN0aW9uID0gWFNT UHJvdGVjdGlvbkRpc3Bvc2l0aW9uOjpJbnZhbGlkOwogICAgICAgICAgICAgICAgIHJlcG9ydFVS TCA9IFVSTCgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL01peGVkQ29udGVu dENoZWNrZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL01peGVkQ29udGVudENoZWNrZXIu Y3BwCmluZGV4IGE3YjZiZjY3M2FkNi4uOTI5OTBiZDc0OTVmIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9sb2FkZXIvTWl4ZWRDb250ZW50Q2hlY2tlci5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvbG9hZGVyL01peGVkQ29udGVudENoZWNrZXIuY3BwCkBAIC01MywxOCArNTMsMjEgQEAgRnJh bWVMb2FkZXJDbGllbnQmIE1peGVkQ29udGVudENoZWNrZXI6OmNsaWVudCgpIGNvbnN0CiB9CiAK IC8vIHN0YXRpYwotYm9vbCBNaXhlZENvbnRlbnRDaGVja2VyOjppc01peGVkQ29udGVudChTZWN1 cml0eU9yaWdpbiYgc2VjdXJpdHlPcmlnaW4sIGNvbnN0IFVSTCYgdXJsKQorYm9vbCBNaXhlZENv bnRlbnRDaGVja2VyOjppc01peGVkQ29udGVudChjb25zdCBTZXR0aW5ncyYgc2V0dGluZ3MsIFNl Y3VyaXR5T3JpZ2luJiBzZWN1cml0eU9yaWdpbiwgY29uc3QgVVJMJiB1cmwpCiB7CiAgICAgaWYg KHNlY3VyaXR5T3JpZ2luLnByb3RvY29sKCkgIT0gImh0dHBzIikKICAgICAgICAgcmV0dXJuIGZh bHNlOyAvLyBXZSBvbmx5IGNhcmUgYWJvdXQgSFRUUFMgc2VjdXJpdHkgb3JpZ2lucy4KIAorICAg IGlmIChTZWN1cml0eU9yaWdpbjo6aXNBUHJpb3JpdHlBdXRoZW50aWNhdGVkVVJMKHNldHRpbmdz LCB1cmwpKQorICAgICAgICByZXR1cm4gZmFsc2U7IC8vIGEgcHJpb3JpIGF1dGhlbnRpY2F0ZWQg dXJscyBhcmUgbm90IG1peGVkIGNvbnRlbnQuCisKICAgICAvLyBXZSdyZSBpbiBhIHNlY3VyZSBj b250ZXh0LCBzbyB8dXJsfCBpcyBtaXhlZCBjb250ZW50IGlmIGl0J3MgaW5zZWN1cmUuCiAgICAg cmV0dXJuICFTZWN1cml0eU9yaWdpbjo6aXNTZWN1cmUodXJsKTsKIH0KIAogYm9vbCBNaXhlZENv bnRlbnRDaGVja2VyOjpjYW5EaXNwbGF5SW5zZWN1cmVDb250ZW50KFNlY3VyaXR5T3JpZ2luJiBz ZWN1cml0eU9yaWdpbiwgQ29udGVudFR5cGUgdHlwZSwgY29uc3QgVVJMJiB1cmwsIEFsd2F5c0Rp c3BsYXlJbk5vblN0cmljdE1vZGUgYWx3YXlzRGlzcGxheUluTm9uU3RyaWN0TW9kZSkgY29uc3QK IHsKLSAgICBpZiAoIWlzTWl4ZWRDb250ZW50KHNlY3VyaXR5T3JpZ2luLCB1cmwpKQorICAgIGlm ICghaXNNaXhlZENvbnRlbnQobV9mcmFtZS5zZXR0aW5ncygpLCBzZWN1cml0eU9yaWdpbiwgdXJs KSkKICAgICAgICAgcmV0dXJuIHRydWU7CiAKICAgICBpZiAoIW1fZnJhbWUuZG9jdW1lbnQoKS0+ Y29udGVudFNlY3VyaXR5UG9saWN5KCktPmFsbG93UnVubmluZ09yRGlzcGxheWluZ0luc2VjdXJl Q29udGVudCh1cmwpKQpAQCAtODcsNyArOTAsNyBAQCBib29sIE1peGVkQ29udGVudENoZWNrZXI6 OmNhbkRpc3BsYXlJbnNlY3VyZUNvbnRlbnQoU2VjdXJpdHlPcmlnaW4mIHNlY3VyaXR5T3JpZwog CiBib29sIE1peGVkQ29udGVudENoZWNrZXI6OmNhblJ1bkluc2VjdXJlQ29udGVudChTZWN1cml0 eU9yaWdpbiYgc2VjdXJpdHlPcmlnaW4sIGNvbnN0IFVSTCYgdXJsKSBjb25zdAogewotICAgIGlm ICghaXNNaXhlZENvbnRlbnQoc2VjdXJpdHlPcmlnaW4sIHVybCkpCisgICAgaWYgKCFpc01peGVk Q29udGVudChtX2ZyYW1lLnNldHRpbmdzKCksIHNlY3VyaXR5T3JpZ2luLCB1cmwpKQogICAgICAg ICByZXR1cm4gdHJ1ZTsKIAogICAgIGlmICghbV9mcmFtZS5kb2N1bWVudCgpLT5jb250ZW50U2Vj dXJpdHlQb2xpY3koKS0+YWxsb3dSdW5uaW5nT3JEaXNwbGF5aW5nSW5zZWN1cmVDb250ZW50KHVy bCkpCkBAIC0xMTEsNyArMTE0LDcgQEAgdm9pZCBNaXhlZENvbnRlbnRDaGVja2VyOjpjaGVja0Zv cm1Gb3JNaXhlZENvbnRlbnQoU2VjdXJpdHlPcmlnaW4mIHNlY3VyaXR5T3JpZ2kKICAgICBpZiAo dXJsLnByb3RvY29sSXNKYXZhU2NyaXB0KCkpCiAgICAgICAgIHJldHVybjsKIAotICAgIGlmICgh aXNNaXhlZENvbnRlbnQoc2VjdXJpdHlPcmlnaW4sIHVybCkpCisgICAgaWYgKCFpc01peGVkQ29u dGVudChtX2ZyYW1lLnNldHRpbmdzKCksIHNlY3VyaXR5T3JpZ2luLCB1cmwpKQogICAgICAgICBy ZXR1cm47CiAKICAgICBTdHJpbmcgbWVzc2FnZSA9IG1ha2VTdHJpbmcoIlRoZSBwYWdlIGF0ICIs IG1fZnJhbWUuZG9jdW1lbnQoKS0+dXJsKCkuc3RyaW5nQ2VudGVyRWxsaXBzaXplZFRvTGVuZ3Ro KCksICIgY29udGFpbnMgYSBmb3JtIHdoaWNoIHRhcmdldHMgYW4gaW5zZWN1cmUgVVJMICIsIHVy bC5zdHJpbmdDZW50ZXJFbGxpcHNpemVkVG9MZW5ndGgoKSwgIi5cbiIpOwpAQCAtMTI4LDcgKzEz MSw3IEBAIE9wdGlvbmFsPFN0cmluZz4gTWl4ZWRDb250ZW50Q2hlY2tlcjo6Y2hlY2tGb3JNaXhl ZENvbnRlbnRJbkZyYW1lVHJlZShjb25zdCBVUkwmCiAgICAgICAgIFJFTEVBU0VfQVNTRVJUX1dJ VEhfTUVTU0FHRShkb2N1bWVudC0+ZnJhbWUoKSwgIkFuIHVucGFyZW50ZWQgZG9jdW1lbnQgdHJp ZWQgdG8gY29ubmVjdCB0byBhIHdlYnNvY2tldCB3aXRoIHVybDogJXMiLCB1cmwuc3RyaW5nKCku dXRmOCgpLmRhdGEoKSk7CiAgICAgICAgIAogICAgICAgICBhdXRvKiBmcmFtZSA9IGRvY3VtZW50 LT5mcmFtZSgpOwotICAgICAgICBpZiAoaXNNaXhlZENvbnRlbnQoZG9jdW1lbnQtPnNlY3VyaXR5 T3JpZ2luKCksIHVybCkpCisgICAgICAgIGlmIChpc01peGVkQ29udGVudChkb2N1bWVudC0+c2V0 dGluZ3MoKSwgZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCksIHVybCkpCiAgICAgICAgICAgICBy ZXR1cm4gbWFrZVN0cmluZygiVGhlIHBhZ2UgYXQgIiwgZG9jdW1lbnQtPnVybCgpLnN0cmluZ0Nl bnRlckVsbGlwc2l6ZWRUb0xlbmd0aCgpLCAiIHdhcyBibG9ja2VkIGZyb20gY29ubmVjdGluZyBp bnNlY3VyZWx5IHRvICIsIHVybC5zdHJpbmdDZW50ZXJFbGxpcHNpemVkVG9MZW5ndGgoKSwgIiBl aXRoZXIgYmVjYXVzZSB0aGUgcHJvdG9jb2wgaXMgaW5zZWN1cmUgb3IgdGhlIHBhZ2UgaXMgZW1i ZWRkZWQgZnJvbSBhbiBpbnNlY3VyZSBwYWdlLiIpOwogCiAgICAgICAgIGlmIChmcmFtZS0+aXNN YWluRnJhbWUoKSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9NaXhlZENvbnRl bnRDaGVja2VyLmggYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvTWl4ZWRDb250ZW50Q2hlY2tlci5o CmluZGV4IDY4ODllNWY0MTRiMi4uYjNlYjFlMThjMDI1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9sb2FkZXIvTWl4ZWRDb250ZW50Q2hlY2tlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2xv YWRlci9NaXhlZENvbnRlbnRDaGVja2VyLmgKQEAgLTM4LDYgKzM4LDcgQEAgbmFtZXNwYWNlIFdl YkNvcmUgewogY2xhc3MgRnJhbWU7CiBjbGFzcyBGcmFtZUxvYWRlckNsaWVudDsKIGNsYXNzIFNl Y3VyaXR5T3JpZ2luOworY2xhc3MgU2V0dGluZ3M7CiAKIGNsYXNzIE1peGVkQ29udGVudENoZWNr ZXIgewogICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKE1peGVkQ29udGVudENoZWNrZXIpOwpAQCAt NTcsNyArNTgsNyBAQCBwdWJsaWM6CiAgICAgYm9vbCBjYW5EaXNwbGF5SW5zZWN1cmVDb250ZW50 KFNlY3VyaXR5T3JpZ2luJiwgQ29udGVudFR5cGUsIGNvbnN0IFVSTCYsIEFsd2F5c0Rpc3BsYXlJ bk5vblN0cmljdE1vZGUgPSBBbHdheXNEaXNwbGF5SW5Ob25TdHJpY3RNb2RlOjpObykgY29uc3Q7 CiAgICAgYm9vbCBjYW5SdW5JbnNlY3VyZUNvbnRlbnQoU2VjdXJpdHlPcmlnaW4mLCBjb25zdCBV UkwmKSBjb25zdDsKICAgICB2b2lkIGNoZWNrRm9ybUZvck1peGVkQ29udGVudChTZWN1cml0eU9y aWdpbiYsIGNvbnN0IFVSTCYpIGNvbnN0OwotICAgIHN0YXRpYyBib29sIGlzTWl4ZWRDb250ZW50 KFNlY3VyaXR5T3JpZ2luJiwgY29uc3QgVVJMJik7CisgICAgc3RhdGljIGJvb2wgaXNNaXhlZENv bnRlbnQoY29uc3QgU2V0dGluZ3MmLCBTZWN1cml0eU9yaWdpbiYsIGNvbnN0IFVSTCYpOwogICAg IE9wdGlvbmFsPFN0cmluZz4gY2hlY2tGb3JNaXhlZENvbnRlbnRJbkZyYW1lVHJlZShjb25zdCBV UkwmKTsKIAogcHJpdmF0ZToKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2VjdXJp dHlPcmlnaW4uY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5jcHAKaW5k ZXggMTA3YzE4NTZhMjExLi4wNmUyMWQwYTdkYTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvU2VjdXJpdHlPcmlnaW4uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2VjdXJp dHlPcmlnaW4uY3BwCkBAIC0xMzEsNiArMTMxLDEyIEBAIHN0YXRpYyBib29sIGlzTG9vcGJhY2tJ UEFkZHJlc3MoU3RyaW5nVmlldyBob3N0KQogICAgIHJldHVybiBkb3RzRm91bmQgPT0gMzsKIH0K IAorc3RhdGljIGJvb2wgaXNMb2NhbGhvc3RJUEFkZHJlc3MoU3RyaW5nVmlldyBob3N0KQorewor ICAgIHJldHVybiBlcXVhbExldHRlcnNJZ25vcmluZ0FTQ0lJQ2FzZShob3N0LCAibG9jYWxob3N0 IikKKyAgICAgICAgfHwgaG9zdC5lbmRzV2l0aElnbm9yaW5nQVNDSUlDYXNlKCIubG9jYWxob3N0 Iik7Cit9CisKIC8vIGh0dHBzOi8vdzNjLmdpdGh1Yi5pby93ZWJhcHBzZWMtc2VjdXJlLWNvbnRl eHRzLyNpcy1vcmlnaW4tdHJ1c3R3b3J0aHkgKEVkaXRvcidzIERyYWZ0LCAxNyBOb3ZlbWJlciAy MDE2KQogc3RhdGljIGJvb2wgc2hvdWxkVHJlYXRBc1BvdGVudGlhbGx5VHJ1c3R3b3J0aHkoY29u c3QgU3RyaW5nJiBwcm90b2NvbCwgY29uc3QgU3RyaW5nJiBob3N0KQogewpAQCAtNTk5LDEyICs2 MDUsMzYgQEAgYm9vbCBTZWN1cml0eU9yaWdpbjo6aXNTYW1lU2NoZW1lSG9zdFBvcnQoY29uc3Qg U2VjdXJpdHlPcmlnaW4mIG90aGVyKSBjb25zdAogICAgIHJldHVybiB0cnVlOwogfQogCitib29s IFNlY3VyaXR5T3JpZ2luOjppc0FQcmlvcml0eUF1dGhlbnRpY2F0ZWRVUkwoY29uc3QgU2V0dGlu Z3MmIHNldHRpbmdzLCBjb25zdCBVUkwmIHVybCkKK3sKKyAgICAvLyBGSVhNRTogVGhpcyBzaG91 bGQganVzdCBiZSByZXR1cm5pbmcgc29tZXRoaW5nIGxpa2UKKyAgICAvLyBzaG91bGRUcmVhdEFz UG90ZW50aWFsbHlUcnVzdHdvcnRoeSh1cmwpIHx8IHVybC5wcm90b2NvbCgpID09ICJkYXRhIgor ICAgIC8vIGJ1dCBzaG91bGRUcmVhdEFzUG90ZW50aWFsbHlUcnVzdHdvcnRoeSBpcyBub3QgcmVh bGx5IHVwLXRvLWRhdGUgd2l0aAorICAgIC8vIHJlc3BlY3QgdG8gdGhlIGxhdGVzdCBzcGVjaWZp Y2F0aW9uLiBGb3Igbm93LCB3ZSBqdXN0IGltcGxlbWVudCBhCisgICAgLy8gc2ltcGxpZmllZCB2 ZXJzaW9uIHRvIGFsbG93IE1peGVkQ29udGVudENoZWNrZXI6OmlzTWl4ZWRDb250ZW50IHRvIHJl dHVybgorICAgIC8vIGZhbHNlIGZvciBsb29wYmFjayBJUCBhZGRyZXNzZXMgYW5kIGxvY2FsaG9z dCBhZGRyZXNzZXMuCisgICAgYXV0byBob3N0ID0gdXJsLmhvc3QoKS50b1N0cmluZ1dpdGhvdXRD b3B5aW5nKCk7CisKKyAgICAvLyBodHRwczovL3czYy5naXRodWIuaW8vd2ViYXBwc2VjLXNlY3Vy ZS1jb250ZXh0cy8jaXMtb3JpZ2luLXRydXN0d29ydGh5CisgICAgLy8gaG9zdCBjb21wb25lbnQg bWF0Y2hlcyBvbmUgb2YgdGhlIENJRFIgbm90YXRpb25zIDEyNy4wLjAuMC84IG9yIDo6MS8xMjgK KyAgICBpZiAoc2V0dGluZ3MudHJ1c3R3b3J0aHlMb29wYmFja0lQQWRkcmVzc2VzRW5hYmxlZCgp ICYmIGlzTG9vcGJhY2tJUEFkZHJlc3MoaG9zdCkpCisgICAgICAgIHJldHVybiB0cnVlOworCisg ICAgLy8gaHR0cHM6Ly93M2MuZ2l0aHViLmlvL3dlYmFwcHNlYy1zZWN1cmUtY29udGV4dHMvI2lz LW9yaWdpbi10cnVzdHdvcnRoeQorICAgIC8vIGhvc3QgY29tcG9uZW50IGlzICJsb2NhbGhvc3Qi IG9yIGZhbGxzIHdpdGhpbiAiLmxvY2FsaG9zdCIKKyAgICBpZiAoc2V0dGluZ3MudHJ1c3R3b3J0 aHlMb2NhbGhvc3RBZGRyZXNzZXNFbmFibGVkKCkgJiYgaXNMb2NhbGhvc3RJUEFkZHJlc3MoaG9z dCkpCisgICAgICAgIHJldHVybiB0cnVlOworCisgICAgcmV0dXJuIGZhbHNlOworfQorCiBib29s IFNlY3VyaXR5T3JpZ2luOjppc0xvY2FsSG9zdE9yTG9vcGJhY2tJUEFkZHJlc3MoU3RyaW5nVmll dyBob3N0KQogewogICAgIGlmIChpc0xvb3BiYWNrSVBBZGRyZXNzKGhvc3QpKQogICAgICAgICBy ZXR1cm4gdHJ1ZTsKIAogICAgIC8vIEZJWE1FOiBFbnN1cmUgdGhhdCBsb2NhbGhvc3QgcmVzb2x2 ZXMgdG8gdGhlIGxvb3BiYWNrIGFkZHJlc3MuCisgICAgLy8gRklYTUU6IFVzZSBpc0xvY2FsaG9z dElQQWRkcmVzcygpLgogICAgIGlmIChlcXVhbExldHRlcnNJZ25vcmluZ0FTQ0lJQ2FzZShob3N0 LCAibG9jYWxob3N0IikpCiAgICAgICAgIHJldHVybiB0cnVlOwogCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1Nl Y3VyaXR5T3JpZ2luLmgKaW5kZXggMjA3ZjhhOGFhNjM5Li4zZjNjMDFhZjFiMjMgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKQEAgLTM1LDYgKzM1LDggQEAKIAogbmFtZXNwYWNl IFdlYkNvcmUgewogCitjbGFzcyBTZXR0aW5nczsKKwogY2xhc3MgU2VjdXJpdHlPcmlnaW4gOiBw dWJsaWMgVGhyZWFkU2FmZVJlZkNvdW50ZWQ8U2VjdXJpdHlPcmlnaW4+IHsKIHB1YmxpYzoKICAg ICBlbnVtIFBvbGljeSB7CkBAIC0yMTYsNiArMjE4LDEwIEBAIHB1YmxpYzoKIAogICAgIFdFQkNP UkVfRVhQT1JUIHN0YXRpYyBib29sIGlzTG9jYWxIb3N0T3JMb29wYmFja0lQQWRkcmVzcyhTdHJp bmdWaWV3KTsKIAorICAgIC8vIFRoaXMgbWV0aG9kIGltcGxlbWVudHMgdGhlIGEgcHJpb3JpIGF1 dGhlbnRpY2F0ZWQgVVJMCisgICAgLy8gaHR0cHM6Ly93M2MuZ2l0aHViLmlvL3dlYmFwcHNlYy1t aXhlZC1jb250ZW50LyNhLXByaW9yaS1hdXRoZW50aWNhdGVkLXVybAorICAgIFdFQkNPUkVfRVhQ T1JUIHN0YXRpYyBib29sIGlzQVByaW9yaXR5QXV0aGVudGljYXRlZFVSTChjb25zdCBTZXR0aW5n cyYsIGNvbnN0IFVSTCYpOworCiAgICAgY29uc3QgU2VjdXJpdHlPcmlnaW5EYXRhJiBkYXRhKCkg Y29uc3QgeyByZXR1cm4gbV9kYXRhOyB9CiAKICAgICB0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVyPiB2 b2lkIGVuY29kZShFbmNvZGVyJikgY29uc3Q7Ci0tIAoyLjI4LjAKCg==