Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1vCSDS-00EHYz-Tf for pgsql-hackers@arkaria.postgresql.org; Sat, 25 Oct 2025 00:33:06 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.94.2) (envelope-from ) id 1vCSDR-001Z3u-OQ for pgsql-hackers@arkaria.postgresql.org; Sat, 25 Oct 2025 00:33:04 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1vCSDR-001Z3m-4S for pgsql-hackers@lists.postgresql.org; Sat, 25 Oct 2025 00:33:04 +0000 Received: from mail-pl1-x636.google.com ([2607:f8b0:4864:20::636]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.96) (envelope-from ) id 1vCSDN-003cgx-1H for pgsql-hackers@postgresql.org; Sat, 25 Oct 2025 00:33:03 +0000 Received: by mail-pl1-x636.google.com with SMTP id d9443c01a7336-27d3540a43fso27580505ad.3 for ; Fri, 24 Oct 2025 17:33:01 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1761352380; x=1761957180; darn=postgresql.org; h=in-reply-to:references:subject:cc:to:from:message-id:date :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=pPXHymRoLmZetMCJNHb1iQI6gw/a5OSlW1ztr2UIfqU=; b=O3F5i9WtKy4n211sixIKvAowvgkjSIsfowThSGyICkO0h9yPWtTu2jGhb6aAMFpakE kIuIdCntDpv/56gBRSZYc0fUS0OmuL0kZVdKw4FqU5RraKFB6t7sMM+vxOGD7CvhQJtY iKqW5eQn0R4CFCASiSLH09lUN6QVZXQ6YxcyqTsfLZZa4x/7xA1i/uzsry5lhRVoIOmK XrYb4nwO2xhy2pirp79Jj9PkBhY/Or9RbEJYvRdYjXQAiL0fNffVqC4ZYoaPnaelzyvg 0QTD2mRug0FOsT17bFY92dxaIOTkZI9prFhKKzAWo0fg+nXSrPLBNSONC6S4Y8JsgfHA eaRA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761352380; x=1761957180; h=in-reply-to:references:subject:cc:to:from:message-id:date :mime-version:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=pPXHymRoLmZetMCJNHb1iQI6gw/a5OSlW1ztr2UIfqU=; b=bz+7IVAKphbKxbXHwWkpTzeMHCQr0KgMqWuXTGprKBhdvdkUWSeJAO5G6YD5BlEE4y cjQpgV1z+XC8XdniVglFh2zcucFKcG8lFekUwHnrJB5n7elxvudUu6TyVcOcCfvtVd7p 8fecMA3x+8+AUrMYLapBofZIHHYI+cXMuW4cdZHRX/k3kAfzNi8zbNjUQHYrWj4OBxBO B4FsM1DSm0EBj1v5Am1ZOuGHz7zqYKOaiML8G48YbraSXrremc1y6e/Tzim/DnBcqpRi F8CT5mwWgRHA+2vsW9ER5vo5Bywmuz8gCnGmp/iYmVS9Voad05lCZN1+uu3o6sigFmOw vD4w== X-Forwarded-Encrypted: i=1; AJvYcCVV9EO+0XZ3gG9grs0oi/5Ko208m+53HwhugR+jjipmL7BTRrSRO0RHEq3pmHLUi5pSJcb/CegzZ8s2umKA@postgresql.org X-Gm-Message-State: AOJu0YynwR0dgc/ktaWCAEAoHb1nd2/4vTnO8Dhy5RE91Krp0HQkYR4f hCWQcqgHrADZYMG8LR3Owse7AT/8+n8qX6HUB3i15+HouwtDqzeZzdB6 X-Gm-Gg: ASbGncuAxMJytU4KFi4nbCwEVxxPCiftRBr1ohu5FmPhfP8dI3oj7Ir31k8zmiWk2jc V6uKNczzRLGHUGBOCLfnft5kiMlXb/DRWITeNnaSIglOEdF8y0oz0ig7K74UK/421InffTq/rqC VOw3FqhglP4sisb8vP9qDXvxVrP0XAYVZofOB0YH0C8oyTwak/98aCKNo16kb9OOnWUUT6+Iz2w OndptbL6TkordtEWbt9QyHLOywNvbIGnoAWhFUCJHJMFjqf/DhajCEJReuJ1TwWEh+NoY9SYn/J ijI7/Znw4iUGo/nakSqkJOfNYkT8mw/Mi5y7W8T9KV1Ol1WAdCtUqANf9R3IA3tamtq88/8VpYl Irkq6LBtdlQQiW2Pa4vD5LkHAztbPkDyHEetqjnf3rna7PtYYZChj6KZdGe0FNTsTHAEbJTyJ+a 81SCNp7Qgqx930fj1rcvWdWQZJNHz8ti6rVg== X-Google-Smtp-Source: AGHT+IEoeyxyBwD9iPmSQ0LYG8HxfUV0BvLfOcwipT/Xn5Mv70cv5K26UZRGbdF3ZzRj/eLi17YCPQ== X-Received: by 2002:a17:902:f68c:b0:290:91d2:9304 with SMTP id d9443c01a7336-290c9c8a770mr338832675ad.4.1761352380019; Fri, 24 Oct 2025 17:33:00 -0700 (PDT) Received: from localhost ([2804:14d:328a:a59c:58be:8196:d2cb:8423]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-29498cf4a40sm5016685ad.0.2025.10.24.17.32.56 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Fri, 24 Oct 2025 17:32:59 -0700 (PDT) Content-Type: multipart/mixed; boundary=5afb61ee74a4f0c9a936380f4a6aae9450e55be349e1f63adb787a1e31bb Mime-Version: 1.0 Date: Fri, 24 Oct 2025 21:32:54 -0300 Message-Id: From: "Matheus Alcantara" To: "Masahiko Sawada" , "Matheus Alcantara" Cc: =?utf-8?q?=C3=81lvaro_Herrera?= , "Joel Jacobson" , "Arseniy Mukhin" , "Rishu Bagga" , "Yura Sokolov" , "Daniil Davydov" <3danissimo@gmail.com>, "Alexandra Wang" , "pgsql-hackers" , "Tom Lane" Subject: Re: LISTEN/NOTIFY bug: VACUUM sets frozenxid past a xid in async queue X-Mailer: aerc 0.21.0 References: <202510221548.tgggefdrlpo3@alvherre.pgsql> In-Reply-To: List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --5afb61ee74a4f0c9a936380f4a6aae9450e55be349e1f63adb787a1e31bb Content-Type: multipart/alternative; boundary=0379f151fae8e18fb48cdf2e691fb2f2ef54b77d73aa95e282ddc8c6bac3 --0379f151fae8e18fb48cdf2e691fb2f2ef54b77d73aa95e282ddc8c6bac3 Content-Transfer-Encoding: quoted-printable Content-Disposition: inline Content-Type: text/plain; charset=UTF-8 Thanks for the review! On Thu Oct 23, 2025 at 8:42 PM -03, Masahiko Sawada wrote: > On Wed, Oct 22, 2025 at 10:25=E2=80=AFAM Matheus Alcantara > wrote: >> >> On Wed Oct 22, 2025 at 12:49 PM -03, =C3=81lvaro Herrera wrote: >> > On 2025-Oct-22, Matheus Alcantara wrote: >> > >> >> I'm wondering if the 002_aborted_tx_notifies.pl is still needed with >> >> this architecture being used. I think that it's not, but perhaps is a >> >> good test to keep it? >> > >> > I'd rather have tests than not, but I'd think it needs to be behind >> > PG_TEST_EXTRA because of things like >> > >> > +$node->safe_psql('postgres', 'select consume_xids(10000000);'); >> > >> Attached v10 with wrapping into PG_TEST_EXTRA. > > Thank you for updating the patches! > > I've reviewed the patches and here are the comments. > > v10-0001-Prevent-VACUUM-from-truncating-XIDs-still-presen.patch: > > + * > + * Returns InvalidTransactionId if there are no unprocessed notification= s. > > This comment is not accurate since the function returns > InvalidTransactionId even if all unprocessed notifications are created > on other databases. > Fixed > --- > +TransactionId > +GetOldestQueuedNotifyXid(void) > +{ > > How about renaming it to something like GetOldestNotifyTransactionId()? > Yeap, sounds better, fixed. > --- > + /* page_buffer must be adequately aligned, so use a union */ > + union > + { > + char buf[QUEUE_PAGESIZE]; > + AsyncQueueEntry align; > + } page_buffer; > > asyncQueueReadAllNotifications() uses this union too, so how about > define this type as AlignedQueueEntryPage or something and use it in > both functions? > Good point, fixed. > --- > + > + LWLockAcquire(NotifyQueueLock, LW_EXCLUSIVE); > + > > I don't think we need an exclusive lock here. > Fixed. > --- > In GetOldestQueuedNotifyXid() why do we keep holding NotifyQueueLock > while calculating the oldest XID in the queue? > Yeah, I don't think that it's necessary. The asyncQueueReadAllNotifications() for example only hold the lock when reading the QUEUE_BACKEND_POS and QUEUE_HEAD. I think that it's a similar case here, fixed. > --- > + > + /* Process all entries on this page up to head */ > + while (curoffset + QUEUEALIGN(AsyncQueueEntryEmptySize) <=3D > QUEUE_PAGESIZE && > + !QUEUE_POS_EQUAL(pos, head)) > + { > + qe =3D (AsyncQueueEntry *) (page_buffer.buf + curoffset); > (snip) > + /* Advance to next entry */ > + if (asyncQueueAdvance(&pos, qe->length)) > + break; /* advanced to next page */ > + > > I think the check "curoffset + QUEUEALIGN(AsyncQueueEntryEmptySize) <=3D > QUEUE_PAGESIZE" is essentially the same as the one we do in > asyncQueueAdvance(). I think we can refactor the inner loop in > GetOldestQueuedNotifyXid() to something like: > > for (;;) > { > bool reachedEndOfPage; > > qe =3D (AsyncQueueEntry *) (page_buffer.buf + curoffset); > > // check qe->xid here... > > reachedEndOfPage =3D asyncQueueAdvance(&pos, qe->length); > > if (reachedEndOfPage || QUEUE_POS_EQUAL(pos, head)) > break; > } > Fixed > --- > v10-0002-Add-tap-tests-for-listen-notify-vacuum-freeze.patch: > > This new test directory needs to have .gitignore. > Fixed > --- > +# Copyright (c) 2024-2025, PostgreSQL Global Development Group > + > > It's better to have a short description of this test here. > Fixed > --- > +use File::Path qw(mkpath); > > It seems not necessary. > Fixed > --- > +$node->safe_psql('postgres', > + 'CREATE TABLE t AS SELECT g AS a, g+2 AS b from > generate_series(1,100000) g;' > > Why does it need to insert many rows? > I think that this value was left when I was writing the first versions of this test, I don't think that it's necessary. I reduced to just 10 rows. > --- > +# --- Session 2, multiple notify's, and commit --- > +for my $i (1 .. 10) > +{ > + $node->safe_psql( > + 'postgres', " > + BEGIN; > + NOTIFY s, '$i'; > + COMMIT;"); > +} > > Why does it need to send a notification 10 times? > I just wanted to test with multiple notifications, we can reduce to two or three, there is not specific reason to send 10 notifications. > --- > +# Consume enough XIDs to trigger truncation > +$node->safe_psql('postgres', 'select consume_xids(10000000);'); > + > > I guess it consumes XID too much to trigger truncation. Given the one > clog segment file is 256kB in size, it's enough to consume 1,050,000 > XIDs to move to the next segment file. > Fixed > --- > +# Get the new datfrozenxid after vacuum freeze to ensure that is advance= d but > +# we can still get the notification status of the notification > +my $datafronzenxid_freeze =3D $node->safe_psql('postgres', "select > datfrozenxid from pg_database where datname =3D 'postgres'"); > +ok($datafronzenxid_freeze > $datafronzenxid, 'datfrozenxid is advanced')= ; > > I think this test passes in all cases, so it is meaningless. Instead, > what we need to check in terms of datfrozenxid is that its value > doesn't get greater than the XID we used for the notification, even > after vacuum freeze. I think we remember the XID used for NOTIFY and > check if the old/new datfrozenxid values are older than that value. > I think that was the goal of this test. I've swap the values to make it more clear. Please let me know if I misunderstood your point here. > --- > +is($notifications_count, 10, 'received all committed notifications'); > + > +done_testing(); > > After consuming the unconsumed notifications, let's do vacuum freeze > and check if datfrozenxid now can be advanced. > Good point, during this I realize that the datafrozenxid was not being advanced even after the queue being consumed. This was because when a backend listener is consuming the notifications it only update their own queue tail pointer and not the global shared tail pointer, so I've included a call to asyncQueueAdvanceTail() at the beginning of GetOldestNotifyTransactionId() to do this. > --- > I would expect to add 002_aborted_tx_notifies.pl in a separate patch > since it's not related to this bug fix. > On the new attached version I've moved this test to a separated patch. > --- > +# Test checks that listeners do not receive notifications from aborted > +# transaction even if notifications have been added to the listen/notify > +# queue. To reproduce it we use the fact that serializable conflicts > +# are checked after tx adds notifications to the queue. > > I wonder if we could implement this test using the isolation test > instead of the tap test. Is there any reason why you used a tap test > for that? > On this new version I just moved the test into a separated patch but I agree that we can implement this using the isolation test, I don't know how we should handle the follow-up patches that Joel have sent on [1], if we should incoportate on 0001 or not. I still need to review and test them. [1] https://www.postgresql.org/message-id/b6f6cbb8-1903-4ca0-ae64-01d84d1e1= 2a3%40app.fastmail.com -- Matheus Alcantara --0379f151fae8e18fb48cdf2e691fb2f2ef54b77d73aa95e282ddc8c6bac3-- --5afb61ee74a4f0c9a936380f4a6aae9450e55be349e1f63adb787a1e31bb Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=v11-0001-Prevent-VACUUM-from-truncating-XIDs-still-presen.patch Content-Type: text/plain; charset=utf-8; name=v11-0001-Prevent-VACUUM-from-truncating-XIDs-still-presen.patch RnJvbSAzNzY3NWY2ZmVmZjMwYTM2NWRlM2IyNjcxOTAwMmI2NWE4MWRhYmIzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb2VsIEphY29ic29uIDxqb2VsQGNvbXBpbGVyLm9yZz4KRGF0 ZTogU3VuLCAxOSBPY3QgMjAyNSAxODo1NToyNSArMDIwMApTdWJqZWN0OiBbUEFUQ0ggdjExIDEv Ml0gUHJldmVudCBWQUNVVU0gZnJvbSB0cnVuY2F0aW5nIFhJRHMgc3RpbGwgcHJlc2VudCBpbgog bm90aWZpY2F0aW9uIHF1ZXVlCgpWQUNVVU0ncyBjb21wdXRhdGlvbiBvZiBkYXRmcm96ZW54aWQg ZGlkIG5vdCBhY2NvdW50IGZvciB0cmFuc2FjdGlvbiBJRHMKaW4gdGhlIExJU1RFTi9OT1RJRlkg cXVldWUuICBUaGlzIGFsbG93ZWQgVkFDVVVNIHRvIHRydW5jYXRlIGNsb2cKZW50cmllcyBmb3Ig WElEcyB0aGF0IHdlcmUgc3RpbGwgcmVmZXJlbmNlZCBieSBxdWV1ZWQgbm90aWZpY2F0aW9ucywK Y2F1c2luZyBiYWNrZW5kcyB0byBmYWlsIGluIFRyYW5zYWN0aW9uSWREaWRDb21taXQgd2hlbiBs YXRlciBwcm9jZXNzaW5nCnRob3NlIG5vdGlmaWNhdGlvbnMuCgpGaXggYnkgYWRkaW5nIEdldE9s ZGVzdFF1ZXVlZE5vdGlmeVhpZCB0byBmaW5kIHRoZSBvbGRlc3QgWElEIGluIHF1ZXVlZApub3Rp ZmljYXRpb25zIGZvciB0aGUgY3VycmVudCBkYXRhYmFzZSwgYW5kIGNvbnN0cmFpbmluZyBkYXRm cm96ZW54aWQgdG8Kbm90IHBhc3MgdGhhdC4gIFRoZSBmdW5jdGlvbiBzY2FucyBmcm9tIFFVRVVF X1RBSUwsIHNpbmNlIG5vdGlmaWNhdGlvbnMKbWF5IGhhdmUgYmVlbiB3cml0dGVuIGJlZm9yZSBh bnkgbGlzdGVuZXJzIGV4aXN0ZWQuCgpUbyBhdm9pZCBjb2RlIGR1cGxpY2F0aW9uLCByZWZhY3Rv ciBTTFJVIHBhZ2UtcmVhZGluZyBjb2RlIGludG8gYSBuZXcKaGVscGVyIGZ1bmN0aW9uIGFzeW5j UXVldWVSZWFkUGFnZVRvQnVmZmVyLgoKQ28tYXV0aG9yZWQtYnk6IE1hdGhldXMgQWxjYW50YXJh IDxtYXRoZXVzc3NpbHY5N0BnbWFpbC5jb20+Ci0tLQogc3JjL2JhY2tlbmQvY29tbWFuZHMvYXN5 bmMuYyAgICAgICAgICAgICAgICAgIHwgMTU2ICsrKysrKysrKysrKysrLS0tLQogc3JjL2JhY2tl bmQvY29tbWFuZHMvdmFjdXVtLmMgICAgICAgICAgICAgICAgIHwgIDEyICsrCiBzcmMvaW5jbHVk ZS9jb21tYW5kcy9hc3luYy5oICAgICAgICAgICAgICAgICAgfCAgIDMgKwogc3JjL3Rlc3QvbW9k dWxlcy9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIHNyYy90ZXN0L21vZHVs ZXMvbWVzb24uYnVpbGQgICAgICAgICAgICAgICAgICB8ICAgMSArCiAuLi4vbW9kdWxlcy90ZXN0 X2xpc3Rlbl9ub3RpZnkvLmdpdGlnbm9yZSAgICAgfCAgIDQgKwogc3JjL3Rlc3QvbW9kdWxlcy90 ZXN0X2xpc3Rlbl9ub3RpZnkvTWFrZWZpbGUgIHwgIDE5ICsrKwogLi4uL21vZHVsZXMvdGVzdF9s aXN0ZW5fbm90aWZ5L21lc29uLmJ1aWxkICAgIHwgIDEzICsrCiAuLi4vdGVzdF9saXN0ZW5fbm90 aWZ5L3QvMDAxX3hpZF9mcmVlemUucGwgICAgfCAgODkgKysrKysrKysrKwogc3JjL3Rvb2xzL3Bn aW5kZW50L3R5cGVkZWZzLmxpc3QgICAgICAgICAgICAgIHwgICAxICsKIDEwIGZpbGVzIGNoYW5n ZWQsIDI2OCBpbnNlcnRpb25zKCspLCAzMSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0 NCBzcmMvdGVzdC9tb2R1bGVzL3Rlc3RfbGlzdGVuX25vdGlmeS8uZ2l0aWdub3JlCiBjcmVhdGUg bW9kZSAxMDA2NDQgc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2xpc3Rlbl9ub3RpZnkvTWFrZWZpbGUK IGNyZWF0ZSBtb2RlIDEwMDY0NCBzcmMvdGVzdC9tb2R1bGVzL3Rlc3RfbGlzdGVuX25vdGlmeS9t ZXNvbi5idWlsZAogY3JlYXRlIG1vZGUgMTAwNjQ0IHNyYy90ZXN0L21vZHVsZXMvdGVzdF9saXN0 ZW5fbm90aWZ5L3QvMDAxX3hpZF9mcmVlemUucGwKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9j b21tYW5kcy9hc3luYy5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvYXN5bmMuYwppbmRleCA0YmQz N2Q1YmViNS4uOGZjMWJiYmE3YTIgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2Fz eW5jLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvYXN5bmMuYwpAQCAtNDAxLDYgKzQwMSwx NyBAQCBzdHJ1Y3QgTm90aWZpY2F0aW9uSGFzaAogCU5vdGlmaWNhdGlvbiAqZXZlbnQ7CQkvKiA9 PiB0aGUgYWN0dWFsIE5vdGlmaWNhdGlvbiBzdHJ1Y3QgKi8KIH07CiAKKy8qCisgKiBQYWdlIGJ1 ZmZlcnMgdXNlZCB0byByZWFkIGZyb20gU0xSVSBjYWNoZSBtdXN0IGJlIGFkZXF1YXRlbHkgYWxp Z25lZCwKKyAqIHNvIHVzZSBhIHVuaW9uLgorICovCit0eXBlZGVmIHVuaW9uCit7CisJY2hhcgkJ YnVmW1FVRVVFX1BBR0VTSVpFXTsKKwlBc3luY1F1ZXVlRW50cnkgYWxpZ247Cit9IEFsaWduZWRR dWV1ZUVudHJ5UGFnZTsKKworCiBzdGF0aWMgTm90aWZpY2F0aW9uTGlzdCAqcGVuZGluZ05vdGlm aWVzID0gTlVMTDsKIAogLyoKQEAgLTE4NDEsNiArMTg1Miw0NCBAQCBQcm9jZXNzTm90aWZ5SW50 ZXJydXB0KGJvb2wgZmx1c2gpCiAJCVByb2Nlc3NJbmNvbWluZ05vdGlmeShmbHVzaCk7CiB9CiAK Ky8qCisgKiBSZWFkIGEgcGFnZSBmcm9tIHRoZSBTTFJVIHF1ZXVlIGludG8gYSBsb2NhbCBidWZm ZXIuCisgKgorICogUmVhZHMgdGhlIHBhZ2UgY29udGFpbmluZyAncG9zJywgY29weWluZyB0aGUg ZGF0YSBmcm9tIHRoZSBjdXJyZW50IG9mZnNldAorICogZWl0aGVyIHRvIHRoZSBlbmQgb2YgdGhl IHBhZ2Ugb3IgdXAgdG8gJ2hlYWQnICh3aGljaGV2ZXIgY29tZXMgZmlyc3QpCisgKiBpbnRvIHBh Z2VfYnVmZmVyLgorICovCitzdGF0aWMgdm9pZAorYXN5bmNRdWV1ZVJlYWRQYWdlVG9CdWZmZXIo UXVldWVQb3NpdGlvbiBwb3MsIFF1ZXVlUG9zaXRpb24gaGVhZCwKKwkJCQkJCSAgIGNoYXIgKnBh Z2VfYnVmZmVyKQoreworCWludDY0CQljdXJwYWdlID0gUVVFVUVfUE9TX1BBR0UocG9zKTsKKwlp bnQJCQljdXJvZmZzZXQgPSBRVUVVRV9QT1NfT0ZGU0VUKHBvcyk7CisJaW50CQkJc2xvdG5vOwor CWludAkJCWNvcHlzaXplOworCisJc2xvdG5vID0gU2ltcGxlTHJ1UmVhZFBhZ2VfUmVhZE9ubHko Tm90aWZ5Q3RsLCBjdXJwYWdlLAorCQkJCQkJCQkJCUludmFsaWRUcmFuc2FjdGlvbklkKTsKKwor CWlmIChjdXJwYWdlID09IFFVRVVFX1BPU19QQUdFKGhlYWQpKQorCXsKKwkJLyogd2Ugb25seSB3 YW50IHRvIHJlYWQgYXMgZmFyIGFzIGhlYWQgKi8KKwkJY29weXNpemUgPSBRVUVVRV9QT1NfT0ZG U0VUKGhlYWQpIC0gY3Vyb2Zmc2V0OworCQlpZiAoY29weXNpemUgPCAwKQorCQkJY29weXNpemUg PSAwOwkJLyoganVzdCBmb3Igc2FmZXR5ICovCisJfQorCWVsc2UKKwl7CisJCS8qIGZldGNoIGFs bCB0aGUgcmVzdCBvZiB0aGUgcGFnZSAqLworCQljb3B5c2l6ZSA9IFFVRVVFX1BBR0VTSVpFIC0g Y3Vyb2Zmc2V0OworCX0KKworCW1lbWNweShwYWdlX2J1ZmZlciArIGN1cm9mZnNldCwKKwkJICAg Tm90aWZ5Q3RsLT5zaGFyZWQtPnBhZ2VfYnVmZmVyW3Nsb3Rub10gKyBjdXJvZmZzZXQsCisJCSAg IGNvcHlzaXplKTsKKwkvKiBSZWxlYXNlIGxvY2sgdGhhdCB3ZSBnb3QgZnJvbSBTaW1wbGVMcnVS ZWFkUGFnZV9SZWFkT25seSgpICovCisJTFdMb2NrUmVsZWFzZShTaW1wbGVMcnVHZXRCYW5rTG9j ayhOb3RpZnlDdGwsIGN1cnBhZ2UpKTsKK30KIAogLyoKICAqIFJlYWQgYWxsIHBlbmRpbmcgbm90 aWZpY2F0aW9ucyBmcm9tIHRoZSBxdWV1ZSwgYW5kIGRlbGl2ZXIgYXBwcm9wcmlhdGUKQEAgLTE4 NTMsMTMgKzE5MDIsNyBAQCBhc3luY1F1ZXVlUmVhZEFsbE5vdGlmaWNhdGlvbnModm9pZCkKIAl2 b2xhdGlsZSBRdWV1ZVBvc2l0aW9uIHBvczsKIAlRdWV1ZVBvc2l0aW9uIGhlYWQ7CiAJU25hcHNo b3QJc25hcHNob3Q7Ci0KLQkvKiBwYWdlX2J1ZmZlciBtdXN0IGJlIGFkZXF1YXRlbHkgYWxpZ25l ZCwgc28gdXNlIGEgdW5pb24gKi8KLQl1bmlvbgotCXsKLQkJY2hhcgkJYnVmW1FVRVVFX1BBR0VT SVpFXTsKLQkJQXN5bmNRdWV1ZUVudHJ5IGFsaWduOwotCX0JCQlwYWdlX2J1ZmZlcjsKKwlBbGln bmVkUXVldWVFbnRyeVBhZ2UgcGFnZV9idWZmZXI7CiAKIAkvKiBGZXRjaCBjdXJyZW50IHN0YXRl ICovCiAJTFdMb2NrQWNxdWlyZShOb3RpZnlRdWV1ZUxvY2ssIExXX1NIQVJFRCk7CkBAIC0xOTMy LDM2ICsxOTc1LDEzIEBAIGFzeW5jUXVldWVSZWFkQWxsTm90aWZpY2F0aW9ucyh2b2lkKQogCiAJ CWRvCiAJCXsKLQkJCWludDY0CQljdXJwYWdlID0gUVVFVUVfUE9TX1BBR0UocG9zKTsKLQkJCWlu dAkJCWN1cm9mZnNldCA9IFFVRVVFX1BPU19PRkZTRVQocG9zKTsKLQkJCWludAkJCXNsb3RubzsK LQkJCWludAkJCWNvcHlzaXplOwotCiAJCQkvKgogCQkJICogV2UgY29weSB0aGUgZGF0YSBmcm9t IFNMUlUgaW50byBhIGxvY2FsIGJ1ZmZlciwgc28gYXMgdG8gYXZvaWQKIAkJCSAqIGhvbGRpbmcg dGhlIFNMUlUgbG9jayB3aGlsZSB3ZSBhcmUgZXhhbWluaW5nIHRoZSBlbnRyaWVzIGFuZAogCQkJ ICogcG9zc2libHkgdHJhbnNtaXR0aW5nIHRoZW0gdG8gb3VyIGZyb250ZW5kLiAgQ29weSBvbmx5 IHRoZSBwYXJ0CiAJCQkgKiBvZiB0aGUgcGFnZSB3ZSB3aWxsIGFjdHVhbGx5IGluc3BlY3QuCiAJ CQkgKi8KLQkJCXNsb3RubyA9IFNpbXBsZUxydVJlYWRQYWdlX1JlYWRPbmx5KE5vdGlmeUN0bCwg Y3VycGFnZSwKLQkJCQkJCQkJCQkJCUludmFsaWRUcmFuc2FjdGlvbklkKTsKLQkJCWlmIChjdXJw YWdlID09IFFVRVVFX1BPU19QQUdFKGhlYWQpKQotCQkJewotCQkJCS8qIHdlIG9ubHkgd2FudCB0 byByZWFkIGFzIGZhciBhcyBoZWFkICovCi0JCQkJY29weXNpemUgPSBRVUVVRV9QT1NfT0ZGU0VU KGhlYWQpIC0gY3Vyb2Zmc2V0OwotCQkJCWlmIChjb3B5c2l6ZSA8IDApCi0JCQkJCWNvcHlzaXpl ID0gMDsJLyoganVzdCBmb3Igc2FmZXR5ICovCi0JCQl9Ci0JCQllbHNlCi0JCQl7Ci0JCQkJLyog ZmV0Y2ggYWxsIHRoZSByZXN0IG9mIHRoZSBwYWdlICovCi0JCQkJY29weXNpemUgPSBRVUVVRV9Q QUdFU0laRSAtIGN1cm9mZnNldDsKLQkJCX0KLQkJCW1lbWNweShwYWdlX2J1ZmZlci5idWYgKyBj dXJvZmZzZXQsCi0JCQkJICAgTm90aWZ5Q3RsLT5zaGFyZWQtPnBhZ2VfYnVmZmVyW3Nsb3Rub10g KyBjdXJvZmZzZXQsCi0JCQkJICAgY29weXNpemUpOwotCQkJLyogUmVsZWFzZSBsb2NrIHRoYXQg d2UgZ290IGZyb20gU2ltcGxlTHJ1UmVhZFBhZ2VfUmVhZE9ubHkoKSAqLwotCQkJTFdMb2NrUmVs ZWFzZShTaW1wbGVMcnVHZXRCYW5rTG9jayhOb3RpZnlDdGwsIGN1cnBhZ2UpKTsKKwkJCWFzeW5j UXVldWVSZWFkUGFnZVRvQnVmZmVyKHBvcywgaGVhZCwgcGFnZV9idWZmZXIuYnVmKTsKIAogCQkJ LyoKIAkJCSAqIFByb2Nlc3MgbWVzc2FnZXMgdXAgdG8gdGhlIHN0b3AgcG9zaXRpb24sIGVuZCBv ZiBwYWdlLCBvciBhbgpAQCAtMjA5Nyw2ICsyMTE3LDgwIEBAIGFzeW5jUXVldWVQcm9jZXNzUGFn ZUVudHJpZXModm9sYXRpbGUgUXVldWVQb3NpdGlvbiAqY3VycmVudCwKIAlyZXR1cm4gcmVhY2hl ZFN0b3A7CiB9CiAKKy8qCisgKiBHZXQgdGhlIG9sZGVzdCBYSUQgaW4gdGhlIG5vdGlmaWNhdGlv biBxdWV1ZSB0aGF0IGhhcyBub3QgeWV0IGJlZW4KKyAqIHByb2Nlc3NlZCBieSBhbGwgbGlzdGVu aW5nIGJhY2tlbmRzLgorICoKKyAqIFJldHVybnMgSW52YWxpZFRyYW5zYWN0aW9uSWQgaWYgdGhl cmUgYXJlIG5vIHVucHJvY2Vzc2VkIG5vdGlmaWNhdGlvbnMgb3IgaWYKKyAqIGFsbCB1bnByb2Nl c3NlZCBub3RpZmljYXRpb25zIGFyZSBjcmVhdGVkIG9uIG90aGVyIGRhdGFiYXNlcyBkaWZmZXJl bnQgZnJvbQorICogTXlEYXRhYmFzZUlkLgorICovCitUcmFuc2FjdGlvbklkCitHZXRPbGRlc3RO b3RpZnlUcmFuc2FjdGlvbklkKHZvaWQpCit7CisJUXVldWVQb3NpdGlvbiBwb3M7CisJUXVldWVQ b3NpdGlvbiBoZWFkOworCUFsaWduZWRRdWV1ZUVudHJ5UGFnZSBwYWdlX2J1ZmZlcjsKKwlUcmFu c2FjdGlvbklkIG9sZGVzdFhpZCA9IEludmFsaWRUcmFuc2FjdGlvbklkOworCisJLyogRmlyc3Qg YWR2YW5jZSB0aGUgc2hhcmVkIHF1ZXVlIHRhaWwgcG9pbnRlciAqLworCWFzeW5jUXVldWVBZHZh bmNlVGFpbCgpOworCisJLyoKKwkgKiBXZSBtdXN0IHN0YXJ0IGF0IFFVRVVFX1RBSUwgc2luY2Ug bm90aWZpY2F0aW9uIGRhdGEgbWlnaHQgaGF2ZSBiZWVuCisJICogd3JpdHRlbiBiZWZvcmUgdGhl cmUgd2VyZSBhbnkgbGlzdGVuaW5nIGJhY2tlbmRzLgorCSAqLworCUxXTG9ja0FjcXVpcmUoTm90 aWZ5UXVldWVMb2NrLCBMV19TSEFSRUQpOworCXBvcyA9IFFVRVVFX1RBSUw7CisJaGVhZCA9IFFV RVVFX0hFQUQ7CisJTFdMb2NrUmVsZWFzZShOb3RpZnlRdWV1ZUxvY2spOworCisJLyogSWYgdGhl IHF1ZXVlIGlzIGVtcHR5LCBubyBYSURzIG5lZWQgcHJvdGVjdGlvbiAqLworCWlmIChRVUVVRV9Q T1NfRVFVQUwocG9zLCBoZWFkKSkKKwkJcmV0dXJuIEludmFsaWRUcmFuc2FjdGlvbklkOworCisJ d2hpbGUgKCFRVUVVRV9QT1NfRVFVQUwocG9zLCBoZWFkKSkKKwl7CisJCWludAkJCWN1cm9mZnNl dDsKKwkJQXN5bmNRdWV1ZUVudHJ5ICpxZTsKKworCQkvKiBSZWFkIHRoZSBjdXJyZW50IHBhZ2Ug ZnJvbSBTTFJVIGludG8gb3VyIGxvY2FsIGJ1ZmZlciAqLworCQlhc3luY1F1ZXVlUmVhZFBhZ2VU b0J1ZmZlcihwb3MsIGhlYWQsIHBhZ2VfYnVmZmVyLmJ1Zik7CisKKwkJY3Vyb2Zmc2V0ID0gUVVF VUVfUE9TX09GRlNFVChwb3MpOworCisJCS8qIFByb2Nlc3MgYWxsIGVudHJpZXMgb24gdGhpcyBw YWdlIHVwIHRvIGhlYWQgKi8KKwkJZm9yICg7OykKKwkJeworCQkJYm9vbAkJcmVhY2hlZEVuZE9m UGFnZTsKKworCQkJcWUgPSAoQXN5bmNRdWV1ZUVudHJ5ICopIChwYWdlX2J1ZmZlci5idWYgKyBj dXJvZmZzZXQpOworCisJCQkvKgorCQkJICogQ2hlY2sgaWYgdGhpcyBlbnRyeSBpcyBmb3Igb3Vy IGRhdGFiYXNlIGFuZCBoYXMgYSB2YWxpZCBYSUQuCisJCQkgKiBPbmx5IGVudHJpZXMgZm9yIG91 ciBkYXRhYmFzZSBtYXR0ZXIgZm9yIG91ciBkYXRmcm96ZW54aWQuCisJCQkgKi8KKwkJCWlmIChx ZS0+ZGJvaWQgPT0gTXlEYXRhYmFzZUlkICYmIFRyYW5zYWN0aW9uSWRJc1ZhbGlkKHFlLT54aWQp KQorCQkJeworCQkJCWlmICghVHJhbnNhY3Rpb25JZElzVmFsaWQob2xkZXN0WGlkKSB8fAorCQkJ CQlUcmFuc2FjdGlvbklkUHJlY2VkZXMocWUtPnhpZCwgb2xkZXN0WGlkKSkKKwkJCQkJb2xkZXN0 WGlkID0gcWUtPnhpZDsKKwkJCX0KKworCQkJLyogQWR2YW5jZSB0byBuZXh0IGVudHJ5ICovCisJ CQlyZWFjaGVkRW5kT2ZQYWdlID0gYXN5bmNRdWV1ZUFkdmFuY2UoJnBvcywgcWUtPmxlbmd0aCk7 CisKKwkJCWlmIChyZWFjaGVkRW5kT2ZQYWdlIHx8IFFVRVVFX1BPU19FUVVBTChwb3MsIGhlYWQp KQorCQkJCWJyZWFrOworCisKKwkJCWN1cm9mZnNldCA9IFFVRVVFX1BPU19PRkZTRVQocG9zKTsK KwkJfQorCX0KKworCXJldHVybiBvbGRlc3RYaWQ7Cit9CisKIC8qCiAgKiBBZHZhbmNlIHRoZSBz aGFyZWQgcXVldWUgdGFpbCB2YXJpYWJsZSB0byB0aGUgbWluaW11bSBvZiBhbGwgdGhlCiAgKiBw ZXItYmFja2VuZCB0YWlsIHBvaW50ZXJzLiAgVHJ1bmNhdGUgcGdfbm90aWZ5IHNwYWNlIGlmIHBv c3NpYmxlLgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMgYi9zcmMv YmFja2VuZC9jb21tYW5kcy92YWN1dW0uYwppbmRleCBlZDAzZTNiZDUwZC4uZTVmZWRmYjMyMzgg MTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCisrKyBiL3NyYy9iYWNr ZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCkBAIC0zNyw2ICszNyw3IEBACiAjaW5jbHVkZSAiY2F0YWxv Zy9uYW1lc3BhY2UuaCIKICNpbmNsdWRlICJjYXRhbG9nL3BnX2RhdGFiYXNlLmgiCiAjaW5jbHVk ZSAiY2F0YWxvZy9wZ19pbmhlcml0cy5oIgorI2luY2x1ZGUgImNvbW1hbmRzL2FzeW5jLmgiCiAj aW5jbHVkZSAiY29tbWFuZHMvY2x1c3Rlci5oIgogI2luY2x1ZGUgImNvbW1hbmRzL2RlZnJlbS5o IgogI2luY2x1ZGUgImNvbW1hbmRzL3Byb2dyZXNzLmgiCkBAIC0xNjE3LDYgKzE2MTgsNyBAQCB2 YWNfdXBkYXRlX2RhdGZyb3plbnhpZCh2b2lkKQogCWJvb2wJCWRpcnR5ID0gZmFsc2U7CiAJU2Nh bktleURhdGEga2V5WzFdOwogCXZvaWQJICAgKmlucGxhY2Vfc3RhdGU7CisJVHJhbnNhY3Rpb25J ZCBvbGRlc3ROb3RpZnlYaWQ7CiAKIAkvKgogCSAqIFJlc3RyaWN0IHRoaXMgdGFzayB0byBvbmUg YmFja2VuZCBwZXIgZGF0YWJhc2UuICBUaGlzIGF2b2lkcyByYWNlCkBAIC0xNzMzLDYgKzE3MzUs MTYgQEAgdmFjX3VwZGF0ZV9kYXRmcm96ZW54aWQodm9pZCkKIAlpZiAoYm9ndXMpCiAJCXJldHVy bjsKIAorCS8qCisJICogQWxzbyBjb25zaWRlciB0aGUgb2xkZXN0IFhJRCBpbiB0aGUgbm90aWZp Y2F0aW9uIHF1ZXVlLCBzaW5jZSBiYWNrZW5kcworCSAqIHdpbGwgbmVlZCB0byBjYWxsIFRyYW5z YWN0aW9uSWREaWRDb21taXQoKSBvbiB0aG9zZSBYSURzIHdoZW4KKwkgKiBwcm9jZXNzaW5nIHRo ZSBub3RpZmljYXRpb25zLgorCSAqLworCW9sZGVzdE5vdGlmeVhpZCA9IEdldE9sZGVzdE5vdGlm eVRyYW5zYWN0aW9uSWQoKTsKKwlpZiAoVHJhbnNhY3Rpb25JZElzVmFsaWQob2xkZXN0Tm90aWZ5 WGlkKSAmJgorCQlUcmFuc2FjdGlvbklkUHJlY2VkZXMob2xkZXN0Tm90aWZ5WGlkLCBuZXdGcm96 ZW5YaWQpKQorCQluZXdGcm96ZW5YaWQgPSBvbGRlc3ROb3RpZnlYaWQ7CisKIAlBc3NlcnQoVHJh bnNhY3Rpb25JZElzTm9ybWFsKG5ld0Zyb3plblhpZCkpOwogCUFzc2VydChNdWx0aVhhY3RJZElz VmFsaWQobmV3TWluTXVsdGkpKTsKIApkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvY29tbWFuZHMv YXN5bmMuaCBiL3NyYy9pbmNsdWRlL2NvbW1hbmRzL2FzeW5jLmgKaW5kZXggZjc1YzNkZjk1NTYu LjBmOGYxN2FkMjJiIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9jb21tYW5kcy9hc3luYy5oCisr KyBiL3NyYy9pbmNsdWRlL2NvbW1hbmRzL2FzeW5jLmgKQEAgLTI2LDYgKzI2LDkgQEAgZXh0ZXJu IHZvaWQgTm90aWZ5TXlGcm9udEVuZChjb25zdCBjaGFyICpjaGFubmVsLAogCQkJCQkJCSBjb25z dCBjaGFyICpwYXlsb2FkLAogCQkJCQkJCSBpbnQzMiBzcmNQaWQpOwogCisvKiBnZXQgb2xkZXN0 IFhJRCBpbiB0aGUgbm90aWZpY2F0aW9uIHF1ZXVlIGZvciB2YWN1dW0gZnJlZXplICovCitleHRl cm4gVHJhbnNhY3Rpb25JZCBHZXRPbGRlc3ROb3RpZnlUcmFuc2FjdGlvbklkKHZvaWQpOworCiAv KiBub3RpZnktcmVsYXRlZCBTUUwgc3RhdGVtZW50cyAqLwogZXh0ZXJuIHZvaWQgQXN5bmNfTm90 aWZ5KGNvbnN0IGNoYXIgKmNoYW5uZWwsIGNvbnN0IGNoYXIgKnBheWxvYWQpOwogZXh0ZXJuIHZv aWQgQXN5bmNfTGlzdGVuKGNvbnN0IGNoYXIgKmNoYW5uZWwpOwpkaWZmIC0tZ2l0IGEvc3JjL3Rl c3QvbW9kdWxlcy9NYWtlZmlsZSBiL3NyYy90ZXN0L21vZHVsZXMvTWFrZWZpbGUKaW5kZXggOTAy YTc5NTQxMDEuLmEwMTVjOTYxZDM1IDEwMDY0NAotLS0gYS9zcmMvdGVzdC9tb2R1bGVzL01ha2Vm aWxlCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvTWFrZWZpbGUKQEAgLTI5LDYgKzI5LDcgQEAgU1VC RElSUyA9IFwKIAkJICB0ZXN0X2ludDEyOCBcCiAJCSAgdGVzdF9pbnRlZ2Vyc2V0IFwKIAkJICB0 ZXN0X2pzb25fcGFyc2VyIFwKKwkJICB0ZXN0X2xpc3Rlbl9ub3RpZnkgXAogCQkgIHRlc3RfbGZp bmQgXAogCQkgIHRlc3RfbHdsb2NrX3RyYW5jaGVzIFwKIAkJICB0ZXN0X21pc2MgXApkaWZmIC0t Z2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy9tZXNvbi5idWlsZCBiL3NyYy90ZXN0L21vZHVsZXMvbWVz b24uYnVpbGQKaW5kZXggMTRmYzc2MWM0Y2YuLjZhZjMzNDQ4ZDdiIDEwMDY0NAotLS0gYS9zcmMv dGVzdC9tb2R1bGVzL21lc29uLmJ1aWxkCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvbWVzb24uYnVp bGQKQEAgLTI4LDYgKzI4LDcgQEAgc3ViZGlyKCd0ZXN0X2dpbnBvc3RpbmdsaXN0JykKIHN1YmRp cigndGVzdF9pbnQxMjgnKQogc3ViZGlyKCd0ZXN0X2ludGVnZXJzZXQnKQogc3ViZGlyKCd0ZXN0 X2pzb25fcGFyc2VyJykKK3N1YmRpcigndGVzdF9saXN0ZW5fbm90aWZ5JykKIHN1YmRpcigndGVz dF9sZmluZCcpCiBzdWJkaXIoJ3Rlc3RfbHdsb2NrX3RyYW5jaGVzJykKIHN1YmRpcigndGVzdF9t aXNjJykKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9saXN0ZW5fbm90aWZ5Ly5n aXRpZ25vcmUgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfbGlzdGVuX25vdGlmeS8uZ2l0aWdub3Jl Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi41ZGNiM2ZmOTcyMwotLS0g L2Rldi9udWxsCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9saXN0ZW5fbm90aWZ5Ly5naXRp Z25vcmUKQEAgLTAsMCArMSw0IEBACisjIEdlbmVyYXRlZCBzdWJkaXJlY3RvcmllcworL2xvZy8K Ky9yZXN1bHRzLworL3RtcF9jaGVjay8KZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvdGVz dF9saXN0ZW5fbm90aWZ5L01ha2VmaWxlIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2xpc3Rlbl9u b3RpZnkvTWFrZWZpbGUKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLmMx ZWI0ZmRlMzcwCi0tLSAvZGV2L251bGwKKysrIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2xpc3Rl bl9ub3RpZnkvTWFrZWZpbGUKQEAgLTAsMCArMSwxOSBAQAorIyBzcmMvdGVzdC9tb2R1bGVzL3Rl c3RfbGlzdGVuX25vdGlmeS9NYWtlZmlsZQorCitNT0RVTEUgPSB0ZXN0X2xpc3Rlbl9ub3RpZnkK K1BHRklMRURFU0MgPSAidGVzdF9saXN0ZW5fbm90aWZ5IC0gcmVncmVzc2lvbiB0ZXN0aW5nIGZv ciBMSVNURU4vTk9USUZZIHN1cHBvcnQiCisKK1RBUF9URVNUUyA9IDEKKworRVhUUkFfSU5TVEFM TD1zcmMvdGVzdC9tb2R1bGVzL3hpZF93cmFwYXJvdW5kCisKK2lmZGVmIFVTRV9QR1hTCitQR19D T05GSUcgPSBwZ19jb25maWcKK1BHWFMgOj0gJChzaGVsbCAkKFBHX0NPTkZJRykgLS1wZ3hzKQor aW5jbHVkZSAkKFBHWFMpCitlbHNlCitzdWJkaXIgPSBzcmMvdGVzdC9tb2R1bGVzL3Rlc3RfbGlz dGVuX25vdGlmeQordG9wX2J1aWxkZGlyID0gLi4vLi4vLi4vLi4KK2luY2x1ZGUgJCh0b3BfYnVp bGRkaXIpL3NyYy9NYWtlZmlsZS5nbG9iYWwKK2luY2x1ZGUgJCh0b3Bfc3JjZGlyKS9jb250cmli L2NvbnRyaWItZ2xvYmFsLm1rCitlbmRpZgpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy90 ZXN0X2xpc3Rlbl9ub3RpZnkvbWVzb24uYnVpbGQgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfbGlz dGVuX25vdGlmeS9tZXNvbi5idWlsZApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMC4uZWJmOTQ0NDEwOGEKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdGVzdC9tb2R1bGVzL3Rl c3RfbGlzdGVuX25vdGlmeS9tZXNvbi5idWlsZApAQCAtMCwwICsxLDEzIEBACisjIENvcHlyaWdo dCAoYykgMjAyMi0yMDI1LCBQb3N0Z3JlU1FMIEdsb2JhbCBEZXZlbG9wbWVudCBHcm91cAorCit0 ZXN0cyArPSB7CisgICduYW1lJzogJ3Rlc3RfbGlzdGVuX25vdGlmeScsCisgICdzZCc6IG1lc29u LmN1cnJlbnRfc291cmNlX2RpcigpLAorICAnYmQnOiBtZXNvbi5jdXJyZW50X2J1aWxkX2Rpcigp LAorICAndGFwJzogeworICAgICd0ZXN0cyc6IFsKKyAgICAgICd0LzAwMV94aWRfZnJlZXplLnBs JworICAgIF0sCisgIH0sCit9CisKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9s aXN0ZW5fbm90aWZ5L3QvMDAxX3hpZF9mcmVlemUucGwgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rf bGlzdGVuX25vdGlmeS90LzAwMV94aWRfZnJlZXplLnBsCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwLi5jNTU1M2Q2Yzc5MgotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0 L21vZHVsZXMvdGVzdF9saXN0ZW5fbm90aWZ5L3QvMDAxX3hpZF9mcmVlemUucGwKQEAgLTAsMCAr MSw4OSBAQAorIyBDb3B5cmlnaHQgKGMpIDIwMjQtMjAyNSwgUG9zdGdyZVNRTCBHbG9iYWwgRGV2 ZWxvcG1lbnQgR3JvdXAKKworIyBUZXN0IHRoYXQgVkFDVVVNIEZSRUVaRSBkb24ndCByZW1vdmUg Y2xvZyBmaWxlcyB0aGF0IGFyZSBuZWVkZWQgdG8gY2hlY2sgdGhlCisjIHRyYW5zYWN0aW9uIHN0 YXR1cyBvZiBub3RpZmljYXRpb25zIHRoYXQgYXJlIG9uIHRoZSBMSVNURU4vTk9USUZZIHF1ZXVl CisjIGR1cmluZyBpdHMgZXhlY3V0aW9uLiBUaGUgVkFDVVVNIEZSRUVaRSBvcGVyYXRpb24gc2hv dWxkIGNoZWNrIHRoZSBvbGRlc3QgeGlkCisjIG9uIHRoZSBxdWV1ZSBkdXJpbmcgZXhlY3V0aW9u LgordXNlIHN0cmljdDsKK3VzZSB3YXJuaW5ncyBGQVRBTCA9PiAnYWxsJzsKK3VzZSBQb3N0Z3Jl U1FMOjpUZXN0OjpDbHVzdGVyOwordXNlIFBvc3RncmVTUUw6OlRlc3Q6OlV0aWxzOwordXNlIFRl c3Q6Ok1vcmU7CisKK215ICRub2RlID0gUG9zdGdyZVNRTDo6VGVzdDo6Q2x1c3Rlci0+bmV3KCdu b2RlJyk7Ciskbm9kZS0+aW5pdDsKKyRub2RlLT5zdGFydDsKKworIyBDaGVjayBpZiB0aGUgZXh0 ZW5zaW9uIHhpZF93cmFwYXJvdW5kIGlzIGF2YWlsYWJsZSwgYXMgaXQgbWF5IGJlCisjIHBvc3Np YmxlIHRoYXQgdGhpcyBzY3JpcHQgaXMgcnVuIHdpdGggaW5zdGFsbGNoZWNrLCB3aGVyZSB0aGUg bW9kdWxlCisjIHdvdWxkIG5vdCBiZSBpbnN0YWxsZWQgYnkgZGVmYXVsdC4KK2lmICghJG5vZGUt PmNoZWNrX2V4dGVuc2lvbigneGlkX3dyYXBhcm91bmQnKSkKK3sKKwlwbGFuIHNraXBfYWxsID0+ ICdFeHRlbnNpb24geGlkX3dyYXBhcm91bmQgbm90IGluc3RhbGxlZCc7Cit9CisKKyMgU2V0dXAK KyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgJ0NSRUFURSBFWFRFTlNJT04geGlkX3dyYXBh cm91bmQnKTsKKyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywKKwknQ1JFQVRFIFRBQkxFIHQg QVMgU0VMRUNUIGcgQVMgYSwgZysyIEFTIGIgZnJvbSBnZW5lcmF0ZV9zZXJpZXMoMSwxMCkgZzsn CispOworJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMnLAorCSdBTFRFUiBEQVRBQkFTRSB0ZW1w bGF0ZTAgV0lUSCBBTExPV19DT05ORUNUSU9OUyB0cnVlJyk7CisKKyMgLS0tIFN0YXJ0IFNlc3Np b24gMSBhbmQgbGVhdmUgaXQgaWRsZSBpbiB0cmFuc2FjdGlvbgorbXkgJHBzcWxfc2Vzc2lvbjEg PSAkbm9kZS0+YmFja2dyb3VuZF9wc3FsKCdwb3N0Z3JlcycpOworJHBzcWxfc2Vzc2lvbjEtPnF1 ZXJ5X3NhZmUoJ2xpc3RlbiBzOycsICJTZXNzaW9uIDEgbGlzdGVucyB0byAncyciKTsKKyRwc3Fs X3Nlc3Npb24xLT5xdWVyeV9zYWZlKCdiZWdpbjsnLCAiU2Vzc2lvbiAxIHN0YXJ0cyBhIHRyYW5z YWN0aW9uIik7CisKKyMgLS0tIFNlc3Npb24gMiwgbXVsdGlwbGUgbm90aWZ5J3MsIGFuZCBjb21t aXQgLS0tCitmb3IgbXkgJGkgKDEgLi4gMTApCit7CisJJG5vZGUtPnNhZmVfcHNxbCgKKwkJJ3Bv c3RncmVzJywgIgorCQlCRUdJTjsKKwkJTk9USUZZIHMsICckaSc7CisJCUNPTU1JVDsiKTsKK30K KworIyBDb25zdW1lIGVub3VnaCBYSURzIHRvIHRyaWdnZXIgdHJ1bmNhdGlvbgorJG5vZGUtPnNh ZmVfcHNxbCgncG9zdGdyZXMnLCAnc2VsZWN0IGNvbnN1bWVfeGlkcygxMDUwMDAwKTsnKTsKKwor IyBFeGVjdXRlIHVwZGF0ZSBzbyB0aGUgZnJvemVuIHhpZCBvZiAidCIgdGFibGUgaXMgdXBkYXRl ZCB0byBhIHhpZCBncmVhdGVyCisjIHRoYW4gY29uc3VtZV94aWRzKCkgcmVzdWx0Ciskbm9kZS0+ c2FmZV9wc3FsKCdwb3N0Z3JlcycsICdVUERBVEUgdCBTRVQgYSA9IGErYjsnKTsKKworIyBSZW1l bWJlciBjdXJyZW50IGRhdGZyb3plbnhpZCBiZWZvcmUgdmFjdXVtIGZyZWV6ZSB0byBlbnN1cmUg dGhhdCBpdCBpcyBhZHZhbmNlZC4KK215ICRkYXRhZnJvbnplbnhpZCA9ICRub2RlLT5zYWZlX3Bz cWwoJ3Bvc3RncmVzJywgInNlbGVjdCBkYXRmcm96ZW54aWQgZnJvbSBwZ19kYXRhYmFzZSB3aGVy ZSBkYXRuYW1lID0gJ3Bvc3RncmVzJyIpOworCisjIEV4ZWN1dGUgdmFjdXVtIGZyZWV6ZSBvbiBh bGwgZGF0YWJhc2VzCiskbm9kZS0+Y29tbWFuZF9vayhbICd2YWN1dW1kYicsICctLWFsbCcsICct LWZyZWV6ZScsICctLXBvcnQnLCAkbm9kZS0+cG9ydCBdLAorCSJ2YWN1dW1kYiAtLWFsbCAtLWZy ZWV6ZSIpOworCisjIEdldCB0aGUgbmV3IGRhdGZyb3plbnhpZCBhZnRlciB2YWN1dW0gZnJlZXpl IHRvIGVuc3VyZSB0aGF0IGlzIG5vdCBhZHZhbmNlZAorIyB0byBhIHZhbHVlIGdyZWF0ZXIgdGhh biB0aGUgeGlkIHVzZWQgdG8gc2VuZCB0aGUgbm90aWZpY2F0aW9ucy4KK215ICRkYXRhZnJvbnpl bnhpZF9mcmVlemUgPSAkbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsICJzZWxlY3QgZGF0ZnJv emVueGlkIGZyb20gcGdfZGF0YWJhc2Ugd2hlcmUgZGF0bmFtZSA9ICdwb3N0Z3JlcyciKTsKK3By aW50KCJcblxuJGRhdGFmcm9uemVueGlkIDwgJGRhdGFmcm9uemVueGlkX2ZyZWV6ZVxuXG4iKTsK K29rKCRkYXRhZnJvbnplbnhpZCA8ICRkYXRhZnJvbnplbnhpZF9mcmVlemUsICdkYXRmcm96ZW54 aWQgaXMgbm90IGZ1bGx5IGFkdmFuY2VkJyk7CisKKyMgT24gU2Vzc2lvbiAxLCBjb21taXQgYW5k IGVuc3VyZSB0aGF0IHRoZSBhbGwgbm90aWZpY2F0aW9ucyBpcyByZWNlaXZlZAorbXkgJHJlcyA9 ICRwc3FsX3Nlc3Npb24xLT5xdWVyeV9zYWZlKCdjb21taXQ7JywgImNvbW1pdCBsaXN0ZW4gczsi KTsKK215ICRub3RpZmljYXRpb25zX2NvdW50ID0gMDsKK2ZvcmVhY2ggbXkgJGkgKHNwbGl0KCdc bicsICRyZXMpKQoreworCSRub3RpZmljYXRpb25zX2NvdW50Kys7CisJbGlrZSgkaSwgcXIvQXN5 bmNocm9ub3VzIG5vdGlmaWNhdGlvbiAicyIgd2l0aCBwYXlsb2FkICIkbm90aWZpY2F0aW9uc19j b3VudCIgcmVjZWl2ZWQvKTsKK30KK2lzKCRub3RpZmljYXRpb25zX2NvdW50LCAxMCwgJ3JlY2Vp dmVkIGFsbCBjb21taXR0ZWQgbm90aWZpY2F0aW9ucycpOworCisjIEV4ZWN1dGUgdmFjdXVtIGZy ZWV6ZSBvbiBhbGwgZGF0YWJhc2VzIGFuZCBlbnN1cmUgdGhhdCB0aGUgZGF0YWZyb3plbnhpZCBp cyBhZHZhbmNlZAorCiskZGF0YWZyb256ZW54aWQgPSAkbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3Jl cycsICJzZWxlY3QgZGF0ZnJvemVueGlkIGZyb20gcGdfZGF0YWJhc2Ugd2hlcmUgZGF0bmFtZSA9 ICdwb3N0Z3JlcyciKTsKKworJG5vZGUtPmNvbW1hbmRfb2soWyAndmFjdXVtZGInLCAnLS1hbGwn LCAnLS1mcmVlemUnLCAnLS1wb3J0JywgJG5vZGUtPnBvcnQgXSwKKwkidmFjdXVtZGIgLS1hbGwg LS1mcmVlemUiKTsKKworJGRhdGFmcm9uemVueGlkX2ZyZWV6ZSA9ICRub2RlLT5zYWZlX3BzcWwo J3Bvc3RncmVzJywgInNlbGVjdCBkYXRmcm96ZW54aWQgZnJvbSBwZ19kYXRhYmFzZSB3aGVyZSBk YXRuYW1lID0gJ3Bvc3RncmVzJyIpOworCitvaygkZGF0YWZyb256ZW54aWRfZnJlZXplID4gJGRh dGFmcm9uemVueGlkLCAiZGF0ZnJvemVueGlkIGlzIGFkdmFuY2VkOiAkZGF0YWZyb256ZW54aWRf ZnJlZXplID4gJGRhdGFmcm9uemVueGlkIik7CisKK2RvbmVfdGVzdGluZygpOwpkaWZmIC0tZ2l0 IGEvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QgYi9zcmMvdG9vbHMvcGdpbmRlbnQv dHlwZWRlZnMubGlzdAppbmRleCA0M2ZlM2JjZDU5My4uYThhYTEzNjUzODIgMTAwNjQ0Ci0tLSBh L3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0CisrKyBiL3NyYy90b29scy9wZ2luZGVu dC90eXBlZGVmcy5saXN0CkBAIC01OCw2ICs1OCw3IEBAIEFnZ3JlZgogQWdncmVnYXRlSW5zdHJ1 bWVudGF0aW9uCiBBbGVuU3RhdGUKIEFsaWFzCitBbGlnbmVkUXVldWVFbnRyeVBhZ2UKIEFsbG9j QmxvY2sKIEFsbG9jRnJlZUxpc3RMaW5rCiBBbGxvY1BvaW50ZXIKLS0gCjIuNTEuMAoK --5afb61ee74a4f0c9a936380f4a6aae9450e55be349e1f63adb787a1e31bb Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=v11-0002-Add-more-tests-for-listen-notify-vacuum-freeze.patch Content-Type: text/plain; charset=utf-8; name=v11-0002-Add-more-tests-for-listen-notify-vacuum-freeze.patch RnJvbSBjYWQzOGViM2MyNjdhYzFkNDZkZmJkMWRhNTQ2NTAwYzA5ODVjMjhiIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXRoZXVzIEFsY2FudGFyYSA8bXRocy5kZXZAcG0ubWU+CkRh dGU6IEZyaSwgMjQgT2N0IDIwMjUgMjE6MTQ6MzggLTAzMDAKU3ViamVjdDogW1BBVENIIHYxMSAy LzJdIEFkZCBtb3JlIHRlc3RzIGZvciBsaXN0ZW4gbm90aWZ5IHZhY3V1bSBmcmVlemUKCkF1dGhv cjogQXJzZW5peSBNdWtoaW4gPGFyc2VuaXkubXVraGluLmRldkBnbWFpbC5jb20KLS0tCiAuLi4v bW9kdWxlcy90ZXN0X2xpc3Rlbl9ub3RpZnkvbWVzb24uYnVpbGQgICAgfCAgMyArLQogLi4uL3Qv MDAyX2Fib3J0ZWRfdHhfbm90aWZpZXMucGwgICAgICAgICAgICAgIHwgODQgKysrKysrKysrKysr KysrKysrKwogMiBmaWxlcyBjaGFuZ2VkLCA4NiBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0p CiBjcmVhdGUgbW9kZSAxMDA2NDQgc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2xpc3Rlbl9ub3RpZnkv dC8wMDJfYWJvcnRlZF90eF9ub3RpZmllcy5wbAoKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVs ZXMvdGVzdF9saXN0ZW5fbm90aWZ5L21lc29uLmJ1aWxkIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0 X2xpc3Rlbl9ub3RpZnkvbWVzb24uYnVpbGQKaW5kZXggZWJmOTQ0NDEwOGEuLmE2ODA1MmNkMzUz IDEwMDY0NAotLS0gYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfbGlzdGVuX25vdGlmeS9tZXNvbi5i dWlsZAorKysgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfbGlzdGVuX25vdGlmeS9tZXNvbi5idWls ZApAQCAtNiw3ICs2LDggQEAgdGVzdHMgKz0gewogICAnYmQnOiBtZXNvbi5jdXJyZW50X2J1aWxk X2RpcigpLAogICAndGFwJzogewogICAgICd0ZXN0cyc6IFsKLSAgICAgICd0LzAwMV94aWRfZnJl ZXplLnBsJworICAgICAgJ3QvMDAxX3hpZF9mcmVlemUucGwnLAorICAgICAgJ3QvMDAyX2Fib3J0 ZWRfdHhfbm90aWZpZXMucGwnCiAgICAgXSwKICAgfSwKIH0KZGlmZiAtLWdpdCBhL3NyYy90ZXN0 L21vZHVsZXMvdGVzdF9saXN0ZW5fbm90aWZ5L3QvMDAyX2Fib3J0ZWRfdHhfbm90aWZpZXMucGwg Yi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfbGlzdGVuX25vdGlmeS90LzAwMl9hYm9ydGVkX3R4X25v dGlmaWVzLnBsCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi40NjRjOTU5 YTVhOQotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9saXN0ZW5fbm90 aWZ5L3QvMDAyX2Fib3J0ZWRfdHhfbm90aWZpZXMucGwKQEAgLTAsMCArMSw4NCBAQAorIyBDb3B5 cmlnaHQgKGMpIDIwMjQtMjAyNSwgUG9zdGdyZVNRTCBHbG9iYWwgRGV2ZWxvcG1lbnQgR3JvdXAK KwordXNlIHN0cmljdDsKK3VzZSB3YXJuaW5ncyBGQVRBTCA9PiAnYWxsJzsKK3VzZSBGaWxlOjpQ YXRoIHF3KG1rcGF0aCk7Cit1c2UgUG9zdGdyZVNRTDo6VGVzdDo6Q2x1c3RlcjsKK3VzZSBQb3N0 Z3JlU1FMOjpUZXN0OjpVdGlsczsKK3VzZSBUZXN0OjpNb3JlOworCitpZiAoISRFTlZ7UEdfVEVT VF9FWFRSQX0gfHwgJEVOVntQR19URVNUX0VYVFJBfSAhfiAvXGJsaXN0ZW5fbm90aWZ5XGIvKQor eworCXBsYW4gc2tpcF9hbGwgPT4gInRlc3QgbGlzdGVuX25vdGlmeSBub3QgZW5hYmxlZCBpbiBQ R19URVNUX0VYVFJBIjsKK30KKworIyBUZXN0IGNoZWNrcyB0aGF0IGxpc3RlbmVycyBkbyBub3Qg cmVjZWl2ZSBub3RpZmljYXRpb25zIGZyb20gYWJvcnRlZAorIyB0cmFuc2FjdGlvbiBldmVuIGlm IG5vdGlmaWNhdGlvbnMgaGF2ZSBiZWVuIGFkZGVkIHRvIHRoZSBsaXN0ZW4vbm90aWZ5CisjIHF1 ZXVlLiBUbyByZXByb2R1Y2UgaXQgd2UgdXNlIHRoZSBmYWN0IHRoYXQgc2VyaWFsaXphYmxlIGNv bmZsaWN0cworIyBhcmUgY2hlY2tlZCBhZnRlciB0eCBhZGRzIG5vdGlmaWNhdGlvbnMgdG8gdGhl IHF1ZXVlLgorCitteSAkbm9kZSA9IFBvc3RncmVTUUw6OlRlc3Q6OkNsdXN0ZXItPm5ldygnbm9k ZScpOworJG5vZGUtPmluaXQ7Ciskbm9kZS0+c3RhcnQ7CisKKyMgU2V0dXAKKyRub2RlLT5zYWZl X3BzcWwoJ3Bvc3RncmVzJywgJ0NSRUFURSBUQUJMRSB0MSAoYSBiaWdzZXJpYWwpOycpOworCisj IExpc3RlbmVyCitteSAkcHNxbF9saXN0ZW5lciA9ICRub2RlLT5iYWNrZ3JvdW5kX3BzcWwoJ3Bv c3RncmVzJyk7CiskcHNxbF9saXN0ZW5lci0+cXVlcnlfc2FmZSgnTElTVEVOIGNoOycpOworCisj IFNlc3Npb24xLiBTdGFydCBTRVJJQUxJWkFCTEUgdHggYW5kIGFkZCBhIG5vdGlmaWNhdGlvbi4K K215ICRwc3FsX3Nlc3Npb24xID0gJG5vZGUtPmJhY2tncm91bmRfcHNxbCgncG9zdGdyZXMnKTsK KyRwc3FsX3Nlc3Npb24xLT5xdWVyeV9zYWZlKCIKKwlCRUdJTiBJU09MQVRJT04gTEVWRUwgU0VS SUFMSVpBQkxFOworCVNFTEVDVCAqIEZST00gdDE7CisJSU5TRVJUIElOVE8gdDEgREVGQVVMVCBW QUxVRVM7CisJTk9USUZZIGNoLCdjb21taXR0ZWRfMCc7CisJTk9USUZZIGNoLCdjb21taXR0ZWRf MSc7CisiKTsKKworIyBTZXNzaW9uMi4gU3RhcnQgU0VSSUFMSVpBQkxFIHR4LCBhZGQgYSBub3Rp ZmljYXRpb24gYW5kIGludHJvZHVjZSBhIGNvbmZsaWN0CisjIHdpdGggc2Vzc2lvbjEuCitteSAk cHNxbF9zZXNzaW9uMiA9ICRub2RlLT5iYWNrZ3JvdW5kX3BzcWwoJ3Bvc3RncmVzJywgb25fZXJy b3Jfc3RvcCA9PiAwKTsKKyRwc3FsX3Nlc3Npb24yLT5xdWVyeV9zYWZlKCIKKwlCRUdJTiBJU09M QVRJT04gTEVWRUwgU0VSSUFMSVpBQkxFOworCVNFTEVDVCAqIEZST00gdDE7CisJSU5TRVJUIElO VE8gdDEgREVGQVVMVCBWQUxVRVM7CisiKTsKKworIyBTZW5kIG5vdGlmaWNhdGlvbnMgdGhhdCBz aG91bGQgbm90IGJlIGV2ZW50dWFsbHkgZGVsaXZlcmVkLCBhcyBzZXNzaW9uMgorIyB0cmFuc2Fj dGlvbiB3aWxsIGJlIGFib3J0ZWQuCitteSAkbWVzc2FnZSA9ICdhYm9ydGVkXycgLiAnYScgeCAx MDAwOworZm9yIChteSAkaSA9IDA7ICRpIDwgMTA7ICRpKyspIHsKKyAgICAkcHNxbF9zZXNzaW9u Mi0+cXVlcnlfc2FmZSgiTk9USUZZIGNoLCAnJGkkbWVzc2FnZSciKTsKK30KKworIyBTZXNzaW9u MSBzaG91bGQgYmUgY29tbWl0dGVkIHN1Y2Nlc3NmdWxseS4gTGlzdGVuZXJzIG11c3QgcmVjZWl2 ZSBzZXNzaW9uMQorIyBub3RpZmljYXRpb25zLgorJHBzcWxfc2Vzc2lvbjEtPnF1ZXJ5X3NhZmUo IkNPTU1JVDsiKTsKKworIyBTZXNzaW9uMiBzaG91bGQgYmUgYWJvcnRlZCBkdWUgdG8gdGhlIGNv bmZsaWN0IHdpdGggc2Vzc2lvbjEuIFRyYW5zYWN0aW9uCisjIGlzIGFib3J0ZWQgYWZ0ZXIgYWRk aW5nIG5vdGlmaWNhdGlvbnMgdG8gdGhlIGxpc3Rlbi9ub3RpZnkgcXVldWUsIGJ1dAorIyBsaXN0 ZW5lcnMgc2hvdWxkIG5vdCByZWNlaXZlIHNlc3Npb24yIG5vdGlmaWNhdGlvbnMuCiskcHNxbF9z ZXNzaW9uMi0+cXVlcnkoIkNPTU1JVDsiKTsKKworIyBzZW5kIG1vcmUgbm90aWZpY2F0aW9ucyBh ZnRlciBhYm9ydGVkCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsICJOT1RJRlkgY2gsICdj b21taXR0ZWRfMic7Iik7Ciskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsICJOT1RJRlkgY2gs ICdjb21taXR0ZWRfMyc7Iik7CisKKyMgZmV0Y2ggbm90aWZpY2F0aW9ucworbXkgJHJlcyA9ICRw c3FsX2xpc3RlbmVyLT5xdWVyeV9zYWZlKCdiZWdpbjsgY29tbWl0OycpOworCisjIGNoZWNrIHJl Y2VpdmVkIG5vdGlmaWNhdGlvbnMKK215IEBsaW5lcyA9IHNwbGl0KCdcbicsICRyZXMpOworaXMo QGxpbmVzLCA0LCAncmVjZWl2ZWQgYWxsIGNvbW1pdHRlZCBub3RpZmljYXRpb25zJyk7Citmb3Ig KG15ICRpID0gMDsgJGkgPCA0OyAkaSsrKSB7CisgICAgbGlrZSgkbGluZXNbJGldLCBxci9Bc3lu Y2hyb25vdXMgbm90aWZpY2F0aW9uICJjaCIgd2l0aCBwYXlsb2FkICJjb21taXR0ZWRfJGkiIHJl Y2VpdmVkLyk7Cit9CisKK29rKCRwc3FsX2xpc3RlbmVyLT5xdWl0KTsKK29rKCRwc3FsX3Nlc3Np b24xLT5xdWl0KTsKK29rKCRwc3FsX3Nlc3Npb24yLT5xdWl0KTsKKworZG9uZV90ZXN0aW5nKCk7 Ci0tIAoyLjUxLjAKCg== --5afb61ee74a4f0c9a936380f4a6aae9450e55be349e1f63adb787a1e31bb--