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>
In-Reply-To: 
 <CAEG8a3L9Ew-WL8sxLROVOcypeaENPmd8qCmMvz4geoGL1TDGCA@mail.gmail.com>
From: Junwang Zhao <zhjwpku@gmail.com>
Date: Tue, 10 Mar 2026 20:28:47 +0800
Message-ID: 
 <CAEG8a3+nUFQo4sdPQF9xy0J73J8RFJ5U9A5+_kMosGDaZ+1sXA@mail.gmail.com>
Subject: Re: Eliminating SPI / SQL from some RI triggers - take 3
To: Amit Langote <amitlangote09@gmail.com>
Cc: Pavel Stehule <pavel.stehule@gmail.com>,
	PostgreSQL-development <pgsql-hackers@postgresql.org>
Content-Type: multipart/mixed; boundary="0000000000000d9ac2064caaaa1f"
Archived-At: 
 <https://www.postgresql.org/message-id/CAEG8a3%2BnUFQo4sdPQF9xy0J73J8RFJ5U9A5%2B_kMosGDaZ%2B1sXA%40mail.gmail.com>
Precedence: bulk

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

Hi,

On Mon, Mar 2, 2026 at 11:30=E2=80=AFPM Junwang Zhao <zhjwpku@gmail.com> wr=
ote:
>
> On Sat, Feb 28, 2026 at 3:08=E2=80=AFPM Amit Langote <amitlangote09@gmail=
.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@g=
mail.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 ni=
t,
> > > maybe merge the following two if conditions into one, not a strong op=
inion
> > > 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-constrain=
t
> > > > cache (0002 already has the right structure for this), build a
> > > > SK_SEARCHARRAY scan key, and let the btree AM walk the matching lea=
f
> > > > pages in one sorted traversal instead of one tree descent per row. =
The
> > > > locking and recheck would still be per-tuple, but the index travers=
al
> > > > cost drops significantly. Single-column FKs are the obvious startin=
g
> > > > point. That seems worth exploring but can be done as a separate pat=
ch
> > > > 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@g=
mail.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-pat=
h + fallback"
> > > > > design.
> > > > >
> > > > > 0001 adds a fast path optimization for foreign key constraint che=
cks
> > > > > that bypasses the SPI executor, the fast path applies when the re=
ferenced
> > > > > table is not partitioned, and the constraint does not involve tem=
poral
> > > > > 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 cur=
rent
> > > > > time only comparison operator hash entries, operator function OID=
s
> > > > > and strategy numbers and subtypes for index scans. But this cache
> > > > > doesn't buy any performance improvement.
> > > > >
> > > > > Caching additional metadata should improve performance for foreig=
n key checks.
> > > > >
> > > > > Amit suggested introducing a mechanism for ri_triggers.c to regis=
ter a
> > > > > cleanup callback in the EState, which AfterTriggerEndQuery() coul=
d then
> > > > > invoke to release per-statement cached metadata (such as the Inde=
xScanDesc).
> > > > > 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 y=
our
> > > > 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 th=
e
> > > > latter turned out to be not so hard thanks to the structure you cho=
se
> > > > to build the core fast path.  Good call on adding the RLS and ACL t=
est
> > > > 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 defer=
red
> > > > ones). It layers resource caching on top so that the PK relation,
> > > > index, scan descriptor, and snapshot stay open across all FK trigge=
r
> > > > 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 relat=
ion
> > > > 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 workload=
s,
> > > > 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-constrain=
t
> > > > cache (0002 already has the right structure for this), build a
> > > > SK_SEARCHARRAY scan key, and let the btree AM walk the matching lea=
f
> > > > pages in one sorted traversal instead of one tree descent per row. =
The
> > > > locking and recheck would still be per-tuple, but the index travers=
al
> > > > cost drops significantly. Single-column FKs are the obvious startin=
g
> > > > point. That seems worth exploring but can be done as a separate pat=
ch
> > > > 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 extr=
a
> > > > 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 ni=
t,
> > > maybe merge the following two if conditions into one, not a strong op=
inion
> > > 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 things
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 creation
function is called once per batch rather than once per row, so the overall
impact is minimal. I'm posting this here for Amit to take a look and decide
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 allo=
ws
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.

--=20
Regards
Junwang Zhao

--0000000000000d9ac2064caaaa1f
Content-Type: application/octet-stream;
	name="v5-0005-Use-SK_SEARCHARRAY-for-batched-fast-path-FK-probe.patch"
Content-Disposition: attachment;
	filename="v5-0005-Use-SK_SEARCHARRAY-for-batched-fast-path-FK-probe.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmkjv7ap1>
X-Attachment-Id: f_mmkjv7ap1

RnJvbSA0MGJjNjAzMDZiZTE3NGFlNTRhYjEzMjBmMGQ3N2M4ZmI2YWZiMmZmIE1vbiBTZXAgMTcg
MDA6MDA6MDAgMjAwMQpGcm9tOiBBbWl0IExhbmdvdGUgPGFtaXRsYW5AcG9zdGdyZXNxbC5vcmc+
CkRhdGU6IFdlZCwgMjUgRmViIDIwMjYgMjE6MjU6MjUgKzA5MDAKU3ViamVjdDogW1BBVENIIHY1
IDUvNl0gVXNlIFNLX1NFQVJDSEFSUkFZIGZvciBiYXRjaGVkIGZhc3QtcGF0aCBGSyBwcm9iZXMK
CkZvciBzaW5nbGUtY29sdW1uIGZvcmVpZ24ga2V5cywgcmVwbGFjZSB0aGUgcGVyLXJvdyBpbmRl
eCBwcm9iZSBsb29wCmluIHJpX0Zhc3RQYXRoQmF0Y2hGbHVzaCgpIHdpdGggYSBzaW5nbGUgU0tf
U0VBUkNIQVJSQVkgc2NhbiBrZXkuClRoZSBidHJlZSBBTSBzb3J0cyBhbmQgZGVkdXBsaWNhdGVz
IHRoZSBhcnJheSBpbnRlcm5hbGx5LCB0aGVuIHdhbGtzCnRoZSBtYXRjaGluZyBsZWFmIHBhZ2Vz
IGluIG9uZSBvcmRlcmVkIHRyYXZlcnNhbCBpbnN0ZWFkIG9mIGRlc2NlbmRpbmcKZnJvbSB0aGUg
cm9vdCBvbmNlIHBlciByb3cuCgpyaV9GYXN0UGF0aEJhdGNoRmx1c2goKSBub3cgZGlzcGF0Y2hl
cyB0byByaV9GYXN0UGF0aEZsdXNoQXJyYXkoKSBmb3IKc2luZ2xlLWNvbHVtbiBGS3MgYW5kIHJp
X0Zhc3RQYXRoRmx1c2hMb29wKCkgZm9yIG11bHRpLWNvbHVtbiBGS3MsCndoaWNoIHJldGFpbnMg
dGhlIHBlci1yb3cgcHJvYmUgbG9vcC4KCnJpX0Zhc3RQYXRoRmx1c2hBcnJheSgpIGJ1aWxkcyBh
biBBcnJheVR5cGUgZnJvbSB0aGUgYnVmZmVyZWQgRksKdmFsdWVzIChjYXN0aW5nIHRvIHRoZSBQ
Sy1zaWRlIHR5cGUgaWYgbmVlZGVkKSwgY29uc3RydWN0cyBhIHNjYW4ga2V5CndpdGggdGhlIFNL
X1NFQVJDSEFSUkFZIGZsYWcsIGFuZCBpdGVyYXRlcyB0aGUgbWF0Y2hlcy4gIEVhY2ggbWF0Y2hl
ZApQSyB0dXBsZSBpcyBsb2NrZWQgYW5kIHJlY2hlY2tlZCBhcyBiZWZvcmUuICBBIG1hdGNoZWRb
XSBiaXRtYXAgdHJhY2tzCndoaWNoIGJhdGNoIGl0ZW1zIHdlcmUgc2F0aXNmaWVkOyB1bm1hdGNo
ZWQgaXRlbXMgYXJlIHJlcG9ydGVkIGFzCnZpb2xhdGlvbnMuCgpXaXRoIGEgYmF0Y2ggc2l6ZSBv
ZiA2NCBhbmQgaW50L2ludCBGSywgdGhpcyBnaXZlcyBhIDMuM3ggc3BlZWR1cApvdmVyIHVucGF0
Y2hlZCBtYXN0ZXIgKHZzIDIuMnggd2l0aCBwZXItcm93IHByb2JpbmcgYWxvbmUpLgotLS0KIHNy
Yy9iYWNrZW5kL3V0aWxzL2FkdC9yaV90cmlnZ2Vycy5jICAgICAgIHwgMjg4ICsrKysrKysrKysr
KysrKysrLS0tLS0KIHNyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvZm9yZWlnbl9rZXkub3V0IHwg
IDE3ICsrCiBzcmMvdGVzdC9yZWdyZXNzL3NxbC9mb3JlaWduX2tleS5zcWwgICAgICB8ICAxNyAr
KwogMyBmaWxlcyBjaGFuZ2VkLCAyNjIgaW5zZXJ0aW9ucygrKSwgNjAgZGVsZXRpb25zKC0pCgpk
aWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L3JpX3RyaWdnZXJzLmMgYi9zcmMvYmFj
a2VuZC91dGlscy9hZHQvcmlfdHJpZ2dlcnMuYwppbmRleCAyMDBjNDA5NDg2MS4uZWIxMTJhYWJj
OTggMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9yaV90cmlnZ2Vycy5jCisrKyBi
L3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9yaV90cmlnZ2Vycy5jCkBAIC0yMjQsNiArMjI0LDEwIEBA
IHR5cGVkZWYgc3RydWN0IFJJX0Zhc3RQYXRoRW50cnkKIAogCS8qIEZvciByaV9GYXN0UGF0aEVu
ZEJhdGNoKCkgKi8KIAljb25zdCBSSV9Db25zdHJhaW50SW5mbyAqcmlpbmZvOworCisJLyogRm9y
IHJpX0Zhc3RQYXRoRmx1c2hBcnJheSgpICovCisJRGF0dW0JCXNlYXJjaF92YWxzW1JJX0ZBU1RQ
QVRIX0JBVENIX1NJWkVdOworCWJvb2wJCW1hdGNoZWRbUklfRkFTVFBBVEhfQkFUQ0hfU0laRV07
CiB9IFJJX0Zhc3RQYXRoRW50cnk7CiAKIC8qCkBAIC0zMTUsNiArMzE5LDEwIEBAIHN0YXRpYyB2
b2lkIHJpX0Zhc3RQYXRoRW5kQmF0Y2godm9pZCAqYXJnKTsKIHN0YXRpYyB2b2lkIHJpX0Zhc3RQ
YXRoVGVhcmRvd24odm9pZCk7CiBzdGF0aWMgdm9pZCByaV9GYXN0UGF0aEJhdGNoQWRkKGNvbnN0
IFJJX0NvbnN0cmFpbnRJbmZvICpyaWluZm8sCiAJCQkJCQkJCVJlbGF0aW9uIGZrX3JlbCwgVHVw
bGVUYWJsZVNsb3QgKm5ld3Nsb3QpOworc3RhdGljIHZvaWQgcmlfRmFzdFBhdGhGbHVzaEFycmF5
KFJJX0Zhc3RQYXRoRW50cnkgKmZwZW50cnksIFR1cGxlVGFibGVTbG90ICpma19zbG90LAorCQkJ
CQkJCQkgIGNvbnN0IFJJX0NvbnN0cmFpbnRJbmZvICpyaWluZm8sIFJlbGF0aW9uIGZrX3JlbCk7
CitzdGF0aWMgdm9pZCByaV9GYXN0UGF0aEZsdXNoTG9vcChSSV9GYXN0UGF0aEVudHJ5ICpmcGVu
dHJ5LCBUdXBsZVRhYmxlU2xvdCAqZmtfc2xvdCwKKwkJCQkJCQkJIGNvbnN0IFJJX0NvbnN0cmFp
bnRJbmZvICpyaWluZm8sIFJlbGF0aW9uIGZrX3JlbCk7CiBzdGF0aWMgdm9pZCByaV9GYXN0UGF0
aEJhdGNoRmx1c2goUklfRmFzdFBhdGhFbnRyeSAqZnBlbnRyeSwKIAkJCQkJCQkJICBSZWxhdGlv
biBma19yZWwpOwogCkBAIC00MDAzLDEwMiArNDAxMSwyNjIgQEAgcmlfRmFzdFBhdGhHZXRFbnRy
eShjb25zdCBSSV9Db25zdHJhaW50SW5mbyAqcmlpbmZvKQogCXJldHVybiBlbnRyeTsKIH0KIAor
LyoKKyAqIHJpX0Zhc3RQYXRoRmx1c2hMb29wCisgKgkJTXVsdGktY29sdW1uIGZhbGxiYWNrOiBw
cm9iZSB0aGUgaW5kZXggb25jZSBwZXIgYnVmZmVyZWQgcm93LgorICoKKyAqIFVzZWQgZm9yIGNv
bXBvc2l0ZSBmb3JlaWduIGtleXMgd2hlcmUgU0tfU0VBUkNIQVJSQVkgZG9lcyBub3QKKyAqIGFw
cGx5LgorICovCiBzdGF0aWMgdm9pZAotcmlfRmFzdFBhdGhCYXRjaEZsdXNoKFJJX0Zhc3RQYXRo
RW50cnkgKmZwZW50cnksIFJlbGF0aW9uIGZrX3JlbCkKK3JpX0Zhc3RQYXRoRmx1c2hMb29wKFJJ
X0Zhc3RQYXRoRW50cnkgKmZwZW50cnksIFR1cGxlVGFibGVTbG90ICpma19zbG90LAorCQkJCQkg
Y29uc3QgUklfQ29uc3RyYWludEluZm8gKnJpaW5mbywgUmVsYXRpb24gZmtfcmVsKQogewotCWNv
bnN0IFJJX0NvbnN0cmFpbnRJbmZvICpyaWluZm8gPSBmcGVudHJ5LT5yaWluZm87CiAJUmVsYXRp
b24JcGtfcmVsID0gZnBlbnRyeS0+cGtfcmVsOwogCVJlbGF0aW9uCWlkeF9yZWwgPSBmcGVudHJ5
LT5pZHhfcmVsOwogCUluZGV4U2NhbkRlc2Mgc2NhbmRlc2MgPSBmcGVudHJ5LT5zY2FuZGVzYzsK
IAlUdXBsZVRhYmxlU2xvdCAqc2xvdCA9IGZwZW50cnktPnNsb3Q7CiAJU25hcHNob3QJc25hcHNo
b3QgPSBmcGVudHJ5LT5zbmFwc2hvdDsKLQlUdXBsZVRhYmxlU2xvdCAqZmtfc2xvdDsKIAlEYXR1
bQkJcGtfdmFsc1tJTkRFWF9NQVhfS0VZU107CiAJY2hhcgkJcGtfbnVsbHNbSU5ERVhfTUFYX0tF
WVNdOwogCVNjYW5LZXlEYXRhIHNrZXlbSU5ERVhfTUFYX0tFWVNdOwotCU9pZAkJCXNhdmVkX3Vz
ZXJpZDsKLQlpbnQJCQlzYXZlZF9zZWNfY29udGV4dDsKLQlNZW1vcnlDb250ZXh0IG9sZGN4dDsK
IAotCWlmIChmcGVudHJ5LT5iYXRjaF9jb3VudCA9PSAwKQotCQlyZXR1cm47CisJZm9yIChpbnQg
aSA9IDA7IGkgPCBmcGVudHJ5LT5iYXRjaF9jb3VudDsgaSsrKQorCXsKKwkJYm9vbAlmb3VuZCA9
IGZhbHNlOwogCi0JaWYgKHJpaW5mby0+ZnBtZXRhID09IE5VTEwpCi0JCXJpX3BvcHVsYXRlX2Zh
c3RwYXRoX21ldGFkYXRhKChSSV9Db25zdHJhaW50SW5mbyAqKSByaWluZm8sCi0JCQkJCQkJCQkg
IGZrX3JlbCwgaWR4X3JlbCk7Ci0JQXNzZXJ0KHJpaW5mby0+ZnBtZXRhKTsKKwkJRXhlY1N0b3Jl
SGVhcFR1cGxlKGZwZW50cnktPmJhdGNoW2ldLCBma19zbG90LCBmYWxzZSk7CiAKLQlDb21tYW5k
Q291bnRlckluY3JlbWVudCgpOwotCXNuYXBzaG90LT5jdXJjaWQgPSBHZXRDdXJyZW50Q29tbWFu
ZElkKGZhbHNlKTsKKwkJcmlfRXh0cmFjdFZhbHVlcyhma19yZWwsIGZrX3Nsb3QsIHJpaW5mbywg
ZmFsc2UsIHBrX3ZhbHMsIHBrX251bGxzKTsKKwkJYnVpbGRfaW5kZXhfc2NhbmtleXMocmlpbmZv
LCBpZHhfcmVsLCBwa192YWxzLCBwa19udWxscywgc2tleSk7CisJCWZvdW5kID0gcmlfRmFzdFBh
dGhQcm9iZU9uZShwa19yZWwsIGlkeF9yZWwsIHNjYW5kZXNjLAorCQkJCQkJCQkJZnBlbnRyeS0+
eGFjdF9zY2FuLCBzbG90LAorCQkJCQkJCQkJc25hcHNob3QsIGZwZW50cnktPnhhY3Rfc25hcCwK
KwkJCQkJCQkJCXJpaW5mbywgc2tleSwgcmlpbmZvLT5ua2V5cywKKwkJCQkJCQkJCXRydWUpOwog
Ci0JR2V0VXNlcklkQW5kU2VjQ29udGV4dCgmc2F2ZWRfdXNlcmlkLCAmc2F2ZWRfc2VjX2NvbnRl
eHQpOwotCVNldFVzZXJJZEFuZFNlY0NvbnRleHQoUmVsYXRpb25HZXRGb3JtKHBrX3JlbCktPnJl
bG93bmVyLAotCQkJCQkJICAgc2F2ZWRfc2VjX2NvbnRleHQgfAotCQkJCQkJICAgU0VDVVJJVFlf
TE9DQUxfVVNFUklEX0NIQU5HRSB8Ci0JCQkJCQkgICBTRUNVUklUWV9OT0ZPUkNFX1JMUyk7CisJ
CWlmICghZm91bmQpCisJCQlyaV9SZXBvcnRWaW9sYXRpb24ocmlpbmZvLCBwa19yZWwsIGZrX3Jl
bCwKKwkJCQkJCQkgICBma19zbG90LCBOVUxMLAorCQkJCQkJCSAgIFJJX1BMQU5fQ0hFQ0tfTE9P
S1VQUEssIGZhbHNlLCBmYWxzZSk7CisJfQorfQogCi0JZmtfc2xvdCA9IE1ha2VTaW5nbGVUdXBs
ZVRhYmxlU2xvdChSZWxhdGlvbkdldERlc2NyKGZrX3JlbCksCi0JCQkJCQkJCQkgICAmVFRTT3Bz
SGVhcFR1cGxlKTsKKy8qCisgKiByaV9GYXN0UGF0aEZsdXNoQXJyYXkKKyAqCQlTaW5nbGUtY29s
dW1uIGZhc3QgcGF0aCB1c2luZyBTS19TRUFSQ0hBUlJBWS4KKyAqCisgKiBCdWlsZHMgYW4gYXJy
YXkgb2YgRksgdmFsdWVzIGFuZCBkb2VzIG9uZSBpbmRleCBzY2FuIHdpdGgKKyAqIFNLX1NFQVJD
SEFSUkFZLiAgVGhlIGluZGV4IEFNIHNvcnRzIGFuZCBkZWR1cGxpY2F0ZXMgdGhlIGFycmF5Cisg
KiBpbnRlcm5hbGx5LCB0aGVuIHdhbGtzIG1hdGNoaW5nIGxlYWYgcGFnZXMgaW4gb3JkZXIuICBF
YWNoCisgKiBtYXRjaGVkIFBLIHR1cGxlIGlzIGxvY2tlZCBhbmQgcmVjaGVja2VkIGFzIGJlZm9y
ZTsgYSBtYXRjaGVkW10KKyAqIGJpdG1hcCB0cmFja3Mgd2hpY2ggYmF0Y2ggaXRlbXMgd2VyZSBz
YXRpc2ZpZWQuCisgKi8KK3N0YXRpYyB2b2lkCityaV9GYXN0UGF0aEZsdXNoQXJyYXkoUklfRmFz
dFBhdGhFbnRyeSAqZnBlbnRyeSwgVHVwbGVUYWJsZVNsb3QgKmZrX3Nsb3QsCisJCQkJCSAgY29u
c3QgUklfQ29uc3RyYWludEluZm8gKnJpaW5mbywgUmVsYXRpb24gZmtfcmVsKQoreworCUZhc3RQ
YXRoTWV0YSAqZnBtZXRhID0gcmlpbmZvLT5mcG1ldGE7CisJUmVsYXRpb24JcGtfcmVsID0gZnBl
bnRyeS0+cGtfcmVsOworCVJlbGF0aW9uCWlkeF9yZWwgPSBmcGVudHJ5LT5pZHhfcmVsOworCUlu
ZGV4U2NhbkRlc2Mgc2NhbmRlc2MgPSBmcGVudHJ5LT5zY2FuZGVzYzsKKwlUdXBsZVRhYmxlU2xv
dCAqc2xvdCA9IGZwZW50cnktPnNsb3Q7CisJU25hcHNob3QJc25hcHNob3QgPSBmcGVudHJ5LT5z
bmFwc2hvdDsKKwlEYXR1bQkgICAqc2VhcmNoX3ZhbHMgPSBmcGVudHJ5LT5zZWFyY2hfdmFsczsK
Kwlib29sCSAgICptYXRjaGVkID0gZnBlbnRyeS0+bWF0Y2hlZDsKKwlpbnQJCQludmFscyA9IGZw
ZW50cnktPmJhdGNoX2NvdW50OworCURhdHVtCQlwa192YWxzW0lOREVYX01BWF9LRVlTXTsKKwlj
aGFyCQlwa19udWxsc1tJTkRFWF9NQVhfS0VZU107CisJU2NhbktleURhdGEgc2tleVsxXTsKKwlS
SV9Db21wYXJlSGFzaEVudHJ5ICplbnRyeTsKKwlPaWQJCQllbGVtX3R5cGU7CisJaW50MTYJCWVs
ZW1fbGVuOworCWJvb2wJCWVsZW1fYnl2YWw7CisJY2hhcgkJZWxlbV9hbGlnbjsKKwlBcnJheVR5
cGUgICphcnI7CisJTWVtb3J5Q29udGV4dCBvbGRjeHQ7CiAKLQlvbGRjeHQgPSBNZW1vcnlDb250
ZXh0U3dpdGNoVG8oVG9wVHJhbnNhY3Rpb25Db250ZXh0KTsKLQlmb3IgKGludCBpID0gMDsgaSA8
IGZwZW50cnktPmJhdGNoX2NvdW50OyBpKyspCi0JewotCQlIZWFwVHVwbGUgZmt0dXBsZSA9IGZw
ZW50cnktPmJhdGNoW2ldOwotCQlib29sCWZvdW5kID0gZmFsc2U7CisJQXNzZXJ0KGZwbWV0YSk7
CiAKLQkJRXhlY1N0b3JlSGVhcFR1cGxlKGZrdHVwbGUsIGZrX3Nsb3QsIGZhbHNlKTsKKwltZW1z
ZXQobWF0Y2hlZCwgMCwgbnZhbHMgKiBzaXplb2YoYm9vbCkpOwogCisJLyoKKwkgKiBFeHRyYWN0
IGFuZCBjYXN0IEZLIHZhbHVlcy4gIFdlIG5lZWQgdGhlIFBLLXNpZGUgdHlwZSBmb3IKKwkgKiB0
aGUgYXJyYXkgZWxlbWVudCB0eXBlIHNpbmNlIHRoZSBzY2FuIGtleSBjb21wYXJlcyBhZ2FpbnN0
CisJICogdGhlIGluZGV4IHdoaWNoIHN0b3JlcyBQSy10eXBlZCB2YWx1ZXMuCisJICovCisJZW50
cnkgPSBmcG1ldGEtPmNvbXBhcmVfZW50cmllc1swXTsKKwlmb3IgKGludCBpID0gMDsgaSA8IG52
YWxzOyBpKyspCisJeworCQlFeGVjU3RvcmVIZWFwVHVwbGUoZnBlbnRyeS0+YmF0Y2hbaV0sIGZr
X3Nsb3QsIGZhbHNlKTsKIAkJcmlfRXh0cmFjdFZhbHVlcyhma19yZWwsIGZrX3Nsb3QsIHJpaW5m
bywgZmFsc2UsIHBrX3ZhbHMsIHBrX251bGxzKTsKLQkJYnVpbGRfaW5kZXhfc2NhbmtleXMocmlp
bmZvLCBpZHhfcmVsLCBwa192YWxzLCBwa19udWxscywgc2tleSk7CiAKLQkJaW5kZXhfcmVzY2Fu
KHNjYW5kZXNjLCBza2V5LCByaWluZm8tPm5rZXlzLCBOVUxMLCAwKTsKKwkJLyogQ2FzdCBpZiBu
ZWVkZWQgKGUuZy4gaW50OCBGSyAtPiBudW1lcmljIFBLKSAqLworCQlpZiAoT2lkSXNWYWxpZChl
bnRyeS0+Y2FzdF9mdW5jX2ZpbmZvLmZuX29pZCkpCisJCQlzZWFyY2hfdmFsc1tpXSA9IEZ1bmN0
aW9uQ2FsbDMoJmVudHJ5LT5jYXN0X2Z1bmNfZmluZm8sCisJCQkJCQkJCQkJICAgcGtfdmFsc1sw
XSwKKwkJCQkJCQkJCQkgICBJbnQzMkdldERhdHVtKC0xKSwKKwkJCQkJCQkJCQkgICBCb29sR2V0
RGF0dW0oZmFsc2UpKTsKKwkJZWxzZQorCQkJc2VhcmNoX3ZhbHNbaV0gPSBwa192YWxzWzBdOwor
CX0KIAotCQlpZiAoaW5kZXhfZ2V0bmV4dF9zbG90KHNjYW5kZXNjLCBGb3J3YXJkU2NhbkRpcmVj
dGlvbiwgc2xvdCkpCi0JCXsKLQkJCWJvb2wJY29uY3VycmVudGx5X3VwZGF0ZWQ7CisJLyoKKwkg
KiBBcnJheSBlbGVtZW50IHR5cGUgbXVzdCBtYXRjaCB0aGUgb3BlcmF0b3IncyByaWdodC1oYW5k
IGlucHV0CisJICogdHlwZSwgd2hpY2ggaXMgd2hhdCB0aGUgaW5kZXggY29tcGFyaXNvbiBleHBl
Y3RzIG9uIHRoZSBzZWFyY2gKKwkgKiBzaWRlLiAgcmlfcG9wdWxhdGVfZmFzdHBhdGhfbWV0YWRh
dGEoKSBzdG9yZXMgZXhhY3RseSB0aGlzIHZpYQorCSAqIGdldF9vcF9vcGZhbWlseV9wcm9wZXJ0
aWVzKCksIHdoaWNoIHJldHVybnMgdGhlIG9wZXJhdG9yJ3MKKwkgKiByaWdodC1oYW5kIHR5cGUg
YXMgdGhlIHN1YnR5cGUgZm9yIGNyb3NzLXR5cGUgb3BlcmF0b3JzIChlLmcuCisJICogaW50OCBm
b3IgaW50NDhlcSkgYW5kIHRoZSBjb21tb24gdHlwZSBmb3Igc2FtZS10eXBlIG9wZXJhdG9ycy4K
KwkgKi8KKwllbGVtX3R5cGUgPSBmcG1ldGEtPnN1YnR5cGVzWzBdOworCUFzc2VydChPaWRJc1Zh
bGlkKGVsZW1fdHlwZSkpOworCWdldF90eXBsZW5ieXZhbGFsaWduKGVsZW1fdHlwZSwgJmVsZW1f
bGVuLCAmZWxlbV9ieXZhbCwgJmVsZW1fYWxpZ24pOwogCi0JCQlpZiAocmlfTG9ja1BLVHVwbGUo
cGtfcmVsLCBzbG90LCBzbmFwc2hvdCwKLQkJCQkJCQkgICAmY29uY3VycmVudGx5X3VwZGF0ZWQp
KQotCQkJewotCQkJCWlmIChjb25jdXJyZW50bHlfdXBkYXRlZCkKLQkJCQkJZm91bmQgPSByZWNo
ZWNrX21hdGNoZWRfcGtfdHVwbGUoaWR4X3JlbCwgc2tleSwgc2xvdCk7Ci0JCQkJZWxzZQotCQkJ
CQlmb3VuZCA9IHRydWU7Ci0JCQl9Ci0JCX0KKwlhcnIgPSBjb25zdHJ1Y3RfYXJyYXkoc2VhcmNo
X3ZhbHMsIG52YWxzLAorCQkJCQkJICBlbGVtX3R5cGUsIGVsZW1fbGVuLCBlbGVtX2J5dmFsLCBl
bGVtX2FsaWduKTsKIAotCQlpZiAoZm91bmQgJiYgSXNvbGF0aW9uVXNlc1hhY3RTbmFwc2hvdCgp
KQotCQl7Ci0JCQlJbmRleFNjYW5EZXNjIHhhY3Rfc2NhbjsKLQkJCVR1cGxlVGFibGVTbG90ICp4
YWN0X3Nsb3Q7Ci0JCQlTbmFwc2hvdAl4YWN0X3NuYXAgPSBHZXRUcmFuc2FjdGlvblNuYXBzaG90
KCk7CisJLyoKKwkgKiBCdWlsZCBzY2FuIGtleSB3aXRoIFNLX1NFQVJDSEFSUkFZLiAgVGhlIGJ0
cmVlIGNvZGUgd2lsbAorCSAqIGludGVybmFsbHkgc29ydCBhbmQgZGVkdXBsaWNhdGUsIHRoZW4g
d2FsayBsZWFmIHBhZ2VzIGluIG9yZGVyLgorCSAqLworCVNjYW5LZXlFbnRyeUluaXRpYWxpemUo
JnNrZXlbMF0sCisJCQkJCQkgICBTS19TRUFSQ0hBUlJBWSwKKwkJCQkJCSAgIDEsCQkJCS8qIGF0
dG5vICovCisJCQkJCQkgICBmcG1ldGEtPnN0cmF0c1swXSwKKwkJCQkJCSAgIGZwbWV0YS0+c3Vi
dHlwZXNbMF0sCisJCQkJCQkgICBpZHhfcmVsLT5yZF9pbmRjb2xsYXRpb25bMF0sCisJCQkJCQkg
ICBmcG1ldGEtPnJlZ29wc1swXSwKKwkJCQkJCSAgIFBvaW50ZXJHZXREYXR1bShhcnIpKTsKIAot
CQkJeGFjdF9zbG90ID0gdGFibGVfc2xvdF9jcmVhdGUocGtfcmVsLCBOVUxMKTsKLQkJCXhhY3Rf
c2NhbiA9IGluZGV4X2JlZ2luc2Nhbihwa19yZWwsIGlkeF9yZWwsCi0JCQkJCQkJCQkJeGFjdF9z
bmFwLCBOVUxMLAotCQkJCQkJCQkJCXJpaW5mby0+bmtleXMsIDApOwotCQkJaW5kZXhfcmVzY2Fu
KHhhY3Rfc2Nhbiwgc2tleSwgcmlpbmZvLT5ua2V5cywgTlVMTCwgMCk7CisJb2xkY3h0ID0gTWVt
b3J5Q29udGV4dFN3aXRjaFRvKFRvcFRyYW5zYWN0aW9uQ29udGV4dCk7CiAKLQkJCWlmICghaW5k
ZXhfZ2V0bmV4dF9zbG90KHhhY3Rfc2NhbiwgRm9yd2FyZFNjYW5EaXJlY3Rpb24sCi0JCQkJCQkJ
CQl4YWN0X3Nsb3QpKQotCQkJCWZvdW5kID0gZmFsc2U7CisJaW5kZXhfcmVzY2FuKHNjYW5kZXNj
LCBza2V5LCAxLCBOVUxMLCAwKTsKIAotCQkJaW5kZXhfZW5kc2Nhbih4YWN0X3NjYW4pOwotCQkJ
RXhlY0Ryb3BTaW5nbGVUdXBsZVRhYmxlU2xvdCh4YWN0X3Nsb3QpOworCS8qCisJICogV2FsayBh
bGwgbWF0Y2hlcy4gIFRoZSBidHJlZSByZXR1cm5zIHRoZW0gaW4gaW5kZXggb3JkZXIuCisJICog
Rm9yIGVhY2ggbWF0Y2gsIGZpbmQgd2hpY2ggYmF0Y2ggaXRlbShzKSBpdCBzYXRpc2ZpZXMuCisJ
ICovCisJd2hpbGUgKGluZGV4X2dldG5leHRfc2xvdChzY2FuZGVzYywgRm9yd2FyZFNjYW5EaXJl
Y3Rpb24sIHNsb3QpKQorCXsKKwkJRGF0dW0JCWZvdW5kX3ZhbDsKKwkJYm9vbAkJZm91bmRfbnVs
bDsKKwkJYm9vbAkJY29uY3VycmVudGx5X3VwZGF0ZWQ7CisJCVNjYW5LZXlEYXRhIHJlY2hlY2tf
c2tleVsxXTsKKwkJYm9vbAkJcmVjaGVja19za2V5X3ZhbGlkID0gZmFsc2U7CisKKwkJaWYgKCFy
aV9Mb2NrUEtUdXBsZShwa19yZWwsIHNsb3QsIHNuYXBzaG90LCAmY29uY3VycmVudGx5X3VwZGF0
ZWQpKQorCQkJY29udGludWU7CisKKwkJLyogRXh0cmFjdCB0aGUgUEsgdmFsdWUgZnJvbSB0aGUg
bWF0Y2hlZCBhbmQgbG9ja2VkIHR1cGxlICovCisJCWZvdW5kX3ZhbCA9IHNsb3RfZ2V0YXR0cihz
bG90LCByaWluZm8tPnBrX2F0dG51bXNbMF0sICZmb3VuZF9udWxsKTsKKwkJQXNzZXJ0KCFmb3Vu
ZF9udWxsKTsKKworCQlpZiAoY29uY3VycmVudGx5X3VwZGF0ZWQpCisJCXsKKwkJCS8qCisJCQkg
KiBCdWlsZCBhIHNpbmdsZS1rZXkgc2NhbmtleSBmb3IgcmVjaGVjay4gIFdlIG5lZWQgdGhlCisJ
CQkgKiBhY3R1YWwgUEsgdmFsdWUgdGhhdCB3YXMgZm91bmQsIG5vdCB0aGUgRksgc2VhcmNoIHZh
bHVlLgorCQkJICovCisJCQlTY2FuS2V5RW50cnlJbml0aWFsaXplKCZyZWNoZWNrX3NrZXlbMF0s
IDAsIDEsCisJCQkJCQkJCSAgIGZwbWV0YS0+c3RyYXRzWzBdLAorCQkJCQkJCQkgICBmcG1ldGEt
PnN1YnR5cGVzWzBdLAorCQkJCQkJCQkgICBpZHhfcmVsLT5yZF9pbmRjb2xsYXRpb25bMF0sCisJ
CQkJCQkJCSAgIGZwbWV0YS0+cmVnb3BzWzBdLAorCQkJCQkJCQkgICBmb3VuZF92YWwpOworCQkJ
cmVjaGVja19za2V5X3ZhbGlkID0gdHJ1ZTsKKwkJCWlmICghcmVjaGVja19tYXRjaGVkX3BrX3R1
cGxlKGlkeF9yZWwsIHJlY2hlY2tfc2tleSwgc2xvdCkpCisJCQkJY29udGludWU7CisJCX0KKwor
CQkvKiBSUi9TRVJJQUxJWkFCTEUgY3Jvc3NjaGVjayAqLworCQlpZiAoSXNvbGF0aW9uVXNlc1hh
Y3RTbmFwc2hvdCgpKQorCQl7CisJCQlJbmRleFNjYW5EZXNjIHhhY3Rfc2NhbiA9IGZwZW50cnkt
PnhhY3Rfc2NhbjsKKworCQkJaWYgKCFyZWNoZWNrX3NrZXlfdmFsaWQpCisJCQkJU2NhbktleUVu
dHJ5SW5pdGlhbGl6ZSgmcmVjaGVja19za2V5WzBdLCAwLCAxLAorCQkJCQkJCQkJICAgZnBtZXRh
LT5zdHJhdHNbMF0sCisJCQkJCQkJCQkgICBmcG1ldGEtPnN1YnR5cGVzWzBdLAorCQkJCQkJCQkJ
ICAgaWR4X3JlbC0+cmRfaW5kY29sbGF0aW9uWzBdLAorCQkJCQkJCQkJICAgZnBtZXRhLT5yZWdv
cHNbMF0sCisJCQkJCQkJCQkgICBmb3VuZF92YWwpOworCisJCQlpbmRleF9yZXNjYW4oeGFjdF9z
Y2FuLCByZWNoZWNrX3NrZXksIDEsIE5VTEwsIDApOworCQkJaWYgKCFpbmRleF9nZXRuZXh0X3Ns
b3QoeGFjdF9zY2FuLCBGb3J3YXJkU2NhbkRpcmVjdGlvbiwgc2xvdCkpCisJCQkJY29udGludWU7
CiAJCX0KIAogCQkvKgotCQkgKiBSZXBvcnQgaW1tZWRpYXRlbHkuICByaV9SZXBvcnRWaW9sYXRp
b24gY2FsbHMgZXJlcG9ydChFUlJPUikKLQkJICogd2hpY2ggZG9lc24ndCByZXR1cm4sIHNvIHJl
bWFpbmluZyBiYXRjaCBpdGVtcyBhbmQgY2xlYW51cAotCQkgKiBhcmUgaGFuZGxlZCBieSB0aGUg
ZXJyb3IgcGF0aCAoUmVzb3VyY2VPd25lciArIFhhY3RDYWxsYmFjaykuCisJCSAqIExpbmVhciBz
Y2FuIHRvIG1hcmsgYWxsIGJhdGNoIGl0ZW1zIG1hdGNoaW5nIHRoaXMgUEsgdmFsdWUuCisJCSAq
IE8oYmF0Y2hfc2l6ZSkgcGVyIG1hdGNoLCBPKGJhdGNoX3NpemVeMikgd29yc3QgY2FzZSAtLSBm
aW5lCisJCSAqIGZvciB0aGUgY3VycmVudCBiYXRjaCBzaXplIG9mIDY0LgogCQkgKi8KLQkJaWYg
KCFmb3VuZCkKKwkJZm9yIChpbnQgaSA9IDA7IGkgPCBudmFsczsgaSsrKQorCQl7CisJCQlpZiAo
IW1hdGNoZWRbaV0gJiYKKwkJCQlEYXR1bUdldEJvb2woRnVuY3Rpb25DYWxsMkNvbGwoJmVudHJ5
LT5lcV9vcHJfZmluZm8sCisJCQkJCQkJCQkJCSAgIGlkeF9yZWwtPnJkX2luZGNvbGxhdGlvblsw
XSwKKwkJCQkJCQkJCQkJICAgZm91bmRfdmFsLAorCQkJCQkJCQkJCQkgICBzZWFyY2hfdmFsc1tp
XSkpKQorCQkJCW1hdGNoZWRbaV0gPSB0cnVlOworCQl9CisJfQorCisJLyogUmVwb3J0IGZpcnN0
IHVubWF0Y2hlZCByb3cgKi8KKwlmb3IgKGludCBpID0gMDsgaSA8IG52YWxzOyBpKyspCisJewor
CQlpZiAoIW1hdGNoZWRbaV0pCisJCXsKKwkJCUV4ZWNTdG9yZUhlYXBUdXBsZShmcGVudHJ5LT5i
YXRjaFtpXSwgZmtfc2xvdCwgZmFsc2UpOwogCQkJcmlfUmVwb3J0VmlvbGF0aW9uKHJpaW5mbywg
cGtfcmVsLCBma19yZWwsCiAJCQkJCQkJICAgZmtfc2xvdCwgTlVMTCwKIAkJCQkJCQkgICBSSV9Q
TEFOX0NIRUNLX0xPT0tVUFBLLCBmYWxzZSwgZmFsc2UpOworCQl9CiAJfQogCiAJTWVtb3J5Q29u
dGV4dFN3aXRjaFRvKG9sZGN4dCk7CisKKwlwZnJlZShhcnIpOworfQorCisKK3N0YXRpYyB2b2lk
CityaV9GYXN0UGF0aEJhdGNoRmx1c2goUklfRmFzdFBhdGhFbnRyeSAqZnBlbnRyeSwgUmVsYXRp
b24gZmtfcmVsKQoreworCWNvbnN0IFJJX0NvbnN0cmFpbnRJbmZvICpyaWluZm8gPSBmcGVudHJ5
LT5yaWluZm87CisJUmVsYXRpb24JcGtfcmVsID0gZnBlbnRyeS0+cGtfcmVsOworCVJlbGF0aW9u
CWlkeF9yZWwgPSBmcGVudHJ5LT5pZHhfcmVsOworCVNuYXBzaG90CXNuYXBzaG90ID0gZnBlbnRy
eS0+c25hcHNob3Q7CisJVHVwbGVUYWJsZVNsb3QgKmZrX3Nsb3Q7CisJT2lkCQkJc2F2ZWRfdXNl
cmlkOworCWludAkJCXNhdmVkX3NlY19jb250ZXh0OworCisJaWYgKGZwZW50cnktPmJhdGNoX2Nv
dW50ID09IDApCisJCXJldHVybjsKKworCWlmIChyaWluZm8tPmZwbWV0YSA9PSBOVUxMKQorCQly
aV9wb3B1bGF0ZV9mYXN0cGF0aF9tZXRhZGF0YSgoUklfQ29uc3RyYWludEluZm8gKikgcmlpbmZv
LAorCQkJCQkJCQkJICBma19yZWwsIGlkeF9yZWwpOworCUFzc2VydChyaWluZm8tPmZwbWV0YSk7
CisKKwlDb21tYW5kQ291bnRlckluY3JlbWVudCgpOworCXNuYXBzaG90LT5jdXJjaWQgPSBHZXRD
dXJyZW50Q29tbWFuZElkKGZhbHNlKTsKKworCUdldFVzZXJJZEFuZFNlY0NvbnRleHQoJnNhdmVk
X3VzZXJpZCwgJnNhdmVkX3NlY19jb250ZXh0KTsKKwlTZXRVc2VySWRBbmRTZWNDb250ZXh0KFJl
bGF0aW9uR2V0Rm9ybShwa19yZWwpLT5yZWxvd25lciwKKwkJCQkJCSAgIHNhdmVkX3NlY19jb250
ZXh0IHwKKwkJCQkJCSAgIFNFQ1VSSVRZX0xPQ0FMX1VTRVJJRF9DSEFOR0UgfAorCQkJCQkJICAg
U0VDVVJJVFlfTk9GT1JDRV9STFMpOworCisJZmtfc2xvdCA9IE1ha2VTaW5nbGVUdXBsZVRhYmxl
U2xvdChSZWxhdGlvbkdldERlc2NyKGZrX3JlbCksCisJCQkJCQkJCQkgICAmVFRTT3BzSGVhcFR1
cGxlKTsKKworCWlmIChyaWluZm8tPm5rZXlzID09IDEpCisJCXJpX0Zhc3RQYXRoRmx1c2hBcnJh
eShmcGVudHJ5LCBma19zbG90LCByaWluZm8sIGZrX3JlbCk7CisJZWxzZQorCQlyaV9GYXN0UGF0
aEZsdXNoTG9vcChmcGVudHJ5LCBma19zbG90LCByaWluZm8sIGZrX3JlbCk7CisKIAlTZXRVc2Vy
SWRBbmRTZWNDb250ZXh0KHNhdmVkX3VzZXJpZCwgc2F2ZWRfc2VjX2NvbnRleHQpOwogCiAJLyog
RnJlZSBtYXRlcmlhbGl6ZWQgdHVwbGVzIGFuZCByZXNldCAqLwpkaWZmIC0tZ2l0IGEvc3JjL3Rl
c3QvcmVncmVzcy9leHBlY3RlZC9mb3JlaWduX2tleS5vdXQgYi9zcmMvdGVzdC9yZWdyZXNzL2V4
cGVjdGVkL2ZvcmVpZ25fa2V5Lm91dAppbmRleCAxNmJiNjM3MGE5Ny4uMGEyNGFjZGIxMzggMTAw
NjQ0Ci0tLSBhL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvZm9yZWlnbl9rZXkub3V0CisrKyBi
L3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvZm9yZWlnbl9rZXkub3V0CkBAIC0zNTkzLDMgKzM1
OTMsMjAgQEAgQ09NTUlUOwogRVJST1I6ICBpbnNlcnQgb3IgdXBkYXRlIG9uIHRhYmxlICJmcF9m
a19jb21taXQiIHZpb2xhdGVzIGZvcmVpZ24ga2V5IGNvbnN0cmFpbnQgImZwX2ZrX2NvbW1pdF9h
X2ZrZXkiCiBERVRBSUw6ICBLZXkgKGEpPSg5OTkpIGlzIG5vdCBwcmVzZW50IGluIHRhYmxlICJm
cF9wa19jb21taXQiLgogRFJPUCBUQUJMRSBmcF9ma19jb21taXQsIGZwX3BrX2NvbW1pdDsKKy0t
IENyb3NzLXR5cGUgRksgd2l0aCBidWxrIGluc2VydDogaW50OCBGSyByZWZlcmVuY2luZyBpbnQ0
IFBLLAorLS0gdmFsdWVzIGNhc3QgZHVyaW5nIGFycmF5IGNvbnN0cnVjdGlvbgorQ1JFQVRFIFRB
QkxFIGZwX3BrX2Nyb3NzIChhIGludDQgUFJJTUFSWSBLRVkpOworSU5TRVJUIElOVE8gZnBfcGtf
Y3Jvc3MgU0VMRUNUIGdlbmVyYXRlX3NlcmllcygxLCAyMDApOworQ1JFQVRFIFRBQkxFIGZwX2Zr
X2Nyb3NzIChhIGludDggUkVGRVJFTkNFUyBmcF9wa19jcm9zcyk7CitJTlNFUlQgSU5UTyBmcF9m
a19jcm9zcyBTRUxFQ1QgZ2VuZXJhdGVfc2VyaWVzKDEsIDIwMCk7CitJTlNFUlQgSU5UTyBmcF9m
a19jcm9zcyBWQUxVRVMgKDk5OSk7CitFUlJPUjogIGluc2VydCBvciB1cGRhdGUgb24gdGFibGUg
ImZwX2ZrX2Nyb3NzIiB2aW9sYXRlcyBmb3JlaWduIGtleSBjb25zdHJhaW50ICJmcF9ma19jcm9z
c19hX2ZrZXkiCitERVRBSUw6ICBLZXkgKGEpPSg5OTkpIGlzIG5vdCBwcmVzZW50IGluIHRhYmxl
ICJmcF9wa19jcm9zcyIuCitEUk9QIFRBQkxFIGZwX2ZrX2Nyb3NzLCBmcF9wa19jcm9zczsKKy0t
IER1cGxpY2F0ZSBGSyB2YWx1ZXM6IHdoZW4gdXNpbmcgdGhlIGJhdGNoZWQgU0FPUCBwYXRoLCBl
dmVyeQorLS0gcm93IG11c3QgYmUgcmVjb2duaXplZCBhcyBzYXRpc2ZpZWQsIG5vdCBqdXN0IHRo
ZSBmaXJzdCBtYXRjaAorQ1JFQVRFIFRBQkxFIGZwX3BrX2R1cCAoYSBpbnQgUFJJTUFSWSBLRVkp
OworSU5TRVJUIElOVE8gZnBfcGtfZHVwIFZBTFVFUyAoMSk7CitDUkVBVEUgVEFCTEUgZnBfZmtf
ZHVwIChhIGludCBSRUZFUkVOQ0VTIGZwX3BrX2R1cCk7CitJTlNFUlQgSU5UTyBmcF9ma19kdXAg
U0VMRUNUIDEgRlJPTSBnZW5lcmF0ZV9zZXJpZXMoMSwgMTAwKTsKK0RST1AgVEFCTEUgZnBfZmtf
ZHVwLCBmcF9wa19kdXA7CmRpZmYgLS1naXQgYS9zcmMvdGVzdC9yZWdyZXNzL3NxbC9mb3JlaWdu
X2tleS5zcWwgYi9zcmMvdGVzdC9yZWdyZXNzL3NxbC9mb3JlaWduX2tleS5zcWwKaW5kZXggYmMy
NDI3MmRmMjAuLmNlODVhMjFmYzc5IDEwMDY0NAotLS0gYS9zcmMvdGVzdC9yZWdyZXNzL3NxbC9m
b3JlaWduX2tleS5zcWwKKysrIGIvc3JjL3Rlc3QvcmVncmVzcy9zcWwvZm9yZWlnbl9rZXkuc3Fs
CkBAIC0yNTc3LDMgKzI1NzcsMjAgQEAgSU5TRVJUIElOVE8gZnBfZmtfY29tbWl0IFZBTFVFUyAo
MSk7CiBJTlNFUlQgSU5UTyBmcF9ma19jb21taXQgVkFMVUVTICg5OTkpOwogQ09NTUlUOwogRFJP
UCBUQUJMRSBmcF9ma19jb21taXQsIGZwX3BrX2NvbW1pdDsKKworLS0gQ3Jvc3MtdHlwZSBGSyB3
aXRoIGJ1bGsgaW5zZXJ0OiBpbnQ4IEZLIHJlZmVyZW5jaW5nIGludDQgUEssCistLSB2YWx1ZXMg
Y2FzdCBkdXJpbmcgYXJyYXkgY29uc3RydWN0aW9uCitDUkVBVEUgVEFCTEUgZnBfcGtfY3Jvc3Mg
KGEgaW50NCBQUklNQVJZIEtFWSk7CitJTlNFUlQgSU5UTyBmcF9wa19jcm9zcyBTRUxFQ1QgZ2Vu
ZXJhdGVfc2VyaWVzKDEsIDIwMCk7CitDUkVBVEUgVEFCTEUgZnBfZmtfY3Jvc3MgKGEgaW50OCBS
RUZFUkVOQ0VTIGZwX3BrX2Nyb3NzKTsKK0lOU0VSVCBJTlRPIGZwX2ZrX2Nyb3NzIFNFTEVDVCBn
ZW5lcmF0ZV9zZXJpZXMoMSwgMjAwKTsKK0lOU0VSVCBJTlRPIGZwX2ZrX2Nyb3NzIFZBTFVFUyAo
OTk5KTsKK0RST1AgVEFCTEUgZnBfZmtfY3Jvc3MsIGZwX3BrX2Nyb3NzOworCistLSBEdXBsaWNh
dGUgRksgdmFsdWVzOiB3aGVuIHVzaW5nIHRoZSBiYXRjaGVkIFNBT1AgcGF0aCwgZXZlcnkKKy0t
IHJvdyBtdXN0IGJlIHJlY29nbml6ZWQgYXMgc2F0aXNmaWVkLCBub3QganVzdCB0aGUgZmlyc3Qg
bWF0Y2gKK0NSRUFURSBUQUJMRSBmcF9wa19kdXAgKGEgaW50IFBSSU1BUlkgS0VZKTsKK0lOU0VS
VCBJTlRPIGZwX3BrX2R1cCBWQUxVRVMgKDEpOworQ1JFQVRFIFRBQkxFIGZwX2ZrX2R1cCAoYSBp
bnQgUkVGRVJFTkNFUyBmcF9wa19kdXApOworSU5TRVJUIElOVE8gZnBfZmtfZHVwIFNFTEVDVCAx
IEZST00gZ2VuZXJhdGVfc2VyaWVzKDEsIDEwMCk7CitEUk9QIFRBQkxFIGZwX2ZrX2R1cCwgZnBf
cGtfZHVwOwotLSAKMi40MS4wCgo=
--0000000000000d9ac2064caaaa1f
Content-Type: application/octet-stream;
	name="v5-0006-Reuse-FK-tuple-slot-across-fast-path-batches.patch"
Content-Disposition: attachment;
	filename="v5-0006-Reuse-FK-tuple-slot-across-fast-path-batches.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmkjv78r0>
X-Attachment-Id: f_mmkjv78r0

RnJvbSA3NjE5MzU3YWRmNzQ4ZTQzOTZmNDE4NjUyYWRmNDBlOWQ3Nzk0MWZjIE1vbiBTZXAgMTcg
MDA6MDA6MDAgMjAwMQpGcm9tOiBKdW53YW5nIFpoYW8gPHpoandwa3VAZ21haWwuY29tPgpEYXRl
OiBUdWUsIDEwIE1hciAyMDI2IDE4OjA2OjIxICswODAwClN1YmplY3Q6IFtQQVRDSCB2NSA2LzZd
IFJldXNlIEZLIHR1cGxlIHNsb3QgYWNyb3NzIGZhc3QtcGF0aCBiYXRjaGVzCgotLS0KIHNyYy9i
YWNrZW5kL3V0aWxzL2FkdC9yaV90cmlnZ2Vycy5jIHwgMjEgKysrKysrKysrKy0tLS0tLS0tLS0t
CiAxIGZpbGUgY2hhbmdlZCwgMTAgaW5zZXJ0aW9ucygrKSwgMTEgZGVsZXRpb25zKC0pCgpkaWZm
IC0tZ2l0IGEvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L3JpX3RyaWdnZXJzLmMgYi9zcmMvYmFja2Vu
ZC91dGlscy9hZHQvcmlfdHJpZ2dlcnMuYwppbmRleCBlYjExMmFhYmM5OC4uYWUxNzY1YTM3ZjQg
MTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9yaV90cmlnZ2Vycy5jCisrKyBiL3Ny
Yy9iYWNrZW5kL3V0aWxzL2FkdC9yaV90cmlnZ2Vycy5jCkBAIC0yMTMsOCArMjEzLDkgQEAgdHlw
ZWRlZiBzdHJ1Y3QgUklfRmFzdFBhdGhFbnRyeQogCVJlbGF0aW9uCWlkeF9yZWw7CiAJSW5kZXhT
Y2FuRGVzYyBzY2FuZGVzYzsKIAlUdXBsZVRhYmxlU2xvdCAqc2xvdDsKKwlUdXBsZVRhYmxlU2xv
dCAqZmtfc2xvdDsKIAlTbmFwc2hvdAlzbmFwc2hvdDsJCS8qIHJlZ2lzdGVyZWQgc25hcHNob3Qg
Zm9yIHRoZSBzY2FuICovCi0gCisKIAkvKiBGb3Igd2hlbiBJc29sYXRpb25Vc2VzWGFjdFNuYXBz
aG90KCkgaXMgdHJ1ZSAqLwogCVNuYXBzaG90CXhhY3Rfc25hcDsKIAlJbmRleFNjYW5EZXNjIHhh
Y3Rfc2NhbjsKQEAgLTMxNCw3ICszMTUsNyBAQCBwZ19ub3JldHVybiBzdGF0aWMgdm9pZCByaV9S
ZXBvcnRWaW9sYXRpb24oY29uc3QgUklfQ29uc3RyYWludEluZm8gKnJpaW5mbywKIAkJCQkJCQkJ
CQkgICBSZWxhdGlvbiBwa19yZWwsIFJlbGF0aW9uIGZrX3JlbCwKIAkJCQkJCQkJCQkgICBUdXBs
ZVRhYmxlU2xvdCAqdmlvbGF0b3JzbG90LCBUdXBsZURlc2MgdHVwZGVzYywKIAkJCQkJCQkJCQkg
ICBpbnQgcXVlcnlubywgYm9vbCBpc19yZXN0cmljdCwgYm9vbCBwYXJ0Z29uZSk7Ci1zdGF0aWMg
UklfRmFzdFBhdGhFbnRyeSAqcmlfRmFzdFBhdGhHZXRFbnRyeShjb25zdCBSSV9Db25zdHJhaW50
SW5mbyAqcmlpbmZvKTsKK3N0YXRpYyBSSV9GYXN0UGF0aEVudHJ5ICpyaV9GYXN0UGF0aEdldEVu
dHJ5KGNvbnN0IFJJX0NvbnN0cmFpbnRJbmZvICpyaWluZm8sIFJlbGF0aW9uIGZrX3JlbCk7CiBz
dGF0aWMgdm9pZCByaV9GYXN0UGF0aEVuZEJhdGNoKHZvaWQgKmFyZyk7CiBzdGF0aWMgdm9pZCBy
aV9GYXN0UGF0aFRlYXJkb3duKHZvaWQpOwogc3RhdGljIHZvaWQgcmlfRmFzdFBhdGhCYXRjaEFk
ZChjb25zdCBSSV9Db25zdHJhaW50SW5mbyAqcmlpbmZvLApAQCAtMzg1MSw2ICszODUyLDggQEAg
cmlfRmFzdFBhdGhUZWFyZG93bih2b2lkKQogCQkJdGFibGVfY2xvc2UoZW50cnktPnBrX3JlbCwg
Tm9Mb2NrKTsKIAkJaWYgKGVudHJ5LT5zbG90KQogCQkJRXhlY0Ryb3BTaW5nbGVUdXBsZVRhYmxl
U2xvdChlbnRyeS0+c2xvdCk7CisJCWlmIChlbnRyeS0+Zmtfc2xvdCkKKwkJCUV4ZWNEcm9wU2lu
Z2xlVHVwbGVUYWJsZVNsb3QoZW50cnktPmZrX3Nsb3QpOwogCQlpZiAoZW50cnktPnNuYXBzaG90
KQogCQkJVW5yZWdpc3RlclNuYXBzaG90KGVudHJ5LT5zbmFwc2hvdCk7CiAJCWlmIChlbnRyeS0+
eGFjdF9zbmFwKQpAQCAtMzkwOSw3ICszOTEyLDcgQEAgcmlfRmFzdFBhdGhTdWJYYWN0Q2FsbGJh
Y2soU3ViWGFjdEV2ZW50IGV2ZW50LCBTdWJUcmFuc2FjdGlvbklkIG15U3ViaWQsCiAgKiBpbmRl
eF9yZXNjYW4oKSB3aXRoIG5ldyBrZXlzLgogICovCiBzdGF0aWMgUklfRmFzdFBhdGhFbnRyeSAq
Ci1yaV9GYXN0UGF0aEdldEVudHJ5KGNvbnN0IFJJX0NvbnN0cmFpbnRJbmZvICpyaWluZm8pCity
aV9GYXN0UGF0aEdldEVudHJ5KGNvbnN0IFJJX0NvbnN0cmFpbnRJbmZvICpyaWluZm8sIFJlbGF0
aW9uIGZrX3JlbCkKIHsKIAlSSV9GYXN0UGF0aEVudHJ5ICplbnRyeTsKIAlib29sCQlmb3VuZDsK
QEAgLTM5NzQsNiArMzk3Nyw4IEBAIHJpX0Zhc3RQYXRoR2V0RW50cnkoY29uc3QgUklfQ29uc3Ry
YWludEluZm8gKnJpaW5mbykKIAkJZW50cnktPnNuYXBzaG90ID0gUmVnaXN0ZXJTbmFwc2hvdChH
ZXRMYXRlc3RTbmFwc2hvdCgpKTsKIAogCQllbnRyeS0+c2xvdCA9IHRhYmxlX3Nsb3RfY3JlYXRl
KGVudHJ5LT5wa19yZWwsIE5VTEwpOworCQllbnRyeS0+Zmtfc2xvdCA9IE1ha2VTaW5nbGVUdXBs
ZVRhYmxlU2xvdChSZWxhdGlvbkdldERlc2NyKGZrX3JlbCksCisJCQkJCQkJCQkJCQkgICZUVFNP
cHNIZWFwVHVwbGUpOwogCiAJCWVudHJ5LT5zY2FuZGVzYyA9IGluZGV4X2JlZ2luc2NhbihlbnRy
eS0+cGtfcmVsLCBlbnRyeS0+aWR4X3JlbCwKIAkJCQkJCQkJCQkgIGVudHJ5LT5zbmFwc2hvdCwg
TlVMTCwKQEAgLTQyMzgsNyArNDI0Myw3IEBAIHJpX0Zhc3RQYXRoQmF0Y2hGbHVzaChSSV9GYXN0
UGF0aEVudHJ5ICpmcGVudHJ5LCBSZWxhdGlvbiBma19yZWwpCiAJUmVsYXRpb24JcGtfcmVsID0g
ZnBlbnRyeS0+cGtfcmVsOwogCVJlbGF0aW9uCWlkeF9yZWwgPSBmcGVudHJ5LT5pZHhfcmVsOwog
CVNuYXBzaG90CXNuYXBzaG90ID0gZnBlbnRyeS0+c25hcHNob3Q7Ci0JVHVwbGVUYWJsZVNsb3Qg
KmZrX3Nsb3Q7CisJVHVwbGVUYWJsZVNsb3QgKmZrX3Nsb3QgPSBmcGVudHJ5LT5ma19zbG90Owog
CU9pZAkJCXNhdmVkX3VzZXJpZDsKIAlpbnQJCQlzYXZlZF9zZWNfY29udGV4dDsKIApAQCAtNDI1
OSw5ICs0MjY0LDYgQEAgcmlfRmFzdFBhdGhCYXRjaEZsdXNoKFJJX0Zhc3RQYXRoRW50cnkgKmZw
ZW50cnksIFJlbGF0aW9uIGZrX3JlbCkKIAkJCQkJCSAgIFNFQ1VSSVRZX0xPQ0FMX1VTRVJJRF9D
SEFOR0UgfAogCQkJCQkJICAgU0VDVVJJVFlfTk9GT1JDRV9STFMpOwogCi0JZmtfc2xvdCA9IE1h
a2VTaW5nbGVUdXBsZVRhYmxlU2xvdChSZWxhdGlvbkdldERlc2NyKGZrX3JlbCksCi0JCQkJCQkJ
CQkgICAmVFRTT3BzSGVhcFR1cGxlKTsKLQogCWlmIChyaWluZm8tPm5rZXlzID09IDEpCiAJCXJp
X0Zhc3RQYXRoRmx1c2hBcnJheShmcGVudHJ5LCBma19zbG90LCByaWluZm8sIGZrX3JlbCk7CiAJ
ZWxzZQpAQCAtNDI3MiwxMCArNDI3NCw3IEBAIHJpX0Zhc3RQYXRoQmF0Y2hGbHVzaChSSV9GYXN0
UGF0aEVudHJ5ICpmcGVudHJ5LCBSZWxhdGlvbiBma19yZWwpCiAJLyogRnJlZSBtYXRlcmlhbGl6
ZWQgdHVwbGVzIGFuZCByZXNldCAqLwogCWZvciAoaW50IGkgPSAwOyBpIDwgZnBlbnRyeS0+YmF0
Y2hfY291bnQ7IGkrKykKIAkJaGVhcF9mcmVldHVwbGUoZnBlbnRyeS0+YmF0Y2hbaV0pOwotCiAJ
ZnBlbnRyeS0+YmF0Y2hfY291bnQgPSAwOwotCi0JRXhlY0Ryb3BTaW5nbGVUdXBsZVRhYmxlU2xv
dChma19zbG90KTsKIH0KIAogLyoKQEAgLTQyOTcsNyArNDI5Niw3IEBAIHJpX0Zhc3RQYXRoQmF0
Y2hBZGQoY29uc3QgUklfQ29uc3RyYWludEluZm8gKnJpaW5mbywKIAlSSV9GYXN0UGF0aEVudHJ5
ICpmcGVudHJ5OwogCU1lbW9yeUNvbnRleHQgb2xkY3h0OwogCi0JZnBlbnRyeSA9IHJpX0Zhc3RQ
YXRoR2V0RW50cnkocmlpbmZvKTsKKwlmcGVudHJ5ID0gcmlfRmFzdFBhdGhHZXRFbnRyeShyaWlu
Zm8sIGZrX3JlbCk7CiAKIAlvbGRjeHQgPSBNZW1vcnlDb250ZXh0U3dpdGNoVG8oVG9wVHJhbnNh
Y3Rpb25Db250ZXh0KTsKIAlmcGVudHJ5LT5iYXRjaFtmcGVudHJ5LT5iYXRjaF9jb3VudF0gPQot
LSAKMi40MS4wCgo=
--0000000000000d9ac2064caaaa1f
Content-Type: application/octet-stream;
	name="v5-0002-Cache-per-batch-resources-for-fast-path-foreign-k.patch"
Content-Disposition: attachment;
	filename="v5-0002-Cache-per-batch-resources-for-fast-path-foreign-k.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmkjv7dn4>
X-Attachment-Id: f_mmkjv7dn4
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--0000000000000d9ac2064caaaa1f
Content-Type: application/octet-stream;
	name="v5-0004-Refine-fast-path-FK-validation-path.patch"
Content-Disposition: attachment;
	filename="v5-0004-Refine-fast-path-FK-validation-path.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmkjv7bs2>
X-Attachment-Id: f_mmkjv7bs2
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==
--0000000000000d9ac2064caaaa1f
Content-Type: application/octet-stream;
	name="v5-0003-Buffer-FK-rows-for-batched-fast-path-probing.patch"
Content-Disposition: attachment;
	filename="v5-0003-Buffer-FK-rows-for-batched-fast-path-probing.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmkjv7cr3>
X-Attachment-Id: f_mmkjv7cr3
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=
--0000000000000d9ac2064caaaa1f
Content-Type: application/octet-stream;
	name="v5-0001-Add-fast-path-for-foreign-key-constraint-checks.patch"
Content-Disposition: attachment;
	filename="v5-0001-Add-fast-path-for-foreign-key-constraint-checks.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmkjv7ei5>
X-Attachment-Id: f_mmkjv7ei5
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--0000000000000d9ac2064caaaa1f--