188742 2018-08-20 05:09:53 -0700 [GLIB] Expose JavaScriptCore options in GLib public API 2019-01-24 03:11:29 -0800 1 1 1 Unclassified WebKit JavaScriptCore WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 cgarcia webkit-unassigned aperez bugs-noreply mcatanzaro webkit-bug-importer ysuzuki oldest_to_newest 1451571 0 cgarcia 2018-08-20 05:09:53 -0700 I think it would be useful to expose the JSC options in the API. Right now it's possible to change them using the env vars, but it would be better to provide some API. To ensure API/ABI stability we could use a common interface to set the options, that receive the option string identifier and the value, similar to the GtkPrintSettings API, for example. Main problem is that users don't know the options available, so we could provide names for the most important options, like we do in WebKit2 API with editing commands. We could also include API to get information about the options available (name, value type, default value and description). Applications could use that to create command line options to set them, for example. JSCOptions* jsc_options_get (void); // Get the singleton instance gboolean jsc_options_set_string (JSCOptions* options, const char* option, const char* value); char* jsc_options_get_string (JSCOptions* options, const char* option); gboolean jsc_options_set_int (JSCOptions* options, const char* option, gint value); int jsc_options_get_int (JSCOptions* options, const char* option); ...... typedef gboolean (* JSCOptionsFunc) (JSCOptions* options, const char* option, GType type, GValue* default_value, const char* description, gpointer user_data); void jsc_options_foreach (JSCOptions* options, JSCOptionsFunc function, gpointer user_data); /** * JSC_OPTION_USE_JIT: * * Allows the executable pages to be allocated for JIT and thunks if %TRUE. * Type: %G_TYPE_BOOLEAN * Default: %TRUE */ #define JSC_OPTION_USE_JIT "useJIT" It would be something like that. 1451580 1 aperez 2018-08-20 05:52:09 -0700 (In reply to Carlos Garcia Campos from comment #0) > I think it would be useful to expose the JSC options in the API. Right now > it's possible to change them using the env vars, but it would be better to > provide some API. To ensure API/ABI stability we could use a common > interface to set the options, that receive the option string identifier and > the value, similar to the GtkPrintSettings API, for example. Main problem is > that users don't know the options available, so we could provide names for > the most important options, like we do in WebKit2 API with editing commands. > We could also include API to get information about the options available > (name, value type, default value and description). Applications could use > that to create command line options to set them, for example. > > JSCOptions* jsc_options_get (void); // Get the singleton instance > gboolean jsc_options_set_string (JSCOptions* options, const char* option, > const char* value); > char* jsc_options_get_string (JSCOptions* options, const char* option); > gboolean jsc_options_set_int (JSCOptions* options, const char* option, gint > value); > int jsc_options_get_int (JSCOptions* options, const char* option); > ...... > typedef gboolean (* JSCOptionsFunc) (JSCOptions* options, const char* > option, GType type, GValue* default_value, const char* description, gpointer > user_data); > void jsc_options_foreach (JSCOptions* options, JSCOptionsFunc function, > gpointer user_data); This being like this, it is like a mini-object system, so I wonder whether it would make more sense to make JSCSettings a class which inherits from GObject and make each option a property instead: * jsc_options_get_{string,int,bool,…} → g_object_get * jsc_options_set_{string,int,bool,…} → g_object_set * jsc_options_foreach → g_object_class_list_properties ...and so on. > /** > * JSC_OPTION_USE_JIT: > * > * Allows the executable pages to be allocated for JIT and thunks if %TRUE. > * Type: %G_TYPE_BOOLEAN > * Default: %TRUE > */ > #define JSC_OPTION_USE_JIT "useJIT" > > It would be something like that. It looks to me that we could even generate the code of such JSCOptions class making use of the JSC_OPTIONS() macro to autogenerate the parts of the jsc_options_class_init() which install the properties, and have a helper function to convert “someOptionName” internal camel-cased option names to GObject style snake-case “some-option-name” strings. Note that JSC_OPTIONS() even includes descriptions for the options, so those could be used when instantiating the GParamSpecs for the properties and then the option descriptions will automatically get picked by gtk-doc. I think that even if the generated JSCOptions class does not have the jsc_options_set_some_option() and jsc_options_get_some_option() methods, the GObject properties functions will work well: JSCOptions *options = jsc_options_get (); g_object_set (options, "use-jit", FALSE, NULL); If additional type safety there is desired, one can use g_object_setv() and g_object_getv(), too. Or is there any reason I am missing to not reuse the existing GObject properties machinery? Also: Maybe I would call this “JSCSettings”, to keep the name consist with “WebKitSettings”. 1451581 2 cgarcia 2018-08-20 06:03:49 -0700 (In reply to Adrian Perez from comment #1) > (In reply to Carlos Garcia Campos from comment #0) > > I think it would be useful to expose the JSC options in the API. Right now > > it's possible to change them using the env vars, but it would be better to > > provide some API. To ensure API/ABI stability we could use a common > > interface to set the options, that receive the option string identifier and > > the value, similar to the GtkPrintSettings API, for example. Main problem is > > that users don't know the options available, so we could provide names for > > the most important options, like we do in WebKit2 API with editing commands. > > We could also include API to get information about the options available > > (name, value type, default value and description). Applications could use > > that to create command line options to set them, for example. > > > > JSCOptions* jsc_options_get (void); // Get the singleton instance > > gboolean jsc_options_set_string (JSCOptions* options, const char* option, > > const char* value); > > char* jsc_options_get_string (JSCOptions* options, const char* option); > > gboolean jsc_options_set_int (JSCOptions* options, const char* option, gint > > value); > > int jsc_options_get_int (JSCOptions* options, const char* option); > > ...... > > typedef gboolean (* JSCOptionsFunc) (JSCOptions* options, const char* > > option, GType type, GValue* default_value, const char* description, gpointer > > user_data); > > void jsc_options_foreach (JSCOptions* options, JSCOptionsFunc function, > > gpointer user_data); > > This being like this, it is like a mini-object system, so I wonder whether it > would make more sense to make JSCSettings a class which inherits from GObject > and make each option a property instead: > > * jsc_options_get_{string,int,bool,…} → g_object_get > * jsc_options_set_{string,int,bool,…} → g_object_set > * jsc_options_foreach → g_object_class_list_properties > > ...and so on. That would require to define all the options at compile time. Any option name change or type or removal would break the API. > > /** > > * JSC_OPTION_USE_JIT: > > * > > * Allows the executable pages to be allocated for JIT and thunks if %TRUE. > > * Type: %G_TYPE_BOOLEAN > > * Default: %TRUE > > */ > > #define JSC_OPTION_USE_JIT "useJIT" > > > > It would be something like that. > > It looks to me that we could even generate the code of such JSCOptions > class making use of the JSC_OPTIONS() macro to autogenerate the parts of > the jsc_options_class_init() which install the properties, and have a > helper function to convert “someOptionName” internal camel-cased option > names to GObject style snake-case “some-option-name” strings. Note that > JSC_OPTIONS() even includes descriptions for the options, so those could > be used when instantiating the GParamSpecs for the properties and then > the option descriptions will automatically get picked by gtk-doc. > > I think that even if the generated JSCOptions class does not have the > jsc_options_set_some_option() and jsc_options_get_some_option() methods, > the GObject properties functions will work well: > > JSCOptions *options = jsc_options_get (); > g_object_set (options, "use-jit", FALSE, NULL); Yes, without the public getter/setter, it might work. > If additional type safety there is desired, one can use g_object_setv() > and g_object_getv(), too. > > Or is there any reason I am missing to not reuse the existing GObject > properties machinery? My initial idea was to use GObject properties indeed, similar to WebKitSettings. API stability was my main concern. > Also: Maybe I would call this “JSCSettings”, to keep the name consist > with “WebKitSettings”. Also thought about it, but I'm not sure. JSC options are not like WebKit settings, so we don't really need to be consistent. In the case of JSC, options are normally set at the very beginning of the program execution and never changed again. 1451598 3 aperez 2018-08-20 07:21:19 -0700 (In reply to Carlos Garcia Campos from comment #2) > (In reply to Adrian Perez from comment #1) > > (In reply to Carlos Garcia Campos from comment #0) > > > I think it would be useful to expose the JSC options in the API. Right now > > > it's possible to change them using the env vars, but it would be better to > > > provide some API. To ensure API/ABI stability we could use a common > > > interface to set the options, that receive the option string identifier and > > > the value, similar to the GtkPrintSettings API, for example. Main problem is > > > that users don't know the options available, so we could provide names for > > > the most important options, like we do in WebKit2 API with editing commands. > > > We could also include API to get information about the options available > > > (name, value type, default value and description). Applications could use > > > that to create command line options to set them, for example. > > > > > > JSCOptions* jsc_options_get (void); // Get the singleton instance > > > gboolean jsc_options_set_string (JSCOptions* options, const char* option, > > > const char* value); > > > char* jsc_options_get_string (JSCOptions* options, const char* option); > > > gboolean jsc_options_set_int (JSCOptions* options, const char* option, gint > > > value); > > > int jsc_options_get_int (JSCOptions* options, const char* option); > > > ...... > > > typedef gboolean (* JSCOptionsFunc) (JSCOptions* options, const char* > > > option, GType type, GValue* default_value, const char* description, gpointer > > > user_data); > > > void jsc_options_foreach (JSCOptions* options, JSCOptionsFunc function, > > > gpointer user_data); > > > > This being like this, it is like a mini-object system, so I wonder whether it > > would make more sense to make JSCSettings a class which inherits from GObject > > and make each option a property instead: > > > > * jsc_options_get_{string,int,bool,…} → g_object_get > > * jsc_options_set_{string,int,bool,…} → g_object_set > > * jsc_options_foreach → g_object_class_list_properties > > > > ...and so on. > > That would require to define all the options at compile time. Any option > name change or type or removal would break the API. If we provide a #define for each common option, those could also change in between releases. If an option is renamed, we can change the #define, but for options removed, added, or the option type changed, the API would be broken with your suggested approach as well. So no matter which of both approaches is implemented, the API can break between releases. The only way of preventing that in both cases is avoiding to merge JSC patches in stable release branches that include changes to the JSC options — and allowing changes in between major releases. > > > /** > > > * JSC_OPTION_USE_JIT: > > > * > > > * Allows the executable pages to be allocated for JIT and thunks if %TRUE. > > > * Type: %G_TYPE_BOOLEAN > > > * Default: %TRUE > > > */ > > > #define JSC_OPTION_USE_JIT "useJIT" > > > > > > It would be something like that. > > > > It looks to me that we could even generate the code of such JSCOptions > > class making use of the JSC_OPTIONS() macro to autogenerate the parts of > > the jsc_options_class_init() which install the properties, and have a > > helper function to convert “someOptionName” internal camel-cased option > > names to GObject style snake-case “some-option-name” strings. Note that > > JSC_OPTIONS() even includes descriptions for the options, so those could > > be used when instantiating the GParamSpecs for the properties and then > > the option descriptions will automatically get picked by gtk-doc. > > > > I think that even if the generated JSCOptions class does not have the > > jsc_options_set_some_option() and jsc_options_get_some_option() methods, > > the GObject properties functions will work well: > > > > JSCOptions *options = jsc_options_get (); > > g_object_set (options, "use-jit", FALSE, NULL); > > Yes, without the public getter/setter, it might work. > > > If additional type safety there is desired, one can use g_object_setv() > > and g_object_getv(), too. > > > > Or is there any reason I am missing to not reuse the existing GObject > > properties machinery? > > My initial idea was to use GObject properties indeed, similar to > WebKitSettings. API stability was my main concern. As I outlined above, the approach you suggested has exactly the same potential API stability issues as using GObject properties. Therefore I would go with the solution that feels more natural in a GLib/GObject API and use object properties. > > Also: Maybe I would call this “JSCSettings”, to keep the name consist > > with “WebKitSettings”. > > Also thought about it, but I'm not sure. JSC options are not like WebKit > settings, so we don't really need to be consistent. In the case of JSC, > options are normally set at the very beginning of the program execution and > never changed again. FWIW, I have nothing against the “JSCOptions” name. If you think using it helps to make it clearer that they are intended to be set once at start (in contrast to a “FooSettings” name), then let's use it :-) 1451990 4 cgarcia 2018-08-20 23:37:25 -0700 (In reply to Adrian Perez from comment #3) > (In reply to Carlos Garcia Campos from comment #2) > > (In reply to Adrian Perez from comment #1) > > > (In reply to Carlos Garcia Campos from comment #0) > > > > I think it would be useful to expose the JSC options in the API. Right now > > > > it's possible to change them using the env vars, but it would be better to > > > > provide some API. To ensure API/ABI stability we could use a common > > > > interface to set the options, that receive the option string identifier and > > > > the value, similar to the GtkPrintSettings API, for example. Main problem is > > > > that users don't know the options available, so we could provide names for > > > > the most important options, like we do in WebKit2 API with editing commands. > > > > We could also include API to get information about the options available > > > > (name, value type, default value and description). Applications could use > > > > that to create command line options to set them, for example. > > > > > > > > JSCOptions* jsc_options_get (void); // Get the singleton instance > > > > gboolean jsc_options_set_string (JSCOptions* options, const char* option, > > > > const char* value); > > > > char* jsc_options_get_string (JSCOptions* options, const char* option); > > > > gboolean jsc_options_set_int (JSCOptions* options, const char* option, gint > > > > value); > > > > int jsc_options_get_int (JSCOptions* options, const char* option); > > > > ...... > > > > typedef gboolean (* JSCOptionsFunc) (JSCOptions* options, const char* > > > > option, GType type, GValue* default_value, const char* description, gpointer > > > > user_data); > > > > void jsc_options_foreach (JSCOptions* options, JSCOptionsFunc function, > > > > gpointer user_data); > > > > > > This being like this, it is like a mini-object system, so I wonder whether it > > > would make more sense to make JSCSettings a class which inherits from GObject > > > and make each option a property instead: > > > > > > * jsc_options_get_{string,int,bool,…} → g_object_get > > > * jsc_options_set_{string,int,bool,…} → g_object_set > > > * jsc_options_foreach → g_object_class_list_properties > > > > > > ...and so on. > > > > That would require to define all the options at compile time. Any option > > name change or type or removal would break the API. > > If we provide a #define for each common option, those could also change > in between releases. If an option is renamed, we can change the #define, > but for options removed, added, or the option type changed, the API would > be broken with your suggested approach as well. > > So no matter which of both approaches is implemented, the API can break > between releases. The only way of preventing that in both cases is avoiding > to merge JSC patches in stable release branches that include changes to the > JSC options — and allowing changes in between major releases. But in the case of not autogenerated code, we would only provide macros for a few common options, that are more unlikely to change. We can deal with changes in any case, we have experience with that when the DOM bindings were autogenerated, and that's the main reason why I want to avoid generated code here :-) I don't know how we could deal with range options using properties, unless we consider them a string of the form begin:end and parse it. With explicit API we could simply add get/set_range (options, begin, end); > > > > /** > > > > * JSC_OPTION_USE_JIT: > > > > * > > > > * Allows the executable pages to be allocated for JIT and thunks if %TRUE. > > > > * Type: %G_TYPE_BOOLEAN > > > > * Default: %TRUE > > > > */ > > > > #define JSC_OPTION_USE_JIT "useJIT" > > > > > > > > It would be something like that. > > > > > > It looks to me that we could even generate the code of such JSCOptions > > > class making use of the JSC_OPTIONS() macro to autogenerate the parts of > > > the jsc_options_class_init() which install the properties, and have a > > > helper function to convert “someOptionName” internal camel-cased option > > > names to GObject style snake-case “some-option-name” strings. Note that > > > JSC_OPTIONS() even includes descriptions for the options, so those could > > > be used when instantiating the GParamSpecs for the properties and then > > > the option descriptions will automatically get picked by gtk-doc. > > > > > > I think that even if the generated JSCOptions class does not have the > > > jsc_options_set_some_option() and jsc_options_get_some_option() methods, > > > the GObject properties functions will work well: > > > > > > JSCOptions *options = jsc_options_get (); > > > g_object_set (options, "use-jit", FALSE, NULL); > > > > Yes, without the public getter/setter, it might work. > > > > > If additional type safety there is desired, one can use g_object_setv() > > > and g_object_getv(), too. > > > > > > Or is there any reason I am missing to not reuse the existing GObject > > > properties machinery? > > > > My initial idea was to use GObject properties indeed, similar to > > WebKitSettings. API stability was my main concern. > > As I outlined above, the approach you suggested has exactly the same > potential API stability issues as using GObject properties. Not exactly the same, an option rename wouldn't be a problem without auto-generated properties. And again, the amount of options with a name in the API would be low. > Therefore > I would go with the solution that feels more natural in a GLib/GObject > API and use object properties. I'm not sure an object with no public API but a getter for the global instance is "natural" :-) I know GObject properties are also public API, but still. > > > Also: Maybe I would call this “JSCSettings”, to keep the name consist > > > with “WebKitSettings”. > > > > Also thought about it, but I'm not sure. JSC options are not like WebKit > > settings, so we don't really need to be consistent. In the case of JSC, > > options are normally set at the very beginning of the program execution and > > never changed again. > > FWIW, I have nothing against the “JSCOptions” name. If you think using it > helps to make it clearer that they are intended to be set once at start > (in contrast to a “FooSettings” name), then let's use it :-) I'm not sure either, but I'm sure we don't need to be consistent with the web view settings. 1453444 5 aperez 2018-08-24 07:31:15 -0700 (In reply to Carlos Garcia Campos from comment #4) > (In reply to Adrian Perez from comment #3) > > (In reply to Carlos Garcia Campos from comment #2) > > > (In reply to Adrian Perez from comment #1) > > > > (In reply to Carlos Garcia Campos from comment #0) > > > > [...] > > > > So no matter which of both approaches is implemented, the API can break > > between releases. The only way of preventing that in both cases is avoiding > > to merge JSC patches in stable release branches that include changes to the > > JSC options — and allowing changes in between major releases. > > But in the case of not autogenerated code, we would only provide macros for > a few common options, that are more unlikely to change. We can deal with > changes in any case, we have experience with that when the DOM bindings were > autogenerated, and that's the main reason why I want to avoid generated code > here :-) I don't know how we could deal with range options using properties, > unless we consider them a string of the form begin:end and parse it. With > explicit API we could simply add get/set_range (options, begin, end); Fair enough! Let's not autogenerate the code then. > > > > > /** > > > > > * JSC_OPTION_USE_JIT: > > > > > * > > > > > * Allows the executable pages to be allocated for JIT and thunks if %TRUE. > > > > > * Type: %G_TYPE_BOOLEAN > > > > > * Default: %TRUE > > > > > */ > > > > > #define JSC_OPTION_USE_JIT "useJIT" > > > > > > > > > > It would be something like that. > > > > > > > > It looks to me that we could even generate the code of such JSCOptions > > > > class making use of the JSC_OPTIONS() macro to autogenerate the parts of > > > > the jsc_options_class_init() which install the properties, and have a > > > > helper function to convert “someOptionName” internal camel-cased option > > > > names to GObject style snake-case “some-option-name” strings. Note that > > > > JSC_OPTIONS() even includes descriptions for the options, so those could > > > > be used when instantiating the GParamSpecs for the properties and then > > > > the option descriptions will automatically get picked by gtk-doc. > > > > > > > > I think that even if the generated JSCOptions class does not have the > > > > jsc_options_set_some_option() and jsc_options_get_some_option() methods, > > > > the GObject properties functions will work well: > > > > > > > > JSCOptions *options = jsc_options_get (); > > > > g_object_set (options, "use-jit", FALSE, NULL); > > > > > > Yes, without the public getter/setter, it might work. > > > > > > > If additional type safety there is desired, one can use g_object_setv() > > > > and g_object_getv(), too. > > > > > > > > Or is there any reason I am missing to not reuse the existing GObject > > > > properties machinery? > > > > > > My initial idea was to use GObject properties indeed, similar to > > > WebKitSettings. API stability was my main concern. > > > > As I outlined above, the approach you suggested has exactly the same > > potential API stability issues as using GObject properties. > > Not exactly the same, an option rename wouldn't be a problem without > auto-generated properties. And again, the amount of options with a name in > the API would be low. But the API would still allow setting the options for which we do not add a “#define JSC_OPTION_FOO”, right? I would rather not allow that behaviour. > > Therefore > > I would go with the solution that feels more natural in a GLib/GObject > > API and use object properties. > > I'm not sure an object with no public API but a getter for the global > instance is "natural" :-) I know GObject properties are also public API, but > still. Now that you have convinced me about *not* autogenerating code, I guess it's not much use exposing the properties either ;-) 1453513 6 mcatanzaro 2018-08-24 11:46:58 -0700 I agree with Carlos: if the available options can change and go away in the future, then the API should be string-based so that client applications understand that setting an option is best-effort only and not guaranteed to work in the future. 1457002 7 349005 cgarcia 2018-09-06 00:21:23 -0700 Created attachment 349005 WIP This patch is almost finished. It includes all the API required, but it doesn't expose the well known options yet. Yusuke, what jsc options do you think we should expose and document? 1457030 8 349005 aperez 2018-09-06 04:37:12 -0700 Comment on attachment 349005 WIP View in context: https://bugs.webkit.org/attachment.cgi?id=349005&action=review Informal r+ from me, with nits: there's a few typos in the documentation comments, and a couple of places where formatting could be improved, but functionality wise the patch LGTM. > Source/JavaScriptCore/API/glib/JSCOptions.cpp:36 > + * API call. Most of the options are only useful for testing and degungging. Typo: deggunging → debugging > Source/JavaScriptCore/API/glib/JSCOptions.cpp:38 > + * your own risk (you can find the list of options in WebKit source code). Grammar: …in WebKit source code → …in the WebKit source code. > Source/JavaScriptCore/API/glib/JSCOptions.cpp:484 > + * format [!]<low>[:<high>] where low and high are #guint values. Probably I would set the format string with monospaced font, to make it stand out in the generated documentation, putting the string inside a <tt> or <code> block would do. > Source/JavaScriptCore/API/glib/JSCOptions.cpp:486 > + * the range, unless ! is used to invert the range. Same, I would use <code>!</code> so the sign does not go unnoticed when reading through the documentation. > Source/JavaScriptCore/API/glib/JSCOptions.cpp:512 > + * the range, unless ! is used to invert the range. Same as above regarding using <tt> or <code> for the format string and the ! sign. > Source/JavaScriptCore/API/glib/JSCOptions.cpp:587 > + * @description: (nullable): the option description, or %NULL Probably it would be worth adding a note mentioning that the option descriptions are only in English and not localized (I think that's the case, right?) > Source/JavaScriptCore/API/glib/JSCOptions.cpp:592 > + * Returns: %TRUE to top the iteration, or %FALSE otherwise Typo: top → stop > Source/JavaScriptCore/API/glib/JSCOptions.cpp:641 > + * jsc-<option>=<value>. The group is set up to automatically set the #JSCOptions I think this is missing the double-dash at the front of the option name: --jsc-<option>=<value> — and as with the others above, I would put the command line example string into <tt> or <code> element. > Source/JavaScriptCore/API/glib/JSCOptions.cpp:642 > + * on parsing, applications only need to pass the group to g_option_context_add_group(). Maybe it's only me, by “automatically set the JSCOptions on parsing” did not make me realize what is exactly done, and only after reading the code below and seeing that each generated GOptionEntry is assigned a callback I realized what it means. If I may suggest a different wording, I would use something like: “Each entry in the returned #GOptionGroup is configured to apply the corresponding setting during command line parsing. Applications only need to pass the returned group to g_option_context_add_group(), and the rest will be taken care for automatically.” Dunno, I am not a native English speaker anyway, so maybe your wording is fine, or a better one than ours is possible ;-) 1457059 9 349021 cgarcia 2018-09-06 06:44:02 -0700 Created attachment 349021 WIP Thanks for the review Adrian, I think I've addressed all the comments. 1457453 10 349021 aperez 2018-09-07 02:49:41 -0700 Comment on attachment 349021 WIP View in context: https://bugs.webkit.org/attachment.cgi?id=349021&action=review There's just one tiny typo, otherwise LGTM. Regarding the list of options for which it may be interesting to provide documented symbols, after taking a look at “Options.h”, I would start with the following (all of them I *think* are unlikely to disappear any time soon): - dumpOptions: Useful to see what's enabled/disabled, because options can have implications, and (un)setting some of them can trigger switching others. - configFile: Well, handy to set many options at once *and* the location of the JSC log file, which AFAIK cannot be set in any other way. - useJIT: Because applications which don't do much JS may want to have a one-stop option to disable the whole JIT machinery and save some resources (e.g. embedding a Web view in an e-mail client, where there shouldn't be ever many scripts.) - useWebAssembly: I guess some applications may want to disable the WebAssembly machinery. Not super sure about this one, though. It would be interesting to have some feedback from people who work more often in JSC on the list above, maybe Caitlin and/or Yusuke have some suggestions. > Source/JavaScriptCore/API/glib/JSCOptions.cpp:37 > + * Only a few of them are documented, you can use the undocummented options at Typo, accidental double “m”: undocummented → undocumented > Source/JavaScriptCore/API/glib/JSCOptions.cpp:484 > + * format <emphasis>[!]&lt;low&gt;[:&lt;high&gt;]</emphasis> where low and high are #guint values. I see you used <emphasis> in the end, which is fine. Good catch with the XML escaping using &entities; :D 1494584 11 359149 cgarcia 2019-01-15 02:33:51 -0800 Created attachment 359149 Patch 1497539 12 359149 mcatanzaro 2019-01-23 13:34:21 -0800 Comment on attachment 359149 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=359149&action=review Sorry it took me much longer than usual to get to this. The options are global, not specific to a particular VM? For the options JSC_OPTIONS_USE_JIT, JSC_OPTIONS_USE_DFG, JSC_OPTIONS_USE_FTL, and JSC_OPTIONS_USE_LLINT, it would be nice to have a little bit more documentation. The only one library users are likely to understand is the plain JIT, and even then we should probabyl explain it a little bit. DGF, FTL, and LLINT are probably just alphabet soup even to experienced developers, unless you're familiar with WebKit internals. Lastly... use-case. You used to require that new APIs be used by a real application. Do you have plans to use it somewhere? Surely not adding API just for the sake of it? > Source/JavaScriptCore/API/glib/JSCOptions.cpp:33 > + * JavaScript options allow to change the behavior of the JavaScript engine. allow changing > Source/JavaScriptCore/API/glib/JSCOptions.cpp:37 > + * Only a few of them are documented, you can use the undocumented options at documented; > Source/JavaScriptCore/API/glib/JSCOptions.cpp:38 > + * your own risk (you can find the list of options in the WebKit source code). your own risk. (You can find the list of options in the WebKit source code.) > Source/JavaScriptCore/API/glib/JSCOptions.cpp:52 > +typedef int32_t int32; > +typedef size_t size; typedefs are fine, but a more modern/natural way would be: using int32 = int32_t; using size = size_t; I guess these are for use by the FOR_EACH options macros? > Tools/TestWebKitAPI/Tests/JavaScriptCore/glib/TestJSC.cpp:3376 > + "--jsc-configFile=/tmp/bar", Does the config file actually get created by the tests? I assume not, since you're not actually running any JS. But if so, it should be cleaned. 1497773 13 cgarcia 2019-01-24 03:07:30 -0800 (In reply to Michael Catanzaro from comment #12) > Comment on attachment 359149 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=359149&action=review > > Sorry it took me much longer than usual to get to this. No problem. > The options are global, not specific to a particular VM? Global. > For the options JSC_OPTIONS_USE_JIT, JSC_OPTIONS_USE_DFG, > JSC_OPTIONS_USE_FTL, and JSC_OPTIONS_USE_LLINT, it would be nice to have a > little bit more documentation. The only one library users are likely to > understand is the plain JIT, and even then we should probabyl explain it a > little bit. DGF, FTL, and LLINT are probably just alphabet soup even to > experienced developers, unless you're familiar with WebKit internals. I expect users of those options to know what they are. > Lastly... use-case. You used to require that new APIs be used by a real > application. Do you have plans to use it somewhere? Surely not adding API > just for the sake of it? > > > Source/JavaScriptCore/API/glib/JSCOptions.cpp:33 > > + * JavaScript options allow to change the behavior of the JavaScript engine. > > allow changing > > > Source/JavaScriptCore/API/glib/JSCOptions.cpp:37 > > + * Only a few of them are documented, you can use the undocumented options at > > documented; > > > Source/JavaScriptCore/API/glib/JSCOptions.cpp:38 > > + * your own risk (you can find the list of options in the WebKit source code). > > your own risk. (You can find the list of options in the WebKit source code.) > > > Source/JavaScriptCore/API/glib/JSCOptions.cpp:52 > > +typedef int32_t int32; > > +typedef size_t size; > > typedefs are fine, but a more modern/natural way would be: > > using int32 = int32_t; > using size = size_t; > > I guess these are for use by the FOR_EACH options macros? Yes. > > Tools/TestWebKitAPI/Tests/JavaScriptCore/glib/TestJSC.cpp:3376 > > + "--jsc-configFile=/tmp/bar", > > Does the config file actually get created by the tests? I assume not, since > you're not actually running any JS. But if so, it should be cleaned. It's not created. 1497774 14 cgarcia 2019-01-24 03:10:01 -0800 Committed r240431: <https://trac.webkit.org/changeset/240431> 1497775 15 webkit-bug-importer 2019-01-24 03:11:29 -0800 <rdar://problem/47510693> 349005 2018-09-06 00:21:23 -0700 2018-09-06 06:44:02 -0700 WIP jsc-glib-options.diff text/plain 39303 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9KU0NPcHRpb25zLmNw cCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9KU0NPcHRpb25zLmNwcApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uMTJhNDI0Zjg5YTIKLS0tIC9kZXYvbnVs bAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQVBJL2dsaWIvSlNDT3B0aW9ucy5jcHAKQEAg LTAsMCArMSw2NzUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTggSWdhbGlhIFMuTC4KKyAq CisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUg aXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFy eSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29m dHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9y IChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5 IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBi dXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50 eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3Ig bW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2Yg dGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhp cyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisg KiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQs IEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2lu Y2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkpTQ09wdGlvbnMuaCIKKworI2luY2x1ZGUgIk9w dGlvbnMuaCIKKyNpbmNsdWRlIDxnbGliL2dpMThuLWxpYi5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0 b3IuaD4KKyNpbmNsdWRlIDx3dGYvZ2xpYi9HVW5pcXVlUHRyLmg+CisKKy8qKgorICogU0VDVElP TjogSlNDT3B0aW9ucworICogQHNob3J0X2Rlc2NyaXB0aW9uOiBKYXZhU2NyaXB0IG9wdGlvbnMK KyAqIEB0aXRsZTogSlNDT3B0aW9ucworICoKKyAqIEphdmFTY3JpcHQgb3B0aW9ucyBhbGxvdyB0 byBjaGFuZ2UgdGhlIGJlaGF2aW9yIG9mIHRoZSBKYXZhU2NyaXB0IGVuZ2luZS4KKyAqIFRoZXkg YWZmZWN0IHRoZSB3YXkgdGhlIGVuZ2luZSB3b3Jrcywgc28gaXQncyBlbmNvdXJhZ2VkIHRvIHNl dCB0aGUgb3B0aW9ucworICogYXQgdGhlIHZlcnkgYmVnaW5uaW5nIG9mIHRoZSBwcm9ncmFtIGV4 ZWN1dGlvbiwgYmVmb3JlIGFueSBvdGhlciBKYXZhU2NyaXB0CisgKiBBUEkgY2FsbC4gTW9zdCBv ZiB0aGUgb3B0aW9ucyBhcmUgb25seSB1c2VmdWwgZm9yIHRlc3RpbmcgYW5kIGRlZ3VuZ2dpbmcu CisgKiBPbmx5IGEgZmV3IG9mIHRoZW0gYXJlIGRvY3VtZW50ZWQsIHlvdSBjYW4gdXNlIHRoZSB1 bmRvY3VtbWVudGVkIG9wdGlvbnMgYXQKKyAqIHlvdXIgb3duIHJpc2sgKHlvdSBjYW4gZmluZCB0 aGUgbGlzdCBvZiBvcHRpb25zIGluIFdlYktpdCBzb3VyY2UgY29kZSkuCisgKgorICogVGhlIEFQ SSBhbGxvd3MgdG8gc2V0IGFuZCBnZXQgYW55IG9wdGlvbiB1c2luZyB0aGUgdHlwZXMgZGVmaW5l ZCBpbiAjSlNDT3B0aW9uVHlwZS4KKyAqIFlvdSBjYW4gYWxzbyBpdGVyYXRlIGFsbCB0aGUgYXZh aWxhYmxlIG9wdGlvbnMgdXNpbmcganNjX29wdGlvbnNfZm9yZWFjaCgpIGFuZAorICogcGFzc2lu ZyBhICNKU0NPcHRpb25zRnVuYyBjYWxsYmFjay4gSWYgeW91ciBhcHBsaWNhdGlvbiB1c2VzICNH T3B0aW9uQ29udGV4dCB0byBoYW5kbGUKKyAqIGNvbW1hbmQgbGluZSBhcmd1bWVudHMsIHlvdSBj YW4gZWFzaWx5IGludGVncmF0ZSB0aGUgSlNDT3B0aW9ucyBieSBhZGRpbmcgdGhlCisgKiAjR09w dGlvbkdyb3VwIHJldHVybmVkIGJ5IGpzY19vcHRpb25zX2dldF9vcHRpb25fZ3JvdXAoKS4KKyAq CisgKiBTaW5jZTogMi4yNAorICovCisKK3VzaW5nIG5hbWVzcGFjZSBKU0M7CisKK3R5cGVkZWYg aW50MzJfdCBpbnQzMjsKK3R5cGVkZWYgc2l6ZV90IHNpemU7CisKK3N0YXRpYyBib29sIHZhbHVl RnJvbUdWYWx1ZShjb25zdCBHVmFsdWUqIGdWYWx1ZSwgYm9vbCYgdmFsdWUpCit7CisgICAgdmFs dWUgPSBnX3ZhbHVlX2dldF9ib29sZWFuKGdWYWx1ZSk7CisgICAgcmV0dXJuIHRydWU7Cit9CisK K3N0YXRpYyB2b2lkIHZhbHVlVG9HVmFsdWUoYm9vbCB2YWx1ZSwgR1ZhbHVlKiBnVmFsdWUpCit7 CisgICAgZ192YWx1ZV9zZXRfYm9vbGVhbihnVmFsdWUsIHZhbHVlKTsKK30KKworc3RhdGljIGJv b2wgdmFsdWVGcm9tR1ZhbHVlKGNvbnN0IEdWYWx1ZSogZ1ZhbHVlLCBpbnQzMl90JiB2YWx1ZSkK K3sKKyAgICB2YWx1ZSA9IGdfdmFsdWVfZ2V0X2ludChnVmFsdWUpOworICAgIHJldHVybiB0cnVl OworfQorCitzdGF0aWMgdm9pZCB2YWx1ZVRvR1ZhbHVlKGludDMyX3QgdmFsdWUsIEdWYWx1ZSog Z1ZhbHVlKQoreworICAgIGdfdmFsdWVfc2V0X2ludChnVmFsdWUsIHZhbHVlKTsKK30KKworc3Rh dGljIGJvb2wgdmFsdWVGcm9tR1ZhbHVlKGNvbnN0IEdWYWx1ZSogZ1ZhbHVlLCB1bnNpZ25lZCYg dmFsdWUpCit7CisgICAgdmFsdWUgPSBnX3ZhbHVlX2dldF91aW50KGdWYWx1ZSk7CisgICAgcmV0 dXJuIHRydWU7Cit9CisKK3N0YXRpYyB2b2lkIHZhbHVlVG9HVmFsdWUodW5zaWduZWQgdmFsdWUs IEdWYWx1ZSogZ1ZhbHVlKQoreworICAgIGdfdmFsdWVfc2V0X3VpbnQoZ1ZhbHVlLCB2YWx1ZSk7 Cit9CisKK3N0YXRpYyBib29sIHZhbHVlRnJvbUdWYWx1ZShjb25zdCBHVmFsdWUqIGdWYWx1ZSwg c2l6ZV90JiB2YWx1ZSkKK3sKKyAgICB2YWx1ZSA9IEdQT0lOVEVSX1RPX1NJWkUoZ192YWx1ZV9n ZXRfcG9pbnRlcihnVmFsdWUpKTsKKyAgICByZXR1cm4gdHJ1ZTsKK30KKworc3RhdGljIHZvaWQg dmFsdWVUb0dWYWx1ZShzaXplX3QgdmFsdWUsIEdWYWx1ZSogZ1ZhbHVlKQoreworICAgIGdfdmFs dWVfc2V0X3BvaW50ZXIoZ1ZhbHVlLCBHU0laRV9UT19QT0lOVEVSKHZhbHVlKSk7Cit9CisKK3N0 YXRpYyBib29sIHZhbHVlRnJvbUdWYWx1ZShjb25zdCBHVmFsdWUqIGdWYWx1ZSwgY29uc3QgY2hh ciomIHZhbHVlKQoreworICAgIHZhbHVlID0gZ192YWx1ZV9kdXBfc3RyaW5nKGdWYWx1ZSk7Cisg ICAgcmV0dXJuIHRydWU7Cit9CisKK3N0YXRpYyB2b2lkIHZhbHVlVG9HVmFsdWUoY29uc3QgY2hh ciogdmFsdWUsIEdWYWx1ZSogZ1ZhbHVlKQoreworICAgIGdfdmFsdWVfc2V0X3N0cmluZyhnVmFs dWUsIHZhbHVlKTsKK30KKworc3RhdGljIGJvb2wgdmFsdWVGcm9tR1ZhbHVlKGNvbnN0IEdWYWx1 ZSogZ1ZhbHVlLCBkb3VibGUmIHZhbHVlKQoreworICAgIHZhbHVlID0gZ192YWx1ZV9nZXRfZG91 YmxlKGdWYWx1ZSk7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3N0YXRpYyB2b2lkIHZhbHVlVG9H VmFsdWUoZG91YmxlIHZhbHVlLCBHVmFsdWUqIGdWYWx1ZSkKK3sKKyAgICBnX3ZhbHVlX3NldF9k b3VibGUoZ1ZhbHVlLCB2YWx1ZSk7Cit9CisKK3N0YXRpYyBib29sIHZhbHVlRnJvbUdWYWx1ZShj b25zdCBHVmFsdWUqIGdWYWx1ZSwgT3B0aW9uUmFuZ2UmIHZhbHVlKQoreworICAgIHJldHVybiB2 YWx1ZS5pbml0KGdfdmFsdWVfZ2V0X3N0cmluZyhnVmFsdWUpID8gZ192YWx1ZV9nZXRfc3RyaW5n KGdWYWx1ZSkgOiAiPG51bGw+Iik7Cit9CisKK3N0YXRpYyB2b2lkIHZhbHVlVG9HVmFsdWUoY29u c3QgT3B0aW9uUmFuZ2UmIHZhbHVlLCBHVmFsdWUqIGdWYWx1ZSkKK3sKKyAgICBjb25zdCBjaGFy KiByYW5nZVN0cmluZyA9IHZhbHVlLnJhbmdlU3RyaW5nKCk7CisgICAgZ192YWx1ZV9zZXRfc3Ry aW5nKGdWYWx1ZSwgIWdfc3RyY21wMChyYW5nZVN0cmluZywgIjxudWxsPiIpID8gbnVsbHB0ciA6 IHJhbmdlU3RyaW5nKTsKK30KKworc3RhdGljIGJvb2wgdmFsdWVGcm9tR1ZhbHVlKGNvbnN0IEdW YWx1ZSogZ1ZhbHVlLCBHQ0xvZ2dpbmc6OkxldmVsJiB2YWx1ZSkKK3sKKyAgICBzd2l0Y2ggKGdf dmFsdWVfZ2V0X3VpbnQoZ1ZhbHVlKSkgeworICAgIGNhc2UgMDoKKyAgICAgICAgdmFsdWUgPSBH Q0xvZ2dpbmc6OkxldmVsOjpOb25lOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICBjYXNlIDE6 CisgICAgICAgIHZhbHVlID0gR0NMb2dnaW5nOjpMZXZlbDo6QmFzaWM7CisgICAgICAgIHJldHVy biB0cnVlOworICAgIGNhc2UgMjoKKyAgICAgICAgdmFsdWUgPSBHQ0xvZ2dpbmc6OkxldmVsOjpW ZXJib3NlOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICBkZWZhdWx0OgorICAgICAgICBicmVh azsKKyAgICB9CisKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK3N0YXRpYyB2b2lkIHZhbHVlVG9H VmFsdWUoR0NMb2dnaW5nOjpMZXZlbCB2YWx1ZSwgR1ZhbHVlKiBnVmFsdWUpCit7CisgICAgc3dp dGNoICh2YWx1ZSkgeworICAgIGNhc2UgR0NMb2dnaW5nOjpMZXZlbDo6Tm9uZToKKyAgICAgICAg Z192YWx1ZV9zZXRfdWludChnVmFsdWUsIDApOworICAgICAgICBicmVhazsKKyAgICBjYXNlIEdD TG9nZ2luZzo6TGV2ZWw6OkJhc2ljOgorICAgICAgICBnX3ZhbHVlX3NldF91aW50KGdWYWx1ZSwg MSk7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgR0NMb2dnaW5nOjpMZXZlbDo6VmVyYm9zZToK KyAgICAgICAgZ192YWx1ZV9zZXRfdWludChnVmFsdWUsIDIpOworICAgICAgICBicmVhazsKKyAg ICB9Cit9CisKK3N0YXRpYyBnYm9vbGVhbiBqc2NPcHRpb25zU2V0VmFsdWUoY29uc3QgY2hhciog b3B0aW9uLCBjb25zdCBHVmFsdWUqIHZhbHVlKQoreworI2RlZmluZSBGT1JfRUFDSF9PUFRJT04o dHlwZV8sIG5hbWVfLCBkZWZhdWx0VmFsdWVfLCBhdmFpbGFiaWxpdHlfLCBkZXNjcmlwdGlvbl8p IFwKKyAgICBpZiAoIWdfc3RyY21wMCgjbmFtZV8sIG9wdGlvbikpIHsgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgdHlwZV8gdmFsdWVUb1NldDsgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgaWYgKCF2YWx1 ZUZyb21HVmFsdWUodmFsdWUsIHZhbHVlVG9TZXQpKSAgICAgICAgICAgICAgICAgICAgICAgIFwK KyAgICAgICAgICAgIHJldHVybiBGQUxTRTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFwKKyAgICAgICAgT3B0aW9uczo6bmFtZV8oKSA9IHZhbHVlVG9TZXQ7 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgcmV0dXJuIFRSVUU7 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAg ICB9CisKKyAgICBPcHRpb25zOjppbml0aWFsaXplKCk7CisgICAgSlNDX09QVElPTlMoRk9SX0VB Q0hfT1BUSU9OKQorI3VuZGVmIEZPUl9FQUNIX09QVElPTgorCisgICAgcmV0dXJuIEZBTFNFOwor fQorCitzdGF0aWMgZ2Jvb2xlYW4ganNjT3B0aW9uc0dldFZhbHVlKGNvbnN0IGNoYXIqIG9wdGlv biwgR1ZhbHVlKiB2YWx1ZSkKK3sKKyNkZWZpbmUgRk9SX0VBQ0hfT1BUSU9OKHR5cGVfLCBuYW1l XywgZGVmYXVsdFZhbHVlXywgYXZhaWxhYmlsaXR5XywgZGVzY3JpcHRpb25fKSBcCisgICAgaWYg KCFnX3N0cmNtcDAoI25hbWVfLCBvcHRpb24pKSB7ICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBcCisgICAgICAgIHR5cGVfIHZhbHVlVG9HZXQgPSBPcHRpb25zOjpuYW1lXygpOyAg ICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICAgIHZhbHVlVG9HVmFsdWUodmFsdWVU b0dldCwgdmFsdWUpOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICAgIHJl dHVybiBUUlVFOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBcCisgICAgfQorCisgICAgT3B0aW9uczo6aW5pdGlhbGl6ZSgpOworICAgIEpTQ19PUFRJ T05TKEZPUl9FQUNIX09QVElPTikKKyN1bmRlZiBGT1JfRUFDSF9PUFRJT04KKworICAgIHJldHVy biBGQUxTRTsKK30KKworLyoqCisgKiBqc2Nfb3B0aW9uc19zZXRfYm9vbGVhbjoKKyAqIEBvcHRp b246IHRoZSBvcHRpb24gaWRlbnRpZmllcgorICogQHZhbHVlOiB0aGUgdmFsdWUgdG8gc2V0Cisg KgorICogU2V0IEBvcHRpb24gYXMgYSAjZ2Jvb2xlYW4gdmFsdWUuCisgKgorICogUmV0dXJuczog JVRSVUUgaWYgb3B0aW9uIHdhcyBjb3JyZWN0bHkgc2V0IG9yICVGQUxTRSBvdGhlcndpc2UuCisg KgorICogU2luY2U6IDIuMjQKKyAqLworZ2Jvb2xlYW4ganNjX29wdGlvbnNfc2V0X2Jvb2xlYW4o Y29uc3QgY2hhciogb3B0aW9uLCBnYm9vbGVhbiB2YWx1ZSkKK3sKKyAgICBnX3JldHVybl92YWxf aWZfZmFpbChvcHRpb24sIEZBTFNFKTsKKworICAgIEdWYWx1ZSBnVmFsdWUgPSBHX1ZBTFVFX0lO SVQ7CisgICAgZ192YWx1ZV9pbml0KCZnVmFsdWUsIEdfVFlQRV9CT09MRUFOKTsKKyAgICBnX3Zh bHVlX3NldF9ib29sZWFuKCZnVmFsdWUsIHZhbHVlKTsKKyAgICByZXR1cm4ganNjT3B0aW9uc1Nl dFZhbHVlKG9wdGlvbiwgJmdWYWx1ZSk7Cit9CisKKy8qKgorICoganNjX29wdGlvbnNfZ2V0X2Jv b2xlYW46CisgKiBAb3B0aW9uOiB0aGUgb3B0aW9uIGlkZW50aWZpZXIKKyAqIEB2YWx1ZTogKG91 dCk6IHJldHVybiBsb2NhdGlvbiBmb3IgdGhlIG9wdGlvbiB2YWx1ZQorICoKKyAqIEdldCBAb3B0 aW9uIGFzIGEgI2dib29sZWFuIHZhbHVlLgorICoKKyAqIFJldHVybnM6ICVUUlVFIGlmIEB2YWx1 ZSBoYXMgYmVlbiBzZXQgb3IgJUZBTFNFIGlmIHRoZSBvcHRpb24gZG9lc24ndCBleGlzdAorICoK KyAqIFNpbmNlOiAyLjI0CisgKi8KK2dib29sZWFuIGpzY19vcHRpb25zX2dldF9ib29sZWFuKGNv bnN0IGNoYXIqIG9wdGlvbiwgZ2Jvb2xlYW4qIHZhbHVlKQoreworICAgIGdfcmV0dXJuX3ZhbF9p Zl9mYWlsKG9wdGlvbiwgRkFMU0UpOworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKHZhbHVlLCBG QUxTRSk7CisKKyAgICBHVmFsdWUgZ1ZhbHVlID0gR19WQUxVRV9JTklUOworICAgIGdfdmFsdWVf aW5pdCgmZ1ZhbHVlLCBHX1RZUEVfQk9PTEVBTik7CisgICAgaWYgKCFqc2NPcHRpb25zR2V0VmFs dWUob3B0aW9uLCAmZ1ZhbHVlKSkKKyAgICAgICAgcmV0dXJuIEZBTFNFOworCisgICAgKnZhbHVl ID0gIGdfdmFsdWVfZ2V0X2Jvb2xlYW4oJmdWYWx1ZSk7CisgICAgcmV0dXJuIFRSVUU7Cit9CisK Ky8qKgorICoganNjX29wdGlvbnNfc2V0X2ludDoKKyAqIEBvcHRpb246IHRoZSBvcHRpb24gaWRl bnRpZmllcgorICogQHZhbHVlOiB0aGUgdmFsdWUgdG8gc2V0CisgKgorICogU2V0IEBvcHRpb24g YXMgYSAjZ2ludCB2YWx1ZS4KKyAqCisgKiBSZXR1cm5zOiAlVFJVRSBpZiBvcHRpb24gd2FzIGNv cnJlY3RseSBzZXQgb3IgJUZBTFNFIG90aGVyd2lzZS4KKyAqCisgKiBTaW5jZTogMi4yNAorICov CitnYm9vbGVhbiBqc2Nfb3B0aW9uc19zZXRfaW50KGNvbnN0IGNoYXIqIG9wdGlvbiwgZ2ludCB2 YWx1ZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChvcHRpb24sIEZBTFNFKTsKKworICAg IEdWYWx1ZSBnVmFsdWUgPSBHX1ZBTFVFX0lOSVQ7CisgICAgZ192YWx1ZV9pbml0KCZnVmFsdWUs IEdfVFlQRV9JTlQpOworICAgIGdfdmFsdWVfc2V0X2ludCgmZ1ZhbHVlLCB2YWx1ZSk7CisgICAg cmV0dXJuIGpzY09wdGlvbnNTZXRWYWx1ZShvcHRpb24sICZnVmFsdWUpOworfQorCisvKioKKyAq IGpzY19vcHRpb25zX2dldF9pbnQ6CisgKiBAb3B0aW9uOiB0aGUgb3B0aW9uIGlkZW50aWZpZXIK KyAqIEB2YWx1ZTogKG91dCk6IHJldHVybiBsb2NhdGlvbiBmb3IgdGhlIG9wdGlvbiB2YWx1ZQor ICoKKyAqIEdldCBAb3B0aW9uIGFzIGEgI2dpbnQgdmFsdWUuCisgKgorICogUmV0dXJuczogJVRS VUUgaWYgQHZhbHVlIGhhcyBiZWVuIHNldCBvciAlRkFMU0UgaWYgdGhlIG9wdGlvbiBkb2Vzbid0 IGV4aXN0CisgKgorICogU2luY2U6IDIuMjQKKyAqLworZ2Jvb2xlYW4ganNjX29wdGlvbnNfZ2V0 X2ludChjb25zdCBjaGFyKiBvcHRpb24sIGdpbnQqIHZhbHVlKQoreworICAgIGdfcmV0dXJuX3Zh bF9pZl9mYWlsKG9wdGlvbiwgRkFMU0UpOworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKHZhbHVl LCBGQUxTRSk7CisKKyAgICBHVmFsdWUgZ1ZhbHVlID0gR19WQUxVRV9JTklUOworICAgIGdfdmFs dWVfaW5pdCgmZ1ZhbHVlLCBHX1RZUEVfSU5UKTsKKyAgICBpZiAoIWpzY09wdGlvbnNHZXRWYWx1 ZShvcHRpb24sICZnVmFsdWUpKQorICAgICAgICByZXR1cm4gRkFMU0U7CisKKyAgICAqdmFsdWUg PSBnX3ZhbHVlX2dldF9pbnQoJmdWYWx1ZSk7CisgICAgcmV0dXJuIFRSVUU7Cit9CisKKy8qKgor ICoganNjX29wdGlvbnNfc2V0X3VpbnQ6CisgKiBAb3B0aW9uOiB0aGUgb3B0aW9uIGlkZW50aWZp ZXIKKyAqIEB2YWx1ZTogdGhlIHZhbHVlIHRvIHNldAorICoKKyAqIFNldCBAb3B0aW9uIGFzIGEg I2d1aW50IHZhbHVlLgorICoKKyAqIFJldHVybnM6ICVUUlVFIGlmIG9wdGlvbiB3YXMgY29ycmVj dGx5IHNldCBvciAlRkFMU0Ugb3RoZXJ3aXNlLgorICoKKyAqIFNpbmNlOiAyLjI0CisgKi8KK2di b29sZWFuIGpzY19vcHRpb25zX3NldF91aW50KGNvbnN0IGNoYXIqIG9wdGlvbiwgZ3VpbnQgdmFs dWUpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwob3B0aW9uLCBGQUxTRSk7CisKKyAgICBH VmFsdWUgZ1ZhbHVlID0gR19WQUxVRV9JTklUOworICAgIGdfdmFsdWVfaW5pdCgmZ1ZhbHVlLCBH X1RZUEVfVUlOVCk7CisgICAgZ192YWx1ZV9zZXRfdWludCgmZ1ZhbHVlLCB2YWx1ZSk7CisgICAg cmV0dXJuIGpzY09wdGlvbnNTZXRWYWx1ZShvcHRpb24sICZnVmFsdWUpOworfQorCisvKioKKyAq IGpzY19vcHRpb25zX2dldF91aW50OgorICogQG9wdGlvbjogdGhlIG9wdGlvbiBpZGVudGlmaWVy CisgKiBAdmFsdWU6IChvdXQpOiByZXR1cm4gbG9jYXRpb24gZm9yIHRoZSBvcHRpb24gdmFsdWUK KyAqCisgKiBHZXQgQG9wdGlvbiBhcyBhICNndWludCB2YWx1ZS4KKyAqCisgKiBSZXR1cm5zOiAl VFJVRSBpZiBAdmFsdWUgaGFzIGJlZW4gc2V0IG9yICVGQUxTRSBpZiB0aGUgb3B0aW9uIGRvZXNu J3QgZXhpc3QKKyAqCisgKiBTaW5jZTogMi4yNAorICovCitnYm9vbGVhbiBqc2Nfb3B0aW9uc19n ZXRfdWludChjb25zdCBjaGFyKiBvcHRpb24sIGd1aW50KiB2YWx1ZSkKK3sKKyAgICBnX3JldHVy bl92YWxfaWZfZmFpbChvcHRpb24sIEZBTFNFKTsKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbCh2 YWx1ZSwgRkFMU0UpOworCisgICAgR1ZhbHVlIGdWYWx1ZSA9IEdfVkFMVUVfSU5JVDsKKyAgICBn X3ZhbHVlX2luaXQoJmdWYWx1ZSwgR19UWVBFX1VJTlQpOworICAgIGlmICghanNjT3B0aW9uc0dl dFZhbHVlKG9wdGlvbiwgJmdWYWx1ZSkpCisgICAgICAgIHJldHVybiBGQUxTRTsKKworICAgICp2 YWx1ZSA9IGdfdmFsdWVfZ2V0X3VpbnQoJmdWYWx1ZSk7CisgICAgcmV0dXJuIFRSVUU7Cit9CisK Ky8qKgorICoganNjX29wdGlvbnNfc2V0X3NpemU6CisgKiBAb3B0aW9uOiB0aGUgb3B0aW9uIGlk ZW50aWZpZXIKKyAqIEB2YWx1ZTogdGhlIHZhbHVlIHRvIHNldAorICoKKyAqIFNldCBAb3B0aW9u IGFzIGEgI2dzaXplIHZhbHVlLgorICoKKyAqIFJldHVybnM6ICVUUlVFIGlmIG9wdGlvbiB3YXMg Y29ycmVjdGx5IHNldCBvciAlRkFMU0Ugb3RoZXJ3aXNlLgorICoKKyAqIFNpbmNlOiAyLjI0Cisg Ki8KK2dib29sZWFuIGpzY19vcHRpb25zX3NldF9zaXplKGNvbnN0IGNoYXIqIG9wdGlvbiwgZ3Np emUgdmFsdWUpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwob3B0aW9uLCBGQUxTRSk7CisK KyAgICBHVmFsdWUgZ1ZhbHVlID0gR19WQUxVRV9JTklUOworICAgIGdfdmFsdWVfaW5pdCgmZ1Zh bHVlLCBHX1RZUEVfUE9JTlRFUik7CisgICAgZ192YWx1ZV9zZXRfcG9pbnRlcigmZ1ZhbHVlLCBH U0laRV9UT19QT0lOVEVSKHZhbHVlKSk7CisgICAgcmV0dXJuIGpzY09wdGlvbnNTZXRWYWx1ZShv cHRpb24sICZnVmFsdWUpOworfQorCisvKioKKyAqIGpzY19vcHRpb25zX2dldF9zaXplOgorICog QG9wdGlvbjogdGhlIG9wdGlvbiBpZGVudGlmaWVyCisgKiBAdmFsdWU6IChvdXQpOiByZXR1cm4g bG9jYXRpb24gZm9yIHRoZSBvcHRpb24gdmFsdWUKKyAqCisgKiBHZXQgQG9wdGlvbiBhcyBhICNn c2l6ZSB2YWx1ZS4KKyAqCisgKiBSZXR1cm5zOiAlVFJVRSBpZiBAdmFsdWUgaGFzIGJlZW4gc2V0 IG9yICVGQUxTRSBpZiB0aGUgb3B0aW9uIGRvZXNuJ3QgZXhpc3QKKyAqCisgKiBTaW5jZTogMi4y NAorICovCitnYm9vbGVhbiBqc2Nfb3B0aW9uc19nZXRfc2l6ZShjb25zdCBjaGFyKiBvcHRpb24s IGdzaXplKiB2YWx1ZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChvcHRpb24sIEZBTFNF KTsKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbCh2YWx1ZSwgRkFMU0UpOworCisgICAgR1ZhbHVl IGdWYWx1ZSA9IEdfVkFMVUVfSU5JVDsKKyAgICBnX3ZhbHVlX2luaXQoJmdWYWx1ZSwgR19UWVBF X1BPSU5URVIpOworICAgIGlmICghanNjT3B0aW9uc0dldFZhbHVlKG9wdGlvbiwgJmdWYWx1ZSkp CisgICAgICAgIHJldHVybiBGQUxTRTsKKworICAgICp2YWx1ZSA9IEdQT0lOVEVSX1RPX1NJWkUo Z192YWx1ZV9nZXRfcG9pbnRlcigmZ1ZhbHVlKSk7CisgICAgcmV0dXJuIFRSVUU7Cit9CisKKy8q KgorICoganNjX29wdGlvbnNfc2V0X2RvdWJsZToKKyAqIEBvcHRpb246IHRoZSBvcHRpb24gaWRl bnRpZmllcgorICogQHZhbHVlOiB0aGUgdmFsdWUgdG8gc2V0CisgKgorICogU2V0IEBvcHRpb24g YXMgYSAjZ2RvdWJsZSB2YWx1ZS4KKyAqCisgKiBSZXR1cm5zOiAlVFJVRSBpZiBvcHRpb24gd2Fz IGNvcnJlY3RseSBzZXQgb3IgJUZBTFNFIG90aGVyd2lzZS4KKyAqCisgKiBTaW5jZTogMi4yNAor ICovCitnYm9vbGVhbiBqc2Nfb3B0aW9uc19zZXRfZG91YmxlKGNvbnN0IGNoYXIqIG9wdGlvbiwg Z2RvdWJsZSB2YWx1ZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChvcHRpb24sIEZBTFNF KTsKKworICAgIEdWYWx1ZSBnVmFsdWUgPSBHX1ZBTFVFX0lOSVQ7CisgICAgZ192YWx1ZV9pbml0 KCZnVmFsdWUsIEdfVFlQRV9ET1VCTEUpOworICAgIGdfdmFsdWVfc2V0X2RvdWJsZSgmZ1ZhbHVl LCB2YWx1ZSk7CisgICAgcmV0dXJuIGpzY09wdGlvbnNTZXRWYWx1ZShvcHRpb24sICZnVmFsdWUp OworfQorCisvKioKKyAqIGpzY19vcHRpb25zX2dldF9kb3VibGU6CisgKiBAb3B0aW9uOiB0aGUg b3B0aW9uIGlkZW50aWZpZXIKKyAqIEB2YWx1ZTogKG91dCk6IHJldHVybiBsb2NhdGlvbiBmb3Ig dGhlIG9wdGlvbiB2YWx1ZQorICoKKyAqIEdldCBAb3B0aW9uIGFzIGEgI2dkb3VibGUgdmFsdWUu CisgKgorICogUmV0dXJuczogJVRSVUUgaWYgQHZhbHVlIGhhcyBiZWVuIHNldCBvciAlRkFMU0Ug aWYgdGhlIG9wdGlvbiBkb2Vzbid0IGV4aXN0CisgKgorICogU2luY2U6IDIuMjQKKyAqLworZ2Jv b2xlYW4ganNjX29wdGlvbnNfZ2V0X2RvdWJsZShjb25zdCBjaGFyKiBvcHRpb24sIGdkb3VibGUq IHZhbHVlKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKG9wdGlvbiwgRkFMU0UpOworICAg IGdfcmV0dXJuX3ZhbF9pZl9mYWlsKHZhbHVlLCBGQUxTRSk7CisKKyAgICBHVmFsdWUgZ1ZhbHVl ID0gR19WQUxVRV9JTklUOworICAgIGdfdmFsdWVfaW5pdCgmZ1ZhbHVlLCBHX1RZUEVfRE9VQkxF KTsKKyAgICBpZiAoIWpzY09wdGlvbnNHZXRWYWx1ZShvcHRpb24sICZnVmFsdWUpKQorICAgICAg ICByZXR1cm4gRkFMU0U7CisKKyAgICAqdmFsdWUgPSBnX3ZhbHVlX2dldF9kb3VibGUoJmdWYWx1 ZSk7CisgICAgcmV0dXJuIFRSVUU7Cit9CisKKy8qKgorICoganNjX29wdGlvbnNfc2V0X3N0cmlu ZzoKKyAqIEBvcHRpb246IHRoZSBvcHRpb24gaWRlbnRpZmllcgorICogQHZhbHVlOiB0aGUgdmFs dWUgdG8gc2V0CisgKgorICogU2V0IEBvcHRpb24gYXMgYSBzdHJpbmcuCisgKgorICogUmV0dXJu czogJVRSVUUgaWYgb3B0aW9uIHdhcyBjb3JyZWN0bHkgc2V0IG9yICVGQUxTRSBvdGhlcndpc2Uu CisgKgorICogU2luY2U6IDIuMjQKKyAqLworZ2Jvb2xlYW4ganNjX29wdGlvbnNfc2V0X3N0cmlu Zyhjb25zdCBjaGFyKiBvcHRpb24sIGNvbnN0IGNoYXIqIHZhbHVlKQoreworICAgIGdfcmV0dXJu X3ZhbF9pZl9mYWlsKG9wdGlvbiwgRkFMU0UpOworCisgICAgR1ZhbHVlIGdWYWx1ZSA9IEdfVkFM VUVfSU5JVDsKKyAgICBnX3ZhbHVlX2luaXQoJmdWYWx1ZSwgR19UWVBFX1NUUklORyk7CisgICAg Z192YWx1ZV9zZXRfc3RyaW5nKCZnVmFsdWUsIHZhbHVlKTsKKyAgICBib29sIHN1Y2Nlc3MgPSBq c2NPcHRpb25zU2V0VmFsdWUob3B0aW9uLCAmZ1ZhbHVlKTsKKyAgICBnX3ZhbHVlX3Vuc2V0KCZn VmFsdWUpOworICAgIHJldHVybiBzdWNjZXNzOworfQorCisvKioKKyAqIGpzY19vcHRpb25zX2dl dF9zdHJpbmc6CisgKiBAb3B0aW9uOiB0aGUgb3B0aW9uIGlkZW50aWZpZXIKKyAqIEB2YWx1ZTog KG91dCk6IHJldHVybiBsb2NhdGlvbiBmb3IgdGhlIG9wdGlvbiB2YWx1ZQorICoKKyAqIEdldCBA b3B0aW9uIGFzIGEgc3RyaW5nLgorICoKKyAqIFJldHVybnM6ICVUUlVFIGlmIEB2YWx1ZSBoYXMg YmVlbiBzZXQgb3IgJUZBTFNFIGlmIHRoZSBvcHRpb24gZG9lc24ndCBleGlzdAorICoKKyAqIFNp bmNlOiAyLjI0CisgKi8KK2dib29sZWFuIGpzY19vcHRpb25zX2dldF9zdHJpbmcoY29uc3QgY2hh ciogb3B0aW9uLCBjaGFyKiogdmFsdWUpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwob3B0 aW9uLCBGQUxTRSk7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwodmFsdWUsIEZBTFNFKTsKKwor ICAgIEdWYWx1ZSBnVmFsdWUgPSBHX1ZBTFVFX0lOSVQ7CisgICAgZ192YWx1ZV9pbml0KCZnVmFs dWUsIEdfVFlQRV9TVFJJTkcpOworICAgIGlmICghanNjT3B0aW9uc0dldFZhbHVlKG9wdGlvbiwg JmdWYWx1ZSkpCisgICAgICAgIHJldHVybiBGQUxTRTsKKworICAgICp2YWx1ZSA9IGdfdmFsdWVf ZHVwX3N0cmluZygmZ1ZhbHVlKTsKKyAgICBnX3ZhbHVlX3Vuc2V0KCZnVmFsdWUpOworICAgIHJl dHVybiBUUlVFOworfQorCisvKioKKyAqIGpzY19vcHRpb25zX3NldF9yYW5nZV9zdHJpbmc6Cisg KiBAb3B0aW9uOiB0aGUgb3B0aW9uIGlkZW50aWZpZXIKKyAqIEB2YWx1ZTogdGhlIHZhbHVlIHRv IHNldAorICoKKyAqIFNldCBAb3B0aW9uIGFzIGEgcmFuZ2Ugc3RyaW5nLiBUaGUgc3RyaW5nIG11 c3QgYmUgaW4gdGhlCisgKiBmb3JtYXQgWyFdPGxvdz5bOjxoaWdoPl0gd2hlcmUgbG93IGFuZCBo aWdoIGFyZSAjZ3VpbnQgdmFsdWVzLgorICogVmFsdWVzIGJldHdlZW4gbG93IGFuZCBoaWdoIChi b3RoIGluY2x1ZGVkKSB3aWxsIGJlIGNvbnNpZGVyZWQgaW4KKyAqIHRoZSByYW5nZSwgdW5sZXNz ICEgaXMgdXNlZCB0byBpbnZlcnQgdGhlIHJhbmdlLgorICoKKyAqIFJldHVybnM6ICVUUlVFIGlm IG9wdGlvbiB3YXMgY29ycmVjdGx5IHNldCBvciAlRkFMU0Ugb3RoZXJ3aXNlLgorICoKKyAqIFNp bmNlOiAyLjI0CisgKi8KK2dib29sZWFuIGpzY19vcHRpb25zX3NldF9yYW5nZV9zdHJpbmcoY29u c3QgY2hhciogb3B0aW9uLCBjb25zdCBjaGFyKiB2YWx1ZSkKK3sKKyAgICBnX3JldHVybl92YWxf aWZfZmFpbChvcHRpb24sIEZBTFNFKTsKKworICAgIEdWYWx1ZSBnVmFsdWUgPSBHX1ZBTFVFX0lO SVQ7CisgICAgZ192YWx1ZV9pbml0KCZnVmFsdWUsIEdfVFlQRV9TVFJJTkcpOworICAgIGdfdmFs dWVfc2V0X3N0cmluZygmZ1ZhbHVlLCB2YWx1ZSk7CisgICAgYm9vbCBzdWNjZXNzID0ganNjT3B0 aW9uc1NldFZhbHVlKG9wdGlvbiwgJmdWYWx1ZSk7CisgICAgZ192YWx1ZV91bnNldCgmZ1ZhbHVl KTsKKyAgICByZXR1cm4gc3VjY2VzczsKK30KKworLyoqCisgKiBqc2Nfb3B0aW9uc19nZXRfcmFu Z2Vfc3RyaW5nOgorICogQG9wdGlvbjogdGhlIG9wdGlvbiBpZGVudGlmaWVyCisgKiBAdmFsdWU6 IChvdXQpOiByZXR1cm4gbG9jYXRpb24gZm9yIHRoZSBvcHRpb24gdmFsdWUKKyAqCisgKiBHZXQg QG9wdGlvbiBhcyBhIHJhbmdlIHN0cmluZy4gVGhlIHN0cmluZyBtdXN0IGJlIGluIHRoZQorICog Zm9ybWF0IFshXTxsb3c+Wzo8aGlnaD5dIHdoZXJlIGxvdyBhbmQgaGlnaCBhcmUgI2d1aW50IHZh bHVlcy4KKyAqIFZhbHVlcyBiZXR3ZWVuIGxvdyBhbmQgaGlnaCAoYm90aCBpbmNsdWRlZCkgd2ls bCBiZSBjb25zaWRlcmVkIGluCisgKiB0aGUgcmFuZ2UsIHVubGVzcyAhIGlzIHVzZWQgdG8gaW52 ZXJ0IHRoZSByYW5nZS4KKyAqCisgKiBSZXR1cm5zOiAlVFJVRSBpZiBAdmFsdWUgaGFzIGJlZW4g c2V0IG9yICVGQUxTRSBpZiB0aGUgb3B0aW9uIGRvZXNuJ3QgZXhpc3QKKyAqCisgKiBTaW5jZTog Mi4yNAorICovCitnYm9vbGVhbiBqc2Nfb3B0aW9uc19nZXRfcmFuZ2Vfc3RyaW5nKGNvbnN0IGNo YXIqIG9wdGlvbiwgY2hhcioqIHZhbHVlKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKG9w dGlvbiwgRkFMU0UpOworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKHZhbHVlLCBGQUxTRSk7CisK KyAgICBHVmFsdWUgZ1ZhbHVlID0gR19WQUxVRV9JTklUOworICAgIGdfdmFsdWVfaW5pdCgmZ1Zh bHVlLCBHX1RZUEVfU1RSSU5HKTsKKyAgICBpZiAoIWpzY09wdGlvbnNHZXRWYWx1ZShvcHRpb24s ICZnVmFsdWUpKQorICAgICAgICByZXR1cm4gRkFMU0U7CisKKyAgICAqdmFsdWUgPSBnX3ZhbHVl X2R1cF9zdHJpbmcoJmdWYWx1ZSk7CisgICAgZ192YWx1ZV91bnNldCgmZ1ZhbHVlKTsKKyAgICBy ZXR1cm4gVFJVRTsKK30KKworc3RhdGljIEpTQ09wdGlvblR5cGUganNjT3B0aW9uc1R5cGUoYm9v bCkKK3sKKyAgICByZXR1cm4gSlNDX09QVElPTl9CT09MRUFOOworfQorCitzdGF0aWMgSlNDT3B0 aW9uVHlwZSBqc2NPcHRpb25zVHlwZShpbnQpCit7CisgICAgcmV0dXJuIEpTQ19PUFRJT05fSU5U OworfQorCitzdGF0aWMgSlNDT3B0aW9uVHlwZSBqc2NPcHRpb25zVHlwZSh1bnNpZ25lZCkKK3sK KyAgICByZXR1cm4gSlNDX09QVElPTl9VSU5UOworfQorCitzdGF0aWMgSlNDT3B0aW9uVHlwZSBq c2NPcHRpb25zVHlwZShzaXplX3QpCit7CisgICAgcmV0dXJuIEpTQ19PUFRJT05fU0laRTsKK30K Kworc3RhdGljIEpTQ09wdGlvblR5cGUganNjT3B0aW9uc1R5cGUoZG91YmxlKQoreworICAgIHJl dHVybiBKU0NfT1BUSU9OX0RPVUJMRTsKK30KKworc3RhdGljIEpTQ09wdGlvblR5cGUganNjT3B0 aW9uc1R5cGUoY29uc3QgY2hhciopCit7CisgICAgcmV0dXJuIEpTQ19PUFRJT05fU1RSSU5HOwor fQorCitzdGF0aWMgSlNDT3B0aW9uVHlwZSBqc2NPcHRpb25zVHlwZShjb25zdCBPcHRpb25SYW5n ZSYpCit7CisgICAgcmV0dXJuIEpTQ19PUFRJT05fUkFOR0VfU1RSSU5HOworfQorCisvKioKKyAq IEpTQ09wdGlvblR5cGU6CisgKiBASlNDX09QVElPTl9CT09MRUFOOiBBICNnYm9vbGVhbiBvcHRp b24gdHlwZS4KKyAqIEBKU0NfT1BUSU9OX0lOVDogQSAjZ2ludCBvcHRpb24gdHlwZS4KKyAqIEBK U0NfT1BUSU9OX1VJTlQ6IEEgI2d1aW50IG9wdGlvbiB0eXBlLgorICogQEpTQ19PUFRJT05fU0la RTogQSAjZ3NpemUgb3B0aW9ucyB0eXBlLgorICogQEpTQ19PUFRJT05fRE9VQkxFOiBBICNnZG91 YmxlIG9wdGlvbnMgdHlwZS4KKyAqIEBKU0NfT1BUSU9OX1NUUklORzogQSBzdHJpbmcgb3B0aW9u IHR5cGUuCisgKiBASlNDX09QVElPTl9SQU5HRV9TVFJJTkc6IEEgcmFuZ2Ugc3RyaW5nIG9wdGlv biB0eXBlLgorICoKKyAqIEVudW0gdmFsdWVzIGZvciBvcHRpb25zIHR5cGVzLgorICoKKyAqIFNp bmNlOiAyLjI0CisgKi8KKworLyoqCisgKiBKU0NPcHRpb25zRnVuYzoKKyAqIEBvcHRpb246IHRo ZSBvcHRpb24gbmFtZQorICogQHR5cGU6IHRoZSBvcHRpb24gI0pTQ09wdGlvblR5cGUKKyAqIEBk ZXNjcmlwdGlvbjogKG51bGxhYmxlKTogdGhlIG9wdGlvbiBkZXNjcmlwdGlvbiwgb3IgJU5VTEwK KyAqIEB1c2VyX2RhdGE6IHVzZXIgZGF0YQorICoKKyAqIEZ1bmN0aW9uIHVzZWQgdG8gaXRlcmF0 ZSBvcHRpb25zLgorICoKKyAqIFJldHVybnM6ICVUUlVFIHRvIHRvcCB0aGUgaXRlcmF0aW9uLCBv ciAlRkFMU0Ugb3RoZXJ3aXNlCisgKgorICogU2luY2U6IDIuMjQKKyAqLworCisvKioKKyAqIGpz Y19vcHRpb25zX2ZvcmVhY2g6CisgKiBAZnVuY3Rpb246IChzY29wZSBjYWxsKTogYSAjSlNDT3B0 aW9uc0Z1bmMgY2FsbGJhY2sKKyAqIEB1c2VyX2RhdGE6IGNhbGxiYWNrIHVzZXIgZGF0YQorICoK KyAqIEl0ZXJhdGVzIGFsbCBhdmFpbGFibGUgb3B0aW9ucyBjYWxsaW5nIEBmdW5jdGlvbiBmb3Ig ZWFjaCBvbmUuIEl0ZXJhdGlvbiBjYW4KKyAqIHN0b3AgZWFybHkgaWYgQGZ1bmN0aW9uIHJldHVy bnMgJUZBTFNFLgorICoKKyAqIFNpbmNlOiAyLjI0CisgKi8KK3ZvaWQganNjX29wdGlvbnNfZm9y ZWFjaChKU0NPcHRpb25zRnVuYyBmdW5jdGlvbiwgZ3BvaW50ZXIgdXNlckRhdGEpCit7CisgICAg Z19yZXR1cm5faWZfZmFpbChmdW5jdGlvbik7CisKKyNkZWZpbmUgRk9SX0VBQ0hfT1BUSU9OKHR5 cGVfLCBuYW1lXywgZGVmYXVsdFZhbHVlXywgYXZhaWxhYmlsaXR5XywgZGVzY3JpcHRpb25fKSBc CisgICAgaWYgKE9wdGlvbnM6OkF2YWlsYWJpbGl0eTo6YXZhaWxhYmlsaXR5XyA9PSBPcHRpb25z OjpBdmFpbGFiaWxpdHk6Ok5vcm1hbCBcCisgICAgICAgIHx8IE9wdGlvbnM6OmlzQXZhaWxhYmxl KE9wdGlvbnM6Om5hbWVfIyNJRCwgT3B0aW9uczo6QXZhaWxhYmlsaXR5OjphdmFpbGFiaWxpdHlf KSkgeyBcCisgICAgICAgIHR5cGVfIGRlZmF1bHRWYWx1ZTsgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICAgIGF1dG8gb3B0aW9uVHlwZSA9IGpzY09w dGlvbnNUeXBlKGRlZmF1bHRWYWx1ZSk7ICAgICAgICAgICAgICAgICBcCisgICAgICAgIGlmIChm dW5jdGlvbiAoI25hbWVfLCBvcHRpb25UeXBlLCBkZXNjcmlwdGlvbl8sIHVzZXJEYXRhKSkgICAg ICBcCisgICAgICAgICAgICByZXR1cm47ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBcCisgICAgfQorCisgICAgT3B0aW9uczo6aW5pdGlhbGl6ZSgp OworICAgIEpTQ19PUFRJT05TKEZPUl9FQUNIX09QVElPTikKKyN1bmRlZiBGT1JfRUFDSF9PUFRJ T04KK30KKworc3RhdGljIGdib29sZWFuIHNldE9wdGlvbkVudHJ5KGNvbnN0IGNoYXIqIG9wdGlv bk5hbWVGdWxsLCBjb25zdCBjaGFyKiB2YWx1ZSwgZ3BvaW50ZXIsIEdFcnJvcioqIGVycm9yKQor eworICAgIGNvbnN0IGNoYXIqIG9wdGlvbk5hbWUgPSBvcHRpb25OYW1lRnVsbCArIDY7IC8vIFJl bW92ZSB0aGUgLS1qc2MtIHByZWZpeC4KKyAgICBHVW5pcXVlUHRyPGNoYXI+IG9wdGlvbihnX3N0 cmR1cF9wcmludGYoIiVzPSVzIiwgb3B0aW9uTmFtZSwgdmFsdWUpKTsKKyAgICBpZiAoIU9wdGlv bnM6OnNldE9wdGlvbihvcHRpb24uZ2V0KCkpKSB7CisgICAgICAgIGdfc2V0X2Vycm9yKGVycm9y LCBHX09QVElPTl9FUlJPUiwgR19PUFRJT05fRVJST1JfQkFEX1ZBTFVFLCAiRmFpbGVkIHBhcnNl IHZhbHVlICclcycgZm9yICVzIiwgdmFsdWUsIG9wdGlvbk5hbWVGdWxsKTsKKyAgICAgICAgcmV0 dXJuIEZBTFNFOworICAgIH0KKyAgICByZXR1cm4gVFJVRTsKK30KKworLyoqCisgKiBqc2Nfb3B0 aW9uc19nZXRfb3B0aW9uX2dyb3VwOgorICoKKyAqIENyZWF0ZSBhICNHT3B0aW9uR3JvdXAgdG8g aGFuZGxlICNKU0NPcHRpb25zIGFzIGNvbW1hbmQgbGluZSBhcmd1bWVudHMuCisgKiBUaGUgb3B0 aW9ucyB3aWxsIGJlIGV4cG9zZWQgYXMgY29tbWFuZCBsaW5lIGFyZ3VtZW50cyB3aXRoIHRoZSBm b3JtCisgKiBqc2MtPG9wdGlvbj49PHZhbHVlPi4gVGhlIGdyb3VwIGlzIHNldCB1cCB0byBhdXRv bWF0aWNhbGx5IHNldCB0aGUgI0pTQ09wdGlvbnMKKyAqIG9uIHBhcnNpbmcsIGFwcGxpY2F0aW9u cyBvbmx5IG5lZWQgdG8gcGFzcyB0aGUgZ3JvdXAgdG8gZ19vcHRpb25fY29udGV4dF9hZGRfZ3Jv dXAoKS4KKyAqCisgKiBSZXR1cm5zOiAodHJhbnNmZXIgZnVsbCk6IGEgI0dPcHRpb25Hcm91cCBm b3IgdGhlICNKU0NPcHRpb25zCisgKgorICogU2luY2U6IDIuMjQKKyAqLworR09wdGlvbkdyb3Vw KiBqc2Nfb3B0aW9uc19nZXRfb3B0aW9uX2dyb3VwKHZvaWQpCit7CisgICAgLy8gR09wdGlvbkVu dHJ5IHdvcmtzIHdpdGggY29uc3Qgc3RyaW5ncywgc28gd2UgbmVlZCB0byBrZWVwIHRoZSBvcHRp b24gbmFtZXMgYXJvdW5kLgorICAgIGF1dG8qIG5hbWVzID0gbmV3IFZlY3RvcjxHVW5pcXVlUHRy PGNoYXI+PjsKKyAgICBHT3B0aW9uR3JvdXAqIGdyb3VwID0gZ19vcHRpb25fZ3JvdXBfbmV3KCJq c2MiLCBfKCJKU0MgT3B0aW9ucyIpLCBfKCJTaG93IEpTQyBPcHRpb25zIiksIG5hbWVzLCBbXSAo Z3BvaW50ZXIgZGF0YSkgeyBkZWxldGUgc3RhdGljX2Nhc3Q8VmVjdG9yPEdVbmlxdWVQdHI8Y2hh cj4+Kj4oZGF0YSk7IH0pOworICAgIGdfb3B0aW9uX2dyb3VwX3NldF90cmFuc2xhdGlvbl9kb21h aW4oZ3JvdXAsIEdFVFRFWFRfUEFDS0FHRSk7CisKKyAgICBHQXJyYXkqIGVudHJpZXMgPSBnX2Fy cmF5X25ldyhUUlVFLCBUUlVFLCBzaXplb2YoR09wdGlvbkVudHJ5KSk7CisjZGVmaW5lIEZPUl9F QUNIX09QVElPTih0eXBlXywgbmFtZV8sIGRlZmF1bHRWYWx1ZV8sIGF2YWlsYWJpbGl0eV8sIGRl c2NyaXB0aW9uXykgXAorICAgIGlmIChPcHRpb25zOjpBdmFpbGFiaWxpdHk6OmF2YWlsYWJpbGl0 eV8gPT0gT3B0aW9uczo6QXZhaWxhYmlsaXR5OjpOb3JtYWwgXAorICAgICAgICB8fCBPcHRpb25z Ojppc0F2YWlsYWJsZShPcHRpb25zOjpuYW1lXyMjSUQsIE9wdGlvbnM6OkF2YWlsYWJpbGl0eTo6 YXZhaWxhYmlsaXR5XykpIHsgXAorICAgICAgICBHVW5pcXVlUHRyPGNoYXI+IG5hbWUoZ19zdHJk dXBfcHJpbnRmKCJqc2MtJXMiLCAjbmFtZV8pKTsgICAgICAgXAorICAgICAgICBlbnRyaWVzID0g Z19hcnJheV9zZXRfc2l6ZShlbnRyaWVzLCBlbnRyaWVzLT5sZW4gKyAxKTsgXAorICAgICAgICBH T3B0aW9uRW50cnkqIGVudHJ5ID0gJmdfYXJyYXlfaW5kZXgoZW50cmllcywgR09wdGlvbkVudHJ5 LCBlbnRyaWVzLT5sZW4gLSAxKTsgXAorICAgICAgICBlbnRyeS0+bG9uZ19uYW1lID0gbmFtZS5n ZXQoKTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgICAgICBlbnRyeS0+ YXJnID0gR19PUFRJT05fQVJHX0NBTExCQUNLOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg XAorICAgICAgICBlbnRyeS0+YXJnX2RhdGEgPSByZWludGVycHJldF9jYXN0PGdwb2ludGVyPihz ZXRPcHRpb25FbnRyeSk7ICAgXAorICAgICAgICBlbnRyeS0+ZGVzY3JpcHRpb24gPSBkZXNjcmlw dGlvbl87ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgICAgICBuYW1lcy0+YXBw ZW5kKFdURk1vdmUobmFtZSkpOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAor ICAgIH0KKworICAgIE9wdGlvbnM6OmluaXRpYWxpemUoKTsKKyAgICBKU0NfT1BUSU9OUyhGT1Jf RUFDSF9PUFRJT04pCisjdW5kZWYgRk9SX0VBQ0hfT1BUSU9OCisKKyAgICBnX29wdGlvbl9ncm91 cF9hZGRfZW50cmllcyhncm91cCwgcmVpbnRlcnByZXRfY2FzdDxHT3B0aW9uRW50cnkqPihlbnRy aWVzLT5kYXRhKSk7CisgICAgcmV0dXJuIGdyb3VwOworfQpkaWZmIC0tZ2l0IGEvU291cmNlL0ph dmFTY3JpcHRDb3JlL0FQSS9nbGliL0pTQ09wdGlvbnMuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9BUEkvZ2xpYi9KU0NPcHRpb25zLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAuLmZhZGQ5Yjc1MGQxCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL0FQSS9nbGliL0pTQ09wdGlvbnMuaApAQCAtMCwwICsxLDEwNSBAQAorLyoKKyAqIENvcHly aWdodCAoQykgMjAxOCBJZ2FsaWEgUy5MLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNv ZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRl ciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNl IGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAq IHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIg dmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUg dGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0 aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3Ig RklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFy eSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNo b3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJs aWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZ SU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1B IDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaWYgIWRlZmluZWQoX19KU0NfSF9JTlNJREVfXykg JiYgIWRlZmluZWQoSlNDX0NPTVBJTEFUSU9OKSAmJiAhZGVmaW5lZChXRUJLSVQyX0NPTVBJTEFU SU9OKQorI2Vycm9yICJPbmx5IDxqc2MvanNjLmg+IGNhbiBiZSBpbmNsdWRlZCBkaXJlY3RseS4i CisjZW5kaWYKKworI2lmbmRlZiBKU0NPcHRpb25zX2gKKyNkZWZpbmUgSlNDT3B0aW9uc19oCisK KyNpbmNsdWRlIDxnbGliLW9iamVjdC5oPgorI2luY2x1ZGUgPGpzYy9KU0NEZWZpbmVzLmg+CisK K0dfQkVHSU5fREVDTFMKKworSlNDX0FQSSBnYm9vbGVhbgoranNjX29wdGlvbnNfc2V0X2Jvb2xl YW4gICAgICAgKGNvbnN0IGNoYXIgKm9wdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBnYm9vbGVhbiAgICB2YWx1ZSk7CitKU0NfQVBJIGdib29sZWFuCitqc2Nfb3B0aW9uc19n ZXRfYm9vbGVhbiAgICAgICAoY29uc3QgY2hhciAqb3B0aW9uLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGdib29sZWFuICAgKnZhbHVlKTsKKworSlNDX0FQSSBnYm9vbGVhbgoranNj X29wdGlvbnNfc2V0X2ludCAgICAgICAgICAgKGNvbnN0IGNoYXIgKm9wdGlvbiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBnaW50ICAgICAgICB2YWx1ZSk7CitKU0NfQVBJIGdib29s ZWFuCitqc2Nfb3B0aW9uc19nZXRfaW50ICAgICAgICAgICAoY29uc3QgY2hhciAqb3B0aW9uLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdpbnQgICAgICAgKnZhbHVlKTsKKworSlND X0FQSSBnYm9vbGVhbgoranNjX29wdGlvbnNfc2V0X3VpbnQgICAgICAgICAgKGNvbnN0IGNoYXIg Km9wdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBndWludCAgICAgICB2YWx1 ZSk7CitKU0NfQVBJIGdib29sZWFuCitqc2Nfb3B0aW9uc19nZXRfdWludCAgICAgICAgICAoY29u c3QgY2hhciAqb3B0aW9uLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGd1aW50ICAg ICAgKnZhbHVlKTsKKworSlNDX0FQSSBnYm9vbGVhbgoranNjX29wdGlvbnNfc2V0X3NpemUgICAg ICAgICAgKGNvbnN0IGNoYXIgKm9wdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBnc2l6ZSAgICAgICB2YWx1ZSk7CitKU0NfQVBJIGdib29sZWFuCitqc2Nfb3B0aW9uc19nZXRf c2l6ZSAgICAgICAgICAoY29uc3QgY2hhciAqb3B0aW9uLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGdzaXplICAgICAgKnZhbHVlKTsKKworSlNDX0FQSSBnYm9vbGVhbgoranNjX29w dGlvbnNfc2V0X2RvdWJsZSAgICAgICAgKGNvbnN0IGNoYXIgKm9wdGlvbiwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBnZG91YmxlICAgICB2YWx1ZSk7CitKU0NfQVBJIGdib29sZWFu Citqc2Nfb3B0aW9uc19nZXRfZG91YmxlICAgICAgICAoY29uc3QgY2hhciAqb3B0aW9uLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdkb3VibGUgICAgKnZhbHVlKTsKKworSlNDX0FQ SSBnYm9vbGVhbgoranNjX29wdGlvbnNfc2V0X3N0cmluZyAgICAgICAgKGNvbnN0IGNoYXIgKm9w dGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICp2YWx1ZSk7 CitKU0NfQVBJIGdib29sZWFuCitqc2Nfb3B0aW9uc19nZXRfc3RyaW5nICAgICAgICAoY29uc3Qg Y2hhciAqb3B0aW9uLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNoYXIgICAgICAg Kip2YWx1ZSk7CisKK0pTQ19BUEkgZ2Jvb2xlYW4KK2pzY19vcHRpb25zX3NldF9yYW5nZV9zdHJp bmcgIChjb25zdCBjaGFyICpvcHRpb24sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg Y29uc3QgY2hhciAqdmFsdWUpOworSlNDX0FQSSBnYm9vbGVhbgoranNjX29wdGlvbnNfZ2V0X3Jh bmdlX3N0cmluZyAgKGNvbnN0IGNoYXIgKm9wdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBjaGFyICAgICAgICoqdmFsdWUpOworCit0eXBlZGVmIGVudW0geworICAgIEpTQ19P UFRJT05fQk9PTEVBTiwKKyAgICBKU0NfT1BUSU9OX0lOVCwKKyAgICBKU0NfT1BUSU9OX1VJTlQs CisgICAgSlNDX09QVElPTl9TSVpFLAorICAgIEpTQ19PUFRJT05fRE9VQkxFLAorICAgIEpTQ19P UFRJT05fU1RSSU5HLAorICAgIEpTQ19PUFRJT05fUkFOR0VfU1RSSU5HCit9IEpTQ09wdGlvblR5 cGU7CisKK3R5cGVkZWYgZ2Jvb2xlYW4gKCogSlNDT3B0aW9uc0Z1bmMpIChjb25zdCBjaGFyICAg ICpvcHRpb24sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSlNDT3B0aW9u VHlwZSAgdHlwZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBj aGFyICAgICpkZXNjcmlwdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBncG9pbnRlciAgICAgICB1c2VyX2RhdGEpOworCitKU0NfQVBJIHZvaWQKK2pzY19vcHRpb25z X2ZvcmVhY2ggICAgICAgICAgICAgICAgIChKU0NPcHRpb25zRnVuYyBmdW5jdGlvbiwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBncG9pbnRlciAgICAgICB1c2VyX2RhdGEp OworCitKU0NfQVBJIEdPcHRpb25Hcm91cCAqCitqc2Nfb3B0aW9uc19nZXRfb3B0aW9uX2dyb3Vw ICAgICAgICAodm9pZCk7CisKK0dfRU5EX0RFQ0xTCisKKyNlbmRpZiAvKiBKU0NPcHRpb25zX2gg Ki8KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9kb2NzL2pzYy1n bGliLTQuMC1zZWN0aW9ucy50eHQgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQVBJL2dsaWIvZG9j cy9qc2MtZ2xpYi00LjAtc2VjdGlvbnMudHh0CmluZGV4IGFkZDY4MmE0ODFhLi45YjZlNzAxNTQ1 ZSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0FQSS9nbGliL2RvY3MvanNjLWds aWItNC4wLXNlY3Rpb25zLnR4dAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQVBJL2dsaWIv ZG9jcy9qc2MtZ2xpYi00LjAtc2VjdGlvbnMudHh0CkBAIC0yMTEsNiArMjExLDMxIEBAIEpTQ19J U19DTEFTUwoganNjX2NsYXNzX2dldF90eXBlCiA8L1NFQ1RJT04+CiAKKzxTRUNUSU9OPgorPEZJ TEU+SlNDT3B0aW9uczwvRklMRT4KKzxUSVRMRT5KU0NPcHRpb25zPC9USVRMRT4KK2pzY19vcHRp b25zX3NldF9ib29sZWFuCitqc2Nfb3B0aW9uc19nZXRfYm9vbGVhbgoranNjX29wdGlvbnNfc2V0 X2ludAoranNjX29wdGlvbnNfZ2V0X2ludAoranNjX29wdGlvbnNfc2V0X3VpbnQKK2pzY19vcHRp b25zX2dldF91aW50Citqc2Nfb3B0aW9uc19zZXRfc2l6ZQoranNjX29wdGlvbnNfZ2V0X3NpemUK K2pzY19vcHRpb25zX3NldF9kb3VibGUKK2pzY19vcHRpb25zX2dldF9kb3VibGUKK2pzY19vcHRp b25zX3NldF9zdHJpbmcKK2pzY19vcHRpb25zX2dldF9zdHJpbmcKK2pzY19vcHRpb25zX3NldF9y YW5nZV9zdHJpbmcKK2pzY19vcHRpb25zX2dldF9yYW5nZV9zdHJpbmcKKworSlNDT3B0aW9uVHlw ZQorSlNDT3B0aW9uc0Z1bmMKK2pzY19vcHRpb25zX2ZvcmVhY2gKKworanNjX29wdGlvbnNfZ2V0 X29wdGlvbl9ncm91cAorPC9TRUNUSU9OPgorCiA8U0VDVElPTj4KIDxGSUxFPkpTQ1ZlcnNpb248 L0ZJTEU+CiA8VElUTEU+SlNDVmVyc2lvbjwvVElUTEU+CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvQVBJL2dsaWIvZG9jcy9qc2MtZ2xpYi1kb2NzLnNnbWwgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvQVBJL2dsaWIvZG9jcy9qc2MtZ2xpYi1kb2NzLnNnbWwKaW5kZXggNDg1M2Ex MDRjNmQuLjFjMmRiNWM3Yjk1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQVBJ L2dsaWIvZG9jcy9qc2MtZ2xpYi1kb2NzLnNnbWwKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L0FQSS9nbGliL2RvY3MvanNjLWdsaWItZG9jcy5zZ21sCkBAIC0xNyw2ICsxNyw3IEBACiAgICAg PHhpOmluY2x1ZGUgaHJlZj0ieG1sL0pTQ1dlYWtWYWx1ZS54bWwiLz4KICAgICA8eGk6aW5jbHVk ZSBocmVmPSJ4bWwvSlNDRXhjZXB0aW9uLnhtbCIvPgogICAgIDx4aTppbmNsdWRlIGhyZWY9Inht bC9KU0NDbGFzcy54bWwiLz4KKyAgICA8eGk6aW5jbHVkZSBocmVmPSJ4bWwvSlNDT3B0aW9ucy54 bWwiLz4KICAgICA8eGk6aW5jbHVkZSBocmVmPSJ4bWwvSlNDVmVyc2lvbi54bWwiLz4KICAgPC9j aGFwdGVyPgogCkBAIC0yNCw1ICsyNSwxMCBAQAogICAgIDx0aXRsZT5JbmRleDwvdGl0bGU+CiAg IDwvaW5kZXg+CiAKKyAgPGluZGV4IGlkPSJhcGktaW5kZXgtMi0yNCIgcm9sZT0iMi4yNCI+Cisg ICAgPHRpdGxlPkluZGV4IG9mIG5ldyBzeW1ib2xzIGluIDIuMjQ8L3RpdGxlPgorICAgIDx4aTpp bmNsdWRlIGhyZWY9InhtbC9hcGktaW5kZXgtMi4yNC54bWwiPjx4aTpmYWxsYmFjayAvPjwveGk6 aW5jbHVkZT4KKyAgPC9pbmRleD4KKwogICA8eGk6aW5jbHVkZSBocmVmPSJ4bWwvYW5ub3RhdGlv bi1nbG9zc2FyeS54bWwiPjx4aTpmYWxsYmFjayAvPjwveGk6aW5jbHVkZT4KIDwvYm9vaz4KZGlm ZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9qc2MuaCBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9qc2MuaAppbmRleCA4YTI4NDUyNDBhOC4uMTE1MzdmOWQ0 YTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9qc2MuaAorKysg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQVBJL2dsaWIvanNjLmgKQEAgLTI2LDYgKzI2LDcgQEAK ICNpbmNsdWRlIDxqc2MvSlNDQ29udGV4dC5oPgogI2luY2x1ZGUgPGpzYy9KU0NEZWZpbmVzLmg+ CiAjaW5jbHVkZSA8anNjL0pTQ0V4Y2VwdGlvbi5oPgorI2luY2x1ZGUgPGpzYy9KU0NPcHRpb25z Lmg+CiAjaW5jbHVkZSA8anNjL0pTQ1ZhbHVlLmg+CiAjaW5jbHVkZSA8anNjL0pTQ1ZlcnNpb24u aD4KICNpbmNsdWRlIDxqc2MvSlNDVmlydHVhbE1hY2hpbmUuaD4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9HTGliLmNtYWtlIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0dMaWIu Y21ha2UKaW5kZXggZGM4NWY0ZTdjNTkuLjRkMWZmZTVkNzlkIDEwMDY0NAotLS0gYS9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvR0xpYi5jbWFrZQorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvR0xp Yi5jbWFrZQpAQCAtOCw2ICs4LDcgQEAgbGlzdChBUFBFTkQgSmF2YVNjcmlwdENvcmVfU09VUkNF UwogICAgIEFQSS9nbGliL0pTQ0NsYXNzLmNwcAogICAgIEFQSS9nbGliL0pTQ0NvbnRleHQuY3Bw CiAgICAgQVBJL2dsaWIvSlNDRXhjZXB0aW9uLmNwcAorICAgIEFQSS9nbGliL0pTQ09wdGlvbnMu Y3BwCiAgICAgQVBJL2dsaWIvSlNDVmFsdWUuY3BwCiAgICAgQVBJL2dsaWIvSlNDVmVyc2lvbi5j cHAKICAgICBBUEkvZ2xpYi9KU0NWaXJ0dWFsTWFjaGluZS5jcHAKQEAgLTI4LDYgKzI5LDcgQEAg c2V0KEphdmFTY3JpcHRDb3JlX0lOU1RBTExFRF9IRUFERVJTCiAgICAgJHtKQVZBU0NSSVBUQ09S RV9ESVJ9L0FQSS9nbGliL0pTQ0NvbnRleHQuaAogICAgICR7SkFWQVNDUklQVENPUkVfRElSfS9B UEkvZ2xpYi9KU0NEZWZpbmVzLmgKICAgICAke0pBVkFTQ1JJUFRDT1JFX0RJUn0vQVBJL2dsaWIv SlNDRXhjZXB0aW9uLmgKKyAgICAke0pBVkFTQ1JJUFRDT1JFX0RJUn0vQVBJL2dsaWIvSlNDT3B0 aW9ucy5oCiAgICAgJHtKQVZBU0NSSVBUQ09SRV9ESVJ9L0FQSS9nbGliL0pTQ1ZhbHVlLmgKICAg ICAke0pBVkFTQ1JJUFRDT1JFX0RJUn0vQVBJL2dsaWIvSlNDVmlydHVhbE1hY2hpbmUuaAogICAg ICR7SkFWQVNDUklQVENPUkVfRElSfS9BUEkvZ2xpYi9KU0NXZWFrVmFsdWUuaApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL3BvL1BPVEZJTEVTLmluIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL3BvL1BPVEZJTEVTLmluCmluZGV4IDlmY2I4NmM3MTc4Li5hM2Jj ZjVhZmY5NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL3BvL1BPVEZJ TEVTLmluCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9wby9QT1RGSUxFUy5pbgpA QCAtMiw2ICsyLDcgQEAKIExvY2FsaXplZFN0cmluZ3NHdGsuY3BwCiAuLi9Mb2NhbGl6ZWRTdHJp bmdzLmNwcAogLi4vbmV0d29yay9zb3VwL05ldHdvcmtTdG9yYWdlU2Vzc2lvblNvdXAuY3BwCisu Li8uLi8uLi9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9KU0NPcHRpb25zLmNwcAogLi4vLi4vLi4v V2ViS2l0L1NoYXJlZC9BUEkvZ2xpYi9XZWJLaXRIaXRUZXN0UmVzdWx0LmNwcAogLi4vLi4vLi4v V2ViS2l0L1NoYXJlZC9BUEkvZ2xpYi9XZWJLaXRVUklSZXF1ZXN0LmNwcAogLi4vLi4vLi4vV2Vi S2l0L1NoYXJlZC9BUEkvZ2xpYi9XZWJLaXRVUklSZXNwb25zZS5jcHAKZGlmZiAtLWdpdCBhL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvSmF2YVNjcmlwdENvcmUvZ2xpYi9UZXN0SlNDLmNwcCBi L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvSmF2YVNjcmlwdENvcmUvZ2xpYi9UZXN0SlNDLmNw cAppbmRleCBmN2ZhNmFhY2RjMy4uN2U3NGY2OTU1MWMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdHMvSmF2YVNjcmlwdENvcmUvZ2xpYi9UZXN0SlNDLmNwcAorKysgYi9Ub29s cy9UZXN0V2ViS2l0QVBJL1Rlc3RzL0phdmFTY3JpcHRDb3JlL2dsaWIvVGVzdEpTQy5jcHAKQEAg LTMyMjcsNiArMzIyNywyMTEgQEAgc3RhdGljIHZvaWQgdGVzdHNKU0NWaXJ0dWFsTWFjaGluZSgp CiAgICAgfQogfQogCitzdGF0aWMgdm9pZCB0ZXN0c0pTQ09wdGlvbnMoKQoreworICAgIGdib29s ZWFuIHVzZUpJVDsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9ib29sZWFuKCJ1 c2VKSVQiLCAmdXNlSklUKSk7CisgICAgZ19hc3NlcnRfdHJ1ZSh1c2VKSVQpOworICAgIGdfYXNz ZXJ0X3RydWUoanNjX29wdGlvbnNfc2V0X2Jvb2xlYW4oInVzZUpJVCIsIEZBTFNFKSk7CisgICAg Z19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfYm9vbGVhbigidXNlSklUIiwgJnVzZUpJVCkp OworICAgIGdfYXNzZXJ0X2ZhbHNlKHVzZUpJVCk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0 aW9uc19zZXRfYm9vbGVhbigidXNlSklUIiwgVFJVRSkpOworCisgICAgZ2ludCB0aHJlc2hvbGRG b3JKSVRBZnRlcldhcm1VcDsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9pbnQo InRocmVzaG9sZEZvckpJVEFmdGVyV2FybVVwIiwgJnRocmVzaG9sZEZvckpJVEFmdGVyV2FybVVw KSk7CisgICAgZ19hc3NlcnRfY21waW50KHRocmVzaG9sZEZvckpJVEFmdGVyV2FybVVwLCA9PSwg NTAwKTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX3NldF9pbnQoInRocmVzaG9sZEZv ckpJVEFmdGVyV2FybVVwIiwgMTAwMCkpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNf Z2V0X2ludCgidGhyZXNob2xkRm9ySklUQWZ0ZXJXYXJtVXAiLCAmdGhyZXNob2xkRm9ySklUQWZ0 ZXJXYXJtVXApKTsKKyAgICBnX2Fzc2VydF9jbXBpbnQodGhyZXNob2xkRm9ySklUQWZ0ZXJXYXJt VXAsID09LCAxMDAwKTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX3NldF9pbnQoInRo cmVzaG9sZEZvckpJVEFmdGVyV2FybVVwIiwgNTAwKSk7CisKKyAgICBndWludCBtYXhQZXJUaHJl YWRTdGFja1VzYWdlOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X3VpbnQoIm1h eFBlclRocmVhZFN0YWNrVXNhZ2UiLCAmbWF4UGVyVGhyZWFkU3RhY2tVc2FnZSkpOworICAgIGdf YXNzZXJ0X2NtcHVpbnQobWF4UGVyVGhyZWFkU3RhY2tVc2FnZSwgPT0sIDQxOTQzMDQpOworICAg IGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfc2V0X3VpbnQoIm1heFBlclRocmVhZFN0YWNrVXNh Z2UiLCA0MDk2KSk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfdWludCgibWF4 UGVyVGhyZWFkU3RhY2tVc2FnZSIsICZtYXhQZXJUaHJlYWRTdGFja1VzYWdlKSk7CisgICAgZ19h c3NlcnRfY21wdWludChtYXhQZXJUaHJlYWRTdGFja1VzYWdlLCA9PSwgNDA5Nik7CisgICAgZ19h c3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRfdWludCgibWF4UGVyVGhyZWFkU3RhY2tVc2FnZSIs IDQxOTQzMDQpKTsKKworICAgIGdzaXplIHdlYkFzc2VtYmx5UGFydGlhbENvbXBpbGVMaW1pdDsK KyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9zaXplKCJ3ZWJBc3NlbWJseVBhcnRp YWxDb21waWxlTGltaXQiLCAmd2ViQXNzZW1ibHlQYXJ0aWFsQ29tcGlsZUxpbWl0KSk7CisgICAg Z19hc3NlcnRfY21wdWludCh3ZWJBc3NlbWJseVBhcnRpYWxDb21waWxlTGltaXQsID09LCA1MDAw KTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX3NldF9zaXplKCJ3ZWJBc3NlbWJseVBh cnRpYWxDb21waWxlTGltaXQiLCA2MDAwKSk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9u c19nZXRfc2l6ZSgid2ViQXNzZW1ibHlQYXJ0aWFsQ29tcGlsZUxpbWl0IiwgJndlYkFzc2VtYmx5 UGFydGlhbENvbXBpbGVMaW1pdCkpOworICAgIGdfYXNzZXJ0X2NtcHVpbnQod2ViQXNzZW1ibHlQ YXJ0aWFsQ29tcGlsZUxpbWl0LCA9PSwgNjAwMCk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0 aW9uc19zZXRfc2l6ZSgid2ViQXNzZW1ibHlQYXJ0aWFsQ29tcGlsZUxpbWl0IiwgNTAwMCkpOwor CisgICAgZ2RvdWJsZSBzbWFsbEhlYXBSQU1GcmFjdGlvbjsKKyAgICBnX2Fzc2VydF90cnVlKGpz Y19vcHRpb25zX2dldF9kb3VibGUoInNtYWxsSGVhcFJBTUZyYWN0aW9uIiwgJnNtYWxsSGVhcFJB TUZyYWN0aW9uKSk7CisgICAgZ19hc3NlcnRfY21wZmxvYXQoc21hbGxIZWFwUkFNRnJhY3Rpb24s ID09LCAwLjI1KTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX3NldF9kb3VibGUoInNt YWxsSGVhcFJBTUZyYWN0aW9uIiwgMC41MCkpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlv bnNfZ2V0X2RvdWJsZSgic21hbGxIZWFwUkFNRnJhY3Rpb24iLCAmc21hbGxIZWFwUkFNRnJhY3Rp b24pKTsKKyAgICBnX2Fzc2VydF9jbXBmbG9hdChzbWFsbEhlYXBSQU1GcmFjdGlvbiwgPT0sIDAu NTApOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfc2V0X2RvdWJsZSgic21hbGxIZWFw UkFNRnJhY3Rpb24iLCAwLjI1KSk7CisKKyAgICBHVW5pcXVlT3V0UHRyPGNoYXI+IGNvbmZpZ0Zp bGU7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfc3RyaW5nKCJjb25maWdGaWxl IiwgJmNvbmZpZ0ZpbGUub3V0UHRyKCkpKTsKKyAgICBnX2Fzc2VydF9udWxsKGNvbmZpZ0ZpbGUu Z2V0KCkpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfc2V0X3N0cmluZygiY29uZmln RmlsZSIsICIvdG1wL2ZvbyIpKTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9z dHJpbmcoImNvbmZpZ0ZpbGUiLCAmY29uZmlnRmlsZS5vdXRQdHIoKSkpOworICAgIGdfYXNzZXJ0 X2NtcHN0cihjb25maWdGaWxlLmdldCgpLCA9PSwgIi90bXAvZm9vIik7CisgICAgZ19hc3NlcnRf dHJ1ZShqc2Nfb3B0aW9uc19zZXRfc3RyaW5nKCJjb25maWdGaWxlIiwgbnVsbHB0cikpOworICAg IGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X3N0cmluZygiY29uZmlnRmlsZSIsICZjb25m aWdGaWxlLm91dFB0cigpKSk7CisgICAgZ19hc3NlcnRfbnVsbChjb25maWdGaWxlLmdldCgpKTsK KworICAgIEdVbmlxdWVPdXRQdHI8Y2hhcj4gYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZTsKKyAg ICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9yYW5nZV9zdHJpbmcoImJ5dGVjb2RlUmFu Z2VUb0pJVENvbXBpbGUiLCAmYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZS5vdXRQdHIoKSkpOwor ICAgIGdfYXNzZXJ0X251bGwoYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZS5nZXQoKSk7CisgICAg Z19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRfcmFuZ2Vfc3RyaW5nKCJieXRlY29kZVJhbmdl VG9KSVRDb21waWxlIiwgIjEwMCIpKTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dl dF9yYW5nZV9zdHJpbmcoImJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUiLCAmYnl0ZWNvZGVSYW5n ZVRvSklUQ29tcGlsZS5vdXRQdHIoKSkpOworICAgIGdfYXNzZXJ0X2NtcHN0cihieXRlY29kZVJh bmdlVG9KSVRDb21waWxlLmdldCgpLCA9PSwgIjEwMCIpOworICAgIGdfYXNzZXJ0X3RydWUoanNj X29wdGlvbnNfc2V0X3JhbmdlX3N0cmluZygiYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZSIsICIx MDA6MjAwIikpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X3JhbmdlX3N0cmlu ZygiYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZSIsICZieXRlY29kZVJhbmdlVG9KSVRDb21waWxl Lm91dFB0cigpKSk7CisgICAgZ19hc3NlcnRfY21wc3RyKGJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBp bGUuZ2V0KCksID09LCAiMTAwOjIwMCIpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNf c2V0X3JhbmdlX3N0cmluZygiYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZSIsICIhMTAwOjIwMCIp KTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9yYW5nZV9zdHJpbmcoImJ5dGVj b2RlUmFuZ2VUb0pJVENvbXBpbGUiLCAmYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZS5vdXRQdHIo KSkpOworICAgIGdfYXNzZXJ0X2NtcHN0cihieXRlY29kZVJhbmdlVG9KSVRDb21waWxlLmdldCgp LCA9PSwgIiExMDA6MjAwIik7CisgICAgZ19hc3NlcnRfZmFsc2UoanNjX29wdGlvbnNfc2V0X3Jh bmdlX3N0cmluZygiYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZSIsICIyMDA6MTAwIikpOworICAg IGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X3JhbmdlX3N0cmluZygiYnl0ZWNvZGVSYW5n ZVRvSklUQ29tcGlsZSIsICZieXRlY29kZVJhbmdlVG9KSVRDb21waWxlLm91dFB0cigpKSk7Cisg ICAgZ19hc3NlcnRfY21wc3RyKGJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUuZ2V0KCksID09LCAi ITEwMDoyMDAiKTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX3NldF9yYW5nZV9zdHJp bmcoImJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUiLCBudWxscHRyKSk7CisgICAgZ19hc3NlcnRf dHJ1ZShqc2Nfb3B0aW9uc19nZXRfcmFuZ2Vfc3RyaW5nKCJieXRlY29kZVJhbmdlVG9KSVRDb21w aWxlIiwgJmJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUub3V0UHRyKCkpKTsKKyAgICBnX2Fzc2Vy dF9udWxsKGJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUuZ2V0KCkpOworCisgICAgZ3VpbnQgbG9n R0M7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfdWludCgibG9nR0MiLCAmbG9n R0MpKTsKKyAgICBnX2Fzc2VydF9jbXB1aW50KGxvZ0dDLCA9PSwgMCk7CisgICAgZ19hc3NlcnRf dHJ1ZShqc2Nfb3B0aW9uc19zZXRfdWludCgibG9nR0MiLCAxKSk7CisgICAgZ19hc3NlcnRfdHJ1 ZShqc2Nfb3B0aW9uc19nZXRfdWludCgibG9nR0MiLCAmbG9nR0MpKTsKKyAgICBnX2Fzc2VydF9j bXB1aW50KGxvZ0dDLCA9PSwgMSk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRf dWludCgibG9nR0MiLCAyKSk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfdWlu dCgibG9nR0MiLCAmbG9nR0MpKTsKKyAgICBnX2Fzc2VydF9jbXB1aW50KGxvZ0dDLCA9PSwgMik7 CisgICAgZ19hc3NlcnRfZmFsc2UoanNjX29wdGlvbnNfc2V0X3VpbnQoImxvZ0dDIiwgMykpOwor ICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X3VpbnQoImxvZ0dDIiwgJmxvZ0dDKSk7 CisgICAgZ19hc3NlcnRfY21wdWludChsb2dHQywgPT0sIDIpOworICAgIGdfYXNzZXJ0X3RydWUo anNjX29wdGlvbnNfc2V0X3VpbnQoImxvZ0dDIiwgMCkpOworICAgIGdfYXNzZXJ0X3RydWUoanNj X29wdGlvbnNfZ2V0X3VpbnQoImxvZ0dDIiwgJmxvZ0dDKSk7CisgICAgZ19hc3NlcnRfY21wdWlu dChsb2dHQywgPT0sIDApOworCisgICAgZ2Jvb2xlYW4gdmFsdWUgPSBUUlVFOworICAgIGdfYXNz ZXJ0X2ZhbHNlKGpzY19vcHRpb25zX2dldF9ib29sZWFuKCJJbnZhbGlkT3B0aW9uIiwgJnZhbHVl KSk7CisgICAgZ19hc3NlcnRfdHJ1ZSh2YWx1ZSk7CisgICAgZ19hc3NlcnRfZmFsc2UoanNjX29w dGlvbnNfc2V0X2Jvb2xlYW4oIkludmFsaWRPcHRpb24iLCBUUlVFKSk7CisgICAgZ19hc3NlcnRf ZmFsc2UoanNjX29wdGlvbnNfZ2V0X2Jvb2xlYW4oIkludmFsaWRPcHRpb24iLCAmdmFsdWUpKTsK KyAgICBnX2Fzc2VydF90cnVlKHZhbHVlKTsKKworICAgIC8vIEZpbmQgYSBwYXJ0aWN1bGFyIG9w dGlvbi4KKyAgICBib29sIGZvdW5kID0gZmFsc2U7CisgICAganNjX29wdGlvbnNfZm9yZWFjaChb XShjb25zdCBjaGFyKiBvcHRpb24sIEpTQ09wdGlvblR5cGUgdHlwZSwgY29uc3QgY2hhciogZGVz Y3JpcHRpb24sIGdwb2ludGVyIHVzZXJEYXRhKSAtPiBnYm9vbGVhbiB7CisgICAgICAgIGlmICgh Z19zdHJjbXAwKG9wdGlvbiwgInVzZUpJVCIpKSB7CisgICAgICAgICAgICAqc3RhdGljX2Nhc3Q8 Ym9vbCo+KHVzZXJEYXRhKSA9IHRydWU7CisgICAgICAgICAgICByZXR1cm4gVFJVRTsKKyAgICAg ICAgfQorICAgICAgICByZXR1cm4gRkFMU0U7CisgICAgfSwgJmZvdW5kKTsKKyAgICBnX2Fzc2Vy dF90cnVlKGZvdW5kKTsKKworICAgIHVuc2lnbmVkIG9wdGlvbnNDb3VudCA9IDA7CisgICAganNj X29wdGlvbnNfZm9yZWFjaChbXShjb25zdCBjaGFyKiBvcHRpb24sIEpTQ09wdGlvblR5cGUgdHlw ZSwgY29uc3QgY2hhciogZGVzY3JpcHRpb24sIGdwb2ludGVyIHVzZXJEYXRhKSAtPiBnYm9vbGVh biB7CisgICAgICAgICgqc3RhdGljX2Nhc3Q8dW5zaWduZWQqPih1c2VyRGF0YSkpKys7CisgICAg ICAgIHJldHVybiBGQUxTRTsKKyAgICB9LCAmb3B0aW9uc0NvdW50KTsKKyAgICBnX2Fzc2VydF9j bXB1aW50KG9wdGlvbnNDb3VudCwgPiwgMTAwKTsKKyAgICBnX2Fzc2VydF9jbXB1aW50KG9wdGlv bnNDb3VudCwgPCwgNTAwKTsKKworICAgIG9wdGlvbnNDb3VudCA9IDA7CisgICAganNjX29wdGlv bnNfZm9yZWFjaChbXShjb25zdCBjaGFyKiBvcHRpb24sIEpTQ09wdGlvblR5cGUgdHlwZSwgY29u c3QgY2hhciogZGVzY3JpcHRpb24sIGdwb2ludGVyIHVzZXJEYXRhKSAtPiBnYm9vbGVhbiB7Cisg ICAgICAgIGlmICghZ19zdHJjbXAwKG9wdGlvbiwgInVzZUpJVCIpKQorICAgICAgICAgICAgZ19h c3NlcnRfdHJ1ZSh0eXBlID09IEpTQ19PUFRJT05fQk9PTEVBTik7CisgICAgICAgIGVsc2UgaWYg KCFnX3N0cmNtcDAob3B0aW9uLCAidGhyZXNob2xkRm9ySklUQWZ0ZXJXYXJtVXAiKSkKKyAgICAg ICAgICAgIGdfYXNzZXJ0X3RydWUodHlwZSA9PSBKU0NfT1BUSU9OX0lOVCk7CisgICAgICAgIGVs c2UgaWYgKCFnX3N0cmNtcDAob3B0aW9uLCAibWF4UGVyVGhyZWFkU3RhY2tVc2FnZSIpKQorICAg ICAgICAgICAgZ19hc3NlcnRfdHJ1ZSh0eXBlID09IEpTQ19PUFRJT05fVUlOVCk7CisgICAgICAg IGVsc2UgaWYgKCFnX3N0cmNtcDAob3B0aW9uLCAid2ViQXNzZW1ibHlQYXJ0aWFsQ29tcGlsZUxp bWl0IikpCisgICAgICAgICAgICBnX2Fzc2VydF90cnVlKHR5cGUgPT0gSlNDX09QVElPTl9TSVpF KTsKKyAgICAgICAgZWxzZSBpZiAoIWdfc3RyY21wMChvcHRpb24sICJzbWFsbEhlYXBSQU1GcmFj dGlvbiIpKQorICAgICAgICAgICAgZ19hc3NlcnRfdHJ1ZSh0eXBlID09IEpTQ19PUFRJT05fRE9V QkxFKTsKKyAgICAgICAgZWxzZSBpZiAoIWdfc3RyY21wMChvcHRpb24sICJjb25maWdGaWxlIikp CisgICAgICAgICAgICBnX2Fzc2VydF90cnVlKHR5cGUgPT0gSlNDX09QVElPTl9TVFJJTkcpOwor ICAgICAgICBlbHNlIGlmICghZ19zdHJjbXAwKG9wdGlvbiwgImJ5dGVjb2RlUmFuZ2VUb0pJVENv bXBpbGUiKSkKKyAgICAgICAgICAgIGdfYXNzZXJ0X3RydWUodHlwZSA9PSBKU0NfT1BUSU9OX1JB TkdFX1NUUklORyk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHJldHVybiBGQUxTRTsKKwor ICAgICAgICAoKnN0YXRpY19jYXN0PHVuc2lnbmVkKj4odXNlckRhdGEpKSsrOworICAgICAgICBy ZXR1cm4gRkFMU0U7CisgICAgfSwgJm9wdGlvbnNDb3VudCk7CisgICAgZ19hc3NlcnRfY21wdWlu dChvcHRpb25zQ291bnQsID09LCA3KTsKKworICAgIEdPcHRpb25Db250ZXh0KiBjb250ZXh0ID0g Z19vcHRpb25fY29udGV4dF9uZXcobnVsbHB0cik7CisgICAgZ19vcHRpb25fY29udGV4dF9hZGRf Z3JvdXAoY29udGV4dCwganNjX29wdGlvbnNfZ2V0X29wdGlvbl9ncm91cCgpKTsKKyAgICBzdGF0 aWMgY29uc3QgY2hhciogYXJndltdID0geworICAgICAgICBfX0ZJTEVfXywKKyAgICAgICAgIi0t anNjLXVzZUpJVD1mYWxzZSIsCisgICAgICAgICItLWpzYy10aHJlc2hvbGRGb3JKSVRBZnRlcldh cm1VcD0yMDAwIiwKKyAgICAgICAgIi0tanNjLW1heFBlclRocmVhZFN0YWNrVXNhZ2U9MTAyNCIs CisgICAgICAgICItLWpzYy13ZWJBc3NlbWJseVBhcnRpYWxDb21waWxlTGltaXQ9NDAwMCIsCisg ICAgICAgICItLWpzYy1zbWFsbEhlYXBSQU1GcmFjdGlvbj0wLjc1IiwKKyAgICAgICAgIi0tanNj LWNvbmZpZ0ZpbGU9L3RtcC9iYXIiLAorICAgICAgICAiLS1qc2MtYnl0ZWNvZGVSYW5nZVRvSklU Q29tcGlsZT0xMDA6MzAwIiwKKyAgICAgICAgIi0tanNjLWxvZ0dDPTEiLAorICAgICAgICBudWxs cHRyCisgICAgfTsKKyAgICBHVW5pcXVlUHRyPGNoYXIqPiBjb3B5KGdfc3RyZHVwdihjb25zdF9j YXN0PGNoYXIqKj4oYXJndikpKTsKKyAgICBpbnQgYXJnYyA9IGdfc3Rydl9sZW5ndGgoY29weS5n ZXQoKSk7CisgICAgYXV0byogY29weVB0ciA9IGNvcHkuZ2V0KCk7CisgICAgZ19hc3NlcnRfdHJ1 ZShnX29wdGlvbl9jb250ZXh0X3BhcnNlKGNvbnRleHQsICZhcmdjLCAmY29weVB0ciwgbnVsbHB0 cikpOworICAgIGdfb3B0aW9uX2NvbnRleHRfZnJlZShjb250ZXh0KTsKKworICAgIGdfYXNzZXJ0 X3RydWUoanNjX29wdGlvbnNfZ2V0X2Jvb2xlYW4oInVzZUpJVCIsICZ1c2VKSVQpKTsKKyAgICBn X2Fzc2VydF9mYWxzZSh1c2VKSVQpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0 X2ludCgidGhyZXNob2xkRm9ySklUQWZ0ZXJXYXJtVXAiLCAmdGhyZXNob2xkRm9ySklUQWZ0ZXJX YXJtVXApKTsKKyAgICBnX2Fzc2VydF9jbXBpbnQodGhyZXNob2xkRm9ySklUQWZ0ZXJXYXJtVXAs ID09LCAyMDAwKTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF91aW50KCJtYXhQ ZXJUaHJlYWRTdGFja1VzYWdlIiwgJm1heFBlclRocmVhZFN0YWNrVXNhZ2UpKTsKKyAgICBnX2Fz c2VydF9jbXB1aW50KG1heFBlclRocmVhZFN0YWNrVXNhZ2UsID09LCAxMDI0KTsKKyAgICBnX2Fz c2VydF90cnVlKGpzY19vcHRpb25zX2dldF9zaXplKCJ3ZWJBc3NlbWJseVBhcnRpYWxDb21waWxl TGltaXQiLCAmd2ViQXNzZW1ibHlQYXJ0aWFsQ29tcGlsZUxpbWl0KSk7CisgICAgZ19hc3NlcnRf Y21wdWludCh3ZWJBc3NlbWJseVBhcnRpYWxDb21waWxlTGltaXQsID09LCA0MDAwKTsKKyAgICBn X2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9kb3VibGUoInNtYWxsSGVhcFJBTUZyYWN0aW9u IiwgJnNtYWxsSGVhcFJBTUZyYWN0aW9uKSk7CisgICAgZ19hc3NlcnRfY21wZmxvYXQoc21hbGxI ZWFwUkFNRnJhY3Rpb24sID09LCAwLjc1KTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25z X2dldF9zdHJpbmcoImNvbmZpZ0ZpbGUiLCAmY29uZmlnRmlsZS5vdXRQdHIoKSkpOworICAgIGdf YXNzZXJ0X2NtcHN0cihjb25maWdGaWxlLmdldCgpLCA9PSwgIi90bXAvYmFyIik7CisgICAgZ19h c3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfcmFuZ2Vfc3RyaW5nKCJieXRlY29kZVJhbmdlVG9K SVRDb21waWxlIiwgJmJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUub3V0UHRyKCkpKTsKKyAgICBn X2Fzc2VydF9jbXBzdHIoYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZS5nZXQoKSwgPT0sICIxMDA6 MzAwIik7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfdWludCgibG9nR0MiLCAm bG9nR0MpKTsKKyAgICBnX2Fzc2VydF9jbXB1aW50KGxvZ0dDLCA9PSwgMSk7CisKKyAgICAvLyBS ZXN0b3JlIG9wdGlvbnMgdGhlaXIgZGVmYXVsdCB2YWx1ZXMuCisgICAgZ19hc3NlcnRfdHJ1ZShq c2Nfb3B0aW9uc19zZXRfYm9vbGVhbigidXNlSklUIiwgVFJVRSkpOworICAgIGdfYXNzZXJ0X3Ry dWUoanNjX29wdGlvbnNfc2V0X2ludCgidGhyZXNob2xkRm9ySklUQWZ0ZXJXYXJtVXAiLCA1MDAp KTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX3NldF91aW50KCJtYXhQZXJUaHJlYWRT dGFja1VzYWdlIiwgNDE5NDMwNCkpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfc2V0 X3NpemUoIndlYkFzc2VtYmx5UGFydGlhbENvbXBpbGVMaW1pdCIsIDUwMDApKTsKKyAgICBnX2Fz c2VydF90cnVlKGpzY19vcHRpb25zX3NldF9kb3VibGUoInNtYWxsSGVhcFJBTUZyYWN0aW9uIiwg MC4yNSkpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfc2V0X3N0cmluZygiY29uZmln RmlsZSIsIG51bGxwdHIpKTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX3NldF9yYW5n ZV9zdHJpbmcoImJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUiLCBudWxscHRyKSk7CisgICAgZ19h c3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRfdWludCgibG9nR0MiLCAwKSk7CisKKyAgICBjb250 ZXh0ID0gZ19vcHRpb25fY29udGV4dF9uZXcobnVsbHB0cik7CisgICAgZ19vcHRpb25fY29udGV4 dF9hZGRfZ3JvdXAoY29udGV4dCwganNjX29wdGlvbnNfZ2V0X29wdGlvbl9ncm91cCgpKTsKKyAg ICBzdGF0aWMgY29uc3QgY2hhciogYXJndjJbXSA9IHsgX19GSUxFX18sICItLWpzYy1JbnZhbGlk T3B0aW9uPXRydWUiLCBudWxscHRyIH07CisgICAgY29weS5yZXNldChnX3N0cmR1cHYoY29uc3Rf Y2FzdDxjaGFyKio+KGFyZ3YyKSkpOworICAgIGFyZ2MgPSBnX3N0cnZfbGVuZ3RoKGNvcHkuZ2V0 KCkpOworICAgIGNvcHlQdHIgPSBjb3B5LmdldCgpOworICAgIGdfYXNzZXJ0X2ZhbHNlKGdfb3B0 aW9uX2NvbnRleHRfcGFyc2UoY29udGV4dCwgJmFyZ2MsICZjb3B5UHRyLCBudWxscHRyKSk7Cisg ICAgZ19vcHRpb25fY29udGV4dF9mcmVlKGNvbnRleHQpOworCisgICAgY29udGV4dCA9IGdfb3B0 aW9uX2NvbnRleHRfbmV3KG51bGxwdHIpOworICAgIGdfb3B0aW9uX2NvbnRleHRfYWRkX2dyb3Vw KGNvbnRleHQsIGpzY19vcHRpb25zX2dldF9vcHRpb25fZ3JvdXAoKSk7CisgICAgc3RhdGljIGNv bnN0IGNoYXIqIGFyZ3YzW10gPSB7IF9fRklMRV9fLCAiLS1qc2MtdXNlSklUPW5laW4iLCBudWxs cHRyIH07CisgICAgY29weS5yZXNldChnX3N0cmR1cHYoY29uc3RfY2FzdDxjaGFyKio+KGFyZ3Yz KSkpOworICAgIGFyZ2MgPSBnX3N0cnZfbGVuZ3RoKGNvcHkuZ2V0KCkpOworICAgIGNvcHlQdHIg PSBjb3B5LmdldCgpOworICAgIGdfYXNzZXJ0X2ZhbHNlKGdfb3B0aW9uX2NvbnRleHRfcGFyc2Uo Y29udGV4dCwgJmFyZ2MsICZjb3B5UHRyLCBudWxscHRyKSk7CisgICAgZ19vcHRpb25fY29udGV4 dF9mcmVlKGNvbnRleHQpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X2Jvb2xl YW4oInVzZUpJVCIsICZ1c2VKSVQpKTsKKyAgICBnX2Fzc2VydF90cnVlKHVzZUpJVCk7Cit9CisK ICNpZmRlZiBHX0RFRklORV9BVVRPUFRSX0NMRUFOVVBfRlVOQwogc3RhdGljIHZvaWQgdGVzdHNK U0NBdXRvY2xlYW51cHMoKQogewpAQCAtMzI3MCw2ICszNDc1LDcgQEAgaW50IG1haW4oaW50IGFy Z2MsIGNoYXIqKiBhcmd2KQogICAgIGdfdGVzdF9hZGRfZnVuYygiL2pzYy9nYXJiYWdlLWNvbGxl Y3RvciIsIHRlc3RKU0NHYXJiYWdlQ29sbGVjdG9yKTsKICAgICBnX3Rlc3RfYWRkX2Z1bmMoIi9q c2Mvd2Vhay12YWx1ZSIsIHRlc3RKU0NXZWFrVmFsdWUpOwogICAgIGdfdGVzdF9hZGRfZnVuYygi L2pzYy92bSIsIHRlc3RzSlNDVmlydHVhbE1hY2hpbmUpOworICAgIGdfdGVzdF9hZGRfZnVuYygi L2pzYy9vcHRpb25zIiwgdGVzdHNKU0NPcHRpb25zKTsKICNpZmRlZiBHX0RFRklORV9BVVRPUFRS X0NMRUFOVVBfRlVOQwogICAgIGdfdGVzdF9hZGRfZnVuYygiL2pzYy9hdXRvY2xlYW51cHMiLCB0 ZXN0c0pTQ0F1dG9jbGVhbnVwcyk7CiAjZW5kaWYK 349021 2018-09-06 06:44:02 -0700 2019-01-15 02:33:51 -0800 WIP jsc-glib-options.diff text/plain 39624 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9KU0NPcHRpb25zLmNw cCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9KU0NPcHRpb25zLmNwcApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uNzdmN2ZmNTI4NTAKLS0tIC9kZXYvbnVs bAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQVBJL2dsaWIvSlNDT3B0aW9ucy5jcHAKQEAg LTAsMCArMSw2ODAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTggSWdhbGlhIFMuTC4KKyAq CisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUg aXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFy eSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29m dHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9y IChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5 IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBi dXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50 eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3Ig bW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2Yg dGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhp cyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisg KiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQs IEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2lu Y2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkpTQ09wdGlvbnMuaCIKKworI2luY2x1ZGUgIk9w dGlvbnMuaCIKKyNpbmNsdWRlIDxnbGliL2dpMThuLWxpYi5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0 b3IuaD4KKyNpbmNsdWRlIDx3dGYvZ2xpYi9HVW5pcXVlUHRyLmg+CisKKy8qKgorICogU0VDVElP TjogSlNDT3B0aW9ucworICogQHNob3J0X2Rlc2NyaXB0aW9uOiBKYXZhU2NyaXB0IG9wdGlvbnMK KyAqIEB0aXRsZTogSlNDT3B0aW9ucworICoKKyAqIEphdmFTY3JpcHQgb3B0aW9ucyBhbGxvdyB0 byBjaGFuZ2UgdGhlIGJlaGF2aW9yIG9mIHRoZSBKYXZhU2NyaXB0IGVuZ2luZS4KKyAqIFRoZXkg YWZmZWN0IHRoZSB3YXkgdGhlIGVuZ2luZSB3b3Jrcywgc28gaXQncyBlbmNvdXJhZ2VkIHRvIHNl dCB0aGUgb3B0aW9ucworICogYXQgdGhlIHZlcnkgYmVnaW5uaW5nIG9mIHRoZSBwcm9ncmFtIGV4 ZWN1dGlvbiwgYmVmb3JlIGFueSBvdGhlciBKYXZhU2NyaXB0CisgKiBBUEkgY2FsbC4gTW9zdCBv ZiB0aGUgb3B0aW9ucyBhcmUgb25seSB1c2VmdWwgZm9yIHRlc3RpbmcgYW5kIGRlYnVnZ2luZy4K KyAqIE9ubHkgYSBmZXcgb2YgdGhlbSBhcmUgZG9jdW1lbnRlZCwgeW91IGNhbiB1c2UgdGhlIHVu ZG9jdW1tZW50ZWQgb3B0aW9ucyBhdAorICogeW91ciBvd24gcmlzayAoeW91IGNhbiBmaW5kIHRo ZSBsaXN0IG9mIG9wdGlvbnMgaW4gdGhlIFdlYktpdCBzb3VyY2UgY29kZSkuCisgKgorICogVGhl IEFQSSBhbGxvd3MgdG8gc2V0IGFuZCBnZXQgYW55IG9wdGlvbiB1c2luZyB0aGUgdHlwZXMgZGVm aW5lZCBpbiAjSlNDT3B0aW9uVHlwZS4KKyAqIFlvdSBjYW4gYWxzbyBpdGVyYXRlIGFsbCB0aGUg YXZhaWxhYmxlIG9wdGlvbnMgdXNpbmcganNjX29wdGlvbnNfZm9yZWFjaCgpIGFuZAorICogcGFz c2luZyBhICNKU0NPcHRpb25zRnVuYyBjYWxsYmFjay4gSWYgeW91ciBhcHBsaWNhdGlvbiB1c2Vz ICNHT3B0aW9uQ29udGV4dCB0byBoYW5kbGUKKyAqIGNvbW1hbmQgbGluZSBhcmd1bWVudHMsIHlv dSBjYW4gZWFzaWx5IGludGVncmF0ZSB0aGUgSlNDT3B0aW9ucyBieSBhZGRpbmcgdGhlCisgKiAj R09wdGlvbkdyb3VwIHJldHVybmVkIGJ5IGpzY19vcHRpb25zX2dldF9vcHRpb25fZ3JvdXAoKS4K KyAqCisgKiBTaW5jZTogMi4yNAorICovCisKK3VzaW5nIG5hbWVzcGFjZSBKU0M7CisKK3R5cGVk ZWYgaW50MzJfdCBpbnQzMjsKK3R5cGVkZWYgc2l6ZV90IHNpemU7CisKK3N0YXRpYyBib29sIHZh bHVlRnJvbUdWYWx1ZShjb25zdCBHVmFsdWUqIGdWYWx1ZSwgYm9vbCYgdmFsdWUpCit7CisgICAg dmFsdWUgPSBnX3ZhbHVlX2dldF9ib29sZWFuKGdWYWx1ZSk7CisgICAgcmV0dXJuIHRydWU7Cit9 CisKK3N0YXRpYyB2b2lkIHZhbHVlVG9HVmFsdWUoYm9vbCB2YWx1ZSwgR1ZhbHVlKiBnVmFsdWUp Cit7CisgICAgZ192YWx1ZV9zZXRfYm9vbGVhbihnVmFsdWUsIHZhbHVlKTsKK30KKworc3RhdGlj IGJvb2wgdmFsdWVGcm9tR1ZhbHVlKGNvbnN0IEdWYWx1ZSogZ1ZhbHVlLCBpbnQzMl90JiB2YWx1 ZSkKK3sKKyAgICB2YWx1ZSA9IGdfdmFsdWVfZ2V0X2ludChnVmFsdWUpOworICAgIHJldHVybiB0 cnVlOworfQorCitzdGF0aWMgdm9pZCB2YWx1ZVRvR1ZhbHVlKGludDMyX3QgdmFsdWUsIEdWYWx1 ZSogZ1ZhbHVlKQoreworICAgIGdfdmFsdWVfc2V0X2ludChnVmFsdWUsIHZhbHVlKTsKK30KKwor c3RhdGljIGJvb2wgdmFsdWVGcm9tR1ZhbHVlKGNvbnN0IEdWYWx1ZSogZ1ZhbHVlLCB1bnNpZ25l ZCYgdmFsdWUpCit7CisgICAgdmFsdWUgPSBnX3ZhbHVlX2dldF91aW50KGdWYWx1ZSk7CisgICAg cmV0dXJuIHRydWU7Cit9CisKK3N0YXRpYyB2b2lkIHZhbHVlVG9HVmFsdWUodW5zaWduZWQgdmFs dWUsIEdWYWx1ZSogZ1ZhbHVlKQoreworICAgIGdfdmFsdWVfc2V0X3VpbnQoZ1ZhbHVlLCB2YWx1 ZSk7Cit9CisKK3N0YXRpYyBib29sIHZhbHVlRnJvbUdWYWx1ZShjb25zdCBHVmFsdWUqIGdWYWx1 ZSwgc2l6ZV90JiB2YWx1ZSkKK3sKKyAgICB2YWx1ZSA9IEdQT0lOVEVSX1RPX1NJWkUoZ192YWx1 ZV9nZXRfcG9pbnRlcihnVmFsdWUpKTsKKyAgICByZXR1cm4gdHJ1ZTsKK30KKworc3RhdGljIHZv aWQgdmFsdWVUb0dWYWx1ZShzaXplX3QgdmFsdWUsIEdWYWx1ZSogZ1ZhbHVlKQoreworICAgIGdf dmFsdWVfc2V0X3BvaW50ZXIoZ1ZhbHVlLCBHU0laRV9UT19QT0lOVEVSKHZhbHVlKSk7Cit9CisK K3N0YXRpYyBib29sIHZhbHVlRnJvbUdWYWx1ZShjb25zdCBHVmFsdWUqIGdWYWx1ZSwgY29uc3Qg Y2hhciomIHZhbHVlKQoreworICAgIHZhbHVlID0gZ192YWx1ZV9kdXBfc3RyaW5nKGdWYWx1ZSk7 CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3N0YXRpYyB2b2lkIHZhbHVlVG9HVmFsdWUoY29uc3Qg Y2hhciogdmFsdWUsIEdWYWx1ZSogZ1ZhbHVlKQoreworICAgIGdfdmFsdWVfc2V0X3N0cmluZyhn VmFsdWUsIHZhbHVlKTsKK30KKworc3RhdGljIGJvb2wgdmFsdWVGcm9tR1ZhbHVlKGNvbnN0IEdW YWx1ZSogZ1ZhbHVlLCBkb3VibGUmIHZhbHVlKQoreworICAgIHZhbHVlID0gZ192YWx1ZV9nZXRf ZG91YmxlKGdWYWx1ZSk7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3N0YXRpYyB2b2lkIHZhbHVl VG9HVmFsdWUoZG91YmxlIHZhbHVlLCBHVmFsdWUqIGdWYWx1ZSkKK3sKKyAgICBnX3ZhbHVlX3Nl dF9kb3VibGUoZ1ZhbHVlLCB2YWx1ZSk7Cit9CisKK3N0YXRpYyBib29sIHZhbHVlRnJvbUdWYWx1 ZShjb25zdCBHVmFsdWUqIGdWYWx1ZSwgT3B0aW9uUmFuZ2UmIHZhbHVlKQoreworICAgIHJldHVy biB2YWx1ZS5pbml0KGdfdmFsdWVfZ2V0X3N0cmluZyhnVmFsdWUpID8gZ192YWx1ZV9nZXRfc3Ry aW5nKGdWYWx1ZSkgOiAiPG51bGw+Iik7Cit9CisKK3N0YXRpYyB2b2lkIHZhbHVlVG9HVmFsdWUo Y29uc3QgT3B0aW9uUmFuZ2UmIHZhbHVlLCBHVmFsdWUqIGdWYWx1ZSkKK3sKKyAgICBjb25zdCBj aGFyKiByYW5nZVN0cmluZyA9IHZhbHVlLnJhbmdlU3RyaW5nKCk7CisgICAgZ192YWx1ZV9zZXRf c3RyaW5nKGdWYWx1ZSwgIWdfc3RyY21wMChyYW5nZVN0cmluZywgIjxudWxsPiIpID8gbnVsbHB0 ciA6IHJhbmdlU3RyaW5nKTsKK30KKworc3RhdGljIGJvb2wgdmFsdWVGcm9tR1ZhbHVlKGNvbnN0 IEdWYWx1ZSogZ1ZhbHVlLCBHQ0xvZ2dpbmc6OkxldmVsJiB2YWx1ZSkKK3sKKyAgICBzd2l0Y2gg KGdfdmFsdWVfZ2V0X3VpbnQoZ1ZhbHVlKSkgeworICAgIGNhc2UgMDoKKyAgICAgICAgdmFsdWUg PSBHQ0xvZ2dpbmc6OkxldmVsOjpOb25lOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICBjYXNl IDE6CisgICAgICAgIHZhbHVlID0gR0NMb2dnaW5nOjpMZXZlbDo6QmFzaWM7CisgICAgICAgIHJl dHVybiB0cnVlOworICAgIGNhc2UgMjoKKyAgICAgICAgdmFsdWUgPSBHQ0xvZ2dpbmc6OkxldmVs OjpWZXJib3NlOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICBkZWZhdWx0OgorICAgICAgICBi cmVhazsKKyAgICB9CisKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK3N0YXRpYyB2b2lkIHZhbHVl VG9HVmFsdWUoR0NMb2dnaW5nOjpMZXZlbCB2YWx1ZSwgR1ZhbHVlKiBnVmFsdWUpCit7CisgICAg c3dpdGNoICh2YWx1ZSkgeworICAgIGNhc2UgR0NMb2dnaW5nOjpMZXZlbDo6Tm9uZToKKyAgICAg ICAgZ192YWx1ZV9zZXRfdWludChnVmFsdWUsIDApOworICAgICAgICBicmVhazsKKyAgICBjYXNl IEdDTG9nZ2luZzo6TGV2ZWw6OkJhc2ljOgorICAgICAgICBnX3ZhbHVlX3NldF91aW50KGdWYWx1 ZSwgMSk7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgR0NMb2dnaW5nOjpMZXZlbDo6VmVyYm9z ZToKKyAgICAgICAgZ192YWx1ZV9zZXRfdWludChnVmFsdWUsIDIpOworICAgICAgICBicmVhazsK KyAgICB9Cit9CisKK3N0YXRpYyBnYm9vbGVhbiBqc2NPcHRpb25zU2V0VmFsdWUoY29uc3QgY2hh ciogb3B0aW9uLCBjb25zdCBHVmFsdWUqIHZhbHVlKQoreworI2RlZmluZSBGT1JfRUFDSF9PUFRJ T04odHlwZV8sIG5hbWVfLCBkZWZhdWx0VmFsdWVfLCBhdmFpbGFiaWxpdHlfLCBkZXNjcmlwdGlv bl8pIFwKKyAgICBpZiAoIWdfc3RyY21wMCgjbmFtZV8sIG9wdGlvbikpIHsgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgdHlwZV8gdmFsdWVUb1NldDsgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgaWYgKCF2 YWx1ZUZyb21HVmFsdWUodmFsdWUsIHZhbHVlVG9TZXQpKSAgICAgICAgICAgICAgICAgICAgICAg IFwKKyAgICAgICAgICAgIHJldHVybiBGQUxTRTsgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgT3B0aW9uczo6bmFtZV8oKSA9IHZhbHVlVG9T ZXQ7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgcmV0dXJuIFRS VUU7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwK KyAgICB9CisKKyAgICBPcHRpb25zOjppbml0aWFsaXplKCk7CisgICAgSlNDX09QVElPTlMoRk9S X0VBQ0hfT1BUSU9OKQorI3VuZGVmIEZPUl9FQUNIX09QVElPTgorCisgICAgcmV0dXJuIEZBTFNF OworfQorCitzdGF0aWMgZ2Jvb2xlYW4ganNjT3B0aW9uc0dldFZhbHVlKGNvbnN0IGNoYXIqIG9w dGlvbiwgR1ZhbHVlKiB2YWx1ZSkKK3sKKyNkZWZpbmUgRk9SX0VBQ0hfT1BUSU9OKHR5cGVfLCBu YW1lXywgZGVmYXVsdFZhbHVlXywgYXZhaWxhYmlsaXR5XywgZGVzY3JpcHRpb25fKSBcCisgICAg aWYgKCFnX3N0cmNtcDAoI25hbWVfLCBvcHRpb24pKSB7ICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBcCisgICAgICAgIHR5cGVfIHZhbHVlVG9HZXQgPSBPcHRpb25zOjpuYW1lXygp OyAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICAgIHZhbHVlVG9HVmFsdWUodmFs dWVUb0dldCwgdmFsdWUpOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICAg IHJldHVybiBUUlVFOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBcCisgICAgfQorCisgICAgT3B0aW9uczo6aW5pdGlhbGl6ZSgpOworICAgIEpTQ19P UFRJT05TKEZPUl9FQUNIX09QVElPTikKKyN1bmRlZiBGT1JfRUFDSF9PUFRJT04KKworICAgIHJl dHVybiBGQUxTRTsKK30KKworLyoqCisgKiBqc2Nfb3B0aW9uc19zZXRfYm9vbGVhbjoKKyAqIEBv cHRpb246IHRoZSBvcHRpb24gaWRlbnRpZmllcgorICogQHZhbHVlOiB0aGUgdmFsdWUgdG8gc2V0 CisgKgorICogU2V0IEBvcHRpb24gYXMgYSAjZ2Jvb2xlYW4gdmFsdWUuCisgKgorICogUmV0dXJu czogJVRSVUUgaWYgb3B0aW9uIHdhcyBjb3JyZWN0bHkgc2V0IG9yICVGQUxTRSBvdGhlcndpc2Uu CisgKgorICogU2luY2U6IDIuMjQKKyAqLworZ2Jvb2xlYW4ganNjX29wdGlvbnNfc2V0X2Jvb2xl YW4oY29uc3QgY2hhciogb3B0aW9uLCBnYm9vbGVhbiB2YWx1ZSkKK3sKKyAgICBnX3JldHVybl92 YWxfaWZfZmFpbChvcHRpb24sIEZBTFNFKTsKKworICAgIEdWYWx1ZSBnVmFsdWUgPSBHX1ZBTFVF X0lOSVQ7CisgICAgZ192YWx1ZV9pbml0KCZnVmFsdWUsIEdfVFlQRV9CT09MRUFOKTsKKyAgICBn X3ZhbHVlX3NldF9ib29sZWFuKCZnVmFsdWUsIHZhbHVlKTsKKyAgICByZXR1cm4ganNjT3B0aW9u c1NldFZhbHVlKG9wdGlvbiwgJmdWYWx1ZSk7Cit9CisKKy8qKgorICoganNjX29wdGlvbnNfZ2V0 X2Jvb2xlYW46CisgKiBAb3B0aW9uOiB0aGUgb3B0aW9uIGlkZW50aWZpZXIKKyAqIEB2YWx1ZTog KG91dCk6IHJldHVybiBsb2NhdGlvbiBmb3IgdGhlIG9wdGlvbiB2YWx1ZQorICoKKyAqIEdldCBA b3B0aW9uIGFzIGEgI2dib29sZWFuIHZhbHVlLgorICoKKyAqIFJldHVybnM6ICVUUlVFIGlmIEB2 YWx1ZSBoYXMgYmVlbiBzZXQgb3IgJUZBTFNFIGlmIHRoZSBvcHRpb24gZG9lc24ndCBleGlzdAor ICoKKyAqIFNpbmNlOiAyLjI0CisgKi8KK2dib29sZWFuIGpzY19vcHRpb25zX2dldF9ib29sZWFu KGNvbnN0IGNoYXIqIG9wdGlvbiwgZ2Jvb2xlYW4qIHZhbHVlKQoreworICAgIGdfcmV0dXJuX3Zh bF9pZl9mYWlsKG9wdGlvbiwgRkFMU0UpOworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKHZhbHVl LCBGQUxTRSk7CisKKyAgICBHVmFsdWUgZ1ZhbHVlID0gR19WQUxVRV9JTklUOworICAgIGdfdmFs dWVfaW5pdCgmZ1ZhbHVlLCBHX1RZUEVfQk9PTEVBTik7CisgICAgaWYgKCFqc2NPcHRpb25zR2V0 VmFsdWUob3B0aW9uLCAmZ1ZhbHVlKSkKKyAgICAgICAgcmV0dXJuIEZBTFNFOworCisgICAgKnZh bHVlID0gIGdfdmFsdWVfZ2V0X2Jvb2xlYW4oJmdWYWx1ZSk7CisgICAgcmV0dXJuIFRSVUU7Cit9 CisKKy8qKgorICoganNjX29wdGlvbnNfc2V0X2ludDoKKyAqIEBvcHRpb246IHRoZSBvcHRpb24g aWRlbnRpZmllcgorICogQHZhbHVlOiB0aGUgdmFsdWUgdG8gc2V0CisgKgorICogU2V0IEBvcHRp b24gYXMgYSAjZ2ludCB2YWx1ZS4KKyAqCisgKiBSZXR1cm5zOiAlVFJVRSBpZiBvcHRpb24gd2Fz IGNvcnJlY3RseSBzZXQgb3IgJUZBTFNFIG90aGVyd2lzZS4KKyAqCisgKiBTaW5jZTogMi4yNAor ICovCitnYm9vbGVhbiBqc2Nfb3B0aW9uc19zZXRfaW50KGNvbnN0IGNoYXIqIG9wdGlvbiwgZ2lu dCB2YWx1ZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChvcHRpb24sIEZBTFNFKTsKKwor ICAgIEdWYWx1ZSBnVmFsdWUgPSBHX1ZBTFVFX0lOSVQ7CisgICAgZ192YWx1ZV9pbml0KCZnVmFs dWUsIEdfVFlQRV9JTlQpOworICAgIGdfdmFsdWVfc2V0X2ludCgmZ1ZhbHVlLCB2YWx1ZSk7Cisg ICAgcmV0dXJuIGpzY09wdGlvbnNTZXRWYWx1ZShvcHRpb24sICZnVmFsdWUpOworfQorCisvKioK KyAqIGpzY19vcHRpb25zX2dldF9pbnQ6CisgKiBAb3B0aW9uOiB0aGUgb3B0aW9uIGlkZW50aWZp ZXIKKyAqIEB2YWx1ZTogKG91dCk6IHJldHVybiBsb2NhdGlvbiBmb3IgdGhlIG9wdGlvbiB2YWx1 ZQorICoKKyAqIEdldCBAb3B0aW9uIGFzIGEgI2dpbnQgdmFsdWUuCisgKgorICogUmV0dXJuczog JVRSVUUgaWYgQHZhbHVlIGhhcyBiZWVuIHNldCBvciAlRkFMU0UgaWYgdGhlIG9wdGlvbiBkb2Vz bid0IGV4aXN0CisgKgorICogU2luY2U6IDIuMjQKKyAqLworZ2Jvb2xlYW4ganNjX29wdGlvbnNf Z2V0X2ludChjb25zdCBjaGFyKiBvcHRpb24sIGdpbnQqIHZhbHVlKQoreworICAgIGdfcmV0dXJu X3ZhbF9pZl9mYWlsKG9wdGlvbiwgRkFMU0UpOworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKHZh bHVlLCBGQUxTRSk7CisKKyAgICBHVmFsdWUgZ1ZhbHVlID0gR19WQUxVRV9JTklUOworICAgIGdf dmFsdWVfaW5pdCgmZ1ZhbHVlLCBHX1RZUEVfSU5UKTsKKyAgICBpZiAoIWpzY09wdGlvbnNHZXRW YWx1ZShvcHRpb24sICZnVmFsdWUpKQorICAgICAgICByZXR1cm4gRkFMU0U7CisKKyAgICAqdmFs dWUgPSBnX3ZhbHVlX2dldF9pbnQoJmdWYWx1ZSk7CisgICAgcmV0dXJuIFRSVUU7Cit9CisKKy8q KgorICoganNjX29wdGlvbnNfc2V0X3VpbnQ6CisgKiBAb3B0aW9uOiB0aGUgb3B0aW9uIGlkZW50 aWZpZXIKKyAqIEB2YWx1ZTogdGhlIHZhbHVlIHRvIHNldAorICoKKyAqIFNldCBAb3B0aW9uIGFz IGEgI2d1aW50IHZhbHVlLgorICoKKyAqIFJldHVybnM6ICVUUlVFIGlmIG9wdGlvbiB3YXMgY29y cmVjdGx5IHNldCBvciAlRkFMU0Ugb3RoZXJ3aXNlLgorICoKKyAqIFNpbmNlOiAyLjI0CisgKi8K K2dib29sZWFuIGpzY19vcHRpb25zX3NldF91aW50KGNvbnN0IGNoYXIqIG9wdGlvbiwgZ3VpbnQg dmFsdWUpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwob3B0aW9uLCBGQUxTRSk7CisKKyAg ICBHVmFsdWUgZ1ZhbHVlID0gR19WQUxVRV9JTklUOworICAgIGdfdmFsdWVfaW5pdCgmZ1ZhbHVl LCBHX1RZUEVfVUlOVCk7CisgICAgZ192YWx1ZV9zZXRfdWludCgmZ1ZhbHVlLCB2YWx1ZSk7Cisg ICAgcmV0dXJuIGpzY09wdGlvbnNTZXRWYWx1ZShvcHRpb24sICZnVmFsdWUpOworfQorCisvKioK KyAqIGpzY19vcHRpb25zX2dldF91aW50OgorICogQG9wdGlvbjogdGhlIG9wdGlvbiBpZGVudGlm aWVyCisgKiBAdmFsdWU6IChvdXQpOiByZXR1cm4gbG9jYXRpb24gZm9yIHRoZSBvcHRpb24gdmFs dWUKKyAqCisgKiBHZXQgQG9wdGlvbiBhcyBhICNndWludCB2YWx1ZS4KKyAqCisgKiBSZXR1cm5z OiAlVFJVRSBpZiBAdmFsdWUgaGFzIGJlZW4gc2V0IG9yICVGQUxTRSBpZiB0aGUgb3B0aW9uIGRv ZXNuJ3QgZXhpc3QKKyAqCisgKiBTaW5jZTogMi4yNAorICovCitnYm9vbGVhbiBqc2Nfb3B0aW9u c19nZXRfdWludChjb25zdCBjaGFyKiBvcHRpb24sIGd1aW50KiB2YWx1ZSkKK3sKKyAgICBnX3Jl dHVybl92YWxfaWZfZmFpbChvcHRpb24sIEZBTFNFKTsKKyAgICBnX3JldHVybl92YWxfaWZfZmFp bCh2YWx1ZSwgRkFMU0UpOworCisgICAgR1ZhbHVlIGdWYWx1ZSA9IEdfVkFMVUVfSU5JVDsKKyAg ICBnX3ZhbHVlX2luaXQoJmdWYWx1ZSwgR19UWVBFX1VJTlQpOworICAgIGlmICghanNjT3B0aW9u c0dldFZhbHVlKG9wdGlvbiwgJmdWYWx1ZSkpCisgICAgICAgIHJldHVybiBGQUxTRTsKKworICAg ICp2YWx1ZSA9IGdfdmFsdWVfZ2V0X3VpbnQoJmdWYWx1ZSk7CisgICAgcmV0dXJuIFRSVUU7Cit9 CisKKy8qKgorICoganNjX29wdGlvbnNfc2V0X3NpemU6CisgKiBAb3B0aW9uOiB0aGUgb3B0aW9u IGlkZW50aWZpZXIKKyAqIEB2YWx1ZTogdGhlIHZhbHVlIHRvIHNldAorICoKKyAqIFNldCBAb3B0 aW9uIGFzIGEgI2dzaXplIHZhbHVlLgorICoKKyAqIFJldHVybnM6ICVUUlVFIGlmIG9wdGlvbiB3 YXMgY29ycmVjdGx5IHNldCBvciAlRkFMU0Ugb3RoZXJ3aXNlLgorICoKKyAqIFNpbmNlOiAyLjI0 CisgKi8KK2dib29sZWFuIGpzY19vcHRpb25zX3NldF9zaXplKGNvbnN0IGNoYXIqIG9wdGlvbiwg Z3NpemUgdmFsdWUpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwob3B0aW9uLCBGQUxTRSk7 CisKKyAgICBHVmFsdWUgZ1ZhbHVlID0gR19WQUxVRV9JTklUOworICAgIGdfdmFsdWVfaW5pdCgm Z1ZhbHVlLCBHX1RZUEVfUE9JTlRFUik7CisgICAgZ192YWx1ZV9zZXRfcG9pbnRlcigmZ1ZhbHVl LCBHU0laRV9UT19QT0lOVEVSKHZhbHVlKSk7CisgICAgcmV0dXJuIGpzY09wdGlvbnNTZXRWYWx1 ZShvcHRpb24sICZnVmFsdWUpOworfQorCisvKioKKyAqIGpzY19vcHRpb25zX2dldF9zaXplOgor ICogQG9wdGlvbjogdGhlIG9wdGlvbiBpZGVudGlmaWVyCisgKiBAdmFsdWU6IChvdXQpOiByZXR1 cm4gbG9jYXRpb24gZm9yIHRoZSBvcHRpb24gdmFsdWUKKyAqCisgKiBHZXQgQG9wdGlvbiBhcyBh ICNnc2l6ZSB2YWx1ZS4KKyAqCisgKiBSZXR1cm5zOiAlVFJVRSBpZiBAdmFsdWUgaGFzIGJlZW4g c2V0IG9yICVGQUxTRSBpZiB0aGUgb3B0aW9uIGRvZXNuJ3QgZXhpc3QKKyAqCisgKiBTaW5jZTog Mi4yNAorICovCitnYm9vbGVhbiBqc2Nfb3B0aW9uc19nZXRfc2l6ZShjb25zdCBjaGFyKiBvcHRp b24sIGdzaXplKiB2YWx1ZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChvcHRpb24sIEZB TFNFKTsKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbCh2YWx1ZSwgRkFMU0UpOworCisgICAgR1Zh bHVlIGdWYWx1ZSA9IEdfVkFMVUVfSU5JVDsKKyAgICBnX3ZhbHVlX2luaXQoJmdWYWx1ZSwgR19U WVBFX1BPSU5URVIpOworICAgIGlmICghanNjT3B0aW9uc0dldFZhbHVlKG9wdGlvbiwgJmdWYWx1 ZSkpCisgICAgICAgIHJldHVybiBGQUxTRTsKKworICAgICp2YWx1ZSA9IEdQT0lOVEVSX1RPX1NJ WkUoZ192YWx1ZV9nZXRfcG9pbnRlcigmZ1ZhbHVlKSk7CisgICAgcmV0dXJuIFRSVUU7Cit9CisK Ky8qKgorICoganNjX29wdGlvbnNfc2V0X2RvdWJsZToKKyAqIEBvcHRpb246IHRoZSBvcHRpb24g aWRlbnRpZmllcgorICogQHZhbHVlOiB0aGUgdmFsdWUgdG8gc2V0CisgKgorICogU2V0IEBvcHRp b24gYXMgYSAjZ2RvdWJsZSB2YWx1ZS4KKyAqCisgKiBSZXR1cm5zOiAlVFJVRSBpZiBvcHRpb24g d2FzIGNvcnJlY3RseSBzZXQgb3IgJUZBTFNFIG90aGVyd2lzZS4KKyAqCisgKiBTaW5jZTogMi4y NAorICovCitnYm9vbGVhbiBqc2Nfb3B0aW9uc19zZXRfZG91YmxlKGNvbnN0IGNoYXIqIG9wdGlv biwgZ2RvdWJsZSB2YWx1ZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChvcHRpb24sIEZB TFNFKTsKKworICAgIEdWYWx1ZSBnVmFsdWUgPSBHX1ZBTFVFX0lOSVQ7CisgICAgZ192YWx1ZV9p bml0KCZnVmFsdWUsIEdfVFlQRV9ET1VCTEUpOworICAgIGdfdmFsdWVfc2V0X2RvdWJsZSgmZ1Zh bHVlLCB2YWx1ZSk7CisgICAgcmV0dXJuIGpzY09wdGlvbnNTZXRWYWx1ZShvcHRpb24sICZnVmFs dWUpOworfQorCisvKioKKyAqIGpzY19vcHRpb25zX2dldF9kb3VibGU6CisgKiBAb3B0aW9uOiB0 aGUgb3B0aW9uIGlkZW50aWZpZXIKKyAqIEB2YWx1ZTogKG91dCk6IHJldHVybiBsb2NhdGlvbiBm b3IgdGhlIG9wdGlvbiB2YWx1ZQorICoKKyAqIEdldCBAb3B0aW9uIGFzIGEgI2dkb3VibGUgdmFs dWUuCisgKgorICogUmV0dXJuczogJVRSVUUgaWYgQHZhbHVlIGhhcyBiZWVuIHNldCBvciAlRkFM U0UgaWYgdGhlIG9wdGlvbiBkb2Vzbid0IGV4aXN0CisgKgorICogU2luY2U6IDIuMjQKKyAqLwor Z2Jvb2xlYW4ganNjX29wdGlvbnNfZ2V0X2RvdWJsZShjb25zdCBjaGFyKiBvcHRpb24sIGdkb3Vi bGUqIHZhbHVlKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKG9wdGlvbiwgRkFMU0UpOwor ICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKHZhbHVlLCBGQUxTRSk7CisKKyAgICBHVmFsdWUgZ1Zh bHVlID0gR19WQUxVRV9JTklUOworICAgIGdfdmFsdWVfaW5pdCgmZ1ZhbHVlLCBHX1RZUEVfRE9V QkxFKTsKKyAgICBpZiAoIWpzY09wdGlvbnNHZXRWYWx1ZShvcHRpb24sICZnVmFsdWUpKQorICAg ICAgICByZXR1cm4gRkFMU0U7CisKKyAgICAqdmFsdWUgPSBnX3ZhbHVlX2dldF9kb3VibGUoJmdW YWx1ZSk7CisgICAgcmV0dXJuIFRSVUU7Cit9CisKKy8qKgorICoganNjX29wdGlvbnNfc2V0X3N0 cmluZzoKKyAqIEBvcHRpb246IHRoZSBvcHRpb24gaWRlbnRpZmllcgorICogQHZhbHVlOiB0aGUg dmFsdWUgdG8gc2V0CisgKgorICogU2V0IEBvcHRpb24gYXMgYSBzdHJpbmcuCisgKgorICogUmV0 dXJuczogJVRSVUUgaWYgb3B0aW9uIHdhcyBjb3JyZWN0bHkgc2V0IG9yICVGQUxTRSBvdGhlcndp c2UuCisgKgorICogU2luY2U6IDIuMjQKKyAqLworZ2Jvb2xlYW4ganNjX29wdGlvbnNfc2V0X3N0 cmluZyhjb25zdCBjaGFyKiBvcHRpb24sIGNvbnN0IGNoYXIqIHZhbHVlKQoreworICAgIGdfcmV0 dXJuX3ZhbF9pZl9mYWlsKG9wdGlvbiwgRkFMU0UpOworCisgICAgR1ZhbHVlIGdWYWx1ZSA9IEdf VkFMVUVfSU5JVDsKKyAgICBnX3ZhbHVlX2luaXQoJmdWYWx1ZSwgR19UWVBFX1NUUklORyk7Cisg ICAgZ192YWx1ZV9zZXRfc3RyaW5nKCZnVmFsdWUsIHZhbHVlKTsKKyAgICBib29sIHN1Y2Nlc3Mg PSBqc2NPcHRpb25zU2V0VmFsdWUob3B0aW9uLCAmZ1ZhbHVlKTsKKyAgICBnX3ZhbHVlX3Vuc2V0 KCZnVmFsdWUpOworICAgIHJldHVybiBzdWNjZXNzOworfQorCisvKioKKyAqIGpzY19vcHRpb25z X2dldF9zdHJpbmc6CisgKiBAb3B0aW9uOiB0aGUgb3B0aW9uIGlkZW50aWZpZXIKKyAqIEB2YWx1 ZTogKG91dCk6IHJldHVybiBsb2NhdGlvbiBmb3IgdGhlIG9wdGlvbiB2YWx1ZQorICoKKyAqIEdl dCBAb3B0aW9uIGFzIGEgc3RyaW5nLgorICoKKyAqIFJldHVybnM6ICVUUlVFIGlmIEB2YWx1ZSBo YXMgYmVlbiBzZXQgb3IgJUZBTFNFIGlmIHRoZSBvcHRpb24gZG9lc24ndCBleGlzdAorICoKKyAq IFNpbmNlOiAyLjI0CisgKi8KK2dib29sZWFuIGpzY19vcHRpb25zX2dldF9zdHJpbmcoY29uc3Qg Y2hhciogb3B0aW9uLCBjaGFyKiogdmFsdWUpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwo b3B0aW9uLCBGQUxTRSk7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwodmFsdWUsIEZBTFNFKTsK KworICAgIEdWYWx1ZSBnVmFsdWUgPSBHX1ZBTFVFX0lOSVQ7CisgICAgZ192YWx1ZV9pbml0KCZn VmFsdWUsIEdfVFlQRV9TVFJJTkcpOworICAgIGlmICghanNjT3B0aW9uc0dldFZhbHVlKG9wdGlv biwgJmdWYWx1ZSkpCisgICAgICAgIHJldHVybiBGQUxTRTsKKworICAgICp2YWx1ZSA9IGdfdmFs dWVfZHVwX3N0cmluZygmZ1ZhbHVlKTsKKyAgICBnX3ZhbHVlX3Vuc2V0KCZnVmFsdWUpOworICAg IHJldHVybiBUUlVFOworfQorCisvKioKKyAqIGpzY19vcHRpb25zX3NldF9yYW5nZV9zdHJpbmc6 CisgKiBAb3B0aW9uOiB0aGUgb3B0aW9uIGlkZW50aWZpZXIKKyAqIEB2YWx1ZTogdGhlIHZhbHVl IHRvIHNldAorICoKKyAqIFNldCBAb3B0aW9uIGFzIGEgcmFuZ2Ugc3RyaW5nLiBUaGUgc3RyaW5n IG11c3QgYmUgaW4gdGhlCisgKiBmb3JtYXQgPGVtcGhhc2lzPlshXSZsdDtsb3cmZ3Q7WzombHQ7 aGlnaCZndDtdPC9lbXBoYXNpcz4gd2hlcmUgbG93IGFuZCBoaWdoIGFyZSAjZ3VpbnQgdmFsdWVz LgorICogVmFsdWVzIGJldHdlZW4gbG93IGFuZCBoaWdoIChib3RoIGluY2x1ZGVkKSB3aWxsIGJl IGNvbnNpZGVyZWQgaW4KKyAqIHRoZSByYW5nZSwgdW5sZXNzIDxlbXBoYXNpcz4hPC9lbXBoYXNp cz4gaXMgdXNlZCB0byBpbnZlcnQgdGhlIHJhbmdlLgorICoKKyAqIFJldHVybnM6ICVUUlVFIGlm IG9wdGlvbiB3YXMgY29ycmVjdGx5IHNldCBvciAlRkFMU0Ugb3RoZXJ3aXNlLgorICoKKyAqIFNp bmNlOiAyLjI0CisgKi8KK2dib29sZWFuIGpzY19vcHRpb25zX3NldF9yYW5nZV9zdHJpbmcoY29u c3QgY2hhciogb3B0aW9uLCBjb25zdCBjaGFyKiB2YWx1ZSkKK3sKKyAgICBnX3JldHVybl92YWxf aWZfZmFpbChvcHRpb24sIEZBTFNFKTsKKworICAgIEdWYWx1ZSBnVmFsdWUgPSBHX1ZBTFVFX0lO SVQ7CisgICAgZ192YWx1ZV9pbml0KCZnVmFsdWUsIEdfVFlQRV9TVFJJTkcpOworICAgIGdfdmFs dWVfc2V0X3N0cmluZygmZ1ZhbHVlLCB2YWx1ZSk7CisgICAgYm9vbCBzdWNjZXNzID0ganNjT3B0 aW9uc1NldFZhbHVlKG9wdGlvbiwgJmdWYWx1ZSk7CisgICAgZ192YWx1ZV91bnNldCgmZ1ZhbHVl KTsKKyAgICByZXR1cm4gc3VjY2VzczsKK30KKworLyoqCisgKiBqc2Nfb3B0aW9uc19nZXRfcmFu Z2Vfc3RyaW5nOgorICogQG9wdGlvbjogdGhlIG9wdGlvbiBpZGVudGlmaWVyCisgKiBAdmFsdWU6 IChvdXQpOiByZXR1cm4gbG9jYXRpb24gZm9yIHRoZSBvcHRpb24gdmFsdWUKKyAqCisgKiBHZXQg QG9wdGlvbiBhcyBhIHJhbmdlIHN0cmluZy4gVGhlIHN0cmluZyBtdXN0IGJlIGluIHRoZQorICog Zm9ybWF0IDxlbXBoYXNpcz5bIV0mbHQ7bG93Jmd0O1s6Jmx0O2hpZ2gmZ3Q7XTwvZW1waGFzaXM+ IHdoZXJlIGxvdyBhbmQgaGlnaCBhcmUgI2d1aW50IHZhbHVlcy4KKyAqIFZhbHVlcyBiZXR3ZWVu IGxvdyBhbmQgaGlnaCAoYm90aCBpbmNsdWRlZCkgd2lsbCBiZSBjb25zaWRlcmVkIGluCisgKiB0 aGUgcmFuZ2UsIHVubGVzcyA8ZW1waGFzaXM+ITwvZW1waGFzaXM+IGlzIHVzZWQgdG8gaW52ZXJ0 IHRoZSByYW5nZS4KKyAqCisgKiBSZXR1cm5zOiAlVFJVRSBpZiBAdmFsdWUgaGFzIGJlZW4gc2V0 IG9yICVGQUxTRSBpZiB0aGUgb3B0aW9uIGRvZXNuJ3QgZXhpc3QKKyAqCisgKiBTaW5jZTogMi4y NAorICovCitnYm9vbGVhbiBqc2Nfb3B0aW9uc19nZXRfcmFuZ2Vfc3RyaW5nKGNvbnN0IGNoYXIq IG9wdGlvbiwgY2hhcioqIHZhbHVlKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKG9wdGlv biwgRkFMU0UpOworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKHZhbHVlLCBGQUxTRSk7CisKKyAg ICBHVmFsdWUgZ1ZhbHVlID0gR19WQUxVRV9JTklUOworICAgIGdfdmFsdWVfaW5pdCgmZ1ZhbHVl LCBHX1RZUEVfU1RSSU5HKTsKKyAgICBpZiAoIWpzY09wdGlvbnNHZXRWYWx1ZShvcHRpb24sICZn VmFsdWUpKQorICAgICAgICByZXR1cm4gRkFMU0U7CisKKyAgICAqdmFsdWUgPSBnX3ZhbHVlX2R1 cF9zdHJpbmcoJmdWYWx1ZSk7CisgICAgZ192YWx1ZV91bnNldCgmZ1ZhbHVlKTsKKyAgICByZXR1 cm4gVFJVRTsKK30KKworc3RhdGljIEpTQ09wdGlvblR5cGUganNjT3B0aW9uc1R5cGUoYm9vbCkK K3sKKyAgICByZXR1cm4gSlNDX09QVElPTl9CT09MRUFOOworfQorCitzdGF0aWMgSlNDT3B0aW9u VHlwZSBqc2NPcHRpb25zVHlwZShpbnQpCit7CisgICAgcmV0dXJuIEpTQ19PUFRJT05fSU5UOwor fQorCitzdGF0aWMgSlNDT3B0aW9uVHlwZSBqc2NPcHRpb25zVHlwZSh1bnNpZ25lZCkKK3sKKyAg ICByZXR1cm4gSlNDX09QVElPTl9VSU5UOworfQorCitzdGF0aWMgSlNDT3B0aW9uVHlwZSBqc2NP cHRpb25zVHlwZShzaXplX3QpCit7CisgICAgcmV0dXJuIEpTQ19PUFRJT05fU0laRTsKK30KKwor c3RhdGljIEpTQ09wdGlvblR5cGUganNjT3B0aW9uc1R5cGUoZG91YmxlKQoreworICAgIHJldHVy biBKU0NfT1BUSU9OX0RPVUJMRTsKK30KKworc3RhdGljIEpTQ09wdGlvblR5cGUganNjT3B0aW9u c1R5cGUoY29uc3QgY2hhciopCit7CisgICAgcmV0dXJuIEpTQ19PUFRJT05fU1RSSU5HOworfQor CitzdGF0aWMgSlNDT3B0aW9uVHlwZSBqc2NPcHRpb25zVHlwZShjb25zdCBPcHRpb25SYW5nZSYp Cit7CisgICAgcmV0dXJuIEpTQ19PUFRJT05fUkFOR0VfU1RSSU5HOworfQorCisvKioKKyAqIEpT Q09wdGlvblR5cGU6CisgKiBASlNDX09QVElPTl9CT09MRUFOOiBBICNnYm9vbGVhbiBvcHRpb24g dHlwZS4KKyAqIEBKU0NfT1BUSU9OX0lOVDogQSAjZ2ludCBvcHRpb24gdHlwZS4KKyAqIEBKU0Nf T1BUSU9OX1VJTlQ6IEEgI2d1aW50IG9wdGlvbiB0eXBlLgorICogQEpTQ19PUFRJT05fU0laRTog QSAjZ3NpemUgb3B0aW9ucyB0eXBlLgorICogQEpTQ19PUFRJT05fRE9VQkxFOiBBICNnZG91Ymxl IG9wdGlvbnMgdHlwZS4KKyAqIEBKU0NfT1BUSU9OX1NUUklORzogQSBzdHJpbmcgb3B0aW9uIHR5 cGUuCisgKiBASlNDX09QVElPTl9SQU5HRV9TVFJJTkc6IEEgcmFuZ2Ugc3RyaW5nIG9wdGlvbiB0 eXBlLgorICoKKyAqIEVudW0gdmFsdWVzIGZvciBvcHRpb25zIHR5cGVzLgorICoKKyAqIFNpbmNl OiAyLjI0CisgKi8KKworLyoqCisgKiBKU0NPcHRpb25zRnVuYzoKKyAqIEBvcHRpb246IHRoZSBv cHRpb24gbmFtZQorICogQHR5cGU6IHRoZSBvcHRpb24gI0pTQ09wdGlvblR5cGUKKyAqIEBkZXNj cmlwdGlvbjogKG51bGxhYmxlKTogdGhlIG9wdGlvbiBkZXNjcmlwdGlvbiwgb3IgJU5VTEwKKyAq IEB1c2VyX2RhdGE6IHVzZXIgZGF0YQorICoKKyAqIEZ1bmN0aW9uIHVzZWQgdG8gaXRlcmF0ZSBv cHRpb25zLgorICoKKyAqIE5vdCB0aGF0IEBkZXNjcmlwdGlvbiBzdHJpbmcgaXMgbm90IGxvY2Fs aXplZC4KKyAqCisgKiBSZXR1cm5zOiAlVFJVRSB0byBzdG9wIHRoZSBpdGVyYXRpb24sIG9yICVG QUxTRSBvdGhlcndpc2UKKyAqCisgKiBTaW5jZTogMi4yNAorICovCisKKy8qKgorICoganNjX29w dGlvbnNfZm9yZWFjaDoKKyAqIEBmdW5jdGlvbjogKHNjb3BlIGNhbGwpOiBhICNKU0NPcHRpb25z RnVuYyBjYWxsYmFjaworICogQHVzZXJfZGF0YTogY2FsbGJhY2sgdXNlciBkYXRhCisgKgorICog SXRlcmF0ZXMgYWxsIGF2YWlsYWJsZSBvcHRpb25zIGNhbGxpbmcgQGZ1bmN0aW9uIGZvciBlYWNo IG9uZS4gSXRlcmF0aW9uIGNhbgorICogc3RvcCBlYXJseSBpZiBAZnVuY3Rpb24gcmV0dXJucyAl RkFMU0UuCisgKgorICogU2luY2U6IDIuMjQKKyAqLwordm9pZCBqc2Nfb3B0aW9uc19mb3JlYWNo KEpTQ09wdGlvbnNGdW5jIGZ1bmN0aW9uLCBncG9pbnRlciB1c2VyRGF0YSkKK3sKKyAgICBnX3Jl dHVybl9pZl9mYWlsKGZ1bmN0aW9uKTsKKworI2RlZmluZSBGT1JfRUFDSF9PUFRJT04odHlwZV8s IG5hbWVfLCBkZWZhdWx0VmFsdWVfLCBhdmFpbGFiaWxpdHlfLCBkZXNjcmlwdGlvbl8pIFwKKyAg ICBpZiAoT3B0aW9uczo6QXZhaWxhYmlsaXR5OjphdmFpbGFiaWxpdHlfID09IE9wdGlvbnM6OkF2 YWlsYWJpbGl0eTo6Tm9ybWFsIFwKKyAgICAgICAgfHwgT3B0aW9uczo6aXNBdmFpbGFibGUoT3B0 aW9uczo6bmFtZV8jI0lELCBPcHRpb25zOjpBdmFpbGFiaWxpdHk6OmF2YWlsYWJpbGl0eV8pKSB7 IFwKKyAgICAgICAgdHlwZV8gZGVmYXVsdFZhbHVlOyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgYXV0byBvcHRpb25UeXBlID0ganNjT3B0aW9u c1R5cGUoZGVmYXVsdFZhbHVlKTsgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgaWYgKGZ1bmN0 aW9uICgjbmFtZV8sIG9wdGlvblR5cGUsIGRlc2NyaXB0aW9uXywgdXNlckRhdGEpKSAgICAgIFwK KyAgICAgICAgICAgIHJldHVybjsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFwKKyAgICB9CisKKyAgICBPcHRpb25zOjppbml0aWFsaXplKCk7Cisg ICAgSlNDX09QVElPTlMoRk9SX0VBQ0hfT1BUSU9OKQorI3VuZGVmIEZPUl9FQUNIX09QVElPTgor fQorCitzdGF0aWMgZ2Jvb2xlYW4gc2V0T3B0aW9uRW50cnkoY29uc3QgY2hhciogb3B0aW9uTmFt ZUZ1bGwsIGNvbnN0IGNoYXIqIHZhbHVlLCBncG9pbnRlciwgR0Vycm9yKiogZXJyb3IpCit7Cisg ICAgY29uc3QgY2hhciogb3B0aW9uTmFtZSA9IG9wdGlvbk5hbWVGdWxsICsgNjsgLy8gUmVtb3Zl IHRoZSAtLWpzYy0gcHJlZml4LgorICAgIEdVbmlxdWVQdHI8Y2hhcj4gb3B0aW9uKGdfc3RyZHVw X3ByaW50ZigiJXM9JXMiLCBvcHRpb25OYW1lLCB2YWx1ZSkpOworICAgIGlmICghT3B0aW9uczo6 c2V0T3B0aW9uKG9wdGlvbi5nZXQoKSkpIHsKKyAgICAgICAgZ19zZXRfZXJyb3IoZXJyb3IsIEdf T1BUSU9OX0VSUk9SLCBHX09QVElPTl9FUlJPUl9CQURfVkFMVUUsICJGYWlsZWQgcGFyc2UgdmFs dWUgJyVzJyBmb3IgJXMiLCB2YWx1ZSwgb3B0aW9uTmFtZUZ1bGwpOworICAgICAgICByZXR1cm4g RkFMU0U7CisgICAgfQorICAgIHJldHVybiBUUlVFOworfQorCisvKioKKyAqIGpzY19vcHRpb25z X2dldF9vcHRpb25fZ3JvdXA6CisgKgorICogQ3JlYXRlIGEgI0dPcHRpb25Hcm91cCB0byBoYW5k bGUgSlNDT3B0aW9ucyBhcyBjb21tYW5kIGxpbmUgYXJndW1lbnRzLgorICogVGhlIG9wdGlvbnMg d2lsbCBiZSBleHBvc2VkIGFzIGNvbW1hbmQgbGluZSBhcmd1bWVudHMgd2l0aCB0aGUgZm9ybQor ICogPGVtcGhhc2lzPi0tanNjLSZsdDtvcHRpb24mZ3Q7PSZsdDt2YWx1ZSZndDs8L2VtcGhhc2lz Pi4KKyAqIEVhY2ggZW50cnkgaW4gdGhlIHJldHVybmVkICNHT3B0aW9uR3JvdXAgaXMgY29uZmln dXJlZCB0byBhcHBseSB0aGUKKyAqIGNvcnJlc3BvbmRpbmcgb3B0aW9uIGR1cmluZyBjb21tYW5k IGxpbmUgcGFyc2luZy4gQXBwbGljYXRpb25zIG9ubHkgbmVlZCB0bworICogcGFzcyB0aGUgcmV0 dXJuZWQgZ3JvdXAgdG8gZ19vcHRpb25fY29udGV4dF9hZGRfZ3JvdXAoKSwgYW5kIHRoZSByZXN0 IHdpbGwKKyAqIGJlIHRha2VuIGNhcmUgZm9yIGF1dG9tYXRpY2FsbHkuCisgKgorICogUmV0dXJu czogKHRyYW5zZmVyIGZ1bGwpOiBhICNHT3B0aW9uR3JvdXAgZm9yIHRoZSBKU0NPcHRpb25zCisg KgorICogU2luY2U6IDIuMjQKKyAqLworR09wdGlvbkdyb3VwKiBqc2Nfb3B0aW9uc19nZXRfb3B0 aW9uX2dyb3VwKHZvaWQpCit7CisgICAgLy8gR09wdGlvbkVudHJ5IHdvcmtzIHdpdGggY29uc3Qg c3RyaW5ncywgc28gd2UgbmVlZCB0byBrZWVwIHRoZSBvcHRpb24gbmFtZXMgYXJvdW5kLgorICAg IGF1dG8qIG5hbWVzID0gbmV3IFZlY3RvcjxHVW5pcXVlUHRyPGNoYXI+PjsKKyAgICBHT3B0aW9u R3JvdXAqIGdyb3VwID0gZ19vcHRpb25fZ3JvdXBfbmV3KCJqc2MiLCBfKCJKU0MgT3B0aW9ucyIp LCBfKCJTaG93IEpTQyBPcHRpb25zIiksIG5hbWVzLCBbXSAoZ3BvaW50ZXIgZGF0YSkgeyBkZWxl dGUgc3RhdGljX2Nhc3Q8VmVjdG9yPEdVbmlxdWVQdHI8Y2hhcj4+Kj4oZGF0YSk7IH0pOworICAg IGdfb3B0aW9uX2dyb3VwX3NldF90cmFuc2xhdGlvbl9kb21haW4oZ3JvdXAsIEdFVFRFWFRfUEFD S0FHRSk7CisKKyAgICBHQXJyYXkqIGVudHJpZXMgPSBnX2FycmF5X25ldyhUUlVFLCBUUlVFLCBz aXplb2YoR09wdGlvbkVudHJ5KSk7CisjZGVmaW5lIEZPUl9FQUNIX09QVElPTih0eXBlXywgbmFt ZV8sIGRlZmF1bHRWYWx1ZV8sIGF2YWlsYWJpbGl0eV8sIGRlc2NyaXB0aW9uXykgXAorICAgIGlm IChPcHRpb25zOjpBdmFpbGFiaWxpdHk6OmF2YWlsYWJpbGl0eV8gPT0gT3B0aW9uczo6QXZhaWxh YmlsaXR5OjpOb3JtYWwgXAorICAgICAgICB8fCBPcHRpb25zOjppc0F2YWlsYWJsZShPcHRpb25z OjpuYW1lXyMjSUQsIE9wdGlvbnM6OkF2YWlsYWJpbGl0eTo6YXZhaWxhYmlsaXR5XykpIHsgXAor ICAgICAgICBHVW5pcXVlUHRyPGNoYXI+IG5hbWUoZ19zdHJkdXBfcHJpbnRmKCJqc2MtJXMiLCAj bmFtZV8pKTsgICAgICAgXAorICAgICAgICBlbnRyaWVzID0gZ19hcnJheV9zZXRfc2l6ZShlbnRy aWVzLCBlbnRyaWVzLT5sZW4gKyAxKTsgXAorICAgICAgICBHT3B0aW9uRW50cnkqIGVudHJ5ID0g JmdfYXJyYXlfaW5kZXgoZW50cmllcywgR09wdGlvbkVudHJ5LCBlbnRyaWVzLT5sZW4gLSAxKTsg XAorICAgICAgICBlbnRyeS0+bG9uZ19uYW1lID0gbmFtZS5nZXQoKTsgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgXAorICAgICAgICBlbnRyeS0+YXJnID0gR19PUFRJT05fQVJHX0NB TExCQUNLOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgICAgICBlbnRyeS0+YXJn X2RhdGEgPSByZWludGVycHJldF9jYXN0PGdwb2ludGVyPihzZXRPcHRpb25FbnRyeSk7ICAgXAor ICAgICAgICBlbnRyeS0+ZGVzY3JpcHRpb24gPSBkZXNjcmlwdGlvbl87ICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgXAorICAgICAgICBuYW1lcy0+YXBwZW5kKFdURk1vdmUobmFtZSkpOyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgIH0KKworICAgIE9wdGlvbnM6 OmluaXRpYWxpemUoKTsKKyAgICBKU0NfT1BUSU9OUyhGT1JfRUFDSF9PUFRJT04pCisjdW5kZWYg Rk9SX0VBQ0hfT1BUSU9OCisKKyAgICBnX29wdGlvbl9ncm91cF9hZGRfZW50cmllcyhncm91cCwg cmVpbnRlcnByZXRfY2FzdDxHT3B0aW9uRW50cnkqPihlbnRyaWVzLT5kYXRhKSk7CisgICAgcmV0 dXJuIGdyb3VwOworfQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0FQSS9nbGli L0pTQ09wdGlvbnMuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9KU0NPcHRpb25z LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLmZhZGQ5Yjc1MGQxCi0t LSAvZGV2L251bGwKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0FQSS9nbGliL0pTQ09wdGlv bnMuaApAQCAtMCwwICsxLDEwNSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxOCBJZ2FsaWEg Uy5MLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGlj ZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlz IGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1 bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEg Y29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcg d2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3Jp dGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGlu IFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAq LworCisjaWYgIWRlZmluZWQoX19KU0NfSF9JTlNJREVfXykgJiYgIWRlZmluZWQoSlNDX0NPTVBJ TEFUSU9OKSAmJiAhZGVmaW5lZChXRUJLSVQyX0NPTVBJTEFUSU9OKQorI2Vycm9yICJPbmx5IDxq c2MvanNjLmg+IGNhbiBiZSBpbmNsdWRlZCBkaXJlY3RseS4iCisjZW5kaWYKKworI2lmbmRlZiBK U0NPcHRpb25zX2gKKyNkZWZpbmUgSlNDT3B0aW9uc19oCisKKyNpbmNsdWRlIDxnbGliLW9iamVj dC5oPgorI2luY2x1ZGUgPGpzYy9KU0NEZWZpbmVzLmg+CisKK0dfQkVHSU5fREVDTFMKKworSlND X0FQSSBnYm9vbGVhbgoranNjX29wdGlvbnNfc2V0X2Jvb2xlYW4gICAgICAgKGNvbnN0IGNoYXIg Km9wdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnYm9vbGVhbiAgICB2YWx1 ZSk7CitKU0NfQVBJIGdib29sZWFuCitqc2Nfb3B0aW9uc19nZXRfYm9vbGVhbiAgICAgICAoY29u c3QgY2hhciAqb3B0aW9uLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdib29sZWFu ICAgKnZhbHVlKTsKKworSlNDX0FQSSBnYm9vbGVhbgoranNjX29wdGlvbnNfc2V0X2ludCAgICAg ICAgICAgKGNvbnN0IGNoYXIgKm9wdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBnaW50ICAgICAgICB2YWx1ZSk7CitKU0NfQVBJIGdib29sZWFuCitqc2Nfb3B0aW9uc19nZXRf aW50ICAgICAgICAgICAoY29uc3QgY2hhciAqb3B0aW9uLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGdpbnQgICAgICAgKnZhbHVlKTsKKworSlNDX0FQSSBnYm9vbGVhbgoranNjX29w dGlvbnNfc2V0X3VpbnQgICAgICAgICAgKGNvbnN0IGNoYXIgKm9wdGlvbiwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBndWludCAgICAgICB2YWx1ZSk7CitKU0NfQVBJIGdib29sZWFu Citqc2Nfb3B0aW9uc19nZXRfdWludCAgICAgICAgICAoY29uc3QgY2hhciAqb3B0aW9uLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGd1aW50ICAgICAgKnZhbHVlKTsKKworSlNDX0FQ SSBnYm9vbGVhbgoranNjX29wdGlvbnNfc2V0X3NpemUgICAgICAgICAgKGNvbnN0IGNoYXIgKm9w dGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnc2l6ZSAgICAgICB2YWx1ZSk7 CitKU0NfQVBJIGdib29sZWFuCitqc2Nfb3B0aW9uc19nZXRfc2l6ZSAgICAgICAgICAoY29uc3Qg Y2hhciAqb3B0aW9uLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdzaXplICAgICAg KnZhbHVlKTsKKworSlNDX0FQSSBnYm9vbGVhbgoranNjX29wdGlvbnNfc2V0X2RvdWJsZSAgICAg ICAgKGNvbnN0IGNoYXIgKm9wdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBn ZG91YmxlICAgICB2YWx1ZSk7CitKU0NfQVBJIGdib29sZWFuCitqc2Nfb3B0aW9uc19nZXRfZG91 YmxlICAgICAgICAoY29uc3QgY2hhciAqb3B0aW9uLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGdkb3VibGUgICAgKnZhbHVlKTsKKworSlNDX0FQSSBnYm9vbGVhbgoranNjX29wdGlv bnNfc2V0X3N0cmluZyAgICAgICAgKGNvbnN0IGNoYXIgKm9wdGlvbiwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICp2YWx1ZSk7CitKU0NfQVBJIGdib29sZWFuCitq c2Nfb3B0aW9uc19nZXRfc3RyaW5nICAgICAgICAoY29uc3QgY2hhciAqb3B0aW9uLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGNoYXIgICAgICAgKip2YWx1ZSk7CisKK0pTQ19BUEkg Z2Jvb2xlYW4KK2pzY19vcHRpb25zX3NldF9yYW5nZV9zdHJpbmcgIChjb25zdCBjaGFyICpvcHRp b24sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgY2hhciAqdmFsdWUpOwor SlNDX0FQSSBnYm9vbGVhbgoranNjX29wdGlvbnNfZ2V0X3JhbmdlX3N0cmluZyAgKGNvbnN0IGNo YXIgKm9wdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjaGFyICAgICAgICoq dmFsdWUpOworCit0eXBlZGVmIGVudW0geworICAgIEpTQ19PUFRJT05fQk9PTEVBTiwKKyAgICBK U0NfT1BUSU9OX0lOVCwKKyAgICBKU0NfT1BUSU9OX1VJTlQsCisgICAgSlNDX09QVElPTl9TSVpF LAorICAgIEpTQ19PUFRJT05fRE9VQkxFLAorICAgIEpTQ19PUFRJT05fU1RSSU5HLAorICAgIEpT Q19PUFRJT05fUkFOR0VfU1RSSU5HCit9IEpTQ09wdGlvblR5cGU7CisKK3R5cGVkZWYgZ2Jvb2xl YW4gKCogSlNDT3B0aW9uc0Z1bmMpIChjb25zdCBjaGFyICAgICpvcHRpb24sCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgSlNDT3B0aW9uVHlwZSAgdHlwZSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICAgICpkZXNjcmlwdGlvbiwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBncG9pbnRlciAgICAgICB1c2Vy X2RhdGEpOworCitKU0NfQVBJIHZvaWQKK2pzY19vcHRpb25zX2ZvcmVhY2ggICAgICAgICAgICAg ICAgIChKU0NPcHRpb25zRnVuYyBmdW5jdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBncG9pbnRlciAgICAgICB1c2VyX2RhdGEpOworCitKU0NfQVBJIEdPcHRpb25H cm91cCAqCitqc2Nfb3B0aW9uc19nZXRfb3B0aW9uX2dyb3VwICAgICAgICAodm9pZCk7CisKK0df RU5EX0RFQ0xTCisKKyNlbmRpZiAvKiBKU0NPcHRpb25zX2ggKi8KZGlmZiAtLWdpdCBhL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9kb2NzL2pzYy1nbGliLTQuMC1zZWN0aW9ucy50eHQg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQVBJL2dsaWIvZG9jcy9qc2MtZ2xpYi00LjAtc2VjdGlv bnMudHh0CmluZGV4IGFkZDY4MmE0ODFhLi45YjZlNzAxNTQ1ZSAxMDA2NDQKLS0tIGEvU291cmNl L0phdmFTY3JpcHRDb3JlL0FQSS9nbGliL2RvY3MvanNjLWdsaWItNC4wLXNlY3Rpb25zLnR4dAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQVBJL2dsaWIvZG9jcy9qc2MtZ2xpYi00LjAtc2Vj dGlvbnMudHh0CkBAIC0yMTEsNiArMjExLDMxIEBAIEpTQ19JU19DTEFTUwoganNjX2NsYXNzX2dl dF90eXBlCiA8L1NFQ1RJT04+CiAKKzxTRUNUSU9OPgorPEZJTEU+SlNDT3B0aW9uczwvRklMRT4K KzxUSVRMRT5KU0NPcHRpb25zPC9USVRMRT4KK2pzY19vcHRpb25zX3NldF9ib29sZWFuCitqc2Nf b3B0aW9uc19nZXRfYm9vbGVhbgoranNjX29wdGlvbnNfc2V0X2ludAoranNjX29wdGlvbnNfZ2V0 X2ludAoranNjX29wdGlvbnNfc2V0X3VpbnQKK2pzY19vcHRpb25zX2dldF91aW50Citqc2Nfb3B0 aW9uc19zZXRfc2l6ZQoranNjX29wdGlvbnNfZ2V0X3NpemUKK2pzY19vcHRpb25zX3NldF9kb3Vi bGUKK2pzY19vcHRpb25zX2dldF9kb3VibGUKK2pzY19vcHRpb25zX3NldF9zdHJpbmcKK2pzY19v cHRpb25zX2dldF9zdHJpbmcKK2pzY19vcHRpb25zX3NldF9yYW5nZV9zdHJpbmcKK2pzY19vcHRp b25zX2dldF9yYW5nZV9zdHJpbmcKKworSlNDT3B0aW9uVHlwZQorSlNDT3B0aW9uc0Z1bmMKK2pz Y19vcHRpb25zX2ZvcmVhY2gKKworanNjX29wdGlvbnNfZ2V0X29wdGlvbl9ncm91cAorPC9TRUNU SU9OPgorCiA8U0VDVElPTj4KIDxGSUxFPkpTQ1ZlcnNpb248L0ZJTEU+CiA8VElUTEU+SlNDVmVy c2lvbjwvVElUTEU+CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQVBJL2dsaWIv ZG9jcy9qc2MtZ2xpYi1kb2NzLnNnbWwgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQVBJL2dsaWIv ZG9jcy9qc2MtZ2xpYi1kb2NzLnNnbWwKaW5kZXggNDg1M2ExMDRjNmQuLjFjMmRiNWM3Yjk1IDEw MDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQVBJL2dsaWIvZG9jcy9qc2MtZ2xpYi1k b2NzLnNnbWwKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0FQSS9nbGliL2RvY3MvanNjLWds aWItZG9jcy5zZ21sCkBAIC0xNyw2ICsxNyw3IEBACiAgICAgPHhpOmluY2x1ZGUgaHJlZj0ieG1s L0pTQ1dlYWtWYWx1ZS54bWwiLz4KICAgICA8eGk6aW5jbHVkZSBocmVmPSJ4bWwvSlNDRXhjZXB0 aW9uLnhtbCIvPgogICAgIDx4aTppbmNsdWRlIGhyZWY9InhtbC9KU0NDbGFzcy54bWwiLz4KKyAg ICA8eGk6aW5jbHVkZSBocmVmPSJ4bWwvSlNDT3B0aW9ucy54bWwiLz4KICAgICA8eGk6aW5jbHVk ZSBocmVmPSJ4bWwvSlNDVmVyc2lvbi54bWwiLz4KICAgPC9jaGFwdGVyPgogCkBAIC0yNCw1ICsy NSwxMCBAQAogICAgIDx0aXRsZT5JbmRleDwvdGl0bGU+CiAgIDwvaW5kZXg+CiAKKyAgPGluZGV4 IGlkPSJhcGktaW5kZXgtMi0yNCIgcm9sZT0iMi4yNCI+CisgICAgPHRpdGxlPkluZGV4IG9mIG5l dyBzeW1ib2xzIGluIDIuMjQ8L3RpdGxlPgorICAgIDx4aTppbmNsdWRlIGhyZWY9InhtbC9hcGkt aW5kZXgtMi4yNC54bWwiPjx4aTpmYWxsYmFjayAvPjwveGk6aW5jbHVkZT4KKyAgPC9pbmRleD4K KwogICA8eGk6aW5jbHVkZSBocmVmPSJ4bWwvYW5ub3RhdGlvbi1nbG9zc2FyeS54bWwiPjx4aTpm YWxsYmFjayAvPjwveGk6aW5jbHVkZT4KIDwvYm9vaz4KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS9BUEkvZ2xpYi9qc2MuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xp Yi9qc2MuaAppbmRleCA4YTI4NDUyNDBhOC4uMTE1MzdmOWQ0YTYgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9qc2MuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQVBJL2dsaWIvanNjLmgKQEAgLTI2LDYgKzI2LDcgQEAKICNpbmNsdWRlIDxqc2MvSlNDQ29u dGV4dC5oPgogI2luY2x1ZGUgPGpzYy9KU0NEZWZpbmVzLmg+CiAjaW5jbHVkZSA8anNjL0pTQ0V4 Y2VwdGlvbi5oPgorI2luY2x1ZGUgPGpzYy9KU0NPcHRpb25zLmg+CiAjaW5jbHVkZSA8anNjL0pT Q1ZhbHVlLmg+CiAjaW5jbHVkZSA8anNjL0pTQ1ZlcnNpb24uaD4KICNpbmNsdWRlIDxqc2MvSlND VmlydHVhbE1hY2hpbmUuaD4KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9HTGli LmNtYWtlIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0dMaWIuY21ha2UKaW5kZXggZGM4NWY0ZTdj NTkuLjRkMWZmZTVkNzlkIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvR0xpYi5j bWFrZQorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvR0xpYi5jbWFrZQpAQCAtOCw2ICs4LDcg QEAgbGlzdChBUFBFTkQgSmF2YVNjcmlwdENvcmVfU09VUkNFUwogICAgIEFQSS9nbGliL0pTQ0Ns YXNzLmNwcAogICAgIEFQSS9nbGliL0pTQ0NvbnRleHQuY3BwCiAgICAgQVBJL2dsaWIvSlNDRXhj ZXB0aW9uLmNwcAorICAgIEFQSS9nbGliL0pTQ09wdGlvbnMuY3BwCiAgICAgQVBJL2dsaWIvSlND VmFsdWUuY3BwCiAgICAgQVBJL2dsaWIvSlNDVmVyc2lvbi5jcHAKICAgICBBUEkvZ2xpYi9KU0NW aXJ0dWFsTWFjaGluZS5jcHAKQEAgLTI4LDYgKzI5LDcgQEAgc2V0KEphdmFTY3JpcHRDb3JlX0lO U1RBTExFRF9IRUFERVJTCiAgICAgJHtKQVZBU0NSSVBUQ09SRV9ESVJ9L0FQSS9nbGliL0pTQ0Nv bnRleHQuaAogICAgICR7SkFWQVNDUklQVENPUkVfRElSfS9BUEkvZ2xpYi9KU0NEZWZpbmVzLmgK ICAgICAke0pBVkFTQ1JJUFRDT1JFX0RJUn0vQVBJL2dsaWIvSlNDRXhjZXB0aW9uLmgKKyAgICAk e0pBVkFTQ1JJUFRDT1JFX0RJUn0vQVBJL2dsaWIvSlNDT3B0aW9ucy5oCiAgICAgJHtKQVZBU0NS SVBUQ09SRV9ESVJ9L0FQSS9nbGliL0pTQ1ZhbHVlLmgKICAgICAke0pBVkFTQ1JJUFRDT1JFX0RJ Un0vQVBJL2dsaWIvSlNDVmlydHVhbE1hY2hpbmUuaAogICAgICR7SkFWQVNDUklQVENPUkVfRElS fS9BUEkvZ2xpYi9KU0NXZWFrVmFsdWUuaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3RrL3BvL1BPVEZJTEVTLmluIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL3Bv L1BPVEZJTEVTLmluCmluZGV4IDlmY2I4NmM3MTc4Li5hM2JjZjVhZmY5NCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL3BvL1BPVEZJTEVTLmluCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2d0ay9wby9QT1RGSUxFUy5pbgpAQCAtMiw2ICsyLDcgQEAKIExvY2Fs aXplZFN0cmluZ3NHdGsuY3BwCiAuLi9Mb2NhbGl6ZWRTdHJpbmdzLmNwcAogLi4vbmV0d29yay9z b3VwL05ldHdvcmtTdG9yYWdlU2Vzc2lvblNvdXAuY3BwCisuLi8uLi8uLi9KYXZhU2NyaXB0Q29y ZS9BUEkvZ2xpYi9KU0NPcHRpb25zLmNwcAogLi4vLi4vLi4vV2ViS2l0L1NoYXJlZC9BUEkvZ2xp Yi9XZWJLaXRIaXRUZXN0UmVzdWx0LmNwcAogLi4vLi4vLi4vV2ViS2l0L1NoYXJlZC9BUEkvZ2xp Yi9XZWJLaXRVUklSZXF1ZXN0LmNwcAogLi4vLi4vLi4vV2ViS2l0L1NoYXJlZC9BUEkvZ2xpYi9X ZWJLaXRVUklSZXNwb25zZS5jcHAKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvSmF2YVNjcmlwdENvcmUvZ2xpYi9UZXN0SlNDLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkv VGVzdHMvSmF2YVNjcmlwdENvcmUvZ2xpYi9UZXN0SlNDLmNwcAppbmRleCBmN2ZhNmFhY2RjMy4u N2U3NGY2OTU1MWMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvSmF2YVNj cmlwdENvcmUvZ2xpYi9UZXN0SlNDLmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3Rz L0phdmFTY3JpcHRDb3JlL2dsaWIvVGVzdEpTQy5jcHAKQEAgLTMyMjcsNiArMzIyNywyMTEgQEAg c3RhdGljIHZvaWQgdGVzdHNKU0NWaXJ0dWFsTWFjaGluZSgpCiAgICAgfQogfQogCitzdGF0aWMg dm9pZCB0ZXN0c0pTQ09wdGlvbnMoKQoreworICAgIGdib29sZWFuIHVzZUpJVDsKKyAgICBnX2Fz c2VydF90cnVlKGpzY19vcHRpb25zX2dldF9ib29sZWFuKCJ1c2VKSVQiLCAmdXNlSklUKSk7Cisg ICAgZ19hc3NlcnRfdHJ1ZSh1c2VKSVQpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNf c2V0X2Jvb2xlYW4oInVzZUpJVCIsIEZBTFNFKSk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0 aW9uc19nZXRfYm9vbGVhbigidXNlSklUIiwgJnVzZUpJVCkpOworICAgIGdfYXNzZXJ0X2ZhbHNl KHVzZUpJVCk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRfYm9vbGVhbigidXNl SklUIiwgVFJVRSkpOworCisgICAgZ2ludCB0aHJlc2hvbGRGb3JKSVRBZnRlcldhcm1VcDsKKyAg ICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9pbnQoInRocmVzaG9sZEZvckpJVEFmdGVy V2FybVVwIiwgJnRocmVzaG9sZEZvckpJVEFmdGVyV2FybVVwKSk7CisgICAgZ19hc3NlcnRfY21w aW50KHRocmVzaG9sZEZvckpJVEFmdGVyV2FybVVwLCA9PSwgNTAwKTsKKyAgICBnX2Fzc2VydF90 cnVlKGpzY19vcHRpb25zX3NldF9pbnQoInRocmVzaG9sZEZvckpJVEFmdGVyV2FybVVwIiwgMTAw MCkpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X2ludCgidGhyZXNob2xkRm9y SklUQWZ0ZXJXYXJtVXAiLCAmdGhyZXNob2xkRm9ySklUQWZ0ZXJXYXJtVXApKTsKKyAgICBnX2Fz c2VydF9jbXBpbnQodGhyZXNob2xkRm9ySklUQWZ0ZXJXYXJtVXAsID09LCAxMDAwKTsKKyAgICBn X2Fzc2VydF90cnVlKGpzY19vcHRpb25zX3NldF9pbnQoInRocmVzaG9sZEZvckpJVEFmdGVyV2Fy bVVwIiwgNTAwKSk7CisKKyAgICBndWludCBtYXhQZXJUaHJlYWRTdGFja1VzYWdlOworICAgIGdf YXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X3VpbnQoIm1heFBlclRocmVhZFN0YWNrVXNhZ2Ui LCAmbWF4UGVyVGhyZWFkU3RhY2tVc2FnZSkpOworICAgIGdfYXNzZXJ0X2NtcHVpbnQobWF4UGVy VGhyZWFkU3RhY2tVc2FnZSwgPT0sIDQxOTQzMDQpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29w dGlvbnNfc2V0X3VpbnQoIm1heFBlclRocmVhZFN0YWNrVXNhZ2UiLCA0MDk2KSk7CisgICAgZ19h c3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfdWludCgibWF4UGVyVGhyZWFkU3RhY2tVc2FnZSIs ICZtYXhQZXJUaHJlYWRTdGFja1VzYWdlKSk7CisgICAgZ19hc3NlcnRfY21wdWludChtYXhQZXJU aHJlYWRTdGFja1VzYWdlLCA9PSwgNDA5Nik7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9u c19zZXRfdWludCgibWF4UGVyVGhyZWFkU3RhY2tVc2FnZSIsIDQxOTQzMDQpKTsKKworICAgIGdz aXplIHdlYkFzc2VtYmx5UGFydGlhbENvbXBpbGVMaW1pdDsKKyAgICBnX2Fzc2VydF90cnVlKGpz Y19vcHRpb25zX2dldF9zaXplKCJ3ZWJBc3NlbWJseVBhcnRpYWxDb21waWxlTGltaXQiLCAmd2Vi QXNzZW1ibHlQYXJ0aWFsQ29tcGlsZUxpbWl0KSk7CisgICAgZ19hc3NlcnRfY21wdWludCh3ZWJB c3NlbWJseVBhcnRpYWxDb21waWxlTGltaXQsID09LCA1MDAwKTsKKyAgICBnX2Fzc2VydF90cnVl KGpzY19vcHRpb25zX3NldF9zaXplKCJ3ZWJBc3NlbWJseVBhcnRpYWxDb21waWxlTGltaXQiLCA2 MDAwKSk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfc2l6ZSgid2ViQXNzZW1i bHlQYXJ0aWFsQ29tcGlsZUxpbWl0IiwgJndlYkFzc2VtYmx5UGFydGlhbENvbXBpbGVMaW1pdCkp OworICAgIGdfYXNzZXJ0X2NtcHVpbnQod2ViQXNzZW1ibHlQYXJ0aWFsQ29tcGlsZUxpbWl0LCA9 PSwgNjAwMCk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRfc2l6ZSgid2ViQXNz ZW1ibHlQYXJ0aWFsQ29tcGlsZUxpbWl0IiwgNTAwMCkpOworCisgICAgZ2RvdWJsZSBzbWFsbEhl YXBSQU1GcmFjdGlvbjsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9kb3VibGUo InNtYWxsSGVhcFJBTUZyYWN0aW9uIiwgJnNtYWxsSGVhcFJBTUZyYWN0aW9uKSk7CisgICAgZ19h c3NlcnRfY21wZmxvYXQoc21hbGxIZWFwUkFNRnJhY3Rpb24sID09LCAwLjI1KTsKKyAgICBnX2Fz c2VydF90cnVlKGpzY19vcHRpb25zX3NldF9kb3VibGUoInNtYWxsSGVhcFJBTUZyYWN0aW9uIiwg MC41MCkpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X2RvdWJsZSgic21hbGxI ZWFwUkFNRnJhY3Rpb24iLCAmc21hbGxIZWFwUkFNRnJhY3Rpb24pKTsKKyAgICBnX2Fzc2VydF9j bXBmbG9hdChzbWFsbEhlYXBSQU1GcmFjdGlvbiwgPT0sIDAuNTApOworICAgIGdfYXNzZXJ0X3Ry dWUoanNjX29wdGlvbnNfc2V0X2RvdWJsZSgic21hbGxIZWFwUkFNRnJhY3Rpb24iLCAwLjI1KSk7 CisKKyAgICBHVW5pcXVlT3V0UHRyPGNoYXI+IGNvbmZpZ0ZpbGU7CisgICAgZ19hc3NlcnRfdHJ1 ZShqc2Nfb3B0aW9uc19nZXRfc3RyaW5nKCJjb25maWdGaWxlIiwgJmNvbmZpZ0ZpbGUub3V0UHRy KCkpKTsKKyAgICBnX2Fzc2VydF9udWxsKGNvbmZpZ0ZpbGUuZ2V0KCkpOworICAgIGdfYXNzZXJ0 X3RydWUoanNjX29wdGlvbnNfc2V0X3N0cmluZygiY29uZmlnRmlsZSIsICIvdG1wL2ZvbyIpKTsK KyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9zdHJpbmcoImNvbmZpZ0ZpbGUiLCAm Y29uZmlnRmlsZS5vdXRQdHIoKSkpOworICAgIGdfYXNzZXJ0X2NtcHN0cihjb25maWdGaWxlLmdl dCgpLCA9PSwgIi90bXAvZm9vIik7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRf c3RyaW5nKCJjb25maWdGaWxlIiwgbnVsbHB0cikpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29w dGlvbnNfZ2V0X3N0cmluZygiY29uZmlnRmlsZSIsICZjb25maWdGaWxlLm91dFB0cigpKSk7Cisg ICAgZ19hc3NlcnRfbnVsbChjb25maWdGaWxlLmdldCgpKTsKKworICAgIEdVbmlxdWVPdXRQdHI8 Y2hhcj4gYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19v cHRpb25zX2dldF9yYW5nZV9zdHJpbmcoImJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUiLCAmYnl0 ZWNvZGVSYW5nZVRvSklUQ29tcGlsZS5vdXRQdHIoKSkpOworICAgIGdfYXNzZXJ0X251bGwoYnl0 ZWNvZGVSYW5nZVRvSklUQ29tcGlsZS5nZXQoKSk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0 aW9uc19zZXRfcmFuZ2Vfc3RyaW5nKCJieXRlY29kZVJhbmdlVG9KSVRDb21waWxlIiwgIjEwMCIp KTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9yYW5nZV9zdHJpbmcoImJ5dGVj b2RlUmFuZ2VUb0pJVENvbXBpbGUiLCAmYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZS5vdXRQdHIo KSkpOworICAgIGdfYXNzZXJ0X2NtcHN0cihieXRlY29kZVJhbmdlVG9KSVRDb21waWxlLmdldCgp LCA9PSwgIjEwMCIpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfc2V0X3JhbmdlX3N0 cmluZygiYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZSIsICIxMDA6MjAwIikpOworICAgIGdfYXNz ZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X3JhbmdlX3N0cmluZygiYnl0ZWNvZGVSYW5nZVRvSklU Q29tcGlsZSIsICZieXRlY29kZVJhbmdlVG9KSVRDb21waWxlLm91dFB0cigpKSk7CisgICAgZ19h c3NlcnRfY21wc3RyKGJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUuZ2V0KCksID09LCAiMTAwOjIw MCIpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfc2V0X3JhbmdlX3N0cmluZygiYnl0 ZWNvZGVSYW5nZVRvSklUQ29tcGlsZSIsICIhMTAwOjIwMCIpKTsKKyAgICBnX2Fzc2VydF90cnVl KGpzY19vcHRpb25zX2dldF9yYW5nZV9zdHJpbmcoImJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUi LCAmYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZS5vdXRQdHIoKSkpOworICAgIGdfYXNzZXJ0X2Nt cHN0cihieXRlY29kZVJhbmdlVG9KSVRDb21waWxlLmdldCgpLCA9PSwgIiExMDA6MjAwIik7Cisg ICAgZ19hc3NlcnRfZmFsc2UoanNjX29wdGlvbnNfc2V0X3JhbmdlX3N0cmluZygiYnl0ZWNvZGVS YW5nZVRvSklUQ29tcGlsZSIsICIyMDA6MTAwIikpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29w dGlvbnNfZ2V0X3JhbmdlX3N0cmluZygiYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZSIsICZieXRl Y29kZVJhbmdlVG9KSVRDb21waWxlLm91dFB0cigpKSk7CisgICAgZ19hc3NlcnRfY21wc3RyKGJ5 dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUuZ2V0KCksID09LCAiITEwMDoyMDAiKTsKKyAgICBnX2Fz c2VydF90cnVlKGpzY19vcHRpb25zX3NldF9yYW5nZV9zdHJpbmcoImJ5dGVjb2RlUmFuZ2VUb0pJ VENvbXBpbGUiLCBudWxscHRyKSk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRf cmFuZ2Vfc3RyaW5nKCJieXRlY29kZVJhbmdlVG9KSVRDb21waWxlIiwgJmJ5dGVjb2RlUmFuZ2VU b0pJVENvbXBpbGUub3V0UHRyKCkpKTsKKyAgICBnX2Fzc2VydF9udWxsKGJ5dGVjb2RlUmFuZ2VU b0pJVENvbXBpbGUuZ2V0KCkpOworCisgICAgZ3VpbnQgbG9nR0M7CisgICAgZ19hc3NlcnRfdHJ1 ZShqc2Nfb3B0aW9uc19nZXRfdWludCgibG9nR0MiLCAmbG9nR0MpKTsKKyAgICBnX2Fzc2VydF9j bXB1aW50KGxvZ0dDLCA9PSwgMCk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRf dWludCgibG9nR0MiLCAxKSk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfdWlu dCgibG9nR0MiLCAmbG9nR0MpKTsKKyAgICBnX2Fzc2VydF9jbXB1aW50KGxvZ0dDLCA9PSwgMSk7 CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRfdWludCgibG9nR0MiLCAyKSk7Cisg ICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfdWludCgibG9nR0MiLCAmbG9nR0MpKTsK KyAgICBnX2Fzc2VydF9jbXB1aW50KGxvZ0dDLCA9PSwgMik7CisgICAgZ19hc3NlcnRfZmFsc2Uo anNjX29wdGlvbnNfc2V0X3VpbnQoImxvZ0dDIiwgMykpOworICAgIGdfYXNzZXJ0X3RydWUoanNj X29wdGlvbnNfZ2V0X3VpbnQoImxvZ0dDIiwgJmxvZ0dDKSk7CisgICAgZ19hc3NlcnRfY21wdWlu dChsb2dHQywgPT0sIDIpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfc2V0X3VpbnQo ImxvZ0dDIiwgMCkpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X3VpbnQoImxv Z0dDIiwgJmxvZ0dDKSk7CisgICAgZ19hc3NlcnRfY21wdWludChsb2dHQywgPT0sIDApOworCisg ICAgZ2Jvb2xlYW4gdmFsdWUgPSBUUlVFOworICAgIGdfYXNzZXJ0X2ZhbHNlKGpzY19vcHRpb25z X2dldF9ib29sZWFuKCJJbnZhbGlkT3B0aW9uIiwgJnZhbHVlKSk7CisgICAgZ19hc3NlcnRfdHJ1 ZSh2YWx1ZSk7CisgICAgZ19hc3NlcnRfZmFsc2UoanNjX29wdGlvbnNfc2V0X2Jvb2xlYW4oIklu dmFsaWRPcHRpb24iLCBUUlVFKSk7CisgICAgZ19hc3NlcnRfZmFsc2UoanNjX29wdGlvbnNfZ2V0 X2Jvb2xlYW4oIkludmFsaWRPcHRpb24iLCAmdmFsdWUpKTsKKyAgICBnX2Fzc2VydF90cnVlKHZh bHVlKTsKKworICAgIC8vIEZpbmQgYSBwYXJ0aWN1bGFyIG9wdGlvbi4KKyAgICBib29sIGZvdW5k ID0gZmFsc2U7CisgICAganNjX29wdGlvbnNfZm9yZWFjaChbXShjb25zdCBjaGFyKiBvcHRpb24s IEpTQ09wdGlvblR5cGUgdHlwZSwgY29uc3QgY2hhciogZGVzY3JpcHRpb24sIGdwb2ludGVyIHVz ZXJEYXRhKSAtPiBnYm9vbGVhbiB7CisgICAgICAgIGlmICghZ19zdHJjbXAwKG9wdGlvbiwgInVz ZUpJVCIpKSB7CisgICAgICAgICAgICAqc3RhdGljX2Nhc3Q8Ym9vbCo+KHVzZXJEYXRhKSA9IHRy dWU7CisgICAgICAgICAgICByZXR1cm4gVFJVRTsKKyAgICAgICAgfQorICAgICAgICByZXR1cm4g RkFMU0U7CisgICAgfSwgJmZvdW5kKTsKKyAgICBnX2Fzc2VydF90cnVlKGZvdW5kKTsKKworICAg IHVuc2lnbmVkIG9wdGlvbnNDb3VudCA9IDA7CisgICAganNjX29wdGlvbnNfZm9yZWFjaChbXShj b25zdCBjaGFyKiBvcHRpb24sIEpTQ09wdGlvblR5cGUgdHlwZSwgY29uc3QgY2hhciogZGVzY3Jp cHRpb24sIGdwb2ludGVyIHVzZXJEYXRhKSAtPiBnYm9vbGVhbiB7CisgICAgICAgICgqc3RhdGlj X2Nhc3Q8dW5zaWduZWQqPih1c2VyRGF0YSkpKys7CisgICAgICAgIHJldHVybiBGQUxTRTsKKyAg ICB9LCAmb3B0aW9uc0NvdW50KTsKKyAgICBnX2Fzc2VydF9jbXB1aW50KG9wdGlvbnNDb3VudCwg PiwgMTAwKTsKKyAgICBnX2Fzc2VydF9jbXB1aW50KG9wdGlvbnNDb3VudCwgPCwgNTAwKTsKKwor ICAgIG9wdGlvbnNDb3VudCA9IDA7CisgICAganNjX29wdGlvbnNfZm9yZWFjaChbXShjb25zdCBj aGFyKiBvcHRpb24sIEpTQ09wdGlvblR5cGUgdHlwZSwgY29uc3QgY2hhciogZGVzY3JpcHRpb24s IGdwb2ludGVyIHVzZXJEYXRhKSAtPiBnYm9vbGVhbiB7CisgICAgICAgIGlmICghZ19zdHJjbXAw KG9wdGlvbiwgInVzZUpJVCIpKQorICAgICAgICAgICAgZ19hc3NlcnRfdHJ1ZSh0eXBlID09IEpT Q19PUFRJT05fQk9PTEVBTik7CisgICAgICAgIGVsc2UgaWYgKCFnX3N0cmNtcDAob3B0aW9uLCAi dGhyZXNob2xkRm9ySklUQWZ0ZXJXYXJtVXAiKSkKKyAgICAgICAgICAgIGdfYXNzZXJ0X3RydWUo dHlwZSA9PSBKU0NfT1BUSU9OX0lOVCk7CisgICAgICAgIGVsc2UgaWYgKCFnX3N0cmNtcDAob3B0 aW9uLCAibWF4UGVyVGhyZWFkU3RhY2tVc2FnZSIpKQorICAgICAgICAgICAgZ19hc3NlcnRfdHJ1 ZSh0eXBlID09IEpTQ19PUFRJT05fVUlOVCk7CisgICAgICAgIGVsc2UgaWYgKCFnX3N0cmNtcDAo b3B0aW9uLCAid2ViQXNzZW1ibHlQYXJ0aWFsQ29tcGlsZUxpbWl0IikpCisgICAgICAgICAgICBn X2Fzc2VydF90cnVlKHR5cGUgPT0gSlNDX09QVElPTl9TSVpFKTsKKyAgICAgICAgZWxzZSBpZiAo IWdfc3RyY21wMChvcHRpb24sICJzbWFsbEhlYXBSQU1GcmFjdGlvbiIpKQorICAgICAgICAgICAg Z19hc3NlcnRfdHJ1ZSh0eXBlID09IEpTQ19PUFRJT05fRE9VQkxFKTsKKyAgICAgICAgZWxzZSBp ZiAoIWdfc3RyY21wMChvcHRpb24sICJjb25maWdGaWxlIikpCisgICAgICAgICAgICBnX2Fzc2Vy dF90cnVlKHR5cGUgPT0gSlNDX09QVElPTl9TVFJJTkcpOworICAgICAgICBlbHNlIGlmICghZ19z dHJjbXAwKG9wdGlvbiwgImJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUiKSkKKyAgICAgICAgICAg IGdfYXNzZXJ0X3RydWUodHlwZSA9PSBKU0NfT1BUSU9OX1JBTkdFX1NUUklORyk7CisgICAgICAg IGVsc2UKKyAgICAgICAgICAgIHJldHVybiBGQUxTRTsKKworICAgICAgICAoKnN0YXRpY19jYXN0 PHVuc2lnbmVkKj4odXNlckRhdGEpKSsrOworICAgICAgICByZXR1cm4gRkFMU0U7CisgICAgfSwg Jm9wdGlvbnNDb3VudCk7CisgICAgZ19hc3NlcnRfY21wdWludChvcHRpb25zQ291bnQsID09LCA3 KTsKKworICAgIEdPcHRpb25Db250ZXh0KiBjb250ZXh0ID0gZ19vcHRpb25fY29udGV4dF9uZXco bnVsbHB0cik7CisgICAgZ19vcHRpb25fY29udGV4dF9hZGRfZ3JvdXAoY29udGV4dCwganNjX29w dGlvbnNfZ2V0X29wdGlvbl9ncm91cCgpKTsKKyAgICBzdGF0aWMgY29uc3QgY2hhciogYXJndltd ID0geworICAgICAgICBfX0ZJTEVfXywKKyAgICAgICAgIi0tanNjLXVzZUpJVD1mYWxzZSIsCisg ICAgICAgICItLWpzYy10aHJlc2hvbGRGb3JKSVRBZnRlcldhcm1VcD0yMDAwIiwKKyAgICAgICAg Ii0tanNjLW1heFBlclRocmVhZFN0YWNrVXNhZ2U9MTAyNCIsCisgICAgICAgICItLWpzYy13ZWJB c3NlbWJseVBhcnRpYWxDb21waWxlTGltaXQ9NDAwMCIsCisgICAgICAgICItLWpzYy1zbWFsbEhl YXBSQU1GcmFjdGlvbj0wLjc1IiwKKyAgICAgICAgIi0tanNjLWNvbmZpZ0ZpbGU9L3RtcC9iYXIi LAorICAgICAgICAiLS1qc2MtYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZT0xMDA6MzAwIiwKKyAg ICAgICAgIi0tanNjLWxvZ0dDPTEiLAorICAgICAgICBudWxscHRyCisgICAgfTsKKyAgICBHVW5p cXVlUHRyPGNoYXIqPiBjb3B5KGdfc3RyZHVwdihjb25zdF9jYXN0PGNoYXIqKj4oYXJndikpKTsK KyAgICBpbnQgYXJnYyA9IGdfc3Rydl9sZW5ndGgoY29weS5nZXQoKSk7CisgICAgYXV0byogY29w eVB0ciA9IGNvcHkuZ2V0KCk7CisgICAgZ19hc3NlcnRfdHJ1ZShnX29wdGlvbl9jb250ZXh0X3Bh cnNlKGNvbnRleHQsICZhcmdjLCAmY29weVB0ciwgbnVsbHB0cikpOworICAgIGdfb3B0aW9uX2Nv bnRleHRfZnJlZShjb250ZXh0KTsKKworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0 X2Jvb2xlYW4oInVzZUpJVCIsICZ1c2VKSVQpKTsKKyAgICBnX2Fzc2VydF9mYWxzZSh1c2VKSVQp OworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X2ludCgidGhyZXNob2xkRm9ySklU QWZ0ZXJXYXJtVXAiLCAmdGhyZXNob2xkRm9ySklUQWZ0ZXJXYXJtVXApKTsKKyAgICBnX2Fzc2Vy dF9jbXBpbnQodGhyZXNob2xkRm9ySklUQWZ0ZXJXYXJtVXAsID09LCAyMDAwKTsKKyAgICBnX2Fz c2VydF90cnVlKGpzY19vcHRpb25zX2dldF91aW50KCJtYXhQZXJUaHJlYWRTdGFja1VzYWdlIiwg Jm1heFBlclRocmVhZFN0YWNrVXNhZ2UpKTsKKyAgICBnX2Fzc2VydF9jbXB1aW50KG1heFBlclRo cmVhZFN0YWNrVXNhZ2UsID09LCAxMDI0KTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25z X2dldF9zaXplKCJ3ZWJBc3NlbWJseVBhcnRpYWxDb21waWxlTGltaXQiLCAmd2ViQXNzZW1ibHlQ YXJ0aWFsQ29tcGlsZUxpbWl0KSk7CisgICAgZ19hc3NlcnRfY21wdWludCh3ZWJBc3NlbWJseVBh cnRpYWxDb21waWxlTGltaXQsID09LCA0MDAwKTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRp b25zX2dldF9kb3VibGUoInNtYWxsSGVhcFJBTUZyYWN0aW9uIiwgJnNtYWxsSGVhcFJBTUZyYWN0 aW9uKSk7CisgICAgZ19hc3NlcnRfY21wZmxvYXQoc21hbGxIZWFwUkFNRnJhY3Rpb24sID09LCAw Ljc1KTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9zdHJpbmcoImNvbmZpZ0Zp bGUiLCAmY29uZmlnRmlsZS5vdXRQdHIoKSkpOworICAgIGdfYXNzZXJ0X2NtcHN0cihjb25maWdG aWxlLmdldCgpLCA9PSwgIi90bXAvYmFyIik7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9u c19nZXRfcmFuZ2Vfc3RyaW5nKCJieXRlY29kZVJhbmdlVG9KSVRDb21waWxlIiwgJmJ5dGVjb2Rl UmFuZ2VUb0pJVENvbXBpbGUub3V0UHRyKCkpKTsKKyAgICBnX2Fzc2VydF9jbXBzdHIoYnl0ZWNv ZGVSYW5nZVRvSklUQ29tcGlsZS5nZXQoKSwgPT0sICIxMDA6MzAwIik7CisgICAgZ19hc3NlcnRf dHJ1ZShqc2Nfb3B0aW9uc19nZXRfdWludCgibG9nR0MiLCAmbG9nR0MpKTsKKyAgICBnX2Fzc2Vy dF9jbXB1aW50KGxvZ0dDLCA9PSwgMSk7CisKKyAgICAvLyBSZXN0b3JlIG9wdGlvbnMgdGhlaXIg ZGVmYXVsdCB2YWx1ZXMuCisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRfYm9vbGVh bigidXNlSklUIiwgVFJVRSkpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfc2V0X2lu dCgidGhyZXNob2xkRm9ySklUQWZ0ZXJXYXJtVXAiLCA1MDApKTsKKyAgICBnX2Fzc2VydF90cnVl KGpzY19vcHRpb25zX3NldF91aW50KCJtYXhQZXJUaHJlYWRTdGFja1VzYWdlIiwgNDE5NDMwNCkp OworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfc2V0X3NpemUoIndlYkFzc2VtYmx5UGFy dGlhbENvbXBpbGVMaW1pdCIsIDUwMDApKTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25z X3NldF9kb3VibGUoInNtYWxsSGVhcFJBTUZyYWN0aW9uIiwgMC4yNSkpOworICAgIGdfYXNzZXJ0 X3RydWUoanNjX29wdGlvbnNfc2V0X3N0cmluZygiY29uZmlnRmlsZSIsIG51bGxwdHIpKTsKKyAg ICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX3NldF9yYW5nZV9zdHJpbmcoImJ5dGVjb2RlUmFu Z2VUb0pJVENvbXBpbGUiLCBudWxscHRyKSk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9u c19zZXRfdWludCgibG9nR0MiLCAwKSk7CisKKyAgICBjb250ZXh0ID0gZ19vcHRpb25fY29udGV4 dF9uZXcobnVsbHB0cik7CisgICAgZ19vcHRpb25fY29udGV4dF9hZGRfZ3JvdXAoY29udGV4dCwg anNjX29wdGlvbnNfZ2V0X29wdGlvbl9ncm91cCgpKTsKKyAgICBzdGF0aWMgY29uc3QgY2hhciog YXJndjJbXSA9IHsgX19GSUxFX18sICItLWpzYy1JbnZhbGlkT3B0aW9uPXRydWUiLCBudWxscHRy IH07CisgICAgY29weS5yZXNldChnX3N0cmR1cHYoY29uc3RfY2FzdDxjaGFyKio+KGFyZ3YyKSkp OworICAgIGFyZ2MgPSBnX3N0cnZfbGVuZ3RoKGNvcHkuZ2V0KCkpOworICAgIGNvcHlQdHIgPSBj b3B5LmdldCgpOworICAgIGdfYXNzZXJ0X2ZhbHNlKGdfb3B0aW9uX2NvbnRleHRfcGFyc2UoY29u dGV4dCwgJmFyZ2MsICZjb3B5UHRyLCBudWxscHRyKSk7CisgICAgZ19vcHRpb25fY29udGV4dF9m cmVlKGNvbnRleHQpOworCisgICAgY29udGV4dCA9IGdfb3B0aW9uX2NvbnRleHRfbmV3KG51bGxw dHIpOworICAgIGdfb3B0aW9uX2NvbnRleHRfYWRkX2dyb3VwKGNvbnRleHQsIGpzY19vcHRpb25z X2dldF9vcHRpb25fZ3JvdXAoKSk7CisgICAgc3RhdGljIGNvbnN0IGNoYXIqIGFyZ3YzW10gPSB7 IF9fRklMRV9fLCAiLS1qc2MtdXNlSklUPW5laW4iLCBudWxscHRyIH07CisgICAgY29weS5yZXNl dChnX3N0cmR1cHYoY29uc3RfY2FzdDxjaGFyKio+KGFyZ3YzKSkpOworICAgIGFyZ2MgPSBnX3N0 cnZfbGVuZ3RoKGNvcHkuZ2V0KCkpOworICAgIGNvcHlQdHIgPSBjb3B5LmdldCgpOworICAgIGdf YXNzZXJ0X2ZhbHNlKGdfb3B0aW9uX2NvbnRleHRfcGFyc2UoY29udGV4dCwgJmFyZ2MsICZjb3B5 UHRyLCBudWxscHRyKSk7CisgICAgZ19vcHRpb25fY29udGV4dF9mcmVlKGNvbnRleHQpOworICAg IGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X2Jvb2xlYW4oInVzZUpJVCIsICZ1c2VKSVQp KTsKKyAgICBnX2Fzc2VydF90cnVlKHVzZUpJVCk7Cit9CisKICNpZmRlZiBHX0RFRklORV9BVVRP UFRSX0NMRUFOVVBfRlVOQwogc3RhdGljIHZvaWQgdGVzdHNKU0NBdXRvY2xlYW51cHMoKQogewpA QCAtMzI3MCw2ICszNDc1LDcgQEAgaW50IG1haW4oaW50IGFyZ2MsIGNoYXIqKiBhcmd2KQogICAg IGdfdGVzdF9hZGRfZnVuYygiL2pzYy9nYXJiYWdlLWNvbGxlY3RvciIsIHRlc3RKU0NHYXJiYWdl Q29sbGVjdG9yKTsKICAgICBnX3Rlc3RfYWRkX2Z1bmMoIi9qc2Mvd2Vhay12YWx1ZSIsIHRlc3RK U0NXZWFrVmFsdWUpOwogICAgIGdfdGVzdF9hZGRfZnVuYygiL2pzYy92bSIsIHRlc3RzSlNDVmly dHVhbE1hY2hpbmUpOworICAgIGdfdGVzdF9hZGRfZnVuYygiL2pzYy9vcHRpb25zIiwgdGVzdHNK U0NPcHRpb25zKTsKICNpZmRlZiBHX0RFRklORV9BVVRPUFRSX0NMRUFOVVBfRlVOQwogICAgIGdf dGVzdF9hZGRfZnVuYygiL2pzYy9hdXRvY2xlYW51cHMiLCB0ZXN0c0pTQ0F1dG9jbGVhbnVwcyk7 CiAjZW5kaWYK 359149 2019-01-15 02:33:51 -0800 2019-01-23 13:34:21 -0800 Patch jsc-options.diff text/plain 43464 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9KU0NPcHRpb25zLmNw cCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9KU0NPcHRpb25zLmNwcApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uMDgyMTI0ZmIyNjAKLS0tIC9kZXYvbnVs bAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQVBJL2dsaWIvSlNDT3B0aW9ucy5jcHAKQEAg LTAsMCArMSw3MjIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTkgSWdhbGlhIFMuTC4KKyAq CisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUg aXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFy eSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29m dHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9y IChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5 IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBi dXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50 eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3Ig bW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2Yg dGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhp cyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisg KiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQs IEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2lu Y2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkpTQ09wdGlvbnMuaCIKKworI2luY2x1ZGUgIk9w dGlvbnMuaCIKKyNpbmNsdWRlIDxnbGliL2dpMThuLWxpYi5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0 b3IuaD4KKyNpbmNsdWRlIDx3dGYvZ2xpYi9HVW5pcXVlUHRyLmg+CisKKy8qKgorICogU0VDVElP TjogSlNDT3B0aW9ucworICogQHNob3J0X2Rlc2NyaXB0aW9uOiBKYXZhU2NyaXB0IG9wdGlvbnMK KyAqIEB0aXRsZTogSlNDT3B0aW9ucworICoKKyAqIEphdmFTY3JpcHQgb3B0aW9ucyBhbGxvdyB0 byBjaGFuZ2UgdGhlIGJlaGF2aW9yIG9mIHRoZSBKYXZhU2NyaXB0IGVuZ2luZS4KKyAqIFRoZXkg YWZmZWN0IHRoZSB3YXkgdGhlIGVuZ2luZSB3b3Jrcywgc28gaXQncyBlbmNvdXJhZ2VkIHRvIHNl dCB0aGUgb3B0aW9ucworICogYXQgdGhlIHZlcnkgYmVnaW5uaW5nIG9mIHRoZSBwcm9ncmFtIGV4 ZWN1dGlvbiwgYmVmb3JlIGFueSBvdGhlciBKYXZhU2NyaXB0CisgKiBBUEkgY2FsbC4gTW9zdCBv ZiB0aGUgb3B0aW9ucyBhcmUgb25seSB1c2VmdWwgZm9yIHRlc3RpbmcgYW5kIGRlYnVnZ2luZy4K KyAqIE9ubHkgYSBmZXcgb2YgdGhlbSBhcmUgZG9jdW1lbnRlZCwgeW91IGNhbiB1c2UgdGhlIHVu ZG9jdW1lbnRlZCBvcHRpb25zIGF0CisgKiB5b3VyIG93biByaXNrICh5b3UgY2FuIGZpbmQgdGhl IGxpc3Qgb2Ygb3B0aW9ucyBpbiB0aGUgV2ViS2l0IHNvdXJjZSBjb2RlKS4KKyAqCisgKiBUaGUg QVBJIGFsbG93cyB0byBzZXQgYW5kIGdldCBhbnkgb3B0aW9uIHVzaW5nIHRoZSB0eXBlcyBkZWZp bmVkIGluICNKU0NPcHRpb25UeXBlLgorICogWW91IGNhbiBhbHNvIGl0ZXJhdGUgYWxsIHRoZSBh dmFpbGFibGUgb3B0aW9ucyB1c2luZyBqc2Nfb3B0aW9uc19mb3JlYWNoKCkgYW5kCisgKiBwYXNz aW5nIGEgI0pTQ09wdGlvbnNGdW5jIGNhbGxiYWNrLiBJZiB5b3VyIGFwcGxpY2F0aW9uIHVzZXMg I0dPcHRpb25Db250ZXh0IHRvIGhhbmRsZQorICogY29tbWFuZCBsaW5lIGFyZ3VtZW50cywgeW91 IGNhbiBlYXNpbHkgaW50ZWdyYXRlIHRoZSBKU0NPcHRpb25zIGJ5IGFkZGluZyB0aGUKKyAqICNH T3B0aW9uR3JvdXAgcmV0dXJuZWQgYnkganNjX29wdGlvbnNfZ2V0X29wdGlvbl9ncm91cCgpLgor ICoKKyAqIFNpbmNlOiAyLjI0CisgKi8KKwordXNpbmcgbmFtZXNwYWNlIEpTQzsKKwordHlwZWRl ZiBpbnQzMl90IGludDMyOwordHlwZWRlZiBzaXplX3Qgc2l6ZTsKKworc3RhdGljIGJvb2wgdmFs dWVGcm9tR1ZhbHVlKGNvbnN0IEdWYWx1ZSogZ1ZhbHVlLCBib29sJiB2YWx1ZSkKK3sKKyAgICB2 YWx1ZSA9IGdfdmFsdWVfZ2V0X2Jvb2xlYW4oZ1ZhbHVlKTsKKyAgICByZXR1cm4gdHJ1ZTsKK30K Kworc3RhdGljIHZvaWQgdmFsdWVUb0dWYWx1ZShib29sIHZhbHVlLCBHVmFsdWUqIGdWYWx1ZSkK K3sKKyAgICBnX3ZhbHVlX3NldF9ib29sZWFuKGdWYWx1ZSwgdmFsdWUpOworfQorCitzdGF0aWMg Ym9vbCB2YWx1ZUZyb21HVmFsdWUoY29uc3QgR1ZhbHVlKiBnVmFsdWUsIGludDMyX3QmIHZhbHVl KQoreworICAgIHZhbHVlID0gZ192YWx1ZV9nZXRfaW50KGdWYWx1ZSk7CisgICAgcmV0dXJuIHRy dWU7Cit9CisKK3N0YXRpYyB2b2lkIHZhbHVlVG9HVmFsdWUoaW50MzJfdCB2YWx1ZSwgR1ZhbHVl KiBnVmFsdWUpCit7CisgICAgZ192YWx1ZV9zZXRfaW50KGdWYWx1ZSwgdmFsdWUpOworfQorCitz dGF0aWMgYm9vbCB2YWx1ZUZyb21HVmFsdWUoY29uc3QgR1ZhbHVlKiBnVmFsdWUsIHVuc2lnbmVk JiB2YWx1ZSkKK3sKKyAgICB2YWx1ZSA9IGdfdmFsdWVfZ2V0X3VpbnQoZ1ZhbHVlKTsKKyAgICBy ZXR1cm4gdHJ1ZTsKK30KKworc3RhdGljIHZvaWQgdmFsdWVUb0dWYWx1ZSh1bnNpZ25lZCB2YWx1 ZSwgR1ZhbHVlKiBnVmFsdWUpCit7CisgICAgZ192YWx1ZV9zZXRfdWludChnVmFsdWUsIHZhbHVl KTsKK30KKworc3RhdGljIGJvb2wgdmFsdWVGcm9tR1ZhbHVlKGNvbnN0IEdWYWx1ZSogZ1ZhbHVl LCBzaXplX3QmIHZhbHVlKQoreworICAgIHZhbHVlID0gR1BPSU5URVJfVE9fU0laRShnX3ZhbHVl X2dldF9wb2ludGVyKGdWYWx1ZSkpOworICAgIHJldHVybiB0cnVlOworfQorCitzdGF0aWMgdm9p ZCB2YWx1ZVRvR1ZhbHVlKHNpemVfdCB2YWx1ZSwgR1ZhbHVlKiBnVmFsdWUpCit7CisgICAgZ192 YWx1ZV9zZXRfcG9pbnRlcihnVmFsdWUsIEdTSVpFX1RPX1BPSU5URVIodmFsdWUpKTsKK30KKwor c3RhdGljIGJvb2wgdmFsdWVGcm9tR1ZhbHVlKGNvbnN0IEdWYWx1ZSogZ1ZhbHVlLCBjb25zdCBj aGFyKiYgdmFsdWUpCit7CisgICAgdmFsdWUgPSBnX3ZhbHVlX2R1cF9zdHJpbmcoZ1ZhbHVlKTsK KyAgICByZXR1cm4gdHJ1ZTsKK30KKworc3RhdGljIHZvaWQgdmFsdWVUb0dWYWx1ZShjb25zdCBj aGFyKiB2YWx1ZSwgR1ZhbHVlKiBnVmFsdWUpCit7CisgICAgZ192YWx1ZV9zZXRfc3RyaW5nKGdW YWx1ZSwgdmFsdWUpOworfQorCitzdGF0aWMgYm9vbCB2YWx1ZUZyb21HVmFsdWUoY29uc3QgR1Zh bHVlKiBnVmFsdWUsIGRvdWJsZSYgdmFsdWUpCit7CisgICAgdmFsdWUgPSBnX3ZhbHVlX2dldF9k b3VibGUoZ1ZhbHVlKTsKKyAgICByZXR1cm4gdHJ1ZTsKK30KKworc3RhdGljIHZvaWQgdmFsdWVU b0dWYWx1ZShkb3VibGUgdmFsdWUsIEdWYWx1ZSogZ1ZhbHVlKQoreworICAgIGdfdmFsdWVfc2V0 X2RvdWJsZShnVmFsdWUsIHZhbHVlKTsKK30KKworc3RhdGljIGJvb2wgdmFsdWVGcm9tR1ZhbHVl KGNvbnN0IEdWYWx1ZSogZ1ZhbHVlLCBPcHRpb25SYW5nZSYgdmFsdWUpCit7CisgICAgcmV0dXJu IHZhbHVlLmluaXQoZ192YWx1ZV9nZXRfc3RyaW5nKGdWYWx1ZSkgPyBnX3ZhbHVlX2dldF9zdHJp bmcoZ1ZhbHVlKSA6ICI8bnVsbD4iKTsKK30KKworc3RhdGljIHZvaWQgdmFsdWVUb0dWYWx1ZShj b25zdCBPcHRpb25SYW5nZSYgdmFsdWUsIEdWYWx1ZSogZ1ZhbHVlKQoreworICAgIGNvbnN0IGNo YXIqIHJhbmdlU3RyaW5nID0gdmFsdWUucmFuZ2VTdHJpbmcoKTsKKyAgICBnX3ZhbHVlX3NldF9z dHJpbmcoZ1ZhbHVlLCAhZ19zdHJjbXAwKHJhbmdlU3RyaW5nLCAiPG51bGw+IikgPyBudWxscHRy IDogcmFuZ2VTdHJpbmcpOworfQorCitzdGF0aWMgYm9vbCB2YWx1ZUZyb21HVmFsdWUoY29uc3Qg R1ZhbHVlKiBnVmFsdWUsIEdDTG9nZ2luZzo6TGV2ZWwmIHZhbHVlKQoreworICAgIHN3aXRjaCAo Z192YWx1ZV9nZXRfdWludChnVmFsdWUpKSB7CisgICAgY2FzZSAwOgorICAgICAgICB2YWx1ZSA9 IEdDTG9nZ2luZzo6TGV2ZWw6Ok5vbmU7CisgICAgICAgIHJldHVybiB0cnVlOworICAgIGNhc2Ug MToKKyAgICAgICAgdmFsdWUgPSBHQ0xvZ2dpbmc6OkxldmVsOjpCYXNpYzsKKyAgICAgICAgcmV0 dXJuIHRydWU7CisgICAgY2FzZSAyOgorICAgICAgICB2YWx1ZSA9IEdDTG9nZ2luZzo6TGV2ZWw6 OlZlcmJvc2U7CisgICAgICAgIHJldHVybiB0cnVlOworICAgIGRlZmF1bHQ6CisgICAgICAgIGJy ZWFrOworICAgIH0KKworICAgIHJldHVybiBmYWxzZTsKK30KKworc3RhdGljIHZvaWQgdmFsdWVU b0dWYWx1ZShHQ0xvZ2dpbmc6OkxldmVsIHZhbHVlLCBHVmFsdWUqIGdWYWx1ZSkKK3sKKyAgICBz d2l0Y2ggKHZhbHVlKSB7CisgICAgY2FzZSBHQ0xvZ2dpbmc6OkxldmVsOjpOb25lOgorICAgICAg ICBnX3ZhbHVlX3NldF91aW50KGdWYWx1ZSwgMCk7CisgICAgICAgIGJyZWFrOworICAgIGNhc2Ug R0NMb2dnaW5nOjpMZXZlbDo6QmFzaWM6CisgICAgICAgIGdfdmFsdWVfc2V0X3VpbnQoZ1ZhbHVl LCAxKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBHQ0xvZ2dpbmc6OkxldmVsOjpWZXJib3Nl OgorICAgICAgICBnX3ZhbHVlX3NldF91aW50KGdWYWx1ZSwgMik7CisgICAgICAgIGJyZWFrOwor ICAgIH0KK30KKworc3RhdGljIGdib29sZWFuIGpzY09wdGlvbnNTZXRWYWx1ZShjb25zdCBjaGFy KiBvcHRpb24sIGNvbnN0IEdWYWx1ZSogdmFsdWUpCit7CisjZGVmaW5lIEZPUl9FQUNIX09QVElP Tih0eXBlXywgbmFtZV8sIGRlZmF1bHRWYWx1ZV8sIGF2YWlsYWJpbGl0eV8sIGRlc2NyaXB0aW9u XykgXAorICAgIGlmICghZ19zdHJjbXAwKCNuYW1lXywgb3B0aW9uKSkgeyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgXAorICAgICAgICB0eXBlXyB2YWx1ZVRvU2V0OyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgICAgICBpZiAoIXZh bHVlRnJvbUdWYWx1ZSh2YWx1ZSwgdmFsdWVUb1NldCkpICAgICAgICAgICAgICAgICAgICAgICAg XAorICAgICAgICAgICAgcmV0dXJuIEZBTFNFOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgXAorICAgICAgICBPcHRpb25zOjpuYW1lXygpID0gdmFsdWVUb1Nl dDsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgICAgICByZXR1cm4gVFJV RTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAor ICAgIH0KKworICAgIE9wdGlvbnM6OmluaXRpYWxpemUoKTsKKyAgICBKU0NfT1BUSU9OUyhGT1Jf RUFDSF9PUFRJT04pCisjdW5kZWYgRk9SX0VBQ0hfT1BUSU9OCisKKyAgICByZXR1cm4gRkFMU0U7 Cit9CisKK3N0YXRpYyBnYm9vbGVhbiBqc2NPcHRpb25zR2V0VmFsdWUoY29uc3QgY2hhciogb3B0 aW9uLCBHVmFsdWUqIHZhbHVlKQoreworI2RlZmluZSBGT1JfRUFDSF9PUFRJT04odHlwZV8sIG5h bWVfLCBkZWZhdWx0VmFsdWVfLCBhdmFpbGFiaWxpdHlfLCBkZXNjcmlwdGlvbl8pIFwKKyAgICBp ZiAoIWdfc3RyY21wMCgjbmFtZV8sIG9wdGlvbikpIHsgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIFwKKyAgICAgICAgdHlwZV8gdmFsdWVUb0dldCA9IE9wdGlvbnM6Om5hbWVfKCk7 ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgdmFsdWVUb0dWYWx1ZSh2YWx1 ZVRvR2V0LCB2YWx1ZSk7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAg cmV0dXJuIFRSVUU7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIFwKKyAgICB9CisKKyAgICBPcHRpb25zOjppbml0aWFsaXplKCk7CisgICAgSlNDX09Q VElPTlMoRk9SX0VBQ0hfT1BUSU9OKQorI3VuZGVmIEZPUl9FQUNIX09QVElPTgorCisgICAgcmV0 dXJuIEZBTFNFOworfQorCisvKioKKyAqIGpzY19vcHRpb25zX3NldF9ib29sZWFuOgorICogQG9w dGlvbjogdGhlIG9wdGlvbiBpZGVudGlmaWVyCisgKiBAdmFsdWU6IHRoZSB2YWx1ZSB0byBzZXQK KyAqCisgKiBTZXQgQG9wdGlvbiBhcyBhICNnYm9vbGVhbiB2YWx1ZS4KKyAqCisgKiBSZXR1cm5z OiAlVFJVRSBpZiBvcHRpb24gd2FzIGNvcnJlY3RseSBzZXQgb3IgJUZBTFNFIG90aGVyd2lzZS4K KyAqCisgKiBTaW5jZTogMi4yNAorICovCitnYm9vbGVhbiBqc2Nfb3B0aW9uc19zZXRfYm9vbGVh bihjb25zdCBjaGFyKiBvcHRpb24sIGdib29sZWFuIHZhbHVlKQoreworICAgIGdfcmV0dXJuX3Zh bF9pZl9mYWlsKG9wdGlvbiwgRkFMU0UpOworCisgICAgR1ZhbHVlIGdWYWx1ZSA9IEdfVkFMVUVf SU5JVDsKKyAgICBnX3ZhbHVlX2luaXQoJmdWYWx1ZSwgR19UWVBFX0JPT0xFQU4pOworICAgIGdf dmFsdWVfc2V0X2Jvb2xlYW4oJmdWYWx1ZSwgdmFsdWUpOworICAgIHJldHVybiBqc2NPcHRpb25z U2V0VmFsdWUob3B0aW9uLCAmZ1ZhbHVlKTsKK30KKworLyoqCisgKiBqc2Nfb3B0aW9uc19nZXRf Ym9vbGVhbjoKKyAqIEBvcHRpb246IHRoZSBvcHRpb24gaWRlbnRpZmllcgorICogQHZhbHVlOiAo b3V0KTogcmV0dXJuIGxvY2F0aW9uIGZvciB0aGUgb3B0aW9uIHZhbHVlCisgKgorICogR2V0IEBv cHRpb24gYXMgYSAjZ2Jvb2xlYW4gdmFsdWUuCisgKgorICogUmV0dXJuczogJVRSVUUgaWYgQHZh bHVlIGhhcyBiZWVuIHNldCBvciAlRkFMU0UgaWYgdGhlIG9wdGlvbiBkb2Vzbid0IGV4aXN0Cisg KgorICogU2luY2U6IDIuMjQKKyAqLworZ2Jvb2xlYW4ganNjX29wdGlvbnNfZ2V0X2Jvb2xlYW4o Y29uc3QgY2hhciogb3B0aW9uLCBnYm9vbGVhbiogdmFsdWUpCit7CisgICAgZ19yZXR1cm5fdmFs X2lmX2ZhaWwob3B0aW9uLCBGQUxTRSk7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwodmFsdWUs IEZBTFNFKTsKKworICAgIEdWYWx1ZSBnVmFsdWUgPSBHX1ZBTFVFX0lOSVQ7CisgICAgZ192YWx1 ZV9pbml0KCZnVmFsdWUsIEdfVFlQRV9CT09MRUFOKTsKKyAgICBpZiAoIWpzY09wdGlvbnNHZXRW YWx1ZShvcHRpb24sICZnVmFsdWUpKQorICAgICAgICByZXR1cm4gRkFMU0U7CisKKyAgICAqdmFs dWUgPSAgZ192YWx1ZV9nZXRfYm9vbGVhbigmZ1ZhbHVlKTsKKyAgICByZXR1cm4gVFJVRTsKK30K KworLyoqCisgKiBqc2Nfb3B0aW9uc19zZXRfaW50OgorICogQG9wdGlvbjogdGhlIG9wdGlvbiBp ZGVudGlmaWVyCisgKiBAdmFsdWU6IHRoZSB2YWx1ZSB0byBzZXQKKyAqCisgKiBTZXQgQG9wdGlv biBhcyBhICNnaW50IHZhbHVlLgorICoKKyAqIFJldHVybnM6ICVUUlVFIGlmIG9wdGlvbiB3YXMg Y29ycmVjdGx5IHNldCBvciAlRkFMU0Ugb3RoZXJ3aXNlLgorICoKKyAqIFNpbmNlOiAyLjI0Cisg Ki8KK2dib29sZWFuIGpzY19vcHRpb25zX3NldF9pbnQoY29uc3QgY2hhciogb3B0aW9uLCBnaW50 IHZhbHVlKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKG9wdGlvbiwgRkFMU0UpOworCisg ICAgR1ZhbHVlIGdWYWx1ZSA9IEdfVkFMVUVfSU5JVDsKKyAgICBnX3ZhbHVlX2luaXQoJmdWYWx1 ZSwgR19UWVBFX0lOVCk7CisgICAgZ192YWx1ZV9zZXRfaW50KCZnVmFsdWUsIHZhbHVlKTsKKyAg ICByZXR1cm4ganNjT3B0aW9uc1NldFZhbHVlKG9wdGlvbiwgJmdWYWx1ZSk7Cit9CisKKy8qKgor ICoganNjX29wdGlvbnNfZ2V0X2ludDoKKyAqIEBvcHRpb246IHRoZSBvcHRpb24gaWRlbnRpZmll cgorICogQHZhbHVlOiAob3V0KTogcmV0dXJuIGxvY2F0aW9uIGZvciB0aGUgb3B0aW9uIHZhbHVl CisgKgorICogR2V0IEBvcHRpb24gYXMgYSAjZ2ludCB2YWx1ZS4KKyAqCisgKiBSZXR1cm5zOiAl VFJVRSBpZiBAdmFsdWUgaGFzIGJlZW4gc2V0IG9yICVGQUxTRSBpZiB0aGUgb3B0aW9uIGRvZXNu J3QgZXhpc3QKKyAqCisgKiBTaW5jZTogMi4yNAorICovCitnYm9vbGVhbiBqc2Nfb3B0aW9uc19n ZXRfaW50KGNvbnN0IGNoYXIqIG9wdGlvbiwgZ2ludCogdmFsdWUpCit7CisgICAgZ19yZXR1cm5f dmFsX2lmX2ZhaWwob3B0aW9uLCBGQUxTRSk7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwodmFs dWUsIEZBTFNFKTsKKworICAgIEdWYWx1ZSBnVmFsdWUgPSBHX1ZBTFVFX0lOSVQ7CisgICAgZ192 YWx1ZV9pbml0KCZnVmFsdWUsIEdfVFlQRV9JTlQpOworICAgIGlmICghanNjT3B0aW9uc0dldFZh bHVlKG9wdGlvbiwgJmdWYWx1ZSkpCisgICAgICAgIHJldHVybiBGQUxTRTsKKworICAgICp2YWx1 ZSA9IGdfdmFsdWVfZ2V0X2ludCgmZ1ZhbHVlKTsKKyAgICByZXR1cm4gVFJVRTsKK30KKworLyoq CisgKiBqc2Nfb3B0aW9uc19zZXRfdWludDoKKyAqIEBvcHRpb246IHRoZSBvcHRpb24gaWRlbnRp ZmllcgorICogQHZhbHVlOiB0aGUgdmFsdWUgdG8gc2V0CisgKgorICogU2V0IEBvcHRpb24gYXMg YSAjZ3VpbnQgdmFsdWUuCisgKgorICogUmV0dXJuczogJVRSVUUgaWYgb3B0aW9uIHdhcyBjb3Jy ZWN0bHkgc2V0IG9yICVGQUxTRSBvdGhlcndpc2UuCisgKgorICogU2luY2U6IDIuMjQKKyAqLwor Z2Jvb2xlYW4ganNjX29wdGlvbnNfc2V0X3VpbnQoY29uc3QgY2hhciogb3B0aW9uLCBndWludCB2 YWx1ZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChvcHRpb24sIEZBTFNFKTsKKworICAg IEdWYWx1ZSBnVmFsdWUgPSBHX1ZBTFVFX0lOSVQ7CisgICAgZ192YWx1ZV9pbml0KCZnVmFsdWUs IEdfVFlQRV9VSU5UKTsKKyAgICBnX3ZhbHVlX3NldF91aW50KCZnVmFsdWUsIHZhbHVlKTsKKyAg ICByZXR1cm4ganNjT3B0aW9uc1NldFZhbHVlKG9wdGlvbiwgJmdWYWx1ZSk7Cit9CisKKy8qKgor ICoganNjX29wdGlvbnNfZ2V0X3VpbnQ6CisgKiBAb3B0aW9uOiB0aGUgb3B0aW9uIGlkZW50aWZp ZXIKKyAqIEB2YWx1ZTogKG91dCk6IHJldHVybiBsb2NhdGlvbiBmb3IgdGhlIG9wdGlvbiB2YWx1 ZQorICoKKyAqIEdldCBAb3B0aW9uIGFzIGEgI2d1aW50IHZhbHVlLgorICoKKyAqIFJldHVybnM6 ICVUUlVFIGlmIEB2YWx1ZSBoYXMgYmVlbiBzZXQgb3IgJUZBTFNFIGlmIHRoZSBvcHRpb24gZG9l c24ndCBleGlzdAorICoKKyAqIFNpbmNlOiAyLjI0CisgKi8KK2dib29sZWFuIGpzY19vcHRpb25z X2dldF91aW50KGNvbnN0IGNoYXIqIG9wdGlvbiwgZ3VpbnQqIHZhbHVlKQoreworICAgIGdfcmV0 dXJuX3ZhbF9pZl9mYWlsKG9wdGlvbiwgRkFMU0UpOworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWls KHZhbHVlLCBGQUxTRSk7CisKKyAgICBHVmFsdWUgZ1ZhbHVlID0gR19WQUxVRV9JTklUOworICAg IGdfdmFsdWVfaW5pdCgmZ1ZhbHVlLCBHX1RZUEVfVUlOVCk7CisgICAgaWYgKCFqc2NPcHRpb25z R2V0VmFsdWUob3B0aW9uLCAmZ1ZhbHVlKSkKKyAgICAgICAgcmV0dXJuIEZBTFNFOworCisgICAg KnZhbHVlID0gZ192YWx1ZV9nZXRfdWludCgmZ1ZhbHVlKTsKKyAgICByZXR1cm4gVFJVRTsKK30K KworLyoqCisgKiBqc2Nfb3B0aW9uc19zZXRfc2l6ZToKKyAqIEBvcHRpb246IHRoZSBvcHRpb24g aWRlbnRpZmllcgorICogQHZhbHVlOiB0aGUgdmFsdWUgdG8gc2V0CisgKgorICogU2V0IEBvcHRp b24gYXMgYSAjZ3NpemUgdmFsdWUuCisgKgorICogUmV0dXJuczogJVRSVUUgaWYgb3B0aW9uIHdh cyBjb3JyZWN0bHkgc2V0IG9yICVGQUxTRSBvdGhlcndpc2UuCisgKgorICogU2luY2U6IDIuMjQK KyAqLworZ2Jvb2xlYW4ganNjX29wdGlvbnNfc2V0X3NpemUoY29uc3QgY2hhciogb3B0aW9uLCBn c2l6ZSB2YWx1ZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChvcHRpb24sIEZBTFNFKTsK KworICAgIEdWYWx1ZSBnVmFsdWUgPSBHX1ZBTFVFX0lOSVQ7CisgICAgZ192YWx1ZV9pbml0KCZn VmFsdWUsIEdfVFlQRV9QT0lOVEVSKTsKKyAgICBnX3ZhbHVlX3NldF9wb2ludGVyKCZnVmFsdWUs IEdTSVpFX1RPX1BPSU5URVIodmFsdWUpKTsKKyAgICByZXR1cm4ganNjT3B0aW9uc1NldFZhbHVl KG9wdGlvbiwgJmdWYWx1ZSk7Cit9CisKKy8qKgorICoganNjX29wdGlvbnNfZ2V0X3NpemU6Cisg KiBAb3B0aW9uOiB0aGUgb3B0aW9uIGlkZW50aWZpZXIKKyAqIEB2YWx1ZTogKG91dCk6IHJldHVy biBsb2NhdGlvbiBmb3IgdGhlIG9wdGlvbiB2YWx1ZQorICoKKyAqIEdldCBAb3B0aW9uIGFzIGEg I2dzaXplIHZhbHVlLgorICoKKyAqIFJldHVybnM6ICVUUlVFIGlmIEB2YWx1ZSBoYXMgYmVlbiBz ZXQgb3IgJUZBTFNFIGlmIHRoZSBvcHRpb24gZG9lc24ndCBleGlzdAorICoKKyAqIFNpbmNlOiAy LjI0CisgKi8KK2dib29sZWFuIGpzY19vcHRpb25zX2dldF9zaXplKGNvbnN0IGNoYXIqIG9wdGlv biwgZ3NpemUqIHZhbHVlKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKG9wdGlvbiwgRkFM U0UpOworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKHZhbHVlLCBGQUxTRSk7CisKKyAgICBHVmFs dWUgZ1ZhbHVlID0gR19WQUxVRV9JTklUOworICAgIGdfdmFsdWVfaW5pdCgmZ1ZhbHVlLCBHX1RZ UEVfUE9JTlRFUik7CisgICAgaWYgKCFqc2NPcHRpb25zR2V0VmFsdWUob3B0aW9uLCAmZ1ZhbHVl KSkKKyAgICAgICAgcmV0dXJuIEZBTFNFOworCisgICAgKnZhbHVlID0gR1BPSU5URVJfVE9fU0la RShnX3ZhbHVlX2dldF9wb2ludGVyKCZnVmFsdWUpKTsKKyAgICByZXR1cm4gVFJVRTsKK30KKwor LyoqCisgKiBqc2Nfb3B0aW9uc19zZXRfZG91YmxlOgorICogQG9wdGlvbjogdGhlIG9wdGlvbiBp ZGVudGlmaWVyCisgKiBAdmFsdWU6IHRoZSB2YWx1ZSB0byBzZXQKKyAqCisgKiBTZXQgQG9wdGlv biBhcyBhICNnZG91YmxlIHZhbHVlLgorICoKKyAqIFJldHVybnM6ICVUUlVFIGlmIG9wdGlvbiB3 YXMgY29ycmVjdGx5IHNldCBvciAlRkFMU0Ugb3RoZXJ3aXNlLgorICoKKyAqIFNpbmNlOiAyLjI0 CisgKi8KK2dib29sZWFuIGpzY19vcHRpb25zX3NldF9kb3VibGUoY29uc3QgY2hhciogb3B0aW9u LCBnZG91YmxlIHZhbHVlKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKG9wdGlvbiwgRkFM U0UpOworCisgICAgR1ZhbHVlIGdWYWx1ZSA9IEdfVkFMVUVfSU5JVDsKKyAgICBnX3ZhbHVlX2lu aXQoJmdWYWx1ZSwgR19UWVBFX0RPVUJMRSk7CisgICAgZ192YWx1ZV9zZXRfZG91YmxlKCZnVmFs dWUsIHZhbHVlKTsKKyAgICByZXR1cm4ganNjT3B0aW9uc1NldFZhbHVlKG9wdGlvbiwgJmdWYWx1 ZSk7Cit9CisKKy8qKgorICoganNjX29wdGlvbnNfZ2V0X2RvdWJsZToKKyAqIEBvcHRpb246IHRo ZSBvcHRpb24gaWRlbnRpZmllcgorICogQHZhbHVlOiAob3V0KTogcmV0dXJuIGxvY2F0aW9uIGZv ciB0aGUgb3B0aW9uIHZhbHVlCisgKgorICogR2V0IEBvcHRpb24gYXMgYSAjZ2RvdWJsZSB2YWx1 ZS4KKyAqCisgKiBSZXR1cm5zOiAlVFJVRSBpZiBAdmFsdWUgaGFzIGJlZW4gc2V0IG9yICVGQUxT RSBpZiB0aGUgb3B0aW9uIGRvZXNuJ3QgZXhpc3QKKyAqCisgKiBTaW5jZTogMi4yNAorICovCitn Ym9vbGVhbiBqc2Nfb3B0aW9uc19nZXRfZG91YmxlKGNvbnN0IGNoYXIqIG9wdGlvbiwgZ2RvdWJs ZSogdmFsdWUpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwob3B0aW9uLCBGQUxTRSk7Cisg ICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwodmFsdWUsIEZBTFNFKTsKKworICAgIEdWYWx1ZSBnVmFs dWUgPSBHX1ZBTFVFX0lOSVQ7CisgICAgZ192YWx1ZV9pbml0KCZnVmFsdWUsIEdfVFlQRV9ET1VC TEUpOworICAgIGlmICghanNjT3B0aW9uc0dldFZhbHVlKG9wdGlvbiwgJmdWYWx1ZSkpCisgICAg ICAgIHJldHVybiBGQUxTRTsKKworICAgICp2YWx1ZSA9IGdfdmFsdWVfZ2V0X2RvdWJsZSgmZ1Zh bHVlKTsKKyAgICByZXR1cm4gVFJVRTsKK30KKworLyoqCisgKiBqc2Nfb3B0aW9uc19zZXRfc3Ry aW5nOgorICogQG9wdGlvbjogdGhlIG9wdGlvbiBpZGVudGlmaWVyCisgKiBAdmFsdWU6IHRoZSB2 YWx1ZSB0byBzZXQKKyAqCisgKiBTZXQgQG9wdGlvbiBhcyBhIHN0cmluZy4KKyAqCisgKiBSZXR1 cm5zOiAlVFJVRSBpZiBvcHRpb24gd2FzIGNvcnJlY3RseSBzZXQgb3IgJUZBTFNFIG90aGVyd2lz ZS4KKyAqCisgKiBTaW5jZTogMi4yNAorICovCitnYm9vbGVhbiBqc2Nfb3B0aW9uc19zZXRfc3Ry aW5nKGNvbnN0IGNoYXIqIG9wdGlvbiwgY29uc3QgY2hhciogdmFsdWUpCit7CisgICAgZ19yZXR1 cm5fdmFsX2lmX2ZhaWwob3B0aW9uLCBGQUxTRSk7CisKKyAgICBHVmFsdWUgZ1ZhbHVlID0gR19W QUxVRV9JTklUOworICAgIGdfdmFsdWVfaW5pdCgmZ1ZhbHVlLCBHX1RZUEVfU1RSSU5HKTsKKyAg ICBnX3ZhbHVlX3NldF9zdHJpbmcoJmdWYWx1ZSwgdmFsdWUpOworICAgIGJvb2wgc3VjY2VzcyA9 IGpzY09wdGlvbnNTZXRWYWx1ZShvcHRpb24sICZnVmFsdWUpOworICAgIGdfdmFsdWVfdW5zZXQo JmdWYWx1ZSk7CisgICAgcmV0dXJuIHN1Y2Nlc3M7Cit9CisKKy8qKgorICoganNjX29wdGlvbnNf Z2V0X3N0cmluZzoKKyAqIEBvcHRpb246IHRoZSBvcHRpb24gaWRlbnRpZmllcgorICogQHZhbHVl OiAob3V0KTogcmV0dXJuIGxvY2F0aW9uIGZvciB0aGUgb3B0aW9uIHZhbHVlCisgKgorICogR2V0 IEBvcHRpb24gYXMgYSBzdHJpbmcuCisgKgorICogUmV0dXJuczogJVRSVUUgaWYgQHZhbHVlIGhh cyBiZWVuIHNldCBvciAlRkFMU0UgaWYgdGhlIG9wdGlvbiBkb2Vzbid0IGV4aXN0CisgKgorICog U2luY2U6IDIuMjQKKyAqLworZ2Jvb2xlYW4ganNjX29wdGlvbnNfZ2V0X3N0cmluZyhjb25zdCBj aGFyKiBvcHRpb24sIGNoYXIqKiB2YWx1ZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChv cHRpb24sIEZBTFNFKTsKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbCh2YWx1ZSwgRkFMU0UpOwor CisgICAgR1ZhbHVlIGdWYWx1ZSA9IEdfVkFMVUVfSU5JVDsKKyAgICBnX3ZhbHVlX2luaXQoJmdW YWx1ZSwgR19UWVBFX1NUUklORyk7CisgICAgaWYgKCFqc2NPcHRpb25zR2V0VmFsdWUob3B0aW9u LCAmZ1ZhbHVlKSkKKyAgICAgICAgcmV0dXJuIEZBTFNFOworCisgICAgKnZhbHVlID0gZ192YWx1 ZV9kdXBfc3RyaW5nKCZnVmFsdWUpOworICAgIGdfdmFsdWVfdW5zZXQoJmdWYWx1ZSk7CisgICAg cmV0dXJuIFRSVUU7Cit9CisKKy8qKgorICoganNjX29wdGlvbnNfc2V0X3JhbmdlX3N0cmluZzoK KyAqIEBvcHRpb246IHRoZSBvcHRpb24gaWRlbnRpZmllcgorICogQHZhbHVlOiB0aGUgdmFsdWUg dG8gc2V0CisgKgorICogU2V0IEBvcHRpb24gYXMgYSByYW5nZSBzdHJpbmcuIFRoZSBzdHJpbmcg bXVzdCBiZSBpbiB0aGUKKyAqIGZvcm1hdCA8ZW1waGFzaXM+WyFdJmx0O2xvdyZndDtbOiZsdDto aWdoJmd0O108L2VtcGhhc2lzPiB3aGVyZSBsb3cgYW5kIGhpZ2ggYXJlICNndWludCB2YWx1ZXMu CisgKiBWYWx1ZXMgYmV0d2VlbiBsb3cgYW5kIGhpZ2ggKGJvdGggaW5jbHVkZWQpIHdpbGwgYmUg Y29uc2lkZXJlZCBpbgorICogdGhlIHJhbmdlLCB1bmxlc3MgPGVtcGhhc2lzPiE8L2VtcGhhc2lz PiBpcyB1c2VkIHRvIGludmVydCB0aGUgcmFuZ2UuCisgKgorICogUmV0dXJuczogJVRSVUUgaWYg b3B0aW9uIHdhcyBjb3JyZWN0bHkgc2V0IG9yICVGQUxTRSBvdGhlcndpc2UuCisgKgorICogU2lu Y2U6IDIuMjQKKyAqLworZ2Jvb2xlYW4ganNjX29wdGlvbnNfc2V0X3JhbmdlX3N0cmluZyhjb25z dCBjaGFyKiBvcHRpb24sIGNvbnN0IGNoYXIqIHZhbHVlKQoreworICAgIGdfcmV0dXJuX3ZhbF9p Zl9mYWlsKG9wdGlvbiwgRkFMU0UpOworCisgICAgR1ZhbHVlIGdWYWx1ZSA9IEdfVkFMVUVfSU5J VDsKKyAgICBnX3ZhbHVlX2luaXQoJmdWYWx1ZSwgR19UWVBFX1NUUklORyk7CisgICAgZ192YWx1 ZV9zZXRfc3RyaW5nKCZnVmFsdWUsIHZhbHVlKTsKKyAgICBib29sIHN1Y2Nlc3MgPSBqc2NPcHRp b25zU2V0VmFsdWUob3B0aW9uLCAmZ1ZhbHVlKTsKKyAgICBnX3ZhbHVlX3Vuc2V0KCZnVmFsdWUp OworICAgIHJldHVybiBzdWNjZXNzOworfQorCisvKioKKyAqIGpzY19vcHRpb25zX2dldF9yYW5n ZV9zdHJpbmc6CisgKiBAb3B0aW9uOiB0aGUgb3B0aW9uIGlkZW50aWZpZXIKKyAqIEB2YWx1ZTog KG91dCk6IHJldHVybiBsb2NhdGlvbiBmb3IgdGhlIG9wdGlvbiB2YWx1ZQorICoKKyAqIEdldCBA b3B0aW9uIGFzIGEgcmFuZ2Ugc3RyaW5nLiBUaGUgc3RyaW5nIG11c3QgYmUgaW4gdGhlCisgKiBm b3JtYXQgPGVtcGhhc2lzPlshXSZsdDtsb3cmZ3Q7WzombHQ7aGlnaCZndDtdPC9lbXBoYXNpcz4g d2hlcmUgbG93IGFuZCBoaWdoIGFyZSAjZ3VpbnQgdmFsdWVzLgorICogVmFsdWVzIGJldHdlZW4g bG93IGFuZCBoaWdoIChib3RoIGluY2x1ZGVkKSB3aWxsIGJlIGNvbnNpZGVyZWQgaW4KKyAqIHRo ZSByYW5nZSwgdW5sZXNzIDxlbXBoYXNpcz4hPC9lbXBoYXNpcz4gaXMgdXNlZCB0byBpbnZlcnQg dGhlIHJhbmdlLgorICoKKyAqIFJldHVybnM6ICVUUlVFIGlmIEB2YWx1ZSBoYXMgYmVlbiBzZXQg b3IgJUZBTFNFIGlmIHRoZSBvcHRpb24gZG9lc24ndCBleGlzdAorICoKKyAqIFNpbmNlOiAyLjI0 CisgKi8KK2dib29sZWFuIGpzY19vcHRpb25zX2dldF9yYW5nZV9zdHJpbmcoY29uc3QgY2hhciog b3B0aW9uLCBjaGFyKiogdmFsdWUpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwob3B0aW9u LCBGQUxTRSk7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwodmFsdWUsIEZBTFNFKTsKKworICAg IEdWYWx1ZSBnVmFsdWUgPSBHX1ZBTFVFX0lOSVQ7CisgICAgZ192YWx1ZV9pbml0KCZnVmFsdWUs IEdfVFlQRV9TVFJJTkcpOworICAgIGlmICghanNjT3B0aW9uc0dldFZhbHVlKG9wdGlvbiwgJmdW YWx1ZSkpCisgICAgICAgIHJldHVybiBGQUxTRTsKKworICAgICp2YWx1ZSA9IGdfdmFsdWVfZHVw X3N0cmluZygmZ1ZhbHVlKTsKKyAgICBnX3ZhbHVlX3Vuc2V0KCZnVmFsdWUpOworICAgIHJldHVy biBUUlVFOworfQorCitzdGF0aWMgSlNDT3B0aW9uVHlwZSBqc2NPcHRpb25zVHlwZShib29sKQor eworICAgIHJldHVybiBKU0NfT1BUSU9OX0JPT0xFQU47Cit9CisKK3N0YXRpYyBKU0NPcHRpb25U eXBlIGpzY09wdGlvbnNUeXBlKGludCkKK3sKKyAgICByZXR1cm4gSlNDX09QVElPTl9JTlQ7Cit9 CisKK3N0YXRpYyBKU0NPcHRpb25UeXBlIGpzY09wdGlvbnNUeXBlKHVuc2lnbmVkKQoreworICAg IHJldHVybiBKU0NfT1BUSU9OX1VJTlQ7Cit9CisKK3N0YXRpYyBKU0NPcHRpb25UeXBlIGpzY09w dGlvbnNUeXBlKHNpemVfdCkKK3sKKyAgICByZXR1cm4gSlNDX09QVElPTl9TSVpFOworfQorCitz dGF0aWMgSlNDT3B0aW9uVHlwZSBqc2NPcHRpb25zVHlwZShkb3VibGUpCit7CisgICAgcmV0dXJu IEpTQ19PUFRJT05fRE9VQkxFOworfQorCitzdGF0aWMgSlNDT3B0aW9uVHlwZSBqc2NPcHRpb25z VHlwZShjb25zdCBjaGFyKikKK3sKKyAgICByZXR1cm4gSlNDX09QVElPTl9TVFJJTkc7Cit9CisK K3N0YXRpYyBKU0NPcHRpb25UeXBlIGpzY09wdGlvbnNUeXBlKGNvbnN0IE9wdGlvblJhbmdlJikK K3sKKyAgICByZXR1cm4gSlNDX09QVElPTl9SQU5HRV9TVFJJTkc7Cit9CisKKy8qKgorICogSlND T3B0aW9uVHlwZToKKyAqIEBKU0NfT1BUSU9OX0JPT0xFQU46IEEgI2dib29sZWFuIG9wdGlvbiB0 eXBlLgorICogQEpTQ19PUFRJT05fSU5UOiBBICNnaW50IG9wdGlvbiB0eXBlLgorICogQEpTQ19P UFRJT05fVUlOVDogQSAjZ3VpbnQgb3B0aW9uIHR5cGUuCisgKiBASlNDX09QVElPTl9TSVpFOiBB ICNnc2l6ZSBvcHRpb25zIHR5cGUuCisgKiBASlNDX09QVElPTl9ET1VCTEU6IEEgI2dkb3VibGUg b3B0aW9ucyB0eXBlLgorICogQEpTQ19PUFRJT05fU1RSSU5HOiBBIHN0cmluZyBvcHRpb24gdHlw ZS4KKyAqIEBKU0NfT1BUSU9OX1JBTkdFX1NUUklORzogQSByYW5nZSBzdHJpbmcgb3B0aW9uIHR5 cGUuCisgKgorICogRW51bSB2YWx1ZXMgZm9yIG9wdGlvbnMgdHlwZXMuCisgKgorICogU2luY2U6 IDIuMjQKKyAqLworCisvKioKKyAqIEpTQ09wdGlvbnNGdW5jOgorICogQG9wdGlvbjogdGhlIG9w dGlvbiBuYW1lCisgKiBAdHlwZTogdGhlIG9wdGlvbiAjSlNDT3B0aW9uVHlwZQorICogQGRlc2Ny aXB0aW9uOiAobnVsbGFibGUpOiB0aGUgb3B0aW9uIGRlc2NyaXB0aW9uLCBvciAlTlVMTAorICog QHVzZXJfZGF0YTogdXNlciBkYXRhCisgKgorICogRnVuY3Rpb24gdXNlZCB0byBpdGVyYXRlIG9w dGlvbnMuCisgKgorICogTm90IHRoYXQgQGRlc2NyaXB0aW9uIHN0cmluZyBpcyBub3QgbG9jYWxp emVkLgorICoKKyAqIFJldHVybnM6ICVUUlVFIHRvIHN0b3AgdGhlIGl0ZXJhdGlvbiwgb3IgJUZB TFNFIG90aGVyd2lzZQorICoKKyAqIFNpbmNlOiAyLjI0CisgKi8KKworLyoqCisgKiBqc2Nfb3B0 aW9uc19mb3JlYWNoOgorICogQGZ1bmN0aW9uOiAoc2NvcGUgY2FsbCk6IGEgI0pTQ09wdGlvbnNG dW5jIGNhbGxiYWNrCisgKiBAdXNlcl9kYXRhOiBjYWxsYmFjayB1c2VyIGRhdGEKKyAqCisgKiBJ dGVyYXRlcyBhbGwgYXZhaWxhYmxlIG9wdGlvbnMgY2FsbGluZyBAZnVuY3Rpb24gZm9yIGVhY2gg b25lLiBJdGVyYXRpb24gY2FuCisgKiBzdG9wIGVhcmx5IGlmIEBmdW5jdGlvbiByZXR1cm5zICVG QUxTRS4KKyAqCisgKiBTaW5jZTogMi4yNAorICovCit2b2lkIGpzY19vcHRpb25zX2ZvcmVhY2go SlNDT3B0aW9uc0Z1bmMgZnVuY3Rpb24sIGdwb2ludGVyIHVzZXJEYXRhKQoreworICAgIGdfcmV0 dXJuX2lmX2ZhaWwoZnVuY3Rpb24pOworCisjZGVmaW5lIEZPUl9FQUNIX09QVElPTih0eXBlXywg bmFtZV8sIGRlZmF1bHRWYWx1ZV8sIGF2YWlsYWJpbGl0eV8sIGRlc2NyaXB0aW9uXykgXAorICAg IGlmIChPcHRpb25zOjpBdmFpbGFiaWxpdHk6OmF2YWlsYWJpbGl0eV8gPT0gT3B0aW9uczo6QXZh aWxhYmlsaXR5OjpOb3JtYWwgXAorICAgICAgICB8fCBPcHRpb25zOjppc0F2YWlsYWJsZShPcHRp b25zOjpuYW1lXyMjSUQsIE9wdGlvbnM6OkF2YWlsYWJpbGl0eTo6YXZhaWxhYmlsaXR5XykpIHsg XAorICAgICAgICB0eXBlXyBkZWZhdWx0VmFsdWU7ICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgXAorICAgICAgICBhdXRvIG9wdGlvblR5cGUgPSBqc2NPcHRpb25z VHlwZShkZWZhdWx0VmFsdWUpOyAgICAgICAgICAgICAgICAgXAorICAgICAgICBpZiAoZnVuY3Rp b24gKCNuYW1lXywgb3B0aW9uVHlwZSwgZGVzY3JpcHRpb25fLCB1c2VyRGF0YSkpICAgICAgXAor ICAgICAgICAgICAgcmV0dXJuOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgXAorICAgIH0KKworICAgIE9wdGlvbnM6OmluaXRpYWxpemUoKTsKKyAg ICBKU0NfT1BUSU9OUyhGT1JfRUFDSF9PUFRJT04pCisjdW5kZWYgRk9SX0VBQ0hfT1BUSU9OCit9 CisKK3N0YXRpYyBnYm9vbGVhbiBzZXRPcHRpb25FbnRyeShjb25zdCBjaGFyKiBvcHRpb25OYW1l RnVsbCwgY29uc3QgY2hhciogdmFsdWUsIGdwb2ludGVyLCBHRXJyb3IqKiBlcnJvcikKK3sKKyAg ICBjb25zdCBjaGFyKiBvcHRpb25OYW1lID0gb3B0aW9uTmFtZUZ1bGwgKyA2OyAvLyBSZW1vdmUg dGhlIC0tanNjLSBwcmVmaXguCisgICAgR1VuaXF1ZVB0cjxjaGFyPiBvcHRpb24oZ19zdHJkdXBf cHJpbnRmKCIlcz0lcyIsIG9wdGlvbk5hbWUsIHZhbHVlKSk7CisgICAgaWYgKCFPcHRpb25zOjpz ZXRPcHRpb24ob3B0aW9uLmdldCgpKSkgeworICAgICAgICBnX3NldF9lcnJvcihlcnJvciwgR19P UFRJT05fRVJST1IsIEdfT1BUSU9OX0VSUk9SX0JBRF9WQUxVRSwgIkZhaWxlZCBwYXJzZSB2YWx1 ZSAnJXMnIGZvciAlcyIsIHZhbHVlLCBvcHRpb25OYW1lRnVsbCk7CisgICAgICAgIHJldHVybiBG QUxTRTsKKyAgICB9CisgICAgcmV0dXJuIFRSVUU7Cit9CisKKy8qKgorICoganNjX29wdGlvbnNf Z2V0X29wdGlvbl9ncm91cDoKKyAqCisgKiBDcmVhdGUgYSAjR09wdGlvbkdyb3VwIHRvIGhhbmRs ZSBKU0NPcHRpb25zIGFzIGNvbW1hbmQgbGluZSBhcmd1bWVudHMuCisgKiBUaGUgb3B0aW9ucyB3 aWxsIGJlIGV4cG9zZWQgYXMgY29tbWFuZCBsaW5lIGFyZ3VtZW50cyB3aXRoIHRoZSBmb3JtCisg KiA8ZW1waGFzaXM+LS1qc2MtJmx0O29wdGlvbiZndDs9Jmx0O3ZhbHVlJmd0OzwvZW1waGFzaXM+ LgorICogRWFjaCBlbnRyeSBpbiB0aGUgcmV0dXJuZWQgI0dPcHRpb25Hcm91cCBpcyBjb25maWd1 cmVkIHRvIGFwcGx5IHRoZQorICogY29ycmVzcG9uZGluZyBvcHRpb24gZHVyaW5nIGNvbW1hbmQg bGluZSBwYXJzaW5nLiBBcHBsaWNhdGlvbnMgb25seSBuZWVkIHRvCisgKiBwYXNzIHRoZSByZXR1 cm5lZCBncm91cCB0byBnX29wdGlvbl9jb250ZXh0X2FkZF9ncm91cCgpLCBhbmQgdGhlIHJlc3Qg d2lsbAorICogYmUgdGFrZW4gY2FyZSBmb3IgYXV0b21hdGljYWxseS4KKyAqCisgKiBSZXR1cm5z OiAodHJhbnNmZXIgZnVsbCk6IGEgI0dPcHRpb25Hcm91cCBmb3IgdGhlIEpTQ09wdGlvbnMKKyAq CisgKiBTaW5jZTogMi4yNAorICovCitHT3B0aW9uR3JvdXAqIGpzY19vcHRpb25zX2dldF9vcHRp b25fZ3JvdXAodm9pZCkKK3sKKyAgICAvLyBHT3B0aW9uRW50cnkgd29ya3Mgd2l0aCBjb25zdCBz dHJpbmdzLCBzbyB3ZSBuZWVkIHRvIGtlZXAgdGhlIG9wdGlvbiBuYW1lcyBhcm91bmQuCisgICAg YXV0byogbmFtZXMgPSBuZXcgVmVjdG9yPEdVbmlxdWVQdHI8Y2hhcj4+OworICAgIEdPcHRpb25H cm91cCogZ3JvdXAgPSBnX29wdGlvbl9ncm91cF9uZXcoImpzYyIsIF8oIkpTQyBPcHRpb25zIiks IF8oIlNob3cgSlNDIE9wdGlvbnMiKSwgbmFtZXMsIFtdIChncG9pbnRlciBkYXRhKSB7CisgICAg ICAgIGRlbGV0ZSBzdGF0aWNfY2FzdDxWZWN0b3I8R1VuaXF1ZVB0cjxjaGFyPj4qPihkYXRhKTsK KyAgICB9KTsKKyAgICBnX29wdGlvbl9ncm91cF9zZXRfdHJhbnNsYXRpb25fZG9tYWluKGdyb3Vw LCBHRVRURVhUX1BBQ0tBR0UpOworCisgICAgR0FycmF5KiBlbnRyaWVzID0gZ19hcnJheV9uZXco VFJVRSwgVFJVRSwgc2l6ZW9mKEdPcHRpb25FbnRyeSkpOworI2RlZmluZSBGT1JfRUFDSF9PUFRJ T04odHlwZV8sIG5hbWVfLCBkZWZhdWx0VmFsdWVfLCBhdmFpbGFiaWxpdHlfLCBkZXNjcmlwdGlv bl8pIFwKKyAgICBpZiAoT3B0aW9uczo6QXZhaWxhYmlsaXR5OjphdmFpbGFiaWxpdHlfID09IE9w dGlvbnM6OkF2YWlsYWJpbGl0eTo6Tm9ybWFsIFwKKyAgICAgICAgfHwgT3B0aW9uczo6aXNBdmFp bGFibGUoT3B0aW9uczo6bmFtZV8jI0lELCBPcHRpb25zOjpBdmFpbGFiaWxpdHk6OmF2YWlsYWJp bGl0eV8pKSB7IFwKKyAgICAgICAgR1VuaXF1ZVB0cjxjaGFyPiBuYW1lKGdfc3RyZHVwX3ByaW50 ZigianNjLSVzIiwgI25hbWVfKSk7ICAgICAgIFwKKyAgICAgICAgZW50cmllcyA9IGdfYXJyYXlf c2V0X3NpemUoZW50cmllcywgZW50cmllcy0+bGVuICsgMSk7IFwKKyAgICAgICAgR09wdGlvbkVu dHJ5KiBlbnRyeSA9ICZnX2FycmF5X2luZGV4KGVudHJpZXMsIEdPcHRpb25FbnRyeSwgZW50cmll cy0+bGVuIC0gMSk7IFwKKyAgICAgICAgZW50cnktPmxvbmdfbmFtZSA9IG5hbWUuZ2V0KCk7ICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgZW50cnktPmFyZyA9IEdf T1BUSU9OX0FSR19DQUxMQkFDSzsgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAg ICAgZW50cnktPmFyZ19kYXRhID0gcmVpbnRlcnByZXRfY2FzdDxncG9pbnRlcj4oc2V0T3B0aW9u RW50cnkpOyAgIFwKKyAgICAgICAgZW50cnktPmRlc2NyaXB0aW9uID0gZGVzY3JpcHRpb25fOyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgbmFtZXMtPmFwcGVuZChXVEZN b3ZlKG5hbWUpKTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICB9CisK KyAgICBPcHRpb25zOjppbml0aWFsaXplKCk7CisgICAgSlNDX09QVElPTlMoRk9SX0VBQ0hfT1BU SU9OKQorI3VuZGVmIEZPUl9FQUNIX09QVElPTgorCisgICAgZ19vcHRpb25fZ3JvdXBfYWRkX2Vu dHJpZXMoZ3JvdXAsIHJlaW50ZXJwcmV0X2Nhc3Q8R09wdGlvbkVudHJ5Kj4oZW50cmllcy0+ZGF0 YSkpOworICAgIHJldHVybiBncm91cDsKK30KKworLyoqCisgKiBKU0NfT1BUSU9OU19VU0VfSklU OgorICoKKyAqIEFsbG93cyB0aGUgZXhlY3V0YWJsZSBwYWdlcyB0byBiZSBhbGxvY2F0ZWQgZm9y IEpJVCBhbmQgdGh1bmtzIGlmICVUUlVFLgorICogVHlwZTogJUpTQ19PUFRJT05fQk9PTEVBTgor ICogRGVmYXVsdDogJVRSVUUuCisgKgorICogU2luY2U6IDIuMjQKKyAqLworCisvKioKKyAqIEpT Q19PUFRJT05TX1VTRV9ERkc6CisgKgorICogQWxsb3dzIHRoZSBERkcgSklUIHRvIGJlIHVzZWQg aWYgJVRSVUUuCisgKiBUeXBlOiAlSlNDX09QVElPTl9CT09MRUFOCisgKiBEZWZhdWx0OiAlVFJV RS4KKyAqCisgKiBTaW5jZTogMi4yNAorICovCisKKy8qKgorICogSlNDX09QVElPTlNfVVNFX0ZU TDoKKyAqCisgKiBBbGxvd3MgdGhlIEZUTCBKSVQgdG8gYmUgdXNlZCBpZiAlVFJVRS4KKyAqIFR5 cGU6ICVKU0NfT1BUSU9OX0JPT0xFQU4KKyAqIERlZmF1bHQ6ICVUUlVFLgorICoKKyAqIFNpbmNl OiAyLjI0CisgKi8KKworLyoqCisgKiBKU0NfT1BUSU9OU19VU0VfTExJTlQ6CisgKgorICogQWxs b3dzIHRoZSBMTElOVCB0byBiZSB1c2VkIGlmICVUUlVFLgorICogVHlwZTogJUpTQ19PUFRJT05f Qk9PTEVBTgorICogRGVmYXVsdDogJVRSVUUuCisgKgorICogU2luY2U6IDIuMjQKKyAqLwpkaWZm IC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0FQSS9nbGliL0pTQ09wdGlvbnMuaCBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9KU0NPcHRpb25zLmgKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLmRlZTk3Yjg4ZDQ0Ci0tLSAvZGV2L251bGwKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL0FQSS9nbGliL0pTQ09wdGlvbnMuaApAQCAtMCwwICsxLDEx MCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxOSBJZ2FsaWEgUy5MLgorICoKKyAqIFRoaXMg bGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IK KyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwg UHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3Vu ZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIg b3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VU IEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBN RVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUg dGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFp bHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExp YnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7 IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxv b3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaWYgIWRlZmluZWQo X19KU0NfSF9JTlNJREVfXykgJiYgIWRlZmluZWQoSlNDX0NPTVBJTEFUSU9OKSAmJiAhZGVmaW5l ZChXRUJLSVQyX0NPTVBJTEFUSU9OKQorI2Vycm9yICJPbmx5IDxqc2MvanNjLmg+IGNhbiBiZSBp bmNsdWRlZCBkaXJlY3RseS4iCisjZW5kaWYKKworI2lmbmRlZiBKU0NPcHRpb25zX2gKKyNkZWZp bmUgSlNDT3B0aW9uc19oCisKKyNpbmNsdWRlIDxnbGliLW9iamVjdC5oPgorI2luY2x1ZGUgPGpz Yy9KU0NEZWZpbmVzLmg+CisKK0dfQkVHSU5fREVDTFMKKworI2RlZmluZSBKU0NfT1BUSU9OU19V U0VfSklUICAgInVzZUpJVCIKKyNkZWZpbmUgSlNDX09QVElPTlNfVVNFX0RGRyAgICJ1c2VERkdK SVQiCisjZGVmaW5lIEpTQ19PUFRJT05TX1VTRV9GVEwgICAidXNlRlRMSklUIgorI2RlZmluZSBK U0NfT1BUSU9OU19VU0VfTExJTlQgInVzZUxMSW50IgorCitKU0NfQVBJIGdib29sZWFuCitqc2Nf b3B0aW9uc19zZXRfYm9vbGVhbiAgICAgICAoY29uc3QgY2hhciAqb3B0aW9uLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGdib29sZWFuICAgIHZhbHVlKTsKK0pTQ19BUEkgZ2Jvb2xl YW4KK2pzY19vcHRpb25zX2dldF9ib29sZWFuICAgICAgIChjb25zdCBjaGFyICpvcHRpb24sCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2Jvb2xlYW4gICAqdmFsdWUpOworCitKU0Nf QVBJIGdib29sZWFuCitqc2Nfb3B0aW9uc19zZXRfaW50ICAgICAgICAgICAoY29uc3QgY2hhciAq b3B0aW9uLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdpbnQgICAgICAgIHZhbHVl KTsKK0pTQ19BUEkgZ2Jvb2xlYW4KK2pzY19vcHRpb25zX2dldF9pbnQgICAgICAgICAgIChjb25z dCBjaGFyICpvcHRpb24sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2ludCAgICAg ICAqdmFsdWUpOworCitKU0NfQVBJIGdib29sZWFuCitqc2Nfb3B0aW9uc19zZXRfdWludCAgICAg ICAgICAoY29uc3QgY2hhciAqb3B0aW9uLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGd1aW50ICAgICAgIHZhbHVlKTsKK0pTQ19BUEkgZ2Jvb2xlYW4KK2pzY19vcHRpb25zX2dldF91 aW50ICAgICAgICAgIChjb25zdCBjaGFyICpvcHRpb24sCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgZ3VpbnQgICAgICAqdmFsdWUpOworCitKU0NfQVBJIGdib29sZWFuCitqc2Nfb3B0 aW9uc19zZXRfc2l6ZSAgICAgICAgICAoY29uc3QgY2hhciAqb3B0aW9uLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGdzaXplICAgICAgIHZhbHVlKTsKK0pTQ19BUEkgZ2Jvb2xlYW4K K2pzY19vcHRpb25zX2dldF9zaXplICAgICAgICAgIChjb25zdCBjaGFyICpvcHRpb24sCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgZ3NpemUgICAgICAqdmFsdWUpOworCitKU0NfQVBJ IGdib29sZWFuCitqc2Nfb3B0aW9uc19zZXRfZG91YmxlICAgICAgICAoY29uc3QgY2hhciAqb3B0 aW9uLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdkb3VibGUgICAgIHZhbHVlKTsK K0pTQ19BUEkgZ2Jvb2xlYW4KK2pzY19vcHRpb25zX2dldF9kb3VibGUgICAgICAgIChjb25zdCBj aGFyICpvcHRpb24sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2RvdWJsZSAgICAq dmFsdWUpOworCitKU0NfQVBJIGdib29sZWFuCitqc2Nfb3B0aW9uc19zZXRfc3RyaW5nICAgICAg ICAoY29uc3QgY2hhciAqb3B0aW9uLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNv bnN0IGNoYXIgKnZhbHVlKTsKK0pTQ19BUEkgZ2Jvb2xlYW4KK2pzY19vcHRpb25zX2dldF9zdHJp bmcgICAgICAgIChjb25zdCBjaGFyICpvcHRpb24sCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgY2hhciAgICAgICAqKnZhbHVlKTsKKworSlNDX0FQSSBnYm9vbGVhbgoranNjX29wdGlv bnNfc2V0X3JhbmdlX3N0cmluZyAgKGNvbnN0IGNoYXIgKm9wdGlvbiwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICp2YWx1ZSk7CitKU0NfQVBJIGdib29sZWFuCitq c2Nfb3B0aW9uc19nZXRfcmFuZ2Vfc3RyaW5nICAoY29uc3QgY2hhciAqb3B0aW9uLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGNoYXIgICAgICAgKip2YWx1ZSk7CisKK3R5cGVkZWYg ZW51bSB7CisgICAgSlNDX09QVElPTl9CT09MRUFOLAorICAgIEpTQ19PUFRJT05fSU5ULAorICAg IEpTQ19PUFRJT05fVUlOVCwKKyAgICBKU0NfT1BUSU9OX1NJWkUsCisgICAgSlNDX09QVElPTl9E T1VCTEUsCisgICAgSlNDX09QVElPTl9TVFJJTkcsCisgICAgSlNDX09QVElPTl9SQU5HRV9TVFJJ TkcKK30gSlNDT3B0aW9uVHlwZTsKKwordHlwZWRlZiBnYm9vbGVhbiAoKiBKU0NPcHRpb25zRnVu YykgKGNvbnN0IGNoYXIgICAgKm9wdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBKU0NPcHRpb25UeXBlICB0eXBlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGNvbnN0IGNoYXIgICAgKmRlc2NyaXB0aW9uLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGdwb2ludGVyICAgICAgIHVzZXJfZGF0YSk7CisKK0pTQ19BUEkg dm9pZAoranNjX29wdGlvbnNfZm9yZWFjaCAgICAgICAgICAgICAgICAgKEpTQ09wdGlvbnNGdW5j IGZ1bmN0aW9uLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdwb2ludGVy ICAgICAgIHVzZXJfZGF0YSk7CisKK0pTQ19BUEkgR09wdGlvbkdyb3VwICoKK2pzY19vcHRpb25z X2dldF9vcHRpb25fZ3JvdXAgICAgICAgICh2b2lkKTsKKworR19FTkRfREVDTFMKKworI2VuZGlm IC8qIEpTQ09wdGlvbnNfaCAqLwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0FQ SS9nbGliL2RvY3MvanNjLWdsaWItNC4wLXNlY3Rpb25zLnR4dCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9BUEkvZ2xpYi9kb2NzL2pzYy1nbGliLTQuMC1zZWN0aW9ucy50eHQKaW5kZXggYWRkNjgy YTQ4MWEuLjNhZTIyMjVlMWI2IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQVBJ L2dsaWIvZG9jcy9qc2MtZ2xpYi00LjAtc2VjdGlvbnMudHh0CisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9BUEkvZ2xpYi9kb2NzL2pzYy1nbGliLTQuMC1zZWN0aW9ucy50eHQKQEAgLTIxMSw2 ICsyMTEsMzYgQEAgSlNDX0lTX0NMQVNTCiBqc2NfY2xhc3NfZ2V0X3R5cGUKIDwvU0VDVElPTj4K IAorPFNFQ1RJT04+Cis8RklMRT5KU0NPcHRpb25zPC9GSUxFPgorPFRJVExFPkpTQ09wdGlvbnM8 L1RJVExFPgoranNjX29wdGlvbnNfc2V0X2Jvb2xlYW4KK2pzY19vcHRpb25zX2dldF9ib29sZWFu Citqc2Nfb3B0aW9uc19zZXRfaW50Citqc2Nfb3B0aW9uc19nZXRfaW50Citqc2Nfb3B0aW9uc19z ZXRfdWludAoranNjX29wdGlvbnNfZ2V0X3VpbnQKK2pzY19vcHRpb25zX3NldF9zaXplCitqc2Nf b3B0aW9uc19nZXRfc2l6ZQoranNjX29wdGlvbnNfc2V0X2RvdWJsZQoranNjX29wdGlvbnNfZ2V0 X2RvdWJsZQoranNjX29wdGlvbnNfc2V0X3N0cmluZworanNjX29wdGlvbnNfZ2V0X3N0cmluZwor anNjX29wdGlvbnNfc2V0X3JhbmdlX3N0cmluZworanNjX29wdGlvbnNfZ2V0X3JhbmdlX3N0cmlu ZworCitKU0NPcHRpb25UeXBlCitKU0NPcHRpb25zRnVuYworanNjX29wdGlvbnNfZm9yZWFjaAor Citqc2Nfb3B0aW9uc19nZXRfb3B0aW9uX2dyb3VwCis8U1VCU0VDVElPTj4KK0pTQ19PUFRJT05T X1VTRV9KSVQKK0pTQ19PUFRJT05TX1VTRV9ERkcKK0pTQ19PUFRJT05TX1VTRV9GVEwKK0pTQ19P UFRJT05TX1VTRV9MTElOVAorPC9TRUNUSU9OPgorCiA8U0VDVElPTj4KIDxGSUxFPkpTQ1ZlcnNp b248L0ZJTEU+CiA8VElUTEU+SlNDVmVyc2lvbjwvVElUTEU+CmRpZmYgLS1naXQgYS9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvQVBJL2dsaWIvZG9jcy9qc2MtZ2xpYi1kb2NzLnNnbWwgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvQVBJL2dsaWIvZG9jcy9qc2MtZ2xpYi1kb2NzLnNnbWwKaW5kZXggNDg1 M2ExMDRjNmQuLjFjMmRiNWM3Yjk1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv QVBJL2dsaWIvZG9jcy9qc2MtZ2xpYi1kb2NzLnNnbWwKKysrIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL0FQSS9nbGliL2RvY3MvanNjLWdsaWItZG9jcy5zZ21sCkBAIC0xNyw2ICsxNyw3IEBACiAg ICAgPHhpOmluY2x1ZGUgaHJlZj0ieG1sL0pTQ1dlYWtWYWx1ZS54bWwiLz4KICAgICA8eGk6aW5j bHVkZSBocmVmPSJ4bWwvSlNDRXhjZXB0aW9uLnhtbCIvPgogICAgIDx4aTppbmNsdWRlIGhyZWY9 InhtbC9KU0NDbGFzcy54bWwiLz4KKyAgICA8eGk6aW5jbHVkZSBocmVmPSJ4bWwvSlNDT3B0aW9u cy54bWwiLz4KICAgICA8eGk6aW5jbHVkZSBocmVmPSJ4bWwvSlNDVmVyc2lvbi54bWwiLz4KICAg PC9jaGFwdGVyPgogCkBAIC0yNCw1ICsyNSwxMCBAQAogICAgIDx0aXRsZT5JbmRleDwvdGl0bGU+ CiAgIDwvaW5kZXg+CiAKKyAgPGluZGV4IGlkPSJhcGktaW5kZXgtMi0yNCIgcm9sZT0iMi4yNCI+ CisgICAgPHRpdGxlPkluZGV4IG9mIG5ldyBzeW1ib2xzIGluIDIuMjQ8L3RpdGxlPgorICAgIDx4 aTppbmNsdWRlIGhyZWY9InhtbC9hcGktaW5kZXgtMi4yNC54bWwiPjx4aTpmYWxsYmFjayAvPjwv eGk6aW5jbHVkZT4KKyAgPC9pbmRleD4KKwogICA8eGk6aW5jbHVkZSBocmVmPSJ4bWwvYW5ub3Rh dGlvbi1nbG9zc2FyeS54bWwiPjx4aTpmYWxsYmFjayAvPjwveGk6aW5jbHVkZT4KIDwvYm9vaz4K ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9qc2MuaCBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9qc2MuaAppbmRleCA4YTI4NDUyNDBhOC4uMTE1Mzdm OWQ0YTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9BUEkvZ2xpYi9qc2MuaAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQVBJL2dsaWIvanNjLmgKQEAgLTI2LDYgKzI2LDcg QEAKICNpbmNsdWRlIDxqc2MvSlNDQ29udGV4dC5oPgogI2luY2x1ZGUgPGpzYy9KU0NEZWZpbmVz Lmg+CiAjaW5jbHVkZSA8anNjL0pTQ0V4Y2VwdGlvbi5oPgorI2luY2x1ZGUgPGpzYy9KU0NPcHRp b25zLmg+CiAjaW5jbHVkZSA8anNjL0pTQ1ZhbHVlLmg+CiAjaW5jbHVkZSA8anNjL0pTQ1ZlcnNp b24uaD4KICNpbmNsdWRlIDxqc2MvSlNDVmlydHVhbE1hY2hpbmUuaD4KZGlmZiAtLWdpdCBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ2hh bmdlTG9nCmluZGV4IDgzNjJjY2IwNGRmLi5kNGMwMzU0NzdlOCAxMDA2NDQKLS0tIGEvU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsNDEgQEAKKzIwMTktMDEtMTUgIENhcmxvcyBHYXJjaWEgQ2FtcG9z ICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgorCisgICAgICAgIFtHTElCXSBFeHBvc2UgSmF2YVNjcmlw dENvcmUgb3B0aW9ucyBpbiBHTGliIHB1YmxpYyBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE4ODc0MgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBuZXcgQVBJIHRvIHNldCwgZ2V0IGFuZCBpdGVy YXRlIEpTQyBvcHRpb25zLgorCisgICAgICAgICogQVBJL2dsaWIvSlNDT3B0aW9ucy5jcHA6IEFk ZGVkLgorICAgICAgICAodmFsdWVGcm9tR1ZhbHVlKToKKyAgICAgICAgKHZhbHVlVG9HVmFsdWUp OgorICAgICAgICAoanNjT3B0aW9uc1NldFZhbHVlKToKKyAgICAgICAgKGpzY09wdGlvbnNHZXRW YWx1ZSk6CisgICAgICAgIChqc2Nfb3B0aW9uc19zZXRfYm9vbGVhbik6CisgICAgICAgIChqc2Nf b3B0aW9uc19nZXRfYm9vbGVhbik6CisgICAgICAgIChqc2Nfb3B0aW9uc19zZXRfaW50KToKKyAg ICAgICAgKGpzY19vcHRpb25zX2dldF9pbnQpOgorICAgICAgICAoanNjX29wdGlvbnNfc2V0X3Vp bnQpOgorICAgICAgICAoanNjX29wdGlvbnNfZ2V0X3VpbnQpOgorICAgICAgICAoanNjX29wdGlv bnNfc2V0X3NpemUpOgorICAgICAgICAoanNjX29wdGlvbnNfZ2V0X3NpemUpOgorICAgICAgICAo anNjX29wdGlvbnNfc2V0X2RvdWJsZSk6CisgICAgICAgIChqc2Nfb3B0aW9uc19nZXRfZG91Ymxl KToKKyAgICAgICAgKGpzY19vcHRpb25zX3NldF9zdHJpbmcpOgorICAgICAgICAoanNjX29wdGlv bnNfZ2V0X3N0cmluZyk6CisgICAgICAgIChqc2Nfb3B0aW9uc19zZXRfcmFuZ2Vfc3RyaW5nKToK KyAgICAgICAgKGpzY19vcHRpb25zX2dldF9yYW5nZV9zdHJpbmcpOgorICAgICAgICAoanNjT3B0 aW9uc1R5cGUpOgorICAgICAgICAoanNjX29wdGlvbnNfZm9yZWFjaCk6CisgICAgICAgIChzZXRP cHRpb25FbnRyeSk6CisgICAgICAgIChqc2Nfb3B0aW9uc19nZXRfb3B0aW9uX2dyb3VwKToKKyAg ICAgICAgKiBBUEkvZ2xpYi9KU0NPcHRpb25zLmg6IEFkZGVkLgorICAgICAgICAqIEFQSS9nbGli L2RvY3MvanNjLWdsaWItNC4wLXNlY3Rpb25zLnR4dDoKKyAgICAgICAgKiBBUEkvZ2xpYi9kb2Nz L2pzYy1nbGliLWRvY3Muc2dtbDoKKyAgICAgICAgKiBBUEkvZ2xpYi9qc2MuaDoKKyAgICAgICAg KiBHTGliLmNtYWtlOgorCiAyMDE5LTAxLTE0ICBNaWNoYWVsIFNhYm9mZiAgPG1zYWJvZmZAYXBw bGUuY29tPgogCiAgICAgICAgIEFkZCBvcHRpb24gdG8gSlNDIHRvIGR1bXAgbWVtb3J5IGZvb3Rw cmludCBvbiBzY3JpcHQgY29tcGxldGlvbgpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRD b3JlL0dMaWIuY21ha2UgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvR0xpYi5jbWFrZQppbmRleCBk Yzg1ZjRlN2M1OS4uNGQxZmZlNWQ3OWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9HTGliLmNtYWtlCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9HTGliLmNtYWtlCkBAIC04 LDYgKzgsNyBAQCBsaXN0KEFQUEVORCBKYXZhU2NyaXB0Q29yZV9TT1VSQ0VTCiAgICAgQVBJL2ds aWIvSlNDQ2xhc3MuY3BwCiAgICAgQVBJL2dsaWIvSlNDQ29udGV4dC5jcHAKICAgICBBUEkvZ2xp Yi9KU0NFeGNlcHRpb24uY3BwCisgICAgQVBJL2dsaWIvSlNDT3B0aW9ucy5jcHAKICAgICBBUEkv Z2xpYi9KU0NWYWx1ZS5jcHAKICAgICBBUEkvZ2xpYi9KU0NWZXJzaW9uLmNwcAogICAgIEFQSS9n bGliL0pTQ1ZpcnR1YWxNYWNoaW5lLmNwcApAQCAtMjgsNiArMjksNyBAQCBzZXQoSmF2YVNjcmlw dENvcmVfSU5TVEFMTEVEX0hFQURFUlMKICAgICAke0pBVkFTQ1JJUFRDT1JFX0RJUn0vQVBJL2ds aWIvSlNDQ29udGV4dC5oCiAgICAgJHtKQVZBU0NSSVBUQ09SRV9ESVJ9L0FQSS9nbGliL0pTQ0Rl ZmluZXMuaAogICAgICR7SkFWQVNDUklQVENPUkVfRElSfS9BUEkvZ2xpYi9KU0NFeGNlcHRpb24u aAorICAgICR7SkFWQVNDUklQVENPUkVfRElSfS9BUEkvZ2xpYi9KU0NPcHRpb25zLmgKICAgICAk e0pBVkFTQ1JJUFRDT1JFX0RJUn0vQVBJL2dsaWIvSlNDVmFsdWUuaAogICAgICR7SkFWQVNDUklQ VENPUkVfRElSfS9BUEkvZ2xpYi9KU0NWaXJ0dWFsTWFjaGluZS5oCiAgICAgJHtKQVZBU0NSSVBU Q09SRV9ESVJ9L0FQSS9nbGliL0pTQ1dlYWtWYWx1ZS5oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvcG8vQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3RrL3BvL0NoYW5nZUxvZwppbmRleCA0OGIwOTJhNTg3Mi4uMDA3ZTUwMTE1ZmIgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9wby9DaGFuZ2VMb2cKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3RrL3BvL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEyIEBACisyMDE5 LTAxLTE1ICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KKworICAg ICAgICBbR0xJQl0gRXhwb3NlIEphdmFTY3JpcHRDb3JlIG9wdGlvbnMgaW4gR0xpYiBwdWJsaWMg QVBJCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xODg3 NDIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFBP VEZJTEVTLmluOiBBZGQgSlNDT3B0aW9ucy5jcHAKKwogMjAxOS0wMS0wOCAgSm9zZWYgQW5kZXJz c29uICA8am9zZWYuYW5kZXJzc29uQGZyaXBvc3Qub3JnPgogCiAgICAgICAgIFtHVEtdIFVwZGF0 ZWQgU3dlZGlzaCB0cmFuc2xhdGlvbgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL3BvL1BPVEZJTEVTLmluIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL3BvL1BP VEZJTEVTLmluCmluZGV4IGI0ZmIwMDFhMGM0Li4zZWMwOWRiYWU0MSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL3BvL1BPVEZJTEVTLmluCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2d0ay9wby9QT1RGSUxFUy5pbgpAQCAtMiw2ICsyLDcgQEAKIExvY2FsaXpl ZFN0cmluZ3NHdGsuY3BwCiAuLi9Mb2NhbGl6ZWRTdHJpbmdzLmNwcAogLi4vbmV0d29yay9zb3Vw L05ldHdvcmtTdG9yYWdlU2Vzc2lvblNvdXAuY3BwCisuLi8uLi8uLi9KYXZhU2NyaXB0Q29yZS9B UEkvZ2xpYi9KU0NPcHRpb25zLmNwcAogLi4vLi4vLi4vV2ViS2l0L1NoYXJlZC9BUEkvZ2xpYi9X ZWJLaXRIaXRUZXN0UmVzdWx0LmNwcAogLi4vLi4vLi4vV2ViS2l0L1NoYXJlZC9BUEkvZ2xpYi9X ZWJLaXRVUklSZXF1ZXN0LmNwcAogLi4vLi4vLi4vV2ViS2l0L1NoYXJlZC9BUEkvZ2xpYi9XZWJL aXRVUklSZXNwb25zZS5jcHAKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0No YW5nZUxvZwppbmRleCBhNTAyNGRmY2U1NS4uYmI5ZGY0MThkNmIgMTAwNjQ0Ci0tLSBhL1Rvb2xz L0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxOS0w MS0xNSAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CisKKyAgICAg ICAgW0dMSUJdIEV4cG9zZSBKYXZhU2NyaXB0Q29yZSBvcHRpb25zIGluIEdMaWIgcHVibGljIEFQ SQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTg4NzQy CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGEg dGVzdCBmb3IgdGhlIG5ldyBBUEkuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL0ph dmFTY3JpcHRDb3JlL2dsaWIvVGVzdEpTQy5jcHA6CisgICAgICAgICh0ZXN0c0pTQ09wdGlvbnMp OgorICAgICAgICAobWFpbik6CisKIDIwMTktMDEtMTUgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8 Y2dhcmNpYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdW1dQRV0gQWRkIGVuYWJsZS1qYXZh c2NyaXB0LW1hcmt1cCBzZXR0aW5nCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RzL0phdmFTY3JpcHRDb3JlL2dsaWIvVGVzdEpTQy5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJ L1Rlc3RzL0phdmFTY3JpcHRDb3JlL2dsaWIvVGVzdEpTQy5jcHAKaW5kZXggN2UzNzJjMzMyNDAu LmIyMmY3ZTUzMDI5IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL0phdmFT Y3JpcHRDb3JlL2dsaWIvVGVzdEpTQy5jcHAKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0 cy9KYXZhU2NyaXB0Q29yZS9nbGliL1Rlc3RKU0MuY3BwCkBAIC0zMjI3LDYgKzMyMjcsMjExIEBA IHN0YXRpYyB2b2lkIHRlc3RzSlNDVmlydHVhbE1hY2hpbmUoKQogICAgIH0KIH0KIAorc3RhdGlj IHZvaWQgdGVzdHNKU0NPcHRpb25zKCkKK3sKKyAgICBnYm9vbGVhbiB1c2VKSVQ7CisgICAgZ19h c3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfYm9vbGVhbihKU0NfT1BUSU9OU19VU0VfSklULCAm dXNlSklUKSk7CisgICAgZ19hc3NlcnRfdHJ1ZSh1c2VKSVQpOworICAgIGdfYXNzZXJ0X3RydWUo anNjX29wdGlvbnNfc2V0X2Jvb2xlYW4oSlNDX09QVElPTlNfVVNFX0pJVCwgRkFMU0UpKTsKKyAg ICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9ib29sZWFuKEpTQ19PUFRJT05TX1VTRV9K SVQsICZ1c2VKSVQpKTsKKyAgICBnX2Fzc2VydF9mYWxzZSh1c2VKSVQpOworICAgIGdfYXNzZXJ0 X3RydWUoanNjX29wdGlvbnNfc2V0X2Jvb2xlYW4oSlNDX09QVElPTlNfVVNFX0pJVCwgVFJVRSkp OworCisgICAgZ2ludCB0aHJlc2hvbGRGb3JKSVRBZnRlcldhcm1VcDsKKyAgICBnX2Fzc2VydF90 cnVlKGpzY19vcHRpb25zX2dldF9pbnQoInRocmVzaG9sZEZvckpJVEFmdGVyV2FybVVwIiwgJnRo cmVzaG9sZEZvckpJVEFmdGVyV2FybVVwKSk7CisgICAgZ19hc3NlcnRfY21waW50KHRocmVzaG9s ZEZvckpJVEFmdGVyV2FybVVwLCA9PSwgNTAwKTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRp b25zX3NldF9pbnQoInRocmVzaG9sZEZvckpJVEFmdGVyV2FybVVwIiwgMTAwMCkpOworICAgIGdf YXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X2ludCgidGhyZXNob2xkRm9ySklUQWZ0ZXJXYXJt VXAiLCAmdGhyZXNob2xkRm9ySklUQWZ0ZXJXYXJtVXApKTsKKyAgICBnX2Fzc2VydF9jbXBpbnQo dGhyZXNob2xkRm9ySklUQWZ0ZXJXYXJtVXAsID09LCAxMDAwKTsKKyAgICBnX2Fzc2VydF90cnVl KGpzY19vcHRpb25zX3NldF9pbnQoInRocmVzaG9sZEZvckpJVEFmdGVyV2FybVVwIiwgNTAwKSk7 CisKKyAgICBndWludCBtYXhQZXJUaHJlYWRTdGFja1VzYWdlOworICAgIGdfYXNzZXJ0X3RydWUo anNjX29wdGlvbnNfZ2V0X3VpbnQoIm1heFBlclRocmVhZFN0YWNrVXNhZ2UiLCAmbWF4UGVyVGhy ZWFkU3RhY2tVc2FnZSkpOworICAgIGdfYXNzZXJ0X2NtcHVpbnQobWF4UGVyVGhyZWFkU3RhY2tV c2FnZSwgPT0sIDQxOTQzMDQpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfc2V0X3Vp bnQoIm1heFBlclRocmVhZFN0YWNrVXNhZ2UiLCA0MDk2KSk7CisgICAgZ19hc3NlcnRfdHJ1ZShq c2Nfb3B0aW9uc19nZXRfdWludCgibWF4UGVyVGhyZWFkU3RhY2tVc2FnZSIsICZtYXhQZXJUaHJl YWRTdGFja1VzYWdlKSk7CisgICAgZ19hc3NlcnRfY21wdWludChtYXhQZXJUaHJlYWRTdGFja1Vz YWdlLCA9PSwgNDA5Nik7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRfdWludCgi bWF4UGVyVGhyZWFkU3RhY2tVc2FnZSIsIDQxOTQzMDQpKTsKKworICAgIGdzaXplIHdlYkFzc2Vt Ymx5UGFydGlhbENvbXBpbGVMaW1pdDsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dl dF9zaXplKCJ3ZWJBc3NlbWJseVBhcnRpYWxDb21waWxlTGltaXQiLCAmd2ViQXNzZW1ibHlQYXJ0 aWFsQ29tcGlsZUxpbWl0KSk7CisgICAgZ19hc3NlcnRfY21wdWludCh3ZWJBc3NlbWJseVBhcnRp YWxDb21waWxlTGltaXQsID09LCA1MDAwKTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25z X3NldF9zaXplKCJ3ZWJBc3NlbWJseVBhcnRpYWxDb21waWxlTGltaXQiLCA2MDAwKSk7CisgICAg Z19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfc2l6ZSgid2ViQXNzZW1ibHlQYXJ0aWFsQ29t cGlsZUxpbWl0IiwgJndlYkFzc2VtYmx5UGFydGlhbENvbXBpbGVMaW1pdCkpOworICAgIGdfYXNz ZXJ0X2NtcHVpbnQod2ViQXNzZW1ibHlQYXJ0aWFsQ29tcGlsZUxpbWl0LCA9PSwgNjAwMCk7Cisg ICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRfc2l6ZSgid2ViQXNzZW1ibHlQYXJ0aWFs Q29tcGlsZUxpbWl0IiwgNTAwMCkpOworCisgICAgZ2RvdWJsZSBzbWFsbEhlYXBSQU1GcmFjdGlv bjsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9kb3VibGUoInNtYWxsSGVhcFJB TUZyYWN0aW9uIiwgJnNtYWxsSGVhcFJBTUZyYWN0aW9uKSk7CisgICAgZ19hc3NlcnRfY21wZmxv YXQoc21hbGxIZWFwUkFNRnJhY3Rpb24sID09LCAwLjI1KTsKKyAgICBnX2Fzc2VydF90cnVlKGpz Y19vcHRpb25zX3NldF9kb3VibGUoInNtYWxsSGVhcFJBTUZyYWN0aW9uIiwgMC41MCkpOworICAg IGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X2RvdWJsZSgic21hbGxIZWFwUkFNRnJhY3Rp b24iLCAmc21hbGxIZWFwUkFNRnJhY3Rpb24pKTsKKyAgICBnX2Fzc2VydF9jbXBmbG9hdChzbWFs bEhlYXBSQU1GcmFjdGlvbiwgPT0sIDAuNTApOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlv bnNfc2V0X2RvdWJsZSgic21hbGxIZWFwUkFNRnJhY3Rpb24iLCAwLjI1KSk7CisKKyAgICBHVW5p cXVlT3V0UHRyPGNoYXI+IGNvbmZpZ0ZpbGU7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9u c19nZXRfc3RyaW5nKCJjb25maWdGaWxlIiwgJmNvbmZpZ0ZpbGUub3V0UHRyKCkpKTsKKyAgICBn X2Fzc2VydF9udWxsKGNvbmZpZ0ZpbGUuZ2V0KCkpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29w dGlvbnNfc2V0X3N0cmluZygiY29uZmlnRmlsZSIsICIvdG1wL2ZvbyIpKTsKKyAgICBnX2Fzc2Vy dF90cnVlKGpzY19vcHRpb25zX2dldF9zdHJpbmcoImNvbmZpZ0ZpbGUiLCAmY29uZmlnRmlsZS5v dXRQdHIoKSkpOworICAgIGdfYXNzZXJ0X2NtcHN0cihjb25maWdGaWxlLmdldCgpLCA9PSwgIi90 bXAvZm9vIik7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRfc3RyaW5nKCJjb25m aWdGaWxlIiwgbnVsbHB0cikpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X3N0 cmluZygiY29uZmlnRmlsZSIsICZjb25maWdGaWxlLm91dFB0cigpKSk7CisgICAgZ19hc3NlcnRf bnVsbChjb25maWdGaWxlLmdldCgpKTsKKworICAgIEdVbmlxdWVPdXRQdHI8Y2hhcj4gYnl0ZWNv ZGVSYW5nZVRvSklUQ29tcGlsZTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9y YW5nZV9zdHJpbmcoImJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUiLCAmYnl0ZWNvZGVSYW5nZVRv SklUQ29tcGlsZS5vdXRQdHIoKSkpOworICAgIGdfYXNzZXJ0X251bGwoYnl0ZWNvZGVSYW5nZVRv SklUQ29tcGlsZS5nZXQoKSk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRfcmFu Z2Vfc3RyaW5nKCJieXRlY29kZVJhbmdlVG9KSVRDb21waWxlIiwgIjEwMCIpKTsKKyAgICBnX2Fz c2VydF90cnVlKGpzY19vcHRpb25zX2dldF9yYW5nZV9zdHJpbmcoImJ5dGVjb2RlUmFuZ2VUb0pJ VENvbXBpbGUiLCAmYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZS5vdXRQdHIoKSkpOworICAgIGdf YXNzZXJ0X2NtcHN0cihieXRlY29kZVJhbmdlVG9KSVRDb21waWxlLmdldCgpLCA9PSwgIjEwMCIp OworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfc2V0X3JhbmdlX3N0cmluZygiYnl0ZWNv ZGVSYW5nZVRvSklUQ29tcGlsZSIsICIxMDA6MjAwIikpOworICAgIGdfYXNzZXJ0X3RydWUoanNj X29wdGlvbnNfZ2V0X3JhbmdlX3N0cmluZygiYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZSIsICZi eXRlY29kZVJhbmdlVG9KSVRDb21waWxlLm91dFB0cigpKSk7CisgICAgZ19hc3NlcnRfY21wc3Ry KGJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUuZ2V0KCksID09LCAiMTAwOjIwMCIpOworICAgIGdf YXNzZXJ0X3RydWUoanNjX29wdGlvbnNfc2V0X3JhbmdlX3N0cmluZygiYnl0ZWNvZGVSYW5nZVRv SklUQ29tcGlsZSIsICIhMTAwOjIwMCIpKTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25z X2dldF9yYW5nZV9zdHJpbmcoImJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUiLCAmYnl0ZWNvZGVS YW5nZVRvSklUQ29tcGlsZS5vdXRQdHIoKSkpOworICAgIGdfYXNzZXJ0X2NtcHN0cihieXRlY29k ZVJhbmdlVG9KSVRDb21waWxlLmdldCgpLCA9PSwgIiExMDA6MjAwIik7CisgICAgZ19hc3NlcnRf ZmFsc2UoanNjX29wdGlvbnNfc2V0X3JhbmdlX3N0cmluZygiYnl0ZWNvZGVSYW5nZVRvSklUQ29t cGlsZSIsICIyMDA6MTAwIikpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X3Jh bmdlX3N0cmluZygiYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZSIsICZieXRlY29kZVJhbmdlVG9K SVRDb21waWxlLm91dFB0cigpKSk7CisgICAgZ19hc3NlcnRfY21wc3RyKGJ5dGVjb2RlUmFuZ2VU b0pJVENvbXBpbGUuZ2V0KCksID09LCAiITEwMDoyMDAiKTsKKyAgICBnX2Fzc2VydF90cnVlKGpz Y19vcHRpb25zX3NldF9yYW5nZV9zdHJpbmcoImJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUiLCBu dWxscHRyKSk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfcmFuZ2Vfc3RyaW5n KCJieXRlY29kZVJhbmdlVG9KSVRDb21waWxlIiwgJmJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUu b3V0UHRyKCkpKTsKKyAgICBnX2Fzc2VydF9udWxsKGJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUu Z2V0KCkpOworCisgICAgZ3VpbnQgbG9nR0M7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9u c19nZXRfdWludCgibG9nR0MiLCAmbG9nR0MpKTsKKyAgICBnX2Fzc2VydF9jbXB1aW50KGxvZ0dD LCA9PSwgMCk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRfdWludCgibG9nR0Mi LCAxKSk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfdWludCgibG9nR0MiLCAm bG9nR0MpKTsKKyAgICBnX2Fzc2VydF9jbXB1aW50KGxvZ0dDLCA9PSwgMSk7CisgICAgZ19hc3Nl cnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRfdWludCgibG9nR0MiLCAyKSk7CisgICAgZ19hc3NlcnRf dHJ1ZShqc2Nfb3B0aW9uc19nZXRfdWludCgibG9nR0MiLCAmbG9nR0MpKTsKKyAgICBnX2Fzc2Vy dF9jbXB1aW50KGxvZ0dDLCA9PSwgMik7CisgICAgZ19hc3NlcnRfZmFsc2UoanNjX29wdGlvbnNf c2V0X3VpbnQoImxvZ0dDIiwgMykpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0 X3VpbnQoImxvZ0dDIiwgJmxvZ0dDKSk7CisgICAgZ19hc3NlcnRfY21wdWludChsb2dHQywgPT0s IDIpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfc2V0X3VpbnQoImxvZ0dDIiwgMCkp OworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X3VpbnQoImxvZ0dDIiwgJmxvZ0dD KSk7CisgICAgZ19hc3NlcnRfY21wdWludChsb2dHQywgPT0sIDApOworCisgICAgZ2Jvb2xlYW4g dmFsdWUgPSBUUlVFOworICAgIGdfYXNzZXJ0X2ZhbHNlKGpzY19vcHRpb25zX2dldF9ib29sZWFu KCJJbnZhbGlkT3B0aW9uIiwgJnZhbHVlKSk7CisgICAgZ19hc3NlcnRfdHJ1ZSh2YWx1ZSk7Cisg ICAgZ19hc3NlcnRfZmFsc2UoanNjX29wdGlvbnNfc2V0X2Jvb2xlYW4oIkludmFsaWRPcHRpb24i LCBUUlVFKSk7CisgICAgZ19hc3NlcnRfZmFsc2UoanNjX29wdGlvbnNfZ2V0X2Jvb2xlYW4oIklu dmFsaWRPcHRpb24iLCAmdmFsdWUpKTsKKyAgICBnX2Fzc2VydF90cnVlKHZhbHVlKTsKKworICAg IC8vIEZpbmQgYSBwYXJ0aWN1bGFyIG9wdGlvbi4KKyAgICBib29sIGZvdW5kID0gZmFsc2U7Cisg ICAganNjX29wdGlvbnNfZm9yZWFjaChbXShjb25zdCBjaGFyKiBvcHRpb24sIEpTQ09wdGlvblR5 cGUgdHlwZSwgY29uc3QgY2hhciogZGVzY3JpcHRpb24sIGdwb2ludGVyIHVzZXJEYXRhKSAtPiBn Ym9vbGVhbiB7CisgICAgICAgIGlmICghZ19zdHJjbXAwKG9wdGlvbiwgInVzZUpJVCIpKSB7Cisg ICAgICAgICAgICAqc3RhdGljX2Nhc3Q8Ym9vbCo+KHVzZXJEYXRhKSA9IHRydWU7CisgICAgICAg ICAgICByZXR1cm4gVFJVRTsKKyAgICAgICAgfQorICAgICAgICByZXR1cm4gRkFMU0U7CisgICAg fSwgJmZvdW5kKTsKKyAgICBnX2Fzc2VydF90cnVlKGZvdW5kKTsKKworICAgIHVuc2lnbmVkIG9w dGlvbnNDb3VudCA9IDA7CisgICAganNjX29wdGlvbnNfZm9yZWFjaChbXShjb25zdCBjaGFyKiBv cHRpb24sIEpTQ09wdGlvblR5cGUgdHlwZSwgY29uc3QgY2hhciogZGVzY3JpcHRpb24sIGdwb2lu dGVyIHVzZXJEYXRhKSAtPiBnYm9vbGVhbiB7CisgICAgICAgICgqc3RhdGljX2Nhc3Q8dW5zaWdu ZWQqPih1c2VyRGF0YSkpKys7CisgICAgICAgIHJldHVybiBGQUxTRTsKKyAgICB9LCAmb3B0aW9u c0NvdW50KTsKKyAgICBnX2Fzc2VydF9jbXB1aW50KG9wdGlvbnNDb3VudCwgPiwgMTAwKTsKKyAg ICBnX2Fzc2VydF9jbXB1aW50KG9wdGlvbnNDb3VudCwgPCwgNTAwKTsKKworICAgIG9wdGlvbnND b3VudCA9IDA7CisgICAganNjX29wdGlvbnNfZm9yZWFjaChbXShjb25zdCBjaGFyKiBvcHRpb24s IEpTQ09wdGlvblR5cGUgdHlwZSwgY29uc3QgY2hhciogZGVzY3JpcHRpb24sIGdwb2ludGVyIHVz ZXJEYXRhKSAtPiBnYm9vbGVhbiB7CisgICAgICAgIGlmICghZ19zdHJjbXAwKG9wdGlvbiwgInVz ZUpJVCIpKQorICAgICAgICAgICAgZ19hc3NlcnRfdHJ1ZSh0eXBlID09IEpTQ19PUFRJT05fQk9P TEVBTik7CisgICAgICAgIGVsc2UgaWYgKCFnX3N0cmNtcDAob3B0aW9uLCAidGhyZXNob2xkRm9y SklUQWZ0ZXJXYXJtVXAiKSkKKyAgICAgICAgICAgIGdfYXNzZXJ0X3RydWUodHlwZSA9PSBKU0Nf T1BUSU9OX0lOVCk7CisgICAgICAgIGVsc2UgaWYgKCFnX3N0cmNtcDAob3B0aW9uLCAibWF4UGVy VGhyZWFkU3RhY2tVc2FnZSIpKQorICAgICAgICAgICAgZ19hc3NlcnRfdHJ1ZSh0eXBlID09IEpT Q19PUFRJT05fVUlOVCk7CisgICAgICAgIGVsc2UgaWYgKCFnX3N0cmNtcDAob3B0aW9uLCAid2Vi QXNzZW1ibHlQYXJ0aWFsQ29tcGlsZUxpbWl0IikpCisgICAgICAgICAgICBnX2Fzc2VydF90cnVl KHR5cGUgPT0gSlNDX09QVElPTl9TSVpFKTsKKyAgICAgICAgZWxzZSBpZiAoIWdfc3RyY21wMChv cHRpb24sICJzbWFsbEhlYXBSQU1GcmFjdGlvbiIpKQorICAgICAgICAgICAgZ19hc3NlcnRfdHJ1 ZSh0eXBlID09IEpTQ19PUFRJT05fRE9VQkxFKTsKKyAgICAgICAgZWxzZSBpZiAoIWdfc3RyY21w MChvcHRpb24sICJjb25maWdGaWxlIikpCisgICAgICAgICAgICBnX2Fzc2VydF90cnVlKHR5cGUg PT0gSlNDX09QVElPTl9TVFJJTkcpOworICAgICAgICBlbHNlIGlmICghZ19zdHJjbXAwKG9wdGlv biwgImJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUiKSkKKyAgICAgICAgICAgIGdfYXNzZXJ0X3Ry dWUodHlwZSA9PSBKU0NfT1BUSU9OX1JBTkdFX1NUUklORyk7CisgICAgICAgIGVsc2UKKyAgICAg ICAgICAgIHJldHVybiBGQUxTRTsKKworICAgICAgICAoKnN0YXRpY19jYXN0PHVuc2lnbmVkKj4o dXNlckRhdGEpKSsrOworICAgICAgICByZXR1cm4gRkFMU0U7CisgICAgfSwgJm9wdGlvbnNDb3Vu dCk7CisgICAgZ19hc3NlcnRfY21wdWludChvcHRpb25zQ291bnQsID09LCA3KTsKKworICAgIEdP cHRpb25Db250ZXh0KiBjb250ZXh0ID0gZ19vcHRpb25fY29udGV4dF9uZXcobnVsbHB0cik7Cisg ICAgZ19vcHRpb25fY29udGV4dF9hZGRfZ3JvdXAoY29udGV4dCwganNjX29wdGlvbnNfZ2V0X29w dGlvbl9ncm91cCgpKTsKKyAgICBzdGF0aWMgY29uc3QgY2hhciogYXJndltdID0geworICAgICAg ICBfX0ZJTEVfXywKKyAgICAgICAgIi0tanNjLXVzZUpJVD1mYWxzZSIsCisgICAgICAgICItLWpz Yy10aHJlc2hvbGRGb3JKSVRBZnRlcldhcm1VcD0yMDAwIiwKKyAgICAgICAgIi0tanNjLW1heFBl clRocmVhZFN0YWNrVXNhZ2U9MTAyNCIsCisgICAgICAgICItLWpzYy13ZWJBc3NlbWJseVBhcnRp YWxDb21waWxlTGltaXQ9NDAwMCIsCisgICAgICAgICItLWpzYy1zbWFsbEhlYXBSQU1GcmFjdGlv bj0wLjc1IiwKKyAgICAgICAgIi0tanNjLWNvbmZpZ0ZpbGU9L3RtcC9iYXIiLAorICAgICAgICAi LS1qc2MtYnl0ZWNvZGVSYW5nZVRvSklUQ29tcGlsZT0xMDA6MzAwIiwKKyAgICAgICAgIi0tanNj LWxvZ0dDPTEiLAorICAgICAgICBudWxscHRyCisgICAgfTsKKyAgICBHVW5pcXVlUHRyPGNoYXIq PiBjb3B5KGdfc3RyZHVwdihjb25zdF9jYXN0PGNoYXIqKj4oYXJndikpKTsKKyAgICBpbnQgYXJn YyA9IGdfc3Rydl9sZW5ndGgoY29weS5nZXQoKSk7CisgICAgYXV0byogY29weVB0ciA9IGNvcHku Z2V0KCk7CisgICAgZ19hc3NlcnRfdHJ1ZShnX29wdGlvbl9jb250ZXh0X3BhcnNlKGNvbnRleHQs ICZhcmdjLCAmY29weVB0ciwgbnVsbHB0cikpOworICAgIGdfb3B0aW9uX2NvbnRleHRfZnJlZShj b250ZXh0KTsKKworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X2Jvb2xlYW4oSlND X09QVElPTlNfVVNFX0pJVCwgJnVzZUpJVCkpOworICAgIGdfYXNzZXJ0X2ZhbHNlKHVzZUpJVCk7 CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19nZXRfaW50KCJ0aHJlc2hvbGRGb3JKSVRB ZnRlcldhcm1VcCIsICZ0aHJlc2hvbGRGb3JKSVRBZnRlcldhcm1VcCkpOworICAgIGdfYXNzZXJ0 X2NtcGludCh0aHJlc2hvbGRGb3JKSVRBZnRlcldhcm1VcCwgPT0sIDIwMDApOworICAgIGdfYXNz ZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X3VpbnQoIm1heFBlclRocmVhZFN0YWNrVXNhZ2UiLCAm bWF4UGVyVGhyZWFkU3RhY2tVc2FnZSkpOworICAgIGdfYXNzZXJ0X2NtcHVpbnQobWF4UGVyVGhy ZWFkU3RhY2tVc2FnZSwgPT0sIDEwMjQpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNf Z2V0X3NpemUoIndlYkFzc2VtYmx5UGFydGlhbENvbXBpbGVMaW1pdCIsICZ3ZWJBc3NlbWJseVBh cnRpYWxDb21waWxlTGltaXQpKTsKKyAgICBnX2Fzc2VydF9jbXB1aW50KHdlYkFzc2VtYmx5UGFy dGlhbENvbXBpbGVMaW1pdCwgPT0sIDQwMDApOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlv bnNfZ2V0X2RvdWJsZSgic21hbGxIZWFwUkFNRnJhY3Rpb24iLCAmc21hbGxIZWFwUkFNRnJhY3Rp b24pKTsKKyAgICBnX2Fzc2VydF9jbXBmbG9hdChzbWFsbEhlYXBSQU1GcmFjdGlvbiwgPT0sIDAu NzUpOworICAgIGdfYXNzZXJ0X3RydWUoanNjX29wdGlvbnNfZ2V0X3N0cmluZygiY29uZmlnRmls ZSIsICZjb25maWdGaWxlLm91dFB0cigpKSk7CisgICAgZ19hc3NlcnRfY21wc3RyKGNvbmZpZ0Zp bGUuZ2V0KCksID09LCAiL3RtcC9iYXIiKTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25z X2dldF9yYW5nZV9zdHJpbmcoImJ5dGVjb2RlUmFuZ2VUb0pJVENvbXBpbGUiLCAmYnl0ZWNvZGVS YW5nZVRvSklUQ29tcGlsZS5vdXRQdHIoKSkpOworICAgIGdfYXNzZXJ0X2NtcHN0cihieXRlY29k ZVJhbmdlVG9KSVRDb21waWxlLmdldCgpLCA9PSwgIjEwMDozMDAiKTsKKyAgICBnX2Fzc2VydF90 cnVlKGpzY19vcHRpb25zX2dldF91aW50KCJsb2dHQyIsICZsb2dHQykpOworICAgIGdfYXNzZXJ0 X2NtcHVpbnQobG9nR0MsID09LCAxKTsKKworICAgIC8vIFJlc3RvcmUgb3B0aW9ucyB0aGVpciBk ZWZhdWx0IHZhbHVlcy4KKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX3NldF9ib29sZWFu KEpTQ19PUFRJT05TX1VTRV9KSVQsIFRSVUUpKTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRp b25zX3NldF9pbnQoInRocmVzaG9sZEZvckpJVEFmdGVyV2FybVVwIiwgNTAwKSk7CisgICAgZ19h c3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRfdWludCgibWF4UGVyVGhyZWFkU3RhY2tVc2FnZSIs IDQxOTQzMDQpKTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX3NldF9zaXplKCJ3ZWJB c3NlbWJseVBhcnRpYWxDb21waWxlTGltaXQiLCA1MDAwKSk7CisgICAgZ19hc3NlcnRfdHJ1ZShq c2Nfb3B0aW9uc19zZXRfZG91YmxlKCJzbWFsbEhlYXBSQU1GcmFjdGlvbiIsIDAuMjUpKTsKKyAg ICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX3NldF9zdHJpbmcoImNvbmZpZ0ZpbGUiLCBudWxs cHRyKSk7CisgICAgZ19hc3NlcnRfdHJ1ZShqc2Nfb3B0aW9uc19zZXRfcmFuZ2Vfc3RyaW5nKCJi eXRlY29kZVJhbmdlVG9KSVRDb21waWxlIiwgbnVsbHB0cikpOworICAgIGdfYXNzZXJ0X3RydWUo anNjX29wdGlvbnNfc2V0X3VpbnQoImxvZ0dDIiwgMCkpOworCisgICAgY29udGV4dCA9IGdfb3B0 aW9uX2NvbnRleHRfbmV3KG51bGxwdHIpOworICAgIGdfb3B0aW9uX2NvbnRleHRfYWRkX2dyb3Vw KGNvbnRleHQsIGpzY19vcHRpb25zX2dldF9vcHRpb25fZ3JvdXAoKSk7CisgICAgc3RhdGljIGNv bnN0IGNoYXIqIGFyZ3YyW10gPSB7IF9fRklMRV9fLCAiLS1qc2MtSW52YWxpZE9wdGlvbj10cnVl IiwgbnVsbHB0ciB9OworICAgIGNvcHkucmVzZXQoZ19zdHJkdXB2KGNvbnN0X2Nhc3Q8Y2hhcioq Pihhcmd2MikpKTsKKyAgICBhcmdjID0gZ19zdHJ2X2xlbmd0aChjb3B5LmdldCgpKTsKKyAgICBj b3B5UHRyID0gY29weS5nZXQoKTsKKyAgICBnX2Fzc2VydF9mYWxzZShnX29wdGlvbl9jb250ZXh0 X3BhcnNlKGNvbnRleHQsICZhcmdjLCAmY29weVB0ciwgbnVsbHB0cikpOworICAgIGdfb3B0aW9u X2NvbnRleHRfZnJlZShjb250ZXh0KTsKKworICAgIGNvbnRleHQgPSBnX29wdGlvbl9jb250ZXh0 X25ldyhudWxscHRyKTsKKyAgICBnX29wdGlvbl9jb250ZXh0X2FkZF9ncm91cChjb250ZXh0LCBq c2Nfb3B0aW9uc19nZXRfb3B0aW9uX2dyb3VwKCkpOworICAgIHN0YXRpYyBjb25zdCBjaGFyKiBh cmd2M1tdID0geyBfX0ZJTEVfXywgIi0tanNjLXVzZUpJVD1uZWluIiwgbnVsbHB0ciB9OworICAg IGNvcHkucmVzZXQoZ19zdHJkdXB2KGNvbnN0X2Nhc3Q8Y2hhcioqPihhcmd2MykpKTsKKyAgICBh cmdjID0gZ19zdHJ2X2xlbmd0aChjb3B5LmdldCgpKTsKKyAgICBjb3B5UHRyID0gY29weS5nZXQo KTsKKyAgICBnX2Fzc2VydF9mYWxzZShnX29wdGlvbl9jb250ZXh0X3BhcnNlKGNvbnRleHQsICZh cmdjLCAmY29weVB0ciwgbnVsbHB0cikpOworICAgIGdfb3B0aW9uX2NvbnRleHRfZnJlZShjb250 ZXh0KTsKKyAgICBnX2Fzc2VydF90cnVlKGpzY19vcHRpb25zX2dldF9ib29sZWFuKEpTQ19PUFRJ T05TX1VTRV9KSVQsICZ1c2VKSVQpKTsKKyAgICBnX2Fzc2VydF90cnVlKHVzZUpJVCk7Cit9CisK ICNpZmRlZiBHX0RFRklORV9BVVRPUFRSX0NMRUFOVVBfRlVOQwogc3RhdGljIHZvaWQgdGVzdHNK U0NBdXRvY2xlYW51cHMoKQogewpAQCAtMzI3MCw2ICszNDc1LDcgQEAgaW50IG1haW4oaW50IGFy Z2MsIGNoYXIqKiBhcmd2KQogICAgIGdfdGVzdF9hZGRfZnVuYygiL2pzYy9nYXJiYWdlLWNvbGxl Y3RvciIsIHRlc3RKU0NHYXJiYWdlQ29sbGVjdG9yKTsKICAgICBnX3Rlc3RfYWRkX2Z1bmMoIi9q c2Mvd2Vhay12YWx1ZSIsIHRlc3RKU0NXZWFrVmFsdWUpOwogICAgIGdfdGVzdF9hZGRfZnVuYygi L2pzYy92bSIsIHRlc3RzSlNDVmlydHVhbE1hY2hpbmUpOworICAgIGdfdGVzdF9hZGRfZnVuYygi L2pzYy9vcHRpb25zIiwgdGVzdHNKU0NPcHRpb25zKTsKICNpZmRlZiBHX0RFRklORV9BVVRPUFRS X0NMRUFOVVBfRlVOQwogICAgIGdfdGVzdF9hZGRfZnVuYygiL2pzYy9hdXRvY2xlYW51cHMiLCB0 ZXN0c0pTQ0F1dG9jbGVhbnVwcyk7CiAjZW5kaWYK