MIME-Version: 1.0
References: <CABPTF7X1X810eT7hjRz9M69sjMv1Vui5gXQEGhqYXmkmywhHCQ@mail.gmail.com>
 <CAAKRu_ZcK+ez71W7j+QzMo0gSafTsbGA3TU-fVSptw7yh41BEQ@mail.gmail.com>
 <6BC5DBAB-6084-4BB8-8450-52E9648AB021@gmail.com> <CAAKRu_ZCjHoRPfQ8AbMrFY8TOMCPAvZ0_m9SX7yg0edfTk45-g@mail.gmail.com>
 <7F5BCD7A-764D-4D8D-8E27-6F2CAAEA1CEE@gmail.com> <CAAKRu_a04jbDACwzRYwzDND31aPyf7Yvz9TAZrTr=+F5bK1aVA@mail.gmail.com>
 <CALdSSPjcv25jmXm29X-MRWZBae6+HwcWfVH1PE8NfD=EMTnkAg@mail.gmail.com>
 <CAAKRu_bwtBEzDwemyim1r6yYonw7FTyFr1HXG8vywCe-MdbPBQ@mail.gmail.com>
 <4379FDA3-9446-4E2C-9C15-32EFE8D4F31B@yandex-team.ru> <CAAKRu_YQd=2KvomM+RHcpeDKj0bq+peJ=3W-fip+pkvzA-Jq9w@mail.gmail.com>
 <7ib3sa55sapwjlaz4sijbiq7iezna27kjvvvar4dpgkmadml6t@gfpkkwmdnepx>
In-Reply-To: <7ib3sa55sapwjlaz4sijbiq7iezna27kjvvvar4dpgkmadml6t@gfpkkwmdnepx>
From: Melanie Plageman <melanieplageman@gmail.com>
Date: Wed, 28 Jan 2026 18:16:10 -0500
Message-ID: <CAAKRu_bs+gZ83QDacmBxunPvCGnXJ05hxP2BDPJ3BGwdbGRXzg@mail.gmail.com>
Subject: Re: eliminate xl_heap_visible to reduce WAL (and eventually set VM on-access)
To: Andres Freund <andres@anarazel.de>
Cc: Andrey Borodin <x4mmm@yandex-team.ru>, Kirill Reshke <reshkekirill@gmail.com>, 
	Chao Li <li.evan.chao@gmail.com>, Xuneng Zhou <xunengzhou@gmail.com>, 
	Robert Haas <robertmhaas@gmail.com>, 
	PostgreSQL Hackers <pgsql-hackers@lists.postgresql.org>, Heikki Linnakangas <hlinnaka@iki.fi>
Content-Type: multipart/mixed; boundary="0000000000000dfe5806497aee85"
Archived-At: <https://www.postgresql.org/message-id/CAAKRu_bs%2BgZ83QDacmBxunPvCGnXJ05hxP2BDPJ3BGwdbGRXzg%40mail.gmail.com>
Precedence: bulk

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

Thanks for the review!
I pushed v33 0001-0003 after incorporating your feedback.

On Fri, Jan 23, 2026 at 7:28=E2=80=AFPM Andres Freund <andres@anarazel.de> =
wrote:
>
> On 2026-01-06 12:31:57 -0500, Melanie Plageman wrote:
>
> > +      */
> > +     if ((old_vmbits & VISIBILITYMAP_ALL_VISIBLE) =3D=3D 0)
> > +     {
> > +             vacrel->vm_new_visible_pages++;
> > +             if (presult.all_frozen)
> > +             {
> > +                     vacrel->vm_new_visible_frozen_pages++;
> > +                     *vm_page_frozen =3D true;
>
> Not this patches fault, but I find "vm_new_visible_pages" and
> "vm_new_visible_frozen_pages" pretty odd names. The concept is all-visibl=
e and
> frozen. The page itself isn't visible or invisible...

I thought having the extra word "all" in there made it too long. And
since "vm" is there, that isn't set unless the page is
_all_-visible/all-frozen. But if you think it gives people the wrong
idea, I am willing to change it. I can omit vm and make it:
new_all_visible_all_frozen_pages
new_all_visible_pages
new_all_frozen_pages

Is that clearer?

> > From 5c65e73246b4968ddfa9d3739f53d0d8734b8727 Mon Sep 17 00:00:00 2001
> > From: Melanie Plageman <melanieplageman@gmail.com>
> > Date: Tue, 2 Dec 2025 15:07:42 -0500
> > Subject: [PATCH v33 04/16] Set the VM in heap_page_prune_and_freeze()
> >
> > This has no independent benefit. It is meant for ease of review. As of
> > this commit, there is still a separate WAL record emitted for setting
> > the VM after pruning and freezing. But it is easier to review if moving
> > the logic into pruneheap.c is separate from setting the VM in the same
> > WAL record.
>
> It seems a bit noisy to refactor the related code in some of the precedin=
g
> commits and then refactor it into a slightly different shape as part of t=
his
> commit (c.f. heap_page_will_set_vm()).

I understand what you are saying. I don't see a good way to keep it
reviewable otherwise, though.

> It's also a bit odd that a function that sounds rather read-only does stu=
ff
> like clearing VM/all-visible.

I thought about this a lot. Ultimately, I ended up keeping it the way it is=
.
I think the other option is changing from this:

    do_set_vm =3D heap_page_will_set_vm(&prstate,
                                      params->relation,
                                      blockno, buffer, page,
                                      vmbuffer,
                                      params->reason,
                                      do_prune, do_freeze,
                                      prstate.lpdead_items,
                                      &old_vmbits, &new_vmbits);

to this:

    heap_page_prepare_vm_set(&prstate,
                                params->relation,
                                blockno, buffer, page,
                                vmbuffer,
                                params->reason,
                                do_prune, do_freeze,
                                prstate.lpdead_items,
                                &old_vmbits, &new_vmbits);

    do_set_vm =3D (new_vmbits & VISIBILITYMAP_VALID_BITS) !=3D 0;

or heap_page_plan_vm_set()

heap_page_will_set_vm() has symmetry with heap_page_will_freeze(), the
helper that decides whether or not we will freeze tuples. I like that
symmetry since heap_page_will_set_vm() decides whether or not to set
the VM.

Now, heap_page_plan/prepare_vm_set() does indirectly hint that
something like clearing VM/all-visible could happen -- if you
understand that preparing the VM to have bits set also includes
clearing any existing corruption. And "prepare" or "plan" has more
symmetry with prune_freeze_plan() -- though that function does not
make changes on the page.

Ultimately, clearing the VM/page of corruption is pretty anomalous
from the rest of the code in heap_page_prune_and_freeze(). All other
changes to the page are done in a single critical section at the
bottom of the function.

I could see an argument for moving identify_and_fix_vm_corruption()
out of the helper and into heap_page_prune_and_freeze() but then we'd
have to move visibilitymap_get_status() out too. And that takes away a
lot of the benefit of encapsulating all that logic.

Ultimately, I don't like any of those alternative structures. But if
you prefer the names and return value change I have above
(heap_page_prepare/plan_vm_set()), I'm fine with going with that.

> Why are we not doing fixing up of the page *before* we prune it?  It's a =
bit
> insane that we do the WAL logging for pruning, which in turn will often
> include an FPI, before we do the fixups. The fixes aren't WAL logged, so =
this
> actually leads to the standby getting further out of sync.
>
> I realize this isn't your mess, but brrr.

Well, after this patch set, clearing the VM does happen before we emit
WAL for pruning. It wouldn't be hard to move the corruption fixups to
the beginning of heap_page_prune_and_freeze() in the new code
structure. But it would split visibility map-related logic into two
parts of heap_page_prune_and_freeze(). Would it be worth it? What
benefit would we get? Do you just feel that it should logically come
first?

> Do we actually forsee a case where only one of HEAP_PAGE_PRUNE_FREEZE |
> HEAP_PAGE_PRUNE_UPDATE_VM would be set?

Yes, when setting the VM on-access, it is too expensive to call
heap_prepare_freeze_tuple() on each tuple. I could work on trying to
optimize it, but it isn't currently viable.

> > -     if ((old_vmbits & VISIBILITYMAP_ALL_VISIBLE) =3D=3D 0)
> > +     if ((presult.old_vmbits & VISIBILITYMAP_ALL_VISIBLE) =3D=3D 0 &&
> > +             (presult.new_vmbits & VISIBILITYMAP_ALL_VISIBLE) !=3D 0)
> >       {
> >               vacrel->vm_new_visible_pages++;
> > -             if (presult.all_frozen)
> > +             if ((presult.new_vmbits & VISIBILITYMAP_ALL_FROZEN) !=3D =
0)
> >               {
> >                       vacrel->vm_new_visible_frozen_pages++;
> >                       *vm_page_frozen =3D true;
> >               }
> >       }
> > -     else if ((old_vmbits & VISIBILITYMAP_ALL_FROZEN) =3D=3D 0 &&
> > -                      presult.all_frozen)
> > +     else if ((presult.old_vmbits & VISIBILITYMAP_ALL_FROZEN) =3D=3D 0=
 &&
> > +                      (presult.new_vmbits & VISIBILITYMAP_ALL_FROZEN) =
!=3D 0)
> >       {
> > +             Assert((presult.new_vmbits & VISIBILITYMAP_ALL_VISIBLE) !=
=3D 0);
> >               vacrel->vm_new_frozen_pages++;
> >               *vm_page_frozen =3D true;
> >       }
>
> It's a bit odd that we figure out all of this by inspecting old/new vmbit=
s and
> have that logic in multiple places.

I changed PruneFreezeResult to have just the counters that have to be
reflected in vacrel for logging (vm_new_frozen_pages, etc) instead of
passing the bits back.

> > Subject: [PATCH v33 05/16] Move VM assert into prune/freeze code
>
> Feels like a somewhat too narrow description, given that it changes the A=
PI
> for heap_page_prune_and_freeze() by removing variables from PruneFreezeRe=
sult.

I've tried to fix this.

> > +/*
> > + * Wrapper for heap_page_would_be_all_visible() which can be used for =
callers
> > + * that expect no LP_DEAD on the page. Currently assert-only, but ther=
e is no
> > + * reason not to use it outside of asserts.
> > + */
>
> If so, why would we want it in pruneheap.c? Seems a bit odd to have
> heap_page_would_be_all_visible() defined in vacuumlazy.c but defined
> heap_page_is_all_visible() in pruneheap.c.

You're right. I've kept them both in vacuumlazy.c

> > From cdf5776fadeae3430c692999b37f8a7ec944bda1 Mon Sep 17 00:00:00 2001
> > From: Melanie Plageman <melanieplageman@gmail.com>
> > Date: Tue, 2 Dec 2025 16:16:22 -0500

> > +static TransactionId
> > +get_conflict_xid(bool do_prune, bool do_freeze, bool do_set_vm,
> > +                              uint8 old_vmbits, uint8 new_vmbits,
> > +                              TransactionId latest_xid_removed, Transa=
ctionId frz_conflict_horizon,
> > +                              TransactionId visibility_cutoff_xid)
> > +{
>
> The logic for horizons is now split between this and "Calculate what the
> snapshot conflict horizon should be for a record" in heap_page_will_freez=
e().

That is true in master too. We determine frz_conflict_horizon in
heap_page_will_freeze() and later before emitting the WAL record
decide which of the latest_xid_removed and frz_conflict_horizon that
we should use as the snapshot conflict horizon for the combined
record.

All I've done is expand that part (the part before emitting the WAL
record) a bit because now we have to consider what the horizon would
be if we set the VM.

If I really wanted to calculate it only in a single place, I could
maintain a new variable, all_frozen_except_dead, and remove the
frz_conflict_horizon from heap_page_will_freeze(). Then, in
get_conflict_xid(), I could have the following logic:

    if (do_set_vm)
        conflict_xid =3D visibility_cutoff_xid;
    else if (do_freeze)
    {
        if (all_frozen_except_dead)
            conflict_xid =3D visibility_cutoff_xid;
        else
        {
            conflict_xid =3D OldestXmin;
            TransactionIdRetreat(conflict_xid);
        }
    }
    else
        conflict_xid =3D InvalidTransactionId;

I think using all_frozen_except_dead while maintaining
visibility_cutoff_xid (in heap_prune_record_unchanged_lp_normal()) has
the potential to be confusing, though. We'd need to keep updating
visibility_cutoff_xid when all_visible is false but
all_frozen_except_dead is true as well as when all_visible is true.
And because we don't care about all_visible_except_dead, it gets even
more confusing to make sure we are maintaining the right variables in
the right situations.

Alternatively, we could keep maintenance of visibility_cutoff_xid the
same and only use all_frozen_except_dead to avoid having the conflict
xid calculation in two places. We would just set it after
prune_freeze_plan() and use it the way it is in the snippet above. But
I don't know if this is better than just having a separate freeze
conflict horizon calculated in the will_freeze code. It is just as
confusing to understand and just as many variables but in a different
place.

For now, I've kept it as is.

> Although I guess I don't understand that code:
>
>                 /*
>                  * Calculate what the snapshot conflict horizon should be=
 for a record
>                  * freezing tuples. We can use the visibility_cutoff_xid =
as our cutoff
>                  * for conflicts when the whole page is eligible to becom=
e all-frozen
>                  * in the VM once we're done with it. Otherwise, we gener=
ate a
>                  * conservative cutoff by stepping back from OldestXmin.
>                  */
>                 if (prstate->all_frozen)
>                         prstate->frz_conflict_horizon =3D prstate->visibi=
lity_cutoff_xid;
>                 else
>                 {
>                         /* Avoids false conflicts when hot_standby_feedba=
ck in use */
>                         prstate->frz_conflict_horizon =3D prstate->cutoff=
s->OldestXmin;
>                         TransactionIdRetreat(prstate->frz_conflict_horizo=
n);
>                 }
>
> Why does it make sense to use OldestXmin? Consider e.g. the case where th=
ere
> is one very old tuple that needs to be frozen and one new live tuple on a
> page. Because of the new tuple we can't mark the page all-frozen. But the=
re's
> also no reason to not use much less aggressive horizon than OldestXmin, n=
amely
> the newer of xmin,xmax of the old frozen tuple?

We don't track the newest frozen xmin right now. Doing so wouldn't be
free (i.e. more comparisons which may matter in a query without much
other overhead). And we can't get rid of any of the other cutoffs we
track. We'd still need to maintain the visibility_cutoff_xid and
latest_removed_xid. Which also means it doesn't simplify the code.

The only purpose it would serve is to make the snapshot conflict
horizon more accurate/more aggressive when we freeze tuples, which
would lead to canceling less queries than master -- which is outside
the purview of this patch. There's also a set of complications around
maintaining this number accurately mentioned by Peter in [1].

I've added a new patch in the series 0001 that expands the comment
about this in heap_page_will_freeze() and describes that we are using
a coarse cutoff because we don't track anything else.

But I don't think changing this behavior is a blocker for this feature.

> I also don't understand what the "false conflicts" thing is referencing.

Yea, neither do I. I ported that comment over (it's from before I
started modifying this code) and have never really understood what it
meant -- wouldn't we have more false conflicts if we use a newer
cutoff? (because OldestXmin will be newer than visibility_cutoff_xid).
If the page isn't all-visible, we won't maintain
visibility_cutoff_xid. But if we did actually track the newest live
tuple xmin on the page, that could very well be newer than OldestXmin
and thus using OldestXmin would cancel less and avoid more false
conflicts. But that feels like a _very_ big stretch (in a hypothetical
world that doesn't exist). Anyway, I've deleted the comment (in 0001)
since it clearly is not adding value.

> > +     TransactionId conflict_xid;
> > +
> > +     /*
> > +      * We can omit the snapshot conflict horizon if we are not prunin=
g or
> > +      * freezing any tuples and are setting an already all-visible pag=
e
> > +      * all-frozen in the VM. In this case, all of the tuples on the p=
age must
> > +      * already be visible to all MVCC snapshots on the standby.
> > +      */
>
> The last sentence here is a bit confusing, because they don't just need t=
o
> already be visible to everyone, they already need to be frozen. Right?

Right. Well that also means that all tuples are visible to all MVCC
snapshots on the standby too -- I picked that language up from
somewhere else in the code and thought it sounded good. But I've
edited it to say frozen, which is more accurate.

> > +     if (!do_prune &&
> > +             !do_freeze &&
> > +             do_set_vm &&
>
> I'm confused by the do_set_vm check here. Doesn't it mean that we will *n=
ot*
> return InvalidTransactionId if !prstate->attempt_update_vm?  I don't unde=
stand
> why that would make sense.
>
> I guess we'll compute a bogus cutoff in that cse, but never use it, since
> we'll also not emit WAL?  Or maybe we'll just unnecessarily go through th=
e
> code below, because the code turns out to do ok regardles?  It's confusin=
g
> either way.

Ah no, that was a relic from when I didn't clear the new vmbits in the
event that they were the same as old_vmbits. Now that I do that, I
don't need to qualify it with do_set_vm anymore. I've fixed that.

> > +             (old_vmbits & VISIBILITYMAP_ALL_VISIBLE) !=3D 0 &&
> > +             (new_vmbits & VISIBILITYMAP_ALL_FROZEN) !=3D 0)
>
> I wonder if some of this code would end up cleaner if we tracked the bits=
 we
> intend to add, rather than the target set of bits is.

I played around with this idea. Unfortunately, this specific check
wouldn't be much simpler, as I'd have to check that _only_ the
all-frozen bit is set. And I think that it is probably more clear with
explicit old and new vmbits. Those make it clear that we are setting a
formerly all-visible page all-frozen.

In some of the other places where I use old/new vmbits, I tried only
using the delta/bits that need to be newly set. But, for example, in
visibilitymap_set(), I need both the all-visible and all-frozen bits
to be passed (even if all-visible is already set), because it asserts
that if all-frozen is passed both all-visible and all-frozen are
passed. If I only keep track of the new bits that need to be set, I
would require other logic before visibilitymap_set(). And it makes
sense that visibilitymap_set() requires both because you don't ever
want people setting just all-frozen -- and you don't want the API to
make it easy to do that.

> > +     /*
> > +      * If we are updating the VM, the conflict horizon is almost alwa=
ys the
> > +      * visibility cutoff XID.
> > +      *
> > +      * Separately, if we are freezing any tuples, as an optimization,=
 we can
> > +      * use the visibility_cutoff_xid as the conflict horizon if the p=
age will
> > +      * be all-frozen.
>
> What does "as an optimization" mean here?

What I meant was that visibility_cutoff_xid is going to be older than
OldestXmin for an all-frozen page, so it will lead to canceling fewer
queries. So, using it is kind of an "optimization". But I re-read that
comment and it was way too confusing. I actually cut that whole
paragraph because it should be discussed in heap_page_will_freeze()
where we are actually handling it.

> Note that the code actually uses visibility_cutoff_xid even if the page i=
s
> just marked all-visible, but not all-frozen (due to the do_set_vm check b=
eing
> earlier)

And that is correct. But the comment (which is now removed) was
misleading, you are right.

> > This is true even if there are LP_DEAD line pointers
> > +      * because we ignored those when maintaining the visibility_cutof=
f_xid.
>
> I must just be missing something because I can't follow this at all.  I g=
uess
> it could be correct because we later then add in knowledge of removed xid=
s in
> via the TransactionIdFollows check below? But if that's it, this is extre=
mely
> confusingly worded.

Yes, we add in latest_xid_removed which is what makes it correct. But
I agree that the wording was terrible. I've cut those details from
get_conflict_xid() and kept them where they are relevant in
heap_page_will_freeze().

- Melanie

[1] https://www.postgresql.org/message-id/CAH2-WzkB-Pt3zPeTXvMik6jcJn%2Bdcp=
UqO-tt_hc13bD6sGRLPg%40mail.gmail.com

--0000000000000dfe5806497aee85
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v34-0001-Clarify-some-heap-tuple-freezing-related-comment.patch"
Content-Disposition: attachment; 
	filename="v34-0001-Clarify-some-heap-tuple-freezing-related-comment.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkyn45r90>
X-Attachment-Id: f_mkyn45r90
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--0000000000000dfe5806497aee85
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v34-0002-Set-the-VM-in-heap_page_prune_and_freeze.patch"
Content-Disposition: attachment; 
	filename="v34-0002-Set-the-VM-in-heap_page_prune_and_freeze.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkyn4d7v1>
X-Attachment-Id: f_mkyn4d7v1
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--0000000000000dfe5806497aee85
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v34-0003-Move-VM-assert-into-prune-freeze-code-and-simpli.patch"
Content-Disposition: attachment; 
	filename="v34-0003-Move-VM-assert-into-prune-freeze-code-and-simpli.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkyn4hm62>
X-Attachment-Id: f_mkyn4hm62

RnJvbSBlNTkxYmYwNjFlZTY3M2YzNzUwZDExODA2NzNlMWFiNDhiZTQzYmI4IE1vbiBTZXAgMTcg
MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h
aWwuY29tPgpEYXRlOiBUdWUsIDI3IEphbiAyMDI2IDE2OjUzOjExIC0wNTAwClN1YmplY3Q6IFtQ
QVRDSCB2MzQgMDMvMTRdIE1vdmUgVk0gYXNzZXJ0IGludG8gcHJ1bmUvZnJlZXplIGNvZGUgYW5k
IHNpbXBsaWZ5CiByZXR1cm5lZCB2YWx1ZXMKCkFmdGVyIHBydW5pbmcgYW5kIGZyZWV6aW5nLCB3
ZSBkbyBhbiBhc3NlcnQtb25seSB2YWxpZGF0YXRpb24gdGhhdCB0aGUKcGFnZSdzIHZpc2liaWxp
dHkgc3RhdHVzIG1hdGNoZXMgd2hhdCB3ZSBmb3VuZCBkdXJpbmcgdGhlIHBydW5pbmcgYW5kCmZy
ZWV6aW5nIHBhc3Mgb3ZlciB0aGUgcGFnZS4KClRoZXJlJ3Mgbm8gcmVhc29uIHRvIHdhaXQgdW50
aWwgbGF6eV9zY2FuX3BydW5lKCkgdG8gZG8gdGhpcyB2YWxpZGF0aW9uLAphcyBhbGwgb2YgdGhl
IFZNIHNldHRpbmcgbG9naWMgaGFzIGFscmVhZHkgYmVlbiBtb3ZlZCB0bwpoZWFwX3BhZ2VfcHJ1
bmVfYW5kX2ZyZWV6ZSgpLgoKRG9pbmcgc28gYWxzbyBhbGxvd3MgdXMgdG8gcmVtb3ZlIHNvbWUg
ZmllbGRzIG9mIFBydW5lRnJlZXplUmVzdWx0LApuYXJyb3dpbmcgdGhlIHNjb3BlIG9mIHZhbHVl
cyB0aGUgY2FsbGVyIGhhcyB0byB0aGluayBhYm91dC4KCkF1dGhvcjogTWVsYW5pZSBQbGFnZW1h
biA8bWVsYW5pZXBsYWdlbWFuQGdtYWlsLmNvbT4KUmV2aWV3ZWQtYnk6IEFuZHJlcyBGcmV1bmQg
PGFuZHJlc0BhbmFyYXplbC5kZT4KUmV2aWV3ZWQtYnk6IENoYW8gTGkgPGxpLmV2YW4uY2hhb0Bn
bWFpbC5jb20+CkRpc2N1c3Npb246IGh0dHBzOi8vcG9zdGdyLmVzL20vN2liM3NhNTVzYXB3amxh
ejRzaWpiaXE3aWV6bmEyN2tqdnZ2YXI0ZHBna21hZG1sNnQlNDBnZnBra3dtZG5lcHgKLS0tCiBz
cmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9wcnVuZWhlYXAuYyAgfCA2NSArKysrKysrKysrKysrKysr
KysrLS0tLS0tLS0tCiBzcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgfCAzNSAr
LS0tLS0tLS0tLS0tLS0KIHNyYy9pbmNsdWRlL2FjY2Vzcy9oZWFwYW0uaCAgICAgICAgICB8IDI2
ICsrKystLS0tLS0tCiAzIGZpbGVzIGNoYW5nZWQsIDU0IGluc2VydGlvbnMoKyksIDcyIGRlbGV0
aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3BydW5laGVhcC5j
IGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvcHJ1bmVoZWFwLmMKaW5kZXggMDE0YzNjOTJkNmMu
LjE5MmRmOWEyMjE4IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9wcnVuZWhl
YXAuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9wcnVuZWhlYXAuYwpAQCAtOTkxLDYg
Kzk5MSw3IEBAIGhlYXBfcGFnZV9wcnVuZV9hbmRfZnJlZXplKFBydW5lRnJlZXplUGFyYW1zICpw
YXJhbXMsCiAJQnVmZmVyCQl2bWJ1ZmZlciA9IHBhcmFtcy0+dm1idWZmZXI7CiAJUGFnZQkJcGFn
ZSA9IEJ1ZmZlckdldFBhZ2UoYnVmZmVyKTsKIAlCbG9ja051bWJlciBibG9ja25vID0gQnVmZmVy
R2V0QmxvY2tOdW1iZXIoYnVmZmVyKTsKKwlUcmFuc2FjdGlvbklkIHZtX2NvbmZsaWN0X2hvcml6
b24gPSBJbnZhbGlkVHJhbnNhY3Rpb25JZDsKIAlQcnVuZVN0YXRlCXByc3RhdGU7CiAJYm9vbAkJ
ZG9fZnJlZXplOwogCWJvb2wJCWRvX3BydW5lOwpAQCAtMTE0OSwyMyArMTE1MCw4IEBAIGhlYXBf
cGFnZV9wcnVuZV9hbmRfZnJlZXplKFBydW5lRnJlZXplUGFyYW1zICpwYXJhbXMsCiAJcHJlc3Vs
dC0+bmZyb3plbiA9IHByc3RhdGUubmZyb3plbjsKIAlwcmVzdWx0LT5saXZlX3R1cGxlcyA9IHBy
c3RhdGUubGl2ZV90dXBsZXM7CiAJcHJlc3VsdC0+cmVjZW50bHlfZGVhZF90dXBsZXMgPSBwcnN0
YXRlLnJlY2VudGx5X2RlYWRfdHVwbGVzOwotCXByZXN1bHQtPmFsbF92aXNpYmxlID0gcHJzdGF0
ZS5hbGxfdmlzaWJsZTsKLQlwcmVzdWx0LT5hbGxfZnJvemVuID0gcHJzdGF0ZS5hbGxfZnJvemVu
OwogCXByZXN1bHQtPmhhc3R1cCA9IHByc3RhdGUuaGFzdHVwOwogCi0JLyoKLQkgKiBGb3IgY2Fs
bGVycyBwbGFubmluZyB0byB1cGRhdGUgdGhlIHZpc2liaWxpdHkgbWFwLCB0aGUgY29uZmxpY3Qg
aG9yaXpvbgotCSAqIGZvciB0aGF0IHJlY29yZCBtdXN0IGJlIHRoZSBuZXdlc3QgeG1pbiBvbiB0
aGUgcGFnZS4gIEhvd2V2ZXIsIGlmIHRoZQotCSAqIHBhZ2UgaXMgY29tcGxldGVseSBmcm96ZW4s
IHRoZXJlIGNhbiBiZSBubyBjb25mbGljdCBhbmQgdGhlCi0JICogdm1fY29uZmxpY3RfaG9yaXpv
biBzaG91bGQgcmVtYWluIEludmFsaWRUcmFuc2FjdGlvbklkLiAgVGhpcyBpbmNsdWRlcwotCSAq
IHRoZSBjYXNlIHRoYXQgd2UganVzdCBmcm96ZSBhbGwgdGhlIHR1cGxlczsgdGhlIHBydW5lLWZy
ZWV6ZSByZWNvcmQKLQkgKiBpbmNsdWRlZCB0aGUgY29uZmxpY3QgWElEIGFscmVhZHkgc28gdGhl
IGNhbGxlciBkb2Vzbid0IG5lZWQgaXQuCi0JICovCi0JaWYgKHByZXN1bHQtPmFsbF9mcm96ZW4p
Ci0JCXByZXN1bHQtPnZtX2NvbmZsaWN0X2hvcml6b24gPSBJbnZhbGlkVHJhbnNhY3Rpb25JZDsK
LQllbHNlCi0JCXByZXN1bHQtPnZtX2NvbmZsaWN0X2hvcml6b24gPSBwcnN0YXRlLnZpc2liaWxp
dHlfY3V0b2ZmX3hpZDsKLQogCXByZXN1bHQtPmxwZGVhZF9pdGVtcyA9IHByc3RhdGUubHBkZWFk
X2l0ZW1zOwogCS8qIHRoZSBwcmVzdWx0LT5kZWFkb2Zmc2V0cyBhcnJheSB3YXMgYWxyZWFkeSBm
aWxsZWQgaW4gKi8KIApAQCAtMTE4Myw2ICsxMTY5LDQ2IEBAIGhlYXBfcGFnZV9wcnVuZV9hbmRf
ZnJlZXplKFBydW5lRnJlZXplUGFyYW1zICpwYXJhbXMsCiAJCX0KIAl9CiAKKwkvKgorCSAqIElm
IHVwZGF0aW5nIHRoZSB2aXNpYmlsaXR5IG1hcCwgdGhlIGNvbmZsaWN0IGhvcml6b24gZm9yIHRo
YXQgcmVjb3JkCisJICogbXVzdCBiZSB0aGUgbmV3ZXN0IHhtaW4gb24gdGhlIHBhZ2UuICBIb3dl
dmVyLCBpZiB0aGUgcGFnZSBpcworCSAqIGNvbXBsZXRlbHkgZnJvemVuLCB0aGVyZSBjYW4gYmUg
bm8gY29uZmxpY3QgYW5kIHRoZSB2bV9jb25mbGljdF9ob3Jpem9uCisJICogc2hvdWxkIHJlbWFp
biBJbnZhbGlkVHJhbnNhY3Rpb25JZC4gIFRoaXMgaW5jbHVkZXMgdGhlIGNhc2UgdGhhdCB3ZQor
CSAqIGp1c3QgZnJvemUgYWxsIHRoZSB0dXBsZXM7IHRoZSBwcnVuZS1mcmVlemUgcmVjb3JkIGlu
Y2x1ZGVkIHRoZQorCSAqIGNvbmZsaWN0IFhJRCBhbHJlYWR5IHNvIHdlIGRvbid0IG5lZWQgdG8g
YWdhaW4uCisJICovCisJaWYgKHByc3RhdGUuYWxsX2Zyb3plbikKKwkJdm1fY29uZmxpY3RfaG9y
aXpvbiA9IEludmFsaWRUcmFuc2FjdGlvbklkOworCWVsc2UKKwkJdm1fY29uZmxpY3RfaG9yaXpv
biA9IHByc3RhdGUudmlzaWJpbGl0eV9jdXRvZmZfeGlkOworCisJLyoKKwkgKiBEdXJpbmcgaXRz
IHNlY29uZCBwYXNzIG92ZXIgdGhlIGhlYXAsIFZBQ1VVTSBjYWxscworCSAqIGhlYXBfcGFnZV93
b3VsZF9iZV9hbGxfdmlzaWJsZSgpIHRvIGRldGVybWluZSB3aGV0aGVyIGEgcGFnZSBpcworCSAq
IGFsbC12aXNpYmxlIGFuZCBhbGwtZnJvemVuLiBUaGUgbG9naWMgaGVyZSBpcyBzaW1pbGFyLiBB
ZnRlciBjb21wbGV0aW5nCisJICogcHJ1bmluZyBhbmQgZnJlZXppbmcsIHVzZSBhbiBhc3NlcnRp
b24gdG8gdmVyaWZ5IHRoYXQgb3VyIHJlc3VsdHMKKwkgKiByZW1haW4gY29uc2lzdGVudCB3aXRo
IGhlYXBfcGFnZV93b3VsZF9iZV9hbGxfdmlzaWJsZSgpLgorCSAqLworI2lmZGVmIFVTRV9BU1NF
UlRfQ0hFQ0tJTkcKKwlpZiAocHJzdGF0ZS5hbGxfdmlzaWJsZSkKKwl7CisJCVRyYW5zYWN0aW9u
SWQgZGVidWdfY3V0b2ZmOworCQlib29sCQlkZWJ1Z19hbGxfZnJvemVuOworCisJCUFzc2VydChw
cmVzdWx0LT5scGRlYWRfaXRlbXMgPT0gMCk7CisKKwkJQXNzZXJ0KGhlYXBfcGFnZV9pc19hbGxf
dmlzaWJsZShwYXJhbXMtPnJlbGF0aW9uLCBidWZmZXIsCisJCQkJCQkJCQkJcHJzdGF0ZS5jdXRv
ZmZzLT5PbGRlc3RYbWluLAorCQkJCQkJCQkJCSZkZWJ1Z19hbGxfZnJvemVuLAorCQkJCQkJCQkJ
CSZkZWJ1Z19jdXRvZmYsIG9mZl9sb2MpKTsKKworCQlBc3NlcnQocHJzdGF0ZS5hbGxfZnJvemVu
ID09IGRlYnVnX2FsbF9mcm96ZW4pOworCisJCUFzc2VydCghVHJhbnNhY3Rpb25JZElzVmFsaWQo
ZGVidWdfY3V0b2ZmKSB8fAorCQkJICAgZGVidWdfY3V0b2ZmID09IHZtX2NvbmZsaWN0X2hvcml6
b24pOworCX0KKyNlbmRpZgorCiAJLyogTm93IHVwZGF0ZSB0aGUgdmlzaWJpbGl0eSBtYXAgYW5k
IFBEX0FMTF9WSVNJQkxFIGhpbnQgKi8KIAlBc3NlcnQoIXByc3RhdGUuYWxsX3Zpc2libGUgfHwg
KHByc3RhdGUubHBkZWFkX2l0ZW1zID09IDApKTsKIApAQCAtMTIyOSwyMiArMTI1NSwyMSBAQCBo
ZWFwX3BhZ2VfcHJ1bmVfYW5kX2ZyZWV6ZShQcnVuZUZyZWV6ZVBhcmFtcyAqcGFyYW1zLAogCQkg
KiBtYWtlIGV2ZXJ5dGhpbmcgc2FmZSBmb3IgUkVETyB3YXMgbG9nZ2VkIHdoZW4gdGhlIHBhZ2Un
cyB0dXBsZXMKIAkJICogd2VyZSBmcm96ZW4uCiAJCSAqLwotCQlBc3NlcnQoIXByc3RhdGUuYWxs
X2Zyb3plbiB8fAotCQkJICAgIVRyYW5zYWN0aW9uSWRJc1ZhbGlkKHByZXN1bHQtPnZtX2NvbmZs
aWN0X2hvcml6b24pKTsKKwkJQXNzZXJ0KCFwcnN0YXRlLmFsbF9mcm96ZW4gfHwgIVRyYW5zYWN0
aW9uSWRJc1ZhbGlkKHZtX2NvbmZsaWN0X2hvcml6b24pKTsKIAogCQl2aXNpYmlsaXR5bWFwX3Nl
dChwYXJhbXMtPnJlbGF0aW9uLCBibG9ja25vLCBidWZmZXIsCiAJCQkJCQkgIEludmFsaWRYTG9n
UmVjUHRyLAotCQkJCQkJICB2bWJ1ZmZlciwgcHJlc3VsdC0+dm1fY29uZmxpY3RfaG9yaXpvbiwK
KwkJCQkJCSAgdm1idWZmZXIsIHZtX2NvbmZsaWN0X2hvcml6b24sCiAJCQkJCQkgIG5ld192bWJp
dHMpOwogCiAJCWlmICgob2xkX3ZtYml0cyAmIFZJU0lCSUxJVFlNQVBfQUxMX1ZJU0lCTEUpID09
IDApCiAJCXsKIAkJCXByZXN1bHQtPm5ld19hbGxfdmlzaWJsZV9wYWdlcyA9IDE7Ci0JCQlpZiAo
cHJlc3VsdC0+YWxsX2Zyb3plbikKKwkJCWlmIChwcnN0YXRlLmFsbF9mcm96ZW4pCiAJCQkJcHJl
c3VsdC0+bmV3X2FsbF92aXNpYmxlX2Zyb3plbl9wYWdlcyA9IDE7CiAJCX0KIAkJZWxzZSBpZiAo
KG9sZF92bWJpdHMgJiBWSVNJQklMSVRZTUFQX0FMTF9GUk9aRU4pID09IDAgJiYKLQkJCQkgcHJl
c3VsdC0+YWxsX2Zyb3plbikKKwkJCQkgcHJzdGF0ZS5hbGxfZnJvemVuKQogCQkJcHJlc3VsdC0+
bmV3X2FsbF9mcm96ZW5fcGFnZXMgPSAxOwogCX0KIH0KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5k
L2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1
bWxhenkuYwppbmRleCAzMjNiOGUzZGRlMy4uOTBlOTRiMmFjM2YgMTAwNjQ0Ci0tLSBhL3NyYy9i
YWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3Mv
aGVhcC92YWN1dW1sYXp5LmMKQEAgLTQ1NiwxMyArNDU2LDYgQEAgc3RhdGljIHZvaWQgZGVhZF9p
dGVtc19hZGQoTFZSZWxTdGF0ZSAqdmFjcmVsLCBCbG9ja051bWJlciBibGtubywgT2Zmc2V0TnVt
YmVyICoKIHN0YXRpYyB2b2lkIGRlYWRfaXRlbXNfcmVzZXQoTFZSZWxTdGF0ZSAqdmFjcmVsKTsK
IHN0YXRpYyB2b2lkIGRlYWRfaXRlbXNfY2xlYW51cChMVlJlbFN0YXRlICp2YWNyZWwpOwogCi0j
aWZkZWYgVVNFX0FTU0VSVF9DSEVDS0lORwotc3RhdGljIGJvb2wgaGVhcF9wYWdlX2lzX2FsbF92
aXNpYmxlKFJlbGF0aW9uIHJlbCwgQnVmZmVyIGJ1ZiwKLQkJCQkJCQkJCSBUcmFuc2FjdGlvbklk
IE9sZGVzdFhtaW4sCi0JCQkJCQkJCQkgYm9vbCAqYWxsX2Zyb3plbiwKLQkJCQkJCQkJCSBUcmFu
c2FjdGlvbklkICp2aXNpYmlsaXR5X2N1dG9mZl94aWQsCi0JCQkJCQkJCQkgT2Zmc2V0TnVtYmVy
ICpsb2dnaW5nX29mZm51bSk7Ci0jZW5kaWYKIHN0YXRpYyBib29sIGhlYXBfcGFnZV93b3VsZF9i
ZV9hbGxfdmlzaWJsZShSZWxhdGlvbiByZWwsIEJ1ZmZlciBidWYsCiAJCQkJCQkJCQkJICAgVHJh
bnNhY3Rpb25JZCBPbGRlc3RYbWluLAogCQkJCQkJCQkJCSAgIE9mZnNldE51bWJlciAqZGVhZG9m
ZnNldHMsCkBAIC0yMDMyLDMyICsyMDI1LDYgQEAgbGF6eV9zY2FuX3BydW5lKExWUmVsU3RhdGUg
KnZhY3JlbCwKIAkJdmFjcmVsLT5uZXdfZnJvemVuX3R1cGxlX3BhZ2VzKys7CiAJfQogCi0JLyoK
LQkgKiBWQUNVVU0gd2lsbCBjYWxsIGhlYXBfcGFnZV9pc19hbGxfdmlzaWJsZSgpIGR1cmluZyB0
aGUgc2Vjb25kIHBhc3Mgb3ZlcgotCSAqIHRoZSBoZWFwIHRvIGRldGVybWluZSBhbGxfdmlzaWJs
ZSBhbmQgYWxsX2Zyb3plbiBmb3IgdGhlIHBhZ2UgLS0gdGhpcwotCSAqIGlzIGEgc3BlY2lhbGl6
ZWQgdmVyc2lvbiBvZiB0aGUgbG9naWMgZnJvbSB0aGlzIGZ1bmN0aW9uLiAgTm93IHRoYXQKLQkg
KiB3ZSd2ZSBmaW5pc2hlZCBwcnVuaW5nIGFuZCBmcmVlemluZywgbWFrZSBzdXJlIHRoYXQgd2Un
cmUgaW4gdG90YWwKLQkgKiBhZ3JlZW1lbnQgd2l0aCBoZWFwX3BhZ2VfaXNfYWxsX3Zpc2libGUo
KSB1c2luZyBhbiBhc3NlcnRpb24uCi0JICovCi0jaWZkZWYgVVNFX0FTU0VSVF9DSEVDS0lORwot
CWlmIChwcmVzdWx0LmFsbF92aXNpYmxlKQotCXsKLQkJVHJhbnNhY3Rpb25JZCBkZWJ1Z19jdXRv
ZmY7Ci0JCWJvb2wJCWRlYnVnX2FsbF9mcm96ZW47Ci0KLQkJQXNzZXJ0KHByZXN1bHQubHBkZWFk
X2l0ZW1zID09IDApOwotCi0JCUFzc2VydChoZWFwX3BhZ2VfaXNfYWxsX3Zpc2libGUodmFjcmVs
LT5yZWwsIGJ1ZiwKLQkJCQkJCQkJCQl2YWNyZWwtPmN1dG9mZnMuT2xkZXN0WG1pbiwgJmRlYnVn
X2FsbF9mcm96ZW4sCi0JCQkJCQkJCQkJJmRlYnVnX2N1dG9mZiwgJnZhY3JlbC0+b2ZmbnVtKSk7
Ci0KLQkJQXNzZXJ0KHByZXN1bHQuYWxsX2Zyb3plbiA9PSBkZWJ1Z19hbGxfZnJvemVuKTsKLQot
CQlBc3NlcnQoIVRyYW5zYWN0aW9uSWRJc1ZhbGlkKGRlYnVnX2N1dG9mZikgfHwKLQkJCSAgIGRl
YnVnX2N1dG9mZiA9PSBwcmVzdWx0LnZtX2NvbmZsaWN0X2hvcml6b24pOwotCX0KLSNlbmRpZgot
CiAJLyoKIAkgKiBOb3cgc2F2ZSBkZXRhaWxzIG9mIHRoZSBMUF9ERUFEIGl0ZW1zIGZyb20gdGhl
IHBhZ2UgaW4gdmFjcmVsCiAJICovCkBAIC0zNTExLDcgKzM0NzgsNyBAQCBkZWFkX2l0ZW1zX2Ns
ZWFudXAoTFZSZWxTdGF0ZSAqdmFjcmVsKQogICogdGhhdCBleHBlY3Qgbm8gTFBfREVBRCBvbiB0
aGUgcGFnZS4gQ3VycmVudGx5IGFzc2VydC1vbmx5LCBidXQgdGhlcmUgaXMgbm8KICAqIHJlYXNv
biBub3QgdG8gdXNlIGl0IG91dHNpZGUgb2YgYXNzZXJ0cy4KICAqLwotc3RhdGljIGJvb2wKK2Jv
b2wKIGhlYXBfcGFnZV9pc19hbGxfdmlzaWJsZShSZWxhdGlvbiByZWwsIEJ1ZmZlciBidWYsCiAJ
CQkJCQkgVHJhbnNhY3Rpb25JZCBPbGRlc3RYbWluLAogCQkJCQkJIGJvb2wgKmFsbF9mcm96ZW4s
CmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9hY2Nlc3MvaGVhcGFtLmggYi9zcmMvaW5jbHVkZS9h
Y2Nlc3MvaGVhcGFtLmgKaW5kZXggZGY5ZmExN2E2ZjkuLmEwZjc5NzQ5NDJlIDEwMDY0NAotLS0g
YS9zcmMvaW5jbHVkZS9hY2Nlc3MvaGVhcGFtLmgKKysrIGIvc3JjL2luY2x1ZGUvYWNjZXNzL2hl
YXBhbS5oCkBAIC0yNTcsOCArMjU3LDcgQEAgdHlwZWRlZiBzdHJ1Y3QgUHJ1bmVGcmVlemVQYXJh
bXMKIAkgKiBIRUFQX1BBR0VfUFJVTkVfTUFSS19VTlVTRURfTk9XIGluZGljYXRlcyB0aGF0IGRl
YWQgaXRlbXMgY2FuIGJlIHNldAogCSAqIExQX1VOVVNFRCBkdXJpbmcgcHJ1bmluZy4KIAkgKgot
CSAqIEhFQVBfUEFHRV9QUlVORV9GUkVFWkUgaW5kaWNhdGVzIHRoYXQgd2Ugd2lsbCBhbHNvIGZy
ZWV6ZSB0dXBsZXMsIGFuZAotCSAqIHdpbGwgcmV0dXJuICdhbGxfdmlzaWJsZScsICdhbGxfZnJv
emVuJyBmbGFncyB0byB0aGUgY2FsbGVyLgorCSAqIEhFQVBfUEFHRV9QUlVORV9GUkVFWkUgaW5k
aWNhdGVzIHRoYXQgd2Ugd2lsbCBhbHNvIGZyZWV6ZSB0dXBsZXMuCiAJICoKIAkgKiBIRUFQX1BB
R0VfUFJVTkVfVVBEQVRFX1ZNIGluZGljYXRlcyB0aGF0IHdlIHdpbGwgc2V0IHRoZSBwYWdlJ3Mg
c3RhdHVzCiAJICogaW4gdGhlIFZNLgpAQCAtMjk0LDIxICsyOTMsNiBAQCB0eXBlZGVmIHN0cnVj
dCBQcnVuZUZyZWV6ZVJlc3VsdAogCWludAkJCWxpdmVfdHVwbGVzOwogCWludAkJCXJlY2VudGx5
X2RlYWRfdHVwbGVzOwogCi0JLyoKLQkgKiBhbGxfdmlzaWJsZSBhbmQgYWxsX2Zyb3plbiBpbmRp
Y2F0ZSBpZiB0aGUgYWxsLXZpc2libGUgYW5kIGFsbC1mcm96ZW4KLQkgKiBiaXRzIGluIHRoZSB2
aXNpYmlsaXR5IG1hcCBjYW4gYmUgc2V0IGZvciB0aGlzIHBhZ2UsIGFmdGVyIHBydW5pbmcuCi0J
ICoKLQkgKiB2bV9jb25mbGljdF9ob3Jpem9uIGlzIHRoZSBuZXdlc3QgeG1pbiBvZiBsaXZlIHR1
cGxlcyBvbiB0aGUgcGFnZS4gIFRoZQotCSAqIGNhbGxlciBjYW4gdXNlIGl0IGFzIHRoZSBjb25m
bGljdCBob3Jpem9uIHdoZW4gc2V0dGluZyB0aGUgVk0gYml0cy4gIEl0Ci0JICogaXMgb25seSB2
YWxpZCBpZiB3ZSBmcm96ZSBzb21lIHR1cGxlcyAobmZyb3plbiA+IDApLCBhbmQgYWxsX2Zyb3pl
biBpcwotCSAqIHRydWUuCi0JICoKLQkgKiBUaGVzZSBhcmUgb25seSBzZXQgaWYgdGhlIEhFQVBf
UEFHRV9QUlVORV9GUkVFWkUgb3B0aW9uIGlzIHNldC4KLQkgKi8KLQlib29sCQlhbGxfdmlzaWJs
ZTsKLQlib29sCQlhbGxfZnJvemVuOwotCVRyYW5zYWN0aW9uSWQgdm1fY29uZmxpY3RfaG9yaXpv
bjsKLQogCS8qCiAJICogV2hldGhlciBvciBub3QgdGhlIHBhZ2Ugd2FzIG5ld2x5IHNldCBhbGwt
dmlzaWJsZSBhbmQgYWxsLWZyb3plbiBkdXJpbmcKIAkgKiBwaGFzZSBJIG9mIHZhY3V1bWluZy4K
QEAgLTQ1Myw3ICs0MzcsMTMgQEAgZXh0ZXJuIHZvaWQgbG9nX2hlYXBfcHJ1bmVfYW5kX2ZyZWV6
ZShSZWxhdGlvbiByZWxhdGlvbiwgQnVmZmVyIGJ1ZmZlciwKIC8qIGluIGhlYXAvdmFjdXVtbGF6
eS5jICovCiBleHRlcm4gdm9pZCBoZWFwX3ZhY3V1bV9yZWwoUmVsYXRpb24gcmVsLAogCQkJCQkJ
CWNvbnN0IFZhY3V1bVBhcmFtcyBwYXJhbXMsIEJ1ZmZlckFjY2Vzc1N0cmF0ZWd5IGJzdHJhdGVn
eSk7Ci0KKyNpZmRlZiBVU0VfQVNTRVJUX0NIRUNLSU5HCitleHRlcm4gYm9vbCBoZWFwX3BhZ2Vf
aXNfYWxsX3Zpc2libGUoUmVsYXRpb24gcmVsLCBCdWZmZXIgYnVmLAorCQkJCQkJCQkJIFRyYW5z
YWN0aW9uSWQgT2xkZXN0WG1pbiwKKwkJCQkJCQkJCSBib29sICphbGxfZnJvemVuLAorCQkJCQkJ
CQkJIFRyYW5zYWN0aW9uSWQgKnZpc2liaWxpdHlfY3V0b2ZmX3hpZCwKKwkJCQkJCQkJCSBPZmZz
ZXROdW1iZXIgKmxvZ2dpbmdfb2ZmbnVtKTsKKyNlbmRpZgogLyogaW4gaGVhcC9oZWFwYW1fdmlz
aWJpbGl0eS5jICovCiBleHRlcm4gYm9vbCBIZWFwVHVwbGVTYXRpc2ZpZXNWaXNpYmlsaXR5KEhl
YXBUdXBsZSBodHVwLCBTbmFwc2hvdCBzbmFwc2hvdCwKIAkJCQkJCQkJCQkgQnVmZmVyIGJ1ZmZl
cik7Ci0tIAoyLjQzLjAKCg==
--0000000000000dfe5806497aee85
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v34-0004-Eliminate-XLOG_HEAP2_VISIBLE-from-vacuum-phase-I.patch"
Content-Disposition: attachment; 
	filename="v34-0004-Eliminate-XLOG_HEAP2_VISIBLE-from-vacuum-phase-I.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkyn4oqv3>
X-Attachment-Id: f_mkyn4oqv3
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--0000000000000dfe5806497aee85
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v34-0005-Eliminate-XLOG_HEAP2_VISIBLE-from-empty-page-vac.patch"
Content-Disposition: attachment; 
	filename="v34-0005-Eliminate-XLOG_HEAP2_VISIBLE-from-empty-page-vac.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkyn4tpy4>
X-Attachment-Id: f_mkyn4tpy4

RnJvbSBkZGE2Y2VmZmM5MjQzMzNmZDc1ODdjOTJjMzM2YTAxOTMyOTY3NTMyIE1vbiBTZXAgMTcg
MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h
aWwuY29tPgpEYXRlOiBTYXQsIDI3IFNlcCAyMDI1IDExOjU1OjIxIC0wNDAwClN1YmplY3Q6IFtQ
QVRDSCB2MzQgMDUvMTRdIEVsaW1pbmF0ZSBYTE9HX0hFQVAyX1ZJU0lCTEUgZnJvbSBlbXB0eS1w
YWdlIHZhY3V1bQoKQXMgcGFydCBvZiByZW1vdmluZyBYTE9HX0hFQVAyX1ZJU0lCTEUgcmVjb3Jk
cywgcGhhc2UgSSBvZiBWQUNVVU0gbm93Cm1hcmtzIGVtcHR5IHBhZ2VzIGFsbC12aXNpYmxlIGlu
IGEgWExPR19IRUFQMl9QUlVORV9WQUNVVU1fU0NBTiByZWNvcmQuCgpBdXRob3I6IE1lbGFuaWUg
UGxhZ2VtYW4gPG1lbGFuaWVwbGFnZW1hbkBnbWFpbC5jb20+ClJldmlld2VkLWJ5OiBSb2JlcnQg
SGFhcyA8cm9iZXJ0bWhhYXNAZ21haWwuY29tPgpSZXZpZXdlZC1ieTogQW5kcmVzIEZyZXVuZCA8
YW5kcmVzQGFuYXJhemVsLmRlPgpSZXZpZXdlZC1ieTogQ2hhbyBMaSA8bGkuZXZhbi5jaGFvQGdt
YWlsLmNvbT4KLS0tCiBzcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgfCAzNSAr
KysrKysrKysrKysrKysrKysrKysrKy0tLS0tCiAxIGZpbGUgY2hhbmdlZCwgMjkgaW5zZXJ0aW9u
cygrKSwgNiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVh
cC92YWN1dW1sYXp5LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKaW5k
ZXggOTBlOTRiMmFjM2YuLjg2YjMxNTU3MTdlIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nl
c3MvaGVhcC92YWN1dW1sYXp5LmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVt
bGF6eS5jCkBAIC0xOTAwLDkgKzE5MDAsMTIgQEAgbGF6eV9zY2FuX25ld19vcl9lbXB0eShMVlJl
bFN0YXRlICp2YWNyZWwsIEJ1ZmZlciBidWYsIEJsb2NrTnVtYmVyIGJsa25vLAogCQkgKi8KIAkJ
aWYgKCFQYWdlSXNBbGxWaXNpYmxlKHBhZ2UpKQogCQl7CisJCQkvKiBMb2NrIHZtYnVmZmVyIGJl
Zm9yZSBlbnRlcmluZyBjcml0aWNhbCBzZWN0aW9uICovCisJCQlMb2NrQnVmZmVyKHZtYnVmZmVy
LCBCVUZGRVJfTE9DS19FWENMVVNJVkUpOworCiAJCQlTVEFSVF9DUklUX1NFQ1RJT04oKTsKIAot
CQkJLyogbWFyayBidWZmZXIgZGlydHkgYmVmb3JlIHdyaXRpbmcgYSBXQUwgcmVjb3JkICovCisJ
CQkvKiBNYXJrIGJ1ZmZlciBkaXJ0eSBiZWZvcmUgd3JpdGluZyBhbnkgV0FMIHJlY29yZHMgKi8K
IAkJCU1hcmtCdWZmZXJEaXJ0eShidWYpOwogCiAJCQkvKgpAQCAtMTkxOSwxMyArMTkyMiwzMyBA
QCBsYXp5X3NjYW5fbmV3X29yX2VtcHR5KExWUmVsU3RhdGUgKnZhY3JlbCwgQnVmZmVyIGJ1Ziwg
QmxvY2tOdW1iZXIgYmxrbm8sCiAJCQkJbG9nX25ld3BhZ2VfYnVmZmVyKGJ1ZiwgdHJ1ZSk7CiAK
IAkJCVBhZ2VTZXRBbGxWaXNpYmxlKHBhZ2UpOwotCQkJdmlzaWJpbGl0eW1hcF9zZXQodmFjcmVs
LT5yZWwsIGJsa25vLCBidWYsCi0JCQkJCQkJICBJbnZhbGlkWExvZ1JlY1B0ciwKLQkJCQkJCQkg
IHZtYnVmZmVyLCBJbnZhbGlkVHJhbnNhY3Rpb25JZCwKLQkJCQkJCQkgIFZJU0lCSUxJVFlNQVBf
QUxMX1ZJU0lCTEUgfAotCQkJCQkJCSAgVklTSUJJTElUWU1BUF9BTExfRlJPWkVOKTsKKwkJCXZp
c2liaWxpdHltYXBfc2V0X3ZtYml0cyhibGtubywKKwkJCQkJCQkJCSB2bWJ1ZmZlciwKKwkJCQkJ
CQkJCSBWSVNJQklMSVRZTUFQX0FMTF9WSVNJQkxFIHwKKwkJCQkJCQkJCSBWSVNJQklMSVRZTUFQ
X0FMTF9GUk9aRU4sCisJCQkJCQkJCQkgdmFjcmVsLT5yZWwtPnJkX2xvY2F0b3IpOworCisJCQkv
KgorCQkJICogRW1pdCBXQUwgZm9yIHNldHRpbmcgUERfQUxMX1ZJU0lCTEUgb24gdGhlIGhlYXAg
cGFnZSBhbmQKKwkJCSAqIHNldHRpbmcgdGhlIFZNLgorCQkJICovCisJCQlpZiAoUmVsYXRpb25O
ZWVkc1dBTCh2YWNyZWwtPnJlbCkpCisJCQkJbG9nX2hlYXBfcHJ1bmVfYW5kX2ZyZWV6ZSh2YWNy
ZWwtPnJlbCwgYnVmLAorCQkJCQkJCQkJCSAgdm1idWZmZXIsCisJCQkJCQkJCQkJICBWSVNJQklM
SVRZTUFQX0FMTF9WSVNJQkxFIHwKKwkJCQkJCQkJCQkgIFZJU0lCSUxJVFlNQVBfQUxMX0ZST1pF
TiwKKwkJCQkJCQkJCQkgIEludmFsaWRUcmFuc2FjdGlvbklkLCAvKiBjb25mbGljdCB4aWQgKi8K
KwkJCQkJCQkJCQkgIGZhbHNlLAkvKiBjbGVhbnVwIGxvY2sgKi8KKwkJCQkJCQkJCQkgIFBSVU5F
X1ZBQ1VVTV9TQ0FOLAkvKiByZWFzb24gKi8KKwkJCQkJCQkJCQkgIE5VTEwsIDAsCisJCQkJCQkJ
CQkJICBOVUxMLCAwLAorCQkJCQkJCQkJCSAgTlVMTCwgMCwKKwkJCQkJCQkJCQkgIE5VTEwsIDAp
OworCiAJCQlFTkRfQ1JJVF9TRUNUSU9OKCk7CiAKKwkJCUxvY2tCdWZmZXIodm1idWZmZXIsIEJV
RkZFUl9MT0NLX1VOTE9DSyk7CisKIAkJCS8qIENvdW50IHRoZSBuZXdseSBhbGwtZnJvemVuIHBh
Z2VzIGZvciBsb2dnaW5nICovCiAJCQl2YWNyZWwtPnZtX25ld192aXNpYmxlX3BhZ2VzKys7CiAJ
CQl2YWNyZWwtPnZtX25ld192aXNpYmxlX2Zyb3plbl9wYWdlcysrOwotLSAKMi40My4wCgo=
--0000000000000dfe5806497aee85
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v34-0006-Remove-XLOG_HEAP2_VISIBLE-entirely.patch"
Content-Disposition: attachment; 
	filename="v34-0006-Remove-XLOG_HEAP2_VISIBLE-entirely.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkyn4yhh5>
X-Attachment-Id: f_mkyn4yhh5
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--0000000000000dfe5806497aee85
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v34-0007-Simplify-heap_page_would_be_all_visible-visibili.patch"
Content-Disposition: attachment; 
	filename="v34-0007-Simplify-heap_page_would_be_all_visible-visibili.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkyn522e6>
X-Attachment-Id: f_mkyn522e6
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==
--0000000000000dfe5806497aee85
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v34-0008-Remove-table_scan_analyze_next_tuple-unneeded-pa.patch"
Content-Disposition: attachment; 
	filename="v34-0008-Remove-table_scan_analyze_next_tuple-unneeded-pa.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkyn55ae7>
X-Attachment-Id: f_mkyn55ae7
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--0000000000000dfe5806497aee85
Content-Type: text/x-patch; charset="UTF-8"; 
	name="v34-0009-Use-GlobalVisState-in-vacuum-to-determine-page-l.patch"
Content-Disposition: attachment; 
	filename="v34-0009-Use-GlobalVisState-in-vacuum-to-determine-page-l.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkyn585f8>
X-Attachment-Id: f_mkyn585f8
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--0000000000000dfe5806497aee85
Content-Type: text/x-patch; charset="UTF-8"; 
	name="v34-0010-Unset-all_visible-sooner-if-not-freezing.patch"
Content-Disposition: attachment; 
	filename="v34-0010-Unset-all_visible-sooner-if-not-freezing.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkyn5b3r9>
X-Attachment-Id: f_mkyn5b3r9
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--0000000000000dfe5806497aee85
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v34-0011-Track-which-relations-are-modified-by-a-query.patch"
Content-Disposition: attachment; 
	filename="v34-0011-Track-which-relations-are-modified-by-a-query.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkyn5fpb10>
X-Attachment-Id: f_mkyn5fpb10
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=
--0000000000000dfe5806497aee85
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v34-0012-Pass-down-information-on-table-modification-to-s.patch"
Content-Disposition: attachment; 
	filename="v34-0012-Pass-down-information-on-table-modification-to-s.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkyn5l9r11>
X-Attachment-Id: f_mkyn5l9r11

RnJvbSA4MjA1YjJkN2RhMGMzYWQzY2JjNWNlYWQzMzZjZWQ2Nzc5OTZiMzdkIE1vbiBTZXAgMTcg
MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h
aWwuY29tPgpEYXRlOiBXZWQsIDMgRGVjIDIwMjUgMTU6MTI6MTggLTA1MDAKU3ViamVjdDogW1BB
VENIIHYzNCAxMi8xNF0gUGFzcyBkb3duIGluZm9ybWF0aW9uIG9uIHRhYmxlIG1vZGlmaWNhdGlv
biB0byBzY2FuCiBub2RlCgpQYXNzIGRvd24gaW5mb3JtYXRpb24gdG8gc2VxdWVudGlhbCBzY2Fu
LCBpbmRleCBbb25seV0gc2NhbiwgYW5kIGJpdG1hcAp0YWJsZSBzY2FuIG5vZGVzIG9uIHdoZXRo
ZXIgb3Igbm90IHRoZSBxdWVyeSBtb2RpZmllcyB0aGUgcmVsYXRpb24gYmVpbmcKc2Nhbm5lZC4g
QSBsYXRlciBjb21taXQgd2lsbCB1c2UgdGhpcyBpbmZvcm1hdGlvbiB0byB1cGRhdGUgdGhlIFZN
CmR1cmluZyBvbi1hY2Nlc3MgcHJ1bmluZyBvbmx5IGlmIHRoZSByZWxhdGlvbiBpcyBub3QgbW9k
aWZpZWQgYnkgdGhlCnF1ZXJ5LgoKQXV0aG9yOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxh
Z2VtYW5AZ21haWwuY29tPgpSZXZpZXdlZC1ieTogQW5kcmV5IEJvcm9kaW4gPHg0bW1tQHlhbmRl
eC10ZWFtLnJ1PgpSZXZpZXdlZC1ieTogQ2hhbyBMaSA8bGkuZXZhbi5jaGFvQGdtYWlsLmNvbT4K
RGlzY3Vzc2lvbjogaHR0cHM6Ly9wb3N0Z3IuZXMvbS80Mzc5RkRBMy05NDQ2LTRFMkMtOUMxNS0z
MkVGRThENEYzMUIlNDB5YW5kZXgtdGVhbS5ydQotLS0KIGNvbnRyaWIvcGdyb3dsb2Nrcy9wZ3Jv
d2xvY2tzLmMgICAgICAgICAgIHwgIDIgKy0KIHNyYy9iYWNrZW5kL2FjY2Vzcy9icmluL2JyaW4u
YyAgICAgICAgICAgIHwgIDMgKystCiBzcmMvYmFja2VuZC9hY2Nlc3MvZ2luL2dpbmluc2VydC5j
ICAgICAgICB8ICAzICsrLQogc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFtX2hhbmRsZXIu
YyAgfCAgNyArKystLS0KIHNyYy9iYWNrZW5kL2FjY2Vzcy9pbmRleC9nZW5hbS5jICAgICAgICAg
IHwgIDQgKystLQogc3JjL2JhY2tlbmQvYWNjZXNzL2luZGV4L2luZGV4YW0uYyAgICAgICAgfCAg
NiArKystLS0KIHNyYy9iYWNrZW5kL2FjY2Vzcy9uYnRyZWUvbmJ0c29ydC5jICAgICAgIHwgIDIg
Ky0KIHNyYy9iYWNrZW5kL2FjY2Vzcy90YWJsZS90YWJsZWFtLmMgICAgICAgIHwgIDcgKysrLS0t
CiBzcmMvYmFja2VuZC9jb21tYW5kcy9jb25zdHJhaW50LmMgICAgICAgICB8ICAyICstCiBzcmMv
YmFja2VuZC9jb21tYW5kcy9jb3B5dG8uYyAgICAgICAgICAgICB8ICAyICstCiBzcmMvYmFja2Vu
ZC9jb21tYW5kcy90YWJsZWNtZHMuYyAgICAgICAgICB8ICA4ICsrKy0tLS0KIHNyYy9iYWNrZW5k
L2NvbW1hbmRzL3R5cGVjbWRzLmMgICAgICAgICAgIHwgIDQgKystLQogc3JjL2JhY2tlbmQvZXhl
Y3V0b3IvZXhlY0luZGV4aW5nLmMgICAgICAgfCAgMiArLQogc3JjL2JhY2tlbmQvZXhlY3V0b3Iv
ZXhlY1JlcGxpY2F0aW9uLmMgICAgfCAgOCArKystLS0tCiBzcmMvYmFja2VuZC9leGVjdXRvci9u
b2RlQml0bWFwSGVhcHNjYW4uYyB8ICA5ICsrKysrKystCiBzcmMvYmFja2VuZC9leGVjdXRvci9u
b2RlSW5kZXhvbmx5c2Nhbi5jICB8ICA5ICsrKysrKystCiBzcmMvYmFja2VuZC9leGVjdXRvci9u
b2RlSW5kZXhzY2FuLmMgICAgICB8IDE4ICsrKysrKysrKysrKysrLS0KIHNyYy9iYWNrZW5kL2V4
ZWN1dG9yL25vZGVTZXFzY2FuLmMgICAgICAgIHwgMjYgKysrKysrKysrKysrKysrKysrKystLS0K
IHNyYy9iYWNrZW5kL3BhcnRpdGlvbmluZy9wYXJ0Ym91bmRzLmMgICAgIHwgIDIgKy0KIHNyYy9i
YWNrZW5kL3V0aWxzL2FkdC9zZWxmdW5jcy5jICAgICAgICAgIHwgIDIgKy0KIHNyYy9pbmNsdWRl
L2FjY2Vzcy9nZW5hbS5oICAgICAgICAgICAgICAgIHwgIDIgKy0KIHNyYy9pbmNsdWRlL2FjY2Vz
cy9oZWFwYW0uaCAgICAgICAgICAgICAgIHwgIDYgKysrKysrCiBzcmMvaW5jbHVkZS9hY2Nlc3Mv
dGFibGVhbS5oICAgICAgICAgICAgICB8IDE5ICsrKysrKysrKystLS0tLS0tCiAyMyBmaWxlcyBj
aGFuZ2VkLCAxMDcgaW5zZXJ0aW9ucygrKSwgNDYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEv
Y29udHJpYi9wZ3Jvd2xvY2tzL3Bncm93bG9ja3MuYyBiL2NvbnRyaWIvcGdyb3dsb2Nrcy9wZ3Jv
d2xvY2tzLmMKaW5kZXggZjg4MjY5MzMyYjYuLjI3ZjAxZDgwNTVmIDEwMDY0NAotLS0gYS9jb250
cmliL3Bncm93bG9ja3MvcGdyb3dsb2Nrcy5jCisrKyBiL2NvbnRyaWIvcGdyb3dsb2Nrcy9wZ3Jv
d2xvY2tzLmMKQEAgLTExNCw3ICsxMTQsNyBAQCBwZ3Jvd2xvY2tzKFBHX0ZVTkNUSU9OX0FSR1Mp
CiAJCQkJCSAgIFJlbGF0aW9uR2V0UmVsYXRpb25OYW1lKHJlbCkpOwogCiAJLyogU2NhbiB0aGUg
cmVsYXRpb24gKi8KLQlzY2FuID0gdGFibGVfYmVnaW5zY2FuKHJlbCwgR2V0QWN0aXZlU25hcHNo
b3QoKSwgMCwgTlVMTCk7CisJc2NhbiA9IHRhYmxlX2JlZ2luc2NhbihyZWwsIEdldEFjdGl2ZVNu
YXBzaG90KCksIDAsIE5VTEwsIDApOwogCWhzY2FuID0gKEhlYXBTY2FuRGVzYykgc2NhbjsKIAog
CWF0dGlubWV0YSA9IFR1cGxlRGVzY0dldEF0dEluTWV0YWRhdGEocnNpbmZvLT5zZXREZXNjKTsK
ZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9icmluL2JyaW4uYyBiL3NyYy9iYWNrZW5k
L2FjY2Vzcy9icmluL2JyaW4uYwppbmRleCA2ODg3ZTQyMTQ0Mi4uNGQ5Njg0YjFiMTkgMTAwNjQ0
Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9icmluL2JyaW4uYworKysgYi9zcmMvYmFja2VuZC9h
Y2Nlc3MvYnJpbi9icmluLmMKQEAgLTI4NDMsNyArMjg0Myw4IEBAIF9icmluX3BhcmFsbGVsX3Nj
YW5fYW5kX2J1aWxkKEJyaW5CdWlsZFN0YXRlICpzdGF0ZSwKIAlpbmRleEluZm8tPmlpX0NvbmN1
cnJlbnQgPSBicmluc2hhcmVkLT5pc2NvbmN1cnJlbnQ7CiAKIAlzY2FuID0gdGFibGVfYmVnaW5z
Y2FuX3BhcmFsbGVsKGhlYXAsCi0JCQkJCQkJCQlQYXJhbGxlbFRhYmxlU2NhbkZyb21CcmluU2hh
cmVkKGJyaW5zaGFyZWQpKTsKKwkJCQkJCQkJCVBhcmFsbGVsVGFibGVTY2FuRnJvbUJyaW5TaGFy
ZWQoYnJpbnNoYXJlZCksCisJCQkJCQkJCQkwKTsKIAogCXJlbHR1cGxlcyA9IHRhYmxlX2luZGV4
X2J1aWxkX3NjYW4oaGVhcCwgaW5kZXgsIGluZGV4SW5mbywgdHJ1ZSwgdHJ1ZSwKIAkJCQkJCQkJ
CSAgIGJyaW5idWlsZENhbGxiYWNrUGFyYWxsZWwsIHN0YXRlLCBzY2FuKTsKZGlmZiAtLWdpdCBh
L3NyYy9iYWNrZW5kL2FjY2Vzcy9naW4vZ2luaW5zZXJ0LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3Mv
Z2luL2dpbmluc2VydC5jCmluZGV4IDBkNjNmYjRiYTI3Li5mMDJkNmRmNDBhMiAxMDA2NDQKLS0t
IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2dpbi9naW5pbnNlcnQuYworKysgYi9zcmMvYmFja2VuZC9h
Y2Nlc3MvZ2luL2dpbmluc2VydC5jCkBAIC0yMDU5LDcgKzIwNTksOCBAQCBfZ2luX3BhcmFsbGVs
X3NjYW5fYW5kX2J1aWxkKEdpbkJ1aWxkU3RhdGUgKnN0YXRlLAogCWluZGV4SW5mby0+aWlfQ29u
Y3VycmVudCA9IGdpbnNoYXJlZC0+aXNjb25jdXJyZW50OwogCiAJc2NhbiA9IHRhYmxlX2JlZ2lu
c2Nhbl9wYXJhbGxlbChoZWFwLAotCQkJCQkJCQkJUGFyYWxsZWxUYWJsZVNjYW5Gcm9tR2luQnVp
bGRTaGFyZWQoZ2luc2hhcmVkKSk7CisJCQkJCQkJCQlQYXJhbGxlbFRhYmxlU2NhbkZyb21HaW5C
dWlsZFNoYXJlZChnaW5zaGFyZWQpLAorCQkJCQkJCQkJMCk7CiAKIAlyZWx0dXBsZXMgPSB0YWJs
ZV9pbmRleF9idWlsZF9zY2FuKGhlYXAsIGluZGV4LCBpbmRleEluZm8sIHRydWUsIHByb2dyZXNz
LAogCQkJCQkJCQkJICAgZ2luQnVpbGRDYWxsYmFja1BhcmFsbGVsLCBzdGF0ZSwgc2Nhbik7CmRp
ZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW1faGFuZGxlci5jIGIvc3Jj
L2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFtX2hhbmRsZXIuYwppbmRleCBkYTRhZTIzNmNhOC4u
NmNlNDM1MGMyYzggMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL2hlYXBhbV9o
YW5kbGVyLmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFtX2hhbmRsZXIuYwpA
QCAtNzksMTIgKzc5LDEzIEBAIGhlYXBhbV9zbG90X2NhbGxiYWNrcyhSZWxhdGlvbiByZWxhdGlv
bikKICAqLwogCiBzdGF0aWMgSW5kZXhGZXRjaFRhYmxlRGF0YSAqCi1oZWFwYW1faW5kZXhfZmV0
Y2hfYmVnaW4oUmVsYXRpb24gcmVsKQoraGVhcGFtX2luZGV4X2ZldGNoX2JlZ2luKFJlbGF0aW9u
IHJlbCwgdWludDMyIGZsYWdzKQogewogCUluZGV4RmV0Y2hIZWFwRGF0YSAqaHNjYW4gPSBwYWxs
b2MwX29iamVjdChJbmRleEZldGNoSGVhcERhdGEpOwogCiAJaHNjYW4tPnhzX2Jhc2UucmVsID0g
cmVsOwogCWhzY2FuLT54c19jYnVmID0gSW52YWxpZEJ1ZmZlcjsKKwloc2Nhbi0+bW9kaWZpZXNf
YmFzZV9yZWwgPSAhKGZsYWdzICYgU09fSElOVF9SRUxfUkVBRF9PTkxZKTsKIAogCXJldHVybiAm
aHNjYW4tPnhzX2Jhc2U7CiB9CkBAIC03NTMsNyArNzU0LDcgQEAgaGVhcGFtX3JlbGF0aW9uX2Nv
cHlfZm9yX2NsdXN0ZXIoUmVsYXRpb24gT2xkSGVhcCwgUmVsYXRpb24gTmV3SGVhcCwKIAogCQl0
YWJsZVNjYW4gPSBOVUxMOwogCQloZWFwU2NhbiA9IE5VTEw7Ci0JCWluZGV4U2NhbiA9IGluZGV4
X2JlZ2luc2NhbihPbGRIZWFwLCBPbGRJbmRleCwgU25hcHNob3RBbnksIE5VTEwsIDAsIDApOwor
CQlpbmRleFNjYW4gPSBpbmRleF9iZWdpbnNjYW4oT2xkSGVhcCwgT2xkSW5kZXgsIFNuYXBzaG90
QW55LCBOVUxMLCAwLCAwLCAwKTsKIAkJaW5kZXhfcmVzY2FuKGluZGV4U2NhbiwgTlVMTCwgMCwg
TlVMTCwgMCk7CiAJfQogCWVsc2UKQEAgLTc2Miw3ICs3NjMsNyBAQCBoZWFwYW1fcmVsYXRpb25f
Y29weV9mb3JfY2x1c3RlcihSZWxhdGlvbiBPbGRIZWFwLCBSZWxhdGlvbiBOZXdIZWFwLAogCQlw
Z3N0YXRfcHJvZ3Jlc3NfdXBkYXRlX3BhcmFtKFBST0dSRVNTX0NMVVNURVJfUEhBU0UsCiAJCQkJ
CQkJCQkgUFJPR1JFU1NfQ0xVU1RFUl9QSEFTRV9TRVFfU0NBTl9IRUFQKTsKIAotCQl0YWJsZVNj
YW4gPSB0YWJsZV9iZWdpbnNjYW4oT2xkSGVhcCwgU25hcHNob3RBbnksIDAsIChTY2FuS2V5KSBO
VUxMKTsKKwkJdGFibGVTY2FuID0gdGFibGVfYmVnaW5zY2FuKE9sZEhlYXAsIFNuYXBzaG90QW55
LCAwLCAoU2NhbktleSkgTlVMTCwgMCk7CiAJCWhlYXBTY2FuID0gKEhlYXBTY2FuRGVzYykgdGFi
bGVTY2FuOwogCQlpbmRleFNjYW4gPSBOVUxMOwogCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9h
Y2Nlc3MvaW5kZXgvZ2VuYW0uYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9pbmRleC9nZW5hbS5jCmlu
ZGV4IGEyOWJlNmY0NjdiLi41YWM3ZDIyZTQ5ZiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvYWNj
ZXNzL2luZGV4L2dlbmFtLmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2luZGV4L2dlbmFtLmMK
QEAgLTQ0Nyw3ICs0NDcsNyBAQCBzeXN0YWJsZV9iZWdpbnNjYW4oUmVsYXRpb24gaGVhcFJlbGF0
aW9uLAogCQl9CiAKIAkJc3lzc2Nhbi0+aXNjYW4gPSBpbmRleF9iZWdpbnNjYW4oaGVhcFJlbGF0
aW9uLCBpcmVsLAotCQkJCQkJCQkJCSBzbmFwc2hvdCwgTlVMTCwgbmtleXMsIDApOworCQkJCQkJ
CQkJCSBzbmFwc2hvdCwgTlVMTCwgbmtleXMsIDAsIDApOwogCQlpbmRleF9yZXNjYW4oc3lzc2Nh
bi0+aXNjYW4sIGlkeGtleSwgbmtleXMsIE5VTEwsIDApOwogCQlzeXNzY2FuLT5zY2FuID0gTlVM
TDsKIApAQCAtNzA4LDcgKzcwOCw3IEBAIHN5c3RhYmxlX2JlZ2luc2Nhbl9vcmRlcmVkKFJlbGF0
aW9uIGhlYXBSZWxhdGlvbiwKIAl9CiAKIAlzeXNzY2FuLT5pc2NhbiA9IGluZGV4X2JlZ2luc2Nh
bihoZWFwUmVsYXRpb24sIGluZGV4UmVsYXRpb24sCi0JCQkJCQkJCQkgc25hcHNob3QsIE5VTEws
IG5rZXlzLCAwKTsKKwkJCQkJCQkJCSBzbmFwc2hvdCwgTlVMTCwgbmtleXMsIDAsIDApOwogCWlu
ZGV4X3Jlc2NhbihzeXNzY2FuLT5pc2NhbiwgaWR4a2V5LCBua2V5cywgTlVMTCwgMCk7CiAJc3lz
c2Nhbi0+c2NhbiA9IE5VTEw7CiAKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9pbmRl
eC9pbmRleGFtLmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaW5kZXgvaW5kZXhhbS5jCmluZGV4IDRl
ZDA1MDhjNjA1Li40ZGY1NjA4Nzg0MSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvYWNjZXNzL2lu
ZGV4L2luZGV4YW0uYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaW5kZXgvaW5kZXhhbS5jCkBA
IC0yNTcsNyArMjU3LDcgQEAgaW5kZXhfYmVnaW5zY2FuKFJlbGF0aW9uIGhlYXBSZWxhdGlvbiwK
IAkJCQlSZWxhdGlvbiBpbmRleFJlbGF0aW9uLAogCQkJCVNuYXBzaG90IHNuYXBzaG90LAogCQkJ
CUluZGV4U2Nhbkluc3RydW1lbnRhdGlvbiAqaW5zdHJ1bWVudCwKLQkJCQlpbnQgbmtleXMsIGlu
dCBub3JkZXJieXMpCisJCQkJaW50IG5rZXlzLCBpbnQgbm9yZGVyYnlzLCB1aW50MzIgZmxhZ3Mp
CiB7CiAJSW5kZXhTY2FuRGVzYyBzY2FuOwogCkBAIC0yODQsNyArMjg0LDcgQEAgaW5kZXhfYmVn
aW5zY2FuKFJlbGF0aW9uIGhlYXBSZWxhdGlvbiwKIAlzY2FuLT5pbnN0cnVtZW50ID0gaW5zdHJ1
bWVudDsKIAogCS8qIHByZXBhcmUgdG8gZmV0Y2ggaW5kZXggbWF0Y2hlcyBmcm9tIHRhYmxlICov
Ci0Jc2Nhbi0+eHNfaGVhcGZldGNoID0gdGFibGVfaW5kZXhfZmV0Y2hfYmVnaW4oaGVhcFJlbGF0
aW9uKTsKKwlzY2FuLT54c19oZWFwZmV0Y2ggPSB0YWJsZV9pbmRleF9mZXRjaF9iZWdpbihoZWFw
UmVsYXRpb24sIGZsYWdzKTsKIAogCXJldHVybiBzY2FuOwogfQpAQCAtNjE1LDcgKzYxNSw3IEBA
IGluZGV4X2JlZ2luc2Nhbl9wYXJhbGxlbChSZWxhdGlvbiBoZWFwcmVsLCBSZWxhdGlvbiBpbmRl
eHJlbCwKIAlzY2FuLT5pbnN0cnVtZW50ID0gaW5zdHJ1bWVudDsKIAogCS8qIHByZXBhcmUgdG8g
ZmV0Y2ggaW5kZXggbWF0Y2hlcyBmcm9tIHRhYmxlICovCi0Jc2Nhbi0+eHNfaGVhcGZldGNoID0g
dGFibGVfaW5kZXhfZmV0Y2hfYmVnaW4oaGVhcHJlbCk7CisJc2Nhbi0+eHNfaGVhcGZldGNoID0g
dGFibGVfaW5kZXhfZmV0Y2hfYmVnaW4oaGVhcHJlbCwgMCk7CiAKIAlyZXR1cm4gc2NhbjsKIH0K
ZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9uYnRyZWUvbmJ0c29ydC5jIGIvc3JjL2Jh
Y2tlbmQvYWNjZXNzL25idHJlZS9uYnRzb3J0LmMKaW5kZXggOTBhYjRlOTFiNTYuLjhhZTU0MjE3
ZjM2IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvbmJ0cmVlL25idHNvcnQuYworKysg
Yi9zcmMvYmFja2VuZC9hY2Nlc3MvbmJ0cmVlL25idHNvcnQuYwpAQCAtMTkyNSw3ICsxOTI1LDcg
QEAgX2J0X3BhcmFsbGVsX3NjYW5fYW5kX3NvcnQoQlRTcG9vbCAqYnRzcG9vbCwgQlRTcG9vbCAq
YnRzcG9vbDIsCiAJaW5kZXhJbmZvID0gQnVpbGRJbmRleEluZm8oYnRzcG9vbC0+aW5kZXgpOwog
CWluZGV4SW5mby0+aWlfQ29uY3VycmVudCA9IGJ0c2hhcmVkLT5pc2NvbmN1cnJlbnQ7CiAJc2Nh
biA9IHRhYmxlX2JlZ2luc2Nhbl9wYXJhbGxlbChidHNwb29sLT5oZWFwLAotCQkJCQkJCQkJUGFy
YWxsZWxUYWJsZVNjYW5Gcm9tQlRTaGFyZWQoYnRzaGFyZWQpKTsKKwkJCQkJCQkJCVBhcmFsbGVs
VGFibGVTY2FuRnJvbUJUU2hhcmVkKGJ0c2hhcmVkKSwgMCk7CiAJcmVsdHVwbGVzID0gdGFibGVf
aW5kZXhfYnVpbGRfc2NhbihidHNwb29sLT5oZWFwLCBidHNwb29sLT5pbmRleCwgaW5kZXhJbmZv
LAogCQkJCQkJCQkJICAgdHJ1ZSwgcHJvZ3Jlc3MsIF9idF9idWlsZF9jYWxsYmFjaywKIAkJCQkJ
CQkJCSAgICZidWlsZHN0YXRlLCBzY2FuKTsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vz
cy90YWJsZS90YWJsZWFtLmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvdGFibGUvdGFibGVhbS5jCmlu
ZGV4IDg3NDkxNzk2NTIzLi4yZmYyOWI2ZTQwYiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvYWNj
ZXNzL3RhYmxlL3RhYmxlYW0uYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvdGFibGUvdGFibGVh
bS5jCkBAIC0xNjMsMTAgKzE2MywxMSBAQCB0YWJsZV9wYXJhbGxlbHNjYW5faW5pdGlhbGl6ZShS
ZWxhdGlvbiByZWwsIFBhcmFsbGVsVGFibGVTY2FuRGVzYyBwc2NhbiwKIH0KIAogVGFibGVTY2Fu
RGVzYwotdGFibGVfYmVnaW5zY2FuX3BhcmFsbGVsKFJlbGF0aW9uIHJlbGF0aW9uLCBQYXJhbGxl
bFRhYmxlU2NhbkRlc2MgcHNjYW4pCit0YWJsZV9iZWdpbnNjYW5fcGFyYWxsZWwoUmVsYXRpb24g
cmVsYXRpb24sIFBhcmFsbGVsVGFibGVTY2FuRGVzYyBwc2NhbiwgdWludDMyIGZsYWdzKQogewog
CVNuYXBzaG90CXNuYXBzaG90OwotCXVpbnQzMgkJZmxhZ3MgPSBTT19UWVBFX1NFUVNDQU4gfAor
CisJZmxhZ3MgfD0gU09fVFlQRV9TRVFTQ0FOIHwKIAkJU09fQUxMT1dfU1RSQVQgfCBTT19BTExP
V19TWU5DIHwgU09fQUxMT1dfUEFHRU1PREU7CiAKIAlBc3NlcnQoUmVsRmlsZUxvY2F0b3JFcXVh
bHMocmVsYXRpb24tPnJkX2xvY2F0b3IsIHBzY2FuLT5waHNfbG9jYXRvcikpOwpAQCAtMjQ4LDcg
KzI0OSw3IEBAIHRhYmxlX2luZGV4X2ZldGNoX3R1cGxlX2NoZWNrKFJlbGF0aW9uIHJlbCwKIAli
b29sCQlmb3VuZDsKIAogCXNsb3QgPSB0YWJsZV9zbG90X2NyZWF0ZShyZWwsIE5VTEwpOwotCXNj
YW4gPSB0YWJsZV9pbmRleF9mZXRjaF9iZWdpbihyZWwpOworCXNjYW4gPSB0YWJsZV9pbmRleF9m
ZXRjaF9iZWdpbihyZWwsIDApOwogCWZvdW5kID0gdGFibGVfaW5kZXhfZmV0Y2hfdHVwbGUoc2Nh
biwgdGlkLCBzbmFwc2hvdCwgc2xvdCwgJmNhbGxfYWdhaW4sCiAJCQkJCQkJCQlhbGxfZGVhZCk7
CiAJdGFibGVfaW5kZXhfZmV0Y2hfZW5kKHNjYW4pOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQv
Y29tbWFuZHMvY29uc3RyYWludC5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvY29uc3RyYWludC5j
CmluZGV4IGNjMTFjNDdiNmYyLi4zN2NmYmQ2MzkzOCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQv
Y29tbWFuZHMvY29uc3RyYWludC5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2NvbnN0cmFp
bnQuYwpAQCAtMTA2LDcgKzEwNiw3IEBAIHVuaXF1ZV9rZXlfcmVjaGVjayhQR19GVU5DVElPTl9B
UkdTKQogCSAqLwogCXRtcHRpZCA9IGNoZWNrdGlkOwogCXsKLQkJSW5kZXhGZXRjaFRhYmxlRGF0
YSAqc2NhbiA9IHRhYmxlX2luZGV4X2ZldGNoX2JlZ2luKHRyaWdkYXRhLT50Z19yZWxhdGlvbik7
CisJCUluZGV4RmV0Y2hUYWJsZURhdGEgKnNjYW4gPSB0YWJsZV9pbmRleF9mZXRjaF9iZWdpbih0
cmlnZGF0YS0+dGdfcmVsYXRpb24sIDApOwogCQlib29sCQljYWxsX2FnYWluID0gZmFsc2U7CiAK
IAkJaWYgKCF0YWJsZV9pbmRleF9mZXRjaF90dXBsZShzY2FuLCAmdG1wdGlkLCBTbmFwc2hvdFNl
bGYsIHNsb3QsCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy9jb3B5dG8uYyBiL3Ny
Yy9iYWNrZW5kL2NvbW1hbmRzL2NvcHl0by5jCmluZGV4IDRhYjRhMzg5M2Q1Li40MjYxYmFmNGE0
MSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvY29weXRvLmMKKysrIGIvc3JjL2Jh
Y2tlbmQvY29tbWFuZHMvY29weXRvLmMKQEAgLTExNTYsNyArMTE1Niw3IEBAIENvcHlSZWxhdGlv
blRvKENvcHlUb1N0YXRlIGNzdGF0ZSwgUmVsYXRpb24gcmVsLCBSZWxhdGlvbiByb290X3JlbCwg
dWludDY0ICpwcm9jCiAJQXR0ck1hcCAgICAqbWFwID0gTlVMTDsKIAlUdXBsZVRhYmxlU2xvdCAq
cm9vdF9zbG90ID0gTlVMTDsKIAotCXNjYW5kZXNjID0gdGFibGVfYmVnaW5zY2FuKHJlbCwgR2V0
QWN0aXZlU25hcHNob3QoKSwgMCwgTlVMTCk7CisJc2NhbmRlc2MgPSB0YWJsZV9iZWdpbnNjYW4o
cmVsLCBHZXRBY3RpdmVTbmFwc2hvdCgpLCAwLCBOVUxMLCAwKTsKIAlzbG90ID0gdGFibGVfc2xv
dF9jcmVhdGUocmVsLCBOVUxMKTsKIAogCS8qCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21t
YW5kcy90YWJsZWNtZHMuYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3RhYmxlY21kcy5jCmluZGV4
IGY5NzZjMGU1YzdlLi5lYjM1ZGJiYzg1MyAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFu
ZHMvdGFibGVjbWRzLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdGFibGVjbWRzLmMKQEAg
LTYzNzgsNyArNjM3OCw3IEBAIEFUUmV3cml0ZVRhYmxlKEFsdGVyZWRUYWJsZUluZm8gKnRhYiwg
T2lkIE9JRE5ld0hlYXApCiAJCSAqIGNoZWNraW5nIGFsbCB0aGUgY29uc3RyYWludHMuCiAJCSAq
LwogCQlzbmFwc2hvdCA9IFJlZ2lzdGVyU25hcHNob3QoR2V0TGF0ZXN0U25hcHNob3QoKSk7Ci0J
CXNjYW4gPSB0YWJsZV9iZWdpbnNjYW4ob2xkcmVsLCBzbmFwc2hvdCwgMCwgTlVMTCk7CisJCXNj
YW4gPSB0YWJsZV9iZWdpbnNjYW4ob2xkcmVsLCBzbmFwc2hvdCwgMCwgTlVMTCwgMCk7CiAKIAkJ
LyoKIAkJICogU3dpdGNoIHRvIHBlci10dXBsZSBtZW1vcnkgY29udGV4dCBhbmQgcmVzZXQgaXQg
Zm9yIGVhY2ggdHVwbGUKQEAgLTEzNzY4LDcgKzEzNzY4LDcgQEAgdmFsaWRhdGVGb3JlaWduS2V5
Q29uc3RyYWludChjaGFyICpjb25uYW1lLAogCSAqLwogCXNuYXBzaG90ID0gUmVnaXN0ZXJTbmFw
c2hvdChHZXRMYXRlc3RTbmFwc2hvdCgpKTsKIAlzbG90ID0gdGFibGVfc2xvdF9jcmVhdGUocmVs
LCBOVUxMKTsKLQlzY2FuID0gdGFibGVfYmVnaW5zY2FuKHJlbCwgc25hcHNob3QsIDAsIE5VTEwp
OworCXNjYW4gPSB0YWJsZV9iZWdpbnNjYW4ocmVsLCBzbmFwc2hvdCwgMCwgTlVMTCwgMCk7CiAK
IAlwZXJUdXBDeHQgPSBBbGxvY1NldENvbnRleHRDcmVhdGUoQ3VycmVudE1lbW9yeUNvbnRleHQs
CiAJCQkJCQkJCQkgICJ2YWxpZGF0ZUZvcmVpZ25LZXlDb25zdHJhaW50IiwKQEAgLTIyNjI2LDcg
KzIyNjI2LDcgQEAgTWVyZ2VQYXJ0aXRpb25zTW92ZVJvd3MoTGlzdCAqKndxdWV1ZSwgTGlzdCAq
bWVyZ2luZ1BhcnRpdGlvbnMsIFJlbGF0aW9uIG5ld1BhcnQKIAogCQkvKiBTY2FuIHRocm91Z2gg
dGhlIHJvd3MuICovCiAJCXNuYXBzaG90ID0gUmVnaXN0ZXJTbmFwc2hvdChHZXRMYXRlc3RTbmFw
c2hvdCgpKTsKLQkJc2NhbiA9IHRhYmxlX2JlZ2luc2NhbihtZXJnaW5nUGFydGl0aW9uLCBzbmFw
c2hvdCwgMCwgTlVMTCk7CisJCXNjYW4gPSB0YWJsZV9iZWdpbnNjYW4obWVyZ2luZ1BhcnRpdGlv
biwgc25hcHNob3QsIDAsIE5VTEwsIDApOwogCiAJCS8qCiAJCSAqIFN3aXRjaCB0byBwZXItdHVw
bGUgbWVtb3J5IGNvbnRleHQgYW5kIHJlc2V0IGl0IGZvciBlYWNoIHR1cGxlCkBAIC0yMzA5MCw3
ICsyMzA5MCw3IEBAIFNwbGl0UGFydGl0aW9uTW92ZVJvd3MoTGlzdCAqKndxdWV1ZSwgUmVsYXRp
b24gcmVsLCBSZWxhdGlvbiBzcGxpdFJlbCwKIAogCS8qIFNjYW4gdGhyb3VnaCB0aGUgcm93cy4g
Ki8KIAlzbmFwc2hvdCA9IFJlZ2lzdGVyU25hcHNob3QoR2V0TGF0ZXN0U25hcHNob3QoKSk7Ci0J
c2NhbiA9IHRhYmxlX2JlZ2luc2NhbihzcGxpdFJlbCwgc25hcHNob3QsIDAsIE5VTEwpOworCXNj
YW4gPSB0YWJsZV9iZWdpbnNjYW4oc3BsaXRSZWwsIHNuYXBzaG90LCAwLCBOVUxMLCAwKTsKIAog
CS8qCiAJICogU3dpdGNoIHRvIHBlci10dXBsZSBtZW1vcnkgY29udGV4dCBhbmQgcmVzZXQgaXQg
Zm9yIGVhY2ggdHVwbGUKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3R5cGVjbWRz
LmMgYi9zcmMvYmFja2VuZC9jb21tYW5kcy90eXBlY21kcy5jCmluZGV4IDI4OGVkYjI1ZjJmLi4z
NGZmOGQwNDFmMSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdHlwZWNtZHMuYwor
KysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy90eXBlY21kcy5jCkBAIC0zMTc5LDcgKzMxNzksNyBA
QCB2YWxpZGF0ZURvbWFpbk5vdE51bGxDb25zdHJhaW50KE9pZCBkb21haW5vaWQpCiAKIAkJLyog
U2NhbiBhbGwgdHVwbGVzIGluIHRoaXMgcmVsYXRpb24gKi8KIAkJc25hcHNob3QgPSBSZWdpc3Rl
clNuYXBzaG90KEdldExhdGVzdFNuYXBzaG90KCkpOwotCQlzY2FuID0gdGFibGVfYmVnaW5zY2Fu
KHRlc3RyZWwsIHNuYXBzaG90LCAwLCBOVUxMKTsKKwkJc2NhbiA9IHRhYmxlX2JlZ2luc2Nhbih0
ZXN0cmVsLCBzbmFwc2hvdCwgMCwgTlVMTCwgMCk7CiAJCXNsb3QgPSB0YWJsZV9zbG90X2NyZWF0
ZSh0ZXN0cmVsLCBOVUxMKTsKIAkJd2hpbGUgKHRhYmxlX3NjYW5fZ2V0bmV4dHNsb3Qoc2Nhbiwg
Rm9yd2FyZFNjYW5EaXJlY3Rpb24sIHNsb3QpKQogCQl7CkBAIC0zMjYwLDcgKzMyNjAsNyBAQCB2
YWxpZGF0ZURvbWFpbkNoZWNrQ29uc3RyYWludChPaWQgZG9tYWlub2lkLCBjb25zdCBjaGFyICpj
Y2JpbiwgTE9DS01PREUgbG9ja21vZAogCiAJCS8qIFNjYW4gYWxsIHR1cGxlcyBpbiB0aGlzIHJl
bGF0aW9uICovCiAJCXNuYXBzaG90ID0gUmVnaXN0ZXJTbmFwc2hvdChHZXRMYXRlc3RTbmFwc2hv
dCgpKTsKLQkJc2NhbiA9IHRhYmxlX2JlZ2luc2Nhbih0ZXN0cmVsLCBzbmFwc2hvdCwgMCwgTlVM
TCk7CisJCXNjYW4gPSB0YWJsZV9iZWdpbnNjYW4odGVzdHJlbCwgc25hcHNob3QsIDAsIE5VTEws
IDApOwogCQlzbG90ID0gdGFibGVfc2xvdF9jcmVhdGUodGVzdHJlbCwgTlVMTCk7CiAJCXdoaWxl
ICh0YWJsZV9zY2FuX2dldG5leHRzbG90KHNjYW4sIEZvcndhcmRTY2FuRGlyZWN0aW9uLCBzbG90
KSkKIAkJewpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY0luZGV4aW5nLmMg
Yi9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjSW5kZXhpbmcuYwppbmRleCA2YWUwZjk1OTU5Mi4u
NmQzZTlkMmYzMTEgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNJbmRleGlu
Zy5jCisrKyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNJbmRleGluZy5jCkBAIC04MTYsNyAr
ODE2LDcgQEAgY2hlY2tfZXhjbHVzaW9uX29yX3VuaXF1ZV9jb25zdHJhaW50KFJlbGF0aW9uIGhl
YXAsIFJlbGF0aW9uIGluZGV4LAogcmV0cnk6CiAJY29uZmxpY3QgPSBmYWxzZTsKIAlmb3VuZF9z
ZWxmID0gZmFsc2U7Ci0JaW5kZXhfc2NhbiA9IGluZGV4X2JlZ2luc2NhbihoZWFwLCBpbmRleCwg
JkRpcnR5U25hcHNob3QsIE5VTEwsIGluZG5rZXlhdHRzLCAwKTsKKwlpbmRleF9zY2FuID0gaW5k
ZXhfYmVnaW5zY2FuKGhlYXAsIGluZGV4LCAmRGlydHlTbmFwc2hvdCwgTlVMTCwgaW5kbmtleWF0
dHMsIDAsIDApOwogCWluZGV4X3Jlc2NhbihpbmRleF9zY2FuLCBzY2Fua2V5cywgaW5kbmtleWF0
dHMsIE5VTEwsIDApOwogCiAJd2hpbGUgKGluZGV4X2dldG5leHRfc2xvdChpbmRleF9zY2FuLCBG
b3J3YXJkU2NhbkRpcmVjdGlvbiwgZXhpc3Rpbmdfc2xvdCkpCmRpZmYgLS1naXQgYS9zcmMvYmFj
a2VuZC9leGVjdXRvci9leGVjUmVwbGljYXRpb24uYyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4
ZWNSZXBsaWNhdGlvbi5jCmluZGV4IDcyZjJiZmY3NzA4Li40Yzk2NWEzNWUwNSAxMDA2NDQKLS0t
IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1JlcGxpY2F0aW9uLmMKKysrIGIvc3JjL2JhY2tl
bmQvZXhlY3V0b3IvZXhlY1JlcGxpY2F0aW9uLmMKQEAgLTIwNSw3ICsyMDUsNyBAQCBSZWxhdGlv
bkZpbmRSZXBsVHVwbGVCeUluZGV4KFJlbGF0aW9uIHJlbCwgT2lkIGlkeG9pZCwKIAlza2V5X2F0
dG9mZiA9IGJ1aWxkX3JlcGxpbmRleF9zY2FuX2tleShza2V5LCByZWwsIGlkeHJlbCwgc2VhcmNo
c2xvdCk7CiAKIAkvKiBTdGFydCBhbiBpbmRleCBzY2FuLiAqLwotCXNjYW4gPSBpbmRleF9iZWdp
bnNjYW4ocmVsLCBpZHhyZWwsICZzbmFwLCBOVUxMLCBza2V5X2F0dG9mZiwgMCk7CisJc2NhbiA9
IGluZGV4X2JlZ2luc2NhbihyZWwsIGlkeHJlbCwgJnNuYXAsIE5VTEwsIHNrZXlfYXR0b2ZmLCAw
LCAwKTsKIAogcmV0cnk6CiAJZm91bmQgPSBmYWxzZTsKQEAgLTM4Myw3ICszODMsNyBAQCBSZWxh
dGlvbkZpbmRSZXBsVHVwbGVTZXEoUmVsYXRpb24gcmVsLCBMb2NrVHVwbGVNb2RlIGxvY2ttb2Rl
LAogCiAJLyogU3RhcnQgYSBoZWFwIHNjYW4uICovCiAJSW5pdERpcnR5U25hcHNob3Qoc25hcCk7
Ci0Jc2NhbiA9IHRhYmxlX2JlZ2luc2NhbihyZWwsICZzbmFwLCAwLCBOVUxMKTsKKwlzY2FuID0g
dGFibGVfYmVnaW5zY2FuKHJlbCwgJnNuYXAsIDAsIE5VTEwsIDApOwogCXNjYW5zbG90ID0gdGFi
bGVfc2xvdF9jcmVhdGUocmVsLCBOVUxMKTsKIAogcmV0cnk6CkBAIC02MDIsNyArNjAyLDcgQEAg
UmVsYXRpb25GaW5kRGVsZXRlZFR1cGxlSW5mb1NlcShSZWxhdGlvbiByZWwsIFR1cGxlVGFibGVT
bG90ICpzZWFyY2hzbG90LAogCSAqIG5vdCB5ZXQgY29tbWl0dGVkIG9yIHRob3NlIGp1c3QgY29t
bWl0dGVkIHByaW9yIHRvIHRoZSBzY2FuIGFyZQogCSAqIGV4Y2x1ZGVkIGluIHVwZGF0ZV9tb3N0
X3JlY2VudF9kZWxldGlvbl9pbmZvKCkuCiAJICovCi0Jc2NhbiA9IHRhYmxlX2JlZ2luc2Nhbihy
ZWwsIFNuYXBzaG90QW55LCAwLCBOVUxMKTsKKwlzY2FuID0gdGFibGVfYmVnaW5zY2FuKHJlbCwg
U25hcHNob3RBbnksIDAsIE5VTEwsIDApOwogCXNjYW5zbG90ID0gdGFibGVfc2xvdF9jcmVhdGUo
cmVsLCBOVUxMKTsKIAogCXRhYmxlX3Jlc2NhbihzY2FuLCBOVUxMKTsKQEAgLTY2Niw3ICs2NjYs
NyBAQCBSZWxhdGlvbkZpbmREZWxldGVkVHVwbGVJbmZvQnlJbmRleChSZWxhdGlvbiByZWwsIE9p
ZCBpZHhvaWQsCiAJICogbm90IHlldCBjb21taXR0ZWQgb3IgdGhvc2UganVzdCBjb21taXR0ZWQg
cHJpb3IgdG8gdGhlIHNjYW4gYXJlCiAJICogZXhjbHVkZWQgaW4gdXBkYXRlX21vc3RfcmVjZW50
X2RlbGV0aW9uX2luZm8oKS4KIAkgKi8KLQlzY2FuID0gaW5kZXhfYmVnaW5zY2FuKHJlbCwgaWR4
cmVsLCBTbmFwc2hvdEFueSwgTlVMTCwgc2tleV9hdHRvZmYsIDApOworCXNjYW4gPSBpbmRleF9i
ZWdpbnNjYW4ocmVsLCBpZHhyZWwsIFNuYXBzaG90QW55LCBOVUxMLCBza2V5X2F0dG9mZiwgMCwg
MCk7CiAKIAlpbmRleF9yZXNjYW4oc2Nhbiwgc2tleSwgc2tleV9hdHRvZmYsIE5VTEwsIDApOwog
CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlQml0bWFwSGVhcHNjYW4uYyBi
L3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVCaXRtYXBIZWFwc2Nhbi5jCmluZGV4IGM2OGMyNmNi
ZjM4Li4xMDE3Njc2ZmNlMCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUJp
dG1hcEhlYXBzY2FuLmMKKysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUJpdG1hcEhlYXBz
Y2FuLmMKQEAgLTEwMywxMSArMTAzLDE4IEBAIEJpdG1hcFRhYmxlU2NhblNldHVwKEJpdG1hcEhl
YXBTY2FuU3RhdGUgKm5vZGUpCiAJICovCiAJaWYgKCFub2RlLT5zcy5zc19jdXJyZW50U2NhbkRl
c2MpCiAJeworCQl1aW50MzIJCWZsYWdzID0gMDsKKworCQlpZiAoIWJtc19pc19tZW1iZXIoKChT
Y2FuICopIG5vZGUtPnNzLnBzLnBsYW4pLT5zY2FucmVsaWQsCisJCQkJCQkgICBub2RlLT5zcy5w
cy5zdGF0ZS0+ZXNfbW9kaWZpZWRfcmVsaWRzKSkKKwkJCWZsYWdzID0gU09fSElOVF9SRUxfUkVB
RF9PTkxZOworCiAJCW5vZGUtPnNzLnNzX2N1cnJlbnRTY2FuRGVzYyA9CiAJCQl0YWJsZV9iZWdp
bnNjYW5fYm0obm9kZS0+c3Muc3NfY3VycmVudFJlbGF0aW9uLAogCQkJCQkJCSAgIG5vZGUtPnNz
LnBzLnN0YXRlLT5lc19zbmFwc2hvdCwKIAkJCQkJCQkgICAwLAotCQkJCQkJCSAgIE5VTEwpOwor
CQkJCQkJCSAgIE5VTEwsCisJCQkJCQkJICAgZmxhZ3MpOwogCX0KIAogCW5vZGUtPnNzLnNzX2N1
cnJlbnRTY2FuRGVzYy0+c3QucnNfdGJtaXRlcmF0b3IgPSB0Ym1pdGVyYXRvcjsKZGlmZiAtLWdp
dCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVJbmRleG9ubHlzY2FuLmMgYi9zcmMvYmFja2Vu
ZC9leGVjdXRvci9ub2RlSW5kZXhvbmx5c2Nhbi5jCmluZGV4IGMyZDA5Mzc0NTE3Li4yZmU3MjRh
MzIzZiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUluZGV4b25seXNjYW4u
YworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlSW5kZXhvbmx5c2Nhbi5jCkBAIC04NCw2
ICs4NCwxMiBAQCBJbmRleE9ubHlOZXh0KEluZGV4T25seVNjYW5TdGF0ZSAqbm9kZSkKIAogCWlm
IChzY2FuZGVzYyA9PSBOVUxMKQogCXsKKwkJdWludDMyCQlmbGFncyA9IDA7CisKKwkJaWYgKCFi
bXNfaXNfbWVtYmVyKCgoU2NhbiAqKSBub2RlLT5zcy5wcy5wbGFuKS0+c2NhbnJlbGlkLAorCQkJ
CQkJICAgZXN0YXRlLT5lc19tb2RpZmllZF9yZWxpZHMpKQorCQkJZmxhZ3MgPSBTT19ISU5UX1JF
TF9SRUFEX09OTFk7CisKIAkJLyoKIAkJICogV2UgcmVhY2ggaGVyZSBpZiB0aGUgaW5kZXggb25s
eSBzY2FuIGlzIG5vdCBwYXJhbGxlbCwgb3IgaWYgd2UncmUKIAkJICogc2VyaWFsbHkgZXhlY3V0
aW5nIGFuIGluZGV4IG9ubHkgc2NhbiB0aGF0IHdhcyBwbGFubmVkIHRvIGJlCkBAIC05NCw3ICsx
MDAsOCBAQCBJbmRleE9ubHlOZXh0KEluZGV4T25seVNjYW5TdGF0ZSAqbm9kZSkKIAkJCQkJCQkJ
ICAgZXN0YXRlLT5lc19zbmFwc2hvdCwKIAkJCQkJCQkJICAgJm5vZGUtPmlvc3NfSW5zdHJ1bWVu
dCwKIAkJCQkJCQkJICAgbm9kZS0+aW9zc19OdW1TY2FuS2V5cywKLQkJCQkJCQkJICAgbm9kZS0+
aW9zc19OdW1PcmRlckJ5S2V5cyk7CisJCQkJCQkJCSAgIG5vZGUtPmlvc3NfTnVtT3JkZXJCeUtl
eXMsCisJCQkJCQkJCSAgIGZsYWdzKTsKIAogCQlub2RlLT5pb3NzX1NjYW5EZXNjID0gc2NhbmRl
c2M7CiAKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVJbmRleHNjYW4uYyBi
L3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVJbmRleHNjYW4uYwppbmRleCBhNjE2YWJmZjA0Yy4u
ODczMGRhYjc0NjkgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVJbmRleHNj
YW4uYworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlSW5kZXhzY2FuLmMKQEAgLTEwMiw2
ICsxMDIsMTIgQEAgSW5kZXhOZXh0KEluZGV4U2NhblN0YXRlICpub2RlKQogCiAJaWYgKHNjYW5k
ZXNjID09IE5VTEwpCiAJeworCQl1aW50MzIJCWZsYWdzID0gMDsKKworCQlpZiAoIWJtc19pc19t
ZW1iZXIoKChTY2FuICopIG5vZGUtPnNzLnBzLnBsYW4pLT5zY2FucmVsaWQsCisJCQkJCQkgICBl
c3RhdGUtPmVzX21vZGlmaWVkX3JlbGlkcykpCisJCQlmbGFncyA9IFNPX0hJTlRfUkVMX1JFQURf
T05MWTsKKwogCQkvKgogCQkgKiBXZSByZWFjaCBoZXJlIGlmIHRoZSBpbmRleCBzY2FuIGlzIG5v
dCBwYXJhbGxlbCwgb3IgaWYgd2UncmUKIAkJICogc2VyaWFsbHkgZXhlY3V0aW5nIGFuIGluZGV4
IHNjYW4gdGhhdCB3YXMgcGxhbm5lZCB0byBiZSBwYXJhbGxlbC4KQEAgLTExMSw3ICsxMTcsOCBA
QCBJbmRleE5leHQoSW5kZXhTY2FuU3RhdGUgKm5vZGUpCiAJCQkJCQkJCSAgIGVzdGF0ZS0+ZXNf
c25hcHNob3QsCiAJCQkJCQkJCSAgICZub2RlLT5pc3NfSW5zdHJ1bWVudCwKIAkJCQkJCQkJICAg
bm9kZS0+aXNzX051bVNjYW5LZXlzLAotCQkJCQkJCQkgICBub2RlLT5pc3NfTnVtT3JkZXJCeUtl
eXMpOworCQkJCQkJCQkgICBub2RlLT5pc3NfTnVtT3JkZXJCeUtleXMsCisJCQkJCQkJCSAgIGZs
YWdzKTsKIAogCQlub2RlLT5pc3NfU2NhbkRlc2MgPSBzY2FuZGVzYzsKIApAQCAtMTk4LDYgKzIw
NSwxMiBAQCBJbmRleE5leHRXaXRoUmVvcmRlcihJbmRleFNjYW5TdGF0ZSAqbm9kZSkKIAogCWlm
IChzY2FuZGVzYyA9PSBOVUxMKQogCXsKKwkJdWludDMyCQlmbGFncyA9IDA7CisKKwkJaWYgKCFi
bXNfaXNfbWVtYmVyKCgoU2NhbiAqKSBub2RlLT5zcy5wcy5wbGFuKS0+c2NhbnJlbGlkLAorCQkJ
CQkJICAgZXN0YXRlLT5lc19tb2RpZmllZF9yZWxpZHMpKQorCQkJZmxhZ3MgPSBTT19ISU5UX1JF
TF9SRUFEX09OTFk7CisKIAkJLyoKIAkJICogV2UgcmVhY2ggaGVyZSBpZiB0aGUgaW5kZXggc2Nh
biBpcyBub3QgcGFyYWxsZWwsIG9yIGlmIHdlJ3JlCiAJCSAqIHNlcmlhbGx5IGV4ZWN1dGluZyBh
biBpbmRleCBzY2FuIHRoYXQgd2FzIHBsYW5uZWQgdG8gYmUgcGFyYWxsZWwuCkBAIC0yMDcsNyAr
MjIwLDggQEAgSW5kZXhOZXh0V2l0aFJlb3JkZXIoSW5kZXhTY2FuU3RhdGUgKm5vZGUpCiAJCQkJ
CQkJCSAgIGVzdGF0ZS0+ZXNfc25hcHNob3QsCiAJCQkJCQkJCSAgICZub2RlLT5pc3NfSW5zdHJ1
bWVudCwKIAkJCQkJCQkJICAgbm9kZS0+aXNzX051bVNjYW5LZXlzLAotCQkJCQkJCQkgICBub2Rl
LT5pc3NfTnVtT3JkZXJCeUtleXMpOworCQkJCQkJCQkgICBub2RlLT5pc3NfTnVtT3JkZXJCeUtl
eXMsCisJCQkJCQkJCSAgIGZsYWdzKTsKIAogCQlub2RlLT5pc3NfU2NhbkRlc2MgPSBzY2FuZGVz
YzsKIApkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZVNlcXNjYW4uYyBiL3Ny
Yy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVTZXFzY2FuLmMKaW5kZXggYWYzYzc4OGNlOGIuLjMzNjM1
NDkyMmEyIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlU2Vxc2Nhbi5jCisr
KyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVTZXFzY2FuLmMKQEAgLTY1LDEzICs2NSwyMCBA
QCBTZXFOZXh0KFNlcVNjYW5TdGF0ZSAqbm9kZSkKIAogCWlmIChzY2FuZGVzYyA9PSBOVUxMKQog
CXsKKwkJdWludDMyCQlmbGFncyA9IDA7CisKKwkJaWYgKCFibXNfaXNfbWVtYmVyKCgoU2NhbiAq
KSBub2RlLT5zcy5wcy5wbGFuKS0+c2NhbnJlbGlkLAorCQkJCQkJICAgZXN0YXRlLT5lc19tb2Rp
ZmllZF9yZWxpZHMpKQorCQkJZmxhZ3MgPSBTT19ISU5UX1JFTF9SRUFEX09OTFk7CisKIAkJLyoK
IAkJICogV2UgcmVhY2ggaGVyZSBpZiB0aGUgc2NhbiBpcyBub3QgcGFyYWxsZWwsIG9yIGlmIHdl
J3JlIHNlcmlhbGx5CiAJCSAqIGV4ZWN1dGluZyBhIHNjYW4gdGhhdCB3YXMgcGxhbm5lZCB0byBi
ZSBwYXJhbGxlbC4KIAkJICovCiAJCXNjYW5kZXNjID0gdGFibGVfYmVnaW5zY2FuKG5vZGUtPnNz
LnNzX2N1cnJlbnRSZWxhdGlvbiwKIAkJCQkJCQkJICAgZXN0YXRlLT5lc19zbmFwc2hvdCwKLQkJ
CQkJCQkJICAgMCwgTlVMTCk7CisJCQkJCQkJCSAgIDAsIE5VTEwsIGZsYWdzKTsKKwogCQlub2Rl
LT5zcy5zc19jdXJyZW50U2NhbkRlc2MgPSBzY2FuZGVzYzsKIAl9CiAKQEAgLTM2NywxNCArMzc0
LDIwIEBAIEV4ZWNTZXFTY2FuSW5pdGlhbGl6ZURTTShTZXFTY2FuU3RhdGUgKm5vZGUsCiB7CiAJ
RVN0YXRlCSAgICplc3RhdGUgPSBub2RlLT5zcy5wcy5zdGF0ZTsKIAlQYXJhbGxlbFRhYmxlU2Nh
bkRlc2MgcHNjYW47CisJdWludDMyCQlmbGFncyA9IDA7CiAKIAlwc2NhbiA9IHNobV90b2NfYWxs
b2NhdGUocGN4dC0+dG9jLCBub2RlLT5wc2Nhbl9sZW4pOwogCXRhYmxlX3BhcmFsbGVsc2Nhbl9p
bml0aWFsaXplKG5vZGUtPnNzLnNzX2N1cnJlbnRSZWxhdGlvbiwKIAkJCQkJCQkJICBwc2NhbiwK
IAkJCQkJCQkJICBlc3RhdGUtPmVzX3NuYXBzaG90KTsKIAlzaG1fdG9jX2luc2VydChwY3h0LT50
b2MsIG5vZGUtPnNzLnBzLnBsYW4tPnBsYW5fbm9kZV9pZCwgcHNjYW4pOworCWlmICghYm1zX2lz
X21lbWJlcigoKFNjYW4gKikgbm9kZS0+c3MucHMucGxhbiktPnNjYW5yZWxpZCwKKwkJCQkJICAg
ZXN0YXRlLT5lc19tb2RpZmllZF9yZWxpZHMpKQorCQlmbGFncyA9IFNPX0hJTlRfUkVMX1JFQURf
T05MWTsKKwogCW5vZGUtPnNzLnNzX2N1cnJlbnRTY2FuRGVzYyA9Ci0JCXRhYmxlX2JlZ2luc2Nh
bl9wYXJhbGxlbChub2RlLT5zcy5zc19jdXJyZW50UmVsYXRpb24sIHBzY2FuKTsKKwkJdGFibGVf
YmVnaW5zY2FuX3BhcmFsbGVsKG5vZGUtPnNzLnNzX2N1cnJlbnRSZWxhdGlvbiwgcHNjYW4sCisJ
CQkJCQkJCSBmbGFncyk7CiB9CiAKIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KQEAgLTQwNCw4ICs0MTcsMTUgQEAgRXhl
Y1NlcVNjYW5Jbml0aWFsaXplV29ya2VyKFNlcVNjYW5TdGF0ZSAqbm9kZSwKIAkJCQkJCQlQYXJh
bGxlbFdvcmtlckNvbnRleHQgKnB3Y3h0KQogewogCVBhcmFsbGVsVGFibGVTY2FuRGVzYyBwc2Nh
bjsKKwl1aW50MzIJCWZsYWdzID0gMDsKKworCWlmICghYm1zX2lzX21lbWJlcigoKFNjYW4gKikg
bm9kZS0+c3MucHMucGxhbiktPnNjYW5yZWxpZCwKKwkJCQkJICAgbm9kZS0+c3MucHMuc3RhdGUt
PmVzX21vZGlmaWVkX3JlbGlkcykpCisJCWZsYWdzID0gU09fSElOVF9SRUxfUkVBRF9PTkxZOwog
CiAJcHNjYW4gPSBzaG1fdG9jX2xvb2t1cChwd2N4dC0+dG9jLCBub2RlLT5zcy5wcy5wbGFuLT5w
bGFuX25vZGVfaWQsIGZhbHNlKTsKIAlub2RlLT5zcy5zc19jdXJyZW50U2NhbkRlc2MgPQotCQl0
YWJsZV9iZWdpbnNjYW5fcGFyYWxsZWwobm9kZS0+c3Muc3NfY3VycmVudFJlbGF0aW9uLCBwc2Nh
bik7CisJCXRhYmxlX2JlZ2luc2Nhbl9wYXJhbGxlbChub2RlLT5zcy5zc19jdXJyZW50UmVsYXRp
b24sCisJCQkJCQkJCSBwc2NhbiwKKwkJCQkJCQkJIGZsYWdzKTsKIH0KZGlmZiAtLWdpdCBhL3Ny
Yy9iYWNrZW5kL3BhcnRpdGlvbmluZy9wYXJ0Ym91bmRzLmMgYi9zcmMvYmFja2VuZC9wYXJ0aXRp
b25pbmcvcGFydGJvdW5kcy5jCmluZGV4IDBjYTMxMmFjMjdkLi5iN2M0ZTZkMTA3MSAxMDA2NDQK
LS0tIGEvc3JjL2JhY2tlbmQvcGFydGl0aW9uaW5nL3BhcnRib3VuZHMuYworKysgYi9zcmMvYmFj
a2VuZC9wYXJ0aXRpb25pbmcvcGFydGJvdW5kcy5jCkBAIC0zMzYyLDcgKzMzNjIsNyBAQCBjaGVj
a19kZWZhdWx0X3BhcnRpdGlvbl9jb250ZW50cyhSZWxhdGlvbiBwYXJlbnQsIFJlbGF0aW9uIGRl
ZmF1bHRfcmVsLAogCQllY29udGV4dCA9IEdldFBlclR1cGxlRXhwckNvbnRleHQoZXN0YXRlKTsK
IAkJc25hcHNob3QgPSBSZWdpc3RlclNuYXBzaG90KEdldExhdGVzdFNuYXBzaG90KCkpOwogCQl0
dXBzbG90ID0gdGFibGVfc2xvdF9jcmVhdGUocGFydF9yZWwsICZlc3RhdGUtPmVzX3R1cGxlVGFi
bGUpOwotCQlzY2FuID0gdGFibGVfYmVnaW5zY2FuKHBhcnRfcmVsLCBzbmFwc2hvdCwgMCwgTlVM
TCk7CisJCXNjYW4gPSB0YWJsZV9iZWdpbnNjYW4ocGFydF9yZWwsIHNuYXBzaG90LCAwLCBOVUxM
LCAwKTsKIAogCQkvKgogCQkgKiBTd2l0Y2ggdG8gcGVyLXR1cGxlIG1lbW9yeSBjb250ZXh0IGFu
ZCByZXNldCBpdCBmb3IgZWFjaCB0dXBsZQpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvdXRpbHMv
YWR0L3NlbGZ1bmNzLmMgYi9zcmMvYmFja2VuZC91dGlscy9hZHQvc2VsZnVuY3MuYwppbmRleCAy
OWZlYzY1NTU5My4uYWMxODE4NTMyMjUgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxzL2Fk
dC9zZWxmdW5jcy5jCisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9zZWxmdW5jcy5jCkBAIC03
MTgxLDcgKzcxODEsNyBAQCBnZXRfYWN0dWFsX3ZhcmlhYmxlX2VuZHBvaW50KFJlbGF0aW9uIGhl
YXBSZWwsCiAKIAlpbmRleF9zY2FuID0gaW5kZXhfYmVnaW5zY2FuKGhlYXBSZWwsIGluZGV4UmVs
LAogCQkJCQkJCQkgJlNuYXBzaG90Tm9uVmFjdXVtYWJsZSwgTlVMTCwKLQkJCQkJCQkJIDEsIDAp
OworCQkJCQkJCQkgMSwgMCwgMCk7CiAJLyogU2V0IGl0IHVwIGZvciBpbmRleC1vbmx5IHNjYW4g
Ki8KIAlpbmRleF9zY2FuLT54c193YW50X2l0dXAgPSB0cnVlOwogCWluZGV4X3Jlc2NhbihpbmRl
eF9zY2FuLCBzY2Fua2V5cywgMSwgTlVMTCwgMCk7CmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9h
Y2Nlc3MvZ2VuYW0uaCBiL3NyYy9pbmNsdWRlL2FjY2Vzcy9nZW5hbS5oCmluZGV4IDRjMDQyOWNj
NjEzLi4zOTM0ZmE0NDc5MyAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvYWNjZXNzL2dlbmFtLmgK
KysrIGIvc3JjL2luY2x1ZGUvYWNjZXNzL2dlbmFtLmgKQEAgLTE1Niw3ICsxNTYsNyBAQCBleHRl
cm4gSW5kZXhTY2FuRGVzYyBpbmRleF9iZWdpbnNjYW4oUmVsYXRpb24gaGVhcFJlbGF0aW9uLAog
CQkJCQkJCQkJIFJlbGF0aW9uIGluZGV4UmVsYXRpb24sCiAJCQkJCQkJCQkgU25hcHNob3Qgc25h
cHNob3QsCiAJCQkJCQkJCQkgSW5kZXhTY2FuSW5zdHJ1bWVudGF0aW9uICppbnN0cnVtZW50LAot
CQkJCQkJCQkJIGludCBua2V5cywgaW50IG5vcmRlcmJ5cyk7CisJCQkJCQkJCQkgaW50IG5rZXlz
LCBpbnQgbm9yZGVyYnlzLCB1aW50MzIgZmxhZ3MpOwogZXh0ZXJuIEluZGV4U2NhbkRlc2MgaW5k
ZXhfYmVnaW5zY2FuX2JpdG1hcChSZWxhdGlvbiBpbmRleFJlbGF0aW9uLAogCQkJCQkJCQkJCQlT
bmFwc2hvdCBzbmFwc2hvdCwKIAkJCQkJCQkJCQkJSW5kZXhTY2FuSW5zdHJ1bWVudGF0aW9uICpp
bnN0cnVtZW50LApkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvYWNjZXNzL2hlYXBhbS5oIGIvc3Jj
L2luY2x1ZGUvYWNjZXNzL2hlYXBhbS5oCmluZGV4IDA1ZWY4ZDhjZDVlLi42ZDU0NzgxNjA5YSAx
MDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvYWNjZXNzL2hlYXBhbS5oCisrKyBiL3NyYy9pbmNsdWRl
L2FjY2Vzcy9oZWFwYW0uaApAQCAtMTE5LDYgKzExOSwxMiBAQCB0eXBlZGVmIHN0cnVjdCBJbmRl
eEZldGNoSGVhcERhdGEKIAogCUJ1ZmZlcgkJeHNfY2J1ZjsJCS8qIGN1cnJlbnQgaGVhcCBidWZm
ZXIgaW4gc2NhbiwgaWYgYW55ICovCiAJLyogTkI6IGlmIHhzX2NidWYgaXMgbm90IEludmFsaWRC
dWZmZXIsIHdlIGhvbGQgYSBwaW4gb24gdGhhdCBidWZmZXIgKi8KKworCS8qCisJICogU29tZSBv
cHRpbWl6YXRpb25zIGNhbiBvbmx5IGJlIHBlcmZvcm1lZCBpZiB0aGUgcXVlcnkgZG9lcyBub3Qg
bW9kaWZ5CisJICogdGhlIHVuZGVybHlpbmcgcmVsYXRpb24uIFRyYWNrIHRoYXQgaGVyZS4KKwkg
Ki8KKwlib29sCQltb2RpZmllc19iYXNlX3JlbDsKIH0gSW5kZXhGZXRjaEhlYXBEYXRhOwogCiAv
KiBSZXN1bHQgY29kZXMgZm9yIEhlYXBUdXBsZVNhdGlzZmllc1ZhY3V1bSAqLwpkaWZmIC0tZ2l0
IGEvc3JjL2luY2x1ZGUvYWNjZXNzL3RhYmxlYW0uaCBiL3NyYy9pbmNsdWRlL2FjY2Vzcy90YWJs
ZWFtLmgKaW5kZXggYzlmYTlmMjU5Y2QuLmZiMmE1NGIwMTBkIDEwMDY0NAotLS0gYS9zcmMvaW5j
bHVkZS9hY2Nlc3MvdGFibGVhbS5oCisrKyBiL3NyYy9pbmNsdWRlL2FjY2Vzcy90YWJsZWFtLmgK
QEAgLTYzLDYgKzYzLDggQEAgdHlwZWRlZiBlbnVtIFNjYW5PcHRpb25zCiAKIAkvKiB1bnJlZ2lz
dGVyIHNuYXBzaG90IGF0IHNjYW4gZW5kPyAqLwogCVNPX1RFTVBfU05BUFNIT1QgPSAxIDw8IDks
CisJLyogc2V0IGlmIHRoZSBxdWVyeSBkb2Vzbid0IG1vZGlmeSB0aGUgcmVsYXRpb24gKi8KKwlT
T19ISU5UX1JFTF9SRUFEX09OTFkgPSAxIDw8IDEwLAogfQkJCVNjYW5PcHRpb25zOwogCiAvKgpA
QCAtNDIwLDcgKzQyMiw3IEBAIHR5cGVkZWYgc3RydWN0IFRhYmxlQW1Sb3V0aW5lCiAJICoKIAkg
KiBUdXBsZXMgZm9yIGFuIGluZGV4IHNjYW4gY2FuIHRoZW4gYmUgZmV0Y2hlZCB2aWEgaW5kZXhf
ZmV0Y2hfdHVwbGUuCiAJICovCi0Jc3RydWN0IEluZGV4RmV0Y2hUYWJsZURhdGEgKigqaW5kZXhf
ZmV0Y2hfYmVnaW4pIChSZWxhdGlvbiByZWwpOworCXN0cnVjdCBJbmRleEZldGNoVGFibGVEYXRh
ICooKmluZGV4X2ZldGNoX2JlZ2luKSAoUmVsYXRpb24gcmVsLCB1aW50MzIgZmxhZ3MpOwogCiAJ
LyoKIAkgKiBSZXNldCBpbmRleCBmZXRjaC4gVHlwaWNhbGx5IHRoaXMgd2lsbCByZWxlYXNlIGNy
b3NzIGluZGV4IGZldGNoCkBAIC04NzMsOSArODc1LDkgQEAgZXh0ZXJuIFR1cGxlVGFibGVTbG90
ICp0YWJsZV9zbG90X2NyZWF0ZShSZWxhdGlvbiByZWxhdGlvbiwgTGlzdCAqKnJlZ2xpc3QpOwog
ICovCiBzdGF0aWMgaW5saW5lIFRhYmxlU2NhbkRlc2MKIHRhYmxlX2JlZ2luc2NhbihSZWxhdGlv
biByZWwsIFNuYXBzaG90IHNuYXBzaG90LAotCQkJCWludCBua2V5cywgU2NhbktleURhdGEgKmtl
eSkKKwkJCQlpbnQgbmtleXMsIFNjYW5LZXlEYXRhICprZXksIHVpbnQzMiBmbGFncykKIHsKLQl1
aW50MzIJCWZsYWdzID0gU09fVFlQRV9TRVFTQ0FOIHwKKwlmbGFncyB8PSBTT19UWVBFX1NFUVND
QU4gfAogCQlTT19BTExPV19TVFJBVCB8IFNPX0FMTE9XX1NZTkMgfCBTT19BTExPV19QQUdFTU9E
RTsKIAogCXJldHVybiByZWwtPnJkX3RhYmxlYW0tPnNjYW5fYmVnaW4ocmVsLCBzbmFwc2hvdCwg
bmtleXMsIGtleSwgTlVMTCwgZmxhZ3MpOwpAQCAtOTE4LDkgKzkyMCw5IEBAIHRhYmxlX2JlZ2lu
c2Nhbl9zdHJhdChSZWxhdGlvbiByZWwsIFNuYXBzaG90IHNuYXBzaG90LAogICovCiBzdGF0aWMg
aW5saW5lIFRhYmxlU2NhbkRlc2MKIHRhYmxlX2JlZ2luc2Nhbl9ibShSZWxhdGlvbiByZWwsIFNu
YXBzaG90IHNuYXBzaG90LAotCQkJCSAgIGludCBua2V5cywgU2NhbktleURhdGEgKmtleSkKKwkJ
CQkgICBpbnQgbmtleXMsIFNjYW5LZXlEYXRhICprZXksIHVpbnQzMiBmbGFncykKIHsKLQl1aW50
MzIJCWZsYWdzID0gU09fVFlQRV9CSVRNQVBTQ0FOIHwgU09fQUxMT1dfUEFHRU1PREU7CisJZmxh
Z3MgfD0gU09fVFlQRV9CSVRNQVBTQ0FOIHwgU09fQUxMT1dfUEFHRU1PREU7CiAKIAlyZXR1cm4g
cmVsLT5yZF90YWJsZWFtLT5zY2FuX2JlZ2luKHJlbCwgc25hcHNob3QsIG5rZXlzLCBrZXksCiAJ
CQkJCQkJCQkgICBOVUxMLCBmbGFncyk7CkBAIC0xMTI3LDcgKzExMjksOCBAQCBleHRlcm4gdm9p
ZCB0YWJsZV9wYXJhbGxlbHNjYW5faW5pdGlhbGl6ZShSZWxhdGlvbiByZWwsCiAgKiBDYWxsZXIg
bXVzdCBob2xkIGEgc3VpdGFibGUgbG9jayBvbiB0aGUgcmVsYXRpb24uCiAgKi8KIGV4dGVybiBU
YWJsZVNjYW5EZXNjIHRhYmxlX2JlZ2luc2Nhbl9wYXJhbGxlbChSZWxhdGlvbiByZWxhdGlvbiwK
LQkJCQkJCQkJCQkJICBQYXJhbGxlbFRhYmxlU2NhbkRlc2MgcHNjYW4pOworCQkJCQkJCQkJCQkg
IFBhcmFsbGVsVGFibGVTY2FuRGVzYyBwc2NhbiwKKwkJCQkJCQkJCQkJICB1aW50MzIgZmxhZ3Mp
OwogCiAvKgogICogQmVnaW4gYSBwYXJhbGxlbCB0aWQgcmFuZ2Ugc2Nhbi4gYHBzY2FuYCBuZWVk
cyB0byBoYXZlIGJlZW4gaW5pdGlhbGl6ZWQKQEAgLTExNjMsOSArMTE2Niw5IEBAIHRhYmxlX3Bh
cmFsbGVsc2Nhbl9yZWluaXRpYWxpemUoUmVsYXRpb24gcmVsLCBQYXJhbGxlbFRhYmxlU2NhbkRl
c2MgcHNjYW4pCiAgKiBUdXBsZXMgZm9yIGFuIGluZGV4IHNjYW4gY2FuIHRoZW4gYmUgZmV0Y2hl
ZCB2aWEgdGFibGVfaW5kZXhfZmV0Y2hfdHVwbGUoKS4KICAqLwogc3RhdGljIGlubGluZSBJbmRl
eEZldGNoVGFibGVEYXRhICoKLXRhYmxlX2luZGV4X2ZldGNoX2JlZ2luKFJlbGF0aW9uIHJlbCkK
K3RhYmxlX2luZGV4X2ZldGNoX2JlZ2luKFJlbGF0aW9uIHJlbCwgdWludDMyIGZsYWdzKQogewot
CXJldHVybiByZWwtPnJkX3RhYmxlYW0tPmluZGV4X2ZldGNoX2JlZ2luKHJlbCk7CisJcmV0dXJu
IHJlbC0+cmRfdGFibGVhbS0+aW5kZXhfZmV0Y2hfYmVnaW4ocmVsLCBmbGFncyk7CiB9CiAKIC8q
Ci0tIAoyLjQzLjAKCg==
--0000000000000dfe5806497aee85
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v34-0013-Allow-on-access-pruning-to-set-pages-all-visible.patch"
Content-Disposition: attachment; 
	filename="v34-0013-Allow-on-access-pruning-to-set-pages-all-visible.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkyn5sob12>
X-Attachment-Id: f_mkyn5sob12
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==
--0000000000000dfe5806497aee85
Content-Type: text/x-patch; charset="UTF-8"; 
	name="v34-0014-Set-pd_prune_xid-on-insert.patch"
Content-Disposition: attachment; 
	filename="v34-0014-Set-pd_prune_xid-on-insert.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkyn5vxh13>
X-Attachment-Id: f_mkyn5vxh13
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--0000000000000dfe5806497aee85--