Content-Type: multipart/mixed; boundary="------------2fGzZEmgSOPtun574i5o0ymG"
Message-ID: <225d341b-f310-eed0-ceff-b8ec61669d9f@postgrespro.ru>
Date: Tue, 16 Aug 2022 04:02:17 +0300
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:91.0) Gecko/20100101
 Thunderbird/91.11.0
Subject: Re: SQL/JSON features for v15
Content-Language: en-US
To: Andres Freund <andres@anarazel.de>,
 "Jonathan S. Katz" <jkatz@postgresql.org>
Cc: PostgreSQL Hackers <pgsql-hackers@lists.postgresql.org>,
 Andrew Dunstan <andrew@dunslane.net>, Tom Lane <tgl@sss.pgh.pa.us>,
 Michael Paquier <michael@paquier.xyz>,
 John Naylor <john.naylor@enterprisedb.com>,
 Amit Langote <amitlangote09@gmail.com>
References: <abd9b83b-aa66-f230-3d6d-734817f0995d@postgresql.org>
 <20220815223853.itrlpqgpqheg6r6a@awork3.anarazel.de>
From: Nikita Glukhov <n.gluhov@postgrespro.ru>
In-Reply-To: <20220815223853.itrlpqgpqheg6r6a@awork3.anarazel.de>
Archived-At: 
 <https://www.postgresql.org/message-id/225d341b-f310-eed0-ceff-b8ec61669d9f%40postgrespro.ru>
Precedence: bulk

This is a multi-part message in MIME format.
--------------2fGzZEmgSOPtun574i5o0ymG
Content-Type: multipart/alternative;
 boundary="------------v9TA1w8y0Rzvz0o66VlWYfEy"

--------------v9TA1w8y0Rzvz0o66VlWYfEy
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit

Hi,


On 16.08.2022 01:38, Andres Freund wrote:
> Continuation from the thread at
> https://postgr.es/m/20220811171740.m5b4h7x63g4lzgrk%40awork3.anarazel.de
>
>
> I started hacking on this Friday.  I think there's some relatively easy
> improvements that make the code substantially more understandable, at least
> for me, without even addressing the structural stuff.

I also started hacking Friday, hacked all weekend, and now have a new
version of the patch.

I received your message when I finished writing of mine, so I will
try answer your new questions only in next message.  But in short, I
can say that some things like ExecEvalJsonExprSubtrans() were fixed.


I took Amit's patch and tried to simplify execution further.
Explanation of the patches is at the very end of message.

Next, I try to answer some of previous questions.

On Aug 2, 2022 at 9:39 AM Andres Freund<andres@anarazel.de>  wrote:
> The whole coercion stuff just seems incredibly clunky (in a
> slightly different shape before this patch).
> ExecEvalJsonExprItemCoercion() calls ExecPrepareJsonItemCoercion(),
> which gets a pointer to one of the per-type elements in
> JsonItemCoercionsState, dispatching on the type of the json
> object.  Then we later call ExecGetJsonItemCoercion() (via a
> convoluted path), which again will dispatch on the type
> (extracting the json object again afaics!), to then somehow
> eventually get the coerced value.  I think it might be possible
> to make this a bit simpler, by not leaving anything
> coercion-related in ExecEvalJsonExpr().

On 2022-08-02 12:05:55 +0900, Amit Langote wrote:
> I left some pieces there, because I thought the error of not finding an
> appropriate coercion must be thrown right away as the code in
> ExecEvalJsonExpr() does after calling ExecGetJsonItemCoercion().

> ExecPrepareJsonItemCoercion() is called later when it's time to
> actually evaluate the coercion.  If we move the error path to
> ExecPrepareJsonItemCoercion(), both ExecGetJsonItemCoercion() and the
> error path code in ExecEvalJsonExpr() will be unnecessary.  I will
> give that a try.

The first dispatch is done only for throwing error about missing cast
without starting subtransaction in which second dispatch is executed.
I agree, this is bad that result of first dispatch is not used later,
and I have removed second dispatch.


> I don't understand the design of what needs to have error handling,
> and what not.

> I don't think subtransactions per-se are a fundamental problem.
> I think the error handling implementation is ridiculously complicated,
> and while I started to hack on improving it, I stopped when I really
> couldn't understand what errors it actually needs to handle when and
> why.

Here is the diagram that may help to understand error handling in
SQL/JSON functions (I hope it will be displayed correctly):


  JSON path  -------
  expression        \
                     ->+-----------+    SQL/JSON    +----------+  Result
  PASSING args ------->| JSON path |--> item or --->|  Output  |-> SQL
                     ->|  executor |     JSONB   .->| Coercion |  value
                    /  +-----------+     datum   |  +----------+
   JSON     + - - - -+   |      |                |       |
  Context ->: FORMAT :   v      v                |       v
   item     : JSON   : error? empty?             |     error?
            + - - - -+   |      |                |       |
                |        | +----------+          |      /
                v        | | ON EMPTY |--> SQL --'     /
              error?     | +----------+   value       /
                |        |      |                    /
                 \       |      v                   /
                  \       \   error?               /
                   \       \    |                 /
                    \______ \   |   _____________/
                           \ \  |  /
                            v v v v       +----------+
                          +----------+    |  Output  |   Result
                          | ON ERROR |--->| Coercion |--> SQL
                          +----------+    +----------+   value
                                |              |
                                V              V
                            EXCEPTION      EXCEPTION


The first dashed box "FORMAT JSON" used for parsing JSON is absent in
our implementation, because we support only jsonb type which is
pre-parsed.  This could be used in queries like that:
JSON_VALUE('invalid json', '$' DEFAULT 'error' ON ERROR) => 'error'

JSON path executor already has error handling and does not need
subtransactions.  We had to add functions like numeric_add_opt_error()
which return error flag instead of throwing exceptions.


On Aug 10, 2022 at 3:57 AM Andres Freund<andres@anarazel.de>  wrote:
>>> One way this code could be drastically simplified is to force all
>>> type-coercions to go through the "io coercion" path, which could be
>>> implemented as a single execution step (which thus could trivially
>>> start/finish a subtransaction) and would remove a lot of the
>>> complicated code around coercions.

>> Could you please clarify how you think we might do the io coercion
>> wrapped with a subtransaction all as a single execution step?  I
>> would've thought that we couldn't do the sub-transaction without
>> leaving ExecInterpExpr() anyway, so maybe you meant the io coercion
>> itself was done using some code outside ExecInterpExpr()?

>> The current JsonExpr code does it by recursively calling
>> ExecInterpExpr() using the nested ExprState expressly for the
>> coercion.

> The basic idea is to rip out all the type-dependent stuff out and
> replace it with a single JSON_IOCERCE step, which has a parameter
> about whether to wrap things in a subtransaction or not. That step
> would always perform the coercion by calling the text output function
> of the input and the text input function of the output.

On Aug 3, 2022 at 12:00 AM Andres Freund<andres@anarazel.de>  wrote:
> But we don't need to wrap arbitrary evaluation in a subtransaction -
> afaics the coercion calls a single function, not an arbitrary
> expression?

SQL standard says that scalar SQL/JSON items are converted to SQL type
through  CAST(corresponding_SQL_type_for_item AS returning_type).
Our JSON_VALUE implementation supports arbitrary output types that can
have specific CASTs from numeric, bool, datetime, which we can't
emulate with simple I/O coercion.  But supporting of arbitrary types
may be dangerous, because SQL standard denotes only a limited set of
types:

   The <data type> contained in the explicit or implicit
   <JSON returning clause> shall be a <predefined type> that identifies
   a character string data type, numeric data type, boolean data type,
   or datetime data type.

I/O coercion will not even work in the following simple case:
  JSON_VALUE('1.23', '$' RETURNING int)
It is expected to return 1::int, like ordinary cast 1.23::numeric::int.

Exceptions may come not only from coercions.  Expressions in DEFAULT ON
EMPTY can also throw exceptions, which also must be handled.

Here is excerpt from ISO/IEC 19075-6:2021(E) "Part 6: Support for JSON",
which explains SQL standard features in human-readable manner:

   6.4.3 JSON_VALUE:

   <JSON value error behavior> specifies what to do if there is an
   unhandled error.  Unhandled errors can arise if there is an input
   conversion error (for example, if the context item cannot be parsed),
   an error returned by the SQL/JSON path engine, or an output
   conversion error.  The choices are the same as for
   <JSON value empty behavior>.

   When using DEFAULT <value expression> for either the empty or error
   behavior, what happens if the <value expression> raises an exception?
   The answer is that an error during empty behavior "falls through"
   to the error behavior.  If the error behavior itself has an error,
   there is no further recourse but to raise the exception.

So, we need to support execution of arbitrary expressions inside a
subtransaction, and do not try to somehow simplify coercions.


In Amit's fix, wrapping DEFAULT ON EMPTY into subtransactions was
lost, mainly because there were no tests for this case.  The following
test should not fall on the second row:

   SELECT JSON_VALUE(jsonb '1', '$.a' RETURNING int
                     DEFAULT 1 / x ON EMPTY
                     DEFAULT 2 ON ERROR)
   FROM (VALUES (1::int), (0)) x(x);

    json_value
   ------------
    1
    2

I have added this test in 0003.


On Aug 3, 2022 at 12:00 AM Andres Freund<andres@anarazel.de>  wrote:
> On 2022-08-02 12:05:55 +0900, Amit Langote wrote:
>> I am not really sure if different coercions may be used
>> in the same query over multiple evaluations of the same JSON path
>> expression, but maybe that's also possible.

> Even if the type can change, I don't think that means we need to have
> space for multiple types at the same time - there can't be multiple
> coercions happening at the same time, otherwise there could be two
> coercions of the same type as well.  So we don't need memory for
> every coercion type.

Only the one item coercion is used in execution of JSON_VALUE().
Multiple coercions could be executed, if we supported quite useful SRF
JSON_QUERY() using "RETURNING SETOF type" (I had this idea for a long
time, but I didn't dare to implement it).

I don't understand what "memory" you mean.  If we will not emit all
possible expressions statically, we will need to generate them
dynamically at run-time, and this could be hardly acceptable.  In the
last version of the fix there is only 4 bytes (int jump) of additional
state space per coercion.


On Aug 6, 2022 at 5:37 Andres Freund<andres@anarazel.de>  wrote:
> There's one layer of subtransactions in one of the paths in
> ExecEvalJsonExpr(), another in ExecEvalJson(). Some paths of
> ExecEvalJsonExpr() go through subtransactions, others don't.

Really, there is only one level of subtransactions. Outer subtransaction
may be used for FORMAT JSON handling which always requires
subtransaction at the beginning of expression execution.
Inner subtransactions are conditional, they are started only and when
there is no outer subtransaction.

Now, outer subtransactions are not used at all,
ExecEvalJsonNeedsSubtransaction(NULL) always returns false. (AFAIR,
FORMAT JSON was present in older version of SQL/JSON patches, then it
was removed, but outer subtransactions were not).  In the last version
of the fix I have removed them completely and moved inner
subtransactions into a separate executor step (see below).


The description of the patches:

0001 - Fix returning of json[b] domains in JSON_VALUE()

(This may require a separate thread.)

I found a bug in returning json[b] domains in JSON_VALUE(). json[b]
has special processing in JSON_VALUE, bypassing oridinary
SQL/JSON item type => SQL type coercions.  But json[b] domains miss
this processing:

   CREATE DOMAIN jsonb_not_null AS jsonb NOT NULL;

   SELECT JSON_VALUE('"123"', '$' RETURNING jsonb);
     "123"

   SELECT JSON_VALUE( '123',  '$' RETURNING jsonb);
     123

   SELECT JSON_VALUE('"123"', '$' RETURNING jsonb_not_null);
     123

   SELECT JSON_VALUE( '123',  '$' RETURNING jsonb_not_null ERROR ON ERROR);
     ERROR: SQL/JSON item cannot be cast to target type

Fixed by examinating output base type in parse_expr.c and skipping
allocation of item coercions, what later will be a signal for special
processing in ExecEvalJsonExpr().


0002 - Add EEOP_SUBTRANS executor step

On 2022-08-02 12:05:55 +0900, Amit Langote wrote:
> So, the problem with inlining coercion evaluation into the main parent
> JsonExpr's is that it needs to be wrapped in a sub-transaction to
> catch any errors and return NULL instead.  I don't know a way to wrap
> ExprEvalStep evaluation in a sub-transaction to achieve that effect.

I also don't know way to run subtransactions without recursion in
executor, but I still managed to elimiate subsidary ExprStates.

I have introduced new EEOP_SUBTRANS step which executes its subsequent
steps in a subtransaction.  It recursively calls a new variant of
ExecInterpExpr() in which starting stepno is passed.  The return from
subtransaction is done with EEOP_DONE step that emitted after
subexpression.  This step can be reused for other future expressions,
that's why it has no JSON prefix in its name (you could see recent
message in the thread about casts with default values, which are
missing in PostgreSQL).

But for JIT I still had to construct additional ExprState with a
function compiled from subexpression steps.


0003 - Simplify JsonExpr execution:

  - New EEOP_SUBTRANS was used to wrap individual coercion expressions:
      after execution it jumps to "done" or "onerror" step
  - JSONEXPR_ITEM_COERCE step was removed
  - JSONEXPR_COERCE split into JSONEXPR_IOCOERCE and JSONEXPR_POPULATE
  - Removed all JsonExprPostEvalState
  - JSONEXPR step simply returns jump address to one of its possible
    continuations: done, onempty, onerror, coercion, coercion_subtrans,
    io_coercion or one of item_coercions
  - Fixed JsonExprNeedsSubTransaction(): considired more cases
  - Eliminated transactions on Const expressions

-- 
Nikita Glukhov
Postgres Professional:http://www.postgrespro.com
The Russian Postgres Company

--------------v9TA1w8y0Rzvz0o66VlWYfEy
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: 7bit

<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  </head>
  <body>
    <pre>Hi,</pre>
    <br>
    <div class="moz-cite-prefix">On 16.08.2022 01:38, Andres Freund
      wrote:
    </div>
    <blockquote type="cite"
      cite="mid:20220815223853.itrlpqgpqheg6r6a@awork3.anarazel.de">
      <pre class="moz-quote-pre" wrap="">Continuation from the thread at
<a class="moz-txt-link-freetext" href="https://postgr.es/m/20220811171740.m5b4h7x63g4lzgrk%40awork3.anarazel.de">https://postgr.es/m/20220811171740.m5b4h7x63g4lzgrk%40awork3.anarazel.de</a>


I started hacking on this Friday.  I think there's some relatively easy
improvements that make the code substantially more understandable, at least
for me, without even addressing the structural stuff.
</pre>
    </blockquote>
    <pre>
I also started hacking Friday, hacked all weekend, and now have a new
version of the patch.

I received your message when I finished writing of mine, so I will
try answer your new questions only in next message.  But in short, I
can say that some things like ExecEvalJsonExprSubtrans() were fixed.


I took Amit's patch and tried to simplify execution further.
Explanation of the patches is at the very end of message.

Next, I try to answer some of previous questions.

On Aug 2, 2022 at 9:39 AM Andres Freund <a class="moz-txt-link-rfc2396E" href="mailto:andres@anarazel.de">&lt;andres@anarazel.de&gt;</a> wrote:
&gt; The whole coercion stuff just seems incredibly clunky (in a
&gt; slightly different shape before this patch).
&gt; ExecEvalJsonExprItemCoercion() calls ExecPrepareJsonItemCoercion(),
&gt; which gets a pointer to one of the per-type elements in
&gt; JsonItemCoercionsState, dispatching on the type of the json
&gt; object.  Then we later call ExecGetJsonItemCoercion() (via a
&gt; convoluted path), which again will dispatch on the type
&gt; (extracting the json object again afaics!), to then somehow
&gt; eventually get the coerced value.  I think it might be possible
&gt; to make this a bit simpler, by not leaving anything
&gt; coercion-related in ExecEvalJsonExpr().

On 2022-08-02 12:05:55 +0900, Amit Langote wrote:
&gt; I left some pieces there, because I thought the error of not finding an
&gt; appropriate coercion must be thrown right away as the code in
&gt; ExecEvalJsonExpr() does after calling ExecGetJsonItemCoercion().

&gt; ExecPrepareJsonItemCoercion() is called later when it's time to
&gt; actually evaluate the coercion.  If we move the error path to
&gt; ExecPrepareJsonItemCoercion(), both ExecGetJsonItemCoercion() and the
&gt; error path code in ExecEvalJsonExpr() will be unnecessary.  I will
&gt; give that a try.

The first dispatch is done only for throwing error about missing cast
without starting subtransaction in which second dispatch is executed.
I agree, this is bad that result of first dispatch is not used later,
and I have removed second dispatch.


&gt; I don't understand the design of what needs to have error handling,
&gt; and what not.

&gt; I don't think subtransactions per-se are a fundamental problem.
&gt; I think the error handling implementation is ridiculously complicated,
&gt; and while I started to hack on improving it, I stopped when I really
&gt; couldn't understand what errors it actually needs to handle when and
&gt; why.

Here is the diagram that may help to understand error handling in
SQL/JSON functions (I hope it will be displayed correctly):


 JSON path  -------
 expression        \
                    -&gt;+-----------+    SQL/JSON    +----------+  Result
 PASSING args -------&gt;| JSON path |--&gt; item or ---&gt;|  Output  |-&gt; SQL
                    -&gt;|  executor |     JSONB   .-&gt;| Coercion |  value
                   /  +-----------+     datum   |  +----------+
  JSON     + - - - -+   |      |                |       |
 Context -&gt;: FORMAT :   v      v                |       v
  item     : JSON   : error? empty?             |     error?
           + - - - -+   |      |                |       |
               |        | +----------+          |      /
               v        | | ON EMPTY |--&gt; SQL --'     /
             error?     | +----------+   value       /
               |        |      |                    /
                \       |      v                   /
                 \       \   error?               /
                  \       \    |                 /
                   \______ \   |   _____________/
                          \ \  |  /
                           v v v v       +----------+
                         +----------+    |  Output  |   Result
                         | ON ERROR |---&gt;| Coercion |--&gt; SQL
                         +----------+    +----------+   value
                               |              |
                               V              V
                           EXCEPTION      EXCEPTION


The first dashed box "FORMAT JSON" used for parsing JSON is absent in
our implementation, because we support only jsonb type which is
pre-parsed.  This could be used in queries like that:
JSON_VALUE('invalid json', '$' DEFAULT 'error' ON ERROR) =&gt; 'error'

JSON path executor already has error handling and does not need
subtransactions.  We had to add functions like numeric_add_opt_error()
which return error flag instead of throwing exceptions.


On Aug 10, 2022 at 3:57 AM Andres Freund <a class="moz-txt-link-rfc2396E" href="mailto:andres@anarazel.de">&lt;andres@anarazel.de&gt;</a> wrote:
&gt;&gt;&gt; One way this code could be drastically simplified is to force all
&gt;&gt;&gt; type-coercions to go through the "io coercion" path, which could be
&gt;&gt;&gt; implemented as a single execution step (which thus could trivially
&gt;&gt;&gt; start/finish a subtransaction) and would remove a lot of the
&gt;&gt;&gt; complicated code around coercions.

&gt;&gt; Could you please clarify how you think we might do the io coercion
&gt;&gt; wrapped with a subtransaction all as a single execution step?  I
&gt;&gt; would've thought that we couldn't do the sub-transaction without
&gt;&gt; leaving ExecInterpExpr() anyway, so maybe you meant the io coercion
&gt;&gt; itself was done using some code outside ExecInterpExpr()?

&gt;&gt; The current JsonExpr code does it by recursively calling
&gt;&gt; ExecInterpExpr() using the nested ExprState expressly for the
&gt;&gt; coercion.

&gt; The basic idea is to rip out all the type-dependent stuff out and
&gt; replace it with a single JSON_IOCERCE step, which has a parameter
&gt; about whether to wrap things in a subtransaction or not. That step
&gt; would always perform the coercion by calling the text output function
&gt; of the input and the text input function of the output.

On Aug 3, 2022 at 12:00 AM Andres Freund <a class="moz-txt-link-rfc2396E" href="mailto:andres@anarazel.de">&lt;andres@anarazel.de&gt;</a> wrote:
&gt; But we don't need to wrap arbitrary evaluation in a subtransaction -
&gt; afaics the coercion calls a single function, not an arbitrary
&gt; expression?

SQL standard says that scalar SQL/JSON items are converted to SQL type
through  CAST(corresponding_SQL_type_for_item AS returning_type).
Our JSON_VALUE implementation supports arbitrary output types that can
have specific CASTs from numeric, bool, datetime, which we can't
emulate with simple I/O coercion.  But supporting of arbitrary types
may be dangerous, because SQL standard denotes only a limited set of
types:

  The &lt;data type&gt; contained in the explicit or implicit
  &lt;JSON returning clause&gt; shall be a &lt;predefined type&gt; that identifies
  a character string data type, numeric data type, boolean data type,
  or datetime data type.

I/O coercion will not even work in the following simple case:
 JSON_VALUE('1.23', '$' RETURNING int)
It is expected to return 1::int, like ordinary cast 1.23::numeric::int.

Exceptions may come not only from coercions.  Expressions in DEFAULT ON
EMPTY can also throw exceptions, which also must be handled.

Here is excerpt from ISO/IEC 19075-6:2021(E) "Part 6: Support for JSON",
which explains SQL standard features in human-readable manner:

  6.4.3 JSON_VALUE:

  &lt;JSON value error behavior&gt; specifies what to do if there is an
  unhandled error.  Unhandled errors can arise if there is an input
  conversion error (for example, if the context item cannot be parsed),
  an error returned by the SQL/JSON path engine, or an output
  conversion error.  The choices are the same as for
  &lt;JSON value empty behavior&gt;.

  When using DEFAULT &lt;value expression&gt; for either the empty or error
  behavior, what happens if the &lt;value expression&gt; raises an exception?
  The answer is that an error during empty behavior "falls through"
  to the error behavior.  If the error behavior itself has an error,
  there is no further recourse but to raise the exception.

So, we need to support execution of arbitrary expressions inside a
subtransaction, and do not try to somehow simplify coercions.


In Amit's fix, wrapping DEFAULT ON EMPTY into subtransactions was
lost, mainly because there were no tests for this case.  The following
test should not fall on the second row:

  SELECT JSON_VALUE(jsonb '1', '$.a' RETURNING int
                    DEFAULT 1 / x ON EMPTY
                    DEFAULT 2 ON ERROR)
  FROM (VALUES (1::int), (0)) x(x);

   json_value
  ------------
   1
   2

I have added this test in 0003.


On Aug 3, 2022 at 12:00 AM Andres Freund <a class="moz-txt-link-rfc2396E" href="mailto:andres@anarazel.de">&lt;andres@anarazel.de&gt;</a> wrote:
&gt; On 2022-08-02 12:05:55 +0900, Amit Langote wrote:
&gt;&gt; I am not really sure if different coercions may be used
&gt;&gt; in the same query over multiple evaluations of the same JSON path
&gt;&gt; expression, but maybe that's also possible.

&gt; Even if the type can change, I don't think that means we need to have
&gt; space for multiple types at the same time - there can't be multiple
&gt; coercions happening at the same time, otherwise there could be two
&gt; coercions of the same type as well.  So we don't need memory for
&gt; every coercion type.

Only the one item coercion is used in execution of JSON_VALUE().
Multiple coercions could be executed, if we supported quite useful SRF
JSON_QUERY() using "RETURNING SETOF type" (I had this idea for a long
time, but I didn't dare to implement it).

I don't understand what "memory" you mean.  If we will not emit all
possible expressions statically, we will need to generate them
dynamically at run-time, and this could be hardly acceptable.  In the
last version of the fix there is only 4 bytes (int jump) of additional
state space per coercion.


On Aug 6, 2022 at 5:37 Andres Freund <a class="moz-txt-link-rfc2396E" href="mailto:andres@anarazel.de">&lt;andres@anarazel.de&gt;</a> wrote:
&gt; There's one layer of subtransactions in one of the paths in
&gt; ExecEvalJsonExpr(), another in ExecEvalJson(). Some paths of
&gt; ExecEvalJsonExpr() go through subtransactions, others don't.

Really, there is only one level of subtransactions. Outer subtransaction
may be used for FORMAT JSON handling which always requires
subtransaction at the beginning of expression execution.
Inner subtransactions are conditional, they are started only and when
there is no outer subtransaction.

Now, outer subtransactions are not used at all,
ExecEvalJsonNeedsSubtransaction(NULL) always returns false. (AFAIR,
FORMAT JSON was present in older version of SQL/JSON patches, then it
was removed, but outer subtransactions were not).  In the last version
of the fix I have removed them completely and moved inner
subtransactions into a separate executor step (see below).


The description of the patches:

0001 - Fix returning of json[b] domains in JSON_VALUE()

(This may require a separate thread.)

I found a bug in returning json[b] domains in JSON_VALUE(). json[b]
has special processing in JSON_VALUE, bypassing oridinary
SQL/JSON item type =&gt; SQL type coercions.  But json[b] domains miss
this processing:

  CREATE DOMAIN jsonb_not_null AS jsonb NOT NULL;

  SELECT JSON_VALUE('"123"', '$' RETURNING jsonb);
    "123"

  SELECT JSON_VALUE( '123',  '$' RETURNING jsonb);
    123

  SELECT JSON_VALUE('"123"', '$' RETURNING jsonb_not_null);
    123

  SELECT JSON_VALUE( '123',  '$' RETURNING jsonb_not_null ERROR ON ERROR);
    ERROR: SQL/JSON item cannot be cast to target type

Fixed by examinating output base type in parse_expr.c and skipping
allocation of item coercions, what later will be a signal for special
processing in ExecEvalJsonExpr().


0002 - Add EEOP_SUBTRANS executor step

On 2022-08-02 12:05:55 +0900, Amit Langote wrote:
&gt; So, the problem with inlining coercion evaluation into the main parent
&gt; JsonExpr's is that it needs to be wrapped in a sub-transaction to
&gt; catch any errors and return NULL instead.  I don't know a way to wrap
&gt; ExprEvalStep evaluation in a sub-transaction to achieve that effect.

I also don't know way to run subtransactions without recursion in
executor, but I still managed to elimiate subsidary ExprStates.

I have introduced new EEOP_SUBTRANS step which executes its subsequent
steps in a subtransaction.  It recursively calls a new variant of
ExecInterpExpr() in which starting stepno is passed.  The return from
subtransaction is done with EEOP_DONE step that emitted after
subexpression.  This step can be reused for other future expressions,
that's why it has no JSON prefix in its name (you could see recent
message in the thread about casts with default values, which are
missing in PostgreSQL).

But for JIT I still had to construct additional ExprState with a
function compiled from subexpression steps.


0003 - Simplify JsonExpr execution:

 - New EEOP_SUBTRANS was used to wrap individual coercion expressions:
     after execution it jumps to "done" or "onerror" step
 - JSONEXPR_ITEM_COERCE step was removed
 - JSONEXPR_COERCE split into JSONEXPR_IOCOERCE and JSONEXPR_POPULATE
 - Removed all JsonExprPostEvalState
 - JSONEXPR step simply returns jump address to one of its possible
   continuations: done, onempty, onerror, coercion, coercion_subtrans,
   io_coercion or one of item_coercions
 - Fixed JsonExprNeedsSubTransaction(): considired more cases
 - Eliminated transactions on Const expressions

</pre>
    <p>
    </p>
    <pre class="moz-signature" cols="72">-- 
Nikita Glukhov
Postgres Professional: <a class="moz-txt-link-freetext" href="http://www.postgrespro.com">http://www.postgrespro.com</a>
The Russian Postgres Company</pre>
  </body>
</html>

--------------v9TA1w8y0Rzvz0o66VlWYfEy--

--------------2fGzZEmgSOPtun574i5o0ymG
Content-Type: text/x-patch; charset=UTF-8;
 name="v6-0001-Fix-returning-of-json-b-domains-in-JSON_VALUE.patch"
Content-Disposition: attachment;
 filename*0="v6-0001-Fix-returning-of-json-b-domains-in-JSON_VALUE.patch"
Content-Transfer-Encoding: base64
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--------------2fGzZEmgSOPtun574i5o0ymG
Content-Type: text/x-patch; charset=UTF-8;
 name="v6-0002-Add-EEOP_SUBTRANS-executor-step.patch"
Content-Disposition: attachment;
 filename="v6-0002-Add-EEOP_SUBTRANS-executor-step.patch"
Content-Transfer-Encoding: base64
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==
--------------2fGzZEmgSOPtun574i5o0ymG
Content-Type: text/x-patch; charset=UTF-8;
 name="v6-0003-Simplify-JsonExpr-execution.patch"
Content-Disposition: attachment;
 filename="v6-0003-Simplify-JsonExpr-execution.patch"
Content-Transfer-Encoding: base64

RnJvbSA4NDJjMDAyNjQyYzA2ZDJkZDM3MWUxOTU1NDQyMzZhZTlhZDJlNzZlIE1vbiBTZXAg
MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBOaWtpdGEgR2x1a2hvdiA8bi5nbHVob3ZAcG9zdGdy
ZXNwcm8ucnU+CkRhdGU6IFR1ZSwgMTYgQXVnIDIwMjIgMDM6MTc6MTYgKzAzMDAKU3ViamVj
dDogW1BBVENIIHY2IDMvM10gU2ltcGxpZnkgSnNvbkV4cHIgZXhlY3V0aW9uCgotLS0KIHNy
Yy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNFeHByLmMgICAgICAgICAgICAgfCA2NzUgKysrKysr
KysrKysrKysrKystLS0KIHNyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNFeHBySW50ZXJwLmMg
ICAgICAgfCA2MDUgKysrKysrLS0tLS0tLS0tLS0tCiBzcmMvYmFja2VuZC9qaXQvbGx2bS9s
bHZtaml0X2V4cHIuYyAgICAgICAgIHwgMTM3ICsrKy0KIHNyYy9iYWNrZW5kL2ppdC9sbHZt
L2xsdm1qaXRfdHlwZXMuYyAgICAgICAgfCAgIDMgKwogc3JjL2JhY2tlbmQvb3B0aW1pemVy
L3V0aWwvY2xhdXNlcy5jICAgICAgICB8ICAgMiArLQogc3JjL2JhY2tlbmQvcGFyc2VyL3Bh
cnNlX2V4cHIuYyAgICAgICAgICAgICB8ICAxOCArLQogc3JjL2JhY2tlbmQvdXRpbHMvYWR0
L2pzb25wYXRoX2V4ZWMuYyAgICAgICB8ICA2OCArKwogc3JjL2luY2x1ZGUvZXhlY3V0b3Iv
ZXhlY0V4cHIuaCAgICAgICAgICAgICB8IDE1MCArKystLQogc3JjL2luY2x1ZGUvbm9kZXMv
cHJpbW5vZGVzLmggICAgICAgICAgICAgICB8ICAgOSArLQogc3JjL2luY2x1ZGUvdXRpbHMv
anNvbmIuaCAgICAgICAgICAgICAgICAgICB8ICAgMiArCiBzcmMvaW5jbHVkZS91dGlscy9q
c29ucGF0aC5oICAgICAgICAgICAgICAgIHwgICAzIC0KIHNyYy90ZXN0L3JlZ3Jlc3MvZXhw
ZWN0ZWQvanNvbmJfc3FsanNvbi5vdXQgfCAgMTcgKwogc3JjL3Rlc3QvcmVncmVzcy9zcWwv
anNvbmJfc3FsanNvbi5zcWwgICAgICB8ICAgNyArCiAxMyBmaWxlcyBjaGFuZ2VkLCAxMTEw
IGluc2VydGlvbnMoKyksIDU4NiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFj
a2VuZC9leGVjdXRvci9leGVjRXhwci5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY0V4
cHIuYwppbmRleCA5NjE5NmQ1MDg3Ni4uOTM3MDcyN2Q5MDIgMTAwNjQ0Ci0tLSBhL3NyYy9i
YWNrZW5kL2V4ZWN1dG9yL2V4ZWNFeHByLmMKKysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3Iv
ZXhlY0V4cHIuYwpAQCAtODYsNyArODYsOCBAQCBzdGF0aWMgdm9pZCBFeGVjQnVpbGRBZ2dU
cmFuc0NhbGwoRXhwclN0YXRlICpzdGF0ZSwgQWdnU3RhdGUgKmFnZ3N0YXRlLAogCQkJCQkJ
CQkgIEZ1bmN0aW9uQ2FsbEluZm8gZmNpbmZvLCBBZ2dTdGF0ZVBlclRyYW5zIHBlcnRyYW5z
LAogCQkJCQkJCQkgIGludCB0cmFuc25vLCBpbnQgc2V0bm8sIGludCBzZXRvZmYsIGJvb2wg
aXNoYXNoLAogCQkJCQkJCQkgIGJvb2wgbnVsbGNoZWNrKTsKLQorc3RhdGljIHZvaWQgRXhl
Y0luaXRKc29uRXhwcihFeHByRXZhbFN0ZXAgKnNjcmF0Y2gsIEpzb25FeHByICpqZXhwciwg
RXhwclN0YXRlICpzdGF0ZSwKKwkJCQkgRGF0dW0gKnJlc3YsIGJvb2wgKnJlc251bGwpOwog
CiBzdGF0aWMgRXhwclN0YXRlICoKIEV4ZWNJbml0RXhwckludGVybmFsKEV4cHIgKm5vZGUs
IFBsYW5TdGF0ZSAqcGFyZW50LCBQYXJhbUxpc3RJbmZvIGV4dF9wYXJhbXMsCkBAIC0xNzgs
NyArMTc5LDcgQEAgRXhlY0luaXRFeHByV2l0aFBhcmFtcyhFeHByICpub2RlLCBQYXJhbUxp
c3RJbmZvIGV4dF9wYXJhbXMpCiAgKiBFeGVjSW5pdEV4cHJXaXRoQ2FzZVZhbHVlOiBwcmVw
YXJlIGFuIGV4cHJlc3Npb24gdHJlZSBmb3IgZXhlY3V0aW9uCiAgKgogICogVGhpcyBpcyB0
aGUgc2FtZSBhcyBFeGVjSW5pdEV4cHIsIGV4Y2VwdCB0aGF0IGEgcG9pbnRlciB0byB0aGUg
dmFsdWUgZm9yCi0gKiBDYXNUZXN0RXhwciBpcyBwYXNzZWQgaGVyZS4KKyAqIENhc2VUZXN0
RXhwciBpcyBwYXNzZWQgaGVyZS4KICAqLwogRXhwclN0YXRlICoKIEV4ZWNJbml0RXhwcldp
dGhDYXNlVmFsdWUoRXhwciAqbm9kZSwgUGxhblN0YXRlICpwYXJlbnQsCkBAIC0yNTYxLDEx
MiArMjU2MiwyMCBAQCBFeGVjSW5pdEV4cHJSZWMoRXhwciAqbm9kZSwgRXhwclN0YXRlICpz
dGF0ZSwKIAkJY2FzZSBUX0pzb25FeHByOgogCQkJewogCQkJCUpzb25FeHByICAgKmpleHBy
ID0gY2FzdE5vZGUoSnNvbkV4cHIsIG5vZGUpOwotCQkJCUpzb25FeHByU3RhdGUgKmpzZXN0
YXRlID0gcGFsbG9jMChzaXplb2YoSnNvbkV4cHJTdGF0ZSkpOwotCQkJCUxpc3RDZWxsICAg
KmFyZ2V4cHJsYzsKLQkJCQlMaXN0Q2VsbCAgICphcmduYW1lbGM7Ci0KLQkJCQlzY3JhdGNo
Lm9wY29kZSA9IEVFT1BfSlNPTkVYUFI7Ci0JCQkJc2NyYXRjaC5kLmpzb25leHByLmpzZXN0
YXRlID0ganNlc3RhdGU7Ci0KLQkJCQlqc2VzdGF0ZS0+anNleHByID0gamV4cHI7Ci0KLQkJ
CQlqc2VzdGF0ZS0+Zm9ybWF0dGVkX2V4cHIgPQotCQkJCQlwYWxsb2Moc2l6ZW9mKCpqc2Vz
dGF0ZS0+Zm9ybWF0dGVkX2V4cHIpKTsKLQotCQkJCUV4ZWNJbml0RXhwclJlYygoRXhwciAq
KSBqZXhwci0+Zm9ybWF0dGVkX2V4cHIsIHN0YXRlLAotCQkJCQkJCQkmanNlc3RhdGUtPmZv
cm1hdHRlZF9leHByLT52YWx1ZSwKLQkJCQkJCQkJJmpzZXN0YXRlLT5mb3JtYXR0ZWRfZXhw
ci0+aXNudWxsKTsKLQotCQkJCWpzZXN0YXRlLT5wYXRoc3BlYyA9Ci0JCQkJCXBhbGxvYyhz
aXplb2YoKmpzZXN0YXRlLT5wYXRoc3BlYykpOwotCi0JCQkJRXhlY0luaXRFeHByUmVjKChF
eHByICopIGpleHByLT5wYXRoX3NwZWMsIHN0YXRlLAotCQkJCQkJCQkmanNlc3RhdGUtPnBh
dGhzcGVjLT52YWx1ZSwKLQkJCQkJCQkJJmpzZXN0YXRlLT5wYXRoc3BlYy0+aXNudWxsKTsK
LQotCQkJCWpzZXN0YXRlLT5yZXNfZXhwciA9Ci0JCQkJCXBhbGxvYyhzaXplb2YoKmpzZXN0
YXRlLT5yZXNfZXhwcikpOwotCi0JCQkJanNlc3RhdGUtPnJlc3VsdF9leHByID0gamV4cHIt
PnJlc3VsdF9jb2VyY2lvbgotCQkJCQk/IEV4ZWNJbml0RXhwcldpdGhDYXNlVmFsdWUoKEV4
cHIgKikgamV4cHItPnJlc3VsdF9jb2VyY2lvbi0+ZXhwciwKLQkJCQkJCQkJCQkJCXN0YXRl
LT5wYXJlbnQsCi0JCQkJCQkJCQkJCQkmanNlc3RhdGUtPnJlc19leHByLT52YWx1ZSwKLQkJ
CQkJCQkJCQkJCSZqc2VzdGF0ZS0+cmVzX2V4cHItPmlzbnVsbCkKLQkJCQkJOiBOVUxMOwot
Ci0JCQkJanNlc3RhdGUtPmRlZmF1bHRfb25fZW1wdHkgPSAhamV4cHItPm9uX2VtcHR5ID8g
TlVMTCA6Ci0JCQkJCUV4ZWNJbml0RXhwcigoRXhwciAqKSBqZXhwci0+b25fZW1wdHktPmRl
ZmF1bHRfZXhwciwKLQkJCQkJCQkJIHN0YXRlLT5wYXJlbnQpOwotCi0JCQkJanNlc3RhdGUt
PmRlZmF1bHRfb25fZXJyb3IgPQotCQkJCQlFeGVjSW5pdEV4cHIoKEV4cHIgKikgamV4cHIt
Pm9uX2Vycm9yLT5kZWZhdWx0X2V4cHIsCi0JCQkJCQkJCSBzdGF0ZS0+cGFyZW50KTsKLQot
CQkJCWlmIChqZXhwci0+b21pdF9xdW90ZXMgfHwKLQkJCQkJKGpleHByLT5yZXN1bHRfY29l
cmNpb24gJiYgamV4cHItPnJlc3VsdF9jb2VyY2lvbi0+dmlhX2lvKSkKLQkJCQl7Ci0JCQkJ
CU9pZAkJCXR5cGlucHV0OwotCi0JCQkJCS8qIGxvb2t1cCB0aGUgcmVzdWx0IHR5cGUncyBp
bnB1dCBmdW5jdGlvbiAqLwotCQkJCQlnZXRUeXBlSW5wdXRJbmZvKGpleHByLT5yZXR1cm5p
bmctPnR5cGlkLCAmdHlwaW5wdXQsCi0JCQkJCQkJCQkgJmpzZXN0YXRlLT5pbnB1dC50eXBp
b3BhcmFtKTsKLQkJCQkJZm1ncl9pbmZvKHR5cGlucHV0LCAmanNlc3RhdGUtPmlucHV0LmZ1
bmMpOwotCQkJCX0KIAotCQkJCWpzZXN0YXRlLT5hcmdzID0gTklMOwotCi0JCQkJZm9yYm90
aChhcmdleHBybGMsIGpleHByLT5wYXNzaW5nX3ZhbHVlcywKLQkJCQkJCWFyZ25hbWVsYywg
amV4cHItPnBhc3NpbmdfbmFtZXMpCi0JCQkJewotCQkJCQlFeHByCSAgICphcmdleHByID0g
KEV4cHIgKikgbGZpcnN0KGFyZ2V4cHJsYyk7Ci0JCQkJCVN0cmluZwkgICAqYXJnbmFtZSA9
IGxmaXJzdF9ub2RlKFN0cmluZywgYXJnbmFtZWxjKTsKLQkJCQkJSnNvblBhdGhWYXJpYWJs
ZUV2YWxDb250ZXh0ICp2YXIgPSBwYWxsb2Moc2l6ZW9mKCp2YXIpKTsKLQotCQkJCQl2YXIt
Pm5hbWUgPSBwc3RyZHVwKGFyZ25hbWUtPnN2YWwpOwotCQkJCQl2YXItPnR5cGlkID0gZXhw
clR5cGUoKE5vZGUgKikgYXJnZXhwcik7Ci0JCQkJCXZhci0+dHlwbW9kID0gZXhwclR5cG1v
ZCgoTm9kZSAqKSBhcmdleHByKTsKLQkJCQkJdmFyLT5lc3RhdGUgPSBFeGVjSW5pdEV4cHIo
YXJnZXhwciwgc3RhdGUtPnBhcmVudCk7Ci0JCQkJCXZhci0+ZWNvbnRleHQgPSBOVUxMOwot
CQkJCQl2YXItPm1jeHQgPSBOVUxMOwotCQkJCQl2YXItPmV2YWx1YXRlZCA9IGZhbHNlOwot
CQkJCQl2YXItPnZhbHVlID0gKERhdHVtKSAwOwotCQkJCQl2YXItPmlzbnVsbCA9IHRydWU7
Ci0KLQkJCQkJanNlc3RhdGUtPmFyZ3MgPQotCQkJCQkJbGFwcGVuZChqc2VzdGF0ZS0+YXJn
cywgdmFyKTsKLQkJCQl9Ci0KLQkJCQlqc2VzdGF0ZS0+Y2FjaGUgPSBOVUxMOworCQkJCUV4
ZWNJbml0SnNvbkV4cHIoJnNjcmF0Y2gsIGpleHByLCBzdGF0ZSwgcmVzdiwgcmVzbnVsbCk7
CisJCQkJYnJlYWs7CisJCQl9CiAKLQkJCQlpZiAoamV4cHItPmNvZXJjaW9ucykKLQkJCQl7
Ci0JCQkJCUpzb25Db2VyY2lvbiAqKmNvZXJjaW9uOwotCQkJCQlzdHJ1Y3QgSnNvbkNvZXJj
aW9uU3RhdGUgKmNzdGF0ZTsKLQkJCQkJRGF0dW0JICAgKmNhc2V2YWw7Ci0JCQkJCWJvb2wJ
ICAgKmNhc2VudWxsOwotCi0JCQkJCWpzZXN0YXRlLT5jb2VyY2lvbnMgPQotCQkJCQkJcGFs
bG9jKHNpemVvZigqanNlc3RhdGUtPmNvZXJjaW9ucykpOwotCQkJCQlqc2VzdGF0ZS0+Y29l
cmNpb25fZXhwciA9Ci0JCQkJCQlwYWxsb2Moc2l6ZW9mKCpqc2VzdGF0ZS0+Y29lcmNpb25f
ZXhwcikpOwotCi0JCQkJCWNhc2V2YWwgPSAmanNlc3RhdGUtPmNvZXJjaW9uX2V4cHItPnZh
bHVlOwotCQkJCQljYXNlbnVsbCA9ICZqc2VzdGF0ZS0+Y29lcmNpb25fZXhwci0+aXNudWxs
OwotCi0JCQkJCWZvciAoY3N0YXRlID0gJmpzZXN0YXRlLT5jb2VyY2lvbnMtPm51bGwsCi0J
CQkJCQkgY29lcmNpb24gPSAmamV4cHItPmNvZXJjaW9ucy0+bnVsbDsKLQkJCQkJCSBjb2Vy
Y2lvbiA8PSAmamV4cHItPmNvZXJjaW9ucy0+Y29tcG9zaXRlOwotCQkJCQkJIGNvZXJjaW9u
KyssIGNzdGF0ZSsrKQotCQkJCQl7Ci0JCQkJCQljc3RhdGUtPmNvZXJjaW9uID0gKmNvZXJj
aW9uOwotCQkJCQkJY3N0YXRlLT5lc3RhdGUgPSAqY29lcmNpb24gPwotCQkJCQkJCUV4ZWNJ
bml0RXhwcldpdGhDYXNlVmFsdWUoKEV4cHIgKikgKCpjb2VyY2lvbiktPmV4cHIsCi0JCQkJ
CQkJCQkJCQkJICBzdGF0ZS0+cGFyZW50LAotCQkJCQkJCQkJCQkJCSAgY2FzZXZhbCwgY2Fz
ZW51bGwpIDogTlVMTDsKLQkJCQkJfQotCQkJCX0KKwkJY2FzZSBUX0pzb25JdGVtQ29lcmNp
b25zOgorCQkJeworCQkJCWVsb2coRVJST1IsICJKc29uSXRlbUNvZXJjaW9ucyBtdXN0IGJl
IGluaXRpYWxpemVkIG1hbnVhbGx5Iik7CisJCQkJYnJlYWs7CisJCQl9CiAKLQkJCQlFeHBy
RXZhbFB1c2hTdGVwKHN0YXRlLCAmc2NyYXRjaCk7CisJCWNhc2UgVF9Kc29uQ29lcmNpb246
CisJCQl7CisJCQkJZWxvZyhFUlJPUiwgIkpzb25Db2VyY2lvbiBtdXN0IGJlIGluaXRpYWxp
emVkIG1hbnVhbGx5Iik7CiAJCQkJYnJlYWs7CiAJCQl9CiAKQEAgLTQyNTksMyArNDE2OCw1
NTkgQEAgRXhlY0J1aWxkUGFyYW1TZXRFcXVhbChUdXBsZURlc2MgZGVzYywKIAogCXJldHVy
biBzdGF0ZTsKIH0KKworc3RhdGljIHZvaWQKK0V4ZWNJbml0SnNvbkNvZXJjaW9uRXhwcihF
eHByU3RhdGUgKnN0YXRlLCBFeHByICpjb2VyY2lvbiwKKwkJCQkJCSBEYXR1bSAqcmVzdiwg
Ym9vbCAqcmVzbnVsbCkKK3sKKwlEYXR1bQkgICAqc2F2ZV9pbm5lcm1vc3RfY2FzZXZhbDsK
Kwlib29sCSAgICpzYXZlX2lubmVybW9zdF9pc251bGw7CisKKwkvKiBQdXNoIHN0ZXAocykg
dG8gY29tcHV0ZSBleHByIHVzaW5nIENhc2VUZXN0VmFsdWUuICovCisJc2F2ZV9pbm5lcm1v
c3RfY2FzZXZhbCA9IHN0YXRlLT5pbm5lcm1vc3RfY2FzZXZhbDsKKwlzYXZlX2lubmVybW9z
dF9pc251bGwgPSBzdGF0ZS0+aW5uZXJtb3N0X2Nhc2VudWxsOworCisJc3RhdGUtPmlubmVy
bW9zdF9jYXNldmFsID0gcmVzdjsKKwlzdGF0ZS0+aW5uZXJtb3N0X2Nhc2VudWxsID0gcmVz
bnVsbDsKKworCUV4ZWNJbml0RXhwclJlYyhjb2VyY2lvbiwgc3RhdGUsIHJlc3YsIHJlc251
bGwpOworCisJc3RhdGUtPmlubmVybW9zdF9jYXNldmFsID0gc2F2ZV9pbm5lcm1vc3RfY2Fz
ZXZhbDsKKwlzdGF0ZS0+aW5uZXJtb3N0X2Nhc2VudWxsID0gc2F2ZV9pbm5lcm1vc3RfaXNu
dWxsOworfQorCisvKiBDb250ZXh0IGZvciBwYXNzaW5nIGNvbW1vbiBmaWVsZHMgdXNlZCBm
b3IgSnNvbkV4cHIgaW5pdGlhbGl6YXRpb24gKi8KK3R5cGVkZWYgc3RydWN0IEV4ZWNJbml0
SnNvbkNvbnRleHQKK3sKKwlFeHByU3RhdGUgICpzdGF0ZTsKKwlFeHByRXZhbFN0ZXAgKnNj
cmF0Y2g7CisJSnNvbkV4cHJTdGF0ZSAqanNlc3RhdGU7CisJRGF0dW0JICAgKnJlc3Y7CisJ
Ym9vbAkgICAqcmVzbnVsbDsKKwlMaXN0CSAgICphZGp1c3RfanVtcHM7CQkvKiBsaXN0IG9m
IHN0ZXAgbnVtYmVycyBvZiBqdW1wX2RvbmUgc3RlcHMgKi8KKwlMaXN0CSAgICphZGp1c3Rf
c3VidHJhbnM7CS8qIGxpc3Qgb2Ygc3RlcCBudW1iZXJzIG9mIHN1YnRyYW5zIHN0ZXBzICov
Cit9IEV4ZWNJbml0SnNvbkNvbnRleHQ7CisKK3N0YXRpYyBib29sCitFeGVjRXhwck5lZWRz
U3ViVHJhbnNhY3Rpb24oTm9kZSAqZXhwcikKK3sKKwkvKiBObyBuZWVkIGZvciBzdWItdHJh
bmFjdGlvbnMgZm9yIENvbnN0IGV4cHJlc3Npb25zICovCisJaWYgKElzQShleHByLCBDb25z
dCkpCisJCXJldHVybiBmYWxzZTsKKworCS8qIFRPRE8gY2hlY2sgb3RoZXIgZXhwcmVzc2lv
biB0eXBlcyAqLworCXJldHVybiB0cnVlOworfQorCitib29sCitFeGVjSnNvbkV4cHJOZWVk
c1N1YlRyYW5zYWN0aW9uKEpzb25FeHByICpqc2V4cHIpCit7CisJaWYgKGpzZXhwci0+b25f
ZXJyb3ItPmJ0eXBlID09IEpTT05fQkVIQVZJT1JfRVJST1IpCisJCXJldHVybiBmYWxzZTsJ
Lyogbm8gZXJyb3IgaGFuZGxpbmcgKi8KKworCWlmIChqc2V4cHItPnJlc3VsdF9jb2VyY2lv
biAmJgorCQkoanNleHByLT5yZXN1bHRfY29lcmNpb24tPmV4cHIgfHwKKwkJIGpzZXhwci0+
cmVzdWx0X2NvZXJjaW9uLT52aWFfaW8gfHwKKwkJIGpzZXhwci0+cmVzdWx0X2NvZXJjaW9u
LT52aWFfcG9wdWxhdGUpKQorCQlyZXR1cm4gdHJ1ZTsKKworCWlmIChqc2V4cHItPm9uX2Vt
cHR5ICYmCisJCWpzZXhwci0+b25fZW1wdHktPmJ0eXBlID09IEpTT05fQkVIQVZJT1JfREVG
QVVMVCAmJgorCQlFeGVjRXhwck5lZWRzU3ViVHJhbnNhY3Rpb24oanNleHByLT5vbl9lbXB0
eS0+ZGVmYXVsdF9leHByKSkKKwkJcmV0dXJuIHRydWU7CisKKwlpZiAoanNleHByLT5vcCA9
PSBKU09OX0VYSVNUU19PUCkKKwkJcmV0dXJuIGZhbHNlOworCisJaWYgKGpzZXhwci0+b3Ag
PT0gSlNPTl9WQUxVRV9PUCAmJiBqc2V4cHItPmNvZXJjaW9ucykKKwkJcmV0dXJuIHRydWU7
CS8qIG1heSBjYWxsIGl0ZW0gY29lcmNpb25zICovCisKKwlpZiAoanNleHByLT5vcCA9PSBK
U09OX1FVRVJZX09QICYmIGpzZXhwci0+b21pdF9xdW90ZXMpCisJCXJldHVybiB0cnVlOwkv
KiBtYXkgY2FsbCBjb2VyY2lvbiB2aWEgSS9PICovCisKKwlyZXR1cm4gZmFsc2U7Cit9CisK
K3N0YXRpYyBpbnQKK0V4ZWNJbml0SnNvbkNvZXJjaW9uKEV4ZWNJbml0SnNvbkNvbnRleHQg
KmN4dCwgTm9kZSAqZXhwciwKKwkJCQkJIGJvb2wgbmVlZF9zdWJ0cmFucykKK3sKKwlFeHBy
U3RhdGUgICpzdGF0ZSA9IGN4dC0+c3RhdGU7CisJRXhwckV2YWxTdGVwICpzY3JhdGNoID0g
Y3h0LT5zY3JhdGNoOworCWludAkJCXN0ZXBfb2ZmID0gc3RhdGUtPnN0ZXBzX2xlbjsKKwor
CWlmIChJc0EoZXhwciwgSnNvbkNvZXJjaW9uKSkKKwl7CisJCUpzb25Db2VyY2lvbiAqY29l
cmNpb24gPSAoSnNvbkNvZXJjaW9uICopIGV4cHI7CisKKwkJaWYgKCFjb2VyY2lvbi0+ZXhw
ciAmJgorCQkJIWNvZXJjaW9uLT52aWFfaW8gJiYKKwkJCSFjb2VyY2lvbi0+dmlhX3BvcHVs
YXRlKQorCQkJcmV0dXJuIC0xOwkvKiBubyBjb2VyY2lvbiBpcyBuZWVkZWQgKi8KKwl9CisK
KwkvKiBDaGVjayB3aGV0aGVyIGV4cHJlc3Npb24gcmVhbGx5IG5lZWRzIHN1Yi10cmFuc2Fj
dGlvbnMgKi8KKwlpZiAobmVlZF9zdWJ0cmFucykKKwkJbmVlZF9zdWJ0cmFucyA9IEV4ZWNF
eHByTmVlZHNTdWJUcmFuc2FjdGlvbihleHByKTsKKworCS8qIEVtaXQgRUVPUF9KU09ORVhQ
Ul9TVUJUUkFOUyBzdGVwICovCisJaWYgKG5lZWRfc3VidHJhbnMpCisJeworCQljeHQtPmFk
anVzdF9zdWJ0cmFucyA9CisJCQlsYXBwZW5kX2ludChjeHQtPmFkanVzdF9zdWJ0cmFucywg
c3RhdGUtPnN0ZXBzX2xlbik7CisKKwkJc2NyYXRjaC0+b3Bjb2RlID0gRUVPUF9TVUJUUkFO
UzsKKwkJc2NyYXRjaC0+ZC5zdWJ0cmFucy5qdW1wX25leHQgPSAtMTsJCS8qIGNvbXB1dGVk
IGxhdGVyICovCisJCXNjcmF0Y2gtPmQuc3VidHJhbnMuanVtcF9kb25lID0gLTE7CQkvKiBj
b21wdXRlZCBsYXRlciAqLworCQlzY3JhdGNoLT5kLnN1YnRyYW5zLmp1bXBfZXJyb3IgPSAt
MTsJLyogY29tcHV0ZWQgbGF0ZXIgKi8KKwkJRXhwckV2YWxQdXNoU3RlcChzdGF0ZSwgc2Ny
YXRjaCk7CisJfQorCisJLyogRW1pdCBleHByZXNzaW9uIHN0ZXAsIGlmIG5lZWRlZC4gKi8K
KwlpZiAoSXNBKGV4cHIsIEpzb25Db2VyY2lvbikpCisJeworCQlKc29uQ29lcmNpb24gKmNv
ZXJjaW9uID0gKEpzb25Db2VyY2lvbiAqKSBleHByOworCisJCWlmIChjb2VyY2lvbi0+ZXhw
cikKKwkJCS8qIFB1c2ggc3RlcChzKSB0byBjb21wdXRlIGNvZXJjaW9uLT5leHByICovCisJ
CQlFeGVjSW5pdEpzb25Db2VyY2lvbkV4cHIoc3RhdGUsIChFeHByICopIGNvZXJjaW9uLT5l
eHByLAorCQkJCQkJCQkJIGN4dC0+cmVzdiwgY3h0LT5yZXNudWxsKTsKKwkJZWxzZSBpZiAo
Y29lcmNpb24tPnZpYV9wb3B1bGF0ZSkKKwkJeworCQkJLyogUHVzaCBzdGVwIGZvciBjb2Vy
Y2lvbiB1c2luZyBqc29uX3BvcHVsYXRlX3R5cGUoKSAqLworCQkJc2NyYXRjaC0+b3Bjb2Rl
ID0gRUVPUF9KU09ORVhQUl9QT1BVTEFURTsKKwkJCXNjcmF0Y2gtPmQuanNvbmV4cHJfcG9w
dWxhdGUuanNleHByID0gY3h0LT5qc2VzdGF0ZS0+anNleHByOworCQkJc2NyYXRjaC0+ZC5q
c29uZXhwcl9wb3B1bGF0ZS5jYWNoZSA9IE5VTEw7CisJCQlFeHByRXZhbFB1c2hTdGVwKHN0
YXRlLCBzY3JhdGNoKTsKKwkJfQorCQllbHNlIGlmIChjb2VyY2lvbi0+dmlhX2lvKQorCQl7
CisJCQkvKiBQdXNoIHN0ZXAgZm9yIGNvZXJjaW9uIHZpYSBJL08gKi8KKwkJCUZtZ3JJbmZv
ICAgKmZpbmZvOworCQkJT2lkCQkJdHlwaW5wdXQ7CisJCQlPaWQJCQl0eXBpb3BhcmFtOwor
CQkJSnNvblJldHVybmluZyAqcmV0dXJuaW5nID0gY3h0LT5qc2VzdGF0ZS0+anNleHByLT5y
ZXR1cm5pbmc7CisKKwkJCS8qIGxvb2t1cCB0aGUgcmVzdWx0IHR5cGUncyBpbnB1dCBmdW5j
dGlvbiAqLworCQkJZ2V0VHlwZUlucHV0SW5mbyhyZXR1cm5pbmctPnR5cGlkLCAmdHlwaW5w
dXQsCisJCQkJCQkJICZ0eXBpb3BhcmFtKTsKKwkJCWZpbmZvID0gcGFsbG9jMChzaXplb2Yo
Rm1nckluZm8pKTsKKwkJCWZtZ3JfaW5mbyh0eXBpbnB1dCwgZmluZm8pOworCisJCQlzY3Jh
dGNoLT5vcGNvZGUgPSBFRU9QX0pTT05FWFBSX0lPQ09FUkNFOworCQkJc2NyYXRjaC0+ZC5q
c29uZXhwcl9pb2NvZXJjZS5maW5mbyA9IGZpbmZvOworCQkJc2NyYXRjaC0+ZC5qc29uZXhw
cl9pb2NvZXJjZS50eXBpb3BhcmFtID0gdHlwaW9wYXJhbTsKKwkJCXNjcmF0Y2gtPmQuanNv
bmV4cHJfaW9jb2VyY2UudHlwbW9kID0gcmV0dXJuaW5nLT50eXBtb2Q7CisJCQlFeHByRXZh
bFB1c2hTdGVwKHN0YXRlLCBzY3JhdGNoKTsKKwkJfQorCQllbHNlCisJCXsKKwkJCUFzc2Vy
dCgwKTsgLyogbm8gY29lcmNpb24gY2FzZSBtdXN0IGJlIGNoZWNrZWQgYXQgdGhlIGJlZ2lu
bmluZyAqLworCQl9CisJfQorCWVsc2UKKwkJLyogUHVzaCBzdGVwKHMpIHRvIGNvbXB1dGUg
ZXhwciAqLworCQlFeGVjSW5pdEV4cHJSZWMoKEV4cHIgKikgZXhwciwgc3RhdGUsIGN4dC0+
cmVzdiwgY3h0LT5yZXNudWxsKTsKKworCWlmIChuZWVkX3N1YnRyYW5zKQorCXsKKwkJLyog
U3RlcCBmb3IgcmV0dXJuaW5nIGJhY2sgdG8gRUVPUF9KU09ORVhQUl9TVUJUUkFOUyBzdGVw
LiAqLworCQlzY3JhdGNoLT5vcGNvZGUgPSBFRU9QX0RPTkU7CisJCUV4cHJFdmFsUHVzaFN0
ZXAoc3RhdGUsIHNjcmF0Y2gpOworCisJCXN0YXRlLT5zdGVwc1tzdGVwX29mZl0uZC5zdWJ0
cmFucy5qdW1wX25leHQgPSBzdGF0ZS0+c3RlcHNfbGVuOworCX0KKwllbHNlCisJeworCQkv
KgorCQkgKiBFbWl0IEpVTVAgc3RlcCB0byBqdW1wIHRvIGVuZCBvZiBKc29uRXhwciBjb2Rl
LCBiZWNhdXNlCisJCSAqIGV2YWx1YXRpbmcgdGhlIGNvZXJjaW9uIG9yIGRlZmF1bHQgZXhw
cmVzc2lvbiBnaXZlcyB0aGUKKwkJICogZmluYWwgcmVzdWx0IGFuZCB0aGVyZSdzIG5vdGhp
bmcgbW9yZSB0byBkby4KKwkJICovCisJCXNjcmF0Y2gtPm9wY29kZSA9IEVFT1BfSlVNUDsK
KwkJc2NyYXRjaC0+ZC5qdW1wLmp1bXBkb25lID0gLTE7CS8qIGNvbXB1dGVkIGxhdGVyICov
CisJCUV4cHJFdmFsUHVzaFN0ZXAoc3RhdGUsIHNjcmF0Y2gpOworCisJCS8qCisJCSAqIERv
bid0IGtub3cgYWRkcmVzcyBmb3IgdGhhdCBqdW1wIHlldCwgY29tcHV0ZSBvbmNlIHRoZSB3
aG9sZQorCQkgKiBKc29uRXhwciBpcyBidWlsdC4gIFNvIHJlbWVtYmVyIEpVTVAgc3RlcCBh
ZGRyZXNzIHRvIHNldAorCQkgKiB0aGUgYWN0dWFsIGp1bXAgdGFyZ2V0IGFkZHJlZXNzLgor
CQkgKi8KKwkJY3h0LT5hZGp1c3RfanVtcHMgPQorCQkJbGFwcGVuZF9pbnQoY3h0LT5hZGp1
c3RfanVtcHMsIHN0YXRlLT5zdGVwc19sZW4gLSAxKTsKKwl9CisKKwlyZXR1cm4gc3RlcF9v
ZmY7Cit9CisKKy8qCisgKiBQdXNoIHN0ZXBzIHRvIGV2YWx1YXRlIGEgSnNvbkl0ZW1Db2Vy
Y2lvbnMsIHdoaWNoIGNvbnRhaW5zIHRoZSBzdGF0ZQorICogZm9yIGV2YWx1YXRpbmcgYWxs
IHBvc3NpYmxlIGNvZXJjaW9ucyB0aGF0IG1heSBuZWVkIHRvIGJlIGFwcGxpZWQgdG8KKyAq
IGEgSlNPTiBpdGVtIGNvbWluZyBmcm9tIGV2YWx1YXRpbmcgdGhlIHBhcmVudCBKc29uRXhw
ci4KKyAqLworc3RhdGljIEpzb25JdGVtQ29lcmNpb25zU3RlcHMgKgorRXhlY0luaXRKc29u
SXRlbUNvZXJjaW9ucyhFeGVjSW5pdEpzb25Db250ZXh0ICpjeHQsCisJCQkJCQkgIEpzb25J
dGVtQ29lcmNpb25zICpjb2VyY2lvbnMsCisJCQkJCQkgIGJvb2wgbmVlZF9zdWJ0cmFucykK
K3sKKwlKc29uSXRlbUNvZXJjaW9uc1N0ZXBzICpqY3N0YXRlID0gcGFsbG9jMChzaXplb2Yo
Kmpjc3RhdGUpKTsKKwlKc29uQ29lcmNpb24gKipjb2VyY2lvbjsKKwlpbnQJCSAgICpzdGVw
OworCisJLyogUHVzaCB0aGUgc3RlcHMgb2YgaW5kaXZpZHVhbCBjb2VyY2lvbidzIGV4cHJl
c3Npb24sIGlmIG5lZWRlZC4gKi8KKwlmb3IgKHN0ZXAgPSAmamNzdGF0ZS0+bnVsbCwKKwkJ
IGNvZXJjaW9uID0gJmNvZXJjaW9ucy0+bnVsbDsKKwkJIGNvZXJjaW9uIDw9ICZjb2VyY2lv
bnMtPmNvbXBvc2l0ZTsKKwkJIGNvZXJjaW9uKyssIHN0ZXArKykKKwl7CisJCWlmICgqY29l
cmNpb24pCisJCXsKKwkJCUFzc2VydCghKCpjb2VyY2lvbiktPnZpYV9pbyAmJiAhKCpjb2Vy
Y2lvbiktPnZpYV9wb3B1bGF0ZSk7CisKKwkJCWlmICgoKmNvZXJjaW9uKS0+ZXhwcikKKwkJ
CQkqc3RlcCA9IEV4ZWNJbml0SnNvbkNvZXJjaW9uKGN4dCwgKE5vZGUgKikgKmNvZXJjaW9u
LAorCQkJCQkJCQkJCQkgbmVlZF9zdWJ0cmFucyk7CisJCQllbHNlCisJCQkJKnN0ZXAgPSAw
OwkvKiBObyBjb2VyY2lvbiBpcyBuZWVkZWQgKi8KKwkJfQorCQllbHNlCisJCQkqc3RlcCA9
IC0xOyAgLyogVGhpcyBtZWFucyB0aGVyZSBpcyBubyBjYXN0IHRvIG91dHB1dCB0eXBlICov
CisJfQorCisJcmV0dXJuIGpjc3RhdGU7Cit9CisKKy8qCisgKiBFdmFsdWF0ZSBhIEpTT04g
ZXJyb3IvZW1wdHkgYmVoYXZpb3IgcmVzdWx0LgorICovCitzdGF0aWMgRGF0dW0KK0V4ZWNK
c29uQmVoYXZpb3IoSnNvbkJlaGF2aW9yICpiZWhhdmlvciwgYm9vbCAqaXNfbnVsbCkKK3sK
KwkqaXNfbnVsbCA9IGZhbHNlOworCisJc3dpdGNoIChiZWhhdmlvci0+YnR5cGUpCisJewor
CQljYXNlIEpTT05fQkVIQVZJT1JfRU1QVFlfQVJSQVk6CisJCQlyZXR1cm4gSnNvbmJQR2V0
RGF0dW0oSnNvbmJNYWtlRW1wdHlBcnJheSgpKTsKKworCQljYXNlIEpTT05fQkVIQVZJT1Jf
RU1QVFlfT0JKRUNUOgorCQkJcmV0dXJuIEpzb25iUEdldERhdHVtKEpzb25iTWFrZUVtcHR5
T2JqZWN0KCkpOworCisJCWNhc2UgSlNPTl9CRUhBVklPUl9UUlVFOgorCQkJcmV0dXJuIEJv
b2xHZXREYXR1bSh0cnVlKTsKKworCQljYXNlIEpTT05fQkVIQVZJT1JfRkFMU0U6CisJCQly
ZXR1cm4gQm9vbEdldERhdHVtKGZhbHNlKTsKKworCQljYXNlIEpTT05fQkVIQVZJT1JfTlVM
TDoKKwkJY2FzZSBKU09OX0JFSEFWSU9SX1VOS05PV046CisJCWNhc2UgSlNPTl9CRUhBVklP
Ul9FTVBUWToKKwkJCSppc19udWxsID0gdHJ1ZTsKKwkJCXJldHVybiAoRGF0dW0pIDA7CisK
KwkJY2FzZSBKU09OX0JFSEFWSU9SX0RFRkFVTFQ6CisJCQkvKiBBbHdheXMgaGFuZGxlZCBp
biB0aGUgY2FsbGVyLiAqLworCQkJQXNzZXJ0KGZhbHNlKTsKKwkJCXJldHVybiAoRGF0dW0p
IDA7CisKKwkJZGVmYXVsdDoKKwkJCWVsb2coRVJST1IsICJ1bnJlY29nbml6ZWQgU1FML0pT
T04gYmVoYXZpb3IgJWQiLCBiZWhhdmlvci0+YnR5cGUpOworCQkJcmV0dXJuIChEYXR1bSkg
MDsKKwl9Cit9CisKKy8qCisgKiBQdXNoIHN0ZXBzIHRvIGV2YWx1YXRlIE9OIEVSUk9SL0VN
UFRZIGJlaGF2aW9yOiBpdCBpcyBlaXRoZXIgREVGQVVMVAorICogZXhwcmVzc2lvbiBvciBj
b25zdGFudCB3aXRoIG9wdGlvbmFsIGNvZXJjaW9uLgorICoKKyAqIFJldHVybmVkIGZpcnN0
IHN0ZXAgbnVtYmVyLCBvciAtMSBpZiBubyBzdGVwcy4KKyAqLworc3RhdGljIGludAorRXhl
Y0luaXRKc29uQmVoYXZpb3IoRXhlY0luaXRKc29uQ29udGV4dCAqY3h0LCBKc29uQmVoYXZp
b3IgKmJlaGF2aW9yLAorCQkJCQkgYm9vbCBuZWVkX3N1YnRyYW5zLCBpbnQgKmp1bXBfY29l
cmNpb25fc3RlcF9vZmYpCit7CisJaWYgKCFiZWhhdmlvciB8fCBiZWhhdmlvci0+YnR5cGUg
PT0gSlNPTl9CRUhBVklPUl9FUlJPUikKKwkJcmV0dXJuIC0xOworCisJaWYgKGJlaGF2aW9y
LT5kZWZhdWx0X2V4cHIpCisJCXJldHVybiBFeGVjSW5pdEpzb25Db2VyY2lvbihjeHQsIGJl
aGF2aW9yLT5kZWZhdWx0X2V4cHIsCisJCQkJCQkJCQluZWVkX3N1YnRyYW5zKTsKKwllbHNl
CisJeworCQlFeHByU3RhdGUgICpzdGF0ZSA9IGN4dC0+c3RhdGU7CisJCUV4cHJFdmFsU3Rl
cCAqc2NyYXRjaCA9IGN4dC0+c2NyYXRjaDsKKwkJYm9vbAkJaXNudWxsOworCQlEYXR1bQkJ
dmFsID0gRXhlY0pzb25CZWhhdmlvcihiZWhhdmlvciwgJmlzbnVsbCk7CisJCWludAkJCXN0
ZXBfb2ZmID0gc3RhdGUtPnN0ZXBzX2xlbjsKKworCQkvKiBTdGVwIHRvIGVtaXQgcmVzdWx0
aW5nIGNvbnN0YW50ICovCisJCXNjcmF0Y2gtPm9wY29kZSA9IEVFT1BfQ09OU1Q7CisJCXNj
cmF0Y2gtPmQuY29uc3R2YWwudmFsdWUgPSB2YWw7CisJCXNjcmF0Y2gtPmQuY29uc3R2YWwu
aXNudWxsID0gaXNudWxsOworCQlFeHByRXZhbFB1c2hTdGVwKHN0YXRlLCBzY3JhdGNoKTsK
KworCQkvKiBTdGVwIHRvIHRoZSBjb2VyY2lvbiBvciB0aGUgZW5kIG9mIGV4cHJlc3Npb24g
Ki8KKwkJc2NyYXRjaC0+b3Bjb2RlID0gRUVPUF9KVU1QOworCQlzY3JhdGNoLT5kLmp1bXAu
anVtcGRvbmUgPSAtMTsJLyogY29tcHV0ZWQgbGF0ZXIgKi8KKwkJRXhwckV2YWxQdXNoU3Rl
cChzdGF0ZSwgc2NyYXRjaCk7CisKKwkJLyoKKwkJICogSWYgaXQgaXMgYSBqdW1wIHRvIGNv
ZXJjaW9uLCByZXR1cm4gaXQgdGhyb3VnaCBzcGVjaWFsIG91dHB1dAorCQkgKiBwYXJhbWV0
ZXIsIGVsc2UgYXBwZW5kIGl0IHRvIGp1bXBfZG9uZSBsaXN0LgorCQkgKi8KKwkJaWYgKGN4
dC0+anNlc3RhdGUtPmpzZXhwci0+cmVzdWx0X2NvZXJjaW9uKQorCQkJKmp1bXBfY29lcmNp
b25fc3RlcF9vZmYgPSBzdGF0ZS0+c3RlcHNfbGVuIC0gMTsKKwkJZWxzZQorCQkJY3h0LT5h
ZGp1c3RfanVtcHMgPQorCQkJCWxhcHBlbmRfaW50KGN4dC0+YWRqdXN0X2p1bXBzLCBzdGF0
ZS0+c3RlcHNfbGVuIC0gMSk7CisKKwkJcmV0dXJuIHN0ZXBfb2ZmOworCX0KK30KKworLyoK
KyAqIFB1c2ggc3RlcHMgdG8gZXZhbHVhdGUgYSBKc29uRXhwciBhbmQgaXRzIHZhcmlvdXMg
c3Vic2lkaWFyeQorICogZXhwcmVzc2lvbnMuCisgKi8KK3N0YXRpYyB2b2lkCitFeGVjSW5p
dEpzb25FeHByKEV4cHJFdmFsU3RlcCAqc2NyYXRjaCwgSnNvbkV4cHIgKmpleHByLCBFeHBy
U3RhdGUgKnN0YXRlLAorCQkJCSBEYXR1bSAqcmVzdiwgYm9vbCAqcmVzbnVsbCkKK3sKKwlF
eGVjSW5pdEpzb25Db250ZXh0IGN4dDsKKwlKc29uRXhwclN0YXRlICpqc2VzdGF0ZSA9IHBh
bGxvYzAoc2l6ZW9mKEpzb25FeHByU3RhdGUpKTsKKwlKc29uRXhwclByZUV2YWxTdGF0ZSAq
cHJlX2V2YWwgPSAmanNlc3RhdGUtPnByZV9ldmFsOworCUV4cHJFdmFsU3RlcCAqYXM7CisJ
TGlzdENlbGwgICAqYXJnZXhwcmxjOworCUxpc3RDZWxsICAgKmFyZ25hbWVsYzsKKwlMaXN0
Q2VsbCAgICpsYzsKKwlpbnQJCQlza2lwX3N0ZXBfb2ZmOworCWludAkJCWV4ZWNwYXRoX3N0
ZXBfb2ZmOworCWludAkJCW9uZW1wdHlfc3RlcF9vZmY7CisJaW50CQkJb25lcnJvcl9zdGVw
X29mZjsKKwlpbnQJCQlvbmVtcHR5X2p1bXBfY29lcmNpb25fc3RlcF9vZmYgPSAtMTsKKwlp
bnQJCQlvbmVycm9yX2p1bXBfY29lcmNpb25fc3RlcF9vZmYgPSAtMTsKKwlpbnQJCQljb2Vy
Y2lvbl9zdGVwX29mZiA9IC0xOworCWludAkJCWNvZXJjaW9uX3N1YnRyYW5zX3N0ZXBfb2Zm
ID0gLTE7CisJaW50CQkJaW9fY29lcmNpb25fc3RlcF9vZmYgPSAtMTsKKwlpbnQJCQlkb25l
X29mZjsKKwlib29sCQluZWVkX3N1YnRyYW5zOworCisJY3h0LnN0YXRlID0gc3RhdGU7CisJ
Y3h0LnNjcmF0Y2ggPSBzY3JhdGNoOworCWN4dC5qc2VzdGF0ZSA9IGpzZXN0YXRlOworCWN4
dC5yZXN2ID0gcmVzdjsKKwljeHQucmVzbnVsbCA9IHJlc251bGw7CisJY3h0LmFkanVzdF9q
dW1wcyA9IE5JTDsKKwljeHQuYWRqdXN0X3N1YnRyYW5zID0gTklMOworCisJanNlc3RhdGUt
PmpzZXhwciA9IGpleHByOworCisJLyoKKwkgKiBTZXQgaWYgY29lcmNpb24gb3IgREVGQVVM
VCBPTiBFTVBUWSBleHByZXNzaW9uLCB3aGljaCBydW5zCisJICogc2VwYXJhdGVseSBmcm9t
IHBhdGggZXZhbHVhdGlvbiBhbmQgd2hvc2UgZXJyb3JzIG11c3QgYmUgY2F1Z2h0CisJICog
YW5kIGhhbmRsZWQgcGVyIE9OIEVSUk9SIGJlaGF2aW9yLCBtdXN0IHVzZSBhIHN1Yi10cmFu
c2FjdGlvbi4KKwkgKi8KKwluZWVkX3N1YnRyYW5zID0gamV4cHItPm9uX2Vycm9yLT5idHlw
ZSAhPSBKU09OX0JFSEFWSU9SX0VSUk9SOworCisJLyoKKwkgKiBBZGQgc3RlcHMgdG8gY29t
cHV0ZSBmb3JtYXR0ZWRfZXhwciwgcGF0aHNwZWMsIGFuZCBQQVNTSU5HIGFyZworCSAqIGV4
cHJlc3Npb25zIGFzIHRoaW5ncyB0aGF0IG11c3QgYmUgZXZhbHVhdGVkICpiZWZvcmUqIHRo
ZSBhY3R1YWwKKwkgKiBKU09OIHBhdGggZXhwcmVzc2lvbi4KKwkgKi8KKwlFeGVjSW5pdEV4
cHJSZWMoKEV4cHIgKikgamV4cHItPmZvcm1hdHRlZF9leHByLCBzdGF0ZSwKKwkJCQkJJnBy
ZV9ldmFsLT5mb3JtYXR0ZWRfZXhwci52YWx1ZSwKKwkJCQkJJnByZV9ldmFsLT5mb3JtYXR0
ZWRfZXhwci5pc251bGwpOworCUV4ZWNJbml0RXhwclJlYygoRXhwciAqKSBqZXhwci0+cGF0
aF9zcGVjLCBzdGF0ZSwKKwkJCQkJJnByZV9ldmFsLT5wYXRoc3BlYy52YWx1ZSwKKwkJCQkJ
JnByZV9ldmFsLT5wYXRoc3BlYy5pc251bGwpOworCisJLyoKKwkgKiBCZWZvcmUgcHVzaGlu
ZyBzdGVwcyBmb3IgUEFTU0lORyBhcmdzLCBwdXNoIGEgc3RlcCB0byBkZWNpZGUKKwkgKiB3
aGV0aGVyIHRvIHNraXAgZXZhbHVhdGluZyB0aGUgYXJncyBhbmQgdGhlIEpTT04gcGF0aCBl
eHByZXNzaW9uCisJICogZGVwZW5kaW5nIG9uIHdoZXRoZXIgZWl0aGVyIG9mIGZvcm1hdHRl
ZF9leHByIGFuZCBwYXRoc3BlYyBpcworCSAqIE5VTEwuCisJICovCisJc2NyYXRjaC0+b3Bj
b2RlID0gRUVPUF9KU09ORVhQUl9TS0lQOworCXNjcmF0Y2gtPmQuanNvbmV4cHJfc2tpcC5q
c2VzdGF0ZSA9IGpzZXN0YXRlOworCXNraXBfc3RlcF9vZmYgPSBzdGF0ZS0+c3RlcHNfbGVu
OworCUV4cHJFdmFsUHVzaFN0ZXAoc3RhdGUsIHNjcmF0Y2gpOworCisJLyogUEFTU0lORyBh
cmdzLiAqLworCWpzZXN0YXRlLT5wcmVfZXZhbC5hcmdzID0gTklMOworCWZvcmJvdGgoYXJn
ZXhwcmxjLCBqZXhwci0+cGFzc2luZ192YWx1ZXMsCisJCQlhcmduYW1lbGMsIGpleHByLT5w
YXNzaW5nX25hbWVzKQorCXsKKwkJRXhwcgkgICAqYXJnZXhwciA9IChFeHByICopIGxmaXJz
dChhcmdleHBybGMpOworCQlTdHJpbmcJICAgKmFyZ25hbWUgPSBsZmlyc3Rfbm9kZShTdHJp
bmcsIGFyZ25hbWVsYyk7CisJCUpzb25QYXRoVmFyaWFibGVFdmFsQ29udGV4dCAqdmFyID0g
cGFsbG9jKHNpemVvZigqdmFyKSk7CisKKwkJdmFyLT5uYW1lID0gcHN0cmR1cChhcmduYW1l
LT5zdmFsKTsKKwkJdmFyLT50eXBpZCA9IGV4cHJUeXBlKChOb2RlICopIGFyZ2V4cHIpOwor
CQl2YXItPnR5cG1vZCA9IGV4cHJUeXBtb2QoKE5vZGUgKikgYXJnZXhwcik7CisKKwkJLyoK
KwkJICogQSBzZXBhcmF0ZSBFeHByU3RhdGUgaXMgbm90IG5lY2Vzc2FyeSBmb3IgdGhlc2Ug
ZXhwcmVzc2lvbnMKKwkJICogd2hlbiBiZWluZyBldmFsdWF0ZWQgZm9yIGEgSnNvbkV4cHIs
IGxpa2UgaW4gdGhpcyBjYXNlLAorCQkgKiBiZWNhdXNlIHRoZXkgd2lsbCBldmFsdWF0ZWQg
YXMgdGhlIHN0ZXBzIG9mIHRoZSBKc29uRXhwci4KKwkJICovCisJCXZhci0+ZXN0YXRlID0g
TlVMTDsKKwkJdmFyLT5lY29udGV4dCA9IE5VTEw7CisJCXZhci0+bWN4dCA9IE5VTEw7CisK
KwkJLyoKKwkJICogTWFyayB0aGVzZSBhcyBhbHdheXMgZXZhbHVhdGVkIGJlY2F1c2UgdGhl
eSBtdXN0IGhhdmUgYmVlbgorCQkgKiBldmFsdWF0ZWQgYmVmb3JlIEpTT04gcGF0aCBldmFs
dWF0aW9uIGJlZ2lucywgYmVjYXVzZSB3ZQorCQkgKiBoYXZlbid0IHB1c2hlZCB0aGUgc3Rl
cCBmb3IgdGhlIGxhdHRlciB5ZXQuCisJCSAqLworCQl2YXItPmV2YWx1YXRlZCA9IHRydWU7
CisKKwkJRXhlY0luaXRFeHByUmVjKChFeHByICopIGFyZ2V4cHIsIHN0YXRlLCAmdmFyLT52
YWx1ZSwgJnZhci0+aXNudWxsKTsKKworCQlwcmVfZXZhbC0+YXJncyA9IGxhcHBlbmQocHJl
X2V2YWwtPmFyZ3MsIHZhcik7CisJfQorCisJLyogU3RlcCBmb3IgdGhlIGFjdHVhbCBKU09O
IHBhdGggZXZhbHVhdGlvbi4gKi8KKwlzY3JhdGNoLT5vcGNvZGUgPSBFRU9QX0pTT05FWFBS
X1BBVEg7CisJc2NyYXRjaC0+ZC5qc29uZXhwci5qc2VzdGF0ZSA9IGpzZXN0YXRlOworCWV4
ZWNwYXRoX3N0ZXBfb2ZmID0gc3RhdGUtPnN0ZXBzX2xlbjsKKwlFeHByRXZhbFB1c2hTdGVw
KHN0YXRlLCBzY3JhdGNoKTsKKworCS8qCisJICogUHVzaCBzdGVwcyB0byBjb250cm9sIHRo
ZSBldmFsdWF0aW9uIG9mIGV4cHJlc3Npb25zIGJhc2VkCisJICogb24gdGhlIHJlc3VsdCBv
ZiBKU09OIHBhdGggZXZhbHVhdGlvbi4KKwkgKi8KKworCS8qIFN0ZXAocykgdG8gZXZhbHVh
dGUgT04gRU1QVFkgYmVoYXZpb3IgKi8KKwlvbmVtcHR5X3N0ZXBfb2ZmID0gRXhlY0luaXRK
c29uQmVoYXZpb3IoJmN4dCwgamV4cHItPm9uX2VtcHR5LAorCQkJCQkJCQkJCQluZWVkX3N1
YnRyYW5zLAorCQkJCQkJCQkJCQkmb25lbXB0eV9qdW1wX2NvZXJjaW9uX3N0ZXBfb2ZmKTsK
KworCS8qIFN0ZXAocykgdG8gZXZhbHVhdGUgT04gRVJST1IgYmVoYXZpb3IgKi8KKwlvbmVy
cm9yX3N0ZXBfb2ZmID0gRXhlY0luaXRKc29uQmVoYXZpb3IoJmN4dCwgamV4cHItPm9uX2Vy
cm9yLAorCQkJCQkJCQkJCQlmYWxzZSwgLyogc3ViLXRyYW5zYWN0aW9ucyBhcmUgbm90IG5l
ZWRlZCBoZXJlICovCisJCQkJCQkJCQkJCSZvbmVycm9yX2p1bXBfY29lcmNpb25fc3RlcF9v
ZmYpOworCisJQXNzZXJ0KCFuZWVkX3N1YnRyYW5zIHx8IG9uZXJyb3Jfc3RlcF9vZmYgPj0g
MCk7CisKKwkvKgorCSAqIEluaXRpYWxpemUgY29lcmNpb24gZXhwcmVzc2lvbi4KKwkgKi8K
KwlpZiAoamV4cHItPnJlc3VsdF9jb2VyY2lvbikKKwl7CisJCS8qCisJCSAqIERvbid0IHVz
ZSBhIHN1Yi10cmFuc2FjdGlvbiBmb3IgY29lcmNpbmcgdGhlIE9OIEVSUk9SCisJCSAqIGV4
cHJlc3Npb24uCisJCSAqLworCQljb2VyY2lvbl9zdGVwX29mZiA9CisJCQlFeGVjSW5pdEpz
b25Db2VyY2lvbigmY3h0LCAoTm9kZSAqKSBqZXhwci0+cmVzdWx0X2NvZXJjaW9uLCBmYWxz
ZSk7CisKKwkJLyoKKwkJICogR2VuZXJhdGUgYWxzbyBjb2VyY2lvbiBleHByZXNzaW9uIHdy
YXBwZWQgaW50byBhCisJCSAqIHN1Yi10cmFuc2FjdGlvbiwgaWYgbmVlZGVkLgorCQkgKi8K
KwkJaWYgKG5lZWRfc3VidHJhbnMpCisJCQljb2VyY2lvbl9zdWJ0cmFuc19zdGVwX29mZiA9
CisJCQkJRXhlY0luaXRKc29uQ29lcmNpb24oJmN4dCwgKE5vZGUgKikgamV4cHItPnJlc3Vs
dF9jb2VyY2lvbiwgdHJ1ZSk7CisJfQorCisJLyoKKwkgKiBFbWl0IEkvTyBjb2VyY2lvbiBp
ZiBPTUlUIFFVT1RFUyBpcyB1c2VkIGFuZCBpdCB3YXMgbm90IGFscmVhZHkKKwkgKiBlbWl0
dGVkLgorCSAqLworCWlmIChqZXhwci0+b21pdF9xdW90ZXMgJiYKKwkJKCFqZXhwci0+cmVz
dWx0X2NvZXJjaW9uIHx8ICFqZXhwci0+cmVzdWx0X2NvZXJjaW9uLT52aWFfaW8pKQorCXsK
KwkJSnNvbkNvZXJjaW9uIGlvX2NvZXJjaW9uID0gezB9OworCisJCWlvX2NvZXJjaW9uLnR5
cGUgPSBUX0pzb25Db2VyY2lvbjsKKwkJaW9fY29lcmNpb24udmlhX2lvID0gdHJ1ZTsKKwor
CQlpb19jb2VyY2lvbl9zdGVwX29mZiA9CisJCQlFeGVjSW5pdEpzb25Db2VyY2lvbigmY3h0
LCAoTm9kZSAqKSAmaW9fY29lcmNpb24sIG5lZWRfc3VidHJhbnMpOworCX0KKworCS8qCisJ
ICogSW5pdGlhbGl6ZSAiU1FML0pTT04gaXRlbSB0eXBlID0+IFNRTCB0eXBlIiBjb2VyY2lv
biBleHByZXNzaW9ucy4KKwkgKi8KKwlpZiAoamV4cHItPmNvZXJjaW9ucykKKwkJanNlc3Rh
dGUtPml0ZW1fY29lcmNpb25zID0KKwkJCUV4ZWNJbml0SnNvbkl0ZW1Db2VyY2lvbnMoJmN4
dCwgamV4cHItPmNvZXJjaW9ucywgbmVlZF9zdWJ0cmFucyk7CisKKwlkb25lX29mZiA9IHN0
YXRlLT5zdGVwc19sZW47CisKKwkvKiBSZWRpcmVjdCBtaXNzaW5nIHN0ZXBzIHRvIHRoZSBl
bmQgc3RlcCAqLworCWlmIChvbmVycm9yX3N0ZXBfb2ZmIDwgMCkKKwkJb25lcnJvcl9zdGVw
X29mZiA9IGRvbmVfb2ZmOworCisJaWYgKG9uZW1wdHlfc3RlcF9vZmYgPCAwKQorCQlvbmVt
cHR5X3N0ZXBfb2ZmID0gZG9uZV9vZmY7CisKKwlpZiAoY29lcmNpb25fc3RlcF9vZmYgPCAw
KQorCQljb2VyY2lvbl9zdGVwX29mZiA9IGRvbmVfb2ZmOworCisJaWYgKGNvZXJjaW9uX3N1
YnRyYW5zX3N0ZXBfb2ZmIDwgMCkKKwkJY29lcmNpb25fc3VidHJhbnNfc3RlcF9vZmYgPSBj
b2VyY2lvbl9zdGVwX29mZjsKKworCWlmIChpb19jb2VyY2lvbl9zdGVwX29mZiA8IDApCisJ
CWlvX2NvZXJjaW9uX3N0ZXBfb2ZmID0gZG9uZV9vZmY7CisKKwkvKgorCSAqIEFkanVzdCBq
dW1wIHRhcmdldCBhZGRyZXNzZXMgaW4gdmFyaW91cyBwb3N0LWV2YWwgc3RlcHMgbm93IHRo
YXQKKwkgKiB3ZSBoYXZlIGFsbCB0aGUgc3RlcHMgaW4gcGxhY2UuCisJICovCisKKwkvKiBF
RU9QX0pTT05FWFBSX1BBVEggKi8KKwlhcyA9ICZzdGF0ZS0+c3RlcHNbZXhlY3BhdGhfc3Rl
cF9vZmZdOworCWFzLT5kLmpzb25leHByLmp1bXBfZG9uZSA9IGRvbmVfb2ZmOworCWFzLT5k
Lmpzb25leHByLmp1bXBfb25lcnJvciA9IG9uZXJyb3Jfc3RlcF9vZmY7CisJYXMtPmQuanNv
bmV4cHIuanVtcF9vbmVtcHR5ID0gb25lbXB0eV9zdGVwX29mZjsKKwlhcy0+ZC5qc29uZXhw
ci5qdW1wX2NvZXJjaW9uID0gY29lcmNpb25fc3RlcF9vZmY7CisJYXMtPmQuanNvbmV4cHIu
anVtcF9jb2VyY2lvbl9zdWJ0cmFucyA9IGNvZXJjaW9uX3N1YnRyYW5zX3N0ZXBfb2ZmOwor
CWFzLT5kLmpzb25leHByLmp1bXBfY29lcmNpb25fdmlhX2lvID0gaW9fY29lcmNpb25fc3Rl
cF9vZmY7CisKKwkvKiBFRU9QX0pTT05FWFBSX1NLSVAgKi8KKwlhcyA9ICZzdGF0ZS0+c3Rl
cHNbc2tpcF9zdGVwX29mZl07CisJYXMtPmQuanNvbmV4cHJfc2tpcC5qdW1wX2NvZXJjaW9u
ID0gY29lcmNpb25fc3RlcF9vZmY7CisKKwkvKiBBZGp1c3QganVtcCB0byBPTiBFTVBUWSBj
b2VyY2lvbiwgaWYgYW55ICovCisJaWYgKG9uZW1wdHlfanVtcF9jb2VyY2lvbl9zdGVwX29m
ZiA+PSAwKQorCXsKKwkJYXMgPSAmc3RhdGUtPnN0ZXBzW29uZW1wdHlfanVtcF9jb2VyY2lv
bl9zdGVwX29mZl07CisJCWFzLT5kLmp1bXAuanVtcGRvbmUgPSBjb2VyY2lvbl9zdWJ0cmFu
c19zdGVwX29mZjsKKwl9CisKKwkvKiBBZGp1c3QganVtcCB0byBPTiBFUlJPUiBjb2VyY2lv
biwgaWYgYW55ICovCisJaWYgKG9uZXJyb3JfanVtcF9jb2VyY2lvbl9zdGVwX29mZiA+PSAw
KQorCXsKKwkJYXMgPSAmc3RhdGUtPnN0ZXBzW29uZXJyb3JfanVtcF9jb2VyY2lvbl9zdGVw
X29mZl07CisJCWFzLT5kLmp1bXAuanVtcGRvbmUgPSBjb2VyY2lvbl9zdGVwX29mZjsKKwl9
CisKKwkvKgorCSAqIEVFT1BfSlVNUCBzdGVwcyBhZGRlZCBhZnRlciBkZWZhdWx0IGV4cHJl
c3Npb25zIGFuZCBjb2VyY2lvbnMKKwkgKiBzaG91bGQganVtcCB0byB0aGUgZXhwcmVzc2lv
biBlbmQuCisJICovCisJZm9yZWFjaChsYywgY3h0LmFkanVzdF9qdW1wcykKKwl7CisJCWFz
ID0gJnN0YXRlLT5zdGVwc1tsZmlyc3RfaW50KGxjKV07CisJCWFzLT5kLmp1bXAuanVtcGRv
bmUgPSBkb25lX29mZjsKKwl9CisKKwkvKgorCSAqIEFkanVzdCBFRU9QX1NVQlRSQU5TIGp1
bXBzIHRvIHBvaW50IHRvIHRoZSBleHByZXNzaW9uIGVuZCBhbmQgdG8KKwkgKiBPTiBFUlJP
UiBoYW5kbGVyLgorCSAqLworCWZvcmVhY2gobGMsIGN4dC5hZGp1c3Rfc3VidHJhbnMpCisJ
eworCQlhcyA9ICZzdGF0ZS0+c3RlcHNbbGZpcnN0X2ludChsYyldOworCQlhcy0+ZC5zdWJ0
cmFucy5qdW1wX2RvbmUgPSBkb25lX29mZjsKKwkJYXMtPmQuc3VidHJhbnMuanVtcF9lcnJv
ciA9IG9uZXJyb3Jfc3RlcF9vZmY7CisJfQorCisJLyoKKwkgKiBWZXJpZnkgdGhhdCBubyBz
dWJ0cmFuc2FjdGlvbiBub2RlcyB3ZXJlIGdlbmVyYXRlZCBpZgorCSAqIEV4ZWNKc29uRXhw
ck5lZWRzU3ViVHJhbnNhY3Rpb24oKSByZXR1cm5zIGZhbHNlLgorCSAqLworCUFzc2VydChj
eHQuYWRqdXN0X3N1YnRyYW5zID09IE5JTCB8fAorCQkgICBFeGVjSnNvbkV4cHJOZWVkc1N1
YlRyYW5zYWN0aW9uKGpleHByKSk7Cit9CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9leGVj
dXRvci9leGVjRXhwckludGVycC5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY0V4cHJJ
bnRlcnAuYwppbmRleCA2NjJkNDdmOGNiYi4uMTUyNzhiMjk2Y2QgMTAwNjQ0Ci0tLSBhL3Ny
Yy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNFeHBySW50ZXJwLmMKKysrIGIvc3JjL2JhY2tlbmQv
ZXhlY3V0b3IvZXhlY0V4cHJJbnRlcnAuYwpAQCAtNDk0LDcgKzQ5NCwxMCBAQCBFeGVjSW50
ZXJwRXhwclN0ZXAoRXhwclN0YXRlICpzdGF0ZSwgaW50IHN0ZXBubywKIAkJJiZDQVNFX0VF
T1BfU1VCVFJBTlMsCiAJCSYmQ0FTRV9FRU9QX0pTT05fQ09OU1RSVUNUT1IsCiAJCSYmQ0FT
RV9FRU9QX0lTX0pTT04sCi0JCSYmQ0FTRV9FRU9QX0pTT05FWFBSLAorCQkmJkNBU0VfRUVP
UF9KU09ORVhQUl9TS0lQLAorCQkmJkNBU0VfRUVPUF9KU09ORVhQUl9QQVRILAorCQkmJkNB
U0VfRUVPUF9KU09ORVhQUl9JT0NPRVJDRSwKKwkJJiZDQVNFX0VFT1BfSlNPTkVYUFJfUE9Q
VUxBVEUsCiAJCSYmQ0FTRV9FRU9QX0FHR19TVFJJQ1RfREVTRVJJQUxJWkUsCiAJCSYmQ0FT
RV9FRU9QX0FHR19ERVNFUklBTElaRSwKIAkJJiZDQVNFX0VFT1BfQUdHX1NUUklDVF9JTlBV
VF9DSEVDS19BUkdTLApAQCAtMTg1NSwxMCArMTg1OCwzMiBAQCBFeGVjSW50ZXJwRXhwclN0
ZXAoRXhwclN0YXRlICpzdGF0ZSwgaW50IHN0ZXBubywKIAkJCUVFT19ORVhUKCk7CiAJCX0K
IAotCQlFRU9fQ0FTRShFRU9QX0pTT05FWFBSKQorCQlFRU9fQ0FTRShFRU9QX0pTT05FWFBS
X1BBVEgpCiAJCXsKIAkJCS8qIHRvbyBjb21wbGV4IGZvciBhbiBpbmxpbmUgaW1wbGVtZW50
YXRpb24gKi8KLQkJCUV4ZWNFdmFsSnNvbihzdGF0ZSwgb3AsIGVjb250ZXh0KTsKKwkJCUVF
T19KVU1QKEV4ZWNFdmFsSnNvbihzdGF0ZSwgb3ApKTsKKwkJfQorCisJCUVFT19DQVNFKEVF
T1BfSlNPTkVYUFJfU0tJUCkKKwkJeworCQkJLyogdG9vIGNvbXBsZXggZm9yIGFuIGlubGlu
ZSBpbXBsZW1lbnRhdGlvbiAqLworCQkJaWYgKEV4ZWNFdmFsSnNvbkV4cHJTa2lwKHN0YXRl
LCBvcCkpCisJCQkJRUVPX0pVTVAob3AtPmQuanNvbmV4cHJfc2tpcC5qdW1wX2NvZXJjaW9u
KTsKKwkJCWVsc2UKKwkJCQlFRU9fTkVYVCgpOworCQl9CisKKwkJRUVPX0NBU0UoRUVPUF9K
U09ORVhQUl9JT0NPRVJDRSkKKwkJeworCQkJLyogdG9vIGNvbXBsZXggZm9yIGFuIGlubGlu
ZSBpbXBsZW1lbnRhdGlvbiAqLworCQkJRXhlY0V2YWxKc29uRXhwcklPQ29lcmNlKHN0YXRl
LCBvcCk7CisJCQlFRU9fTkVYVCgpOworCQl9CisKKwkJRUVPX0NBU0UoRUVPUF9KU09ORVhQ
Ul9QT1BVTEFURSkKKwkJeworCQkJLyogdG9vIGNvbXBsZXggZm9yIGFuIGlubGluZSBpbXBs
ZW1lbnRhdGlvbiAqLworCQkJRXhlY0V2YWxKc29uRXhwclBvcHVsYXRlKHN0YXRlLCBvcCwg
ZWNvbnRleHQpOwogCQkJRUVPX05FWFQoKTsKIAkJfQogCkBAIC00Nzk5LDU1MCArNDgyNCwz
MDAgQEAgRXhlY0V2YWxKc29uQ29uc3RydWN0b3IoRXhwclN0YXRlICpzdGF0ZSwgRXhwckV2
YWxTdGVwICpvcCwKIH0KIAogLyoKLSAqIEV2YWx1YXRlIGEgSlNPTiBlcnJvci9lbXB0eSBi
ZWhhdmlvciByZXN1bHQuCisgKiBQcmVwYXJlIFNRTC9KU09OIGl0ZW0gY29lcmNpb24gdG8g
dGhlIG91dHB1dCB0eXBlLiAgUmV0dXJuZWQgYSBkYXR1bQorICogb2YgdGhlIGNvcnJlc3Bv
bmRpbmcgU1FMIHR5cGUgYW5kIHBvaW50ZXJzIHRvIHRoZSBjb2VyY2lvbiBhbmQgaXRzCisg
KiBzdGF0ZS4KICAqLwogc3RhdGljIERhdHVtCi1FeGVjRXZhbEpzb25CZWhhdmlvcihFeHBy
Q29udGV4dCAqZWNvbnRleHQsIEpzb25CZWhhdmlvciAqYmVoYXZpb3IsCi0JCQkJCSBFeHBy
U3RhdGUgKmRlZmF1bHRfZXN0YXRlLCBib29sICppc19udWxsKQorRXhlY1ByZXBhcmVKc29u
SXRlbUNvZXJjaW9uKEpzb25iVmFsdWUgKml0ZW0sIEV4cHJFdmFsU3RlcCAqb3AsCisJCQkJ
CQkJSnNvbkl0ZW1Db2VyY2lvbnNTdGVwcyAqc3RlcHMsIGludCAqanVtcCkKIHsKLQkqaXNf
bnVsbCA9IGZhbHNlOwotCi0Jc3dpdGNoIChiZWhhdmlvci0+YnR5cGUpCi0JewotCQljYXNl
IEpTT05fQkVIQVZJT1JfRU1QVFlfQVJSQVk6Ci0JCQlyZXR1cm4gSnNvbmJQR2V0RGF0dW0o
SnNvbmJNYWtlRW1wdHlBcnJheSgpKTsKLQotCQljYXNlIEpTT05fQkVIQVZJT1JfRU1QVFlf
T0JKRUNUOgotCQkJcmV0dXJuIEpzb25iUEdldERhdHVtKEpzb25iTWFrZUVtcHR5T2JqZWN0
KCkpOwotCi0JCWNhc2UgSlNPTl9CRUhBVklPUl9UUlVFOgotCQkJcmV0dXJuIEJvb2xHZXRE
YXR1bSh0cnVlKTsKLQotCQljYXNlIEpTT05fQkVIQVZJT1JfRkFMU0U6Ci0JCQlyZXR1cm4g
Qm9vbEdldERhdHVtKGZhbHNlKTsKLQotCQljYXNlIEpTT05fQkVIQVZJT1JfTlVMTDoKLQkJ
Y2FzZSBKU09OX0JFSEFWSU9SX1VOS05PV046Ci0JCWNhc2UgSlNPTl9CRUhBVklPUl9FTVBU
WToKLQkJCSppc19udWxsID0gdHJ1ZTsKLQkJCXJldHVybiAoRGF0dW0pIDA7Ci0KLQkJY2Fz
ZSBKU09OX0JFSEFWSU9SX0RFRkFVTFQ6Ci0JCQlyZXR1cm4gRXhlY0V2YWxFeHByKGRlZmF1
bHRfZXN0YXRlLCBlY29udGV4dCwgaXNfbnVsbCk7Ci0KLQkJZGVmYXVsdDoKLQkJCWVsb2co
RVJST1IsICJ1bnJlY29nbml6ZWQgU1FML0pTT04gYmVoYXZpb3IgJWQiLCBiZWhhdmlvci0+
YnR5cGUpOwotCQkJcmV0dXJuIChEYXR1bSkgMDsKLQl9Ci19Ci0KLS8qCi0gKiBFdmFsdWF0
ZSBhIGNvZXJjaW9uIG9mIGEgSlNPTiBpdGVtIHRvIHRoZSB0YXJnZXQgdHlwZS4KLSAqLwot
c3RhdGljIERhdHVtCi1FeGVjRXZhbEpzb25FeHByQ29lcmNpb24oRXhwckV2YWxTdGVwICpv
cCwgRXhwckNvbnRleHQgKmVjb250ZXh0LAotCQkJCQkJIERhdHVtIHJlcywgYm9vbCAqaXNO
dWxsLCB2b2lkICpwLCBib29sICplcnJvcikKLXsKLQlFeHByU3RhdGUgICplc3RhdGUgPSBw
OwotCUpzb25FeHByU3RhdGUgKmpzZXN0YXRlOwotCi0JaWYgKGVzdGF0ZSkJCQkJCS8qIGNv
ZXJjZSB1c2luZyBzcGVjaWZpZWQgZXhwcmVzc2lvbiAqLwotCQlyZXR1cm4gRXhlY0V2YWxF
eHByKGVzdGF0ZSwgZWNvbnRleHQsIGlzTnVsbCk7Ci0KLQlqc2VzdGF0ZSA9IG9wLT5kLmpz
b25leHByLmpzZXN0YXRlOwotCi0JaWYgKGpzZXN0YXRlLT5qc2V4cHItPm9wICE9IEpTT05f
RVhJU1RTX09QKQotCXsKLQkJSnNvbkNvZXJjaW9uICpjb2VyY2lvbiA9IGpzZXN0YXRlLT5q
c2V4cHItPnJlc3VsdF9jb2VyY2lvbjsKLQkJSnNvbkV4cHIgICAqamV4cHIgPSBqc2VzdGF0
ZS0+anNleHByOwotCQlKc29uYgkgICAqamIgPSAqaXNOdWxsID8gTlVMTCA6IERhdHVtR2V0
SnNvbmJQKHJlcyk7Ci0KLQkJaWYgKChjb2VyY2lvbiAmJiBjb2VyY2lvbi0+dmlhX2lvKSB8
fAotCQkJKGpleHByLT5vbWl0X3F1b3RlcyAmJiAhKmlzTnVsbCAmJgotCQkJIEpCX1JPT1Rf
SVNfU0NBTEFSKGpiKSkpCi0JCXsKLQkJCS8qIHN0cmlwIHF1b3RlcyBhbmQgY2FsbCB0eXBp
bnB1dCBmdW5jdGlvbiAqLwotCQkJY2hhcgkgICAqc3RyID0gKmlzTnVsbCA/IE5VTEwgOiBK
c29uYlVucXVvdGUoamIpOwotCi0JCQlyZXR1cm4gSW5wdXRGdW5jdGlvbkNhbGwoJmpzZXN0
YXRlLT5pbnB1dC5mdW5jLCBzdHIsCi0JCQkJCQkJCQkganNlc3RhdGUtPmlucHV0LnR5cGlv
cGFyYW0sCi0JCQkJCQkJCQkgamV4cHItPnJldHVybmluZy0+dHlwbW9kKTsKLQkJfQotCQll
bHNlIGlmIChjb2VyY2lvbiAmJiBjb2VyY2lvbi0+dmlhX3BvcHVsYXRlKQotCQkJcmV0dXJu
IGpzb25fcG9wdWxhdGVfdHlwZShyZXMsIEpTT05CT0lELAotCQkJCQkJCQkJICBqZXhwci0+
cmV0dXJuaW5nLT50eXBpZCwKLQkJCQkJCQkJCSAgamV4cHItPnJldHVybmluZy0+dHlwbW9k
LAotCQkJCQkJCQkJICAmanNlc3RhdGUtPmNhY2hlLAotCQkJCQkJCQkJICBlY29udGV4dC0+
ZWN4dF9wZXJfcXVlcnlfbWVtb3J5LAotCQkJCQkJCQkJICBpc051bGwpOwotCX0KLQotCWlm
IChqc2VzdGF0ZS0+cmVzdWx0X2V4cHIpCi0JewotCQlqc2VzdGF0ZS0+cmVzX2V4cHItPnZh
bHVlID0gcmVzOwotCQlqc2VzdGF0ZS0+cmVzX2V4cHItPmlzbnVsbCA9ICppc051bGw7Ci0K
LQkJcmVzID0gRXhlY0V2YWxFeHByKGpzZXN0YXRlLT5yZXN1bHRfZXhwciwgZWNvbnRleHQs
IGlzTnVsbCk7Ci0JfQotCi0JcmV0dXJuIHJlczsKLX0KLQotLyoKLSAqIEV2YWx1YXRlIGEg
SlNPTiBwYXRoIHZhcmlhYmxlIGNhY2hpbmcgY29tcHV0ZWQgdmFsdWUuCi0gKi8KLWludAot
RXZhbEpzb25QYXRoVmFyKHZvaWQgKmN4dCwgY2hhciAqdmFyTmFtZSwgaW50IHZhck5hbWVM
ZW4sCi0JCQkJSnNvbmJWYWx1ZSAqdmFsLCBKc29uYlZhbHVlICpiYXNlT2JqZWN0KQotewot
CUpzb25QYXRoVmFyaWFibGVFdmFsQ29udGV4dCAqdmFyID0gTlVMTDsKLQlMaXN0CSAgICp2
YXJzID0gY3h0OwotCUxpc3RDZWxsICAgKmxjOwotCWludAkJCWlkID0gMTsKLQotCWlmICgh
dmFyTmFtZSkKLQkJcmV0dXJuIGxpc3RfbGVuZ3RoKHZhcnMpOwotCi0JZm9yZWFjaChsYywg
dmFycykKLQl7Ci0JCXZhciA9IGxmaXJzdChsYyk7CisJSnNvbmJWYWx1ZSAJYnVmOwogCi0J
CWlmICghc3RybmNtcCh2YXItPm5hbWUsIHZhck5hbWUsIHZhck5hbWVMZW4pKQotCQkJYnJl
YWs7Ci0KLQkJdmFyID0gTlVMTDsKLQkJaWQrKzsKLQl9Ci0KLQlpZiAoIXZhcikKLQkJcmV0
dXJuIC0xOwotCi0JaWYgKCF2YXItPmV2YWx1YXRlZCkKKwkvKgorCSAqIFNwZWNpYWwgY2Fz
ZSBmb3IganNvbiBhbmQganNvbmIgdHlwZXMgZm9yIHdoaWNoIHdlIGRvbid0IGhhdmUKKwkg
KiBjYXN0cyBsaWtlIG51bWVyaWM6Ompzb25iIGV0Yy4KKwkgKi8KKwlpZiAoIXN0ZXBzKQog
CXsKLQkJTWVtb3J5Q29udGV4dCBvbGRjeHQgPSB2YXItPm1jeHQgPwotCQlNZW1vcnlDb250
ZXh0U3dpdGNoVG8odmFyLT5tY3h0KSA6IE5VTEw7Ci0KLQkJdmFyLT52YWx1ZSA9IEV4ZWNF
dmFsRXhwcih2YXItPmVzdGF0ZSwgdmFyLT5lY29udGV4dCwgJnZhci0+aXNudWxsKTsKLQkJ
dmFyLT5ldmFsdWF0ZWQgPSB0cnVlOworCQlKc29uYgkgICAqamIgPSBKc29uYlZhbHVlVG9K
c29uYihpdGVtKTsKIAotCQlpZiAob2xkY3h0KQotCQkJTWVtb3J5Q29udGV4dFN3aXRjaFRv
KG9sZGN4dCk7Ci0JfQorCQkvKgorCQkgKiBVc2UgcmVzdWx0IGNvZXJjaW9uIGZyb20ganNv
bltiXSB0byB0aGUgb3V0cHV0CisJCSAqIHR5cGUgd2hlbiBjYXN0aW5nIHRvIGpzb25bYl0g
dHlwZXMgb3IgdGhlaXIKKwkJICogZG9tYWlucy4KKwkJICovCiAKLQlpZiAodmFyLT5pc251
bGwpCi0JewotCQl2YWwtPnR5cGUgPSBqYnZOdWxsOwotCQlyZXR1cm4gMDsKKwkJKmp1bXAg
PSBvcC0+ZC5qc29uZXhwci5qdW1wX2NvZXJjaW9uX3N1YnRyYW5zOworCQlyZXR1cm4gSnNv
bmJQR2V0RGF0dW0oamIpOzsKIAl9CiAKLQlKc29uSXRlbUZyb21EYXR1bSh2YXItPnZhbHVl
LCB2YXItPnR5cGlkLCB2YXItPnR5cG1vZCwgdmFsKTsKLQotCSpiYXNlT2JqZWN0ID0gKnZh
bDsKLQlyZXR1cm4gaWQ7Ci19Ci0KLS8qCi0gKiBQcmVwYXJlIFNRTC9KU09OIGl0ZW0gY29l
cmNpb24gdG8gdGhlIG91dHB1dCB0eXBlLiBSZXR1cm5lZCBhIGRhdHVtIG9mIHRoZQotICog
Y29ycmVzcG9uZGluZyBTUUwgdHlwZSBhbmQgYSBwb2ludGVyIHRvIHRoZSBjb2VyY2lvbiBz
dGF0ZS4KLSAqLwotRGF0dW0KLUV4ZWNQcmVwYXJlSnNvbkl0ZW1Db2VyY2lvbihKc29uYlZh
bHVlICppdGVtLAotCQkJCQkJCUpzb25SZXR1cm5pbmcgKnJldHVybmluZywKLQkJCQkJCQlz
dHJ1Y3QgSnNvbkNvZXJjaW9uc1N0YXRlICpjb2VyY2lvbnMsCi0JCQkJCQkJc3RydWN0IEpz
b25Db2VyY2lvblN0YXRlICoqcGNvZXJjaW9uKQotewotCXN0cnVjdCBKc29uQ29lcmNpb25T
dGF0ZSAqY29lcmNpb247Ci0JRGF0dW0JCXJlczsKLQlKc29uYlZhbHVlCWJ1ZjsKLQorCS8q
IEV4dHJhY3Qgc2NhbGFyIGZyb20gYmluYXJ5IHNjYWxhciBwcmVzdWRvLWFycmF5ICovCiAJ
aWYgKGl0ZW0tPnR5cGUgPT0gamJ2QmluYXJ5ICYmCiAJCUpzb25Db250YWluZXJJc1NjYWxh
cihpdGVtLT52YWwuYmluYXJ5LmRhdGEpKQogCXsKLQkJYm9vbAkJcmVzIFBHX1VTRURfRk9S
X0FTU0VSVFNfT05MWTsKKwkJYm9vbAkJaXNfc2NhbGFyIFBHX1VTRURfRk9SX0FTU0VSVFNf
T05MWTsKKworCQlpc19zY2FsYXIgPSBKc29uYkV4dHJhY3RTY2FsYXIoaXRlbS0+dmFsLmJp
bmFyeS5kYXRhLCAmYnVmKTsKKwkJQXNzZXJ0KGlzX3NjYWxhcik7CiAKLQkJcmVzID0gSnNv
bmJFeHRyYWN0U2NhbGFyKGl0ZW0tPnZhbC5iaW5hcnkuZGF0YSwgJmJ1Zik7CiAJCWl0ZW0g
PSAmYnVmOwotCQlBc3NlcnQocmVzKTsKIAl9CiAKIAkvKiBnZXQgY29lcmNpb24gc3RhdGUg
cmVmZXJlbmNlIGFuZCBkYXR1bSBvZiB0aGUgY29ycmVzcG9uZGluZyBTUUwgdHlwZSAqLwog
CXN3aXRjaCAoaXRlbS0+dHlwZSkKIAl7CiAJCWNhc2UgamJ2TnVsbDoKLQkJCWNvZXJjaW9u
ID0gJmNvZXJjaW9ucy0+bnVsbDsKLQkJCXJlcyA9IChEYXR1bSkgMDsKLQkJCWJyZWFrOwor
CQkJKmp1bXAgPSBzdGVwcy0+bnVsbDsKKwkJCXJldHVybiAoRGF0dW0pIDA7CiAKIAkJY2Fz
ZSBqYnZTdHJpbmc6Ci0JCQljb2VyY2lvbiA9ICZjb2VyY2lvbnMtPnN0cmluZzsKLQkJCXJl
cyA9IFBvaW50ZXJHZXREYXR1bShjc3RyaW5nX3RvX3RleHRfd2l0aF9sZW4oaXRlbS0+dmFs
LnN0cmluZy52YWwsCi0JCQkJCQkJCQkJCQkJCSAgIGl0ZW0tPnZhbC5zdHJpbmcubGVuKSk7
Ci0JCQlicmVhazsKKwkJCSpqdW1wID0gc3RlcHMtPnN0cmluZzsKKwkJCXJldHVybiAqanVt
cCA8IDAgPyAoRGF0dW0pIDAgOgorCQkJCVBvaW50ZXJHZXREYXR1bShjc3RyaW5nX3RvX3Rl
eHRfd2l0aF9sZW4oaXRlbS0+dmFsLnN0cmluZy52YWwsCisJCQkJCQkJCQkJCQkJCSBpdGVt
LT52YWwuc3RyaW5nLmxlbikpOwogCiAJCWNhc2UgamJ2TnVtZXJpYzoKLQkJCWNvZXJjaW9u
ID0gJmNvZXJjaW9ucy0+bnVtZXJpYzsKLQkJCXJlcyA9IE51bWVyaWNHZXREYXR1bShpdGVt
LT52YWwubnVtZXJpYyk7Ci0JCQlicmVhazsKKwkJCSpqdW1wID0gc3RlcHMtPm51bWVyaWM7
CisJCQlyZXR1cm4gTnVtZXJpY0dldERhdHVtKGl0ZW0tPnZhbC5udW1lcmljKTsKIAogCQlj
YXNlIGpidkJvb2w6Ci0JCQljb2VyY2lvbiA9ICZjb2VyY2lvbnMtPmJvb2xlYW47Ci0JCQly
ZXMgPSBCb29sR2V0RGF0dW0oaXRlbS0+dmFsLmJvb2xlYW4pOwotCQkJYnJlYWs7CisJCQkq
anVtcCA9IHN0ZXBzLT5ib29sZWFuOworCQkJcmV0dXJuIEJvb2xHZXREYXR1bShpdGVtLT52
YWwuYm9vbGVhbik7CiAKIAkJY2FzZSBqYnZEYXRldGltZToKLQkJCXJlcyA9IGl0ZW0tPnZh
bC5kYXRldGltZS52YWx1ZTsKIAkJCXN3aXRjaCAoaXRlbS0+dmFsLmRhdGV0aW1lLnR5cGlk
KQogCQkJewogCQkJCWNhc2UgREFURU9JRDoKLQkJCQkJY29lcmNpb24gPSAmY29lcmNpb25z
LT5kYXRlOworCQkJCQkqanVtcCA9IHN0ZXBzLT5kYXRlOwogCQkJCQlicmVhazsKIAkJCQlj
YXNlIFRJTUVPSUQ6Ci0JCQkJCWNvZXJjaW9uID0gJmNvZXJjaW9ucy0+dGltZTsKKwkJCQkJ
Kmp1bXAgPSBzdGVwcy0+dGltZTsKIAkJCQkJYnJlYWs7CiAJCQkJY2FzZSBUSU1FVFpPSUQ6
Ci0JCQkJCWNvZXJjaW9uID0gJmNvZXJjaW9ucy0+dGltZXR6OworCQkJCQkqanVtcCA9IHN0
ZXBzLT50aW1ldHo7CiAJCQkJCWJyZWFrOwogCQkJCWNhc2UgVElNRVNUQU1QT0lEOgotCQkJ
CQljb2VyY2lvbiA9ICZjb2VyY2lvbnMtPnRpbWVzdGFtcDsKKwkJCQkJKmp1bXAgPSBzdGVw
cy0+dGltZXN0YW1wOwogCQkJCQlicmVhazsKIAkJCQljYXNlIFRJTUVTVEFNUFRaT0lEOgot
CQkJCQljb2VyY2lvbiA9ICZjb2VyY2lvbnMtPnRpbWVzdGFtcHR6OworCQkJCQkqanVtcCA9
IHN0ZXBzLT50aW1lc3RhbXB0ejsKIAkJCQkJYnJlYWs7CiAJCQkJZGVmYXVsdDoKIAkJCQkJ
ZWxvZyhFUlJPUiwgInVuZXhwZWN0ZWQganNvbmIgZGF0ZXRpbWUgdHlwZSBvaWQgJXUiLAog
CQkJCQkJIGl0ZW0tPnZhbC5kYXRldGltZS50eXBpZCk7CiAJCQkJCXJldHVybiAoRGF0dW0p
IDA7CiAJCQl9Ci0JCQlicmVhazsKKworCQkJcmV0dXJuIGl0ZW0tPnZhbC5kYXRldGltZS52
YWx1ZTsKIAogCQljYXNlIGpidkFycmF5OgogCQljYXNlIGpidk9iamVjdDoKIAkJY2FzZSBq
YnZCaW5hcnk6Ci0JCQljb2VyY2lvbiA9ICZjb2VyY2lvbnMtPmNvbXBvc2l0ZTsKLQkJCXJl
cyA9IEpzb25iUEdldERhdHVtKEpzb25iVmFsdWVUb0pzb25iKGl0ZW0pKTsKLQkJCWJyZWFr
OworCQkJKmp1bXAgPSBzdGVwcy0+Y29tcG9zaXRlOworCQkJcmV0dXJuICpqdW1wIDwgMCA/
IChEYXR1bSkgMCA6CisJCQkJSnNvbmJQR2V0RGF0dW0oSnNvbmJWYWx1ZVRvSnNvbmIoaXRl
bSkpOwogCiAJCWRlZmF1bHQ6CiAJCQllbG9nKEVSUk9SLCAidW5leHBlY3RlZCBqc29uYiB2
YWx1ZSB0eXBlICVkIiwgaXRlbS0+dHlwZSk7CiAJCQlyZXR1cm4gKERhdHVtKSAwOwogCX0K
LQotCSpwY29lcmNpb24gPSBjb2VyY2lvbjsKLQotCXJldHVybiByZXM7Ci19Ci0KLXR5cGVk
ZWYgRGF0dW0gKCpKc29uRnVuYykgKEV4cHJFdmFsU3RlcCAqb3AsIEV4cHJDb250ZXh0ICpl
Y29udGV4dCwKLQkJCQkJCSAgIERhdHVtIGl0ZW0sIGJvb2wgKnJlc251bGwsIHZvaWQgKnAs
IGJvb2wgKmVycm9yKTsKLQotc3RhdGljIERhdHVtCi1FeGVjRXZhbEpzb25FeHByU3VidHJh
bnMoSnNvbkZ1bmMgZnVuYywgRXhwckV2YWxTdGVwICpvcCwKLQkJCQkJCSBFeHByQ29udGV4
dCAqZWNvbnRleHQsCi0JCQkJCQkgRGF0dW0gcmVzLCBib29sICpyZXNudWxsLAotCQkJCQkJ
IHZvaWQgKnAsIGJvb2wgKmVycm9yLCBib29sIHN1YnRyYW5zKQotewotCU1lbW9yeUNvbnRl
eHQgb2xkY29udGV4dDsKLQlSZXNvdXJjZU93bmVyIG9sZG93bmVyOwotCi0JaWYgKCFzdWJ0
cmFucykKLQkJLyogTm8gbmVlZCB0byB1c2Ugc3VidHJhbnNhY3Rpb25zLiAqLwotCQlyZXR1
cm4gZnVuYyhvcCwgZWNvbnRleHQsIHJlcywgcmVzbnVsbCwgcCwgZXJyb3IpOwotCi0JLyoK
LQkgKiBXZSBzaG91bGQgY2F0Y2ggZXhjZXB0aW9ucyBvZiBjYXRlZ29yeSBFUlJDT0RFX0RB
VEFfRVhDRVBUSU9OIGFuZAotCSAqIGV4ZWN1dGUgdGhlIGNvcnJlc3BvbmRpbmcgT04gRVJS
T1IgYmVoYXZpb3IgdGhlbi4KLQkgKi8KLQlvbGRjb250ZXh0ID0gQ3VycmVudE1lbW9yeUNv
bnRleHQ7Ci0Jb2xkb3duZXIgPSBDdXJyZW50UmVzb3VyY2VPd25lcjsKLQotCUFzc2VydChl
cnJvcik7Ci0KLQlCZWdpbkludGVybmFsU3ViVHJhbnNhY3Rpb24oTlVMTCk7Ci0JLyogV2Fu
dCB0byBleGVjdXRlIGV4cHJlc3Npb25zIGluc2lkZSBmdW5jdGlvbidzIG1lbW9yeSBjb250
ZXh0ICovCi0JTWVtb3J5Q29udGV4dFN3aXRjaFRvKG9sZGNvbnRleHQpOwotCi0JUEdfVFJZ
KCk7Ci0JewotCQlyZXMgPSBmdW5jKG9wLCBlY29udGV4dCwgcmVzLCByZXNudWxsLCBwLCBl
cnJvcik7Ci0KLQkJLyogQ29tbWl0IHRoZSBpbm5lciB0cmFuc2FjdGlvbiwgcmV0dXJuIHRv
IG91dGVyIHhhY3QgY29udGV4dCAqLwotCQlSZWxlYXNlQ3VycmVudFN1YlRyYW5zYWN0aW9u
KCk7Ci0JCU1lbW9yeUNvbnRleHRTd2l0Y2hUbyhvbGRjb250ZXh0KTsKLQkJQ3VycmVudFJl
c291cmNlT3duZXIgPSBvbGRvd25lcjsKLQl9Ci0JUEdfQ0FUQ0goKTsKLQl7Ci0JCUVycm9y
RGF0YSAgKmVkYXRhOwotCQlpbnQJCQllY2F0ZWdvcnk7Ci0KLQkJLyogU2F2ZSBlcnJvciBp
bmZvIGluIG9sZGNvbnRleHQgKi8KLQkJTWVtb3J5Q29udGV4dFN3aXRjaFRvKG9sZGNvbnRl
eHQpOwotCQllZGF0YSA9IENvcHlFcnJvckRhdGEoKTsKLQkJRmx1c2hFcnJvclN0YXRlKCk7
Ci0KLQkJLyogQWJvcnQgdGhlIGlubmVyIHRyYW5zYWN0aW9uICovCi0JCVJvbGxiYWNrQW5k
UmVsZWFzZUN1cnJlbnRTdWJUcmFuc2FjdGlvbigpOwotCQlNZW1vcnlDb250ZXh0U3dpdGNo
VG8ob2xkY29udGV4dCk7Ci0JCUN1cnJlbnRSZXNvdXJjZU93bmVyID0gb2xkb3duZXI7Ci0K
LQkJZWNhdGVnb3J5ID0gRVJSQ09ERV9UT19DQVRFR09SWShlZGF0YS0+c3FsZXJyY29kZSk7
Ci0KLQkJaWYgKGVjYXRlZ29yeSAhPSBFUlJDT0RFX0RBVEFfRVhDRVBUSU9OICYmCS8qIGpz
b25wYXRoIGFuZCBvdGhlciBkYXRhCi0JCQkJCQkJCQkJCQkJICogZXJyb3JzICovCi0JCQll
Y2F0ZWdvcnkgIT0gRVJSQ09ERV9JTlRFR1JJVFlfQ09OU1RSQUlOVF9WSU9MQVRJT04pCS8q
IGRvbWFpbiBlcnJvcnMgKi8KLQkJCVJlVGhyb3dFcnJvcihlZGF0YSk7Ci0KLQkJcmVzID0g
KERhdHVtKSAwOwotCQkqZXJyb3IgPSB0cnVlOwotCX0KLQlQR19FTkRfVFJZKCk7Ci0KLQly
ZXR1cm4gcmVzOwogfQogCi0KLXR5cGVkZWYgc3RydWN0Ci17Ci0JSnNvblBhdGggICAqcGF0
aDsKLQlib29sCSAgICplcnJvcjsKLQlib29sCQljb2VyY2lvbkluU3VidHJhbnM7Ci19IEV4
ZWNFdmFsSnNvbkV4cHJDb250ZXh0OwotCi1zdGF0aWMgRGF0dW0KLUV4ZWNFdmFsSnNvbkV4
cHIoRXhwckV2YWxTdGVwICpvcCwgRXhwckNvbnRleHQgKmVjb250ZXh0LAotCQkJCSBEYXR1
bSBpdGVtLCBib29sICpyZXNudWxsLCB2b2lkICpwY3h0LAotCQkJCSBib29sICplcnJvcikK
Ky8qCisgKiBFdmFsdWF0ZSBhIFNRTC9KU09OIGZ1bmN0aW9uLgorICovCitpbnQKK0V4ZWNF
dmFsSnNvbihFeHByU3RhdGUgKnN0YXRlLCBFeHByRXZhbFN0ZXAgKm9wKQogewotCUV4ZWNF
dmFsSnNvbkV4cHJDb250ZXh0ICpjeHQgPSBwY3h0OwotCUpzb25QYXRoICAgKnBhdGggPSBj
eHQtPnBhdGg7CiAJSnNvbkV4cHJTdGF0ZSAqanNlc3RhdGUgPSBvcC0+ZC5qc29uZXhwci5q
c2VzdGF0ZTsKKwlKc29uRXhwclByZUV2YWxTdGF0ZSAqcHJlX2V2YWwgPSAmanNlc3RhdGUt
PnByZV9ldmFsOwogCUpzb25FeHByICAgKmpleHByID0ganNlc3RhdGUtPmpzZXhwcjsKLQlF
eHByU3RhdGUgICplc3RhdGUgPSBOVUxMOwotCWJvb2wJCWVtcHR5ID0gZmFsc2U7CisJRGF0
dW0JCWl0ZW0gPSBwcmVfZXZhbC0+Zm9ybWF0dGVkX2V4cHIudmFsdWU7CisJSnNvblBhdGgg
ICAqcGF0aCA9IERhdHVtR2V0SnNvblBhdGhQKHByZV9ldmFsLT5wYXRoc3BlYy52YWx1ZSk7
CisJYm9vbAkJY2F0Y2hfZXJyb3JzID0KKwkJamV4cHItPm9uX2Vycm9yLT5idHlwZSAhPSBK
U09OX0JFSEFWSU9SX0VSUk9SOwogCURhdHVtCQlyZXMgPSAoRGF0dW0pIDA7CisJYm9vbAkJ
ZW1wdHkgPSBmYWxzZTsKKwlib29sCQllcnJvciA9IGZhbHNlOworCWJvb2wJICAgKnBfZXJy
b3IgPSBjYXRjaF9lcnJvcnMgPyAmZXJyb3IgOiBOVUxMOworCisJKm9wLT5yZXN2YWx1ZSA9
IChEYXR1bSkgMDsKKwkqb3AtPnJlc251bGwgPSB0cnVlOwkJLyogdW50aWwgd2UgZ2V0IGEg
cmVzdWx0ICovCiAKIAlzd2l0Y2ggKGpleHByLT5vcCkKIAl7CiAJCWNhc2UgSlNPTl9RVUVS
WV9PUDoKLQkJCXJlcyA9IEpzb25QYXRoUXVlcnkoaXRlbSwgcGF0aCwgamV4cHItPndyYXBw
ZXIsICZlbXB0eSwgZXJyb3IsCi0JCQkJCQkJCWpzZXN0YXRlLT5hcmdzKTsKLQkJCWlmIChl
cnJvciAmJiAqZXJyb3IpCi0JCQl7Ci0JCQkJKnJlc251bGwgPSB0cnVlOwotCQkJCXJldHVy
biAoRGF0dW0pIDA7Ci0JCQl9Ci0JCQkqcmVzbnVsbCA9ICFEYXR1bUdldFBvaW50ZXIocmVz
KTsKKwkJCXJlcyA9IEpzb25QYXRoUXVlcnkoaXRlbSwgcGF0aCwgamV4cHItPndyYXBwZXIs
ICZlbXB0eSwKKwkJCQkJCQkJcF9lcnJvciwgcHJlX2V2YWwtPmFyZ3MpOworCisJCQlpZiAo
ZXJyb3IpCisJCQkJcmV0dXJuIG9wLT5kLmpzb25leHByLmp1bXBfb25lcnJvcjsKKworCQkJ
Km9wLT5yZXNudWxsID0gIURhdHVtR2V0UG9pbnRlcihyZXMpOworCQkJKm9wLT5yZXN2YWx1
ZSA9IHJlczsKKworCQkJLyogRm9yY2UgY29lcmNpb24gdmlhIEkvTyBpZiBPTUlUIFFVT1RF
UyBpcyB1c2VkICovCisJCQlpZiAoamV4cHItPm9taXRfcXVvdGVzICYmICFlbXB0eSAmJiAh
Km9wLT5yZXNudWxsICYmCisJCQkJSkJfUk9PVF9JU19TQ0FMQVIoRGF0dW1HZXRKc29uYlAo
cmVzKSkpCisJCQkJcmV0dXJuIG9wLT5kLmpzb25leHByLmp1bXBfY29lcmNpb25fdmlhX2lv
OworCiAJCQlicmVhazsKIAogCQljYXNlIEpTT05fVkFMVUVfT1A6CiAJCQl7Ci0JCQkJc3Ry
dWN0IEpzb25Db2VyY2lvblN0YXRlICpqY3N0YXRlOwotCQkJCUpzb25iVmFsdWUgKmpidiA9
IEpzb25QYXRoVmFsdWUoaXRlbSwgcGF0aCwgJmVtcHR5LCBlcnJvciwKLQkJCQkJCQkJCQkJ
CWpzZXN0YXRlLT5hcmdzKTsKKwkJCQlpbnQJCQlqdW1wX2l0ZW1fY29lcmNpb247CisJCQkJ
SnNvbmJWYWx1ZSAqamJ2ID0gSnNvblBhdGhWYWx1ZShpdGVtLCBwYXRoLCAmZW1wdHksCisJ
CQkJCQkJCQkJCQlwX2Vycm9yLCBwcmVfZXZhbC0+YXJncyk7CiAKLQkJCQlpZiAoZXJyb3Ig
JiYgKmVycm9yKQotCQkJCQlyZXR1cm4gKERhdHVtKSAwOworCQkJCWlmIChlcnJvcikKKwkJ
CQkJcmV0dXJuIG9wLT5kLmpzb25leHByLmp1bXBfb25lcnJvcjsKIAogCQkJCWlmICghamJ2
KQkJLyogTlVMTCBvciBlbXB0eSAqLwogCQkJCQlicmVhazsKIAogCQkJCUFzc2VydCghZW1w
dHkpOworCQkJCUFzc2VydChqYnYtPnR5cGUgIT0gamJ2TnVsbCk7CiAKLQkJCQkqcmVzbnVs
bCA9IGZhbHNlOworCQkJCS8qCisJCQkJICogUHJlcGFyZSBjb2VyY2lvbiBmcm9tIFNRTC9K
U09OIGl0ZW0gdHlwZSB0byB0aGUKKwkJCQkgKiBvdXRwdXQgU1FMIHR5cGUuCisJCQkJICov
CisJCQkJcmVzID0gRXhlY1ByZXBhcmVKc29uSXRlbUNvZXJjaW9uKGpidiwgb3AsCisJCQkJ
CQkJCQkJCQkgIGpzZXN0YXRlLT5pdGVtX2NvZXJjaW9ucywKKwkJCQkJCQkJCQkJCSAgJmp1
bXBfaXRlbV9jb2VyY2lvbik7CiAKLQkJCQkvKiBjb2VyY2Ugc2NhbGFyIGl0ZW0gdG8gdGhl
IG91dHB1dCB0eXBlICovCi0JCQkJaWYgKCFqc2VzdGF0ZS0+Y29lcmNpb25zKQotCQkJCXsK
LQkJCQkJLyoKLQkJCQkJICogVXNlIHJlc3VsdCBjb2VyY2lvbiBmcm9tIGpzb25bYl0gdG8g
dGhlIG91dHB1dAotCQkJCQkgKiB0eXBlIHdoZW4gY2FzdGluZyB0byBqc29uW2JdIHR5cGVz
IG9yIHRoZWlyCi0JCQkJCSAqIGRvbWFpbnMuCi0JCQkJCSAqLwotCQkJCQlyZXMgPSBKc29u
YlBHZXREYXR1bShKc29uYlZhbHVlVG9Kc29uYihqYnYpKTsKLQkJCQkJYnJlYWs7Ci0JCQkJ
fQorCQkJCSpvcC0+cmVzdmFsdWUgPSByZXM7CisJCQkJKm9wLT5yZXNudWxsID0gZmFsc2U7
CiAKLQkJCQkvKiBVc2UgY29lcmNpb24gZnJvbSBTUUwvSlNPTiBpdGVtIHR5cGUgdG8gdGhl
IG91dHB1dCB0eXBlICovCi0JCQkJcmVzID0gRXhlY1ByZXBhcmVKc29uSXRlbUNvZXJjaW9u
KGpidiwKLQkJCQkJCQkJCQkJCSAganNlc3RhdGUtPmpzZXhwci0+cmV0dXJuaW5nLAotCQkJ
CQkJCQkJCQkJICBqc2VzdGF0ZS0+Y29lcmNpb25zLAotCQkJCQkJCQkJCQkJICAmamNzdGF0
ZSk7CisJCQkJLyogSnVtcCB0byB6ZXJvIGhlcmUgbWVhbnMganVtcCB0byB0aGUgZW5kLiAq
LworCQkJCWlmIChqdW1wX2l0ZW1fY29lcmNpb24gPT0gMCkKKwkJCQkJcmV0dXJuIG9wLT5k
Lmpzb25leHByLmp1bXBfZG9uZTsKIAotCQkJCWlmIChqY3N0YXRlLT5jb2VyY2lvbiAmJgot
CQkJCQkoamNzdGF0ZS0+Y29lcmNpb24tPnZpYV9pbyB8fAotCQkJCQkgamNzdGF0ZS0+Y29l
cmNpb24tPnZpYV9wb3B1bGF0ZSkpCisJCQkJLyoKKwkJCQkgKiBFcnJvciBvdXQgaWYgbm8g
Y2FzdCBleGlzdHMgdG8gY29lcmNlIFNRTC9KU09OIGl0ZW0KKwkJCQkgKiB0byB0aGUgdGhl
IG91dHB1dCB0eXBlLgorCQkJCSAqLworCQkJCWlmIChqdW1wX2l0ZW1fY29lcmNpb24gPCAw
KQogCQkJCXsKLQkJCQkJaWYgKGVycm9yKQotCQkJCQl7Ci0JCQkJCQkqZXJyb3IgPSB0cnVl
OwotCQkJCQkJcmV0dXJuIChEYXR1bSkgMDsKLQkJCQkJfQorCQkJCQkqb3AtPnJlc251bGwg
PSB0cnVlOworCisJCQkJCWlmIChjYXRjaF9lcnJvcnMpCisJCQkJCQlyZXR1cm4gb3AtPmQu
anNvbmV4cHIuanVtcF9vbmVycm9yOwogCi0JCQkJCS8qCi0JCQkJCSAqIENvZXJjaW9uIHZp
YSBJL08gbWVhbnMgaGVyZSB0aGF0IHRoZSBjYXN0IHRvIHRoZSB0YXJnZXQKLQkJCQkJICog
dHlwZSBzaW1wbHkgZG9lcyBub3QgZXhpc3QuCi0JCQkJCSAqLwogCQkJCQllcmVwb3J0KEVS
Uk9SLAogCQkJCQkJCShlcnJjb2RlKEVSUkNPREVfU1FMX0pTT05fSVRFTV9DQU5OT1RfQkVf
Q0FTVF9UT19UQVJHRVRfVFlQRSksCiAJCQkJCQkJIGVycm1zZygiU1FML0pTT04gaXRlbSBj
YW5ub3QgYmUgY2FzdCB0byB0YXJnZXQgdHlwZSIpKSk7CiAJCQkJfQotCQkJCWVsc2UgaWYg
KCFqY3N0YXRlLT5lc3RhdGUpCi0JCQkJCXJldHVybiByZXM7IC8qIG5vIGNvZXJjaW9uICov
CiAKLQkJCQkvKiBjb2VyY2UgdXNpbmcgc3BlY2lmaWMgZXhwcmVzc2lvbiAqLwotCQkJCWVz
dGF0ZSA9IGpjc3RhdGUtPmVzdGF0ZTsKLQkJCQlqc2VzdGF0ZS0+Y29lcmNpb25fZXhwci0+
dmFsdWUgPSByZXM7Ci0JCQkJanNlc3RhdGUtPmNvZXJjaW9uX2V4cHItPmlzbnVsbCA9ICpy
ZXNudWxsOwotCQkJCWJyZWFrOworCQkJCS8qIENvZXJjZSB1c2luZyBhIHNwZWNpZmljIGNv
ZXJjaW9uIGV4cHJlc3Npb24gKi8KKwkJCQlyZXR1cm4ganVtcF9pdGVtX2NvZXJjaW9uOwog
CQkJfQogCiAJCWNhc2UgSlNPTl9FWElTVFNfT1A6CiAJCQl7CiAJCQkJYm9vbAkJZXhpc3Rz
ID0gSnNvblBhdGhFeGlzdHMoaXRlbSwgcGF0aCwKLQkJCQkJCQkJCQkJCQlqc2VzdGF0ZS0+
YXJncywKLQkJCQkJCQkJCQkJCQllcnJvcik7CisJCQkJCQkJCQkJCQkJcHJlX2V2YWwtPmFy
Z3MsCisJCQkJCQkJCQkJCQkJcF9lcnJvcik7CiAKLQkJCQkqcmVzbnVsbCA9IGVycm9yICYm
ICplcnJvcjsKLQkJCQlyZXMgPSBCb29sR2V0RGF0dW0oZXhpc3RzKTsKKwkJCQkqb3AtPnJl
c251bGwgPSBlcnJvcjsKKwkJCQkqb3AtPnJlc3ZhbHVlID0gQm9vbEdldERhdHVtKGV4aXN0
cyk7CiAKLQkJCQlpZiAoIWpzZXN0YXRlLT5yZXN1bHRfZXhwcikKLQkJCQkJcmV0dXJuIHJl
czsKKwkJCQlpZiAoZXJyb3IpCisJCQkJCXJldHVybiBvcC0+ZC5qc29uZXhwci5qdW1wX29u
ZXJyb3I7CiAKLQkJCQkvKiBjb2VyY2UgdXNpbmcgcmVzdWx0IGV4cHJlc3Npb24gKi8KLQkJ
CQllc3RhdGUgPSBqc2VzdGF0ZS0+cmVzdWx0X2V4cHI7Ci0JCQkJanNlc3RhdGUtPnJlc19l
eHByLT52YWx1ZSA9IHJlczsKLQkJCQlqc2VzdGF0ZS0+cmVzX2V4cHItPmlzbnVsbCA9ICpy
ZXNudWxsOwogCQkJCWJyZWFrOwogCQkJfQogCiAJCWNhc2UgSlNPTl9UQUJMRV9PUDoKLQkJ
CSpyZXNudWxsID0gZmFsc2U7Ci0JCQlyZXR1cm4gaXRlbTsKKwkJCSpvcC0+cmVzdmFsdWUg
PSBpdGVtOworCQkJKm9wLT5yZXNudWxsID0gZmFsc2U7CisJCQlyZXR1cm4gb3AtPmQuanNv
bmV4cHIuanVtcF9kb25lOwogCiAJCWRlZmF1bHQ6CiAJCQllbG9nKEVSUk9SLCAidW5yZWNv
Z25pemVkIFNRTC9KU09OIGV4cHJlc3Npb24gb3AgJWQiLCBqZXhwci0+b3ApOwotCQkJcmV0
dXJuIChEYXR1bSkgMDsKKwkJCXJldHVybiBvcC0+ZC5qc29uZXhwci5qdW1wX2RvbmU7CiAJ
fQogCisJLyogRXhlY3V0ZSBPTiBFTVBUWSBiZWhhdmlvciBpZiBubyBTUUwvSlNPTiBpdGVt
cyB3ZXJlIGZvdW5kICovCiAJaWYgKGVtcHR5KQogCXsKIAkJQXNzZXJ0KGpleHByLT5vbl9l
bXB0eSk7CS8qIGl0IGlzIG5vdCBKU09OX0VYSVNUUyAqLwogCiAJCWlmIChqZXhwci0+b25f
ZW1wdHktPmJ0eXBlID09IEpTT05fQkVIQVZJT1JfRVJST1IpCiAJCXsKLQkJCWlmIChlcnJv
cikKLQkJCXsKLQkJCQkqZXJyb3IgPSB0cnVlOwotCQkJCXJldHVybiAoRGF0dW0pIDA7Ci0J
CQl9CisJCQkvKiBUaHJvdyBhbiBlcnJvciBvciBqdW1wIHRvIE9OIEVSUk9SIGhhbmRsZXIg
Ki8KKwkJCWlmIChjYXRjaF9lcnJvcnMpCisJCQkJcmV0dXJuIG9wLT5kLmpzb25leHByLmp1
bXBfb25lcnJvcjsKIAogCQkJZXJlcG9ydChFUlJPUiwKIAkJCQkJKGVycmNvZGUoRVJSQ09E
RV9OT19TUUxfSlNPTl9JVEVNKSwKIAkJCQkJIGVycm1zZygibm8gU1FML0pTT04gaXRlbSIp
KSk7CiAJCX0KIAotCQlpZiAoamV4cHItPm9uX2VtcHR5LT5idHlwZSA9PSBKU09OX0JFSEFW
SU9SX0RFRkFVTFQpCi0KLQkJCS8qCi0JCQkgKiBFeGVjdXRlIERFRkFVTFQgZXhwcmVzc2lv
biBhcyBhIGNvZXJjaW9uIGV4cHJlc3Npb24sIGJlY2F1c2UKLQkJCSAqIGl0cyByZXN1bHQg
aXMgYWxyZWFkeSBjb2VyY2VkIHRvIHRoZSB0YXJnZXQgdHlwZS4KLQkJCSAqLwotCQkJZXN0
YXRlID0ganNlc3RhdGUtPmRlZmF1bHRfb25fZW1wdHk7Ci0JCWVsc2UKLQkJCS8qIEV4ZWN1
dGUgT04gRU1QVFkgYmVoYXZpb3IgKi8KLQkJCXJlcyA9IEV4ZWNFdmFsSnNvbkJlaGF2aW9y
KGVjb250ZXh0LCBqZXhwci0+b25fZW1wdHksCi0JCQkJCQkJCQkgICBqc2VzdGF0ZS0+ZGVm
YXVsdF9vbl9lbXB0eSwKLQkJCQkJCQkJCSAgIHJlc251bGwpOworCQkvKiBFdmFsdWF0ZSBP
TiBFTVBUWSBiZWhhdmlvciAqLworCQlyZXR1cm4gb3AtPmQuanNvbmV4cHIuanVtcF9vbmVt
cHR5OwogCX0KIAotCXJldHVybiBFeGVjRXZhbEpzb25FeHByU3VidHJhbnMoRXhlY0V2YWxK
c29uRXhwckNvZXJjaW9uLCBvcCwgZWNvbnRleHQsCi0JCQkJCQkJCQlyZXMsIHJlc251bGws
IGVzdGF0ZSwgZXJyb3IsCi0JCQkJCQkJCQljeHQtPmNvZXJjaW9uSW5TdWJ0cmFucyk7CisJ
LyogRXZhbHVhdGUgY29lcmNpb24gZXhwcmVzc2lvbiBpbnNpZGUgc3VidHJhbnNhY3Rpb24g
Ki8KKwlyZXR1cm4gb3AtPmQuanNvbmV4cHIuanVtcF9jb2VyY2lvbl9zdWJ0cmFuczsKIH0K
IAorLyogU2tpcCBjYWxsaW5nIEV4ZWNFdmFsSnNvbigpIG9uIGEgSnNvbkV4cHI/ICovCiBi
b29sCi1FeGVjRXZhbEpzb25OZWVkc1N1YlRyYW5zYWN0aW9uKEpzb25FeHByICpqc2V4cHIs
Ci0JCQkJCQkJCWJvb2wgY29uc2lkZXJfY29uZGl0aW9uYWxfY29lcmNpb25zKQorRXhlY0V2
YWxKc29uRXhwclNraXAoRXhwclN0YXRlICpzdGF0ZSwgRXhwckV2YWxTdGVwICpvcCkKIHsK
LQlpZiAoanNleHByLT5vbl9lcnJvci0+YnR5cGUgPT0gSlNPTl9CRUhBVklPUl9FUlJPUikK
LQkJcmV0dXJuIGZhbHNlOwotCi0JaWYgKGpzZXhwci0+b3AgPT0gSlNPTl9FWElTVFNfT1Ag
JiYgIWpzZXhwci0+cmVzdWx0X2NvZXJjaW9uKQotCQlyZXR1cm4gZmFsc2U7CisJSnNvbkV4
cHJTdGF0ZSAqanNlc3RhdGUgPSBvcC0+ZC5qc29uZXhwcl9za2lwLmpzZXN0YXRlOwogCi0J
aWYgKGNvbnNpZGVyX2NvbmRpdGlvbmFsX2NvZXJjaW9ucykKKwkvKgorCSAqIFNraXAgaWYg
ZWl0aGVyIG9mIHRoZSBpbnB1dCBleHByZXNzaW9ucyBoYXMgdHVybmVkIG91dCB0byBiZQor
CSAqIE5VTEwsIHRob3VnaCBkbyBleGVjdXRlIGRvbWFpbiBjaGVja3MgZm9yIE5VTExzLCB3
aGljaCBhcmUKKwkgKiBoYW5kbGVkIGJ5IHRoZSBjb2VyY2lvbiBzdGVwLgorCSAqLworCWlm
IChqc2VzdGF0ZS0+cHJlX2V2YWwuZm9ybWF0dGVkX2V4cHIuaXNudWxsIHx8CisJCWpzZXN0
YXRlLT5wcmVfZXZhbC5wYXRoc3BlYy5pc251bGwpCisJeworCQkqb3AtPnJlc3ZhbHVlID0g
KERhdHVtKSAwOworCQkqb3AtPnJlc251bGwgPSB0cnVlOwogCQlyZXR1cm4gdHJ1ZTsKKwl9
CiAKKwkvKgorCSAqIEdvIGV2YWx1YXRlIHRoZSBQQVNTSU5HIGFyZ3MgaWYgYW55IGFuZCBz
dWJzZXF1ZW50bHkgSlNPTiBwYXRoCisJICogaXRzZWxmLgorCSAqLwogCXJldHVybiBmYWxz
ZTsKIH0KIAotLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotICoJCUV4ZWNFdmFsSnNvbgotICogLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LQotICovCisvKiBBcHBseSBJL08gY29lcmNpb24gdG8gYSBKU09OIGl0ZW0gKi8KIHZvaWQK
LUV4ZWNFdmFsSnNvbihFeHByU3RhdGUgKnN0YXRlLCBFeHByRXZhbFN0ZXAgKm9wLCBFeHBy
Q29udGV4dCAqZWNvbnRleHQpCitFeGVjRXZhbEpzb25FeHBySU9Db2VyY2UoRXhwclN0YXRl
ICpzdGF0ZSwgRXhwckV2YWxTdGVwICpvcCkKIHsKLQlFeGVjRXZhbEpzb25FeHByQ29udGV4
dCBjeHQ7Ci0JSnNvbkV4cHJTdGF0ZSAqanNlc3RhdGUgPSBvcC0+ZC5qc29uZXhwci5qc2Vz
dGF0ZTsKLQlKc29uRXhwciAgICpqZXhwciA9IGpzZXN0YXRlLT5qc2V4cHI7Ci0JRGF0dW0J
CWl0ZW07Ci0JRGF0dW0JCXJlcyA9IChEYXR1bSkgMDsKLQlKc29uUGF0aCAgICpwYXRoOwot
CUxpc3RDZWxsICAgKmxjOwotCWJvb2wJCWVycm9yID0gZmFsc2U7Ci0JYm9vbAkJbmVlZFN1
YnRyYW5zOwotCWJvb2wJCXRocm93RXJyb3JzID0gamV4cHItPm9uX2Vycm9yLT5idHlwZSA9
PSBKU09OX0JFSEFWSU9SX0VSUk9SOwotCi0JKm9wLT5yZXNudWxsID0gdHJ1ZTsJCS8qIHVu
dGlsIHdlIGdldCBhIHJlc3VsdCAqLwotCSpvcC0+cmVzdmFsdWUgPSAoRGF0dW0pIDA7Ci0K
LQlpZiAoanNlc3RhdGUtPmZvcm1hdHRlZF9leHByLT5pc251bGwgfHwganNlc3RhdGUtPnBh
dGhzcGVjLT5pc251bGwpCi0JewotCQkvKiBleGVjdXRlIGRvbWFpbiBjaGVja3MgZm9yIE5V
TExzICovCi0JCSh2b2lkKSBFeGVjRXZhbEpzb25FeHByQ29lcmNpb24ob3AsIGVjb250ZXh0
LCByZXMsIG9wLT5yZXNudWxsLAotCQkJCQkJCQkJCU5VTEwsIE5VTEwpOworCS8qIFN0cmlw
IHF1b3RlcyBhbmQgY2FsbCB0eXBpbnB1dCBmdW5jdGlvbiAqLworCWNoYXIJICAgKnN0ciA9
IE5VTEw7CiAKLQkJQXNzZXJ0KCpvcC0+cmVzbnVsbCk7Ci0JCXJldHVybjsKLQl9Ci0KLQlp
dGVtID0ganNlc3RhdGUtPmZvcm1hdHRlZF9leHByLT52YWx1ZTsKLQlwYXRoID0gRGF0dW1H
ZXRKc29uUGF0aFAoanNlc3RhdGUtPnBhdGhzcGVjLT52YWx1ZSk7Ci0KLQkvKiByZXNldCBK
U09OIHBhdGggdmFyaWFibGUgY29udGV4dHMgKi8KLQlmb3JlYWNoKGxjLCBqc2VzdGF0ZS0+
YXJncykKKwlpZiAoISpvcC0+cmVzbnVsbCkKIAl7Ci0JCUpzb25QYXRoVmFyaWFibGVFdmFs
Q29udGV4dCAqdmFyID0gbGZpcnN0KGxjKTsKKwkJSnNvbmIJICAgKmpiID0gRGF0dW1HZXRK
c29uYlAoKm9wLT5yZXN2YWx1ZSk7CiAKLQkJdmFyLT5lY29udGV4dCA9IGVjb250ZXh0Owot
CQl2YXItPmV2YWx1YXRlZCA9IGZhbHNlOworCQlzdHIgPSBKc29uYlVucXVvdGUoamIpOwog
CX0KIAotCW5lZWRTdWJ0cmFucyA9IEV4ZWNFdmFsSnNvbk5lZWRzU3ViVHJhbnNhY3Rpb24o
amV4cHIsIGZhbHNlKTsKLQotCWN4dC5wYXRoID0gcGF0aDsKLQljeHQuZXJyb3IgPSB0aHJv
d0Vycm9ycyA/IE5VTEwgOiAmZXJyb3I7Ci0JY3h0LmNvZXJjaW9uSW5TdWJ0cmFucyA9ICFu
ZWVkU3VidHJhbnMgJiYgIXRocm93RXJyb3JzOwotCUFzc2VydCghbmVlZFN1YnRyYW5zIHx8
IGN4dC5lcnJvcik7Ci0KLQlyZXMgPSBFeGVjRXZhbEpzb25FeHByU3VidHJhbnMoRXhlY0V2
YWxKc29uRXhwciwgb3AsIGVjb250ZXh0LCBpdGVtLAotCQkJCQkJCQkgICBvcC0+cmVzbnVs
bCwgJmN4dCwgY3h0LmVycm9yLAotCQkJCQkJCQkgICBuZWVkU3VidHJhbnMpOwotCi0JaWYg
KGVycm9yKQotCXsKLQkJLyogRXhlY3V0ZSBPTiBFUlJPUiBiZWhhdmlvciAqLwotCQlyZXMg
PSBFeGVjRXZhbEpzb25CZWhhdmlvcihlY29udGV4dCwgamV4cHItPm9uX2Vycm9yLAotCQkJ
CQkJCQkgICBqc2VzdGF0ZS0+ZGVmYXVsdF9vbl9lcnJvciwKLQkJCQkJCQkJICAgb3AtPnJl
c251bGwpOwotCi0JCS8qIHJlc3VsdCBpcyBhbHJlYWR5IGNvZXJjZWQgaW4gREVGQVVMVCBi
ZWhhdmlvciBjYXNlICovCi0JCWlmIChqZXhwci0+b25fZXJyb3ItPmJ0eXBlICE9IEpTT05f
QkVIQVZJT1JfREVGQVVMVCkKLQkJCXJlcyA9IEV4ZWNFdmFsSnNvbkV4cHJDb2VyY2lvbihv
cCwgZWNvbnRleHQsIHJlcywKLQkJCQkJCQkJCQkgICBvcC0+cmVzbnVsbCwKLQkJCQkJCQkJ
CQkgICBOVUxMLCBOVUxMKTsKLQl9CisJKm9wLT5yZXN2YWx1ZSA9IElucHV0RnVuY3Rpb25D
YWxsKG9wLT5kLmpzb25leHByX2lvY29lcmNlLmZpbmZvLCBzdHIsCisJCQkJCQkJCQkgIG9w
LT5kLmpzb25leHByX2lvY29lcmNlLnR5cGlvcGFyYW0sCisJCQkJCQkJCQkgIG9wLT5kLmpz
b25leHByX2lvY29lcmNlLnR5cG1vZCk7Cit9CiAKLQkqb3AtPnJlc3ZhbHVlID0gcmVzOwor
LyogQXBwbHkganNvbl9wb3B1bGF0ZV90eXBlKCkgdG8gYSBKU09OIGl0ZW0gKi8KK3ZvaWQK
K0V4ZWNFdmFsSnNvbkV4cHJQb3B1bGF0ZShFeHByU3RhdGUgKnN0YXRlLCBFeHByRXZhbFN0
ZXAgKm9wLAorCQkJCQkJIEV4cHJDb250ZXh0ICplY29udGV4dCkKK3sKKwkqb3AtPnJlc3Zh
bHVlID0KKwkJanNvbl9wb3B1bGF0ZV90eXBlKCpvcC0+cmVzdmFsdWUsIEpTT05CT0lELAor
CQkJCQkJICAgb3AtPmQuanNvbmV4cHJfcG9wdWxhdGUuanNleHByLT5yZXR1cm5pbmctPnR5
cGlkLAorCQkJCQkJICAgb3AtPmQuanNvbmV4cHJfcG9wdWxhdGUuanNleHByLT5yZXR1cm5p
bmctPnR5cG1vZCwKKwkJCQkJCSAgICZvcC0+ZC5qc29uZXhwcl9wb3B1bGF0ZS5jYWNoZSwK
KwkJCQkJCSAgIGVjb250ZXh0LT5lY3h0X3Blcl9xdWVyeV9tZW1vcnksCisJCQkJCQkgICBv
cC0+cmVzbnVsbCk7CiB9CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9qaXQvbGx2bS9sbHZt
aml0X2V4cHIuYyBiL3NyYy9iYWNrZW5kL2ppdC9sbHZtL2xsdm1qaXRfZXhwci5jCmluZGV4
IDYxNGVkNThmMWNiLi41MjQ1ZmU3NjVjNSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvaml0
L2xsdm0vbGx2bWppdF9leHByLmMKKysrIGIvc3JjL2JhY2tlbmQvaml0L2xsdm0vbGx2bWpp
dF9leHByLmMKQEAgLTI0NjUsOCArMjQ2NSwxNDEgQEAgbGx2bV9jb21waWxlX2V4cHJfc3Rl
cChFeHByU3RhdGUgKnN0YXRlLCBpbnQgc3RhcnRfb3BubykKIAkJCQlMTFZNQnVpbGRCcihi
LCBvcGJsb2Nrc1tvcG5vICsgMV0pOwogCQkJCWJyZWFrOwogCi0JCQljYXNlIEVFT1BfSlNP
TkVYUFI6Ci0JCQkJYnVpbGRfRXZhbFhGdW5jKGIsIG1vZCwgIkV4ZWNFdmFsSnNvbiIsCisJ
CQljYXNlIEVFT1BfSlNPTkVYUFJfUEFUSDoKKwkJCQl7CisJCQkJCUxMVk1WYWx1ZVJlZiB2
X3JldDsKKwkJCQkJTExWTUJhc2ljQmxvY2tSZWYgKmJfY29lcmNpb25zOworCQkJCQlKc29u
SXRlbUNvZXJjaW9uc1N0ZXBzICpqY3N0YXRlID0KKwkJCQkJCW9wLT5kLmpzb25leHByLmpz
ZXN0YXRlLT5pdGVtX2NvZXJjaW9uczsKKwkJCQkJaW50CQkJbl9qdW1wcyA9IDY7CisJCQkJ
CWludAkJCW5fY29lcmNpb25zID0gIWpjc3RhdGUgPyAwIDoKKwkJCQkJCShpbnQpICgmamNz
dGF0ZS0+Y29tcG9zaXRlIC0gJmpjc3RhdGUtPm51bGwpICsgMTsKKwkJCQkJaW50CQkgICAq
anVtcHM7CisKKwkJCQkJLyoKKwkJCQkJICogRXhlY0V2YWxKc29uKCkgcmV0dXJucyBudW1i
ZXIgb2YgdGhlIHN0ZXAgd2UKKwkJCQkJICogbmVlZCB0byBqdW1wLgorCQkJCQkgKi8KKwkJ
CQkJdl9yZXQgPSBidWlsZF9FdmFsWEZ1bmMoYiwgbW9kLCAiRXhlY0V2YWxKc29uIiwKKwkJ
CQkJCQkJCQkJdl9zdGF0ZSwgb3ApOworCisJCQkJCS8qCisJCQkJCSAqIFdpbGwgY3JlYXRl
IGEgYmxvY2sgZm9yIGVhY2ggcG9zc2libGUganVtcCB0bworCQkJCQkgKiBjaGVjayB3aGV0
aGVyIHRvIGV2YWx1YXRlIHRoZSBjb2VyY2lvbidzCisJCQkJCSAqIGV4cHJlc3Npb24gaWYg
dGhlcmUncyBvbmUgb3IgdG8gc2tpcCB0byB0aGUgZW5kCisJCQkJCSAqIGlmIG5vdC4KKwkJ
CQkJICovCisJCQkJCWJfY29lcmNpb25zID0gcGFsbG9jKChuX2p1bXBzICsgbl9jb2VyY2lv
bnMpICogc2l6ZW9mKCpiX2NvZXJjaW9ucykpOworCQkJCQlqdW1wcyA9IHBhbGxvYygobl9q
dW1wcyArIG5fY29lcmNpb25zKSAqIHNpemVvZigqanVtcHMpKTsKKworCQkJCQlqdW1wc1sw
XSA9IG9wLT5kLmpzb25leHByLmp1bXBfZG9uZTsKKwkJCQkJanVtcHNbMV0gPSBvcC0+ZC5q
c29uZXhwci5qdW1wX2NvZXJjaW9uOworCQkJCQlqdW1wc1syXSA9IG9wLT5kLmpzb25leHBy
Lmp1bXBfY29lcmNpb25fc3VidHJhbnM7CisJCQkJCWp1bXBzWzNdID0gb3AtPmQuanNvbmV4
cHIuanVtcF9jb2VyY2lvbl92aWFfaW87CisJCQkJCWp1bXBzWzRdID0gb3AtPmQuanNvbmV4
cHIuanVtcF9vbmVtcHR5OworCQkJCQlqdW1wc1s1XSA9IG9wLT5kLmpzb25leHByLmp1bXBf
b25lcnJvcjsKKworCQkJCQliX2NvZXJjaW9uc1swXSA9CisJCQkJCQlsX2JiX2JlZm9yZV92
KG9wYmxvY2tzW29wbm8gKyAxXSwKKwkJCQkJCQkJCSAgIm9wLiVkLmpzb25leHByX2p1bXBf
Y29lcmNpb24iLCBvcG5vKTsKKwkJCQkJYl9jb2VyY2lvbnNbMV0gPQorCQkJCQkJbF9iYl9i
ZWZvcmVfdihvcGJsb2Nrc1tvcG5vICsgMV0sCisJCQkJCQkJCQkgICJvcC4lZC5qc29uZXhw
cl9qdW1wX2NvZXJjaW9uX3N1YnRyYW5zIiwgb3Bubyk7CisJCQkJCWJfY29lcmNpb25zWzJd
ID0KKwkJCQkJCWxfYmJfYmVmb3JlX3Yob3BibG9ja3Nbb3BubyArIDFdLAorCQkJCQkJCQkJ
ICAib3AuJWQuanNvbmV4cHJfanVtcF9jb2VyY2lvbl9pbyIsIG9wbm8pOworCQkJCQliX2Nv
ZXJjaW9uc1szXSA9CisJCQkJCQlsX2JiX2JlZm9yZV92KG9wYmxvY2tzW29wbm8gKyAxXSwK
KwkJCQkJCQkJCSAgIm9wLiVkLmpzb25leHByX2p1bXBfb25lbXB0eSIsIG9wbm8pOworCQkJ
CQliX2NvZXJjaW9uc1s0XSA9CisJCQkJCQlsX2JiX2JlZm9yZV92KG9wYmxvY2tzW29wbm8g
KyAxXSwKKwkJCQkJCQkJCSAgIm9wLiVkLmpzb25leHByX2p1bXBfb25lcnJvciIsIG9wbm8p
OworCisJCQkJCWZvciAoaW50IGkgPSAwOyBpIDwgbl9jb2VyY2lvbnM7IGkrKykKKwkJCQkJ
CWp1bXBzW2kgKyBuX2p1bXBzXSA9ICgmamNzdGF0ZS0+bnVsbClbaV07CisKKwkJCQkJZm9y
IChpbnQgaSA9IDA7IGkgPCBuX2NvZXJjaW9ucyArIDE7IGkrKykKKwkJCQkJCWJfY29lcmNp
b25zW2kgKyBuX2p1bXBzIC0gMV0gPQorCQkJCQkJCWxfYmJfYmVmb3JlX3Yob3BibG9ja3Nb
b3BubyArIDFdLAorCQkJCQkJCQkJCSAgIm9wLiVkLmpzb25leHByX2p1bXBfaXRlbS4lZCIs
CisJCQkJCQkJCQkJICBvcG5vLCBpKTsKKworCQkJCQkvKgorCQkJCQkgKiBBZGQgY29uZGl0
aW9uYWwgYnJhbmNoZXMgZm9yIGluZGl2aWR1YWwKKwkJCQkJICogY29lcmNpb24ncyBleHBy
ZXNzaW9ucy4KKwkJCQkJICoKKwkJCQkJICogSnVtcCB0byBjb2VyY2lvbiBzdGVwIGlmIHRo
ZSByZXR1cm5lZCBhZGRyZXNzIGlzCisJCQkJCSAqIHRoZSBzYW1lIGFzIGp1bXBzW2ldLCBl
bHNlIGp1bXAgdG8gdGhlIG5leHQKKwkJCQkJICogYmxvY2ssIHRoYXQgY2hlY2tzIG5leHQg
anVtcCBhZGRyZXNzLgorCQkJCQkgKi8KKwkJCQkJZm9yIChpbnQgaSA9IDA7IGkgPCBuX2p1
bXBzICsgbl9jb2VyY2lvbnM7IGkrKykKKwkJCQkJeworCQkJCQkJaWYgKGkgPiAwKQorCQkJ
CQkJCUxMVk1Qb3NpdGlvbkJ1aWxkZXJBdEVuZChiLCBiX2NvZXJjaW9uc1tpIC0gMV0pOwor
CisJCQkJCQlMTFZNQnVpbGRDb25kQnIoYiwKKwkJCQkJCQkJCQlMTFZNQnVpbGRJQ21wKGIs
CisJCQkJCQkJCQkJCQkJICBMTFZNSW50RVEsCisJCQkJCQkJCQkJCQkJICB2X3JldCwKKwkJ
CQkJCQkJCQkJCQkgIGxfaW50MzJfY29uc3QoanVtcHNbaV0pLAorCQkJCQkJCQkJCQkJCSAg
IiIpLAorCQkJCQkJCQkJCW9wYmxvY2tzW2p1bXBzW2ldID49IDAgPyBqdW1wc1tpXSA6IGp1
bXBzWzBdXSwKKwkJCQkJCQkJCQliX2NvZXJjaW9uc1tpXSk7CisJCQkJCX0KKworCQkJCQkv
KgorCQkJCQkgKiBBIHBsYWNlaG9sZGVyIGJsb2NrIHRoYXQgdGhlIGxhc3QgY29lcmNpb24n
cworCQkJCQkgKiBibG9jayBtaWdodCBqdW1wIHRvLCB3aGljaCB1bmNvbmRpdGlvbmFsbHkg
anVtcHMKKwkJCQkJICogdG8gZW5kIG9mIGNvZXJjaW9ucy4KKwkJCQkJICovCisJCQkJCUxM
Vk1Qb3NpdGlvbkJ1aWxkZXJBdEVuZChiLCBiX2NvZXJjaW9uc1tuX2p1bXBzICsgbl9jb2Vy
Y2lvbnMgLSAxXSk7CisJCQkJCUxMVk1CdWlsZEJyKGIsIG9wYmxvY2tzW29wLT5kLmpzb25l
eHByLmp1bXBfZG9uZV0pOworCisJCQkJCXBmcmVlKGJfY29lcmNpb25zKTsKKwkJCQkJcGZy
ZWUoanVtcHMpOworCQkJCQlicmVhazsKKwkJCQl9CisJCQkJYnJlYWs7CisKKwkJCWNhc2Ug
RUVPUF9KU09ORVhQUl9TS0lQOgorCQkJCXsKKwkJCQkJTExWTVZhbHVlUmVmIHZfcmV0Owor
CisJCQkJCS8qCisJCQkJCSAqIENhbGwgRXhlY0V2YWxKc29uRXhwclNraXAoKSB0byBkZWNp
ZGUgaWYgSlNPTgorCQkJCQkgKiBwYXRoIGV2YWx1YXRpb24gY2FuIGJlIHNraXBwZWQuICBU
aGlzIHJldHVybnMKKwkJCQkJICogYm9vbGVhbiAic2tpcCIgZmxhZy4KKwkJCQkJICovCisJ
CQkJCXZfcmV0ID0gYnVpbGRfRXZhbFhGdW5jKGIsIG1vZCwgIkV4ZWNFdmFsSnNvbkV4cHJT
a2lwIiwKKwkJCQkJCQkJCQkJdl9zdGF0ZSwgb3ApOworCQkJCQl2X3JldCA9IExMVk1CdWls
ZFpFeHQoYiwgdl9yZXQsIFR5cGVTdG9yYWdlQm9vbCwgIiIpOworCisJCQkJCS8qCisJCQkJ
CSAqIEp1bXAgdG8gY29lcmNpb24gc3RlcCBpZiB0cnVlIHdhcyByZXR1cm5lZCwKKwkJCQkJ
ICogd2hpY2ggc2lnbmlmaWVzIHNraXBwaW5nIG9mIEpTT04gcGF0aCBldmFsdWF0aW9uLAor
CQkJCQkgKiBlbHNlIHRvIHRoZSBuZXh0IHN0ZXAgd2hpY2ggbXVzdCBwb2ludCB0byB0aGUK
KwkJCQkJICogc3RlcHMgdG8gZXZhbHVhdGUgUEFTU0lORyBhcmdzLCBpZiBhbnksIG9yIHRv
CisJCQkJCSAqIHRoZSBKU09OIHBhdGggZXZhbHVhdGlvbi4KKwkJCQkJICovCisJCQkJCUxM
Vk1CdWlsZENvbmRCcihiLAorCQkJCQkJCQkJTExWTUJ1aWxkSUNtcChiLAorCQkJCQkJCQkJ
CQkJICBMTFZNSW50RVEsCisJCQkJCQkJCQkJCQkgIHZfcmV0LAorCQkJCQkJCQkJCQkJICBs
X3Nib29sX2NvbnN0KDApLAorCQkJCQkJCQkJCQkJICAiIiksCisJCQkJCQkJCQlvcGJsb2Nr
c1tvcG5vICsgMV0sCisJCQkJCQkJCQlvcGJsb2Nrc1tvcC0+ZC5qc29uZXhwcl9za2lwLmp1
bXBfY29lcmNpb25dKTsKKwkJCQkJYnJlYWs7CisJCQkJfQorCisJCQljYXNlIEVFT1BfSlNP
TkVYUFJfSU9DT0VSQ0U6CisJCQkJYnVpbGRfRXZhbFhGdW5jKGIsIG1vZCwgIkV4ZWNFdmFs
SnNvbkV4cHJJT0NvZXJjZSIsCisJCQkJCQkJCQl2X3N0YXRlLCBvcCk7CisJCQkJTExWTUJ1
aWxkQnIoYiwgb3BibG9ja3Nbb3BubyArIDFdKTsKKwkJCQlicmVhazsKKworCQkJY2FzZSBF
RU9QX0pTT05FWFBSX1BPUFVMQVRFOgorCQkJCWJ1aWxkX0V2YWxYRnVuYyhiLCBtb2QsICJF
eGVjRXZhbEpzb25FeHByUG9wdWxhdGUiLAogCQkJCQkJCQl2X3N0YXRlLCBvcCwgdl9lY29u
dGV4dCk7CiAJCQkJTExWTUJ1aWxkQnIoYiwgb3BibG9ja3Nbb3BubyArIDFdKTsKIAkJCQli
cmVhazsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2ppdC9sbHZtL2xsdm1qaXRfdHlwZXMu
YyBiL3NyYy9iYWNrZW5kL2ppdC9sbHZtL2xsdm1qaXRfdHlwZXMuYwppbmRleCBhOWRkYmE2
ZTRjZC4uZDQ3ZDA2NWRjNTkgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2ppdC9sbHZtL2xs
dm1qaXRfdHlwZXMuYworKysgYi9zcmMvYmFja2VuZC9qaXQvbGx2bS9sbHZtaml0X3R5cGVz
LmMKQEAgLTEzNiw2ICsxMzYsOSBAQCB2b2lkCSAgICpyZWZlcmVuY2VkX2Z1bmN0aW9uc1td
ID0KIAlFeGVjRXZhbFN1YnRyYW5zLAogCUV4ZWNFdmFsSnNvbkNvbnN0cnVjdG9yLAogCUV4
ZWNFdmFsSnNvbklzUHJlZGljYXRlLAorCUV4ZWNFdmFsSnNvbkV4cHJTa2lwLAorCUV4ZWNF
dmFsSnNvbkV4cHJJT0NvZXJjZSwKKwlFeGVjRXZhbEpzb25FeHByUG9wdWxhdGUsCiAJRXhl
Y0V2YWxKc29uLAogCU1ha2VFeHBhbmRlZE9iamVjdFJlYWRPbmx5SW50ZXJuYWwsCiAJc2xv
dF9nZXRtaXNzaW5nYXR0cnMsCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9vcHRpbWl6ZXIv
dXRpbC9jbGF1c2VzLmMgYi9zcmMvYmFja2VuZC9vcHRpbWl6ZXIvdXRpbC9jbGF1c2VzLmMK
aW5kZXggYTFkODY4YmI4N2IuLmU5ZWVlOGMxYTBjIDEwMDY0NAotLS0gYS9zcmMvYmFja2Vu
ZC9vcHRpbWl6ZXIvdXRpbC9jbGF1c2VzLmMKKysrIGIvc3JjL2JhY2tlbmQvb3B0aW1pemVy
L3V0aWwvY2xhdXNlcy5jCkBAIC05MDEsNyArOTAxLDcgQEAgbWF4X3BhcmFsbGVsX2hhemFy
ZF93YWxrZXIoTm9kZSAqbm9kZSwgbWF4X3BhcmFsbGVsX2hhemFyZF9jb250ZXh0ICpjb250
ZXh0KQogCXsKIAkJSnNvbkV4cHIgICAqanNleHByID0gKEpzb25FeHByICopIG5vZGU7CiAK
LQkJaWYgKEV4ZWNFdmFsSnNvbk5lZWRzU3ViVHJhbnNhY3Rpb24oanNleHByLCB0cnVlKSkK
KwkJaWYgKEV4ZWNKc29uRXhwck5lZWRzU3ViVHJhbnNhY3Rpb24oanNleHByKSkKIAkJewog
CQkJY29udGV4dC0+bWF4X2hhemFyZCA9IFBST1BBUkFMTEVMX1VOU0FGRTsKIAkJCXJldHVy
biB0cnVlOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvcGFyc2VyL3BhcnNlX2V4cHIuYyBi
L3NyYy9iYWNrZW5kL3BhcnNlci9wYXJzZV9leHByLmMKaW5kZXggMzFmYjU1NTU2NTkuLjQx
ZjRhY2JjMjYyIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9wYXJzZXIvcGFyc2VfZXhwci5j
CisrKyBiL3NyYy9iYWNrZW5kL3BhcnNlci9wYXJzZV9leHByLmMKQEAgLTQzMjksNiArNDMy
OSw3IEBAIGluaXRKc29uSXRlbUNvZXJjaW9uKFBhcnNlU3RhdGUgKnBzdGF0ZSwgT2lkIHR5
cGlkLAogCQkJCQkgY29uc3QgSnNvblJldHVybmluZyAqcmV0dXJuaW5nKQogewogCU5vZGUJ
ICAgKmV4cHI7CisJSnNvbkNvZXJjaW9uICpjb2VyY2lvbjsKIAogCWlmICh0eXBpZCA9PSBV
TktOT1dOT0lEKQogCXsKQEAgLTQzNDUsNyArNDM0NiwxNiBAQCBpbml0SnNvbkl0ZW1Db2Vy
Y2lvbihQYXJzZVN0YXRlICpwc3RhdGUsIE9pZCB0eXBpZCwKIAkJZXhwciA9IChOb2RlICop
IHBsYWNlaG9sZGVyOwogCX0KIAotCXJldHVybiBjb2VyY2VKc29uRXhwcihwc3RhdGUsIGV4
cHIsIHJldHVybmluZyk7CisJY29lcmNpb24gPSBjb2VyY2VKc29uRXhwcihwc3RhdGUsIGV4
cHIsIHJldHVybmluZyk7CisKKwkvKgorCSAqIENvZXJjaW9uIHZpYSBJL08gbWVhbnMgaGVy
ZSB0aGF0IHRoZSBjYXN0IHRvIHRoZSB0YXJnZXQgdHlwZQorCSAqIHNpbXBseSBkb2VzIG5v
dCBleGlzdC4KKwkgKi8KKwlpZiAoY29lcmNpb24tPnZpYV9pbyB8fCBjb2VyY2lvbi0+dmlh
X3BvcHVsYXRlKQorCQlyZXR1cm4gTlVMTDsKKworCXJldHVybiBjb2VyY2lvbjsKIH0KIAog
c3RhdGljIEpzb25JdGVtQ29lcmNpb25zICoKQEAgLTQzNzMsNiArNDM4MywxMSBAQCBpbml0
SnNvbkl0ZW1Db2VyY2lvbnMoUGFyc2VTdGF0ZSAqcHN0YXRlLCBjb25zdCBKc29uUmV0dXJu
aW5nICpyZXR1cm5pbmcsCiAJCXtOVUxMLCBJbnZhbGlkT2lkfQogCX07CiAKKwkvKiBXaGVu
IHJldHVybmluZyBKU09OIHR5cGVzLCBubyBuZWVkIHRvIGluaXRpYWxpemUgY29lcmNpb25z
ICovCisJLyogWFhYIGRvbWFpbiB0eXBlcyBvbiBqc29uL2pzb25iICovCisJaWYgKHJldHVy
bmluZy0+dHlwaWQgPT0gSlNPTkJPSUQgfHwgcmV0dXJuaW5nLT50eXBpZCA9PSBKU09OT0lE
KQorCQlyZXR1cm4gTlVMTDsKKwogCWZvciAocCA9IGNvZXJjaW9uVHlwaWRzOyBwLT5jb2Vy
Y2lvbjsgcCsrKQogCQkqcC0+Y29lcmNpb24gPSBpbml0SnNvbkl0ZW1Db2VyY2lvbihwc3Rh
dGUsIHAtPnR5cGlkLCByZXR1cm5pbmcpOwogCkBAIC00NDUzLDYgKzQ0NjgsNyBAQCB0cmFu
c2Zvcm1Kc29uRnVuY0V4cHIoUGFyc2VTdGF0ZSAqcHN0YXRlLCBKc29uRnVuY0V4cHIgKmZ1
bmMpCiAJCQl9CiAJCQllbHNlIGlmIChqc2V4cHItPnJldHVybmluZy0+dHlwaWQgIT0gQk9P
TE9JRCkKIAkJCXsKKwkJCQkvKiBXZSBuZWVkIHRvIGhhbmRsZSBSRVRVUk5JTkcgaW50IGV0
Yy4gKi8KIAkJCQlDYXNlVGVzdEV4cHIgKnBsYWNlaG9sZGVyID0gbWFrZU5vZGUoQ2FzZVRl
c3RFeHByKTsKIAkJCQlpbnQJCQlsb2NhdGlvbiA9IGV4cHJMb2NhdGlvbigoTm9kZSAqKSBq
c2V4cHIpOwogCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9hZHQvanNvbnBhdGhf
ZXhlYy5jIGIvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L2pzb25wYXRoX2V4ZWMuYwppbmRleCAx
MGM3ZTY0YWFiMy4uYzNmYzc3Y2Y1MTUgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxz
L2FkdC9qc29ucGF0aF9leGVjLmMKKysrIGIvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L2pzb25w
YXRoX2V4ZWMuYwpAQCAtMjg2LDYgKzI4Niw4IEBAIHN0YXRpYyBKc29uUGF0aEV4ZWNSZXN1
bHQgYXBwZW5kQm9vbFJlc3VsdChKc29uUGF0aEV4ZWNDb250ZXh0ICpjeHQsCiAJCQkJCQkJ
CQkJICAgSnNvblBhdGhJdGVtICpqc3AsIEpzb25WYWx1ZUxpc3QgKmZvdW5kLCBKc29uUGF0
aEJvb2wgcmVzKTsKIHN0YXRpYyB2b2lkIGdldEpzb25QYXRoSXRlbShKc29uUGF0aEV4ZWND
b250ZXh0ICpjeHQsIEpzb25QYXRoSXRlbSAqaXRlbSwKIAkJCQkJCQlKc29uYlZhbHVlICp2
YWx1ZSk7CitzdGF0aWMgaW50CUV2YWxKc29uUGF0aFZhcih2b2lkICp2YXJzLCBjaGFyICp2
YXJOYW1lLCBpbnQgdmFyTmFtZUxlbiwKKwkJCQkJCQlKc29uYlZhbHVlICp2YWwsIEpzb25i
VmFsdWUgKmJhc2VPYmplY3QpOwogc3RhdGljIHZvaWQgZ2V0SnNvblBhdGhWYXJpYWJsZShK
c29uUGF0aEV4ZWNDb250ZXh0ICpjeHQsCiAJCQkJCQkJCUpzb25QYXRoSXRlbSAqdmFyaWFi
bGUsIEpzb25iVmFsdWUgKnZhbHVlKTsKIHN0YXRpYyBpbnQJZ2V0SnNvblBhdGhWYXJpYWJs
ZUZyb21Kc29uYih2b2lkICp2YXJzSnNvbmIsIGNoYXIgKnZhck5hbWUsCkBAIC0yMTcyLDYg
KzIxNzQsNzIgQEAgZ2V0SnNvblBhdGhJdGVtKEpzb25QYXRoRXhlY0NvbnRleHQgKmN4dCwg
SnNvblBhdGhJdGVtICppdGVtLAogCX0KIH0KIAorLyoKKyAqIEV2YWx1YXRlIGEgSlNPTiBw
YXRoIHZhcmlhYmxlIGNhY2hpbmcgY29tcHV0ZWQgdmFsdWUuCisgKi8KK2ludAorRXZhbEpz
b25QYXRoVmFyKHZvaWQgKmN4dCwgY2hhciAqdmFyTmFtZSwgaW50IHZhck5hbWVMZW4sCisJ
CQkJSnNvbmJWYWx1ZSAqdmFsLCBKc29uYlZhbHVlICpiYXNlT2JqZWN0KQoreworCUpzb25Q
YXRoVmFyaWFibGVFdmFsQ29udGV4dCAqdmFyID0gTlVMTDsKKwlMaXN0CSAgICp2YXJzID0g
Y3h0OworCUxpc3RDZWxsICAgKmxjOworCWludAkJCWlkID0gMTsKKworCWlmICghdmFyTmFt
ZSkKKwkJcmV0dXJuIGxpc3RfbGVuZ3RoKHZhcnMpOworCisJZm9yZWFjaChsYywgdmFycykK
Kwl7CisJCXZhciA9IGxmaXJzdChsYyk7CisKKwkJaWYgKCFzdHJuY21wKHZhci0+bmFtZSwg
dmFyTmFtZSwgdmFyTmFtZUxlbikpCisJCQlicmVhazsKKworCQl2YXIgPSBOVUxMOworCQlp
ZCsrOworCX0KKworCWlmICghdmFyKQorCQlyZXR1cm4gLTE7CisKKwkvKgorCSAqIFdoZW4g
YmVsb25naW5nIHRvIGEgSnNvbkV4cHIsIHBhdGggdmFyaWFibGVzIGFyZSBjb21wdXRlZCB3
aXRoIHRoZQorCSAqIEpzb25FeHByJ3MgRXhwclN0YXRlICh2YXItPmVzdGF0ZSBpcyBOVUxM
KSwgc28gZG9uJ3QgbmVlZCB0byBiZSBjb21wdXRlZAorCSAqIGhlcmUuICBJbiBzb21lIG90
aGVyIGNhc2VzLCBzdWNoIGFzIHdoZW4gdGhlIHBhdGggdmFyaWFibGVzIGJlbG9uZ2luZwor
CSAqIHRvIGEgSnNvblRhYmxlIGluc3RlYWQsIHRob3NlIHZhcmlhYmxlcyBtdXN0IGJlIGV2
YWx1YXRlZCBvbiB0aGVpciBvd24sCisJICogd2l0aG91dCB0aGUgZW5jbG9zaW5nIEpzb25F
eHByIGl0c2VsZiBuZWVkaW5nIHRvIGJlIGV2YWx1YXRlZCwgc28gbXVzdAorCSAqIGJlIGhh
bmRsZWQgaGVyZS4KKwkgKi8KKwlpZiAodmFyLT5lc3RhdGUgJiYgIXZhci0+ZXZhbHVhdGVk
KQorCXsKKwkJTWVtb3J5Q29udGV4dCBvbGRjeHQgPSB2YXItPm1jeHQgPworCQlNZW1vcnlD
b250ZXh0U3dpdGNoVG8odmFyLT5tY3h0KSA6IE5VTEw7CisKKwkJQXNzZXJ0KHZhci0+ZWNv
bnRleHQgIT0gTlVMTCk7CisJCXZhci0+dmFsdWUgPSBFeGVjRXZhbEV4cHIodmFyLT5lc3Rh
dGUsIHZhci0+ZWNvbnRleHQsICZ2YXItPmlzbnVsbCk7CisJCXZhci0+ZXZhbHVhdGVkID0g
dHJ1ZTsKKworCQlpZiAob2xkY3h0KQorCQkJTWVtb3J5Q29udGV4dFN3aXRjaFRvKG9sZGN4
dCk7CisJfQorCWVsc2UKKwl7CisJCUFzc2VydCh2YXItPmV2YWx1YXRlZCk7CisJfQorCisJ
aWYgKHZhci0+aXNudWxsKQorCXsKKwkJdmFsLT50eXBlID0gamJ2TnVsbDsKKwkJcmV0dXJu
IDA7CisJfQorCisJSnNvbkl0ZW1Gcm9tRGF0dW0odmFyLT52YWx1ZSwgdmFyLT50eXBpZCwg
dmFyLT50eXBtb2QsIHZhbCk7CisKKwkqYmFzZU9iamVjdCA9ICp2YWw7CisJcmV0dXJuIGlk
OworfQorCiAvKgogICogR2V0IHRoZSB2YWx1ZSBvZiB2YXJpYWJsZSBwYXNzZWQgdG8ganNv
bnBhdGggZXhlY3V0b3IKICAqLwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvZXhlY3V0b3Iv
ZXhlY0V4cHIuaCBiL3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2V4ZWNFeHByLmgKaW5kZXggMTQw
NjRkZDk1MjEuLjQzMjg3NmZiMDFmIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9leGVjdXRv
ci9leGVjRXhwci5oCisrKyBiL3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2V4ZWNFeHByLmgKQEAg
LTI0NSw3ICsyNDUsMTAgQEAgdHlwZWRlZiBlbnVtIEV4cHJFdmFsT3AKIAlFRU9QX1NVQlRS
QU5TLAogCUVFT1BfSlNPTl9DT05TVFJVQ1RPUiwKIAlFRU9QX0lTX0pTT04sCi0JRUVPUF9K
U09ORVhQUiwKKwlFRU9QX0pTT05FWFBSX1NLSVAsCisJRUVPUF9KU09ORVhQUl9QQVRILAor
CUVFT1BfSlNPTkVYUFJfSU9DT0VSQ0UsCisJRUVPUF9KU09ORVhQUl9QT1BVTEFURSwKIAog
CS8qIGFnZ3JlZ2F0aW9uIHJlbGF0ZWQgbm9kZXMgKi8KIAlFRU9QX0FHR19TVFJJQ1RfREVT
RVJJQUxJWkUsCkBAIC03MDIsMTIgKzcwNSw0OCBAQCB0eXBlZGVmIHN0cnVjdCBFeHByRXZh
bFN0ZXAKIAkJCUpzb25Jc1ByZWRpY2F0ZSAqcHJlZDsJLyogb3JpZ2luYWwgZXhwcmVzc2lv
biBub2RlICovCiAJCX0JCQlpc19qc29uOwogCi0JCS8qIGZvciBFRU9QX0pTT05FWFBSICov
CisJCS8qIGZvciBFRU9QX0pTT05FWFBSX1BBVEggKi8KIAkJc3RydWN0CiAJCXsKIAkJCXN0
cnVjdCBKc29uRXhwclN0YXRlICpqc2VzdGF0ZTsKKworCQkJLyogU2VlIEV4ZWNFdmFsSnNv
bkV4cHIoKSAqLworCQkJaW50CQkJanVtcF9kb25lOworCQkJaW50CQkJanVtcF9vbmVycm9y
OworCQkJaW50CQkJanVtcF9vbmVtcHR5OworCQkJaW50CQkJanVtcF9jb2VyY2lvbjsKKwkJ
CWludAkJCWp1bXBfY29lcmNpb25fc3VidHJhbnM7CisJCQlpbnQJCQlqdW1wX2NvZXJjaW9u
X3ZpYV9pbzsKIAkJfQkJCWpzb25leHByOwogCisJCS8qIGZvciBFRU9QX0pTT05FWFBSX1NL
SVAgKi8KKwkJc3RydWN0CisJCXsKKwkJCS8qIFNhbWUgYXMganNvbmV4cHIuanNlc3RhdGUg
Ki8KKwkJCXN0cnVjdCBKc29uRXhwclN0YXRlICpqc2VzdGF0ZTsKKworCQkJLyogU2VlIEV4
ZWNFdmFsSnNvbkV4cHJTa2lwKCkgKi8KKwkJCWludAkJCWp1bXBfY29lcmNpb247CisJCX0J
CQlqc29uZXhwcl9za2lwOworCisJCS8qIGZvciBFRU9QX0pTT05FWFBSX0lPQ09FUkNFICov
CisJCXN0cnVjdAorCQl7CisJCQkvKiBJL08gaW5mbyBmb3Igb3V0cHV0IHR5cGUgKi8KKwkJ
CUZtZ3JJbmZvICAgKmZpbmZvOwkvKiB0eXBpbnB1dCBmdW5jdGlvbiBmb3Igb3V0cHV0IHR5
cGUgKi8KKwkJCU9pZAkJCXR5cGlvcGFyYW07CisJCQlpbnQzMgkJdHlwbW9kOworCQl9CQkJ
anNvbmV4cHJfaW9jb2VyY2U7CisKKwkJLyogZm9yIEVFT1BfSlNPTkVYUFJfUE9QVUxBVEUg
Ki8KKwkJc3RydWN0CisJCXsKKwkJCXN0cnVjdCBKc29uRXhwciAqanNleHByOworCisJCQkv
KiBDYWNoZSBmb3IganNvbl9wb3B1bGF0ZV90eXBlKCkgKi8KKwkJCXZvaWQJICAgKmNhY2hl
OworCQl9CQkJanNvbmV4cHJfcG9wdWxhdGU7CisKIAl9CQkJZDsKIH0gRXhwckV2YWxTdGVw
OwogCkBAIC03NjcsNjAgKzgwNiw2NyBAQCB0eXBlZGVmIHN0cnVjdCBKc29uQ29uc3RydWN0
b3JFeHByU3RhdGUKIAlpbnQJCQluYXJnczsKIH0gSnNvbkNvbnN0cnVjdG9yRXhwclN0YXRl
OwogCisvKgorICogSW5mb3JtYXRpb24gY29tcHV0ZWQgYmVmb3JlIGV2YWx1YXRpbmcgYSBK
c29uRXhwciBleHByZXNzaW9uLgorICovCit0eXBlZGVmIHN0cnVjdCBKc29uRXhwclByZUV2
YWxTdGF0ZQoreworCS8qIHZhbHVlL2lzbnVsbCBmb3IgSnNvbkV4cHIuZm9ybWF0dGVkX2V4
cHIgKi8KKwlOdWxsYWJsZURhdHVtIGZvcm1hdHRlZF9leHByOworCisJLyogdmFsdWUvaXNu
dWxsIGZvciBKc29uRXhwci5wYXRoc3BlYyAqLworCU51bGxhYmxlRGF0dW0gcGF0aHNwZWM7
CisKKwkvKiBKc29uUGF0aFZhcmlhYmxlRXZhbENvbnRleHQgZW50cmllcyBmb3IgSnNvbkV4
cHIucGFzc2luZ192YWx1ZXMgKi8KKwlMaXN0CSAgICphcmdzOworfQlKc29uRXhwclByZUV2
YWxTdGF0ZTsKKworLyoKKyAqIFN0YXRlIGZvciBldmFsdWF0aW5nIHRoZSBjb2VyY2lvbiBm
b3IgYSBnaXZlbiBKU09OIGl0ZW0gdXNpbmcgb25lIG9mCisgKiB0aGUgZm9sbG93aW5nIGNv
ZXJjaW9ucy4KKyAqCisgKiBOb3RlIHRoYXQgd2hpbGUgRXhlY0luaXRFeHByUmVjKCkgZm9y
IEpzb25JdGVtQ29lcmNpb25zIHdpbGwKKyAqIGluaXRpYWxpemUgRXhwckV2YWxTdGVwcyBm
b3IgYWxsIG9mIHRoZSBtZW1iZXJzIHRoYXQgbmVlZCBpdCwgb25seQorICogb25lIHdpbGwg
Z2V0IHJ1biBkdXJpbmcgYSBnaXZlbiBldmFsdWF0aW9uIG9mIHRoZSBlbmNsb3NpbmcgSnNv
bkV4cHIKKyAqIGRlcGVuZGluZyBvbiB0aGUgdHlwZSBvZiB0aGUgcmVzdWx0IEpTT04gaXRl
bS4KKyAqLwordHlwZWRlZiBzdHJ1Y3QgSnNvbkl0ZW1Db2VyY2lvbnNTdGVwcworeworCS8q
IE51bWJlciBvZiBFeHByRXZhbFN0ZXAgdG8gY29tcHV0ZSB0aGlzIGNvZXJjaW9uJ3MgZXhw
cmVzc2lvbiAqLworCWludAkJCW51bGw7CisJaW50CQkJc3RyaW5nOworCWludAkJCW51bWVy
aWM7CisJaW50CQkJYm9vbGVhbjsKKwlpbnQJCQlkYXRlOworCWludAkJCXRpbWU7CisJaW50
CQkJdGltZXR6OworCWludAkJCXRpbWVzdGFtcDsKKwlpbnQJCQl0aW1lc3RhbXB0ejsKKwlp
bnQJCQljb21wb3NpdGU7Cit9IEpzb25JdGVtQ29lcmNpb25zU3RlcHM7CisKIC8qIEVFT1Bf
SlNPTkVYUFIgc3RhdGUsIHRvbyBiaWcgdG8gaW5saW5lICovCiB0eXBlZGVmIHN0cnVjdCBK
c29uRXhwclN0YXRlCiB7CiAJSnNvbkV4cHIgICAqanNleHByOwkJCS8qIG9yaWdpbmFsIGV4
cHJlc3Npb24gbm9kZSAqLwogCi0Jc3RydWN0Ci0JewotCQlGbWdySW5mbwlmdW5jOwkJLyog
dHlwaW5wdXQgZnVuY3Rpb24gZm9yIG91dHB1dCB0eXBlICovCi0JCU9pZAkJCXR5cGlvcGFy
YW07Ci0JfQkJCWlucHV0OwkJCS8qIEkvTyBpbmZvIGZvciBvdXRwdXQgdHlwZSAqLwotCi0J
TnVsbGFibGVEYXR1bQotCQkJICAgKmZvcm1hdHRlZF9leHByLCAvKiBmb3JtYXR0ZWQgY29u
dGV4dCBpdGVtIHZhbHVlICovCi0JCQkgICAqcmVzX2V4cHIsCQkvKiByZXN1bHQgaXRlbSAq
LwotCQkJICAgKmNvZXJjaW9uX2V4cHIsCS8qIGlucHV0IGZvciBKU09OIGl0ZW0gY29lcmNp
b24gKi8KLQkJCSAgICpwYXRoc3BlYzsJCS8qIHBhdGggc3BlY2lmaWNhdGlvbiB2YWx1ZSAq
LworCUpzb25FeHByUHJlRXZhbFN0YXRlIHByZV9ldmFsOwogCi0JRXhwclN0YXRlICAqcmVz
dWx0X2V4cHI7CS8qIGNvZXJjZWQgdG8gb3V0cHV0IHR5cGUgKi8KLQlFeHByU3RhdGUgICpk
ZWZhdWx0X29uX2VtcHR5OwkvKiBPTiBFTVBUWSBERUZBVUxUIGV4cHJlc3Npb24gKi8KLQlF
eHByU3RhdGUgICpkZWZhdWx0X29uX2Vycm9yOwkvKiBPTiBFUlJPUiBERUZBVUxUIGV4cHJl
c3Npb24gKi8KLQlMaXN0CSAgICphcmdzOwkJCS8qIHBhc3NpbmcgYXJndW1lbnRzICovCi0K
LQl2b2lkCSAgICpjYWNoZTsJCQkvKiBjYWNoZSBmb3IganNvbl9wb3B1bGF0ZV90eXBlKCkg
Ki8KKwkvKgorCSAqIEVpdGhlciBvZiB0aGUgZm9sbG93aW5nIHR3byBpcyB1c2VkIGJ5IEV4
ZWNFdmFsSnNvbkNvZXJjaW9uKCkKKwkgKiB0byBhcHBseSBjb2VyY2lvbiB0byB0aGUgZmlu
YWwgcmVzdWx0IGlmIG5lZWRlZC4KKwkgKi8KIAogCS8qCi0JICogVGhpcyBpcyB1c2VkIG9u
bHkgaW4gSlNPTl9WQUxVRS4KLQkgKgotCSAqIFN0YXRlcyBmb3IgY29lcmNpb24gZnJvbSBT
UUwvSlNPTiBpdGVtIHR5cGVzIGRpcmVjdGx5IHRvIHRoZQotCSAqIG91dHB1dCB0eXBlLgot
CSAqCi0JICogImNvZXJjaW9ucyA9PSBOVUxMIiBtZWFucyBvdXRwdXQgdHlwZSBpcyBqc29u
W2JdIG9yIGl0cyBkb21haW4KLQkgKiBhbmQgd2UgdXNlICJyZXN1bHRfZXhwciIgZm9yIGNv
ZXJjaW9uLgorCSAqIEluIEpTT05fVkFMVUUoKSAiaXRlbV9jb2VyY2lvbnMgPT0gTlVMTCIg
bWVhbnMgdGhhdCBvdXRwdXQgdHlwZQorCSAqIGlzIGpzb25bYl0gb3IgaXRzIGRvbWFpbiBh
bmQgd2UgdXNlICJyZXN1bHRfY29lcmNpb24iLgogCSAqLwotCXN0cnVjdCBKc29uQ29lcmNp
b25zU3RhdGUKLQl7Ci0JCXN0cnVjdCBKc29uQ29lcmNpb25TdGF0ZQotCQl7Ci0JCQlKc29u
Q29lcmNpb24gKmNvZXJjaW9uOyAvKiBjb2VyY2lvbiBleHByZXNzaW9uICovCi0JCQlFeHBy
U3RhdGUgICplc3RhdGU7IC8qIGNvZXJjaW9uIGV4cHJlc3Npb24gc3RhdGUgKi8KLQkJfQkJ
CW51bGwsCi0JCQkJCXN0cmluZywKLQkJbnVtZXJpYyAgICAsCi0JCQkJCWJvb2xlYW4sCi0J
CQkJCWRhdGUsCi0JCQkJCXRpbWUsCi0JCQkJCXRpbWV0eiwKLQkJCQkJdGltZXN0YW1wLAot
CQkJCQl0aW1lc3RhbXB0eiwKLQkJCQkJY29tcG9zaXRlOwotCX0JCSAgICpjb2VyY2lvbnM7
CisJSnNvbkl0ZW1Db2VyY2lvbnNTdGVwcyAqaXRlbV9jb2VyY2lvbnM7CiB9IEpzb25FeHBy
U3RhdGU7CiAKIC8qIGZ1bmN0aW9ucyBpbiBleGVjRXhwci5jICovCiBleHRlcm4gdm9pZCBF
eHByRXZhbFB1c2hTdGVwKEV4cHJTdGF0ZSAqZXMsIGNvbnN0IEV4cHJFdmFsU3RlcCAqcyk7
CitleHRlcm4gYm9vbCBFeGVjSnNvbkV4cHJOZWVkc1N1YlRyYW5zYWN0aW9uKEpzb25FeHBy
ICpqc2V4cHIpOwogCiAvKiBmdW5jdGlvbnMgaW4gZXhlY0V4cHJJbnRlcnAuYyAqLwogZXh0
ZXJuIHZvaWQgRXhlY1JlYWR5SW50ZXJwcmV0ZWRFeHByKEV4cHJTdGF0ZSAqc3RhdGUpOwpA
QCAtODgxLDE5ICs5MjcsMTEgQEAgZXh0ZXJuIGJvb2wgRXhlY0V2YWxTdWJ0cmFucyhFeHBy
U3RhdGUgKnN0YXRlLCBFeHByRXZhbFN0ZXAgKm9wLAogCQkJCQkJCSBFeGVjRXZhbFN1YnJv
dXRpbmUgZnVuYyk7CiBleHRlcm4gdm9pZCBFeGVjRXZhbEpzb25Db25zdHJ1Y3RvcihFeHBy
U3RhdGUgKnN0YXRlLCBFeHByRXZhbFN0ZXAgKm9wLAogCQkJCQkJCQkJRXhwckNvbnRleHQg
KmVjb250ZXh0KTsKLWV4dGVybiB2b2lkIEV4ZWNFdmFsSnNvbihFeHByU3RhdGUgKnN0YXRl
LCBFeHByRXZhbFN0ZXAgKm9wLAotCQkJCQkJIEV4cHJDb250ZXh0ICplY29udGV4dCk7Ci1l
eHRlcm4gRGF0dW0gRXhlY1ByZXBhcmVKc29uSXRlbUNvZXJjaW9uKHN0cnVjdCBKc29uYlZh
bHVlICppdGVtLAotCQkJCQkJCQkJCSBKc29uUmV0dXJuaW5nICpyZXR1cm5pbmcsCi0JCQkJ
CQkJCQkJIHN0cnVjdCBKc29uQ29lcmNpb25zU3RhdGUgKmNvZXJjaW9ucywKLQkJCQkJCQkJ
CQkgc3RydWN0IEpzb25Db2VyY2lvblN0YXRlICoqcGpjc3RhdGUpOwotZXh0ZXJuIGJvb2wg
RXhlY0V2YWxKc29uTmVlZHNTdWJUcmFuc2FjdGlvbihKc29uRXhwciAqanNleHByLAotCQkJ
CQkJCQkJCQlib29sIGNvbnNpZGVyX2NvbmRpdGlvbmFsX2NvZXJjaW9ucyk7Ci1leHRlcm4g
RGF0dW0gRXhlY0V2YWxFeHByUGFzc2luZ0Nhc2VWYWx1ZShFeHByU3RhdGUgKmVzdGF0ZSwK
LQkJCQkJCQkJCQkgIEV4cHJDb250ZXh0ICplY29udGV4dCwgYm9vbCAqaXNudWxsLAotCQkJ
CQkJCQkJCSAgRGF0dW0gY2FzZXZhbF9kYXR1bSwKLQkJCQkJCQkJCQkgIGJvb2wgY2FzZXZh
bF9pc251bGwpOwotCitleHRlcm4gYm9vbCBFeGVjRXZhbEpzb25FeHByU2tpcChFeHByU3Rh
dGUgKnN0YXRlLCBFeHByRXZhbFN0ZXAgKm9wKTsKK2V4dGVybiB2b2lkIEV4ZWNFdmFsSnNv
bkV4cHJJT0NvZXJjZShFeHByU3RhdGUgKnN0YXRlLCBFeHByRXZhbFN0ZXAgKm9wKTsKK2V4
dGVybiB2b2lkIEV4ZWNFdmFsSnNvbkV4cHJQb3B1bGF0ZShFeHByU3RhdGUgKnN0YXRlLCBF
eHByRXZhbFN0ZXAgKm9wLAorCQkJCQkJCQkJIEV4cHJDb250ZXh0ICplY29udGV4dCk7Citl
eHRlcm4gaW50IEV4ZWNFdmFsSnNvbihFeHByU3RhdGUgKnN0YXRlLCBFeHByRXZhbFN0ZXAg
Km9wKTsKIGV4dGVybiB2b2lkIEV4ZWNBZ2dJbml0R3JvdXAoQWdnU3RhdGUgKmFnZ3N0YXRl
LCBBZ2dTdGF0ZVBlclRyYW5zIHBlcnRyYW5zLCBBZ2dTdGF0ZVBlckdyb3VwIHBlcmdyb3Vw
LAogCQkJCQkJCSBFeHByQ29udGV4dCAqYWdnY29udGV4dCk7CiBleHRlcm4gRGF0dW0gRXhl
Y0FnZ1RyYW5zUmVwYXJlbnQoQWdnU3RhdGUgKmFnZ3N0YXRlLCBBZ2dTdGF0ZVBlclRyYW5z
IHBlcnRyYW5zLApkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvbm9kZXMvcHJpbW5vZGVzLmgg
Yi9zcmMvaW5jbHVkZS9ub2Rlcy9wcmltbm9kZXMuaAppbmRleCAzYWE5NmJiNjg1NS4uNmFm
YjQyMjg3MzAgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL25vZGVzL3ByaW1ub2Rlcy5oCisr
KyBiL3NyYy9pbmNsdWRlL25vZGVzL3ByaW1ub2Rlcy5oCkBAIC0xNTY2LDggKzE1NjYsMTEg
QEAgdHlwZWRlZiBzdHJ1Y3QgSnNvbkNvZXJjaW9uCiAKIC8qCiAgKiBKc29uSXRlbUNvZXJj
aW9ucyAtCi0gKgkJZXhwcmVzc2lvbnMgZm9yIGNvZXJjaW9uIGZyb20gU1FML0pTT04gaXRl
bSB0eXBlcyBkaXJlY3RseSB0byB0aGUKLSAqCQlvdXRwdXQgU1FMIHR5cGUKKyAqCQlleHBy
ZXNzaW9ucyBmb3IgY29lcmNpb24gZnJvbSBTUUwvSlNPTiBpdGVtIHR5cGVzIGRpcmVjdGx5
IHRvCisgKgkJdGhlIG91dHB1dCBTUUwgdHlwZS4KKyAqCisgKgkJIkpzb25Db2VyY2lvbiA9
PSBOVUxMIiBtZWFucyBubyBjYXN0IGlzIGF2YWlsYWJsZS4KKyAqIAkJIkpzb25Db2VyY2lv
bi5leHByID09IE5VTEwiIG1lYW5zIG5vIGNvZXJjaW9uIGlzIG5lZWRlZC4KICAqLwogdHlw
ZWRlZiBzdHJ1Y3QgSnNvbkl0ZW1Db2VyY2lvbnMKIHsKQEAgLTE1ODEsNyArMTU4NCw3IEBA
IHR5cGVkZWYgc3RydWN0IEpzb25JdGVtQ29lcmNpb25zCiAJSnNvbkNvZXJjaW9uICp0aW1l
dHo7CiAJSnNvbkNvZXJjaW9uICp0aW1lc3RhbXA7CiAJSnNvbkNvZXJjaW9uICp0aW1lc3Rh
bXB0ejsKLQlKc29uQ29lcmNpb24gKmNvbXBvc2l0ZTsJLyogYXJyYXlzIGFuZCBvYmplY3Rz
ICovCisJSnNvbkNvZXJjaW9uICpjb21wb3NpdGU7CiB9IEpzb25JdGVtQ29lcmNpb25zOwog
CiAvKgpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvdXRpbHMvanNvbmIuaCBiL3NyYy9pbmNs
dWRlL3V0aWxzL2pzb25iLmgKaW5kZXggYmFlNDY2YjUyMzQuLjZiZGQ5ZjUxMjE5IDEwMDY0
NAotLS0gYS9zcmMvaW5jbHVkZS91dGlscy9qc29uYi5oCisrKyBiL3NyYy9pbmNsdWRlL3V0
aWxzL2pzb25iLmgKQEAgLTY5LDggKzY5LDEwIEBAIHR5cGVkZWYgZW51bQogCiAvKiBDb252
ZW5pZW5jZSBtYWNyb3MgKi8KICNkZWZpbmUgRGF0dW1HZXRKc29uYlAoZCkJKChKc29uYiAq
KSBQR19ERVRPQVNUX0RBVFVNKGQpKQorI2RlZmluZSBEYXR1bUdldEpzb25iVmFsdWVQKGQp
CSgoSnNvbmJWYWx1ZSAqKSBEYXR1bUdldFBvaW50ZXIoZCkpCiAjZGVmaW5lIERhdHVtR2V0
SnNvbmJQQ29weShkKQkoKEpzb25iICopIFBHX0RFVE9BU1RfREFUVU1fQ09QWShkKSkKICNk
ZWZpbmUgSnNvbmJQR2V0RGF0dW0ocCkJUG9pbnRlckdldERhdHVtKHApCisjZGVmaW5lIEpz
b25iVmFsdWVQR2V0RGF0dW0ocCkJUG9pbnRlckdldERhdHVtKHApCiAjZGVmaW5lIFBHX0dF
VEFSR19KU09OQl9QKHgpCURhdHVtR2V0SnNvbmJQKFBHX0dFVEFSR19EQVRVTSh4KSkKICNk
ZWZpbmUgUEdfR0VUQVJHX0pTT05CX1BfQ09QWSh4KQlEYXR1bUdldEpzb25iUENvcHkoUEdf
R0VUQVJHX0RBVFVNKHgpKQogI2RlZmluZSBQR19SRVRVUk5fSlNPTkJfUCh4KQlQR19SRVRV
Uk5fUE9JTlRFUih4KQpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvdXRpbHMvanNvbnBhdGgu
aCBiL3NyYy9pbmNsdWRlL3V0aWxzL2pzb25wYXRoLmgKaW5kZXggOGU3OWI4ZGM5ZjAuLmZh
MWQzZWFlNmNmIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS91dGlscy9qc29ucGF0aC5oCisr
KyBiL3NyYy9pbmNsdWRlL3V0aWxzL2pzb25wYXRoLmgKQEAgLTI4MCw5ICsyODAsNiBAQCBl
eHRlcm4gRGF0dW0gSnNvblBhdGhRdWVyeShEYXR1bSBqYiwgSnNvblBhdGggKmpwLCBKc29u
V3JhcHBlciB3cmFwcGVyLAogZXh0ZXJuIEpzb25iVmFsdWUgKkpzb25QYXRoVmFsdWUoRGF0
dW0gamIsIEpzb25QYXRoICpqcCwgYm9vbCAqZW1wdHksCiAJCQkJCQkJCSBib29sICplcnJv
ciwgTGlzdCAqdmFycyk7CiAKLWV4dGVybiBpbnQJRXZhbEpzb25QYXRoVmFyKHZvaWQgKnZh
cnMsIGNoYXIgKnZhck5hbWUsIGludCB2YXJOYW1lTGVuLAotCQkJCQkJCUpzb25iVmFsdWUg
KnZhbCwgSnNvbmJWYWx1ZSAqYmFzZU9iamVjdCk7Ci0KIGV4dGVybiBQR0RMTElNUE9SVCBj
b25zdCBUYWJsZUZ1bmNSb3V0aW5lIEpzb25iVGFibGVSb3V0aW5lOwogCiAjZW5kaWYKZGlm
ZiAtLWdpdCBhL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvanNvbmJfc3FsanNvbi5vdXQg
Yi9zcmMvdGVzdC9yZWdyZXNzL2V4cGVjdGVkL2pzb25iX3NxbGpzb24ub3V0CmluZGV4IGVl
NWU1OTc5MDljLi5jODRmYjAzZGYzNyAxMDA2NDQKLS0tIGEvc3JjL3Rlc3QvcmVncmVzcy9l
eHBlY3RlZC9qc29uYl9zcWxqc29uLm91dAorKysgYi9zcmMvdGVzdC9yZWdyZXNzL2V4cGVj
dGVkL2pzb25iX3NxbGpzb24ub3V0CkBAIC02OTMsNiArNjkzLDE3IEBAIFNFTEVDVCBKU09O
X1ZBTFVFKGpzb25iICdudWxsJywgJyR0cycgUEFTU0lORyB0aW1lc3RhbXB0eiAnMjAxOC0w
Mi0yMSAxMjozNDo1NiArCiAgIjIwMTgtMDItMjFUMDI6MzQ6NTYrMDA6MDAiCiAoMSByb3cp
CiAKKy0tIHRlc3QgZXJyb3JzIGluIERFRkFVTFQgT04gRU1QVFkgZXhwcmVzc2lvbnMKK1NF
TEVDVCBKU09OX1ZBTFVFKCcxJzo6anNvbmIsICckLngnIFJFVFVSTklORyBpbnQKKyAgICAg
ICAgICAgICAgICAgIERFRkFVTFQgMSAvIHggT04gRU1QVFkKKyAgICAgICAgICAgICAgICAg
IERFRkFVTFQgMiBPTiBFUlJPUikKK0ZST00gKFZBTFVFUyAoMTo6aW50KSwgKDApKSB4KHgp
OworIGpzb25fdmFsdWUgCistLS0tLS0tLS0tLS0KKyAgICAgICAgICAxCisgICAgICAgICAg
MgorKDIgcm93cykKKwogLS0gSlNPTl9RVUVSWQogU0VMRUNUCiAJSlNPTl9RVUVSWShqcywg
JyQnKSwKQEAgLTc5NCw2ICs4MDUsMTIgQEAgU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJyJh
YWEiJywgJyQnIFJFVFVSTklORyBieXRlYSBGT1JNQVQgSlNPTiBPTUlUIFFVT1RFUyBFUlIK
ICBceDYxNjE2MQogKDEgcm93KQogCitTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnImFhYSIn
LCAnJCcgUkVUVVJOSU5HIGpzb24gT01JVCBRVU9URVMgRU1QVFkgQVJSQVkgT04gRVJST1Ip
OworIGpzb25fcXVlcnkgCistLS0tLS0tLS0tLS0KKyBbXQorKDEgcm93KQorCiAtLSBRVU9U
RVMgYmVoYXZpb3Igc2hvdWxkIG5vdCBiZSBzcGVjaWZpZWQgd2hlbiBXSVRIIFdSQVBQRVIg
dXNlZDoKIC0tIFNob3VsZCBmYWlsCiBTRUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnWzFdJywg
JyQnIFdJVEggV1JBUFBFUiBPTUlUIFFVT1RFUyk7CmRpZmYgLS1naXQgYS9zcmMvdGVzdC9y
ZWdyZXNzL3NxbC9qc29uYl9zcWxqc29uLnNxbCBiL3NyYy90ZXN0L3JlZ3Jlc3Mvc3FsL2pz
b25iX3NxbGpzb24uc3FsCmluZGV4IGQ3MDEwNGI3MGVmLi5lZWQxNjNlNzA4OSAxMDA2NDQK
LS0tIGEvc3JjL3Rlc3QvcmVncmVzcy9zcWwvanNvbmJfc3FsanNvbi5zcWwKKysrIGIvc3Jj
L3Rlc3QvcmVncmVzcy9zcWwvanNvbmJfc3FsanNvbi5zcWwKQEAgLTE5NCw2ICsxOTQsMTIg
QEAgU0VMRUNUIEpTT05fVkFMVUUoanNvbmIgJ251bGwnLCAnJHRzJyBQQVNTSU5HIHRpbWVz
dGFtcHR6ICcyMDE4LTAyLTIxIDEyOjM0OjU2ICsKIFNFTEVDVCBKU09OX1ZBTFVFKGpzb25i
ICdudWxsJywgJyR0cycgUEFTU0lORyB0aW1lc3RhbXB0eiAnMjAxOC0wMi0yMSAxMjozNDo1
NiArMTAnIEFTIHRzIFJFVFVSTklORyBqc29uKTsKIFNFTEVDVCBKU09OX1ZBTFVFKGpzb25i
ICdudWxsJywgJyR0cycgUEFTU0lORyB0aW1lc3RhbXB0eiAnMjAxOC0wMi0yMSAxMjozNDo1
NiArMTAnIEFTIHRzIFJFVFVSTklORyBqc29uYik7CiAKKy0tIHRlc3QgZXJyb3JzIGluIERF
RkFVTFQgT04gRU1QVFkgZXhwcmVzc2lvbnMKK1NFTEVDVCBKU09OX1ZBTFVFKCcxJzo6anNv
bmIsICckLngnIFJFVFVSTklORyBpbnQKKyAgICAgICAgICAgICAgICAgIERFRkFVTFQgMSAv
IHggT04gRU1QVFkKKyAgICAgICAgICAgICAgICAgIERFRkFVTFQgMiBPTiBFUlJPUikKK0ZS
T00gKFZBTFVFUyAoMTo6aW50KSwgKDApKSB4KHgpOworCiAtLSBKU09OX1FVRVJZCiAKIFNF
TEVDVApAQCAtMjM5LDYgKzI0NSw3IEBAIFNFTEVDVCBKU09OX1FVRVJZKGpzb25iICciYWFh
IicsICckJyBSRVRVUk5JTkcgdGV4dCBPTUlUIFFVT1RFUyBPTiBTQ0FMQVIgU1RSSU5HCiBT
RUxFQ1QgSlNPTl9RVUVSWShqc29uYiAnImFhYSInLCAnJCcgT01JVCBRVU9URVMgRVJST1Ig
T04gRVJST1IpOwogU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJyJhYWEiJywgJyQnIFJFVFVS
TklORyBqc29uIE9NSVQgUVVPVEVTIEVSUk9SIE9OIEVSUk9SKTsKIFNFTEVDVCBKU09OX1FV
RVJZKGpzb25iICciYWFhIicsICckJyBSRVRVUk5JTkcgYnl0ZWEgRk9STUFUIEpTT04gT01J
VCBRVU9URVMgRVJST1IgT04gRVJST1IpOworU0VMRUNUIEpTT05fUVVFUlkoanNvbmIgJyJh
YWEiJywgJyQnIFJFVFVSTklORyBqc29uIE9NSVQgUVVPVEVTIEVNUFRZIEFSUkFZIE9OIEVS
Uk9SKTsKIAogLS0gUVVPVEVTIGJlaGF2aW9yIHNob3VsZCBub3QgYmUgc3BlY2lmaWVkIHdo
ZW4gV0lUSCBXUkFQUEVSIHVzZWQ6CiAtLSBTaG91bGQgZmFpbAotLSAKMi4yNS4xCgo=

--------------2fGzZEmgSOPtun574i5o0ymG--