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 1vAbYZ-003pRF-6s for pgsql-hackers@arkaria.postgresql.org; Sun, 19 Oct 2025 22:07:14 +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 1vAbYY-00CoVJ-4n for pgsql-hackers@arkaria.postgresql.org; Sun, 19 Oct 2025 22:07:13 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1vAbYX-00CoV9-8C for pgsql-hackers@lists.postgresql.org; Sun, 19 Oct 2025 22:07:12 +0000 Received: from fout-a5-smtp.messagingengine.com ([103.168.172.148]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vAbYT-0037Fx-0d for pgsql-hackers@postgresql.org; Sun, 19 Oct 2025 22:07:11 +0000 Received: from phl-compute-04.internal (phl-compute-04.internal [10.202.2.44]) by mailfout.phl.internal (Postfix) with ESMTP id A2174EC0122; Sun, 19 Oct 2025 18:07:06 -0400 (EDT) Received: from phl-imap-03 ([10.202.2.93]) by phl-compute-04.internal (MEProxy); Sun, 19 Oct 2025 18:07:06 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=compiler.org; h= cc:cc:content-type:content-type:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:subject :subject:to:to; s=fm2; t=1760911626; x=1760998026; bh=imQzXXpAWC 3fEnVXnX/fWFpL4vttFNDl6egQimIeV0Q=; b=RXiKSF2Z4GI4baG4R/9nbfCTnT 2kROCv2+x1Fql/wBT/MmEXfbCj+pUXCUAndn3lgtOPS8GEYnxf4wpAe6gRrXdW7U ewWZFjVeqdDDWji7k1xowyK/l3nFBraf6rVLvTdgpNoqSwDsBOkSjFKDVPbudfZ/ pHp3zmB2tBm8xAgvxtiVFcMyg2RdkrNKUDl/aSpaDUj13C6oNPROKA6BpJ0SqcRo o/KMnnXynHDd0DJRQnAWmKXVxoK/DlqPvK0kd5YVYAEDgPy+TXrIiqDtsYvYMlnS ovhMjnTCzCLPnjr2gPNRf4kjQS4+mxb9QfG4cSj8DNpNip83eoRZfT5Kv9eQ== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-type:content-type:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:subject:subject:to :to:x-me-proxy:x-me-sender:x-me-sender:x-sasl-enc; s=fm2; t= 1760911626; x=1760998026; bh=imQzXXpAWC3fEnVXnX/fWFpL4vttFNDl6eg QimIeV0Q=; b=WXDV30RQk2VrR8fujaiTLspXz8qTS2kugyUidlRXxqRgrJQovWA dgasP8dHWXsV6MaLVJ2vdddsZzB1Zz7yxGkW2g/Aw2JSm5sTB4pbNgSdtae+clIO PPo7wyBtkV0DKEjOtC6fsBXe2Cp2IPEOkBXf6/dw0ASVSrtL46J9fdUBwoD+cUHl HT4ZUUEkfQCJwZLiXq5e/p7SMdhpc8+nRc7Exs1yEb/6vj4rUPwCgjevaby15Bnh s7c/huL1nJ4O2dLwE14Tco55M1MGLvqs2Y6w8KhnxOXOsoVq+8sFE4EHCp3z26RB aKulaCndCG2EG5FVyrB8WqSVKFaIcS22BMQ== X-ME-Sender: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgeeffedrtdeggddufeeitdelucetufdoteggodetrf dotffvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfurfetoffkrfgpnffqhgenuceu rghilhhouhhtmecufedttdenucenucfjughrpefoggffhffvvefkjghfufgtsehmtderre ertddtnecuhfhrohhmpedflfhovghlucflrggtohgsshhonhdfuceojhhovghlsegtohhm phhilhgvrhdrohhrgheqnecuggftrfgrthhtvghrnhepfffgleffffdvhefhieegfeeije dujedvieeuveeugefgveeukeevieethefhteeinecuvehluhhsthgvrhfuihiivgeptden ucfrrghrrghmpehmrghilhhfrhhomhepjhhovghlsegtohhmphhilhgvrhdrohhrghdpnh gspghrtghpthhtohepfedpmhhouggvpehsmhhtphhouhhtpdhrtghpthhtoheplhhirdgv vhgrnhdrtghhrghosehgmhgrihhlrdgtohhmpdhrtghpthhtohepphhgshhqlhdqhhgrtg hkvghrshesphhoshhtghhrvghsqhhlrdhorhhgpdhrtghpthhtohepthhglhesshhsshdr phhghhdrphgrrdhush X-ME-Proxy: Feedback-ID: ic6394509:Fastmail Received: by mailuser.phl.internal (Postfix, from userid 501) id E5D0018E0054; Sun, 19 Oct 2025 18:07:05 -0400 (EDT) X-Mailer: MessagingEngine.com Webmail Interface MIME-Version: 1.0 X-ThreadId: AE1r89ybsZ1g Date: Mon, 20 Oct 2025 00:06:45 +0200 From: "Joel Jacobson" To: "Tom Lane" Cc: "Chao Li" , pgsql-hackers Message-Id: In-Reply-To: <1547585.1760645808@sss.pgh.pa.us> References: <6899c044-4a82-49be-8117-e6f669765f7e@app.fastmail.com> <165530.1752362320@sss.pgh.pa.us> <02a7cd37-e2fc-4212-8b19-f8c239c95fb8@app.fastmail.com> <96f00bf1-cc9d-4520-9d02-9e14e7767c88@app.fastmail.com> <30c2aa7d-dd6c-4b68-a2e4-f217a1a34acf@app.fastmail.com> <0b4d402a-9ac2-4aa8-acf8-8231dbe579ea@app.fastmail.com> <3095599.1758644879@sss.pgh.pa.us> <0dc6a2cc-5216-4dc1-9dd2-430cafc6095b@app.fastmail.com> <52CC167F-763B-4ECA-B0B4-DAB381816828@gmail.com> <9186C6D0-F7A9-482A-9183-89E530B57E36@gmail.com> <1073593.1759423179@sss.pgh.pa.us> <4bd5e6c4-6fa7-44bb-869d-59a32a331fa8@app.fastmail.com> <85828f29-e72e-4400-94f3-9a69bc8dc239@app.fastmail.com> <2495353.1759860890@sss.pgh.pa.us> <8aeae418-92a6-4bbd-9c06-9574c79e59f7@app.fastmail.com> <2531672.1759868124@sss.pgh.pa.us> <474efa78-337c-41cd-a73a-f845a0115109@app.fastmail.com> <2749343.1759949176@sss.pgh.pa.us> <8bfca2be-1ec0-4e15-aafb-0b7b661fe936@app.fastmail.com> <9eba307f-f2fb-48f0-9507-2e197f39ef9e@app.fastmail.com> <8c71183a-0d28-4bcf-a806-78446ff95404@app.fastmail.com> <1009807.1760476747@sss.pgh.pa.us> <1F7227F5-C33D-4E2C-8511-33F1468590D0@gmail.com> <0a5a20d3-4621-46b3-b2ab-903f63a20dea@app.fastmail.com> <6F913129-ABEF-4004-AAF3-F22FC34!29AE8@gmail.com> <1547585.1760645808@sss.pgh.pa.us> Subject: Re: Optimize LISTEN/NOTIFY Content-Type: multipart/mixed; boundary=ce7d73ebaa3f43ad826ea7bd8f210476 List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --ce7d73ebaa3f43ad826ea7bd8f210476 Content-Type: text/plain Content-Transfer-Encoding: 7bit On Thu, Oct 16, 2025, at 22:16, Tom Lane wrote: > "Joel Jacobson" writes: >> On Thu, Oct 16, 2025, at 20:16, Joel Jacobson wrote: >>> Building pendingNotifyChannels is O(N^2) yes, but how large N is >>> realistic here? > >> I agree this looks like a real problem, since I guess it's not >> completely unthinkable someone might have >> some kind of trigger on a table, that could fire off NOTIFY >> for each row, possibly causing hundreds of thousands of >> notifies in the same db txn. > > We already de-duplicate identical NOTIFY operations for exactly that > reason (cf. AsyncExistsPendingNotify). However, non-identical NOTIFYs > obviously can't be merged. > > I wonder whether we could adapt that de-duplication logic so that > it produces a list of unique channel names in addition to a list > of unique NOTIFY events. One way could be a list/hashtable of > channels used, and for each one a list/hashtable of unique payloads, > rather than the existing single-level list/hashtable. Thanks for the great idea! Yes, this was indeed possible. 0002-optimize_listen_notify-v20.patch: * Added channelHashtab field, created and updated together with hashtab. If we have channelHashtab, it's used within PreCommit_Notify to quickly build pendingNotifyChannelsl. In this email, I'm also answering to the feedback from Arseniy Mukhin, and I've based the alt1, alt2, alt3 .txt patches on top of v20. On Sat, Oct 18, 2025, at 18:41, Arseniy Mukhin wrote: > Thank you for the new version and all implementations! Thanks for review and great ideas! >> > I think we can perhaps salvage the idea if we invent a separate >> > "advisory" queue position field, which tells its backend "hey, >> > you could skip as far as here if you want", but is not used for >> > purposes of SLRU truncation. >> >> Above idea is implemented in 0002-optimize_listen_notify-v19-alt1.txt > > pos = QUEUE_BACKEND_POS(i); > > /* Direct advancement for idle backends at the old head */ > if (pendingNotifies != NULL && > QUEUE_POS_EQUAL(pos, queueHeadBeforeWrite)) > { > QUEUE_BACKEND_ADVISORY_POS(i) = queueHeadAfterWrite; > > If we have several notifying backends, it looks like only the first > one will be able to do direct advancement here. Next notifying backend > will fail on QUEUE_POS_EQUAL(pos, queueHeadBeforeWrite) as we don't > wake up the listener and pos will be the same as it was for the first > notifying backend. Right. > It seems that to accumulate direct advancement from > several notifying backends we need to compare queueHeadBeforeWrite > with advisoryPos here. *** 0002-optimize_listen_notify-v20-alt1.txt: * Fixed; compare advisoryPos with queueHeadBeforeWrite instead of pos. > And we also need to advance advisoryPos to the > listener's position after reading if advisoryPos falls behind. * Fixed; set advisoryPos to max(max,advisoryPos) in PG_FINALLY block. * Also noted Exec_ListenPreCommit didn't set advisoryPos to max for the first LISTEN, now fixed. > Minute of brainstorming > > I also thought about a workload that probably frequently can be met. > Let's say we have sequence of notifications: > > F F F T F F F T F F F T > > Here F - notification from the channel we don't care about and T - the opposite. > It seems that after the first 'T' notification it will be more > difficult for notifying backends to do 'direct advancement' as there > will be some lag before the listener reads the notification and > advances its position. Not sure if it's a problem, probably it depends > on the intensity of notifications. Hmm, I realize both the advisoryPos and donePos ideas share a problem; they both require listening backends to wakeup eventually anyway, just to advance the 'pos'. The holy grail would be to avoid this context switching cost entirely, and only need to wakeup listening backends when they are actually interested in the queued notifications. I think the third idea, alt3, is most promising in achieving this goal. > But maybe we can use a bit more > sophisticated data structure here? Something like a list of skip > ranges. Every entry in the list is the range (pos1, pos2) that the > listener can skip during the reading. So instead of advancing > advisoryPos every notifying backend should add skip range to the list. > Notifying backends can merge neighbour ranges (pos1, pos2) & (pos2, > pos3) -> (pos1, pos3). We also can limit the number of entries to 5 > for example. Listeners on their side should clear the list before > reading and skip all ranges from it. What do you think? Is it > overkill? Hmm, maybe, but I'm a bit wary about too much complication. Hopefully there is a simpler solution that avoids the need for this, but sure, if we can't find one, then I'm positive to try this skip ranges idea. >> > Alternatively, split the queue pos >> > into "this is where to read next" and "this is as much as I'm >> > definitively done with", where the second field gets advanced at >> > the end of asyncQueueReadAllNotifications. Not sure which >> > view would be less confusing (in the end I guess they're nearly >> > the same thing, differently explained). >> >> Above idea is implemented in 0002-optimize_listen_notify-v19-alt2.txt >> > > IMHO it's a little bit more confusing than the first option. Two > points I noticed: > > 1) We have a fast path in asyncQueueReadAllNotifications() > > if (QUEUE_POS_EQUAL(pos, head)) > { > /* Nothing to do, we have read all notifications already. */ > return; > } > > Should we update donePos here? It looks like donePos may never be > updated without it. *** 0002-optimize_listen_notify-v20-alt2.txt: * Fixed; update donePos here > 2) In SignalBackends() > > /* Signal backends that have fallen too far behind */ > lag = asyncQueuePageDiff(QUEUE_POS_PAGE(QUEUE_HEAD), > QUEUE_POS_PAGE(pos)); > > if (lag >= QUEUE_CLEANUP_DELAY) > { > pid = QUEUE_BACKEND_PID(i); > Assert(pid != InvalidPid); > > QUEUE_BACKEND_WAKEUP_PENDING(i) = true; > pids[count] = pid; > procnos[count] = i; > count++; > } > > Should we use donePos here as it is responsible for queue truncation now? * Fixed; use donePos here >> > A different line of thought could be to get rid of >> > asyncQueueReadAllNotifications's optimization of moving the >> > queue pos only once, per >> > >> > * (We could alternatively retake NotifyQueueLock and move the position >> > * before handling each individual message, but that seems like too much >> > * lock traffic.) >> > >> > Since we only need shared lock to advance our own queue pos, >> > maybe that wouldn't be too awful. Not sure. >> >> Above idea is implemented in 0002-optimize_listen_notify-v19-alt3.txt >> > > Hmm, it seems we still have the race when in the beginning of > asyncQueueReadAllNotifications we read pos into the local variable and > release the lock. IIUC to avoid the race without introducing another > field here, the listener needs to hold the lock until it updates its > position so that the notifying backend cannot change it concurrently. *** 0002-optimize_listen_notify-v20-alt3.txt: * Fixed; the shared 'pos' is now only updated if the new position is ahead. To me, it looks like alt3 is the winner in terms of simplicity, and is also the winner in my ping-pong benchmark, due to avoiding context switches more effectively than alt1 and alt2. Eager to hear your thoughts! /Joel --ce7d73ebaa3f43ad826ea7bd8f210476 Content-Disposition: attachment; filename*0="0001-optimize_listen_notify-v20.patch" Content-Type: application/octet-stream; name="=?UTF-8?Q?0001-optimize=5Flisten=5Fnotify-v20.patch?=" Content-Transfer-Encoding: base64 RnJvbSBmMzcwOTUyNTA1MjFkMGEyOWQ4MTI5OTdiN2I3OWQ5MzhlZDljODk0IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBKb2VsIEphY29ic29uIDxqb2VsQGNvbXBpbGVyLm9y Zz4KRGF0ZTogV2VkLCA4IE9jdCAyMDI1IDA5OjMwOjU0ICswMjAwClN1YmplY3Q6IFtQQVRD SCAxLzJdIEltcHJvdmUgTElTVEVOL05PVElGWSB0ZXN0IGNvdmVyYWdlCgpUaGlzIGFkZHMg aXNvbGF0aW9uIHRlc3RzIHRvIGNvdmVyIHByZXZpb3VzbHkgdW50ZXN0ZWQgY29kZSBwYXRo czoKCiogQ2hlY2sgc2ltcGxlIE5PVElGWSByZXBhcmVudGluZyB3aGVuIHBhcmVudCBoYXMg bm8gYWN0aW9uCiogQ2hlY2sgTElTVEVOIHJlcGFyZW50aW5nIGluIHN1YnRyYW5zYWN0aW9u CiogQ2hlY2sgTElTVEVOIG1lcmdlIHBhdGggd2hlbiBib3RoIG91dGVyIGFuZCBpbm5lciB0 cmFuc2FjdGlvbnMgaGF2ZSBhY3Rpb25zCiogQ2hlY2sgTElTVEVOIGFib3J0IHBhdGggKFJP TExCQUNLIFRPIFNBVkVQT0lOVCBkaXNjYXJkcyBwZW5kaW5nIGFjdGlvbnMpCiogQ2hlY2sg bm90aWZpY2F0aW9uX21hdGNoIGZ1bmN0aW9uICh0cmlnZ2VyZWQgYnkgaGFzaCB0YWJsZSBk dXBsaWNhdGUgZGV0ZWN0aW9uKQoqIENoZWNrIHRoYXQgbm90aWZpY2F0aW9ucyBzZW50IGZy b20gYSBiYWNrZW5kIHRoYXQgaGFzIG5vdCBkb25lIExJU1RFTgogIGFyZSBwcm9wZXJseSBk ZWxpdmVyZWQgdG8gYSBsaXN0ZW5lciBpbiBhbm90aGVyIGJhY2tlbmQKClRoaXMgYWxzbyBh ZGRzIGEgdGVzdCB0byBwcmVwYXJlIGZvciB0aGUgbmV4dCBwYXRjaDoKCiogQ2hlY2sgQ2hh bm5lbEhhc2hBZGRMaXN0ZW5lciBhcnJheSBncm93dGgKLS0tCiBzcmMvdGVzdC9pc29sYXRp b24vZXhwZWN0ZWQvYXN5bmMtbm90aWZ5Lm91dCB8IDExNCArKysrKysrKysrKysrKysrKyst CiBzcmMvdGVzdC9pc29sYXRpb24vc3BlY3MvYXN5bmMtbm90aWZ5LnNwZWMgICB8ICA2OCAr KysrKysrKysrKwogMiBmaWxlcyBjaGFuZ2VkLCAxODEgaW5zZXJ0aW9ucygrKSwgMSBkZWxl dGlvbigtKQoKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L2lzb2xhdGlvbi9leHBlY3RlZC9hc3lu Yy1ub3RpZnkub3V0IGIvc3JjL3Rlc3QvaXNvbGF0aW9uL2V4cGVjdGVkL2FzeW5jLW5vdGlm eS5vdXQKaW5kZXggNTU2ZTE4MDU4OTMuLjQ0M2E2ZWI2NjlmIDEwMDY0NAotLS0gYS9zcmMv dGVzdC9pc29sYXRpb24vZXhwZWN0ZWQvYXN5bmMtbm90aWZ5Lm91dAorKysgYi9zcmMvdGVz dC9pc29sYXRpb24vZXhwZWN0ZWQvYXN5bmMtbm90aWZ5Lm91dApAQCAtMSw0ICsxLDQgQEAK LVBhcnNlZCB0ZXN0IHNwZWMgd2l0aCAzIHNlc3Npb25zCitQYXJzZWQgdGVzdCBzcGVjIHdp dGggNyBzZXNzaW9ucwogCiBzdGFydGluZyBwZXJtdXRhdGlvbjogbGlzdGVuYyBub3RpZnkx IG5vdGlmeTIgbm90aWZ5MyBub3RpZnlmCiBzdGVwIGxpc3RlbmM6IExJU1RFTiBjMTsgTElT VEVOIGMyOwpAQCAtNDcsNiArNDcsMTA1IEBAIG5vdGlmaWVyOiBOT1RJRlkgImMyIiB3aXRo IHBheWxvYWQgInBheWxvYWQiIGZyb20gbm90aWZpZXIKIG5vdGlmaWVyOiBOT1RJRlkgImMx IiB3aXRoIHBheWxvYWQgInBheWxvYWRzIiBmcm9tIG5vdGlmaWVyCiBub3RpZmllcjogTk9U SUZZICJjMiIgd2l0aCBwYXlsb2FkICJwYXlsb2FkcyIgZnJvbSBub3RpZmllcgogCitzdGFy dGluZyBwZXJtdXRhdGlvbjogbGlzdGVuYyBub3RpZnlzX3NpbXBsZQorc3RlcCBsaXN0ZW5j OiBMSVNURU4gYzE7IExJU1RFTiBjMjsKK3N0ZXAgbm90aWZ5c19zaW1wbGU6IAorCUJFR0lO OworCVNBVkVQT0lOVCBzMTsKKwlOT1RJRlkgYzEsICdzaW1wbGUxJzsKKwlOT1RJRlkgYzIs ICdzaW1wbGUyJzsKKwlSRUxFQVNFIFNBVkVQT0lOVCBzMTsKKwlDT01NSVQ7CisKK25vdGlm aWVyOiBOT1RJRlkgImMxIiB3aXRoIHBheWxvYWQgInNpbXBsZTEiIGZyb20gbm90aWZpZXIK K25vdGlmaWVyOiBOT1RJRlkgImMyIiB3aXRoIHBheWxvYWQgInNpbXBsZTIiIGZyb20gbm90 aWZpZXIKKworc3RhcnRpbmcgcGVybXV0YXRpb246IGxzYmVnaW4gbHNzYXZlcG9pbnQgbHNs aXN0ZW4gbHNyZWxlYXNlIGxzY29tbWl0IGxzbm90aWZ5CitzdGVwIGxzYmVnaW46IEJFR0lO Oworc3RlcCBsc3NhdmVwb2ludDogU0FWRVBPSU5UIHMxOworc3RlcCBsc2xpc3RlbjogTElT VEVOIGMxOyBMSVNURU4gYzI7CitzdGVwIGxzcmVsZWFzZTogUkVMRUFTRSBTQVZFUE9JTlQg czE7CitzdGVwIGxzY29tbWl0OiBDT01NSVQ7CitzdGVwIGxzbm90aWZ5OiBOT1RJRlkgYzEs ICdzdWJ4YWN0X3Rlc3QnOworbGlzdGVuX3N1YnhhY3Q6IE5PVElGWSAiYzEiIHdpdGggcGF5 bG9hZCAic3VieGFjdF90ZXN0IiBmcm9tIGxpc3Rlbl9zdWJ4YWN0CisKK3N0YXJ0aW5nIHBl cm11dGF0aW9uOiBsc2JlZ2luIGxzbGlzdGVuX291dGVyIGxzc2F2ZXBvaW50IGxzbGlzdGVu IGxzcmVsZWFzZSBsc2NvbW1pdCBsc25vdGlmeQorc3RlcCBsc2JlZ2luOiBCRUdJTjsKK3N0 ZXAgbHNsaXN0ZW5fb3V0ZXI6IExJU1RFTiBjMzsKK3N0ZXAgbHNzYXZlcG9pbnQ6IFNBVkVQ T0lOVCBzMTsKK3N0ZXAgbHNsaXN0ZW46IExJU1RFTiBjMTsgTElTVEVOIGMyOworc3RlcCBs c3JlbGVhc2U6IFJFTEVBU0UgU0FWRVBPSU5UIHMxOworc3RlcCBsc2NvbW1pdDogQ09NTUlU Oworc3RlcCBsc25vdGlmeTogTk9USUZZIGMxLCAnc3VieGFjdF90ZXN0JzsKK2xpc3Rlbl9z dWJ4YWN0OiBOT1RJRlkgImMxIiB3aXRoIHBheWxvYWQgInN1YnhhY3RfdGVzdCIgZnJvbSBs aXN0ZW5fc3VieGFjdAorCitzdGFydGluZyBwZXJtdXRhdGlvbjogbHNiZWdpbiBsc3NhdmVw b2ludCBsc2xpc3RlbiBsc3JvbGxiYWNrIGxzY29tbWl0IGxzbm90aWZ5X2NoZWNrCitzdGVw IGxzYmVnaW46IEJFR0lOOworc3RlcCBsc3NhdmVwb2ludDogU0FWRVBPSU5UIHMxOworc3Rl cCBsc2xpc3RlbjogTElTVEVOIGMxOyBMSVNURU4gYzI7CitzdGVwIGxzcm9sbGJhY2s6IFJP TExCQUNLIFRPIFNBVkVQT0lOVCBzMTsKK3N0ZXAgbHNjb21taXQ6IENPTU1JVDsKK3N0ZXAg bHNub3RpZnlfY2hlY2s6IE5PVElGWSBjMSwgJ3Nob3VsZF9ub3RfcmVjZWl2ZSc7CisKK3N0 YXJ0aW5nIHBlcm11dGF0aW9uOiBsaXN0ZW5jIG5vdGlmeV9tYW55X3dpdGhfZHVwCitzdGVw IGxpc3RlbmM6IExJU1RFTiBjMTsgTElTVEVOIGMyOworc3RlcCBub3RpZnlfbWFueV93aXRo X2R1cDogCisJQkVHSU47CisJU0VMRUNUIHBnX25vdGlmeSgnYzEnLCAnbXNnJyB8fCBzOjp0 ZXh0KSBGUk9NIGdlbmVyYXRlX3NlcmllcygxLCAxNykgczsKKwlTRUxFQ1QgcGdfbm90aWZ5 KCdjMScsICdtc2cxJyk7CisJQ09NTUlUOworCitwZ19ub3RpZnkKKy0tLS0tLS0tLQorICAg ICAgICAgCisgICAgICAgICAKKyAgICAgICAgIAorICAgICAgICAgCisgICAgICAgICAKKyAg ICAgICAgIAorICAgICAgICAgCisgICAgICAgICAKKyAgICAgICAgIAorICAgICAgICAgCisg ICAgICAgICAKKyAgICAgICAgIAorICAgICAgICAgCisgICAgICAgICAKKyAgICAgICAgIAor ICAgICAgICAgCisgICAgICAgICAKKygxNyByb3dzKQorCitwZ19ub3RpZnkKKy0tLS0tLS0t LQorICAgICAgICAgCisoMSByb3cpCisKK25vdGlmaWVyOiBOT1RJRlkgImMxIiB3aXRoIHBh eWxvYWQgIm1zZzEiIGZyb20gbm90aWZpZXIKK25vdGlmaWVyOiBOT1RJRlkgImMxIiB3aXRo IHBheWxvYWQgIm1zZzIiIGZyb20gbm90aWZpZXIKK25vdGlmaWVyOiBOT1RJRlkgImMxIiB3 aXRoIHBheWxvYWQgIm1zZzMiIGZyb20gbm90aWZpZXIKK25vdGlmaWVyOiBOT1RJRlkgImMx IiB3aXRoIHBheWxvYWQgIm1zZzQiIGZyb20gbm90aWZpZXIKK25vdGlmaWVyOiBOT1RJRlkg ImMxIiB3aXRoIHBheWxvYWQgIm1zZzUiIGZyb20gbm90aWZpZXIKK25vdGlmaWVyOiBOT1RJ RlkgImMxIiB3aXRoIHBheWxvYWQgIm1zZzYiIGZyb20gbm90aWZpZXIKK25vdGlmaWVyOiBO T1RJRlkgImMxIiB3aXRoIHBheWxvYWQgIm1zZzciIGZyb20gbm90aWZpZXIKK25vdGlmaWVy OiBOT1RJRlkgImMxIiB3aXRoIHBheWxvYWQgIm1zZzgiIGZyb20gbm90aWZpZXIKK25vdGlm aWVyOiBOT1RJRlkgImMxIiB3aXRoIHBheWxvYWQgIm1zZzkiIGZyb20gbm90aWZpZXIKK25v dGlmaWVyOiBOT1RJRlkgImMxIiB3aXRoIHBheWxvYWQgIm1zZzEwIiBmcm9tIG5vdGlmaWVy Citub3RpZmllcjogTk9USUZZICJjMSIgd2l0aCBwYXlsb2FkICJtc2cxMSIgZnJvbSBub3Rp Zmllcgorbm90aWZpZXI6IE5PVElGWSAiYzEiIHdpdGggcGF5bG9hZCAibXNnMTIiIGZyb20g bm90aWZpZXIKK25vdGlmaWVyOiBOT1RJRlkgImMxIiB3aXRoIHBheWxvYWQgIm1zZzEzIiBm cm9tIG5vdGlmaWVyCitub3RpZmllcjogTk9USUZZICJjMSIgd2l0aCBwYXlsb2FkICJtc2cx NCIgZnJvbSBub3RpZmllcgorbm90aWZpZXI6IE5PVElGWSAiYzEiIHdpdGggcGF5bG9hZCAi bXNnMTUiIGZyb20gbm90aWZpZXIKK25vdGlmaWVyOiBOT1RJRlkgImMxIiB3aXRoIHBheWxv YWQgIm1zZzE2IiBmcm9tIG5vdGlmaWVyCitub3RpZmllcjogTk9USUZZICJjMSIgd2l0aCBw YXlsb2FkICJtc2cxNyIgZnJvbSBub3RpZmllcgorCitzdGFydGluZyBwZXJtdXRhdGlvbjog bGlzdGVuYyBsbGlzdGVuIGwybGlzdGVuIGwzbGlzdGVuIGxzbGlzdGVuCitzdGVwIGxpc3Rl bmM6IExJU1RFTiBjMTsgTElTVEVOIGMyOworc3RlcCBsbGlzdGVuOiBMSVNURU4gYzE7IExJ U1RFTiBjMjsKK3N0ZXAgbDJsaXN0ZW46IExJU1RFTiBjMTsKK3N0ZXAgbDNsaXN0ZW46IExJ U1RFTiBjMTsKK3N0ZXAgbHNsaXN0ZW46IExJU1RFTiBjMTsgTElTVEVOIGMyOworCiBzdGFy dGluZyBwZXJtdXRhdGlvbjogbGxpc3RlbiBub3RpZnkxIG5vdGlmeTIgbm90aWZ5MyBub3Rp ZnlmIGxjaGVjawogc3RlcCBsbGlzdGVuOiBMSVNURU4gYzE7IExJU1RFTiBjMjsKIHN0ZXAg bm90aWZ5MTogTk9USUZZIGMxOwpAQCAtOTUsNiArMTk0LDggQEAgbGlzdGVuZXI6IE5PVElG WSAiYzIiIHdpdGggcGF5bG9hZCAiIiBmcm9tIG5vdGlmaWVyCiAKIHN0YXJ0aW5nIHBlcm11 dGF0aW9uOiBsMmxpc3RlbiBsMmJlZ2luIG5vdGlmeTEgbGJlZ2lucyBsbGlzdGVuIGxjb21t aXQgbDJjb21taXQgbDJzdG9wCiBzdGVwIGwybGlzdGVuOiBMSVNURU4gYzE7CitsaXN0ZW5l cjI6IE5PVElGWSAiYzEiIHdpdGggcGF5bG9hZCAiIiBmcm9tIG5vdGlmaWVyCitsaXN0ZW5l cjI6IE5PVElGWSAiYzEiIHdpdGggcGF5bG9hZCAiIiBmcm9tIG5vdGlmaWVyCiBzdGVwIGwy YmVnaW46IEJFR0lOOwogc3RlcCBub3RpZnkxOiBOT1RJRlkgYzE7CiBzdGVwIGxiZWdpbnM6 IEJFR0lOIElTT0xBVElPTiBMRVZFTCBTRVJJQUxJWkFCTEU7CkBAIC0xMDQsNiArMjA1LDE3 IEBAIHN0ZXAgbDJjb21taXQ6IENPTU1JVDsKIGxpc3RlbmVyMjogTk9USUZZICJjMSIgd2l0 aCBwYXlsb2FkICIiIGZyb20gbm90aWZpZXIKIHN0ZXAgbDJzdG9wOiBVTkxJU1RFTiAqOwog CitzdGFydGluZyBwZXJtdXRhdGlvbjogbGNoX2xpc3RlbiBuY2hfbm90aWZ5IGxjaF9jaGVj aworc3RlcCBsY2hfbGlzdGVuOiBMSVNURU4gY2g7CitzdGVwIG5jaF9ub3RpZnk6IE5PVElG WSBjaCwgJ2FhJzsKK3N0ZXAgbGNoX2NoZWNrOiBTRUxFQ1QgMSBBUyB4OworeAorLQorMQor KDEgcm93KQorCitsaXN0ZW5lcl9jaDogTk9USUZZICJjaCIgd2l0aCBwYXlsb2FkICJhYSIg ZnJvbSBub3RpZmllcl9jaAorCiBzdGFydGluZyBwZXJtdXRhdGlvbjogbGxpc3RlbiBsYmVn aW4gdXNhZ2UgYmlnbm90aWZ5IHVzYWdlCiBzdGVwIGxsaXN0ZW46IExJU1RFTiBjMTsgTElT VEVOIGMyOwogc3RlcCBsYmVnaW46IEJFR0lOOwpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvaXNv bGF0aW9uL3NwZWNzL2FzeW5jLW5vdGlmeS5zcGVjIGIvc3JjL3Rlc3QvaXNvbGF0aW9uL3Nw ZWNzL2FzeW5jLW5vdGlmeS5zcGVjCmluZGV4IDBiOGNmZDkxMDgzLi4wYTAxZTc3N2I5OCAx MDA2NDQKLS0tIGEvc3JjL3Rlc3QvaXNvbGF0aW9uL3NwZWNzL2FzeW5jLW5vdGlmeS5zcGVj CisrKyBiL3NyYy90ZXN0L2lzb2xhdGlvbi9zcGVjcy9hc3luYy1ub3RpZnkuc3BlYwpAQCAt MzEsNiArMzEsMjAgQEAgc3RlcCBub3RpZnlzMQl7CiAJUk9MTEJBQ0sgVE8gU0FWRVBPSU5U IHMyOwogCUNPTU1JVDsKIH0KK3N0ZXAgbm90aWZ5c19zaW1wbGUJeworCUJFR0lOOworCVNB VkVQT0lOVCBzMTsKKwlOT1RJRlkgYzEsICdzaW1wbGUxJzsKKwlOT1RJRlkgYzIsICdzaW1w bGUyJzsKKwlSRUxFQVNFIFNBVkVQT0lOVCBzMTsKKwlDT01NSVQ7Cit9CitzdGVwIG5vdGlm eV9tYW55X3dpdGhfZHVwCXsKKwlCRUdJTjsKKwlTRUxFQ1QgcGdfbm90aWZ5KCdjMScsICdt c2cnIHx8IHM6OnRleHQpIEZST00gZ2VuZXJhdGVfc2VyaWVzKDEsIDE3KSBzOworCVNFTEVD VCBwZ19ub3RpZnkoJ2MxJywgJ21zZzEnKTsKKwlDT01NSVQ7Cit9CiBzdGVwIHVzYWdlCQl7 IFNFTEVDVCBwZ19ub3RpZmljYXRpb25fcXVldWVfdXNhZ2UoKSA+IDAgQVMgbm9uemVybzsg fQogc3RlcCBiaWdub3RpZnkJeyBTRUxFQ1QgY291bnQocGdfbm90aWZ5KCdjMScsIHM6OnRl eHQpKSBGUk9NIGdlbmVyYXRlX3NlcmllcygxLCAxMDAwKSBzOyB9CiB0ZWFyZG93bgkJeyBV TkxJU1RFTiAqOyB9CkBAIC01Myw2ICs2NywzOCBAQCBzdGVwIGwyYmVnaW4JeyBCRUdJTjsg fQogc3RlcCBsMmNvbW1pdAl7IENPTU1JVDsgfQogc3RlcCBsMnN0b3AJCXsgVU5MSVNURU4g KjsgfQogCisjIFRoaXJkIGxpc3RlbmVyIHNlc3Npb24gZm9yIHRlc3RpbmcgYXJyYXkgZ3Jv d3RoLgorCitzZXNzaW9uIGxpc3RlbmVyMworc3RlcCBsM2xpc3Rlbgl7IExJU1RFTiBjMTsg fQordGVhcmRvd24JCXsgVU5MSVNURU4gKjsgfQorCisjIExpc3RlbmVyIHNlc3Npb24gZm9y IGNyb3NzLXNlc3Npb24gbm90aWZpY2F0aW9uIHRlc3Qgd2l0aCBjaGFubmVsICdjaCcuCisK K3Nlc3Npb24gbGlzdGVuZXJfY2gKK3N0ZXAgbGNoX2xpc3Rlbgl7IExJU1RFTiBjaDsgfQor c3RlcCBsY2hfY2hlY2sJeyBTRUxFQ1QgMSBBUyB4OyB9Cit0ZWFyZG93bgkJeyBVTkxJU1RF TiAqOyB9CisKKyMgTm90aWZpZXIgc2Vzc2lvbiBmb3IgY3Jvc3Mtc2Vzc2lvbiBub3RpZmlj YXRpb24gdGVzdCB3aXRoIGNoYW5uZWwgJ2NoJy4KKworc2Vzc2lvbiBub3RpZmllcl9jaAor c3RlcCBuY2hfbm90aWZ5CXsgTk9USUZZIGNoLCAnYWEnOyB9CisKKyMgU2Vzc2lvbiBmb3Ig dGVzdGluZyBMSVNURU4gaW4gc3VidHJhbnNhY3Rpb24gd2l0aCBzZXBhcmF0ZSBzdGVwcy4K Kworc2Vzc2lvbiBsaXN0ZW5fc3VieGFjdAorc3RlcCBsc2JlZ2luCXsgQkVHSU47IH0KK3N0 ZXAgbHNsaXN0ZW5fb3V0ZXIJeyBMSVNURU4gYzM7IH0KK3N0ZXAgbHNzYXZlcG9pbnQJeyBT QVZFUE9JTlQgczE7IH0KK3N0ZXAgbHNsaXN0ZW4JeyBMSVNURU4gYzE7IExJU1RFTiBjMjsg fQorc3RlcCBsc3JlbGVhc2UJeyBSRUxFQVNFIFNBVkVQT0lOVCBzMTsgfQorc3RlcCBsc3Jv bGxiYWNrCXsgUk9MTEJBQ0sgVE8gU0FWRVBPSU5UIHMxOyB9CitzdGVwIGxzY29tbWl0CXsg Q09NTUlUOyB9CitzdGVwIGxzbm90aWZ5CXsgTk9USUZZIGMxLCAnc3VieGFjdF90ZXN0Jzsg fQorc3RlcCBsc25vdGlmeV9jaGVjawl7IE5PVElGWSBjMSwgJ3Nob3VsZF9ub3RfcmVjZWl2 ZSc7IH0KK3RlYXJkb3duCQl7IFVOTElTVEVOICo7IH0KKwogCiAjIFRyaXZpYWwgY2FzZXMu CiBwZXJtdXRhdGlvbiBsaXN0ZW5jIG5vdGlmeTEgbm90aWZ5MiBub3RpZnkzIG5vdGlmeWYK QEAgLTYwLDYgKzEwNiwyNCBAQCBwZXJtdXRhdGlvbiBsaXN0ZW5jIG5vdGlmeTEgbm90aWZ5 MiBub3RpZnkzIG5vdGlmeWYKICMgQ2hlY2sgc2ltcGxlIGFuZCBsZXNzLXNpbXBsZSBkZWR1 cGxpY2F0aW9uLgogcGVybXV0YXRpb24gbGlzdGVuYyBub3RpZnlkMSBub3RpZnlkMiBub3Rp ZnlzMQogCisjIENoZWNrIHNpbXBsZSBOT1RJRlkgcmVwYXJlbnRpbmcgd2hlbiBwYXJlbnQg aGFzIG5vIGFjdGlvbi4KK3Blcm11dGF0aW9uIGxpc3RlbmMgbm90aWZ5c19zaW1wbGUKKwor IyBDaGVjayBMSVNURU4gcmVwYXJlbnRpbmcgaW4gc3VidHJhbnNhY3Rpb24uCitwZXJtdXRh dGlvbiBsc2JlZ2luIGxzc2F2ZXBvaW50IGxzbGlzdGVuIGxzcmVsZWFzZSBsc2NvbW1pdCBs c25vdGlmeQorCisjIENoZWNrIExJU1RFTiBtZXJnZSBwYXRoIHdoZW4gYm90aCBvdXRlciBh bmQgaW5uZXIgdHJhbnNhY3Rpb25zIGhhdmUgYWN0aW9ucy4KK3Blcm11dGF0aW9uIGxzYmVn aW4gbHNsaXN0ZW5fb3V0ZXIgbHNzYXZlcG9pbnQgbHNsaXN0ZW4gbHNyZWxlYXNlIGxzY29t bWl0IGxzbm90aWZ5CisKKyMgQ2hlY2sgTElTVEVOIGFib3J0IHBhdGggKFJPTExCQUNLIFRP IFNBVkVQT0lOVCBkaXNjYXJkcyBwZW5kaW5nIGFjdGlvbnMpLgorcGVybXV0YXRpb24gbHNi ZWdpbiBsc3NhdmVwb2ludCBsc2xpc3RlbiBsc3JvbGxiYWNrIGxzY29tbWl0IGxzbm90aWZ5 X2NoZWNrCisKKyMgQ2hlY2sgbm90aWZpY2F0aW9uX21hdGNoIGZ1bmN0aW9uICh0cmlnZ2Vy ZWQgYnkgaGFzaCB0YWJsZSBkdXBsaWNhdGUgZGV0ZWN0aW9uKS4KK3Blcm11dGF0aW9uIGxp c3RlbmMgbm90aWZ5X21hbnlfd2l0aF9kdXAKKworIyBDaGVjayBDaGFubmVsSGFzaEFkZExp c3RlbmVyIGFycmF5IGdyb3d0aC4KK3Blcm11dGF0aW9uIGxpc3RlbmMgbGxpc3RlbiBsMmxp c3RlbiBsM2xpc3RlbiBsc2xpc3RlbgorCiAjIENyb3NzLWJhY2tlbmQgbm90aWZpY2F0aW9u IGRlbGl2ZXJ5LiAgV2UgdXNlIGEgInNlbGVjdCAxIiB0byBmb3JjZSB0aGUKICMgbGlzdGVu ZXIgc2Vzc2lvbiB0byBjaGVjayBmb3Igbm90aWZpZXMuICBJbiBwcmluY2lwbGUgd2UgY291 bGQganVzdCB3YWl0CiAjIGZvciBkZWxpdmVyeSwgYnV0IHRoYXQgd291bGQgcmVxdWlyZSBl eHRyYSBzdXBwb3J0IGluIGlzb2xhdGlvbnRlc3RlcgpAQCAtNzMsNiArMTM3LDEwIEBAIHBl cm11dGF0aW9uIGxpc3RlbmMgbGxpc3RlbiBub3RpZnkxIG5vdGlmeTIgbm90aWZ5MyBub3Rp ZnlmIGxjaGVjawogIyBhbmQgbm90aWZ5IHF1ZXVlIGlzIG5vdCBlbXB0eQogcGVybXV0YXRp b24gbDJsaXN0ZW4gbDJiZWdpbiBub3RpZnkxIGxiZWdpbnMgbGxpc3RlbiBsY29tbWl0IGwy Y29tbWl0IGwyc3RvcAogCisjIENoZWNrIHRoYXQgbm90aWZpY2F0aW9ucyBzZW50IGZyb20g YSBiYWNrZW5kIHRoYXQgaGFzIG5vdCBkb25lIExJU1RFTgorIyBhcmUgcHJvcGVybHkgZGVs aXZlcmVkIHRvIGEgbGlzdGVuZXIgaW4gYW5vdGhlciBiYWNrZW5kLgorcGVybXV0YXRpb24g bGNoX2xpc3RlbiBuY2hfbm90aWZ5IGxjaF9jaGVjaworCiAjIFZlcmlmeSB0aGF0IHBnX25v dGlmaWNhdGlvbl9xdWV1ZV91c2FnZSBjb3JyZWN0bHkgcmVwb3J0cyBhIG5vbi16ZXJvIHJl c3VsdCwKICMgYWZ0ZXIgc3VibWl0dGluZyBub3RpZmljYXRpb25zIHdoaWxlIGFub3RoZXIg Y29ubmVjdGlvbiBpcyBsaXN0ZW5pbmcgZm9yCiAjIHRob3NlIG5vdGlmaWNhdGlvbnMgYW5k IHdhaXRpbmcgaW5zaWRlIGFuIGFjdGl2ZSB0cmFuc2FjdGlvbi4gIFdlIGhhdmUgdG8KLS0g CjIuNTAuMQoK --ce7d73ebaa3f43ad826ea7bd8f210476 Content-Disposition: attachment; filename*0="0002-optimize_listen_notify-v20-alt1.txt" Content-Type: text/plain; name="0002-optimize_listen_notify-v20-alt1.txt" Content-Transfer-Encoding: base64 RnJvbSBhZmZmMGYzZjhiMDFjZmRlMzY5YzU2NDAyNTMxM2U2YWNjOWE2MTBhIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBKb2VsIEphY29ic29uIDxqb2VsQGNvbXBpbGVyLm9y Zz4KRGF0ZTogU3VuLCAxOSBPY3QgMjAyNSAwODowODowNSArMDIwMApTdWJqZWN0OiBbUEFU Q0hdIEltcGxlbWVudHMgaWRlYSAjMTogYWR2aXNvcnlQb3MKCi0tLQogc3JjL2JhY2tlbmQv Y29tbWFuZHMvYXN5bmMuYyB8IDYzICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr Ky0tLQogMSBmaWxlIGNoYW5nZWQsIDU4IGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25zKC0p CgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvYXN5bmMuYyBiL3NyYy9iYWNr ZW5kL2NvbW1hbmRzL2FzeW5jLmMKaW5kZXggNGU2NTU2ZmI4ZDEuLjZhMDJmNWUzYWNjIDEw MDY0NAotLS0gYS9zcmMvYmFja2VuZC9jb21tYW5kcy9hc3luYy5jCisrKyBiL3NyYy9iYWNr ZW5kL2NvbW1hbmRzL2FzeW5jLmMKQEAgLTI2NCw2ICsyNjQsMTEgQEAgdHlwZWRlZiBzdHJ1 Y3QgUXVldWVQb3NpdGlvbgogCSAoeCkucGFnZSAhPSAoeSkucGFnZSA/ICh4KSA6IFwKIAkg KHgpLm9mZnNldCA+ICh5KS5vZmZzZXQgPyAoeCkgOiAoeSkpCiAKKy8qIHJldHVybnMgdHJ1 ZSBpZiB4IGNvbWVzIGJlZm9yZSB5IGluIHF1ZXVlIG9yZGVyICovCisjZGVmaW5lIFFVRVVF X1BPU19QUkVDRURFUyh4LHkpIFwKKwkoYXN5bmNRdWV1ZVBhZ2VQcmVjZWRlcygoeCkucGFn ZSwgKHkpLnBhZ2UpIHx8IFwKKwkgKCh4KS5wYWdlID09ICh5KS5wYWdlICYmICh4KS5vZmZz ZXQgPCAoeSkub2Zmc2V0KSkKKwogLyoKICAqIFBhcmFtZXRlciBkZXRlcm1pbmluZyBob3cg b2Z0ZW4gd2UgdHJ5IHRvIGFkdmFuY2UgdGhlIHRhaWwgcG9pbnRlcjoKICAqIHdlIGRvIHRo YXQgYWZ0ZXIgZXZlcnkgUVVFVUVfQ0xFQU5VUF9ERUxBWSBwYWdlcyBvZiBOT1RJRlkgZGF0 YS4gIFRoaXMgaXMKQEAgLTI4Niw2ICsyOTEsNyBAQCB0eXBlZGVmIHN0cnVjdCBRdWV1ZUJh Y2tlbmRTdGF0dXMKIAlPaWQJCQlkYm9pZDsJCQkvKiBiYWNrZW5kJ3MgZGF0YWJhc2UgT0lE LCBvciBJbnZhbGlkT2lkICovCiAJUHJvY051bWJlcgluZXh0TGlzdGVuZXI7CS8qIGlkIG9m IG5leHQgbGlzdGVuZXIsIG9yIElOVkFMSURfUFJPQ19OVU1CRVIgKi8KIAlRdWV1ZVBvc2l0 aW9uIHBvczsJCQkvKiBiYWNrZW5kIGhhcyByZWFkIHF1ZXVlIHVwIHRvIGhlcmUgKi8KKwlR dWV1ZVBvc2l0aW9uIGFkdmlzb3J5UG9zOwkvKiBiYWNrZW5kIGNvdWxkIHNraXAgcXVldWUg dG8gaGVyZSAqLwogCWJvb2wJCXdha2V1cFBlbmRpbmc7CS8qIHNpZ25hbCBzZW50IGJ1dCBu b3QgeWV0IHByb2Nlc3NlZCAqLwogfSBRdWV1ZUJhY2tlbmRTdGF0dXM7CiAKQEAgLTM0Nyw2 ICszNTMsNyBAQCBzdGF0aWMgZHNoYXNoX3RhYmxlICpjaGFubmVsSGFzaCA9IE5VTEw7CiAj ZGVmaW5lIFFVRVVFX0JBQ0tFTkRfREJPSUQoaSkJCShhc3luY1F1ZXVlQ29udHJvbC0+YmFj a2VuZFtpXS5kYm9pZCkKICNkZWZpbmUgUVVFVUVfTkVYVF9MSVNURU5FUihpKQkJKGFzeW5j UXVldWVDb250cm9sLT5iYWNrZW5kW2ldLm5leHRMaXN0ZW5lcikKICNkZWZpbmUgUVVFVUVf QkFDS0VORF9QT1MoaSkJCShhc3luY1F1ZXVlQ29udHJvbC0+YmFja2VuZFtpXS5wb3MpCisj ZGVmaW5lIFFVRVVFX0JBQ0tFTkRfQURWSVNPUllfUE9TKGkpCShhc3luY1F1ZXVlQ29udHJv bC0+YmFja2VuZFtpXS5hZHZpc29yeVBvcykKICNkZWZpbmUgUVVFVUVfQkFDS0VORF9XQUtF VVBfUEVORElORyhpKQkoYXN5bmNRdWV1ZUNvbnRyb2wtPmJhY2tlbmRbaV0ud2FrZXVwUGVu ZGluZykKIAogLyoKQEAgLTY3NCw2ICs2ODEsNyBAQCBBc3luY1NobWVtSW5pdCh2b2lkKQog CQkJUVVFVUVfQkFDS0VORF9EQk9JRChpKSA9IEludmFsaWRPaWQ7CiAJCQlRVUVVRV9ORVhU X0xJU1RFTkVSKGkpID0gSU5WQUxJRF9QUk9DX05VTUJFUjsKIAkJCVNFVF9RVUVVRV9QT1Mo UVVFVUVfQkFDS0VORF9QT1MoaSksIDAsIDApOworCQkJU0VUX1FVRVVFX1BPUyhRVUVVRV9C QUNLRU5EX0FEVklTT1JZX1BPUyhpKSwgMCwgMCk7CiAJCQlRVUVVRV9CQUNLRU5EX1dBS0VV UF9QRU5ESU5HKGkpID0gZmFsc2U7CiAJCX0KIAl9CkBAIC0xMzEyLDYgKzEzMjAsNyBAQCBF eGVjX0xpc3RlblByZUNvbW1pdCh2b2lkKQogCQkJcHJldkxpc3RlbmVyID0gaTsKIAl9CiAJ UVVFVUVfQkFDS0VORF9QT1MoTXlQcm9jTnVtYmVyKSA9IG1heDsKKwlRVUVVRV9CQUNLRU5E X0FEVklTT1JZX1BPUyhNeVByb2NOdW1iZXIpID0gbWF4OwogCVFVRVVFX0JBQ0tFTkRfUElE KE15UHJvY051bWJlcikgPSBNeVByb2NQaWQ7CiAJUVVFVUVfQkFDS0VORF9EQk9JRChNeVBy b2NOdW1iZXIpID0gTXlEYXRhYmFzZUlkOwogCS8qIEluc2VydCBiYWNrZW5kIGludG8gbGlz dCBvZiBsaXN0ZW5lcnMgYXQgY29ycmVjdCBwb3NpdGlvbiAqLwpAQCAtMjAzMSw5ICsyMDQw LDEzIEBAIFNpZ25hbEJhY2tlbmRzKHZvaWQpCiAJICogRXZlbiB0aG91Z2ggd2UgbWF5IHRh a2UgYW5kIHJlbGVhc2UgTm90aWZ5UXVldWVMb2NrIG11bHRpcGxlIHRpbWVzCiAJICogd2hp bGUgd3JpdGluZywgdGhlIGhlYXZ5d2VpZ2h0IGxvY2sgZ3VhcmFudGVlcyB0aGlzIHJlZ2lv biBjb250YWlucwogCSAqIG9ubHkgb3VyIG1lc3NhZ2VzLiAgVGhlcmVmb3JlLCBhbnkgYmFj a2VuZCBzdGlsbCBwb3NpdGlvbmVkIGF0IHRoZQotCSAqIHF1ZXVlIGhlYWQgZnJvbSBiZWZv cmUgb3VyIHdyaXRlIGNhbiBiZSBzYWZlbHkgYWR2YW5jZWQgdG8gdGhlIGN1cnJlbnQKKwkg KiBxdWV1ZSBoZWFkIGZyb20gYmVmb3JlIG91ciB3cml0ZSBjYW4gYmUgYWR2aXNlZCB0byBz a2lwIHRvIHRoZSBjdXJyZW50CiAJICogcXVldWUgaGVhZCB3aXRob3V0IHdha2luZyBpdC4K IAkgKgorCSAqIFdlIHVzZSB0aGUgYWR2aXNvcnlQb3MgZmllbGQgcmF0aGVyIHRoYW4gZGly ZWN0bHkgbW9kaWZ5aW5nIHBvcy4KKwkgKiBUaGUgYmFja2VuZCBjb250cm9scyBpdHMgb3du IHBvcyBmaWVsZCBhbmQgd2lsbCBjaGVjayBhZHZpc29yeVBvcworCSAqIHdoZW4gaXQncyBz YWZlIHRvIGRvIHNvLgorCSAqCiAJICogRmFsc2UtcG9zaXRpdmUgcG9zc2liaWxpdHk6IGlm IGEgYmFja2VuZCB3YXMgcHJldmlvdXNseSBzaWduYWxlZCBidXQKIAkgKiBoYXNuJ3QgeWV0 IGF3b2tlbiwgd2UnbGwgc2tpcCBhZHZhbmNpbmcgaXQgKGJlY2F1c2Ugd2FrZXVwUGVuZGlu ZyBpcwogCSAqIHRydWUpLiAgVGhpcyBpcyBzYWZlIC0gdGhlIGJhY2tlbmQgd2lsbCBhZHZh bmNlIGl0cyBwb2ludGVyIHdoZW4gaXQKQEAgLTIwNDgsNiArMjA2MSw3IEBAIFNpZ25hbEJh Y2tlbmRzKHZvaWQpCiAJCSBpID0gUVVFVUVfTkVYVF9MSVNURU5FUihpKSkKIAl7CiAJCVF1 ZXVlUG9zaXRpb24gcG9zOworCQlRdWV1ZVBvc2l0aW9uIGFkdmlzb3J5UG9zOwogCQlpbnQ2 NAkJbGFnOwogCQlpbnQzMgkJcGlkOwogCkBAIC0yMDU1LDE1ICsyMDY5LDMxIEBAIFNpZ25h bEJhY2tlbmRzKHZvaWQpCiAJCQljb250aW51ZTsKIAogCQlwb3MgPSBRVUVVRV9CQUNLRU5E X1BPUyhpKTsKKwkJYWR2aXNvcnlQb3MgPSBRVUVVRV9CQUNLRU5EX0FEVklTT1JZX1BPUyhp KTsKIAotCQkvKiBEaXJlY3QgYWR2YW5jZW1lbnQgZm9yIGlkbGUgYmFja2VuZHMgYXQgdGhl IG9sZCBoZWFkICovCisJCS8qCisJCSAqIERpcmVjdCBhZHZhbmNlbWVudCBmb3IgaWRsZSBi YWNrZW5kcyBhdCB0aGUgb2xkIGhlYWQuCisJCSAqCisJCSAqIFdlIGNoZWNrIGFkdmlzb3J5 UG9zIHJhdGhlciB0aGFuIHBvcyB0byBhbGxvdyBhY2N1bXVsYXRpbmcgYWR2YW5jZXMKKwkJ ICogZnJvbSBtdWx0aXBsZSBjb25zZWN1dGl2ZSBub3RpZnlpbmcgYmFja2VuZHMuICBJZiB3 ZSBjaGVja2VkIHBvcywKKwkJICogb25seSB0aGUgZmlyc3Qgbm90aWZpZXIgY291bGQgYWR2 YW5jZSBpZGxlIGJhY2tlbmRzOyBzdWJzZXF1ZW50CisJCSAqIG5vdGlmaWVycyB3b3VsZCBm aW5kIHBvcyB1bmNoYW5nZWQgKHNpbmNlIHRoZSBiYWNrZW5kIGhhc24ndCB3b2tlbgorCQkg KiB1cCB5ZXQpIGFuZCBmYWlsIHRvIGFkdmFuY2UgZnVydGhlci4KKwkJICovCiAJCWlmIChw ZW5kaW5nTm90aWZpZXMgIT0gTlVMTCAmJgotCQkJUVVFVUVfUE9TX0VRVUFMKHBvcywgcXVl dWVIZWFkQmVmb3JlV3JpdGUpKQorCQkJUVVFVUVfUE9TX0VRVUFMKGFkdmlzb3J5UG9zLCBx dWV1ZUhlYWRCZWZvcmVXcml0ZSkpCiAJCXsKLQkJCVFVRVVFX0JBQ0tFTkRfUE9TKGkpID0g cXVldWVIZWFkQWZ0ZXJXcml0ZTsKLQkJCXBvcyA9IHF1ZXVlSGVhZEFmdGVyV3JpdGU7CisJ CQlRVUVVRV9CQUNLRU5EX0FEVklTT1JZX1BPUyhpKSA9IHF1ZXVlSGVhZEFmdGVyV3JpdGU7 CisJCQlhZHZpc29yeVBvcyA9IHF1ZXVlSGVhZEFmdGVyV3JpdGU7CiAJCX0KIAorCQkvKgor CQkgKiBGb3IgbGFnIGNhbGN1bGF0aW9uLCB1c2Ugd2hpY2hldmVyIHBvc2l0aW9uIGlzIGZ1 cnRoZXIgYWhlYWQuCisJCSAqIFRoaXMgZW5zdXJlcyB3ZSBkb24ndCBzcHVyaW91c2x5IHdh a2UgYSBiYWNrZW5kIHRoYXQgaGFzIGJlZW4KKwkJICogZGlyZWN0bHkgYWR2YW5jZWQuCisJ CSAqLworCQlwb3MgPSBRVUVVRV9QT1NfTUFYKHBvcywgYWR2aXNvcnlQb3MpOworCiAJCS8q IFNpZ25hbCBiYWNrZW5kcyB0aGF0IGhhdmUgZmFsbGVuIHRvbyBmYXIgYmVoaW5kICovCiAJ CWxhZyA9IGFzeW5jUXVldWVQYWdlRGlmZihRVUVVRV9QT1NfUEFHRShRVUVVRV9IRUFEKSwK IAkJCQkJCQkJIFFVRVVFX1BPU19QQUdFKHBvcykpOwpAQCAtMjMwMiw2ICsyMzMyLDcgQEAg c3RhdGljIHZvaWQKIGFzeW5jUXVldWVSZWFkQWxsTm90aWZpY2F0aW9ucyh2b2lkKQogewog CXZvbGF0aWxlIFF1ZXVlUG9zaXRpb24gcG9zOworCVF1ZXVlUG9zaXRpb24gYWR2aXNvcnlQ b3M7CiAJUXVldWVQb3NpdGlvbiBoZWFkOwogCVNuYXBzaG90CXNuYXBzaG90OwogCkBAIC0y MzE5LDYgKzIzNTAsMjEgQEAgYXN5bmNRdWV1ZVJlYWRBbGxOb3RpZmljYXRpb25zKHZvaWQp CiAJUVVFVUVfQkFDS0VORF9XQUtFVVBfUEVORElORyhNeVByb2NOdW1iZXIpID0gZmFsc2U7 CiAJcG9zID0gUVVFVUVfQkFDS0VORF9QT1MoTXlQcm9jTnVtYmVyKTsKIAloZWFkID0gUVVF VUVfSEVBRDsKKworCS8qCisJICogQ2hlY2sgaWYgYW5vdGhlciBiYWNrZW5kIGhhcyBzZXQg YW4gYWR2aXNvcnkgcG9zaXRpb24gZm9yIHVzLgorCSAqIElmIHNvLCBhbmQgaWYgd2UgaGF2 ZW4ndCB5ZXQgcmVhZCBwYXN0IHRoYXQgcG9pbnQsIHdlIGNhbiBzYWZlbHkKKwkgKiBhZG9w dCB0aGUgYWR2aXNvcnkgcG9zaXRpb24gYW5kIHNraXAgdGhlIGludGVydmVuaW5nIG5vdGlm aWNhdGlvbnMuCisJICovCisJYWR2aXNvcnlQb3MgPSBRVUVVRV9CQUNLRU5EX0FEVklTT1JZ X1BPUyhNeVByb2NOdW1iZXIpOworCisJaWYgKCFRVUVVRV9QT1NfRVFVQUwoYWR2aXNvcnlQ b3MsIHBvcykgJiYKKwkJUVVFVUVfUE9TX1BSRUNFREVTKHBvcywgYWR2aXNvcnlQb3MpKQor CXsKKwkJcG9zID0gYWR2aXNvcnlQb3M7CisJCVFVRVVFX0JBQ0tFTkRfUE9TKE15UHJvY051 bWJlcikgPSBwb3M7CisJfQorCiAJTFdMb2NrUmVsZWFzZShOb3RpZnlRdWV1ZUxvY2spOwog CiAJaWYgKFFVRVVFX1BPU19FUVVBTChwb3MsIGhlYWQpKQpAQCAtMjQ0MCw2ICsyNDg2LDEz IEBAIGFzeW5jUXVldWVSZWFkQWxsTm90aWZpY2F0aW9ucyh2b2lkKQogCQkvKiBVcGRhdGUg c2hhcmVkIHN0YXRlICovCiAJCUxXTG9ja0FjcXVpcmUoTm90aWZ5UXVldWVMb2NrLCBMV19T SEFSRUQpOwogCQlRVUVVRV9CQUNLRU5EX1BPUyhNeVByb2NOdW1iZXIpID0gcG9zOworCQkv KgorCQkgKiBBZHZhbmNlIGFkdmlzb3J5UG9zIHRvIG91ciBjdXJyZW50IHBvc2l0aW9uIGlm IGl0IGhhcyBmYWxsZW4gYmVoaW5kLAorCQkgKiBidXQgcHJlc2VydmUgYW55IG5ld2VyIGFk dmlzb3J5IHBvc2l0aW9uIHRoYXQgbWF5IGhhdmUgYmVlbiBzZXQgYnkKKwkJICogYW5vdGhl ciBiYWNrZW5kIHdoaWxlIHdlIHdlcmUgcHJvY2Vzc2luZyBub3RpZmljYXRpb25zLgorCQkg Ki8KKwkJUVVFVUVfQkFDS0VORF9BRFZJU09SWV9QT1MoTXlQcm9jTnVtYmVyKSA9CisJCQlR VUVVRV9QT1NfTUFYKHBvcywgUVVFVUVfQkFDS0VORF9BRFZJU09SWV9QT1MoTXlQcm9jTnVt YmVyKSk7CiAJCUxXTG9ja1JlbGVhc2UoTm90aWZ5UXVldWVMb2NrKTsKIAl9CiAJUEdfRU5E X1RSWSgpOwotLSAKMi41MC4xCgo= --ce7d73ebaa3f43ad826ea7bd8f210476 Content-Disposition: attachment; filename*0="0002-optimize_listen_notify-v20-alt3.txt" Content-Type: text/plain; name="0002-optimize_listen_notify-v20-alt3.txt" Content-Transfer-Encoding: base64 RnJvbSBjNDAzMDk4YWU0ZTRkMDZmMTA5ZWI2MjkyYTY3YzY1NzdlMTIzMDEwIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBKb2VsIEphY29ic29uIDxqb2VsQGNvbXBpbGVyLm9y Zz4KRGF0ZTogU3VuLCAxOSBPY3QgMjAyNSAwODozNTo0NCArMDIwMApTdWJqZWN0OiBbUEFU Q0hdIEltcGxlbWVudCBpZGVhICMzCgotLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL2FzeW5j LmMgfCAxNTAgKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0tLS0KIDEgZmlsZSBj aGFuZ2VkLCA4NSBpbnNlcnRpb25zKCspLCA2NSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQg YS9zcmMvYmFja2VuZC9jb21tYW5kcy9hc3luYy5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMv YXN5bmMuYwppbmRleCA0ZTY1NTZmYjhkMS4uYjM0ZTRhMjI0N2IgMTAwNjQ0Ci0tLSBhL3Ny Yy9iYWNrZW5kL2NvbW1hbmRzL2FzeW5jLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMv YXN5bmMuYwpAQCAtMjY0LDYgKzI2NCwxMSBAQCB0eXBlZGVmIHN0cnVjdCBRdWV1ZVBvc2l0 aW9uCiAJICh4KS5wYWdlICE9ICh5KS5wYWdlID8gKHgpIDogXAogCSAoeCkub2Zmc2V0ID4g KHkpLm9mZnNldCA/ICh4KSA6ICh5KSkKIAorLyogcmV0dXJucyB0cnVlIGlmIHggY29tZXMg YmVmb3JlIHkgaW4gcXVldWUgb3JkZXIgKi8KKyNkZWZpbmUgUVVFVUVfUE9TX1BSRUNFREVT KHgseSkgXAorCShhc3luY1F1ZXVlUGFnZVByZWNlZGVzKCh4KS5wYWdlLCAoeSkucGFnZSkg fHwgXAorCSAoKHgpLnBhZ2UgPT0gKHkpLnBhZ2UgJiYgKHgpLm9mZnNldCA8ICh5KS5vZmZz ZXQpKQorCiAvKgogICogUGFyYW1ldGVyIGRldGVybWluaW5nIGhvdyBvZnRlbiB3ZSB0cnkg dG8gYWR2YW5jZSB0aGUgdGFpbCBwb2ludGVyOgogICogd2UgZG8gdGhhdCBhZnRlciBldmVy eSBRVUVVRV9DTEVBTlVQX0RFTEFZIHBhZ2VzIG9mIE5PVElGWSBkYXRhLiAgVGhpcyBpcwpA QCAtMjMwNCw2ICsyMzA5LDcgQEAgYXN5bmNRdWV1ZVJlYWRBbGxOb3RpZmljYXRpb25zKHZv aWQpCiAJdm9sYXRpbGUgUXVldWVQb3NpdGlvbiBwb3M7CiAJUXVldWVQb3NpdGlvbiBoZWFk OwogCVNuYXBzaG90CXNuYXBzaG90OworCWJvb2wJCXJlYWNoZWRTdG9wOwogCiAJLyogcGFn ZV9idWZmZXIgbXVzdCBiZSBhZGVxdWF0ZWx5IGFsaWduZWQsIHNvIHVzZSBhIHVuaW9uICov CiAJdW5pb24KQEAgLTIzNzIsNzcgKzIzNzgsNjkgQEAgYXN5bmNRdWV1ZVJlYWRBbGxOb3Rp ZmljYXRpb25zKHZvaWQpCiAJICogSXQgaXMgcG9zc2libGUgdGhhdCB3ZSBmYWlsIHdoaWxl IHRyeWluZyB0byBzZW5kIGEgbWVzc2FnZSB0byBvdXIKIAkgKiBmcm9udGVuZCAoZm9yIGV4 YW1wbGUsIGJlY2F1c2Ugb2YgZW5jb2RpbmcgY29udmVyc2lvbiBmYWlsdXJlKS4gIElmCiAJ ICogdGhhdCBoYXBwZW5zIGl0IGlzIGNyaXRpY2FsIHRoYXQgd2Ugbm90IHRyeSB0byBzZW5k IHRoZSBzYW1lIG1lc3NhZ2UKLQkgKiBvdmVyIGFuZCBvdmVyIGFnYWluLiAgVGhlcmVmb3Jl LCB3ZSBwbGFjZSBhIFBHX1RSWSBibG9jayBoZXJlIHRoYXQgd2lsbAotCSAqIGZvcmNpYmx5 IGFkdmFuY2Ugb3VyIHF1ZXVlIHBvc2l0aW9uIGJlZm9yZSB3ZSBsb3NlIGNvbnRyb2wgdG8g YW4gZXJyb3IuCi0JICogKFdlIGNvdWxkIGFsdGVybmF0aXZlbHkgcmV0YWtlIE5vdGlmeVF1 ZXVlTG9jayBhbmQgbW92ZSB0aGUgcG9zaXRpb24KLQkgKiBiZWZvcmUgaGFuZGxpbmcgZWFj aCBpbmRpdmlkdWFsIG1lc3NhZ2UsIGJ1dCB0aGF0IHNlZW1zIGxpa2UgdG9vIG11Y2gKLQkg KiBsb2NrIHRyYWZmaWMuKQorCSAqIG92ZXIgYW5kIG92ZXIgYWdhaW4uICBUaGVyZWZvcmUs IHdlIG11c3QgYWR2YW5jZSBvdXIgcXVldWUgcG9zaXRpb24KKwkgKiByZWd1bGFybHkgYXMg d2UgcHJvY2VzcyBtZXNzYWdlcy4KKwkgKgorCSAqIFdlIG11c3QgYWxzbyBiZSBjYXJlZnVs IGFib3V0IGNvbmN1cnJlbmN5OiBTaWduYWxCYWNrZW5kcygpIGNhbgorCSAqIGRpcmVjdGx5 IGFkdmFuY2Ugb3VyIHBvc2l0aW9uIHdoaWxlIHdlJ3JlIHJlYWRpbmcuICBUbyBwcmVzZXJ2 ZSBzdWNoCisJICogYWR2YW5jZW1lbnQsIGFzeW5jUXVldWVQcm9jZXNzUGFnZUVudHJpZXMg dXBkYXRlcyBvdXIgcG9zaXRpb24gaW4KKwkgKiBzaGFyZWQgbWVtb3J5IGZvciBlYWNoIG1l c3NhZ2UsIG9ubHkgd3JpdGluZyBpZiBvdXIgcG9zaXRpb24gaXMgYWhlYWQuCisJICogU2hh cmVkIGxvY2sgaXMgc3VmZmljaWVudCBzaW5jZSB3ZSdyZSBvbmx5IHVwZGF0aW5nIG91ciBv d24gcG9zaXRpb24uCiAJICovCi0JUEdfVFJZKCk7CisJZG8KIAl7Ci0JCWJvb2wJCXJlYWNo ZWRTdG9wOworCQlpbnQ2NAkJY3VycGFnZSA9IFFVRVVFX1BPU19QQUdFKHBvcyk7CisJCWlu dAkJCWN1cm9mZnNldCA9IFFVRVVFX1BPU19PRkZTRVQocG9zKTsKKwkJaW50CQkJc2xvdG5v OworCQlpbnQJCQljb3B5c2l6ZTsKIAotCQlkbworCQkvKgorCQkgKiBXZSBjb3B5IHRoZSBk YXRhIGZyb20gU0xSVSBpbnRvIGEgbG9jYWwgYnVmZmVyLCBzbyBhcyB0byBhdm9pZAorCQkg KiBob2xkaW5nIHRoZSBTTFJVIGxvY2sgd2hpbGUgd2UgYXJlIGV4YW1pbmluZyB0aGUgZW50 cmllcyBhbmQKKwkJICogcG9zc2libHkgdHJhbnNtaXR0aW5nIHRoZW0gdG8gb3VyIGZyb250 ZW5kLiAgQ29weSBvbmx5IHRoZSBwYXJ0CisJCSAqIG9mIHRoZSBwYWdlIHdlIHdpbGwgYWN0 dWFsbHkgaW5zcGVjdC4KKwkJICovCisJCXNsb3RubyA9IFNpbXBsZUxydVJlYWRQYWdlX1Jl YWRPbmx5KE5vdGlmeUN0bCwgY3VycGFnZSwKKwkJCQkJCQkJCQkJSW52YWxpZFRyYW5zYWN0 aW9uSWQpOworCQlpZiAoY3VycGFnZSA9PSBRVUVVRV9QT1NfUEFHRShoZWFkKSkKIAkJewot CQkJaW50NjQJCWN1cnBhZ2UgPSBRVUVVRV9QT1NfUEFHRShwb3MpOwotCQkJaW50CQkJY3Vy b2Zmc2V0ID0gUVVFVUVfUE9TX09GRlNFVChwb3MpOwotCQkJaW50CQkJc2xvdG5vOwotCQkJ aW50CQkJY29weXNpemU7CisJCQkvKiB3ZSBvbmx5IHdhbnQgdG8gcmVhZCBhcyBmYXIgYXMg aGVhZCAqLworCQkJY29weXNpemUgPSBRVUVVRV9QT1NfT0ZGU0VUKGhlYWQpIC0gY3Vyb2Zm c2V0OworCQkJaWYgKGNvcHlzaXplIDwgMCkKKwkJCQljb3B5c2l6ZSA9IDA7CS8qIGp1c3Qg Zm9yIHNhZmV0eSAqLworCQl9CisJCWVsc2UKKwkJeworCQkJLyogZmV0Y2ggYWxsIHRoZSBy ZXN0IG9mIHRoZSBwYWdlICovCisJCQljb3B5c2l6ZSA9IFFVRVVFX1BBR0VTSVpFIC0gY3Vy b2Zmc2V0OworCQl9CisJCW1lbWNweShwYWdlX2J1ZmZlci5idWYgKyBjdXJvZmZzZXQsCisJ CQkgICBOb3RpZnlDdGwtPnNoYXJlZC0+cGFnZV9idWZmZXJbc2xvdG5vXSArIGN1cm9mZnNl dCwKKwkJCSAgIGNvcHlzaXplKTsKKwkJLyogUmVsZWFzZSBsb2NrIHRoYXQgd2UgZ290IGZy b20gU2ltcGxlTHJ1UmVhZFBhZ2VfUmVhZE9ubHkoKSAqLworCQlMV0xvY2tSZWxlYXNlKFNp bXBsZUxydUdldEJhbmtMb2NrKE5vdGlmeUN0bCwgY3VycGFnZSkpOwogCi0JCQkvKgotCQkJ ICogV2UgY29weSB0aGUgZGF0YSBmcm9tIFNMUlUgaW50byBhIGxvY2FsIGJ1ZmZlciwgc28g YXMgdG8gYXZvaWQKLQkJCSAqIGhvbGRpbmcgdGhlIFNMUlUgbG9jayB3aGlsZSB3ZSBhcmUg ZXhhbWluaW5nIHRoZSBlbnRyaWVzIGFuZAotCQkJICogcG9zc2libHkgdHJhbnNtaXR0aW5n IHRoZW0gdG8gb3VyIGZyb250ZW5kLiAgQ29weSBvbmx5IHRoZSBwYXJ0Ci0JCQkgKiBvZiB0 aGUgcGFnZSB3ZSB3aWxsIGFjdHVhbGx5IGluc3BlY3QuCi0JCQkgKi8KLQkJCXNsb3RubyA9 IFNpbXBsZUxydVJlYWRQYWdlX1JlYWRPbmx5KE5vdGlmeUN0bCwgY3VycGFnZSwKLQkJCQkJ CQkJCQkJCUludmFsaWRUcmFuc2FjdGlvbklkKTsKLQkJCWlmIChjdXJwYWdlID09IFFVRVVF X1BPU19QQUdFKGhlYWQpKQotCQkJewotCQkJCS8qIHdlIG9ubHkgd2FudCB0byByZWFkIGFz IGZhciBhcyBoZWFkICovCi0JCQkJY29weXNpemUgPSBRVUVVRV9QT1NfT0ZGU0VUKGhlYWQp IC0gY3Vyb2Zmc2V0OwotCQkJCWlmIChjb3B5c2l6ZSA8IDApCi0JCQkJCWNvcHlzaXplID0g MDsJLyoganVzdCBmb3Igc2FmZXR5ICovCi0JCQl9Ci0JCQllbHNlCi0JCQl7Ci0JCQkJLyog ZmV0Y2ggYWxsIHRoZSByZXN0IG9mIHRoZSBwYWdlICovCi0JCQkJY29weXNpemUgPSBRVUVV RV9QQUdFU0laRSAtIGN1cm9mZnNldDsKLQkJCX0KLQkJCW1lbWNweShwYWdlX2J1ZmZlci5i dWYgKyBjdXJvZmZzZXQsCi0JCQkJICAgTm90aWZ5Q3RsLT5zaGFyZWQtPnBhZ2VfYnVmZmVy W3Nsb3Rub10gKyBjdXJvZmZzZXQsCi0JCQkJICAgY29weXNpemUpOwotCQkJLyogUmVsZWFz ZSBsb2NrIHRoYXQgd2UgZ290IGZyb20gU2ltcGxlTHJ1UmVhZFBhZ2VfUmVhZE9ubHkoKSAq LwotCQkJTFdMb2NrUmVsZWFzZShTaW1wbGVMcnVHZXRCYW5rTG9jayhOb3RpZnlDdGwsIGN1 cnBhZ2UpKTsKKwkJLyoKKwkJICogUHJvY2VzcyBtZXNzYWdlcyB1cCB0byB0aGUgc3RvcCBw b3NpdGlvbiwgZW5kIG9mIHBhZ2UsIG9yIGFuCisJCSAqIHVuY29tbWl0dGVkIG1lc3NhZ2Uu CisJCSAqCisJCSAqIE91ciBzdG9wIHBvc2l0aW9uIGlzIHdoYXQgd2UgZm91bmQgdG8gYmUg dGhlIGhlYWQncyBwb3NpdGlvbgorCQkgKiB3aGVuIHdlIGVudGVyZWQgdGhpcyBmdW5jdGlv bi4gSXQgbWlnaHQgaGF2ZSBjaGFuZ2VkIGFscmVhZHkuCisJCSAqIEJ1dCBpZiBpdCBoYXMs IHdlIHdpbGwgcmVjZWl2ZSAob3IgaGF2ZSBhbHJlYWR5IHJlY2VpdmVkIGFuZAorCQkgKiBx dWV1ZWQpIGFub3RoZXIgc2lnbmFsIGFuZCBjb21lIGhlcmUgYWdhaW4uCisJCSAqCisJCSAq IFdlIGFyZSBub3QgaG9sZGluZyBOb3RpZnlRdWV1ZUxvY2sgaGVyZSEgVGhlIHF1ZXVlIGNh biBvbmx5CisJCSAqIGV4dGVuZCBiZXlvbmQgdGhlIGhlYWQgcG9pbnRlciAoc2VlIGFib3Zl KS4KKwkJICogYXN5bmNRdWV1ZVByb2Nlc3NQYWdlRW50cmllcyB3aWxsIHVwZGF0ZSBvdXIg YmFja2VuZCdzIHBvc2l0aW9uCisJCSAqIGZvciBlYWNoIG1lc3NhZ2UgdG8gZW5zdXJlIHdl IGRvbid0IHJlcHJvY2VzcyBtZXNzYWdlcyBpZiB3ZSBmYWlsCisJCSAqIHBhcnR3YXkgdGhy b3VnaCwgYW5kIHRvIHByZXNlcnZlIGFueSBkaXJlY3QgYWR2YW5jZW1lbnQgdGhhdAorCQkg KiBTaWduYWxCYWNrZW5kcygpIG1pZ2h0IHBlcmZvcm0gY29uY3VycmVudGx5LgorCQkgKi8K KwkJcmVhY2hlZFN0b3AgPSBhc3luY1F1ZXVlUHJvY2Vzc1BhZ2VFbnRyaWVzKCZwb3MsIGhl YWQsCisJCQkJCQkJCQkJCQkgICBwYWdlX2J1ZmZlci5idWYsCisJCQkJCQkJCQkJCQkgICBz bmFwc2hvdCk7CiAKLQkJCS8qCi0JCQkgKiBQcm9jZXNzIG1lc3NhZ2VzIHVwIHRvIHRoZSBz dG9wIHBvc2l0aW9uLCBlbmQgb2YgcGFnZSwgb3IgYW4KLQkJCSAqIHVuY29tbWl0dGVkIG1l c3NhZ2UuCi0JCQkgKgotCQkJICogT3VyIHN0b3AgcG9zaXRpb24gaXMgd2hhdCB3ZSBmb3Vu ZCB0byBiZSB0aGUgaGVhZCdzIHBvc2l0aW9uCi0JCQkgKiB3aGVuIHdlIGVudGVyZWQgdGhp cyBmdW5jdGlvbi4gSXQgbWlnaHQgaGF2ZSBjaGFuZ2VkIGFscmVhZHkuCi0JCQkgKiBCdXQg aWYgaXQgaGFzLCB3ZSB3aWxsIHJlY2VpdmUgKG9yIGhhdmUgYWxyZWFkeSByZWNlaXZlZCBh bmQKLQkJCSAqIHF1ZXVlZCkgYW5vdGhlciBzaWduYWwgYW5kIGNvbWUgaGVyZSBhZ2Fpbi4K LQkJCSAqCi0JCQkgKiBXZSBhcmUgbm90IGhvbGRpbmcgTm90aWZ5UXVldWVMb2NrIGhlcmUh IFRoZSBxdWV1ZSBjYW4gb25seQotCQkJICogZXh0ZW5kIGJleW9uZCB0aGUgaGVhZCBwb2lu dGVyIChzZWUgYWJvdmUpIGFuZCB3ZSBsZWF2ZSBvdXIKLQkJCSAqIGJhY2tlbmQncyBwb2lu dGVyIHdoZXJlIGl0IGlzIHNvIG5vYm9keSB3aWxsIHRydW5jYXRlIG9yCi0JCQkgKiByZXdy aXRlIHBhZ2VzIHVuZGVyIHVzLiBFc3BlY2lhbGx5IHdlIGRvbid0IHdhbnQgdG8gaG9sZCBh IGxvY2sKLQkJCSAqIHdoaWxlIHNlbmRpbmcgdGhlIG5vdGlmaWNhdGlvbnMgdG8gdGhlIGZy b250ZW5kLgotCQkJICovCi0JCQlyZWFjaGVkU3RvcCA9IGFzeW5jUXVldWVQcm9jZXNzUGFn ZUVudHJpZXMoJnBvcywgaGVhZCwKLQkJCQkJCQkJCQkJCQkgICBwYWdlX2J1ZmZlci5idWYs Ci0JCQkJCQkJCQkJCQkJICAgc25hcHNob3QpOwotCQl9IHdoaWxlICghcmVhY2hlZFN0b3Ap OwotCX0KLQlQR19GSU5BTExZKCk7Ci0JewotCQkvKiBVcGRhdGUgc2hhcmVkIHN0YXRlICov Ci0JCUxXTG9ja0FjcXVpcmUoTm90aWZ5UXVldWVMb2NrLCBMV19TSEFSRUQpOwotCQlRVUVV RV9CQUNLRU5EX1BPUyhNeVByb2NOdW1iZXIpID0gcG9zOwotCQlMV0xvY2tSZWxlYXNlKE5v dGlmeVF1ZXVlTG9jayk7Ci0JfQotCVBHX0VORF9UUlkoKTsKKwl9IHdoaWxlICghcmVhY2hl ZFN0b3ApOwogCiAJLyogRG9uZSB3aXRoIHNuYXBzaG90ICovCiAJVW5yZWdpc3RlclNuYXBz aG90KHNuYXBzaG90KTsKQEAgLTI0OTAsNiArMjQ4OCwyNCBAQCBhc3luY1F1ZXVlUHJvY2Vz c1BhZ2VFbnRyaWVzKHZvbGF0aWxlIFF1ZXVlUG9zaXRpb24gKmN1cnJlbnQsCiAJCSAqLwog CQlyZWFjaGVkRW5kT2ZQYWdlID0gYXN5bmNRdWV1ZUFkdmFuY2UoY3VycmVudCwgcWUtPmxl bmd0aCk7CiAKKwkJLyoKKwkJICogVXBkYXRlIG91ciBwb3NpdGlvbiBpbiBzaGFyZWQgbWVt b3J5IGltbWVkaWF0ZWx5IGFmdGVyIGFkdmFuY2luZywKKwkJICogYmVmb3JlIHdlIGF0dGVt cHQgdG8gcHJvY2VzcyB0aGUgbWVzc2FnZS4gVGhpcyBlbnN1cmVzIHdlIHdvbid0CisJCSAq IHJlcHJvY2VzcyB0aGlzIG1lc3NhZ2UgaWYgTm90aWZ5TXlGcm9udEVuZCBmYWlscy4KKwkJ ICoKKwkJICogT25seSB3cml0ZSBpZiBvdXIgcG9zaXRpb24gaXMgYWhlYWQgb2YgdGhlIHNo YXJlZCBwb3NpdGlvbi4KKwkJICogSWYgdGhlIHNoYXJlZCBwb3NpdGlvbiBpcyBhbHJlYWR5 IGFoZWFkIChkdWUgdG8gZGlyZWN0IGFkdmFuY2VtZW50CisJCSAqIGJ5IFNpZ25hbEJhY2tl bmRzKSwgcHJlc2VydmUgaXQgYnkgbm90IG92ZXJ3cml0aW5nLgorCQkgKi8KKwkJTFdMb2Nr QWNxdWlyZShOb3RpZnlRdWV1ZUxvY2ssIExXX1NIQVJFRCk7CisJCXsKKwkJCVF1ZXVlUG9z aXRpb24gc2hhcmVkUG9zID0gUVVFVUVfQkFDS0VORF9QT1MoTXlQcm9jTnVtYmVyKTsKKwor CQkJaWYgKFFVRVVFX1BPU19QUkVDRURFUyhzaGFyZWRQb3MsICpjdXJyZW50KSkKKwkJCQlR VUVVRV9CQUNLRU5EX1BPUyhNeVByb2NOdW1iZXIpID0gKmN1cnJlbnQ7CisJCX0KKwkJTFdM b2NrUmVsZWFzZShOb3RpZnlRdWV1ZUxvY2spOworCiAJCS8qIElnbm9yZSBtZXNzYWdlcyBk ZXN0aW5lZCBmb3Igb3RoZXIgZGF0YWJhc2VzICovCiAJCWlmIChxZS0+ZGJvaWQgPT0gTXlE YXRhYmFzZUlkKQogCQl7CkBAIC0yNTE1LDYgKzI1MzEsMTAgQEAgYXN5bmNRdWV1ZVByb2Nl c3NQYWdlRW50cmllcyh2b2xhdGlsZSBRdWV1ZVBvc2l0aW9uICpjdXJyZW50LAogCQkJCSAq IG1lc3NhZ2VzLgogCQkJCSAqLwogCQkJCSpjdXJyZW50ID0gdGhpc2VudHJ5OworCQkJCS8q IFVwZGF0ZSBzaGFyZWQgbWVtb3J5IHRvIHJlZmxlY3QgdGhlIGJhY2tlZC11cCBwb3NpdGlv biAqLworCQkJCUxXTG9ja0FjcXVpcmUoTm90aWZ5UXVldWVMb2NrLCBMV19TSEFSRUQpOwor CQkJCVFVRVVFX0JBQ0tFTkRfUE9TKE15UHJvY051bWJlcikgPSAqY3VycmVudDsKKwkJCQlM V0xvY2tSZWxlYXNlKE5vdGlmeVF1ZXVlTG9jayk7CiAJCQkJcmVhY2hlZFN0b3AgPSB0cnVl OwogCQkJCWJyZWFrOwogCQkJfQotLSAKMi41MC4xCgo= --ce7d73ebaa3f43ad826ea7bd8f210476 Content-Disposition: attachment; filename*0="0002-optimize_listen_notify-v20-alt2.txt" Content-Type: text/plain; name="0002-optimize_listen_notify-v20-alt2.txt" Content-Transfer-Encoding: base64 RnJvbSA5MjhjYzAzMjcwNmFjMTU0MTUzMjc5YWRiZGZiYTk1ZjZhZjJmYWU0IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBKb2VsIEphY29ic29uIDxqb2VsQGNvbXBpbGVyLm9y Zz4KRGF0ZTogU3VuLCAxOSBPY3QgMjAyNSAwODoxMjo0NyArMDIwMApTdWJqZWN0OiBbUEFU Q0hdIEltcGxlbWVudCBpZGVhICMyOiBkb25lUG9zCgotLS0KIHNyYy9iYWNrZW5kL2NvbW1h bmRzL2FzeW5jLmMgfCA1NyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0K IDEgZmlsZSBjaGFuZ2VkLCA0OSBpbnNlcnRpb25zKCspLCA4IGRlbGV0aW9ucygtKQoKZGlm ZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2FzeW5jLmMgYi9zcmMvYmFja2VuZC9j b21tYW5kcy9hc3luYy5jCmluZGV4IDRlNjU1NmZiOGQxLi5jODE4MDcxMDdkMSAxMDA2NDQK LS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvYXN5bmMuYworKysgYi9zcmMvYmFja2VuZC9j b21tYW5kcy9hc3luYy5jCkBAIC0yODUsNyArMjg1LDggQEAgdHlwZWRlZiBzdHJ1Y3QgUXVl dWVCYWNrZW5kU3RhdHVzCiAJaW50MzIJCXBpZDsJCQkvKiBlaXRoZXIgYSBQSUQgb3IgSW52 YWxpZFBpZCAqLwogCU9pZAkJCWRib2lkOwkJCS8qIGJhY2tlbmQncyBkYXRhYmFzZSBPSUQs IG9yIEludmFsaWRPaWQgKi8KIAlQcm9jTnVtYmVyCW5leHRMaXN0ZW5lcjsJLyogaWQgb2Yg bmV4dCBsaXN0ZW5lciwgb3IgSU5WQUxJRF9QUk9DX05VTUJFUiAqLwotCVF1ZXVlUG9zaXRp b24gcG9zOwkJCS8qIGJhY2tlbmQgaGFzIHJlYWQgcXVldWUgdXAgdG8gaGVyZSAqLworCVF1 ZXVlUG9zaXRpb24gcG9zOwkJCS8qIG5leHQgcG9zaXRpb24gdG8gcmVhZCBmcm9tICovCisJ UXVldWVQb3NpdGlvbiBkb25lUG9zOwkJLyogYmFja2VuZCBoYXMgZGVmaW5pdGl2ZWx5IHBy b2Nlc3NlZCB1cCB0byBoZXJlICovCiAJYm9vbAkJd2FrZXVwUGVuZGluZzsJLyogc2lnbmFs IHNlbnQgYnV0IG5vdCB5ZXQgcHJvY2Vzc2VkICovCiB9IFF1ZXVlQmFja2VuZFN0YXR1czsK IApAQCAtMzQ3LDYgKzM0OCw3IEBAIHN0YXRpYyBkc2hhc2hfdGFibGUgKmNoYW5uZWxIYXNo ID0gTlVMTDsKICNkZWZpbmUgUVVFVUVfQkFDS0VORF9EQk9JRChpKQkJKGFzeW5jUXVldWVD b250cm9sLT5iYWNrZW5kW2ldLmRib2lkKQogI2RlZmluZSBRVUVVRV9ORVhUX0xJU1RFTkVS KGkpCQkoYXN5bmNRdWV1ZUNvbnRyb2wtPmJhY2tlbmRbaV0ubmV4dExpc3RlbmVyKQogI2Rl ZmluZSBRVUVVRV9CQUNLRU5EX1BPUyhpKQkJKGFzeW5jUXVldWVDb250cm9sLT5iYWNrZW5k W2ldLnBvcykKKyNkZWZpbmUgUVVFVUVfQkFDS0VORF9ET05FUE9TKGkpCShhc3luY1F1ZXVl Q29udHJvbC0+YmFja2VuZFtpXS5kb25lUG9zKQogI2RlZmluZSBRVUVVRV9CQUNLRU5EX1dB S0VVUF9QRU5ESU5HKGkpCShhc3luY1F1ZXVlQ29udHJvbC0+YmFja2VuZFtpXS53YWtldXBQ ZW5kaW5nKQogCiAvKgpAQCAtNjc0LDYgKzY3Niw3IEBAIEFzeW5jU2htZW1Jbml0KHZvaWQp CiAJCQlRVUVVRV9CQUNLRU5EX0RCT0lEKGkpID0gSW52YWxpZE9pZDsKIAkJCVFVRVVFX05F WFRfTElTVEVORVIoaSkgPSBJTlZBTElEX1BST0NfTlVNQkVSOwogCQkJU0VUX1FVRVVFX1BP UyhRVUVVRV9CQUNLRU5EX1BPUyhpKSwgMCwgMCk7CisJCQlTRVRfUVVFVUVfUE9TKFFVRVVF X0JBQ0tFTkRfRE9ORVBPUyhpKSwgMCwgMCk7CiAJCQlRVUVVRV9CQUNLRU5EX1dBS0VVUF9Q RU5ESU5HKGkpID0gZmFsc2U7CiAJCX0KIAl9CkBAIC0xMzEyLDYgKzEzMTUsNyBAQCBFeGVj X0xpc3RlblByZUNvbW1pdCh2b2lkKQogCQkJcHJldkxpc3RlbmVyID0gaTsKIAl9CiAJUVVF VUVfQkFDS0VORF9QT1MoTXlQcm9jTnVtYmVyKSA9IG1heDsKKwlRVUVVRV9CQUNLRU5EX0RP TkVQT1MoTXlQcm9jTnVtYmVyKSA9IG1heDsKIAlRVUVVRV9CQUNLRU5EX1BJRChNeVByb2NO dW1iZXIpID0gTXlQcm9jUGlkOwogCVFVRVVFX0JBQ0tFTkRfREJPSUQoTXlQcm9jTnVtYmVy KSA9IE15RGF0YWJhc2VJZDsKIAkvKiBJbnNlcnQgYmFja2VuZCBpbnRvIGxpc3Qgb2YgbGlz dGVuZXJzIGF0IGNvcnJlY3QgcG9zaXRpb24gKi8KQEAgLTIwNDgsNiArMjA1Miw3IEBAIFNp Z25hbEJhY2tlbmRzKHZvaWQpCiAJCSBpID0gUVVFVUVfTkVYVF9MSVNURU5FUihpKSkKIAl7 CiAJCVF1ZXVlUG9zaXRpb24gcG9zOworCQlRdWV1ZVBvc2l0aW9uIGRvbmVQb3M7CiAJCWlu dDY0CQlsYWc7CiAJCWludDMyCQlwaWQ7CiAKQEAgLTIwNTUsNiArMjA2MCw3IEBAIFNpZ25h bEJhY2tlbmRzKHZvaWQpCiAJCQljb250aW51ZTsKIAogCQlwb3MgPSBRVUVVRV9CQUNLRU5E X1BPUyhpKTsKKwkJZG9uZVBvcyA9IFFVRVVFX0JBQ0tFTkRfRE9ORVBPUyhpKTsKIAogCQkv KiBEaXJlY3QgYWR2YW5jZW1lbnQgZm9yIGlkbGUgYmFja2VuZHMgYXQgdGhlIG9sZCBoZWFk ICovCiAJCWlmIChwZW5kaW5nTm90aWZpZXMgIT0gTlVMTCAmJgpAQCAtMjA2NCw5ICsyMDcw LDE3IEBAIFNpZ25hbEJhY2tlbmRzKHZvaWQpCiAJCQlwb3MgPSBxdWV1ZUhlYWRBZnRlcldy aXRlOwogCQl9CiAKLQkJLyogU2lnbmFsIGJhY2tlbmRzIHRoYXQgaGF2ZSBmYWxsZW4gdG9v IGZhciBiZWhpbmQgKi8KKwkJLyoKKwkJICogU2lnbmFsIGJhY2tlbmRzIHRoYXQgaGF2ZSBm YWxsZW4gdG9vIGZhciBiZWhpbmQuCisJCSAqCisJCSAqIFdlIHVzZSBkb25lUG9zIHJhdGhl ciB0aGFuIHBvcyBmb3IgdGhlIGxhZyBjaGVjayBiZWNhdXNlIGRvbmVQb3MKKwkJICogaXMg d2hhdCBtYXR0ZXJzIGZvciBxdWV1ZSB0cnVuY2F0aW9uIChzZWUgYXN5bmNRdWV1ZUFkdmFu Y2VUYWlsKS4KKwkJICogQSBiYWNrZW5kIG1heSBoYXZlIGJlZW4gZGlyZWN0bHkgYWR2YW5j ZWQgKHBvcyBpcyByZWNlbnQpIHdoaWxlCisJCSAqIGRvbmVQb3MgaXMgc3RpbGwgZmFyIGJl aGluZCwgaG9sZGluZyBiYWNrIHRoZSB0YWlsLiAgV2UgbmVlZCB0bworCQkgKiB3YWtlIHN1 Y2ggYmFja2VuZHMgc28gdGhleSBjYW4gYWR2YW5jZSB0aGVpciBkb25lUG9zLgorCQkgKi8K IAkJbGFnID0gYXN5bmNRdWV1ZVBhZ2VEaWZmKFFVRVVFX1BPU19QQUdFKFFVRVVFX0hFQUQp LAotCQkJCQkJCQkgUVVFVUVfUE9TX1BBR0UocG9zKSk7CisJCQkJCQkJCSBRVUVVRV9QT1Nf UEFHRShkb25lUG9zKSk7CiAKIAkJaWYgKGxhZyA+PSBRVUVVRV9DTEVBTlVQX0RFTEFZKQog CQl7CkBAIC0yMzE5LDE0ICsyMzMzLDI1IEBAIGFzeW5jUXVldWVSZWFkQWxsTm90aWZpY2F0 aW9ucyh2b2lkKQogCVFVRVVFX0JBQ0tFTkRfV0FLRVVQX1BFTkRJTkcoTXlQcm9jTnVtYmVy KSA9IGZhbHNlOwogCXBvcyA9IFFVRVVFX0JBQ0tFTkRfUE9TKE15UHJvY051bWJlcik7CiAJ aGVhZCA9IFFVRVVFX0hFQUQ7Ci0JTFdMb2NrUmVsZWFzZShOb3RpZnlRdWV1ZUxvY2spOwog CiAJaWYgKFFVRVVFX1BPU19FUVVBTChwb3MsIGhlYWQpKQogCXsKLQkJLyogTm90aGluZyB0 byBkbywgd2UgaGF2ZSByZWFkIGFsbCBub3RpZmljYXRpb25zIGFscmVhZHkuICovCisJCS8q CisJCSAqIE5vdGhpbmcgdG8gZG8sIHdlIGhhdmUgcmVhZCBhbGwgbm90aWZpY2F0aW9ucyBh bHJlYWR5LgorCQkgKgorCQkgKiBVcGRhdGUgZG9uZVBvcyB0byBtYXRjaCBwb3MgYmVmb3Jl IHJldHVybmluZy4gIFRoaXMgaXMgaW1wb3J0YW50CisJCSAqIHdoZW4gb3VyIHBvc2l0aW9u IHdhcyBhZHZhbmNlZCB2aWEgZGlyZWN0IGFkdmFuY2VtZW50OiB3ZSBuZWVkIHRvCisJCSAq IHVwZGF0ZSBkb25lUG9zIHNvIHRoZSBxdWV1ZSB0YWlsIGNhbiBhZHZhbmNlLiAgV2l0aG91 dCB0aGlzLAorCQkgKiBiYWNrZW5kcyB0aGF0IGhhdmUgYmVlbiBkaXJlY3RseSBhZHZhbmNl ZCB3b3VsZCBob2xkIGJhY2sgcXVldWUKKwkJICogdHJ1bmNhdGlvbiBpbmRlZmluaXRlbHku CisJCSAqLworCQlRVUVVRV9CQUNLRU5EX0RPTkVQT1MoTXlQcm9jTnVtYmVyKSA9IHBvczsK KwkJTFdMb2NrUmVsZWFzZShOb3RpZnlRdWV1ZUxvY2spOwogCQlyZXR1cm47CiAJfQogCisJ TFdMb2NrUmVsZWFzZShOb3RpZnlRdWV1ZUxvY2spOworCiAJLyotLS0tLS0tLS0tCiAJICog R2V0IHNuYXBzaG90IHdlJ2xsIHVzZSB0byBkZWNpZGUgd2hpY2ggeGFjdHMgYXJlIHN0aWxs IGluIHByb2dyZXNzLgogCSAqIFRoaXMgaXMgdHJpY2tpZXIgdGhhbiBpdCBtaWdodCBzZWVt LCBiZWNhdXNlIG9mIHJhY2UgY29uZGl0aW9ucy4KQEAgLTI0MzcsOSArMjQ2MiwxOSBAQCBh c3luY1F1ZXVlUmVhZEFsbE5vdGlmaWNhdGlvbnModm9pZCkKIAl9CiAJUEdfRklOQUxMWSgp OwogCXsKLQkJLyogVXBkYXRlIHNoYXJlZCBzdGF0ZSAqLworCQkvKgorCQkgKiBVcGRhdGUg c2hhcmVkIHN0YXRlLgorCQkgKgorCQkgKiBXZSB1cGRhdGUgZG9uZVBvcyB0byB3aGF0IHdl IGFjdHVhbGx5IHJlYWQgKHRoZSBsb2NhbCBwb3MgdmFyaWFibGUpLAorCQkgKiBhcyB0aGlz IGlzIHVzZWQgZm9yIHRydW5jYXRpb24gc2FmZXR5LiAgRm9yIHRoZSByZWFkIHBvc2l0aW9u IChwb3MpLAorCQkgKiB3ZSB1c2UgdGhlIG1heGltdW0gb2Ygb3VyIGxvY2FsIHBvc2l0aW9u IGFuZCB0aGUgY3VycmVudCBzaGFyZWQKKwkJICogcG9zaXRpb24sIGluIGNhc2UgYW5vdGhl ciBiYWNrZW5kIHVzZWQgZGlyZWN0IGFkdmFuY2VtZW50IHRvIHNraXAgdXMKKwkJICogYWhl YWQgd2hpbGUgd2Ugd2VyZSByZWFkaW5nLiAgVGhpcyBwcmV2ZW50cyB1cyBmcm9tIGdvaW5n IGJhY2t3YXJkcworCQkgKiBhbmQgcG90ZW50aWFsbHkgcG9pbnRpbmcgdG8gYSB0cnVuY2F0 ZWQgcGFnZS4KKwkJICovCiAJCUxXTG9ja0FjcXVpcmUoTm90aWZ5UXVldWVMb2NrLCBMV19T SEFSRUQpOwotCQlRVUVVRV9CQUNLRU5EX1BPUyhNeVByb2NOdW1iZXIpID0gcG9zOworCQlR VUVVRV9CQUNLRU5EX0RPTkVQT1MoTXlQcm9jTnVtYmVyKSA9IHBvczsKKwkJUVVFVUVfQkFD S0VORF9QT1MoTXlQcm9jTnVtYmVyKSA9IFFVRVVFX1BPU19NQVgocG9zLCBRVUVVRV9CQUNL RU5EX1BPUyhNeVByb2NOdW1iZXIpKTsKIAkJTFdMb2NrUmVsZWFzZShOb3RpZnlRdWV1ZUxv Y2spOwogCX0KIAlQR19FTkRfVFJZKCk7CkBAIC0yNTg5LDcgKzI2MjQsMTMgQEAgYXN5bmNR dWV1ZUFkdmFuY2VUYWlsKHZvaWQpCiAJZm9yIChQcm9jTnVtYmVyIGkgPSBRVUVVRV9GSVJT VF9MSVNURU5FUjsgaSAhPSBJTlZBTElEX1BST0NfTlVNQkVSOyBpID0gUVVFVUVfTkVYVF9M SVNURU5FUihpKSkKIAl7CiAJCUFzc2VydChRVUVVRV9CQUNLRU5EX1BJRChpKSAhPSBJbnZh bGlkUGlkKTsKLQkJbWluID0gUVVFVUVfUE9TX01JTihtaW4sIFFVRVVFX0JBQ0tFTkRfUE9T KGkpKTsKKwkJLyoKKwkJICogVXNlIGRvbmVQb3MgcmF0aGVyIHRoYW4gcG9zIGZvciB0cnVu Y2F0aW9uIHNhZmV0eS4gIFRoZSBkb25lUG9zCisJCSAqIGZpZWxkIHJlcHJlc2VudHMgd2hh dCB0aGUgYmFja2VuZCBoYXMgZGVmaW5pdGl2ZWx5IHByb2Nlc3NlZCwgd2hpbGUKKwkJICog cG9zIGNhbiBiZSBhZHZhbmNlZCBieSBvdGhlciBiYWNrZW5kcyB2aWEgZGlyZWN0IGFkdmFu Y2VtZW50LiAgVGhpcworCQkgKiBwcmV2ZW50cyB0cnVuY2F0aW5nIHBhZ2VzIHRoYXQgYSBi YWNrZW5kIGlzIHN0aWxsIHJlYWRpbmcgZnJvbS4KKwkJICovCisJCW1pbiA9IFFVRVVFX1BP U19NSU4obWluLCBRVUVVRV9CQUNLRU5EX0RPTkVQT1MoaSkpOwogCX0KIAlRVUVVRV9UQUlM ID0gbWluOwogCW9sZHRhaWxwYWdlID0gUVVFVUVfU1RPUF9QQUdFOwotLSAKMi41MC4xCgo= --ce7d73ebaa3f43ad826ea7bd8f210476--