210422 2020-04-13 07:06:11 -0700 [GTK][WPE] Add API to expose UIClient::requestStorageAccessConfirm 2020-06-15 08:19:21 -0700 1 1 1 Unclassified WebKit WebKitGTK WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED Gtk P2 Normal --- 210184 1 cgarcia webkit-unassigned annulen berto bugs-noreply ews-watchlist gustavo gyuyoung.kim mcatanzaro ryuan.choi sergio wilander oldest_to_newest 1640845 0 cgarcia 2020-04-13 07:06:11 -0700 . 1640848 1 mcatanzaro 2020-04-13 07:29:55 -0700 Naive proposal: WebKitWebView::storage-access-request (parallels WebKitWebView::permission-request). Default impl in WebKit could use a GtkDialog, but Epiphany would reimplement using GtkInfoBar. 1640849 2 cgarcia 2020-04-13 07:32:36 -0700 I think we can just use permission-request. 1640859 3 mcatanzaro 2020-04-13 07:48:23 -0700 You're right :) 1661920 4 401725 cgarcia 2020-06-12 06:55:06 -0700 Created attachment 401725 Patch I have no idea how to test this. 1661921 5 ews-watchlist 2020-06-12 06:55:48 -0700 Thanks for the patch. If this patch contains new public API please make sure it follows the guidelines for new WebKit2 GTK+ API. See http://trac.webkit.org/wiki/WebKitGTK/AddingNewWebKit2API 1662071 6 401725 mcatanzaro 2020-06-12 11:54:32 -0700 Comment on attachment 401725 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401725&action=review I think it would be pretty hard to create an API test for this. Manual testing should suffice. (Bonus points for Epiphany implementation.) Do we know of any existing websites that make use of the storage access API with either Safari or Firefox? > Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataAccessPermissionRequest.cpp:33 > + * WebKitUserMediaPermissionRequest represents a request for WebKitWebsiteDataPermissionRequest > Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataAccessPermissionRequest.cpp:34 > + * permission to allow a third-party domain access cookies and website data. access to cookies and website data Although, I'm not actually certain it *does* allow a third-party domain to access website data other than cookies. Are you sure about this? Firefox allows this according to https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API, but its documentation implies that WebKit does not. John would know exactly how this works. > Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataAccessPermissionRequest.cpp:81 > + // Default behaviour when no decision has been made is denying the request. > + webkitWebsiteDataAccessPermissionRequestDeny(WEBKIT_PERMISSION_REQUEST(object)); So I see this is copied from our various other permission request classes, but all those classes have a bool madeDecision member variable to track whether a permission request has previously been completed or not and only call the CompletionHandler if so. You don't have that here, so it's going to call the CompletionHandler again unconditionally. If you try this patch in a debug build, I think it's going to assert, because CompletionHandler is designed to assert when called twice. > Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataAccessPermissionRequest.cpp:125 > +/** > + * webkit_website_data_access_permission_request_get_current_domain: > + * @request: a #WebKitWebsiteDataAccessPermissionRequest > + * > + * Get the domain from which the requesting domain wants to access cookies and website data while browsing. > + * > + * Returns: the current domain name > + * > + * Since: 2.30 Hm, I assumed that the domain requesting storage access only gets access to its *own* cookies (and maybe also other website data), not access to the first-party domain's data. Does it really get access to the data of the first-party domain? John? Please investigate before landing; we need to be sure about this before we land this API. > Source/WebKit/UIProcess/API/gtk/WebKitWebsiteDataAccessPermissionRequest.h:56 > +struct _WebKitWebsiteDataAccessPermissionRequestClass { > + GObjectClass parent_class; > + > + void (*_webkit_reserved0) (void); > + void (*_webkit_reserved1) (void); > + void (*_webkit_reserved2) (void); > + void (*_webkit_reserved3) (void); > +}; Idle brainstorming: now that GTK 4 is upon us, it might be a good idea to figure out if it's possible to hide these class structs from the GTK 4 API. There's no reason for this type to be derivable, and no value in exposing class structs for non-derivable types. Problem is we can't use #if USE(GTK4) in the header files, so we'd need a third copy of all the public header files... possibly not worth it. 1662074 7 mcatanzaro 2020-06-12 11:56:18 -0700 (In reply to Michael Catanzaro from comment #6) > > Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataAccessPermissionRequest.cpp:33 > > + * WebKitUserMediaPermissionRequest represents a request for > > WebKitWebsiteDataPermissionRequest Even better: WebKitWebsiteDataAccessPermissionRequest :P 1662465 8 401725 cgarcia 2020-06-14 01:43:19 -0700 Comment on attachment 401725 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401725&action=review >> Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataAccessPermissionRequest.cpp:33 >> + * WebKitUserMediaPermissionRequest represents a request for > > WebKitWebsiteDataPermissionRequest Oops. >> Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataAccessPermissionRequest.cpp:34 >> + * permission to allow a third-party domain access cookies and website data. > > access to cookies and website data > > Although, I'm not actually certain it *does* allow a third-party domain to access website data other than cookies. Are you sure about this? Firefox allows this according to https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API, but its documentation implies that WebKit does not. John would know exactly how this works. I used the safari dialog message as a reference, see https://webkit.org/wp-content/uploads/storage-access-prompt.png >> Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataAccessPermissionRequest.cpp:81 >> + webkitWebsiteDataAccessPermissionRequestDeny(WEBKIT_PERMISSION_REQUEST(object)); > > So I see this is copied from our various other permission request classes, but all those classes have a bool madeDecision member variable to track whether a permission request has previously been completed or not and only call the CompletionHandler if so. You don't have that here, so it's going to call the CompletionHandler again unconditionally. If you try this patch in a debug build, I think it's going to assert, because CompletionHandler is designed to assert when called twice. We don't need an extra variable for that in this case because completion handler is false once it has been called, and I'm checking it's true before calling it in both Allow and Deny. >> Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataAccessPermissionRequest.cpp:125 >> + * Since: 2.30 > > Hm, I assumed that the domain requesting storage access only gets access to its *own* cookies (and maybe also other website data), not access to the first-party domain's data. Does it really get access to the data of the first-party domain? John? > > Please investigate before landing; we need to be sure about this before we land this API. Again I used the safari dialog as reference. >> Source/WebKit/UIProcess/API/gtk/WebKitWebsiteDataAccessPermissionRequest.h:56 >> +}; > > Idle brainstorming: now that GTK 4 is upon us, it might be a good idea to figure out if it's possible to hide these class structs from the GTK 4 API. There's no reason for this type to be derivable, and no value in exposing class structs for non-derivable types. Problem is we can't use #if USE(GTK4) in the header files, so we'd need a third copy of all the public header files... possibly not worth it. We are already adding another header for the cases where gtk4 needs a different API. I don't think it's worth using a different header for all classes in gtk4 just to me them final. 1662484 9 401725 mcatanzaro 2020-06-14 06:48:11 -0700 Comment on attachment 401725 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401725&action=review >>> Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataAccessPermissionRequest.cpp:34 >>> + * permission to allow a third-party domain access cookies and website data. >> >> access to cookies and website data >> >> Although, I'm not actually certain it *does* allow a third-party domain to access website data other than cookies. Are you sure about this? Firefox allows this according to https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API, but its documentation implies that WebKit does not. John would know exactly how this works. > > I used the safari dialog message as a reference, see https://webkit.org/wp-content/uploads/storage-access-prompt.png OK. >>> Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataAccessPermissionRequest.cpp:81 >>> + webkitWebsiteDataAccessPermissionRequestDeny(WEBKIT_PERMISSION_REQUEST(object)); >> >> So I see this is copied from our various other permission request classes, but all those classes have a bool madeDecision member variable to track whether a permission request has previously been completed or not and only call the CompletionHandler if so. You don't have that here, so it's going to call the CompletionHandler again unconditionally. If you try this patch in a debug build, I think it's going to assert, because CompletionHandler is designed to assert when called twice. > > We don't need an extra variable for that in this case because completion handler is false once it has been called, and I'm checking it's true before calling it in both Allow and Deny. OK. >>> Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataAccessPermissionRequest.cpp:125 >>> + * Since: 2.30 >> >> Hm, I assumed that the domain requesting storage access only gets access to its *own* cookies (and maybe also other website data), not access to the first-party domain's data. Does it really get access to the data of the first-party domain? John? >> >> Please investigate before landing; we need to be sure about this before we land this API. > > Again I used the safari dialog as reference. In this case, I think you misread the Safari dialog (although I might be wrong). I think the third-party domain is requesting access to its own cookies and website data, not the first-party domain's cookies and website data. 1662485 10 mcatanzaro 2020-06-14 06:54:39 -0700 (In reply to Carlos Garcia Campos from comment #8) > We are already adding another header for the cases where gtk4 needs a > different API. I don't think it's worth using a different header for all > classes in gtk4 just to me them final. At the risk of getting a bit off-topic for this bug, we've probably reached the point where it would be useful to have a "control header" to allow us to use conditional compilation in the public headers. Then, we only need to duplicate the control header for GTK4, rather than every such header. In fact, if we were able to use preprocessor guards we should be able to eliminate duplication between WPE and GTK headers as well and just have one header for WPE, GTK3, and GTK4. Is there any reason we cannot do that? (I guess there is some reason I cannot think of, or you would have done this already?) Then we can guard all the GObject boilerplate in every header behind #if !USE(GTK4) and use either G_DECLARE_FINAL_TYPE or G_DECLARE_DERIVABLE_TYPE for the USE(GTK4) case, so we have a path to eventually removing the boilerplate 5-10 years from now when dropping GTK 3 support. We can also more aggressively remove all deprecated APIs from the USE(GTK4) case. And we can add more class struct padding to the types that remain derivable, most urgently to WebKitWebView. (It would be a shame to release the new GTK 4 ABI with only a single byte of padding in the WebKitWebView class struct.) I think the main challenge in supporting different APIs is gtk-doc, but gtk-doc looks at the source files, not the header files. 1662562 11 cgarcia 2020-06-15 00:29:43 -0700 (In reply to Michael Catanzaro from comment #10) > (In reply to Carlos Garcia Campos from comment #8) > > We are already adding another header for the cases where gtk4 needs a > > different API. I don't think it's worth using a different header for all > > classes in gtk4 just to me them final. > > At the risk of getting a bit off-topic for this bug, we've probably reached > the point where it would be useful to have a "control header" to allow us to > use conditional compilation in the public headers. Headers include gtk so I guess we can use #if GTK_CHECK_VERSION. I still don't like condition compilation in public headers, though. What's exactly a control header? > Then, we only need to > duplicate the control header for GTK4, rather than every such header. In > fact, if we were able to use preprocessor guards we should be able to > eliminate duplication between WPE and GTK headers as well and just have one > header for WPE, GTK3, and GTK4. Is there any reason we cannot do that? (I > guess there is some reason I cannot think of, or you would have done this > already?) I don't understand the proposal, TBH. > Then we can guard all the GObject boilerplate in every header behind #if > !USE(GTK4) and use either G_DECLARE_FINAL_TYPE or G_DECLARE_DERIVABLE_TYPE > for the USE(GTK4) case, so we have a path to eventually removing the > boilerplate 5-10 years from now when dropping GTK 3 support. We can also > more aggressively remove all deprecated APIs from the USE(GTK4) case. The plan is to remove all deprecated APIs for GTK4 in any case. > And we > can add more class struct padding to the types that remain derivable, most > urgently to WebKitWebView. (It would be a shame to release the new GTK 4 ABI > with only a single byte of padding in the WebKitWebView class struct.) That's also the case, no matter how we do it, we won't reuse the same header in those cases. > I think the main challenge in supporting different APIs is gtk-doc, but > gtk-doc looks at the source files, not the header files. It looks at headers too. 1662572 12 cgarcia 2020-06-15 01:23:36 -0700 (In reply to Michael Catanzaro from comment #9) > Comment on attachment 401725 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=401725&action=review > > >>> Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataAccessPermissionRequest.cpp:34 > >>> + * permission to allow a third-party domain access cookies and website data. > >> > >> access to cookies and website data > >> > >> Although, I'm not actually certain it *does* allow a third-party domain to access website data other than cookies. Are you sure about this? Firefox allows this according to https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API, but its documentation implies that WebKit does not. John would know exactly how this works. > > > > I used the safari dialog message as a reference, see https://webkit.org/wp-content/uploads/storage-access-prompt.png > > OK. > > >>> Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataAccessPermissionRequest.cpp:81 > >>> + webkitWebsiteDataAccessPermissionRequestDeny(WEBKIT_PERMISSION_REQUEST(object)); > >> > >> So I see this is copied from our various other permission request classes, but all those classes have a bool madeDecision member variable to track whether a permission request has previously been completed or not and only call the CompletionHandler if so. You don't have that here, so it's going to call the CompletionHandler again unconditionally. If you try this patch in a debug build, I think it's going to assert, because CompletionHandler is designed to assert when called twice. > > > > We don't need an extra variable for that in this case because completion handler is false once it has been called, and I'm checking it's true before calling it in both Allow and Deny. > > OK. > > >>> Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataAccessPermissionRequest.cpp:125 > >>> + * Since: 2.30 > >> > >> Hm, I assumed that the domain requesting storage access only gets access to its *own* cookies (and maybe also other website data), not access to the first-party domain's data. Does it really get access to the data of the first-party domain? John? > >> > >> Please investigate before landing; we need to be sure about this before we land this API. > > > > Again I used the safari dialog as reference. > > In this case, I think you misread the Safari dialog (although I might be > wrong). I think the third-party domain is requesting access to its own > cookies and website data, not the first-party domain's cookies and website > data. You are indeed right. 1662575 13 cgarcia 2020-06-15 01:29:53 -0700 So, in https://webkit.org/blog/8124/introducing-storage-access-api/ it says: "WebKit’s implementation of the API only covers cookies for now. It does not affect the partitioning of other storage forms such as IndexedDB or LocalStorage." So, yes, for now it's only about cookies. It's a good idea to use WebsiteDataAccess in the permission request name, but maybe we can refer to cookies only in the docs (and message dialog) for now. 1662580 14 401888 cgarcia 2020-06-15 01:40:58 -0700 Created attachment 401888 Patch for landing 1662596 15 cgarcia 2020-06-15 02:27:18 -0700 Committed r263028: <https://trac.webkit.org/changeset/263028> 1662650 16 mcatanzaro 2020-06-15 08:12:51 -0700 OK, tangent: (In reply to Carlos Garcia Campos from comment #11) > Headers include gtk so I guess we can use #if GTK_CHECK_VERSION. I still > don't like condition compilation in public headers, though. What's exactly a > control header? Just some header that would define USE_GTK4 for us. Using GTK_CHECK_VERSION is a good idea, but then we still have to have separate headers for GTK and WPE. I don't mind conditional compilation in public headers if it makes the headers more maintainable. Having two and now potentially three copies of every header that have to be updated in tandem is a shame. > > Then, we only need to > > duplicate the control header for GTK4, rather than every such header. In > > fact, if we were able to use preprocessor guards we should be able to > > eliminate duplication between WPE and GTK headers as well and just have one > > header for WPE, GTK3, and GTK4. Is there any reason we cannot do that? (I > > guess there is some reason I cannot think of, or you would have done this > > already?) > > I don't understand the proposal, TBH. For instance: #define WEBKIT_TYPE_WEBSITE_DATA_ACCESS_PERMISSION_REQUEST (webkit_website_data_access_permission_request_get_type()) #if GTK_CHECK_VERSION(3, 90, 0) G_DECLARE_FINAL_TYPE(WebKitWebsiteDataAccessPermissionRequest, webkit_website_data_access_permission_request, WEBKIT, WEBSITE_DATA_ACCESS_PERMISSION_REQUEST, WebKitPermissionRequest) #else #define WEBKIT_WEBSITE_DATA_ACCESS_PERMISSION_REQUEST(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_WEBSITE_DATA_ACCESS_PERMISSION_REQUEST, WebKitWebsiteDataAccessPermissionRequest)) #define WEBKIT_IS_WEBSITE_DATA_ACCESS_PERMISSION_REQUEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_WEBSITE_DATA_ACCESS_PERMISSION_REQUEST)) #define WEBKIT_WEBSITE_DATA_ACCESS_PERMISSION_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), WEBKIT_TYPE_WEBSITE_DATA_ACCESS_PERMISSION_REQUEST, WebKitWebsiteDataAccessPermissionRequestClass)) #define WEBKIT_IS_WEBSITE_DATA_ACCESS_PERMISSION_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), WEBKIT_TYPE_WEBSITE_DATA_ACCESS_PERMISSION_REQUEST)) #define WEBKIT_WEBSITE_DATA_ACCESS_PERMISSION_REQUEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), WEBKIT_TYPE_WEBSITE_DATA_ACCESS_PERMISSION_REQUEST, WebKitWebsiteDataAccessPermissionRequestClass)) typedef struct _WebKitWebsiteDataAccessPermissionRequest WebKitWebsiteDataAccessPermissionRequest; typedef struct _WebKitWebsiteDataAccessPermissionRequestClass WebKitWebsiteDataAccessPermissionRequestClass; typedef struct _WebKitWebsiteDataAccessPermissionRequestPrivate WebKitWebsiteDataAccessPermissionRequestPrivate; struct _WebKitWebsiteDataAccessPermissionRequest { GObject parent; /*< private >*/ WebKitWebsiteDataAccessPermissionRequestPrivate *priv; }; struct _WebKitWebsiteDataAccessPermissionRequestClass { GObjectClass parent_class; void (*_webkit_reserved0) (void); void (*_webkit_reserved1) (void); void (*_webkit_reserved2) (void); void (*_webkit_reserved3) (void); }; #endif Now, let's say we remove the GTK 3 API in 2025. Then that's a lot of boilerplate we can remove from the header files five years from now. But if we don't switch to G_DECLARE_[FINAL,DERIVABLE]_TYPE now, we're stuck with it. Or, for something completely different... we could use it in WebKitWebContext.h to hide functions entirely from the GTK 4 API: #if !GTK_CHECK_VERSION(3, 90, 0) WEBKIT_API void webkit_web_context_set_sandbox_enabled (WebKitWebContext *context, gboolean enabled); WEBKIT_API gboolean webkit_web_context_get_sandbox_enabled (WebKitWebContext *context); #endif Or consider WebKitWebPage.h, it's not meaningful to create your own WebKitWebPage, so why should the class struct be declared in a public header? Ideally every single public header would change for GTK 4, but we don't really want to have three copies of each header. 1662653 17 mcatanzaro 2020-06-15 08:19:21 -0700 I forgot the most important example: struct _WebKitWebViewClass { // ... void (*_webkit_reserved0) (void); #if GTK_CHECK_VERSION(3, 90, 0) void (*_webkit_reserved1) (void); void (*_webkit_reserved2) (void); void (*_webkit_reserved3) (void); void (*_webkit_reserved4) (void); void (*_webkit_reserved5) (void); void (*_webkit_reserved6) (void); void (*_webkit_reserved7) (void); void (*_webkit_reserved8) (void); void (*_webkit_reserved9) (void); void (*_webkit_reserved10) (void); void (*_webkit_reserved11) (void); void (*_webkit_reserved12) (void); void (*_webkit_reserved13) (void); void (*_webkit_reserved14) (void); void (*_webkit_reserved15) (void); void (*_webkit_reserved16) (void); void (*_webkit_reserved17) (void); void (*_webkit_reserved18) (void); void (*_webkit_reserved19) (void); void (*_webkit_reserved20) (void); void (*_webkit_reserved21) (void); void (*_webkit_reserved22) (void); void (*_webkit_reserved23) (void); void (*_webkit_reserved24) (void); #endif } Probably we won't use that much, but we'll feel really silly if we only add 16 new padding bytes and run out. :) 401725 2020-06-12 06:55:06 -0700 2020-06-15 01:40:58 -0700 Patch wk2-storage-access-request.diff text/plain 28027 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9DaGFu Z2VMb2cKaW5kZXggNTg5YmJiYjEzYWQyLi5lZjBkNjc0YzMyMjAgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMzcgQEAKKzIwMjAtMDYtMTIgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2Fs aWEuY29tPgorCisgICAgICAgIFtHVEtdW1dQRV0gQWRkIEFQSSB0byBleHBvc2UgVUlDbGllbnQ6 OnJlcXVlc3RTdG9yYWdlQWNjZXNzQ29uZmlybQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEwNDIyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgQWRkIFdlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lv blJlcXVlc3QgdG8gYXNrIGZvciBwZXJtaXNzaW9uIHRvIHRoZSB1c2VyIHVzaW5nIHRoZSBleGlz dGluZyBwZXJtaXNzaW9uCisgICAgICAgIHJlcXVlc3QgQVBJLgorCisgICAgICAgICogUGxhdGZv cm1HVEsuY21ha2U6CisgICAgICAgICogUGxhdGZvcm1XUEUuY21ha2U6CisgICAgICAgICogU291 cmNlc0dUSy50eHQ6CisgICAgICAgICogU291cmNlc1dQRS50eHQ6CisgICAgICAgICogVUlQcm9j ZXNzL0FQSS9nbGliL1dlYktpdFVJQ2xpZW50LmNwcDoKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJ L2dsaWIvV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdC5jcHA6IEFkZGVk LgorICAgICAgICAod2Via2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdEFsbG93 KToKKyAgICAgICAgKHdlYmtpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3REZW55 KToKKyAgICAgICAgKHdlYmtpdF9wZXJtaXNzaW9uX3JlcXVlc3RfaW50ZXJmYWNlX2luaXQpOgor ICAgICAgICAod2Via2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdERpc3Bvc2Up OgorICAgICAgICAod2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9yZXF1ZXN0 X2NsYXNzX2luaXQpOgorICAgICAgICAod2Via2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9u UmVxdWVzdENyZWF0ZSk6CisgICAgICAgICh3ZWJraXRfd2Vic2l0ZV9kYXRhX2FjY2Vzc19wZXJt aXNzaW9uX3JlcXVlc3RfZ2V0X3JlcXVlc3RpbmdfZG9tYWluKToKKyAgICAgICAgKHdlYmtpdF93 ZWJzaXRlX2RhdGFfYWNjZXNzX3Blcm1pc3Npb25fcmVxdWVzdF9nZXRfY3VycmVudF9kb21haW4p OgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Bl cm1pc3Npb25SZXF1ZXN0UHJpdmF0ZS5oOiBBZGRlZC4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0Lmg6IEFkZGVkLgor ICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlvbnMu dHh0OgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1kb2NzLnNn bWw6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvd2Via2l0Mi5oOgorICAgICAgICAqIFVJ UHJvY2Vzcy9BUEkvd3BlL1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3Qu aDogQWRkZWQuCisgICAgICAgICogVUlQcm9jZXNzL0FQSS93cGUvZG9jcy93cGUtMS4wLXNlY3Rp b25zLnR4dDoKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL3dwZS9kb2NzL3dwZS1kb2NzLnNnbWw6 CisgICAgICAgICogVUlQcm9jZXNzL0FQSS93cGUvd2Via2l0Lmg6CisKIDIwMjAtMDYtMTIgIENh cmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtTT1VQ XSBEaXNhYmxlIEhTVFMgZm9yIHJlcXVlc3RzIHdoZW4gY29va2llcyB3aWxsIGJlIGJsb2NrZWQg YnkgSVRQCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtR1RLLmNtYWtlIGIvU291 cmNlL1dlYktpdC9QbGF0Zm9ybUdUSy5jbWFrZQppbmRleCBiOTQ1MjJjOGZjYTAuLmYwYjYzOWI1 YmNlMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybUdUSy5jbWFrZQorKysgYi9T b3VyY2UvV2ViS2l0L1BsYXRmb3JtR1RLLmNtYWtlCkBAIC0xMzgsNiArMTM4LDcgQEAgc2V0KFdl YktpdDJHVEtfSU5TVEFMTEVEX0hFQURFUlMKICAgICAke1dFQktJVF9ESVJ9L1VJUHJvY2Vzcy9B UEkvZ3RrL1dlYktpdFdlYlZpZXcuaAogICAgICR7V0VCS0lUX0RJUn0vVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZS5oCiAgICAgJHtXRUJLSVRfRElSfS9VSVByb2Nl c3MvQVBJL2d0ay9XZWJLaXRXZWJzaXRlRGF0YS5oCisgICAgJHtXRUJLSVRfRElSfS9VSVByb2Nl c3MvQVBJL2d0ay9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0LmgKICAg ICAke1dFQktJVF9ESVJ9L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYnNpdGVEYXRhTWFuYWdl ci5oCiAgICAgJHtXRUJLSVRfRElSfS9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXaW5kb3dQcm9w ZXJ0aWVzLmgKICAgICAke1dFQktJVF9ESVJ9L1VJUHJvY2Vzcy9BUEkvZ3RrL3dlYmtpdDIuaApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybVdQRS5jbWFrZSBiL1NvdXJjZS9XZWJL aXQvUGxhdGZvcm1XUEUuY21ha2UKaW5kZXggODMyMGUzMTBlNmM0Li44OWNjN2UzY2RiMjMgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm1XUEUuY21ha2UKKysrIGIvU291cmNlL1dl YktpdC9QbGF0Zm9ybVdQRS5jbWFrZQpAQCAtMTUwLDYgKzE1MCw3IEBAIHNldChXUEVfQVBJX0lO U1RBTExFRF9IRUFERVJTCiAgICAgJHtXRUJLSVRfRElSfS9VSVByb2Nlc3MvQVBJL3dwZS9XZWJL aXRXZWJWaWV3QmFja2VuZC5oCiAgICAgJHtXRUJLSVRfRElSfS9VSVByb2Nlc3MvQVBJL3dwZS9X ZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmgKICAgICAke1dFQktJVF9ESVJ9L1VJUHJvY2Vzcy9B UEkvd3BlL1dlYktpdFdlYnNpdGVEYXRhLmgKKyAgICAke1dFQktJVF9ESVJ9L1VJUHJvY2Vzcy9B UEkvd3BlL1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QuaAogICAgICR7 V0VCS0lUX0RJUn0vVUlQcm9jZXNzL0FQSS93cGUvV2ViS2l0V2Vic2l0ZURhdGFNYW5hZ2VyLmgK ICAgICAke1dFQktJVF9ESVJ9L1VJUHJvY2Vzcy9BUEkvd3BlL1dlYktpdFdpbmRvd1Byb3BlcnRp ZXMuaAogICAgICR7V0VCS0lUX0RJUn0vVUlQcm9jZXNzL0FQSS93cGUvd2Via2l0LmgKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvU291cmNlc0dUSy50eHQgYi9Tb3VyY2UvV2ViS2l0L1NvdXJj ZXNHVEsudHh0CmluZGV4IDJkNWFhYzk1M2FiZS4uNTRmOGZhNDA4MDQ4IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L1NvdXJjZXNHVEsudHh0CisrKyBiL1NvdXJjZS9XZWJLaXQvU291cmNlc0dU Sy50eHQKQEAgLTE5MCw2ICsxOTAsNyBAQCBVSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2ViVmll dy5jcHAgQG5vLXVuaWZ5CiBVSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2ViVmlld0FjY2Vzc2li bGUuY3BwIEBuby11bmlmeQogVUlQcm9jZXNzL0FQSS9nbGliL1dlYktpdFdlYlZpZXdTZXNzaW9u U3RhdGUuY3BwIEBuby11bmlmeQogVUlQcm9jZXNzL0FQSS9nbGliL1dlYktpdFdlYnNpdGVEYXRh LmNwcCBAbm8tdW5pZnkKK1VJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vz c1Blcm1pc3Npb25SZXF1ZXN0LmNwcCBAbm8tdW5pZnkKIFVJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJL aXRXZWJzaXRlRGF0YU1hbmFnZXIuY3BwIEBuby11bmlmeQogVUlQcm9jZXNzL0FQSS9nbGliL1dl YktpdFdpbmRvd1Byb3BlcnRpZXMuY3BwIEBuby11bmlmeQogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L1NvdXJjZXNXUEUudHh0IGIvU291cmNlL1dlYktpdC9Tb3VyY2VzV1BFLnR4dAppbmRl eCA4YjkzNGU4MWU3NDguLmZiY2ViMDA1MjRlNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9T b3VyY2VzV1BFLnR4dAorKysgYi9Tb3VyY2UvV2ViS2l0L1NvdXJjZXNXUEUudHh0CkBAIC0xNzgs NiArMTc4LDcgQEAgVUlQcm9jZXNzL0FQSS9nbGliL1dlYktpdFdlYlZpZXcuY3BwIEBuby11bmlm eQogVUlQcm9jZXNzL0FQSS9nbGliL1dlYktpdFdlYlZpZXdBY2Nlc3NpYmxlLmNwcCBAbm8tdW5p ZnkKIFVJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmNwcCBAbm8t dW5pZnkKIFVJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJzaXRlRGF0YS5jcHAgQG5vLXVuaWZ5 CitVSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVx dWVzdC5jcHAgQG5vLXVuaWZ5CiBVSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2Vic2l0ZURhdGFN YW5hZ2VyLmNwcCBAbm8tdW5pZnkKIFVJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRXaW5kb3dQcm9w ZXJ0aWVzLmNwcCBAbm8tdW5pZnkKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvQVBJL2dsaWIvV2ViS2l0VUlDbGllbnQuY3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv QVBJL2dsaWIvV2ViS2l0VUlDbGllbnQuY3BwCmluZGV4IDM3MzE3MWI2OGY3ZC4uMmNlYjJiNGY0 OWY0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRV SUNsaWVudC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0 VUlDbGllbnQuY3BwCkBAIC0zMSw2ICszMSw3IEBACiAjaW5jbHVkZSAiV2ViS2l0VVJJUmVxdWVz dFByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJLaXRVc2VyTWVkaWFQZXJtaXNzaW9uUmVxdWVzdFBy aXZhdGUuaCIKICNpbmNsdWRlICJXZWJLaXRXZWJWaWV3UHJpdmF0ZS5oIgorI2luY2x1ZGUgIldl YktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3RQcml2YXRlLmgiCiAjaW5jbHVk ZSAiV2ViS2l0V2luZG93UHJvcGVydGllc1ByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJQYWdlUHJv eHkuaCIKICNpbmNsdWRlICJXZWJQcm9jZXNzUHJveHkuaCIKQEAgLTMwMCw2ICszMDEsMTIgQEAg cHJpdmF0ZToKICAgICAgICAgd2Via2l0V2ViVmlld01ha2VQZXJtaXNzaW9uUmVxdWVzdChtX3dl YlZpZXcsIFdFQktJVF9QRVJNSVNTSU9OX1JFUVVFU1Qobm90aWZpY2F0aW9uUGVybWlzc2lvblJl cXVlc3QuZ2V0KCkpKTsKICAgICB9CiAKKyAgICB2b2lkIHJlcXVlc3RTdG9yYWdlQWNjZXNzQ29u ZmlybShXZWJQYWdlUHJveHkmLCBXZWJGcmFtZVByb3h5KiwgY29uc3QgV2ViQ29yZTo6UmVnaXN0 cmFibGVEb21haW4mIHJlcXVlc3RpbmdEb21haW4sIGNvbnN0IFdlYkNvcmU6OlJlZ2lzdHJhYmxl RG9tYWluJiBjdXJyZW50RG9tYWluLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKGJvb2wpPiYmIGNv bXBsZXRpb25IYW5kbGVyKSBmaW5hbAorICAgIHsKKyAgICAgICAgR1JlZlB0cjxXZWJLaXRXZWJz aXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0PiB3ZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Np b25SZXF1ZXN0ID0gYWRvcHRHUmVmKHdlYmtpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJl cXVlc3RDcmVhdGUocmVxdWVzdGluZ0RvbWFpbiwgY3VycmVudERvbWFpbiwgV1RGTW92ZShjb21w bGV0aW9uSGFuZGxlcikpKTsKKyAgICAgICAgd2Via2l0V2ViVmlld01ha2VQZXJtaXNzaW9uUmVx dWVzdChtX3dlYlZpZXcsIFdFQktJVF9QRVJNSVNTSU9OX1JFUVVFU1Qod2Vic2l0ZURhdGFBY2Nl c3NQZXJtaXNzaW9uUmVxdWVzdC5nZXQoKSkpOworICAgIH0KKwogI2lmIFBMQVRGT1JNKEdUSykK ICAgICBib29sIHRha2VGb2N1cyhXZWJQYWdlUHJveHkqIHBhZ2UsIFdLRm9jdXNEaXJlY3Rpb24g ZGlyZWN0aW9uKSBmaW5hbAogICAgIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL0FQSS9nbGliL1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QuY3Bw IGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2Vic2l0ZURhdGFBY2Nl c3NQZXJtaXNzaW9uUmVxdWVzdC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwLi5hNmRjYzNjZGJlMDcKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0 LmNwcApAQCAtMCwwICsxLDEzMiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMCBJZ2FsaWEg Uy5MCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IKKyAqICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBH TlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiAgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiAgdmVyc2lvbiAyIG9mIHRoZSBM aWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqICBU aGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVz ZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiAgTGVzc2VyIEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJlY2Vp dmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogIExpY2Vuc2Ug YWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdh cmUKKyAqICBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29y LCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgi CisjaW5jbHVkZSAiV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdC5oIgor CisjaW5jbHVkZSAiV2ViS2l0UGVybWlzc2lvblJlcXVlc3QuaCIKKyNpbmNsdWRlICJXZWJLaXRX ZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0UHJpdmF0ZS5oIgorI2luY2x1ZGUgPHd0 Zi9Db21wbGV0aW9uSGFuZGxlci5oPgorI2luY2x1ZGUgPHd0Zi9nbGliL1dURkdUeXBlLmg+CisK Ky8qKgorICogU0VDVElPTjogV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVz dAorICogQFNob3J0X2Rlc2NyaXB0aW9uOiBBIHBlcm1pc3Npb24gcmVxdWVzdCBmb3IgYWNjZXNz aW5nIHdlYnNpdGUgZGF0YSBmcm9tIHRoaXJkLXBhcnR5IGRvbWFpbnMKKyAqIEBUaXRsZTogV2Vi S2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdAorICogQFNlZV9hbHNvOiAjV2Vi S2l0UGVybWlzc2lvblJlcXVlc3QsICNXZWJLaXRXZWJWaWV3CisgKgorICogV2ViS2l0VXNlck1l ZGlhUGVybWlzc2lvblJlcXVlc3QgcmVwcmVzZW50cyBhIHJlcXVlc3QgZm9yCisgKiBwZXJtaXNz aW9uIHRvIGFsbG93IGEgdGhpcmQtcGFydHkgZG9tYWluIGFjY2VzcyBjb29raWVzIGFuZCB3ZWJz aXRlIGRhdGEuCisgKgorICogV2hlbiBhIFdlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lv blJlcXVlc3QgaXMgbm90IGhhbmRsZWQgYnkgdGhlIHVzZXIsCisgKiBpdCBpcyBkZW5pZWQgYnkg ZGVmYXVsdC4KKyAqCisgKiBTaW5jZTogMi4zMAorICovCisKK3N0YXRpYyB2b2lkIHdlYmtpdF9w ZXJtaXNzaW9uX3JlcXVlc3RfaW50ZXJmYWNlX2luaXQoV2ViS2l0UGVybWlzc2lvblJlcXVlc3RJ ZmFjZSopOworCitzdHJ1Y3QgX1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVl c3RQcml2YXRlIHsKKyAgICBDU3RyaW5nIHJlcXVlc3RpbmdEb21haW47CisgICAgQ1N0cmluZyBj dXJyZW50RG9tYWluOworICAgIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoYm9vbCk+IGNvbXBsZXRp b25IYW5kbGVyOworfTsKKworV0VCS0lUX0RFRklORV9UWVBFX1dJVEhfQ09ERSgKKyAgICBXZWJL aXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0LCB3ZWJraXRfd2Vic2l0ZV9kYXRh X2FjY2Vzc19wZXJtaXNzaW9uX3JlcXVlc3QsIEdfVFlQRV9PQkpFQ1QsCisgICAgR19JTVBMRU1F TlRfSU5URVJGQUNFKFdFQktJVF9UWVBFX1BFUk1JU1NJT05fUkVRVUVTVCwgd2Via2l0X3Blcm1p c3Npb25fcmVxdWVzdF9pbnRlcmZhY2VfaW5pdCkpCisKK3N0YXRpYyB2b2lkIHdlYmtpdFdlYnNp dGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3RBbGxvdyhXZWJLaXRQZXJtaXNzaW9uUmVxdWVz dCogcmVxdWVzdCkKK3sKKyAgICBBU1NFUlQoV0VCS0lUX0lTX1dFQlNJVEVfREFUQV9BQ0NFU1Nf UEVSTUlTU0lPTl9SRVFVRVNUKHJlcXVlc3QpKTsKKworICAgIGF1dG8qIHByaXYgPSBXRUJLSVRf V0VCU0lURV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1QocmVxdWVzdCktPnByaXY7Cisg ICAgaWYgKHByaXYtPmNvbXBsZXRpb25IYW5kbGVyKQorICAgICAgICBwcml2LT5jb21wbGV0aW9u SGFuZGxlcih0cnVlKTsKK30KKworc3RhdGljIHZvaWQgd2Via2l0V2Vic2l0ZURhdGFBY2Nlc3NQ ZXJtaXNzaW9uUmVxdWVzdERlbnkoV2ViS2l0UGVybWlzc2lvblJlcXVlc3QqIHJlcXVlc3QpCit7 CisgICAgQVNTRVJUKFdFQktJVF9JU19XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVR VUVTVChyZXF1ZXN0KSk7CisKKyAgICBhdXRvKiBwcml2ID0gV0VCS0lUX1dFQlNJVEVfREFUQV9B Q0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNUKHJlcXVlc3QpLT5wcml2OworICAgIGlmIChwcml2LT5j b21wbGV0aW9uSGFuZGxlcikKKyAgICAgICAgcHJpdi0+Y29tcGxldGlvbkhhbmRsZXIoZmFsc2Up OworfQorCitzdGF0aWMgdm9pZCB3ZWJraXRfcGVybWlzc2lvbl9yZXF1ZXN0X2ludGVyZmFjZV9p bml0KFdlYktpdFBlcm1pc3Npb25SZXF1ZXN0SWZhY2UqIGlmYWNlKQoreworICAgIGlmYWNlLT5h bGxvdyA9IHdlYmtpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3RBbGxvdzsKKyAg ICBpZmFjZS0+ZGVueSA9IHdlYmtpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3RE ZW55OworfQorCitzdGF0aWMgdm9pZCB3ZWJraXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25S ZXF1ZXN0RGlzcG9zZShHT2JqZWN0KiBvYmplY3QpCit7CisgICAgLy8gRGVmYXVsdCBiZWhhdmlv dXIgd2hlbiBubyBkZWNpc2lvbiBoYXMgYmVlbiBtYWRlIGlzIGRlbnlpbmcgdGhlIHJlcXVlc3Qu CisgICAgd2Via2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdERlbnkoV0VCS0lU X1BFUk1JU1NJT05fUkVRVUVTVChvYmplY3QpKTsKKyAgICBHX09CSkVDVF9DTEFTUyh3ZWJraXRf d2Vic2l0ZV9kYXRhX2FjY2Vzc19wZXJtaXNzaW9uX3JlcXVlc3RfcGFyZW50X2NsYXNzKS0+ZGlz cG9zZShvYmplY3QpOworfQorCitzdGF0aWMgdm9pZCB3ZWJraXRfd2Vic2l0ZV9kYXRhX2FjY2Vz c19wZXJtaXNzaW9uX3JlcXVlc3RfY2xhc3NfaW5pdChXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Bl cm1pc3Npb25SZXF1ZXN0Q2xhc3MqIGtsYXNzKQoreworICAgIEdPYmplY3RDbGFzcyogb2JqZWN0 Q2xhc3MgPSBHX09CSkVDVF9DTEFTUyhrbGFzcyk7CisgICAgb2JqZWN0Q2xhc3MtPmRpc3Bvc2Ug PSB3ZWJraXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0RGlzcG9zZTsKK30KKwor V2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdCogd2Via2l0V2Vic2l0ZURh dGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdENyZWF0ZShjb25zdCBXZWJDb3JlOjpSZWdpc3RyYWJs ZURvbWFpbiYgcmVxdWVzdGluZ0RvbWFpbiwgY29uc3QgV2ViQ29yZTo6UmVnaXN0cmFibGVEb21h aW4mIGN1cnJlbnREb21haW4sIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoYm9vbCk+JiYgY29tcGxl dGlvbkhhbmRsZXIpCit7CisgICAgYXV0byogd2Vic2l0ZURhdGFQZXJtaXNzaW9uUmVxdWVzdCA9 IFdFQktJVF9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVChnX29iamVjdF9u ZXcoV0VCS0lUX1RZUEVfV0VCU0lURV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1QsIG51 bGxwdHIpKTsKKyAgICB3ZWJzaXRlRGF0YVBlcm1pc3Npb25SZXF1ZXN0LT5wcml2LT5yZXF1ZXN0 aW5nRG9tYWluID0gcmVxdWVzdGluZ0RvbWFpbi5zdHJpbmcoKS51dGY4KCk7CisgICAgd2Vic2l0 ZURhdGFQZXJtaXNzaW9uUmVxdWVzdC0+cHJpdi0+Y3VycmVudERvbWFpbiA9IGN1cnJlbnREb21h aW4uc3RyaW5nKCkudXRmOCgpOworICAgIHdlYnNpdGVEYXRhUGVybWlzc2lvblJlcXVlc3QtPnBy aXYtPmNvbXBsZXRpb25IYW5kbGVyID0gV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlcik7CisgICAg cmV0dXJuIHdlYnNpdGVEYXRhUGVybWlzc2lvblJlcXVlc3Q7Cit9CisKKy8qKgorICogd2Via2l0 X3dlYnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9yZXF1ZXN0X2dldF9yZXF1ZXN0aW5nX2Rv bWFpbjoKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25S ZXF1ZXN0CisgKgorICogR2V0IHRoZSBkb21haW4gcmVxdWVzdGluZyBwZXJtaXNzaW9uIHRvIGFj Y2VzcyBjb29raWVzIGFuZCB3ZWJzaXRlIGRhdGEgd2hpbGUgYnJvd3NpbmcgdGhlIGN1cnJlbnQg ZG9tYWluLgorICoKKyAqIFJldHVybnM6IHRoZSByZXF1ZXN0aW5nIGRvbWFpbiBuYW1lCisgKgor ICogU2luY2U6IDIuMzAKKyAqLworY29uc3QgY2hhciogd2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nl c3NfcGVybWlzc2lvbl9yZXF1ZXN0X2dldF9yZXF1ZXN0aW5nX2RvbWFpbihXZWJLaXRXZWJzaXRl RGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGdfcmV0dXJuX3Zh bF9pZl9mYWlsKFdFQktJVF9JU19XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVT VChyZXF1ZXN0KSwgbnVsbHB0cik7CisKKyAgICByZXR1cm4gcmVxdWVzdC0+cHJpdi0+cmVxdWVz dGluZ0RvbWFpbi5kYXRhKCk7Cit9CisKKy8qKgorICogd2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nl c3NfcGVybWlzc2lvbl9yZXF1ZXN0X2dldF9jdXJyZW50X2RvbWFpbjoKKyAqIEByZXF1ZXN0OiBh ICNXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0CisgKgorICogR2V0IHRo ZSBkb21haW4gZnJvbSB3aGljaCB0aGUgcmVxdWVzdGluZyBkb21haW4gd2FudHMgdG8gYWNjZXNz IGNvb2tpZXMgYW5kIHdlYnNpdGUgZGF0YSB3aGlsZSBicm93c2luZy4KKyAqCisgKiBSZXR1cm5z OiB0aGUgY3VycmVudCBkb21haW4gbmFtZQorICoKKyAqIFNpbmNlOiAyLjMwCisgKi8KK2NvbnN0 IGNoYXIqIHdlYmtpdF93ZWJzaXRlX2RhdGFfYWNjZXNzX3Blcm1pc3Npb25fcmVxdWVzdF9nZXRf Y3VycmVudF9kb21haW4oV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdCog cmVxdWVzdCkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfV0VCU0lURV9E QVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1QocmVxdWVzdCksIG51bGxwdHIpOworCisgICAg cmV0dXJuIHJlcXVlc3QtPnByaXYtPmN1cnJlbnREb21haW4uZGF0YSgpOworfQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2Vic2l0ZURhdGFBY2Nl c3NQZXJtaXNzaW9uUmVxdWVzdFByaXZhdGUuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQ SS9nbGliL1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3RQcml2YXRlLmgK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5kZWM3MjE4YWJmYzAKLS0t IC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRX ZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0UHJpdmF0ZS5oCkBAIC0wLDAgKzEsMjQg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjAgSWdhbGlhIFMuTAorICoKKyAqICBUaGlzIGxp YnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisg KiAgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1 YmxpYworICogIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5k YXRpb247IGVpdGhlcgorICogIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIg b3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3Ry aWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiAgYnV0IFdJVEhP VVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAq ICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBT ZWUgdGhlIEdOVQorICogIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRl dGFpbHMuCisgKgorICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdO VSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJy YXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiAgRm91bmRhdGlvbiwg SW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAt MTMwMSAgVVNBCisgKi8KKworI3ByYWdtYSBvbmNlCisKKyNpbmNsdWRlICJXZWJLaXRXZWJzaXRl RGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0LmgiCisjaW5jbHVkZSA8V2ViQ29yZS9SZWdpc3Ry YWJsZURvbWFpbi5oPgorCitXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0 KiB3ZWJraXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0Q3JlYXRlKGNvbnN0IFdl YkNvcmU6OlJlZ2lzdHJhYmxlRG9tYWluJiByZXF1ZXN0aW5nRG9tYWluLCBjb25zdCBXZWJDb3Jl OjpSZWdpc3RyYWJsZURvbWFpbiYgY3VycmVudERvbWFpbiwgQ29tcGxldGlvbkhhbmRsZXI8dm9p ZChib29sKT4mJik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ3Rr L1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QuaCBiL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVx dWVzdC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uOTFhYzU1YmZl NTJiCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0LmgKQEAgLTAsMCArMSw2OSBA QAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMCBJZ2FsaWEgUy5MCisgKgorICogIFRoaXMgbGli cmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAq ICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVi bGljCisgKiAgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbjsgZWl0aGVyCisgKiAgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBv cHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqICBidXQgV0lUSE9V VCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICog IE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNl ZSB0aGUgR05VCisgKiAgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0 YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05V IExlc3NlciBHZW5lcmFsIFB1YmxpYworICogIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJh cnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqICBGb3VuZGF0aW9uLCBJ bmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0x MzAxICBVU0EKKyAqLworCisjaWYgIWRlZmluZWQoX19XRUJLSVQyX0hfSU5TSURFX18pICYmICFk ZWZpbmVkKFdFQktJVDJfQ09NUElMQVRJT04pCisjZXJyb3IgIk9ubHkgPHdlYmtpdDIvd2Via2l0 Mi5oPiBjYW4gYmUgaW5jbHVkZWQgZGlyZWN0bHkuIgorI2VuZGlmCisKKyNpZm5kZWYgV2ViS2l0 V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdF9oCisjZGVmaW5lIFdlYktpdFdlYnNp dGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3RfaAorCisjaW5jbHVkZSA8Z2xpYi1vYmplY3Qu aD4KKyNpbmNsdWRlIDx3ZWJraXQyL1dlYktpdERlZmluZXMuaD4KKworR19CRUdJTl9ERUNMUwor CisjZGVmaW5lIFdFQktJVF9UWVBFX1dFQlNJVEVfREFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFV RVNUICAgICAgICAgICAgKHdlYmtpdF93ZWJzaXRlX2RhdGFfYWNjZXNzX3Blcm1pc3Npb25fcmVx dWVzdF9nZXRfdHlwZSgpKQorI2RlZmluZSBXRUJLSVRfV0VCU0lURV9EQVRBX0FDQ0VTU19QRVJN SVNTSU9OX1JFUVVFU1Qob2JqKSAgICAgICAgICAgIChHX1RZUEVfQ0hFQ0tfSU5TVEFOQ0VfQ0FT VCgob2JqKSwgV0VCS0lUX1RZUEVfV0VCU0lURV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVF U1QsIFdlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QpKQorI2RlZmluZSBX RUJLSVRfSVNfV0VCU0lURV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1Qob2JqKSAgICAg ICAgIChHX1RZUEVfQ0hFQ0tfSU5TVEFOQ0VfVFlQRSgob2JqKSwgV0VCS0lUX1RZUEVfV0VCU0lU RV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1QpKQorI2RlZmluZSBXRUJLSVRfV0VCU0lU RV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1RfQ0xBU1Moa2xhc3MpICAgIChHX1RZUEVf Q0hFQ0tfQ0xBU1NfQ0FTVCgoa2xhc3MpLCAgV0VCS0lUX1RZUEVfV0VCU0lURV9EQVRBX0FDQ0VT U19QRVJNSVNTSU9OX1JFUVVFU1QsIFdlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJl cXVlc3RDbGFzcykpCisjZGVmaW5lIFdFQktJVF9JU19XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1J U1NJT05fUkVRVUVTVF9DTEFTUyhrbGFzcykgKEdfVFlQRV9DSEVDS19DTEFTU19UWVBFKChrbGFz cyksICBXRUJLSVRfVFlQRV9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVCkp CisjZGVmaW5lIFdFQktJVF9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVF9H RVRfQ0xBU1Mob2JqKSAgKEdfVFlQRV9JTlNUQU5DRV9HRVRfQ0xBU1MoKG9iaiksICBXRUJLSVRf VFlQRV9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVCwgV2ViS2l0V2Vic2l0 ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdENsYXNzKSkKKwordHlwZWRlZiBzdHJ1Y3QgX1dl YktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QgICAgICAgIFdlYktpdFdlYnNp dGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3Q7Cit0eXBlZGVmIHN0cnVjdCBfV2ViS2l0V2Vi c2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdENsYXNzICAgV2ViS2l0V2Vic2l0ZURhdGFB Y2Nlc3NQZXJtaXNzaW9uUmVxdWVzdENsYXNzOwordHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFdlYnNp dGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3RQcml2YXRlIFdlYktpdFdlYnNpdGVEYXRhQWNj ZXNzUGVybWlzc2lvblJlcXVlc3RQcml2YXRlOworCitzdHJ1Y3QgX1dlYktpdFdlYnNpdGVEYXRh QWNjZXNzUGVybWlzc2lvblJlcXVlc3QgeworICAgIEdPYmplY3QgcGFyZW50OworCisgICAgLyo8 IHByaXZhdGUgPiovCisgICAgV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVz dFByaXZhdGUgKnByaXY7Cit9OworCitzdHJ1Y3QgX1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVy bWlzc2lvblJlcXVlc3RDbGFzcyB7CisgICAgR09iamVjdENsYXNzIHBhcmVudF9jbGFzczsKKwor ICAgIHZvaWQgKCpfd2Via2l0X3Jlc2VydmVkMCkgKHZvaWQpOworICAgIHZvaWQgKCpfd2Via2l0 X3Jlc2VydmVkMSkgKHZvaWQpOworICAgIHZvaWQgKCpfd2Via2l0X3Jlc2VydmVkMikgKHZvaWQp OworICAgIHZvaWQgKCpfd2Via2l0X3Jlc2VydmVkMykgKHZvaWQpOworfTsKKworV0VCS0lUX0FQ SSBHVHlwZQord2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9yZXF1ZXN0X2dl dF90eXBlICAgICAgICAgICAgICAodm9pZCk7CisKK1dFQktJVF9BUEkgY29uc3QgY2hhciAqCit3 ZWJraXRfd2Vic2l0ZV9kYXRhX2FjY2Vzc19wZXJtaXNzaW9uX3JlcXVlc3RfZ2V0X3JlcXVlc3Rp bmdfZG9tYWluIChXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0ICpyZXF1 ZXN0KTsKKworV0VCS0lUX0FQSSBjb25zdCBjaGFyICoKK3dlYmtpdF93ZWJzaXRlX2RhdGFfYWNj ZXNzX3Blcm1pc3Npb25fcmVxdWVzdF9nZXRfY3VycmVudF9kb21haW4gICAgKFdlYktpdFdlYnNp dGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QgKnJlcXVlc3QpOworCitHX0VORF9ERUNMUwor CisjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9ndGsvZG9j cy93ZWJraXQyZ3RrLTQuMC1zZWN0aW9ucy50eHQgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9B UEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0CmluZGV4IDQ4MmIwNmNlY2Zh MS4uYzAwNTU0NmYwMGM5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkv Z3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0CisrKyBiL1NvdXJjZS9XZWJLaXQv VUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLTQuMC1zZWN0aW9ucy50eHQKQEAgLTg0 MSw2ICs4NDEsMjYgQEAgV2ViS2l0Tm90aWZpY2F0aW9uUGVybWlzc2lvblJlcXVlc3RQcml2YXRl CiB3ZWJraXRfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25fcmVxdWVzdF9nZXRfdHlwZQogPC9TRUNU SU9OPgogCis8U0VDVElPTj4KKzxGSUxFPldlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lv blJlcXVlc3Q8L0ZJTEU+CitXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0 Cit3ZWJraXRfd2Vic2l0ZV9kYXRhX2FjY2Vzc19wZXJtaXNzaW9uX3JlcXVlc3RfZ2V0X3JlcXVl c3RpbmdfZG9tYWluCit3ZWJraXRfd2Vic2l0ZV9kYXRhX2FjY2Vzc19wZXJtaXNzaW9uX3JlcXVl c3RfZ2V0X2N1cnJlbnRfZG9tYWluCisKKzxTVUJTRUNUSU9OIFN0YW5kYXJkPgorV2ViS2l0V2Vi c2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdENsYXNzCitXRUJLSVRfVFlQRV9XRUJTSVRF X0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVAorV0VCS0lUX1dFQlNJVEVfREFUQV9BQ0NF U1NfUEVSTUlTU0lPTl9SRVFVRVNUCitXRUJLSVRfSVNfV0VCU0lURV9EQVRBX0FDQ0VTU19QRVJN SVNTSU9OX1JFUVVFU1QKK1dFQktJVF9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVR VUVTVF9DTEFTUworV0VCS0lUX0lTX1dFQlNJVEVfREFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFV RVNUX0NMQVNTCitXRUJLSVRfV0VCU0lURV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1Rf R0VUX0NMQVNTCisKKzxTVUJTRUNUSU9OIFByaXZhdGU+CitXZWJLaXRXZWJzaXRlRGF0YUFjY2Vz c1Blcm1pc3Npb25SZXF1ZXN0UHJpdmF0ZQord2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nlc3NfcGVy bWlzc2lvbl9yZXF1ZXN0X2dldF90eXBlCis8L1NFQ1RJT04+CisKIDxTRUNUSU9OPgogPEZJTEU+ V2ViS2l0UG9saWN5RGVjaXNpb248L0ZJTEU+CiBXZWJLaXRQb2xpY3lEZWNpc2lvbgpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstZG9j cy5zZ21sIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGst ZG9jcy5zZ21sCmluZGV4IDg2OTJjYzU1MTk0ZC4uZDhhYzgyMzMzMmYyIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1kb2NzLnNnbWwK KysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstZG9j cy5zZ21sCkBAIC02Niw2ICs2Niw3IEBACiAgICAgPHhpOmluY2x1ZGUgaHJlZj0ieG1sL1dlYktp dFVzZXJNZXNzYWdlLnhtbCIvPgogICAgIDx4aTppbmNsdWRlIGhyZWY9InhtbC9XZWJLaXRQb2lu dGVyTG9ja1Blcm1pc3Npb25SZXF1ZXN0LnhtbCIvPgogICAgIDx4aTppbmNsdWRlIGhyZWY9Inht bC9XZWJLaXRJbnB1dE1ldGhvZENvbnRleHQueG1sIi8+CisgICAgPHhpOmluY2x1ZGUgaHJlZj0i eG1sL1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QueG1sIi8+CiAgIDwv Y2hhcHRlcj4KIAogICA8Y2hhcHRlcj4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL0FQSS9ndGsvd2Via2l0Mi5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay93 ZWJraXQyLmgKaW5kZXggOTMwYjE3YjY2MjllLi5jMzU4MTE4MzYwYTMgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9ndGsvd2Via2l0Mi5oCisrKyBiL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL0FQSS9ndGsvd2Via2l0Mi5oCkBAIC05MCw2ICs5MCw3IEBACiAjaW5jbHVk ZSA8d2Via2l0Mi9XZWJLaXRXZWJWaWV3QmFzZS5oPgogI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0 V2ViVmlld1Nlc3Npb25TdGF0ZS5oPgogI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0V2Vic2l0ZURh dGEuaD4KKyNpbmNsdWRlIDx3ZWJraXQyL1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lv blJlcXVlc3QuaD4KICNpbmNsdWRlIDx3ZWJraXQyL1dlYktpdFdlYnNpdGVEYXRhTWFuYWdlci5o PgogI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0V2luZG93UHJvcGVydGllcy5oPgogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvd3BlL1dlYktpdFdlYnNpdGVEYXRhQWNj ZXNzUGVybWlzc2lvblJlcXVlc3QuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUv V2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdC5oCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZjc4ZGIwMWY1MjViCi0tLSAvZGV2L251bGwKKysr IGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vz c1Blcm1pc3Npb25SZXF1ZXN0LmgKQEAgLTAsMCArMSw2OSBAQAorLyoKKyAqIENvcHlyaWdodCAo QykgMjAyMCBJZ2FsaWEgUy5MCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqICBtb2RpZnkgaXQgdW5kZXIgdGhl IHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiAgTGljZW5zZSBhcyBw dWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiAgdmVy c2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJz aW9uLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhh dCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhv dXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBvciBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiAgTGVzc2Vy IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNo b3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1Ymxp YworICogIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8g dGhlIEZyZWUgU29mdHdhcmUKKyAqICBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJl ZXQsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqLworCisjaWYg IWRlZmluZWQoX19XRUJLSVRfSF9JTlNJREVfXykgJiYgIWRlZmluZWQoV0VCS0lUMl9DT01QSUxB VElPTikKKyNlcnJvciAiT25seSA8d3BlL3dlYmtpdC5oPiBjYW4gYmUgaW5jbHVkZWQgZGlyZWN0 bHkuIgorI2VuZGlmCisKKyNpZm5kZWYgV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9u UmVxdWVzdF9oCisjZGVmaW5lIFdlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVl c3RfaAorCisjaW5jbHVkZSA8Z2xpYi1vYmplY3QuaD4KKyNpbmNsdWRlIDx3cGUvV2ViS2l0RGVm aW5lcy5oPgorCitHX0JFR0lOX0RFQ0xTCisKKyNkZWZpbmUgV0VCS0lUX1RZUEVfV0VCU0lURV9E QVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1QgICAgICAgICAgICAod2Via2l0X3dlYnNpdGVf ZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9yZXF1ZXN0X2dldF90eXBlKCkpCisjZGVmaW5lIFdFQktJ VF9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVChvYmopICAgICAgICAgICAg KEdfVFlQRV9DSEVDS19JTlNUQU5DRV9DQVNUKChvYmopLCBXRUJLSVRfVFlQRV9XRUJTSVRFX0RB VEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVCwgV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJt aXNzaW9uUmVxdWVzdCkpCisjZGVmaW5lIFdFQktJVF9JU19XRUJTSVRFX0RBVEFfQUNDRVNTX1BF Uk1JU1NJT05fUkVRVUVTVChvYmopICAgICAgICAgKEdfVFlQRV9DSEVDS19JTlNUQU5DRV9UWVBF KChvYmopLCBXRUJLSVRfVFlQRV9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVT VCkpCisjZGVmaW5lIFdFQktJVF9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVT VF9DTEFTUyhrbGFzcykgICAgKEdfVFlQRV9DSEVDS19DTEFTU19DQVNUKChrbGFzcyksICBXRUJL SVRfVFlQRV9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVCwgV2ViS2l0V2Vi c2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdENsYXNzKSkKKyNkZWZpbmUgV0VCS0lUX0lT X1dFQlNJVEVfREFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNUX0NMQVNTKGtsYXNzKSAoR19U WVBFX0NIRUNLX0NMQVNTX1RZUEUoKGtsYXNzKSwgIFdFQktJVF9UWVBFX1dFQlNJVEVfREFUQV9B Q0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNUKSkKKyNkZWZpbmUgV0VCS0lUX1dFQlNJVEVfREFUQV9B Q0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNUX0dFVF9DTEFTUyhvYmopICAoR19UWVBFX0lOU1RBTkNF X0dFVF9DTEFTUygob2JqKSwgIFdFQktJVF9UWVBFX1dFQlNJVEVfREFUQV9BQ0NFU1NfUEVSTUlT U0lPTl9SRVFVRVNULCBXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0Q2xh c3MpKQorCit0eXBlZGVmIHN0cnVjdCBfV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9u UmVxdWVzdCAgICAgICAgV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdDsK K3R5cGVkZWYgc3RydWN0IF9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0 Q2xhc3MgICBXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0Q2xhc3M7Cit0 eXBlZGVmIHN0cnVjdCBfV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdFBy aXZhdGUgV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdFByaXZhdGU7CisK K3N0cnVjdCBfV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdCB7CisgICAg R09iamVjdCBwYXJlbnQ7CisKKyAgICAvKjwgcHJpdmF0ZSA+Ki8KKyAgICBXZWJLaXRXZWJzaXRl RGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0UHJpdmF0ZSAqcHJpdjsKK307CisKK3N0cnVjdCBf V2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdENsYXNzIHsKKyAgICBHT2Jq ZWN0Q2xhc3MgcGFyZW50X2NsYXNzOworCisgICAgdm9pZCAoKl93ZWJraXRfcmVzZXJ2ZWQwKSAo dm9pZCk7CisgICAgdm9pZCAoKl93ZWJraXRfcmVzZXJ2ZWQxKSAodm9pZCk7CisgICAgdm9pZCAo Kl93ZWJraXRfcmVzZXJ2ZWQyKSAodm9pZCk7CisgICAgdm9pZCAoKl93ZWJraXRfcmVzZXJ2ZWQz KSAodm9pZCk7Cit9OworCitXRUJLSVRfQVBJIEdUeXBlCit3ZWJraXRfd2Vic2l0ZV9kYXRhX2Fj Y2Vzc19wZXJtaXNzaW9uX3JlcXVlc3RfZ2V0X3R5cGUgICAgICAgICAgICAgICh2b2lkKTsKKwor V0VCS0lUX0FQSSBjb25zdCBjaGFyICoKK3dlYmtpdF93ZWJzaXRlX2RhdGFfYWNjZXNzX3Blcm1p c3Npb25fcmVxdWVzdF9nZXRfcmVxdWVzdGluZ19kb21haW4gKFdlYktpdFdlYnNpdGVEYXRhQWNj ZXNzUGVybWlzc2lvblJlcXVlc3QgKnJlcXVlc3QpOworCitXRUJLSVRfQVBJIGNvbnN0IGNoYXIg Kgord2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9yZXF1ZXN0X2dldF9jdXJy ZW50X2RvbWFpbiAgICAoV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdCAq cmVxdWVzdCk7CisKK0dfRU5EX0RFQ0xTCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9VSVByb2Nlc3MvQVBJL3dwZS9kb2NzL3dwZS0xLjAtc2VjdGlvbnMudHh0IGIvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9kb2NzL3dwZS0xLjAtc2VjdGlvbnMudHh0CmluZGV4 IDAyZjQ5YWRkMDU5Yy4uYjk0MjliYjY1ZDAwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9BUEkvd3BlL2RvY3Mvd3BlLTEuMC1zZWN0aW9ucy50eHQKKysrIGIvU291cmNlL1dl YktpdC9VSVByb2Nlc3MvQVBJL3dwZS9kb2NzL3dwZS0xLjAtc2VjdGlvbnMudHh0CkBAIC04NDUs NiArODQ1LDI2IEBAIFdlYktpdE5vdGlmaWNhdGlvblBlcm1pc3Npb25SZXF1ZXN0UHJpdmF0ZQog d2Via2l0X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uX3JlcXVlc3RfZ2V0X3R5cGUKIDwvU0VDVElP Tj4KIAorPFNFQ1RJT04+Cis8RklMRT5XZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25S ZXF1ZXN0PC9GSUxFPgorV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdAor d2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9yZXF1ZXN0X2dldF9yZXF1ZXN0 aW5nX2RvbWFpbgord2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9yZXF1ZXN0 X2dldF9jdXJyZW50X2RvbWFpbgorCis8U1VCU0VDVElPTiBTdGFuZGFyZD4KK1dlYktpdFdlYnNp dGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3RDbGFzcworV0VCS0lUX1RZUEVfV0VCU0lURV9E QVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1QKK1dFQktJVF9XRUJTSVRFX0RBVEFfQUNDRVNT X1BFUk1JU1NJT05fUkVRVUVTVAorV0VCS0lUX0lTX1dFQlNJVEVfREFUQV9BQ0NFU1NfUEVSTUlT U0lPTl9SRVFVRVNUCitXRUJLSVRfV0VCU0lURV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVF U1RfQ0xBU1MKK1dFQktJVF9JU19XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVT VF9DTEFTUworV0VCS0lUX1dFQlNJVEVfREFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNUX0dF VF9DTEFTUworCis8U1VCU0VDVElPTiBQcml2YXRlPgorV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQ ZXJtaXNzaW9uUmVxdWVzdFByaXZhdGUKK3dlYmtpdF93ZWJzaXRlX2RhdGFfYWNjZXNzX3Blcm1p c3Npb25fcmVxdWVzdF9nZXRfdHlwZQorPC9TRUNUSU9OPgorCiA8U0VDVElPTj4KIDxGSUxFPldl YktpdFBvbGljeURlY2lzaW9uPC9GSUxFPgogV2ViS2l0UG9saWN5RGVjaXNpb24KZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUvZG9jcy93cGUtZG9jcy5zZ21sIGIv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9kb2NzL3dwZS1kb2NzLnNnbWwKaW5kZXgg MmVmODAwZmZlZDRkLi4wOWFmNGZjOWJiNGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL0FQSS93cGUvZG9jcy93cGUtZG9jcy5zZ21sCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL0FQSS93cGUvZG9jcy93cGUtZG9jcy5zZ21sCkBAIC02MCw2ICs2MCw3IEBACiAgICAg PHhpOmluY2x1ZGUgaHJlZj0ieG1sL1dlYktpdFVzZXJNZXNzYWdlLnhtbCIvPgogICAgIDx4aTpp bmNsdWRlIGhyZWY9InhtbC9XZWJLaXRJbnB1dE1ldGhvZENvbnRleHQueG1sIi8+CiAgICAgPHhp OmluY2x1ZGUgaHJlZj0ieG1sL1dlYktpdFJlY3RhbmdsZS54bWwiLz4KKyAgICA8eGk6aW5jbHVk ZSBocmVmPSJ4bWwvV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdC54bWwi Lz4KICAgPC9jaGFwdGVyPgogCiAgIDxjaGFwdGVyPgpAQCAtMTAxLDUgKzEwMiwxMCBAQAogICAg IDx4aTppbmNsdWRlIGhyZWY9InhtbC9hcGktaW5kZXgtMi4yOC54bWwiPjx4aTpmYWxsYmFjayAv PjwveGk6aW5jbHVkZT4KICAgPC9pbmRleD4KIAorICA8aW5kZXggaWQ9ImFwaS1pbmRleC0yLTMw IiByb2xlPSIyLjMwIj4KKyAgICA8dGl0bGU+SW5kZXggb2YgbmV3IHN5bWJvbHMgaW4gMi4zMDwv dGl0bGU+CisgICAgPHhpOmluY2x1ZGUgaHJlZj0ieG1sL2FwaS1pbmRleC0yLjMwLnhtbCI+PHhp OmZhbGxiYWNrIC8+PC94aTppbmNsdWRlPgorICA8L2luZGV4PgorCiAgIDx4aTppbmNsdWRlIGhy ZWY9InhtbC9hbm5vdGF0aW9uLWdsb3NzYXJ5LnhtbCI+PHhpOmZhbGxiYWNrIC8+PC94aTppbmNs dWRlPgogPC9ib29rPgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dw ZS93ZWJraXQuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUvd2Via2l0LmgKaW5k ZXggMDJlMjU4MjUzZTQ3Li4yN2M2ODBkNDY0MjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv VUlQcm9jZXNzL0FQSS93cGUvd2Via2l0LmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv QVBJL3dwZS93ZWJraXQuaApAQCAtODQsNiArODQsNyBAQAogI2luY2x1ZGUgPHdwZS9XZWJLaXRX ZWJWaWV3QmFja2VuZC5oPgogI2luY2x1ZGUgPHdwZS9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRl Lmg+CiAjaW5jbHVkZSA8d3BlL1dlYktpdFdlYnNpdGVEYXRhLmg+CisjaW5jbHVkZSA8d3BlL1dl YktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QuaD4KICNpbmNsdWRlIDx3cGUv V2ViS2l0V2Vic2l0ZURhdGFNYW5hZ2VyLmg+CiAjaW5jbHVkZSA8d3BlL1dlYktpdFdpbmRvd1By b3BlcnRpZXMuaD4KIApkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdl TG9nCmluZGV4IGQyOWEwN2YwZjhkZi4uZTg1OWZlNTE5YWQ2IDEwMDY0NAotLS0gYS9Ub29scy9D aGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMjAtMDYt MTIgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgorCisgICAgICAg IFtHVEtdW1dQRV0gQWRkIEFQSSB0byBleHBvc2UgVUlDbGllbnQ6OnJlcXVlc3RTdG9yYWdlQWNj ZXNzQ29uZmlybQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjEwNDIyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgSGFuZGxlIFdlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QgaW4gTWlu aUJyb3dzZXIuCisKKyAgICAgICAgKiBNaW5pQnJvd3Nlci9ndGsvQnJvd3NlclRhYi5jOgorICAg ICAgICAoZGVjaWRlUGVybWlzc2lvblJlcXVlc3QpOgorCiAyMDIwLTA2LTEyICBDYXJsb3MgR2Fy Y2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLiBG aXggR1RLIFdlYkRyaXZlciB0ZXN0cyBhZnRlciByMjYyOTM4CmRpZmYgLS1naXQgYS9Ub29scy9N aW5pQnJvd3Nlci9ndGsvQnJvd3NlclRhYi5jIGIvVG9vbHMvTWluaUJyb3dzZXIvZ3RrL0Jyb3dz ZXJUYWIuYwppbmRleCA5ZTQ0YTVhNTIyOGEuLjEwZTM0NjIwNTY0ZSAxMDA2NDQKLS0tIGEvVG9v bHMvTWluaUJyb3dzZXIvZ3RrL0Jyb3dzZXJUYWIuYworKysgYi9Ub29scy9NaW5pQnJvd3Nlci9n dGsvQnJvd3NlclRhYi5jCkBAIC0zMzMsNiArMzMzLDEzIEBAIHN0YXRpYyBnYm9vbGVhbiBkZWNp ZGVQZXJtaXNzaW9uUmVxdWVzdChXZWJLaXRXZWJWaWV3ICp3ZWJWaWV3LCBXZWJLaXRQZXJtaXNz aW9uCiAgICAgICAgIHRhYi0+cG9pbnRlckxvY2tNZXNzYWdlTGFiZWxJZCA9IGdfdGltZW91dF9h ZGRfc2Vjb25kcygyLCAoR1NvdXJjZUZ1bmMpcG9pbnRlckxvY2tNZXNzYWdlVGltZW91dENhbGxi YWNrLCB0YWIpOwogICAgICAgICBnX3NvdXJjZV9zZXRfbmFtZV9ieV9pZCh0YWItPnBvaW50ZXJM b2NrTWVzc2FnZUxhYmVsSWQsICJbV2ViS2l0XXBvaW50ZXJMb2NrTWVzc2FnZVRpbWVvdXRDYWxs YmFjayIpOwogICAgICAgICByZXR1cm4gVFJVRTsKKyAgICB9IGVsc2UgaWYgKFdFQktJVF9JU19X RUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVChyZXF1ZXN0KSkgeworICAgICAg ICB0aXRsZSA9ICJXZWJzaXRlRGF0YSBhY2Nlc3MgcmVxdWVzdCI7CisgICAgICAgIFdlYktpdFdl YnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QgKndlYnNpdGVEYXRhQWNjZXNzUmVxdWVz dCA9IFdFQktJVF9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVChyZXF1ZXN0 KTsKKyAgICAgICAgY29uc3QgZ2NoYXIgKnJlcXVlc3RpbmdEb21haW4gPSB3ZWJraXRfd2Vic2l0 ZV9kYXRhX2FjY2Vzc19wZXJtaXNzaW9uX3JlcXVlc3RfZ2V0X3JlcXVlc3RpbmdfZG9tYWluKHdl YnNpdGVEYXRhQWNjZXNzUmVxdWVzdCk7CisgICAgICAgIGNvbnN0IGdjaGFyICpjdXJyZW50RG9t YWluID0gd2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9yZXF1ZXN0X2dldF9j dXJyZW50X2RvbWFpbih3ZWJzaXRlRGF0YUFjY2Vzc1JlcXVlc3QpOworICAgICAgICB0ZXh0ID0g Z19zdHJkdXBfcHJpbnRmKCJEbyB5b3Ugd2FudCB0byBhbGxvdyBcIiVzXCIgdG8gdXNlIGNvb2tp ZXMgYW5kIHdlYnNpdGUgZGF0YSB3aGlsZSBicm93c2luZyBcIiVzXCI/IFRoaXMgd2lsbCBhbGxv dyBcIiVzXCIgdG8gdHJhY2sgeW91ciBhY3Rpdml0eSIsCisgICAgICAgICAgICByZXF1ZXN0aW5n RG9tYWluLCBjdXJyZW50RG9tYWluLCByZXF1ZXN0aW5nRG9tYWluKTsKICAgICB9IGVsc2Ugewog ICAgICAgICBnX3ByaW50KCIlcyByZXF1ZXN0IG5vdCBoYW5kbGVkXG4iLCBHX09CSkVDVF9UWVBF X05BTUUocmVxdWVzdCkpOwogICAgICAgICByZXR1cm4gRkFMU0U7Cg== 401888 2020-06-15 01:40:58 -0700 2020-06-15 01:40:58 -0700 Patch for landing wk2-storage-access-permission.diff text/plain 27968 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9DaGFu Z2VMb2cKaW5kZXggMTQ4NzdhOTNiYWNiLi5kN2ZlNWM1YTliNTYgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMzcgQEAKKzIwMjAtMDYtMTIgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2Fs aWEuY29tPgorCisgICAgICAgIFtHVEtdW1dQRV0gQWRkIEFQSSB0byBleHBvc2UgVUlDbGllbnQ6 OnJlcXVlc3RTdG9yYWdlQWNjZXNzQ29uZmlybQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEwNDIyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTWljaGFl bCBDYXRhbnphcm8uCisKKyAgICAgICAgQWRkIFdlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlz c2lvblJlcXVlc3QgdG8gYXNrIGZvciBwZXJtaXNzaW9uIHRvIHRoZSB1c2VyIHVzaW5nIHRoZSBl eGlzdGluZyBwZXJtaXNzaW9uCisgICAgICAgIHJlcXVlc3QgQVBJLgorCisgICAgICAgICogUGxh dGZvcm1HVEsuY21ha2U6CisgICAgICAgICogUGxhdGZvcm1XUEUuY21ha2U6CisgICAgICAgICog U291cmNlc0dUSy50eHQ6CisgICAgICAgICogU291cmNlc1dQRS50eHQ6CisgICAgICAgICogVUlQ cm9jZXNzL0FQSS9nbGliL1dlYktpdFVJQ2xpZW50LmNwcDoKKyAgICAgICAgKiBVSVByb2Nlc3Mv QVBJL2dsaWIvV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdC5jcHA6IEFk ZGVkLgorICAgICAgICAod2Via2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdEFs bG93KToKKyAgICAgICAgKHdlYmtpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3RE ZW55KToKKyAgICAgICAgKHdlYmtpdF9wZXJtaXNzaW9uX3JlcXVlc3RfaW50ZXJmYWNlX2luaXQp OgorICAgICAgICAod2Via2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdERpc3Bv c2UpOgorICAgICAgICAod2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9yZXF1 ZXN0X2NsYXNzX2luaXQpOgorICAgICAgICAod2Via2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNz aW9uUmVxdWVzdENyZWF0ZSk6CisgICAgICAgICh3ZWJraXRfd2Vic2l0ZV9kYXRhX2FjY2Vzc19w ZXJtaXNzaW9uX3JlcXVlc3RfZ2V0X3JlcXVlc3RpbmdfZG9tYWluKToKKyAgICAgICAgKHdlYmtp dF93ZWJzaXRlX2RhdGFfYWNjZXNzX3Blcm1pc3Npb25fcmVxdWVzdF9nZXRfY3VycmVudF9kb21h aW4pOgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vz c1Blcm1pc3Npb25SZXF1ZXN0UHJpdmF0ZS5oOiBBZGRlZC4KKyAgICAgICAgKiBVSVByb2Nlc3Mv QVBJL2d0ay9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0Lmg6IEFkZGVk LgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlv bnMudHh0OgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1kb2Nz LnNnbWw6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvd2Via2l0Mi5oOgorICAgICAgICAq IFVJUHJvY2Vzcy9BUEkvd3BlL1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVl c3QuaDogQWRkZWQuCisgICAgICAgICogVUlQcm9jZXNzL0FQSS93cGUvZG9jcy93cGUtMS4wLXNl Y3Rpb25zLnR4dDoKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL3dwZS9kb2NzL3dwZS1kb2NzLnNn bWw6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS93cGUvd2Via2l0Lmg6CisKIDIwMjAtMDYtMTIg IENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtT T1VQXSBEaXNhYmxlIEhTVFMgZm9yIHJlcXVlc3RzIHdoZW4gY29va2llcyB3aWxsIGJlIGJsb2Nr ZWQgYnkgSVRQCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtR1RLLmNtYWtlIGIv U291cmNlL1dlYktpdC9QbGF0Zm9ybUdUSy5jbWFrZQppbmRleCBiOTQ1MjJjOGZjYTAuLmYwYjYz OWI1YmNlMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybUdUSy5jbWFrZQorKysg Yi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtR1RLLmNtYWtlCkBAIC0xMzgsNiArMTM4LDcgQEAgc2V0 KFdlYktpdDJHVEtfSU5TVEFMTEVEX0hFQURFUlMKICAgICAke1dFQktJVF9ESVJ9L1VJUHJvY2Vz cy9BUEkvZ3RrL1dlYktpdFdlYlZpZXcuaAogICAgICR7V0VCS0lUX0RJUn0vVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZS5oCiAgICAgJHtXRUJLSVRfRElSfS9VSVBy b2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJzaXRlRGF0YS5oCisgICAgJHtXRUJLSVRfRElSfS9VSVBy b2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0LmgK ICAgICAke1dFQktJVF9ESVJ9L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYnNpdGVEYXRhTWFu YWdlci5oCiAgICAgJHtXRUJLSVRfRElSfS9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXaW5kb3dQ cm9wZXJ0aWVzLmgKICAgICAke1dFQktJVF9ESVJ9L1VJUHJvY2Vzcy9BUEkvZ3RrL3dlYmtpdDIu aApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybVdQRS5jbWFrZSBiL1NvdXJjZS9X ZWJLaXQvUGxhdGZvcm1XUEUuY21ha2UKaW5kZXggODMyMGUzMTBlNmM0Li44OWNjN2UzY2RiMjMg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm1XUEUuY21ha2UKKysrIGIvU291cmNl L1dlYktpdC9QbGF0Zm9ybVdQRS5jbWFrZQpAQCAtMTUwLDYgKzE1MCw3IEBAIHNldChXUEVfQVBJ X0lOU1RBTExFRF9IRUFERVJTCiAgICAgJHtXRUJLSVRfRElSfS9VSVByb2Nlc3MvQVBJL3dwZS9X ZWJLaXRXZWJWaWV3QmFja2VuZC5oCiAgICAgJHtXRUJLSVRfRElSfS9VSVByb2Nlc3MvQVBJL3dw ZS9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmgKICAgICAke1dFQktJVF9ESVJ9L1VJUHJvY2Vz cy9BUEkvd3BlL1dlYktpdFdlYnNpdGVEYXRhLmgKKyAgICAke1dFQktJVF9ESVJ9L1VJUHJvY2Vz cy9BUEkvd3BlL1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QuaAogICAg ICR7V0VCS0lUX0RJUn0vVUlQcm9jZXNzL0FQSS93cGUvV2ViS2l0V2Vic2l0ZURhdGFNYW5hZ2Vy LmgKICAgICAke1dFQktJVF9ESVJ9L1VJUHJvY2Vzcy9BUEkvd3BlL1dlYktpdFdpbmRvd1Byb3Bl cnRpZXMuaAogICAgICR7V0VCS0lUX0RJUn0vVUlQcm9jZXNzL0FQSS93cGUvd2Via2l0LmgKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvU291cmNlc0dUSy50eHQgYi9Tb3VyY2UvV2ViS2l0L1Nv dXJjZXNHVEsudHh0CmluZGV4IDJkNWFhYzk1M2FiZS4uNTRmOGZhNDA4MDQ4IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L1NvdXJjZXNHVEsudHh0CisrKyBiL1NvdXJjZS9XZWJLaXQvU291cmNl c0dUSy50eHQKQEAgLTE5MCw2ICsxOTAsNyBAQCBVSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2Vi Vmlldy5jcHAgQG5vLXVuaWZ5CiBVSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2ViVmlld0FjY2Vz c2libGUuY3BwIEBuby11bmlmeQogVUlQcm9jZXNzL0FQSS9nbGliL1dlYktpdFdlYlZpZXdTZXNz aW9uU3RhdGUuY3BwIEBuby11bmlmeQogVUlQcm9jZXNzL0FQSS9nbGliL1dlYktpdFdlYnNpdGVE YXRhLmNwcCBAbm8tdW5pZnkKK1VJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJzaXRlRGF0YUFj Y2Vzc1Blcm1pc3Npb25SZXF1ZXN0LmNwcCBAbm8tdW5pZnkKIFVJUHJvY2Vzcy9BUEkvZ2xpYi9X ZWJLaXRXZWJzaXRlRGF0YU1hbmFnZXIuY3BwIEBuby11bmlmeQogVUlQcm9jZXNzL0FQSS9nbGli L1dlYktpdFdpbmRvd1Byb3BlcnRpZXMuY3BwIEBuby11bmlmeQogCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L1NvdXJjZXNXUEUudHh0IGIvU291cmNlL1dlYktpdC9Tb3VyY2VzV1BFLnR4dApp bmRleCA4YjkzNGU4MWU3NDguLmZiY2ViMDA1MjRlNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dC9Tb3VyY2VzV1BFLnR4dAorKysgYi9Tb3VyY2UvV2ViS2l0L1NvdXJjZXNXUEUudHh0CkBAIC0x NzgsNiArMTc4LDcgQEAgVUlQcm9jZXNzL0FQSS9nbGliL1dlYktpdFdlYlZpZXcuY3BwIEBuby11 bmlmeQogVUlQcm9jZXNzL0FQSS9nbGliL1dlYktpdFdlYlZpZXdBY2Nlc3NpYmxlLmNwcCBAbm8t dW5pZnkKIFVJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmNwcCBA bm8tdW5pZnkKIFVJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJzaXRlRGF0YS5jcHAgQG5vLXVu aWZ5CitVSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9u UmVxdWVzdC5jcHAgQG5vLXVuaWZ5CiBVSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2Vic2l0ZURh dGFNYW5hZ2VyLmNwcCBAbm8tdW5pZnkKIFVJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRXaW5kb3dQ cm9wZXJ0aWVzLmNwcCBAbm8tdW5pZnkKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVBy b2Nlc3MvQVBJL2dsaWIvV2ViS2l0VUlDbGllbnQuY3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvQVBJL2dsaWIvV2ViS2l0VUlDbGllbnQuY3BwCmluZGV4IDM3MzE3MWI2OGY3ZC4uMmNlYjJi NGY0OWY0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJL aXRVSUNsaWVudC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2dsaWIvV2Vi S2l0VUlDbGllbnQuY3BwCkBAIC0zMSw2ICszMSw3IEBACiAjaW5jbHVkZSAiV2ViS2l0VVJJUmVx dWVzdFByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJLaXRVc2VyTWVkaWFQZXJtaXNzaW9uUmVxdWVz dFByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJLaXRXZWJWaWV3UHJpdmF0ZS5oIgorI2luY2x1ZGUg IldlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3RQcml2YXRlLmgiCiAjaW5j bHVkZSAiV2ViS2l0V2luZG93UHJvcGVydGllc1ByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJQYWdl UHJveHkuaCIKICNpbmNsdWRlICJXZWJQcm9jZXNzUHJveHkuaCIKQEAgLTMwMCw2ICszMDEsMTIg QEAgcHJpdmF0ZToKICAgICAgICAgd2Via2l0V2ViVmlld01ha2VQZXJtaXNzaW9uUmVxdWVzdCht X3dlYlZpZXcsIFdFQktJVF9QRVJNSVNTSU9OX1JFUVVFU1Qobm90aWZpY2F0aW9uUGVybWlzc2lv blJlcXVlc3QuZ2V0KCkpKTsKICAgICB9CiAKKyAgICB2b2lkIHJlcXVlc3RTdG9yYWdlQWNjZXNz Q29uZmlybShXZWJQYWdlUHJveHkmLCBXZWJGcmFtZVByb3h5KiwgY29uc3QgV2ViQ29yZTo6UmVn aXN0cmFibGVEb21haW4mIHJlcXVlc3RpbmdEb21haW4sIGNvbnN0IFdlYkNvcmU6OlJlZ2lzdHJh YmxlRG9tYWluJiBjdXJyZW50RG9tYWluLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKGJvb2wpPiYm IGNvbXBsZXRpb25IYW5kbGVyKSBmaW5hbAorICAgIHsKKyAgICAgICAgR1JlZlB0cjxXZWJLaXRX ZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0PiB3ZWJzaXRlRGF0YUFjY2Vzc1Blcm1p c3Npb25SZXF1ZXN0ID0gYWRvcHRHUmVmKHdlYmtpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lv blJlcXVlc3RDcmVhdGUocmVxdWVzdGluZ0RvbWFpbiwgY3VycmVudERvbWFpbiwgV1RGTW92ZShj b21wbGV0aW9uSGFuZGxlcikpKTsKKyAgICAgICAgd2Via2l0V2ViVmlld01ha2VQZXJtaXNzaW9u UmVxdWVzdChtX3dlYlZpZXcsIFdFQktJVF9QRVJNSVNTSU9OX1JFUVVFU1Qod2Vic2l0ZURhdGFB Y2Nlc3NQZXJtaXNzaW9uUmVxdWVzdC5nZXQoKSkpOworICAgIH0KKwogI2lmIFBMQVRGT1JNKEdU SykKICAgICBib29sIHRha2VGb2N1cyhXZWJQYWdlUHJveHkqIHBhZ2UsIFdLRm9jdXNEaXJlY3Rp b24gZGlyZWN0aW9uKSBmaW5hbAogICAgIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL0FQSS9nbGliL1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3Qu Y3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2Vic2l0ZURhdGFB Y2Nlc3NQZXJtaXNzaW9uUmVxdWVzdC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwLi5hYjk5NGRmOGFjZjQKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0 L1VJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1 ZXN0LmNwcApAQCAtMCwwICsxLDEzMiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMCBJZ2Fs aWEgUy5MCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJl ZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiAgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkg dGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiAgdmVyc2lvbiAyIG9mIHRo ZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAq ICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl IHVzZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUg aW1wbGllZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiAgTGVzc2VyIEdlbmVyYWwgUHVi bGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJl Y2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogIExpY2Vu c2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29m dHdhcmUKKyAqICBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZs b29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqLworCisjaW5jbHVkZSAiY29uZmln LmgiCisjaW5jbHVkZSAiV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdC5o IgorCisjaW5jbHVkZSAiV2ViS2l0UGVybWlzc2lvblJlcXVlc3QuaCIKKyNpbmNsdWRlICJXZWJL aXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0UHJpdmF0ZS5oIgorI2luY2x1ZGUg PHd0Zi9Db21wbGV0aW9uSGFuZGxlci5oPgorI2luY2x1ZGUgPHd0Zi9nbGliL1dURkdUeXBlLmg+ CisKKy8qKgorICogU0VDVElPTjogV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVx dWVzdAorICogQFNob3J0X2Rlc2NyaXB0aW9uOiBBIHBlcm1pc3Npb24gcmVxdWVzdCBmb3IgYWNj ZXNzaW5nIHdlYnNpdGUgZGF0YSBmcm9tIHRoaXJkLXBhcnR5IGRvbWFpbnMKKyAqIEBUaXRsZTog V2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdAorICogQFNlZV9hbHNvOiAj V2ViS2l0UGVybWlzc2lvblJlcXVlc3QsICNXZWJLaXRXZWJWaWV3CisgKgorICogV2ViS2l0V2Vi c2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdCByZXByZXNlbnRzIGEgcmVxdWVzdCBmb3IK KyAqIHBlcm1pc3Npb24gdG8gYWxsb3cgYSB0aGlyZC1wYXJ0eSBkb21haW4gYWNjZXNzIGl0cyBj b29raWVzLgorICoKKyAqIFdoZW4gYSBXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25S ZXF1ZXN0IGlzIG5vdCBoYW5kbGVkIGJ5IHRoZSB1c2VyLAorICogaXQgaXMgZGVuaWVkIGJ5IGRl ZmF1bHQuCisgKgorICogU2luY2U6IDIuMzAKKyAqLworCitzdGF0aWMgdm9pZCB3ZWJraXRfcGVy bWlzc2lvbl9yZXF1ZXN0X2ludGVyZmFjZV9pbml0KFdlYktpdFBlcm1pc3Npb25SZXF1ZXN0SWZh Y2UqKTsKKworc3RydWN0IF9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0 UHJpdmF0ZSB7CisgICAgQ1N0cmluZyByZXF1ZXN0aW5nRG9tYWluOworICAgIENTdHJpbmcgY3Vy cmVudERvbWFpbjsKKyAgICBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKGJvb2wpPiBjb21wbGV0aW9u SGFuZGxlcjsKK307CisKK1dFQktJVF9ERUZJTkVfVFlQRV9XSVRIX0NPREUoCisgICAgV2ViS2l0 V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdCwgd2Via2l0X3dlYnNpdGVfZGF0YV9h Y2Nlc3NfcGVybWlzc2lvbl9yZXF1ZXN0LCBHX1RZUEVfT0JKRUNULAorICAgIEdfSU1QTEVNRU5U X0lOVEVSRkFDRShXRUJLSVRfVFlQRV9QRVJNSVNTSU9OX1JFUVVFU1QsIHdlYmtpdF9wZXJtaXNz aW9uX3JlcXVlc3RfaW50ZXJmYWNlX2luaXQpKQorCitzdGF0aWMgdm9pZCB3ZWJraXRXZWJzaXRl RGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0QWxsb3coV2ViS2l0UGVybWlzc2lvblJlcXVlc3Qq IHJlcXVlc3QpCit7CisgICAgQVNTRVJUKFdFQktJVF9JU19XRUJTSVRFX0RBVEFfQUNDRVNTX1BF Uk1JU1NJT05fUkVRVUVTVChyZXF1ZXN0KSk7CisKKyAgICBhdXRvKiBwcml2ID0gV0VCS0lUX1dF QlNJVEVfREFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNUKHJlcXVlc3QpLT5wcml2OworICAg IGlmIChwcml2LT5jb21wbGV0aW9uSGFuZGxlcikKKyAgICAgICAgcHJpdi0+Y29tcGxldGlvbkhh bmRsZXIodHJ1ZSk7Cit9CisKK3N0YXRpYyB2b2lkIHdlYmtpdFdlYnNpdGVEYXRhQWNjZXNzUGVy bWlzc2lvblJlcXVlc3REZW55KFdlYktpdFBlcm1pc3Npb25SZXF1ZXN0KiByZXF1ZXN0KQorewor ICAgIEFTU0VSVChXRUJLSVRfSVNfV0VCU0lURV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVF U1QocmVxdWVzdCkpOworCisgICAgYXV0byogcHJpdiA9IFdFQktJVF9XRUJTSVRFX0RBVEFfQUND RVNTX1BFUk1JU1NJT05fUkVRVUVTVChyZXF1ZXN0KS0+cHJpdjsKKyAgICBpZiAocHJpdi0+Y29t cGxldGlvbkhhbmRsZXIpCisgICAgICAgIHByaXYtPmNvbXBsZXRpb25IYW5kbGVyKGZhbHNlKTsK K30KKworc3RhdGljIHZvaWQgd2Via2l0X3Blcm1pc3Npb25fcmVxdWVzdF9pbnRlcmZhY2VfaW5p dChXZWJLaXRQZXJtaXNzaW9uUmVxdWVzdElmYWNlKiBpZmFjZSkKK3sKKyAgICBpZmFjZS0+YWxs b3cgPSB3ZWJraXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0QWxsb3c7CisgICAg aWZhY2UtPmRlbnkgPSB3ZWJraXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0RGVu eTsKK30KKworc3RhdGljIHZvaWQgd2Via2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVx dWVzdERpc3Bvc2UoR09iamVjdCogb2JqZWN0KQoreworICAgIC8vIERlZmF1bHQgYmVoYXZpb3Vy IHdoZW4gbm8gZGVjaXNpb24gaGFzIGJlZW4gbWFkZSBpcyBkZW55aW5nIHRoZSByZXF1ZXN0Lgor ICAgIHdlYmtpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3REZW55KFdFQktJVF9Q RVJNSVNTSU9OX1JFUVVFU1Qob2JqZWN0KSk7CisgICAgR19PQkpFQ1RfQ0xBU1Mod2Via2l0X3dl YnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9yZXF1ZXN0X3BhcmVudF9jbGFzcyktPmRpc3Bv c2Uob2JqZWN0KTsKK30KKworc3RhdGljIHZvaWQgd2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nlc3Nf cGVybWlzc2lvbl9yZXF1ZXN0X2NsYXNzX2luaXQoV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJt aXNzaW9uUmVxdWVzdENsYXNzKiBrbGFzcykKK3sKKyAgICBHT2JqZWN0Q2xhc3MqIG9iamVjdENs YXNzID0gR19PQkpFQ1RfQ0xBU1Moa2xhc3MpOworICAgIG9iamVjdENsYXNzLT5kaXNwb3NlID0g d2Via2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdERpc3Bvc2U7Cit9CisKK1dl YktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QqIHdlYmtpdFdlYnNpdGVEYXRh QWNjZXNzUGVybWlzc2lvblJlcXVlc3RDcmVhdGUoY29uc3QgV2ViQ29yZTo6UmVnaXN0cmFibGVE b21haW4mIHJlcXVlc3RpbmdEb21haW4sIGNvbnN0IFdlYkNvcmU6OlJlZ2lzdHJhYmxlRG9tYWlu JiBjdXJyZW50RG9tYWluLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKGJvb2wpPiYmIGNvbXBsZXRp b25IYW5kbGVyKQoreworICAgIGF1dG8qIHdlYnNpdGVEYXRhUGVybWlzc2lvblJlcXVlc3QgPSBX RUJLSVRfV0VCU0lURV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1QoZ19vYmplY3RfbmV3 KFdFQktJVF9UWVBFX1dFQlNJVEVfREFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNULCBudWxs cHRyKSk7CisgICAgd2Vic2l0ZURhdGFQZXJtaXNzaW9uUmVxdWVzdC0+cHJpdi0+cmVxdWVzdGlu Z0RvbWFpbiA9IHJlcXVlc3RpbmdEb21haW4uc3RyaW5nKCkudXRmOCgpOworICAgIHdlYnNpdGVE YXRhUGVybWlzc2lvblJlcXVlc3QtPnByaXYtPmN1cnJlbnREb21haW4gPSBjdXJyZW50RG9tYWlu LnN0cmluZygpLnV0ZjgoKTsKKyAgICB3ZWJzaXRlRGF0YVBlcm1pc3Npb25SZXF1ZXN0LT5wcml2 LT5jb21wbGV0aW9uSGFuZGxlciA9IFdURk1vdmUoY29tcGxldGlvbkhhbmRsZXIpOworICAgIHJl dHVybiB3ZWJzaXRlRGF0YVBlcm1pc3Npb25SZXF1ZXN0OworfQorCisvKioKKyAqIHdlYmtpdF93 ZWJzaXRlX2RhdGFfYWNjZXNzX3Blcm1pc3Npb25fcmVxdWVzdF9nZXRfcmVxdWVzdGluZ19kb21h aW46CisgKiBAcmVxdWVzdDogYSAjV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVx dWVzdAorICoKKyAqIEdldCB0aGUgZG9tYWluIHJlcXVlc3RpbmcgcGVybWlzc2lvbiB0byBhY2Nl c3MgaXRzIGNvb2tpZXMgd2hpbGUgYnJvd3NpbmcgdGhlIGN1cnJlbnQgZG9tYWluLgorICoKKyAq IFJldHVybnM6IHRoZSByZXF1ZXN0aW5nIGRvbWFpbiBuYW1lCisgKgorICogU2luY2U6IDIuMzAK KyAqLworY29uc3QgY2hhciogd2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9y ZXF1ZXN0X2dldF9yZXF1ZXN0aW5nX2RvbWFpbihXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1p c3Npb25SZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJ VF9JU19XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVChyZXF1ZXN0KSwgbnVs bHB0cik7CisKKyAgICByZXR1cm4gcmVxdWVzdC0+cHJpdi0+cmVxdWVzdGluZ0RvbWFpbi5kYXRh KCk7Cit9CisKKy8qKgorICogd2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9y ZXF1ZXN0X2dldF9jdXJyZW50X2RvbWFpbjoKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXRXZWJzaXRl RGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0CisgKgorICogR2V0IHRoZSBjdXJyZW50IGRvbWFp biBiZWluZyBicm93c2VkLgorICoKKyAqIFJldHVybnM6IHRoZSBjdXJyZW50IGRvbWFpbiBuYW1l CisgKgorICogU2luY2U6IDIuMzAKKyAqLworY29uc3QgY2hhciogd2Via2l0X3dlYnNpdGVfZGF0 YV9hY2Nlc3NfcGVybWlzc2lvbl9yZXF1ZXN0X2dldF9jdXJyZW50X2RvbWFpbihXZWJLaXRXZWJz aXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGdfcmV0dXJu X3ZhbF9pZl9mYWlsKFdFQktJVF9JU19XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVR VUVTVChyZXF1ZXN0KSwgbnVsbHB0cik7CisKKyAgICByZXR1cm4gcmVxdWVzdC0+cHJpdi0+Y3Vy cmVudERvbWFpbi5kYXRhKCk7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9BUEkvZ2xpYi9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0UHJpdmF0 ZS5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2Vic2l0ZURhdGFB Y2Nlc3NQZXJtaXNzaW9uUmVxdWVzdFByaXZhdGUuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAuLmRlYzcyMThhYmZjMAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL0FQSS9nbGliL1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lv blJlcXVlc3RQcml2YXRlLmgKQEAgLTAsMCArMSwyNCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykg MjAyMCBJZ2FsaWEgUy5MCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5 b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRl cm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiAgTGljZW5zZSBhcyBwdWJs aXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiAgdmVyc2lv biAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9u LgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBp dCB3aWxsIGJlIHVzZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQg ZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiAgTGVzc2VyIEdl bmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3Vs ZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYwor ICogIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhl IEZyZWUgU29mdHdhcmUKKyAqICBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQs IEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqLworCisjcHJhZ21h IG9uY2UKKworI2luY2x1ZGUgIldlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVl c3QuaCIKKyNpbmNsdWRlIDxXZWJDb3JlL1JlZ2lzdHJhYmxlRG9tYWluLmg+CisKK1dlYktpdFdl YnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QqIHdlYmtpdFdlYnNpdGVEYXRhQWNjZXNz UGVybWlzc2lvblJlcXVlc3RDcmVhdGUoY29uc3QgV2ViQ29yZTo6UmVnaXN0cmFibGVEb21haW4m IHJlcXVlc3RpbmdEb21haW4sIGNvbnN0IFdlYkNvcmU6OlJlZ2lzdHJhYmxlRG9tYWluJiBjdXJy ZW50RG9tYWluLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKGJvb2wpPiYmKTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQ ZXJtaXNzaW9uUmVxdWVzdC5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0LmgKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwLi45MWFjNTViZmU1MmIKLS0tIC9kZXYvbnVsbAorKysgYi9T b3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVy bWlzc2lvblJlcXVlc3QuaApAQCAtMCwwICsxLDY5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDIwIElnYWxpYSBTLkwKKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlv dSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVy bXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFzIHB1Ymxp c2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqICB2ZXJzaW9u IDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24u CisgKgorICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0 IHdpbGwgYmUgdXNlZnVsLAorICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBl dmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5F U1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMZXNzZXIgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqICBZb3Ugc2hvdWxk IGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisg KiAgTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUg RnJlZSBTb2Z0d2FyZQorICogIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwg RmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICovCisKKyNpZiAhZGVm aW5lZChfX1dFQktJVDJfSF9JTlNJREVfXykgJiYgIWRlZmluZWQoV0VCS0lUMl9DT01QSUxBVElP TikKKyNlcnJvciAiT25seSA8d2Via2l0Mi93ZWJraXQyLmg+IGNhbiBiZSBpbmNsdWRlZCBkaXJl Y3RseS4iCisjZW5kaWYKKworI2lmbmRlZiBXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Np b25SZXF1ZXN0X2gKKyNkZWZpbmUgV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVx dWVzdF9oCisKKyNpbmNsdWRlIDxnbGliLW9iamVjdC5oPgorI2luY2x1ZGUgPHdlYmtpdDIvV2Vi S2l0RGVmaW5lcy5oPgorCitHX0JFR0lOX0RFQ0xTCisKKyNkZWZpbmUgV0VCS0lUX1RZUEVfV0VC U0lURV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1QgICAgICAgICAgICAod2Via2l0X3dl YnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9yZXF1ZXN0X2dldF90eXBlKCkpCisjZGVmaW5l IFdFQktJVF9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVChvYmopICAgICAg ICAgICAgKEdfVFlQRV9DSEVDS19JTlNUQU5DRV9DQVNUKChvYmopLCBXRUJLSVRfVFlQRV9XRUJT SVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVCwgV2ViS2l0V2Vic2l0ZURhdGFBY2Nl c3NQZXJtaXNzaW9uUmVxdWVzdCkpCisjZGVmaW5lIFdFQktJVF9JU19XRUJTSVRFX0RBVEFfQUND RVNTX1BFUk1JU1NJT05fUkVRVUVTVChvYmopICAgICAgICAgKEdfVFlQRV9DSEVDS19JTlNUQU5D RV9UWVBFKChvYmopLCBXRUJLSVRfVFlQRV9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05f UkVRVUVTVCkpCisjZGVmaW5lIFdFQktJVF9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05f UkVRVUVTVF9DTEFTUyhrbGFzcykgICAgKEdfVFlQRV9DSEVDS19DTEFTU19DQVNUKChrbGFzcyks ICBXRUJLSVRfVFlQRV9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVCwgV2Vi S2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdENsYXNzKSkKKyNkZWZpbmUgV0VC S0lUX0lTX1dFQlNJVEVfREFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNUX0NMQVNTKGtsYXNz KSAoR19UWVBFX0NIRUNLX0NMQVNTX1RZUEUoKGtsYXNzKSwgIFdFQktJVF9UWVBFX1dFQlNJVEVf REFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNUKSkKKyNkZWZpbmUgV0VCS0lUX1dFQlNJVEVf REFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNUX0dFVF9DTEFTUyhvYmopICAoR19UWVBFX0lO U1RBTkNFX0dFVF9DTEFTUygob2JqKSwgIFdFQktJVF9UWVBFX1dFQlNJVEVfREFUQV9BQ0NFU1Nf UEVSTUlTU0lPTl9SRVFVRVNULCBXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1 ZXN0Q2xhc3MpKQorCit0eXBlZGVmIHN0cnVjdCBfV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJt aXNzaW9uUmVxdWVzdCAgICAgICAgV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVx dWVzdDsKK3R5cGVkZWYgc3RydWN0IF9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25S ZXF1ZXN0Q2xhc3MgICBXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0Q2xh c3M7Cit0eXBlZGVmIHN0cnVjdCBfV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVx dWVzdFByaXZhdGUgV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdFByaXZh dGU7CisKK3N0cnVjdCBfV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdCB7 CisgICAgR09iamVjdCBwYXJlbnQ7CisKKyAgICAvKjwgcHJpdmF0ZSA+Ki8KKyAgICBXZWJLaXRX ZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0UHJpdmF0ZSAqcHJpdjsKK307CisKK3N0 cnVjdCBfV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdENsYXNzIHsKKyAg ICBHT2JqZWN0Q2xhc3MgcGFyZW50X2NsYXNzOworCisgICAgdm9pZCAoKl93ZWJraXRfcmVzZXJ2 ZWQwKSAodm9pZCk7CisgICAgdm9pZCAoKl93ZWJraXRfcmVzZXJ2ZWQxKSAodm9pZCk7CisgICAg dm9pZCAoKl93ZWJraXRfcmVzZXJ2ZWQyKSAodm9pZCk7CisgICAgdm9pZCAoKl93ZWJraXRfcmVz ZXJ2ZWQzKSAodm9pZCk7Cit9OworCitXRUJLSVRfQVBJIEdUeXBlCit3ZWJraXRfd2Vic2l0ZV9k YXRhX2FjY2Vzc19wZXJtaXNzaW9uX3JlcXVlc3RfZ2V0X3R5cGUgICAgICAgICAgICAgICh2b2lk KTsKKworV0VCS0lUX0FQSSBjb25zdCBjaGFyICoKK3dlYmtpdF93ZWJzaXRlX2RhdGFfYWNjZXNz X3Blcm1pc3Npb25fcmVxdWVzdF9nZXRfcmVxdWVzdGluZ19kb21haW4gKFdlYktpdFdlYnNpdGVE YXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QgKnJlcXVlc3QpOworCitXRUJLSVRfQVBJIGNvbnN0 IGNoYXIgKgord2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9yZXF1ZXN0X2dl dF9jdXJyZW50X2RvbWFpbiAgICAoV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVx dWVzdCAqcmVxdWVzdCk7CisKK0dfRU5EX0RFQ0xTCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstNC4wLXNlY3Rpb25z LnR4dCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLTQu MC1zZWN0aW9ucy50eHQKaW5kZXggNDgyYjA2Y2VjZmExLi5jMDA1NTQ2ZjAwYzkgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLTQuMC1z ZWN0aW9ucy50eHQKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dl YmtpdDJndGstNC4wLXNlY3Rpb25zLnR4dApAQCAtODQxLDYgKzg0MSwyNiBAQCBXZWJLaXROb3Rp ZmljYXRpb25QZXJtaXNzaW9uUmVxdWVzdFByaXZhdGUKIHdlYmtpdF9ub3RpZmljYXRpb25fcGVy bWlzc2lvbl9yZXF1ZXN0X2dldF90eXBlCiA8L1NFQ1RJT04+CiAKKzxTRUNUSU9OPgorPEZJTEU+ V2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdDwvRklMRT4KK1dlYktpdFdl YnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QKK3dlYmtpdF93ZWJzaXRlX2RhdGFfYWNj ZXNzX3Blcm1pc3Npb25fcmVxdWVzdF9nZXRfcmVxdWVzdGluZ19kb21haW4KK3dlYmtpdF93ZWJz aXRlX2RhdGFfYWNjZXNzX3Blcm1pc3Npb25fcmVxdWVzdF9nZXRfY3VycmVudF9kb21haW4KKwor PFNVQlNFQ1RJT04gU3RhbmRhcmQ+CitXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25S ZXF1ZXN0Q2xhc3MKK1dFQktJVF9UWVBFX1dFQlNJVEVfREFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9S RVFVRVNUCitXRUJLSVRfV0VCU0lURV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1QKK1dF QktJVF9JU19XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVAorV0VCS0lUX1dF QlNJVEVfREFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNUX0NMQVNTCitXRUJLSVRfSVNfV0VC U0lURV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1RfQ0xBU1MKK1dFQktJVF9XRUJTSVRF X0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVF9HRVRfQ0xBU1MKKworPFNVQlNFQ1RJT04g UHJpdmF0ZT4KK1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3RQcml2YXRl Cit3ZWJraXRfd2Vic2l0ZV9kYXRhX2FjY2Vzc19wZXJtaXNzaW9uX3JlcXVlc3RfZ2V0X3R5cGUK KzwvU0VDVElPTj4KKwogPFNFQ1RJT04+CiA8RklMRT5XZWJLaXRQb2xpY3lEZWNpc2lvbjwvRklM RT4KIFdlYktpdFBvbGljeURlY2lzaW9uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1kb2NzLnNnbWwgYi9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1kb2NzLnNnbWwKaW5kZXggODY5MmNjNTUx OTRkLi5kOGFjODIzMzMyZjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQ SS9ndGsvZG9jcy93ZWJraXQyZ3RrLWRvY3Muc2dtbAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1kb2NzLnNnbWwKQEAgLTY2LDYgKzY2LDcgQEAK ICAgICA8eGk6aW5jbHVkZSBocmVmPSJ4bWwvV2ViS2l0VXNlck1lc3NhZ2UueG1sIi8+CiAgICAg PHhpOmluY2x1ZGUgaHJlZj0ieG1sL1dlYktpdFBvaW50ZXJMb2NrUGVybWlzc2lvblJlcXVlc3Qu eG1sIi8+CiAgICAgPHhpOmluY2x1ZGUgaHJlZj0ieG1sL1dlYktpdElucHV0TWV0aG9kQ29udGV4 dC54bWwiLz4KKyAgICA8eGk6aW5jbHVkZSBocmVmPSJ4bWwvV2ViS2l0V2Vic2l0ZURhdGFBY2Nl c3NQZXJtaXNzaW9uUmVxdWVzdC54bWwiLz4KICAgPC9jaGFwdGVyPgogCiAgIDxjaGFwdGVyPgpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay93ZWJraXQyLmggYi9T b3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ3RrL3dlYmtpdDIuaAppbmRleCA5MzBiMTdiNjYy OWUuLmMzNTgxMTgzNjBhMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJ L2d0ay93ZWJraXQyLmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay93ZWJr aXQyLmgKQEAgLTkwLDYgKzkwLDcgQEAKICNpbmNsdWRlIDx3ZWJraXQyL1dlYktpdFdlYlZpZXdC YXNlLmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmg+CiAj aW5jbHVkZSA8d2Via2l0Mi9XZWJLaXRXZWJzaXRlRGF0YS5oPgorI2luY2x1ZGUgPHdlYmtpdDIv V2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdC5oPgogI2luY2x1ZGUgPHdl YmtpdDIvV2ViS2l0V2Vic2l0ZURhdGFNYW5hZ2VyLmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJL aXRXaW5kb3dQcm9wZXJ0aWVzLmg+CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL0FQSS93cGUvV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdC5oIGIv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Bl cm1pc3Npb25SZXF1ZXN0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw Li5mNzhkYjAxZjUyNWIKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9BUEkvd3BlL1dlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QuaApAQCAt MCwwICsxLDY5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDIwIElnYWxpYSBTLkwKKyAqCisg KiAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgorICogIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIg R2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9y IChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogIFRoaXMgbGlicmFy eSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICog IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBm b3IgbW9yZSBkZXRhaWxzLgorICoKKyAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5 IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiAgTGljZW5zZSBhbG9uZyB3aXRo IHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogIEZv dW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsIEJvc3Rvbiwg TUEgIDAyMTEwLTEzMDEgIFVTQQorICovCisKKyNpZiAhZGVmaW5lZChfX1dFQktJVF9IX0lOU0lE RV9fKSAmJiAhZGVmaW5lZChXRUJLSVQyX0NPTVBJTEFUSU9OKQorI2Vycm9yICJPbmx5IDx3cGUv d2Via2l0Lmg+IGNhbiBiZSBpbmNsdWRlZCBkaXJlY3RseS4iCisjZW5kaWYKKworI2lmbmRlZiBX ZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0X2gKKyNkZWZpbmUgV2ViS2l0 V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdF9oCisKKyNpbmNsdWRlIDxnbGliLW9i amVjdC5oPgorI2luY2x1ZGUgPHdwZS9XZWJLaXREZWZpbmVzLmg+CisKK0dfQkVHSU5fREVDTFMK KworI2RlZmluZSBXRUJLSVRfVFlQRV9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVR VUVTVCAgICAgICAgICAgICh3ZWJraXRfd2Vic2l0ZV9kYXRhX2FjY2Vzc19wZXJtaXNzaW9uX3Jl cXVlc3RfZ2V0X3R5cGUoKSkKKyNkZWZpbmUgV0VCS0lUX1dFQlNJVEVfREFUQV9BQ0NFU1NfUEVS TUlTU0lPTl9SRVFVRVNUKG9iaikgICAgICAgICAgICAoR19UWVBFX0NIRUNLX0lOU1RBTkNFX0NB U1QoKG9iaiksIFdFQktJVF9UWVBFX1dFQlNJVEVfREFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFV RVNULCBXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0KSkKKyNkZWZpbmUg V0VCS0lUX0lTX1dFQlNJVEVfREFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNUKG9iaikgICAg ICAgICAoR19UWVBFX0NIRUNLX0lOU1RBTkNFX1RZUEUoKG9iaiksIFdFQktJVF9UWVBFX1dFQlNJ VEVfREFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNUKSkKKyNkZWZpbmUgV0VCS0lUX1dFQlNJ VEVfREFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNUX0NMQVNTKGtsYXNzKSAgICAoR19UWVBF X0NIRUNLX0NMQVNTX0NBU1QoKGtsYXNzKSwgIFdFQktJVF9UWVBFX1dFQlNJVEVfREFUQV9BQ0NF U1NfUEVSTUlTU0lPTl9SRVFVRVNULCBXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25S ZXF1ZXN0Q2xhc3MpKQorI2RlZmluZSBXRUJLSVRfSVNfV0VCU0lURV9EQVRBX0FDQ0VTU19QRVJN SVNTSU9OX1JFUVVFU1RfQ0xBU1Moa2xhc3MpIChHX1RZUEVfQ0hFQ0tfQ0xBU1NfVFlQRSgoa2xh c3MpLCAgV0VCS0lUX1RZUEVfV0VCU0lURV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1Qp KQorI2RlZmluZSBXRUJLSVRfV0VCU0lURV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1Rf R0VUX0NMQVNTKG9iaikgIChHX1RZUEVfSU5TVEFOQ0VfR0VUX0NMQVNTKChvYmopLCAgV0VCS0lU X1RZUEVfV0VCU0lURV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1QsIFdlYktpdFdlYnNp dGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3RDbGFzcykpCisKK3R5cGVkZWYgc3RydWN0IF9X ZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0ICAgICAgICBXZWJLaXRXZWJz aXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0OwordHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFdl YnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3RDbGFzcyAgIFdlYktpdFdlYnNpdGVEYXRh QWNjZXNzUGVybWlzc2lvblJlcXVlc3RDbGFzczsKK3R5cGVkZWYgc3RydWN0IF9XZWJLaXRXZWJz aXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0UHJpdmF0ZSBXZWJLaXRXZWJzaXRlRGF0YUFj Y2Vzc1Blcm1pc3Npb25SZXF1ZXN0UHJpdmF0ZTsKKworc3RydWN0IF9XZWJLaXRXZWJzaXRlRGF0 YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0IHsKKyAgICBHT2JqZWN0IHBhcmVudDsKKworICAgIC8q PCBwcml2YXRlID4qLworICAgIFdlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVl c3RQcml2YXRlICpwcml2OworfTsKKworc3RydWN0IF9XZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Bl cm1pc3Npb25SZXF1ZXN0Q2xhc3MgeworICAgIEdPYmplY3RDbGFzcyBwYXJlbnRfY2xhc3M7CisK KyAgICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDApICh2b2lkKTsKKyAgICB2b2lkICgqX3dlYmtp dF9yZXNlcnZlZDEpICh2b2lkKTsKKyAgICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDIpICh2b2lk KTsKKyAgICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDMpICh2b2lkKTsKK307CisKK1dFQktJVF9B UEkgR1R5cGUKK3dlYmtpdF93ZWJzaXRlX2RhdGFfYWNjZXNzX3Blcm1pc3Npb25fcmVxdWVzdF9n ZXRfdHlwZSAgICAgICAgICAgICAgKHZvaWQpOworCitXRUJLSVRfQVBJIGNvbnN0IGNoYXIgKgor d2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9yZXF1ZXN0X2dldF9yZXF1ZXN0 aW5nX2RvbWFpbiAoV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdCAqcmVx dWVzdCk7CisKK1dFQktJVF9BUEkgY29uc3QgY2hhciAqCit3ZWJraXRfd2Vic2l0ZV9kYXRhX2Fj Y2Vzc19wZXJtaXNzaW9uX3JlcXVlc3RfZ2V0X2N1cnJlbnRfZG9tYWluICAgIChXZWJLaXRXZWJz aXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0ICpyZXF1ZXN0KTsKKworR19FTkRfREVDTFMK KworI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvd3BlL2Rv Y3Mvd3BlLTEuMC1zZWN0aW9ucy50eHQgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvd3Bl L2RvY3Mvd3BlLTEuMC1zZWN0aW9ucy50eHQKaW5kZXggMDJmNDlhZGQwNTljLi5iOTQyOWJiNjVk MDAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUvZG9jcy93cGUt MS4wLXNlY3Rpb25zLnR4dAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvd3BlL2Rv Y3Mvd3BlLTEuMC1zZWN0aW9ucy50eHQKQEAgLTg0NSw2ICs4NDUsMjYgQEAgV2ViS2l0Tm90aWZp Y2F0aW9uUGVybWlzc2lvblJlcXVlc3RQcml2YXRlCiB3ZWJraXRfbm90aWZpY2F0aW9uX3Blcm1p c3Npb25fcmVxdWVzdF9nZXRfdHlwZQogPC9TRUNUSU9OPgogCis8U0VDVElPTj4KKzxGSUxFPldl YktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3Q8L0ZJTEU+CitXZWJLaXRXZWJz aXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0Cit3ZWJraXRfd2Vic2l0ZV9kYXRhX2FjY2Vz c19wZXJtaXNzaW9uX3JlcXVlc3RfZ2V0X3JlcXVlc3RpbmdfZG9tYWluCit3ZWJraXRfd2Vic2l0 ZV9kYXRhX2FjY2Vzc19wZXJtaXNzaW9uX3JlcXVlc3RfZ2V0X2N1cnJlbnRfZG9tYWluCisKKzxT VUJTRUNUSU9OIFN0YW5kYXJkPgorV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVx dWVzdENsYXNzCitXRUJLSVRfVFlQRV9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVR VUVTVAorV0VCS0lUX1dFQlNJVEVfREFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNUCitXRUJL SVRfSVNfV0VCU0lURV9EQVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1QKK1dFQktJVF9XRUJT SVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVF9DTEFTUworV0VCS0lUX0lTX1dFQlNJ VEVfREFUQV9BQ0NFU1NfUEVSTUlTU0lPTl9SRVFVRVNUX0NMQVNTCitXRUJLSVRfV0VCU0lURV9E QVRBX0FDQ0VTU19QRVJNSVNTSU9OX1JFUVVFU1RfR0VUX0NMQVNTCisKKzxTVUJTRUNUSU9OIFBy aXZhdGU+CitXZWJLaXRXZWJzaXRlRGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0UHJpdmF0ZQor d2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lvbl9yZXF1ZXN0X2dldF90eXBlCis8 L1NFQ1RJT04+CisKIDxTRUNUSU9OPgogPEZJTEU+V2ViS2l0UG9saWN5RGVjaXNpb248L0ZJTEU+ CiBXZWJLaXRQb2xpY3lEZWNpc2lvbgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvQVBJL3dwZS9kb2NzL3dwZS1kb2NzLnNnbWwgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9B UEkvd3BlL2RvY3Mvd3BlLWRvY3Muc2dtbAppbmRleCAyZWY4MDBmZmVkNGQuLjA5YWY0ZmM5YmI0 ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9kb2NzL3dwZS1k b2NzLnNnbWwKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9kb2NzL3dwZS1k b2NzLnNnbWwKQEAgLTYwLDYgKzYwLDcgQEAKICAgICA8eGk6aW5jbHVkZSBocmVmPSJ4bWwvV2Vi S2l0VXNlck1lc3NhZ2UueG1sIi8+CiAgICAgPHhpOmluY2x1ZGUgaHJlZj0ieG1sL1dlYktpdElu cHV0TWV0aG9kQ29udGV4dC54bWwiLz4KICAgICA8eGk6aW5jbHVkZSBocmVmPSJ4bWwvV2ViS2l0 UmVjdGFuZ2xlLnhtbCIvPgorICAgIDx4aTppbmNsdWRlIGhyZWY9InhtbC9XZWJLaXRXZWJzaXRl RGF0YUFjY2Vzc1Blcm1pc3Npb25SZXF1ZXN0LnhtbCIvPgogICA8L2NoYXB0ZXI+CiAKICAgPGNo YXB0ZXI+CkBAIC0xMDEsNSArMTAyLDEwIEBACiAgICAgPHhpOmluY2x1ZGUgaHJlZj0ieG1sL2Fw aS1pbmRleC0yLjI4LnhtbCI+PHhpOmZhbGxiYWNrIC8+PC94aTppbmNsdWRlPgogICA8L2luZGV4 PgogCisgIDxpbmRleCBpZD0iYXBpLWluZGV4LTItMzAiIHJvbGU9IjIuMzAiPgorICAgIDx0aXRs ZT5JbmRleCBvZiBuZXcgc3ltYm9scyBpbiAyLjMwPC90aXRsZT4KKyAgICA8eGk6aW5jbHVkZSBo cmVmPSJ4bWwvYXBpLWluZGV4LTIuMzAueG1sIj48eGk6ZmFsbGJhY2sgLz48L3hpOmluY2x1ZGU+ CisgIDwvaW5kZXg+CisKICAgPHhpOmluY2x1ZGUgaHJlZj0ieG1sL2Fubm90YXRpb24tZ2xvc3Nh cnkueG1sIj48eGk6ZmFsbGJhY2sgLz48L3hpOmluY2x1ZGU+CiA8L2Jvb2s+CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvd3BlL3dlYmtpdC5oIGIvU291cmNlL1dlYktp dC9VSVByb2Nlc3MvQVBJL3dwZS93ZWJraXQuaAppbmRleCAwMmUyNTgyNTNlNDcuLjI3YzY4MGQ0 NjQyOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS93ZWJraXQu aAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvd3BlL3dlYmtpdC5oCkBAIC04NCw2 ICs4NCw3IEBACiAjaW5jbHVkZSA8d3BlL1dlYktpdFdlYlZpZXdCYWNrZW5kLmg+CiAjaW5jbHVk ZSA8d3BlL1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuaD4KICNpbmNsdWRlIDx3cGUvV2ViS2l0 V2Vic2l0ZURhdGEuaD4KKyNpbmNsdWRlIDx3cGUvV2ViS2l0V2Vic2l0ZURhdGFBY2Nlc3NQZXJt aXNzaW9uUmVxdWVzdC5oPgogI2luY2x1ZGUgPHdwZS9XZWJLaXRXZWJzaXRlRGF0YU1hbmFnZXIu aD4KICNpbmNsdWRlIDx3cGUvV2ViS2l0V2luZG93UHJvcGVydGllcy5oPgogCmRpZmYgLS1naXQg YS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggMjMyNDYwODdjZTM4Li44 NGJlMTBhMjcxYjQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFu Z2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAyMC0wNi0xMiAgQ2FybG9zIEdhcmNpYSBDYW1wb3Mg IDxjZ2FyY2lhQGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS11bV1BFXSBBZGQgQVBJIHRvIGV4 cG9zZSBVSUNsaWVudDo6cmVxdWVzdFN0b3JhZ2VBY2Nlc3NDb25maXJtCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTA0MjIKKworICAgICAgICBSZXZp ZXdlZCBieSBNaWNoYWVsIENhdGFuemFyby4KKworICAgICAgICBIYW5kbGUgV2ViS2l0V2Vic2l0 ZURhdGFBY2Nlc3NQZXJtaXNzaW9uUmVxdWVzdCBpbiBNaW5pQnJvd3Nlci4KKworICAgICAgICAq IE1pbmlCcm93c2VyL2d0ay9Ccm93c2VyVGFiLmM6CisgICAgICAgIChkZWNpZGVQZXJtaXNzaW9u UmVxdWVzdCk6CisKIDIwMjAtMDYtMTMgIFNhYW0gQmFyYXRpICA8c2JhcmF0aUBhcHBsZS5jb20+ CiAKICAgICAgICAgY29tcGFyZS1yZXN1bHRzIHNob3VsZCBoYXZlIGFuIG9wdGlvbiB0byBwcmlu dCBhIGJyZWFrZG93biBhbmQgdG8gc2F2ZSB0aGUgYnJlYWtkb3duIGFzIGNzdiBmaWxlCmRpZmYg LS1naXQgYS9Ub29scy9NaW5pQnJvd3Nlci9ndGsvQnJvd3NlclRhYi5jIGIvVG9vbHMvTWluaUJy b3dzZXIvZ3RrL0Jyb3dzZXJUYWIuYwppbmRleCA5ZTQ0YTVhNTIyOGEuLjM4NDVlYWJiYTNlOSAx MDA2NDQKLS0tIGEvVG9vbHMvTWluaUJyb3dzZXIvZ3RrL0Jyb3dzZXJUYWIuYworKysgYi9Ub29s cy9NaW5pQnJvd3Nlci9ndGsvQnJvd3NlclRhYi5jCkBAIC0zMzMsNiArMzMzLDEzIEBAIHN0YXRp YyBnYm9vbGVhbiBkZWNpZGVQZXJtaXNzaW9uUmVxdWVzdChXZWJLaXRXZWJWaWV3ICp3ZWJWaWV3 LCBXZWJLaXRQZXJtaXNzaW9uCiAgICAgICAgIHRhYi0+cG9pbnRlckxvY2tNZXNzYWdlTGFiZWxJ ZCA9IGdfdGltZW91dF9hZGRfc2Vjb25kcygyLCAoR1NvdXJjZUZ1bmMpcG9pbnRlckxvY2tNZXNz YWdlVGltZW91dENhbGxiYWNrLCB0YWIpOwogICAgICAgICBnX3NvdXJjZV9zZXRfbmFtZV9ieV9p ZCh0YWItPnBvaW50ZXJMb2NrTWVzc2FnZUxhYmVsSWQsICJbV2ViS2l0XXBvaW50ZXJMb2NrTWVz c2FnZVRpbWVvdXRDYWxsYmFjayIpOwogICAgICAgICByZXR1cm4gVFJVRTsKKyAgICB9IGVsc2Ug aWYgKFdFQktJVF9JU19XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05fUkVRVUVTVChyZXF1 ZXN0KSkgeworICAgICAgICB0aXRsZSA9ICJXZWJzaXRlRGF0YSBhY2Nlc3MgcmVxdWVzdCI7Cisg ICAgICAgIFdlYktpdFdlYnNpdGVEYXRhQWNjZXNzUGVybWlzc2lvblJlcXVlc3QgKndlYnNpdGVE YXRhQWNjZXNzUmVxdWVzdCA9IFdFQktJVF9XRUJTSVRFX0RBVEFfQUNDRVNTX1BFUk1JU1NJT05f UkVRVUVTVChyZXF1ZXN0KTsKKyAgICAgICAgY29uc3QgZ2NoYXIgKnJlcXVlc3RpbmdEb21haW4g PSB3ZWJraXRfd2Vic2l0ZV9kYXRhX2FjY2Vzc19wZXJtaXNzaW9uX3JlcXVlc3RfZ2V0X3JlcXVl c3RpbmdfZG9tYWluKHdlYnNpdGVEYXRhQWNjZXNzUmVxdWVzdCk7CisgICAgICAgIGNvbnN0IGdj aGFyICpjdXJyZW50RG9tYWluID0gd2Via2l0X3dlYnNpdGVfZGF0YV9hY2Nlc3NfcGVybWlzc2lv bl9yZXF1ZXN0X2dldF9jdXJyZW50X2RvbWFpbih3ZWJzaXRlRGF0YUFjY2Vzc1JlcXVlc3QpOwor ICAgICAgICB0ZXh0ID0gZ19zdHJkdXBfcHJpbnRmKCJEbyB5b3Ugd2FudCB0byBhbGxvdyBcIiVz XCIgdG8gdXNlIGNvb2tpZXMgd2hpbGUgYnJvd3NpbmcgXCIlc1wiPyBUaGlzIHdpbGwgYWxsb3cg XCIlc1wiIHRvIHRyYWNrIHlvdXIgYWN0aXZpdHkiLAorICAgICAgICAgICAgcmVxdWVzdGluZ0Rv bWFpbiwgY3VycmVudERvbWFpbiwgcmVxdWVzdGluZ0RvbWFpbik7CiAgICAgfSBlbHNlIHsKICAg ICAgICAgZ19wcmludCgiJXMgcmVxdWVzdCBub3QgaGFuZGxlZFxuIiwgR19PQkpFQ1RfVFlQRV9O QU1FKHJlcXVlc3QpKTsKICAgICAgICAgcmV0dXJuIEZBTFNFOwo=