MIME-Version: 1.0
References: 
 <CAKWEB6pq7C0Wv1wT9Y1_c_1fn-+cR8pb210Pj3w2FcEOmNGxbQ@mail.gmail.com>
 <CAN55FZ2DT4-k06umn=7NYG+NoM6gnVJVQCCwRrr2qOraO+Jadw@mail.gmail.com>
 <aZikzQP6WPJ5Rq2S@nathan>
 <CAN55FZ3cBN_TncLVWyXAKm-KfewguN1AUjyRhoR6zL_QCxHh7A@mail.gmail.com>
 <CAKWEB6qzsZEQ4Czo9QBFiMXqdXVJknHUJwg6wjRwNzLn4+Jw0g@mail.gmail.com>
 <CAN55FZ2O2Ls==sdpROHqxWRx-PMBZ0riJ6eVKoHj8=vssTavxw@mail.gmail.com>
 <aZ3kYQnF9_u6sUQp@nathan>
 <CAN55FZ3+NYF1TkKyNtpRQuLiaauSYk9G5tA+fpruOA4-14Y_ZA@mail.gmail.com>
 <aaXrGSyq4u2d9qEC@nathan>
 <CAN55FZ2DNaKCK3Kf_kHizb2pAbQvULeDYtzaiz97B_xz7YbrkQ@mail.gmail.com>
 <aa8QlTVEDhG1JU0Z@nathan>
In-Reply-To: <aa8QlTVEDhG1JU0Z@nathan>
From: Nazir Bilal Yavuz <byavuz81@gmail.com>
Date: Tue, 10 Mar 2026 15:35:30 +0300
Message-ID: 
 <CAN55FZ08kqmA+B9pzPDy-QstxAd=cK-RqjbR3cWBjPF_8-FXAw@mail.gmail.com>
Subject: Re: Speed up COPY FROM text/CSV parsing using SIMD
To: Nathan Bossart <nathandbossart@gmail.com>
Cc: Manni Wood <manni.wood@enterprisedb.com>, KAZAR Ayoub <ma_kazar@esi.dz>,
	Neil Conway <neil.conway@gmail.com>, Andrew Dunstan <andrew@dunslane.net>,
	Shinya Kato <shinya11.kato@gmail.com>,
	PostgreSQL-development <pgsql-hackers@postgresql.org>
Content-Type: multipart/mixed; boundary="00000000000007670b064caac2b8"
Archived-At: 
 <https://www.postgresql.org/message-id/CAN55FZ08kqmA%2BB9pzPDy-QstxAd%3DcK-RqjbR3cWBjPF_8-FXAw%40mail.gmail.com>
Precedence: bulk

--00000000000007670b064caac2b8
Content-Type: text/plain; charset="UTF-8"

Hi,

On Mon, 9 Mar 2026 at 21:25, Nathan Bossart <nathandbossart@gmail.com> wrote:
>
> On Wed, Mar 04, 2026 at 06:15:53PM +0300, Nazir Bilal Yavuz wrote:
> > +#ifndef USE_NO_SIMD
> > +static bool CopyReadLineTextSIMDHelper(CopyFromState cstate, bool is_csv,
> > +                                                                        bool *temp_hit_eof, int *temp_input_buf_ptr);
> > +#endif
>
> Should we inline this, too?

I think there is no need to inline this function. In the previous
version, SIMD code was in the main for loop which loops for every
character in the data. This means there was branching for every
character in the data. In the current version, SIMD code is outside of
this loop so there is no branching.


> > +                             /*
> > +                              * Do not disable SIMD when we hit EOL or EOF characters. In
> > +                              * practice, it does not matter for EOF because parsing ends
> > +                              * there, but we keep the behavior consistent.
> > +                              */
> > +                             if (!(simd_hit_eof || simd_hit_eol))
> > +                                     cstate->simd_enabled = false;
>
> nitpick: I would personally avoid disabling it for EOF.  It probably
> doesn't amount to much, but I don't see any point in the extra
> complexity/work solely for consistency.

Done. I thought that was a small change but this removed more
complexity than I thought.


>
> > +                             /*
> > +                              * We encountered a EOL or EOF on the first vector. This means
> > +                              * lines are not long enough to skip fully sized vector. If
> > +                              * this happens two times consecutively, then disable the
> > +                              * SIMD.
> > +                              */
> > +                             if (first_vector)
> > +                             {
> > +                                     if (cstate->simd_failed_first_vector)
> > +                                             cstate->simd_enabled = false;
> > +
> > +                                     cstate->simd_failed_first_vector = true;
> > +                             }
>
> The first time I saw this, my mind immediately went to the extreme case
> where this likely regresses: alternating long and short lines.  We might
> just want to disable it the first time we see a short line, like we do for
> special characters.  This is another thing that we can improve
> independently later on.

I agree with you, done.


>
> > +     /* First try to run SIMD, then continue with the scalar path */
> > +     if (cstate->simd_enabled)
> > +     {
> > +             int                     temp_input_buf_ptr = input_buf_ptr;
> > +             bool            temp_hit_eof = false;
> > +
> > +             result = CopyReadLineTextSIMDHelper(cstate, is_csv, &temp_hit_eof,
> > +                                                                                     &temp_input_buf_ptr);
> > +             input_buf_ptr = temp_input_buf_ptr;
> > +             hit_eof = temp_hit_eof;
>
> Given CopyReadLineTextSIMDHelper() doesn't have too much duplicated code,
> moving the SIMD stuff to its own function is nice.  The temp variables seem
> a bit too magical to me, though.  If those really make a difference, IMHO
> there ought to be a big comment explaining why.

I added a comment, please let me know if you wouldn't like it.


--
Regards,
Nazir Bilal Yavuz
Microsoft

--00000000000007670b064caac2b8
Content-Type: text/x-patch; charset="US-ASCII";
	name="v12-0001-Speed-up-COPY-FROM-text-CSV-parsing-using-SIMD.patch"
Content-Disposition: attachment;
	filename="v12-0001-Speed-up-COPY-FROM-text-CSV-parsing-using-SIMD.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmkle9h40>
X-Attachment-Id: f_mmkle9h40

RnJvbSBkZTY5NWFhZjVjN2NlZWI0ZjYyZDIzNTJmYWJiYjExMTA0N2E0NDM0IE1vbiBTZXAgMTcg
MDA6MDA6MDAgMjAwMQpGcm9tOiBOYXppciBCaWxhbCBZYXZ1eiA8YnlhdnV6ODFAZ21haWwuY29t
PgpEYXRlOiBXZWQsIDQgTWFyIDIwMjYgMTc6Mjg6NTQgKzAzMDAKU3ViamVjdDogW1BBVENIIHYx
Ml0gU3BlZWQgdXAgQ09QWSBGUk9NIHRleHQvQ1NWIHBhcnNpbmcgdXNpbmcgU0lNRAoKQ09QWSBG
Uk9NIHRleHQgYW5kIENTViBwYXJzaW5nIHByZXZpb3VzbHkgc2Nhbm5lZCB0aGUgaW5wdXQgYnVm
ZmVyCm9uZSBieXRlIGF0IGEgdGltZSBsb29raW5nIGZvciBzcGVjaWFsIGNoYXJhY3RlcnMgKG5l
d2xpbmUsIGNhcnJpYWdlCnJldHVybiwgYmFja3NsYXNoLCBhbmQgaW4gQ1NWIG1vZGUsIHF1b3Rl
IGFuZCBlc2NhcGUgY2hhcmFjdGVycykuClRoaXMgcGF0Y2ggYWRkcyBhIFNJTUQtYWNjZWxlcmF0
ZWQgZmFzdCBwYXRoIHRoYXQgcHJvY2Vzc2VzIGEgZnVsbAp2ZWN0b3Itd2lkdGggY2h1bmsgcGVy
IGl0ZXJhdGlvbiwgc2lnbmlmaWNhbnRseSByZWR1Y2luZyB0aGUgbnVtYmVyCm9mIGl0ZXJhdGlv
bnMgbmVlZGVkIG9uIGlucHV0cyB3aXRoIGxvbmcgbGluZXMuCgpBIG5ldyBoZWxwZXIgZnVuY3Rp
b24sIENvcHlSZWFkTGluZVRleHRTSU1ESGVscGVyKCksIGxvYWRzIGNodW5rcwpvZiB0aGUgaW5w
dXQgYnVmZmVyIGludG8gdmVjdG9yIHJlZ2lzdGVycyBhbmQgY2hlY2tzIGZvciBhbnkgc3BlY2lh
bApjaGFyYWN0ZXJzIHVzaW5nIFNJTUQgY29tcGFyaXNvbnMuIFdoZW4gbm8gc3BlY2lhbCBjaGFy
YWN0ZXJzIGFyZQpmb3VuZCwgdGhlIGVudGlyZSBjaHVuayBpcyBza2lwcGVkIGF0IG9uY2UuIFdo
ZW4gYSBzcGVjaWFsIGNoYXJhY3RlcgppcyBmb3VuZCwgdGhlIGhlbHBlciBhZHZhbmNlcyB0byB0
aGF0IHBvc2l0aW9uIGFuZCBoYW5kcyBvZmYgdG8gdGhlCmV4aXN0aW5nIHNjYWxhciBjb2RlIHRv
IGhhbmRsZSBpdCBjb3JyZWN0bHkuCgpUbyBhdm9pZCBhIHJlZ3Jlc3Npb24gb24gaW5wdXRzIHRo
YXQgY29udGFpbiBtYW55IHNwZWNpYWwgY2hhcmFjdGVycywKU0lNRCBpcyBkaXNhYmxlZCBmb3Ig
dGhlIHJlbWFpbmRlciBvZiB0aGUgY3VycmVudCBpbnB1dCBvbmNlIGEKbm9uLUVPTCBzcGVjaWFs
IGNoYXJhY3RlciBpcyBlbmNvdW50ZXJlZC4gU0lNRCBpcyBhbHNvIGRpc2FibGVkIHdoZW4KdGhl
IHByb2Nlc3NlZCBsaW5lIGlzIHNob3J0ZXIgdGhhbiBhIGZ1bGwgdmVjdG9yLCBzaW5jZSBTSU1E
IGNhbid0CnByb3ZpZGUgYSBiZW5lZml0IHRoZXJlLgoKQXV0aG9yOiBTaGlueWEgS2F0byA8c2hp
bnlhMTEua2F0b0BnbWFpbC5jb20+CkF1dGhvcjogTmF6aXIgQmlsYWwgWWF2dXogPGJ5YXZ1ejgx
QGdtYWlsLmNvbT4KUmV2aWV3ZWQtYnk6IEthemFyIEF5b3ViIDxtYV9rYXphckBlc2kuZHo+ClJl
dmlld2VkLWJ5OiBOYXRoYW4gQm9zc2FydCA8bmF0aGFuZGJvc3NhcnRAZ21haWwuY29tPgpSZXZp
ZXdlZC1ieTogTmVpbCBDb253YXkgPG5laWwuY29ud2F5QGdtYWlsLmNvbT4KUmV2aWV3ZWQtYnk6
IEFuZHJldyBEdW5zdGFuIDxhbmRyZXdAZHVuc2xhbmUubmV0PgpSZXZpZXdlZC1ieTogTWFubmkg
V29vZCA8bWFubmkud29vZEBlbnRlcnByaXNlZGIuY29tPgpSZXZpZXdlZC1ieTogTWFyayBXb25n
IDxtYXJrd2ttQGdtYWlsLmNvbT4KRGlzY3Vzc2lvbjogaHR0cHM6Ly9wb3N0Z3IuZXMvbS9DQU96
RXVyU1c4Y05yNlRQS3NqcnN0blBmaGY0UXlRcUI0dG5QWEdHZThONGVfdjdKaWclNDBtYWlsLmdt
YWlsLmNvbQotLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL2NvcHlmcm9tLmMgICAgICAgICAgfCAg
IDMgKwogc3JjL2JhY2tlbmQvY29tbWFuZHMvY29weWZyb21wYXJzZS5jICAgICB8IDIwNiArKysr
KysrKysrKysrKysrKysrKysrLQogc3JjL2luY2x1ZGUvY29tbWFuZHMvY29weWZyb21faW50ZXJu
YWwuaCB8ICAgMyArCiAzIGZpbGVzIGNoYW5nZWQsIDIwNSBpbnNlcnRpb25zKCspLCA3IGRlbGV0
aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2NvcHlmcm9tLmMgYi9z
cmMvYmFja2VuZC9jb21tYW5kcy9jb3B5ZnJvbS5jCmluZGV4IDJmNDJmNTVlMjI5Li5mZTE4YmQ3
MDg5MCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvY29weWZyb20uYworKysgYi9z
cmMvYmFja2VuZC9jb21tYW5kcy9jb3B5ZnJvbS5jCkBAIC0xNzQ3LDYgKzE3NDcsOSBAQCBCZWdp
bkNvcHlGcm9tKFBhcnNlU3RhdGUgKnBzdGF0ZSwKIAljc3RhdGUtPmN1cl9hdHR2YWwgPSBOVUxM
OwogCWNzdGF0ZS0+cmVsbmFtZV9vbmx5ID0gZmFsc2U7CiAKKwkvKiBJbml0aWFsaXplIFNJTUQg
Ki8KKwljc3RhdGUtPnNpbWRfZW5hYmxlZCA9IHRydWU7CisKIAkvKgogCSAqIEFsbG9jYXRlIGJ1
ZmZlcnMgZm9yIHRoZSBpbnB1dCBwaXBlbGluZS4KIAkgKgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tl
bmQvY29tbWFuZHMvY29weWZyb21wYXJzZS5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvY29weWZy
b21wYXJzZS5jCmluZGV4IDg0Yzg4MDlhODg5Li4xNjZiMWM0YzQxNSAxMDA2NDQKLS0tIGEvc3Jj
L2JhY2tlbmQvY29tbWFuZHMvY29weWZyb21wYXJzZS5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1h
bmRzL2NvcHlmcm9tcGFyc2UuYwpAQCAtNzIsNiArNzIsNyBAQAogI2luY2x1ZGUgIm1pc2NhZG1p
bi5oIgogI2luY2x1ZGUgInBnc3RhdC5oIgogI2luY2x1ZGUgInBvcnQvcGdfYnN3YXAuaCIKKyNp
bmNsdWRlICJwb3J0L3NpbWQuaCIKICNpbmNsdWRlICJ1dGlscy9idWlsdGlucy5oIgogI2luY2x1
ZGUgInV0aWxzL3JlbC5oIgogI2luY2x1ZGUgInV0aWxzL3dhaXRfZXZlbnQuaCIKQEAgLTE1OSw2
ICsxNjAsMTIgQEAgc3RhdGljIHBnX2F0dHJpYnV0ZV9hbHdheXNfaW5saW5lIGJvb2wgTmV4dENv
cHlGcm9tUmF3RmllbGRzSW50ZXJuYWwoQ29weUZyb21TdGEKIAkJCQkJCQkJCQkJCQkJCQkJIGlu
dCAqbmZpZWxkcywKIAkJCQkJCQkJCQkJCQkJCQkJIGJvb2wgaXNfY3N2KTsKIAorLyogU0lNRCBm
dW5jdGlvbnMgKi8KKyNpZm5kZWYgVVNFX05PX1NJTUQKK3N0YXRpYyBib29sIENvcHlSZWFkTGlu
ZVRleHRTSU1ESGVscGVyKENvcHlGcm9tU3RhdGUgY3N0YXRlLCBib29sIGlzX2NzdiwKKwkJCQkJ
CQkJCSAgIGJvb2wgKnRlbXBfaGl0X2VvZiwgaW50ICp0ZW1wX2lucHV0X2J1Zl9wdHIpOworI2Vu
ZGlmCisKIAogLyogTG93LWxldmVsIGNvbW11bmljYXRpb25zIGZ1bmN0aW9ucyAqLwogc3RhdGlj
IGludAlDb3B5R2V0RGF0YShDb3B5RnJvbVN0YXRlIGNzdGF0ZSwgdm9pZCAqZGF0YWJ1ZiwKQEAg
LTEzMTEsNiArMTMxOCwxNTUgQEAgQ29weVJlYWRMaW5lKENvcHlGcm9tU3RhdGUgY3N0YXRlLCBi
b29sIGlzX2NzdikKIAlyZXR1cm4gcmVzdWx0OwogfQogCisjaWZuZGVmIFVTRV9OT19TSU1ECisv
KgorICogVXNlIFNJTUQgaW5zdHJ1Y3Rpb25zIHRvIGVmZmljaWVudGx5IHNjYW4gdGhlIGlucHV0
IGJ1ZmZlciBmb3Igc3BlY2lhbAorICogY2hhcmFjdGVycyAoZS5nLiwgbmV3bGluZSwgY2Fycmlh
Z2UgcmV0dXJuLCBxdW90ZSwgYW5kIGVzY2FwZSkuIFRoaXMgaXMKKyAqIGZhc3RlciB0aGFuIGJ5
dGUtYnktYnl0ZSBpdGVyYXRpb24sIGVzcGVjaWFsbHkgb24gbGFyZ2UgYnVmZmVycy4KKyAqCisg
KiBOb3RlIHRoYXQsIFNJTUQgbWF5IGJlY29tZSBzbG93ZXIgd2hlbiB0aGUgaW5wdXQgY29udGFp
bnMgbWFueSBzcGVjaWFsCisgKiBjaGFyYWN0ZXJzLiBUbyBhdm9pZCB0aGlzIHJlZ3Jlc3Npb24s
IHdlIGRpc2FibGUgU0lNRCBmb3IgdGhlIHJlc3Qgb2YgdGhlCisgKiBpbnB1dCBvbmNlIHdlIGVu
Y291bnRlciBhIHNwZWNpYWwgY2hhcmFjdGVyIHdoaWNoIGlzbid0IEVPTC4KKyAqIEFsc28sIFNJ
TUQgaXMgZGlzYWJsZWQgd2hlbiBpdCBlbmNvdW50ZXJzIGEgc2hvcnQgbGluZSB0aGF0IFNJTUQg
Y2FuJ3QKKyAqIGNyZWF0ZSBhIGZ1bGwgc2l6ZWQgVmVjdG9yLCB0b28uCisgKi8KK3N0YXRpYyBi
b29sCitDb3B5UmVhZExpbmVUZXh0U0lNREhlbHBlcihDb3B5RnJvbVN0YXRlIGNzdGF0ZSwgYm9v
bCBpc19jc3YsIGJvb2wgKnRlbXBfaGl0X2VvZiwgaW50ICp0ZW1wX2lucHV0X2J1Zl9wdHIpCit7
CisJY2hhcgkJcXVvdGVjID0gJ1wwJzsKKwljaGFyCQllc2NhcGVjID0gJ1wwJzsKKwljaGFyCSAg
ICpjb3B5X2lucHV0X2J1ZjsKKwlpbnQJCQlpbnB1dF9idWZfcHRyOworCWludAkJCWNvcHlfYnVm
X2xlbjsKKwlib29sCQlyZXN1bHQgPSBmYWxzZTsKKwlib29sCQl1bmlxdWVfZXNjYXBlYyA9IGZh
bHNlOworCWJvb2wJCWZpcnN0X3ZlY3RvciA9IHRydWU7CisJVmVjdG9yOAkJbmwgPSB2ZWN0b3I4
X2Jyb2FkY2FzdCgnXG4nKTsKKwlWZWN0b3I4CQljciA9IHZlY3RvcjhfYnJvYWRjYXN0KCdccicp
OworCVZlY3RvcjgJCWJzID0gdmVjdG9yOF9icm9hZGNhc3QoJ1xcJyk7CisJVmVjdG9yOAkJcXVv
dGUgPSB2ZWN0b3I4X2Jyb2FkY2FzdCgwKTsKKwlWZWN0b3I4CQllc2NhcGUgPSB2ZWN0b3I4X2Jy
b2FkY2FzdCgwKTsKKworCWlmIChpc19jc3YpCisJeworCQlxdW90ZWMgPSBjc3RhdGUtPm9wdHMu
cXVvdGVbMF07CisJCWVzY2FwZWMgPSBjc3RhdGUtPm9wdHMuZXNjYXBlWzBdOworCisJCXF1b3Rl
ID0gdmVjdG9yOF9icm9hZGNhc3QocXVvdGVjKTsKKwkJaWYgKHF1b3RlYyAhPSBlc2NhcGVjKQor
CQl7CisJCQl1bmlxdWVfZXNjYXBlYyA9IHRydWU7CisJCQllc2NhcGUgPSB2ZWN0b3I4X2Jyb2Fk
Y2FzdChlc2NhcGVjKTsKKwkJfQorCX0KKworCS8qIEZvciBhIGxpdHRsZSBleHRyYSBzcGVlZCB3
ZSBjb3B5IHRoZXNlIGludG8gbG9jYWwgdmFyaWFibGVzICovCisJY29weV9pbnB1dF9idWYgPSBj
c3RhdGUtPmlucHV0X2J1ZjsKKwlpbnB1dF9idWZfcHRyID0gY3N0YXRlLT5pbnB1dF9idWZfaW5k
ZXg7CisJY29weV9idWZfbGVuID0gY3N0YXRlLT5pbnB1dF9idWZfbGVuOworCisJd2hpbGUgKHRy
dWUpCisJeworCQkvKiBMb2FkIG1vcmUgZGF0YSBpZiBuZWVkZWQgKi8KKwkJaWYgKHNpemVvZihW
ZWN0b3I4KSA+IGNvcHlfYnVmX2xlbiAtIGlucHV0X2J1Zl9wdHIpCisJCXsKKwkJCVJFRklMTF9M
SU5FQlVGOworCisJCQlDb3B5TG9hZElucHV0QnVmKGNzdGF0ZSk7CisJCQkvKiB1cGRhdGUgb3Vy
IGxvY2FsIHZhcmlhYmxlcyAqLworCQkJKnRlbXBfaGl0X2VvZiA9IGNzdGF0ZS0+aW5wdXRfcmVh
Y2hlZF9lb2Y7CisJCQlpbnB1dF9idWZfcHRyID0gY3N0YXRlLT5pbnB1dF9idWZfaW5kZXg7CisJ
CQljb3B5X2J1Zl9sZW4gPSBjc3RhdGUtPmlucHV0X2J1Zl9sZW47CisKKwkJCS8qCisJCQkgKiBJ
ZiB3ZSBhcmUgY29tcGxldGVseSBvdXQgb2YgZGF0YSwgYnJlYWsgb3V0IG9mIHRoZSBsb29wLAor
CQkJICogcmVwb3J0aW5nIEVPRi4KKwkJCSAqLworCQkJaWYgKElOUFVUX0JVRl9CWVRFUyhjc3Rh
dGUpIDw9IDApCisJCQl7CisJCQkJcmVzdWx0ID0gdHJ1ZTsKKwkJCQlicmVhazsKKwkJCX0KKwkJ
fQorCisJCWlmIChjb3B5X2J1Zl9sZW4gLSBpbnB1dF9idWZfcHRyID49IHNpemVvZihWZWN0b3I4
KSkKKwkJeworCQkJVmVjdG9yOAkJY2h1bms7CisJCQlWZWN0b3I4CQltYXRjaCA9IHZlY3Rvcjhf
YnJvYWRjYXN0KDApOworCisJCQkvKiBMb2FkIGEgY2h1bmsgb2YgZGF0YSBpbnRvIGEgdmVjdG9y
IHJlZ2lzdGVyICovCisJCQl2ZWN0b3I4X2xvYWQoJmNodW5rLCAoY29uc3QgdWludDggKikgJmNv
cHlfaW5wdXRfYnVmW2lucHV0X2J1Zl9wdHJdKTsKKworCQkJaWYgKGlzX2NzdikKKwkJCXsKKwkJ
CQltYXRjaCA9IHZlY3Rvcjhfb3IodmVjdG9yOF9lcShjaHVuaywgbmwpLCB2ZWN0b3I4X2VxKGNo
dW5rLCBjcikpOworCQkJCW1hdGNoID0gdmVjdG9yOF9vcihtYXRjaCwgdmVjdG9yOF9lcShjaHVu
aywgcXVvdGUpKTsKKwkJCQlpZiAodW5pcXVlX2VzY2FwZWMpCisJCQkJCW1hdGNoID0gdmVjdG9y
OF9vcihtYXRjaCwgdmVjdG9yOF9lcShjaHVuaywgZXNjYXBlKSk7CisJCQl9CisJCQllbHNlCisJ
CQl7CisJCQkJbWF0Y2ggPSB2ZWN0b3I4X29yKHZlY3RvcjhfZXEoY2h1bmssIG5sKSwgdmVjdG9y
OF9lcShjaHVuaywgY3IpKTsKKwkJCQltYXRjaCA9IHZlY3Rvcjhfb3IobWF0Y2gsIHZlY3Rvcjhf
ZXEoY2h1bmssIGJzKSk7CisJCQl9CisKKwkJCS8qIENoZWNrIGlmIHdlIGZvdW5kIGFueSBzcGVj
aWFsIGNoYXJhY3RlcnMgKi8KKwkJCWlmICh2ZWN0b3I4X2lzX2hpZ2hiaXRfc2V0KG1hdGNoKSkK
KwkJCXsKKwkJCQkvKgorCQkJCSAqIEZvdW5kIGEgc3BlY2lhbCBjaGFyYWN0ZXIuIEFkdmFuY2Ug
dXAgdG8gdGhhdCBwb2ludCBhbmQgbGV0CisJCQkJICogdGhlIHNjYWxhciBjb2RlIGhhbmRsZSBp
dC4KKwkJCQkgKi8KKwkJCQl1aW50MzIJCW1hc2s7CisJCQkJaW50CQkJYWR2YW5jZTsKKwkJCQlj
aGFyCQljOworCisJCQkJbWFzayA9IHZlY3RvcjhfaGlnaGJpdF9tYXNrKG1hdGNoKTsKKwkJCQlh
ZHZhbmNlID0gcGdfcmlnaHRtb3N0X29uZV9wb3MzMihtYXNrKTsKKworCQkJCWlucHV0X2J1Zl9w
dHIgKz0gYWR2YW5jZTsKKwkJCQljID0gY29weV9pbnB1dF9idWZbaW5wdXRfYnVmX3B0cl07CisK
KwkJCQkvKgorCQkJCSAqIFdlIGVuY291bnRlcmVkIGEgc3BlY2lhbCBjaGFyYWN0ZXIgaW4gdGhl
IGZpcnN0IHZlY3Rvci4KKwkJCQkgKiBUaGlzIG1lYW5zIGxpbmUgaXMgbm90IGxvbmcgZW5vdWdo
IHRvIHNraXAgZnVsbHkgc2l6ZWQKKwkJCQkgKiB2ZWN0b3IuIFRvIGJlIGNhdXRpb3MsIGRpc2Fi
bGUgU0lNRCBmb3IgdGhlIHJlc3QuCisJCQkJICoKKwkJCQkgKiBPdGhlcndpc2UsIGRvIG5vdCBk
aXNhYmxlIFNJTUQgd2hlbiB3ZSBoaXQgRU9MIGNoYXJhY3RlcnMuCisJCQkJICogV2UgZG9uJ3Qg
Y2hlY2sgZm9yIEVPRiBiZWNhdXNlIHBhcnNpbmcgZW5kcyB0aGVyZS4KKwkJCQkgKi8KKwkJCQlp
ZiAoZmlyc3RfdmVjdG9yIHx8ICEoYyA9PSAnXHInIHx8IGMgPT0gJ1xuJykpCisJCQkJCWNzdGF0
ZS0+c2ltZF9lbmFibGVkID0gZmFsc2U7CisKKwkJCQlicmVhazsKKwkJCX0KKwkJCWVsc2UKKwkJ
CXsKKwkJCQkvKiBObyBzcGVjaWFsIGNoYXJhY3RlcnMgZm91bmQsIHNvIHNraXAgdGhlIGVudGly
ZSBjaHVuayAqLworCQkJCWlucHV0X2J1Zl9wdHIgKz0gc2l6ZW9mKFZlY3RvcjgpOworCQkJCWZp
cnN0X3ZlY3RvciA9IGZhbHNlOworCQkJfQorCQl9CisKKwkJLyoKKwkJICogQWx0aG91Z2ggd2Ug
cmVmaWxsIGxpbmVidWYsIHRoZXJlIGlzIG5vdCBlbm91Z2ggY2hhcmFjdGVyIHRvIGZpbGwKKwkJ
ICogZnVsbCBzaXplZCB2ZWN0b3IuIFRoaXMgZG9lc24ndCBtZWFuIHRoYXQgd2UgZW5jb3VudGVy
ZWQgYSBsaW5lCisJCSAqIHRoYXQgaXMgbm90IGVub3VnaCB0byBmaWxsIGEgZnVsbCBzaXplZCB2
ZWN0b3IuCisJCSAqCisJCSAqIFNjYWxhciBjb2RlIHdpbGwgaGFuZGxlIHRoZSByZXN0IGZvciB0
aGlzIGxpbmUuIFRoZW4sIFNJTUQgd2lsbAorCQkgKiBjb250aW51ZSBmcm9tIHRoZSBuZXh0IGxp
bmUuCisJCSAqLworCQllbHNlCisJCXsKKwkJCWJyZWFrOworCQl9CisJfQorCisJKnRlbXBfaW5w
dXRfYnVmX3B0ciA9IGlucHV0X2J1Zl9wdHI7CisJcmV0dXJuIHJlc3VsdDsKK30KKyNlbmRpZgor
CiAvKgogICogQ29weVJlYWRMaW5lVGV4dCAtIGlubmVyIGxvb3Agb2YgQ29weVJlYWRMaW5lIGZv
ciB0ZXh0IG1vZGUKICAqLwpAQCAtMTMzOSw2ICsxNDk1LDQ5IEBAIENvcHlSZWFkTGluZVRleHQo
Q29weUZyb21TdGF0ZSBjc3RhdGUsIGJvb2wgaXNfY3N2KQogCQkJZXNjYXBlYyA9ICdcMCc7CiAJ
fQogCisJLyoKKwkgKiBpbnB1dF9idWZfcHRyIG1pZ2h0IGJlIHVwZGF0ZWQgaW4gdGhlIFNJTUQg
SGVscGVyIGZ1bmN0aW9uLCBzbyBpdCBuZWVkcworCSAqIHRvIGJlIHNldCBiZWZvcmUgY2FsbGlu
ZyBDb3B5UmVhZExpbmVUZXh0U0lNREhlbHBlcigpLgorCSAqLworCWlucHV0X2J1Zl9wdHIgPSBj
c3RhdGUtPmlucHV0X2J1Zl9pbmRleDsKKworI2lmbmRlZiBVU0VfTk9fU0lNRAorCS8qIEZpcnN0
IHRyeSB0byBydW4gU0lNRCwgdGhlbiBjb250aW51ZSB3aXRoIHRoZSBzY2FsYXIgcGF0aCAqLwor
CWlmIChjc3RhdGUtPnNpbWRfZW5hYmxlZCkKKwl7CisJCS8qCisJCSAqIFRlbXBvcmFyeSB2YXJp
YWJsZXMgYXJlIHVzZWQgaGVyZSBpbnN0ZWFkIG9mIHBhc3NpbmcgdGhlIGFjdHVhbAorCQkgKiB2
YXJpYWJsZXMgKGVzcGVjaWFsbHkgaW5wdXRfYnVmX3B0cikgZGlyZWN0bHkgdG8gdGhlIGhlbHBl
ci4gVGFraW5nCisJCSAqIHRoZSBhZGRyZXNzIG9mIGEgbG9jYWwgdmFyaWFibGUgbWlnaHQgZm9y
Y2UgdGhlIGNvbXBpbGVyIHRvCisJCSAqIGFsbG9jYXRlIGl0IG9uIHRoZSBzdGFjayByYXRoZXIg
dGhhbiBpbiBhIHJlZ2lzdGVyLiAgQmVjYXVzZQorCQkgKiBpbnB1dF9idWZfcHRyIGlzIHVzZWQg
aGVhdmlseSBpbiB0aGUgaG90IHNjYWxhciBwYXRoIGJlbG93LCBrZWVwaW5nCisJCSAqIGl0IGlu
IGEgcmVnaXN0ZXIgaXMgaW1wb3J0YW50IGZvciBwZXJmb3JtYW5jZS4KKwkJICovCisJCWludAkJ
CXRlbXBfaW5wdXRfYnVmX3B0cjsKKwkJYm9vbAkJdGVtcF9oaXRfZW9mID0gaGl0X2VvZjsKKwor
CQlyZXN1bHQgPSBDb3B5UmVhZExpbmVUZXh0U0lNREhlbHBlcihjc3RhdGUsIGlzX2NzdiwgJnRl
bXBfaGl0X2VvZiwKKwkJCQkJCQkJCQkJJnRlbXBfaW5wdXRfYnVmX3B0cik7CisJCWlucHV0X2J1
Zl9wdHIgPSB0ZW1wX2lucHV0X2J1Zl9wdHI7CisJCWhpdF9lb2YgPSB0ZW1wX2hpdF9lb2Y7CisK
KwkJLyogU2hvcnQgZXhpdCBmcm9tIFNJTUQgKi8KKwkJaWYgKHJlc3VsdCkKKwkJeworCQkJLyoK
KwkJCSAqIFRyYW5zZmVyIGFueSBzdGlsbC11bmNvcGllZCBkYXRhIHRvIGxpbmVfYnVmLgorCQkJ
ICovCisJCQlSRUZJTExfTElORUJVRjsKKworCQkJcmV0dXJuIHJlc3VsdDsKKwkJfQorCX0KKyNl
bmRpZgorCisJLyogRm9yIGEgbGl0dGxlIGV4dHJhIHNwZWVkIHdlIGNvcHkgdGhlc2UgaW50byBs
b2NhbCB2YXJpYWJsZXMgKi8KKwljb3B5X2lucHV0X2J1ZiA9IGNzdGF0ZS0+aW5wdXRfYnVmOwor
CWNvcHlfYnVmX2xlbiA9IGNzdGF0ZS0+aW5wdXRfYnVmX2xlbjsKKwogCS8qCiAJICogVGhlIG9i
amVjdGl2ZSBvZiB0aGlzIGxvb3AgaXMgdG8gdHJhbnNmZXIgdGhlIGVudGlyZSBuZXh0IGlucHV0
IGxpbmUKIAkgKiBpbnRvIGxpbmVfYnVmLiAgSGVuY2UsIHdlIG9ubHkgY2FyZSBmb3IgZGV0ZWN0
aW5nIG5ld2xpbmVzIChcciBhbmQvb3IKQEAgLTEzNjAsMTQgKzE1NTksNyBAQCBDb3B5UmVhZExp
bmVUZXh0KENvcHlGcm9tU3RhdGUgY3N0YXRlLCBib29sIGlzX2NzdikKIAkgKiBjaGFyYWN0ZXIg
dG8gZXhhbWluZTsgYW55IGNoYXJhY3RlcnMgZnJvbSBpbnB1dF9idWZfaW5kZXggdG8KIAkgKiBp
bnB1dF9idWZfcHRyIGhhdmUgYmVlbiBkZXRlcm1pbmVkIHRvIGJlIHBhcnQgb2YgdGhlIGxpbmUs
IGJ1dCBub3QgeWV0CiAJICogdHJhbnNmZXJyZWQgdG8gbGluZV9idWYuCi0JICoKLQkgKiBGb3Ig
YSBsaXR0bGUgZXh0cmEgc3BlZWQgd2l0aGluIHRoZSBsb29wLCB3ZSBjb3B5IGlucHV0X2J1ZiBh
bmQKLQkgKiBpbnB1dF9idWZfbGVuIGludG8gbG9jYWwgdmFyaWFibGVzLgogCSAqLwotCWNvcHlf
aW5wdXRfYnVmID0gY3N0YXRlLT5pbnB1dF9idWY7Ci0JaW5wdXRfYnVmX3B0ciA9IGNzdGF0ZS0+
aW5wdXRfYnVmX2luZGV4OwotCWNvcHlfYnVmX2xlbiA9IGNzdGF0ZS0+aW5wdXRfYnVmX2xlbjsK
LQogCWZvciAoOzspCiAJewogCQlpbnQJCQlwcmV2X3Jhd19wdHI7CmRpZmYgLS1naXQgYS9zcmMv
aW5jbHVkZS9jb21tYW5kcy9jb3B5ZnJvbV9pbnRlcm5hbC5oIGIvc3JjL2luY2x1ZGUvY29tbWFu
ZHMvY29weWZyb21faW50ZXJuYWwuaAppbmRleCBmODkyYzM0MzE1Ny4uNWIwMjBiZjRkMGIgMTAw
NjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL2NvbW1hbmRzL2NvcHlmcm9tX2ludGVybmFsLmgKKysrIGIv
c3JjL2luY2x1ZGUvY29tbWFuZHMvY29weWZyb21faW50ZXJuYWwuaApAQCAtODksNiArODksOSBA
QCB0eXBlZGVmIHN0cnVjdCBDb3B5RnJvbVN0YXRlRGF0YQogCWNvbnN0IGNoYXIgKmN1cl9hdHR2
YWw7CQkvKiBjdXJyZW50IGF0dCB2YWx1ZSBmb3IgZXJyb3IgbWVzc2FnZXMgKi8KIAlib29sCQly
ZWxuYW1lX29ubHk7CS8qIGRvbid0IG91dHB1dCBsaW5lIG51bWJlciwgYXR0LCBldGMuICovCiAK
KwkvKiBTSU1EIHZhcmlhYmxlcyAqLworCWJvb2wJCXNpbWRfZW5hYmxlZDsKKwogCS8qCiAJICog
V29ya2luZyBzdGF0ZQogCSAqLwotLSAKMi40Ny4zCgo=
--00000000000007670b064caac2b8--