MIME-Version: 1.0
References: 
 <CA+HiwqF4C0ws3cO+z5cLkPuvwnAwkSp7sfvgGj3yQ=Li6KNMqA@mail.gmail.com>
 <CA+HiwqGM6nvAV5O+=Nr+BXMPWOma0oeCRVzVP0XiLE8zX5TVAg@mail.gmail.com>
 <CA+HiwqGMaovCUgDbGxVGnK0Mrivr+ph3YE2Ws+47-ugyPb4f7g@mail.gmail.com>
 <CAFj8pRDaiBe_GOLk_yyYHTtPiDAAaLOM8u1-=Q3ZgXBTH+1igg@mail.gmail.com>
 <CA+HiwqGA5Ay_MR0eJEEbt4j6WrVh4F+AasTp8yCbs5aJLOJn6Q@mail.gmail.com>
 <CAEG8a3JM=NoqiTK0V6S9FNxZPvy1+C5F7rfafTtPKBVWnunL-g@mail.gmail.com>
 <CA+HiwqEyiLCY6MTLbOJXDdLNNQLaURYHvdW797MQgbjEK9od4Q@mail.gmail.com>
 <CAEG8a3+VBpwPf1Rm-ECD90whM9b3YnGhux5CVXdsL6khiBfzRQ@mail.gmail.com>
 <CA+HiwqF2UHzF0sKCp-F2a-U29rqh_9ZPy=f1h+Fh_=M8efj3pg@mail.gmail.com>
 <CAEG8a3L9Ew-WL8sxLROVOcypeaENPmd8qCmMvz4geoGL1TDGCA@mail.gmail.com>
 <CAEG8a3+nUFQo4sdPQF9xy0J73J8RFJ5U9A5+_kMosGDaZ+1sXA@mail.gmail.com>
 <2BE661BA-D909-4093-BF78-DB9B0C099337@gmail.com>
 <CAEG8a3JyKdizWvYsF+z_mA1BKy=dpW11iKVMOG=bk6Tbz6M1Bw@mail.gmail.com>
In-Reply-To: 
 <CAEG8a3JyKdizWvYsF+z_mA1BKy=dpW11iKVMOG=bk6Tbz6M1Bw@mail.gmail.com>
From: Junwang Zhao <zhjwpku@gmail.com>
Date: Fri, 20 Mar 2026 00:19:53 +0800
Message-ID: 
 <CAEG8a3+Hf4tvvbts29_k_AFhWQmRYfEo_SW4C5FY_140iKghBw@mail.gmail.com>
Subject: Re: Eliminating SPI / SQL from some RI triggers - take 3
To: Haibo Yan <tristan.yim@gmail.com>
Cc: amitlangote09@gmail.com, Pavel Stehule <pavel.stehule@gmail.com>,
	PostgreSQL-development <pgsql-hackers@postgresql.org>
Content-Type: multipart/mixed; boundary="000000000000130115064d62f122"
Archived-At: 
 <https://www.postgresql.org/message-id/CAEG8a3%2BHf4tvvbts29_k_AFhWQmRYfEo_SW4C5FY_140iKghBw%40mail.gmail.com>
Precedence: bulk

--000000000000130115064d62f122
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

On Wed, Mar 18, 2026 at 11:34=E2=80=AFPM Junwang Zhao <zhjwpku@gmail.com> w=
rote:
>
> Hi Haibo,
>
> On Tue, Mar 17, 2026 at 8:28=E2=80=AFAM Haibo Yan <tristan.yim@gmail.com>=
 wrote:
> >
> > Hi, Amit and Junwang
> >
> > Thanks for the latest patch. I think the overall direction makes sense,=
 and the single-column SK_SEARCHARRAY path looks like one of the most valua=
ble optimizations here. The patch also seems to cover several important cas=
es, including deferred constraints, duplicate FK values, and multi-column f=
allback behavior.
> >
> > After reading through the patch, I have one major comments and a few sm=
aller ones.
>
> Thanks for your review.
>
> >
> > 1. TopTransactionContext usage during batched flush may be too coarse-g=
rained
> > My biggest concern is the use of TopTransactionContext around the batch=
ed flush path.
> > As written, ri_FastPathBatchFlush() switches to TopTransactionContext b=
efore calling ri_FastPathFlushArray() / ri_FastPathFlushLoop(). That seems =
broad enough that temporary allocations made during the flush may end up th=
ere.
> > In particular, in ri_FastPathFlushArray(), I think the objects worth ch=
ecking carefully are the pass-by-reference Datums returned by the per-eleme=
nt cast call and stored in search_vals[], e.g.
> >
> > ```search_vals[i] =3D FunctionCall3(&entry->cast_func_finfo, ...);```
> > If those cast results are separately allocated in the current memory co=
ntext, then pfree(arr) only frees the constructed array object itself; it d=
oes not obviously free those intermediate cast results. If so, those alloca=
tions could survive until end of transaction rather than just until the end=
 of the current flush.
> > Maybe this is harmless in practice, but I think it needs a closer look.=
 It might be better to use a dedicated short-lived context for per-flush te=
mporary allocations, reset it after each flush, or otherwise separate alloc=
ations that really need transaction lifetime from those that are only neede=
d transiently during batched processing.
>
> Yeah, that concern is reasonable. After a brief discussion with Amit,
> we now replace the TopTransactionContext usage with two
> purpose-specific contexts, scan_cxt for index AM allocations, freed
> at teardown, and flush_cxt for per-flush transient work, reset each flush=
,
> TopTransactionContext is parent of scan_cxt, and scan_cxt is parent
> of flush_cxt, so MemoryContextDelete(scan_cxt) in teardown cleans up
> both.
>
> These changes are in v7-0004.
>
> >
> > 2. RI_FastPathEntry comment mentions the wrong function name
> > The comment above RI_FastPathEntry says it contains resources needed by=
 ri_FastPathFlushBatch(), but the function is named ri_FastPathBatchFlush()=
.
>
> Fixed.
>
> >
> > 3. RI_FASTPATH_BATCH_SIZE needs some rationale
> > RI_FASTPATH_BATCH_SIZE =3D 64 may well be a reasonable compromise, but =
right now it reads like a magic number.
> > This choice seems especially relevant because the patch has two opposin=
g effects:
> > 3-1. larger batches should amortize the array-scan work better,
> > 3-2. but the matched[] bookkeeping in ri_FastPathFlushArray() is O(batc=
h_size^2) in the worst case.
> > So I think it would help to include at least a brief rationale in a com=
ment or in the commit message.
>
> Added.
>
> >
> > 4. Commit message says the entry stashes fk_relid, but the code actuall=
y stashes riinfo
> > The commit message says the entry stashes fk_relid and can reopen the r=
elation if needed. Unless I am misreading it, the code actually stores riin=
fo and later uses riinfo->fk_relid. The distinction is small, but I think t=
he wording should match the implementation more closely.
>
> I changed the commit message to:
>
> Since the FK relation may already be closed by flush time (e.g. for
> deferred constraints at COMMIT), reopens the relation using
> entry->riinfo->fk_relid if needed.
>
> >
> > Thanks again for working on this.
> >
> > Best regards,
> >
> > Haibo Yan
> >
> >
> > On Mar 10, 2026, at 5:28=E2=80=AFAM, Junwang Zhao <zhjwpku@gmail.com> w=
rote:
> >
> > Hi,
> >
> > On Mon, Mar 2, 2026 at 11:30=E2=80=AFPM Junwang Zhao <zhjwpku@gmail.com=
> wrote:
> >
> >
> > On Sat, Feb 28, 2026 at 3:08=E2=80=AFPM Amit Langote <amitlangote09@gma=
il.com> wrote:
> >
> >
> > Hi Junwang,
> >
> > On Mon, Feb 23, 2026 at 10:45=E2=80=AFPM Junwang Zhao <zhjwpku@gmail.co=
m> wrote:
> >
> > On Thu, Feb 19, 2026 at 5:21=E2=80=AFPM Amit Langote <amitlangote09@gma=
il.com> wrote:
> >
> > I re-ran the benchmarks (same test as yours, different machine):
> >
> > create table pk (a numeric primary key);
> > create table fk (a bigint references pk);
> > insert into pk select generate_series(1, 2000000);
> > insert into fk select generate_series(1, 2000000, 2);
> >
> > master: 2444 ms  (median of 3 runs)
> > 0001: 1382 ms  (43% faster)
> > 0001+0002: 1202 ms  (51% faster, 13% over 0001 alone)
> >
> >
> > I can get similar improvement on my old mac intel chip:
> >
> > master: 12963.993 ms
> > 0001: 6641.692 ms, 48.8% faster
> > 0001+0002: 5771.703 ms, 55.5% faster
> >
> >
> > Also, with int PK / int FK (1M rows):
> >
> > create table pk (a int primary key);
> > create table fk (a int references pk);
> > insert into pk select generate_series(1, 1000000);
> > insert into fk select generate_series(1, 1000000);
> >
> > master: 1000 ms
> > 0001: 520 ms  (48% faster)
> > 0001+0002: 432 ms  (57% faster, 17% over 0001 alone)
> >
> >
> > master: 11134.583 ms
> > 0001: 5240.298 ms, 52.9% faster
> > 0001+0002: 4554.215 ms, 59.1% faster
> >
> >
> > Thanks for testing, good to see similar numbers.  I had forgotten to
> > note that these results are when these PK index probes don't do any
> > I/O, though you might be aware of that. Below, I report some numbers
> > that Tomas Vondra shared with me off-list where the probes do have to
> > perform I/O and there the benefits from only this patch set are only
> > marginal.
> >
> > I don't have any additional comments on the patch except one minor nit,
> > maybe merge the following two if conditions into one, not a strong opin=
ion
> > though.
> >
> > if (use_cache)
> > {
> > /*
> > * The snapshot was registered once when the cache entry was created.
> > * We just patch curcid to reflect the new command counter.
> > * SnapshotSetCommandId() only patches process-global statics, not
> > * registered copies, so we do it directly.
> > *
> > * The xmin/xmax/xip fields don't need refreshing: within a single
> > * statement batch, only curcid changes between rows.
> > */
> > Assert(fpentry && fpentry->snapshot !=3D NULL);
> > snapshot =3D fpentry->snapshot;
> > snapshot->curcid =3D GetCurrentCommandId(false);
> > }
> > else
> > snapshot =3D RegisterSnapshot(GetLatestSnapshot());
> >
> > if (use_cache)
> > {
> > pk_rel =3D fpentry->pk_rel;
> > idx_rel =3D fpentry->idx_rel;
> > scandesc =3D fpentry->scandesc;
> > slot =3D fpentry->slot;
> > }
> > else
> > {
> > pk_rel =3D table_open(riinfo->pk_relid, RowShareLock);
> > idx_rel =3D index_open(riinfo->conindid, AccessShareLock);
> > scandesc =3D index_beginscan(pk_rel, idx_rel,
> > snapshot, NULL,
> > riinfo->nkeys, 0);
> > slot =3D table_slot_create(pk_rel, NULL);
> > }
> >
> >
> > Good idea, done.
> >
> > While polishing 0002, I revisited the snapshot caching semantics. The
> > previous commit message hand-waved about only curcid changing between
> > rows, but GetLatestSnapshot() also reflects other backends' commits,
> > so reusing the snapshot is a deliberate semantic change from the SPI
> > path. I think it's safe because curcid is all we need for
> > intra-statement visibility, concurrent commits either already happened
> > before our snapshot (and are visible) or are racing with our statement
> > and wouldn't be seen reliably even with per-row snapshots since the
> > order in which FK rows are checked is nondeterministic, and
> > LockTupleKeyShare prevents the PK row from disappearing regardless. In
> > essence, we're treating all the FK checks within a trigger-firing
> > cycle as a single plan execution that happens to scan N rows, rather
> > than N independent SPI queries each taking a fresh snapshot. That's
> > the natural model -- a normal SELECT ... FOR KEY SHARE plan doesn't
> > re-take GetLatestSnapshot() between rows either.
> >
> > Similarly, the permission check (schema USAGE + table SELECT) is now
> > done once at cache entry creation in ri_FastPathGetEntry() rather than
> > on every flush.
> >
> >
> > nice improvement.
> >
> > The RI check runs as the PK table owner, so we're
> > verifying that the owner can access their own table -- a condition
> > that won't change unless someone explicitly revokes from the owner,
> > which would also break the SPI path.
> >
> > David Rowley mentioned off-list that it might be worth batching
> > multiple FK values into a single index probe, leveraging the
> > ScalarArrayOp btree improvements from PostgreSQL 17. The idea would be
> > to buffer FK values across trigger invocations in the per-constraint
> > cache (0002 already has the right structure for this), build a
> > SK_SEARCHARRAY scan key, and let the btree AM walk the matching leaf
> > pages in one sorted traversal instead of one tree descent per row. The
> > locking and recheck would still be per-tuple, but the index traversal
> > cost drops significantly. Single-column FKs are the obvious starting
> > point. That seems worth exploring but can be done as a separate patch
> > on top of this.
> >
> >
> > I will take a look at this in the following weeks.
> >
> >
> > I ended up going ahead with the batching and SAOP idea that David
> > mentioned -- I had a proof-of-concept working shortly after posting v3
> > and kept iterating on it.  So attached set is now:
> >
> > 0001 - Core fast path (your 0001+0002 reworked, as before)
> >
> > 0002 - Per-batch resource caching (PK relation, index, scandesc, snapsh=
ot)
> >
> > 0003 - FK row buffering: materialize FK tuples into a per-constraint
> > batch buffer (64 rows), flush when full or at batch end
> >
> > 0004 - SK_SEARCHARRAY for single-column FKs: build an array from the
> > buffered FK values and do one index scan instead of 64 separate tree
> > descents.  Multi-column FKs fall back to a per-row loop.
> >
> > 0003 is pure infrastructure -- it doesn't improve performance on its
> > own because the per-row index descent still dominates.  The payoff
> > comes in 0004.
> >
> > Numbers (same machine as before, median of 3 runs):
> >
> > numeric PK / bigint FK, 1M rows:
> > master: 2487 ms
> > 0001..0004: 1168 ms  (2.1x)
> >
> > int PK / int FK, 500K rows:
> > master: 1043 ms
> > 0001..0004: 335 ms  (3.1x)
> >
> > The int/int case benefits most because the per-row cost is lower, so
> > the SAOP traversal savings are a larger fraction of the total. The
> > numeric/bigint case still sees a solid improvement despite the
> > cross-type cast overhead.
> >
> > Tomas Vondra also tested with an I/O-intensive workload (dataset
> > larger than shared_buffers, combined with his and Peter Geoghegan's
> > I/O prefetching patches) and confirmed that the batching + SAOP
> > approach helps there too, not just in the CPU-bound / memory-resident
> > case.  In fact he showed that the patches here don't make a big dent
> > when the main bottleneck is I/O as shown in numbers that he shared in
> > an off-list email:
> >
> > master: 161617 ms
> > ri-check (0001..0004): 149446 ms  (1.08x)
> > ri-check + i/o prefetching: 50885 ms  (3.2x)
> >
> > So the RI patches alone only give ~8% here since most time is waiting
> > on reads.  But the batching gives the prefetch machinery a window of
> > upcoming probes to issue readahead against, so the two together yield
> > 3.2x.
> >
> >
> > impressive!
> >
> >
> > Tomas also caught a memory context bug in the batch flush path: the
> > cached scandesc lives in TopTransactionContext, but the btree AM
> > defers _bt_preprocess_keys allocation to the first getnext call, which
> > pallocs into CurrentMemoryContext. If that's a short-lived
> > per-trigger-row context, the scandesc has dangling pointers on the
> > next rescan. Fixed by switching to TopTransactionContext before the
> > probe loop.
> >
> > Finally, I've fixed a number of other small and not-so-small bugs
> > found while polishing the old patches and made other stylistic
> > improvements. One notable change is that I introduced a FastPathMeta
> >
> >
> > Yeah, this is much better than the fpmeta_valid field.
> >
> > struct to store the fast path metadata instead of dumping those arrays
> > in the RI_ConstraintInfo. It's allocated lazily on first use and holds
> > the per-key compare entries, operator procedures, and index strategy
> > info needed by the scan key construction, so RI_ConstraintInfo doesn't
> > pay for them when the fast path isn't used.
> >
> >
> > On Mon, Feb 23, 2026 at 10:45=E2=80=AFPM Junwang Zhao <zhjwpku@gmail.co=
m> wrote:
> >
> >
> > Hi Amit,
> >
> > On Thu, Feb 19, 2026 at 5:21=E2=80=AFPM Amit Langote <amitlangote09@gma=
il.com> wrote:
> >
> >
> > Hi Junwang,
> >
> > On Mon, Dec 1, 2025 at 3:09=E2=80=AFPM Junwang Zhao <zhjwpku@gmail.com>=
 wrote:
> >
> > As Amit has already stated, we are approaching a hybrid "fast-path + fa=
llback"
> > design.
> >
> > 0001 adds a fast path optimization for foreign key constraint checks
> > that bypasses the SPI executor, the fast path applies when the referenc=
ed
> > table is not partitioned, and the constraint does not involve temporal
> > semantics.
> >
> > With the following test:
> >
> > create table pk (a numeric primary key);
> > create table fk (a bigint references pk);
> > insert into pk select generate_series(1, 2000000);
> >
> > head:
> >
> > [local] zhjwpku@postgres:5432-90419=3D# insert into fk select
> > generate_series(1, 2000000, 2);
> > INSERT 0 1000000
> > Time: 13516.177 ms (00:13.516)
> >
> > [local] zhjwpku@postgres:5432-90419=3D# update fk set a =3D a + 1;
> > UPDATE 1000000
> > Time: 15057.638 ms (00:15.058)
> >
> > patched:
> >
> > [local] zhjwpku@postgres:5432-98673=3D# insert into fk select
> > generate_series(1, 2000000, 2);
> > INSERT 0 1000000
> > Time: 8248.777 ms (00:08.249)
> >
> > [local] zhjwpku@postgres:5432-98673=3D# update fk set a =3D a + 1;
> > UPDATE 1000000
> > Time: 10117.002 ms (00:10.117)
> >
> > 0002 cache fast-path metadata used by the index probe, at the current
> > time only comparison operator hash entries, operator function OIDs
> > and strategy numbers and subtypes for index scans. But this cache
> > doesn't buy any performance improvement.
> >
> > Caching additional metadata should improve performance for foreign key =
checks.
> >
> > Amit suggested introducing a mechanism for ri_triggers.c to register a
> > cleanup callback in the EState, which AfterTriggerEndQuery() could then
> > invoke to release per-statement cached metadata (such as the IndexScanD=
esc).
> > However, I haven't been able to implement this mechanism yet.
> >
> >
> > Thanks for working on this.  I've taken your patches as a starting
> > point and reworked the series into two patches (attached): 1st is your
> > 0001+0002 as the core patch that adds a gated fast-path alternative to
> > SPI and 2nd where I added per-statement resource caching.  Doing the
> > latter turned out to be not so hard thanks to the structure you chose
> > to build the core fast path.  Good call on adding the RLS and ACL test
> > cases, btw.
> >
> > So, 0001 is a functionally complete fast path: concurrency handling,
> > REPEATABLE READ crosscheck, cross-type operators, security context,
> > and metadata caching. 0002 implements the per-statement resource
> > caching we discussed, though instead of sharing the EState between
> > trigger.c and ri_triggers.c it uses a new AfterTriggerBatchCallback
> > mechanism that fires at the end of each trigger-firing cycle
> > (per-statement for immediate constraints, or until COMMIT for deferred
> > ones). It layers resource caching on top so that the PK relation,
> > index, scan descriptor, and snapshot stay open across all FK trigger
> > invocations within a single trigger-firing cycle rather than being
> > opened and closed per row.
> >
> > Note that phe previous 0002 (metadata caching) is folded into 0001,
> > and most of the new fast-path logic added in 0001 now lives in
> > ri_FastPathCheck() rather than inline in RI_FKey_check(), so the
> > RI_FKey_check diff is just the gating call and SPI fallback.
> >
> > I re-ran the benchmarks (same test as yours, different machine):
> >
> > create table pk (a numeric primary key);
> > create table fk (a bigint references pk);
> > insert into pk select generate_series(1, 2000000);
> > insert into fk select generate_series(1, 2000000, 2);
> >
> > master: 2444 ms  (median of 3 runs)
> > 0001: 1382 ms  (43% faster)
> > 0001+0002: 1202 ms  (51% faster, 13% over 0001 alone)
> >
> >
> > I can get similar improvement on my old mac intel chip:
> >
> > master: 12963.993 ms
> > 0001: 6641.692 ms, 48.8% faster
> > 0001+0002: 5771.703 ms, 55.5% faster
> >
> >
> > Also, with int PK / int FK (1M rows):
> >
> > create table pk (a int primary key);
> > create table fk (a int references pk);
> > insert into pk select generate_series(1, 1000000);
> > insert into fk select generate_series(1, 1000000);
> >
> > master: 1000 ms
> > 0001: 520 ms  (48% faster)
> > 0001+0002: 432 ms  (57% faster, 17% over 0001 alone)
> >
> >
> > master: 11134.583 ms
> > 0001: 5240.298 ms, 52.9% faster
> > 0001+0002: 4554.215 ms, 59.1% faster
> >
> >
> > The incremental gain from 0002 comes from eliminating per-row relation
> > open/close, scan begin/end, slot alloc/free, and replacing per-row
> > GetSnapshotData() with only curcid adjustment on the registered
> > snapshot copy in the cache.
> >
> > The two current limitations are partitioned referenced tables and
> > temporal foreign keys. Partitioned PKs are relatively uncommon in
> > practice, so the non-partitioned case should cover most FK workloads,
> > so I'm not sure it's worth the added complexity to support them.
> > Temporal FKs are inherently multi-row, so they're a poor fit for a
> > single-probe fast path.
> >
> > David Rowley mentioned off-list that it might be worth batching
> > multiple FK values into a single index probe, leveraging the
> > ScalarArrayOp btree improvements from PostgreSQL 17. The idea would be
> > to buffer FK values across trigger invocations in the per-constraint
> > cache (0002 already has the right structure for this), build a
> > SK_SEARCHARRAY scan key, and let the btree AM walk the matching leaf
> > pages in one sorted traversal instead of one tree descent per row. The
> > locking and recheck would still be per-tuple, but the index traversal
> > cost drops significantly. Single-column FKs are the obvious starting
> > point. That seems worth exploring but can be done as a separate patch
> > on top of this.
> >
> >
> > I will take a look at this in the following weeks.
> >
> >
> > I think the series is in reasonable shape but would appreciate extra
> > eyeballs, especially on the concurrency handling in ri_LockPKTuple()
> > in 0001 and the snapshot lifecycle in 0002. Or anything else that
> > catches one's eye.
> >
> > --
> > Thanks, Amit Langote
> >
> >
> > I don't have any additional comments on the patch except one minor nit,
> > maybe merge the following two if conditions into one, not a strong opin=
ion
> > though.
> >
> > if (use_cache)
> > {
> > /*
> > * The snapshot was registered once when the cache entry was created.
> > * We just patch curcid to reflect the new command counter.
> > * SnapshotSetCommandId() only patches process-global statics, not
> > * registered copies, so we do it directly.
> > *
> > * The xmin/xmax/xip fields don't need refreshing: within a single
> > * statement batch, only curcid changes between rows.
> > */
> > Assert(fpentry && fpentry->snapshot !=3D NULL);
> > snapshot =3D fpentry->snapshot;
> > snapshot->curcid =3D GetCurrentCommandId(false);
> > }
> > else
> > snapshot =3D RegisterSnapshot(GetLatestSnapshot());
> >
> > if (use_cache)
> > {
> > pk_rel =3D fpentry->pk_rel;
> > idx_rel =3D fpentry->idx_rel;
> > scandesc =3D fpentry->scandesc;
> > slot =3D fpentry->slot;
> > }
> > else
> > {
> > pk_rel =3D table_open(riinfo->pk_relid, RowShareLock);
> > idx_rel =3D index_open(riinfo->conindid, AccessShareLock);
> > scandesc =3D index_beginscan(pk_rel, idx_rel,
> > snapshot, NULL,
> > riinfo->nkeys, 0);
> > slot =3D table_slot_create(pk_rel, NULL);
> > }
> >
> > --
> > Regards
> > Junwang Zhao
> >
> >
> >
> >
> > --
> > Thanks, Amit Langote
> >
> >
> >
> >
> > --
> > Regards
> > Junwang Zhao
> >
> >
> > I had an offline discussion with Amit today. There were a few small thi=
ngs
> > that could be improved, so I posted a new version of the patch set.
> >
> > 1.
> >
> > + if (ri_fastpath_is_applicable(riinfo))
> > + {
> > + bool found =3D ri_FastPathCheck(riinfo, fk_rel, newslot);
> > +
> > + if (found)
> > + return PointerGetDatum(NULL);
> > +
> > + /*
> > + * ri_FastPathCheck opens pk_rel internally; we need it for
> > + * ri_ReportViolation.  Re-open briefly.
> > + */
> > + pk_rel =3D table_open(riinfo->pk_relid, RowShareLock);
> > + ri_ReportViolation(riinfo, pk_rel, fk_rel,
> > +    newslot, NULL,
> > +    RI_PLAN_CHECK_LOOKUPPK, false, false);
> > + }
> >
> > Move ri_ReportViolation into ri_FastPathCheck, so table_open is no
> > longer needed, and ri_FastPathCheck now returns void. Since Amit
> > agreed this is the right approach, I included it directly in v5-0001.
> >
> > 2.
> >
> > After adding the batch fast path, the original ri_FastPathCheck is only
> > used by the ALTER TABLE validation path. This path cannot use the
> > cache because the registered AfterTriggerBatch callback will never run.
> > Therefore, the use_cache branch can be removed.
> >
> > I made this change in v5-0004 and also updated some related comments.
> > Once we agree the changes are correct, it can be merged into v5-0003.
> >
> > 3.
> >
> > + fk_slot =3D MakeSingleTupleTableSlot(RelationGetDescr(fk_rel),
> > +    &TTSOpsHeapTuple);
> >
> > ri_FastPathBatchFlush creates a new fk_slot but does not cache it in
> > RI_FastPathEntry. I tried caching it in v5-0006 and ran some benchmarks=
,
> > it didn't show much improvement. This might be because the slot creatio=
n
> > function is called once per batch rather than once per row, so the over=
all
> > impact is minimal. I'm posting this here for Amit to take a look and de=
cide
> > whether we should adopt it or drop it, since I mentioned the idea to
> > him earlier.
> >
> > 4.
> >
> > ri_FastPathFlushArray currently uses SK_SEARCHARRAY only for
> > single-column checks. I asked whether this could be extended to support
> > multi-column cases, and Amit encouraged me to look into it.
> >
> > After a brief investigation, it seems that ScanKeyEntryInitialize only =
allows
> > passing a single subtype/collation/procedure, which makes it difficult =
to
> > handle multiple types. Based on this, my current understanding is that
> > SK_SEARCHARRAY may not work for multi-column checks.
> >
> > --
> > Regards
> > Junwang Zhao
> > <v5-0005-Use-SK_SEARCHARRAY-for-batched-fast-path-FK-probe.patch><v5-00=
06-Reuse-FK-tuple-slot-across-fast-path-batches.patch><v5-0002-Cache-per-ba=
tch-resources-for-fast-path-foreign-k.patch><v5-0004-Refine-fast-path-FK-va=
lidation-path.patch><v5-0003-Buffer-FK-rows-for-batched-fast-path-probing.p=
atch><v5-0001-Add-fast-path-for-foreign-key-constraint-checks.patch>
> >
> >
>
>
> --
> Regards
> Junwang Zhao

I squashed 0004 into 0003 so that each file can be committed independently.
I also runned pgindent for each file.

--=20
Regards
Junwang Zhao

--000000000000130115064d62f122
Content-Type: application/octet-stream;
	name="v8-0001-Add-fast-path-for-foreign-key-constraint-checks.patch"
Content-Disposition: attachment;
	filename="v8-0001-Add-fast-path-for-foreign-key-constraint-checks.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmxoe2ma2>
X-Attachment-Id: f_mmxoe2ma2

RnJvbSA2NzJkYWQ5YzNjZmU5NzA2OWQ4MjU3ZjI1MWU0YTM0ZTkzZmZhZjE4IE1vbiBTZXAgMTcg
MDA6MDA6MDAgMjAwMQpGcm9tOiBBbWl0IExhbmdvdGUgPGFtaXRsYW5AcG9zdGdyZXNxbC5vcmc+
CkRhdGU6IFN1biwgMTUgTWFyIDIwMjYgMTY6NTM6MjcgKzA5MDAKU3ViamVjdDogW1BBVENIIHY4
IDEvM10gQWRkIGZhc3QgcGF0aCBmb3IgZm9yZWlnbiBrZXkgY29uc3RyYWludCBjaGVja3MKCkFk
ZCBhIGZhc3QtcGF0aCBvcHRpbWl6YXRpb24gZm9yIGZvcmVpZ24ga2V5IGNoZWNrcyB0aGF0IGJ5
cGFzc2VzIFNQSQpieSBkaXJlY3RseSBwcm9iaW5nIHRoZSB1bmlxdWUgaW5kZXggb24gdGhlIHJl
ZmVyZW5jZWQgdGFibGUuCgpUaGUgZmFzdCBwYXRoIGFwcGxpZXMgd2hlbiB0aGUgcmVmZXJlbmNl
ZCB0YWJsZSBpcyBub3QgcGFydGl0aW9uZWQgYW5kCnRoZSBjb25zdHJhaW50IGRvZXMgbm90IGlu
dm9sdmUgdGVtcG9yYWwgc2VtYW50aWNzLiAgcmlfRmFzdFBhdGhDaGVjaygpCmV4dHJhY3RzIHRo
ZSBGSyB2YWx1ZXMsIGJ1aWxkcyBzY2FuIGtleXMsIHBlcmZvcm1zIGFuIGluZGV4IHNjYW4sIGFu
ZApsb2NrcyB0aGUgbWF0Y2hpbmcgdHVwbGUgd2l0aCBMb2NrVHVwbGVLZXlTaGFyZSB2aWEgcmlf
TG9ja1BLVHVwbGUoKSwKd2hpY2ggaGFuZGxlcyB0aGUgUkktc3BlY2lmaWMgc3Vic2V0IG9mIHRh
YmxlX3R1cGxlX2xvY2soKSByZXN1bHRzLgoKSWYgdGhlIGxvY2tlZCB0dXBsZSB3YXMgcmVhY2hl
ZCBieSBjaGFzaW5nIGFuIHVwZGF0ZSBjaGFpbgoodG1mZC50cmF2ZXJzZWQpLCByZWNoZWNrX21h
dGNoZWRfcGtfdHVwbGUoKSB2ZXJpZmllcyB0aGF0IHRoZSBrZXkKaXMgc3RpbGwgdGhlIHNhbWUs
IGVtdWxhdGluZyBFdmFsUGxhblF1YWwuCgpUaGUgc2NhbiB1c2VzIEdldFRyYW5zYWN0aW9uU25h
cHNob3QoKSwgbWF0Y2hpbmcgd2hhdCB0aGUgU1BJIHBhdGgKdXNlcyAodmlhIF9TUElfZXhlY3V0
ZV9wbGFuIHB1c2hpbmcgR2V0VHJhbnNhY3Rpb25TbmFwc2hvdCgpIGFzIHRoZQphY3RpdmUgc25h
cHNob3QpLiAgVW5kZXIgUkVBRCBDT01NSVRURUQgdGhpcyBpcyBhIGZyZXNoIHNuYXBzaG90Owp1
bmRlciBSRVBFQVRBQkxFIFJFQUQgLyBTRVJJQUxJWkFCTEUgaXQgaXMgdGhlIGZyb3plbiB0cmFu
c2FjdGlvbi0Kc3RhcnQgc25hcHNob3QsIHNvIFBLIHJvd3MgY29tbWl0dGVkIGFmdGVyIHRoZSB0
cmFuc2FjdGlvbiBzdGFydGVkCmFyZSBub3QgdmlzaWJsZS4KClRoZSByaV9DaGVja1Blcm1pc3Np
b25zKCkgZnVuY3Rpb24gcGVyZm9ybXMgc2NoZW1hIFVTQUdFIGFuZCB0YWJsZQpTRUxFQ1QgY2hl
Y2tzLCBtYXRjaGluZyB3aGF0IHRoZSBTUEkgcGF0aCBkb2VzIGltcGxpY2l0bHkuCgpyaV9IYXNo
Q29tcGFyZU9wKCkgaXMgYWRqdXN0ZWQgdG8gaGFuZGxlIGNyb3NzLXR5cGUgZXF1YWxpdHkgb3Bl
cmF0b3JzCihlLmcuIGludDQ4ZXEgZm9yIGludDQgUEsgLyBpbnQ4IEZLKSB3aGljaCBjYW4gYXBw
ZWFyIGluIGNvbnBmZXFvcC4KVGhlIG9yaWdpbmFsIGNvZGUgYXNzZXJ0ZWQgc2FtZS10eXBlIG9w
ZXJhdG9ycyBvbmx5LgoKUGVyLWtleSBtZXRhZGF0YSAoY29tcGFyZSBlbnRyaWVzLCBvcGVyYXRv
ciBwcm9jZWR1cmVzLCBzdHJhdGVneQpudW1iZXJzKSBpcyBjYWNoZWQgaW4gUklfQ29uc3RyYWlu
dEluZm8gdmlhCnJpX3BvcHVsYXRlX2Zhc3RwYXRoX21ldGFkYXRhKCkgb24gZmlyc3QgdXNlLCBl
bGltaW5hdGluZyByZXBlYXRlZApjYWxscyB0byByaV9IYXNoQ29tcGFyZU9wKCkgYW5kIGdldF9v
cF9vcGZhbWlseV9wcm9wZXJ0aWVzKCkuCmNvbmluZGlkIGFuZCBwa19pc19wYXJ0aXRpb25lZCBh
cmUgYWxzbyBjYWNoZWQgYXQgY29uc3RyYWludCBsb2FkCnRpbWUsIGF2b2lkaW5nIHBlci1pbnZv
Y2F0aW9uIHN5c2NhY2hlIGxvb2t1cHMgYW5kIHRoZSBuZWVkIHRvIG9wZW4KcGtfcmVsIGJlZm9y
ZSBkZWNpZGluZyB3aGV0aGVyIHRoZSBmYXN0IHBhdGggYXBwbGllcy4KCk5ldyByZWdyZXNzaW9u
IHRlc3RzIGNvdmVyIFJMUyBieXBhc3MgYW5kIEFDTCBlbmZvcmNlbWVudCBmb3IgdGhlCmZhc3Qt
cGF0aCBwZXJtaXNzaW9uIGNoZWNrcy4gIE5ldyBpc29sYXRpb24gdGVzdHMgZXhlcmNpc2UgY29u
Y3VycmVudApQSyB1cGRhdGVzIHVuZGVyIGJvdGggUkVBRCBDT01NSVRURUQgYW5kIFJFUEVBVEFC
TEUgUkVBRC4KCkF1dGhvcjogSnVud2FuZyBaaGFvIDx6aGp3cGt1QGdtYWlsLmNvbT4KQXV0aG9y
OiBBbWl0IExhbmdvdGUgPGFtaXRsYW5nb3RlMDlAZ21haWwuY29tPgpEaXNjdXNzaW9uOiBodHRw
czovL3Bvc3Rnci5lcy9tLwotLS0KIHNyYy9iYWNrZW5kL3V0aWxzL2FkdC9yaV90cmlnZ2Vycy5j
ICAgICAgICAgICB8IDQ2NCArKysrKysrKysrKysrKysrKy0KIC4uLi9leHBlY3RlZC9may1jb25j
dXJyZW50LXBrLXVwZC5vdXQgICAgICAgICB8IDEwNSArKysrCiBzcmMvdGVzdC9pc29sYXRpb24v
aXNvbGF0aW9uX3NjaGVkdWxlICAgICAgICAgfCAgIDEgKwogLi4uL2lzb2xhdGlvbi9zcGVjcy9m
ay1jb25jdXJyZW50LXBrLXVwZC5zcGVjIHwgIDUzICsrCiBzcmMvdGVzdC9yZWdyZXNzL2V4cGVj
dGVkL2ZvcmVpZ25fa2V5Lm91dCAgICAgfCAgNDcgKysKIHNyYy90ZXN0L3JlZ3Jlc3Mvc3FsL2Zv
cmVpZ25fa2V5LnNxbCAgICAgICAgICB8ICA2NCArKysKIHNyYy90b29scy9wZ2luZGVudC90eXBl
ZGVmcy5saXN0ICAgICAgICAgICAgICB8ICAgMSArCiA3IGZpbGVzIGNoYW5nZWQsIDcyMyBpbnNl
cnRpb25zKCspLCAxMiBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzcmMvdGVzdC9p
c29sYXRpb24vZXhwZWN0ZWQvZmstY29uY3VycmVudC1way11cGQub3V0CiBjcmVhdGUgbW9kZSAx
MDA2NDQgc3JjL3Rlc3QvaXNvbGF0aW9uL3NwZWNzL2ZrLWNvbmN1cnJlbnQtcGstdXBkLnNwZWMK
CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9hZHQvcmlfdHJpZ2dlcnMuYyBiL3NyYy9i
YWNrZW5kL3V0aWxzL2FkdC9yaV90cmlnZ2Vycy5jCmluZGV4IGQyMmI4ZWY3ZjNjLi5jZTBmNWMx
MjBmNCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L3JpX3RyaWdnZXJzLmMKKysr
IGIvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L3JpX3RyaWdnZXJzLmMKQEAgLTI0LDEyICsyNCwxNSBA
QAogI2luY2x1ZGUgInBvc3RncmVzLmgiCiAKICNpbmNsdWRlICJhY2Nlc3MvaHR1cF9kZXRhaWxz
LmgiCisjaW5jbHVkZSAiYWNjZXNzL3NrZXkuaCIKICNpbmNsdWRlICJhY2Nlc3Mvc3lzYXR0ci5o
IgogI2luY2x1ZGUgImFjY2Vzcy90YWJsZS5oIgogI2luY2x1ZGUgImFjY2Vzcy90YWJsZWFtLmgi
CiAjaW5jbHVkZSAiYWNjZXNzL3hhY3QuaCIKKyNpbmNsdWRlICJjYXRhbG9nL2luZGV4LmgiCiAj
aW5jbHVkZSAiY2F0YWxvZy9wZ19jb2xsYXRpb24uaCIKICNpbmNsdWRlICJjYXRhbG9nL3BnX2Nv
bnN0cmFpbnQuaCIKKyNpbmNsdWRlICJjYXRhbG9nL3BnX25hbWVzcGFjZS5oIgogI2luY2x1ZGUg
ImNvbW1hbmRzL3RyaWdnZXIuaCIKICNpbmNsdWRlICJleGVjdXRvci9leGVjdXRvci5oIgogI2lu
Y2x1ZGUgImV4ZWN1dG9yL3NwaS5oIgpAQCAtOTEsNiArOTQsNyBAQAogI2RlZmluZSBSSV9UUklH
VFlQRV9VUERBVEUgMgogI2RlZmluZSBSSV9UUklHVFlQRV9ERUxFVEUgMwogCit0eXBlZGVmIHN0
cnVjdCBGYXN0UGF0aE1ldGEgRmFzdFBhdGhNZXRhOwogCiAvKgogICogUklfQ29uc3RyYWludElu
Zm8KQEAgLTEzMiw4ICsxMzYsMjQgQEAgdHlwZWRlZiBzdHJ1Y3QgUklfQ29uc3RyYWludEluZm8K
IAlPaWQJCQlwZXJpb2RfaW50ZXJzZWN0X29wZXI7CS8qIGFueXJhbmdlICogYW55cmFuZ2UgKG9y
CiAJCQkJCQkJCQkJICogbXVsdGlyYW5nZXMpICovCiAJZGxpc3Rfbm9kZQl2YWxpZF9saW5rOwkJ
LyogTGluayBpbiBsaXN0IG9mIHZhbGlkIGVudHJpZXMgKi8KKworCU9pZAkJCWNvbmluZGlkOwor
CWJvb2wJCXBrX2lzX3BhcnRpdGlvbmVkOworCisJRmFzdFBhdGhNZXRhICpmcG1ldGE7CiB9IFJJ
X0NvbnN0cmFpbnRJbmZvOwogCit0eXBlZGVmIHN0cnVjdCBSSV9Db21wYXJlSGFzaEVudHJ5IFJJ
X0NvbXBhcmVIYXNoRW50cnk7CisKKy8qIEZhc3QtcGF0aCBtZXRhZGF0YSBmb3IgUkkgY2hlY2tz
IG9uIGZvcmVpZ24ga2V5IHJlZmVyZW5jaW5nIHRhYmxlcyAqLwordHlwZWRlZiBzdHJ1Y3QgRmFz
dFBhdGhNZXRhCit7CisJUklfQ29tcGFyZUhhc2hFbnRyeSAqY29tcGFyZV9lbnRyaWVzW1JJX01B
WF9OVU1LRVlTXTsKKwlSZWdQcm9jZWR1cmUgcmVnb3BzW1JJX01BWF9OVU1LRVlTXTsKKwlPaWQJ
CQlzdWJ0eXBlc1tSSV9NQVhfTlVNS0VZU107CisJaW50CQkJc3RyYXRzW1JJX01BWF9OVU1LRVlT
XTsKK30gRmFzdFBhdGhNZXRhOworCiAvKgogICogUklfUXVlcnlLZXkKICAqCkBAIC0yMzMsNiAr
MjUzLDIzIEBAIHN0YXRpYyBib29sIHJpX1BlcmZvcm1DaGVjayhjb25zdCBSSV9Db25zdHJhaW50
SW5mbyAqcmlpbmZvLAogCQkJCQkJCVR1cGxlVGFibGVTbG90ICpvbGRzbG90LCBUdXBsZVRhYmxl
U2xvdCAqbmV3c2xvdCwKIAkJCQkJCQlib29sIGlzX3Jlc3RyaWN0LAogCQkJCQkJCWJvb2wgZGV0
ZWN0TmV3Um93cywgaW50IGV4cGVjdF9PSyk7CitzdGF0aWMgdm9pZCByaV9GYXN0UGF0aENoZWNr
KGNvbnN0IFJJX0NvbnN0cmFpbnRJbmZvICpyaWluZm8sCisJCQkJCQkJIFJlbGF0aW9uIGZrX3Jl
bCwgVHVwbGVUYWJsZVNsb3QgKm5ld3Nsb3QpOworc3RhdGljIGJvb2wgcmlfRmFzdFBhdGhQcm9i
ZU9uZShSZWxhdGlvbiBwa19yZWwsIFJlbGF0aW9uIGlkeF9yZWwsCisJCQkJCQkJCUluZGV4U2Nh
bkRlc2Mgc2NhbmRlc2MsIFR1cGxlVGFibGVTbG90ICpzbG90LAorCQkJCQkJCQlTbmFwc2hvdCBz
bmFwc2hvdCwgY29uc3QgUklfQ29uc3RyYWludEluZm8gKnJpaW5mbywKKwkJCQkJCQkJU2Nhbktl
eURhdGEgKnNrZXksIGludCBua2V5cyk7CitzdGF0aWMgYm9vbCByaV9Mb2NrUEtUdXBsZShSZWxh
dGlvbiBwa19yZWwsIFR1cGxlVGFibGVTbG90ICpzbG90LCBTbmFwc2hvdCBzbmFwLAorCQkJCQkJ
ICAgYm9vbCAqY29uY3VycmVudGx5X3VwZGF0ZWQpOworc3RhdGljIGJvb2wgcmlfZmFzdHBhdGhf
aXNfYXBwbGljYWJsZShjb25zdCBSSV9Db25zdHJhaW50SW5mbyAqcmlpbmZvKTsKK3N0YXRpYyB2
b2lkIHJpX0NoZWNrUGVybWlzc2lvbnMoUmVsYXRpb24gcXVlcnlfcmVsKTsKK3N0YXRpYyBib29s
IHJlY2hlY2tfbWF0Y2hlZF9wa190dXBsZShSZWxhdGlvbiBpZHhyZWwsIFNjYW5LZXlEYXRhICpz
a2V5cywKKwkJCQkJCQkJCSBUdXBsZVRhYmxlU2xvdCAqbmV3X3Nsb3QpOworc3RhdGljIHZvaWQg
YnVpbGRfaW5kZXhfc2NhbmtleXMoY29uc3QgUklfQ29uc3RyYWludEluZm8gKnJpaW5mbywKKwkJ
CQkJCQkJIFJlbGF0aW9uIGlkeF9yZWwsIERhdHVtICpwa192YWxzLAorCQkJCQkJCQkgY2hhciAq
cGtfbnVsbHMsIFNjYW5LZXkgc2tleXMpOworc3RhdGljIHZvaWQgcmlfcG9wdWxhdGVfZmFzdHBh
dGhfbWV0YWRhdGEoUklfQ29uc3RyYWludEluZm8gKnJpaW5mbywKKwkJCQkJCQkJCQkgIFJlbGF0
aW9uIGZrX3JlbCwgUmVsYXRpb24gaWR4X3JlbCk7CiBzdGF0aWMgdm9pZCByaV9FeHRyYWN0VmFs
dWVzKFJlbGF0aW9uIHJlbCwgVHVwbGVUYWJsZVNsb3QgKnNsb3QsCiAJCQkJCQkJIGNvbnN0IFJJ
X0NvbnN0cmFpbnRJbmZvICpyaWluZm8sIGJvb2wgcmVsX2lzX3BrLAogCQkJCQkJCSBEYXR1bSAq
dmFscywgY2hhciAqbnVsbHMpOwpAQCAtMjc2LDE0ICszMTMsNyBAQCBSSV9GS2V5X2NoZWNrKFRy
aWdnZXJEYXRhICp0cmlnZGF0YSkKIAlpZiAoIXRhYmxlX3R1cGxlX3NhdGlzZmllc19zbmFwc2hv
dCh0cmlnZGF0YS0+dGdfcmVsYXRpb24sIG5ld3Nsb3QsIFNuYXBzaG90U2VsZikpCiAJCXJldHVy
biBQb2ludGVyR2V0RGF0dW0oTlVMTCk7CiAKLQkvKgotCSAqIEdldCB0aGUgcmVsYXRpb24gZGVz
Y3JpcHRvcnMgb2YgdGhlIEZLIGFuZCBQSyB0YWJsZXMuCi0JICoKLQkgKiBwa19yZWwgaXMgb3Bl
bmVkIGluIFJvd1NoYXJlTG9jayBtb2RlIHNpbmNlIHRoYXQncyB3aGF0IG91ciBldmVudHVhbAot
CSAqIFNFTEVDVCBGT1IgS0VZIFNIQVJFIHdpbGwgZ2V0IG9uIGl0LgotCSAqLwogCWZrX3JlbCA9
IHRyaWdkYXRhLT50Z19yZWxhdGlvbjsKLQlwa19yZWwgPSB0YWJsZV9vcGVuKHJpaW5mby0+cGtf
cmVsaWQsIFJvd1NoYXJlTG9jayk7CiAKIAlzd2l0Y2ggKHJpX051bGxDaGVjayhSZWxhdGlvbkdl
dERlc2NyKGZrX3JlbCksIG5ld3Nsb3QsIHJpaW5mbywgZmFsc2UpKQogCXsKQEAgLTI5Myw3ICsz
MjMsNiBAQCBSSV9GS2V5X2NoZWNrKFRyaWdnZXJEYXRhICp0cmlnZGF0YSkKIAkJCSAqIE5vIGZ1
cnRoZXIgY2hlY2sgbmVlZGVkIC0gYW4gYWxsLU5VTEwga2V5IHBhc3NlcyBldmVyeSB0eXBlIG9m
CiAJCQkgKiBmb3JlaWduIGtleSBjb25zdHJhaW50LgogCQkJICovCi0JCQl0YWJsZV9jbG9zZShw
a19yZWwsIFJvd1NoYXJlTG9jayk7CiAJCQlyZXR1cm4gUG9pbnRlckdldERhdHVtKE5VTEwpOwog
CiAJCWNhc2UgUklfS0VZU19TT01FX05VTEw6CkBAIC0zMTgsNyArMzQ3LDYgQEAgUklfRktleV9j
aGVjayhUcmlnZ2VyRGF0YSAqdHJpZ2RhdGEpCiAJCQkJCQkJIGVycmRldGFpbCgiTUFUQ0ggRlVM
TCBkb2VzIG5vdCBhbGxvdyBtaXhpbmcgb2YgbnVsbCBhbmQgbm9ubnVsbCBrZXkgdmFsdWVzLiIp
LAogCQkJCQkJCSBlcnJ0YWJsZWNvbnN0cmFpbnQoZmtfcmVsLAogCQkJCQkJCQkJCQkJTmFtZVN0
cihyaWluZm8tPmNvbm5hbWUpKSkpOwotCQkJCQl0YWJsZV9jbG9zZShwa19yZWwsIFJvd1NoYXJl
TG9jayk7CiAJCQkJCXJldHVybiBQb2ludGVyR2V0RGF0dW0oTlVMTCk7CiAKIAkJCQljYXNlIEZL
Q09OU1RSX01BVENIX1NJTVBMRToKQEAgLTMyNyw3ICszNTUsNiBAQCBSSV9GS2V5X2NoZWNrKFRy
aWdnZXJEYXRhICp0cmlnZGF0YSkKIAkJCQkJICogTUFUQ0ggU0lNUExFIC0gaWYgQU5ZIGNvbHVt
biBpcyBudWxsLCB0aGUga2V5IHBhc3NlcwogCQkJCQkgKiB0aGUgY29uc3RyYWludC4KIAkJCQkJ
ICovCi0JCQkJCXRhYmxlX2Nsb3NlKHBrX3JlbCwgUm93U2hhcmVMb2NrKTsKIAkJCQkJcmV0dXJu
IFBvaW50ZXJHZXREYXR1bShOVUxMKTsKIAogI2lmZGVmIE5PVF9VU0VECkBAIC0zNTIsOCArMzc5
LDMxIEBAIFJJX0ZLZXlfY2hlY2soVHJpZ2dlckRhdGEgKnRyaWdkYXRhKQogCQkJYnJlYWs7CiAJ
fQogCisJLyoKKwkgKiBGYXN0IHBhdGg6IHByb2JlIHRoZSBQSyB1bmlxdWUgaW5kZXggZGlyZWN0
bHksIGJ5cGFzc2luZyBTUEkuCisJICoKKwkgKiBGb3Igbm9uLXBhcnRpdGlvbmVkLCBub24tdGVt
cG9yYWwgRktzLCB3ZSBjYW4gc2tpcCB0aGUgU1BJIG1hY2hpbmVyeQorCSAqIChwbGFuIGNhY2hl
LCBleGVjdXRvciBzZXR1cCwgZXRjLikgYW5kIGRvIGEgZGlyZWN0IGluZGV4IHNjYW4gKyB0dXBs
ZQorCSAqIGxvY2suICBUaGlzIGlzIHNlbWFudGljYWxseSBlcXVpdmFsZW50IHRvIHRoZSBTUEkg
cGF0aCBiZWxvdyBidXQgYXZvaWRzCisJICogdGhlIHBlci1yb3cgZXhlY3V0b3Igb3ZlcmhlYWQu
CisJICoKKwkgKiByaV9GYXN0UGF0aENoZWNrKCkgcmVwb3J0cyB0aGUgdmlvbGF0aW9uIGl0c2Vs
ZiAodmlhIGVyZXBvcnQpIGlmIG5vCisJICogbWF0Y2hpbmcgUEsgcm93IGlzIGZvdW5kLCBzbyBp
dCBvbmx5IHJldHVybnMgb24gc3VjY2Vzcy4KKwkgKi8KKwlpZiAocmlfZmFzdHBhdGhfaXNfYXBw
bGljYWJsZShyaWluZm8pKQorCXsKKwkJcmlfRmFzdFBhdGhDaGVjayhyaWluZm8sIGZrX3JlbCwg
bmV3c2xvdCk7CisJCXJldHVybiBQb2ludGVyR2V0RGF0dW0oTlVMTCk7CisJfQorCiAJU1BJX2Nv
bm5lY3QoKTsKIAorCS8qCisJICogcGtfcmVsIGlzIG9wZW5lZCBpbiBSb3dTaGFyZUxvY2sgbW9k
ZSBzaW5jZSB0aGF0J3Mgd2hhdCBvdXIgZXZlbnR1YWwKKwkgKiBTRUxFQ1QgRk9SIEtFWSBTSEFS
RSB3aWxsIGdldCBvbiBpdC4KKwkgKi8KKwlwa19yZWwgPSB0YWJsZV9vcGVuKHJpaW5mby0+cGtf
cmVsaWQsIFJvd1NoYXJlTG9jayk7CisKIAkvKiBGZXRjaCBvciBwcmVwYXJlIGEgc2F2ZWQgcGxh
biBmb3IgdGhlIHJlYWwgY2hlY2sgKi8KIAlyaV9CdWlsZFF1ZXJ5S2V5KCZxa2V5LCByaWluZm8s
IFJJX1BMQU5fQ0hFQ0tfTE9PS1VQUEspOwogCkBAIC0yMzU2LDYgKzI0MDYsMTIgQEAgcmlfTG9h
ZENvbnN0cmFpbnRJbmZvKE9pZCBjb25zdHJhaW50T2lkKQogCiAJcmlpbmZvLT52YWxpZCA9IHRy
dWU7CiAKKwlyaWluZm8tPmNvbmluZGlkID0gY29uRm9ybS0+Y29uaW5kaWQ7CisJcmlpbmZvLT5w
a19pc19wYXJ0aXRpb25lZCA9CisJCShnZXRfcmVsX3JlbGtpbmQocmlpbmZvLT5wa19yZWxpZCkg
PT0gUkVMS0lORF9QQVJUSVRJT05FRF9UQUJMRSk7CisKKwlyaWluZm8tPmZwbWV0YSA9IE5VTEw7
CisKIAlyZXR1cm4gcmlpbmZvOwogfQogCkBAIC0yNjE3LDYgKzI2NzMsMzgyIEBAIHJpX1BlcmZv
cm1DaGVjayhjb25zdCBSSV9Db25zdHJhaW50SW5mbyAqcmlpbmZvLAogCXJldHVybiBTUElfcHJv
Y2Vzc2VkICE9IDA7CiB9CiAKKy8qCisgKiByaV9GYXN0UGF0aENoZWNrCisgKgkJUGVyZm9ybSBG
SyBleGlzdGVuY2UgY2hlY2sgdmlhIGRpcmVjdCBpbmRleCBwcm9iZSwgYnlwYXNzaW5nIFNQSS4K
KyAqCisgKiBJZiBubyBtYXRjaGluZyBQSyByb3cgZXhpc3RzLCByZXBvcnQgdGhlIHZpb2xhdGlv
biB2aWEgcmlfUmVwb3J0VmlvbGF0aW9uKCksCisgKiBvdGhlcndpc2UsIHRoZSBmdW5jdGlvbiBy
ZXR1cm5zIG5vcm1hbGx5LgorICovCitzdGF0aWMgdm9pZAorcmlfRmFzdFBhdGhDaGVjayhjb25z
dCBSSV9Db25zdHJhaW50SW5mbyAqcmlpbmZvLAorCQkJCSBSZWxhdGlvbiBma19yZWwsIFR1cGxl
VGFibGVTbG90ICpuZXdzbG90KQoreworCVJlbGF0aW9uCXBrX3JlbDsKKwlSZWxhdGlvbglpZHhf
cmVsOworCUluZGV4U2NhbkRlc2Mgc2NhbmRlc2M7CisJVHVwbGVUYWJsZVNsb3QgKnNsb3Q7CisJ
RGF0dW0JCXBrX3ZhbHNbSU5ERVhfTUFYX0tFWVNdOworCWNoYXIJCXBrX251bGxzW0lOREVYX01B
WF9LRVlTXTsKKwlTY2FuS2V5RGF0YSBza2V5W0lOREVYX01BWF9LRVlTXTsKKwlib29sCQlmb3Vu
ZCA9IGZhbHNlOworCU9pZAkJCXNhdmVkX3VzZXJpZDsKKwlpbnQJCQlzYXZlZF9zZWNfY29udGV4
dDsKKwlTbmFwc2hvdAlzbmFwc2hvdDsKKworCS8qCisJICogQWR2YW5jZSB0aGUgY29tbWFuZCBj
b3VudGVyIHNvIHRoZSBzbmFwc2hvdCBzZWVzIHRoZSBlZmZlY3RzIG9mIHByaW9yCisJICogdHJp
Z2dlcnMgaW4gdGhpcyBzdGF0ZW1lbnQuICBNaXJyb3JzIHdoYXQgdGhlIFNQSSBwYXRoIGRvZXMg
aW4KKwkgKiByaV9QZXJmb3JtQ2hlY2soKS4KKwkgKi8KKwlDb21tYW5kQ291bnRlckluY3JlbWVu
dCgpOworCXNuYXBzaG90ID0gUmVnaXN0ZXJTbmFwc2hvdChHZXRUcmFuc2FjdGlvblNuYXBzaG90
KCkpOworCisJcGtfcmVsID0gdGFibGVfb3BlbihyaWluZm8tPnBrX3JlbGlkLCBSb3dTaGFyZUxv
Y2spOworCWlkeF9yZWwgPSBpbmRleF9vcGVuKHJpaW5mby0+Y29uaW5kaWQsIEFjY2Vzc1NoYXJl
TG9jayk7CisKKwlzbG90ID0gdGFibGVfc2xvdF9jcmVhdGUocGtfcmVsLCBOVUxMKTsKKwlzY2Fu
ZGVzYyA9IGluZGV4X2JlZ2luc2Nhbihwa19yZWwsIGlkeF9yZWwsCisJCQkJCQkJICAgc25hcHNo
b3QsIE5VTEwsCisJCQkJCQkJICAgcmlpbmZvLT5ua2V5cywgMCk7CisKKwlpZiAocmlpbmZvLT5m
cG1ldGEgPT0gTlVMTCkKKwkJcmlfcG9wdWxhdGVfZmFzdHBhdGhfbWV0YWRhdGEoKFJJX0NvbnN0
cmFpbnRJbmZvICopIHJpaW5mbywKKwkJCQkJCQkJCSAgZmtfcmVsLCBpZHhfcmVsKTsKKwlBc3Nl
cnQocmlpbmZvLT5mcG1ldGEpOworCisJR2V0VXNlcklkQW5kU2VjQ29udGV4dCgmc2F2ZWRfdXNl
cmlkLCAmc2F2ZWRfc2VjX2NvbnRleHQpOworCVNldFVzZXJJZEFuZFNlY0NvbnRleHQoUmVsYXRp
b25HZXRGb3JtKHBrX3JlbCktPnJlbG93bmVyLAorCQkJCQkJICAgc2F2ZWRfc2VjX2NvbnRleHQg
fAorCQkJCQkJICAgU0VDVVJJVFlfTE9DQUxfVVNFUklEX0NIQU5HRSB8CisJCQkJCQkgICBTRUNV
UklUWV9OT0ZPUkNFX1JMUyk7CisJcmlfQ2hlY2tQZXJtaXNzaW9ucyhwa19yZWwpOworCisJcmlf
RXh0cmFjdFZhbHVlcyhma19yZWwsIG5ld3Nsb3QsIHJpaW5mbywgZmFsc2UsIHBrX3ZhbHMsIHBr
X251bGxzKTsKKwlidWlsZF9pbmRleF9zY2Fua2V5cyhyaWluZm8sIGlkeF9yZWwsIHBrX3ZhbHMs
IHBrX251bGxzLCBza2V5KTsKKwlmb3VuZCA9IHJpX0Zhc3RQYXRoUHJvYmVPbmUocGtfcmVsLCBp
ZHhfcmVsLCBzY2FuZGVzYywgc2xvdCwKKwkJCQkJCQkJc25hcHNob3QsIHJpaW5mbywgc2tleSwg
cmlpbmZvLT5ua2V5cyk7CisJU2V0VXNlcklkQW5kU2VjQ29udGV4dChzYXZlZF91c2VyaWQsIHNh
dmVkX3NlY19jb250ZXh0KTsKKwlpbmRleF9lbmRzY2FuKHNjYW5kZXNjKTsKKwlFeGVjRHJvcFNp
bmdsZVR1cGxlVGFibGVTbG90KHNsb3QpOworCVVucmVnaXN0ZXJTbmFwc2hvdChzbmFwc2hvdCk7
CisKKwlpZiAoIWZvdW5kKQorCQlyaV9SZXBvcnRWaW9sYXRpb24ocmlpbmZvLCBwa19yZWwsIGZr
X3JlbCwKKwkJCQkJCSAgIG5ld3Nsb3QsIE5VTEwsCisJCQkJCQkgICBSSV9QTEFOX0NIRUNLX0xP
T0tVUFBLLCBmYWxzZSwgZmFsc2UpOworCisJaW5kZXhfY2xvc2UoaWR4X3JlbCwgTm9Mb2NrKTsK
Kwl0YWJsZV9jbG9zZShwa19yZWwsIE5vTG9jayk7Cit9CisKKy8qCisgKiByaV9GYXN0UGF0aFBy
b2JlT25lCisgKgkJUHJvYmUgdGhlIFBLIGluZGV4IGZvciBvbmUgc2V0IG9mIHNjYW4ga2V5cywg
bG9jayB0aGUgbWF0Y2hpbmcKKyAqCQl0dXBsZQorICoKKyAqIFJldHVybnMgdHJ1ZSBpZiBhIG1h
dGNoaW5nIFBLIHJvdyB3YXMgZm91bmQsIGxvY2tlZCwgYW5kIChpZgorICogYXBwbGljYWJsZSkg
dmlzaWJsZSB0byB0aGUgdHJhbnNhY3Rpb24gc25hcHNob3QuCisgKgorICogVGhlIGNhbGxlciBt
dXN0IGVuc3VyZSBDdXJyZW50TWVtb3J5Q29udGV4dCBpcyBsb25nLWxpdmVkIGVub3VnaAorICog
Zm9yIHRoZSBzY2FuIGRlc2NyaXB0b3IncyBpbnRlcm5hbCBhbGxvY2F0aW9ucyAodHlwaWNhbGx5
CisgKiBUb3BUcmFuc2FjdGlvbkNvbnRleHQgd2hlbiB1c2luZyBhIGNhY2hlZCBzY2FuZGVzYyku
CisgKi8KK3N0YXRpYyBib29sCityaV9GYXN0UGF0aFByb2JlT25lKFJlbGF0aW9uIHBrX3JlbCwg
UmVsYXRpb24gaWR4X3JlbCwKKwkJCQkJSW5kZXhTY2FuRGVzYyBzY2FuZGVzYywgVHVwbGVUYWJs
ZVNsb3QgKnNsb3QsCisJCQkJCVNuYXBzaG90IHNuYXBzaG90LCBjb25zdCBSSV9Db25zdHJhaW50
SW5mbyAqcmlpbmZvLAorCQkJCQlTY2FuS2V5RGF0YSAqc2tleSwgaW50IG5rZXlzKQoreworCWJv
b2wJCWZvdW5kID0gZmFsc2U7CisKKwlpbmRleF9yZXNjYW4oc2NhbmRlc2MsIHNrZXksIG5rZXlz
LCBOVUxMLCAwKTsKKworCWlmIChpbmRleF9nZXRuZXh0X3Nsb3Qoc2NhbmRlc2MsIEZvcndhcmRT
Y2FuRGlyZWN0aW9uLCBzbG90KSkKKwl7CisJCWJvb2wJCWNvbmN1cnJlbnRseV91cGRhdGVkOwor
CisJCWlmIChyaV9Mb2NrUEtUdXBsZShwa19yZWwsIHNsb3QsIHNuYXBzaG90LAorCQkJCQkJICAg
JmNvbmN1cnJlbnRseV91cGRhdGVkKSkKKwkJeworCQkJaWYgKGNvbmN1cnJlbnRseV91cGRhdGVk
KQorCQkJCWZvdW5kID0gcmVjaGVja19tYXRjaGVkX3BrX3R1cGxlKGlkeF9yZWwsIHNrZXksIHNs
b3QpOworCQkJZWxzZQorCQkJCWZvdW5kID0gdHJ1ZTsKKwkJfQorCX0KKworCXJldHVybiBmb3Vu
ZDsKK30KKworLyoKKyAqIHJpX0xvY2tQS1R1cGxlCisgKgkJTG9jayBhIFBLIHR1cGxlIGZvdW5k
IGJ5IHRoZSBmYXN0LXBhdGggaW5kZXggc2Nhbi4KKyAqCisgKiBDYWxscyB0YWJsZV90dXBsZV9s
b2NrKCkgZGlyZWN0bHkgd2l0aCBoYW5kbGluZyBzcGVjaWZpYyB0byBSSSBjaGVja3MuCisgKiBS
ZXR1cm5zIHRydWUgaWYgdGhlIHR1cGxlIHdhcyBzdWNjZXNzZnVsbHkgbG9ja2VkLgorICoKKyAq
IFNldHMgKmNvbmN1cnJlbnRseV91cGRhdGVkIHRvIHRydWUgaWYgdGhlIGxvY2tlZCB0dXBsZSB3
YXMgcmVhY2hlZAorICogYnkgZm9sbG93aW5nIGFuIHVwZGF0ZSBjaGFpbiAodG1mZC50cmF2ZXJz
ZWQpLCBpbmRpY2F0aW5nIHRoZSBjYWxsZXIKKyAqIHNob3VsZCByZWNoZWNrIHRoZSBrZXkuCisg
Ki8KK3N0YXRpYyBib29sCityaV9Mb2NrUEtUdXBsZShSZWxhdGlvbiBwa19yZWwsIFR1cGxlVGFi
bGVTbG90ICpzbG90LCBTbmFwc2hvdCBzbmFwLAorCQkJICAgYm9vbCAqY29uY3VycmVudGx5X3Vw
ZGF0ZWQpCit7CisJVE1fRmFpbHVyZURhdGEgdG1mZDsKKwlUTV9SZXN1bHQJcmVzdWx0OworCWlu
dAkJCWxvY2tmbGFncyA9IFRVUExFX0xPQ0tfRkxBR19MT0NLX1VQREFURV9JTl9QUk9HUkVTUzsK
KworCSpjb25jdXJyZW50bHlfdXBkYXRlZCA9IGZhbHNlOworCisJaWYgKCFJc29sYXRpb25Vc2Vz
WGFjdFNuYXBzaG90KCkpCisJCWxvY2tmbGFncyB8PSBUVVBMRV9MT0NLX0ZMQUdfRklORF9MQVNU
X1ZFUlNJT047CisKKwlyZXN1bHQgPSB0YWJsZV90dXBsZV9sb2NrKHBrX3JlbCwgJnNsb3QtPnR0
c190aWQsIHNuYXAsCisJCQkJCQkJICBzbG90LCBHZXRDdXJyZW50Q29tbWFuZElkKGZhbHNlKSwK
KwkJCQkJCQkgIExvY2tUdXBsZUtleVNoYXJlLCBMb2NrV2FpdEJsb2NrLAorCQkJCQkJCSAgbG9j
a2ZsYWdzLCAmdG1mZCk7CisKKwlzd2l0Y2ggKHJlc3VsdCkKKwl7CisJCWNhc2UgVE1fT2s6CisJ
CQlpZiAodG1mZC50cmF2ZXJzZWQpCisJCQkJKmNvbmN1cnJlbnRseV91cGRhdGVkID0gdHJ1ZTsK
KwkJCXJldHVybiB0cnVlOworCisJCWNhc2UgVE1fRGVsZXRlZDoKKwkJCWlmIChJc29sYXRpb25V
c2VzWGFjdFNuYXBzaG90KCkpCisJCQkJZXJlcG9ydChFUlJPUiwKKwkJCQkJCShlcnJjb2RlKEVS
UkNPREVfVF9SX1NFUklBTElaQVRJT05fRkFJTFVSRSksCisJCQkJCQkgZXJybXNnKCJjb3VsZCBu
b3Qgc2VyaWFsaXplIGFjY2VzcyBkdWUgdG8gY29uY3VycmVudCB1cGRhdGUiKSkpOworCQkJcmV0
dXJuIGZhbHNlOworCisJCWNhc2UgVE1fVXBkYXRlZDoKKwkJCWlmIChJc29sYXRpb25Vc2VzWGFj
dFNuYXBzaG90KCkpCisJCQkJZXJlcG9ydChFUlJPUiwKKwkJCQkJCShlcnJjb2RlKEVSUkNPREVf
VF9SX1NFUklBTElaQVRJT05fRkFJTFVSRSksCisJCQkJCQkgZXJybXNnKCJjb3VsZCBub3Qgc2Vy
aWFsaXplIGFjY2VzcyBkdWUgdG8gY29uY3VycmVudCB1cGRhdGUiKSkpOworCisJCQkvKgorCQkJ
ICogSW4gUkVBRCBDT01NSVRURUQsIEZJTkRfTEFTVF9WRVJTSU9OIHNob3VsZCBoYXZlIGNoYXNl
ZCB0aGUKKwkJCSAqIGNoYWluIGFuZCByZXR1cm5lZCBUTV9Pay4gIEdldHRpbmcgaGVyZSBtZWFu
cyBzb21ldGhpbmcKKwkJCSAqIHVuZXhwZWN0ZWQgLS0gZmFsbCB0aHJvdWdoIHRvIGVycm9yLgor
CQkJICovCisJCQllbG9nKEVSUk9SLCAidW5leHBlY3RlZCB0YWJsZV90dXBsZV9sb2NrIHN0YXR1
czogJXUiLCByZXN1bHQpOworCQkJYnJlYWs7CisKKwkJY2FzZSBUTV9TZWxmTW9kaWZpZWQ6CisK
KwkJCS8qCisJCQkgKiBUaGUgY3VycmVudCBjb21tYW5kIG9yIGEgbGF0ZXIgY29tbWFuZCBpbiB0
aGlzIHRyYW5zYWN0aW9uCisJCQkgKiBtb2RpZmllZCB0aGUgUEsgcm93LiAgVGhpcyBzaG91bGRu
J3Qgbm9ybWFsbHkgaGFwcGVuIGR1cmluZyBhbgorCQkJICogRksgY2hlY2sgKHdlJ3JlIG5vdCBt
b2RpZnlpbmcgcGtfcmVsKSwgYnV0IGhhbmRsZSBpdCBzYWZlbHkgYnkKKwkJCSAqIHRyZWF0aW5n
IHRoZSB0dXBsZSBhcyBub3QgZm91bmQuCisJCQkgKi8KKwkJCXJldHVybiBmYWxzZTsKKworCQlj
YXNlIFRNX0ludmlzaWJsZToKKwkJCWVsb2coRVJST1IsICJhdHRlbXB0ZWQgdG8gbG9jayBpbnZp
c2libGUgdHVwbGUiKTsKKwkJCWJyZWFrOworCisJCWRlZmF1bHQ6CisJCQllbG9nKEVSUk9SLCAi
dW5yZWNvZ25pemVkIHRhYmxlX3R1cGxlX2xvY2sgc3RhdHVzOiAldSIsIHJlc3VsdCk7CisJCQli
cmVhazsKKwl9CisKKwlyZXR1cm4gZmFsc2U7CQkJCS8qIGtlZXAgY29tcGlsZXIgcXVpZXQgKi8K
K30KKworc3RhdGljIGJvb2wKK3JpX2Zhc3RwYXRoX2lzX2FwcGxpY2FibGUoY29uc3QgUklfQ29u
c3RyYWludEluZm8gKnJpaW5mbykKK3sKKwkvKgorCSAqIFBhcnRpdGlvbmVkIHJlZmVyZW5jZWQg
dGFibGVzIGFyZSBza2lwcGVkIGZvciBzaW1wbGljaXR5LCBzaW5jZSB0aGV5CisJICogcmVxdWly
ZSByb3V0aW5nIHRoZSBwcm9iZSB0aHJvdWdoIHRoZSBjb3JyZWN0IHBhcnRpdGlvbiB1c2luZwor
CSAqIFBhcnRpdGlvbkRpcmVjdG9yeS4KKwkgKi8KKwlpZiAocmlpbmZvLT5wa19pc19wYXJ0aXRp
b25lZCkKKwkJcmV0dXJuIGZhbHNlOworCisJLyoKKwkgKiBUZW1wb3JhbCBmb3JlaWduIGtleXMg
dXNlIHJhbmdlIG92ZXJsYXAgYW5kIGNvbnRhaW5tZW50IHNlbWFudGljcyAoJiYsCisJICogPEAs
IHJhbmdlX2FnZygpKSB0aGF0IGluaGVyZW50bHkgaW52b2x2ZSBhZ2dyZWdhdGlvbiBhbmQgbXVs
dGlwbGUtcm93CisJICogcmVhc29uaW5nLCBzbyB0aGV5IHN0YXkgb24gdGhlIFNQSSBwYXRoLgor
CSAqLworCWlmIChyaWluZm8tPmhhc3BlcmlvZCkKKwkJcmV0dXJuIGZhbHNlOworCisJcmV0dXJu
IHRydWU7Cit9CisKKy8qCisgKiByaV9DaGVja1Blcm1pc3Npb25zCisgKiAgIENoZWNrIHRoYXQg
dGhlIGN1cnJlbnQgdXNlciBoYXMgcGVybWlzc2lvbnMgdG8gbG9vayBpbnRvIHRoZSBzY2hlbWEg
b2YKKyAqICAgYW5kIFNFTEVDVCBmcm9tICdxdWVyeV9yZWwnCisgKi8KK3N0YXRpYyB2b2lkCity
aV9DaGVja1Blcm1pc3Npb25zKFJlbGF0aW9uIHF1ZXJ5X3JlbCkKK3sKKwlBY2xSZXN1bHQJYWNs
cmVzdWx0OworCisJLyogVVNBR0Ugb24gc2NoZW1hLiAqLworCWFjbHJlc3VsdCA9IG9iamVjdF9h
Y2xjaGVjayhOYW1lc3BhY2VSZWxhdGlvbklkLAorCQkJCQkJCQlSZWxhdGlvbkdldE5hbWVzcGFj
ZShxdWVyeV9yZWwpLAorCQkJCQkJCQlHZXRVc2VySWQoKSwgQUNMX1VTQUdFKTsKKwlpZiAoYWNs
cmVzdWx0ICE9IEFDTENIRUNLX09LKQorCQlhY2xjaGVja19lcnJvcihhY2xyZXN1bHQsIE9CSkVD
VF9TQ0hFTUEsCisJCQkJCSAgIGdldF9uYW1lc3BhY2VfbmFtZShSZWxhdGlvbkdldE5hbWVzcGFj
ZShxdWVyeV9yZWwpKSk7CisKKwkvKiBTRUxFQ1Qgb24gcmVsYXRpb24uICovCisJYWNscmVzdWx0
ID0gcGdfY2xhc3NfYWNsY2hlY2soUmVsYXRpb25HZXRSZWxpZChxdWVyeV9yZWwpLCBHZXRVc2Vy
SWQoKSwKKwkJCQkJCQkJICBBQ0xfU0VMRUNUKTsKKwlpZiAoYWNscmVzdWx0ICE9IEFDTENIRUNL
X09LKQorCQlhY2xjaGVja19lcnJvcihhY2xyZXN1bHQsIE9CSkVDVF9UQUJMRSwKKwkJCQkJICAg
UmVsYXRpb25HZXRSZWxhdGlvbk5hbWUocXVlcnlfcmVsKSk7Cit9CisKKy8qCisgKiByZWNoZWNr
X21hdGNoZWRfcGtfdHVwbGUKKyAqCQlBZnRlciBmb2xsb3dpbmcgYW4gdXBkYXRlIGNoYWluICh0
bWZkLnRyYXZlcnNlZCksIHZlcmlmeSB0aGF0CisgKgkJdGhlIGxvY2tlZCBQSyB0dXBsZSBzdGls
bCBtYXRjaGVzIHRoZSBvcmlnaW5hbCBzZWFyY2gga2V5cy4KKyAqCisgKiBBIG5vbi1rZXkgdXBk
YXRlIChlLmcuIGNoYW5naW5nIGEgbm9uLVBLIGNvbHVtbikgY3JlYXRlcyBhIG5ldyB0dXBsZSB2
ZXJzaW9uCisgKiB0aGF0IHdlJ3ZlIG5vdyBsb2NrZWQsIGJ1dCB0aGUga2V5IGlzIHVuY2hhbmdl
ZCAtLSB0aGF0J3MgZmluZS4gIEEga2V5CisgKiB1cGRhdGUgbWVhbnMgdGhlIHZhbHVlIHdlIHdl
cmUgbG9va2luZyBmb3IgaXMgZ29uZSwgc28gd2Ugc2hvdWxkIHRyZWF0IGl0IGFzCisgKiBub3Qg
Zm91bmQuCisgKi8KK3N0YXRpYyBib29sCityZWNoZWNrX21hdGNoZWRfcGtfdHVwbGUoUmVsYXRp
b24gaWR4cmVsLCBTY2FuS2V5RGF0YSAqc2tleXMsCisJCQkJCQkgVHVwbGVUYWJsZVNsb3QgKm5l
d19zbG90KQoreworCS8qCisJICogVE9ETzogQnVpbGRJbmRleEluZm8gZG9lcyBhIHN5c2NhY2hl
IGxvb2t1cCArIHBhbGxvYyBvbiBldmVyeSBjYWxsLgorCSAqIFRoaXMgb25seSBmaXJlcyBvbiB0
aGUgY29uY3VycmVudC11cGRhdGUgcGF0aCAodG1mZC50cmF2ZXJzZWQpLCB3aGljaAorCSAqIHNo
b3VsZCBiZSByYXJlLCBzbyB0aGUgY29zdCBpcyBhY2NlcHRhYmxlIGZvciBub3cuICBJZiBwcm9m
aWxpbmcgc2hvd3MKKwkgKiBvdGhlcndpc2UsIGNhY2hlIHRoZSBJbmRleEluZm8gaW4gRmFzdFBh
dGhNZXRhLgorCSAqLworCUluZGV4SW5mbyAgKmluZGV4SW5mbyA9IEJ1aWxkSW5kZXhJbmZvKGlk
eHJlbCk7CisJRGF0dW0JCXZhbHVlc1tJTkRFWF9NQVhfS0VZU107CisJYm9vbAkJaXNudWxsW0lO
REVYX01BWF9LRVlTXTsKKwlib29sCQltYXRjaGVkID0gdHJ1ZTsKKworCS8qIFBLIGluZGV4ZXMg
bmV2ZXIgaGF2ZSB0aGVzZS4gKi8KKwlBc3NlcnQoaW5kZXhJbmZvLT5paV9FeHByZXNzaW9ucyA9
PSBOSUwgJiYKKwkJICAgaW5kZXhJbmZvLT5paV9FeGNsdXNpb25PcHMgPT0gTlVMTCk7CisKKwkv
KiBGb3JtIHRoZSBpbmRleCB2YWx1ZXMgYW5kIGlzbnVsbCBmbGFncyBnaXZlbiB0aGUgdGFibGUg
dHVwbGUuICovCisJRm9ybUluZGV4RGF0dW0oaW5kZXhJbmZvLCBuZXdfc2xvdCwgTlVMTCwgdmFs
dWVzLCBpc251bGwpOworCWZvciAoaW50IGkgPSAwOyBpIDwgaW5kZXhJbmZvLT5paV9OdW1JbmRl
eEtleUF0dHJzOyBpKyspCisJeworCQlTY2FuS2V5RGF0YSAqc2tleSA9ICZza2V5c1tpXTsKKwor
CQkvKiBBIFBLIGNvbHVtbiBjYW4gbmV2ZXIgYmUgc2V0IHRvIE5VTEwuICovCisJCUFzc2VydCgh
aXNudWxsW2ldKTsKKwkJaWYgKCFEYXR1bUdldEJvb2woRnVuY3Rpb25DYWxsMkNvbGwoJnNrZXkt
PnNrX2Z1bmMsCisJCQkJCQkJCQkJCXNrZXktPnNrX2NvbGxhdGlvbiwKKwkJCQkJCQkJCQkJdmFs
dWVzW2ldLAorCQkJCQkJCQkJCQlza2V5LT5za19hcmd1bWVudCkpKQorCQl7CisJCQltYXRjaGVk
ID0gZmFsc2U7CisJCQlicmVhazsKKwkJfQorCX0KKworCXJldHVybiBtYXRjaGVkOworfQorCisv
KgorICogYnVpbGRfaW5kZXhfc2NhbmtleXMKKyAqCQlCdWlsZCBTY2FuS2V5cyBmb3IgYSBkaXJl
Y3QgaW5kZXggcHJvYmUgb2YgdGhlIFBLJ3MgdW5pcXVlIGluZGV4LgorICoKKyAqIFVzZXMgY2Fj
aGVkIGNvbXBhcmUgZW50cmllcywgb3BlcmF0b3IgcHJvY2VkdXJlcywgYW5kIHN0cmF0ZWd5IG51
bWJlcnMKKyAqIGZyb20gcmlfcG9wdWxhdGVfZmFzdHBhdGhfbWV0YWRhdGEoKSByYXRoZXIgdGhh
biBsb29raW5nIHRoZW0gdXAgb24KKyAqIGVhY2ggaW52b2NhdGlvbi4gIENhc3RzIEZLIHZhbHVl
cyB0byB0aGUgb3BlcmF0b3IncyBleHBlY3RlZCBpbnB1dAorICogdHlwZSBpZiBuZWVkZWQuCisg
Ki8KK3N0YXRpYyB2b2lkCitidWlsZF9pbmRleF9zY2Fua2V5cyhjb25zdCBSSV9Db25zdHJhaW50
SW5mbyAqcmlpbmZvLAorCQkJCQkgUmVsYXRpb24gaWR4X3JlbCwgRGF0dW0gKnBrX3ZhbHMsCisJ
CQkJCSBjaGFyICpwa19udWxscywgU2NhbktleSBza2V5cykKK3sKKwlGYXN0UGF0aE1ldGEgKmZw
bWV0YSA9IHJpaW5mby0+ZnBtZXRhOworCisJQXNzZXJ0KGZwbWV0YSk7CisKKwkvKgorCSAqIE1h
eSBuZWVkIHRvIGNhc3QgZWFjaCBvZiB0aGUgaW5kaXZpZHVhbCB2YWx1ZXMgb2YgdGhlIGZvcmVp
Z24ga2V5IHRvCisJICogdGhlIGNvcnJlc3BvbmRpbmcgUEsgY29sdW1uJ3MgdHlwZSBpZiB0aGUg
ZXF1YWxpdHkgb3BlcmF0b3IgZGVtYW5kcyBpdC4KKwkgKi8KKwlmb3IgKGludCBpID0gMDsgaSA8
IHJpaW5mby0+bmtleXM7IGkrKykKKwl7CisJCWlmIChwa19udWxsc1tpXSAhPSAnbicpCisJCXsK
KwkJCVJJX0NvbXBhcmVIYXNoRW50cnkgKmVudHJ5ID0gZnBtZXRhLT5jb21wYXJlX2VudHJpZXNb
aV07CisKKwkJCWlmIChPaWRJc1ZhbGlkKGVudHJ5LT5jYXN0X2Z1bmNfZmluZm8uZm5fb2lkKSkK
KwkJCQlwa192YWxzW2ldID0gRnVuY3Rpb25DYWxsMygmZW50cnktPmNhc3RfZnVuY19maW5mbywK
KwkJCQkJCQkJCQkgICBwa192YWxzW2ldLAorCQkJCQkJCQkJCSAgIEludDMyR2V0RGF0dW0oLTEp
LAkvKiB0eXBtb2QgKi8KKwkJCQkJCQkJCQkgICBCb29sR2V0RGF0dW0oZmFsc2UpKTsJLyogaW1w
bGljaXQgY29lcmNpb24gKi8KKwkJfQorCX0KKworCS8qCisJICogU2V0IHVwIFNjYW5LZXlzIGZv
ciB0aGUgaW5kZXggc2Nhbi4gVGhpcyBpcyBlc3NlbnRpYWxseSBob3cKKwkgKiBFeGVjSW5kZXhC
dWlsZFNjYW5LZXlzKCkgc2V0cyB0aGVtIHVwLgorCSAqLworCWZvciAoaW50IGkgPSAwOyBpIDwg
cmlpbmZvLT5ua2V5czsgaSsrKQorCXsKKwkJaW50CQkJcGthdHRybm8gPSBpICsgMTsKKworCQlT
Y2FuS2V5RW50cnlJbml0aWFsaXplKCZza2V5c1tpXSwgMCwgcGthdHRybm8sCisJCQkJCQkJICAg
ZnBtZXRhLT5zdHJhdHNbaV0sIGZwbWV0YS0+c3VidHlwZXNbaV0sCisJCQkJCQkJICAgaWR4X3Jl
bC0+cmRfaW5kY29sbGF0aW9uW2ldLCBmcG1ldGEtPnJlZ29wc1tpXSwKKwkJCQkJCQkgICBwa192
YWxzW2ldKTsKKwl9Cit9CisKKy8qCisgKiByaV9wb3B1bGF0ZV9mYXN0cGF0aF9tZXRhZGF0YQor
ICoJCUNhY2hlIHBlci1rZXkgbWV0YWRhdGEgbmVlZGVkIGJ5IGJ1aWxkX2luZGV4X3NjYW5rZXlz
KCkuCisgKgorICogTG9va3MgdXAgdGhlIGNvbXBhcmUgaGFzaCBlbnRyeSwgb3BlcmF0b3IgcHJv
Y2VkdXJlIE9JRCwgYW5kIGluZGV4CisgKiBzdHJhdGVneS9zdWJ0eXBlIGZvciBlYWNoIGtleSBj
b2x1bW4uICBDYWxsZWQgbGF6aWx5IG9uIGZpcnN0IHVzZQorICogYW5kIHBlcnNpc3RzIGZvciB0
aGUgbGlmZXRpbWUgb2YgdGhlIFJJX0NvbnN0cmFpbnRJbmZvIGVudHJ5LgorICovCitzdGF0aWMg
dm9pZAorcmlfcG9wdWxhdGVfZmFzdHBhdGhfbWV0YWRhdGEoUklfQ29uc3RyYWludEluZm8gKnJp
aW5mbywKKwkJCQkJCQkgIFJlbGF0aW9uIGZrX3JlbCwgUmVsYXRpb24gaWR4X3JlbCkKK3sKKwlG
YXN0UGF0aE1ldGEgKmZwbWV0YTsKKwlNZW1vcnlDb250ZXh0IG9sZGN4dCA9IE1lbW9yeUNvbnRl
eHRTd2l0Y2hUbyhUb3BNZW1vcnlDb250ZXh0KTsKKworCUFzc2VydChyaWluZm8gIT0gTlVMTCAm
JiByaWluZm8tPnZhbGlkKTsKKworCWZwbWV0YSA9IHBhbGxvY19vYmplY3QoRmFzdFBhdGhNZXRh
KTsKKwlmb3IgKGludCBpID0gMDsgaSA8IHJpaW5mby0+bmtleXM7IGkrKykKKwl7CisJCU9pZAkJ
CWVxX29wciA9IHJpaW5mby0+cGZfZXFfb3Byc1tpXTsKKwkJT2lkCQkJdHlwZWlkID0gUklBdHRU
eXBlKGZrX3JlbCwgcmlpbmZvLT5ma19hdHRudW1zW2ldKTsKKwkJT2lkCQkJbGVmdHR5cGU7CisJ
CVJJX0NvbXBhcmVIYXNoRW50cnkgKmVudHJ5ID0gcmlfSGFzaENvbXBhcmVPcChlcV9vcHIsIHR5
cGVpZCk7CisKKwkJZnBtZXRhLT5jb21wYXJlX2VudHJpZXNbaV0gPSBlbnRyeTsKKwkJZnBtZXRh
LT5yZWdvcHNbaV0gPSBnZXRfb3Bjb2RlKGVxX29wcik7CisKKwkJZ2V0X29wX29wZmFtaWx5X3By
b3BlcnRpZXMoZXFfb3ByLAorCQkJCQkJCQkgICBpZHhfcmVsLT5yZF9vcGZhbWlseVtpXSwKKwkJ
CQkJCQkJICAgZmFsc2UsCisJCQkJCQkJCSAgICZmcG1ldGEtPnN0cmF0c1tpXSwKKwkJCQkJCQkJ
ICAgJmxlZnR0eXBlLAorCQkJCQkJCQkgICAmZnBtZXRhLT5zdWJ0eXBlc1tpXSk7CisJfQorCisJ
cmlpbmZvLT5mcG1ldGEgPSBmcG1ldGE7CisJTWVtb3J5Q29udGV4dFN3aXRjaFRvKG9sZGN4dCk7
Cit9CisKIC8qCiAgKiBFeHRyYWN0IGZpZWxkcyBmcm9tIGEgdHVwbGUgaW50byBEYXR1bS9udWxs
cyBhcnJheXMKICAqLwpAQCAtMzE2OSw4ICszNjAxLDE2IEBAIHJpX0hhc2hDb21wYXJlT3AoT2lk
IGVxX29wciwgT2lkIHR5cGVpZCkKIAkJICogbW9tZW50IHNpbmNlIHRoYXQgd2lsbCBuZXZlciBi
ZSBnZW5lcmF0ZWQgZm9yIGltcGxpY2l0IGNvZXJjaW9ucy4KIAkJICovCiAJCW9wX2lucHV0X3R5
cGVzKGVxX29wciwgJmxlZnR0eXBlLCAmcmlnaHR0eXBlKTsKLQkJQXNzZXJ0KGxlZnR0eXBlID09
IHJpZ2h0dHlwZSk7Ci0JCWlmICh0eXBlaWQgPT0gbGVmdHR5cGUpCisKKwkJLyoKKwkJICogRG9u
J3QgbmVlZCB0byBjYXN0IGlmIHRoZSBGSyBjb2x1bW4gdHlwZSBhbHJlYWR5IG1hdGNoZXMgd2hh
dCB0aGUKKwkJICogb3BlcmF0b3IgZXhwZWN0cy4gIEZvciBzYW1lLXR5cGUgb3BlcmF0b3JzLCB0
aGF0J3MgdGhlIGNvbW1vbiB0eXBlLgorCQkgKiBGb3IgY3Jvc3MtdHlwZSBvcGVyYXRvcnMgKGUu
Zy4gaW50NDhlcSBmb3IgaW50NCBQSyAvIGludDggRkspLCB0aGUKKwkJICogRksgdmFsdWUgaXMg
dGhlIHJpZ2h0IG9wZXJhbmQsIHNvIHNraXAgdGhlIGNhc3QgaWYgdHlwZWlkIG1hdGNoZXMKKwkJ
ICogcmlnaHR0eXBlLgorCQkgKi8KKwkJaWYgKChsZWZ0dHlwZSA9PSByaWdodHR5cGUgJiYgdHlw
ZWlkID09IGxlZnR0eXBlKSB8fAorCQkJKGxlZnR0eXBlICE9IHJpZ2h0dHlwZSAmJiB0eXBlaWQg
PT0gcmlnaHR0eXBlKSkKIAkJCWNhc3RmdW5jID0gSW52YWxpZE9pZDsJLyogc2ltcGxlc3QgY2Fz
ZSAqLwogCQllbHNlCiAJCXsKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L2lzb2xhdGlvbi9leHBlY3Rl
ZC9may1jb25jdXJyZW50LXBrLXVwZC5vdXQgYi9zcmMvdGVzdC9pc29sYXRpb24vZXhwZWN0ZWQv
ZmstY29uY3VycmVudC1way11cGQub3V0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw
MDAwMDAwLi40ZGQ5NTM1ZDNjMAotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0L2lzb2xhdGlv
bi9leHBlY3RlZC9may1jb25jdXJyZW50LXBrLXVwZC5vdXQKQEAgLTAsMCArMSwxMDUgQEAKK1Bh
cnNlZCB0ZXN0IHNwZWMgd2l0aCAzIHNlc3Npb25zCisKK3N0YXJ0aW5nIHBlcm11dGF0aW9uOiBz
MmIgczJ1a2V5IHMxYiBzMWkgczJjIHMxYyBzMnMgczFzCitzdGVwIHMyYjogQkVHSU47CitzdGVw
IHMydWtleTogVVBEQVRFIHBhcmVudCBTRVQgcGFyZW50X2tleSA9IDIgV0hFUkUgcGFyZW50X2tl
eSA9IDE7CitzdGVwIHMxYjogQkVHSU47CitzdGVwIHMxaTogSU5TRVJUIElOVE8gY2hpbGQgVkFM
VUVTICgxLCAxKTsgPHdhaXRpbmcgLi4uPgorc3RlcCBzMmM6IENPTU1JVDsKK3N0ZXAgczFpOiA8
Li4uIGNvbXBsZXRlZD4KK0VSUk9SOiAgaW5zZXJ0IG9yIHVwZGF0ZSBvbiB0YWJsZSAiY2hpbGQi
IHZpb2xhdGVzIGZvcmVpZ24ga2V5IGNvbnN0cmFpbnQgImNoaWxkX3BhcmVudF9rZXlfZmtleSIK
K3N0ZXAgczFjOiBDT01NSVQ7CitzdGVwIHMyczogU0VMRUNUICogRlJPTSBwYXJlbnQ7CitwYXJl
bnRfa2V5fGF1eAorLS0tLS0tLS0tLSstLS0KKyAgICAgICAgIDJ8Zm9vCisoMSByb3cpCisKK3N0
ZXAgczFzOiBTRUxFQ1QgKiBGUk9NIGNoaWxkOworY2hpbGRfa2V5fHBhcmVudF9rZXkKKy0tLS0t
LS0tLSstLS0tLS0tLS0tCisoMCByb3dzKQorCisKK3N0YXJ0aW5nIHBlcm11dGF0aW9uOiBzMmIg
czJ1YXV4IHMxYiBzMWkgczJjIHMxYyBzMnMgczFzCitzdGVwIHMyYjogQkVHSU47CitzdGVwIHMy
dWF1eDogVVBEQVRFIHBhcmVudCBTRVQgYXV4ID0gJ2JhcicgV0hFUkUgcGFyZW50X2tleSA9IDE7
CitzdGVwIHMxYjogQkVHSU47CitzdGVwIHMxaTogSU5TRVJUIElOVE8gY2hpbGQgVkFMVUVTICgx
LCAxKTsKK3N0ZXAgczJjOiBDT01NSVQ7CitzdGVwIHMxYzogQ09NTUlUOworc3RlcCBzMnM6IFNF
TEVDVCAqIEZST00gcGFyZW50OworcGFyZW50X2tleXxhdXgKKy0tLS0tLS0tLS0rLS0tCisgICAg
ICAgICAxfGJhcgorKDEgcm93KQorCitzdGVwIHMxczogU0VMRUNUICogRlJPTSBjaGlsZDsKK2No
aWxkX2tleXxwYXJlbnRfa2V5CistLS0tLS0tLS0rLS0tLS0tLS0tLQorICAgICAgICAxfCAgICAg
ICAgIDEKKygxIHJvdykKKworCitzdGFydGluZyBwZXJtdXRhdGlvbjogczJiIHMydWtleSBzMWIg
czFpIHMydWtleTIgczJjIHMxYyBzMnMgczFzCitzdGVwIHMyYjogQkVHSU47CitzdGVwIHMydWtl
eTogVVBEQVRFIHBhcmVudCBTRVQgcGFyZW50X2tleSA9IDIgV0hFUkUgcGFyZW50X2tleSA9IDE7
CitzdGVwIHMxYjogQkVHSU47CitzdGVwIHMxaTogSU5TRVJUIElOVE8gY2hpbGQgVkFMVUVTICgx
LCAxKTsgPHdhaXRpbmcgLi4uPgorc3RlcCBzMnVrZXkyOiBVUERBVEUgcGFyZW50IFNFVCBwYXJl
bnRfa2V5ID0gMSBXSEVSRSBwYXJlbnRfa2V5ID0gMjsKK3N0ZXAgczJjOiBDT01NSVQ7CitzdGVw
IHMxaTogPC4uLiBjb21wbGV0ZWQ+CitzdGVwIHMxYzogQ09NTUlUOworc3RlcCBzMnM6IFNFTEVD
VCAqIEZST00gcGFyZW50OworcGFyZW50X2tleXxhdXgKKy0tLS0tLS0tLS0rLS0tCisgICAgICAg
ICAxfGZvbworKDEgcm93KQorCitzdGVwIHMxczogU0VMRUNUICogRlJPTSBjaGlsZDsKK2NoaWxk
X2tleXxwYXJlbnRfa2V5CistLS0tLS0tLS0rLS0tLS0tLS0tLQorICAgICAgICAxfCAgICAgICAg
IDEKKygxIHJvdykKKworCitzdGFydGluZyBwZXJtdXRhdGlvbjogczJiIHMydWtleSBzM2IgczNp
IHMyYyBzM2MgczJzIHMzcworc3RlcCBzMmI6IEJFR0lOOworc3RlcCBzMnVrZXk6IFVQREFURSBw
YXJlbnQgU0VUIHBhcmVudF9rZXkgPSAyIFdIRVJFIHBhcmVudF9rZXkgPSAxOworc3RlcCBzM2I6
IEJFR0lOIElTT0xBVElPTiBMRVZFTCBSRVBFQVRBQkxFIFJFQUQ7CitzdGVwIHMzaTogSU5TRVJU
IElOVE8gY2hpbGQgVkFMVUVTICgyLCAxKTsgPHdhaXRpbmcgLi4uPgorc3RlcCBzMmM6IENPTU1J
VDsKK3N0ZXAgczNpOiA8Li4uIGNvbXBsZXRlZD4KK0VSUk9SOiAgY291bGQgbm90IHNlcmlhbGl6
ZSBhY2Nlc3MgZHVlIHRvIGNvbmN1cnJlbnQgdXBkYXRlCitzdGVwIHMzYzogQ09NTUlUOworc3Rl
cCBzMnM6IFNFTEVDVCAqIEZST00gcGFyZW50OworcGFyZW50X2tleXxhdXgKKy0tLS0tLS0tLS0r
LS0tCisgICAgICAgICAyfGZvbworKDEgcm93KQorCitzdGVwIHMzczogU0VMRUNUICogRlJPTSBj
aGlsZDsKK2NoaWxkX2tleXxwYXJlbnRfa2V5CistLS0tLS0tLS0rLS0tLS0tLS0tLQorKDAgcm93
cykKKworCitzdGFydGluZyBwZXJtdXRhdGlvbjogczJiIHMydWF1eCBzM2IgczNpIHMyYyBzM2Mg
czJzIHMzcworc3RlcCBzMmI6IEJFR0lOOworc3RlcCBzMnVhdXg6IFVQREFURSBwYXJlbnQgU0VU
IGF1eCA9ICdiYXInIFdIRVJFIHBhcmVudF9rZXkgPSAxOworc3RlcCBzM2I6IEJFR0lOIElTT0xB
VElPTiBMRVZFTCBSRVBFQVRBQkxFIFJFQUQ7CitzdGVwIHMzaTogSU5TRVJUIElOVE8gY2hpbGQg
VkFMVUVTICgyLCAxKTsKK3N0ZXAgczJjOiBDT01NSVQ7CitzdGVwIHMzYzogQ09NTUlUOworc3Rl
cCBzMnM6IFNFTEVDVCAqIEZST00gcGFyZW50OworcGFyZW50X2tleXxhdXgKKy0tLS0tLS0tLS0r
LS0tCisgICAgICAgICAxfGJhcgorKDEgcm93KQorCitzdGVwIHMzczogU0VMRUNUICogRlJPTSBj
aGlsZDsKK2NoaWxkX2tleXxwYXJlbnRfa2V5CistLS0tLS0tLS0rLS0tLS0tLS0tLQorICAgICAg
ICAyfCAgICAgICAgIDEKKygxIHJvdykKKwpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvaXNvbGF0aW9u
L2lzb2xhdGlvbl9zY2hlZHVsZSBiL3NyYy90ZXN0L2lzb2xhdGlvbi9pc29sYXRpb25fc2NoZWR1
bGUKaW5kZXggNGU0NjY1ODBjZDQuLmMxYTk5OWJmMWQyIDEwMDY0NAotLS0gYS9zcmMvdGVzdC9p
c29sYXRpb24vaXNvbGF0aW9uX3NjaGVkdWxlCisrKyBiL3NyYy90ZXN0L2lzb2xhdGlvbi9pc29s
YXRpb25fc2NoZWR1bGUKQEAgLTM3LDYgKzM3LDcgQEAgdGVzdDogZmstcGFydGl0aW9uZWQtMgog
dGVzdDogZmstc25hcHNob3QKIHRlc3Q6IGZrLXNuYXBzaG90LTIKIHRlc3Q6IGZrLXNuYXBzaG90
LTMKK3Rlc3Q6IGZrLWNvbmN1cnJlbnQtcGstdXBkCiB0ZXN0OiBzdWJ4aWQtb3ZlcmZsb3cKIHRl
c3Q6IGV2YWwtcGxhbi1xdWFsCiB0ZXN0OiBldmFsLXBsYW4tcXVhbC10cmlnZ2VyCmRpZmYgLS1n
aXQgYS9zcmMvdGVzdC9pc29sYXRpb24vc3BlY3MvZmstY29uY3VycmVudC1way11cGQuc3BlYyBi
L3NyYy90ZXN0L2lzb2xhdGlvbi9zcGVjcy9may1jb25jdXJyZW50LXBrLXVwZC5zcGVjCm5ldyBm
aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi4wM2RjN2YyNjBjZAotLS0gL2Rldi9u
dWxsCisrKyBiL3NyYy90ZXN0L2lzb2xhdGlvbi9zcGVjcy9may1jb25jdXJyZW50LXBrLXVwZC5z
cGVjCkBAIC0wLDAgKzEsNTMgQEAKKyMgVGVzdHMgdGhhdCBhbiBJTlNFUlQgb24gcmVmZXJlbmNp
bmcgdGFibGUgY29ycmVjdGx5IGZhaWxzIHdoZW4KKyMgdGhlIHJlZmVyZW5jZWQgdmFsdWUgZGlz
YXBwZWFycyBkdWUgdG8gYSBjb25jdXJyZW50IHVwZGF0ZQorc2V0dXAKK3sKKyAgQ1JFQVRFIFRB
QkxFIHBhcmVudCAoCisgICAgcGFyZW50X2tleSBpbnQgUFJJTUFSWSBLRVksCisgICAgYXV4ICAg
dGV4dCBOT1QgTlVMTAorICApOworCisgIENSRUFURSBUQUJMRSBjaGlsZCAoCisgICAgY2hpbGRf
a2V5IGludCBQUklNQVJZIEtFWSwKKyAgICBwYXJlbnRfa2V5IGludDggTk9UIE5VTEwgUkVGRVJF
TkNFUyBwYXJlbnQKKyAgKTsKKworICBJTlNFUlQgSU5UTyBwYXJlbnQgVkFMVUVTICgxLCAnZm9v
Jyk7Cit9CisKK3RlYXJkb3duCit7CisgIERST1AgVEFCTEUgcGFyZW50LCBjaGlsZDsKK30KKwor
c2Vzc2lvbiBzMQorc3RlcCBzMWIgIHsgQkVHSU47IH0KK3N0ZXAgczFpIHsgSU5TRVJUIElOVE8g
Y2hpbGQgVkFMVUVTICgxLCAxKTsgfQorc3RlcCBzMWMgeyBDT01NSVQ7IH0KK3N0ZXAgczFzIHsg
U0VMRUNUICogRlJPTSBjaGlsZDsgfQorCitzZXNzaW9uIHMyCitzdGVwIHMyYiAgeyBCRUdJTjsg
fQorc3RlcCBzMnVrZXkgeyBVUERBVEUgcGFyZW50IFNFVCBwYXJlbnRfa2V5ID0gMiBXSEVSRSBw
YXJlbnRfa2V5ID0gMTsgfQorc3RlcCBzMnVhdXggeyBVUERBVEUgcGFyZW50IFNFVCBhdXggPSAn
YmFyJyBXSEVSRSBwYXJlbnRfa2V5ID0gMTsgfQorc3RlcCBzMnVrZXkyIHsgVVBEQVRFIHBhcmVu
dCBTRVQgcGFyZW50X2tleSA9IDEgV0hFUkUgcGFyZW50X2tleSA9IDI7IH0KK3N0ZXAgczJjIHsg
Q09NTUlUOyB9CitzdGVwIHMycyB7IFNFTEVDVCAqIEZST00gcGFyZW50OyB9CisKK3Nlc3Npb24g
czMKK3N0ZXAgczNiIHsgQkVHSU4gSVNPTEFUSU9OIExFVkVMIFJFUEVBVEFCTEUgUkVBRDsgfQor
c3RlcCBzM2kgeyBJTlNFUlQgSU5UTyBjaGlsZCBWQUxVRVMgKDIsIDEpOyB9CitzdGVwIHMzYyB7
IENPTU1JVDsgfQorc3RlcCBzM3MgeyBTRUxFQ1QgKiBGUk9NIGNoaWxkOyB9CisKKyMgZmFpbAor
cGVybXV0YXRpb24gczJiIHMydWtleSBzMWIgczFpIHMyYyBzMWMgczJzIHMxcworIyBvaworcGVy
bXV0YXRpb24gczJiIHMydWF1eCBzMWIgczFpIHMyYyBzMWMgczJzIHMxcworIyBvaworcGVybXV0
YXRpb24gczJiIHMydWtleSBzMWIgczFpIHMydWtleTIgczJjIHMxYyBzMnMgczFzCisKKyMgUlI6
IGtleSB1cGRhdGUgLT4gc2VyaWFsaXphdGlvbiBmYWlsdXJlCitwZXJtdXRhdGlvbiBzMmIgczJ1
a2V5IHMzYiBzM2kgczJjIHMzYyBzMnMgczNzCisjIFJSOiBub24ta2V5IHVwZGF0ZSAtPiBvbGQg
dmVyc2lvbiB2aXNpYmxlIHZpYSB0cmFuc2FjdGlvbiBzbmFwc2hvdAorcGVybXV0YXRpb24gczJi
IHMydWF1eCBzM2IgczNpIHMyYyBzM2MgczJzIHMzcwpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvcmVn
cmVzcy9leHBlY3RlZC9mb3JlaWduX2tleS5vdXQgYi9zcmMvdGVzdC9yZWdyZXNzL2V4cGVjdGVk
L2ZvcmVpZ25fa2V5Lm91dAppbmRleCA5YWU0ZGJmMWIwYS4uMDgyNmY1MTgwMDQgMTAwNjQ0Ci0t
LSBhL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvZm9yZWlnbl9rZXkub3V0CisrKyBiL3NyYy90
ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvZm9yZWlnbl9rZXkub3V0CkBAIC0zNzAsNiArMzcwLDUzIEBA
IFNFTEVDVCAqIEZST00gUEtUQUJMRTsKIERST1AgVEFCTEUgRktUQUJMRTsKIERST1AgVEFCTEUg
UEtUQUJMRTsKIC0tCistLSBDaGVjayBSTFMKKy0tCitDUkVBVEUgVEFCTEUgUEtUQUJMRSAoIHB0
ZXN0MSBpbnQgUFJJTUFSWSBLRVksIHB0ZXN0MiB0ZXh0ICk7CitDUkVBVEUgVEFCTEUgRktUQUJM
RSAoIGZ0ZXN0MSBpbnQgUkVGRVJFTkNFUyBQS1RBQkxFLCBmdGVzdDIgaW50ICk7CistLSBJbnNl
cnQgdGVzdCBkYXRhIGludG8gUEtUQUJMRQorSU5TRVJUIElOVE8gUEtUQUJMRSBWQUxVRVMgKDEs
ICdUZXN0MScpOworSU5TRVJUIElOVE8gUEtUQUJMRSBWQUxVRVMgKDIsICdUZXN0MicpOworSU5T
RVJUIElOVE8gUEtUQUJMRSBWQUxVRVMgKDMsICdUZXN0MycpOworLS0gR3JhbnQgcHJpdmlsZWdl
cyBvbiBQS1RBQkxFL0ZLVEFCTEUgdG8gdXNlciByZWdyZXNzX2ZvcmVpZ25fa2V5X3VzZXIKK0NS
RUFURSBVU0VSIHJlZ3Jlc3NfZm9yZWlnbl9rZXlfdXNlciBOT0xPR0lOOworR1JBTlQgU0VMRUNU
IE9OIFBLVEFCTEUgVE8gcmVncmVzc19mb3JlaWduX2tleV91c2VyOworR1JBTlQgU0VMRUNULCBJ
TlNFUlQgT04gRktUQUJMRSBUTyByZWdyZXNzX2ZvcmVpZ25fa2V5X3VzZXI7CistLSBFbmFibGUg
UkxTIG9uIFBLVEFCTEUgYW5kIENyZWF0ZSBwb2xpY2llcworQUxURVIgVEFCTEUgUEtUQUJMRSBF
TkFCTEUgUk9XIExFVkVMIFNFQ1VSSVRZOworQ1JFQVRFIFBPTElDWSBwa3RhYmxlX3ZpZXdfb2Rk
X3BvbGljeSBPTiBQS1RBQkxFIFRPIHJlZ3Jlc3NfZm9yZWlnbl9rZXlfdXNlciBVU0lORyAocHRl
c3QxICUgMiA9IDEpOworQUxURVIgVEFCTEUgUEtUQUJMRSBPV05FUiB0byByZWdyZXNzX2ZvcmVp
Z25fa2V5X3VzZXI7CitTRVQgUk9MRSByZWdyZXNzX2ZvcmVpZ25fa2V5X3VzZXI7CitJTlNFUlQg
SU5UTyBGS1RBQkxFIFZBTFVFUyAoMywgNSk7CitJTlNFUlQgSU5UTyBGS1RBQkxFIFZBTFVFUyAo
MiwgNSk7IC0tIHN1Y2Nlc3MsIFJFRkVSRU5DRVMgYXJlIG5vdCBzdWJqZWN0IHRvIHJvdyBzZWN1
cml0eQorUkVTRVQgUk9MRTsKK0RST1AgVEFCTEUgRktUQUJMRTsKK0RST1AgVEFCTEUgUEtUQUJM
RTsKK0RST1AgVVNFUiByZWdyZXNzX2ZvcmVpZ25fa2V5X3VzZXI7CistLQorLS0gQ2hlY2sgQUNM
CistLQorQ1JFQVRFIFRBQkxFIFBLVEFCTEUgKCBwdGVzdDEgaW50IFBSSU1BUlkgS0VZLCBwdGVz
dDIgdGV4dCApOworQ1JFQVRFIFRBQkxFIEZLVEFCTEUgKCBmdGVzdDEgaW50IFJFRkVSRU5DRVMg
UEtUQUJMRSwgZnRlc3QyIGludCApOworLS0gSW5zZXJ0IHRlc3QgZGF0YSBpbnRvIFBLVEFCTEUK
K0lOU0VSVCBJTlRPIFBLVEFCTEUgVkFMVUVTICgxLCAnVGVzdDEnKTsKK0lOU0VSVCBJTlRPIFBL
VEFCTEUgVkFMVUVTICgyLCAnVGVzdDInKTsKK0lOU0VSVCBJTlRPIFBLVEFCTEUgVkFMVUVTICgz
LCAnVGVzdDMnKTsKKy0tIEdyYW50IHVzYWdlIG9uIFBLVEFCTEUgdG8gdXNlciByZWdyZXNzX2Zv
cmVpZ25fa2V5X3VzZXIKK0NSRUFURSBVU0VSIHJlZ3Jlc3NfZm9yZWlnbl9rZXlfdXNlciBOT0xP
R0lOOworR1JBTlQgU0VMRUNUIE9OIFBLVEFCTEUgVE8gcmVncmVzc19mb3JlaWduX2tleV91c2Vy
OworQUxURVIgVEFCTEUgUEtUQUJMRSBPV05FUiB0byByZWdyZXNzX2ZvcmVpZ25fa2V5X3VzZXI7
CistLSBJbnNlcnRpbmcgaW50byBGS1RBQkxFIHNob3VsZCB3b3JrCitJTlNFUlQgSU5UTyBGS1RB
QkxFIFZBTFVFUyAoMywgNSk7CistLSBSZXZva2UgdXNhZ2Ugb24gUEtUQUJMRSBmcm9tIHVzZXIg
cmVncmVzc19mb3JlaWduX2tleV91c2VyCitSRVZPS0UgU0VMRUNUIE9OIFBLVEFCTEUgRlJPTSBy
ZWdyZXNzX2ZvcmVpZ25fa2V5X3VzZXI7CistLSBJbnNlcnRpbmcgaW50byBGS1RBQkxFIHNob3Vs
ZCBmYWlsCitJTlNFUlQgSU5UTyBGS1RBQkxFIFZBTFVFUyAoMiwgNik7CitFUlJPUjogIHBlcm1p
c3Npb24gZGVuaWVkIGZvciB0YWJsZSBwa3RhYmxlCitEUk9QIFRBQkxFIEZLVEFCTEU7CitEUk9Q
IFRBQkxFIFBLVEFCTEU7CitEUk9QIFVTRVIgcmVncmVzc19mb3JlaWduX2tleV91c2VyOworLS0K
IC0tIENoZWNrIGluaXRpYWwgY2hlY2sgdXBvbiBBTFRFUiBUQUJMRQogLS0KIENSRUFURSBUQUJM
RSBQS1RBQkxFICggcHRlc3QxIGludCwgcHRlc3QyIGludCwgUFJJTUFSWSBLRVkocHRlc3QxLCBw
dGVzdDIpICk7CmRpZmYgLS1naXQgYS9zcmMvdGVzdC9yZWdyZXNzL3NxbC9mb3JlaWduX2tleS5z
cWwgYi9zcmMvdGVzdC9yZWdyZXNzL3NxbC9mb3JlaWduX2tleS5zcWwKaW5kZXggM2I4Yzk1YmY4
OTMuLmU5ZWUyOTMzMWNiIDEwMDY0NAotLS0gYS9zcmMvdGVzdC9yZWdyZXNzL3NxbC9mb3JlaWdu
X2tleS5zcWwKKysrIGIvc3JjL3Rlc3QvcmVncmVzcy9zcWwvZm9yZWlnbl9rZXkuc3FsCkBAIC0y
NDIsNiArMjQyLDcwIEBAIFNFTEVDVCAqIEZST00gUEtUQUJMRTsKIERST1AgVEFCTEUgRktUQUJM
RTsKIERST1AgVEFCTEUgUEtUQUJMRTsKIAorLS0KKy0tIENoZWNrIFJMUworLS0KK0NSRUFURSBU
QUJMRSBQS1RBQkxFICggcHRlc3QxIGludCBQUklNQVJZIEtFWSwgcHRlc3QyIHRleHQgKTsKK0NS
RUFURSBUQUJMRSBGS1RBQkxFICggZnRlc3QxIGludCBSRUZFUkVOQ0VTIFBLVEFCTEUsIGZ0ZXN0
MiBpbnQgKTsKKworLS0gSW5zZXJ0IHRlc3QgZGF0YSBpbnRvIFBLVEFCTEUKK0lOU0VSVCBJTlRP
IFBLVEFCTEUgVkFMVUVTICgxLCAnVGVzdDEnKTsKK0lOU0VSVCBJTlRPIFBLVEFCTEUgVkFMVUVT
ICgyLCAnVGVzdDInKTsKK0lOU0VSVCBJTlRPIFBLVEFCTEUgVkFMVUVTICgzLCAnVGVzdDMnKTsK
KworLS0gR3JhbnQgcHJpdmlsZWdlcyBvbiBQS1RBQkxFL0ZLVEFCTEUgdG8gdXNlciByZWdyZXNz
X2ZvcmVpZ25fa2V5X3VzZXIKK0NSRUFURSBVU0VSIHJlZ3Jlc3NfZm9yZWlnbl9rZXlfdXNlciBO
T0xPR0lOOworR1JBTlQgU0VMRUNUIE9OIFBLVEFCTEUgVE8gcmVncmVzc19mb3JlaWduX2tleV91
c2VyOworR1JBTlQgU0VMRUNULCBJTlNFUlQgT04gRktUQUJMRSBUTyByZWdyZXNzX2ZvcmVpZ25f
a2V5X3VzZXI7CisKKy0tIEVuYWJsZSBSTFMgb24gUEtUQUJMRSBhbmQgQ3JlYXRlIHBvbGljaWVz
CitBTFRFUiBUQUJMRSBQS1RBQkxFIEVOQUJMRSBST1cgTEVWRUwgU0VDVVJJVFk7CitDUkVBVEUg
UE9MSUNZIHBrdGFibGVfdmlld19vZGRfcG9saWN5IE9OIFBLVEFCTEUgVE8gcmVncmVzc19mb3Jl
aWduX2tleV91c2VyIFVTSU5HIChwdGVzdDEgJSAyID0gMSk7CisKK0FMVEVSIFRBQkxFIFBLVEFC
TEUgT1dORVIgdG8gcmVncmVzc19mb3JlaWduX2tleV91c2VyOworCitTRVQgUk9MRSByZWdyZXNz
X2ZvcmVpZ25fa2V5X3VzZXI7CisKK0lOU0VSVCBJTlRPIEZLVEFCTEUgVkFMVUVTICgzLCA1KTsK
K0lOU0VSVCBJTlRPIEZLVEFCTEUgVkFMVUVTICgyLCA1KTsgLS0gc3VjY2VzcywgUkVGRVJFTkNF
UyBhcmUgbm90IHN1YmplY3QgdG8gcm93IHNlY3VyaXR5CisKK1JFU0VUIFJPTEU7CisKK0RST1Ag
VEFCTEUgRktUQUJMRTsKK0RST1AgVEFCTEUgUEtUQUJMRTsKK0RST1AgVVNFUiByZWdyZXNzX2Zv
cmVpZ25fa2V5X3VzZXI7CisKKy0tCistLSBDaGVjayBBQ0wKKy0tCitDUkVBVEUgVEFCTEUgUEtU
QUJMRSAoIHB0ZXN0MSBpbnQgUFJJTUFSWSBLRVksIHB0ZXN0MiB0ZXh0ICk7CitDUkVBVEUgVEFC
TEUgRktUQUJMRSAoIGZ0ZXN0MSBpbnQgUkVGRVJFTkNFUyBQS1RBQkxFLCBmdGVzdDIgaW50ICk7
CisKKy0tIEluc2VydCB0ZXN0IGRhdGEgaW50byBQS1RBQkxFCitJTlNFUlQgSU5UTyBQS1RBQkxF
IFZBTFVFUyAoMSwgJ1Rlc3QxJyk7CitJTlNFUlQgSU5UTyBQS1RBQkxFIFZBTFVFUyAoMiwgJ1Rl
c3QyJyk7CitJTlNFUlQgSU5UTyBQS1RBQkxFIFZBTFVFUyAoMywgJ1Rlc3QzJyk7CisKKy0tIEdy
YW50IHVzYWdlIG9uIFBLVEFCTEUgdG8gdXNlciByZWdyZXNzX2ZvcmVpZ25fa2V5X3VzZXIKK0NS
RUFURSBVU0VSIHJlZ3Jlc3NfZm9yZWlnbl9rZXlfdXNlciBOT0xPR0lOOworR1JBTlQgU0VMRUNU
IE9OIFBLVEFCTEUgVE8gcmVncmVzc19mb3JlaWduX2tleV91c2VyOworCitBTFRFUiBUQUJMRSBQ
S1RBQkxFIE9XTkVSIHRvIHJlZ3Jlc3NfZm9yZWlnbl9rZXlfdXNlcjsKKworLS0gSW5zZXJ0aW5n
IGludG8gRktUQUJMRSBzaG91bGQgd29yaworSU5TRVJUIElOVE8gRktUQUJMRSBWQUxVRVMgKDMs
IDUpOworCistLSBSZXZva2UgdXNhZ2Ugb24gUEtUQUJMRSBmcm9tIHVzZXIgcmVncmVzc19mb3Jl
aWduX2tleV91c2VyCitSRVZPS0UgU0VMRUNUIE9OIFBLVEFCTEUgRlJPTSByZWdyZXNzX2ZvcmVp
Z25fa2V5X3VzZXI7CisKKy0tIEluc2VydGluZyBpbnRvIEZLVEFCTEUgc2hvdWxkIGZhaWwKK0lO
U0VSVCBJTlRPIEZLVEFCTEUgVkFMVUVTICgyLCA2KTsKKworRFJPUCBUQUJMRSBGS1RBQkxFOwor
RFJPUCBUQUJMRSBQS1RBQkxFOworCitEUk9QIFVTRVIgcmVncmVzc19mb3JlaWduX2tleV91c2Vy
OworCiAtLQogLS0gQ2hlY2sgaW5pdGlhbCBjaGVjayB1cG9uIEFMVEVSIFRBQkxFCiAtLQpkaWZm
IC0tZ2l0IGEvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QgYi9zcmMvdG9vbHMvcGdp
bmRlbnQvdHlwZWRlZnMubGlzdAppbmRleCA0NjczZWNhOWNkNi4uZjg0MGY0NzFiMzUgMTAwNjQ0
Ci0tLSBhL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0CisrKyBiL3NyYy90b29scy9w
Z2luZGVudC90eXBlZGVmcy5saXN0CkBAIC04MTEsNiArODExLDcgQEAgRXh0ZW5zaW9uSW5mbwog
RXh0ZW5zaW9uTG9jYXRpb24KIEV4dGVuc2lvblNpYmxpbmdDYWNoZQogRXh0ZW5zaW9uVmVyc2lv
bkluZm8KK0Zhc3RQYXRoTWV0YQogRkRXQ29sbGF0ZVN0YXRlCiBGRF9TRVQKIEZJTEUKLS0gCjIu
NDEuMAoK
--000000000000130115064d62f122
Content-Type: application/octet-stream;
	name="v8-0002-Cache-per-batch-resources-for-fast-path-foreign-k.patch"
Content-Disposition: attachment;
	filename="v8-0002-Cache-per-batch-resources-for-fast-path-foreign-k.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmxoe2la1>
X-Attachment-Id: f_mmxoe2la1

RnJvbSA1Yzk3ZjkwMzIzNWI3MmVkMDIxYTA5NTM4MWY0MDNmYmRmOGQyZTRmIE1vbiBTZXAgMTcg
MDA6MDA6MDAgMjAwMQpGcm9tOiBBbWl0IExhbmdvdGUgPGFtaXRsYW5AcG9zdGdyZXNxbC5vcmc+
CkRhdGU6IE1vbiwgMTYgTWFyIDIwMjYgMjA6NTc6MzUgKzA5MDAKU3ViamVjdDogW1BBVENIIHY4
IDIvM10gQ2FjaGUgcGVyLWJhdGNoIHJlc291cmNlcyBmb3IgZmFzdC1wYXRoIGZvcmVpZ24ga2V5
CiBjaGVja3MKClRoZSBmYXN0LXBhdGggRksgY2hlY2sgaW50cm9kdWNlZCBpbiB0aGUgcHJldmlv
dXMgY29tbWl0IG9wZW5zIGFuZApjbG9zZXMgdGhlIFBLIHJlbGF0aW9uLCBpbmRleCwgc2NhbiBk
ZXNjcmlwdG9yLCBhbmQgdHVwbGUgc2xvdCBvbgpldmVyeSB0cmlnZ2VyIGludm9jYXRpb24uICBG
b3IgYnVsayBvcGVyYXRpb25zIHRoYXQgZmlyZSB0aG91c2FuZHMgb2YKRksgdHJpZ2dlcnMgaW4g
YSBzaW5nbGUgc3RhdGVtZW50LCB0aGlzIHJlcGVhdGVkIHNldHVwL3RlYXJkb3duCmRvbWluYXRl
cyB0aGUgY29zdC4KCkludHJvZHVjZSBSSV9GYXN0UGF0aEVudHJ5LCBhIHBlci1jb25zdHJhaW50
IGhhc2ggdGFibGUgdGhhdCBjYWNoZXMKdGhlIG9wZW4gUmVsYXRpb24gKHBrX3JlbCwgaWR4X3Jl
bCksIEluZGV4U2NhbkRlc2MsIFR1cGxlVGFibGVTbG90LAphbmQgYSByZWdpc3RlcmVkIFNuYXBz
aG90IGFjcm9zcyBhbGwgdHJpZ2dlciBpbnZvY2F0aW9ucyB3aXRoaW4gYQpzaW5nbGUgdHJpZ2dl
ci1maXJpbmcgYmF0Y2guICBFbnRyaWVzIGFyZSBjcmVhdGVkIGxhemlseSBvbiBmaXJzdCB1c2UK
dmlhIHJpX0Zhc3RQYXRoR2V0RW50cnkoKSBhbmQgcGVyc2lzdCB1bnRpbCB0aGUgYmF0Y2ggZW5k
cy4KClRoZSBzbmFwc2hvdCBpcyByZWdpc3RlcmVkIG9uY2UgYXQgZW50cnkgY3JlYXRpb24gdGlt
ZSwgYW5kIGl0cwpjdXJjaWQgaXMgcGF0Y2hlZCBpbiBwbGFjZSBvbiBlYWNoIHN1YnNlcXVlbnQg
cm93IHJhdGhlciB0aGFuCnRha2luZyBhIGZyZXNoIHNuYXBzaG90IHBlciBpbnZvY2F0aW9uLiAg
VGhpcyBhdm9pZHMgdGhlIHBlci1yb3cKR2V0U25hcHNob3REYXRhKCkgY29zdC4gIFVuZGVyIFJF
UEVBVEFCTEUgUkVBRCB0aGUgdHJhbnNhY3Rpb24Kc25hcHNob3QgaXMgaW1tdXRhYmxlIHNvIGNh
Y2hpbmcgaXMgYSBuby1vcC4gIFVuZGVyIFJFQUQgQ09NTUlUVEVECnRoZSBjYWNoZWQgc25hcHNo
b3Qgd2lsbCBub3QgcmVmbGVjdCBQSyByb3dzIGNvbW1pdHRlZCBieSBvdGhlcgpiYWNrZW5kcyBt
aWQtYmF0Y2gsIGJ1dCB0aGlzIGlzIGFjY2VwdGFibGU6IHRoZSBGSyBjaGVjayBvbmx5IG5lZWRz
ClBLIHJvd3MgdmlzaWJsZSBiZWZvcmUgdGhlIHN0YXRlbWVudCBiZWdhbiBwbHVzIGVmZmVjdHMg
b2YgZWFybGllcgp0cmlnZ2VycyAodHJhY2tlZCBieSBjdXJjaWQpLCBjb25jdXJyZW50IGNvbW1p
dHMgd291bGQgbm90IGJlCnJlbGlhYmx5IHZpc2libGUgZXZlbiB3aXRoIHBlci1yb3cgc25hcHNo
b3RzIHNpbmNlIHRyaWdnZXIgZmlyaW5nCm9yZGVyIGlzIG5vbmRldGVybWluaXN0aWMsIGFuZCBM
b2NrVHVwbGVLZXlTaGFyZSBwcmV2ZW50cyB0aGUgUEsKcm93IGZyb20gZGlzYXBwZWFyaW5nIHJl
Z2FyZGxlc3MuCgpTbmFwc2hvdFNldENvbW1hbmRJZCgpIG9ubHkgcGF0Y2hlcyB0aGUgcHJvY2Vz
cy1nbG9iYWwgc3RhdGljcywgbm90CnJlZ2lzdGVyZWQgY29waWVzLCBzbyB3ZSBwYXRjaCBlbnRy
eS0+c25hcHNob3QtPmN1cmNpZCBkaXJlY3RseS4KClBlcm1pc3Npb24gY2hlY2tzIChzY2hlbWEg
VVNBR0UgKyB0YWJsZSBTRUxFQ1QpIGFyZSBwZXJmb3JtZWQgb25jZSBhdApjYWNoZSBlbnRyeSBj
cmVhdGlvbiByYXRoZXIgdGhhbiBwZXIgZmx1c2guICBUaGUgUkkgY2hlY2sgcnVucyBhcyB0aGUK
UEsgdGFibGUgb3duZXIgKHZpYSBTZXRVc2VySWRBbmRTZWNDb250ZXh0KSwgc28gaW4gcHJhY3Rp
Y2UgdGhlc2UKY2hlY2tzIHZlcmlmeSB0aGF0IHRoZSBvd25lciBoYXMgYWNjZXNzIHRvIHRoZWly
IG93biB0YWJsZSAtLSBhCmNvbmRpdGlvbiB0aGF0IGhvbGRzIHVubGVzcyBwcml2aWxlZ2VzIGhh
dmUgYmVlbiBleHBsaWNpdGx5IHJldm9rZWQKZnJvbSB0aGUgb3duZXIsIHdoaWNoIHdvdWxkIGVx
dWFsbHkgYnJlYWsgdGhlIFNQSSBwYXRoLiAgQ2hlY2tpbmcKb25jZSBwZXIgYmF0Y2ggYXZvaWRz
IHJlcGVhdGVkIHN5c2NhY2hlIGxvb2t1cHMgZnJvbQpwZ19jbGFzc19hY2xjaGVjaygpIHdpdGgg
bm8gdXNlci12aXNpYmxlIGJlaGF2aW9yIGNoYW5nZS4KCkxpZmVjeWNsZSBtYW5hZ2VtZW50OgoK
ICAtIEFmdGVyVHJpZ2dlckJhdGNoQ2FsbGJhY2s6IEEgbmV3IGdlbmVyYWwtcHVycG9zZSBjYWxs
YmFjawogICAgbWVjaGFuaXNtIGluIHRyaWdnZXIuYy4gIENhbGxiYWNrcyByZWdpc3RlcmVkIHZp
YQogICAgUmVnaXN0ZXJBZnRlclRyaWdnZXJCYXRjaENhbGxiYWNrKCkgZmlyZSBhdCB0aGUgZW5k
IG9mIGVhY2gKICAgIHRyaWdnZXItZmlyaW5nIGJhdGNoIChBZnRlclRyaWdnZXJFbmRRdWVyeSBm
b3IgaW1tZWRpYXRlCiAgICBjb25zdHJhaW50cywgQWZ0ZXJUcmlnZ2VyRmlyZURlZmVycmVkIGF0
IENPTU1JVCwgYW5kCiAgICBBZnRlclRyaWdnZXJTZXRTdGF0ZSBmb3IgU0VUIENPTlNUUkFJTlRT
IElNTUVESUFURSkuICBUaGUgUkkgY29kZQogICAgcmVnaXN0ZXJzIHJpX0Zhc3RQYXRoVGVhcmRv
d24gYXMgYSBiYXRjaCBjYWxsYmFjaywgd2hpY2ggZG9lcwogICAgb3JkZXJseSB0ZWFyZG93bjog
aW5kZXhfZW5kc2NhbiwgaW5kZXhfY2xvc2UsIHRhYmxlX2Nsb3NlLAogICAgRXhlY0Ryb3BTaW5n
bGVUdXBsZVRhYmxlU2xvdCwgVW5yZWdpc3RlclNuYXBzaG90LgoKICAtIFhhY3RDYWxsYmFjazog
cmlfRmFzdFBhdGhYYWN0Q2FsbGJhY2sgTlVMTHMgdGhlIHN0YXRpYyBjYWNoZQogICAgcG9pbnRl
ciBhdCB0cmFuc2FjdGlvbiBlbmQuICBPbiB0aGUgbm9ybWFsIHBhdGgsIGNsZWFudXAgYWxyZWFk
eQogICAgcmFuIHZpYSB0aGUgYmF0Y2ggY2FsbGJhY2s7IHRoaXMgaGFuZGxlcyB0aGUgYWJvcnQg
cGF0aCB3aGVyZQogICAgVG9wVHJhbnNhY3Rpb25Db250ZXh0IGRlc3RydWN0aW9uIGZyZWVzIHRo
ZSBtZW1vcnkgYnV0CiAgICBSZXNvdXJjZU93bmVyIGhhbmRsZXMgdGhlIGFjdHVhbCByZXNvdXJj
ZSBjbGVhbnVwLgoKICAtIFN1YlhhY3RDYWxsYmFjazogcmlfRmFzdFBhdGhTdWJYYWN0Q2FsbGJh
Y2sgTlVMTHMgdGhlIHN0YXRpYwogICAgY2FjaGUgcG9pbnRlciBvbiBzdWJ0cmFuc2FjdGlvbiBh
Ym9ydC4gIFJlc291cmNlT3duZXIgYWxyZWFkeQogICAgY2xlYW5lZCB1cCB0aGUgcmVzb3VyY2Vz
OyB0aGlzIHByZXZlbnRzIHRoZSBiYXRjaCBjYWxsYmFjayBmcm9tCiAgICB0cnlpbmcgdG8gZG91
YmxlLWNsb3NlIHRoZW0uCgogIC0gQWZ0ZXJUcmlnZ2VyQmF0Y2hJc0FjdGl2ZSgpOiBFeHBvcnRl
ZCBhY2Nlc3NvciB0aGF0IHJldHVybnMgdHJ1ZQogICAgd2hlbiBhZnRlclRyaWdnZXJzLnF1ZXJ5
X2RlcHRoID49IDAuICBEdXJpbmcgQUxURVIgVEFCTEUgLi4uIEFERAogICAgRk9SRUlHTiBLRVkg
dmFsaWRhdGlvbiwgUkkgdHJpZ2dlcnMgYXJlIGNhbGxlZCBkaXJlY3RseSBvdXRzaWRlCiAgICB0
aGUgYWZ0ZXItdHJpZ2dlciBmcmFtZXdvcmssIHNvIGJhdGNoIGNhbGxiYWNrcyB3b3VsZCBuZXZl
ciBmaXJlLgogICAgVGhlIGZhc3QtcGF0aCBjb2RlIHVzZXMgdGhpcyB0byBmYWxsIGJhY2sgdG8g
YSBub24tY2FjaGVkCiAgICBwZXItaW52b2NhdGlvbiBwYXRoIChvcGVuL3NjYW4vY2xvc2UgZWFj
aCBjYWxsKSBpbiB0aGF0IGNvbnRleHQuCi0tLQogc3JjL2JhY2tlbmQvY29tbWFuZHMvdHJpZ2dl
ci5jICAgICAgICAgICAgfCAgOTAgKysrKysrKwogc3JjL2JhY2tlbmQvdXRpbHMvYWR0L3JpX3Ry
aWdnZXJzLmMgICAgICAgfCAyNzUgKysrKysrKysrKysrKysrKysrKysrLQogc3JjL2luY2x1ZGUv
Y29tbWFuZHMvdHJpZ2dlci5oICAgICAgICAgICAgfCAgMTggKysKIHNyYy90ZXN0L3JlZ3Jlc3Mv
ZXhwZWN0ZWQvZm9yZWlnbl9rZXkub3V0IHwgIDg2ICsrKysrKysKIHNyYy90ZXN0L3JlZ3Jlc3Mv
c3FsL2ZvcmVpZ25fa2V5LnNxbCAgICAgIHwgIDgwICsrKysrKysKIHNyYy90b29scy9wZ2luZGVu
dC90eXBlZGVmcy5saXN0ICAgICAgICAgIHwgICAzICsKIDYgZmlsZXMgY2hhbmdlZCwgNTQ5IGlu
c2VydGlvbnMoKyksIDMgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29t
bWFuZHMvdHJpZ2dlci5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdHJpZ2dlci5jCmluZGV4IDY1
OTY4NDNhOGQ4Li5iNzQ0MmNmNmNiMSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMv
dHJpZ2dlci5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3RyaWdnZXIuYwpAQCAtMzg5Myw2
ICszODkzLDggQEAgdHlwZWRlZiBzdHJ1Y3QgQWZ0ZXJUcmlnZ2Vyc0RhdGEKIAkvKiBwZXItc3Vi
dHJhbnNhY3Rpb24tbGV2ZWwgZGF0YTogKi8KIAlBZnRlclRyaWdnZXJzVHJhbnNEYXRhICp0cmFu
c19zdGFjazsJLyogYXJyYXkgb2Ygc3RydWN0cyBzaG93biBiZWxvdyAqLwogCWludAkJCW1heHRy
YW5zZGVwdGg7CS8qIGFsbG9jYXRlZCBsZW4gb2YgYWJvdmUgYXJyYXkgKi8KKworCUxpc3QJICAg
KmJhdGNoX2NhbGxiYWNrczsJLyogTGlzdCBvZiBBZnRlclRyaWdnZXJDYWxsYmFja0l0ZW0gKi8K
IH0gQWZ0ZXJUcmlnZ2Vyc0RhdGE7CiAKIHN0cnVjdCBBZnRlclRyaWdnZXJzUXVlcnlEYXRhCkBA
IC0zOTI5LDYgKzM5MzEsMTMgQEAgc3RydWN0IEFmdGVyVHJpZ2dlcnNUYWJsZURhdGEKIAlUdXBs
ZVRhYmxlU2xvdCAqc3RvcmVzbG90OwkvKiBmb3IgY29udmVydGluZyB0byB0dXBsZXN0b3JlJ3Mg
Zm9ybWF0ICovCiB9OwogCisvKiBFbnRyeSBpbiBhZnRlclRyaWdnZXJzLmJhdGNoX2NhbGxiYWNr
cyAqLwordHlwZWRlZiBzdHJ1Y3QgQWZ0ZXJUcmlnZ2VyQ2FsbGJhY2tJdGVtCit7CisJQWZ0ZXJU
cmlnZ2VyQmF0Y2hDYWxsYmFjayBjYWxsYmFjazsKKwl2b2lkCSAgICphcmc7Cit9IEFmdGVyVHJp
Z2dlckNhbGxiYWNrSXRlbTsKKwogc3RhdGljIEFmdGVyVHJpZ2dlcnNEYXRhIGFmdGVyVHJpZ2dl
cnM7CiAKIHN0YXRpYyB2b2lkIEFmdGVyVHJpZ2dlckV4ZWN1dGUoRVN0YXRlICplc3RhdGUsCkBA
IC0zOTY0LDYgKzM5NzMsNyBAQCBzdGF0aWMgU2V0Q29uc3RyYWludFN0YXRlIFNldENvbnN0cmFp
bnRTdGF0ZUFkZEl0ZW0oU2V0Q29uc3RyYWludFN0YXRlIHN0YXRlLAogCQkJCQkJCQkJCQkJCU9p
ZCB0Z29pZCwgYm9vbCB0Z2lzZGVmZXJyZWQpOwogc3RhdGljIHZvaWQgY2FuY2VsX3ByaW9yX3N0
bXRfdHJpZ2dlcnMoT2lkIHJlbGlkLCBDbWRUeXBlIGNtZFR5cGUsIGludCB0Z2V2ZW50KTsKIAor
c3RhdGljIHZvaWQgRmlyZUFmdGVyVHJpZ2dlckJhdGNoQ2FsbGJhY2tzKHZvaWQpOwogCiAvKgog
ICogR2V0IHRoZSBGRFcgdHVwbGVzdG9yZSBmb3IgdGhlIGN1cnJlbnQgdHJpZ2dlciBxdWVyeSBs
ZXZlbCwgY3JlYXRpbmcgaXQKQEAgLTUwODksNiArNTA5OSw3IEBAIEFmdGVyVHJpZ2dlckJlZ2lu
WGFjdCh2b2lkKQogCSAqLwogCWFmdGVyVHJpZ2dlcnMuZmlyaW5nX2NvdW50ZXIgPSAoQ29tbWFu
ZElkKSAxOwkvKiBtdXN0bid0IGJlIDAgKi8KIAlhZnRlclRyaWdnZXJzLnF1ZXJ5X2RlcHRoID0g
LTE7CisJYWZ0ZXJUcmlnZ2Vycy5iYXRjaF9jYWxsYmFja3MgPSBOSUw7CiAKIAkvKgogCSAqIFZl
cmlmeSB0aGF0IHRoZXJlIGlzIG5vIGxlZnRvdmVyIHN0YXRlIHJlbWFpbmluZy4gIElmIHRoZXNl
IGFzc2VydGlvbnMKQEAgLTUyMTAsNiArNTIyMSw4IEBAIEFmdGVyVHJpZ2dlckVuZFF1ZXJ5KEVT
dGF0ZSAqZXN0YXRlKQogCQkJYnJlYWs7CiAJfQogCisJRmlyZUFmdGVyVHJpZ2dlckJhdGNoQ2Fs
bGJhY2tzKCk7CisKIAkvKiBSZWxlYXNlIHF1ZXJ5LWxldmVsLWxvY2FsIHN0b3JhZ2UsIGluY2x1
ZGluZyB0dXBsZXN0b3JlcyBpZiBhbnkgKi8KIAlBZnRlclRyaWdnZXJGcmVlUXVlcnkoJmFmdGVy
VHJpZ2dlcnMucXVlcnlfc3RhY2tbYWZ0ZXJUcmlnZ2Vycy5xdWVyeV9kZXB0aF0pOwogCkBAIC01
MzE3LDYgKzUzMzAsOCBAQCBBZnRlclRyaWdnZXJGaXJlRGVmZXJyZWQodm9pZCkKIAkJCWJyZWFr
OwkJCQkvKiBhbGwgZmlyZWQgKi8KIAl9CiAKKwlGaXJlQWZ0ZXJUcmlnZ2VyQmF0Y2hDYWxsYmFj
a3MoKTsKKwogCS8qCiAJICogV2UgZG9uJ3QgYm90aGVyIGZyZWVpbmcgdGhlIGV2ZW50IGxpc3Qs
IHNpbmNlIGl0IHdpbGwgZ28gYXdheSBhbnl3YXkKIAkgKiAoYW5kIG1vcmUgZWZmaWNpZW50bHkg
dGhhbiB2aWEgcGZyZWUpIGluIEFmdGVyVHJpZ2dlckVuZFhhY3QuCkBAIC02MDU5LDYgKzYwNzQs
OCBAQCBBZnRlclRyaWdnZXJTZXRTdGF0ZShDb25zdHJhaW50c1NldFN0bXQgKnN0bXQpCiAJCQkJ
YnJlYWs7CQkJLyogYWxsIGZpcmVkICovCiAJCX0KIAorCQlGaXJlQWZ0ZXJUcmlnZ2VyQmF0Y2hD
YWxsYmFja3MoKTsKKwogCQlpZiAoc25hcHNob3Rfc2V0KQogCQkJUG9wQWN0aXZlU25hcHNob3Qo
KTsKIAl9CkBAIC02NzU1LDMgKzY3NzIsNzYgQEAgY2hlY2tfbW9kaWZpZWRfdmlydHVhbF9nZW5l
cmF0ZWQoVHVwbGVEZXNjIHR1cGRlc2MsIEhlYXBUdXBsZSB0dXBsZSkKIAogCXJldHVybiB0dXBs
ZTsKIH0KKworLyoKKyAqIFJlZ2lzdGVyQWZ0ZXJUcmlnZ2VyQmF0Y2hDYWxsYmFjaworICoJCVJl
Z2lzdGVyIGEgZnVuY3Rpb24gdG8gYmUgY2FsbGVkIHdoZW4gdGhlIGN1cnJlbnQgdHJpZ2dlci1m
aXJpbmcKKyAqCQliYXRjaCBjb21wbGV0ZXMuCisgKgorICogTXVzdCBiZSBjYWxsZWQgZnJvbSB3
aXRoaW4gYSB0cmlnZ2VyIGZ1bmN0aW9uJ3MgZXhlY3V0aW9uIGNvbnRleHQKKyAqIChpLmUuLCB3
aGlsZSBhZnRlclRyaWdnZXJzIHN0YXRlIGlzIGFjdGl2ZSkuCisgKgorICogVGhlIGNhbGxiYWNr
IGxpc3QgaXMgY2xlYXJlZCBhZnRlciBpbnZvY2F0aW9uLCBzbyB0aGUgY2FsbGVyIG11c3QKKyAq
IHJlLXJlZ2lzdGVyIGZvciBlYWNoIG5ldyBiYXRjaCBpZiBuZWVkZWQuCisgKi8KK3ZvaWQKK1Jl
Z2lzdGVyQWZ0ZXJUcmlnZ2VyQmF0Y2hDYWxsYmFjayhBZnRlclRyaWdnZXJCYXRjaENhbGxiYWNr
IGNhbGxiYWNrLAorCQkJCQkJCQkgIHZvaWQgKmFyZykKK3sKKwlBZnRlclRyaWdnZXJDYWxsYmFj
a0l0ZW0gKml0ZW07CisJTWVtb3J5Q29udGV4dCBvbGRjeHQ7CisKKwkvKgorCSAqIEFsbG9jYXRl
IGluIFRvcFRyYW5zYWN0aW9uQ29udGV4dCBzbyB0aGUgaXRlbSBzdXJ2aXZlcyBmb3IgdGhlIGR1
cmF0aW9uCisJICogb2YgdGhlIGJhdGNoLCB3aGljaCBtYXkgc3BhbiBtdWx0aXBsZSB0cmlnZ2Vy
IGludm9jYXRpb25zLgorCSAqLworCW9sZGN4dCA9IE1lbW9yeUNvbnRleHRTd2l0Y2hUbyhUb3BU
cmFuc2FjdGlvbkNvbnRleHQpOworCWl0ZW0gPSBwYWxsb2Moc2l6ZW9mKEFmdGVyVHJpZ2dlckNh
bGxiYWNrSXRlbSkpOworCWl0ZW0tPmNhbGxiYWNrID0gY2FsbGJhY2s7CisJaXRlbS0+YXJnID0g
YXJnOworCWFmdGVyVHJpZ2dlcnMuYmF0Y2hfY2FsbGJhY2tzID0KKwkJbGFwcGVuZChhZnRlclRy
aWdnZXJzLmJhdGNoX2NhbGxiYWNrcywgaXRlbSk7CisJTWVtb3J5Q29udGV4dFN3aXRjaFRvKG9s
ZGN4dCk7Cit9CisKKy8qCisgKiBGaXJlQWZ0ZXJUcmlnZ2VyQmF0Y2hDYWxsYmFja3MKKyAqCQlJ
bnZva2UgYW5kIGNsZWFyIGFsbCByZWdpc3RlcmVkIGJhdGNoIGNhbGxiYWNrcy4KKyAqCisgKiBP
bmx5IGZpcmVzIGF0IHRoZSBvdXRlcm1vc3QgcXVlcnkgbGV2ZWwgKHF1ZXJ5X2RlcHRoID09IDAp
IG9yIGZyb20KKyAqIHRvcC1sZXZlbCBvcGVyYXRpb25zIChxdWVyeV9kZXB0aCA9PSAtMSwgZS5n
LiBBZnRlclRyaWdnZXJGaXJlRGVmZXJyZWQKKyAqIGF0IENPTU1JVCkuICBOZXN0ZWQgcXVlcmll
cyBmcm9tIFNQSSBpbnNpZGUgQUZURVIgdHJpZ2dlcnMgcnVuIGF0CisgKiBkZXB0aCA+IDAgYW5k
IG11c3Qgbm90IHRlYXIgZG93biByZXNvdXJjZXMgdGhlIG91dGVyIGJhdGNoIHN0aWxsIG5lZWRz
LgorICovCitzdGF0aWMgdm9pZAorRmlyZUFmdGVyVHJpZ2dlckJhdGNoQ2FsbGJhY2tzKHZvaWQp
Cit7CisJTGlzdENlbGwgICAqbGM7CisKKwlpZiAoYWZ0ZXJUcmlnZ2Vycy5xdWVyeV9kZXB0aCA+
IDApCisJCXJldHVybjsKKworCWZvcmVhY2gobGMsIGFmdGVyVHJpZ2dlcnMuYmF0Y2hfY2FsbGJh
Y2tzKQorCXsKKwkJQWZ0ZXJUcmlnZ2VyQ2FsbGJhY2tJdGVtICppdGVtID0gbGZpcnN0KGxjKTsK
KworCQlpdGVtLT5jYWxsYmFjayhpdGVtLT5hcmcpOworCX0KKworCWxpc3RfZnJlZV9kZWVwKGFm
dGVyVHJpZ2dlcnMuYmF0Y2hfY2FsbGJhY2tzKTsKKwlhZnRlclRyaWdnZXJzLmJhdGNoX2NhbGxi
YWNrcyA9IE5JTDsKK30KKworLyoKKyAqIEFmdGVyVHJpZ2dlckJhdGNoSXNBY3RpdmUKKyAqCQlS
ZXR1cm5zIHRydWUgaWYgd2UncmUgaW5zaWRlIGEgcXVlcnktbGV2ZWwgdHJpZ2dlciBiYXRjaCB3
aGVyZQorICoJCXJlZ2lzdGVyZWQgYmF0Y2ggY2FsbGJhY2tzIHdpbGwgYWN0dWFsbHkgYmUgaW52
b2tlZC4KKyAqCisgKiBUaGlzIGlzIGZhbHNlIGR1cmluZyB2YWxpZGF0ZUZvcmVpZ25LZXlDb25z
dHJhaW50KCksIHdoaWNoIGNhbGxzCisgKiBSSSB0cmlnZ2VyIGZ1bmN0aW9ucyBkaXJlY3RseSBv
dXRzaWRlIHRoZSBhZnRlci10cmlnZ2VyIGZyYW1ld29yay4KKyAqLworYm9vbAorQWZ0ZXJUcmln
Z2VyQmF0Y2hJc0FjdGl2ZSh2b2lkKQoreworCXJldHVybiBhZnRlclRyaWdnZXJzLnF1ZXJ5X2Rl
cHRoID49IDA7Cit9CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9hZHQvcmlfdHJpZ2dl
cnMuYyBiL3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9yaV90cmlnZ2Vycy5jCmluZGV4IGNlMGY1YzEy
MGY0Li44NGJmN2Q3NGVjNSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L3JpX3Ry
aWdnZXJzLmMKKysrIGIvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L3JpX3RyaWdnZXJzLmMKQEAgLTE5
Niw2ICsxOTYsMjMgQEAgdHlwZWRlZiBzdHJ1Y3QgUklfQ29tcGFyZUhhc2hFbnRyeQogCUZtZ3JJ
bmZvCWNhc3RfZnVuY19maW5mbzsJLyogaW4gY2FzZSB3ZSBtdXN0IGNvZXJjZSBpbnB1dCAqLwog
fSBSSV9Db21wYXJlSGFzaEVudHJ5OwogCisvKgorICogUklfRmFzdFBhdGhFbnRyeQorICoJCVBl
ci1jb25zdHJhaW50IGNhY2hlIG9mIHJlc291cmNlcyBuZWVkZWQgYnkgcmlfRmFzdFBhdGhDaGVj
a0NhY2hlZCgpLgorICoKKyAqIE9uZSBlbnRyeSBwZXIgY29uc3RyYWludCwga2V5ZWQgYnkgcGdf
Y29uc3RyYWludCBPSUQuICBDcmVhdGVkIGxhemlseQorICogYnkgcmlfRmFzdFBhdGhHZXRFbnRy
eSgpIG9uIGZpcnN0IHVzZSB3aXRoaW4gYSB0cmlnZ2VyLWZpcmluZyBiYXRjaAorICogYW5kIHRv
cm4gZG93biBieSByaV9GYXN0UGF0aFRlYXJkb3duKCkgYXQgYmF0Y2ggZW5kLgorICovCit0eXBl
ZGVmIHN0cnVjdCBSSV9GYXN0UGF0aEVudHJ5Cit7CisJT2lkCQkJY29ub2lkOwkJCS8qIGhhc2gg
a2V5OiBwZ19jb25zdHJhaW50IE9JRCAqLworCVJlbGF0aW9uCXBrX3JlbDsKKwlSZWxhdGlvbglp
ZHhfcmVsOworCUluZGV4U2NhbkRlc2Mgc2NhbmRlc2M7CisJVHVwbGVUYWJsZVNsb3QgKnNsb3Q7
CisJU25hcHNob3QJc25hcHNob3Q7CQkvKiByZWdpc3RlcmVkIHNuYXBzaG90IGZvciB0aGUgc2Nh
biAqLworfSBSSV9GYXN0UGF0aEVudHJ5OwogCiAvKgogICogTG9jYWwgZGF0YQpAQCAtMjA1LDYg
KzIyMiw4IEBAIHN0YXRpYyBIVEFCICpyaV9xdWVyeV9jYWNoZSA9IE5VTEw7CiBzdGF0aWMgSFRB
QiAqcmlfY29tcGFyZV9jYWNoZSA9IE5VTEw7CiBzdGF0aWMgZGNsaXN0X2hlYWQgcmlfY29uc3Ry
YWludF9jYWNoZV92YWxpZF9saXN0OwogCitzdGF0aWMgSFRBQiAqcmlfZmFzdHBhdGhfY2FjaGUg
PSBOVUxMOworc3RhdGljIGJvb2wgcmlfZmFzdHBhdGhfY2FsbGJhY2tfcmVnaXN0ZXJlZCA9IGZh
bHNlOwogCiAvKgogICogTG9jYWwgZnVuY3Rpb24gcHJvdG90eXBlcwpAQCAtMjU1LDYgKzI3NCw4
IEBAIHN0YXRpYyBib29sIHJpX1BlcmZvcm1DaGVjayhjb25zdCBSSV9Db25zdHJhaW50SW5mbyAq
cmlpbmZvLAogCQkJCQkJCWJvb2wgZGV0ZWN0TmV3Um93cywgaW50IGV4cGVjdF9PSyk7CiBzdGF0
aWMgdm9pZCByaV9GYXN0UGF0aENoZWNrKGNvbnN0IFJJX0NvbnN0cmFpbnRJbmZvICpyaWluZm8s
CiAJCQkJCQkJIFJlbGF0aW9uIGZrX3JlbCwgVHVwbGVUYWJsZVNsb3QgKm5ld3Nsb3QpOworc3Rh
dGljIHZvaWQgcmlfRmFzdFBhdGhDaGVja0NhY2hlZChjb25zdCBSSV9Db25zdHJhaW50SW5mbyAq
cmlpbmZvLAorCQkJCQkJCQkgICBSZWxhdGlvbiBma19yZWwsIFR1cGxlVGFibGVTbG90ICpuZXdz
bG90KTsKIHN0YXRpYyBib29sIHJpX0Zhc3RQYXRoUHJvYmVPbmUoUmVsYXRpb24gcGtfcmVsLCBS
ZWxhdGlvbiBpZHhfcmVsLAogCQkJCQkJCQlJbmRleFNjYW5EZXNjIHNjYW5kZXNjLCBUdXBsZVRh
YmxlU2xvdCAqc2xvdCwKIAkJCQkJCQkJU25hcHNob3Qgc25hcHNob3QsIGNvbnN0IFJJX0NvbnN0
cmFpbnRJbmZvICpyaWluZm8sCkBAIC0yNzcsNiArMjk4LDkgQEAgcGdfbm9yZXR1cm4gc3RhdGlj
IHZvaWQgcmlfUmVwb3J0VmlvbGF0aW9uKGNvbnN0IFJJX0NvbnN0cmFpbnRJbmZvICpyaWluZm8s
CiAJCQkJCQkJCQkJICAgUmVsYXRpb24gcGtfcmVsLCBSZWxhdGlvbiBma19yZWwsCiAJCQkJCQkJ
CQkJICAgVHVwbGVUYWJsZVNsb3QgKnZpb2xhdG9yc2xvdCwgVHVwbGVEZXNjIHR1cGRlc2MsCiAJ
CQkJCQkJCQkJICAgaW50IHF1ZXJ5bm8sIGJvb2wgaXNfcmVzdHJpY3QsIGJvb2wgcGFydGdvbmUp
Oworc3RhdGljIFJJX0Zhc3RQYXRoRW50cnkgKnJpX0Zhc3RQYXRoR2V0RW50cnkoY29uc3QgUklf
Q29uc3RyYWludEluZm8gKnJpaW5mbywKKwkJCQkJCQkJCQkJIFJlbGF0aW9uIGZrX3JlbCk7Citz
dGF0aWMgdm9pZCByaV9GYXN0UGF0aFRlYXJkb3duKHZvaWQgKmFyZyk7CiAKIAogLyoKQEAgLTM4
NywxMiArNDExLDE2IEBAIFJJX0ZLZXlfY2hlY2soVHJpZ2dlckRhdGEgKnRyaWdkYXRhKQogCSAq
IGxvY2suICBUaGlzIGlzIHNlbWFudGljYWxseSBlcXVpdmFsZW50IHRvIHRoZSBTUEkgcGF0aCBi
ZWxvdyBidXQgYXZvaWRzCiAJICogdGhlIHBlci1yb3cgZXhlY3V0b3Igb3ZlcmhlYWQuCiAJICoK
LQkgKiByaV9GYXN0UGF0aENoZWNrKCkgcmVwb3J0cyB0aGUgdmlvbGF0aW9uIGl0c2VsZiAodmlh
IGVyZXBvcnQpIGlmIG5vCi0JICogbWF0Y2hpbmcgUEsgcm93IGlzIGZvdW5kLCBzbyBpdCBvbmx5
IHJldHVybnMgb24gc3VjY2Vzcy4KKwkgKiByaV9GYXN0UGF0aENoZWNrQ2FjaGVkKCkgYW5kIHJp
X0Zhc3RQYXRoQ2hlY2soKSByZXBvcnQgdGhlIHZpb2xhdGlvbgorCSAqIHRoZW1zZWx2ZXMgaWYg
bm8gbWF0Y2hpbmcgUEsgcm93IGlzIGZvdW5kLCBzbyB0aGV5IG9ubHkgcmV0dXJuIG9uCisJICog
c3VjY2Vzcy4KIAkgKi8KIAlpZiAocmlfZmFzdHBhdGhfaXNfYXBwbGljYWJsZShyaWluZm8pKQog
CXsKLQkJcmlfRmFzdFBhdGhDaGVjayhyaWluZm8sIGZrX3JlbCwgbmV3c2xvdCk7CisJCWlmIChB
ZnRlclRyaWdnZXJCYXRjaElzQWN0aXZlKCkpCisJCQlyaV9GYXN0UGF0aENoZWNrQ2FjaGVkKHJp
aW5mbywgZmtfcmVsLCBuZXdzbG90KTsKKwkJZWxzZQorCQkJcmlfRmFzdFBhdGhDaGVjayhyaWlu
Zm8sIGZrX3JlbCwgbmV3c2xvdCk7CiAJCXJldHVybiBQb2ludGVyR2V0RGF0dW0oTlVMTCk7CiAJ
fQogCkBAIC0yNzQyLDYgKzI3NzAsNzMgQEAgcmlfRmFzdFBhdGhDaGVjayhjb25zdCBSSV9Db25z
dHJhaW50SW5mbyAqcmlpbmZvLAogCXRhYmxlX2Nsb3NlKHBrX3JlbCwgTm9Mb2NrKTsKIH0KIAor
LyoKKyAqIHJpX0Zhc3RQYXRoQ2hlY2tDYWNoZWQKKyAqCQlDYWNoZWQtcmVzb3VyY2UgdmFyaWFu
dCBvZiByaV9GYXN0UGF0aENoZWNrIGZvciB1c2Ugd2l0aGluIHRoZQorICoJCWFmdGVyLXRyaWdn
ZXIgZnJhbWV3b3JrLgorICoKKyAqIFVzZXMgdGhlIHBlci1iYXRjaCBjYWNoZSAoUklfRmFzdFBh
dGhFbnRyeSkgdG8gYXZvaWQgcGVyLXJvdyByZWxhdGlvbgorICogb3Blbi9jbG9zZSwgc2NhbiBi
ZWdpbi9lbmQsIGFuZCBzbmFwc2hvdCByZWdpc3RyYXRpb24uICBUaGUgc25hcHNob3QncworICog
Y3VyY2lkIGlzIHBhdGNoZWQgZWFjaCBjYWxsIHNvIHRoZSBzY2FuIHNlZXMgZWZmZWN0cyBvZiBw
cmlvciB0cmlnZ2Vycy4KKyAqCisgKiBMaWtlIHJpX0Zhc3RQYXRoQ2hlY2ssIHJlcG9ydHMgdGhl
IHZpb2xhdGlvbiB2aWEgcmlfUmVwb3J0VmlvbGF0aW9uKCkKKyAqIGlmIG5vIG1hdGNoaW5nIFBL
IHJvdyBpcyBmb3VuZC4KKyAqLworc3RhdGljIHZvaWQKK3JpX0Zhc3RQYXRoQ2hlY2tDYWNoZWQo
Y29uc3QgUklfQ29uc3RyYWludEluZm8gKnJpaW5mbywKKwkJCQkJICAgUmVsYXRpb24gZmtfcmVs
LCBUdXBsZVRhYmxlU2xvdCAqbmV3c2xvdCkKK3sKKwlSSV9GYXN0UGF0aEVudHJ5ICpmcGVudHJ5
ID0gcmlfRmFzdFBhdGhHZXRFbnRyeShyaWluZm8sIGZrX3JlbCk7CisJUmVsYXRpb24JcGtfcmVs
ID0gZnBlbnRyeS0+cGtfcmVsOworCVJlbGF0aW9uCWlkeF9yZWwgPSBmcGVudHJ5LT5pZHhfcmVs
OworCUluZGV4U2NhbkRlc2Mgc2NhbmRlc2MgPSBmcGVudHJ5LT5zY2FuZGVzYzsKKwlTbmFwc2hv
dAlzbmFwc2hvdCA9IGZwZW50cnktPnNuYXBzaG90OworCVR1cGxlVGFibGVTbG90ICpzbG90ID0g
ZnBlbnRyeS0+c2xvdDsKKwlEYXR1bQkJcGtfdmFsc1tJTkRFWF9NQVhfS0VZU107CisJY2hhcgkJ
cGtfbnVsbHNbSU5ERVhfTUFYX0tFWVNdOworCVNjYW5LZXlEYXRhIHNrZXlbSU5ERVhfTUFYX0tF
WVNdOworCWJvb2wJCWZvdW5kOworCU9pZAkJCXNhdmVkX3VzZXJpZDsKKwlpbnQJCQlzYXZlZF9z
ZWNfY29udGV4dDsKKwlNZW1vcnlDb250ZXh0IG9sZGN4dDsKKworCS8qCisJICogQWR2YW5jZSB0
aGUgY29tbWFuZCBjb3VudGVyIGFuZCBwYXRjaCB0aGUgY2FjaGVkIHNuYXBzaG90J3MgY3VyY2lk
IHNvCisJICogdGhlIHNjYW4gc2VlcyBQSyByb3dzIGluc2VydGVkIGJ5IGVhcmxpZXIgdHJpZ2dl
cnMgaW4gdGhpcyBzdGF0ZW1lbnQuCisJICovCisJQ29tbWFuZENvdW50ZXJJbmNyZW1lbnQoKTsK
KwlmcGVudHJ5LT5zbmFwc2hvdC0+Y3VyY2lkID0gR2V0Q3VycmVudENvbW1hbmRJZChmYWxzZSk7
CisKKwlpZiAocmlpbmZvLT5mcG1ldGEgPT0gTlVMTCkKKwkJcmlfcG9wdWxhdGVfZmFzdHBhdGhf
bWV0YWRhdGEoKFJJX0NvbnN0cmFpbnRJbmZvICopIHJpaW5mbywKKwkJCQkJCQkJCSAgZmtfcmVs
LCBpZHhfcmVsKTsKKwlBc3NlcnQocmlpbmZvLT5mcG1ldGEpOworCisJR2V0VXNlcklkQW5kU2Vj
Q29udGV4dCgmc2F2ZWRfdXNlcmlkLCAmc2F2ZWRfc2VjX2NvbnRleHQpOworCVNldFVzZXJJZEFu
ZFNlY0NvbnRleHQoUmVsYXRpb25HZXRGb3JtKHBrX3JlbCktPnJlbG93bmVyLAorCQkJCQkJICAg
c2F2ZWRfc2VjX2NvbnRleHQgfAorCQkJCQkJICAgU0VDVVJJVFlfTE9DQUxfVVNFUklEX0NIQU5H
RSB8CisJCQkJCQkgICBTRUNVUklUWV9OT0ZPUkNFX1JMUyk7CisKKwlyaV9FeHRyYWN0VmFsdWVz
KGZrX3JlbCwgbmV3c2xvdCwgcmlpbmZvLCBmYWxzZSwgcGtfdmFscywgcGtfbnVsbHMpOworCWJ1
aWxkX2luZGV4X3NjYW5rZXlzKHJpaW5mbywgaWR4X3JlbCwgcGtfdmFscywgcGtfbnVsbHMsIHNr
ZXkpOworCisJLyoKKwkgKiBUaGUgY2FjaGVkIHNjYW5kZXNjIGxpdmVzIGluIFRvcFRyYW5zYWN0
aW9uQ29udGV4dCwgYnV0IHRoZSBidHJlZSBBTQorCSAqIGRlZmVycyBzb21lIGFsbG9jYXRpb25z
IHRvIHRoZSBmaXJzdCBpbmRleF9nZXRuZXh0X3Nsb3QgY2FsbC4gIEVuc3VyZQorCSAqIHRob3Nl
IGxhbmQgaW4gVG9wVHJhbnNhY3Rpb25Db250ZXh0IHRvby4KKwkgKi8KKwlvbGRjeHQgPSBNZW1v
cnlDb250ZXh0U3dpdGNoVG8oVG9wVHJhbnNhY3Rpb25Db250ZXh0KTsKKwlmb3VuZCA9IHJpX0Zh
c3RQYXRoUHJvYmVPbmUocGtfcmVsLCBpZHhfcmVsLCBzY2FuZGVzYywgc2xvdCwgc25hcHNob3Qs
CisJCQkJCQkJCXJpaW5mbywgc2tleSwgcmlpbmZvLT5ua2V5cyk7CisJTWVtb3J5Q29udGV4dFN3
aXRjaFRvKG9sZGN4dCk7CisJU2V0VXNlcklkQW5kU2VjQ29udGV4dChzYXZlZF91c2VyaWQsIHNh
dmVkX3NlY19jb250ZXh0KTsKKworCWlmICghZm91bmQpCisJCXJpX1JlcG9ydFZpb2xhdGlvbihy
aWluZm8sIHBrX3JlbCwgZmtfcmVsLCBuZXdzbG90LCBOVUxMLAorCQkJCQkJICAgUklfUExBTl9D
SEVDS19MT09LVVBQSywgZmFsc2UsIGZhbHNlKTsKK30KKwogLyoKICAqIHJpX0Zhc3RQYXRoUHJv
YmVPbmUKICAqCQlQcm9iZSB0aGUgUEsgaW5kZXggZm9yIG9uZSBzZXQgb2Ygc2NhbiBrZXlzLCBs
b2NrIHRoZSBtYXRjaGluZwpAQCAtMzY3MiwzICszNzY3LDE3NyBAQCBSSV9GS2V5X3RyaWdnZXJf
dHlwZShPaWQgdGdmb2lkKQogCiAJcmV0dXJuIFJJX1RSSUdHRVJfTk9ORTsKIH0KKworLyoKKyAq
IHJpX0Zhc3RQYXRoVGVhcmRvd24KKyAqCQlUZWFyIGRvd24gYWxsIGNhY2hlZCBmYXN0LXBhdGgg
c3RhdGUuCisgKgorICogQ2FsbGVkIGFzIGFuIEFmdGVyVHJpZ2dlckJhdGNoQ2FsbGJhY2sgYXQg
ZW5kIG9mIGJhdGNoLgorICovCitzdGF0aWMgdm9pZAorcmlfRmFzdFBhdGhUZWFyZG93bih2b2lk
ICphcmcpCit7CisJSEFTSF9TRVFfU1RBVFVTIHN0YXR1czsKKwlSSV9GYXN0UGF0aEVudHJ5ICpl
bnRyeTsKKworCWlmIChyaV9mYXN0cGF0aF9jYWNoZSA9PSBOVUxMKQorCQlyZXR1cm47CisKKwlo
YXNoX3NlcV9pbml0KCZzdGF0dXMsIHJpX2Zhc3RwYXRoX2NhY2hlKTsKKwl3aGlsZSAoKGVudHJ5
ID0gaGFzaF9zZXFfc2VhcmNoKCZzdGF0dXMpKSAhPSBOVUxMKQorCXsKKwkJLyogQ2xvc2UgYm90
aCBzY2FucyBiZWZvcmUgY2xvc2luZyBpZHhfcmVsLiAqLworCQlpZiAoZW50cnktPnNjYW5kZXNj
KQorCQkJaW5kZXhfZW5kc2NhbihlbnRyeS0+c2NhbmRlc2MpOworCQlpZiAoZW50cnktPmlkeF9y
ZWwpCisJCQlpbmRleF9jbG9zZShlbnRyeS0+aWR4X3JlbCwgTm9Mb2NrKTsKKwkJaWYgKGVudHJ5
LT5wa19yZWwpCisJCQl0YWJsZV9jbG9zZShlbnRyeS0+cGtfcmVsLCBOb0xvY2spOworCQlpZiAo
ZW50cnktPnNsb3QpCisJCQlFeGVjRHJvcFNpbmdsZVR1cGxlVGFibGVTbG90KGVudHJ5LT5zbG90
KTsKKwkJaWYgKGVudHJ5LT5zbmFwc2hvdCkKKwkJCVVucmVnaXN0ZXJTbmFwc2hvdChlbnRyeS0+
c25hcHNob3QpOworCX0KKworCWhhc2hfZGVzdHJveShyaV9mYXN0cGF0aF9jYWNoZSk7CisJcmlf
ZmFzdHBhdGhfY2FjaGUgPSBOVUxMOworCXJpX2Zhc3RwYXRoX2NhbGxiYWNrX3JlZ2lzdGVyZWQg
PSBmYWxzZTsKK30KKworc3RhdGljIGJvb2wgcmlfZmFzdHBhdGhfeGFjdF9jYWxsYmFja19yZWdp
c3RlcmVkID0gZmFsc2U7CisKK3N0YXRpYyB2b2lkCityaV9GYXN0UGF0aFhhY3RDYWxsYmFjayhY
YWN0RXZlbnQgZXZlbnQsIHZvaWQgKmFyZykKK3sKKwkvKgorCSAqIFRvcFRyYW5zYWN0aW9uQ29u
dGV4dCBpcyBkZXN0cm95ZWQgYXQgZW5kIG9mIHRyYW5zYWN0aW9uLCB0YWtpbmcgdGhlCisJICog
aGFzaCB0YWJsZSBhbmQgYWxsIGNhY2hlZCByZXNvdXJjZXMgd2l0aCBpdC4gIEp1c3QgcmVzZXQg
b3VyIHN0YXRpYworCSAqIHBvaW50ZXJzIHNvIHdlIGRvbid0IGRlcmVmZXJlbmNlIGZyZWVkIG1l
bW9yeS4KKwkgKgorCSAqIEluIHRoZSBub3JtYWwgKG5vbi1lcnJvcikgcGF0aCwgcmlfRmFzdFBh
dGhUZWFyZG93biBhbHJlYWR5IHJhbiB2aWEgdGhlCisJICogYmF0Y2ggY2FsbGJhY2sgYW5kIGRp
ZCBvcmRlcmx5IHRlYXJkb3duLiAgSGVyZSB3ZSdyZSBqdXN0IGhhbmRsaW5nIHRoZQorCSAqIGFi
b3J0IHBhdGggd2hlcmUgdGhhdCBjYWxsYmFjayBuZXZlciBmaXJlZC4KKwkgKi8KKwlyaV9mYXN0
cGF0aF9jYWNoZSA9IE5VTEw7CisJcmlfZmFzdHBhdGhfY2FsbGJhY2tfcmVnaXN0ZXJlZCA9IGZh
bHNlOworfQorCitzdGF0aWMgdm9pZAorcmlfRmFzdFBhdGhTdWJYYWN0Q2FsbGJhY2soU3ViWGFj
dEV2ZW50IGV2ZW50LCBTdWJUcmFuc2FjdGlvbklkIG15U3ViaWQsCisJCQkJCQkgICBTdWJUcmFu
c2FjdGlvbklkIHBhcmVudFN1YmlkLCB2b2lkICphcmcpCit7CisJaWYgKGV2ZW50ID09IFNVQlhB
Q1RfRVZFTlRfQUJPUlRfU1VCKQorCXsKKwkJLyoKKwkJICogUmVzb3VyY2VPd25lciBhbHJlYWR5
IGNsZWFuZWQgdXAgcmVsYXRpb25zIGFuZCBzbmFwc2hvdHMuICBKdXN0CisJCSAqIE5VTEwgb3Vy
IHBvaW50ZXJzIHNvIHRoZSBzdGlsbC1yZWdpc3RlcmVkIGJhdGNoIGNhbGxiYWNrIGJlY29tZXMg
YQorCQkgKiBuby1vcC4gIFRoZSBoYXNoIHRhYmxlIG1lbW9yeSBpbiBUb3BUcmFuc2FjdGlvbkNv
bnRleHQgd2lsbCBiZQorCQkgKiBmcmVlZCBhdCB0cmFuc2FjdGlvbiBlbmQuCisJCSAqLworCQly
aV9mYXN0cGF0aF9jYWNoZSA9IE5VTEw7CisJCXJpX2Zhc3RwYXRoX2NhbGxiYWNrX3JlZ2lzdGVy
ZWQgPSBmYWxzZTsKKwl9Cit9CisKKy8qCisgKiByaV9GYXN0UGF0aEdldEVudHJ5CisgKgkJTG9v
ayB1cCBvciBjcmVhdGUgYSBwZXItYmF0Y2ggY2FjaGUgZW50cnkgZm9yIHRoZSBnaXZlbiBjb25z
dHJhaW50LgorICoKKyAqIE9uIGZpcnN0IGNhbGwgZm9yIGEgY29uc3RyYWludCB3aXRoaW4gYSBi
YXRjaDogb3BlbnMgcGtfcmVsIGFuZCB0aGUKKyAqIGluZGV4LCBiZWdpbnMgYW4gaW5kZXggc2Nh
biwgYWxsb2NhdGVzIGEgcmVzdWx0IHNsb3QsIGFuZCByZWdpc3RlcnMKKyAqIHRoZSBjbGVhbnVw
IGNhbGxiYWNrLgorICoKKyAqIE9uIHN1YnNlcXVlbnQgY2FsbHM6IHJldHVybnMgdGhlIGV4aXN0
aW5nIGVudHJ5LiAgQ2FsbGVyIHVzZXMKKyAqIGluZGV4X3Jlc2NhbigpIHdpdGggbmV3IGtleXMu
CisgKi8KK3N0YXRpYyBSSV9GYXN0UGF0aEVudHJ5ICoKK3JpX0Zhc3RQYXRoR2V0RW50cnkoY29u
c3QgUklfQ29uc3RyYWludEluZm8gKnJpaW5mbywgUmVsYXRpb24gZmtfcmVsKQoreworCVJJX0Zh
c3RQYXRoRW50cnkgKmVudHJ5OworCWJvb2wJCWZvdW5kOworCisJLyogQ3JlYXRlIGhhc2ggdGFi
bGUgb24gZmlyc3QgdXNlIGluIHRoaXMgYmF0Y2ggKi8KKwlpZiAocmlfZmFzdHBhdGhfY2FjaGUg
PT0gTlVMTCkKKwl7CisJCUhBU0hDVEwJCWN0bDsKKworCQlpZiAoIXJpX2Zhc3RwYXRoX3hhY3Rf
Y2FsbGJhY2tfcmVnaXN0ZXJlZCkKKwkJeworCQkJUmVnaXN0ZXJYYWN0Q2FsbGJhY2socmlfRmFz
dFBhdGhYYWN0Q2FsbGJhY2ssIE5VTEwpOworCQkJUmVnaXN0ZXJTdWJYYWN0Q2FsbGJhY2socmlf
RmFzdFBhdGhTdWJYYWN0Q2FsbGJhY2ssIE5VTEwpOworCQkJcmlfZmFzdHBhdGhfeGFjdF9jYWxs
YmFja19yZWdpc3RlcmVkID0gdHJ1ZTsKKwkJfQorCisJCWN0bC5rZXlzaXplID0gc2l6ZW9mKE9p
ZCk7CisJCWN0bC5lbnRyeXNpemUgPSBzaXplb2YoUklfRmFzdFBhdGhFbnRyeSk7CisJCWN0bC5o
Y3h0ID0gVG9wVHJhbnNhY3Rpb25Db250ZXh0OworCQlyaV9mYXN0cGF0aF9jYWNoZSA9IGhhc2hf
Y3JlYXRlKCJSSSBmYXN0LXBhdGggY2FjaGUiLAorCQkJCQkJCQkJCTE2LAorCQkJCQkJCQkJCSZj
dGwsCisJCQkJCQkJCQkJSEFTSF9FTEVNIHwgSEFTSF9CTE9CUyB8IEhBU0hfQ09OVEVYVCk7CisJ
fQorCisJZW50cnkgPSBoYXNoX3NlYXJjaChyaV9mYXN0cGF0aF9jYWNoZSwgJnJpaW5mby0+Y29u
c3RyYWludF9pZCwKKwkJCQkJCUhBU0hfRU5URVIsICZmb3VuZCk7CisKKwlpZiAoIWZvdW5kKQor
CXsKKwkJTWVtb3J5Q29udGV4dCBvbGRjeHQ7CisJCU9pZAkJCXNhdmVkX3VzZXJpZDsKKwkJaW50
CQkJc2F2ZWRfc2VjX2NvbnRleHQ7CisKKwkJLyoKKwkJICogWmVybyBvdXQgbm9uLWtleSBmaWVs
ZHMgc28gcmlfRmFzdFBhdGhUZWFyZG93biBpcyBzYWZlIGlmIHdlIGVycm9yCisJCSAqIG91dCBk
dXJpbmcgcGFydGlhbCBpbml0aWFsaXphdGlvbiBiZWxvdy4KKwkJICovCisJCW1lbXNldCgoKGNo
YXIgKikgZW50cnkpICsgb2Zmc2V0b2YoUklfRmFzdFBhdGhFbnRyeSwgcGtfcmVsKSwgMCwKKwkJ
CSAgIHNpemVvZihSSV9GYXN0UGF0aEVudHJ5KSAtIG9mZnNldG9mKFJJX0Zhc3RQYXRoRW50cnks
IHBrX3JlbCkpOworCisJCW9sZGN4dCA9IE1lbW9yeUNvbnRleHRTd2l0Y2hUbyhUb3BUcmFuc2Fj
dGlvbkNvbnRleHQpOworCisJCS8qCisJCSAqIE9wZW4gUEsgdGFibGUgYW5kIGl0cyB1bmlxdWUg
aW5kZXguCisJCSAqCisJCSAqIFJvd1NoYXJlTG9jayBvbiBwa19yZWwgbWF0Y2hlcyB3aGF0IHRo
ZSBTUEkgcGF0aCdzIFNFTEVDVCAuLi4gRk9SCisJCSAqIEtFWSBTSEFSRSB3b3VsZCBhY3F1aXJl
IGFzIGEgcmVsYXRpb24tbGV2ZWwgbG9jay4gQWNjZXNzU2hhcmVMb2NrCisJCSAqIG9uIHRoZSBp
bmRleCBpcyBzdGFuZGFyZCBmb3IgaW5kZXggc2NhbnMuCisJCSAqCisJCSAqIFdlIGRvbid0IHJl
bGVhc2UgdGhlc2UgbG9ja3MgdW50aWwgZW5kIG9mIHRyYW5zYWN0aW9uLCBtYXRjaGluZyBTUEkK
KwkJICogYmVoYXZpb3IuCisJCSAqLworCQllbnRyeS0+cGtfcmVsID0gdGFibGVfb3BlbihyaWlu
Zm8tPnBrX3JlbGlkLCBSb3dTaGFyZUxvY2spOworCQllbnRyeS0+aWR4X3JlbCA9IGluZGV4X29w
ZW4ocmlpbmZvLT5jb25pbmRpZCwgQWNjZXNzU2hhcmVMb2NrKTsKKworCQkvKgorCQkgKiBSZWdp
c3RlciBhbiBpbml0aWFsIHNuYXBzaG90LiAgSXRzIGN1cmNpZCB3aWxsIGJlIHBhdGNoZWQgaW4g
cGxhY2UKKwkJICogb24gZWFjaCBzdWJzZXF1ZW50IHJvdyAoc2VlIHJpX0Zhc3RQYXRoQ2hlY2tD
YWNoZWQoKSksIGF2b2lkaW5nCisJCSAqIHBlci1yb3cgR2V0U25hcHNob3REYXRhKCkgb3Zlcmhl
YWQuCisJCSAqLworCQllbnRyeS0+c25hcHNob3QgPSBSZWdpc3RlclNuYXBzaG90KEdldFRyYW5z
YWN0aW9uU25hcHNob3QoKSk7CisKKwkJZW50cnktPnNsb3QgPSB0YWJsZV9zbG90X2NyZWF0ZShl
bnRyeS0+cGtfcmVsLCBOVUxMKTsKKworCQllbnRyeS0+c2NhbmRlc2MgPSBpbmRleF9iZWdpbnNj
YW4oZW50cnktPnBrX3JlbCwgZW50cnktPmlkeF9yZWwsCisJCQkJCQkJCQkJICBlbnRyeS0+c25h
cHNob3QsIE5VTEwsCisJCQkJCQkJCQkJICByaWluZm8tPm5rZXlzLCAwKTsKKworCQlNZW1vcnlD
b250ZXh0U3dpdGNoVG8ob2xkY3h0KTsKKworCQkvKiBFbnN1cmUgY2xlYW51cCBhdCBlbmQgb2Yg
dGhpcyB0cmlnZ2VyLWZpcmluZyBiYXRjaCAqLworCQlpZiAoIXJpX2Zhc3RwYXRoX2NhbGxiYWNr
X3JlZ2lzdGVyZWQpCisJCXsKKwkJCVJlZ2lzdGVyQWZ0ZXJUcmlnZ2VyQmF0Y2hDYWxsYmFjayhy
aV9GYXN0UGF0aFRlYXJkb3duLCBOVUxMKTsKKwkJCXJpX2Zhc3RwYXRoX2NhbGxiYWNrX3JlZ2lz
dGVyZWQgPSB0cnVlOworCQl9CisKKwkJR2V0VXNlcklkQW5kU2VjQ29udGV4dCgmc2F2ZWRfdXNl
cmlkLCAmc2F2ZWRfc2VjX2NvbnRleHQpOworCQlTZXRVc2VySWRBbmRTZWNDb250ZXh0KFJlbGF0
aW9uR2V0Rm9ybShlbnRyeS0+cGtfcmVsKS0+cmVsb3duZXIsCisJCQkJCQkJICAgc2F2ZWRfc2Vj
X2NvbnRleHQgfAorCQkJCQkJCSAgIFNFQ1VSSVRZX0xPQ0FMX1VTRVJJRF9DSEFOR0UgfAorCQkJ
CQkJCSAgIFNFQ1VSSVRZX05PRk9SQ0VfUkxTKTsKKwkJcmlfQ2hlY2tQZXJtaXNzaW9ucyhlbnRy
eS0+cGtfcmVsKTsKKwkJU2V0VXNlcklkQW5kU2VjQ29udGV4dChzYXZlZF91c2VyaWQsIHNhdmVk
X3NlY19jb250ZXh0KTsKKwl9CisKKwlyZXR1cm4gZW50cnk7Cit9CmRpZmYgLS1naXQgYS9zcmMv
aW5jbHVkZS9jb21tYW5kcy90cmlnZ2VyLmggYi9zcmMvaW5jbHVkZS9jb21tYW5kcy90cmlnZ2Vy
LmgKaW5kZXggMjdhZjUyODQ0MDYuLjc2NjQyOThmNWM4IDEwMDY0NAotLS0gYS9zcmMvaW5jbHVk
ZS9jb21tYW5kcy90cmlnZ2VyLmgKKysrIGIvc3JjL2luY2x1ZGUvY29tbWFuZHMvdHJpZ2dlci5o
CkBAIC0yODksNCArMjg5LDIyIEBAIGV4dGVybiB2b2lkIFJJX1BhcnRpdGlvblJlbW92ZV9DaGVj
ayhUcmlnZ2VyICp0cmlnZ2VyLCBSZWxhdGlvbiBma19yZWwsCiAKIGV4dGVybiBpbnQJUklfRktl
eV90cmlnZ2VyX3R5cGUoT2lkIHRnZm9pZCk7CiAKKy8qCisgKiBDYWxsYmFjayB0eXBlIGZvciBl
bmQtb2YtdHJpZ2dlci1iYXRjaCBub3RpZmljYXRpb25zLgorICoKKyAqIFJlZ2lzdGVyZWQgdmlh
IFJlZ2lzdGVyQWZ0ZXJUcmlnZ2VyQmF0Y2hDYWxsYmFjaygpLiAgSW52b2tlZCB3aGVuCisgKiBh
IGJhdGNoIG9mIGFmdGVyLXRyaWdnZXIgcHJvY2Vzc2luZyBjb21wbGV0ZXM6CisgKgktIEFmdGVy
VHJpZ2dlckVuZFF1ZXJ5KCkgICAgICAoaW1tZWRpYXRlIGNvbnN0cmFpbnRzKQorICoJLSBBZnRl
clRyaWdnZXJGaXJlRGVmZXJyZWQoKSAgKGRlZmVycmVkIGNvbnN0cmFpbnRzIGF0IENPTU1JVCkK
KyAqCS0gQWZ0ZXJUcmlnZ2VyU2V0U3RhdGUoKSAgICAgIChTRVQgQ09OU1RSQUlOVFMgSU1NRURJ
QVRFKQorICoKKyAqIFRoZSBjYWxsYmFjayBsaXN0IGlzIGNsZWFyZWQgYWZ0ZXIgZWFjaCBiYXRj
aC4gIENhbGxlcnMgbXVzdAorICogcmUtcmVnaXN0ZXIgaWYgdGhleSBuZWVkIHRvIGJlIGNhbGxl
ZCBhZ2FpbiBpbiBhIHN1YnNlcXVlbnQgYmF0Y2guCisgKi8KK3R5cGVkZWYgdm9pZCAoKkFmdGVy
VHJpZ2dlckJhdGNoQ2FsbGJhY2spICh2b2lkICphcmcpOworCitleHRlcm4gdm9pZCBSZWdpc3Rl
ckFmdGVyVHJpZ2dlckJhdGNoQ2FsbGJhY2soQWZ0ZXJUcmlnZ2VyQmF0Y2hDYWxsYmFjayBjYWxs
YmFjaywKKwkJCQkJCQkJCQkJICB2b2lkICphcmcpOworZXh0ZXJuIGJvb2wgQWZ0ZXJUcmlnZ2Vy
QmF0Y2hJc0FjdGl2ZSh2b2lkKTsKKwogI2VuZGlmCQkJCQkJCS8qIFRSSUdHRVJfSCAqLwpkaWZm
IC0tZ2l0IGEvc3JjL3Rlc3QvcmVncmVzcy9leHBlY3RlZC9mb3JlaWduX2tleS5vdXQgYi9zcmMv
dGVzdC9yZWdyZXNzL2V4cGVjdGVkL2ZvcmVpZ25fa2V5Lm91dAppbmRleCAwODI2ZjUxODAwNC4u
MjVkNTA1YzZjMTIgMTAwNjQ0Ci0tLSBhL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvZm9yZWln
bl9rZXkub3V0CisrKyBiL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvZm9yZWlnbl9rZXkub3V0
CkBAIC0zNTA0LDMgKzM1MDQsODkgQEAgREVUQUlMOiAgZHJvcCBjYXNjYWRlcyB0byB0YWJsZSBm
a3BhcnQxM190MQogZHJvcCBjYXNjYWRlcyB0byB0YWJsZSBma3BhcnQxM190MgogZHJvcCBjYXNj
YWRlcyB0byB0YWJsZSBma3BhcnQxM190MwogUkVTRVQgc2VhcmNoX3BhdGg7CistLSBUZXN0cyBm
b3JlaWduIGtleSBjaGVjayBmYXN0LXBhdGggbm8tY2FjaGUgcGF0aC4KK0NSRUFURSBUQUJMRSBm
cF9wa19hbHRlciAoYSBpbnQgUFJJTUFSWSBLRVkpOworSU5TRVJUIElOVE8gZnBfcGtfYWx0ZXIg
U0VMRUNUIGdlbmVyYXRlX3NlcmllcygxLCAxMDApOworQ1JFQVRFIFRBQkxFIGZwX2ZrX2FsdGVy
IChhIGludCk7CitJTlNFUlQgSU5UTyBmcF9ma19hbHRlciBTRUxFQ1QgZ2VuZXJhdGVfc2VyaWVz
KDEsIDEwMCk7CistLSBWYWxpZGF0aW9uIHBhdGg6IHNob3VsZCBzdWNjZWVkCitBTFRFUiBUQUJM
RSBmcF9ma19hbHRlciBBREQgRk9SRUlHTiBLRVkgKGEpIFJFRkVSRU5DRVMgZnBfcGtfYWx0ZXI7
CitJTlNFUlQgSU5UTyBmcF9ma19hbHRlciBWQUxVRVMgKDEwMSk7ICAtLSBzaG91bGQgZmFpbCAo
Y29uc3RyYWludCBhY3RpdmUpCitFUlJPUjogIGluc2VydCBvciB1cGRhdGUgb24gdGFibGUgImZw
X2ZrX2FsdGVyIiB2aW9sYXRlcyBmb3JlaWduIGtleSBjb25zdHJhaW50ICJmcF9ma19hbHRlcl9h
X2ZrZXkiCitERVRBSUw6ICBLZXkgKGEpPSgxMDEpIGlzIG5vdCBwcmVzZW50IGluIHRhYmxlICJm
cF9wa19hbHRlciIuCitEUk9QIFRBQkxFIGZwX2ZrX2FsdGVyLCBmcF9wa19hbHRlcjsKKy0tIFNl
cGFyYXRlIHRlc3Q6IHZhbGlkYXRpb24gY2F0Y2hlcyBleGlzdGluZyB2aW9sYXRpb24KK0NSRUFU
RSBUQUJMRSBmcF9wa19hbHRlcjIgKGEgaW50IFBSSU1BUlkgS0VZKTsKK0lOU0VSVCBJTlRPIGZw
X3BrX2FsdGVyMiBWQUxVRVMgKDEpOworQ1JFQVRFIFRBQkxFIGZwX2ZrX2FsdGVyMiAoYSBpbnQp
OworSU5TRVJUIElOVE8gZnBfZmtfYWx0ZXIyIFZBTFVFUyAoMSksICgyMDApOyAgLS0gMjAwIGhh
cyBubyBQSyBtYXRjaAorQUxURVIgVEFCTEUgZnBfZmtfYWx0ZXIyIEFERCBGT1JFSUdOIEtFWSAo
YSkgUkVGRVJFTkNFUyBmcF9wa19hbHRlcjI7ICAtLSBzaG91bGQgZmFpbAorRVJST1I6ICBpbnNl
cnQgb3IgdXBkYXRlIG9uIHRhYmxlICJmcF9ma19hbHRlcjIiIHZpb2xhdGVzIGZvcmVpZ24ga2V5
IGNvbnN0cmFpbnQgImZwX2ZrX2FsdGVyMl9hX2ZrZXkiCitERVRBSUw6ICBLZXkgKGEpPSgyMDAp
IGlzIG5vdCBwcmVzZW50IGluIHRhYmxlICJmcF9wa19hbHRlcjIiLgorRFJPUCBUQUJMRSBmcF9m
a19hbHRlcjIsIGZwX3BrX2FsdGVyMjsKKy0tIFRlc3RzIHRoYXQgdGhlIGZhc3QtcGF0aCBoYW5k
bGVzIGNhY2hpbmcgZm9yIG11bHRpcGxlIGNvbnN0cmFpbnRzCitDUkVBVEUgVEFCTEUgZnBfcGsx
IChhIGludCBQUklNQVJZIEtFWSk7CitDUkVBVEUgVEFCTEUgZnBfcGsyIChiIGludCBQUklNQVJZ
IEtFWSk7CitJTlNFUlQgSU5UTyBmcF9wazEgVkFMVUVTICgxKTsKK0lOU0VSVCBJTlRPIGZwX3Br
MiBWQUxVRVMgKDEpOworQ1JFQVRFIFRBQkxFIGZwX211bHRpX2ZrICgKKyAgICBhIGludCBSRUZF
UkVOQ0VTIGZwX3BrMSwKKyAgICBiIGludCBSRUZFUkVOQ0VTIGZwX3BrMgorKTsKK0lOU0VSVCBJ
TlRPIGZwX211bHRpX2ZrIFZBTFVFUyAoMSwgMSk7ICAtLSB0d28gY29uc3RyYWludHMsIG9uZSBi
YXRjaAorSU5TRVJUIElOVE8gZnBfbXVsdGlfZmsgVkFMVUVTICgxLCAyKTsgIC0tIHNlY29uZCBj
b25zdHJhaW50IGZhaWxzCitFUlJPUjogIGluc2VydCBvciB1cGRhdGUgb24gdGFibGUgImZwX211
bHRpX2ZrIiB2aW9sYXRlcyBmb3JlaWduIGtleSBjb25zdHJhaW50ICJmcF9tdWx0aV9ma19iX2Zr
ZXkiCitERVRBSUw6ICBLZXkgKGIpPSgyKSBpcyBub3QgcHJlc2VudCBpbiB0YWJsZSAiZnBfcGsy
Ii4KK0RST1AgVEFCTEUgZnBfbXVsdGlfZmssIGZwX3BrMSwgZnBfcGsyOworLS0gVGVzdCB0aGF0
IGZhc3QtcGF0aCBjYWNoZSBoYW5kbGVzIGRlZmVycmVkIGNvbnN0cmFpbnRzIGFuZCBTRVQgQ09O
U1RSQUlOVFMgSU1NRURJQVRFCitDUkVBVEUgVEFCTEUgZnBfcGtfZGVmZXIgKGEgaW50IFBSSU1B
UlkgS0VZKTsKK0NSRUFURSBUQUJMRSBmcF9ma19kZWZlciAoYSBpbnQgUkVGRVJFTkNFUyBmcF9w
a19kZWZlciBERUZFUlJBQkxFIElOSVRJQUxMWSBERUZFUlJFRCk7CitJTlNFUlQgSU5UTyBmcF9w
a19kZWZlciBWQUxVRVMgKDEpLCAoMik7CitCRUdJTjsKK0lOU0VSVCBJTlRPIGZwX2ZrX2RlZmVy
IFZBTFVFUyAoMSk7CitJTlNFUlQgSU5UTyBmcF9ma19kZWZlciBWQUxVRVMgKDIpOworU0VUIENP
TlNUUkFJTlRTIEFMTCBJTU1FRElBVEU7ICAtLSBmaXJlcyBiYXRjaCBjYWxsYmFjayBoZXJlCitJ
TlNFUlQgSU5UTyBmcF9ma19kZWZlciBWQUxVRVMgKDMpOyAgLS0gc2hvdWxkIGZhaWwsIGFsc28g
dGVzdHMgdGhhdCBjYWNoZSB3YXMgY2xlYW5lZCB1cAorRVJST1I6ICBpbnNlcnQgb3IgdXBkYXRl
IG9uIHRhYmxlICJmcF9ma19kZWZlciIgdmlvbGF0ZXMgZm9yZWlnbiBrZXkgY29uc3RyYWludCAi
ZnBfZmtfZGVmZXJfYV9ma2V5IgorREVUQUlMOiAgS2V5IChhKT0oMykgaXMgbm90IHByZXNlbnQg
aW4gdGFibGUgImZwX3BrX2RlZmVyIi4KK0NPTU1JVDsKK0RST1AgVEFCTEUgZnBfcGtfZGVmZXIs
IGZwX2ZrX2RlZmVyOworLS0gU3VidHJhbnNhY3Rpb24gYWJvcnQ6IGNhY2hlZCBzdGF0ZSBtdXN0
IGJlIGludmFsaWRhdGVkIG9uIFJPTExCQUNLIFRPCitDUkVBVEUgVEFCTEUgZnBfcGtfc3VieGFj
dCAoYSBpbnQgUFJJTUFSWSBLRVkpOworQ1JFQVRFIFRBQkxFIGZwX2ZrX3N1YnhhY3QgKGEgaW50
IFJFRkVSRU5DRVMgZnBfcGtfc3VieGFjdCk7CitJTlNFUlQgSU5UTyBmcF9wa19zdWJ4YWN0IFZB
TFVFUyAoMSksICgyKTsKK0JFR0lOOworSU5TRVJUIElOVE8gZnBfZmtfc3VieGFjdCBWQUxVRVMg
KDEpOworU0FWRVBPSU5UIHNwMTsKK0lOU0VSVCBJTlRPIGZwX2ZrX3N1YnhhY3QgVkFMVUVTICgy
KTsKK1JPTExCQUNLIFRPIHNwMTsKK0lOU0VSVCBJTlRPIGZwX2ZrX3N1YnhhY3QgVkFMVUVTICgx
KTsKK0NPTU1JVDsKK1NFTEVDVCAqIEZST00gZnBfZmtfc3VieGFjdDsKKyBhIAorLS0tCisgMQor
IDEKKygyIHJvd3MpCisKK0RST1AgVEFCTEUgZnBfZmtfc3VieGFjdCwgZnBfcGtfc3VieGFjdDsK
Ky0tIEZLIGNoZWNrIG11c3Qgc2VlIFBLIHJvd3MgaW5zZXJ0ZWQgYnkgZWFybGllciBBRlRFUiB0
cmlnZ2VycworLS0gZmlyaW5nIG9uIHRoZSBzYW1lIHN0YXRlbWVudAorQ1JFQVRFIFRBQkxFIGZw
X3BrX2NjaSAoYSBpbnQgUFJJTUFSWSBLRVkpOworQ1JFQVRFIFRBQkxFIGZwX2ZrX2NjaSAoYSBp
bnQgUkVGRVJFTkNFUyBmcF9wa19jY2kpOworQ1JFQVRFIEZVTkNUSU9OIGZwX2F1dG9fcGsoKSBS
RVRVUk5TIHRyaWdnZXIgQVMgJCQKK0JFR0lOCisgIFJBSVNFIE5PVElDRSAnZnBfYXV0b19wayBj
YWxsZWQnOworICBJTlNFUlQgSU5UTyBmcF9wa19jY2kgVkFMVUVTIChORVcuYSk7CisgIFJFVFVS
TiBORVc7CitFTkQgJCQgTEFOR1VBR0UgcGxwZ3NxbDsKKy0tIE5hbWUgc29ydHMgYmVmb3JlIHRo
ZSBSSSB0cmlnZ2VyLCBzbyBmaXJlcyBmaXJzdCBwZXIgcm93CitDUkVBVEUgVFJJR0dFUiAiQUFB
X2F1dG8iIEFGVEVSIElOU0VSVCBPTiBmcF9ma19jY2kKKyAgRk9SIEVBQ0ggUk9XIEVYRUNVVEUg
RlVOQ1RJT04gZnBfYXV0b19waygpOworLS0gU2hvdWxkIHN1Y2NlZWQ6IEFBQV9hdXRvIHByb3Zp
c2lvbnMgdGhlIFBLIHJvdyBiZWZvcmUgUkkgY2hlY2sKK0lOU0VSVCBJTlRPIGZwX2ZrX2NjaSBW
QUxVRVMgKDEpLCAoMiksICgzKTsKK05PVElDRTogIGZwX2F1dG9fcGsgY2FsbGVkCitOT1RJQ0U6
ICBmcF9hdXRvX3BrIGNhbGxlZAorTk9USUNFOiAgZnBfYXV0b19wayBjYWxsZWQKK0RST1AgVEFC
TEUgZnBfZmtfY2NpLCBmcF9wa19jY2k7CitEUk9QIEZVTkNUSU9OIGZwX2F1dG9fcGs7CmRpZmYg
LS1naXQgYS9zcmMvdGVzdC9yZWdyZXNzL3NxbC9mb3JlaWduX2tleS5zcWwgYi9zcmMvdGVzdC9y
ZWdyZXNzL3NxbC9mb3JlaWduX2tleS5zcWwKaW5kZXggZTllZTI5MzMxY2IuLmNlZGQyMGM4ZDEx
IDEwMDY0NAotLS0gYS9zcmMvdGVzdC9yZWdyZXNzL3NxbC9mb3JlaWduX2tleS5zcWwKKysrIGIv
c3JjL3Rlc3QvcmVncmVzcy9zcWwvZm9yZWlnbl9rZXkuc3FsCkBAIC0yNDk4LDMgKzI0OTgsODMg
QEAgV0lUSCBjdGUgQVMgKAogCiBEUk9QIFNDSEVNQSBma3BhcnQxMyBDQVNDQURFOwogUkVTRVQg
c2VhcmNoX3BhdGg7CisKKy0tIFRlc3RzIGZvcmVpZ24ga2V5IGNoZWNrIGZhc3QtcGF0aCBuby1j
YWNoZSBwYXRoLgorQ1JFQVRFIFRBQkxFIGZwX3BrX2FsdGVyIChhIGludCBQUklNQVJZIEtFWSk7
CitJTlNFUlQgSU5UTyBmcF9wa19hbHRlciBTRUxFQ1QgZ2VuZXJhdGVfc2VyaWVzKDEsIDEwMCk7
CitDUkVBVEUgVEFCTEUgZnBfZmtfYWx0ZXIgKGEgaW50KTsKK0lOU0VSVCBJTlRPIGZwX2ZrX2Fs
dGVyIFNFTEVDVCBnZW5lcmF0ZV9zZXJpZXMoMSwgMTAwKTsKKy0tIFZhbGlkYXRpb24gcGF0aDog
c2hvdWxkIHN1Y2NlZWQKK0FMVEVSIFRBQkxFIGZwX2ZrX2FsdGVyIEFERCBGT1JFSUdOIEtFWSAo
YSkgUkVGRVJFTkNFUyBmcF9wa19hbHRlcjsKK0lOU0VSVCBJTlRPIGZwX2ZrX2FsdGVyIFZBTFVF
UyAoMTAxKTsgIC0tIHNob3VsZCBmYWlsIChjb25zdHJhaW50IGFjdGl2ZSkKK0RST1AgVEFCTEUg
ZnBfZmtfYWx0ZXIsIGZwX3BrX2FsdGVyOworCistLSBTZXBhcmF0ZSB0ZXN0OiB2YWxpZGF0aW9u
IGNhdGNoZXMgZXhpc3RpbmcgdmlvbGF0aW9uCitDUkVBVEUgVEFCTEUgZnBfcGtfYWx0ZXIyIChh
IGludCBQUklNQVJZIEtFWSk7CitJTlNFUlQgSU5UTyBmcF9wa19hbHRlcjIgVkFMVUVTICgxKTsK
K0NSRUFURSBUQUJMRSBmcF9ma19hbHRlcjIgKGEgaW50KTsKK0lOU0VSVCBJTlRPIGZwX2ZrX2Fs
dGVyMiBWQUxVRVMgKDEpLCAoMjAwKTsgIC0tIDIwMCBoYXMgbm8gUEsgbWF0Y2gKK0FMVEVSIFRB
QkxFIGZwX2ZrX2FsdGVyMiBBREQgRk9SRUlHTiBLRVkgKGEpIFJFRkVSRU5DRVMgZnBfcGtfYWx0
ZXIyOyAgLS0gc2hvdWxkIGZhaWwKK0RST1AgVEFCTEUgZnBfZmtfYWx0ZXIyLCBmcF9wa19hbHRl
cjI7CisKKy0tIFRlc3RzIHRoYXQgdGhlIGZhc3QtcGF0aCBoYW5kbGVzIGNhY2hpbmcgZm9yIG11
bHRpcGxlIGNvbnN0cmFpbnRzCitDUkVBVEUgVEFCTEUgZnBfcGsxIChhIGludCBQUklNQVJZIEtF
WSk7CitDUkVBVEUgVEFCTEUgZnBfcGsyIChiIGludCBQUklNQVJZIEtFWSk7CitJTlNFUlQgSU5U
TyBmcF9wazEgVkFMVUVTICgxKTsKK0lOU0VSVCBJTlRPIGZwX3BrMiBWQUxVRVMgKDEpOworQ1JF
QVRFIFRBQkxFIGZwX211bHRpX2ZrICgKKyAgICBhIGludCBSRUZFUkVOQ0VTIGZwX3BrMSwKKyAg
ICBiIGludCBSRUZFUkVOQ0VTIGZwX3BrMgorKTsKK0lOU0VSVCBJTlRPIGZwX211bHRpX2ZrIFZB
TFVFUyAoMSwgMSk7ICAtLSB0d28gY29uc3RyYWludHMsIG9uZSBiYXRjaAorSU5TRVJUIElOVE8g
ZnBfbXVsdGlfZmsgVkFMVUVTICgxLCAyKTsgIC0tIHNlY29uZCBjb25zdHJhaW50IGZhaWxzCitE
Uk9QIFRBQkxFIGZwX211bHRpX2ZrLCBmcF9wazEsIGZwX3BrMjsKKworLS0gVGVzdCB0aGF0IGZh
c3QtcGF0aCBjYWNoZSBoYW5kbGVzIGRlZmVycmVkIGNvbnN0cmFpbnRzIGFuZCBTRVQgQ09OU1RS
QUlOVFMgSU1NRURJQVRFCitDUkVBVEUgVEFCTEUgZnBfcGtfZGVmZXIgKGEgaW50IFBSSU1BUlkg
S0VZKTsKK0NSRUFURSBUQUJMRSBmcF9ma19kZWZlciAoYSBpbnQgUkVGRVJFTkNFUyBmcF9wa19k
ZWZlciBERUZFUlJBQkxFIElOSVRJQUxMWSBERUZFUlJFRCk7CitJTlNFUlQgSU5UTyBmcF9wa19k
ZWZlciBWQUxVRVMgKDEpLCAoMik7CisKK0JFR0lOOworSU5TRVJUIElOVE8gZnBfZmtfZGVmZXIg
VkFMVUVTICgxKTsKK0lOU0VSVCBJTlRPIGZwX2ZrX2RlZmVyIFZBTFVFUyAoMik7CitTRVQgQ09O
U1RSQUlOVFMgQUxMIElNTUVESUFURTsgIC0tIGZpcmVzIGJhdGNoIGNhbGxiYWNrIGhlcmUKK0lO
U0VSVCBJTlRPIGZwX2ZrX2RlZmVyIFZBTFVFUyAoMyk7ICAtLSBzaG91bGQgZmFpbCwgYWxzbyB0
ZXN0cyB0aGF0IGNhY2hlIHdhcyBjbGVhbmVkIHVwCitDT01NSVQ7CitEUk9QIFRBQkxFIGZwX3Br
X2RlZmVyLCBmcF9ma19kZWZlcjsKKworLS0gU3VidHJhbnNhY3Rpb24gYWJvcnQ6IGNhY2hlZCBz
dGF0ZSBtdXN0IGJlIGludmFsaWRhdGVkIG9uIFJPTExCQUNLIFRPCitDUkVBVEUgVEFCTEUgZnBf
cGtfc3VieGFjdCAoYSBpbnQgUFJJTUFSWSBLRVkpOworQ1JFQVRFIFRBQkxFIGZwX2ZrX3N1Ynhh
Y3QgKGEgaW50IFJFRkVSRU5DRVMgZnBfcGtfc3VieGFjdCk7CitJTlNFUlQgSU5UTyBmcF9wa19z
dWJ4YWN0IFZBTFVFUyAoMSksICgyKTsKK0JFR0lOOworSU5TRVJUIElOVE8gZnBfZmtfc3VieGFj
dCBWQUxVRVMgKDEpOworU0FWRVBPSU5UIHNwMTsKK0lOU0VSVCBJTlRPIGZwX2ZrX3N1YnhhY3Qg
VkFMVUVTICgyKTsKK1JPTExCQUNLIFRPIHNwMTsKK0lOU0VSVCBJTlRPIGZwX2ZrX3N1YnhhY3Qg
VkFMVUVTICgxKTsKK0NPTU1JVDsKK1NFTEVDVCAqIEZST00gZnBfZmtfc3VieGFjdDsKK0RST1Ag
VEFCTEUgZnBfZmtfc3VieGFjdCwgZnBfcGtfc3VieGFjdDsKKworLS0gRksgY2hlY2sgbXVzdCBz
ZWUgUEsgcm93cyBpbnNlcnRlZCBieSBlYXJsaWVyIEFGVEVSIHRyaWdnZXJzCistLSBmaXJpbmcg
b24gdGhlIHNhbWUgc3RhdGVtZW50CitDUkVBVEUgVEFCTEUgZnBfcGtfY2NpIChhIGludCBQUklN
QVJZIEtFWSk7CitDUkVBVEUgVEFCTEUgZnBfZmtfY2NpIChhIGludCBSRUZFUkVOQ0VTIGZwX3Br
X2NjaSk7CisKK0NSRUFURSBGVU5DVElPTiBmcF9hdXRvX3BrKCkgUkVUVVJOUyB0cmlnZ2VyIEFT
ICQkCitCRUdJTgorICBSQUlTRSBOT1RJQ0UgJ2ZwX2F1dG9fcGsgY2FsbGVkJzsKKyAgSU5TRVJU
IElOVE8gZnBfcGtfY2NpIFZBTFVFUyAoTkVXLmEpOworICBSRVRVUk4gTkVXOworRU5EICQkIExB
TkdVQUdFIHBscGdzcWw7CisKKy0tIE5hbWUgc29ydHMgYmVmb3JlIHRoZSBSSSB0cmlnZ2VyLCBz
byBmaXJlcyBmaXJzdCBwZXIgcm93CitDUkVBVEUgVFJJR0dFUiAiQUFBX2F1dG8iIEFGVEVSIElO
U0VSVCBPTiBmcF9ma19jY2kKKyAgRk9SIEVBQ0ggUk9XIEVYRUNVVEUgRlVOQ1RJT04gZnBfYXV0
b19waygpOworCistLSBTaG91bGQgc3VjY2VlZDogQUFBX2F1dG8gcHJvdmlzaW9ucyB0aGUgUEsg
cm93IGJlZm9yZSBSSSBjaGVjaworSU5TRVJUIElOVE8gZnBfZmtfY2NpIFZBTFVFUyAoMSksICgy
KSwgKDMpOworCitEUk9QIFRBQkxFIGZwX2ZrX2NjaSwgZnBfcGtfY2NpOworRFJPUCBGVU5DVElP
TiBmcF9hdXRvX3BrOwpkaWZmIC0tZ2l0IGEvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxp
c3QgYi9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdAppbmRleCBmODQwZjQ3MWIzNS4u
MTAwOTg2YjNkODQgMTAwNjQ0Ci0tLSBhL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0
CisrKyBiL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0CkBAIC0zMCw2ICszMCw4IEBA
IEFkZEZvcmVpZ25VcGRhdGVUYXJnZXRzX2Z1bmN0aW9uCiBBZGRySW5mbwogQWZmaXhOb2RlCiBB
ZmZpeE5vZGVEYXRhCitBZnRlclRyaWdnZXJCYXRjaENhbGxiYWNrCitBZnRlclRyaWdnZXJDYWxs
YmFja0l0ZW0KIEFmdGVyVHJpZ2dlckV2ZW50CiBBZnRlclRyaWdnZXJFdmVudENodW5rCiBBZnRl
clRyaWdnZXJFdmVudERhdGEKQEAgLTI0NzIsNiArMjQ3NCw3IEBAIFJJWAogUklfQ29tcGFyZUhh
c2hFbnRyeQogUklfQ29tcGFyZUtleQogUklfQ29uc3RyYWludEluZm8KK1JJX0Zhc3RQYXRoRW50
cnkKIFJJX1F1ZXJ5SGFzaEVudHJ5CiBSSV9RdWVyeUtleQogUlRFS2luZAotLSAKMi40MS4wCgo=
--000000000000130115064d62f122
Content-Type: application/octet-stream;
	name="v8-0003-Batch-FK-rows-and-use-SK_SEARCHARRAY-for-fast-pat.patch"
Content-Disposition: attachment;
	filename="v8-0003-Batch-FK-rows-and-use-SK_SEARCHARRAY-for-fast-pat.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmxoe2jn0>
X-Attachment-Id: f_mmxoe2jn0
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--000000000000130115064d62f122--