From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from esa4.mentor.iphmx.com (esa4.mentor.iphmx.com [68.232.137.252]) by sourceware.org (Postfix) with ESMTPS id 5A7143858D33 for ; Fri, 10 Jun 2022 13:59:46 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 5A7143858D33 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=codesourcery.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=mentor.com X-IronPort-AV: E=Sophos;i="5.91,290,1647331200"; d="diff'?scan'208";a="77087121" Received: from orw-gwy-02-in.mentorg.com ([192.94.38.167]) by esa4.mentor.iphmx.com with ESMTP; 10 Jun 2022 05:59:43 -0800 IronPort-SDR: 2AvUknEhO2keVGs4D6qLvggDAPYBPEgOf5aPIz0iqQOGxhwoS0yK4Q4kDxL9Adzvn5YjwUCPCg WzDe53LWp173ZnqIREvgM/iphkqw7T8X8AKg2aXdOMgaBJj4NDvk0OAjODE+X8zfEc0OmYRg49 FaL3pPX98sCpgF2raI3h2aoPvS5BzeG7gZO8Ksg/QYmvFkWPZtvkXQPvuFUgkGL1rcDtjE72Wq ex1opfYsI87W2Y8cQ6LUzSkXZ2QuyXq16+HRRwg/kuszlm7jv7YgYqC7Z31K/qhUZGuGDlsFyo m3M= Content-Type: multipart/mixed; boundary="------------0HfT3DE3BCPMcOTLxsw4juJx" Message-ID: <73621930-22ce-c3f1-61e0-f15683f8b281@codesourcery.com> Date: Fri, 10 Jun 2022 15:59:37 +0200 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.7.0 From: Marcel Vollweiler Subject: Re: [PATCH] OpenMP, libgomp: Environment variable syntax extension. References: <392c847d-e798-2be3-a808-6888de6c90cd@codesourcery.com> To: "jakub@redhat.com >> Jakub Jelinek" CC: In-Reply-To: X-Originating-IP: [137.202.0.90] X-ClientProxiedBy: SVR-IES-MBX-07.mgc.mentorg.com (139.181.222.7) To svr-ies-mbx-10.mgc.mentorg.com (139.181.222.10) X-Spam-Status: No, score=-13.3 required=5.0 tests=BAYES_00, GIT_PATCH_0, HEADER_FROM_DIFFERENT_DOMAINS, KAM_DMARC_STATUS, NICE_REPLY_A, SPF_HELO_PASS, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 10 Jun 2022 13:59:55 -0000 --------------0HfT3DE3BCPMcOTLxsw4juJx Content-Type: text/plain; charset="UTF-8"; format=flowed Content-Transfer-Encoding: quoted-printable Hi Jakub, Am 04.05.2022 um 17:12 schrieb Jakub Jelinek: > On Tue, Jan 18, 2022 at 05:10:47PM +0100, Marcel Vollweiler wrote: >> Hi, >> >> This patch considers the environment variable syntax extension for >> device-specific variants of environment variables from OpenMP 5.1 (see >> OpenMP 5.1 specification, p. 75 and p. 639). An environment variable >> (e.g. OMP_NUM_TEAMS) can have different suffixes: >> >> _DEV (e.g. OMP_NUM_TEAMS_DEV): affects all devices but not the host. >> _DEV_ (e.g. OMP_NUM_TEAMS_DEV_42): affects only device with >> number . >> no suffix (e.g. OMP_NUM_TEAMS): affects only the host. >> >> In future OpenMP versions also suffix _ALL will be introduced (see >> discussion https://github.com/OpenMP/spec/issues/3179). This is also >> considered in this patch: >> >> _ALL (e.g. OMP_NUM_TEAMS_ALL): affects all devices and the host. >> >> The precedence is as follows (descending). For the host: >> >> 1. no suffix >> 2. _ALL >> >> For devices: >> >> 1. _DEV_ >> 2. _DEV >> 3. _ALL >> >> That means, _DEV_ is used whenever available. Otherwise _DEV is >> used if available, and at last _ALL. If there is no value for any of the >> variable variants, default values are used as already implemented before= . >> >> This patch concerns parsing (a), storing (b), output (c) and >> transmission to the device (d): >> >> (a) The actual number of devices and the numbering are not known when >> parsing the environment variables. Thus all environment variables are >> iterated and searched for device-specific ones. >> >> (b) Only configured device-specific variables are stored. Thus, linked >> lists are used. >> >> (c) The output is done in omp_display_env (see specification p. 468f). >> Global ICVs are tagged with [all], see >> https://github.com/OpenMP/spec/issues/3179. ICVs which are not global >> but aren't handled device-specific yet are tagged with [host]. >> omp_display_env outputs the initial values of the ICVs. That's why >> separate data structures are introduced (like gomp_initial_icv...). >> >> (d) Device-specific ICVs which are already user accessible on the device >> are transmitted to the device (moreover nteams-var is added and used for >> the tests). There are ICVs which values are currently set explicitly in >> the config when copying them to the device: GOMP_NTHREADS_VAR, >> GOMP_THREAD_LIMIT_VAR, GOMP_DYN_VAR (see gomp_gcn_enter_kernel in >> libgomp/config/gcn/team.c and gomp_nvptx_main in >> libgomp/config/nvptx/team.c). The corresponding environment variables >> are nevertheless parsed and stored device-specific but the transmission >> to the device is not changed. > > Just a partial review, there are many issues. > Some issues I'm mentioning just once or several times but many apply to > various other spots in the patch. > >> +/* Returns the element of the list for the specified device number. */ >> +struct gomp_icv_list* >> +gomp_get_icv_list (struct gomp_icv_list **list, int device_num) >> +{ >> + struct gomp_icv_list *l =3D *list; >> + while (l !=3D NULL) >> + { >> + if (l->device_num =3D=3D device_num) >> + return l; >> + l =3D l->next; >> + } >> + return NULL; >> +} >> + >> +void* > > Space before *. Corrected all occurrences. > >> +gomp_get_icv_value_ptr (struct gomp_icv_list **list, int device_num) >> +{ >> + struct gomp_icv_list *l =3D gomp_get_icv_list (list, device_num); >> + if (l =3D=3D NULL) >> + return NULL; >> + return l->value; >> +} >> + >> +/* Lists for initial device-specific ICVs, i.e. ICVs that are configure= d for >> + particular devices (with environment variables like OMP_NUM_TEAMS_DE= V_42). */ >> +struct gomp_icv_list *gomp_dyn_var_dev_list =3D NULL; >> +struct gomp_icv_list *gomp_nthreads_var_dev_list =3D NULL; >> +struct gomp_icv_list *gomp_nthreads_var_list_dev_list =3D NULL; >> +struct gomp_icv_list *gomp_nthreads_var_list_len_dev_list =3D NULL; >> +struct gomp_icv_list *gomp_run_sched_var_dev_list =3D NULL; >> +struct gomp_icv_list *gomp_run_sched_chunk_size_dev_list =3D NULL; >> +struct gomp_icv_list *gomp_nteams_var_dev_list =3D NULL; >> +struct gomp_icv_list *gomp_thread_limit_var_dev_list =3D NULL; >> +struct gomp_icv_list *gomp_max_active_levels_var_dev_list =3D NULL; >> +struct gomp_icv_list *gomp_proc_bind_var_dev_list =3D NULL; >> +struct gomp_icv_list *gomp_proc_bind_var_list_dev_list =3D NULL; >> +struct gomp_icv_list *gomp_proc_bind_var_list_len_dev_list =3D NULL; >> +struct gomp_icv_list *stacksize_dev_list =3D NULL; >> +struct gomp_icv_list *wait_policy_dev_list =3D NULL; >> +struct gomp_icv_list *teams_thread_limit_var_dev_list =3D NULL; > > To me the above is just too big extra .data growth, we should optimize fo= r > the common case of no OMP_* env vars or a few host cases of them. > So, I think it is ok to have the gomp_initial_icv var as is and > gomp_initial_icv_flags too. But I'd turn gomp_initial_icv_all and > gomp_initial_icv_dev into pointers to gomp_initial_icv_t, Turning gomp_initial_icv_all and gomp_initial_icv_dev into pointers does no= t work in the (new) table driven approach were the addresses of both are used= . > and maybe instead > of the OMP_*_DEV_ linked lists for each var separately add one linke= d > list that contains device number, next pointer, gomp_initial_icv_t for va= lues > and gomp_icv_flags_t used as a bitmask "is this ICV set for this ". The above lists are replaced by one list now. > >> + >> +/* Flags for non-global ICVs to store by which environment variables th= ey are >> + affected. */ >> +struct gomp_icv_flags_t gomp_initial_icv_flags =3D { >> + .nthreads_var =3D GOMP_ENV_VAR_SUFFIX_UNKNOWN, >> + .run_sched_var =3D GOMP_ENV_VAR_SUFFIX_UNKNOWN, >> + .run_sched_chunk_size =3D GOMP_ENV_VAR_SUFFIX_UNKNOWN, >> + .thread_limit_var =3D GOMP_ENV_VAR_SUFFIX_UNKNOWN, >> + .dyn_var =3D GOMP_ENV_VAR_SUFFIX_UNKNOWN, >> + .max_active_levels_var =3D GOMP_ENV_VAR_SUFFIX_UNKNOWN, >> + .bind_var =3D GOMP_ENV_VAR_SUFFIX_UNKNOWN, >> + .nteams_var =3D GOMP_ENV_VAR_SUFFIX_UNKNOWN, >> + .stacksize =3D GOMP_ENV_VAR_SUFFIX_UNKNOWN, >> + .wait_policy =3D GOMP_ENV_VAR_SUFFIX_UNKNOWN, >> + .teams_thread_limit_var =3D GOMP_ENV_VAR_SUFFIX_UNKNOWN >> +}; >> + > >> invalid: >> gomp_error ("Invalid value for chunk size in " >> "environment variable OMP_SCHEDULE"); > > This should be > gomp_error ("Invalid value for chunk size in " > "environment variable %s", name); > and similarly for all the other parsing routines. Corrected all occurrences. > >> +/* Helper function for omp_display_env which prints the values of run_s= ched_var. >> + 'device' can be 'host', 'dev', 'all' or a particular device number. = */ >> +static void >> +print_schedule (enum gomp_schedule_type run_sched_var, int run_sched_ch= unk_size, >> + const char* device) > > Formatting, space before * not after it. Corrected all occurrences. > >> +/* Helper function for omp_display_env which prints the values of proc_= bind_var. >> + 'device' can be 'host', 'dev', 'all', or a particular device number.= */ >> +static void print_proc_bind (char proc_bind_var, unsigned long len, cha= r **list, >> + const char* device) > > Space before * instead of after it. > print_proc_bind should be at the start of line, not in the middle. Changed. > >> +{ >> + fprintf (stderr, " [%s] OMP_PROC_BIND =3D '", device); >> + switch (proc_bind_var) >> { >> case omp_proc_bind_false: >> fputs ("FALSE", stderr); >> @@ -1324,8 +1392,8 @@ omp_display_env (int verbose) >> fputs ("SPREAD", stderr); >> break; >> } >> - for (i =3D 1; i < gomp_bind_var_list_len; i++) >> - switch (gomp_bind_var_list[i]) >> + for (int i =3D 1; i < len; i++) >> + switch ((*list)[i]) >> { >> case omp_proc_bind_master: >> fputs (",MASTER", stderr); /* TODO: Change to PRIMARY for OpenMP 5.= 1. */ >> @@ -1338,7 +1406,131 @@ omp_display_env (int verbose) >> break; >> } >> fputs ("'\n", stderr); >> - fputs (" OMP_PLACES =3D '", stderr); >> +} >> + >> +void >> +omp_display_env (int verbose) >> +{ >> + int i; >> + >> + fputs ("\nOPENMP DISPLAY ENVIRONMENT BEGIN\n", stderr); >> + >> + fputs (" _OPENMP =3D '201511'\n", stderr); >> + >> + fprintf (stderr, " [host] OMP_DYNAMIC =3D '%s'\n", >> + gomp_initial_icv.dyn_var ? "TRUE" : "FALSE"); >> + if (gomp_initial_icv_flags.dyn_var & GOMP_ENV_VAR_SUFFIX_ALL) >> + fprintf (stderr, " [all] OMP_DYNAMIC =3D '%s'\n", >> + gomp_initial_icv_all.dyn_var ? "TRUE" : "FALSE"); >> + if (gomp_initial_icv_flags.dyn_var & GOMP_ENV_VAR_SUFFIX_DEV) >> + fprintf (stderr, " [device] OMP_DYNAMIC =3D '%s'\n", >> + gomp_initial_icv_dev.dyn_var ? "TRUE" : "FALSE"); >> + struct gomp_icv_list* l_dyn_var =3D gomp_dyn_var_dev_list; > > * formatting. Corrected all occurrences. > >> + while (l_dyn_var !=3D NULL) >> + { >> + fprintf (stderr, " [%d] OMP_DYNAMIC =3D '%s'\n", l_dyn_var->devi= ce_num, >> + *(bool*)l_dyn_var->value ? "TRUE" : "FALSE"); >> + l_dyn_var =3D l_dyn_var->next; >> + } > > And like mentioned elsewhere, this should be table driven, ideally using > one table for all. You really don't want to duplicate that much code. Three tables are introduced in env.c: 1) a table for parsing device specific ICVs ("envvars_dev"), 2) a table for parsing non device specific ICVs ("envvars"), 3) a table that helps setting the host ICVs depending on the _ALL and _DEV variants of the environment variables ("host_envvars"). Those tables make the parsing of environment variables and setting the corresponding ICV values more compact and clear from my point of view. However, making omp_display_env table driven seems not quite helpful, since mostly all of the ICVs have different output patterns. Nevertheless I intro= duced print_device_specific_icvs function to reduce the complexity of iterating t= he list for most of the ICVs. > >> + struct gomp_icv_list* l_nthreads_var =3D gomp_nthreads_var_dev_list; > > * formatting. > >> + struct gomp_icv_list* l_run_sched_var =3D gomp_run_sched_var_dev_list= ; > > * formatting (many times more). > >> +/* Helper function for parse_device_specific. Extracts the device numbe= r from >> + an environment variable name. */ >> +static void >> +get_device_num (char **env, int prefix_len, int *dev_num, int *name_len= ) > > Why do you pass char **env rather than say just char *env? The extra > indirection doesn't seem to be useful. Why don't you return one of the > two return values and just fill in the other one through pointer argument= ? Removed the extra indirection for "env". The function "get_device_num" returns a boolean value now in order to signa= lize success or failure. > >> +{ >> + if (env =3D=3D NULL || *env =3D=3D NULL) >> + { >> + *name_len =3D 0; >> + *dev_num =3D -1; >> + return; >> + } >> + >> + int eq_pos =3D strchr (*env, '=3D') - *env; > > This will misbehave if there is no =3D character. > There is no point to walk again the first prefix_len bytes or walk megaby= tes > of chars if somebody creates extremely long vars, those will never someth= ing > we care about. > So I'd just compute the longest device num we want to support > (stringify __INT_MAX__ with an extra preprocessor macro in between so tha= t > it is expanded and compute sizeof of it, unless you hardcode 10 chars > maximum) and check that after the prefix_len there is 1 to 10 of [0-9] ch= ars > followed by =3D in a loop, if not, punt, otherwise strtoul it into a numb= er? > Maybe also verify that first digit is 0 only iff that is immediately > followed by =3D. The get_device_num function was adapted accordingly and a constant INT_MAX_STR_LEN with value 10 is introduced and used. I thought about stringification of __INT_MAX__ instead using the hardcoded = "10" but ended only in some over-complicated macros since __INT_MAX__ is given a= s hex number and not as decimal. > >> + int dev_num_len =3D eq_pos - prefix_len; >> + char buf_dev_num[dev_num_len+1]; >> + >> + strncpy(buf_dev_num, *env + prefix_len, dev_num_len); >> + buf_dev_num[dev_num_len] =3D '\0'; > > No need to copy anything, VLA, etc. And strtoul is what is used elsewher= e > in libgomp, we never use atoi. Replaced the strncpy with a loop over the actual expected device number and replaced atoi with strtoul. > >> + *dev_num =3D atoi (buf_dev_num); >> + *name_len =3D eq_pos; >> +} >> + >> +/* Helper function for parse_device_specific. Adds a new node to the gi= ven >> + list. */ >> +static struct gomp_icv_list* >> +add_device_specific_icv (int dev_num, size_t size, struct gomp_icv_list= **list) >> +{ >> + if (list =3D=3D NULL) >> + return NULL; >> + >> + struct gomp_icv_list *new_node =3D >> + (struct gomp_icv_list*) malloc (sizeof (struct gomp_icv_list)); > > Please always use gomp_malloc if it can't fail, malloc should be only use= d > if it is an optimization and caller will handle malloc returning NULL > gracefully. Changed. > >> + new_node->device_num =3D dev_num; >> + new_node->value =3D malloc (size); >> + new_node->next =3D *list; >> + *list =3D new_node; >> + >> + return new_node; >> +} >> + >> +/* Helper function for 'initialize_env' to parse device-specific enviro= nment >> + variables like 'OMP_NUM_TEAMS_DEV_42'. */ >> +static void >> +parse_device_specific () > > Should be (void) Good hint, thanks. (parse_device_specific was removed though) > >> +{ >> + extern char **environ; >> + int dev_num; >> + int name_len; >> + struct gomp_icv_list *new_node; >> + >> + for (char **env =3D environ; *env !=3D 0; env++) >> + { >> + if (strncmp (*env, "OMP_SCHEDULE_DEV_", 17) =3D=3D 0) > > These would be a maintainance nightmare (making sure all the computed > lengths are accurate). Please add something like > static inline bool > startswith (const char *str, const char *prefix) > { > return strncmp (str, prefix, strlen (prefix)) =3D=3D 0; > } > gcc/system.h has and use it. > But even with that you really don't want to have to duplicate so much cod= e, > e.g. all the get_device_num char name[name_len strncpy and termination > at least. So I think you want it table driven, start by checking > if (!startswith (*env, "OMP_")) > continue; > and then walk over some table with names of the env vars, their precomput= ed > lengths (using some macro so that you don't duplicate the strings), and t= hen > what to do with it, where what to do could be what function to call and v= ar > to fill in, or something you can switch on if common code can't be used. Agreed, so I introduced a table ("envvars") that contains the names, the le= ngth of the names, pointers to the parse functions etc. > >> + { >> + get_device_num (env, 17, &dev_num, &name_len); >> + char name[name_len+1]; > > Formatting, spaces around + on both sides. > But I think using a VLA is unnecessary, you can easily compute some > upper bound (length of largest supported env var name + length of largest > supported device number (we shouldn't support > INT_MAX numbers). Changed. > >> + strncpy(name, *env, name_len); > > Formatting, space before (. Changed. > >> + new_node =3D add_device_specific_icv (dev_num, sizeof (bool), >> + &gomp_dyn_var_dev_list); >> + *((bool*)(new_node->value)) =3D value; > > Formatting, space before *, space in between )(. Corrected (hopefully) all occurrences. > >> + /* Parse the environment variables and store their values in the init= ial >> + struct. */ >> + if (parse_schedule ("OMP_SCHEDULE", &gomp_initial_icv.run_sched_var, >> + &gomp_initial_icv.run_sched_chunk_size)) >> + { >> + gomp_initial_icv_flags.run_sched_var |=3D GOMP_ENV_VAR_SUFFIX_NON= E; >> + gomp_initial_icv_flags.run_sched_chunk_size |=3D GOMP_ENV_VAR_SUF= FIX_NONE; >> + } >> + if (parse_schedule ("OMP_SCHEDULE_ALL", &gomp_initial_icv_all.run_sch= ed_var, >> + &gomp_initial_icv_all.run_sched_chunk_size)) >> + { >> + gomp_initial_icv_flags.run_sched_var |=3D GOMP_ENV_VAR_SUFFIX_ALL= ; >> + gomp_initial_icv_flags.run_sched_chunk_size |=3D GOMP_ENV_VAR_SUF= FIX_ALL; >> + } >> + if (parse_schedule ("OMP_SCHEDULE_DEV", &gomp_initial_icv_dev.run_sch= ed_var, >> + &gomp_initial_icv_dev.run_sched_chunk_size)) >> + { >> + gomp_initial_icv_flags.run_sched_var |=3D GOMP_ENV_VAR_SUFFIX_DEV= ; >> + gomp_initial_icv_flags.run_sched_chunk_size |=3D GOMP_ENV_VAR_SUF= FIX_DEV; >> + } > > This really should be table driven. This is code done once during progra= m > startup, so we don't want such code to be extra large (roughly optimize f= or > size, not speed). Furthermore, we should optimize for the common case th= at > no env vars or only very few of them are used and if anything, the host > ones. > Looking at glibc's getenv implementation, getenv is O(num_env_vars), like= : > for (ep =3D __environ; *ep !=3D NULL; ++ep) > { > #if _STRING_ARCH_unaligned > uint16_t ep_start =3D *(uint16_t *) *ep; > #else > uint16_t ep_start =3D (((unsigned char *) *ep)[0] > | (((unsigned char *) *ep)[1] << 8)); > #endif > > if (name_start =3D=3D ep_start && !strncmp (*ep + 2, name, len= ) > && (*ep)[len + 2] =3D=3D '=3D') > return &(*ep)[len + 3]; > } > I'd keep the GOMP_* env vars as is using getenv, but as we need to walk > environ completely for the OMP_*_DEV_* vars anyway, I wonder if we just > shouldn't handle all the OMP_* env vars inside of that loop. Good point. Changed accordingly, i.e. one iteration over all environment variables. Only in a few cases getenv is still used (GOMP_ and dependent OM= P_ variables). > Immediately punt on non-OMP_ prefixed vars, then do table driven decision > on what middle part we have and depending on what tail (nothing, _DEV, _A= LL, > _DEV_) ending it has decide where to stick it. > > For the table driven operation, some vars are regular and just parse a bo= ol > or long etc. value, others need some extra handling code. > > Though, there is one gotcha, if we had code where we parsed some var firs= t > and another one later and there was interdependence between the two, in > environ they can appear in any order. > >> + >> + /* Set the ICV values for the host. */ >> + if (gomp_initial_icv_flags.run_sched_var & GOMP_ENV_VAR_SUFFIX_NONE) >> + { >> + gomp_global_icv.run_sched_var =3D gomp_initial_icv.run_sched_var; >> + gomp_global_icv.run_sched_chunk_size =3D > > No =3D at the end of line. Changed. > >> + gomp_initial_icv.run_sched_chunk_size; >> + } > >> +enum gomp_env_var_suffix_t >> +{ >> + GOMP_ENV_VAR_SUFFIX_UNKNOWN =3D 0, >> + GOMP_ENV_VAR_SUFFIX_NONE =3D 1, >> + GOMP_ENV_VAR_SUFFIX_DEV =3D 2, >> + GOMP_ENV_VAR_SUFFIX_ALL =3D 4 >> +}; >> + >> +/* Struct that contains all ICVs for which we need to store initial val= ues. >> + Keeping the initial values is needed for omp_display_env and also us= ed for >> + transmitting device-specific values to the target. */ >> +struct gomp_initial_icv_t >> +{ >> + unsigned long nthreads_var; >> + unsigned long *nthreads_var_list; >> + unsigned long nthreads_var_list_len; >> + enum gomp_schedule_type run_sched_var; >> + int run_sched_chunk_size; >> + int default_device_var; >> + unsigned int thread_limit_var; >> + bool dyn_var; >> + unsigned char max_active_levels_var; >> + char bind_var; >> + char *bind_var_list; >> + unsigned long bind_var_list_len; >> + int nteams_var; >> + int teams_thread_limit_var; >> + int wait_policy; >> + unsigned long stacksize; > > Would be nice to order the struct elements to avoid padding. > Say put pointers first, then unsigned long fields, then > int/uint/enum ones and finally the bool/char ones. Changed. > >> +}; >> + >> +struct gomp_icv_flags_t >> +{ >> + enum gomp_env_var_suffix_t nthreads_var; >> + enum gomp_env_var_suffix_t run_sched_var; >> + enum gomp_env_var_suffix_t run_sched_chunk_size; >> + enum gomp_env_var_suffix_t thread_limit_var; >> + enum gomp_env_var_suffix_t dyn_var; >> + enum gomp_env_var_suffix_t max_active_levels_var; >> + enum gomp_env_var_suffix_t bind_var; >> + enum gomp_env_var_suffix_t nteams_var; >> + enum gomp_env_var_suffix_t stacksize; >> + enum gomp_env_var_suffix_t wait_policy; >> + enum gomp_env_var_suffix_t teams_thread_limit_var; > > This is unnecessarily large. You need just 3 bits for each. > Can't you make all those say 4 bit bitfields? > I know it is a GNU extension, but we don't expect libgomp to be compiled = by > other compilers, do we? Changed. > >> +}; >> + >> +struct gomp_icv_list { > > Formatting consistency. All other toplevel structs have > { on the next line. Changed. > >> + int device_num; >> + void* value; > > Formatting, use void *value; instead. Changed. > >> + struct gomp_icv_list *next; >> +}; >> + > >> --- /dev/null >> +++ b/libgomp/testsuite/libgomp.c-c++-common/icv-5.c >> @@ -0,0 +1,48 @@ >> +/* { dg-do run } */ >> + >> +#include >> +#include >> +#include >> +#include >> + >> +char const *varnames[] =3D { >> + "OMP_NUM_TEAMS_DEV_0", >> + "OMP_NUM_TEAMS_DEV_1", >> + "OMP_NUM_TEAMS_DEV_2", >> + "OMP_NUM_TEAMS_ALL", >> + "OMP_NUM_TEAMS_DEV", >> + "OMP_NUM_TEAMS" >> +}; >> +char const *values[] =3D { "42", "43", "44", "45", "46", "47" }; >> +const int cnt =3D 6; >> + >> +int >> +main (int argc, char *const *argv) >> +{ >> + int updated =3D 0; >> + for (int i =3D 0; i < cnt; i++) >> + { >> + if (getenv (varnames[i]) =3D=3D NULL >> + || strcmp (getenv (varnames[i]), values[i]) !=3D 0) >> + { >> + setenv (varnames[i], values[i], 1); >> + updated =3D 1; >> + } >> + } >> + if (updated) >> + { >> + execv (argv[0], argv); > > I'm not sure we can rely on execv on all targets that do support libgomp. > Any reason why you actually need this, rather than using > dg-set-target-env-var directive(s) and perhaps return 0; if getenv doesn'= t > return the expected values? Interesting topic. After some (internal) discussions I think the best way i= s to set the environment variables explicitely instead using dg-set-target-env-v= ar. The reason is that dg-set-target-env-var does not work for remote testing (= which seems to be a common test environment). For remote testing dejagnu immediat= ely aborts the test case with UNSUPPORTED which is specified in the correspondi= ng extension and makes sence from my point of view as the test assumption cann= ot be fulfilled (since the environment variables are not set on remote targets). It also means that whenever dg-set-target-env-var is set in the test file, = the execution of the test case is not tested on remote targets. However, I understand that compatibility is essential (in this particular c= ase to use execv only if the test is run on POSIX compliant systems) and added = a test for "__unix__" (though this is not a complete guarantee for POSIX conformity as far as I understand). > >> + abort (); >> + } >> + > >> + int num_devices =3D omp_get_num_devices () > 3 ? 3 : omp_get_num_devi= ces (); >> + for (int i=3D0; i < num_devices; i++) >> + #pragma omp target device (i) >> + if (omp_get_max_teams () !=3D 42) >> + abort (); >> + >> + return 0; >> +} >> \ No newline at end of file > > Please avoid files without newlines at the end. Corrected all test files. An updated patch is attached and tested again on x86_64-linux with nvptx an= d amdgcn offloading without regression. Marcel ----------------- Siemens Electronic Design Automation GmbH; Anschrift: Arnulfstra=C3=9Fe 201= , 80634 M=C3=BCnchen; Gesellschaft mit beschr=C3=A4nkter Haftung; Gesch=C3= =A4ftsf=C3=BChrer: Thomas Heurung, Frank Th=C3=BCrauf; Sitz der Gesellschaf= t: M=C3=BCnchen; Registergericht M=C3=BCnchen, HRB 106955 --------------0HfT3DE3BCPMcOTLxsw4juJx Content-Type: text/plain; charset="UTF-8"; name="extend-env-variables-syntax.diff" Content-Disposition: attachment; filename="extend-env-variables-syntax.diff" Content-Transfer-Encoding: base64 T3Blbk1QLCBsaWJnb21wOiBFbnZpcm9ubWVudCB2YXJpYWJsZSBzeW50YXggZXh0ZW5zaW9u LgoKVGhpcyBwYXRjaCBjb25zaWRlcnMgdGhlIGVudmlyb25tZW50IHZhcmlhYmxlIHN5bnRh eCBleHRlbnNpb24gZm9yCmRldmljZS1zcGVjaWZpYyB2YXJpYW50cyBvZiBlbnZpcm9ubWVu dCB2YXJpYWJsZXMgZnJvbSBPcGVuTVAgNS4xIChzZWUKT3Blbk1QIDUuMSBzcGVjaWZpY2F0 aW9uLCBwLiA3NSBhbmQgcC4gNjM5KS4gQW4gZW52aXJvbm1lbnQgdmFyaWFibGUgKGUuZy4K T01QX05VTV9URUFNUykgY2FuIGhhdmUgZGlmZmVyZW50IHN1ZmZpeGVzOgoKX0RFViAoZS5n LiBPTVBfTlVNX1RFQU1TX0RFVik6IGFmZmVjdHMgYWxsIGRldmljZXMgYnV0IG5vdCB0aGUg aG9zdC4KX0RFVl88ZGV2aWNlPiAoZS5nLiBPTVBfTlVNX1RFQU1TX0RFVl80Mik6IGFmZmVj dHMgb25seSBkZXZpY2Ugd2l0aApudW1iZXIgPGRldmljZT4uCm5vIHN1ZmZpeCAoZS5nLiBP TVBfTlVNX1RFQU1TKTogYWZmZWN0cyBvbmx5IHRoZSBob3N0LgoKSW4gZnV0dXJlIE9wZW5N UCB2ZXJzaW9ucyBhbHNvIHN1ZmZpeCBfQUxMIHdpbGwgYmUgaW50cm9kdWNlZCAoc2VlIGRp c2N1c3Npb24KaHR0cHM6Ly9naXRodWIuY29tL09wZW5NUC9zcGVjL2lzc3Vlcy8zMTc5KS4g VGhpcyBpcyBhbHNvIGNvbnNpZGVyZWQgaW4gdGhpcwpwYXRjaDoKCl9BTEwgKGUuZy4gT01Q X05VTV9URUFNU19BTEwpOiBhZmZlY3RzIGFsbCBkZXZpY2VzIGFuZCB0aGUgaG9zdC4KCQpU aGUgcHJlY2VkZW5jZSBpcyBhcyBmb2xsb3dzIChkZXNjZW5kaW5nKS4gRm9yIHRoZSBob3N0 OgoKCTEuIG5vIHN1ZmZpeAoJMi4gX0FMTAoJCkZvciBkZXZpY2VzOgoKCTEuIF9ERVZfPGRl dmljZT4KCTIuIF9ERVYKCTMuIF9BTEwKCQpUaGF0IG1lYW5zLCBfREVWXzxkZXZpY2U+IGlz IHVzZWQgd2hlbmV2ZXIgYXZhaWxhYmxlLiBPdGhlcndpc2UgX0RFViBpcyB1c2VkIGlmCmF2 YWlsYWJsZSwgYW5kIGF0IGxhc3QgX0FMTC4gSWYgdGhlcmUgaXMgbm8gdmFsdWUgZm9yIGFu eSBvZiB0aGUgdmFyaWFibGUKdmFyaWFudHMsIGRlZmF1bHQgdmFsdWVzIGFyZSB1c2VkIGFz IGFscmVhZHkgaW1wbGVtZW50ZWQgYmVmb3JlLgoKVGhpcyBwYXRjaCBjb25jZXJucyBwYXJz aW5nIChhKSwgc3RvcmluZyAoYiksIG91dHB1dCAoYykgYW5kIHRyYW5zbWlzc2lvbiB0byB0 aGUKZGV2aWNlIChkKToKCihhKSBUaGUgYWN0dWFsIG51bWJlciBvZiBkZXZpY2VzIGFuZCB0 aGUgbnVtYmVyaW5nIGFyZSBub3Qga25vd24gd2hlbiBwYXJzaW5nCnRoZSBlbnZpcm9ubWVu dCB2YXJpYWJsZXMuIFRodXMgYWxsIGVudmlyb25tZW50IHZhcmlhYmxlcyBhcmUgaXRlcmF0 ZWQgYW5kCnNlYXJjaGVkIGZvciBkZXZpY2Utc3BlY2lmaWMgb25lcy4KKGIpIE9ubHkgY29u ZmlndXJlZCBkZXZpY2Utc3BlY2lmaWMgdmFyaWFibGVzIGFyZSBzdG9yZWQuIFRodXMsIGxp bmtlZCBsaXN0cwphcmUgdXNlZC4KKGMpIFRoZSBvdXRwdXQgaXMgZG9uZSBpbiBvbXBfZGlz cGxheV9lbnYgKHNlZSBzcGVjaWZpY2F0aW9uIHAuIDQ2OGYpLiBHbG9iYWwKSUNWcyBhcmUg dGFnZ2VkIHdpdGggW2FsbF0sIHNlZSBodHRwczovL2dpdGh1Yi5jb20vT3Blbk1QL3NwZWMv aXNzdWVzLzMxNzkuCklDVnMgd2hpY2ggYXJlIG5vdCBnbG9iYWwgYnV0IGFyZW4ndCBoYW5k bGVkIGRldmljZS1zcGVjaWZpYyB5ZXQgYXJlIHRhZ2dlZAp3aXRoIFtob3N0XS4gb21wX2Rp c3BsYXlfZW52IG91dHB1dHMgdGhlIGluaXRpYWwgdmFsdWVzIG9mIHRoZSBJQ1ZzLiBUaGF0 J3Mgd2h5CnNlcGFyYXRlIGRhdGEgc3RydWN0dXJlcyBhcmUgaW50cm9kdWNlZCAobGlrZSBn b21wX2luaXRpYWxfaWN2Li4uKS4KKGQpIERldmljZS1zcGVjaWZpYyBJQ1ZzIHdoaWNoIGFy ZSBhbHJlYWR5IHVzZXIgYWNjZXNzaWJsZSBvbiB0aGUgZGV2aWNlIGFyZQp0cmFuc21pdHRl ZCB0byB0aGUgZGV2aWNlIChtb3Jlb3ZlciBudGVhbXMtdmFyIGlzIGFkZGVkIGFuZCB1c2Vk IGZvciB0aGUgdGVzdHMpLgoKbGliZ29tcC9DaGFuZ2VMb2c6CgoJKiBjb25maWcvZ2NuL2lj di1kZXZpY2UuYyAob21wX2dldF9kZWZhdWx0X2RldmljZSk6IFJldHVybiBJQ1YgdmFsdWUu Cgkob21wX2dldF9tYXhfdGVhbXMpOiBBZGRlZCBmb3IgR0NOIGRldmljZXMuCgkqIGNvbmZp Zy9udnB0eC9pY3YtZGV2aWNlLmMgKG9tcF9nZXRfZGVmYXVsdF9kZXZpY2UpOiBSZXR1cm4g SUNWIHZhbHVlLgoJKG9tcF9nZXRfbWF4X3RlYW1zKTogQWRkZWQgZm9yIG52cHR4IGRldmlj ZXMuCgkqIGVudi5jIChnb21wX2luaXRpYWxfaWN2c19ub25lKTogQ29udGFpbnMgYWxsIElD ViB2YWx1ZXMgZm9yIHRoZSBob3N0LAoJd2hpY2ggYXJlIGNvbmZpZ3VyZWQgd2l0aCBlbnZp cm9ubWVudCB2YXJpYWJsZXMgd2l0aG91dCBhIHN1ZmZpeC4KCShnb21wX2luaXRpYWxfaWN2 c19hbGwpOiBJbml0aWFsIElDViB2YWx1ZXMgdGhhdCB3ZXJlIGNvbmZpZ3VyZWQgZm9yIHRo ZQoJaG9zdCBhbmQgZm9yIGFsbCBkZXZpY2VzIGJ5IHVzaW5nIGVudmlyb25tZW50IHZhcmlh YmxlcyB3aXRoIHN1ZmZpeAoJX0FMTC4KCShnb21wX2luaXRpYWxfaWN2c19kZXYpOiBJbml0 aWFsIElDViB2YWx1ZXMgdGhhdCB3ZXJlIGNvbmZpZ3VyZWQgb25seQoJZm9yIGRldmljZXMg KG5vdCBmb3IgdGhlIGhvc3QpIGJ5IHVzaW5nIGVudmlyb25tZW50IHZhcmlhYmxlcyB3aXRo CglzdWZmaXggX0RFVi4KCShnb21wX2luaXRpYWxfaWN2X2Rldl9saXN0KTogTmV3IGxpc3Qg Zm9yIGluaXRpYWwgZGV2aWNlLXNwZWNpZmljIElDVnMuCgkoZ29tcF9pbml0aWFsX2ljdl9m bGFncyk6IEZsYWdzIGZvciBub24tZ2xvYmFsIElDVnMgdG8gc3RvcmUgYnkgd2hpY2gKCWVu dmlyb25tZW50IHZhcmlhYmxlcyB0aGV5IGFyZSBhZmZlY3RlZC4KCShwYXJzZV9zY2hlZHVs ZSk6IEdlbmVyYWxpemVkIGZvciBkaWZmZXJlbnQgdmFyaWFudHMgb2YgT01QX1NDSEVEVUxF LgoJKHByaW50X2Vudl92YXJfZXJyb3IpOiBGdW5jdGlvbiB0aGF0IHByaW50cyBhbiBlcnJv ciBmb3IgaW52YWxpZCB2YWx1ZXMKCWZvciBJQ1ZzLgoJKHBhcnNlX3Vuc2lnbmVkX2xvbmdf MSk6IFJlbW92ZWQgZ2V0ZW52LiBHZW5lcmFsaXplZC4KCShwYXJzZV91bnNpZ25lZF9sb25n KTogTGlrZXdpc2UuCgkocGFyc2VfaW50XzEpOiBMaWtld2lzZS4KCShwYXJzZV9pbnQpOiBM aWtld2lzZS4KCShwYXJzZV9pbnRfc2VjdXJlKTogTGlrZXdpc2UuCgkocGFyc2VfdW5zaWdu ZWRfbG9uZ19saXN0KTogTGlrZXdpc2UuCgkocGFyc2VfdGFyZ2V0X29mZmxvYWQpOiBMaWtl d2lzZS4KCShwYXJzZV9iaW5kX3Zhcik6IExpa2V3aXNlLgoJKHBhcnNlX3N0YWNrc2l6ZSk6 IExpa2V3aXNlLgoJKHBhcnNlX2Jvb2xlYW4pOiBMaWtld2lzZS4KCShwYXJzZV93YWl0X3Bv bGljeSk6IExpa2V3aXNlLgoJKHBhcnNlX2FsbG9jYXRvcik6IExpa2V3aXNlLgoJKG9tcF9k aXNwbGF5X2Vudik6IEV4dGVuZGVkIHRvIG91dHB1dCBkaWZmZXJlbnQgdmFyaWFudHMgb2Yg ZW52aXJvbm1lbnQKCXZhcmlhYmxlcy4KCShwcmludF9zY2hlZHVsZSk6IE5ldyBoZWxwZXIg ZnVuY3Rpb24gZm9yIG9tcF9kaXNwbGF5X2VudiB3aGljaCBwcmludHMKCXRoZSB2YWx1ZXMg b2YgcnVuX3NjaGVkX3Zhci4KCShwcmludF9wcm9jX2JpbmQpOiBOZXcgaGVscGVyIGZ1bmN0 aW9uIGZvciBvbXBfZGlzcGxheV9lbnYgd2hpY2ggcHJpbnRzCgl0aGUgdmFsdWVzIG9mIHBy b2NfYmluZF92YXIuCgkocHJpbnRfZGV2aWNlX3NwZWNpZmljX2ljdnMpOiBOZXcgaGVscGVy IGZ1bmN0aW9uIGZvciBvbXBfZGlzcGxheV9lbnYgdG8KCXByaW50IGRldmljZSBzcGVjaWZp YyBJQ1YgdmFsdWVzLgoJKGdldF9kZXZpY2VfbnVtKTogTmV3IGhlbHBlciBmdW5jdGlvbiBm b3IgcGFyc2VfZGV2aWNlX3NwZWNpZmljLgoJRXh0cmFjdHMgdGhlIGRldmljZSBudW1iZXIg ZnJvbSBhbiBlbnZpcm9ubWVudCB2YXJpYWJsZSBuYW1lLgoJKGFkZF9kZXZpY2Vfc3BlY2lm aWNfaWN2KTogTmV3IGhlbHBlciBmdW5jdGlvbiBmb3IgaW5pdGlhbGl6ZV9lbnYuIEFkZHMK CWFuIElDViB2YWx1ZSB0byBhbiBleGlzdGluZyBub2RlIG9yIGNyZWF0ZXMgYSBuZXcgbm9k ZSB0byB0aGUgbGlzdCBvZgoJZGV2aWNlIHNwZWNpZmljIElDVnMuCgkoc3RhcnRzd2l0aCk6 IENoZWNrcyBpZiBhIHN0cmluZyBoYXMgYSBnaXZlbiBwcmVmaXguCgkoZ2V0X2ljdl9mbGFn KTogR2V0cyB0aGUgZmxhZyBvZiBhIGdpdmVuIElDVi4KCShzZXRfaWN2X2ZsYWcpOiBTZXRz IHRoZSBmbGFnIGZvciBhIGdpdmVuIElDVi4KCShpbml0aWFsaXplX2Vudik6IEV4dGVuZGVk IHRvIHBhcnNlIHRoZSBuZXcgc3ludGF4IG9mIGVudmlyb25tZW50Cgl2YXJpYWJsZXMuCgkq IGljdi1kZXZpY2UuYyAob21wX2dldF9tYXhfdGVhbXMpOiBBZGRlZC4KCSogaWN2LmMgKG9t cF9nZXRfbWF4X3RlYW1zKTogTW92ZWQgdG8gaWN2LWRldmljZS5jLgoJKiBsaWJnb21wLXBs dWdpbi5oIChHT01QX0RFRkFVTFRfREVWSUNFX1ZBUik6ICBOZXcgdGFyZ2V0LXNpZGUgdmFy aWFibGUKCXRoYXQgaG9sZHMgdGhlIGRlc2lnbmF0ZWQgSUNWIG9mIHRoZSB0YXJnZXQgZGV2 aWNlLgoJKEdPTVBfTlRFQU1TX1ZBUik6IExpa2V3aXNlLgoJKHN0cnVjdCBnb21wX2luaXRp YWxfaWN2cyk6IENvbnRhaW5zIGFsbCBJQ1ZzIGZvciB3aGljaCB3ZSBuZWVkIHRvIHN0b3Jl Cglpbml0aWFsIHZhbHVlcy4KCShzdHJ1Y3QgZ29tcF9pY3ZfZmxhZ3MpOiBTdG9yZSB3aXRo IHdoaWNoIHN1ZmZpeGVzIChmb3Igd2hpY2ggdmFyaWFudHMpCgllbnZpcm9ubWVudCB2YXJp YWJsZXMgYXJlIGRlZmluZWQuCgkoc3RydWN0IGdvbXBfaWN2X2xpc3QpOiBEZWZpbml0aW9u IG9mIGEgbGlua2VkIGxpc3QgdGhhdCBpcyB1c2VkIGZvcgoJc3RvcmluZyBJQ1ZzIGZvciB0 aGUgZGV2aWNlcy4KCSogcGx1Z2luL3BsdWdpbi1nY24uYyAoR09NUF9PRkZMT0FEX2xvYWRf aW1hZ2UpOiBFeHRlbmRlZCB0byByZWFkCglmdXJ0aGVyIElDVnMgZnJvbSB0aGUgb2ZmbG9h ZCBpbWFnZS4KCSogcGx1Z2luL3BsdWdpbi1udnB0eC5jIChHT01QX09GRkxPQURfbG9hZF9p bWFnZSk6IExpa2V3aXNlLgoJKiB0YXJnZXQuYyAoZ29tcF9nZXRfaWN2KTogTmV3IGhlbHBl ciBmdW5jdGlvbiBmb3IKCSdnb21wX2xvYWRfaW1hZ2VfdG9fZGV2aWNlJyB0aGF0IHJldHVy bnMgdGhlIHBvaW50ZXIgZm9yIGFuIElDViB2YWx1ZQoJZGVwZW5kaW5nIG9uIHRoZSBkZXZp Y2UgbnVtYmVyIGFuZCB0aGUgdmFyaWFibGUgaGllcmFyY2h5LgoJKGdvbXBfbG9hZF9pbWFn ZV90b19kZXZpY2UpOiBFeHRlbmRlZCB0byBjb3B5IGZ1cnRoZXIgSUNWcyB0byB0aGUgZGV2 aWNlLgoJKiB0ZXN0c3VpdGUvbGliZ29tcC5jLWMrKy1jb21tb24vaWN2LTUuYzogTmV3IHRl c3QuCgkqIHRlc3RzdWl0ZS9saWJnb21wLmMtYysrLWNvbW1vbi9pY3YtNi5jOiBOZXcgdGVz dC4KCSogdGVzdHN1aXRlL2xpYmdvbXAuYy1jKystY29tbW9uL2ljdi03LmM6IE5ldyB0ZXN0 LgoJKiB0ZXN0c3VpdGUvbGliZ29tcC5jLWMrKy1jb21tb24vb21wLWRpc3BsYXktZW52LTEu YzogTmV3IHRlc3QuCgkqIHRlc3RzdWl0ZS9saWJnb21wLmMtYysrLWNvbW1vbi9vbXAtZGlz cGxheS1lbnYtMi5jOiBOZXcgdGVzdC4KCmRpZmYgLS1naXQgYS9saWJnb21wL2NvbmZpZy9n Y24vaWN2LWRldmljZS5jIGIvbGliZ29tcC9jb25maWcvZ2NuL2ljdi1kZXZpY2UuYwppbmRl eCBmNzBiN2U2Li45NjZjODY0IDEwMDY0NAotLS0gYS9saWJnb21wL2NvbmZpZy9nY24vaWN2 LWRldmljZS5jCisrKyBiL2xpYmdvbXAvY29uZmlnL2djbi9pY3YtZGV2aWNlLmMKQEAgLTI4 LDYgKzI4LDEyIEBACiAKICNpbmNsdWRlICJsaWJnb21wLmgiCiAKKy8qIFRoaXMgaXMgc2V0 IHRvIHRoZSBJQ1YgdmFsdWVzIG9mIGN1cnJlbnQgR1BVIGR1cmluZyBkZXZpY2UgaW5pdGlh bGl6YXRpb24sCisgICB3aGVuIHRoZSBvZmZsb2FkIGltYWdlIGNvbnRhaW5pbmcgdGhpcyBs aWJnb21wIHBvcnRpb24gaXMgbG9hZGVkLiAgKi8KK3ZvbGF0aWxlIGludCBHT01QX0RFVklD RV9OVU1fVkFSOwordm9sYXRpbGUgaW50IEdPTVBfREVGQVVMVF9ERVZJQ0VfVkFSOwordm9s YXRpbGUgaW50IEdPTVBfTlRFQU1TX1ZBUjsKKwogdm9pZAogb21wX3NldF9kZWZhdWx0X2Rl dmljZSAoaW50IGRldmljZV9udW0gX19hdHRyaWJ1dGVfXygodW51c2VkKSkpCiB7CkBAIC0z Niw3ICs0Miw3IEBAIG9tcF9zZXRfZGVmYXVsdF9kZXZpY2UgKGludCBkZXZpY2VfbnVtIF9f YXR0cmlidXRlX18oKHVudXNlZCkpKQogaW50CiBvbXBfZ2V0X2RlZmF1bHRfZGV2aWNlICh2 b2lkKQogewotICByZXR1cm4gMDsKKyAgcmV0dXJuIEdPTVBfREVGQVVMVF9ERVZJQ0VfVkFS OwogfQogCiBpbnQKQEAgLTU4LDE5ICs2NCwyMiBAQCBvbXBfaXNfaW5pdGlhbF9kZXZpY2Ug KHZvaWQpCiAgIHJldHVybiAwOwogfQogCi0vKiBUaGlzIGlzIHNldCB0byB0aGUgZGV2aWNl IG51bWJlciBvZiBjdXJyZW50IEdQVSBkdXJpbmcgZGV2aWNlIGluaXRpYWxpemF0aW9uLAot ICAgd2hlbiB0aGUgb2ZmbG9hZCBpbWFnZSBjb250YWluaW5nIHRoaXMgbGliZ29tcCBwb3J0 aW9uIGlzIGxvYWRlZC4gICovCi12b2xhdGlsZSBpbnQgR09NUF9ERVZJQ0VfTlVNX1ZBUjsK LQogaW50CiBvbXBfZ2V0X2RldmljZV9udW0gKHZvaWQpCiB7CiAgIHJldHVybiBHT01QX0RF VklDRV9OVU1fVkFSOwogfQogCitpbnQKK29tcF9nZXRfbWF4X3RlYW1zICh2b2lkKQorewor ICByZXR1cm4gR09NUF9OVEVBTVNfVkFSOworfQorCiBpYWxpYXMgKG9tcF9zZXRfZGVmYXVs dF9kZXZpY2UpCiBpYWxpYXMgKG9tcF9nZXRfZGVmYXVsdF9kZXZpY2UpCiBpYWxpYXMgKG9t cF9nZXRfaW5pdGlhbF9kZXZpY2UpCiBpYWxpYXMgKG9tcF9nZXRfbnVtX2RldmljZXMpCiBp YWxpYXMgKG9tcF9pc19pbml0aWFsX2RldmljZSkKIGlhbGlhcyAob21wX2dldF9kZXZpY2Vf bnVtKQoraWFsaWFzIChvbXBfZ2V0X21heF90ZWFtcykKZGlmZiAtLWdpdCBhL2xpYmdvbXAv Y29uZmlnL252cHR4L2ljdi1kZXZpY2UuYyBiL2xpYmdvbXAvY29uZmlnL252cHR4L2ljdi1k ZXZpY2UuYwppbmRleCBmYWY5MGY5Li5kYWNhYzhkIDEwMDY0NAotLS0gYS9saWJnb21wL2Nv bmZpZy9udnB0eC9pY3YtZGV2aWNlLmMKKysrIGIvbGliZ29tcC9jb25maWcvbnZwdHgvaWN2 LWRldmljZS5jCkBAIC0yOCw2ICsyOCwxMiBAQAogCiAjaW5jbHVkZSAibGliZ29tcC5oIgog CisvKiBUaGlzIGlzIHNldCB0byB0aGUgSUNWIHZhbHVlcyBvZiBjdXJyZW50IEdQVSBkdXJp bmcgZGV2aWNlIGluaXRpYWxpemF0aW9uLAorICAgd2hlbiB0aGUgb2ZmbG9hZCBpbWFnZSBj b250YWluaW5nIHRoaXMgbGliZ29tcCBwb3J0aW9uIGlzIGxvYWRlZC4gICovCitzdGF0aWMg dm9sYXRpbGUgaW50IEdPTVBfREVWSUNFX05VTV9WQVI7CitzdGF0aWMgdm9sYXRpbGUgaW50 IEdPTVBfREVGQVVMVF9ERVZJQ0VfVkFSOworc3RhdGljIHZvbGF0aWxlIGludCBHT01QX05U RUFNU19WQVI7CisKIHZvaWQKIG9tcF9zZXRfZGVmYXVsdF9kZXZpY2UgKGludCBkZXZpY2Vf bnVtIF9fYXR0cmlidXRlX18oKHVudXNlZCkpKQogewpAQCAtMzYsNyArNDIsNyBAQCBvbXBf c2V0X2RlZmF1bHRfZGV2aWNlIChpbnQgZGV2aWNlX251bSBfX2F0dHJpYnV0ZV9fKCh1bnVz ZWQpKSkKIGludAogb21wX2dldF9kZWZhdWx0X2RldmljZSAodm9pZCkKIHsKLSAgcmV0dXJu IDA7CisgIHJldHVybiBHT01QX0RFRkFVTFRfREVWSUNFX1ZBUjsKIH0KIAogaW50CkBAIC01 OCwxOSArNjQsMjIgQEAgb21wX2lzX2luaXRpYWxfZGV2aWNlICh2b2lkKQogICByZXR1cm4g MDsKIH0KIAotLyogVGhpcyBpcyBzZXQgdG8gdGhlIGRldmljZSBudW1iZXIgb2YgY3VycmVu dCBHUFUgZHVyaW5nIGRldmljZSBpbml0aWFsaXphdGlvbiwKLSAgIHdoZW4gdGhlIG9mZmxv YWQgaW1hZ2UgY29udGFpbmluZyB0aGlzIGxpYmdvbXAgcG9ydGlvbiBpcyBsb2FkZWQuICAq Lwotc3RhdGljIHZvbGF0aWxlIGludCBHT01QX0RFVklDRV9OVU1fVkFSOwotCiBpbnQKIG9t cF9nZXRfZGV2aWNlX251bSAodm9pZCkKIHsKICAgcmV0dXJuIEdPTVBfREVWSUNFX05VTV9W QVI7CiB9CiAKK2ludAorb21wX2dldF9tYXhfdGVhbXMgKHZvaWQpCit7CisgIHJldHVybiBH T01QX05URUFNU19WQVI7Cit9CisKIGlhbGlhcyAob21wX3NldF9kZWZhdWx0X2RldmljZSkK IGlhbGlhcyAob21wX2dldF9kZWZhdWx0X2RldmljZSkKIGlhbGlhcyAob21wX2dldF9pbml0 aWFsX2RldmljZSkKIGlhbGlhcyAob21wX2dldF9udW1fZGV2aWNlcykKIGlhbGlhcyAob21w X2lzX2luaXRpYWxfZGV2aWNlKQogaWFsaWFzIChvbXBfZ2V0X2RldmljZV9udW0pCitpYWxp YXMgKG9tcF9nZXRfbWF4X3RlYW1zKQpkaWZmIC0tZ2l0IGEvbGliZ29tcC9lbnYuYyBiL2xp YmdvbXAvZW52LmMKaW5kZXggMWM0ZWU4OS4uNGRkNGExNyAxMDA2NDQKLS0tIGEvbGliZ29t cC9lbnYuYworKysgYi9saWJnb21wL2Vudi5jCkBAIC03Myw2ICs3MywzOSBAQCBzdHJ1Y3Qg Z29tcF90YXNrX2ljdiBnb21wX2dsb2JhbF9pY3YgPSB7CiAgIC50YXJnZXRfZGF0YSA9IE5V TEwKIH07CiAKKy8qIFRoZSBpbml0aWFsIElDViB2YWx1ZXMgZm9yIHRoZSBob3N0LCB3aGlj aCBhcmUgY29uZmlndXJlZCB3aXRoIGVudmlyb25tZW50CisgICB2YXJpYWJsZXMgd2l0aG91 dCBhIHN1ZmZpeCwgZS5nLiBPTVBfTlVNX1RFQU1TLiAgKi8KK3N0cnVjdCBnb21wX2luaXRp YWxfaWN2cyBnb21wX2luaXRpYWxfaWN2c19ub25lOworCisvKiBJbml0aWFsIElDViB2YWx1 ZXMgdGhhdCB3ZXJlIGNvbmZpZ3VyZWQgZm9yIHRoZSBob3N0IGFuZCBmb3IgYWxsIGRldmlj ZXMgYnkKKyAgIHVzaW5nIGVudmlyb25tZW50IHZhcmlhYmxlcyBsaWtlIE9NUF9OVU1fVEVB TVNfQUxMLiAgKi8KK3N0cnVjdCBnb21wX2luaXRpYWxfaWN2cyBnb21wX2luaXRpYWxfaWN2 c19hbGw7CisKKy8qIEluaXRpYWwgSUNWIHZhbHVlcyB0aGF0IHdlcmUgY29uZmlndXJlZCBv bmx5IGZvciBkZXZpY2VzIChub3QgZm9yIHRoZSBob3N0KQorICAgYnkgdXNpbmcgZW52aXJv bm1lbnQgdmFyaWFibGVzIGxpa2UgT01QX05VTV9URUFNU19ERVYuICAqLworc3RydWN0IGdv bXBfaW5pdGlhbF9pY3ZzIGdvbXBfaW5pdGlhbF9pY3ZzX2RldjsKKworLyogTGlzdCBmb3Ig aW5pdGlhbCBkZXZpY2Utc3BlY2lmaWMgSUNWcywgaS5lLiBJQ1ZzIHRoYXQgYXJlIGNvbmZp Z3VyZWQgZm9yCisgICBwYXJ0aWN1bGFyIGRldmljZXMgKHdpdGggZW52aXJvbm1lbnQgdmFy aWFibGVzIGxpa2UgT01QX05VTV9URUFNU19ERVZfNDIpLiAqLworc3RydWN0IGdvbXBfaWN2 X2xpc3QgKmdvbXBfaW5pdGlhbF9pY3ZfZGV2X2xpc3QgPSBOVUxMOworCisvKiBGbGFncyBm b3Igbm9uLWdsb2JhbCBJQ1ZzIHRvIHN0b3JlIGJ5IHdoaWNoIGVudmlyb25tZW50IHZhcmlh YmxlcyB0aGV5IGFyZQorICAgYWZmZWN0ZWQuICAqLworc3RydWN0IGdvbXBfaWN2X2ZsYWdz IGdvbXBfaW5pdGlhbF9pY3ZfZmxhZ3MgPSB7CisgIC5udGhyZWFkc192YXIgPSBHT01QX0VO Vl9WQVJfU1VGRklYX1VOS05PV04sCisgIC5ydW5fc2NoZWRfdmFyID0gR09NUF9FTlZfVkFS X1NVRkZJWF9VTktOT1dOLAorICAucnVuX3NjaGVkX2NodW5rX3NpemUgPSBHT01QX0VOVl9W QVJfU1VGRklYX1VOS05PV04sCisgIC50aHJlYWRfbGltaXRfdmFyID0gR09NUF9FTlZfVkFS X1NVRkZJWF9VTktOT1dOLAorICAuZHluX3ZhciA9IEdPTVBfRU5WX1ZBUl9TVUZGSVhfVU5L Tk9XTiwKKyAgLm1heF9hY3RpdmVfbGV2ZWxzX3ZhciA9IEdPTVBfRU5WX1ZBUl9TVUZGSVhf VU5LTk9XTiwKKyAgLmJpbmRfdmFyID0gR09NUF9FTlZfVkFSX1NVRkZJWF9VTktOT1dOLAor ICAubnRlYW1zX3ZhciA9IEdPTVBfRU5WX1ZBUl9TVUZGSVhfVU5LTk9XTiwKKyAgLnN0YWNr c2l6ZSA9IEdPTVBfRU5WX1ZBUl9TVUZGSVhfVU5LTk9XTiwKKyAgLndhaXRfcG9saWN5ID0g R09NUF9FTlZfVkFSX1NVRkZJWF9VTktOT1dOLAorICAudGVhbXNfdGhyZWFkX2xpbWl0X3Zh ciA9IEdPTVBfRU5WX1ZBUl9TVUZGSVhfVU5LTk9XTiwKKyAgLmRlZmF1bHRfZGV2aWNlX3Zh ciA9IEdPTVBfRU5WX1ZBUl9TVUZGSVhfVU5LTk9XTgorfTsKKwogYm9vbCBnb21wX2NhbmNl bF92YXIgPSBmYWxzZTsKIGVudW0gZ29tcF90YXJnZXRfb2ZmbG9hZF90IGdvbXBfdGFyZ2V0 X29mZmxvYWRfdmFyCiAgID0gR09NUF9UQVJHRVRfT0ZGTE9BRF9ERUZBVUxUOwpAQCAtMTA0 LDg2ICsxMzcsOTQgQEAgaW50IGdvYWNjX2RlZmF1bHRfZGltc1tHT01QX0RJTV9NQVhdOwog c3RhdGljIGludCB3YWl0X3BvbGljeTsKIHN0YXRpYyB1bnNpZ25lZCBsb25nIHN0YWNrc2l6 ZSA9IEdPTVBfREVGQVVMVF9TVEFDS1NJWkU7CiAKLS8qIFBhcnNlIHRoZSBPTVBfU0NIRURV TEUgZW52aXJvbm1lbnQgdmFyaWFibGUuICAqLwotCiBzdGF0aWMgdm9pZAotcGFyc2Vfc2No ZWR1bGUgKHZvaWQpCitwcmludF9lbnZfdmFyX2Vycm9yIChjb25zdCBjaGFyICplbnYsIGNv bnN0IGNoYXIgKnZhbCkKIHsKLSAgY2hhciAqZW52LCAqZW5kOworICBjaGFyIG5hbWVbdmFs IC0gZW52XTsKKyAgbWVtY3B5IChuYW1lLCBlbnYsIHZhbCAtIGVudiAtIDEpOworICBuYW1l W3ZhbCAtIGVudiAtIDFdID0gJ1wwJzsKKyAgZ29tcF9lcnJvciAoIkludmFsaWQgdmFsdWUg Zm9yIGVudmlyb25tZW50IHZhcmlhYmxlICVzOiAlcyIsIG5hbWUsIHZhbCk7Cit9CisKKy8q IFBhcnNlIHRoZSBPTVBfU0NIRURVTEUgZW52aXJvbm1lbnQgdmFyaWFibGUuICAqLworc3Rh dGljIGJvb2wKK3BhcnNlX3NjaGVkdWxlIChjb25zdCBjaGFyICplbnYsIGNvbnN0IGNoYXIg KnZhbCwgdm9pZCAqIGNvbnN0IHBhcmFtc1tdKQoreworICBlbnVtIGdvbXBfc2NoZWR1bGVf dHlwZSAqc2NoZWR1bGUgPSAoZW51bSBnb21wX3NjaGVkdWxlX3R5cGUgKikgcGFyYW1zWzBd OworICBpbnQgKmNodW5rX3NpemUgPSAoaW50ICopIHBhcmFtc1sxXTsKKyAgY2hhciAqZW5k OwogICB1bnNpZ25lZCBsb25nIHZhbHVlOwogICBpbnQgbW9ub3RvbmljID0gMDsKIAotICBl bnYgPSBnZXRlbnYgKCJPTVBfU0NIRURVTEUiKTsKLSAgaWYgKGVudiA9PSBOVUxMKQotICAg IHJldHVybjsKKyAgaWYgKHZhbCA9PSBOVUxMKQorICAgIHJldHVybiBmYWxzZTsKIAotICB3 aGlsZSAoaXNzcGFjZSAoKHVuc2lnbmVkIGNoYXIpICplbnYpKQotICAgICsrZW52OwotICBp ZiAoc3RybmNhc2VjbXAgKGVudiwgIm1vbm90b25pYyIsIDkpID09IDApCisgIHdoaWxlIChp c3NwYWNlICgodW5zaWduZWQgY2hhcikgKnZhbCkpCisgICAgKyt2YWw7CisgIGlmIChzdHJu Y2FzZWNtcCAodmFsLCAibW9ub3RvbmljIiwgOSkgPT0gMCkKICAgICB7CiAgICAgICBtb25v dG9uaWMgPSAxOwotICAgICAgZW52ICs9IDk7CisgICAgICB2YWwgKz0gOTsKICAgICB9Ci0g IGVsc2UgaWYgKHN0cm5jYXNlY21wIChlbnYsICJub25tb25vdG9uaWMiLCAxMikgPT0gMCkK KyAgZWxzZSBpZiAoc3RybmNhc2VjbXAgKHZhbCwgIm5vbm1vbm90b25pYyIsIDEyKSA9PSAw KQogICAgIHsKICAgICAgIG1vbm90b25pYyA9IC0xOwotICAgICAgZW52ICs9IDEyOworICAg ICAgdmFsICs9IDEyOwogICAgIH0KICAgaWYgKG1vbm90b25pYykKICAgICB7Ci0gICAgICB3 aGlsZSAoaXNzcGFjZSAoKHVuc2lnbmVkIGNoYXIpICplbnYpKQotCSsrZW52OwotICAgICAg aWYgKCplbnYgIT0gJzonKQorICAgICAgd2hpbGUgKGlzc3BhY2UgKCh1bnNpZ25lZCBjaGFy KSAqdmFsKSkKKwkrK3ZhbDsKKyAgICAgIGlmICgqdmFsICE9ICc6JykKIAlnb3RvIHVua25v d247Ci0gICAgICArK2VudjsKLSAgICAgIHdoaWxlIChpc3NwYWNlICgodW5zaWduZWQgY2hh cikgKmVudikpCi0JKytlbnY7CisgICAgICArK3ZhbDsKKyAgICAgIHdoaWxlIChpc3NwYWNl ICgodW5zaWduZWQgY2hhcikgKnZhbCkpCisJKyt2YWw7CiAgICAgfQotICBpZiAoc3RybmNh c2VjbXAgKGVudiwgInN0YXRpYyIsIDYpID09IDApCisgIGlmIChzdHJuY2FzZWNtcCAodmFs LCAic3RhdGljIiwgNikgPT0gMCkKICAgICB7Ci0gICAgICBnb21wX2dsb2JhbF9pY3YucnVu X3NjaGVkX3ZhciA9IEdGU19TVEFUSUM7Ci0gICAgICBlbnYgKz0gNjsKKyAgICAgICpzY2hl ZHVsZSA9IEdGU19TVEFUSUM7CisgICAgICB2YWwgKz0gNjsKICAgICB9Ci0gIGVsc2UgaWYg KHN0cm5jYXNlY21wIChlbnYsICJkeW5hbWljIiwgNykgPT0gMCkKKyAgZWxzZSBpZiAoc3Ry bmNhc2VjbXAgKHZhbCwgImR5bmFtaWMiLCA3KSA9PSAwKQogICAgIHsKLSAgICAgIGdvbXBf Z2xvYmFsX2ljdi5ydW5fc2NoZWRfdmFyID0gR0ZTX0RZTkFNSUM7Ci0gICAgICBlbnYgKz0g NzsKKyAgICAgICpzY2hlZHVsZSA9IEdGU19EWU5BTUlDOworICAgICAgdmFsICs9IDc7CiAg ICAgfQotICBlbHNlIGlmIChzdHJuY2FzZWNtcCAoZW52LCAiZ3VpZGVkIiwgNikgPT0gMCkK KyAgZWxzZSBpZiAoc3RybmNhc2VjbXAgKHZhbCwgImd1aWRlZCIsIDYpID09IDApCiAgICAg ewotICAgICAgZ29tcF9nbG9iYWxfaWN2LnJ1bl9zY2hlZF92YXIgPSBHRlNfR1VJREVEOwot ICAgICAgZW52ICs9IDY7CisgICAgICAqc2NoZWR1bGUgPSBHRlNfR1VJREVEOworICAgICAg dmFsICs9IDY7CiAgICAgfQotICBlbHNlIGlmIChzdHJuY2FzZWNtcCAoZW52LCAiYXV0byIs IDQpID09IDApCisgIGVsc2UgaWYgKHN0cm5jYXNlY21wICh2YWwsICJhdXRvIiwgNCkgPT0g MCkKICAgICB7Ci0gICAgICBnb21wX2dsb2JhbF9pY3YucnVuX3NjaGVkX3ZhciA9IEdGU19B VVRPOwotICAgICAgZW52ICs9IDQ7CisgICAgICAqc2NoZWR1bGUgPSBHRlNfQVVUTzsKKyAg ICAgIHZhbCArPSA0OwogICAgIH0KICAgZWxzZQogICAgIGdvdG8gdW5rbm93bjsKIAogICBp ZiAobW9ub3RvbmljID09IDEKLSAgICAgIHx8IChtb25vdG9uaWMgPT0gMCAmJiBnb21wX2ds b2JhbF9pY3YucnVuX3NjaGVkX3ZhciA9PSBHRlNfU1RBVElDKSkKLSAgICBnb21wX2dsb2Jh bF9pY3YucnVuX3NjaGVkX3ZhciB8PSBHRlNfTU9OT1RPTklDOworICAgICAgfHwgKG1vbm90 b25pYyA9PSAwICYmICpzY2hlZHVsZSA9PSBHRlNfU1RBVElDKSkKKyAgICAqc2NoZWR1bGUg fD0gR0ZTX01PTk9UT05JQzsKIAotICB3aGlsZSAoaXNzcGFjZSAoKHVuc2lnbmVkIGNoYXIp ICplbnYpKQotICAgICsrZW52OwotICBpZiAoKmVudiA9PSAnXDAnKQorICB3aGlsZSAoaXNz cGFjZSAoKHVuc2lnbmVkIGNoYXIpICp2YWwpKQorICAgICsrdmFsOworICBpZiAoKnZhbCA9 PSAnXDAnKQogICAgIHsKLSAgICAgIGdvbXBfZ2xvYmFsX2ljdi5ydW5fc2NoZWRfY2h1bmtf c2l6ZQotCT0gKGdvbXBfZ2xvYmFsX2ljdi5ydW5fc2NoZWRfdmFyICYgfkdGU19NT05PVE9O SUMpICE9IEdGU19TVEFUSUM7Ci0gICAgICByZXR1cm47CisgICAgICAqY2h1bmtfc2l6ZSA9 ICgqc2NoZWR1bGUgJiB+R0ZTX01PTk9UT05JQykgIT0gR0ZTX1NUQVRJQzsKKyAgICAgIHJl dHVybiB0cnVlOwogICAgIH0KLSAgaWYgKCplbnYrKyAhPSAnLCcpCisgIGlmICgqdmFsKysg IT0gJywnKQogICAgIGdvdG8gdW5rbm93bjsKLSAgd2hpbGUgKGlzc3BhY2UgKCh1bnNpZ25l ZCBjaGFyKSAqZW52KSkKLSAgICArK2VudjsKLSAgaWYgKCplbnYgPT0gJ1wwJykKKyAgd2hp bGUgKGlzc3BhY2UgKCh1bnNpZ25lZCBjaGFyKSAqdmFsKSkKKyAgICArK3ZhbDsKKyAgaWYg KCp2YWwgPT0gJ1wwJykKICAgICBnb3RvIGludmFsaWQ7CiAKICAgZXJybm8gPSAwOwotICB2 YWx1ZSA9IHN0cnRvdWwgKGVudiwgJmVuZCwgMTApOwotICBpZiAoZXJybm8gfHwgZW5kID09 IGVudikKKyAgdmFsdWUgPSBzdHJ0b3VsICh2YWwsICZlbmQsIDEwKTsKKyAgaWYgKGVycm5v IHx8IGVuZCA9PSB2YWwpCiAgICAgZ290byBpbnZhbGlkOwogCiAgIHdoaWxlIChpc3NwYWNl ICgodW5zaWduZWQgY2hhcikgKmVuZCkpCkBAIC0xOTQsMjAgKzIzNSwyMiBAQCBwYXJzZV9z Y2hlZHVsZSAodm9pZCkKICAgaWYgKChpbnQpdmFsdWUgIT0gdmFsdWUpCiAgICAgZ290byBp bnZhbGlkOwogCi0gIGlmICh2YWx1ZSA9PSAwCi0gICAgICAmJiAoZ29tcF9nbG9iYWxfaWN2 LnJ1bl9zY2hlZF92YXIgJiB+R0ZTX01PTk9UT05JQykgIT0gR0ZTX1NUQVRJQykKKyAgaWYg KHZhbHVlID09IDAgJiYgKCpzY2hlZHVsZSAmIH5HRlNfTU9OT1RPTklDKSAhPSBHRlNfU1RB VElDKQogICAgIHZhbHVlID0gMTsKLSAgZ29tcF9nbG9iYWxfaWN2LnJ1bl9zY2hlZF9jaHVu a19zaXplID0gdmFsdWU7Ci0gIHJldHVybjsKKyAgKmNodW5rX3NpemUgPSB2YWx1ZTsKKyAg cmV0dXJuIHRydWU7CiAKICB1bmtub3duOgotICBnb21wX2Vycm9yICgiVW5rbm93biB2YWx1 ZSBmb3IgZW52aXJvbm1lbnQgdmFyaWFibGUgT01QX1NDSEVEVUxFIik7Ci0gIHJldHVybjsK KyAgcHJpbnRfZW52X3Zhcl9lcnJvciAoZW52LCB2YWwpOworICByZXR1cm4gZmFsc2U7CiAK ICBpbnZhbGlkOgorICBjaGFyIG5hbWVbdmFsIC0gZW52XTsKKyAgbWVtY3B5IChuYW1lLCBl bnYsIHZhbCAtIGVudiAtIDEpOworICBuYW1lW3ZhbCAtIGVudiAtIDFdID0gJ1wwJzsKICAg Z29tcF9lcnJvciAoIkludmFsaWQgdmFsdWUgZm9yIGNodW5rIHNpemUgaW4gIgotCSAgICAg ICJlbnZpcm9ubWVudCB2YXJpYWJsZSBPTVBfU0NIRURVTEUiKTsKLSAgcmV0dXJuOworCSAg ICAgICJlbnZpcm9ubWVudCB2YXJpYWJsZSAlczogJXMiLCBuYW1lLCB2YWwpOworICByZXR1 cm4gZmFsc2U7CiB9CiAKIC8qIFBhcnNlIGFuIHVuc2lnbmVkIGxvbmcgZW52aXJvbm1lbnQg dmFyaWFibGUuICBSZXR1cm4gdHJ1ZSBpZiBvbmUgd2FzCkBAIC0yMTUsMjQgKzI1OCwyMyBA QCBwYXJzZV9zY2hlZHVsZSAodm9pZCkKICAgIGVudmlyb25tZW50IHZhcmlhYmxlLiAgKi8K IAogc3RhdGljIGJvb2wKLXBhcnNlX3Vuc2lnbmVkX2xvbmdfMSAoY29uc3QgY2hhciAqbmFt ZSwgdW5zaWduZWQgbG9uZyAqcHZhbHVlLCBib29sIGFsbG93X3plcm8sCi0JCSAgICAgICBi b29sIHNlY3VyZSkKK3BhcnNlX3Vuc2lnbmVkX2xvbmdfMSAoY29uc3QgY2hhciAqZW52LCBj b25zdCBjaGFyICp2YWwsIHVuc2lnbmVkIGxvbmcgKnB2YWx1ZSwKKwkJICAgICAgIGJvb2wg YWxsb3dfemVybykKIHsKLSAgY2hhciAqZW52LCAqZW5kOworICBjaGFyICplbmQ7CiAgIHVu c2lnbmVkIGxvbmcgdmFsdWU7CiAKLSAgZW52ID0gKHNlY3VyZSA/IHNlY3VyZV9nZXRlbnYg KG5hbWUpIDogZ2V0ZW52IChuYW1lKSk7Ci0gIGlmIChlbnYgPT0gTlVMTCkKKyAgaWYgKHZh bCA9PSBOVUxMKQogICAgIHJldHVybiBmYWxzZTsKIAotICB3aGlsZSAoaXNzcGFjZSAoKHVu c2lnbmVkIGNoYXIpICplbnYpKQotICAgICsrZW52OwotICBpZiAoKmVudiA9PSAnXDAnKQor ICB3aGlsZSAoaXNzcGFjZSAoKHVuc2lnbmVkIGNoYXIpICp2YWwpKQorICAgICsrdmFsOwor ICBpZiAoKnZhbCA9PSAnXDAnKQogICAgIGdvdG8gaW52YWxpZDsKIAogICBlcnJubyA9IDA7 Ci0gIHZhbHVlID0gc3RydG91bCAoZW52LCAmZW5kLCAxMCk7Ci0gIGlmIChlcnJubyB8fCBl bmQgPT0gZW52IHx8IChsb25nKSB2YWx1ZSA8PSAwIC0gYWxsb3dfemVybykKKyAgdmFsdWUg PSBzdHJ0b3VsICh2YWwsICZlbmQsIDEwKTsKKyAgaWYgKGVycm5vIHx8IGVuZCA9PSB2YWwg fHwgKGxvbmcpIHZhbHVlIDw9IDAgLSBhbGxvd196ZXJvKQogICAgIGdvdG8gaW52YWxpZDsK IAogICB3aGlsZSAoaXNzcGFjZSAoKHVuc2lnbmVkIGNoYXIpICplbmQpKQpAQCAtMjQ0LDE2 ICsyODYsMzYgQEAgcGFyc2VfdW5zaWduZWRfbG9uZ18xIChjb25zdCBjaGFyICpuYW1lLCB1 bnNpZ25lZCBsb25nICpwdmFsdWUsIGJvb2wgYWxsb3dfemVybywKICAgcmV0dXJuIHRydWU7 CiAKICBpbnZhbGlkOgotICBnb21wX2Vycm9yICgiSW52YWxpZCB2YWx1ZSBmb3IgZW52aXJv bm1lbnQgdmFyaWFibGUgJXMiLCBuYW1lKTsKKyAgcHJpbnRfZW52X3Zhcl9lcnJvciAoZW52 LCB2YWwpOwogICByZXR1cm4gZmFsc2U7CiB9CiAKIC8qIEFzIHBhcnNlX3Vuc2lnbmVkX2xv bmdfMSwgYnV0IGFsd2F5cyB1c2UgZ2V0ZW52LiAgKi8KIAogc3RhdGljIGJvb2wKLXBhcnNl X3Vuc2lnbmVkX2xvbmcgKGNvbnN0IGNoYXIgKm5hbWUsIHVuc2lnbmVkIGxvbmcgKnB2YWx1 ZSwgYm9vbCBhbGxvd196ZXJvKQorcGFyc2VfdW5zaWduZWRfbG9uZyAoY29uc3QgY2hhciAq ZW52LCBjb25zdCBjaGFyICp2YWwsIHZvaWQgKiBjb25zdCBwYXJhbXNbXSkKIHsKLSAgcmV0 dXJuIHBhcnNlX3Vuc2lnbmVkX2xvbmdfMSAobmFtZSwgcHZhbHVlLCBhbGxvd196ZXJvLCBm YWxzZSk7CisgIHVuc2lnbmVkIHVwcGVyID0gKHVuc2lnbmVkIGxvbmcpIHBhcmFtc1syXTsK KyAgdW5zaWduZWQgbG9uZyBwdmFsdWUgPSAwOworICBib29sIHJldCA9IHBhcnNlX3Vuc2ln bmVkX2xvbmdfMSAoZW52LCB2YWwsICZwdmFsdWUsIChib29sKSBwYXJhbXNbMV0pOworICBp ZiAoIXJldCkKKyAgICByZXR1cm4gZmFsc2U7CisKKyAgaWYgKHVwcGVyID09IDApCisgICAg Kih1bnNpZ25lZCBsb25nICopIHBhcmFtc1swXSA9IHB2YWx1ZTsKKyAgZWxzZQorICAgIHsK KyAgICAgIGlmIChwdmFsdWUgPiB1cHBlcikKKwlwdmFsdWUgPSB1cHBlcjsKKyAgICAgIGlm ICh1cHBlciA8PSBVQ0hBUl9NQVgpCisJKih1bnNpZ25lZCBjaGFyICopIHBhcmFtc1swXSA9 IHB2YWx1ZTsKKyAgICAgIGVsc2UgaWYgKHVwcGVyIDw9IFVJTlRfTUFYKQorCSoodW5zaWdu ZWQgaW50ICopIHBhcmFtc1swXSA9IHB2YWx1ZTsKKyAgICAgIGVsc2UKKwkqKHVuc2lnbmVk IGxvbmcgKikgcGFyYW1zWzBdID0gcHZhbHVlOworICAgIH0KKworICByZXR1cm4gcmV0Owog fQogCiAvKiBQYXJzZSBhIHBvc2l0aXZlIGludCBlbnZpcm9ubWVudCB2YXJpYWJsZS4gIFJl dHVybiB0cnVlIGlmIG9uZSB3YXMKQEAgLTI2MSw1OCArMzIzLDU3IEBAIHBhcnNlX3Vuc2ln bmVkX2xvbmcgKGNvbnN0IGNoYXIgKm5hbWUsIHVuc2lnbmVkIGxvbmcgKnB2YWx1ZSwgYm9v bCBhbGxvd196ZXJvKQogICAgZW52aXJvbm1lbnQgdmFyaWFibGUuICAqLwogCiBzdGF0aWMg Ym9vbAotcGFyc2VfaW50XzEgKGNvbnN0IGNoYXIgKm5hbWUsIGludCAqcHZhbHVlLCBib29s IGFsbG93X3plcm8sIGJvb2wgc2VjdXJlKQorcGFyc2VfaW50XzEgKGNvbnN0IGNoYXIgKmVu diwgY29uc3QgY2hhciAqdmFsLCBpbnQgKnB2YWx1ZSwgYm9vbCBhbGxvd196ZXJvKQogewog ICB1bnNpZ25lZCBsb25nIHZhbHVlOwotICBpZiAoIXBhcnNlX3Vuc2lnbmVkX2xvbmdfMSAo bmFtZSwgJnZhbHVlLCBhbGxvd196ZXJvLCBzZWN1cmUpKQorICBpZiAoIXBhcnNlX3Vuc2ln bmVkX2xvbmdfMSAoZW52LCB2YWwsICZ2YWx1ZSwgYWxsb3dfemVybykpCiAgICAgcmV0dXJu IGZhbHNlOwogICBpZiAodmFsdWUgPiBJTlRfTUFYKQogICAgIHsKLSAgICAgIGdvbXBfZXJy b3IgKCJJbnZhbGlkIHZhbHVlIGZvciBlbnZpcm9ubWVudCB2YXJpYWJsZSAlcyIsIG5hbWUp OworICAgICAgcHJpbnRfZW52X3Zhcl9lcnJvciAoZW52LCB2YWwpOwogICAgICAgcmV0dXJu IGZhbHNlOwogICAgIH0KICAgKnB2YWx1ZSA9IChpbnQpIHZhbHVlOwogICByZXR1cm4gdHJ1 ZTsKIH0KIAotLyogQXMgcGFyc2VfaW50XzEsIGJ1dCB1c2UgZ2V0ZW52LiAgKi8KLQogc3Rh dGljIGJvb2wKLXBhcnNlX2ludCAoY29uc3QgY2hhciAqbmFtZSwgaW50ICpwdmFsdWUsIGJv b2wgYWxsb3dfemVybykKK3BhcnNlX2ludCAoY29uc3QgY2hhciAqZW52LCBjb25zdCBjaGFy ICp2YWwsIHZvaWQgKiBjb25zdCBwYXJhbXNbXSkKIHsKLSAgcmV0dXJuIHBhcnNlX2ludF8x IChuYW1lLCBwdmFsdWUsIGFsbG93X3plcm8sIGZhbHNlKTsKKyAgcmV0dXJuIHBhcnNlX2lu dF8xIChlbnYsIHZhbCwgKGludCAqKSBwYXJhbXNbMF0sIChib29sKSBwYXJhbXNbMV0pOwog fQogCiAvKiBBcyBwYXJzZV9pbnRfMSwgYnV0IHVzZSBnZXRlbnZfc2VjdXJlLiAgKi8KIAog c3RhdGljIGJvb2wKLXBhcnNlX2ludF9zZWN1cmUgKGNvbnN0IGNoYXIgKm5hbWUsIGludCAq cHZhbHVlLCBib29sIGFsbG93X3plcm8pCitwYXJzZV9pbnRfc2VjdXJlIChjb25zdCBjaGFy ICplbnYsIGludCAqcHZhbHVlLCBib29sIGFsbG93X3plcm8pCiB7Ci0gIHJldHVybiBwYXJz ZV9pbnRfMSAobmFtZSwgcHZhbHVlLCBhbGxvd196ZXJvLCB0cnVlKTsKKyAgcmV0dXJuIHBh cnNlX2ludF8xIChlbnYsIHNlY3VyZV9nZXRlbnYgKGVudiksIHB2YWx1ZSwgYWxsb3dfemVy byk7CiB9CiAKIC8qIFBhcnNlIGFuIHVuc2lnbmVkIGxvbmcgbGlzdCBlbnZpcm9ubWVudCB2 YXJpYWJsZS4gIFJldHVybiB0cnVlIGlmIG9uZSB3YXMKICAgIHByZXNlbnQgYW5kIGl0IHdh cyBzdWNjZXNzZnVsbHkgcGFyc2VkLiAgKi8KIAogc3RhdGljIGJvb2wKLXBhcnNlX3Vuc2ln bmVkX2xvbmdfbGlzdCAoY29uc3QgY2hhciAqbmFtZSwgdW5zaWduZWQgbG9uZyAqcDFzdHZh bHVlLAotCQkJICB1bnNpZ25lZCBsb25nICoqcHZhbHVlcywKLQkJCSAgdW5zaWduZWQgbG9u ZyAqcG52YWx1ZXMpCitwYXJzZV91bnNpZ25lZF9sb25nX2xpc3QgKGNvbnN0IGNoYXIgKmVu diwgY29uc3QgY2hhciAqdmFsLAorCQkJICB2b2lkICogY29uc3QgcGFyYW1zW10pCiB7Ci0g IGNoYXIgKmVudiwgKmVuZDsKKyAgdW5zaWduZWQgbG9uZyAqcDFzdHZhbHVlID0gKHVuc2ln bmVkIGxvbmcgKikgcGFyYW1zWzBdOworICB1bnNpZ25lZCBsb25nICoqcHZhbHVlcyA9ICh1 bnNpZ25lZCBsb25nICoqKSBwYXJhbXNbMV07CisgIHVuc2lnbmVkIGxvbmcgKnBudmFsdWVz ID0gKHVuc2lnbmVkIGxvbmcqKSBwYXJhbXNbMl07CisgIGNoYXIgKmVuZDsKICAgdW5zaWdu ZWQgbG9uZyB2YWx1ZSwgKnZhbHVlcyA9IE5VTEw7CiAKLSAgZW52ID0gZ2V0ZW52IChuYW1l KTsKLSAgaWYgKGVudiA9PSBOVUxMKQorICBpZiAodmFsID09IE5VTEwpCiAgICAgcmV0dXJu IGZhbHNlOwogCi0gIHdoaWxlIChpc3NwYWNlICgodW5zaWduZWQgY2hhcikgKmVudikpCi0g ICAgKytlbnY7Ci0gIGlmICgqZW52ID09ICdcMCcpCisgIHdoaWxlIChpc3NwYWNlICgodW5z aWduZWQgY2hhcikgKnZhbCkpCisgICAgKyt2YWw7CisgIGlmICgqdmFsID09ICdcMCcpCiAg ICAgZ290byBpbnZhbGlkOwogCiAgIGVycm5vID0gMDsKLSAgdmFsdWUgPSBzdHJ0b3VsIChl bnYsICZlbmQsIDEwKTsKKyAgdmFsdWUgPSBzdHJ0b3VsICh2YWwsICZlbmQsIDEwKTsKICAg aWYgKGVycm5vIHx8IChsb25nKSB2YWx1ZSA8PSAwKQogICAgIGdvdG8gaW52YWxpZDsKIApA QCAtMzI2LDcgKzM4Nyw3IEBAIHBhcnNlX3Vuc2lnbmVkX2xvbmdfbGlzdCAoY29uc3QgY2hh ciAqbmFtZSwgdW5zaWduZWQgbG9uZyAqcDFzdHZhbHVlLAogCiAJICBkbwogCSAgICB7Ci0J ICAgICAgZW52ID0gZW5kICsgMTsKKwkgICAgICB2YWwgPSBlbmQgKyAxOwogCSAgICAgIGlm IChudmFsdWVzID09IG5hbGxvY2VkKQogCQl7CiAJCSAgdW5zaWduZWQgbG9uZyAqbjsKQEAg LTMzNSw2ICszOTYsOSBAQCBwYXJzZV91bnNpZ25lZF9sb25nX2xpc3QgKGNvbnN0IGNoYXIg Km5hbWUsIHVuc2lnbmVkIGxvbmcgKnAxc3R2YWx1ZSwKIAkJICBpZiAobiA9PSBOVUxMKQog CQkgICAgewogCQkgICAgICBmcmVlICh2YWx1ZXMpOworCQkgICAgICBjaGFyIG5hbWVbdmFs IC0gZW52XTsKKwkJICAgICAgbWVtY3B5IChuYW1lLCBlbnYsIHZhbCAtIGVudiAtIDEpOwor CQkgICAgICBuYW1lW3ZhbCAtIGVudiAtIDFdID0gJ1wwJzsKIAkJICAgICAgZ29tcF9lcnJv ciAoIk91dCBvZiBtZW1vcnkgd2hpbGUgdHJ5aW5nIHRvIHBhcnNlIgogCQkJCSAgIiBlbnZp cm9ubWVudCB2YXJpYWJsZSAlcyIsIG5hbWUpOwogCQkgICAgICByZXR1cm4gZmFsc2U7CkBA IC0zNDQsMTMgKzQwOCwxMyBAQCBwYXJzZV91bnNpZ25lZF9sb25nX2xpc3QgKGNvbnN0IGNo YXIgKm5hbWUsIHVuc2lnbmVkIGxvbmcgKnAxc3R2YWx1ZSwKIAkJICAgIHZhbHVlc1tudmFs dWVzKytdID0gdmFsdWU7CiAJCX0KIAotCSAgICAgIHdoaWxlIChpc3NwYWNlICgodW5zaWdu ZWQgY2hhcikgKmVudikpCi0JCSsrZW52OwotCSAgICAgIGlmICgqZW52ID09ICdcMCcpCisJ ICAgICAgd2hpbGUgKGlzc3BhY2UgKCh1bnNpZ25lZCBjaGFyKSAqdmFsKSkKKwkJKyt2YWw7 CisJICAgICAgaWYgKCp2YWwgPT0gJ1wwJykKIAkJZ290byBpbnZhbGlkOwogCiAJICAgICAg ZXJybm8gPSAwOwotCSAgICAgIHZhbHVlID0gc3RydG91bCAoZW52LCAmZW5kLCAxMCk7CisJ ICAgICAgdmFsdWUgPSBzdHJ0b3VsICh2YWwsICZlbmQsIDEwKTsKIAkgICAgICBpZiAoZXJy bm8gfHwgKGxvbmcpIHZhbHVlIDw9IDApCiAJCWdvdG8gaW52YWxpZDsKIApAQCAtMzc2LDQ2 ICs0NDAsNDUgQEAgcGFyc2VfdW5zaWduZWRfbG9uZ19saXN0IChjb25zdCBjaGFyICpuYW1l LCB1bnNpZ25lZCBsb25nICpwMXN0dmFsdWUsCiAKICBpbnZhbGlkOgogICBmcmVlICh2YWx1 ZXMpOwotICBnb21wX2Vycm9yICgiSW52YWxpZCB2YWx1ZSBmb3IgZW52aXJvbm1lbnQgdmFy aWFibGUgJXMiLCBuYW1lKTsKKyAgcHJpbnRfZW52X3Zhcl9lcnJvciAoZW52LCB2YWwpOwog ICByZXR1cm4gZmFsc2U7CiB9CiAKLXN0YXRpYyB2b2lkCi1wYXJzZV90YXJnZXRfb2ZmbG9h ZCAoY29uc3QgY2hhciAqbmFtZSwgZW51bSBnb21wX3RhcmdldF9vZmZsb2FkX3QgKm9mZmxv YWQpCitzdGF0aWMgYm9vbAorcGFyc2VfdGFyZ2V0X29mZmxvYWQgKGNvbnN0IGNoYXIgKmVu diwgY29uc3QgY2hhciAqdmFsLCB2b2lkICogY29uc3QgcGFyYW1zW10pCiB7Ci0gIGNvbnN0 IGNoYXIgKmVudjsKICAgaW50IG5ld19vZmZsb2FkID0gLTE7CiAKLSAgZW52ID0gZ2V0ZW52 IChuYW1lKTsKLSAgaWYgKGVudiA9PSBOVUxMKQotICAgIHJldHVybjsKKyAgaWYgKHZhbCA9 PSBOVUxMKQorICAgIHJldHVybiBmYWxzZTsKIAotICB3aGlsZSAoaXNzcGFjZSAoKHVuc2ln bmVkIGNoYXIpICplbnYpKQotICAgICsrZW52OwotICBpZiAoc3RybmNhc2VjbXAgKGVudiwg ImRlZmF1bHQiLCA3KSA9PSAwKQorICB3aGlsZSAoaXNzcGFjZSAoKHVuc2lnbmVkIGNoYXIp ICp2YWwpKQorICAgICsrdmFsOworICBpZiAoc3RybmNhc2VjbXAgKHZhbCwgImRlZmF1bHQi LCA3KSA9PSAwKQogICAgIHsKLSAgICAgIGVudiArPSA3OworICAgICAgdmFsICs9IDc7CiAg ICAgICBuZXdfb2ZmbG9hZCA9IEdPTVBfVEFSR0VUX09GRkxPQURfREVGQVVMVDsKICAgICB9 Ci0gIGVsc2UgaWYgKHN0cm5jYXNlY21wIChlbnYsICJtYW5kYXRvcnkiLCA5KSA9PSAwKQor ICBlbHNlIGlmIChzdHJuY2FzZWNtcCAodmFsLCAibWFuZGF0b3J5IiwgOSkgPT0gMCkKICAg ICB7Ci0gICAgICBlbnYgKz0gOTsKKyAgICAgIHZhbCArPSA5OwogICAgICAgbmV3X29mZmxv YWQgPSBHT01QX1RBUkdFVF9PRkZMT0FEX01BTkRBVE9SWTsKICAgICB9Ci0gIGVsc2UgaWYg KHN0cm5jYXNlY21wIChlbnYsICJkaXNhYmxlZCIsIDgpID09IDApCisgIGVsc2UgaWYgKHN0 cm5jYXNlY21wICh2YWwsICJkaXNhYmxlZCIsIDgpID09IDApCiAgICAgewotICAgICAgZW52 ICs9IDg7CisgICAgICB2YWwgKz0gODsKICAgICAgIG5ld19vZmZsb2FkID0gR09NUF9UQVJH RVRfT0ZGTE9BRF9ESVNBQkxFRDsKICAgICB9Ci0gIHdoaWxlIChpc3NwYWNlICgodW5zaWdu ZWQgY2hhcikgKmVudikpCi0gICAgKytlbnY7Ci0gIGlmIChuZXdfb2ZmbG9hZCAhPSAtMSAm JiAqZW52ID09ICdcMCcpCisgIHdoaWxlIChpc3NwYWNlICgodW5zaWduZWQgY2hhcikgKnZh bCkpCisgICAgKyt2YWw7CisgIGlmIChuZXdfb2ZmbG9hZCAhPSAtMSAmJiAqdmFsID09ICdc MCcpCiAgICAgewotICAgICAgKm9mZmxvYWQgPSBuZXdfb2ZmbG9hZDsKLSAgICAgIHJldHVy bjsKKyAgICAgICooZW51bSBnb21wX3RhcmdldF9vZmZsb2FkX3QgKikgcGFyYW1zWzBdID0g bmV3X29mZmxvYWQ7CisgICAgICByZXR1cm4gdHJ1ZTsKICAgICB9CiAKLSAgZ29tcF9lcnJv ciAoIkludmFsaWQgdmFsdWUgZm9yIGVudmlyb25tZW50IHZhcmlhYmxlIE9NUF9UQVJHRVRf T0ZGTE9BRCIpOworICBwcmludF9lbnZfdmFyX2Vycm9yIChlbnYsIHZhbCk7CisgIHJldHVy biBmYWxzZTsKIH0KIAogLyogUGFyc2UgZW52aXJvbm1lbnQgdmFyaWFibGUgc2V0IHRvIGEg Ym9vbGVhbiBvciBsaXN0IG9mIG9tcF9wcm9jX2JpbmRfdApAQCAtNDIzLDEwICs0ODYsMTEg QEAgcGFyc2VfdGFyZ2V0X29mZmxvYWQgKGNvbnN0IGNoYXIgKm5hbWUsIGVudW0gZ29tcF90 YXJnZXRfb2ZmbG9hZF90ICpvZmZsb2FkKQogICAgcGFyc2VkLiAgKi8KIAogc3RhdGljIGJv b2wKLXBhcnNlX2JpbmRfdmFyIChjb25zdCBjaGFyICpuYW1lLCBjaGFyICpwMXN0dmFsdWUs Ci0JCWNoYXIgKipwdmFsdWVzLCB1bnNpZ25lZCBsb25nICpwbnZhbHVlcykKK3BhcnNlX2Jp bmRfdmFyIChjb25zdCBjaGFyICplbnYsIGNvbnN0IGNoYXIgKnZhbCwgdm9pZCAqIGNvbnN0 IHBhcmFtc1tdKQogewotICBjaGFyICplbnY7CisgIGNoYXIgKnAxc3R2YWx1ZSA9IChjaGFy ICopIHBhcmFtc1swXTsKKyAgY2hhciAqKnB2YWx1ZXMgPSAoY2hhciAqKikgcGFyYW1zWzFd OworICB1bnNpZ25lZCBsb25nICpwbnZhbHVlcyA9ICh1bnNpZ25lZCBsb25nICopIHBhcmFt c1syXTsKICAgY2hhciB2YWx1ZSA9IG9tcF9wcm9jX2JpbmRfZmFsc2UsICp2YWx1ZXMgPSBO VUxMOwogICBpbnQgaTsKICAgc3RhdGljIHN0cnVjdCBwcm9jX2JpbmRfa2luZHMKQEAgLTQ0 NCwzMCArNTA4LDI5IEBAIHBhcnNlX2JpbmRfdmFyIChjb25zdCBjaGFyICpuYW1lLCBjaGFy ICpwMXN0dmFsdWUsCiAgICAgeyAic3ByZWFkIiwgNiwgb21wX3Byb2NfYmluZF9zcHJlYWQg fQogICB9OwogCi0gIGVudiA9IGdldGVudiAobmFtZSk7Ci0gIGlmIChlbnYgPT0gTlVMTCkK KyAgaWYgKHZhbCA9PSBOVUxMKQogICAgIHJldHVybiBmYWxzZTsKIAotICB3aGlsZSAoaXNz cGFjZSAoKHVuc2lnbmVkIGNoYXIpICplbnYpKQotICAgICsrZW52OwotICBpZiAoKmVudiA9 PSAnXDAnKQorICB3aGlsZSAoaXNzcGFjZSAoKHVuc2lnbmVkIGNoYXIpICp2YWwpKQorICAg ICsrdmFsOworICBpZiAoKnZhbCA9PSAnXDAnKQogICAgIGdvdG8gaW52YWxpZDsKIAogICBm b3IgKGkgPSAwOyBpIDwgNjsgaSsrKQotICAgIGlmIChzdHJuY2FzZWNtcCAoZW52LCBraW5k c1tpXS5uYW1lLCBraW5kc1tpXS5sZW4pID09IDApCisgICAgaWYgKHN0cm5jYXNlY21wICh2 YWwsIGtpbmRzW2ldLm5hbWUsIGtpbmRzW2ldLmxlbikgPT0gMCkKICAgICAgIHsKIAl2YWx1 ZSA9IGtpbmRzW2ldLmtpbmQ7Ci0JZW52ICs9IGtpbmRzW2ldLmxlbjsKKwl2YWwgKz0ga2lu ZHNbaV0ubGVuOwogCWJyZWFrOwogICAgICAgfQogICBpZiAoaSA9PSA2KQogICAgIGdvdG8g aW52YWxpZDsKIAotICB3aGlsZSAoaXNzcGFjZSAoKHVuc2lnbmVkIGNoYXIpICplbnYpKQot ICAgICsrZW52OwotICBpZiAoKmVudiAhPSAnXDAnKQorICB3aGlsZSAoaXNzcGFjZSAoKHVu c2lnbmVkIGNoYXIpICp2YWwpKQorICAgICsrdmFsOworICBpZiAoKnZhbCAhPSAnXDAnKQog ICAgIHsKLSAgICAgIGlmICgqZW52ID09ICcsJykKKyAgICAgIGlmICgqdmFsID09ICcsJykK IAl7CiAJICB1bnNpZ25lZCBsb25nIG52YWx1ZXMgPSAwLCBuYWxsb2NlZCA9IDA7CiAKQEAg LTQ3Nyw3ICs1NDAsNyBAQCBwYXJzZV9iaW5kX3ZhciAoY29uc3QgY2hhciAqbmFtZSwgY2hh ciAqcDFzdHZhbHVlLAogCiAJICBkbwogCSAgICB7Ci0JICAgICAgZW52Kys7CisJICAgICAg dmFsKys7CiAJICAgICAgaWYgKG52YWx1ZXMgPT0gbmFsbG9jZWQpCiAJCXsKIAkJICBjaGFy ICpuOwpAQCAtNDg2LDYgKzU0OSw5IEBAIHBhcnNlX2JpbmRfdmFyIChjb25zdCBjaGFyICpu YW1lLCBjaGFyICpwMXN0dmFsdWUsCiAJCSAgaWYgKG4gPT0gTlVMTCkKIAkJICAgIHsKIAkJ ICAgICAgZnJlZSAodmFsdWVzKTsKKwkJICAgICAgY2hhciBuYW1lW3ZhbCAtIGVudl07CisJ CSAgICAgIG1lbWNweSAobmFtZSwgZW52LCB2YWwgLSBlbnYgLSAxKTsKKwkJICAgICAgbmFt ZVt2YWwgLSBlbnYgLSAxXSA9ICdcMCc7CiAJCSAgICAgIGdvbXBfZXJyb3IgKCJPdXQgb2Yg bWVtb3J5IHdoaWxlIHRyeWluZyB0byBwYXJzZSIKIAkJCQkgICIgZW52aXJvbm1lbnQgdmFy aWFibGUgJXMiLCBuYW1lKTsKIAkJICAgICAgcmV0dXJuIGZhbHNlOwpAQCAtNDk1LDI3ICs1 NjEsMjcgQEAgcGFyc2VfYmluZF92YXIgKGNvbnN0IGNoYXIgKm5hbWUsIGNoYXIgKnAxc3R2 YWx1ZSwKIAkJICAgIHZhbHVlc1tudmFsdWVzKytdID0gdmFsdWU7CiAJCX0KIAotCSAgICAg IHdoaWxlIChpc3NwYWNlICgodW5zaWduZWQgY2hhcikgKmVudikpCi0JCSsrZW52OwotCSAg ICAgIGlmICgqZW52ID09ICdcMCcpCisJICAgICAgd2hpbGUgKGlzc3BhY2UgKCh1bnNpZ25l ZCBjaGFyKSAqdmFsKSkKKwkJKyt2YWw7CisJICAgICAgaWYgKCp2YWwgPT0gJ1wwJykKIAkJ Z290byBpbnZhbGlkOwogCiAJICAgICAgZm9yIChpID0gMjsgaSA8IDY7IGkrKykKLQkJaWYg KHN0cm5jYXNlY21wIChlbnYsIGtpbmRzW2ldLm5hbWUsIGtpbmRzW2ldLmxlbikgPT0gMCkK KwkJaWYgKHN0cm5jYXNlY21wICh2YWwsIGtpbmRzW2ldLm5hbWUsIGtpbmRzW2ldLmxlbikg PT0gMCkKIAkJICB7CiAJCSAgICB2YWx1ZSA9IGtpbmRzW2ldLmtpbmQ7Ci0JCSAgICBlbnYg Kz0ga2luZHNbaV0ubGVuOworCQkgICAgdmFsICs9IGtpbmRzW2ldLmxlbjsKIAkJICAgIGJy ZWFrOwogCQkgIH0KIAkgICAgICBpZiAoaSA9PSA2KQogCQlnb3RvIGludmFsaWQ7CiAKIAkg ICAgICB2YWx1ZXNbbnZhbHVlcysrXSA9IHZhbHVlOwotCSAgICAgIHdoaWxlIChpc3NwYWNl ICgodW5zaWduZWQgY2hhcikgKmVudikpCi0JCSsrZW52OwotCSAgICAgIGlmICgqZW52ID09 ICdcMCcpCisJICAgICAgd2hpbGUgKGlzc3BhY2UgKCh1bnNpZ25lZCBjaGFyKSAqdmFsKSkK KwkJKyt2YWw7CisJICAgICAgaWYgKCp2YWwgPT0gJ1wwJykKIAkJYnJlYWs7Ci0JICAgICAg aWYgKCplbnYgIT0gJywnKQorCSAgICAgIGlmICgqdmFsICE9ICcsJykKIAkJZ290byBpbnZh bGlkOwogCSAgICB9CiAJICB3aGlsZSAoMSk7CkBAIC01MzIsNyArNTk4LDcgQEAgcGFyc2Vf YmluZF92YXIgKGNvbnN0IGNoYXIgKm5hbWUsIGNoYXIgKnAxc3R2YWx1ZSwKIAogIGludmFs aWQ6CiAgIGZyZWUgKHZhbHVlcyk7Ci0gIGdvbXBfZXJyb3IgKCJJbnZhbGlkIHZhbHVlIGZv ciBlbnZpcm9ubWVudCB2YXJpYWJsZSAlcyIsIG5hbWUpOworICBwcmludF9lbnZfdmFyX2Vy cm9yIChlbnYsIHZhbCk7CiAgIHJldHVybiBmYWxzZTsKIH0KIApAQCAtODY1LDIzICs5MzEs MjIgQEAgcGFyc2VfcGxhY2VzX3ZhciAoY29uc3QgY2hhciAqbmFtZSwgYm9vbCBpZ25vcmUp CiAgICBwcmVzZW50IGFuZCBpdCB3YXMgc3VjY2Vzc2Z1bGx5IHBhcnNlZC4gICovCiAKIHN0 YXRpYyBib29sCi1wYXJzZV9zdGFja3NpemUgKGNvbnN0IGNoYXIgKm5hbWUsIHVuc2lnbmVk IGxvbmcgKnB2YWx1ZSkKK3BhcnNlX3N0YWNrc2l6ZSAoY29uc3QgY2hhciAqZW52LCBjb25z dCBjaGFyICp2YWwsIHZvaWQgKiBjb25zdCBwYXJhbXNbXSkKIHsKLSAgY2hhciAqZW52LCAq ZW5kOworICBjaGFyICplbmQ7CiAgIHVuc2lnbmVkIGxvbmcgdmFsdWUsIHNoaWZ0ID0gMTA7 CiAKLSAgZW52ID0gZ2V0ZW52IChuYW1lKTsKLSAgaWYgKGVudiA9PSBOVUxMKQorICBpZiAo dmFsID09IE5VTEwpCiAgICAgcmV0dXJuIGZhbHNlOwogCi0gIHdoaWxlIChpc3NwYWNlICgo dW5zaWduZWQgY2hhcikgKmVudikpCi0gICAgKytlbnY7Ci0gIGlmICgqZW52ID09ICdcMCcp CisgIHdoaWxlIChpc3NwYWNlICgodW5zaWduZWQgY2hhcikgKnZhbCkpCisgICAgKyt2YWw7 CisgIGlmICgqdmFsID09ICdcMCcpCiAgICAgZ290byBpbnZhbGlkOwogCiAgIGVycm5vID0g MDsKLSAgdmFsdWUgPSBzdHJ0b3VsIChlbnYsICZlbmQsIDEwKTsKLSAgaWYgKGVycm5vIHx8 IGVuZCA9PSBlbnYpCisgIHZhbHVlID0gc3RydG91bCAodmFsLCAmZW5kLCAxMCk7CisgIGlm IChlcnJubyB8fCBlbmQgPT0gdmFsKQogICAgIGdvdG8gaW52YWxpZDsKIAogICB3aGlsZSAo aXNzcGFjZSAoKHVuc2lnbmVkIGNoYXIpICplbmQpKQpAQCAtOTE0LDExICs5NzksMTEgQEAg cGFyc2Vfc3RhY2tzaXplIChjb25zdCBjaGFyICpuYW1lLCB1bnNpZ25lZCBsb25nICpwdmFs dWUpCiAgIGlmICgoKHZhbHVlIDw8IHNoaWZ0KSA+PiBzaGlmdCkgIT0gdmFsdWUpCiAgICAg Z290byBpbnZhbGlkOwogCi0gICpwdmFsdWUgPSB2YWx1ZSA8PCBzaGlmdDsKKyAgKih1bnNp Z25lZCBsb25nICopIHBhcmFtc1swXSA9IHZhbHVlIDw8IHNoaWZ0OwogICByZXR1cm4gdHJ1 ZTsKIAogIGludmFsaWQ6Ci0gIGdvbXBfZXJyb3IgKCJJbnZhbGlkIHZhbHVlIGZvciBlbnZp cm9ubWVudCB2YXJpYWJsZSAlcyIsIG5hbWUpOworICBwcmludF9lbnZfdmFyX2Vycm9yIChl bnYsIHZhbCk7CiAgIHJldHVybiBmYWxzZTsKIH0KIApAQCAtOTk4LDM1ICsxMDYzLDMzIEBA IHBhcnNlX3NwaW5jb3VudCAoY29uc3QgY2hhciAqbmFtZSwgdW5zaWduZWQgbG9uZyBsb25n ICpwdmFsdWUpCiAvKiBQYXJzZSBhIGJvb2xlYW4gdmFsdWUgZm9yIGVudmlyb25tZW50IHZh cmlhYmxlIE5BTUUgYW5kIHN0b3JlIHRoZQogICAgcmVzdWx0IGluIFZBTFVFLiAgUmV0dXJu IHRydWUgaWYgb25lIHdhcyBwcmVzZW50IGFuZCBpdCB3YXMKICAgIHN1Y2Nlc3NmdWxseSBw YXJzZWQuICAqLwotCiBzdGF0aWMgYm9vbAotcGFyc2VfYm9vbGVhbiAoY29uc3QgY2hhciAq bmFtZSwgYm9vbCAqdmFsdWUpCitwYXJzZV9ib29sZWFuIChjb25zdCBjaGFyICplbnYsIGNv bnN0IGNoYXIgKnZhbCwgdm9pZCAqIGNvbnN0IHBhcmFtc1tdKQogewotICBjb25zdCBjaGFy ICplbnY7CisgIGJvb2wgKnZhbHVlID0gKGJvb2wgKikgcGFyYW1zWzBdOwogCi0gIGVudiA9 IGdldGVudiAobmFtZSk7Ci0gIGlmIChlbnYgPT0gTlVMTCkKKyAgaWYgKHZhbCA9PSBOVUxM KQogICAgIHJldHVybiBmYWxzZTsKIAotICB3aGlsZSAoaXNzcGFjZSAoKHVuc2lnbmVkIGNo YXIpICplbnYpKQotICAgICsrZW52OwotICBpZiAoc3RybmNhc2VjbXAgKGVudiwgInRydWUi LCA0KSA9PSAwKQorICB3aGlsZSAoaXNzcGFjZSAoKHVuc2lnbmVkIGNoYXIpICp2YWwpKQor ICAgICsrdmFsOworICBpZiAoc3RybmNhc2VjbXAgKHZhbCwgInRydWUiLCA0KSA9PSAwKQog ICAgIHsKICAgICAgICp2YWx1ZSA9IHRydWU7Ci0gICAgICBlbnYgKz0gNDsKKyAgICAgIHZh bCArPSA0OwogICAgIH0KLSAgZWxzZSBpZiAoc3RybmNhc2VjbXAgKGVudiwgImZhbHNlIiwg NSkgPT0gMCkKKyAgZWxzZSBpZiAoc3RybmNhc2VjbXAgKHZhbCwgImZhbHNlIiwgNSkgPT0g MCkKICAgICB7CiAgICAgICAqdmFsdWUgPSBmYWxzZTsKLSAgICAgIGVudiArPSA1OworICAg ICAgdmFsICs9IDU7CiAgICAgfQogICBlbHNlCi0gICAgZW52ID0gIlgiOwotICB3aGlsZSAo aXNzcGFjZSAoKHVuc2lnbmVkIGNoYXIpICplbnYpKQotICAgICsrZW52OwotICBpZiAoKmVu diAhPSAnXDAnKQorICAgIHZhbCA9ICJYIjsKKyAgd2hpbGUgKGlzc3BhY2UgKCh1bnNpZ25l ZCBjaGFyKSAqdmFsKSkKKyAgICArK3ZhbDsKKyAgaWYgKCp2YWwgIT0gJ1wwJykKICAgICB7 Ci0gICAgICBnb21wX2Vycm9yICgiSW52YWxpZCB2YWx1ZSBmb3IgZW52aXJvbm1lbnQgdmFy aWFibGUgJXMiLCBuYW1lKTsKKyAgICAgIHByaW50X2Vudl92YXJfZXJyb3IgKGVudiwgdmFs KTsKICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAgIHJldHVybiB0cnVlOwpAQCAtMTAz NCwzNiArMTA5Nyw0MiBAQCBwYXJzZV9ib29sZWFuIChjb25zdCBjaGFyICpuYW1lLCBib29s ICp2YWx1ZSkKIAogLyogUGFyc2UgdGhlIE9NUF9XQUlUX1BPTElDWSBlbnZpcm9ubWVudCB2 YXJpYWJsZSBhbmQgcmV0dXJuIHRoZSB2YWx1ZS4gICovCiAKLXN0YXRpYyBpbnQKLXBhcnNl X3dhaXRfcG9saWN5ICh2b2lkKQorc3RhdGljIGJvb2wKK3BhcnNlX3dhaXRfcG9saWN5IChj b25zdCBjaGFyICplbnYsIGNvbnN0IGNoYXIgKnZhbCwgdm9pZCAqIGNvbnN0IHBhcmFtc1td KQogewotICBjb25zdCBjaGFyICplbnY7CisgIGludCAqcHZhbHVlID0gKGludCAqKSBwYXJh bXNbMF07CiAgIGludCByZXQgPSAtMTsKIAotICBlbnYgPSBnZXRlbnYgKCJPTVBfV0FJVF9Q T0xJQ1kiKTsKLSAgaWYgKGVudiA9PSBOVUxMKQotICAgIHJldHVybiAtMTsKKyAgaWYgKHZh bCA9PSBOVUxMKQorICB7CisgICAgKnB2YWx1ZSA9IC0xOworICAgIHJldHVybiBmYWxzZTsK KyAgfQogCi0gIHdoaWxlIChpc3NwYWNlICgodW5zaWduZWQgY2hhcikgKmVudikpCi0gICAg KytlbnY7Ci0gIGlmIChzdHJuY2FzZWNtcCAoZW52LCAiYWN0aXZlIiwgNikgPT0gMCkKKyAg d2hpbGUgKGlzc3BhY2UgKCh1bnNpZ25lZCBjaGFyKSAqdmFsKSkKKyAgICArK3ZhbDsKKyAg aWYgKHN0cm5jYXNlY21wICh2YWwsICJhY3RpdmUiLCA2KSA9PSAwKQogICAgIHsKICAgICAg IHJldCA9IDE7Ci0gICAgICBlbnYgKz0gNjsKKyAgICAgIHZhbCArPSA2OwogICAgIH0KLSAg ZWxzZSBpZiAoc3RybmNhc2VjbXAgKGVudiwgInBhc3NpdmUiLCA3KSA9PSAwKQorICBlbHNl IGlmIChzdHJuY2FzZWNtcCAodmFsLCAicGFzc2l2ZSIsIDcpID09IDApCiAgICAgewogICAg ICAgcmV0ID0gMDsKLSAgICAgIGVudiArPSA3OworICAgICAgdmFsICs9IDc7CiAgICAgfQog ICBlbHNlCi0gICAgZW52ID0gIlgiOwotICB3aGlsZSAoaXNzcGFjZSAoKHVuc2lnbmVkIGNo YXIpICplbnYpKQotICAgICsrZW52OwotICBpZiAoKmVudiA9PSAnXDAnKQotICAgIHJldHVy biByZXQ7Ci0gIGdvbXBfZXJyb3IgKCJJbnZhbGlkIHZhbHVlIGZvciBlbnZpcm9ubWVudCB2 YXJpYWJsZSBPTVBfV0FJVF9QT0xJQ1kiKTsKLSAgcmV0dXJuIC0xOworICAgIHZhbCA9ICJY IjsKKyAgd2hpbGUgKGlzc3BhY2UgKCh1bnNpZ25lZCBjaGFyKSAqdmFsKSkKKyAgICArK3Zh bDsKKyAgaWYgKCp2YWwgPT0gJ1wwJykKKyAgICB7CisgICAgICAqcHZhbHVlID0gcmV0Owor ICAgICAgcmV0dXJuIHRydWU7CisgICAgfQorICBwcmludF9lbnZfdmFyX2Vycm9yIChlbnYs IHZhbCk7CisgICpwdmFsdWUgPSAtMTsKKyAgcmV0dXJuIGZhbHNlOwogfQogCiAvKiBQYXJz ZSB0aGUgR09NUF9DUFVfQUZGSU5JVFkgZW52aXJvbm1lbnQgdmFyaWJsZS4gIFJldHVybiB0 cnVlIGlmIG9uZSB3YXMKQEAgLTExNjcsMjYgKzEyMzYsMjQgQEAgcGFyc2VfYWZmaW5pdHkg KGJvb2wgaWdub3JlKQogfQogCiAvKiBQYXJzZSB0aGUgT01QX0FMTE9DQVRPUiBlbnZpcm9u bWVudCB2YXJpYWJsZSBhbmQgcmV0dXJuIHRoZSB2YWx1ZS4gICovCi0KLXN0YXRpYyB1aW50 cHRyX3QKLXBhcnNlX2FsbG9jYXRvciAodm9pZCkKK3N0YXRpYyBib29sCitwYXJzZV9hbGxv Y2F0b3IgKGNvbnN0IGNoYXIgKmVudiwgY29uc3QgY2hhciAqdmFsLCB2b2lkICogY29uc3Qg cGFyYW1zW10pCiB7Ci0gIGNvbnN0IGNoYXIgKmVudjsKLSAgdWludHB0cl90IHJldCA9IG9t cF9kZWZhdWx0X21lbV9hbGxvYzsKKyAgdWludHB0cl90ICpyZXQgPSAodWludHB0cl90ICop IHBhcmFtc1swXTsKKyAgKnJldCA9IG9tcF9kZWZhdWx0X21lbV9hbGxvYzsKIAotICBlbnYg PSBnZXRlbnYgKCJPTVBfQUxMT0NBVE9SIik7Ci0gIGlmIChlbnYgPT0gTlVMTCkKLSAgICBy ZXR1cm4gcmV0OworICBpZiAodmFsID09IE5VTEwpCisgICAgcmV0dXJuIGZhbHNlOwogCi0g IHdoaWxlIChpc3NwYWNlICgodW5zaWduZWQgY2hhcikgKmVudikpCi0gICAgKytlbnY7Cisg IHdoaWxlIChpc3NwYWNlICgodW5zaWduZWQgY2hhcikgKnZhbCkpCisgICAgKyt2YWw7CiAg IGlmICgwKQogICAgIDsKICNkZWZpbmUgQyh2KSBcCi0gIGVsc2UgaWYgKHN0cm5jYXNlY21w IChlbnYsICN2LCBzaXplb2YgKCN2KSAtIDEpID09IDApCVwKKyAgZWxzZSBpZiAoc3RybmNh c2VjbXAgKHZhbCwgI3YsIHNpemVvZiAoI3YpIC0gMSkgPT0gMCkJXAogICAgIHsJCQkJCQkJ XAotICAgICAgcmV0ID0gdjsJCQkJCQlcCi0gICAgICBlbnYgKz0gc2l6ZW9mICgjdikgLSAx OwkJCQlcCisgICAgICAqcmV0ID0gdjsJCQkJCQlcCisgICAgICB2YWwgKz0gc2l6ZW9mICgj dikgLSAxOwkJCQlcCiAgICAgfQogICBDIChvbXBfZGVmYXVsdF9tZW1fYWxsb2MpCiAgIEMg KG9tcF9sYXJnZV9jYXBfbWVtX2FsbG9jKQpAQCAtMTE5OCwxMyArMTI2NSwxNCBAQCBwYXJz ZV9hbGxvY2F0b3IgKHZvaWQpCiAgIEMgKG9tcF90aHJlYWRfbWVtX2FsbG9jKQogI3VuZGVm IEMKICAgZWxzZQotICAgIGVudiA9ICJYIjsKLSAgd2hpbGUgKGlzc3BhY2UgKCh1bnNpZ25l ZCBjaGFyKSAqZW52KSkKLSAgICArK2VudjsKLSAgaWYgKCplbnYgPT0gJ1wwJykKLSAgICBy ZXR1cm4gcmV0OwotICBnb21wX2Vycm9yICgiSW52YWxpZCB2YWx1ZSBmb3IgZW52aXJvbm1l bnQgdmFyaWFibGUgT01QX0FMTE9DQVRPUiIpOwotICByZXR1cm4gb21wX2RlZmF1bHRfbWVt X2FsbG9jOworICAgIHZhbCA9ICJYIjsKKyAgd2hpbGUgKGlzc3BhY2UgKCh1bnNpZ25lZCBj aGFyKSAqdmFsKSkKKyAgICArK3ZhbDsKKyAgaWYgKCp2YWwgPT0gJ1wwJykKKyAgICByZXR1 cm4gdHJ1ZTsKKyAgcHJpbnRfZW52X3Zhcl9lcnJvciAoZW52LCB2YWwpOworICAqcmV0ID0g b21wX2RlZmF1bHRfbWVtX2FsbG9jOworICByZXR1cm4gZmFsc2U7CiB9CiAKIHN0YXRpYyB2 b2lkCkBAIC0xMjUxLDYyICsxMzE5LDU5IEBAIHBhcnNlX2dvbXBfb3BlbmFjY19kaW0gKHZv aWQpCiAgICAgfQogfQogCi12b2lkCi1vbXBfZGlzcGxheV9lbnYgKGludCB2ZXJib3NlKQot ewotICBpbnQgaTsKLQotICBmcHV0cyAoIlxuT1BFTk1QIERJU1BMQVkgRU5WSVJPTk1FTlQg QkVHSU5cbiIsIHN0ZGVycik7Ci0KLSAgZnB1dHMgKCIgIF9PUEVOTVAgPSAnMjAxNTExJ1xu Iiwgc3RkZXJyKTsKLSAgZnByaW50ZiAoc3RkZXJyLCAiICBPTVBfRFlOQU1JQyA9ICclcydc biIsCi0JICAgZ29tcF9nbG9iYWxfaWN2LmR5bl92YXIgPyAiVFJVRSIgOiAiRkFMU0UiKTsK LSAgZnByaW50ZiAoc3RkZXJyLCAiICBPTVBfTkVTVEVEID0gJyVzJ1xuIiwKLQkgICBnb21w X2dsb2JhbF9pY3YubWF4X2FjdGl2ZV9sZXZlbHNfdmFyID4gMSA/ICJUUlVFIiA6ICJGQUxT RSIpOwotCi0gIGZwcmludGYgKHN0ZGVyciwgIiAgT01QX05VTV9USFJFQURTID0gJyVsdSIs IGdvbXBfZ2xvYmFsX2ljdi5udGhyZWFkc192YXIpOwotICBmb3IgKGkgPSAxOyBpIDwgZ29t cF9udGhyZWFkc192YXJfbGlzdF9sZW47IGkrKykKLSAgICBmcHJpbnRmIChzdGRlcnIsICIs JWx1IiwgZ29tcF9udGhyZWFkc192YXJfbGlzdFtpXSk7Ci0gIGZwdXRzICgiJ1xuIiwgc3Rk ZXJyKTsKKy8qIEhlbHBlciBmdW5jdGlvbiBmb3Igb21wX2Rpc3BsYXlfZW52IHdoaWNoIHBy aW50cyB0aGUgdmFsdWVzIG9mIHJ1bl9zY2hlZF92YXIuCisgICAnZGV2aWNlJyBjYW4gYmUg J2hvc3QnLCAnZGV2JywgJ2FsbCcgb3IgYSBwYXJ0aWN1bGFyIGRldmljZSBudW1iZXIuICAq LwogCi0gIGZwcmludGYgKHN0ZGVyciwgIiAgT01QX1NDSEVEVUxFID0gJyIpOwotICBpZiAo KGdvbXBfZ2xvYmFsX2ljdi5ydW5fc2NoZWRfdmFyICYgR0ZTX01PTk9UT05JQykpCitzdGF0 aWMgdm9pZAorcHJpbnRfc2NoZWR1bGUgKGVudW0gZ29tcF9zY2hlZHVsZV90eXBlIHJ1bl9z Y2hlZF92YXIsIGludCBydW5fc2NoZWRfY2h1bmtfc2l6ZSwKKwkJY29uc3QgY2hhciAqZGV2 aWNlKQoreworICBmcHJpbnRmIChzdGRlcnIsICIgIFslc10gT01QX1NDSEVEVUxFID0gJyIs IGRldmljZSk7CisgIGlmICgocnVuX3NjaGVkX3ZhciAmIEdGU19NT05PVE9OSUMpKQogICAg IHsKLSAgICAgIGlmIChnb21wX2dsb2JhbF9pY3YucnVuX3NjaGVkX3ZhciAhPSAoR0ZTX01P Tk9UT05JQyB8IEdGU19TVEFUSUMpKQorICAgICAgaWYgKHJ1bl9zY2hlZF92YXIgIT0gKEdG U19NT05PVE9OSUMgfCBHRlNfU1RBVElDKSkKIAlmcHV0cyAoIk1PTk9UT05JQzoiLCBzdGRl cnIpOwogICAgIH0KLSAgZWxzZSBpZiAoZ29tcF9nbG9iYWxfaWN2LnJ1bl9zY2hlZF92YXIg PT0gR0ZTX1NUQVRJQykKKyAgZWxzZSBpZiAocnVuX3NjaGVkX3ZhciA9PSBHRlNfU1RBVElD KQogICAgIGZwdXRzICgiTk9OTU9OT1RPTklDOiIsIHN0ZGVycik7Ci0gIHN3aXRjaCAoZ29t cF9nbG9iYWxfaWN2LnJ1bl9zY2hlZF92YXIgJiB+R0ZTX01PTk9UT05JQykKKyAgc3dpdGNo IChydW5fc2NoZWRfdmFyICYgfkdGU19NT05PVE9OSUMpCiAgICAgewogICAgIGNhc2UgR0ZT X1JVTlRJTUU6CiAgICAgICBmcHV0cyAoIlJVTlRJTUUiLCBzdGRlcnIpOwotICAgICAgaWYg KGdvbXBfZ2xvYmFsX2ljdi5ydW5fc2NoZWRfY2h1bmtfc2l6ZSAhPSAxKQotCWZwcmludGYg KHN0ZGVyciwgIiwlZCIsIGdvbXBfZ2xvYmFsX2ljdi5ydW5fc2NoZWRfY2h1bmtfc2l6ZSk7 CisgICAgICBpZiAocnVuX3NjaGVkX2NodW5rX3NpemUgIT0gMSkKKwlmcHJpbnRmIChzdGRl cnIsICIsJWQiLCBydW5fc2NoZWRfY2h1bmtfc2l6ZSk7CiAgICAgICBicmVhazsKICAgICBj YXNlIEdGU19TVEFUSUM6CiAgICAgICBmcHV0cyAoIlNUQVRJQyIsIHN0ZGVycik7Ci0gICAg ICBpZiAoZ29tcF9nbG9iYWxfaWN2LnJ1bl9zY2hlZF9jaHVua19zaXplICE9IDApCi0JZnBy aW50ZiAoc3RkZXJyLCAiLCVkIiwgZ29tcF9nbG9iYWxfaWN2LnJ1bl9zY2hlZF9jaHVua19z aXplKTsKKyAgICAgIGlmIChydW5fc2NoZWRfY2h1bmtfc2l6ZSAhPSAwKQorCWZwcmludGYg KHN0ZGVyciwgIiwlZCIsIHJ1bl9zY2hlZF9jaHVua19zaXplKTsKICAgICAgIGJyZWFrOwog ICAgIGNhc2UgR0ZTX0RZTkFNSUM6CiAgICAgICBmcHV0cyAoIkRZTkFNSUMiLCBzdGRlcnIp OwotICAgICAgaWYgKGdvbXBfZ2xvYmFsX2ljdi5ydW5fc2NoZWRfY2h1bmtfc2l6ZSAhPSAx KQotCWZwcmludGYgKHN0ZGVyciwgIiwlZCIsIGdvbXBfZ2xvYmFsX2ljdi5ydW5fc2NoZWRf Y2h1bmtfc2l6ZSk7CisgICAgICBpZiAocnVuX3NjaGVkX2NodW5rX3NpemUgIT0gMSkKKwlm cHJpbnRmIChzdGRlcnIsICIsJWQiLCBydW5fc2NoZWRfY2h1bmtfc2l6ZSk7CiAgICAgICBi cmVhazsKICAgICBjYXNlIEdGU19HVUlERUQ6CiAgICAgICBmcHV0cyAoIkdVSURFRCIsIHN0 ZGVycik7Ci0gICAgICBpZiAoZ29tcF9nbG9iYWxfaWN2LnJ1bl9zY2hlZF9jaHVua19zaXpl ICE9IDEpCi0JZnByaW50ZiAoc3RkZXJyLCAiLCVkIiwgZ29tcF9nbG9iYWxfaWN2LnJ1bl9z Y2hlZF9jaHVua19zaXplKTsKKyAgICAgIGlmIChydW5fc2NoZWRfY2h1bmtfc2l6ZSAhPSAx KQorCWZwcmludGYgKHN0ZGVyciwgIiwlZCIsIHJ1bl9zY2hlZF9jaHVua19zaXplKTsKICAg ICAgIGJyZWFrOwogICAgIGNhc2UgR0ZTX0FVVE86CiAgICAgICBmcHV0cyAoIkFVVE8iLCBz dGRlcnIpOwogICAgICAgYnJlYWs7CiAgICAgfQogICBmcHV0cyAoIidcbiIsIHN0ZGVycik7 Cit9CisKKy8qIEhlbHBlciBmdW5jdGlvbiBmb3Igb21wX2Rpc3BsYXlfZW52IHdoaWNoIHBy aW50cyB0aGUgdmFsdWVzIG9mIHByb2NfYmluZF92YXIuCisgICAnZGV2aWNlJyBjYW4gYmUg J2hvc3QnLCAnZGV2JywgJ2FsbCcsIG9yIGEgcGFydGljdWxhciBkZXZpY2UgbnVtYmVyLiAg Ki8KIAotICBmcHV0cyAoIiAgT01QX1BST0NfQklORCA9ICciLCBzdGRlcnIpOwotICBzd2l0 Y2ggKGdvbXBfZ2xvYmFsX2ljdi5iaW5kX3ZhcikKK3N0YXRpYyB2b2lkCitwcmludF9wcm9j X2JpbmQgKGNoYXIgcHJvY19iaW5kX3ZhciwgdW5zaWduZWQgbG9uZyBsZW4sIGNoYXIgKips aXN0LAorCQkgY29uc3QgY2hhciAqZGV2aWNlKQoreworICBmcHJpbnRmIChzdGRlcnIsICIg IFslc10gT01QX1BST0NfQklORCA9ICciLCBkZXZpY2UpOworICBzd2l0Y2ggKHByb2NfYmlu ZF92YXIpCiAgICAgewogICAgIGNhc2Ugb21wX3Byb2NfYmluZF9mYWxzZToKICAgICAgIGZw dXRzICgiRkFMU0UiLCBzdGRlcnIpOwpAQCAtMTMyNCw4ICsxMzg5LDggQEAgb21wX2Rpc3Bs YXlfZW52IChpbnQgdmVyYm9zZSkKICAgICAgIGZwdXRzICgiU1BSRUFEIiwgc3RkZXJyKTsK ICAgICAgIGJyZWFrOwogICAgIH0KLSAgZm9yIChpID0gMTsgaSA8IGdvbXBfYmluZF92YXJf bGlzdF9sZW47IGkrKykKLSAgICBzd2l0Y2ggKGdvbXBfYmluZF92YXJfbGlzdFtpXSkKKyAg Zm9yIChpbnQgaSA9IDE7IGkgPCBsZW47IGkrKykKKyAgICBzd2l0Y2ggKCgqbGlzdClbaV0p CiAgICAgICB7CiAgICAgICBjYXNlIG9tcF9wcm9jX2JpbmRfbWFzdGVyOgogCWZwdXRzICgi LE1BU1RFUiIsIHN0ZGVycik7IC8qIFRPRE86IENoYW5nZSB0byBQUklNQVJZIGZvciBPcGVu TVAgNS4xLiAqLwpAQCAtMTMzOCw3ICsxNDAzLDMwMyBAQCBvbXBfZGlzcGxheV9lbnYgKGlu dCB2ZXJib3NlKQogCWJyZWFrOwogICAgICAgfQogICBmcHV0cyAoIidcbiIsIHN0ZGVycik7 Ci0gIGZwdXRzICgiICBPTVBfUExBQ0VTID0gJyIsIHN0ZGVycik7Cit9CisKKyNkZWZpbmUg RU5UUlkoTkFNRSkgTkFNRSwgc2l6ZW9mIChOQU1FKSAtIDEKKyNkZWZpbmUgRU5UUllfREVW KE5BTUUpICNOQU1FLCBzaXplb2YgKCNOQU1FKSAtIDEsIE5BTUUKKworI2RlZmluZSBQQVJT RV9JTlQgMQorI2RlZmluZSBQQVJTRV9JTlRfREVWIDIKKyNkZWZpbmUgUEFSU0VfQk9PTCAz CisjZGVmaW5lIFBBUlNFX0JPT0xfREVWIDQKKyNkZWZpbmUgUEFSU0VfU0NIRURVTEVfREVW IDUKKyNkZWZpbmUgUEFSU0VfR0VORVJJQyA2CisjZGVmaW5lIFBBUlNFX1RIUkVBRF9MSU1J VF9ERVYgNworI2RlZmluZSBQQVJTRV9VSU5UIDgKKyNkZWZpbmUgUEFSU0VfTlRIUkVBRFNf REVWIDkKKyNkZWZpbmUgUEFSU0VfVUxPTkcgMTAKKyNkZWZpbmUgUEFSU0VfQ0hBUiAxMQor I2RlZmluZSBQQVJTRV9NQVhfQUNUSVZFX0xFVkVMU19ERVYgMTIKKyNkZWZpbmUgUEFSU0Vf UFJPQ19CSU5EX0RFViAxMworI2RlZmluZSBQQVJTRV9VQ0hBUiAxNAorI2RlZmluZSBQQVJT RV9XQUlUX1BPTElDWV9ERVYgMTUKKyNkZWZpbmUgUEFSU0VfU1RBQ0tTSVpFX0RFViAxNgor I2RlZmluZSBQQVJTRV9VTE9OR1BUUiAxNworI2RlZmluZSBQQVJTRV9DSEFSUFRSIDE4CisK Ky8qIFRoZSBmb2xsb3dpbmcgdGFibGUgY29udGFpbnMgaXRlbXMgdGhhdCBoZWxwIHBhcnNp bmcgZGV2aWNlIHNwZWNpZmljCisgICBlbnZpcm9ubWVudCB2YXJpYWJsZXMgYW5kIGZpbGwg Y29ycmVzcG9uZGluZyBJQ1ZzIHdpdGggdmFsdWVzLiBJdCBoYXMgdGhlCisgICBmb2xsb3dp bmcgc3RydWN0dXJlOgorCQlwcmVmaXggfCBwcmVmaXggbGVuZ3RoIHwgaWN2IGNvZGUgfCBw YXJzZSBjb2RlICAqLworCitzdGF0aWMgY29uc3Qgc3RydWN0IGVudnZhcl9kZXYKK3sKKyAg Y29uc3QgY2hhciAqbmFtZTsKKyAgaW50IG5hbWVfbGVuOworICBpbnQgaWN2X2NvZGU7Cisg IGludCBwYXJzZV90eXBlOworfSBlbnZ2YXJzX2RldltdID0geworICB7RU5UUllfREVWIChP TVBfU0NIRURVTEVfREVWXyksIFBBUlNFX1NDSEVEVUxFX0RFVn0sCisgIHtFTlRSWV9ERVYg KE9NUF9OVU1fVEVBTVNfREVWXyksIFBBUlNFX0lOVF9ERVZ9LAorICB7RU5UUllfREVWIChP TVBfRFlOQU1JQ19ERVZfKSwgUEFSU0VfQk9PTF9ERVZ9LAorICB7RU5UUllfREVWIChPTVBf VEVBTVNfVEhSRUFEX0xJTUlUX0RFVl8pLCBQQVJTRV9JTlRfREVWfSwKKyAge0VOVFJZX0RF ViAoT01QX1RIUkVBRF9MSU1JVF9ERVZfKSwgUEFSU0VfVEhSRUFEX0xJTUlUX0RFVn0sCisg IHtFTlRSWV9ERVYgKE9NUF9OVU1fVEhSRUFEU19ERVZfKSwgUEFSU0VfTlRIUkVBRFNfREVW fSwKKyAge0VOVFJZX0RFViAoT01QX1BST0NfQklORF9ERVZfKSwgUEFSU0VfUFJPQ19CSU5E X0RFVn0sCisgIHtFTlRSWV9ERVYgKE9NUF9NQVhfQUNUSVZFX0xFVkVMU19ERVZfKSwgUEFS U0VfTUFYX0FDVElWRV9MRVZFTFNfREVWfSwKKyAge0VOVFJZX0RFViAoT01QX1dBSVRfUE9M SUNZX0RFVl8pLCBQQVJTRV9XQUlUX1BPTElDWV9ERVZ9LAorICB7RU5UUllfREVWIChPTVBf U1RBQ0tTSVpFX0RFVl8pLCBQQVJTRV9TVEFDS1NJWkVfREVWfSwKK307CisjZGVmaW5lIE9N UF9ERVZfVkFSX0NOVCAoc2l6ZW9mIChlbnZ2YXJzX2RldikgLyBzaXplb2YgKGVudnZhcnNf ZGV2WzBdKSkKKworLyogVGhlIGZvbGxvd2luZyB0YWJsZSBjb250YWlucyBpdGVtcyB0aGF0 IGhlbHAgcGFyc2luZyBub24tZGV2aWNlLXNwZWNpZmljCisgICBlbnZpcm9ubWVudCB2YXJp YWJsZXMgYW5kIGZpbGwgY29ycmVzcG9uZGluZyBJQ1ZzIHdpdGggdmFsdWVzLiBJdCBoYXMg dGhlCisgICBmb2xsb3dpbmcgc3RydWN0dXJlOgorCXByZWZpeCB8IHByZWZpeCBsZW5ndGgg fCB2YXJpYWJsZXMgdG8gc2V0IHRoZSBmbGFncyB8IGZsYWcgdG8gc2V0CisJCXwgcGFyc2Ug ZnVuY3Rpb24gcGFyYW1ldGVycyB8IHB0ciB0byBwYXJzZSBmdW5jdGlvbgorCisgICBUaGUg b3JkZXIgb2YgdGhlIGl0ZW1zIG11c3QgYXN1cmUgdGhhdCBwcmVmaXhlcyBkbyBub3QgcHJl Y2VlZCwgZS5nLgorICAgT01QX1RIUkVBRF9MSU1JVCBtdXN0IGJlIGRlZmluZWQgYWZ0ZXIg T01QX1RIUkVBRF9MSU1JVF9BTEwgYW5kCisgICBPTVBfVEhSRUFEX0xJTUlUX0RFVi4gICov CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZW52dmFyCit7CisgIGNvbnN0IGNoYXIgKm5hbWU7 CisgIGludCBuYW1lX2xlbjsKKyAgdW5zaWduZWQgY2hhciBmbGFnX3ZhcnNbM107CisgIHVu c2lnbmVkIGNoYXIgZmxhZzsKKyAgdm9pZCAqcGFyYW1zWzNdOworICBib29sICgqcGFyc2Vf ZnVuYykgKGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqLCB2b2lkICogY29uc3RbXSk7Cit9 IGVudnZhcnNbXSA9IHsKKyAge0VOVFJZICgiT01QX1NDSEVEVUxFX0RFViIpLCB7T01QX1ND SEVEVUxFX0RFVl8sIE9NUF9TQ0hFRFVMRV9DSFVOS19TSVpFX0RFVl99LCBHT01QX0VOVl9W QVJfU1VGRklYX0RFViwgeyZnb21wX2luaXRpYWxfaWN2c19kZXYucnVuX3NjaGVkX3Zhciwg JmdvbXBfaW5pdGlhbF9pY3ZzX2Rldi5ydW5fc2NoZWRfY2h1bmtfc2l6ZX0sICZwYXJzZV9z Y2hlZHVsZX0sCisgIHtFTlRSWSAoIk9NUF9TQ0hFRFVMRV9BTEwiKSwge09NUF9TQ0hFRFVM RV9ERVZfLCBPTVBfU0NIRURVTEVfQ0hVTktfU0laRV9ERVZffSwgR09NUF9FTlZfVkFSX1NV RkZJWF9BTEwsIHsmZ29tcF9pbml0aWFsX2ljdnNfYWxsLnJ1bl9zY2hlZF92YXIsICZnb21w X2luaXRpYWxfaWN2c19hbGwucnVuX3NjaGVkX2NodW5rX3NpemV9LCAmcGFyc2Vfc2NoZWR1 bGV9LAorICB7RU5UUlkgKCJPTVBfU0NIRURVTEUiKSwge09NUF9TQ0hFRFVMRV9ERVZfLCBP TVBfU0NIRURVTEVfQ0hVTktfU0laRV9ERVZffSwgR09NUF9FTlZfVkFSX1NVRkZJWF9OT05F LCB7JmdvbXBfaW5pdGlhbF9pY3ZzX25vbmUucnVuX3NjaGVkX3ZhciwgJmdvbXBfaW5pdGlh bF9pY3ZzX25vbmUucnVuX3NjaGVkX2NodW5rX3NpemV9LCAmcGFyc2Vfc2NoZWR1bGV9LAor CisgIHtFTlRSWSAoIk9NUF9OVU1fVEVBTVNfREVWIiksIHtPTVBfTlVNX1RFQU1TX0RFVl99 LCBHT01QX0VOVl9WQVJfU1VGRklYX0RFViAsIHsmZ29tcF9pbml0aWFsX2ljdnNfZGV2Lm50 ZWFtc192YXIsIGZhbHNlfSwgJnBhcnNlX2ludH0sCisgIHtFTlRSWSAoIk9NUF9OVU1fVEVB TVNfQUxMIiksIHtPTVBfTlVNX1RFQU1TX0RFVl99LCBHT01QX0VOVl9WQVJfU1VGRklYX0FM TCwgeyZnb21wX2luaXRpYWxfaWN2c19hbGwubnRlYW1zX3ZhciwgZmFsc2V9LCAmcGFyc2Vf aW50fSwKKyAge0VOVFJZICgiT01QX05VTV9URUFNUyIpLCB7T01QX05VTV9URUFNU19ERVZf fSwgR09NUF9FTlZfVkFSX1NVRkZJWF9OT05FLCB7JmdvbXBfaW5pdGlhbF9pY3ZzX25vbmUu bnRlYW1zX3ZhciwgZmFsc2V9LCAmcGFyc2VfaW50fSwKKworICB7RU5UUlkgKCJPTVBfRFlO QU1JQ19ERVYiKSwge09NUF9EWU5BTUlDX0RFVl99LCBHT01QX0VOVl9WQVJfU1VGRklYX0RF ViwgeyZnb21wX2luaXRpYWxfaWN2c19kZXYuZHluX3Zhcn0sICZwYXJzZV9ib29sZWFufSwK KyAge0VOVFJZICgiT01QX0RZTkFNSUNfQUxMIiksIHtPTVBfRFlOQU1JQ19ERVZffSwgR09N UF9FTlZfVkFSX1NVRkZJWF9BTEwsIHsmZ29tcF9pbml0aWFsX2ljdnNfYWxsLmR5bl92YXJ9 LCAmcGFyc2VfYm9vbGVhbn0sCisgIHtFTlRSWSAoIk9NUF9EWU5BTUlDIiksIHtPTVBfRFlO QU1JQ19ERVZffSwgR09NUF9FTlZfVkFSX1NVRkZJWF9OT05FLCB7JmdvbXBfaW5pdGlhbF9p Y3ZzX25vbmUuZHluX3Zhcn0sICZwYXJzZV9ib29sZWFufSwKKworICB7RU5UUlkgKCJPTVBf VEVBTVNfVEhSRUFEX0xJTUlUX0RFViIpLCB7T01QX1RFQU1TX1RIUkVBRF9MSU1JVF9ERVZf fSwgR09NUF9FTlZfVkFSX1NVRkZJWF9ERVYsIHsmZ29tcF9pbml0aWFsX2ljdnNfZGV2LnRl YW1zX3RocmVhZF9saW1pdF92YXIsIGZhbHNlfSwgJnBhcnNlX2ludH0sCisgIHtFTlRSWSAo Ik9NUF9URUFNU19USFJFQURfTElNSVRfQUxMIiksIHtPTVBfVEVBTVNfVEhSRUFEX0xJTUlU X0RFVl99LCBHT01QX0VOVl9WQVJfU1VGRklYX0FMTCwgeyZnb21wX2luaXRpYWxfaWN2c19h bGwudGVhbXNfdGhyZWFkX2xpbWl0X3ZhciwgZmFsc2V9LCAmcGFyc2VfaW50fSwKKyAge0VO VFJZICgiT01QX1RFQU1TX1RIUkVBRF9MSU1JVCIpLCB7T01QX1RFQU1TX1RIUkVBRF9MSU1J VF9ERVZffSwgR09NUF9FTlZfVkFSX1NVRkZJWF9OT05FLCB7JmdvbXBfaW5pdGlhbF9pY3Zz X25vbmUudGVhbXNfdGhyZWFkX2xpbWl0X3ZhciwgZmFsc2V9LCAmcGFyc2VfaW50fSwKKwor ICB7RU5UUlkgKCJPTVBfVEhSRUFEX0xJTUlUX0RFViIpLCB7T01QX1RIUkVBRF9MSU1JVF9E RVZffSwgR09NUF9FTlZfVkFSX1NVRkZJWF9ERVYsIHsmZ29tcF9pbml0aWFsX2ljdnNfZGV2 LnRocmVhZF9saW1pdF92YXIsIGZhbHNlLCAodm9pZCAqKSBVSU5UX01BWH0sICZwYXJzZV91 bnNpZ25lZF9sb25nfSwKKyAge0VOVFJZICgiT01QX1RIUkVBRF9MSU1JVF9BTEwiKSwge09N UF9USFJFQURfTElNSVRfREVWX30sIEdPTVBfRU5WX1ZBUl9TVUZGSVhfQUxMLCB7JmdvbXBf aW5pdGlhbF9pY3ZzX2FsbC50aHJlYWRfbGltaXRfdmFyLCBmYWxzZSwgKHZvaWQgKikgVUlO VF9NQVh9LCAmcGFyc2VfdW5zaWduZWRfbG9uZ30sCisgIHtFTlRSWSAoIk9NUF9USFJFQURf TElNSVQiKSwge09NUF9USFJFQURfTElNSVRfREVWX30sIEdPTVBfRU5WX1ZBUl9TVUZGSVhf Tk9ORSwgeyZnb21wX2luaXRpYWxfaWN2c19ub25lLnRocmVhZF9saW1pdF92YXIsIGZhbHNl LCAodm9pZCAqKSBVSU5UX01BWH0sICZwYXJzZV91bnNpZ25lZF9sb25nfSwKKworICB7RU5U UlkgKCJPTVBfTlVNX1RIUkVBRFNfREVWIiksIHtPTVBfTlVNX1RIUkVBRFNfREVWXywgT01Q X05USFJFQURTX0xJU1RfREVWLCBPTVBfTlRIUkVBRFNfTElTVF9MRU5fREVWfSwgR09NUF9F TlZfVkFSX1NVRkZJWF9ERVYsIHsmZ29tcF9pbml0aWFsX2ljdnNfZGV2Lm50aHJlYWRzX3Zh ciwgJmdvbXBfaW5pdGlhbF9pY3ZzX2Rldi5udGhyZWFkc192YXJfbGlzdCwgJmdvbXBfaW5p dGlhbF9pY3ZzX2Rldi5udGhyZWFkc192YXJfbGlzdF9sZW59LCAmcGFyc2VfdW5zaWduZWRf bG9uZ19saXN0fSwKKyAge0VOVFJZICgiT01QX05VTV9USFJFQURTX0FMTCIpLCB7T01QX05V TV9USFJFQURTX0RFVl8sIE9NUF9OVEhSRUFEU19MSVNUX0RFViwgT01QX05USFJFQURTX0xJ U1RfTEVOX0RFVn0sIEdPTVBfRU5WX1ZBUl9TVUZGSVhfQUxMLCB7JmdvbXBfaW5pdGlhbF9p Y3ZzX2FsbC5udGhyZWFkc192YXIsICZnb21wX2luaXRpYWxfaWN2c19hbGwubnRocmVhZHNf dmFyX2xpc3QsICZnb21wX2luaXRpYWxfaWN2c19hbGwubnRocmVhZHNfdmFyX2xpc3RfbGVu fSwgJnBhcnNlX3Vuc2lnbmVkX2xvbmdfbGlzdH0sCisgIHtFTlRSWSAoIk9NUF9OVU1fVEhS RUFEUyIpLCB7T01QX05VTV9USFJFQURTX0RFVl8sIE9NUF9OVEhSRUFEU19MSVNUX0RFViwg T01QX05USFJFQURTX0xJU1RfTEVOX0RFVn0sIEdPTVBfRU5WX1ZBUl9TVUZGSVhfTk9ORSwg eyZnb21wX2luaXRpYWxfaWN2c19ub25lLm50aHJlYWRzX3ZhciwgJmdvbXBfaW5pdGlhbF9p Y3ZzX25vbmUubnRocmVhZHNfdmFyX2xpc3QsICZnb21wX2luaXRpYWxfaWN2c19ub25lLm50 aHJlYWRzX3Zhcl9saXN0X2xlbn0sICZwYXJzZV91bnNpZ25lZF9sb25nX2xpc3R9LAorCisg IHtFTlRSWSAoIk9NUF9QUk9DX0JJTkRfREVWIiksIHtPTVBfUFJPQ19CSU5EX0RFVl8sIE9N UF9QUk9DX0JJTkRfTElTVF9ERVZfLCBPTVBfUFJPQ19CSU5EX0xJU1RfTEVOX0RFVl99LCBH T01QX0VOVl9WQVJfU1VGRklYX0RFViwgeyZnb21wX2luaXRpYWxfaWN2c19kZXYuYmluZF92 YXIsICZnb21wX2luaXRpYWxfaWN2c19kZXYuYmluZF92YXJfbGlzdCwgJmdvbXBfaW5pdGlh bF9pY3ZzX2Rldi5iaW5kX3Zhcl9saXN0X2xlbn0sICZwYXJzZV9iaW5kX3Zhcn0sCisgIHtF TlRSWSAoIk9NUF9QUk9DX0JJTkRfQUxMIiksIHtPTVBfUFJPQ19CSU5EX0RFVl8sIE9NUF9Q Uk9DX0JJTkRfTElTVF9ERVZfLCBPTVBfUFJPQ19CSU5EX0xJU1RfTEVOX0RFVl99LCBHT01Q X0VOVl9WQVJfU1VGRklYX0FMTCwgeyZnb21wX2luaXRpYWxfaWN2c19hbGwuYmluZF92YXIs ICZnb21wX2luaXRpYWxfaWN2c19hbGwuYmluZF92YXJfbGlzdCwgJmdvbXBfaW5pdGlhbF9p Y3ZzX2FsbC5iaW5kX3Zhcl9saXN0X2xlbn0sICZwYXJzZV9iaW5kX3Zhcn0sCisgIHtFTlRS WSAoIk9NUF9QUk9DX0JJTkQiKSwge09NUF9QUk9DX0JJTkRfREVWXywgT01QX1BST0NfQklO RF9MSVNUX0RFVl8sIE9NUF9QUk9DX0JJTkRfTElTVF9MRU5fREVWX30sIEdPTVBfRU5WX1ZB Ul9TVUZGSVhfTk9ORSwgeyZnb21wX2luaXRpYWxfaWN2c19ub25lLmJpbmRfdmFyLCAmZ29t cF9pbml0aWFsX2ljdnNfbm9uZS5iaW5kX3Zhcl9saXN0LCAmZ29tcF9pbml0aWFsX2ljdnNf bm9uZS5iaW5kX3Zhcl9saXN0X2xlbn0sICZwYXJzZV9iaW5kX3Zhcn0sCisKKyAge0VOVFJZ ICgiT01QX01BWF9BQ1RJVkVfTEVWRUxTX0RFViIpLCB7T01QX01BWF9BQ1RJVkVfTEVWRUxT X0RFVl99LCBHT01QX0VOVl9WQVJfU1VGRklYX0RFViwgeyZnb21wX2luaXRpYWxfaWN2c19k ZXYubWF4X2FjdGl2ZV9sZXZlbHNfdmFyLCAodm9pZCAqKSB0cnVlLCAodm9pZCAqKSBnb21w X3N1cHBvcnRlZF9hY3RpdmVfbGV2ZWxzfSwgJnBhcnNlX3Vuc2lnbmVkX2xvbmd9LAorICB7 RU5UUlkgKCJPTVBfTUFYX0FDVElWRV9MRVZFTFNfQUxMIiksIHtPTVBfTUFYX0FDVElWRV9M RVZFTFNfREVWX30sIEdPTVBfRU5WX1ZBUl9TVUZGSVhfQUxMLCB7JmdvbXBfaW5pdGlhbF9p Y3ZzX2FsbC5tYXhfYWN0aXZlX2xldmVsc192YXIsICh2b2lkICopIHRydWUsICh2b2lkICop IGdvbXBfc3VwcG9ydGVkX2FjdGl2ZV9sZXZlbHN9LCAmcGFyc2VfdW5zaWduZWRfbG9uZ30s CisgIHtFTlRSWSAoIk9NUF9NQVhfQUNUSVZFX0xFVkVMUyIpLCB7T01QX01BWF9BQ1RJVkVf TEVWRUxTX0RFVl99LCBHT01QX0VOVl9WQVJfU1VGRklYX05PTkUsIHsmZ29tcF9pbml0aWFs X2ljdnNfbm9uZS5tYXhfYWN0aXZlX2xldmVsc192YXIsICh2b2lkICopIHRydWUsICh2b2lk ICopIGdvbXBfc3VwcG9ydGVkX2FjdGl2ZV9sZXZlbHN9LCAmcGFyc2VfdW5zaWduZWRfbG9u Z30sCisKKyAge0VOVFJZICgiT01QX1dBSVRfUE9MSUNZX0RFViIpLCB7T01QX1dBSVRfUE9M SUNZX0RFVl99LCBHT01QX0VOVl9WQVJfU1VGRklYX0RFViwgeyZnb21wX2luaXRpYWxfaWN2 c19kZXYud2FpdF9wb2xpY3l9LCAmcGFyc2Vfd2FpdF9wb2xpY3l9LAorICB7RU5UUlkgKCJP TVBfV0FJVF9QT0xJQ1lfQUxMIiksIHtPTVBfV0FJVF9QT0xJQ1lfREVWX30sIEdPTVBfRU5W X1ZBUl9TVUZGSVhfQUxMLCB7JmdvbXBfaW5pdGlhbF9pY3ZzX2FsbC53YWl0X3BvbGljeX0s ICZwYXJzZV93YWl0X3BvbGljeX0sCisgIHtFTlRSWSAoIk9NUF9XQUlUX1BPTElDWSIpLCB7 T01QX1dBSVRfUE9MSUNZX0RFVl99LCBHT01QX0VOVl9WQVJfU1VGRklYX05PTkUsIHsmZ29t cF9pbml0aWFsX2ljdnNfbm9uZS53YWl0X3BvbGljeX0sICZwYXJzZV93YWl0X3BvbGljeX0s CisKKyAge0VOVFJZICgiT01QX1NUQUNLU0laRV9ERVYiKSwge09NUF9TVEFDS1NJWkVfREVW X30sIEdPTVBfRU5WX1ZBUl9TVUZGSVhfREVWLCB7JmdvbXBfaW5pdGlhbF9pY3ZzX2Rldi5z dGFja3NpemV9LCAmcGFyc2Vfc3RhY2tzaXplfSwKKyAge0VOVFJZICgiT01QX1NUQUNLU0la RV9BTEwiKSwge09NUF9TVEFDS1NJWkVfREVWX30sIEdPTVBfRU5WX1ZBUl9TVUZGSVhfQUxM LCB7JmdvbXBfaW5pdGlhbF9pY3ZzX2FsbC5zdGFja3NpemV9LCAmcGFyc2Vfc3RhY2tzaXpl fSwKKyAge0VOVFJZICgiT01QX1NUQUNLU0laRSIpLCB7T01QX1NUQUNLU0laRV9ERVZffSwg R09NUF9FTlZfVkFSX1NVRkZJWF9OT05FLCB7JmdvbXBfaW5pdGlhbF9pY3ZzX25vbmUuc3Rh Y2tzaXplfSwgJnBhcnNlX3N0YWNrc2l6ZX0sCisKKyAge0VOVFJZICgiT01QX0NBTkNFTExB VElPTiIpLCB7fSwgR09NUF9FTlZfVkFSX1NVRkZJWF9OT05FLCB7JmdvbXBfY2FuY2VsX3Zh cn0sICZwYXJzZV9ib29sZWFufSwKKyAge0VOVFJZICgiT01QX0RJU1BMQVlfQUZGSU5JVFki KSwge30sIEdPTVBfRU5WX1ZBUl9TVUZGSVhfTk9ORSwgeyZnb21wX2Rpc3BsYXlfYWZmaW5p dHlfdmFyfSwgJnBhcnNlX2Jvb2xlYW59LAorICB7RU5UUlkgKCJPTVBfVEFSR0VUX09GRkxP QUQiKSwge30sIEdPTVBfRU5WX1ZBUl9TVUZGSVhfTk9ORSwgeyZnb21wX3RhcmdldF9vZmZs b2FkX3Zhcn0sICZwYXJzZV90YXJnZXRfb2ZmbG9hZH0sCisgIHtFTlRSWSAoIk9NUF9NQVhf VEFTS19QUklPUklUWSIpLCB7fSwgR09NUF9FTlZfVkFSX1NVRkZJWF9OT05FLCB7JmdvbXBf bWF4X3Rhc2tfcHJpb3JpdHlfdmFyLCAodm9pZCAqKSB0cnVlfSwgJnBhcnNlX2ludH0sCisg IHtFTlRSWSAoIk9NUF9BTExPQ0FUT1IiKSwge30sIEdPTVBfRU5WX1ZBUl9TVUZGSVhfTk9O RSwgeyZnb21wX2RlZl9hbGxvY2F0b3J9LCAmcGFyc2VfYWxsb2NhdG9yfSwKKyAge0VOVFJZ ICgiT01QX0RFRkFVTFRfREVWSUNFIiksIHtPTVBfREVGQVVMVF9ERVZJQ0VfREVWX30sIEdP TVBfRU5WX1ZBUl9TVUZGSVhfTk9ORSwgeyZnb21wX2luaXRpYWxfaWN2c19ub25lLmRlZmF1 bHRfZGV2aWNlX3ZhciwgKHZvaWQgKikgdHJ1ZX0sICZwYXJzZV9pbnR9LAorfTsKKyN1bmRl ZiBFTlRSWQorI3VuZGVmIEVOVFJZX0RFVgorI2RlZmluZSBPTVBfVkFSX0NOVCAoc2l6ZW9m IChlbnZ2YXJzKSAvIHNpemVvZiAoZW52dmFyc1swXSkpCisKKy8qIFRoZSBmb2xsb3dpbmcg dGFibGUgaXMgdXNlZCB0byBhcHBseSB0aGUgaGllcmFyY2h5IG9mIElDViB2YXJpYW50cyBm b3IgaG9zdAorICAgdmFyaWFibGVzLCBlLmcuIG50ZWFtc192YXIgaXMgc2V0IHRvIE9NUF9O VU1fVEVBTVNfQUxMIGlmIE9NUF9OVU1fVEVBTVMgaXMKKyAgIHVuZGVmaW5lZC4gICovCisK K3N0YXRpYyBjb25zdCBzdHJ1Y3QgaG9zdF9lbnZ2YXIKK3sKKyAgdW5zaWduZWQgY2hhciBm bGFnX3ZhcjsKKyAgdm9pZCAqYWxsX3ZhcjsKKyAgdm9pZCAqbm9uZV92YXI7CisgIHZvaWQg KmRlc3Q7CisgIGludCB0eXBlX2NvZGU7Cit9IGhvc3RfZW52dmFyc1tdID0geworICB7T01Q X05VTV9URUFNU19ERVZfLCAmZ29tcF9pbml0aWFsX2ljdnNfYWxsLm50ZWFtc192YXIsICZn b21wX2luaXRpYWxfaWN2c19ub25lLm50ZWFtc192YXIsICZnb21wX250ZWFtc192YXIsIFBB UlNFX0lOVH0sCisgIHtPTVBfRFlOQU1JQ19ERVZfLCAmZ29tcF9pbml0aWFsX2ljdnNfYWxs LmR5bl92YXIsICZnb21wX2luaXRpYWxfaWN2c19ub25lLmR5bl92YXIsICZnb21wX2dsb2Jh bF9pY3YuZHluX3ZhciwgUEFSU0VfQk9PTH0sCisgIHtPTVBfREVGQVVMVF9ERVZJQ0VfREVW XywgTlVMTCwgJmdvbXBfaW5pdGlhbF9pY3ZzX25vbmUuZGVmYXVsdF9kZXZpY2VfdmFyLCAm Z29tcF9nbG9iYWxfaWN2LmRlZmF1bHRfZGV2aWNlX3ZhciwgUEFSU0VfSU5UfSwKKyAge09N UF9URUFNU19USFJFQURfTElNSVRfREVWXywgJmdvbXBfaW5pdGlhbF9pY3ZzX2FsbC50ZWFt c190aHJlYWRfbGltaXRfdmFyLCAmZ29tcF9pbml0aWFsX2ljdnNfbm9uZS50ZWFtc190aHJl YWRfbGltaXRfdmFyLCAmZ29tcF90ZWFtc190aHJlYWRfbGltaXRfdmFyLCBQQVJTRV9JTlR9 LAorICB7T01QX1NDSEVEVUxFX0RFVl8sICZnb21wX2luaXRpYWxfaWN2c19hbGwucnVuX3Nj aGVkX3ZhciwgJmdvbXBfaW5pdGlhbF9pY3ZzX25vbmUucnVuX3NjaGVkX3ZhciwgJmdvbXBf Z2xvYmFsX2ljdi5ydW5fc2NoZWRfdmFyLCBQQVJTRV9JTlR9LAorICB7T01QX1NDSEVEVUxF X0NIVU5LX1NJWkVfREVWXywgJmdvbXBfaW5pdGlhbF9pY3ZzX2FsbC5ydW5fc2NoZWRfY2h1 bmtfc2l6ZSwgJmdvbXBfaW5pdGlhbF9pY3ZzX25vbmUucnVuX3NjaGVkX2NodW5rX3NpemUs ICZnb21wX2dsb2JhbF9pY3YucnVuX3NjaGVkX2NodW5rX3NpemUsIFBBUlNFX0lOVH0sCisg IHtPTVBfVEhSRUFEX0xJTUlUX0RFVl8sICZnb21wX2luaXRpYWxfaWN2c19hbGwudGhyZWFk X2xpbWl0X3ZhciwgJmdvbXBfaW5pdGlhbF9pY3ZzX25vbmUudGhyZWFkX2xpbWl0X3Zhciwg JmdvbXBfZ2xvYmFsX2ljdi50aHJlYWRfbGltaXRfdmFyLCBQQVJTRV9VSU5UfSwKKyAge09N UF9OVU1fVEhSRUFEU19ERVZfLCAmZ29tcF9pbml0aWFsX2ljdnNfYWxsLm50aHJlYWRzX3Zh ciwgJmdvbXBfaW5pdGlhbF9pY3ZzX25vbmUubnRocmVhZHNfdmFyLCAmZ29tcF9nbG9iYWxf aWN2Lm50aHJlYWRzX3ZhciwgUEFSU0VfVUxPTkd9LAorICB7T01QX05USFJFQURTX0xJU1Rf REVWLCAmZ29tcF9pbml0aWFsX2ljdnNfYWxsLm50aHJlYWRzX3Zhcl9saXN0LCAmZ29tcF9p bml0aWFsX2ljdnNfbm9uZS5udGhyZWFkc192YXJfbGlzdCwgJmdvbXBfbnRocmVhZHNfdmFy X2xpc3QsIFBBUlNFX1VMT05HfSwKKyAge09NUF9OVEhSRUFEU19MSVNUX0xFTl9ERVYsICZn b21wX2luaXRpYWxfaWN2c19hbGwubnRocmVhZHNfdmFyX2xpc3RfbGVuLCAmZ29tcF9pbml0 aWFsX2ljdnNfbm9uZS5udGhyZWFkc192YXJfbGlzdF9sZW4sICZnb21wX250aHJlYWRzX3Zh cl9saXN0X2xlbiwgUEFSU0VfVUxPTkdQVFJ9LAorICB7T01QX1BST0NfQklORF9ERVZfLCAm Z29tcF9pbml0aWFsX2ljdnNfYWxsLmJpbmRfdmFyLCAmZ29tcF9pbml0aWFsX2ljdnNfbm9u ZS5iaW5kX3ZhciwgJmdvbXBfZ2xvYmFsX2ljdi5iaW5kX3ZhciwgUEFSU0VfQ0hBUn0sCisg IHtPTVBfUFJPQ19CSU5EX0xJU1RfREVWXywgJmdvbXBfaW5pdGlhbF9pY3ZzX2FsbC5iaW5k X3Zhcl9saXN0LCAmZ29tcF9pbml0aWFsX2ljdnNfbm9uZS5iaW5kX3Zhcl9saXN0LCAmZ29t cF9iaW5kX3Zhcl9saXN0LCBQQVJTRV9DSEFSUFRSfSwKKyAge09NUF9QUk9DX0JJTkRfTElT VF9MRU5fREVWXywgJmdvbXBfaW5pdGlhbF9pY3ZzX2FsbC5iaW5kX3Zhcl9saXN0X2xlbiwg JmdvbXBfaW5pdGlhbF9pY3ZzX25vbmUuYmluZF92YXJfbGlzdF9sZW4sICZnb21wX2JpbmRf dmFyX2xpc3RfbGVuLCBQQVJTRV9VTE9OR30sCisgIHtPTVBfTUFYX0FDVElWRV9MRVZFTFNf REVWXywgJmdvbXBfaW5pdGlhbF9pY3ZzX2FsbC5tYXhfYWN0aXZlX2xldmVsc192YXIsICZn b21wX2luaXRpYWxfaWN2c19ub25lLm1heF9hY3RpdmVfbGV2ZWxzX3ZhciwgJmdvbXBfZ2xv YmFsX2ljdi5tYXhfYWN0aXZlX2xldmVsc192YXIsIFBBUlNFX1VDSEFSfSwKK307CisjZGVm aW5lIE9NUF9IT1NUX1ZBUl9DTlQgKHNpemVvZiAoaG9zdF9lbnZ2YXJzKSAvIHNpemVvZiAo aG9zdF9lbnZ2YXJzWzBdKSkKKworI2RlZmluZSBJTlRfTUFYX1NUUl9MRU4gMTAKKworc3Rh dGljIHZvaWQKK3ByaW50X2RldmljZV9zcGVjaWZpY19pY3ZzIChpbnQgaWN2X2NvZGUpCit7 CisgIHN0cnVjdCBnb21wX2ljdl9saXN0ICpsaXN0ID0gZ29tcF9pbml0aWFsX2ljdl9kZXZf bGlzdDsKKyAgaW50IGk7CisgIGNoYXIgZGV2X251bVtJTlRfTUFYX1NUUl9MRU5dOworCisg IHdoaWxlIChsaXN0ICE9IE5VTEwpCisgICAgeworICAgICAgc3dpdGNoIChpY3ZfY29kZSkK Kwl7CisJY2FzZSBPTVBfTlVNX1RFQU1TX0RFVl86CisJICBpZiAobGlzdC0+ZmxhZ3MubnRl YW1zX3ZhciAmIEdPTVBfRU5WX1ZBUl9TVUZGSVhfREVWX1gpCisJICAgIGZwcmludGYgKHN0 ZGVyciwgIiAgWyVkXSBPTVBfTlVNX1RFQU1TID0gJyVkJ1xuIiwKKwkJICAgICBsaXN0LT5k ZXZpY2VfbnVtLCBsaXN0LT5pY3ZzLm50ZWFtc192YXIpOworCSAgYnJlYWs7CisJY2FzZSBP TVBfRFlOQU1JQ19ERVZfOgorCSAgaWYgKGxpc3QtPmZsYWdzLmR5bl92YXIgJiBHT01QX0VO Vl9WQVJfU1VGRklYX0RFVl9YKQorCSAgICBmcHJpbnRmIChzdGRlcnIsICIgIFslZF0gT01Q X0RZTkFNSUMgPSAnJXMnXG4iLAorCQkgICAgIGxpc3QtPmRldmljZV9udW0sIGxpc3QtPmlj dnMuZHluX3ZhciA/ICJUUlVFIiA6ICJGQUxTRSIpOworCSAgYnJlYWs7CisJY2FzZSBPTVBf VEVBTVNfVEhSRUFEX0xJTUlUX0RFVl86CisJICBpZiAobGlzdC0+ZmxhZ3MudGVhbXNfdGhy ZWFkX2xpbWl0X3ZhciAmIEdPTVBfRU5WX1ZBUl9TVUZGSVhfREVWX1gpCisJICAgIGZwcmlu dGYgKHN0ZGVyciwgIiAgWyVkXSBPTVBfVEVBTVNfVEhSRUFEX0xJTUlUID0gJyV1J1xuIiwK KwkJICAgICBsaXN0LT5kZXZpY2VfbnVtLCBsaXN0LT5pY3ZzLnRlYW1zX3RocmVhZF9saW1p dF92YXIpOworCSAgYnJlYWs7CisJY2FzZSBPTVBfU0NIRURVTEVfREVWXzoKKwkgIGlmICgh KGxpc3QtPmZsYWdzLnJ1bl9zY2hlZF92YXIgJiBHT01QX0VOVl9WQVJfU1VGRklYX0RFVl9Y KSkKKwkgICAgYnJlYWs7CisJICBzcHJpbnRmIChkZXZfbnVtLCAiJWQiLCBsaXN0LT5kZXZp Y2VfbnVtKTsKKwkgIHByaW50X3NjaGVkdWxlIChsaXN0LT5pY3ZzLnJ1bl9zY2hlZF92YXIs CisJCQkgIGxpc3QtPmljdnMucnVuX3NjaGVkX2NodW5rX3NpemUsCisJCQkgIGRldl9udW0p OworCSAgYnJlYWs7CisJY2FzZSBPTVBfVEhSRUFEX0xJTUlUX0RFVl86CisJICBpZiAobGlz dC0+ZmxhZ3MudGhyZWFkX2xpbWl0X3ZhciAmIEdPTVBfRU5WX1ZBUl9TVUZGSVhfREVWX1gp CisJICAgIGZwcmludGYgKHN0ZGVyciwgIiAgWyVkXSBPTVBfVEhSRUFEX0xJTUlUID0gJyVk J1xuIiwKKwkJICAgICBsaXN0LT5kZXZpY2VfbnVtLCBsaXN0LT5pY3ZzLnRocmVhZF9saW1p dF92YXIpOworCSAgYnJlYWs7CisJY2FzZSBPTVBfTlVNX1RIUkVBRFNfREVWXzoKKwkgIGlm ICghKGxpc3QtPmZsYWdzLm50aHJlYWRzX3ZhciAmIEdPTVBfRU5WX1ZBUl9TVUZGSVhfREVW X1gpKQorCSAgICBicmVhazsKKwkgIGZwcmludGYgKHN0ZGVyciwgIiAgWyVkXSBPTVBfTlVN X1RIUkVBRFMgPSAnJWx1IiwgbGlzdC0+ZGV2aWNlX251bSwKKwkJICAgbGlzdC0+aWN2cy5u dGhyZWFkc192YXIpOworCSAgZm9yIChpID0gMTsgaSA8IGxpc3QtPmljdnMubnRocmVhZHNf dmFyX2xpc3RfbGVuOyBpKyspCisJICAgIGZwcmludGYgKHN0ZGVyciwgIiwlbHUiLCBsaXN0 LT5pY3ZzLm50aHJlYWRzX3Zhcl9saXN0W2ldKTsKKwkgIGZwdXRzICgiJ1xuIiwgc3RkZXJy KTsKKwkgIGJyZWFrOworCWNhc2UgT01QX01BWF9BQ1RJVkVfTEVWRUxTX0RFVl86CisJICBm cHJpbnRmIChzdGRlcnIsICIgIFslZF0gT01QX01BWF9BQ1RJVkVfTEVWRUxTID0gJyV1J1xu IiwKKwkJICAgbGlzdC0+ZGV2aWNlX251bSwgbGlzdC0+aWN2cy5tYXhfYWN0aXZlX2xldmVs c192YXIpOworCSAgYnJlYWs7CisJY2FzZSBPTVBfUFJPQ19CSU5EX0RFVl86CisJICBpZiAo IShsaXN0LT5mbGFncy5iaW5kX3ZhciAmIEdPTVBfRU5WX1ZBUl9TVUZGSVhfREVWX1gpKQor CSAgICBicmVhazsKKwkgIHNwcmludGYgKGRldl9udW0sICIlZCIsIGxpc3QtPmRldmljZV9u dW0pOworCSAgcHJpbnRfcHJvY19iaW5kIChsaXN0LT5pY3ZzLmJpbmRfdmFyLCBsaXN0LT5p Y3ZzLmJpbmRfdmFyX2xpc3RfbGVuLAorCQkJICAgJmxpc3QtPmljdnMuYmluZF92YXJfbGlz dCwgZGV2X251bSk7CisJICBicmVhazsKKwljYXNlIE9NUF9XQUlUX1BPTElDWV9ERVZfOgor CSAgaWYgKGxpc3QtPmZsYWdzLmJpbmRfdmFyICYgR09NUF9FTlZfVkFSX1NVRkZJWF9ERVZf WCkKKwkgICAgZnByaW50ZiAoc3RkZXJyLCAiICBbJWRdIE9NUF9XQUlUX1BPTElDWSA9ICcl cydcbiIsCisJCSAgICAgbGlzdC0+ZGV2aWNlX251bSwKKwkJICAgICBsaXN0LT5pY3ZzLndh aXRfcG9saWN5ID4gMCA/ICJBQ1RJVkUiIDogIlBBU1NJVkUiKTsKKwkgIGJyZWFrOworCWNh c2UgT01QX1NUQUNLU0laRV9ERVZfOgorCSAgaWYgKGxpc3QtPmZsYWdzLnN0YWNrc2l6ZSAm IEdPTVBfRU5WX1ZBUl9TVUZGSVhfREVWX1gpCisJICAgIGZwcmludGYgKHN0ZGVyciwgIiAg WyVkXSBPTVBfU1RBQ0tTSVpFID0gJyVsdSdcbiIsCisJCSAgICAgbGlzdC0+ZGV2aWNlX251 bSwgbGlzdC0+aWN2cy5zdGFja3NpemUpOworCSAgYnJlYWs7CisJfQorICAgICAgbGlzdCA9 IGxpc3QtPm5leHQ7CisgICAgfQorfQorCit2b2lkCitvbXBfZGlzcGxheV9lbnYgKGludCB2 ZXJib3NlKQoreworICBpbnQgaTsKKworICBmcHV0cyAoIlxuT1BFTk1QIERJU1BMQVkgRU5W SVJPTk1FTlQgQkVHSU5cbiIsIHN0ZGVycik7CisKKyAgZnB1dHMgKCIgIF9PUEVOTVAgPSAn MjAxNTExJ1xuIiwgc3RkZXJyKTsKKworICBmcHJpbnRmIChzdGRlcnIsICIgIFtob3N0XSBP TVBfRFlOQU1JQyA9ICclcydcbiIsCisJICAgZ29tcF9pbml0aWFsX2ljdnNfbm9uZS5keW5f dmFyID8gIlRSVUUiIDogIkZBTFNFIik7CisgIGlmIChnb21wX2luaXRpYWxfaWN2X2ZsYWdz LmR5bl92YXIgJiBHT01QX0VOVl9WQVJfU1VGRklYX0FMTCkKKyAgICBmcHJpbnRmIChzdGRl cnIsICIgIFthbGxdIE9NUF9EWU5BTUlDID0gJyVzJ1xuIiwKKwkgICAgIGdvbXBfaW5pdGlh bF9pY3ZzX2FsbC5keW5fdmFyID8gIlRSVUUiIDogIkZBTFNFIik7CisgIGlmIChnb21wX2lu aXRpYWxfaWN2X2ZsYWdzLmR5bl92YXIgJiBHT01QX0VOVl9WQVJfU1VGRklYX0RFVikKKyAg ICBmcHJpbnRmIChzdGRlcnIsICIgIFtkZXZpY2VdIE9NUF9EWU5BTUlDID0gJyVzJ1xuIiwK KwkgICAgIGdvbXBfaW5pdGlhbF9pY3ZzX2Rldi5keW5fdmFyID8gIlRSVUUiIDogIkZBTFNF Iik7CisgIHByaW50X2RldmljZV9zcGVjaWZpY19pY3ZzIChPTVBfRFlOQU1JQ19ERVZfKTsK KworCisgIC8qIFRoZSBPTVBfTkVTVEVEIGVudmlyb25tZW50IHZhcmlhYmxlIGhhcyBiZWVu IGRlcHJlY2F0ZWQuICAqLworICBmcHJpbnRmIChzdGRlcnIsICIgIFtob3N0XSBPTVBfTkVT VEVEID0gJyVzJ1xuIiwKKwkgICBnb21wX2luaXRpYWxfaWN2c19ub25lLm1heF9hY3RpdmVf bGV2ZWxzX3ZhciA+IDEgPyAiVFJVRSIgOiAiRkFMU0UiKTsKKworICBmcHJpbnRmIChzdGRl cnIsICIgIFtob3N0XSBPTVBfTlVNX1RIUkVBRFMgPSAnJWx1IiwKKwkgICBnb21wX2luaXRp YWxfaWN2c19ub25lLm50aHJlYWRzX3Zhcik7CisgIGZvciAoaSA9IDE7IGkgPCBnb21wX2lu aXRpYWxfaWN2c19ub25lLm50aHJlYWRzX3Zhcl9saXN0X2xlbjsgaSsrKQorICAgIGZwcmlu dGYgKHN0ZGVyciwgIiwlbHUiLCBnb21wX2luaXRpYWxfaWN2c19ub25lLm50aHJlYWRzX3Zh cl9saXN0W2ldKTsKKyAgZnB1dHMgKCInXG4iLCBzdGRlcnIpOworICBpZiAoZ29tcF9pbml0 aWFsX2ljdl9mbGFncy5udGhyZWFkc192YXIgJiBHT01QX0VOVl9WQVJfU1VGRklYX0FMTCkK KyAgICB7CisgICAgICBmcHJpbnRmIChzdGRlcnIsICIgIFthbGxdIE9NUF9OVU1fVEhSRUFE UyA9ICclbHUiLAorCSAgICAgICBnb21wX2luaXRpYWxfaWN2c19hbGwubnRocmVhZHNfdmFy KTsKKyAgICAgIGZvciAoaSA9IDE7IGkgPCBnb21wX2luaXRpYWxfaWN2c19hbGwubnRocmVh ZHNfdmFyX2xpc3RfbGVuOyBpKyspCisJZnByaW50ZiAoc3RkZXJyLCAiLCVsdSIsIGdvbXBf aW5pdGlhbF9pY3ZzX2FsbC5udGhyZWFkc192YXJfbGlzdFtpXSk7CisgICAgICBmcHV0cyAo IidcbiIsIHN0ZGVycik7CisgICAgfQorICBpZiAoZ29tcF9pbml0aWFsX2ljdl9mbGFncy5u dGhyZWFkc192YXIgJiBHT01QX0VOVl9WQVJfU1VGRklYX0RFVikKKyAgICB7CisgICAgICBm cHJpbnRmIChzdGRlcnIsICIgIFtkZXZpY2VdIE9NUF9OVU1fVEhSRUFEUyA9ICclbHUiLAor CSAgICAgICBnb21wX2luaXRpYWxfaWN2c19kZXYubnRocmVhZHNfdmFyKTsKKyAgICAgIGZv ciAoaSA9IDE7IGkgPCBnb21wX2luaXRpYWxfaWN2c19kZXYubnRocmVhZHNfdmFyX2xpc3Rf bGVuOyBpKyspCisJZnByaW50ZiAoc3RkZXJyLCAiLCVsdSIsIGdvbXBfaW5pdGlhbF9pY3Zz X2Rldi5udGhyZWFkc192YXJfbGlzdFtpXSk7CisgICAgICBmcHV0cyAoIidcbiIsIHN0ZGVy cik7CisgICAgfQorICBwcmludF9kZXZpY2Vfc3BlY2lmaWNfaWN2cyAoT01QX05VTV9USFJF QURTX0RFVl8pOworCisKKyAgcHJpbnRfc2NoZWR1bGUgKGdvbXBfaW5pdGlhbF9pY3ZzX25v bmUucnVuX3NjaGVkX3ZhciwKKwkJICBnb21wX2luaXRpYWxfaWN2c19ub25lLnJ1bl9zY2hl ZF9jaHVua19zaXplLCAiaG9zdCIpOworICBpZiAoZ29tcF9pbml0aWFsX2ljdl9mbGFncy5y dW5fc2NoZWRfdmFyICYgR09NUF9FTlZfVkFSX1NVRkZJWF9BTEwpCisgICAgcHJpbnRfc2No ZWR1bGUgKGdvbXBfaW5pdGlhbF9pY3ZzX2FsbC5ydW5fc2NoZWRfdmFyLAorCQkgICAgZ29t cF9pbml0aWFsX2ljdnNfYWxsLnJ1bl9zY2hlZF9jaHVua19zaXplLCAiYWxsIik7CisgIGlm IChnb21wX2luaXRpYWxfaWN2X2ZsYWdzLnJ1bl9zY2hlZF92YXIgJiBHT01QX0VOVl9WQVJf U1VGRklYX0RFVikKKyAgICBwcmludF9zY2hlZHVsZSAoZ29tcF9pbml0aWFsX2ljdnNfZGV2 LnJ1bl9zY2hlZF92YXIsCisJCSAgICBnb21wX2luaXRpYWxfaWN2c19kZXYucnVuX3NjaGVk X2NodW5rX3NpemUsICJkZXZpY2UiKTsKKyAgcHJpbnRfZGV2aWNlX3NwZWNpZmljX2ljdnMg KE9NUF9TQ0hFRFVMRV9ERVZfKTsKKworICBwcmludF9wcm9jX2JpbmQgKGdvbXBfaW5pdGlh bF9pY3ZzX25vbmUuYmluZF92YXIsCisJCSAgIGdvbXBfaW5pdGlhbF9pY3ZzX25vbmUuYmlu ZF92YXJfbGlzdF9sZW4sCisJCSAgICZnb21wX2luaXRpYWxfaWN2c19ub25lLmJpbmRfdmFy X2xpc3QsICJob3N0Iik7CisgIGlmIChnb21wX2luaXRpYWxfaWN2X2ZsYWdzLmJpbmRfdmFy ICYgR09NUF9FTlZfVkFSX1NVRkZJWF9BTEwpCisgICAgcHJpbnRfcHJvY19iaW5kIChnb21w X2luaXRpYWxfaWN2c19hbGwuYmluZF92YXIsCisJCSAgICAgZ29tcF9pbml0aWFsX2ljdnNf YWxsLmJpbmRfdmFyX2xpc3RfbGVuLAorCQkgICAgICZnb21wX2luaXRpYWxfaWN2c19hbGwu YmluZF92YXJfbGlzdCwgImFsbCIpOworICBpZiAoZ29tcF9pbml0aWFsX2ljdl9mbGFncy5i aW5kX3ZhciAmIEdPTVBfRU5WX1ZBUl9TVUZGSVhfREVWKQorICAgIHByaW50X3Byb2NfYmlu ZCAoZ29tcF9pbml0aWFsX2ljdnNfZGV2LmJpbmRfdmFyLAorCQkgICAgIGdvbXBfaW5pdGlh bF9pY3ZzX2Rldi5iaW5kX3Zhcl9saXN0X2xlbiwKKwkJICAgICAmZ29tcF9pbml0aWFsX2lj dnNfZGV2LmJpbmRfdmFyX2xpc3QsICJkZXZpY2UiKTsKKyAgcHJpbnRfZGV2aWNlX3NwZWNp ZmljX2ljdnMgKE9NUF9QUk9DX0JJTkRfREVWXyk7CisKKyAgZnB1dHMgKCIgIFtob3N0XSBP TVBfUExBQ0VTID0gJyIsIHN0ZGVycik7CiAgIGZvciAoaSA9IDA7IGkgPCBnb21wX3BsYWNl c19saXN0X2xlbjsgaSsrKQogICAgIHsKICAgICAgIGZwdXRzICgieyIsIHN0ZGVycik7CkBA IC0xMzQ3LDMwICsxNzA4LDgxIEBAIG9tcF9kaXNwbGF5X2VudiAoaW50IHZlcmJvc2UpCiAg ICAgfQogICBmcHV0cyAoIidcbiIsIHN0ZGVycik7CiAKLSAgZnByaW50ZiAoc3RkZXJyLCAi ICBPTVBfU1RBQ0tTSVpFID0gJyVsdSdcbiIsIHN0YWNrc2l6ZSk7CisgIGZwcmludGYgKHN0 ZGVyciwgIiAgW2hvc3RdIE9NUF9TVEFDS1NJWkUgPSAnJWx1J1xuIiwKKwkgICBnb21wX2lu aXRpYWxfaWN2c19ub25lLnN0YWNrc2l6ZSk7CisgIGlmIChnb21wX2luaXRpYWxfaWN2X2Zs YWdzLnN0YWNrc2l6ZSAmIEdPTVBfRU5WX1ZBUl9TVUZGSVhfQUxMKQorICAgIGZwcmludGYg KHN0ZGVyciwgIiAgW2FsbF0gT01QX1NUQUNLU0laRSA9ICclbHUnXG4iLAorCSAgICAgZ29t cF9pbml0aWFsX2ljdnNfYWxsLnN0YWNrc2l6ZSk7CisgIGlmIChnb21wX2luaXRpYWxfaWN2 X2ZsYWdzLnN0YWNrc2l6ZSAmIEdPTVBfRU5WX1ZBUl9TVUZGSVhfREVWKQorICAgIGZwcmlu dGYgKHN0ZGVyciwgIiAgW2RldmljZV0gT01QX1NUQUNLU0laRSA9ICclbHUnXG4iLAorCSAg ICAgZ29tcF9pbml0aWFsX2ljdnNfZGV2LnN0YWNrc2l6ZSk7CisgIHByaW50X2RldmljZV9z cGVjaWZpY19pY3ZzIChPTVBfU1RBQ0tTSVpFX0RFVl8pOwogCiAgIC8qIEdPTVAncyBkZWZh dWx0IHZhbHVlIGlzIGFjdHVhbGx5IG5laXRoZXIgYWN0aXZlIG5vciBwYXNzaXZlLiAgKi8K LSAgZnByaW50ZiAoc3RkZXJyLCAiICBPTVBfV0FJVF9QT0xJQ1kgPSAnJXMnXG4iLAotCSAg IHdhaXRfcG9saWN5ID4gMCA/ICJBQ1RJVkUiIDogIlBBU1NJVkUiKTsKLSAgZnByaW50ZiAo c3RkZXJyLCAiICBPTVBfVEhSRUFEX0xJTUlUID0gJyV1J1xuIiwKLQkgICBnb21wX2dsb2Jh bF9pY3YudGhyZWFkX2xpbWl0X3Zhcik7Ci0gIGZwcmludGYgKHN0ZGVyciwgIiAgT01QX01B WF9BQ1RJVkVfTEVWRUxTID0gJyV1J1xuIiwKLQkgICBnb21wX2dsb2JhbF9pY3YubWF4X2Fj dGl2ZV9sZXZlbHNfdmFyKTsKLSAgZnByaW50ZiAoc3RkZXJyLCAiICBPTVBfTlVNX1RFQU1T ID0gJyV1J1xuIiwgZ29tcF9udGVhbXNfdmFyKTsKLSAgZnByaW50ZiAoc3RkZXJyLCAiICBP TVBfVEVBTVNfVEhSRUFEX0xJTUlUID0gJyV1J1xuIiwKLQkgICBnb21wX3RlYW1zX3RocmVh ZF9saW1pdF92YXIpOwotCi0gIGZwcmludGYgKHN0ZGVyciwgIiAgT01QX0NBTkNFTExBVElP TiA9ICclcydcbiIsCisgIGZwcmludGYgKHN0ZGVyciwgIiAgW2hvc3RdIE9NUF9XQUlUX1BP TElDWSA9ICclcydcbiIsCisJICAgZ29tcF9pbml0aWFsX2ljdnNfbm9uZS53YWl0X3BvbGlj eSA+IDAgPyAiQUNUSVZFIiA6ICJQQVNTSVZFIik7CisgIGlmIChnb21wX2luaXRpYWxfaWN2 X2ZsYWdzLndhaXRfcG9saWN5ICYgR09NUF9FTlZfVkFSX1NVRkZJWF9BTEwpCisgICAgZnBy aW50ZiAoc3RkZXJyLCAiICBbYWxsXSBPTVBfV0FJVF9QT0xJQ1kgPSAnJXMnXG4iLAorCSAg ICAgZ29tcF9pbml0aWFsX2ljdnNfYWxsLndhaXRfcG9saWN5ID4gMCA/ICJBQ1RJVkUiIDog IlBBU1NJVkUiKTsKKyAgaWYgKGdvbXBfaW5pdGlhbF9pY3ZfZmxhZ3Mud2FpdF9wb2xpY3kg JiBHT01QX0VOVl9WQVJfU1VGRklYX0RFVikKKyAgICBmcHJpbnRmIChzdGRlcnIsICIgIFtk ZXZpY2VdIE9NUF9XQUlUX1BPTElDWSA9ICclcydcbiIsCisJICAgICBnb21wX2luaXRpYWxf aWN2c19kZXYud2FpdF9wb2xpY3kgPiAwID8gIkFDVElWRSIgOiAiUEFTU0lWRSIpOworICBw cmludF9kZXZpY2Vfc3BlY2lmaWNfaWN2cyAoT01QX1dBSVRfUE9MSUNZX0RFVl8pOworCisg IGZwcmludGYgKHN0ZGVyciwgIiAgW2hvc3RdIE9NUF9USFJFQURfTElNSVQgPSAnJXUnXG4i LAorCSAgIGdvbXBfaW5pdGlhbF9pY3ZzX25vbmUudGhyZWFkX2xpbWl0X3Zhcik7CisgIGlm IChnb21wX2luaXRpYWxfaWN2X2ZsYWdzLnRocmVhZF9saW1pdF92YXIgJiBHT01QX0VOVl9W QVJfU1VGRklYX0FMTCkKKyAgICBmcHJpbnRmIChzdGRlcnIsICIgIFthbGxdIE9NUF9USFJF QURfTElNSVQgPSAnJWQnXG4iLAorCSAgICAgZ29tcF9pbml0aWFsX2ljdnNfYWxsLnRocmVh ZF9saW1pdF92YXIpOworICBpZiAoZ29tcF9pbml0aWFsX2ljdl9mbGFncy50aHJlYWRfbGlt aXRfdmFyICYgR09NUF9FTlZfVkFSX1NVRkZJWF9ERVYpCisgICAgZnByaW50ZiAoc3RkZXJy LCAiICBbZGV2aWNlXSBPTVBfVEhSRUFEX0xJTUlUID0gJyVkJ1xuIiwKKwkgICAgIGdvbXBf aW5pdGlhbF9pY3ZzX2Rldi50aHJlYWRfbGltaXRfdmFyKTsKKyAgcHJpbnRfZGV2aWNlX3Nw ZWNpZmljX2ljdnMgKE9NUF9USFJFQURfTElNSVRfREVWXyk7CisKKyAgZnByaW50ZiAoc3Rk ZXJyLCAiICBbaG9zdF0gT01QX01BWF9BQ1RJVkVfTEVWRUxTID0gJyV1J1xuIiwKKwkgICBn b21wX2luaXRpYWxfaWN2c19ub25lLm1heF9hY3RpdmVfbGV2ZWxzX3Zhcik7CisgIGlmIChn b21wX2luaXRpYWxfaWN2X2ZsYWdzLm1heF9hY3RpdmVfbGV2ZWxzX3ZhciAmIEdPTVBfRU5W X1ZBUl9TVUZGSVhfQUxMKQorICAgIGZwcmludGYgKHN0ZGVyciwgIiAgW2FsbF0gT01QX01B WF9BQ1RJVkVfTEVWRUxTID0gJyV1J1xuIiwKKwkgICAgIGdvbXBfaW5pdGlhbF9pY3ZzX2Fs bC5tYXhfYWN0aXZlX2xldmVsc192YXIpOworICBpZiAoZ29tcF9pbml0aWFsX2ljdl9mbGFn cy5tYXhfYWN0aXZlX2xldmVsc192YXIgJiBHT01QX0VOVl9WQVJfU1VGRklYX0RFVikKKyAg ICBmcHJpbnRmIChzdGRlcnIsICIgIFtkZXZpY2VdIE9NUF9NQVhfQUNUSVZFX0xFVkVMUyA9 ICcldSdcbiIsCisJICAgICBnb21wX2luaXRpYWxfaWN2c19kZXYubWF4X2FjdGl2ZV9sZXZl bHNfdmFyKTsKKyAgcHJpbnRfZGV2aWNlX3NwZWNpZmljX2ljdnMgKE9NUF9NQVhfQUNUSVZF X0xFVkVMU19ERVZfKTsKKworCisgIGZwcmludGYgKHN0ZGVyciwgIiAgW2hvc3RdIE9NUF9O VU1fVEVBTVMgPSAnJWQnXG4iLAorCSAgIGdvbXBfaW5pdGlhbF9pY3ZzX25vbmUubnRlYW1z X3Zhcik7CisgIGlmIChnb21wX2luaXRpYWxfaWN2X2ZsYWdzLm50ZWFtc192YXIgJiBHT01Q X0VOVl9WQVJfU1VGRklYX0FMTCkKKyAgICBmcHJpbnRmIChzdGRlcnIsICIgIFthbGxdIE9N UF9OVU1fVEVBTVMgPSAnJWQnXG4iLAorCSAgICAgZ29tcF9pbml0aWFsX2ljdnNfYWxsLm50 ZWFtc192YXIpOworICBpZiAoZ29tcF9pbml0aWFsX2ljdl9mbGFncy5udGVhbXNfdmFyICYg R09NUF9FTlZfVkFSX1NVRkZJWF9ERVYpCisgICAgZnByaW50ZiAoc3RkZXJyLCAiICBbZGV2 aWNlXSBPTVBfTlVNX1RFQU1TID0gJyVkJ1xuIiwKKwkgICAgIGdvbXBfaW5pdGlhbF9pY3Zz X2Rldi5udGVhbXNfdmFyKTsKKyAgcHJpbnRfZGV2aWNlX3NwZWNpZmljX2ljdnMgKE9NUF9O VU1fVEVBTVNfREVWXyk7CisKKyAgZnByaW50ZiAoc3RkZXJyLCAiICBbaG9zdF0gT01QX1RF QU1TX1RIUkVBRF9MSU1JVCA9ICcldSdcbiIsCisJICAgZ29tcF9pbml0aWFsX2ljdnNfbm9u ZS50ZWFtc190aHJlYWRfbGltaXRfdmFyKTsKKyAgaWYgKGdvbXBfaW5pdGlhbF9pY3ZfZmxh Z3MudGVhbXNfdGhyZWFkX2xpbWl0X3ZhciAmIEdPTVBfRU5WX1ZBUl9TVUZGSVhfQUxMKQor ICAgIGZwcmludGYgKHN0ZGVyciwgIiAgW2FsbF0gT01QX1RFQU1TX1RIUkVBRF9MSU1JVCA9 ICcldSdcbiIsCisJICAgICBnb21wX2luaXRpYWxfaWN2c19hbGwudGVhbXNfdGhyZWFkX2xp bWl0X3Zhcik7CisgIGlmIChnb21wX2luaXRpYWxfaWN2X2ZsYWdzLnRlYW1zX3RocmVhZF9s aW1pdF92YXIgJiBHT01QX0VOVl9WQVJfU1VGRklYX0RFVikKKyAgICBmcHJpbnRmIChzdGRl cnIsICIgIFtkZXZpY2VdIE9NUF9URUFNU19USFJFQURfTElNSVQgPSAnJXUnXG4iLAorCSAg ICAgZ29tcF9pbml0aWFsX2ljdnNfZGV2LnRlYW1zX3RocmVhZF9saW1pdF92YXIpOworICBw cmludF9kZXZpY2Vfc3BlY2lmaWNfaWN2cyAoT01QX1RFQU1TX1RIUkVBRF9MSU1JVF9ERVZf KTsKKworICBmcHJpbnRmIChzdGRlcnIsICIgIFtob3N0XSBPTVBfQ0FOQ0VMTEFUSU9OID0g JyVzJ1xuIiwKIAkgICBnb21wX2NhbmNlbF92YXIgPyAiVFJVRSIgOiAiRkFMU0UiKTsKLSAg ZnByaW50ZiAoc3RkZXJyLCAiICBPTVBfREVGQVVMVF9ERVZJQ0UgPSAnJWQnXG4iLAotCSAg IGdvbXBfZ2xvYmFsX2ljdi5kZWZhdWx0X2RldmljZV92YXIpOwotICBmcHJpbnRmIChzdGRl cnIsICIgIE9NUF9NQVhfVEFTS19QUklPUklUWSA9ICclZCdcbiIsCisKKyAgZnByaW50ZiAo c3RkZXJyLCAiICBbaG9zdF0gT01QX0RFRkFVTFRfREVWSUNFID0gJyVkJ1xuIiwKKwkgICBn b21wX2luaXRpYWxfaWN2c19ub25lLmRlZmF1bHRfZGV2aWNlX3Zhcik7CisKKyAgZnByaW50 ZiAoc3RkZXJyLCAiICBbaG9zdF0gT01QX01BWF9UQVNLX1BSSU9SSVRZID0gJyVkJ1xuIiwK IAkgICBnb21wX21heF90YXNrX3ByaW9yaXR5X3Zhcik7Ci0gIGZwcmludGYgKHN0ZGVyciwg IiAgT01QX0RJU1BMQVlfQUZGSU5JVFkgPSAnJXMnXG4iLAorICBmcHJpbnRmIChzdGRlcnIs ICIgIFtob3N0XSBPTVBfRElTUExBWV9BRkZJTklUWSA9ICclcydcbiIsCiAJICAgZ29tcF9k aXNwbGF5X2FmZmluaXR5X3ZhciA/ICJUUlVFIiA6ICJGQUxTRSIpOwotICBmcHJpbnRmIChz dGRlcnIsICIgIE9NUF9BRkZJTklUWV9GT1JNQVQgPSAnJXMnXG4iLAorICBmcHJpbnRmIChz dGRlcnIsICIgIFtob3N0XSBPTVBfQUZGSU5JVFlfRk9STUFUID0gJyVzJ1xuIiwKIAkgICBn b21wX2FmZmluaXR5X2Zvcm1hdF92YXIpOwotICBmcHJpbnRmIChzdGRlcnIsICIgIE9NUF9B TExPQ0FUT1IgPSAnIik7CisgIGZwcmludGYgKHN0ZGVyciwgIiAgW2hvc3RdIE9NUF9BTExP Q0FUT1IgPSAnIik7CiAgIHN3aXRjaCAoZ29tcF9kZWZfYWxsb2NhdG9yKQogICAgIHsKICNk ZWZpbmUgQyh2KSBjYXNlIHY6IGZwdXRzICgjdiwgc3RkZXJyKTsgYnJlYWs7CkBAIC0xMzg3 LDcgKzE3OTksNyBAQCBvbXBfZGlzcGxheV9lbnYgKGludCB2ZXJib3NlKQogICAgIH0KICAg ZnB1dHMgKCInXG4iLCBzdGRlcnIpOwogCi0gIGZwdXRzICgiICBPTVBfVEFSR0VUX09GRkxP QUQgPSAnIiwgc3RkZXJyKTsKKyAgZnB1dHMgKCIgIFtob3N0XSBPTVBfVEFSR0VUX09GRkxP QUQgPSAnIiwgc3RkZXJyKTsKICAgc3dpdGNoIChnb21wX3RhcmdldF9vZmZsb2FkX3ZhcikK ICAgICB7CiAgICAgY2FzZSBHT01QX1RBUkdFVF9PRkZMT0FEX0RFRkFVTFQ6CkBAIC0xNDA0 LDEzICsxODE2LDEzIEBAIG9tcF9kaXNwbGF5X2VudiAoaW50IHZlcmJvc2UpCiAKICAgaWYg KHZlcmJvc2UpCiAgICAgewotICAgICAgZnB1dHMgKCIgIEdPTVBfQ1BVX0FGRklOSVRZID0g JydcbiIsIHN0ZGVycik7Ci0gICAgICBmcHJpbnRmIChzdGRlcnIsICIgIEdPTVBfU1RBQ0tT SVpFID0gJyVsdSdcbiIsIHN0YWNrc2l6ZSk7CisgICAgICBmcHV0cyAoIiAgW2hvc3RdIEdP TVBfQ1BVX0FGRklOSVRZID0gJydcbiIsIHN0ZGVycik7CisgICAgICBmcHJpbnRmIChzdGRl cnIsICIgIFtob3N0XSBHT01QX1NUQUNLU0laRSA9ICclbHUnXG4iLCBzdGFja3NpemUpOwog I2lmZGVmIEhBVkVfSU5UVFlQRVNfSAotICAgICAgZnByaW50ZiAoc3RkZXJyLCAiICBHT01Q X1NQSU5DT1VOVCA9ICclIlBSSXU2NCInXG4iLAorICAgICAgZnByaW50ZiAoc3RkZXJyLCAi ICBbaG9zdF0gR09NUF9TUElOQ09VTlQgPSAnJSJQUkl1NjQiJ1xuIiwKIAkgICAgICAgKHVp bnQ2NF90KSBnb21wX3NwaW5fY291bnRfdmFyKTsKICNlbHNlCi0gICAgICBmcHJpbnRmIChz dGRlcnIsICIgIEdPTVBfU1BJTkNPVU5UID0gJyVsdSdcbiIsCisgICAgICBmcHJpbnRmIChz dGRlcnIsICIgIFtob3N0XSBHT01QX1NQSU5DT1VOVCA9ICclbHUnXG4iLAogCSAgICAgICAo dW5zaWduZWQgbG9uZykgZ29tcF9zcGluX2NvdW50X3Zhcik7CiAjZW5kaWYKICAgICB9CkBA IC0xNDU5LDY1ICsxODcxLDUwMyBAQCBoYW5kbGVfb21wX2Rpc3BsYXlfZW52ICh2b2lkKQog ICAgIGlhbGlhc19jYWxsIChvbXBfZGlzcGxheV9lbnYpICh2ZXJib3NlKTsKIH0KIAorLyog SGVscGVyIGZ1bmN0aW9uIGZvciBpbml0aWFsaXplX2Vudi4gRXh0cmFjdHMgdGhlIGRldmlj ZSBudW1iZXIgZnJvbQorICAgYW4gZW52aXJvbm1lbnQgdmFyaWFibGUgbmFtZS4gICovCisK K3N0YXRpYyBib29sCitnZXRfZGV2aWNlX251bSAoY2hhciAqZW52LCBpbnQgKmRldl9udW0s IGludCAqZGV2X251bV9sZW4pCit7CisgIGludCBwb3MgPSAwOworICBjaGFyIGRldl9udW1f c3RyW0lOVF9NQVhfU1RSX0xFTisxXTsKKworICAqZGV2X251bV9sZW4gPSAwOworICAqZGV2 X251bSA9IC0xOworICBpZiAoZW52ID09IE5VTEwpCisgICAgcmV0dXJuIGZhbHNlOworCisg IHdoaWxlIChwb3MgPCBJTlRfTUFYX1NUUl9MRU4pCisgICAgeworICAgICAgaWYgKGVudltw b3NdID09ICdcMCcgfHwgZW52W3Bvc10gPT0gJz0nKQorCWJyZWFrOworICAgICAgZGV2X251 bV9zdHJbcG9zXSA9IGVudltwb3NdOworICAgICAgcG9zKys7CisgICAgfQorCisgIGlmIChl bnZbcG9zXSAhPSAnPScgfHwgKGRldl9udW1fc3RyWzBdID09ICcwJyAmJiBwb3MgPiAxKSkK KyAgICByZXR1cm4gZmFsc2U7CisKKyAgZGV2X251bV9zdHJbcG9zXSA9ICdcMCc7CisgICpk ZXZfbnVtID0gKGludCkgc3RydG91bCAoZGV2X251bV9zdHIsIDAsIDEwKTsKKyAgKmRldl9u dW1fbGVuID0gcG9zOworICByZXR1cm4gdHJ1ZTsKK30KKworLyogSGVscGVyIGZ1bmN0aW9u IGZvciBpbml0aWFsaXplX2VudiB0byBhZGQgYSBkZXZpY2Ugc3BlY2lmaWMgSUNWIHZhbHVl CisgICB0byBnb21wX2luaXRpYWxfaWN2X2Rldl9saXN0LiAgKi8KKworc3RhdGljIHZvaWQK K2FkZF9kZXZpY2Vfc3BlY2lmaWNfaWN2IChpbnQgZGV2X251bSwgaW50IGljdl9jb2RlLCB2 b2lkICp2YWx1ZSkKK3sKKyAgc3RydWN0IGdvbXBfaWN2X2xpc3QgKmxpc3QgPSBnb21wX2lu aXRpYWxfaWN2X2Rldl9saXN0OworICB3aGlsZSAobGlzdCAhPSBOVUxMICYmIGxpc3QtPmRl dmljZV9udW0gIT0gZGV2X251bSkKKyAgICBsaXN0ID0gbGlzdC0+bmV4dDsKKworICBpZiAo bGlzdCA9PSBOVUxMKQorICAgIHsKKyAgICAgIGxpc3QgPQorCShzdHJ1Y3QgZ29tcF9pY3Zf bGlzdCAqKSBnb21wX21hbGxvYyAoc2l6ZW9mIChzdHJ1Y3QgZ29tcF9pY3ZfbGlzdCkpOwor ICAgICAgbGlzdC0+bmV4dCA9IGdvbXBfaW5pdGlhbF9pY3ZfZGV2X2xpc3Q7CisgICAgICBs aXN0LT5kZXZpY2VfbnVtID0gZGV2X251bTsKKyAgICAgIGxpc3QtPmZsYWdzICA9IChzdHJ1 Y3QgZ29tcF9pY3ZfZmxhZ3MpIHsKKwkubnRocmVhZHNfdmFyID0gR09NUF9FTlZfVkFSX1NV RkZJWF9VTktOT1dOLAorCS5udGhyZWFkc192YXJfbGlzdCA9IEdPTVBfRU5WX1ZBUl9TVUZG SVhfVU5LTk9XTiwKKwkubnRocmVhZHNfdmFyX2xpc3RfbGVuID0gR09NUF9FTlZfVkFSX1NV RkZJWF9VTktOT1dOLAorCS5ydW5fc2NoZWRfdmFyID0gR09NUF9FTlZfVkFSX1NVRkZJWF9V TktOT1dOLAorCS5ydW5fc2NoZWRfY2h1bmtfc2l6ZSA9IEdPTVBfRU5WX1ZBUl9TVUZGSVhf VU5LTk9XTiwKKwkudGhyZWFkX2xpbWl0X3ZhciA9IEdPTVBfRU5WX1ZBUl9TVUZGSVhfVU5L Tk9XTiwKKwkuZHluX3ZhciA9IEdPTVBfRU5WX1ZBUl9TVUZGSVhfVU5LTk9XTiwKKwkubWF4 X2FjdGl2ZV9sZXZlbHNfdmFyID0gR09NUF9FTlZfVkFSX1NVRkZJWF9VTktOT1dOLAorCS5i aW5kX3ZhciA9IEdPTVBfRU5WX1ZBUl9TVUZGSVhfVU5LTk9XTiwKKwkuYmluZF92YXJfbGlz dCA9IEdPTVBfRU5WX1ZBUl9TVUZGSVhfVU5LTk9XTiwKKwkuYmluZF92YXJfbGlzdF9sZW4g PSBHT01QX0VOVl9WQVJfU1VGRklYX1VOS05PV04sCisJLm50ZWFtc192YXIgPSBHT01QX0VO Vl9WQVJfU1VGRklYX1VOS05PV04sCisJLnN0YWNrc2l6ZSA9IEdPTVBfRU5WX1ZBUl9TVUZG SVhfVU5LTk9XTiwKKwkud2FpdF9wb2xpY3kgPSBHT01QX0VOVl9WQVJfU1VGRklYX1VOS05P V04sCisJLnRlYW1zX3RocmVhZF9saW1pdF92YXIgPSBHT01QX0VOVl9WQVJfU1VGRklYX1VO S05PV04sCisJLmRlZmF1bHRfZGV2aWNlX3ZhciA9IEdPTVBfRU5WX1ZBUl9TVUZGSVhfVU5L Tk9XTiwKKyAgICAgIH07CisgICAgICBnb21wX2luaXRpYWxfaWN2X2Rldl9saXN0ID0gbGlz dDsKKyAgICB9CisKKyAgc3dpdGNoIChpY3ZfY29kZSkKKyAgICB7CisgICAgY2FzZSBPTVBf TlVNX1RFQU1TX0RFVl86CisgICAgICBsaXN0LT5pY3ZzLm50ZWFtc192YXIgPSAqKGludCAq KSB2YWx1ZTsKKyAgICAgIGxpc3QtPmZsYWdzLm50ZWFtc192YXIgfD0gR09NUF9FTlZfVkFS X1NVRkZJWF9ERVZfWDsKKyAgICAgIGJyZWFrOworICAgIGNhc2UgT01QX0RZTkFNSUNfREVW XzoKKyAgICAgIGxpc3QtPmljdnMuZHluX3ZhciA9ICooYm9vbCAqKSB2YWx1ZTsKKyAgICAg IGxpc3QtPmZsYWdzLmR5bl92YXIgfD0gR09NUF9FTlZfVkFSX1NVRkZJWF9ERVZfWDsKKyAg ICAgIGJyZWFrOworICAgIGNhc2UgT01QX1RFQU1TX1RIUkVBRF9MSU1JVF9ERVZfOgorICAg ICAgbGlzdC0+aWN2cy50ZWFtc190aHJlYWRfbGltaXRfdmFyID0gKihpbnQgKikgdmFsdWU7 CisgICAgICBsaXN0LT5mbGFncy50ZWFtc190aHJlYWRfbGltaXRfdmFyIHw9IEdPTVBfRU5W X1ZBUl9TVUZGSVhfREVWX1g7CisgICAgYnJlYWs7CisgICAgICBjYXNlIE9NUF9TQ0hFRFVM RV9ERVZfOgorICAgICAgbGlzdC0+aWN2cy5ydW5fc2NoZWRfdmFyID0gKihlbnVtIGdvbXBf c2NoZWR1bGVfdHlwZSAqKSB2YWx1ZTsKKyAgICAgIGxpc3QtPmZsYWdzLnJ1bl9zY2hlZF92 YXIgfD0gR09NUF9FTlZfVkFSX1NVRkZJWF9ERVZfWDsKKyAgICAgIGJyZWFrOworICAgIGNh c2UgT01QX1NDSEVEVUxFX0NIVU5LX1NJWkVfREVWXzoKKyAgICAgIGxpc3QtPmljdnMucnVu X3NjaGVkX2NodW5rX3NpemUgPSAqKGludCAqKSB2YWx1ZTsKKyAgICAgIGxpc3QtPmZsYWdz LnJ1bl9zY2hlZF9jaHVua19zaXplIHw9IEdPTVBfRU5WX1ZBUl9TVUZGSVhfREVWX1g7Cisg ICAgICBicmVhazsKKyAgICBjYXNlIE9NUF9USFJFQURfTElNSVRfREVWXzoKKyAgICAgIGxp c3QtPmljdnMudGhyZWFkX2xpbWl0X3ZhciA9ICoodW5zaWduZWQgaW50ICopIHZhbHVlOwor ICAgICAgbGlzdC0+ZmxhZ3MudGhyZWFkX2xpbWl0X3ZhciB8PSBHT01QX0VOVl9WQVJfU1VG RklYX0RFVl9YOworICAgICAgYnJlYWs7CisgICAgY2FzZSBPTVBfTlVNX1RIUkVBRFNfREVW XzoKKyAgICAgIGxpc3QtPmljdnMubnRocmVhZHNfdmFyID0gKih1bnNpZ25lZCBsb25nICop IHZhbHVlOworICAgICAgbGlzdC0+ZmxhZ3MubnRocmVhZHNfdmFyIHw9IEdPTVBfRU5WX1ZB Ul9TVUZGSVhfREVWX1g7CisgICAgICBicmVhazsKKyAgICBjYXNlIE9NUF9OVEhSRUFEU19M SVNUX0RFVjoKKyAgICAgIGxpc3QtPmljdnMubnRocmVhZHNfdmFyX2xpc3QgPSAqKHVuc2ln bmVkIGxvbmcgKiopIHZhbHVlOworICAgICAgbGlzdC0+ZmxhZ3MubnRocmVhZHNfdmFyX2xp c3QgfD0gR09NUF9FTlZfVkFSX1NVRkZJWF9ERVZfWDsKKyAgICAgIGJyZWFrOworICAgIGNh c2UgT01QX05USFJFQURTX0xJU1RfTEVOX0RFVjoKKyAgICAgIGxpc3QtPmljdnMubnRocmVh ZHNfdmFyX2xpc3RfbGVuID0gKih1bnNpZ25lZCBsb25nICopIHZhbHVlOworICAgICAgbGlz dC0+ZmxhZ3MubnRocmVhZHNfdmFyX2xpc3RfbGVuIHw9IEdPTVBfRU5WX1ZBUl9TVUZGSVhf REVWX1g7CisgICAgICBicmVhazsKKyAgICBjYXNlIE9NUF9NQVhfQUNUSVZFX0xFVkVMU19E RVZfOgorICAgICAgbGlzdC0+aWN2cy5tYXhfYWN0aXZlX2xldmVsc192YXIgPSAqKHVuc2ln bmVkIGxvbmcgKikgdmFsdWU7CisgICAgICBsaXN0LT5mbGFncy5tYXhfYWN0aXZlX2xldmVs c192YXIgfD0gR09NUF9FTlZfVkFSX1NVRkZJWF9ERVZfWDsKKyAgICAgIGJyZWFrOworICAg IGNhc2UgT01QX1BST0NfQklORF9ERVZfOgorICAgICAgbGlzdC0+aWN2cy5iaW5kX3ZhciA9 ICooY2hhciAqKSB2YWx1ZTsKKyAgICAgIGxpc3QtPmZsYWdzLmJpbmRfdmFyIHw9IEdPTVBf RU5WX1ZBUl9TVUZGSVhfREVWX1g7CisgICAgICBicmVhazsKKyAgICBjYXNlIE9NUF9QUk9D X0JJTkRfTElTVF9ERVZfOgorICAgICAgbGlzdC0+aWN2cy5iaW5kX3Zhcl9saXN0ID0gKihj aGFyICoqKSB2YWx1ZTsKKyAgICAgIGxpc3QtPmZsYWdzLmJpbmRfdmFyX2xpc3QgfD0gR09N UF9FTlZfVkFSX1NVRkZJWF9ERVZfWDsKKyAgICAgIGJyZWFrOworICAgIGNhc2UgT01QX1BS T0NfQklORF9MSVNUX0xFTl9ERVZfOgorICAgICAgbGlzdC0+aWN2cy5iaW5kX3Zhcl9saXN0 X2xlbiA9ICoodW5zaWduZWQgbG9uZyAqKSB2YWx1ZTsKKyAgICAgIGxpc3QtPmZsYWdzLmJp bmRfdmFyX2xpc3RfbGVuIHw9IEdPTVBfRU5WX1ZBUl9TVUZGSVhfREVWX1g7CisgICAgICBi cmVhazsKKyAgICBjYXNlIE9NUF9XQUlUX1BPTElDWV9ERVZfOgorICAgICAgbGlzdC0+aWN2 cy53YWl0X3BvbGljeSA9ICooaW50ICopIHZhbHVlOworICAgICAgbGlzdC0+ZmxhZ3Mud2Fp dF9wb2xpY3kgfD0gR09NUF9FTlZfVkFSX1NVRkZJWF9ERVZfWDsKKyAgICAgIGJyZWFrOwor ICAgIGNhc2UgT01QX1NUQUNLU0laRV9ERVZfOgorICAgICAgbGlzdC0+aWN2cy5zdGFja3Np emUgPSAqKHVuc2lnbmVkIGxvbmcgKikgdmFsdWU7CisgICAgICBsaXN0LT5mbGFncy5zdGFj a3NpemUgfD0gR09NUF9FTlZfVkFSX1NVRkZJWF9ERVZfWDsKKyAgICAgIGJyZWFrOworICAg IH0KK30KKworLyogUmV0dXJuIHRydWUgaWYgU1RSIHN0cmluZyBzdGFydHMgd2l0aCBQUkVG SVguICAqLworCitzdGF0aWMgaW5saW5lIGJvb2wKK3N0YXJ0c3dpdGggKGNvbnN0IGNoYXIg KnN0ciwgY29uc3QgY2hhciAqcHJlZml4KQoreworICByZXR1cm4gc3RybmNtcCAoc3RyLCBw cmVmaXgsIHN0cmxlbiAocHJlZml4KSkgPT0gMDsKK30KKworc3RhdGljIHVuc2lnbmVkIGNo YXIKK2dldF9pY3ZfZmxhZyAodW5zaWduZWQgY2hhciBmbGFnX3ZhcikKK3sKKyAgc3dpdGNo IChmbGFnX3ZhcikKKyAgICB7CisgICAgY2FzZSBPTVBfTlVNX1RFQU1TX0RFVl86CisgICAg ICByZXR1cm4gZ29tcF9pbml0aWFsX2ljdl9mbGFncy5udGVhbXNfdmFyOworICAgIGNhc2Ug T01QX1NDSEVEVUxFX0RFVl86CisgICAgICByZXR1cm4gZ29tcF9pbml0aWFsX2ljdl9mbGFn cy5ydW5fc2NoZWRfdmFyOworICAgIGNhc2UgT01QX1NDSEVEVUxFX0NIVU5LX1NJWkVfREVW XzoKKyAgICAgIHJldHVybiBnb21wX2luaXRpYWxfaWN2X2ZsYWdzLnJ1bl9zY2hlZF9jaHVu a19zaXplOworICAgIGNhc2UgT01QX0RZTkFNSUNfREVWXzoKKyAgICAgIHJldHVybiBnb21w X2luaXRpYWxfaWN2X2ZsYWdzLmR5bl92YXI7CisgICAgY2FzZSBPTVBfVEVBTVNfVEhSRUFE X0xJTUlUX0RFVl86CisgICAgICByZXR1cm4gZ29tcF9pbml0aWFsX2ljdl9mbGFncy50ZWFt c190aHJlYWRfbGltaXRfdmFyOworICAgIGNhc2UgT01QX1RIUkVBRF9MSU1JVF9ERVZfOgor ICAgICAgcmV0dXJuIGdvbXBfaW5pdGlhbF9pY3ZfZmxhZ3MudGhyZWFkX2xpbWl0X3ZhcjsK KyAgICBjYXNlIE9NUF9OVU1fVEhSRUFEU19ERVZfOgorICAgICAgcmV0dXJuIGdvbXBfaW5p dGlhbF9pY3ZfZmxhZ3MubnRocmVhZHNfdmFyOworICAgIGNhc2UgT01QX05USFJFQURTX0xJ U1RfREVWOgorICAgICAgcmV0dXJuIGdvbXBfaW5pdGlhbF9pY3ZfZmxhZ3MubnRocmVhZHNf dmFyX2xpc3Q7CisgICAgY2FzZSBPTVBfTlRIUkVBRFNfTElTVF9MRU5fREVWOgorICAgICAg cmV0dXJuIGdvbXBfaW5pdGlhbF9pY3ZfZmxhZ3MubnRocmVhZHNfdmFyX2xpc3RfbGVuOwor ICAgIGNhc2UgT01QX1BST0NfQklORF9ERVZfOgorICAgICAgcmV0dXJuIGdvbXBfaW5pdGlh bF9pY3ZfZmxhZ3MuYmluZF92YXI7CisgICAgY2FzZSBPTVBfUFJPQ19CSU5EX0xJU1RfREVW XzoKKyAgICAgIHJldHVybiBnb21wX2luaXRpYWxfaWN2X2ZsYWdzLmJpbmRfdmFyX2xpc3Q7 CisgICAgY2FzZSBPTVBfUFJPQ19CSU5EX0xJU1RfTEVOX0RFVl86CisgICAgICByZXR1cm4g Z29tcF9pbml0aWFsX2ljdl9mbGFncy5iaW5kX3Zhcl9saXN0X2xlbjsKKyAgICBjYXNlIE9N UF9NQVhfQUNUSVZFX0xFVkVMU19ERVZfOgorICAgICAgcmV0dXJuIGdvbXBfaW5pdGlhbF9p Y3ZfZmxhZ3MubWF4X2FjdGl2ZV9sZXZlbHNfdmFyOworICAgIGNhc2UgT01QX1dBSVRfUE9M SUNZX0RFVl86CisgICAgICByZXR1cm4gZ29tcF9pbml0aWFsX2ljdl9mbGFncy53YWl0X3Bv bGljeTsKKyAgICBjYXNlIE9NUF9TVEFDS1NJWkVfREVWXzoKKyAgICAgIHJldHVybiBnb21w X2luaXRpYWxfaWN2X2ZsYWdzLnN0YWNrc2l6ZTsKKyAgICBjYXNlIE9NUF9ERUZBVUxUX0RF VklDRV9ERVZfOgorICAgICAgcmV0dXJuIGdvbXBfaW5pdGlhbF9pY3ZfZmxhZ3MuZGVmYXVs dF9kZXZpY2VfdmFyOworICAgIGRlZmF1bHQ6CisgICAgICByZXR1cm4gT01QX05PTkU7Cisg ICAgfQorfQorCitzdGF0aWMgYm9vbAorc2V0X2ljdl9mbGFnICh1bnNpZ25lZCBjaGFyIGZs YWdfdmFyLCB1bnNpZ25lZCBjaGFyIGZsYWcpCit7CisgIHN3aXRjaCAoZmxhZ192YXIpCisg ICAgeworICAgIGNhc2UgT01QX05PTkU6CisgICAgICByZXR1cm4gZmFsc2U7CisgICAgY2Fz ZSBPTVBfTlVNX1RFQU1TX0RFVl86CisgICAgICBnb21wX2luaXRpYWxfaWN2X2ZsYWdzLm50 ZWFtc192YXIgfD0gZmxhZzsKKyAgICAgIGJyZWFrOworICAgIGNhc2UgT01QX1NDSEVEVUxF X0RFVl86CisgICAgICBnb21wX2luaXRpYWxfaWN2X2ZsYWdzLnJ1bl9zY2hlZF92YXIgfD0g ZmxhZzsKKyAgICAgIGJyZWFrOworICAgIGNhc2UgT01QX1NDSEVEVUxFX0NIVU5LX1NJWkVf REVWXzoKKyAgICAgIGdvbXBfaW5pdGlhbF9pY3ZfZmxhZ3MucnVuX3NjaGVkX2NodW5rX3Np emUgfD0gZmxhZzsKKyAgICAgIGJyZWFrOworICAgIGNhc2UgT01QX0RZTkFNSUNfREVWXzoK KyAgICAgIGdvbXBfaW5pdGlhbF9pY3ZfZmxhZ3MuZHluX3ZhciB8PSBmbGFnOworICAgICAg YnJlYWs7CisgICAgY2FzZSBPTVBfVEVBTVNfVEhSRUFEX0xJTUlUX0RFVl86CisgICAgICBn b21wX2luaXRpYWxfaWN2X2ZsYWdzLnRlYW1zX3RocmVhZF9saW1pdF92YXIgfD0gZmxhZzsK KyAgICAgIGJyZWFrOworICAgIGNhc2UgT01QX1RIUkVBRF9MSU1JVF9ERVZfOgorICAgICAg Z29tcF9pbml0aWFsX2ljdl9mbGFncy50aHJlYWRfbGltaXRfdmFyIHw9IGZsYWc7CisgICAg ICBicmVhazsKKyAgICBjYXNlIE9NUF9OVU1fVEhSRUFEU19ERVZfOgorICAgICAgZ29tcF9p bml0aWFsX2ljdl9mbGFncy5udGhyZWFkc192YXIgfD0gZmxhZzsKKyAgICAgIGJyZWFrOwor ICAgIGNhc2UgT01QX05USFJFQURTX0xJU1RfREVWOgorICAgICAgZ29tcF9pbml0aWFsX2lj dl9mbGFncy5udGhyZWFkc192YXJfbGlzdCB8PSBmbGFnOworICAgICAgYnJlYWs7CisgICAg Y2FzZSBPTVBfTlRIUkVBRFNfTElTVF9MRU5fREVWOgorICAgICAgZ29tcF9pbml0aWFsX2lj dl9mbGFncy5udGhyZWFkc192YXJfbGlzdF9sZW4gfD0gZmxhZzsKKyAgICAgIGJyZWFrOwor ICAgIGNhc2UgT01QX1BST0NfQklORF9ERVZfOgorICAgICAgZ29tcF9pbml0aWFsX2ljdl9m bGFncy5iaW5kX3ZhciB8PSBmbGFnOworICAgICAgYnJlYWs7CisgICAgY2FzZSBPTVBfUFJP Q19CSU5EX0xJU1RfREVWXzoKKyAgICAgIGdvbXBfaW5pdGlhbF9pY3ZfZmxhZ3MuYmluZF92 YXJfbGlzdCB8PSBmbGFnOworICAgICAgYnJlYWs7CisgICAgY2FzZSBPTVBfUFJPQ19CSU5E X0xJU1RfTEVOX0RFVl86CisgICAgICBnb21wX2luaXRpYWxfaWN2X2ZsYWdzLmJpbmRfdmFy X2xpc3RfbGVuIHw9IGZsYWc7CisgICAgICBicmVhazsKKyAgICBjYXNlIE9NUF9NQVhfQUNU SVZFX0xFVkVMU19ERVZfOgorICAgICAgZ29tcF9pbml0aWFsX2ljdl9mbGFncy5tYXhfYWN0 aXZlX2xldmVsc192YXIgfD0gZmxhZzsKKyAgICAgIGJyZWFrOworICAgIGNhc2UgT01QX1dB SVRfUE9MSUNZX0RFVl86CisgICAgICBnb21wX2luaXRpYWxfaWN2X2ZsYWdzLndhaXRfcG9s aWN5IHw9IGZsYWc7CisgICAgICBicmVhazsKKyAgICBjYXNlIE9NUF9TVEFDS1NJWkVfREVW XzoKKyAgICAgIGdvbXBfaW5pdGlhbF9pY3ZfZmxhZ3Muc3RhY2tzaXplIHw9IGZsYWc7Cisg ICAgICBicmVhazsKKyAgICBjYXNlIE9NUF9ERUZBVUxUX0RFVklDRV9ERVZfOgorICAgICAg Z29tcF9pbml0aWFsX2ljdl9mbGFncy5kZWZhdWx0X2RldmljZV92YXIgfD0gZmxhZzsKKyAg ICAgIGJyZWFrOworICAgIGRlZmF1bHQ6CisgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQor ICByZXR1cm4gdHJ1ZTsKK30KIAogc3RhdGljIHZvaWQgX19hdHRyaWJ1dGVfXygoY29uc3Ry dWN0b3IpKQogaW5pdGlhbGl6ZV9lbnYgKHZvaWQpCiB7Ci0gIHVuc2lnbmVkIGxvbmcgdGhy ZWFkX2xpbWl0X3ZhcjsKLSAgdW5zaWduZWQgbG9uZyBtYXhfYWN0aXZlX2xldmVsc192YXI7 CisgIGV4dGVybiBjaGFyICoqZW52aXJvbjsKKyAgY2hhciAqKmVudjsKKyAgaW50IG9tcF92 YXIsIGRldl9udW0gPSAwLCBkZXZfbnVtX2xlbiA9IDAsIGludF92YWx1ZSwgazsKKyAgYm9v bCBib29sX3ZhbHVlLCBpZ25vcmUgPSBmYWxzZTsKKyAgY2hhciAqZW52X3ZhbDsKIAogICAv KiBEbyBhIGNvbXBpbGUgdGltZSBjaGVjayB0aGF0IG1rb21wX2gucGwgZGlkIGdvb2Qgam9i LiAgKi8KICAgb21wX2NoZWNrX2RlZmluZXMgKCk7CiAKLSAgcGFyc2Vfc2NoZWR1bGUgKCk7 Ci0gIHBhcnNlX2Jvb2xlYW4gKCJPTVBfRFlOQU1JQyIsICZnb21wX2dsb2JhbF9pY3YuZHlu X3Zhcik7Ci0gIHBhcnNlX2Jvb2xlYW4gKCJPTVBfQ0FOQ0VMTEFUSU9OIiwgJmdvbXBfY2Fu Y2VsX3Zhcik7Ci0gIHBhcnNlX2Jvb2xlYW4gKCJPTVBfRElTUExBWV9BRkZJTklUWSIsICZn b21wX2Rpc3BsYXlfYWZmaW5pdHlfdmFyKTsKLSAgcGFyc2VfaW50ICgiT01QX0RFRkFVTFRf REVWSUNFIiwgJmdvbXBfZ2xvYmFsX2ljdi5kZWZhdWx0X2RldmljZV92YXIsIHRydWUpOwot ICBwYXJzZV90YXJnZXRfb2ZmbG9hZCAoIk9NUF9UQVJHRVRfT0ZGTE9BRCIsICZnb21wX3Rh cmdldF9vZmZsb2FkX3Zhcik7Ci0gIHBhcnNlX2ludCAoIk9NUF9NQVhfVEFTS19QUklPUklU WSIsICZnb21wX21heF90YXNrX3ByaW9yaXR5X3ZhciwgdHJ1ZSk7Ci0gIGdvbXBfZGVmX2Fs bG9jYXRvciA9IHBhcnNlX2FsbG9jYXRvciAoKTsKLSAgaWYgKHBhcnNlX3Vuc2lnbmVkX2xv bmcgKCJPTVBfVEhSRUFEX0xJTUlUIiwgJnRocmVhZF9saW1pdF92YXIsIGZhbHNlKSkKLSAg ICB7Ci0gICAgICBnb21wX2dsb2JhbF9pY3YudGhyZWFkX2xpbWl0X3ZhcgotCT0gdGhyZWFk X2xpbWl0X3ZhciA+IElOVF9NQVggPyBVSU5UX01BWCA6IHRocmVhZF9saW1pdF92YXI7Ci0g ICAgfQotICBwYXJzZV9pbnRfc2VjdXJlICgiR09NUF9ERUJVRyIsICZnb21wX2RlYnVnX3Zh ciwgdHJ1ZSk7CiAjaWZuZGVmIEhBVkVfU1lOQ19CVUlMVElOUwogICBnb21wX211dGV4X2lu aXQgKCZnb21wX21hbmFnZWRfdGhyZWFkc19sb2NrKTsKICNlbmRpZgogICBnb21wX2luaXRf bnVtX3RocmVhZHMgKCk7CiAgIGdvbXBfYXZhaWxhYmxlX2NwdXMgPSBnb21wX2dsb2JhbF9p Y3YubnRocmVhZHNfdmFyOwotICBpZiAoIXBhcnNlX3Vuc2lnbmVkX2xvbmdfbGlzdCAoIk9N UF9OVU1fVEhSRUFEUyIsCi0JCQkJICZnb21wX2dsb2JhbF9pY3YubnRocmVhZHNfdmFyLAot CQkJCSAmZ29tcF9udGhyZWFkc192YXJfbGlzdCwKLQkJCQkgJmdvbXBfbnRocmVhZHNfdmFy X2xpc3RfbGVuKSkKLSAgICBnb21wX2dsb2JhbF9pY3YubnRocmVhZHNfdmFyID0gZ29tcF9h dmFpbGFibGVfY3B1czsKLSAgcGFyc2VfaW50ICgiT01QX05VTV9URUFNUyIsICZnb21wX250 ZWFtc192YXIsIGZhbHNlKTsKLSAgcGFyc2VfaW50ICgiT01QX1RFQU1TX1RIUkVBRF9MSU1J VCIsICZnb21wX3RlYW1zX3RocmVhZF9saW1pdF92YXIsIGZhbHNlKTsKLSAgYm9vbCBpZ25v cmUgPSBmYWxzZTsKLSAgaWYgKHBhcnNlX2JpbmRfdmFyICgiT01QX1BST0NfQklORCIsCi0J CSAgICAgICZnb21wX2dsb2JhbF9pY3YuYmluZF92YXIsCi0JCSAgICAgICZnb21wX2JpbmRf dmFyX2xpc3QsCi0JCSAgICAgICZnb21wX2JpbmRfdmFyX2xpc3RfbGVuKQorCisgIGZvciAo ZW52ID0gZW52aXJvbjsgKmVudiAhPSAwOyBlbnYrKykKKyAgICB7CisgICAgICBpZiAoIXN0 YXJ0c3dpdGggKCplbnYsICJPTVBfIikpCisJY29udGludWU7CisKKyAgICAgIGZvciAob21w X3ZhciA9IDA7IG9tcF92YXIgPCBPTVBfREVWX1ZBUl9DTlQ7IG9tcF92YXIrKykKKwl7CisJ ICBpZiAoc3RhcnRzd2l0aCAoKmVudiwgZW52dmFyc19kZXZbb21wX3Zhcl0ubmFtZSkpCisJ ICAgIHsKKwkgICAgICBpZiAoc3RybGVuICgqZW52KSA8IGVudnZhcnNfZGV2W29tcF92YXJd Lm5hbWVfbGVuICsgMikKKwkJZ290byBuZXh0X3ZhcjsKKworCSAgICAgIGlmICghZ2V0X2Rl dmljZV9udW0gKCYoKmVudilbZW52dmFyc19kZXZbb21wX3Zhcl0ubmFtZV9sZW5dLAorCQkJ CSAgICZkZXZfbnVtLCAmZGV2X251bV9sZW4pKQorCQl7CisJCSAgZ29tcF9lcnJvciAoIklu dmFsaWQgZGV2aWNlIG51bWJlciBpbiAlcyIsICplbnYpOworCQkgIGdvdG8gbmV4dF92YXI7 CisJCX0KKwkgICAgICBlbnZfdmFsID0gJigqZW52KVtlbnZ2YXJzX2RldltvbXBfdmFyXS5u YW1lX2xlbiArIGRldl9udW1fbGVuICsgMV07CisKKwkgICAgICBzd2l0Y2ggKGVudnZhcnNf ZGV2W29tcF92YXJdLnBhcnNlX3R5cGUpCisJCXsKKwkJY2FzZSBQQVJTRV9JTlRfREVWOgor CQkgIGlmIChwYXJzZV9pbnQgKCplbnYsIGVudl92YWwsICh2b2lkICpbXSkgeyZpbnRfdmFs dWUsIGZhbHNlfSkpCisJCSAgICBhZGRfZGV2aWNlX3NwZWNpZmljX2ljdiAoZGV2X251bSwK KwkJCQkJICAgICBlbnZ2YXJzX2RldltvbXBfdmFyXS5pY3ZfY29kZSwKKwkJCQkJICAgICAm aW50X3ZhbHVlKTsKKwkJICBicmVhazsKKwkJY2FzZSBQQVJTRV9CT09MX0RFVjoKKwkJICBp ZiAocGFyc2VfYm9vbGVhbiAoZW52dmFyc19kZXZbb21wX3Zhcl0ubmFtZSwgZW52X3ZhbCwK KwkJCQkgICAgICh2b2lkICpbXSkgeyZib29sX3ZhbHVlfSkpCisJCSAgICBhZGRfZGV2aWNl X3NwZWNpZmljX2ljdiAoZGV2X251bSwKKwkJCQkJICAgICBlbnZ2YXJzX2RldltvbXBfdmFy XS5pY3ZfY29kZSwKKwkJCQkJICAgICAmYm9vbF92YWx1ZSk7CisJCSAgYnJlYWs7CisJCWNh c2UgUEFSU0VfU0NIRURVTEVfREVWOgorCQkgIHsKKwkJICAgIGVudW0gZ29tcF9zY2hlZHVs ZV90eXBlIHNjaGVkdWxlX3R5cGU7CisJCSAgICBpbnQgY2h1bmtfc2l6ZTsKKwkJICAgIGlm ICghcGFyc2Vfc2NoZWR1bGUgKGVudnZhcnNfZGV2W29tcF92YXJdLm5hbWUsIGVudl92YWws CisJCQkJCSAodm9pZCAqW10pIHsmc2NoZWR1bGVfdHlwZSwKKwkJCQkJCSAgICAgJmNodW5r X3NpemV9KSkKKwkJICAgICAgZ290byBuZXh0X3ZhcjsKKwkJICAgIGFkZF9kZXZpY2Vfc3Bl Y2lmaWNfaWN2IChkZXZfbnVtLCBPTVBfU0NIRURVTEVfREVWXywKKwkJCQkJICAgICAmc2No ZWR1bGVfdHlwZSk7CisJCSAgICBhZGRfZGV2aWNlX3NwZWNpZmljX2ljdiAoZGV2X251bSwK KwkJCQkJICAgICBPTVBfU0NIRURVTEVfQ0hVTktfU0laRV9ERVZfLAorCQkJCQkgICAgICZj aHVua19zaXplKTsKKwkJICAgIGJyZWFrOworCQkgIH0KKwkJY2FzZSBQQVJTRV9USFJFQURf TElNSVRfREVWOgorCQkgIHsKKwkJICAgIHVuc2lnbmVkIGxvbmcgdmFsdWU7CisJCSAgICBp ZiAoIXBhcnNlX3Vuc2lnbmVkX2xvbmcgKGVudnZhcnNfZGV2W29tcF92YXJdLm5hbWUsCisJ CQkJCSAgICAgIGVudl92YWwsCisJCQkJCSAgICAgICh2b2lkICpbXSkgeyZ2YWx1ZSwgZmFs c2UsCisJCQkJCQkJICAodm9pZCAqKSBVSU5UX01BWH0pKQorCQkgICAgICBnb3RvIG5leHRf dmFyOworCQkgICAgYWRkX2RldmljZV9zcGVjaWZpY19pY3YgKGRldl9udW0sCisJCQkJCSAg ICAgZW52dmFyc19kZXZbb21wX3Zhcl0uaWN2X2NvZGUsCisJCQkJCSAgICAgJnZhbHVlKTsK KwkJICAgIGJyZWFrOworCQkgIH0KKwkJY2FzZSBQQVJTRV9OVEhSRUFEU19ERVY6CisJCSAg eworCQkgICAgdW5zaWduZWQgbG9uZyB2YWx1ZTsKKwkJICAgIHVuc2lnbmVkIGxvbmcgKnB2 YWx1ZXM7CisJCSAgICB1bnNpZ25lZCBsb25nIG52YWx1ZXMgPSAwOworCQkgICAgaWYgKCFw YXJzZV91bnNpZ25lZF9sb25nX2xpc3QgKGVudnZhcnNfZGV2W29tcF92YXJdLm5hbWUsCisJ CQkJCQkgICBlbnZfdmFsLAorCQkJCQkJICAgKHZvaWQgKltdKSB7JnZhbHVlLCAmcHZhbHVl cywKKwkJCQkJCQkgICAgICAgJm52YWx1ZXN9KSkKKwkJICAgICAgZ290byBuZXh0X3ZhcjsK KwkJICAgIGFkZF9kZXZpY2Vfc3BlY2lmaWNfaWN2IChkZXZfbnVtLCBPTVBfTlVNX1RIUkVB RFNfREVWXywKKwkJCQkJICAgICAmdmFsdWUpOworCQkgICAgaWYgKG52YWx1ZXMgPiAwKQor CQkgICAgICB7CisJCQlhZGRfZGV2aWNlX3NwZWNpZmljX2ljdiAoZGV2X251bSwgT01QX05U SFJFQURTX0xJU1RfREVWLAorCQkJCQkJICZwdmFsdWVzKTsKKwkJCWFkZF9kZXZpY2Vfc3Bl Y2lmaWNfaWN2IChkZXZfbnVtLAorCQkJCQkJIE9NUF9OVEhSRUFEU19MSVNUX0xFTl9ERVYs CisJCQkJCQkgJm52YWx1ZXMpOworCQkgICAgICB9CisJCSAgICBicmVhazsKKwkJICB9CisJ CWNhc2UgUEFSU0VfTUFYX0FDVElWRV9MRVZFTFNfREVWOgorCQkgIHsKKwkJICAgIHVuc2ln bmVkIGxvbmcgdmFsdWU7CisJCSAgICBpZiAoIXBhcnNlX3Vuc2lnbmVkX2xvbmcgKGVudnZh cnNfZGV2W29tcF92YXJdLm5hbWUsCisJCQkJCSAgICAgIGVudl92YWwsCisJCQkJCSAgICAg ICh2b2lkICpbXSkgeyZ2YWx1ZSwKKwkJCQkJCQkgICh2b2lkICopIHRydWUsCisJCQkJCQkJ ICAodm9pZCAqKSBnb21wX3N1cHBvcnRlZF9hY3RpdmVfbGV2ZWxzfSkpCisJCSAgICAgIGdv dG8gbmV4dF92YXI7CisJCSAgICBhZGRfZGV2aWNlX3NwZWNpZmljX2ljdiAoZGV2X251bSwK KwkJCQkJICAgICBPTVBfTUFYX0FDVElWRV9MRVZFTFNfREVWXywKKwkJCQkJICAgICAmdmFs dWUpOworCQkgICAgYnJlYWs7CisJCSAgfQorCQljYXNlIFBBUlNFX1BST0NfQklORF9ERVY6 CisJCSAgeworCQkgICAgY2hhciBwMXN0dmFsdWU7CisJCSAgICBjaGFyICpwdmFsdWVzOwor CQkgICAgdW5zaWduZWQgbG9uZyBwbnZhbHVlczsKKwkJICAgIGlmICghcGFyc2VfYmluZF92 YXIgKGVudnZhcnNfZGV2W29tcF92YXJdLm5hbWUsIGVudl92YWwsCisJCQkJCSAodm9pZCAq W10pIHsmcDFzdHZhbHVlLCAmcHZhbHVlcywKKwkJCQkJCSAgICAgJnBudmFsdWVzfSkpCisJ CSAgICAgIGdvdG8gbmV4dF92YXI7CisJCSAgICBhZGRfZGV2aWNlX3NwZWNpZmljX2ljdiAo ZGV2X251bSwgT01QX1BST0NfQklORF9ERVZfLAorCQkJCQkgICAgICZwMXN0dmFsdWUpOwor CQkgICAgaWYgKHBudmFsdWVzID4gMCkKKwkJICAgICAgeworCQkJYWRkX2RldmljZV9zcGVj aWZpY19pY3YgKGRldl9udW0sCisJCQkJCQkgT01QX1BST0NfQklORF9MSVNUX0RFVl8sCisJ CQkJCQkgJnB2YWx1ZXMpOworCQkJYWRkX2RldmljZV9zcGVjaWZpY19pY3YgKGRldl9udW0s CisJCQkJCQkgT01QX1BST0NfQklORF9MSVNUX0xFTl9ERVZfLAorCQkJCQkJICZwbnZhbHVl cyk7CisJCSAgICAgIH0KKwkJICAgIGJyZWFrOworCQkgIH0KKwkJY2FzZSBQQVJTRV9XQUlU X1BPTElDWV9ERVY6CisJCSAgeworCQkgICAgaW50IHZhbHVlOworCQkgICAgaWYgKCFwYXJz ZV93YWl0X3BvbGljeSAoZW52dmFyc19kZXZbb21wX3Zhcl0ubmFtZSwgZW52X3ZhbCwKKwkJ CQkJICAgICh2b2lkICpbXSkgeyZ2YWx1ZX0pKQorCQkgICAgICBnb3RvIG5leHRfdmFyOwor CQkgICAgYWRkX2RldmljZV9zcGVjaWZpY19pY3YgKGRldl9udW0sIE9NUF9XQUlUX1BPTElD WV9ERVZfLAorCQkJCQkgICAgICZ2YWx1ZSk7CisJCSAgICBicmVhazsKKwkJICB9CisJCWNh c2UgUEFSU0VfU1RBQ0tTSVpFX0RFVjoKKwkJICB7CisJCSAgICB1bnNpZ25lZCBsb25nIHZh bHVlOworCQkgICAgaWYgKHBhcnNlX3N0YWNrc2l6ZSAoZW52dmFyc19kZXZbb21wX3Zhcl0u bmFtZSwgZW52X3ZhbCwKKwkJCQkJICh2b2lkICpbXSkgeyZ2YWx1ZX0pKQorCQkgICAgICBh ZGRfZGV2aWNlX3NwZWNpZmljX2ljdiAoZGV2X251bSwgT01QX1NUQUNLU0laRV9ERVZfLAor CQkJCQkgICAgICAgJnZhbHVlKTsKKwkJICAgIGJyZWFrOworCQkgIH0KKwkJfQorCSAgICAg IGdvdG8gbmV4dF92YXI7CisJICAgIH0KKwl9CisKKyAgICAgIGZvciAob21wX3ZhciA9IDA7 IG9tcF92YXIgPCBPTVBfVkFSX0NOVDsgb21wX3ZhcisrKQorCXsKKwkgIGlmIChzdGFydHN3 aXRoICgqZW52LCBlbnZ2YXJzW29tcF92YXJdLm5hbWUpKQorCSAgICB7CisJICAgICAgaWYg KCgqZW52KVtlbnZ2YXJzW29tcF92YXJdLm5hbWVfbGVuXSAhPSAnPScpCisJCWJyZWFrOwor CSAgICAgIGVudl92YWwgPSAmKCplbnYpW2VudnZhcnNbb21wX3Zhcl0ubmFtZV9sZW4gKyAx XTsKKworCSAgICAgIGlmIChlbnZ2YXJzW29tcF92YXJdLnBhcnNlX2Z1bmMgKCplbnYsCisJ CQkJCSAgICAgICBlbnZfdmFsLAorCQkJCQkgICAgICAgZW52dmFyc1tvbXBfdmFyXS5wYXJh bXMpKQorCQlmb3IgKGsgPSAwOyBrIDwgMzsgaysrKQorCQkgIGlmICghc2V0X2ljdl9mbGFn IChlbnZ2YXJzW29tcF92YXJdLmZsYWdfdmFyc1trXSwKKwkJCQkgICAgIGVudnZhcnNbb21w X3Zhcl0uZmxhZykpCisJCSAgICBicmVhazsKKwkgICAgICBicmVhazsKKwkgICAgfQorCX0K KworIG5leHRfdmFyOgorICAgIH0KKworICAgIGZvciAob21wX3ZhciA9IDA7IG9tcF92YXIg PCBPTVBfSE9TVF9WQVJfQ05UOyBvbXBfdmFyKyspCisgICAgICB7CisJdm9pZCAqc3JjID0g TlVMTDsKKwl1bnNpZ25lZCBjaGFyIGZsYWcgPSBnZXRfaWN2X2ZsYWcgKGhvc3RfZW52dmFy c1tvbXBfdmFyXS5mbGFnX3Zhcik7CisJaWYgKGZsYWcgJiBHT01QX0VOVl9WQVJfU1VGRklY X05PTkUpCisJICBzcmMgPSBob3N0X2VudnZhcnNbb21wX3Zhcl0ubm9uZV92YXI7CisJZWxz ZSBpZiAoZmxhZyAmIEdPTVBfRU5WX1ZBUl9TVUZGSVhfQUxMKQorCSAgc3JjID0gaG9zdF9l bnZ2YXJzW29tcF92YXJdLmFsbF92YXI7CisJZWxzZQorCSAgY29udGludWU7CisKKwlpZiAo c3JjICE9IE5VTEwgJiYgaG9zdF9lbnZ2YXJzW29tcF92YXJdLmRlc3QgIT0gTlVMTCkKKwkg IHN3aXRjaCAoaG9zdF9lbnZ2YXJzW29tcF92YXJdLnR5cGVfY29kZSkKKwkgICAgeworCSAg ICBjYXNlIFBBUlNFX0lOVDoKKwkgICAgICAqKGludCAqKSAoaG9zdF9lbnZ2YXJzW29tcF92 YXJdLmRlc3QpID0gKihpbnQgKikgc3JjOworCSAgICAgIGJyZWFrOworCSAgICBjYXNlIFBB UlNFX0JPT0w6CisJICAgICAgKihib29sICopIChob3N0X2VudnZhcnNbb21wX3Zhcl0uZGVz dCkgPSAqKGJvb2wgKikgc3JjOworCSAgICAgIGJyZWFrOworCSAgICBjYXNlIFBBUlNFX1VJ TlQ6CisJICAgICAgKih1bnNpZ25lZCBpbnQgKikgKGhvc3RfZW52dmFyc1tvbXBfdmFyXS5k ZXN0KSA9CisJCSoodW5zaWduZWQgaW50ICopIHNyYzsKKwkgICAgICBicmVhazsKKwkgICAg Y2FzZSBQQVJTRV9VTE9ORzoKKwkgICAgICAqKHVuc2lnbmVkIGxvbmcgKikgKGhvc3RfZW52 dmFyc1tvbXBfdmFyXS5kZXN0KSA9CisJCSoodW5zaWduZWQgbG9uZyAqKSBzcmM7CisJICAg ICAgYnJlYWs7CisJICAgIGNhc2UgUEFSU0VfQ0hBUjoKKwkgICAgICAqKGNoYXIgKikgKGhv c3RfZW52dmFyc1tvbXBfdmFyXS5kZXN0KSA9ICooY2hhciAqKSBzcmM7CisJICAgICAgYnJl YWs7CisJICAgIGNhc2UgUEFSU0VfVUNIQVI6CisJICAgICAgKih1bnNpZ25lZCBjaGFyICop IChob3N0X2VudnZhcnNbb21wX3Zhcl0uZGVzdCkgPQorCQkqKHVuc2lnbmVkIGNoYXIgKikg c3JjOworCSAgICAgIGJyZWFrOworCSAgICBjYXNlIFBBUlNFX1VMT05HUFRSOgorCSAgICAg ICoodW5zaWduZWQgbG9uZyAqKikgKGhvc3RfZW52dmFyc1tvbXBfdmFyXS5kZXN0KSA9CisJ CSoodW5zaWduZWQgbG9uZyAqKikgc3JjOworCSAgICAgIGJyZWFrOworCSAgICBjYXNlIFBB UlNFX0NIQVJQVFI6CisJICAgICAgKihjaGFyICoqKSAoaG9zdF9lbnZ2YXJzW29tcF92YXJd LmRlc3QpID0gKihjaGFyICoqKSBzcmM7CisJICAgICAgYnJlYWs7CisJICAgIH0KKyAgICAg IH0KKworICBpZiAoKGdvbXBfaW5pdGlhbF9pY3ZfZmxhZ3MuYmluZF92YXIgJiBHT01QX0VO Vl9WQVJfU1VGRklYX05PTkUKKyAgICAgICB8fCBnb21wX2luaXRpYWxfaWN2X2ZsYWdzLmJp bmRfdmFyICYgR09NUF9FTlZfVkFSX1NVRkZJWF9BTEwpCiAgICAgICAmJiBnb21wX2dsb2Jh bF9pY3YuYmluZF92YXIgPT0gb21wX3Byb2NfYmluZF9mYWxzZSkKICAgICBpZ25vcmUgPSB0 cnVlOwotICBpZiAocGFyc2VfdW5zaWduZWRfbG9uZyAoIk9NUF9NQVhfQUNUSVZFX0xFVkVM UyIsCi0JCQkgICAmbWF4X2FjdGl2ZV9sZXZlbHNfdmFyLCB0cnVlKSkKLSAgICBnb21wX2ds b2JhbF9pY3YubWF4X2FjdGl2ZV9sZXZlbHNfdmFyCi0gICAgICA9IChtYXhfYWN0aXZlX2xl dmVsc192YXIgPiBnb21wX3N1cHBvcnRlZF9hY3RpdmVfbGV2ZWxzKQotCT8gZ29tcF9zdXBw b3J0ZWRfYWN0aXZlX2xldmVscyA6IG1heF9hY3RpdmVfbGV2ZWxzX3ZhcjsKLSAgZWxzZQor CisgIGlmICghKGdvbXBfaW5pdGlhbF9pY3ZfZmxhZ3MubWF4X2FjdGl2ZV9sZXZlbHNfdmFy ICYgR09NUF9FTlZfVkFSX1NVRkZJWF9OT05FCisgICAgICAgfHwgKGdvbXBfaW5pdGlhbF9p Y3ZfZmxhZ3MubWF4X2FjdGl2ZV9sZXZlbHNfdmFyCisJICAgJiBHT01QX0VOVl9WQVJfU1VG RklYX0FMTCkpKQogICAgIHsKICAgICAgIGJvb2wgbmVzdGVkID0gdHJ1ZTsKKyAgICAgIGNv bnN0IGNoYXIgKmVudiA9IGdldGVudiAoIk9NUF9ORVNURUQiKTsKIAogICAgICAgLyogT01Q X05FU1RFRCBpcyBkZXByZWNhdGVkIGluIE9wZW5NUCA1LjAuICAqLwotICAgICAgaWYgKHBh cnNlX2Jvb2xlYW4gKCJPTVBfTkVTVEVEIiwgJm5lc3RlZCkpCisgICAgICBpZiAocGFyc2Vf Ym9vbGVhbiAoIk9NUF9ORVNURUQiLCBlbnYsICh2b2lkICpbXSkgeyZuZXN0ZWR9KSkKIAln b21wX2dsb2JhbF9pY3YubWF4X2FjdGl2ZV9sZXZlbHNfdmFyCiAJICA9IG5lc3RlZCA/IGdv bXBfc3VwcG9ydGVkX2FjdGl2ZV9sZXZlbHMgOiAxOwogICAgICAgZWxzZSBpZiAoZ29tcF9u dGhyZWFkc192YXJfbGlzdF9sZW4gPiAxIHx8IGdvbXBfYmluZF92YXJfbGlzdF9sZW4gPiAx KQogCWdvbXBfZ2xvYmFsX2ljdi5tYXhfYWN0aXZlX2xldmVsc192YXIgPSBnb21wX3N1cHBv cnRlZF9hY3RpdmVfbGV2ZWxzOwogICAgIH0KKworICAvKiBQcm9jZXNzIEdPTVBfKiB2YXJp YWJsZXMgYW5kIGRlcGVuZGVuY2llcyBiZXR3ZWVuIHBhcnNlZCBJQ1ZzLiAgKi8KKyAgcGFy c2VfaW50X3NlY3VyZSAoIkdPTVBfREVCVUciLCAmZ29tcF9kZWJ1Z192YXIsIHRydWUpOwor CiAgIC8qIE1ha2Ugc3VyZSBPTVBfUExBQ0VTIGFuZCBHT01QX0NQVV9BRkZJTklUWSBlbnYg dmFycyBhcmUgYWx3YXlzCiAgICAgIHBhcnNlZCBpZiBwcmVzZW50IGluIHRoZSBlbnZpcm9u bWVudC4gIElmIE9NUF9QUk9DX0JJTkQgd2FzIHNldAogICAgICBleHBsaWNpdGx5IHRvIGZh bHNlLCBkb24ndCBwb3B1bGF0ZSBwbGFjZXMgbGlzdCB0aG91Z2guICBJZiBwbGFjZXMKQEAg LTE1NDcsNyArMjM5NywxMSBAQCBpbml0aWFsaXplX2VudiAodm9pZCkKICAgICAgIGdvbXBf c2V0X2FmZmluaXR5X2Zvcm1hdCAoZW52LCBzdHJsZW4gKGVudikpOwogICB9CiAKLSAgd2Fp dF9wb2xpY3kgPSBwYXJzZV93YWl0X3BvbGljeSAoKTsKKyAgaWYgKGdvbXBfaW5pdGlhbF9p Y3ZfZmxhZ3Mud2FpdF9wb2xpY3kgJiBHT01QX0VOVl9WQVJfU1VGRklYX05PTkUpCisgICAg d2FpdF9wb2xpY3kgPSBnb21wX2luaXRpYWxfaWN2c19ub25lLndhaXRfcG9saWN5OworICBl bHNlIGlmIChnb21wX2luaXRpYWxfaWN2X2ZsYWdzLndhaXRfcG9saWN5ICYgR09NUF9FTlZf VkFSX1NVRkZJWF9BTEwpCisgICAgd2FpdF9wb2xpY3kgPSBnb21wX2luaXRpYWxfaWN2c19h bGwud2FpdF9wb2xpY3k7CisKICAgaWYgKCFwYXJzZV9zcGluY291bnQgKCJHT01QX1NQSU5D T1VOVCIsICZnb21wX3NwaW5fY291bnRfdmFyKSkKICAgICB7CiAgICAgICAvKiBVc2luZyBh IHJvdWdoIGVzdGltYXRpb24gb2YgMTAwMDAwIHNwaW5zIHBlciBtc2VjLApAQCAtMTU3Myw4 ICsyNDI3LDIxIEBAIGluaXRpYWxpemVfZW52ICh2b2lkKQogICAvKiBOb3Qgc3RyaWN0bHkg ZW52aXJvbm1lbnQgcmVsYXRlZCwgYnV0IG9yZGVyaW5nIGNvbnN0cnVjdG9ycyBpcyB0cmlj a3kuICAqLwogICBwdGhyZWFkX2F0dHJfaW5pdCAoJmdvbXBfdGhyZWFkX2F0dHIpOwogCi0g IGlmIChwYXJzZV9zdGFja3NpemUgKCJPTVBfU1RBQ0tTSVpFIiwgJnN0YWNrc2l6ZSkKLSAg ICAgIHx8IHBhcnNlX3N0YWNrc2l6ZSAoIkdPTVBfU1RBQ0tTSVpFIiwgJnN0YWNrc2l6ZSkK KyAgaWYgKCEoZ29tcF9pbml0aWFsX2ljdl9mbGFncy5zdGFja3NpemUgJiBHT01QX0VOVl9W QVJfU1VGRklYX05PTkUpKQorICAgIHsKKyAgICAgIGNvbnN0IGNoYXIgKmVudiA9IGdldGVu diAoIkdPTVBfU1RBQ0tTSVpFIik7CisgICAgICBpZiAoZW52ICE9IE5VTEwKKwkgICYmIHBh cnNlX3N0YWNrc2l6ZSAoIkdPTVBfU1RBQ0tTSVpFIiwgZW52LAorCQkJICAgICAgKHZvaWQg KlszXSkgeyZnb21wX2luaXRpYWxfaWN2c19ub25lLnN0YWNrc2l6ZX0pKQorCWdvbXBfaW5p dGlhbF9pY3ZfZmxhZ3Muc3RhY2tzaXplID0gR09NUF9FTlZfVkFSX1NVRkZJWF9OT05FOwor ICAgIH0KKyAgaWYgKGdvbXBfaW5pdGlhbF9pY3ZfZmxhZ3Muc3RhY2tzaXplICYgR09NUF9F TlZfVkFSX1NVRkZJWF9OT05FKQorICAgIHN0YWNrc2l6ZSA9IGdvbXBfaW5pdGlhbF9pY3Zz X25vbmUuc3RhY2tzaXplOworICBlbHNlIGlmIChnb21wX2luaXRpYWxfaWN2X2ZsYWdzLnN0 YWNrc2l6ZSAmIEdPTVBfRU5WX1ZBUl9TVUZGSVhfQUxMKQorICAgIHN0YWNrc2l6ZSA9IGdv bXBfaW5pdGlhbF9pY3ZzX2FsbC5zdGFja3NpemU7CisKKyAgaWYgKGdvbXBfaW5pdGlhbF9p Y3ZfZmxhZ3Muc3RhY2tzaXplICYgR09NUF9FTlZfVkFSX1NVRkZJWF9OT05FCisgICAgICB8 fCBnb21wX2luaXRpYWxfaWN2X2ZsYWdzLnN0YWNrc2l6ZSAmIEdPTVBfRU5WX1ZBUl9TVUZG SVhfQUxMCiAgICAgICB8fCBHT01QX0RFRkFVTFRfU1RBQ0tTSVpFKQogICAgIHsKICAgICAg IGludCBlcnI7CkBAIC0xNjAxLDcgKzI0NjgsOCBAQCBpbml0aWFsaXplX2VudiAodm9pZCkK IAogICAvKiBPcGVuQUNDLiAgKi8KIAotICBpZiAoIXBhcnNlX2ludCAoIkFDQ19ERVZJQ0Vf TlVNIiwgJmdvYWNjX2RldmljZV9udW0sIHRydWUpKQorICBpZiAoIXBhcnNlX2ludCAoIkFD Q19ERVZJQ0VfTlVNIiwgZ2V0ZW52ICgiQUNDX0RFVklDRV9OVU0iKSwKKwkJICAodm9pZCAq W10pIHsmZ29hY2NfZGV2aWNlX251bSwgKHZvaWQgKikgdHJ1ZX0pKQogICAgIGdvYWNjX2Rl dmljZV9udW0gPSAwOwogCiAgIHBhcnNlX2FjY19kZXZpY2VfdHlwZSAoKTsKZGlmZiAtLWdp dCBhL2xpYmdvbXAvaWN2LWRldmljZS5jIGIvbGliZ29tcC9pY3YtZGV2aWNlLmMKaW5kZXgg NzkyNjFhYi4uYmMxYWY5NyAxMDA2NDQKLS0tIGEvbGliZ29tcC9pY3YtZGV2aWNlLmMKKysr IGIvbGliZ29tcC9pY3YtZGV2aWNlLmMKQEAgLTgwLDMgKzgwLDExIEBAIG9tcF9nZXRfZGV2 aWNlX251bSAodm9pZCkKIH0KIAogaWFsaWFzIChvbXBfZ2V0X2RldmljZV9udW0pCisKK2lu dAorb21wX2dldF9tYXhfdGVhbXMgKHZvaWQpCit7CisgIHJldHVybiBnb21wX250ZWFtc192 YXI7Cit9CisKK2lhbGlhcyAob21wX2dldF9tYXhfdGVhbXMpCmRpZmYgLS1naXQgYS9saWJn b21wL2ljdi5jIGIvbGliZ29tcC9pY3YuYwppbmRleCBkZTE1Y2M4Li41YzQzNWQ2IDEwMDY0 NAotLS0gYS9saWJnb21wL2ljdi5jCisrKyBiL2xpYmdvbXAvaWN2LmMKQEAgLTE1NSwxMiAr MTU1LDYgQEAgb21wX3NldF9udW1fdGVhbXMgKGludCBudW1fdGVhbXMpCiAgICAgZ29tcF9u dGVhbXNfdmFyID0gbnVtX3RlYW1zOwogfQogCi1pbnQKLW9tcF9nZXRfbWF4X3RlYW1zICh2 b2lkKQotewotICByZXR1cm4gZ29tcF9udGVhbXNfdmFyOwotfQotCiB2b2lkCiBvbXBfc2V0 X3RlYW1zX3RocmVhZF9saW1pdCAoaW50IHRocmVhZF9saW1pdCkKIHsKQEAgLTI3NSw3ICsy NjksNiBAQCBpYWxpYXMgKG9tcF9zZXRfbWF4X2FjdGl2ZV9sZXZlbHMpCiBpYWxpYXMgKG9t cF9nZXRfbWF4X2FjdGl2ZV9sZXZlbHMpCiBpYWxpYXMgKG9tcF9nZXRfc3VwcG9ydGVkX2Fj dGl2ZV9sZXZlbHMpCiBpYWxpYXMgKG9tcF9zZXRfbnVtX3RlYW1zKQotaWFsaWFzIChvbXBf Z2V0X21heF90ZWFtcykKIGlhbGlhcyAob21wX3NldF90ZWFtc190aHJlYWRfbGltaXQpCiBp YWxpYXMgKG9tcF9nZXRfdGVhbXNfdGhyZWFkX2xpbWl0KQogaWFsaWFzIChvbXBfZ2V0X2Nh bmNlbGxhdGlvbikKZGlmZiAtLWdpdCBhL2xpYmdvbXAvbGliZ29tcC1wbHVnaW4uaCBiL2xp YmdvbXAvbGliZ29tcC1wbHVnaW4uaAppbmRleCAwN2FiNzAwLi40ZmUwYjc1IDEwMDY0NAot LS0gYS9saWJnb21wL2xpYmdvbXAtcGx1Z2luLmgKKysrIGIvbGliZ29tcC9saWJnb21wLXBs dWdpbi5oCkBAIC0xMDIsMTEgKzEwMiwxMyBAQCBzdHJ1Y3QgYWRkcl9wYWlyCiAgIHVpbnRw dHJfdCBlbmQ7CiB9OwogCi0vKiBUaGlzIHN5bWJvbCBpcyB0byBuYW1lIGEgdGFyZ2V0IHNp ZGUgdmFyaWFibGUgdGhhdCBob2xkcyB0aGUgZGVzaWduYXRlZAotICAgJ2RldmljZSBudW1i ZXInIG9mIHRoZSB0YXJnZXQgZGV2aWNlLiBUaGUgc3ltYm9sIG5lZWRzIHRvIGJlIGF2YWls YWJsZSB0bworLyogVGhpcyBmb2xsb3dpbmcgc3ltYm9scyBhcmUgdG8gbmFtZSB0YXJnZXQg c2lkZSB2YXJpYWJsZXMgdGhhdCBob2xkIHRoZQorICAgZGVzaWduYXRlZCBJQ1ZzIG9mIHRo ZSB0YXJnZXQgZGV2aWNlLiBUaGUgc3ltYm9scyBuZWVkIHRvIGJlIGF2YWlsYWJsZSB0bwog ICAgbGliZ29tcCBjb2RlIGFuZCB0aGUgb2ZmbG9hZCBwbHVnaW4gKHdoaWNoIGluIHRoZSBs YXR0ZXIgY2FzZSBtdXN0IGJlCiAgICBzdHJpbmdpZmllZCkuICAqLwogI2RlZmluZSBHT01Q X0RFVklDRV9OVU1fVkFSIF9fZ29tcF9kZXZpY2VfbnVtCisjZGVmaW5lIEdPTVBfREVGQVVM VF9ERVZJQ0VfVkFSIF9fZ29tcF9kZWZhdWx0X2RldmljZQorI2RlZmluZSBHT01QX05URUFN U19WQVIgX19nb21wX250ZWFtcwogCiAvKiBNaXNjZWxsYW5lb3VzIGZ1bmN0aW9ucy4gICov CiBleHRlcm4gdm9pZCAqR09NUF9QTFVHSU5fbWFsbG9jIChzaXplX3QpIF9fYXR0cmlidXRl X18gKChtYWxsb2MpKTsKZGlmZiAtLWdpdCBhL2xpYmdvbXAvbGliZ29tcC5oIGIvbGliZ29t cC9saWJnb21wLmgKaW5kZXggYjllMDM5MS4uYmY1NzI1MiAxMDA2NDQKLS0tIGEvbGliZ29t cC9saWJnb21wLmgKKysrIGIvbGliZ29tcC9saWJnb21wLmgKQEAgLTQ1NCw2ICs0NTQsMjQg QEAgc3RydWN0IGdvbXBfdGVhbV9zdGF0ZQogCiBzdHJ1Y3QgdGFyZ2V0X21lbV9kZXNjOwog CisjZGVmaW5lIE9NUF9OT05FIDAKKyNkZWZpbmUgT01QX05VTV9URUFNU19ERVZfIDEKKyNk ZWZpbmUgT01QX1NDSEVEVUxFX0RFVl8gMgorI2RlZmluZSBPTVBfU0NIRURVTEVfQ0hVTktf U0laRV9ERVZfIDMKKyNkZWZpbmUgT01QX0RZTkFNSUNfREVWXyA0CisjZGVmaW5lIE9NUF9U RUFNU19USFJFQURfTElNSVRfREVWXyA1CisjZGVmaW5lIE9NUF9USFJFQURfTElNSVRfREVW XyA2CisjZGVmaW5lIE9NUF9OVU1fVEhSRUFEU19ERVZfIDcKKyNkZWZpbmUgT01QX05USFJF QURTX0xJU1RfREVWIDgKKyNkZWZpbmUgT01QX05USFJFQURTX0xJU1RfTEVOX0RFViA5Cisj ZGVmaW5lIE9NUF9QUk9DX0JJTkRfREVWXyAxMAorI2RlZmluZSBPTVBfUFJPQ19CSU5EX0xJ U1RfREVWXyAxMQorI2RlZmluZSBPTVBfUFJPQ19CSU5EX0xJU1RfTEVOX0RFVl8gMTIKKyNk ZWZpbmUgT01QX01BWF9BQ1RJVkVfTEVWRUxTX0RFVl8gMTMKKyNkZWZpbmUgT01QX1dBSVRf UE9MSUNZX0RFVl8gMTQKKyNkZWZpbmUgT01QX1NUQUNLU0laRV9ERVZfIDE1CisjZGVmaW5l IE9NUF9ERUZBVUxUX0RFVklDRV9ERVZfIDE2CisKIC8qIFRoZXNlIGFyZSB0aGUgT3Blbk1Q IDQuMCBJbnRlcm5hbCBDb250cm9sIFZhcmlhYmxlcyBkZXNjcmliZWQgaW4KICAgIHNlY3Rp b24gMi4zLjEuICBUaG9zZSBkZXNjcmliZWQgYXMgaGF2aW5nIG9uZSBjb3B5IHBlciB0YXNr IGFyZQogICAgc3RvcmVkIHdpdGhpbiB0aGUgc3RydWN0dXJlOyB0aG9zZSBkZXNjcmliZWQg YXMgaGF2aW5nIG9uZSBjb3B5CkBAIC00NzMsNiArNDkxLDY5IEBAIHN0cnVjdCBnb21wX3Rh c2tfaWN2CiAgIHN0cnVjdCB0YXJnZXRfbWVtX2Rlc2MgKnRhcmdldF9kYXRhOwogfTsKIAor I2RlZmluZSBHT01QX0VOVl9WQVJfU1VGRklYX1VOS05PV04gMAorI2RlZmluZSBHT01QX0VO Vl9WQVJfU1VGRklYX05PTkUgMQorI2RlZmluZSBHT01QX0VOVl9WQVJfU1VGRklYX0RFViAy CisjZGVmaW5lIEdPTVBfRU5WX1ZBUl9TVUZGSVhfQUxMIDQKKyNkZWZpbmUgR09NUF9FTlZf VkFSX1NVRkZJWF9ERVZfWCA4CisKKy8qIFN0cnVjdCB0aGF0IGNvbnRhaW5zIGFsbCBJQ1Zz IGZvciB3aGljaCB3ZSBuZWVkIHRvIHN0b3JlIGluaXRpYWwgdmFsdWVzLgorICAgS2VlcGlu ZyB0aGUgaW5pdGlhbCB2YWx1ZXMgaXMgbmVlZGVkIGZvciBvbXBfZGlzcGxheV9lbnYuICBN b3Jlb3ZlciBpbml0aWFsCisgICBfREVWIGFuZCBfQUxMIHZhcmlhbnRzIG9mIGVudmlyb25t ZW50IHZhcmlhYmxlcyBhcmUgYWxzbyB1c2VkIHRvIGRldGVybWluZQorICAgYWN0dWFsbHkg dXNlZCB2YWx1ZXMgZm9yIGRldmljZXMgYW5kIGZvciB0aGUgaG9zdC4gICovCitzdHJ1Y3Qg Z29tcF9pbml0aWFsX2ljdnMKK3sKKyAgdW5zaWduZWQgbG9uZyAqbnRocmVhZHNfdmFyX2xp c3Q7CisgIGNoYXIgKmJpbmRfdmFyX2xpc3Q7CisgIHVuc2lnbmVkIGxvbmcgbnRocmVhZHNf dmFyOworICB1bnNpZ25lZCBsb25nIG50aHJlYWRzX3Zhcl9saXN0X2xlbjsKKyAgdW5zaWdu ZWQgbG9uZyBiaW5kX3Zhcl9saXN0X2xlbjsKKyAgdW5zaWduZWQgbG9uZyBzdGFja3NpemU7 CisgIGludCBydW5fc2NoZWRfY2h1bmtfc2l6ZTsKKyAgaW50IGRlZmF1bHRfZGV2aWNlX3Zh cjsKKyAgaW50IG50ZWFtc192YXI7CisgIGludCB0ZWFtc190aHJlYWRfbGltaXRfdmFyOwor ICBpbnQgd2FpdF9wb2xpY3k7CisgIHVuc2lnbmVkIGludCB0aHJlYWRfbGltaXRfdmFyOwor ICBlbnVtIGdvbXBfc2NoZWR1bGVfdHlwZSBydW5fc2NoZWRfdmFyOworICBib29sIGR5bl92 YXI7CisgIHVuc2lnbmVkIGNoYXIgbWF4X2FjdGl2ZV9sZXZlbHNfdmFyOworICBjaGFyIGJp bmRfdmFyOworfTsKKworc3RydWN0IGdvbXBfaWN2X2ZsYWdzCit7CisgIHVuc2lnbmVkIGlu dCBudGhyZWFkc192YXIgOiA0OworICB1bnNpZ25lZCBpbnQgbnRocmVhZHNfdmFyX2xpc3Qg OiA0OworICB1bnNpZ25lZCBpbnQgbnRocmVhZHNfdmFyX2xpc3RfbGVuIDogNDsKKyAgdW5z aWduZWQgaW50IHJ1bl9zY2hlZF92YXIgOiA0OworICB1bnNpZ25lZCBpbnQgcnVuX3NjaGVk X2NodW5rX3NpemUgOiA0OworICB1bnNpZ25lZCBpbnQgdGhyZWFkX2xpbWl0X3ZhciA6IDQ7 CisgIHVuc2lnbmVkIGludCBkeW5fdmFyIDogNDsKKyAgdW5zaWduZWQgaW50IG1heF9hY3Rp dmVfbGV2ZWxzX3ZhciA6IDQ7CisgIHVuc2lnbmVkIGludCBiaW5kX3ZhciA6IDQ7CisgIHVu c2lnbmVkIGludCBiaW5kX3Zhcl9saXN0IDogNDsKKyAgdW5zaWduZWQgaW50IGJpbmRfdmFy X2xpc3RfbGVuIDogNDsKKyAgdW5zaWduZWQgaW50IG50ZWFtc192YXIgOiA0OworICB1bnNp Z25lZCBpbnQgc3RhY2tzaXplIDogNDsKKyAgdW5zaWduZWQgaW50IHdhaXRfcG9saWN5IDog NDsKKyAgdW5zaWduZWQgaW50IHRlYW1zX3RocmVhZF9saW1pdF92YXIgOiA0OworICB1bnNp Z25lZCBpbnQgZGVmYXVsdF9kZXZpY2VfdmFyIDogNDsKK307CisKK3N0cnVjdCBnb21wX2lj dl9saXN0Cit7CisgIGludCBkZXZpY2VfbnVtOworICBzdHJ1Y3QgZ29tcF9pbml0aWFsX2lj dnMgaWN2czsKKyAgc3RydWN0IGdvbXBfaWN2X2ZsYWdzIGZsYWdzOworICBzdHJ1Y3QgZ29t cF9pY3ZfbGlzdCAqbmV4dDsKK307CitleHRlcm4gc3RydWN0IGdvbXBfaWN2X2xpc3QgKmdv bXBfaW5pdGlhbF9pY3ZfZGV2X2xpc3Q7CisKK2V4dGVybiBzdHJ1Y3QgZ29tcF9pbml0aWFs X2ljdnMgZ29tcF9pbml0aWFsX2ljdnNfYWxsOworZXh0ZXJuIHN0cnVjdCBnb21wX2luaXRp YWxfaWN2cyBnb21wX2luaXRpYWxfaWN2c19kZXY7CitleHRlcm4gc3RydWN0IGdvbXBfaWN2 X2ZsYWdzIGdvbXBfaW5pdGlhbF9pY3ZfZmxhZ3M7CisKIGVudW0gZ29tcF90YXJnZXRfb2Zm bG9hZF90CiB7CiAgIEdPTVBfVEFSR0VUX09GRkxPQURfREVGQVVMVCwKZGlmZiAtLWdpdCBh L2xpYmdvbXAvcGx1Z2luL3BsdWdpbi1nY24uYyBiL2xpYmdvbXAvcGx1Z2luL3BsdWdpbi1n Y24uYwppbmRleCBmMzA1ZDcyLi42ZDg2YjNlIDEwMDY0NAotLS0gYS9saWJnb21wL3BsdWdp bi9wbHVnaW4tZ2NuLmMKKysrIGIvbGliZ29tcC9wbHVnaW4vcGx1Z2luLWdjbi5jCkBAIC01 NjAsNiArNTYwLDE0IEBAIHN0cnVjdCBoZWFwIHsKICAgY2hhciBkYXRhWzBdOwogfTsKIAor LyogU3RyaW5ncyBvZiBJQ1ZzIHdoaWNoIGFyZSBjb3BpZWQgdG8gdGhlIGRldmljZS4gICov CitzdGF0aWMgY2hhciAqR09NUF9JQ1ZfU1RSSU5HU1tdID0KK3sKKyAgWFNUUklORyAoR09N UF9ERVZJQ0VfTlVNX1ZBUiksCisgIFhTVFJJTkcgKEdPTVBfREVGQVVMVF9ERVZJQ0VfVkFS KSwKKyAgWFNUUklORyAoR09NUF9OVEVBTVNfVkFSKQorfTsKKwogLyogfX19ICAqLwogLyog e3t7IEdsb2JhbCB2YXJpYWJsZXMgICovCiAKQEAgLTMzNTYsNyArMzM2NCw3IEBAIEdPTVBf T0ZGTE9BRF9sb2FkX2ltYWdlIChpbnQgb3JkLCB1bnNpZ25lZCB2ZXJzaW9uLCBjb25zdCB2 b2lkICp0YXJnZXRfZGF0YSwKICAgc3RydWN0IGtlcm5lbF9pbmZvICprZXJuZWw7CiAgIGlu dCBrZXJuZWxfY291bnQgPSBpbWFnZV9kZXNjLT5rZXJuZWxfY291bnQ7CiAgIHVuc2lnbmVk IHZhcl9jb3VudCA9IGltYWdlX2Rlc2MtPmdsb2JhbF92YXJpYWJsZV9jb3VudDsKLSAgaW50 IG90aGVyX2NvdW50ID0gMTsKKyAgaW50IG90aGVyX2NvdW50ID0gMzsKIAogICBhZ2VudCA9 IGdldF9hZ2VudF9pbmZvIChvcmQpOwogICBpZiAoIWFnZW50KQpAQCAtMzQ1MywzNiArMzQ2 MSw0MyBAQCBHT01QX09GRkxPQURfbG9hZF9pbWFnZSAoaW50IG9yZCwgdW5zaWduZWQgdmVy c2lvbiwgY29uc3Qgdm9pZCAqdGFyZ2V0X2RhdGEsCiAJfQogICAgIH0KIAotICBHQ05fREVC VUcgKCJMb29raW5nIGZvciB2YXJpYWJsZSAlc1xuIiwgWFNUUklORyAoR09NUF9ERVZJQ0Vf TlVNX1ZBUikpOwotCi0gIGhzYV9zdGF0dXNfdCBzdGF0dXM7Ci0gIGhzYV9leGVjdXRhYmxl X3N5bWJvbF90IHZhcl9zeW1ib2w7Ci0gIHN0YXR1cyA9IGhzYV9mbnMuaHNhX2V4ZWN1dGFi bGVfZ2V0X3N5bWJvbF9mbiAoYWdlbnQtPmV4ZWN1dGFibGUsIE5VTEwsCi0JCQkJCQkgWFNU UklORyAoR09NUF9ERVZJQ0VfTlVNX1ZBUiksCi0JCQkJCQkgYWdlbnQtPmlkLCAwLCAmdmFy X3N5bWJvbCk7Ci0gIGlmIChzdGF0dXMgPT0gSFNBX1NUQVRVU19TVUNDRVNTKQorICBmb3Ig KHVuc2lnbmVkIGkgPSAwOyBpIDwgb3RoZXJfY291bnQ7IGkrKykKICAgICB7Ci0gICAgICB1 aW50NjRfdCBkZXZpY2VfbnVtX3ZhcnB0cjsKLSAgICAgIHVpbnQzMl90IGRldmljZV9udW1f dmFyc2l6ZTsKKyAgICAgIEdDTl9ERUJVRyAoIkxvb2tpbmcgZm9yIHZhcmlhYmxlICVzXG4i LCBHT01QX0lDVl9TVFJJTkdTW2ldKTsKIAotICAgICAgc3RhdHVzID0gaHNhX2Zucy5oc2Ff ZXhlY3V0YWJsZV9zeW1ib2xfZ2V0X2luZm9fZm4KLQkodmFyX3N5bWJvbCwgSFNBX0VYRUNV VEFCTEVfU1lNQk9MX0lORk9fVkFSSUFCTEVfQUREUkVTUywKLQkgJmRldmljZV9udW1fdmFy cHRyKTsKLSAgICAgIGlmIChzdGF0dXMgIT0gSFNBX1NUQVRVU19TVUNDRVNTKQotCWhzYV9m YXRhbCAoIkNvdWxkIG5vdCBleHRyYWN0IGEgdmFyaWFibGUgZnJvbSBpdHMgc3ltYm9sIiwg c3RhdHVzKTsKLSAgICAgIHN0YXR1cyA9IGhzYV9mbnMuaHNhX2V4ZWN1dGFibGVfc3ltYm9s X2dldF9pbmZvX2ZuCi0JKHZhcl9zeW1ib2wsIEhTQV9FWEVDVVRBQkxFX1NZTUJPTF9JTkZP X1ZBUklBQkxFX1NJWkUsCi0JICZkZXZpY2VfbnVtX3ZhcnNpemUpOwotICAgICAgaWYgKHN0 YXR1cyAhPSBIU0FfU1RBVFVTX1NVQ0NFU1MpCi0JaHNhX2ZhdGFsICgiQ291bGQgbm90IGV4 dHJhY3QgYSB2YXJpYWJsZSBzaXplIGZyb20gaXRzIHN5bWJvbCIsIHN0YXR1cyk7CisgICAg ICBoc2Ffc3RhdHVzX3Qgc3RhdHVzOworICAgICAgaHNhX2V4ZWN1dGFibGVfc3ltYm9sX3Qg dmFyX3N5bWJvbDsKKyAgICAgIHN0YXR1cyA9IGhzYV9mbnMuaHNhX2V4ZWN1dGFibGVfZ2V0 X3N5bWJvbF9mbiAoYWdlbnQtPmV4ZWN1dGFibGUsIE5VTEwsCisJCQkJCQkgICAgIEdPTVBf SUNWX1NUUklOR1NbaV0sCisJCQkJCQkgICAgIGFnZW50LT5pZCwgMCwgJnZhcl9zeW1ib2wp OworICAgICAgaWYgKHN0YXR1cyA9PSBIU0FfU1RBVFVTX1NVQ0NFU1MpCisJeworCSAgdWlu dDY0X3QgdmFycHRyOworCSAgdWludDMyX3QgdmFyc2l6ZTsKIAotICAgICAgcGFpci0+c3Rh cnQgPSBkZXZpY2VfbnVtX3ZhcnB0cjsKLSAgICAgIHBhaXItPmVuZCA9IGRldmljZV9udW1f dmFycHRyICsgZGV2aWNlX251bV92YXJzaXplOworCSAgc3RhdHVzID0gaHNhX2Zucy5oc2Ff ZXhlY3V0YWJsZV9zeW1ib2xfZ2V0X2luZm9fZm4KKwkgICAgKHZhcl9zeW1ib2wsIEhTQV9F WEVDVVRBQkxFX1NZTUJPTF9JTkZPX1ZBUklBQkxFX0FERFJFU1MsCisJICAgICAmdmFycHRy KTsKKwkgIGlmIChzdGF0dXMgIT0gSFNBX1NUQVRVU19TVUNDRVNTKQorCSAgICBoc2FfZmF0 YWwgKCJDb3VsZCBub3QgZXh0cmFjdCBhIHZhcmlhYmxlIGZyb20gaXRzIHN5bWJvbCIsIHN0 YXR1cyk7CisJICBzdGF0dXMgPSBoc2FfZm5zLmhzYV9leGVjdXRhYmxlX3N5bWJvbF9nZXRf aW5mb19mbgorCSAgICAodmFyX3N5bWJvbCwgSFNBX0VYRUNVVEFCTEVfU1lNQk9MX0lORk9f VkFSSUFCTEVfU0laRSwKKwkgICAgICZ2YXJzaXplKTsKKwkgIGlmIChzdGF0dXMgIT0gSFNB X1NUQVRVU19TVUNDRVNTKQorCSAgICBoc2FfZmF0YWwgKCJDb3VsZCBub3QgZXh0cmFjdCBh IHZhcmlhYmxlIHNpemUgZnJvbSBpdHMgc3ltYm9sIiwKKwkJICAgICAgIHN0YXR1cyk7CisK KwkgIHBhaXItPnN0YXJ0ID0gdmFycHRyOworCSAgcGFpci0+ZW5kID0gdmFycHRyICsgdmFy c2l6ZTsKKwl9CisgICAgICBlbHNlCisJeworCSAgLyogVGhlIHZhcmlhYmxlIHdhcyBub3Qg aW4gdGhpcyBpbWFnZS4gICovCisJICBHQ05fREVCVUcgKCJWYXJpYWJsZSBub3QgZm91bmQg aW4gaW1hZ2U6ICVzXG4iLCBHT01QX0lDVl9TVFJJTkdTW2ldKTsKKwkgIHBhaXItPnN0YXJ0 ID0gcGFpci0+ZW5kID0gMDsKKwl9CisgICAgICBwYWlyKys7CiAgICAgfQotICBlbHNlCi0g ICAgLyogVGhlICdHT01QX0RFVklDRV9OVU1fVkFSJyB2YXJpYWJsZSB3YXMgbm90IGluIHRo aXMgaW1hZ2UuICAqLwotICAgIHBhaXItPnN0YXJ0ID0gcGFpci0+ZW5kID0gMDsKLSAgcGFp cisrOwogCiAgIC8qIEVuc3VyZSB0aGF0IGNvbnN0cnVjdG9ycyBhcmUgcnVuIGZpcnN0LiAg Ki8KICAgc3RydWN0IEdPTVBfa2VybmVsX2xhdW5jaF9hdHRyaWJ1dGVzIGtsYSA9CmRpZmYg LS1naXQgYS9saWJnb21wL3BsdWdpbi9wbHVnaW4tbnZwdHguYyBiL2xpYmdvbXAvcGx1Z2lu L3BsdWdpbi1udnB0eC5jCmluZGV4IGI0ZjBhODQuLjcxODJmZWYgMTAwNjQ0Ci0tLSBhL2xp YmdvbXAvcGx1Z2luL3BsdWdpbi1udnB0eC5jCisrKyBiL2xpYmdvbXAvcGx1Z2luL3BsdWdp bi1udnB0eC5jCkBAIC0zMzAsNiArMzMwLDE0IEBAIHN0cnVjdCBwdHhfZGV2aWNlCiAKIHN0 YXRpYyBzdHJ1Y3QgcHR4X2RldmljZSAqKnB0eF9kZXZpY2VzOwogCisvKiBTdHJpbmdzIG9m IElDVnMgd2hpY2ggYXJlIGNvcGllZCB0byB0aGUgZGV2aWNlLiAgKi8KK3N0YXRpYyBjaGFy ICpHT01QX0lDVl9TVFJJTkdTW10gPQoreworICBYU1RSSU5HIChHT01QX0RFVklDRV9OVU1f VkFSKSwKKyAgWFNUUklORyAoR09NUF9ERUZBVUxUX0RFVklDRV9WQVIpLAorICBYU1RSSU5H IChHT01QX05URUFNU19WQVIpCit9OworCiBzdGF0aWMgaW5saW5lIHN0cnVjdCBudnB0eF90 aHJlYWQgKgogbnZwdHhfdGhyZWFkICh2b2lkKQogewpAQCAtMTI2Niw3ICsxMjc0LDcgQEAg R09NUF9PRkZMT0FEX2xvYWRfaW1hZ2UgKGludCBvcmQsIHVuc2lnbmVkIHZlcnNpb24sIGNv bnN0IHZvaWQgKnRhcmdldF9kYXRhLAogICBDVW1vZHVsZSBtb2R1bGU7CiAgIGNvbnN0IGNo YXIgKmNvbnN0ICp2YXJfbmFtZXM7CiAgIGNvbnN0IHN0cnVjdCB0YXJnX2ZuX2xhdW5jaCAq Zm5fZGVzY3M7Ci0gIHVuc2lnbmVkIGludCBmbl9lbnRyaWVzLCB2YXJfZW50cmllcywgb3Ro ZXJfZW50cmllcywgaSwgajsKKyAgdW5zaWduZWQgaW50IGZuX2VudHJpZXMsIHZhcl9lbnRy aWVzLCBvdGhlcl9lbnRyaWVzLCBpLCBqLCBrOwogICBzdHJ1Y3QgdGFyZ19mbl9kZXNjcmlw dG9yICp0YXJnX2ZuczsKICAgc3RydWN0IGFkZHJfcGFpciAqdGFyZ190Ymw7CiAgIGNvbnN0 IG52cHR4X3RkYXRhX3QgKmltZ19oZWFkZXIgPSAoY29uc3QgbnZwdHhfdGRhdGFfdCAqKSB0 YXJnZXRfZGF0YTsKQEAgLTEyOTYsOCArMTMwNCw4IEBAIEdPTVBfT0ZGTE9BRF9sb2FkX2lt YWdlIChpbnQgb3JkLCB1bnNpZ25lZCB2ZXJzaW9uLCBjb25zdCB2b2lkICp0YXJnZXRfZGF0 YSwKICAgZm5fZW50cmllcyA9IGltZ19oZWFkZXItPmZuX251bTsKICAgZm5fZGVzY3MgPSBp bWdfaGVhZGVyLT5mbl9kZXNjczsKIAotICAvKiBDdXJyZW50bHksIHRoZSBvbmx5IG90aGVy IGVudHJ5IGtpbmQgaXMgJ2RldmljZSBudW1iZXInLiAgKi8KLSAgb3RoZXJfZW50cmllcyA9 IDE7CisgIC8qIEN1cnJlbnRseSwgb3RoZXIgZW50cnkga2luZHMgYXJlICdkZXZpY2UgbnVt YmVyJyBhbmQgZnVydGhlciBJQ1ZzLiAgKi8KKyAgb3RoZXJfZW50cmllcyA9IDM7CiAKICAg dGFyZ190YmwgPSBHT01QX1BMVUdJTl9tYWxsb2MgKHNpemVvZiAoc3RydWN0IGFkZHJfcGFp cikKIAkJCQkgKiAoZm5fZW50cmllcyArIHZhcl9lbnRyaWVzICsgb3RoZXJfZW50cmllcykp OwpAQCAtMTM0OSwyMCArMTM1NywyMyBAQCBHT01QX09GRkxPQURfbG9hZF9pbWFnZSAoaW50 IG9yZCwgdW5zaWduZWQgdmVyc2lvbiwgY29uc3Qgdm9pZCAqdGFyZ2V0X2RhdGEsCiAgICAg ICB0YXJnX3RibC0+ZW5kID0gdGFyZ190YmwtPnN0YXJ0ICsgYnl0ZXM7CiAgICAgfQogCi0g IENVZGV2aWNlcHRyIGRldmljZV9udW1fdmFycHRyOwotICBzaXplX3QgZGV2aWNlX251bV92 YXJzaXplOwotICBDVXJlc3VsdCByID0gQ1VEQV9DQUxMX05PQ0hFQ0sgKGN1TW9kdWxlR2V0 R2xvYmFsLCAmZGV2aWNlX251bV92YXJwdHIsCi0JCQkJICAmZGV2aWNlX251bV92YXJzaXpl LCBtb2R1bGUsCi0JCQkJICBYU1RSSU5HIChHT01QX0RFVklDRV9OVU1fVkFSKSk7Ci0gIGlm IChyID09IENVREFfU1VDQ0VTUykKKyAgZm9yIChrID0gMDsgayA8IG90aGVyX2VudHJpZXM7 IGsrKywgdGFyZ190YmwrKykKICAgICB7Ci0gICAgICB0YXJnX3RibC0+c3RhcnQgPSAodWlu dHB0cl90KSBkZXZpY2VfbnVtX3ZhcnB0cjsKLSAgICAgIHRhcmdfdGJsLT5lbmQgPSAodWlu dHB0cl90KSAoZGV2aWNlX251bV92YXJwdHIgKyBkZXZpY2VfbnVtX3ZhcnNpemUpOworICAg ICAgQ1VkZXZpY2VwdHIgdmFycHRyOworICAgICAgc2l6ZV90IHZhcnNpemU7CisgICAgICBD VXJlc3VsdCByID0gQ1VEQV9DQUxMX05PQ0hFQ0sgKGN1TW9kdWxlR2V0R2xvYmFsLCAmdmFy cHRyLCAmdmFyc2l6ZSwKKwkJCQkgICAgICBtb2R1bGUsIEdPTVBfSUNWX1NUUklOR1Nba10p OworICAgICAgaWYgKHIgPT0gQ1VEQV9TVUNDRVNTKQorCXsKKwkgIHRhcmdfdGJsLT5zdGFy dCA9ICh1aW50cHRyX3QpIHZhcnB0cjsKKwkgIHRhcmdfdGJsLT5lbmQgPSAodWludHB0cl90 KSAodmFycHRyICsgdmFyc2l6ZSk7CisJfQorICAgICAgZWxzZQorCXsKKwkgIC8qIFRoZSB2 YXJpYWJsZSB3YXMgbm90IGluIHRoaXMgaW1hZ2UuICAqLworCSAgdGFyZ190YmwtPnN0YXJ0 ID0gdGFyZ190YmwtPmVuZCA9IDA7CisJfQogICAgIH0KLSAgZWxzZQotICAgIC8qIFRoZSAn R09NUF9ERVZJQ0VfTlVNX1ZBUicgdmFyaWFibGUgd2FzIG5vdCBpbiB0aGlzIGltYWdlLiAg Ki8KLSAgICB0YXJnX3RibC0+c3RhcnQgPSB0YXJnX3RibC0+ZW5kID0gMDsKLSAgdGFyZ190 YmwrKzsKIAogICBudnB0eF9zZXRfY2xvY2t0aWNrIChtb2R1bGUsIGRldik7CiAKZGlmZiAt LWdpdCBhL2xpYmdvbXAvdGFyZ2V0LmMgYi9saWJnb21wL3RhcmdldC5jCmluZGV4IDkwMTc0 NTguLjdmYWM4NjQgMTAwNjQ0Ci0tLSBhL2xpYmdvbXAvdGFyZ2V0LmMKKysrIGIvbGliZ29t cC90YXJnZXQuYwpAQCAtMjA3Miw2ICsyMDcyLDM0IEBAIGdvbXBfdXBkYXRlIChzdHJ1Y3Qg Z29tcF9kZXZpY2VfZGVzY3IgKmRldmljZXAsIHNpemVfdCBtYXBudW0sIHZvaWQgKipob3N0 YWRkcnMsCiAgIGdvbXBfbXV0ZXhfdW5sb2NrICgmZGV2aWNlcC0+bG9jayk7CiB9CiAKKy8q IEhlbHBlciBmdW5jdGlvbiBmb3IgJ2dvbXBfbG9hZF9pbWFnZV90b19kZXZpY2UnLiBSZXR1 cm5zIHRoZSBwb2ludGVyIGZvciBhbgorICAgSUNWIHZhbHVlIGRlcGVuZGluZyBvbiB0aGUg ZGV2aWNlIG51bSBERVZfTlVNIGFuZCB0aGUgdmFyaWFibGUgaGllcmFyY2h5CisgICAoX0RF Vl80MiwgX0RFViwgX0FMTCkuICAqLworCitzdGF0aWMgdm9pZCAqCitnb21wX2dldF9pY3Yg KGludCBkZXZfbnVtLCBpbnQgaWN2X2NvZGUpCit7CisgIHZvaWQgKnZhbCA9IE5VTEw7Cisg IHN0cnVjdCBnb21wX2ljdl9saXN0ICpsaXN0ID0gZ29tcF9pbml0aWFsX2ljdl9kZXZfbGlz dDsKKyAgd2hpbGUgKGxpc3QgIT0gTlVMTCAmJiBsaXN0LT5kZXZpY2VfbnVtICE9IGRldl9u dW0pCisgICAgbGlzdCA9IGxpc3QtPm5leHQ7CisKKyAgc3dpdGNoIChpY3ZfY29kZSkKKyAg ICB7CisgICAgY2FzZSBPTVBfTlVNX1RFQU1TX0RFVl86CisgICAgICBpZiAobGlzdCAhPSBO VUxMICYmIGxpc3QtPmZsYWdzLm50ZWFtc192YXIgJiBHT01QX0VOVl9WQVJfU1VGRklYX0RF Vl9YKQorCXZhbCA9ICZsaXN0LT5pY3ZzLm50ZWFtc192YXI7CisgICAgICBlbHNlIGlmIChn b21wX2luaXRpYWxfaWN2X2ZsYWdzLm50ZWFtc192YXIgJiBHT01QX0VOVl9WQVJfU1VGRklY X0RFVikKKwl2YWwgPSAmZ29tcF9pbml0aWFsX2ljdnNfZGV2Lm50ZWFtc192YXI7CisgICAg ICBlbHNlIGlmIChnb21wX2luaXRpYWxfaWN2X2ZsYWdzLm50ZWFtc192YXIgJiBHT01QX0VO Vl9WQVJfU1VGRklYX0FMTCkKKwl2YWwgPSAmZ29tcF9pbml0aWFsX2ljdnNfYWxsLm50ZWFt c192YXI7CisgICAgICBicmVhazsKKyAgICBkZWZhdWx0OgorICAgICAgcmV0dXJuIHZhbCA9 IE5VTEw7CisgICAgfQorICByZXR1cm4gdmFsOworfQorCiAvKiBMb2FkIGltYWdlIHBvaW50 ZWQgYnkgVEFSR0VUX0RBVEEgdG8gdGhlIGRldmljZSwgc3BlY2lmaWVkIGJ5IERFVklDRVAu CiAgICBBbmQgaW5zZXJ0IHRvIHNwbGF5IHRyZWUgdGhlIG1hcHBpbmcgYmV0d2VlbiBhZGRy ZXNzZXMgZnJvbSBIT1NUX1RBQkxFIGFuZAogICAgZnJvbSBsb2FkZWQgdGFyZ2V0IGltYWdl LiAgV2UgcmVseSBpbiB0aGUgaG9zdCBhbmQgZGV2aWNlIGNvbXBpbGVyCkBAIC0yMDkyLDgg KzIxMjAsOCBAQCBnb21wX2xvYWRfaW1hZ2VfdG9fZGV2aWNlIChzdHJ1Y3QgZ29tcF9kZXZp Y2VfZGVzY3IgKmRldmljZXAsIHVuc2lnbmVkIHZlcnNpb24sCiAgIGludCBudW1fZnVuY3Mg PSBob3N0X2Z1bmNzX2VuZCAtIGhvc3RfZnVuY190YWJsZTsKICAgaW50IG51bV92YXJzICA9 IChob3N0X3ZhcnNfZW5kIC0gaG9zdF92YXJfdGFibGUpIC8gMjsKIAotICAvKiBPdGhlcnMg Y3VycmVudGx5IGlzIG9ubHkgJ2RldmljZV9udW0nICovCi0gIGludCBudW1fb3RoZXJzID0g MTsKKyAgLyogT3RoZXJzIGNvbnRhaW5zIGZ1cnRoZXIgSUNWcyAoY3VycmVudGx5IGRldmlj ZV9udW0sIGV0Yy4pLiAgKi8KKyAgaW50IG51bV9vdGhlcnMgPSAzOwogCiAgIC8qIExvYWQg aW1hZ2UgdG8gZGV2aWNlIGFuZCBnZXQgdGFyZ2V0IGFkZHJlc3NlcyBmb3IgdGhlIGltYWdl LiAgKi8KICAgc3RydWN0IGFkZHJfcGFpciAqdGFyZ2V0X3RhYmxlID0gTlVMTDsKQEAgLTIx NzcsMzIgKzIyMDUsNDQgQEAgZ29tcF9sb2FkX2ltYWdlX3RvX2RldmljZSAoc3RydWN0IGdv bXBfZGV2aWNlX2Rlc2NyICpkZXZpY2VwLCB1bnNpZ25lZCB2ZXJzaW9uLAogICAgICAgYXJy YXkrKzsKICAgICB9CiAKLSAgLyogTGFzdCBlbnRyeSBpcyBmb3IgdGhlIG9uLWRldmljZSAn ZGV2aWNlX251bScgdmFyaWFibGUuIFRvbGVyYXRlIGNhc2UKLSAgICAgd2hlcmUgcGx1Z2lu IGRvZXMgbm90IHJldHVybiB0aGlzIGVudHJ5LiAgKi8KKyAgLyogTGFzdCBlbnRyaWVzIGFy ZSBmb3IgdGhlIG9uLWRldmljZSAnZGV2aWNlX251bScgdmFyaWFibGUgYW5kIG90aGVyIElD VnMuCisgICAgIFRoZSBwb3NpdGlvbiBvZiB0aGUgdmFyaWFibGVzIGluIFRBUkdFVF9UQUJM RSByZXN1bHRzIGZyb20gR09NUF9JQ1ZfU1RSSU5HUworICAgICBhcnJheS4gVG9sZXJhdGUg Y2FzZSB3aGVyZSBwbHVnaW4gZG9lcyBub3QgcmV0dXJuIHRob3NlIGVudHJpZXMuICAqLwog ICBpZiAobnVtX2Z1bmNzICsgbnVtX3ZhcnMgPCBudW1fdGFyZ2V0X2VudHJpZXMpCiAgICAg ewotICAgICAgc3RydWN0IGFkZHJfcGFpciAqZGV2aWNlX251bV92YXIgPSAmdGFyZ2V0X3Rh YmxlW251bV9mdW5jcyArIG51bV92YXJzXTsKLSAgICAgIC8qIFN0YXJ0IGFkZHJlc3Mgd2ls bCBiZSBub24temVybyBmb3IgbGFzdCBlbnRyeSBpZiBHT01QX0RFVklDRV9OVU1fVkFSCi0J IHdhcyBmb3VuZCBpbiB0aGlzIGltYWdlLiAgKi8KLSAgICAgIGlmIChkZXZpY2VfbnVtX3Zh ci0+c3RhcnQgIT0gMCkKKyAgICAgIC8qIFRoZSBpbmRleCBvZiB0aGUgZGV2aWNlcCB3aXRo aW4gZGV2aWNlc1tdIGlzIHJlZ2FyZGVkIGFzIGl0cworCSAnZGV2aWNlIG51bWJlcicsIHdo aWNoIGlzIGRpZmZlcmVudCBmcm9tIHRoZSBwZXItZGV2aWNlIHR5cGUKKwkgZGV2aWNlcC0+ dGFyZ2V0X2lkLiAgKi8KKyAgICAgIGludCBkZXZfbnVtID0gKGludCkgKGRldmljZXAgLSAm ZGV2aWNlc1swXSk7CisgICAgICBmb3IgKGkgPSAwOyBpIDwgbnVtX290aGVyczsgKytpKQog CXsKLQkgIC8qIFRoZSBpbmRleCBvZiB0aGUgZGV2aWNlcCB3aXRoaW4gZGV2aWNlc1tdIGlz IHJlZ2FyZGVkIGFzIGl0cwotCSAgICAgJ2RldmljZSBudW1iZXInLCB3aGljaCBpcyBkaWZm ZXJlbnQgZnJvbSB0aGUgcGVyLWRldmljZSB0eXBlCi0JICAgICBkZXZpY2VwLT50YXJnZXRf aWQuICAqLwotCSAgaW50IGRldmljZV9udW1fdmFsID0gKGludCkgKGRldmljZXAgLSAmZGV2 aWNlc1swXSk7Ci0JICBpZiAoZGV2aWNlX251bV92YXItPmVuZCAtIGRldmljZV9udW1fdmFy LT5zdGFydCAhPSBzaXplb2YgKGludCkpCisJICBzdHJ1Y3QgYWRkcl9wYWlyICp2YXIgPSAm dGFyZ2V0X3RhYmxlW251bV9mdW5jcyArIG51bV92YXJzICsgaV07CisJICAvKiBTdGFydCBh ZGRyZXNzIHdpbGwgYmUgbm9uLXplcm8gZm9yIHRoZSBjdXJyZW50IGVudHJ5IGlmCisJICAg ICB0aGUgdmFyaWFibGUgd2FzIGZvdW5kIGluIHRoaXMgaW1hZ2UuICAqLworCSAgaWYgKHZh ci0+c3RhcnQgIT0gMCkKIAkgICAgewotCSAgICAgIGdvbXBfbXV0ZXhfdW5sb2NrICgmZGV2 aWNlcC0+bG9jayk7Ci0JICAgICAgaWYgKGlzX3JlZ2lzdGVyX2xvY2spCi0JCWdvbXBfbXV0 ZXhfdW5sb2NrICgmcmVnaXN0ZXJfbG9jayk7Ci0JICAgICAgZ29tcF9mYXRhbCAoIm9mZmxv YWQgcGx1Z2luIG1hbmFnZWQgJ2RldmljZV9udW0nIG5vdCBvZiBleHBlY3RlZCAiCi0JCQkg ICJmb3JtYXQiKTsKLQkgICAgfQotCi0JICAvKiBDb3B5IGRldmljZV9udW0gdmFsdWUgdG8g cGxhY2Ugb24gZGV2aWNlIG1lbW9yeSwgaGVyZWJ5IGFjdHVhbGx5Ci0JICAgICBkZXNpZ25h dGluZyBpdHMgZGV2aWNlIG51bWJlciBpbnRvIGVmZmVjdC4gICovCi0JICBnb21wX2NvcHlf aG9zdDJkZXYgKGRldmljZXAsIE5VTEwsICh2b2lkICopIGRldmljZV9udW1fdmFyLT5zdGFy dCwKLQkJCSAgICAgICZkZXZpY2VfbnVtX3ZhbCwgc2l6ZW9mIChpbnQpLCBmYWxzZSwgTlVM TCk7CisJICAgICAgdm9pZCAqdmFsID0gTlVMTDsKKwkgICAgICBzd2l0Y2ggKGkpCisJCXsK KwkJY2FzZSAwOiAgLy8gR09NUF9ERVZJQ0VfTlVNX1ZBUgorCQkgIHZhbCA9ICZkZXZfbnVt OworCQkgIGJyZWFrOworCQljYXNlIDE6ICAvLyBHT01QX0RFRkFVTFRfREVWSUNFX1ZBUgor CQkgIHZhbCA9ICZnb21wX2dsb2JhbF9pY3YuZGVmYXVsdF9kZXZpY2VfdmFyOworCQkgIGJy ZWFrOworCQljYXNlIDI6IC8vIEdPTVBfTlRFQU1TX1ZBUgorCQkgIHZhbCA9IGdvbXBfZ2V0 X2ljdiAoZGV2X251bSwgT01QX05VTV9URUFNU19ERVZfKTsKKwkJICBicmVhazsKKwkJfQor CSAgICAgIGlmICh2YWwgIT0gTlVMTCkKKwkJeworCQkgIHNpemVfdCB2YXJfc2l6ZSA9IHZh ci0+ZW5kIC0gdmFyLT5zdGFydDsKKwkJICAvKiBDb3B5IGRldmljZV9udW0gdmFsdWUgdG8g cGxhY2Ugb24gZGV2aWNlIG1lbW9yeSwgaGVyZWJ5CisJCSAgICAgYWN0dWFsbHkgZGVzaWdu YXRpbmcgaXRzIGRldmljZSBudW1iZXIgaW50byBlZmZlY3QuICAqLworCQkgIGdvbXBfY29w eV9ob3N0MmRldiAoZGV2aWNlcCwgTlVMTCwgKHZvaWQgKikgdmFyLT5zdGFydCwgdmFsLAor CQkJCSAgICAgIHZhcl9zaXplLCBmYWxzZSwgTlVMTCk7CisJCX0KKwkgIH0KIAl9CiAgICAg fQogCmRpZmYgLS1naXQgYS9saWJnb21wL3Rlc3RzdWl0ZS9saWJnb21wLmMtYysrLWNvbW1v bi9pY3YtNS5jIGIvbGliZ29tcC90ZXN0c3VpdGUvbGliZ29tcC5jLWMrKy1jb21tb24vaWN2 LTUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44YjYyMWU4Ci0tLSAv ZGV2L251bGwKKysrIGIvbGliZ29tcC90ZXN0c3VpdGUvbGliZ29tcC5jLWMrKy1jb21tb24v aWN2LTUuYwpAQCAtMCwwICsxLDUzIEBACisvKiB7IGRnLWRvIHJ1biB9ICovCisKKyNpbmNs dWRlIDxvbXAuaD4KKyNpbmNsdWRlIDxzdGRsaWIuaD4KKyNpbmNsdWRlIDxzdHJpbmcuaD4K KworI2lmZGVmIF9fdW5peF9fCisjaW5jbHVkZSA8dW5pc3RkLmg+CisKK2NoYXIgY29uc3Qg KnZhcm5hbWVzW10gPSB7CisgICJPTVBfTlVNX1RFQU1TX0RFVl8wIiwKKyAgIk9NUF9OVU1f VEVBTVNfREVWXzEiLAorICAiT01QX05VTV9URUFNU19ERVZfMiIsCisgICJPTVBfTlVNX1RF QU1TX0FMTCIsCisgICJPTVBfTlVNX1RFQU1TX0RFViIsCisgICJPTVBfTlVNX1RFQU1TIgor fTsKK2NoYXIgY29uc3QgKnZhbHVlc1tdID0geyI0MiIsICI0MyIsICI0NCIsICI0NSIsICI0 NiIsICI0NyJ9OworY29uc3QgaW50IGNudCA9IDY7CisjZW5kaWYKKworaW50CittYWluIChp bnQgYXJnYywgY2hhciAqY29uc3QgKmFyZ3YpCit7CisjaWZkZWYgX191bml4X18KKyAgaW50 IHVwZGF0ZWQgPSAwOworICBmb3IgKGludCBpID0gMDsgaSA8IGNudDsgaSsrKQorICAgIHsK KyAgICAgIGlmIChnZXRlbnYgKHZhcm5hbWVzW2ldKSA9PSBOVUxMCisJICB8fCBzdHJjbXAg KGdldGVudiAodmFybmFtZXNbaV0pLCB2YWx1ZXNbaV0pICE9IDApCisJeworCSAgc2V0ZW52 ICh2YXJuYW1lc1tpXSwgdmFsdWVzW2ldLCAxKTsKKwkgIHVwZGF0ZWQgPSAxOworCX0KKyAg ICB9CisgIGlmICh1cGRhdGVkKQorICAgIHsKKyAgICAgIGV4ZWN2IChhcmd2WzBdLCBhcmd2 KTsKKyAgICAgIGFib3J0ICgpOworICAgIH0KKyNlbmRpZgorCisgIGlmIChvbXBfZ2V0X21h eF90ZWFtcyAoKSAhPSA0NykKKyAgICBhYm9ydCAoKTsKKworICBpbnQgbnVtX2RldmljZXMg PSBvbXBfZ2V0X251bV9kZXZpY2VzICgpID4gMyA/IDMgOiBvbXBfZ2V0X251bV9kZXZpY2Vz ICgpOworICBmb3IgKGludCBpPTA7IGkgPCBudW1fZGV2aWNlczsgaSsrKQorICAgICNwcmFn bWEgb21wIHRhcmdldCBkZXZpY2UgKGkpCisgICAgICBpZiAob21wX2dldF9tYXhfdGVhbXMg KCkgIT0gNDIgKyBpKQorCWFib3J0ICgpOworCisgIHJldHVybiAwOworfQpkaWZmIC0tZ2l0 IGEvbGliZ29tcC90ZXN0c3VpdGUvbGliZ29tcC5jLWMrKy1jb21tb24vaWN2LTYuYyBiL2xp YmdvbXAvdGVzdHN1aXRlL2xpYmdvbXAuYy1jKystY29tbW9uL2ljdi02LmMKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZTNiZGZmOAotLS0gL2Rldi9udWxsCisrKyBi L2xpYmdvbXAvdGVzdHN1aXRlL2xpYmdvbXAuYy1jKystY29tbW9uL2ljdi02LmMKQEAgLTAs MCArMSw5NyBAQAorLyogeyBkZy1kbyBydW4gfSAqLworCisvKiBUaGlzIHRlc3RzIHRoZSBo aWVyYXJjaGljYWwgdXNhZ2Ugb2YgSUNWcyBvbiB0aGUgZGV2aWNlLCBpLmUuIGlmCisgICBP TVBfTlVNX1RFQU1TX0RFVl88ZGV2aWNlX251bT4gaXMgbm90IGNvbmZpZ3VyZWQsIHRoZW4g dGhlIHZhbHVlIG9mCisgICBPTVBfTlVNX1RFQU1TX0RFViBzaG91bGQgYmUgdXNlZC4gIEFu ZCBpZiAqLworCisjaW5jbHVkZSA8b21wLmg+CisjaW5jbHVkZSA8c3RkbGliLmg+CisjaW5j bHVkZSA8c3RyaW5nLmg+CisjaWZkZWYgX191bml4X18KKyNpbmNsdWRlIDx1bmlzdGQuaD4K KworY2hhciBjb25zdCAqdmFybmFtZXNbXSA9IHsKKyAgIk9NUF9OVU1fVEVBTVNfQUxMIiwK KyAgIk9NUF9OVU1fVEVBTVNfREVWIiwKKyAgIk9NUF9TQ0hFRFVMRV9BTEwiLAorICAiT01Q X0RZTkFNSUNfQUxMIiwKKyAgIk9NUF9URUFNU19USFJFQURfTElNSVRfQUxMIiwKKyAgIk9N UF9USFJFQURfTElNSVRfQUxMIiwKKyAgIk9NUF9OVU1fVEhSRUFEU19BTEwiLAorICAiT01Q X01BWF9BQ1RJVkVfTEVWRUxTX0FMTCIsCisgICJPTVBfUFJPQ19CSU5EX0FMTCIsCisgICJP TVBfV0FJVF9QT0xJQ1lfQUxMIiwKK307CitjaGFyIGNvbnN0ICp2YWx1ZXNbXSA9IHsgIjQy IiwgIjQzIiwgImd1aWRlZCw0IiwgInRydWUiLCAiNDQiLCAiNDUiLCAiNDYsMywyIiwgIjQ3 IiwgInNwcmVhZCIsICJhY3RpdmUiIH07Citjb25zdCBpbnQgY250ID0gc2l6ZW9mICh2YXJu YW1lcykgLyBzaXplb2YgKGNvbnN0IGNoYXIgKik7CisKK2NoYXIgY29uc3QgKmV4Y2x1ZGVz W10gPSB7CisgICJPTVBfTlVNX1RFQU1TX0RFVl8wIiwKKyAgIk9NUF9OVU1fVEVBTVNfREVW XzEiLAorICAiT01QX05VTV9URUFNU19ERVZfMiIsCisgICJPTVBfU0NIRURVTEUiLAorICAi T01QX0RZTkFNSUMiLAorICAiT01QX1RFQU1TX1RIUkVBRF9MSU1JVCIsCisgICJPTVBfVEhS RUFEX0xJTUlUIiwKKyAgIk9NUF9OVU1fVEhSRUFEUyIsCisgICJPTVBfUFJPQ19CSU5EIiwK KyAgIk9NUF9NQVhfQUNUSVZFX0xFVkVMUyIsCisgICJPTVBfV0FJVF9QT0xJQ1kiLAorfTsK K2NvbnN0IGludCBjbnRfZXhsdWRlcyA9IHNpemVvZiAoZXhjbHVkZXMpIC8gc2l6ZW9mIChj b25zdCBjaGFyICopOworI2VuZGlmCisKK2ludAorbWFpbiAoaW50IGFyZ2MsIGNoYXIgKmNv bnN0ICphcmd2KQoreworI2lmZGVmIF9fdW5peF9fCisgIGlmIChzaXplb2YgKHZhbHVlcykg LyBzaXplb2YgKGNvbnN0IGNoYXIgKikgIT0gY250KQorICAgIGFib3J0ICgpOworCisgIGlu dCB1cGRhdGVkID0gMDsKKyAgZm9yIChpbnQgaSA9IDA7IGkgPCBjbnQ7IGkrKykKKyAgICB7 CisgICAgICBpZiAoZ2V0ZW52ICh2YXJuYW1lc1tpXSkgPT0gTlVMTAorCSAgfHwgc3RyY21w IChnZXRlbnYgKHZhcm5hbWVzW2ldKSwgdmFsdWVzW2ldKSAhPSAwKQorCXsKKwkgIHNldGVu diAodmFybmFtZXNbaV0sIHZhbHVlc1tpXSwgMSk7CisJICB1cGRhdGVkID0gMTsKKwl9Cisg ICAgfQorICBmb3IgKGludCBpID0gMDsgaSA8IGNudF9leGx1ZGVzOyBpKyspCisgICAgewor ICAgICAgaWYgKGdldGVudiAoZXhjbHVkZXNbaV0pICE9IE5VTEwpCisJeworCSAgdW5zZXRl bnYgKGV4Y2x1ZGVzW2ldKTsKKwkgIHVwZGF0ZWQgPSAxOworCX0KKyAgICB9CisgIGlmICh1 cGRhdGVkKQorICAgIHsKKyAgICAgIGV4ZWN2IChhcmd2WzBdLCBhcmd2KTsKKyAgICAgIGFi b3J0ICgpOworICAgIH0KKyNlbmRpZgorCisgIGVudW0gb21wX3NjaGVkX3Qga2luZDsKKyAg aW50IGNodW5rX3NpemU7CisgIG9tcF9nZXRfc2NoZWR1bGUoJmtpbmQsICZjaHVua19zaXpl KTsKKworICBpZiAob21wX2dldF9tYXhfdGVhbXMgKCkgIT0gNDIKKyAgICAgIHx8ICFvbXBf Z2V0X2R5bmFtaWMgKCkKKyAgICAgIHx8IGtpbmQgIT0gMyB8fCBjaHVua19zaXplICE9IDQK KyAgICAgIHx8IG9tcF9nZXRfdGVhbXNfdGhyZWFkX2xpbWl0ICgpICE9IDQ0CisgICAgICB8 fCBvbXBfZ2V0X3RocmVhZF9saW1pdCAoKSAhPSA0NQorICAgICAgfHwgb21wX2dldF9tYXhf dGhyZWFkcyAoKSAhPSA0NgorICAgICAgfHwgb21wX2dldF9wcm9jX2JpbmQgKCkgIT0gb21w X3Byb2NfYmluZF9zcHJlYWQKKyAgICAgIHx8IG9tcF9nZXRfbWF4X2FjdGl2ZV9sZXZlbHMg KCkgIT0gNDcpCisgICAgYWJvcnQgKCk7CisKKyAgaW50IG51bV9kZXZpY2VzID0gb21wX2dl dF9udW1fZGV2aWNlcyAoKSA+IDMgPyAzIDogb21wX2dldF9udW1fZGV2aWNlcyAoKTsKKyAg Zm9yIChpbnQgaT0wOyBpIDwgbnVtX2RldmljZXM7IGkrKykKKyAgICAjcHJhZ21hIG9tcCB0 YXJnZXQgZGV2aWNlIChpKQorICAgICAgaWYgKG9tcF9nZXRfbWF4X3RlYW1zICgpICE9IDQz KQorCWFib3J0ICgpOworCisgIHJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvbGliZ29tcC90 ZXN0c3VpdGUvbGliZ29tcC5jLWMrKy1jb21tb24vaWN2LTcuYyBiL2xpYmdvbXAvdGVzdHN1 aXRlL2xpYmdvbXAuYy1jKystY29tbW9uL2ljdi03LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMC4uZGEyNWFhZQotLS0gL2Rldi9udWxsCisrKyBiL2xpYmdvbXAvdGVz dHN1aXRlL2xpYmdvbXAuYy1jKystY29tbW9uL2ljdi03LmMKQEAgLTAsMCArMSw3MCBAQAor LyogeyBkZy1kbyBydW4gfSAqLworCisvKiBUaGlzIHRlc3RzIHRoZSBoaWVyYXJjaGljYWwg dXNhZ2Ugb2YgSUNWcyBvbiB0aGUgaG9zdCBhbmQgb24gZGV2aWNlcywgaS5lLiBpZgorICAg T01QX05VTV9URUFNU19ERVZfPGRldmljZV9udW0+LCBPTVBfTlVNX1RFQU1TX0RFViwgYW5k CisgICBPTVBfTlVNX1RFQU1TIGFyZSBub3QgY29uZmlndXJlZCwgdGhlbiB0aGUgdmFsdWUg b2YKKyAgIE9NUF9OVU1fVEVBTVNfQUxMIHNob3VsZCBiZSB1c2VkIGZvciB0aGUgaG9zdCBh cyB3ZWxsIGFzIGZvciB0aGUKKyAgIGRldmljZXMuICAqLworCisjaW5jbHVkZSA8b21wLmg+ CisjaW5jbHVkZSA8c3RkbGliLmg+CisjaW5jbHVkZSA8c3RyaW5nLmg+CisjaWZkZWYgX191 bml4X18KKyNpbmNsdWRlIDx1bmlzdGQuaD4KKworY2hhciBjb25zdCAqdmFybmFtZXNbXSA9 IHsKKyAgIk9NUF9OVU1fVEVBTVNfQUxMIgorfTsKK2NoYXIgY29uc3QgKnZhbHVlc1tdID0g eyAiNDIiIH07Citjb25zdCBpbnQgY250ID0gMTsKKworY2hhciBjb25zdCAqZXhjbHVkZXNb XSA9IHsKKyAgIk9NUF9OVU1fVEVBTVNfREVWXzAiLAorICAiT01QX05VTV9URUFNU19ERVZf MSIsCisgICJPTVBfTlVNX1RFQU1TX0RFVl8yIiwKKyAgIk9NUF9OVU1fVEVBTVNfREVWIiwK KyAgIk9NUF9OVU1fVEVBTVMiCit9OworY29uc3QgaW50IGNudF9leGx1ZGVzID0gNTsKKyNl bmRpZgorCitpbnQKK21haW4gKGludCBhcmdjLCBjaGFyICpjb25zdCAqYXJndikKK3sKKyNp ZmRlZiBfX3VuaXhfXworICBpbnQgdXBkYXRlZCA9IDA7CisgIGZvciAoaW50IGkgPSAwOyBp IDwgY250OyBpKyspCisgICAgeworICAgICAgaWYgKGdldGVudiAodmFybmFtZXNbaV0pID09 IE5VTEwKKwkgIHx8IHN0cmNtcCAoZ2V0ZW52ICh2YXJuYW1lc1tpXSksIHZhbHVlc1tpXSkg IT0gMCkKKwl7CisJICBzZXRlbnYgKHZhcm5hbWVzW2ldLCB2YWx1ZXNbaV0sIDEpOworCSAg dXBkYXRlZCA9IDE7CisJfQorICAgIH0KKyAgZm9yIChpbnQgaSA9IDA7IGkgPCBjbnRfZXhs dWRlczsgaSsrKQorICAgIHsKKyAgICAgIGlmIChnZXRlbnYgKGV4Y2x1ZGVzW2ldKSAhPSBO VUxMKQorCXsKKwkgIHVuc2V0ZW52IChleGNsdWRlc1tpXSk7CisJICB1cGRhdGVkID0gMTsK Kwl9CisgICAgfQorICBpZiAodXBkYXRlZCkKKyAgICB7CisgICAgICBleGVjdiAoYXJndlsw XSwgYXJndik7CisgICAgICBhYm9ydCAoKTsKKyAgICB9CisjZW5kaWYKKworICBpZiAob21w X2dldF9tYXhfdGVhbXMgKCkgIT0gNDIpCisgICAgYWJvcnQgKCk7CisKKyAgaW50IG51bV9k ZXZpY2VzID0gb21wX2dldF9udW1fZGV2aWNlcyAoKSA+IDMgPyAzIDogb21wX2dldF9udW1f ZGV2aWNlcyAoKTsKKyAgZm9yIChpbnQgaT0wOyBpIDwgbnVtX2RldmljZXM7IGkrKykKKyAg ICAjcHJhZ21hIG9tcCB0YXJnZXQgZGV2aWNlIChpKQorICAgICAgaWYgKG9tcF9nZXRfbWF4 X3RlYW1zICgpICE9IDQyKQorCWFib3J0ICgpOworCisgIHJldHVybiAwOworfQpkaWZmIC0t Z2l0IGEvbGliZ29tcC90ZXN0c3VpdGUvbGliZ29tcC5jLWMrKy1jb21tb24vb21wLWRpc3Bs YXktZW52LTEuYyBiL2xpYmdvbXAvdGVzdHN1aXRlL2xpYmdvbXAuYy1jKystY29tbW9uL29t cC1kaXNwbGF5LWVudi0xLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u MTBmZjE0OQotLS0gL2Rldi9udWxsCisrKyBiL2xpYmdvbXAvdGVzdHN1aXRlL2xpYmdvbXAu Yy1jKystY29tbW9uL29tcC1kaXNwbGF5LWVudi0xLmMKQEAgLTAsMCArMSwyMDQgQEAKKy8q IHsgZGctZG8gcnVuIH0gKi8KKworI2luY2x1ZGUgPG9tcC5oPgorI2luY2x1ZGUgPHN0ZGxp Yi5oPgorI2luY2x1ZGUgPHN0cmluZy5oPgorCisjaWZkZWYgX191bml4X18KKyNpbmNsdWRl IDx1bmlzdGQuaD4KKworY2hhciBjb25zdCAqdmFybmFtZXNbXSA9IHsKKyAgIk9NUF9USFJF QURfTElNSVRfREVWXzI0IiwKKyAgIk9NUF9USFJFQURfTElNSVRfQUxMIiwKKyAgIk9NUF9U SFJFQURfTElNSVRfREVWIiwKKyAgIk9NUF9USFJFQURfTElNSVQiLAorICAiT01QX0RFRkFV TFRfREVWSUNFIiwKKyAgIk9NUF9TQ0hFRFVMRV9ERVZfMjQiLAorICAiT01QX1NDSEVEVUxF X0FMTCIsCisgICJPTVBfU0NIRURVTEVfREVWIiwKKyAgIk9NUF9TQ0hFRFVMRSIsCisgICJP TVBfRFlOQU1JQ19ERVZfMjQiLAorCisgICJPTVBfRFlOQU1JQ19BTEwiLAorICAiT01QX0RZ TkFNSUNfREVWIiwKKyAgIk9NUF9EWU5BTUlDIiwKKyAgIk9NUF9OVU1fVEhSRUFEUyIsCisg ICJPTVBfTlVNX1RIUkVBRFNfQUxMIiwKKyAgIk9NUF9OVU1fVEhSRUFEU19ERVYiLAorICAi T01QX05VTV9USFJFQURTX0RFVl8yNCIsCisgICJPTVBfTUFYX0FDVElWRV9MRVZFTFMiLAor ICAiT01QX01BWF9BQ1RJVkVfTEVWRUxTX0FMTCIsCisgICJPTVBfTUFYX0FDVElWRV9MRVZF TFNfREVWIiwKKworICAiT01QX01BWF9BQ1RJVkVfTEVWRUxTX0RFVl8yNCIsCisgICJPTVBf TlVNX1RFQU1TIiwKKyAgIk9NUF9OVU1fVEVBTVNfQUxMIiwKKyAgIk9NUF9OVU1fVEVBTVNf REVWIiwKKyAgIk9NUF9OVU1fVEVBTVNfREVWXzI0IiwKKyAgIk9NUF9QUk9DX0JJTkQiLAor ICAiT01QX1BST0NfQklORF9BTEwiLAorICAiT01QX1BST0NfQklORF9ERVYiLAorICAiT01Q X1BST0NfQklORF9ERVZfMjQiLAorICAiT01QX1NUQUNLU0laRSIsCisKKyAgIk9NUF9TVEFD S1NJWkVfQUxMIiwKKyAgIk9NUF9TVEFDS1NJWkVfREVWIiwKKyAgIk9NUF9TVEFDS1NJWkVf REVWXzI0IiwKKyAgIk9NUF9XQUlUX1BPTElDWSIsCisgICJPTVBfV0FJVF9QT0xJQ1lfQUxM IiwKKyAgIk9NUF9XQUlUX1BPTElDWV9ERVYiLAorICAiT01QX1dBSVRfUE9MSUNZX0RFVl8y NCIsCisgICJPTVBfVEVBTVNfVEhSRUFEX0xJTUlUIiwKKyAgIk9NUF9URUFNU19USFJFQURf TElNSVRfQUxMIiwKKyAgIk9NUF9URUFNU19USFJFQURfTElNSVRfREVWIiwKKworICAiT01Q X1RFQU1TX1RIUkVBRF9MSU1JVF9ERVZfMjQiLAorICAiT01QX0NBTkNFTExBVElPTiIsCisg ICJPTVBfRElTUExBWV9BRkZJTklUWSIsCisgICJPTVBfVEFSR0VUX09GRkxPQUQiLAorICAi T01QX01BWF9UQVNLX1BSSU9SSVRZIiwKKyAgIk9NUF9BTExPQ0FUT1IiLAorICAiT01QX05F U1RFRCIsCit9OworCitjaGFyIGNvbnN0ICp2YWx1ZXNbXSA9IHsKKyAgIjQyIiwKKyAgIjQz IiwKKyAgIjQ0IiwKKyAgIjQ1IiwKKyAgIjQyIiwKKyAgImd1aWRlZCw0IiwKKyAgImR5bmFt aWMiLAorICAiZ3VpZGVkLDEiLAorICAiZ3VpZGVkLDIiLAorICAidHJ1ZSIsCisKKyAgInRy dWUiLAorICAidHJ1ZSIsCisgICJ0cnVlIiwKKyAgIjQsMywyIiwKKyAgIjQ1LDQ2LDQ3IiwK KyAgIjQyLDQzLDQ0IiwKKyAgIjE0LDEzLDEyIiwKKyAgIjQyIiwKKyAgIjQzIiwKKyAgIjQ0 IiwKKworICAiNDUiLAorICAiNDIiLAorICAiNDMiLAorICAiNDQiLAorICAiNDUiLAorICAi c3ByZWFkIiwKKyAgImNsb3NlIiwKKyAgInNwcmVhZCxzcHJlYWQiLAorICAic3ByZWFkLGNs b3NlIiwKKyAgIjQyIiwKKworICAiNDIgTSIsCisgICI0MyBrIiwKKyAgIjQ0IiwKKyAgImFj dGl2ZSIsCisgICJBQ1RJVkUiLAorICAicGFzc2l2ZSIsCisgICJQQVNTSVZFIiwKKyAgIjQy IiwKKyAgIjQzIiwKKyAgIjQ0IiwKKworICAiNDUiLAorICAidHJ1ZSIsCisgICJ0cnVlIiwK KyAgIm1hbmRhdG9yeSIsCisgICIyMCIsCisgICJvbXBfY29uc3RfbWVtX2FsbG9jIiwKKyAg ImZhbHNlIiwKK307CisKK2NvbnN0IGludCBjbnQgPSBzaXplb2YgKHZhcm5hbWVzKSAvIHNp emVvZiAoY29uc3QgY2hhciAqKTsKKyNlbmRpZgorCitpbnQKK21haW4gKGludCBhcmdjLCBj aGFyICpjb25zdCAqYXJndikKK3sKKyNpZmRlZiBfX3VuaXhfXworICBpZiAoc2l6ZW9mICh2 YWx1ZXMpIC8gc2l6ZW9mIChjb25zdCBjaGFyICopICE9IGNudCkKKyAgICBhYm9ydCAoKTsK KworICBpbnQgdXBkYXRlZCA9IDA7CisgIGZvciAoaW50IGkgPSAwOyBpIDwgY250OyBpKysp CisgICAgeworICAgICAgaWYgKGdldGVudiAodmFybmFtZXNbaV0pID09IE5VTEwKKwkgIHx8 IHN0cmNtcCAoZ2V0ZW52ICh2YXJuYW1lc1tpXSksIHZhbHVlc1tpXSkgIT0gMCkKKwl7CisJ ICBzZXRlbnYgKHZhcm5hbWVzW2ldLCB2YWx1ZXNbaV0sIDEpOworCSAgdXBkYXRlZCA9IDE7 CisJfQorICAgIH0KKyAgaWYgKHVwZGF0ZWQpCisgICAgeworICAgICAgZXhlY3YgKGFyZ3Zb MF0sIGFyZ3YpOworICAgICAgcmV0dXJuIDA7CisgICAgfQorI2VuZGlmCisKKyAgb21wX2Rp c3BsYXlfZW52ICgxKTsKKyAgcmV0dXJuIDA7Cit9CisKKy8qIHsgZGctb3V0cHV0ICIuKlxc XFtob3N0XSBPTVBfRFlOQU1JQyA9ICdUUlVFJy4qIiB9ICovCisvKiB7IGRnLW91dHB1dCAi LipcXFxbYWxsXSBPTVBfRFlOQU1JQyA9ICdUUlVFJy4qIiB9ICovCisvKiB7IGRnLW91dHB1 dCAiLipcXFxbZGV2aWNlXSBPTVBfRFlOQU1JQyA9ICdUUlVFJy4qIiB9ICovCisvKiB7IGRn LW91dHB1dCAiLipcXFxbMjRcXSBPTVBfRFlOQU1JQyA9ICdUUlVFJy4qIiB9ICovCisKKy8q IHsgZGctb3V0cHV0ICIuKlxcXFtob3N0XSBPTVBfTlVNX1RIUkVBRFMgPSAnNCwzLDInLioi IH0gKi8KKy8qIHsgZGctb3V0cHV0ICIuKlxcXFthbGxcXSBPTVBfTlVNX1RIUkVBRFMgPSAn NDUsNDYsNDcnLioiIH0gKi8KKy8qIHsgZGctb3V0cHV0ICIuKlxcXFtkZXZpY2VcXSBPTVBf TlVNX1RIUkVBRFMgPSAnNDIsNDMsNDQnLioiIH0gKi8KKy8qIHsgZGctb3V0cHV0ICIuKlxc XFsyNFxdIE9NUF9OVU1fVEhSRUFEUyA9ICcxNCwxMywxMicuKiIgfSAqLworCisvKiB7IGRn LW91dHB1dCAiLipcXFxbaG9zdF0gT01QX1NDSEVEVUxFID0gJ0dVSURFRCwyJy4qIiB9ICov CisvKiB7IGRnLW91dHB1dCAiLipcXFxbYWxsXF0gT01QX1NDSEVEVUxFID0gJ0RZTkFNSUMn LioiIH0gKi8KKy8qIHsgZGctb3V0cHV0ICIuKlxcXFtkZXZpY2VcXSBPTVBfU0NIRURVTEUg PSAnR1VJREVEJy4qIiB9ICovCisvKiB7IGRnLW91dHB1dCAiLipcXFxbMjRcXSBPTVBfU0NI RURVTEUgPSAnR1VJREVELDQnLioiIH0gKi8KKworLyogeyBkZy1vdXRwdXQgIi4qXFxcW2hv c3RdIE9NUF9QUk9DX0JJTkQgPSAnU1BSRUFEJy4qIiB9ICovCisvKiB7IGRnLW91dHB1dCAi LipcXFxbYWxsXF0gT01QX1BST0NfQklORCA9ICdDTE9TRScuKiIgfSAqLworLyogeyBkZy1v dXRwdXQgIi4qXFxcW2RldmljZVxdIE9NUF9QUk9DX0JJTkQgPSAnU1BSRUFELFNQUkVBRCcu KiIgfSAqLworLyogeyBkZy1vdXRwdXQgIi4qXFxcWzI0XF0gT01QX1BST0NfQklORCA9ICdT UFJFQUQsQ0xPU0UnLioiIH0gKi8KKworLyogeyBkZy1vdXRwdXQgIi4qXFxcW2hvc3RdIE9N UF9TVEFDS1NJWkUgPSAnNDMwMDgnLioiIH0gKi8KKy8qIHsgZGctb3V0cHV0ICIuKlxcXFth bGxcXSBPTVBfU1RBQ0tTSVpFID0gJzQ0MDQwMTkyJy4qIiB9ICovCisvKiB7IGRnLW91dHB1 dCAiLipcXFxbZGV2aWNlXF0gT01QX1NUQUNLU0laRSA9ICc0NDAzMicuKiIgfSAqLworLyog eyBkZy1vdXRwdXQgIi4qXFxcWzI0XF0gT01QX1NUQUNLU0laRSA9ICc0NTA1NicuKiIgfSAq LworCisvKiB7IGRnLW91dHB1dCAiLipcXFxbaG9zdF0gT01QX1dBSVRfUE9MSUNZID0gJ0FD VElWRScuKiIgfSAqLworLyogeyBkZy1vdXRwdXQgIi4qXFxcW2FsbFxdIE9NUF9XQUlUX1BP TElDWSA9ICdBQ1RJVkUnLioiIH0gKi8KKy8qIHsgZGctb3V0cHV0ICIuKlxcXFtkZXZpY2Vc XSBPTVBfV0FJVF9QT0xJQ1kgPSAnUEFTU0lWRScuKiIgfSAqLworLyogeyBkZy1vdXRwdXQg Ii4qXFxcWzI0XF0gT01QX1dBSVRfUE9MSUNZID0gJ1BBU1NJVkUnLioiIH0gKi8KKworLyog eyBkZy1vdXRwdXQgIi4qXFxcW2hvc3RdIE9NUF9USFJFQURfTElNSVQgPSAnNDUnLioiIH0g Ki8KKy8qIHsgZGctb3V0cHV0ICIuKlxcXFthbGxcXSBPTVBfVEhSRUFEX0xJTUlUID0gJzQz Jy4qIiB9ICovCisvKiB7IGRnLW91dHB1dCAiLipcXFxbZGV2aWNlXF0gT01QX1RIUkVBRF9M SU1JVCA9ICc0NCcuKiIgfSAqLworLyogeyBkZy1vdXRwdXQgIi4qXFxcWzI0XF0gT01QX1RI UkVBRF9MSU1JVCA9ICc0MicuKiIgfSAqLworCisvKiB7IGRnLW91dHB1dCAiLipcXFxbaG9z dF0gT01QX01BWF9BQ1RJVkVfTEVWRUxTID0gJzQyJy4qIiB9ICovCisvKiB7IGRnLW91dHB1 dCAiLipcXFxbYWxsXF0gT01QX01BWF9BQ1RJVkVfTEVWRUxTID0gJzQzJy4qIiB9ICovCisv KiB7IGRnLW91dHB1dCAiLipcXFxbZGV2aWNlXF0gT01QX01BWF9BQ1RJVkVfTEVWRUxTID0g JzQ0Jy4qIiB9ICovCisvKiB7IGRnLW91dHB1dCAiLipcXFxbMjRcXSBPTVBfTUFYX0FDVElW RV9MRVZFTFMgPSAnNDUnLioiIH0gKi8KKworLyogeyBkZy1vdXRwdXQgIi4qXFxcW2hvc3Rd IE9NUF9OVU1fVEVBTVMgPSAnNDInLioiIH0gKi8KKy8qIHsgZGctb3V0cHV0ICIuKlxcXFth bGxcXSBPTVBfTlVNX1RFQU1TID0gJzQzJy4qIiB9ICovCisvKiB7IGRnLW91dHB1dCAiLipc XFxbZGV2aWNlXF0gT01QX05VTV9URUFNUyA9ICc0NCcuKiIgfSAqLworLyogeyBkZy1vdXRw dXQgIi4qXFxcWzI0XF0gT01QX05VTV9URUFNUyA9ICc0NScuKiIgfSAqLworCisvKiB7IGRn LW91dHB1dCAiLipcXFxbaG9zdF0gT01QX1RFQU1TX1RIUkVBRF9MSU1JVCA9ICc0MicuKiIg fSAqLworLyogeyBkZy1vdXRwdXQgIi4qXFxcW2FsbFxdIE9NUF9URUFNU19USFJFQURfTElN SVQgPSAnNDMnLioiIH0gKi8KKy8qIHsgZGctb3V0cHV0ICIuKlxcXFtkZXZpY2VcXSBPTVBf VEVBTVNfVEhSRUFEX0xJTUlUID0gJzQ0Jy4qIiB9ICovCisvKiB7IGRnLW91dHB1dCAiLipc XFxbMjRcXSBPTVBfVEVBTVNfVEhSRUFEX0xJTUlUID0gJzQ1Jy4qIiB9ICovCisKKy8qIHsg ZGctb3V0cHV0ICIuKlxcXFtob3N0XSBPTVBfQ0FOQ0VMTEFUSU9OID0gJ1RSVUUnLioiIH0g Ki8KKy8qIHsgZGctb3V0cHV0ICIuKlxcXFtob3N0XSBPTVBfREVGQVVMVF9ERVZJQ0UgPSAn NDInLioiIH0gKi8KKy8qIHsgZGctb3V0cHV0ICIuKlxcXFtob3N0XSBPTVBfTUFYX1RBU0tf UFJJT1JJVFkgPSAnMjAnLioiIH0gKi8KKy8qIHsgZGctb3V0cHV0ICIuKlxcXFtob3N0XSBP TVBfRElTUExBWV9BRkZJTklUWSA9ICdUUlVFJy4qIiB9ICovCisvKiB7IGRnLW91dHB1dCAi LipcXFxbaG9zdF0gT01QX0FMTE9DQVRPUiA9ICdvbXBfY29uc3RfbWVtX2FsbG9jJy4qIiB9 ICovCisvKiB7IGRnLW91dHB1dCAiLipcXFxbaG9zdF0gT01QX1RBUkdFVF9PRkZMT0FEID0g J01BTkRBVE9SWScuKiIgfSAqLwpkaWZmIC0tZ2l0IGEvbGliZ29tcC90ZXN0c3VpdGUvbGli Z29tcC5jLWMrKy1jb21tb24vb21wLWRpc3BsYXktZW52LTIuYyBiL2xpYmdvbXAvdGVzdHN1 aXRlL2xpYmdvbXAuYy1jKystY29tbW9uL29tcC1kaXNwbGF5LWVudi0yLmMKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNGIwMWYwNQotLS0gL2Rldi9udWxsCisrKyBi L2xpYmdvbXAvdGVzdHN1aXRlL2xpYmdvbXAuYy1jKystY29tbW9uL29tcC1kaXNwbGF5LWVu di0yLmMKQEAgLTAsMCArMSwzNiBAQAorLyogeyBkZy1kbyBydW4gfSAqLworCisvKiBUaGlz IHRlc3QgY2hlY2tzIGlmIG9tcF9kaXNwbGF5X2VudiBvdXRwdXRzIHRoZSBpbml0aWFsIElD ViB2YWx1ZXMuICAqLworCisjaW5jbHVkZSA8b21wLmg+CisjaW5jbHVkZSA8c3RkbGliLmg+ CisjaW5jbHVkZSA8c3RyaW5nLmg+CisjaWZkZWYgX191bml4X18KKyNpbmNsdWRlIDx1bmlz dGQuaD4KKyNlbmRpZgorCitpbnQKK21haW4gKGludCBhcmdjLCBjaGFyICpjb25zdCAqYXJn dikKK3sKKyNpZmRlZiBfX3VuaXhfXworICBpbnQgdXBkYXRlZCA9IDA7CisgIGlmIChnZXRl bnYgKCJPTVBfTlVNX1RFQU1TIikgPT0gTlVMTAorICAgICAgfHwgc3RyY21wIChnZXRlbnYg KCJPTVBfTlVNX1RFQU1TIiksICI0MiIpICE9IDApCisgICAgeworICAgICAgc2V0ZW52ICgi T01QX05VTV9URUFNUyIsICI0MiIsIDEpOworICAgICAgdXBkYXRlZCA9IDE7CisgICAgfQor ICBpZiAodXBkYXRlZCkKKyAgICBleGVjdiAoYXJndlswXSwgYXJndik7CisjZW5kaWYKKwor ICBvbXBfZGlzcGxheV9lbnYgKDEpOworICBvbXBfc2V0X251bV90ZWFtcyAoMjQpOworICBp ZiAob21wX2dldF9tYXhfdGVhbXMgKCkgIT0gMjQpCisgICAgYWJvcnQgKCk7CisgIG9tcF9k aXNwbGF5X2VudiAoMSk7CisKKyAgcmV0dXJuIDA7Cit9CisKKy8qIHsgZGctb3V0cHV0ICIu KlxcXFtob3N0XSBPTVBfTlVNX1RFQU1TID0gJzQyJy4qXFxcW2hvc3RdIE9NUF9OVU1fVEVB TVMgPSAnNDInIiB9ICovCg== --------------0HfT3DE3BCPMcOTLxsw4juJx--