Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1rQSCz-001NKL-Uv for pgsql-hackers@arkaria.postgresql.org; Thu, 18 Jan 2024 13:13:27 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.94.2) (envelope-from ) id 1rQSCz-002bEy-1f for pgsql-hackers@arkaria.postgresql.org; Thu, 18 Jan 2024 13:13:25 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1rQSCx-002bEo-Ng for pgsql-hackers@lists.postgresql.org; Thu, 18 Jan 2024 13:13:24 +0000 Received: from mail-oo1-xc2c.google.com ([2607:f8b0:4864:20::c2c]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.94.2) (envelope-from ) id 1rQSCt-0029jF-0T for pgsql-hackers@postgresql.org; Thu, 18 Jan 2024 13:13:22 +0000 Received: by mail-oo1-xc2c.google.com with SMTP id 006d021491bc7-599206f8a61so1510806eaf.0 for ; Thu, 18 Jan 2024 05:13:18 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1705583598; x=1706188398; darn=postgresql.org; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=vwjgC3KiZXHDIbhkT5haikA2pXKqyCcdpaAFM/eqmCg=; b=QvDyDl765jIs9djFnD5V0LwH4psZCL7AsE2iHfK7t4MB2dUEvqoJBwEcGnQ+jIDiUW g7nDdhGme8FkLq3WpyDxYXFCkS/dQ0stg56YIgANW1bXsKiA0vWhCW9H9DuXGFNuMi+l R5KOVHDxMyeE9D9Ic1+lBo6bknXDNmeHHfNZ6C8UrEzJiP4arBgnxt6mPqySEWR4VDd6 qYmdxNteJLOBXHnwkwhbeTTta0Z3d9SDAoi+AHVJNvoUrbCmtrj1YTqEHj/nvbPSr/Ys D0yfF+BOLpgKANjWfvWdlGrsWRRjNoDqOG8YlQ+iyh43Fk/a+bK5iNBYsDtPuySobPhR bEeQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1705583598; x=1706188398; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=vwjgC3KiZXHDIbhkT5haikA2pXKqyCcdpaAFM/eqmCg=; b=RBBihgBvpw0LTEORKn/AOYVEPhBPcZYSirV7pAWiAuMkmLqNiOQ2Ublh17SKksWPuO hffSsSvbmVa2tX7D0RTtwExXecI/kjR0SENtHShnrSqOu2z6TxBxvAzruK4SCgJwEg+t FiAlLYAAgvbtCMl4x7jazVsyJ57LQ6YsNrkyuMb6ToBmmh7YujhjSBESD/IGVb0x7uFW O/ttG5qkFk6FUz9NxgQinLq9uzlqWgwapDxlcyvwcQUe0dka0pMe7ujkYX4Kk0J2mqaa 1k2wIXC3EeTIIbOW3rkeZuUryT89RA1SS77dPSuCeyMFFu/Ct41hI6sdZ8Q2pAXrY1uh V9iA== X-Gm-Message-State: AOJu0YwUFwFYhVP99ISk0lcaT2O1fLiIuEhR7fQNcXs5yZeaI2IHHhpT DgzMrAsiKMVfQ4ZG28JUCJINlK4UBdn/rvNccvoSt/1NVDGbXfXVcrOf/imGlAxadjP3OjfBlC4 ar8yIJCWi/oyula8RZV1f92D66xE= X-Google-Smtp-Source: AGHT+IGVIKIq3MJfHp2uwWWQpMkf2Wxbm88HOGuxjNh1KYfObbgyaNHGTnhXbPqQsLUnNWHQSzGuSuFDNwx1eXJP4lA= X-Received: by 2002:a05:6359:5e03:b0:175:9b4d:5d83 with SMTP id pw3-20020a0563595e0300b001759b4d5d83mr736228rwb.25.1705583597546; Thu, 18 Jan 2024 05:13:17 -0800 (PST) MIME-Version: 1.0 References: <202312071051.cpxujwos4tlj@alvherre.pgsql> <20231208173014.2qycwc6kjqf6zlck@awork3.anarazel.de> In-Reply-To: From: Amit Langote Date: Thu, 18 Jan 2024 22:12:57 +0900 Message-ID: Subject: Re: remaining sql/json patches To: jian he Cc: Andres Freund , Alvaro Herrera , Erik Rijkers , Andrew Dunstan , PostgreSQL-development Content-Type: multipart/mixed; boundary="00000000000078edb1060f38208c" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --00000000000078edb1060f38208c Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Hi, On Fri, Dec 22, 2023 at 10:01=E2=80=AFPM jian he wrote: > Hi Thanks for the reviews. > v33-0007-SQL-JSON-query-functions.patch, commit message: > This introduces the SQL/JSON functions for querying JSON data using > jsonpath expressions. The functions are: > > should it be "These functions are" Rewrote that sentence to say "introduces the following SQL/JSON functions..= ." > + > + Returns true if the SQL/JSON path_expression > + applied to the context_item using the > + values yields any items. > + The ON ERROR clause specifies what is returne= d if > + an error occurs; the default is to return FALSE. > + Note that if the path_expression > + is strict, an error is generated if it > yields no items. > + > > I think the following description is more accurate. > + Note that if the path_expression > + is strict and the ON > ERROR clause is ERROR, > + an error is generated if it yields no items. > + True, fixed. > +/* > + * transformJsonTable - > + * Transform a raw JsonTable into TableFunc. > + * > + * Transform the document-generating expression, the row-generating expr= ession, > + * the column-generating expressions, and the default value expressions. > + */ > +ParseNamespaceItem * > +transformJsonTable(ParseState *pstate, JsonTable *jt) > +{ > + JsonTableParseContext cxt; > + TableFunc *tf =3D makeNode(TableFunc); > + JsonFuncExpr *jfe =3D makeNode(JsonFuncExpr); > + JsonExpr *je; > + JsonTablePlan *plan =3D jt->plan; > + char *rootPathName =3D jt->pathname; > + char *rootPath; > + bool is_lateral; > + > + if (jt->on_empty) > + ereport(ERROR, > + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), > + errmsg("ON EMPTY not allowed in JSON_TABLE"), > + parser_errposition(pstate, > + exprLocation((Node *) jt->on_empty)))); > > This error may be slightly misleading? > you can add ON EMPTY inside the COLUMNS part, like the following: > SELECT * FROM (VALUES ('1'), ('"1"')) vals(js) LEFT OUTER JOIN > JSON_TABLE(vals.js::jsonb, '$' COLUMNS (a int PATH '$' default 1 ON > empty)) jt ON true; That check is to catch an ON EMPTY specified *outside* the COLUMN(...) clause of a JSON_TABLE(...) expression. It was added during a recent gram.y refactoring, but maybe that wasn't a great idea. It seems better to disallow the ON EMPTY clause in the grammar itself. > + > + Each NESTED PATH clause can generate one or more > + columns. Columns produced by NESTED PATHs at the > + same level are considered to be siblings, > + while a column produced by a NESTED PATH is > + considered to be a child of the column produced by a > + NESTED PATH or row expression at a higher level. > + Sibling columns are always joined first. Once they are processed, > + the resulting rows are joined to the parent row. > + > Does changing to the following make sense? > + considered to be a child of the column produce= d by a > + the resulting rows are joined to the parent ro= w. Terms "child" and "parent" are already introduced in previous paragraphs, so no need for the tag. > seems like `format json_representation`, not listed in the > documentation, but json_representation is "Parameters", do we need > add a section to explain it? > even though I think currently we can only do `FORMAT JSON`. The syntax appears to allow an optional ENCODING UTF8 too, so I've gotten rid of json_representation and literally listed out what the syntax says. > SELECT * FROM JSON_TABLE(jsonb '123', '$' COLUMNS (item int PATH '$' > empty on empty)) bar; > ERROR: cannot cast jsonb array to type integer > The error is the same as the output of the following: > SELECT * FROM JSON_TABLE(jsonb '123', '$' COLUMNS (item int PATH '$' > empty array on empty )) bar; > but these two are different things? EMPTY and EMPTY ARRAY both spell out an array: json_behavior_type: ... | EMPTY_P ARRAY { $$ =3D JSON_BEHAVIOR_EMPTY_ARRAY; } /* non-standard, for Oracle compatibility only */ | EMPTY_P { $$ =3D JSON_BEHAVIOR_EMPTY_ARRAY; } > + /* FALLTHROUGH */ > + case JTC_EXISTS: > + case JTC_FORMATTED: > + { > + Node *je; > + CaseTestExpr *param =3D makeNode(CaseTestExpr); > + > + param->collation =3D InvalidOid; > + param->typeId =3D cxt->contextItemTypid; > + param->typeMod =3D -1; > + > + if (rawc->wrapper !=3D JSW_NONE && > + rawc->quotes !=3D JS_QUOTES_UNSPEC) > + ereport(ERROR, > + (errcode(ERRCODE_SYNTAX_ERROR), > + errmsg("cannot use WITH WRAPPER clause for formatted colunmns" > + " without also specifying OMIT/KEEP QUOTES"), > + parser_errposition(pstate, rawc->location))); > > typo, should be "formatted columns". Oops. > I suspect people will be confused with the meaning of "formatted column". > maybe we can replace this part:"cannot use WITH WRAPPER clause for > formatted column" > to > "SQL/JSON WITH WRAPPER behavior must not be specified when FORMAT > clause is used" > > SELECT * FROM JSON_TABLE(jsonb '"world"', '$' COLUMNS (item text > FORMAT JSON PATH '$' with wrapper KEEP QUOTES)); > ERROR: cannot use WITH WRAPPER clause for formatted colunmns without > also specifying OMIT/KEEP QUOTES > LINE 1: ...T * FROM JSON_TABLE(jsonb '"world"', '$' COLUMNS (item text ..= . > ^ > this error is misleading, since now I am using WITH WRAPPER clause for > formatted columns and specified KEEP QUOTES. > > in parse_expr.c, we have errmsg("SQL/JSON QUOTES behavior must not be > specified when WITH WRAPPER is used"). It seems to me that we should just remove the above check in appendJsonTableColumns() and let the check(s) in parse_expr.c take care of the various allowed/disallowed scenarios for "formatted" columns. Also see further below... > +/* > + * Fetch next row from a cross/union joined scan. > + * > + * Returns false at the end of a scan, true otherwise. > + */ > +static bool > +JsonTablePlanNextRow(JsonTablePlanState * state) > +{ > + JsonTableJoinState *join; > + > + if (state->type =3D=3D JSON_TABLE_SCAN_STATE) > + return JsonTableScanNextRow((JsonTableScanState *) state); > + > + join =3D (JsonTableJoinState *) state; > + if (join->advanceRight) > + { > + /* fetch next inner row */ > + if (JsonTablePlanNextRow(join->right)) > + return true; > + > + /* inner rows are exhausted */ > + if (join->cross) > + join->advanceRight =3D false; /* next outer row */ > + else > + return false; /* end of scan */ > + } > + > + while (!join->advanceRight) > + { > + /* fetch next outer row */ > + bool left =3D JsonTablePlanNextRow(join->left); > > + bool left =3D JsonTablePlanNextRow(join->left); > JsonTablePlanNextRow function comment says "Returns false at the end > of a scan, true otherwise.", > so bool variable name as "left" seems not so good? Hmm, maybe, "more" might be more appropriate given the context. > It might help others understand the whole code by adding some comments on > struct JsonTableScanState and struct JsonTableJoinState. > since json_table patch is quite recursive, IMHO. Agree that the various JsonTable parser/executor comments are lacking. Working on adding more commentary and improving the notation -- struct names, etc. > I did some minor refactoring in parse_expr.c, since some code like > transformJsonExprCommon is duplicated. Thanks, I've adopted some of the ideas in your patch. On Mon, Dec 25, 2023 at 2:03=E2=80=AFPM jian he wrote: > +/* > + * JsonTableFetchRow > + * Prepare the next "current" tuple for upcoming GetValue calls. > + * Returns FALSE if the row-filter expression returned no more rows. > + */ > +static bool > +JsonTableFetchRow(TableFuncScanState *state) > +{ > + JsonTableExecContext *cxt =3D > + GetJsonTableExecContext(state, "JsonTableFetchRow"); > + > + if (cxt->empty) > + return false; > + > + return JsonTableScanNextRow(cxt->root); > +} > > The declaration of struct JsonbTableRoutine, SetRowFilter field is > null. So I am confused by the above comment. Yeah, it might be a leftover from copy-pasting the XML code. Reworded the comment to not mention SetRowFilter. > also seems the `if (cxt->empty)` part never called. I don't understand why the context struct has that empty flag too, it might be a leftover field. Removed. > +static inline JsonTableExecContext * > +GetJsonTableExecContext(TableFuncScanState *state, const char *fname) > +{ > + JsonTableExecContext *result; > + > + if (!IsA(state, TableFuncScanState)) > + elog(ERROR, "%s called with invalid TableFuncScanState", fname); > + result =3D (JsonTableExecContext *) state->opaque; > + if (result->magic !=3D JSON_TABLE_EXEC_CONTEXT_MAGIC) > + elog(ERROR, "%s called with invalid TableFuncScanState", fname); > + > + return result; > +} > I think Assert(IsA(state, TableFuncScanState)) would be better. Hmm, better to leave this as-is to be consistent with what the XML code is doing. Though I also wonder why it's not an Assert in the first place. > +/* > + * JsonTablePlanType - > + * flags for JSON_TABLE plan node types representation > + */ > +typedef enum JsonTablePlanType > +{ > + JSTP_DEFAULT, > + JSTP_SIMPLE, > + JSTP_JOINED, > +} JsonTablePlanType; > it would be better to add some comments on it. thanks. > > JsonTablePlanNextRow is quite recursive! Adding more explanation would > be helpful, thanks. Will do. > +/* Recursively reset scan and its child nodes */ > +static void > +JsonTableRescanRecursive(JsonTablePlanState * state) > +{ > + if (state->type =3D=3D JSON_TABLE_JOIN_STATE) > + { > + JsonTableJoinState *join =3D (JsonTableJoinState *) state; > + > + JsonTableRescanRecursive(join->left); > + JsonTableRescanRecursive(join->right); > + join->advanceRight =3D false; > + } > + else > + { > + JsonTableScanState *scan =3D (JsonTableScanState *) state; > + > + Assert(state->type =3D=3D JSON_TABLE_SCAN_STATE); > + JsonTableRescan(scan); > + if (scan->plan.nested) > + JsonTableRescanRecursive(scan->plan.nested); > + } > +} > > From the coverage report, I noticed the first IF branch in > JsonTableRescanRecursive never called. Will look into this. > + foreach(col, columns) > + { > + JsonTableColumn *rawc =3D castNode(JsonTableColumn, lfirst(col)); > + Oid typid; > + int32 typmod; > + Node *colexpr; > + > + if (rawc->name) > + { > + /* make sure column names are unique */ > + ListCell *colname; > + > + foreach(colname, tf->colnames) > + if (!strcmp((const char *) colname, rawc->name)) > + ereport(ERROR, > + (errcode(ERRCODE_SYNTAX_ERROR), > + errmsg("column name \"%s\" is not unique", > + rawc->name), > + parser_errposition(pstate, rawc->location))); > > this `/* make sure column names are unique */` logic part already > validated in isJsonTablePathNameDuplicate, so we don't need it? > actually isJsonTablePathNameDuplicate validates both column name and path= name. I think you are right. All columns/path names are de-duplicated much earlier at the beginning of transformJsonTable(), so there's no need for the above check. That said, I don't know why column and path names share the namespace or whether that has any semantic issues. Maybe there aren't, but will think some more on that. > select jt.* from jsonb_table_test jtt, > json_table (jtt.js,'strict $[*]' as p > columns (n for ordinality, > nested path 'strict $.b[*]' as pb columns ( c int path '$' ), > nested path 'strict $.b[*]' as pb columns ( s int path '$' )) > ) jt; > > ERROR: duplicate JSON_TABLE column name: pb > HINT: JSON_TABLE column names must be distinct from one another. > the error is not very accurate, since pb is a pathname? I think this can be improved by passing the information whether it's a column or path name to the deduplication code. I've reworked that code to get more useful error info. On Wed, Jan 3, 2024 at 7:53=E2=80=AFPM jian he wrote: > some more minor issues: > SELECT * FROM JSON_TABLE(jsonb '{"a":[123,2]}', '$' > COLUMNS (item int[] PATH '$.a' error on error, foo text path '$' > error on error)) bar; > ERROR: JSON path expression in JSON_VALUE should return singleton scalar= item > > the error message seems not so great, imho. > since the JSON_TABLE doc entries didn't mention that > JSON_TABLE actually transformed to json_value, json_query, json_exists. Hmm, yes, the context whether the JSON_VALUE() is user-specified or internally generated is not readily available where the error is reported. I'm inlinced to document this aspect of JSON_TABLE(), instead of complicating the executor interfaces in order to make the error message better. > JSON_VALUE even though cannot specify KEEP | OMIT QUOTES. > It might be a good idea to mention the default is to omit quotes in the = doc. > because JSON_TABLE actually transformed to json_value, json_query, json_e= xists. > JSON_TABLE can specify quotes behavior freely. Done. > (json_query) > + This function must return a JSON string, so if the path expressi= on > + returns multiple SQL/JSON items, you must wrap the result using = the > + WITH WRAPPER clause. If the wrapper is > + UNCONDITIONAL, an array wrapper will always > + be applied, even if the returned value is already a single JSON = object > + or an array, but if it is CONDITIONAL, it > will not be > + applied to a single array or object. UNCONDITIONAL > + is the default. If the result is a scalar string, by default th= e value > + returned will have surrounding quotes making it a valid JSON val= ue, > + which can be made explicit by specifying KEEP > QUOTES. > + Conversely, quotes can be omitted by specifying OMIT > QUOTES. > + The returned data_type has the > same semantics > + as for constructor functions like json_objectagg; > + the default returned type is jsonb. > > + > + Returns the result of applying the > + path_expression to the > + context_item using the > + PASSING values. Th= e > + extracted value must be a single SQL/JSON sca= lar > + item. For results that are objects or arrays, use the > + json_query function instead. > + The returned data_type has the > same semantics > + as for constructor functions like json_objectagg. > + The default returned type is text. > + The ON ERROR and ON EMPTY > + clauses have similar semantics as mentioned in the description o= f > + json_query. > + > > + The returned data_type has the > same semantics > + as for constructor functions like json_objectagg. > > IMHO, the above description is not so good, since the function > json_objectagg is listed in functions-aggregate.html, > using Ctrl + F in the browser cannot find json_objectagg in functions-jso= n.html. > > for json_query, maybe we can rephrase like: > the RETURNING clause, which specifies the data type returned. It must > be a type for which there is a cast from text to that type. > By default, the jsonb type is returned. > > json_value: > the RETURNING clause, which specifies the data type returned. It must > be a type for which there is a cast from text to that type. > By default, the text type is returned. Fixed the description of returned type for both json_query() and json_value(). For the latter, the cast to the returned type must exist from each possible JSON scalar type viz. text, boolean, numeric, and various datetime types. On Wed, Jan 3, 2024 at 7:50=E2=80=AFPM jian he wrote: > Hi. still based on v33. > JSON_TABLE: > I also refactor parse_jsontable.c error reporting, now the error > message will be consistent with json_query. > now you can specify wrapper freely as long as you don't specify > wrapper and quote at the same time. > overall, json_table behavior is more consistent with json_query and json_= value. > I also added some tests. Thanks for the patches. I've taken the tests, some of your suggested code changes, and made some changes of my own. Some of the new tests give a different error message than what your patch had but I think what I have is fine. > +void > +ExecEvalJsonCoercion(ExprState *state, ExprEvalStep *op, > + ExprContext *econtext) > +{ > + JsonCoercion *coercion =3D op->d.jsonexpr_coercion.coercion; > + ErrorSaveContext *escontext =3D op->d.jsonexpr_coercion.escontext; > + Datum res =3D *op->resvalue; > + bool resnull =3D *op->resnull; > + > + if (coercion->via_populate) > + { > + void *cache =3D op->d.jsonexpr_coercion.json_populate_type_cache; > + > + *op->resvalue =3D json_populate_type(res, JSONBOID, > + coercion->targettype, > + coercion->targettypmod, > + &cache, > + econtext->ecxt_per_query_memory, > + op->resnull, (Node *) escontext); > + } > + else if (coercion->via_io) > + { > + FmgrInfo *input_finfo =3D op->d.jsonexpr_coercion.input_finfo; > + Oid typioparam =3D op->d.jsonexpr_coercion.typioparam; > + char *val_string =3D resnull ? NULL : > + JsonbUnquote(DatumGetJsonbP(res)); > + > + (void) InputFunctionCallSafe(input_finfo, val_string, typioparam, > + coercion->targettypmod, > + (Node *) escontext, > + op->resvalue); > + } > via_populate, via_io should be mutually exclusive. > your patch, in some cases, both (coercion->via_io) and > (coercion->via_populate) are true. > (we can use elog find out). > I refactor coerceJsonFuncExprOutput, so now it will be mutually exclusive= . > I also add asserts to it. I realized that we don't really need the via_io and via_populate flags. You can see in the latest patch that the decision of whether to call json_populate_type() or the RETURNING type's input function is now deferred to run-time or ExecEvalJsonCoercion(). The new comment should also make it clear why one or the other is used for a given source datum passed to ExecEvalJsonCoercion(). > By default, json_query keeps quotes, json_value omit quotes. > However, json_table will be transformed to json_value or json_query > based on certain criteria, > that means we need to explicitly set the JsonExpr->omit_quotes in the > function transformJsonFuncExpr > for case JSON_QUERY_OP and JSON_VALUE_OP. > > We need to know the QUOTE behavior in the function ExecEvalJsonCoercion. > Because for ExecEvalJsonCoercion, the coercion datum source can be a > scalar string item, > scalar items means RETURNING clause is dependent on QUOTE behavior. > keep quotes, omit quotes the results are different. > consider > JSON_QUERY(jsonb'{"rec": "[1,2]"}', '$.rec' returning int4range omit quot= es); > and > JSON_QUERY(jsonb'{"rec": "[1,2]"}', '$.rec' returning int4range omit quot= es); > > to make sure ExecEvalJsonCoercion can distinguish keep and omit quotes, > I added a bool keep_quotes to struct JsonCoercion. > (maybe there is a more simple way, so far, that's what I come up with). > the keep_quotes value will be settled in the function transformJsonFuncEx= pr. > After refactoring, in ExecEvalJsonCoercion, keep_quotes is true then > call JsonbToCString, else call JsonbUnquote. > > example: > SELECT JSON_QUERY(jsonb'{"rec": "{1,2,3}"}', '$.rec' returning int[] > omit quotes); > without my changes, return NULL > with my changes: > {1,2,3} > > JSON_VALUE: > main changes: > --- a/src/test/regress/expected/jsonb_sqljson.out > +++ b/src/test/regress/expected/jsonb_sqljson.out > @@ -301,7 +301,11 @@ SELECT JSON_VALUE(jsonb '"2017-02-20"', '$' > RETURNING date) + 9; > -- Test NULL checks execution in domain types > CREATE DOMAIN sqljsonb_int_not_null AS int NOT NULL; > SELECT JSON_VALUE(jsonb 'null', '$' RETURNING sqljsonb_int_not_null); > -ERROR: domain sqljsonb_int_not_null does not allow null values > + json_value > +------------ > + > +(1 row) > + > I think the change is correct, given `SELECT JSON_VALUE(jsonb 'null', > '$' RETURNING int4range);` returns NULL. > > I also attached a test.sql, without_patch.out (apply v33 only), > with_patch.out (my changes based on v33). > So you can see the difference after applying the patch, in case, my > wording is not clear. To address these points: * I've taken your idea to make omit/keep_quotes available to ExecEvalJsonCoercion(). * I've also taken your suggestion to fix parse_jsontable.c such that WRAPPER/QUOTES combinations specified with JSON_TABLE() columns work without many arbitrary-looking restrictions. Please take a look at the attached latest patch and let me know if anything looks amiss. On Sat, Jan 6, 2024 at 9:45=E2=80=AFAM jian he wrote: > some tests after applying V33 and my small changes. > setup: > create table test_scalar1(js jsonb); > insert into test_scalar1 select jsonb '{"a":"[12,13]"}' FROM > generate_series(1,1e5) g; > create table test_scalar2(js jsonb); > insert into test_scalar2 select jsonb '{"a":12}' FROM generate_series(1,1= e5) g; > create table test_array1(js jsonb); > insert into test_array1 select jsonb '{"a":[1,2,3,4,5]}' FROM > generate_series(1,1e5) g; > create table test_array2(js jsonb); > insert into test_array2 select jsonb '{"a": "{1,2,3,4,5}"}' FROM > generate_series(1,1e5) g; > > tests: > ----------------------------------------return a scalar int4range > explain(costs off,analyze) SELECT item FROM test_scalar1, > JSON_TABLE(js, '$.a' COLUMNS (item int4range PATH '$' omit quotes)) > \watch count=3D5 > 237.753 ms > > explain(costs off,analyze) select json_query(js, '$.a' returning > int4range omit quotes) from test_scalar1 \watch count=3D5 > 462.379 ms > > explain(costs off,analyze) select json_value(js,'$.a' returning > int4range) from test_scalar1 \watch count=3D5 > 362.148 ms > > explain(costs off,analyze) select (js->>'a')::int4range from > test_scalar1 \watch count=3D5 > 301.089 ms > > explain(costs off,analyze) select trim(both '"' from > jsonb_path_query_first(js,'$.a')::text)::int4range from test_scalar1 > \watch count=3D5 > 643.337 ms > --------------------------------- > overall, json_value is faster than json_query. but json_value can not > deal with arrays in some cases. I think that may be explained by the fact that JsonPathQuery() has this step, which JsonPathValue() does not: if (singleton) return JsonbPGetDatum(JsonbValueToJsonb(singleton)); I can see JsonbValueToJsonb() in perf profile when running the benchmark you shared. I don't know if there's any way to make that better. > but as you can see, in some cases, json_value and json_query are not > as fast as our current implementation Yeah, there *is* some expected overhead to using the new functions; ExecEvalJsonExprPath() appears in the top 5 frames of perf profile, for example. The times I see are similar to yours and I don't find the difference to be very drastic. postgres=3D# \o /dev/null postgres=3D# explain(costs off,analyze) select (js->>'a') from test_scalar1 \watch count=3D3 Time: 21.581 ms Time: 18.838 ms Time: 21.589 ms postgres=3D# explain(costs off,analyze) select json_query(js,'$.a') from test_scalar1 \watch count=3D3 Time: 38.562 ms Time: 34.251 ms Time: 32.681 ms postgres=3D# explain(costs off,analyze) select json_value(js,'$.a') from test_scalar1 \watch count=3D3 Time: 28.595 ms Time: 23.947 ms Time: 25.334 ms postgres=3D# explain(costs off,analyze) select item from test_scalar1, json_table(js, '$.a' columns (item int4range path '$')); \watch count=3D3 Time: 52.739 ms Time: 53.996 ms Time: 50.774 ms Attached v34 of all of the patches. 0008 may be considered to be WIP given the points I mentioned above -- need to add a bit more commentary about JSON_TABLE plan implementation and other miscellaneous fixes. As said in my previous email, I'd like to commit 0001-0007 next week. -- Thanks, Amit Langote EDB: http://www.enterprisedb.com --00000000000078edb1060f38208c Content-Type: application/octet-stream; name="v34-0005-Add-a-jsonpath-support-function-jspIsMutable.patch" Content-Disposition: attachment; filename="v34-0005-Add-a-jsonpath-support-function-jspIsMutable.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lrj7oap44 RnJvbSBhOWFmNDM5YjUwMDFkNWRkZGJlNzJkZDAxYzk0NjBhYjk3YjY2NDE3IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbWl0IExhbmdvdGUgPGFtaXRsYW5AcG9zdGdyZXNxbC5vcmc+ CkRhdGU6IFRodSwgMTggSmFuIDIwMjQgMTc6NTc6NDYgKzA5MDAKU3ViamVjdDogW1BBVENIIHYz NCA1LzhdIEFkZCBhIGpzb25wYXRoIHN1cHBvcnQgZnVuY3Rpb24ganNwSXNNdXRhYmxlCgpUaGlz IHdpbGwgYmUgdXNlZCBpbiB0aGUgcGxhbm5lciBjaGFuZ2VzIG9mIHRoZSBzdWJzZXF1ZW50IGNv bW1pdCB0bwphZGQgU1FML0pTT04gcXVlcnkgZnVuY3Rpb25zLgoKRGlzY3Vzc2lvbjogaHR0cHM6 Ly9wb3N0Z3IuZXMvbS9DQStIaXdxRTRYVGRmYjFuVz1Pam95X3RRU1JoWXQtcV9rYjZpNWQ0eGNL eXJMQzFOYmdAbWFpbC5nbWFpbC5jb20KLS0tCiBzcmMvYmFja2VuZC91dGlscy9hZHQvZm9ybWF0 dGluZy5jIHwgIDQ0ICsrKysrCiBzcmMvYmFja2VuZC91dGlscy9hZHQvanNvbnBhdGguYyAgIHwg MjU5ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBzcmMvaW5jbHVkZS91dGlscy9mb3Jt YXR0aW5nLmggICAgIHwgICAxICsKIHNyYy9pbmNsdWRlL3V0aWxzL2pzb25wYXRoLmggICAgICAg fCAgIDEgKwogNCBmaWxlcyBjaGFuZ2VkLCAzMDUgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBh L3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9mb3JtYXR0aW5nLmMgYi9zcmMvYmFja2VuZC91dGlscy9h ZHQvZm9ybWF0dGluZy5jCmluZGV4IDgzZTFmMTI2NWMuLjQxYmIwZTA1NDYgMTAwNjQ0Ci0tLSBh L3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9mb3JtYXR0aW5nLmMKKysrIGIvc3JjL2JhY2tlbmQvdXRp bHMvYWR0L2Zvcm1hdHRpbmcuYwpAQCAtNDQyNiw2ICs0NDI2LDUwIEBAIHBhcnNlX2RhdGV0aW1l KHRleHQgKmRhdGVfdHh0LCB0ZXh0ICpmbXQsIE9pZCBjb2xsaWQsIGJvb2wgc3RyaWN0LAogCX0K IH0KIAorLyoKKyAqIFBhcnNlcyB0aGUgZGF0ZXRpbWUgZm9ybWF0IHN0cmluZyBpbiAnZm10X3N0 cicgYW5kIHJldHVybnMgdHJ1ZSBpZiBpdAorICogY29udGFpbnMgYSB0aW1lem9uZSBzcGVjaWZp ZXIsIGZhbHNlIGlmIG5vdC4KKyAqLworYm9vbAorZGF0ZXRpbWVfZm9ybWF0X2hhc190eihjb25z dCBjaGFyICpmbXRfc3RyKQoreworCWJvb2wJCWluY2FjaGU7CisJaW50CQkJZm10X2xlbiA9IHN0 cmxlbihmbXRfc3RyKTsKKwlpbnQJCQlyZXN1bHQ7CisJRm9ybWF0Tm9kZSAqZm9ybWF0OworCisJ aWYgKGZtdF9sZW4gPiBEQ0hfQ0FDSEVfU0laRSkKKwl7CisJCS8qCisJCSAqIEFsbG9jYXRlIG5l dyBtZW1vcnkgaWYgZm9ybWF0IHBpY3R1cmUgaXMgYmlnZ2VyIHRoYW4gc3RhdGljIGNhY2hlCisJ CSAqIGFuZCBkbyBub3QgdXNlIGNhY2hlIChjYWxsIHBhcnNlciBhbHdheXMpCisJCSAqLworCQlp bmNhY2hlID0gZmFsc2U7CisKKwkJZm9ybWF0ID0gKEZvcm1hdE5vZGUgKikgcGFsbG9jKChmbXRf bGVuICsgMSkgKiBzaXplb2YoRm9ybWF0Tm9kZSkpOworCisJCXBhcnNlX2Zvcm1hdChmb3JtYXQs IGZtdF9zdHIsIERDSF9rZXl3b3JkcywKKwkJCQkJIERDSF9zdWZmLCBEQ0hfaW5kZXgsIERDSF9G TEFHLCBOVUxMKTsKKwl9CisJZWxzZQorCXsKKwkJLyoKKwkJICogVXNlIGNhY2hlIGJ1ZmZlcnMK KwkJICovCisJCURDSENhY2hlRW50cnkgKmVudCA9IERDSF9jYWNoZV9mZXRjaChmbXRfc3RyLCBm YWxzZSk7CisKKwkJaW5jYWNoZSA9IHRydWU7CisJCWZvcm1hdCA9IGVudC0+Zm9ybWF0OworCX0K KworCXJlc3VsdCA9IERDSF9kYXRldGltZV90eXBlKGZvcm1hdCk7CisKKwlpZiAoIWluY2FjaGUp CisJCXBmcmVlKGZvcm1hdCk7CisKKwlyZXR1cm4gcmVzdWx0ICYgRENIX1pPTkVEOworfQorCiAv KgogICogZG9fdG9fdGltZXN0YW1wOiBzaGFyZWQgY29kZSBmb3IgdG9fdGltZXN0YW1wIGFuZCB0 b19kYXRlCiAgKgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L2pzb25wYXRoLmMg Yi9zcmMvYmFja2VuZC91dGlscy9hZHQvanNvbnBhdGguYwppbmRleCBkMDJjMDNlMDE0Li43Y2Vh NmFkNDVjIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC91dGlscy9hZHQvanNvbnBhdGguYworKysg Yi9zcmMvYmFja2VuZC91dGlscy9hZHQvanNvbnBhdGguYwpAQCAtNjgsNyArNjgsOSBAQAogI2lu Y2x1ZGUgImxpYnBxL3BxZm9ybWF0LmgiCiAjaW5jbHVkZSAibm9kZXMvbWlzY25vZGVzLmgiCiAj aW5jbHVkZSAibWlzY2FkbWluLmgiCisjaW5jbHVkZSAibm9kZXMvbm9kZUZ1bmNzLmgiCiAjaW5j bHVkZSAidXRpbHMvYnVpbHRpbnMuaCIKKyNpbmNsdWRlICJ1dGlscy9mb3JtYXR0aW5nLmgiCiAj aW5jbHVkZSAidXRpbHMvanNvbi5oIgogI2luY2x1ZGUgInV0aWxzL2pzb25wYXRoLmgiCiAKQEAg LTExMTAsMyArMTExMiwyNjAgQEAganNwR2V0QXJyYXlTdWJzY3JpcHQoSnNvblBhdGhJdGVtICp2 LCBKc29uUGF0aEl0ZW0gKmZyb20sIEpzb25QYXRoSXRlbSAqdG8sCiAKIAlyZXR1cm4gdHJ1ZTsK IH0KKworLyogU1FML0pTT04gZGF0YXR5cGUgc3RhdHVzOiAqLworZW51bSBKc29uUGF0aERhdGF0 eXBlU3RhdHVzCit7CisJanBkc05vbkRhdGVUaW1lLAkJCS8qIG51bGwsIGJvb2wsIG51bWVyaWMs IHN0cmluZywgYXJyYXksIG9iamVjdCAqLworCWpwZHNVbmtub3duRGF0ZVRpbWUsCQkvKiB1bmtu b3duIGRhdGV0aW1lIHR5cGUgKi8KKwlqcGRzRGF0ZVRpbWVab25lZCwJCQkvKiB0aW1ldHosIHRp bWVzdGFtcHR6ICovCisJanBkc0RhdGVUaW1lTm9uWm9uZWQsCQkvKiB0aW1lLCB0aW1lc3RhbXAs IGRhdGUgKi8KK307CisKKy8qIENvbnRleHQgZm9yIGpzcElzTXV0YWJsZVdhbGtlcigpICovCitz dHJ1Y3QgSnNvblBhdGhNdXRhYmxlQ29udGV4dAoreworCUxpc3QJICAgKnZhcm5hbWVzOwkJLyog bGlzdCBvZiB2YXJpYWJsZSBuYW1lcyAqLworCUxpc3QJICAgKnZhcmV4cHJzOwkJLyogbGlzdCBv ZiB2YXJpYWJsZSBleHByZXNzaW9ucyAqLworCWVudW0gSnNvblBhdGhEYXRhdHlwZVN0YXR1cyBj dXJyZW50OyAvKiBzdGF0dXMgb2YgQCBpdGVtICovCisJYm9vbAkJbGF4OwkJCS8qIGpzb25wYXRo IGlzIGxheCBvciBzdHJpY3QgKi8KKwlib29sCQltdXRhYmxlOwkJLyogcmVzdWx0aW5nIG11dGFi aWxpdHkgc3RhdHVzICovCit9OworCitzdGF0aWMgZW51bSBKc29uUGF0aERhdGF0eXBlU3RhdHVz IGpzcElzTXV0YWJsZVdhbGtlcihKc29uUGF0aEl0ZW0gKmpwaSwKKwkJCQkJCQkJCQkJCQkgIHN0 cnVjdCBKc29uUGF0aE11dGFibGVDb250ZXh0ICpjeHQpOworCisvKgorICogRnVuY3Rpb24gdG8g Y2hlY2sgd2hldGhlciBqc29ucGF0aCBleHByZXNzaW9uIGlzIG11dGFibGUgdG8gYmUgdXNlZCBp biB0aGUKKyAqIHBsYW5uZXIgZnVuY3Rpb24gY29udGFpbl9tdXRhYmxlX2Z1bmN0aW9ucygpLgor ICovCitib29sCitqc3BJc011dGFibGUoSnNvblBhdGggKnBhdGgsIExpc3QgKnZhcm5hbWVzLCBM aXN0ICp2YXJleHBycykKK3sKKwlzdHJ1Y3QgSnNvblBhdGhNdXRhYmxlQ29udGV4dCBjeHQ7CisJ SnNvblBhdGhJdGVtIGpwaTsKKworCWN4dC52YXJuYW1lcyA9IHZhcm5hbWVzOworCWN4dC52YXJl eHBycyA9IHZhcmV4cHJzOworCWN4dC5jdXJyZW50ID0ganBkc05vbkRhdGVUaW1lOworCWN4dC5s YXggPSAocGF0aC0+aGVhZGVyICYgSlNPTlBBVEhfTEFYKSAhPSAwOworCWN4dC5tdXRhYmxlID0g ZmFsc2U7CisKKwlqc3BJbml0KCZqcGksIHBhdGgpOworCSh2b2lkKSBqc3BJc011dGFibGVXYWxr ZXIoJmpwaSwgJmN4dCk7CisKKwlyZXR1cm4gY3h0Lm11dGFibGU7Cit9CisKKy8qCisgKiBSZWN1 cnNpdmUgd2Fsa2VyIGZvciBqc3BJc011dGFibGUoKQorICovCitzdGF0aWMgZW51bSBKc29uUGF0 aERhdGF0eXBlU3RhdHVzCitqc3BJc011dGFibGVXYWxrZXIoSnNvblBhdGhJdGVtICpqcGksIHN0 cnVjdCBKc29uUGF0aE11dGFibGVDb250ZXh0ICpjeHQpCit7CisJSnNvblBhdGhJdGVtIG5leHQ7 CisJZW51bSBKc29uUGF0aERhdGF0eXBlU3RhdHVzIHN0YXR1cyA9IGpwZHNOb25EYXRlVGltZTsK KworCXdoaWxlICghY3h0LT5tdXRhYmxlKQorCXsKKwkJSnNvblBhdGhJdGVtIGFyZzsKKwkJZW51 bSBKc29uUGF0aERhdGF0eXBlU3RhdHVzIGxlZnRTdGF0dXM7CisJCWVudW0gSnNvblBhdGhEYXRh dHlwZVN0YXR1cyByaWdodFN0YXR1czsKKworCQlzd2l0Y2ggKGpwaS0+dHlwZSkKKwkJeworCQkJ Y2FzZSBqcGlSb290OgorCQkJCUFzc2VydChzdGF0dXMgPT0ganBkc05vbkRhdGVUaW1lKTsKKwkJ CQlicmVhazsKKworCQkJY2FzZSBqcGlDdXJyZW50OgorCQkJCUFzc2VydChzdGF0dXMgPT0ganBk c05vbkRhdGVUaW1lKTsKKwkJCQlzdGF0dXMgPSBjeHQtPmN1cnJlbnQ7CisJCQkJYnJlYWs7CisK KwkJCWNhc2UganBpRmlsdGVyOgorCQkJCXsKKwkJCQkJZW51bSBKc29uUGF0aERhdGF0eXBlU3Rh dHVzIHByZXZTdGF0dXMgPSBjeHQtPmN1cnJlbnQ7CisKKwkJCQkJY3h0LT5jdXJyZW50ID0gc3Rh dHVzOworCQkJCQlqc3BHZXRBcmcoanBpLCAmYXJnKTsKKwkJCQkJanNwSXNNdXRhYmxlV2Fsa2Vy KCZhcmcsIGN4dCk7CisKKwkJCQkJY3h0LT5jdXJyZW50ID0gcHJldlN0YXR1czsKKwkJCQkJYnJl YWs7CisJCQkJfQorCisJCQljYXNlIGpwaVZhcmlhYmxlOgorCQkJCXsKKwkJCQkJaW50MzIJCWxl bjsKKwkJCQkJY29uc3QgY2hhciAqbmFtZSA9IGpzcEdldFN0cmluZyhqcGksICZsZW4pOworCQkJ CQlMaXN0Q2VsbCAgICpsYzE7CisJCQkJCUxpc3RDZWxsICAgKmxjMjsKKworCQkJCQlBc3NlcnQo c3RhdHVzID09IGpwZHNOb25EYXRlVGltZSk7CisKKwkJCQkJZm9yYm90aChsYzEsIGN4dC0+dmFy bmFtZXMsIGxjMiwgY3h0LT52YXJleHBycykKKwkJCQkJeworCQkJCQkJU3RyaW5nCSAgICp2YXJu YW1lID0gbGZpcnN0X25vZGUoU3RyaW5nLCBsYzEpOworCQkJCQkJTm9kZQkgICAqdmFyZXhwciA9 IGxmaXJzdChsYzIpOworCisJCQkJCQlpZiAoc3RybmNtcCh2YXJuYW1lLT5zdmFsLCBuYW1lLCBs ZW4pKQorCQkJCQkJCWNvbnRpbnVlOworCisJCQkJCQlzd2l0Y2ggKGV4cHJUeXBlKHZhcmV4cHIp KQorCQkJCQkJeworCQkJCQkJCWNhc2UgREFURU9JRDoKKwkJCQkJCQljYXNlIFRJTUVPSUQ6CisJ CQkJCQkJY2FzZSBUSU1FU1RBTVBPSUQ6CisJCQkJCQkJCXN0YXR1cyA9IGpwZHNEYXRlVGltZU5v blpvbmVkOworCQkJCQkJCQlicmVhazsKKworCQkJCQkJCWNhc2UgVElNRVRaT0lEOgorCQkJCQkJ CWNhc2UgVElNRVNUQU1QVFpPSUQ6CisJCQkJCQkJCXN0YXR1cyA9IGpwZHNEYXRlVGltZVpvbmVk OworCQkJCQkJCQlicmVhazsKKworCQkJCQkJCWRlZmF1bHQ6CisJCQkJCQkJCXN0YXR1cyA9IGpw ZHNOb25EYXRlVGltZTsKKwkJCQkJCQkJYnJlYWs7CisJCQkJCQl9CisKKwkJCQkJCWJyZWFrOwor CQkJCQl9CisJCQkJCWJyZWFrOworCQkJCX0KKworCQkJY2FzZSBqcGlFcXVhbDoKKwkJCWNhc2Ug anBpTm90RXF1YWw6CisJCQljYXNlIGpwaUxlc3M6CisJCQljYXNlIGpwaUdyZWF0ZXI6CisJCQlj YXNlIGpwaUxlc3NPckVxdWFsOgorCQkJY2FzZSBqcGlHcmVhdGVyT3JFcXVhbDoKKwkJCQlBc3Nl cnQoc3RhdHVzID09IGpwZHNOb25EYXRlVGltZSk7CisJCQkJanNwR2V0TGVmdEFyZyhqcGksICZh cmcpOworCQkJCWxlZnRTdGF0dXMgPSBqc3BJc011dGFibGVXYWxrZXIoJmFyZywgY3h0KTsKKwor CQkJCWpzcEdldFJpZ2h0QXJnKGpwaSwgJmFyZyk7CisJCQkJcmlnaHRTdGF0dXMgPSBqc3BJc011 dGFibGVXYWxrZXIoJmFyZywgY3h0KTsKKworCQkJCS8qCisJCQkJICogQ29tcGFyaXNvbiBvZiBk YXRldGltZSB0eXBlIHdpdGggZGlmZmVyZW50IHRpbWV6b25lIHN0YXR1cworCQkJCSAqIGlzIG11 dGFibGUuCisJCQkJICovCisJCQkJaWYgKGxlZnRTdGF0dXMgIT0ganBkc05vbkRhdGVUaW1lICYm CisJCQkJCXJpZ2h0U3RhdHVzICE9IGpwZHNOb25EYXRlVGltZSAmJgorCQkJCQkobGVmdFN0YXR1 cyA9PSBqcGRzVW5rbm93bkRhdGVUaW1lIHx8CisJCQkJCSByaWdodFN0YXR1cyA9PSBqcGRzVW5r bm93bkRhdGVUaW1lIHx8CisJCQkJCSBsZWZ0U3RhdHVzICE9IHJpZ2h0U3RhdHVzKSkKKwkJCQkJ Y3h0LT5tdXRhYmxlID0gdHJ1ZTsKKwkJCQlicmVhazsKKworCQkJY2FzZSBqcGlOb3Q6CisJCQlj YXNlIGpwaUlzVW5rbm93bjoKKwkJCWNhc2UganBpRXhpc3RzOgorCQkJY2FzZSBqcGlQbHVzOgor CQkJY2FzZSBqcGlNaW51czoKKwkJCQlBc3NlcnQoc3RhdHVzID09IGpwZHNOb25EYXRlVGltZSk7 CisJCQkJanNwR2V0QXJnKGpwaSwgJmFyZyk7CisJCQkJanNwSXNNdXRhYmxlV2Fsa2VyKCZhcmcs IGN4dCk7CisJCQkJYnJlYWs7CisKKwkJCWNhc2UganBpQW5kOgorCQkJY2FzZSBqcGlPcjoKKwkJ CWNhc2UganBpQWRkOgorCQkJY2FzZSBqcGlTdWI6CisJCQljYXNlIGpwaU11bDoKKwkJCWNhc2Ug anBpRGl2OgorCQkJY2FzZSBqcGlNb2Q6CisJCQljYXNlIGpwaVN0YXJ0c1dpdGg6CisJCQkJQXNz ZXJ0KHN0YXR1cyA9PSBqcGRzTm9uRGF0ZVRpbWUpOworCQkJCWpzcEdldExlZnRBcmcoanBpLCAm YXJnKTsKKwkJCQlqc3BJc011dGFibGVXYWxrZXIoJmFyZywgY3h0KTsKKwkJCQlqc3BHZXRSaWdo dEFyZyhqcGksICZhcmcpOworCQkJCWpzcElzTXV0YWJsZVdhbGtlcigmYXJnLCBjeHQpOworCQkJ CWJyZWFrOworCisJCQljYXNlIGpwaUluZGV4QXJyYXk6CisJCQkJZm9yIChpbnQgaSA9IDA7IGkg PCBqcGktPmNvbnRlbnQuYXJyYXkubmVsZW1zOyBpKyspCisJCQkJeworCQkJCQlKc29uUGF0aEl0 ZW0gZnJvbTsKKwkJCQkJSnNvblBhdGhJdGVtIHRvOworCisJCQkJCWlmIChqc3BHZXRBcnJheVN1 YnNjcmlwdChqcGksICZmcm9tLCAmdG8sIGkpKQorCQkJCQkJanNwSXNNdXRhYmxlV2Fsa2VyKCZ0 bywgY3h0KTsKKworCQkJCQlqc3BJc011dGFibGVXYWxrZXIoJmZyb20sIGN4dCk7CisJCQkJfQor CQkJCS8qIEZBTExUSFJPVUdIICovCisKKwkJCWNhc2UganBpQW55QXJyYXk6CisJCQkJaWYgKCFj eHQtPmxheCkKKwkJCQkJc3RhdHVzID0ganBkc05vbkRhdGVUaW1lOworCQkJCWJyZWFrOworCisJ CQljYXNlIGpwaUFueToKKwkJCQlpZiAoanBpLT5jb250ZW50LmFueWJvdW5kcy5maXJzdCA+IDAp CisJCQkJCXN0YXR1cyA9IGpwZHNOb25EYXRlVGltZTsKKwkJCQlicmVhazsKKworCQkJY2FzZSBq cGlEYXRldGltZToKKwkJCQlpZiAoanBpLT5jb250ZW50LmFyZykKKwkJCQl7CisJCQkJCWNoYXIJ ICAgKnRlbXBsYXRlOworCisJCQkJCWpzcEdldEFyZyhqcGksICZhcmcpOworCQkJCQlpZiAoYXJn LnR5cGUgIT0ganBpU3RyaW5nKQorCQkJCQl7CisJCQkJCQlzdGF0dXMgPSBqcGRzTm9uRGF0ZVRp bWU7CisJCQkJCQlicmVhazsJLyogdGhlcmUgd2lsbCBiZSBydW50aW1lIGVycm9yICovCisJCQkJ CX0KKworCQkJCQl0ZW1wbGF0ZSA9IGpzcEdldFN0cmluZygmYXJnLCBOVUxMKTsKKwkJCQkJaWYg KGRhdGV0aW1lX2Zvcm1hdF9oYXNfdHoodGVtcGxhdGUpKQorCQkJCQkJc3RhdHVzID0ganBkc0Rh dGVUaW1lWm9uZWQ7CisJCQkJCWVsc2UKKwkJCQkJCXN0YXR1cyA9IGpwZHNEYXRlVGltZU5vblpv bmVkOworCQkJCX0KKwkJCQllbHNlCisJCQkJeworCQkJCQlzdGF0dXMgPSBqcGRzVW5rbm93bkRh dGVUaW1lOworCQkJCX0KKwkJCQlicmVhazsKKworCQkJY2FzZSBqcGlMaWtlUmVnZXg6CisJCQkJ QXNzZXJ0KHN0YXR1cyA9PSBqcGRzTm9uRGF0ZVRpbWUpOworCQkJCWpzcEluaXRCeUJ1ZmZlcigm YXJnLCBqcGktPmJhc2UsIGpwaS0+Y29udGVudC5saWtlX3JlZ2V4LmV4cHIpOworCQkJCWpzcElz TXV0YWJsZVdhbGtlcigmYXJnLCBjeHQpOworCQkJCWJyZWFrOworCisJCQkJLyogbGl0ZXJhbHMg Ki8KKwkJCWNhc2UganBpTnVsbDoKKwkJCWNhc2UganBpU3RyaW5nOgorCQkJY2FzZSBqcGlOdW1l cmljOgorCQkJY2FzZSBqcGlCb29sOgorCQkJCS8qIGFjY2Vzc29ycyAqLworCQkJY2FzZSBqcGlL ZXk6CisJCQljYXNlIGpwaUFueUtleToKKwkJCQkvKiBzcGVjaWFsIGl0ZW1zICovCisJCQljYXNl IGpwaVN1YnNjcmlwdDoKKwkJCWNhc2UganBpTGFzdDoKKwkJCQkvKiBpdGVtIG1ldGhvZHMgKi8K KwkJCWNhc2UganBpVHlwZToKKwkJCWNhc2UganBpU2l6ZToKKwkJCWNhc2UganBpQWJzOgorCQkJ Y2FzZSBqcGlGbG9vcjoKKwkJCWNhc2UganBpQ2VpbGluZzoKKwkJCWNhc2UganBpRG91YmxlOgor CQkJY2FzZSBqcGlLZXlWYWx1ZToKKwkJCQlzdGF0dXMgPSBqcGRzTm9uRGF0ZVRpbWU7CisJCQkJ YnJlYWs7CisJCX0KKworCQlpZiAoIWpzcEdldE5leHQoanBpLCAmbmV4dCkpCisJCQlicmVhazsK KworCQlqcGkgPSAmbmV4dDsKKwl9CisKKwlyZXR1cm4gc3RhdHVzOworfQpkaWZmIC0tZ2l0IGEv c3JjL2luY2x1ZGUvdXRpbHMvZm9ybWF0dGluZy5oIGIvc3JjL2luY2x1ZGUvdXRpbHMvZm9ybWF0 dGluZy5oCmluZGV4IDdlYTFhNzBmNzEuLmNkZTAzMDQxNGUgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNs dWRlL3V0aWxzL2Zvcm1hdHRpbmcuaAorKysgYi9zcmMvaW5jbHVkZS91dGlscy9mb3JtYXR0aW5n LmgKQEAgLTI5LDUgKzI5LDYgQEAgZXh0ZXJuIGNoYXIgKmFzY19pbml0Y2FwKGNvbnN0IGNoYXIg KmJ1ZmYsIHNpemVfdCBuYnl0ZXMpOwogZXh0ZXJuIERhdHVtIHBhcnNlX2RhdGV0aW1lKHRleHQg KmRhdGVfdHh0LCB0ZXh0ICpmbXQsIE9pZCBjb2xsaWQsIGJvb2wgc3RyaWN0LAogCQkJCQkJCU9p ZCAqdHlwaWQsIGludDMyICp0eXBtb2QsIGludCAqdHosCiAJCQkJCQkJc3RydWN0IE5vZGUgKmVz Y29udGV4dCk7CitleHRlcm4gYm9vbCBkYXRldGltZV9mb3JtYXRfaGFzX3R6KGNvbnN0IGNoYXIg KmZtdF9zdHIpOwogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL3V0aWxzL2pzb25w YXRoLmggYi9zcmMvaW5jbHVkZS91dGlscy9qc29ucGF0aC5oCmluZGV4IDZlYWJkY2ZiNzUuLjg5 N2RlMjFhNTEgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL3V0aWxzL2pzb25wYXRoLmgKKysrIGIv c3JjL2luY2x1ZGUvdXRpbHMvanNvbnBhdGguaApAQCAtMTkyLDYgKzE5Miw3IEBAIGV4dGVybiBi b29sIGpzcEdldEJvb2woSnNvblBhdGhJdGVtICp2KTsKIGV4dGVybiBjaGFyICpqc3BHZXRTdHJp bmcoSnNvblBhdGhJdGVtICp2LCBpbnQzMiAqbGVuKTsKIGV4dGVybiBib29sIGpzcEdldEFycmF5 U3Vic2NyaXB0KEpzb25QYXRoSXRlbSAqdiwgSnNvblBhdGhJdGVtICpmcm9tLAogCQkJCQkJCQkg SnNvblBhdGhJdGVtICp0bywgaW50IGkpOworZXh0ZXJuIGJvb2wganNwSXNNdXRhYmxlKEpzb25Q YXRoICpwYXRoLCBMaXN0ICp2YXJuYW1lcywgTGlzdCAqdmFyZXhwcnMpOwogCiBleHRlcm4gY29u c3QgY2hhciAqanNwT3BlcmF0aW9uTmFtZShKc29uUGF0aEl0ZW1UeXBlIHR5cGUpOwogCi0tIAoy LjM1LjMKCg== --00000000000078edb1060f38208c Content-Type: application/octet-stream; name="v34-0001-Add-soft-error-handling-to-some-expression-nodes.patch" Content-Disposition: attachment; filename="v34-0001-Add-soft-error-handling-to-some-expression-nodes.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lrj7oaoa0 RnJvbSA2YWMwZGEzYTlmMjE2ZDM3N2ZlMjJhM2NhNjU5YTc1NjMxNDFiZWY3IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbWl0IExhbmdvdGUgPGFtaXRsYW5AcG9zdGdyZXNxbC5vcmc+ CkRhdGU6IFRodSwgMTggSmFuIDIwMjQgMTY6MTY6MjEgKzA5MDAKU3ViamVjdDogW1BBVENIIHYz NCAxLzhdIEFkZCBzb2Z0IGVycm9yIGhhbmRsaW5nIHRvIHNvbWUgZXhwcmVzc2lvbiBub2RlcwpN SU1FLVZlcnNpb246IDEuMApDb250ZW50LVR5cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9VVRGLTgK Q29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogOGJpdAoKVGhpcyBhZGp1c3RzIHRoZSBDb2VyY2VW aWFJTyBhbmQgQ29lcmNlVG9Eb21haW4gZXhwcmVzc2lvbiBldmFsdWF0aW9uCmNvZGUgdG8gaGFu ZGxlIGVycm9ycyBzb2Z0bHkuCgpGb3IgQ29lcmNlVmlhSW8sIHRoaXMgYWRkcyBhIG5ldyBFeHBy RXZhbFN0ZXAgb3Bjb2RlCkVFT1BfSU9DT0VSQ0VfU0FGRSwgd2hpY2ggaXMgaW1wbGVtZW50ZWQg aW4gdGhlIG5ldyBhY2NvbXBhbnlpbmcKZnVuY3Rpb24gRXhlY0V2YWxDb2VyY2VWaWFJT1NhZmUo KS4gIFRoZSBvbmx5IGRpZmZlcmVuY2UgZnJvbQpFRU9QX0lPQ09FUkNFJ3MgaW5saW5lIGltcGxl bWVudGF0aW9uIGlzIHRoYXQgdGhlIGlucHV0IGZ1bmN0aW9uCnJlY2VpdmVzIGFuIEVycm9yU2F2 ZUNvbnRleHQgdmlhIHRoZSBmdW5jdGlvbidzCkZ1bmN0aW9uQ2FsbEluZm8uY29udGV4dCwgd2hp Y2ggaXQgY2FuIHVzZSB0byBoYW5kbGUgZXJyb3JzIHNvZnRseS4KCkZvciBDb2VyY2VUb0RvbWFp biwgdGhpcyBzaW1wbHkgZW50YWlscyByZXBsYWNpbmcgdGhlIGVyZXBvcnQoKSBpbgpFeGVjRXZh bENvbnN0cmFpbnROb3ROdWxsKCkgYW5kIEV4ZWNFdmFsQ29uc3RyYWludENoZWNrKCkgYnkKZXJy c2F2ZSgpIHBhc3NpbmcgaXQgdGhlIEVycm9yU2F2ZUNvbnRleHQgcGFzc2VkIGluIHRoZSBleHBy ZXNzaW9uJ3MKRXhwckV2YWxTdGVwLgoKSW4gYm90aCBjYXNlcywgdGhlIEVycm9yU2F2ZUNvbnRl eHQgdG8gYmUgdXNlZCBpcyBwYXNzZWQgYnkgc2V0dGluZwpFeHByU3RhdGUuZXNjb250ZXh0IHRv IHBvaW50IHRvIGl0IGJlZm9yZSBjYWxsaW5nIEV4ZWNJbml0RXhwclJlYygpCm9uIHRoZSBleHBy ZXNzaW9uIHRyZWUgd2hvc2UgZXJyb3JzIGFyZSB0byBiZSBzdXBwcmVzc2VkLgoKTm90ZSB0aGF0 IG5vIGNhbGwgc2l0ZSBvZiBFeGVjSW5pdEV4cHJSZWMoKSBoYXMgYmVlbiBjaGFuZ2VkIGluIHRo aXMKY29tbWl0LCBzbyB0aGVyZSdzIG5vIGZ1bmN0aW9uYWwgY2hhbmdlLiAgVGhpcyBpcyBpbnRl bmRlZCBmb3IKaW1wbGVtZW50aW5nIG5ldyBTUUwvSlNPTiBleHByZXNzaW9uIG5vZGVzIGluIGZ1 dHVyZSBjb21taXRzLgoKUmV2aWV3ZWQtYnk6IMOBbHZhcm8gSGVycmVyYQpSZXZpZXdlZC1ieTog QW5kcmVzIEZyZXVuZApEaXNjdXNzaW9uOiBodHRwczovL3Bvc3Rnci5lcy9tL0NBK0hpd3FFNFhU ZGZiMW5XPU9qb3lfdFFTUmhZdC1xX2tiNmk1ZDR4Y0t5ckxDMU5iZ0BtYWlsLmdtYWlsLmNvbQot LS0KIHNyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNFeHByLmMgICAgICAgfCAgOCArKy0KIHNyYy9i YWNrZW5kL2V4ZWN1dG9yL2V4ZWNFeHBySW50ZXJwLmMgfCA3NCArKysrKysrKysrKysrKysrKysr KysrKysrKy0KIHNyYy9iYWNrZW5kL2ppdC9sbHZtL2xsdm1qaXRfZXhwci5jICAgfCAgNiArKysK IHNyYy9iYWNrZW5kL2ppdC9sbHZtL2xsdm1qaXRfdHlwZXMuYyAgfCAgMSArCiBzcmMvaW5jbHVk ZS9leGVjdXRvci9leGVjRXhwci5oICAgICAgIHwgIDQgKysKIHNyYy9pbmNsdWRlL25vZGVzL2V4 ZWNub2Rlcy5oICAgICAgICAgfCAgNyArKysKIDYgZmlsZXMgY2hhbmdlZCwgOTcgaW5zZXJ0aW9u cygrKSwgMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9leGVjdXRvci9l eGVjRXhwci5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY0V4cHIuYwppbmRleCA5MWRmMjAw OWJlLi4zMTgxYjExMzZhIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjRXhw ci5jCisrKyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNFeHByLmMKQEAgLTE1NjAsNyArMTU2 MCwxMCBAQCBFeGVjSW5pdEV4cHJSZWMoRXhwciAqbm9kZSwgRXhwclN0YXRlICpzdGF0ZSwKIAkJ CQkgKiBXZSBkb24ndCBjaGVjayBwZXJtaXNzaW9ucyBoZXJlIGFzIGEgdHlwZSdzIGlucHV0L291 dHB1dAogCQkJCSAqIGZ1bmN0aW9uIGFyZSBhc3N1bWVkIHRvIGJlIGV4ZWN1dGFibGUgYnkgZXZl cnlvbmUuCiAJCQkJICovCi0JCQkJc2NyYXRjaC5vcGNvZGUgPSBFRU9QX0lPQ09FUkNFOworCQkJ CWlmIChzdGF0ZS0+ZXNjb250ZXh0ID09IE5VTEwpCisJCQkJCXNjcmF0Y2gub3Bjb2RlID0gRUVP UF9JT0NPRVJDRTsKKwkJCQllbHNlCisJCQkJCXNjcmF0Y2gub3Bjb2RlID0gRUVPUF9JT0NPRVJD RV9TQUZFOwogCiAJCQkJLyogbG9va3VwIHRoZSBzb3VyY2UgdHlwZSdzIG91dHB1dCBmdW5jdGlv biAqLwogCQkJCXNjcmF0Y2guZC5pb2NvZXJjZS5maW5mb19vdXQgPSBwYWxsb2MwKHNpemVvZihG bWdySW5mbykpOwpAQCAtMTU5Niw2ICsxNTk5LDggQEAgRXhlY0luaXRFeHByUmVjKEV4cHIgKm5v ZGUsIEV4cHJTdGF0ZSAqc3RhdGUsCiAJCQkJZmNpbmZvX2luLT5hcmdzWzJdLnZhbHVlID0gSW50 MzJHZXREYXR1bSgtMSk7CiAJCQkJZmNpbmZvX2luLT5hcmdzWzJdLmlzbnVsbCA9IGZhbHNlOwog CisJCQkJZmNpbmZvX2luLT5jb250ZXh0ID0gKE5vZGUgKikgc3RhdGUtPmVzY29udGV4dDsKKwog CQkJCUV4cHJFdmFsUHVzaFN0ZXAoc3RhdGUsICZzY3JhdGNoKTsKIAkJCQlicmVhazsKIAkJCX0K QEAgLTMzMDMsNiArMzMwOCw3IEBAIEV4ZWNJbml0Q29lcmNlVG9Eb21haW4oRXhwckV2YWxTdGVw ICpzY3JhdGNoLCBDb2VyY2VUb0RvbWFpbiAqY3Rlc3QsCiAJLyogd2UnbGwgYWxsb2NhdGUgd29y a3NwYWNlIG9ubHkgaWYgbmVlZGVkICovCiAJc2NyYXRjaC0+ZC5kb21haW5jaGVjay5jaGVja3Zh bHVlID0gTlVMTDsKIAlzY3JhdGNoLT5kLmRvbWFpbmNoZWNrLmNoZWNrbnVsbCA9IE5VTEw7CisJ c2NyYXRjaC0+ZC5kb21haW5jaGVjay5lc2NvbnRleHQgPSBzdGF0ZS0+ZXNjb250ZXh0OwogCiAJ LyoKIAkgKiBFdmFsdWF0ZSBhcmd1bWVudCAtIGl0J3MgZmluZSB0byBkaXJlY3RseSBzdG9yZSBp dCBpbnRvIHJlc3YvcmVzbnVsbCwKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4 ZWNFeHBySW50ZXJwLmMgYi9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjRXhwckludGVycC5jCmlu ZGV4IDNjMTdjYzZiMWUuLmIxN2NhYjA2YjYgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1 dG9yL2V4ZWNFeHBySW50ZXJwLmMKKysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY0V4cHJJ bnRlcnAuYwpAQCAtNjMsNiArNjMsNyBAQAogI2luY2x1ZGUgImV4ZWN1dG9yL25vZGVTdWJwbGFu LmgiCiAjaW5jbHVkZSAiZnVuY2FwaS5oIgogI2luY2x1ZGUgIm1pc2NhZG1pbi5oIgorI2luY2x1 ZGUgIm5vZGVzL21pc2Nub2Rlcy5oIgogI2luY2x1ZGUgIm5vZGVzL25vZGVGdW5jcy5oIgogI2lu Y2x1ZGUgInBhcnNlci9wYXJzZXRyZWUuaCIKICNpbmNsdWRlICJwZ3N0YXQuaCIKQEAgLTQ1Miw2 ICs0NTMsNyBAQCBFeGVjSW50ZXJwRXhwcihFeHByU3RhdGUgKnN0YXRlLCBFeHByQ29udGV4dCAq ZWNvbnRleHQsIGJvb2wgKmlzbnVsbCkKIAkJJiZDQVNFX0VFT1BfQ0FTRV9URVNUVkFMLAogCQkm JkNBU0VfRUVPUF9NQUtFX1JFQURPTkxZLAogCQkmJkNBU0VfRUVPUF9JT0NPRVJDRSwKKwkJJiZD QVNFX0VFT1BfSU9DT0VSQ0VfU0FGRSwKIAkJJiZDQVNFX0VFT1BfRElTVElOQ1QsCiAJCSYmQ0FT RV9FRU9QX05PVF9ESVNUSU5DVCwKIAkJJiZDQVNFX0VFT1BfTlVMTElGLApAQCAtMTIwNSw2ICsx MjA3LDEyIEBAIEV4ZWNJbnRlcnBFeHByKEV4cHJTdGF0ZSAqc3RhdGUsIEV4cHJDb250ZXh0ICpl Y29udGV4dCwgYm9vbCAqaXNudWxsKQogCQkJRUVPX05FWFQoKTsKIAkJfQogCisJCUVFT19DQVNF KEVFT1BfSU9DT0VSQ0VfU0FGRSkKKwkJeworCQkJRXhlY0V2YWxDb2VyY2VWaWFJT1NhZmUoc3Rh dGUsIG9wKTsKKwkJCUVFT19ORVhUKCk7CisJCX0KKwogCQlFRU9fQ0FTRShFRU9QX0RJU1RJTkNU KQogCQl7CiAJCQkvKgpAQCAtMjUxMCw2ICsyNTE4LDY4IEBAIEV4ZWNFdmFsUGFyYW1FeHRlcm4o RXhwclN0YXRlICpzdGF0ZSwgRXhwckV2YWxTdGVwICpvcCwgRXhwckNvbnRleHQgKmVjb250ZXh0 KQogCQkJIGVycm1zZygibm8gdmFsdWUgZm91bmQgZm9yIHBhcmFtZXRlciAlZCIsIHBhcmFtSWQp KSk7CiB9CiAKKy8qCisgKiBFdmFsdWF0ZSBhIENvZXJjZVZpYUlPIG5vZGUgaW4gc29mdC1lcnJv ciBtb2RlLgorICoKKyAqIFRoZSBzb3VyY2UgdmFsdWUgaXMgaW4gb3AncyByZXN1bHQgdmFyaWFi bGUuCisgKi8KK3ZvaWQKK0V4ZWNFdmFsQ29lcmNlVmlhSU9TYWZlKEV4cHJTdGF0ZSAqc3RhdGUs IEV4cHJFdmFsU3RlcCAqb3ApCit7CisJY2hhcgkgICAqc3RyOworCisJLyogY2FsbCBvdXRwdXQg ZnVuY3Rpb24gKHNpbWlsYXIgdG8gT3V0cHV0RnVuY3Rpb25DYWxsKSAqLworCWlmICgqb3AtPnJl c251bGwpCisJeworCQkvKiBvdXRwdXQgZnVuY3Rpb25zIGFyZSBub3QgY2FsbGVkIG9uIG51bGxz ICovCisJCXN0ciA9IE5VTEw7CisJfQorCWVsc2UKKwl7CisJCUZ1bmN0aW9uQ2FsbEluZm8gZmNp bmZvX291dDsKKworCQlmY2luZm9fb3V0ID0gb3AtPmQuaW9jb2VyY2UuZmNpbmZvX2RhdGFfb3V0 OworCQlmY2luZm9fb3V0LT5hcmdzWzBdLnZhbHVlID0gKm9wLT5yZXN2YWx1ZTsKKwkJZmNpbmZv X291dC0+YXJnc1swXS5pc251bGwgPSBmYWxzZTsKKworCQlmY2luZm9fb3V0LT5pc251bGwgPSBm YWxzZTsKKwkJc3RyID0gRGF0dW1HZXRDU3RyaW5nKEZ1bmN0aW9uQ2FsbEludm9rZShmY2luZm9f b3V0KSk7CisKKwkJLyogT3V0cHV0RnVuY3Rpb25DYWxsIGFzc3VtZXMgcmVzdWx0IGlzbid0IG51 bGwgKi8KKwkJQXNzZXJ0KCFmY2luZm9fb3V0LT5pc251bGwpOworCX0KKworCS8qIGNhbGwgaW5w dXQgZnVuY3Rpb24gKHNpbWlsYXIgdG8gSW5wdXRGdW5jdGlvbkNhbGwpICovCisJaWYgKCFvcC0+ ZC5pb2NvZXJjZS5maW5mb19pbi0+Zm5fc3RyaWN0IHx8IHN0ciAhPSBOVUxMKQorCXsKKwkJRnVu Y3Rpb25DYWxsSW5mbyBmY2luZm9faW47CisKKwkJZmNpbmZvX2luID0gb3AtPmQuaW9jb2VyY2Uu ZmNpbmZvX2RhdGFfaW47CisJCWZjaW5mb19pbi0+YXJnc1swXS52YWx1ZSA9IFBvaW50ZXJHZXRE YXR1bShzdHIpOworCQlmY2luZm9faW4tPmFyZ3NbMF0uaXNudWxsID0gKm9wLT5yZXNudWxsOwor CQkvKiBzZWNvbmQgYW5kIHRoaXJkIGFyZ3VtZW50cyBhcmUgYWxyZWFkeSBzZXQgdXAgKi8KKwor CQkvKiBFcnJvclNhdmVDb250ZXh0IG11c3QgYmUgcHJlc2VudC4gKi8KKwkJQXNzZXJ0KElzQShm Y2luZm9faW4tPmNvbnRleHQsIEVycm9yU2F2ZUNvbnRleHQpKTsKKworCQlmY2luZm9faW4tPmlz bnVsbCA9IGZhbHNlOworCQkqb3AtPnJlc3ZhbHVlID0gRnVuY3Rpb25DYWxsSW52b2tlKGZjaW5m b19pbik7CisKKwkJaWYgKFNPRlRfRVJST1JfT0NDVVJSRUQoZmNpbmZvX2luLT5jb250ZXh0KSkK KwkJeworCQkJKm9wLT5yZXNudWxsID0gdHJ1ZTsKKwkJCSpvcC0+cmVzdmFsdWUgPSAoRGF0dW0p IDA7CisJCQlyZXR1cm47CisJCX0KKworCQkvKiBTaG91bGQgZ2V0IG51bGwgcmVzdWx0IGlmIGFu ZCBvbmx5IGlmIHN0ciBpcyBOVUxMICovCisJCWlmIChzdHIgPT0gTlVMTCkKKwkJCUFzc2VydCgq b3AtPnJlc251bGwpOworCQllbHNlCisJCQlBc3NlcnQoISpvcC0+cmVzbnVsbCk7CisJfQorfQor CiAvKgogICogRXZhbHVhdGUgYSBTUUxWYWx1ZUZ1bmN0aW9uIGV4cHJlc3Npb24uCiAgKi8KQEAg LTM3MzAsNyArMzgwMCw3IEBAIHZvaWQKIEV4ZWNFdmFsQ29uc3RyYWludE5vdE51bGwoRXhwclN0 YXRlICpzdGF0ZSwgRXhwckV2YWxTdGVwICpvcCkKIHsKIAlpZiAoKm9wLT5yZXNudWxsKQotCQll cmVwb3J0KEVSUk9SLAorCQllcnJzYXZlKChOb2RlICopIG9wLT5kLmRvbWFpbmNoZWNrLmVzY29u dGV4dCwKIAkJCQkoZXJyY29kZShFUlJDT0RFX05PVF9OVUxMX1ZJT0xBVElPTiksCiAJCQkJIGVy cm1zZygiZG9tYWluICVzIGRvZXMgbm90IGFsbG93IG51bGwgdmFsdWVzIiwKIAkJCQkJCWZvcm1h dF90eXBlX2JlKG9wLT5kLmRvbWFpbmNoZWNrLnJlc3VsdHR5cGUpKSwKQEAgLTM3NDUsNyArMzgx NSw3IEBAIEV4ZWNFdmFsQ29uc3RyYWludENoZWNrKEV4cHJTdGF0ZSAqc3RhdGUsIEV4cHJFdmFs U3RlcCAqb3ApCiB7CiAJaWYgKCEqb3AtPmQuZG9tYWluY2hlY2suY2hlY2tudWxsICYmCiAJCSFE YXR1bUdldEJvb2woKm9wLT5kLmRvbWFpbmNoZWNrLmNoZWNrdmFsdWUpKQotCQllcmVwb3J0KEVS Uk9SLAorCQllcnJzYXZlKChOb2RlICopIG9wLT5kLmRvbWFpbmNoZWNrLmVzY29udGV4dCwKIAkJ CQkoZXJyY29kZShFUlJDT0RFX0NIRUNLX1ZJT0xBVElPTiksCiAJCQkJIGVycm1zZygidmFsdWUg Zm9yIGRvbWFpbiAlcyB2aW9sYXRlcyBjaGVjayBjb25zdHJhaW50IFwiJXNcIiIsCiAJCQkJCQlm b3JtYXRfdHlwZV9iZShvcC0+ZC5kb21haW5jaGVjay5yZXN1bHR0eXBlKSwKZGlmZiAtLWdpdCBh L3NyYy9iYWNrZW5kL2ppdC9sbHZtL2xsdm1qaXRfZXhwci5jIGIvc3JjL2JhY2tlbmQvaml0L2xs dm0vbGx2bWppdF9leHByLmMKaW5kZXggMzMxNjFkODEyZi4uMDk5OTQ1MDNiMSAxMDA2NDQKLS0t IGEvc3JjL2JhY2tlbmQvaml0L2xsdm0vbGx2bWppdF9leHByLmMKKysrIGIvc3JjL2JhY2tlbmQv aml0L2xsdm0vbGx2bWppdF9leHByLmMKQEAgLTE0MzEsNiArMTQzMSwxMiBAQCBsbHZtX2NvbXBp bGVfZXhwcihFeHByU3RhdGUgKnN0YXRlKQogCQkJCQlicmVhazsKIAkJCQl9CiAKKwkJCWNhc2Ug RUVPUF9JT0NPRVJDRV9TQUZFOgorCQkJCWJ1aWxkX0V2YWxYRnVuYyhiLCBtb2QsICJFeGVjRXZh bENvZXJjZVZpYUlPU2FmZSIsCisJCQkJCQkJCXZfc3RhdGUsIG9wKTsKKwkJCQlMTFZNQnVpbGRC cihiLCBvcGJsb2Nrc1tvcG5vICsgMV0pOworCQkJCWJyZWFrOworCiAJCQljYXNlIEVFT1BfRElT VElOQ1Q6CiAJCQljYXNlIEVFT1BfTk9UX0RJU1RJTkNUOgogCQkJCXsKZGlmZiAtLWdpdCBhL3Ny Yy9iYWNrZW5kL2ppdC9sbHZtL2xsdm1qaXRfdHlwZXMuYyBiL3NyYy9iYWNrZW5kL2ppdC9sbHZt L2xsdm1qaXRfdHlwZXMuYwppbmRleCA1MjEyZjUyOWM4Li40N2M5ZGFmNDAyIDEwMDY0NAotLS0g YS9zcmMvYmFja2VuZC9qaXQvbGx2bS9sbHZtaml0X3R5cGVzLmMKKysrIGIvc3JjL2JhY2tlbmQv aml0L2xsdm0vbGx2bWppdF90eXBlcy5jCkBAIC0xNjIsNiArMTYyLDcgQEAgdm9pZAkgICAqcmVm ZXJlbmNlZF9mdW5jdGlvbnNbXSA9CiAJRXhlY0V2YWxSb3csCiAJRXhlY0V2YWxSb3dOb3ROdWxs LAogCUV4ZWNFdmFsUm93TnVsbCwKKwlFeGVjRXZhbENvZXJjZVZpYUlPU2FmZSwKIAlFeGVjRXZh bFNRTFZhbHVlRnVuY3Rpb24sCiAJRXhlY0V2YWxTY2FsYXJBcnJheU9wLAogCUV4ZWNFdmFsSGFz aGVkU2NhbGFyQXJyYXlPcCwKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2V4ZWNF eHByLmggYi9zcmMvaW5jbHVkZS9leGVjdXRvci9leGVjRXhwci5oCmluZGV4IGEyMGM1MzlhMjUu LmEyOGRkY2RkNzcgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2V4ZWNFeHByLmgK KysrIGIvc3JjL2luY2x1ZGUvZXhlY3V0b3IvZXhlY0V4cHIuaApAQCAtMTYsNiArMTYsNyBAQAog CiAjaW5jbHVkZSAiZXhlY3V0b3Ivbm9kZUFnZy5oIgogI2luY2x1ZGUgIm5vZGVzL2V4ZWNub2Rl cy5oIgorI2luY2x1ZGUgIm5vZGVzL21pc2Nub2Rlcy5oIgogCiAvKiBmb3J3YXJkIHJlZmVyZW5j ZXMgdG8gYXZvaWQgY2lyY3VsYXJpdHkgKi8KIHN0cnVjdCBFeHByRXZhbFN0ZXA7CkBAIC0xNjgs NiArMTY5LDcgQEAgdHlwZWRlZiBlbnVtIEV4cHJFdmFsT3AKIAogCS8qIGV2YWx1YXRlIGFzc29y dGVkIHNwZWNpYWwtcHVycG9zZSBleHByZXNzaW9uIHR5cGVzICovCiAJRUVPUF9JT0NPRVJDRSwK KwlFRU9QX0lPQ09FUkNFX1NBRkUsCiAJRUVPUF9ESVNUSU5DVCwKIAlFRU9QX05PVF9ESVNUSU5D VCwKIAlFRU9QX05VTExJRiwKQEAgLTU0Nyw2ICs1NDksNyBAQCB0eXBlZGVmIHN0cnVjdCBFeHBy RXZhbFN0ZXAKIAkJCWJvb2wJICAgKmNoZWNrbnVsbDsKIAkJCS8qIE9JRCBvZiBkb21haW4gdHlw ZSAqLwogCQkJT2lkCQkJcmVzdWx0dHlwZTsKKwkJCUVycm9yU2F2ZUNvbnRleHQgKmVzY29udGV4 dDsKIAkJfQkJCWRvbWFpbmNoZWNrOwogCiAJCS8qIGZvciBFRU9QX0NPTlZFUlRfUk9XVFlQRSAq LwpAQCAtNzc2LDYgKzc3OSw3IEBAIGV4dGVybiB2b2lkIEV4ZWNFdmFsUGFyYW1FeGVjKEV4cHJT dGF0ZSAqc3RhdGUsIEV4cHJFdmFsU3RlcCAqb3AsCiAJCQkJCQkJICBFeHByQ29udGV4dCAqZWNv bnRleHQpOwogZXh0ZXJuIHZvaWQgRXhlY0V2YWxQYXJhbUV4dGVybihFeHByU3RhdGUgKnN0YXRl LCBFeHByRXZhbFN0ZXAgKm9wLAogCQkJCQkJCQlFeHByQ29udGV4dCAqZWNvbnRleHQpOworZXh0 ZXJuIHZvaWQgRXhlY0V2YWxDb2VyY2VWaWFJT1NhZmUoRXhwclN0YXRlICpzdGF0ZSwgRXhwckV2 YWxTdGVwICpvcCk7CiBleHRlcm4gdm9pZCBFeGVjRXZhbFNRTFZhbHVlRnVuY3Rpb24oRXhwclN0 YXRlICpzdGF0ZSwgRXhwckV2YWxTdGVwICpvcCk7CiBleHRlcm4gdm9pZCBFeGVjRXZhbEN1cnJl bnRPZkV4cHIoRXhwclN0YXRlICpzdGF0ZSwgRXhwckV2YWxTdGVwICpvcCk7CiBleHRlcm4gdm9p ZCBFeGVjRXZhbE5leHRWYWx1ZUV4cHIoRXhwclN0YXRlICpzdGF0ZSwgRXhwckV2YWxTdGVwICpv cCk7CmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9ub2Rlcy9leGVjbm9kZXMuaCBiL3NyYy9pbmNs dWRlL25vZGVzL2V4ZWNub2Rlcy5oCmluZGV4IDU2MWZkZDk4ZjEuLjQ0NGE1ZjBmZDUgMTAwNjQ0 Ci0tLSBhL3NyYy9pbmNsdWRlL25vZGVzL2V4ZWNub2Rlcy5oCisrKyBiL3NyYy9pbmNsdWRlL25v ZGVzL2V4ZWNub2Rlcy5oCkBAIC0zNCw2ICszNCw3IEBACiAjaW5jbHVkZSAiZm1nci5oIgogI2lu Y2x1ZGUgImxpYi9pbGlzdC5oIgogI2luY2x1ZGUgImxpYi9wYWlyaW5naGVhcC5oIgorI2luY2x1 ZGUgIm5vZGVzL21pc2Nub2Rlcy5oIgogI2luY2x1ZGUgIm5vZGVzL3BhcmFtcy5oIgogI2luY2x1 ZGUgIm5vZGVzL3BsYW5ub2Rlcy5oIgogI2luY2x1ZGUgIm5vZGVzL3RpZGJpdG1hcC5oIgpAQCAt MTI5LDYgKzEzMCwxMiBAQCB0eXBlZGVmIHN0cnVjdCBFeHByU3RhdGUKIAogCURhdHVtCSAgICpp bm5lcm1vc3RfZG9tYWludmFsOwogCWJvb2wJICAgKmlubmVybW9zdF9kb21haW5udWxsOworCisJ LyoKKwkgKiBGb3IgZXhwcmVzc2lvbiBub2RlcyB0aGF0IHN1cHBvcnQgc29mdCBlcnJvcnMuICBT aG91bGQgYmUgc2V0IHRvIE5VTEwKKwkgKiBiZWZvcmUgY2FsbGluZyBFeGVjSW5pdEV4cHJSZWMo KSBpZiB0aGUgY2FsbGVyIHdhbnRzIGVycm9ycyB0aHJvd24uCisJICovCisJRXJyb3JTYXZlQ29u dGV4dCAqZXNjb250ZXh0OwogfSBFeHByU3RhdGU7CiAKIAotLSAKMi4zNS4zCgo= --00000000000078edb1060f38208c Content-Type: application/octet-stream; name="v34-0003-Refactor-code-used-by-jsonpath-executor-to-fetch.patch" Content-Disposition: attachment; filename="v34-0003-Refactor-code-used-by-jsonpath-executor-to-fetch.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lrj7oaos2 RnJvbSBjY2I3ZGJjOGE3OGVlN2IwMDI4OTc0Nzc0NGI1Mjk1YjRmZjlhZmYyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbWl0IExhbmdvdGUgPGFtaXRsYW5AcG9zdGdyZXNxbC5vcmc+ CkRhdGU6IFRodSwgMTggSmFuIDIwMjQgMTY6MzA6NTYgKzA5MDAKU3ViamVjdDogW1BBVENIIHYz NCAzLzhdIFJlZmFjdG9yIGNvZGUgdXNlZCBieSBqc29ucGF0aCBleGVjdXRvciB0byBmZXRjaAog dmFyaWFibGVzCgpDdXJyZW50bHksIGdldEpzb25QYXRoVmFyaWFibGUoKSBkaXJlY3RseSBleHRy YWN0cyBhIG5hbWVkCnZhcmlhYmxlL2tleSBmcm9tIHRoZSBzb3VyY2UgSnNvbmIgdmFsdWUuICBU aGlzIGNvbW1pdCBwdXRzIHRoYXQKbG9naWMgaW50byBhIGNhbGxiYWNrIGZ1bmN0aW9uIGNhbGxl ZCBieSBnZXRKc29uUGF0aFZhcmlhYmxlKCkuCk90aGVyIGltcGxlbWVudGF0aW9ucyBvZiB0aGUg Y2FsbGJhY2sgbWF5IGFjY2VwdCBkaWZmZXJlbnQgZm9ybXMKb2YgdGhlIHNvdXJjZSB2YWx1ZShz KSwgZm9yIGV4YW1wbGUsIGEgTGlzdCBvZiB2YWx1ZXMgcGFzc2VkIGZyb20Kb3V0c2lkZSBqc29u cGF0aF9leGVjLmMuCgpEaXNjdXNzaW9uOiBodHRwczovL3Bvc3Rnci5lcy9tL0NBK0hpd3FFNFhU ZGZiMW5XPU9qb3lfdFFTUmhZdC1xX2tiNmk1ZDR4Y0t5ckxDMU5iZ0BtYWlsLmdtYWlsLmNvbQot LS0KIHNyYy9iYWNrZW5kL3V0aWxzL2FkdC9qc29ucGF0aF9leGVjLmMgfCAxMzYgKysrKysrKysr KysrKysrKysrKy0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCA5OSBpbnNlcnRpb25zKCspLCAzNyBk ZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9hZHQvanNvbnBhdGhf ZXhlYy5jIGIvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L2pzb25wYXRoX2V4ZWMuYwppbmRleCBhYzE2 ZjVjODVkLi5jMTYyODIxZTY1IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC91dGlscy9hZHQvanNv bnBhdGhfZXhlYy5jCisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9qc29ucGF0aF9leGVjLmMK QEAgLTg3LDEyICs4NywxOSBAQCB0eXBlZGVmIHN0cnVjdCBKc29uQmFzZU9iamVjdEluZm8KIAlp bnQJCQlpZDsKIH0gSnNvbkJhc2VPYmplY3RJbmZvOwogCisvKiBDYWxsYmFja3MgZm9yIGV4ZWN1 dGVKc29uUGF0aCgpICovCit0eXBlZGVmIEpzb25iVmFsdWUgKigqSnNvblBhdGhHZXRWYXJDYWxs YmFjaykgKHZvaWQgKnZhcnMsIGNoYXIgKnZhck5hbWUsIGludCB2YXJOYW1lTGVuLAorCQkJCQkJ CQkJCQkgICBKc29uYlZhbHVlICpiYXNlT2JqZWN0LCBpbnQgKmJhc2VPYmplY3RJZCk7Cit0eXBl ZGVmIGludCAoKkpzb25QYXRoQ291bnRWYXJzQ2FsbGJhY2spICh2b2lkICp2YXJzKTsKKwogLyoK ICAqIENvbnRleHQgb2YganNvbnBhdGggZXhlY3V0aW9uLgogICovCiB0eXBlZGVmIHN0cnVjdCBK c29uUGF0aEV4ZWNDb250ZXh0CiB7Ci0JSnNvbmIJICAgKnZhcnM7CQkJLyogdmFyaWFibGVzIHRv IHN1YnN0aXR1dGUgaW50byBqc29ucGF0aCAqLworCXZvaWQJICAgKnZhcnM7CQkJLyogdmFyaWFi bGVzIHRvIHN1YnN0aXR1dGUgaW50byBqc29ucGF0aCAqLworCUpzb25QYXRoR2V0VmFyQ2FsbGJh Y2sgZ2V0VmFyOwkvKiBjYWxsYmFjayB0byBleHRyYWN0IGEgZ2l2ZW4gdmFyaWFibGUKKwkJCQkJ CQkJCSAqIGZyb20gJ3ZhcnMnICovCiAJSnNvbmJWYWx1ZSAqcm9vdDsJCQkvKiBmb3IgJCBldmFs dWF0aW9uICovCiAJSnNvbmJWYWx1ZSAqY3VycmVudDsJCS8qIGZvciBAIGV2YWx1YXRpb24gKi8K IAlKc29uQmFzZU9iamVjdEluZm8gYmFzZU9iamVjdDsJLyogImJhc2Ugb2JqZWN0IiBmb3IgLmtl eXZhbHVlKCkKQEAgLTE3NCw3ICsxODEsOSBAQCB0eXBlZGVmIEpzb25QYXRoQm9vbCAoKkpzb25Q YXRoUHJlZGljYXRlQ2FsbGJhY2spIChKc29uUGF0aEl0ZW0gKmpzcCwKIAkJCQkJCQkJCQkJCSAg IHZvaWQgKnBhcmFtKTsKIHR5cGVkZWYgTnVtZXJpYyAoKkJpbmFyeUFyaXRobUZ1bmMpIChOdW1l cmljIG51bTEsIE51bWVyaWMgbnVtMiwgYm9vbCAqZXJyb3IpOwogCi1zdGF0aWMgSnNvblBhdGhF eGVjUmVzdWx0IGV4ZWN1dGVKc29uUGF0aChKc29uUGF0aCAqcGF0aCwgSnNvbmIgKnZhcnMsCitz dGF0aWMgSnNvblBhdGhFeGVjUmVzdWx0IGV4ZWN1dGVKc29uUGF0aChKc29uUGF0aCAqcGF0aCwg dm9pZCAqdmFycywKKwkJCQkJCQkJCQkgIEpzb25QYXRoR2V0VmFyQ2FsbGJhY2sgZ2V0VmFyLAor CQkJCQkJCQkJCSAgSnNvblBhdGhDb3VudFZhcnNDYWxsYmFjayBjb3VudFZhcnMsCiAJCQkJCQkJ CQkJICBKc29uYiAqanNvbiwgYm9vbCB0aHJvd0Vycm9ycywKIAkJCQkJCQkJCQkgIEpzb25WYWx1 ZUxpc3QgKnJlc3VsdCwgYm9vbCB1c2VUeik7CiBzdGF0aWMgSnNvblBhdGhFeGVjUmVzdWx0IGV4 ZWN1dGVJdGVtKEpzb25QYXRoRXhlY0NvbnRleHQgKmN4dCwKQEAgLTIyNiw3ICsyMzUsMTIgQEAg c3RhdGljIEpzb25QYXRoRXhlY1Jlc3VsdCBhcHBlbmRCb29sUmVzdWx0KEpzb25QYXRoRXhlY0Nv bnRleHQgKmN4dCwKIHN0YXRpYyB2b2lkIGdldEpzb25QYXRoSXRlbShKc29uUGF0aEV4ZWNDb250 ZXh0ICpjeHQsIEpzb25QYXRoSXRlbSAqaXRlbSwKIAkJCQkJCQlKc29uYlZhbHVlICp2YWx1ZSk7 CiBzdGF0aWMgdm9pZCBnZXRKc29uUGF0aFZhcmlhYmxlKEpzb25QYXRoRXhlY0NvbnRleHQgKmN4 dCwKLQkJCQkJCQkJSnNvblBhdGhJdGVtICp2YXJpYWJsZSwgSnNvbmIgKnZhcnMsIEpzb25iVmFs dWUgKnZhbHVlKTsKKwkJCQkJCQkJSnNvblBhdGhJdGVtICp2YXJpYWJsZSwgSnNvbmJWYWx1ZSAq dmFsdWUpOworc3RhdGljIGludCBjb3VudFZhcmlhYmxlc0Zyb21Kc29uYih2b2lkICp2YXJzSnNv bmIpOworc3RhdGljIEpzb25iVmFsdWUgKmdldEpzb25QYXRoVmFyaWFibGVGcm9tSnNvbmIodm9p ZCAqdmFyc0pzb25iLCBjaGFyICp2YXJOYW1lLAorCQkJCQkJCQkJCQkJaW50IHZhck5hbWVMZW4s CisJCQkJCQkJCQkJCQlKc29uYlZhbHVlICpiYXNlT2JqZWN0LAorCQkJCQkJCQkJCQkJaW50ICpi YXNlT2JqZWN0SWQpOwogc3RhdGljIGludAlKc29uYkFycmF5U2l6ZShKc29uYlZhbHVlICpqYik7 CiBzdGF0aWMgSnNvblBhdGhCb29sIGV4ZWN1dGVDb21wYXJpc29uKEpzb25QYXRoSXRlbSAqY21w LCBKc29uYlZhbHVlICpsdiwKIAkJCQkJCQkJCSAgSnNvbmJWYWx1ZSAqcnYsIHZvaWQgKnApOwpA QCAtMjg0LDcgKzI5OCw5IEBAIGpzb25iX3BhdGhfZXhpc3RzX2ludGVybmFsKEZ1bmN0aW9uQ2Fs bEluZm8gZmNpbmZvLCBib29sIHR6KQogCQlzaWxlbnQgPSBQR19HRVRBUkdfQk9PTCgzKTsKIAl9 CiAKLQlyZXMgPSBleGVjdXRlSnNvblBhdGgoanAsIHZhcnMsIGpiLCAhc2lsZW50LCBOVUxMLCB0 eik7CisJcmVzID0gZXhlY3V0ZUpzb25QYXRoKGpwLCB2YXJzLCBnZXRKc29uUGF0aFZhcmlhYmxl RnJvbUpzb25iLAorCQkJCQkJICBjb3VudFZhcmlhYmxlc0Zyb21Kc29uYiwKKwkJCQkJCSAgamIs ICFzaWxlbnQsIE5VTEwsIHR6KTsKIAogCVBHX0ZSRUVfSUZfQ09QWShqYiwgMCk7CiAJUEdfRlJF RV9JRl9DT1BZKGpwLCAxKTsKQEAgLTMzOSw3ICszNTUsOSBAQCBqc29uYl9wYXRoX21hdGNoX2lu dGVybmFsKEZ1bmN0aW9uQ2FsbEluZm8gZmNpbmZvLCBib29sIHR6KQogCQlzaWxlbnQgPSBQR19H RVRBUkdfQk9PTCgzKTsKIAl9CiAKLQkodm9pZCkgZXhlY3V0ZUpzb25QYXRoKGpwLCB2YXJzLCBq YiwgIXNpbGVudCwgJmZvdW5kLCB0eik7CisJKHZvaWQpIGV4ZWN1dGVKc29uUGF0aChqcCwgdmFy cywgZ2V0SnNvblBhdGhWYXJpYWJsZUZyb21Kc29uYiwKKwkJCQkJCSAgIGNvdW50VmFyaWFibGVz RnJvbUpzb25iLAorCQkJCQkJICAgamIsICFzaWxlbnQsICZmb3VuZCwgdHopOwogCiAJUEdfRlJF RV9JRl9DT1BZKGpiLCAwKTsKIAlQR19GUkVFX0lGX0NPUFkoanAsIDEpOwpAQCAtNDE3LDcgKzQz NSw5IEBAIGpzb25iX3BhdGhfcXVlcnlfaW50ZXJuYWwoRnVuY3Rpb25DYWxsSW5mbyBmY2luZm8s IGJvb2wgdHopCiAJCXZhcnMgPSBQR19HRVRBUkdfSlNPTkJfUF9DT1BZKDIpOwogCQlzaWxlbnQg PSBQR19HRVRBUkdfQk9PTCgzKTsKIAotCQkodm9pZCkgZXhlY3V0ZUpzb25QYXRoKGpwLCB2YXJz LCBqYiwgIXNpbGVudCwgJmZvdW5kLCB0eik7CisJCSh2b2lkKSBleGVjdXRlSnNvblBhdGgoanAs IHZhcnMsIGdldEpzb25QYXRoVmFyaWFibGVGcm9tSnNvbmIsCisJCQkJCQkJICAgY291bnRWYXJp YWJsZXNGcm9tSnNvbmIsCisJCQkJCQkJICAgamIsICFzaWxlbnQsICZmb3VuZCwgdHopOwogCiAJ CWZ1bmNjdHgtPnVzZXJfZmN0eCA9IEpzb25WYWx1ZUxpc3RHZXRMaXN0KCZmb3VuZCk7CiAKQEAg LTQ2NCw3ICs0ODQsOSBAQCBqc29uYl9wYXRoX3F1ZXJ5X2FycmF5X2ludGVybmFsKEZ1bmN0aW9u Q2FsbEluZm8gZmNpbmZvLCBib29sIHR6KQogCUpzb25iCSAgICp2YXJzID0gUEdfR0VUQVJHX0pT T05CX1AoMik7CiAJYm9vbAkJc2lsZW50ID0gUEdfR0VUQVJHX0JPT0woMyk7CiAKLQkodm9pZCkg ZXhlY3V0ZUpzb25QYXRoKGpwLCB2YXJzLCBqYiwgIXNpbGVudCwgJmZvdW5kLCB0eik7CisJKHZv aWQpIGV4ZWN1dGVKc29uUGF0aChqcCwgdmFycywgZ2V0SnNvblBhdGhWYXJpYWJsZUZyb21Kc29u YiwKKwkJCQkJCSAgIGNvdW50VmFyaWFibGVzRnJvbUpzb25iLAorCQkJCQkJICAgamIsICFzaWxl bnQsICZmb3VuZCwgdHopOwogCiAJUEdfUkVUVVJOX0pTT05CX1AoSnNvbmJWYWx1ZVRvSnNvbmIo d3JhcEl0ZW1zSW5BcnJheSgmZm91bmQpKSk7CiB9CkBAIC00OTUsNyArNTE3LDkgQEAganNvbmJf cGF0aF9xdWVyeV9maXJzdF9pbnRlcm5hbChGdW5jdGlvbkNhbGxJbmZvIGZjaW5mbywgYm9vbCB0 eikKIAlKc29uYgkgICAqdmFycyA9IFBHX0dFVEFSR19KU09OQl9QKDIpOwogCWJvb2wJCXNpbGVu dCA9IFBHX0dFVEFSR19CT09MKDMpOwogCi0JKHZvaWQpIGV4ZWN1dGVKc29uUGF0aChqcCwgdmFy cywgamIsICFzaWxlbnQsICZmb3VuZCwgdHopOworCSh2b2lkKSBleGVjdXRlSnNvblBhdGgoanAs IHZhcnMsIGdldEpzb25QYXRoVmFyaWFibGVGcm9tSnNvbmIsCisJCQkJCQkgICBjb3VudFZhcmlh Ymxlc0Zyb21Kc29uYiwKKwkJCQkJCSAgIGpiLCAhc2lsZW50LCAmZm91bmQsIHR6KTsKIAogCWlm IChKc29uVmFsdWVMaXN0TGVuZ3RoKCZmb3VuZCkgPj0gMSkKIAkJUEdfUkVUVVJOX0pTT05CX1Ao SnNvbmJWYWx1ZVRvSnNvbmIoSnNvblZhbHVlTGlzdEhlYWQoJmZvdW5kKSkpOwpAQCAtNTIyLDYg KzU0Niw5IEBAIGpzb25iX3BhdGhfcXVlcnlfZmlyc3RfdHooUEdfRlVOQ1RJT05fQVJHUykKICAq CiAgKiAncGF0aCcgLSBqc29ucGF0aCB0byBiZSBleGVjdXRlZAogICogJ3ZhcnMnIC0gdmFyaWFi bGVzIHRvIGJlIHN1YnN0aXR1dGVkIHRvIGpzb25wYXRoCisgKiAnZ2V0VmFyJyAtIGNhbGxiYWNr IHVzZWQgYnkgZ2V0SnNvblBhdGhWYXJpYWJsZSgpIHRvIGV4dHJhY3QgdmFyaWFibGVzIGZyb20K KyAqCQkndmFycycKKyAqICdjb3VudFZhcnMnIC0gY2FsbGJhY2sgdG8gY291bnQgdGhlIG51bWJl ciBvZiBqc29ucGF0aCB2YXJpYWJsZXMgaW4gJ3ZhcnMnCiAgKiAnanNvbicgLSB0YXJnZXQgZG9j dW1lbnQgZm9yIGpzb25wYXRoIGV2YWx1YXRpb24KICAqICd0aHJvd0Vycm9ycycgLSB3aGV0aGVy IHdlIHNob3VsZCB0aHJvdyBzdXBwcmVzc2libGUgZXJyb3JzCiAgKiAncmVzdWx0JyAtIGxpc3Qg dG8gc3RvcmUgcmVzdWx0IGl0ZW1zIGludG8KQEAgLTUzNyw4ICs1NjQsMTAgQEAganNvbmJfcGF0 aF9xdWVyeV9maXJzdF90eihQR19GVU5DVElPTl9BUkdTKQogICogSW4gb3RoZXIgY2FzZSBpdCB0 cmllcyB0byBmaW5kIGFsbCB0aGUgc2F0aXNmaWVkIHJlc3VsdCBpdGVtcy4KICAqLwogc3RhdGlj IEpzb25QYXRoRXhlY1Jlc3VsdAotZXhlY3V0ZUpzb25QYXRoKEpzb25QYXRoICpwYXRoLCBKc29u YiAqdmFycywgSnNvbmIgKmpzb24sIGJvb2wgdGhyb3dFcnJvcnMsCi0JCQkJSnNvblZhbHVlTGlz dCAqcmVzdWx0LCBib29sIHVzZVR6KQorZXhlY3V0ZUpzb25QYXRoKEpzb25QYXRoICpwYXRoLCB2 b2lkICp2YXJzLCBKc29uUGF0aEdldFZhckNhbGxiYWNrIGdldFZhciwKKwkJCQlKc29uUGF0aENv dW50VmFyc0NhbGxiYWNrIGNvdW50VmFycywKKwkJCQlKc29uYiAqanNvbiwgYm9vbCB0aHJvd0Vy cm9ycywgSnNvblZhbHVlTGlzdCAqcmVzdWx0LAorCQkJCWJvb2wgdXNlVHopCiB7CiAJSnNvblBh dGhFeGVjQ29udGV4dCBjeHQ7CiAJSnNvblBhdGhFeGVjUmVzdWx0IHJlczsKQEAgLTU1MCwyMiAr NTc5LDE2IEBAIGV4ZWN1dGVKc29uUGF0aChKc29uUGF0aCAqcGF0aCwgSnNvbmIgKnZhcnMsIEpz b25iICpqc29uLCBib29sIHRocm93RXJyb3JzLAogCWlmICghSnNvbmJFeHRyYWN0U2NhbGFyKCZq c29uLT5yb290LCAmamJ2KSkKIAkJSnNvbmJJbml0QmluYXJ5KCZqYnYsIGpzb24pOwogCi0JaWYg KHZhcnMgJiYgIUpzb25Db250YWluZXJJc09iamVjdCgmdmFycy0+cm9vdCkpCi0JewotCQllcmVw b3J0KEVSUk9SLAotCQkJCShlcnJjb2RlKEVSUkNPREVfSU5WQUxJRF9QQVJBTUVURVJfVkFMVUUp LAotCQkJCSBlcnJtc2coIlwidmFyc1wiIGFyZ3VtZW50IGlzIG5vdCBhbiBvYmplY3QiKSwKLQkJ CQkgZXJyZGV0YWlsKCJKc29ucGF0aCBwYXJhbWV0ZXJzIHNob3VsZCBiZSBlbmNvZGVkIGFzIGtl eS12YWx1ZSBwYWlycyBvZiBcInZhcnNcIiBvYmplY3QuIikpKTsKLQl9Ci0KIAljeHQudmFycyA9 IHZhcnM7CisJY3h0LmdldFZhciA9IGdldFZhcjsKIAljeHQubGF4TW9kZSA9IChwYXRoLT5oZWFk ZXIgJiBKU09OUEFUSF9MQVgpICE9IDA7CiAJY3h0Lmlnbm9yZVN0cnVjdHVyYWxFcnJvcnMgPSBj eHQubGF4TW9kZTsKIAljeHQucm9vdCA9ICZqYnY7CiAJY3h0LmN1cnJlbnQgPSAmamJ2OwogCWN4 dC5iYXNlT2JqZWN0LmpiYyA9IE5VTEw7CiAJY3h0LmJhc2VPYmplY3QuaWQgPSAwOwotCWN4dC5s YXN0R2VuZXJhdGVkT2JqZWN0SWQgPSB2YXJzID8gMiA6IDE7CisJLyogMSArIG51bWJlciBvZiBi YXNlIG9iamVjdHMgaW4gdmFycyAqLworCWN4dC5sYXN0R2VuZXJhdGVkT2JqZWN0SWQgPSAxICsg Y291bnRWYXJzKHZhcnMpOwogCWN4dC5pbm5lcm1vc3RBcnJheVNpemUgPSAtMTsKIAljeHQudGhy b3dFcnJvcnMgPSB0aHJvd0Vycm9yczsKIAljeHQudXNlVHogPSB1c2VUejsKQEAgLTIxMDgsNyAr MjEzMSw3IEBAIGdldEpzb25QYXRoSXRlbShKc29uUGF0aEV4ZWNDb250ZXh0ICpjeHQsIEpzb25Q YXRoSXRlbSAqaXRlbSwKIAkJCQkJCQkJCQkJCSAmdmFsdWUtPnZhbC5zdHJpbmcubGVuKTsKIAkJ CWJyZWFrOwogCQljYXNlIGpwaVZhcmlhYmxlOgotCQkJZ2V0SnNvblBhdGhWYXJpYWJsZShjeHQs IGl0ZW0sIGN4dC0+dmFycywgdmFsdWUpOworCQkJZ2V0SnNvblBhdGhWYXJpYWJsZShjeHQsIGl0 ZW0sIHZhbHVlKTsKIAkJCXJldHVybjsKIAkJZGVmYXVsdDoKIAkJCWVsb2coRVJST1IsICJ1bmV4 cGVjdGVkIGpzb25wYXRoIGl0ZW0gdHlwZSIpOwpAQCAtMjEyMCw0MiArMjE0Myw4MSBAQCBnZXRK c29uUGF0aEl0ZW0oSnNvblBhdGhFeGVjQ29udGV4dCAqY3h0LCBKc29uUGF0aEl0ZW0gKml0ZW0s CiAgKi8KIHN0YXRpYyB2b2lkCiBnZXRKc29uUGF0aFZhcmlhYmxlKEpzb25QYXRoRXhlY0NvbnRl eHQgKmN4dCwgSnNvblBhdGhJdGVtICp2YXJpYWJsZSwKLQkJCQkJSnNvbmIgKnZhcnMsIEpzb25i VmFsdWUgKnZhbHVlKQorCQkJCQlKc29uYlZhbHVlICp2YWx1ZSkKIHsKIAljaGFyCSAgICp2YXJO YW1lOwogCWludAkJCXZhck5hbWVMZW5ndGg7Ci0JSnNvbmJWYWx1ZQl0bXA7CisJSnNvbmJWYWx1 ZQliYXNlT2JqZWN0OworCWludAkJCWJhc2VPYmplY3RJZDsKIAlKc29uYlZhbHVlICp2OwogCi0J aWYgKCF2YXJzKQorCUFzc2VydCh2YXJpYWJsZS0+dHlwZSA9PSBqcGlWYXJpYWJsZSk7CisJdmFy TmFtZSA9IGpzcEdldFN0cmluZyh2YXJpYWJsZSwgJnZhck5hbWVMZW5ndGgpOworCisJaWYgKGN4 dC0+dmFycyA9PSBOVUxMIHx8CisJCSh2ID0gY3h0LT5nZXRWYXIoY3h0LT52YXJzLCB2YXJOYW1l LCB2YXJOYW1lTGVuZ3RoLAorCQkJCQkJICZiYXNlT2JqZWN0LCAmYmFzZU9iamVjdElkKSkgPT0g TlVMTCkKKwkJZXJlcG9ydChFUlJPUiwKKwkJCQkoZXJyY29kZShFUlJDT0RFX1VOREVGSU5FRF9P QkpFQ1QpLAorCQkJCSBlcnJtc2coImNvdWxkIG5vdCBmaW5kIGpzb25wYXRoIHZhcmlhYmxlIFwi JXNcIiIsCisJCQkJCQlwbnN0cmR1cCh2YXJOYW1lLCB2YXJOYW1lTGVuZ3RoKSkpKTsKKworCWlm IChiYXNlT2JqZWN0SWQgPiAwKQogCXsKLQkJdmFsdWUtPnR5cGUgPSBqYnZOdWxsOwotCQlyZXR1 cm47CisJCSp2YWx1ZSA9ICp2OworCQlzZXRCYXNlT2JqZWN0KGN4dCwgJmJhc2VPYmplY3QsIGJh c2VPYmplY3RJZCk7CiAJfQorfQorCisvKgorICogRGVmaW5pdGlvbiBvZiBKc29uUGF0aEdldFZh ckNhbGxiYWNrIGZvciB3aGVuIEpzb25QYXRoRXhlY0NvbnRleHQudmFycworICogaXMgc3BlY2lm aWVkIGFzIGEganNvbmIgdmFsdWUuCisgKi8KK3N0YXRpYyBKc29uYlZhbHVlICoKK2dldEpzb25Q YXRoVmFyaWFibGVGcm9tSnNvbmIodm9pZCAqdmFyc0pzb25iLCBjaGFyICp2YXJOYW1lLCBpbnQg dmFyTmFtZUxlbmd0aCwKKwkJCQkJCQkgSnNvbmJWYWx1ZSAqYmFzZU9iamVjdCwgaW50ICpiYXNl T2JqZWN0SWQpCit7CisJSnNvbmIJICAgKnZhcnMgPSB2YXJzSnNvbmI7CisJSnNvbmJWYWx1ZQl0 bXA7CisJSnNvbmJWYWx1ZSAqcmVzdWx0OwogCi0JQXNzZXJ0KHZhcmlhYmxlLT50eXBlID09IGpw aVZhcmlhYmxlKTsKLQl2YXJOYW1lID0ganNwR2V0U3RyaW5nKHZhcmlhYmxlLCAmdmFyTmFtZUxl bmd0aCk7CiAJdG1wLnR5cGUgPSBqYnZTdHJpbmc7CiAJdG1wLnZhbC5zdHJpbmcudmFsID0gdmFy TmFtZTsKIAl0bXAudmFsLnN0cmluZy5sZW4gPSB2YXJOYW1lTGVuZ3RoOwogCi0JdiA9IGZpbmRK c29uYlZhbHVlRnJvbUNvbnRhaW5lcigmdmFycy0+cm9vdCwgSkJfRk9CSkVDVCwgJnRtcCk7CisJ cmVzdWx0ID0gZmluZEpzb25iVmFsdWVGcm9tQ29udGFpbmVyKCZ2YXJzLT5yb290LCBKQl9GT0JK RUNULCAmdG1wKTsKIAotCWlmICh2KQorCWlmIChyZXN1bHQgPT0gTlVMTCkKIAl7Ci0JCSp2YWx1 ZSA9ICp2OwotCQlwZnJlZSh2KTsKKwkJKmJhc2VPYmplY3RJZCA9IC0xOworCQlyZXR1cm4gTlVM TDsKIAl9Ci0JZWxzZQorCisJKmJhc2VPYmplY3RJZCA9IDE7CisJSnNvbmJJbml0QmluYXJ5KGJh c2VPYmplY3QsIHZhcnMpOworCisJcmV0dXJuIHJlc3VsdDsKK30KKworLyoKKyAqIERlZmluaXRp b24gb2YgSnNvblBhdGhDb3VudFZhcnNDYWxsYmFjayBmb3Igd2hlbiBKc29uUGF0aEV4ZWNDb250 ZXh0LnZhcnMKKyAqIGlzIHNwZWNpZmllZCBhcyBhIGpzb25iIHZhbHVlLgorICovCitzdGF0aWMg aW50Citjb3VudFZhcmlhYmxlc0Zyb21Kc29uYih2b2lkICp2YXJzSnNvbmIpCit7CisJSnNvbmIJ ICAgKnZhcnMgPSB2YXJzSnNvbmI7CisKKwlpZiAodmFycyAmJiAhSnNvbkNvbnRhaW5lcklzT2Jq ZWN0KCZ2YXJzLT5yb290KSkKIAl7CiAJCWVyZXBvcnQoRVJST1IsCi0JCQkJKGVycmNvZGUoRVJS Q09ERV9VTkRFRklORURfT0JKRUNUKSwKLQkJCQkgZXJybXNnKCJjb3VsZCBub3QgZmluZCBqc29u cGF0aCB2YXJpYWJsZSBcIiVzXCIiLAotCQkJCQkJcG5zdHJkdXAodmFyTmFtZSwgdmFyTmFtZUxl bmd0aCkpKSk7CisJCQkJZXJyY29kZShFUlJDT0RFX0lOVkFMSURfUEFSQU1FVEVSX1ZBTFVFKSwK KwkJCQllcnJtc2coIlwidmFyc1wiIGFyZ3VtZW50IGlzIG5vdCBhbiBvYmplY3QiKSwKKwkJCQll cnJkZXRhaWwoIkpzb25wYXRoIHBhcmFtZXRlcnMgc2hvdWxkIGJlIGVuY29kZWQgYXMga2V5LXZh bHVlIHBhaXJzIG9mIFwidmFyc1wiIG9iamVjdC4iKSk7CiAJfQogCi0JSnNvbmJJbml0QmluYXJ5 KCZ0bXAsIHZhcnMpOwotCXNldEJhc2VPYmplY3QoY3h0LCAmdG1wLCAxKTsKKwkvKiBjb3VudCBv ZiBiYXNlIG9iamVjdHMgKi8KKwlyZXR1cm4gdmFycyAhPSBOVUxMID8gMSA6IDA7CiB9CiAKIC8q KioqKioqKioqKioqKioqIFN1cHBvcnQgZnVuY3Rpb25zIGZvciBKc29uUGF0aCBleGVjdXRpb24g KioqKioqKioqKioqKioqKiovCi0tIAoyLjM1LjMKCg== --00000000000078edb1060f38208c Content-Type: application/octet-stream; name="v34-0004-Add-jsonpath_exec-APIs-to-use-in-SQL-JSON-query-.patch" Content-Disposition: attachment; filename="v34-0004-Add-jsonpath_exec-APIs-to-use-in-SQL-JSON-query-.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lrj7oaox3 RnJvbSAzNTk1OWM5MmRkMzhjMWNjMGM4ZGU3ZjgyYzI4MzRjYzJiMWQxZDhlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbWl0IExhbmdvdGUgPGFtaXRsYW5AcG9zdGdyZXNxbC5vcmc+ CkRhdGU6IFRodSwgMTggSmFuIDIwMjQgMTc6NTc6MjAgKzA5MDAKU3ViamVjdDogW1BBVENIIHYz NCA0LzhdIEFkZCBqc29ucGF0aF9leGVjIEFQSXMgdG8gdXNlIGluIFNRTC9KU09OIHF1ZXJ5CiBm dW5jdGlvbnMKClRoaXMgYWRkcyBKc29uUGF0aEV4aXN0cygpLCBKc29uUGF0aFF1ZXJ5KCksIEpz b25QYXRoVmFsdWUoKSB0aGF0CmFyZSB3cmFwcGVycyBvdmVyIGV4ZWN1dGVKc29uUGF0aCgpIHRv IGltcGxlbWVudCBTUUwvSlNPTiBmdW5jdGlvbnMKSlNPTl9FWElTVFMoKSwgSlNPTl9RVUVSWSgp LCBhbmQgSlNPTl9WQUxVRSgpLCByZXNwZWN0aXZlbHkuICBUaG9zZQpmdW5jdGlvbnMgdGhlbXNl bHZlcyB3aWxsIGJlIGFkZGVkIGluIGEgc3Vic2VxdWVudCBjb21taXQgYWxvbmcgd2l0aAp0aGUg bmVjZXNzYXJ5IHBhcnNlci9wbGFubmVyL2V4ZWN1dG9yIHN1cHBvcnQuCgpUaGlzIGFsc28gaW50 cm9kdWNlcyBhIG5ldyBzdHJ1Y3QgSnNvblBhdGhWYXJpYWJsZSBmb3IgdGhlIGV4ZWN1dG9yCmlt cGxlbWVudGF0aW9uIG9mIHRob3NlIGZ1bmN0aW9ucyB0byBiZSBhYmxlIHRvIHBhc3MgdGhlIHZh bHVlcwpvZiB0aGUgdmFyaWFibGVzIHVzZWQgaW4ganNvbnBhdGggdGhhdCBhcmUgc2VwYXJhdGVs eSBldmFsdWF0ZWQKYnkgdGhlIGV4ZWN1dG9yLgoKRGlzY3Vzc2lvbjogaHR0cHM6Ly9wb3N0Z3Iu ZXMvbS9DQStIaXdxRTRYVGRmYjFuVz1Pam95X3RRU1JoWXQtcV9rYjZpNWQ0eGNLeXJMQzFOYmdA bWFpbC5nbWFpbC5jb20KLS0tCiBzcmMvYmFja2VuZC91dGlscy9hZHQvanNvbnBhdGhfZXhlYy5j IHwgMzIyICsrKysrKysrKysrKysrKysrKysrKysrKysrCiBzcmMvaW5jbHVkZS9ub2Rlcy9wcmlt bm9kZXMuaCAgICAgICAgIHwgIDExICsKIHNyYy9pbmNsdWRlL3V0aWxzL2pzb25wYXRoLmggICAg ICAgICAgfCAgMjMgKysKIDMgZmlsZXMgY2hhbmdlZCwgMzU2IGluc2VydGlvbnMoKykKCmRpZmYg LS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9hZHQvanNvbnBhdGhfZXhlYy5jIGIvc3JjL2JhY2tl bmQvdXRpbHMvYWR0L2pzb25wYXRoX2V4ZWMuYwppbmRleCBjMTYyODIxZTY1Li42ZGE2ZTI3ZWU2 IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC91dGlscy9hZHQvanNvbnBhdGhfZXhlYy5jCisrKyBi L3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9qc29ucGF0aF9leGVjLmMKQEAgLTIzNCw2ICsyMzQsMTIg QEAgc3RhdGljIEpzb25QYXRoRXhlY1Jlc3VsdCBhcHBlbmRCb29sUmVzdWx0KEpzb25QYXRoRXhl Y0NvbnRleHQgKmN4dCwKIAkJCQkJCQkJCQkgICBKc29uUGF0aEl0ZW0gKmpzcCwgSnNvblZhbHVl TGlzdCAqZm91bmQsIEpzb25QYXRoQm9vbCByZXMpOwogc3RhdGljIHZvaWQgZ2V0SnNvblBhdGhJ dGVtKEpzb25QYXRoRXhlY0NvbnRleHQgKmN4dCwgSnNvblBhdGhJdGVtICppdGVtLAogCQkJCQkJ CUpzb25iVmFsdWUgKnZhbHVlKTsKK3N0YXRpYyBKc29uYlZhbHVlICpHZXRKc29uUGF0aFZhcih2 b2lkICpjeHQsIGNoYXIgKnZhck5hbWUsIGludCB2YXJOYW1lTGVuLAorCQkJCQkJCQkgIEpzb25i VmFsdWUgKmJhc2VPYmplY3QsIGludCAqYmFzZU9iamVjdElkKTsKK3N0YXRpYyBpbnQgQ291bnRK c29uUGF0aFZhcnModm9pZCAqY3h0KTsKK3N0YXRpYyB2b2lkIEpzb25JdGVtRnJvbURhdHVtKERh dHVtIHZhbCwgT2lkIHR5cGlkLCBpbnQzMiB0eXBtb2QsCisJCQkJCQkJICBKc29uYlZhbHVlICpy ZXMpOworc3RhdGljIHZvaWQgSnNvbmJWYWx1ZUluaXROdW1lcmljRGF0dW0oSnNvbmJWYWx1ZSAq amJ2LCBEYXR1bSBudW0pOwogc3RhdGljIHZvaWQgZ2V0SnNvblBhdGhWYXJpYWJsZShKc29uUGF0 aEV4ZWNDb250ZXh0ICpjeHQsCiAJCQkJCQkJCUpzb25QYXRoSXRlbSAqdmFyaWFibGUsIEpzb25i VmFsdWUgKnZhbHVlKTsKIHN0YXRpYyBpbnQgY291bnRWYXJpYWJsZXNGcm9tSnNvbmIodm9pZCAq dmFyc0pzb25iKTsKQEAgLTIxMzgsNiArMjE0NCwxNTUgQEAgZ2V0SnNvblBhdGhJdGVtKEpzb25Q YXRoRXhlY0NvbnRleHQgKmN4dCwgSnNvblBhdGhJdGVtICppdGVtLAogCX0KIH0KIAorLyoKKyAq IFJldHVybnMgdGhlIGNvbXB1dGVkIHZhbHVlIG9mIGEgSlNPTiBwYXRoIHZhcmlhYmxlIHdpdGgg Z2l2ZW4gbmFtZS4KKyAqLworc3RhdGljIEpzb25iVmFsdWUgKgorR2V0SnNvblBhdGhWYXIodm9p ZCAqY3h0LCBjaGFyICp2YXJOYW1lLCBpbnQgdmFyTmFtZUxlbiwKKwkJCSAgIEpzb25iVmFsdWUg KmJhc2VPYmplY3QsIGludCAqYmFzZU9iamVjdElkKQoreworCUpzb25QYXRoVmFyaWFibGUgKnZh ciA9IE5VTEw7CisJTGlzdAkgICAqdmFycyA9IGN4dDsKKwlMaXN0Q2VsbCAgICpsYzsKKwlKc29u YlZhbHVlICpyZXN1bHQ7CisJaW50CQkJaWQgPSAxOworCisJZm9yZWFjaChsYywgdmFycykKKwl7 CisJCUpzb25QYXRoVmFyaWFibGUgKmN1cnZhciA9IGxmaXJzdChsYyk7CisKKwkJaWYgKCFzdHJu Y21wKGN1cnZhci0+bmFtZSwgdmFyTmFtZSwgdmFyTmFtZUxlbikpCisJCXsKKwkJCXZhciA9IGN1 cnZhcjsKKwkJCWJyZWFrOworCQl9CisKKwkJaWQrKzsKKwl9CisKKwlpZiAodmFyID09IE5VTEwp CisJeworCQkqYmFzZU9iamVjdElkID0gLTE7CisJCXJldHVybiBOVUxMOworCX0KKworCXJlc3Vs dCA9IHBhbGxvYyhzaXplb2YoSnNvbmJWYWx1ZSkpOworCWlmICh2YXItPmlzbnVsbCkKKwl7CisJ CSpiYXNlT2JqZWN0SWQgPSAwOworCQlyZXN1bHQtPnR5cGUgPSBqYnZOdWxsOworCX0KKwllbHNl CisJCUpzb25JdGVtRnJvbURhdHVtKHZhci0+dmFsdWUsIHZhci0+dHlwaWQsIHZhci0+dHlwbW9k LCByZXN1bHQpOworCisJKmJhc2VPYmplY3QgPSAqcmVzdWx0OworCSpiYXNlT2JqZWN0SWQgPSBp ZDsKKworCXJldHVybiByZXN1bHQ7Cit9CisKK3N0YXRpYyBpbnQKK0NvdW50SnNvblBhdGhWYXJz KHZvaWQgKmN4dCkKK3sKKwlMaXN0ICp2YXJzID0gKExpc3QgKikgY3h0OworCisJcmV0dXJuIGxp c3RfbGVuZ3RoKHZhcnMpOworfQorCisKKy8qCisgKiBJbml0aWFsaXplIEpzb25iVmFsdWUgdG8g cGFzcyB0byBqc29ucGF0aCBleGVjdXRvciBmcm9tIGdpdmVuCisgKiBkYXR1bSB2YWx1ZSBvZiB0 aGUgc3BlY2lmaWVkIHR5cGUuCisgKi8KK3N0YXRpYyB2b2lkCitKc29uSXRlbUZyb21EYXR1bShE YXR1bSB2YWwsIE9pZCB0eXBpZCwgaW50MzIgdHlwbW9kLCBKc29uYlZhbHVlICpyZXMpCit7CisJ c3dpdGNoICh0eXBpZCkKKwl7CisJCWNhc2UgQk9PTE9JRDoKKwkJCXJlcy0+dHlwZSA9IGpidkJv b2w7CisJCQlyZXMtPnZhbC5ib29sZWFuID0gRGF0dW1HZXRCb29sKHZhbCk7CisJCQlicmVhazsK KwkJY2FzZSBOVU1FUklDT0lEOgorCQkJSnNvbmJWYWx1ZUluaXROdW1lcmljRGF0dW0ocmVzLCB2 YWwpOworCQkJYnJlYWs7CisJCWNhc2UgSU5UMk9JRDoKKwkJCUpzb25iVmFsdWVJbml0TnVtZXJp Y0RhdHVtKHJlcywgRGlyZWN0RnVuY3Rpb25DYWxsMShpbnQyX251bWVyaWMsIHZhbCkpOworCQkJ YnJlYWs7CisJCWNhc2UgSU5UNE9JRDoKKwkJCUpzb25iVmFsdWVJbml0TnVtZXJpY0RhdHVtKHJl cywgRGlyZWN0RnVuY3Rpb25DYWxsMShpbnQ0X251bWVyaWMsIHZhbCkpOworCQkJYnJlYWs7CisJ CWNhc2UgSU5UOE9JRDoKKwkJCUpzb25iVmFsdWVJbml0TnVtZXJpY0RhdHVtKHJlcywgRGlyZWN0 RnVuY3Rpb25DYWxsMShpbnQ4X251bWVyaWMsIHZhbCkpOworCQkJYnJlYWs7CisJCWNhc2UgRkxP QVQ0T0lEOgorCQkJSnNvbmJWYWx1ZUluaXROdW1lcmljRGF0dW0ocmVzLCBEaXJlY3RGdW5jdGlv bkNhbGwxKGZsb2F0NF9udW1lcmljLCB2YWwpKTsKKwkJCWJyZWFrOworCQljYXNlIEZMT0FUOE9J RDoKKwkJCUpzb25iVmFsdWVJbml0TnVtZXJpY0RhdHVtKHJlcywgRGlyZWN0RnVuY3Rpb25DYWxs MShmbG9hdDhfbnVtZXJpYywgdmFsKSk7CisJCQlicmVhazsKKwkJY2FzZSBURVhUT0lEOgorCQlj YXNlIFZBUkNIQVJPSUQ6CisJCQlyZXMtPnR5cGUgPSBqYnZTdHJpbmc7CisJCQlyZXMtPnZhbC5z dHJpbmcudmFsID0gVkFSREFUQV9BTlkodmFsKTsKKwkJCXJlcy0+dmFsLnN0cmluZy5sZW4gPSBW QVJTSVpFX0FOWV9FWEhEUih2YWwpOworCQkJYnJlYWs7CisJCWNhc2UgREFURU9JRDoKKwkJY2Fz ZSBUSU1FT0lEOgorCQljYXNlIFRJTUVUWk9JRDoKKwkJY2FzZSBUSU1FU1RBTVBPSUQ6CisJCWNh c2UgVElNRVNUQU1QVFpPSUQ6CisJCQlyZXMtPnR5cGUgPSBqYnZEYXRldGltZTsKKwkJCXJlcy0+ dmFsLmRhdGV0aW1lLnZhbHVlID0gdmFsOworCQkJcmVzLT52YWwuZGF0ZXRpbWUudHlwaWQgPSB0 eXBpZDsKKwkJCXJlcy0+dmFsLmRhdGV0aW1lLnR5cG1vZCA9IHR5cG1vZDsKKwkJCXJlcy0+dmFs LmRhdGV0aW1lLnR6ID0gMDsKKwkJCWJyZWFrOworCQljYXNlIEpTT05CT0lEOgorCQkJeworCQkJ CUpzb25iVmFsdWUgKmpidiA9IHJlczsKKwkJCQlKc29uYgkgICAqamIgPSBEYXR1bUdldEpzb25i UCh2YWwpOworCisJCQkJaWYgKEpzb25Db250YWluZXJJc1NjYWxhcigmamItPnJvb3QpKQorCQkJ CXsKKwkJCQkJYm9vbAkJcmVzdWx0IFBHX1VTRURfRk9SX0FTU0VSVFNfT05MWTsKKworCQkJCQly ZXN1bHQgPSBKc29uYkV4dHJhY3RTY2FsYXIoJmpiLT5yb290LCBqYnYpOworCQkJCQlBc3NlcnQo cmVzdWx0KTsKKwkJCQl9CisJCQkJZWxzZQorCQkJCQlKc29uYkluaXRCaW5hcnkoamJ2LCBqYik7 CisJCQkJYnJlYWs7CisJCQl9CisJCWNhc2UgSlNPTk9JRDoKKwkJCXsKKwkJCQl0ZXh0CSAgICp0 eHQgPSBEYXR1bUdldFRleHRQKHZhbCk7CisJCQkJY2hhcgkgICAqc3RyID0gdGV4dF90b19jc3Ry aW5nKHR4dCk7CisJCQkJSnNvbmIJICAgKmpiOworCisJCQkJamIgPSBEYXR1bUdldEpzb25iUChE aXJlY3RGdW5jdGlvbkNhbGwxKGpzb25iX2luLAorCQkJCQkJCQkJCQkJCQlDU3RyaW5nR2V0RGF0 dW0oc3RyKSkpOworCQkJCXBmcmVlKHN0cik7CisKKwkJCQlKc29uSXRlbUZyb21EYXR1bShKc29u YlBHZXREYXR1bShqYiksIEpTT05CT0lELCAtMSwgcmVzKTsKKwkJCQlicmVhazsKKwkJCX0KKwkJ ZGVmYXVsdDoKKwkJCWVyZXBvcnQoRVJST1IsCisJCQkJCWVycmNvZGUoRVJSQ09ERV9JTlZBTElE X1BBUkFNRVRFUl9WQUxVRSksCisJCQkJCWVycm1zZygiY291bGQgbm90IGNvbnZlcnQgdmFsdWUg b2YgdHlwZSAlcyB0byBqc29ucGF0aCIsCisJCQkJCQkgICBmb3JtYXRfdHlwZV9iZSh0eXBpZCkp KTsKKwl9Cit9CisKKy8qIEluaXRpYWxpemUgbnVtZXJpYyB2YWx1ZSBmcm9tIHRoZSBnaXZlbiBk YXR1bSAqLworc3RhdGljIHZvaWQKK0pzb25iVmFsdWVJbml0TnVtZXJpY0RhdHVtKEpzb25iVmFs dWUgKmpidiwgRGF0dW0gbnVtKQoreworCWpidi0+dHlwZSA9IGpidk51bWVyaWM7CisJamJ2LT52 YWwubnVtZXJpYyA9IERhdHVtR2V0TnVtZXJpYyhudW0pOworfQorCiAvKgogICogR2V0IHRoZSB2 YWx1ZSBvZiB2YXJpYWJsZSBwYXNzZWQgdG8ganNvbnBhdGggZXhlY3V0b3IKICAqLwpAQCAtMjg3 NCwzICszMDI5LDE3MCBAQCBjb21wYXJlRGF0ZXRpbWUoRGF0dW0gdmFsMSwgT2lkIHR5cGlkMSwg RGF0dW0gdmFsMiwgT2lkIHR5cGlkMiwKIAogCXJldHVybiBEYXR1bUdldEludDMyKERpcmVjdEZ1 bmN0aW9uQ2FsbDIoY21wZnVuYywgdmFsMSwgdmFsMikpOwogfQorCisvKgorICogRXhlY3V0b3It Y2FsbGFibGUgSlNPTl9FWElTVFMgaW1wbGVtZW50YXRpb24KKyAqCisgKiBSZXR1cm5zIE5VTEwg aW5zdGVhZCBvZiB0aHJvd2luZyBlcnJvcnMgaWYgJ2Vycm9yJyBpcyBub3QgTlVMTCwgc2V0dGlu ZworICogKmVycm9yIHRvIHRydWUuCisgKi8KK2Jvb2wKK0pzb25QYXRoRXhpc3RzKERhdHVtIGpi LCBKc29uUGF0aCAqanAsIGJvb2wgKmVycm9yLCBMaXN0ICp2YXJzKQoreworCUpzb25QYXRoRXhl Y1Jlc3VsdCByZXM7CisKKwlyZXMgPSBleGVjdXRlSnNvblBhdGgoanAsIHZhcnMsCisJCQkJCQkg IEdldEpzb25QYXRoVmFyLCBDb3VudEpzb25QYXRoVmFycywKKwkJCQkJCSAgRGF0dW1HZXRKc29u YlAoamIpLCAhZXJyb3IsIE5VTEwsIHRydWUpOworCisJQXNzZXJ0KGVycm9yIHx8ICFqcGVySXNF cnJvcihyZXMpKTsKKworCWlmIChlcnJvciAmJiBqcGVySXNFcnJvcihyZXMpKQorCQkqZXJyb3Ig PSB0cnVlOworCisJcmV0dXJuIHJlcyA9PSBqcGVyT2s7Cit9CisKKy8qCisgKiBFeGVjdXRvci1j YWxsYWJsZSBKU09OX1FVRVJZIGltcGxlbWVudGF0aW9uCisgKgorICogUmV0dXJucyBOVUxMIGlu c3RlYWQgb2YgdGhyb3dpbmcgZXJyb3JzIGlmICdlcnJvcicgaXMgbm90IE5VTEwsIHNldHRpbmcK KyAqICplcnJvciB0byB0cnVlLiAgKmVtcHR5IGlzIHNldCB0byB0cnVlIGlmIG5vIG1hdGNoIGlz IGZvdW5kLgorICovCitEYXR1bQorSnNvblBhdGhRdWVyeShEYXR1bSBqYiwgSnNvblBhdGggKmpw LCBKc29uV3JhcHBlciB3cmFwcGVyLCBib29sICplbXB0eSwKKwkJCSAgYm9vbCAqZXJyb3IsIExp c3QgKnZhcnMpCit7CisJSnNvbmJWYWx1ZSAqc2luZ2xldG9uOworCWJvb2wJCXdyYXA7CisJSnNv blZhbHVlTGlzdCBmb3VuZCA9IHswfTsKKwlKc29uUGF0aEV4ZWNSZXN1bHQgcmVzOworCWludAkJ CWNvdW50OworCisJcmVzID0gZXhlY3V0ZUpzb25QYXRoKGpwLCB2YXJzLAorCQkJCQkJICBHZXRK c29uUGF0aFZhciwgQ291bnRKc29uUGF0aFZhcnMsCisJCQkJCQkgIERhdHVtR2V0SnNvbmJQKGpi KSwgIWVycm9yLCAmZm91bmQsIHRydWUpOworCUFzc2VydChlcnJvciB8fCAhanBlcklzRXJyb3Io cmVzKSk7CisJaWYgKGVycm9yICYmIGpwZXJJc0Vycm9yKHJlcykpCisJeworCQkqZXJyb3IgPSB0 cnVlOworCQkqZW1wdHkgPSBmYWxzZTsKKwkJcmV0dXJuIChEYXR1bSkgMDsKKwl9CisKKwkvKiBX UkFQIG9yIG5vdD8gKi8KKwljb3VudCA9IEpzb25WYWx1ZUxpc3RMZW5ndGgoJmZvdW5kKTsKKwlz aW5nbGV0b24gPSBjb3VudCA+IDAgPyBKc29uVmFsdWVMaXN0SGVhZCgmZm91bmQpIDogTlVMTDsK KwlpZiAoc2luZ2xldG9uID09IE5VTEwpCisJCXdyYXAgPSBmYWxzZTsKKwllbHNlIGlmICh3cmFw cGVyID09IEpTV19OT05FKQorCQl3cmFwID0gZmFsc2U7CisJZWxzZSBpZiAod3JhcHBlciA9PSBK U1dfVU5DT05ESVRJT05BTCkKKwkJd3JhcCA9IHRydWU7CisJZWxzZSBpZiAod3JhcHBlciA9PSBK U1dfQ09ORElUSU9OQUwpCisJCXdyYXAgPSBjb3VudCA+IDEgfHwKKwkJCUlzQUpzb25iU2NhbGFy KHNpbmdsZXRvbikgfHwKKwkJCShzaW5nbGV0b24tPnR5cGUgPT0gamJ2QmluYXJ5ICYmCisJCQkg SnNvbkNvbnRhaW5lcklzU2NhbGFyKHNpbmdsZXRvbi0+dmFsLmJpbmFyeS5kYXRhKSk7CisJZWxz ZQorCXsKKwkJZWxvZyhFUlJPUiwgInVucmVjb2duaXplZCBqc29uIHdyYXBwZXIgJWQiLCB3cmFw cGVyKTsKKwkJd3JhcCA9IGZhbHNlOworCX0KKworCWlmICh3cmFwKQorCQlyZXR1cm4gSnNvbmJQ R2V0RGF0dW0oSnNvbmJWYWx1ZVRvSnNvbmIod3JhcEl0ZW1zSW5BcnJheSgmZm91bmQpKSk7CisK KwkvKiBObyB3cmFwcGluZyBtZWFucyBvbmx5IG9uZSBpdGVtIGlzIGV4cGVjdGVkLiAqLworCWlm IChjb3VudCA+IDEpCisJeworCQlpZiAoZXJyb3IpCisJCXsKKwkJCSplcnJvciA9IHRydWU7CisJ CQlyZXR1cm4gKERhdHVtKSAwOworCQl9CisKKwkJZXJlcG9ydChFUlJPUiwKKwkJCQkoZXJyY29k ZShFUlJDT0RFX01PUkVfVEhBTl9PTkVfU1FMX0pTT05fSVRFTSksCisJCQkJIGVycm1zZygiSlNP TiBwYXRoIGV4cHJlc3Npb24gaW4gSlNPTl9RVUVSWSBzaG91bGQgcmV0dXJuIHNpbmdsZXRvbiBp dGVtIHdpdGhvdXQgd3JhcHBlciIpLAorCQkJCSBlcnJoaW50KCJVc2UgV0lUSCBXUkFQUEVSIGNs YXVzZSB0byB3cmFwIFNRTC9KU09OIGl0ZW0gc2VxdWVuY2UgaW50byBhcnJheS4iKSkpOworCX0K KworCWlmIChzaW5nbGV0b24pCisJCXJldHVybiBKc29uYlBHZXREYXR1bShKc29uYlZhbHVlVG9K c29uYihzaW5nbGV0b24pKTsKKworCSplbXB0eSA9IHRydWU7CisJcmV0dXJuIFBvaW50ZXJHZXRE YXR1bShOVUxMKTsKK30KKworLyoKKyAqIEV4ZWN1dG9yLWNhbGxhYmxlIEpTT05fVkFMVUUgaW1w bGVtZW50YXRpb24KKyAqCisgKiBSZXR1cm5zIE5VTEwgaW5zdGVhZCBvZiB0aHJvd2luZyBlcnJv cnMgaWYgJ2Vycm9yJyBpcyBub3QgTlVMTCwgc2V0dGluZworICogKmVycm9yIHRvIHRydWUuICAq ZW1wdHkgaXMgc2V0IHRvIHRydWUgaWYgbm8gbWF0Y2ggaXMgZm91bmQuCisgKi8KK0pzb25iVmFs dWUgKgorSnNvblBhdGhWYWx1ZShEYXR1bSBqYiwgSnNvblBhdGggKmpwLCBib29sICplbXB0eSwg Ym9vbCAqZXJyb3IsIExpc3QgKnZhcnMpCit7CisJSnNvbmJWYWx1ZSAqcmVzOworCUpzb25WYWx1 ZUxpc3QgZm91bmQgPSB7MH07CisJSnNvblBhdGhFeGVjUmVzdWx0IGpwZXIgUEdfVVNFRF9GT1Jf QVNTRVJUU19PTkxZOworCWludAkJCWNvdW50OworCisJanBlciA9IGV4ZWN1dGVKc29uUGF0aChq cCwgdmFycywgR2V0SnNvblBhdGhWYXIsIENvdW50SnNvblBhdGhWYXJzLAorCQkJCQkJICAgRGF0 dW1HZXRKc29uYlAoamIpLAorCQkJCQkJICAgIWVycm9yLCAmZm91bmQsIHRydWUpOworCisJQXNz ZXJ0KGVycm9yIHx8ICFqcGVySXNFcnJvcihqcGVyKSk7CisKKwlpZiAoZXJyb3IgJiYganBlcklz RXJyb3IoanBlcikpCisJeworCQkqZXJyb3IgPSB0cnVlOworCQkqZW1wdHkgPSBmYWxzZTsKKwkJ cmV0dXJuIE5VTEw7CisJfQorCisJY291bnQgPSBKc29uVmFsdWVMaXN0TGVuZ3RoKCZmb3VuZCk7 CisKKwkqZW1wdHkgPSAoY291bnQgPT0gMCk7CisKKwlpZiAoKmVtcHR5KQorCQlyZXR1cm4gTlVM TDsKKworCS8qIEpTT05fVkFMVUUgZXhwZWN0cyB0byBnZXQgb25seSBzaW5nbGV0b25zLiAqLwor CWlmIChjb3VudCA+IDEpCisJeworCQlpZiAoZXJyb3IpCisJCXsKKwkJCSplcnJvciA9IHRydWU7 CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCisJCWVyZXBvcnQoRVJST1IsCisJCQkJKGVycmNvZGUo RVJSQ09ERV9NT1JFX1RIQU5fT05FX1NRTF9KU09OX0lURU0pLAorCQkJCSBlcnJtc2coIkpTT04g cGF0aCBleHByZXNzaW9uIGluIEpTT05fVkFMVUUgc2hvdWxkIHJldHVybiBzaW5nbGV0b24gc2Nh bGFyIGl0ZW0iKSkpOworCX0KKworCXJlcyA9IEpzb25WYWx1ZUxpc3RIZWFkKCZmb3VuZCk7CisJ aWYgKHJlcy0+dHlwZSA9PSBqYnZCaW5hcnkgJiYgSnNvbkNvbnRhaW5lcklzU2NhbGFyKHJlcy0+ dmFsLmJpbmFyeS5kYXRhKSkKKwkJSnNvbmJFeHRyYWN0U2NhbGFyKHJlcy0+dmFsLmJpbmFyeS5k YXRhLCByZXMpOworCisJLyogSlNPTl9WQUxVRSBleHBlY3RzIHRvIGdldCBvbmx5IHNjYWxhcnMu ICovCisJaWYgKCFJc0FKc29uYlNjYWxhcihyZXMpKQorCXsKKwkJaWYgKGVycm9yKQorCQl7CisJ CQkqZXJyb3IgPSB0cnVlOworCQkJcmV0dXJuIE5VTEw7CisJCX0KKworCQllcmVwb3J0KEVSUk9S LAorCQkJCShlcnJjb2RlKEVSUkNPREVfU1FMX0pTT05fU0NBTEFSX1JFUVVJUkVEKSwKKwkJCQkg ZXJybXNnKCJKU09OIHBhdGggZXhwcmVzc2lvbiBpbiBKU09OX1ZBTFVFIHNob3VsZCByZXR1cm4g c2luZ2xldG9uIHNjYWxhciBpdGVtIikpKTsKKwl9CisKKwlpZiAocmVzLT50eXBlID09IGpidk51 bGwpCisJCXJldHVybiBOVUxMOworCisJcmV0dXJuIHJlczsKK30KZGlmZiAtLWdpdCBhL3NyYy9p bmNsdWRlL25vZGVzL3ByaW1ub2Rlcy5oIGIvc3JjL2luY2x1ZGUvbm9kZXMvcHJpbW5vZGVzLmgK aW5kZXggNGExNTQ2MDZkMi4uNjEyODlkODEyNCAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvbm9k ZXMvcHJpbW5vZGVzLmgKKysrIGIvc3JjL2luY2x1ZGUvbm9kZXMvcHJpbW5vZGVzLmgKQEAgLTE1 NzYsNiArMTU3NiwxNyBAQCB0eXBlZGVmIGVudW0gSnNvbkZvcm1hdFR5cGUKIAkJCQkJCQkJICog anNvbmIgKi8KIH0gSnNvbkZvcm1hdFR5cGU7CiAKKy8qCisgKiBKc29uV3JhcHBlciAtCisgKgkJ cmVwcmVzZW50YXRpb24gb2YgV1JBUFBFUiBjbGF1c2UgZm9yIEpzb25QYXRoUXVlcnkoKQorICov Cit0eXBlZGVmIGVudW0gSnNvbldyYXBwZXIKK3sKKwlKU1dfTk9ORSwKKwlKU1dfQ09ORElUSU9O QUwsCisJSlNXX1VOQ09ORElUSU9OQUwsCit9IEpzb25XcmFwcGVyOworCiAvKgogICogSnNvbkZv cm1hdCAtCiAgKgkJcmVwcmVzZW50YXRpb24gb2YgSlNPTiBGT1JNQVQgY2xhdXNlCmRpZmYgLS1n aXQgYS9zcmMvaW5jbHVkZS91dGlscy9qc29ucGF0aC5oIGIvc3JjL2luY2x1ZGUvdXRpbHMvanNv bnBhdGguaAppbmRleCA5ZDU1YzI1ZWJjLi42ZWFiZGNmYjc1IDEwMDY0NAotLS0gYS9zcmMvaW5j bHVkZS91dGlscy9qc29ucGF0aC5oCisrKyBiL3NyYy9pbmNsdWRlL3V0aWxzL2pzb25wYXRoLmgK QEAgLTE2LDYgKzE2LDcgQEAKIAogI2luY2x1ZGUgImZtZ3IuaCIKICNpbmNsdWRlICJub2Rlcy9w Z19saXN0LmgiCisjaW5jbHVkZSAibm9kZXMvcHJpbW5vZGVzLmgiCiAjaW5jbHVkZSAidXRpbHMv anNvbmIuaCIKIAogdHlwZWRlZiBzdHJ1Y3QKQEAgLTI2OCw0ICsyNjksMjYgQEAgZXh0ZXJuIGJv b2wganNwQ29udmVydFJlZ2V4RmxhZ3ModWludDMyIHhmbGFncywgaW50ICpyZXN1bHQsCiAJCQkJ CQkJCSBzdHJ1Y3QgTm9kZSAqZXNjb250ZXh0KTsKIAogCisvKgorICogRXZhbHVhdGlvbiBvZiBq c29ucGF0aAorICovCisKKy8qIEV4dGVybmFsIHZhcmlhYmxlIHBhc3NlZCBpbnRvIGpzb25wYXRo LiAqLwordHlwZWRlZiBzdHJ1Y3QgSnNvblBhdGhWYXJpYWJsZQoreworCWNoYXIJICAgKm5hbWU7 CisJT2lkCQkJdHlwaWQ7CisJaW50MzIJCXR5cG1vZDsKKwlEYXR1bQkJdmFsdWU7CisJYm9vbAkJ aXNudWxsOworfSBKc29uUGF0aFZhcmlhYmxlOworCisKKy8qIFNRTC9KU09OIGl0ZW0gKi8KK2V4 dGVybiBib29sIEpzb25QYXRoRXhpc3RzKERhdHVtIGpiLCBKc29uUGF0aCAqcGF0aCwgYm9vbCAq ZXJyb3IsIExpc3QgKnZhcnMpOworZXh0ZXJuIERhdHVtIEpzb25QYXRoUXVlcnkoRGF0dW0gamIs IEpzb25QYXRoICpqcCwgSnNvbldyYXBwZXIgd3JhcHBlciwKKwkJCQkJCSAgIGJvb2wgKmVtcHR5 LCBib29sICplcnJvciwgTGlzdCAqdmFycyk7CitleHRlcm4gSnNvbmJWYWx1ZSAqSnNvblBhdGhW YWx1ZShEYXR1bSBqYiwgSnNvblBhdGggKmpwLCBib29sICplbXB0eSwKKwkJCQkJCQkJIGJvb2wg KmVycm9yLCBMaXN0ICp2YXJzKTsKKwogI2VuZGlmCi0tIAoyLjM1LjMKCg== --00000000000078edb1060f38208c Content-Type: application/octet-stream; name="v34-0002-Add-json_populate_type-with-support-for-soft-err.patch" Content-Disposition: attachment; filename="v34-0002-Add-json_populate_type-with-support-for-soft-err.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lrj7oaon1 RnJvbSBhMmU2ZDY0NDJkOTgyMTI1ZWNjOTEyMWJjOGYzN2Q3MzhiYzdiMTVhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbWl0IExhbmdvdGUgPGFtaXRsYW5AcG9zdGdyZXNxbC5vcmc+ CkRhdGU6IFRodSwgMTggSmFuIDIwMjQgMTY6MTY6NTYgKzA5MDAKU3ViamVjdDogW1BBVENIIHYz NCAyLzhdIEFkZCBqc29uX3BvcHVsYXRlX3R5cGUoKSB3aXRoIHN1cHBvcnQgZm9yIHNvZnQgZXJy b3IKIGhhbmRsaW5nCk1JTUUtVmVyc2lvbjogMS4wCkNvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsg Y2hhcnNldD1VVEYtOApDb250ZW50LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0CgpUaGUgbmV3IGZ1 bmN0aW9uIGlzIGludGVuZGVkIHRvIGV4dHJhY3QgYSB2YWx1ZSBmcm9tIGEgZ2l2ZW4ganNvbmIK dmFsdWUgcGFzc2VkIGluIGFzIGEgRGF0dW0gYW5kIHJldHVybiBhcyBhIERhdHVtIG9mIHRoZSBz cGVjaWZpZWQKdHlwZS4gIEl0cyBpbXBsZW1lbnRhdGlvbiB1c2VzIHRoZSBleGlzdGluZyBwb3B1 bGF0ZV9yZWNvcmRfZmllbGQoKSwKd2hpY2ggaGFzIGJlZW4gbW9kaWZpZWQgaGVyZSB0byBhZGQg c29mdCBoYW5kbGluZyBvZiBlcnJvcnMuCgpUaGUgY2hhbmdlcyBoZXJlIGFyZSBvbmx5IGludGVu ZGVkIHRvIHN1cHByZXNzIGVycm9ycyBpbiB0aGUgZnVuY3Rpb25zCmluIGpzb25mdW5jcy5jLCBi dXQgbm90IHRob3NlIGluIGFueSBleHRlcm5hbCBmdW5jdGlvbnMgdGhhdCB0aGUKZnVuY3Rpb25z IGluIGpzb25mdW5jcy5jIG1heSBpbiB0dXJuIGNhbGwsIHN1Y2ggYXMgdGhvc2UgaW4KYXJyYXlm dW5jcy5jLCBldGMuICBUaGUgYXNzdW1wdGlvbiBpcyB0aGF0IHRoZSB2YXJpb3VzIGNoZWNrcyBp bgpwb3B1bGF0ZV8qIGZ1bmN0aW9ucyBzaG91bGQgZW5zdXJlIHRoYXQgb25seSB2YWx1ZXMgdGhh dCBhcmUKc3RydWN0dXJhbGx5IHZhbGlkIGdldCBwYXNzZWQgdG8gdGhlIGV4dGVybmFsIGZ1bmN0 aW9ucy4KClJldmlld2VkLWJ5OiDDgWx2YXJvIEhlcnJlcmEKUmV2aWV3ZWQtYnk6IEFuZHJlcyBG cmV1bmQKRGlzY3Vzc2lvbjogaHR0cHM6Ly9wb3N0Z3IuZXMvbS9DQStIaXdxRTRYVGRmYjFuVz1P am95X3RRU1JoWXQtcV9rYjZpNWQ0eGNLeXJMQzFOYmdAbWFpbC5nbWFpbC5jb20KLS0tCiBzcmMv YmFja2VuZC91dGlscy9hZHQvanNvbmZ1bmNzLmMgfCAzNzMgKysrKysrKysrKysrKysrKysrKysr KysrLS0tLS0tCiBzcmMvaW5jbHVkZS91dGlscy9qc29uZnVuY3MuaCAgICAgfCAgIDYgKwogMiBm aWxlcyBjaGFuZ2VkLCAzMDIgaW5zZXJ0aW9ucygrKSwgNzcgZGVsZXRpb25zKC0pCgpkaWZmIC0t Z2l0IGEvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L2pzb25mdW5jcy5jIGIvc3JjL2JhY2tlbmQvdXRp bHMvYWR0L2pzb25mdW5jcy5jCmluZGV4IGNhYWFmYjcyYzAuLjg3NTk5NTMwZDEgMTAwNjQ0Ci0t LSBhL3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9qc29uZnVuY3MuYworKysgYi9zcmMvYmFja2VuZC91 dGlscy9hZHQvanNvbmZ1bmNzLmMKQEAgLTI2NSw2ICsyNjUsNyBAQCB0eXBlZGVmIHN0cnVjdCBQ b3B1bGF0ZUFycmF5Q29udGV4dAogCWludAkJICAgKmRpbXM7CQkJLyogZGltZW5zaW9ucyAqLwog CWludAkJICAgKnNpemVzOwkJCS8qIGN1cnJlbnQgZGltZW5zaW9uIGNvdW50ZXJzICovCiAJaW50 CQkJbmRpbXM7CQkJLyogbnVtYmVyIG9mIGRpbWVuc2lvbnMgKi8KKwlOb2RlCSAgICplc2NvbnRl eHQ7CQkvKiBGb3Igc29mdC1lcnJvciBoYW5kbGluZyAqLwogfSBQb3B1bGF0ZUFycmF5Q29udGV4 dDsKIAogLyogc3RhdGUgZm9yIHBvcHVsYXRlX2FycmF5X2pzb24oKSAqLwpAQCAtMzg5LDcgKzM5 MCw4IEBAIHN0YXRpYyBKc29uUGFyc2VFcnJvclR5cGUgZWxlbWVudHNfYXJyYXlfZWxlbWVudF9l bmQodm9pZCAqc3RhdGUsIGJvb2wgaXNudWxsKTsKIHN0YXRpYyBKc29uUGFyc2VFcnJvclR5cGUg ZWxlbWVudHNfc2NhbGFyKHZvaWQgKnN0YXRlLCBjaGFyICp0b2tlbiwgSnNvblRva2VuVHlwZSB0 b2tlbnR5cGUpOwogCiAvKiB0dXJuIGEganNvbiBvYmplY3QgaW50byBhIGhhc2ggdGFibGUgKi8K LXN0YXRpYyBIVEFCICpnZXRfanNvbl9vYmplY3RfYXNfaGFzaChjaGFyICpqc29uLCBpbnQgbGVu LCBjb25zdCBjaGFyICpmdW5jbmFtZSk7CitzdGF0aWMgSFRBQiAqZ2V0X2pzb25fb2JqZWN0X2Fz X2hhc2goY2hhciAqanNvbiwgaW50IGxlbiwgY29uc3QgY2hhciAqZnVuY25hbWUsCisJCQkJCQkJ CQkgTm9kZSAqZXNjb250ZXh0KTsKIAogLyogc2VtYW50aWMgYWN0aW9ucyBmb3IgcG9wdWxhdGVf YXJyYXlfanNvbiAqLwogc3RhdGljIEpzb25QYXJzZUVycm9yVHlwZSBwb3B1bGF0ZV9hcnJheV9v YmplY3Rfc3RhcnQodm9pZCAqX3N0YXRlKTsKQEAgLTQzMSwzNyArNDMzLDQyIEBAIHN0YXRpYyBE YXR1bSBwb3B1bGF0ZV9yZWNvcmRfd29ya2VyKEZ1bmN0aW9uQ2FsbEluZm8gZmNpbmZvLCBjb25z dCBjaGFyICpmdW5jbmFtCiAvKiBoZWxwZXIgZnVuY3Rpb25zIGZvciBwb3B1bGF0ZV9yZWNvcmRb c2V0XSAqLwogc3RhdGljIEhlYXBUdXBsZUhlYWRlciBwb3B1bGF0ZV9yZWNvcmQoVHVwbGVEZXNj IHR1cGRlc2MsIFJlY29yZElPRGF0YSAqKnJlY29yZF9wLAogCQkJCQkJCQkJICAgSGVhcFR1cGxl SGVhZGVyIGRlZmF1bHR2YWwsIE1lbW9yeUNvbnRleHQgbWN4dCwKLQkJCQkJCQkJCSAgIEpzT2Jq ZWN0ICpvYmopOworCQkJCQkJCQkJICAgSnNPYmplY3QgKm9iaiwgTm9kZSAqZXNjb250ZXh0KTsK IHN0YXRpYyB2b2lkIGdldF9yZWNvcmRfdHlwZV9mcm9tX2FyZ3VtZW50KEZ1bmN0aW9uQ2FsbElu Zm8gZmNpbmZvLAogCQkJCQkJCQkJCSAgY29uc3QgY2hhciAqZnVuY25hbWUsCiAJCQkJCQkJCQkJ ICBQb3B1bGF0ZVJlY29yZENhY2hlICpjYWNoZSk7CiBzdGF0aWMgdm9pZCBnZXRfcmVjb3JkX3R5 cGVfZnJvbV9xdWVyeShGdW5jdGlvbkNhbGxJbmZvIGZjaW5mbywKIAkJCQkJCQkJCSAgIGNvbnN0 IGNoYXIgKmZ1bmNuYW1lLAogCQkJCQkJCQkJICAgUG9wdWxhdGVSZWNvcmRDYWNoZSAqY2FjaGUp Owotc3RhdGljIHZvaWQgSnNWYWx1ZVRvSnNPYmplY3QoSnNWYWx1ZSAqanN2LCBKc09iamVjdCAq anNvKTsKK3N0YXRpYyBib29sIEpzVmFsdWVUb0pzT2JqZWN0KEpzVmFsdWUgKmpzdiwgSnNPYmpl Y3QgKmpzbywgTm9kZSAqZXNjb250ZXh0KTsKIHN0YXRpYyBEYXR1bSBwb3B1bGF0ZV9jb21wb3Np dGUoQ29tcG9zaXRlSU9EYXRhICppbywgT2lkIHR5cGlkLAogCQkJCQkJCQljb25zdCBjaGFyICpj b2xuYW1lLCBNZW1vcnlDb250ZXh0IG1jeHQsCi0JCQkJCQkJCUhlYXBUdXBsZUhlYWRlciBkZWZh dWx0dmFsLCBKc1ZhbHVlICpqc3YsIGJvb2wgaXNudWxsKTsKLXN0YXRpYyBEYXR1bSBwb3B1bGF0 ZV9zY2FsYXIoU2NhbGFySU9EYXRhICppbywgT2lkIHR5cGlkLCBpbnQzMiB0eXBtb2QsIEpzVmFs dWUgKmpzdik7CisJCQkJCQkJCUhlYXBUdXBsZUhlYWRlciBkZWZhdWx0dmFsLCBKc1ZhbHVlICpq c3YsIGJvb2wgKmlzbnVsbCwKKwkJCQkJCQkJTm9kZSAqZXNjb250ZXh0KTsKK3N0YXRpYyBEYXR1 bSBwb3B1bGF0ZV9zY2FsYXIoU2NhbGFySU9EYXRhICppbywgT2lkIHR5cGlkLCBpbnQzMiB0eXBt b2QsIEpzVmFsdWUgKmpzdiwKKwkJCQkJCQkgYm9vbCAqaXNudWxsLCBOb2RlICplc2NvbnRleHQp Owogc3RhdGljIHZvaWQgcHJlcGFyZV9jb2x1bW5fY2FjaGUoQ29sdW1uSU9EYXRhICpjb2x1bW4s IE9pZCB0eXBpZCwgaW50MzIgdHlwbW9kLAogCQkJCQkJCQkgTWVtb3J5Q29udGV4dCBtY3h0LCBi b29sIG5lZWRfc2NhbGFyKTsKIHN0YXRpYyBEYXR1bSBwb3B1bGF0ZV9yZWNvcmRfZmllbGQoQ29s dW1uSU9EYXRhICpjb2wsIE9pZCB0eXBpZCwgaW50MzIgdHlwbW9kLAogCQkJCQkJCQkgICBjb25z dCBjaGFyICpjb2xuYW1lLCBNZW1vcnlDb250ZXh0IG1jeHQsIERhdHVtIGRlZmF1bHR2YWwsCi0J CQkJCQkJCSAgIEpzVmFsdWUgKmpzdiwgYm9vbCAqaXNudWxsKTsKKwkJCQkJCQkJICAgSnNWYWx1 ZSAqanN2LCBib29sICppc251bGwsIE5vZGUgKmVzY29udGV4dCk7CiBzdGF0aWMgUmVjb3JkSU9E YXRhICphbGxvY2F0ZV9yZWNvcmRfaW5mbyhNZW1vcnlDb250ZXh0IG1jeHQsIGludCBuY29sdW1u cyk7CiBzdGF0aWMgYm9vbCBKc09iamVjdEdldEZpZWxkKEpzT2JqZWN0ICpvYmosIGNoYXIgKmZp ZWxkLCBKc1ZhbHVlICpqc3YpOwogc3RhdGljIHZvaWQgcG9wdWxhdGVfcmVjb3Jkc2V0X3JlY29y ZChQb3B1bGF0ZVJlY29yZHNldFN0YXRlICpzdGF0ZSwgSnNPYmplY3QgKm9iaik7Ci1zdGF0aWMg dm9pZCBwb3B1bGF0ZV9hcnJheV9qc29uKFBvcHVsYXRlQXJyYXlDb250ZXh0ICpjdHgsIGNoYXIg Kmpzb24sIGludCBsZW4pOwotc3RhdGljIHZvaWQgcG9wdWxhdGVfYXJyYXlfZGltX2pzb25iKFBv cHVsYXRlQXJyYXlDb250ZXh0ICpjdHgsIEpzb25iVmFsdWUgKmpidiwKK3N0YXRpYyBib29sIHBv cHVsYXRlX2FycmF5X2pzb24oUG9wdWxhdGVBcnJheUNvbnRleHQgKmN0eCwgY2hhciAqanNvbiwg aW50IGxlbik7CitzdGF0aWMgYm9vbCBwb3B1bGF0ZV9hcnJheV9kaW1fanNvbmIoUG9wdWxhdGVB cnJheUNvbnRleHQgKmN0eCwgSnNvbmJWYWx1ZSAqamJ2LAogCQkJCQkJCQkJIGludCBuZGltKTsK IHN0YXRpYyB2b2lkIHBvcHVsYXRlX2FycmF5X3JlcG9ydF9leHBlY3RlZF9hcnJheShQb3B1bGF0 ZUFycmF5Q29udGV4dCAqY3R4LCBpbnQgbmRpbSk7Ci1zdGF0aWMgdm9pZCBwb3B1bGF0ZV9hcnJh eV9hc3NpZ25fbmRpbXMoUG9wdWxhdGVBcnJheUNvbnRleHQgKmN0eCwgaW50IG5kaW1zKTsKLXN0 YXRpYyB2b2lkIHBvcHVsYXRlX2FycmF5X2NoZWNrX2RpbWVuc2lvbihQb3B1bGF0ZUFycmF5Q29u dGV4dCAqY3R4LCBpbnQgbmRpbSk7Ci1zdGF0aWMgdm9pZCBwb3B1bGF0ZV9hcnJheV9lbGVtZW50 KFBvcHVsYXRlQXJyYXlDb250ZXh0ICpjdHgsIGludCBuZGltLCBKc1ZhbHVlICpqc3YpOworc3Rh dGljIGJvb2wgcG9wdWxhdGVfYXJyYXlfYXNzaWduX25kaW1zKFBvcHVsYXRlQXJyYXlDb250ZXh0 ICpjdHgsIGludCBuZGltcyk7CitzdGF0aWMgYm9vbCBwb3B1bGF0ZV9hcnJheV9jaGVja19kaW1l bnNpb24oUG9wdWxhdGVBcnJheUNvbnRleHQgKmN0eCwgaW50IG5kaW0pOworc3RhdGljIGJvb2wg cG9wdWxhdGVfYXJyYXlfZWxlbWVudChQb3B1bGF0ZUFycmF5Q29udGV4dCAqY3R4LCBpbnQgbmRp bSwgSnNWYWx1ZSAqanN2KTsKIHN0YXRpYyBEYXR1bSBwb3B1bGF0ZV9hcnJheShBcnJheUlPRGF0 YSAqYWlvLCBjb25zdCBjaGFyICpjb2xuYW1lLAotCQkJCQkJCU1lbW9yeUNvbnRleHQgbWN4dCwg SnNWYWx1ZSAqanN2KTsKKwkJCQkJCQlNZW1vcnlDb250ZXh0IG1jeHQsIEpzVmFsdWUgKmpzdiwK KwkJCQkJCQlib29sICppc251bGwsCisJCQkJCQkJTm9kZSAqZXNjb250ZXh0KTsKIHN0YXRpYyBE YXR1bSBwb3B1bGF0ZV9kb21haW4oRG9tYWluSU9EYXRhICppbywgT2lkIHR5cGlkLCBjb25zdCBj aGFyICpjb2xuYW1lLAotCQkJCQkJCSBNZW1vcnlDb250ZXh0IG1jeHQsIEpzVmFsdWUgKmpzdiwg Ym9vbCBpc251bGwpOworCQkJCQkJCSBNZW1vcnlDb250ZXh0IG1jeHQsIEpzVmFsdWUgKmpzdiwg Ym9vbCBpc251bGwsCisJCQkJCQkJIE5vZGUgKmVzY29udGV4dCk7CiAKIC8qIGZ1bmN0aW9ucyBz dXBwb3J0aW5nIGpzb25iX2RlbGV0ZSwganNvbmJfc2V0IGFuZCBqc29uYl9jb25jYXQgKi8KIHN0 YXRpYyBKc29uYlZhbHVlICpJdGVyYXRvckNvbmNhdChKc29uYkl0ZXJhdG9yICoqaXQxLCBKc29u Ykl0ZXJhdG9yICoqaXQyLApAQCAtMjQ4NCwxNCArMjQ5MSwxNSBAQCBwb3B1bGF0ZV9hcnJheV9y ZXBvcnRfZXhwZWN0ZWRfYXJyYXkoUG9wdWxhdGVBcnJheUNvbnRleHQgKmN0eCwgaW50IG5kaW0p CiAJaWYgKG5kaW0gPD0gMCkKIAl7CiAJCWlmIChjdHgtPmNvbG5hbWUpCi0JCQllcmVwb3J0KEVS Uk9SLAorCQkJZXJyc2F2ZShjdHgtPmVzY29udGV4dCwKIAkJCQkJKGVycmNvZGUoRVJSQ09ERV9J TlZBTElEX1RFWFRfUkVQUkVTRU5UQVRJT04pLAogCQkJCQkgZXJybXNnKCJleHBlY3RlZCBKU09O IGFycmF5IiksCiAJCQkJCSBlcnJoaW50KCJTZWUgdGhlIHZhbHVlIG9mIGtleSBcIiVzXCIuIiwg Y3R4LT5jb2xuYW1lKSkpOwogCQllbHNlCi0JCQllcmVwb3J0KEVSUk9SLAorCQkJZXJyc2F2ZShj dHgtPmVzY29udGV4dCwKIAkJCQkJKGVycmNvZGUoRVJSQ09ERV9JTlZBTElEX1RFWFRfUkVQUkVT RU5UQVRJT04pLAogCQkJCQkgZXJybXNnKCJleHBlY3RlZCBKU09OIGFycmF5IikpKTsKKwkJcmV0 dXJuOwogCX0KIAllbHNlCiAJewpAQCAtMjUwNiwyMiArMjUxNCwyOCBAQCBwb3B1bGF0ZV9hcnJh eV9yZXBvcnRfZXhwZWN0ZWRfYXJyYXkoUG9wdWxhdGVBcnJheUNvbnRleHQgKmN0eCwgaW50IG5k aW0pCiAJCQlhcHBlbmRTdHJpbmdJbmZvKCZpbmRpY2VzLCAiWyVkXSIsIGN0eC0+c2l6ZXNbaV0p OwogCiAJCWlmIChjdHgtPmNvbG5hbWUpCi0JCQllcmVwb3J0KEVSUk9SLAorCQkJZXJyc2F2ZShj dHgtPmVzY29udGV4dCwKIAkJCQkJKGVycmNvZGUoRVJSQ09ERV9JTlZBTElEX1RFWFRfUkVQUkVT RU5UQVRJT04pLAogCQkJCQkgZXJybXNnKCJleHBlY3RlZCBKU09OIGFycmF5IiksCiAJCQkJCSBl cnJoaW50KCJTZWUgdGhlIGFycmF5IGVsZW1lbnQgJXMgb2Yga2V5IFwiJXNcIi4iLAogCQkJCQkJ CSBpbmRpY2VzLmRhdGEsIGN0eC0+Y29sbmFtZSkpKTsKIAkJZWxzZQotCQkJZXJlcG9ydChFUlJP UiwKKwkJCWVycnNhdmUoY3R4LT5lc2NvbnRleHQsCiAJCQkJCShlcnJjb2RlKEVSUkNPREVfSU5W QUxJRF9URVhUX1JFUFJFU0VOVEFUSU9OKSwKIAkJCQkJIGVycm1zZygiZXhwZWN0ZWQgSlNPTiBh cnJheSIpLAogCQkJCQkgZXJyaGludCgiU2VlIHRoZSBhcnJheSBlbGVtZW50ICVzLiIsCiAJCQkJ CQkJIGluZGljZXMuZGF0YSkpKTsKKwkJcmV0dXJuOwogCX0KIH0KIAotLyogc2V0IHRoZSBudW1i ZXIgb2YgZGltZW5zaW9ucyBvZiB0aGUgcG9wdWxhdGVkIGFycmF5IHdoZW4gaXQgYmVjb21lcyBr bm93biAqLwotc3RhdGljIHZvaWQKKy8qCisgKiBWYWxpZGF0ZSBhbmQgc2V0IG5kaW1zIGZvciBw b3B1bGF0aW5nIGFuIGFycmF5IHdpdGggc29tZQorICogcG9wdWxhdGVfYXJyYXlfKigpIGZ1bmN0 aW9uLgorICoKKyAqIFJldHVybnMgZmFsc2UgaWYgdGhlIGlucHV0IChuZGltcykgaXMgZXJyb25l b3VzLgorICovCitzdGF0aWMgYm9vbAogcG9wdWxhdGVfYXJyYXlfYXNzaWduX25kaW1zKFBvcHVs YXRlQXJyYXlDb250ZXh0ICpjdHgsIGludCBuZGltcykKIHsKIAlpbnQJCQlpOwpAQCAtMjUyOSw3 ICsyNTQzLDEyIEBAIHBvcHVsYXRlX2FycmF5X2Fzc2lnbl9uZGltcyhQb3B1bGF0ZUFycmF5Q29u dGV4dCAqY3R4LCBpbnQgbmRpbXMpCiAJQXNzZXJ0KGN0eC0+bmRpbXMgPD0gMCk7CiAKIAlpZiAo bmRpbXMgPD0gMCkKKwl7CiAJCXBvcHVsYXRlX2FycmF5X3JlcG9ydF9leHBlY3RlZF9hcnJheShj dHgsIG5kaW1zKTsKKwkJLyogR2V0dGluZyBoZXJlIG1lYW5zIHRoZSBlcnJvciB3YXMgcmVwb3J0 ZWQgc29mdGx5LiAqLworCQlBc3NlcnQoU09GVF9FUlJPUl9PQ0NVUlJFRChjdHgtPmVzY29udGV4 dCkpOworCQlyZXR1cm4gZmFsc2U7CisJfQogCiAJY3R4LT5uZGltcyA9IG5kaW1zOwogCWN0eC0+ ZGltcyA9IHBhbGxvYyhzaXplb2YoaW50KSAqIG5kaW1zKTsKQEAgLTI1MzcsMTAgKzI1NTYsMTYg QEAgcG9wdWxhdGVfYXJyYXlfYXNzaWduX25kaW1zKFBvcHVsYXRlQXJyYXlDb250ZXh0ICpjdHgs IGludCBuZGltcykKIAogCWZvciAoaSA9IDA7IGkgPCBuZGltczsgaSsrKQogCQljdHgtPmRpbXNb aV0gPSAtMTsJCS8qIGRpbWVuc2lvbnMgYXJlIHVua25vd24geWV0ICovCisKKwlyZXR1cm4gdHJ1 ZTsKIH0KIAotLyogY2hlY2sgdGhlIHBvcHVsYXRlZCBzdWJhcnJheSBkaW1lbnNpb24gKi8KLXN0 YXRpYyB2b2lkCisvKgorICogQ2hlY2sgdGhlIHBvcHVsYXRlZCBzdWJhcnJheSBkaW1lbnNpb24K KyAqCisgKiBSZXR1cm5zIGZhbHNlIGlmIHRoZSBpbnB1dCAobmRpbXMpIGlzIGVycm9uZW91cy4K KyAqLworc3RhdGljIGJvb2wKIHBvcHVsYXRlX2FycmF5X2NoZWNrX2RpbWVuc2lvbihQb3B1bGF0 ZUFycmF5Q29udGV4dCAqY3R4LCBpbnQgbmRpbSkKIHsKIAlpbnQJCQlkaW0gPSBjdHgtPnNpemVz W25kaW1dOyAvKiBjdXJyZW50IGRpbWVuc2lvbiBjb3VudGVyICovCkBAIC0yNTQ4LDIxICsyNTcz LDMxIEBAIHBvcHVsYXRlX2FycmF5X2NoZWNrX2RpbWVuc2lvbihQb3B1bGF0ZUFycmF5Q29udGV4 dCAqY3R4LCBpbnQgbmRpbSkKIAlpZiAoY3R4LT5kaW1zW25kaW1dID09IC0xKQogCQljdHgtPmRp bXNbbmRpbV0gPSBkaW07CS8qIGFzc2lnbiBkaW1lbnNpb24gaWYgbm90IHlldCBrbm93biAqLwog CWVsc2UgaWYgKGN0eC0+ZGltc1tuZGltXSAhPSBkaW0pCi0JCWVyZXBvcnQoRVJST1IsCisJCWVy cnNhdmUoY3R4LT5lc2NvbnRleHQsCiAJCQkJKGVycmNvZGUoRVJSQ09ERV9JTlZBTElEX1RFWFRf UkVQUkVTRU5UQVRJT04pLAogCQkJCSBlcnJtc2coIm1hbGZvcm1lZCBKU09OIGFycmF5IiksCiAJ CQkJIGVycmRldGFpbCgiTXVsdGlkaW1lbnNpb25hbCBhcnJheXMgbXVzdCBoYXZlICIKIAkJCQkJ CSAgICJzdWItYXJyYXlzIHdpdGggbWF0Y2hpbmcgZGltZW5zaW9ucy4iKSkpOwogCisJLyogTm90 aGluZyB0byBkbyBvbiBhbiBlcnJvci4gKi8KKwlpZiAoU09GVF9FUlJPUl9PQ0NVUlJFRChjdHgt PmVzY29udGV4dCkpCisJCXJldHVybiBmYWxzZTsKKwogCS8qIHJlc2V0IHRoZSBjdXJyZW50IGFy cmF5IGRpbWVuc2lvbiBzaXplIGNvdW50ZXIgKi8KIAljdHgtPnNpemVzW25kaW1dID0gMDsKIAog CS8qIGluY3JlbWVudCB0aGUgcGFyZW50IGRpbWVuc2lvbiBjb3VudGVyIGlmIGl0IGlzIGEgbmVz dGVkIHN1Yi1hcnJheSAqLwogCWlmIChuZGltID4gMCkKIAkJY3R4LT5zaXplc1tuZGltIC0gMV0r KzsKKworCXJldHVybiB0cnVlOwogfQogCi1zdGF0aWMgdm9pZAorLyoKKyAqIFJldHVybnMgdHJ1 ZSBpZiB0aGUgYXJyYXkgZWxlbWVudCB2YWx1ZSB3YXMgc3VjY2Vzc2Z1bGx5IGV4dHJhY3RlZCBm cm9tIGpzdgorICogYW5kIGFkZGVkIHRvIGN0eC0+YXN0YXRlLiAgRmFsc2UgaWYgYW4gZXJyb3Ig b2NjdXJyZWQgd2hlbiBkb2luZyBzby4KKyAqLworc3RhdGljIGJvb2wKIHBvcHVsYXRlX2FycmF5 X2VsZW1lbnQoUG9wdWxhdGVBcnJheUNvbnRleHQgKmN0eCwgaW50IG5kaW0sIEpzVmFsdWUgKmpz dikKIHsKIAlEYXR1bQkJZWxlbWVudDsKQEAgLTI1NzMsMTMgKzI2MDgsMTggQEAgcG9wdWxhdGVf YXJyYXlfZWxlbWVudChQb3B1bGF0ZUFycmF5Q29udGV4dCAqY3R4LCBpbnQgbmRpbSwgSnNWYWx1 ZSAqanN2KQogCQkJCQkJCQkJY3R4LT5haW8tPmVsZW1lbnRfdHlwZSwKIAkJCQkJCQkJCWN0eC0+ YWlvLT5lbGVtZW50X3R5cG1vZCwKIAkJCQkJCQkJCU5VTEwsIGN0eC0+bWN4dCwgUG9pbnRlckdl dERhdHVtKE5VTEwpLAotCQkJCQkJCQkJanN2LCAmZWxlbWVudF9pc251bGwpOworCQkJCQkJCQkJ anN2LCAmZWxlbWVudF9pc251bGwsIGN0eC0+ZXNjb250ZXh0KTsKKwkvKiBOb3RoaW5nIHRvIGRv IG9uIGFuIGVycm9yLiAqLworCWlmIChTT0ZUX0VSUk9SX09DQ1VSUkVEKGN0eC0+ZXNjb250ZXh0 KSkKKwkJcmV0dXJuIGZhbHNlOwogCiAJYWNjdW1BcnJheVJlc3VsdChjdHgtPmFzdGF0ZSwgZWxl bWVudCwgZWxlbWVudF9pc251bGwsCiAJCQkJCSBjdHgtPmFpby0+ZWxlbWVudF90eXBlLCBjdHgt PmFjeHQpOwogCiAJQXNzZXJ0KG5kaW0gPiAwKTsKIAljdHgtPnNpemVzW25kaW0gLSAxXSsrOwkJ LyogaW5jcmVtZW50IGN1cnJlbnQgZGltZW5zaW9uIGNvdW50ZXIgKi8KKworCXJldHVybiB0cnVl OwogfQogCiAvKiBqc29uIG9iamVjdCBzdGFydCBoYW5kbGVyIGZvciBwb3B1bGF0ZV9hcnJheV9q c29uKCkgKi8KQEAgLTI1OTAsOSArMjYzMCwxNyBAQCBwb3B1bGF0ZV9hcnJheV9vYmplY3Rfc3Rh cnQodm9pZCAqX3N0YXRlKQogCWludAkJCW5kaW0gPSBzdGF0ZS0+bGV4LT5sZXhfbGV2ZWw7CiAK IAlpZiAoc3RhdGUtPmN0eC0+bmRpbXMgPD0gMCkKLQkJcG9wdWxhdGVfYXJyYXlfYXNzaWduX25k aW1zKHN0YXRlLT5jdHgsIG5kaW0pOworCXsKKwkJaWYgKCFwb3B1bGF0ZV9hcnJheV9hc3NpZ25f bmRpbXMoc3RhdGUtPmN0eCwgbmRpbSkpCisJCQlyZXR1cm4gSlNPTl9TRU1fQUNUSU9OX0ZBSUxF RDsKKwl9CiAJZWxzZSBpZiAobmRpbSA8IHN0YXRlLT5jdHgtPm5kaW1zKQorCXsKIAkJcG9wdWxh dGVfYXJyYXlfcmVwb3J0X2V4cGVjdGVkX2FycmF5KHN0YXRlLT5jdHgsIG5kaW0pOworCQkvKiBH ZXR0aW5nIGhlcmUgbWVhbnMgdGhlIGVycm9yIHdhcyByZXBvcnRlZCBzb2Z0bHkuICovCisJCUFz c2VydChTT0ZUX0VSUk9SX09DQ1VSUkVEKHN0YXRlLT5jdHgtPmVzY29udGV4dCkpOworCQlyZXR1 cm4gSlNPTl9TRU1fQUNUSU9OX0ZBSUxFRDsKKwl9CiAKIAlyZXR1cm4gSlNPTl9TVUNDRVNTOwog fQpAQCAtMjYwNiwxMCArMjY1NCwxNyBAQCBwb3B1bGF0ZV9hcnJheV9hcnJheV9lbmQodm9pZCAq X3N0YXRlKQogCWludAkJCW5kaW0gPSBzdGF0ZS0+bGV4LT5sZXhfbGV2ZWw7CiAKIAlpZiAoY3R4 LT5uZGltcyA8PSAwKQotCQlwb3B1bGF0ZV9hcnJheV9hc3NpZ25fbmRpbXMoY3R4LCBuZGltICsg MSk7CisJeworCQlpZiAoIXBvcHVsYXRlX2FycmF5X2Fzc2lnbl9uZGltcyhjdHgsIG5kaW0gKyAx KSkKKwkJCXJldHVybiBKU09OX1NFTV9BQ1RJT05fRkFJTEVEOworCX0KIAogCWlmIChuZGltIDwg Y3R4LT5uZGltcykKLQkJcG9wdWxhdGVfYXJyYXlfY2hlY2tfZGltZW5zaW9uKGN0eCwgbmRpbSk7 CisJeworCQkvKiBSZXBvcnQgaWYgYW4gZXJyb3Igb2NjdXJyZWQuICovCisJCWlmICghcG9wdWxh dGVfYXJyYXlfY2hlY2tfZGltZW5zaW9uKGN0eCwgbmRpbSkpCisJCQlyZXR1cm4gSlNPTl9TRU1f QUNUSU9OX0ZBSUxFRDsKKwl9CiAKIAlyZXR1cm4gSlNPTl9TVUNDRVNTOwogfQpAQCAtMjY2Nyw3 ICsyNzIyLDkgQEAgcG9wdWxhdGVfYXJyYXlfZWxlbWVudF9lbmQodm9pZCAqX3N0YXRlLCBib29s IGlzbnVsbCkKIAkJCQkJCQkJc3RhdGUtPmVsZW1lbnRfc3RhcnQpICogc2l6ZW9mKGNoYXIpOwog CQl9CiAKLQkJcG9wdWxhdGVfYXJyYXlfZWxlbWVudChjdHgsIG5kaW0sICZqc3YpOworCQkvKiBS ZXBvcnQgaWYgYW4gZXJyb3Igb2NjdXJyZWQuICovCisJCWlmICghcG9wdWxhdGVfYXJyYXlfZWxl bWVudChjdHgsIG5kaW0sICZqc3YpKQorCQkJcmV0dXJuIEpTT05fU0VNX0FDVElPTl9GQUlMRUQ7 CiAJfQogCiAJcmV0dXJuIEpTT05fU1VDQ0VTUzsKQEAgLTI2ODIsOSArMjczOSwxNyBAQCBwb3B1 bGF0ZV9hcnJheV9zY2FsYXIodm9pZCAqX3N0YXRlLCBjaGFyICp0b2tlbiwgSnNvblRva2VuVHlw ZSB0b2tlbnR5cGUpCiAJaW50CQkJbmRpbSA9IHN0YXRlLT5sZXgtPmxleF9sZXZlbDsKIAogCWlm IChjdHgtPm5kaW1zIDw9IDApCi0JCXBvcHVsYXRlX2FycmF5X2Fzc2lnbl9uZGltcyhjdHgsIG5k aW0pOworCXsKKwkJaWYgKCFwb3B1bGF0ZV9hcnJheV9hc3NpZ25fbmRpbXMoY3R4LCBuZGltKSkK KwkJCXJldHVybiBKU09OX1NFTV9BQ1RJT05fRkFJTEVEOworCX0KIAllbHNlIGlmIChuZGltIDwg Y3R4LT5uZGltcykKKwl7CiAJCXBvcHVsYXRlX2FycmF5X3JlcG9ydF9leHBlY3RlZF9hcnJheShj dHgsIG5kaW0pOworCQkvKiBHZXR0aW5nIGhlcmUgbWVhbnMgdGhlIGVycm9yIHdhcyByZXBvcnRl ZCBzb2Z0bHkuICovCisJCUFzc2VydChTT0ZUX0VSUk9SX09DQ1VSUkVEKGN0eC0+ZXNjb250ZXh0 KSk7CisJCXJldHVybiBKU09OX1NFTV9BQ1RJT05fRkFJTEVEOworCX0KIAogCWlmIChuZGltID09 IGN0eC0+bmRpbXMpCiAJewpAQCAtMjY5Nyw4ICsyNzYyLDEyIEBAIHBvcHVsYXRlX2FycmF5X3Nj YWxhcih2b2lkICpfc3RhdGUsIGNoYXIgKnRva2VuLCBKc29uVG9rZW5UeXBlIHRva2VudHlwZSkK IAlyZXR1cm4gSlNPTl9TVUNDRVNTOwogfQogCi0vKiBwYXJzZSBhIGpzb24gYXJyYXkgYW5kIHBv cHVsYXRlIGFycmF5ICovCi1zdGF0aWMgdm9pZAorLyoKKyAqIFBhcnNlIGEganNvbiBhcnJheSBh bmQgcG9wdWxhdGUgYXJyYXkKKyAqCisgKiBSZXR1cm5zIGZhbHNlIGlmIGFuIGVycm9yIG9jY3Vy cyB3aGVuIHBhcnNpbmcuCisgKi8KK3N0YXRpYyBib29sCiBwb3B1bGF0ZV9hcnJheV9qc29uKFBv cHVsYXRlQXJyYXlDb250ZXh0ICpjdHgsIGNoYXIgKmpzb24sIGludCBsZW4pCiB7CiAJUG9wdWxh dGVBcnJheVN0YXRlIHN0YXRlOwpAQCAtMjcxNiwxOSArMjc4NSwyNSBAQCBwb3B1bGF0ZV9hcnJh eV9qc29uKFBvcHVsYXRlQXJyYXlDb250ZXh0ICpjdHgsIGNoYXIgKmpzb24sIGludCBsZW4pCiAJ c2VtLmFycmF5X2VsZW1lbnRfZW5kID0gcG9wdWxhdGVfYXJyYXlfZWxlbWVudF9lbmQ7CiAJc2Vt LnNjYWxhciA9IHBvcHVsYXRlX2FycmF5X3NjYWxhcjsKIAotCXBnX3BhcnNlX2pzb25fb3JfZXJl cG9ydChzdGF0ZS5sZXgsICZzZW0pOwotCi0JLyogbnVtYmVyIG9mIGRpbWVuc2lvbnMgc2hvdWxk IGJlIGFscmVhZHkga25vd24gKi8KLQlBc3NlcnQoY3R4LT5uZGltcyA+IDAgJiYgY3R4LT5kaW1z KTsKKwlpZiAocGdfcGFyc2VfanNvbl9vcl9lcnJzYXZlKHN0YXRlLmxleCwgJnNlbSwgY3R4LT5l c2NvbnRleHQpKQorCXsKKwkJLyogbnVtYmVyIG9mIGRpbWVuc2lvbnMgc2hvdWxkIGJlIGFscmVh ZHkga25vd24gKi8KKwkJQXNzZXJ0KGN0eC0+bmRpbXMgPiAwICYmIGN0eC0+ZGltcyk7CisJfQog CiAJZnJlZUpzb25MZXhDb250ZXh0KHN0YXRlLmxleCk7CisKKwlyZXR1cm4gIVNPRlRfRVJST1Jf T0NDVVJSRUQoY3R4LT5lc2NvbnRleHQpOwogfQogCiAvKgogICogcG9wdWxhdGVfYXJyYXlfZGlt X2pzb25iKCkgLS0gSXRlcmF0ZSByZWN1cnNpdmVseSB0aHJvdWdoIGpzb25iIHN1Yi1hcnJheQog ICoJCWVsZW1lbnRzIGFuZCBhY2N1bXVsYXRlIHJlc3VsdCB1c2luZyBnaXZlbiBBcnJheUJ1aWxk U3RhdGUuCisgKgorICogUmV0dXJucyBmYWxzZSBpZiB3ZSByZXR1cm4gcGFydHdheSB0aHJvdWdo IGJlY2F1c2Ugb2YgYW4gZXJyb3IgaW4gYQorICogc3Vicm91dGluZS4KICAqLwotc3RhdGljIHZv aWQKK3N0YXRpYyBib29sCiBwb3B1bGF0ZV9hcnJheV9kaW1fanNvbmIoUG9wdWxhdGVBcnJheUNv bnRleHQgKmN0eCwgLyogY29udGV4dCAqLwogCQkJCQkJIEpzb25iVmFsdWUgKmpidiwJLyoganNv bmIgc3ViLWFycmF5ICovCiAJCQkJCQkgaW50IG5kaW0pCS8qIGN1cnJlbnQgZGltZW5zaW9uICov CkBAIC0yNzQxLDEwICsyODE2LDE0IEBAIHBvcHVsYXRlX2FycmF5X2RpbV9qc29uYihQb3B1bGF0 ZUFycmF5Q29udGV4dCAqY3R4LCAvKiBjb250ZXh0ICovCiAKIAljaGVja19zdGFja19kZXB0aCgp OwogCi0JaWYgKGpidi0+dHlwZSAhPSBqYnZCaW5hcnkgfHwgIUpzb25Db250YWluZXJJc0FycmF5 KGpiYykpCisJaWYgKGpidi0+dHlwZSAhPSBqYnZCaW5hcnkgfHwgIUpzb25Db250YWluZXJJc0Fy cmF5KGpiYykgfHwKKwkJSnNvbkNvbnRhaW5lcklzU2NhbGFyKGpiYykpCisJewogCQlwb3B1bGF0 ZV9hcnJheV9yZXBvcnRfZXhwZWN0ZWRfYXJyYXkoY3R4LCBuZGltIC0gMSk7Ci0KLQlBc3NlcnQo IUpzb25Db250YWluZXJJc1NjYWxhcihqYmMpKTsKKwkJLyogR2V0dGluZyBoZXJlIG1lYW5zIHRo ZSBlcnJvciB3YXMgcmVwb3J0ZWQgc29mdGx5LiAqLworCQlBc3NlcnQoU09GVF9FUlJPUl9PQ0NV UlJFRChjdHgtPmVzY29udGV4dCkpOworCQlyZXR1cm4gZmFsc2U7CisJfQogCiAJaXQgPSBKc29u Ykl0ZXJhdG9ySW5pdChqYmMpOwogCkBAIC0yNzYzLDcgKzI4NDIsMTAgQEAgcG9wdWxhdGVfYXJy YXlfZGltX2pzb25iKFBvcHVsYXRlQXJyYXlDb250ZXh0ICpjdHgsIC8qIGNvbnRleHQgKi8KIAkJ ICh0b2sgPT0gV0pCX0VMRU0gJiYKIAkJICAodmFsLnR5cGUgIT0gamJ2QmluYXJ5IHx8CiAJCSAg ICFKc29uQ29udGFpbmVySXNBcnJheSh2YWwudmFsLmJpbmFyeS5kYXRhKSkpKSkKLQkJcG9wdWxh dGVfYXJyYXlfYXNzaWduX25kaW1zKGN0eCwgbmRpbSk7CisJeworCQlpZiAoIXBvcHVsYXRlX2Fy cmF5X2Fzc2lnbl9uZGltcyhjdHgsIG5kaW0pKQorCQkJcmV0dXJuIGZhbHNlOworCX0KIAogCWpz di5pc19qc29uID0gZmFsc2U7CiAJanN2LnZhbC5qc29uYiA9ICZ2YWw7CkBAIC0yNzc2LDE2ICsy ODU4LDIxIEBAIHBvcHVsYXRlX2FycmF5X2RpbV9qc29uYihQb3B1bGF0ZUFycmF5Q29udGV4dCAq Y3R4LCAvKiBjb250ZXh0ICovCiAJCSAqIGl0IGlzIG5vdCB0aGUgaW5uZXJtb3N0IGRpbWVuc2lv bi4KIAkJICovCiAJCWlmIChjdHgtPm5kaW1zID4gMCAmJiBuZGltID49IGN0eC0+bmRpbXMpCi0J CQlwb3B1bGF0ZV9hcnJheV9lbGVtZW50KGN0eCwgbmRpbSwgJmpzdik7CisJCXsKKwkJCWlmICgh cG9wdWxhdGVfYXJyYXlfZWxlbWVudChjdHgsIG5kaW0sICZqc3YpKQorCQkJCXJldHVybiBmYWxz ZTsKKwkJfQogCQllbHNlCiAJCXsKIAkJCS8qIHBvcHVsYXRlIGNoaWxkIHN1Yi1hcnJheSAqLwot CQkJcG9wdWxhdGVfYXJyYXlfZGltX2pzb25iKGN0eCwgJnZhbCwgbmRpbSArIDEpOworCQkJaWYg KCFwb3B1bGF0ZV9hcnJheV9kaW1fanNvbmIoY3R4LCAmdmFsLCBuZGltICsgMSkpCisJCQkJcmV0 dXJuIGZhbHNlOwogCiAJCQkvKiBudW1iZXIgb2YgZGltZW5zaW9ucyBzaG91bGQgYmUgYWxyZWFk eSBrbm93biAqLwogCQkJQXNzZXJ0KGN0eC0+bmRpbXMgPiAwICYmIGN0eC0+ZGltcyk7CiAKLQkJ CXBvcHVsYXRlX2FycmF5X2NoZWNrX2RpbWVuc2lvbihjdHgsIG5kaW0pOworCQkJaWYgKCFwb3B1 bGF0ZV9hcnJheV9jaGVja19kaW1lbnNpb24oY3R4LCBuZGltKSkKKwkJCQlyZXR1cm4gZmFsc2U7 CiAJCX0KIAogCQl0b2sgPSBKc29uYkl0ZXJhdG9yTmV4dCgmaXQsICZ2YWwsIHRydWUpOwpAQCAt Mjc5NiwxNCArMjg4MywyMiBAQCBwb3B1bGF0ZV9hcnJheV9kaW1fanNvbmIoUG9wdWxhdGVBcnJh eUNvbnRleHQgKmN0eCwgLyogY29udGV4dCAqLwogCS8qIGZyZWUgaXRlcmF0b3IsIGl0ZXJhdGlu ZyB1bnRpbCBXSkJfRE9ORSAqLwogCXRvayA9IEpzb25iSXRlcmF0b3JOZXh0KCZpdCwgJnZhbCwg dHJ1ZSk7CiAJQXNzZXJ0KHRvayA9PSBXSkJfRE9ORSAmJiAhaXQpOworCisJcmV0dXJuIHRydWU7 CiB9CiAKLS8qIHJlY3Vyc2l2ZWx5IHBvcHVsYXRlIGFuIGFycmF5IGZyb20ganNvbi9qc29uYiAq LworLyoKKyAqIFJlY3Vyc2l2ZWx5IHBvcHVsYXRlIGFuIGFycmF5IGZyb20ganNvbi9qc29uYgor ICoKKyAqICppc251bGwgaXMgc2V0IHRvIHRydWUgaWYgYW4gZXJyb3IgaXMgcmVwb3J0ZWQgZHVy aW5nIHBhcnNpbmcuCisgKi8KIHN0YXRpYyBEYXR1bQogcG9wdWxhdGVfYXJyYXkoQXJyYXlJT0Rh dGEgKmFpbywKIAkJCSAgIGNvbnN0IGNoYXIgKmNvbG5hbWUsCiAJCQkgICBNZW1vcnlDb250ZXh0 IG1jeHQsCi0JCQkgICBKc1ZhbHVlICpqc3YpCisJCQkgICBKc1ZhbHVlICpqc3YsCisJCQkgICBi b29sICppc251bGwsCisJCQkgICBOb2RlICplc2NvbnRleHQpCiB7CiAJUG9wdWxhdGVBcnJheUNv bnRleHQgY3R4OwogCURhdHVtCQlyZXN1bHQ7CkBAIC0yODE4LDE0ICsyOTEzLDI3IEBAIHBvcHVs YXRlX2FycmF5KEFycmF5SU9EYXRhICphaW8sCiAJY3R4Lm5kaW1zID0gMDsJCQkJLyogdW5rbm93 biB5ZXQgKi8KIAljdHguZGltcyA9IE5VTEw7CiAJY3R4LnNpemVzID0gTlVMTDsKKwljdHguZXNj b250ZXh0ID0gZXNjb250ZXh0OwogCiAJaWYgKGpzdi0+aXNfanNvbikKLQkJcG9wdWxhdGVfYXJy YXlfanNvbigmY3R4LCBqc3YtPnZhbC5qc29uLnN0ciwKLQkJCQkJCQlqc3YtPnZhbC5qc29uLmxl biA+PSAwID8ganN2LT52YWwuanNvbi5sZW4KLQkJCQkJCQk6IHN0cmxlbihqc3YtPnZhbC5qc29u LnN0cikpOworCXsKKwkJLyogUmV0dXJuIG51bGwgaWYgYW4gZXJyb3Igd2FzIGZvdW5kLiAqLwor CQlpZiAoIXBvcHVsYXRlX2FycmF5X2pzb24oJmN0eCwganN2LT52YWwuanNvbi5zdHIsCisJCQkJ CQkJCSBqc3YtPnZhbC5qc29uLmxlbiA+PSAwID8ganN2LT52YWwuanNvbi5sZW4KKwkJCQkJCQkJ IDogc3RybGVuKGpzdi0+dmFsLmpzb24uc3RyKSkpCisJCXsKKwkJCSppc251bGwgPSB0cnVlOwor CQkJcmV0dXJuIChEYXR1bSkgMDsKKwkJfQorCX0KIAllbHNlCiAJewotCQlwb3B1bGF0ZV9hcnJh eV9kaW1fanNvbmIoJmN0eCwganN2LT52YWwuanNvbmIsIDEpOworCQkvKiBSZXR1cm4gbnVsbCBp ZiBhbiBlcnJvciB3YXMgZm91bmQuICovCisJCWlmICghcG9wdWxhdGVfYXJyYXlfZGltX2pzb25i KCZjdHgsIGpzdi0+dmFsLmpzb25iLCAxKSkKKwkJeworCQkJKmlzbnVsbCA9IHRydWU7CisJCQly ZXR1cm4gKERhdHVtKSAwOworCQl9CiAJCWN0eC5kaW1zWzBdID0gY3R4LnNpemVzWzBdOwogCX0K IApAQCAtMjg0MywxMSArMjk1MSwxNiBAQCBwb3B1bGF0ZV9hcnJheShBcnJheUlPRGF0YSAqYWlv LAogCXBmcmVlKGN0eC5zaXplcyk7CiAJcGZyZWUobGJzKTsKIAorCSppc251bGwgPSBmYWxzZTsK IAlyZXR1cm4gcmVzdWx0OwogfQogCi1zdGF0aWMgdm9pZAotSnNWYWx1ZVRvSnNPYmplY3QoSnNW YWx1ZSAqanN2LCBKc09iamVjdCAqanNvKQorLyoKKyAqIFJldHVybnMgZmFsc2UgaWYgYW4gZXJy b3Igb2NjdXJzLCBwcm92aWRlZCBlc2NvbnRleHQgcG9pbnRzIHRvIGFuCisgKiBFcnJvclNhdmVD b250ZXh0LgorICovCitzdGF0aWMgYm9vbAorSnNWYWx1ZVRvSnNPYmplY3QoSnNWYWx1ZSAqanN2 LCBKc09iamVjdCAqanNvLCBOb2RlICplc2NvbnRleHQpCiB7CiAJanNvLT5pc19qc29uID0ganN2 LT5pc19qc29uOwogCkBAIC0yODU5LDcgKzI5NzIsOSBAQCBKc1ZhbHVlVG9Kc09iamVjdChKc1Zh bHVlICpqc3YsIEpzT2JqZWN0ICpqc28pCiAJCQkJCQkJCQlqc3YtPnZhbC5qc29uLmxlbiA+PSAw CiAJCQkJCQkJCQk/IGpzdi0+dmFsLmpzb24ubGVuCiAJCQkJCQkJCQk6IHN0cmxlbihqc3YtPnZh bC5qc29uLnN0ciksCi0JCQkJCQkJCQkicG9wdWxhdGVfY29tcG9zaXRlIik7CisJCQkJCQkJCQki cG9wdWxhdGVfY29tcG9zaXRlIiwKKwkJCQkJCQkJCWVzY29udGV4dCk7CisJCUFzc2VydChqc28t PnZhbC5qc29uX2hhc2ggIT0gTlVMTCB8fCBTT0ZUX0VSUk9SX09DQ1VSUkVEKGVzY29udGV4dCkp OwogCX0KIAllbHNlCiAJewpAQCAtMjg3Nyw3ICsyOTkyLDcgQEAgSnNWYWx1ZVRvSnNPYmplY3Qo SnNWYWx1ZSAqanN2LCBKc09iamVjdCAqanNvKQogCQkJaXNfc2NhbGFyID0gSXNBSnNvbmJTY2Fs YXIoamJ2KSB8fAogCQkJCShqYnYtPnR5cGUgPT0gamJ2QmluYXJ5ICYmCiAJCQkJIEpzb25Db250 YWluZXJJc1NjYWxhcihqYnYtPnZhbC5iaW5hcnkuZGF0YSkpOwotCQkJZXJlcG9ydChFUlJPUiwK KwkJCWVycnNhdmUoZXNjb250ZXh0LAogCQkJCQkoZXJyY29kZShFUlJDT0RFX0lOVkFMSURfUEFS QU1FVEVSX1ZBTFVFKSwKIAkJCQkJIGlzX3NjYWxhcgogCQkJCQkgPyBlcnJtc2coImNhbm5vdCBj YWxsICVzIG9uIGEgc2NhbGFyIiwKQEAgLTI4ODYsNiArMzAwMSw4IEBAIEpzVmFsdWVUb0pzT2Jq ZWN0KEpzVmFsdWUgKmpzdiwgSnNPYmplY3QgKmpzbykKIAkJCQkJCQkgICJwb3B1bGF0ZV9jb21w b3NpdGUiKSkpOwogCQl9CiAJfQorCisJcmV0dXJuICFTT0ZUX0VSUk9SX09DQ1VSUkVEKGVzY29u dGV4dCk7CiB9CiAKIC8qIGFjcXVpcmUgb3IgdXBkYXRlIGNhY2hlZCB0dXBsZSBkZXNjcmlwdG9y IGZvciBhIGNvbXBvc2l0ZSB0eXBlICovCkBAIC0yOTEyLDcgKzMwMjksMTIgQEAgdXBkYXRlX2Nh Y2hlZF90dXBkZXNjKENvbXBvc2l0ZUlPRGF0YSAqaW8sIE1lbW9yeUNvbnRleHQgbWN4dCkKIAl9 CiB9CiAKLS8qIHJlY3Vyc2l2ZWx5IHBvcHVsYXRlIGEgY29tcG9zaXRlIChyb3cgdHlwZSkgdmFs dWUgZnJvbSBqc29uL2pzb25iICovCisvKgorICogUmVjdXJzaXZlbHkgcG9wdWxhdGUgYSBjb21w b3NpdGUgKHJvdyB0eXBlKSB2YWx1ZSBmcm9tIGpzb24vanNvbmIKKyAqCisgKiBSZXR1cm5zIG51 bGwgaWYgYW4gZXJyb3Igb2NjdXJzIGluIGEgc3Vicm91dGluZSwgcHJvdmlkZWQgZXNjb250ZXh0 IHBvaW50cworICogdG8gYW4gRXJyb3JTYXZlQ29udGV4dC4KKyAqLwogc3RhdGljIERhdHVtCiBw b3B1bGF0ZV9jb21wb3NpdGUoQ29tcG9zaXRlSU9EYXRhICppbywKIAkJCQkgICBPaWQgdHlwaWQs CkBAIC0yOTIwLDE0ICszMDQyLDE1IEBAIHBvcHVsYXRlX2NvbXBvc2l0ZShDb21wb3NpdGVJT0Rh dGEgKmlvLAogCQkJCSAgIE1lbW9yeUNvbnRleHQgbWN4dCwKIAkJCQkgICBIZWFwVHVwbGVIZWFk ZXIgZGVmYXVsdHZhbCwKIAkJCQkgICBKc1ZhbHVlICpqc3YsCi0JCQkJICAgYm9vbCBpc251bGwp CisJCQkJICAgYm9vbCAqaXNudWxsLAorCQkJCSAgIE5vZGUgKmVzY29udGV4dCkKIHsKIAlEYXR1 bQkJcmVzdWx0OwogCiAJLyogYWNxdWlyZS91cGRhdGUgY2FjaGVkIHR1cGxlIGRlc2NyaXB0b3Ig Ki8KIAl1cGRhdGVfY2FjaGVkX3R1cGRlc2MoaW8sIG1jeHQpOwogCi0JaWYgKGlzbnVsbCkKKwlp ZiAoKmlzbnVsbCkKIAkJcmVzdWx0ID0gKERhdHVtKSAwOwogCWVsc2UKIAl7CkBAIC0yOTM1LDEx ICszMDU4LDIxIEBAIHBvcHVsYXRlX2NvbXBvc2l0ZShDb21wb3NpdGVJT0RhdGEgKmlvLAogCQlK c09iamVjdAlqc287CiAKIAkJLyogcHJlcGFyZSBpbnB1dCB2YWx1ZSAqLwotCQlKc1ZhbHVlVG9K c09iamVjdChqc3YsICZqc28pOworCQlpZiAoIUpzVmFsdWVUb0pzT2JqZWN0KGpzdiwgJmpzbywg ZXNjb250ZXh0KSkKKwkJeworCQkJKmlzbnVsbCA9IHRydWU7CisJCQlyZXR1cm4gKERhdHVtKSAw OworCQl9CiAKIAkJLyogcG9wdWxhdGUgcmVzdWx0aW5nIHJlY29yZCB0dXBsZSAqLwogCQl0dXBs ZSA9IHBvcHVsYXRlX3JlY29yZChpby0+dHVwZGVzYywgJmlvLT5yZWNvcmRfaW8sCi0JCQkJCQkJ CWRlZmF1bHR2YWwsIG1jeHQsICZqc28pOworCQkJCQkJCQlkZWZhdWx0dmFsLCBtY3h0LCAmanNv LCBlc2NvbnRleHQpOworCisJCWlmIChTT0ZUX0VSUk9SX09DQ1VSUkVEKGVzY29udGV4dCkpCisJ CXsKKwkJCSppc251bGwgPSB0cnVlOworCQkJcmV0dXJuIChEYXR1bSkgMDsKKwkJfQogCQlyZXN1 bHQgPSBIZWFwVHVwbGVIZWFkZXJHZXREYXR1bSh0dXBsZSk7CiAKIAkJSnNPYmplY3RGcmVlKCZq c28pOwpAQCAtMjk1MSwxNCArMzA4NCwyMCBAQCBwb3B1bGF0ZV9jb21wb3NpdGUoQ29tcG9zaXRl SU9EYXRhICppbywKIAkgKiBub3csIHdlIGNhbiB0ZWxsIGJ5IGNvbXBhcmluZyB0eXBpZCB0byBi YXNlX3R5cGlkLikKIAkgKi8KIAlpZiAodHlwaWQgIT0gaW8tPmJhc2VfdHlwaWQgJiYgdHlwaWQg IT0gUkVDT1JET0lEKQotCQlkb21haW5fY2hlY2socmVzdWx0LCBpc251bGwsIHR5cGlkLCAmaW8t PmRvbWFpbl9pbmZvLCBtY3h0KTsKKwkJZG9tYWluX2NoZWNrKHJlc3VsdCwgKmlzbnVsbCwgdHlw aWQsICZpby0+ZG9tYWluX2luZm8sIG1jeHQpOwogCiAJcmV0dXJuIHJlc3VsdDsKIH0KIAotLyog cG9wdWxhdGUgbm9uLW51bGwgc2NhbGFyIHZhbHVlIGZyb20ganNvbi9qc29uYiB2YWx1ZSAqLwor LyoKKyAqIFBvcHVsYXRlIG5vbi1udWxsIHNjYWxhciB2YWx1ZSBmcm9tIGpzb24vanNvbmIgdmFs dWUuCisgKgorICogUmV0dXJucyBudWxsIGlmIGFuIGVycm9yIG9jY3VycyBkdXJpbmcgdGhlIGNh bGwgdG8gdHlwZSBpbnB1dCBmdW5jdGlvbiwKKyAqIHByb3ZpZGVkIGVzY29udGV4dCBpcyB2YWxp ZC4KKyAqLwogc3RhdGljIERhdHVtCi1wb3B1bGF0ZV9zY2FsYXIoU2NhbGFySU9EYXRhICppbywg T2lkIHR5cGlkLCBpbnQzMiB0eXBtb2QsIEpzVmFsdWUgKmpzdikKK3BvcHVsYXRlX3NjYWxhcihT Y2FsYXJJT0RhdGEgKmlvLCBPaWQgdHlwaWQsIGludDMyIHR5cG1vZCwgSnNWYWx1ZSAqanN2LAor CQkJCWJvb2wgKmlzbnVsbCwgTm9kZSAqZXNjb250ZXh0KQogewogCURhdHVtCQlyZXM7CiAJY2hh cgkgICAqc3RyID0gTlVMTDsKQEAgLTMwMjksNyArMzE2OCwxMiBAQCBwb3B1bGF0ZV9zY2FsYXIo U2NhbGFySU9EYXRhICppbywgT2lkIHR5cGlkLCBpbnQzMiB0eXBtb2QsIEpzVmFsdWUgKmpzdikK IAkJCWVsb2coRVJST1IsICJ1bnJlY29nbml6ZWQganNvbmIgdHlwZTogJWQiLCAoaW50KSBqYnYt PnR5cGUpOwogCX0KIAotCXJlcyA9IElucHV0RnVuY3Rpb25DYWxsKCZpby0+dHlwaW9mdW5jLCBz dHIsIGlvLT50eXBpb3BhcmFtLCB0eXBtb2QpOworCWlmICghSW5wdXRGdW5jdGlvbkNhbGxTYWZl KCZpby0+dHlwaW9mdW5jLCBzdHIsIGlvLT50eXBpb3BhcmFtLCB0eXBtb2QsCisJCQkJCQkJICAg ZXNjb250ZXh0LCAmcmVzKSkKKwl7CisJCXJlcyA9IChEYXR1bSkgMDsKKwkJKmlzbnVsbCA9IHRy dWU7CisJfQogCiAJLyogZnJlZSB0ZW1wb3JhcnkgYnVmZmVyICovCiAJaWYgKHN0ciAhPSBqc29u KQpAQCAtMzA0NCw3ICszMTg4LDggQEAgcG9wdWxhdGVfZG9tYWluKERvbWFpbklPRGF0YSAqaW8s CiAJCQkJY29uc3QgY2hhciAqY29sbmFtZSwKIAkJCQlNZW1vcnlDb250ZXh0IG1jeHQsCiAJCQkJ SnNWYWx1ZSAqanN2LAotCQkJCWJvb2wgaXNudWxsKQorCQkJCWJvb2wgaXNudWxsLAorCQkJCU5v ZGUgKmVzY29udGV4dCkKIHsKIAlEYXR1bQkJcmVzOwogCkBAIC0zMDU1LDggKzMyMDAsOCBAQCBw b3B1bGF0ZV9kb21haW4oRG9tYWluSU9EYXRhICppbywKIAkJcmVzID0gcG9wdWxhdGVfcmVjb3Jk X2ZpZWxkKGlvLT5iYXNlX2lvLAogCQkJCQkJCQkJaW8tPmJhc2VfdHlwaWQsIGlvLT5iYXNlX3R5 cG1vZCwKIAkJCQkJCQkJCWNvbG5hbWUsIG1jeHQsIFBvaW50ZXJHZXREYXR1bShOVUxMKSwKLQkJ CQkJCQkJCWpzdiwgJmlzbnVsbCk7Ci0JCUFzc2VydCghaXNudWxsKTsKKwkJCQkJCQkJCWpzdiwg JmlzbnVsbCwgZXNjb250ZXh0KTsKKwkJQXNzZXJ0KCFpc251bGwgfHwgU09GVF9FUlJPUl9PQ0NV UlJFRChlc2NvbnRleHQpKTsKIAl9CiAKIAlkb21haW5fY2hlY2socmVzLCBpc251bGwsIHR5cGlk LCAmaW8tPmRvbWFpbl9pbmZvLCBtY3h0KTsKQEAgLTMxNjAsNyArMzMwNSw4IEBAIHBvcHVsYXRl X3JlY29yZF9maWVsZChDb2x1bW5JT0RhdGEgKmNvbCwKIAkJCQkJICBNZW1vcnlDb250ZXh0IG1j eHQsCiAJCQkJCSAgRGF0dW0gZGVmYXVsdHZhbCwKIAkJCQkJICBKc1ZhbHVlICpqc3YsCi0JCQkJ CSAgYm9vbCAqaXNudWxsKQorCQkJCQkgIGJvb2wgKmlzbnVsbCwKKwkJCQkJICBOb2RlICplc2Nv bnRleHQpCiB7CiAJVHlwZUNhdAkJdHlwY2F0OwogCkBAIC0zMTkzLDEwICszMzM5LDEyIEBAIHBv cHVsYXRlX3JlY29yZF9maWVsZChDb2x1bW5JT0RhdGEgKmNvbCwKIAlzd2l0Y2ggKHR5cGNhdCkK IAl7CiAJCWNhc2UgVFlQRUNBVF9TQ0FMQVI6Ci0JCQlyZXR1cm4gcG9wdWxhdGVfc2NhbGFyKCZj b2wtPnNjYWxhcl9pbywgdHlwaWQsIHR5cG1vZCwganN2KTsKKwkJCXJldHVybiBwb3B1bGF0ZV9z Y2FsYXIoJmNvbC0+c2NhbGFyX2lvLCB0eXBpZCwgdHlwbW9kLCBqc3YsCisJCQkJCQkJCSAgIGlz bnVsbCwgZXNjb250ZXh0KTsKIAogCQljYXNlIFRZUEVDQVRfQVJSQVk6Ci0JCQlyZXR1cm4gcG9w dWxhdGVfYXJyYXkoJmNvbC0+aW8uYXJyYXksIGNvbG5hbWUsIG1jeHQsIGpzdik7CisJCQlyZXR1 cm4gcG9wdWxhdGVfYXJyYXkoJmNvbC0+aW8uYXJyYXksIGNvbG5hbWUsIG1jeHQsIGpzdiwKKwkJ CQkJCQkJICBpc251bGwsIGVzY29udGV4dCk7CiAKIAkJY2FzZSBUWVBFQ0FUX0NPTVBPU0lURToK IAkJY2FzZSBUWVBFQ0FUX0NPTVBPU0lURV9ET01BSU46CkBAIC0zMjA1LDExICszMzUzLDEyIEBA IHBvcHVsYXRlX3JlY29yZF9maWVsZChDb2x1bW5JT0RhdGEgKmNvbCwKIAkJCQkJCQkJCSAgRGF0 dW1HZXRQb2ludGVyKGRlZmF1bHR2YWwpCiAJCQkJCQkJCQkgID8gRGF0dW1HZXRIZWFwVHVwbGVI ZWFkZXIoZGVmYXVsdHZhbCkKIAkJCQkJCQkJCSAgOiBOVUxMLAotCQkJCQkJCQkJICBqc3YsICpp c251bGwpOworCQkJCQkJCQkJICBqc3YsIGlzbnVsbCwKKwkJCQkJCQkJCSAgZXNjb250ZXh0KTsK IAogCQljYXNlIFRZUEVDQVRfRE9NQUlOOgogCQkJcmV0dXJuIHBvcHVsYXRlX2RvbWFpbigmY29s LT5pby5kb21haW4sIHR5cGlkLCBjb2xuYW1lLCBtY3h0LAotCQkJCQkJCQkgICBqc3YsICppc251 bGwpOworCQkJCQkJCQkgICBqc3YsICppc251bGwsIGVzY29udGV4dCk7CiAKIAkJZGVmYXVsdDoK IAkJCWVsb2coRVJST1IsICJ1bnJlY29nbml6ZWQgdHlwZSBjYXRlZ29yeSAnJWMnIiwgdHlwY2F0 KTsKQEAgLTMyMTcsNiArMzM2Niw2MiBAQCBwb3B1bGF0ZV9yZWNvcmRfZmllbGQoQ29sdW1uSU9E YXRhICpjb2wsCiAJfQogfQogCisvKgorICogUG9wdWxhdGUgYW5kIHJldHVybiB0aGUgdmFsdWUg b2Ygc3BlY2lmaWVkIHR5cGUgZnJvbSBhIGdpdmVuIGpzb24vanNvbmIKKyAqIHZhbHVlICdqc29u X3ZhbCcuICAnY2FjaGUnIGlzIGNhbGxlci1zcGVjaWZpZWQgcG9pbnRlciB0byBzYXZlIHRoZQor ICogQ29sdW1uSU9EYXRhIHRoYXQgd2lsbCBiZSBpbml0aWFsaXplZCBvbiB0aGUgMXN0IGNhbGwg YW5kIHRoZW4gcmV1c2VkCisgKiBkdXJpbmcgYW55IHN1YnNlcXVlbnQgY2FsbHMuICAnbWN4dCcg Z2l2ZXMgdGhlIG1lbW9yeSBjb250ZXh0IHRvIGFsbG9jYXRlCisgKiB0aGUgQ29sdW1uSU9EYXRh IGFuZCBhbnkgb3RoZXIgc3Vic2lkaWFyeSBtZW1vcnkgaW4uICAnZXNjb250ZXh0JywKKyAqIGlm IG5vdCBOVUxMLCB0ZWxscyB0aGF0IGFueSBlcnJvcnMgdGhhdCBvY2N1ciBzaG91bGQgYmUgaGFu ZGxlZCBzb2Z0bHkuCisgKi8KK0RhdHVtCitqc29uX3BvcHVsYXRlX3R5cGUoRGF0dW0ganNvbl92 YWwsIE9pZCBqc29uX3R5cGUsCisJCQkJICAgT2lkIHR5cGlkLCBpbnQzMiB0eXBtb2QsCisJCQkJ ICAgdm9pZCAqKmNhY2hlLCBNZW1vcnlDb250ZXh0IG1jeHQsCisJCQkJICAgYm9vbCAqaXNudWxs LAorCQkJCSAgIE5vZGUgKmVzY29udGV4dCkKK3sKKwlKc1ZhbHVlCQlqc3YgPSB7MH07CisJSnNv bmJWYWx1ZQlqYnY7CisKKwlqc3YuaXNfanNvbiA9IGpzb25fdHlwZSA9PSBKU09OT0lEOworCisJ aWYgKCppc251bGwpCisJeworCQlpZiAoanN2LmlzX2pzb24pCisJCQlqc3YudmFsLmpzb24uc3Ry ID0gTlVMTDsKKwkJZWxzZQorCQkJanN2LnZhbC5qc29uYiA9IE5VTEw7CisJfQorCWVsc2UgaWYg KGpzdi5pc19qc29uKQorCXsKKwkJdGV4dAkgICAqanNvbiA9IERhdHVtR2V0VGV4dFBQKGpzb25f dmFsKTsKKworCQlqc3YudmFsLmpzb24uc3RyID0gVkFSREFUQV9BTlkoanNvbik7CisJCWpzdi52 YWwuanNvbi5sZW4gPSBWQVJTSVpFX0FOWV9FWEhEUihqc29uKTsKKwkJanN2LnZhbC5qc29uLnR5 cGUgPSBKU09OX1RPS0VOX0lOVkFMSUQ7IC8qIG5vdCB1c2VkIGluCisJCQkJCQkJCQkJCQkgKiBw b3B1bGF0ZV9jb21wb3NpdGUoKSAqLworCX0KKwllbHNlCisJeworCQlKc29uYgkgICAqanNvbmIg PSBEYXR1bUdldEpzb25iUChqc29uX3ZhbCk7CisKKwkJanN2LnZhbC5qc29uYiA9ICZqYnY7CisK KwkJLyogZmlsbCBiaW5hcnkganNvbmIgdmFsdWUgcG9pbnRpbmcgdG8gamIgKi8KKwkJamJ2LnR5 cGUgPSBqYnZCaW5hcnk7CisJCWpidi52YWwuYmluYXJ5LmRhdGEgPSAmanNvbmItPnJvb3Q7CisJ CWpidi52YWwuYmluYXJ5LmxlbiA9IFZBUlNJWkUoanNvbmIpIC0gVkFSSERSU1o7CisJfQorCisJ aWYgKCpjYWNoZSA9PSBOVUxMKQorCQkqY2FjaGUgPSBNZW1vcnlDb250ZXh0QWxsb2NaZXJvKG1j eHQsIHNpemVvZihDb2x1bW5JT0RhdGEpKTsKKworCXJldHVybiBwb3B1bGF0ZV9yZWNvcmRfZmll bGQoKmNhY2hlLCB0eXBpZCwgdHlwbW9kLCBOVUxMLCBtY3h0LAorCQkJCQkJCQkgUG9pbnRlckdl dERhdHVtKE5VTEwpLCAmanN2LCBpc251bGwsCisJCQkJCQkJCSBlc2NvbnRleHQpOworfQorCiBz dGF0aWMgUmVjb3JkSU9EYXRhICoKIGFsbG9jYXRlX3JlY29yZF9pbmZvKE1lbW9yeUNvbnRleHQg bWN4dCwgaW50IG5jb2x1bW5zKQogewpAQCAtMzI2Niw3ICszNDcxLDggQEAgcG9wdWxhdGVfcmVj b3JkKFR1cGxlRGVzYyB0dXBkZXNjLAogCQkJCVJlY29yZElPRGF0YSAqKnJlY29yZF9wLAogCQkJ CUhlYXBUdXBsZUhlYWRlciBkZWZhdWx0dmFsLAogCQkJCU1lbW9yeUNvbnRleHQgbWN4dCwKLQkJ CQlKc09iamVjdCAqb2JqKQorCQkJCUpzT2JqZWN0ICpvYmosCisJCQkJTm9kZSAqZXNjb250ZXh0 KQogewogCVJlY29yZElPRGF0YSAqcmVjb3JkID0gKnJlY29yZF9wOwogCURhdHVtCSAgICp2YWx1 ZXM7CkBAIC0zMzU4LDcgKzM1NjQsOCBAQCBwb3B1bGF0ZV9yZWNvcmQoVHVwbGVEZXNjIHR1cGRl c2MsCiAJCQkJCQkJCQkJICBtY3h0LAogCQkJCQkJCQkJCSAgbnVsbHNbaV0gPyAoRGF0dW0pIDAg OiB2YWx1ZXNbaV0sCiAJCQkJCQkJCQkJICAmZmllbGQsCi0JCQkJCQkJCQkJICAmbnVsbHNbaV0p OworCQkJCQkJCQkJCSAgJm51bGxzW2ldLAorCQkJCQkJCQkJCSAgZXNjb250ZXh0KTsKIAl9CiAK IAlyZXMgPSBoZWFwX2Zvcm1fdHVwbGUodHVwZGVzYywgdmFsdWVzLCBudWxscyk7CkBAIC0zNDQ1 LDYgKzM2NTIsNyBAQCBwb3B1bGF0ZV9yZWNvcmRfd29ya2VyKEZ1bmN0aW9uQ2FsbEluZm8gZmNp bmZvLCBjb25zdCBjaGFyICpmdW5jbmFtZSwKIAlKc1ZhbHVlCQlqc3YgPSB7MH07CiAJSGVhcFR1 cGxlSGVhZGVyIHJlYzsKIAlEYXR1bQkJcmV0dHVwbGU7CisJYm9vbAkJaXNudWxsOwogCUpzb25i VmFsdWUJamJ2OwogCU1lbW9yeUNvbnRleHQgZm5tY3h0ID0gZmNpbmZvLT5mbGluZm8tPmZuX21j eHQ7CiAJUG9wdWxhdGVSZWNvcmRDYWNoZSAqY2FjaGUgPSBmY2luZm8tPmZsaW5mby0+Zm5fZXh0 cmE7CkBAIC0zNTMxLDggKzM3MzksMTEgQEAgcG9wdWxhdGVfcmVjb3JkX3dvcmtlcihGdW5jdGlv bkNhbGxJbmZvIGZjaW5mbywgY29uc3QgY2hhciAqZnVuY25hbWUsCiAJCWpidi52YWwuYmluYXJ5 LmxlbiA9IFZBUlNJWkUoamIpIC0gVkFSSERSU1o7CiAJfQogCisJaXNudWxsID0gZmFsc2U7CiAJ cmV0dHVwbGUgPSBwb3B1bGF0ZV9jb21wb3NpdGUoJmNhY2hlLT5jLmlvLmNvbXBvc2l0ZSwgY2Fj aGUtPmFyZ3R5cGUsCi0JCQkJCQkJCSAgTlVMTCwgZm5tY3h0LCByZWMsICZqc3YsIGZhbHNlKTsK KwkJCQkJCQkJICBOVUxMLCBmbm1jeHQsIHJlYywgJmpzdiwgJmlzbnVsbCwKKwkJCQkJCQkJICBO VUxMKTsKKwlBc3NlcnQoIWlzbnVsbCk7CiAKIAlQR19SRVRVUk5fREFUVU0ocmV0dHVwbGUpOwog fQpAQCAtMzU0MCwxMCArMzc1MSwxMyBAQCBwb3B1bGF0ZV9yZWNvcmRfd29ya2VyKEZ1bmN0aW9u Q2FsbEluZm8gZmNpbmZvLCBjb25zdCBjaGFyICpmdW5jbmFtZSwKIC8qCiAgKiBnZXRfanNvbl9v YmplY3RfYXNfaGFzaAogICoKLSAqIGRlY29tcG9zZSBhIGpzb24gb2JqZWN0IGludG8gYSBoYXNo IHRhYmxlLgorICogRGVjb21wb3NlcyBhIGpzb24gb2JqZWN0IGludG8gYSBoYXNoIHRhYmxlLgor ICoKKyAqIFJldHVybnMgdGhlIGhhc2ggdGFibGUgaWYgdGhlIGpzb24gaXMgcGFyc2VkIHN1Y2Nl c3NmdWxseSwgTlVMTCBvdGhlcndpc2UuCiAgKi8KIHN0YXRpYyBIVEFCICoKLWdldF9qc29uX29i amVjdF9hc19oYXNoKGNoYXIgKmpzb24sIGludCBsZW4sIGNvbnN0IGNoYXIgKmZ1bmNuYW1lKQor Z2V0X2pzb25fb2JqZWN0X2FzX2hhc2goY2hhciAqanNvbiwgaW50IGxlbiwgY29uc3QgY2hhciAq ZnVuY25hbWUsCisJCQkJCQlOb2RlICplc2NvbnRleHQpCiB7CiAJSEFTSENUTAkJY3RsOwogCUhU QUIJICAgKnRhYjsKQEAgLTM1NzIsNyArMzc4NiwxMSBAQCBnZXRfanNvbl9vYmplY3RfYXNfaGFz aChjaGFyICpqc29uLCBpbnQgbGVuLCBjb25zdCBjaGFyICpmdW5jbmFtZSkKIAlzZW0tPm9iamVj dF9maWVsZF9zdGFydCA9IGhhc2hfb2JqZWN0X2ZpZWxkX3N0YXJ0OwogCXNlbS0+b2JqZWN0X2Zp ZWxkX2VuZCA9IGhhc2hfb2JqZWN0X2ZpZWxkX2VuZDsKIAotCXBnX3BhcnNlX2pzb25fb3JfZXJl cG9ydChzdGF0ZS0+bGV4LCBzZW0pOworCWlmICghcGdfcGFyc2VfanNvbl9vcl9lcnJzYXZlKHN0 YXRlLT5sZXgsIHNlbSwgZXNjb250ZXh0KSkKKwl7CisJCWhhc2hfZGVzdHJveShzdGF0ZS0+aGFz aCk7CisJCXRhYiA9IE5VTEw7CisJfQogCiAJZnJlZUpzb25MZXhDb250ZXh0KHN0YXRlLT5sZXgp OwogCkBAIC0zNzQzLDcgKzM5NjEsOCBAQCBwb3B1bGF0ZV9yZWNvcmRzZXRfcmVjb3JkKFBvcHVs YXRlUmVjb3Jkc2V0U3RhdGUgKnN0YXRlLCBKc09iamVjdCAqb2JqKQogCQkJCQkJCSAgJmNhY2hl LT5jLmlvLmNvbXBvc2l0ZS5yZWNvcmRfaW8sCiAJCQkJCQkJICBzdGF0ZS0+cmVjLAogCQkJCQkJ CSAgY2FjaGUtPmZuX21jeHQsCi0JCQkJCQkJICBvYmopOworCQkJCQkJCSAgb2JqLAorCQkJCQkJ CSAgTlVMTCk7CiAKIAkvKiBpZiBpdCdzIGRvbWFpbiBvdmVyIGNvbXBvc2l0ZSwgY2hlY2sgZG9t YWluIGNvbnN0cmFpbnRzICovCiAJaWYgKGNhY2hlLT5jLnR5cGNhdCA9PSBUWVBFQ0FUX0NPTVBP U0lURV9ET01BSU4pCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS91dGlscy9qc29uZnVuY3MuaCBi L3NyYy9pbmNsdWRlL3V0aWxzL2pzb25mdW5jcy5oCmluZGV4IDMxYzFhZTQ3NjcuLjliYjllYjcz YjQgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL3V0aWxzL2pzb25mdW5jcy5oCisrKyBiL3NyYy9p bmNsdWRlL3V0aWxzL2pzb25mdW5jcy5oCkBAIC0xNSw2ICsxNSw3IEBACiAjZGVmaW5lIEpTT05G VU5DU19ICiAKICNpbmNsdWRlICJjb21tb24vanNvbmFwaS5oIgorI2luY2x1ZGUgIm5vZGVzL25v ZGVzLmgiCiAjaW5jbHVkZSAidXRpbHMvanNvbmIuaCIKIAogLyoKQEAgLTg3LDUgKzg4LDEwIEBA IGV4dGVybiBEYXR1bSBkYXR1bV90b19qc29uKERhdHVtIHZhbCwgSnNvblR5cGVDYXRlZ29yeSB0 Y2F0ZWdvcnksCiBleHRlcm4gRGF0dW0gZGF0dW1fdG9fanNvbmIoRGF0dW0gdmFsLCBKc29uVHlw ZUNhdGVnb3J5IHRjYXRlZ29yeSwKIAkJCQkJCQlPaWQgb3V0ZnVuY29pZCk7CiBleHRlcm4gRGF0 dW0ganNvbmJfZnJvbV90ZXh0KHRleHQgKmpzLCBib29sIHVuaXF1ZV9rZXlzKTsKK2V4dGVybiBE YXR1bSBqc29uX3BvcHVsYXRlX3R5cGUoRGF0dW0ganNvbl92YWwsIE9pZCBqc29uX3R5cGUsCisJ CQkJICAgT2lkIHR5cGlkLCBpbnQzMiB0eXBtb2QsCisJCQkJICAgdm9pZCAqKmNhY2hlLCBNZW1v cnlDb250ZXh0IG1jeHQsCisJCQkJICAgYm9vbCAqaXNudWxsLAorCQkJCSAgIE5vZGUgKmVzY29u dGV4dCk7CiAKICNlbmRpZgotLSAKMi4zNS4zCgo= --00000000000078edb1060f38208c Content-Type: application/octet-stream; name="v34-0006-Add-jsonb-support-function-JsonbUnquote.patch" Content-Disposition: attachment; filename="v34-0006-Add-jsonb-support-function-JsonbUnquote.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lrj7oapa5 RnJvbSAxNmY5ODYxNDFkMmNkNGIwN2NiNGQ1YmNkYWNkZjhkYWEyNGIxNDVhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbWl0IExhbmdvdGUgPGFtaXRsYW5AcG9zdGdyZXNxbC5vcmc+ CkRhdGU6IFRodSwgMTggSmFuIDIwMjQgMTc6NTc6NTggKzA5MDAKU3ViamVjdDogW1BBVENIIHYz NCA2LzhdIEFkZCBqc29uYiBzdXBwb3J0IGZ1bmN0aW9uIEpzb25iVW5xdW90ZSgpCgpBcyB0aGUg bmFtZSBzYXlzLCBpdCdzIGludGVuZGVkIHRvIHJlbW92ZSBxdW90ZXMgZnJvbSBzY2FsYXIgc3Ry aW5ncwpleHRyYWN0ZWQgZnJvbSBqc29uKGIpIHZhbHVlcy4KCkRpc2N1c3Npb246IGh0dHBzOi8v cG9zdGdyLmVzL20vQ0ErSGl3cUU0WFRkZmIxblc9T2pveV90UVNSaFl0LXFfa2I2aTVkNHhjS3ly TEMxTmJnQG1haWwuZ21haWwuY29tCi0tLQogc3JjL2JhY2tlbmQvdXRpbHMvYWR0L2pzb25iLmMg fCAzMSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBzcmMvaW5jbHVkZS91dGlscy9q c29uYi5oICAgICB8ICAxICsKIDIgZmlsZXMgY2hhbmdlZCwgMzIgaW5zZXJ0aW9ucygrKQoKZGlm ZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9qc29uYi5jIGIvc3JjL2JhY2tlbmQvdXRp bHMvYWR0L2pzb25iLmMKaW5kZXggYzEwYjNmYmVkZi4uNmQ3OTdjMDk1MyAxMDA2NDQKLS0tIGEv c3JjL2JhY2tlbmQvdXRpbHMvYWR0L2pzb25iLmMKKysrIGIvc3JjL2JhY2tlbmQvdXRpbHMvYWR0 L2pzb25iLmMKQEAgLTIxNjMsMyArMjE2MywzNCBAQCBqc29uYl9mbG9hdDgoUEdfRlVOQ1RJT05f QVJHUykKIAogCVBHX1JFVFVSTl9EQVRVTShyZXRWYWx1ZSk7CiB9CisKKy8qCisgKiBDb252ZXJ0 IGpzb25iIHRvIGEgQy1zdHJpbmcgc3RyaXBwaW5nIHF1b3RlcyBmcm9tIHNjYWxhciBzdHJpbmdz LgorICovCitjaGFyICoKK0pzb25iVW5xdW90ZShKc29uYiAqamIpCit7CisJaWYgKEpCX1JPT1Rf SVNfU0NBTEFSKGpiKSkKKwl7CisJCUpzb25iVmFsdWUJdjsKKworCQkodm9pZCkgSnNvbmJFeHRy YWN0U2NhbGFyKCZqYi0+cm9vdCwgJnYpOworCisJCWlmICh2LnR5cGUgPT0gamJ2U3RyaW5nKQor CQkJcmV0dXJuIHBuc3RyZHVwKHYudmFsLnN0cmluZy52YWwsIHYudmFsLnN0cmluZy5sZW4pOwor CQllbHNlIGlmICh2LnR5cGUgPT0gamJ2Qm9vbCkKKwkJCXJldHVybiBwc3RyZHVwKHYudmFsLmJv b2xlYW4gPyAidHJ1ZSIgOiAiZmFsc2UiKTsKKwkJZWxzZSBpZiAodi50eXBlID09IGpidk51bWVy aWMpCisJCQlyZXR1cm4gRGF0dW1HZXRDU3RyaW5nKERpcmVjdEZ1bmN0aW9uQ2FsbDEobnVtZXJp Y19vdXQsCisJCQkJCQkJCQkJCQkJICAgUG9pbnRlckdldERhdHVtKHYudmFsLm51bWVyaWMpKSk7 CisJCWVsc2UgaWYgKHYudHlwZSA9PSBqYnZOdWxsKQorCQkJcmV0dXJuIHBzdHJkdXAoIm51bGwi KTsKKwkJZWxzZQorCQl7CisJCQllbG9nKEVSUk9SLCAidW5yZWNvZ25pemVkIGpzb25iIHZhbHVl IHR5cGUgJWQiLCB2LnR5cGUpOworCQkJcmV0dXJuIE5VTEw7CisJCX0KKwl9CisJZWxzZQorCQly ZXR1cm4gSnNvbmJUb0NTdHJpbmcoTlVMTCwgJmpiLT5yb290LCBWQVJTSVpFKGpiKSk7Cit9CmRp ZmYgLS1naXQgYS9zcmMvaW5jbHVkZS91dGlscy9qc29uYi5oIGIvc3JjL2luY2x1ZGUvdXRpbHMv anNvbmIuaAppbmRleCBlMzhkZmQ0OTAxLi5kNTg5YWNlNWEyIDEwMDY0NAotLS0gYS9zcmMvaW5j bHVkZS91dGlscy9qc29uYi5oCisrKyBiL3NyYy9pbmNsdWRlL3V0aWxzL2pzb25iLmgKQEAgLTQy Miw2ICs0MjIsNyBAQCBleHRlcm4gY2hhciAqSnNvbmJUb0NTdHJpbmcoU3RyaW5nSW5mbyBvdXQs IEpzb25iQ29udGFpbmVyICppbiwKIAkJCQkJCQlpbnQgZXN0aW1hdGVkX2xlbik7CiBleHRlcm4g Y2hhciAqSnNvbmJUb0NTdHJpbmdJbmRlbnQoU3RyaW5nSW5mbyBvdXQsIEpzb25iQ29udGFpbmVy ICppbiwKIAkJCQkJCQkJICBpbnQgZXN0aW1hdGVkX2xlbik7CitleHRlcm4gY2hhciAqSnNvbmJV bnF1b3RlKEpzb25iICpqYik7CiBleHRlcm4gYm9vbCBKc29uYkV4dHJhY3RTY2FsYXIoSnNvbmJD b250YWluZXIgKmpiYywgSnNvbmJWYWx1ZSAqcmVzKTsKIGV4dGVybiBjb25zdCBjaGFyICpKc29u YlR5cGVOYW1lKEpzb25iVmFsdWUgKnZhbCk7CiAKLS0gCjIuMzUuMwoK --00000000000078edb1060f38208c Content-Type: application/octet-stream; name="v34-0007-SQL-JSON-query-functions.patch" Content-Disposition: attachment; filename="v34-0007-SQL-JSON-query-functions.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lrj7oapf6 RnJvbSBiZDc1OWZlZjRlOWVhNzYyZDU4YWIxNDI0ZjMyZGI5YTRiMTU1NTA2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbWl0IExhbmdvdGUgPGFtaXRsYW5AcG9zdGdyZXNxbC5vcmc+ CkRhdGU6IFRodSwgMTggSmFuIDIwMjQgMTc6NTk6NTYgKzA5MDAKU3ViamVjdDogW1BBVENIIHYz NCA3LzhdIFNRTC9KU09OIHF1ZXJ5IGZ1bmN0aW9ucwpNSU1FLVZlcnNpb246IDEuMApDb250ZW50 LVR5cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNvZGlu ZzogOGJpdAoKVGhpcyBpbnRyb2R1Y2VzIHRoZSBmb2xsb3dpbmcgU1FML0pTT04gZnVuY3Rpb25z IGZvciBxdWVyeWluZyBKU09OCmRhdGEgdXNpbmcganNvbnBhdGggZXhwcmVzc2lvbnM6CgpKU09O X0VYSVNUUygpCkpTT05fUVVFUlkoKQpKU09OX1ZBTFVFKCkKCkpTT05fRVhJU1RTKCkgdGVzdHMg aWYgdGhlIGpzb25wYXRoIGV4cHJlc3Npb24gYXBwbGllZCB0byB0aGUganNvbmIKdmFsdWUgeWll bGRzIGFueSB2YWx1ZXMuCgpKU09OX1ZBTFVFKCkgbXVzdCByZXR1cm4gYSBzaW5nbGUgdmFsdWUs IGFuZCBhbiBlcnJvciBvY2N1cnMgaWYgaXQKdHJpZXMgdG8gcmV0dXJuIG11bHRpcGxlIHZhbHVl cy4KCkpTT05fUVVFUlkoKSBtdXN0IHJldHVybiBhIGpzb24gb2JqZWN0IG9yIGFycmF5LCBhbmQg dGhlcmUgYXJlCnZhcmlvdXMgV1JBUFBFUiBvcHRpb25zIGZvciBoYW5kbGluZyBzY2FsYXIgb3Ig bXVsdGktdmFsdWUgcmVzdWx0cy4KQm90aCB0aGVzZSBmdW5jdGlvbnMgaGF2ZSBvcHRpb25zIGZv ciBoYW5kbGluZyBFTVBUWSBhbmQgRVJST1IKY29uZGl0aW9ucy4KCkFsbCBvZiB0aGVzZSBmdW5j dGlvbnMgb25seSBvcGVyYXRlIG9uIGpzb25iLiBUaGUgd29ya2Fyb3VuZCBmb3Igbm93CmlzIHRv IGNhc3QgdGhlIGFyZ3VtZW50IHRvIGpzb25iLgoKQXV0aG9yOiBOaWtpdGEgR2x1a2hvdiA8bi5n bHVob3ZAcG9zdGdyZXNwcm8ucnU+CkF1dGhvcjogVGVvZG9yIFNpZ2FldiA8dGVvZG9yQHNpZ2Fl di5ydT4KQXV0aG9yOiBPbGVnIEJhcnR1bm92IDxvYmFydHVub3ZAZ21haWwuY29tPgpBdXRob3I6 IEFsZXhhbmRlciBLb3JvdGtvdiA8YWVrb3JvdGtvdkBnbWFpbC5jb20+CkF1dGhvcjogQW5kcmV3 IER1bnN0YW4gPGFuZHJld0BkdW5zbGFuZS5uZXQ+CkF1dGhvcjogQW1pdCBMYW5nb3RlIDxhbWl0 bGFuZ290ZTA5QGdtYWlsLmNvbT4KQXV0aG9yOiBQZXRlciBFaXNlbnRyYXV0IDxwZXRlckBlaXNl bnRyYXV0Lm9yZz4KQXV0aG9yOiBKaWFuIEhlIDxqaWFuLnVuaXZlcnNhbGl0eUBnbWFpbC5jb20+ CgpSZXZpZXdlcnMgaGF2ZSBpbmNsdWRlZCAoaW4gbm8gcGFydGljdWxhciBvcmRlcikgQW5kcmVz IEZyZXVuZCwgQWxleGFuZGVyCktvcm90a292LCBQYXZlbCBTdGVodWxlLCBBbmRyZXcgQWxzdXAs IEVyaWsgUmlqa2VycywgWmlob25nIFl1LApIaW1hbnNodSBVcGFkaHlheWEsIERhbmllbCBHdXN0 YWZzc29uLCBKdXN0aW4gUHJ5emJ5LCDDgWx2YXJvIEhlcnJlcmEsCmppYW4gaGUsIEFudG9uIEEu IE1lbG5pa292LCBOaWtpdGEgTWFsYWtob3YsIFBldGVyIEVpc2VudHJhdXQKCkRpc2N1c3Npb246 IGh0dHBzOi8vcG9zdGdyLmVzL20vY2QwYmI5MzUtMDE1OC03OGE3LTA4YjUtOTA0ODg2ZGVhYzRi QHBvc3RncmVzcHJvLnJ1CkRpc2N1c3Npb246IGh0dHBzOi8vcG9zdGdyLmVzL20vMjAyMjA2MTYy MzMxMzAucnBhcml2YWZpcHQ2ZG9qM0BhbGFwMy5hbmFyYXplbC5kZQpEaXNjdXNzaW9uOiBodHRw czovL3Bvc3Rnci5lcy9tL2FiZDliODNiLWFhNjYtZjIzMC0zZDZkLTczNDgxN2YwOTk1ZCU0MHBv c3RncmVzcWwub3JnCkRpc2N1c3Npb246IGh0dHBzOi8vcG9zdGdyLmVzL20vQ0ErSGl3cUU0WFRk ZmIxblc9T2pveV90UVNSaFl0LXFfa2I2aTVkNHhjS3lyTEMxTmJnQG1haWwuZ21haWwuY29tCi0t LQogZG9jL3NyYy9zZ21sL2Z1bmMuc2dtbCAgICAgICAgICAgICAgICAgICAgICB8ICAxNjIgKysr CiBzcmMvYmFja2VuZC9jYXRhbG9nL3NxbF9mZWF0dXJlcy50eHQgICAgICAgIHwgICAxMiArLQog c3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY0V4cHIuYyAgICAgICAgICAgICB8ICAzNDQgKysrKysr CiBzcmMvYmFja2VuZC9leGVjdXRvci9leGVjRXhwckludGVycC5jICAgICAgIHwgIDM3MCArKysr KystCiBzcmMvYmFja2VuZC9qaXQvbGx2bS9sbHZtaml0X2V4cHIuYyAgICAgICAgIHwgIDE0MCAr KysKIHNyYy9iYWNrZW5kL2ppdC9sbHZtL2xsdm1qaXRfdHlwZXMuYyAgICAgICAgfCAgICAzICsK IHNyYy9iYWNrZW5kL25vZGVzL21ha2VmdW5jcy5jICAgICAgICAgICAgICAgfCAgIDE4ICsKIHNy Yy9iYWNrZW5kL25vZGVzL25vZGVGdW5jcy5jICAgICAgICAgICAgICAgfCAgMjMzICsrKy0KIHNy Yy9iYWNrZW5kL29wdGltaXplci9wYXRoL2Nvc3RzaXplLmMgICAgICAgfCAgICAzICstCiBzcmMv YmFja2VuZC9vcHRpbWl6ZXIvdXRpbC9jbGF1c2VzLmMgICAgICAgIHwgICAxOSArCiBzcmMvYmFj a2VuZC9wYXJzZXIvZ3JhbS55ICAgICAgICAgICAgICAgICAgIHwgIDE4OCArKystCiBzcmMvYmFj a2VuZC9wYXJzZXIvcGFyc2VfZXhwci5jICAgICAgICAgICAgIHwgIDYxMSArKysrKysrKysrLQog c3JjL2JhY2tlbmQvcGFyc2VyL3BhcnNlX3RhcmdldC5jICAgICAgICAgICB8ICAgMTUgKwogc3Jj L2JhY2tlbmQvdXRpbHMvYWR0L2pzb25wYXRoX2V4ZWMuYyAgICAgICB8ICAgIDIgKy0KIHNyYy9i YWNrZW5kL3V0aWxzL2FkdC9ydWxldXRpbHMuYyAgICAgICAgICAgfCAgMTM2ICsrKwogc3JjL2lu Y2x1ZGUvZXhlY3V0b3IvZXhlY0V4cHIuaCAgICAgICAgICAgICB8ICAgMjQgKy0KIHNyYy9pbmNs dWRlL25vZGVzL2V4ZWNub2Rlcy5oICAgICAgICAgICAgICAgfCAgIDg2ICsrCiBzcmMvaW5jbHVk ZS9ub2Rlcy9tYWtlZnVuY3MuaCAgICAgICAgICAgICAgIHwgICAgMiArCiBzcmMvaW5jbHVkZS9u b2Rlcy9wYXJzZW5vZGVzLmggICAgICAgICAgICAgIHwgICA0NyArCiBzcmMvaW5jbHVkZS9ub2Rl cy9wcmltbm9kZXMuaCAgICAgICAgICAgICAgIHwgIDE2NCArKysKIHNyYy9pbmNsdWRlL3BhcnNl ci9rd2xpc3QuaCAgICAgICAgICAgICAgICAgfCAgIDExICsKIHNyYy9pbnRlcmZhY2VzL2VjcGcv cHJlcHJvYy9lY3BnLnRyYWlsZXIgICAgfCAgIDI4ICsKIHNyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0 ZWQvanNvbl9zcWxqc29uLm91dCAgfCAgIDE4ICsKIHNyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQv anNvbmJfc3FsanNvbi5vdXQgfCAxMDczICsrKysrKysrKysrKysrKysrKysKIHNyYy90ZXN0L3Jl Z3Jlc3MvcGFyYWxsZWxfc2NoZWR1bGUgICAgICAgICAgfCAgICAyICstCiBzcmMvdGVzdC9yZWdy ZXNzL3NxbC9qc29uX3NxbGpzb24uc3FsICAgICAgIHwgICAxMSArCiBzcmMvdGVzdC9yZWdyZXNz L3NxbC9qc29uYl9zcWxqc29uLnNxbCAgICAgIHwgIDM1MCArKysrKysKIHNyYy90b29scy9wZ2lu ZGVudC90eXBlZGVmcy5saXN0ICAgICAgICAgICAgfCAgIDE3ICsKIDI4IGZpbGVzIGNoYW5nZWQs IDQwNTMgaW5zZXJ0aW9ucygrKSwgMzYgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQg c3JjL3Rlc3QvcmVncmVzcy9leHBlY3RlZC9qc29uX3NxbGpzb24ub3V0CiBjcmVhdGUgbW9kZSAx MDA2NDQgc3JjL3Rlc3QvcmVncmVzcy9leHBlY3RlZC9qc29uYl9zcWxqc29uLm91dAogY3JlYXRl IG1vZGUgMTAwNjQ0IHNyYy90ZXN0L3JlZ3Jlc3Mvc3FsL2pzb25fc3FsanNvbi5zcWwKIGNyZWF0 ZSBtb2RlIDEwMDY0NCBzcmMvdGVzdC9yZWdyZXNzL3NxbC9qc29uYl9zcWxqc29uLnNxbAoKZGlm ZiAtLWdpdCBhL2RvYy9zcmMvc2dtbC9mdW5jLnNnbWwgYi9kb2Mvc3JjL3NnbWwvZnVuYy5zZ21s CmluZGV4IGNlYzIxZTQyYzAuLjIxZmQ2NzEyYjggMTAwNjQ0Ci0tLSBhL2RvYy9zcmMvc2dtbC9m dW5jLnNnbWwKKysrIGIvZG9jL3NyYy9zZ21sL2Z1bmMuc2dtbApAQCAtMTgxNjIsNiArMTgxNjIs MTY4IEBAICQuKiA/IChAIGxpa2VfcmVnZXggIl5cXGQrJCIpCiA8L3Byb2dyYW1saXN0aW5nPgog ICAgIDwvcGFyYT4KICAgIDwvc2VjdDM+CisKKyAgIDxzZWN0MyBpZD0ic3FsanNvbi1xdWVyeS1m dW5jdGlvbnMiPgorICAgIDx0aXRsZT5TUUwvSlNPTiBRdWVyeSBGdW5jdGlvbnM8L3RpdGxlPgor ICA8cGFyYT4KKyAgIDx4cmVmIGxpbmtlbmQ9ImZ1bmN0aW9ucy1zcWxqc29uLXF1ZXJ5aW5nIi8+ IGRldGFpbHMgdGhlIFNRTC9KU09OCisgICBmdW5jdGlvbnMgdGhhdCBjYW4gYmUgdXNlZCB0byBx dWVyeSBKU09OIGRhdGEuCisgIDwvcGFyYT4KKworICA8bm90ZT4KKyAgIDxwYXJhPgorICAgIFNR TC9KU09OIHBhdGggZXhwcmVzc2lvbiBjYW4gY3VycmVudGx5IG9ubHkgYWNjZXB0IHZhbHVlcyBv ZiB0aGUKKyAgICA8dHlwZT5qc29uYjwvdHlwZT4gdHlwZSwgc28gaXQgbWlnaHQgYmUgbmVjZXNz YXJ5IHRvIGNhc3QgdGhlCisgICAgPHJlcGxhY2VhYmxlPmNvbnRleHRfaXRlbTwvcmVwbGFjZWFi bGU+IGFyZ3VtZW50IG9mIHRoZXNlIGZ1bmN0aW9ucyB0bworICAgIDx0eXBlPmpzb25iPC90eXBl Pi4KKyAgIDwvcGFyYT4KKyAgPC9ub3RlPgorCisgIDx0YWJsZSBpZD0iZnVuY3Rpb25zLXNxbGpz b24tcXVlcnlpbmciPgorICAgPHRpdGxlPlNRTC9KU09OIFF1ZXJ5IEZ1bmN0aW9uczwvdGl0bGU+ CisgICA8dGdyb3VwIGNvbHM9IjEiPgorICAgIDx0aGVhZD4KKyAgICAgPHJvdz4KKyAgICAgIDxl bnRyeSByb2xlPSJmdW5jX3RhYmxlX2VudHJ5Ij48cGFyYSByb2xlPSJmdW5jX3NpZ25hdHVyZSI+ CisgICAgICAgIEZ1bmN0aW9uIHNpZ25hdHVyZQorICAgICAgIDwvcGFyYT4KKyAgICAgICA8cGFy YT4KKyAgICAgICAgRGVzY3JpcHRpb24KKyAgICAgICA8L3BhcmE+CisgICAgICAgPHBhcmE+Cisg ICAgICAgIEV4YW1wbGUocykKKyAgICAgIDwvcGFyYT48L2VudHJ5PgorICAgICA8L3Jvdz4KKyAg ICA8L3RoZWFkPgorICAgIDx0Ym9keT4KKyAgICAgPHJvdz4KKyAgICAgIDxlbnRyeSByb2xlPSJm dW5jX3RhYmxlX2VudHJ5Ij48cGFyYSByb2xlPSJmdW5jX3NpZ25hdHVyZSI+CisgICAgICAgIDxp bmRleHRlcm0+PHByaW1hcnk+anNvbl9leGlzdHM8L3ByaW1hcnk+PC9pbmRleHRlcm0+CisgICAg ICAgIDxmdW5jdGlvbj5qc29uX2V4aXN0czwvZnVuY3Rpb24+ICgKKyAgICAgICAgPHJlcGxhY2Vh YmxlPmNvbnRleHRfaXRlbTwvcmVwbGFjZWFibGU+LCA8cmVwbGFjZWFibGU+cGF0aF9leHByZXNz aW9uPC9yZXBsYWNlYWJsZT4gPG9wdGlvbmFsPiA8bGl0ZXJhbD5QQVNTSU5HPC9saXRlcmFsPiB7 IDxyZXBsYWNlYWJsZT52YWx1ZTwvcmVwbGFjZWFibGU+IDxsaXRlcmFsPkFTPC9saXRlcmFsPiA8 cmVwbGFjZWFibGU+dmFybmFtZTwvcmVwbGFjZWFibGU+IH0gPG9wdGlvbmFsPiwgLi4uPC9vcHRp b25hbD48L29wdGlvbmFsPgorICAgICAgICA8b3B0aW9uYWw+IHsgPGxpdGVyYWw+VFJVRTwvbGl0 ZXJhbD4gfCA8bGl0ZXJhbD5GQUxTRTwvbGl0ZXJhbD4gfDxsaXRlcmFsPiBVTktOT1dOPC9saXRl cmFsPiB8IDxsaXRlcmFsPkVSUk9SPC9saXRlcmFsPiB9IDxsaXRlcmFsPk9OIEVSUk9SPC9saXRl cmFsPiA8L29wdGlvbmFsPikKKyAgICAgICA8L3BhcmE+CisgICAgICAgPHBhcmE+CisgICAgICAg IFJldHVybnMgdHJ1ZSBpZiB0aGUgU1FML0pTT04gPHJlcGxhY2VhYmxlPnBhdGhfZXhwcmVzc2lv bjwvcmVwbGFjZWFibGU+CisgICAgICAgIGFwcGxpZWQgdG8gdGhlIDxyZXBsYWNlYWJsZT5jb250 ZXh0X2l0ZW08L3JlcGxhY2VhYmxlPiB1c2luZyB0aGUKKyAgICAgICAgPHJlcGxhY2VhYmxlPnZh bHVlPC9yZXBsYWNlYWJsZT5zIHlpZWxkcyBhbnkgaXRlbXMuCisgICAgICAgIFRoZSA8bGl0ZXJh bD5PTiBFUlJPUjwvbGl0ZXJhbD4gY2xhdXNlIHNwZWNpZmllcyB0aGUgYmVoYXZpb3IgaWYKKyAg ICAgICAgYW4gZXJyb3Igb2NjdXJzOyB0aGUgZGVmYXVsdCBpcyB0byByZXR1cm4gdGhlIDx0eXBl PmJvb2xlYW48L3R5cGU+CisgICAgICAgIDxsaXRlcmFsPkZBTFNFPC9saXRlcmFsPiB2YWx1ZS4K KyAgICAgICAgTm90ZSB0aGF0IGlmIHRoZSA8cmVwbGFjZWFibGU+cGF0aF9leHByZXNzaW9uPC9y ZXBsYWNlYWJsZT4KKyAgICAgICAgaXMgPGxpdGVyYWw+c3RyaWN0PC9saXRlcmFsPiwgYW4gZXJy b3IgaXMgZ2VuZXJhdGVkIGlmIGl0IHlpZWxkcyBubworICAgICAgICBpdGVtcywgcHJvdmlkZWQg dGhlIHNwZWNpZmllZCA8bGl0ZXJhbD5PTiBFUlJPUjwvbGl0ZXJhbD4gYmVoYXZpb3IgaXMKKyAg ICAgICAgPGxpdGVyYWw+RVJST1I8L2xpdGVyYWw+LgorICAgICAgIDwvcGFyYT4KKyAgICAgICA8 cGFyYT4KKyAgICAgICAgPGxpdGVyYWw+anNvbl9leGlzdHMoanNvbmIgJ3sia2V5MSI6IFsxLDIs M119JywgJ3N0cmljdCAkLmtleTFbKl0gPyAoQCA+IDIpJyk8L2xpdGVyYWw+CisgICAgICAgIDxy ZXR1cm52YWx1ZT50PC9yZXR1cm52YWx1ZT4KKyAgICAgICA8L3BhcmE+CisgICAgICAgPHBhcmE+ CisgICAgICAgIDxsaXRlcmFsPmpzb25fZXhpc3RzKGpzb25iICd7ImEiOiBbMSwyLDNdfScsICds YXggJC5hWzVdJyBFUlJPUiBPTiBFUlJPUik8L2xpdGVyYWw+CisgICAgICAgIDxyZXR1cm52YWx1 ZT5mPC9yZXR1cm52YWx1ZT4KKyAgICAgICA8L3BhcmE+CisgICAgICAgPHBhcmE+CisgICAgICAg IDxsaXRlcmFsPmpzb25fZXhpc3RzKGpzb25iICd7ImEiOiBbMSwyLDNdfScsICdzdHJpY3QgJC5h WzVdJyBFUlJPUiBPTiBFUlJPUik8L2xpdGVyYWw+CisgICAgICAgIDxyZXR1cm52YWx1ZT5FUlJP UjogIGpzb25wYXRoIGFycmF5IHN1YnNjcmlwdCBpcyBvdXQgb2YgYm91bmRzPC9yZXR1cm52YWx1 ZT4KKyAgICAgIDwvcGFyYT48L2VudHJ5PgorICAgICA8L3Jvdz4KKyAgICAgPHJvdz4KKyAgICAg IDxlbnRyeSByb2xlPSJmdW5jX3RhYmxlX2VudHJ5Ij48cGFyYSByb2xlPSJmdW5jX3NpZ25hdHVy ZSI+CisgICAgICAgIDxpbmRleHRlcm0+PHByaW1hcnk+anNvbl9xdWVyeTwvcHJpbWFyeT48L2lu ZGV4dGVybT4KKyAgICAgICAgPGZ1bmN0aW9uPmpzb25fcXVlcnk8L2Z1bmN0aW9uPiAoCisgICAg ICAgIDxyZXBsYWNlYWJsZT5jb250ZXh0X2l0ZW08L3JlcGxhY2VhYmxlPiwgPHJlcGxhY2VhYmxl PnBhdGhfZXhwcmVzc2lvbjwvcmVwbGFjZWFibGU+IDxvcHRpb25hbD4gPGxpdGVyYWw+UEFTU0lO RzwvbGl0ZXJhbD4geyA8cmVwbGFjZWFibGU+dmFsdWU8L3JlcGxhY2VhYmxlPiA8bGl0ZXJhbD5B UzwvbGl0ZXJhbD4gPHJlcGxhY2VhYmxlPnZhcm5hbWU8L3JlcGxhY2VhYmxlPiB9IDxvcHRpb25h bD4sIC4uLjwvb3B0aW9uYWw+PC9vcHRpb25hbD4KKyAgICAgICAgPG9wdGlvbmFsPiA8bGl0ZXJh bD5SRVRVUk5JTkc8L2xpdGVyYWw+IDxyZXBsYWNlYWJsZT5kYXRhX3R5cGU8L3JlcGxhY2VhYmxl PiA8b3B0aW9uYWw+IDxsaXRlcmFsPkZPUk1BVCBKU09OPC9saXRlcmFsPiA8b3B0aW9uYWw+IDxs aXRlcmFsPkVOQ09ESU5HIFVURjg8L2xpdGVyYWw+IDwvb3B0aW9uYWw+IDwvb3B0aW9uYWw+IDwv b3B0aW9uYWw+CisgICAgICAgIDxvcHRpb25hbD4geyA8bGl0ZXJhbD5XSVRIT1VUPC9saXRlcmFs PiB8IDxsaXRlcmFsPldJVEg8L2xpdGVyYWw+IHsgPGxpdGVyYWw+Q09ORElUSU9OQUw8L2xpdGVy YWw+IHwgPG9wdGlvbmFsPjxsaXRlcmFsPlVOQ09ORElUSU9OQUw8L2xpdGVyYWw+PC9vcHRpb25h bD4gfSB9IDxvcHRpb25hbD4gPGxpdGVyYWw+QVJSQVk8L2xpdGVyYWw+IDwvb3B0aW9uYWw+IDxs aXRlcmFsPldSQVBQRVI8L2xpdGVyYWw+IDwvb3B0aW9uYWw+CisgICAgICAgIDxvcHRpb25hbD4g eyA8bGl0ZXJhbD5LRUVQPC9saXRlcmFsPiB8IDxsaXRlcmFsPk9NSVQ8L2xpdGVyYWw+IH0gPGxp dGVyYWw+UVVPVEVTPC9saXRlcmFsPiA8b3B0aW9uYWw+IDxsaXRlcmFsPk9OIFNDQUxBUiBTVFJJ Tkc8L2xpdGVyYWw+IDwvb3B0aW9uYWw+IDwvb3B0aW9uYWw+CisgICAgICAgIDxvcHRpb25hbD4g eyA8bGl0ZXJhbD5FUlJPUjwvbGl0ZXJhbD4gfCA8bGl0ZXJhbD5OVUxMPC9saXRlcmFsPiB8IDxs aXRlcmFsPkVNUFRZPC9saXRlcmFsPiB7IDxvcHRpb25hbD4gPGxpdGVyYWw+QVJSQVk8L2xpdGVy YWw+IDwvb3B0aW9uYWw+IHwgPGxpdGVyYWw+T0JKRUNUPC9saXRlcmFsPiB9IHwgPGxpdGVyYWw+ REVGQVVMVDwvbGl0ZXJhbD4gPHJlcGxhY2VhYmxlPmV4cHJlc3Npb248L3JlcGxhY2VhYmxlPiB9 IDxsaXRlcmFsPk9OIEVNUFRZPC9saXRlcmFsPiA8L29wdGlvbmFsPgorICAgICAgICA8b3B0aW9u YWw+IHsgPGxpdGVyYWw+RVJST1I8L2xpdGVyYWw+IHwgPGxpdGVyYWw+TlVMTDwvbGl0ZXJhbD4g fCA8bGl0ZXJhbD5FTVBUWTwvbGl0ZXJhbD4geyA8b3B0aW9uYWw+IDxsaXRlcmFsPkFSUkFZPC9s aXRlcmFsPiA8L29wdGlvbmFsPiB8IDxsaXRlcmFsPk9CSkVDVDwvbGl0ZXJhbD4gfSB8IDxsaXRl cmFsPkRFRkFVTFQ8L2xpdGVyYWw+IDxyZXBsYWNlYWJsZT5leHByZXNzaW9uPC9yZXBsYWNlYWJs ZT4gfSA8bGl0ZXJhbD5PTiBFUlJPUjwvbGl0ZXJhbD4gPC9vcHRpb25hbD4pCisgICAgICA8L3Bh cmE+CisgICAgICAgPHBhcmE+CisgICAgICAgIFJldHVybnMgdGhlIHJlc3VsdCBvZiBhcHBseWlu ZyB0aGUKKyAgICAgICAgPHJlcGxhY2VhYmxlPnBhdGhfZXhwcmVzc2lvbjwvcmVwbGFjZWFibGU+ IHRvIHRoZQorICAgICAgICA8cmVwbGFjZWFibGU+Y29udGV4dF9pdGVtPC9yZXBsYWNlYWJsZT4g dXNpbmcgdGhlCisgICAgICAgIDxyZXBsYWNlYWJsZT52YWx1ZTwvcmVwbGFjZWFibGU+cy4KKyAg ICAgICAgVGhpcyBmdW5jdGlvbiBtdXN0IHJldHVybiBhIEpTT04gc3RyaW5nLCBzbyBpZiB0aGUg cGF0aCBleHByZXNzaW9uCisgICAgICAgIHJldHVybnMgbXVsdGlwbGUgU1FML0pTT04gaXRlbXMs IHlvdSBtdXN0IHdyYXAgdGhlIHJlc3VsdCB1c2luZyB0aGUKKyAgICAgICAgPGxpdGVyYWw+V0lU SCBXUkFQUEVSPC9saXRlcmFsPiBjbGF1c2UuIElmIHRoZSB3cmFwcGVyIGlzCisgICAgICAgIDxs aXRlcmFsPlVOQ09ORElUSU9OQUw8L2xpdGVyYWw+LCBhbiBhcnJheSB3cmFwcGVyIHdpbGwgYWx3 YXlzCisgICAgICAgIGJlIGFwcGxpZWQsIGV2ZW4gaWYgdGhlIHJldHVybmVkIHZhbHVlIGlzIGFs cmVhZHkgYSBzaW5nbGUgSlNPTiBvYmplY3QKKyAgICAgICAgb3IgYW4gYXJyYXksIGJ1dCBpZiBp dCBpcyA8bGl0ZXJhbD5DT05ESVRJT05BTDwvbGl0ZXJhbD4sIGl0IHdpbGwgbm90IGJlCisgICAg ICAgIGFwcGxpZWQgdG8gYSBzaW5nbGUgYXJyYXkgb3Igb2JqZWN0LiA8bGl0ZXJhbD5VTkNPTkRJ VElPTkFMPC9saXRlcmFsPgorICAgICAgICBpcyB0aGUgZGVmYXVsdC4gIElmIHRoZSByZXN1bHQg aXMgYSBzY2FsYXIgc3RyaW5nLCBieSBkZWZhdWx0IHRoZSB2YWx1ZQorICAgICAgICByZXR1cm5l ZCB3aWxsIGhhdmUgc3Vycm91bmRpbmcgcXVvdGVzIG1ha2luZyBpdCBhIHZhbGlkIEpTT04gdmFs dWUsCisgICAgICAgIHdoaWNoIGNhbiBiZSBtYWRlIGV4cGxpY2l0IGJ5IHNwZWNpZnlpbmcgPGxp dGVyYWw+S0VFUCBRVU9URVM8L2xpdGVyYWw+LgorICAgICAgICBDb252ZXJzZWx5LCBxdW90ZXMg Y2FuIGJlIG9taXR0ZWQgYnkgc3BlY2lmeWluZyA8bGl0ZXJhbD5PTUlUIFFVT1RFUzwvbGl0ZXJh bD4uCisgICAgICAgIFRoZSA8bGl0ZXJhbD5SRVRVUk5JTkc8L2xpdGVyYWw+IGNsYXVzZSBjYW4g YmUgdXNlZCB0byBzcGVjaWZ5IHRoZQorICAgICAgICA8cmVwbGFjZWFibGU+ZGF0YV90eXBlPC9y ZXBsYWNlYWJsZT4gb2YgdGhlIHJlc3VsdCB2YWx1ZS4gIEl0IG11c3QKKyAgICAgICAgYmUgYSB0 eXBlIGZvciB3aGljaCB0aGVyZSBpcyBhIGNhc3QgZnJvbSA8dHlwZT50ZXh0PC90eXBlPiB0byB0 aGF0IHR5cGUuCisgICAgICAgIElmIG5vIDxsaXRlcmFsPlJFVFVSTklORzwvbGl0ZXJhbD4gaXMg c3BjaWZpZWQsIHRoZSByZXR1cm5lZCB2YWx1ZSB3aWxsCisgICAgICAgIGJlIG9mIHR5cGUgPHR5 cGU+anNvbmI8L3R5cGU+LgorICAgICAgICBUaGUgPGxpdGVyYWw+T04gRU1QVFk8L2xpdGVyYWw+ IGNsYXVzZSBzcGVjaWZpZXMgdGhlIGJlaGF2aW9yIGlmIHRoZQorICAgICAgICA8cmVwbGFjZWFi bGU+cGF0aF9leHByZXNzaW9uPC9yZXBsYWNlYWJsZT4geWllbGRzIG5vIHZhbHVlIGF0IGFsbDsg dGhlCisgICAgICAgIGRlZmF1bHQgd2hlbiA8bGl0ZXJhbD5PTiBFTVBUWTwvbGl0ZXJhbD4gaXMg bm90IHNwZWNpZmllZCBpcyB0byByZXR1cm4gYQorICAgICAgICBudWxsIHZhbHVlLiAgVGhlIDxs aXRlcmFsPk9OIEVSUk9SPC9saXRlcmFsPiBjbGF1c2Ugc3BlY2lmaWVzIHRoZSBiZWhhdmlvcgor ICAgICAgICBpZiBhbiBlcnJvciBvY2N1cnMgYXMgYSByZXN1bHQgb2YgPHR5cGU+anNvbnBhdGg8 L3R5cGU+IGV2YWx1YXRpb24KKyAgICAgICAgKGluY2x1ZGluZyBjYXN0IHRvIHRoZSBvdXRwdXQg dHlwZSkgb3IgZHVyaW5nIHRoZSBleGVjdXRpb24gb2YKKyAgICAgICAgPGxpdGVyYWw+T04gRU1Q VFk8L2xpdGVyYWw+IGJlaGF2aW9yICh0aGF0IHdhcyBjYXVzZWQgYnkgZW1wdHkgcmVzdWx0IG9m CisgICAgICAgIDx0eXBlPmpzb25wYXRoPC90eXBlPiBldmFsdWF0aW9uKTsgdGhlIGRlZmF1bHQg d2hlbgorICAgICAgICA8bGl0ZXJhbD5PTiBFUlJPUjwvbGl0ZXJhbD4gaXMgbm90IHNwZWNpZmll ZCBpcyB0byByZXR1cm4gYSBudWxsIHZhbHVlLgorICAgICAgIDwvcGFyYT4KKyAgICAgICA8cGFy YT4KKyAgICAgICAgPGxpdGVyYWw+anNvbl9xdWVyeShqc29uYiAnWzEsWzIsM10sbnVsbF0nLCAn bGF4ICRbKl1bMV0nIFdJVEggQ09ORElUSU9OQUwgV1JBUFBFUik8L2xpdGVyYWw+CisgICAgICAg IDxyZXR1cm52YWx1ZT5bM108L3JldHVybnZhbHVlPgorICAgICAgPC9wYXJhPjwvZW50cnk+Cisg ICAgIDwvcm93PgorICAgICA8cm93PgorICAgICAgPGVudHJ5IHJvbGU9ImZ1bmNfdGFibGVfZW50 cnkiPjxwYXJhIHJvbGU9ImZ1bmNfc2lnbmF0dXJlIj4KKyAgICAgICAgPGluZGV4dGVybT48cHJp bWFyeT5qc29uX3ZhbHVlPC9wcmltYXJ5PjwvaW5kZXh0ZXJtPgorICAgICAgICA8ZnVuY3Rpb24+ anNvbl92YWx1ZTwvZnVuY3Rpb24+ICgKKyAgICAgICAgPHJlcGxhY2VhYmxlPmNvbnRleHRfaXRl bTwvcmVwbGFjZWFibGU+LCA8cmVwbGFjZWFibGU+cGF0aF9leHByZXNzaW9uPC9yZXBsYWNlYWJs ZT4KKyAgICAgICAgPG9wdGlvbmFsPiA8bGl0ZXJhbD5QQVNTSU5HPC9saXRlcmFsPiB7IDxyZXBs YWNlYWJsZT52YWx1ZTwvcmVwbGFjZWFibGU+IDxsaXRlcmFsPkFTPC9saXRlcmFsPiA8cmVwbGFj ZWFibGU+dmFybmFtZTwvcmVwbGFjZWFibGU+IH0gPG9wdGlvbmFsPiwgLi4uPC9vcHRpb25hbD48 L29wdGlvbmFsPgorICAgICAgICA8b3B0aW9uYWw+IDxsaXRlcmFsPlJFVFVSTklORzwvbGl0ZXJh bD4gPHJlcGxhY2VhYmxlPmRhdGFfdHlwZTwvcmVwbGFjZWFibGU+IDwvb3B0aW9uYWw+CisgICAg ICAgIDxvcHRpb25hbD4geyA8bGl0ZXJhbD5FUlJPUjwvbGl0ZXJhbD4gfCA8bGl0ZXJhbD5OVUxM PC9saXRlcmFsPiB8IDxsaXRlcmFsPkRFRkFVTFQ8L2xpdGVyYWw+IDxyZXBsYWNlYWJsZT5leHBy ZXNzaW9uPC9yZXBsYWNlYWJsZT4gfSA8bGl0ZXJhbD5PTiBFTVBUWTwvbGl0ZXJhbD4gPC9vcHRp b25hbD4KKyAgICAgICAgPG9wdGlvbmFsPiB7IDxsaXRlcmFsPkVSUk9SPC9saXRlcmFsPiB8IDxs aXRlcmFsPk5VTEw8L2xpdGVyYWw+IHwgPGxpdGVyYWw+REVGQVVMVDwvbGl0ZXJhbD4gPHJlcGxh Y2VhYmxlPmV4cHJlc3Npb248L3JlcGxhY2VhYmxlPiB9IDxsaXRlcmFsPk9OIEVSUk9SPC9saXRl cmFsPiA8L29wdGlvbmFsPikKKyAgICAgICA8L3BhcmE+CisgICAgICAgPHBhcmE+CisgICAgICAg IFJldHVybnMgdGhlIHJlc3VsdCBvZiBhcHBseWluZyB0aGUKKyAgICAgICAgPHJlcGxhY2VhYmxl PnBhdGhfZXhwcmVzc2lvbjwvcmVwbGFjZWFibGU+IHRvIHRoZQorICAgICAgICA8cmVwbGFjZWFi bGU+Y29udGV4dF9pdGVtPC9yZXBsYWNlYWJsZT4gdXNpbmcgdGhlCisgICAgICAgIDxsaXRlcmFs PlBBU1NJTkc8L2xpdGVyYWw+IDxyZXBsYWNlYWJsZT52YWx1ZTwvcmVwbGFjZWFibGU+cy4gVGhl CisgICAgICAgIGV4dHJhY3RlZCB2YWx1ZSBtdXN0IGJlIGEgc2luZ2xlIDxhY3JvbnltPlNRTC9K U09OPC9hY3JvbnltPiBzY2FsYXIKKyAgICAgICAgaXRlbS4gRm9yIHJlc3VsdHMgdGhhdCBhcmUg b2JqZWN0cyBvciBhcnJheXMsIHVzZSB0aGUKKyAgICAgICAgPGZ1bmN0aW9uPmpzb25fcXVlcnk8 L2Z1bmN0aW9uPiBmdW5jdGlvbiBpbnN0ZWFkLgorICAgICAgICBUaGUgPGxpdGVyYWw+UkVUVVJO SU5HPC9saXRlcmFsPiBjbGF1c2UgY2FuIGJlIHVzZWQgdG8gc3BlY2lmeSB0aGUKKyAgICAgICAg PHJlcGxhY2VhYmxlPmRhdGFfdHlwZTwvcmVwbGFjZWFibGU+IG9mIHRoZSByZXN1bHQgdmFsdWUu ICBJdCBtdXN0CisgICAgICAgIGJlIGEgdHlwZSBmb3Igd2hpY2ggdGhlcmUgYXJlIGNhc3RzIGZy b20gYWxsIHBvc3NpYmxlIEpTT04gc2NhbGFyCisgICAgICAgIHZhbHVlIHR5cGVzICg8dHlwZT50 ZXh0PC90eXBlPiwgPHR5cGU+Ym9vbGVhbjwvdHlwZT4sIDx0eXBlPm51bWVyaWM8L3R5cGU+LAor ICAgICAgICBhbmQgdmFyaW91cyBkYXRldGltZSB0eXBlcykgdG8gdGhhdCB0eXBlLiAgSWYgbm8g PGxpdGVyYWw+UkVUVVJOSU5HPC9saXRlcmFsPgorICAgICAgICBpcyBzcGNpZmllZCwgdGhlIHJl dHVybmVkIHZhbHVlIHdpbGwgYmUgb2YgdHlwZSA8dHlwZT50ZXh0PC90eXBlPi4KKyAgICAgICAg VGhlIDxsaXRlcmFsPk9OIEVSUk9SPC9saXRlcmFsPiBhbmQgPGxpdGVyYWw+T04gRU1QVFk8L2xp dGVyYWw+CisgICAgICAgIGNsYXVzZXMgaGF2ZSBzaW1pbGFyIHNlbWFudGljcyBhcyBtZW50aW9u ZWQgaW4gdGhlIGRlc2NyaXB0aW9uIG9mCisgICAgICAgIDxmdW5jdGlvbj5qc29uX3F1ZXJ5PC9m dW5jdGlvbj4uICBOb3RlIHRoYXQgc2NhbGFyIHN0cmluZ3MgcmV0dXJuZWQKKyAgICAgICAgYnkg PGZ1bmN0aW9uPmpzb25fdmFsdWU8L2Z1bmN0aW9uPiBhbHdheXMgaGF2ZSB0aGVpciBxdW90ZXMg cmVtb3ZlZCwKKyAgICAgICAgZXF1aXZhbGVudCB0byB3aGF0IG9uZSB3b3VsZCBnZXQgd2l0aCA8 bGl0ZXJhbD5PTUlUIFFVT1RFUzwvbGl0ZXJhbD4KKyAgICAgICAgd2hlbiB1c2luZyA8ZnVuY3Rp b24+anNvbl9xdWVyeTwvZnVuY3Rpb24+LgorICAgICAgIDwvcGFyYT4KKyAgICAgICA8cGFyYT4K KyAgICAgICAgPGxpdGVyYWw+anNvbl92YWx1ZShqc29uYiAnIjEyMy40NSInLCAnJCcgUkVUVVJO SU5HIGZsb2F0KTwvbGl0ZXJhbD4KKyAgICAgICAgPHJldHVybnZhbHVlPjEyMy40NTwvcmV0dXJu dmFsdWU+CisgICAgICAgPC9wYXJhPgorICAgICAgIDxwYXJhPgorICAgICAgICA8bGl0ZXJhbD5q c29uX3ZhbHVlKGpzb25iICciMDM6MDQgMjAxNS0wMi0wMSInLCAnJC5kYXRldGltZSgiSEgyNDpN SSZuYnNwO1lZWVktTU0tREQiKScgUkVUVVJOSU5HIGRhdGUpPC9saXRlcmFsPgorICAgICAgICA8 cmV0dXJudmFsdWU+MjAxNS0wMi0wMTwvcmV0dXJudmFsdWU+CisgICAgICAgPC9wYXJhPgorICAg ICAgIDxwYXJhPgorICAgICAgICA8bGl0ZXJhbD5qc29uX3ZhbHVlKGpzb25iICdbMSwyXScsICdz dHJpY3QgJFsqXScgREVGQVVMVCA5IE9OIEVSUk9SKTwvbGl0ZXJhbD4KKyAgICAgICAgPHJldHVy bnZhbHVlPjk8L3JldHVybnZhbHVlPgorICAgICAgPC9wYXJhPjwvZW50cnk+CisgICAgIDwvcm93 PgorICAgIDwvdGJvZHk+CisgICA8L3Rncm91cD4KKyAgPC90YWJsZT4KKworICAgPC9zZWN0Mz4K ICAgPC9zZWN0Mj4KICA8L3NlY3QxPgogCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jYXRhbG9n L3NxbF9mZWF0dXJlcy50eHQgYi9zcmMvYmFja2VuZC9jYXRhbG9nL3NxbF9mZWF0dXJlcy50eHQK aW5kZXggODBjNDBlYWY1Ny4uNzU5OGJkOGYyMiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY2F0 YWxvZy9zcWxfZmVhdHVyZXMudHh0CisrKyBiL3NyYy9iYWNrZW5kL2NhdGFsb2cvc3FsX2ZlYXR1 cmVzLnR4dApAQCAtNTQ4LDE1ICs1NDgsMTUgQEAgVDgxMQlCYXNpYyBTUUwvSlNPTiBjb25zdHJ1 Y3RvciBmdW5jdGlvbnMJCQlZRVMKIFQ4MTIJU1FML0pTT046IEpTT05fT0JKRUNUQUdHCQkJWUVT CQogVDgxMwlTUUwvSlNPTjogSlNPTl9BUlJBWUFHRyB3aXRoIE9SREVSIEJZCQkJWUVTCQogVDgx NAlDb2xvbiBpbiBKU09OX09CSkVDVCBvciBKU09OX09CSkVDVEFHRwkJCVlFUwkKLVQ4MjEJQmFz aWMgU1FML0pTT04gcXVlcnkgb3BlcmF0b3JzCQkJTk8JCitUODIxCUJhc2ljIFNRTC9KU09OIHF1 ZXJ5IG9wZXJhdG9ycwkJCVlFUwkKIFQ4MjIJU1FML0pTT046IElTIEpTT04gV0lUSCBVTklRVUUg S0VZUyBwcmVkaWNhdGUJCQlZRVMJCi1UODIzCVNRTC9KU09OOiBQQVNTSU5HIGNsYXVzZQkJCU5P CQorVDgyMwlTUUwvSlNPTjogUEFTU0lORyBjbGF1c2UJCQlZRVMJCiBUODI0CUpTT05fVEFCTEU6 IHNwZWNpZmljIFBMQU4gY2xhdXNlCQkJTk8JCi1UODI1CVNRTC9KU09OOiBPTiBFTVBUWSBhbmQg T04gRVJST1IgY2xhdXNlcwkJCU5PCQotVDgyNglHZW5lcmFsIHZhbHVlIGV4cHJlc3Npb24gaW4g T04gRVJST1Igb3IgT04gRU1QVFkgY2xhdXNlcwkJCU5PCQorVDgyNQlTUUwvSlNPTjogT04gRU1Q VFkgYW5kIE9OIEVSUk9SIGNsYXVzZXMJCQlZRVMJCitUODI2CUdlbmVyYWwgdmFsdWUgZXhwcmVz c2lvbiBpbiBPTiBFUlJPUiBvciBPTiBFTVBUWSBjbGF1c2VzCQkJWUVTCQogVDgyNwlKU09OX1RB QkxFOiBzaWJsaW5nIE5FU1RFRCBDT0xVTU5TIGNsYXVzZXMJCQlOTwkKLVQ4MjgJSlNPTl9RVUVS WQkJCU5PCQotVDgyOQlKU09OX1FVRVJZOiBhcnJheSB3cmFwcGVyIG9wdGlvbnMJCQlOTwkKK1Q4 MjgJSlNPTl9RVUVSWQkJCVlFUwkKK1Q4MjkJSlNPTl9RVUVSWTogYXJyYXkgd3JhcHBlciBvcHRp b25zCQkJWUVTCQogVDgzMAlFbmZvcmNpbmcgdW5pcXVlIGtleXMgaW4gU1FML0pTT04gY29uc3Ry dWN0b3IgZnVuY3Rpb25zCQkJWUVTCQogVDgzMQlTUUwvSlNPTiBwYXRoIGxhbmd1YWdlOiBzdHJp Y3QgbW9kZQkJCVlFUwkKIFQ4MzIJU1FML0pTT04gcGF0aCBsYW5ndWFnZTogaXRlbSBtZXRob2QJ CQlZRVMJCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjRXhwci5jIGIvc3Jj L2JhY2tlbmQvZXhlY3V0b3IvZXhlY0V4cHIuYwppbmRleCAzMTgxYjExMzZhLi5jZjBiNWU1YjAw IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjRXhwci5jCisrKyBiL3NyYy9i YWNrZW5kL2V4ZWN1dG9yL2V4ZWNFeHByLmMKQEAgLTQ5LDYgKzQ5LDcgQEAKICNpbmNsdWRlICJ1 dGlscy9idWlsdGlucy5oIgogI2luY2x1ZGUgInV0aWxzL2RhdHVtLmgiCiAjaW5jbHVkZSAidXRp bHMvanNvbmZ1bmNzLmgiCisjaW5jbHVkZSAidXRpbHMvanNvbnBhdGguaCIKICNpbmNsdWRlICJ1 dGlscy9sc3lzY2FjaGUuaCIKICNpbmNsdWRlICJ1dGlscy90eXBjYWNoZS5oIgogCkBAIC04OCw2 ICs4OSwxMiBAQCBzdGF0aWMgdm9pZCBFeGVjQnVpbGRBZ2dUcmFuc0NhbGwoRXhwclN0YXRlICpz dGF0ZSwgQWdnU3RhdGUgKmFnZ3N0YXRlLAogCQkJCQkJCQkgIEZ1bmN0aW9uQ2FsbEluZm8gZmNp bmZvLCBBZ2dTdGF0ZVBlclRyYW5zIHBlcnRyYW5zLAogCQkJCQkJCQkgIGludCB0cmFuc25vLCBp bnQgc2V0bm8sIGludCBzZXRvZmYsIGJvb2wgaXNoYXNoLAogCQkJCQkJCQkgIGJvb2wgbnVsbGNo ZWNrKTsKK3N0YXRpYyB2b2lkIEV4ZWNJbml0SnNvbkV4cHIoSnNvbkV4cHIgKmpleHByLCBFeHBy U3RhdGUgKnN0YXRlLAorCQkJCQkJCSBEYXR1bSAqcmVzdiwgYm9vbCAqcmVzbnVsbCwKKwkJCQkJ CQkgRXhwckV2YWxTdGVwICpzY3JhdGNoKTsKK3N0YXRpYyBpbnQgRXhlY0luaXRKc29uRXhwckNv ZXJjaW9uKEV4cHJTdGF0ZSAqc3RhdGUsIE5vZGUgKmNvZXJjaW9uLAorCQkJCQkJIEVycm9yU2F2 ZUNvbnRleHQgKmVzY29udGV4dCwKKwkJCQkJCSBEYXR1bSAqcmVzdiwgYm9vbCAqcmVzbnVsbCk7 CiAKIAogLyoKQEAgLTI0MTMsNiArMjQyMCwxNCBAQCBFeGVjSW5pdEV4cHJSZWMoRXhwciAqbm9k ZSwgRXhwclN0YXRlICpzdGF0ZSwKIAkJCQlicmVhazsKIAkJCX0KIAorCQljYXNlIFRfSnNvbkV4 cHI6CisJCQl7CisJCQkJSnNvbkV4cHIgICAqamV4cHIgPSBjYXN0Tm9kZShKc29uRXhwciwgbm9k ZSk7CisKKwkJCQlFeGVjSW5pdEpzb25FeHByKGpleHByLCBzdGF0ZSwgcmVzdiwgcmVzbnVsbCwg JnNjcmF0Y2gpOworCQkJCWJyZWFrOworCQkJfQorCiAJCWNhc2UgVF9OdWxsVGVzdDoKIAkJCXsK IAkJCQlOdWxsVGVzdCAgICpudGVzdCA9IChOdWxsVGVzdCAqKSBub2RlOwpAQCAtNDE4MSwzICs0 MTk2LDMzMiBAQCBFeGVjQnVpbGRQYXJhbVNldEVxdWFsKFR1cGxlRGVzYyBkZXNjLAogCiAJcmV0 dXJuIHN0YXRlOwogfQorCisvKgorICogUHVzaCBzdGVwcyB0byBldmFsdWF0ZSBhIEpzb25FeHBy IGFuZCBpdHMgdmFyaW91cyBzdWJzaWRpYXJ5IGV4cHJlc3Npb25zLgorICovCitzdGF0aWMgdm9p ZAorRXhlY0luaXRKc29uRXhwcihKc29uRXhwciAqamV4cHIsIEV4cHJTdGF0ZSAqc3RhdGUsCisJ CQkJIERhdHVtICpyZXN2LCBib29sICpyZXNudWxsLAorCQkJCSBFeHByRXZhbFN0ZXAgKnNjcmF0 Y2gpCit7CisJSnNvbkV4cHJTdGF0ZSAqanNlc3RhdGUgPSBwYWxsb2MwKHNpemVvZihKc29uRXhw clN0YXRlKSk7CisJSnNvbkV4cHJQb3N0RXZhbFN0YXRlICpwb3N0X2V2YWwgPSAmanNlc3RhdGUt PnBvc3RfZXZhbDsKKwlMaXN0Q2VsbCAgICphcmdleHBybGM7CisJTGlzdENlbGwgICAqYXJnbmFt ZWxjOworCUxpc3QJICAgKmp1bXBzX2lmX3NraXAgPSBOSUw7CisJTGlzdAkgICAqanVtcHNfdG9f Y29lcmNlX2ZpbmlzaCA9IE5JTDsKKwlMaXN0CSAgICpqdW1wc190b19lbmQgPSBOSUw7CisJTGlz dENlbGwgICAqbGM7CisJRXhwckV2YWxTdGVwICphczsKKworCWpzZXN0YXRlLT5qc2V4cHIgPSBq ZXhwcjsKKworCS8qCisJICogRXZhbHVhdGUgZm9ybWF0dGVkX2V4cHIgc3RvcmluZyB0aGUgcmVz dWx0IGludG8KKwkgKiBqc2VzdGF0ZS0+Zm9ybWF0dGVkX2V4cHIuCisJICovCisJRXhlY0luaXRF eHByUmVjKChFeHByICopIGpleHByLT5mb3JtYXR0ZWRfZXhwciwgc3RhdGUsCisJCQkJCSZqc2Vz dGF0ZS0+Zm9ybWF0dGVkX2V4cHIudmFsdWUsCisJCQkJCSZqc2VzdGF0ZS0+Zm9ybWF0dGVkX2V4 cHIuaXNudWxsKTsKKworCS8qIFN0ZXBzIHRvIGp1bXAgdG8gZW5kIGlmIGZvcm1hdHRlZF9leHBy IGV2YWx1YXRlcyB0byBOVUxMICovCisJc2NyYXRjaC0+b3Bjb2RlID0gRUVPUF9KVU1QX0lGX05V TEw7CisJc2NyYXRjaC0+cmVzbnVsbCA9ICZqc2VzdGF0ZS0+Zm9ybWF0dGVkX2V4cHIuaXNudWxs OworCXNjcmF0Y2gtPmQuanVtcC5qdW1wZG9uZSA9IC0xOwkvKiBzZXQgYmVsb3cgKi8KKwlqdW1w c19pZl9za2lwID0gbGFwcGVuZF9pbnQoanVtcHNfaWZfc2tpcCwgc3RhdGUtPnN0ZXBzX2xlbik7 CisJRXhwckV2YWxQdXNoU3RlcChzdGF0ZSwgc2NyYXRjaCk7CisKKwkvKgorCSAqIEV2YWx1YXRl IHBhdGhzcGVjIGV4cHJlc3Npb24gc3RvcmluZyB0aGUgcmVzdWx0IGludG8KKwkgKiBqc2VzdGF0 ZS0+cGF0aHNwZWMuCisJICovCisJRXhlY0luaXRFeHByUmVjKChFeHByICopIGpleHByLT5wYXRo X3NwZWMsIHN0YXRlLAorCQkJCQkmanNlc3RhdGUtPnBhdGhzcGVjLnZhbHVlLAorCQkJCQkmanNl c3RhdGUtPnBhdGhzcGVjLmlzbnVsbCk7CisKKwkvKiBTdGVwcyB0byBKVU1QIHRvIGVuZCBpZiBw YXRoc3BlYyBldmFsdWF0ZXMgdG8gTlVMTCAqLworCXNjcmF0Y2gtPm9wY29kZSA9IEVFT1BfSlVN UF9JRl9OVUxMOworCXNjcmF0Y2gtPnJlc251bGwgPSAmanNlc3RhdGUtPnBhdGhzcGVjLmlzbnVs bDsKKwlzY3JhdGNoLT5kLmp1bXAuanVtcGRvbmUgPSAtMTsJLyogc2V0IGJlbG93ICovCisJanVt cHNfaWZfc2tpcCA9IGxhcHBlbmRfaW50KGp1bXBzX2lmX3NraXAsIHN0YXRlLT5zdGVwc19sZW4p OworCUV4cHJFdmFsUHVzaFN0ZXAoc3RhdGUsIHNjcmF0Y2gpOworCisJLyogU3RlcHMgdG8gY29t cHV0ZSBQQVNTSU5HIGFyZ3MuICovCisJanNlc3RhdGUtPmFyZ3MgPSBOSUw7CisJZm9yYm90aChh cmdleHBybGMsIGpleHByLT5wYXNzaW5nX3ZhbHVlcywKKwkJCWFyZ25hbWVsYywgamV4cHItPnBh c3NpbmdfbmFtZXMpCisJeworCQlFeHByCSAgICphcmdleHByID0gKEV4cHIgKikgbGZpcnN0KGFy Z2V4cHJsYyk7CisJCVN0cmluZwkgICAqYXJnbmFtZSA9IGxmaXJzdF9ub2RlKFN0cmluZywgYXJn bmFtZWxjKTsKKwkJSnNvblBhdGhWYXJpYWJsZSAqdmFyID0gcGFsbG9jKHNpemVvZigqdmFyKSk7 CisKKwkJdmFyLT5uYW1lID0gYXJnbmFtZS0+c3ZhbDsKKwkJdmFyLT50eXBpZCA9IGV4cHJUeXBl KChOb2RlICopIGFyZ2V4cHIpOworCQl2YXItPnR5cG1vZCA9IGV4cHJUeXBtb2QoKE5vZGUgKikg YXJnZXhwcik7CisKKwkJRXhlY0luaXRFeHByUmVjKChFeHByICopIGFyZ2V4cHIsIHN0YXRlLCAm dmFyLT52YWx1ZSwgJnZhci0+aXNudWxsKTsKKworCQlqc2VzdGF0ZS0+YXJncyA9IGxhcHBlbmQo anNlc3RhdGUtPmFyZ3MsIHZhcik7CisJfQorCisJLyogU3RlcCBmb3IgSnNvblBhdGgqIGV2YWx1 YXRpb247IHNlZSBFeGVjRXZhbEpzb25FeHByUGF0aCgpLiAqLworCXNjcmF0Y2gtPm9wY29kZSA9 IEVFT1BfSlNPTkVYUFJfUEFUSDsKKwlzY3JhdGNoLT5yZXN2YWx1ZSA9IHJlc3Y7CisJc2NyYXRj aC0+cmVzbnVsbCA9IHJlc251bGw7CisJc2NyYXRjaC0+ZC5qc29uZXhwci5qc2VzdGF0ZSA9IGpz ZXN0YXRlOworCUV4cHJFdmFsUHVzaFN0ZXAoc3RhdGUsIHNjcmF0Y2gpOworCisJLyoKKwkgKiBT dGVwIHRvIGp1bXAgdG8gZW5kIHdoZW4gdGhlcmUncyBuZWl0aGVyIGFuIGVycm9yIHdoZW4gZXZh bHVhdGluZworCSAqIEpzb25QYXRoKiBub3IgYW55IG5lZWQgdG8gY29lcmNlIHRoZSByZXN1bHQg YmVjYXVzZSBpdCdzIGFscmVhZHkKKwkgKiBvZiB0aGUgc3BlY2lmaWVkIHR5cGUuCisJICovCisJ c2NyYXRjaC0+b3Bjb2RlID0gRUVPUF9KVU1QOworCXNjcmF0Y2gtPmQuanVtcC5qdW1wZG9uZSA9 IC0xOwkvKiBzZXQgYmVsb3cgKi8KKwlqdW1wc190b19lbmQgPSBsYXBwZW5kX2ludChqdW1wc190 b19lbmQsIHN0YXRlLT5zdGVwc19sZW4pOworCUV4cHJFdmFsUHVzaFN0ZXAoc3RhdGUsIHNjcmF0 Y2gpOworCisJLyoKKwkgKiBTdGVwcyB0byBjb2VyY2UgdGhlIHJlc3VsdCB2YWx1ZSBjb21wdXRl ZCBieSBFRU9QX0pTT05FWFBSX1BBVEguCisJICogVG8gaGFuZGxlIGNvZXJjaW9uIGVycm9ycyBz b2Z0bHksIHVzZSB0aGUgZm9sbG93aW5nIEVycm9yU2F2ZUNvbnRleHQKKwkgKiB3aGVuIGluaXRp YWxpemluZyB0aGUgY29lcmNpb24gZXhwcmVzc2lvbnMsIGluY2x1ZGluZyBhbnkgSnNvbkNvZXJj aW9uCisJICogbm9kZXMuCisJICovCisJanNlc3RhdGUtPmVzY29udGV4dC50eXBlID0gVF9FcnJv clNhdmVDb250ZXh0OworCWlmIChqZXhwci0+cmVzdWx0X2NvZXJjaW9uIHx8IGpleHByLT5vbWl0 X3F1b3RlcykKKwl7CisJCWpzZXN0YXRlLT5qdW1wX2V2YWxfcmVzdWx0X2NvZXJjaW9uID0KKwkJ CUV4ZWNJbml0SnNvbkV4cHJDb2VyY2lvbihzdGF0ZSwgamV4cHItPnJlc3VsdF9jb2VyY2lvbiwK KwkJCQkJCQkJCSBqZXhwci0+b25fZXJyb3ItPmJ0eXBlICE9IEpTT05fQkVIQVZJT1JfRVJST1Ig PworCQkJCQkJCQkJICZqc2VzdGF0ZS0+ZXNjb250ZXh0IDogTlVMTCwKKwkJCQkJCQkJCSByZXN2 LCByZXNudWxsKTsKKwkJLyogSnVtcCB0byBDT0VSQ0lPTl9GSU5JU0guICovCisJCXNjcmF0Y2gt Pm9wY29kZSA9IEVFT1BfSlVNUDsKKwkJc2NyYXRjaC0+ZC5qdW1wLmp1bXBkb25lID0gLTE7CS8q IHNldCBiZWxvdyAqLworCQlqdW1wc190b19jb2VyY2VfZmluaXNoID0gbGFwcGVuZF9pbnQoanVt cHNfdG9fY29lcmNlX2ZpbmlzaCwKKwkJCQkJCQkJCQkJIHN0YXRlLT5zdGVwc19sZW4pOworCQlF eHByRXZhbFB1c2hTdGVwKHN0YXRlLCBzY3JhdGNoKTsKKwl9CisJZWxzZQorCQlqc2VzdGF0ZS0+ anVtcF9ldmFsX3Jlc3VsdF9jb2VyY2lvbiA9IC0xOworCisJLyogU3RlcHMgZm9yIGNvZXJjaW5n IEpzb25JdGVtVHlwZSB2YWx1ZXMgcmV0dXJuZWQgYnkgSnNvblBhdGhWYWx1ZSgpLiAqLworCWlm IChqZXhwci0+aXRlbV9jb2VyY2lvbnMpCisJeworCQkvKgorCQkgKiBIZXJlIHdlIGNyZWF0ZSB0 aGUgc3RlcHMgZm9yIGVhY2ggSnNvbkl0ZW1UeXBlIHR5cGUncyBjb2VyY2lvbgorCQkgKiBleHBy ZXNzaW9uIGFuZCBhbHNvIHN0b3JlIGEgZmxhZyB3aGV0aGVyIHRoZSBleHByZXNzaW9uIGlzCisJ CSAqIGEgSnNvbkNvZXJjaW9uIG5vZGUuICBFeGVjUHJlcGFyZUpzb25JdGVtQ29lcmNpb24oKSBj YWxsZWQgYnkKKwkJICogRXhlY0V2YWxKc29uRXhwclBhdGgoKSB3aWxsIG1hcCBhIGdpdmVuIEpz b25iVmFsdWUgcmV0dXJuZWQgYnkKKwkJICogSnNvblBhdGhWYWx1ZSgpIHRvIGl0cyAgSnNvbkl0 ZW1UeXBlJ3MgZXhwcmVzc2lvbidzIHN0ZXAgYWRkcmVzcworCQkgKiBhbmQgdGhlIGZsYWcgYnkg aW5kZXhpbmcgdGhlIGZvbGxvd2luZyBhcnJheXMgd2l0aCBKc29uSXRlbVR5cGUKKwkJICogZW51 bSB2YWx1ZS4KKwkJICovCisJCWpzZXN0YXRlLT5udW1faXRlbV9jb2VyY2lvbnMgPSBsaXN0X2xl bmd0aChqZXhwci0+aXRlbV9jb2VyY2lvbnMpOworCQlqc2VzdGF0ZS0+ZXZhbF9pdGVtX2NvZXJj aW9uX2p1bXBzID0gKGludCAqKQorCQkJcGFsbG9jKGpzZXN0YXRlLT5udW1faXRlbV9jb2VyY2lv bnMgKiBzaXplb2YoaW50KSk7CisJCWpzZXN0YXRlLT5pdGVtX2NvZXJjaW9uX3ZpYV9leHByID0g KGJvb2wgKikKKwkJCXBhbGxvYzAoanNlc3RhdGUtPm51bV9pdGVtX2NvZXJjaW9ucyAqIHNpemVv Zihib29sKSk7CisJCWZvcmVhY2gobGMsIGpleHByLT5pdGVtX2NvZXJjaW9ucykKKwkJeworCQkJ SnNvbkl0ZW1Db2VyY2lvbiAqaXRlbV9jb2VyY2lvbiA9IGxmaXJzdChsYyk7CisJCQlOb2RlICpj b2VyY2lvbiA9IGl0ZW1fY29lcmNpb24tPmNvZXJjaW9uOworCisJCQlqc2VzdGF0ZS0+aXRlbV9j b2VyY2lvbl92aWFfZXhwcltpdGVtX2NvZXJjaW9uLT5pdGVtX3R5cGVdID0KKwkJCQkoY29lcmNp b24gIT0gTlVMTCAmJiAhSXNBKGNvZXJjaW9uLCBKc29uQ29lcmNpb24pKTsKKwkJCWpzZXN0YXRl LT5ldmFsX2l0ZW1fY29lcmNpb25fanVtcHNbaXRlbV9jb2VyY2lvbi0+aXRlbV90eXBlXSA9CisJ CQkJRXhlY0luaXRKc29uRXhwckNvZXJjaW9uKHN0YXRlLCBjb2VyY2lvbiwKKwkJCQkJCQkJCQkg amV4cHItPm9uX2Vycm9yLT5idHlwZSAhPSBKU09OX0JFSEFWSU9SX0VSUk9SID8KKwkJCQkJCQkJ CQkgJmpzZXN0YXRlLT5lc2NvbnRleHQgOiBOVUxMLAorCQkJCQkJCQkJCSByZXN2LCByZXNudWxs KTsKKworCQkJLyogSnVtcCB0byBDT0VSQ0lPTl9GSU5JU0guICovCisJCQlzY3JhdGNoLT5vcGNv ZGUgPSBFRU9QX0pVTVA7CisJCQlzY3JhdGNoLT5kLmp1bXAuanVtcGRvbmUgPSAtMTsJLyogc2V0 IGJlbG93ICovCisJCQlqdW1wc190b19jb2VyY2VfZmluaXNoID0gbGFwcGVuZF9pbnQoanVtcHNf dG9fY29lcmNlX2ZpbmlzaCwKKwkJCQkJCQkJCQkJCSBzdGF0ZS0+c3RlcHNfbGVuKTsKKwkJCUV4 cHJFdmFsUHVzaFN0ZXAoc3RhdGUsIHNjcmF0Y2gpOworCQl9CisJfQorCisJLyoKKwkgKiBBZGQg c3RlcCB0byByZXNldCB0aGUgRXJyb3JTYXZlQ29udGV4dCBhbmQgc2V0IGVycm9yIGZsYWcgaWYg dGhlCisJICogY29lcmNpb24gc3RlcHMgZW5jb3VudGVyZWQgYW4gZXJyb3IgYnV0IHdhcyBub3Qg dGhyb3duIGJlY2F1c2Ugb2YgdGhlCisJICogT04gRVJST1IgYmVoYXZpb3IuCisJICovCisJaWYg KGpleHByLT5yZXN1bHRfY29lcmNpb24gfHwgamV4cHItPml0ZW1fY29lcmNpb25zKQorCXsKKwkJ Zm9yZWFjaChsYywganVtcHNfdG9fY29lcmNlX2ZpbmlzaCkKKwkJeworCQkJYXMgPSAmc3RhdGUt PnN0ZXBzW2xmaXJzdF9pbnQobGMpXTsKKwkJCWFzLT5kLmp1bXAuanVtcGRvbmUgPSBzdGF0ZS0+ c3RlcHNfbGVuOworCQl9CisKKwkJc2NyYXRjaC0+b3Bjb2RlID0gRUVPUF9KU09ORVhQUl9DT0VS Q0lPTl9GSU5JU0g7CisJCXNjcmF0Y2gtPmQuanNvbmV4cHIuanNlc3RhdGUgPSBqc2VzdGF0ZTsK KwkJRXhwckV2YWxQdXNoU3RlcChzdGF0ZSwgc2NyYXRjaCk7CisJfQorCisJanNlc3RhdGUtPmp1 bXBfZW1wdHkgPSBqc2VzdGF0ZS0+anVtcF9lcnJvciA9IC0xOworCisJLyoKKwkgKiBTdGVwIHRv IGhhbmRsZSBPTiBFUlJPUiBiZWhhdmlvcnMuICBUaGlzIGhhbmRsZXMgYm90aCB0aGUgZXJyb3Jz CisJICogdGhhdCBvY2N1ciBkdXJpbmcgRUVPUF9KU09ORVhQUl9QQVRIIGV2YWx1YXRpb24gYW5k IHN1YnNlcXVlbnQgY29lcmNpb24KKwkgKiBldmFsdWF0aW9uLgorCSAqLworCWlmIChqZXhwci0+ b25fZXJyb3IgJiYKKwkJamV4cHItPm9uX2Vycm9yLT5idHlwZSAhPSBKU09OX0JFSEFWSU9SX0VS Uk9SKQorCXsKKwkJanNlc3RhdGUtPmp1bXBfZXJyb3IgPSBzdGF0ZS0+c3RlcHNfbGVuOworCQlz Y3JhdGNoLT5vcGNvZGUgPSBFRU9QX0pVTVBfSUZfTk9UX1RSVUU7CisKKwkJLyoKKwkJICogcG9z dF9ldmFsLmVycm9yIGlzIHNldCBieSBFeGVjRXZhbEpzb25FeHByUGF0aCgpIGFuZAorCQkgKiBF eGVjRXZhbEpzb25Db2VyY2lvbkZpbmlzaCgpLgorCQkgKi8KKwkJc2NyYXRjaC0+cmVzdmFsdWUg PSAmcG9zdF9ldmFsLT5lcnJvci52YWx1ZTsKKwkJc2NyYXRjaC0+cmVzbnVsbCA9ICZwb3N0X2V2 YWwtPmVycm9yLmlzbnVsbDsKKwkJc2NyYXRjaC0+ZC5qdW1wLmp1bXBkb25lID0gLTE7CS8qIHNl dCBiZWxvdyAqLworCQlqdW1wc190b19lbmQgPSBsYXBwZW5kX2ludChqdW1wc190b19lbmQsIHN0 YXRlLT5zdGVwc19sZW4pOworCQlFeHByRXZhbFB1c2hTdGVwKHN0YXRlLCBzY3JhdGNoKTsKKwor CQkvKiBTdGVwcyB0byBldmFsdWF0ZSB0aGUgT04gRVJST1IgZXhwcmVzc2lvbiAqLworCQlFeGVj SW5pdEV4cHJSZWMoKEV4cHIgKikgamV4cHItPm9uX2Vycm9yLT5leHByLAorCQkJCQkJc3RhdGUs IHJlc3YsIHJlc251bGwpOworCisJCS8qIFN0ZXBzIHRvIGNvZXJjZSB0aGUgT04gRVJST1IgZXhw cmVzc2lvbiBpZiBuZWVkZWQgKi8KKwkJKHZvaWQpIEV4ZWNJbml0SnNvbkV4cHJDb2VyY2lvbihz dGF0ZSwKKwkJCQkJCQkJCQkoTm9kZSAqKSBqZXhwci0+b25fZXJyb3ItPmNvZXJjaW9uLAorCQkJ CQkJCQkJCU5VTEwsCS8qIHRocm93IGVycm9ycyAqLworCQkJCQkJCQkJCXJlc3YsIHJlc251bGwp OworCisJCWp1bXBzX3RvX2VuZCA9IGxhcHBlbmRfaW50KGp1bXBzX3RvX2VuZCwgc3RhdGUtPnN0 ZXBzX2xlbik7CisJCXNjcmF0Y2gtPm9wY29kZSA9IEVFT1BfSlVNUDsKKwkJc2NyYXRjaC0+ZC5q dW1wLmp1bXBkb25lID0gLTE7CisJCUV4cHJFdmFsUHVzaFN0ZXAoc3RhdGUsIHNjcmF0Y2gpOwor CX0KKworCS8qIFN0ZXAgdG8gaGFuZGxlIE9OIEVNUFRZIGJlaGF2aW9ycy4gKi8KKwlpZiAoamV4 cHItPm9uX2VtcHR5ICE9IE5VTEwgJiYKKwkJamV4cHItPm9uX2VtcHR5LT5idHlwZSAhPSBKU09O X0JFSEFWSU9SX0VSUk9SKQorCXsKKwkJanNlc3RhdGUtPmp1bXBfZW1wdHkgPSBzdGF0ZS0+c3Rl cHNfbGVuOworCisJCXNjcmF0Y2gtPm9wY29kZSA9IEVFT1BfSlVNUF9JRl9OT1RfVFJVRTsKKwkJ c2NyYXRjaC0+cmVzdmFsdWUgPSAmcG9zdF9ldmFsLT5lbXB0eS52YWx1ZTsKKwkJc2NyYXRjaC0+ cmVzbnVsbCA9ICZwb3N0X2V2YWwtPmVtcHR5LmlzbnVsbDsKKwkJc2NyYXRjaC0+ZC5qdW1wLmp1 bXBkb25lID0gLTE7CS8qIHNldCBiZWxvdyAqLworCQlqdW1wc190b19lbmQgPSBsYXBwZW5kX2lu dChqdW1wc190b19lbmQsIHN0YXRlLT5zdGVwc19sZW4pOworCQlFeHByRXZhbFB1c2hTdGVwKHN0 YXRlLCBzY3JhdGNoKTsKKworCQkvKiBTdGVwcyB0byBldmFsdWF0ZSB0aGUgT04gRU1QVFkgZXhw cmVzc2lvbiAqLworCQlFeGVjSW5pdEV4cHJSZWMoKEV4cHIgKikgamV4cHItPm9uX2VtcHR5LT5l eHByLAorCQkJCQkJc3RhdGUsIHJlc3YsIHJlc251bGwpOworCisJCS8qIFN0ZXBzIHRvIGNvZXJj ZSB0aGUgT04gRU1QVFkgZXhwcmVzc2lvbiBpZiBuZWVkZWQgKi8KKwkJKHZvaWQpIEV4ZWNJbml0 SnNvbkV4cHJDb2VyY2lvbihzdGF0ZSwKKwkJCQkJCQkJCQkoTm9kZSAqKSBqZXhwci0+b25fZW1w dHktPmNvZXJjaW9uLAorCQkJCQkJCQkJCU5VTEwsCS8qIHRocm93IGVycm9ycyAqLworCQkJCQkJ CQkJCXJlc3YsIHJlc251bGwpOworCisJCXNjcmF0Y2gtPm9wY29kZSA9IEVFT1BfSlVNUDsKKwkJ c2NyYXRjaC0+ZC5qdW1wLmp1bXBkb25lID0gLTE7CS8qIHNldCBiZWxvdyAqLworCQlqdW1wc190 b19lbmQgPSBsYXBwZW5kX2ludChqdW1wc190b19lbmQsIHN0YXRlLT5zdGVwc19sZW4pOworCQlF eHByRXZhbFB1c2hTdGVwKHN0YXRlLCBzY3JhdGNoKTsKKwl9CisKKwlpZiAoanNlc3RhdGUtPmp1 bXBfZXJyb3IgPCAwICYmIGpzZXN0YXRlLT5qdW1wX2VtcHR5IDwgMCkKKwl7CisJCXNjcmF0Y2gt Pm9wY29kZSA9IEVFT1BfSlVNUDsKKwkJc2NyYXRjaC0+ZC5qdW1wLmp1bXBkb25lID0gLTE7CS8q IHNldCBiZWxvdyAqLworCQlqdW1wc190b19lbmQgPSBsYXBwZW5kX2ludChqdW1wc190b19lbmQs IHN0YXRlLT5zdGVwc19sZW4pOworCQlFeHByRXZhbFB1c2hTdGVwKHN0YXRlLCBzY3JhdGNoKTsK Kwl9CisKKwkvKiBSZXR1cm4gTlVMTCB3aGVuIGVpdGhlciBmb3JtYXR0ZWRfZXhwciBvciBwYXRo c3BlYyBpcyBOVUxMLiAqLworCWZvcmVhY2gobGMsIGp1bXBzX2lmX3NraXApCisJeworCQlhcyA9 ICZzdGF0ZS0+c3RlcHNbbGZpcnN0X2ludChsYyldOworCQlhcy0+ZC5qdW1wLmp1bXBkb25lID0g c3RhdGUtPnN0ZXBzX2xlbjsKKwl9CisJc2NyYXRjaC0+b3Bjb2RlID0gRUVPUF9DT05TVDsKKwlz Y3JhdGNoLT5yZXN2YWx1ZSA9IHJlc3Y7CisJc2NyYXRjaC0+cmVzbnVsbCA9IHJlc251bGw7CisJ c2NyYXRjaC0+ZC5jb25zdHZhbC52YWx1ZSA9IChEYXR1bSkgMDsKKwlzY3JhdGNoLT5kLmNvbnN0 dmFsLmlzbnVsbCA9IHRydWU7CisJRXhwckV2YWxQdXNoU3RlcChzdGF0ZSwgc2NyYXRjaCk7CisK KwkvKiBKdW1wIHRvIGNvZXJjZSB0aGUgTlVMTCB1c2luZyByZXN1bHRfY29lcmNpb24gaXMgcHJl c2VudC4gKi8KKwlpZiAoanNlc3RhdGUtPmp1bXBfZXZhbF9yZXN1bHRfY29lcmNpb24gPj0gMCkK Kwl7CisJCXNjcmF0Y2gtPm9wY29kZSA9IEVFT1BfSlVNUDsKKwkJc2NyYXRjaC0+ZC5qdW1wLmp1 bXBkb25lID0ganNlc3RhdGUtPmp1bXBfZXZhbF9yZXN1bHRfY29lcmNpb247CisJCUV4cHJFdmFs UHVzaFN0ZXAoc3RhdGUsIHNjcmF0Y2gpOworCX0KKworCWZvcmVhY2gobGMsIGp1bXBzX3RvX2Vu ZCkKKwl7CisJCWFzID0gJnN0YXRlLT5zdGVwc1tsZmlyc3RfaW50KGxjKV07CisJCWFzLT5kLmp1 bXAuanVtcGRvbmUgPSBzdGF0ZS0+c3RlcHNfbGVuOworCX0KKworCWpzZXN0YXRlLT5qdW1wX2Vu ZCA9IHN0YXRlLT5zdGVwc19sZW47Cit9CisKKy8qIEluaXRpYWxpemUgb25lIEpzb25Db2VyY2lv biBmb3IgZXhlY3V0aW9uLiAqLworc3RhdGljIGludAorRXhlY0luaXRKc29uRXhwckNvZXJjaW9u KEV4cHJTdGF0ZSAqc3RhdGUsIE5vZGUgKmNvZXJjaW9uLAorCQkJCQkJIEVycm9yU2F2ZUNvbnRl eHQgKmVzY29udGV4dCwKKwkJCQkJCSBEYXR1bSAqcmVzdiwgYm9vbCAqcmVzbnVsbCkKK3sKKwlp bnQJCQlqdW1wX2V2YWxfY29lcmNpb247CisJRGF0dW0JICAgKnNhdmVfaW5uZXJtb3N0X2Nhc2V2 YWw7CisJYm9vbAkgICAqc2F2ZV9pbm5lcm1vc3RfY2FzZW51bGw7CisJRXJyb3JTYXZlQ29udGV4 dCAqc2F2ZV9lc2NvbnRleHQ7CisKKwlpZiAoY29lcmNpb24gPT0gTlVMTCkKKwkJcmV0dXJuIC0x OworCisJanVtcF9ldmFsX2NvZXJjaW9uID0gc3RhdGUtPnN0ZXBzX2xlbjsKKwlpZiAoSXNBKGNv ZXJjaW9uLCBKc29uQ29lcmNpb24pKQorCXsKKwkJRXhwckV2YWxTdGVwIHNjcmF0Y2ggPSB7MH07 CisJCU9pZAkJCXR5cGlucHV0OworCQlGbWdySW5mbyAgICpmaW5mbzsKKwkJT2lkCQkJdHlwaW9w YXJhbTsKKworCQlnZXRUeXBlSW5wdXRJbmZvKCgoSnNvbkNvZXJjaW9uICopIGNvZXJjaW9uKS0+ dGFyZ2V0dHlwZSwKKwkJCQkJCSAmdHlwaW5wdXQsICZ0eXBpb3BhcmFtKTsKKwkJZmluZm8gPSBw YWxsb2MwKHNpemVvZihGbWdySW5mbykpOworCQlmbWdyX2luZm8odHlwaW5wdXQsIGZpbmZvKTsK KworCQlzY3JhdGNoLm9wY29kZSA9IEVFT1BfSlNPTkVYUFJfQ09FUkNJT047CisJCXNjcmF0Y2gu cmVzdmFsdWUgPSByZXN2OworCQlzY3JhdGNoLnJlc251bGwgPSByZXNudWxsOworCQlzY3JhdGNo LmQuanNvbmV4cHJfY29lcmNpb24uY29lcmNpb24gPSAoSnNvbkNvZXJjaW9uICopIGNvZXJjaW9u OworCQlzY3JhdGNoLmQuanNvbmV4cHJfY29lcmNpb24uaW5wdXRfZmluZm8gPSBmaW5mbzsKKwkJ c2NyYXRjaC5kLmpzb25leHByX2NvZXJjaW9uLnR5cGlvcGFyYW0gPSB0eXBpb3BhcmFtOworCQlz Y3JhdGNoLmQuanNvbmV4cHJfY29lcmNpb24uanNvbl9wb3B1bGF0ZV90eXBlX2NhY2hlID0gTlVM TDsKKwkJc2NyYXRjaC5kLmpzb25leHByX2NvZXJjaW9uLmVzY29udGV4dCA9IGVzY29udGV4dDsK KwkJRXhwckV2YWxQdXNoU3RlcChzdGF0ZSwgJnNjcmF0Y2gpOworCQlyZXR1cm4ganVtcF9ldmFs X2NvZXJjaW9uOworCX0KKworCS8qIFB1c2ggc3RlcChzKSB0byBjb21wdXRlIGNzdGF0ZS0+Y29l cmNpb24uICovCisJc2F2ZV9pbm5lcm1vc3RfY2FzZXZhbCA9IHN0YXRlLT5pbm5lcm1vc3RfY2Fz ZXZhbDsKKwlzYXZlX2lubmVybW9zdF9jYXNlbnVsbCA9IHN0YXRlLT5pbm5lcm1vc3RfY2FzZW51 bGw7CisJc2F2ZV9lc2NvbnRleHQgPSBzdGF0ZS0+ZXNjb250ZXh0OworCisJc3RhdGUtPmlubmVy bW9zdF9jYXNldmFsID0gcmVzdjsKKwlzdGF0ZS0+aW5uZXJtb3N0X2Nhc2VudWxsID0gcmVzbnVs bDsKKwlzdGF0ZS0+ZXNjb250ZXh0ID0gZXNjb250ZXh0OworCisJRXhlY0luaXRFeHByUmVjKChF eHByICopIGNvZXJjaW9uLCBzdGF0ZSwgcmVzdiwgcmVzbnVsbCk7CisKKwlzdGF0ZS0+aW5uZXJt b3N0X2Nhc2V2YWwgPSBzYXZlX2lubmVybW9zdF9jYXNldmFsOworCXN0YXRlLT5pbm5lcm1vc3Rf Y2FzZW51bGwgPSBzYXZlX2lubmVybW9zdF9jYXNlbnVsbDsKKwlzdGF0ZS0+ZXNjb250ZXh0ID0g c2F2ZV9lc2NvbnRleHQ7CisKKwlyZXR1cm4ganVtcF9ldmFsX2NvZXJjaW9uOworfQpkaWZmIC0t Z2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY0V4cHJJbnRlcnAuYyBiL3NyYy9iYWNrZW5k L2V4ZWN1dG9yL2V4ZWNFeHBySW50ZXJwLmMKaW5kZXggYjE3Y2FiMDZiNi4uOTY0NDMzYTBlNyAx MDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY0V4cHJJbnRlcnAuYworKysgYi9z cmMvYmFja2VuZC9leGVjdXRvci9leGVjRXhwckludGVycC5jCkBAIC03Myw4ICs3Myw4IEBACiAj aW5jbHVkZSAidXRpbHMvZGF0dW0uaCIKICNpbmNsdWRlICJ1dGlscy9leHBhbmRlZHJlY29yZC5o IgogI2luY2x1ZGUgInV0aWxzL2pzb24uaCIKLSNpbmNsdWRlICJ1dGlscy9qc29uYi5oIgogI2lu Y2x1ZGUgInV0aWxzL2pzb25mdW5jcy5oIgorI2luY2x1ZGUgInV0aWxzL2pzb25wYXRoLmgiCiAj aW5jbHVkZSAidXRpbHMvbHN5c2NhY2hlLmgiCiAjaW5jbHVkZSAidXRpbHMvbWVtdXRpbHMuaCIK ICNpbmNsdWRlICJ1dGlscy90aW1lc3RhbXAuaCIKQEAgLTE4MSw2ICsxODEsMTAgQEAgc3RhdGlj IHBnX2F0dHJpYnV0ZV9hbHdheXNfaW5saW5lIHZvaWQgRXhlY0FnZ1BsYWluVHJhbnNCeVJlZihB Z2dTdGF0ZSAqYWdnc3RhdGUKIAkJCQkJCQkJCQkJCQkJCSAgQWdnU3RhdGVQZXJHcm91cCBwZXJn cm91cCwKIAkJCQkJCQkJCQkJCQkJCSAgRXhwckNvbnRleHQgKmFnZ2NvbnRleHQsCiAJCQkJCQkJ CQkJCQkJCQkgIGludCBzZXRubyk7CitzdGF0aWMgdm9pZCBFeGVjUHJlcGFyZUpzb25JdGVtQ29l cmNpb24oSnNvbmJWYWx1ZSAqaXRlbSwgSnNvbkV4cHJTdGF0ZSAqanNlc3RhdGUsCisJCQkJCQkJ Ym9vbCB0aHJvd19lcnJvciwKKwkJCQkJCQlpbnQgKmp1bXBfZXZhbF9pdGVtX2NvZXJjaW9uLAor CQkJCQkJCURhdHVtICpyZXN2YWx1ZSwgYm9vbCAqcmVzbnVsbCk7CiAKIC8qCiAgKiBTY2FsYXJB cnJheU9wRXhwckhhc2hFbnRyeQpAQCAtNDgyLDYgKzQ4Niw5IEBAIEV4ZWNJbnRlcnBFeHByKEV4 cHJTdGF0ZSAqc3RhdGUsIEV4cHJDb250ZXh0ICplY29udGV4dCwgYm9vbCAqaXNudWxsKQogCQkm JkNBU0VfRUVPUF9YTUxFWFBSLAogCQkmJkNBU0VfRUVPUF9KU09OX0NPTlNUUlVDVE9SLAogCQkm JkNBU0VfRUVPUF9JU19KU09OLAorCQkmJkNBU0VfRUVPUF9KU09ORVhQUl9QQVRILAorCQkmJkNB U0VfRUVPUF9KU09ORVhQUl9DT0VSQ0lPTiwKKwkJJiZDQVNFX0VFT1BfSlNPTkVYUFJfQ09FUkNJ T05fRklOSVNILAogCQkmJkNBU0VfRUVPUF9BR0dSRUYsCiAJCSYmQ0FTRV9FRU9QX0dST1VQSU5H X0ZVTkMsCiAJCSYmQ0FTRV9FRU9QX1dJTkRPV19GVU5DLApAQCAtMTU1MSw2ICsxNTU4LDI4IEBA IEV4ZWNJbnRlcnBFeHByKEV4cHJTdGF0ZSAqc3RhdGUsIEV4cHJDb250ZXh0ICplY29udGV4dCwg Ym9vbCAqaXNudWxsKQogCQkJRUVPX05FWFQoKTsKIAkJfQogCisJCUVFT19DQVNFKEVFT1BfSlNP TkVYUFJfUEFUSCkKKwkJeworCQkJLyogdG9vIGNvbXBsZXggZm9yIGFuIGlubGluZSBpbXBsZW1l bnRhdGlvbiAqLworCQkJRUVPX0pVTVAoRXhlY0V2YWxKc29uRXhwclBhdGgoc3RhdGUsIG9wLCBl Y29udGV4dCkpOworCQl9CisKKwkJRUVPX0NBU0UoRUVPUF9KU09ORVhQUl9DT0VSQ0lPTikKKwkJ eworCQkJLyogdG9vIGNvbXBsZXggZm9yIGFuIGlubGluZSBpbXBsZW1lbnRhdGlvbiAqLworCQkJ RXhlY0V2YWxKc29uQ29lcmNpb24oc3RhdGUsIG9wLCBlY29udGV4dCk7CisKKwkJCUVFT19ORVhU KCk7CisJCX0KKworCQlFRU9fQ0FTRShFRU9QX0pTT05FWFBSX0NPRVJDSU9OX0ZJTklTSCkKKwkJ eworCQkJLyogdG9vIGNvbXBsZXggZm9yIGFuIGlubGluZSBpbXBsZW1lbnRhdGlvbiAqLworCQkJ RXhlY0V2YWxKc29uQ29lcmNpb25GaW5pc2goc3RhdGUsIG9wKTsKKworCQkJRUVPX05FWFQoKTsK KwkJfQorCiAJCUVFT19DQVNFKEVFT1BfQUdHUkVGKQogCQl7CiAJCQkvKgpAQCAtNDIwOCw2ICs0 MjM3LDM0NSBAQCBFeGVjRXZhbEpzb25Jc1ByZWRpY2F0ZShFeHByU3RhdGUgKnN0YXRlLCBFeHBy RXZhbFN0ZXAgKm9wKQogCSpvcC0+cmVzdmFsdWUgPSBCb29sR2V0RGF0dW0ocmVzKTsKIH0KIAor LyoKKyAqIFBlcmZvcm1zIEpzb25QYXRoe0V4aXN0c3xRdWVyeXxWYWx1ZX0oKSBmb3IgZ2l2ZW4g Y29udGV4dCBpdGVtIGFuZCBKU09OCisgKiBwYXRoLgorICoKKyAqIFJlc3VsdCBpcyBzZXQgaW4g Km9wLT5yZXN2YWx1ZSBhbmQgKm9wLT5yZXNudWxsLiAgUmV0dXJuIHZhbHVlIGlzIHRoZQorICog c3RlcCBhZGRyZXNzIHRvIGJlIHBlcmZvcm1lZCBuZXh0LgorICoKKyAqIE9uIHJldHVybiwgSnNv bkV4cHJQb3N0RXZhbFN0YXRlIGlzIHBvcHVsYXRlZCB3aXRoIHRoZSBmb2xsb3dpbmcgZGV0YWls czoKKyAqCS0gZXJyb3IudmFsdWU6IHRydWUgaWYgYW4gZXJyb3Igb2NjdXJyZWQgZHVyaW5nIEpz b25QYXRoIGV2YWx1YXRpb24KKyAqCS0gZW1wdHkudmFsdWU6IHRydWUgaWYgSnNvblBhdGh7UXVl cnl8VmFsdWV9KCkgZm91bmQgbm8gbWF0Y2hpbmcgaXRlbQorICoKKyAqIE5vIHJldHVybiBpZiB0 aGUgT04gRVJST1IvRU1QVFkgYmVoYXZpb3IgaXMgRVJST1IuCisgKi8KK2ludAorRXhlY0V2YWxK c29uRXhwclBhdGgoRXhwclN0YXRlICpzdGF0ZSwgRXhwckV2YWxTdGVwICpvcCwKKwkJCQkJIEV4 cHJDb250ZXh0ICplY29udGV4dCkKK3sKKwlKc29uRXhwclN0YXRlICpqc2VzdGF0ZSA9IG9wLT5k Lmpzb25leHByLmpzZXN0YXRlOworCUpzb25FeHByUG9zdEV2YWxTdGF0ZSAqcG9zdF9ldmFsID0g JmpzZXN0YXRlLT5wb3N0X2V2YWw7CisJSnNvbkV4cHIgICAqamV4cHIgPSBqc2VzdGF0ZS0+anNl eHByOworCURhdHVtCQlpdGVtOworCUpzb25QYXRoICAgKnBhdGg7CisJYm9vbAkJdGhyb3dfZXJy b3IgPSBqZXhwci0+b25fZXJyb3ItPmJ0eXBlID09IEpTT05fQkVIQVZJT1JfRVJST1I7CisJYm9v bAkJZXJyb3IgPSBmYWxzZSwKKwkJCQllbXB0eSA9IGZhbHNlOworCS8qIE1pZ2h0IGdldCBvdmVy cmlkZGVuIGZvciBKU09OX1ZBTFVFX09QIGJ5IGFuIHBlci1pdGVtIGNvZXJjaW9uLiAqLworCWlu dAkJCWp1bXBfZXZhbF9jb2VyY2lvbiA9IGpzZXN0YXRlLT5qdW1wX2V2YWxfcmVzdWx0X2NvZXJj aW9uOworCisJaXRlbSA9IGpzZXN0YXRlLT5mb3JtYXR0ZWRfZXhwci52YWx1ZTsKKwlwYXRoID0g RGF0dW1HZXRKc29uUGF0aFAoanNlc3RhdGUtPnBhdGhzcGVjLnZhbHVlKTsKKworCS8qIFJlc2V0 IEpzb25FeHByUG9zdEV2YWxTdGF0ZSBmb3IgdGhpcyBldmFsdWF0aW9uLiAqLworCW1lbXNldChw b3N0X2V2YWwsIDAsIHNpemVvZigqcG9zdF9ldmFsKSk7CisJc3dpdGNoIChqZXhwci0+b3ApCisJ eworCQljYXNlIEpTT05fRVhJU1RTX09QOgorCQkJeworCQkJCWJvb2wJCWV4aXN0cyA9IEpzb25Q YXRoRXhpc3RzKGl0ZW0sIHBhdGgsCisJCQkJCQkJCQkJCQkJIXRocm93X2Vycm9yID8gJmVycm9y IDogTlVMTCwKKwkJCQkJCQkJCQkJCQlqc2VzdGF0ZS0+YXJncyk7CisKKwkJCQlpZiAoIWVycm9y KQorCQkJCXsKKwkJCQkJKm9wLT5yZXN2YWx1ZSA9IEJvb2xHZXREYXR1bShleGlzdHMpOworCQkJ CQkqb3AtPnJlc251bGwgPSBmYWxzZTsKKwkJCQl9CisJCQl9CisJCQlicmVhazsKKworCQljYXNl IEpTT05fUVVFUllfT1A6CisJCQkqb3AtPnJlc3ZhbHVlID0gSnNvblBhdGhRdWVyeShpdGVtLCBw YXRoLCBqZXhwci0+d3JhcHBlciwgJmVtcHR5LAorCQkJCQkJCQkJCSAgIXRocm93X2Vycm9yID8g JmVycm9yIDogTlVMTCwKKwkJCQkJCQkJCQkgIGpzZXN0YXRlLT5hcmdzKTsKKworCQkJaWYgKCFl cnJvciAmJiAhZW1wdHkpCisJCQkJKm9wLT5yZXNudWxsID0gKERhdHVtR2V0UG9pbnRlcigqb3At PnJlc3ZhbHVlKSA9PSBOVUxMKTsKKwkJCWJyZWFrOworCisJCWNhc2UgSlNPTl9WQUxVRV9PUDoK KwkJCXsKKwkJCQlKc29uYlZhbHVlICpqYnYgPSBKc29uUGF0aFZhbHVlKGl0ZW0sIHBhdGgsICZl bXB0eSwKKwkJCQkJCQkJCQkJCSF0aHJvd19lcnJvciA/ICZlcnJvciA6IE5VTEwsCisJCQkJCQkJ CQkJCQlqc2VzdGF0ZS0+YXJncyk7CisKKwkJCQlpZiAoamJ2ID09IE5VTEwpCisJCQkJeworCQkJ CQkvKiBXaWxsIGJlIGNvZXJjZWQgd2l0aCByZXN1bHRfY29lcmNpb24uICovCisJCQkJCSpvcC0+ cmVzdmFsdWUgPSAoRGF0dW0pIDA7CisJCQkJCSpvcC0+cmVzbnVsbCA9IHRydWU7CisJCQkJfQor CQkJCWVsc2UgaWYgKCFlcnJvciAmJiAhZW1wdHkpCisJCQkJeworCQkJCQkvKgorCQkJCQkgKiBJ ZiB0aGUgcmVxdWVzdGVkIG91dHB1dCB0eXBlIGlzIGpzb24oYiksIHVzZQorCQkJCQkgKiByZXN1 bHRfY29lcmNpb24gdG8gZG8gdGhlIGNvZXJjaW9uLgorCQkJCQkgKi8KKwkJCQkJaWYgKGpleHBy LT5yZXR1cm5pbmctPnR5cGlkID09IEpTT05PSUQgfHwKKwkJCQkJCWpleHByLT5yZXR1cm5pbmct PnR5cGlkID09IEpTT05CT0lEKQorCQkJCQl7CisJCQkJCQkqb3AtPnJlc3ZhbHVlID0gSnNvbmJQ R2V0RGF0dW0oSnNvbmJWYWx1ZVRvSnNvbmIoamJ2KSk7CisJCQkJCQkqb3AtPnJlc251bGwgPSBm YWxzZTsKKwkJCQkJfQorCQkJCQllbHNlCisJCQkJCXsKKwkJCQkJCS8qCisJCQkJCQkgKiBFbHNl LCB1c2Ugb25lIG9mIHRoZSBpdGVtX2NvZXJjaW9ucy4KKwkJCQkJCSAqCisJCQkJCQkgKiBFcnJv ciBvdXQgaWYgbm8gY2FzdCBleHByZXNzaW9uIGV4aXN0cy4KKwkJCQkJCSAqLworCQkJCQkJRXhl Y1ByZXBhcmVKc29uSXRlbUNvZXJjaW9uKGpidiwganNlc3RhdGUsIHRocm93X2Vycm9yLAorCQkJ CQkJCQkJCQkJCSZqdW1wX2V2YWxfY29lcmNpb24sCisJCQkJCQkJCQkJCQkJb3AtPnJlc3ZhbHVl LCBvcC0+cmVzbnVsbCk7CisJCQkJCX0KKwkJCQl9CisJCQkJYnJlYWs7CisJCQl9CisKKwkJZGVm YXVsdDoKKwkJCWVsb2coRVJST1IsICJ1bnJlY29nbml6ZWQgU1FML0pTT04gZXhwcmVzc2lvbiBv cCAlZCIsIGpleHByLT5vcCk7CisJCQlyZXR1cm4gZmFsc2U7CisJfQorCisJaWYgKGVtcHR5KQor CXsKKwkJaWYgKGpleHByLT5vbl9lbXB0eSkKKwkJeworCQkJaWYgKGpleHByLT5vbl9lbXB0eS0+ YnR5cGUgPT0gSlNPTl9CRUhBVklPUl9FUlJPUikKKwkJCQllcmVwb3J0KEVSUk9SLAorCQkJCQkJ ZXJyY29kZShFUlJDT0RFX05PX1NRTF9KU09OX0lURU0pLAorCQkJCQkJZXJybXNnKCJubyBTUUwv SlNPTiBpdGVtIikpOworCQkJZWxzZQorCQkJCXBvc3RfZXZhbC0+ZW1wdHkudmFsdWUgPSBCb29s R2V0RGF0dW0odHJ1ZSk7CisKKwkJCUFzc2VydChqc2VzdGF0ZS0+anVtcF9lbXB0eSA+PSAwKTsK KwkJCXJldHVybiBqc2VzdGF0ZS0+anVtcF9lbXB0eTsKKwkJfQorCQllbHNlIGlmIChqZXhwci0+ b25fZXJyb3ItPmJ0eXBlID09IEpTT05fQkVIQVZJT1JfRVJST1IpCisJCQllcmVwb3J0KEVSUk9S LAorCQkJCQllcnJjb2RlKEVSUkNPREVfTk9fU1FMX0pTT05fSVRFTSksCisJCQkJCWVycm1zZygi bm8gU1FML0pTT04gaXRlbSIpKTsKKwkJZWxzZQorCQkJcG9zdF9ldmFsLT5lcnJvci52YWx1ZSA9 IEJvb2xHZXREYXR1bSh0cnVlKTsKKworCQkqb3AtPnJlc3ZhbHVlID0gKERhdHVtKSAwOworCQkq b3AtPnJlc251bGwgPSB0cnVlOworCisJCUFzc2VydChqc2VzdGF0ZS0+anVtcF9lcnJvciA+PSAw KTsKKwkJcmV0dXJuIGpzZXN0YXRlLT5qdW1wX2Vycm9yOworCX0KKworCWlmIChlcnJvcikKKwl7 CisJCUFzc2VydCghdGhyb3dfZXJyb3IgJiYganNlc3RhdGUtPmp1bXBfZXJyb3IgPj0gMCk7CisJ CSpvcC0+cmVzdmFsdWUgPSAoRGF0dW0pIDA7CisJCSpvcC0+cmVzbnVsbCA9IHRydWU7CisJCXBv c3RfZXZhbC0+ZXJyb3IudmFsdWUgPSBCb29sR2V0RGF0dW0odHJ1ZSk7CisJCXJldHVybiBqc2Vz dGF0ZS0+anVtcF9lcnJvcjsKKwl9CisKKwkvKiBFbHNlIHJldHVybiB0aGUgY29lcmNpb24gc3Rl cCBhZGRyZXNzIG9yIHRoZSBhZGRyZXNzIHRvIHNraXAgdG8gZW5kLiAqLworCXJldHVybiBqdW1w X2V2YWxfY29lcmNpb24gPj0gMCA/IGp1bXBfZXZhbF9jb2VyY2lvbiA6IGpzZXN0YXRlLT5qdW1w X2VuZDsKK30KKworLyoKKyAqIFNlbGVjdHMgYSBjb2VyY2lvbiBmb3IgYSBnaXZlbiBKc29uYlZh bHVlIGJhc2VkIG9uIGl0cyB0eXBlLgorICoKKyAqIE9uIHJldHVybiwgKnJlc3ZhbHVlIGFuZCAq cmVzbnVsbCBhcmUgc2V0IHRvIHRoZSB2YWx1ZSBleHRyYWN0ZWQgZnJvbSB0aGUKKyAqIEpzb25i VmFsdWUgYW5kICpqdW1wX2V2YWxfaXRlbV9jb2VyY2lvbiBpcyBzZXQgdG8gdGhlIHN0ZXAgYWRk cmVzcyBvZiB0aGUKKyAqIGNvZXJjaW9uIGV4cHJlc3Npb24uCisgKgorICogSWYgdGhlIGZvdW5k IGV4cHJlc3Npb24gaXMgYSBKc29uQ29lcmNpb24gbm9kZSB0aGF0IG1lYW5zIHRoZSBwYXJzZXIK KyAqIGRpZG50JyBmaW5kIGEgY2FzdCB0byBkbyB0aGUgY29lcmNpb24sIHNvIHRocm93IGFuIGVy cm9yIGlmIHRoZQorICogT04gRVJST1IgYmVoYXZpb3Igc2F5cyB0byBkbyBzby4KKyAqLworc3Rh dGljIHZvaWQKK0V4ZWNQcmVwYXJlSnNvbkl0ZW1Db2VyY2lvbihKc29uYlZhbHVlICppdGVtLCBK c29uRXhwclN0YXRlICpqc2VzdGF0ZSwKKwkJCQkJCQlib29sIHRocm93X2Vycm9yLAorCQkJCQkJ CWludCAqanVtcF9ldmFsX2l0ZW1fY29lcmNpb24sCisJCQkJCQkJRGF0dW0gKnJlc3ZhbHVlLCBi b29sICpyZXNudWxsKQoreworCWludAkJICAgKmV2YWxfaXRlbV9jb2VyY2lvbl9qdW1wcyA9IGpz ZXN0YXRlLT5ldmFsX2l0ZW1fY29lcmNpb25fanVtcHM7CisJYm9vbAkgICAqaXRlbV9jb2VyY2lv bl92aWFfZXhwciA9IGpzZXN0YXRlLT5pdGVtX2NvZXJjaW9uX3ZpYV9leHByOworCWJvb2wJCXZp YV9leHByOworCWludAkJCWp1bXBfdG87CisJSnNvbmJWYWx1ZQlidWY7CisKKwlpZiAoaXRlbS0+ dHlwZSA9PSBqYnZCaW5hcnkgJiYgSnNvbkNvbnRhaW5lcklzU2NhbGFyKGl0ZW0tPnZhbC5iaW5h cnkuZGF0YSkpCisJeworCQlib29sCWlzX3NjYWxhciBQR19VU0VEX0ZPUl9BU1NFUlRTX09OTFk7 CisKKwkJaXNfc2NhbGFyID0gSnNvbmJFeHRyYWN0U2NhbGFyKGl0ZW0tPnZhbC5iaW5hcnkuZGF0 YSwgJmJ1Zik7CisJCWl0ZW0gPSAmYnVmOworCQlBc3NlcnQoaXNfc2NhbGFyKTsKKwl9CisKKwkq cmVzbnVsbCA9IGZhbHNlOworCisJLyogZ2V0IGNvZXJjaW9uIHN0YXRlIHJlZmVyZW5jZSBhbmQg ZGF0dW0gb2YgdGhlIGNvcnJlc3BvbmRpbmcgU1FMIHR5cGUgKi8KKwlzd2l0Y2ggKGl0ZW0tPnR5 cGUpCisJeworCQljYXNlIGpidk51bGw6CisJCQl2aWFfZXhwciA9IGl0ZW1fY29lcmNpb25fdmlh X2V4cHJbSnNvbkl0ZW1UeXBlTnVsbF07CisJCQlqdW1wX3RvID0gZXZhbF9pdGVtX2NvZXJjaW9u X2p1bXBzW0pzb25JdGVtVHlwZU51bGxdOworCQkJKnJlc3ZhbHVlID0gKERhdHVtKSAwOworCQkJ KnJlc251bGwgPSB0cnVlOworCQkJYnJlYWs7CisKKwkJY2FzZSBqYnZTdHJpbmc6CisJCQl2aWFf ZXhwciA9IGl0ZW1fY29lcmNpb25fdmlhX2V4cHJbSnNvbkl0ZW1UeXBlU3RyaW5nXTsKKwkJCWp1 bXBfdG8gPSBldmFsX2l0ZW1fY29lcmNpb25fanVtcHNbSnNvbkl0ZW1UeXBlU3RyaW5nXTsKKwkJ CSpyZXN2YWx1ZSA9CisJCQkJUG9pbnRlckdldERhdHVtKGNzdHJpbmdfdG9fdGV4dF93aXRoX2xl bihpdGVtLT52YWwuc3RyaW5nLnZhbCwKKwkJCQkJCQkJaXRlbS0+dmFsLnN0cmluZy5sZW4pKTsK KwkJCWJyZWFrOworCisJCWNhc2UgamJ2TnVtZXJpYzoKKwkJCXZpYV9leHByID0gaXRlbV9jb2Vy Y2lvbl92aWFfZXhwcltKc29uSXRlbVR5cGVOdW1lcmljXTsKKwkJCWp1bXBfdG8gPSBldmFsX2l0 ZW1fY29lcmNpb25fanVtcHNbSnNvbkl0ZW1UeXBlTnVtZXJpY107CisJCQkqcmVzdmFsdWUgPSBO dW1lcmljR2V0RGF0dW0oaXRlbS0+dmFsLm51bWVyaWMpOworCQkJYnJlYWs7CisKKwkJY2FzZSBq YnZCb29sOgorCQkJdmlhX2V4cHIgPSBpdGVtX2NvZXJjaW9uX3ZpYV9leHByW0pzb25JdGVtVHlw ZUJvb2xlYW5dOworCQkJanVtcF90byA9IGV2YWxfaXRlbV9jb2VyY2lvbl9qdW1wc1tKc29uSXRl bVR5cGVCb29sZWFuXTsKKwkJCSpyZXN2YWx1ZSA9IEJvb2xHZXREYXR1bShpdGVtLT52YWwuYm9v bGVhbik7CisJCQlicmVhazsKKworCQljYXNlIGpidkRhdGV0aW1lOgorCQkJKnJlc3ZhbHVlID0g aXRlbS0+dmFsLmRhdGV0aW1lLnZhbHVlOworCQkJc3dpdGNoIChpdGVtLT52YWwuZGF0ZXRpbWUu dHlwaWQpCisJCQl7CisJCQkJY2FzZSBEQVRFT0lEOgorCQkJCQl2aWFfZXhwciA9IGl0ZW1fY29l cmNpb25fdmlhX2V4cHJbSnNvbkl0ZW1UeXBlRGF0ZV07CisJCQkJCWp1bXBfdG8gPSBldmFsX2l0 ZW1fY29lcmNpb25fanVtcHNbSnNvbkl0ZW1UeXBlRGF0ZV07CisJCQkJCWJyZWFrOworCQkJCWNh c2UgVElNRU9JRDoKKwkJCQkJdmlhX2V4cHIgPSBpdGVtX2NvZXJjaW9uX3ZpYV9leHByW0pzb25J dGVtVHlwZVRpbWVdOworCQkJCQlqdW1wX3RvID0gZXZhbF9pdGVtX2NvZXJjaW9uX2p1bXBzW0pz b25JdGVtVHlwZVRpbWVdOworCQkJCQlicmVhazsKKwkJCQljYXNlIFRJTUVUWk9JRDoKKwkJCQkJ dmlhX2V4cHIgPSBpdGVtX2NvZXJjaW9uX3ZpYV9leHByW0pzb25JdGVtVHlwZVRpbWV0el07CisJ CQkJCWp1bXBfdG8gPSBldmFsX2l0ZW1fY29lcmNpb25fanVtcHNbSnNvbkl0ZW1UeXBlVGltZXR6 XTsKKwkJCQkJYnJlYWs7CisJCQkJY2FzZSBUSU1FU1RBTVBPSUQ6CisJCQkJCXZpYV9leHByID0g aXRlbV9jb2VyY2lvbl92aWFfZXhwcltKc29uSXRlbVR5cGVUaW1lc3RhbXBdOworCQkJCQlqdW1w X3RvID0gZXZhbF9pdGVtX2NvZXJjaW9uX2p1bXBzW0pzb25JdGVtVHlwZVRpbWVzdGFtcF07CisJ CQkJCWJyZWFrOworCQkJCWNhc2UgVElNRVNUQU1QVFpPSUQ6CisJCQkJCXZpYV9leHByID0gaXRl bV9jb2VyY2lvbl92aWFfZXhwcltKc29uSXRlbVR5cGVUaW1lc3RhbXB0el07CisJCQkJCWp1bXBf dG8gPSBldmFsX2l0ZW1fY29lcmNpb25fanVtcHNbSnNvbkl0ZW1UeXBlVGltZXN0YW1wdHpdOwor CQkJCQlicmVhazsKKwkJCQlkZWZhdWx0OgorCQkJCQllbG9nKEVSUk9SLCAidW5leHBlY3RlZCBq c29uYiBkYXRldGltZSB0eXBlIG9pZCAldSIsCisJCQkJCQkgaXRlbS0+dmFsLmRhdGV0aW1lLnR5 cGlkKTsKKwkJCX0KKwkJCWJyZWFrOworCisJCWNhc2UgamJ2QXJyYXk6CisJCWNhc2UgamJ2T2Jq ZWN0OgorCQljYXNlIGpidkJpbmFyeToKKwkJCXZpYV9leHByID0gaXRlbV9jb2VyY2lvbl92aWFf ZXhwcltKc29uSXRlbVR5cGVDb21wb3NpdGVdOworCQkJanVtcF90byA9IGV2YWxfaXRlbV9jb2Vy Y2lvbl9qdW1wc1tKc29uSXRlbVR5cGVDb21wb3NpdGVdOworCQkJKnJlc3ZhbHVlID0gSnNvbmJQ R2V0RGF0dW0oSnNvbmJWYWx1ZVRvSnNvbmIoaXRlbSkpOworCQkJYnJlYWs7CisKKwkJZGVmYXVs dDoKKwkJCWVsb2coRVJST1IsICJ1bmV4cGVjdGVkIGpzb25iIHZhbHVlIHR5cGUgJWQiLCBpdGVt LT50eXBlKTsKKwl9CisKKwkvKiBJZiB0aGUgZXhwcmVzc2lvbiBpcyBhIEpzb25Db2VyY2lvbiwg dGhyb3cgYW4gZXJyb3IuICovCisJaWYgKGp1bXBfdG8gPj0gMCAmJiAhdmlhX2V4cHIpCisJewor CQlpZiAodGhyb3dfZXJyb3IpCisJCQllcmVwb3J0KEVSUk9SLAorCQkJCQllcnJjb2RlKEVSUkNP REVfU1FMX0pTT05fSVRFTV9DQU5OT1RfQkVfQ0FTVF9UT19UQVJHRVRfVFlQRSksCisJCQkJCWVy cm1zZygiU1FML0pTT04gaXRlbSBjYW5ub3QgYmUgY2FzdCB0byB0YXJnZXQgdHlwZSIpKTsKKwor CQkqcmVzdmFsdWUgPSAoRGF0dW0pIDA7CisJCSpyZXNudWxsID0gdHJ1ZTsKKwl9CisKKwkqanVt cF9ldmFsX2l0ZW1fY29lcmNpb24gPSBqdW1wX3RvOworfQorCisvKgorICogQ29lcmNlIGEganNv bmIgdmFsdWUgcHJvZHVjZWQgYnkgRXhlY0V2YWxKc29uRXhwclBhdGgoKSBvciBhbiBPTiBFUlJP UiAvCisgKiBFTVBUWSBiZWhhdmlvciBleHByZXNzaW9uIHRvIHRoZSB0YXJnZXQgdHlwZSBieSBl aXRoZXIgY2FsbGluZworICoganNvbl9wb3B1bGF0ZV90eXBlKCkgb3IgYnkgZGlyZWN0bHkgY2Fs bGluZyB0aGUgdHlwZSdzIGlucHV0IGZ1bmN0aW9uIGluCisgKiBzb21lIGNhc2VzLgorICoKKyAq IEFueSBzb2Z0IGVycm9ycyB0aGF0IG9jY3VyIHdpbGwgYmUgY2hlY2tlZCBieSBFRU9QX0pTT05F WFBSX0NPRVJDSU9OX0ZJTklTSAorICogdGhhdCB3aWxsIHJ1biByaWdodCBhZnRlciB0aGlzLgor ICovCit2b2lkCitFeGVjRXZhbEpzb25Db2VyY2lvbihFeHByU3RhdGUgKnN0YXRlLCBFeHByRXZh bFN0ZXAgKm9wLAorCQkJCQkgRXhwckNvbnRleHQgKmVjb250ZXh0KQoreworCUpzb25Db2VyY2lv biAqY29lcmNpb24gPSBvcC0+ZC5qc29uZXhwcl9jb2VyY2lvbi5jb2VyY2lvbjsKKwlFcnJvclNh dmVDb250ZXh0ICplc2NvbnRleHQgPSBvcC0+ZC5qc29uZXhwcl9jb2VyY2lvbi5lc2NvbnRleHQ7 CisJRGF0dW0JCXJlcyA9ICpvcC0+cmVzdmFsdWU7CisJYm9vbAkJcmVzbnVsbCA9ICpvcC0+cmVz bnVsbDsKKwlKc29uYgkgICAqamIgPSAhcmVzbnVsbCA/IERhdHVtR2V0SnNvbmJQKHJlcykgOiBO VUxMOworCisJLyoKKwkgKiBDYW4ndCBnbyB0byBqc29uX3BvcHVsYXRlX3R5cGUoKSBmb3Igc2Nh bGFycyB3aGVuIE9NSVQgUVVPVEVTIGlzCisJICogc3BlY2lmaWVkLCBiZWNhdXNlIGl0IGtlZXBz IHRoZSBxdW90ZXMgYnkgZGVmYXVsdC4gIFNvIGxldCdzIGRvIHRoZQorCSAqIGRlZWQgb3Vyc2Vs dmVzIGJ5IGNhbGxpbmcgdGhlIGlucHV0IGZ1bmN0aW9uLCB0aGF0IGlzLCBhZnRlciByZW1vdmlu ZworCSAqIHRoZSBxdW90ZXMuCisJICovCisJaWYgKGpiICYmIEpCX1JPT1RfSVNfU0NBTEFSKGpi KSAmJiBjb2VyY2lvbi0+b21pdF9xdW90ZXMpCisJeworCQlGbWdySW5mbyAgICppbnB1dF9maW5m byA9IG9wLT5kLmpzb25leHByX2NvZXJjaW9uLmlucHV0X2ZpbmZvOworCQlPaWQJCQl0eXBpb3Bh cmFtID0gb3AtPmQuanNvbmV4cHJfY29lcmNpb24udHlwaW9wYXJhbTsKKwkJY2hhcgkgICAqdmFs X3N0cmluZyA9IEpzb25iVW5xdW90ZShqYik7CisKKwkJKHZvaWQpIElucHV0RnVuY3Rpb25DYWxs U2FmZShpbnB1dF9maW5mbywgdmFsX3N0cmluZywgdHlwaW9wYXJhbSwKKwkJCQkJCQkJCSBjb2Vy Y2lvbi0+dGFyZ2V0dHlwbW9kLAorCQkJCQkJCQkJIChOb2RlICopIGVzY29udGV4dCwKKwkJCQkJ CQkJCSBvcC0+cmVzdmFsdWUpOworCX0KKwllbHNlCisJeworCQl2b2lkICpjYWNoZSA9IG9wLT5k Lmpzb25leHByX2NvZXJjaW9uLmpzb25fcG9wdWxhdGVfdHlwZV9jYWNoZTsKKworCQkqb3AtPnJl c3ZhbHVlID0ganNvbl9wb3B1bGF0ZV90eXBlKHJlcywgSlNPTkJPSUQsCisJCQkJCQkJCQkJICAg Y29lcmNpb24tPnRhcmdldHR5cGUsCisJCQkJCQkJCQkJICAgY29lcmNpb24tPnRhcmdldHR5cG1v ZCwKKwkJCQkJCQkJCQkgICAmY2FjaGUsCisJCQkJCQkJCQkJICAgZWNvbnRleHQtPmVjeHRfcGVy X3F1ZXJ5X21lbW9yeSwKKwkJCQkJCQkJCQkgICBvcC0+cmVzbnVsbCwgKE5vZGUgKikgZXNjb250 ZXh0KTsKKwl9Cit9CisKKy8qCisgKiBDaGVja3MgaWYgdGhlIGNvZXJjaW9uIGV2YWx1YXRpb24g bGVkIHRvIGFuIGVycm9yLiAgSWYgYW4gZXJyb3IgZGlkIG9jY3VyLAorICogdGhpcyBzZXRzIHBv c3RfZXZhbC0+ZXJyb3IgdG8gdHJpZ2dlciB0aGUgc3Vic2VxdWVudCBPTiBFUlJPUiBoYW5kbGlu ZworICogc3RlcHMuCisgKi8KK3ZvaWQKK0V4ZWNFdmFsSnNvbkNvZXJjaW9uRmluaXNoKEV4cHJT dGF0ZSAqc3RhdGUsIEV4cHJFdmFsU3RlcCAqb3ApCit7CisJSnNvbkV4cHJTdGF0ZSAqanNlc3Rh dGUgPSBvcC0+ZC5qc29uZXhwci5qc2VzdGF0ZTsKKworCWlmIChTT0ZUX0VSUk9SX09DQ1VSUkVE KCZqc2VzdGF0ZS0+ZXNjb250ZXh0KSkKKwl7CisJCSpvcC0+cmVzdmFsdWUgPSAoRGF0dW0pIDA7 CisJCSpvcC0+cmVzbnVsbCA9IHRydWU7CisJCWpzZXN0YXRlLT5wb3N0X2V2YWwuZXJyb3IudmFs dWUgPSBCb29sR2V0RGF0dW0odHJ1ZSk7CisKKwkJLyoKKwkJICogQWxzbyBtYWtlIEVycm9yU2F2 ZUNvbnRleHQgcmVhZHkgZm9yIHRoZSBuZXh0IHJvdy4gIFNpbmNlIHdlIG5ldmVyCisJCSAqIHNl dCBkZXRhaWxzX3dhbnRlZCwgd2UgZG9uJ3QgbmVlZCB0byBhbHNvIHJlc2V0IGVycm9yX2RhdGEs IHdoaWNoCisJCSAqIHdvdWxkIGJlIE5VTEwgYW55d2F5LgorCQkgKi8KKwkJQXNzZXJ0KCFqc2Vz dGF0ZS0+ZXNjb250ZXh0LmRldGFpbHNfd2FudGVkICYmCisJCQkgICBqc2VzdGF0ZS0+ZXNjb250 ZXh0LmVycm9yX2RhdGEgPT0gTlVMTCk7CisJCWpzZXN0YXRlLT5lc2NvbnRleHQuZXJyb3Jfb2Nj dXJyZWQgPSBmYWxzZTsKKwl9Cit9CiAKIC8qCiAgKiBFeGVjRXZhbEdyb3VwaW5nRnVuYwpkaWZm IC0tZ2l0IGEvc3JjL2JhY2tlbmQvaml0L2xsdm0vbGx2bWppdF9leHByLmMgYi9zcmMvYmFja2Vu ZC9qaXQvbGx2bS9sbHZtaml0X2V4cHIuYwppbmRleCAwOTk5NDUwM2IxLi43YTVmZjJmZWRmIDEw MDY0NAotLS0gYS9zcmMvYmFja2VuZC9qaXQvbGx2bS9sbHZtaml0X2V4cHIuYworKysgYi9zcmMv YmFja2VuZC9qaXQvbGx2bS9sbHZtaml0X2V4cHIuYwpAQCAtMTkzMCw2ICsxOTMwLDE0NiBAQCBs bHZtX2NvbXBpbGVfZXhwcihFeHByU3RhdGUgKnN0YXRlKQogCQkJCUxMVk1CdWlsZEJyKGIsIG9w YmxvY2tzW29wbm8gKyAxXSk7CiAJCQkJYnJlYWs7CiAKKwkJCWNhc2UgRUVPUF9KU09ORVhQUl9Q QVRIOgorCQkJCXsKKwkJCQkJSnNvbkV4cHJTdGF0ZSAqanNlc3RhdGUgPSBvcC0+ZC5qc29uZXhw ci5qc2VzdGF0ZTsKKwkJCQkJTExWTVZhbHVlUmVmIHZfcmV0OworCisJCQkJCS8qCisJCQkJCSAq IENhbGwgRXhlY0V2YWxKc29uRXhwclBhdGgoKS4gIEl0IHJldHVybnMgdGhlIGFkZHJlc3Mgb2YK KwkJCQkJICogdGhlIHN0ZXAgdG8gcGVyZm9ybSBuZXh0LgorCQkJCQkgKi8KKwkJCQkJdl9yZXQg PSBidWlsZF9FdmFsWEZ1bmMoYiwgbW9kLCAiRXhlY0V2YWxKc29uRXhwclBhdGgiLAorCQkJCQkJ CQkJCQl2X3N0YXRlLCBvcCwgdl9lY29udGV4dCk7CisKKwkJCQkJLyoKKwkJCQkJICogQnVpbGQg YSBzd2l0Y2ggdG8gbWFwIHRoZSByZXR1cm4gdmFsdWUsIHdoaWNoIGlzIGEKKwkJCQkJICogcnVu dGltZSB2YWx1ZSBvZiB0aGUgc3RlcCBhZGRyZXNzIHRvIHBlcmZvcm0gbmV4dCwgdG8KKwkJCQkJ ICogZWl0aGVyIGp1bXBfZW1wdHksIGp1bXBfZXJyb3IsIG9yIHRoZSBjb2VyY2lvbgorCQkJCQkg KiBleHByZXNzaW9uLgorCQkJCQkgKi8KKwkJCQkJaWYgKGpzZXN0YXRlLT5qdW1wX2VtcHR5ID49 IDAgfHwKKwkJCQkJCWpzZXN0YXRlLT5qdW1wX2Vycm9yID49IDAgfHwKKwkJCQkJCWpzZXN0YXRl LT5qdW1wX2V2YWxfcmVzdWx0X2NvZXJjaW9uID49IDAgfHwKKwkJCQkJCWpzZXN0YXRlLT5udW1f aXRlbV9jb2VyY2lvbnMgPiAwKQorCQkJCQl7CisJCQkJCQlpbnQJCQlpOworCQkJCQkJTExWTVZh bHVlUmVmIHZfanVtcF9lbXB0eTsKKwkJCQkJCUxMVk1WYWx1ZVJlZiB2X2p1bXBfZXJyb3I7CisJ CQkJCQlMTFZNVmFsdWVSZWYgdl9qdW1wX2NvZXJjaW9uOworCQkJCQkJTExWTVZhbHVlUmVmIHZf c3dpdGNoOworCQkJCQkJTExWTUJhc2ljQmxvY2tSZWYgCWJfZG9uZSwKKwkJCQkJCQkJCQkJYl9l bXB0eSwKKwkJCQkJCQkJCQkJYl9lcnJvciwKKwkJCQkJCQkJCQkJYl9yZXN1bHRfY29lcmNpb24s CisJCQkJCQkJCQkJICAgKmJfaXRlbV9jb2VyY2lvbnMgPSBOVUxMOworCisJCQkJCQliX2VtcHR5 ID0KKwkJCQkJCQlsX2JiX2JlZm9yZV92KG9wYmxvY2tzW29wbm8gKyAxXSwKKwkJCQkJCQkJCQkg ICJvcC4lZC5qc29uZXhwcl9lbXB0eSIsIG9wbm8pOworCQkJCQkJYl9lcnJvciA9CisJCQkJCQkJ bF9iYl9iZWZvcmVfdihvcGJsb2Nrc1tvcG5vICsgMV0sCisJCQkJCQkJCQkJICAib3AuJWQuanNv bmV4cHJfZXJyb3IiLCBvcG5vKTsKKwkJCQkJCWJfcmVzdWx0X2NvZXJjaW9uID0KKwkJCQkJCQls X2JiX2JlZm9yZV92KG9wYmxvY2tzW29wbm8gKyAxXSwKKwkJCQkJCQkJCQkgICJvcC4lZC5qc29u ZXhwcl9yZXN1bHRfY29lcmNpb24iLCBvcG5vKTsKKwkJCQkJCWlmIChqc2VzdGF0ZS0+bnVtX2l0 ZW1fY29lcmNpb25zID4gMCkKKwkJCQkJCXsKKwkJCQkJCQliX2l0ZW1fY29lcmNpb25zID0gcGFs bG9jKHNpemVvZihMTFZNQmFzaWNCbG9ja1JlZikgKgorCQkJCQkJCQkJCQkJCSAganNlc3RhdGUt Pm51bV9pdGVtX2NvZXJjaW9ucyk7CisJCQkJCQkJZm9yIChpID0gMDsgaSA8IGpzZXN0YXRlLT5u dW1faXRlbV9jb2VyY2lvbnM7IGkrKykKKwkJCQkJCQl7CisJCQkJCQkJCWJfaXRlbV9jb2VyY2lv bnNbaV0gPQorCQkJCQkJCQkJbF9iYl9iZWZvcmVfdihvcGJsb2Nrc1tvcG5vICsgMV0sCisJCQkJ CQkJCQkJCQkgICJvcC4lZC5qc29uZXhwcl9pdGVtX2NvZXJjaW9uLiVkIiwKKwkJCQkJCQkJCQkJ CSAgb3BubywgaSk7CisJCQkJCQkJfQorCQkJCQkJfQorCQkJCQkJYl9kb25lID0KKwkJCQkJCQls X2JiX2JlZm9yZV92KG9wYmxvY2tzW29wbm8gKyAxXSwKKwkJCQkJCQkJCQkgICJvcC4lZC5qc29u ZXhwcl9kb25lIiwgb3Bubyk7CisKKwkJCQkJCXZfc3dpdGNoID0gTExWTUJ1aWxkU3dpdGNoKGIs CisJCQkJCQkJCQkJCQkgICB2X3JldCwKKwkJCQkJCQkJCQkJCSAgIGJfZG9uZSwKKwkJCQkJCQkJ CQkJCSAgIGpzZXN0YXRlLT5udW1faXRlbV9jb2VyY2lvbnMgKyAzKTsKKwkJCQkJCS8qIFJldHVy bmVkIGpzZXN0YXRlLT5qdW1wX2VtcHR5PyAqLworCQkJCQkJaWYgKGpzZXN0YXRlLT5qdW1wX2Vt cHR5ID49IDApCisJCQkJCQl7CisJCQkJCQkJdl9qdW1wX2VtcHR5ID0gbF9pbnQzMl9jb25zdChs YywganNlc3RhdGUtPmp1bXBfZW1wdHkpOworCQkJCQkJCUxMVk1BZGRDYXNlKHZfc3dpdGNoLCB2 X2p1bXBfZW1wdHksIGJfZW1wdHkpOworCQkJCQkJfQorCQkJCQkJLyogUmV0dXJuZWQganNlc3Rh dGUtPmp1bXBfZXJyb3I/ICovCisJCQkJCQlpZiAoanNlc3RhdGUtPmp1bXBfZXJyb3IgPj0gMCkK KwkJCQkJCXsKKwkJCQkJCQl2X2p1bXBfZXJyb3IgPSBsX2ludDMyX2NvbnN0KGxjLCBqc2VzdGF0 ZS0+anVtcF9lcnJvcik7CisJCQkJCQkJTExWTUFkZENhc2Uodl9zd2l0Y2gsIHZfanVtcF9lcnJv ciwgYl9lcnJvcik7CisJCQkJCQl9CisJCQkJCQkvKiBSZXR1cm5lZCBqc2VzdGF0ZS0+anVtcF9l dmFsX3Jlc3VsdF9jb2VyY2lvbj8gKi8KKwkJCQkJCWlmIChqc2VzdGF0ZS0+anVtcF9ldmFsX3Jl c3VsdF9jb2VyY2lvbiA+PSAwKQorCQkJCQkJeworCQkJCQkJCXZfanVtcF9jb2VyY2lvbiA9IGxf aW50MzJfY29uc3QobGMsIGpzZXN0YXRlLT5qdW1wX2V2YWxfcmVzdWx0X2NvZXJjaW9uKTsKKwkJ CQkJCQlMTFZNQWRkQ2FzZSh2X3N3aXRjaCwgdl9qdW1wX2NvZXJjaW9uLCBiX3Jlc3VsdF9jb2Vy Y2lvbik7CisJCQkJCQl9CisJCQkJCQkvKiBSZXR1cm5lZCBvbmUgb2YganNlc3RhdGUtPmV2YWxf aXRlbV9jb2VyY2lvbl9qdW1wc1tdPyAqLworCQkJCQkJZm9yIChpID0gMDsgaSA8IGpzZXN0YXRl LT5udW1faXRlbV9jb2VyY2lvbnM7IGkrKykKKwkJCQkJCXsKKwkJCQkJCQlpZiAoanNlc3RhdGUt PmV2YWxfaXRlbV9jb2VyY2lvbl9qdW1wc1tpXSA+PSAwKQorCQkJCQkJCXsKKwkJCQkJCQkJdl9q dW1wX2NvZXJjaW9uID0gbF9pbnQzMl9jb25zdChsYywganNlc3RhdGUtPmV2YWxfaXRlbV9jb2Vy Y2lvbl9qdW1wc1tpXSk7CisJCQkJCQkJCUxMVk1BZGRDYXNlKHZfc3dpdGNoLCB2X2p1bXBfY29l cmNpb24sIGJfaXRlbV9jb2VyY2lvbnNbaV0pOworCQkJCQkJCX0KKwkJCQkJCX0KKworCQkJCQkJ LyogT04gRU1QVFkgY29kZSAqLworCQkJCQkJTExWTVBvc2l0aW9uQnVpbGRlckF0RW5kKGIsIGJf ZW1wdHkpOworCQkJCQkJaWYgKGpzZXN0YXRlLT5qdW1wX2VtcHR5ID49IDApCisJCQkJCQkJTExW TUJ1aWxkQnIoYiwgb3BibG9ja3NbanNlc3RhdGUtPmp1bXBfZW1wdHldKTsKKwkJCQkJCWVsc2UK KwkJCQkJCQlMTFZNQnVpbGRVbnJlYWNoYWJsZShiKTsKKwkJCQkJCS8qIE9OIEVSUk9SIGNvZGUg Ki8KKwkJCQkJCUxMVk1Qb3NpdGlvbkJ1aWxkZXJBdEVuZChiLCBiX2Vycm9yKTsKKwkJCQkJCWlm IChqc2VzdGF0ZS0+anVtcF9lcnJvciA+PSAwKQorCQkJCQkJCUxMVk1CdWlsZEJyKGIsIG9wYmxv Y2tzW2pzZXN0YXRlLT5qdW1wX2Vycm9yXSk7CisJCQkJCQllbHNlCisJCQkJCQkJTExWTUJ1aWxk VW5yZWFjaGFibGUoYik7CisJCQkJCQkvKiByZXN1bHRfY29lcmNpb24gY29kZSAqLworCQkJCQkJ TExWTVBvc2l0aW9uQnVpbGRlckF0RW5kKGIsIGJfcmVzdWx0X2NvZXJjaW9uKTsKKwkJCQkJCWlm IChqc2VzdGF0ZS0+anVtcF9ldmFsX3Jlc3VsdF9jb2VyY2lvbiA+PSAwKQorCQkJCQkJCUxMVk1C dWlsZEJyKGIsIG9wYmxvY2tzW2pzZXN0YXRlLT5qdW1wX2V2YWxfcmVzdWx0X2NvZXJjaW9uXSk7 CisJCQkJCQllbHNlCisJCQkJCQkJTExWTUJ1aWxkVW5yZWFjaGFibGUoYik7CisJCQkJCQkvKiBp dGVtIGNvZXJjaW9uIGNvZGUgYmxvY2tzICovCisJCQkJCQlmb3IgKGkgPSAwOyBpIDwganNlc3Rh dGUtPm51bV9pdGVtX2NvZXJjaW9uczsgaSsrKQorCQkJCQkJeworCQkJCQkJCUxMVk1Qb3NpdGlv bkJ1aWxkZXJBdEVuZChiLCBiX2l0ZW1fY29lcmNpb25zW2ldKTsKKwkJCQkJCQlpZiAoanNlc3Rh dGUtPmV2YWxfaXRlbV9jb2VyY2lvbl9qdW1wc1tpXSA+PSAwKQorCQkJCQkJCQlMTFZNQnVpbGRC cihiLCBvcGJsb2Nrc1tqc2VzdGF0ZS0+ZXZhbF9pdGVtX2NvZXJjaW9uX2p1bXBzW2ldXSk7CisJ CQkJCQkJZWxzZQorCQkJCQkJCQlMTFZNQnVpbGRVbnJlYWNoYWJsZShiKTsKKwkJCQkJCX0KKwor CQkJCQkJTExWTVBvc2l0aW9uQnVpbGRlckF0RW5kKGIsIGJfZG9uZSk7CisJCQkJCX0KKworCQkJ CQlMTFZNQnVpbGRCcihiLCBvcGJsb2Nrc1tvcG5vICsgMV0pOworCQkJCQlicmVhazsKKwkJCQl9 CisKKwkJCWNhc2UgRUVPUF9KU09ORVhQUl9DT0VSQ0lPTjoKKwkJCQlidWlsZF9FdmFsWEZ1bmMo YiwgbW9kLCAiRXhlY0V2YWxKc29uQ29lcmNpb24iLAorCQkJCQkJCQkJdl9zdGF0ZSwgb3AsIHZf ZWNvbnRleHQpOworCisJCQkJTExWTUJ1aWxkQnIoYiwgb3BibG9ja3Nbb3BubyArIDFdKTsKKwkJ CQlicmVhazsKKworCQkJY2FzZSBFRU9QX0pTT05FWFBSX0NPRVJDSU9OX0ZJTklTSDoKKwkJCQli dWlsZF9FdmFsWEZ1bmMoYiwgbW9kLCAiRXhlY0V2YWxKc29uQ29lcmNpb25GaW5pc2giLAorCQkJ CQkJCQl2X3N0YXRlLCBvcCk7CisKKwkJCQlMTFZNQnVpbGRCcihiLCBvcGJsb2Nrc1tvcG5vICsg MV0pOworCQkJCWJyZWFrOworCiAJCQljYXNlIEVFT1BfQUdHUkVGOgogCQkJCXsKIAkJCQkJTExW TVZhbHVlUmVmIHZfYWdnbm87CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9qaXQvbGx2bS9sbHZt aml0X3R5cGVzLmMgYi9zcmMvYmFja2VuZC9qaXQvbGx2bS9sbHZtaml0X3R5cGVzLmMKaW5kZXgg NDdjOWRhZjQwMi4uZWRkMWUxNjc5YiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvaml0L2xsdm0v bGx2bWppdF90eXBlcy5jCisrKyBiL3NyYy9iYWNrZW5kL2ppdC9sbHZtL2xsdm1qaXRfdHlwZXMu YwpAQCAtMTcyLDYgKzE3Miw5IEBAIHZvaWQJICAgKnJlZmVyZW5jZWRfZnVuY3Rpb25zW10gPQog CUV4ZWNFdmFsWG1sRXhwciwKIAlFeGVjRXZhbEpzb25Db25zdHJ1Y3RvciwKIAlFeGVjRXZhbEpz b25Jc1ByZWRpY2F0ZSwKKwlFeGVjRXZhbEpzb25Db2VyY2lvbiwKKwlFeGVjRXZhbEpzb25Db2Vy Y2lvbkZpbmlzaCwKKwlFeGVjRXZhbEpzb25FeHByUGF0aCwKIAlNYWtlRXhwYW5kZWRPYmplY3RS ZWFkT25seUludGVybmFsLAogCXNsb3RfZ2V0bWlzc2luZ2F0dHJzLAogCXNsb3RfZ2V0c29tZWF0 dHJzX2ludCwKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL25vZGVzL21ha2VmdW5jcy5jIGIvc3Jj L2JhY2tlbmQvbm9kZXMvbWFrZWZ1bmNzLmMKaW5kZXggYTAyMzMyYTFlYy4uMDlhMDVhMDM3MyAx MDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvbm9kZXMvbWFrZWZ1bmNzLmMKKysrIGIvc3JjL2JhY2tl bmQvbm9kZXMvbWFrZWZ1bmNzLmMKQEAgLTg1Nyw2ICs4NTcsMjQgQEAgbWFrZUpzb25WYWx1ZUV4 cHIoRXhwciAqcmF3X2V4cHIsIEV4cHIgKmZvcm1hdHRlZF9leHByLAogCXJldHVybiBqdmU7CiB9 CiAKKy8qCisgKiBtYWtlSnNvbkJlaGF2aW9yIC0KKyAqCSAgY3JlYXRlcyBhIEpzb25CZWhhdmlv ciBub2RlCisgKi8KK0pzb25CZWhhdmlvciAqCittYWtlSnNvbkJlaGF2aW9yKEpzb25CZWhhdmlv clR5cGUgdHlwZSwgTm9kZSAqZXhwciwgSnNvbkNvZXJjaW9uICpjb2VyY2lvbiwKKwkJCQkgaW50 IGxvY2F0aW9uKQoreworCUpzb25CZWhhdmlvciAqYmVoYXZpb3IgPSBtYWtlTm9kZShKc29uQmVo YXZpb3IpOworCisJYmVoYXZpb3ItPmJ0eXBlID0gdHlwZTsKKwliZWhhdmlvci0+ZXhwciA9IGV4 cHI7CisJYmVoYXZpb3ItPmNvZXJjaW9uID0gY29lcmNpb247CisJYmVoYXZpb3ItPmxvY2F0aW9u ID0gbG9jYXRpb247CisKKwlyZXR1cm4gYmVoYXZpb3I7Cit9CisKIC8qCiAgKiBtYWtlSnNvbktl eVZhbHVlIC0KICAqCSAgY3JlYXRlcyBhIEpzb25LZXlWYWx1ZSBub2RlCmRpZmYgLS1naXQgYS9z cmMvYmFja2VuZC9ub2Rlcy9ub2RlRnVuY3MuYyBiL3NyYy9iYWNrZW5kL25vZGVzL25vZGVGdW5j cy5jCmluZGV4IDAzMDQ2M2NiNDIuLmQyNzIwMjdmOGEgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5k L25vZGVzL25vZGVGdW5jcy5jCisrKyBiL3NyYy9iYWNrZW5kL25vZGVzL25vZGVGdW5jcy5jCkBA IC0yMzQsNiArMjM0LDMzIEBAIGV4cHJUeXBlKGNvbnN0IE5vZGUgKmV4cHIpCiAJCWNhc2UgVF9K c29uSXNQcmVkaWNhdGU6CiAJCQl0eXBlID0gQk9PTE9JRDsKIAkJCWJyZWFrOworCQljYXNlIFRf SnNvbkV4cHI6CisJCQl7CisJCQkJY29uc3QgSnNvbkV4cHIgKmpleHByID0gKGNvbnN0IEpzb25F eHByICopIGV4cHI7CisKKwkJCQl0eXBlID0gamV4cHItPnJldHVybmluZy0+dHlwaWQ7CisJCQkJ YnJlYWs7CisJCQl9CisJCWNhc2UgVF9Kc29uQ29lcmNpb246CisJCQl7CisJCQkJY29uc3QgSnNv bkNvZXJjaW9uICpjb2VyY2lvbiA9IChjb25zdCBKc29uQ29lcmNpb24gKikgZXhwcjsKKworCQkJ CXR5cGUgPSBjb2VyY2lvbi0+dGFyZ2V0dHlwZTsKKwkJCQlicmVhazsKKwkJCX0KKwkJY2FzZSBU X0pzb25JdGVtQ29lcmNpb246CisJCQl0eXBlID0gZXhwclR5cGUoKChKc29uSXRlbUNvZXJjaW9u ICopIGV4cHIpLT5jb2VyY2lvbik7CisJCQlicmVhazsKKwkJY2FzZSBUX0pzb25CZWhhdmlvcjoK KwkJCXsKKwkJCQljb25zdCBKc29uQmVoYXZpb3IgKmJlaGF2aW9yID0gKGNvbnN0IEpzb25CZWhh dmlvciAqKSBleHByOworCisJCQkJaWYgKGJlaGF2aW9yLT5jb2VyY2lvbikKKwkJCQkJdHlwZSA9 IGV4cHJUeXBlKChOb2RlICopIGJlaGF2aW9yLT5jb2VyY2lvbik7CisJCQkJZWxzZQorCQkJCQl0 eXBlID0gZXhwclR5cGUoYmVoYXZpb3ItPmV4cHIpOworCQkJCWJyZWFrOworCQkJfQogCQljYXNl IFRfTnVsbFRlc3Q6CiAJCQl0eXBlID0gQk9PTE9JRDsKIAkJCWJyZWFrOwpAQCAtNDkxLDggKzUx OCwzMiBAQCBleHByVHlwbW9kKGNvbnN0IE5vZGUgKmV4cHIpCiAJCQlyZXR1cm4gKChjb25zdCBT UUxWYWx1ZUZ1bmN0aW9uICopIGV4cHIpLT50eXBtb2Q7CiAJCWNhc2UgVF9Kc29uVmFsdWVFeHBy OgogCQkJcmV0dXJuIGV4cHJUeXBtb2QoKE5vZGUgKikgKChjb25zdCBKc29uVmFsdWVFeHByICop IGV4cHIpLT5mb3JtYXR0ZWRfZXhwcik7Ci0JCWNhc2UgVF9Kc29uQ29uc3RydWN0b3JFeHByOgot CQkJcmV0dXJuICgoY29uc3QgSnNvbkNvbnN0cnVjdG9yRXhwciAqKSBleHByKS0+cmV0dXJuaW5n LT50eXBtb2Q7CisJCWNhc2UgVF9Kc29uRXhwcjoKKwkJCXsKKwkJCQljb25zdCBKc29uRXhwciAq amV4cHIgPSAoY29uc3QgSnNvbkV4cHIgKikgZXhwcjsKKworCQkJCXJldHVybiBqZXhwci0+cmV0 dXJuaW5nLT50eXBtb2Q7CisJCQl9CisJCQlicmVhazsKKwkJY2FzZSBUX0pzb25Db2VyY2lvbjoK KwkJCXsKKwkJCQljb25zdCBKc29uQ29lcmNpb24gKmNvZXJjaW9uID0gKGNvbnN0IEpzb25Db2Vy Y2lvbiAqKSBleHByOworCisJCQkJcmV0dXJuIGNvZXJjaW9uLT50YXJnZXR0eXBtb2Q7CisJCQl9 CisJCQlicmVhazsKKwkJY2FzZSBUX0pzb25JdGVtQ29lcmNpb246CisJCQlyZXR1cm4gZXhwclR5 cG1vZCgoKEpzb25JdGVtQ29lcmNpb24gKikgZXhwciktPmNvZXJjaW9uKTsKKwkJY2FzZSBUX0pz b25CZWhhdmlvcjoKKwkJCXsKKwkJCQljb25zdCBKc29uQmVoYXZpb3IgKmJlaGF2aW9yID0gKGNv bnN0IEpzb25CZWhhdmlvciAqKSBleHByOworCisJCQkJaWYgKGJlaGF2aW9yLT5jb2VyY2lvbikK KwkJCQkJcmV0dXJuIGV4cHJUeXBtb2QoKE5vZGUgKikgYmVoYXZpb3ItPmNvZXJjaW9uKTsKKwkJ CQllbHNlCisJCQkJCXJldHVybiBleHByVHlwbW9kKGJlaGF2aW9yLT5leHByKTsKKwkJCX0KKwkJ CWJyZWFrOwogCQljYXNlIFRfQ29lcmNlVG9Eb21haW46CiAJCQlyZXR1cm4gKChjb25zdCBDb2Vy Y2VUb0RvbWFpbiAqKSBleHByKS0+cmVzdWx0dHlwbW9kOwogCQljYXNlIFRfQ29lcmNlVG9Eb21h aW5WYWx1ZToKQEAgLTk2OSw2ICsxMDIwLDI3IEBAIGV4cHJDb2xsYXRpb24oY29uc3QgTm9kZSAq ZXhwcikKIAkJCS8qIElTIEpTT04ncyByZXN1bHQgaXMgYm9vbGVhbiAuLi4gKi8KIAkJCWNvbGwg PSBJbnZhbGlkT2lkOwkvKiAuLi4gc28gaXQgaGFzIG5vIGNvbGxhdGlvbiAqLwogCQkJYnJlYWs7 CisJCWNhc2UgVF9Kc29uRXhwcjoKKwkJCWNvbGwgPSBleHByQ29sbGF0aW9uKCgoSnNvbkV4cHIg KikgZXhwciktPnJlc3VsdF9jb2VyY2lvbik7CisJCQlicmVhazsKKwkJY2FzZSBUX0pzb25Db2Vy Y2lvbjoKKwkJCWNvbGwgPSAoKGNvbnN0IEpzb25Db2VyY2lvbiAqKSBleHByKS0+Y29sbGF0aW9u OworCQkJYnJlYWs7CisJCWNhc2UgVF9Kc29uSXRlbUNvZXJjaW9uOgorCQkJY29sbCA9IGV4cHJD b2xsYXRpb24oKChKc29uSXRlbUNvZXJjaW9uICopIGV4cHIpLT5jb2VyY2lvbik7CisJCQlicmVh azsKKwkJY2FzZSBUX0pzb25CZWhhdmlvcjoKKwkJCXsKKwkJCQlKc29uQmVoYXZpb3IgKmJlaGF2 aW9yID0gKEpzb25CZWhhdmlvciAqKSBleHByOworCisJCQkJaWYgKGJlaGF2aW9yLT5jb2VyY2lv bikKKwkJCQkJY29sbCA9IGV4cHJDb2xsYXRpb24oKE5vZGUgKikgYmVoYXZpb3ItPmNvZXJjaW9u KTsKKwkJCQllbHNlIGlmIChiZWhhdmlvci0+ZXhwcikKKwkJCQkJY29sbCA9IGV4cHJDb2xsYXRp b24oYmVoYXZpb3ItPmV4cHIpOworCQkJCWVsc2UKKwkJCQkJY29sbCA9IEludmFsaWRPaWQ7CisJ CQl9CisJCQlicmVhazsKIAkJY2FzZSBUX051bGxUZXN0OgogCQkJLyogTnVsbFRlc3QncyByZXN1 bHQgaXMgYm9vbGVhbiAuLi4gKi8KIAkJCWNvbGwgPSBJbnZhbGlkT2lkOwkvKiAuLi4gc28gaXQg aGFzIG5vIGNvbGxhdGlvbiAqLwpAQCAtMTIwNSw2ICsxMjc3LDQyIEBAIGV4cHJTZXRDb2xsYXRp b24oTm9kZSAqZXhwciwgT2lkIGNvbGxhdGlvbikKIAkJY2FzZSBUX0pzb25Jc1ByZWRpY2F0ZToK IAkJCUFzc2VydCghT2lkSXNWYWxpZChjb2xsYXRpb24pKTsgLyogcmVzdWx0IGlzIGFsd2F5cyBi b29sZWFuICovCiAJCQlicmVhazsKKwkJY2FzZSBUX0pzb25FeHByOgorCQkJeworCQkJCUpzb25F eHByICAgKmpleHByID0gKEpzb25FeHByICopIGV4cHI7CisKKwkJCQlpZiAoamV4cHItPnJlc3Vs dF9jb2VyY2lvbikKKwkJCQkJZXhwclNldENvbGxhdGlvbigoTm9kZSAqKSBqZXhwci0+cmVzdWx0 X2NvZXJjaW9uLCBjb2xsYXRpb24pOworCQkJCWVsc2UKKwkJCQkJQXNzZXJ0KCFPaWRJc1ZhbGlk KGNvbGxhdGlvbikpOyAvKiByZXN1bHQgaXMgYWx3YXlzIGEKKwkJCQkJCQkJCQkJCQkgKiBqc29u W2JdIHR5cGUgKi8KKwkJCX0KKwkJCWJyZWFrOworCQljYXNlIFRfSnNvbkl0ZW1Db2VyY2lvbjoK KwkJCXsKKwkJCQlKc29uSXRlbUNvZXJjaW9uICppdGVtX2NvZXJjaW9uID0gKEpzb25JdGVtQ29l cmNpb24gKikgZXhwcjsKKworCQkJCWlmIChpdGVtX2NvZXJjaW9uLT5jb2VyY2lvbikKKwkJCQkJ ZXhwclNldENvbGxhdGlvbihpdGVtX2NvZXJjaW9uLT5jb2VyY2lvbiwgY29sbGF0aW9uKTsKKwkJ CX0KKwkJCWJyZWFrOworCQljYXNlIFRfSnNvbkNvZXJjaW9uOgorCQkJeworCQkJCUpzb25Db2Vy Y2lvbiAqY29lcmNpb24gPSAoSnNvbkNvZXJjaW9uICopIGV4cHI7CisKKwkJCQljb2VyY2lvbi0+ Y29sbGF0aW9uID0gY29sbGF0aW9uOworCQkJfQorCQkJYnJlYWs7CisJCWNhc2UgVF9Kc29uQmVo YXZpb3I6CisJCQl7CisJCQkJSnNvbkJlaGF2aW9yICpiZWhhdmlvciA9IChKc29uQmVoYXZpb3Ig KikgZXhwcjsKKworCQkJCWlmIChiZWhhdmlvci0+ZXhwcikKKwkJCQkJZXhwclNldENvbGxhdGlv bihiZWhhdmlvci0+ZXhwciwgY29sbGF0aW9uKTsKKwkJCQlpZiAoYmVoYXZpb3ItPmNvZXJjaW9u KQorCQkJCQlleHByU2V0Q29sbGF0aW9uKChOb2RlICopIGJlaGF2aW9yLT5jb2VyY2lvbiwgY29s bGF0aW9uKTsKKwkJCX0KKwkJCWJyZWFrOwogCQljYXNlIFRfTnVsbFRlc3Q6CiAJCQkvKiBOdWxs VGVzdCdzIHJlc3VsdCBpcyBib29sZWFuIC4uLiAqLwogCQkJQXNzZXJ0KCFPaWRJc1ZhbGlkKGNv bGxhdGlvbikpOyAvKiAuLi4gc28gbmV2ZXIgc2V0IGEgY29sbGF0aW9uICovCkBAIC0xNTA4LDYg KzE2MTYsMTggQEAgZXhwckxvY2F0aW9uKGNvbnN0IE5vZGUgKmV4cHIpCiAJCWNhc2UgVF9Kc29u SXNQcmVkaWNhdGU6CiAJCQlsb2MgPSAoKGNvbnN0IEpzb25Jc1ByZWRpY2F0ZSAqKSBleHByKS0+ bG9jYXRpb247CiAJCQlicmVhazsKKwkJY2FzZSBUX0pzb25FeHByOgorCQkJeworCQkJCWNvbnN0 IEpzb25FeHByICpqc2V4cHIgPSAoY29uc3QgSnNvbkV4cHIgKikgZXhwcjsKKworCQkJCS8qIGNv bnNpZGVyIGJvdGggZnVuY3Rpb24gbmFtZSBhbmQgbGVmdG1vc3QgYXJnICovCisJCQkJbG9jID0g bGVmdG1vc3RMb2MoanNleHByLT5sb2NhdGlvbiwKKwkJCQkJCQkJICBleHByTG9jYXRpb24oanNl eHByLT5mb3JtYXR0ZWRfZXhwcikpOworCQkJfQorCQkJYnJlYWs7CisJCWNhc2UgVF9Kc29uQmVo YXZpb3I6CisJCQlsb2MgPSBleHByTG9jYXRpb24oKChKc29uQmVoYXZpb3IgKikgZXhwciktPmV4 cHIpOworCQkJYnJlYWs7CiAJCWNhc2UgVF9OdWxsVGVzdDoKIAkJCXsKIAkJCQljb25zdCBOdWxs VGVzdCAqbmV4cHIgPSAoY29uc3QgTnVsbFRlc3QgKikgZXhwcjsKQEAgLTIyNjAsNiArMjM4MCw0 NSBAQCBleHByZXNzaW9uX3RyZWVfd2Fsa2VyX2ltcGwoTm9kZSAqbm9kZSwKIAkJCWJyZWFrOwog CQljYXNlIFRfSnNvbklzUHJlZGljYXRlOgogCQkJcmV0dXJuIFdBTEsoKChKc29uSXNQcmVkaWNh dGUgKikgbm9kZSktPmV4cHIpOworCQljYXNlIFRfSnNvbkV4cHI6CisJCQl7CisJCQkJSnNvbkV4 cHIgICAqamV4cHIgPSAoSnNvbkV4cHIgKikgbm9kZTsKKworCQkJCWlmIChXQUxLKGpleHByLT5m b3JtYXR0ZWRfZXhwcikpCisJCQkJCXJldHVybiB0cnVlOworCQkJCWlmIChXQUxLKGpleHByLT5y ZXN1bHRfY29lcmNpb24pKQorCQkJCQlyZXR1cm4gdHJ1ZTsKKwkJCQlpZiAoV0FMSyhqZXhwci0+ aXRlbV9jb2VyY2lvbnMpKQorCQkJCQlyZXR1cm4gdHJ1ZTsKKwkJCQlpZiAoV0FMSyhqZXhwci0+ cGFzc2luZ192YWx1ZXMpKQorCQkJCQlyZXR1cm4gdHJ1ZTsKKwkJCQkvKiB3ZSBhc3N1bWUgd2Fs a2VyIGRvZXNuJ3QgY2FyZSBhYm91dCBwYXNzaW5nX25hbWVzICovCisJCQkJaWYgKFdBTEsoamV4 cHItPm9uX2VtcHR5KSkKKwkJCQkJcmV0dXJuIHRydWU7CisJCQkJaWYgKFdBTEsoamV4cHItPm9u X2Vycm9yKSkKKwkJCQkJcmV0dXJuIHRydWU7CisJCQl9CisJCQlicmVhazsKKwkJY2FzZSBUX0pz b25Db2VyY2lvbjoKKwkJCWJyZWFrOworCQljYXNlIFRfSnNvbkl0ZW1Db2VyY2lvbjoKKwkJCXsK KwkJCQlKc29uSXRlbUNvZXJjaW9uICAgKml0ZW1fY29lcmNpb24gPSAoSnNvbkl0ZW1Db2VyY2lv biAqKSBub2RlOworCisJCQkJaWYgKFdBTEsoaXRlbV9jb2VyY2lvbi0+Y29lcmNpb24pKQorCQkJ CQlyZXR1cm4gdHJ1ZTsKKwkJCX0KKwkJCWJyZWFrOworCQljYXNlIFRfSnNvbkJlaGF2aW9yOgor CQkJeworCQkJCUpzb25CZWhhdmlvciAgICpiZWhhdmlvciA9IChKc29uQmVoYXZpb3IgKikgbm9k ZTsKKworCQkJCWlmIChXQUxLKGJlaGF2aW9yLT5leHByKSkKKwkJCQkJcmV0dXJuIHRydWU7CisJ CQkJaWYgKFdBTEsoYmVoYXZpb3ItPmNvZXJjaW9uKSkKKwkJCQkJcmV0dXJuIHRydWU7CisJCQl9 CisJCQlicmVhazsKIAkJY2FzZSBUX051bGxUZXN0OgogCQkJcmV0dXJuIFdBTEsoKChOdWxsVGVz dCAqKSBub2RlKS0+YXJnKTsKIAkJY2FzZSBUX0Jvb2xlYW5UZXN0OgpAQCAtMzI1OSw2ICszNDE4 LDQ2IEBAIGV4cHJlc3Npb25fdHJlZV9tdXRhdG9yX2ltcGwoTm9kZSAqbm9kZSwKIAogCQkJCXJl dHVybiAoTm9kZSAqKSBuZXdub2RlOwogCQkJfQorCQljYXNlIFRfSnNvbkV4cHI6CisJCQl7CisJ CQkJSnNvbkV4cHIgICAqamV4cHIgPSAoSnNvbkV4cHIgKikgbm9kZTsKKwkJCQlKc29uRXhwciAg ICpuZXdub2RlOworCisJCQkJRkxBVENPUFkobmV3bm9kZSwgamV4cHIsIEpzb25FeHByKTsKKwkJ CQlNVVRBVEUobmV3bm9kZS0+cGF0aF9zcGVjLCBqZXhwci0+cGF0aF9zcGVjLCBOb2RlICopOwor CQkJCU1VVEFURShuZXdub2RlLT5mb3JtYXR0ZWRfZXhwciwgamV4cHItPmZvcm1hdHRlZF9leHBy LCBOb2RlICopOworCQkJCU1VVEFURShuZXdub2RlLT5yZXN1bHRfY29lcmNpb24sIGpleHByLT5y ZXN1bHRfY29lcmNpb24sIE5vZGUgKik7CisJCQkJTVVUQVRFKG5ld25vZGUtPml0ZW1fY29lcmNp b25zLCBqZXhwci0+aXRlbV9jb2VyY2lvbnMsIExpc3QgKik7CisJCQkJTVVUQVRFKG5ld25vZGUt PnBhc3NpbmdfdmFsdWVzLCBqZXhwci0+cGFzc2luZ192YWx1ZXMsIExpc3QgKik7CisJCQkJLyog YXNzdW1lIG11dGF0b3IgZG9lcyBub3QgY2FyZSBhYm91dCBwYXNzaW5nX25hbWVzICovCisJCQkJ TVVUQVRFKG5ld25vZGUtPm9uX2VtcHR5LCBqZXhwci0+b25fZW1wdHksIEpzb25CZWhhdmlvciAq KTsKKwkJCQlNVVRBVEUobmV3bm9kZS0+b25fZXJyb3IsIGpleHByLT5vbl9lcnJvciwgSnNvbkJl aGF2aW9yICopOworCQkJCXJldHVybiAoTm9kZSAqKSBuZXdub2RlOworCQkJfQorCQkJYnJlYWs7 CisJCWNhc2UgVF9Kc29uQ29lcmNpb246CisJCQlyZXR1cm4gKE5vZGUgKikgY29weU9iamVjdChu b2RlKTsKKwkJY2FzZSBUX0pzb25JdGVtQ29lcmNpb246CisJCQl7CisJCQkJSnNvbkl0ZW1Db2Vy Y2lvbiAgICppdGVtX2NvZXJjaW9uID0gKEpzb25JdGVtQ29lcmNpb24gKikgbm9kZTsKKwkJCQlK c29uSXRlbUNvZXJjaW9uICAgKm5ld25vZGU7CisKKwkJCQlGTEFUQ09QWShuZXdub2RlLCBpdGVt X2NvZXJjaW9uLCBKc29uSXRlbUNvZXJjaW9uKTsKKwkJCQlNVVRBVEUobmV3bm9kZS0+Y29lcmNp b24sIGl0ZW1fY29lcmNpb24tPmNvZXJjaW9uLCBOb2RlICopOworCQkJCXJldHVybiAoTm9kZSAq KSBuZXdub2RlOworCQkJfQorCQkJYnJlYWs7CisJCWNhc2UgVF9Kc29uQmVoYXZpb3I6CisJCQl7 CisJCQkJSnNvbkJlaGF2aW9yICAgKmJlaGF2aW9yID0gKEpzb25CZWhhdmlvciAqKSBub2RlOwor CQkJCUpzb25CZWhhdmlvciAgICpuZXdub2RlOworCisJCQkJRkxBVENPUFkobmV3bm9kZSwgYmVo YXZpb3IsIEpzb25CZWhhdmlvcik7CisJCQkJTVVUQVRFKG5ld25vZGUtPmV4cHIsIGJlaGF2aW9y LT5leHByLCBOb2RlICopOworCQkJCU1VVEFURShuZXdub2RlLT5jb2VyY2lvbiwgYmVoYXZpb3It PmNvZXJjaW9uLCBKc29uQ29lcmNpb24gKik7CisJCQkJcmV0dXJuIChOb2RlICopIG5ld25vZGU7 CisJCQl9CisJCQlicmVhazsKIAkJY2FzZSBUX051bGxUZXN0OgogCQkJewogCQkJCU51bGxUZXN0 ICAgKm50ZXN0ID0gKE51bGxUZXN0ICopIG5vZGU7CkBAIC0zOTQ1LDYgKzQxNDQsMzYgQEAgcmF3 X2V4cHJlc3Npb25fdHJlZV93YWxrZXJfaW1wbChOb2RlICpub2RlLAogCQkJYnJlYWs7CiAJCWNh c2UgVF9Kc29uSXNQcmVkaWNhdGU6CiAJCQlyZXR1cm4gV0FMSygoKEpzb25Jc1ByZWRpY2F0ZSAq KSBub2RlKS0+ZXhwcik7CisJCWNhc2UgVF9Kc29uQXJndW1lbnQ6CisJCQlyZXR1cm4gV0FMSygo KEpzb25Bcmd1bWVudCAqKSBub2RlKS0+dmFsKTsKKwkJY2FzZSBUX0pzb25GdW5jRXhwcjoKKwkJ CXsKKwkJCQlKc29uRnVuY0V4cHIgKmpmZSA9IChKc29uRnVuY0V4cHIgKikgbm9kZTsKKworCQkJ CWlmIChXQUxLKGpmZS0+Y29udGV4dF9pdGVtKSkKKwkJCQkJcmV0dXJuIHRydWU7CisJCQkJaWYg KFdBTEsoamZlLT5wYXRoc3BlYykpCisJCQkJCXJldHVybiB0cnVlOworCQkJCWlmIChXQUxLKGpm ZS0+cGFzc2luZykpCisJCQkJCXJldHVybiB0cnVlOworCQkJCWlmIChqZmUtPm91dHB1dCAmJiBX QUxLKGpmZS0+b3V0cHV0KSkKKwkJCQkJcmV0dXJuIHRydWU7CisJCQkJaWYgKGpmZS0+b25fZW1w dHkpCisJCQkJCXJldHVybiB0cnVlOworCQkJCWlmIChqZmUtPm9uX2Vycm9yKQorCQkJCQlyZXR1 cm4gdHJ1ZTsKKwkJCX0KKwkJCWJyZWFrOworCQljYXNlIFRfSnNvbkJlaGF2aW9yOgorCQkJewor CQkJCUpzb25CZWhhdmlvciAqamIgPSAoSnNvbkJlaGF2aW9yICopIG5vZGU7CisKKwkJCQlpZiAo V0FMSyhqYi0+ZXhwcikpCisJCQkJCXJldHVybiB0cnVlOworCQkJCWlmIChXQUxLKGpiLT5jb2Vy Y2lvbikpCisJCQkJCXJldHVybiB0cnVlOworCQkJfQorCQkJYnJlYWs7CiAJCWNhc2UgVF9OdWxs VGVzdDoKIAkJCXJldHVybiBXQUxLKCgoTnVsbFRlc3QgKikgbm9kZSktPmFyZyk7CiAJCWNhc2Ug VF9Cb29sZWFuVGVzdDoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL29wdGltaXplci9wYXRoL2Nv c3RzaXplLmMgYi9zcmMvYmFja2VuZC9vcHRpbWl6ZXIvcGF0aC9jb3N0c2l6ZS5jCmluZGV4IDhi NzZlOTg1MjkuLjRjZDYwNmNhNzMgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL29wdGltaXplci9w YXRoL2Nvc3RzaXplLmMKKysrIGIvc3JjL2JhY2tlbmQvb3B0aW1pemVyL3BhdGgvY29zdHNpemUu YwpAQCAtNDg3OSw3ICs0ODc5LDggQEAgY29zdF9xdWFsX2V2YWxfd2Fsa2VyKE5vZGUgKm5vZGUs IGNvc3RfcXVhbF9ldmFsX2NvbnRleHQgKmNvbnRleHQpCiAJCQkgSXNBKG5vZGUsIFNRTFZhbHVl RnVuY3Rpb24pIHx8CiAJCQkgSXNBKG5vZGUsIFhtbEV4cHIpIHx8CiAJCQkgSXNBKG5vZGUsIENv ZXJjZVRvRG9tYWluKSB8fAotCQkJIElzQShub2RlLCBOZXh0VmFsdWVFeHByKSkKKwkJCSBJc0Eo bm9kZSwgTmV4dFZhbHVlRXhwcikgfHwKKwkJCSBJc0Eobm9kZSwgSnNvbkV4cHIpKQogCXsKIAkJ LyogVHJlYXQgYWxsIHRoZXNlIGFzIGhhdmluZyBjb3N0IDEgKi8KIAkJY29udGV4dC0+dG90YWwu cGVyX3R1cGxlICs9IGNwdV9vcGVyYXRvcl9jb3N0OwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQv b3B0aW1pemVyL3V0aWwvY2xhdXNlcy5jIGIvc3JjL2JhY2tlbmQvb3B0aW1pemVyL3V0aWwvY2xh dXNlcy5jCmluZGV4IDk0ZWI1NmExZTcuLjg4NDk4NjRjYWQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNr ZW5kL29wdGltaXplci91dGlsL2NsYXVzZXMuYworKysgYi9zcmMvYmFja2VuZC9vcHRpbWl6ZXIv dXRpbC9jbGF1c2VzLmMKQEAgLTUzLDYgKzUzLDcgQEAKICNpbmNsdWRlICJ1dGlscy9mbWdyb2lk cy5oIgogI2luY2x1ZGUgInV0aWxzL2pzb24uaCIKICNpbmNsdWRlICJ1dGlscy9qc29uYi5oIgor I2luY2x1ZGUgInV0aWxzL2pzb25wYXRoLmgiCiAjaW5jbHVkZSAidXRpbHMvbHN5c2NhY2hlLmgi CiAjaW5jbHVkZSAidXRpbHMvbWVtdXRpbHMuaCIKICNpbmNsdWRlICJ1dGlscy9zeXNjYWNoZS5o IgpAQCAtNDE3LDYgKzQxOCwyNCBAQCBjb250YWluX211dGFibGVfZnVuY3Rpb25zX3dhbGtlcihO b2RlICpub2RlLCB2b2lkICpjb250ZXh0KQogCQkvKiBDaGVjayBhbGwgc3Vibm9kZXMgKi8KIAl9 CiAKKwlpZiAoSXNBKG5vZGUsIEpzb25FeHByKSkKKwl7CisJCUpzb25FeHByICAgKmpleHByID0g Y2FzdE5vZGUoSnNvbkV4cHIsIG5vZGUpOworCQlDb25zdAkgICAqY25zdDsKKworCQlpZiAoIUlz QShqZXhwci0+cGF0aF9zcGVjLCBDb25zdCkpCisJCQlyZXR1cm4gdHJ1ZTsKKworCQljbnN0ID0g Y2FzdE5vZGUoQ29uc3QsIGpleHByLT5wYXRoX3NwZWMpOworCisJCUFzc2VydChjbnN0LT5jb25z dHR5cGUgPT0gSlNPTlBBVEhPSUQpOworCQlpZiAoY25zdC0+Y29uc3Rpc251bGwpCisJCQlyZXR1 cm4gZmFsc2U7CisKKwkJcmV0dXJuIGpzcElzTXV0YWJsZShEYXR1bUdldEpzb25QYXRoUChjbnN0 LT5jb25zdHZhbHVlKSwKKwkJCQkJCQlqZXhwci0+cGFzc2luZ19uYW1lcywgamV4cHItPnBhc3Np bmdfdmFsdWVzKTsKKwl9CisKIAlpZiAoSXNBKG5vZGUsIFNRTFZhbHVlRnVuY3Rpb24pKQogCXsK IAkJLyogYWxsIHZhcmlhbnRzIG9mIFNRTFZhbHVlRnVuY3Rpb24gYXJlIHN0YWJsZSAqLwpkaWZm IC0tZ2l0IGEvc3JjL2JhY2tlbmQvcGFyc2VyL2dyYW0ueSBiL3NyYy9iYWNrZW5kL3BhcnNlci9n cmFtLnkKaW5kZXggNmI4ODA5NmU4ZS4uYWQ5NWFmMGQ5MSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tl bmQvcGFyc2VyL2dyYW0ueQorKysgYi9zcmMvYmFja2VuZC9wYXJzZXIvZ3JhbS55CkBAIC02NTEs MTAgKzY1MSwxOSBAQCBzdGF0aWMgTm9kZSAqbWFrZVJlY3Vyc2l2ZVZpZXdTZWxlY3QoY2hhciAq cmVsbmFtZSwgTGlzdCAqYWxpYXNlcywgTm9kZSAqcXVlcnkpOwogCQkJCWpzb25fcmV0dXJuaW5n X2NsYXVzZV9vcHQKIAkJCQlqc29uX25hbWVfYW5kX3ZhbHVlCiAJCQkJanNvbl9hZ2dyZWdhdGVf ZnVuYworCQkJCWpzb25fYXJndW1lbnQKKwkJCQlqc29uX2JlaGF2aW9yCisJCQkJanNvbl9vbl9l cnJvcl9jbGF1c2Vfb3B0CiAldHlwZSA8bGlzdD4JanNvbl9uYW1lX2FuZF92YWx1ZV9saXN0CiAJ CQkJanNvbl92YWx1ZV9leHByX2xpc3QKIAkJCQlqc29uX2FycmF5X2FnZ3JlZ2F0ZV9vcmRlcl9i eV9jbGF1c2Vfb3B0Ci0ldHlwZSA8aXZhbD4JanNvbl9wcmVkaWNhdGVfdHlwZV9jb25zdHJhaW50 CisJCQkJanNvbl9hcmd1bWVudHMKKwkJCQlqc29uX2JlaGF2aW9yX2NsYXVzZV9vcHQKKwkJCQlq c29uX3Bhc3NpbmdfY2xhdXNlX29wdAorJXR5cGUgPGl2YWw+CWpzb25fYmVoYXZpb3JfdHlwZQor CQkJCWpzb25fcHJlZGljYXRlX3R5cGVfY29uc3RyYWludAorCQkJCWpzb25fcXVvdGVzX2NsYXVz ZV9vcHQKKwkJCQlqc29uX3dyYXBwZXJfYmVoYXZpb3IKICV0eXBlIDxib29sZWFuPglqc29uX2tl eV91bmlxdWVuZXNzX2NvbnN0cmFpbnRfb3B0CiAJCQkJanNvbl9vYmplY3RfY29uc3RydWN0b3Jf bnVsbF9jbGF1c2Vfb3B0CiAJCQkJanNvbl9hcnJheV9jb25zdHJ1Y3Rvcl9udWxsX2NsYXVzZV9v cHQKQEAgLTY5NSw3ICs3MDQsNyBAQCBzdGF0aWMgTm9kZSAqbWFrZVJlY3Vyc2l2ZVZpZXdTZWxl Y3QoY2hhciAqcmVsbmFtZSwgTGlzdCAqYWxpYXNlcywgTm9kZSAqcXVlcnkpOwogCUNBQ0hFIENB TEwgQ0FMTEVEIENBU0NBREUgQ0FTQ0FERUQgQ0FTRSBDQVNUIENBVEFMT0dfUCBDSEFJTiBDSEFS X1AKIAlDSEFSQUNURVIgQ0hBUkFDVEVSSVNUSUNTIENIRUNLIENIRUNLUE9JTlQgQ0xBU1MgQ0xP U0UKIAlDTFVTVEVSIENPQUxFU0NFIENPTExBVEUgQ09MTEFUSU9OIENPTFVNTiBDT0xVTU5TIENP TU1FTlQgQ09NTUVOVFMgQ09NTUlUCi0JQ09NTUlUVEVEIENPTVBSRVNTSU9OIENPTkNVUlJFTlRM WSBDT05GSUdVUkFUSU9OIENPTkZMSUNUCisJQ09NTUlUVEVEIENPTVBSRVNTSU9OIENPTkNVUlJF TlRMWSBDT05ESVRJT05BTCBDT05GSUdVUkFUSU9OIENPTkZMSUNUCiAJQ09OTkVDVElPTiBDT05T VFJBSU5UIENPTlNUUkFJTlRTIENPTlRFTlRfUCBDT05USU5VRV9QIENPTlZFUlNJT05fUCBDT1BZ CiAJQ09TVCBDUkVBVEUgQ1JPU1MgQ1NWIENVQkUgQ1VSUkVOVF9QCiAJQ1VSUkVOVF9DQVRBTE9H IENVUlJFTlRfREFURSBDVVJSRU5UX1JPTEUgQ1VSUkVOVF9TQ0hFTUEKQEAgLTcwNiw4ICs3MTUs OCBAQCBzdGF0aWMgTm9kZSAqbWFrZVJlY3Vyc2l2ZVZpZXdTZWxlY3QoY2hhciAqcmVsbmFtZSwg TGlzdCAqYWxpYXNlcywgTm9kZSAqcXVlcnkpOwogCURFVEFDSCBESUNUSU9OQVJZIERJU0FCTEVf UCBESVNDQVJEIERJU1RJTkNUIERPIERPQ1VNRU5UX1AgRE9NQUlOX1AKIAlET1VCTEVfUCBEUk9Q CiAKLQlFQUNIIEVMU0UgRU5BQkxFX1AgRU5DT0RJTkcgRU5DUllQVEVEIEVORF9QIEVOVU1fUCBF U0NBUEUgRVZFTlQgRVhDRVBUCi0JRVhDTFVERSBFWENMVURJTkcgRVhDTFVTSVZFIEVYRUNVVEUg RVhJU1RTIEVYUExBSU4gRVhQUkVTU0lPTgorCUVBQ0ggRUxTRSBFTVBUWV9QIEVOQUJMRV9QIEVO Q09ESU5HIEVOQ1JZUFRFRCBFTkRfUCBFTlVNX1AgRVJST1JfUCBFU0NBUEUKKwlFVkVOVCBFWENF UFQgRVhDTFVERSBFWENMVURJTkcgRVhDTFVTSVZFIEVYRUNVVEUgRVhJU1RTIEVYUExBSU4gRVhQ UkVTU0lPTgogCUVYVEVOU0lPTiBFWFRFUk5BTCBFWFRSQUNUCiAKIAlGQUxTRV9QIEZBTUlMWSBG RVRDSCBGSUxURVIgRklOQUxJWkUgRklSU1RfUCBGTE9BVF9QIEZPTExPV0lORyBGT1IKQEAgLTcy MiwxMCArNzMxLDEwIEBAIHN0YXRpYyBOb2RlICptYWtlUmVjdXJzaXZlVmlld1NlbGVjdChjaGFy ICpyZWxuYW1lLCBMaXN0ICphbGlhc2VzLCBOb2RlICpxdWVyeSk7CiAJSU5ORVJfUCBJTk9VVCBJ TlBVVF9QIElOU0VOU0lUSVZFIElOU0VSVCBJTlNURUFEIElOVF9QIElOVEVHRVIKIAlJTlRFUlNF Q1QgSU5URVJWQUwgSU5UTyBJTlZPS0VSIElTIElTTlVMTCBJU09MQVRJT04KIAotCUpPSU4gSlNP TiBKU09OX0FSUkFZIEpTT05fQVJSQVlBR0cgSlNPTl9PQkpFQ1QgSlNPTl9PQkpFQ1RBR0cKLQlK U09OX1NDQUxBUiBKU09OX1NFUklBTElaRQorCUpPSU4gSlNPTiBKU09OX0FSUkFZIEpTT05fQVJS QVlBR0cgSlNPTl9FWElTVFMgSlNPTl9PQkpFQ1QgSlNPTl9PQkpFQ1RBR0cKKwlKU09OX1FVRVJZ IEpTT05fU0NBTEFSIEpTT05fU0VSSUFMSVpFIEpTT05fVkFMVUUKIAotCUtFWSBLRVlTCisJS0VF UCBLRVkgS0VZUwogCiAJTEFCRUwgTEFOR1VBR0UgTEFSR0VfUCBMQVNUX1AgTEFURVJBTF9QCiAJ TEVBRElORyBMRUFLUFJPT0YgTEVBU1QgTEVGVCBMRVZFTCBMSUtFIExJTUlUIExJU1RFTiBMT0FE IExPQ0FMCkBAIC03MzksNyArNzQ4LDcgQEAgc3RhdGljIE5vZGUgKm1ha2VSZWN1cnNpdmVWaWV3 U2VsZWN0KGNoYXIgKnJlbG5hbWUsIExpc3QgKmFsaWFzZXMsIE5vZGUgKnF1ZXJ5KTsKIAlOT1Qg Tk9USElORyBOT1RJRlkgTk9UTlVMTCBOT1dBSVQgTlVMTF9QIE5VTExJRgogCU5VTExTX1AgTlVN RVJJQwogCi0JT0JKRUNUX1AgT0YgT0ZGIE9GRlNFVCBPSURTIE9MRCBPTiBPTkxZIE9QRVJBVE9S IE9QVElPTiBPUFRJT05TIE9SCisJT0JKRUNUX1AgT0YgT0ZGIE9GRlNFVCBPSURTIE9MRCBPTUlU IE9OIE9OTFkgT1BFUkFUT1IgT1BUSU9OIE9QVElPTlMgT1IKIAlPUkRFUiBPUkRJTkFMSVRZIE9U SEVSUyBPVVRfUCBPVVRFUl9QCiAJT1ZFUiBPVkVSTEFQUyBPVkVSTEFZIE9WRVJSSURJTkcgT1dO RUQgT1dORVIKIApAQCAtNzQ4LDcgKzc1Nyw3IEBAIHN0YXRpYyBOb2RlICptYWtlUmVjdXJzaXZl Vmlld1NlbGVjdChjaGFyICpyZWxuYW1lLCBMaXN0ICphbGlhc2VzLCBOb2RlICpxdWVyeSk7CiAJ UE9TSVRJT04gUFJFQ0VESU5HIFBSRUNJU0lPTiBQUkVTRVJWRSBQUkVQQVJFIFBSRVBBUkVEIFBS SU1BUlkKIAlQUklPUiBQUklWSUxFR0VTIFBST0NFRFVSQUwgUFJPQ0VEVVJFIFBST0NFRFVSRVMg UFJPR1JBTSBQVUJMSUNBVElPTgogCi0JUVVPVEUKKwlRVU9URSBRVU9URVMKIAogCVJBTkdFIFJF QUQgUkVBTCBSRUFTU0lHTiBSRUNIRUNLIFJFQ1VSU0lWRSBSRUZfUCBSRUZFUkVOQ0VTIFJFRkVS RU5DSU5HCiAJUkVGUkVTSCBSRUlOREVYIFJFTEFUSVZFX1AgUkVMRUFTRSBSRU5BTUUgUkVQRUFU QUJMRSBSRVBMQUNFIFJFUExJQ0EKQEAgLTc1OSw3ICs3NjgsNyBAQCBzdGF0aWMgTm9kZSAqbWFr ZVJlY3Vyc2l2ZVZpZXdTZWxlY3QoY2hhciAqcmVsbmFtZSwgTGlzdCAqYWxpYXNlcywgTm9kZSAq cXVlcnkpOwogCVNFUVVFTkNFIFNFUVVFTkNFUwogCVNFUklBTElaQUJMRSBTRVJWRVIgU0VTU0lP TiBTRVNTSU9OX1VTRVIgU0VUIFNFVFMgU0VUT0YgU0hBUkUgU0hPVwogCVNJTUlMQVIgU0lNUExF IFNLSVAgU01BTExJTlQgU05BUFNIT1QgU09NRSBTUUxfUCBTVEFCTEUgU1RBTkRBTE9ORV9QCi0J U1RBUlQgU1RBVEVNRU5UIFNUQVRJU1RJQ1MgU1RESU4gU1RET1VUIFNUT1JBR0UgU1RPUkVEIFNU UklDVF9QIFNUUklQX1AKKwlTVEFSVCBTVEFURU1FTlQgU1RBVElTVElDUyBTVERJTiBTVERPVVQg U1RPUkFHRSBTVE9SRUQgU1RSSUNUX1AgU1RSSU5HX1AgU1RSSVBfUAogCVNVQlNDUklQVElPTiBT VUJTVFJJTkcgU1VQUE9SVCBTWU1NRVRSSUMgU1lTSUQgU1lTVEVNX1AgU1lTVEVNX1VTRVIKIAog CVRBQkxFIFRBQkxFUyBUQUJMRVNBTVBMRSBUQUJMRVNQQUNFIFRFTVAgVEVNUExBVEUgVEVNUE9S QVJZIFRFWFRfUCBUSEVOCkBAIC03NjcsNyArNzc2LDcgQEAgc3RhdGljIE5vZGUgKm1ha2VSZWN1 cnNpdmVWaWV3U2VsZWN0KGNoYXIgKnJlbG5hbWUsIExpc3QgKmFsaWFzZXMsIE5vZGUgKnF1ZXJ5 KTsKIAlUUkVBVCBUUklHR0VSIFRSSU0gVFJVRV9QCiAJVFJVTkNBVEUgVFJVU1RFRCBUWVBFX1Ag VFlQRVNfUAogCi0JVUVTQ0FQRSBVTkJPVU5ERUQgVU5DT01NSVRURUQgVU5FTkNSWVBURUQgVU5J T04gVU5JUVVFIFVOS05PV04KKwlVRVNDQVBFIFVOQk9VTkRFRCBVTkNPTkRJVElPTkFMIFVOQ09N TUlUVEVEIFVORU5DUllQVEVEIFVOSU9OIFVOSVFVRSBVTktOT1dOCiAJVU5MSVNURU4gVU5MT0dH RUQgVU5USUwgVVBEQVRFIFVTRVIgVVNJTkcKIAogCVZBQ1VVTSBWQUxJRCBWQUxJREFURSBWQUxJ REFUT1IgVkFMVUVfUCBWQUxVRVMgVkFSQ0hBUiBWQVJJQURJQyBWQVJZSU5HCkBAIC0xNTc3Niw2 ICsxNTc4NSw2MiBAQCBmdW5jX2V4cHJfY29tbW9uX3N1YmV4cHI6CiAJCQkJCW4tPmxvY2F0aW9u ID0gQDE7CiAJCQkJCSQkID0gKE5vZGUgKikgbjsKIAkJCQl9CisJCQl8IEpTT05fUVVFUlkgJygn CisJCQkJanNvbl92YWx1ZV9leHByICcsJyBhX2V4cHIganNvbl9wYXNzaW5nX2NsYXVzZV9vcHQK KwkJCQlqc29uX3JldHVybmluZ19jbGF1c2Vfb3B0CisJCQkJanNvbl93cmFwcGVyX2JlaGF2aW9y CisJCQkJanNvbl9xdW90ZXNfY2xhdXNlX29wdAorCQkJCWpzb25fYmVoYXZpb3JfY2xhdXNlX29w dAorCQkJJyknCisJCQkJeworCQkJCQlKc29uRnVuY0V4cHIgKm4gPSBtYWtlTm9kZShKc29uRnVu Y0V4cHIpOworCisJCQkJCW4tPm9wID0gSlNPTl9RVUVSWV9PUDsKKwkJCQkJbi0+Y29udGV4dF9p dGVtID0gKEpzb25WYWx1ZUV4cHIgKikgJDM7CisJCQkJCW4tPnBhdGhzcGVjID0gJDU7CisJCQkJ CW4tPnBhc3NpbmcgPSAkNjsKKwkJCQkJbi0+b3V0cHV0ID0gKEpzb25PdXRwdXQgKikgJDc7CisJ CQkJCW4tPndyYXBwZXIgPSAkODsKKwkJCQkJbi0+cXVvdGVzID0gJDk7CisJCQkJCW4tPm9uX2Vt cHR5ID0gKEpzb25CZWhhdmlvciAqKSBsaW5pdGlhbCgkMTApOworCQkJCQluLT5vbl9lcnJvciA9 IChKc29uQmVoYXZpb3IgKikgbHNlY29uZCgkMTApOworCQkJCQluLT5sb2NhdGlvbiA9IEAxOwor CQkJCQkkJCA9IChOb2RlICopIG47CisJCQkJfQorCQkJfCBKU09OX0VYSVNUUyAnKCcKKwkJCQlq c29uX3ZhbHVlX2V4cHIgJywnIGFfZXhwciBqc29uX3Bhc3NpbmdfY2xhdXNlX29wdAorCQkJCWpz b25fb25fZXJyb3JfY2xhdXNlX29wdAorCQkJJyknCisJCQkJeworCQkJCQlKc29uRnVuY0V4cHIg Km4gPSBtYWtlTm9kZShKc29uRnVuY0V4cHIpOworCisJCQkJCW4tPm9wID0gSlNPTl9FWElTVFNf T1A7CisJCQkJCW4tPmNvbnRleHRfaXRlbSA9IChKc29uVmFsdWVFeHByICopICQzOworCQkJCQlu LT5wYXRoc3BlYyA9ICQ1OworCQkJCQluLT5wYXNzaW5nID0gJDY7CisJCQkJCW4tPm91dHB1dCA9 IE5VTEw7CisJCQkJCW4tPm9uX2Vycm9yID0gKEpzb25CZWhhdmlvciAqKSAkNzsKKwkJCQkJbi0+ bG9jYXRpb24gPSBAMTsKKwkJCQkJJCQgPSAoTm9kZSAqKSBuOworCQkJCX0KKwkJCXwgSlNPTl9W QUxVRSAnKCcKKwkJCQlqc29uX3ZhbHVlX2V4cHIgJywnIGFfZXhwciBqc29uX3Bhc3NpbmdfY2xh dXNlX29wdAorCQkJCWpzb25fcmV0dXJuaW5nX2NsYXVzZV9vcHQKKwkJCQlqc29uX2JlaGF2aW9y X2NsYXVzZV9vcHQKKwkJCScpJworCQkJCXsKKwkJCQkJSnNvbkZ1bmNFeHByICpuID0gbWFrZU5v ZGUoSnNvbkZ1bmNFeHByKTsKKworCQkJCQluLT5vcCA9IEpTT05fVkFMVUVfT1A7CisJCQkJCW4t PmNvbnRleHRfaXRlbSA9IChKc29uVmFsdWVFeHByICopICQzOworCQkJCQluLT5wYXRoc3BlYyA9 ICQ1OworCQkJCQluLT5wYXNzaW5nID0gJDY7CisJCQkJCW4tPm91dHB1dCA9IChKc29uT3V0cHV0 ICopICQ3OworCQkJCQluLT5vbl9lbXB0eSA9IChKc29uQmVoYXZpb3IgKikgbGluaXRpYWwoJDgp OworCQkJCQluLT5vbl9lcnJvciA9IChKc29uQmVoYXZpb3IgKikgbHNlY29uZCgkOCk7CisJCQkJ CW4tPmxvY2F0aW9uID0gQDE7CisJCQkJCSQkID0gKE5vZGUgKikgbjsKKwkJCQl9CiAJCQk7CiAK IApAQCAtMTY1MDIsNiArMTY1NjcsNzcgQEAgb3B0X2FzeW1tZXRyaWM6IEFTWU1NRVRSSUMKIAkJ OwogCiAvKiBTUUwvSlNPTiBzdXBwb3J0ICovCitqc29uX3Bhc3NpbmdfY2xhdXNlX29wdDoKKwkJ CVBBU1NJTkcganNvbl9hcmd1bWVudHMJCQkJCXsgJCQgPSAkMjsgfQorCQkJfCAvKkVNUFRZKi8J CQkJCQkJCXsgJCQgPSBOSUw7IH0KKwkJOworCitqc29uX2FyZ3VtZW50czoKKwkJCWpzb25fYXJn dW1lbnQJCQkJCQkJeyAkJCA9IGxpc3RfbWFrZTEoJDEpOyB9CisJCQl8IGpzb25fYXJndW1lbnRz ICcsJyBqc29uX2FyZ3VtZW50CQl7ICQkID0gbGFwcGVuZCgkMSwgJDMpOyB9CisJCTsKKworanNv bl9hcmd1bWVudDoKKwkJCWpzb25fdmFsdWVfZXhwciBBUyBDb2xMYWJlbAorCQkJeworCQkJCUpz b25Bcmd1bWVudCAqbiA9IG1ha2VOb2RlKEpzb25Bcmd1bWVudCk7CisKKwkJCQluLT52YWwgPSAo SnNvblZhbHVlRXhwciAqKSAkMTsKKwkJCQluLT5uYW1lID0gJDM7CisJCQkJJCQgPSAoTm9kZSAq KSBuOworCQkJfQorCQk7CisKKy8qIEFSUkFZIGlzIGEgbm9pc2Ugd29yZCAqLworanNvbl93cmFw cGVyX2JlaGF2aW9yOgorCQkJICBXSVRIT1VUIFdSQVBQRVIJCQkJCXsgJCQgPSBKU1dfTk9ORTsg fQorCQkJfCBXSVRIT1VUIEFSUkFZCVdSQVBQRVIJCQkJeyAkJCA9IEpTV19OT05FOyB9CisJCQl8 IFdJVEggV1JBUFBFUgkJCQkJCXsgJCQgPSBKU1dfVU5DT05ESVRJT05BTDsgfQorCQkJfCBXSVRI IEFSUkFZIFdSQVBQRVIJCQkJeyAkJCA9IEpTV19VTkNPTkRJVElPTkFMOyB9CisJCQl8IFdJVEgg Q09ORElUSU9OQUwgQVJSQVkgV1JBUFBFUgl7ICQkID0gSlNXX0NPTkRJVElPTkFMOyB9CisJCQl8 IFdJVEggVU5DT05ESVRJT05BTCBBUlJBWSBXUkFQUEVSCXsgJCQgPSBKU1dfVU5DT05ESVRJT05B TDsgfQorCQkJfCBXSVRIIENPTkRJVElPTkFMIFdSQVBQRVIJCQl7ICQkID0gSlNXX0NPTkRJVElP TkFMOyB9CisJCQl8IFdJVEggVU5DT05ESVRJT05BTCBXUkFQUEVSCQl7ICQkID0gSlNXX1VOQ09O RElUSU9OQUw7IH0KKwkJCXwgLyogZW1wdHkgKi8JCQkJCQl7ICQkID0gSlNXX1VOU1BFQzsgfQor CQk7CisKK2pzb25fYmVoYXZpb3I6CisJCQlERUZBVUxUIGFfZXhwcgorCQkJCXsgJCQgPSAoTm9k ZSAqKSBtYWtlSnNvbkJlaGF2aW9yKEpTT05fQkVIQVZJT1JfREVGQVVMVCwgJDIsIE5VTEwsIEAx KTsgfQorCQkJfCBqc29uX2JlaGF2aW9yX3R5cGUKKwkJCQl7ICQkID0gKE5vZGUgKikgbWFrZUpz b25CZWhhdmlvcigkMSwgTlVMTCwgTlVMTCwgQDEpOyB9CisJCTsKKworanNvbl9iZWhhdmlvcl90 eXBlOgorCQkJRVJST1JfUAkJeyAkJCA9IEpTT05fQkVIQVZJT1JfRVJST1I7IH0KKwkJCXwgTlVM TF9QCXsgJCQgPSBKU09OX0JFSEFWSU9SX05VTEw7IH0KKwkJCXwgVFJVRV9QCXsgJCQgPSBKU09O X0JFSEFWSU9SX1RSVUU7IH0KKwkJCXwgRkFMU0VfUAl7ICQkID0gSlNPTl9CRUhBVklPUl9GQUxT RTsgfQorCQkJfCBVTktOT1dOCXsgJCQgPSBKU09OX0JFSEFWSU9SX1VOS05PV047IH0KKwkJCXwg RU1QVFlfUCBBUlJBWQl7ICQkID0gSlNPTl9CRUhBVklPUl9FTVBUWV9BUlJBWTsgfQorCQkJfCBF TVBUWV9QIE9CSkVDVF9QCXsgJCQgPSBKU09OX0JFSEFWSU9SX0VNUFRZX09CSkVDVDsgfQorCQkJ Lyogbm9uLXN0YW5kYXJkLCBmb3IgT3JhY2xlIGNvbXBhdGliaWxpdHkgb25seSAqLworCQkJfCBF TVBUWV9QCXsgJCQgPSBKU09OX0JFSEFWSU9SX0VNUFRZX0FSUkFZOyB9CisJCTsKKworanNvbl9i ZWhhdmlvcl9jbGF1c2Vfb3B0OgorCQkJanNvbl9iZWhhdmlvciBPTiBFTVBUWV9QCisJCQkJeyAk JCA9IGxpc3RfbWFrZTIoJDEsIE5VTEwpOyB9CisJCQl8IGpzb25fYmVoYXZpb3IgT04gRVJST1Jf UAorCQkJCXsgJCQgPSBsaXN0X21ha2UyKE5VTEwsICQxKTsgfQorCQkJfCBqc29uX2JlaGF2aW9y IE9OIEVNUFRZX1AganNvbl9iZWhhdmlvciBPTiBFUlJPUl9QCisJCQkJeyAkJCA9IGxpc3RfbWFr ZTIoJDEsICQ0KTsgfQorCQkJfCAvKiBFTVBUWSAqLworCQkJCXsgJCQgPSBsaXN0X21ha2UyKE5V TEwsIE5VTEwpOyB9CisJCTsKKworanNvbl9vbl9lcnJvcl9jbGF1c2Vfb3B0OgorCQkJanNvbl9i ZWhhdmlvciBPTiBFUlJPUl9QCisJCQkJeyAkJCA9ICQxOyB9CisJCQl8IC8qIEVNUFRZICovCisJ CQkJeyAkJCA9IE5VTEw7IH0KKwkJOworCiBqc29uX3ZhbHVlX2V4cHI6CiAJCQlhX2V4cHIganNv bl9mb3JtYXRfY2xhdXNlX29wdAogCQkJewpAQCAtMTY1NDYsNiArMTY2ODIsMTQgQEAganNvbl9m b3JtYXRfY2xhdXNlX29wdDoKIAkJCQl9CiAJCTsKIAoranNvbl9xdW90ZXNfY2xhdXNlX29wdDoK KwkJCUtFRVAgUVVPVEVTIE9OIFNDQUxBUiBTVFJJTkdfUAkJeyAkJCA9IEpTX1FVT1RFU19LRUVQ OyB9CisJCQl8IEtFRVAgUVVPVEVTCQkJCQkJeyAkJCA9IEpTX1FVT1RFU19LRUVQOyB9CisJCQl8 IE9NSVQgUVVPVEVTIE9OIFNDQUxBUiBTVFJJTkdfUAl7ICQkID0gSlNfUVVPVEVTX09NSVQ7IH0K KwkJCXwgT01JVCBRVU9URVMJCQkJCQl7ICQkID0gSlNfUVVPVEVTX09NSVQ7IH0KKwkJCXwgLyog RU1QVFkgKi8JCQkJCQl7ICQkID0gSlNfUVVPVEVTX1VOU1BFQzsgfQorCQk7CisKIGpzb25fcmV0 dXJuaW5nX2NsYXVzZV9vcHQ6CiAJCQlSRVRVUk5JTkcgVHlwZW5hbWUganNvbl9mb3JtYXRfY2xh dXNlX29wdAogCQkJCXsKQEAgLTE3MTYyLDYgKzE3MzA2LDcgQEAgdW5yZXNlcnZlZF9rZXl3b3Jk OgogCQkJfCBDT01NSVQKIAkJCXwgQ09NTUlUVEVECiAJCQl8IENPTVBSRVNTSU9OCisJCQl8IENP TkRJVElPTkFMCiAJCQl8IENPTkZJR1VSQVRJT04KIAkJCXwgQ09ORkxJQ1QKIAkJCXwgQ09OTkVD VElPTgpAQCAtMTcxOTgsMTAgKzE3MzQzLDEyIEBAIHVucmVzZXJ2ZWRfa2V5d29yZDoKIAkJCXwg RE9VQkxFX1AKIAkJCXwgRFJPUAogCQkJfCBFQUNICisJCQl8IEVNUFRZX1AKIAkJCXwgRU5BQkxF X1AKIAkJCXwgRU5DT0RJTkcKIAkJCXwgRU5DUllQVEVECiAJCQl8IEVOVU1fUAorCQkJfCBFUlJP Ul9QCiAJCQl8IEVTQ0FQRQogCQkJfCBFVkVOVAogCQkJfCBFWENMVURFCkBAIC0xNzI1MSw2ICsx NzM5OCw3IEBAIHVucmVzZXJ2ZWRfa2V5d29yZDoKIAkJCXwgSU5TVEVBRAogCQkJfCBJTlZPS0VS CiAJCQl8IElTT0xBVElPTgorCQkJfCBLRUVQCiAJCQl8IEtFWQogCQkJfCBLRVlTCiAJCQl8IExB QkVMCkBAIC0xNzI5Nyw2ICsxNzQ0NSw3IEBAIHVucmVzZXJ2ZWRfa2V5d29yZDoKIAkJCXwgT0ZG CiAJCQl8IE9JRFMKIAkJCXwgT0xECisJCQl8IE9NSVQKIAkJCXwgT1BFUkFUT1IKIAkJCXwgT1BU SU9OCiAJCQl8IE9QVElPTlMKQEAgLTE3MzI3LDYgKzE3NDc2LDcgQEAgdW5yZXNlcnZlZF9rZXl3 b3JkOgogCQkJfCBQUk9HUkFNCiAJCQl8IFBVQkxJQ0FUSU9OCiAJCQl8IFFVT1RFCisJCQl8IFFV T1RFUwogCQkJfCBSQU5HRQogCQkJfCBSRUFECiAJCQl8IFJFQVNTSUdOCkBAIC0xNzM4Niw2ICsx NzUzNiw3IEBAIHVucmVzZXJ2ZWRfa2V5d29yZDoKIAkJCXwgU1RPUkFHRQogCQkJfCBTVE9SRUQK IAkJCXwgU1RSSUNUX1AKKwkJCXwgU1RSSU5HX1AKIAkJCXwgU1RSSVBfUAogCQkJfCBTVUJTQ1JJ UFRJT04KIAkJCXwgU1VQUE9SVApAQCAtMTc0MDgsNiArMTc1NTksNyBAQCB1bnJlc2VydmVkX2tl eXdvcmQ6CiAJCQl8IFVFU0NBUEUKIAkJCXwgVU5CT1VOREVECiAJCQl8IFVOQ09NTUlUVEVECisJ CQl8IFVOQ09ORElUSU9OQUwKIAkJCXwgVU5FTkNSWVBURUQKIAkJCXwgVU5LTk9XTgogCQkJfCBV TkxJU1RFTgpAQCAtMTc0NjgsMTAgKzE3NjIwLDEzIEBAIGNvbF9uYW1lX2tleXdvcmQ6CiAJCQl8 IEpTT04KIAkJCXwgSlNPTl9BUlJBWQogCQkJfCBKU09OX0FSUkFZQUdHCisJCQl8IEpTT05fRVhJ U1RTCiAJCQl8IEpTT05fT0JKRUNUCiAJCQl8IEpTT05fT0JKRUNUQUdHCisJCQl8IEpTT05fUVVF UlkKIAkJCXwgSlNPTl9TQ0FMQVIKIAkJCXwgSlNPTl9TRVJJQUxJWkUKKwkJCXwgSlNPTl9WQUxV RQogCQkJfCBMRUFTVAogCQkJfCBOQVRJT05BTAogCQkJfCBOQ0hBUgpAQCAtMTc3MDQsNiArMTc4 NTksNyBAQCBiYXJlX2xhYmVsX2tleXdvcmQ6CiAJCQl8IENPTU1JVFRFRAogCQkJfCBDT01QUkVT U0lPTgogCQkJfCBDT05DVVJSRU5UTFkKKwkJCXwgQ09ORElUSU9OQUwKIAkJCXwgQ09ORklHVVJB VElPTgogCQkJfCBDT05GTElDVAogCQkJfCBDT05ORUNUSU9OCkBAIC0xNzc1NiwxMSArMTc5MTIs MTMgQEAgYmFyZV9sYWJlbF9rZXl3b3JkOgogCQkJfCBEUk9QCiAJCQl8IEVBQ0gKIAkJCXwgRUxT RQorCQkJfCBFTVBUWV9QCiAJCQl8IEVOQUJMRV9QCiAJCQl8IEVOQ09ESU5HCiAJCQl8IEVOQ1JZ UFRFRAogCQkJfCBFTkRfUAogCQkJfCBFTlVNX1AKKwkJCXwgRVJST1JfUAogCQkJfCBFU0NBUEUK IAkJCXwgRVZFTlQKIAkJCXwgRVhDTFVERQpAQCAtMTc4MzAsMTAgKzE3OTg4LDE0IEBAIGJhcmVf bGFiZWxfa2V5d29yZDoKIAkJCXwgSlNPTgogCQkJfCBKU09OX0FSUkFZCiAJCQl8IEpTT05fQVJS QVlBR0cKKwkJCXwgSlNPTl9FWElTVFMKIAkJCXwgSlNPTl9PQkpFQ1QKIAkJCXwgSlNPTl9PQkpF Q1RBR0cKKwkJCXwgSlNPTl9RVUVSWQogCQkJfCBKU09OX1NDQUxBUgogCQkJfCBKU09OX1NFUklB TElaRQorCQkJfCBKU09OX1ZBTFVFCisJCQl8IEtFRVAKIAkJCXwgS0VZCiAJCQl8IEtFWVMKIAkJ CXwgTEFCRUwKQEAgLTE3ODk0LDYgKzE4MDU2LDcgQEAgYmFyZV9sYWJlbF9rZXl3b3JkOgogCQkJ fCBPRkYKIAkJCXwgT0lEUwogCQkJfCBPTEQKKwkJCXwgT01JVAogCQkJfCBPTkxZCiAJCQl8IE9Q RVJBVE9SCiAJCQl8IE9QVElPTgpAQCAtMTc5MzEsNiArMTgwOTQsNyBAQCBiYXJlX2xhYmVsX2tl eXdvcmQ6CiAJCQl8IFBST0dSQU0KIAkJCXwgUFVCTElDQVRJT04KIAkJCXwgUVVPVEUKKwkJCXwg UVVPVEVTCiAJCQl8IFJBTkdFCiAJCQl8IFJFQUQKIAkJCXwgUkVBTApAQCAtMTc5OTksNiArMTgx NjMsNyBAQCBiYXJlX2xhYmVsX2tleXdvcmQ6CiAJCQl8IFNUT1JBR0UKIAkJCXwgU1RPUkVECiAJ CQl8IFNUUklDVF9QCisJCQl8IFNUUklOR19QCiAJCQl8IFNUUklQX1AKIAkJCXwgU1VCU0NSSVBU SU9OCiAJCQl8IFNVQlNUUklORwpAQCAtMTgwMzMsNiArMTgxOTgsNyBAQCBiYXJlX2xhYmVsX2tl eXdvcmQ6CiAJCQl8IFVFU0NBUEUKIAkJCXwgVU5CT1VOREVECiAJCQl8IFVOQ09NTUlUVEVECisJ CQl8IFVOQ09ORElUSU9OQUwKIAkJCXwgVU5FTkNSWVBURUQKIAkJCXwgVU5JUVVFCiAJCQl8IFVO S05PV04KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3BhcnNlci9wYXJzZV9leHByLmMgYi9zcmMv YmFja2VuZC9wYXJzZXIvcGFyc2VfZXhwci5jCmluZGV4IDkzMDBjN2I5YWIuLjU0OTNiMDVhZTgg MTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3BhcnNlci9wYXJzZV9leHByLmMKKysrIGIvc3JjL2Jh Y2tlbmQvcGFyc2VyL3BhcnNlX2V4cHIuYwpAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgInV0 aWxzL2J1aWx0aW5zLmgiCiAjaW5jbHVkZSAidXRpbHMvZGF0ZS5oIgogI2luY2x1ZGUgInV0aWxz L2ZtZ3JvaWRzLmgiCisjaW5jbHVkZSAidXRpbHMvanNvbmIuaCIKICNpbmNsdWRlICJ1dGlscy9s c3lzY2FjaGUuaCIKICNpbmNsdWRlICJ1dGlscy90aW1lc3RhbXAuaCIKICNpbmNsdWRlICJ1dGls cy94bWwuaCIKQEAgLTkwLDYgKzkxLDIyIEBAIHN0YXRpYyBOb2RlICp0cmFuc2Zvcm1Kc29uUGFy c2VFeHByKFBhcnNlU3RhdGUgKnBzdGF0ZSwgSnNvblBhcnNlRXhwciAqZXhwcik7CiBzdGF0aWMg Tm9kZSAqdHJhbnNmb3JtSnNvblNjYWxhckV4cHIoUGFyc2VTdGF0ZSAqcHN0YXRlLCBKc29uU2Nh bGFyRXhwciAqZXhwcik7CiBzdGF0aWMgTm9kZSAqdHJhbnNmb3JtSnNvblNlcmlhbGl6ZUV4cHIo UGFyc2VTdGF0ZSAqcHN0YXRlLAogCQkJCQkJCQkJCUpzb25TZXJpYWxpemVFeHByICpleHByKTsK K3N0YXRpYyBOb2RlICp0cmFuc2Zvcm1Kc29uRnVuY0V4cHIoUGFyc2VTdGF0ZSAqcHN0YXRlLCBK c29uRnVuY0V4cHIgKnApOworc3RhdGljIEpzb25FeHByICp0cmFuc2Zvcm1Kc29uRXhwckNvbW1v bihQYXJzZVN0YXRlICpwc3RhdGUsIEpzb25GdW5jRXhwciAqZnVuYywKKwkJCQkJCQkJCQkgY29u c3QgY2hhciAqY29uc3RydWN0TmFtZSk7CitzdGF0aWMgdm9pZCB0cmFuc2Zvcm1Kc29uUGFzc2lu Z0FyZ3MoUGFyc2VTdGF0ZSAqcHN0YXRlLCBjb25zdCBjaGFyICpjb25zdHJ1Y3ROYW1lLAorCQkJ CQkJCQkJIEpzb25Gb3JtYXRUeXBlIGZvcm1hdCwgTGlzdCAqYXJncywKKwkJCQkJCQkJCSBMaXN0 ICoqcGFzc2luZ192YWx1ZXMsIExpc3QgKipwYXNzaW5nX25hbWVzKTsKK3N0YXRpYyBOb2RlICpj b2VyY2VKc29uRnVuY0V4cHJPdXRwdXQoUGFyc2VTdGF0ZSAqcHN0YXRlLCBKc29uRXhwciAqanNl eHByKTsKK3N0YXRpYyBPaWQJSnNvbkZ1bmNFeHByRGVmYXVsdFJldHVyblR5cGUoSnNvbkV4cHIg KmpzZXhwcik7CitzdGF0aWMgTm9kZSAqY29lcmNlSnNvbkV4cHIoUGFyc2VTdGF0ZSAqcHN0YXRl LCBOb2RlICpleHByLAorCQkJCQkJCWNvbnN0IEpzb25SZXR1cm5pbmcgKnJldHVybmluZyk7Citz dGF0aWMgSnNvbkNvZXJjaW9uICptYWtlSnNvbkNvZXJjaW9uKGNvbnN0IEpzb25SZXR1cm5pbmcg KnJldHVybmluZyk7CitzdGF0aWMgTGlzdCAqSW5pdEpzb25JdGVtQ29lcmNpb25zKFBhcnNlU3Rh dGUgKnBzdGF0ZSwgY29uc3QgSnNvblJldHVybmluZyAqcmV0dXJuaW5nLAorCQkJCQkJCQkgICBP aWQgY29udGV4dEl0ZW1UeXBlSWQpOworc3RhdGljIEpzb25CZWhhdmlvciAqdHJhbnNmb3JtSnNv bkJlaGF2aW9yKFBhcnNlU3RhdGUgKnBzdGF0ZSwgSnNvbkJlaGF2aW9yICpiZWhhdmlvciwKKwkJ CQkJCQkJCQkgICBKc29uQmVoYXZpb3JUeXBlIGRlZmF1bHRfYmVoYXZpb3IsCisJCQkJCQkJCQkJ ICAgSnNvblJldHVybmluZyAqcmV0dXJuaW5nKTsKIHN0YXRpYyBOb2RlICptYWtlX3Jvd19jb21w YXJpc29uX29wKFBhcnNlU3RhdGUgKnBzdGF0ZSwgTGlzdCAqb3BuYW1lLAogCQkJCQkJCQkJTGlz dCAqbGFyZ3MsIExpc3QgKnJhcmdzLCBpbnQgbG9jYXRpb24pOwogc3RhdGljIE5vZGUgKm1ha2Vf cm93X2Rpc3RpbmN0X29wKFBhcnNlU3RhdGUgKnBzdGF0ZSwgTGlzdCAqb3BuYW1lLApAQCAtMzUz LDYgKzM3MCwxMCBAQCB0cmFuc2Zvcm1FeHByUmVjdXJzZShQYXJzZVN0YXRlICpwc3RhdGUsIE5v ZGUgKmV4cHIpCiAJCQlyZXN1bHQgPSB0cmFuc2Zvcm1Kc29uU2VyaWFsaXplRXhwcihwc3RhdGUs IChKc29uU2VyaWFsaXplRXhwciAqKSBleHByKTsKIAkJCWJyZWFrOwogCisJCWNhc2UgVF9Kc29u RnVuY0V4cHI6CisJCQlyZXN1bHQgPSB0cmFuc2Zvcm1Kc29uRnVuY0V4cHIocHN0YXRlLCAoSnNv bkZ1bmNFeHByICopIGV4cHIpOworCQkJYnJlYWs7CisKIAkJZGVmYXVsdDoKIAkJCS8qIHNob3Vs ZCBub3QgcmVhY2ggaGVyZSAqLwogCQkJZWxvZyhFUlJPUiwgInVucmVjb2duaXplZCBub2RlIHR5 cGU6ICVkIiwgKGludCkgbm9kZVRhZyhleHByKSk7CkBAIC0zMjI5LDcgKzMyNTAsNyBAQCBtYWtl SnNvbkJ5dGVhVG9UZXh0Q29udmVyc2lvbihOb2RlICpleHByLCBKc29uRm9ybWF0ICpmb3JtYXQs IGludCBsb2NhdGlvbikKIHN0YXRpYyBOb2RlICoKIHRyYW5zZm9ybUpzb25WYWx1ZUV4cHIoUGFy c2VTdGF0ZSAqcHN0YXRlLCBjb25zdCBjaGFyICpjb25zdHJ1Y3ROYW1lLAogCQkJCQkgICBKc29u VmFsdWVFeHByICp2ZSwgSnNvbkZvcm1hdFR5cGUgZGVmYXVsdF9mb3JtYXQsCi0JCQkJCSAgIE9p ZCB0YXJnZXR0eXBlKQorCQkJCQkgICBPaWQgdGFyZ2V0dHlwZSwgYm9vbCBpc2FyZykKIHsKIAlO b2RlCSAgICpleHByID0gdHJhbnNmb3JtRXhwclJlY3Vyc2UocHN0YXRlLCAoTm9kZSAqKSB2ZS0+ cmF3X2V4cHIpOwogCU5vZGUJICAgKnJhd2V4cHI7CkBAIC0zMjYxLDYgKzMyODIsNDEgQEAgdHJh bnNmb3JtSnNvblZhbHVlRXhwcihQYXJzZVN0YXRlICpwc3RhdGUsIGNvbnN0IGNoYXIgKmNvbnN0 cnVjdE5hbWUsCiAJCWVsc2UKIAkJCWZvcm1hdCA9IHZlLT5mb3JtYXQtPmZvcm1hdF90eXBlOwog CX0KKwllbHNlIGlmIChpc2FyZykKKwl7CisJCS8qCisJCSAqIFNwZWNpYWwgdHJlYXRtZW50IGZv ciBQQVNTSU5HIGFyZ3VtZW50cy4KKwkJICoKKwkJICogUGFzcyB0eXBlcyBzdXBwb3J0ZWQgYnkg R2V0SnNvblBhdGhWYXIoKSAvCisJCSAqIEpzb25JdGVtRnJvbURhdHVtKCkgZGlyZWN0bHkgd2l0 aG91dCBjb252ZXJ0aW5nIHRvIGpzb25bYl0uCisJCSAqLworCQlzd2l0Y2ggKGV4cHJ0eXBlKQor CQl7CisJCQljYXNlIEJPT0xPSUQ6CisJCQljYXNlIE5VTUVSSUNPSUQ6CisJCQljYXNlIElOVDJP SUQ6CisJCQljYXNlIElOVDRPSUQ6CisJCQljYXNlIElOVDhPSUQ6CisJCQljYXNlIEZMT0FUNE9J RDoKKwkJCWNhc2UgRkxPQVQ4T0lEOgorCQkJY2FzZSBURVhUT0lEOgorCQkJY2FzZSBWQVJDSEFS T0lEOgorCQkJY2FzZSBEQVRFT0lEOgorCQkJY2FzZSBUSU1FT0lEOgorCQkJY2FzZSBUSU1FVFpP SUQ6CisJCQljYXNlIFRJTUVTVEFNUE9JRDoKKwkJCWNhc2UgVElNRVNUQU1QVFpPSUQ6CisJCQkJ cmV0dXJuIGV4cHI7CisKKwkJCWRlZmF1bHQ6CisJCQkJaWYgKHR5cGNhdGVnb3J5ID09IFRZUENB VEVHT1JZX1NUUklORykKKwkJCQkJcmV0dXJuIGV4cHI7CisJCQkJLyogZWxzZSBjb252ZXJ0IGFy Z3VtZW50IHRvIGpzb25bYl0gdHlwZSAqLworCQkJCWJyZWFrOworCQl9CisKKwkJZm9ybWF0ID0g ZGVmYXVsdF9mb3JtYXQ7CisJfQogCWVsc2UgaWYgKGV4cHJ0eXBlID09IEpTT05PSUQgfHwgZXhw cnR5cGUgPT0gSlNPTkJPSUQpCiAJCWZvcm1hdCA9IEpTX0ZPUk1BVF9ERUZBVUxUOyAvKiBkbyBu b3QgZm9ybWF0IGpzb25bYl0gdHlwZXMgKi8KIAllbHNlCkBAIC0zMjcyLDcgKzMzMjgsMTIgQEAg dHJhbnNmb3JtSnNvblZhbHVlRXhwcihQYXJzZVN0YXRlICpwc3RhdGUsIGNvbnN0IGNoYXIgKmNv bnN0cnVjdE5hbWUsCiAJCU5vZGUJICAgKmNvZXJjZWQ7CiAJCWJvb2wJCW9ubHlfYWxsb3dfY2Fz dCA9IE9pZElzVmFsaWQodGFyZ2V0dHlwZSk7CiAKLQkJaWYgKCFvbmx5X2FsbG93X2Nhc3QgJiYK KwkJLyoKKwkJICogUEFTU0lORyBhcmdzIGFyZSBoYW5kbGVkIGFwcHJvcHJpYXRlbHkgYnkgR2V0 SnNvblBhdGhWYXIoKSAvCisJCSAqIEpzb25JdGVtRnJvbURhdHVtKCkuCisJCSAqLworCQlpZiAo IWlzYXJnICYmCisJCQkhb25seV9hbGxvd19jYXN0ICYmCiAJCQlleHBydHlwZSAhPSBCWVRFQU9J RCAmJiB0eXBjYXRlZ29yeSAhPSBUWVBDQVRFR09SWV9TVFJJTkcpCiAJCQllcmVwb3J0KEVSUk9S LAogCQkJCQllcnJjb2RlKEVSUkNPREVfREFUQVRZUEVfTUlTTUFUQ0gpLApAQCAtMzQyNSw2ICsz NDg2LDExIEBAIHRyYW5zZm9ybUpzb25PdXRwdXQoUGFyc2VTdGF0ZSAqcHN0YXRlLCBjb25zdCBK c29uT3V0cHV0ICpvdXRwdXQsCiAJCQkJZXJyY29kZShFUlJDT0RFX0ZFQVRVUkVfTk9UX1NVUFBP UlRFRCksCiAJCQkJZXJybXNnKCJyZXR1cm5pbmcgU0VUT0YgdHlwZXMgaXMgbm90IHN1cHBvcnRl ZCBpbiBTUUwvSlNPTiBmdW5jdGlvbnMiKSk7CiAKKwlpZiAoZ2V0X3R5cHR5cGUocmV0LT50eXBp ZCkgPT0gVFlQVFlQRV9QU0VVRE8pCisJCWVyZXBvcnQoRVJST1IsCisJCQkJZXJyY29kZShFUlJD T0RFX0ZFQVRVUkVfTk9UX1NVUFBPUlRFRCksCisJCQkJZXJybXNnKCJyZXR1cm5pbmcgcHNldWRv LXR5cGVzIGlzIG5vdCBzdXBwb3J0ZWQgaW4gU1FML0pTT04gZnVuY3Rpb25zIikpOworCiAJaWYg KHJldC0+Zm9ybWF0LT5mb3JtYXRfdHlwZSA9PSBKU19GT1JNQVRfREVGQVVMVCkKIAkJLyogYXNz aWduIEpTT05CIGZvcm1hdCB3aGVuIHJldHVybmluZyBqc29uYiwgb3IgSlNPTiBmb3JtYXQgb3Ro ZXJ3aXNlICovCiAJCXJldC0+Zm9ybWF0LT5mb3JtYXRfdHlwZSA9CkBAIC0zNjIxLDcgKzM2ODcs NyBAQCB0cmFuc2Zvcm1Kc29uT2JqZWN0Q29uc3RydWN0b3IoUGFyc2VTdGF0ZSAqcHN0YXRlLCBK c29uT2JqZWN0Q29uc3RydWN0b3IgKmN0b3IpCiAJCQlOb2RlCSAgICp2YWwgPSB0cmFuc2Zvcm1K c29uVmFsdWVFeHByKHBzdGF0ZSwgIkpTT05fT0JKRUNUKCkiLAogCQkJCQkJCQkJCQkJCSBrdi0+ dmFsdWUsCiAJCQkJCQkJCQkJCQkJIEpTX0ZPUk1BVF9ERUZBVUxULAotCQkJCQkJCQkJCQkJCSBJ bnZhbGlkT2lkKTsKKwkJCQkJCQkJCQkJCQkgSW52YWxpZE9pZCwgZmFsc2UpOwogCiAJCQlhcmdz ID0gbGFwcGVuZChhcmdzLCBrZXkpOwogCQkJYXJncyA9IGxhcHBlbmQoYXJncywgdmFsKTsKQEAg LTM4MDgsNyArMzg3NCw3IEBAIHRyYW5zZm9ybUpzb25PYmplY3RBZ2coUGFyc2VTdGF0ZSAqcHN0 YXRlLCBKc29uT2JqZWN0QWdnICphZ2cpCiAJdmFsID0gdHJhbnNmb3JtSnNvblZhbHVlRXhwcihw c3RhdGUsICJKU09OX09CSkVDVEFHRygpIiwKIAkJCQkJCQkJIGFnZy0+YXJnLT52YWx1ZSwKIAkJ CQkJCQkJIEpTX0ZPUk1BVF9ERUZBVUxULAotCQkJCQkJCQkgSW52YWxpZE9pZCk7CisJCQkJCQkJ CSBJbnZhbGlkT2lkLCBmYWxzZSk7CiAJYXJncyA9IGxpc3RfbWFrZTIoa2V5LCB2YWwpOwogCiAJ cmV0dXJuaW5nID0gdHJhbnNmb3JtSnNvbkNvbnN0cnVjdG9yT3V0cHV0KHBzdGF0ZSwgYWdnLT5j b25zdHJ1Y3Rvci0+b3V0cHV0LApAQCAtMzg2NCw5ICszOTMwLDggQEAgdHJhbnNmb3JtSnNvbkFy cmF5QWdnKFBhcnNlU3RhdGUgKnBzdGF0ZSwgSnNvbkFycmF5QWdnICphZ2cpCiAJT2lkCQkJYWdn Zm5vaWQ7CiAJT2lkCQkJYWdndHlwZTsKIAotCWFyZyA9IHRyYW5zZm9ybUpzb25WYWx1ZUV4cHIo cHN0YXRlLCAiSlNPTl9BUlJBWUFHRygpIiwKLQkJCQkJCQkJIGFnZy0+YXJnLAotCQkJCQkJCQkg SlNfRk9STUFUX0RFRkFVTFQsIEludmFsaWRPaWQpOworCWFyZyA9IHRyYW5zZm9ybUpzb25WYWx1 ZUV4cHIocHN0YXRlLCAiSlNPTl9BUlJBWUFHRygpIiwgYWdnLT5hcmcsCisJCQkJCQkJCSBKU19G T1JNQVRfREVGQVVMVCwgSW52YWxpZE9pZCwgZmFsc2UpOwogCiAJcmV0dXJuaW5nID0gdHJhbnNm b3JtSnNvbkNvbnN0cnVjdG9yT3V0cHV0KHBzdGF0ZSwgYWdnLT5jb25zdHJ1Y3Rvci0+b3V0cHV0 LAogCQkJCQkJCQkJCQkgICBsaXN0X21ha2UxKGFyZykpOwpAQCAtMzkxMyw5ICszOTc4LDggQEAg dHJhbnNmb3JtSnNvbkFycmF5Q29uc3RydWN0b3IoUGFyc2VTdGF0ZSAqcHN0YXRlLCBKc29uQXJy YXlDb25zdHJ1Y3RvciAqY3RvcikKIAkJewogCQkJSnNvblZhbHVlRXhwciAqanN2YWwgPSBjYXN0 Tm9kZShKc29uVmFsdWVFeHByLCBsZmlyc3QobGMpKTsKIAkJCU5vZGUJICAgKnZhbCA9IHRyYW5z Zm9ybUpzb25WYWx1ZUV4cHIocHN0YXRlLCAiSlNPTl9BUlJBWSgpIiwKLQkJCQkJCQkJCQkJCQkg anN2YWwsCi0JCQkJCQkJCQkJCQkJIEpTX0ZPUk1BVF9ERUZBVUxULAotCQkJCQkJCQkJCQkJCSBJ bnZhbGlkT2lkKTsKKwkJCQkJCQkJCQkJCQkganN2YWwsIEpTX0ZPUk1BVF9ERUZBVUxULAorCQkJ CQkJCQkJCQkJCSBJbnZhbGlkT2lkLCBmYWxzZSk7CiAKIAkJCWFyZ3MgPSBsYXBwZW5kKGFyZ3Ms IHZhbCk7CiAJCX0KQEAgLTQwNzQsNyArNDEzOCw3IEBAIHRyYW5zZm9ybUpzb25QYXJzZUV4cHIo UGFyc2VTdGF0ZSAqcHN0YXRlLCBKc29uUGFyc2VFeHByICpqc2V4cHIpCiAJCSAqIGZ1bmN0aW9u LWxpa2UgQ0FTVHMuCiAJCSAqLwogCQlhcmcgPSB0cmFuc2Zvcm1Kc29uVmFsdWVFeHByKHBzdGF0 ZSwgIkpTT04oKSIsIGpzZXhwci0+ZXhwciwKLQkJCQkJCQkJCSBKU19GT1JNQVRfSlNPTiwgcmV0 dXJuaW5nLT50eXBpZCk7CisJCQkJCQkJCQkgSlNfRk9STUFUX0pTT04sIHJldHVybmluZy0+dHlw aWQsIGZhbHNlKTsKIAl9CiAKIAlyZXR1cm4gbWFrZUpzb25Db25zdHJ1Y3RvckV4cHIocHN0YXRl LCBKU0NUT1JfSlNPTl9QQVJTRSwgbGlzdF9tYWtlMShhcmcpLCBOVUxMLApAQCAtNDExOSw3ICs0 MTgzLDcgQEAgdHJhbnNmb3JtSnNvblNlcmlhbGl6ZUV4cHIoUGFyc2VTdGF0ZSAqcHN0YXRlLCBK c29uU2VyaWFsaXplRXhwciAqZXhwcikKIAlOb2RlCSAgICphcmcgPSB0cmFuc2Zvcm1Kc29uVmFs dWVFeHByKHBzdGF0ZSwgIkpTT05fU0VSSUFMSVpFKCkiLAogCQkJCQkJCQkJCQkgZXhwci0+ZXhw ciwKIAkJCQkJCQkJCQkJIEpTX0ZPUk1BVF9KU09OLAotCQkJCQkJCQkJCQkgSW52YWxpZE9pZCk7 CisJCQkJCQkJCQkJCSBJbnZhbGlkT2lkLCBmYWxzZSk7CiAKIAlpZiAoZXhwci0+b3V0cHV0KQog CXsKQEAgLTQxNTMsMyArNDIxNyw1MjYgQEAgdHJhbnNmb3JtSnNvblNlcmlhbGl6ZUV4cHIoUGFy c2VTdGF0ZSAqcHN0YXRlLCBKc29uU2VyaWFsaXplRXhwciAqZXhwcikKIAlyZXR1cm4gbWFrZUpz b25Db25zdHJ1Y3RvckV4cHIocHN0YXRlLCBKU0NUT1JfSlNPTl9TRVJJQUxJWkUsIGxpc3RfbWFr ZTEoYXJnKSwKIAkJCQkJCQkJICAgTlVMTCwgcmV0dXJuaW5nLCBmYWxzZSwgZmFsc2UsIGV4cHIt PmxvY2F0aW9uKTsKIH0KKworLyoKKyAqIFRyYW5zZm9ybSBKU09OX1ZBTFVFLCBKU09OX1FVRVJZ LCBKU09OX0VYSVNUUyBmdW5jdGlvbnMgaW50byBhIEpzb25FeHByIG5vZGUuCisgKi8KK3N0YXRp YyBOb2RlICoKK3RyYW5zZm9ybUpzb25GdW5jRXhwcihQYXJzZVN0YXRlICpwc3RhdGUsIEpzb25G dW5jRXhwciAqZnVuYykKK3sKKwlKc29uRXhwciAgICpqc2V4cHIgPSBOVUxMOworCWNvbnN0IGNo YXIgKmZ1bmNfbmFtZSA9IE5VTEw7CisKKwlzd2l0Y2ggKGZ1bmMtPm9wKQorCXsKKwkJY2FzZSBK U09OX0VYSVNUU19PUDoKKwkJCWZ1bmNfbmFtZSA9ICJKU09OX0VYSVNUUyI7CisJCQlicmVhazsK KwkJY2FzZSBKU09OX1FVRVJZX09QOgorCQkJZnVuY19uYW1lID0gIkpTT05fUVVFUlkiOworCQkJ YnJlYWs7CisJCWNhc2UgSlNPTl9WQUxVRV9PUDoKKwkJCWZ1bmNfbmFtZSA9ICJKU09OX1ZBTFVF IjsKKwkJCWJyZWFrOworCQlkZWZhdWx0OgorCQkJZWxvZyhFUlJPUiwgImludmFsaWQgSnNvbkZ1 bmNFeHByIG9wIik7CisJCQlicmVhazsKKwl9CisKKwkvKiBPbmx5IGFsbG93IEZPUk1BVCBzcGVj aWZpY2F0aW9uIGZvciBKU09OX1FVRVJZKCkuICovCisJaWYgKGZ1bmMtPm91dHB1dCAmJiBmdW5j LT5vcCAhPSBKU09OX1FVRVJZX09QKQorCXsKKwkJSnNvbkZvcm1hdCAqZm9ybWF0ID0gZnVuYy0+ b3V0cHV0LT5yZXR1cm5pbmctPmZvcm1hdDsKKworCQlpZiAoZm9ybWF0LT5mb3JtYXRfdHlwZSAh PSBKU19GT1JNQVRfREVGQVVMVCB8fAorCQkJZm9ybWF0LT5lbmNvZGluZyAhPSBKU19FTkNfREVG QVVMVCkKKwkJCWVyZXBvcnQoRVJST1IsCisJCQkJCWVycmNvZGUoRVJSQ09ERV9TWU5UQVhfRVJS T1IpLAorCQkJCQllcnJtc2coImNhbm5vdCBzcGVjaWZ5IEZPUk1BVCBpbiBSRVRVUk5JTkcgY2xh dXNlIG9mICVzKCkiLAorCQkJCQkJICAgZnVuY19uYW1lKSwKKwkJCQkJcGFyc2VyX2VycnBvc2l0 aW9uKHBzdGF0ZSwgZm9ybWF0LT5sb2NhdGlvbikpOworCX0KKworCWlmIChmdW5jLT5vcCA9PSBK U09OX1FVRVJZX09QICYmCisJCWZ1bmMtPnF1b3RlcyAhPSBKU19RVU9URVNfVU5TUEVDICYmCisJ CShmdW5jLT53cmFwcGVyID09IEpTV19DT05ESVRJT05BTCB8fAorCQkgZnVuYy0+d3JhcHBlciA9 PSBKU1dfVU5DT05ESVRJT05BTCkpCisJCWVyZXBvcnQoRVJST1IsCisJCQkJZXJyY29kZShFUlJD T0RFX1NZTlRBWF9FUlJPUiksCisJCQkJZXJybXNnKCJTUUwvSlNPTiBRVU9URVMgYmVoYXZpb3Ig bXVzdCBub3QgYmUgc3BlY2lmaWVkIHdoZW4gV0lUSCBXUkFQUEVSIGlzIHVzZWQiKSwKKwkJCQlw YXJzZXJfZXJycG9zaXRpb24ocHN0YXRlLCBmdW5jLT5sb2NhdGlvbikpOworCisKKwlqc2V4cHIg PSB0cmFuc2Zvcm1Kc29uRXhwckNvbW1vbihwc3RhdGUsIGZ1bmMsIGZ1bmNfbmFtZSk7CisKKwlz d2l0Y2ggKGZ1bmMtPm9wKQorCXsKKwkJY2FzZSBKU09OX0VYSVNUU19PUDoKKwkJCWlmICghT2lk SXNWYWxpZChqc2V4cHItPnJldHVybmluZy0+dHlwaWQpKQorCQkJeworCQkJCWpzZXhwci0+cmV0 dXJuaW5nLT50eXBpZCA9IEJPT0xPSUQ7CisJCQkJanNleHByLT5yZXR1cm5pbmctPnR5cG1vZCA9 IC0xOworCQkJfQorCisJCQlqc2V4cHItPm9uX2Vycm9yID0gdHJhbnNmb3JtSnNvbkJlaGF2aW9y KHBzdGF0ZSwgZnVuYy0+b25fZXJyb3IsCisJCQkJCQkJCQkJCQkJIEpTT05fQkVIQVZJT1JfRkFM U0UsCisJCQkJCQkJCQkJCQkJIGpzZXhwci0+cmV0dXJuaW5nKTsKKwkJCWJyZWFrOworCisJCWNh c2UgSlNPTl9RVUVSWV9PUDoKKwkJCWpzZXhwci0+d3JhcHBlciA9IGZ1bmMtPndyYXBwZXI7CisK KwkJCS8qCisJCQkgKiBLZWVwIHF1b3RlcyBieSBkZWZhdWx0LCBvbWl0dGluZyB0aGVtIG9ubHkg aWYgT01JVCBRVU9URVMgaXMKKwkJCSAqIHNwZWNpZmllZC4KKwkJCSAqLworCQkJanNleHByLT5v bWl0X3F1b3RlcyA9IChmdW5jLT5xdW90ZXMgPT0gSlNfUVVPVEVTX09NSVQpOworCisJCQlpZiAo IU9pZElzVmFsaWQoanNleHByLT5yZXR1cm5pbmctPnR5cGlkKSkKKwkJCXsKKwkJCQlKc29uUmV0 dXJuaW5nICpyZXQgPSBqc2V4cHItPnJldHVybmluZzsKKworCQkJCXJldC0+dHlwaWQgPSBKc29u RnVuY0V4cHJEZWZhdWx0UmV0dXJuVHlwZShqc2V4cHIpOworCQkJCXJldC0+dHlwbW9kID0gLTE7 CisJCQl9CisJCQlqc2V4cHItPnJlc3VsdF9jb2VyY2lvbiA9IGNvZXJjZUpzb25GdW5jRXhwck91 dHB1dChwc3RhdGUsIGpzZXhwcik7CisKKwkJCWlmIChmdW5jLT5vbl9lbXB0eSkKKwkJCQlqc2V4 cHItPm9uX2VtcHR5ID0gdHJhbnNmb3JtSnNvbkJlaGF2aW9yKHBzdGF0ZSwKKwkJCQkJCQkJCQkJ CQkJIGZ1bmMtPm9uX2VtcHR5LAorCQkJCQkJCQkJCQkJCQkgSlNPTl9CRUhBVklPUl9OVUxMLAor CQkJCQkJCQkJCQkJCQkganNleHByLT5yZXR1cm5pbmcpOworCQkJanNleHByLT5vbl9lcnJvciA9 IHRyYW5zZm9ybUpzb25CZWhhdmlvcihwc3RhdGUsIGZ1bmMtPm9uX2Vycm9yLAorCQkJCQkJCQkJ CQkJCSBKU09OX0JFSEFWSU9SX05VTEwsCisJCQkJCQkJCQkJCQkJIGpzZXhwci0+cmV0dXJuaW5n KTsKKwkJCWJyZWFrOworCisJCWNhc2UgSlNPTl9WQUxVRV9PUDoKKwkJCWlmICghT2lkSXNWYWxp ZChqc2V4cHItPnJldHVybmluZy0+dHlwaWQpKQorCQkJeworCQkJCS8qIE1ha2UgSlNPTl9WQUxV RSByZXR1cm4gdGV4dCBieSBkZWZhdWx0ICovCisJCQkJanNleHByLT5yZXR1cm5pbmctPnR5cGlk ID0gVEVYVE9JRDsKKwkJCQlqc2V4cHItPnJldHVybmluZy0+dHlwbW9kID0gLTE7CisJCQl9CisJ CQlqc2V4cHItPnJlc3VsdF9jb2VyY2lvbiA9IGNvZXJjZUpzb25GdW5jRXhwck91dHB1dChwc3Rh dGUsIGpzZXhwcik7CisKKwkJCS8qCisJCQkgKiBJbml0aWFsaXplIGV4cHJlc3Npb25zIHRvIGNv ZXJjZSB0aGUgc2NhbGFyIHZhbHVlIHJldHVybmVkCisJCQkgKiBieSBKc29uUGF0aFZhbHVlKCkg dG8gdGhlICJyZXR1cm5pbmciIHR5cGUuCisJCQkgKi8KKwkJCWlmIChqc2V4cHItPnJlc3VsdF9j b2VyY2lvbikKKwkJCQlqc2V4cHItPml0ZW1fY29lcmNpb25zID0KKwkJCQkJSW5pdEpzb25JdGVt Q29lcmNpb25zKHBzdGF0ZSwganNleHByLT5yZXR1cm5pbmcsCisJCQkJCQkJCQkJICBleHByVHlw ZShqc2V4cHItPmZvcm1hdHRlZF9leHByKSk7CisKKwkJCWlmIChmdW5jLT5vbl9lbXB0eSkKKwkJ CQlqc2V4cHItPm9uX2VtcHR5ID0gdHJhbnNmb3JtSnNvbkJlaGF2aW9yKHBzdGF0ZSwKKwkJCQkJ CQkJCQkJCQkJIGZ1bmMtPm9uX2VtcHR5LAorCQkJCQkJCQkJCQkJCQkgSlNPTl9CRUhBVklPUl9O VUxMLAorCQkJCQkJCQkJCQkJCQkganNleHByLT5yZXR1cm5pbmcpOworCQkJanNleHByLT5vbl9l cnJvciA9IHRyYW5zZm9ybUpzb25CZWhhdmlvcihwc3RhdGUsIGZ1bmMtPm9uX2Vycm9yLAorCQkJ CQkJCQkJCQkJCSBKU09OX0JFSEFWSU9SX05VTEwsCisJCQkJCQkJCQkJCQkJIGpzZXhwci0+cmV0 dXJuaW5nKTsKKwkJCWJyZWFrOworCisJCWRlZmF1bHQ6CisJCQllbG9nKEVSUk9SLCAiaW52YWxp ZCBKc29uRnVuY0V4cHIgb3AiKTsKKwkJCWJyZWFrOworCX0KKworCXJldHVybiAoTm9kZSAqKSBq c2V4cHI7Cit9CisKKy8qCisgKiBDb21tb24gY29kZSBmb3IgSlNPTl9WQUxVRSwgSlNPTl9RVUVS WSwgSlNPTl9FWElTVFMgdHJhbnNmb3JtYXRpb24KKyAqIGludG8gYSBKc29uRXhwciBub2RlLgor ICovCitzdGF0aWMgSnNvbkV4cHIgKgordHJhbnNmb3JtSnNvbkV4cHJDb21tb24oUGFyc2VTdGF0 ZSAqcHN0YXRlLCBKc29uRnVuY0V4cHIgKmZ1bmMsCisJCQkJCQljb25zdCBjaGFyICpjb25zdHJ1 Y3ROYW1lKQoreworCUpzb25FeHByICAgKmpzZXhwciA9IG1ha2VOb2RlKEpzb25FeHByKTsKKwlO b2RlCSAgICpwYXRoc3BlYzsKKworCWpzZXhwci0+bG9jYXRpb24gPSBmdW5jLT5sb2NhdGlvbjsK Kwlqc2V4cHItPm9wID0gZnVuYy0+b3A7CisJanNleHByLT5mb3JtYXR0ZWRfZXhwciA9IHRyYW5z Zm9ybUpzb25WYWx1ZUV4cHIocHN0YXRlLCBjb25zdHJ1Y3ROYW1lLAorCQkJCQkJCQkJCQkJCWZ1 bmMtPmNvbnRleHRfaXRlbSwKKwkJCQkJCQkJCQkJCQlKU19GT1JNQVRfSlNPTiwKKwkJCQkJCQkJ CQkJCQlJbnZhbGlkT2lkLCBmYWxzZSk7CisKKwlpZiAoZXhwclR5cGUoanNleHByLT5mb3JtYXR0 ZWRfZXhwcikgIT0gSlNPTkJPSUQpCisJCWVyZXBvcnQoRVJST1IsCisJCQkJZXJyY29kZShFUlJD T0RFX0ZFQVRVUkVfTk9UX1NVUFBPUlRFRCksCisJCQkJZXJybXNnKCIlcygpIGlzIG5vdCB5ZXQg aW1wbGVtZW50ZWQgZm9yIHRoZSBqc29uIHR5cGUiLAorCQkJCQkgICBjb25zdHJ1Y3ROYW1lKSwK KwkJCQllcnJoaW50KCJUcnkgY2FzdGluZyB0aGUgYXJndW1lbnQgdG8ganNvbmIiKSwKKwkJCQlw YXJzZXJfZXJycG9zaXRpb24ocHN0YXRlLCBleHByTG9jYXRpb24oanNleHByLT5mb3JtYXR0ZWRf ZXhwcikpKTsKKworCWpzZXhwci0+Zm9ybWF0ID0gZnVuYy0+Y29udGV4dF9pdGVtLT5mb3JtYXQ7 CisKKwkvKiBCb3RoIHNldCBpbiB0aGUgY2FsbGVyLiAqLworCWpzZXhwci0+cmVzdWx0X2NvZXJj aW9uID0gTlVMTDsKKwlqc2V4cHItPm9taXRfcXVvdGVzID0gZmFsc2U7CisKKwlwYXRoc3BlYyA9 IHRyYW5zZm9ybUV4cHJSZWN1cnNlKHBzdGF0ZSwgZnVuYy0+cGF0aHNwZWMpOworCisJanNleHBy LT5wYXRoX3NwZWMgPQorCQljb2VyY2VfdG9fdGFyZ2V0X3R5cGUocHN0YXRlLCBwYXRoc3BlYywg ZXhwclR5cGUocGF0aHNwZWMpLAorCQkJCQkJCSAgSlNPTlBBVEhPSUQsIC0xLAorCQkJCQkJCSAg Q09FUkNJT05fRVhQTElDSVQsIENPRVJDRV9JTVBMSUNJVF9DQVNULAorCQkJCQkJCSAgZXhwckxv Y2F0aW9uKHBhdGhzcGVjKSk7CisJaWYgKCFqc2V4cHItPnBhdGhfc3BlYykKKwkJZXJlcG9ydChF UlJPUiwKKwkJCQkoZXJyY29kZShFUlJDT0RFX0RBVEFUWVBFX01JU01BVENIKSwKKwkJCQkgZXJy bXNnKCJKU09OIHBhdGggZXhwcmVzc2lvbiBtdXN0IGJlIG9mIHR5cGUgJXMsIG5vdCBvZiB0eXBl ICVzIiwKKwkJCQkJCSJqc29ucGF0aCIsIGZvcm1hdF90eXBlX2JlKGV4cHJUeXBlKHBhdGhzcGVj KSkpLAorCQkJCSBwYXJzZXJfZXJycG9zaXRpb24ocHN0YXRlLCBleHByTG9jYXRpb24ocGF0aHNw ZWMpKSkpOworCisJLyoKKwkgKiBUcmFuc2Zvcm0gYW5kIGNvZXJjZSB0byBqc29uW2JdIHBhc3Np bmcgYXJndW1lbnRzLCB3aG9zZSBmb3JtYXQgaXMKKwkgKiBkZXRlcm1pbmVkIGJ5IGNvbnRleHQg aXRlbSB0eXBlLgorCSAqLworCXRyYW5zZm9ybUpzb25QYXNzaW5nQXJncyhwc3RhdGUsIGNvbnN0 cnVjdE5hbWUsCisJCQkJCQkJIGV4cHJUeXBlKGpzZXhwci0+Zm9ybWF0dGVkX2V4cHIpID09IEpT T05CT0lEID8KKwkJCQkJCQkgSlNfRk9STUFUX0pTT05CIDogSlNfRk9STUFUX0pTT04sCisJCQkJ CQkJIGZ1bmMtPnBhc3NpbmcsCisJCQkJCQkJICZqc2V4cHItPnBhc3NpbmdfdmFsdWVzLAorCQkJ CQkJCSAmanNleHByLT5wYXNzaW5nX25hbWVzKTsKKworCWpzZXhwci0+cmV0dXJuaW5nID0gdHJh bnNmb3JtSnNvbk91dHB1dChwc3RhdGUsIGZ1bmMtPm91dHB1dCwgZmFsc2UpOworCisJLyogSlNP Tl9RVUVSWSBzdXBwb3J0cyBzcGVjaWZ5aW5nIEZPUk1BVCBleHBsaWNpdGx5LiAqLworCWlmIChm dW5jLT5vcCAhPSBKU09OX1FVRVJZX09QKQorCXsKKwkJanNleHByLT5yZXR1cm5pbmctPmZvcm1h dC0+Zm9ybWF0X3R5cGUgPSBKU19GT1JNQVRfREVGQVVMVDsKKwkJanNleHByLT5yZXR1cm5pbmct PmZvcm1hdC0+ZW5jb2RpbmcgPSBKU19FTkNfREVGQVVMVDsKKwl9CisKKwlyZXR1cm4ganNleHBy OworfQorCisvKgorICogVHJhbnNmb3JtIGEgSlNPTiBQQVNTSU5HIGNsYXVzZS4KKyAqLworc3Rh dGljIHZvaWQKK3RyYW5zZm9ybUpzb25QYXNzaW5nQXJncyhQYXJzZVN0YXRlICpwc3RhdGUsIGNv bnN0IGNoYXIgKmNvbnN0cnVjdE5hbWUsCisJCQkJCQkgSnNvbkZvcm1hdFR5cGUgZm9ybWF0LCBM aXN0ICphcmdzLAorCQkJCQkJIExpc3QgKipwYXNzaW5nX3ZhbHVlcywgTGlzdCAqKnBhc3Npbmdf bmFtZXMpCit7CisJTGlzdENlbGwgICAqbGM7CisKKwkqcGFzc2luZ192YWx1ZXMgPSBOSUw7CisJ KnBhc3NpbmdfbmFtZXMgPSBOSUw7CisKKwlmb3JlYWNoKGxjLCBhcmdzKQorCXsKKwkJSnNvbkFy Z3VtZW50ICphcmcgPSBjYXN0Tm9kZShKc29uQXJndW1lbnQsIGxmaXJzdChsYykpOworCQlOb2Rl CSAgICpleHByID0gdHJhbnNmb3JtSnNvblZhbHVlRXhwcihwc3RhdGUsIGNvbnN0cnVjdE5hbWUs CisJCQkJCQkJCQkJCQkgIGFyZy0+dmFsLCBmb3JtYXQsCisJCQkJCQkJCQkJCQkgIEludmFsaWRP aWQsIHRydWUpOworCisJCSpwYXNzaW5nX3ZhbHVlcyA9IGxhcHBlbmQoKnBhc3NpbmdfdmFsdWVz LCBleHByKTsKKwkJKnBhc3NpbmdfbmFtZXMgPSBsYXBwZW5kKCpwYXNzaW5nX25hbWVzLCBtYWtl U3RyaW5nKGFyZy0+bmFtZSkpOworCX0KK30KKworLyoKKyAqIENyZWF0ZSBhbiBleHByZXNzaW9u IHRvIGNvZXJjZSB0aGUgb3V0cHV0IG9mIEpTT05fVkFMVUUoKSAvIEpTT05fUVVFUlkoKQorICog dG8gdGhlIG91dHB1dCB0eXBlLCBpZiBuZWVkZWQuCisgKi8KK3N0YXRpYyBOb2RlICoKK2NvZXJj ZUpzb25GdW5jRXhwck91dHB1dChQYXJzZVN0YXRlICpwc3RhdGUsIEpzb25FeHByICpqc2V4cHIp Cit7CisJSnNvblJldHVybmluZyAqcmV0dXJuaW5nID0ganNleHByLT5yZXR1cm5pbmc7CisJTm9k ZQkgICAqY29udGV4dF9pdGVtID0ganNleHByLT5mb3JtYXR0ZWRfZXhwcjsKKwlpbnQJCQlkZWZh dWx0X3R5cG1vZDsKKwlPaWQJCQlkZWZhdWx0X3R5cGlkOworCisJQXNzZXJ0KHJldHVybmluZyk7 CisKKwkvKgorCSAqIFVzZSBhIEpzb25Db2VyY2lvbiBub2RlIHRvIGltcGxlbWVudCBhIG5vbi1k ZWZhdWx0IFFVT1RFUyBvciBXUkFQUEVSCisJICogYmVoYXZpb3IuCisJICovCisJaWYgKGpzZXhw ci0+b21pdF9xdW90ZXMgfHwganNleHByLT53cmFwcGVyICE9IEpTV19VTlNQRUMpCisJeworCQlK c29uQ29lcmNpb24gKmNvZXJjaW9uID0gbWFrZUpzb25Db2VyY2lvbihyZXR1cm5pbmcpOworCisJ CWNvZXJjaW9uLT5vbWl0X3F1b3RlcyA9IGpzZXhwci0+b21pdF9xdW90ZXM7CisKKwkJcmV0dXJu IChOb2RlICopIGNvZXJjaW9uOworCX0KKworCWRlZmF1bHRfdHlwaWQgPSBKc29uRnVuY0V4cHJE ZWZhdWx0UmV0dXJuVHlwZShqc2V4cHIpOworCWRlZmF1bHRfdHlwbW9kID0gLTE7CisJaWYgKHJl dHVybmluZy0+dHlwaWQgIT0gZGVmYXVsdF90eXBpZCB8fAorCQlyZXR1cm5pbmctPnR5cG1vZCAh PSBkZWZhdWx0X3R5cG1vZCkKKwl7CisJCS8qCisJCSAqIFdlIGFidXNlIENhc2VUZXN0RXhwciBo ZXJlIGFzIHBsYWNlaG9sZGVyIHRvIHBhc3MgdGhlIHJlc3VsdCBvZgorCQkgKiBldmFsdWF0aW5n IHRoZSBKU09OX1ZBTFVFL1FVRVJZIGpzb25wYXRoIGV4cHJlc3Npb24gYXMgaW5wdXQgdG8gdGhl CisJCSAqIGNvZXJjaW9uIGV4cHJlc3Npb24uCisJCSAqLworCQlDYXNlVGVzdEV4cHIgKnBsYWNl aG9sZGVyID0gbWFrZU5vZGUoQ2FzZVRlc3RFeHByKTsKKworCQlwbGFjZWhvbGRlci0+dHlwZUlk ID0gZXhwclR5cGUoY29udGV4dF9pdGVtKTsKKwkJcGxhY2Vob2xkZXItPnR5cGVNb2QgPSBleHBy VHlwbW9kKGNvbnRleHRfaXRlbSk7CisJCXBsYWNlaG9sZGVyLT5jb2xsYXRpb24gPSBleHByQ29s bGF0aW9uKGNvbnRleHRfaXRlbSk7CisKKwkJQXNzZXJ0KHBsYWNlaG9sZGVyLT50eXBlSWQgPT0g ZGVmYXVsdF90eXBpZCk7CisJCUFzc2VydChwbGFjZWhvbGRlci0+dHlwZU1vZCA9PSBkZWZhdWx0 X3R5cG1vZCk7CisKKwkJcmV0dXJuIGNvZXJjZUpzb25FeHByKHBzdGF0ZSwgKE5vZGUgKikgcGxh Y2Vob2xkZXIsIHJldHVybmluZyk7CisJfQorCisJcmV0dXJuIE5VTEw7Cit9CisKKy8qIFJldHVy bnMgdGhlIGRlZmF1bHQgdHlwZSBmb3IgYSBnaXZlbiBKc29uRXhwciBmb3IgYSBnaXZlbiBKc29u Rm9ybWF0LiAqLworc3RhdGljIE9pZAorSnNvbkZ1bmNFeHByRGVmYXVsdFJldHVyblR5cGUoSnNv bkV4cHIgKmpzZXhwcikKK3sKKwlKc29uRm9ybWF0ICpmb3JtYXQgPSBqc2V4cHItPmZvcm1hdDsK KwlOb2RlCSAgICpjb250ZXh0X2l0ZW0gPSBqc2V4cHItPmZvcm1hdHRlZF9leHByOworCisJQXNz ZXJ0KGZvcm1hdCk7CisJaWYgKGZvcm1hdC0+Zm9ybWF0X3R5cGUgPT0gSlNfRk9STUFUX0pTT05C KQorCQlyZXR1cm4gSlNPTkJPSUQ7CisJZWxzZSBpZiAoZm9ybWF0LT5mb3JtYXRfdHlwZSA9PSBK U19GT1JNQVRfREVGQVVMVCAmJgorCQkJIGV4cHJUeXBlKGNvbnRleHRfaXRlbSkgPT0gSlNPTkJP SUQpCisJCXJldHVybiBKU09OQk9JRDsKKworCXJldHVybiBKU09OT0lEOworfQorCisvKgorICog UmV0dXJucyBhIEpzb25Db2VyY2lvbiBub2RlIHRvIGNvZXJjZSBhIGpzb25iLXZhbHVlZCBleHBy ZXNzaW9uIHRvIHRoZQorICogdGFyZ2V0IHR5cGUgZ2l2ZW4gYnkgJ3JldHVybmluZycgdXNpbmcg ZWl0aGVyIGpzb25fcG9wdWxhdGVfdHlwZSgpIG9yCisgKiBieSB1c2luZyB0aGUgdGFyZ2V0IHR5 cGUncyBpbnB1dCBmdW5jdGlvbi4KKyAqLworc3RhdGljIEpzb25Db2VyY2lvbiAqCittYWtlSnNv bkNvZXJjaW9uKGNvbnN0IEpzb25SZXR1cm5pbmcgKnJldHVybmluZykKK3sKKwlKc29uQ29lcmNp b24gKmNvZXJjaW9uID0gbWFrZU5vZGUoSnNvbkNvZXJjaW9uKTsKKworCWNvZXJjaW9uLT50YXJn ZXR0eXBlID0gcmV0dXJuaW5nLT50eXBpZDsKKwljb2VyY2lvbi0+dGFyZ2V0dHlwbW9kID0gcmV0 dXJuaW5nLT50eXBtb2Q7CisKKwlyZXR1cm4gY29lcmNpb247Cit9CisKKy8qCisgKiBTZXQgdXAg YSBKc29uQ29lcmNpb24gbm9kZSB0bzoKKyAqCisgKiAJLSBjb2VyY2UgZXhwcmVzc2lvbiB0byB0 aGUgb3V0cHV0IHJldHVybmluZyB0eXBlLCBvcgorICogCS0gY29lcmNlIHVzaW5nIGpzb25fcG9w dWxhdGVfdHlwZSgpIGlmIHJldHVybmluZyB0eXBlIHJlcXVpcmVzIGl0LCBvcgorICogCS0gY29l cmNlIHZpYSBJL08uCisgKi8KK3N0YXRpYyBOb2RlICoKK2NvZXJjZUpzb25FeHByKFBhcnNlU3Rh dGUgKnBzdGF0ZSwgTm9kZSAqZXhwciwgY29uc3QgSnNvblJldHVybmluZyAqcmV0dXJuaW5nKQor eworCU5vZGUJICAgKmNvZXJjZWRfZXhwcjsKKworCWNvZXJjZWRfZXhwciA9IGNvZXJjZUpzb25G dW5jRXhwcihwc3RhdGUsIGV4cHIsIHJldHVybmluZywgZmFsc2UpOworCWlmIChjb2VyY2VkX2V4 cHIpCisJeworCQlpZiAoY29lcmNlZF9leHByID09IGV4cHIpCisJCQlyZXR1cm4gTlVMTDsKKwkJ cmV0dXJuIGNvZXJjZWRfZXhwcjsKKwl9CisKKwlyZXR1cm4gKE5vZGUgKikgbWFrZUpzb25Db2Vy Y2lvbihyZXR1cm5pbmcpOworfQorCisvKgorICogSW5pdGlhbGl6ZSBKc29uQ29lcmNpb24gbm9k ZXMgZm9yIGNvZXJjaW5nIGEgZ2l2ZW4gSlNPTiBpdGVtIHZhbHVlIHByb2R1Y2VkCisgKiBieSBK U09OX1ZBTFVFIHRvIHRoZSB0YXJnZXQgInJldHVybmluZyIgdHlwZTsgYWxzbyBzZWUKKyAqIEV4 ZWNQcmVwYXJlSnNvbkl0ZW1Db2VyY2lvbigpLgorICovCitzdGF0aWMgTGlzdCAqCitJbml0SnNv bkl0ZW1Db2VyY2lvbnMoUGFyc2VTdGF0ZSAqcHN0YXRlLCBjb25zdCBKc29uUmV0dXJuaW5nICpy ZXR1cm5pbmcsCisJCQkJCSAgT2lkIGNvbnRleHRJdGVtVHlwZUlkKQoreworCUxpc3QJICAgKml0 ZW1fY29lcmNpb25zID0gTklMOworCWludAkJCWk7CisJT2lkCQkJdHlwZW9pZDsKKwlzdHJ1Y3QK Kwl7CisJCUpzb25JdGVtVHlwZSBpdGVtX3R5cGU7CisJCU9pZAkJdHlwZW9pZDsKKwl9CQlpdGVt X3R5cGVzW10gPQorCXsKKwkJe0pzb25JdGVtVHlwZU51bGwsIFVOS05PV05PSUR9LAorCQl7SnNv bkl0ZW1UeXBlU3RyaW5nLCBURVhUT0lEfSwKKwkJe0pzb25JdGVtVHlwZU51bWVyaWMsIE5VTUVS SUNPSUR9LAorCQl7SnNvbkl0ZW1UeXBlQm9vbGVhbiwgQk9PTE9JRH0sCisJCXtKc29uSXRlbVR5 cGVEYXRlLCBEQVRFT0lEfSwKKwkJe0pzb25JdGVtVHlwZVRpbWUsIFRJTUVPSUR9LAorCQl7SnNv bkl0ZW1UeXBlVGltZXR6LCBUSU1FVFpPSUR9LAorCQl7SnNvbkl0ZW1UeXBlVGltZXN0YW1wLCBU SU1FU1RBTVBPSUR9LAorCQl7SnNvbkl0ZW1UeXBlVGltZXN0YW1wdHosIFRJTUVTVEFNUFRaT0lE fSwKKwkJe0pzb25JdGVtVHlwZUNvbXBvc2l0ZSwgY29udGV4dEl0ZW1UeXBlSWR9LAorCQl7SnNv bkl0ZW1UeXBlSW52YWxpZCwgSW52YWxpZE9pZH0KKwl9OworCisJZm9yIChpID0gMDsgT2lkSXNW YWxpZCh0eXBlb2lkID0gaXRlbV90eXBlc1tpXS50eXBlb2lkKTsgaSsrKQorCXsKKwkJTm9kZQkg ICAqZXhwcjsKKwkJSnNvbkl0ZW1Db2VyY2lvbiAqaXRlbV9jb2VyY2lvbiA9IG1ha2VOb2RlKEpz b25JdGVtQ29lcmNpb24pOworCisJCWlmICh0eXBlb2lkID09IFVOS05PV05PSUQpCisJCXsKKwkJ CWV4cHIgPSAoTm9kZSAqKSBtYWtlTnVsbENvbnN0KFVOS05PV05PSUQsIC0xLCBJbnZhbGlkT2lk KTsKKwkJfQorCQllbHNlCisJCXsKKwkJCUNhc2VUZXN0RXhwciAqcGxhY2Vob2xkZXIgPSBtYWtl Tm9kZShDYXNlVGVzdEV4cHIpOworCisJCQkvKgorCQkJICogV2UgYWJ1c2UgQ2FzZVRlc3RFeHBy IGhlcmUgYXMgcGxhY2Vob2xkZXIgdG8gcGFzcyB0aGUgcmVzdWx0IG9mCisJCQkgKiBKU09OX1ZB TFVFIGpzb25wYXRoIGV4cHJlc3Npb24gdG8gdGhlIGNvZXJjaW9uIGZ1bmN0aW9uLgorCQkJICov CisJCQlwbGFjZWhvbGRlci0+dHlwZUlkID0gaXRlbV90eXBlc1tpXS50eXBlb2lkOworCQkJcGxh Y2Vob2xkZXItPnR5cGVNb2QgPSAtMTsKKwkJCXBsYWNlaG9sZGVyLT5jb2xsYXRpb24gPSBJbnZh bGlkT2lkOworCisJCQlleHByID0gKE5vZGUgKikgcGxhY2Vob2xkZXI7CisJCX0KKworCQlpdGVt X2NvZXJjaW9uLT5pdGVtX3R5cGUgPSBpdGVtX3R5cGVzW2ldLml0ZW1fdHlwZTsKKwkJaXRlbV9j b2VyY2lvbi0+Y29lcmNpb24gPSBjb2VyY2VKc29uRXhwcihwc3RhdGUsIGV4cHIsIHJldHVybmlu Zyk7CisJCWl0ZW1fY29lcmNpb25zID0gbGFwcGVuZChpdGVtX2NvZXJjaW9ucywgaXRlbV9jb2Vy Y2lvbik7CisJfQorCisJcmV0dXJuIGl0ZW1fY29lcmNpb25zOworfQorCisvKgorICogUmV0dXJu cyBjb25zdGFudCB2YWx1ZXMgdG8gYmUgcmV0dXJuZWQgdG8gdGhlIHVzZXIgZm9yIHZhcmlvdXMK KyAqIG5vbi1FUlJPUiBPTiBFUlJPUi9FTVBUWSBiZWhhdmlvcnMuCisgKgorICogTm90ZSB0aGF0 IEpTT05fQkVIQVZJT1JfREVGQVVMVCBleHByZXNzaW9uIGlzIGhhbmRsZWQgYnkgdGhlCisgKiBj YWxsZXIgc2VwYXJhdGVseS4KKyAqLworc3RhdGljIE5vZGUgKgorR2V0SnNvbkJlaGF2aW9yQ29u c3RFeHByKEpzb25CZWhhdmlvclR5cGUgYnR5cGUsIGludCBsb2NhdGlvbikKK3sKKwlEYXR1bQl2 YWwgPSAoRGF0dW0pIDA7CisJT2lkCQl0eXBpZCA9IEpTT05CT0lEOworCWludAkJbGVuID0gLTE7 CisJYm9vbAlpc2J5dmFsID0gZmFsc2U7CisJYm9vbAlpc251bGwgPSBmYWxzZTsKKwlDb25zdCAg KmNvbjsKKworCXN3aXRjaCAoYnR5cGUpCisJeworCQljYXNlIEpTT05fQkVIQVZJT1JfRU1QVFlf QVJSQVk6CisJCQl2YWwgPSBEaXJlY3RGdW5jdGlvbkNhbGwxKGpzb25iX2luLCBDU3RyaW5nR2V0 RGF0dW0oIltdIikpOworCQkJYnJlYWs7CisKKwkJY2FzZSBKU09OX0JFSEFWSU9SX0VNUFRZX09C SkVDVDoKKwkJCXZhbCA9IERpcmVjdEZ1bmN0aW9uQ2FsbDEoanNvbmJfaW4sIENTdHJpbmdHZXRE YXR1bSgie30iKSk7CisJCQlicmVhazsKKworCQljYXNlIEpTT05fQkVIQVZJT1JfVFJVRToKKwkJ CXZhbCA9IEJvb2xHZXREYXR1bSh0cnVlKTsKKwkJCXR5cGlkID0gQk9PTE9JRDsKKwkJCWxlbiA9 IHNpemVvZihib29sKTsKKwkJCWlzYnl2YWwgPSB0cnVlOworCQkJYnJlYWs7CisKKwkJY2FzZSBK U09OX0JFSEFWSU9SX0ZBTFNFOgorCQkJdmFsID0gQm9vbEdldERhdHVtKGZhbHNlKTsKKwkJCXR5 cGlkID0gQk9PTE9JRDsKKwkJCWxlbiA9IHNpemVvZihib29sKTsKKwkJCWlzYnl2YWwgPSB0cnVl OworCQkJYnJlYWs7CisKKwkJY2FzZSBKU09OX0JFSEFWSU9SX05VTEw6CisJCWNhc2UgSlNPTl9C RUhBVklPUl9VTktOT1dOOgorCQljYXNlIEpTT05fQkVIQVZJT1JfRU1QVFk6CisJCQl2YWwgPSAo RGF0dW0pIDA7CisJCQlpc251bGwgPSB0cnVlOworCQkJdHlwaWQgPSBJTlQ0T0lEOworCQkJbGVu ID0gc2l6ZW9mKGludDMyKTsKKwkJCWlzYnl2YWwgPSB0cnVlOworCQkJYnJlYWs7CisKKwkJY2Fz ZSBKU09OX0JFSEFWSU9SX0RFRkFVTFQ6CisJCWNhc2UgSlNPTl9CRUhBVklPUl9FUlJPUjoKKwkJ CS8qIEFsd2F5cyBoYW5kbGVkIGluIHRoZSBjYWxsZXIuICovCisJCQlBc3NlcnQoZmFsc2UpOwor CQkJYnJlYWs7CisKKwkJZGVmYXVsdDoKKwkJCWVsb2coRVJST1IsICJ1bnJlY29nbml6ZWQgU1FM L0pTT04gYmVoYXZpb3IgJWQiLCBidHlwZSk7CisJCQlicmVhazsKKwl9CisKKwljb24gPSBtYWtl Q29uc3QodHlwaWQsIC0xLCBJbnZhbGlkT2lkLCBsZW4sIHZhbCwgaXNudWxsLCBpc2J5dmFsKTsK Kwljb24tPmxvY2F0aW9uID0gbG9jYXRpb247CisKKwlyZXR1cm4gKE5vZGUgKikgY29uOworfQor CisvKgorICogVHJhbnNmb3JtIGEgSlNPTiBCRUhBVklPUiBjbGF1c2UuCisgKi8KK3N0YXRpYyBK c29uQmVoYXZpb3IgKgordHJhbnNmb3JtSnNvbkJlaGF2aW9yKFBhcnNlU3RhdGUgKnBzdGF0ZSwg SnNvbkJlaGF2aW9yICpiZWhhdmlvciwKKwkJCQkJICBKc29uQmVoYXZpb3JUeXBlIGRlZmF1bHRf YmVoYXZpb3IsCisJCQkJCSAgSnNvblJldHVybmluZyAqcmV0dXJuaW5nKQoreworCUpzb25CZWhh dmlvclR5cGUgYmVoYXZpb3JfdHlwZSA9IGRlZmF1bHRfYmVoYXZpb3I7CisJTm9kZQkgICAqZXhw ciA9IE5VTEw7CisJSnNvbkNvZXJjaW9uICpjb2VyY2lvbiA9IE5VTEw7CisJaW50CQkJbG9jYXRp b24gPSAtMTsKKworCWlmIChiZWhhdmlvcikKKwl7CisJCWJlaGF2aW9yX3R5cGUgPSBiZWhhdmlv ci0+YnR5cGU7CisJCWxvY2F0aW9uID0gYmVoYXZpb3ItPmxvY2F0aW9uOworCQlpZiAoYmVoYXZp b3JfdHlwZSA9PSBKU09OX0JFSEFWSU9SX0RFRkFVTFQpCisJCQlleHByID0gdHJhbnNmb3JtRXhw clJlY3Vyc2UocHN0YXRlLCBiZWhhdmlvci0+ZXhwcik7CisJfQorCisJaWYgKGV4cHIgPT0gTlVM TCAmJiBiZWhhdmlvcl90eXBlICE9IEpTT05fQkVIQVZJT1JfRVJST1IpCisJCWV4cHIgPSAJR2V0 SnNvbkJlaGF2aW9yQ29uc3RFeHByKGJlaGF2aW9yX3R5cGUsIGxvY2F0aW9uKTsKKworCWlmIChl eHByKQorCXsKKwkJTm9kZSAgICpjb2VyY2VkX2V4cHIgPSBleHByOworCQlib29sCWlzbnVsbCA9 IChJc0EoZXhwciwgQ29uc3QpICYmICgoQ29uc3QgKikgZXhwciktPmNvbnN0aXNudWxsKTsKKwor CQkvKgorCQkgKiBDb2VyY2UgTlVMTHMgYW5kICJkZWZhdWx0IiAodGhhdCBpcywgbm90IHNwZWNp ZmllZCBieSB0aGUgdXNlcikKKwkJICoganNvbmItdmFsdWVkIGV4cHJlc3Npb25zIHVzaW5nIGEg SnNvbkNvZXJjaW9uIG5vZGUuCisJCSAqCisJCSAqIEZvciBvdGhlciAodXNlci1zcGVjaWZpZWQp IG5vbi1OVUxMIHZhbHVlcywgdHJ5IHRvIGZpbmQgYSBjYXN0CisJCSAqIGFuZCBlcnJvciBvdXQg aWYgb25lIGlzIG5vdCBmb3VuZC4KKwkJICovCisJCWlmIChpc251bGwgfHwKKwkJCShleHByVHlw ZShleHByKSA9PSBKU09OQk9JRCAmJgorCQkJIGJlaGF2aW9yX3R5cGUgPT0gZGVmYXVsdF9iZWhh dmlvcikpCisJCQljb2VyY2lvbiA9IG1ha2VKc29uQ29lcmNpb24ocmV0dXJuaW5nKTsKKwkJZWxz ZQorCQkJY29lcmNlZF9leHByID0KKwkJCQljb2VyY2VfdG9fdGFyZ2V0X3R5cGUocHN0YXRlLCBl eHByLCBleHByVHlwZShleHByKSwKKwkJCQkJCQkJCSAgcmV0dXJuaW5nLT50eXBpZCwgcmV0dXJu aW5nLT50eXBtb2QsCisJCQkJCQkJCQkgIENPRVJDSU9OX0VYUExJQ0lULCBDT0VSQ0VfRVhQTElD SVRfQ0FTVCwKKwkJCQkJCQkJCSAgZXhwckxvY2F0aW9uKChOb2RlICopIGJlaGF2aW9yKSk7CisK KwkJaWYgKGNvZXJjZWRfZXhwciA9PSBOVUxMKQorCQkJZXJlcG9ydChFUlJPUiwKKwkJCQkJZXJy Y29kZShFUlJDT0RFX0NBTk5PVF9DT0VSQ0UpLAorCQkJCQllcnJtc2coImNhbm5vdCBjYXN0IGJl aGF2aW9yIGV4cHJlc3Npb24gb2YgdHlwZSAlcyB0byAlcyIsCisJCQkJCQkgICBmb3JtYXRfdHlw ZV9iZShleHByVHlwZShleHByKSksCisJCQkJCQkgICBmb3JtYXRfdHlwZV9iZShyZXR1cm5pbmct PnR5cGlkKSksCisJCQkJCQkgICBwYXJzZXJfZXJycG9zaXRpb24ocHN0YXRlLCBleHByTG9jYXRp b24oZXhwcikpKTsKKwkJZWxzZQorCQkJZXhwciA9IGNvZXJjZWRfZXhwcjsKKwl9CisKKwlyZXR1 cm4gbWFrZUpzb25CZWhhdmlvcihiZWhhdmlvcl90eXBlLCBleHByLCBjb2VyY2lvbiwgbG9jYXRp b24pOworfQpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvcGFyc2VyL3BhcnNlX3RhcmdldC5jIGIv c3JjL2JhY2tlbmQvcGFyc2VyL3BhcnNlX3RhcmdldC5jCmluZGV4IDBjZDkwNGY4ZGEuLmVhNWFj NmJhZmUgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3BhcnNlci9wYXJzZV90YXJnZXQuYworKysg Yi9zcmMvYmFja2VuZC9wYXJzZXIvcGFyc2VfdGFyZ2V0LmMKQEAgLTE5ODksNiArMTk4OSwyMSBA QCBGaWd1cmVDb2xuYW1lSW50ZXJuYWwoTm9kZSAqbm9kZSwgY2hhciAqKm5hbWUpCiAJCQkvKiBt YWtlIEpTT05fQVJSQVlBR0cgYWN0IGxpa2UgYSByZWd1bGFyIGZ1bmN0aW9uICovCiAJCQkqbmFt ZSA9ICJqc29uX2FycmF5YWdnIjsKIAkJCXJldHVybiAyOworCQljYXNlIFRfSnNvbkZ1bmNFeHBy OgorCQkJLyogbWFrZSBTUUwvSlNPTiBmdW5jdGlvbnMgYWN0IGxpa2UgYSByZWd1bGFyIGZ1bmN0 aW9uICovCisJCQlzd2l0Y2ggKCgoSnNvbkZ1bmNFeHByICopIG5vZGUpLT5vcCkKKwkJCXsKKwkJ CQljYXNlIEpTT05fRVhJU1RTX09QOgorCQkJCQkqbmFtZSA9ICJqc29uX2V4aXN0cyI7CisJCQkJ CXJldHVybiAyOworCQkJCWNhc2UgSlNPTl9RVUVSWV9PUDoKKwkJCQkJKm5hbWUgPSAianNvbl9x dWVyeSI7CisJCQkJCXJldHVybiAyOworCQkJCWNhc2UgSlNPTl9WQUxVRV9PUDoKKwkJCQkJKm5h bWUgPSAianNvbl92YWx1ZSI7CisJCQkJCXJldHVybiAyOworCQkJfQorCQkJYnJlYWs7CiAJCWRl ZmF1bHQ6CiAJCQlicmVhazsKIAl9CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9hZHQv anNvbnBhdGhfZXhlYy5jIGIvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L2pzb25wYXRoX2V4ZWMuYwpp bmRleCA2ZGE2ZTI3ZWU2Li42ZDYxZDg3ZjAxIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC91dGls cy9hZHQvanNvbnBhdGhfZXhlYy5jCisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9qc29ucGF0 aF9leGVjLmMKQEAgLTMwODUsNyArMzA4NSw3IEBAIEpzb25QYXRoUXVlcnkoRGF0dW0gamIsIEpz b25QYXRoICpqcCwgSnNvbldyYXBwZXIgd3JhcHBlciwgYm9vbCAqZW1wdHksCiAJc2luZ2xldG9u ID0gY291bnQgPiAwID8gSnNvblZhbHVlTGlzdEhlYWQoJmZvdW5kKSA6IE5VTEw7CiAJaWYgKHNp bmdsZXRvbiA9PSBOVUxMKQogCQl3cmFwID0gZmFsc2U7Ci0JZWxzZSBpZiAod3JhcHBlciA9PSBK U1dfTk9ORSkKKwllbHNlIGlmICh3cmFwcGVyID09IEpTV19OT05FIHx8IHdyYXBwZXIgPT0gSlNX X1VOU1BFQykKIAkJd3JhcCA9IGZhbHNlOwogCWVsc2UgaWYgKHdyYXBwZXIgPT0gSlNXX1VOQ09O RElUSU9OQUwpCiAJCXdyYXAgPSB0cnVlOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvdXRpbHMv YWR0L3J1bGV1dGlscy5jIGIvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L3J1bGV1dGlscy5jCmluZGV4 IDBiMmExNjQwNTcuLjI3MzUzNDg0MTYgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxzL2Fk dC9ydWxldXRpbHMuYworKysgYi9zcmMvYmFja2VuZC91dGlscy9hZHQvcnVsZXV0aWxzLmMKQEAg LTQ3Niw2ICs0NzYsOCBAQCBzdGF0aWMgdm9pZCBnZXRfY29uc3RfZXhwcihDb25zdCAqY29uc3R2 YWwsIGRlcGFyc2VfY29udGV4dCAqY29udGV4dCwKIAkJCQkJCSAgIGludCBzaG93dHlwZSk7CiBz dGF0aWMgdm9pZCBnZXRfY29uc3RfY29sbGF0aW9uKENvbnN0ICpjb25zdHZhbCwgZGVwYXJzZV9j b250ZXh0ICpjb250ZXh0KTsKIHN0YXRpYyB2b2lkIGdldF9qc29uX2Zvcm1hdChKc29uRm9ybWF0 ICpmb3JtYXQsIFN0cmluZ0luZm8gYnVmKTsKK3N0YXRpYyB2b2lkIGdldF9qc29uX3JldHVybmlu ZyhKc29uUmV0dXJuaW5nICpyZXR1cm5pbmcsIFN0cmluZ0luZm8gYnVmLAorCQkJCQkJCSAgIGJv b2wganNvbl9mb3JtYXRfYnlfZGVmYXVsdCk7CiBzdGF0aWMgdm9pZCBnZXRfanNvbl9jb25zdHJ1 Y3RvcihKc29uQ29uc3RydWN0b3JFeHByICpjdG9yLAogCQkJCQkJCQkgZGVwYXJzZV9jb250ZXh0 ICpjb250ZXh0LCBib29sIHNob3dpbXBsaWNpdCk7CiBzdGF0aWMgdm9pZCBnZXRfanNvbl9jb25z dHJ1Y3Rvcl9vcHRpb25zKEpzb25Db25zdHJ1Y3RvckV4cHIgKmN0b3IsCkBAIC01MTgsNiArNTIw LDggQEAgc3RhdGljIGNoYXIgKmdlbmVyYXRlX3F1YWxpZmllZF90eXBlX25hbWUoT2lkIHR5cGlk KTsKIHN0YXRpYyB0ZXh0ICpzdHJpbmdfdG9fdGV4dChjaGFyICpzdHIpOwogc3RhdGljIGNoYXIg KmZsYXR0ZW5fcmVsb3B0aW9ucyhPaWQgcmVsaWQpOwogc3RhdGljIHZvaWQgZ2V0X3JlbG9wdGlv bnMoU3RyaW5nSW5mbyBidWYsIERhdHVtIHJlbG9wdGlvbnMpOworc3RhdGljIHZvaWQgZ2V0X2pz b25fcGF0aF9zcGVjKE5vZGUgKnBhdGhfc3BlYywgZGVwYXJzZV9jb250ZXh0ICpjb250ZXh0LAor CQkJCQkJCSAgIGJvb2wgc2hvd2ltcGxpY2l0KTsKIAogI2RlZmluZSBvbmx5X21hcmtlcihydGUp ICAoKHJ0ZSktPmluaCA/ICIiIDogIk9OTFkgIikKIApAQCAtODMwMCw2ICs4MzA0LDcgQEAgaXNT aW1wbGVOb2RlKE5vZGUgKm5vZGUsIE5vZGUgKnBhcmVudE5vZGUsIGludCBwcmV0dHlGbGFncykK IAkJY2FzZSBUX1dpbmRvd0Z1bmM6CiAJCWNhc2UgVF9GdW5jRXhwcjoKIAkJY2FzZSBUX0pzb25D b25zdHJ1Y3RvckV4cHI6CisJCWNhc2UgVF9Kc29uRXhwcjoKIAkJCS8qIGZ1bmN0aW9uLWxpa2U6 IG5hbWUoLi4pIG9yIG5hbWVbLi5dICovCiAJCQlyZXR1cm4gdHJ1ZTsKIApAQCAtODQ3MSw2ICs4 NDc2LDcgQEAgaXNTaW1wbGVOb2RlKE5vZGUgKm5vZGUsIE5vZGUgKnBhcmVudE5vZGUsIGludCBw cmV0dHlGbGFncykKIAkJCQljYXNlIFRfR3JvdXBpbmdGdW5jOgkvKiBvd24gcGFyZW50aGVzZXMg Ki8KIAkJCQljYXNlIFRfV2luZG93RnVuYzoJLyogb3duIHBhcmVudGhlc2VzICovCiAJCQkJY2Fz ZSBUX0Nhc2VFeHByOgkvKiBvdGhlciBzZXBhcmF0b3JzICovCisJCQkJY2FzZSBUX0pzb25FeHBy OgkvKiBvd24gcGFyZW50aGVzZXMgKi8KIAkJCQkJcmV0dXJuIHRydWU7CiAJCQkJZGVmYXVsdDoK IAkJCQkJcmV0dXJuIGZhbHNlOwpAQCAtODU4Niw2ICs4NTkyLDY0IEBAIGdldF9ydWxlX2V4cHJf cGFyZW4oTm9kZSAqbm9kZSwgZGVwYXJzZV9jb250ZXh0ICpjb250ZXh0LAogCQlhcHBlbmRTdHJp bmdJbmZvQ2hhcihjb250ZXh0LT5idWYsICcpJyk7CiB9CiAKK3N0YXRpYyB2b2lkCitnZXRfanNv bl9iZWhhdmlvcihKc29uQmVoYXZpb3IgKmJlaGF2aW9yLCBkZXBhcnNlX2NvbnRleHQgKmNvbnRl eHQsCisJCQkJICBjb25zdCBjaGFyICpvbikKK3sKKwkvKgorCSAqIFRoZSBvcmRlciBvZiBhcnJh eSBlbGVtZW50cyBtdXN0IGNvcnJlc3BvbmQgdG8gdGhlIG9yZGVyIG9mCisJICogSnNvbkJlaGF2 aW9yVHlwZSBtZW1iZXJzLgorCSAqLworCWNvbnN0IGNoYXIgKmJlaGF2aW9yX25hbWVzW10gPQor CXsKKwkJIiBOVUxMIiwKKwkJIiBFUlJPUiIsCisJCSIgRU1QVFkiLAorCQkiIFRSVUUiLAorCQki IEZBTFNFIiwKKwkJIiBVTktOT1dOIiwKKwkJIiBFTVBUWSBBUlJBWSIsCisJCSIgRU1QVFkgT0JK RUNUIiwKKwkJIiBERUZBVUxUICIKKwl9OworCisJaWYgKChpbnQpIGJlaGF2aW9yLT5idHlwZSA8 IDAgfHwgYmVoYXZpb3ItPmJ0eXBlID49IGxlbmd0aG9mKGJlaGF2aW9yX25hbWVzKSkKKwkJZWxv ZyhFUlJPUiwgImludmFsaWQganNvbiBiZWhhdmlvciB0eXBlOiAlZCIsIGJlaGF2aW9yLT5idHlw ZSk7CisKKwlhcHBlbmRTdHJpbmdJbmZvU3RyaW5nKGNvbnRleHQtPmJ1ZiwgYmVoYXZpb3JfbmFt ZXNbYmVoYXZpb3ItPmJ0eXBlXSk7CisKKwlpZiAoYmVoYXZpb3ItPmJ0eXBlID09IEpTT05fQkVI QVZJT1JfREVGQVVMVCkKKwkJZ2V0X3J1bGVfZXhwcihiZWhhdmlvci0+ZXhwciwgY29udGV4dCwg ZmFsc2UpOworCisJYXBwZW5kU3RyaW5nSW5mbyhjb250ZXh0LT5idWYsICIgT04gJXMiLCBvbik7 Cit9CisKKy8qCisgKiBnZXRfanNvbl9leHByX29wdGlvbnMKKyAqCisgKiBQYXJzZSBiYWNrIGNv bW1vbiBvcHRpb25zIGZvciBKU09OX1FVRVJZLCBKU09OX1ZBTFVFLCBKU09OX0VYSVNUUy4KKyAq Lworc3RhdGljIHZvaWQKK2dldF9qc29uX2V4cHJfb3B0aW9ucyhKc29uRXhwciAqanNleHByLCBk ZXBhcnNlX2NvbnRleHQgKmNvbnRleHQsCisJCQkJCSAgSnNvbkJlaGF2aW9yVHlwZSBkZWZhdWx0 X2JlaGF2aW9yKQoreworCWlmIChqc2V4cHItPm9wID09IEpTT05fUVVFUllfT1ApCisJeworCQlp ZiAoanNleHByLT53cmFwcGVyID09IEpTV19DT05ESVRJT05BTCkKKwkJCWFwcGVuZFN0cmluZ0lu Zm8oY29udGV4dC0+YnVmLCAiIFdJVEggQ09ORElUSU9OQUwgV1JBUFBFUiIpOworCQllbHNlIGlm IChqc2V4cHItPndyYXBwZXIgPT0gSlNXX1VOQ09ORElUSU9OQUwpCisJCQlhcHBlbmRTdHJpbmdJ bmZvKGNvbnRleHQtPmJ1ZiwgIiBXSVRIIFVOQ09ORElUSU9OQUwgV1JBUFBFUiIpOworCisJCWlm IChqc2V4cHItPm9taXRfcXVvdGVzKQorCQkJYXBwZW5kU3RyaW5nSW5mbyhjb250ZXh0LT5idWYs ICIgT01JVCBRVU9URVMiKTsKKwl9CisKKwlpZiAoanNleHByLT5vbl9lbXB0eSAmJiBqc2V4cHIt Pm9uX2VtcHR5LT5idHlwZSAhPSBkZWZhdWx0X2JlaGF2aW9yKQorCQlnZXRfanNvbl9iZWhhdmlv cihqc2V4cHItPm9uX2VtcHR5LCBjb250ZXh0LCAiRU1QVFkiKTsKKworCWlmIChqc2V4cHItPm9u X2Vycm9yICYmIGpzZXhwci0+b25fZXJyb3ItPmJ0eXBlICE9IGRlZmF1bHRfYmVoYXZpb3IpCisJ CWdldF9qc29uX2JlaGF2aW9yKGpzZXhwci0+b25fZXJyb3IsIGNvbnRleHQsICJFUlJPUiIpOwor fQogCiAvKiAtLS0tLS0tLS0tCiAgKiBnZXRfcnVsZV9leHByCQkJLSBQYXJzZSBiYWNrIGFuIGV4 cHJlc3Npb24KQEAgLTk3NDUsNiArOTgwOSw3IEBAIGdldF9ydWxlX2V4cHIoTm9kZSAqbm9kZSwg ZGVwYXJzZV9jb250ZXh0ICpjb250ZXh0LAogCQkJfQogCQkJYnJlYWs7CiAKKwogCQljYXNlIFRf SnNvblZhbHVlRXhwcjoKIAkJCXsKIAkJCQlKc29uVmFsdWVFeHByICpqdmUgPSAoSnNvblZhbHVl RXhwciAqKSBub2RlOwpAQCAtOTc5NCw2ICs5ODU5LDY0IEBAIGdldF9ydWxlX2V4cHIoTm9kZSAq bm9kZSwgZGVwYXJzZV9jb250ZXh0ICpjb250ZXh0LAogCQkJfQogCQkJYnJlYWs7CiAKKwkJY2Fz ZSBUX0pzb25FeHByOgorCQkJeworCQkJCUpzb25FeHByICAgKmpleHByID0gKEpzb25FeHByICop IG5vZGU7CisKKwkJCQlzd2l0Y2ggKGpleHByLT5vcCkKKwkJCQl7CisJCQkJCWNhc2UgSlNPTl9F WElTVFNfT1A6CisJCQkJCQlhcHBlbmRTdHJpbmdJbmZvU3RyaW5nKGJ1ZiwgIkpTT05fRVhJU1RT KCIpOworCQkJCQkJYnJlYWs7CisJCQkJCWNhc2UgSlNPTl9RVUVSWV9PUDoKKwkJCQkJCWFwcGVu ZFN0cmluZ0luZm9TdHJpbmcoYnVmLCAiSlNPTl9RVUVSWSgiKTsKKwkJCQkJCWJyZWFrOworCQkJ CQljYXNlIEpTT05fVkFMVUVfT1A6CisJCQkJCQlhcHBlbmRTdHJpbmdJbmZvU3RyaW5nKGJ1Ziwg IkpTT05fVkFMVUUoIik7CisJCQkJCQlicmVhazsKKwkJCQl9CisKKwkJCQlnZXRfcnVsZV9leHBy KGpleHByLT5mb3JtYXR0ZWRfZXhwciwgY29udGV4dCwgc2hvd2ltcGxpY2l0KTsKKworCQkJCWFw cGVuZFN0cmluZ0luZm9TdHJpbmcoYnVmLCAiLCAiKTsKKworCQkJCWdldF9qc29uX3BhdGhfc3Bl YyhqZXhwci0+cGF0aF9zcGVjLCBjb250ZXh0LCBzaG93aW1wbGljaXQpOworCisJCQkJaWYgKGpl eHByLT5wYXNzaW5nX3ZhbHVlcykKKwkJCQl7CisJCQkJCUxpc3RDZWxsICAgKmxjMSwKKwkJCQkJ CQkgICAqbGMyOworCQkJCQlib29sCQluZWVkY29tbWEgPSBmYWxzZTsKKworCQkJCQlhcHBlbmRT dHJpbmdJbmZvU3RyaW5nKGJ1ZiwgIiBQQVNTSU5HICIpOworCisJCQkJCWZvcmJvdGgobGMxLCBq ZXhwci0+cGFzc2luZ19uYW1lcywKKwkJCQkJCQlsYzIsIGpleHByLT5wYXNzaW5nX3ZhbHVlcykK KwkJCQkJeworCQkJCQkJaWYgKG5lZWRjb21tYSkKKwkJCQkJCQlhcHBlbmRTdHJpbmdJbmZvU3Ry aW5nKGJ1ZiwgIiwgIik7CisJCQkJCQluZWVkY29tbWEgPSB0cnVlOworCisJCQkJCQlnZXRfcnVs ZV9leHByKChOb2RlICopIGxmaXJzdChsYzIpLCBjb250ZXh0LCBzaG93aW1wbGljaXQpOworCQkJ CQkJYXBwZW5kU3RyaW5nSW5mbyhidWYsICIgQVMgJXMiLAorCQkJCQkJCQkJCSAoKFN0cmluZyAq KSBsZmlyc3Rfbm9kZShTdHJpbmcsIGxjMSkpLT5zdmFsKTsKKwkJCQkJfQorCQkJCX0KKworCQkJ CWlmIChqZXhwci0+b3AgIT0gSlNPTl9FWElTVFNfT1AgfHwKKwkJCQkJamV4cHItPnJldHVybmlu Zy0+dHlwaWQgIT0gQk9PTE9JRCkKKwkJCQkJZ2V0X2pzb25fcmV0dXJuaW5nKGpleHByLT5yZXR1 cm5pbmcsIGNvbnRleHQtPmJ1ZiwKKwkJCQkJCQkJCSAgIGpleHByLT5vcCA9PSBKU09OX1FVRVJZ X09QKTsKKworCQkJCWdldF9qc29uX2V4cHJfb3B0aW9ucyhqZXhwciwgY29udGV4dCwKKwkJCQkJ CQkJCSAgamV4cHItPm9wICE9IEpTT05fRVhJU1RTX09QID8KKwkJCQkJCQkJCSAgSlNPTl9CRUhB VklPUl9OVUxMIDoKKwkJCQkJCQkJCSAgSlNPTl9CRUhBVklPUl9GQUxTRSk7CisKKwkJCQlhcHBl bmRTdHJpbmdJbmZvU3RyaW5nKGJ1ZiwgIikiKTsKKwkJCX0KKwkJCWJyZWFrOworCiAJCWNhc2Ug VF9MaXN0OgogCQkJewogCQkJCWNoYXIJICAgKnNlcDsKQEAgLTk5MTcsNiArMTAwNDAsNyBAQCBs b29rc19saWtlX2Z1bmN0aW9uKE5vZGUgKm5vZGUpCiAJCWNhc2UgVF9NaW5NYXhFeHByOgogCQlj YXNlIFRfU1FMVmFsdWVGdW5jdGlvbjoKIAkJY2FzZSBUX1htbEV4cHI6CisJCWNhc2UgVF9Kc29u RXhwcjoKIAkJCS8qIHRoZXNlIGFyZSBhbGwgYWNjZXB0ZWQgYnkgZnVuY19leHByX2NvbW1vbl9z dWJleHByICovCiAJCQlyZXR1cm4gdHJ1ZTsKIAkJZGVmYXVsdDoKQEAgLTEwNzg2LDYgKzEwOTEw LDE4IEBAIGdldF9jb25zdF9jb2xsYXRpb24oQ29uc3QgKmNvbnN0dmFsLCBkZXBhcnNlX2NvbnRl eHQgKmNvbnRleHQpCiAJfQogfQogCisvKgorICogZ2V0X2pzb25fcGF0aF9zcGVjCQktIFBhcnNl IGJhY2sgYSBKU09OIHBhdGggc3BlY2lmaWNhdGlvbgorICovCitzdGF0aWMgdm9pZAorZ2V0X2pz b25fcGF0aF9zcGVjKE5vZGUgKnBhdGhfc3BlYywgZGVwYXJzZV9jb250ZXh0ICpjb250ZXh0LCBi b29sIHNob3dpbXBsaWNpdCkKK3sKKwlpZiAoSXNBKHBhdGhfc3BlYywgQ29uc3QpKQorCQlnZXRf Y29uc3RfZXhwcigoQ29uc3QgKikgcGF0aF9zcGVjLCBjb250ZXh0LCAtMSk7CisJZWxzZQorCQln ZXRfcnVsZV9leHByKHBhdGhfc3BlYywgY29udGV4dCwgc2hvd2ltcGxpY2l0KTsKK30KKwogLyoK ICAqIGdldF9qc29uX2Zvcm1hdAkJCS0gUGFyc2UgYmFjayBhIEpzb25Gb3JtYXQgbm9kZQogICov CmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9leGVjdXRvci9leGVjRXhwci5oIGIvc3JjL2luY2x1 ZGUvZXhlY3V0b3IvZXhlY0V4cHIuaAppbmRleCBhMjhkZGNkZDc3Li41ZGIzNTRmMjIwIDEwMDY0 NAotLS0gYS9zcmMvaW5jbHVkZS9leGVjdXRvci9leGVjRXhwci5oCisrKyBiL3NyYy9pbmNsdWRl L2V4ZWN1dG9yL2V4ZWNFeHByLmgKQEAgLTI0MCw2ICsyNDAsOSBAQCB0eXBlZGVmIGVudW0gRXhw ckV2YWxPcAogCUVFT1BfWE1MRVhQUiwKIAlFRU9QX0pTT05fQ09OU1RSVUNUT1IsCiAJRUVPUF9J U19KU09OLAorCUVFT1BfSlNPTkVYUFJfUEFUSCwKKwlFRU9QX0pTT05FWFBSX0NPRVJDSU9OLAor CUVFT1BfSlNPTkVYUFJfQ09FUkNJT05fRklOSVNILAogCUVFT1BfQUdHUkVGLAogCUVFT1BfR1JP VVBJTkdfRlVOQywKIAlFRU9QX1dJTkRPV19GVU5DLApAQCAtNjkyLDYgKzY5NSwyMSBAQCB0eXBl ZGVmIHN0cnVjdCBFeHByRXZhbFN0ZXAKIAkJCUpzb25Jc1ByZWRpY2F0ZSAqcHJlZDsJLyogb3Jp Z2luYWwgZXhwcmVzc2lvbiBub2RlICovCiAJCX0JCQlpc19qc29uOwogCisJCS8qIGZvciBFRU9Q X0pTT05FWFBSX1BBVEggKi8KKwkJc3RydWN0CisJCXsKKwkJCXN0cnVjdCBKc29uRXhwclN0YXRl ICpqc2VzdGF0ZTsKKwkJfQkJCWpzb25leHByOworCisJCS8qIGZvciBFRU9QX0pTT05FWFBSX0NP RVJDSU9OICovCisJCXN0cnVjdAorCQl7CisJCQlKc29uQ29lcmNpb24gICAqY29lcmNpb247CisJ CQlGbWdySW5mbwkgICAqaW5wdXRfZmluZm87CisJCQlPaWQJCQkJdHlwaW9wYXJhbTsKKwkJCXZv aWQJCSAgICpqc29uX3BvcHVsYXRlX3R5cGVfY2FjaGU7CisJCQlFcnJvclNhdmVDb250ZXh0ICpl c2NvbnRleHQ7CisJCX0JCQlqc29uZXhwcl9jb2VyY2lvbjsKIAl9CQkJZDsKIH0gRXhwckV2YWxT dGVwOwogCkBAIC03NTUsNyArNzczLDYgQEAgdHlwZWRlZiBzdHJ1Y3QgSnNvbkNvbnN0cnVjdG9y RXhwclN0YXRlCiAJaW50CQkJbmFyZ3M7CiB9IEpzb25Db25zdHJ1Y3RvckV4cHJTdGF0ZTsKIAot CiAvKiBmdW5jdGlvbnMgaW4gZXhlY0V4cHIuYyAqLwogZXh0ZXJuIHZvaWQgRXhwckV2YWxQdXNo U3RlcChFeHByU3RhdGUgKmVzLCBjb25zdCBFeHByRXZhbFN0ZXAgKnMpOwogCkBAIC04MDksNiAr ODI2LDExIEBAIGV4dGVybiB2b2lkIEV4ZWNFdmFsWG1sRXhwcihFeHByU3RhdGUgKnN0YXRlLCBF eHByRXZhbFN0ZXAgKm9wKTsKIGV4dGVybiB2b2lkIEV4ZWNFdmFsSnNvbkNvbnN0cnVjdG9yKEV4 cHJTdGF0ZSAqc3RhdGUsIEV4cHJFdmFsU3RlcCAqb3AsCiAJCQkJCQkJCQlFeHByQ29udGV4dCAq ZWNvbnRleHQpOwogZXh0ZXJuIHZvaWQgRXhlY0V2YWxKc29uSXNQcmVkaWNhdGUoRXhwclN0YXRl ICpzdGF0ZSwgRXhwckV2YWxTdGVwICpvcCk7CitleHRlcm4gdm9pZAlFeGVjRXZhbEpzb25Db2Vy Y2lvbihFeHByU3RhdGUgKnN0YXRlLCBFeHByRXZhbFN0ZXAgKm9wLAorCQkJCQkJCQkgRXhwckNv bnRleHQgKmVjb250ZXh0KTsKK2V4dGVybiB2b2lkCUV4ZWNFdmFsSnNvbkNvZXJjaW9uRmluaXNo KEV4cHJTdGF0ZSAqc3RhdGUsIEV4cHJFdmFsU3RlcCAqb3ApOworZXh0ZXJuIGludCBFeGVjRXZh bEpzb25FeHByUGF0aChFeHByU3RhdGUgKnN0YXRlLCBFeHByRXZhbFN0ZXAgKm9wLAorCQkJCQkJ CQlFeHByQ29udGV4dCAqZWNvbnRleHQpOwogZXh0ZXJuIHZvaWQgRXhlY0V2YWxHcm91cGluZ0Z1 bmMoRXhwclN0YXRlICpzdGF0ZSwgRXhwckV2YWxTdGVwICpvcCk7CiBleHRlcm4gdm9pZCBFeGVj RXZhbFN1YlBsYW4oRXhwclN0YXRlICpzdGF0ZSwgRXhwckV2YWxTdGVwICpvcCwKIAkJCQkJCQlF eHByQ29udGV4dCAqZWNvbnRleHQpOwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvbm9kZXMvZXhl Y25vZGVzLmggYi9zcmMvaW5jbHVkZS9ub2Rlcy9leGVjbm9kZXMuaAppbmRleCA0NDRhNWYwZmQ1 Li4yZThkZjIzMDFmIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9ub2Rlcy9leGVjbm9kZXMuaAor KysgYi9zcmMvaW5jbHVkZS9ub2Rlcy9leGVjbm9kZXMuaApAQCAtMTAwOCw2ICsxMDA4LDkyIEBA IHR5cGVkZWYgc3RydWN0IERvbWFpbkNvbnN0cmFpbnRTdGF0ZQogCUV4cHJTdGF0ZSAgKmNoZWNr X2V4cHJzdGF0ZTsJLyogY2hlY2tfZXhwcidzIGV2YWwgc3RhdGUsIG9yIE5VTEwgKi8KIH0gRG9t YWluQ29uc3RyYWludFN0YXRlOwogCisvKgorICogSW5mb3JtYXRpb24gYWJvdXQgdGhlIHN0YXRl IG9mIEpzb25QYXRoKiBldmFsdWF0aW9uLgorICovCit0eXBlZGVmIHN0cnVjdCBKc29uRXhwclBv c3RFdmFsU3RhdGUKK3sKKwkvKiBEaWQgSnNvblBhdGgqIGV2YWx1YXRpb24gY2F1c2UgYW4gZXJy b3I/ICovCisJTnVsbGFibGVEYXR1bQllcnJvcjsKKworCS8qIElzIHRoZSByZXN1bHQgb2YgSnNv blBhdGgqIGV2YWx1YXRpb24gZW1wdHk/ICovCisJTnVsbGFibGVEYXR1bQllbXB0eTsKKworCS8q CisJICogRXhlY0V2YWxKc29uRXhwclBhdGgoKSB3aWxsIHNldCB0aGlzIHRvIHRoZSBhZGRyZXNz IG9mIHRoZSBzdGVwIHRvCisJICogdXNlIHRvIGNvZXJjZSB0aGUgcmVzdWx0IG9mIEpzb25QYXRo KiBldmFsdWF0aW9uIHRvIHRoZSBSRVRVUk5JTkcgdHlwZS4KKwkgKiBBbHNvIHNlZSB0aGUgZGVz Y3JpcHRpb24gb2YgcG9zc2libGUgc3RlcCBhZGRyZXNzZXMgdGhhdCB0aGlzIGNvdWxkIGJlCisJ ICogc2V0IHRvIGluIHRoZSBkZWZpbml0aW9uIG9mIEpzb25FeHByU3RhdGUuCisJICovCisJaW50 CQkJanVtcF9ldmFsX2NvZXJjaW9uOworfSBKc29uRXhwclBvc3RFdmFsU3RhdGU7CisKKy8qIFN0 YXRlIGZvciBldmFsdWF0aW5nIGEgSnNvbkV4cHIsIHRvbyBiaWcgdG8gaW5saW5lICovCit0eXBl ZGVmIHN0cnVjdCBKc29uRXhwclN0YXRlCit7CisJLyogb3JpZ2luYWwgZXhwcmVzc2lvbiBub2Rl ICovCisJSnNvbkV4cHIgICAqanNleHByOworCisJLyogdmFsdWUvaXNudWxsIGZvciBmb3JtYXR0 ZWRfZXhwciAqLworCU51bGxhYmxlRGF0dW0gZm9ybWF0dGVkX2V4cHI7CisKKwkvKiB2YWx1ZS9p c251bGwgZm9yIHBhdGhzcGVjICovCisJTnVsbGFibGVEYXR1bSBwYXRoc3BlYzsKKworCS8qIEpz b25QYXRoVmFyaWFibGUgZW50cmllcyBmb3IgcGFzc2luZ192YWx1ZXMgKi8KKwlMaXN0CSAgICph cmdzOworCisJLyoKKwkgKiBQZXItcm93IHJlc3VsdCBzdGF0dXMgaW5mbyBwb3B1bGF0ZWQgYnkg RXhlY0V2YWxKc29uRXhwclBhdGgoKQorCSAqIGFuZCBFeGVjRXZhbEpzb25Db2VyY2lvbkZpbmlz aCgpLgorCSAqLworCUpzb25FeHByUG9zdEV2YWxTdGF0ZSBwb3N0X2V2YWw7CisKKwkvKgorCSAq IEFkZHJlc3NlcyBvZiB0aGUgc3RlcHMgdGhhdCBpbXBsZW1lbnRzIHRoZSBub24tRVJST1IgdmFy aWFudCBvZiBPTiBFTVBUWQorCSAqIGFuZCBPTiBFUlJPUiBiZWhhdmlvcnMsIHJlc3BlY3RpdmVs eS4KKwkgKi8KKwlpbnQJCQlqdW1wX2VtcHR5OworCWludAkJCWp1bXBfZXJyb3I7CisKKwkvKgor CSAqIEFkZHJlc3NlcyBvZiBzdGVwcyB0byBwZXJmb3JtIHRoZSBjb2VyY2lvbiBvZiB0aGUgSnNv blBhdGgqIHJlc3VsdCB2YWx1ZQorCSAqIHRvIHRoZSBSRVRVUk5JTkcgdHlwZS4gIEVhY2ggYWRk cmVzcyBwb2ludHMgdG8gZWl0aGVyIDEpIGEgc3BlY2lhbAorCSAqIEVFT1BfSlNPTkVYUFJfQ09F UkNJT04gc3RlcCB0aGF0IGhhbmRsZXMgY29lcmNpb24gdXNpbmcgdGhlIFJFVFVSTklORworCSAq IHR5cGUncyBpbnB1dCBmdW5jdGlvbiBvciBieSB1c2luZyBqc29uX3ZpYV9wb3B1bGF0ZSgpLCBv ciAyKSBhbgorCSAqIGV4cHJlc3Npb24gc3VjaCBhcyBDb2VyY2VWaWFJTy4gIEl0IG1heSBiZSAt MSBpZiBubyBjb2VyY2lvbiBpcworCSAqIG5lY2Vzc2FyeS4KKwkgKgorCSAqIGp1bXBfZXZhbF9y ZXN1bHRfY29lcmNpb24gcG9pbnRzIHRvIHRoZSBzdGVwIHRvIGV2YWx1YXRlIHRoZSBjb2VyY2lv bgorCSAqIGdpdmVuIGluIEpzb25FeHByLnJlc3VsdF9jb2VyY2lvbi4KKwkgKi8KKwlpbnQJCQlq dW1wX2V2YWxfcmVzdWx0X2NvZXJjaW9uOworCisJLyogSnVtcCB0byBlbmQgdG8gc2tpcCBhbGwg dGhlIHN0ZXBzIGFmdGVyIEVFT1BfSlNPTkVYUFJfUEFUSC4gKi8KKwlpbnQJCQlqdW1wX2VuZDsK KworCS8qIGV2YWxfaXRlbV9jb2VyY2lvbl9qdW1wcyBpcyBhbiBhcnJheSBvZiBudW1faXRlbV9j b2VyY2lvbnMgZWxlbWVudHMKKwkgKiBlYWNoIGNvbnRhaW5pbmcgYSBzdGVwIGFkZHJlc3MgdG8g ZXZhbHVhdGUgdGhlIGNvZXJjaW9uIGZyb20gYSB2YWx1ZSBvZgorCSAqIHRoZSBnaXZlbiBKc29u SXRlbVR5cGUgdG8gdGhlIFJFVFVSTklORyB0eXBlLCBvciAtMSBpZiBubyBjb2VyY2lvbiBpcwor CSAqIG5lY2Vzc2FyeS4gIGl0ZW1fY29lcmNpb25fdmlhX2V4cHIgaXMgYW4gYXJyYXkgb2YgYm9v bGVhbiBmbGFncyBvZiB0aGUKKwkgKiBzYW1lIGxlbmd0aCB0aGF0IGluZGljYXRlcyB3aGV0aGVy IGVhY2ggdmFsaWQgc3RlcCBhZGRyZXNzIGluIHRoZQorCSAqIGV2YWxfaXRlbV9jb2VyY2lvbl9q dW1wcyBhcnJheSBwb2ludHMgdG8gYW4gZXhwcmVzc2lvbiBvciBhCisJICogRUVPUF9KU09ORVhQ Ul9DT0VSQ0lPTiBzdGVwLiAgRXhlY0V2YWxKc29uRXhwclBhdGgoKSB3aWxsIGNhdXNlIGFuCisJ ICogZXJyb3IgaWYgaXQncyB0aGUgbGF0dGVyLCBiZWNhdXNlIHRoYXQgbW9kZSBvZiBjb2VyY2lv biBpcyBub3QKKwkgKiBzdXBwb3J0ZWQgZm9yIGFsbCBKc29uSXRlbVR5cGVzLgorCSAqLworCWlu dAkJCW51bV9pdGVtX2NvZXJjaW9uczsKKwlpbnQJCSAgICpldmFsX2l0ZW1fY29lcmNpb25fanVt cHM7CisJYm9vbAkgICAqaXRlbV9jb2VyY2lvbl92aWFfZXhwcjsKKworCS8qCisJICogRm9yIHBh c3Npbmcgd2hlbiBpbml0aWFsaXppbmcgYSBFRU9QX0lPQ09FUkNFX1NBRkUgc3RlcCBmb3IgYW55 CisJICogQ29lcmNlVmlhSU8gbm9kZXMgaW4gdGhlIGV4cHJlc3Npb24gdGhhdCBtdXN0IGJlIGV2 YWx1YXRlZCBpbiBhbgorCSAqIGVycm9yLXNhZmUgbWFubmVyLgorCSAqLworCUVycm9yU2F2ZUNv bnRleHQgZXNjb250ZXh0OworfSBKc29uRXhwclN0YXRlOworCiAKIC8qIC0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICAqCQkJ CSBFeGVjdXRvciBTdGF0ZSBUcmVlcwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvbm9kZXMvbWFr ZWZ1bmNzLmggYi9zcmMvaW5jbHVkZS9ub2Rlcy9tYWtlZnVuY3MuaAppbmRleCAyZGM3OTY0OGQy Li5hOTZmZDYyZDdmIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9ub2Rlcy9tYWtlZnVuY3MuaAor KysgYi9zcmMvaW5jbHVkZS9ub2Rlcy9tYWtlZnVuY3MuaApAQCAtMTEyLDYgKzExMiw4IEBAIGV4 dGVybiBKc29uRm9ybWF0ICptYWtlSnNvbkZvcm1hdChKc29uRm9ybWF0VHlwZSB0eXBlLCBKc29u RW5jb2RpbmcgZW5jb2RpbmcsCiAJCQkJCQkJCSAgaW50IGxvY2F0aW9uKTsKIGV4dGVybiBKc29u VmFsdWVFeHByICptYWtlSnNvblZhbHVlRXhwcihFeHByICpyYXdfZXhwciwgRXhwciAqZm9ybWF0 dGVkX2V4cHIsCiAJCQkJCQkJCQkJSnNvbkZvcm1hdCAqZm9ybWF0KTsKK2V4dGVybiBKc29uQmVo YXZpb3IgKm1ha2VKc29uQmVoYXZpb3IoSnNvbkJlaGF2aW9yVHlwZSB0eXBlLCBOb2RlICpleHBy LAorCQkJCSBKc29uQ29lcmNpb24gKmNvZXJjaW9uLCBpbnQgbG9jYXRpb24pOwogZXh0ZXJuIE5v ZGUgKm1ha2VKc29uS2V5VmFsdWUoTm9kZSAqa2V5LCBOb2RlICp2YWx1ZSk7CiBleHRlcm4gTm9k ZSAqbWFrZUpzb25Jc1ByZWRpY2F0ZShOb2RlICpleHByLCBKc29uRm9ybWF0ICpmb3JtYXQsCiAJ CQkJCQkJCSBKc29uVmFsdWVUeXBlIGl0ZW1fdHlwZSwgYm9vbCB1bmlxdWVfa2V5cywKZGlmZiAt LWdpdCBhL3NyYy9pbmNsdWRlL25vZGVzL3BhcnNlbm9kZXMuaCBiL3NyYy9pbmNsdWRlL25vZGVz L3BhcnNlbm9kZXMuaAppbmRleCBiMzE4MWYzNGFlLi4wMTg0Yzc2Y2U2IDEwMDY0NAotLS0gYS9z cmMvaW5jbHVkZS9ub2Rlcy9wYXJzZW5vZGVzLmgKKysrIGIvc3JjL2luY2x1ZGUvbm9kZXMvcGFy c2Vub2Rlcy5oCkBAIC0xNjkyLDYgKzE2OTIsMjMgQEAgdHlwZWRlZiBzdHJ1Y3QgVHJpZ2dlclRy YW5zaXRpb24KIAogLyogTm9kZXMgZm9yIFNRTC9KU09OIHN1cHBvcnQgKi8KIAorLyoKKyAqIEpz b25RdW90ZXMgLQorICoJCXJlcHJlc2VudGF0aW9uIG9mIFtLRUVQfE9NSVRdIFFVT1RFUyBjbGF1 c2UgZm9yIEpTT05fUVVFUlkoKQorICovCit0eXBlZGVmIGVudW0gSnNvblF1b3RlcworeworCUpT X1FVT1RFU19VTlNQRUMsCQkJLyogdW5zcGVjaWZpZWQgKi8KKwlKU19RVU9URVNfS0VFUCwJCQkJ LyogS0VFUCBRVU9URVMgKi8KKwlKU19RVU9URVNfT01JVCwJCQkJLyogT01JVCBRVU9URVMgKi8K K30gSnNvblF1b3RlczsKKworLyoKKyAqIEpzb25QYXRoU3BlYyAtCisgKgkJcmVwcmVzZW50YXRp b24gb2YgSlNPTiBwYXRoIGNvbnN0YW50CisgKi8KK3R5cGVkZWYgY2hhciAqSnNvblBhdGhTcGVj OworCiAvKgogICogSnNvbk91dHB1dCAtCiAgKgkJcmVwcmVzZW50YXRpb24gb2YgSlNPTiBvdXRw dXQgY2xhdXNlIChSRVRVUk5JTkcgdHlwZSBbRk9STUFUIGZvcm1hdF0pCkBAIC0xNzAzLDYgKzE3 MjAsMzYgQEAgdHlwZWRlZiBzdHJ1Y3QgSnNvbk91dHB1dAogCUpzb25SZXR1cm5pbmcgKnJldHVy bmluZzsJLyogUkVUVVJOSU5HIEZPUk1BVCBjbGF1c2UgYW5kIHR5cGUgT2lkcyAqLwogfSBKc29u T3V0cHV0OwogCisvKgorICogSnNvbkFyZ3VtZW50IC0KKyAqCQlyZXByZXNlbnRhdGlvbiBvZiBh cmd1bWVudCBmcm9tIEpTT04gUEFTU0lORyBjbGF1c2UKKyAqLwordHlwZWRlZiBzdHJ1Y3QgSnNv bkFyZ3VtZW50Cit7CisJTm9kZVRhZwkJdHlwZTsKKwlKc29uVmFsdWVFeHByICp2YWw7CQkJLyog YXJndW1lbnQgdmFsdWUgZXhwcmVzc2lvbiAqLworCWNoYXIJICAgKm5hbWU7CQkJLyogYXJndW1l bnQgbmFtZSAqLworfSBKc29uQXJndW1lbnQ7CisKKy8qCisgKiBKc29uRnVuY0V4cHIgLQorICoJ CXVudHJhbnNmb3JtZWQgcmVwcmVzZW50YXRpb24gb2YgSlNPTiBmdW5jdGlvbiBleHByZXNzaW9u cworICovCit0eXBlZGVmIHN0cnVjdCBKc29uRnVuY0V4cHIKK3sKKwlOb2RlVGFnCQl0eXBlOwor CUpzb25FeHByT3AJb3A7CQkJCS8qIGV4cHJlc3Npb24gdHlwZSAqLworCUpzb25WYWx1ZUV4cHIg KmNvbnRleHRfaXRlbTsJLyogY29udGV4dCBpdGVtIGV4cHJlc3Npb24gKi8KKwlOb2RlCSAgICpw YXRoc3BlYzsJCS8qIEpTT04gcGF0aCBzcGVjaWZpY2F0aW9uIGV4cHJlc3Npb24gKi8KKwlMaXN0 CSAgICpwYXNzaW5nOwkJLyogbGlzdCBvZiBQQVNTSU5HIGNsYXVzZSBhcmd1bWVudHMsIGlmIGFu eSAqLworCUpzb25PdXRwdXQgKm91dHB1dDsJCQkvKiBvdXRwdXQgY2xhdXNlLCBpZiBzcGVjaWZp ZWQgKi8KKwlKc29uQmVoYXZpb3IgKm9uX2VtcHR5OwkJLyogT04gRU1QVFkgYmVoYXZpb3IgKi8K KwlKc29uQmVoYXZpb3IgKm9uX2Vycm9yOwkJLyogT04gRVJST1IgYmVoYXZpb3IgKi8KKwlKc29u V3JhcHBlciB3cmFwcGVyOwkJLyogYXJyYXkgd3JhcHBlciBiZWhhdmlvciAoSlNPTl9RVUVSWSBv bmx5KSAqLworCUpzb25RdW90ZXMJcXVvdGVzOwkJCS8qIG9taXQgb3Iga2VlcCBxdW90ZXM/IChK U09OX1FVRVJZIG9ubHkpICovCisJaW50CQkJbG9jYXRpb247CQkvKiB0b2tlbiBsb2NhdGlvbiwg b3IgLTEgaWYgdW5rbm93biAqLworfSBKc29uRnVuY0V4cHI7CisKIC8qCiAgKiBKc29uS2V5VmFs dWUgLQogICoJCXVudHJhbnNmb3JtZWQgcmVwcmVzZW50YXRpb24gb2YgSlNPTiBvYmplY3Qga2V5 LXZhbHVlIHBhaXIgZm9yCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9ub2Rlcy9wcmltbm9kZXMu aCBiL3NyYy9pbmNsdWRlL25vZGVzL3ByaW1ub2Rlcy5oCmluZGV4IDYxMjg5ZDgxMjQuLmZlOWRm YmIwMmEgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL25vZGVzL3ByaW1ub2Rlcy5oCisrKyBiL3Ny Yy9pbmNsdWRlL25vZGVzL3ByaW1ub2Rlcy5oCkBAIC0xNTUyLDYgKzE1NTIsMTcgQEAgdHlwZWRl ZiBzdHJ1Y3QgWG1sRXhwcgogCWludAkJCWxvY2F0aW9uOwogfSBYbWxFeHByOwogCisvKgorICog SnNvbkV4cHJPcCAtCisgKgkJZW51bWVyYXRpb24gb2YgSlNPTiBmdW5jdGlvbnMgdXNpbmcgSlNP TiBwYXRoCisgKi8KK3R5cGVkZWYgZW51bSBKc29uRXhwck9wCit7CisJSlNPTl9WQUxVRV9PUCwJ CQkJLyogSlNPTl9WQUxVRSgpICovCisJSlNPTl9RVUVSWV9PUCwJCQkJLyogSlNPTl9RVUVSWSgp ICovCisJSlNPTl9FWElTVFNfT1AsCQkJCS8qIEpTT05fRVhJU1RTKCkgKi8KK30gSnNvbkV4cHJP cDsKKwogLyoKICAqIEpzb25FbmNvZGluZyAtCiAgKgkJcmVwcmVzZW50YXRpb24gb2YgSlNPTiBF TkNPRElORyBjbGF1c2UKQEAgLTE1ODIsMTEgKzE1OTMsMzIgQEAgdHlwZWRlZiBlbnVtIEpzb25G b3JtYXRUeXBlCiAgKi8KIHR5cGVkZWYgZW51bSBKc29uV3JhcHBlcgogeworCUpTV19VTlNQRUMs CiAJSlNXX05PTkUsCiAJSlNXX0NPTkRJVElPTkFMLAogCUpTV19VTkNPTkRJVElPTkFMLAogfSBK c29uV3JhcHBlcjsKIAorLyoKKyAqIEpzb25CZWhhdmlvclR5cGUgLQorICoJCWVudW1lcmF0aW9u IG9mIGJlaGF2aW9yIHR5cGVzIHVzZWQgaW4gSlNPTiBPTiAuLi4gQkVIQVZJT1IgY2xhdXNlCisg KgorICogCQlJZiBlbnVtIG1lbWJlcnMgYXJlIHJlb3JkZXJlZCwgZ2V0X2pzb25fYmVoYXZpb3Io KSBmcm9tIHJ1bGV1dGlscy5jCisgKiAJCW11c3QgYmUgdXBkYXRlZCBhY2NvcmRpbmdseS4KKyAq LwordHlwZWRlZiBlbnVtIEpzb25CZWhhdmlvclR5cGUKK3sKKwlKU09OX0JFSEFWSU9SX05VTEwg PSAwLAorCUpTT05fQkVIQVZJT1JfRVJST1IsCisJSlNPTl9CRUhBVklPUl9FTVBUWSwKKwlKU09O X0JFSEFWSU9SX1RSVUUsCisJSlNPTl9CRUhBVklPUl9GQUxTRSwKKwlKU09OX0JFSEFWSU9SX1VO S05PV04sCisJSlNPTl9CRUhBVklPUl9FTVBUWV9BUlJBWSwKKwlKU09OX0JFSEFWSU9SX0VNUFRZ X09CSkVDVCwKKwlKU09OX0JFSEFWSU9SX0RFRkFVTFQsCit9IEpzb25CZWhhdmlvclR5cGU7CisK IC8qCiAgKiBKc29uRm9ybWF0IC0KICAqCQlyZXByZXNlbnRhdGlvbiBvZiBKU09OIEZPUk1BVCBj bGF1c2UKQEAgLTE2ODEsNiArMTcxMywxMzggQEAgdHlwZWRlZiBzdHJ1Y3QgSnNvbklzUHJlZGlj YXRlCiAJaW50CQkJbG9jYXRpb247CQkvKiB0b2tlbiBsb2NhdGlvbiwgb3IgLTEgaWYgdW5rbm93 biAqLwogfSBKc29uSXNQcmVkaWNhdGU7CiAKKy8qCisgKiBKc29uQ29lcmNpb24KKyAqCQlJbmZv cm1hdGlvbiBhYm91dCBjb2VyY2luZyBhIFNRTC9KU09OIHZhbHVlIHRvIHRoZSBzcGVjaWZpZWQK KyAqCQl0eXBlIGF0IHJ1bnRpbWUgdXNpbmcganNvbl9wb3B1bGF0ZV90eXBlKCkgb3IgYnkgY2Fs bGluZyB0aGUgdHlwZSdzCisgKgkJaW5wdXQgZnVudGlvbi4KKyAqCisgKiBBIG5vZGUgb2YgdGhp cyB0eXBlIGlzIGNyZWF0ZWQgaWYgdGhlIHBhcnNlciBjYW5ub3QgZmluZCBhIGNhc3QgZXhwcmVz c2lvbgorICogdXNpbmcgY29lcmNlX3R5cGUoKS4KKyAqLwordHlwZWRlZiBzdHJ1Y3QgSnNvbkNv ZXJjaW9uCit7CisJTm9kZVRhZwkJdHlwZTsKKworCU9pZAkJCXRhcmdldHR5cGU7CisJaW50MzIJ CXRhcmdldHR5cG1vZDsKKwlib29sCQlvbWl0X3F1b3RlczsJLyogb21pdCBxdW90ZXMgZnJvbSBz Y2FsYXIgb3V0cHV0IHN0cmluZ3M/ICovCisJT2lkCQkJY29sbGF0aW9uOwkJLyogY29sbGF0aW9u IGZvciBjb2VyY2lvbiB2aWEgSS9PIG9yIHBvcHVsYXRlICovCit9IEpzb25Db2VyY2lvbjsKKwor LyoKKyAqIEpzb25JdGVtVHlwZQorICoJCVBvc3NpYmxlIHR5cGVzIGZvciBzY2FsYXIgdmFsdWVz IHJldHVybmVkIGJ5IEpTT05fVkFMVUUoKQorICoKKyAqIFRoZSBjb21tZW50IG5leHQgdG8gZWFj aCBpdGVtIHR5cGUgbWVudGlvbnMgdGhlIGNvcnJlc3BvbmRpbmcKKyAqIEpzb25iVmFsdWUuamJ2 VHlwZS4KKyAqLwordHlwZWRlZiBlbnVtIEpzb25JdGVtVHlwZQoreworCUpzb25JdGVtVHlwZU51 bGwsCQkvKiBqYnZOdWxsICovCisJSnNvbkl0ZW1UeXBlU3RyaW5nLAkJLyogamJ2U3RyaW5nICov CisJSnNvbkl0ZW1UeXBlTnVtZXJpYywJLyogamJ2TnVtZXJpYyAqLworCUpzb25JdGVtVHlwZUJv b2xlYW4sCS8qIGpidkJvb2wgKi8KKwlKc29uSXRlbVR5cGVEYXRlLAkJLyogamJ2RGF0ZXRpbWU6 IERBVEVPSUQgKi8KKwlKc29uSXRlbVR5cGVUaW1lLAkJLyogamJ2RGF0ZXRpbWU6IFRJTUVPSUQg Ki8KKwlKc29uSXRlbVR5cGVUaW1ldHosCQkvKiBqYnZEYXRldGltZTogVElNRVRaT0lEICovCisJ SnNvbkl0ZW1UeXBlVGltZXN0YW1wLAkvKiBqYnZEYXRldGltZTogVElNRVNUQU1QT0lEICovCisJ SnNvbkl0ZW1UeXBlVGltZXN0YW1wdHosLyogamJ2RGF0ZXRpbWU6IFRJTUVTVEFNUFRaT0lEICov CisJSnNvbkl0ZW1UeXBlQ29tcG9zaXRlLAkvKiBqYnZBcnJheSwgamJ2T2JqZWN0LCBqYnZCaW5h cnkgKi8KKwlKc29uSXRlbVR5cGVJbnZhbGlkLAorfSBKc29uSXRlbVR5cGU7CisKKy8qCisgKiBK c29uSXRlbUNvZXJjaW9uCisgKgkJQ29lcmNpb24gZXhwcmVzc2lvbiBmb3IgdGhlIGdpdmVuIEpz b25JdGVtVHlwZQorICoKKyAqIElmIG5vdCBOVUxMLCAnY29lcmNpb24nIGdpdmVuIHRoZSBleHBy ZXNzaW9uIG5vZGUgdG8gY29udmVydCBhIHNjYWxhciB2YWx1ZQorICogZXh0cmFjdGVkIGZyb20g YSBKc29uYlZhbHVlIG9mIHRoZSBnaXZlbiB0eXBlIHRvIHRoZSB0YXJnZXQgdHlwZSBnaXZlbiBi eQorICogSnNvbkV4cHIucmV0dXJuaW5nLiAgTlVMTCBtZWFucyB0aGUgY29lcmNpb24gaXMgdW5u ZWNlc3NhcnkuCisgKi8KK3R5cGVkZWYgc3RydWN0IEpzb25JdGVtQ29lcmNpb24KK3sKKwlOb2Rl VGFnCQl0eXBlOworCisJSnNvbkl0ZW1UeXBlIGl0ZW1fdHlwZTsKKwlOb2RlCSAgICpjb2VyY2lv bjsKK30gSnNvbkl0ZW1Db2VyY2lvbjsKKworLyoKKyAqIEpzb25CZWhhdmlvcgorICoJCUluZm9y bWF0aW9uIGFib3V0IE9OIEVSUk9SIC8gT04gRU1QVFkgYmVoYXZpb3JzIG9mIEpTT05fVkFMVUUo KSwKKyAqCQlKU09OX1FVRVJZKCksIGFuZCBKU09OX0VYSVNUUygpCisgKgorICogJ2V4cHInIGlz IHRoZSBleHByZXNzaW9uIHRvIGVtaXQgd2hlbiBhIGdpdmVuIGJlaGF2aW9yIChFTVBUWSBvciBF UlJPUikKKyAqIG9jY3VycyBvbiBldmFsdWF0aW5nIHRoZSBTUUwvSlNPTiBxdWVyeSBmdW5jdGlv bi4gICdjb2VyY2lvbicgaXMgc2V0CisgKiBpZiAnZXhwcicgaXNuJ3QgYWxyZWFkeSBvZiB0aGUg ZXhwZWN0ZWQgdGFyZ2V0IHR5cGUgZ2l2ZW4gYnkKKyAqIEpzb25FeHByLnJldHVybmluZy4KKyAq LwordHlwZWRlZiBzdHJ1Y3QgSnNvbkJlaGF2aW9yCit7CisJTm9kZVRhZwkJdHlwZTsKKworCUpz b25CZWhhdmlvclR5cGUgYnR5cGU7CisJTm9kZQkgICAqZXhwcjsKKwlKc29uQ29lcmNpb24gKmNv ZXJjaW9uOwkJLyogdG8gY29lcmNlIGJlaGF2aW9yIGV4cHJlc3Npb24gd2hlbiB0aGVyZSBpcwor CQkJCQkJCQkgKiBubyBjYXN0IHRvIHRoZSB0YXJnZXQgdHlwZSAqLworCWludAkJCWxvY2F0aW9u OwkJLyogdG9rZW4gbG9jYXRpb24sIG9yIC0xIGlmIHVua25vd24gKi8KK30gSnNvbkJlaGF2aW9y OworCisvKgorICogSnNvbkV4cHIgLQorICoJCVRyYW5zZm9ybWVkIHJlcHJlc2VudGF0aW9uIG9m IEpTT05fVkFMVUUoKSwgSlNPTl9RVUVSWSgpLCBhbmQKKyAqCQlKU09OX0VYSVNUUygpCisgKi8K K3R5cGVkZWYgc3RydWN0IEpzb25FeHByCit7CisJRXhwcgkJeHByOworCisJLyogSlNPTl8qIGZ1 bmN0aW9uIGlkZW50aWZpZXIgKi8KKwlKc29uRXhwck9wCW9wOworCisJLyoganNvbihiKS12YWx1 ZWQgZXhwcmVzc2lvbiB0byBxdWVyeSAqLworCU5vZGUJICAgKmZvcm1hdHRlZF9leHByOworCisJ LyogRm9ybWF0IG9mIHRoZSBhYm92ZSBleHByZXNzaW9uIG5lZWRlZCBieSBydWxldXRpbHMuYyAq LworCUpzb25Gb3JtYXQgKmZvcm1hdDsKKworCS8qIGpzb3BhdGgtdmFsdWVkIGV4cHJlc3Npb24g Y29udGFpbmluZyB0aGUgcXVlcnkgcGF0dGVybiAqLworCU5vZGUJICAgKnBhdGhfc3BlYzsKKwor CS8qIEV4cGVjdGVkIHR5cGUvZm9ybWF0IG9mIHRoZSBvdXRwdXQuICovCisJSnNvblJldHVybmlu ZyAqcmV0dXJuaW5nOworCisJLyogSW5mb3JtYXRpb24gYWJvdXQgdGhlIFBBU1NJTkcgYXJndW1l bnQgZXhwcmVzc2lvbnMgKi8KKwlMaXN0CSAgICpwYXNzaW5nX25hbWVzOworCUxpc3QJICAgKnBh c3NpbmdfdmFsdWVzOworCisJLyogVXNlLXNwZWNpZmllZCBvciBkZWZhdWx0IE9OIEVNUFRZIGFu ZCBPTiBFUlJPUiBiZWhhdmlvcnMgKi8KKwlKc29uQmVoYXZpb3IgKm9uX2VtcHR5OworCUpzb25C ZWhhdmlvciAqb25fZXJyb3I7CisKKwkvKgorCSAqIEV4cHJlc3Npb24gdG8gY29udmVydCB0aGUg cmVzdWx0IG9mIEpTT05fKiBmdW5jdGlvbiB0byB0aGUKKwkgKiBSRVRVUk5JTkcgdHlwZQorCSAq LworCU5vZGUJICAgKnJlc3VsdF9jb2VyY2lvbjsKKworCS8qCisJICogTGlzdCBvZiBleHByZXNz aW9ucyBmb3IgY29lcmNpbmcgSlNPTl9WQUxVRSgpIHJlc3VsdCB2YWx1ZXMsIGNvbnRhaW5pbmcK KwkgKiBvbmUgZWxlbWVudCBmb3IgZXZlcnkgSnNvbkl0ZW1UeXBlLgorCSAqLworCUxpc3QJICAg Kml0ZW1fY29lcmNpb25zOworCisJLyogV1JBUFBFUiBzcGVjaWZpY2F0aW9uIGZvciBKU09OX1FV RVJZICovCisJSnNvbldyYXBwZXIgd3JhcHBlcjsKKworCS8qIEtFRVAgb3IgT01JVCBRVU9URVMg Zm9yIHNpbmdsZXRvbiBzY2FsYXJzIHJldHVybmVkIGJ5IEpTT05fUVVFUlkoKSAqLworCWJvb2wJ CW9taXRfcXVvdGVzOworCisJLyogT3JpZ2luYWwgSnNvbkZ1bmNFeHByJ3MgbG9jYXRpb24gKi8K KwlpbnQJCQlsb2NhdGlvbjsKK30gSnNvbkV4cHI7CisKIC8qIC0tLS0tLS0tLS0tLS0tLS0KICAq IE51bGxUZXN0CiAgKgpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvcGFyc2VyL2t3bGlzdC5oIGIv c3JjL2luY2x1ZGUvcGFyc2VyL2t3bGlzdC5oCmluZGV4IDIzMzFhY2FjMDkuLjk0ZTFjYjRkY2Ug MTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL3BhcnNlci9rd2xpc3QuaAorKysgYi9zcmMvaW5jbHVk ZS9wYXJzZXIva3dsaXN0LmgKQEAgLTkzLDYgKzkzLDcgQEAgUEdfS0VZV09SRCgiY29tbWl0Iiwg Q09NTUlULCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJjb21t aXR0ZWQiLCBDT01NSVRURUQsIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tF WVdPUkQoImNvbXByZXNzaW9uIiwgQ09NUFJFU1NJT04sIFVOUkVTRVJWRURfS0VZV09SRCwgQkFS RV9MQUJFTCkKIFBHX0tFWVdPUkQoImNvbmN1cnJlbnRseSIsIENPTkNVUlJFTlRMWSwgVFlQRV9G VU5DX05BTUVfS0VZV09SRCwgQkFSRV9MQUJFTCkKK1BHX0tFWVdPUkQoImNvbmRpdGlvbmFsIiwg Q09ORElUSU9OQUwsIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdPUkQo ImNvbmZpZ3VyYXRpb24iLCBDT05GSUdVUkFUSU9OLCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVf TEFCRUwpCiBQR19LRVlXT1JEKCJjb25mbGljdCIsIENPTkZMSUNULCBVTlJFU0VSVkVEX0tFWVdP UkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJjb25uZWN0aW9uIiwgQ09OTkVDVElPTiwgVU5S RVNFUlZFRF9LRVlXT1JELCBCQVJFX0xBQkVMKQpAQCAtMTQ3LDExICsxNDgsMTMgQEAgUEdfS0VZ V09SRCgiZG91YmxlIiwgRE9VQkxFX1AsIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkK IFBHX0tFWVdPUkQoImRyb3AiLCBEUk9QLCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwp CiBQR19LRVlXT1JEKCJlYWNoIiwgRUFDSCwgVU5SRVNFUlZFRF9LRVlXT1JELCBCQVJFX0xBQkVM KQogUEdfS0VZV09SRCgiZWxzZSIsIEVMU0UsIFJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwp CitQR19LRVlXT1JEKCJlbXB0eSIsIEVNUFRZX1AsIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9M QUJFTCkKIFBHX0tFWVdPUkQoImVuYWJsZSIsIEVOQUJMRV9QLCBVTlJFU0VSVkVEX0tFWVdPUkQs IEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJlbmNvZGluZyIsIEVOQ09ESU5HLCBVTlJFU0VSVkVE X0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJlbmNyeXB0ZWQiLCBFTkNSWVBURUQs IFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdPUkQoImVuZCIsIEVORF9Q LCBSRVNFUlZFRF9LRVlXT1JELCBCQVJFX0xBQkVMKQogUEdfS0VZV09SRCgiZW51bSIsIEVOVU1f UCwgVU5SRVNFUlZFRF9LRVlXT1JELCBCQVJFX0xBQkVMKQorUEdfS0VZV09SRCgiZXJyb3IiLCBF UlJPUl9QLCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJlc2Nh cGUiLCBFU0NBUEUsIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdPUkQo ImV2ZW50IiwgRVZFTlQsIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdP UkQoImV4Y2VwdCIsIEVYQ0VQVCwgUkVTRVJWRURfS0VZV09SRCwgQVNfTEFCRUwpCkBAIC0yMzMs MTAgKzIzNiwxNCBAQCBQR19LRVlXT1JEKCJqb2luIiwgSk9JTiwgVFlQRV9GVU5DX05BTUVfS0VZ V09SRCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdPUkQoImpzb24iLCBKU09OLCBDT0xfTkFNRV9LRVlX T1JELCBCQVJFX0xBQkVMKQogUEdfS0VZV09SRCgianNvbl9hcnJheSIsIEpTT05fQVJSQVksIENP TF9OQU1FX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJqc29uX2FycmF5YWdnIiwg SlNPTl9BUlJBWUFHRywgQ09MX05BTUVfS0VZV09SRCwgQkFSRV9MQUJFTCkKK1BHX0tFWVdPUkQo Impzb25fZXhpc3RzIiwgSlNPTl9FWElTVFMsIENPTF9OQU1FX0tFWVdPUkQsIEJBUkVfTEFCRUwp CiBQR19LRVlXT1JEKCJqc29uX29iamVjdCIsIEpTT05fT0JKRUNULCBDT0xfTkFNRV9LRVlXT1JE LCBCQVJFX0xBQkVMKQogUEdfS0VZV09SRCgianNvbl9vYmplY3RhZ2ciLCBKU09OX09CSkVDVEFH RywgQ09MX05BTUVfS0VZV09SRCwgQkFSRV9MQUJFTCkKK1BHX0tFWVdPUkQoImpzb25fcXVlcnki LCBKU09OX1FVRVJZLCBDT0xfTkFNRV9LRVlXT1JELCBCQVJFX0xBQkVMKQogUEdfS0VZV09SRCgi anNvbl9zY2FsYXIiLCBKU09OX1NDQUxBUiwgQ09MX05BTUVfS0VZV09SRCwgQkFSRV9MQUJFTCkK IFBHX0tFWVdPUkQoImpzb25fc2VyaWFsaXplIiwgSlNPTl9TRVJJQUxJWkUsIENPTF9OQU1FX0tF WVdPUkQsIEJBUkVfTEFCRUwpCitQR19LRVlXT1JEKCJqc29uX3ZhbHVlIiwgSlNPTl9WQUxVRSwg Q09MX05BTUVfS0VZV09SRCwgQkFSRV9MQUJFTCkKK1BHX0tFWVdPUkQoImtlZXAiLCBLRUVQLCBV TlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJrZXkiLCBLRVksIFVO UkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdPUkQoImtleXMiLCBLRVlTLCBV TlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJsYWJlbCIsIExBQkVM LCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCkBAIC0zMDIsNiArMzA5LDcgQEAgUEdf S0VZV09SRCgib2ZmIiwgT0ZGLCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19L RVlXT1JEKCJvZmZzZXQiLCBPRkZTRVQsIFJFU0VSVkVEX0tFWVdPUkQsIEFTX0xBQkVMKQogUEdf S0VZV09SRCgib2lkcyIsIE9JRFMsIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBH X0tFWVdPUkQoIm9sZCIsIE9MRCwgVU5SRVNFUlZFRF9LRVlXT1JELCBCQVJFX0xBQkVMKQorUEdf S0VZV09SRCgib21pdCIsIE9NSVQsIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBH X0tFWVdPUkQoIm9uIiwgT04sIFJFU0VSVkVEX0tFWVdPUkQsIEFTX0xBQkVMKQogUEdfS0VZV09S RCgib25seSIsIE9OTFksIFJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JE KCJvcGVyYXRvciIsIE9QRVJBVE9SLCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCkBA IC0zNDQsNiArMzUyLDcgQEAgUEdfS0VZV09SRCgicHJvY2VkdXJlcyIsIFBST0NFRFVSRVMsIFVO UkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdPUkQoInByb2dyYW0iLCBQUk9H UkFNLCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJwdWJsaWNh dGlvbiIsIFBVQkxJQ0FUSU9OLCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19L RVlXT1JEKCJxdW90ZSIsIFFVT1RFLCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCitQ R19LRVlXT1JEKCJxdW90ZXMiLCBRVU9URVMsIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJF TCkKIFBHX0tFWVdPUkQoInJhbmdlIiwgUkFOR0UsIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9M QUJFTCkKIFBHX0tFWVdPUkQoInJlYWQiLCBSRUFELCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVf TEFCRUwpCiBQR19LRVlXT1JEKCJyZWFsIiwgUkVBTCwgQ09MX05BTUVfS0VZV09SRCwgQkFSRV9M QUJFTCkKQEAgLTQxNCw2ICs0MjMsNyBAQCBQR19LRVlXT1JEKCJzdGRvdXQiLCBTVERPVVQsIFVO UkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdPUkQoInN0b3JhZ2UiLCBTVE9S QUdFLCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJzdG9yZWQi LCBTVE9SRUQsIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdPUkQoInN0 cmljdCIsIFNUUklDVF9QLCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCitQR19LRVlX T1JEKCJzdHJpbmciLCBTVFJJTkdfUCwgVU5SRVNFUlZFRF9LRVlXT1JELCBCQVJFX0xBQkVMKQog UEdfS0VZV09SRCgic3RyaXAiLCBTVFJJUF9QLCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFC RUwpCiBQR19LRVlXT1JEKCJzdWJzY3JpcHRpb24iLCBTVUJTQ1JJUFRJT04sIFVOUkVTRVJWRURf S0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdPUkQoInN1YnN0cmluZyIsIFNVQlNUUklORywg Q09MX05BTUVfS0VZV09SRCwgQkFSRV9MQUJFTCkKQEAgLTQ0OSw2ICs0NTksNyBAQCBQR19LRVlX T1JEKCJ0eXBlcyIsIFRZUEVTX1AsIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBH X0tFWVdPUkQoInVlc2NhcGUiLCBVRVNDQVBFLCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFC RUwpCiBQR19LRVlXT1JEKCJ1bmJvdW5kZWQiLCBVTkJPVU5ERUQsIFVOUkVTRVJWRURfS0VZV09S RCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdPUkQoInVuY29tbWl0dGVkIiwgVU5DT01NSVRURUQsIFVO UkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKK1BHX0tFWVdPUkQoInVuY29uZGl0aW9uYWwi LCBVTkNPTkRJVElPTkFMLCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlX T1JEKCJ1bmVuY3J5cHRlZCIsIFVORU5DUllQVEVELCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVf TEFCRUwpCiBQR19LRVlXT1JEKCJ1bmlvbiIsIFVOSU9OLCBSRVNFUlZFRF9LRVlXT1JELCBBU19M QUJFTCkKIFBHX0tFWVdPUkQoInVuaXF1ZSIsIFVOSVFVRSwgUkVTRVJWRURfS0VZV09SRCwgQkFS RV9MQUJFTCkKZGlmZiAtLWdpdCBhL3NyYy9pbnRlcmZhY2VzL2VjcGcvcHJlcHJvYy9lY3BnLnRy YWlsZXIgYi9zcmMvaW50ZXJmYWNlcy9lY3BnL3ByZXByb2MvZWNwZy50cmFpbGVyCmluZGV4IDQz NWMxMzllYzIuLmIyYWE0NGYzNmQgMTAwNjQ0Ci0tLSBhL3NyYy9pbnRlcmZhY2VzL2VjcGcvcHJl cHJvYy9lY3BnLnRyYWlsZXIKKysrIGIvc3JjL2ludGVyZmFjZXMvZWNwZy9wcmVwcm9jL2VjcGcu dHJhaWxlcgpAQCAtNjUxLDYgKzY1MSwzNCBAQCB2YXJfdHlwZToJc2ltcGxlX3R5cGUKIAkJCSQk LnR5cGVfaW5kZXggPSBtbV9zdHJkdXAoIi0xIik7CiAJCQkkJC50eXBlX3NpemVvZiA9IE5VTEw7 CiAJCX0KKwkJfCBTVFJJTkdfUAorCQl7CisJCQlpZiAoSU5GT1JNSVhfTU9ERSkKKwkJCXsKKwkJ CQkvKiBJbiBJbmZvcm1peCBtb2RlLCAic3RyaW5nIiBpcyBhdXRvbWF0aWNhbGx5IGEgdHlwZWRl ZiAqLworCQkJCSQkLnR5cGVfZW51bSA9IEVDUEd0X3N0cmluZzsKKwkJCQkkJC50eXBlX3N0ciA9 IG1tX3N0cmR1cCgiY2hhciIpOworCQkJCSQkLnR5cGVfZGltZW5zaW9uID0gbW1fc3RyZHVwKCIt MSIpOworCQkJCSQkLnR5cGVfaW5kZXggPSBtbV9zdHJkdXAoIi0xIik7CisJCQkJJCQudHlwZV9z aXplb2YgPSBOVUxMOworCQkJfQorCQkJZWxzZQorCQkJeworCQkJCS8qIE90aGVyd2lzZSwgbGVn YWwgb25seSBpZiB1c2VyIHR5cGVkZWYnZWQgaXQgKi8KKwkJCQlzdHJ1Y3QgdHlwZWRlZnMgKnRo aXMgPSBnZXRfdHlwZWRlZigic3RyaW5nIiwgZmFsc2UpOworCisJCQkJJCQudHlwZV9zdHIgPSAo dGhpcy0+dHlwZS0+dHlwZV9lbnVtID09IEVDUEd0X3ZhcmNoYXIgfHwgdGhpcy0+dHlwZS0+dHlw ZV9lbnVtID09IEVDUEd0X2J5dGVhKSA/IEVNUFRZIDogbW1fc3RyZHVwKHRoaXMtPm5hbWUpOwor CQkJCSQkLnR5cGVfZW51bSA9IHRoaXMtPnR5cGUtPnR5cGVfZW51bTsKKwkJCQkkJC50eXBlX2Rp bWVuc2lvbiA9IHRoaXMtPnR5cGUtPnR5cGVfZGltZW5zaW9uOworCQkJCSQkLnR5cGVfaW5kZXgg PSB0aGlzLT50eXBlLT50eXBlX2luZGV4OworCQkJCWlmICh0aGlzLT50eXBlLT50eXBlX3NpemVv ZiAmJiBzdHJsZW4odGhpcy0+dHlwZS0+dHlwZV9zaXplb2YpICE9IDApCisJCQkJCSQkLnR5cGVf c2l6ZW9mID0gdGhpcy0+dHlwZS0+dHlwZV9zaXplb2Y7CisJCQkJZWxzZQorCQkJCQkkJC50eXBl X3NpemVvZiA9IGNhdF9zdHIoMywgbW1fc3RyZHVwKCJzaXplb2YoIiksIG1tX3N0cmR1cCh0aGlz LT5uYW1lKSwgbW1fc3RyZHVwKCIpIikpOworCisJCQkJc3RydWN0X21lbWJlcl9saXN0W3N0cnVj dF9sZXZlbF0gPSBFQ1BHc3RydWN0X21lbWJlcl9kdXAodGhpcy0+c3RydWN0X21lbWJlcl9saXN0 KTsKKwkJCX0KKwkJfQogCQl8IElOVEVSVkFMIGVjcGdfaW50ZXJ2YWwKIAkJewogCQkJJCQudHlw ZV9lbnVtID0gRUNQR3RfaW50ZXJ2YWw7CmRpZmYgLS1naXQgYS9zcmMvdGVzdC9yZWdyZXNzL2V4 cGVjdGVkL2pzb25fc3FsanNvbi5vdXQgYi9zcmMvdGVzdC9yZWdyZXNzL2V4cGVjdGVkL2pzb25f c3FsanNvbi5vdXQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMC4uMDRkNWNj NzRlMwotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvanNvbl9z cWxqc29uLm91dApAQCAtMCwwICsxLDE4IEBACistLSBKU09OX0VYSVNUUworU0VMRUNUIEpTT05f RVhJU1RTKE5VTEwgRk9STUFUIEpTT04sICckJyk7CitFUlJPUjogIEpTT05fRVhJU1RTKCkgaXMg bm90IHlldCBpbXBsZW1lbnRlZCBmb3IgdGhlIGpzb24gdHlwZQorTElORSAxOiBTRUxFQ1QgSlNP Tl9FWElTVFMoTlVMTCBGT1JNQVQgSlNPTiwgJyQnKTsKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgIF4KK0hJTlQ6ICBUcnkgY2FzdGluZyB0aGUgYXJndW1lbnQgdG8ganNvbmIKKy0tIEpTT05f VkFMVUUKK1NFTEVDVCBKU09OX1ZBTFVFKE5VTEwgRk9STUFUIEpTT04sICckJyk7CitFUlJPUjog IEpTT05fVkFMVUUoKSBpcyBub3QgeWV0IGltcGxlbWVudGVkIGZvciB0aGUganNvbiB0eXBlCitM SU5FIDE6IFNFTEVDVCBKU09OX1ZBTFVFKE5VTEwgRk9STUFUIEpTT04sICckJyk7CisgICAgICAg ICAgICAgICAgICAgICAgICAgIF4KK0hJTlQ6ICBUcnkgY2FzdGluZyB0aGUgYXJndW1lbnQgdG8g anNvbmIKKy0tIEpTT05fUVVFUlkKK1NFTEVDVCBKU09OX1FVRVJZKE5VTEwgRk9STUFUIEpTT04s ICckJyk7CitFUlJPUjogIEpTT05fUVVFUlkoKSBpcyBub3QgeWV0IGltcGxlbWVudGVkIGZvciB0 aGUganNvbiB0eXBlCitMSU5FIDE6IFNFTEVDVCBKU09OX1FVRVJZKE5VTEwgRk9STUFUIEpTT04s ICckJyk7CisgICAgICAgICAgICAgICAgICAgICAgICAgIF4KK0hJTlQ6ICBUcnkgY2FzdGluZyB0 aGUgYXJndW1lbnQgdG8ganNvbmIKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0 ZWQvanNvbmJfc3FsanNvbi5vdXQgYi9zcmMvdGVzdC9yZWdyZXNzL2V4cGVjdGVkL2pzb25iX3Nx bGpzb24ub3V0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAuLjk0YzFiNDMw ZmUKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdGVzdC9yZWdyZXNzL2V4cGVjdGVkL2pzb25iX3Nx bGpzb24ub3V0CkBAIC0wLDAgKzEsMTA3MyBAQAorLS0gSlNPTl9FWElTVFMKK1NFTEVDVCBKU09O X0VYSVNUUyhOVUxMOjpqc29uYiwgJyQnKTsKKyBqc29uX2V4aXN0cyAKKy0tLS0tLS0tLS0tLS0K KyAKKygxIHJvdykKKworU0VMRUNUIEpTT05fRVhJU1RTKGpzb25iICdbXScsICckJyk7CisganNv bl9leGlzdHMgCistLS0tLS0tLS0tLS0tCisgdAorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9FWElT VFMoSlNPTl9PQkpFQ1QoUkVUVVJOSU5HIGpzb25iKSwgJyQnKTsKKyBqc29uX2V4aXN0cyAKKy0t LS0tLS0tLS0tLS0KKyB0CisoMSByb3cpCisKK1NFTEVDVCBKU09OX0VYSVNUUyhqc29uYiAnMScs ICckJyk7CisganNvbl9leGlzdHMgCistLS0tLS0tLS0tLS0tCisgdAorKDEgcm93KQorCitTRUxF Q1QgSlNPTl9FWElTVFMoanNvbmIgJ251bGwnLCAnJCcpOworIGpzb25fZXhpc3RzIAorLS0tLS0t LS0tLS0tLQorIHQKKygxIHJvdykKKworU0VMRUNUIEpTT05fRVhJU1RTKGpzb25iICdbXScsICck Jyk7CisganNvbl9leGlzdHMgCistLS0tLS0tLS0tLS0tCisgdAorKDEgcm93KQorCitTRUxFQ1Qg SlNPTl9FWElTVFMoanNvbmIgJzEnLCAnJC5hJyk7CisganNvbl9leGlzdHMgCistLS0tLS0tLS0t LS0tCisgZgorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9FWElTVFMoanNvbmIgJzEnLCAnc3RyaWN0 ICQuYScpOyAtLSBGQUxTRSBvbiBlcnJvcgorIGpzb25fZXhpc3RzIAorLS0tLS0tLS0tLS0tLQor IGYKKygxIHJvdykKKworU0VMRUNUIEpTT05fRVhJU1RTKGpzb25iICcxJywgJ3N0cmljdCAkLmEn IEVSUk9SIE9OIEVSUk9SKTsKK0VSUk9SOiAganNvbnBhdGggbWVtYmVyIGFjY2Vzc29yIGNhbiBv bmx5IGJlIGFwcGxpZWQgdG8gYW4gb2JqZWN0CitTRUxFQ1QgSlNPTl9FWElTVFMoanNvbmIgJ251 bGwnLCAnJC5hJyk7CisganNvbl9leGlzdHMgCistLS0tLS0tLS0tLS0tCisgZgorKDEgcm93KQor CitTRUxFQ1QgSlNPTl9FWElTVFMoanNvbmIgJ1tdJywgJyQuYScpOworIGpzb25fZXhpc3RzIAor LS0tLS0tLS0tLS0tLQorIGYKKygxIHJvdykKKworU0VMRUNUIEpTT05fRVhJU1RTKGpzb25iICdb MSwgImFhYSIsIHsiYSI6IDF9XScsICdzdHJpY3QgJC5hJyk7IC0tIEZBTFNFIG9uIGVycm9yCisg anNvbl9leGlzdHMgCistLS0tLS0tLS0tLS0tCisgZgorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9F WElTVFMoanNvbmIgJ1sxLCAiYWFhIiwgeyJhIjogMX1dJywgJ2xheCAkLmEnKTsKKyBqc29uX2V4 aXN0cyAKKy0tLS0tLS0tLS0tLS0KKyB0CisoMSByb3cpCisKK1NFTEVDVCBKU09OX0VYSVNUUyhq c29uYiAne30nLCAnJC5hJyk7CisganNvbl9leGlzdHMgCistLS0tLS0tLS0tLS0tCisgZgorKDEg cm93KQorCitTRUxFQ1QgSlNPTl9FWElTVFMoanNvbmIgJ3siYiI6IDEsICJhIjogMn0nLCAnJC5h Jyk7CisganNvbl9leGlzdHMgCistLS0tLS0tLS0tLS0tCisgdAorKDEgcm93KQorCitTRUxFQ1Qg SlNPTl9FWElTVFMoanNvbmIgJzEnLCAnJC5hLmInKTsKKyBqc29uX2V4aXN0cyAKKy0tLS0tLS0t LS0tLS0KKyBmCisoMSByb3cpCisKK1NFTEVDVCBKU09OX0VYSVNUUyhqc29uYiAneyJhIjogeyJi IjogMX19JywgJyQuYS5iJyk7CisganNvbl9leGlzdHMgCistLS0tLS0tLS0tLS0tCisgdAorKDEg cm93KQorCitTRUxFQ1QgSlNPTl9FWElTVFMoanNvbmIgJ3siYSI6IDEsICJiIjogMn0nLCAnJC5h LmInKTsKKyBqc29uX2V4aXN0cyAKKy0tLS0tLS0tLS0tLS0KKyBmCisoMSByb3cpCisKK1NFTEVD VCBKU09OX0VYSVNUUyhqc29uYiAneyJhIjogMSwgImIiOiAyfScsICckLiogPyAoQCA+ICR4KScg UEFTU0lORyAxIEFTIHgpOworIGpzb25fZXhpc3RzIAorLS0tLS0tLS0tLS0tLQorIHQKKygxIHJv dykKKworU0VMRUNUIEpTT05fRVhJU1RTKGpzb25iICd7ImEiOiAxLCAiYiI6IDJ9JywgJyQuKiA/ IChAID4gJHgpJyBQQVNTSU5HICcxJyBBUyB4KTsKKyBqc29uX2V4aXN0cyAKKy0tLS0tLS0tLS0t LS0KKyBmCisoMSByb3cpCisKK1NFTEVDVCBKU09OX0VYSVNUUyhqc29uYiAneyJhIjogMSwgImIi OiAyfScsICckLiogPyAoQCA+ICR4ICYmIEAgPCAkeSknIFBBU1NJTkcgMCBBUyB4LCAyIEFTIHkp OworIGpzb25fZXhpc3RzIAorLS0tLS0tLS0tLS0tLQorIHQKKygxIHJvdykKKworU0VMRUNUIEpT T05fRVhJU1RTKGpzb25iICd7ImEiOiAxLCAiYiI6IDJ9JywgJyQuKiA/IChAID4gJHggJiYgQCA8 ICR5KScgUEFTU0lORyAwIEFTIHgsIDEgQVMgeSk7CisganNvbl9leGlzdHMgCistLS0tLS0tLS0t LS0tCisgZgorKDEgcm93KQorCistLSBleHRlbnNpb246IGJvb2xlYW4gZXhwcmVzc2lvbnMKK1NF TEVDVCBKU09OX0VYSVNUUyhqc29uYiAnMScsICckID4gMicpOworIGpzb25fZXhpc3RzIAorLS0t LS0tLS0tLS0tLQorIHQKKygxIHJvdykKKworU0VMRUNUIEpTT05fRVhJU1RTKGpzb25iICcxJywg JyQuYSA+IDInIEVSUk9SIE9OIEVSUk9SKTsKKyBqc29uX2V4aXN0cyAKKy0tLS0tLS0tLS0tLS0K KyB0CisoMSByb3cpCisKKy0tIEpTT05fVkFMVUUKK1NFTEVDVCBKU09OX1ZBTFVFKE5VTEw6Ompz b25iLCAnJCcpOworIGpzb25fdmFsdWUgCistLS0tLS0tLS0tLS0KKyAKKygxIHJvdykKKworU0VM RUNUIEpTT05fVkFMVUUoanNvbmIgJ251bGwnLCAnJCcpOworIGpzb25fdmFsdWUgCistLS0tLS0t LS0tLS0KKyAKKygxIHJvdykKKworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJ251bGwnLCAnJCcg UkVUVVJOSU5HIGludCk7CisganNvbl92YWx1ZSAKKy0tLS0tLS0tLS0tLQorICAgICAgICAgICAK KygxIHJvdykKKworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJ3RydWUnLCAnJCcpOworIGpzb25f dmFsdWUgCistLS0tLS0tLS0tLS0KKyB0cnVlCisoMSByb3cpCisKK1NFTEVDVCBKU09OX1ZBTFVF KGpzb25iICd0cnVlJywgJyQnIFJFVFVSTklORyBib29sKTsKKyBqc29uX3ZhbHVlIAorLS0tLS0t LS0tLS0tCisgdAorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnMTIzJywgJyQn KTsKKyBqc29uX3ZhbHVlIAorLS0tLS0tLS0tLS0tCisgMTIzCisoMSByb3cpCisKK1NFTEVDVCBK U09OX1ZBTFVFKGpzb25iICcxMjMnLCAnJCcgUkVUVVJOSU5HIGludCkgKyAyMzQ7CisgP2NvbHVt bj8gCistLS0tLS0tLS0tCisgICAgICAzNTcKKygxIHJvdykKKworU0VMRUNUIEpTT05fVkFMVUUo anNvbmIgJzEyMycsICckJyBSRVRVUk5JTkcgdGV4dCk7CisganNvbl92YWx1ZSAKKy0tLS0tLS0t LS0tLQorIDEyMworKDEgcm93KQorCisvKiBqc29uYiBieXRlYSA/Pz8gKi8KK1NFTEVDVCBKU09O X1ZBTFVFKGpzb25iICcxMjMnLCAnJCcgUkVUVVJOSU5HIGJ5dGVhIEVSUk9SIE9OIEVSUk9SKTsK K0VSUk9SOiAgU1FML0pTT04gaXRlbSBjYW5ub3QgYmUgY2FzdCB0byB0YXJnZXQgdHlwZQorU0VM RUNUIEpTT05fVkFMVUUoanNvbmIgJzEuMjMnLCAnJCcpOworIGpzb25fdmFsdWUgCistLS0tLS0t LS0tLS0KKyAxLjIzCisoMSByb3cpCisKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICcxLjIzJywg JyQnIFJFVFVSTklORyBpbnQpOworIGpzb25fdmFsdWUgCistLS0tLS0tLS0tLS0KKyAgICAgICAg ICAxCisoMSByb3cpCisKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICciMS4yMyInLCAnJCcgUkVU VVJOSU5HIG51bWVyaWMpOworIGpzb25fdmFsdWUgCistLS0tLS0tLS0tLS0KKyAgICAgICAxLjIz CisoMSByb3cpCisKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICciMS4yMyInLCAnJCcgUkVUVVJO SU5HIGludCBFUlJPUiBPTiBFUlJPUik7CitFUlJPUjogIGludmFsaWQgaW5wdXQgc3ludGF4IGZv ciB0eXBlIGludGVnZXI6ICIxLjIzIgorU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJyJhYWEiJywg JyQnKTsKKyBqc29uX3ZhbHVlIAorLS0tLS0tLS0tLS0tCisgYWFhCisoMSByb3cpCisKK1NFTEVD VCBKU09OX1ZBTFVFKGpzb25iICciYWFhIicsICckJyBSRVRVUk5JTkcgdGV4dCk7CisganNvbl92 YWx1ZSAKKy0tLS0tLS0tLS0tLQorIGFhYQorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9WQUxVRShq c29uYiAnImFhYSInLCAnJCcgUkVUVVJOSU5HIGNoYXIoNSkpOworIGpzb25fdmFsdWUgCistLS0t LS0tLS0tLS0KKyBhYWEgIAorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnImFh YSInLCAnJCcgUkVUVVJOSU5HIGNoYXIoMikpOworIGpzb25fdmFsdWUgCistLS0tLS0tLS0tLS0K KyBhYQorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnImFhYSInLCAnJCcgUkVU VVJOSU5HIGpzb24pOworIGpzb25fdmFsdWUgCistLS0tLS0tLS0tLS0KKyAiYWFhIgorKDEgcm93 KQorCitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnImFhYSInLCAnJCcgUkVUVVJOSU5HIGpzb25i KTsKKyBqc29uX3ZhbHVlIAorLS0tLS0tLS0tLS0tCisgImFhYSIKKygxIHJvdykKKworU0VMRUNU IEpTT05fVkFMVUUoanNvbmIgJyJhYWEiJywgJyQnIFJFVFVSTklORyBqc29uIEVSUk9SIE9OIEVS Uk9SKTsKKyBqc29uX3ZhbHVlIAorLS0tLS0tLS0tLS0tCisgImFhYSIKKygxIHJvdykKKworU0VM RUNUIEpTT05fVkFMVUUoanNvbmIgJyJhYWEiJywgJyQnIFJFVFVSTklORyBqc29uYiBFUlJPUiBP TiBFUlJPUik7CisganNvbl92YWx1ZSAKKy0tLS0tLS0tLS0tLQorICJhYWEiCisoMSByb3cpCisK K1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICciXCJhYWFcIiInLCAnJCcgUkVUVVJOSU5HIGpzb24p OworIGpzb25fdmFsdWUgCistLS0tLS0tLS0tLS0KKyAiXCJhYWFcIiIKKygxIHJvdykKKworU0VM RUNUIEpTT05fVkFMVUUoanNvbmIgJyJcImFhYVwiIicsICckJyBSRVRVUk5JTkcganNvbmIpOwor IGpzb25fdmFsdWUgCistLS0tLS0tLS0tLS0KKyAiXCJhYWFcIiIKKygxIHJvdykKKworU0VMRUNU IEpTT05fVkFMVUUoanNvbmIgJyJhYWEiJywgJyQnIFJFVFVSTklORyBpbnQpOworIGpzb25fdmFs dWUgCistLS0tLS0tLS0tLS0KKyAgICAgICAgICAgCisoMSByb3cpCisKK1NFTEVDVCBKU09OX1ZB TFVFKGpzb25iICciYWFhIicsICckJyBSRVRVUk5JTkcgaW50IEVSUk9SIE9OIEVSUk9SKTsKK0VS Uk9SOiAgaW52YWxpZCBpbnB1dCBzeW50YXggZm9yIHR5cGUgaW50ZWdlcjogImFhYSIKK1NFTEVD VCBKU09OX1ZBTFVFKGpzb25iICciYWFhIicsICckJyBSRVRVUk5JTkcgaW50IERFRkFVTFQgMTEx IE9OIEVSUk9SKTsKKyBqc29uX3ZhbHVlIAorLS0tLS0tLS0tLS0tCisgICAgICAgIDExMQorKDEg cm93KQorCitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnIjEyMyInLCAnJCcgUkVUVVJOSU5HIGlu dCkgKyAyMzQ7CisgP2NvbHVtbj8gCistLS0tLS0tLS0tCisgICAgICAzNTcKKygxIHJvdykKKwor U0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJyIyMDE3LTAyLTIwIicsICckJyBSRVRVUk5JTkcgZGF0 ZSkgKyA5OworICA/Y29sdW1uPyAgCistLS0tLS0tLS0tLS0KKyAwMy0wMS0yMDE3CisoMSByb3cp CisKKy0tIFRlc3QgTlVMTCBjaGVja3MgZXhlY3V0aW9uIGluIGRvbWFpbiB0eXBlcworQ1JFQVRF IERPTUFJTiBzcWxqc29uYl9pbnRfbm90X251bGwgQVMgaW50IE5PVCBOVUxMOworU0VMRUNUIEpT T05fVkFMVUUoanNvbmIgJ251bGwnLCAnJCcgUkVUVVJOSU5HIHNxbGpzb25iX2ludF9ub3RfbnVs bCk7CitFUlJPUjogIGRvbWFpbiBzcWxqc29uYl9pbnRfbm90X251bGwgZG9lcyBub3QgYWxsb3cg bnVsbCB2YWx1ZXMKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICdudWxsJywgJyQnIFJFVFVSTklO RyBzcWxqc29uYl9pbnRfbm90X251bGwgRVJST1IgT04gRVJST1IpOworRVJST1I6ICBkb21haW4g c3FsanNvbmJfaW50X25vdF9udWxsIGRvZXMgbm90IGFsbG93IG51bGwgdmFsdWVzCitTRUxFQ1Qg SlNPTl9WQUxVRShqc29uYiAnbnVsbCcsICckJyBSRVRVUk5JTkcgc3FsanNvbmJfaW50X25vdF9u dWxsIERFRkFVTFQgMiBPTiBFTVBUWSBFUlJPUiBPTiBFUlJPUik7CitFUlJPUjogIGRvbWFpbiBz cWxqc29uYl9pbnRfbm90X251bGwgZG9lcyBub3QgYWxsb3cgbnVsbCB2YWx1ZXMKK1NFTEVDVCBK U09OX1ZBTFVFKGpzb25iICcxJywgICckLmEnIFJFVFVSTklORyBzcWxqc29uYl9pbnRfbm90X251 bGwgREVGQVVMVCAyIE9OIEVNUFRZIEVSUk9SIE9OIEVSUk9SKTsKKyBqc29uX3ZhbHVlIAorLS0t LS0tLS0tLS0tCisgICAgICAgICAgMgorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9WQUxVRShqc29u YiAnMScsICAnJC5hJyBSRVRVUk5JTkcgc3FsanNvbmJfaW50X25vdF9udWxsIERFRkFVTFQgTlVM TCBPTiBFTVBUWSBFUlJPUiBPTiBFUlJPUik7CitFUlJPUjogIGRvbWFpbiBzcWxqc29uYl9pbnRf bm90X251bGwgZG9lcyBub3QgYWxsb3cgbnVsbCB2YWx1ZXMKK0NSRUFURSBUWVBFIHJhaW5ib3cg QVMgRU5VTSAoJ3JlZCcsICdvcmFuZ2UnLCAneWVsbG93JywgJ2dyZWVuJywgJ2JsdWUnLCAncHVy cGxlJyk7CitDUkVBVEUgRE9NQUlOIHJnYiBBUyByYWluYm93IENIRUNLIChWQUxVRSBJTiAoJ3Jl ZCcsICdncmVlbicsICdibHVlJykpOworU0VMRUNUIEpTT05fVkFMVUUoJyJwdXJwbGUiJzo6anNv bmIsICdsYXggJFsqXScgUkVUVVJOSU5HIHJnYik7CisganNvbl92YWx1ZSAKKy0tLS0tLS0tLS0t LQorIAorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9WQUxVRSgnInB1cnBsZSInOjpqc29uYiwgJ2xh eCAkWypdJyBSRVRVUk5JTkcgcmdiIEVSUk9SIE9OIEVSUk9SKTsKK0VSUk9SOiAgdmFsdWUgZm9y IGRvbWFpbiByZ2IgdmlvbGF0ZXMgY2hlY2sgY29uc3RyYWludCAicmdiX2NoZWNrIgorU0VMRUNU IEpTT05fVkFMVUUoanNvbmIgJ1tdJywgJyQnKTsKKyBqc29uX3ZhbHVlIAorLS0tLS0tLS0tLS0t CisgCisoMSByb3cpCisKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICdbXScsICckJyBFUlJPUiBP TiBFUlJPUik7CitFUlJPUjogIEpTT04gcGF0aCBleHByZXNzaW9uIGluIEpTT05fVkFMVUUgc2hv dWxkIHJldHVybiBzaW5nbGV0b24gc2NhbGFyIGl0ZW0KK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25i ICd7fScsICckJyk7CisganNvbl92YWx1ZSAKKy0tLS0tLS0tLS0tLQorIAorKDEgcm93KQorCitT RUxFQ1QgSlNPTl9WQUxVRShqc29uYiAne30nLCAnJCcgRVJST1IgT04gRVJST1IpOworRVJST1I6 ICBKU09OIHBhdGggZXhwcmVzc2lvbiBpbiBKU09OX1ZBTFVFIHNob3VsZCByZXR1cm4gc2luZ2xl dG9uIHNjYWxhciBpdGVtCitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnMScsICckLmEnKTsKKyBq c29uX3ZhbHVlIAorLS0tLS0tLS0tLS0tCisgCisoMSByb3cpCisKK1NFTEVDVCBKU09OX1ZBTFVF KGpzb25iICcxJywgJ3N0cmljdCAkLmEnIEVSUk9SIE9OIEVSUk9SKTsKK0VSUk9SOiAganNvbnBh dGggbWVtYmVyIGFjY2Vzc29yIGNhbiBvbmx5IGJlIGFwcGxpZWQgdG8gYW4gb2JqZWN0CitTRUxF Q1QgSlNPTl9WQUxVRShqc29uYiAnMScsICdzdHJpY3QgJC5hJyBERUZBVUxUICdlcnJvcicgT04g RVJST1IpOworIGpzb25fdmFsdWUgCistLS0tLS0tLS0tLS0KKyBlcnJvcgorKDEgcm93KQorCitT RUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnMScsICdsYXggJC5hJyBFUlJPUiBPTiBFUlJPUik7CitF UlJPUjogIG5vIFNRTC9KU09OIGl0ZW0KK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICcxJywgJ2xh eCAkLmEnIEVSUk9SIE9OIEVNUFRZIEVSUk9SIE9OIEVSUk9SKTsKK0VSUk9SOiAgbm8gU1FML0pT T04gaXRlbQorU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJzEnLCAnc3RyaWN0ICQuYScgREVGQVVM VCAyIE9OIEVSUk9SKTsKKyBqc29uX3ZhbHVlIAorLS0tLS0tLS0tLS0tCisgMgorKDEgcm93KQor CitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnMScsICdsYXggJC5hJyBERUZBVUxUIDIgT04gRVJS T1IpOworIGpzb25fdmFsdWUgCistLS0tLS0tLS0tLS0KKyAyCisoMSByb3cpCisKK1NFTEVDVCBK U09OX1ZBTFVFKGpzb25iICcxJywgJ2xheCAkLmEnIERFRkFVTFQgJzInIE9OIEVSUk9SKTsKKyBq c29uX3ZhbHVlIAorLS0tLS0tLS0tLS0tCisgMgorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9WQUxV RShqc29uYiAnMScsICdsYXggJC5hJyBOVUxMIE9OIEVNUFRZIERFRkFVTFQgJzInIE9OIEVSUk9S KTsKKyBqc29uX3ZhbHVlIAorLS0tLS0tLS0tLS0tCisgCisoMSByb3cpCisKK1NFTEVDVCBKU09O X1ZBTFVFKGpzb25iICcxJywgJ2xheCAkLmEnIERFRkFVTFQgJzInIE9OIEVNUFRZIERFRkFVTFQg JzMnIE9OIEVSUk9SKTsKKyBqc29uX3ZhbHVlIAorLS0tLS0tLS0tLS0tCisgMgorKDEgcm93KQor CitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnMScsICdsYXggJC5hJyBFUlJPUiBPTiBFTVBUWSBE RUZBVUxUICczJyBPTiBFUlJPUik7CitFUlJPUjogIG5vIFNRTC9KU09OIGl0ZW0KK1NFTEVDVCBK U09OX1ZBTFVFKGpzb25iICdbMSwyXScsICckWypdJyBFUlJPUiBPTiBFUlJPUik7CitFUlJPUjog IEpTT04gcGF0aCBleHByZXNzaW9uIGluIEpTT05fVkFMVUUgc2hvdWxkIHJldHVybiBzaW5nbGV0 b24gc2NhbGFyIGl0ZW0KK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICdbMSwyXScsICckWypdJyBE RUZBVUxUICcwJyBPTiBFUlJPUik7CisganNvbl92YWx1ZSAKKy0tLS0tLS0tLS0tLQorIDAKKygx IHJvdykKKworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJ1siICJdJywgJyRbKl0nIFJFVFVSTklO RyBpbnQgRVJST1IgT04gRVJST1IpOworRVJST1I6ICBpbnZhbGlkIGlucHV0IHN5bnRheCBmb3Ig dHlwZSBpbnRlZ2VyOiAiICIKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICdbIiAiXScsICckWypd JyBSRVRVUk5JTkcgaW50IERFRkFVTFQgMiArIDMgT04gRVJST1IpOworIGpzb25fdmFsdWUgCist LS0tLS0tLS0tLS0KKyAgICAgICAgICA1CisoMSByb3cpCisKK1NFTEVDVCBKU09OX1ZBTFVFKGpz b25iICdbIjEiXScsICckWypdJyBSRVRVUk5JTkcgaW50IERFRkFVTFQgMiArIDMgT04gRVJST1Ip OworIGpzb25fdmFsdWUgCistLS0tLS0tLS0tLS0KKyAgICAgICAgICAxCisoMSByb3cpCisKK1NF TEVDVCBKU09OX1ZBTFVFKGpzb25iICdbIjEiXScsICckWypdJyBSRVRVUk5JTkcgaW50IEZPUk1B VCBKU09OKTsgLS0gUkVUVVJOSU5HIEZPUk1BVCBub3QgYWxsb3dlZAorRVJST1I6ICBjYW5ub3Qg c3BlY2lmeSBGT1JNQVQgaW4gUkVUVVJOSU5HIGNsYXVzZSBvZiBKU09OX1ZBTFVFKCkKK0xJTkUg MTogLi4uQ1QgSlNPTl9WQUxVRShqc29uYiAnWyIxIl0nLCAnJFsqXScgUkVUVVJOSU5HIGludCBG T1JNQVQgSlNPLi4uCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgXgorLS0gUkVUVUdOSU5HIHBzZXVkby10eXBlcyBub3QgYWxsb3dl ZAorU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJ1siMSJdJywgJyRbKl0nIFJFVFVSTklORyByZWNv cmQpOworRVJST1I6ICByZXR1cm5pbmcgcHNldWRvLXR5cGVzIGlzIG5vdCBzdXBwb3J0ZWQgaW4g U1FML0pTT04gZnVuY3Rpb25zCitTRUxFQ1QKKwl4LAorCUpTT05fVkFMVUUoCisJCWpzb25iICd7 ImEiOiAxLCAiYiI6IDJ9JywKKwkJJyQuKiA/IChAID4gJHgpJyBQQVNTSU5HIHggQVMgeAorCQlS RVRVUk5JTkcgaW50CisJCURFRkFVTFQgLTEgT04gRU1QVFkKKwkJREVGQVVMVCAtMiBPTiBFUlJP UgorCSkgeQorRlJPTQorCWdlbmVyYXRlX3NlcmllcygwLCAyKSB4OworIHggfCB5ICAKKy0tLSst LS0tCisgMCB8IC0yCisgMSB8ICAyCisgMiB8IC0xCisoMyByb3dzKQorCitTRUxFQ1QgSlNPTl9W QUxVRShqc29uYiAnbnVsbCcsICckYScgUEFTU0lORyBwb2ludCAnICgxLCAyICknIEFTIGEpOwor IGpzb25fdmFsdWUgCistLS0tLS0tLS0tLS0KKyAoMSwyKQorKDEgcm93KQorCitTRUxFQ1QgSlNP Tl9WQUxVRShqc29uYiAnbnVsbCcsICckYScgUEFTU0lORyBwb2ludCAnICgxLCAyICknIEFTIGEg UkVUVVJOSU5HIHBvaW50KTsKKyBqc29uX3ZhbHVlIAorLS0tLS0tLS0tLS0tCisgKDEsMikKKygx IHJvdykKKworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJ251bGwnLCAnJGEnIFBBU1NJTkcgcG9p bnQgJyAoMSwgMiApJyBBUyBhIFJFVFVSTklORyBwb2ludCBFUlJPUiBPTiBFUlJPUik7CisganNv bl92YWx1ZSAKKy0tLS0tLS0tLS0tLQorICgxLDIpCisoMSByb3cpCisKKy0tIFRlc3QgUEFTU0lO RyBhbmQgUkVUVVJOSU5HIGRhdGUvdGltZSB0eXBlcworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIg J251bGwnLCAnJHRzJyBQQVNTSU5HIHRpbWVzdGFtcHR6ICcyMDE4LTAyLTIxIDEyOjM0OjU2ICsx MCcgQVMgdHMpOworICAgICAgICAgIGpzb25fdmFsdWUgICAgICAgICAgCistLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KKyBUdWUgRmViIDIwIDE4OjM0OjU2IDIwMTggUFNUCisoMSByb3cp CisKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICdudWxsJywgJyR0cycgUEFTU0lORyB0aW1lc3Rh bXB0eiAnMjAxOC0wMi0yMSAxMjozNDo1NiArMTAnIEFTIHRzIFJFVFVSTklORyB0aW1lc3RhbXB0 eik7CisgICAgICAgICAganNvbl92YWx1ZSAgICAgICAgICAKKy0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLQorIFR1ZSBGZWIgMjAgMTg6MzQ6NTYgMjAxOCBQU1QKKygxIHJvdykKKworU0VM RUNUIEpTT05fVkFMVUUoanNvbmIgJ251bGwnLCAnJHRzJyBQQVNTSU5HIHRpbWVzdGFtcHR6ICcy MDE4LTAyLTIxIDEyOjM0OjU2ICsxMCcgQVMgdHMgUkVUVVJOSU5HIHRpbWVzdGFtcCk7CisgICAg ICAgIGpzb25fdmFsdWUgICAgICAgIAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyBUdWUg RmViIDIwIDE4OjM0OjU2IDIwMTgKKygxIHJvdykKKworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIg J251bGwnLCAnJHRzJyBQQVNTSU5HIGRhdGUgJzIwMTgtMDItMjEgMTI6MzQ6NTYgKzEwJyBBUyB0 cyBSRVRVUk5JTkcgZGF0ZSk7CisganNvbl92YWx1ZSAKKy0tLS0tLS0tLS0tLQorIDAyLTIxLTIw MTgKKygxIHJvdykKKworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJ251bGwnLCAnJHRzJyBQQVNT SU5HIHRpbWUgJzIwMTgtMDItMjEgMTI6MzQ6NTYgKzEwJyBBUyB0cyBSRVRVUk5JTkcgdGltZSk7 CisganNvbl92YWx1ZSAKKy0tLS0tLS0tLS0tLQorIDEyOjM0OjU2CisoMSByb3cpCisKK1NFTEVD VCBKU09OX1ZBTFVFKGpzb25iICdudWxsJywgJyR0cycgUEFTU0lORyB0aW1ldHogJzIwMTgtMDIt MjEgMTI6MzQ6NTYgKzEwJyBBUyB0cyBSRVRVUk5JTkcgdGltZXR6KTsKKyBqc29uX3ZhbHVlICAK Ky0tLS0tLS0tLS0tLS0KKyAxMjozNDo1NisxMAorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9WQUxV RShqc29uYiAnbnVsbCcsICckdHMnIFBBU1NJTkcgdGltZXN0YW1wICcyMDE4LTAyLTIxIDEyOjM0 OjU2ICsxMCcgQVMgdHMgUkVUVVJOSU5HIHRpbWVzdGFtcCk7CisgICAgICAgIGpzb25fdmFsdWUg ICAgICAgIAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyBXZWQgRmViIDIxIDEyOjM0OjU2 IDIwMTgKKygxIHJvdykKKworLS0gQWxzbyB0ZXN0IFJFVFVSTklORyBqc29uW2JdCitTRUxFQ1Qg SlNPTl9WQUxVRShqc29uYiAnbnVsbCcsICckdHMnIFBBU1NJTkcgdGltZXN0YW1wdHogJzIwMTgt MDItMjEgMTI6MzQ6NTYgKzEwJyBBUyB0cyBSRVRVUk5JTkcganNvbik7CisgICAgICAgICBqc29u X3ZhbHVlICAgICAgICAgIAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAiMjAxOC0w Mi0yMVQwMjozNDo1NiswMDowMCIKKygxIHJvdykKKworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIg J251bGwnLCAnJHRzJyBQQVNTSU5HIHRpbWVzdGFtcHR6ICcyMDE4LTAyLTIxIDEyOjM0OjU2ICsx MCcgQVMgdHMgUkVUVVJOSU5HIGpzb25iKTsKKyAgICAgICAgIGpzb25fdmFsdWUgICAgICAgICAg CistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICIyMDE4LTAyLTIxVDAyOjM0OjU2KzAw OjAwIgorKDEgcm93KQorCistLSBKU09OX1FVRVJZCitTRUxFQ1QKKwlKU09OX1FVRVJZKGpzLCAn JCcpLAorCUpTT05fUVVFUlkoanMsICckJyBXSVRIT1VUIFdSQVBQRVIpLAorCUpTT05fUVVFUlko anMsICckJyBXSVRIIENPTkRJVElPTkFMIFdSQVBQRVIpLAorCUpTT05fUVVFUlkoanMsICckJyBX SVRIIFVOQ09ORElUSU9OQUwgQVJSQVkgV1JBUFBFUiksCisJSlNPTl9RVUVSWShqcywgJyQnIFdJ VEggQVJSQVkgV1JBUFBFUikKK0ZST00KKwkoVkFMVUVTCisJCShqc29uYiAnbnVsbCcpLAorCQko JzEyLjMnKSwKKwkJKCd0cnVlJyksCisJCSgnImFhYSInKSwKKwkJKCdbMSwgbnVsbCwgIjIiXScp LAorCQkoJ3siYSI6IDEsICJiIjogWzJdfScpCisJKSBmb28oanMpOworICAgICBqc29uX3F1ZXJ5 ICAgICB8ICAgICBqc29uX3F1ZXJ5ICAgICB8ICAgICBqc29uX3F1ZXJ5ICAgICB8ICAgICAganNv bl9xdWVyeSAgICAgIHwgICAgICBqc29uX3F1ZXJ5ICAgICAgCistLS0tLS0tLS0tLS0tLS0tLS0t LSstLS0tLS0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0t LS0tLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyBudWxsICAgICAgICAgICAgICAgfCBu dWxsICAgICAgICAgICAgICAgfCBbbnVsbF0gICAgICAgICAgICAgfCBbbnVsbF0gICAgICAgICAg ICAgICB8IFtudWxsXQorIDEyLjMgICAgICAgICAgICAgICB8IDEyLjMgICAgICAgICAgICAgICB8 IFsxMi4zXSAgICAgICAgICAgICB8IFsxMi4zXSAgICAgICAgICAgICAgIHwgWzEyLjNdCisgdHJ1 ZSAgICAgICAgICAgICAgIHwgdHJ1ZSAgICAgICAgICAgICAgIHwgW3RydWVdICAgICAgICAgICAg IHwgW3RydWVdICAgICAgICAgICAgICAgfCBbdHJ1ZV0KKyAiYWFhIiAgICAgICAgICAgICAgfCAi YWFhIiAgICAgICAgICAgICAgfCBbImFhYSJdICAgICAgICAgICAgfCBbImFhYSJdICAgICAgICAg ICAgICB8IFsiYWFhIl0KKyBbMSwgbnVsbCwgIjIiXSAgICAgfCBbMSwgbnVsbCwgIjIiXSAgICAg fCBbMSwgbnVsbCwgIjIiXSAgICAgfCBbWzEsIG51bGwsICIyIl1dICAgICB8IFtbMSwgbnVsbCwg IjIiXV0KKyB7ImEiOiAxLCAiYiI6IFsyXX0gfCB7ImEiOiAxLCAiYiI6IFsyXX0gfCB7ImEiOiAx LCAiYiI6IFsyXX0gfCBbeyJhIjogMSwgImIiOiBbMl19XSB8IFt7ImEiOiAxLCAiYiI6IFsyXX1d CisoNiByb3dzKQorCitTRUxFQ1QKKwlKU09OX1FVRVJZKGpzLCAnc3RyaWN0ICRbKl0nKSBBUyAi dW5zcGVjIiwKKwlKU09OX1FVRVJZKGpzLCAnc3RyaWN0ICRbKl0nIFdJVEhPVVQgV1JBUFBFUikg QVMgIndpdGhvdXQiLAorCUpTT05fUVVFUlkoanMsICdzdHJpY3QgJFsqXScgV0lUSCBDT05ESVRJ T05BTCBXUkFQUEVSKSBBUyAid2l0aCBjb25kIiwKKwlKU09OX1FVRVJZKGpzLCAnc3RyaWN0ICRb Kl0nIFdJVEggVU5DT05ESVRJT05BTCBBUlJBWSBXUkFQUEVSKSBBUyAid2l0aCB1bmNvbmQiLAor CUpTT05fUVVFUlkoanMsICdzdHJpY3QgJFsqXScgV0lUSCBBUlJBWSBXUkFQUEVSKSBBUyAid2l0 aCIKK0ZST00KKwkoVkFMVUVTCisJCShqc29uYiAnMScpLAorCQkoJ1tdJyksCisJCSgnW251bGxd JyksCisJCSgnWzEyLjNdJyksCisJCSgnW3RydWVdJyksCisJCSgnWyJhYWEiXScpLAorCQkoJ1tb MSwgMiwgM11dJyksCisJCSgnW3siYSI6IDEsICJiIjogWzJdfV0nKSwKKwkJKCdbMSwgIjIiLCBu dWxsLCBbM11dJykKKwkpIGZvbyhqcyk7CisgICAgICAgdW5zcGVjICAgICAgIHwgICAgICB3aXRo b3V0ICAgICAgIHwgICAgICB3aXRoIGNvbmQgICAgICB8ICAgICB3aXRoIHVuY29uZCAgICAgIHwg ICAgICAgICB3aXRoICAgICAgICAgCistLS0tLS0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0t LS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSstLS0t LS0tLS0tLS0tLS0tLS0tLS0tCisgICAgICAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgICAg ICAgIHwgICAgICAgICAgICAgICAgICAgICB8ICAgICAgICAgICAgICAgICAgICAgIHwgCisgICAg ICAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgICAgICAg ICB8ICAgICAgICAgICAgICAgICAgICAgIHwgCisgbnVsbCAgICAgICAgICAgICAgIHwgbnVsbCAg ICAgICAgICAgICAgIHwgW251bGxdICAgICAgICAgICAgICB8IFtudWxsXSAgICAgICAgICAgICAg IHwgW251bGxdCisgMTIuMyAgICAgICAgICAgICAgIHwgMTIuMyAgICAgICAgICAgICAgIHwgWzEy LjNdICAgICAgICAgICAgICB8IFsxMi4zXSAgICAgICAgICAgICAgIHwgWzEyLjNdCisgdHJ1ZSAg ICAgICAgICAgICAgIHwgdHJ1ZSAgICAgICAgICAgICAgIHwgW3RydWVdICAgICAgICAgICAgICB8 IFt0cnVlXSAgICAgICAgICAgICAgIHwgW3RydWVdCisgImFhYSIgICAgICAgICAgICAgIHwgImFh YSIgICAgICAgICAgICAgIHwgWyJhYWEiXSAgICAgICAgICAgICB8IFsiYWFhIl0gICAgICAgICAg ICAgIHwgWyJhYWEiXQorIFsxLCAyLCAzXSAgICAgICAgICB8IFsxLCAyLCAzXSAgICAgICAgICB8 IFsxLCAyLCAzXSAgICAgICAgICAgfCBbWzEsIDIsIDNdXSAgICAgICAgICB8IFtbMSwgMiwgM11d CisgeyJhIjogMSwgImIiOiBbMl19IHwgeyJhIjogMSwgImIiOiBbMl19IHwgeyJhIjogMSwgImIi OiBbMl19ICB8IFt7ImEiOiAxLCAiYiI6IFsyXX1dIHwgW3siYSI6IDEsICJiIjogWzJdfV0KKyAg ICAgICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgICAgfCBbMSwgIjIiLCBudWxsLCBb M11dIHwgWzEsICIyIiwgbnVsbCwgWzNdXSAgfCBbMSwgIjIiLCBudWxsLCBbM11dCisoOSByb3dz KQorCitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnImFhYSInLCAnJCcgUkVUVVJOSU5HIHRleHQp OworIGpzb25fcXVlcnkgCistLS0tLS0tLS0tLS0KKyAiYWFhIgorKDEgcm93KQorCitTRUxFQ1Qg SlNPTl9RVUVSWShqc29uYiAnImFhYSInLCAnJCcgUkVUVVJOSU5HIHRleHQgS0VFUCBRVU9URVMp OworIGpzb25fcXVlcnkgCistLS0tLS0tLS0tLS0KKyAiYWFhIgorKDEgcm93KQorCitTRUxFQ1Qg SlNPTl9RVUVSWShqc29uYiAnImFhYSInLCAnJCcgUkVUVVJOSU5HIHRleHQgS0VFUCBRVU9URVMg T04gU0NBTEFSIFNUUklORyk7CisganNvbl9xdWVyeSAKKy0tLS0tLS0tLS0tLQorICJhYWEiCiso MSByb3cpCisKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICciYWFhIicsICckJyBSRVRVUk5JTkcg dGV4dCBPTUlUIFFVT1RFUyk7CisganNvbl9xdWVyeSAKKy0tLS0tLS0tLS0tLQorIGFhYQorKDEg cm93KQorCitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnImFhYSInLCAnJCcgUkVUVVJOSU5HIHRl eHQgT01JVCBRVU9URVMgT04gU0NBTEFSIFNUUklORyk7CisganNvbl9xdWVyeSAKKy0tLS0tLS0t LS0tLQorIGFhYQorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnImFhYSInLCAn JCcgT01JVCBRVU9URVMgRVJST1IgT04gRVJST1IpOworRVJST1I6ICBpbnZhbGlkIGlucHV0IHN5 bnRheCBmb3IgdHlwZSBqc29uCitERVRBSUw6ICBUb2tlbiAiYWFhIiBpcyBpbnZhbGlkLgorQ09O VEVYVDogIEpTT04gZGF0YSwgbGluZSAxOiBhYWEKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICci YWFhIicsICckJyBSRVRVUk5JTkcganNvbiBPTUlUIFFVT1RFUyBFUlJPUiBPTiBFUlJPUik7CitF UlJPUjogIGludmFsaWQgaW5wdXQgc3ludGF4IGZvciB0eXBlIGpzb24KK0RFVEFJTDogIFRva2Vu ICJhYWEiIGlzIGludmFsaWQuCitDT05URVhUOiAgSlNPTiBkYXRhLCBsaW5lIDE6IGFhYQorU0VM RUNUIEpTT05fUVVFUlkoanNvbmIgJyJhYWEiJywgJyQnIFJFVFVSTklORyBieXRlYSBGT1JNQVQg SlNPTiBPTUlUIFFVT1RFUyBFUlJPUiBPTiBFUlJPUik7CisganNvbl9xdWVyeSAKKy0tLS0tLS0t LS0tLQorIFx4NjE2MTYxCisoMSByb3cpCisKKy0tIFFVT1RFUyBiZWhhdmlvciBzaG91bGQgbm90 IGJlIHNwZWNpZmllZCB3aGVuIFdJVEggV1JBUFBFUiB1c2VkOgorLS0gU2hvdWxkIGZhaWwKK1NF TEVDVCBKU09OX1FVRVJZKGpzb25iICdbMV0nLCAnJCcgV0lUSCBXUkFQUEVSIE9NSVQgUVVPVEVT KTsKK0VSUk9SOiAgU1FML0pTT04gUVVPVEVTIGJlaGF2aW9yIG11c3Qgbm90IGJlIHNwZWNpZmll ZCB3aGVuIFdJVEggV1JBUFBFUiBpcyB1c2VkCitMSU5FIDE6IFNFTEVDVCBKU09OX1FVRVJZKGpz b25iICdbMV0nLCAnJCcgV0lUSCBXUkFQUEVSIE9NSVQgUVVPVEVTKS4uLgorICAgICAgICAgICAg ICAgXgorU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ1sxXScsICckJyBXSVRIIFdSQVBQRVIgS0VF UCBRVU9URVMpOworRVJST1I6ICBTUUwvSlNPTiBRVU9URVMgYmVoYXZpb3IgbXVzdCBub3QgYmUg c3BlY2lmaWVkIHdoZW4gV0lUSCBXUkFQUEVSIGlzIHVzZWQKK0xJTkUgMTogU0VMRUNUIEpTT05f UVVFUlkoanNvbmIgJ1sxXScsICckJyBXSVRIIFdSQVBQRVIgS0VFUCBRVU9URVMpLi4uCisgICAg ICAgICAgICAgICBeCitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnWzFdJywgJyQnIFdJVEggQ09O RElUSU9OQUwgV1JBUFBFUiBLRUVQIFFVT1RFUyk7CitFUlJPUjogIFNRTC9KU09OIFFVT1RFUyBi ZWhhdmlvciBtdXN0IG5vdCBiZSBzcGVjaWZpZWQgd2hlbiBXSVRIIFdSQVBQRVIgaXMgdXNlZAor TElORSAxOiBTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnWzFdJywgJyQnIFdJVEggQ09ORElUSU9O QUwgV1JBUFBFUiAuLi4KKyAgICAgICAgICAgICAgIF4KK1NFTEVDVCBKU09OX1FVRVJZKGpzb25i ICdbMV0nLCAnJCcgV0lUSCBDT05ESVRJT05BTCBXUkFQUEVSIE9NSVQgUVVPVEVTKTsKK0VSUk9S OiAgU1FML0pTT04gUVVPVEVTIGJlaGF2aW9yIG11c3Qgbm90IGJlIHNwZWNpZmllZCB3aGVuIFdJ VEggV1JBUFBFUiBpcyB1c2VkCitMSU5FIDE6IFNFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbMV0n LCAnJCcgV0lUSCBDT05ESVRJT05BTCBXUkFQUEVSIC4uLgorICAgICAgICAgICAgICAgXgorLS0g U2hvdWxkIHN1Y2NlZWQKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbMV0nLCAnJCcgV0lUSE9V VCBXUkFQUEVSIE9NSVQgUVVPVEVTKTsKKyBqc29uX3F1ZXJ5IAorLS0tLS0tLS0tLS0tCisgWzFd CisoMSByb3cpCisKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbMV0nLCAnJCcgV0lUSE9VVCBX UkFQUEVSIEtFRVAgUVVPVEVTKTsKKyBqc29uX3F1ZXJ5IAorLS0tLS0tLS0tLS0tCisgWzFdCiso MSByb3cpCisKKy0tIHRlc3QgUVVPVEVTIGJlaGF2aW9yLgorU0VMRUNUIEpTT05fUVVFUlkoanNv bmIneyJyZWMiOiAiezEsMiwzfSJ9JywgJyQucmVjJyByZXR1cm5pbmcgaW50W10gb21pdCBxdW90 ZXMpOworIGpzb25fcXVlcnkgCistLS0tLS0tLS0tLS0KKyB7MSwyLDN9CisoMSByb3cpCisKK1NF TEVDVCBKU09OX1FVRVJZKGpzb25iJ3sicmVjIjogInsxLDIsM30ifScsICckLnJlYycgcmV0dXJu aW5nIGludFtdIGtlZXAgcXVvdGVzKTsKKyBqc29uX3F1ZXJ5IAorLS0tLS0tLS0tLS0tCisgCiso MSByb3cpCisKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iJ3sicmVjIjogInsxLDIsM30ifScsICck LnJlYycgcmV0dXJuaW5nIGludFtdIGtlZXAgcXVvdGVzIGVycm9yIG9uIGVycm9yKTsKK0VSUk9S OiAgZXhwZWN0ZWQgSlNPTiBhcnJheQorU0VMRUNUIEpTT05fUVVFUlkoanNvbmIneyJyZWMiOiAi WzEsMl0ifScsICckLnJlYycgcmV0dXJuaW5nIGludDRyYW5nZSBvbWl0IHF1b3Rlcyk7CisganNv bl9xdWVyeSAKKy0tLS0tLS0tLS0tLQorIFsxLDMpCisoMSByb3cpCisKK1NFTEVDVCBKU09OX1FV RVJZKGpzb25iJ3sicmVjIjogIlsxLDJdIn0nLCAnJC5yZWMnIHJldHVybmluZyBpbnQ0cmFuZ2Ug a2VlcCBxdW90ZXMpOworIGpzb25fcXVlcnkgCistLS0tLS0tLS0tLS0KKyAKKygxIHJvdykKKwor U0VMRUNUIEpTT05fUVVFUlkoanNvbmIneyJyZWMiOiAiWzEsMl0ifScsICckLnJlYycgCXJldHVy bmluZyBpbnQ0cmFuZ2Uga2VlcCBxdW90ZXMgZXJyb3Igb24gZXJyb3IpOworRVJST1I6ICBtYWxm b3JtZWQgcmFuZ2UgbGl0ZXJhbDogIiJbMSwyXSIiCitERVRBSUw6ICBNaXNzaW5nIGxlZnQgcGFy ZW50aGVzaXMgb3IgYnJhY2tldC4KK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbXScsICckWypd Jyk7CisganNvbl9xdWVyeSAKKy0tLS0tLS0tLS0tLQorIAorKDEgcm93KQorCitTRUxFQ1QgSlNP Tl9RVUVSWShqc29uYiAnW10nLCAnJFsqXScgTlVMTCBPTiBFTVBUWSk7CisganNvbl9xdWVyeSAK Ky0tLS0tLS0tLS0tLQorIAorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnW10n LCAnJFsqXScgRU1QVFkgT04gRU1QVFkpOworIGpzb25fcXVlcnkgCistLS0tLS0tLS0tLS0KKyBb XQorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnW10nLCAnJFsqXScgRU1QVFkg QVJSQVkgT04gRU1QVFkpOworIGpzb25fcXVlcnkgCistLS0tLS0tLS0tLS0KKyBbXQorKDEgcm93 KQorCitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnW10nLCAnJFsqXScgRU1QVFkgT0JKRUNUIE9O IEVNUFRZKTsKKyBqc29uX3F1ZXJ5IAorLS0tLS0tLS0tLS0tCisge30KKygxIHJvdykKKworU0VM RUNUIEpTT05fUVVFUlkoanNvbmIgJ1tdJywgJyRbKl0nIEVSUk9SIE9OIEVNUFRZKTsKK0VSUk9S OiAgbm8gU1FML0pTT04gaXRlbQorU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ1tdJywgJyRbKl0n IERFRkFVTFQgJyJlbXB0eSInIE9OIEVNUFRZKTsKKyBqc29uX3F1ZXJ5IAorLS0tLS0tLS0tLS0t CisgImVtcHR5IgorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnW10nLCAnJFsq XScgRVJST1IgT04gRU1QVFkgTlVMTCBPTiBFUlJPUik7CitFUlJPUjogIG5vIFNRTC9KU09OIGl0 ZW0KK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbXScsICckWypdJyBFUlJPUiBPTiBFTVBUWSBF TVBUWSBBUlJBWSBPTiBFUlJPUik7CitFUlJPUjogIG5vIFNRTC9KU09OIGl0ZW0KK1NFTEVDVCBK U09OX1FVRVJZKGpzb25iICdbXScsICckWypdJyBFUlJPUiBPTiBFTVBUWSBFTVBUWSBPQkpFQ1Qg T04gRVJST1IpOworRVJST1I6ICBubyBTUUwvSlNPTiBpdGVtCitTRUxFQ1QgSlNPTl9RVUVSWShq c29uYiAnW10nLCAnJFsqXScgRVJST1IgT04gRU1QVFkgRVJST1IgT04gRVJST1IpOworRVJST1I6 ICBubyBTUUwvSlNPTiBpdGVtCitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnW10nLCAnJFsqXScg RVJST1IgT04gRVJST1IpOworRVJST1I6ICBubyBTUUwvSlNPTiBpdGVtCitTRUxFQ1QgSlNPTl9R VUVSWShqc29uYiAnWzEsMl0nLCAnJFsqXScgRVJST1IgT04gRVJST1IpOworRVJST1I6ICBKU09O IHBhdGggZXhwcmVzc2lvbiBpbiBKU09OX1FVRVJZIHNob3VsZCByZXR1cm4gc2luZ2xldG9uIGl0 ZW0gd2l0aG91dCB3cmFwcGVyCitISU5UOiAgVXNlIFdJVEggV1JBUFBFUiBjbGF1c2UgdG8gd3Jh cCBTUUwvSlNPTiBpdGVtIHNlcXVlbmNlIGludG8gYXJyYXkuCitTRUxFQ1QgSlNPTl9RVUVSWShq c29uYiAnWzEsMl0nLCAnJFsqXScgREVGQVVMVCAnImVtcHR5IicgT04gRVJST1IpOworIGpzb25f cXVlcnkgCistLS0tLS0tLS0tLS0KKyAiZW1wdHkiCisoMSByb3cpCisKK1NFTEVDVCBKU09OX1FV RVJZKGpzb25iICdbMSwyXScsICckJyBSRVRVUk5JTkcganNvbik7CisganNvbl9xdWVyeSAKKy0t LS0tLS0tLS0tLQorIFsxLCAyXQorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAn WzEsMl0nLCAnJCcgUkVUVVJOSU5HIGpzb24gRk9STUFUIEpTT04pOworIGpzb25fcXVlcnkgCist LS0tLS0tLS0tLS0KKyBbMSwgMl0KKygxIHJvdykKKworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIg J1sxLDJdJywgJyQnIFJFVFVSTklORyBqc29uYik7CisganNvbl9xdWVyeSAKKy0tLS0tLS0tLS0t LQorIFsxLCAyXQorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnWzEsMl0nLCAn JCcgUkVUVVJOSU5HIGpzb25iIEZPUk1BVCBKU09OKTsKKyBqc29uX3F1ZXJ5IAorLS0tLS0tLS0t LS0tCisgWzEsIDJdCisoMSByb3cpCisKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbMSwyXScs ICckJyBSRVRVUk5JTkcgdGV4dCk7CisganNvbl9xdWVyeSAKKy0tLS0tLS0tLS0tLQorIFsxLCAy XQorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnWzEsMl0nLCAnJCcgUkVUVVJO SU5HIGNoYXIoMTApKTsKKyBqc29uX3F1ZXJ5IAorLS0tLS0tLS0tLS0tCisgWzEsIDJdICAgIAor KDEgcm93KQorCitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnWzEsMl0nLCAnJCcgUkVUVVJOSU5H IGNoYXIoMykpOworIGpzb25fcXVlcnkgCistLS0tLS0tLS0tLS0KKyBbMSwKKygxIHJvdykKKwor U0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ1sxLDJdJywgJyQnIFJFVFVSTklORyB0ZXh0IEZPUk1B VCBKU09OKTsKKyBqc29uX3F1ZXJ5IAorLS0tLS0tLS0tLS0tCisgWzEsIDJdCisoMSByb3cpCisK K1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbMSwyXScsICckJyBSRVRVUk5JTkcgYnl0ZWEpOwor ICAganNvbl9xdWVyeSAgIAorLS0tLS0tLS0tLS0tLS0tLQorIFx4NWIzMTJjMjAzMjVkCisoMSBy b3cpCisKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbMSwyXScsICckJyBSRVRVUk5JTkcgYnl0 ZWEgRk9STUFUIEpTT04pOworICAganNvbl9xdWVyeSAgIAorLS0tLS0tLS0tLS0tLS0tLQorIFx4 NWIzMTJjMjAzMjVkCisoMSByb3cpCisKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbMSwyXScs ICckWypdJyBSRVRVUk5JTkcgYnl0ZWEgRU1QVFkgT0JKRUNUIE9OIEVSUk9SKTsKK0VSUk9SOiAg Y2Fubm90IGNhc3QgYmVoYXZpb3IgZXhwcmVzc2lvbiBvZiB0eXBlIGpzb25iIHRvIGJ5dGVhCitM SU5FIDE6IC4uLiBKU09OX1FVRVJZKGpzb25iICdbMSwyXScsICckWypdJyBSRVRVUk5JTkcgYnl0 ZWEgRU1QVFkgT0JKRS4uLgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIF4KK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbMSwyXScs ICckWypdJyBSRVRVUk5JTkcgYnl0ZWEgRk9STUFUIEpTT04gRU1QVFkgT0JKRUNUIE9OIEVSUk9S KTsKK0VSUk9SOiAgY2Fubm90IGNhc3QgYmVoYXZpb3IgZXhwcmVzc2lvbiBvZiB0eXBlIGpzb25i IHRvIGJ5dGVhCitMSU5FIDE6IC4uLmpzb25iICdbMSwyXScsICckWypdJyBSRVRVUk5JTkcgYnl0 ZWEgRk9STUFUIEpTT04gRU1QVFkgT0JKRS4uLgorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIF4KK1NFTEVDVCBKU09OX1FVRVJZKGpz b25iICdbMSwyXScsICckWypdJyBSRVRVUk5JTkcganNvbiBFTVBUWSBPQkpFQ1QgT04gRVJST1Ip OworIGpzb25fcXVlcnkgCistLS0tLS0tLS0tLS0KKyB7fQorKDEgcm93KQorCitTRUxFQ1QgSlNP Tl9RVUVSWShqc29uYiAnWzEsMl0nLCAnJFsqXScgUkVUVVJOSU5HIGpzb25iIEVNUFRZIE9CSkVD VCBPTiBFUlJPUik7CisganNvbl9xdWVyeSAKKy0tLS0tLS0tLS0tLQorIHt9CisoMSByb3cpCisK K1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbMyw0XScsICckWypdJyBSRVRVUk5JTkcgYmlnaW50 W10gRU1QVFkgT0JKRUNUIE9OIEVSUk9SKTsKK0VSUk9SOiAgY2Fubm90IGNhc3QgYmVoYXZpb3Ig ZXhwcmVzc2lvbiBvZiB0eXBlIGpzb25iIHRvIGJpZ2ludFtdCitMSU5FIDE6IC4uLk9OX1FVRVJZ KGpzb25iICdbMyw0XScsICckWypdJyBSRVRVUk5JTkcgYmlnaW50W10gRU1QVFkgT0JKRS4uLgor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIF4KK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICciWzMsNF0iJywgJyRbKl0nIFJFVFVSTklO RyBiaWdpbnRbXSBFTVBUWSBPQkpFQ1QgT04gRVJST1IpOworRVJST1I6ICBjYW5ub3QgY2FzdCBi ZWhhdmlvciBleHByZXNzaW9uIG9mIHR5cGUganNvbmIgdG8gYmlnaW50W10KK0xJTkUgMTogLi4u X1FVRVJZKGpzb25iICciWzMsNF0iJywgJyRbKl0nIFJFVFVSTklORyBiaWdpbnRbXSBFTVBUWSBP QkpFLi4uCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgXgorLS0gUkVUVUdOSU5HIHBzZXVkby10eXBlcyBub3QgYWxsb3dlZAorU0VM RUNUIEpTT05fUVVFUlkoanNvbmIgJ1szLDRdJywgJyRbKl0nIFJFVFVSTklORyBhbnlhcnJheSBF TVBUWSBPQkpFQ1QgT04gRVJST1IpOworRVJST1I6ICByZXR1cm5pbmcgcHNldWRvLXR5cGVzIGlz IG5vdCBzdXBwb3J0ZWQgaW4gU1FML0pTT04gZnVuY3Rpb25zCitTRUxFQ1QKKwl4LCB5LAorCUpT T05fUVVFUlkoCisJCWpzb25iICdbMSwyLDMsNCw1LG51bGxdJywKKwkJJyRbKl0gPyAoQCA+PSAk eCAmJiBAIDw9ICR5KScKKwkJUEFTU0lORyB4IEFTIHgsIHkgQVMgeQorCQlXSVRIIENPTkRJVElP TkFMIFdSQVBQRVIKKwkJRU1QVFkgQVJSQVkgT04gRU1QVFkKKwkpIGxpc3QKK0ZST00KKwlnZW5l cmF0ZV9zZXJpZXMoMCwgNCkgeCwKKwlnZW5lcmF0ZV9zZXJpZXMoMCwgNCkgeTsKKyB4IHwgeSB8 ICAgICBsaXN0ICAgICAKKy0tLSstLS0rLS0tLS0tLS0tLS0tLS0KKyAwIHwgMCB8IFtdCisgMCB8 IDEgfCBbMV0KKyAwIHwgMiB8IFsxLCAyXQorIDAgfCAzIHwgWzEsIDIsIDNdCisgMCB8IDQgfCBb MSwgMiwgMywgNF0KKyAxIHwgMCB8IFtdCisgMSB8IDEgfCBbMV0KKyAxIHwgMiB8IFsxLCAyXQor IDEgfCAzIHwgWzEsIDIsIDNdCisgMSB8IDQgfCBbMSwgMiwgMywgNF0KKyAyIHwgMCB8IFtdCisg MiB8IDEgfCBbXQorIDIgfCAyIHwgWzJdCisgMiB8IDMgfCBbMiwgM10KKyAyIHwgNCB8IFsyLCAz LCA0XQorIDMgfCAwIHwgW10KKyAzIHwgMSB8IFtdCisgMyB8IDIgfCBbXQorIDMgfCAzIHwgWzNd CisgMyB8IDQgfCBbMywgNF0KKyA0IHwgMCB8IFtdCisgNCB8IDEgfCBbXQorIDQgfCAyIHwgW10K KyA0IHwgMyB8IFtdCisgNCB8IDQgfCBbNF0KKygyNSByb3dzKQorCistLSByZWNvcmQgdHlwZSBy ZXR1cm5pbmcgd2l0aCBxdW90ZXMgYmVoYXZpb3IuCitDUkVBVEUgVFlQRSBjb21wX2FiYyBBUyAo YSB0ZXh0LCBiIGludCwgYyB0aW1lc3RhbXApOworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIneyJy ZWMiOiAiKGFiYyw0MiwwMS4wMi4yMDAzKSJ9JywgJyQucmVjJyByZXR1cm5pbmcgY29tcF9hYmMg b21pdCBxdW90ZXMpOworICAgICAgICAgICAgIGpzb25fcXVlcnkgICAgICAgICAgICAgIAorLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorIChhYmMsNDIsIlRodSBKYW4gMDIg MDA6MDA6MDAgMjAwMyIpCisoMSByb3cpCisKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iJ3sicmVj IjogIihhYmMsNDIsMDEuMDIuMjAwMykifScsICckLnJlYycgcmV0dXJuaW5nIGNvbXBfYWJjIGtl ZXAgcXVvdGVzKTsKKyBqc29uX3F1ZXJ5IAorLS0tLS0tLS0tLS0tCisgCisoMSByb3cpCisKK1NF TEVDVCBKU09OX1FVRVJZKGpzb25iJ3sicmVjIjogIihhYmMsNDIsMDEuMDIuMjAwMykifScsICck LnJlYycgcmV0dXJuaW5nIGNvbXBfYWJjIGtlZXAgcXVvdGVzIGVycm9yIG9uIGVycm9yKTsKK0VS Uk9SOiAgY2Fubm90IGNhbGwgcG9wdWxhdGVfY29tcG9zaXRlIG9uIGEgc2NhbGFyCitEUk9QIFRZ UEUgY29tcF9hYmM7CistLSBFeHRlbnNpb246IHJlY29yZCB0eXBlcyByZXR1cm5pbmcKK0NSRUFU RSBUWVBFIHNxbGpzb25iX3JlYyBBUyAoYSBpbnQsIHQgdGV4dCwganMganNvbiwgamIganNvbmIs IGpzYSBqc29uW10pOworQ1JFQVRFIFRZUEUgc3FsanNvbmJfcmVjYSBBUyAocmVjYSBzcWxqc29u Yl9yZWNbXSk7CitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnW3siYSI6IDEsICJiIjogImZvbyIs ICJ0IjogImFhYSIsICJqcyI6IFsxLCAiMiIsIHt9XSwgImpiIjogeyJ4IjogWzEsICIyIiwge31d fX0sICB7ImEiOiAyfV0nLCAnJFswXScgUkVUVVJOSU5HIHNxbGpzb25iX3JlYyk7CisgICAgICAg ICAgICAgICAgICAgICBqc29uX3F1ZXJ5ICAgICAgICAgICAgICAgICAgICAgIAorLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAoMSxhYWEsIlsx LCAiIjIiIiwge31dIiwieyIieCIiOiBbMSwgIiIyIiIsIHt9XX0iLCkKKygxIHJvdykKKworU0VM RUNUIEpTT05fUVVFUlkoanNvbmIgJ1t7ImEiOiAiYSIsICJiIjogImZvbyIsICJ0IjogImFhYSIs ICJqcyI6IFsxLCAiMiIsIHt9XSwgImpiIjogeyJ4IjogWzEsICIyIiwge31dfX0sICB7ImEiOiAy fV0nLCAnJFswXScgUkVUVVJOSU5HIHNxbGpzb25iX3JlYyBFUlJPUiBPTiBFUlJPUik7CitFUlJP UjogIGludmFsaWQgaW5wdXQgc3ludGF4IGZvciB0eXBlIGludGVnZXI6ICJhIgorU0VMRUNUIEpT T05fUVVFUlkoanNvbmIgJ1t7ImEiOiAiYSIsICJiIjogImZvbyIsICJ0IjogImFhYSIsICJqcyI6 IFsxLCAiMiIsIHt9XSwgImpiIjogeyJ4IjogWzEsICIyIiwge31dfX0sICB7ImEiOiAyfV0nLCAn JFswXScgUkVUVVJOSU5HIHNxbGpzb25iX3JlYyk7CisganNvbl9xdWVyeSAKKy0tLS0tLS0tLS0t LQorIAorKDEgcm93KQorCitTRUxFQ1QgKiBGUk9NIHVubmVzdCgoSlNPTl9RVUVSWShqc29uYiAn eyJqc2EiOiAgW3siYSI6IDEsICJiIjogWyJmb28iXX0sIHsiYSI6IDIsICJjIjoge319LCAxMjNd fScsICckJyBSRVRVUk5JTkcgc3FsanNvbmJfcmVjKSkuanNhKTsKKyAgICAgICAgIHVubmVzdCAg ICAgICAgIAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgeyJhIjogMSwgImIiOiBbImZvbyJd fQorIHsiYSI6IDIsICJjIjoge319CisgMTIzCisoMyByb3dzKQorCitTRUxFQ1QgKiBGUk9NIHVu bmVzdCgoSlNPTl9RVUVSWShqc29uYiAneyJyZWNhIjogW3siYSI6IDEsICJ0IjogWyJmb28iLCBb XV19LCB7ImEiOiAyLCAiamIiOiBbe30sIHRydWVdfV19JywgJyQnIFJFVFVSTklORyBzcWxqc29u Yl9yZWNhKSkucmVjYSk7CisgYSB8ICAgICAgdCAgICAgIHwganMgfCAgICAgamIgICAgIHwganNh IAorLS0tKy0tLS0tLS0tLS0tLS0rLS0tLSstLS0tLS0tLS0tLS0rLS0tLS0KKyAxIHwgWyJmb28i LCBbXV0gfCAgICB8ICAgICAgICAgICAgfCAKKyAyIHwgICAgICAgICAgICAgfCAgICB8IFt7fSwg dHJ1ZV0gfCAKKygyIHJvd3MpCisKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbeyJhIjogMSwg ImIiOiAiZm9vIiwgInQiOiAiYWFhIiwgImpzIjogWzEsICIyIiwge31dLCAiamIiOiB7IngiOiBb MSwgIjIiLCB7fV19fSwgIHsiYSI6IDJ9XScsICckWzBdJyBSRVRVUk5JTkcganNvbnBhdGgpOwor IGpzb25fcXVlcnkgCistLS0tLS0tLS0tLS0KKyAKKygxIHJvdykKKworU0VMRUNUIEpTT05fUVVF UlkoanNvbmIgJ1t7ImEiOiAxLCAiYiI6ICJmb28iLCAidCI6ICJhYWEiLCAianMiOiBbMSwgIjIi LCB7fV0sICJqYiI6IHsieCI6IFsxLCAiMiIsIHt9XX19LCAgeyJhIjogMn1dJywgJyRbMF0nIFJF VFVSTklORyBqc29ucGF0aCBFUlJPUiBPTiBFUlJPUik7CitFUlJPUjogIHN5bnRheCBlcnJvciBh dCBvciBuZWFyICJ7IiBvZiBqc29ucGF0aCBpbnB1dAorLS0gRXh0ZW5zaW9uOiBhcnJheSB0eXBl cyByZXR1cm5pbmcKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbMSwyLG51bGwsIjMiXScsICck WypdJyBSRVRVUk5JTkcgaW50W10gV0lUSCBXUkFQUEVSKTsKKyAganNvbl9xdWVyeSAgCistLS0t LS0tLS0tLS0tLQorIHsxLDIsTlVMTCwzfQorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9RVUVSWShq c29uYiAnWzEsMixudWxsLCJhIl0nLCAnJFsqXScgUkVUVVJOSU5HIGludFtdIFdJVEggV1JBUFBF UiBFUlJPUiBPTiBFUlJPUik7CitFUlJPUjogIGludmFsaWQgaW5wdXQgc3ludGF4IGZvciB0eXBl IGludGVnZXI6ICJhIgorU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ1sxLDIsbnVsbCwiYSJdJywg JyRbKl0nIFJFVFVSTklORyBpbnRbXSBXSVRIIFdSQVBQRVIpOworIGpzb25fcXVlcnkgCistLS0t LS0tLS0tLS0KKyAKKygxIHJvdykKKworU0VMRUNUICogRlJPTSB1bm5lc3QoSlNPTl9RVUVSWShq c29uYiAnW3siYSI6IDEsICJ0IjogWyJmb28iLCBbXV19LCB7ImEiOiAyLCAiamIiOiBbe30sIHRy dWVdfV0nLCAnJCcgUkVUVVJOSU5HIHNxbGpzb25iX3JlY1tdKSk7CisgYSB8ICAgICAgdCAgICAg IHwganMgfCAgICAgamIgICAgIHwganNhIAorLS0tKy0tLS0tLS0tLS0tLS0rLS0tLSstLS0tLS0t LS0tLS0rLS0tLS0KKyAxIHwgWyJmb28iLCBbXV0gfCAgICB8ICAgICAgICAgICAgfCAKKyAyIHwg ICAgICAgICAgICAgfCAgICB8IFt7fSwgdHJ1ZV0gfCAKKygyIHJvd3MpCisKKy0tIEV4dGVuc2lv bjogZG9tYWluIHR5cGVzIHJldHVybmluZworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ3siYSI6 IDF9JywgJyQuYScgUkVUVVJOSU5HIHNxbGpzb25iX2ludF9ub3RfbnVsbCk7CisganNvbl9xdWVy eSAKKy0tLS0tLS0tLS0tLQorICAgICAgICAgIDEKKygxIHJvdykKKworU0VMRUNUIEpTT05fUVVF UlkoanNvbmIgJ3siYSI6IDF9JywgJyQuYicgUkVUVVJOSU5HIHNxbGpzb25iX2ludF9ub3RfbnVs bCk7CitFUlJPUjogIGRvbWFpbiBzcWxqc29uYl9pbnRfbm90X251bGwgZG9lcyBub3QgYWxsb3cg bnVsbCB2YWx1ZXMKKy0tIFRlc3QgdGltZXN0YW1wdHogcGFzc2luZyBhbmQgb3V0cHV0CitTRUxF Q1QgSlNPTl9RVUVSWShqc29uYiAnbnVsbCcsICckdHMnIFBBU1NJTkcgdGltZXN0YW1wdHogJzIw MTgtMDItMjEgMTI6MzQ6NTYgKzEwJyBBUyB0cyk7CisgICAgICAgICBqc29uX3F1ZXJ5ICAgICAg ICAgIAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAiMjAxOC0wMi0yMVQwMjozNDo1 NiswMDowMCIKKygxIHJvdykKKworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ251bGwnLCAnJHRz JyBQQVNTSU5HIHRpbWVzdGFtcHR6ICcyMDE4LTAyLTIxIDEyOjM0OjU2ICsxMCcgQVMgdHMgUkVU VVJOSU5HIGpzb24pOworICAgICAgICAganNvbl9xdWVyeSAgICAgICAgICAKKy0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tCisgIjIwMTgtMDItMjFUMDI6MzQ6NTYrMDA6MDAiCisoMSByb3cp CisKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdudWxsJywgJyR0cycgUEFTU0lORyB0aW1lc3Rh bXB0eiAnMjAxOC0wMi0yMSAxMjozNDo1NiArMTAnIEFTIHRzIFJFVFVSTklORyBqc29uYik7Cisg ICAgICAgICBqc29uX3F1ZXJ5ICAgICAgICAgIAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0KKyAiMjAxOC0wMi0yMVQwMjozNDo1NiswMDowMCIKKygxIHJvdykKKworLS0gVGVzdCBjb25z dHJhaW50cworQ1JFQVRFIFRBQkxFIHRlc3RfanNvbmJfY29uc3RyYWludHMgKAorCWpzIHRleHQs CisJaSBpbnQsCisJeCBqc29uYiBERUZBVUxUIEpTT05fUVVFUlkoanNvbmIgJ1sxLDJdJywgJyRb Kl0nIFdJVEggV1JBUFBFUikKKwlDT05TVFJBSU5UIHRlc3RfanNvbmJfY29uc3RyYWludDEKKwkJ Q0hFQ0sgKGpzIElTIEpTT04pCisJQ09OU1RSQUlOVCB0ZXN0X2pzb25iX2NvbnN0cmFpbnQyCisJ CUNIRUNLIChKU09OX0VYSVNUUyhqczo6anNvbmIsICckLmEnIFBBU1NJTkcgaSArIDUgQVMgaW50 LCBpOjp0ZXh0IEFTIHR4dCwgYXJyYXlbMSwyLDNdIGFzIGFycikpCisJQ09OU1RSQUlOVCB0ZXN0 X2pzb25iX2NvbnN0cmFpbnQzCisJCUNIRUNLIChKU09OX1ZBTFVFKGpzOjpqc29uYiwgJyQuYScg UkVUVVJOSU5HIGludCBERUZBVUxUICcxMicgT04gRU1QVFkgRVJST1IgT04gRVJST1IpID4gaSkK KwlDT05TVFJBSU5UIHRlc3RfanNvbmJfY29uc3RyYWludDQKKwkJQ0hFQ0sgKEpTT05fUVVFUlko anM6Ompzb25iLCAnJC5hJyBXSVRIIENPTkRJVElPTkFMIFdSQVBQRVIgRU1QVFkgT0JKRUNUIE9O IEVSUk9SKSA8IGpzb25iICdbMTBdJykKKwlDT05TVFJBSU5UIHRlc3RfanNvbmJfY29uc3RyYWlu dDUKKwkJQ0hFQ0sgKEpTT05fUVVFUlkoanM6Ompzb25iLCAnJC5hJyBSRVRVUk5JTkcgY2hhcig1 KSBPTUlUIFFVT1RFUyBFTVBUWSBBUlJBWSBPTiBFTVBUWSkgPiAgJ2EnIENPTExBVEUgIkMiKQor KTsKK1xkIHRlc3RfanNvbmJfY29uc3RyYWludHMKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFRhYmxlICJwdWJsaWMudGVzdF9qc29uYl9jb25zdHJhaW50cyIKKyBD b2x1bW4gfCAgVHlwZSAgIHwgQ29sbGF0aW9uIHwgTnVsbGFibGUgfCAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIERlZmF1bHQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgCistLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tLS0rLS0tLS0tLS0tLSstLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLQorIGpzICAgICB8IHRleHQgICAgfCAgICAgICAgICAgfCAgICAgICAg ICB8IAorIGkgICAgICB8IGludGVnZXIgfCAgICAgICAgICAgfCAgICAgICAgICB8IAorIHggICAg ICB8IGpzb25iICAgfCAgICAgICAgICAgfCAgICAgICAgICB8IEpTT05fUVVFUlkoJ1sxLCAyXSc6 Ompzb25iLCAnJFsqXScgUkVUVVJOSU5HIGpzb25iIFdJVEggVU5DT05ESVRJT05BTCBXUkFQUEVS KQorQ2hlY2sgY29uc3RyYWludHM6CisgICAgInRlc3RfanNvbmJfY29uc3RyYWludDEiIENIRUNL IChqcyBJUyBKU09OKQorICAgICJ0ZXN0X2pzb25iX2NvbnN0cmFpbnQyIiBDSEVDSyAoSlNPTl9F WElTVFMoanM6Ompzb25iLCAnJC4iYSInIFBBU1NJTkcgaSArIDUgQVMgaW50LCBpOjp0ZXh0IEFT IHR4dCwgQVJSQVlbMSwgMiwgM10gQVMgYXJyKSkKKyAgICAidGVzdF9qc29uYl9jb25zdHJhaW50 MyIgQ0hFQ0sgKEpTT05fVkFMVUUoanM6Ompzb25iLCAnJC4iYSInIFJFVFVSTklORyBpbnRlZ2Vy IERFRkFVTFQgMTIgT04gRU1QVFkgRVJST1IgT04gRVJST1IpID4gaSkKKyAgICAidGVzdF9qc29u Yl9jb25zdHJhaW50NCIgQ0hFQ0sgKEpTT05fUVVFUlkoanM6Ompzb25iLCAnJC4iYSInIFJFVFVS TklORyBqc29uYiBXSVRIIENPTkRJVElPTkFMIFdSQVBQRVIgRU1QVFkgT0JKRUNUIE9OIEVSUk9S KSA8ICdbMTBdJzo6anNvbmIpCisgICAgInRlc3RfanNvbmJfY29uc3RyYWludDUiIENIRUNLIChK U09OX1FVRVJZKGpzOjpqc29uYiwgJyQuImEiJyBSRVRVUk5JTkcgY2hhcmFjdGVyKDUpIE9NSVQg UVVPVEVTIEVNUFRZIEFSUkFZIE9OIEVNUFRZKSA+ICgnYSc6OmJwY2hhciBDT0xMQVRFICJDIikp CisKK1NFTEVDVCBjaGVja19jbGF1c2UKK0ZST00gaW5mb3JtYXRpb25fc2NoZW1hLmNoZWNrX2Nv bnN0cmFpbnRzCitXSEVSRSBjb25zdHJhaW50X25hbWUgTElLRSAndGVzdF9qc29uYl9jb25zdHJh aW50JScKK09SREVSIEJZIDE7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBjaGVja19jbGF1c2UgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorIChKU09OX1FVRVJZKChqcyk6Ompz b25iLCAnJC4iYSInIFJFVFVSTklORyBjaGFyYWN0ZXIoNSkgT01JVCBRVU9URVMgRU1QVFkgQVJS QVkgT04gRU1QVFkpID4gKCdhJzo6YnBjaGFyIENPTExBVEUgIkMiKSkKKyAoSlNPTl9RVUVSWSgo anMpOjpqc29uYiwgJyQuImEiJyBSRVRVUk5JTkcganNvbmIgV0lUSCBDT05ESVRJT05BTCBXUkFQ UEVSIEVNUFRZIE9CSkVDVCBPTiBFUlJPUikgPCAnWzEwXSc6Ompzb25iKQorIChKU09OX1ZBTFVF KChqcyk6Ompzb25iLCAnJC4iYSInIFJFVFVSTklORyBpbnRlZ2VyIERFRkFVTFQgMTIgT04gRU1Q VFkgRVJST1IgT04gRVJST1IpID4gaSkKKyAoanMgSVMgSlNPTikKKyBKU09OX0VYSVNUUygoanMp Ojpqc29uYiwgJyQuImEiJyBQQVNTSU5HIChpICsgNSkgQVMgaW50LCAoaSk6OnRleHQgQVMgdHh0 LCBBUlJBWVsxLCAyLCAzXSBBUyBhcnIpCisoNSByb3dzKQorCitTRUxFQ1QgcGdfZ2V0X2V4cHIo YWRiaW4sIGFkcmVsaWQpCitGUk9NIHBnX2F0dHJkZWYKK1dIRVJFIGFkcmVsaWQgPSAndGVzdF9q c29uYl9jb25zdHJhaW50cyc6OnJlZ2NsYXNzCitPUkRFUiBCWSAxOworICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHBnX2dldF9leHByICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgSlNPTl9RVUVSWSgnWzEsIDJdJzo6 anNvbmIsICckWypdJyBSRVRVUk5JTkcganNvbmIgV0lUSCBVTkNPTkRJVElPTkFMIFdSQVBQRVIp CisoMSByb3cpCisKK0lOU0VSVCBJTlRPIHRlc3RfanNvbmJfY29uc3RyYWludHMgVkFMVUVTICgn JywgMSk7CitFUlJPUjogIG5ldyByb3cgZm9yIHJlbGF0aW9uICJ0ZXN0X2pzb25iX2NvbnN0cmFp bnRzIiB2aW9sYXRlcyBjaGVjayBjb25zdHJhaW50ICJ0ZXN0X2pzb25iX2NvbnN0cmFpbnQxIgor REVUQUlMOiAgRmFpbGluZyByb3cgY29udGFpbnMgKCwgMSwgWzEsIDJdKS4KK0lOU0VSVCBJTlRP IHRlc3RfanNvbmJfY29uc3RyYWludHMgVkFMVUVTICgnMScsIDEpOworRVJST1I6ICBuZXcgcm93 IGZvciByZWxhdGlvbiAidGVzdF9qc29uYl9jb25zdHJhaW50cyIgdmlvbGF0ZXMgY2hlY2sgY29u c3RyYWludCAidGVzdF9qc29uYl9jb25zdHJhaW50MiIKK0RFVEFJTDogIEZhaWxpbmcgcm93IGNv bnRhaW5zICgxLCAxLCBbMSwgMl0pLgorSU5TRVJUIElOVE8gdGVzdF9qc29uYl9jb25zdHJhaW50 cyBWQUxVRVMgKCdbXScpOworRVJST1I6ICBuZXcgcm93IGZvciByZWxhdGlvbiAidGVzdF9qc29u Yl9jb25zdHJhaW50cyIgdmlvbGF0ZXMgY2hlY2sgY29uc3RyYWludCAidGVzdF9qc29uYl9jb25z dHJhaW50MiIKK0RFVEFJTDogIEZhaWxpbmcgcm93IGNvbnRhaW5zIChbXSwgbnVsbCwgWzEsIDJd KS4KK0lOU0VSVCBJTlRPIHRlc3RfanNvbmJfY29uc3RyYWludHMgVkFMVUVTICgneyJiIjogMX0n LCAxKTsKK0VSUk9SOiAgbmV3IHJvdyBmb3IgcmVsYXRpb24gInRlc3RfanNvbmJfY29uc3RyYWlu dHMiIHZpb2xhdGVzIGNoZWNrIGNvbnN0cmFpbnQgInRlc3RfanNvbmJfY29uc3RyYWludDIiCitE RVRBSUw6ICBGYWlsaW5nIHJvdyBjb250YWlucyAoeyJiIjogMX0sIDEsIFsxLCAyXSkuCitJTlNF UlQgSU5UTyB0ZXN0X2pzb25iX2NvbnN0cmFpbnRzIFZBTFVFUyAoJ3siYSI6IDF9JywgMSk7CitF UlJPUjogIG5ldyByb3cgZm9yIHJlbGF0aW9uICJ0ZXN0X2pzb25iX2NvbnN0cmFpbnRzIiB2aW9s YXRlcyBjaGVjayBjb25zdHJhaW50ICJ0ZXN0X2pzb25iX2NvbnN0cmFpbnQzIgorREVUQUlMOiAg RmFpbGluZyByb3cgY29udGFpbnMgKHsiYSI6IDF9LCAxLCBbMSwgMl0pLgorSU5TRVJUIElOVE8g dGVzdF9qc29uYl9jb25zdHJhaW50cyBWQUxVRVMgKCd7ImEiOiA3fScsIDEpOworRVJST1I6ICBu ZXcgcm93IGZvciByZWxhdGlvbiAidGVzdF9qc29uYl9jb25zdHJhaW50cyIgdmlvbGF0ZXMgY2hl Y2sgY29uc3RyYWludCAidGVzdF9qc29uYl9jb25zdHJhaW50NSIKK0RFVEFJTDogIEZhaWxpbmcg cm93IGNvbnRhaW5zICh7ImEiOiA3fSwgMSwgWzEsIDJdKS4KK0lOU0VSVCBJTlRPIHRlc3RfanNv bmJfY29uc3RyYWludHMgVkFMVUVTICgneyJhIjogMTB9JywgMSk7CitFUlJPUjogIG5ldyByb3cg Zm9yIHJlbGF0aW9uICJ0ZXN0X2pzb25iX2NvbnN0cmFpbnRzIiB2aW9sYXRlcyBjaGVjayBjb25z dHJhaW50ICJ0ZXN0X2pzb25iX2NvbnN0cmFpbnQ0IgorREVUQUlMOiAgRmFpbGluZyByb3cgY29u dGFpbnMgKHsiYSI6IDEwfSwgMSwgWzEsIDJdKS4KK0RST1AgVEFCTEUgdGVzdF9qc29uYl9jb25z dHJhaW50czsKKy0tIFRlc3QgbXV0YWJpbGlseSBvZiBxdWVyeSBmdW5jdGlvbnMKK0NSRUFURSBU QUJMRSB0ZXN0X2pzb25iX211dGFiaWxpdHkoanMganNvbmIpOworQ1JFQVRFIElOREVYIE9OIHRl c3RfanNvbmJfbXV0YWJpbGl0eSAoSlNPTl9RVUVSWShqcywgJyQnKSk7CitDUkVBVEUgSU5ERVgg T04gdGVzdF9qc29uYl9tdXRhYmlsaXR5IChKU09OX1FVRVJZKGpzLCAnJC5hWzBdJykpOworQ1JF QVRFIElOREVYIE9OIHRlc3RfanNvbmJfbXV0YWJpbGl0eSAoSlNPTl9RVUVSWShqcywgJyQuZGF0 ZXRpbWUoKScpKTsKK0NSRUFURSBJTkRFWCBPTiB0ZXN0X2pzb25iX211dGFiaWxpdHkgKEpTT05f UVVFUlkoanMsICckLmEgPyAoQCA8ICQuZGF0ZXRpbWUoKSknKSk7CitDUkVBVEUgSU5ERVggT04g dGVzdF9qc29uYl9tdXRhYmlsaXR5IChKU09OX1FVRVJZKGpzLCAnJC5hID8gKEAuZGF0ZXRpbWUo KSA8ICQuZGF0ZXRpbWUoKSknKSk7CitFUlJPUjogIGZ1bmN0aW9ucyBpbiBpbmRleCBleHByZXNz aW9uIG11c3QgYmUgbWFya2VkIElNTVVUQUJMRQorQ1JFQVRFIElOREVYIE9OIHRlc3RfanNvbmJf bXV0YWJpbGl0eSAoSlNPTl9RVUVSWShqcywgJyQuYSA/IChALmRhdGV0aW1lKCkgPCAkLmRhdGV0 aW1lKCJISDpNSSBUWkgiKSknKSk7CitFUlJPUjogIGZ1bmN0aW9ucyBpbiBpbmRleCBleHByZXNz aW9uIG11c3QgYmUgbWFya2VkIElNTVVUQUJMRQorQ1JFQVRFIElOREVYIE9OIHRlc3RfanNvbmJf bXV0YWJpbGl0eSAoSlNPTl9RVUVSWShqcywgJyQuYSA/IChALmRhdGV0aW1lKCJISDpNSSBUWkgi KSA8ICQuZGF0ZXRpbWUoIkhIOk1JIFRaSCIpKScpKTsKK0NSRUFURSBJTkRFWCBPTiB0ZXN0X2pz b25iX211dGFiaWxpdHkgKEpTT05fUVVFUlkoanMsICckLmEgPyAoQC5kYXRldGltZSgiSEg6TUki KSA8ICQuZGF0ZXRpbWUoIllZLU1NLUREIEhIOk1JIikpJykpOworQ1JFQVRFIElOREVYIE9OIHRl c3RfanNvbmJfbXV0YWJpbGl0eSAoSlNPTl9RVUVSWShqcywgJyQuYSA/IChALmRhdGV0aW1lKCJI SDpNSSBUWkgiKSA8ICQuZGF0ZXRpbWUoIllZLU1NLUREIEhIOk1JIikpJykpOworRVJST1I6ICBm dW5jdGlvbnMgaW4gaW5kZXggZXhwcmVzc2lvbiBtdXN0IGJlIG1hcmtlZCBJTU1VVEFCTEUKK0NS RUFURSBJTkRFWCBPTiB0ZXN0X2pzb25iX211dGFiaWxpdHkgKEpTT05fUVVFUlkoanMsICckLmRh dGV0aW1lKCJISDpNSSBUWkgiKSA8ICR4JyBQQVNTSU5HICcxMjozNCc6OnRpbWV0eiBBUyB4KSk7 CitDUkVBVEUgSU5ERVggT04gdGVzdF9qc29uYl9tdXRhYmlsaXR5IChKU09OX1FVRVJZKGpzLCAn JC5kYXRldGltZSgiSEg6TUkgVFpIIikgPCAkeScgUEFTU0lORyAnMTI6MzQnOjp0aW1ldHogQVMg eCkpOworQ1JFQVRFIElOREVYIE9OIHRlc3RfanNvbmJfbXV0YWJpbGl0eSAoSlNPTl9RVUVSWShq cywgJyQuZGF0ZXRpbWUoKSA8ICR4JyBQQVNTSU5HICcxMjozNCc6OnRpbWV0eiBBUyB4KSk7CitF UlJPUjogIGZ1bmN0aW9ucyBpbiBpbmRleCBleHByZXNzaW9uIG11c3QgYmUgbWFya2VkIElNTVVU QUJMRQorQ1JFQVRFIElOREVYIE9OIHRlc3RfanNvbmJfbXV0YWJpbGl0eSAoSlNPTl9RVUVSWShq cywgJyQuZGF0ZXRpbWUoKSA8ICR4JyBQQVNTSU5HICcxMjM0Jzo6aW50IEFTIHgpKTsKK0NSRUFU RSBJTkRFWCBPTiB0ZXN0X2pzb25iX211dGFiaWxpdHkgKEpTT05fUVVFUlkoanMsICckLmRhdGV0 aW1lKCkgPyAoQCA9PSAkeCknIFBBU1NJTkcgJzEyOjM0Jzo6dGltZSBBUyB4KSk7CitFUlJPUjog IGZ1bmN0aW9ucyBpbiBpbmRleCBleHByZXNzaW9uIG11c3QgYmUgbWFya2VkIElNTVVUQUJMRQor Q1JFQVRFIElOREVYIE9OIHRlc3RfanNvbmJfbXV0YWJpbGl0eSAoSlNPTl9RVUVSWShqcywgJyQu ZGF0ZXRpbWUoIllZLU1NLUREIikgPyAoQCA9PSAkeCknIFBBU1NJTkcgJzIwMjAtMDctMTQnOjpk YXRlIEFTIHgpKTsKK0NSRUFURSBJTkRFWCBPTiB0ZXN0X2pzb25iX211dGFiaWxpdHkgKEpTT05f UVVFUlkoanMsICckWzEsICQuYSA/IChALmRhdGV0aW1lKCkgPT0gJHgpXScgUEFTU0lORyAnMTI6 MzQnOjp0aW1lIEFTIHgpKTsKK0VSUk9SOiAgZnVuY3Rpb25zIGluIGluZGV4IGV4cHJlc3Npb24g bXVzdCBiZSBtYXJrZWQgSU1NVVRBQkxFCitDUkVBVEUgSU5ERVggT04gdGVzdF9qc29uYl9tdXRh YmlsaXR5IChKU09OX1FVRVJZKGpzLCAnJFsxLCAwIHRvICQuYSA/IChALmRhdGV0aW1lKCkgPT0g JHgpXScgUEFTU0lORyAnMTI6MzQnOjp0aW1lIEFTIHgpKTsKK0VSUk9SOiAgZnVuY3Rpb25zIGlu IGluZGV4IGV4cHJlc3Npb24gbXVzdCBiZSBtYXJrZWQgSU1NVVRBQkxFCitDUkVBVEUgSU5ERVgg T04gdGVzdF9qc29uYl9tdXRhYmlsaXR5IChKU09OX1FVRVJZKGpzLCAnJFsxLCAkLmEgPyAoQC5k YXRldGltZSgiSEg6TUkiKSA9PSAkeCldJyBQQVNTSU5HICcxMjozNCc6OnRpbWUgQVMgeCkpOwor RFJPUCBUQUJMRSB0ZXN0X2pzb25iX211dGFiaWxpdHk7CmRpZmYgLS1naXQgYS9zcmMvdGVzdC9y ZWdyZXNzL3BhcmFsbGVsX3NjaGVkdWxlIGIvc3JjL3Rlc3QvcmVncmVzcy9wYXJhbGxlbF9zY2hl ZHVsZQppbmRleCBmMDk4N2ZmNTM3Li44NjRiZjA0ZmU3IDEwMDY0NAotLS0gYS9zcmMvdGVzdC9y ZWdyZXNzL3BhcmFsbGVsX3NjaGVkdWxlCisrKyBiL3NyYy90ZXN0L3JlZ3Jlc3MvcGFyYWxsZWxf c2NoZWR1bGUKQEAgLTEwMyw3ICsxMDMsNyBAQCB0ZXN0OiBzZWxlY3Rfdmlld3MgcG9ydGFsc19w MiBmb3JlaWduX2tleSBjbHVzdGVyIGRlcGVuZGVuY3kgZ3VjIGJpdG1hcG9wcyBjb21ibwogIyAt LS0tLS0tLS0tCiAjIEFub3RoZXIgZ3JvdXAgb2YgcGFyYWxsZWwgdGVzdHMgKEpTT04gcmVsYXRl ZCkKICMgLS0tLS0tLS0tLQotdGVzdDoganNvbiBqc29uYiBqc29uX2VuY29kaW5nIGpzb25wYXRo IGpzb25wYXRoX2VuY29kaW5nIGpzb25iX2pzb25wYXRoIHNxbGpzb24KK3Rlc3Q6IGpzb24ganNv bmIganNvbl9lbmNvZGluZyBqc29ucGF0aCBqc29ucGF0aF9lbmNvZGluZyBqc29uYl9qc29ucGF0 aCBzcWxqc29uIGpzb25fc3FsanNvbiBqc29uYl9zcWxqc29uCiAKICMgLS0tLS0tLS0tLQogIyBB bm90aGVyIGdyb3VwIG9mIHBhcmFsbGVsIHRlc3RzCmRpZmYgLS1naXQgYS9zcmMvdGVzdC9yZWdy ZXNzL3NxbC9qc29uX3NxbGpzb24uc3FsIGIvc3JjL3Rlc3QvcmVncmVzcy9zcWwvanNvbl9zcWxq c29uLnNxbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwLi40ZjMwZmE0NmI5 Ci0tLSAvZGV2L251bGwKKysrIGIvc3JjL3Rlc3QvcmVncmVzcy9zcWwvanNvbl9zcWxqc29uLnNx bApAQCAtMCwwICsxLDExIEBACistLSBKU09OX0VYSVNUUworCitTRUxFQ1QgSlNPTl9FWElTVFMo TlVMTCBGT1JNQVQgSlNPTiwgJyQnKTsKKworLS0gSlNPTl9WQUxVRQorCitTRUxFQ1QgSlNPTl9W QUxVRShOVUxMIEZPUk1BVCBKU09OLCAnJCcpOworCistLSBKU09OX1FVRVJZCisKK1NFTEVDVCBK U09OX1FVRVJZKE5VTEwgRk9STUFUIEpTT04sICckJyk7CmRpZmYgLS1naXQgYS9zcmMvdGVzdC9y ZWdyZXNzL3NxbC9qc29uYl9zcWxqc29uLnNxbCBiL3NyYy90ZXN0L3JlZ3Jlc3Mvc3FsL2pzb25i X3NxbGpzb24uc3FsCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAuLmI2NGM5 MDE3ZjUKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdGVzdC9yZWdyZXNzL3NxbC9qc29uYl9zcWxq c29uLnNxbApAQCAtMCwwICsxLDM1MCBAQAorLS0gSlNPTl9FWElTVFMKK1NFTEVDVCBKU09OX0VY SVNUUyhOVUxMOjpqc29uYiwgJyQnKTsKKworU0VMRUNUIEpTT05fRVhJU1RTKGpzb25iICdbXScs ICckJyk7CitTRUxFQ1QgSlNPTl9FWElTVFMoSlNPTl9PQkpFQ1QoUkVUVVJOSU5HIGpzb25iKSwg JyQnKTsKKworU0VMRUNUIEpTT05fRVhJU1RTKGpzb25iICcxJywgJyQnKTsKK1NFTEVDVCBKU09O X0VYSVNUUyhqc29uYiAnbnVsbCcsICckJyk7CitTRUxFQ1QgSlNPTl9FWElTVFMoanNvbmIgJ1td JywgJyQnKTsKKworU0VMRUNUIEpTT05fRVhJU1RTKGpzb25iICcxJywgJyQuYScpOworU0VMRUNU IEpTT05fRVhJU1RTKGpzb25iICcxJywgJ3N0cmljdCAkLmEnKTsgLS0gRkFMU0Ugb24gZXJyb3IK K1NFTEVDVCBKU09OX0VYSVNUUyhqc29uYiAnMScsICdzdHJpY3QgJC5hJyBFUlJPUiBPTiBFUlJP Uik7CitTRUxFQ1QgSlNPTl9FWElTVFMoanNvbmIgJ251bGwnLCAnJC5hJyk7CitTRUxFQ1QgSlNP Tl9FWElTVFMoanNvbmIgJ1tdJywgJyQuYScpOworU0VMRUNUIEpTT05fRVhJU1RTKGpzb25iICdb MSwgImFhYSIsIHsiYSI6IDF9XScsICdzdHJpY3QgJC5hJyk7IC0tIEZBTFNFIG9uIGVycm9yCitT RUxFQ1QgSlNPTl9FWElTVFMoanNvbmIgJ1sxLCAiYWFhIiwgeyJhIjogMX1dJywgJ2xheCAkLmEn KTsKK1NFTEVDVCBKU09OX0VYSVNUUyhqc29uYiAne30nLCAnJC5hJyk7CitTRUxFQ1QgSlNPTl9F WElTVFMoanNvbmIgJ3siYiI6IDEsICJhIjogMn0nLCAnJC5hJyk7CisKK1NFTEVDVCBKU09OX0VY SVNUUyhqc29uYiAnMScsICckLmEuYicpOworU0VMRUNUIEpTT05fRVhJU1RTKGpzb25iICd7ImEi OiB7ImIiOiAxfX0nLCAnJC5hLmInKTsKK1NFTEVDVCBKU09OX0VYSVNUUyhqc29uYiAneyJhIjog MSwgImIiOiAyfScsICckLmEuYicpOworCitTRUxFQ1QgSlNPTl9FWElTVFMoanNvbmIgJ3siYSI6 IDEsICJiIjogMn0nLCAnJC4qID8gKEAgPiAkeCknIFBBU1NJTkcgMSBBUyB4KTsKK1NFTEVDVCBK U09OX0VYSVNUUyhqc29uYiAneyJhIjogMSwgImIiOiAyfScsICckLiogPyAoQCA+ICR4KScgUEFT U0lORyAnMScgQVMgeCk7CitTRUxFQ1QgSlNPTl9FWElTVFMoanNvbmIgJ3siYSI6IDEsICJiIjog Mn0nLCAnJC4qID8gKEAgPiAkeCAmJiBAIDwgJHkpJyBQQVNTSU5HIDAgQVMgeCwgMiBBUyB5KTsK K1NFTEVDVCBKU09OX0VYSVNUUyhqc29uYiAneyJhIjogMSwgImIiOiAyfScsICckLiogPyAoQCA+ ICR4ICYmIEAgPCAkeSknIFBBU1NJTkcgMCBBUyB4LCAxIEFTIHkpOworCistLSBleHRlbnNpb246 IGJvb2xlYW4gZXhwcmVzc2lvbnMKK1NFTEVDVCBKU09OX0VYSVNUUyhqc29uYiAnMScsICckID4g MicpOworU0VMRUNUIEpTT05fRVhJU1RTKGpzb25iICcxJywgJyQuYSA+IDInIEVSUk9SIE9OIEVS Uk9SKTsKKworLS0gSlNPTl9WQUxVRQorCitTRUxFQ1QgSlNPTl9WQUxVRShOVUxMOjpqc29uYiwg JyQnKTsKKworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJ251bGwnLCAnJCcpOworU0VMRUNUIEpT T05fVkFMVUUoanNvbmIgJ251bGwnLCAnJCcgUkVUVVJOSU5HIGludCk7CisKK1NFTEVDVCBKU09O X1ZBTFVFKGpzb25iICd0cnVlJywgJyQnKTsKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICd0cnVl JywgJyQnIFJFVFVSTklORyBib29sKTsKKworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJzEyMycs ICckJyk7CitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnMTIzJywgJyQnIFJFVFVSTklORyBpbnQp ICsgMjM0OworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJzEyMycsICckJyBSRVRVUk5JTkcgdGV4 dCk7CisvKiBqc29uYiBieXRlYSA/Pz8gKi8KK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICcxMjMn LCAnJCcgUkVUVVJOSU5HIGJ5dGVhIEVSUk9SIE9OIEVSUk9SKTsKKworU0VMRUNUIEpTT05fVkFM VUUoanNvbmIgJzEuMjMnLCAnJCcpOworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJzEuMjMnLCAn JCcgUkVUVVJOSU5HIGludCk7CitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnIjEuMjMiJywgJyQn IFJFVFVSTklORyBudW1lcmljKTsKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICciMS4yMyInLCAn JCcgUkVUVVJOSU5HIGludCBFUlJPUiBPTiBFUlJPUik7CisKK1NFTEVDVCBKU09OX1ZBTFVFKGpz b25iICciYWFhIicsICckJyk7CitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnImFhYSInLCAnJCcg UkVUVVJOSU5HIHRleHQpOworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJyJhYWEiJywgJyQnIFJF VFVSTklORyBjaGFyKDUpKTsKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICciYWFhIicsICckJyBS RVRVUk5JTkcgY2hhcigyKSk7CitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnImFhYSInLCAnJCcg UkVUVVJOSU5HIGpzb24pOworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJyJhYWEiJywgJyQnIFJF VFVSTklORyBqc29uYik7CitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnImFhYSInLCAnJCcgUkVU VVJOSU5HIGpzb24gRVJST1IgT04gRVJST1IpOworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJyJh YWEiJywgJyQnIFJFVFVSTklORyBqc29uYiBFUlJPUiBPTiBFUlJPUik7CitTRUxFQ1QgSlNPTl9W QUxVRShqc29uYiAnIlwiYWFhXCIiJywgJyQnIFJFVFVSTklORyBqc29uKTsKK1NFTEVDVCBKU09O X1ZBTFVFKGpzb25iICciXCJhYWFcIiInLCAnJCcgUkVUVVJOSU5HIGpzb25iKTsKK1NFTEVDVCBK U09OX1ZBTFVFKGpzb25iICciYWFhIicsICckJyBSRVRVUk5JTkcgaW50KTsKK1NFTEVDVCBKU09O X1ZBTFVFKGpzb25iICciYWFhIicsICckJyBSRVRVUk5JTkcgaW50IEVSUk9SIE9OIEVSUk9SKTsK K1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICciYWFhIicsICckJyBSRVRVUk5JTkcgaW50IERFRkFV TFQgMTExIE9OIEVSUk9SKTsKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICciMTIzIicsICckJyBS RVRVUk5JTkcgaW50KSArIDIzNDsKKworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJyIyMDE3LTAy LTIwIicsICckJyBSRVRVUk5JTkcgZGF0ZSkgKyA5OworCistLSBUZXN0IE5VTEwgY2hlY2tzIGV4 ZWN1dGlvbiBpbiBkb21haW4gdHlwZXMKK0NSRUFURSBET01BSU4gc3FsanNvbmJfaW50X25vdF9u dWxsIEFTIGludCBOT1QgTlVMTDsKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICdudWxsJywgJyQn IFJFVFVSTklORyBzcWxqc29uYl9pbnRfbm90X251bGwpOworU0VMRUNUIEpTT05fVkFMVUUoanNv bmIgJ251bGwnLCAnJCcgUkVUVVJOSU5HIHNxbGpzb25iX2ludF9ub3RfbnVsbCBFUlJPUiBPTiBF UlJPUik7CitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnbnVsbCcsICckJyBSRVRVUk5JTkcgc3Fs anNvbmJfaW50X25vdF9udWxsIERFRkFVTFQgMiBPTiBFTVBUWSBFUlJPUiBPTiBFUlJPUik7CitT RUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnMScsICAnJC5hJyBSRVRVUk5JTkcgc3FsanNvbmJfaW50 X25vdF9udWxsIERFRkFVTFQgMiBPTiBFTVBUWSBFUlJPUiBPTiBFUlJPUik7CitTRUxFQ1QgSlNP Tl9WQUxVRShqc29uYiAnMScsICAnJC5hJyBSRVRVUk5JTkcgc3FsanNvbmJfaW50X25vdF9udWxs IERFRkFVTFQgTlVMTCBPTiBFTVBUWSBFUlJPUiBPTiBFUlJPUik7CitDUkVBVEUgVFlQRSByYWlu Ym93IEFTIEVOVU0gKCdyZWQnLCAnb3JhbmdlJywgJ3llbGxvdycsICdncmVlbicsICdibHVlJywg J3B1cnBsZScpOworQ1JFQVRFIERPTUFJTiByZ2IgQVMgcmFpbmJvdyBDSEVDSyAoVkFMVUUgSU4g KCdyZWQnLCAnZ3JlZW4nLCAnYmx1ZScpKTsKK1NFTEVDVCBKU09OX1ZBTFVFKCcicHVycGxlIic6 Ompzb25iLCAnbGF4ICRbKl0nIFJFVFVSTklORyByZ2IpOworU0VMRUNUIEpTT05fVkFMVUUoJyJw dXJwbGUiJzo6anNvbmIsICdsYXggJFsqXScgUkVUVVJOSU5HIHJnYiBFUlJPUiBPTiBFUlJPUik7 CisKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICdbXScsICckJyk7CitTRUxFQ1QgSlNPTl9WQUxV RShqc29uYiAnW10nLCAnJCcgRVJST1IgT04gRVJST1IpOworU0VMRUNUIEpTT05fVkFMVUUoanNv bmIgJ3t9JywgJyQnKTsKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICd7fScsICckJyBFUlJPUiBP TiBFUlJPUik7CisKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICcxJywgJyQuYScpOworU0VMRUNU IEpTT05fVkFMVUUoanNvbmIgJzEnLCAnc3RyaWN0ICQuYScgRVJST1IgT04gRVJST1IpOworU0VM RUNUIEpTT05fVkFMVUUoanNvbmIgJzEnLCAnc3RyaWN0ICQuYScgREVGQVVMVCAnZXJyb3InIE9O IEVSUk9SKTsKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICcxJywgJ2xheCAkLmEnIEVSUk9SIE9O IEVSUk9SKTsKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICcxJywgJ2xheCAkLmEnIEVSUk9SIE9O IEVNUFRZIEVSUk9SIE9OIEVSUk9SKTsKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICcxJywgJ3N0 cmljdCAkLmEnIERFRkFVTFQgMiBPTiBFUlJPUik7CitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAn MScsICdsYXggJC5hJyBERUZBVUxUIDIgT04gRVJST1IpOworU0VMRUNUIEpTT05fVkFMVUUoanNv bmIgJzEnLCAnbGF4ICQuYScgREVGQVVMVCAnMicgT04gRVJST1IpOworU0VMRUNUIEpTT05fVkFM VUUoanNvbmIgJzEnLCAnbGF4ICQuYScgTlVMTCBPTiBFTVBUWSBERUZBVUxUICcyJyBPTiBFUlJP Uik7CitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnMScsICdsYXggJC5hJyBERUZBVUxUICcyJyBP TiBFTVBUWSBERUZBVUxUICczJyBPTiBFUlJPUik7CitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAn MScsICdsYXggJC5hJyBFUlJPUiBPTiBFTVBUWSBERUZBVUxUICczJyBPTiBFUlJPUik7CisKK1NF TEVDVCBKU09OX1ZBTFVFKGpzb25iICdbMSwyXScsICckWypdJyBFUlJPUiBPTiBFUlJPUik7CitT RUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnWzEsMl0nLCAnJFsqXScgREVGQVVMVCAnMCcgT04gRVJS T1IpOworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJ1siICJdJywgJyRbKl0nIFJFVFVSTklORyBp bnQgRVJST1IgT04gRVJST1IpOworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJ1siICJdJywgJyRb Kl0nIFJFVFVSTklORyBpbnQgREVGQVVMVCAyICsgMyBPTiBFUlJPUik7CitTRUxFQ1QgSlNPTl9W QUxVRShqc29uYiAnWyIxIl0nLCAnJFsqXScgUkVUVVJOSU5HIGludCBERUZBVUxUIDIgKyAzIE9O IEVSUk9SKTsKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICdbIjEiXScsICckWypdJyBSRVRVUk5J TkcgaW50IEZPUk1BVCBKU09OKTsgLS0gUkVUVVJOSU5HIEZPUk1BVCBub3QgYWxsb3dlZAorCist LSBSRVRVR05JTkcgcHNldWRvLXR5cGVzIG5vdCBhbGxvd2VkCitTRUxFQ1QgSlNPTl9WQUxVRShq c29uYiAnWyIxIl0nLCAnJFsqXScgUkVUVVJOSU5HIHJlY29yZCk7CisKK1NFTEVDVAorCXgsCisJ SlNPTl9WQUxVRSgKKwkJanNvbmIgJ3siYSI6IDEsICJiIjogMn0nLAorCQknJC4qID8gKEAgPiAk eCknIFBBU1NJTkcgeCBBUyB4CisJCVJFVFVSTklORyBpbnQKKwkJREVGQVVMVCAtMSBPTiBFTVBU WQorCQlERUZBVUxUIC0yIE9OIEVSUk9SCisJKSB5CitGUk9NCisJZ2VuZXJhdGVfc2VyaWVzKDAs IDIpIHg7CisKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICdudWxsJywgJyRhJyBQQVNTSU5HIHBv aW50ICcgKDEsIDIgKScgQVMgYSk7CitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnbnVsbCcsICck YScgUEFTU0lORyBwb2ludCAnICgxLCAyICknIEFTIGEgUkVUVVJOSU5HIHBvaW50KTsKK1NFTEVD VCBKU09OX1ZBTFVFKGpzb25iICdudWxsJywgJyRhJyBQQVNTSU5HIHBvaW50ICcgKDEsIDIgKScg QVMgYSBSRVRVUk5JTkcgcG9pbnQgRVJST1IgT04gRVJST1IpOworCistLSBUZXN0IFBBU1NJTkcg YW5kIFJFVFVSTklORyBkYXRlL3RpbWUgdHlwZXMKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICdu dWxsJywgJyR0cycgUEFTU0lORyB0aW1lc3RhbXB0eiAnMjAxOC0wMi0yMSAxMjozNDo1NiArMTAn IEFTIHRzKTsKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICdudWxsJywgJyR0cycgUEFTU0lORyB0 aW1lc3RhbXB0eiAnMjAxOC0wMi0yMSAxMjozNDo1NiArMTAnIEFTIHRzIFJFVFVSTklORyB0aW1l c3RhbXB0eik7CitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAnbnVsbCcsICckdHMnIFBBU1NJTkcg dGltZXN0YW1wdHogJzIwMTgtMDItMjEgMTI6MzQ6NTYgKzEwJyBBUyB0cyBSRVRVUk5JTkcgdGlt ZXN0YW1wKTsKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICdudWxsJywgJyR0cycgUEFTU0lORyBk YXRlICcyMDE4LTAyLTIxIDEyOjM0OjU2ICsxMCcgQVMgdHMgUkVUVVJOSU5HIGRhdGUpOworU0VM RUNUIEpTT05fVkFMVUUoanNvbmIgJ251bGwnLCAnJHRzJyBQQVNTSU5HIHRpbWUgJzIwMTgtMDIt MjEgMTI6MzQ6NTYgKzEwJyBBUyB0cyBSRVRVUk5JTkcgdGltZSk7CitTRUxFQ1QgSlNPTl9WQUxV RShqc29uYiAnbnVsbCcsICckdHMnIFBBU1NJTkcgdGltZXR6ICcyMDE4LTAyLTIxIDEyOjM0OjU2 ICsxMCcgQVMgdHMgUkVUVVJOSU5HIHRpbWV0eik7CitTRUxFQ1QgSlNPTl9WQUxVRShqc29uYiAn bnVsbCcsICckdHMnIFBBU1NJTkcgdGltZXN0YW1wICcyMDE4LTAyLTIxIDEyOjM0OjU2ICsxMCcg QVMgdHMgUkVUVVJOSU5HIHRpbWVzdGFtcCk7CisKKy0tIEFsc28gdGVzdCBSRVRVUk5JTkcganNv bltiXQorU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJ251bGwnLCAnJHRzJyBQQVNTSU5HIHRpbWVz dGFtcHR6ICcyMDE4LTAyLTIxIDEyOjM0OjU2ICsxMCcgQVMgdHMgUkVUVVJOSU5HIGpzb24pOwor U0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJ251bGwnLCAnJHRzJyBQQVNTSU5HIHRpbWVzdGFtcHR6 ICcyMDE4LTAyLTIxIDEyOjM0OjU2ICsxMCcgQVMgdHMgUkVUVVJOSU5HIGpzb25iKTsKKworLS0g SlNPTl9RVUVSWQorCitTRUxFQ1QKKwlKU09OX1FVRVJZKGpzLCAnJCcpLAorCUpTT05fUVVFUlko anMsICckJyBXSVRIT1VUIFdSQVBQRVIpLAorCUpTT05fUVVFUlkoanMsICckJyBXSVRIIENPTkRJ VElPTkFMIFdSQVBQRVIpLAorCUpTT05fUVVFUlkoanMsICckJyBXSVRIIFVOQ09ORElUSU9OQUwg QVJSQVkgV1JBUFBFUiksCisJSlNPTl9RVUVSWShqcywgJyQnIFdJVEggQVJSQVkgV1JBUFBFUikK K0ZST00KKwkoVkFMVUVTCisJCShqc29uYiAnbnVsbCcpLAorCQkoJzEyLjMnKSwKKwkJKCd0cnVl JyksCisJCSgnImFhYSInKSwKKwkJKCdbMSwgbnVsbCwgIjIiXScpLAorCQkoJ3siYSI6IDEsICJi IjogWzJdfScpCisJKSBmb28oanMpOworCitTRUxFQ1QKKwlKU09OX1FVRVJZKGpzLCAnc3RyaWN0 ICRbKl0nKSBBUyAidW5zcGVjIiwKKwlKU09OX1FVRVJZKGpzLCAnc3RyaWN0ICRbKl0nIFdJVEhP VVQgV1JBUFBFUikgQVMgIndpdGhvdXQiLAorCUpTT05fUVVFUlkoanMsICdzdHJpY3QgJFsqXScg V0lUSCBDT05ESVRJT05BTCBXUkFQUEVSKSBBUyAid2l0aCBjb25kIiwKKwlKU09OX1FVRVJZKGpz LCAnc3RyaWN0ICRbKl0nIFdJVEggVU5DT05ESVRJT05BTCBBUlJBWSBXUkFQUEVSKSBBUyAid2l0 aCB1bmNvbmQiLAorCUpTT05fUVVFUlkoanMsICdzdHJpY3QgJFsqXScgV0lUSCBBUlJBWSBXUkFQ UEVSKSBBUyAid2l0aCIKK0ZST00KKwkoVkFMVUVTCisJCShqc29uYiAnMScpLAorCQkoJ1tdJyks CisJCSgnW251bGxdJyksCisJCSgnWzEyLjNdJyksCisJCSgnW3RydWVdJyksCisJCSgnWyJhYWEi XScpLAorCQkoJ1tbMSwgMiwgM11dJyksCisJCSgnW3siYSI6IDEsICJiIjogWzJdfV0nKSwKKwkJ KCdbMSwgIjIiLCBudWxsLCBbM11dJykKKwkpIGZvbyhqcyk7CisKK1NFTEVDVCBKU09OX1FVRVJZ KGpzb25iICciYWFhIicsICckJyBSRVRVUk5JTkcgdGV4dCk7CitTRUxFQ1QgSlNPTl9RVUVSWShq c29uYiAnImFhYSInLCAnJCcgUkVUVVJOSU5HIHRleHQgS0VFUCBRVU9URVMpOworU0VMRUNUIEpT T05fUVVFUlkoanNvbmIgJyJhYWEiJywgJyQnIFJFVFVSTklORyB0ZXh0IEtFRVAgUVVPVEVTIE9O IFNDQUxBUiBTVFJJTkcpOworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJyJhYWEiJywgJyQnIFJF VFVSTklORyB0ZXh0IE9NSVQgUVVPVEVTKTsKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICciYWFh IicsICckJyBSRVRVUk5JTkcgdGV4dCBPTUlUIFFVT1RFUyBPTiBTQ0FMQVIgU1RSSU5HKTsKK1NF TEVDVCBKU09OX1FVRVJZKGpzb25iICciYWFhIicsICckJyBPTUlUIFFVT1RFUyBFUlJPUiBPTiBF UlJPUik7CitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnImFhYSInLCAnJCcgUkVUVVJOSU5HIGpz b24gT01JVCBRVU9URVMgRVJST1IgT04gRVJST1IpOworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIg JyJhYWEiJywgJyQnIFJFVFVSTklORyBieXRlYSBGT1JNQVQgSlNPTiBPTUlUIFFVT1RFUyBFUlJP UiBPTiBFUlJPUik7CisKKy0tIFFVT1RFUyBiZWhhdmlvciBzaG91bGQgbm90IGJlIHNwZWNpZmll ZCB3aGVuIFdJVEggV1JBUFBFUiB1c2VkOgorLS0gU2hvdWxkIGZhaWwKK1NFTEVDVCBKU09OX1FV RVJZKGpzb25iICdbMV0nLCAnJCcgV0lUSCBXUkFQUEVSIE9NSVQgUVVPVEVTKTsKK1NFTEVDVCBK U09OX1FVRVJZKGpzb25iICdbMV0nLCAnJCcgV0lUSCBXUkFQUEVSIEtFRVAgUVVPVEVTKTsKK1NF TEVDVCBKU09OX1FVRVJZKGpzb25iICdbMV0nLCAnJCcgV0lUSCBDT05ESVRJT05BTCBXUkFQUEVS IEtFRVAgUVVPVEVTKTsKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbMV0nLCAnJCcgV0lUSCBD T05ESVRJT05BTCBXUkFQUEVSIE9NSVQgUVVPVEVTKTsKKy0tIFNob3VsZCBzdWNjZWVkCitTRUxF Q1QgSlNPTl9RVUVSWShqc29uYiAnWzFdJywgJyQnIFdJVEhPVVQgV1JBUFBFUiBPTUlUIFFVT1RF Uyk7CitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnWzFdJywgJyQnIFdJVEhPVVQgV1JBUFBFUiBL RUVQIFFVT1RFUyk7CisKKy0tIHRlc3QgUVVPVEVTIGJlaGF2aW9yLgorU0VMRUNUIEpTT05fUVVF UlkoanNvbmIneyJyZWMiOiAiezEsMiwzfSJ9JywgJyQucmVjJyByZXR1cm5pbmcgaW50W10gb21p dCBxdW90ZXMpOworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIneyJyZWMiOiAiezEsMiwzfSJ9Jywg JyQucmVjJyByZXR1cm5pbmcgaW50W10ga2VlcCBxdW90ZXMpOworU0VMRUNUIEpTT05fUVVFUlko anNvbmIneyJyZWMiOiAiezEsMiwzfSJ9JywgJyQucmVjJyByZXR1cm5pbmcgaW50W10ga2VlcCBx dW90ZXMgZXJyb3Igb24gZXJyb3IpOworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIneyJyZWMiOiAi WzEsMl0ifScsICckLnJlYycgcmV0dXJuaW5nIGludDRyYW5nZSBvbWl0IHF1b3Rlcyk7CitTRUxF Q1QgSlNPTl9RVUVSWShqc29uYid7InJlYyI6ICJbMSwyXSJ9JywgJyQucmVjJyByZXR1cm5pbmcg aW50NHJhbmdlIGtlZXAgcXVvdGVzKTsKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iJ3sicmVjIjog IlsxLDJdIn0nLCAnJC5yZWMnIAlyZXR1cm5pbmcgaW50NHJhbmdlIGtlZXAgcXVvdGVzIGVycm9y IG9uIGVycm9yKTsKKworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ1tdJywgJyRbKl0nKTsKK1NF TEVDVCBKU09OX1FVRVJZKGpzb25iICdbXScsICckWypdJyBOVUxMIE9OIEVNUFRZKTsKK1NFTEVD VCBKU09OX1FVRVJZKGpzb25iICdbXScsICckWypdJyBFTVBUWSBPTiBFTVBUWSk7CitTRUxFQ1Qg SlNPTl9RVUVSWShqc29uYiAnW10nLCAnJFsqXScgRU1QVFkgQVJSQVkgT04gRU1QVFkpOworU0VM RUNUIEpTT05fUVVFUlkoanNvbmIgJ1tdJywgJyRbKl0nIEVNUFRZIE9CSkVDVCBPTiBFTVBUWSk7 CitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnW10nLCAnJFsqXScgRVJST1IgT04gRU1QVFkpOwor U0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ1tdJywgJyRbKl0nIERFRkFVTFQgJyJlbXB0eSInIE9O IEVNUFRZKTsKKworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ1tdJywgJyRbKl0nIEVSUk9SIE9O IEVNUFRZIE5VTEwgT04gRVJST1IpOworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ1tdJywgJyRb Kl0nIEVSUk9SIE9OIEVNUFRZIEVNUFRZIEFSUkFZIE9OIEVSUk9SKTsKK1NFTEVDVCBKU09OX1FV RVJZKGpzb25iICdbXScsICckWypdJyBFUlJPUiBPTiBFTVBUWSBFTVBUWSBPQkpFQ1QgT04gRVJS T1IpOworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ1tdJywgJyRbKl0nIEVSUk9SIE9OIEVNUFRZ IEVSUk9SIE9OIEVSUk9SKTsKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbXScsICckWypdJyBF UlJPUiBPTiBFUlJPUik7CisKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbMSwyXScsICckWypd JyBFUlJPUiBPTiBFUlJPUik7CitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnWzEsMl0nLCAnJFsq XScgREVGQVVMVCAnImVtcHR5IicgT04gRVJST1IpOworCitTRUxFQ1QgSlNPTl9RVUVSWShqc29u YiAnWzEsMl0nLCAnJCcgUkVUVVJOSU5HIGpzb24pOworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIg J1sxLDJdJywgJyQnIFJFVFVSTklORyBqc29uIEZPUk1BVCBKU09OKTsKK1NFTEVDVCBKU09OX1FV RVJZKGpzb25iICdbMSwyXScsICckJyBSRVRVUk5JTkcganNvbmIpOworU0VMRUNUIEpTT05fUVVF UlkoanNvbmIgJ1sxLDJdJywgJyQnIFJFVFVSTklORyBqc29uYiBGT1JNQVQgSlNPTik7CitTRUxF Q1QgSlNPTl9RVUVSWShqc29uYiAnWzEsMl0nLCAnJCcgUkVUVVJOSU5HIHRleHQpOworU0VMRUNU IEpTT05fUVVFUlkoanNvbmIgJ1sxLDJdJywgJyQnIFJFVFVSTklORyBjaGFyKDEwKSk7CitTRUxF Q1QgSlNPTl9RVUVSWShqc29uYiAnWzEsMl0nLCAnJCcgUkVUVVJOSU5HIGNoYXIoMykpOworU0VM RUNUIEpTT05fUVVFUlkoanNvbmIgJ1sxLDJdJywgJyQnIFJFVFVSTklORyB0ZXh0IEZPUk1BVCBK U09OKTsKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbMSwyXScsICckJyBSRVRVUk5JTkcgYnl0 ZWEpOworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ1sxLDJdJywgJyQnIFJFVFVSTklORyBieXRl YSBGT1JNQVQgSlNPTik7CisKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbMSwyXScsICckWypd JyBSRVRVUk5JTkcgYnl0ZWEgRU1QVFkgT0JKRUNUIE9OIEVSUk9SKTsKK1NFTEVDVCBKU09OX1FV RVJZKGpzb25iICdbMSwyXScsICckWypdJyBSRVRVUk5JTkcgYnl0ZWEgRk9STUFUIEpTT04gRU1Q VFkgT0JKRUNUIE9OIEVSUk9SKTsKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbMSwyXScsICck WypdJyBSRVRVUk5JTkcganNvbiBFTVBUWSBPQkpFQ1QgT04gRVJST1IpOworU0VMRUNUIEpTT05f UVVFUlkoanNvbmIgJ1sxLDJdJywgJyRbKl0nIFJFVFVSTklORyBqc29uYiBFTVBUWSBPQkpFQ1Qg T04gRVJST1IpOworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ1szLDRdJywgJyRbKl0nIFJFVFVS TklORyBiaWdpbnRbXSBFTVBUWSBPQkpFQ1QgT04gRVJST1IpOworU0VMRUNUIEpTT05fUVVFUlko anNvbmIgJyJbMyw0XSInLCAnJFsqXScgUkVUVVJOSU5HIGJpZ2ludFtdIEVNUFRZIE9CSkVDVCBP TiBFUlJPUik7CisKKy0tIFJFVFVHTklORyBwc2V1ZG8tdHlwZXMgbm90IGFsbG93ZWQKK1NFTEVD VCBKU09OX1FVRVJZKGpzb25iICdbMyw0XScsICckWypdJyBSRVRVUk5JTkcgYW55YXJyYXkgRU1Q VFkgT0JKRUNUIE9OIEVSUk9SKTsKKworU0VMRUNUCisJeCwgeSwKKwlKU09OX1FVRVJZKAorCQlq c29uYiAnWzEsMiwzLDQsNSxudWxsXScsCisJCSckWypdID8gKEAgPj0gJHggJiYgQCA8PSAkeSkn CisJCVBBU1NJTkcgeCBBUyB4LCB5IEFTIHkKKwkJV0lUSCBDT05ESVRJT05BTCBXUkFQUEVSCisJ CUVNUFRZIEFSUkFZIE9OIEVNUFRZCisJKSBsaXN0CitGUk9NCisJZ2VuZXJhdGVfc2VyaWVzKDAs IDQpIHgsCisJZ2VuZXJhdGVfc2VyaWVzKDAsIDQpIHk7CisKKy0tIHJlY29yZCB0eXBlIHJldHVy bmluZyB3aXRoIHF1b3RlcyBiZWhhdmlvci4KK0NSRUFURSBUWVBFIGNvbXBfYWJjIEFTIChhIHRl eHQsIGIgaW50LCBjIHRpbWVzdGFtcCk7CitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYid7InJlYyI6 ICIoYWJjLDQyLDAxLjAyLjIwMDMpIn0nLCAnJC5yZWMnIHJldHVybmluZyBjb21wX2FiYyBvbWl0 IHF1b3Rlcyk7CitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYid7InJlYyI6ICIoYWJjLDQyLDAxLjAy LjIwMDMpIn0nLCAnJC5yZWMnIHJldHVybmluZyBjb21wX2FiYyBrZWVwIHF1b3Rlcyk7CitTRUxF Q1QgSlNPTl9RVUVSWShqc29uYid7InJlYyI6ICIoYWJjLDQyLDAxLjAyLjIwMDMpIn0nLCAnJC5y ZWMnIHJldHVybmluZyBjb21wX2FiYyBrZWVwIHF1b3RlcyBlcnJvciBvbiBlcnJvcik7CitEUk9Q IFRZUEUgY29tcF9hYmM7CisKKy0tIEV4dGVuc2lvbjogcmVjb3JkIHR5cGVzIHJldHVybmluZwor Q1JFQVRFIFRZUEUgc3FsanNvbmJfcmVjIEFTIChhIGludCwgdCB0ZXh0LCBqcyBqc29uLCBqYiBq c29uYiwganNhIGpzb25bXSk7CitDUkVBVEUgVFlQRSBzcWxqc29uYl9yZWNhIEFTIChyZWNhIHNx bGpzb25iX3JlY1tdKTsKKworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ1t7ImEiOiAxLCAiYiI6 ICJmb28iLCAidCI6ICJhYWEiLCAianMiOiBbMSwgIjIiLCB7fV0sICJqYiI6IHsieCI6IFsxLCAi MiIsIHt9XX19LCAgeyJhIjogMn1dJywgJyRbMF0nIFJFVFVSTklORyBzcWxqc29uYl9yZWMpOwor U0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ1t7ImEiOiAiYSIsICJiIjogImZvbyIsICJ0IjogImFh YSIsICJqcyI6IFsxLCAiMiIsIHt9XSwgImpiIjogeyJ4IjogWzEsICIyIiwge31dfX0sICB7ImEi OiAyfV0nLCAnJFswXScgUkVUVVJOSU5HIHNxbGpzb25iX3JlYyBFUlJPUiBPTiBFUlJPUik7CitT RUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnW3siYSI6ICJhIiwgImIiOiAiZm9vIiwgInQiOiAiYWFh IiwgImpzIjogWzEsICIyIiwge31dLCAiamIiOiB7IngiOiBbMSwgIjIiLCB7fV19fSwgIHsiYSI6 IDJ9XScsICckWzBdJyBSRVRVUk5JTkcgc3FsanNvbmJfcmVjKTsKK1NFTEVDVCAqIEZST00gdW5u ZXN0KChKU09OX1FVRVJZKGpzb25iICd7ImpzYSI6ICBbeyJhIjogMSwgImIiOiBbImZvbyJdfSwg eyJhIjogMiwgImMiOiB7fX0sIDEyM119JywgJyQnIFJFVFVSTklORyBzcWxqc29uYl9yZWMpKS5q c2EpOworU0VMRUNUICogRlJPTSB1bm5lc3QoKEpTT05fUVVFUlkoanNvbmIgJ3sicmVjYSI6IFt7 ImEiOiAxLCAidCI6IFsiZm9vIiwgW11dfSwgeyJhIjogMiwgImpiIjogW3t9LCB0cnVlXX1dfScs ICckJyBSRVRVUk5JTkcgc3FsanNvbmJfcmVjYSkpLnJlY2EpOworCitTRUxFQ1QgSlNPTl9RVUVS WShqc29uYiAnW3siYSI6IDEsICJiIjogImZvbyIsICJ0IjogImFhYSIsICJqcyI6IFsxLCAiMiIs IHt9XSwgImpiIjogeyJ4IjogWzEsICIyIiwge31dfX0sICB7ImEiOiAyfV0nLCAnJFswXScgUkVU VVJOSU5HIGpzb25wYXRoKTsKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdbeyJhIjogMSwgImIi OiAiZm9vIiwgInQiOiAiYWFhIiwgImpzIjogWzEsICIyIiwge31dLCAiamIiOiB7IngiOiBbMSwg IjIiLCB7fV19fSwgIHsiYSI6IDJ9XScsICckWzBdJyBSRVRVUk5JTkcganNvbnBhdGggRVJST1Ig T04gRVJST1IpOworCistLSBFeHRlbnNpb246IGFycmF5IHR5cGVzIHJldHVybmluZworU0VMRUNU IEpTT05fUVVFUlkoanNvbmIgJ1sxLDIsbnVsbCwiMyJdJywgJyRbKl0nIFJFVFVSTklORyBpbnRb XSBXSVRIIFdSQVBQRVIpOworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ1sxLDIsbnVsbCwiYSJd JywgJyRbKl0nIFJFVFVSTklORyBpbnRbXSBXSVRIIFdSQVBQRVIgRVJST1IgT04gRVJST1IpOwor U0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ1sxLDIsbnVsbCwiYSJdJywgJyRbKl0nIFJFVFVSTklO RyBpbnRbXSBXSVRIIFdSQVBQRVIpOworU0VMRUNUICogRlJPTSB1bm5lc3QoSlNPTl9RVUVSWShq c29uYiAnW3siYSI6IDEsICJ0IjogWyJmb28iLCBbXV19LCB7ImEiOiAyLCAiamIiOiBbe30sIHRy dWVdfV0nLCAnJCcgUkVUVVJOSU5HIHNxbGpzb25iX3JlY1tdKSk7CisKKy0tIEV4dGVuc2lvbjog ZG9tYWluIHR5cGVzIHJldHVybmluZworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJ3siYSI6IDF9 JywgJyQuYScgUkVUVVJOSU5HIHNxbGpzb25iX2ludF9ub3RfbnVsbCk7CitTRUxFQ1QgSlNPTl9R VUVSWShqc29uYiAneyJhIjogMX0nLCAnJC5iJyBSRVRVUk5JTkcgc3FsanNvbmJfaW50X25vdF9u dWxsKTsKKworLS0gVGVzdCB0aW1lc3RhbXB0eiBwYXNzaW5nIGFuZCBvdXRwdXQKK1NFTEVDVCBK U09OX1FVRVJZKGpzb25iICdudWxsJywgJyR0cycgUEFTU0lORyB0aW1lc3RhbXB0eiAnMjAxOC0w Mi0yMSAxMjozNDo1NiArMTAnIEFTIHRzKTsKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdudWxs JywgJyR0cycgUEFTU0lORyB0aW1lc3RhbXB0eiAnMjAxOC0wMi0yMSAxMjozNDo1NiArMTAnIEFT IHRzIFJFVFVSTklORyBqc29uKTsKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICdudWxsJywgJyR0 cycgUEFTU0lORyB0aW1lc3RhbXB0eiAnMjAxOC0wMi0yMSAxMjozNDo1NiArMTAnIEFTIHRzIFJF VFVSTklORyBqc29uYik7CisKKy0tIFRlc3QgY29uc3RyYWludHMKKworQ1JFQVRFIFRBQkxFIHRl c3RfanNvbmJfY29uc3RyYWludHMgKAorCWpzIHRleHQsCisJaSBpbnQsCisJeCBqc29uYiBERUZB VUxUIEpTT05fUVVFUlkoanNvbmIgJ1sxLDJdJywgJyRbKl0nIFdJVEggV1JBUFBFUikKKwlDT05T VFJBSU5UIHRlc3RfanNvbmJfY29uc3RyYWludDEKKwkJQ0hFQ0sgKGpzIElTIEpTT04pCisJQ09O U1RSQUlOVCB0ZXN0X2pzb25iX2NvbnN0cmFpbnQyCisJCUNIRUNLIChKU09OX0VYSVNUUyhqczo6 anNvbmIsICckLmEnIFBBU1NJTkcgaSArIDUgQVMgaW50LCBpOjp0ZXh0IEFTIHR4dCwgYXJyYXlb MSwyLDNdIGFzIGFycikpCisJQ09OU1RSQUlOVCB0ZXN0X2pzb25iX2NvbnN0cmFpbnQzCisJCUNI RUNLIChKU09OX1ZBTFVFKGpzOjpqc29uYiwgJyQuYScgUkVUVVJOSU5HIGludCBERUZBVUxUICcx MicgT04gRU1QVFkgRVJST1IgT04gRVJST1IpID4gaSkKKwlDT05TVFJBSU5UIHRlc3RfanNvbmJf Y29uc3RyYWludDQKKwkJQ0hFQ0sgKEpTT05fUVVFUlkoanM6Ompzb25iLCAnJC5hJyBXSVRIIENP TkRJVElPTkFMIFdSQVBQRVIgRU1QVFkgT0JKRUNUIE9OIEVSUk9SKSA8IGpzb25iICdbMTBdJykK KwlDT05TVFJBSU5UIHRlc3RfanNvbmJfY29uc3RyYWludDUKKwkJQ0hFQ0sgKEpTT05fUVVFUlko anM6Ompzb25iLCAnJC5hJyBSRVRVUk5JTkcgY2hhcig1KSBPTUlUIFFVT1RFUyBFTVBUWSBBUlJB WSBPTiBFTVBUWSkgPiAgJ2EnIENPTExBVEUgIkMiKQorKTsKKworXGQgdGVzdF9qc29uYl9jb25z dHJhaW50cworCitTRUxFQ1QgY2hlY2tfY2xhdXNlCitGUk9NIGluZm9ybWF0aW9uX3NjaGVtYS5j aGVja19jb25zdHJhaW50cworV0hFUkUgY29uc3RyYWludF9uYW1lIExJS0UgJ3Rlc3RfanNvbmJf Y29uc3RyYWludCUnCitPUkRFUiBCWSAxOworCitTRUxFQ1QgcGdfZ2V0X2V4cHIoYWRiaW4sIGFk cmVsaWQpCitGUk9NIHBnX2F0dHJkZWYKK1dIRVJFIGFkcmVsaWQgPSAndGVzdF9qc29uYl9jb25z dHJhaW50cyc6OnJlZ2NsYXNzCitPUkRFUiBCWSAxOworCitJTlNFUlQgSU5UTyB0ZXN0X2pzb25i X2NvbnN0cmFpbnRzIFZBTFVFUyAoJycsIDEpOworSU5TRVJUIElOVE8gdGVzdF9qc29uYl9jb25z dHJhaW50cyBWQUxVRVMgKCcxJywgMSk7CitJTlNFUlQgSU5UTyB0ZXN0X2pzb25iX2NvbnN0cmFp bnRzIFZBTFVFUyAoJ1tdJyk7CitJTlNFUlQgSU5UTyB0ZXN0X2pzb25iX2NvbnN0cmFpbnRzIFZB TFVFUyAoJ3siYiI6IDF9JywgMSk7CitJTlNFUlQgSU5UTyB0ZXN0X2pzb25iX2NvbnN0cmFpbnRz IFZBTFVFUyAoJ3siYSI6IDF9JywgMSk7CitJTlNFUlQgSU5UTyB0ZXN0X2pzb25iX2NvbnN0cmFp bnRzIFZBTFVFUyAoJ3siYSI6IDd9JywgMSk7CitJTlNFUlQgSU5UTyB0ZXN0X2pzb25iX2NvbnN0 cmFpbnRzIFZBTFVFUyAoJ3siYSI6IDEwfScsIDEpOworCitEUk9QIFRBQkxFIHRlc3RfanNvbmJf Y29uc3RyYWludHM7CisKKy0tIFRlc3QgbXV0YWJpbGlseSBvZiBxdWVyeSBmdW5jdGlvbnMKK0NS RUFURSBUQUJMRSB0ZXN0X2pzb25iX211dGFiaWxpdHkoanMganNvbmIpOworQ1JFQVRFIElOREVY IE9OIHRlc3RfanNvbmJfbXV0YWJpbGl0eSAoSlNPTl9RVUVSWShqcywgJyQnKSk7CitDUkVBVEUg SU5ERVggT04gdGVzdF9qc29uYl9tdXRhYmlsaXR5IChKU09OX1FVRVJZKGpzLCAnJC5hWzBdJykp OworQ1JFQVRFIElOREVYIE9OIHRlc3RfanNvbmJfbXV0YWJpbGl0eSAoSlNPTl9RVUVSWShqcywg JyQuZGF0ZXRpbWUoKScpKTsKK0NSRUFURSBJTkRFWCBPTiB0ZXN0X2pzb25iX211dGFiaWxpdHkg KEpTT05fUVVFUlkoanMsICckLmEgPyAoQCA8ICQuZGF0ZXRpbWUoKSknKSk7CitDUkVBVEUgSU5E RVggT04gdGVzdF9qc29uYl9tdXRhYmlsaXR5IChKU09OX1FVRVJZKGpzLCAnJC5hID8gKEAuZGF0 ZXRpbWUoKSA8ICQuZGF0ZXRpbWUoKSknKSk7CitDUkVBVEUgSU5ERVggT04gdGVzdF9qc29uYl9t dXRhYmlsaXR5IChKU09OX1FVRVJZKGpzLCAnJC5hID8gKEAuZGF0ZXRpbWUoKSA8ICQuZGF0ZXRp bWUoIkhIOk1JIFRaSCIpKScpKTsKK0NSRUFURSBJTkRFWCBPTiB0ZXN0X2pzb25iX211dGFiaWxp dHkgKEpTT05fUVVFUlkoanMsICckLmEgPyAoQC5kYXRldGltZSgiSEg6TUkgVFpIIikgPCAkLmRh dGV0aW1lKCJISDpNSSBUWkgiKSknKSk7CitDUkVBVEUgSU5ERVggT04gdGVzdF9qc29uYl9tdXRh YmlsaXR5IChKU09OX1FVRVJZKGpzLCAnJC5hID8gKEAuZGF0ZXRpbWUoIkhIOk1JIikgPCAkLmRh dGV0aW1lKCJZWS1NTS1ERCBISDpNSSIpKScpKTsKK0NSRUFURSBJTkRFWCBPTiB0ZXN0X2pzb25i X211dGFiaWxpdHkgKEpTT05fUVVFUlkoanMsICckLmEgPyAoQC5kYXRldGltZSgiSEg6TUkgVFpI IikgPCAkLmRhdGV0aW1lKCJZWS1NTS1ERCBISDpNSSIpKScpKTsKK0NSRUFURSBJTkRFWCBPTiB0 ZXN0X2pzb25iX211dGFiaWxpdHkgKEpTT05fUVVFUlkoanMsICckLmRhdGV0aW1lKCJISDpNSSBU WkgiKSA8ICR4JyBQQVNTSU5HICcxMjozNCc6OnRpbWV0eiBBUyB4KSk7CitDUkVBVEUgSU5ERVgg T04gdGVzdF9qc29uYl9tdXRhYmlsaXR5IChKU09OX1FVRVJZKGpzLCAnJC5kYXRldGltZSgiSEg6 TUkgVFpIIikgPCAkeScgUEFTU0lORyAnMTI6MzQnOjp0aW1ldHogQVMgeCkpOworQ1JFQVRFIElO REVYIE9OIHRlc3RfanNvbmJfbXV0YWJpbGl0eSAoSlNPTl9RVUVSWShqcywgJyQuZGF0ZXRpbWUo KSA8ICR4JyBQQVNTSU5HICcxMjozNCc6OnRpbWV0eiBBUyB4KSk7CitDUkVBVEUgSU5ERVggT04g dGVzdF9qc29uYl9tdXRhYmlsaXR5IChKU09OX1FVRVJZKGpzLCAnJC5kYXRldGltZSgpIDwgJHgn IFBBU1NJTkcgJzEyMzQnOjppbnQgQVMgeCkpOworQ1JFQVRFIElOREVYIE9OIHRlc3RfanNvbmJf bXV0YWJpbGl0eSAoSlNPTl9RVUVSWShqcywgJyQuZGF0ZXRpbWUoKSA/IChAID09ICR4KScgUEFT U0lORyAnMTI6MzQnOjp0aW1lIEFTIHgpKTsKK0NSRUFURSBJTkRFWCBPTiB0ZXN0X2pzb25iX211 dGFiaWxpdHkgKEpTT05fUVVFUlkoanMsICckLmRhdGV0aW1lKCJZWS1NTS1ERCIpID8gKEAgPT0g JHgpJyBQQVNTSU5HICcyMDIwLTA3LTE0Jzo6ZGF0ZSBBUyB4KSk7CitDUkVBVEUgSU5ERVggT04g dGVzdF9qc29uYl9tdXRhYmlsaXR5IChKU09OX1FVRVJZKGpzLCAnJFsxLCAkLmEgPyAoQC5kYXRl dGltZSgpID09ICR4KV0nIFBBU1NJTkcgJzEyOjM0Jzo6dGltZSBBUyB4KSk7CitDUkVBVEUgSU5E RVggT04gdGVzdF9qc29uYl9tdXRhYmlsaXR5IChKU09OX1FVRVJZKGpzLCAnJFsxLCAwIHRvICQu YSA/IChALmRhdGV0aW1lKCkgPT0gJHgpXScgUEFTU0lORyAnMTI6MzQnOjp0aW1lIEFTIHgpKTsK K0NSRUFURSBJTkRFWCBPTiB0ZXN0X2pzb25iX211dGFiaWxpdHkgKEpTT05fUVVFUlkoanMsICck WzEsICQuYSA/IChALmRhdGV0aW1lKCJISDpNSSIpID09ICR4KV0nIFBBU1NJTkcgJzEyOjM0Jzo6 dGltZSBBUyB4KSk7CitEUk9QIFRBQkxFIHRlc3RfanNvbmJfbXV0YWJpbGl0eTsKZGlmZiAtLWdp dCBhL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0IGIvc3JjL3Rvb2xzL3BnaW5kZW50 L3R5cGVkZWZzLmxpc3QKaW5kZXggNWZkNDZiN2JkMS4uYmM2ZGE0YjRkMiAxMDA2NDQKLS0tIGEv c3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKKysrIGIvc3JjL3Rvb2xzL3BnaW5kZW50 L3R5cGVkZWZzLmxpc3QKQEAgLTEyNTEsNiArMTI1MSw3IEBAIEpvaW4KIEpvaW5Db3N0V29ya3Nw YWNlCiBKb2luRG9tYWluCiBKb2luRXhwcgorSnNvbkZ1bmNFeHByCiBKb2luSGFzaEVudHJ5CiBK b2luUGF0aAogSm9pblBhdGhFeHRyYURhdGEKQEAgLTEyNjEsMTggKzEyNjIsMjcgQEAgSnNPYmpl Y3QKIEpzVmFsdWUKIEpzb25BZ2dDb25zdHJ1Y3RvcgogSnNvbkFnZ1N0YXRlCitKc29uQXJndW1l bnQKIEpzb25BcnJheUFnZwogSnNvbkFycmF5Q29uc3RydWN0b3IKIEpzb25BcnJheVF1ZXJ5Q29u c3RydWN0b3IKIEpzb25CYXNlT2JqZWN0SW5mbworSnNvbkJlaGF2aW9yCitKc29uQmVoYXZpb3JU eXBlCitKc29uQ29lcmNpb24KIEpzb25Db25zdHJ1Y3RvckV4cHIKIEpzb25Db25zdHJ1Y3RvckV4 cHJTdGF0ZQogSnNvbkNvbnN0cnVjdG9yVHlwZQogSnNvbkVuY29kaW5nCitKc29uRXhwcgorSnNv bkV4cHJPcAorSnNvbkV4cHJQb3N0RXZhbFN0YXRlCitKc29uRXhwclN0YXRlCiBKc29uRm9ybWF0 CiBKc29uRm9ybWF0VHlwZQogSnNvbkhhc2hFbnRyeQogSnNvbklzUHJlZGljYXRlCitKc29uSXRl bVR5cGUKIEpzb25JdGVyYXRlU3RyaW5nVmFsdWVzQWN0aW9uCiBKc29uS2V5VmFsdWUKIEpzb25M ZXhDb250ZXh0CkBAIC0xMjkwLDYgKzEzMDAsNyBAQCBKc29uUGFyc2VDb250ZXh0CiBKc29uUGFy c2VFcnJvclR5cGUKIEpzb25QYXRoCiBKc29uUGF0aEJvb2wKK0pzb25QYXRoRGF0YXR5cGVTdGF0 dXMKIEpzb25QYXRoRXhlY0NvbnRleHQKIEpzb25QYXRoRXhlY1Jlc3VsdAogSnNvblBhdGhHaW5B ZGRQYXRoSXRlbUZ1bmMKQEAgLTEzMDIsMTAgKzEzMTMsMTUgQEAgSnNvblBhdGhHaW5QYXRoSXRl bQogSnNvblBhdGhJdGVtCiBKc29uUGF0aEl0ZW1UeXBlCiBKc29uUGF0aEtleXdvcmQKK0pzb25Q YXRoTXV0YWJsZUNvbnRleHQKIEpzb25QYXRoUGFyc2VJdGVtCiBKc29uUGF0aFBhcnNlUmVzdWx0 CiBKc29uUGF0aFByZWRpY2F0ZUNhbGxiYWNrCiBKc29uUGF0aFN0cmluZworSnNvblBhdGhWYXJD YWxsYmFjaworSnNvblBhdGhWYXJpYWJsZQorSnNvblBhdGhWYXJpYWJsZUV2YWxDb250ZXh0CitK c29uUXVvdGVzCiBKc29uUmV0dXJuaW5nCiBKc29uU2NhbGFyRXhwcgogSnNvblNlbUFjdGlvbgpA QCAtMTMyMiw2ICsxMzM4LDcgQEAgSnNvblZhbHVlRXhwcgogSnNvblZhbHVlTGlzdAogSnNvblZh bHVlTGlzdEl0ZXJhdG9yCiBKc29uVmFsdWVUeXBlCitKc29uV3JhcHBlcgogSnNvbmIKIEpzb25i QWdnU3RhdGUKIEpzb25iQ29udGFpbmVyCi0tIAoyLjM1LjMKCg== --00000000000078edb1060f38208c Content-Type: application/octet-stream; name="v34-0008-JSON_TABLE.patch" Content-Disposition: attachment; filename="v34-0008-JSON_TABLE.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lrj7oapj7 RnJvbSA4NmNmMWM4NmFlNWNhNTVlMzJlYjUzYmNlMTMzZTMwNmIyMzU1MjcwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbWl0IExhbmdvdGUgPGFtaXRsYW5AcG9zdGdyZXNxbC5vcmc+ CkRhdGU6IFRodSwgMTggSmFuIDIwMjQgMTg6MDA6MDYgKzA5MDAKU3ViamVjdDogW1BBVENIIHYz NCA4LzhdIEpTT05fVEFCTEUKTUlNRS1WZXJzaW9uOiAxLjAKQ29udGVudC1UeXBlOiB0ZXh0L3Bs YWluOyBjaGFyc2V0PVVURi04CkNvbnRlbnQtVHJhbnNmZXItRW5jb2Rpbmc6IDhiaXQKClRoaXMg ZmVhdHVyZSBhbGxvd3MganNvbmIgZGF0YSB0byBiZSB0cmVhdGVkIGFzIGEgdGFibGUgYW5kIHRo dXMKdXNlZCBpbiBhIEZST00gY2xhdXNlIGxpa2Ugb3RoZXIgdGFidWxhciBkYXRhLiBEYXRhIGNh biBiZSBzZWxlY3RlZApmcm9tIHRoZSBqc29uYiB1c2luZyBqc29ucGF0aCBleHByZXNzaW9ucywg YW5kIGhvaXN0ZWQgb3V0IG9mIG5lc3RlZApzdHJ1Y3R1cmVzIGluIHRoZSBqc29uYiB0byBmb3Jt IG11bHRpcGxlIHJvd3MsIG1vcmUgb3IgbGVzcyBsaWtlIGFuCm91dGVyIGpvaW4uCgpUaGlzIGFs c28gYWRkcyB0aGUgUExBTiBjbGF1c2VzIGZvciBKU09OX1RBQkxFLCB3aGljaCBhbGxvdyB0aGUg dXNlcgp0byBzcGVjaWZ5IGhvdyBkYXRhIGZyb20gbmVzdGVkIHBhdGhzIGFyZSBqb2luZWQsIGFs bG93aW5nCmNvbnNpZGVyYWJsZSBmcmVlZG9tIGluIHNoYXBpbmcgdGhlIHRhYnVsYXIgb3V0cHV0 IG9mIEpTT05fVEFCTEUuClBMQU4gREVGQVVMVCBhbGxvd3MgdGhlIHVzZXIgdG8gc3BlY2lmeSB0 aGUgZ2xvYmFsIHN0cmF0ZWdpZXMgd2hlbgpkZWFsaW5nIHdpdGggc2libGluZyBvciBjaGlsZCBu ZXN0ZWQgcGF0aHMuIFRoZSBpcyBvZnRlbiBzdWZmaWNpZW50CnRvIGFjaGlldmUgdGhlIG5lY2Vz c2FyeSBnb2FsLCBhbmQgaXMgY29uc2lkZXJhYmx5IHNpbXBsZXIgdGhhbiB0aGUKZnVsbCBQTEFO IGNsYXVzZSwgd2hpY2ggYWxsb3dzIHRoZSB1c2VyIHRvIHNwZWNpZnkgdGhlIHN0cmF0ZWd5IHRv IGJlCnVzZWQgZm9yIGVhY2ggbmFtZWQgbmVzdGVkIHBhdGguCgpBdXRob3I6IE5pa2l0YSBHbHVr aG92IDxuLmdsdWhvdkBwb3N0Z3Jlc3Byby5ydT4KQXV0aG9yOiBUZW9kb3IgU2lnYWV2IDx0ZW9k b3JAc2lnYWV2LnJ1PgpBdXRob3I6IE9sZWcgQmFydHVub3YgPG9iYXJ0dW5vdkBnbWFpbC5jb20+ CkF1dGhvcjogQWxleGFuZGVyIEtvcm90a292IDxhZWtvcm90a292QGdtYWlsLmNvbT4KQXV0aG9y OiBBbmRyZXcgRHVuc3RhbiA8YW5kcmV3QGR1bnNsYW5lLm5ldD4KQXV0aG9yOiBBbWl0IExhbmdv dGUgPGFtaXRsYW5nb3RlMDlAZ21haWwuY29tPgpBdXRob3I6IEppYW4gSGUgPGppYW4udW5pdmVy c2FsaXR5QGdtYWlsLmNvbT4KClJldmlld2VycyBoYXZlIGluY2x1ZGVkIChpbiBubyBwYXJ0aWN1 bGFyIG9yZGVyKSBBbmRyZXMgRnJldW5kLCBBbGV4YW5kZXIKS29yb3Rrb3YsIFBhdmVsIFN0ZWh1 bGUsIEFuZHJldyBBbHN1cCwgRXJpayBSaWprZXJzLCBaaWhvbmcgWXUsCkhpbWFuc2h1IFVwYWRo eWF5YSwgRGFuaWVsIEd1c3RhZnNzb24sIEp1c3RpbiBQcnl6YnksIMOBbHZhcm8gSGVycmVyYSwK amlhbiBoZQoKRGlzY3Vzc2lvbjogaHR0cHM6Ly9wb3N0Z3IuZXMvbS9jZDBiYjkzNS0wMTU4LTc4 YTctMDhiNS05MDQ4ODZkZWFjNGJAcG9zdGdyZXNwcm8ucnUKRGlzY3Vzc2lvbjogaHR0cHM6Ly9w b3N0Z3IuZXMvbS8yMDIyMDYxNjIzMzEzMC5ycGFyaXZhZmlwdDZkb2ozQGFsYXAzLmFuYXJhemVs LmRlCkRpc2N1c3Npb246IGh0dHBzOi8vcG9zdGdyLmVzL20vYWJkOWI4M2ItYWE2Ni1mMjMwLTNk NmQtNzM0ODE3ZjA5OTVkJTQwcG9zdGdyZXNxbC5vcmcKRGlzY3Vzc2lvbjogaHR0cHM6Ly9wb3N0 Z3IuZXMvbS9DQStIaXdxRTRYVGRmYjFuVz1Pam95X3RRU1JoWXQtcV9rYjZpNWQ0eGNLeXJMQzFO YmdAbWFpbC5nbWFpbC5jb20KLS0tCiBkb2Mvc3JjL3NnbWwvZnVuYy5zZ21sICAgICAgICAgICAg ICAgICAgICAgICAgfCAgNTEwICsrKysrKysKIHNyYy9iYWNrZW5kL2NhdGFsb2cvc3FsX2ZlYXR1 cmVzLnR4dCAgICAgICAgICB8ICAgIDYgKy0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL2V4cGxhaW4u YyAgICAgICAgICAgICAgICB8ICAgIDggKy0KIHNyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNFeHBy SW50ZXJwLmMgICAgICAgICB8ICAgIDYgKwogc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZVRhYmxl RnVuY3NjYW4uYyAgICAgIHwgICAyNyArLQogc3JjL2JhY2tlbmQvbm9kZXMvbWFrZWZ1bmNzLmMg ICAgICAgICAgICAgICAgIHwgICA3NCArCiBzcmMvYmFja2VuZC9ub2Rlcy9ub2RlRnVuY3MuYyAg ICAgICAgICAgICAgICAgfCAgIDM4ICsKIHNyYy9iYWNrZW5kL3BhcnNlci9NYWtlZmlsZSAgICAg ICAgICAgICAgICAgICB8ICAgIDEgKwogc3JjL2JhY2tlbmQvcGFyc2VyL2dyYW0ueSAgICAgICAg ICAgICAgICAgICAgIHwgIDMwNiArKysrLQogc3JjL2JhY2tlbmQvcGFyc2VyL21lc29uLmJ1aWxk ICAgICAgICAgICAgICAgIHwgICAgMSArCiBzcmMvYmFja2VuZC9wYXJzZXIvcGFyc2VfY2xhdXNl LmMgICAgICAgICAgICAgfCAgIDE0ICstCiBzcmMvYmFja2VuZC9wYXJzZXIvcGFyc2VfZXhwci5j ICAgICAgICAgICAgICAgfCAgIDUzICstCiBzcmMvYmFja2VuZC9wYXJzZXIvcGFyc2VfanNvbnRh YmxlLmMgICAgICAgICAgfCAgNzE4ICsrKysrKysrKysKIHNyYy9iYWNrZW5kL3BhcnNlci9wYXJz ZV9yZWxhdGlvbi5jICAgICAgICAgICB8ICAgIDUgKy0KIHNyYy9iYWNrZW5kL3BhcnNlci9wYXJz ZV90YXJnZXQuYyAgICAgICAgICAgICB8ICAgIDMgKwogc3JjL2JhY2tlbmQvdXRpbHMvYWR0L2pz b25wYXRoX2V4ZWMuYyAgICAgICAgIHwgIDU0NyArKysrKysrKwogc3JjL2JhY2tlbmQvdXRpbHMv YWR0L3J1bGV1dGlscy5jICAgICAgICAgICAgIHwgIDI3OSArKystCiBzcmMvaW5jbHVkZS9ub2Rl cy9leGVjbm9kZXMuaCAgICAgICAgICAgICAgICAgfCAgICAyICsKIHNyYy9pbmNsdWRlL25vZGVz L21ha2VmdW5jcy5oICAgICAgICAgICAgICAgICB8ICAgIDcgKwogc3JjL2luY2x1ZGUvbm9kZXMv cGFyc2Vub2Rlcy5oICAgICAgICAgICAgICAgIHwgIDEwNiArKwogc3JjL2luY2x1ZGUvbm9kZXMv cHJpbW5vZGVzLmggICAgICAgICAgICAgICAgIHwgICA2MCArLQogc3JjL2luY2x1ZGUvcGFyc2Vy L2t3bGlzdC5oICAgICAgICAgICAgICAgICAgIHwgICAgNCArCiBzcmMvaW5jbHVkZS9wYXJzZXIv cGFyc2VfY2xhdXNlLmggICAgICAgICAgICAgfCAgICAzICsKIHNyYy9pbmNsdWRlL3V0aWxzL2pz b25wYXRoLmggICAgICAgICAgICAgICAgICB8ICAgIDMgKwogc3JjL2ludGVyZmFjZXMvZWNwZy90 ZXN0L2VjcGdfc2NoZWR1bGUgICAgICAgIHwgICAgMSArCiAuLi4vdGVzdC9leHBlY3RlZC9zcWwt c3FsanNvbl9xdWVyeWZ1bmNzLmMgICAgfCAgMTMyICsrCiAuLi4vZXhwZWN0ZWQvc3FsLXNxbGpz b25fcXVlcnlmdW5jcy5zdGRlcnIgICAgfCAgIDIwICsKIC4uLi9leHBlY3RlZC9zcWwtc3FsanNv bl9xdWVyeWZ1bmNzLnN0ZG91dCAgICB8ICAgIDAKIHNyYy9pbnRlcmZhY2VzL2VjcGcvdGVzdC9z cWwvTWFrZWZpbGUgICAgICAgICB8ICAgIDEgKwogc3JjL2ludGVyZmFjZXMvZWNwZy90ZXN0L3Nx bC9tZXNvbi5idWlsZCAgICAgIHwgICAgMSArCiAuLi4vZWNwZy90ZXN0L3NxbC9zcWxqc29uX3F1 ZXJ5ZnVuY3MucGdjICAgICAgfCAgIDMyICsKIHNyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvanNv bl9zcWxqc29uLm91dCAgICB8ICAgIDYgKwogc3JjL3Rlc3QvcmVncmVzcy9leHBlY3RlZC9qc29u Yl9zcWxqc29uLm91dCAgIHwgMTIxOSArKysrKysrKysrKysrKysrKwogc3JjL3Rlc3QvcmVncmVz cy9zcWwvanNvbl9zcWxqc29uLnNxbCAgICAgICAgIHwgICAgNCArCiBzcmMvdGVzdC9yZWdyZXNz L3NxbC9qc29uYl9zcWxqc29uLnNxbCAgICAgICAgfCAgNjgxICsrKysrKysrKwogc3JjL3Rvb2xz L3BnaW5kZW50L3R5cGVkZWZzLmxpc3QgICAgICAgICAgICAgIHwgICAxNiArCiAzNiBmaWxlcyBj aGFuZ2VkLCA0ODQ4IGluc2VydGlvbnMoKyksIDQ2IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUg MTAwNjQ0IHNyYy9iYWNrZW5kL3BhcnNlci9wYXJzZV9qc29udGFibGUuYwogY3JlYXRlIG1vZGUg MTAwNjQ0IHNyYy9pbnRlcmZhY2VzL2VjcGcvdGVzdC9leHBlY3RlZC9zcWwtc3FsanNvbl9xdWVy eWZ1bmNzLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzcmMvaW50ZXJmYWNlcy9lY3BnL3Rlc3QvZXhw ZWN0ZWQvc3FsLXNxbGpzb25fcXVlcnlmdW5jcy5zdGRlcnIKIGNyZWF0ZSBtb2RlIDEwMDY0NCBz cmMvaW50ZXJmYWNlcy9lY3BnL3Rlc3QvZXhwZWN0ZWQvc3FsLXNxbGpzb25fcXVlcnlmdW5jcy5z dGRvdXQKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzcmMvaW50ZXJmYWNlcy9lY3BnL3Rlc3Qvc3FsL3Nx bGpzb25fcXVlcnlmdW5jcy5wZ2MKCmRpZmYgLS1naXQgYS9kb2Mvc3JjL3NnbWwvZnVuYy5zZ21s IGIvZG9jL3NyYy9zZ21sL2Z1bmMuc2dtbAppbmRleCAyMWZkNjcxMmI4Li4yNjdjZmFmMmM5IDEw MDY0NAotLS0gYS9kb2Mvc3JjL3NnbWwvZnVuYy5zZ21sCisrKyBiL2RvYy9zcmMvc2dtbC9mdW5j LnNnbWwKQEAgLTE4MzI1LDYgKzE4MzI1LDUxNiBAQCAkLiogPyAoQCBsaWtlX3JlZ2V4ICJeXFxk KyQiKQogCiAgICA8L3NlY3QzPgogICA8L3NlY3QyPgorCisgPHNlY3QyIGlkPSJmdW5jdGlvbnMt c3FsanNvbi10YWJsZSI+CisgIDx0aXRsZT5KU09OX1RBQkxFPC90aXRsZT4KKyAgPGluZGV4dGVy bT4KKyAgIDxwcmltYXJ5Pmpzb25fdGFibGU8L3ByaW1hcnk+CisgIDwvaW5kZXh0ZXJtPgorCisg IDxwYXJhPgorICAgPGZ1bmN0aW9uPmpzb25fdGFibGU8L2Z1bmN0aW9uPiBpcyBhbiBTUUwvSlNP TiBmdW5jdGlvbiB3aGljaAorICAgcXVlcmllcyA8YWNyb255bT5KU09OPC9hY3JvbnltPiBkYXRh CisgICBhbmQgcHJlc2VudHMgdGhlIHJlc3VsdHMgYXMgYSByZWxhdGlvbmFsIHZpZXcsIHdoaWNo IGNhbiBiZSBhY2Nlc3NlZCBhcyBhCisgICByZWd1bGFyIFNRTCB0YWJsZS4gWW91IGNhbiBvbmx5 IHVzZSA8ZnVuY3Rpb24+anNvbl90YWJsZTwvZnVuY3Rpb24+IGluc2lkZSB0aGUKKyAgIDxsaXRl cmFsPkZST008L2xpdGVyYWw+IGNsYXVzZSBvZiBhIDxsaXRlcmFsPlNFTEVDVDwvbGl0ZXJhbD4g c3RhdGVtZW50LgorICA8L3BhcmE+CisKKyAgPHBhcmE+CisgICBUYWtpbmcgSlNPTiBkYXRhIGFz IGlucHV0LCA8ZnVuY3Rpb24+anNvbl90YWJsZTwvZnVuY3Rpb24+IHVzZXMKKyAgIGEgcGF0aCBl eHByZXNzaW9uIHRvIGV4dHJhY3QgYSBwYXJ0IG9mIHRoZSBwcm92aWRlZCBkYXRhIHRoYXQKKyAg IHdpbGwgYmUgdXNlZCBhcyBhIDxmaXJzdHRlcm0+cm93IHBhdHRlcm48L2ZpcnN0dGVybT4gZm9y IHRoZQorICAgY29uc3RydWN0ZWQgdmlldy4gRWFjaCBTUUwvSlNPTiBpdGVtIGF0IHRoZSB0b3Ag bGV2ZWwgb2YgdGhlIHJvdyBwYXR0ZXJuIHNlcnZlcworICAgYXMgdGhlIHNvdXJjZSBmb3IgYSBz ZXBhcmF0ZSByb3cgaW4gdGhlIGNvbnN0cnVjdGVkIHJlbGF0aW9uYWwgdmlldy4KKyAgPC9wYXJh PgorCisgIDxwYXJhPgorICAgVG8gc3BsaXQgdGhlIHJvdyBwYXR0ZXJuIGludG8gY29sdW1ucywg PGZ1bmN0aW9uPmpzb25fdGFibGU8L2Z1bmN0aW9uPgorICAgcHJvdmlkZXMgdGhlIDxsaXRlcmFs PkNPTFVNTlM8L2xpdGVyYWw+IGNsYXVzZSB0aGF0IGRlZmluZXMgdGhlCisgICBzY2hlbWEgb2Yg dGhlIGNyZWF0ZWQgdmlldy4gRm9yIGVhY2ggY29sdW1uIHRvIGJlIGNvbnN0cnVjdGVkLAorICAg dGhpcyBjbGF1c2UgcHJvdmlkZXMgYSBzZXBhcmF0ZSBwYXRoIGV4cHJlc3Npb24gdGhhdCBldmFs dWF0ZXMKKyAgIHRoZSByb3cgcGF0dGVybiwgZXh0cmFjdHMgYSBKU09OIGl0ZW0sIGFuZCByZXR1 cm5zIGl0IGFzIGEKKyAgIHNlcGFyYXRlIFNRTCB2YWx1ZSBmb3IgdGhlIHNwZWNpZmllZCBjb2x1 bW4uIElmIHRoZSByZXF1aXJlZCB2YWx1ZQorICAgaXMgc3RvcmVkIGluIGEgbmVzdGVkIGxldmVs IG9mIHRoZSByb3cgcGF0dGVybiwgaXQgY2FuIGJlIGV4dHJhY3RlZAorICAgdXNpbmcgdGhlIDxs aXRlcmFsPk5FU1RFRCBQQVRIPC9saXRlcmFsPiBzdWJjbGF1c2UuIEpvaW5pbmcgdGhlCisgICBj b2x1bW5zIHJldHVybmVkIGJ5IDxsaXRlcmFsPk5FU1RFRCBQQVRIPC9saXRlcmFsPiBjYW4gYWRk IG11bHRpcGxlCisgICBuZXcgcm93cyB0byB0aGUgY29uc3RydWN0ZWQgdmlldy4gU3VjaCByb3dz IGFyZSBjYWxsZWQKKyAgIDxmaXJzdHRlcm0+Y2hpbGQgcm93czwvZmlyc3R0ZXJtPiwgYXMgb3Bw b3NlZCB0byB0aGUgPGZpcnN0dGVybT5wYXJlbnQgcm93PC9maXJzdHRlcm0+CisgICB0aGF0IGdl bmVyYXRlcyB0aGVtLgorICA8L3BhcmE+CisKKyAgPHBhcmE+CisgICBUaGUgcm93cyBwcm9kdWNl ZCBieSA8ZnVuY3Rpb24+SlNPTl9UQUJMRTwvZnVuY3Rpb24+IGFyZSBsYXRlcmFsbHkKKyAgIGpv aW5lZCB0byB0aGUgcm93IHRoYXQgZ2VuZXJhdGVkIHRoZW0sIHNvIHlvdSBkbyBub3QgaGF2ZSB0 byBleHBsaWNpdGx5IGpvaW4KKyAgIHRoZSBjb25zdHJ1Y3RlZCB2aWV3IHdpdGggdGhlIG9yaWdp bmFsIHRhYmxlIGhvbGRpbmcgPGFjcm9ueW0+SlNPTjwvYWNyb255bT4KKyAgIGRhdGEuIE9wdGlv bmFsbHksIHlvdSBjYW4gc3BlY2lmeSBob3cgdG8gam9pbiB0aGUgY29sdW1ucyByZXR1cm5lZAor ICAgYnkgPGxpdGVyYWw+TkVTVEVEIFBBVEg8L2xpdGVyYWw+IHVzaW5nIHRoZSA8bGl0ZXJhbD5Q TEFOPC9saXRlcmFsPiBjbGF1c2UuCisgIDwvcGFyYT4KKworICA8cGFyYT4KKyAgIEVhY2ggPGxp dGVyYWw+TkVTVEVEIFBBVEg8L2xpdGVyYWw+IGNsYXVzZSBjYW4gZ2VuZXJhdGUgb25lIG9yIG1v cmUKKyAgIGNvbHVtbnMuIENvbHVtbnMgcHJvZHVjZWQgYnkgPGxpdGVyYWw+TkVTVEVEIFBBVEg8 L2xpdGVyYWw+cyBhdCB0aGUKKyAgIHNhbWUgbGV2ZWwgYXJlIGNvbnNpZGVyZWQgdG8gYmUgPGZp cnN0dGVybT5zaWJsaW5nczwvZmlyc3R0ZXJtPiwKKyAgIHdoaWxlIGEgY29sdW1uIHByb2R1Y2Vk IGJ5IGEgPGxpdGVyYWw+TkVTVEVEIFBBVEg8L2xpdGVyYWw+IGlzCisgICBjb25zaWRlcmVkIHRv IGJlIGEgY2hpbGQgb2YgdGhlIGNvbHVtbiBwcm9kdWNlZCBieSBhCisgICA8bGl0ZXJhbD5ORVNU RUQgUEFUSDwvbGl0ZXJhbD4gb3Igcm93IGV4cHJlc3Npb24gYXQgYSBoaWdoZXIgbGV2ZWwuCisg ICBTaWJsaW5nIGNvbHVtbnMgYXJlIGFsd2F5cyBqb2luZWQgZmlyc3QuIE9uY2UgdGhleSBhcmUg cHJvY2Vzc2VkLAorICAgdGhlIHJlc3VsdGluZyByb3dzIGFyZSBqb2luZWQgdG8gdGhlIHBhcmVu dCByb3cuCisgIDwvcGFyYT4KKworICA8cGFyYT4KKyAgIFRoZSBzeW50YXggaXM6CisgIDwvcGFy YT4KKworPHN5bm9wc2lzPgorSlNPTl9UQUJMRSAoCisgIDxyZXBsYWNlYWJsZT5jb250ZXh0X2l0 ZW08L3JlcGxhY2VhYmxlPiwgPHJlcGxhY2VhYmxlPnBhdGhfZXhwcmVzc2lvbjwvcmVwbGFjZWFi bGU+IDxvcHRpb25hbD4gQVMgPHJlcGxhY2VhYmxlPmpzb25fcGF0aF9uYW1lPC9yZXBsYWNlYWJs ZT4gPC9vcHRpb25hbD4gPG9wdGlvbmFsPiBQQVNTSU5HIHsgPHJlcGxhY2VhYmxlPnZhbHVlPC9y ZXBsYWNlYWJsZT4gQVMgPHJlcGxhY2VhYmxlPnZhcm5hbWU8L3JlcGxhY2VhYmxlPiB9IDxvcHRp b25hbD4sIC4uLjwvb3B0aW9uYWw+IDwvb3B0aW9uYWw+CisgIENPTFVNTlMgKCA8cmVwbGFjZWFi bGUgY2xhc3M9InBhcmFtZXRlciI+anNvbl90YWJsZV9jb2x1bW48L3JlcGxhY2VhYmxlPiA8b3B0 aW9uYWw+LCAuLi48L29wdGlvbmFsPiApCisgIDxvcHRpb25hbD4geyA8bGl0ZXJhbD5FUlJPUjwv bGl0ZXJhbD4gfCA8bGl0ZXJhbD5FTVBUWTwvbGl0ZXJhbD4gfSA8bGl0ZXJhbD5PTiBFUlJPUjwv bGl0ZXJhbD4gPC9vcHRpb25hbD4KKyAgPG9wdGlvbmFsPgorICAgIFBMQU4gKCA8cmVwbGFjZWFi bGUgY2xhc3M9InBhcmFtZXRlciI+anNvbl90YWJsZV9wbGFuPC9yZXBsYWNlYWJsZT4gKSB8Cisg ICAgUExBTiBERUZBVUxUICggeyBJTk5FUiB8IE9VVEVSIH0gPG9wdGlvbmFsPiAsIHsgQ1JPU1Mg fCBVTklPTiB9IDwvb3B0aW9uYWw+CisgICAgICAgICAgICAgICAgIHwgeyBDUk9TUyB8IFVOSU9O IH0gPG9wdGlvbmFsPiAsIHsgSU5ORVIgfCBPVVRFUiB9IDwvb3B0aW9uYWw+ICkKKyAgPC9vcHRp b25hbD4KKykKKworPHBocmFzZT4KK3doZXJlIDxyZXBsYWNlYWJsZSBjbGFzcz0icGFyYW1ldGVy Ij5qc29uX3RhYmxlX2NvbHVtbjwvcmVwbGFjZWFibGU+IGlzOgorPC9waHJhc2U+CisgICAgPHJl cGxhY2VhYmxlPm5hbWU8L3JlcGxhY2VhYmxlPiA8cmVwbGFjZWFibGU+dHlwZTwvcmVwbGFjZWFi bGU+IDxvcHRpb25hbD4gUEFUSCA8cmVwbGFjZWFibGU+anNvbl9wYXRoX3NwZWNpZmljYXRpb248 L3JlcGxhY2VhYmxlPiA8L29wdGlvbmFsPgorICAgICAgICA8b3B0aW9uYWw+IHsgV0lUSE9VVCB8 IFdJVEggeyBDT05ESVRJT05BTCB8IDxvcHRpb25hbD5VTkNPTkRJVElPTkFMPC9vcHRpb25hbD4g fSB9IDxvcHRpb25hbD4gQVJSQVkgPC9vcHRpb25hbD4gV1JBUFBFUiA8L29wdGlvbmFsPgorICAg ICAgICA8b3B0aW9uYWw+IHsgS0VFUCB8IE9NSVQgfSBRVU9URVMgPG9wdGlvbmFsPiBPTiBTQ0FM QVIgU1RSSU5HIDwvb3B0aW9uYWw+IDwvb3B0aW9uYWw+CisgICAgICAgIDxvcHRpb25hbD4geyBF UlJPUiB8IE5VTEwgfCBERUZBVUxUIDxyZXBsYWNlYWJsZT5leHByZXNzaW9uPC9yZXBsYWNlYWJs ZT4gfSBPTiBFTVBUWSA8L29wdGlvbmFsPgorICAgICAgICA8b3B0aW9uYWw+IHsgRVJST1IgfCBO VUxMIHwgREVGQVVMVCA8cmVwbGFjZWFibGU+ZXhwcmVzc2lvbjwvcmVwbGFjZWFibGU+IH0gT04g RVJST1IgPC9vcHRpb25hbD4KKyAgfCA8cmVwbGFjZWFibGU+bmFtZTwvcmVwbGFjZWFibGU+IDxy ZXBsYWNlYWJsZT50eXBlPC9yZXBsYWNlYWJsZT4gRk9STUFUIEpTT04gPG9wdGlvbmFsPkVOQ09E SU5HIDxsaXRlcmFsPlVURjg8L2xpdGVyYWw+PC9vcHRpb25hbD4KKyAgICAgICAgPG9wdGlvbmFs PiBQQVRIIDxyZXBsYWNlYWJsZT5qc29uX3BhdGhfc3BlY2lmaWNhdGlvbjwvcmVwbGFjZWFibGU+ IDwvb3B0aW9uYWw+CisgICAgICAgIDxvcHRpb25hbD4geyBXSVRIT1VUIHwgV0lUSCB7IENPTkRJ VElPTkFMIHwgPG9wdGlvbmFsPlVOQ09ORElUSU9OQUw8L29wdGlvbmFsPiB9IH0gPG9wdGlvbmFs PiBBUlJBWSA8L29wdGlvbmFsPiBXUkFQUEVSIDwvb3B0aW9uYWw+CisgICAgICAgIDxvcHRpb25h bD4geyBLRUVQIHwgT01JVCB9IFFVT1RFUyA8b3B0aW9uYWw+IE9OIFNDQUxBUiBTVFJJTkcgPC9v cHRpb25hbD4gPC9vcHRpb25hbD4KKyAgICAgICAgPG9wdGlvbmFsPiB7IEVSUk9SIHwgTlVMTCB8 IEVNUFRZIHsgQVJSQVkgfCBPQkpFQ1QgfSB8IERFRkFVTFQgPHJlcGxhY2VhYmxlPmV4cHJlc3Np b248L3JlcGxhY2VhYmxlPiB9IE9OIEVNUFRZIDwvb3B0aW9uYWw+CisgICAgICAgIDxvcHRpb25h bD4geyBFUlJPUiB8IE5VTEwgfCBFTVBUWSB7IEFSUkFZIHwgT0JKRUNUIH0gfCBERUZBVUxUIDxy ZXBsYWNlYWJsZT5leHByZXNzaW9uPC9yZXBsYWNlYWJsZT4gfSBPTiBFUlJPUiA8L29wdGlvbmFs PgorICB8IDxyZXBsYWNlYWJsZT5uYW1lPC9yZXBsYWNlYWJsZT4gPHJlcGxhY2VhYmxlPnR5cGU8 L3JlcGxhY2VhYmxlPiBFWElTVFMgPG9wdGlvbmFsPiBQQVRIIDxyZXBsYWNlYWJsZT5qc29uX3Bh dGhfc3BlY2lmaWNhdGlvbjwvcmVwbGFjZWFibGU+IDwvb3B0aW9uYWw+CisgICAgICAgIDxvcHRp b25hbD4geyBFUlJPUiB8IFRSVUUgfCBGQUxTRSB8IFVOS05PV04gfSBPTiBFUlJPUiA8L29wdGlv bmFsPgorICB8IE5FU1RFRCBQQVRIIDxyZXBsYWNlYWJsZT5qc29uX3BhdGhfc3BlY2lmaWNhdGlv bjwvcmVwbGFjZWFibGU+IDxvcHRpb25hbD4gQVMgPHJlcGxhY2VhYmxlPnBhdGhfbmFtZTwvcmVw bGFjZWFibGU+IDwvb3B0aW9uYWw+CisgICAgICAgIENPTFVNTlMgKCA8cmVwbGFjZWFibGU+anNv bl90YWJsZV9jb2x1bW48L3JlcGxhY2VhYmxlPiA8b3B0aW9uYWw+LCAuLi48L29wdGlvbmFsPiAp CisgIHwgPHJlcGxhY2VhYmxlPm5hbWU8L3JlcGxhY2VhYmxlPiBGT1IgT1JESU5BTElUWQorPHBo cmFzZT4KKzxyZXBsYWNlYWJsZT5qc29uX3RhYmxlX3BsYW48L3JlcGxhY2VhYmxlPiBpczoKKzwv cGhyYXNlPgorICAgIDxyZXBsYWNlYWJsZT5qc29uX3BhdGhfbmFtZTwvcmVwbGFjZWFibGU+IDxv cHRpb25hbD4geyBPVVRFUiB8IElOTkVSIH0gPHJlcGxhY2VhYmxlPmpzb25fdGFibGVfcGxhbl9w cmltYXJ5PC9yZXBsYWNlYWJsZT4gPC9vcHRpb25hbD4KKyAgfCA8cmVwbGFjZWFibGU+anNvbl90 YWJsZV9wbGFuX3ByaW1hcnk8L3JlcGxhY2VhYmxlPiB7IFVOSU9OIDxyZXBsYWNlYWJsZT5qc29u X3RhYmxlX3BsYW5fcHJpbWFyeTwvcmVwbGFjZWFibGU+IH0gPG9wdGlvbmFsPi4uLjwvb3B0aW9u YWw+CisgIHwgPHJlcGxhY2VhYmxlPmpzb25fdGFibGVfcGxhbl9wcmltYXJ5PC9yZXBsYWNlYWJs ZT4geyBDUk9TUyA8cmVwbGFjZWFibGU+anNvbl90YWJsZV9wbGFuX3ByaW1hcnk8L3JlcGxhY2Vh YmxlPiB9IDxvcHRpb25hbD4uLi48L29wdGlvbmFsPgorPHBocmFzZT4KKzxyZXBsYWNlYWJsZT5q c29uX3RhYmxlX3BsYW5fcHJpbWFyeTwvcmVwbGFjZWFibGU+IGlzOgorPC9waHJhc2U+CisgICAg PHJlcGxhY2VhYmxlPmpzb25fcGF0aF9uYW1lPC9yZXBsYWNlYWJsZT4gfCAoIDxyZXBsYWNlYWJs ZT5qc29uX3RhYmxlX3BsYW48L3JlcGxhY2VhYmxlPiApCis8L3N5bm9wc2lzPgorCisgIDxwYXJh PgorICAgRWFjaCBzeW50YXggZWxlbWVudCBpcyBkZXNjcmliZWQgYmVsb3cgaW4gbW9yZSBkZXRh aWwuCisgIDwvcGFyYT4KKworICA8dmFyaWFibGVsaXN0PgorICAgPHZhcmxpc3RlbnRyeT4KKyAg ICA8dGVybT4KKyAgICAgPGxpdGVyYWw+PHJlcGxhY2VhYmxlPmNvbnRleHRfaXRlbTwvcmVwbGFj ZWFibGU+LCA8cmVwbGFjZWFibGU+cGF0aF9leHByZXNzaW9uPC9yZXBsYWNlYWJsZT4gPG9wdGlv bmFsPiA8bGl0ZXJhbD5BUzwvbGl0ZXJhbD4gPHJlcGxhY2VhYmxlPmpzb25fcGF0aF9uYW1lPC9y ZXBsYWNlYWJsZT4gPC9vcHRpb25hbD4gPG9wdGlvbmFsPiA8bGl0ZXJhbD5QQVNTSU5HPC9saXRl cmFsPiB7IDxyZXBsYWNlYWJsZT52YWx1ZTwvcmVwbGFjZWFibGU+IDxsaXRlcmFsPkFTPC9saXRl cmFsPiA8cmVwbGFjZWFibGU+dmFybmFtZTwvcmVwbGFjZWFibGU+IH0gPG9wdGlvbmFsPiwgLi4u PC9vcHRpb25hbD48L29wdGlvbmFsPjwvbGl0ZXJhbD4KKyAgICA8L3Rlcm0+CisgICAgPGxpc3Rp dGVtPgorICAgIDxwYXJhPgorICAgICBUaGUgaW5wdXQgZGF0YSB0byBxdWVyeSwgdGhlIEpTT04g cGF0aCBleHByZXNzaW9uIGRlZmluaW5nIHRoZSBxdWVyeSwKKyAgICAgYW5kIGFuIG9wdGlvbmFs IDxsaXRlcmFsPlBBU1NJTkc8L2xpdGVyYWw+IGNsYXVzZSwgd2hpY2ggY2FuIHByb3ZpZGUgZGF0 YQorICAgICB2YWx1ZXMgdG8gdGhlIDxyZXBsYWNlYWJsZT5wYXRoX2V4cHJlc3Npb248L3JlcGxh Y2VhYmxlPi4KKyAgICAgVGhlIHJlc3VsdCBvZiB0aGUgaW5wdXQgZGF0YQorICAgICBldmFsdWF0 aW9uIGlzIGNhbGxlZCB0aGUgPGZpcnN0dGVybT5yb3cgcGF0dGVybjwvZmlyc3R0ZXJtPi4gVGhl IHJvdworICAgICBwYXR0ZXJuIGlzIHVzZWQgYXMgdGhlIHNvdXJjZSBmb3Igcm93IHZhbHVlcyBp biB0aGUgY29uc3RydWN0ZWQgdmlldy4KKyAgICA8L3BhcmE+CisgICAgPC9saXN0aXRlbT4KKyAg IDwvdmFybGlzdGVudHJ5PgorCisgICA8dmFybGlzdGVudHJ5PgorICAgIDx0ZXJtPgorICAgICA8 bGl0ZXJhbD5DT0xVTU5TPC9saXRlcmFsPiggPHJlcGxhY2VhYmxlPmpzb25fdGFibGVfY29sdW1u PC9yZXBsYWNlYWJsZT4gPG9wdGlvbmFsPiwgLi4uPC9vcHRpb25hbD4gKQorICAgIDwvdGVybT4K KyAgICA8bGlzdGl0ZW0+CisKKyAgICA8cGFyYT4KKyAgICAgVGhlIDxsaXRlcmFsPkNPTFVNTlM8 L2xpdGVyYWw+IGNsYXVzZSBkZWZpbmluZyB0aGUgc2NoZW1hIG9mIHRoZQorICAgICBjb25zdHJ1 Y3RlZCB2aWV3LiBJbiB0aGlzIGNsYXVzZSwgeW91IG11c3Qgc3BlY2lmeSBhbGwgdGhlIGNvbHVt bnMKKyAgICAgdG8gYmUgZmlsbGVkIHdpdGggU1FML0pTT04gaXRlbXMuCisgICAgIFRoZSA8cmVw bGFjZWFibGU+anNvbl90YWJsZV9jb2x1bW48L3JlcGxhY2VhYmxlPgorICAgICBleHByZXNzaW9u IGhhcyB0aGUgZm9sbG93aW5nIHN5bnRheCB2YXJpYW50czoKKyAgICA8L3BhcmE+CisKKyAgPHZh cmlhYmxlbGlzdD4KKyAgIDx2YXJsaXN0ZW50cnk+CisgICAgPHRlcm0+CisgICAgIDxsaXRlcmFs PjxyZXBsYWNlYWJsZT5uYW1lPC9yZXBsYWNlYWJsZT4gPHJlcGxhY2VhYmxlPnR5cGU8L3JlcGxh Y2VhYmxlPgorICAgICAgICAgIDxvcHRpb25hbD4gPGxpdGVyYWw+UEFUSDwvbGl0ZXJhbD4gPHJl cGxhY2VhYmxlPmpzb25fcGF0aF9zcGVjaWZpY2F0aW9uPC9yZXBsYWNlYWJsZT4gPC9vcHRpb25h bD48L2xpdGVyYWw+CisgICAgPC90ZXJtPgorICAgIDxsaXN0aXRlbT4KKworICAgIDxwYXJhPgor ICAgICBJbnNlcnRzIGEgc2luZ2xlIFNRTC9KU09OIGl0ZW0gaW50byB0aGUgb3V0cHV0IHJvdy4K KyAgICA8L3BhcmE+CisgICAgPHBhcmE+CisgICAgIFRoZSBwcm92aWRlZCA8bGl0ZXJhbD5QQVRI PC9saXRlcmFsPiBleHByZXNzaW9uIGlzIGV2YWx1YXRlZCBhbmQKKyAgICAgdGhlIGNvbHVtbiBp cyBmaWxsZWQgd2l0aCB0aGUgcHJvZHVjZWQgU1FML0pTT04gaXRlbSwgb25lIGZvciBlYWNoIHJv dy4KKyAgICAgSWYgdGhlIDxsaXRlcmFsPlBBVEg8L2xpdGVyYWw+IGV4cHJlc3Npb24gaXMgb21p dHRlZCwKKyAgICAgPGZ1bmN0aW9uPkpTT05fVEFCTEU8L2Z1bmN0aW9uPiB1c2VzIHRoZQorICAg ICA8bGl0ZXJhbD4kLjxyZXBsYWNlYWJsZT5uYW1lPC9yZXBsYWNlYWJsZT48L2xpdGVyYWw+IHBh dGggZXhwcmVzc2lvbiwKKyAgICAgd2hlcmUgPHJlcGxhY2VhYmxlPm5hbWU8L3JlcGxhY2VhYmxl PiBpcyB0aGUgcHJvdmlkZWQgY29sdW1uIG5hbWUuCisgICAgIEluIHRoaXMgY2FzZSwgdGhlIGNv bHVtbiBuYW1lIG11c3QgY29ycmVzcG9uZCB0byBvbmUgb2YgdGhlCisgICAgIGtleXMgd2l0aGlu IHRoZSBTUUwvSlNPTiBpdGVtIHByb2R1Y2VkIGJ5IHRoZSByb3cgcGF0dGVybi4KKyAgICA8L3Bh cmE+CisgICAgPHBhcmE+CisgICAgIE9wdGlvbmFsbHksIHlvdSBjYW4gc3BlY2lmeSA8bGl0ZXJh bD5XUkFQUEVSPC9saXRlcmFsPiwKKyAgICAgPGxpdGVyYWw+UVVPVEVTPC9saXRlcmFsPiBjbGF1 c2VzIHRvIGZvcm1hdCB0aGUgb3V0cHV0IGFuZAorICAgICA8bGl0ZXJhbD5PTiBFTVBUWTwvbGl0 ZXJhbD4gYW5kIDxsaXRlcmFsPk9OIEVSUk9SPC9saXRlcmFsPiB0byBoYW5kbGUKKyAgICAgdGhv c2UgbWlzc2luZyB2YWx1ZXMgYW5kIHN0cnVjdHVyYWwgZXJyb3JzLCByZXNwZWN0aXZlbHkuCisg ICAgPC9wYXJhPgorICAgIDxub3RlPgorICAgICA8cGFyYT4KKyAgICAgIFRoaXMgY2xhdXNlIGlz IGludGVybmFsbHkgdHVybmVkIGludG8gYW5kIGhhcyB0aGUgc2FtZSBzZW1hbnRpY3MgYXMKKyAg ICAgIDxmdW5jdGlvbj5qc29uX3ZhbHVlPC9mdW5jdGlvbj4gYW5kIDxmdW5jdGlvbj5qc29uX3F1 ZXJ5PC9mdW5jdGlvbj4uCisgICAgICBUaGUgbGF0dGVyIGlmIHRoZSBzcGVjaWZpZWQgdHlwZSBp cyBub3QgYSBzY2FsYXIgdHlwZSBvciBpZgorICAgICAgPGxpdGVyYWw+V1JBUFBFUjwvbGl0ZXJh bD4gb3IgPGxpdGVyYWw+UVVPVEVTPC9saXRlcmFsPiBjbGF1c2UgaXMKKyAgICAgIHByZXNlbnQu CisgICAgIDwvcGFyYT4KKyAgICA8L25vdGU+CisgICAgPC9saXN0aXRlbT4KKyAgIDwvdmFybGlz dGVudHJ5PgorCisgICA8dmFybGlzdGVudHJ5PgorICAgIDx0ZXJtPgorICAgICA8cmVwbGFjZWFi bGU+bmFtZTwvcmVwbGFjZWFibGU+IDxyZXBsYWNlYWJsZT50eXBlPC9yZXBsYWNlYWJsZT4gPGxp dGVyYWw+Rk9STUFUIEpTT048L2xpdGVyYWw+IDxvcHRpb25hbD5FTkNPRElORyA8bGl0ZXJhbD5V VEY4PC9saXRlcmFsPjwvb3B0aW9uYWw+CisgICAgICAgICAgPG9wdGlvbmFsPiA8bGl0ZXJhbD5Q QVRIPC9saXRlcmFsPiA8cmVwbGFjZWFibGU+anNvbl9wYXRoX3NwZWNpZmljYXRpb248L3JlcGxh Y2VhYmxlPiA8L29wdGlvbmFsPgorICAgIDwvdGVybT4KKyAgICA8bGlzdGl0ZW0+CisKKyAgICA8 cGFyYT4KKyAgICAgSW5zZXJ0cyBhIGNvbXBvc2l0ZSBTUUwvSlNPTiBpdGVtIGludG8gdGhlIG91 dHB1dCByb3cuCisgICAgPC9wYXJhPgorICAgIDxwYXJhPgorICAgICBUaGUgcHJvdmlkZWQgPGxp dGVyYWw+UEFUSDwvbGl0ZXJhbD4gZXhwcmVzc2lvbiBpcyBldmFsdWF0ZWQgYW5kCisgICAgIHRo ZSBjb2x1bW4gaXMgZmlsbGVkIHdpdGggdGhlIHByb2R1Y2VkIFNRTC9KU09OIGl0ZW0uICBJZiB0 aGUKKyAgICAgPGxpdGVyYWw+UEFUSDwvbGl0ZXJhbD4gZXhwcmVzc2lvbiBpcyBvbWl0dGVkLCBw YXRoIGV4cHJlc3Npb24KKyAgICAgPGxpdGVyYWw+JC48cmVwbGFjZWFibGU+bmFtZTwvcmVwbGFj ZWFibGU+PC9saXRlcmFsPiBpcyB1c2VkLAorICAgICB3aGVyZSA8cmVwbGFjZWFibGU+bmFtZTwv cmVwbGFjZWFibGU+IGlzIHRoZSBwcm92aWRlZCBjb2x1bW4gbmFtZS4KKyAgICAgSW4gdGhpcyBj YXNlLCB0aGUgY29sdW1uIG5hbWUgbXVzdCBjb3JyZXNwb25kIHRvIG9uZSBvZiB0aGUKKyAgICAg a2V5cyB3aXRoaW4gdGhlIFNRTC9KU09OIGl0ZW0gcHJvZHVjZWQgYnkgdGhlIHJvdyBwYXR0ZXJu LgorICAgIDwvcGFyYT4KKyAgICA8cGFyYT4KKyAgICAgT3B0aW9uYWxseSwgeW91IGNhbiBzcGVj aWZ5IDxsaXRlcmFsPldSQVBQRVI8L2xpdGVyYWw+LAorICAgICA8bGl0ZXJhbD5RVU9URVM8L2xp dGVyYWw+IGNsYXVzZXMgdG8gZm9ybWF0IHRoZSBvdXRwdXQgYW5kCisgICAgIDxsaXRlcmFsPk9O IEVNUFRZPC9saXRlcmFsPiBhbmQgPGxpdGVyYWw+T04gRVJST1I8L2xpdGVyYWw+IHRvIGhhbmRs ZQorICAgICB0aG9zZSBzY2VuYXJpb3MgYXBwcm9wcmlhdGVseS4KKyAgICA8L3BhcmE+CisgICAg PG5vdGU+CisgICAgIDxwYXJhPgorICAgICAgVGhpcyBjbGF1c2UgaXMgaW50ZXJuYWxseSB0dXJu ZWQgaW50byBhbmQgaGFzIHRoZSBzYW1lIHNlbWFudGljcyBhcworICAgICAgPGZ1bmN0aW9uPmpz b25fcXVlcnk8L2Z1bmN0aW9uPi4KKyAgICAgPC9wYXJhPgorICAgIDwvbm90ZT4KKyAgICA8L2xp c3RpdGVtPgorICAgPC92YXJsaXN0ZW50cnk+CisKKyAgIDx2YXJsaXN0ZW50cnk+CisgICAgPHRl cm0+CisgICAgICAgPHJlcGxhY2VhYmxlPm5hbWU8L3JlcGxhY2VhYmxlPiA8cmVwbGFjZWFibGU+ dHlwZTwvcmVwbGFjZWFibGU+CisgICAgICAgPGxpdGVyYWw+RVhJU1RTPC9saXRlcmFsPiA8b3B0 aW9uYWw+IDxsaXRlcmFsPlBBVEg8L2xpdGVyYWw+IDxyZXBsYWNlYWJsZT5qc29uX3BhdGhfc3Bl Y2lmaWNhdGlvbjwvcmVwbGFjZWFibGU+IDwvb3B0aW9uYWw+CisgICAgPC90ZXJtPgorICAgIDxs aXN0aXRlbT4KKworICAgIDxwYXJhPgorICAgICBJbnNlcnRzIGEgYm9vbGVhbiBpdGVtIGludG8g ZWFjaCBvdXRwdXQgcm93LgorICAgIDwvcGFyYT4KKyAgICA8cGFyYT4KKyAgICAgVGhlIHZhbHVl IGNvcnJlc3BvbmRzIHRvIHdoZXRoZXIgZXZhbHVhdGluZyB0aGUgPGxpdGVyYWw+UEFUSDwvbGl0 ZXJhbD4KKyAgICAgZXhwcmVzc2lvbiB5aWVsZHMgYW55IFNRTC9KU09OIGl0ZW1zLiAgSWYgdGhl IDxsaXRlcmFsPlBBVEg8L2xpdGVyYWw+CisgICAgIGV4cHJlc3Npb24gaXMgb21pdHRlZCwgcGF0 aCBleHByZXNzaW9uCisgICAgIDxsaXRlcmFsPiQuPHJlcGxhY2VhYmxlPm5hbWU8L3JlcGxhY2Vh YmxlPjwvbGl0ZXJhbD4gaXMgdXNlZCwKKyAgICAgd2hlcmUgPHJlcGxhY2VhYmxlPm5hbWU8L3Jl cGxhY2VhYmxlPiBpcyB0aGUgcHJvdmlkZWQgY29sdW1uIG5hbWUuCisgICAgPC9wYXJhPgorICAg IDxwYXJhPgorICAgICBUaGUgc3BlY2lmaWVkIDxwYXJhbWV0ZXI+dHlwZTwvcGFyYW1ldGVyPiBz aG91bGQgaGF2ZSBhIGNhc3QgZnJvbSB0aGUKKyAgICAgPHR5cGU+Ym9vbGVhbjwvdHlwZT4uCisg ICAgPC9wYXJhPgorICAgIDxwYXJhPgorICAgICBPcHRpb25hbGx5LCB5b3UgY2FuIGFkZCA8bGl0 ZXJhbD5PTiBFUlJPUjwvbGl0ZXJhbD4gY2xhdXNlIHRvIGRlZmluZQorICAgICBlcnJvciBiZWhh dmlvci4KKyAgICA8L3BhcmE+CisgICAgPG5vdGU+CisgICAgIDxwYXJhPgorICAgICAgVGhpcyBj bGF1c2UgaXMgaW50ZXJuYWxseSB0dXJuZWQgaW50byBhbmQgaGFzIHRoZSBzYW1lIHNlbWFudGlj cyBhcworICAgICAgPGZ1bmN0aW9uPmpzb25fZXhpc3RzPC9mdW5jdGlvbj4uCisgICAgIDwvcGFy YT4KKyAgICA8L25vdGU+CisgICAgPC9saXN0aXRlbT4KKyAgIDwvdmFybGlzdGVudHJ5PgorCisg ICA8dmFybGlzdGVudHJ5PgorICAgIDx0ZXJtPgorICAgICAgPGxpdGVyYWw+TkVTVEVEIFBBVEg8 L2xpdGVyYWw+IDxyZXBsYWNlYWJsZT5qc29uX3BhdGhfc3BlY2lmaWNhdGlvbjwvcmVwbGFjZWFi bGU+IDxvcHRpb25hbD4gPGxpdGVyYWw+QVM8L2xpdGVyYWw+IDxyZXBsYWNlYWJsZT5qc29uX3Bh dGhfbmFtZTwvcmVwbGFjZWFibGU+IDwvb3B0aW9uYWw+CisgICAgICAgICAgPGxpdGVyYWw+Q09M VU1OUzwvbGl0ZXJhbD4gKCA8cmVwbGFjZWFibGU+anNvbl90YWJsZV9jb2x1bW48L3JlcGxhY2Vh YmxlPiA8b3B0aW9uYWw+LCAuLi48L29wdGlvbmFsPiApCisgICAgPC90ZXJtPgorICAgIDxsaXN0 aXRlbT4KKworICAgIDxwYXJhPgorICAgICBFeHRyYWN0cyBTUUwvSlNPTiBpdGVtcyBmcm9tIG5l c3RlZCBsZXZlbHMgb2YgdGhlIHJvdyBwYXR0ZXJuLAorICAgICBnZW5lcmF0ZXMgb25lIG9yIG1v cmUgY29sdW1ucyBhcyBkZWZpbmVkIGJ5IHRoZSA8bGl0ZXJhbD5DT0xVTU5TPC9saXRlcmFsPgor ICAgICBzdWJjbGF1c2UsIGFuZCBpbnNlcnRzIHRoZSBleHRyYWN0ZWQgU1FML0pTT04gaXRlbXMg aW50byBlYWNoIHJvdyBvZiB0aGVzZSBjb2x1bW5zLgorICAgICBUaGUgPHJlcGxhY2VhYmxlPmpz b25fdGFibGVfY29sdW1uPC9yZXBsYWNlYWJsZT4gZXhwcmVzc2lvbiBpbiB0aGUKKyAgICAgPGxp dGVyYWw+Q09MVU1OUzwvbGl0ZXJhbD4gc3ViY2xhdXNlIHVzZXMgdGhlIHNhbWUgc3ludGF4IGFz IGluIHRoZQorICAgICBwYXJlbnQgPGxpdGVyYWw+Q09MVU1OUzwvbGl0ZXJhbD4gY2xhdXNlLgor ICAgIDwvcGFyYT4KKworICAgIDxwYXJhPgorICAgICBUaGUgPGxpdGVyYWw+TkVTVEVEIFBBVEg8 L2xpdGVyYWw+IHN5bnRheCBpcyByZWN1cnNpdmUsCisgICAgIHNvIHlvdSBjYW4gZ28gZG93biBt dWx0aXBsZSBuZXN0ZWQgbGV2ZWxzIGJ5IHNwZWNpZnlpbmcgc2V2ZXJhbAorICAgICA8bGl0ZXJh bD5ORVNURUQgUEFUSDwvbGl0ZXJhbD4gc3ViY2xhdXNlcyB3aXRoaW4gZWFjaCBvdGhlci4KKyAg ICAgSXQgYWxsb3dzIHRvIHVubmVzdCB0aGUgaGllcmFyY2h5IG9mIEpTT04gb2JqZWN0cyBhbmQg YXJyYXlzCisgICAgIGluIGEgc2luZ2xlIGZ1bmN0aW9uIGludm9jYXRpb24gcmF0aGVyIHRoYW4g Y2hhaW5pbmcgc2V2ZXJhbAorICAgICA8ZnVuY3Rpb24+SlNPTl9UQUJMRTwvZnVuY3Rpb24+IGV4 cHJlc3Npb25zIGluIGFuIFNRTCBzdGF0ZW1lbnQuCisgICAgPC9wYXJhPgorCisgICAgPHBhcmE+ CisgICAgIFlvdSBjYW4gdXNlIHRoZSA8bGl0ZXJhbD5QTEFOPC9saXRlcmFsPiBjbGF1c2UgdG8g ZGVmaW5lIGhvdworICAgICB0byBqb2luIHRoZSBjb2x1bW5zIHJldHVybmVkIGJ5IDxsaXRlcmFs Pk5FU1RFRCBQQVRIPC9saXRlcmFsPiBjbGF1c2VzLgorICAgIDwvcGFyYT4KKyAgICA8L2xpc3Rp dGVtPgorICAgPC92YXJsaXN0ZW50cnk+CisKKyAgIDx2YXJsaXN0ZW50cnk+CisgICAgPHRlcm0+ CisgICAgIDxyZXBsYWNlYWJsZT5uYW1lPC9yZXBsYWNlYWJsZT4gPGxpdGVyYWw+Rk9SIE9SRElO QUxJVFk8L2xpdGVyYWw+CisgICAgPC90ZXJtPgorICAgIDxsaXN0aXRlbT4KKworICAgIDxwYXJh PgorICAgICBBZGRzIGFuIG9yZGluYWxpdHkgY29sdW1uIHRoYXQgcHJvdmlkZXMgc2VxdWVudGlh bCByb3cgbnVtYmVyaW5nLgorICAgICBZb3UgY2FuIGhhdmUgb25seSBvbmUgb3JkaW5hbGl0eSBj b2x1bW4gcGVyIHRhYmxlLiBSb3cgbnVtYmVyaW5nCisgICAgIGlzIDEtYmFzZWQuIEZvciBjaGls ZCByb3dzIHRoYXQgcmVzdWx0IGZyb20gdGhlIDxsaXRlcmFsPk5FU1RFRCBQQVRIPC9saXRlcmFs PgorICAgICBjbGF1c2VzLCB0aGUgcGFyZW50IHJvdyBudW1iZXIgaXMgcmVwZWF0ZWQuCisgICAg PC9wYXJhPgorICAgIDwvbGlzdGl0ZW0+CisgICA8L3Zhcmxpc3RlbnRyeT4KKyAgPC92YXJpYWJs ZWxpc3Q+CisKKyAgICA8L2xpc3RpdGVtPgorICAgPC92YXJsaXN0ZW50cnk+CisKKyAgIDx2YXJs aXN0ZW50cnk+CisgICAgPHRlcm0+CisgICAgIDxsaXRlcmFsPkFTPC9saXRlcmFsPiA8cmVwbGFj ZWFibGU+anNvbl9wYXRoX25hbWU8L3JlcGxhY2VhYmxlPgorICAgIDwvdGVybT4KKyAgICA8bGlz dGl0ZW0+CisKKyAgICA8cGFyYT4KKyAgICAgVGhlIG9wdGlvbmFsIDxyZXBsYWNlYWJsZT5qc29u X3BhdGhfbmFtZTwvcmVwbGFjZWFibGU+IHNlcnZlcyBhcyBhbgorICAgICBpZGVudGlmaWVyIG9m IHRoZSBwcm92aWRlZCA8cmVwbGFjZWFibGU+anNvbl9wYXRoX3NwZWNpZmljYXRpb248L3JlcGxh Y2VhYmxlPi4KKyAgICAgVGhlIHBhdGggbmFtZSBtdXN0IGJlIHVuaXF1ZSBhbmQgZGlzdGluY3Qg ZnJvbSB0aGUgY29sdW1uIG5hbWVzLgorICAgICBXaGVuIHVzaW5nIHRoZSA8bGl0ZXJhbD5QTEFO PC9saXRlcmFsPiBjbGF1c2UsIHlvdSBtdXN0IHNwZWNpZnkgdGhlIG5hbWVzCisgICAgIGZvciBh bGwgdGhlIHBhdGhzLCBpbmNsdWRpbmcgdGhlIHJvdyBwYXR0ZXJuLiBFYWNoIHBhdGggbmFtZSBj YW4gYXBwZWFyIGluCisgICAgIHRoZSA8bGl0ZXJhbD5QTEFOPC9saXRlcmFsPiBjbGF1c2Ugb25s eSBvbmNlLgorICAgIDwvcGFyYT4KKyAgICA8L2xpc3RpdGVtPgorICAgPC92YXJsaXN0ZW50cnk+ CisKKyAgIDx2YXJsaXN0ZW50cnk+CisgICAgPHRlcm0+CisgICAgIDxsaXRlcmFsPlBMQU48L2xp dGVyYWw+ICggPHJlcGxhY2VhYmxlPmpzb25fdGFibGVfcGxhbjwvcmVwbGFjZWFibGU+ICkKKyAg ICA8L3Rlcm0+CisgICAgPGxpc3RpdGVtPgorCisgICAgPHBhcmE+CisgICAgIERlZmluZXMgaG93 IHRvIGpvaW4gdGhlIGRhdGEgcmV0dXJuZWQgYnkgPGxpdGVyYWw+TkVTVEVEIFBBVEg8L2xpdGVy YWw+CisgICAgIGNsYXVzZXMgdG8gdGhlIGNvbnN0cnVjdGVkIHZpZXcuCisgICAgPC9wYXJhPgor ICAgIDxwYXJhPgorICAgICBUbyBqb2luIGNvbHVtbnMgd2l0aCBwYXJlbnQvY2hpbGQgcmVsYXRp b25zaGlwLCB5b3UgY2FuIHVzZToKKyAgICA8L3BhcmE+CisgIDx2YXJpYWJsZWxpc3Q+CisgICA8 dmFybGlzdGVudHJ5PgorICAgIDx0ZXJtPgorICAgICA8bGl0ZXJhbD5JTk5FUjwvbGl0ZXJhbD4K KyAgICA8L3Rlcm0+CisgICAgPGxpc3RpdGVtPgorCisgICAgPHBhcmE+CisgICAgIFVzZSA8bGl0 ZXJhbD5JTk5FUiBKT0lOPC9saXRlcmFsPiwgc28gdGhhdCB0aGUgcGFyZW50IHJvdworICAgICBp cyBvbWl0dGVkIGZyb20gdGhlIG91dHB1dCBpZiBpdCBkb2VzIG5vdCBoYXZlIGFueSBjaGlsZCBy b3dzCisgICAgIGFmdGVyIGpvaW5pbmcgdGhlIGRhdGEgcmV0dXJuZWQgYnkgPGxpdGVyYWw+TkVT VEVEIFBBVEg8L2xpdGVyYWw+LgorICAgIDwvcGFyYT4KKyAgICA8L2xpc3RpdGVtPgorICAgPC92 YXJsaXN0ZW50cnk+CisKKyAgIDx2YXJsaXN0ZW50cnk+CisgICAgPHRlcm0+CisgICAgIDxsaXRl cmFsPk9VVEVSPC9saXRlcmFsPgorICAgIDwvdGVybT4KKyAgICA8bGlzdGl0ZW0+CisKKyAgICA8 cGFyYT4KKyAgICAgVXNlIDxsaXRlcmFsPkxFRlQgT1VURVIgSk9JTjwvbGl0ZXJhbD4sIHNvIHRo YXQgdGhlIHBhcmVudCByb3cKKyAgICAgaXMgYWx3YXlzIGluY2x1ZGVkIGludG8gdGhlIG91dHB1 dCBldmVuIGlmIGl0IGRvZXMgbm90IGhhdmUgYW55IGNoaWxkIHJvd3MKKyAgICAgYWZ0ZXIgam9p bmluZyB0aGUgZGF0YSByZXR1cm5lZCBieSA8bGl0ZXJhbD5ORVNURUQgUEFUSDwvbGl0ZXJhbD4s IHdpdGggTlVMTCB2YWx1ZXMKKyAgICAgaW5zZXJ0ZWQgaW50byB0aGUgY2hpbGQgY29sdW1ucyBp ZiB0aGUgY29ycmVzcG9uZGluZworICAgICB2YWx1ZXMgYXJlIG1pc3NpbmcuCisgICAgPC9wYXJh PgorICAgIDxwYXJhPgorICAgICBUaGlzIGlzIHRoZSBkZWZhdWx0IG9wdGlvbiBmb3Igam9pbmlu ZyBjb2x1bW5zIHdpdGggcGFyZW50L2NoaWxkIHJlbGF0aW9uc2hpcC4KKyAgICA8L3BhcmE+Cisg ICAgPC9saXN0aXRlbT4KKyAgIDwvdmFybGlzdGVudHJ5PgorICA8L3ZhcmlhYmxlbGlzdD4KKwor ICAgICA8cGFyYT4KKyAgICAgVG8gam9pbiBzaWJsaW5nIGNvbHVtbnMsIHlvdSBjYW4gdXNlOgor ICAgIDwvcGFyYT4KKworICA8dmFyaWFibGVsaXN0PgorICAgPHZhcmxpc3RlbnRyeT4KKyAgICA8 dGVybT4KKyAgICAgPGxpdGVyYWw+VU5JT048L2xpdGVyYWw+CisgICAgPC90ZXJtPgorICAgIDxs aXN0aXRlbT4KKworICAgIDxwYXJhPgorICAgICBHZW5lcmF0ZSBvbmUgcm93IGZvciBlYWNoIHZh bHVlIHByb2R1Y2VkIGJ5IGVhY2ggb2YgdGhlIHNpYmxpbmcKKyAgICAgY29sdW1ucy4gVGhlIGNv bHVtbnMgZnJvbSB0aGUgb3RoZXIgc2libGluZ3MgYXJlIHNldCB0byBudWxsLgorICAgIDwvcGFy YT4KKyAgICA8cGFyYT4KKyAgICAgVGhpcyBpcyB0aGUgZGVmYXVsdCBvcHRpb24gZm9yIGpvaW5p bmcgc2libGluZyBjb2x1bW5zLgorICAgIDwvcGFyYT4KKyAgICA8L2xpc3RpdGVtPgorICAgPC92 YXJsaXN0ZW50cnk+CisKKyAgIDx2YXJsaXN0ZW50cnk+CisgICAgPHRlcm0+CisgICAgIDxsaXRl cmFsPkNST1NTPC9saXRlcmFsPgorICAgIDwvdGVybT4KKyAgICA8bGlzdGl0ZW0+CisKKyAgICA8 cGFyYT4KKyAgICAgR2VuZXJhdGUgb25lIHJvdyBmb3IgZWFjaCBjb21iaW5hdGlvbiBvZiB2YWx1 ZXMgZnJvbSB0aGUgc2libGluZyBjb2x1bW5zLgorICAgIDwvcGFyYT4KKyAgICA8L2xpc3RpdGVt PgorICAgPC92YXJsaXN0ZW50cnk+CisKKyAgPC92YXJpYWJsZWxpc3Q+CisKKyAgICA8L2xpc3Rp dGVtPgorICAgPC92YXJsaXN0ZW50cnk+CisKKyAgIDx2YXJsaXN0ZW50cnk+CisgICAgPHRlcm0+ CisgICAgIDxsaXRlcmFsPlBMQU4gREVGQVVMVDwvbGl0ZXJhbD4gKCA8bGl0ZXJhbD48cmVwbGFj ZWFibGU+T1VURVIgfCBJTk5FUjwvcmVwbGFjZWFibGU+IDxvcHRpb25hbD4sIDxyZXBsYWNlYWJs ZT5VTklPTiB8IENST1NTPC9yZXBsYWNlYWJsZT4gPC9vcHRpb25hbD48L2xpdGVyYWw+ICkKKyAg ICA8L3Rlcm0+CisgICAgPGxpc3RpdGVtPgorICAgICA8cGFyYT4KKyAgICAgIFRoZSB0ZXJtcyBj YW4gYWxzbyBiZSBzcGVjaWZpZWQgaW4gcmV2ZXJzZSBvcmRlci4gVGhlCisgICAgICA8bGl0ZXJh bD5JTk5FUjwvbGl0ZXJhbD4gb3IgPGxpdGVyYWw+T1VURVI8L2xpdGVyYWw+IG9wdGlvbiBkZWZp bmVzIHRoZQorICAgICAgam9pbmluZyBwbGFuIGZvciBwYXJlbnQvY2hpbGQgY29sdW1ucywgd2hp bGUgPGxpdGVyYWw+VU5JT048L2xpdGVyYWw+IG9yCisgICAgICA8bGl0ZXJhbD5DUk9TUzwvbGl0 ZXJhbD4gYWZmZWN0cyBqb2lucyBvZiBzaWJsaW5nIGNvbHVtbnMuIFRoaXMgZm9ybQorICAgICAg b2YgPGxpdGVyYWw+UExBTjwvbGl0ZXJhbD4gb3ZlcnJpZGVzIHRoZSBkZWZhdWx0IHBsYW4gZm9y CisgICAgICBhbGwgY29sdW1ucyBhdCBvbmNlLiBFdmVuIHRob3VnaCB0aGUgcGF0aCBuYW1lcyBh cmUgbm90IGluY2x1ZGVkIGluIHRoZQorICAgICAgPGxpdGVyYWw+UExBTiBERUZBVUxUPC9saXRl cmFsPiBmb3JtLCB0byBjb25mb3JtIHRvIHRoZSBTUUwvSlNPTiBzdGFuZGFyZAorICAgICAgdGhl eSBtdXN0IGJlIHByb3ZpZGVkIGZvciBhbGwgdGhlIHBhdGhzIGlmIHRoZSA8bGl0ZXJhbD5QTEFO PC9saXRlcmFsPgorICAgICAgY2xhdXNlIGlzIHVzZWQuCisgICAgIDwvcGFyYT4KKyAgICAgPHBh cmE+CisgICAgICA8bGl0ZXJhbD5QTEFOIERFRkFVTFQ8L2xpdGVyYWw+IGlzIHNpbXBsZXIgdGhh biBzcGVjaWZ5aW5nIGEgY29tcGxldGUKKyAgICAgIDxsaXRlcmFsPlBMQU48L2xpdGVyYWw+LCBh bmQgaXMgb2Z0ZW4gYWxsIHRoYXQgaXMgcmVxdWlyZWQgdG8gZ2V0IHRoZSBkZXNpcmVkCisgICAg ICBvdXRwdXQuCisgICAgIDwvcGFyYT4KKyAgICA8L2xpc3RpdGVtPgorICAgPC92YXJsaXN0ZW50 cnk+CisgIDwvdmFyaWFibGVsaXN0PgorCisgIDxwYXJhPkV4YW1wbGVzPC9wYXJhPgorCisgICAg IDxwYXJhPgorICAgICBJbiB0aGVzZSBleGFtcGxlcyB0aGUgZm9sbG93aW5nIHNtYWxsIHRhYmxl IHN0b3Jpbmcgc29tZSBKU09OIGRhdGEgd2lsbCBiZSB1c2VkOgorPHByb2dyYW1saXN0aW5nPgor Q1JFQVRFIFRBQkxFIG15X2ZpbG1zICgganMganNvbmIgKTsKKworSU5TRVJUIElOVE8gbXlfZmls bXMgVkFMVUVTICgKKyd7ICJmYXZvcml0ZXMiIDogWworICAgeyAia2luZCIgOiAiY29tZWR5Iiwg ImZpbG1zIiA6IFsKKyAgICAgeyAidGl0bGUiIDogIkJhbmFuYXMiLAorICAgICAgICJkaXJlY3Rv ciIgOiAiV29vZHkgQWxsZW4ifSwKKyAgICAgeyAidGl0bGUiIDogIlRoZSBEaW5uZXIgR2FtZSIs CisgICAgICAgImRpcmVjdG9yIiA6ICJGcmFuY2lzIFZlYmVyIiB9IF0gfSwKKyAgIHsgImtpbmQi IDogImhvcnJvciIsICJmaWxtcyIgOiBbCisgICAgIHsgInRpdGxlIiA6ICJQc3ljaG8iLAorICAg ICAgICJkaXJlY3RvciIgOiAiQWxmcmVkIEhpdGNoY29jayIgfSBdIH0sCisgICB7ICJraW5kIiA6 ICJ0aHJpbGxlciIsICJmaWxtcyIgOiBbCisgICAgIHsgInRpdGxlIiA6ICJWZXJ0aWdvIiwKKyAg ICAgICAiZGlyZWN0b3IiIDogIkFsZnJlZCBIaXRjaGNvY2siIH0gXSB9LAorICAgeyAia2luZCIg OiAiZHJhbWEiLCAiZmlsbXMiIDogWworICAgICB7ICJ0aXRsZSIgOiAiWW9qaW1ibyIsCisgICAg ICAgImRpcmVjdG9yIiA6ICJBa2lyYSBLdXJvc2F3YSIgfSBdIH0KKyAgXSB9Jyk7Cis8L3Byb2dy YW1saXN0aW5nPgorICAgICA8L3BhcmE+CisgICAgIDxwYXJhPgorICAgICAgUXVlcnkgdGhlIDxz dHJ1Y3RuYW1lPm15X2ZpbG1zPC9zdHJ1Y3RuYW1lPiB0YWJsZSBob2xkaW5nCisgICAgICBzb21l IEpTT04gZGF0YSBhYm91dCB0aGUgZmlsbXMgYW5kIGNyZWF0ZSBhIHZpZXcgdGhhdAorICAgICAg ZGlzdHJpYnV0ZXMgdGhlIGZpbG0gZ2VucmUsIHRpdGxlLCBhbmQgZGlyZWN0b3IgYmV0d2VlbiBz ZXBhcmF0ZSBjb2x1bW5zOgorPHNjcmVlbj4KK1NFTEVDVCBqdC4qIEZST00KKyBteV9maWxtcywK KyBKU09OX1RBQkxFICgganMsICckLmZhdm9yaXRlc1sqXScgQ09MVU1OUyAoCisgICBpZCBGT1Ig T1JESU5BTElUWSwKKyAgIGtpbmQgdGV4dCBQQVRIICckLmtpbmQnLAorICAgTkVTVEVEIFBBVEgg JyQuZmlsbXNbKl0nIENPTFVNTlMgKAorICAgICB0aXRsZSB0ZXh0IFBBVEggJyQudGl0bGUnLAor ICAgICBkaXJlY3RvciB0ZXh0IFBBVEggJyQuZGlyZWN0b3InKSkpIEFTIGp0OworLS0tLSstLS0t LS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tCisgaWQgfCAgIGtp bmQgICB8ICAgICAgIHRpdGxlICAgICAgfCAgICBkaXJlY3RvcgorLS0tLSstLS0tLS0tLS0tKy0t LS0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tCisgMSAgfCBjb21lZHkgICB8IEJh bmFuYXMgICAgICAgICAgfCBXb29keSBBbGxlbgorIDEgIHwgY29tZWR5ICAgfCBUaGUgRGlubmVy IEdhbWUgIHwgRnJhbmNpcyBWZWJlcgorIDIgIHwgaG9ycm9yICAgfCBQc3ljaG8gICAgICAgICAg IHwgQWxmcmVkIEhpdGNoY29jaworIDMgIHwgdGhyaWxsZXIgfCBWZXJ0aWdvICAgICAgICAgIHwg QWxmcmVkIEhpdGNoY29jaworIDQgIHwgZHJhbWEgICAgfCBZb2ppbWJvICAgICAgICAgIHwgQWtp cmEgS3Vyb3Nhd2EKKyAoNSByb3dzKQorPC9zY3JlZW4+CisgICAgIDwvcGFyYT4KKworICAgICA8 cGFyYT4KKyAgICAgIEZpbmQgYSBkaXJlY3RvciB0aGF0IGhhcyBkb25lIGZpbG1zIGluIHR3byBk aWZmZXJlbnQgZ2VucmVzOgorPHNjcmVlbj4KK1NFTEVDVAorICBkaXJlY3RvcjEgQVMgZGlyZWN0 b3IsIHRpdGxlMSwga2luZDEsIHRpdGxlMiwga2luZDIKK0ZST00KKyAgbXlfZmlsbXMsCisgIEpT T05fVEFCTEUgKCBqcywgJyQuZmF2b3JpdGVzJyBBUyBmYXZzIENPTFVNTlMgKAorICAgIE5FU1RF RCBQQVRIICckWypdJyBBUyBmaWxtczEgQ09MVU1OUyAoCisgICAgICBraW5kMSB0ZXh0IFBBVEgg JyQua2luZCcsCisgICAgICBORVNURUQgUEFUSCAnJC5maWxtc1sqXScgQVMgZmlsbTEgQ09MVU1O UyAoCisgICAgICAgIHRpdGxlMSB0ZXh0IFBBVEggJyQudGl0bGUnLAorICAgICAgICBkaXJlY3Rv cjEgdGV4dCBQQVRIICckLmRpcmVjdG9yJykKKyAgICApLAorICAgIE5FU1RFRCBQQVRIICckWypd JyBBUyBmaWxtczIgQ09MVU1OUyAoCisgICAgICBraW5kMiB0ZXh0IFBBVEggJyQua2luZCcsCisg ICAgICBORVNURUQgUEFUSCAnJC5maWxtc1sqXScgQVMgZmlsbTIgQ09MVU1OUyAoCisgICAgICAg IHRpdGxlMiB0ZXh0IFBBVEggJyQudGl0bGUnLAorICAgICAgICBkaXJlY3RvcjIgdGV4dCBQQVRI ICckLmRpcmVjdG9yJworICAgICAgKQorICAgICkKKyAgICkKKyAgIFBMQU4gKGZhdnMgT1VURVIg KChmaWxtczEgSU5ORVIgZmlsbTEpIENST1NTIChmaWxtczIgSU5ORVIgZmlsbTIpKSkKKyAgKSBB UyBqdAorIFdIRVJFIGtpbmQxID4ga2luZDIgQU5EIGRpcmVjdG9yMSA9IGRpcmVjdG9yMjsKKwor ICAgICBkaXJlY3RvciAgICAgfCB0aXRsZTEgIHwgIGtpbmQxICAgfCB0aXRsZTIgfCBraW5kMgor LS0tLS0tLS0tLS0tLS0tLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0tKy0tLS0tLS0tKy0tLS0tLS0t CisgQWxmcmVkIEhpdGNoY29jayB8IFZlcnRpZ28gfCB0aHJpbGxlciB8IFBzeWNobyB8IGhvcnJv cgorKDEgcm93KQorPC9zY3JlZW4+CisgICAgIDwvcGFyYT4KKyAgPC9zZWN0Mj4KKwogIDwvc2Vj dDE+CiAKICA8c2VjdDEgaWQ9ImZ1bmN0aW9ucy1zZXF1ZW5jZSI+CmRpZmYgLS1naXQgYS9zcmMv YmFja2VuZC9jYXRhbG9nL3NxbF9mZWF0dXJlcy50eHQgYi9zcmMvYmFja2VuZC9jYXRhbG9nL3Nx bF9mZWF0dXJlcy50eHQKaW5kZXggNzU5OGJkOGYyMi4uOTUwMGE4MGY0ZCAxMDA2NDQKLS0tIGEv c3JjL2JhY2tlbmQvY2F0YWxvZy9zcWxfZmVhdHVyZXMudHh0CisrKyBiL3NyYy9iYWNrZW5kL2Nh dGFsb2cvc3FsX2ZlYXR1cmVzLnR4dApAQCAtNTUxLDEwICs1NTEsMTAgQEAgVDgxNAlDb2xvbiBp biBKU09OX09CSkVDVCBvciBKU09OX09CSkVDVEFHRwkJCVlFUwogVDgyMQlCYXNpYyBTUUwvSlNP TiBxdWVyeSBvcGVyYXRvcnMJCQlZRVMJCiBUODIyCVNRTC9KU09OOiBJUyBKU09OIFdJVEggVU5J UVVFIEtFWVMgcHJlZGljYXRlCQkJWUVTCQogVDgyMwlTUUwvSlNPTjogUEFTU0lORyBjbGF1c2UJ CQlZRVMJCi1UODI0CUpTT05fVEFCTEU6IHNwZWNpZmljIFBMQU4gY2xhdXNlCQkJTk8JCitUODI0 CUpTT05fVEFCTEU6IHNwZWNpZmljIFBMQU4gY2xhdXNlCQkJWUVTCQogVDgyNQlTUUwvSlNPTjog T04gRU1QVFkgYW5kIE9OIEVSUk9SIGNsYXVzZXMJCQlZRVMJCiBUODI2CUdlbmVyYWwgdmFsdWUg ZXhwcmVzc2lvbiBpbiBPTiBFUlJPUiBvciBPTiBFTVBUWSBjbGF1c2VzCQkJWUVTCQotVDgyNwlK U09OX1RBQkxFOiBzaWJsaW5nIE5FU1RFRCBDT0xVTU5TIGNsYXVzZXMJCQlOTwkKK1Q4MjcJSlNP Tl9UQUJMRTogc2libGluZyBORVNURUQgQ09MVU1OUyBjbGF1c2VzCQkJWUVTCQogVDgyOAlKU09O X1FVRVJZCQkJWUVTCQogVDgyOQlKU09OX1FVRVJZOiBhcnJheSB3cmFwcGVyIG9wdGlvbnMJCQlZ RVMJCiBUODMwCUVuZm9yY2luZyB1bmlxdWUga2V5cyBpbiBTUUwvSlNPTiBjb25zdHJ1Y3RvciBm dW5jdGlvbnMJCQlZRVMJCkBAIC01NjUsNyArNTY1LDcgQEAgVDgzNAlTUUwvSlNPTiBwYXRoIGxh bmd1YWdlOiB3aWxkY2FyZCBtZW1iZXIgYWNjZXNzb3IJCQlZRVMKIFQ4MzUJU1FML0pTT04gcGF0 aCBsYW5ndWFnZTogZmlsdGVyIGV4cHJlc3Npb25zCQkJWUVTCQogVDgzNglTUUwvSlNPTiBwYXRo IGxhbmd1YWdlOiBzdGFydHMgd2l0aCBwcmVkaWNhdGUJCQlZRVMJCiBUODM3CVNRTC9KU09OIHBh dGggbGFuZ3VhZ2U6IHJlZ2V4X2xpa2UgcHJlZGljYXRlCQkJWUVTCQotVDgzOAlKU09OX1RBQkxF OiBQTEFOIERFRkFVTFQgY2xhdXNlCQkJTk8JCitUODM4CUpTT05fVEFCTEU6IFBMQU4gREVGQVVM VCBjbGF1c2UJCQlZRVMJCiBUODM5CUZvcm1hdHRlZCBjYXN0IG9mIGRhdGV0aW1lcyB0by9mcm9t IGNoYXJhY3RlciBzdHJpbmdzCQkJTk8JCiBUODQwCUhleCBpbnRlZ2VyIGxpdGVyYWxzIGluIFNR TC9KU09OIHBhdGggbGFuZ3VhZ2UJCQlZRVMJCiBUODUxCVNRTC9KU09OOiBvcHRpb25hbCBrZXl3 b3JkcyBmb3IgZGVmYXVsdCBzeW50YXgJCQlZRVMJCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9j b21tYW5kcy9leHBsYWluLmMgYi9zcmMvYmFja2VuZC9jb21tYW5kcy9leHBsYWluLmMKaW5kZXgg M2Q1OTBhNmI5Zi4uN2NkN2IyZGQ4MiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMv ZXhwbGFpbi5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2V4cGxhaW4uYwpAQCAtMzg5Miw3 ICszODkyLDEzIEBAIEV4cGxhaW5UYXJnZXRSZWwoUGxhbiAqcGxhbiwgSW5kZXggcnRpLCBFeHBs YWluU3RhdGUgKmVzKQogCQkJYnJlYWs7CiAJCWNhc2UgVF9UYWJsZUZ1bmNTY2FuOgogCQkJQXNz ZXJ0KHJ0ZS0+cnRla2luZCA9PSBSVEVfVEFCTEVGVU5DKTsKLQkJCW9iamVjdG5hbWUgPSAieG1s dGFibGUiOworCQkJaWYgKHJ0ZS0+dGFibGVmdW5jKQorCQkJCWlmIChydGUtPnRhYmxlZnVuYy0+ ZnVuY3R5cGUgPT0gVEZUX1hNTFRBQkxFKQorCQkJCQlvYmplY3RuYW1lID0gInhtbHRhYmxlIjsK KwkJCQllbHNlCQkJLyogTXVzdCBiZSBURlRfSlNPTl9UQUJMRSAqLworCQkJCQlvYmplY3RuYW1l ID0gImpzb25fdGFibGUiOworCQkJZWxzZQorCQkJCW9iamVjdG5hbWUgPSBOVUxMOwogCQkJb2Jq ZWN0dGFnID0gIlRhYmxlIEZ1bmN0aW9uIE5hbWUiOwogCQkJYnJlYWs7CiAJCWNhc2UgVF9WYWx1 ZXNTY2FuOgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY0V4cHJJbnRlcnAu YyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNFeHBySW50ZXJwLmMKaW5kZXggOTY0NDMzYTBl Ny4uM2Q0ZGZiODJiMCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY0V4cHJJ bnRlcnAuYworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjRXhwckludGVycC5jCkBAIC00 MzM0LDYgKzQzMzQsMTIgQEAgRXhlY0V2YWxKc29uRXhwclBhdGgoRXhwclN0YXRlICpzdGF0ZSwg RXhwckV2YWxTdGVwICpvcCwKIAkJCQlicmVhazsKIAkJCX0KIAorCQljYXNlIEpTT05fVEFCTEVf T1A6CisJCQlwb3N0X2V2YWwtPmp1bXBfZXZhbF9jb2VyY2lvbiA9IC0xOworCQkJKm9wLT5yZXN2 YWx1ZSA9IGl0ZW07CisJCQkqb3AtPnJlc251bGwgPSBmYWxzZTsKKwkJCWJyZWFrOworCiAJCWRl ZmF1bHQ6CiAJCQllbG9nKEVSUk9SLCAidW5yZWNvZ25pemVkIFNRTC9KU09OIGV4cHJlc3Npb24g b3AgJWQiLCBqZXhwci0+b3ApOwogCQkJcmV0dXJuIGZhbHNlOwpkaWZmIC0tZ2l0IGEvc3JjL2Jh Y2tlbmQvZXhlY3V0b3Ivbm9kZVRhYmxlRnVuY3NjYW4uYyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9y L25vZGVUYWJsZUZ1bmNzY2FuLmMKaW5kZXggNzJjYTM0YTIyOC4uOTlmYjkyODk0YyAxMDA2NDQK LS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZVRhYmxlRnVuY3NjYW4uYworKysgYi9zcmMv YmFja2VuZC9leGVjdXRvci9ub2RlVGFibGVGdW5jc2Nhbi5jCkBAIC0yOCw2ICsyOCw3IEBACiAj aW5jbHVkZSAibWlzY2FkbWluLmgiCiAjaW5jbHVkZSAibm9kZXMvZXhlY25vZGVzLmgiCiAjaW5j bHVkZSAidXRpbHMvYnVpbHRpbnMuaCIKKyNpbmNsdWRlICJ1dGlscy9qc29ucGF0aC5oIgogI2lu Y2x1ZGUgInV0aWxzL2xzeXNjYWNoZS5oIgogI2luY2x1ZGUgInV0aWxzL21lbXV0aWxzLmgiCiAj aW5jbHVkZSAidXRpbHMveG1sLmgiCkBAIC0xNjEsOCArMTYyLDkgQEAgRXhlY0luaXRUYWJsZUZ1 bmNTY2FuKFRhYmxlRnVuY1NjYW4gKm5vZGUsIEVTdGF0ZSAqZXN0YXRlLCBpbnQgZWZsYWdzKQog CXNjYW5zdGF0ZS0+c3MucHMucXVhbCA9CiAJCUV4ZWNJbml0UXVhbChub2RlLT5zY2FuLnBsYW4u cXVhbCwgJnNjYW5zdGF0ZS0+c3MucHMpOwogCi0JLyogT25seSBYTUxUQUJMRSBpcyBzdXBwb3J0 ZWQgY3VycmVudGx5ICovCi0Jc2NhbnN0YXRlLT5yb3V0aW5lID0gJlhtbFRhYmxlUm91dGluZTsK KwkvKiBPbmx5IFhNTFRBQkxFIGFuZCBKU09OX1RBQkxFIGFyZSBzdXBwb3J0ZWQgY3VycmVudGx5 ICovCisJc2NhbnN0YXRlLT5yb3V0aW5lID0KKwkJdGYtPmZ1bmN0eXBlID09IFRGVF9YTUxUQUJM RSA/ICZYbWxUYWJsZVJvdXRpbmUgOiAmSnNvbmJUYWJsZVJvdXRpbmU7CiAKIAlzY2Fuc3RhdGUt PnBlclRhYmxlQ3h0ID0KIAkJQWxsb2NTZXRDb250ZXh0Q3JlYXRlKEN1cnJlbnRNZW1vcnlDb250 ZXh0LApAQCAtMTgyLDYgKzE4NCwxMCBAQCBFeGVjSW5pdFRhYmxlRnVuY1NjYW4oVGFibGVGdW5j U2NhbiAqbm9kZSwgRVN0YXRlICplc3RhdGUsIGludCBlZmxhZ3MpCiAJCUV4ZWNJbml0RXhwckxp c3QodGYtPmNvbGV4cHJzLCAoUGxhblN0YXRlICopIHNjYW5zdGF0ZSk7CiAJc2NhbnN0YXRlLT5j b2xkZWZleHBycyA9CiAJCUV4ZWNJbml0RXhwckxpc3QodGYtPmNvbGRlZmV4cHJzLCAoUGxhblN0 YXRlICopIHNjYW5zdGF0ZSk7CisJc2NhbnN0YXRlLT5jb2x2YWxleHBycyA9CisJCUV4ZWNJbml0 RXhwckxpc3QodGYtPmNvbHZhbGV4cHJzLCAoUGxhblN0YXRlICopIHNjYW5zdGF0ZSk7CisJc2Nh bnN0YXRlLT5wYXNzaW5ndmFsZXhwcnMgPQorCQlFeGVjSW5pdEV4cHJMaXN0KHRmLT5wYXNzaW5n dmFsZXhwcnMsIChQbGFuU3RhdGUgKikgc2NhbnN0YXRlKTsKIAogCXNjYW5zdGF0ZS0+bm90bnVs bHMgPSB0Zi0+bm90bnVsbHM7CiAKQEAgLTM2OSwxNCArMzc1LDE3IEBAIHRmdW5jSW5pdGlhbGl6 ZShUYWJsZUZ1bmNTY2FuU3RhdGUgKnRzdGF0ZSwgRXhwckNvbnRleHQgKmVjb250ZXh0LCBEYXR1 bSBkb2MpCiAJCXJvdXRpbmUtPlNldE5hbWVzcGFjZSh0c3RhdGUsIG5zX25hbWUsIG5zX3VyaSk7 CiAJfQogCi0JLyogSW5zdGFsbCB0aGUgcm93IGZpbHRlciBleHByZXNzaW9uIGludG8gdGhlIHRh YmxlIGJ1aWxkZXIgY29udGV4dCAqLwotCXZhbHVlID0gRXhlY0V2YWxFeHByKHRzdGF0ZS0+cm93 ZXhwciwgZWNvbnRleHQsICZpc251bGwpOwotCWlmIChpc251bGwpCi0JCWVyZXBvcnQoRVJST1Is Ci0JCQkJKGVycmNvZGUoRVJSQ09ERV9OVUxMX1ZBTFVFX05PVF9BTExPV0VEKSwKLQkJCQkgZXJy bXNnKCJyb3cgZmlsdGVyIGV4cHJlc3Npb24gbXVzdCBub3QgYmUgbnVsbCIpKSk7CisJaWYgKHJv dXRpbmUtPlNldFJvd0ZpbHRlcikKKwl7CisJCS8qIEluc3RhbGwgdGhlIHJvdyBmaWx0ZXIgZXhw cmVzc2lvbiBpbnRvIHRoZSB0YWJsZSBidWlsZGVyIGNvbnRleHQgKi8KKwkJdmFsdWUgPSBFeGVj RXZhbEV4cHIodHN0YXRlLT5yb3dleHByLCBlY29udGV4dCwgJmlzbnVsbCk7CisJCWlmIChpc251 bGwpCisJCQllcmVwb3J0KEVSUk9SLAorCQkJCQkoZXJyY29kZShFUlJDT0RFX05VTExfVkFMVUVf Tk9UX0FMTE9XRUQpLAorCQkJCQkgZXJybXNnKCJyb3cgZmlsdGVyIGV4cHJlc3Npb24gbXVzdCBu b3QgYmUgbnVsbCIpKSk7CiAKLQlyb3V0aW5lLT5TZXRSb3dGaWx0ZXIodHN0YXRlLCBUZXh0RGF0 dW1HZXRDU3RyaW5nKHZhbHVlKSk7CisJCXJvdXRpbmUtPlNldFJvd0ZpbHRlcih0c3RhdGUsIFRl eHREYXR1bUdldENTdHJpbmcodmFsdWUpKTsKKwl9CiAKIAkvKgogCSAqIEluc3RhbGwgdGhlIGNv bHVtbiBmaWx0ZXIgZXhwcmVzc2lvbnMgaW50byB0aGUgdGFibGUgYnVpbGRlciBjb250ZXh0Lgpk aWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvbm9kZXMvbWFrZWZ1bmNzLmMgYi9zcmMvYmFja2VuZC9u b2Rlcy9tYWtlZnVuY3MuYwppbmRleCAwOWEwNWEwMzczLi5mMTYyMzFhMjAyIDEwMDY0NAotLS0g YS9zcmMvYmFja2VuZC9ub2Rlcy9tYWtlZnVuY3MuYworKysgYi9zcmMvYmFja2VuZC9ub2Rlcy9t YWtlZnVuY3MuYwpAQCAtNTM4LDYgKzUzOCwyMiBAQCBtYWtlRnVuY0V4cHIoT2lkIGZ1bmNpZCwg T2lkIHJldHR5cGUsIExpc3QgKmFyZ3MsCiAJcmV0dXJuIGZ1bmNleHByOwogfQogCisvKgorICog bWFrZVN0cmluZ0NvbnN0IC0KKyAqIAlidWlsZCBhIEFfQ29uc3Qgbm9kZSBvZiB0eXBlIFRfU3Ry aW5nIGZvciBnaXZlbiBzdHJpbmcKKyAqLworTm9kZSAqCittYWtlU3RyaW5nQ29uc3QoY2hhciAq c3RyLCBpbnQgbG9jYXRpb24pCit7CisJQV9Db25zdAkgICAqbiA9IG1ha2VOb2RlKEFfQ29uc3Qp OworCisJbi0+dmFsLnN2YWwudHlwZSA9IFRfU3RyaW5nOworCW4tPnZhbC5zdmFsLnN2YWwgPSBz dHI7CisJbi0+bG9jYXRpb24gPSBsb2NhdGlvbjsKKworICAgcmV0dXJuIChOb2RlICopIG47Cit9 CisKIC8qCiAgKiBtYWtlRGVmRWxlbSAtCiAgKglidWlsZCBhIERlZkVsZW0gbm9kZQpAQCAtODc1 LDYgKzg5MSw2NCBAQCBtYWtlSnNvbkJlaGF2aW9yKEpzb25CZWhhdmlvclR5cGUgdHlwZSwgTm9k ZSAqZXhwciwgSnNvbkNvZXJjaW9uICpjb2VyY2lvbiwKIAlyZXR1cm4gYmVoYXZpb3I7CiB9CiAK Ky8qCisgKiBtYWtlSnNvblRhYmxlUGF0aCAtCisgKgkJTWFrZSBKc29uVGFibGVQYXRoIG5vZGUg ZnJvbSBnaXZlbiBwYXRoIHN0cmluZyBhbmQgbmFtZSAoaWYgYW55KQorICovCitKc29uVGFibGVQ YXRoICoKK21ha2VKc29uVGFibGVQYXRoKENvbnN0ICpwYXRodmFsdWUsIGNoYXIgKnBhdGhuYW1l KQoreworCUpzb25UYWJsZVBhdGggKnBhdGggPSBtYWtlTm9kZShKc29uVGFibGVQYXRoKTsKKwor CUFzc2VydChJc0EocGF0aHZhbHVlLCBDb25zdCkpOworCXBhdGgtPnZhbHVlID0gcGF0aHZhbHVl OworCWlmIChwYXRobmFtZSkKKwkJcGF0aC0+bmFtZSA9IHBhdGhuYW1lOworCisJcmV0dXJuIHBh dGg7Cit9CisKKy8qCisgKiBtYWtlSnNvblRhYmxlUGF0aFNwZWMgLQorICoJCU1ha2UgSnNvblRh YmxlUGF0aFNwZWMgbm9kZSBmcm9tIGdpdmVuIHBhdGggc3RyaW5nIGFuZCBuYW1lIChpZiBhbnkp CisgKi8KK0pzb25UYWJsZVBhdGhTcGVjICoKK21ha2VKc29uVGFibGVQYXRoU3BlYyhjaGFyICpz dHJpbmcsIGNoYXIgKm5hbWUsIGludCBzdHJpbmdfbG9jYXRpb24sCisJCQkJCSAgaW50IG5hbWVf bG9jYXRpb24pCit7CisJSnNvblRhYmxlUGF0aFNwZWMgKnBhdGhzcGVjID0gbWFrZU5vZGUoSnNv blRhYmxlUGF0aFNwZWMpOworCisJQXNzZXJ0KHN0cmluZyAhPSBOVUxMKTsKKwlwYXRoc3BlYy0+ c3RyaW5nID0gbWFrZVN0cmluZ0NvbnN0KHN0cmluZywgc3RyaW5nX2xvY2F0aW9uKTsKKwlpZiAo bmFtZSAhPSBOVUxMKQorCQlwYXRoc3BlYy0+bmFtZSA9IHBzdHJkdXAobmFtZSk7CisKKwlwYXRo c3BlYy0+bmFtZV9sb2NhdGlvbiA9IG5hbWVfbG9jYXRpb247CisJcGF0aHNwZWMtPmxvY2F0aW9u ID0gc3RyaW5nX2xvY2F0aW9uOworCisJcmV0dXJuIHBhdGhzcGVjOworfQorCisvKgorICogbWFr ZUpzb25UYWJsZUpvaW5lZFBsYW4gLQorICoJICAgY3JlYXRlcyBhIEpzb25UYWJsZVBsYW5TcGVj IG5vZGUgdG8gcmVwcmVzZW50IGpvaW4gYmV0d2VlbiB0aGUgZ2l2ZW4KKyAqCSAgIHBhaXIgb2Yg cGxhbnMKKyAqLworTm9kZSAqCittYWtlSnNvblRhYmxlSm9pbmVkUGxhbihKc29uVGFibGVQbGFu Sm9pblR5cGUgdHlwZSwgTm9kZSAqcGxhbjEsIE5vZGUgKnBsYW4yLAorCQkJCQkJaW50IGxvY2F0 aW9uKQoreworCUpzb25UYWJsZVBsYW5TcGVjICpuID0gbWFrZU5vZGUoSnNvblRhYmxlUGxhblNw ZWMpOworCisJbi0+cGxhbl90eXBlID0gSlNUUF9KT0lORUQ7CisJbi0+am9pbl90eXBlID0gdHlw ZTsKKwluLT5wbGFuMSA9IGNhc3ROb2RlKEpzb25UYWJsZVBsYW5TcGVjLCBwbGFuMSk7CisJbi0+ cGxhbjIgPSBjYXN0Tm9kZShKc29uVGFibGVQbGFuU3BlYywgcGxhbjIpOworCW4tPmxvY2F0aW9u ID0gbG9jYXRpb247CisKKwlyZXR1cm4gKE5vZGUgKikgbjsKK30KKwogLyoKICAqIG1ha2VKc29u S2V5VmFsdWUgLQogICoJICBjcmVhdGVzIGEgSnNvbktleVZhbHVlIG5vZGUKZGlmZiAtLWdpdCBh L3NyYy9iYWNrZW5kL25vZGVzL25vZGVGdW5jcy5jIGIvc3JjL2JhY2tlbmQvbm9kZXMvbm9kZUZ1 bmNzLmMKaW5kZXggZDI3MjAyN2Y4YS4uYzY4Mzk5OGFiOSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tl bmQvbm9kZXMvbm9kZUZ1bmNzLmMKKysrIGIvc3JjL2JhY2tlbmQvbm9kZXMvbm9kZUZ1bmNzLmMK QEAgLTI2OTAsNiArMjY5MCwxMCBAQCBleHByZXNzaW9uX3RyZWVfd2Fsa2VyX2ltcGwoTm9kZSAq bm9kZSwKIAkJCQkJcmV0dXJuIHRydWU7CiAJCQkJaWYgKFdBTEsodGYtPmNvbGRlZmV4cHJzKSkK IAkJCQkJcmV0dXJuIHRydWU7CisJCQkJaWYgKFdBTEsodGYtPmNvbHZhbGV4cHJzKSkKKwkJCQkJ cmV0dXJuIHRydWU7CisJCQkJaWYgKFdBTEsodGYtPnBhc3Npbmd2YWxleHBycykpCisJCQkJCXJl dHVybiB0cnVlOwogCQkJfQogCQkJYnJlYWs7CiAJCWRlZmF1bHQ6CkBAIC0zNzUwLDYgKzM3NTQs OCBAQCBleHByZXNzaW9uX3RyZWVfbXV0YXRvcl9pbXBsKE5vZGUgKm5vZGUsCiAJCQkJTVVUQVRF KG5ld25vZGUtPnJvd2V4cHIsIHRmLT5yb3dleHByLCBOb2RlICopOwogCQkJCU1VVEFURShuZXdu b2RlLT5jb2xleHBycywgdGYtPmNvbGV4cHJzLCBMaXN0ICopOwogCQkJCU1VVEFURShuZXdub2Rl LT5jb2xkZWZleHBycywgdGYtPmNvbGRlZmV4cHJzLCBMaXN0ICopOworCQkJCU1VVEFURShuZXdu b2RlLT5jb2x2YWxleHBycywgdGYtPmNvbHZhbGV4cHJzLCBMaXN0ICopOworCQkJCU1VVEFURShu ZXdub2RlLT5wYXNzaW5ndmFsZXhwcnMsIHRmLT5wYXNzaW5ndmFsZXhwcnMsIExpc3QgKik7CiAJ CQkJcmV0dXJuIChOb2RlICopIG5ld25vZGU7CiAJCQl9CiAJCQlicmVhazsKQEAgLTQxNzQsNiAr NDE4MCwzOCBAQCByYXdfZXhwcmVzc2lvbl90cmVlX3dhbGtlcl9pbXBsKE5vZGUgKm5vZGUsCiAJ CQkJCXJldHVybiB0cnVlOwogCQkJfQogCQkJYnJlYWs7CisJCWNhc2UgVF9Kc29uVGFibGU6CisJ CQl7CisJCQkJSnNvblRhYmxlICAqanQgPSAoSnNvblRhYmxlICopIG5vZGU7CisKKwkJCQlpZiAo V0FMSyhqdC0+Y29udGV4dF9pdGVtKSkKKwkJCQkJcmV0dXJuIHRydWU7CisJCQkJaWYgKFdBTEso anQtPnBhdGhzcGVjKSkKKwkJCQkJcmV0dXJuIHRydWU7CisJCQkJaWYgKFdBTEsoanQtPnBhc3Np bmcpKQorCQkJCQlyZXR1cm4gdHJ1ZTsKKwkJCQlpZiAoV0FMSyhqdC0+Y29sdW1ucykpCisJCQkJ CXJldHVybiB0cnVlOworCQkJCWlmIChXQUxLKGp0LT5vbl9lcnJvcikpCisJCQkJCXJldHVybiB0 cnVlOworCQkJfQorCQkJYnJlYWs7CisJCWNhc2UgVF9Kc29uVGFibGVDb2x1bW46CisJCQl7CisJ CQkJSnNvblRhYmxlQ29sdW1uICpqdGMgPSAoSnNvblRhYmxlQ29sdW1uICopIG5vZGU7CisKKwkJ CQlpZiAoV0FMSyhqdGMtPnR5cGVOYW1lKSkKKwkJCQkJcmV0dXJuIHRydWU7CisJCQkJaWYgKFdB TEsoanRjLT5vbl9lbXB0eSkpCisJCQkJCXJldHVybiB0cnVlOworCQkJCWlmIChXQUxLKGp0Yy0+ b25fZXJyb3IpKQorCQkJCQlyZXR1cm4gdHJ1ZTsKKwkJCQlpZiAoanRjLT5jb2x0eXBlID09IEpU Q19ORVNURUQgJiYgV0FMSyhqdGMtPmNvbHVtbnMpKQorCQkJCQlyZXR1cm4gdHJ1ZTsKKwkJCX0K KwkJCWJyZWFrOworCQljYXNlIFRfSnNvblRhYmxlUGF0aFNwZWM6CisJCQlyZXR1cm4gV0FMSygo KEpzb25UYWJsZVBhdGhTcGVjICopIG5vZGUpLT5zdHJpbmcpOwogCQljYXNlIFRfTnVsbFRlc3Q6 CiAJCQlyZXR1cm4gV0FMSygoKE51bGxUZXN0ICopIG5vZGUpLT5hcmcpOwogCQljYXNlIFRfQm9v bGVhblRlc3Q6CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9wYXJzZXIvTWFrZWZpbGUgYi9zcmMv YmFja2VuZC9wYXJzZXIvTWFrZWZpbGUKaW5kZXggNDAxYzE2Njg2Yy4uMzE2MmEwMWYzMCAxMDA2 NDQKLS0tIGEvc3JjL2JhY2tlbmQvcGFyc2VyL01ha2VmaWxlCisrKyBiL3NyYy9iYWNrZW5kL3Bh cnNlci9NYWtlZmlsZQpAQCAtMjMsNiArMjMsNyBAQCBPQkpTID0gXAogCXBhcnNlX2Vuci5vIFwK IAlwYXJzZV9leHByLm8gXAogCXBhcnNlX2Z1bmMubyBcCisJcGFyc2VfanNvbnRhYmxlLm8gXAog CXBhcnNlX21lcmdlLm8gXAogCXBhcnNlX25vZGUubyBcCiAJcGFyc2Vfb3Blci5vIFwKZGlmZiAt LWdpdCBhL3NyYy9iYWNrZW5kL3BhcnNlci9ncmFtLnkgYi9zcmMvYmFja2VuZC9wYXJzZXIvZ3Jh bS55CmluZGV4IGFkOTVhZjBkOTEuLmQ5ODk3YjFjYTggMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5k L3BhcnNlci9ncmFtLnkKKysrIGIvc3JjL2JhY2tlbmQvcGFyc2VyL2dyYW0ueQpAQCAtMTcwLDcg KzE3MCw2IEBAIHN0YXRpYyB2b2lkIHVwZGF0ZVJhd1N0bXRFbmQoUmF3U3RtdCAqcnMsIGludCBl bmRfbG9jYXRpb24pOwogc3RhdGljIE5vZGUgKm1ha2VDb2x1bW5SZWYoY2hhciAqY29sbmFtZSwg TGlzdCAqaW5kaXJlY3Rpb24sCiAJCQkJCQkgICBpbnQgbG9jYXRpb24sIGNvcmVfeXlzY2FuX3Qg eXlzY2FubmVyKTsKIHN0YXRpYyBOb2RlICptYWtlVHlwZUNhc3QoTm9kZSAqYXJnLCBUeXBlTmFt ZSAqdHlwZW5hbWUsIGludCBsb2NhdGlvbik7Ci1zdGF0aWMgTm9kZSAqbWFrZVN0cmluZ0NvbnN0 KGNoYXIgKnN0ciwgaW50IGxvY2F0aW9uKTsKIHN0YXRpYyBOb2RlICptYWtlU3RyaW5nQ29uc3RD YXN0KGNoYXIgKnN0ciwgaW50IGxvY2F0aW9uLCBUeXBlTmFtZSAqdHlwZW5hbWUpOwogc3RhdGlj IE5vZGUgKm1ha2VJbnRDb25zdChpbnQgdmFsLCBpbnQgbG9jYXRpb24pOwogc3RhdGljIE5vZGUg Km1ha2VGbG9hdENvbnN0KGNoYXIgKnN0ciwgaW50IGxvY2F0aW9uKTsKQEAgLTY1NCwxNSArNjUz LDMxIEBAIHN0YXRpYyBOb2RlICptYWtlUmVjdXJzaXZlVmlld1NlbGVjdChjaGFyICpyZWxuYW1l LCBMaXN0ICphbGlhc2VzLCBOb2RlICpxdWVyeSk7CiAJCQkJanNvbl9hcmd1bWVudAogCQkJCWpz b25fYmVoYXZpb3IKIAkJCQlqc29uX29uX2Vycm9yX2NsYXVzZV9vcHQKKwkJCQlqc29uX3RhYmxl CisJCQkJanNvbl90YWJsZV9jb2x1bW5fZGVmaW5pdGlvbgorCQkJCWpzb25fdGFibGVfY29sdW1u X3BhdGhfY2xhdXNlX29wdAorCQkJCWpzb25fdGFibGVfcGxhbl9jbGF1c2Vfb3B0CisJCQkJanNv bl90YWJsZV9wbGFuCisJCQkJanNvbl90YWJsZV9wbGFuX3NpbXBsZQorCQkJCWpzb25fdGFibGVf cGxhbl9vdXRlcgorCQkJCWpzb25fdGFibGVfcGxhbl9pbm5lcgorCQkJCWpzb25fdGFibGVfcGxh bl91bmlvbgorCQkJCWpzb25fdGFibGVfcGxhbl9jcm9zcworCQkJCWpzb25fdGFibGVfcGxhbl9w cmltYXJ5CiAldHlwZSA8bGlzdD4JanNvbl9uYW1lX2FuZF92YWx1ZV9saXN0CiAJCQkJanNvbl92 YWx1ZV9leHByX2xpc3QKIAkJCQlqc29uX2FycmF5X2FnZ3JlZ2F0ZV9vcmRlcl9ieV9jbGF1c2Vf b3B0CiAJCQkJanNvbl9hcmd1bWVudHMKIAkJCQlqc29uX2JlaGF2aW9yX2NsYXVzZV9vcHQKIAkJ CQlqc29uX3Bhc3NpbmdfY2xhdXNlX29wdAorCQkJCWpzb25fdGFibGVfY29sdW1uX2RlZmluaXRp b25fbGlzdAorJXR5cGUgPHN0cj4JCWpzb25fdGFibGVfcGF0aF9uYW1lX29wdAogJXR5cGUgPGl2 YWw+CWpzb25fYmVoYXZpb3JfdHlwZQogCQkJCWpzb25fcHJlZGljYXRlX3R5cGVfY29uc3RyYWlu dAogCQkJCWpzb25fcXVvdGVzX2NsYXVzZV9vcHQKKwkJCQlqc29uX3RhYmxlX2RlZmF1bHRfcGxh bl9jaG9pY2VzCisJCQkJanNvbl90YWJsZV9kZWZhdWx0X3BsYW5faW5uZXJfb3V0ZXIKKwkJCQlq c29uX3RhYmxlX2RlZmF1bHRfcGxhbl91bmlvbl9jcm9zcwogCQkJCWpzb25fd3JhcHBlcl9iZWhh dmlvcgogJXR5cGUgPGJvb2xlYW4+CWpzb25fa2V5X3VuaXF1ZW5lc3NfY29uc3RyYWludF9vcHQK IAkJCQlqc29uX29iamVjdF9jb25zdHJ1Y3Rvcl9udWxsX2NsYXVzZV9vcHQKQEAgLTczMiw3ICs3 NDcsNyBAQCBzdGF0aWMgTm9kZSAqbWFrZVJlY3Vyc2l2ZVZpZXdTZWxlY3QoY2hhciAqcmVsbmFt ZSwgTGlzdCAqYWxpYXNlcywgTm9kZSAqcXVlcnkpOwogCUlOVEVSU0VDVCBJTlRFUlZBTCBJTlRP IElOVk9LRVIgSVMgSVNOVUxMIElTT0xBVElPTgogCiAJSk9JTiBKU09OIEpTT05fQVJSQVkgSlNP Tl9BUlJBWUFHRyBKU09OX0VYSVNUUyBKU09OX09CSkVDVCBKU09OX09CSkVDVEFHRwotCUpTT05f UVVFUlkgSlNPTl9TQ0FMQVIgSlNPTl9TRVJJQUxJWkUgSlNPTl9WQUxVRQorCUpTT05fUVVFUlkg SlNPTl9TQ0FMQVIgSlNPTl9TRVJJQUxJWkUgSlNPTl9UQUJMRSBKU09OX1ZBTFVFCiAKIAlLRUVQ IEtFWSBLRVlTCiAKQEAgLTc0Myw4ICs3NTgsOCBAQCBzdGF0aWMgTm9kZSAqbWFrZVJlY3Vyc2l2 ZVZpZXdTZWxlY3QoY2hhciAqcmVsbmFtZSwgTGlzdCAqYWxpYXNlcywgTm9kZSAqcXVlcnkpOwog CU1BUFBJTkcgTUFUQ0ggTUFUQ0hFRCBNQVRFUklBTElaRUQgTUFYVkFMVUUgTUVSR0UgTUVUSE9E CiAJTUlOVVRFX1AgTUlOVkFMVUUgTU9ERSBNT05USF9QIE1PVkUKIAotCU5BTUVfUCBOQU1FUyBO QVRJT05BTCBOQVRVUkFMIE5DSEFSIE5FVyBORVhUIE5GQyBORkQgTkZLQyBORktEIE5PIE5PTkUK LQlOT1JNQUxJWkUgTk9STUFMSVpFRAorCU5BTUVfUCBOQU1FUyBOQVRJT05BTCBOQVRVUkFMIE5D SEFSIE5FU1RFRCBORVcgTkVYVCBORkMgTkZEIE5GS0MgTkZLRCBOTworCU5PTkUgTk9STUFMSVpF IE5PUk1BTElaRUQKIAlOT1QgTk9USElORyBOT1RJRlkgTk9UTlVMTCBOT1dBSVQgTlVMTF9QIE5V TExJRgogCU5VTExTX1AgTlVNRVJJQwogCkBAIC03NTIsOCArNzY3LDggQEAgc3RhdGljIE5vZGUg Km1ha2VSZWN1cnNpdmVWaWV3U2VsZWN0KGNoYXIgKnJlbG5hbWUsIExpc3QgKmFsaWFzZXMsIE5v ZGUgKnF1ZXJ5KTsKIAlPUkRFUiBPUkRJTkFMSVRZIE9USEVSUyBPVVRfUCBPVVRFUl9QCiAJT1ZF UiBPVkVSTEFQUyBPVkVSTEFZIE9WRVJSSURJTkcgT1dORUQgT1dORVIKIAotCVBBUkFMTEVMIFBB UkFNRVRFUiBQQVJTRVIgUEFSVElBTCBQQVJUSVRJT04gUEFTU0lORyBQQVNTV09SRAotCVBMQUNJ TkcgUExBTlMgUE9MSUNZCisJUEFSQUxMRUwgUEFSQU1FVEVSIFBBUlNFUiBQQVJUSUFMIFBBUlRJ VElPTiBQQVNTSU5HIFBBU1NXT1JEIFBBVEgKKwlQTEFDSU5HIFBMQU4gUExBTlMgUE9MSUNZCiAJ UE9TSVRJT04gUFJFQ0VESU5HIFBSRUNJU0lPTiBQUkVTRVJWRSBQUkVQQVJFIFBSRVBBUkVEIFBS SU1BUlkKIAlQUklPUiBQUklWSUxFR0VTIFBST0NFRFVSQUwgUFJPQ0VEVVJFIFBST0NFRFVSRVMg UFJPR1JBTSBQVUJMSUNBVElPTgogCkBAIC04NzEsMTAgKzg4NiwxMyBAQCBzdGF0aWMgTm9kZSAq bWFrZVJlY3Vyc2l2ZVZpZXdTZWxlY3QoY2hhciAqcmVsbmFtZSwgTGlzdCAqYWxpYXNlcywgTm9k ZSAqcXVlcnkpOwogICogdGhlIHNhbWUgcHJlY2VkZW5jZSBhcyBJREVOVC4gIFRoaXMgYWxsb3dz IHJlc29sdmluZyBjb25mbGljdHMgaW4gdGhlCiAgKiBqc29uX3ByZWRpY2F0ZV90eXBlX2NvbnN0 cmFpbnQgYW5kIGpzb25fa2V5X3VuaXF1ZW5lc3NfY29uc3RyYWludF9vcHQKICAqIHByb2R1Y3Rp b25zIChzZWUgY29tbWVudHMgdGhlcmUpLgorICoKKyAqIExpa2UgdGhlIFVOQk9VTkRFRCBQUkVD RURJTkcvRk9MTE9XSU5HIGNhc2UsIE5FU1RFRCBpcyBhc3NpZ25lZCBhIGxvd2VyCisgKiBwcmVj ZWRlbmNlIHRoYW4gUEFUSCB0byBmaXggYW1iaWd1aXR5IGluIHRoZSBqc29uX3RhYmxlIHByb2R1 Y3Rpb24uCiAgKi8KLSVub25hc3NvYwlVTkJPVU5ERUQJCS8qIGlkZWFsbHkgd291bGQgaGF2ZSBz YW1lIHByZWNlZGVuY2UgYXMgSURFTlQgKi8KKyVub25hc3NvYwlVTkJPVU5ERUQgTkVTVEVEIC8q IGlkZWFsbHkgd291bGQgaGF2ZSBzYW1lIHByZWNlZGVuY2UgYXMgSURFTlQgKi8KICVub25hc3Nv YwlJREVOVCBQQVJUSVRJT04gUkFOR0UgUk9XUyBHUk9VUFMgUFJFQ0VESU5HIEZPTExPV0lORyBD VUJFIFJPTExVUAotCQkJU0VUIEtFWVMgT0JKRUNUX1AgU0NBTEFSIFZBTFVFX1AgV0lUSCBXSVRI T1VUCisJCQlTRVQgS0VZUyBPQkpFQ1RfUCBTQ0FMQVIgVkFMVUVfUCBXSVRIIFdJVEhPVVQgUEFU SAogJWxlZnQJCU9wIE9QRVJBVE9SCQkvKiBtdWx0aS1jaGFyYWN0ZXIgb3BzIGFuZCB1c2VyLWRl ZmluZWQgb3BlcmF0b3JzICovCiAlbGVmdAkJJysnICctJwogJWxlZnQJCScqJyAnLycgJyUnCkBA IC04OTUsNyArOTEzLDYgQEAgc3RhdGljIE5vZGUgKm1ha2VSZWN1cnNpdmVWaWV3U2VsZWN0KGNo YXIgKnJlbG5hbWUsIExpc3QgKmFsaWFzZXMsIE5vZGUgKnF1ZXJ5KTsKICAqIGxlZnQtYXNzb2Np YXRpdml0eSBhbW9uZyB0aGUgSk9JTiBydWxlcyB0aGVtc2VsdmVzLgogICovCiAlbGVmdAkJSk9J TiBDUk9TUyBMRUZUIEZVTEwgUklHSFQgSU5ORVJfUCBOQVRVUkFMCi0KICUlCiAKIC8qCkBAIC0x MzQzMiw2ICsxMzQ0OSwyMSBAQCB0YWJsZV9yZWY6CXJlbGF0aW9uX2V4cHIgb3B0X2FsaWFzX2Ns YXVzZQogCQkJCQkkMi0+YWxpYXMgPSAkNDsKIAkJCQkJJCQgPSAoTm9kZSAqKSAkMjsKIAkJCQl9 CisJCQl8IGpzb25fdGFibGUgb3B0X2FsaWFzX2NsYXVzZQorCQkJCXsKKwkJCQkJSnNvblRhYmxl ICAqanQgPSBjYXN0Tm9kZShKc29uVGFibGUsICQxKTsKKworCQkJCQlqdC0+YWxpYXMgPSAkMjsK KwkJCQkJJCQgPSAoTm9kZSAqKSBqdDsKKwkJCQl9CisJCQl8IExBVEVSQUxfUCBqc29uX3RhYmxl IG9wdF9hbGlhc19jbGF1c2UKKwkJCQl7CisJCQkJCUpzb25UYWJsZSAgKmp0ID0gY2FzdE5vZGUo SnNvblRhYmxlLCAkMik7CisKKwkJCQkJanQtPmFsaWFzID0gJDM7CisJCQkJCWp0LT5sYXRlcmFs ID0gdHJ1ZTsKKwkJCQkJJCQgPSAoTm9kZSAqKSBqdDsKKwkJCQl9CiAJCTsKIAogCkBAIC0xMzk5 OSw2ICsxNDAzMSw4IEBAIHhtbHRhYmxlX2NvbHVtbl9vcHRpb25fZWw6CiAJCQkJeyAkJCA9IG1h a2VEZWZFbGVtKCJpc19ub3RfbnVsbCIsIChOb2RlICopIG1ha2VCb29sZWFuKHRydWUpLCBAMSk7 IH0KIAkJCXwgTlVMTF9QCiAJCQkJeyAkJCA9IG1ha2VEZWZFbGVtKCJpc19ub3RfbnVsbCIsIChO b2RlICopIG1ha2VCb29sZWFuKGZhbHNlKSwgQDEpOyB9CisJCQl8IFBBVEggYl9leHByCisJCQkJ eyAkJCA9IG1ha2VEZWZFbGVtKCJwYXRoIiwgJDIsIEAxKTsgfQogCQk7CiAKIHhtbF9uYW1lc3Bh Y2VfbGlzdDoKQEAgLTE2NjkwLDYgKzE2NzI0LDI0MCBAQCBqc29uX3F1b3Rlc19jbGF1c2Vfb3B0 OgogCQkJfCAvKiBFTVBUWSAqLwkJCQkJCXsgJCQgPSBKU19RVU9URVNfVU5TUEVDOyB9CiAJCTsK IAoranNvbl90YWJsZToKKwkJCUpTT05fVEFCTEUgJygnCisJCQkJanNvbl92YWx1ZV9leHByICcs JyBhX2V4cHIganNvbl90YWJsZV9wYXRoX25hbWVfb3B0CisJCQkJanNvbl9wYXNzaW5nX2NsYXVz ZV9vcHQKKwkJCQlDT0xVTU5TICcoJyBqc29uX3RhYmxlX2NvbHVtbl9kZWZpbml0aW9uX2xpc3Qg JyknCisJCQkJanNvbl90YWJsZV9wbGFuX2NsYXVzZV9vcHQKKwkJCQlqc29uX29uX2Vycm9yX2Ns YXVzZV9vcHQKKwkJCScpJworCQkJCXsKKwkJCQkJSnNvblRhYmxlICpuID0gbWFrZU5vZGUoSnNv blRhYmxlKTsKKwkJCQkJY2hhcgkgICpwYXRoc3RyaW5nOworCisJCQkJCW4tPmNvbnRleHRfaXRl bSA9IChKc29uVmFsdWVFeHByICopICQzOworCQkJCQlpZiAoIUlzQSgkNSwgQV9Db25zdCkgfHwK KwkJCQkJCWNhc3ROb2RlKEFfQ29uc3QsICQ1KS0+dmFsLm5vZGUudHlwZSAhPSBUX1N0cmluZykK KwkJCQkJCWVyZXBvcnQoRVJST1IsCisJCQkJCQkJCWVycmNvZGUoRVJSQ09ERV9GRUFUVVJFX05P VF9TVVBQT1JURUQpLAorCQkJCQkJCQllcnJtc2coIm9ubHkgc3RyaW5nIGNvbnN0YW50cyBhcmUg c3VwcG9ydGVkIGluIEpTT05fVEFCTEUiCisJCQkJCQkJCQkgICAiIHBhdGggc3BlY2lmaWNhdGlv biIpLAorCQkJCQkJCQlwYXJzZXJfZXJycG9zaXRpb24oQDUpKTsKKwkJCQkJcGF0aHN0cmluZyA9 IGNhc3ROb2RlKEFfQ29uc3QsICQ1KS0+dmFsLnN2YWwuc3ZhbDsKKwkJCQkJbi0+cGF0aHNwZWMg PSBtYWtlSnNvblRhYmxlUGF0aFNwZWMocGF0aHN0cmluZywgJDYsIEA1LCBANik7CisJCQkJCW4t PnBhc3NpbmcgPSAkNzsKKwkJCQkJbi0+Y29sdW1ucyA9ICQxMDsKKwkJCQkJbi0+cGxhbnNwZWMg PSAoSnNvblRhYmxlUGxhblNwZWMgKikgJDEyOworCQkJCQluLT5vbl9lcnJvciA9IChKc29uQmVo YXZpb3IgKikgJDEzOworCQkJCQluLT5sb2NhdGlvbiA9IEAxOworCQkJCQkkJCA9IChOb2RlICop IG47CisJCQkJfQorCQk7CisKK2pzb25fdGFibGVfcGF0aF9uYW1lX29wdDoKKwkJCUFTIG5hbWUJ CQl7ICQkID0gJDI7IH0KKwkJCXwgLyogZW1wdHkgKi8JeyAkJCA9IE5VTEw7IH0KKwkJOworCitq c29uX3RhYmxlX2NvbHVtbl9kZWZpbml0aW9uX2xpc3Q6CisJCQlqc29uX3RhYmxlX2NvbHVtbl9k ZWZpbml0aW9uCisJCQkJeyAkJCA9IGxpc3RfbWFrZTEoJDEpOyB9CisJCQl8IGpzb25fdGFibGVf Y29sdW1uX2RlZmluaXRpb25fbGlzdCAnLCcganNvbl90YWJsZV9jb2x1bW5fZGVmaW5pdGlvbgor CQkJCXsgJCQgPSBsYXBwZW5kKCQxLCAkMyk7IH0KKwkJOworCitqc29uX3RhYmxlX2NvbHVtbl9k ZWZpbml0aW9uOgorCQkJQ29sSWQgRk9SIE9SRElOQUxJVFkKKwkJCQl7CisJCQkJCUpzb25UYWJs ZUNvbHVtbiAqbiA9IG1ha2VOb2RlKEpzb25UYWJsZUNvbHVtbik7CisKKwkJCQkJbi0+Y29sdHlw ZSA9IEpUQ19GT1JfT1JESU5BTElUWTsKKwkJCQkJbi0+bmFtZSA9ICQxOworCQkJCQluLT5sb2Nh dGlvbiA9IEAxOworCQkJCQkkJCA9IChOb2RlICopIG47CisJCQkJfQorCQkJfCBDb2xJZCBUeXBl bmFtZQorCQkJCWpzb25fdGFibGVfY29sdW1uX3BhdGhfY2xhdXNlX29wdAorCQkJCWpzb25fd3Jh cHBlcl9iZWhhdmlvcgorCQkJCWpzb25fcXVvdGVzX2NsYXVzZV9vcHQKKwkJCQlqc29uX2JlaGF2 aW9yX2NsYXVzZV9vcHQKKwkJCQl7CisJCQkJCUpzb25UYWJsZUNvbHVtbiAqbiA9IG1ha2VOb2Rl KEpzb25UYWJsZUNvbHVtbik7CisKKwkJCQkJbi0+Y29sdHlwZSA9IEpUQ19SRUdVTEFSOworCQkJ CQluLT5uYW1lID0gJDE7CisJCQkJCW4tPnR5cGVOYW1lID0gJDI7CisJCQkJCW4tPmZvcm1hdCA9 IG1ha2VKc29uRm9ybWF0KEpTX0ZPUk1BVF9ERUZBVUxULCBKU19FTkNfREVGQVVMVCwgLTEpOwor CQkJCQluLT5wYXRoc3BlYyA9IChKc29uVGFibGVQYXRoU3BlYyAqKSAkMzsKKwkJCQkJbi0+d3Jh cHBlciA9ICQ0OyAvKiBkaXNhbGxvd2VkIGR1cmluZyBwYXJzZS1hbmFseXNpcyEgKi8KKwkJCQkJ bi0+cXVvdGVzID0gJDU7IC8qIGRpc2FsbG93ZWQgZHVyaW5nIHBhcnNlLWFuYWx5c2lzISAqLwor CQkJCQluLT5vbl9lbXB0eSA9IChKc29uQmVoYXZpb3IgKikgbGluaXRpYWwoJDYpOworCQkJCQlu LT5vbl9lcnJvciA9IChKc29uQmVoYXZpb3IgKikgbHNlY29uZCgkNik7CisJCQkJCW4tPmxvY2F0 aW9uID0gQDE7CisJCQkJCSQkID0gKE5vZGUgKikgbjsKKwkJCQl9CisJCQl8IENvbElkIFR5cGVu YW1lIGpzb25fZm9ybWF0X2NsYXVzZQorCQkJCWpzb25fdGFibGVfY29sdW1uX3BhdGhfY2xhdXNl X29wdAorCQkJCWpzb25fd3JhcHBlcl9iZWhhdmlvcgorCQkJCWpzb25fcXVvdGVzX2NsYXVzZV9v cHQKKwkJCQlqc29uX2JlaGF2aW9yX2NsYXVzZV9vcHQKKwkJCQl7CisJCQkJCUpzb25UYWJsZUNv bHVtbiAqbiA9IG1ha2VOb2RlKEpzb25UYWJsZUNvbHVtbik7CisKKwkJCQkJbi0+Y29sdHlwZSA9 IEpUQ19GT1JNQVRURUQ7CisJCQkJCW4tPm5hbWUgPSAkMTsKKwkJCQkJbi0+dHlwZU5hbWUgPSAk MjsKKwkJCQkJbi0+Zm9ybWF0ID0gKEpzb25Gb3JtYXQgKikgJDM7CisJCQkJCW4tPnBhdGhzcGVj ID0gKEpzb25UYWJsZVBhdGhTcGVjICopICQ0OworCQkJCQluLT53cmFwcGVyID0gJDU7CisJCQkJ CW4tPnF1b3RlcyA9ICQ2OworCQkJCQluLT5vbl9lbXB0eSA9IChKc29uQmVoYXZpb3IgKikgbGlu aXRpYWwoJDcpOworCQkJCQluLT5vbl9lcnJvciA9IChKc29uQmVoYXZpb3IgKikgbHNlY29uZCgk Nyk7CisJCQkJCW4tPmxvY2F0aW9uID0gQDE7CisJCQkJCSQkID0gKE5vZGUgKikgbjsKKwkJCQl9 CisJCQl8IENvbElkIFR5cGVuYW1lCisJCQkJRVhJU1RTIGpzb25fdGFibGVfY29sdW1uX3BhdGhf Y2xhdXNlX29wdAorCQkJCWpzb25fYmVoYXZpb3JfY2xhdXNlX29wdAorCQkJCXsKKwkJCQkJSnNv blRhYmxlQ29sdW1uICpuID0gbWFrZU5vZGUoSnNvblRhYmxlQ29sdW1uKTsKKworCQkJCQluLT5j b2x0eXBlID0gSlRDX0VYSVNUUzsKKwkJCQkJbi0+bmFtZSA9ICQxOworCQkJCQluLT50eXBlTmFt ZSA9ICQyOworCQkJCQluLT5mb3JtYXQgPSBtYWtlSnNvbkZvcm1hdChKU19GT1JNQVRfREVGQVVM VCwgSlNfRU5DX0RFRkFVTFQsIC0xKTsKKwkJCQkJbi0+d3JhcHBlciA9IEpTV19OT05FOworCQkJ CQluLT5xdW90ZXMgPSBKU19RVU9URVNfVU5TUEVDOworCQkJCQluLT5wYXRoc3BlYyA9IChKc29u VGFibGVQYXRoU3BlYyAqKSAkNDsKKwkJCQkJbi0+b25fZW1wdHkgPSAoSnNvbkJlaGF2aW9yICop IGxpbml0aWFsKCQ1KTsKKwkJCQkJbi0+b25fZXJyb3IgPSAoSnNvbkJlaGF2aW9yICopIGxzZWNv bmQoJDUpOworCQkJCQluLT5sb2NhdGlvbiA9IEAxOworCQkJCQkkJCA9IChOb2RlICopIG47CisJ CQkJfQorCQkJfCBORVNURUQgcGF0aF9vcHQgU2NvbnN0CisJCQkJQ09MVU1OUyAnKCcganNvbl90 YWJsZV9jb2x1bW5fZGVmaW5pdGlvbl9saXN0ICcpJworCQkJCXsKKwkJCQkJSnNvblRhYmxlQ29s dW1uICpuID0gbWFrZU5vZGUoSnNvblRhYmxlQ29sdW1uKTsKKworCQkJCQluLT5jb2x0eXBlID0g SlRDX05FU1RFRDsKKwkJCQkJbi0+cGF0aHNwZWMgPSBtYWtlSnNvblRhYmxlUGF0aFNwZWMoJDMs IE5VTEwsIEAzLCAtMSk7CisJCQkJCW4tPmNvbHVtbnMgPSAkNjsKKwkJCQkJbi0+bG9jYXRpb24g PSBAMTsKKwkJCQkJJCQgPSAoTm9kZSAqKSBuOworCQkJCX0KKwkJCXwgTkVTVEVEIHBhdGhfb3B0 IFNjb25zdCBBUyBuYW1lCisJCQkJQ09MVU1OUyAnKCcganNvbl90YWJsZV9jb2x1bW5fZGVmaW5p dGlvbl9saXN0ICcpJworCQkJCXsKKwkJCQkJSnNvblRhYmxlQ29sdW1uICpuID0gbWFrZU5vZGUo SnNvblRhYmxlQ29sdW1uKTsKKworCQkJCQluLT5jb2x0eXBlID0gSlRDX05FU1RFRDsKKwkJCQkJ bi0+cGF0aHNwZWMgPSBtYWtlSnNvblRhYmxlUGF0aFNwZWMoJDMsICQ1LCBAMywgQDUpOworCQkJ CQluLT5jb2x1bW5zID0gJDg7CisJCQkJCW4tPmxvY2F0aW9uID0gQDE7CisJCQkJCSQkID0gKE5v ZGUgKikgbjsKKwkJCQl9CisJCTsKKworcGF0aF9vcHQ6CisJCQlQQVRICisJCQl8IC8qIEVNUFRZ ICovCisJCTsKKworanNvbl90YWJsZV9jb2x1bW5fcGF0aF9jbGF1c2Vfb3B0OgorCQkJUEFUSCBT Y29uc3QKKwkJCQl7ICQkID0gKE5vZGUgKikgbWFrZUpzb25UYWJsZVBhdGhTcGVjKCQyLCBOVUxM LCBAMiwgLTEpOyB9CisJCQl8IC8qIEVNUFRZICovCXsgJCQgPSBOVUxMOyB9CisJCTsKKworanNv bl90YWJsZV9wbGFuX2NsYXVzZV9vcHQ6CisJCQlQTEFOICcoJyBqc29uX3RhYmxlX3BsYW4gJykn CQkJeyAkJCA9ICQzOyB9CisJCQl8IFBMQU4gREVGQVVMVCAnKCcganNvbl90YWJsZV9kZWZhdWx0 X3BsYW5fY2hvaWNlcyAnKScKKwkJCQl7CisJCQkJCUpzb25UYWJsZVBsYW5TcGVjICpuID0gbWFr ZU5vZGUoSnNvblRhYmxlUGxhblNwZWMpOworCisJCQkJCW4tPnBsYW5fdHlwZSA9IEpTVFBfREVG QVVMVDsKKwkJCQkJbi0+am9pbl90eXBlID0gJDQ7CisJCQkJCW4tPmxvY2F0aW9uID0gQDE7CisJ CQkJCSQkID0gKE5vZGUgKikgbjsKKwkJCQl9CisJCQl8IC8qIEVNUFRZICovCQkJCQkJCXsgJCQg PSBOVUxMOyB9CisJCTsKKworanNvbl90YWJsZV9wbGFuOgorCQkJanNvbl90YWJsZV9wbGFuX3Np bXBsZQorCQkJfCBqc29uX3RhYmxlX3BsYW5fb3V0ZXIKKwkJCXwganNvbl90YWJsZV9wbGFuX2lu bmVyCisJCQl8IGpzb25fdGFibGVfcGxhbl91bmlvbgorCQkJfCBqc29uX3RhYmxlX3BsYW5fY3Jv c3MKKwkJOworCitqc29uX3RhYmxlX3BsYW5fc2ltcGxlOgorCQkJbmFtZQorCQkJCXsKKwkJCQkJ SnNvblRhYmxlUGxhblNwZWMgKm4gPSBtYWtlTm9kZShKc29uVGFibGVQbGFuU3BlYyk7CisKKwkJ CQkJbi0+cGxhbl90eXBlID0gSlNUUF9TSU1QTEU7CisJCQkJCW4tPnBhdGhuYW1lID0gJDE7CisJ CQkJCW4tPmxvY2F0aW9uID0gQDE7CisJCQkJCSQkID0gKE5vZGUgKikgbjsKKwkJCQl9CisJCTsK KworanNvbl90YWJsZV9wbGFuX3ByaW1hcnk6CisJCQlqc29uX3RhYmxlX3BsYW5fc2ltcGxlCQkJ CQkJeyAkJCA9ICQxOyB9CisJCQl8ICcoJyBqc29uX3RhYmxlX3BsYW4gJyknCisJCQkJeworCQkJ CQljYXN0Tm9kZShKc29uVGFibGVQbGFuU3BlYywgJDIpLT5sb2NhdGlvbiA9IEAxOworCQkJCQkk JCA9ICQyOworCQkJCX0KKwkJOworCitqc29uX3RhYmxlX3BsYW5fb3V0ZXI6CisJCQlqc29uX3Rh YmxlX3BsYW5fc2ltcGxlIE9VVEVSX1AganNvbl90YWJsZV9wbGFuX3ByaW1hcnkKKwkJCQl7ICQk ID0gbWFrZUpzb25UYWJsZUpvaW5lZFBsYW4oSlNUUEpfT1VURVIsICQxLCAkMywgQDEpOyB9CisJ CTsKKworanNvbl90YWJsZV9wbGFuX2lubmVyOgorCQkJanNvbl90YWJsZV9wbGFuX3NpbXBsZSBJ Tk5FUl9QIGpzb25fdGFibGVfcGxhbl9wcmltYXJ5CisJCQkJeyAkJCA9IG1ha2VKc29uVGFibGVK b2luZWRQbGFuKEpTVFBKX0lOTkVSLCAkMSwgJDMsIEAxKTsgfQorCQk7CisKK2pzb25fdGFibGVf cGxhbl91bmlvbjoKKwkJCWpzb25fdGFibGVfcGxhbl9wcmltYXJ5IFVOSU9OIGpzb25fdGFibGVf cGxhbl9wcmltYXJ5CisJCQkJeyAkJCA9IG1ha2VKc29uVGFibGVKb2luZWRQbGFuKEpTVFBKX1VO SU9OLCAkMSwgJDMsIEAxKTsgfQorCQkJfCBqc29uX3RhYmxlX3BsYW5fdW5pb24gVU5JT04ganNv bl90YWJsZV9wbGFuX3ByaW1hcnkKKwkJCQl7ICQkID0gbWFrZUpzb25UYWJsZUpvaW5lZFBsYW4o SlNUUEpfVU5JT04sICQxLCAkMywgQDEpOyB9CisJCTsKKworanNvbl90YWJsZV9wbGFuX2Nyb3Nz OgorCQkJanNvbl90YWJsZV9wbGFuX3ByaW1hcnkgQ1JPU1MganNvbl90YWJsZV9wbGFuX3ByaW1h cnkKKwkJCQl7ICQkID0gbWFrZUpzb25UYWJsZUpvaW5lZFBsYW4oSlNUUEpfQ1JPU1MsICQxLCAk MywgQDEpOyB9CisJCQl8IGpzb25fdGFibGVfcGxhbl9jcm9zcyBDUk9TUyBqc29uX3RhYmxlX3Bs YW5fcHJpbWFyeQorCQkJCXsgJCQgPSBtYWtlSnNvblRhYmxlSm9pbmVkUGxhbihKU1RQSl9DUk9T UywgJDEsICQzLCBAMSk7IH0KKwkJOworCitqc29uX3RhYmxlX2RlZmF1bHRfcGxhbl9jaG9pY2Vz OgorCQkJanNvbl90YWJsZV9kZWZhdWx0X3BsYW5faW5uZXJfb3V0ZXIKKwkJCQl7ICQkID0gJDEg fCBKU1RQSl9VTklPTjsgfQorCQkJfCBqc29uX3RhYmxlX2RlZmF1bHRfcGxhbl91bmlvbl9jcm9z cworCQkJCXsgJCQgPSAkMSB8IEpTVFBKX09VVEVSOyB9CisJCQl8IGpzb25fdGFibGVfZGVmYXVs dF9wbGFuX2lubmVyX291dGVyICcsJyBqc29uX3RhYmxlX2RlZmF1bHRfcGxhbl91bmlvbl9jcm9z cworCQkJCXsgJCQgPSAkMSB8ICQzOyB9CisJCQl8IGpzb25fdGFibGVfZGVmYXVsdF9wbGFuX3Vu aW9uX2Nyb3NzICcsJyBqc29uX3RhYmxlX2RlZmF1bHRfcGxhbl9pbm5lcl9vdXRlcgorCQkJCXsg JCQgPSAkMSB8ICQzOyB9CisJCTsKKworanNvbl90YWJsZV9kZWZhdWx0X3BsYW5faW5uZXJfb3V0 ZXI6CisJCQlJTk5FUl9QCQkJCQkJCQkJCXsgJCQgPSBKU1RQSl9JTk5FUjsgfQorCQkJfCBPVVRF Ul9QCQkJCQkJCQkJeyAkJCA9IEpTVFBKX09VVEVSOyB9CisJCTsKKworanNvbl90YWJsZV9kZWZh dWx0X3BsYW5fdW5pb25fY3Jvc3M6CisJCQlVTklPTgkJCQkJCQkJCQl7ICQkID0gSlNUUEpfVU5J T047IH0KKwkJCXwgQ1JPU1MJCQkJCQkJCQkJeyAkJCA9IEpTVFBKX0NST1NTOyB9CisJCTsKKwog anNvbl9yZXR1cm5pbmdfY2xhdXNlX29wdDoKIAkJCVJFVFVSTklORyBUeXBlbmFtZSBqc29uX2Zv cm1hdF9jbGF1c2Vfb3B0CiAJCQkJewpAQCAtMTc0MjgsNiArMTc2OTYsNyBAQCB1bnJlc2VydmVk X2tleXdvcmQ6CiAJCQl8IE1PVkUKIAkJCXwgTkFNRV9QCiAJCQl8IE5BTUVTCisJCQl8IE5FU1RF RAogCQkJfCBORVcKIAkJCXwgTkVYVAogCQkJfCBORkMKQEAgLTE3NDYyLDYgKzE3NzMxLDggQEAg dW5yZXNlcnZlZF9rZXl3b3JkOgogCQkJfCBQQVJUSVRJT04KIAkJCXwgUEFTU0lORwogCQkJfCBQ QVNTV09SRAorCQkJfCBQQVRICisJCQl8IFBMQU4KIAkJCXwgUExBTlMKIAkJCXwgUE9MSUNZCiAJ CQl8IFBSRUNFRElORwpAQCAtMTc2MjYsNiArMTc4OTcsNyBAQCBjb2xfbmFtZV9rZXl3b3JkOgog CQkJfCBKU09OX1FVRVJZCiAJCQl8IEpTT05fU0NBTEFSCiAJCQl8IEpTT05fU0VSSUFMSVpFCisJ CQl8IEpTT05fVEFCTEUKIAkJCXwgSlNPTl9WQUxVRQogCQkJfCBMRUFTVAogCQkJfCBOQVRJT05B TApAQCAtMTc5OTQsNiArMTgyNjYsNyBAQCBiYXJlX2xhYmVsX2tleXdvcmQ6CiAJCQl8IEpTT05f UVVFUlkKIAkJCXwgSlNPTl9TQ0FMQVIKIAkJCXwgSlNPTl9TRVJJQUxJWkUKKwkJCXwgSlNPTl9U QUJMRQogCQkJfCBKU09OX1ZBTFVFCiAJCQl8IEtFRVAKIAkJCXwgS0VZCkBAIC0xODAzMyw2ICsx ODMwNiw3IEBAIGJhcmVfbGFiZWxfa2V5d29yZDoKIAkJCXwgTkFUSU9OQUwKIAkJCXwgTkFUVVJB TAogCQkJfCBOQ0hBUgorCQkJfCBORVNURUQKIAkJCXwgTkVXCiAJCQl8IE5FWFQKIAkJCXwgTkZD CkBAIC0xODA3Nyw3ICsxODM1MSw5IEBAIGJhcmVfbGFiZWxfa2V5d29yZDoKIAkJCXwgUEFSVElU SU9OCiAJCQl8IFBBU1NJTkcKIAkJCXwgUEFTU1dPUkQKKwkJCXwgUEFUSAogCQkJfCBQTEFDSU5H CisJCQl8IFBMQU4KIAkJCXwgUExBTlMKIAkJCXwgUE9MSUNZCiAJCQl8IFBPU0lUSU9OCkBAIC0x ODM0NSwxOCArMTg2MjEsNiBAQCBtYWtlVHlwZUNhc3QoTm9kZSAqYXJnLCBUeXBlTmFtZSAqdHlw ZW5hbWUsIGludCBsb2NhdGlvbikKIAlyZXR1cm4gKE5vZGUgKikgbjsKIH0KIAotc3RhdGljIE5v ZGUgKgotbWFrZVN0cmluZ0NvbnN0KGNoYXIgKnN0ciwgaW50IGxvY2F0aW9uKQotewotCUFfQ29u c3QJICAgKm4gPSBtYWtlTm9kZShBX0NvbnN0KTsKLQotCW4tPnZhbC5zdmFsLnR5cGUgPSBUX1N0 cmluZzsKLQluLT52YWwuc3ZhbC5zdmFsID0gc3RyOwotCW4tPmxvY2F0aW9uID0gbG9jYXRpb247 Ci0KLSAgIHJldHVybiAoTm9kZSAqKSBuOwotfQotCiBzdGF0aWMgTm9kZSAqCiBtYWtlU3RyaW5n Q29uc3RDYXN0KGNoYXIgKnN0ciwgaW50IGxvY2F0aW9uLCBUeXBlTmFtZSAqdHlwZW5hbWUpCiB7 CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9wYXJzZXIvbWVzb24uYnVpbGQgYi9zcmMvYmFja2Vu ZC9wYXJzZXIvbWVzb24uYnVpbGQKaW5kZXggOGU4Mjk1NjQwYi4uNTczZDcwYjNkMSAxMDA2NDQK LS0tIGEvc3JjL2JhY2tlbmQvcGFyc2VyL21lc29uLmJ1aWxkCisrKyBiL3NyYy9iYWNrZW5kL3Bh cnNlci9tZXNvbi5idWlsZApAQCAtMTAsNiArMTAsNyBAQCBiYWNrZW5kX3NvdXJjZXMgKz0gZmls ZXMoCiAgICdwYXJzZV9lbnIuYycsCiAgICdwYXJzZV9leHByLmMnLAogICAncGFyc2VfZnVuYy5j JywKKyAgJ3BhcnNlX2pzb250YWJsZS5jJywKICAgJ3BhcnNlX21lcmdlLmMnLAogICAncGFyc2Vf bm9kZS5jJywKICAgJ3BhcnNlX29wZXIuYycsCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9wYXJz ZXIvcGFyc2VfY2xhdXNlLmMgYi9zcmMvYmFja2VuZC9wYXJzZXIvcGFyc2VfY2xhdXNlLmMKaW5k ZXggNGI1MDI3OGZkMC4uMzhlMjdlODQ3MiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvcGFyc2Vy L3BhcnNlX2NsYXVzZS5jCisrKyBiL3NyYy9iYWNrZW5kL3BhcnNlci9wYXJzZV9jbGF1c2UuYwpA QCAtNjk3LDcgKzY5NywxMSBAQCB0cmFuc2Zvcm1SYW5nZVRhYmxlRnVuYyhQYXJzZVN0YXRlICpw c3RhdGUsIFJhbmdlVGFibGVGdW5jICpydGYpCiAJY2hhcgkgICoqbmFtZXM7CiAJaW50CQkJY29s bm87CiAKLQkvKiBDdXJyZW50bHkgb25seSBYTUxUQUJMRSBpcyBzdXBwb3J0ZWQgKi8KKwkvKgor CSAqIEN1cnJlbnRseSB3ZSBvbmx5IHN1cHBvcnQgWE1MVEFCTEUgaGVyZS4gIFNlZSB0cmFuc2Zv cm1Kc29uVGFibGUoKSBmb3IKKwkgKiBKU09OX1RBQkxFIHN1cHBvcnQuCisJICovCisJdGYtPmZ1 bmN0eXBlID0gVEZUX1hNTFRBQkxFOwogCWNvbnN0cnVjdE5hbWUgPSAiWE1MVEFCTEUiOwogCWRv Y1R5cGUgPSBYTUxPSUQ7CiAKQEAgLTExMDQsMTMgKzExMDgsMTcgQEAgdHJhbnNmb3JtRnJvbUNs YXVzZUl0ZW0oUGFyc2VTdGF0ZSAqcHN0YXRlLCBOb2RlICpuLAogCQlydHItPnJ0aW5kZXggPSBu c2l0ZW0tPnBfcnRpbmRleDsKIAkJcmV0dXJuIChOb2RlICopIHJ0cjsKIAl9Ci0JZWxzZSBpZiAo SXNBKG4sIFJhbmdlVGFibGVGdW5jKSkKKwllbHNlIGlmIChJc0EobiwgUmFuZ2VUYWJsZUZ1bmMp IHx8IElzQShuLCBKc29uVGFibGUpKQogCXsKIAkJLyogdGFibGUgZnVuY3Rpb24gaXMgbGlrZSBh IHBsYWluIHJlbGF0aW9uICovCiAJCVJhbmdlVGJsUmVmICpydHI7CiAJCVBhcnNlTmFtZXNwYWNl SXRlbSAqbnNpdGVtOwogCi0JCW5zaXRlbSA9IHRyYW5zZm9ybVJhbmdlVGFibGVGdW5jKHBzdGF0 ZSwgKFJhbmdlVGFibGVGdW5jICopIG4pOworCQlpZiAoSXNBKG4sIFJhbmdlVGFibGVGdW5jKSkK KwkJCW5zaXRlbSA9IHRyYW5zZm9ybVJhbmdlVGFibGVGdW5jKHBzdGF0ZSwgKFJhbmdlVGFibGVG dW5jICopIG4pOworCQllbHNlCisJCQluc2l0ZW0gPSB0cmFuc2Zvcm1Kc29uVGFibGUocHN0YXRl LCAoSnNvblRhYmxlICopIG4pOworCiAJCSp0b3BfbnNpdGVtID0gbnNpdGVtOwogCQkqbmFtZXNw YWNlID0gbGlzdF9tYWtlMShuc2l0ZW0pOwogCQlydHIgPSBtYWtlTm9kZShSYW5nZVRibFJlZik7 CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9wYXJzZXIvcGFyc2VfZXhwci5jIGIvc3JjL2JhY2tl bmQvcGFyc2VyL3BhcnNlX2V4cHIuYwppbmRleCA1NDkzYjA1YWU4Li5iMTkwOGMzNjliIDEwMDY0 NAotLS0gYS9zcmMvYmFja2VuZC9wYXJzZXIvcGFyc2VfZXhwci5jCisrKyBiL3NyYy9iYWNrZW5k L3BhcnNlci9wYXJzZV9leHByLmMKQEAgLTQyMTksNyArNDIxOSw4IEBAIHRyYW5zZm9ybUpzb25T ZXJpYWxpemVFeHByKFBhcnNlU3RhdGUgKnBzdGF0ZSwgSnNvblNlcmlhbGl6ZUV4cHIgKmV4cHIp CiB9CiAKIC8qCi0gKiBUcmFuc2Zvcm0gSlNPTl9WQUxVRSwgSlNPTl9RVUVSWSwgSlNPTl9FWElT VFMgZnVuY3Rpb25zIGludG8gYSBKc29uRXhwciBub2RlLgorICogVHJhbnNmb3JtIEpTT05fVkFM VUUsIEpTT05fUVVFUlksIEpTT05fRVhJU1RTLCBKU09OX1RBQkxFIGZ1bmN0aW9ucyBpbnRvCisg KiBhIEpzb25FeHByIG5vZGUuCiAgKi8KIHN0YXRpYyBOb2RlICoKIHRyYW5zZm9ybUpzb25GdW5j RXhwcihQYXJzZVN0YXRlICpwc3RhdGUsIEpzb25GdW5jRXhwciAqZnVuYykKQEAgLTQyMzgsNiAr NDIzOSw5IEBAIHRyYW5zZm9ybUpzb25GdW5jRXhwcihQYXJzZVN0YXRlICpwc3RhdGUsIEpzb25G dW5jRXhwciAqZnVuYykKIAkJY2FzZSBKU09OX1ZBTFVFX09QOgogCQkJZnVuY19uYW1lID0gIkpT T05fVkFMVUUiOwogCQkJYnJlYWs7CisJCWNhc2UgSlNPTl9UQUJMRV9PUDoKKwkJCWZ1bmNfbmFt ZSA9ICJKU09OX1RBQkxFIjsKKwkJCWJyZWFrOwogCQlkZWZhdWx0OgogCQkJZWxvZyhFUlJPUiwg ImludmFsaWQgSnNvbkZ1bmNFeHByIG9wIik7CiAJCQlicmVhazsKQEAgLTQyNzcsNiArNDI4MSw0 MiBAQCB0cmFuc2Zvcm1Kc29uRnVuY0V4cHIoUGFyc2VTdGF0ZSAqcHN0YXRlLCBKc29uRnVuY0V4 cHIgKmZ1bmMpCiAJCQkJanNleHByLT5yZXR1cm5pbmctPnR5cGlkID0gQk9PTE9JRDsKIAkJCQlq c2V4cHItPnJldHVybmluZy0+dHlwbW9kID0gLTE7CiAJCQl9CisJCQkvKiBKU09OX1RBQkxFKCkg Q09MVU1OUyBjYW4gc3BlY2lmeSBhIG5vbi1ib29sZWFuIHR5cGUuICovCisJCQllbHNlIGlmIChq c2V4cHItPnJldHVybmluZy0+dHlwaWQgIT0gQk9PTE9JRCkKKwkJCXsKKwkJCQlOb2RlCSAgICpj b2VyY2lvbl9leHByOworCQkJCUNhc2VUZXN0RXhwciAqcGxhY2Vob2xkZXIgPSBtYWtlTm9kZShD YXNlVGVzdEV4cHIpOworCQkJCWludAkJCWxvY2F0aW9uID0gZXhwckxvY2F0aW9uKChOb2RlICop IGpzZXhwcik7CisKKwkJCQkvKgorCQkJCSAqIFdlIGFidXNlIENhc2VUZXN0RXhwciBoZXJlIGFz IHBsYWNlaG9sZGVyIHRvIHBhc3MgdGhlCisJCQkJICogcmVzdWx0IG9mIGV2YWx1YXRpbmcgSlNP Tl9FWElTVFMgdG8gdGhlIGNvZXJjaW9uCisJCQkJICogZXhwcmVzc2lvbi4KKwkJCQkgKi8KKwkJ CQlwbGFjZWhvbGRlci0+dHlwZUlkID0gQk9PTE9JRDsKKwkJCQlwbGFjZWhvbGRlci0+dHlwZU1v ZCA9IC0xOworCQkJCXBsYWNlaG9sZGVyLT5jb2xsYXRpb24gPSBJbnZhbGlkT2lkOworCisJCQkJ Y29lcmNpb25fZXhwciA9CisJCQkJCWNvZXJjZV90b190YXJnZXRfdHlwZShwc3RhdGUsIChOb2Rl ICopIHBsYWNlaG9sZGVyLCBCT09MT0lELAorCQkJCQkJCQkJCSAganNleHByLT5yZXR1cm5pbmct PnR5cGlkLAorCQkJCQkJCQkJCSAganNleHByLT5yZXR1cm5pbmctPnR5cG1vZCwKKwkJCQkJCQkJ CQkgIENPRVJDSU9OX0VYUExJQ0lULAorCQkJCQkJCQkJCSAgQ09FUkNFX0lNUExJQ0lUX0NBU1Qs CisJCQkJCQkJCQkJICBsb2NhdGlvbik7CisKKwkJCQlpZiAoY29lcmNpb25fZXhwciA9PSBOVUxM KQorCQkJCQllcmVwb3J0KEVSUk9SLAorCQkJCQkJCShlcnJjb2RlKEVSUkNPREVfQ0FOTk9UX0NP RVJDRSksCisJCQkJCQkJIGVycm1zZygiY2Fubm90IGNhc3QgdHlwZSAlcyB0byAlcyIsCisJCQkJ CQkJCQlmb3JtYXRfdHlwZV9iZShCT09MT0lEKSwKKwkJCQkJCQkJCWZvcm1hdF90eXBlX2JlKGpz ZXhwci0+cmV0dXJuaW5nLT50eXBpZCkpLAorCQkJCQkJCSBwYXJzZXJfY29lcmNpb25fZXJycG9z aXRpb24ocHN0YXRlLCBsb2NhdGlvbiwgKE5vZGUgKikganNleHByKSkpOworCisJCQkJaWYgKGNv ZXJjaW9uX2V4cHIgIT0gKE5vZGUgKikgcGxhY2Vob2xkZXIpCisJCQkJCWpzZXhwci0+cmVzdWx0 X2NvZXJjaW9uID0gY29lcmNpb25fZXhwcjsKKwkJCX0KKwogCiAJCQlqc2V4cHItPm9uX2Vycm9y ID0gdHJhbnNmb3JtSnNvbkJlaGF2aW9yKHBzdGF0ZSwgZnVuYy0+b25fZXJyb3IsCiAJCQkJCQkJ CQkJCQkJIEpTT05fQkVIQVZJT1JfRkFMU0UsCkBAIC00MzM5LDYgKzQzNzksMTcgQEAgdHJhbnNm b3JtSnNvbkZ1bmNFeHByKFBhcnNlU3RhdGUgKnBzdGF0ZSwgSnNvbkZ1bmNFeHByICpmdW5jKQog CQkJCQkJCQkJCQkJCSBqc2V4cHItPnJldHVybmluZyk7CiAJCQlicmVhazsKIAorCQljYXNlIEpT T05fVEFCTEVfT1A6CisJCQlpZiAoIU9pZElzVmFsaWQoanNleHByLT5yZXR1cm5pbmctPnR5cGlk KSkKKwkJCXsKKwkJCQlqc2V4cHItPnJldHVybmluZy0+dHlwaWQgPSBleHByVHlwZShqc2V4cHIt PmZvcm1hdHRlZF9leHByKTsKKwkJCQlqc2V4cHItPnJldHVybmluZy0+dHlwbW9kID0gLTE7CisJ CQl9CisJCQlqc2V4cHItPm9uX2Vycm9yID0gdHJhbnNmb3JtSnNvbkJlaGF2aW9yKHBzdGF0ZSwg ZnVuYy0+b25fZXJyb3IsCisJCQkJCQkJCQkJCQkJIEpTT05fQkVIQVZJT1JfRU1QVFksCisJCQkJ CQkJCQkJCQkJIGpzZXhwci0+cmV0dXJuaW5nKTsKKwkJCWJyZWFrOworCiAJCWRlZmF1bHQ6CiAJ CQllbG9nKEVSUk9SLCAiaW52YWxpZCBKc29uRnVuY0V4cHIgb3AiKTsKIAkJCWJyZWFrOwpkaWZm IC0tZ2l0IGEvc3JjL2JhY2tlbmQvcGFyc2VyL3BhcnNlX2pzb250YWJsZS5jIGIvc3JjL2JhY2tl bmQvcGFyc2VyL3BhcnNlX2pzb250YWJsZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAuLjJjZjBjZGZkNzQKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvYmFja2VuZC9wYXJz ZXIvcGFyc2VfanNvbnRhYmxlLmMKQEAgLTAsMCArMSw3MTggQEAKKy8qLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LQorICoKKyAqIHBhcnNlX2pzb250YWJsZS5jCisgKgkgIHBhcnNpbmcgb2YgSlNPTl9UQUJMRQor ICoKKyAqIFBvcnRpb25zIENvcHlyaWdodCAoYykgMTk5Ni0yMDIyLCBQb3N0Z3JlU1FMIEdsb2Jh bCBEZXZlbG9wbWVudCBHcm91cAorICogUG9ydGlvbnMgQ29weXJpZ2h0IChjKSAxOTk0LCBSZWdl bnRzIG9mIHRoZSBVbml2ZXJzaXR5IG9mIENhbGlmb3JuaWEKKyAqCisgKgorICogSURFTlRJRklD QVRJT04KKyAqCSAgc3JjL2JhY2tlbmQvcGFyc2VyL3BhcnNlX2pzb250YWJsZS5jCisgKgorICot LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCisgKi8KKworI2luY2x1ZGUgInBvc3RncmVzLmgiCisKKyNpbmNsdWRl ICJjYXRhbG9nL3BnX2NvbGxhdGlvbi5oIgorI2luY2x1ZGUgImNhdGFsb2cvcGdfdHlwZS5oIgor I2luY2x1ZGUgIm1pc2NhZG1pbi5oIgorI2luY2x1ZGUgIm5vZGVzL21ha2VmdW5jcy5oIgorI2lu Y2x1ZGUgIm5vZGVzL25vZGVGdW5jcy5oIgorI2luY2x1ZGUgIm9wdGltaXplci9vcHRpbWl6ZXIu aCIKKyNpbmNsdWRlICJwYXJzZXIvcGFyc2VfY2xhdXNlLmgiCisjaW5jbHVkZSAicGFyc2VyL3Bh cnNlX2NvbGxhdGUuaCIKKyNpbmNsdWRlICJwYXJzZXIvcGFyc2VfZXhwci5oIgorI2luY2x1ZGUg InBhcnNlci9wYXJzZV9yZWxhdGlvbi5oIgorI2luY2x1ZGUgInBhcnNlci9wYXJzZV90eXBlLmgi CisjaW5jbHVkZSAidXRpbHMvYnVpbHRpbnMuaCIKKyNpbmNsdWRlICJ1dGlscy9qc29uLmgiCisj aW5jbHVkZSAidXRpbHMvbHN5c2NhY2hlLmgiCisKKy8qIENvbnRleHQgZm9yIEpTT05fVEFCTEUg dHJhbnNmb3JtYXRpb24gKi8KK3R5cGVkZWYgc3RydWN0IEpzb25UYWJsZVBhcnNlQ29udGV4dAor eworCVBhcnNlU3RhdGUgKnBzdGF0ZTsJCQkvKiBwYXJzaW5nIHN0YXRlICovCisJSnNvblRhYmxl ICAqdGFibGU7CQkJLyogdW50cmFuc2Zvcm1lZCBub2RlICovCisJVGFibGVGdW5jICAqdGFibGVm dW5jOwkJLyogdHJhbnNmb3JtZWQgbm9kZQkqLworCUxpc3QJICAgKnBhdGhOYW1lczsJCS8qIGxp c3Qgb2YgYWxsIHBhdGggYW5kIGNvbHVtbnMgbmFtZXMgKi8KKwlpbnQJCQlwYXRoTmFtZUlkOwkJ LyogcGF0aCBuYW1lIGlkIGNvdW50ZXIgKi8KKwlPaWQJCQljb250ZXh0SXRlbVR5cGlkOwkvKiB0 eXBlIG9pZCBvZiBjb250ZXh0IGl0ZW0gKGpzb24vanNvbmIpICovCit9CQkJSnNvblRhYmxlUGFy c2VDb250ZXh0OworCitzdGF0aWMgSnNvblRhYmxlUGxhbiAqdHJhbnNmb3JtSnNvblRhYmxlQ29s dW1ucyhKc29uVGFibGVQYXJzZUNvbnRleHQgKiBjeHQsCisJCQkJCQkJCQkJCQlKc29uVGFibGVQ bGFuU3BlYyAqcGxhbnNwZWMsCisJCQkJCQkJCQkJCQlMaXN0ICpjb2x1bW5zLAorCQkJCQkJCQkJ CQkJSnNvblRhYmxlUGF0aFNwZWMgKnBhdGhzcGVjKTsKKworLyoKKyAqIFRyYW5zZm9ybSBKU09O X1RBQkxFIGNvbHVtbgorICogICAtIHJlZ3VsYXIgY29sdW1uIGludG8gSlNPTl9WQUxVRSgpCisg KiAgIC0gRk9STUFUIEpTT04gY29sdW1uIGludG8gSlNPTl9RVUVSWSgpCisgKiAgIC0gRVhJU1RT IGNvbHVtbiBpbnRvIEpTT05fRVhJU1RTKCkKKyAqLworc3RhdGljIE5vZGUgKgordHJhbnNmb3Jt SnNvblRhYmxlQ29sdW1uKEpzb25UYWJsZUNvbHVtbiAqanRjLCBOb2RlICpjb250ZXh0SXRlbUV4 cHIsCisJCQkJCQkgTGlzdCAqcGFzc2luZ0FyZ3MsIGJvb2wgZXJyb3JPbkVycm9yKQoreworCUpz b25GdW5jRXhwciAqamZleHByID0gbWFrZU5vZGUoSnNvbkZ1bmNFeHByKTsKKwlOb2RlCSAgICpw YXRoc3BlYzsKKwlKc29uRm9ybWF0ICpkZWZhdWx0X2Zvcm1hdDsKKworCWlmIChqdGMtPmNvbHR5 cGUgPT0gSlRDX1JFR1VMQVIpCisJCWpmZXhwci0+b3AgPSBKU09OX1ZBTFVFX09QOworCWVsc2Ug aWYgKGp0Yy0+Y29sdHlwZSA9PSBKVENfRVhJU1RTKQorCQlqZmV4cHItPm9wID0gSlNPTl9FWElT VFNfT1A7CisJZWxzZQorCQlqZmV4cHItPm9wID0gSlNPTl9RVUVSWV9PUDsKKwlqZmV4cHItPm91 dHB1dCA9IG1ha2VOb2RlKEpzb25PdXRwdXQpOworCWpmZXhwci0+b25fZW1wdHkgPSBqdGMtPm9u X2VtcHR5OworCWpmZXhwci0+b25fZXJyb3IgPSBqdGMtPm9uX2Vycm9yOworCWlmIChqZmV4cHIt Pm9uX2Vycm9yID09IE5VTEwgJiYgZXJyb3JPbkVycm9yKQorCQlqZmV4cHItPm9uX2Vycm9yID0g bWFrZUpzb25CZWhhdmlvcihKU09OX0JFSEFWSU9SX0VSUk9SLCBOVUxMLAorCQkJCQkJCQkJCQlO VUxMLCAtMSk7CisJamZleHByLT5xdW90ZXMgPSBqdGMtPnF1b3RlczsKKwlqZmV4cHItPndyYXBw ZXIgPSBqdGMtPndyYXBwZXI7CisJamZleHByLT5sb2NhdGlvbiA9IGp0Yy0+bG9jYXRpb247CisK KwlqZmV4cHItPm91dHB1dC0+dHlwZU5hbWUgPSBqdGMtPnR5cGVOYW1lOworCWpmZXhwci0+b3V0 cHV0LT5yZXR1cm5pbmcgPSBtYWtlTm9kZShKc29uUmV0dXJuaW5nKTsKKwlqZmV4cHItPm91dHB1 dC0+cmV0dXJuaW5nLT5mb3JtYXQgPSBqdGMtPmZvcm1hdDsKKworCWRlZmF1bHRfZm9ybWF0ID0g bWFrZUpzb25Gb3JtYXQoSlNfRk9STUFUX0RFRkFVTFQsIEpTX0VOQ19ERUZBVUxULCAtMSk7CisK KwlpZiAoanRjLT5wYXRoc3BlYykKKwkJcGF0aHNwZWMgPSAoTm9kZSAqKSBqdGMtPnBhdGhzcGVj LT5zdHJpbmc7CisJZWxzZQorCXsKKwkJLyogQ29uc3RydWN0IGRlZmF1bHQgcGF0aCBhcyAnJC4i Y29sdW1uX25hbWUiJyAqLworCQlTdHJpbmdJbmZvRGF0YSBwYXRoOworCisJCWluaXRTdHJpbmdJ bmZvKCZwYXRoKTsKKworCQlhcHBlbmRTdHJpbmdJbmZvU3RyaW5nKCZwYXRoLCAiJC4iKTsKKwkJ ZXNjYXBlX2pzb24oJnBhdGgsIGp0Yy0+bmFtZSk7CisKKwkJcGF0aHNwZWMgPSBtYWtlU3RyaW5n Q29uc3QocGF0aC5kYXRhLCAtMSk7CisJfQorCisJamZleHByLT5jb250ZXh0X2l0ZW0gPQltYWtl SnNvblZhbHVlRXhwcigoRXhwciAqKSBjb250ZXh0SXRlbUV4cHIsIE5VTEwsCisJCQkJCQkJCQkJ CSAgZGVmYXVsdF9mb3JtYXQpOworCWpmZXhwci0+cGF0aHNwZWMgPSBwYXRoc3BlYzsKKwlqZmV4 cHItPnBhdGhuYW1lID0gTlVMTDsKKwlqZmV4cHItPnBhc3NpbmcgPSBwYXNzaW5nQXJnczsKKwor CXJldHVybiAoTm9kZSAqKSBqZmV4cHI7Cit9CisKKy8qCisgKiBSZWdpc3RlciBhIGNvbHVtbi9w YXRoIG5hbWUgaW4gdGhlIHBhdGggbmFtZSBsaXN0LCBmbGFnZ2luZyBpZiB0aGUgbmFtZSBpcwor ICogYWxyZWFkeSB0YWtlbiBieSBhbm90aGVyIGNvbHVtbi9wYXRoLgorICovCitzdGF0aWMgdm9p ZAorcmVnaXN0ZXJKc29uVGFibGVDb2x1bW4oSnNvblRhYmxlUGFyc2VDb250ZXh0ICogY3h0LCBj aGFyICpjb2xuYW1lLAorCQkJCQkJaW50IGxvY2F0aW9uKQoreworCUxpc3RDZWxsICAgKmxjOwor CisJZm9yZWFjaChsYywgY3h0LT5wYXRoTmFtZXMpCisJeworCQlpZiAoc3RyY21wKGNvbG5hbWUs IChjb25zdCBjaGFyICopIGxmaXJzdChsYykpID09IDApCisJCQllcmVwb3J0KEVSUk9SLAorCQkJ CQllcnJjb2RlKEVSUkNPREVfRFVQTElDQVRFX0FMSUFTKSwKKwkJCQkJZXJybXNnKCJkdXBsaWNh dGUgSlNPTl9UQUJMRSBjb2x1bW4gbmFtZTogJXMiLCBjb2xuYW1lKSwKKwkJCQkJcGFyc2VyX2Vy cnBvc2l0aW9uKGN4dC0+cHN0YXRlLCBsb2NhdGlvbikpOworCX0KKworCWN4dC0+cGF0aE5hbWVz ID0gbGFwcGVuZChjeHQtPnBhdGhOYW1lcywgY29sbmFtZSk7Cit9CisKK3N0YXRpYyB2b2lkCity ZWdpc3Rlckpzb25UYWJsZVBhdGgoSnNvblRhYmxlUGFyc2VDb250ZXh0ICogY3h0LCBjaGFyICpw YXRobmFtZSwKKwkJCQkJICBpbnQgbG9jYXRpb24pCit7CisJTGlzdENlbGwgICAqbGM7CisKKwlm b3JlYWNoKGxjLCBjeHQtPnBhdGhOYW1lcykKKwl7CisJCWlmIChzdHJjbXAocGF0aG5hbWUsIChj b25zdCBjaGFyICopIGxmaXJzdChsYykpID09IDApCisJCQllcmVwb3J0KEVSUk9SLAorCQkJCQll cnJjb2RlKEVSUkNPREVfRFVQTElDQVRFX0FMSUFTKSwKKwkJCQkJZXJybXNnKCJkdXBsaWNhdGUg SlNPTl9UQUJMRSBwYXRoIG5hbWU6ICVzIiwgcGF0aG5hbWUpLAorCQkJCQlwYXJzZXJfZXJycG9z aXRpb24oY3h0LT5wc3RhdGUsIGxvY2F0aW9uKSk7CisJfQorCisJY3h0LT5wYXRoTmFtZXMgPSBs YXBwZW5kKGN4dC0+cGF0aE5hbWVzLCBwYXRobmFtZSk7Cit9CisKKy8qCisgKiBSZWN1cnNpdmVs eSByZWdpc3RlciBhbGwgbmVzdGVkIGNvbHVtbiBuYW1lcyBpbiB0aGUgc2hhcmVkIGNvbHVtbnMv cGF0aCBuYW1lCisgKiBsaXN0LgorICovCitzdGF0aWMgdm9pZAorcmVnaXN0ZXJBbGxKc29uVGFi bGVDb2x1bW5zQW5kUGF0aHMoSnNvblRhYmxlUGFyc2VDb250ZXh0ICogY3h0LAorCQkJCQkJCQkJ TGlzdCAqY29sdW1ucykKK3sKKwlMaXN0Q2VsbCAgICpsYzsKKworCWZvcmVhY2gobGMsIGNvbHVt bnMpCisJeworCQlKc29uVGFibGVDb2x1bW4gKmp0YyA9IGNhc3ROb2RlKEpzb25UYWJsZUNvbHVt biwgbGZpcnN0KGxjKSk7CisKKwkJaWYgKGp0Yy0+Y29sdHlwZSA9PSBKVENfTkVTVEVEKQorCQl7 CisJCQlpZiAoanRjLT5wYXRoc3BlYy0+bmFtZSkKKwkJCQlyZWdpc3Rlckpzb25UYWJsZVBhdGgo Y3h0LCBqdGMtPnBhdGhzcGVjLT5uYW1lLAorCQkJCQkJCQkJICBqdGMtPnBhdGhzcGVjLT5uYW1l X2xvY2F0aW9uKTsKKworCQkJcmVnaXN0ZXJBbGxKc29uVGFibGVDb2x1bW5zQW5kUGF0aHMoY3h0 LCBqdGMtPmNvbHVtbnMpOworCQl9CisJCWVsc2UKKwkJeworCQkJcmVnaXN0ZXJKc29uVGFibGVD b2x1bW4oY3h0LCBqdGMtPm5hbWUsIGp0Yy0+bG9jYXRpb24pOworCQl9CisJfQorfQorCisvKiBH ZW5lcmF0ZSBhIG5ldyB1bmlxdWUgSlNPTl9UQUJMRSBwYXRoIG5hbWUuICovCitzdGF0aWMgY2hh ciAqCitnZW5lcmF0ZUpzb25UYWJsZVBhdGhOYW1lKEpzb25UYWJsZVBhcnNlQ29udGV4dCAqIGN4 dCkKK3sKKwljaGFyCQluYW1lYnVmWzMyXTsKKwljaGFyCSAgICpuYW1lID0gbmFtZWJ1ZjsKKwor CXNucHJpbnRmKG5hbWVidWYsIHNpemVvZihuYW1lYnVmKSwgImpzb25fdGFibGVfcGF0aF8lZCIs CisJCQkgY3h0LT5wYXRoTmFtZUlkKyspOworCisJbmFtZSA9IHBzdHJkdXAobmFtZSk7CisJY3h0 LT5wYXRoTmFtZXMgPSBsYXBwZW5kKGN4dC0+cGF0aE5hbWVzLCBuYW1lKTsKKworCXJldHVybiBu YW1lOworfQorCisvKiBDb2xsZWN0IHNpYmxpbmcgcGF0aCBuYW1lcyBmcm9tIHBsYW4gdG8gdGhl IHNwZWNpZmllZCBsaXN0LiAqLworc3RhdGljIHZvaWQKK2NvbGxlY3RTaWJsaW5nUGF0aHNJbkpz b25UYWJsZVBsYW4oSnNvblRhYmxlUGxhblNwZWMgKnBsYW4sIExpc3QgKipwYXRocykKK3sKKwlp ZiAocGxhbi0+cGxhbl90eXBlID09IEpTVFBfU0lNUExFKQorCQkqcGF0aHMgPSBsYXBwZW5kKCpw YXRocywgcGxhbi0+cGF0aG5hbWUpOworCWVsc2UgaWYgKHBsYW4tPnBsYW5fdHlwZSA9PSBKU1RQ X0pPSU5FRCkKKwl7CisJCWlmIChwbGFuLT5qb2luX3R5cGUgPT0gSlNUUEpfSU5ORVIgfHwKKwkJ CXBsYW4tPmpvaW5fdHlwZSA9PSBKU1RQSl9PVVRFUikKKwkJeworCQkJQXNzZXJ0KHBsYW4tPnBs YW4xLT5wbGFuX3R5cGUgPT0gSlNUUF9TSU1QTEUpOworCQkJKnBhdGhzID0gbGFwcGVuZCgqcGF0 aHMsIHBsYW4tPnBsYW4xLT5wYXRobmFtZSk7CisJCX0KKwkJZWxzZSBpZiAocGxhbi0+am9pbl90 eXBlID09IEpTVFBKX0NST1NTIHx8CisJCQkJIHBsYW4tPmpvaW5fdHlwZSA9PSBKU1RQSl9VTklP TikKKwkJeworCQkJY29sbGVjdFNpYmxpbmdQYXRoc0luSnNvblRhYmxlUGxhbihwbGFuLT5wbGFu MSwgcGF0aHMpOworCQkJY29sbGVjdFNpYmxpbmdQYXRoc0luSnNvblRhYmxlUGxhbihwbGFuLT5w bGFuMiwgcGF0aHMpOworCQl9CisJCWVsc2UKKwkJCWVsb2coRVJST1IsICJpbnZhbGlkIEpTT05f VEFCTEUgam9pbiB0eXBlICVkIiwKKwkJCQkgcGxhbi0+am9pbl90eXBlKTsKKwl9Cit9CisKKy8q CisgKiBWYWxpZGF0ZSBjaGlsZCBKU09OX1RBQkxFIHBsYW4gYnkgY2hlY2tpbmcgdGhhdDoKKyAq ICAtIGFsbCBuZXN0ZWQgY29sdW1ucyBoYXZlIHBhdGggbmFtZXMgc3BlY2lmaWVkCisgKiAgLSBh bGwgbmVzdGVkIGNvbHVtbnMgaGF2ZSBjb3JyZXNwb25kaW5nIG5vZGUgaW4gdGhlIHNpYmxpbmcg cGxhbgorICogIC0gcGxhbiBkb2VzIG5vdCBjb250YWluIGR1cGxpY2F0ZSBvciBleHRyYSBub2Rl cworICovCitzdGF0aWMgdm9pZAordmFsaWRhdGVKc29uVGFibGVDaGlsZFBsYW4oUGFyc2VTdGF0 ZSAqcHN0YXRlLCBKc29uVGFibGVQbGFuU3BlYyAqcGxhbiwKKwkJCQkJCSAgIExpc3QgKmNvbHVt bnMpCit7CisJTGlzdENlbGwgICAqbGMxOworCUxpc3QJICAgKnNpYmxpbmdzID0gTklMOworCWlu dAkJCW5jaGlsZHJlbiA9IDA7CisKKwlpZiAocGxhbikKKwkJY29sbGVjdFNpYmxpbmdQYXRoc0lu SnNvblRhYmxlUGxhbihwbGFuLCAmc2libGluZ3MpOworCisJZm9yZWFjaChsYzEsIGNvbHVtbnMp CisJeworCQlKc29uVGFibGVDb2x1bW4gKmp0YyA9IGNhc3ROb2RlKEpzb25UYWJsZUNvbHVtbiwg bGZpcnN0KGxjMSkpOworCisJCWlmIChqdGMtPmNvbHR5cGUgPT0gSlRDX05FU1RFRCkKKwkJewor CQkJTGlzdENlbGwgICAqbGMyOworCQkJYm9vbAkJZm91bmQgPSBmYWxzZTsKKworCQkJaWYgKGp0 Yy0+cGF0aHNwZWMtPm5hbWUgPT0gTlVMTCkKKwkJCQllcmVwb3J0KEVSUk9SLAorCQkJCQkJZXJy Y29kZShFUlJDT0RFX1NZTlRBWF9FUlJPUiksCisJCQkJCQllcnJtc2coIm5lc3RlZCBKU09OX1RB QkxFIGNvbHVtbnMgbXVzdCBjb250YWluIgorCQkJCQkJCQkiIGFuIGV4cGxpY2l0IEFTIHBhdGhu YW1lIHNwZWNpZmljYXRpb24iCisJCQkJCQkJCSIgaWYgYW4gZXhwbGljaXQgUExBTiBjbGF1c2Ug aXMgdXNlZCIpLAorCQkJCQkJcGFyc2VyX2VycnBvc2l0aW9uKHBzdGF0ZSwganRjLT5sb2NhdGlv bikpOworCisJCQkvKiBmaW5kIG5lc3RlZCBwYXRoIG5hbWUgaW4gdGhlIGxpc3Qgb2Ygc2libGlu ZyBwYXRoIG5hbWVzICovCisJCQlmb3JlYWNoKGxjMiwgc2libGluZ3MpCisJCQl7CisJCQkJaWYg KChmb3VuZCA9ICFzdHJjbXAoanRjLT5wYXRoc3BlYy0+bmFtZSwgbGZpcnN0KGxjMikpKSkKKwkJ CQkJYnJlYWs7CisJCQl9CisKKwkJCWlmICghZm91bmQpCisJCQkJZXJlcG9ydChFUlJPUiwKKwkJ CQkJCWVycmNvZGUoRVJSQ09ERV9TWU5UQVhfRVJST1IpLAorCQkJCQkJZXJybXNnKCJpbnZhbGlk IEpTT05fVEFCTEUgc3BlY2lmaWNhdGlvbiIpLAorCQkJCQkJZXJyZGV0YWlsKCJQTEFOIGNsYXVz ZSBmb3IgbmVzdGVkIHBhdGggJXMgd2FzIG5vdCBmb3VuZC4iLAorCQkJCQkJCQkgIGp0Yy0+cGF0 aHNwZWMtPm5hbWUpLAorCQkJCQkJcGFyc2VyX2VycnBvc2l0aW9uKHBzdGF0ZSwganRjLT5sb2Nh dGlvbikpOworCisJCQluY2hpbGRyZW4rKzsKKwkJfQorCX0KKworCWlmIChsaXN0X2xlbmd0aChz aWJsaW5ncykgPiBuY2hpbGRyZW4pCisJCWVyZXBvcnQoRVJST1IsCisJCQkJZXJyY29kZShFUlJD T0RFX1NZTlRBWF9FUlJPUiksCisJCQkJZXJybXNnKCJpbnZhbGlkIEpTT05fVEFCTEUgcGxhbiBj bGF1c2UiKSwKKwkJCQllcnJkZXRhaWwoIlBMQU4gY2xhdXNlIGNvbnRhaW5zIHNvbWUgZXh0cmEg b3IgZHVwbGljYXRlIHNpYmxpbmcgbm9kZXMuIiksCisJCQkJcGFyc2VyX2VycnBvc2l0aW9uKHBz dGF0ZSwgcGxhbiA/IHBsYW4tPmxvY2F0aW9uIDogLTEpKTsKK30KKworc3RhdGljIEpzb25UYWJs ZUNvbHVtbiAqCitmaW5kTmVzdGVkSnNvblRhYmxlQ29sdW1uKExpc3QgKmNvbHVtbnMsIGNvbnN0 IGNoYXIgKnBhdGhuYW1lKQoreworCUxpc3RDZWxsICAgKmxjOworCisJZm9yZWFjaChsYywgY29s dW1ucykKKwl7CisJCUpzb25UYWJsZUNvbHVtbiAqanRjID0gY2FzdE5vZGUoSnNvblRhYmxlQ29s dW1uLCBsZmlyc3QobGMpKTsKKworCQlpZiAoanRjLT5jb2x0eXBlID09IEpUQ19ORVNURUQgJiYK KwkJCWp0Yy0+cGF0aHNwZWMtPm5hbWUgJiYKKwkJCSFzdHJjbXAoanRjLT5wYXRoc3BlYy0+bmFt ZSwgcGF0aG5hbWUpKQorCQkJcmV0dXJuIGp0YzsKKwl9CisKKwlyZXR1cm4gTlVMTDsKK30KKwor c3RhdGljIE5vZGUgKgordHJhbnNmb3JtTmVzdGVkSnNvblRhYmxlQ29sdW1uKEpzb25UYWJsZVBh cnNlQ29udGV4dCAqIGN4dCwgSnNvblRhYmxlQ29sdW1uICpqdGMsCisJCQkJCQkJICAgSnNvblRh YmxlUGxhblNwZWMgKnBsYW5zcGVjKQoreworCWlmIChqdGMtPnBhdGhzcGVjLT5uYW1lID09IE5V TEwpCisJeworCQlpZiAoY3h0LT50YWJsZS0+cGxhbnNwZWMgIT0gTlVMTCkKKwkJCWVyZXBvcnQo RVJST1IsCisJCQkJCShlcnJjb2RlKEVSUkNPREVfU1lOVEFYX0VSUk9SKSwKKwkJCQkJIGVycm1z ZygiaW52YWxpZCBKU09OX1RBQkxFIGV4cHJlc3Npb24iKSwKKwkJCQkJIGVycmRldGFpbCgiSlNP Tl9UQUJMRSBwYXRoIG11c3QgY29udGFpbiIKKwkJCQkJCQkgICAiIGV4cGxpY2l0IEFTIHBhdGhu YW1lIHNwZWNpZmljYXRpb24gaWYiCisJCQkJCQkJICAgIiBleHBsaWNpdCBQTEFOIGNsYXVzZSBp cyB1c2VkIiksCisJCQkJCSBwYXJzZXJfZXJycG9zaXRpb24oY3h0LT5wc3RhdGUsIGp0Yy0+bG9j YXRpb24pKSk7CisKKwkJanRjLT5wYXRoc3BlYy0+bmFtZSA9IGdlbmVyYXRlSnNvblRhYmxlUGF0 aE5hbWUoY3h0KTsKKwl9CisKKwlyZXR1cm4gKE5vZGUgKikgdHJhbnNmb3JtSnNvblRhYmxlQ29s dW1ucyhjeHQsIHBsYW5zcGVjLCBqdGMtPmNvbHVtbnMsCisJCQkJCQkJCQkJCSAganRjLT5wYXRo c3BlYyk7Cit9CisKK3N0YXRpYyBOb2RlICoKK21ha2VKc29uVGFibGVTaWJsaW5nSm9pbihib29s IGNyb3NzLCBOb2RlICpsbm9kZSwgTm9kZSAqcm5vZGUpCit7CisJSnNvblRhYmxlU2libGluZyAq am9pbiA9IG1ha2VOb2RlKEpzb25UYWJsZVNpYmxpbmcpOworCisJam9pbi0+bGFyZyA9IGxub2Rl OworCWpvaW4tPnJhcmcgPSBybm9kZTsKKwlqb2luLT5jcm9zcyA9IGNyb3NzOworCisJcmV0dXJu IChOb2RlICopIGpvaW47Cit9CisKKy8qCisgKiBSZWN1cnNpdmVseSB0cmFuc2Zvcm0gY2hpbGQg SlNPTl9UQUJMRSBwbGFuLgorICoKKyAqIERlZmF1bHQgcGxhbiBpcyB0cmFuc2Zvcm1lZCBpbnRv IGEgY3Jvc3MvdW5pb24gam9pbiBvZiBpdHMgbmVzdGVkIGNvbHVtbnMuCisgKiBTaW1wbGUgYW5k IG91dGVyL2lubmVyIHBsYW5zIGFyZSB0cmFuc2Zvcm1lZCBpbnRvIGEgSnNvblRhYmxlUGxhbiBi eQorICogZmluZGluZyBhbmQgdHJhbnNmb3JtaW5nIGNvcnJlc3BvbmRpbmcgbmVzdGVkIGNvbHVt bi4KKyAqIFNpYmxpbmcgcGxhbnMgYXJlIHJlY3Vyc2l2ZWx5IHRyYW5zZm9ybWVkIGludG8gYSBK c29uVGFibGVTaWJsaW5nLgorICovCitzdGF0aWMgTm9kZSAqCit0cmFuc2Zvcm1Kc29uVGFibGVD aGlsZFBsYW4oSnNvblRhYmxlUGFyc2VDb250ZXh0ICogY3h0LAorCQkJCQkJCUpzb25UYWJsZVBs YW5TcGVjICpwbGFuLAorCQkJCQkJCUxpc3QgKmNvbHVtbnMpCit7CisJSnNvblRhYmxlQ29sdW1u ICpqdGMgPSBOVUxMOworCisJaWYgKCFwbGFuIHx8IHBsYW4tPnBsYW5fdHlwZSA9PSBKU1RQX0RF RkFVTFQpCisJeworCQkvKiB1bnNwZWNpZmllZCBvciBkZWZhdWx0IHBsYW4gKi8KKwkJTm9kZQkg ICAqcmVzID0gTlVMTDsKKwkJTGlzdENlbGwgICAqbGM7CisJCWJvb2wJCWNyb3NzID0gcGxhbiAm JiAocGxhbi0+am9pbl90eXBlICYgSlNUUEpfQ1JPU1MpOworCisJCS8qIHRyYW5zZm9ybSBhbGwg bmVzdGVkIGNvbHVtbnMgaW50byBjcm9zcy91bmlvbiBqb2luICovCisJCWZvcmVhY2gobGMsIGNv bHVtbnMpCisJCXsKKwkJCUpzb25UYWJsZUNvbHVtbiAqY29sID0gY2FzdE5vZGUoSnNvblRhYmxl Q29sdW1uLCBsZmlyc3QobGMpKTsKKwkJCU5vZGUJICAgKm5vZGU7CisKKwkJCWlmIChjb2wtPmNv bHR5cGUgIT0gSlRDX05FU1RFRCkKKwkJCQljb250aW51ZTsKKworCQkJbm9kZSA9IHRyYW5zZm9y bU5lc3RlZEpzb25UYWJsZUNvbHVtbihjeHQsIGNvbCwgcGxhbik7CisKKwkJCS8qIGpvaW4gdHJh bnNmb3JtZWQgbm9kZSB3aXRoIHByZXZpb3VzIHNpYmxpbmcgbm9kZXMgKi8KKwkJCXJlcyA9IHJl cyA/IG1ha2VKc29uVGFibGVTaWJsaW5nSm9pbihjcm9zcywgcmVzLCBub2RlKSA6IG5vZGU7CisJ CX0KKworCQlyZXR1cm4gcmVzOworCX0KKwllbHNlIGlmIChwbGFuLT5wbGFuX3R5cGUgPT0gSlNU UF9TSU1QTEUpCisJeworCQlqdGMgPSBmaW5kTmVzdGVkSnNvblRhYmxlQ29sdW1uKGNvbHVtbnMs IHBsYW4tPnBhdGhuYW1lKTsKKwl9CisJZWxzZSBpZiAocGxhbi0+cGxhbl90eXBlID09IEpTVFBf Sk9JTkVEKQorCXsKKwkJaWYgKHBsYW4tPmpvaW5fdHlwZSA9PSBKU1RQSl9JTk5FUiB8fAorCQkJ cGxhbi0+am9pbl90eXBlID09IEpTVFBKX09VVEVSKQorCQl7CisJCQlBc3NlcnQocGxhbi0+cGxh bjEtPnBsYW5fdHlwZSA9PSBKU1RQX1NJTVBMRSk7CisJCQlqdGMgPSBmaW5kTmVzdGVkSnNvblRh YmxlQ29sdW1uKGNvbHVtbnMsIHBsYW4tPnBsYW4xLT5wYXRobmFtZSk7CisJCX0KKwkJZWxzZQor CQl7CisJCQlOb2RlCSAgICpub2RlMSA9IHRyYW5zZm9ybUpzb25UYWJsZUNoaWxkUGxhbihjeHQs IHBsYW4tPnBsYW4xLAorCQkJCQkJCQkJCQkJCQkJY29sdW1ucyk7CisJCQlOb2RlCSAgICpub2Rl MiA9IHRyYW5zZm9ybUpzb25UYWJsZUNoaWxkUGxhbihjeHQsIHBsYW4tPnBsYW4yLAorCQkJCQkJ CQkJCQkJCQkJY29sdW1ucyk7CisKKwkJCXJldHVybiBtYWtlSnNvblRhYmxlU2libGluZ0pvaW4o cGxhbi0+am9pbl90eXBlID09IEpTVFBKX0NST1NTLAorCQkJCQkJCQkJCQlub2RlMSwgbm9kZTIp OworCQl9CisJfQorCWVsc2UKKwkJZWxvZyhFUlJPUiwgImludmFsaWQgSlNPTl9UQUJMRSBwbGFu IHR5cGUgJWQiLCBwbGFuLT5wbGFuX3R5cGUpOworCisJaWYgKCFqdGMpCisJCWVyZXBvcnQoRVJS T1IsCisJCQkJKGVycmNvZGUoRVJSQ09ERV9TWU5UQVhfRVJST1IpLAorCQkJCSBlcnJtc2coImlu dmFsaWQgSlNPTl9UQUJMRSBwbGFuIGNsYXVzZSIpLAorCQkJCSBlcnJkZXRhaWwoIlBBVEggbmFt ZSB3YXMgJXMgbm90IGZvdW5kIGluIG5lc3RlZCBjb2x1bW5zIGxpc3QuIiwKKwkJCQkJCSAgIHBs YW4tPnBhdGhuYW1lKSwKKwkJCQkgcGFyc2VyX2VycnBvc2l0aW9uKGN4dC0+cHN0YXRlLCBwbGFu LT5sb2NhdGlvbikpKTsKKworCXJldHVybiB0cmFuc2Zvcm1OZXN0ZWRKc29uVGFibGVDb2x1bW4o Y3h0LCBqdGMsIHBsYW4pOworfQorCisvKiBDaGVjayB3aGV0aGVyIHR5cGUgaXMganNvbi9qc29u YiwgYXJyYXksIG9yIHJlY29yZC4gKi8KK3N0YXRpYyBib29sCit0eXBlSXNDb21wb3NpdGUoT2lk IHR5cGlkKQoreworCWNoYXIJCXR5cHR5cGU7CisKKwlpZiAodHlwaWQgPT0gSlNPTk9JRCB8fAor CQl0eXBpZCA9PSBKU09OQk9JRCB8fAorCQl0eXBpZCA9PSBSRUNPUkRPSUQgfHwKKwkJdHlwZV9p c19hcnJheSh0eXBpZCkpCisJCXJldHVybiB0cnVlOworCisJdHlwdHlwZSA9IGdldF90eXB0eXBl KHR5cGlkKTsKKworCWlmICh0eXB0eXBlID09IFRZUFRZUEVfQ09NUE9TSVRFKQorCQlyZXR1cm4g dHJ1ZTsKKworCWlmICh0eXB0eXBlID09IFRZUFRZUEVfRE9NQUlOKQorCQlyZXR1cm4gdHlwZUlz Q29tcG9zaXRlKGdldEJhc2VUeXBlKHR5cGlkKSk7CisKKwlyZXR1cm4gZmFsc2U7Cit9CisKKy8q IEFwcGVuZCB0cmFuc2Zvcm1lZCBub24tbmVzdGVkIEpTT05fVEFCTEUgY29sdW1ucyB0byB0aGUg VGFibGVGdW5jIG5vZGUgKi8KK3N0YXRpYyB2b2lkCithcHBlbmRKc29uVGFibGVDb2x1bW5zKEpz b25UYWJsZVBhcnNlQ29udGV4dCAqIGN4dCwgTGlzdCAqY29sdW1ucykKK3sKKwlMaXN0Q2VsbCAg ICpjb2w7CisJUGFyc2VTdGF0ZSAqcHN0YXRlID0gY3h0LT5wc3RhdGU7CisJSnNvblRhYmxlICAq anQgPSBjeHQtPnRhYmxlOworCVRhYmxlRnVuYyAgKnRmID0gY3h0LT50YWJsZWZ1bmM7CisJYm9v bAkJb3JkaW5hbGl0eV9mb3VuZCA9IGZhbHNlOworCUpzb25CZWhhdmlvciAqb25fZXJyb3IgPSBq dC0+b25fZXJyb3I7CisJYm9vbAkJZXJyb3JPbkVycm9yID0gb25fZXJyb3IgJiYKKwkJb25fZXJy b3ItPmJ0eXBlID09IEpTT05fQkVIQVZJT1JfRVJST1I7CisKKwlmb3JlYWNoKGNvbCwgY29sdW1u cykKKwl7CisJCUpzb25UYWJsZUNvbHVtbiAqcmF3YyA9IGNhc3ROb2RlKEpzb25UYWJsZUNvbHVt biwgbGZpcnN0KGNvbCkpOworCQlPaWQJCQl0eXBpZDsKKwkJaW50MzIJCXR5cG1vZDsKKwkJTm9k ZQkgICAqY29sZXhwcjsKKworCQlpZiAocmF3Yy0+bmFtZSkKKwkJCXRmLT5jb2xuYW1lcyA9IGxh cHBlbmQodGYtPmNvbG5hbWVzLAorCQkJCQkJCQkgICBtYWtlU3RyaW5nKHBzdHJkdXAocmF3Yy0+ bmFtZSkpKTsKKworCQkvKgorCQkgKiBEZXRlcm1pbmUgdGhlIHR5cGUgYW5kIHR5cG1vZCBmb3Ig dGhlIG5ldyBjb2x1bW4uIEZPUiBPUkRJTkFMSVRZCisJCSAqIGNvbHVtbnMgYXJlIElOVEVHRVIg Ynkgc3RhbmRhcmQ7IHRoZSBvdGhlcnMgYXJlIHVzZXItc3BlY2lmaWVkLgorCQkgKi8KKwkJc3dp dGNoIChyYXdjLT5jb2x0eXBlKQorCQl7CisJCQljYXNlIEpUQ19GT1JfT1JESU5BTElUWToKKwkJ CQlpZiAob3JkaW5hbGl0eV9mb3VuZCkKKwkJCQkJZXJlcG9ydChFUlJPUiwKKwkJCQkJCQkoZXJy Y29kZShFUlJDT0RFX1NZTlRBWF9FUlJPUiksCisJCQkJCQkJIGVycm1zZygiY2Fubm90IHVzZSBt b3JlIHRoYW4gb25lIEZPUiBPUkRJTkFMSVRZIGNvbHVtbiIpLAorCQkJCQkJCSBwYXJzZXJfZXJy cG9zaXRpb24ocHN0YXRlLCByYXdjLT5sb2NhdGlvbikpKTsKKwkJCQlvcmRpbmFsaXR5X2ZvdW5k ID0gdHJ1ZTsKKwkJCQljb2xleHByID0gTlVMTDsKKwkJCQl0eXBpZCA9IElOVDRPSUQ7CisJCQkJ dHlwbW9kID0gLTE7CisJCQkJYnJlYWs7CisKKwkJCWNhc2UgSlRDX1JFR1VMQVI6CisJCQkJdHlw ZW5hbWVUeXBlSWRBbmRNb2QocHN0YXRlLCByYXdjLT50eXBlTmFtZSwgJnR5cGlkLCAmdHlwbW9k KTsKKworCQkJCS8qCisJCQkJICogVXNlIGltcGxpY2l0IEZPUk1BVCBKU09OIGZvciBjb21wb3Np dGUgdHlwZXMgKGFycmF5cyBhbmQKKwkJCQkgKiByZWNvcmRzKSBvciBpZiBhIG5vbi1kZWZhdWx0 IFdSQVBQRVIgLyBRVU9URVMgYmVoYXZpb3IKKwkJCQkgKiBpcyBzcGVjaWZpZWQuCisJCQkJICov CisJCQkJaWYgKHR5cGVJc0NvbXBvc2l0ZSh0eXBpZCkgfHwKKwkJCQkJcmF3Yy0+cXVvdGVzICE9 IEpTX1FVT1RFU19VTlNQRUMgfHwKKwkJCQkJcmF3Yy0+d3JhcHBlciAhPSBKU1dfVU5TUEVDKQor CQkJCQlyYXdjLT5jb2x0eXBlID0gSlRDX0ZPUk1BVFRFRDsKKworCQkJCS8qIEZBTExUSFJPVUdI ICovCisJCQljYXNlIEpUQ19GT1JNQVRURUQ6CisJCQljYXNlIEpUQ19FWElTVFM6CisJCQkJewor CQkJCQlOb2RlCSAgICpqZTsKKwkJCQkJQ2FzZVRlc3RFeHByICpwYXJhbSA9IG1ha2VOb2RlKENh c2VUZXN0RXhwcik7CisKKwkJCQkJcGFyYW0tPmNvbGxhdGlvbiA9IEludmFsaWRPaWQ7CisJCQkJ CXBhcmFtLT50eXBlSWQgPSBjeHQtPmNvbnRleHRJdGVtVHlwaWQ7CisJCQkJCXBhcmFtLT50eXBl TW9kID0gLTE7CisKKwkJCQkJamUgPSB0cmFuc2Zvcm1Kc29uVGFibGVDb2x1bW4ocmF3YywgKE5v ZGUgKikgcGFyYW0sCisJCQkJCQkJCQkJCQkgIE5JTCwgZXJyb3JPbkVycm9yKTsKKworCQkJCQlj b2xleHByID0gdHJhbnNmb3JtRXhwcihwc3RhdGUsIGplLCBFWFBSX0tJTkRfRlJPTV9GVU5DVElP Tik7CisJCQkJCWFzc2lnbl9leHByX2NvbGxhdGlvbnMocHN0YXRlLCBjb2xleHByKTsKKworCQkJ CQl0eXBpZCA9IGV4cHJUeXBlKGNvbGV4cHIpOworCQkJCQl0eXBtb2QgPSBleHByVHlwbW9kKGNv bGV4cHIpOworCQkJCQlicmVhazsKKwkJCQl9CisKKwkJCWNhc2UgSlRDX05FU1RFRDoKKwkJCQlj b250aW51ZTsKKworCQkJZGVmYXVsdDoKKwkJCQllbG9nKEVSUk9SLCAidW5rbm93biBKU09OX1RB QkxFIGNvbHVtbiB0eXBlOiAlZCIsIHJhd2MtPmNvbHR5cGUpOworCQkJCWJyZWFrOworCQl9CisK KwkJdGYtPmNvbHR5cGVzID0gbGFwcGVuZF9vaWQodGYtPmNvbHR5cGVzLCB0eXBpZCk7CisJCXRm LT5jb2x0eXBtb2RzID0gbGFwcGVuZF9pbnQodGYtPmNvbHR5cG1vZHMsIHR5cG1vZCk7CisJCXRm LT5jb2xjb2xsYXRpb25zID0gbGFwcGVuZF9vaWQodGYtPmNvbGNvbGxhdGlvbnMsIGdldF90eXBj b2xsYXRpb24odHlwaWQpKTsKKwkJdGYtPmNvbHZhbGV4cHJzID0gbGFwcGVuZCh0Zi0+Y29sdmFs ZXhwcnMsIGNvbGV4cHIpOworCX0KK30KKworLyoKKyAqIENyZWF0ZSB0cmFuc2Zvcm1lZCBKU09O X1RBQkxFIHBhcmVudCBwbGFuIG5vZGUgYnkgYXBwZW5kaW5nIGFsbCBub24tbmVzdGVkCisgKiBj b2x1bW5zIHRvIHRoZSBUYWJsZUZ1bmMgbm9kZSBhbmQgcmVtZW1iZXJpbmcgdGhlaXIgaW5kaWNl cyBpbiB0aGUKKyAqIGNvbHZhbGV4cHJzIGxpc3QuCisgKi8KK3N0YXRpYyBKc29uVGFibGVQbGFu ICoKK21ha2VQYXJlbnRKc29uVGFibGVQbGFuKEpzb25UYWJsZVBhcnNlQ29udGV4dCAqIGN4dCwg SnNvblRhYmxlUGF0aFNwZWMgKnBhdGhzcGVjLAorCQkJCQkJTGlzdCAqY29sdW1ucykKK3sKKwlK c29uVGFibGVQbGFuICpwbGFuID0gbWFrZU5vZGUoSnNvblRhYmxlUGxhbik7CisJSnNvbkJlaGF2 aW9yICpvbl9lcnJvciA9IGN4dC0+dGFibGUtPm9uX2Vycm9yOworCWNoYXIJCSAqcGF0aHN0cmlu ZzsKKwlDb25zdAkJICp2YWx1ZTsKKworCUFzc2VydChJc0EocGF0aHNwZWMtPnN0cmluZywgQV9D b25zdCkpOworCXBhdGhzdHJpbmcgPSBjYXN0Tm9kZShBX0NvbnN0LCBwYXRoc3BlYy0+c3RyaW5n KS0+dmFsLnN2YWwuc3ZhbDsKKwl2YWx1ZSA9IG1ha2VDb25zdChKU09OUEFUSE9JRCwgLTEsIElu dmFsaWRPaWQsIC0xLAorCQkJCQkgIERpcmVjdEZ1bmN0aW9uQ2FsbDEoanNvbnBhdGhfaW4sCisJ CQkJCQkJCQkJICBDU3RyaW5nR2V0RGF0dW0ocGF0aHN0cmluZykpLAorCQkJCQkgIGZhbHNlLCBm YWxzZSk7CisJcGxhbi0+cGF0aCA9IG1ha2VKc29uVGFibGVQYXRoKHZhbHVlLCBwYXRoc3BlYy0+ bmFtZSk7CisKKwkvKiBzYXZlIHN0YXJ0IG9mIGNvbHVtbiByYW5nZSAqLworCXBsYW4tPmNvbE1p biA9IGxpc3RfbGVuZ3RoKGN4dC0+dGFibGVmdW5jLT5jb2x2YWxleHBycyk7CisKKwlhcHBlbmRK c29uVGFibGVDb2x1bW5zKGN4dCwgY29sdW1ucyk7CisKKwkvKiBzYXZlIGVuZCBvZiBjb2x1bW4g cmFuZ2UgKi8KKwlwbGFuLT5jb2xNYXggPSBsaXN0X2xlbmd0aChjeHQtPnRhYmxlZnVuYy0+Y29s dmFsZXhwcnMpIC0gMTsKKworCXBsYW4tPmVycm9yT25FcnJvciA9IG9uX2Vycm9yICYmIG9uX2Vy cm9yLT5idHlwZSA9PSBKU09OX0JFSEFWSU9SX0VSUk9SOworCisJcmV0dXJuIHBsYW47Cit9CisK K3N0YXRpYyBKc29uVGFibGVQbGFuICoKK3RyYW5zZm9ybUpzb25UYWJsZUNvbHVtbnMoSnNvblRh YmxlUGFyc2VDb250ZXh0ICogY3h0LAorCQkJCQkJICBKc29uVGFibGVQbGFuU3BlYyAqcGxhbnNw ZWMsCisJCQkJCQkgIExpc3QgKmNvbHVtbnMsCisJCQkJCQkgIEpzb25UYWJsZVBhdGhTcGVjICpw YXRoc3BlYykKK3sKKwlKc29uVGFibGVQbGFuICpwbGFuOworCUpzb25UYWJsZVBsYW5TcGVjICpj aGlsZFBsYW5TcGVjOworCWJvb2wJCWRlZmF1bHRQbGFuID0gcGxhbnNwZWMgPT0gTlVMTCB8fAor CQlwbGFuc3BlYy0+cGxhbl90eXBlID09IEpTVFBfREVGQVVMVDsKKworCWlmIChkZWZhdWx0UGxh bikKKwkJY2hpbGRQbGFuU3BlYyA9IHBsYW5zcGVjOworCWVsc2UKKwl7CisJCS8qIHZhbGlkYXRl IHBhcmVudCBhbmQgY2hpbGQgcGxhbnMgKi8KKwkJSnNvblRhYmxlUGxhblNwZWMgKnBhcmVudFBs YW5TcGVjOworCisJCWlmIChwbGFuc3BlYy0+cGxhbl90eXBlID09IEpTVFBfSk9JTkVEKQorCQl7 CisJCQlpZiAocGxhbnNwZWMtPmpvaW5fdHlwZSAhPSBKU1RQSl9JTk5FUiAmJgorCQkJCXBsYW5z cGVjLT5qb2luX3R5cGUgIT0gSlNUUEpfT1VURVIpCisJCQkJZXJlcG9ydChFUlJPUiwKKwkJCQkJ CShlcnJjb2RlKEVSUkNPREVfU1lOVEFYX0VSUk9SKSwKKwkJCQkJCSBlcnJtc2coImludmFsaWQg SlNPTl9UQUJMRSBwbGFuIGNsYXVzZSIpLAorCQkJCQkJIGVycmRldGFpbCgiRXhwZWN0ZWQgSU5O RVIgb3IgT1VURVIuIiksCisJCQkJCQkgcGFyc2VyX2VycnBvc2l0aW9uKGN4dC0+cHN0YXRlLCBw bGFuc3BlYy0+bG9jYXRpb24pKSk7CisKKwkJCXBhcmVudFBsYW5TcGVjID0gcGxhbnNwZWMtPnBs YW4xOworCQkJY2hpbGRQbGFuU3BlYyA9IHBsYW5zcGVjLT5wbGFuMjsKKworCQkJQXNzZXJ0KHBh cmVudFBsYW5TcGVjLT5wbGFuX3R5cGUgIT0gSlNUUF9KT0lORUQpOworCQkJQXNzZXJ0KHBhcmVu dFBsYW5TcGVjLT5wYXRobmFtZSk7CisJCX0KKwkJZWxzZQorCQl7CisJCQlwYXJlbnRQbGFuU3Bl YyA9IHBsYW5zcGVjOworCQkJY2hpbGRQbGFuU3BlYyA9IE5VTEw7CisJCX0KKworCQlpZiAoc3Ry Y21wKHBhcmVudFBsYW5TcGVjLT5wYXRobmFtZSwgcGF0aHNwZWMtPm5hbWUpICE9IDApCisJCQll cmVwb3J0KEVSUk9SLAorCQkJCQkoZXJyY29kZShFUlJDT0RFX1NZTlRBWF9FUlJPUiksCisJCQkJ CSBlcnJtc2coImludmFsaWQgSlNPTl9UQUJMRSBwbGFuIiksCisJCQkJCSBlcnJkZXRhaWwoIlBB VEggbmFtZSBtaXNtYXRjaDogZXhwZWN0ZWQgJXMgYnV0ICVzIGlzIGdpdmVuLiIsCisJCQkJCQkJ ICAgcGF0aHNwZWMtPm5hbWUsIHBhcmVudFBsYW5TcGVjLT5wYXRobmFtZSksCisJCQkJCSBwYXJz ZXJfZXJycG9zaXRpb24oY3h0LT5wc3RhdGUsIHBsYW5zcGVjLT5sb2NhdGlvbikpKTsKKworCQl2 YWxpZGF0ZUpzb25UYWJsZUNoaWxkUGxhbihjeHQtPnBzdGF0ZSwgY2hpbGRQbGFuU3BlYywgY29s dW1ucyk7CisJfQorCisJLyogdHJhbnNmb3JtIG9ubHkgbm9uLW5lc3RlZCBjb2x1bW5zICovCisJ cGxhbiA9IG1ha2VQYXJlbnRKc29uVGFibGVQbGFuKGN4dCwgcGF0aHNwZWMsIGNvbHVtbnMpOwor CisJaWYgKGNoaWxkUGxhblNwZWMgfHwgZGVmYXVsdFBsYW4pCisJeworCQkvKiB0cmFuc2Zvcm0g cmVjdXJzaXZlbHkgbmVzdGVkIGNvbHVtbnMgKi8KKwkJcGxhbi0+Y2hpbGQgPSB0cmFuc2Zvcm1K c29uVGFibGVDaGlsZFBsYW4oY3h0LCBjaGlsZFBsYW5TcGVjLCBjb2x1bW5zKTsKKwkJaWYgKHBs YW4tPmNoaWxkKQorCQkJcGxhbi0+b3V0ZXJKb2luID0gcGxhbnNwZWMgPT0gTlVMTCB8fAorCQkJ CShwbGFuc3BlYy0+am9pbl90eXBlICYgSlNUUEpfT1VURVIpOworCQkvKiBlbHNlOiBkZWZhdWx0 IHBsYW4gY2FzZSwgbm8gY2hpbGRyZW4gZm91bmQgKi8KKwl9CisKKwlyZXR1cm4gcGxhbjsKK30K KworLyoKKyAqIHRyYW5zZm9ybUpzb25UYWJsZSAtCisgKgkJCVRyYW5zZm9ybSBhIHJhdyBKc29u VGFibGUgaW50byBUYWJsZUZ1bmMuCisgKgorICogVHJhbnNmb3JtIHRoZSBkb2N1bWVudC1nZW5l cmF0aW5nIGV4cHJlc3Npb24sIHRoZSByb3ctZ2VuZXJhdGluZyBleHByZXNzaW9uLAorICogdGhl IGNvbHVtbi1nZW5lcmF0aW5nIGV4cHJlc3Npb25zLCBhbmQgdGhlIGRlZmF1bHQgdmFsdWUgZXhw cmVzc2lvbnMuCisgKi8KK1BhcnNlTmFtZXNwYWNlSXRlbSAqCit0cmFuc2Zvcm1Kc29uVGFibGUo UGFyc2VTdGF0ZSAqcHN0YXRlLCBKc29uVGFibGUgKmp0KQoreworCUpzb25UYWJsZVBhcnNlQ29u dGV4dCBjeHQ7CisJVGFibGVGdW5jICAqdGYgPSBtYWtlTm9kZShUYWJsZUZ1bmMpOworCUpzb25G dW5jRXhwciAqamZlID0gbWFrZU5vZGUoSnNvbkZ1bmNFeHByKTsKKwlKc29uRXhwciAgICpqZTsK KwlKc29uVGFibGVQbGFuU3BlYyAqcGxhbiA9IGp0LT5wbGFuc3BlYzsKKwlKc29uVGFibGVQYXRo U3BlYyAqcm9vdFBhdGhTcGVjID0ganQtPnBhdGhzcGVjOworCWJvb2wJCWlzX2xhdGVyYWw7CisK KwlBc3NlcnQoSXNBKHJvb3RQYXRoU3BlYy0+c3RyaW5nLCBBX0NvbnN0KSAmJgorCQkgICBjYXN0 Tm9kZShBX0NvbnN0LCByb290UGF0aFNwZWMtPnN0cmluZyktPnZhbC5ub2RlLnR5cGUgPT0gVF9T dHJpbmcpOworCisJY3h0LnBzdGF0ZSA9IHBzdGF0ZTsKKwljeHQudGFibGUgPSBqdDsKKwljeHQu dGFibGVmdW5jID0gdGY7CisJY3h0LnBhdGhOYW1lcyA9IE5JTDsKKwljeHQucGF0aE5hbWVJZCA9 IDA7CisKKwlpZiAocm9vdFBhdGhTcGVjLT5uYW1lKQorCQlyZWdpc3Rlckpzb25UYWJsZVBhdGgo JmN4dCwgcm9vdFBhdGhTcGVjLT5uYW1lLAorCQkJCQkJCSAgcm9vdFBhdGhTcGVjLT5uYW1lX2xv Y2F0aW9uKTsKKwllbHNlCisJeworCQlpZiAoanQtPnBsYW5zcGVjICE9IE5VTEwpCisJCQllcmVw b3J0KEVSUk9SLAorCQkJCQkoZXJyY29kZShFUlJDT0RFX1NZTlRBWF9FUlJPUiksCisJCQkJCSBl cnJtc2coImludmFsaWQgSlNPTl9UQUJMRSBleHByZXNzaW9uIiksCisJCQkJCSBlcnJkZXRhaWwo IkpTT05fVEFCTEUgcGF0aCBtdXN0IGNvbnRhaW4iCisJCQkJCQkJICAgIiBleHBsaWNpdCBBUyBw YXRobmFtZSBzcGVjaWZpY2F0aW9uIGlmIgorCQkJCQkJCSAgICIgZXhwbGljaXQgUExBTiBjbGF1 c2UgaXMgdXNlZCIpLAorCQkJCQkgcGFyc2VyX2VycnBvc2l0aW9uKHBzdGF0ZSwgcm9vdFBhdGhT cGVjLT5sb2NhdGlvbikpKTsKKworCQlyb290UGF0aFNwZWMtPm5hbWUgPSBnZW5lcmF0ZUpzb25U YWJsZVBhdGhOYW1lKCZjeHQpOworCX0KKworCXJlZ2lzdGVyQWxsSnNvblRhYmxlQ29sdW1uc0Fu ZFBhdGhzKCZjeHQsIGp0LT5jb2x1bW5zKTsKKworCWpmZS0+b3AgPSBKU09OX1RBQkxFX09QOwor CWpmZS0+Y29udGV4dF9pdGVtID0JanQtPmNvbnRleHRfaXRlbTsKKwlqZmUtPnBhdGhzcGVjID0g KE5vZGUgKikgcm9vdFBhdGhTcGVjLT5zdHJpbmc7CisJamZlLT5wYXRobmFtZSA9IHJvb3RQYXRo U3BlYy0+bmFtZTsKKwlqZmUtPnBhc3NpbmcgPSBqdC0+cGFzc2luZzsKKwlqZmUtPm9uX2VtcHR5 ID0gTlVMTDsKKwlqZmUtPm9uX2Vycm9yID0ganQtPm9uX2Vycm9yOworCWpmZS0+bG9jYXRpb24g PSBqdC0+bG9jYXRpb247CisKKwkvKgorCSAqIFdlIG1ha2UgbGF0ZXJhbF9vbmx5IG5hbWVzIG9m IHRoaXMgbGV2ZWwgdmlzaWJsZSwgd2hldGhlciBvciBub3QgdGhlCisJICogUmFuZ2VUYWJsZUZ1 bmMgaXMgZXhwbGljaXRseSBtYXJrZWQgTEFURVJBTC4gIFRoaXMgaXMgbmVlZGVkIGZvciBTUUwK KwkgKiBzcGVjIGNvbXBsaWFuY2UgYW5kIHNlZW1zIHVzZWZ1bCBvbiBjb252ZW5pZW5jZSBncm91 bmRzIGZvciBhbGwKKwkgKiBmdW5jdGlvbnMgaW4gRlJPTS4KKwkgKgorCSAqIChMQVRFUkFMIGNh bid0IG5lc3Qgd2l0aGluIGEgc2luZ2xlIHBzdGF0ZSBsZXZlbCwgc28gd2UgZG9uJ3QgbmVlZAor CSAqIHNhdmUvcmVzdG9yZSBsb2dpYyBoZXJlLikKKwkgKi8KKwlBc3NlcnQoIXBzdGF0ZS0+cF9s YXRlcmFsX2FjdGl2ZSk7CisJcHN0YXRlLT5wX2xhdGVyYWxfYWN0aXZlID0gdHJ1ZTsKKworCXRm LT5mdW5jdHlwZSA9IFRGVF9KU09OX1RBQkxFOworCXRmLT5kb2NleHByID0gdHJhbnNmb3JtRXhw cihwc3RhdGUsIChOb2RlICopIGpmZSwgRVhQUl9LSU5EX0ZST01fRlVOQ1RJT04pOworCisJY3h0 LmNvbnRleHRJdGVtVHlwaWQgPSBleHByVHlwZSh0Zi0+ZG9jZXhwcik7CisKKwl0Zi0+cGxhbiA9 IChOb2RlICopIHRyYW5zZm9ybUpzb25UYWJsZUNvbHVtbnMoJmN4dCwgcGxhbiwganQtPmNvbHVt bnMsCisJCQkJCQkJCQkJCQkgIHJvb3RQYXRoU3BlYyk7CisKKwkvKiBBbHNvIHNhdmUgYSBjb3B5 IG9mIHRoZSBQQVNTSU5HIGFyZ3VtZW50cyBpbiB0aGUgVGFibGVGdW5jIG5vZGUuICovCisJamUg PSAoSnNvbkV4cHIgKikgdGYtPmRvY2V4cHI7CisJdGYtPnBhc3Npbmd2YWxleHBycyA9IGNvcHlP YmplY3QoamUtPnBhc3NpbmdfdmFsdWVzKTsKKworCXRmLT5vcmRpbmFsaXR5Y29sID0gLTE7CQkv KiB1bmRlZmluZSBvcmRpbmFsaXR5IGNvbHVtbiBudW1iZXIgKi8KKwl0Zi0+bG9jYXRpb24gPSBq dC0+bG9jYXRpb247CisKKwlwc3RhdGUtPnBfbGF0ZXJhbF9hY3RpdmUgPSBmYWxzZTsKKworCS8q CisJICogTWFyayB0aGUgUlRFIGFzIExBVEVSQUwgaWYgdGhlIHVzZXIgc2FpZCBMQVRFUkFMIGV4 cGxpY2l0bHksIG9yIGlmCisJICogdGhlcmUgYXJlIGFueSBsYXRlcmFsIGNyb3NzLXJlZmVyZW5j ZXMgaW4gaXQuCisJICovCisJaXNfbGF0ZXJhbCA9IGp0LT5sYXRlcmFsIHx8IGNvbnRhaW5fdmFy c19vZl9sZXZlbCgoTm9kZSAqKSB0ZiwgMCk7CisKKwlyZXR1cm4gYWRkUmFuZ2VUYWJsZUVudHJ5 Rm9yVGFibGVGdW5jKHBzdGF0ZSwKKwkJCQkJCQkJCQkgIHRmLCBqdC0+YWxpYXMsIGlzX2xhdGVy YWwsIHRydWUpOworfQpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvcGFyc2VyL3BhcnNlX3JlbGF0 aW9uLmMgYi9zcmMvYmFja2VuZC9wYXJzZXIvcGFyc2VfcmVsYXRpb24uYwppbmRleCAzNGEwZWM1 OTAxLi42MjUxYzMwOTM5IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9wYXJzZXIvcGFyc2VfcmVs YXRpb24uYworKysgYi9zcmMvYmFja2VuZC9wYXJzZXIvcGFyc2VfcmVsYXRpb24uYwpAQCAtMjA3 Myw3ICsyMDczLDggQEAgYWRkUmFuZ2VUYWJsZUVudHJ5Rm9yVGFibGVGdW5jKFBhcnNlU3RhdGUg KnBzdGF0ZSwKIAlBc3NlcnQobGlzdF9sZW5ndGgodGYtPmNvbHR5cG1vZHMpID09IGxpc3RfbGVu Z3RoKHRmLT5jb2xuYW1lcykpOwogCUFzc2VydChsaXN0X2xlbmd0aCh0Zi0+Y29sY29sbGF0aW9u cykgPT0gbGlzdF9sZW5ndGgodGYtPmNvbG5hbWVzKSk7CiAKLQlyZWZuYW1lID0gYWxpYXMgPyBh bGlhcy0+YWxpYXNuYW1lIDogcHN0cmR1cCgieG1sdGFibGUiKTsKKwlyZWZuYW1lID0gYWxpYXMg PyBhbGlhcy0+YWxpYXNuYW1lIDoKKwkJcHN0cmR1cCh0Zi0+ZnVuY3R5cGUgPT0gVEZUX1hNTFRB QkxFID8gInhtbHRhYmxlIiA6ICJqc29uX3RhYmxlIik7CiAKIAlydGUtPnJ0ZWtpbmQgPSBSVEVf VEFCTEVGVU5DOwogCXJ0ZS0+cmVsaWQgPSBJbnZhbGlkT2lkOwpAQCAtMjA5Niw3ICsyMDk3LDcg QEAgYWRkUmFuZ2VUYWJsZUVudHJ5Rm9yVGFibGVGdW5jKFBhcnNlU3RhdGUgKnBzdGF0ZSwKIAkJ ZXJlcG9ydChFUlJPUiwKIAkJCQkoZXJyY29kZShFUlJDT0RFX0lOVkFMSURfQ09MVU1OX1JFRkVS RU5DRSksCiAJCQkJIGVycm1zZygiJXMgZnVuY3Rpb24gaGFzICVkIGNvbHVtbnMgYXZhaWxhYmxl IGJ1dCAlZCBjb2x1bW5zIHNwZWNpZmllZCIsCi0JCQkJCQkiWE1MVEFCTEUiLAorCQkJCQkJdGYt PmZ1bmN0eXBlID09IFRGVF9YTUxUQUJMRSA/ICJYTUxUQUJMRSIgOiAiSlNPTl9UQUJMRSIsCiAJ CQkJCQlsaXN0X2xlbmd0aCh0Zi0+Y29sbmFtZXMpLCBudW1hbGlhc2VzKSkpOwogCiAJcnRlLT5l cmVmID0gZXJlZjsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3BhcnNlci9wYXJzZV90YXJnZXQu YyBiL3NyYy9iYWNrZW5kL3BhcnNlci9wYXJzZV90YXJnZXQuYwppbmRleCBlYTVhYzZiYWZlLi5h MzMxZWEzMjcwIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9wYXJzZXIvcGFyc2VfdGFyZ2V0LmMK KysrIGIvc3JjL2JhY2tlbmQvcGFyc2VyL3BhcnNlX3RhcmdldC5jCkBAIC0yMDAyLDYgKzIwMDIs OSBAQCBGaWd1cmVDb2xuYW1lSW50ZXJuYWwoTm9kZSAqbm9kZSwgY2hhciAqKm5hbWUpCiAJCQkJ Y2FzZSBKU09OX1ZBTFVFX09QOgogCQkJCQkqbmFtZSA9ICJqc29uX3ZhbHVlIjsKIAkJCQkJcmV0 dXJuIDI7CisJCQkJY2FzZSBKU09OX1RBQkxFX09QOgorCQkJCQkqbmFtZSA9ICJqc29uX3RhYmxl IjsKKwkJCQkJcmV0dXJuIDI7CiAJCQl9CiAJCQlicmVhazsKIAkJZGVmYXVsdDoKZGlmZiAtLWdp dCBhL3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9qc29ucGF0aF9leGVjLmMgYi9zcmMvYmFja2VuZC91 dGlscy9hZHQvanNvbnBhdGhfZXhlYy5jCmluZGV4IDZkNjFkODdmMDEuLjdhNGZiM2QyN2MgMTAw NjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9qc29ucGF0aF9leGVjLmMKKysrIGIvc3Jj L2JhY2tlbmQvdXRpbHMvYWR0L2pzb25wYXRoX2V4ZWMuYwpAQCAtNjEsMTAgKzYxLDEyIEBACiAK ICNpbmNsdWRlICJjYXRhbG9nL3BnX2NvbGxhdGlvbi5oIgogI2luY2x1ZGUgImNhdGFsb2cvcGdf dHlwZS5oIgorI2luY2x1ZGUgImV4ZWN1dG9yL2V4ZWNFeHByLmgiCiAjaW5jbHVkZSAiZnVuY2Fw aS5oIgogI2luY2x1ZGUgImxpYi9zdHJpbmdpbmZvLmgiCiAjaW5jbHVkZSAibWlzY2FkbWluLmgi CiAjaW5jbHVkZSAibm9kZXMvbWlzY25vZGVzLmgiCisjaW5jbHVkZSAibm9kZXMvbm9kZUZ1bmNz LmgiCiAjaW5jbHVkZSAicmVnZXgvcmVnZXguaCIKICNpbmNsdWRlICJ1dGlscy9idWlsdGlucy5o IgogI2luY2x1ZGUgInV0aWxzL2RhdGUuaCIKQEAgLTc1LDYgKzc3LDggQEAKICNpbmNsdWRlICJ1 dGlscy9ndWMuaCIKICNpbmNsdWRlICJ1dGlscy9qc29uLmgiCiAjaW5jbHVkZSAidXRpbHMvanNv bnBhdGguaCIKKyNpbmNsdWRlICJ1dGlscy9sc3lzY2FjaGUuaCIKKyNpbmNsdWRlICJ1dGlscy9t ZW11dGlscy5oIgogI2luY2x1ZGUgInV0aWxzL3RpbWVzdGFtcC5oIgogI2luY2x1ZGUgInV0aWxz L3ZhcmxlbmEuaCIKIApAQCAtMTU5LDYgKzE2Myw2MCBAQCB0eXBlZGVmIHN0cnVjdCBKc29uVmFs dWVMaXN0SXRlcmF0b3IKIAlMaXN0Q2VsbCAgICpuZXh0OwogfSBKc29uVmFsdWVMaXN0SXRlcmF0 b3I7CiAKKy8qIFN0cnVjdHVyZXMgZm9yIEpTT05fVEFCTEUgZXhlY3V0aW9uICAqLworCit0eXBl ZGVmIGVudW0gSnNvblRhYmxlUGxhblN0YXRlVHlwZQoreworCUpTT05fVEFCTEVfU0NBTl9TVEFU RSA9IDAsCisJSlNPTl9UQUJMRV9KT0lOX1NUQVRFLAorfQkJCUpzb25UYWJsZVBsYW5TdGF0ZVR5 cGU7CisKK3R5cGVkZWYgc3RydWN0IEpzb25UYWJsZVBsYW5TdGF0ZQoreworCUpzb25UYWJsZVBs YW5TdGF0ZVR5cGUgdHlwZTsKKworCXN0cnVjdCBKc29uVGFibGVQbGFuU3RhdGUgKnBhcmVudDsK KwlzdHJ1Y3QgSnNvblRhYmxlUGxhblN0YXRlICpuZXN0ZWQ7Cit9CQkJSnNvblRhYmxlUGxhblN0 YXRlOworCit0eXBlZGVmIHN0cnVjdCBKc29uVGFibGVTY2FuU3RhdGUKK3sKKwlKc29uVGFibGVQ bGFuU3RhdGUgcGxhbjsKKworCU1lbW9yeUNvbnRleHQgbWN4dDsKKwlKc29uUGF0aCAgICpwYXRo OworCUxpc3QJICAgKmFyZ3M7CisJSnNvblZhbHVlTGlzdCBmb3VuZDsKKwlKc29uVmFsdWVMaXN0 SXRlcmF0b3IgaXRlcjsKKwlEYXR1bQkJY3VycmVudDsKKwlpbnQJCQlvcmRpbmFsOworCWJvb2wJ CWN1cnJlbnRJc051bGw7CisJYm9vbAkJb3V0ZXJKb2luOworCWJvb2wJCWVycm9yT25FcnJvcjsK Kwlib29sCQlhZHZhbmNlTmVzdGVkOworCWJvb2wJCXJlc2V0OworfSBKc29uVGFibGVTY2FuU3Rh dGU7CisKK3R5cGVkZWYgc3RydWN0IEpzb25UYWJsZUpvaW5TdGF0ZQoreworCUpzb25UYWJsZVBs YW5TdGF0ZSBwbGFuOworCisJSnNvblRhYmxlUGxhblN0YXRlICpsZWZ0OworCUpzb25UYWJsZVBs YW5TdGF0ZSAqcmlnaHQ7CisJYm9vbAkJY3Jvc3M7CisJYm9vbAkJYWR2YW5jZVJpZ2h0OworfSBK c29uVGFibGVKb2luU3RhdGU7CisKKy8qIHJhbmRvbSBudW1iZXIgdG8gaWRlbnRpZnkgSnNvblRh YmxlRXhlY0NvbnRleHQgKi8KKyNkZWZpbmUgSlNPTl9UQUJMRV9FWEVDX0NPTlRFWFRfTUFHSUMJ CTQxODM1Mjg2NworCit0eXBlZGVmIHN0cnVjdCBKc29uVGFibGVFeGVjQ29udGV4dAoreworCWlu dAkJCW1hZ2ljOworCUpzb25UYWJsZVNjYW5TdGF0ZSAqKmNvbGV4cHJzY2FuczsKKwlKc29uVGFi bGVTY2FuU3RhdGUgKnJvb3Q7Cit9CQkJSnNvblRhYmxlRXhlY0NvbnRleHQ7CisKIC8qIHN0cmlj dC9sYXggZmxhZ3MgaXMgZGVjb21wb3NlZCBpbnRvIGZvdXIgW3VuXXdyYXAvZXJyb3IgZmxhZ3Mg Ki8KICNkZWZpbmUganNwU3RyaWN0QWJzZW5jZU9mRXJyb3JzKGN4dCkJKCEoY3h0KS0+bGF4TW9k ZSkKICNkZWZpbmUganNwQXV0b1Vud3JhcChjeHQpCQkJCSgoY3h0KS0+bGF4TW9kZSkKQEAgLTI1 OCw2ICszMTYsNyBAQCBzdGF0aWMgSnNvblBhdGhFeGVjUmVzdWx0IGdldEFycmF5SW5kZXgoSnNv blBhdGhFeGVjQ29udGV4dCAqY3h0LAogCQkJCQkJCQkJCUpzb25QYXRoSXRlbSAqanNwLCBKc29u YlZhbHVlICpqYiwgaW50MzIgKmluZGV4KTsKIHN0YXRpYyBKc29uQmFzZU9iamVjdEluZm8gc2V0 QmFzZU9iamVjdChKc29uUGF0aEV4ZWNDb250ZXh0ICpjeHQsCiAJCQkJCQkJCQkJSnNvbmJWYWx1 ZSAqamJ2LCBpbnQzMiBpZCk7CitzdGF0aWMgdm9pZCBKc29uVmFsdWVMaXN0Q2xlYXIoSnNvblZh bHVlTGlzdCAqanZsKTsKIHN0YXRpYyB2b2lkIEpzb25WYWx1ZUxpc3RBcHBlbmQoSnNvblZhbHVl TGlzdCAqanZsLCBKc29uYlZhbHVlICpqYnYpOwogc3RhdGljIGludAlKc29uVmFsdWVMaXN0TGVu Z3RoKGNvbnN0IEpzb25WYWx1ZUxpc3QgKmp2bCk7CiBzdGF0aWMgYm9vbCBKc29uVmFsdWVMaXN0 SXNFbXB0eShKc29uVmFsdWVMaXN0ICpqdmwpOwpAQCAtMjc1LDYgKzMzNCwzMiBAQCBzdGF0aWMg SnNvbmJWYWx1ZSAqd3JhcEl0ZW1zSW5BcnJheShjb25zdCBKc29uVmFsdWVMaXN0ICppdGVtcyk7 CiBzdGF0aWMgaW50CWNvbXBhcmVEYXRldGltZShEYXR1bSB2YWwxLCBPaWQgdHlwaWQxLCBEYXR1 bSB2YWwyLCBPaWQgdHlwaWQyLAogCQkJCQkJCWJvb2wgdXNlVHosIGJvb2wgKmNhc3RfZXJyb3Ip OwogCisKK3N0YXRpYyBKc29uVGFibGVQbGFuU3RhdGUgKiBKc29uVGFibGVJbml0UGxhblN0YXRl KEpzb25UYWJsZUV4ZWNDb250ZXh0ICogY3h0LAorCQkJCQkJCQkJCQkJICAgTm9kZSAqcGxhbiwK KwkJCQkJCQkJCQkJCSAgIEpzb25UYWJsZVBsYW5TdGF0ZSAqIHBhcmVudCk7CitzdGF0aWMgYm9v bCBKc29uVGFibGVQbGFuTmV4dFJvdyhKc29uVGFibGVQbGFuU3RhdGUgKiBzdGF0ZSk7CitzdGF0 aWMgYm9vbCBKc29uVGFibGVTY2FuTmV4dFJvdyhKc29uVGFibGVTY2FuU3RhdGUgKnNjYW4pOwor CitzdGF0aWMgdm9pZCBKc29uVGFibGVJbml0T3BhcXVlKFRhYmxlRnVuY1NjYW5TdGF0ZSAqc3Rh dGUsIGludCBuYXR0cyk7CitzdGF0aWMgdm9pZCBKc29uVGFibGVTZXREb2N1bWVudChUYWJsZUZ1 bmNTY2FuU3RhdGUgKnN0YXRlLCBEYXR1bSB2YWx1ZSk7CitzdGF0aWMgYm9vbCBKc29uVGFibGVG ZXRjaFJvdyhUYWJsZUZ1bmNTY2FuU3RhdGUgKnN0YXRlKTsKK3N0YXRpYyBEYXR1bSBKc29uVGFi bGVHZXRWYWx1ZShUYWJsZUZ1bmNTY2FuU3RhdGUgKnN0YXRlLCBpbnQgY29sbnVtLAorCQkJCSAg T2lkIHR5cGlkLCBpbnQzMiB0eXBtb2QsIGJvb2wgKmlzbnVsbCk7CitzdGF0aWMgdm9pZCBKc29u VGFibGVEZXN0cm95T3BhcXVlKFRhYmxlRnVuY1NjYW5TdGF0ZSAqc3RhdGUpOworCitjb25zdCBU YWJsZUZ1bmNSb3V0aW5lIEpzb25iVGFibGVSb3V0aW5lID0KK3sKKwlKc29uVGFibGVJbml0T3Bh cXVlLAorCUpzb25UYWJsZVNldERvY3VtZW50LAorCU5VTEwsCisJTlVMTCwKKwlOVUxMLAorCUpz b25UYWJsZUZldGNoUm93LAorCUpzb25UYWJsZUdldFZhbHVlLAorCUpzb25UYWJsZURlc3Ryb3lP cGFxdWUKK307CisKIC8qKioqKioqKioqKioqKioqKiogVXNlciBpbnRlcmZhY2UgdG8gSnNvblBh dGggZXhlY3V0b3IgKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCkBAIC0yNjYxLDYgKzI3NDYs MTMgQEAgc2V0QmFzZU9iamVjdChKc29uUGF0aEV4ZWNDb250ZXh0ICpjeHQsIEpzb25iVmFsdWUg KmpidiwgaW50MzIgaWQpCiAJcmV0dXJuIGJhc2VPYmplY3Q7CiB9CiAKK3N0YXRpYyB2b2lkCitK c29uVmFsdWVMaXN0Q2xlYXIoSnNvblZhbHVlTGlzdCAqanZsKQoreworCWp2bC0+c2luZ2xldG9u ID0gTlVMTDsKKwlqdmwtPmxpc3QgPSBOVUxMOworfQorCiBzdGF0aWMgdm9pZAogSnNvblZhbHVl TGlzdEFwcGVuZChKc29uVmFsdWVMaXN0ICpqdmwsIEpzb25iVmFsdWUgKmpidikKIHsKQEAgLTMx OTYsMyArMzI4OCw0NTggQEAgSnNvblBhdGhWYWx1ZShEYXR1bSBqYiwgSnNvblBhdGggKmpwLCBi b29sICplbXB0eSwgYm9vbCAqZXJyb3IsIExpc3QgKnZhcnMpCiAKIAlyZXR1cm4gcmVzOwogfQor CisvKioqKioqKioqKioqKioqKioqKioqKioqIEpTT05fVEFCTEUgZnVuY3Rpb25zICoqKioqKioq KioqKioqKioqKioqKioqKioqKi8KKworLyoKKyAqIFJldHVybnMgcHJpdmF0ZSBkYXRhIGZyb20g ZXhlY3V0b3Igc3RhdGUuIEVuc3VyZSB2YWxpZGl0eSBieSBjaGVjayB3aXRoCisgKiBNQUdJQyBu dW1iZXIuCisgKi8KK3N0YXRpYyBpbmxpbmUgSnNvblRhYmxlRXhlY0NvbnRleHQgKgorR2V0SnNv blRhYmxlRXhlY0NvbnRleHQoVGFibGVGdW5jU2NhblN0YXRlICpzdGF0ZSwgY29uc3QgY2hhciAq Zm5hbWUpCit7CisJSnNvblRhYmxlRXhlY0NvbnRleHQgKnJlc3VsdDsKKworCWlmICghSXNBKHN0 YXRlLCBUYWJsZUZ1bmNTY2FuU3RhdGUpKQorCQllbG9nKEVSUk9SLCAiJXMgY2FsbGVkIHdpdGgg aW52YWxpZCBUYWJsZUZ1bmNTY2FuU3RhdGUiLCBmbmFtZSk7CisJcmVzdWx0ID0gKEpzb25UYWJs ZUV4ZWNDb250ZXh0ICopIHN0YXRlLT5vcGFxdWU7CisJaWYgKHJlc3VsdC0+bWFnaWMgIT0gSlNP Tl9UQUJMRV9FWEVDX0NPTlRFWFRfTUFHSUMpCisJCWVsb2coRVJST1IsICIlcyBjYWxsZWQgd2l0 aCBpbnZhbGlkIFRhYmxlRnVuY1NjYW5TdGF0ZSIsIGZuYW1lKTsKKworCXJldHVybiByZXN1bHQ7 Cit9CisKKy8qIFJlY3Vyc2l2ZWx5IGluaXRpYWxpemUgSlNPTl9UQUJMRSBzY2FuIC8gam9pbiBz dGF0ZSAqLworc3RhdGljIEpzb25UYWJsZUpvaW5TdGF0ZSAqCitKc29uVGFibGVJbml0Sm9pblN0 YXRlKEpzb25UYWJsZUV4ZWNDb250ZXh0ICogY3h0LCBKc29uVGFibGVTaWJsaW5nICpwbGFuLAor CQkJCQkgICBKc29uVGFibGVQbGFuU3RhdGUgKiBwYXJlbnQpCit7CisJSnNvblRhYmxlSm9pblN0 YXRlICpqb2luID0gcGFsbG9jMChzaXplb2YoKmpvaW4pKTsKKworCWpvaW4tPnBsYW4udHlwZSA9 IEpTT05fVEFCTEVfSk9JTl9TVEFURTsKKwkvKiBwYXJlbnQgYW5kIG5lc3RlZCBub3Qgc2V0LiAq LworCisJam9pbi0+Y3Jvc3MgPSBwbGFuLT5jcm9zczsKKwlqb2luLT5sZWZ0ID0gSnNvblRhYmxl SW5pdFBsYW5TdGF0ZShjeHQsIHBsYW4tPmxhcmcsIHBhcmVudCk7CisJam9pbi0+cmlnaHQgPSBK c29uVGFibGVJbml0UGxhblN0YXRlKGN4dCwgcGxhbi0+cmFyZywgcGFyZW50KTsKKworCXJldHVy biBqb2luOworfQorCitzdGF0aWMgSnNvblRhYmxlU2NhblN0YXRlICoKK0pzb25UYWJsZUluaXRT Y2FuU3RhdGUoSnNvblRhYmxlRXhlY0NvbnRleHQgKiBjeHQsCisJCQkJCSAgIEpzb25UYWJsZVBs YW4gKnBsYW4sCisJCQkJCSAgIEpzb25UYWJsZVBsYW5TdGF0ZSAqcGFyZW50LAorCQkJCQkgICBM aXN0ICphcmdzLCBNZW1vcnlDb250ZXh0IG1jeHQpCit7CisJSnNvblRhYmxlU2NhblN0YXRlICpz Y2FuID0gcGFsbG9jMChzaXplb2YoKnNjYW4pKTsKKwlpbnQJCQlpOworCisJc2Nhbi0+cGxhbi50 eXBlID0gSlNPTl9UQUJMRV9TQ0FOX1NUQVRFOworCXNjYW4tPnBsYW4ucGFyZW50ID0gcGFyZW50 OworCisJc2Nhbi0+b3V0ZXJKb2luID0gcGxhbi0+b3V0ZXJKb2luOworCXNjYW4tPmVycm9yT25F cnJvciA9IHBsYW4tPmVycm9yT25FcnJvcjsKKwlzY2FuLT5wYXRoID0gRGF0dW1HZXRKc29uUGF0 aFAocGxhbi0+cGF0aC0+dmFsdWUtPmNvbnN0dmFsdWUpOworCXNjYW4tPmFyZ3MgPSBhcmdzOwor CXNjYW4tPm1jeHQgPSBBbGxvY1NldENvbnRleHRDcmVhdGUobWN4dCwgIkpzb25UYWJsZUV4ZWND b250ZXh0IiwKKwkJCQkJCQkJCSAgIEFMTE9DU0VUX0RFRkFVTFRfU0laRVMpOworCisJLyoKKwkg KiBTZXQgYWZ0ZXIgc2V0dGluZ3Mgc2Nhbi0+YXJncyBhbmQgc2Nhbi0+bWN4dCwgYmVjYXVzZSB0 aGUgcmVjdXJzaXZlCisJICogY2FsbCB3YW50cyB0byB1c2UgdGhvc2UgdmFsdWVzLgorCSAqLwor CXNjYW4tPnBsYW4ubmVzdGVkID0gcGxhbi0+Y2hpbGQgPworCQlKc29uVGFibGVJbml0UGxhblN0 YXRlKGN4dCwgcGxhbi0+Y2hpbGQsIChKc29uVGFibGVQbGFuU3RhdGUgKikgc2NhbikgOgorCQlO VUxMOworCisJc2Nhbi0+Y3VycmVudCA9IFBvaW50ZXJHZXREYXR1bShOVUxMKTsKKwlzY2FuLT5j dXJyZW50SXNOdWxsID0gdHJ1ZTsKKworCWZvciAoaSA9IHBsYW4tPmNvbE1pbjsgaSA8PSBwbGFu LT5jb2xNYXg7IGkrKykKKwkJY3h0LT5jb2xleHByc2NhbnNbaV0gPSBzY2FuOworCisJcmV0dXJu IHNjYW47Cit9CisKKy8qIFJlY3Vyc2l2ZWx5IGluaXRpYWxpemUgSlNPTl9UQUJMRSBzY2FuIHN0 YXRlICovCitzdGF0aWMgSnNvblRhYmxlUGxhblN0YXRlICoKK0pzb25UYWJsZUluaXRQbGFuU3Rh dGUoSnNvblRhYmxlRXhlY0NvbnRleHQgKiBjeHQsIE5vZGUgKnBsYW4sCisJCQkJCSAgIEpzb25U YWJsZVBsYW5TdGF0ZSAqIHBhcmVudCkKK3sKKwlKc29uVGFibGVQbGFuU3RhdGUgKnN0YXRlOwor CisJaWYgKElzQShwbGFuLCBKc29uVGFibGVTaWJsaW5nKSkKKwl7CisJCUpzb25UYWJsZVNpYmxp bmcgKmpvaW4gPSAoSnNvblRhYmxlU2libGluZyAqKSBwbGFuOworCisJCXN0YXRlID0gKEpzb25U YWJsZVBsYW5TdGF0ZSAqKQorCQkJSnNvblRhYmxlSW5pdEpvaW5TdGF0ZShjeHQsIGpvaW4sIHBh cmVudCk7CisJfQorCWVsc2UKKwl7CisJCUpzb25UYWJsZVBsYW4gKnNjYW4gPSBjYXN0Tm9kZShK c29uVGFibGVQbGFuLCBwbGFuKTsKKwkJSnNvblRhYmxlU2NhblN0YXRlICpwYXJlbnRfc2NhbiA9 IChKc29uVGFibGVTY2FuU3RhdGUgKikgcGFyZW50OworCisJCUFzc2VydChwYXJlbnRfc2Nhbik7 CisJCXN0YXRlID0gKEpzb25UYWJsZVBsYW5TdGF0ZSAqKQorCQkJSnNvblRhYmxlSW5pdFNjYW5T dGF0ZShjeHQsIHNjYW4sIHBhcmVudCwgcGFyZW50X3NjYW4tPmFyZ3MsCisJCQkJCQkJCSAgIHBh cmVudF9zY2FuLT5tY3h0KTsKKwl9CisKKwlyZXR1cm4gc3RhdGU7Cit9CisKKy8qCisgKiBKc29u VGFibGVJbml0T3BhcXVlCisgKgkJRmlsbCBpbiBUYWJsZUZ1bmNTY2FuU3RhdGUtPm9wYXF1ZSBm b3IgSnNvblRhYmxlIHByb2Nlc3NvcgorICovCitzdGF0aWMgdm9pZAorSnNvblRhYmxlSW5pdE9w YXF1ZShUYWJsZUZ1bmNTY2FuU3RhdGUgKnN0YXRlLCBpbnQgbmF0dHMpCit7CisJSnNvblRhYmxl RXhlY0NvbnRleHQgKmN4dDsKKwlQbGFuU3RhdGUgICpwcyA9ICZzdGF0ZS0+c3MucHM7CisJVGFi bGVGdW5jU2NhbiAqdGZzID0gY2FzdE5vZGUoVGFibGVGdW5jU2NhbiwgcHMtPnBsYW4pOworCVRh YmxlRnVuYyAgKnRmID0gdGZzLT50YWJsZWZ1bmM7CisJSnNvblRhYmxlUGxhbiAqcm9vdCA9IGNh c3ROb2RlKEpzb25UYWJsZVBsYW4sIHRmLT5wbGFuKTsKKwlKc29uRXhwciAgICpqZSA9IGNhc3RO b2RlKEpzb25FeHByLCB0Zi0+ZG9jZXhwcik7CisJTGlzdAkgICAqYXJncyA9IE5JTDsKKworCWN4 dCA9IHBhbGxvYzAoc2l6ZW9mKEpzb25UYWJsZUV4ZWNDb250ZXh0KSk7CisJY3h0LT5tYWdpYyA9 IEpTT05fVEFCTEVfRVhFQ19DT05URVhUX01BR0lDOworCisJaWYgKHN0YXRlLT5wYXNzaW5ndmFs ZXhwcnMpCisJeworCQlMaXN0Q2VsbCAgICpleHBybGM7CisJCUxpc3RDZWxsICAgKm5hbWVsYzsK KworCQlBc3NlcnQobGlzdF9sZW5ndGgoc3RhdGUtPnBhc3Npbmd2YWxleHBycykgPT0KKwkJCSAg IGxpc3RfbGVuZ3RoKGplLT5wYXNzaW5nX25hbWVzKSk7CisJCWZvcmJvdGgoZXhwcmxjLCBzdGF0 ZS0+cGFzc2luZ3ZhbGV4cHJzLAorCQkJCW5hbWVsYywgamUtPnBhc3NpbmdfbmFtZXMpCisJCXsK KwkJCUV4cHJTdGF0ZSAgKnN0YXRlID0gbGZpcnN0X25vZGUoRXhwclN0YXRlLCBleHBybGMpOwor CQkJU3RyaW5nCSAgICpuYW1lID0gbGZpcnN0X25vZGUoU3RyaW5nLCBuYW1lbGMpOworCQkJSnNv blBhdGhWYXJpYWJsZSAqdmFyID0gcGFsbG9jKHNpemVvZigqdmFyKSk7CisKKwkJCXZhci0+bmFt ZSA9IHBzdHJkdXAobmFtZS0+c3ZhbCk7CisJCQl2YXItPnR5cGlkID0gZXhwclR5cGUoKE5vZGUg Kikgc3RhdGUtPmV4cHIpOworCQkJdmFyLT50eXBtb2QgPSBleHByVHlwbW9kKChOb2RlICopIHN0 YXRlLT5leHByKTsKKworCQkJLyoKKwkJCSAqIEV2YWx1YXRlIHRoZSBleHByZXNzaW9uIGFuZCBz YXZlIHRoZSB2YWx1ZSB0byBiZSByZXR1cm5lZCBieQorCQkJICogR2V0SnNvblBhdGhWYXIoKS4K KwkJCSAqLworCQkJdmFyLT52YWx1ZSA9IEV4ZWNFdmFsRXhwcihzdGF0ZSwgcHMtPnBzX0V4cHJD b250ZXh0LAorCQkJCQkJCQkJICAmdmFyLT5pc251bGwpOworCisJCQlhcmdzID0gbGFwcGVuZChh cmdzLCB2YXIpOworCQl9CisJfQorCisJY3h0LT5jb2xleHByc2NhbnMgPSBwYWxsb2Moc2l6ZW9m KEpzb25UYWJsZVNjYW5TdGF0ZSAqKSAqCisJCQkJCQkJICAgbGlzdF9sZW5ndGgodGYtPmNvbHZh bGV4cHJzKSk7CisKKwljeHQtPnJvb3QgPSBKc29uVGFibGVJbml0U2NhblN0YXRlKGN4dCwgcm9v dCwgTlVMTCwgYXJncywKKwkJCQkJCQkJCSAgIEN1cnJlbnRNZW1vcnlDb250ZXh0KTsKKwlzdGF0 ZS0+b3BhcXVlID0gY3h0OworfQorCisvKiBSZXNldCBzY2FuIGl0ZXJhdG9yIHRvIHRoZSBiZWdp bm5pbmcgb2YgdGhlIGl0ZW0gbGlzdCAqLworc3RhdGljIHZvaWQKK0pzb25UYWJsZVJlc2NhbihK c29uVGFibGVTY2FuU3RhdGUgKnNjYW4pCit7CisJSnNvblZhbHVlTGlzdEluaXRJdGVyYXRvcigm c2Nhbi0+Zm91bmQsICZzY2FuLT5pdGVyKTsKKwlzY2FuLT5jdXJyZW50ID0gUG9pbnRlckdldERh dHVtKE5VTEwpOworCXNjYW4tPmN1cnJlbnRJc051bGwgPSB0cnVlOworCXNjYW4tPmFkdmFuY2VO ZXN0ZWQgPSBmYWxzZTsKKwlzY2FuLT5vcmRpbmFsID0gMDsKK30KKworLyogUmVzZXQgY29udGV4 dCBpdGVtIG9mIGEgc2NhbiwgZXhlY3V0ZSBKU09OIHBhdGggYW5kIHJlc2V0IGEgc2NhbiAqLwor c3RhdGljIHZvaWQKK0pzb25UYWJsZVJlc2V0Q29udGV4dEl0ZW0oSnNvblRhYmxlU2NhblN0YXRl ICpzY2FuLCBEYXR1bSBpdGVtKQoreworCU1lbW9yeUNvbnRleHQgb2xkY3h0OworCUpzb25QYXRo RXhlY1Jlc3VsdCByZXM7CisJSnNvbmIJICAgKmpzID0gKEpzb25iICopIERhdHVtR2V0SnNvbmJQ KGl0ZW0pOworCisJSnNvblZhbHVlTGlzdENsZWFyKCZzY2FuLT5mb3VuZCk7CisKKwlNZW1vcnlD b250ZXh0UmVzZXRPbmx5KHNjYW4tPm1jeHQpOworCisJb2xkY3h0ID0gTWVtb3J5Q29udGV4dFN3 aXRjaFRvKHNjYW4tPm1jeHQpOworCisJcmVzID0gZXhlY3V0ZUpzb25QYXRoKHNjYW4tPnBhdGgs IHNjYW4tPmFyZ3MsCisJCQkJCQkgIEdldEpzb25QYXRoVmFyLCBDb3VudEpzb25QYXRoVmFycywK KwkJCQkJCSAganMsIHNjYW4tPmVycm9yT25FcnJvciwgJnNjYW4tPmZvdW5kLAorCQkJCQkJICBm YWxzZSAvKiBGSVhNRSAqLyApOworCisJTWVtb3J5Q29udGV4dFN3aXRjaFRvKG9sZGN4dCk7CisK KwlpZiAoanBlcklzRXJyb3IocmVzKSkKKwl7CisJCUFzc2VydCghc2Nhbi0+ZXJyb3JPbkVycm9y KTsKKwkJSnNvblZhbHVlTGlzdENsZWFyKCZzY2FuLT5mb3VuZCk7CS8qIEVNUFRZIE9OIEVSUk9S IGNhc2UgKi8KKwl9CisKKwlKc29uVGFibGVSZXNjYW4oc2Nhbik7Cit9CisKKy8qCisgKiBKc29u VGFibGVTZXREb2N1bWVudAorICoJCUluc3RhbGwgdGhlIGlucHV0IGRvY3VtZW50CisgKi8KK3N0 YXRpYyB2b2lkCitKc29uVGFibGVTZXREb2N1bWVudChUYWJsZUZ1bmNTY2FuU3RhdGUgKnN0YXRl LCBEYXR1bSB2YWx1ZSkKK3sKKwlKc29uVGFibGVFeGVjQ29udGV4dCAqY3h0ID0KKwkJR2V0SnNv blRhYmxlRXhlY0NvbnRleHQoc3RhdGUsICJKc29uVGFibGVTZXREb2N1bWVudCIpOworCisJSnNv blRhYmxlUmVzZXRDb250ZXh0SXRlbShjeHQtPnJvb3QsIHZhbHVlKTsKK30KKworLyogUmVjdXJz aXZlbHkgcmVzZXQgc2NhbiBhbmQgaXRzIGNoaWxkIG5vZGVzICovCitzdGF0aWMgdm9pZAorSnNv blRhYmxlUmVzY2FuUmVjdXJzaXZlKEpzb25UYWJsZVBsYW5TdGF0ZSAqIHN0YXRlKQoreworCWlm IChzdGF0ZS0+dHlwZSA9PSBKU09OX1RBQkxFX0pPSU5fU1RBVEUpCisJeworCQlKc29uVGFibGVK b2luU3RhdGUgKmpvaW4gPSAoSnNvblRhYmxlSm9pblN0YXRlICopIHN0YXRlOworCisJCUpzb25U YWJsZVJlc2NhblJlY3Vyc2l2ZShqb2luLT5sZWZ0KTsKKwkJSnNvblRhYmxlUmVzY2FuUmVjdXJz aXZlKGpvaW4tPnJpZ2h0KTsKKwkJam9pbi0+YWR2YW5jZVJpZ2h0ID0gZmFsc2U7CisJfQorCWVs c2UKKwl7CisJCUpzb25UYWJsZVNjYW5TdGF0ZSAqc2NhbiA9IChKc29uVGFibGVTY2FuU3RhdGUg Kikgc3RhdGU7CisKKwkJQXNzZXJ0KHN0YXRlLT50eXBlID09IEpTT05fVEFCTEVfU0NBTl9TVEFU RSk7CisJCUpzb25UYWJsZVJlc2NhbihzY2FuKTsKKwkJaWYgKHNjYW4tPnBsYW4ubmVzdGVkKQor CQkJSnNvblRhYmxlUmVzY2FuUmVjdXJzaXZlKHNjYW4tPnBsYW4ubmVzdGVkKTsKKwl9Cit9CisK Ky8qCisgKiBGZXRjaCBuZXh0IHJvdyBmcm9tIGEgY3Jvc3MvdW5pb24gam9pbmVkIHNjYW4uCisg KgorICogUmV0dXJucyBmYWxzZSBhdCB0aGUgZW5kIG9mIGEgc2NhbiwgdHJ1ZSBvdGhlcndpc2Uu CisgKi8KK3N0YXRpYyBib29sCitKc29uVGFibGVQbGFuTmV4dFJvdyhKc29uVGFibGVQbGFuU3Rh dGUgKiBzdGF0ZSkKK3sKKwlKc29uVGFibGVKb2luU3RhdGUgKmpvaW47CisKKwlpZiAoc3RhdGUt PnR5cGUgPT0gSlNPTl9UQUJMRV9TQ0FOX1NUQVRFKQorCQlyZXR1cm4gSnNvblRhYmxlU2Nhbk5l eHRSb3coKEpzb25UYWJsZVNjYW5TdGF0ZSAqKSBzdGF0ZSk7CisKKwlqb2luID0gKEpzb25UYWJs ZUpvaW5TdGF0ZSAqKSBzdGF0ZTsKKwlpZiAoam9pbi0+YWR2YW5jZVJpZ2h0KQorCXsKKwkJLyog ZmV0Y2ggbmV4dCBpbm5lciByb3cgKi8KKwkJaWYgKEpzb25UYWJsZVBsYW5OZXh0Um93KGpvaW4t PnJpZ2h0KSkKKwkJCXJldHVybiB0cnVlOworCisJCS8qIGlubmVyIHJvd3MgYXJlIGV4aGF1c3Rl ZCAqLworCQlpZiAoam9pbi0+Y3Jvc3MpCisJCQlqb2luLT5hZHZhbmNlUmlnaHQgPSBmYWxzZTsg LyogbmV4dCBvdXRlciByb3cgKi8KKwkJZWxzZQorCQkJcmV0dXJuIGZhbHNlOwkJLyogZW5kIG9m IHNjYW4gKi8KKwl9CisKKwl3aGlsZSAoIWpvaW4tPmFkdmFuY2VSaWdodCkKKwl7CisJCS8qIGZl dGNoIG5leHQgb3V0ZXIgcm93ICovCisJCWJvb2wJCW1vcmUgPSBKc29uVGFibGVQbGFuTmV4dFJv dyhqb2luLT5sZWZ0KTsKKworCQlpZiAoam9pbi0+Y3Jvc3MpCisJCXsKKwkJCWlmICghbW9yZSkK KwkJCQlyZXR1cm4gZmFsc2U7CS8qIGVuZCBvZiBzY2FuICovCisKKwkJCUpzb25UYWJsZVJlc2Nh blJlY3Vyc2l2ZShqb2luLT5yaWdodCk7CisKKwkJCWlmICghSnNvblRhYmxlUGxhbk5leHRSb3co am9pbi0+cmlnaHQpKQorCQkJCWNvbnRpbnVlOwkJLyogbmV4dCBvdXRlciByb3cgKi8KKworCQkJ am9pbi0+YWR2YW5jZVJpZ2h0ID0gdHJ1ZTsJLyogbmV4dCBpbm5lciByb3cgKi8KKwkJfQorCQll bHNlIGlmICghbW9yZSkKKwkJeworCQkJaWYgKCFKc29uVGFibGVQbGFuTmV4dFJvdyhqb2luLT5y aWdodCkpCisJCQkJcmV0dXJuIGZhbHNlOwkvKiBlbmQgb2Ygc2NhbiAqLworCisJCQlqb2luLT5h ZHZhbmNlUmlnaHQgPSB0cnVlOwkvKiBuZXh0IGlubmVyIHJvdyAqLworCQl9CisKKwkJYnJlYWs7 CisJfQorCisJcmV0dXJuIHRydWU7Cit9CisKKy8qIFJlY3Vyc2l2ZWx5IHNldCAncmVzZXQnIGZs YWcgb2Ygc2NhbiBhbmQgaXRzIGNoaWxkIG5vZGVzICovCitzdGF0aWMgdm9pZAorSnNvblRhYmxl UGxhblJlc2V0KEpzb25UYWJsZVBsYW5TdGF0ZSAqIHN0YXRlKQoreworCWlmIChzdGF0ZS0+dHlw ZSA9PSBKU09OX1RBQkxFX0pPSU5fU1RBVEUpCisJeworCQlKc29uVGFibGVKb2luU3RhdGUgKmpv aW4gPSAoSnNvblRhYmxlSm9pblN0YXRlICopIHN0YXRlOworCisJCUpzb25UYWJsZVBsYW5SZXNl dChqb2luLT5sZWZ0KTsKKwkJSnNvblRhYmxlUGxhblJlc2V0KGpvaW4tPnJpZ2h0KTsKKwkJam9p bi0+YWR2YW5jZVJpZ2h0ID0gZmFsc2U7CisJfQorCWVsc2UKKwl7CisJCUpzb25UYWJsZVNjYW5T dGF0ZSAqc2NhbjsKKworCQlBc3NlcnQoc3RhdGUtPnR5cGUgPT0gSlNPTl9UQUJMRV9TQ0FOX1NU QVRFKTsKKwkJc2NhbiA9IChKc29uVGFibGVTY2FuU3RhdGUgKikgc3RhdGU7CisJCXNjYW4tPnJl c2V0ID0gdHJ1ZTsKKwkJc2Nhbi0+YWR2YW5jZU5lc3RlZCA9IGZhbHNlOworCisJCWlmIChzY2Fu LT5wbGFuLm5lc3RlZCkKKwkJCUpzb25UYWJsZVBsYW5SZXNldChzY2FuLT5wbGFuLm5lc3RlZCk7 CisJfQorfQorCisvKgorICogRmV0Y2ggbmV4dCByb3cgZnJvbSBhIHNpbXBsZSBzY2FuIHdpdGgg b3V0ZXIvaW5uZXIgam9pbmVkIG5lc3RlZCBzdWJzY2Fucy4KKyAqCisgKiBSZXR1cm5zIGZhbHNl IGF0IHRoZSBlbmQgb2YgYSBzY2FuLCB0cnVlIG90aGVyd2lzZS4KKyAqLworc3RhdGljIGJvb2wK K0pzb25UYWJsZVNjYW5OZXh0Um93KEpzb25UYWJsZVNjYW5TdGF0ZSAqc2NhbikKK3sKKwkvKiBy ZXNldCBjb250ZXh0IGl0ZW0gaWYgcmVxdWVzdGVkICovCisJaWYgKHNjYW4tPnJlc2V0KQorCXsK KwkJSnNvblRhYmxlU2NhblN0YXRlICpwYXJlbnRfc2NhbiA9CisJCQkoSnNvblRhYmxlU2NhblN0 YXRlICopIHNjYW4tPnBsYW4ucGFyZW50OworCisJCUFzc2VydChwYXJlbnRfc2NhbiAmJiAhcGFy ZW50X3NjYW4tPmN1cnJlbnRJc051bGwpOworCQlKc29uVGFibGVSZXNldENvbnRleHRJdGVtKHNj YW4sIHBhcmVudF9zY2FuLT5jdXJyZW50KTsKKwkJc2Nhbi0+cmVzZXQgPSBmYWxzZTsKKwl9CisK KwlpZiAoc2Nhbi0+YWR2YW5jZU5lc3RlZCkKKwl7CisJCS8qIGZldGNoIG5leHQgbmVzdGVkIHJv dyAqLworCQlzY2FuLT5hZHZhbmNlTmVzdGVkID0gSnNvblRhYmxlUGxhbk5leHRSb3coc2Nhbi0+ cGxhbi5uZXN0ZWQpOworCisJCWlmIChzY2FuLT5hZHZhbmNlTmVzdGVkKQorCQkJcmV0dXJuIHRy dWU7CisJfQorCisJZm9yICg7OykKKwl7CisJCS8qIGZldGNoIG5leHQgcm93ICovCisJCUpzb25i VmFsdWUgKmpidiA9IEpzb25WYWx1ZUxpc3ROZXh0KCZzY2FuLT5mb3VuZCwgJnNjYW4tPml0ZXIp OworCQlNZW1vcnlDb250ZXh0IG9sZGN4dDsKKworCQlpZiAoIWpidikKKwkJeworCQkJc2Nhbi0+ Y3VycmVudCA9IFBvaW50ZXJHZXREYXR1bShOVUxMKTsKKwkJCXNjYW4tPmN1cnJlbnRJc051bGwg PSB0cnVlOworCQkJcmV0dXJuIGZhbHNlOwkJLyogZW5kIG9mIHNjYW4gKi8KKwkJfQorCisJCS8q IHNldCBjdXJyZW50IHJvdyBpdGVtICovCisJCW9sZGN4dCA9IE1lbW9yeUNvbnRleHRTd2l0Y2hU byhzY2FuLT5tY3h0KTsKKwkJc2Nhbi0+Y3VycmVudCA9IEpzb25iUEdldERhdHVtKEpzb25iVmFs dWVUb0pzb25iKGpidikpOworCQlzY2FuLT5jdXJyZW50SXNOdWxsID0gZmFsc2U7CisJCU1lbW9y eUNvbnRleHRTd2l0Y2hUbyhvbGRjeHQpOworCisJCXNjYW4tPm9yZGluYWwrKzsKKworCQlpZiAo IXNjYW4tPnBsYW4ubmVzdGVkKQorCQkJYnJlYWs7CisKKwkJSnNvblRhYmxlUGxhblJlc2V0KHNj YW4tPnBsYW4ubmVzdGVkKTsKKworCQlzY2FuLT5hZHZhbmNlTmVzdGVkID0gSnNvblRhYmxlUGxh bk5leHRSb3coc2Nhbi0+cGxhbi5uZXN0ZWQpOworCisJCWlmIChzY2FuLT5hZHZhbmNlTmVzdGVk IHx8IHNjYW4tPm91dGVySm9pbikKKwkJCWJyZWFrOworCX0KKworCXJldHVybiB0cnVlOworfQor CisvKgorICogSnNvblRhYmxlRmV0Y2hSb3cKKyAqCQlQcmVwYXJlIHRoZSBuZXh0ICJjdXJyZW50 IiB0dXBsZSBmb3IgdXBjb21pbmcgR2V0VmFsdWUgY2FsbHMuCisgKgkJUmV0dXJucyBmYWxzZSBp ZiBubyBtb3JlIHJvd3MgY2FuIGJlIHJldHVybmVkLgorICovCitzdGF0aWMgYm9vbAorSnNvblRh YmxlRmV0Y2hSb3coVGFibGVGdW5jU2NhblN0YXRlICpzdGF0ZSkKK3sKKwlKc29uVGFibGVFeGVj Q29udGV4dCAqY3h0ID0KKwkJR2V0SnNvblRhYmxlRXhlY0NvbnRleHQoc3RhdGUsICJKc29uVGFi bGVGZXRjaFJvdyIpOworCisJcmV0dXJuIEpzb25UYWJsZVNjYW5OZXh0Um93KGN4dC0+cm9vdCk7 Cit9CisKKy8qCisgKiBKc29uVGFibGVHZXRWYWx1ZQorICoJCVJldHVybiB0aGUgdmFsdWUgZm9y IGNvbHVtbiBudW1iZXIgJ2NvbG51bScgZm9yIHRoZSBjdXJyZW50IHJvdy4KKyAqCisgKiBUaGlz IGxlYWtzIG1lbW9yeSwgc28gYmUgc3VyZSB0byByZXNldCBvZnRlbiB0aGUgY29udGV4dCBpbiB3 aGljaCBpdCdzCisgKiBjYWxsZWQuCisgKi8KK3N0YXRpYyBEYXR1bQorSnNvblRhYmxlR2V0VmFs dWUoVGFibGVGdW5jU2NhblN0YXRlICpzdGF0ZSwgaW50IGNvbG51bSwKKwkJCQkgIE9pZCB0eXBp ZCwgaW50MzIgdHlwbW9kLCBib29sICppc251bGwpCit7CisJSnNvblRhYmxlRXhlY0NvbnRleHQg KmN4dCA9CisJCUdldEpzb25UYWJsZUV4ZWNDb250ZXh0KHN0YXRlLCAiSnNvblRhYmxlR2V0VmFs dWUiKTsKKwlFeHByQ29udGV4dCAqZWNvbnRleHQgPSBzdGF0ZS0+c3MucHMucHNfRXhwckNvbnRl eHQ7CisJRXhwclN0YXRlICAqZXN0YXRlID0gbGlzdF9udGgoc3RhdGUtPmNvbHZhbGV4cHJzLCBj b2xudW0pOworCUpzb25UYWJsZVNjYW5TdGF0ZSAqc2NhbiA9IGN4dC0+Y29sZXhwcnNjYW5zW2Nv bG51bV07CisJRGF0dW0JCXJlc3VsdDsKKworCWlmIChzY2FuLT5jdXJyZW50SXNOdWxsKQkvKiBO VUxMIGZyb20gb3V0ZXIvdW5pb24gam9pbiAqLworCXsKKwkJcmVzdWx0ID0gKERhdHVtKSAwOwor CQkqaXNudWxsID0gdHJ1ZTsKKwl9CisJZWxzZSBpZiAoZXN0YXRlKQkJCS8qIHJlZ3VsYXIgY29s dW1uICovCisJeworCQlEYXR1bQkJc2F2ZWRfY2FzZVZhbHVlID0gZWNvbnRleHQtPmNhc2VWYWx1 ZV9kYXR1bTsKKwkJYm9vbAkJc2F2ZWRfY2FzZUlzTnVsbCA9IGVjb250ZXh0LT5jYXNlVmFsdWVf aXNOdWxsOworCisJCS8qIFBhc3MgdGhlIHZhbHVlIGZvciBDYXNlVGVzdEV4cHIgdGhhdCBtYXkg YmUgcHJlc2VudCBpbiBjb2xleHByICovCisJCWVjb250ZXh0LT5jYXNlVmFsdWVfZGF0dW0gPSBz Y2FuLT5jdXJyZW50OworCQllY29udGV4dC0+Y2FzZVZhbHVlX2lzTnVsbCA9IGZhbHNlOworCisJ CXJlc3VsdCA9IEV4ZWNFdmFsRXhwcihlc3RhdGUsIGVjb250ZXh0LCBpc251bGwpOworCisJCWVj b250ZXh0LT5jYXNlVmFsdWVfZGF0dW0gPSBzYXZlZF9jYXNlVmFsdWU7CisJCWVjb250ZXh0LT5j YXNlVmFsdWVfaXNOdWxsID0gc2F2ZWRfY2FzZUlzTnVsbDsKKwl9CisJZWxzZQorCXsKKwkJcmVz dWx0ID0gSW50MzJHZXREYXR1bShzY2FuLT5vcmRpbmFsKTsJLyogb3JkaW5hbGl0eSBjb2x1bW4g Ki8KKwkJKmlzbnVsbCA9IGZhbHNlOworCX0KKworCXJldHVybiByZXN1bHQ7Cit9CisKKy8qCisg KiBKc29uVGFibGVEZXN0cm95T3BhcXVlCisgKi8KK3N0YXRpYyB2b2lkCitKc29uVGFibGVEZXN0 cm95T3BhcXVlKFRhYmxlRnVuY1NjYW5TdGF0ZSAqc3RhdGUpCit7CisJSnNvblRhYmxlRXhlY0Nv bnRleHQgKmN4dCA9CisJCUdldEpzb25UYWJsZUV4ZWNDb250ZXh0KHN0YXRlLCAiSnNvblRhYmxl RGVzdHJveU9wYXF1ZSIpOworCisJLyogbm90IHZhbGlkIGFueW1vcmUgKi8KKwljeHQtPm1hZ2lj ID0gMDsKKworCXN0YXRlLT5vcGFxdWUgPSBOVUxMOworfQpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tl bmQvdXRpbHMvYWR0L3J1bGV1dGlscy5jIGIvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L3J1bGV1dGls cy5jCmluZGV4IDI3MzUzNDg0MTYuLmEyN2M3YTM1MGUgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5k L3V0aWxzL2FkdC9ydWxldXRpbHMuYworKysgYi9zcmMvYmFja2VuZC91dGlscy9hZHQvcnVsZXV0 aWxzLmMKQEAgLTUyMiw2ICs1MjIsOCBAQCBzdGF0aWMgY2hhciAqZmxhdHRlbl9yZWxvcHRpb25z KE9pZCByZWxpZCk7CiBzdGF0aWMgdm9pZCBnZXRfcmVsb3B0aW9ucyhTdHJpbmdJbmZvIGJ1Ziwg RGF0dW0gcmVsb3B0aW9ucyk7CiBzdGF0aWMgdm9pZCBnZXRfanNvbl9wYXRoX3NwZWMoTm9kZSAq cGF0aF9zcGVjLCBkZXBhcnNlX2NvbnRleHQgKmNvbnRleHQsCiAJCQkJCQkJICAgYm9vbCBzaG93 aW1wbGljaXQpOworc3RhdGljIHZvaWQgZ2V0X2pzb25fdGFibGVfY29sdW1ucyhUYWJsZUZ1bmMg KnRmLCBKc29uVGFibGVQbGFuICpub2RlLAorCQkJCQkJCQkgICBkZXBhcnNlX2NvbnRleHQgKmNv bnRleHQsIGJvb2wgc2hvd2ltcGxpY2l0KTsKIAogI2RlZmluZSBvbmx5X21hcmtlcihydGUpICAo KHJ0ZSktPmluaCA/ICIiIDogIk9OTFkgIikKIApAQCAtODYyNyw3ICs4NjI5LDggQEAgZ2V0X2pz b25fYmVoYXZpb3IoSnNvbkJlaGF2aW9yICpiZWhhdmlvciwgZGVwYXJzZV9jb250ZXh0ICpjb250 ZXh0LAogLyoKICAqIGdldF9qc29uX2V4cHJfb3B0aW9ucwogICoKLSAqIFBhcnNlIGJhY2sgY29t bW9uIG9wdGlvbnMgZm9yIEpTT05fUVVFUlksIEpTT05fVkFMVUUsIEpTT05fRVhJU1RTLgorICog UGFyc2UgYmFjayBjb21tb24gb3B0aW9ucyBmb3IgSlNPTl9RVUVSWSwgSlNPTl9WQUxVRSwgSlNP Tl9FWElTVFMgYW5kCisgKiBKU09OX1RBQkxFIGNvbHVtbnMuCiAgKi8KIHN0YXRpYyB2b2lkCiBn ZXRfanNvbl9leHByX29wdGlvbnMoSnNvbkV4cHIgKmpzZXhwciwgZGVwYXJzZV9jb250ZXh0ICpj b250ZXh0LApAQCAtOTg3NCw2ICs5ODc3LDkgQEAgZ2V0X3J1bGVfZXhwcihOb2RlICpub2RlLCBk ZXBhcnNlX2NvbnRleHQgKmNvbnRleHQsCiAJCQkJCWNhc2UgSlNPTl9WQUxVRV9PUDoKIAkJCQkJ CWFwcGVuZFN0cmluZ0luZm9TdHJpbmcoYnVmLCAiSlNPTl9WQUxVRSgiKTsKIAkJCQkJCWJyZWFr OworCQkJCQlkZWZhdWx0OgorCQkJCQkJZWxvZyhFUlJPUiwgInVuZXhwZWN0ZWQgSnNvbkV4cHIg dHlwZTogJWQiLCBqZXhwci0+b3ApOworCQkJCQkJYnJlYWs7CiAJCQkJfQogCiAJCQkJZ2V0X3J1 bGVfZXhwcihqZXhwci0+Zm9ybWF0dGVkX2V4cHIsIGNvbnRleHQsIHNob3dpbXBsaWNpdCk7CkBA IC0xMTI0MCwxNiArMTEyNDYsMTQgQEAgZ2V0X3N1YmxpbmtfZXhwcihTdWJMaW5rICpzdWJsaW5r LCBkZXBhcnNlX2NvbnRleHQgKmNvbnRleHQpCiAKIAogLyogLS0tLS0tLS0tLQotICogZ2V0X3Rh YmxlZnVuYwkJCS0gUGFyc2UgYmFjayBhIHRhYmxlIGZ1bmN0aW9uCisgKiBnZXRfeG1sdGFibGUJ CQktIFBhcnNlIGJhY2sgYSBYTUxUQUJMRSBmdW5jdGlvbgogICogLS0tLS0tLS0tLQogICovCiBz dGF0aWMgdm9pZAotZ2V0X3RhYmxlZnVuYyhUYWJsZUZ1bmMgKnRmLCBkZXBhcnNlX2NvbnRleHQg KmNvbnRleHQsIGJvb2wgc2hvd2ltcGxpY2l0KQorZ2V0X3htbHRhYmxlKFRhYmxlRnVuYyAqdGYs IGRlcGFyc2VfY29udGV4dCAqY29udGV4dCwgYm9vbCBzaG93aW1wbGljaXQpCiB7CiAJU3RyaW5n SW5mbwlidWYgPSBjb250ZXh0LT5idWY7CiAKLQkvKiBYTUxUQUJMRSBpcyB0aGUgb25seSBleGlz dGluZyBpbXBsZW1lbnRhdGlvbi4gICovCi0KIAlhcHBlbmRTdHJpbmdJbmZvU3RyaW5nKGJ1Ziwg IlhNTFRBQkxFKCIpOwogCiAJaWYgKHRmLT5uc191cmlzICE9IE5JTCkKQEAgLTExMzQwLDYgKzEx MzQ0LDI3MSBAQCBnZXRfdGFibGVmdW5jKFRhYmxlRnVuYyAqdGYsIGRlcGFyc2VfY29udGV4dCAq Y29udGV4dCwgYm9vbCBzaG93aW1wbGljaXQpCiAJYXBwZW5kU3RyaW5nSW5mb0NoYXIoYnVmLCAn KScpOwogfQogCisvKgorICogZ2V0X2pzb25fbmVzdGVkX2NvbHVtbnMgLSBQYXJzZSBiYWNrIG5l c3RlZCBKU09OX1RBQkxFIGNvbHVtbnMKKyAqLworc3RhdGljIHZvaWQKK2dldF9qc29uX3RhYmxl X25lc3RlZF9jb2x1bW5zKFRhYmxlRnVuYyAqdGYsIE5vZGUgKm5vZGUsCisJCQkJCQkJICBkZXBh cnNlX2NvbnRleHQgKmNvbnRleHQsIGJvb2wgc2hvd2ltcGxpY2l0LAorCQkJCQkJCSAgYm9vbCBu ZWVkY29tbWEpCit7CisJaWYgKElzQShub2RlLCBKc29uVGFibGVTaWJsaW5nKSkKKwl7CisJCUpz b25UYWJsZVNpYmxpbmcgKm4gPSAoSnNvblRhYmxlU2libGluZyAqKSBub2RlOworCisJCWdldF9q c29uX3RhYmxlX25lc3RlZF9jb2x1bW5zKHRmLCBuLT5sYXJnLCBjb250ZXh0LCBzaG93aW1wbGlj aXQsCisJCQkJCQkJCQkgIG5lZWRjb21tYSk7CisJCWdldF9qc29uX3RhYmxlX25lc3RlZF9jb2x1 bW5zKHRmLCBuLT5yYXJnLCBjb250ZXh0LCBzaG93aW1wbGljaXQsIHRydWUpOworCX0KKwllbHNl CisJeworCQlKc29uVGFibGVQbGFuICpuID0gY2FzdE5vZGUoSnNvblRhYmxlUGxhbiwgbm9kZSk7 CisKKwkJaWYgKG5lZWRjb21tYSkKKwkJCWFwcGVuZFN0cmluZ0luZm9DaGFyKGNvbnRleHQtPmJ1 ZiwgJywnKTsKKworCQlhcHBlbmRTdHJpbmdJbmZvQ2hhcihjb250ZXh0LT5idWYsICcgJyk7CisJ CWFwcGVuZENvbnRleHRLZXl3b3JkKGNvbnRleHQsICJORVNURUQgUEFUSCAiLCAwLCAwLCAwKTsK KwkJZ2V0X2NvbnN0X2V4cHIobi0+cGF0aC0+dmFsdWUsIGNvbnRleHQsIC0xKTsKKwkJYXBwZW5k U3RyaW5nSW5mbyhjb250ZXh0LT5idWYsICIgQVMgJXMiLCBxdW90ZV9pZGVudGlmaWVyKG4tPnBh dGgtPm5hbWUpKTsKKwkJZ2V0X2pzb25fdGFibGVfY29sdW1ucyh0ZiwgbiwgY29udGV4dCwgc2hv d2ltcGxpY2l0KTsKKwl9Cit9CisKKy8qCisgKiBnZXRfanNvbl90YWJsZV9wbGFuIC0gUGFyc2Ug YmFjayBhIEpTT05fVEFCTEUgcGxhbgorICovCitzdGF0aWMgdm9pZAorZ2V0X2pzb25fdGFibGVf cGxhbihUYWJsZUZ1bmMgKnRmLCBOb2RlICpub2RlLCBkZXBhcnNlX2NvbnRleHQgKmNvbnRleHQs CisJCQkJCWJvb2wgcGFyZW50aGVzaXplKQoreworCWlmIChwYXJlbnRoZXNpemUpCisJCWFwcGVu ZFN0cmluZ0luZm9DaGFyKGNvbnRleHQtPmJ1ZiwgJygnKTsKKworCWlmIChJc0Eobm9kZSwgSnNv blRhYmxlU2libGluZykpCisJeworCQlKc29uVGFibGVTaWJsaW5nICpuID0gKEpzb25UYWJsZVNp YmxpbmcgKikgbm9kZTsKKworCQlnZXRfanNvbl90YWJsZV9wbGFuKHRmLCBuLT5sYXJnLCBjb250 ZXh0LAorCQkJCQkJCUlzQShuLT5sYXJnLCBKc29uVGFibGVTaWJsaW5nKSB8fAorCQkJCQkJCWNh c3ROb2RlKEpzb25UYWJsZVBsYW4sIG4tPmxhcmcpLT5jaGlsZCk7CisKKwkJYXBwZW5kU3RyaW5n SW5mb1N0cmluZyhjb250ZXh0LT5idWYsIG4tPmNyb3NzID8gIiBDUk9TUyAiIDogIiBVTklPTiAi KTsKKworCQlnZXRfanNvbl90YWJsZV9wbGFuKHRmLCBuLT5yYXJnLCBjb250ZXh0LAorCQkJCQkJ CUlzQShuLT5yYXJnLCBKc29uVGFibGVTaWJsaW5nKSB8fAorCQkJCQkJCWNhc3ROb2RlKEpzb25U YWJsZVBsYW4sIG4tPnJhcmcpLT5jaGlsZCk7CisJfQorCWVsc2UKKwl7CisJCUpzb25UYWJsZVBs YW4gKm4gPSBjYXN0Tm9kZShKc29uVGFibGVQbGFuLCBub2RlKTsKKworCQlhcHBlbmRTdHJpbmdJ bmZvU3RyaW5nKGNvbnRleHQtPmJ1ZiwgcXVvdGVfaWRlbnRpZmllcihuLT5wYXRoLT5uYW1lKSk7 CisKKwkJaWYgKG4tPmNoaWxkKQorCQl7CisJCQlhcHBlbmRTdHJpbmdJbmZvU3RyaW5nKGNvbnRl eHQtPmJ1ZiwKKwkJCQkJCQkJICAgbi0+b3V0ZXJKb2luID8gIiBPVVRFUiAiIDogIiBJTk5FUiAi KTsKKwkJCWdldF9qc29uX3RhYmxlX3BsYW4odGYsIG4tPmNoaWxkLCBjb250ZXh0LAorCQkJCQkJ CQlJc0Eobi0+Y2hpbGQsIEpzb25UYWJsZVNpYmxpbmcpKTsKKwkJfQorCX0KKworCWlmIChwYXJl bnRoZXNpemUpCisJCWFwcGVuZFN0cmluZ0luZm9DaGFyKGNvbnRleHQtPmJ1ZiwgJyknKTsKK30K KworLyoKKyAqIGdldF9qc29uX3RhYmxlX2NvbHVtbnMgLSBQYXJzZSBiYWNrIEpTT05fVEFCTEUg Y29sdW1ucworICovCitzdGF0aWMgdm9pZAorZ2V0X2pzb25fdGFibGVfY29sdW1ucyhUYWJsZUZ1 bmMgKnRmLCBKc29uVGFibGVQbGFuICpwbGFuLAorCQkJCQkgICBkZXBhcnNlX2NvbnRleHQgKmNv bnRleHQsIGJvb2wgc2hvd2ltcGxpY2l0KQoreworCVN0cmluZ0luZm8JYnVmID0gY29udGV4dC0+ YnVmOworCUpzb25FeHByICAgKmpleHByID0gY2FzdE5vZGUoSnNvbkV4cHIsIHRmLT5kb2NleHBy KTsKKwlMaXN0Q2VsbCAgICpsY19jb2xuYW1lOworCUxpc3RDZWxsICAgKmxjX2NvbHR5cGU7CisJ TGlzdENlbGwgICAqbGNfY29sdHlwbW9kOworCUxpc3RDZWxsICAgKmxjX2NvbHZhbGV4cHI7CisJ aW50CQkJY29sbnVtID0gMDsKKworCWFwcGVuZFN0cmluZ0luZm9DaGFyKGJ1ZiwgJyAnKTsKKwlh cHBlbmRDb250ZXh0S2V5d29yZChjb250ZXh0LCAiQ09MVU1OUyAoIiwgMCwgMCwgMCk7CisKKwlp ZiAoUFJFVFRZX0lOREVOVChjb250ZXh0KSkKKwkJY29udGV4dC0+aW5kZW50TGV2ZWwgKz0gUFJF VFRZSU5ERU5UX1ZBUjsKKworCWZvcmZvdXIobGNfY29sbmFtZSwgdGYtPmNvbG5hbWVzLAorCQkJ bGNfY29sdHlwZSwgdGYtPmNvbHR5cGVzLAorCQkJbGNfY29sdHlwbW9kLCB0Zi0+Y29sdHlwbW9k cywKKwkJCWxjX2NvbHZhbGV4cHIsIHRmLT5jb2x2YWxleHBycykKKwl7CisJCWNoYXIJICAgKmNv bG5hbWUgPSBzdHJWYWwobGZpcnN0KGxjX2NvbG5hbWUpKTsKKwkJSnNvbkV4cHIgICAqY29sZXhw cjsKKwkJT2lkCQkJdHlwaWQ7CisJCWludDMyCQl0eXBtb2Q7CisJCWJvb2wJCW9yZGluYWxpdHk7 CisJCUpzb25CZWhhdmlvclR5cGUgZGVmYXVsdF9iZWhhdmlvcjsKKworCQl0eXBpZCA9IGxmaXJz dF9vaWQobGNfY29sdHlwZSk7CisJCXR5cG1vZCA9IGxmaXJzdF9pbnQobGNfY29sdHlwbW9kKTsK KwkJY29sZXhwciA9IGNhc3ROb2RlKEpzb25FeHByLCBsZmlyc3QobGNfY29sdmFsZXhwcikpOwor CisJCWlmIChjb2xudW0gPCBwbGFuLT5jb2xNaW4pCisJCXsKKwkJCWNvbG51bSsrOworCQkJY29u dGludWU7CisJCX0KKworCQlpZiAoY29sbnVtID4gcGxhbi0+Y29sTWF4KQorCQkJYnJlYWs7CisK KwkJaWYgKGNvbG51bSA+IHBsYW4tPmNvbE1pbikKKwkJCWFwcGVuZFN0cmluZ0luZm9TdHJpbmco YnVmLCAiLCAiKTsKKworCQljb2xudW0rKzsKKworCQlvcmRpbmFsaXR5ID0gIWNvbGV4cHI7CisK KwkJYXBwZW5kQ29udGV4dEtleXdvcmQoY29udGV4dCwgIiIsIDAsIDAsIDApOworCisJCWFwcGVu ZFN0cmluZ0luZm8oYnVmLCAiJXMgJXMiLCBxdW90ZV9pZGVudGlmaWVyKGNvbG5hbWUpLAorCQkJ CQkJIG9yZGluYWxpdHkgPyAiRk9SIE9SRElOQUxJVFkiIDoKKwkJCQkJCSBmb3JtYXRfdHlwZV93 aXRoX3R5cGVtb2QodHlwaWQsIHR5cG1vZCkpOworCQlpZiAob3JkaW5hbGl0eSkKKwkJCWNvbnRp bnVlOworCisJCWlmIChjb2xleHByLT5vcCA9PSBKU09OX0VYSVNUU19PUCkKKwkJeworCQkJYXBw ZW5kU3RyaW5nSW5mb1N0cmluZyhidWYsICIgRVhJU1RTIik7CisJCQlkZWZhdWx0X2JlaGF2aW9y ID0gSlNPTl9CRUhBVklPUl9GQUxTRTsKKwkJfQorCQllbHNlCisJCXsKKwkJCWlmIChjb2xleHBy LT5vcCA9PSBKU09OX1FVRVJZX09QKQorCQkJeworCQkJCWNoYXIJCXR5cGNhdGVnb3J5OworCQkJ CWJvb2wJCXR5cGlzcHJlZmVycmVkOworCisJCQkJZ2V0X3R5cGVfY2F0ZWdvcnlfcHJlZmVycmVk KHR5cGlkLCAmdHlwY2F0ZWdvcnksICZ0eXBpc3ByZWZlcnJlZCk7CisKKwkJCQlpZiAodHlwY2F0 ZWdvcnkgPT0gVFlQQ0FURUdPUllfU1RSSU5HKQorCQkJCQlhcHBlbmRTdHJpbmdJbmZvU3RyaW5n KGJ1ZiwKKwkJCQkJCQkJCQkgICBjb2xleHByLT5mb3JtYXQtPmZvcm1hdF90eXBlID09IEpTX0ZP Uk1BVF9KU09OQiA/CisJCQkJCQkJCQkJICAgIiBGT1JNQVQgSlNPTkIiIDogIiBGT1JNQVQgSlNP TiIpOworCQkJfQorCisJCQlkZWZhdWx0X2JlaGF2aW9yID0gSlNPTl9CRUhBVklPUl9OVUxMOwor CQl9CisKKwkJaWYgKGpleHByLT5vbl9lcnJvci0+YnR5cGUgPT0gSlNPTl9CRUhBVklPUl9FUlJP UikKKwkJCWRlZmF1bHRfYmVoYXZpb3IgPSBKU09OX0JFSEFWSU9SX0VSUk9SOworCisJCWFwcGVu ZFN0cmluZ0luZm9TdHJpbmcoYnVmLCAiIFBBVEggIik7CisKKwkJZ2V0X2pzb25fcGF0aF9zcGVj KGNvbGV4cHItPnBhdGhfc3BlYywgY29udGV4dCwgc2hvd2ltcGxpY2l0KTsKKworCQlnZXRfanNv bl9leHByX29wdGlvbnMoY29sZXhwciwgY29udGV4dCwgZGVmYXVsdF9iZWhhdmlvcik7CisJfQor CisJaWYgKHBsYW4tPmNoaWxkKQorCQlnZXRfanNvbl90YWJsZV9uZXN0ZWRfY29sdW1ucyh0Ziwg cGxhbi0+Y2hpbGQsIGNvbnRleHQsIHNob3dpbXBsaWNpdCwKKwkJCQkJCQkJCSAgcGxhbi0+Y29s TWF4ID49IHBsYW4tPmNvbE1pbik7CisKKwlpZiAoUFJFVFRZX0lOREVOVChjb250ZXh0KSkKKwkJ Y29udGV4dC0+aW5kZW50TGV2ZWwgLT0gUFJFVFRZSU5ERU5UX1ZBUjsKKworCWFwcGVuZENvbnRl eHRLZXl3b3JkKGNvbnRleHQsICIpIiwgMCwgMCwgMCk7Cit9CisKKy8qIC0tLS0tLS0tLS0KKyAq IGdldF9qc29uX3RhYmxlCQkJLSBQYXJzZSBiYWNrIGEgSlNPTl9UQUJMRSBmdW5jdGlvbgorICog LS0tLS0tLS0tLQorICovCitzdGF0aWMgdm9pZAorZ2V0X2pzb25fdGFibGUoVGFibGVGdW5jICp0 ZiwgZGVwYXJzZV9jb250ZXh0ICpjb250ZXh0LCBib29sIHNob3dpbXBsaWNpdCkKK3sKKwlTdHJp bmdJbmZvCWJ1ZiA9IGNvbnRleHQtPmJ1ZjsKKwlKc29uRXhwciAgICpqZXhwciA9IGNhc3ROb2Rl KEpzb25FeHByLCB0Zi0+ZG9jZXhwcik7CisJSnNvblRhYmxlUGxhbiAqcm9vdCA9IGNhc3ROb2Rl KEpzb25UYWJsZVBsYW4sIHRmLT5wbGFuKTsKKworCWFwcGVuZFN0cmluZ0luZm9TdHJpbmcoYnVm LCAiSlNPTl9UQUJMRSgiKTsKKworCWlmIChQUkVUVFlfSU5ERU5UKGNvbnRleHQpKQorCQljb250 ZXh0LT5pbmRlbnRMZXZlbCArPSBQUkVUVFlJTkRFTlRfVkFSOworCisJYXBwZW5kQ29udGV4dEtl eXdvcmQoY29udGV4dCwgIiIsIDAsIDAsIDApOworCisJZ2V0X3J1bGVfZXhwcihqZXhwci0+Zm9y bWF0dGVkX2V4cHIsIGNvbnRleHQsIHNob3dpbXBsaWNpdCk7CisKKwlhcHBlbmRTdHJpbmdJbmZv U3RyaW5nKGJ1ZiwgIiwgIik7CisKKwlnZXRfY29uc3RfZXhwcihyb290LT5wYXRoLT52YWx1ZSwg Y29udGV4dCwgLTEpOworCisJYXBwZW5kU3RyaW5nSW5mbyhidWYsICIgQVMgJXMiLCBxdW90ZV9p ZGVudGlmaWVyKHJvb3QtPnBhdGgtPm5hbWUpKTsKKworCWlmIChqZXhwci0+cGFzc2luZ192YWx1 ZXMpCisJeworCQlMaXN0Q2VsbCAgICpsYzEsCisJCQkJICAgKmxjMjsKKwkJYm9vbAkJbmVlZGNv bW1hID0gZmFsc2U7CisKKwkJYXBwZW5kU3RyaW5nSW5mb0NoYXIoYnVmLCAnICcpOworCQlhcHBl bmRDb250ZXh0S2V5d29yZChjb250ZXh0LCAiUEFTU0lORyAiLCAwLCAwLCAwKTsKKworCQlpZiAo UFJFVFRZX0lOREVOVChjb250ZXh0KSkKKwkJCWNvbnRleHQtPmluZGVudExldmVsICs9IFBSRVRU WUlOREVOVF9WQVI7CisKKwkJZm9yYm90aChsYzEsIGpleHByLT5wYXNzaW5nX25hbWVzLAorCQkJ CWxjMiwgamV4cHItPnBhc3NpbmdfdmFsdWVzKQorCQl7CisJCQlpZiAobmVlZGNvbW1hKQorCQkJ CWFwcGVuZFN0cmluZ0luZm9TdHJpbmcoYnVmLCAiLCAiKTsKKwkJCW5lZWRjb21tYSA9IHRydWU7 CisKKwkJCWFwcGVuZENvbnRleHRLZXl3b3JkKGNvbnRleHQsICIiLCAwLCAwLCAwKTsKKworCQkJ Z2V0X3J1bGVfZXhwcigoTm9kZSAqKSBsZmlyc3QobGMyKSwgY29udGV4dCwgZmFsc2UpOworCQkJ YXBwZW5kU3RyaW5nSW5mbyhidWYsICIgQVMgJXMiLAorCQkJCQkJCSBxdW90ZV9pZGVudGlmaWVy KChsZmlyc3Rfbm9kZShTdHJpbmcsIGxjMSkpLT5zdmFsKQorCQkJCSk7CisJCX0KKworCQlpZiAo UFJFVFRZX0lOREVOVChjb250ZXh0KSkKKwkJCWNvbnRleHQtPmluZGVudExldmVsIC09IFBSRVRU WUlOREVOVF9WQVI7CisJfQorCisJZ2V0X2pzb25fdGFibGVfY29sdW1ucyh0Ziwgcm9vdCwgY29u dGV4dCwgc2hvd2ltcGxpY2l0KTsKKworCWFwcGVuZFN0cmluZ0luZm9DaGFyKGJ1ZiwgJyAnKTsK KwlhcHBlbmRDb250ZXh0S2V5d29yZChjb250ZXh0LCAiUExBTiAiLCAwLCAwLCAwKTsKKwlnZXRf anNvbl90YWJsZV9wbGFuKHRmLCAoTm9kZSAqKSByb290LCBjb250ZXh0LCB0cnVlKTsKKworCWlm IChqZXhwci0+b25fZXJyb3ItPmJ0eXBlICE9IEpTT05fQkVIQVZJT1JfRU1QVFkpCisJCWdldF9q c29uX2JlaGF2aW9yKGpleHByLT5vbl9lcnJvciwgY29udGV4dCwgIkVSUk9SIik7CisKKwlpZiAo UFJFVFRZX0lOREVOVChjb250ZXh0KSkKKwkJY29udGV4dC0+aW5kZW50TGV2ZWwgLT0gUFJFVFRZ SU5ERU5UX1ZBUjsKKworCWFwcGVuZENvbnRleHRLZXl3b3JkKGNvbnRleHQsICIpIiwgMCwgMCwg MCk7Cit9CisKKy8qIC0tLS0tLS0tLS0KKyAqIGdldF90YWJsZWZ1bmMJCQktIFBhcnNlIGJhY2sg YSB0YWJsZSBmdW5jdGlvbgorICogLS0tLS0tLS0tLQorICovCitzdGF0aWMgdm9pZAorZ2V0X3Rh YmxlZnVuYyhUYWJsZUZ1bmMgKnRmLCBkZXBhcnNlX2NvbnRleHQgKmNvbnRleHQsIGJvb2wgc2hv d2ltcGxpY2l0KQoreworCS8qIFhNTFRBQkxFIGFuZCBKU09OX1RBQkxFIGFyZSB0aGUgb25seSBl eGlzdGluZyBpbXBsZW1lbnRhdGlvbnMuICAqLworCisJaWYgKHRmLT5mdW5jdHlwZSA9PSBURlRf WE1MVEFCTEUpCisJCWdldF94bWx0YWJsZSh0ZiwgY29udGV4dCwgc2hvd2ltcGxpY2l0KTsKKwll bHNlIGlmICh0Zi0+ZnVuY3R5cGUgPT0gVEZUX0pTT05fVEFCTEUpCisJCWdldF9qc29uX3RhYmxl KHRmLCBjb250ZXh0LCBzaG93aW1wbGljaXQpOworfQorCiAvKiAtLS0tLS0tLS0tCiAgKiBnZXRf ZnJvbV9jbGF1c2UJCQktIFBhcnNlIGJhY2sgYSBGUk9NIGNsYXVzZQogICoKZGlmZiAtLWdpdCBh L3NyYy9pbmNsdWRlL25vZGVzL2V4ZWNub2Rlcy5oIGIvc3JjL2luY2x1ZGUvbm9kZXMvZXhlY25v ZGVzLmgKaW5kZXggMmU4ZGYyMzAxZi4uZmJiYTc5Zjk0ZSAxMDA2NDQKLS0tIGEvc3JjL2luY2x1 ZGUvbm9kZXMvZXhlY25vZGVzLmgKKysrIGIvc3JjL2luY2x1ZGUvbm9kZXMvZXhlY25vZGVzLmgK QEAgLTE5NjgsNiArMTk2OCw4IEBAIHR5cGVkZWYgc3RydWN0IFRhYmxlRnVuY1NjYW5TdGF0ZQog CUV4cHJTdGF0ZSAgKnJvd2V4cHI7CQkvKiBzdGF0ZSBmb3Igcm93LWdlbmVyYXRpbmcgZXhwcmVz c2lvbiAqLwogCUxpc3QJICAgKmNvbGV4cHJzOwkJLyogc3RhdGUgZm9yIGNvbHVtbi1nZW5lcmF0 aW5nIGV4cHJlc3Npb24gKi8KIAlMaXN0CSAgICpjb2xkZWZleHByczsJLyogc3RhdGUgZm9yIGNv bHVtbiBkZWZhdWx0IGV4cHJlc3Npb25zICovCisJTGlzdAkgICAqY29sdmFsZXhwcnM7CS8qIHN0 YXRlIGZvciBjb2x1bW4gdmFsdWUgZXhwcmVzc2lvbiAqLworCUxpc3QJICAgKnBhc3Npbmd2YWxl eHByczsJLyogc3RhdGUgZm9yIFBBU1NJTkcgYXJndW1lbnQgZXhwcmVzc2lvbiAqLwogCUxpc3QJ ICAgKm5zX25hbWVzOwkJLyogc2FtZSBhcyBUYWJsZUZ1bmMubnNfbmFtZXMgKi8KIAlMaXN0CSAg ICpuc191cmlzOwkJLyogbGlzdCBvZiBzdGF0ZXMgb2YgbmFtZXNwYWNlIFVSSSBleHBycyAqLwog CUJpdG1hcHNldCAgKm5vdG51bGxzOwkJLyogbnVsbGFiaWxpdHkgZmxhZyBmb3IgZWFjaCBvdXRw dXQgY29sdW1uICovCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9ub2Rlcy9tYWtlZnVuY3MuaCBi L3NyYy9pbmNsdWRlL25vZGVzL21ha2VmdW5jcy5oCmluZGV4IGE5NmZkNjJkN2YuLjY3YTZiN2Zj ODYgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL25vZGVzL21ha2VmdW5jcy5oCisrKyBiL3NyYy9p bmNsdWRlL25vZGVzL21ha2VmdW5jcy5oCkBAIC0xMDAsNiArMTAwLDcgQEAgZXh0ZXJuIEluZGV4 SW5mbyAqbWFrZUluZGV4SW5mbyhpbnQgbnVtYXR0cnMsIGludCBudW1rZXlhdHRycywgT2lkIGFt b2lkLAogCQkJCQkJCQlib29sIGlzcmVhZHksIGJvb2wgY29uY3VycmVudCwKIAkJCQkJCQkJYm9v bCBzdW1tYXJpemluZyk7CiAKK2V4dGVybiBOb2RlICptYWtlU3RyaW5nQ29uc3QoY2hhciAqc3Ry LCBpbnQgbG9jYXRpb24pOwogZXh0ZXJuIERlZkVsZW0gKm1ha2VEZWZFbGVtKGNoYXIgKm5hbWUs IE5vZGUgKmFyZywgaW50IGxvY2F0aW9uKTsKIGV4dGVybiBEZWZFbGVtICptYWtlRGVmRWxlbUV4 dGVuZGVkKGNoYXIgKm5hbWVTcGFjZSwgY2hhciAqbmFtZSwgTm9kZSAqYXJnLAogCQkJCQkJCQkJ RGVmRWxlbUFjdGlvbiBkZWZhY3Rpb24sIGludCBsb2NhdGlvbik7CkBAIC0xMTQsNiArMTE1LDEy IEBAIGV4dGVybiBKc29uVmFsdWVFeHByICptYWtlSnNvblZhbHVlRXhwcihFeHByICpyYXdfZXhw ciwgRXhwciAqZm9ybWF0dGVkX2V4cHIsCiAJCQkJCQkJCQkJSnNvbkZvcm1hdCAqZm9ybWF0KTsK IGV4dGVybiBKc29uQmVoYXZpb3IgKm1ha2VKc29uQmVoYXZpb3IoSnNvbkJlaGF2aW9yVHlwZSB0 eXBlLCBOb2RlICpleHByLAogCQkJCSBKc29uQ29lcmNpb24gKmNvZXJjaW9uLCBpbnQgbG9jYXRp b24pOworZXh0ZXJuIEpzb25UYWJsZVBhdGggKm1ha2VKc29uVGFibGVQYXRoKENvbnN0ICpwYXRo dmFsdWUsIGNoYXIgKnBhdGhuYW1lKTsKK2V4dGVybiBKc29uVGFibGVQYXRoU3BlYyAqbWFrZUpz b25UYWJsZVBhdGhTcGVjKGNoYXIgKnN0cmluZywgY2hhciAqbmFtZSwKKwkJCQkJCQkJCQkJCWlu dCBzdHJpbmdfbG9jYXRpb24sCisJCQkJCQkJCQkJCQlpbnQgbmFtZV9sb2NhdGlvbik7CitleHRl cm4gTm9kZSAqbWFrZUpzb25UYWJsZUpvaW5lZFBsYW4oSnNvblRhYmxlUGxhbkpvaW5UeXBlIHR5 cGUsCisJCQkJCQkJCQkgTm9kZSAqcGxhbjEsIE5vZGUgKnBsYW4yLCBpbnQgbG9jYXRpb24pOwog ZXh0ZXJuIE5vZGUgKm1ha2VKc29uS2V5VmFsdWUoTm9kZSAqa2V5LCBOb2RlICp2YWx1ZSk7CiBl eHRlcm4gTm9kZSAqbWFrZUpzb25Jc1ByZWRpY2F0ZShOb2RlICpleHByLCBKc29uRm9ybWF0ICpm b3JtYXQsCiAJCQkJCQkJCSBKc29uVmFsdWVUeXBlIGl0ZW1fdHlwZSwgYm9vbCB1bmlxdWVfa2V5 cywKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL25vZGVzL3BhcnNlbm9kZXMuaCBiL3NyYy9pbmNs dWRlL25vZGVzL3BhcnNlbm9kZXMuaAppbmRleCAwMTg0Yzc2Y2U2Li4xZWY2YzhjYTRmIDEwMDY0 NAotLS0gYS9zcmMvaW5jbHVkZS9ub2Rlcy9wYXJzZW5vZGVzLmgKKysrIGIvc3JjL2luY2x1ZGUv bm9kZXMvcGFyc2Vub2Rlcy5oCkBAIC0xNzQxLDYgKzE3NDEsNyBAQCB0eXBlZGVmIHN0cnVjdCBK c29uRnVuY0V4cHIKIAlKc29uRXhwck9wCW9wOwkJCQkvKiBleHByZXNzaW9uIHR5cGUgKi8KIAlK c29uVmFsdWVFeHByICpjb250ZXh0X2l0ZW07CS8qIGNvbnRleHQgaXRlbSBleHByZXNzaW9uICov CiAJTm9kZQkgICAqcGF0aHNwZWM7CQkvKiBKU09OIHBhdGggc3BlY2lmaWNhdGlvbiBleHByZXNz aW9uICovCisJY2hhcgkgICAqcGF0aG5hbWU7CQkvKiBwYXRoIG5hbWUsIGlmIGFueSAqLwogCUxp c3QJICAgKnBhc3Npbmc7CQkvKiBsaXN0IG9mIFBBU1NJTkcgY2xhdXNlIGFyZ3VtZW50cywgaWYg YW55ICovCiAJSnNvbk91dHB1dCAqb3V0cHV0OwkJCS8qIG91dHB1dCBjbGF1c2UsIGlmIHNwZWNp ZmllZCAqLwogCUpzb25CZWhhdmlvciAqb25fZW1wdHk7CQkvKiBPTiBFTVBUWSBiZWhhdmlvciAq LwpAQCAtMTc1MCw2ICsxNzUxLDExMSBAQCB0eXBlZGVmIHN0cnVjdCBKc29uRnVuY0V4cHIKIAlp bnQJCQlsb2NhdGlvbjsJCS8qIHRva2VuIGxvY2F0aW9uLCBvciAtMSBpZiB1bmtub3duICovCiB9 IEpzb25GdW5jRXhwcjsKIAorLyoKKyAqIEpzb25UYWJsZVBhdGhTcGVjCisgKgkJdW50cmFuc2Zv cm1lZCBzcGVjaWZpY2F0aW9uIG9mIEpTT04gcGF0aCBleHByZXNzaW9uIHdpdGggYW4gb3B0aW9u YWwKKyAqCQluYW1lCisgKi8KK3R5cGVkZWYgc3RydWN0IEpzb25UYWJsZVBhdGhTcGVjCit7CisJ Tm9kZVRhZwkJdHlwZTsKKworCU5vZGUJICAgKnN0cmluZzsKKwljaGFyCSAgICpuYW1lOworCWlu dAkJCW5hbWVfbG9jYXRpb247CisJaW50CQkJbG9jYXRpb247CS8qIGxvY2F0aW9uIG9mICdzdHJp bmcnICovCit9IEpzb25UYWJsZVBhdGhTcGVjOworCisvKgorICogSnNvblRhYmxlQ29sdW1uVHlw ZSAtCisgKgkJZW51bWVyYXRpb24gb2YgSlNPTl9UQUJMRSBjb2x1bW4gdHlwZXMKKyAqLwordHlw ZWRlZiBlbnVtIEpzb25UYWJsZUNvbHVtblR5cGUKK3sKKwlKVENfRk9SX09SRElOQUxJVFksCisJ SlRDX1JFR1VMQVIsCisJSlRDX0VYSVNUUywKKwlKVENfRk9STUFUVEVELAorCUpUQ19ORVNURUQs Cit9IEpzb25UYWJsZUNvbHVtblR5cGU7CisKKy8qCisgKiBKc29uVGFibGVDb2x1bW4gLQorICoJ CXVudHJhbnNmb3JtZWQgcmVwcmVzZW50YXRpb24gb2YgSlNPTl9UQUJMRSBjb2x1bW4KKyAqLwor dHlwZWRlZiBzdHJ1Y3QgSnNvblRhYmxlQ29sdW1uCit7CisJTm9kZVRhZwkJdHlwZTsKKwlKc29u VGFibGVDb2x1bW5UeXBlIGNvbHR5cGU7CS8qIGNvbHVtbiB0eXBlICovCisJY2hhcgkgICAqbmFt ZTsJCQkvKiBjb2x1bW4gbmFtZSAqLworCVR5cGVOYW1lICAgKnR5cGVOYW1lOwkJLyogY29sdW1u IHR5cGUgbmFtZSAqLworCUpzb25UYWJsZVBhdGhTcGVjICpwYXRoc3BlYzsgLyogSlNPTiBwYXRo IHNwZWNpZmljYXRpb24gKi8KKwlKc29uRm9ybWF0ICpmb3JtYXQ7CQkJLyogSlNPTiBmb3JtYXQg Y2xhdXNlLCBpZiBzcGVjaWZpZWQgKi8KKwlKc29uV3JhcHBlciB3cmFwcGVyOwkJLyogV1JBUFBF UiBiZWhhdmlvciBmb3IgZm9ybWF0dGVkIGNvbHVtbnMgKi8KKwlKc29uUXVvdGVzCXF1b3RlczsJ CQkvKiBvbWl0IG9yIGtlZXAgcXVvdGVzIG9uIHNjYWxhciBzdHJpbmdzPyAqLworCUxpc3QJICAg KmNvbHVtbnM7CQkvKiBuZXN0ZWQgY29sdW1ucyAqLworCUpzb25CZWhhdmlvciAqb25fZW1wdHk7 CQkvKiBPTiBFTVBUWSBiZWhhdmlvciAqLworCUpzb25CZWhhdmlvciAqb25fZXJyb3I7CQkvKiBP TiBFUlJPUiBiZWhhdmlvciAqLworCWludAkJCWxvY2F0aW9uOwkJLyogdG9rZW4gbG9jYXRpb24s IG9yIC0xIGlmIHVua25vd24gKi8KK30gSnNvblRhYmxlQ29sdW1uOworCisvKgorICogSnNvblRh YmxlUGxhblR5cGUgLQorICoJCWZsYWdzIGZvciBKU09OX1RBQkxFIHBsYW4gbm9kZSB0eXBlcyBy ZXByZXNlbnRhdGlvbgorICovCit0eXBlZGVmIGVudW0gSnNvblRhYmxlUGxhblR5cGUKK3sKKwlK U1RQX0RFRkFVTFQsCisJSlNUUF9TSU1QTEUsCisJSlNUUF9KT0lORUQsCit9IEpzb25UYWJsZVBs YW5UeXBlOworCisvKgorICogSnNvblRhYmxlUGxhbkpvaW5UeXBlIC0KKyAqCQlmbGFncyBmb3Ig SlNPTl9UQUJMRSBqb2luIHR5cGVzIHJlcHJlc2VudGF0aW9uCisgKi8KK3R5cGVkZWYgZW51bSBK c29uVGFibGVQbGFuSm9pblR5cGUKK3sKKwlKU1RQSl9JTk5FUiwKKwlKU1RQSl9PVVRFUiwKKwlK U1RQSl9DUk9TUywKKwlKU1RQSl9VTklPTiwKK30gSnNvblRhYmxlUGxhbkpvaW5UeXBlOworCisv KgorICogSnNvblRhYmxlUGxhblNwZWMgLQorICoJCXVudHJhbnNmb3JtZWQgcmVwcmVzZW50YXRp b24gb2YgSlNPTl9UQUJMRSdzIFBMQU4gY2xhdXNlCisgKi8KK3R5cGVkZWYgc3RydWN0IEpzb25U YWJsZVBsYW5TcGVjCit7CisJTm9kZVRhZwkJdHlwZTsKKworCUpzb25UYWJsZVBsYW5UeXBlIHBs YW5fdHlwZTsJLyogcGxhbiB0eXBlICovCisJSnNvblRhYmxlUGxhbkpvaW5UeXBlIGpvaW5fdHlw ZTsJLyogam9pbiB0eXBlIChmb3Igam9pbmVkIHBsYW4gb25seSkgKi8KKwlzdHJ1Y3QgSnNvblRh YmxlUGxhblNwZWMgKnBsYW4xOwkJLyogZmlyc3Qgam9pbmVkIHBsYW4gKi8KKwlzdHJ1Y3QgSnNv blRhYmxlUGxhblNwZWMgKnBsYW4yOwkJLyogc2Vjb25kIGpvaW5lZCBwbGFuICovCisJY2hhcgkg ICAqcGF0aG5hbWU7CQkvKiBwYXRoIG5hbWUgKGZvciBzaW1wbGUgcGxhbiBvbmx5KSAqLworCWlu dAkJCWxvY2F0aW9uOwkJLyogdG9rZW4gbG9jYXRpb24sIG9yIC0xIGlmIHVua25vd24gKi8KK30g SnNvblRhYmxlUGxhblNwZWM7CisKKy8qCisgKiBKc29uVGFibGUgLQorICoJCXVudHJhbnNmb3Jt ZWQgcmVwcmVzZW50YXRpb24gb2YgSlNPTl9UQUJMRQorICovCit0eXBlZGVmIHN0cnVjdCBKc29u VGFibGUKK3sKKwlOb2RlVGFnCQl0eXBlOworCUpzb25WYWx1ZUV4cHIgKmNvbnRleHRfaXRlbTsJ LyogY29udGV4dCBpdGVtIGV4cHJlc3Npb24gKi8KKwlKc29uVGFibGVQYXRoU3BlYyAqcGF0aHNw ZWM7CS8qIEpTT04gcGF0aCBzcGVjaWZpY2F0aW9uICovCisJTGlzdAkgICAqcGFzc2luZzsJCS8q IGxpc3Qgb2YgUEFTU0lORyBjbGF1c2UgYXJndW1lbnRzLCBpZiBhbnkgKi8KKwlMaXN0CSAgICpj b2x1bW5zOwkJLyogbGlzdCBvZiBKc29uVGFibGVDb2x1bW4gKi8KKwlKc29uVGFibGVQbGFuU3Bl YyAqcGxhbnNwZWM7IC8qIGpvaW4gcGxhbiwgaWYgc3BlY2lmaWVkICovCisJSnNvbkJlaGF2aW9y ICAqb25fZXJyb3I7CS8qIE9OIEVSUk9SIGJlaGF2aW9yICovCisJQWxpYXMJICAgKmFsaWFzOwkJ CS8qIHRhYmxlIGFsaWFzIGluIEZST00gY2xhdXNlICovCisJYm9vbAkJbGF0ZXJhbDsJCS8qIGRv ZXMgaXQgaGF2ZSBMQVRFUkFMIHByZWZpeD8gKi8KKwlpbnQJCQlsb2NhdGlvbjsJCS8qIHRva2Vu IGxvY2F0aW9uLCBvciAtMSBpZiB1bmtub3duICovCit9IEpzb25UYWJsZTsKKwogLyoKICAqIEpz b25LZXlWYWx1ZSAtCiAgKgkJdW50cmFuc2Zvcm1lZCByZXByZXNlbnRhdGlvbiBvZiBKU09OIG9i amVjdCBrZXktdmFsdWUgcGFpciBmb3IKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL25vZGVzL3By aW1ub2Rlcy5oIGIvc3JjL2luY2x1ZGUvbm9kZXMvcHJpbW5vZGVzLmgKaW5kZXggZmU5ZGZiYjAy YS4uZDdjZmUzNGI4ZSAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvbm9kZXMvcHJpbW5vZGVzLmgK KysrIGIvc3JjL2luY2x1ZGUvbm9kZXMvcHJpbW5vZGVzLmgKQEAgLTk0LDggKzk0LDE0IEBAIHR5 cGVkZWYgc3RydWN0IFJhbmdlVmFyCiAJaW50CQkJbG9jYXRpb247CiB9IFJhbmdlVmFyOwogCit0 eXBlZGVmIGVudW0gVGFibGVGdW5jVHlwZQoreworCVRGVF9YTUxUQUJMRSwKKwlURlRfSlNPTl9U QUJMRSwKK30gVGFibGVGdW5jVHlwZTsKKwogLyoKLSAqIFRhYmxlRnVuYyAtIG5vZGUgZm9yIGEg dGFibGUgZnVuY3Rpb24sIHN1Y2ggYXMgWE1MVEFCTEUuCisgKiBUYWJsZUZ1bmMgLSBub2RlIGZv ciBhIHRhYmxlIGZ1bmN0aW9uLCBzdWNoIGFzIFhNTFRBQkxFIG9yIEpTT05fVEFCTEUuCiAgKgog ICogRW50cmllcyBpbiB0aGUgbnNfbmFtZXMgbGlzdCBhcmUgZWl0aGVyIFN0cmluZyBub2RlcyBj b250YWluaW5nCiAgKiBsaXRlcmFsIG5hbWVzcGFjZSBuYW1lcywgb3IgTlVMTCBwb2ludGVycyB0 byByZXByZXNlbnQgREVGQVVMVC4KQEAgLTEwMyw2ICsxMDksOCBAQCB0eXBlZGVmIHN0cnVjdCBS YW5nZVZhcgogdHlwZWRlZiBzdHJ1Y3QgVGFibGVGdW5jCiB7CiAJTm9kZVRhZwkJdHlwZTsKKwkv KiBYTUxUQUJMRSBvciBKU09OX1RBQkxFICovCisJVGFibGVGdW5jVHlwZSBmdW5jdHlwZTsKIAkv KiBsaXN0IG9mIG5hbWVzcGFjZSBVUkkgZXhwcmVzc2lvbnMgKi8KIAlMaXN0CSAgICpuc191cmlz IHBnX25vZGVfYXR0cihxdWVyeV9qdW1ibGVfaWdub3JlKTsKIAkvKiBsaXN0IG9mIG5hbWVzcGFj ZSBuYW1lcyBvciBOVUxMICovCkBAIC0xMjMsOCArMTMxLDE0IEBAIHR5cGVkZWYgc3RydWN0IFRh YmxlRnVuYwogCUxpc3QJICAgKmNvbGV4cHJzOwogCS8qIGxpc3Qgb2YgY29sdW1uIGRlZmF1bHQg ZXhwcmVzc2lvbnMgKi8KIAlMaXN0CSAgICpjb2xkZWZleHBycyBwZ19ub2RlX2F0dHIocXVlcnlf anVtYmxlX2lnbm9yZSk7CisJLyogbGlzdCBvZiBjb2x1bW4gdmFsdWUgZXhwcmVzc2lvbnMgKi8K KwlMaXN0CSAgICpjb2x2YWxleHBycyBwZ19ub2RlX2F0dHIocXVlcnlfanVtYmxlX2lnbm9yZSk7 CisJLyogbGlzdCBvZiBQQVNTSU5HIGFyZ3VtZW50IGV4cHJlc3Npb25zICovCisJTGlzdAkgICAq cGFzc2luZ3ZhbGV4cHJzIHBnX25vZGVfYXR0cihxdWVyeV9qdW1ibGVfaWdub3JlKTsKIAkvKiBu dWxsYWJpbGl0eSBmbGFnIGZvciBlYWNoIG91dHB1dCBjb2x1bW4gKi8KIAlCaXRtYXBzZXQgICpu b3RudWxscyBwZ19ub2RlX2F0dHIocXVlcnlfanVtYmxlX2lnbm9yZSk7CisJLyogSlNPTl9UQUJM RSBwbGFuICovCisJTm9kZQkgICAqcGxhbiBwZ19ub2RlX2F0dHIocXVlcnlfanVtYmxlX2lnbm9y ZSk7CiAJLyogY291bnRzIGZyb20gMDsgLTEgaWYgbm9uZSBzcGVjaWZpZWQgKi8KIAlpbnQJCQlv cmRpbmFsaXR5Y29sIHBnX25vZGVfYXR0cihxdWVyeV9qdW1ibGVfaWdub3JlKTsKIAkvKiB0b2tl biBsb2NhdGlvbiwgb3IgLTEgaWYgdW5rbm93biAqLwpAQCAtMTU2MSw2ICsxNTc1LDcgQEAgdHlw ZWRlZiBlbnVtIEpzb25FeHByT3AKIAlKU09OX1ZBTFVFX09QLAkJCQkvKiBKU09OX1ZBTFVFKCkg Ki8KIAlKU09OX1FVRVJZX09QLAkJCQkvKiBKU09OX1FVRVJZKCkgKi8KIAlKU09OX0VYSVNUU19P UCwJCQkJLyogSlNPTl9FWElTVFMoKSAqLworCUpTT05fVEFCTEVfT1AsCQkJCS8qIEpTT05fVEFC TEUoKSAqLwogfSBKc29uRXhwck9wOwogCiAvKgpAQCAtMTg0NSw2ICsxODYwLDQ5IEBAIHR5cGVk ZWYgc3RydWN0IEpzb25FeHByCiAJaW50CQkJbG9jYXRpb247CiB9IEpzb25FeHByOwogCisvKgor ICogSnNvblRhYmxlUGF0aAorICoJCUEgSlNPTiBwYXRoIGV4cHJlc3Npb24gdG8gYmUgY29tcHV0 ZWQgYXMgcGFydCBvZiBldmFsdWF0aW5nCisgKgkJYSBKU09OX1RBQkxFIHBsYW4gbm9kZQorICov Cit0eXBlZGVmIHN0cnVjdCBKc29uVGFibGVQYXRoCit7CisJTm9kZVRhZwkJdHlwZTsKKworCUNv bnN0CSAgICp2YWx1ZTsKKwljaGFyCSAgICpuYW1lOworfQkJCUpzb25UYWJsZVBhdGg7CisKKy8q CisgKiBKc29uVGFibGVTcGVjIC0KKyAqCQl0cmFuc2Zvcm1lZCByZXByZXNlbnRhdGlvbiBvZiBh IEpTT05fVEFCTEUgcGxhbgorICovCit0eXBlZGVmIHN0cnVjdCBKc29uVGFibGVQbGFuCit7CisJ Tm9kZVRhZwkJdHlwZTsKKworCUpzb25UYWJsZVBhdGggKnBhdGg7CisJTm9kZQkgICAqY2hpbGQ7 CQkJLyogbmVzdGVkIGNvbHVtbnMsIGlmIGFueSAqLworCWJvb2wJCW91dGVySm9pbjsJCS8qIG91 dGVyIG9yIGlubmVyIGpvaW4gZm9yIG5lc3RlZCBjb2x1bW5zPyAqLworCWludAkJCWNvbE1pbjsJ CQkvKiBtaW4gY29sdW1uIGluZGV4IGluIHRoZSByZXN1bHRpbmcgY29sdW1uCisJCQkJCQkJCSAq IGxpc3QgKi8KKwlpbnQJCQljb2xNYXg7CQkJLyogbWF4IGNvbHVtbiBpbmRleCBpbiB0aGUgcmVz dWx0aW5nIGNvbHVtbgorCQkJCQkJCQkgKiBsaXN0ICovCisJYm9vbAkJZXJyb3JPbkVycm9yOwkv KiBFUlJPUi9FTVBUWSBPTiBFUlJPUiBiZWhhdmlvciAqLworfSBKc29uVGFibGVQbGFuOworCisv KgorICogSnNvblRhYmxlU2libGluZyAtCisgKgkJdHJhbnNmb3JtZWQgcmVwcmVzZW50YXRpb24g b2Ygam9pbmVkIHNpYmxpbmcgSlNPTl9UQUJMRSBwbGFuIG5vZGUKKyAqLwordHlwZWRlZiBzdHJ1 Y3QgSnNvblRhYmxlU2libGluZworeworCU5vZGVUYWcJCXR5cGU7CisJTm9kZQkgICAqbGFyZzsJ CQkvKiBsZWZ0IGpvaW4gbm9kZSAqLworCU5vZGUJICAgKnJhcmc7CQkJLyogcmlnaHQgam9pbiBu b2RlICovCisJYm9vbAkJY3Jvc3M7CQkJLyogY3Jvc3Mgb3IgdW5pb24gam9pbj8gKi8KK30gSnNv blRhYmxlU2libGluZzsKKwogLyogLS0tLS0tLS0tLS0tLS0tLQogICogTnVsbFRlc3QKICAqCmRp ZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9wYXJzZXIva3dsaXN0LmggYi9zcmMvaW5jbHVkZS9wYXJz ZXIva3dsaXN0LmgKaW5kZXggOTRlMWNiNGRjZS4uZTJiYmVlYjIwOSAxMDA2NDQKLS0tIGEvc3Jj L2luY2x1ZGUvcGFyc2VyL2t3bGlzdC5oCisrKyBiL3NyYy9pbmNsdWRlL3BhcnNlci9rd2xpc3Qu aApAQCAtMjQyLDYgKzI0Miw3IEBAIFBHX0tFWVdPUkQoImpzb25fb2JqZWN0YWdnIiwgSlNPTl9P QkpFQ1RBR0csIENPTF9OQU1FX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJqc29u X3F1ZXJ5IiwgSlNPTl9RVUVSWSwgQ09MX05BTUVfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tF WVdPUkQoImpzb25fc2NhbGFyIiwgSlNPTl9TQ0FMQVIsIENPTF9OQU1FX0tFWVdPUkQsIEJBUkVf TEFCRUwpCiBQR19LRVlXT1JEKCJqc29uX3NlcmlhbGl6ZSIsIEpTT05fU0VSSUFMSVpFLCBDT0xf TkFNRV9LRVlXT1JELCBCQVJFX0xBQkVMKQorUEdfS0VZV09SRCgianNvbl90YWJsZSIsIEpTT05f VEFCTEUsIENPTF9OQU1FX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJqc29uX3Zh bHVlIiwgSlNPTl9WQUxVRSwgQ09MX05BTUVfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdP UkQoImtlZXAiLCBLRUVQLCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlX T1JEKCJrZXkiLCBLRVksIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKQEAgLTI4NCw2 ICsyODUsNyBAQCBQR19LRVlXT1JEKCJuYW1lcyIsIE5BTUVTLCBVTlJFU0VSVkVEX0tFWVdPUkQs IEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJuYXRpb25hbCIsIE5BVElPTkFMLCBDT0xfTkFNRV9L RVlXT1JELCBCQVJFX0xBQkVMKQogUEdfS0VZV09SRCgibmF0dXJhbCIsIE5BVFVSQUwsIFRZUEVf RlVOQ19OQU1FX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJuY2hhciIsIE5DSEFS LCBDT0xfTkFNRV9LRVlXT1JELCBCQVJFX0xBQkVMKQorUEdfS0VZV09SRCgibmVzdGVkIiwgTkVT VEVELCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJuZXciLCBO RVcsIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdPUkQoIm5leHQiLCBO RVhULCBVTlJFU0VSVkVEX0tFWVdPUkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJuZmMiLCBO RkMsIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKQEAgLTMzNCw3ICszMzYsOSBAQCBQ R19LRVlXT1JEKCJwYXJ0aWFsIiwgUEFSVElBTCwgVU5SRVNFUlZFRF9LRVlXT1JELCBCQVJFX0xB QkVMKQogUEdfS0VZV09SRCgicGFydGl0aW9uIiwgUEFSVElUSU9OLCBVTlJFU0VSVkVEX0tFWVdP UkQsIEJBUkVfTEFCRUwpCiBQR19LRVlXT1JEKCJwYXNzaW5nIiwgUEFTU0lORywgVU5SRVNFUlZF RF9LRVlXT1JELCBCQVJFX0xBQkVMKQogUEdfS0VZV09SRCgicGFzc3dvcmQiLCBQQVNTV09SRCwg VU5SRVNFUlZFRF9LRVlXT1JELCBCQVJFX0xBQkVMKQorUEdfS0VZV09SRCgicGF0aCIsIFBBVEgs IFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdPUkQoInBsYWNpbmciLCBQ TEFDSU5HLCBSRVNFUlZFRF9LRVlXT1JELCBCQVJFX0xBQkVMKQorUEdfS0VZV09SRCgicGxhbiIs IFBMQU4sIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdPUkQoInBsYW5z IiwgUExBTlMsIFVOUkVTRVJWRURfS0VZV09SRCwgQkFSRV9MQUJFTCkKIFBHX0tFWVdPUkQoInBv bGljeSIsIFBPTElDWSwgVU5SRVNFUlZFRF9LRVlXT1JELCBCQVJFX0xBQkVMKQogUEdfS0VZV09S RCgicG9zaXRpb24iLCBQT1NJVElPTiwgQ09MX05BTUVfS0VZV09SRCwgQkFSRV9MQUJFTCkKZGlm ZiAtLWdpdCBhL3NyYy9pbmNsdWRlL3BhcnNlci9wYXJzZV9jbGF1c2UuaCBiL3NyYy9pbmNsdWRl L3BhcnNlci9wYXJzZV9jbGF1c2UuaAppbmRleCAzODI5ZGIwZmM0Li5lNzE3NjJiMTBjIDEwMDY0 NAotLS0gYS9zcmMvaW5jbHVkZS9wYXJzZXIvcGFyc2VfY2xhdXNlLmgKKysrIGIvc3JjL2luY2x1 ZGUvcGFyc2VyL3BhcnNlX2NsYXVzZS5oCkBAIC01MSw0ICs1MSw3IEBAIGV4dGVybiBMaXN0ICph ZGRUYXJnZXRUb1NvcnRMaXN0KFBhcnNlU3RhdGUgKnBzdGF0ZSwgVGFyZ2V0RW50cnkgKnRsZSwK IGV4dGVybiBJbmRleCBhc3NpZ25Tb3J0R3JvdXBSZWYoVGFyZ2V0RW50cnkgKnRsZSwgTGlzdCAq dGxpc3QpOwogZXh0ZXJuIGJvb2wgdGFyZ2V0SXNJblNvcnRMaXN0KFRhcmdldEVudHJ5ICp0bGUs IE9pZCBzb3J0b3AsIExpc3QgKnNvcnRMaXN0KTsKIAorLyogZnVuY3Rpb25zIGluIHBhcnNlX2pz b250YWJsZS5jICovCitleHRlcm4gUGFyc2VOYW1lc3BhY2VJdGVtICp0cmFuc2Zvcm1Kc29uVGFi bGUoUGFyc2VTdGF0ZSAqcHN0YXRlLCBKc29uVGFibGUgKmp0KTsKKwogI2VuZGlmCQkJCQkJCS8q IFBBUlNFX0NMQVVTRV9IICovCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS91dGlscy9qc29ucGF0 aC5oIGIvc3JjL2luY2x1ZGUvdXRpbHMvanNvbnBhdGguaAppbmRleCA4OTdkZTIxYTUxLi44Mzhk YzhlMGZlIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS91dGlscy9qc29ucGF0aC5oCisrKyBiL3Ny Yy9pbmNsdWRlL3V0aWxzL2pzb25wYXRoLmgKQEAgLTE1LDYgKzE1LDcgQEAKICNkZWZpbmUgSlNP TlBBVEhfSAogCiAjaW5jbHVkZSAiZm1nci5oIgorI2luY2x1ZGUgImV4ZWN1dG9yL3RhYmxlZnVu Yy5oIgogI2luY2x1ZGUgIm5vZGVzL3BnX2xpc3QuaCIKICNpbmNsdWRlICJub2Rlcy9wcmltbm9k ZXMuaCIKICNpbmNsdWRlICJ1dGlscy9qc29uYi5oIgpAQCAtMjkyLDQgKzI5Myw2IEBAIGV4dGVy biBEYXR1bSBKc29uUGF0aFF1ZXJ5KERhdHVtIGpiLCBKc29uUGF0aCAqanAsIEpzb25XcmFwcGVy IHdyYXBwZXIsCiBleHRlcm4gSnNvbmJWYWx1ZSAqSnNvblBhdGhWYWx1ZShEYXR1bSBqYiwgSnNv blBhdGggKmpwLCBib29sICplbXB0eSwKIAkJCQkJCQkJIGJvb2wgKmVycm9yLCBMaXN0ICp2YXJz KTsKIAorZXh0ZXJuIFBHRExMSU1QT1JUIGNvbnN0IFRhYmxlRnVuY1JvdXRpbmUgSnNvbmJUYWJs ZVJvdXRpbmU7CisKICNlbmRpZgpkaWZmIC0tZ2l0IGEvc3JjL2ludGVyZmFjZXMvZWNwZy90ZXN0 L2VjcGdfc2NoZWR1bGUgYi9zcmMvaW50ZXJmYWNlcy9lY3BnL3Rlc3QvZWNwZ19zY2hlZHVsZQpp bmRleCAzOTgxNGEzOWMxLi43NzBhMTQxMWYzIDEwMDY0NAotLS0gYS9zcmMvaW50ZXJmYWNlcy9l Y3BnL3Rlc3QvZWNwZ19zY2hlZHVsZQorKysgYi9zcmMvaW50ZXJmYWNlcy9lY3BnL3Rlc3QvZWNw Z19zY2hlZHVsZQpAQCAtNTEsNiArNTEsNyBAQCB0ZXN0OiBzcWwvb2xkZXhlYwogdGVzdDogc3Fs L3F1b3RlCiB0ZXN0OiBzcWwvc2hvdwogdGVzdDogc3FsL3NxbGpzb24KK3Rlc3Q6IHNxbC9zcWxq c29uX3F1ZXJ5ZnVuY3MKIHRlc3Q6IHNxbC9pbnN1cGQKIHRlc3Q6IHNxbC9wYXJzZXIKIHRlc3Q6 IHNxbC9wcmVwYXJlYXMKZGlmZiAtLWdpdCBhL3NyYy9pbnRlcmZhY2VzL2VjcGcvdGVzdC9leHBl Y3RlZC9zcWwtc3FsanNvbl9xdWVyeWZ1bmNzLmMgYi9zcmMvaW50ZXJmYWNlcy9lY3BnL3Rlc3Qv ZXhwZWN0ZWQvc3FsLXNxbGpzb25fcXVlcnlmdW5jcy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAuLjZlZGZlZWVmMTkKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvaW50ZXJm YWNlcy9lY3BnL3Rlc3QvZXhwZWN0ZWQvc3FsLXNxbGpzb25fcXVlcnlmdW5jcy5jCkBAIC0wLDAg KzEsMTMyIEBACisvKiBQcm9jZXNzZWQgYnkgZWNwZyAocmVncmVzc2lvbiBtb2RlKSAqLworLyog VGhlc2UgaW5jbHVkZSBmaWxlcyBhcmUgYWRkZWQgYnkgdGhlIHByZXByb2Nlc3NvciAqLworI2lu Y2x1ZGUgPGVjcGdsaWIuaD4KKyNpbmNsdWRlIDxlY3BnZXJybm8uaD4KKyNpbmNsdWRlIDxzcWxj YS5oPgorLyogRW5kIG9mIGF1dG9tYXRpYyBpbmNsdWRlIHNlY3Rpb24gKi8KKyNkZWZpbmUgRUNQ R2RlYnVnKFgsWSkgRUNQR2RlYnVnKChYKSsxMDAsKFkpKQorCisjbGluZSAxICJzcWxqc29uX3F1 ZXJ5ZnVuY3MucGdjIgorI2luY2x1ZGUgPHN0ZGlvLmg+CisKKworI2xpbmUgMSAic3FsY2EuaCIK KyNpZm5kZWYgUE9TVEdSRVNfU1FMQ0FfSAorI2RlZmluZSBQT1NUR1JFU19TUUxDQV9ICisKKyNp Zm5kZWYgUEdETExJTVBPUlQKKyNpZiAgZGVmaW5lZChXSU4zMikgfHwgZGVmaW5lZChfX0NZR1dJ Tl9fKQorI2RlZmluZSBQR0RMTElNUE9SVCBfX2RlY2xzcGVjIChkbGxpbXBvcnQpCisjZWxzZQor I2RlZmluZSBQR0RMTElNUE9SVAorI2VuZGlmCQkJCQkJCS8qIF9fQ1lHV0lOX18gKi8KKyNlbmRp ZgkJCQkJCQkvKiBQR0RMTElNUE9SVCAqLworCisjZGVmaW5lIFNRTEVSUk1DX0xFTgkxNTAKKwor I2lmZGVmIF9fY3BsdXNwbHVzCitleHRlcm4gIkMiCit7CisjZW5kaWYKKworc3RydWN0IHNxbGNh X3QKK3sKKwljaGFyCQlzcWxjYWlkWzhdOworCWxvbmcJCXNxbGFiYzsKKwlsb25nCQlzcWxjb2Rl OworCXN0cnVjdAorCXsKKwkJaW50CQkJc3FsZXJybWw7CisJCWNoYXIJCXNxbGVycm1jW1NRTEVS Uk1DX0xFTl07CisJfQkJCXNxbGVycm07CisJY2hhcgkJc3FsZXJycFs4XTsKKwlsb25nCQlzcWxl cnJkWzZdOworCS8qIEVsZW1lbnQgMDogZW1wdHkJCQkJCQkqLworCS8qIDE6IE9JRCBvZiBwcm9j ZXNzZWQgdHVwbGUgaWYgYXBwbGljYWJsZQkJCSovCisJLyogMjogbnVtYmVyIG9mIHJvd3MgcHJv Y2Vzc2VkCQkJCSovCisJLyogYWZ0ZXIgYW4gSU5TRVJULCBVUERBVEUgb3IJCQkJKi8KKwkvKiBE RUxFVEUgc3RhdGVtZW50CQkJCQkqLworCS8qIDM6IGVtcHR5CQkJCQkJKi8KKwkvKiA0OiBlbXB0 eQkJCQkJCSovCisJLyogNTogZW1wdHkJCQkJCQkqLworCWNoYXIJCXNxbHdhcm5bOF07CisJLyog RWxlbWVudCAwOiBzZXQgdG8gJ1cnIGlmIGF0IGxlYXN0IG9uZSBvdGhlciBpcyAnVycJKi8KKwkv KiAxOiBpZiAnVycgYXQgbGVhc3Qgb25lIGNoYXJhY3RlciBzdHJpbmcJCSovCisJLyogdmFsdWUg d2FzIHRydW5jYXRlZCB3aGVuIGl0IHdhcwkJCSovCisJLyogc3RvcmVkIGludG8gYSBob3N0IHZh cmlhYmxlLiAgICAgICAgICAgICAqLworCisJLyoKKwkgKiAyOiBpZiAnVycgYSAoaG9wZWZ1bGx5 KSBub24tZmF0YWwgbm90aWNlIG9jY3VycmVkCisJICovCS8qIDM6IGVtcHR5ICovCisJLyogNDog ZW1wdHkJCQkJCQkqLworCS8qIDU6IGVtcHR5CQkJCQkJKi8KKwkvKiA2OiBlbXB0eQkJCQkJCSov CisJLyogNzogZW1wdHkJCQkJCQkqLworCisJY2hhcgkJc3Fsc3RhdGVbNV07Cit9OworCitzdHJ1 Y3Qgc3FsY2FfdCAqRUNQR2dldF9zcWxjYSh2b2lkKTsKKworI2lmbmRlZiBQT1NUR1JFU19FQ1BH X0lOVEVSTkFMCisjZGVmaW5lIHNxbGNhICgqRUNQR2dldF9zcWxjYSgpKQorI2VuZGlmCisKKyNp ZmRlZiBfX2NwbHVzcGx1cworfQorI2VuZGlmCisKKyNlbmRpZgorCisjbGluZSAzICJzcWxqc29u X3F1ZXJ5ZnVuY3MucGdjIgorCisKKyNsaW5lIDEgInJlZ3Jlc3Npb24uaCIKKworCisKKworCisK KyNsaW5lIDQgInNxbGpzb25fcXVlcnlmdW5jcy5wZ2MiCisKKworLyogZXhlYyBzcWwgd2hlbmV2 ZXIgc3FsZXJyb3IgIHNxbHByaW50IDsgKi8KKyNsaW5lIDYgInNxbGpzb25fcXVlcnlmdW5jcy5w Z2MiCisKKworaW50CittYWluICgpCit7CisgIEVDUEdkZWJ1ZyAoMSwgc3RkZXJyKTsKKworICB7 IEVDUEdjb25uZWN0KF9fTElORV9fLCAwLCAiZWNwZzFfcmVncmVzc2lvbiIgLCBOVUxMLCBOVUxM ICwgTlVMTCwgMCk7IAorI2xpbmUgMTMgInNxbGpzb25fcXVlcnlmdW5jcy5wZ2MiCisKK2lmIChz cWxjYS5zcWxjb2RlIDwgMCkgc3FscHJpbnQoKTt9CisjbGluZSAxMyAic3FsanNvbl9xdWVyeWZ1 bmNzLnBnYyIKKworICB7IEVDUEdzZXRjb21taXQoX19MSU5FX18sICJvbiIsIE5VTEwpOworI2xp bmUgMTQgInNxbGpzb25fcXVlcnlmdW5jcy5wZ2MiCisKK2lmIChzcWxjYS5zcWxjb2RlIDwgMCkg c3FscHJpbnQoKTt9CisjbGluZSAxNCAic3FsanNvbl9xdWVyeWZ1bmNzLnBnYyIKKworCisgIHsg RUNQR2RvKF9fTElORV9fLCAwLCAxLCBOVUxMLCAwLCBFQ1BHc3Rfbm9ybWFsLCAic2VsZWN0ICog ZnJvbSBqc29uX3RhYmxlICgganNvbmIgJ251bGwnICwgJyRbKl0nIGFzIHAwIGNvbHVtbnMgKCBu ZXN0ZWQgJyQnIGFzIHAxIGNvbHVtbnMgKCBuZXN0ZWQgcGF0aCAnJCcgYXMgcDExIGNvbHVtbnMg KCBmb28gaW50ICkgLCBuZXN0ZWQgcGF0aCAnJCcgYXMgcDEyIGNvbHVtbnMgKCBiYXIgaW50ICkg KSAsIG5lc3RlZCBwYXRoICckJyBhcyBwMiBjb2x1bW5zICggbmVzdGVkIHBhdGggJyQnIGFzIHAy MSBjb2x1bW5zICggYmF6IGludCApICkgKSBwbGFuICggcDEgKSApIGp0IiwgRUNQR3RfRU9JVCwg RUNQR3RfRU9SVCk7CisjbGluZSAyNiAic3FsanNvbl9xdWVyeWZ1bmNzLnBnYyIKKworaWYgKHNx bGNhLnNxbGNvZGUgPCAwKSBzcWxwcmludCgpO30KKyNsaW5lIDI2ICJzcWxqc29uX3F1ZXJ5ZnVu Y3MucGdjIgorCisgIC8vIGVycm9yCisKKyAgeyBFQ1BHZGlzY29ubmVjdChfX0xJTkVfXywgIkNV UlJFTlQiKTsKKyNsaW5lIDI5ICJzcWxqc29uX3F1ZXJ5ZnVuY3MucGdjIgorCitpZiAoc3FsY2Eu c3FsY29kZSA8IDApIHNxbHByaW50KCk7fQorI2xpbmUgMjkgInNxbGpzb25fcXVlcnlmdW5jcy5w Z2MiCisKKworICByZXR1cm4gMDsKK30KZGlmZiAtLWdpdCBhL3NyYy9pbnRlcmZhY2VzL2VjcGcv dGVzdC9leHBlY3RlZC9zcWwtc3FsanNvbl9xdWVyeWZ1bmNzLnN0ZGVyciBiL3NyYy9pbnRlcmZh Y2VzL2VjcGcvdGVzdC9leHBlY3RlZC9zcWwtc3FsanNvbl9xdWVyeWZ1bmNzLnN0ZGVycgpuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwLi5jOTgyZjMxODYwCi0tLSAvZGV2L251 bGwKKysrIGIvc3JjL2ludGVyZmFjZXMvZWNwZy90ZXN0L2V4cGVjdGVkL3NxbC1zcWxqc29uX3F1 ZXJ5ZnVuY3Muc3RkZXJyCkBAIC0wLDAgKzEsMjAgQEAKK1tOT19QSURdOiBFQ1BHZGVidWc6IHNl dCB0byAxCitbTk9fUElEXTogc3FsY2E6IGNvZGU6IDAsIHN0YXRlOiAwMDAwMAorW05PX1BJRF06 IEVDUEdjb25uZWN0OiBvcGVuaW5nIGRhdGFiYXNlIGVjcGcxX3JlZ3Jlc3Npb24gb24gPERFRkFV TFQ+IHBvcnQgPERFRkFVTFQ+ICAKK1tOT19QSURdOiBzcWxjYTogY29kZTogMCwgc3RhdGU6IDAw MDAwCitbTk9fUElEXTogRUNQR3NldGNvbW1pdCBvbiBsaW5lIDE0OiBhY3Rpb24gIm9uIjsgY29u bmVjdGlvbiAiZWNwZzFfcmVncmVzc2lvbiIKK1tOT19QSURdOiBzcWxjYTogY29kZTogMCwgc3Rh dGU6IDAwMDAwCitbTk9fUElEXTogZWNwZ19leGVjdXRlIG9uIGxpbmUgMTY6IHF1ZXJ5OiBzZWxl Y3QgKiBmcm9tIGpzb25fdGFibGUgKCBqc29uYiAnbnVsbCcgLCAnJFsqXScgYXMgcDAgY29sdW1u cyAoIG5lc3RlZCAnJCcgYXMgcDEgY29sdW1ucyAoIG5lc3RlZCBwYXRoICckJyBhcyBwMTEgY29s dW1ucyAoIGZvbyBpbnQgKSAsIG5lc3RlZCBwYXRoICckJyBhcyBwMTIgY29sdW1ucyAoIGJhciBp bnQgKSApICwgbmVzdGVkIHBhdGggJyQnIGFzIHAyIGNvbHVtbnMgKCBuZXN0ZWQgcGF0aCAnJCcg YXMgcDIxIGNvbHVtbnMgKCBiYXogaW50ICkgKSApIHBsYW4gKCBwMSApICkganQ7IHdpdGggMCBw YXJhbWV0ZXIocykgb24gY29ubmVjdGlvbiBlY3BnMV9yZWdyZXNzaW9uCitbTk9fUElEXTogc3Fs Y2E6IGNvZGU6IDAsIHN0YXRlOiAwMDAwMAorW05PX1BJRF06IGVjcGdfZXhlY3V0ZSBvbiBsaW5l IDE2OiB1c2luZyBQUWV4ZWMKK1tOT19QSURdOiBzcWxjYTogY29kZTogMCwgc3RhdGU6IDAwMDAw CitbTk9fUElEXTogZWNwZ19jaGVja19QUXJlc3VsdCBvbiBsaW5lIDE2OiBiYWQgcmVzcG9uc2Ug LSBFUlJPUjogIGludmFsaWQgSlNPTl9UQUJMRSBwbGFuCitMSU5FIDE6IC4uLnRlZCBwYXRoICck JyBhcyBwMjEgY29sdW1ucyAoIGJheiBpbnQgKSApICkgcGxhbiAoIHAxICkgKSBqdAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBe CitERVRBSUw6ICBQYXRoIG5hbWUgbWlzbWF0Y2g6IGV4cGVjdGVkIHAwIGJ1dCBwMSBpcyBnaXZl bi4KK1tOT19QSURdOiBzcWxjYTogY29kZTogMCwgc3RhdGU6IDAwMDAwCitbTk9fUElEXTogcmFp c2luZyBzcWxzdGF0ZSA0MjYwMSAoc3FsY29kZSAtNDAwKTogaW52YWxpZCBKU09OX1RBQkxFIHBs YW4gb24gbGluZSAxNgorW05PX1BJRF06IHNxbGNhOiBjb2RlOiAtNDAwLCBzdGF0ZTogNDI2MDEK K1NRTCBlcnJvcjogaW52YWxpZCBKU09OX1RBQkxFIHBsYW4gb24gbGluZSAxNgorW05PX1BJRF06 IGVjcGdfZmluaXNoOiBjb25uZWN0aW9uIGVjcGcxX3JlZ3Jlc3Npb24gY2xvc2VkCitbTk9fUElE XTogc3FsY2E6IGNvZGU6IDAsIHN0YXRlOiAwMDAwMApkaWZmIC0tZ2l0IGEvc3JjL2ludGVyZmFj ZXMvZWNwZy90ZXN0L2V4cGVjdGVkL3NxbC1zcWxqc29uX3F1ZXJ5ZnVuY3Muc3Rkb3V0IGIvc3Jj L2ludGVyZmFjZXMvZWNwZy90ZXN0L2V4cGVjdGVkL3NxbC1zcWxqc29uX3F1ZXJ5ZnVuY3Muc3Rk b3V0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAuLmU2OWRlMjliYjIKZGlm ZiAtLWdpdCBhL3NyYy9pbnRlcmZhY2VzL2VjcGcvdGVzdC9zcWwvTWFrZWZpbGUgYi9zcmMvaW50 ZXJmYWNlcy9lY3BnL3Rlc3Qvc3FsL01ha2VmaWxlCmluZGV4IGQ4MjEzYjI1Y2UuLjk2YTA2NDY4 NzcgMTAwNjQ0Ci0tLSBhL3NyYy9pbnRlcmZhY2VzL2VjcGcvdGVzdC9zcWwvTWFrZWZpbGUKKysr IGIvc3JjL2ludGVyZmFjZXMvZWNwZy90ZXN0L3NxbC9NYWtlZmlsZQpAQCAtMjQsNiArMjQsNyBA QCBURVNUUyA9IGFycmF5IGFycmF5LmMgXAogICAgICAgICBxdW90ZSBxdW90ZS5jIFwKICAgICAg ICAgc2hvdyBzaG93LmMgXAogICAgICAgICBzcWxqc29uIHNxbGpzb24uYyBcCisgICAgICAgIHNx bGpzb25fcXVlcnlmdW5jcyBzcWxqc29uX3F1ZXJ5ZnVuY3MuYyBcCiAgICAgICAgIGluc3VwZCBp bnN1cGQuYyBcCiAgICAgICAgIHR3b3BoYXNlIHR3b3BoYXNlLmMgXAogICAgICAgICBpbnN1cGQg aW5zdXBkLmMgXApkaWZmIC0tZ2l0IGEvc3JjL2ludGVyZmFjZXMvZWNwZy90ZXN0L3NxbC9tZXNv bi5idWlsZCBiL3NyYy9pbnRlcmZhY2VzL2VjcGcvdGVzdC9zcWwvbWVzb24uYnVpbGQKaW5kZXgg MTJmMjhlMGEyNC4uZjE2NTVkMmRmYyAxMDA2NDQKLS0tIGEvc3JjL2ludGVyZmFjZXMvZWNwZy90 ZXN0L3NxbC9tZXNvbi5idWlsZAorKysgYi9zcmMvaW50ZXJmYWNlcy9lY3BnL3Rlc3Qvc3FsL21l c29uLmJ1aWxkCkBAIC0yNiw2ICsyNiw3IEBAIHBnY19maWxlcyA9IFsKICAgJ3Nob3cnLAogICAn c3FsZGEnLAogICAnc3FsanNvbicsCisgICdzcWxqc29uX3F1ZXJ5ZnVuY3MnLAogICAndHdvcGhh c2UnLAogXQogCmRpZmYgLS1naXQgYS9zcmMvaW50ZXJmYWNlcy9lY3BnL3Rlc3Qvc3FsL3NxbGpz b25fcXVlcnlmdW5jcy5wZ2MgYi9zcmMvaW50ZXJmYWNlcy9lY3BnL3Rlc3Qvc3FsL3NxbGpzb25f cXVlcnlmdW5jcy5wZ2MKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMC4uMDZm OGEyYjYzNAotLS0gL2Rldi9udWxsCisrKyBiL3NyYy9pbnRlcmZhY2VzL2VjcGcvdGVzdC9zcWwv c3FsanNvbl9xdWVyeWZ1bmNzLnBnYwpAQCAtMCwwICsxLDMyIEBACisjaW5jbHVkZSA8c3RkaW8u aD4KKworRVhFQyBTUUwgSU5DTFVERSBzcWxjYTsKK2V4ZWMgc3FsIGluY2x1ZGUgLi4vcmVncmVz c2lvbjsKKworRVhFQyBTUUwgV0hFTkVWRVIgU1FMRVJST1Igc3FscHJpbnQ7CisKK2ludAorbWFp biAoKQoreworICBFQ1BHZGVidWcgKDEsIHN0ZGVycik7CisKKyAgRVhFQyBTUUwgQ09OTkVDVCBU TyBSRUdSRVNTREIxOworICBFWEVDIFNRTCBTRVQgQVVUT0NPTU1JVCA9IE9OOworCisgIEVYRUMg U1FMIFNFTEVDVCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAnbnVsbCcsICckWypdJyBBUyBwMAor CUNPTFVNTlMgKAorCQlORVNURUQgJyQnIEFTIHAxIENPTFVNTlMgKAorCQkJTkVTVEVEIFBBVEgg JyQnIEFTIHAxMSBDT0xVTU5TICggZm9vIGludCApLAorCQkJTkVTVEVEIFBBVEggJyQnIEFTIHAx MiBDT0xVTU5TICggYmFyIGludCApCisJCSksCisJCU5FU1RFRCBQQVRIICckJyBBUyBwMiBDT0xV TU5TICgKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMjEgQ09MVU1OUyAoIGJheiBpbnQgKQorCQkp CisJKQorCVBMQU4gKHAxKSkganQ7CisgIC8vIGVycm9yCisKKyAgRVhFQyBTUUwgRElTQ09OTkVD VDsKKworICByZXR1cm4gMDsKK30KZGlmZiAtLWdpdCBhL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0 ZWQvanNvbl9zcWxqc29uLm91dCBiL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvanNvbl9zcWxq c29uLm91dAppbmRleCAwNGQ1Y2M3NGUzLi41ZDBjNmI2ZmRkIDEwMDY0NAotLS0gYS9zcmMvdGVz dC9yZWdyZXNzL2V4cGVjdGVkL2pzb25fc3FsanNvbi5vdXQKKysrIGIvc3JjL3Rlc3QvcmVncmVz cy9leHBlY3RlZC9qc29uX3NxbGpzb24ub3V0CkBAIC0xNiwzICsxNiw5IEBAIEVSUk9SOiAgSlNP Tl9RVUVSWSgpIGlzIG5vdCB5ZXQgaW1wbGVtZW50ZWQgZm9yIHRoZSBqc29uIHR5cGUKIExJTkUg MTogU0VMRUNUIEpTT05fUVVFUlkoTlVMTCBGT1JNQVQgSlNPTiwgJyQnKTsKICAgICAgICAgICAg ICAgICAgICAgICAgICAgXgogSElOVDogIFRyeSBjYXN0aW5nIHRoZSBhcmd1bWVudCB0byBqc29u YgorLS0gSlNPTl9UQUJMRQorU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKE5VTEwgRk9STUFUIEpT T04sICckJyBDT0xVTU5TIChmb28gdGV4dCkpOworRVJST1I6ICBKU09OX1RBQkxFKCkgaXMgbm90 IHlldCBpbXBsZW1lbnRlZCBmb3IgdGhlIGpzb24gdHlwZQorTElORSAxOiBTRUxFQ1QgKiBGUk9N IEpTT05fVEFCTEUoTlVMTCBGT1JNQVQgSlNPTiwgJyQnIENPTFVNTlMgKGZvbyAuLi4KKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIF4KK0hJTlQ6ICBUcnkgY2FzdGluZyB0aGUgYXJn dW1lbnQgdG8ganNvbmIKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvanNv bmJfc3FsanNvbi5vdXQgYi9zcmMvdGVzdC9yZWdyZXNzL2V4cGVjdGVkL2pzb25iX3NxbGpzb24u b3V0CmluZGV4IDk0YzFiNDMwZmUuLjIzYTMwNmI1NzQgMTAwNjQ0Ci0tLSBhL3NyYy90ZXN0L3Jl Z3Jlc3MvZXhwZWN0ZWQvanNvbmJfc3FsanNvbi5vdXQKKysrIGIvc3JjL3Rlc3QvcmVncmVzcy9l eHBlY3RlZC9qc29uYl9zcWxqc29uLm91dApAQCAtMTA3MSwzICsxMDcxLDEyMjIgQEAgQ1JFQVRF IElOREVYIE9OIHRlc3RfanNvbmJfbXV0YWJpbGl0eSAoSlNPTl9RVUVSWShqcywgJyRbMSwgMCB0 byAkLmEgPyAoQC5kYXRldGkKIEVSUk9SOiAgZnVuY3Rpb25zIGluIGluZGV4IGV4cHJlc3Npb24g bXVzdCBiZSBtYXJrZWQgSU1NVVRBQkxFCiBDUkVBVEUgSU5ERVggT04gdGVzdF9qc29uYl9tdXRh YmlsaXR5IChKU09OX1FVRVJZKGpzLCAnJFsxLCAkLmEgPyAoQC5kYXRldGltZSgiSEg6TUkiKSA9 PSAkeCldJyBQQVNTSU5HICcxMjozNCc6OnRpbWUgQVMgeCkpOwogRFJPUCBUQUJMRSB0ZXN0X2pz b25iX211dGFiaWxpdHk7CistLSBKU09OX1RBQkxFCistLSBTaG91bGQgZmFpbCAoSlNPTl9UQUJM RSBjYW4gYmUgdXNlZCBvbmx5IGluIEZST00gY2xhdXNlKQorU0VMRUNUIEpTT05fVEFCTEUoJ1td JywgJyQnKTsKK0VSUk9SOiAgc3ludGF4IGVycm9yIGF0IG9yIG5lYXIgIigiCitMSU5FIDE6IFNF TEVDVCBKU09OX1RBQkxFKCdbXScsICckJyk7CisgICAgICAgICAgICAgICAgICAgICAgICAgXgor LS0gU2hvdWxkIGZhaWwgKG5vIGNvbHVtbnMpCitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoTlVM TCwgJyQnIENPTFVNTlMgKCkpOworRVJST1I6ICBzeW50YXggZXJyb3IgYXQgb3IgbmVhciAiKSIK K0xJTkUgMTogU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKE5VTEwsICckJyBDT0xVTU5TICgpKTsK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBeCitT RUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUgKE5VTEw6Ompzb25iLCAnJCcgQ09MVU1OUyAodjEgdGlt ZXN0YW1wKSkgQVMgZiAodjEsIHYyKTsKK0VSUk9SOiAgSlNPTl9UQUJMRSBmdW5jdGlvbiBoYXMg MSBjb2x1bW5zIGF2YWlsYWJsZSBidXQgMiBjb2x1bW5zIHNwZWNpZmllZAorLS0gTlVMTCA9PiBl bXB0eSB0YWJsZQorU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKE5VTEw6Ompzb25iLCAnJCcgQ09M VU1OUyAoZm9vIGludCkpIGJhcjsKKyBmb28gCistLS0tLQorKDAgcm93cykKKworLS0KK1NFTEVD VCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAnMTIzJywgJyQnCisJQ09MVU1OUyAoaXRlbSBpbnQg UEFUSCAnJCcsIGZvbyBpbnQpKSBiYXI7CisgaXRlbSB8IGZvbyAKKy0tLS0tLSstLS0tLQorICAx MjMgfCAgICAKKygxIHJvdykKKworLS0gSlNPTl9UQUJMRTogYmFzaWMgZnVuY3Rpb25hbGl0eQor Q1JFQVRFIERPTUFJTiBqc29uYl90ZXN0X2RvbWFpbiBBUyB0ZXh0IENIRUNLICh2YWx1ZSA8PiAn Zm9vJyk7CitDUkVBVEUgVEVNUCBUQUJMRSBqc29uX3RhYmxlX3Rlc3QgKGpzKSBBUworCShWQUxV RVMKKwkJKCcxJyksCisJCSgnW10nKSwKKwkJKCd7fScpLAorCQkoJ1sxLCAxLjIzLCAiMiIsICJh YWFhYWFhIiwgImZvbyIsIG51bGwsIGZhbHNlLCB0cnVlLCB7ImFhYSI6IDEyM30sICJbMSwyXSIs ICJcInN0clwiIl0nKQorCSk7CistLSBSZWd1bGFyICJ1bmZvcm1hdHRlZCIgY29sdW1ucworU0VM RUNUICoKK0ZST00ganNvbl90YWJsZV90ZXN0IHZhbHMKKwlMRUZUIE9VVEVSIEpPSU4KKwlKU09O X1RBQkxFKAorCQl2YWxzLmpzOjpqc29uYiwgJ2xheCAkWypdJworCQlDT0xVTU5TICgKKwkJCWlk IEZPUiBPUkRJTkFMSVRZLAorCQkJImludCIgaW50IFBBVEggJyQnLAorCQkJInRleHQiIHRleHQg UEFUSCAnJCcsCisJCQkiY2hhcig0KSIgY2hhcig0KSBQQVRIICckJywKKwkJCSJib29sIiBib29s IFBBVEggJyQnLAorCQkJIm51bWVyaWMiIG51bWVyaWMgUEFUSCAnJCcsCisJCQkiZG9tYWluIiBq c29uYl90ZXN0X2RvbWFpbiBQQVRIICckJywKKwkJCWpzIGpzb24gUEFUSCAnJCcsCisJCQlqYiBq c29uYiBQQVRIICckJworCQkpCisJKSBqdAorCU9OIHRydWU7CisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBqcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB8IGlkIHwgaW50IHwgIHRleHQgICB8IGNoYXIoNCkgfCBib29sIHwgbnVtZXJp YyB8IGRvbWFpbiAgfCAgICAgIGpzICAgICAgfCAgICAgIGpiICAgICAgCistLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0rLS0tLSstLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0tLSst LS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLS0tLS0tKy0tLS0tLS0tLS0tLS0tCisgMSAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICB8ICAxIHwgICAxIHwgMSAgICAgICB8IDEgICAgICAgfCAg ICAgIHwgICAgICAgMSB8IDEgICAgICAgfCAxICAgICAgICAgICAgfCAxCisgW10gICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB8ICAgIHwgICAgIHwgICAgICAgICB8ICAgICAgICAgfCAgICAgIHwg ICAgICAgICB8ICAgICAgICAgfCAgICAgICAgICAgICAgfCAKKyB7fSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgIDEgfCAgICAgfCAgICAgICAgIHwgICAgICAgICB8ICAgICAgfCAgICAgICAg IHwgICAgICAgICB8IHt9ICAgICAgICAgICB8IHt9CisgWzEsIDEuMjMsICIyIiwgImFhYWFhYWEi LCAiZm9vIiwgbnVsbCwgZmFsc2UsIHRydWUsIHsiYWFhIjogMTIzfSwgIlsxLDJdIiwgIlwic3Ry XCIiXSB8ICAxIHwgICAxIHwgMSAgICAgICB8IDEgICAgICAgfCAgICAgIHwgICAgICAgMSB8IDEg ICAgICAgfCAxICAgICAgICAgICAgfCAxCisgWzEsIDEuMjMsICIyIiwgImFhYWFhYWEiLCAiZm9v IiwgbnVsbCwgZmFsc2UsIHRydWUsIHsiYWFhIjogMTIzfSwgIlsxLDJdIiwgIlwic3RyXCIiXSB8 ICAyIHwgICAxIHwgMS4yMyAgICB8IDEuMjMgICAgfCAgICAgIHwgICAgMS4yMyB8IDEuMjMgICAg fCAxLjIzICAgICAgICAgfCAxLjIzCisgWzEsIDEuMjMsICIyIiwgImFhYWFhYWEiLCAiZm9vIiwg bnVsbCwgZmFsc2UsIHRydWUsIHsiYWFhIjogMTIzfSwgIlsxLDJdIiwgIlwic3RyXCIiXSB8ICAz IHwgICAyIHwgMiAgICAgICB8IDIgICAgICAgfCAgICAgIHwgICAgICAgMiB8IDIgICAgICAgfCAi MiIgICAgICAgICAgfCAiMiIKKyBbMSwgMS4yMywgIjIiLCAiYWFhYWFhYSIsICJmb28iLCBudWxs LCBmYWxzZSwgdHJ1ZSwgeyJhYWEiOiAxMjN9LCAiWzEsMl0iLCAiXCJzdHJcIiJdIHwgIDQgfCAg ICAgfCBhYWFhYWFhIHwgYWFhYSAgICB8ICAgICAgfCAgICAgICAgIHwgYWFhYWFhYSB8ICJhYWFh YWFhIiAgICB8ICJhYWFhYWFhIgorIFsxLCAxLjIzLCAiMiIsICJhYWFhYWFhIiwgImZvbyIsIG51 bGwsIGZhbHNlLCB0cnVlLCB7ImFhYSI6IDEyM30sICJbMSwyXSIsICJcInN0clwiIl0gfCAgNSB8 ICAgICB8IGZvbyAgICAgfCBmb28gICAgIHwgICAgICB8ICAgICAgICAgfCAgICAgICAgIHwgImZv byIgICAgICAgIHwgImZvbyIKKyBbMSwgMS4yMywgIjIiLCAiYWFhYWFhYSIsICJmb28iLCBudWxs LCBmYWxzZSwgdHJ1ZSwgeyJhYWEiOiAxMjN9LCAiWzEsMl0iLCAiXCJzdHJcIiJdIHwgIDYgfCAg ICAgfCAgICAgICAgIHwgICAgICAgICB8ICAgICAgfCAgICAgICAgIHwgICAgICAgICB8IG51bGwg ICAgICAgICB8IG51bGwKKyBbMSwgMS4yMywgIjIiLCAiYWFhYWFhYSIsICJmb28iLCBudWxsLCBm YWxzZSwgdHJ1ZSwgeyJhYWEiOiAxMjN9LCAiWzEsMl0iLCAiXCJzdHJcIiJdIHwgIDcgfCAgIDAg fCBmYWxzZSAgIHwgZmFscyAgICB8IGYgICAgfCAgICAgICAgIHwgZmFsc2UgICB8IGZhbHNlICAg ICAgICB8IGZhbHNlCisgWzEsIDEuMjMsICIyIiwgImFhYWFhYWEiLCAiZm9vIiwgbnVsbCwgZmFs c2UsIHRydWUsIHsiYWFhIjogMTIzfSwgIlsxLDJdIiwgIlwic3RyXCIiXSB8ICA4IHwgICAxIHwg dHJ1ZSAgICB8IHRydWUgICAgfCB0ICAgIHwgICAgICAgICB8IHRydWUgICAgfCB0cnVlICAgICAg ICAgfCB0cnVlCisgWzEsIDEuMjMsICIyIiwgImFhYWFhYWEiLCAiZm9vIiwgbnVsbCwgZmFsc2Us IHRydWUsIHsiYWFhIjogMTIzfSwgIlsxLDJdIiwgIlwic3RyXCIiXSB8ICA5IHwgICAgIHwgICAg ICAgICB8ICAgICAgICAgfCAgICAgIHwgICAgICAgICB8ICAgICAgICAgfCB7ImFhYSI6IDEyM30g fCB7ImFhYSI6IDEyM30KKyBbMSwgMS4yMywgIjIiLCAiYWFhYWFhYSIsICJmb28iLCBudWxsLCBm YWxzZSwgdHJ1ZSwgeyJhYWEiOiAxMjN9LCAiWzEsMl0iLCAiXCJzdHJcIiJdIHwgMTAgfCAgICAg fCBbMSwyXSAgIHwgWzEsMiAgICB8ICAgICAgfCAgICAgICAgIHwgWzEsMl0gICB8ICJbMSwyXSIg ICAgICB8ICJbMSwyXSIKKyBbMSwgMS4yMywgIjIiLCAiYWFhYWFhYSIsICJmb28iLCBudWxsLCBm YWxzZSwgdHJ1ZSwgeyJhYWEiOiAxMjN9LCAiWzEsMl0iLCAiXCJzdHJcIiJdIHwgMTEgfCAgICAg fCAic3RyIiAgIHwgInN0ciAgICB8ICAgICAgfCAgICAgICAgIHwgInN0ciIgICB8ICJcInN0clwi IiAgICB8ICJcInN0clwiIgorKDE0IHJvd3MpCisKKy0tICJmb3JtYXR0ZWQiIGNvbHVtbnMKK1NF TEVDVCAqCitGUk9NIGpzb25fdGFibGVfdGVzdCB2YWxzCisJTEVGVCBPVVRFUiBKT0lOCisJSlNP Tl9UQUJMRSgKKwkJdmFscy5qczo6anNvbmIsICdsYXggJFsqXScKKwkJQ09MVU1OUyAoCisJCQlp ZCBGT1IgT1JESU5BTElUWSwKKwkJCWpzdCB0ZXh0ICAgIEZPUk1BVCBKU09OICBQQVRIICckJywK KwkJCWpzYyBjaGFyKDQpIEZPUk1BVCBKU09OICBQQVRIICckJywKKwkJCWpzdiB2YXJjaGFyKDQp IEZPUk1BVCBKU09OICBQQVRIICckJywKKwkJCWpzYiBqc29uYiBGT1JNQVQgSlNPTiBQQVRIICck JywKKwkJCWpzYnEganNvbmIgRk9STUFUIEpTT04gUEFUSCAnJCcgT01JVCBRVU9URVMKKwkJKQor CSkganQKKwlPTiB0cnVlOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAganMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCBpZCB8ICAg ICBqc3QgICAgICB8IGpzYyAgfCBqc3YgIHwgICAgIGpzYiAgICAgIHwgICAgIGpzYnEgICAgIAor LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKy0tLS0rLS0tLS0tLS0tLS0tLS0rLS0tLS0t Ky0tLS0tLSstLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLQorIDEgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgfCAgMSB8IDEgICAgICAgICAgICB8IDEgICAgfCAxICAgIHwgMSAgICAgICAg ICAgIHwgMQorIFtdICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICB8ICAgICAgICAgICAg ICB8ICAgICAgfCAgICAgIHwgICAgICAgICAgICAgIHwgCisge30gICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8ICAxIHwge30gICAgICAgICAgIHwge30gICB8IHt9ICAgfCB7fSAgICAgICAgICAg fCB7fQorIFsxLCAxLjIzLCAiMiIsICJhYWFhYWFhIiwgImZvbyIsIG51bGwsIGZhbHNlLCB0cnVl LCB7ImFhYSI6IDEyM30sICJbMSwyXSIsICJcInN0clwiIl0gfCAgMSB8IDEgICAgICAgICAgICB8 IDEgICAgfCAxICAgIHwgMSAgICAgICAgICAgIHwgMQorIFsxLCAxLjIzLCAiMiIsICJhYWFhYWFh IiwgImZvbyIsIG51bGwsIGZhbHNlLCB0cnVlLCB7ImFhYSI6IDEyM30sICJbMSwyXSIsICJcInN0 clwiIl0gfCAgMiB8IDEuMjMgICAgICAgICB8IDEuMjMgfCAxLjIzIHwgMS4yMyAgICAgICAgIHwg MS4yMworIFsxLCAxLjIzLCAiMiIsICJhYWFhYWFhIiwgImZvbyIsIG51bGwsIGZhbHNlLCB0cnVl LCB7ImFhYSI6IDEyM30sICJbMSwyXSIsICJcInN0clwiIl0gfCAgMyB8ICIyIiAgICAgICAgICB8 ICIyIiAgfCAiMiIgIHwgIjIiICAgICAgICAgIHwgMgorIFsxLCAxLjIzLCAiMiIsICJhYWFhYWFh IiwgImZvbyIsIG51bGwsIGZhbHNlLCB0cnVlLCB7ImFhYSI6IDEyM30sICJbMSwyXSIsICJcInN0 clwiIl0gfCAgNCB8ICJhYWFhYWFhIiAgICB8ICJhYWEgfCAiYWFhIHwgImFhYWFhYWEiICAgIHwg CisgWzEsIDEuMjMsICIyIiwgImFhYWFhYWEiLCAiZm9vIiwgbnVsbCwgZmFsc2UsIHRydWUsIHsi YWFhIjogMTIzfSwgIlsxLDJdIiwgIlwic3RyXCIiXSB8ICA1IHwgImZvbyIgICAgICAgIHwgImZv byB8ICJmb28gfCAiZm9vIiAgICAgICAgfCAKKyBbMSwgMS4yMywgIjIiLCAiYWFhYWFhYSIsICJm b28iLCBudWxsLCBmYWxzZSwgdHJ1ZSwgeyJhYWEiOiAxMjN9LCAiWzEsMl0iLCAiXCJzdHJcIiJd IHwgIDYgfCBudWxsICAgICAgICAgfCBudWxsIHwgbnVsbCB8IG51bGwgICAgICAgICB8IG51bGwK KyBbMSwgMS4yMywgIjIiLCAiYWFhYWFhYSIsICJmb28iLCBudWxsLCBmYWxzZSwgdHJ1ZSwgeyJh YWEiOiAxMjN9LCAiWzEsMl0iLCAiXCJzdHJcIiJdIHwgIDcgfCBmYWxzZSAgICAgICAgfCBmYWxz IHwgZmFscyB8IGZhbHNlICAgICAgICB8IGZhbHNlCisgWzEsIDEuMjMsICIyIiwgImFhYWFhYWEi LCAiZm9vIiwgbnVsbCwgZmFsc2UsIHRydWUsIHsiYWFhIjogMTIzfSwgIlsxLDJdIiwgIlwic3Ry XCIiXSB8ICA4IHwgdHJ1ZSAgICAgICAgIHwgdHJ1ZSB8IHRydWUgfCB0cnVlICAgICAgICAgfCB0 cnVlCisgWzEsIDEuMjMsICIyIiwgImFhYWFhYWEiLCAiZm9vIiwgbnVsbCwgZmFsc2UsIHRydWUs IHsiYWFhIjogMTIzfSwgIlsxLDJdIiwgIlwic3RyXCIiXSB8ICA5IHwgeyJhYWEiOiAxMjN9IHwg eyJhYSB8IHsiYWEgfCB7ImFhYSI6IDEyM30gfCB7ImFhYSI6IDEyM30KKyBbMSwgMS4yMywgIjIi LCAiYWFhYWFhYSIsICJmb28iLCBudWxsLCBmYWxzZSwgdHJ1ZSwgeyJhYWEiOiAxMjN9LCAiWzEs Ml0iLCAiXCJzdHJcIiJdIHwgMTAgfCAiWzEsMl0iICAgICAgfCAiWzEsIHwgIlsxLCB8ICJbMSwy XSIgICAgICB8IFsxLCAyXQorIFsxLCAxLjIzLCAiMiIsICJhYWFhYWFhIiwgImZvbyIsIG51bGws IGZhbHNlLCB0cnVlLCB7ImFhYSI6IDEyM30sICJbMSwyXSIsICJcInN0clwiIl0gfCAxMSB8ICJc InN0clwiIiAgICB8ICJcInMgfCAiXCJzIHwgIlwic3RyXCIiICAgIHwgInN0ciIKKygxNCByb3dz KQorCistLSBFWElTVFMgY29sdW1ucworU0VMRUNUICoKK0ZST00ganNvbl90YWJsZV90ZXN0IHZh bHMKKwlMRUZUIE9VVEVSIEpPSU4KKwlKU09OX1RBQkxFKAorCQl2YWxzLmpzOjpqc29uYiwgJ2xh eCAkWypdJworCQlDT0xVTU5TICgKKwkJCWlkIEZPUiBPUkRJTkFMSVRZLAorCQkJZXhpc3RzMSBi b29sIEVYSVNUUyBQQVRIICckLmFhYScsCisJCQlleGlzdHMyIGludCBFWElTVFMgUEFUSCAnJC5h YWEnLAorCQkJZXhpc3RzMyBpbnQgRVhJU1RTIFBBVEggJ3N0cmljdCAkLmFhYScgVU5LTk9XTiBP TiBFUlJPUiwKKwkJCWV4aXN0czQgdGV4dCBFWElTVFMgUEFUSCAnc3RyaWN0ICQuYWFhJyBGQUxT RSBPTiBFUlJPUgorCQkpCisJKSBqdAorCU9OIHRydWU7CisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBqcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8IGlkIHwgZXhpc3RzMSB8IGV4aXN0czIgfCBleGlzdHMzIHwgZXhpc3RzNCAKKy0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSstLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rLS0t LS0tLS0tKy0tLS0tLS0tLQorIDEgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMSB8IGYg ICAgICAgfCAgICAgICAwIHwgICAgICAgICB8IGZhbHNlCisgW10gICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8ICAgIHwgICAgICAgICB8ICAgICAgICAgfCAgICAgICAgIHwgCisge30gICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB8ICAxIHwgZiAgICAgICB8ICAgICAgIDAgfCAgICAgICAgIHwg ZmFsc2UKKyBbMSwgMS4yMywgIjIiLCAiYWFhYWFhYSIsICJmb28iLCBudWxsLCBmYWxzZSwgdHJ1 ZSwgeyJhYWEiOiAxMjN9LCAiWzEsMl0iLCAiXCJzdHJcIiJdIHwgIDEgfCBmICAgICAgIHwgICAg ICAgMCB8ICAgICAgICAgfCBmYWxzZQorIFsxLCAxLjIzLCAiMiIsICJhYWFhYWFhIiwgImZvbyIs IG51bGwsIGZhbHNlLCB0cnVlLCB7ImFhYSI6IDEyM30sICJbMSwyXSIsICJcInN0clwiIl0gfCAg MiB8IGYgICAgICAgfCAgICAgICAwIHwgICAgICAgICB8IGZhbHNlCisgWzEsIDEuMjMsICIyIiwg ImFhYWFhYWEiLCAiZm9vIiwgbnVsbCwgZmFsc2UsIHRydWUsIHsiYWFhIjogMTIzfSwgIlsxLDJd IiwgIlwic3RyXCIiXSB8ICAzIHwgZiAgICAgICB8ICAgICAgIDAgfCAgICAgICAgIHwgZmFsc2UK KyBbMSwgMS4yMywgIjIiLCAiYWFhYWFhYSIsICJmb28iLCBudWxsLCBmYWxzZSwgdHJ1ZSwgeyJh YWEiOiAxMjN9LCAiWzEsMl0iLCAiXCJzdHJcIiJdIHwgIDQgfCBmICAgICAgIHwgICAgICAgMCB8 ICAgICAgICAgfCBmYWxzZQorIFsxLCAxLjIzLCAiMiIsICJhYWFhYWFhIiwgImZvbyIsIG51bGws IGZhbHNlLCB0cnVlLCB7ImFhYSI6IDEyM30sICJbMSwyXSIsICJcInN0clwiIl0gfCAgNSB8IGYg ICAgICAgfCAgICAgICAwIHwgICAgICAgICB8IGZhbHNlCisgWzEsIDEuMjMsICIyIiwgImFhYWFh YWEiLCAiZm9vIiwgbnVsbCwgZmFsc2UsIHRydWUsIHsiYWFhIjogMTIzfSwgIlsxLDJdIiwgIlwi c3RyXCIiXSB8ICA2IHwgZiAgICAgICB8ICAgICAgIDAgfCAgICAgICAgIHwgZmFsc2UKKyBbMSwg MS4yMywgIjIiLCAiYWFhYWFhYSIsICJmb28iLCBudWxsLCBmYWxzZSwgdHJ1ZSwgeyJhYWEiOiAx MjN9LCAiWzEsMl0iLCAiXCJzdHJcIiJdIHwgIDcgfCBmICAgICAgIHwgICAgICAgMCB8ICAgICAg ICAgfCBmYWxzZQorIFsxLCAxLjIzLCAiMiIsICJhYWFhYWFhIiwgImZvbyIsIG51bGwsIGZhbHNl LCB0cnVlLCB7ImFhYSI6IDEyM30sICJbMSwyXSIsICJcInN0clwiIl0gfCAgOCB8IGYgICAgICAg fCAgICAgICAwIHwgICAgICAgICB8IGZhbHNlCisgWzEsIDEuMjMsICIyIiwgImFhYWFhYWEiLCAi Zm9vIiwgbnVsbCwgZmFsc2UsIHRydWUsIHsiYWFhIjogMTIzfSwgIlsxLDJdIiwgIlwic3RyXCIi XSB8ICA5IHwgdCAgICAgICB8ICAgICAgIDEgfCAgICAgICAxIHwgdHJ1ZQorIFsxLCAxLjIzLCAi MiIsICJhYWFhYWFhIiwgImZvbyIsIG51bGwsIGZhbHNlLCB0cnVlLCB7ImFhYSI6IDEyM30sICJb MSwyXSIsICJcInN0clwiIl0gfCAxMCB8IGYgICAgICAgfCAgICAgICAwIHwgICAgICAgICB8IGZh bHNlCisgWzEsIDEuMjMsICIyIiwgImFhYWFhYWEiLCAiZm9vIiwgbnVsbCwgZmFsc2UsIHRydWUs IHsiYWFhIjogMTIzfSwgIlsxLDJdIiwgIlwic3RyXCIiXSB8IDExIHwgZiAgICAgICB8ICAgICAg IDAgfCAgICAgICAgIHwgZmFsc2UKKygxNCByb3dzKQorCistLSBPdGhlciBtaXNjZWxsYW5vdXMg Y2hlY2tzCitTRUxFQ1QgKgorRlJPTSBqc29uX3RhYmxlX3Rlc3QgdmFscworCUxFRlQgT1VURVIg Sk9JTgorCUpTT05fVEFCTEUoCisJCXZhbHMuanM6Ompzb25iLCAnbGF4ICRbKl0nCisJCUNPTFVN TlMgKAorCQkJaWQgRk9SIE9SRElOQUxJVFksCisJCQlhYWEgaW50LCAtLSAiYWFhIiBoYXMgaW1w bGljaXQgcGF0aCAnJC4iYWFhIicKKwkJCWFhYTEgaW50IFBBVEggJyQuYWFhJywKKwkJCWpzMiBq c29uIFBBVEggJyQnLAorCQkJanNiMncganNvbmIgUEFUSCAnJCcgV0lUSCBXUkFQUEVSLAorCQkJ anNiMnEganNvbmIgUEFUSCAnJCcgT01JVCBRVU9URVMsCisJCQlpYSBpbnRbXSBQQVRIICckJywK KwkJCXRhIHRleHRbXSBQQVRIICckJywKKwkJCWpiYSBqc29uYltdIFBBVEggJyQnCisJCSkKKwkp IGp0CisJT04gdHJ1ZTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGpzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgaWQgfCBhYWEg fCBhYWExIHwgICAgIGpzMiAgICAgIHwgICAgIGpzYjJ3ICAgICAgfCAgICBqc2IycSAgICAgfCBp YSB8IHRhIHwgamJhIAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKy0tLS0rLS0tLS0r LS0tLS0tKy0tLS0tLS0tLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0rLS0t LSstLS0tKy0tLS0tCisgMSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAxIHwgICAgIHwg ICAgICB8IDEgICAgICAgICAgICB8IFsxXSAgICAgICAgICAgIHwgMSAgICAgICAgICAgIHwgICAg fCAgICB8IAorIFtdICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICB8ICAgICB8ICAgICAg fCAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICB8ICAgICAgICAgICAgICB8ICAgIHwgICAg fCAKKyB7fSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDEgfCAgICAgfCAgICAgIHwge30g ICAgICAgICAgIHwgW3t9XSAgICAgICAgICAgfCB7fSAgICAgICAgICAgfCAgICB8ICAgIHwgCisg WzEsIDEuMjMsICIyIiwgImFhYWFhYWEiLCAiZm9vIiwgbnVsbCwgZmFsc2UsIHRydWUsIHsiYWFh IjogMTIzfSwgIlsxLDJdIiwgIlwic3RyXCIiXSB8ICAxIHwgICAgIHwgICAgICB8IDEgICAgICAg ICAgICB8IFsxXSAgICAgICAgICAgIHwgMSAgICAgICAgICAgIHwgICAgfCAgICB8IAorIFsxLCAx LjIzLCAiMiIsICJhYWFhYWFhIiwgImZvbyIsIG51bGwsIGZhbHNlLCB0cnVlLCB7ImFhYSI6IDEy M30sICJbMSwyXSIsICJcInN0clwiIl0gfCAgMiB8ICAgICB8ICAgICAgfCAxLjIzICAgICAgICAg fCBbMS4yM10gICAgICAgICB8IDEuMjMgICAgICAgICB8ICAgIHwgICAgfCAKKyBbMSwgMS4yMywg IjIiLCAiYWFhYWFhYSIsICJmb28iLCBudWxsLCBmYWxzZSwgdHJ1ZSwgeyJhYWEiOiAxMjN9LCAi WzEsMl0iLCAiXCJzdHJcIiJdIHwgIDMgfCAgICAgfCAgICAgIHwgIjIiICAgICAgICAgIHwgWyIy Il0gICAgICAgICAgfCAyICAgICAgICAgICAgfCAgICB8ICAgIHwgCisgWzEsIDEuMjMsICIyIiwg ImFhYWFhYWEiLCAiZm9vIiwgbnVsbCwgZmFsc2UsIHRydWUsIHsiYWFhIjogMTIzfSwgIlsxLDJd IiwgIlwic3RyXCIiXSB8ICA0IHwgICAgIHwgICAgICB8ICJhYWFhYWFhIiAgICB8IFsiYWFhYWFh YSJdICAgIHwgICAgICAgICAgICAgIHwgICAgfCAgICB8IAorIFsxLCAxLjIzLCAiMiIsICJhYWFh YWFhIiwgImZvbyIsIG51bGwsIGZhbHNlLCB0cnVlLCB7ImFhYSI6IDEyM30sICJbMSwyXSIsICJc InN0clwiIl0gfCAgNSB8ICAgICB8ICAgICAgfCAiZm9vIiAgICAgICAgfCBbImZvbyJdICAgICAg ICB8ICAgICAgICAgICAgICB8ICAgIHwgICAgfCAKKyBbMSwgMS4yMywgIjIiLCAiYWFhYWFhYSIs ICJmb28iLCBudWxsLCBmYWxzZSwgdHJ1ZSwgeyJhYWEiOiAxMjN9LCAiWzEsMl0iLCAiXCJzdHJc IiJdIHwgIDYgfCAgICAgfCAgICAgIHwgbnVsbCAgICAgICAgIHwgW251bGxdICAgICAgICAgfCBu dWxsICAgICAgICAgfCAgICB8ICAgIHwgCisgWzEsIDEuMjMsICIyIiwgImFhYWFhYWEiLCAiZm9v IiwgbnVsbCwgZmFsc2UsIHRydWUsIHsiYWFhIjogMTIzfSwgIlsxLDJdIiwgIlwic3RyXCIiXSB8 ICA3IHwgICAgIHwgICAgICB8IGZhbHNlICAgICAgICB8IFtmYWxzZV0gICAgICAgIHwgZmFsc2Ug ICAgICAgIHwgICAgfCAgICB8IAorIFsxLCAxLjIzLCAiMiIsICJhYWFhYWFhIiwgImZvbyIsIG51 bGwsIGZhbHNlLCB0cnVlLCB7ImFhYSI6IDEyM30sICJbMSwyXSIsICJcInN0clwiIl0gfCAgOCB8 ICAgICB8ICAgICAgfCB0cnVlICAgICAgICAgfCBbdHJ1ZV0gICAgICAgICB8IHRydWUgICAgICAg ICB8ICAgIHwgICAgfCAKKyBbMSwgMS4yMywgIjIiLCAiYWFhYWFhYSIsICJmb28iLCBudWxsLCBm YWxzZSwgdHJ1ZSwgeyJhYWEiOiAxMjN9LCAiWzEsMl0iLCAiXCJzdHJcIiJdIHwgIDkgfCAxMjMg fCAgMTIzIHwgeyJhYWEiOiAxMjN9IHwgW3siYWFhIjogMTIzfV0gfCB7ImFhYSI6IDEyM30gfCAg ICB8ICAgIHwgCisgWzEsIDEuMjMsICIyIiwgImFhYWFhYWEiLCAiZm9vIiwgbnVsbCwgZmFsc2Us IHRydWUsIHsiYWFhIjogMTIzfSwgIlsxLDJdIiwgIlwic3RyXCIiXSB8IDEwIHwgICAgIHwgICAg ICB8ICJbMSwyXSIgICAgICB8IFsiWzEsMl0iXSAgICAgIHwgWzEsIDJdICAgICAgIHwgICAgfCAg ICB8IAorIFsxLCAxLjIzLCAiMiIsICJhYWFhYWFhIiwgImZvbyIsIG51bGwsIGZhbHNlLCB0cnVl LCB7ImFhYSI6IDEyM30sICJbMSwyXSIsICJcInN0clwiIl0gfCAxMSB8ICAgICB8ICAgICAgfCAi XCJzdHJcIiIgICAgfCBbIlwic3RyXCIiXSAgICB8ICJzdHIiICAgICAgICB8ICAgIHwgICAgfCAK KygxNCByb3dzKQorCistLSBKU09OX1RBQkxFOiBUZXN0IGJhY2t3YXJkIHBhcnNpbmcKK0NSRUFU RSBWSUVXIGpzb25iX3RhYmxlX3ZpZXcgQVMKK1NFTEVDVCAqIEZST00KKwlKU09OX1RBQkxFKAor CQlqc29uYiAnbnVsbCcsICdsYXggJFsqXScgUEFTU0lORyAxICsgMiBBUyBhLCBqc29uICciZm9v IicgQVMgImIgYyIKKwkJQ09MVU1OUyAoCisJCQlpZCBGT1IgT1JESU5BTElUWSwKKwkJCSJpbnQi IGludCBQQVRIICckJywKKwkJCSJ0ZXh0IiB0ZXh0IFBBVEggJyQnLAorCQkJImNoYXIoNCkiIGNo YXIoNCkgUEFUSCAnJCcsCisJCQkiYm9vbCIgYm9vbCBQQVRIICckJywKKwkJCSJudW1lcmljIiBu dW1lcmljIFBBVEggJyQnLAorCQkJImRvbWFpbiIganNvbmJfdGVzdF9kb21haW4gUEFUSCAnJCcs CisJCQlqcyBqc29uIFBBVEggJyQnLAorCQkJamIganNvbmIgUEFUSCAnJCcsCisJCQlqc3QgdGV4 dCAgICBGT1JNQVQgSlNPTiAgUEFUSCAnJCcsCisJCQlqc2MgY2hhcig0KSBGT1JNQVQgSlNPTiAg UEFUSCAnJCcsCisJCQlqc3YgdmFyY2hhcig0KSBGT1JNQVQgSlNPTiAgUEFUSCAnJCcsCisJCQlq c2IganNvbmIgICBGT1JNQVQgSlNPTiBQQVRIICckJywKKwkJCWpzYnEganNvbmIgRk9STUFUIEpT T04gUEFUSCAnJCcgT01JVCBRVU9URVMsCisJCQlhYWEgaW50LCAtLSBpbXBsaWNpdCBwYXRoICck LiJhYWEiJywKKwkJCWFhYTEgaW50IFBBVEggJyQuYWFhJywKKwkJCWV4aXN0czEgYm9vbCBFWElT VFMgUEFUSCAnJC5hYWEnLAorCQkJZXhpc3RzMiBpbnQgRVhJU1RTIFBBVEggJyQuYWFhJyBUUlVF IE9OIEVSUk9SLAorCQkJZXhpc3RzMyB0ZXh0IEVYSVNUUyBQQVRIICdzdHJpY3QgJC5hYWEnIFVO S05PV04gT04gRVJST1IsCisJCQlqczIganNvbiBQQVRIICckJywKKwkJCWpzYjJ3IGpzb25iIFBB VEggJyQnIFdJVEggV1JBUFBFUiwKKwkJCWpzYjJxIGpzb25iIFBBVEggJyQnIE9NSVQgUVVPVEVT LAorCQkJaWEgaW50W10gUEFUSCAnJCcsCisJCQl0YSB0ZXh0W10gUEFUSCAnJCcsCisJCQlqYmEg anNvbmJbXSBQQVRIICckJywKKwkJCU5FU1RFRCBQQVRIICckWzFdJyBBUyBwMSBDT0xVTU5TICgK KwkJCQlhMSBpbnQsCisJCQkJTkVTVEVEIFBBVEggJyRbKl0nIEFTICJwMSAxIiBDT0xVTU5TICgK KwkJCQkJYTExIHRleHQKKwkJCQkpLAorCQkJCWIxIHRleHQKKwkJCSksCisJCQlORVNURUQgUEFU SCAnJFsyXScgQVMgcDIgQ09MVU1OUyAoCisJCQkJTkVTVEVEIFBBVEggJyRbKl0nIEFTICJwMjox IiBDT0xVTU5TICgKKwkJCQkJYTIxIHRleHQKKwkJCQkpLAorCQkJCU5FU1RFRCBQQVRIICckWypd JyBBUyBwMjIgQ09MVU1OUyAoCisJCQkJCWEyMiB0ZXh0CisJCQkJKQorCQkJKQorCQkpCisJKTsK K1xzdiBqc29uYl90YWJsZV92aWV3CitDUkVBVEUgT1IgUkVQTEFDRSBWSUVXIHB1YmxpYy5qc29u Yl90YWJsZV92aWV3IEFTCisgU0VMRUNUIGlkLAorICAgICJpbnQiLAorICAgIHRleHQsCisgICAg ImNoYXIoNCkiLAorICAgIGJvb2wsCisgICAgIm51bWVyaWMiLAorICAgIGRvbWFpbiwKKyAgICBq cywKKyAgICBqYiwKKyAgICBqc3QsCisgICAganNjLAorICAgIGpzdiwKKyAgICBqc2IsCisgICAg anNicSwKKyAgICBhYWEsCisgICAgYWFhMSwKKyAgICBleGlzdHMxLAorICAgIGV4aXN0czIsCisg ICAgZXhpc3RzMywKKyAgICBqczIsCisgICAganNiMncsCisgICAganNiMnEsCisgICAgaWEsCisg ICAgdGEsCisgICAgamJhLAorICAgIGExLAorICAgIGIxLAorICAgIGExMSwKKyAgICBhMjEsCisg ICAgYTIyCisgICBGUk9NIEpTT05fVEFCTEUoCisgICAgICAgICAgICAnbnVsbCc6Ompzb25iLCAn JFsqXScgQVMganNvbl90YWJsZV9wYXRoXzAKKyAgICAgICAgICAgIFBBU1NJTkcKKyAgICAgICAg ICAgICAgICAxICsgMiBBUyBhLAorICAgICAgICAgICAgICAgICciZm9vIic6Ompzb24gQVMgImIg YyIKKyAgICAgICAgICAgIENPTFVNTlMgKAorICAgICAgICAgICAgICAgIGlkIEZPUiBPUkRJTkFM SVRZLAorICAgICAgICAgICAgICAgICJpbnQiIGludGVnZXIgUEFUSCAnJCcsCisgICAgICAgICAg ICAgICAgdGV4dCB0ZXh0IFBBVEggJyQnLAorICAgICAgICAgICAgICAgICJjaGFyKDQpIiBjaGFy YWN0ZXIoNCkgUEFUSCAnJCcsCisgICAgICAgICAgICAgICAgYm9vbCBib29sZWFuIFBBVEggJyQn LAorICAgICAgICAgICAgICAgICJudW1lcmljIiBudW1lcmljIFBBVEggJyQnLAorICAgICAgICAg ICAgICAgIGRvbWFpbiBqc29uYl90ZXN0X2RvbWFpbiBQQVRIICckJywKKyAgICAgICAgICAgICAg ICBqcyBqc29uIFBBVEggJyQnLAorICAgICAgICAgICAgICAgIGpiIGpzb25iIFBBVEggJyQnLAor ICAgICAgICAgICAgICAgIGpzdCB0ZXh0IEZPUk1BVCBKU09OIFBBVEggJyQnLAorICAgICAgICAg ICAgICAgIGpzYyBjaGFyYWN0ZXIoNCkgRk9STUFUIEpTT04gUEFUSCAnJCcsCisgICAgICAgICAg ICAgICAganN2IGNoYXJhY3RlciB2YXJ5aW5nKDQpIEZPUk1BVCBKU09OIFBBVEggJyQnLAorICAg ICAgICAgICAgICAgIGpzYiBqc29uYiBQQVRIICckJywKKyAgICAgICAgICAgICAgICBqc2JxIGpz b25iIFBBVEggJyQnIE9NSVQgUVVPVEVTLAorICAgICAgICAgICAgICAgIGFhYSBpbnRlZ2VyIFBB VEggJyQuImFhYSInLAorICAgICAgICAgICAgICAgIGFhYTEgaW50ZWdlciBQQVRIICckLiJhYWEi JywKKyAgICAgICAgICAgICAgICBleGlzdHMxIGJvb2xlYW4gRVhJU1RTIFBBVEggJyQuImFhYSIn LAorICAgICAgICAgICAgICAgIGV4aXN0czIgaW50ZWdlciBFWElTVFMgUEFUSCAnJC4iYWFhIicg VFJVRSBPTiBFUlJPUiwKKyAgICAgICAgICAgICAgICBleGlzdHMzIHRleHQgRVhJU1RTIFBBVEgg J3N0cmljdCAkLiJhYWEiJyBVTktOT1dOIE9OIEVSUk9SLAorICAgICAgICAgICAgICAgIGpzMiBq c29uIFBBVEggJyQnLAorICAgICAgICAgICAgICAgIGpzYjJ3IGpzb25iIFBBVEggJyQnIFdJVEgg VU5DT05ESVRJT05BTCBXUkFQUEVSLAorICAgICAgICAgICAgICAgIGpzYjJxIGpzb25iIFBBVEgg JyQnIE9NSVQgUVVPVEVTLAorICAgICAgICAgICAgICAgIGlhIGludGVnZXJbXSBQQVRIICckJywK KyAgICAgICAgICAgICAgICB0YSB0ZXh0W10gUEFUSCAnJCcsCisgICAgICAgICAgICAgICAgamJh IGpzb25iW10gUEFUSCAnJCcsCisgICAgICAgICAgICAgICAgTkVTVEVEIFBBVEggJyRbMV0nIEFT IHAxCisgICAgICAgICAgICAgICAgQ09MVU1OUyAoCisgICAgICAgICAgICAgICAgICAgIGExIGlu dGVnZXIgUEFUSCAnJC4iYTEiJywKKyAgICAgICAgICAgICAgICAgICAgYjEgdGV4dCBQQVRIICck LiJiMSInLAorICAgICAgICAgICAgICAgICAgICBORVNURUQgUEFUSCAnJFsqXScgQVMgInAxIDEi CisgICAgICAgICAgICAgICAgICAgIENPTFVNTlMgKAorICAgICAgICAgICAgICAgICAgICAgICAg YTExIHRleHQgUEFUSCAnJC4iYTExIicKKyAgICAgICAgICAgICAgICAgICAgKQorICAgICAgICAg ICAgICAgICksCisgICAgICAgICAgICAgICAgTkVTVEVEIFBBVEggJyRbMl0nIEFTIHAyCisgICAg ICAgICAgICAgICAgQ09MVU1OUyAoCisgICAgICAgICAgICAgICAgICAgIE5FU1RFRCBQQVRIICck WypdJyBBUyAicDI6MSIKKyAgICAgICAgICAgICAgICAgICAgQ09MVU1OUyAoCisgICAgICAgICAg ICAgICAgICAgICAgICBhMjEgdGV4dCBQQVRIICckLiJhMjEiJworICAgICAgICAgICAgICAgICAg ICApLAorICAgICAgICAgICAgICAgICAgICBORVNURUQgUEFUSCAnJFsqXScgQVMgcDIyCisgICAg ICAgICAgICAgICAgICAgIENPTFVNTlMgKAorICAgICAgICAgICAgICAgICAgICAgICAgYTIyIHRl eHQgUEFUSCAnJC4iYTIyIicKKyAgICAgICAgICAgICAgICAgICAgKQorICAgICAgICAgICAgICAg ICkKKyAgICAgICAgICAgICkKKyAgICAgICAgICAgIFBMQU4gKGpzb25fdGFibGVfcGF0aF8wIE9V VEVSICgocDEgT1VURVIgInAxIDEiKSBVTklPTiAocDIgT1VURVIgKCJwMjoxIiBVTklPTiBwMjIp KSkpCisgICAgICAgICkKK0VYUExBSU4gKENPU1RTIE9GRiwgVkVSQk9TRSkgU0VMRUNUICogRlJP TSBqc29uYl90YWJsZV92aWV3OworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUVVFUlkgUExBTiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAK Ky0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgVGFibGUgRnVuY3Rpb24gU2Nh biBvbiAianNvbl90YWJsZSIKKyAgIE91dHB1dDogImpzb25fdGFibGUiLmlkLCAianNvbl90YWJs ZSIuImludCIsICJqc29uX3RhYmxlIi50ZXh0LCAianNvbl90YWJsZSIuImNoYXIoNCkiLCAianNv bl90YWJsZSIuYm9vbCwgImpzb25fdGFibGUiLiJudW1lcmljIiwgImpzb25fdGFibGUiLmRvbWFp biwgImpzb25fdGFibGUiLmpzLCAianNvbl90YWJsZSIuamIsICJqc29uX3RhYmxlIi5qc3QsICJq c29uX3RhYmxlIi5qc2MsICJqc29uX3RhYmxlIi5qc3YsICJqc29uX3RhYmxlIi5qc2IsICJqc29u X3RhYmxlIi5qc2JxLCAianNvbl90YWJsZSIuYWFhLCAianNvbl90YWJsZSIuYWFhMSwgImpzb25f dGFibGUiLmV4aXN0czEsICJqc29uX3RhYmxlIi5leGlzdHMyLCAianNvbl90YWJsZSIuZXhpc3Rz MywgImpzb25fdGFibGUiLmpzMiwgImpzb25fdGFibGUiLmpzYjJ3LCAianNvbl90YWJsZSIuanNi MnEsICJqc29uX3RhYmxlIi5pYSwgImpzb25fdGFibGUiLnRhLCAianNvbl90YWJsZSIuamJhLCAi anNvbl90YWJsZSIuYTEsICJqc29uX3RhYmxlIi5iMSwgImpzb25fdGFibGUiLmExMSwgImpzb25f dGFibGUiLmEyMSwgImpzb25fdGFibGUiLmEyMgorICAgVGFibGUgRnVuY3Rpb24gQ2FsbDogSlNP Tl9UQUJMRSgnbnVsbCc6Ompzb25iLCAnJFsqXScgQVMganNvbl90YWJsZV9wYXRoXzAgUEFTU0lO RyAzIEFTIGEsICciZm9vIic6Ompzb25iIEFTICJiIGMiIENPTFVNTlMgKGlkIEZPUiBPUkRJTkFM SVRZLCAiaW50IiBpbnRlZ2VyIFBBVEggJyQnLCB0ZXh0IHRleHQgUEFUSCAnJCcsICJjaGFyKDQp IiBjaGFyYWN0ZXIoNCkgUEFUSCAnJCcsIGJvb2wgYm9vbGVhbiBQQVRIICckJywgIm51bWVyaWMi IG51bWVyaWMgUEFUSCAnJCcsIGRvbWFpbiBqc29uYl90ZXN0X2RvbWFpbiBQQVRIICckJywganMg anNvbiBQQVRIICckJywgamIganNvbmIgUEFUSCAnJCcsIGpzdCB0ZXh0IEZPUk1BVCBKU09OIFBB VEggJyQnLCBqc2MgY2hhcmFjdGVyKDQpIEZPUk1BVCBKU09OIFBBVEggJyQnLCBqc3YgY2hhcmFj dGVyIHZhcnlpbmcoNCkgRk9STUFUIEpTT04gUEFUSCAnJCcsIGpzYiBqc29uYiBQQVRIICckJywg anNicSBqc29uYiBQQVRIICckJyBPTUlUIFFVT1RFUywgYWFhIGludGVnZXIgUEFUSCAnJC4iYWFh IicsIGFhYTEgaW50ZWdlciBQQVRIICckLiJhYWEiJywgZXhpc3RzMSBib29sZWFuIEVYSVNUUyBQ QVRIICckLiJhYWEiJywgZXhpc3RzMiBpbnRlZ2VyIEVYSVNUUyBQQVRIICckLiJhYWEiJyBUUlVF IE9OIEVSUk9SLCBleGlzdHMzIHRleHQgRVhJU1RTIFBBVEggJ3N0cmljdCAkLiJhYWEiJyBVTktO T1dOIE9OIEVSUk9SLCBqczIganNvbiBQQVRIICckJywganNiMncganNvbmIgUEFUSCAnJCcgV0lU SCBVTkNPTkRJVElPTkFMIFdSQVBQRVIsIGpzYjJxIGpzb25iIFBBVEggJyQnIE9NSVQgUVVPVEVT LCBpYSBpbnRlZ2VyW10gUEFUSCAnJCcsIHRhIHRleHRbXSBQQVRIICckJywgamJhIGpzb25iW10g UEFUSCAnJCcsIE5FU1RFRCBQQVRIICckWzFdJyBBUyBwMSBDT0xVTU5TIChhMSBpbnRlZ2VyIFBB VEggJyQuImExIicsIGIxIHRleHQgUEFUSCAnJC4iYjEiJywgTkVTVEVEIFBBVEggJyRbKl0nIEFT ICJwMSAxIiBDT0xVTU5TIChhMTEgdGV4dCBQQVRIICckLiJhMTEiJykpLCBORVNURUQgUEFUSCAn JFsyXScgQVMgcDIgQ09MVU1OUyAoIE5FU1RFRCBQQVRIICckWypdJyBBUyAicDI6MSIgQ09MVU1O UyAoYTIxIHRleHQgUEFUSCAnJC4iYTIxIicpLCBORVNURUQgUEFUSCAnJFsqXScgQVMgcDIyIENP TFVNTlMgKGEyMiB0ZXh0IFBBVEggJyQuImEyMiInKSkpIFBMQU4gKGpzb25fdGFibGVfcGF0aF8w IE9VVEVSICgocDEgT1VURVIgInAxIDEiKSBVTklPTiAocDIgT1VURVIgKCJwMjoxIiBVTklPTiBw MjIpKSkpKQorKDMgcm93cykKKworRFJPUCBWSUVXIGpzb25iX3RhYmxlX3ZpZXc7CitEUk9QIERP TUFJTiBqc29uYl90ZXN0X2RvbWFpbjsKKy0tIEpTT05fVEFCTEU6IG9ubHkgb25lIEZPUiBPUkRJ TkFMSVRZIGNvbHVtbnMgYWxsb3dlZAorU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKGpzb25iICcx JywgJyQnIENPTFVNTlMgKGlkIEZPUiBPUkRJTkFMSVRZLCBpZDIgRk9SIE9SRElOQUxJVFksIGEg aW50IFBBVEggJyQuYScgRVJST1IgT04gRU1QVFkpKSBqdDsKK0VSUk9SOiAgY2Fubm90IHVzZSBt b3JlIHRoYW4gb25lIEZPUiBPUkRJTkFMSVRZIGNvbHVtbgorTElORSAxOiAuLi5fVEFCTEUoanNv bmIgJzEnLCAnJCcgQ09MVU1OUyAoaWQgRk9SIE9SRElOQUxJVFksIGlkMiBGT1IgT1IuLi4KKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBeCitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoanNvbmIgJzEnLCAnJCcgQ09MVU1OUyAoaWQg Rk9SIE9SRElOQUxJVFksIGEgaW50IFBBVEggJyQnIEVSUk9SIE9OIEVNUFRZKSkganQ7CisgaWQg fCBhIAorLS0tLSstLS0KKyAgMSB8IDEKKygxIHJvdykKKworLS0gSlNPTl9UQUJMRTogT04gRU1Q VFkvT04gRVJST1IgYmVoYXZpb3IKK1NFTEVDVCAqCitGUk9NCisJKFZBTFVFUyAoJzEnKSwgKCci ZXJyIicpKSB2YWxzKGpzKSwKKwlKU09OX1RBQkxFKHZhbHMuanM6Ompzb25iLCAnJCcgQ09MVU1O UyAoYSBpbnQgUEFUSCAnJCcpKSBqdDsKKyAganMgICB8IGEgCistLS0tLS0tKy0tLQorIDEgICAg IHwgMQorICJlcnIiIHwgIAorKDIgcm93cykKKworU0VMRUNUICoKK0ZST00KKwkoVkFMVUVTICgn MScpLCAoJyJlcnIiJykpIHZhbHMoanMpCisJCUxFRlQgT1VURVIgSk9JTgorCUpTT05fVEFCTEUo dmFscy5qczo6anNvbmIsICckJyBDT0xVTU5TIChhIGludCBQQVRIICckJykgRVJST1IgT04gRVJS T1IpIGp0CisJCU9OIHRydWU7CitFUlJPUjogIGludmFsaWQgaW5wdXQgc3ludGF4IGZvciB0eXBl IGludGVnZXI6ICJlcnIiCitTRUxFQ1QgKgorRlJPTQorCShWQUxVRVMgKCcxJyksICgnImVyciIn KSkgdmFscyhqcykKKwkJTEVGVCBPVVRFUiBKT0lOCisJSlNPTl9UQUJMRSh2YWxzLmpzOjpqc29u YiwgJyQnIENPTFVNTlMgKGEgaW50IFBBVEggJyQnIEVSUk9SIE9OIEVSUk9SKSkganQKKwkJT04g dHJ1ZTsKK0VSUk9SOiAgaW52YWxpZCBpbnB1dCBzeW50YXggZm9yIHR5cGUgaW50ZWdlcjogImVy ciIKK1NFTEVDVCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAnMScsICckJyBDT0xVTU5TIChhIGlu dCBQQVRIICckLmEnIEVSUk9SIE9OIEVNUFRZKSkganQ7CitFUlJPUjogIG5vIFNRTC9KU09OIGl0 ZW0KK1NFTEVDVCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAnMScsICckJyBDT0xVTU5TIChhIGlu dCBQQVRIICdzdHJpY3QgJC5hJyBFUlJPUiBPTiBFTVBUWSkgRVJST1IgT04gRVJST1IpIGp0Owor RVJST1I6ICBqc29ucGF0aCBtZW1iZXIgYWNjZXNzb3IgY2FuIG9ubHkgYmUgYXBwbGllZCB0byBh biBvYmplY3QKK1NFTEVDVCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAnMScsICckJyBDT0xVTU5T IChhIGludCBQQVRIICdsYXggJC5hJyBFUlJPUiBPTiBFTVBUWSkgRVJST1IgT04gRVJST1IpIGp0 OworRVJST1I6ICBubyBTUUwvSlNPTiBpdGVtCitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoanNv bmIgJyJhIicsICckJyBDT0xVTU5TIChhIGludCBQQVRIICckJyAgIERFRkFVTFQgMSBPTiBFTVBU WSBERUZBVUxUIDIgT04gRVJST1IpKSBqdDsKKyBhIAorLS0tCisgMgorKDEgcm93KQorCitTRUxF Q1QgKiBGUk9NIEpTT05fVEFCTEUoanNvbmIgJyJhIicsICckJyBDT0xVTU5TIChhIGludCBQQVRI ICdzdHJpY3QgJC5hJyBERUZBVUxUIDEgT04gRU1QVFkgREVGQVVMVCAyIE9OIEVSUk9SKSkganQ7 CisgYSAKKy0tLQorIDIKKygxIHJvdykKKworU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKGpzb25i ICciYSInLCAnJCcgQ09MVU1OUyAoYSBpbnQgUEFUSCAnbGF4ICQuYScgREVGQVVMVCAxIE9OIEVN UFRZIERFRkFVTFQgMiBPTiBFUlJPUikpIGp0OworIGEgCistLS0KKyAxCisoMSByb3cpCisKKy0t IEpTT05fVEFCTEU6IEVYSVNUUyBQQVRIIHR5cGVzCitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUo anNvbmIgJyJhIicsICckJyBDT0xVTU5TIChhIGludDQgRVhJU1RTIFBBVEggJyQuYScpKTsKKyBh IAorLS0tCisgMAorKDEgcm93KQorCitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoanNvbmIgJyJh IicsICckJyBDT0xVTU5TIChhIGludDIgRVhJU1RTIFBBVEggJyQuYScpKTsKK0VSUk9SOiAgY2Fu bm90IGNhc3QgdHlwZSBib29sZWFuIHRvIHNtYWxsaW50CitMSU5FIDE6IC4uLkVMRUNUICogRlJP TSBKU09OX1RBQkxFKGpzb25iICciYSInLCAnJCcgQ09MVU1OUyAoYSBpbnQyIEVYSS4uLgorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IF4KK1NFTEVDVCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAnImEiJywgJyQnIENPTFVNTlMgKGEg aW50OCBFWElTVFMgUEFUSCAnJC5hJykpOworRVJST1I6ICBjYW5ub3QgY2FzdCB0eXBlIGJvb2xl YW4gdG8gYmlnaW50CitMSU5FIDE6IC4uLkVMRUNUICogRlJPTSBKU09OX1RBQkxFKGpzb25iICci YSInLCAnJCcgQ09MVU1OUyAoYSBpbnQ4IEVYSS4uLgorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIF4KK1NFTEVDVCAqIEZST00gSlNP Tl9UQUJMRShqc29uYiAnImEiJywgJyQnIENPTFVNTlMgKGEgZmxvYXQ0IEVYSVNUUyBQQVRIICck LmEnKSk7CitFUlJPUjogIGNhbm5vdCBjYXN0IHR5cGUgYm9vbGVhbiB0byByZWFsCitMSU5FIDE6 IC4uLkVMRUNUICogRlJPTSBKU09OX1RBQkxFKGpzb25iICciYSInLCAnJCcgQ09MVU1OUyAoYSBm bG9hdDQgRS4uLgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIF4KK1NFTEVDVCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAnImEiJywg JyQnIENPTFVNTlMgKGEgY2hhcigzKSBFWElTVFMgUEFUSCAnJC5hJykpOworICBhICAKKy0tLS0t CisgZmFsCisoMSByb3cpCisKK1NFTEVDVCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAnImEiJywg JyQnIENPTFVNTlMgKGEganNvbiBFWElTVFMgUEFUSCAnJC5hJykpOworRVJST1I6ICBjYW5ub3Qg Y2FzdCB0eXBlIGJvb2xlYW4gdG8ganNvbgorTElORSAxOiAuLi5FTEVDVCAqIEZST00gSlNPTl9U QUJMRShqc29uYiAnImEiJywgJyQnIENPTFVNTlMgKGEganNvbiBFWEkuLi4KKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBeCitTRUxF Q1QgKiBGUk9NIEpTT05fVEFCTEUoanNvbmIgJyJhIicsICckJyBDT0xVTU5TIChhIGpzb25iIEVY SVNUUyBQQVRIICckLmEnKSk7CitFUlJPUjogIGNhbm5vdCBjYXN0IHR5cGUgYm9vbGVhbiB0byBq c29uYgorTElORSAxOiAuLi5FTEVDVCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAnImEiJywgJyQn IENPTFVNTlMgKGEganNvbmIgRVguLi4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBeCistLSBKU09OX1RBQkxFOiBXUkFQUEVSL1FV T1RFUyBjbGF1c2VzIG9uIHNjYWxhciBjb2x1bW5zCitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUo anNvbmIgJyJ3b3JsZCInLCAnJCcgQ09MVU1OUyAoaXRlbSB0ZXh0IFBBVEggJyQnIEtFRVAgUVVP VEVTIE9OIFNDQUxBUiBTVFJJTkcpKTsKKyAgaXRlbSAgIAorLS0tLS0tLS0tCisgIndvcmxkIgor KDEgcm93KQorCitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoanNvbmIgJyJ3b3JsZCInLCAnJCcg Q09MVU1OUyAoaXRlbSB0ZXh0IFBBVEggJyQnIE9NSVQgUVVPVEVTIE9OIFNDQUxBUiBTVFJJTkcp KTsKKyBpdGVtICAKKy0tLS0tLS0KKyB3b3JsZAorKDEgcm93KQorCitTRUxFQ1QgKiBGUk9NIEpT T05fVEFCTEUoanNvbmIgJyJ3b3JsZCInLCAnJCcgQ09MVU1OUyAoaXRlbSB0ZXh0IEZPUk1BVCBK U09OIFBBVEggJyQnIEtFRVAgUVVPVEVTKSk7CisgIGl0ZW0gICAKKy0tLS0tLS0tLQorICJ3b3Js ZCIKKygxIHJvdykKKworU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKGpzb25iICcid29ybGQiJywg JyQnIENPTFVNTlMgKGl0ZW0gdGV4dCBGT1JNQVQgSlNPTiBQQVRIICckJyBPTUlUIFFVT1RFUykp OworIGl0ZW0gIAorLS0tLS0tLQorIHdvcmxkCisoMSByb3cpCisKK1NFTEVDVCAqIEZST00gSlNP Tl9UQUJMRShqc29uYiAnIndvcmxkIicsICckJyBDT0xVTU5TIChpdGVtIHRleHQgRk9STUFUIEpT T04gUEFUSCAnJCcgV0lUSE9VVCBXUkFQUEVSIEtFRVAgUVVPVEVTKSk7CisgIGl0ZW0gICAKKy0t LS0tLS0tLQorICJ3b3JsZCIKKygxIHJvdykKKworU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKGpz b25iICcid29ybGQiJywgJyQnIENPTFVNTlMgKGl0ZW0gdGV4dCBQQVRIICckJyBXSVRIT1VUIFdS QVBQRVIgT01JVCBRVU9URVMpKTsKKyBpdGVtICAKKy0tLS0tLS0KKyB3b3JsZAorKDEgcm93KQor CitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoanNvbmIgJyJ3b3JsZCInLCAnJCcgQ09MVU1OUyAo aXRlbSB0ZXh0IEZPUk1BVCBKU09OIFBBVEggJyQnIFdJVEggV1JBUFBFUikpOworICAgaXRlbSAg ICAKKy0tLS0tLS0tLS0tCisgWyJ3b3JsZCJdCisoMSByb3cpCisKKy0tIEVycm9yOiBRVU9URVMg Y2xhdXNlIG1lYW5pbmdsZXNzIHdoZW4gV0lUSCBXUkFQUEVSIGlzIHByZXNlbnQKK1NFTEVDVCAq IEZST00gSlNPTl9UQUJMRShqc29uYiAnIndvcmxkIicsICckJyBDT0xVTU5TIChpdGVtIHRleHQg Rk9STUFUIEpTT04gUEFUSCAnJCcgV0lUSCBXUkFQUEVSIEtFRVAgUVVPVEVTKSk7CitFUlJPUjog IFNRTC9KU09OIFFVT1RFUyBiZWhhdmlvciBtdXN0IG5vdCBiZSBzcGVjaWZpZWQgd2hlbiBXSVRI IFdSQVBQRVIgaXMgdXNlZAorTElORSAxOiAuLi5UICogRlJPTSBKU09OX1RBQkxFKGpzb25iICci d29ybGQiJywgJyQnIENPTFVNTlMgKGl0ZW0gdGV4dCAuLi4KKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBeCitTRUxFQ1QgKiBGUk9N IEpTT05fVEFCTEUoanNvbmIgJyJ3b3JsZCInLCAnJCcgQ09MVU1OUyAoaXRlbSB0ZXh0IFBBVEgg JyQnIFdJVEggV1JBUFBFUiBPTUlUIFFVT1RFUykpOworRVJST1I6ICBTUUwvSlNPTiBRVU9URVMg YmVoYXZpb3IgbXVzdCBub3QgYmUgc3BlY2lmaWVkIHdoZW4gV0lUSCBXUkFQUEVSIGlzIHVzZWQK K0xJTkUgMTogLi4uVCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAnIndvcmxkIicsICckJyBDT0xV TU5TIChpdGVtIHRleHQgLi4uCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgXgorLS0gSlNPTl9UQUJMRTogbmVzdGVkIHBhdGhzIGFu ZCBwbGFucworLS0gU2hvdWxkIGZhaWwgKEpTT05fVEFCTEUgY29sdW1ucyBtdXN0IGNvbnRhaW4g ZXhwbGljaXQgQVMgcGF0aAorLS0gc3BlY2lmaWNhdGlvbnMgaWYgZXhwbGljaXQgUExBTiBjbGF1 c2UgaXMgdXNlZCkKK1NFTEVDVCAqIEZST00gSlNPTl9UQUJMRSgKKwlqc29uYiAnW10nLCAnJCcg LS0gQVMgPHBhdGggbmFtZT4gcmVxdWlyZWQgaGVyZQorCUNPTFVNTlMgKAorCQlmb28gaW50IFBB VEggJyQnCisJKQorCVBMQU4gREVGQVVMVCAoVU5JT04pCispIGp0OworRVJST1I6ICBpbnZhbGlk IEpTT05fVEFCTEUgZXhwcmVzc2lvbgorTElORSAyOiAganNvbmIgJ1tdJywgJyQnIC0tIEFTIDxw YXRoIG5hbWU+IHJlcXVpcmVkIGhlcmUKKyAgICAgICAgICAgICAgICAgICAgIF4KK0RFVEFJTDog IEpTT05fVEFCTEUgcGF0aCBtdXN0IGNvbnRhaW4gZXhwbGljaXQgQVMgcGF0aG5hbWUgc3BlY2lm aWNhdGlvbiBpZiBleHBsaWNpdCBQTEFOIGNsYXVzZSBpcyB1c2VkCitTRUxFQ1QgKiBGUk9NIEpT T05fVEFCTEUoCisJanNvbmIgJ1tdJywgJyQnIEFTIHBhdGgxCisJQ09MVU1OUyAoCisJCU5FU1RF RCBQQVRIICckJyBDT0xVTU5TICggLS0gQVMgPHBhdGggbmFtZT4gcmVxdWlyZWQgaGVyZQorCQkJ Zm9vIGludCBQQVRIICckJworCQkpCisJKQorCVBMQU4gREVGQVVMVCAoVU5JT04pCispIGp0Owor RVJST1I6ICBpbnZhbGlkIEpTT05fVEFCTEUgZXhwcmVzc2lvbgorTElORSA0OiAgIE5FU1RFRCBQ QVRIICckJyBDT0xVTU5TICggLS0gQVMgPHBhdGggbmFtZT4gcmVxdWlyZWQgaGVyZQorICAgICAg ICAgIF4KK0RFVEFJTDogIEpTT05fVEFCTEUgcGF0aCBtdXN0IGNvbnRhaW4gZXhwbGljaXQgQVMg cGF0aG5hbWUgc3BlY2lmaWNhdGlvbiBpZiBleHBsaWNpdCBQTEFOIGNsYXVzZSBpcyB1c2VkCist LSBTaG91bGQgZmFpbCAoY29sdW1uIG5hbWVzIG11c3QgYmUgZGlzdGluY3QpCitTRUxFQ1QgKiBG Uk9NIEpTT05fVEFCTEUoCisJanNvbmIgJ1tdJywgJyQnIEFTIGEKKwlDT0xVTU5TICgKKwkJYSBp bnQKKwkpCispIGp0OworRVJST1I6ICBkdXBsaWNhdGUgSlNPTl9UQUJMRSBjb2x1bW4gbmFtZTog YQorTElORSA0OiAgIGEgaW50CisgICAgICAgICAgXgorU0VMRUNUICogRlJPTSBKU09OX1RBQkxF KAorCWpzb25iICdbXScsICckJyBBUyBhCisJQ09MVU1OUyAoCisJCWIgaW50LAorCQlORVNURUQg UEFUSCAnJCcgQVMgYQorCQlDT0xVTU5TICgKKwkJCWMgaW50CisJCSkKKwkpCispIGp0OworRVJS T1I6ICBkdXBsaWNhdGUgSlNPTl9UQUJMRSBwYXRoIG5hbWU6IGEKK0xJTkUgNTogICBORVNURUQg UEFUSCAnJCcgQVMgYQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBeCitTRUxFQ1QgKiBG Uk9NIEpTT05fVEFCTEUoCisJanNvbmIgJ1tdJywgJyQnCisJQ09MVU1OUyAoCisJCWIgaW50LAor CQlORVNURUQgUEFUSCAnJCcgQVMgYgorCQlDT0xVTU5TICgKKwkJCWMgaW50CisJCSkKKwkpCisp IGp0OworRVJST1I6ICBkdXBsaWNhdGUgSlNPTl9UQUJMRSBwYXRoIG5hbWU6IGIKK0xJTkUgNTog ICBORVNURUQgUEFUSCAnJCcgQVMgYgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBeCitT RUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoCisJanNvbmIgJ1tdJywgJyQnCisJQ09MVU1OUyAoCisJ CU5FU1RFRCBQQVRIICckJyBBUyBhCisJCUNPTFVNTlMgKAorCQkJYiBpbnQKKwkJKSwKKwkJTkVT VEVEIFBBVEggJyQnCisJCUNPTFVNTlMgKAorCQkJTkVTVEVEIFBBVEggJyQnIEFTIGEKKwkJCUNP TFVNTlMgKAorCQkJCWMgaW50CisJCQkpCisJCSkKKwkpCispIGp0OworRVJST1I6ICBkdXBsaWNh dGUgSlNPTl9UQUJMRSBwYXRoIG5hbWU6IGEKK0xJTkUgMTA6ICAgIE5FU1RFRCBQQVRIICckJyBB UyBhCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXgorLS0gSlNPTl9UQUJMRTogcGxh biB2YWxpZGF0aW9uCitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoCisJanNvbmIgJ251bGwnLCAn JFsqXScgQVMgcDAKKwlDT0xVTU5TICgKKwkJTkVTVEVEICckJyBBUyBwMSBDT0xVTU5TICgKKwkJ CU5FU1RFRCBQQVRIICckJyBBUyBwMTEgQ09MVU1OUyAoIGZvbyBpbnQgKSwKKwkJCU5FU1RFRCBQ QVRIICckJyBBUyBwMTIgQ09MVU1OUyAoIGJhciBpbnQgKQorCQkpLAorCQlORVNURUQgUEFUSCAn JCcgQVMgcDIgQ09MVU1OUyAoCisJCQlORVNURUQgUEFUSCAnJCcgQVMgcDIxIENPTFVNTlMgKCBi YXogaW50ICkKKwkJKQorCSkKKwlQTEFOIChwMSkKKykganQ7CitFUlJPUjogIGludmFsaWQgSlNP Tl9UQUJMRSBwbGFuCitMSU5FIDEyOiAgUExBTiAocDEpCisgICAgICAgICAgICAgICAgXgorREVU QUlMOiAgUEFUSCBuYW1lIG1pc21hdGNoOiBleHBlY3RlZCBwMCBidXQgcDEgaXMgZ2l2ZW4uCitT RUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoCisJanNvbmIgJ251bGwnLCAnJFsqXScgQVMgcDAKKwlD T0xVTU5TICgKKwkJTkVTVEVEIFBBVEggJyQnIEFTIHAxIENPTFVNTlMgKAorCQkJTkVTVEVEIFBB VEggJyQnIEFTIHAxMSBDT0xVTU5TICggZm9vIGludCApLAorCQkJTkVTVEVEIFBBVEggJyQnIEFT IHAxMiBDT0xVTU5TICggYmFyIGludCApCisJCSksCisJCU5FU1RFRCBQQVRIICckJyBBUyBwMiBD T0xVTU5TICgKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMjEgQ09MVU1OUyAoIGJheiBpbnQgKQor CQkpCisJKQorCVBMQU4gKHAwKQorKSBqdDsKK0VSUk9SOiAgaW52YWxpZCBKU09OX1RBQkxFIHNw ZWNpZmljYXRpb24KK0xJTkUgNDogICBORVNURUQgUEFUSCAnJCcgQVMgcDEgQ09MVU1OUyAoCisg ICAgICAgICAgXgorREVUQUlMOiAgUExBTiBjbGF1c2UgZm9yIG5lc3RlZCBwYXRoIHAxIHdhcyBu b3QgZm91bmQuCitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoCisJanNvbmIgJ251bGwnLCAnJFsq XScgQVMgcDAKKwlDT0xVTU5TICgKKwkJTkVTVEVEIFBBVEggJyQnIEFTIHAxIENPTFVNTlMgKAor CQkJTkVTVEVEIFBBVEggJyQnIEFTIHAxMSBDT0xVTU5TICggZm9vIGludCApLAorCQkJTkVTVEVE IFBBVEggJyQnIEFTIHAxMiBDT0xVTU5TICggYmFyIGludCApCisJCSksCisJCU5FU1RFRCBQQVRI ICckJyBBUyBwMiBDT0xVTU5TICgKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMjEgQ09MVU1OUyAo IGJheiBpbnQgKQorCQkpCisJKQorCVBMQU4gKHAwIE9VVEVSIHAzKQorKSBqdDsKK0VSUk9SOiAg aW52YWxpZCBKU09OX1RBQkxFIHNwZWNpZmljYXRpb24KK0xJTkUgNDogICBORVNURUQgUEFUSCAn JCcgQVMgcDEgQ09MVU1OUyAoCisgICAgICAgICAgXgorREVUQUlMOiAgUExBTiBjbGF1c2UgZm9y IG5lc3RlZCBwYXRoIHAxIHdhcyBub3QgZm91bmQuCitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUo CisJanNvbmIgJ251bGwnLCAnJFsqXScgQVMgcDAKKwlDT0xVTU5TICgKKwkJTkVTVEVEIFBBVEgg JyQnIEFTIHAxIENPTFVNTlMgKAorCQkJTkVTVEVEIFBBVEggJyQnIEFTIHAxMSBDT0xVTU5TICgg Zm9vIGludCApLAorCQkJTkVTVEVEIFBBVEggJyQnIEFTIHAxMiBDT0xVTU5TICggYmFyIGludCAp CisJCSksCisJCU5FU1RFRCBQQVRIICckJyBBUyBwMiBDT0xVTU5TICgKKwkJCU5FU1RFRCBQQVRI ICckJyBBUyBwMjEgQ09MVU1OUyAoIGJheiBpbnQgKQorCQkpCisJKQorCVBMQU4gKHAwIFVOSU9O IHAxIFVOSU9OIHAxMSkKKykganQ7CitFUlJPUjogIGludmFsaWQgSlNPTl9UQUJMRSBwbGFuIGNs YXVzZQorTElORSAxMjogIFBMQU4gKHAwIFVOSU9OIHAxIFVOSU9OIHAxMSkKKyAgICAgICAgICAg ICAgICBeCitERVRBSUw6ICBFeHBlY3RlZCBJTk5FUiBvciBPVVRFUi4KK1NFTEVDVCAqIEZST00g SlNPTl9UQUJMRSgKKwlqc29uYiAnbnVsbCcsICckWypdJyBBUyBwMAorCUNPTFVNTlMgKAorCQlO RVNURUQgUEFUSCAnJCcgQVMgcDEgQ09MVU1OUyAoCisJCQlORVNURUQgUEFUSCAnJCcgQVMgcDEx IENPTFVNTlMgKCBmb28gaW50ICksCisJCQlORVNURUQgUEFUSCAnJCcgQVMgcDEyIENPTFVNTlMg KCBiYXIgaW50ICkKKwkJKSwKKwkJTkVTVEVEIFBBVEggJyQnIEFTIHAyIENPTFVNTlMgKAorCQkJ TkVTVEVEIFBBVEggJyQnIEFTIHAyMSBDT0xVTU5TICggYmF6IGludCApCisJCSkKKwkpCisJUExB TiAocDAgT1VURVIgKHAxIENST1NTIHAxMykpCispIGp0OworRVJST1I6ICBpbnZhbGlkIEpTT05f VEFCTEUgc3BlY2lmaWNhdGlvbgorTElORSA4OiAgIE5FU1RFRCBQQVRIICckJyBBUyBwMiBDT0xV TU5TICgKKyAgICAgICAgICBeCitERVRBSUw6ICBQTEFOIGNsYXVzZSBmb3IgbmVzdGVkIHBhdGgg cDIgd2FzIG5vdCBmb3VuZC4KK1NFTEVDVCAqIEZST00gSlNPTl9UQUJMRSgKKwlqc29uYiAnbnVs bCcsICckWypdJyBBUyBwMAorCUNPTFVNTlMgKAorCQlORVNURUQgUEFUSCAnJCcgQVMgcDEgQ09M VU1OUyAoCisJCQlORVNURUQgUEFUSCAnJCcgQVMgcDExIENPTFVNTlMgKCBmb28gaW50ICksCisJ CQlORVNURUQgUEFUSCAnJCcgQVMgcDEyIENPTFVNTlMgKCBiYXIgaW50ICkKKwkJKSwKKwkJTkVT VEVEIFBBVEggJyQnIEFTIHAyIENPTFVNTlMgKAorCQkJTkVTVEVEIFBBVEggJyQnIEFTIHAyMSBD T0xVTU5TICggYmF6IGludCApCisJCSkKKwkpCisJUExBTiAocDAgT1VURVIgKHAxIENST1NTIHAy KSkKKykganQ7CitFUlJPUjogIGludmFsaWQgSlNPTl9UQUJMRSBzcGVjaWZpY2F0aW9uCitMSU5F IDU6ICAgIE5FU1RFRCBQQVRIICckJyBBUyBwMTEgQ09MVU1OUyAoIGZvbyBpbnQgKSwKKyAgICAg ICAgICAgXgorREVUQUlMOiAgUExBTiBjbGF1c2UgZm9yIG5lc3RlZCBwYXRoIHAxMSB3YXMgbm90 IGZvdW5kLgorU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKAorCWpzb25iICdudWxsJywgJyRbKl0n IEFTIHAwCisJQ09MVU1OUyAoCisJCU5FU1RFRCBQQVRIICckJyBBUyBwMSBDT0xVTU5TICgKKwkJ CU5FU1RFRCBQQVRIICckJyBBUyBwMTEgQ09MVU1OUyAoIGZvbyBpbnQgKSwKKwkJCU5FU1RFRCBQ QVRIICckJyBBUyBwMTIgQ09MVU1OUyAoIGJhciBpbnQgKQorCQkpLAorCQlORVNURUQgUEFUSCAn JCcgQVMgcDIgQ09MVU1OUyAoCisJCQlORVNURUQgUEFUSCAnJCcgQVMgcDIxIENPTFVNTlMgKCBi YXogaW50ICkKKwkJKQorCSkKKwlQTEFOIChwMCBPVVRFUiAoKHAxIFVOSU9OIHAxMSkgQ1JPU1Mg cDIpKQorKSBqdDsKK0VSUk9SOiAgaW52YWxpZCBKU09OX1RBQkxFIHBsYW4gY2xhdXNlCitMSU5F IDEyOiAgUExBTiAocDAgT1VURVIgKChwMSBVTklPTiBwMTEpIENST1NTIHAyKSkKKyAgICAgICAg ICAgICAgICAgICAgICAgICBeCitERVRBSUw6ICBQTEFOIGNsYXVzZSBjb250YWlucyBzb21lIGV4 dHJhIG9yIGR1cGxpY2F0ZSBzaWJsaW5nIG5vZGVzLgorU0VMRUNUICogRlJPTSBKU09OX1RBQkxF KAorCWpzb25iICdudWxsJywgJyRbKl0nIEFTIHAwCisJQ09MVU1OUyAoCisJCU5FU1RFRCBQQVRI ICckJyBBUyBwMSBDT0xVTU5TICgKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMTEgQ09MVU1OUyAo IGZvbyBpbnQgKSwKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMTIgQ09MVU1OUyAoIGJhciBpbnQg KQorCQkpLAorCQlORVNURUQgUEFUSCAnJCcgQVMgcDIgQ09MVU1OUyAoCisJCQlORVNURUQgUEFU SCAnJCcgQVMgcDIxIENPTFVNTlMgKCBiYXogaW50ICkKKwkJKQorCSkKKwlQTEFOIChwMCBPVVRF UiAoKHAxIElOTkVSIHAxMSkgQ1JPU1MgcDIpKQorKSBqdDsKK0VSUk9SOiAgaW52YWxpZCBKU09O X1RBQkxFIHNwZWNpZmljYXRpb24KK0xJTkUgNjogICAgTkVTVEVEIFBBVEggJyQnIEFTIHAxMiBD T0xVTU5TICggYmFyIGludCApCisgICAgICAgICAgIF4KK0RFVEFJTDogIFBMQU4gY2xhdXNlIGZv ciBuZXN0ZWQgcGF0aCBwMTIgd2FzIG5vdCBmb3VuZC4KK1NFTEVDVCAqIEZST00gSlNPTl9UQUJM RSgKKwlqc29uYiAnbnVsbCcsICckWypdJyBBUyBwMAorCUNPTFVNTlMgKAorCQlORVNURUQgUEFU SCAnJCcgQVMgcDEgQ09MVU1OUyAoCisJCQlORVNURUQgUEFUSCAnJCcgQVMgcDExIENPTFVNTlMg KCBmb28gaW50ICksCisJCQlORVNURUQgUEFUSCAnJCcgQVMgcDEyIENPTFVNTlMgKCBiYXIgaW50 ICkKKwkJKSwKKwkJTkVTVEVEIFBBVEggJyQnIEFTIHAyIENPTFVNTlMgKAorCQkJTkVTVEVEIFBB VEggJyQnIEFTIHAyMSBDT0xVTU5TICggYmF6IGludCApCisJCSkKKwkpCisJUExBTiAocDAgT1VU RVIgKChwMSBJTk5FUiAocDEyIENST1NTIHAxMSkpIENST1NTIHAyKSkKKykganQ7CitFUlJPUjog IGludmFsaWQgSlNPTl9UQUJMRSBzcGVjaWZpY2F0aW9uCitMSU5FIDk6ICAgIE5FU1RFRCBQQVRI ICckJyBBUyBwMjEgQ09MVU1OUyAoIGJheiBpbnQgKQorICAgICAgICAgICBeCitERVRBSUw6ICBQ TEFOIGNsYXVzZSBmb3IgbmVzdGVkIHBhdGggcDIxIHdhcyBub3QgZm91bmQuCitTRUxFQ1QgKiBG Uk9NIEpTT05fVEFCTEUoCisJanNvbmIgJ251bGwnLCAnc3RyaWN0ICRbKl0nIEFTIHAwCisJQ09M VU1OUyAoCisJCU5FU1RFRCBQQVRIICckJyBBUyBwMSBDT0xVTU5TICgKKwkJCU5FU1RFRCBQQVRI ICckJyBBUyBwMTEgQ09MVU1OUyAoIGZvbyBpbnQgKSwKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBw MTIgQ09MVU1OUyAoIGJhciBpbnQgKQorCQkpLAorCQlORVNURUQgUEFUSCAnJCcgQVMgcDIgQ09M VU1OUyAoCisJCQlORVNURUQgUEFUSCAnJCcgQVMgcDIxIENPTFVNTlMgKCBiYXogaW50ICkKKwkJ KQorCSkKKwlQTEFOIChwMCBPVVRFUiAoKHAxIElOTkVSIChwMTIgQ1JPU1MgcDExKSkgQ1JPU1Mg KHAyIElOTkVSIHAyMSkpKQorKSBqdDsKKyBiYXIgfCBmb28gfCBiYXogCistLS0tLSstLS0tLSst LS0tLQorKDAgcm93cykKKworU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKAorCWpzb25iICdudWxs JywgJ3N0cmljdCAkWypdJyAtLSB3aXRob3V0IHJvb3QgcGF0aCBuYW1lCisJQ09MVU1OUyAoCisJ CU5FU1RFRCBQQVRIICckJyBBUyBwMSBDT0xVTU5TICgKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBw MTEgQ09MVU1OUyAoIGZvbyBpbnQgKSwKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMTIgQ09MVU1O UyAoIGJhciBpbnQgKQorCQkpLAorCQlORVNURUQgUEFUSCAnJCcgQVMgcDIgQ09MVU1OUyAoCisJ CQlORVNURUQgUEFUSCAnJCcgQVMgcDIxIENPTFVNTlMgKCBiYXogaW50ICkKKwkJKQorCSkKKwlQ TEFOICgocDEgSU5ORVIgKHAxMiBDUk9TUyBwMTEpKSBDUk9TUyAocDIgSU5ORVIgcDIxKSkKKykg anQ7CitFUlJPUjogIGludmFsaWQgSlNPTl9UQUJMRSBleHByZXNzaW9uCitMSU5FIDI6ICBqc29u YiAnbnVsbCcsICdzdHJpY3QgJFsqXScgLS0gd2l0aG91dCByb290IHBhdGggbmFtZQorICAgICAg ICAgICAgICAgICAgICAgICBeCitERVRBSUw6ICBKU09OX1RBQkxFIHBhdGggbXVzdCBjb250YWlu IGV4cGxpY2l0IEFTIHBhdGhuYW1lIHNwZWNpZmljYXRpb24gaWYgZXhwbGljaXQgUExBTiBjbGF1 c2UgaXMgdXNlZAorLS0gSlNPTl9UQUJMRTogcGxhbiBleGVjdXRpb24KK0NSRUFURSBURU1QIFRB QkxFIGpzb25iX3RhYmxlX3Rlc3QgKGpzIGpzb25iKTsKK0lOU0VSVCBJTlRPIGpzb25iX3RhYmxl X3Rlc3QKK1ZBTFVFUyAoCisJJ1sKKwkJeyJhIjogIDEsICAiYiI6IFtdLCAiYyI6IFtdfSwKKwkJ eyJhIjogIDIsICAiYiI6IFsxLCAyLCAzXSwgImMiOiBbMTAsIG51bGwsIDIwXX0sCisJCXsiYSI6 ICAzLCAgImIiOiBbMSwgMl0sICJjIjogW119LAorCQl7IngiOiAiNCIsICJiIjogWzEsIDJdLCAi YyI6IDEyM30KKwkgXScKKyk7CistLSB1bnNwZWNpZmllZCBwbGFuIChvdXRlciwgdW5pb24pCitz ZWxlY3QKKwlqdC4qCitmcm9tCisJanNvbmJfdGFibGVfdGVzdCBqdHQsCisJanNvbl90YWJsZSAo CisJCWp0dC5qcywnc3RyaWN0ICRbKl0nIGFzIHAKKwkJY29sdW1ucyAoCisJCQluIGZvciBvcmRp bmFsaXR5LAorCQkJYSBpbnQgcGF0aCAnbGF4ICQuYScgZGVmYXVsdCAtMSBvbiBlbXB0eSwKKwkJ CW5lc3RlZCBwYXRoICdzdHJpY3QgJC5iWypdJyBhcyBwYiBjb2x1bW5zICggYiBpbnQgcGF0aCAn JCcgKSwKKwkJCW5lc3RlZCBwYXRoICdzdHJpY3QgJC5jWypdJyBhcyBwYyBjb2x1bW5zICggYyBp bnQgcGF0aCAnJCcgKQorCQkpCisJKSBqdDsKKyBuIHwgYSAgfCBiIHwgYyAgCistLS0rLS0tLSst LS0rLS0tLQorIDEgfCAgMSB8ICAgfCAgIAorIDIgfCAgMiB8IDEgfCAgIAorIDIgfCAgMiB8IDIg fCAgIAorIDIgfCAgMiB8IDMgfCAgIAorIDIgfCAgMiB8ICAgfCAxMAorIDIgfCAgMiB8ICAgfCAg IAorIDIgfCAgMiB8ICAgfCAyMAorIDMgfCAgMyB8IDEgfCAgIAorIDMgfCAgMyB8IDIgfCAgIAor IDQgfCAtMSB8IDEgfCAgIAorIDQgfCAtMSB8IDIgfCAgIAorKDExIHJvd3MpCisKKy0tIGRlZmF1 bHQgcGxhbiAob3V0ZXIsIHVuaW9uKQorc2VsZWN0CisJanQuKgorZnJvbQorCWpzb25iX3RhYmxl X3Rlc3QganR0LAorCWpzb25fdGFibGUgKAorCQlqdHQuanMsJ3N0cmljdCAkWypdJyBhcyBwCisJ CWNvbHVtbnMgKAorCQkJbiBmb3Igb3JkaW5hbGl0eSwKKwkJCWEgaW50IHBhdGggJ2xheCAkLmEn IGRlZmF1bHQgLTEgb24gZW1wdHksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQuYlsqXScgYXMg cGIgY29sdW1ucyAoIGIgaW50IHBhdGggJyQnICksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQu Y1sqXScgYXMgcGMgY29sdW1ucyAoIGMgaW50IHBhdGggJyQnICkKKwkJKQorCQlwbGFuIGRlZmF1 bHQgKG91dGVyLCB1bmlvbikKKwkpIGp0OworIG4gfCBhICB8IGIgfCBjICAKKy0tLSstLS0tKy0t LSstLS0tCisgMSB8ICAxIHwgICB8ICAgCisgMiB8ICAyIHwgMSB8IDEwCisgMiB8ICAyIHwgMSB8 ICAgCisgMiB8ICAyIHwgMSB8IDIwCisgMiB8ICAyIHwgMiB8IDEwCisgMiB8ICAyIHwgMiB8ICAg CisgMiB8ICAyIHwgMiB8IDIwCisgMiB8ICAyIHwgMyB8IDEwCisgMiB8ICAyIHwgMyB8ICAgCisg MiB8ICAyIHwgMyB8IDIwCisgMyB8ICAzIHwgICB8ICAgCisgNCB8IC0xIHwgICB8ICAgCisoMTIg cm93cykKKworLS0gc3BlY2lmaWMgcGxhbiAocCBvdXRlciAocGIgdW5pb24gcGMpKQorc2VsZWN0 CisJanQuKgorZnJvbQorCWpzb25iX3RhYmxlX3Rlc3QganR0LAorCWpzb25fdGFibGUgKAorCQlq dHQuanMsJ3N0cmljdCAkWypdJyBhcyBwCisJCWNvbHVtbnMgKAorCQkJbiBmb3Igb3JkaW5hbGl0 eSwKKwkJCWEgaW50IHBhdGggJ2xheCAkLmEnIGRlZmF1bHQgLTEgb24gZW1wdHksCisJCQluZXN0 ZWQgcGF0aCAnc3RyaWN0ICQuYlsqXScgYXMgcGIgY29sdW1ucyAoIGIgaW50IHBhdGggJyQnICks CisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQuY1sqXScgYXMgcGMgY29sdW1ucyAoIGMgaW50IHBh dGggJyQnICkKKwkJKQorCQlwbGFuIChwIG91dGVyIChwYiB1bmlvbiBwYykpCisJKSBqdDsKKyBu IHwgYSAgfCBiIHwgYyAgCistLS0rLS0tLSstLS0rLS0tLQorIDEgfCAgMSB8ICAgfCAgIAorIDIg fCAgMiB8IDEgfCAgIAorIDIgfCAgMiB8IDIgfCAgIAorIDIgfCAgMiB8IDMgfCAgIAorIDIgfCAg MiB8ICAgfCAxMAorIDIgfCAgMiB8ICAgfCAgIAorIDIgfCAgMiB8ICAgfCAyMAorIDMgfCAgMyB8 IDEgfCAgIAorIDMgfCAgMyB8IDIgfCAgIAorIDQgfCAtMSB8IDEgfCAgIAorIDQgfCAtMSB8IDIg fCAgIAorKDExIHJvd3MpCisKKy0tIHNwZWNpZmljIHBsYW4gKHAgb3V0ZXIgKHBjIHVuaW9uIHBi KSkKK3NlbGVjdAorCWp0LioKK2Zyb20KKwlqc29uYl90YWJsZV90ZXN0IGp0dCwKKwlqc29uX3Rh YmxlICgKKwkJanR0LmpzLCdzdHJpY3QgJFsqXScgYXMgcAorCQljb2x1bW5zICgKKwkJCW4gZm9y IG9yZGluYWxpdHksCisJCQlhIGludCBwYXRoICdsYXggJC5hJyBkZWZhdWx0IC0xIG9uIGVtcHR5 LAorCQkJbmVzdGVkIHBhdGggJ3N0cmljdCAkLmJbKl0nIGFzIHBiIGNvbHVtbnMgKCBiIGludCBw YXRoICckJyApLAorCQkJbmVzdGVkIHBhdGggJ3N0cmljdCAkLmNbKl0nIGFzIHBjIGNvbHVtbnMg KCBjIGludCBwYXRoICckJyApCisJCSkKKwkJcGxhbiAocCBvdXRlciAocGMgdW5pb24gcGIpKQor CSkganQ7CisgbiB8IGEgIHwgYyAgfCBiIAorLS0tKy0tLS0rLS0tLSstLS0KKyAxIHwgIDEgfCAg ICB8ICAKKyAyIHwgIDIgfCAxMCB8ICAKKyAyIHwgIDIgfCAgICB8ICAKKyAyIHwgIDIgfCAyMCB8 ICAKKyAyIHwgIDIgfCAgICB8IDEKKyAyIHwgIDIgfCAgICB8IDIKKyAyIHwgIDIgfCAgICB8IDMK KyAzIHwgIDMgfCAgICB8IDEKKyAzIHwgIDMgfCAgICB8IDIKKyA0IHwgLTEgfCAgICB8IDEKKyA0 IHwgLTEgfCAgICB8IDIKKygxMSByb3dzKQorCistLSBkZWZhdWx0IHBsYW4gKGlubmVyLCB1bmlv bikKK3NlbGVjdAorCWp0LioKK2Zyb20KKwlqc29uYl90YWJsZV90ZXN0IGp0dCwKKwlqc29uX3Rh YmxlICgKKwkJanR0LmpzLCdzdHJpY3QgJFsqXScgYXMgcAorCQljb2x1bW5zICgKKwkJCW4gZm9y IG9yZGluYWxpdHksCisJCQlhIGludCBwYXRoICdsYXggJC5hJyBkZWZhdWx0IC0xIG9uIGVtcHR5 LAorCQkJbmVzdGVkIHBhdGggJ3N0cmljdCAkLmJbKl0nIGFzIHBiIGNvbHVtbnMgKCBiIGludCBw YXRoICckJyApLAorCQkJbmVzdGVkIHBhdGggJ3N0cmljdCAkLmNbKl0nIGFzIHBjIGNvbHVtbnMg KCBjIGludCBwYXRoICckJyApCisJCSkKKwkJcGxhbiBkZWZhdWx0IChpbm5lcikKKwkpIGp0Owor IG4gfCBhICB8IGIgfCBjICAKKy0tLSstLS0tKy0tLSstLS0tCisgMSB8ICAxIHwgICB8ICAgCisg MiB8ICAyIHwgMSB8IDEwCisgMiB8ICAyIHwgMSB8ICAgCisgMiB8ICAyIHwgMSB8IDIwCisgMiB8 ICAyIHwgMiB8IDEwCisgMiB8ICAyIHwgMiB8ICAgCisgMiB8ICAyIHwgMiB8IDIwCisgMiB8ICAy IHwgMyB8IDEwCisgMiB8ICAyIHwgMyB8ICAgCisgMiB8ICAyIHwgMyB8IDIwCisgMyB8ICAzIHwg ICB8ICAgCisgNCB8IC0xIHwgICB8ICAgCisoMTIgcm93cykKKworLS0gc3BlY2lmaWMgcGxhbiAo cCBpbm5lciAocGIgdW5pb24gcGMpKQorc2VsZWN0CisJanQuKgorZnJvbQorCWpzb25iX3RhYmxl X3Rlc3QganR0LAorCWpzb25fdGFibGUgKAorCQlqdHQuanMsJ3N0cmljdCAkWypdJyBhcyBwCisJ CWNvbHVtbnMgKAorCQkJbiBmb3Igb3JkaW5hbGl0eSwKKwkJCWEgaW50IHBhdGggJ2xheCAkLmEn IGRlZmF1bHQgLTEgb24gZW1wdHksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQuYlsqXScgYXMg cGIgY29sdW1ucyAoIGIgaW50IHBhdGggJyQnICksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQu Y1sqXScgYXMgcGMgY29sdW1ucyAoIGMgaW50IHBhdGggJyQnICkKKwkJKQorCQlwbGFuIChwIGlu bmVyIChwYiB1bmlvbiBwYykpCisJKSBqdDsKKyBuIHwgYSAgfCBiIHwgYyAgCistLS0rLS0tLSst LS0rLS0tLQorIDIgfCAgMiB8IDEgfCAgIAorIDIgfCAgMiB8IDIgfCAgIAorIDIgfCAgMiB8IDMg fCAgIAorIDIgfCAgMiB8ICAgfCAxMAorIDIgfCAgMiB8ICAgfCAgIAorIDIgfCAgMiB8ICAgfCAy MAorIDMgfCAgMyB8IDEgfCAgIAorIDMgfCAgMyB8IDIgfCAgIAorIDQgfCAtMSB8IDEgfCAgIAor IDQgfCAtMSB8IDIgfCAgIAorKDEwIHJvd3MpCisKKy0tIGRlZmF1bHQgcGxhbiAoaW5uZXIsIGNy b3NzKQorc2VsZWN0CisJanQuKgorZnJvbQorCWpzb25iX3RhYmxlX3Rlc3QganR0LAorCWpzb25f dGFibGUgKAorCQlqdHQuanMsJ3N0cmljdCAkWypdJyBhcyBwCisJCWNvbHVtbnMgKAorCQkJbiBm b3Igb3JkaW5hbGl0eSwKKwkJCWEgaW50IHBhdGggJ2xheCAkLmEnIGRlZmF1bHQgLTEgb24gZW1w dHksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQuYlsqXScgYXMgcGIgY29sdW1ucyAoIGIgaW50 IHBhdGggJyQnICksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQuY1sqXScgYXMgcGMgY29sdW1u cyAoIGMgaW50IHBhdGggJyQnICkKKwkJKQorCQlwbGFuIGRlZmF1bHQgKGNyb3NzLCBpbm5lcikK KwkpIGp0OworIG4gfCBhIHwgYiB8IGMgIAorLS0tKy0tLSstLS0rLS0tLQorIDIgfCAyIHwgMSB8 IDEwCisgMiB8IDIgfCAxIHwgICAKKyAyIHwgMiB8IDEgfCAyMAorIDIgfCAyIHwgMiB8IDEwCisg MiB8IDIgfCAyIHwgICAKKyAyIHwgMiB8IDIgfCAyMAorIDIgfCAyIHwgMyB8IDEwCisgMiB8IDIg fCAzIHwgICAKKyAyIHwgMiB8IDMgfCAyMAorKDkgcm93cykKKworLS0gc3BlY2lmaWMgcGxhbiAo cCBpbm5lciAocGIgY3Jvc3MgcGMpKQorc2VsZWN0CisJanQuKgorZnJvbQorCWpzb25iX3RhYmxl X3Rlc3QganR0LAorCWpzb25fdGFibGUgKAorCQlqdHQuanMsJ3N0cmljdCAkWypdJyBhcyBwCisJ CWNvbHVtbnMgKAorCQkJbiBmb3Igb3JkaW5hbGl0eSwKKwkJCWEgaW50IHBhdGggJ2xheCAkLmEn IGRlZmF1bHQgLTEgb24gZW1wdHksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQuYlsqXScgYXMg cGIgY29sdW1ucyAoIGIgaW50IHBhdGggJyQnICksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQu Y1sqXScgYXMgcGMgY29sdW1ucyAoIGMgaW50IHBhdGggJyQnICkKKwkJKQorCQlwbGFuIChwIGlu bmVyIChwYiBjcm9zcyBwYykpCisJKSBqdDsKKyBuIHwgYSB8IGIgfCBjICAKKy0tLSstLS0rLS0t Ky0tLS0KKyAyIHwgMiB8IDEgfCAxMAorIDIgfCAyIHwgMSB8ICAgCisgMiB8IDIgfCAxIHwgMjAK KyAyIHwgMiB8IDIgfCAxMAorIDIgfCAyIHwgMiB8ICAgCisgMiB8IDIgfCAyIHwgMjAKKyAyIHwg MiB8IDMgfCAxMAorIDIgfCAyIHwgMyB8ICAgCisgMiB8IDIgfCAzIHwgMjAKKyg5IHJvd3MpCisK Ky0tIGRlZmF1bHQgcGxhbiAob3V0ZXIsIGNyb3NzKQorc2VsZWN0CisJanQuKgorZnJvbQorCWpz b25iX3RhYmxlX3Rlc3QganR0LAorCWpzb25fdGFibGUgKAorCQlqdHQuanMsJ3N0cmljdCAkWypd JyBhcyBwCisJCWNvbHVtbnMgKAorCQkJbiBmb3Igb3JkaW5hbGl0eSwKKwkJCWEgaW50IHBhdGgg J2xheCAkLmEnIGRlZmF1bHQgLTEgb24gZW1wdHksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQu YlsqXScgYXMgcGIgY29sdW1ucyAoIGIgaW50IHBhdGggJyQnICksCisJCQluZXN0ZWQgcGF0aCAn c3RyaWN0ICQuY1sqXScgYXMgcGMgY29sdW1ucyAoIGMgaW50IHBhdGggJyQnICkKKwkJKQorCQlw bGFuIGRlZmF1bHQgKG91dGVyLCBjcm9zcykKKwkpIGp0OworIG4gfCBhICB8IGIgfCBjICAKKy0t LSstLS0tKy0tLSstLS0tCisgMSB8ICAxIHwgICB8ICAgCisgMiB8ICAyIHwgMSB8IDEwCisgMiB8 ICAyIHwgMSB8ICAgCisgMiB8ICAyIHwgMSB8IDIwCisgMiB8ICAyIHwgMiB8IDEwCisgMiB8ICAy IHwgMiB8ICAgCisgMiB8ICAyIHwgMiB8IDIwCisgMiB8ICAyIHwgMyB8IDEwCisgMiB8ICAyIHwg MyB8ICAgCisgMiB8ICAyIHwgMyB8IDIwCisgMyB8ICAzIHwgICB8ICAgCisgNCB8IC0xIHwgICB8 ICAgCisoMTIgcm93cykKKworLS0gc3BlY2lmaWMgcGxhbiAocCBvdXRlciAocGIgY3Jvc3MgcGMp KQorc2VsZWN0CisJanQuKgorZnJvbQorCWpzb25iX3RhYmxlX3Rlc3QganR0LAorCWpzb25fdGFi bGUgKAorCQlqdHQuanMsJ3N0cmljdCAkWypdJyBhcyBwCisJCWNvbHVtbnMgKAorCQkJbiBmb3Ig b3JkaW5hbGl0eSwKKwkJCWEgaW50IHBhdGggJ2xheCAkLmEnIGRlZmF1bHQgLTEgb24gZW1wdHks CisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQuYlsqXScgYXMgcGIgY29sdW1ucyAoIGIgaW50IHBh dGggJyQnICksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQuY1sqXScgYXMgcGMgY29sdW1ucyAo IGMgaW50IHBhdGggJyQnICkKKwkJKQorCQlwbGFuIChwIG91dGVyIChwYiBjcm9zcyBwYykpCisJ KSBqdDsKKyBuIHwgYSAgfCBiIHwgYyAgCistLS0rLS0tLSstLS0rLS0tLQorIDEgfCAgMSB8ICAg fCAgIAorIDIgfCAgMiB8IDEgfCAxMAorIDIgfCAgMiB8IDEgfCAgIAorIDIgfCAgMiB8IDEgfCAy MAorIDIgfCAgMiB8IDIgfCAxMAorIDIgfCAgMiB8IDIgfCAgIAorIDIgfCAgMiB8IDIgfCAyMAor IDIgfCAgMiB8IDMgfCAxMAorIDIgfCAgMiB8IDMgfCAgIAorIDIgfCAgMiB8IDMgfCAyMAorIDMg fCAgMyB8ICAgfCAgIAorIDQgfCAtMSB8ICAgfCAgIAorKDEyIHJvd3MpCisKK3NlbGVjdAorCWp0 LiosIGIxICsgMTAwIGFzIGIKK2Zyb20KKwlqc29uX3RhYmxlIChqc29uYgorCQknWworCQkJeyJh IjogIDEsICAiYiI6IFtbMSwgMTBdLCBbMl0sIFszLCAzMCwgMzAwXV0sICJjIjogWzEsIG51bGws IDJdfSwKKwkJCXsiYSI6ICAyLCAgImIiOiBbMTAsIDIwXSwgImMiOiBbMSwgbnVsbCwgMl19LAor CQkJeyJ4IjogIjMiLCAiYiI6IFsxMSwgMjIsIDMzLCA0NF19CisJCSBdJywKKwkJJyRbKl0nIGFz IHAKKwkJY29sdW1ucyAoCisJCQluIGZvciBvcmRpbmFsaXR5LAorCQkJYSBpbnQgcGF0aCAnbGF4 ICQuYScgZGVmYXVsdCAtMSBvbiBlcnJvciwKKwkJCW5lc3RlZCBwYXRoICdzdHJpY3QgJC5iWypd JyBhcyBwYiBjb2x1bW5zICgKKwkJCQliIHRleHQgZm9ybWF0IGpzb24gcGF0aCAnJCcsCisJCQkJ bmVzdGVkIHBhdGggJ3N0cmljdCAkWypdJyBhcyBwYjEgY29sdW1ucyAoCisJCQkJCWIxIGludCBw YXRoICckJworCQkJCSkKKwkJCSksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQuY1sqXScgYXMg cGMgY29sdW1ucyAoCisJCQkJYyB0ZXh0IGZvcm1hdCBqc29uIHBhdGggJyQnLAorCQkJCW5lc3Rl ZCBwYXRoICdzdHJpY3QgJFsqXScgYXMgcGMxIGNvbHVtbnMgKAorCQkJCQljMSBpbnQgcGF0aCAn JCcKKwkJCQkpCisJCQkpCisJCSkKKwkJLS1wbGFuIGRlZmF1bHQob3V0ZXIsIGNyb3NzKQorCQlw bGFuKHAgb3V0ZXIgKChwYiBpbm5lciBwYjEpIGNyb3NzIChwYyBvdXRlciBwYzEpKSkKKwkpIGp0 OworIG4gfCBhICB8ICAgICAgYiAgICAgICB8IGIxICB8ICBjICAgfCBjMSB8ICBiICAKKy0tLSst LS0tKy0tLS0tLS0tLS0tLS0tKy0tLS0tKy0tLS0tLSstLS0tKy0tLS0tCisgMSB8ICAxIHwgWzEs IDEwXSAgICAgIHwgICAxIHwgMSAgICB8ICAgIHwgMTAxCisgMSB8ICAxIHwgWzEsIDEwXSAgICAg IHwgICAxIHwgbnVsbCB8ICAgIHwgMTAxCisgMSB8ICAxIHwgWzEsIDEwXSAgICAgIHwgICAxIHwg MiAgICB8ICAgIHwgMTAxCisgMSB8ICAxIHwgWzEsIDEwXSAgICAgIHwgIDEwIHwgMSAgICB8ICAg IHwgMTEwCisgMSB8ICAxIHwgWzEsIDEwXSAgICAgIHwgIDEwIHwgbnVsbCB8ICAgIHwgMTEwCisg MSB8ICAxIHwgWzEsIDEwXSAgICAgIHwgIDEwIHwgMiAgICB8ICAgIHwgMTEwCisgMSB8ICAxIHwg WzJdICAgICAgICAgIHwgICAyIHwgMSAgICB8ICAgIHwgMTAyCisgMSB8ICAxIHwgWzJdICAgICAg ICAgIHwgICAyIHwgbnVsbCB8ICAgIHwgMTAyCisgMSB8ICAxIHwgWzJdICAgICAgICAgIHwgICAy IHwgMiAgICB8ICAgIHwgMTAyCisgMSB8ICAxIHwgWzMsIDMwLCAzMDBdIHwgICAzIHwgMSAgICB8 ICAgIHwgMTAzCisgMSB8ICAxIHwgWzMsIDMwLCAzMDBdIHwgICAzIHwgbnVsbCB8ICAgIHwgMTAz CisgMSB8ICAxIHwgWzMsIDMwLCAzMDBdIHwgICAzIHwgMiAgICB8ICAgIHwgMTAzCisgMSB8ICAx IHwgWzMsIDMwLCAzMDBdIHwgIDMwIHwgMSAgICB8ICAgIHwgMTMwCisgMSB8ICAxIHwgWzMsIDMw LCAzMDBdIHwgIDMwIHwgbnVsbCB8ICAgIHwgMTMwCisgMSB8ICAxIHwgWzMsIDMwLCAzMDBdIHwg IDMwIHwgMiAgICB8ICAgIHwgMTMwCisgMSB8ICAxIHwgWzMsIDMwLCAzMDBdIHwgMzAwIHwgMSAg ICB8ICAgIHwgNDAwCisgMSB8ICAxIHwgWzMsIDMwLCAzMDBdIHwgMzAwIHwgbnVsbCB8ICAgIHwg NDAwCisgMSB8ICAxIHwgWzMsIDMwLCAzMDBdIHwgMzAwIHwgMiAgICB8ICAgIHwgNDAwCisgMiB8 ICAyIHwgICAgICAgICAgICAgIHwgICAgIHwgICAgICB8ICAgIHwgICAgCisgMyB8IC0xIHwgICAg ICAgICAgICAgIHwgICAgIHwgICAgICB8ICAgIHwgICAgCisoMjAgcm93cykKKworLS0gU2hvdWxk IHN1Y2NlZWQgKEpTT04gYXJndW1lbnRzIGFyZSBwYXNzZWQgdG8gcm9vdCBhbmQgbmVzdGVkIHBh dGhzKQorU0VMRUNUICoKK0ZST00KKwlnZW5lcmF0ZV9zZXJpZXMoMSwgNCkgeCwKKwlnZW5lcmF0 ZV9zZXJpZXMoMSwgMykgeSwKKwlKU09OX1RBQkxFKGpzb25iCisJCSdbWzEsMiwzXSxbMiwzLDQs NV0sWzMsNCw1LDZdXScsCisJCSdzdHJpY3QgJFsqXSA/IChAWypdIDwgJHgpJworCQlQQVNTSU5H IHggQVMgeCwgeSBBUyB5CisJCUNPTFVNTlMgKAorCQkJeSB0ZXh0IEZPUk1BVCBKU09OIFBBVEgg JyQnLAorCQkJTkVTVEVEIFBBVEggJ3N0cmljdCAkWypdID8gKEAgPj0gJHkpJworCQkJQ09MVU1O UyAoCisJCQkJeiBpbnQgUEFUSCAnJCcKKwkJCSkKKwkJKQorCSkganQ7CisgeCB8IHkgfCAgICAg IHkgICAgICAgfCB6IAorLS0tKy0tLSstLS0tLS0tLS0tLS0tLSstLS0KKyAyIHwgMSB8IFsxLCAy LCAzXSAgICB8IDEKKyAyIHwgMSB8IFsxLCAyLCAzXSAgICB8IDIKKyAyIHwgMSB8IFsxLCAyLCAz XSAgICB8IDMKKyAzIHwgMSB8IFsxLCAyLCAzXSAgICB8IDEKKyAzIHwgMSB8IFsxLCAyLCAzXSAg ICB8IDIKKyAzIHwgMSB8IFsxLCAyLCAzXSAgICB8IDMKKyAzIHwgMSB8IFsyLCAzLCA0LCA1XSB8 IDIKKyAzIHwgMSB8IFsyLCAzLCA0LCA1XSB8IDMKKyAzIHwgMSB8IFsyLCAzLCA0LCA1XSB8IDQK KyAzIHwgMSB8IFsyLCAzLCA0LCA1XSB8IDUKKyA0IHwgMSB8IFsxLCAyLCAzXSAgICB8IDEKKyA0 IHwgMSB8IFsxLCAyLCAzXSAgICB8IDIKKyA0IHwgMSB8IFsxLCAyLCAzXSAgICB8IDMKKyA0IHwg MSB8IFsyLCAzLCA0LCA1XSB8IDIKKyA0IHwgMSB8IFsyLCAzLCA0LCA1XSB8IDMKKyA0IHwgMSB8 IFsyLCAzLCA0LCA1XSB8IDQKKyA0IHwgMSB8IFsyLCAzLCA0LCA1XSB8IDUKKyA0IHwgMSB8IFsz LCA0LCA1LCA2XSB8IDMKKyA0IHwgMSB8IFszLCA0LCA1LCA2XSB8IDQKKyA0IHwgMSB8IFszLCA0 LCA1LCA2XSB8IDUKKyA0IHwgMSB8IFszLCA0LCA1LCA2XSB8IDYKKyAyIHwgMiB8IFsxLCAyLCAz XSAgICB8IDIKKyAyIHwgMiB8IFsxLCAyLCAzXSAgICB8IDMKKyAzIHwgMiB8IFsxLCAyLCAzXSAg ICB8IDIKKyAzIHwgMiB8IFsxLCAyLCAzXSAgICB8IDMKKyAzIHwgMiB8IFsyLCAzLCA0LCA1XSB8 IDIKKyAzIHwgMiB8IFsyLCAzLCA0LCA1XSB8IDMKKyAzIHwgMiB8IFsyLCAzLCA0LCA1XSB8IDQK KyAzIHwgMiB8IFsyLCAzLCA0LCA1XSB8IDUKKyA0IHwgMiB8IFsxLCAyLCAzXSAgICB8IDIKKyA0 IHwgMiB8IFsxLCAyLCAzXSAgICB8IDMKKyA0IHwgMiB8IFsyLCAzLCA0LCA1XSB8IDIKKyA0IHwg MiB8IFsyLCAzLCA0LCA1XSB8IDMKKyA0IHwgMiB8IFsyLCAzLCA0LCA1XSB8IDQKKyA0IHwgMiB8 IFsyLCAzLCA0LCA1XSB8IDUKKyA0IHwgMiB8IFszLCA0LCA1LCA2XSB8IDMKKyA0IHwgMiB8IFsz LCA0LCA1LCA2XSB8IDQKKyA0IHwgMiB8IFszLCA0LCA1LCA2XSB8IDUKKyA0IHwgMiB8IFszLCA0 LCA1LCA2XSB8IDYKKyAyIHwgMyB8IFsxLCAyLCAzXSAgICB8IDMKKyAzIHwgMyB8IFsxLCAyLCAz XSAgICB8IDMKKyAzIHwgMyB8IFsyLCAzLCA0LCA1XSB8IDMKKyAzIHwgMyB8IFsyLCAzLCA0LCA1 XSB8IDQKKyAzIHwgMyB8IFsyLCAzLCA0LCA1XSB8IDUKKyA0IHwgMyB8IFsxLCAyLCAzXSAgICB8 IDMKKyA0IHwgMyB8IFsyLCAzLCA0LCA1XSB8IDMKKyA0IHwgMyB8IFsyLCAzLCA0LCA1XSB8IDQK KyA0IHwgMyB8IFsyLCAzLCA0LCA1XSB8IDUKKyA0IHwgMyB8IFszLCA0LCA1LCA2XSB8IDMKKyA0 IHwgMyB8IFszLCA0LCA1LCA2XSB8IDQKKyA0IHwgMyB8IFszLCA0LCA1LCA2XSB8IDUKKyA0IHwg MyB8IFszLCA0LCA1LCA2XSB8IDYKKyg1MiByb3dzKQorCistLSBTaG91bGQgZmFpbCAoSlNPTiBh cmd1bWVudHMgYXJlIG5vdCBwYXNzZWQgdG8gY29sdW1uIHBhdGhzKQorU0VMRUNUICoKK0ZST00g SlNPTl9UQUJMRSgKKwlqc29uYiAnWzEsMiwzXScsCisJJyRbKl0gPyAoQCA8ICR4KScKKwkJUEFT U0lORyAxMCBBUyB4CisJCUNPTFVNTlMgKHkgdGV4dCBGT1JNQVQgSlNPTiBQQVRIICckID8gKEAg PCAkeCknKQorCSkganQ7CitFUlJPUjogIGNvdWxkIG5vdCBmaW5kIGpzb25wYXRoIHZhcmlhYmxl ICJ4IgorLS0gRXh0ZW5zaW9uOiBub24tY29uc3RhbnQgSlNPTiBwYXRoCitTRUxFQ1QgSlNPTl9F WElTVFMoanNvbmIgJ3siYSI6IDEyM30nLCAnJCcgfHwgJy4nIHx8ICdhJyk7CisganNvbl9leGlz dHMgCistLS0tLS0tLS0tLS0tCisgdAorKDEgcm93KQorCitTRUxFQ1QgSlNPTl9WQUxVRShqc29u YiAneyJhIjogMTIzfScsICckJyB8fCAnLicgfHwgJ2EnKTsKKyBqc29uX3ZhbHVlIAorLS0tLS0t LS0tLS0tCisgMTIzCisoMSByb3cpCisKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICd7ImEiOiAx MjN9JywgJyQnIHx8ICcuJyB8fCAnYicgREVGQVVMVCAnZm9vJyBPTiBFTVBUWSk7CisganNvbl92 YWx1ZSAKKy0tLS0tLS0tLS0tLQorIGZvbworKDEgcm93KQorCitTRUxFQ1QgSlNPTl9RVUVSWShq c29uYiAneyJhIjogMTIzfScsICckJyB8fCAnLicgfHwgJ2EnKTsKKyBqc29uX3F1ZXJ5IAorLS0t LS0tLS0tLS0tCisgMTIzCisoMSByb3cpCisKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICd7ImEi OiAxMjN9JywgJyQnIHx8ICcuJyB8fCAnYScgV0lUSCBXUkFQUEVSKTsKKyBqc29uX3F1ZXJ5IAor LS0tLS0tLS0tLS0tCisgWzEyM10KKygxIHJvdykKKworLS0gU2hvdWxkIGZhaWwgKGludmFsaWQg cGF0aCkKK1NFTEVDVCBKU09OX1FVRVJZKGpzb25iICd7ImEiOiAxMjN9JywgJ2Vycm9yJyB8fCAn ICcgfHwgJ2Vycm9yJyk7CitFUlJPUjogIHN5bnRheCBlcnJvciBhdCBvciBuZWFyICIgIiBvZiBq c29ucGF0aCBpbnB1dAorLS0gU2hvdWxkIGZhaWwgKG5vdCBzdXBwb3J0ZWQpCitTRUxFQ1QgKiBG Uk9NIEpTT05fVEFCTEUoanNvbmIgJ3siYSI6IDEyM30nLCAnJCcgfHwgJy4nIHx8ICdhJyBDT0xV TU5TIChmb28gaW50KSk7CitFUlJPUjogIG9ubHkgc3RyaW5nIGNvbnN0YW50cyBhcmUgc3VwcG9y dGVkIGluIEpTT05fVEFCTEUgcGF0aCBzcGVjaWZpY2F0aW9uCitMSU5FIDE6IFNFTEVDVCAqIEZS T00gSlNPTl9UQUJMRShqc29uYiAneyJhIjogMTIzfScsICckJyB8fCAnLicgfHwgJy4uLgorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBeCmRpZmYg LS1naXQgYS9zcmMvdGVzdC9yZWdyZXNzL3NxbC9qc29uX3NxbGpzb24uc3FsIGIvc3JjL3Rlc3Qv cmVncmVzcy9zcWwvanNvbl9zcWxqc29uLnNxbAppbmRleCA0ZjMwZmE0NmI5Li5kZjRhNDMwZDg4 IDEwMDY0NAotLS0gYS9zcmMvdGVzdC9yZWdyZXNzL3NxbC9qc29uX3NxbGpzb24uc3FsCisrKyBi L3NyYy90ZXN0L3JlZ3Jlc3Mvc3FsL2pzb25fc3FsanNvbi5zcWwKQEAgLTksMyArOSw3IEBAIFNF TEVDVCBKU09OX1ZBTFVFKE5VTEwgRk9STUFUIEpTT04sICckJyk7CiAtLSBKU09OX1FVRVJZCiAK IFNFTEVDVCBKU09OX1FVRVJZKE5VTEwgRk9STUFUIEpTT04sICckJyk7CisKKy0tIEpTT05fVEFC TEUKKworU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKE5VTEwgRk9STUFUIEpTT04sICckJyBDT0xV TU5TIChmb28gdGV4dCkpOwpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvcmVncmVzcy9zcWwvanNvbmJf c3FsanNvbi5zcWwgYi9zcmMvdGVzdC9yZWdyZXNzL3NxbC9qc29uYl9zcWxqc29uLnNxbAppbmRl eCBiNjRjOTAxN2Y1Li42ZTU5Y2NmYmQwIDEwMDY0NAotLS0gYS9zcmMvdGVzdC9yZWdyZXNzL3Nx bC9qc29uYl9zcWxqc29uLnNxbAorKysgYi9zcmMvdGVzdC9yZWdyZXNzL3NxbC9qc29uYl9zcWxq c29uLnNxbApAQCAtMzQ4LDMgKzM0OCw2ODQgQEAgQ1JFQVRFIElOREVYIE9OIHRlc3RfanNvbmJf bXV0YWJpbGl0eSAoSlNPTl9RVUVSWShqcywgJyRbMSwgJC5hID8gKEAuZGF0ZXRpbWUoKQogQ1JF QVRFIElOREVYIE9OIHRlc3RfanNvbmJfbXV0YWJpbGl0eSAoSlNPTl9RVUVSWShqcywgJyRbMSwg MCB0byAkLmEgPyAoQC5kYXRldGltZSgpID09ICR4KV0nIFBBU1NJTkcgJzEyOjM0Jzo6dGltZSBB UyB4KSk7CiBDUkVBVEUgSU5ERVggT04gdGVzdF9qc29uYl9tdXRhYmlsaXR5IChKU09OX1FVRVJZ KGpzLCAnJFsxLCAkLmEgPyAoQC5kYXRldGltZSgiSEg6TUkiKSA9PSAkeCldJyBQQVNTSU5HICcx MjozNCc6OnRpbWUgQVMgeCkpOwogRFJPUCBUQUJMRSB0ZXN0X2pzb25iX211dGFiaWxpdHk7CisK Ky0tIEpTT05fVEFCTEUKKworLS0gU2hvdWxkIGZhaWwgKEpTT05fVEFCTEUgY2FuIGJlIHVzZWQg b25seSBpbiBGUk9NIGNsYXVzZSkKK1NFTEVDVCBKU09OX1RBQkxFKCdbXScsICckJyk7CisKKy0t IFNob3VsZCBmYWlsIChubyBjb2x1bW5zKQorU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKE5VTEws ICckJyBDT0xVTU5TICgpKTsKKworU0VMRUNUICogRlJPTSBKU09OX1RBQkxFIChOVUxMOjpqc29u YiwgJyQnIENPTFVNTlMgKHYxIHRpbWVzdGFtcCkpIEFTIGYgKHYxLCB2Mik7CisKKy0tIE5VTEwg PT4gZW1wdHkgdGFibGUKK1NFTEVDVCAqIEZST00gSlNPTl9UQUJMRShOVUxMOjpqc29uYiwgJyQn IENPTFVNTlMgKGZvbyBpbnQpKSBiYXI7CisKKy0tCitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUo anNvbmIgJzEyMycsICckJworCUNPTFVNTlMgKGl0ZW0gaW50IFBBVEggJyQnLCBmb28gaW50KSkg YmFyOworCistLSBKU09OX1RBQkxFOiBiYXNpYyBmdW5jdGlvbmFsaXR5CitDUkVBVEUgRE9NQUlO IGpzb25iX3Rlc3RfZG9tYWluIEFTIHRleHQgQ0hFQ0sgKHZhbHVlIDw+ICdmb28nKTsKK0NSRUFU RSBURU1QIFRBQkxFIGpzb25fdGFibGVfdGVzdCAoanMpIEFTCisJKFZBTFVFUworCQkoJzEnKSwK KwkJKCdbXScpLAorCQkoJ3t9JyksCisJCSgnWzEsIDEuMjMsICIyIiwgImFhYWFhYWEiLCAiZm9v IiwgbnVsbCwgZmFsc2UsIHRydWUsIHsiYWFhIjogMTIzfSwgIlsxLDJdIiwgIlwic3RyXCIiXScp CisJKTsKKworLS0gUmVndWxhciAidW5mb3JtYXR0ZWQiIGNvbHVtbnMKK1NFTEVDVCAqCitGUk9N IGpzb25fdGFibGVfdGVzdCB2YWxzCisJTEVGVCBPVVRFUiBKT0lOCisJSlNPTl9UQUJMRSgKKwkJ dmFscy5qczo6anNvbmIsICdsYXggJFsqXScKKwkJQ09MVU1OUyAoCisJCQlpZCBGT1IgT1JESU5B TElUWSwKKwkJCSJpbnQiIGludCBQQVRIICckJywKKwkJCSJ0ZXh0IiB0ZXh0IFBBVEggJyQnLAor CQkJImNoYXIoNCkiIGNoYXIoNCkgUEFUSCAnJCcsCisJCQkiYm9vbCIgYm9vbCBQQVRIICckJywK KwkJCSJudW1lcmljIiBudW1lcmljIFBBVEggJyQnLAorCQkJImRvbWFpbiIganNvbmJfdGVzdF9k b21haW4gUEFUSCAnJCcsCisJCQlqcyBqc29uIFBBVEggJyQnLAorCQkJamIganNvbmIgUEFUSCAn JCcKKwkJKQorCSkganQKKwlPTiB0cnVlOworCistLSAiZm9ybWF0dGVkIiBjb2x1bW5zCitTRUxF Q1QgKgorRlJPTSBqc29uX3RhYmxlX3Rlc3QgdmFscworCUxFRlQgT1VURVIgSk9JTgorCUpTT05f VEFCTEUoCisJCXZhbHMuanM6Ompzb25iLCAnbGF4ICRbKl0nCisJCUNPTFVNTlMgKAorCQkJaWQg Rk9SIE9SRElOQUxJVFksCisJCQlqc3QgdGV4dCAgICBGT1JNQVQgSlNPTiAgUEFUSCAnJCcsCisJ CQlqc2MgY2hhcig0KSBGT1JNQVQgSlNPTiAgUEFUSCAnJCcsCisJCQlqc3YgdmFyY2hhcig0KSBG T1JNQVQgSlNPTiAgUEFUSCAnJCcsCisJCQlqc2IganNvbmIgRk9STUFUIEpTT04gUEFUSCAnJCcs CisJCQlqc2JxIGpzb25iIEZPUk1BVCBKU09OIFBBVEggJyQnIE9NSVQgUVVPVEVTCisJCSkKKwkp IGp0CisJT04gdHJ1ZTsKKworLS0gRVhJU1RTIGNvbHVtbnMKK1NFTEVDVCAqCitGUk9NIGpzb25f dGFibGVfdGVzdCB2YWxzCisJTEVGVCBPVVRFUiBKT0lOCisJSlNPTl9UQUJMRSgKKwkJdmFscy5q czo6anNvbmIsICdsYXggJFsqXScKKwkJQ09MVU1OUyAoCisJCQlpZCBGT1IgT1JESU5BTElUWSwK KwkJCWV4aXN0czEgYm9vbCBFWElTVFMgUEFUSCAnJC5hYWEnLAorCQkJZXhpc3RzMiBpbnQgRVhJ U1RTIFBBVEggJyQuYWFhJywKKwkJCWV4aXN0czMgaW50IEVYSVNUUyBQQVRIICdzdHJpY3QgJC5h YWEnIFVOS05PV04gT04gRVJST1IsCisJCQlleGlzdHM0IHRleHQgRVhJU1RTIFBBVEggJ3N0cmlj dCAkLmFhYScgRkFMU0UgT04gRVJST1IKKwkJKQorCSkganQKKwlPTiB0cnVlOworCistLSBPdGhl ciBtaXNjZWxsYW5vdXMgY2hlY2tzCitTRUxFQ1QgKgorRlJPTSBqc29uX3RhYmxlX3Rlc3QgdmFs cworCUxFRlQgT1VURVIgSk9JTgorCUpTT05fVEFCTEUoCisJCXZhbHMuanM6Ompzb25iLCAnbGF4 ICRbKl0nCisJCUNPTFVNTlMgKAorCQkJaWQgRk9SIE9SRElOQUxJVFksCisJCQlhYWEgaW50LCAt LSAiYWFhIiBoYXMgaW1wbGljaXQgcGF0aCAnJC4iYWFhIicKKwkJCWFhYTEgaW50IFBBVEggJyQu YWFhJywKKwkJCWpzMiBqc29uIFBBVEggJyQnLAorCQkJanNiMncganNvbmIgUEFUSCAnJCcgV0lU SCBXUkFQUEVSLAorCQkJanNiMnEganNvbmIgUEFUSCAnJCcgT01JVCBRVU9URVMsCisJCQlpYSBp bnRbXSBQQVRIICckJywKKwkJCXRhIHRleHRbXSBQQVRIICckJywKKwkJCWpiYSBqc29uYltdIFBB VEggJyQnCisJCSkKKwkpIGp0CisJT04gdHJ1ZTsKKworLS0gSlNPTl9UQUJMRTogVGVzdCBiYWNr d2FyZCBwYXJzaW5nCisKK0NSRUFURSBWSUVXIGpzb25iX3RhYmxlX3ZpZXcgQVMKK1NFTEVDVCAq IEZST00KKwlKU09OX1RBQkxFKAorCQlqc29uYiAnbnVsbCcsICdsYXggJFsqXScgUEFTU0lORyAx ICsgMiBBUyBhLCBqc29uICciZm9vIicgQVMgImIgYyIKKwkJQ09MVU1OUyAoCisJCQlpZCBGT1Ig T1JESU5BTElUWSwKKwkJCSJpbnQiIGludCBQQVRIICckJywKKwkJCSJ0ZXh0IiB0ZXh0IFBBVEgg JyQnLAorCQkJImNoYXIoNCkiIGNoYXIoNCkgUEFUSCAnJCcsCisJCQkiYm9vbCIgYm9vbCBQQVRI ICckJywKKwkJCSJudW1lcmljIiBudW1lcmljIFBBVEggJyQnLAorCQkJImRvbWFpbiIganNvbmJf dGVzdF9kb21haW4gUEFUSCAnJCcsCisJCQlqcyBqc29uIFBBVEggJyQnLAorCQkJamIganNvbmIg UEFUSCAnJCcsCisJCQlqc3QgdGV4dCAgICBGT1JNQVQgSlNPTiAgUEFUSCAnJCcsCisJCQlqc2Mg Y2hhcig0KSBGT1JNQVQgSlNPTiAgUEFUSCAnJCcsCisJCQlqc3YgdmFyY2hhcig0KSBGT1JNQVQg SlNPTiAgUEFUSCAnJCcsCisJCQlqc2IganNvbmIgICBGT1JNQVQgSlNPTiBQQVRIICckJywKKwkJ CWpzYnEganNvbmIgRk9STUFUIEpTT04gUEFUSCAnJCcgT01JVCBRVU9URVMsCisJCQlhYWEgaW50 LCAtLSBpbXBsaWNpdCBwYXRoICckLiJhYWEiJywKKwkJCWFhYTEgaW50IFBBVEggJyQuYWFhJywK KwkJCWV4aXN0czEgYm9vbCBFWElTVFMgUEFUSCAnJC5hYWEnLAorCQkJZXhpc3RzMiBpbnQgRVhJ U1RTIFBBVEggJyQuYWFhJyBUUlVFIE9OIEVSUk9SLAorCQkJZXhpc3RzMyB0ZXh0IEVYSVNUUyBQ QVRIICdzdHJpY3QgJC5hYWEnIFVOS05PV04gT04gRVJST1IsCisKKwkJCWpzMiBqc29uIFBBVEgg JyQnLAorCQkJanNiMncganNvbmIgUEFUSCAnJCcgV0lUSCBXUkFQUEVSLAorCQkJanNiMnEganNv bmIgUEFUSCAnJCcgT01JVCBRVU9URVMsCisJCQlpYSBpbnRbXSBQQVRIICckJywKKwkJCXRhIHRl eHRbXSBQQVRIICckJywKKwkJCWpiYSBqc29uYltdIFBBVEggJyQnLAorCisJCQlORVNURUQgUEFU SCAnJFsxXScgQVMgcDEgQ09MVU1OUyAoCisJCQkJYTEgaW50LAorCQkJCU5FU1RFRCBQQVRIICck WypdJyBBUyAicDEgMSIgQ09MVU1OUyAoCisJCQkJCWExMSB0ZXh0CisJCQkJKSwKKwkJCQliMSB0 ZXh0CisJCQkpLAorCQkJTkVTVEVEIFBBVEggJyRbMl0nIEFTIHAyIENPTFVNTlMgKAorCQkJCU5F U1RFRCBQQVRIICckWypdJyBBUyAicDI6MSIgQ09MVU1OUyAoCisJCQkJCWEyMSB0ZXh0CisJCQkJ KSwKKwkJCQlORVNURUQgUEFUSCAnJFsqXScgQVMgcDIyIENPTFVNTlMgKAorCQkJCQlhMjIgdGV4 dAorCQkJCSkKKwkJCSkKKwkJKQorCSk7CisKK1xzdiBqc29uYl90YWJsZV92aWV3CisKK0VYUExB SU4gKENPU1RTIE9GRiwgVkVSQk9TRSkgU0VMRUNUICogRlJPTSBqc29uYl90YWJsZV92aWV3Owor CitEUk9QIFZJRVcganNvbmJfdGFibGVfdmlldzsKK0RST1AgRE9NQUlOIGpzb25iX3Rlc3RfZG9t YWluOworCistLSBKU09OX1RBQkxFOiBvbmx5IG9uZSBGT1IgT1JESU5BTElUWSBjb2x1bW5zIGFs bG93ZWQKK1NFTEVDVCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAnMScsICckJyBDT0xVTU5TIChp ZCBGT1IgT1JESU5BTElUWSwgaWQyIEZPUiBPUkRJTkFMSVRZLCBhIGludCBQQVRIICckLmEnIEVS Uk9SIE9OIEVNUFRZKSkganQ7CitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoanNvbmIgJzEnLCAn JCcgQ09MVU1OUyAoaWQgRk9SIE9SRElOQUxJVFksIGEgaW50IFBBVEggJyQnIEVSUk9SIE9OIEVN UFRZKSkganQ7CisKKy0tIEpTT05fVEFCTEU6IE9OIEVNUFRZL09OIEVSUk9SIGJlaGF2aW9yCitT RUxFQ1QgKgorRlJPTQorCShWQUxVRVMgKCcxJyksICgnImVyciInKSkgdmFscyhqcyksCisJSlNP Tl9UQUJMRSh2YWxzLmpzOjpqc29uYiwgJyQnIENPTFVNTlMgKGEgaW50IFBBVEggJyQnKSkganQ7 CisKK1NFTEVDVCAqCitGUk9NCisJKFZBTFVFUyAoJzEnKSwgKCciZXJyIicpKSB2YWxzKGpzKQor CQlMRUZUIE9VVEVSIEpPSU4KKwlKU09OX1RBQkxFKHZhbHMuanM6Ompzb25iLCAnJCcgQ09MVU1O UyAoYSBpbnQgUEFUSCAnJCcpIEVSUk9SIE9OIEVSUk9SKSBqdAorCQlPTiB0cnVlOworCitTRUxF Q1QgKgorRlJPTQorCShWQUxVRVMgKCcxJyksICgnImVyciInKSkgdmFscyhqcykKKwkJTEVGVCBP VVRFUiBKT0lOCisJSlNPTl9UQUJMRSh2YWxzLmpzOjpqc29uYiwgJyQnIENPTFVNTlMgKGEgaW50 IFBBVEggJyQnIEVSUk9SIE9OIEVSUk9SKSkganQKKwkJT04gdHJ1ZTsKKworU0VMRUNUICogRlJP TSBKU09OX1RBQkxFKGpzb25iICcxJywgJyQnIENPTFVNTlMgKGEgaW50IFBBVEggJyQuYScgRVJS T1IgT04gRU1QVFkpKSBqdDsKK1NFTEVDVCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAnMScsICck JyBDT0xVTU5TIChhIGludCBQQVRIICdzdHJpY3QgJC5hJyBFUlJPUiBPTiBFTVBUWSkgRVJST1Ig T04gRVJST1IpIGp0OworU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKGpzb25iICcxJywgJyQnIENP TFVNTlMgKGEgaW50IFBBVEggJ2xheCAkLmEnIEVSUk9SIE9OIEVNUFRZKSBFUlJPUiBPTiBFUlJP UikganQ7CisKK1NFTEVDVCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAnImEiJywgJyQnIENPTFVN TlMgKGEgaW50IFBBVEggJyQnICAgREVGQVVMVCAxIE9OIEVNUFRZIERFRkFVTFQgMiBPTiBFUlJP UikpIGp0OworU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKGpzb25iICciYSInLCAnJCcgQ09MVU1O UyAoYSBpbnQgUEFUSCAnc3RyaWN0ICQuYScgREVGQVVMVCAxIE9OIEVNUFRZIERFRkFVTFQgMiBP TiBFUlJPUikpIGp0OworU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKGpzb25iICciYSInLCAnJCcg Q09MVU1OUyAoYSBpbnQgUEFUSCAnbGF4ICQuYScgREVGQVVMVCAxIE9OIEVNUFRZIERFRkFVTFQg MiBPTiBFUlJPUikpIGp0OworCistLSBKU09OX1RBQkxFOiBFWElTVFMgUEFUSCB0eXBlcworU0VM RUNUICogRlJPTSBKU09OX1RBQkxFKGpzb25iICciYSInLCAnJCcgQ09MVU1OUyAoYSBpbnQ0IEVY SVNUUyBQQVRIICckLmEnKSk7CitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoanNvbmIgJyJhIics ICckJyBDT0xVTU5TIChhIGludDIgRVhJU1RTIFBBVEggJyQuYScpKTsKK1NFTEVDVCAqIEZST00g SlNPTl9UQUJMRShqc29uYiAnImEiJywgJyQnIENPTFVNTlMgKGEgaW50OCBFWElTVFMgUEFUSCAn JC5hJykpOworU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKGpzb25iICciYSInLCAnJCcgQ09MVU1O UyAoYSBmbG9hdDQgRVhJU1RTIFBBVEggJyQuYScpKTsKK1NFTEVDVCAqIEZST00gSlNPTl9UQUJM RShqc29uYiAnImEiJywgJyQnIENPTFVNTlMgKGEgY2hhcigzKSBFWElTVFMgUEFUSCAnJC5hJykp OworU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKGpzb25iICciYSInLCAnJCcgQ09MVU1OUyAoYSBq c29uIEVYSVNUUyBQQVRIICckLmEnKSk7CitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoanNvbmIg JyJhIicsICckJyBDT0xVTU5TIChhIGpzb25iIEVYSVNUUyBQQVRIICckLmEnKSk7CisKKy0tIEpT T05fVEFCTEU6IFdSQVBQRVIvUVVPVEVTIGNsYXVzZXMgb24gc2NhbGFyIGNvbHVtbnMKK1NFTEVD VCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAnIndvcmxkIicsICckJyBDT0xVTU5TIChpdGVtIHRl eHQgUEFUSCAnJCcgS0VFUCBRVU9URVMgT04gU0NBTEFSIFNUUklORykpOworU0VMRUNUICogRlJP TSBKU09OX1RBQkxFKGpzb25iICcid29ybGQiJywgJyQnIENPTFVNTlMgKGl0ZW0gdGV4dCBQQVRI ICckJyBPTUlUIFFVT1RFUyBPTiBTQ0FMQVIgU1RSSU5HKSk7CitTRUxFQ1QgKiBGUk9NIEpTT05f VEFCTEUoanNvbmIgJyJ3b3JsZCInLCAnJCcgQ09MVU1OUyAoaXRlbSB0ZXh0IEZPUk1BVCBKU09O IFBBVEggJyQnIEtFRVAgUVVPVEVTKSk7CitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoanNvbmIg JyJ3b3JsZCInLCAnJCcgQ09MVU1OUyAoaXRlbSB0ZXh0IEZPUk1BVCBKU09OIFBBVEggJyQnIE9N SVQgUVVPVEVTKSk7CitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoanNvbmIgJyJ3b3JsZCInLCAn JCcgQ09MVU1OUyAoaXRlbSB0ZXh0IEZPUk1BVCBKU09OIFBBVEggJyQnIFdJVEhPVVQgV1JBUFBF UiBLRUVQIFFVT1RFUykpOworU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKGpzb25iICcid29ybGQi JywgJyQnIENPTFVNTlMgKGl0ZW0gdGV4dCBQQVRIICckJyBXSVRIT1VUIFdSQVBQRVIgT01JVCBR VU9URVMpKTsKKworU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKGpzb25iICcid29ybGQiJywgJyQn IENPTFVNTlMgKGl0ZW0gdGV4dCBGT1JNQVQgSlNPTiBQQVRIICckJyBXSVRIIFdSQVBQRVIpKTsK KworLS0gRXJyb3I6IFFVT1RFUyBjbGF1c2UgbWVhbmluZ2xlc3Mgd2hlbiBXSVRIIFdSQVBQRVIg aXMgcHJlc2VudAorU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKGpzb25iICcid29ybGQiJywgJyQn IENPTFVNTlMgKGl0ZW0gdGV4dCBGT1JNQVQgSlNPTiBQQVRIICckJyBXSVRIIFdSQVBQRVIgS0VF UCBRVU9URVMpKTsKK1NFTEVDVCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAnIndvcmxkIicsICck JyBDT0xVTU5TIChpdGVtIHRleHQgUEFUSCAnJCcgV0lUSCBXUkFQUEVSIE9NSVQgUVVPVEVTKSk7 CisKKy0tIEpTT05fVEFCTEU6IG5lc3RlZCBwYXRocyBhbmQgcGxhbnMKKworLS0gU2hvdWxkIGZh aWwgKEpTT05fVEFCTEUgY29sdW1ucyBtdXN0IGNvbnRhaW4gZXhwbGljaXQgQVMgcGF0aAorLS0g c3BlY2lmaWNhdGlvbnMgaWYgZXhwbGljaXQgUExBTiBjbGF1c2UgaXMgdXNlZCkKK1NFTEVDVCAq IEZST00gSlNPTl9UQUJMRSgKKwlqc29uYiAnW10nLCAnJCcgLS0gQVMgPHBhdGggbmFtZT4gcmVx dWlyZWQgaGVyZQorCUNPTFVNTlMgKAorCQlmb28gaW50IFBBVEggJyQnCisJKQorCVBMQU4gREVG QVVMVCAoVU5JT04pCispIGp0OworCitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoCisJanNvbmIg J1tdJywgJyQnIEFTIHBhdGgxCisJQ09MVU1OUyAoCisJCU5FU1RFRCBQQVRIICckJyBDT0xVTU5T ICggLS0gQVMgPHBhdGggbmFtZT4gcmVxdWlyZWQgaGVyZQorCQkJZm9vIGludCBQQVRIICckJwor CQkpCisJKQorCVBMQU4gREVGQVVMVCAoVU5JT04pCispIGp0OworCistLSBTaG91bGQgZmFpbCAo Y29sdW1uIG5hbWVzIG11c3QgYmUgZGlzdGluY3QpCitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUo CisJanNvbmIgJ1tdJywgJyQnIEFTIGEKKwlDT0xVTU5TICgKKwkJYSBpbnQKKwkpCispIGp0Owor CitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoCisJanNvbmIgJ1tdJywgJyQnIEFTIGEKKwlDT0xV TU5TICgKKwkJYiBpbnQsCisJCU5FU1RFRCBQQVRIICckJyBBUyBhCisJCUNPTFVNTlMgKAorCQkJ YyBpbnQKKwkJKQorCSkKKykganQ7CisKK1NFTEVDVCAqIEZST00gSlNPTl9UQUJMRSgKKwlqc29u YiAnW10nLCAnJCcKKwlDT0xVTU5TICgKKwkJYiBpbnQsCisJCU5FU1RFRCBQQVRIICckJyBBUyBi CisJCUNPTFVNTlMgKAorCQkJYyBpbnQKKwkJKQorCSkKKykganQ7CisKK1NFTEVDVCAqIEZST00g SlNPTl9UQUJMRSgKKwlqc29uYiAnW10nLCAnJCcKKwlDT0xVTU5TICgKKwkJTkVTVEVEIFBBVEgg JyQnIEFTIGEKKwkJQ09MVU1OUyAoCisJCQliIGludAorCQkpLAorCQlORVNURUQgUEFUSCAnJCcK KwkJQ09MVU1OUyAoCisJCQlORVNURUQgUEFUSCAnJCcgQVMgYQorCQkJQ09MVU1OUyAoCisJCQkJ YyBpbnQKKwkJCSkKKwkJKQorCSkKKykganQ7CisKKy0tIEpTT05fVEFCTEU6IHBsYW4gdmFsaWRh dGlvbgorCitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoCisJanNvbmIgJ251bGwnLCAnJFsqXScg QVMgcDAKKwlDT0xVTU5TICgKKwkJTkVTVEVEICckJyBBUyBwMSBDT0xVTU5TICgKKwkJCU5FU1RF RCBQQVRIICckJyBBUyBwMTEgQ09MVU1OUyAoIGZvbyBpbnQgKSwKKwkJCU5FU1RFRCBQQVRIICck JyBBUyBwMTIgQ09MVU1OUyAoIGJhciBpbnQgKQorCQkpLAorCQlORVNURUQgUEFUSCAnJCcgQVMg cDIgQ09MVU1OUyAoCisJCQlORVNURUQgUEFUSCAnJCcgQVMgcDIxIENPTFVNTlMgKCBiYXogaW50 ICkKKwkJKQorCSkKKwlQTEFOIChwMSkKKykganQ7CisKK1NFTEVDVCAqIEZST00gSlNPTl9UQUJM RSgKKwlqc29uYiAnbnVsbCcsICckWypdJyBBUyBwMAorCUNPTFVNTlMgKAorCQlORVNURUQgUEFU SCAnJCcgQVMgcDEgQ09MVU1OUyAoCisJCQlORVNURUQgUEFUSCAnJCcgQVMgcDExIENPTFVNTlMg KCBmb28gaW50ICksCisJCQlORVNURUQgUEFUSCAnJCcgQVMgcDEyIENPTFVNTlMgKCBiYXIgaW50 ICkKKwkJKSwKKwkJTkVTVEVEIFBBVEggJyQnIEFTIHAyIENPTFVNTlMgKAorCQkJTkVTVEVEIFBB VEggJyQnIEFTIHAyMSBDT0xVTU5TICggYmF6IGludCApCisJCSkKKwkpCisJUExBTiAocDApCisp IGp0OworCitTRUxFQ1QgKiBGUk9NIEpTT05fVEFCTEUoCisJanNvbmIgJ251bGwnLCAnJFsqXScg QVMgcDAKKwlDT0xVTU5TICgKKwkJTkVTVEVEIFBBVEggJyQnIEFTIHAxIENPTFVNTlMgKAorCQkJ TkVTVEVEIFBBVEggJyQnIEFTIHAxMSBDT0xVTU5TICggZm9vIGludCApLAorCQkJTkVTVEVEIFBB VEggJyQnIEFTIHAxMiBDT0xVTU5TICggYmFyIGludCApCisJCSksCisJCU5FU1RFRCBQQVRIICck JyBBUyBwMiBDT0xVTU5TICgKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMjEgQ09MVU1OUyAoIGJh eiBpbnQgKQorCQkpCisJKQorCVBMQU4gKHAwIE9VVEVSIHAzKQorKSBqdDsKKworU0VMRUNUICog RlJPTSBKU09OX1RBQkxFKAorCWpzb25iICdudWxsJywgJyRbKl0nIEFTIHAwCisJQ09MVU1OUyAo CisJCU5FU1RFRCBQQVRIICckJyBBUyBwMSBDT0xVTU5TICgKKwkJCU5FU1RFRCBQQVRIICckJyBB UyBwMTEgQ09MVU1OUyAoIGZvbyBpbnQgKSwKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMTIgQ09M VU1OUyAoIGJhciBpbnQgKQorCQkpLAorCQlORVNURUQgUEFUSCAnJCcgQVMgcDIgQ09MVU1OUyAo CisJCQlORVNURUQgUEFUSCAnJCcgQVMgcDIxIENPTFVNTlMgKCBiYXogaW50ICkKKwkJKQorCSkK KwlQTEFOIChwMCBVTklPTiBwMSBVTklPTiBwMTEpCispIGp0OworCitTRUxFQ1QgKiBGUk9NIEpT T05fVEFCTEUoCisJanNvbmIgJ251bGwnLCAnJFsqXScgQVMgcDAKKwlDT0xVTU5TICgKKwkJTkVT VEVEIFBBVEggJyQnIEFTIHAxIENPTFVNTlMgKAorCQkJTkVTVEVEIFBBVEggJyQnIEFTIHAxMSBD T0xVTU5TICggZm9vIGludCApLAorCQkJTkVTVEVEIFBBVEggJyQnIEFTIHAxMiBDT0xVTU5TICgg YmFyIGludCApCisJCSksCisJCU5FU1RFRCBQQVRIICckJyBBUyBwMiBDT0xVTU5TICgKKwkJCU5F U1RFRCBQQVRIICckJyBBUyBwMjEgQ09MVU1OUyAoIGJheiBpbnQgKQorCQkpCisJKQorCVBMQU4g KHAwIE9VVEVSIChwMSBDUk9TUyBwMTMpKQorKSBqdDsKKworU0VMRUNUICogRlJPTSBKU09OX1RB QkxFKAorCWpzb25iICdudWxsJywgJyRbKl0nIEFTIHAwCisJQ09MVU1OUyAoCisJCU5FU1RFRCBQ QVRIICckJyBBUyBwMSBDT0xVTU5TICgKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMTEgQ09MVU1O UyAoIGZvbyBpbnQgKSwKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMTIgQ09MVU1OUyAoIGJhciBp bnQgKQorCQkpLAorCQlORVNURUQgUEFUSCAnJCcgQVMgcDIgQ09MVU1OUyAoCisJCQlORVNURUQg UEFUSCAnJCcgQVMgcDIxIENPTFVNTlMgKCBiYXogaW50ICkKKwkJKQorCSkKKwlQTEFOIChwMCBP VVRFUiAocDEgQ1JPU1MgcDIpKQorKSBqdDsKKworU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKAor CWpzb25iICdudWxsJywgJyRbKl0nIEFTIHAwCisJQ09MVU1OUyAoCisJCU5FU1RFRCBQQVRIICck JyBBUyBwMSBDT0xVTU5TICgKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMTEgQ09MVU1OUyAoIGZv byBpbnQgKSwKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMTIgQ09MVU1OUyAoIGJhciBpbnQgKQor CQkpLAorCQlORVNURUQgUEFUSCAnJCcgQVMgcDIgQ09MVU1OUyAoCisJCQlORVNURUQgUEFUSCAn JCcgQVMgcDIxIENPTFVNTlMgKCBiYXogaW50ICkKKwkJKQorCSkKKwlQTEFOIChwMCBPVVRFUiAo KHAxIFVOSU9OIHAxMSkgQ1JPU1MgcDIpKQorKSBqdDsKKworU0VMRUNUICogRlJPTSBKU09OX1RB QkxFKAorCWpzb25iICdudWxsJywgJyRbKl0nIEFTIHAwCisJQ09MVU1OUyAoCisJCU5FU1RFRCBQ QVRIICckJyBBUyBwMSBDT0xVTU5TICgKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMTEgQ09MVU1O UyAoIGZvbyBpbnQgKSwKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMTIgQ09MVU1OUyAoIGJhciBp bnQgKQorCQkpLAorCQlORVNURUQgUEFUSCAnJCcgQVMgcDIgQ09MVU1OUyAoCisJCQlORVNURUQg UEFUSCAnJCcgQVMgcDIxIENPTFVNTlMgKCBiYXogaW50ICkKKwkJKQorCSkKKwlQTEFOIChwMCBP VVRFUiAoKHAxIElOTkVSIHAxMSkgQ1JPU1MgcDIpKQorKSBqdDsKKworU0VMRUNUICogRlJPTSBK U09OX1RBQkxFKAorCWpzb25iICdudWxsJywgJyRbKl0nIEFTIHAwCisJQ09MVU1OUyAoCisJCU5F U1RFRCBQQVRIICckJyBBUyBwMSBDT0xVTU5TICgKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMTEg Q09MVU1OUyAoIGZvbyBpbnQgKSwKKwkJCU5FU1RFRCBQQVRIICckJyBBUyBwMTIgQ09MVU1OUyAo IGJhciBpbnQgKQorCQkpLAorCQlORVNURUQgUEFUSCAnJCcgQVMgcDIgQ09MVU1OUyAoCisJCQlO RVNURUQgUEFUSCAnJCcgQVMgcDIxIENPTFVNTlMgKCBiYXogaW50ICkKKwkJKQorCSkKKwlQTEFO IChwMCBPVVRFUiAoKHAxIElOTkVSIChwMTIgQ1JPU1MgcDExKSkgQ1JPU1MgcDIpKQorKSBqdDsK KworU0VMRUNUICogRlJPTSBKU09OX1RBQkxFKAorCWpzb25iICdudWxsJywgJ3N0cmljdCAkWypd JyBBUyBwMAorCUNPTFVNTlMgKAorCQlORVNURUQgUEFUSCAnJCcgQVMgcDEgQ09MVU1OUyAoCisJ CQlORVNURUQgUEFUSCAnJCcgQVMgcDExIENPTFVNTlMgKCBmb28gaW50ICksCisJCQlORVNURUQg UEFUSCAnJCcgQVMgcDEyIENPTFVNTlMgKCBiYXIgaW50ICkKKwkJKSwKKwkJTkVTVEVEIFBBVEgg JyQnIEFTIHAyIENPTFVNTlMgKAorCQkJTkVTVEVEIFBBVEggJyQnIEFTIHAyMSBDT0xVTU5TICgg YmF6IGludCApCisJCSkKKwkpCisJUExBTiAocDAgT1VURVIgKChwMSBJTk5FUiAocDEyIENST1NT IHAxMSkpIENST1NTIChwMiBJTk5FUiBwMjEpKSkKKykganQ7CisKK1NFTEVDVCAqIEZST00gSlNP Tl9UQUJMRSgKKwlqc29uYiAnbnVsbCcsICdzdHJpY3QgJFsqXScgLS0gd2l0aG91dCByb290IHBh dGggbmFtZQorCUNPTFVNTlMgKAorCQlORVNURUQgUEFUSCAnJCcgQVMgcDEgQ09MVU1OUyAoCisJ CQlORVNURUQgUEFUSCAnJCcgQVMgcDExIENPTFVNTlMgKCBmb28gaW50ICksCisJCQlORVNURUQg UEFUSCAnJCcgQVMgcDEyIENPTFVNTlMgKCBiYXIgaW50ICkKKwkJKSwKKwkJTkVTVEVEIFBBVEgg JyQnIEFTIHAyIENPTFVNTlMgKAorCQkJTkVTVEVEIFBBVEggJyQnIEFTIHAyMSBDT0xVTU5TICgg YmF6IGludCApCisJCSkKKwkpCisJUExBTiAoKHAxIElOTkVSIChwMTIgQ1JPU1MgcDExKSkgQ1JP U1MgKHAyIElOTkVSIHAyMSkpCispIGp0OworCistLSBKU09OX1RBQkxFOiBwbGFuIGV4ZWN1dGlv bgorCitDUkVBVEUgVEVNUCBUQUJMRSBqc29uYl90YWJsZV90ZXN0IChqcyBqc29uYik7CisKK0lO U0VSVCBJTlRPIGpzb25iX3RhYmxlX3Rlc3QKK1ZBTFVFUyAoCisJJ1sKKwkJeyJhIjogIDEsICAi YiI6IFtdLCAiYyI6IFtdfSwKKwkJeyJhIjogIDIsICAiYiI6IFsxLCAyLCAzXSwgImMiOiBbMTAs IG51bGwsIDIwXX0sCisJCXsiYSI6ICAzLCAgImIiOiBbMSwgMl0sICJjIjogW119LAorCQl7Ingi OiAiNCIsICJiIjogWzEsIDJdLCAiYyI6IDEyM30KKwkgXScKKyk7CisKKy0tIHVuc3BlY2lmaWVk IHBsYW4gKG91dGVyLCB1bmlvbikKK3NlbGVjdAorCWp0LioKK2Zyb20KKwlqc29uYl90YWJsZV90 ZXN0IGp0dCwKKwlqc29uX3RhYmxlICgKKwkJanR0LmpzLCdzdHJpY3QgJFsqXScgYXMgcAorCQlj b2x1bW5zICgKKwkJCW4gZm9yIG9yZGluYWxpdHksCisJCQlhIGludCBwYXRoICdsYXggJC5hJyBk ZWZhdWx0IC0xIG9uIGVtcHR5LAorCQkJbmVzdGVkIHBhdGggJ3N0cmljdCAkLmJbKl0nIGFzIHBi IGNvbHVtbnMgKCBiIGludCBwYXRoICckJyApLAorCQkJbmVzdGVkIHBhdGggJ3N0cmljdCAkLmNb Kl0nIGFzIHBjIGNvbHVtbnMgKCBjIGludCBwYXRoICckJyApCisJCSkKKwkpIGp0OworCistLSBk ZWZhdWx0IHBsYW4gKG91dGVyLCB1bmlvbikKK3NlbGVjdAorCWp0LioKK2Zyb20KKwlqc29uYl90 YWJsZV90ZXN0IGp0dCwKKwlqc29uX3RhYmxlICgKKwkJanR0LmpzLCdzdHJpY3QgJFsqXScgYXMg cAorCQljb2x1bW5zICgKKwkJCW4gZm9yIG9yZGluYWxpdHksCisJCQlhIGludCBwYXRoICdsYXgg JC5hJyBkZWZhdWx0IC0xIG9uIGVtcHR5LAorCQkJbmVzdGVkIHBhdGggJ3N0cmljdCAkLmJbKl0n IGFzIHBiIGNvbHVtbnMgKCBiIGludCBwYXRoICckJyApLAorCQkJbmVzdGVkIHBhdGggJ3N0cmlj dCAkLmNbKl0nIGFzIHBjIGNvbHVtbnMgKCBjIGludCBwYXRoICckJyApCisJCSkKKwkJcGxhbiBk ZWZhdWx0IChvdXRlciwgdW5pb24pCisJKSBqdDsKKworLS0gc3BlY2lmaWMgcGxhbiAocCBvdXRl ciAocGIgdW5pb24gcGMpKQorc2VsZWN0CisJanQuKgorZnJvbQorCWpzb25iX3RhYmxlX3Rlc3Qg anR0LAorCWpzb25fdGFibGUgKAorCQlqdHQuanMsJ3N0cmljdCAkWypdJyBhcyBwCisJCWNvbHVt bnMgKAorCQkJbiBmb3Igb3JkaW5hbGl0eSwKKwkJCWEgaW50IHBhdGggJ2xheCAkLmEnIGRlZmF1 bHQgLTEgb24gZW1wdHksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQuYlsqXScgYXMgcGIgY29s dW1ucyAoIGIgaW50IHBhdGggJyQnICksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQuY1sqXScg YXMgcGMgY29sdW1ucyAoIGMgaW50IHBhdGggJyQnICkKKwkJKQorCQlwbGFuIChwIG91dGVyIChw YiB1bmlvbiBwYykpCisJKSBqdDsKKworLS0gc3BlY2lmaWMgcGxhbiAocCBvdXRlciAocGMgdW5p b24gcGIpKQorc2VsZWN0CisJanQuKgorZnJvbQorCWpzb25iX3RhYmxlX3Rlc3QganR0LAorCWpz b25fdGFibGUgKAorCQlqdHQuanMsJ3N0cmljdCAkWypdJyBhcyBwCisJCWNvbHVtbnMgKAorCQkJ biBmb3Igb3JkaW5hbGl0eSwKKwkJCWEgaW50IHBhdGggJ2xheCAkLmEnIGRlZmF1bHQgLTEgb24g ZW1wdHksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQuYlsqXScgYXMgcGIgY29sdW1ucyAoIGIg aW50IHBhdGggJyQnICksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQuY1sqXScgYXMgcGMgY29s dW1ucyAoIGMgaW50IHBhdGggJyQnICkKKwkJKQorCQlwbGFuIChwIG91dGVyIChwYyB1bmlvbiBw YikpCisJKSBqdDsKKworLS0gZGVmYXVsdCBwbGFuIChpbm5lciwgdW5pb24pCitzZWxlY3QKKwlq dC4qCitmcm9tCisJanNvbmJfdGFibGVfdGVzdCBqdHQsCisJanNvbl90YWJsZSAoCisJCWp0dC5q cywnc3RyaWN0ICRbKl0nIGFzIHAKKwkJY29sdW1ucyAoCisJCQluIGZvciBvcmRpbmFsaXR5LAor CQkJYSBpbnQgcGF0aCAnbGF4ICQuYScgZGVmYXVsdCAtMSBvbiBlbXB0eSwKKwkJCW5lc3RlZCBw YXRoICdzdHJpY3QgJC5iWypdJyBhcyBwYiBjb2x1bW5zICggYiBpbnQgcGF0aCAnJCcgKSwKKwkJ CW5lc3RlZCBwYXRoICdzdHJpY3QgJC5jWypdJyBhcyBwYyBjb2x1bW5zICggYyBpbnQgcGF0aCAn JCcgKQorCQkpCisJCXBsYW4gZGVmYXVsdCAoaW5uZXIpCisJKSBqdDsKKworLS0gc3BlY2lmaWMg cGxhbiAocCBpbm5lciAocGIgdW5pb24gcGMpKQorc2VsZWN0CisJanQuKgorZnJvbQorCWpzb25i X3RhYmxlX3Rlc3QganR0LAorCWpzb25fdGFibGUgKAorCQlqdHQuanMsJ3N0cmljdCAkWypdJyBh cyBwCisJCWNvbHVtbnMgKAorCQkJbiBmb3Igb3JkaW5hbGl0eSwKKwkJCWEgaW50IHBhdGggJ2xh eCAkLmEnIGRlZmF1bHQgLTEgb24gZW1wdHksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQuYlsq XScgYXMgcGIgY29sdW1ucyAoIGIgaW50IHBhdGggJyQnICksCisJCQluZXN0ZWQgcGF0aCAnc3Ry aWN0ICQuY1sqXScgYXMgcGMgY29sdW1ucyAoIGMgaW50IHBhdGggJyQnICkKKwkJKQorCQlwbGFu IChwIGlubmVyIChwYiB1bmlvbiBwYykpCisJKSBqdDsKKworLS0gZGVmYXVsdCBwbGFuIChpbm5l ciwgY3Jvc3MpCitzZWxlY3QKKwlqdC4qCitmcm9tCisJanNvbmJfdGFibGVfdGVzdCBqdHQsCisJ anNvbl90YWJsZSAoCisJCWp0dC5qcywnc3RyaWN0ICRbKl0nIGFzIHAKKwkJY29sdW1ucyAoCisJ CQluIGZvciBvcmRpbmFsaXR5LAorCQkJYSBpbnQgcGF0aCAnbGF4ICQuYScgZGVmYXVsdCAtMSBv biBlbXB0eSwKKwkJCW5lc3RlZCBwYXRoICdzdHJpY3QgJC5iWypdJyBhcyBwYiBjb2x1bW5zICgg YiBpbnQgcGF0aCAnJCcgKSwKKwkJCW5lc3RlZCBwYXRoICdzdHJpY3QgJC5jWypdJyBhcyBwYyBj b2x1bW5zICggYyBpbnQgcGF0aCAnJCcgKQorCQkpCisJCXBsYW4gZGVmYXVsdCAoY3Jvc3MsIGlu bmVyKQorCSkganQ7CisKKy0tIHNwZWNpZmljIHBsYW4gKHAgaW5uZXIgKHBiIGNyb3NzIHBjKSkK K3NlbGVjdAorCWp0LioKK2Zyb20KKwlqc29uYl90YWJsZV90ZXN0IGp0dCwKKwlqc29uX3RhYmxl ICgKKwkJanR0LmpzLCdzdHJpY3QgJFsqXScgYXMgcAorCQljb2x1bW5zICgKKwkJCW4gZm9yIG9y ZGluYWxpdHksCisJCQlhIGludCBwYXRoICdsYXggJC5hJyBkZWZhdWx0IC0xIG9uIGVtcHR5LAor CQkJbmVzdGVkIHBhdGggJ3N0cmljdCAkLmJbKl0nIGFzIHBiIGNvbHVtbnMgKCBiIGludCBwYXRo ICckJyApLAorCQkJbmVzdGVkIHBhdGggJ3N0cmljdCAkLmNbKl0nIGFzIHBjIGNvbHVtbnMgKCBj IGludCBwYXRoICckJyApCisJCSkKKwkJcGxhbiAocCBpbm5lciAocGIgY3Jvc3MgcGMpKQorCSkg anQ7CisKKy0tIGRlZmF1bHQgcGxhbiAob3V0ZXIsIGNyb3NzKQorc2VsZWN0CisJanQuKgorZnJv bQorCWpzb25iX3RhYmxlX3Rlc3QganR0LAorCWpzb25fdGFibGUgKAorCQlqdHQuanMsJ3N0cmlj dCAkWypdJyBhcyBwCisJCWNvbHVtbnMgKAorCQkJbiBmb3Igb3JkaW5hbGl0eSwKKwkJCWEgaW50 IHBhdGggJ2xheCAkLmEnIGRlZmF1bHQgLTEgb24gZW1wdHksCisJCQluZXN0ZWQgcGF0aCAnc3Ry aWN0ICQuYlsqXScgYXMgcGIgY29sdW1ucyAoIGIgaW50IHBhdGggJyQnICksCisJCQluZXN0ZWQg cGF0aCAnc3RyaWN0ICQuY1sqXScgYXMgcGMgY29sdW1ucyAoIGMgaW50IHBhdGggJyQnICkKKwkJ KQorCQlwbGFuIGRlZmF1bHQgKG91dGVyLCBjcm9zcykKKwkpIGp0OworCistLSBzcGVjaWZpYyBw bGFuIChwIG91dGVyIChwYiBjcm9zcyBwYykpCitzZWxlY3QKKwlqdC4qCitmcm9tCisJanNvbmJf dGFibGVfdGVzdCBqdHQsCisJanNvbl90YWJsZSAoCisJCWp0dC5qcywnc3RyaWN0ICRbKl0nIGFz IHAKKwkJY29sdW1ucyAoCisJCQluIGZvciBvcmRpbmFsaXR5LAorCQkJYSBpbnQgcGF0aCAnbGF4 ICQuYScgZGVmYXVsdCAtMSBvbiBlbXB0eSwKKwkJCW5lc3RlZCBwYXRoICdzdHJpY3QgJC5iWypd JyBhcyBwYiBjb2x1bW5zICggYiBpbnQgcGF0aCAnJCcgKSwKKwkJCW5lc3RlZCBwYXRoICdzdHJp Y3QgJC5jWypdJyBhcyBwYyBjb2x1bW5zICggYyBpbnQgcGF0aCAnJCcgKQorCQkpCisJCXBsYW4g KHAgb3V0ZXIgKHBiIGNyb3NzIHBjKSkKKwkpIGp0OworCisKK3NlbGVjdAorCWp0LiosIGIxICsg MTAwIGFzIGIKK2Zyb20KKwlqc29uX3RhYmxlIChqc29uYgorCQknWworCQkJeyJhIjogIDEsICAi YiI6IFtbMSwgMTBdLCBbMl0sIFszLCAzMCwgMzAwXV0sICJjIjogWzEsIG51bGwsIDJdfSwKKwkJ CXsiYSI6ICAyLCAgImIiOiBbMTAsIDIwXSwgImMiOiBbMSwgbnVsbCwgMl19LAorCQkJeyJ4Ijog IjMiLCAiYiI6IFsxMSwgMjIsIDMzLCA0NF19CisJCSBdJywKKwkJJyRbKl0nIGFzIHAKKwkJY29s dW1ucyAoCisJCQluIGZvciBvcmRpbmFsaXR5LAorCQkJYSBpbnQgcGF0aCAnbGF4ICQuYScgZGVm YXVsdCAtMSBvbiBlcnJvciwKKwkJCW5lc3RlZCBwYXRoICdzdHJpY3QgJC5iWypdJyBhcyBwYiBj b2x1bW5zICgKKwkJCQliIHRleHQgZm9ybWF0IGpzb24gcGF0aCAnJCcsCisJCQkJbmVzdGVkIHBh dGggJ3N0cmljdCAkWypdJyBhcyBwYjEgY29sdW1ucyAoCisJCQkJCWIxIGludCBwYXRoICckJwor CQkJCSkKKwkJCSksCisJCQluZXN0ZWQgcGF0aCAnc3RyaWN0ICQuY1sqXScgYXMgcGMgY29sdW1u cyAoCisJCQkJYyB0ZXh0IGZvcm1hdCBqc29uIHBhdGggJyQnLAorCQkJCW5lc3RlZCBwYXRoICdz dHJpY3QgJFsqXScgYXMgcGMxIGNvbHVtbnMgKAorCQkJCQljMSBpbnQgcGF0aCAnJCcKKwkJCQkp CisJCQkpCisJCSkKKwkJLS1wbGFuIGRlZmF1bHQob3V0ZXIsIGNyb3NzKQorCQlwbGFuKHAgb3V0 ZXIgKChwYiBpbm5lciBwYjEpIGNyb3NzIChwYyBvdXRlciBwYzEpKSkKKwkpIGp0OworCistLSBT aG91bGQgc3VjY2VlZCAoSlNPTiBhcmd1bWVudHMgYXJlIHBhc3NlZCB0byByb290IGFuZCBuZXN0 ZWQgcGF0aHMpCitTRUxFQ1QgKgorRlJPTQorCWdlbmVyYXRlX3NlcmllcygxLCA0KSB4LAorCWdl bmVyYXRlX3NlcmllcygxLCAzKSB5LAorCUpTT05fVEFCTEUoanNvbmIKKwkJJ1tbMSwyLDNdLFsy LDMsNCw1XSxbMyw0LDUsNl1dJywKKwkJJ3N0cmljdCAkWypdID8gKEBbKl0gPCAkeCknCisJCVBB U1NJTkcgeCBBUyB4LCB5IEFTIHkKKwkJQ09MVU1OUyAoCisJCQl5IHRleHQgRk9STUFUIEpTT04g UEFUSCAnJCcsCisJCQlORVNURUQgUEFUSCAnc3RyaWN0ICRbKl0gPyAoQCA+PSAkeSknCisJCQlD T0xVTU5TICgKKwkJCQl6IGludCBQQVRIICckJworCQkJKQorCQkpCisJKSBqdDsKKworLS0gU2hv dWxkIGZhaWwgKEpTT04gYXJndW1lbnRzIGFyZSBub3QgcGFzc2VkIHRvIGNvbHVtbiBwYXRocykK K1NFTEVDVCAqCitGUk9NIEpTT05fVEFCTEUoCisJanNvbmIgJ1sxLDIsM10nLAorCSckWypdID8g KEAgPCAkeCknCisJCVBBU1NJTkcgMTAgQVMgeAorCQlDT0xVTU5TICh5IHRleHQgRk9STUFUIEpT T04gUEFUSCAnJCA/IChAIDwgJHgpJykKKwkpIGp0OworCistLSBFeHRlbnNpb246IG5vbi1jb25z dGFudCBKU09OIHBhdGgKK1NFTEVDVCBKU09OX0VYSVNUUyhqc29uYiAneyJhIjogMTIzfScsICck JyB8fCAnLicgfHwgJ2EnKTsKK1NFTEVDVCBKU09OX1ZBTFVFKGpzb25iICd7ImEiOiAxMjN9Jywg JyQnIHx8ICcuJyB8fCAnYScpOworU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJ3siYSI6IDEyM30n LCAnJCcgfHwgJy4nIHx8ICdiJyBERUZBVUxUICdmb28nIE9OIEVNUFRZKTsKK1NFTEVDVCBKU09O X1FVRVJZKGpzb25iICd7ImEiOiAxMjN9JywgJyQnIHx8ICcuJyB8fCAnYScpOworU0VMRUNUIEpT T05fUVVFUlkoanNvbmIgJ3siYSI6IDEyM30nLCAnJCcgfHwgJy4nIHx8ICdhJyBXSVRIIFdSQVBQ RVIpOworLS0gU2hvdWxkIGZhaWwgKGludmFsaWQgcGF0aCkKK1NFTEVDVCBKU09OX1FVRVJZKGpz b25iICd7ImEiOiAxMjN9JywgJ2Vycm9yJyB8fCAnICcgfHwgJ2Vycm9yJyk7CistLSBTaG91bGQg ZmFpbCAobm90IHN1cHBvcnRlZCkKK1NFTEVDVCAqIEZST00gSlNPTl9UQUJMRShqc29uYiAneyJh IjogMTIzfScsICckJyB8fCAnLicgfHwgJ2EnIENPTFVNTlMgKGZvbyBpbnQpKTsKZGlmZiAtLWdp dCBhL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0IGIvc3JjL3Rvb2xzL3BnaW5kZW50 L3R5cGVkZWZzLmxpc3QKaW5kZXggYmM2ZGE0YjRkMi4uMmQyNjQ4OGJjZCAxMDA2NDQKLS0tIGEv c3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKKysrIGIvc3JjL3Rvb2xzL3BnaW5kZW50 L3R5cGVkZWZzLmxpc3QKQEAgLTEzMTcsNiArMTMxNyw3IEBAIEpzb25QYXRoTXV0YWJsZUNvbnRl eHQKIEpzb25QYXRoUGFyc2VJdGVtCiBKc29uUGF0aFBhcnNlUmVzdWx0CiBKc29uUGF0aFByZWRp Y2F0ZUNhbGxiYWNrCitKc29uUGF0aFNwZWMKIEpzb25QYXRoU3RyaW5nCiBKc29uUGF0aFZhckNh bGxiYWNrCiBKc29uUGF0aFZhcmlhYmxlCkBAIC0xMzI2LDYgKzEzMjcsMjAgQEAgSnNvblJldHVy bmluZwogSnNvblNjYWxhckV4cHIKIEpzb25TZW1BY3Rpb24KIEpzb25TZXJpYWxpemVFeHByCitK c29uVGFibGUKK0pzb25UYWJsZUNvbHVtbgorSnNvblRhYmxlQ29sdW1uVHlwZQorSnNvblRhYmxl Q29udGV4dAorSnNvblRhYmxlUGFyc2VDb250ZXh0CitKc29uVGFibGVKb2luU3RhdGUKK0pzb25U YWJsZVBsYW4KK0pzb25UYWJsZVBsYW5TcGVjCitKc29uVGFibGVQbGFuU3RhdGUKK0pzb25UYWJs ZVBsYW5TdGF0ZVR5cGUKK0pzb25UYWJsZVBsYW5Kb2luVHlwZQorSnNvblRhYmxlUGxhblR5cGUK K0pzb25UYWJsZVNjYW5TdGF0ZQorSnNvblRhYmxlU2libGluZwogSnNvblRva2VuVHlwZQogSnNv blRyYW5zZm9ybVN0cmluZ1ZhbHVlc0FjdGlvbgogSnNvblR5cGVDYXRlZ29yeQpAQCAtMjc5Miw2 ICsyODA3LDcgQEAgVGFibGVGdW5jCiBUYWJsZUZ1bmNSb3V0aW5lCiBUYWJsZUZ1bmNTY2FuCiBU YWJsZUZ1bmNTY2FuU3RhdGUKK1RhYmxlRnVuY1R5cGUKIFRhYmxlSW5mbwogVGFibGVMaWtlQ2xh dXNlCiBUYWJsZVNhbXBsZUNsYXVzZQotLSAKMi4zNS4zCgo= --00000000000078edb1060f38208c--