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.96) (envelope-from ) id 1wThhl-000hVQ-1Q for pgsql-hackers@arkaria.postgresql.org; Sun, 31 May 2026 15:03:57 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1wThhj-007ihR-2H for pgsql-hackers@arkaria.postgresql.org; Sun, 31 May 2026 15:03:56 +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.96) (envelope-from ) id 1wThhj-007ihI-03 for pgsql-hackers@lists.postgresql.org; Sun, 31 May 2026 15:03:55 +0000 Received: from mail-vk1-xa2c.google.com ([2607:f8b0:4864:20::a2c]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.98.2) (envelope-from ) id 1wThhe-00000000QvD-3tkx for pgsql-hackers@postgresql.org; Sun, 31 May 2026 15:03:53 +0000 Received: by mail-vk1-xa2c.google.com with SMTP id 71dfb90a1353d-59d6e44e5c8so618619e0c.2 for ; Sun, 31 May 2026 08:03:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=dunslane-net.20251104.gappssmtp.com; s=20251104; t=1780239830; x=1780844630; darn=postgresql.org; h=in-reply-to:autocrypt:content-language:from:references:to:subject :user-agent:mime-version:date:message-id:from:to:cc:subject:date :message-id:reply-to; bh=SeNjNis/hpNhPoCPRf5fEQNVs80TMe8YJ8vhJ8Vpj/I=; b=XRbP8bFkwaYZR7DDQ4u8tA13rucpADxVsNbcTCyAFJEnr81luxdvuo/bZMiQnH592i rOb0Sopumhx+HNdE4kno5QIpI93DoxECtJe8o4coEWLXgSu/UNHn1/SjGCq6B6eCofu/ OX21fI1o2fDxsdL6E1b7RlABusBYx+oQv8wF5EudBcZT7zjw7p22QyGvOffWrVmOkC3e +yyjKz16fDGEH0tccpGki21rfVaAfck0PIiA+1aonfF4Uq20tYDJmQOlgPezk6/y623J J/iY8Hts4DmZ9FLWFXGVCK1vRWwxZy7CUNEsUt3wlXBNgRI6jzVE9FLm38iS34h/qTtx 8ZQQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1780239830; x=1780844630; h=in-reply-to:autocrypt:content-language:from:references:to:subject :user-agent:mime-version:date:message-id:x-gm-gg:x-gm-message-state :from:to:cc:subject:date:message-id:reply-to; bh=SeNjNis/hpNhPoCPRf5fEQNVs80TMe8YJ8vhJ8Vpj/I=; b=QghM88rxXIlV+EW2VUt/m9DynnzszqSuyCSvPovrpr4nQPugie429sT+4EO0Lek78a fHrObBqvNxkGYBDxkAXhbbwVh/t1OhQJ/BpuYF2SYL1Rhe3calsSZzwbGHFeKmlwvFUd N6nl+IudMjhTfsdg9iHm0IKfdYuoYCluMmtI0vcl1iIligiF8LIisZjxjs05qWwzGmNo wlRvieTOGDAtbEVIOZjI1s4kc1poDQF/FDNO+IA0tQ2HTV5i00gChsJ3g6VXEYOTLaSZ upnkRvV5+P6d63LBPKMl38FRrld3wkyEuTEkT+Dkm7worNheOVg+n02ojcr9iII+PCDo HFhg== X-Forwarded-Encrypted: i=1; AFNElJ+rqS1AYo4942ilSSkKqkFxzHefiy8otqHo4uSWEk9VWLmR+C7ptr7BncnAIPnEhXzc7eJuxuXslo/JHlvx@postgresql.org X-Gm-Message-State: AOJu0Yzc0RRY3qlDSV6dJfk3TIdgNVGzVhxDo7gmc5cOIbo14E80sCY1 C1gutbwyIl+EvBt/NmVBwxcgtyd+d3WGBuv0gBmvdgsXCZznDXfvvpbyAf/46LsLgdI= X-Gm-Gg: Acq92OH6P1hBDVQsTyWhRNqaK3AFlA0M+NhuVPJBJNfhnWkIij/2jviuSQ6Pl3dCWNr G/S87Y2lHuMejnARrptgdFGgtoykJtn7acpeUIXhhRZiVrPjbR6m+JBWPNHnW0LL/+aw8cQgr+O QJkErrdCnhCI+DWVxD7Wm6uEsp+E9G4j2O2/hoflo7+AuqjQddcVXhrla7/j8aemJvEyWYCynCm CA2PjsOvnR26ZtPKxJEC9QHDi6ZbSQ8uLqKuVCDeD6/+y/FtZb23Ihg7YU4Xf0mS5c2E30S0Dm7 PIBQdBCTM22pgbqpuI2JH+9N1iN96HKmitWO58Ixr66m/zw8RMz4ertPPvUTGYJGnfQo248SRxN DD79UUCgv3WTRrLywDiPMxBCQHlisy6/iAagbT3Pn1084g6z4FC7L5Qa5HgGLtWSX6fzGQkrE5A bsWEm7juxRNBmcBuqu08D5tpKld9Y6jvTlGgIPvi2M X-Received: by 2002:a05:6122:4006:b0:56e:f1d2:c3ca with SMTP id 71dfb90a1353d-59bf0aa0522mr3169802e0c.2.1780239829864; Sun, 31 May 2026 08:03:49 -0700 (PDT) Received: from ?IPV6:2605:a601:a6b0:500::1cb? ([2605:a601:a6b0:500::1cb]) by smtp.googlemail.com with ESMTPSA id 6a1803df08f44-8ccea08b749sm70709266d6.19.2026.05.31.08.03.48 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Sun, 31 May 2026 08:03:48 -0700 (PDT) Content-Type: multipart/mixed; boundary="------------W5bFIh3ctAXAmJgggZldxehu" Message-ID: <12d255f1-533f-414f-8caa-9867759cfce9@dunslane.net> Date: Sun, 31 May 2026 11:03:47 -0400 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: hashjoins vs. Bloom filters (yet again) To: Tomas Vondra , PostgreSQL Hackers References: <5cd8c20c-14b5-4b0d-bedc-69bf714e87eb@vondra.me> From: Andrew Dunstan Content-Language: en-US Autocrypt: addr=andrew@dunslane.net; keydata= xsBNBE7KWFkBCAClridxur2AIc7eW2AR7izbfp3EnNefie2HbLF0izW5Ik5UjX2HBXBx4syI gY6b0ugohXrr274+baoAlvSbq6cAoQuEVrk5IZFzt20b1Xkx65FwGSEj526yiKLocqkJceSq Xr9xcA5SGY+FZv441chh5SU92v4q6z+6LPpoHOh97ptAVXZYNTtU0LevyvD5lja0TzbvJm6C eFXitJfnm1pLEr0DGJCR/iUOl/N62Kh4855zZC7NHIjQHPOvV5Stz/l5ilDhvGVk+xkXFPys SjZoUr1rXhYLpiyi5sR0X9FHXT0KnGuz1F5ERO7ZTLSSQ6fJwPj6gOk9K+vvoKvoeql5ABEB AAHNJEFuZHJldyBEdW5zdGFuIDxhbmRyZXdAZHVuc2xhbmUubmV0PsLAlwQTAQgAQQIbAwIX gAIZAQULCQgHAwUVCgkICwUWAgMBAAIeBRYhBOQ+WEYd/Hy/RGkVpZn6f8tZ/DuBBQJoGNGd BQkdEO8nAAoJEJn6f8tZ/DuBq74H/jkTR4Zi3stbw+xC7v2u3QozssK7MYPL2AsVfh7OealS h182fiWXpfvmmAB7WUHbhk9GC2RAOnHI/2d2jgKaMLAHsGYOT0YopTVIwRY43fCw/mK67yxc wmDcX+zyKfLaivNbf5A7QPLNwda98bEAMSJ8Sn652Uc6cA8t3uKGsVzbRBQOoYzjgvBCfSrE 9ql3PDNg0l4BfAqabd2f70ZUm9VAMEPrgv/v2xI7M2XiL4g5BVmqLCOwxLM8RMCotCuoweUr VO43DeBCIDwLxotMJKvGWDjBzQYlU1NPUAtNcz/gN9ITUe1VUGjyvGj4u1lxBOcQQUw7l1+T 5moZ4iZxXzvOwE0ETspYWQEIANGc4zQULOxhbqO2dyD51YhqCNRmm9oKWaqf+wmW4tpDe/VV cxAnNizd4LWCHfzpb5cHAtGkOPePMfzWVf6nvdF7d3eglbtf59+zG7O7llV0xSSoFiieQBsr GvqDInXYX/4mRRXMtyhM353/tixC9RWLs1oofyYmCPPXXY7h9R7en3B8BoVrRFcdzlIY/NFN hFGW/9dkEiGjgna2Rk6e15kln4ZvFBWUg23p93w/pqXcxY6+k/8TEk+C4R+M6w7o2PLGOjdZ +kPiUcw5H85zf/yZJwQXzisXaNduwWB6Vads9YC9dj6kPR1c4VGRqAaYL++LAEOqrlvm2Tvq QqZRtnEAEQEAAcLAfAQYAQgAJgIbDBYhBOQ+WEYd/Hy/RGkVpZn6f8tZ/DuBBQJoGNI2BQkd EODdAAoJEJn6f8tZ/DuBfw0IAKTsfD40teP/pp+bsLLMSxPXUYrrprTj7WFB5v61p6dkpSr/ qXmMlyahdxQFaPmfVgVirB1Vk/kHiWNnnGjfUV9nB2Zg9LI0Xb9/ts3LsUiRWXzG3tkMY6XL vsVOxW4XFRND9l2q+WW93aZ1DZl+fqWfYgMvsusFRhmGFOKTRfKPta2Pkv+AhA24N4+PrR5p bU4k2MO8PAGiK8eaYKGFG1bHKuAvoDoF7WXJ3FHxuWqLnKEt4dfOLm5pAe3zq1Lt6q8azT9i QWGpSAK5vQUWQHBHpiDjdPeqKZ6HiAXIIKfSmb+jrvXBqoP+D6/K7rUjG2aXiRtTIAXms9sm VRu7cmw= In-Reply-To: List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk This is a multi-part message in MIME format. --------------W5bFIh3ctAXAmJgggZldxehu Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit On 2026-05-30 Sa 2:14 PM, Tomas Vondra wrote: > > > Hi, Tomas > > This is terrific and very timely from my POV. > > I've been experimenting with a table AM (implemented as a > CustomScan scan provider), and bloom-filter pushdown from a hashjoin is one > of the bigger wins available to it: a fact-table scan joined to a filtered > dimension can use the filter to skip whole row groups and avoid > decompressing columns entirely, rather than just rejecting a tuple after > it's been produced. I'd hacked up a private version of this via a new > table-AM callback (the hashjoin walks the outer subtree, builds a filter > from the build side, and hands it to the AM's scan descriptor). Having now > read your PoC, I think your framework is the better foundation, and I'd > rather build on it than carry a parallel mechanism. But two things stand in > the way of a storage-level consumer using it, and I think both are > relatively > small. > > OK, good to hear. I was actually thinking about that use case too, i.e. > making it possible for the scan to do something smart with the filter > (like even pushing it even further down, to "storage"). Or maybe the > ForeignScan could push it to the remote side, so that it's actually > filtered there. > > I didn't mention that my message, and there are some difficulties: > > 1) We only build the hash (and bloom) with a delay, after the scan > already produces some tuples. That complicates the pushdown, whiich may > need to happen when starting the scan. Presumably, we'd need to allow > disabling this optimization, optionally. > > 2) We'd need some sort of "portable" Bloom filter, with serialization > and deserialization, etc. > > Both of these seem rather solvable. > >> 1) A CustomScan can't currently be a recipient. >> >> find_bloom_filter_recipient() only recognizes the stock scan tags, and the >> probe itself lives in ExecScanExtended(), which a CustomScan never calls >> (it dispatches to the provider's ExecCustomScan). The second part is >> actually a feature, not a bug: if a CustomScan provider does its own >> probing, it can choose the granularity -- per dictionary entry, per row >> group, or per row -- instead of being locked into the per-row, >> post-materialization probe that the stock nodes get. So all that's needed >> on your side is to let the planner attach a filter to a base-relation >> CustomScan; the provider takes care of consuming it. >> >> Concretely, that's adding T_CustomScan to the scan-leaf case in >> find_bloom_filter_recipient() (CustomScan embeds Scan first, so the >> scanrelid test is identical; non-leaf custom nodes have scanrelid == 0 and >> fall through to NULL), plus the matching fix_scan_bloom_filters() call in >> set_customscan_references(). The provider then calls ExecInitBloomFilters() >> in BeginCustomScan and ExecBloomFilters() (or a coarser-grained variant) >> inside its scan loop. Everything else -- producer registration, the >> es_bloom_producers lookup, the adaptive sampling, EXPLAIN -- is reused >> unchanged. >> > Yes, that should work and it's a mostly mechanical change. > > Maybe we'd want some sort of opt-in, so that the CustomScan can indicate > it can handle Bloom filters. Like, setting > CUSTOMPATH_SUPPORT_BLOOM_FILTERS to flags. > >> 2) The combined-hash filter can't be tested against a single column. >> >> You build one filter keyed on hash32() of all the join keys combined. For a >> single-key join that's ideal, and a column store can use it directly: hash >> each distinct dictionary value once per row group and skip groups whose >> values are all absent. For a multi-column join, though, the combined hash >> mixes the keys, so it can only ever be tested per-row (with all key columns >> in hand) -- it can't be checked against any one column's dictionary. The >> per-row probe is still useful, but the row-group/dictionary skipping, which >> is where most of the storage win comes from, isn't available. >> >> The obvious thought is to key a filter per column instead. But I don't >> think that should *replace* the combined filter, because per-column filters >> are strictly less selective on multi-column joins: they only test whether >> each column's value appears *somewhere* in the build side, not whether the >> combination does. With build pairs {(1,10),(2,20)}, an outer (1,20) passes >> both per-column filters even though it matches no build row, whereas the >> combined filter rejects it. So for the row-level probe -- and especially >> for plain heap -- the combined filter is the better one, and replacing it >> would be a regression. >> >> What I think would actually help is to let the framework *optionally* emit >> per-column filters in addition to the combined one, when a recipient >> signals it can use them. The combined filter stays the default and does the >> precise per-row rejection (unchanged for heap, and usable per-row by a >> column store too); the per-column filters are extra, built only on demand, >> and let a storage consumer cheaply eliminate whole row groups before the >> combined filter does the exact work. The cost is the build CPU and memory >> for the extra filters -- but only for consumers that ask, so your design is >> untouched when nobody does. For a single-key join the two filters >> coincide, so >> there'd be no reason to build both. >> > I think I speculated about this (having per-key filters) in some of the > comments in the patch, although the use case was different. I haven't > thought about TAM, but about different joins where the join keys come > from both sides. Consider a join like > > HJ > / \ > A HJ > / \ > B C > > where A-(BC) is on (A.x = B.x AND A.y = C.y), so the complete filter > can't be pushed to either side. But we could: > > (1) Push the filter on top of the BC join (which in this example is not > really a push-down). > > (2) Build filters on (x) and (y) separately, and push-down these. > > Or we could do both, really. > > I suppose a variation of (2) would work for your use case too, except > we'd push all three filters (x,y), (x) and (y) to the same scan. > > I guess this could also be opt-in, enabled by some CUSTOMPATH_ flag. > > The question is how efficient can the smaller filters be. The complete > filter can be very selective, while the per-key filters are terrible. > >> I'd be happy to work on patches for these. >> > Great. It's and interesting experiment / area to explore. Here are 3 patches (developed using Claude) that sit on top of your POC. Patch 1 enables the pushdown filters for custom scans. As you say it's fairly mechanical and is enabled by a CUSTOMPATH_SUPPORT_BLOOM_FILTERS path flag. Patch 2 provides for building per-key filters in addition to the multi-key filter if that flag is set. There may be other cases that would want it, but this would suit my immediate use case. Patch 3 provides for eager creation of the filter(s) in such cases, disabling the optimization you mentioned in point 1 above. > > FWIW I think the main difficulty for this PoC is going to be the > planning/costing stuff, and the impact on EXPLAIN. > > I haven't dealt with that or other issues you raise, but I think this is enough for me to begin testing. I have adapted my TAM to it and verified that it acts as expected. I will start doing some benchmarks. cheers andrew -- Andrew Dunstan EDB: https://www.enterprisedb.com --------------W5bFIh3ctAXAmJgggZldxehu Content-Type: text/plain; charset=UTF-8; name="0001-Allow-a-CustomScan-to-receive-a-pushed-down-hashjoin.patch.text" Content-Disposition: attachment; filename*0="0001-Allow-a-CustomScan-to-receive-a-pushed-down-hashjoin.pa"; filename*1="tch.text" Content-Transfer-Encoding: base64 RnJvbSBmZjczNDUxMWQyMmJjYjkzZjVjMTI1NmZkNzQ1YTlkMjE4MThmN2YxIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbmRyZXcgRHVuc3RhbiA8YW5kcmV3QGR1bnNsYW5l Lm5ldD4KRGF0ZTogU3VuLCAzMSBNYXkgMjAyNiAwNzoxMzo0OCAtMDQwMApTdWJqZWN0OiBb UEFUQ0ggYWRkb24gMS8zXSBBbGxvdyBhIEN1c3RvbVNjYW4gdG8gcmVjZWl2ZSBhIHB1c2hl ZC1kb3duCiBoYXNoam9pbiBibG9vbSBmaWx0ZXIKCkV4dGVuZCB0aGUgaGFzaGpvaW4gYmxv b20tZmlsdGVyIHB1c2hkb3duIHNvIHRoYXQgYSBiYXNlLXJlbGF0aW9uCkN1c3RvbVNjYW4g Y2FuIGJlIGEgcmVjaXBpZW50LCBnYXRlZCBvbiBhIG5ldyBvcHQtaW4gcGF0aCBmbGFnCkNV U1RPTVBBVEhfU1VQUE9SVF9CTE9PTV9GSUxURVJTLiAgVGhpcyBsZXRzIGEgdGFibGUgQU0g aW1wbGVtZW50ZWQgYXMgYQpDdXN0b21TY2FuIHNjYW4gcHJvdmlkZXIgY29uc3VtZSB0aGUg ZmlsdGVyIGFuZCBhcHBseSBpdCBpbnNpZGUgaXRzIG93bgpzY2FuIGxvb3AgLS0gZm9yIGEg Y29sdW1uIHN0b3JlLCBhdCByb3ctZ3JvdXAgb3IgZGljdGlvbmFyeSBncmFudWxhcml0eSwK YmVmb3JlIGRlY29tcHJlc3Npb24gLS0gcmF0aGVyIHRoYW4gb25seSByZWplY3RpbmcgYW4g YWxyZWFkeS1wcm9kdWNlZAp0dXBsZS4KCmZpbmRfYmxvb21fZmlsdGVyX3JlY2lwaWVudCgp IG5vdyB0cmVhdHMgYSBiYXNlLXJlbCBDdXN0b21TY2FuCihzY2FucmVsaWQgPiAwKSB0aGF0 IGFkdmVydGlzZWQgdGhlIGZsYWcgdGhlIHNhbWUgYXMgYSBTZXFTY2FuLiAgVGhlCnByb2Jl IGlzIG5vdCB3aXJlZCBpbnRvIEV4ZWNTY2FuRXh0ZW5kZWQoKSAoYSBDdXN0b21TY2FuIGRp c3BhdGNoZXMgdG8KdGhlIHByb3ZpZGVyJ3MgRXhlY0N1c3RvbVNjYW4pLCBzbyB0aGUgcHJv dmlkZXIgY2FsbHMgRXhlY0Jsb29tRmlsdGVycygpCml0c2VsZjsgRXhlY0luaXRDdXN0b21T Y2FuKCkgY29tcGlsZXMgdGhlIHByb2JlIHN0YXRlIHVwIGZyb250IHZpYQpFeGVjSW5pdEJs b29tRmlsdGVycygpIHNvIHRoZSBwcm92aWRlciBuZWVkIG5vdCB0b3VjaCBibG9vbSBpbnRl cm5hbHMuCnNldF9jdXN0b21zY2FuX3JlZmVyZW5jZXMoKSBmaXhlcyB0aGUgcHVzaGVkIGtl eSBleHByZXNzaW9ucyBmb3IgYQpiYXNlLXJlbGF0aW9uIHNjYW4ganVzdCBsaWtlIHRoZSBz Y2FuIHF1YWwuCgpQcm92aWRlcnMgdGhhdCBkbyBub3Qgc2V0IHRoZSBmbGFnLCBhbmQgaGVh cCwgYXJlIHVuYWZmZWN0ZWQuCi0tLQogc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUN1c3Rv bS5jICAgICAgIHwgMTAgKysrKysrKysrKwogc3JjL2JhY2tlbmQvb3B0aW1pemVyL3BsYW4v Y3JlYXRlcGxhbi5jIHwgMTkgKysrKysrKysrKysrKysrKysrKwogc3JjL2JhY2tlbmQvb3B0 aW1pemVyL3BsYW4vc2V0cmVmcy5jICAgIHwgMTAgKysrKysrKysrKwogc3JjL2luY2x1ZGUv bm9kZXMvZXh0ZW5zaWJsZS5oICAgICAgICAgIHwgIDIgKysKIDQgZmlsZXMgY2hhbmdlZCwg NDEgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25v ZGVDdXN0b20uYyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVDdXN0b20uYwppbmRleCBi N2NjODkwY2QyMC4uZGZkODdlNDk3MzcgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1 dG9yL25vZGVDdXN0b20uYworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlQ3VzdG9t LmMKQEAgLTEwMSw2ICsxMDEsMTYgQEAgRXhlY0luaXRDdXN0b21TY2FuKEN1c3RvbVNjYW4g KmNzY2FuLCBFU3RhdGUgKmVzdGF0ZSwgaW50IGVmbGFncykKIAljc3MtPnNzLnBzLnF1YWwg PQogCQlFeGVjSW5pdFF1YWwoY3NjYW4tPnNjYW4ucGxhbi5xdWFsLCAoUGxhblN0YXRlICop IGNzcyk7CiAKKwkvKgorCSAqIFNldCB1cCBhbnkgYmxvb20gZmlsdGVycyBhIGhhc2ggam9p biBwdXNoZWQgZG93biB0byB0aGlzIHNjYW4gKHNlZQorCSAqIG5vZGVIYXNoam9pbi5jKS4g IFRoaXMgY29tcGlsZXMgdGhlIHByb2JlIGV4cHJlc3Npb25zIGFnYWluc3QgdGhlIHNjYW4K KwkgKiB0dXBsZSBzbG90OyB0aGUgcHJvdmlkZXIgaXMgcmVzcG9uc2libGUgZm9yIGFjdHVh bGx5IHByb2JpbmcgdGhlbSB3aXRoCisJICogRXhlY0Jsb29tRmlsdGVycygpIGZyb20gaXRz IEV4ZWNDdXN0b21TY2FuIGNhbGxiYWNrLCBhdCB3aGF0ZXZlcgorCSAqIGdyYW51bGFyaXR5 IGl0IHN1cHBvcnRzLiAgQSBuby1vcCB1bmxlc3MgdGhlIHByb3ZpZGVyIGFkdmVydGlzZWQK KwkgKiBDVVNUT01QQVRIX1NVUFBPUlRfQkxPT01fRklMVEVSUyBhbmQgdGhlIHBsYW5uZXIg Zm91bmQgYSBmaWx0ZXIgdG8gcHVzaC4KKwkgKi8KKwlFeGVjSW5pdEJsb29tRmlsdGVycygo UGxhblN0YXRlICopIGNzcywgY3NzLT5zcy5zc19TY2FuVHVwbGVTbG90KTsKKwogCS8qCiAJ ICogVGhlIGNhbGxiYWNrIG9mIGN1c3RvbS1zY2FuIHByb3ZpZGVyIGFwcGxpZXMgdGhlIGZp bmFsIGluaXRpYWxpemF0aW9uCiAJICogb2YgdGhlIGN1c3RvbS1zY2FuLXN0YXRlIG5vZGUg YWNjb3JkaW5nIHRvIGl0cyBsb2dpYy4KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL29wdGlt aXplci9wbGFuL2NyZWF0ZXBsYW4uYyBiL3NyYy9iYWNrZW5kL29wdGltaXplci9wbGFuL2Ny ZWF0ZXBsYW4uYwppbmRleCA3ZWNiNTUxYWFlNi4uMzA0Y2UwZTNjMGQgMTAwNjQ0Ci0tLSBh L3NyYy9iYWNrZW5kL29wdGltaXplci9wbGFuL2NyZWF0ZXBsYW4uYworKysgYi9zcmMvYmFj a2VuZC9vcHRpbWl6ZXIvcGxhbi9jcmVhdGVwbGFuLmMKQEAgLTQ3OTksNiArNDc5OSwyNSBA QCBmaW5kX2Jsb29tX2ZpbHRlcl9yZWNpcGllbnQoUGxhbiAqcGxhbiwgSW5kZXggdGFyZ2V0 X3JlbGlkKQogCQkJCQlyZXR1cm4gcGxhbjsKIAkJCQlyZXR1cm4gTlVMTDsKIAkJCX0KKwkJ Y2FzZSBUX0N1c3RvbVNjYW46CisJCQl7CisJCQkJLyoKKwkJCQkgKiBBIEN1c3RvbVNjYW4g b24gYSBiYXNlIHJlbGF0aW9uIGNhbiBhY3QgYXMgYSByZWNpcGllbnQsIGJ1dAorCQkJCSAq IG9ubHkgaWYgdGhlIHByb3ZpZGVyIGFkdmVydGlzZWQgdGhhdCBpdCBrbm93cyBob3cgdG8g Y29uc3VtZQorCQkJCSAqIGEgcHVzaGVkLWRvd24gYmxvb20gZmlsdGVyLiAgVW5saWtlIHRo ZSBzdG9jayBzY2FucywgdGhlCisJCQkJICogcHJvYmUgaXMgbm90IHBlcmZvcm1lZCBieSBF eGVjU2NhbkV4dGVuZGVkKCkgKGEgQ3VzdG9tU2NhbgorCQkJCSAqIGRpc3BhdGNoZXMgdG8g dGhlIHByb3ZpZGVyJ3Mgb3duIEV4ZWNDdXN0b21TY2FuKTsgdGhlCisJCQkJICogcHJvdmlk ZXIgaXMgcmVzcG9uc2libGUgZm9yIGNhbGxpbmcgRXhlY0Jsb29tRmlsdGVycygpIGF0CisJ CQkJICogd2hhdGV2ZXIgZ3JhbnVsYXJpdHkgaXQgbGlrZXMuICBOb24tbGVhZiBjdXN0b20g bm9kZXMgaGF2ZQorCQkJCSAqIHNjYW5yZWxpZCA9PSAwIGFuZCBzbyBhcmUgcmVqZWN0ZWQg YnkgdGhlIHJlbGlkIHRlc3QuCisJCQkJICovCisJCQkJQ3VzdG9tU2NhbiAqY3NjYW4gPSAo Q3VzdG9tU2NhbiAqKSBwbGFuOworCisJCQkJaWYgKChjc2Nhbi0+ZmxhZ3MgJiBDVVNUT01Q QVRIX1NVUFBPUlRfQkxPT01fRklMVEVSUykgJiYKKwkJCQkJY3NjYW4tPnNjYW4uc2NhbnJl bGlkID09IHRhcmdldF9yZWxpZCkKKwkJCQkJcmV0dXJuIHBsYW47CisJCQkJcmV0dXJuIE5V TEw7CisJCQl9CiAJCWNhc2UgVF9Tb3J0OgogCQljYXNlIFRfSW5jcmVtZW50YWxTb3J0Ogog CQljYXNlIFRfTWF0ZXJpYWw6CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9vcHRpbWl6ZXIv cGxhbi9zZXRyZWZzLmMgYi9zcmMvYmFja2VuZC9vcHRpbWl6ZXIvcGxhbi9zZXRyZWZzLmMK aW5kZXggMDA1OWFjZmNjYmUuLjc0YzdhNWJmM2E1IDEwMDY0NAotLS0gYS9zcmMvYmFja2Vu ZC9vcHRpbWl6ZXIvcGxhbi9zZXRyZWZzLmMKKysrIGIvc3JjL2JhY2tlbmQvb3B0aW1pemVy L3BsYW4vc2V0cmVmcy5jCkBAIC0xODI2LDYgKzE4MjYsMTYgQEAgc2V0X2N1c3RvbXNjYW5f cmVmZXJlbmNlcyhQbGFubmVySW5mbyAqcm9vdCwKIAkJY3NjYW4tPmN1c3RvbV9leHBycyA9 CiAJCQlmaXhfc2Nhbl9saXN0KHJvb3QsIGNzY2FuLT5jdXN0b21fZXhwcnMsCiAJCQkJCQkg IHJ0b2Zmc2V0LCBOVU1fRVhFQ19RVUFMKChQbGFuICopIGNzY2FuKSk7CisKKwkJLyoKKwkJ ICogQmxvb20gZmlsdGVycyBwdXNoZWQgZG93biB0byBhIGJhc2UtcmVsYXRpb24gQ3VzdG9t U2NhbjogdGhlIGtleQorCQkgKiBleHByZXNzaW9ucyBhcmUgcGxhaW4gVmFycyBvZiB0aGUg c2Nhbm5lZCByZWxhdGlvbiwgc28gdGhleSBhcmUKKwkJICogZml4ZWQgdXAgdGhlIHNhbWUg d2F5IGFzIHRoZSBzY2FuIHF1YWwuICAoQSBDdXN0b21TY2FuIGVtaXR0aW5nIGEKKwkJICog Y3VzdG9tX3NjYW5fdGxpc3QgdGFrZXMgdGhlIGJyYW5jaCBhYm92ZSBhbmQgd291bGQgaW5z dGVhZCBuZWVkCisJCSAqIGZpeF91cHBlcl9leHByIGFnYWluc3QgdGhlIHRsaXN0IGluZGV4 LCBsaWtlIEluZGV4T25seVNjYW47IG5vCisJCSAqIGluLXRyZWUgcHJvdmlkZXIgbmVlZHMg dGhhdCB5ZXQuKQorCQkgKi8KKwkJZml4X3NjYW5fYmxvb21fZmlsdGVycyhyb290LCAoUGxh biAqKSBjc2NhbiwgcnRvZmZzZXQpOwogCX0KIAogCS8qIEFkanVzdCBjaGlsZCBwbGFuLW5v ZGVzIHJlY3Vyc2l2ZWx5LCBpZiBuZWVkZWQgKi8KZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRl L25vZGVzL2V4dGVuc2libGUuaCBiL3NyYy9pbmNsdWRlL25vZGVzL2V4dGVuc2libGUuaApp bmRleCA1MTdkYjk1YzRhMy4uZWEyY2VmNGZlM2IgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRl L25vZGVzL2V4dGVuc2libGUuaAorKysgYi9zcmMvaW5jbHVkZS9ub2Rlcy9leHRlbnNpYmxl LmgKQEAgLTg0LDYgKzg0LDggQEAgZXh0ZXJuIGNvbnN0IEV4dGVuc2libGVOb2RlTWV0aG9k cyAqR2V0RXh0ZW5zaWJsZU5vZGVNZXRob2RzKGNvbnN0IGNoYXIgKmV4dG5vZGUKICNkZWZp bmUgQ1VTVE9NUEFUSF9TVVBQT1JUX0JBQ0tXQVJEX1NDQU4JMHgwMDAxCiAjZGVmaW5lIENV U1RPTVBBVEhfU1VQUE9SVF9NQVJLX1JFU1RPUkUJCTB4MDAwMgogI2RlZmluZSBDVVNUT01Q QVRIX1NVUFBPUlRfUFJPSkVDVElPTgkJMHgwMDA0CisvKiBwcm92aWRlciBjYW4gYWNjZXB0 IGEgaGFzaGpvaW4gYmxvb20gZmlsdGVyIHB1c2hlZCBkb3duIHRvIGl0cyBzY2FuICovCisj ZGVmaW5lIENVU1RPTVBBVEhfU1VQUE9SVF9CTE9PTV9GSUxURVJTCTB4MDAwOAogCiAvKgog ICogQ3VzdG9tIHBhdGggbWV0aG9kcy4gIE1vc3RseSwgd2UganVzdCBuZWVkIHRvIGtub3cg aG93IHRvIGNvbnZlcnQgYQotLSAKMi40My4wCgo= --------------W5bFIh3ctAXAmJgggZldxehu Content-Type: text/plain; charset=UTF-8; name="0002-Optionally-build-per-key-hashjoin-bloom-filters-for-.patch.text" Content-Disposition: attachment; filename*0="0002-Optionally-build-per-key-hashjoin-bloom-filters-for-.pa"; filename*1="tch.text" Content-Transfer-Encoding: base64 RnJvbSAyYmFjM2JiOGE0OTE3Zjc3ZGViMTk5OTg3NTI0OTNmNzViNGYxYzcwIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbmRyZXcgRHVuc3RhbiA8YW5kcmV3QGR1bnNsYW5l Lm5ldD4KRGF0ZTogU3VuLCAzMSBNYXkgMjAyNiAwNzoxMzo1OCAtMDQwMApTdWJqZWN0OiBb UEFUQ0ggYWRkb24gMi8zXSBPcHRpb25hbGx5IGJ1aWxkIHBlci1rZXkgaGFzaGpvaW4gYmxv b20gZmlsdGVycyBmb3IKIG9wdGVkLWluIHJlY2lwaWVudHMKCkFkZCBhbiBvcHQtaW4gcGF0 aCB0aGF0IGJ1aWxkcyBvbmUgYmxvb20gZmlsdGVyIHBlciBqb2luIGtleSwgaW4KYWRkaXRp b24gdG8gdGhlIGV4aXN0aW5nIGNvbWJpbmVkLWhhc2ggZmlsdGVyLCB3aGVuIHRoZSBwdXNo ZG93bgpyZWNpcGllbnQgaXMgYSBDdXN0b21TY2FuIHRoYXQgYWR2ZXJ0aXNlZCBDVVNUT01Q QVRIX1NVUFBPUlRfQkxPT01fRklMVEVSUwphbmQgdGhlIGpvaW4gaGFzIG1vcmUgdGhhbiBv bmUga2V5LgoKVGhlIGNvbWJpbmVkIGZpbHRlciwga2V5ZWQgb24gdGhlIGhhc2ggb2YgYWxs IGtleXMgdG9nZXRoZXIsIHN0YXlzIHRoZQpkZWZhdWx0IGFuZCByZW1haW5zIHRoZSBtb3Jl IHNlbGVjdGl2ZSBvbmUgZm9yIGEgcGVyLXJvdyBwcm9iZTogcGVyLWtleQpmaWx0ZXJzIG9u bHkgdGVzdCB3aGV0aGVyIGVhY2ggY29sdW1uJ3MgdmFsdWUgYXBwZWFycyBzb21ld2hlcmUg aW4gdGhlCmJ1aWxkIHNpZGUsIHNvIG9uIGEgbXVsdGktY29sdW1uIGpvaW4gdGhleSBhcmUg c3RyaWN0bHkgd2Vha2VyICh0aGV5CmNhbm5vdCByZWplY3QgYSByb3cgd2hvc2UgY29sdW1u cyBlYWNoIG1hdGNoIGJ1dCBub3QgYXMgYSB0dXBsZSkuICBXaGF0CnRoZXkgZW5hYmxlIGlz IHRlc3RpbmcgYSBzaW5nbGUga2V5IGNvbHVtbiBvbiBpdHMgb3duIC0tIGEgY29sdW1uIHN0 b3JlCmNhbiBjaGVjayBvbmUgY29sdW1uIGFnYWluc3QgaXRzIHBlci1jb2x1bW4gZGljdGlv bmFyeSBvciB6b25lIG1hcCBhbmQKc2tpcCB3aG9sZSByb3cgZ3JvdXBzIGJlZm9yZSBkZWNv bXByZXNzaW9uLCB3aGljaCB0aGUgY29tYmluZWQgZmlsdGVyCmNhbm5vdCBzdXBwb3J0LgoK VGhlIGJ1aWxkIHJldXNlcyB0aGUgcGVyLWtleSBpbm5lciBoYXNoIGZ1bmN0aW9ucyAodGhl IGNvbWJpbmVkIGhhc2gKdmFsdWUgY2Fubm90IGJlIGRlY29tcG9zZWQsIHNvIHRoZSBIYXNo IG5vZGUgYnVpbGRzIG9uZSBzaW5nbGUta2V5IGhhc2gKRXhwclN0YXRlIHBlciBrZXkpOyB0 aGUgZXh0cmEgQ1BVIGFuZCBtZW1vcnkgYXJlIHBhaWQgb25seSBieSBhIGNvbnN1bWVyCnRo YXQgb3B0ZWQgaW4uICBBIHJlY2lwaWVudCBjb3JyZWxhdGVzIEhhc2hTdGF0ZS5wZXJrZXlf ZmlsdGVyc1tpXSB3aXRoCkJsb29tRmlsdGVyLmZpbHRlcl9leHByc1tpXSBieSBwb3NpdGlv bi4gIEhlYXAgYW5kIHNpbmdsZS1rZXkgam9pbnMgYXJlCnVuYWZmZWN0ZWQuCi0tLQogc3Jj L2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUhhc2guYyAgICAgICAgIHwgMzUgKysrKysrKysrKysr KysrKysrKysrKysrKwogc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUhhc2hqb2luLmMgICAg IHwgMjUgKysrKysrKysrKysrKysrKysrCiBzcmMvYmFja2VuZC9vcHRpbWl6ZXIvcGxhbi9j cmVhdGVwbGFuLmMgfCAxMiArKysrKysrKysKIHNyYy9pbmNsdWRlL25vZGVzL2V4ZWNub2Rl cy5oICAgICAgICAgICB8IDE0ICsrKysrKysrKysKIHNyYy9pbmNsdWRlL25vZGVzL3BsYW5u b2Rlcy5oICAgICAgICAgICB8IDExICsrKysrKysrCiA1IGZpbGVzIGNoYW5nZWQsIDk3IGlu c2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlSGFz aC5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUhhc2guYwppbmRleCAzNzIyNDMyNGJj ZS4uMmIwNDVlYWUxODYgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVI YXNoLmMKKysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUhhc2guYwpAQCAtMTk3LDYg KzE5NywyNSBAQCBNdWx0aUV4ZWNQcml2YXRlSGFzaChIYXNoU3RhdGUgKm5vZGUpCiAJCQkJ CQkJCSAgKHVuc2lnbmVkIGNoYXIgKikgJmhhc2h2YWx1ZSwKIAkJCQkJCQkJICBzaXplb2Yo aGFzaHZhbHVlKSk7CiAKKwkJCS8qCisJCQkgKiBMaWtld2lzZSBmb3IgdGhlIG9wdGlvbmFs IHBlci1rZXkgZmlsdGVycywgdXNpbmcgdGhlIHBlci1rZXkKKwkJCSAqIChzaW5nbGUta2V5 KSBoYXNoIEV4cHJTdGF0ZXMuICBTYW1lIGVjb250ZXh0IGFzIHRoZSBjb21iaW5lZAorCQkJ ICogaGFzaCBhYm92ZSAoZWN4dF9vdXRlcnR1cGxlIGlzIHRoZSBqdXN0LWZldGNoZWQgaW5u ZXIgdHVwbGUpLgorCQkJICovCisJCQlmb3IgKGludCBrID0gMDsgayA8IG5vZGUtPnBlcmtl eV9uZmlsdGVyczsgaysrKQorCQkJeworCQkJCWJvb2wJCWtleWlzbnVsbDsKKwkJCQl1aW50 MzIJCWtleWhhc2g7CisKKwkJCQlrZXloYXNoID0gRGF0dW1HZXRVSW50MzIoRXhlY0V2YWxF eHByU3dpdGNoQ29udGV4dChub2RlLT5wZXJrZXlfaGFzaFtrXSwKKwkJCQkJCQkJCQkJCQkJ CQkgICBlY29udGV4dCwKKwkJCQkJCQkJCQkJCQkJCQkgICAma2V5aXNudWxsKSk7CisJCQkJ aWYgKCFrZXlpc251bGwpCisJCQkJCWJsb29tX2FkZF9lbGVtZW50KG5vZGUtPnBlcmtleV9m aWx0ZXJzW2tdLAorCQkJCQkJCQkJICAodW5zaWduZWQgY2hhciAqKSAma2V5aGFzaCwKKwkJ CQkJCQkJCSAgc2l6ZW9mKGtleWhhc2gpKTsKKwkJCX0KKwogCQkJYnVja2V0TnVtYmVyID0g RXhlY0hhc2hHZXRTa2V3QnVja2V0KGhhc2h0YWJsZSwgaGFzaHZhbHVlKTsKIAkJCWlmIChi dWNrZXROdW1iZXIgIT0gSU5WQUxJRF9TS0VXX0JVQ0tFVF9OTykKIAkJCXsKQEAgLTcyMiw2 ICs3NDEsMjIgQEAgRXhlY0hhc2hUYWJsZUNyZWF0ZShIYXNoU3RhdGUgKnN0YXRlKQogCQlv bGRjdHggPSBNZW1vcnlDb250ZXh0U3dpdGNoVG8oaGFzaHRhYmxlLT5oYXNoQ3h0KTsKIAkJ c3RhdGUtPmJsb29tX2ZpbHRlciA9IGJsb29tX2NyZWF0ZSgoaW50NjQpIE1heChyb3dzLCAx LjApLAogCQkJCQkJCQkJCSAgIGJsb29tX3dvcmtfbWVtLCAwKTsKKworCQkvKgorCQkgKiBJ ZiBhIHJlY2lwaWVudCBvcHRlZCBpbiwgYWxzbyBidWlsZCBvbmUgZmlsdGVyIHBlciBqb2lu IGtleSAoaW4KKwkJICogYWRkaXRpb24gdG8gdGhlIGNvbWJpbmVkIG9uZSBhYm92ZSkuICBU aGVzZSBsZXQgYSByZWNpcGllbnQgdGVzdCBhbgorCQkgKiBpbmRpdmlkdWFsIGtleSBjb2x1 bW4gb24gaXRzIG93bjsgdGhleSBhcmUgbGVzcyBzZWxlY3RpdmUgdGhhbiB0aGUKKwkJICog Y29tYmluZWQgZmlsdGVyLCBzbyB0aGV5IGFyZSBidWlsdCBvbmx5IG9uIGRlbWFuZC4KKwkJ ICovCisJCWlmIChzdGF0ZS0+d2FudF9wZXJrZXlfYmxvb20pCisJCXsKKwkJCXN0YXRlLT5w ZXJrZXlfZmlsdGVycyA9IHBhbGxvY19hcnJheShzdHJ1Y3QgYmxvb21fZmlsdGVyICosCisJ CQkJCQkJCQkJCQkgc3RhdGUtPnBlcmtleV9uZmlsdGVycyk7CisJCQlmb3IgKGludCBpID0g MDsgaSA8IHN0YXRlLT5wZXJrZXlfbmZpbHRlcnM7IGkrKykKKwkJCQlzdGF0ZS0+cGVya2V5 X2ZpbHRlcnNbaV0gPSBibG9vbV9jcmVhdGUoKGludDY0KSBNYXgocm93cywgMS4wKSwKKwkJ CQkJCQkJCQkJCQkJYmxvb21fd29ya19tZW0sIDApOworCQl9CisKIAkJTWVtb3J5Q29udGV4 dFN3aXRjaFRvKG9sZGN0eCk7CiAJfQogCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9leGVj dXRvci9ub2RlSGFzaGpvaW4uYyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVIYXNoam9p bi5jCmluZGV4IDhmYTdhZjRjZmVmLi4xZWFmODEyODVmOCAxMDA2NDQKLS0tIGEvc3JjL2Jh Y2tlbmQvZXhlY3V0b3Ivbm9kZUhhc2hqb2luLmMKKysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0 b3Ivbm9kZUhhc2hqb2luLmMKQEAgLTkwOCw2ICs5MDgsNyBAQCBFeGVjSW5pdEhhc2hKb2lu KEhhc2hKb2luICpub2RlLCBFU3RhdGUgKmVzdGF0ZSwgaW50IGVmbGFncykKIAloYXNoU3Rh dGUgPSBjYXN0Tm9kZShIYXNoU3RhdGUsIGlubmVyUGxhblN0YXRlKGhqc3RhdGUpKTsKIAlo YXNoU3RhdGUtPndhbnRfYmxvb21fZmlsdGVyID0gKG5vZGUtPmJsb29tX2NvbnN1bWVyX2Nv dW50ID4gMCk7CiAJaGFzaFN0YXRlLT5ibG9vbV9maWx0ZXJfaWQgPSBub2RlLT5ibG9vbV9m aWx0ZXJfaWQ7CisJaGFzaFN0YXRlLT53YW50X3BlcmtleV9ibG9vbSA9IG5vZGUtPmJsb29t X3BlcmtleTsKIAogCS8qCiAJICogSW5pdGlhbGl6ZSByZXN1bHQgc2xvdCwgdHlwZSBhbmQg cHJvamVjdGlvbi4KQEAgLTEwMzEsNiArMTAzMiwyOCBAQCBFeGVjSW5pdEhhc2hKb2luKEhh c2hKb2luICpub2RlLCBFU3RhdGUgKmVzdGF0ZSwgaW50IGVmbGFncykKIAkJCQkJCQkJJmhh c2hzdGF0ZS0+cHMsCiAJCQkJCQkJCTApOwogCisJCS8qCisJCSAqIElmIGEgcmVjaXBpZW50 IG9wdGVkIGluIHRvIHBlci1rZXkgYmxvb20gZmlsdGVycywgYnVpbGQgb25lIGlubmVyCisJ CSAqIChzaW5nbGUta2V5KSBoYXNoIEV4cHJTdGF0ZSBwZXIgam9pbiBrZXksIHVzZWQgYnkg dGhlIEhhc2ggbm9kZSB0bworCQkgKiBwb3B1bGF0ZSB0aGUgcGVyLWtleSBmaWx0ZXJzLiAg VGhlIGNvbWJpbmVkIGhhc2ggYWJvdmUgY2Fubm90IGJlCisJCSAqIGRlY29tcG9zZWQsIHNv IHRoaXMgaXMgdGhlIGV4dHJhIGNvc3QgYSBwZXIta2V5IGNvbnN1bWVyIHBheXMuCisJCSAq LworCQlpZiAoaGFzaHN0YXRlLT53YW50X3BlcmtleV9ibG9vbSkKKwkJeworCQkJaGFzaHN0 YXRlLT5wZXJrZXlfbmZpbHRlcnMgPSBua2V5czsKKwkJCWhhc2hzdGF0ZS0+cGVya2V5X2hh c2ggPSBwYWxsb2NfYXJyYXkoRXhwclN0YXRlICosIG5rZXlzKTsKKwkJCWZvciAoaW50IGkg PSAwOyBpIDwgbmtleXM7IGkrKykKKwkJCQloYXNoc3RhdGUtPnBlcmtleV9oYXNoW2ldID0K KwkJCQkJRXhlY0J1aWxkSGFzaDMyRXhwcihoYXNoc3RhdGUtPnBzLnBzX1Jlc3VsdFR1cGxl RGVzYywKKwkJCQkJCQkJCQloYXNoc3RhdGUtPnBzLnJlc3VsdG9wcywKKwkJCQkJCQkJCQkm aW5uZXJfaGFzaGZ1bmNpZFtpXSwKKwkJCQkJCQkJCQlsaXN0X21ha2UxX29pZChsaXN0X250 aF9vaWQobm9kZS0+aGFzaGNvbGxhdGlvbnMsIGkpKSwKKwkJCQkJCQkJCQlsaXN0X21ha2Ux KGxpc3RfbnRoKGhhc2gtPmhhc2hrZXlzLCBpKSksCisJCQkJCQkJCQkJJmhhc2hfc3RyaWN0 W2ldLAorCQkJCQkJCQkJCSZoYXNoc3RhdGUtPnBzLAorCQkJCQkJCQkJCTApOworCQl9CisK IAkJLyogUmVtZW1iZXIgd2hldGhlciB3ZSBuZWVkIHRvIHNhdmUgdHVwbGVzIHdpdGggbnVs bCBqb2luIGtleXMgKi8KIAkJaGpzdGF0ZS0+aGpfS2VlcE51bGxUdXBsZXMgPSBISl9GSUxM X09VVEVSKGhqc3RhdGUpOwogCQloYXNoc3RhdGUtPmtlZXBfbnVsbF90dXBsZXMgPSBISl9G SUxMX0lOTkVSKGhqc3RhdGUpOwpAQCAtMTExOCw2ICsxMTQxLDcgQEAgRXhlY0VuZEhhc2hK b2luKEhhc2hKb2luU3RhdGUgKm5vZGUpCiAJCUV4ZWNIYXNoVGFibGVEZXN0cm95KG5vZGUt PmhqX0hhc2hUYWJsZSk7CiAJCW5vZGUtPmhqX0hhc2hUYWJsZSA9IE5VTEw7CiAJCWhhc2hO b2RlLT5ibG9vbV9maWx0ZXIgPSBOVUxMOworCQloYXNoTm9kZS0+cGVya2V5X2ZpbHRlcnMg PSBOVUxMOwogCX0KIAogCS8qCkBAIC0xNzc1LDYgKzE3OTksNyBAQCBFeGVjUmVTY2FuSGFz aEpvaW4oSGFzaEpvaW5TdGF0ZSAqbm9kZSkKIAkJCSAqIGZyZWVkIGJ5IHRoZSBFeGVjSGFz aFRhYmxlRGVzdHJveSBjYWxsLgogCQkJICovCiAJCQloYXNoTm9kZS0+Ymxvb21fZmlsdGVy ID0gTlVMTDsKKwkJCWhhc2hOb2RlLT5wZXJrZXlfZmlsdGVycyA9IE5VTEw7CiAKIAkJCS8q CiAJCQkgKiBpZiBjaGdQYXJhbSBvZiBzdWJub2RlIGlzIG5vdCBudWxsIHRoZW4gcGxhbiB3 aWxsIGJlIHJlLXNjYW5uZWQKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL29wdGltaXplci9w bGFuL2NyZWF0ZXBsYW4uYyBiL3NyYy9iYWNrZW5kL29wdGltaXplci9wbGFuL2NyZWF0ZXBs YW4uYwppbmRleCAzMDRjZTBlM2MwZC4uNWIwMWIzZTQ1Y2MgMTAwNjQ0Ci0tLSBhL3NyYy9i YWNrZW5kL29wdGltaXplci9wbGFuL2NyZWF0ZXBsYW4uYworKysgYi9zcmMvYmFja2VuZC9v cHRpbWl6ZXIvcGxhbi9jcmVhdGVwbGFuLmMKQEAgLTQ5OTIsNiArNDk5MiwxOCBAQCB0cnlf cHVzaF9ibG9vbV9maWx0ZXIoUGxhbm5lckluZm8gKnJvb3QsIEhhc2hKb2luICpoaiwgUGxh biAqb3V0ZXJfcGxhbikKIAogCXJlY2lwaWVudC0+Ymxvb21fZmlsdGVycyA9IGxhcHBlbmQo cmVjaXBpZW50LT5ibG9vbV9maWx0ZXJzLCBiZik7CiAKKwkvKgorCSAqIElmIHRoZSByZWNp cGllbnQgaXMgYSBDdXN0b21TY2FuIHRoYXQgb3B0ZWQgaW4sIGFsc28gYnVpbGQgYSBzZXBh cmF0ZQorCSAqIGZpbHRlciBwZXIgam9pbiBrZXkuICBPbmx5IHN1Y2ggYSByZWNpcGllbnQg Y2FuIG1ha2UgdXNlIG9mIHRoZW0gKHRvCisJICogdGVzdCBhIHNpbmdsZSBjb2x1bW4gYWdh aW5zdCBhIGRpY3Rpb25hcnkgb3Igem9uZSBtYXApOyB0aGUgY29tYmluZWQKKwkgKiBmaWx0 ZXIgaXMgYWx3YXlzIGJ1aWx0IGFuZCBpcyB0aGUgbW9yZSBzZWxlY3RpdmUgb25lIGZvciB0 aGUgcGVyLXJvdworCSAqIHByb2JlLiAgVGhlcmUgaXMgbm90aGluZyB0byBnYWluIGZvciBh IHNpbmdsZS1rZXkgam9pbiwgd2hlcmUgdGhlIHR3bworCSAqIGNvaW5jaWRlLgorCSAqLwor CWlmIChsaXN0X2xlbmd0aChoYXNoa2V5cykgPiAxICYmIElzQShyZWNpcGllbnQsIEN1c3Rv bVNjYW4pICYmCisJCSgoKEN1c3RvbVNjYW4gKikgcmVjaXBpZW50KS0+ZmxhZ3MgJiBDVVNU T01QQVRIX1NVUFBPUlRfQkxPT01fRklMVEVSUykpCisJCWhqLT5ibG9vbV9wZXJrZXkgPSB0 cnVlOworCiAJLyoKIAkgKiBYWFggV2UndmUgbWFuZ2VkIHRvIHB1c2ggdGhlIGZpbHRlciB0 byB0aGUgc2NhbiBub2RlLCBidXQgbWF5YmUKIAkgKiB3ZSBzaG91bGQgd2FpdCB3aXRoIHVw ZGF0aW5nIGJsb29tX2NvbnN1bWVyX2NvdW50IHdoZW4gaXQgYWN0dWFsbHkKZGlmZiAtLWdp dCBhL3NyYy9pbmNsdWRlL25vZGVzL2V4ZWNub2Rlcy5oIGIvc3JjL2luY2x1ZGUvbm9kZXMv ZXhlY25vZGVzLmgKaW5kZXggMDQzMzNmMWE0ZDAuLmVlOThiY2IzYWRmIDEwMDY0NAotLS0g YS9zcmMvaW5jbHVkZS9ub2Rlcy9leGVjbm9kZXMuaAorKysgYi9zcmMvaW5jbHVkZS9ub2Rl cy9leGVjbm9kZXMuaApAQCAtMjc4Myw2ICsyNzgzLDIwIEBAIHR5cGVkZWYgc3RydWN0IEhh c2hTdGF0ZQogCSAqLwogCXN0cnVjdCBibG9vbV9maWx0ZXIgKmJsb29tX2ZpbHRlcjsKIAor CS8qCisJICogT3B0aW9uYWwgcGVyLWtleSBibG9vbSBmaWx0ZXJzLCBidWlsdCBpbiBhZGRp dGlvbiB0byB0aGUgY29tYmluZWQKKwkgKiBibG9vbV9maWx0ZXIgYWJvdmUgd2hlbiBhIHJl Y2lwaWVudCBvcHRlZCBpbiAoSGFzaEpvaW4uYmxvb21fcGVya2V5KS4KKwkgKiBwZXJrZXlf ZmlsdGVycyBoYXMgcGVya2V5X25maWx0ZXJzIGVudHJpZXMsIG9uZSBwZXIgam9pbiBrZXks IGluIGhhc2hrZXkKKwkgKiBvcmRlcjsgYSByZWNpcGllbnQgY29ycmVsYXRlcyB0aGVtIHdp dGggQmxvb21GaWx0ZXIuZmlsdGVyX2V4cHJzIGJ5CisJICogcG9zaXRpb24uICBwZXJrZXlf aGFzaCBob2xkcyB0aGUgbWF0Y2hpbmcgcGVyLWtleSAoc2luZ2xlLWtleSkgaGFzaAorCSAq IEV4cHJTdGF0ZXMgdXNlZCB0byBwb3B1bGF0ZSB0aGVtIGR1cmluZyB0aGUgYnVpbGQuICBB bGwgbGl2ZSBpbiBoYXNoQ3h0CisJICogYW5kIGZvbGxvdyB0aGUgc2FtZSBsaWZlY3ljbGUg YXMgYmxvb21fZmlsdGVyLgorCSAqLworCWJvb2wJCXdhbnRfcGVya2V5X2Jsb29tOworCWlu dAkJCXBlcmtleV9uZmlsdGVyczsKKwlzdHJ1Y3QgYmxvb21fZmlsdGVyICoqcGVya2V5X2Zp bHRlcnM7CisJRXhwclN0YXRlICoqcGVya2V5X2hhc2g7CisKIAkvKgogCSAqIENvdW50ZXJz IHdpdGggdG90YWwgcGVyLWZpbHRlciBpbnN0cnVtZW50YXRpb24uIFNlcGFyYXRlIGZyb20g dGhlCiAJICogcGVyLXJlY2lwaWVudCBjb3VudGVycyBpbiBCbG9vbUZpbHRlclN0YXRlLiBS ZWR1bmRhbnQsIGJ1dCB3aWxsIGJlCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9ub2Rlcy9w bGFubm9kZXMuaCBiL3NyYy9pbmNsdWRlL25vZGVzL3BsYW5ub2Rlcy5oCmluZGV4IDRlMzVk NzdjYzQ5Li4yMWVjN2ZmYWUxYSAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvbm9kZXMvcGxh bm5vZGVzLmgKKysrIGIvc3JjL2luY2x1ZGUvbm9kZXMvcGxhbm5vZGVzLmgKQEAgLTExMjQs NiArMTEyNCwxNyBAQCB0eXBlZGVmIHN0cnVjdCBIYXNoSm9pbgogCSAqIFplcm8gd2hlbiB0 aGlzIEhhc2hKb2luIGhhcyBubyBjb25zdW1lcnMuCiAJICovCiAJaW50CQkJYmxvb21fZmls dGVyX2lkOworCisJLyoKKwkgKiBXaGV0aGVyIHRvIGFsc28gYnVpbGQgb25lIGJsb29tIGZp bHRlciBwZXIgam9pbiBrZXkgKGluIGFkZGl0aW9uIHRvIHRoZQorCSAqIGNvbWJpbmVkLWhh c2ggZmlsdGVyKSwgc28gdGhhdCBhIHJlY2lwaWVudCBjYW4gdGVzdCBhbiBpbmRpdmlkdWFs IGtleQorCSAqIGNvbHVtbiBvbiBpdHMgb3duIC0tIGUuZy4gYSBjb2x1bW4gc3RvcmUgcHJv YmluZyBhIHBlci1jb2x1bW4gZGljdGlvbmFyeQorCSAqIG9yIHpvbmUgbWFwLiAgU2V0IGF0 IHBsYW4gdGltZSBvbmx5IHdoZW4gdGhlIHJlY2lwaWVudCBpcyBhIEN1c3RvbVNjYW4KKwkg KiB0aGF0IGFkdmVydGlzZWQgQ1VTVE9NUEFUSF9TVVBQT1JUX0JMT09NX0ZJTFRFUlMuICBU aGUgY29tYmluZWQgZmlsdGVyIGlzCisJICogYWx3YXlzIGJ1aWx0IGFuZCByZW1haW5zIHRo ZSBtb3JlIHNlbGVjdGl2ZSBvbmU7IHBlci1rZXkgZmlsdGVycyBhcmUgYW4KKwkgKiBvcHQt aW4gZXh0cmEgdGhhdCBub2JvZHkgZWxzZSBwYXlzIGZvci4KKwkgKi8KKwlib29sCQlibG9v bV9wZXJrZXk7CiB9IEhhc2hKb2luOwogCiAvKiAtLS0tLS0tLS0tLS0tLS0tCi0tIAoyLjQz LjAKCg== --------------W5bFIh3ctAXAmJgggZldxehu Content-Type: text/plain; charset=UTF-8; name="0003-Build-the-hashjoin-bloom-filter-eagerly-for-a-Custom.patc.text" Content-Disposition: attachment; filename*0="0003-Build-the-hashjoin-bloom-filter-eagerly-for-a-Custom.pa"; filename*1="tc.text" Content-Transfer-Encoding: base64 RnJvbSAzYTRiZTczZWJkZWQyYzdjYjY4M2YyZjA4MDNkY2YzYmFkZjA2ODZhIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbmRyZXcgRHVuc3RhbiA8YW5kcmV3QGR1bnNsYW5l Lm5ldD4KRGF0ZTogU3VuLCAzMSBNYXkgMjAyNiAwNzo0ODoyMyAtMDQwMApTdWJqZWN0OiBb UEFUQ0ggYWRkb24gMy8zXSBCdWlsZCB0aGUgaGFzaGpvaW4gYmxvb20gZmlsdGVyIGVhZ2Vy bHkgZm9yIGEKIEN1c3RvbVNjYW4gcmVjaXBpZW50CgpXaGVuIHRoZSBvdXRlciByZWxhdGlv bidzIHN0YXJ0dXAgY29zdCBpcyBiZWxvdyB0aGUgaGFzaC10YWJsZSBidWlsZApjb3N0LCBF eGVjSGFzaEpvaW5JbXBsIGZldGNoZXMgdGhlIGZpcnN0IG91dGVyIHR1cGxlIGJlZm9yZSBi dWlsZGluZyB0aGUKaGFzaCB0YWJsZSwgdG8gdGFrZSB0aGUgZW1wdHktb3V0ZXIgc2hvcnRj dXQuICBGb3IgYSBDdXN0b21TY2FuIHRoYXQKY29uc3VtZXMgYSBwdXNoZWQtZG93biBibG9v bSBmaWx0ZXIgaW4gaXRzIG93biBzY2FuIGxvb3AgdGhhdCBpcyB0b28KbGF0ZTogaXRzIGZp cnN0IHR1cGxlIHJlcXVlc3QgLS0gd2hpY2ggZm9yIGEgY29sdW1uIHN0b3JlIG1heSBkZWNv bXByZXNzCmEgd2hvbGUgcm93IGdyb3VwIC0tIGhhcHBlbnMgYmVmb3JlIHRoZSBmaWx0ZXIg ZXhpc3RzLCBzbyB0aGUgZmlyc3QKYmF0Y2ggaXMgc2Nhbm5lZCB1bmZpbHRlcmVkLgoKQWRk IGEgSGFzaEpvaW4uYmxvb21fZWFnZXIgZmxhZywgc2V0IGF0IHBsYW4gdGltZSB3aGVuIHRo ZSBmaWx0ZXIgaXMKcHVzaGVkIHRvIGEgQ3VzdG9tU2NhbiByZWNpcGllbnQgKHdoaWNoIGFk dmVydGlzZWQKQ1VTVE9NUEFUSF9TVVBQT1JUX0JMT09NX0ZJTFRFUlMpLCB0ZWxsaW5nIHRo ZSBleGVjdXRvciB0byBza2lwIHRoZQplbXB0eS1vdXRlciBwcmVmZXRjaCBhbmQgYnVpbGQg dGhlIGhhc2ggdGFibGUgLS0gYW5kIHRoZSBmaWx0ZXIgLS0KYmVmb3JlIHRoZSBvdXRlciBz Y2FuIHN0YXJ0cy4gIFRoaXMgaXMgZHJpdmVuIGJ5IHRoZSBzYW1lIG9wdC1pbiBwYXRoIGFz CnRoZSByZWNpcGllbnQgaXRzZWxmIHJhdGhlciB0aGFuIGEgR1VDLCBhbmQgb25seSBzdWNo IGEgcmVjaXBpZW50IHBheXMKdGhlIGNvc3QgKGEgcG9zc2libHktbmVlZGxlc3MgaGFzaCBi dWlsZCB3aGVuIHRoZSBvdXRlciB0dXJucyBvdXQgZW1wdHkpOwpzdG9jay1zY2FuIHJlY2lw aWVudHMsIHdoaWNoIHByb2JlIHBlci1yb3cgYWZ0ZXIgcHJvZHVjaW5nIGEgdHVwbGUKYW55 d2F5LCBhcmUgdW5hZmZlY3RlZC4KLS0tCiBzcmMvYmFja2VuZC9leGVjdXRvci9ub2RlSGFz aGpvaW4uYyAgICAgfCAxMSArKysrKysrKysKIHNyYy9iYWNrZW5kL29wdGltaXplci9wbGFu L2NyZWF0ZXBsYW4uYyB8IDMwICsrKysrKysrKysrKysrKysrKy0tLS0tLS0KIHNyYy9pbmNs dWRlL25vZGVzL3BsYW5ub2Rlcy5oICAgICAgICAgICB8IDEwICsrKysrKysrKwogMyBmaWxl cyBjaGFuZ2VkLCA0MyBpbnNlcnRpb25zKCspLCA4IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdp dCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVIYXNoam9pbi5jIGIvc3JjL2JhY2tlbmQv ZXhlY3V0b3Ivbm9kZUhhc2hqb2luLmMKaW5kZXggMWVhZjgxMjg1ZjguLjkxNTQzMTBjMDlh IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlSGFzaGpvaW4uYworKysg Yi9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlSGFzaGpvaW4uYwpAQCAtMzE3LDYgKzMxNywx NyBAQCBFeGVjSGFzaEpvaW5JbXBsKFBsYW5TdGF0ZSAqcHN0YXRlLCBib29sIHBhcmFsbGVs KQogCQkJCQkgKi8KIAkJCQkJbm9kZS0+aGpfRmlyc3RPdXRlclR1cGxlU2xvdCA9IE5VTEw7 CiAJCQkJfQorCQkJCWVsc2UgaWYgKCgoSGFzaEpvaW4gKikgbm9kZS0+anMucHMucGxhbikt PmJsb29tX2VhZ2VyKQorCQkJCXsKKwkJCQkJLyoKKwkJCQkJICogV2UgcHVzaGVkIGEgYmxv b20gZmlsdGVyIHRvIGEgQ3VzdG9tU2NhbiBvbiB0aGUgb3V0ZXIKKwkJCQkJICogc2lkZSB0 aGF0IHdhbnRzIGl0IGF0IHNjYW4gc3RhcnQgKGUuZy4gdG8gc2tpcCByb3cgZ3JvdXBzCisJ CQkJCSAqIGJlZm9yZSBkZWNvbXByZXNzaW9uKS4gIFNraXAgdGhlIGVtcHR5LW91dGVyIHBy ZWZldGNoIGFuZAorCQkJCQkgKiBidWlsZCB0aGUgaGFzaCB0YWJsZSAtLSBhbmQgdGhlIGZp bHRlciAtLSBmaXJzdCwgc28gaXQgaXMKKwkJCQkJICogcmVhZHkgYmVmb3JlIHRoZSBvdXRl ciBzY2FuIHByb2R1Y2VzIGl0cyBmaXJzdCB0dXBsZS4KKwkJCQkJICovCisJCQkJCW5vZGUt PmhqX0ZpcnN0T3V0ZXJUdXBsZVNsb3QgPSBOVUxMOworCQkJCX0KIAkJCQllbHNlIGlmIChI Sl9GSUxMX09VVEVSKG5vZGUpIHx8CiAJCQkJCQkgKG91dGVyTm9kZS0+cGxhbi0+c3RhcnR1 cF9jb3N0IDwgaGFzaE5vZGUtPnBzLnBsYW4tPnRvdGFsX2Nvc3QgJiYKIAkJCQkJCSAgIW5v ZGUtPmhqX091dGVyTm90RW1wdHkpKQpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvb3B0aW1p emVyL3BsYW4vY3JlYXRlcGxhbi5jIGIvc3JjL2JhY2tlbmQvb3B0aW1pemVyL3BsYW4vY3Jl YXRlcGxhbi5jCmluZGV4IDViMDFiM2U0NWNjLi5hNzBmMTEwNDgwMCAxMDA2NDQKLS0tIGEv c3JjL2JhY2tlbmQvb3B0aW1pemVyL3BsYW4vY3JlYXRlcGxhbi5jCisrKyBiL3NyYy9iYWNr ZW5kL29wdGltaXplci9wbGFuL2NyZWF0ZXBsYW4uYwpAQCAtNDk5MywxNiArNDk5MywzMCBA QCB0cnlfcHVzaF9ibG9vbV9maWx0ZXIoUGxhbm5lckluZm8gKnJvb3QsIEhhc2hKb2luICpo aiwgUGxhbiAqb3V0ZXJfcGxhbikKIAlyZWNpcGllbnQtPmJsb29tX2ZpbHRlcnMgPSBsYXBw ZW5kKHJlY2lwaWVudC0+Ymxvb21fZmlsdGVycywgYmYpOwogCiAJLyoKLQkgKiBJZiB0aGUg cmVjaXBpZW50IGlzIGEgQ3VzdG9tU2NhbiB0aGF0IG9wdGVkIGluLCBhbHNvIGJ1aWxkIGEg c2VwYXJhdGUKLQkgKiBmaWx0ZXIgcGVyIGpvaW4ga2V5LiAgT25seSBzdWNoIGEgcmVjaXBp ZW50IGNhbiBtYWtlIHVzZSBvZiB0aGVtICh0bwotCSAqIHRlc3QgYSBzaW5nbGUgY29sdW1u IGFnYWluc3QgYSBkaWN0aW9uYXJ5IG9yIHpvbmUgbWFwKTsgdGhlIGNvbWJpbmVkCi0JICog ZmlsdGVyIGlzIGFsd2F5cyBidWlsdCBhbmQgaXMgdGhlIG1vcmUgc2VsZWN0aXZlIG9uZSBm b3IgdGhlIHBlci1yb3cKLQkgKiBwcm9iZS4gIFRoZXJlIGlzIG5vdGhpbmcgdG8gZ2FpbiBm b3IgYSBzaW5nbGUta2V5IGpvaW4sIHdoZXJlIHRoZSB0d28KLQkgKiBjb2luY2lkZS4KKwkg KiBBIEN1c3RvbVNjYW4gcmVjaXBpZW50IHRoYXQgb3B0ZWQgaW4gY29uc3VtZXMgdGhlIGZp bHRlciBpbiBpdHMgb3duCisJICogc2NhbiBsb29wLCBwb3NzaWJseSBhdCB0aGUgc3RvcmFn ZSBsZXZlbCwgc28gaXQgd2FudHMgdHdvIHRoaW5ncyBhCisJICogc3RvY2sgc2NhbiBkb2Vz IG5vdC4KIAkgKi8KLQlpZiAobGlzdF9sZW5ndGgoaGFzaGtleXMpID4gMSAmJiBJc0EocmVj aXBpZW50LCBDdXN0b21TY2FuKSAmJgorCWlmIChJc0EocmVjaXBpZW50LCBDdXN0b21TY2Fu KSAmJgogCQkoKChDdXN0b21TY2FuICopIHJlY2lwaWVudCktPmZsYWdzICYgQ1VTVE9NUEFU SF9TVVBQT1JUX0JMT09NX0ZJTFRFUlMpKQotCQloai0+Ymxvb21fcGVya2V5ID0gdHJ1ZTsK Kwl7CisJCS8qCisJCSAqIEJ1aWxkIHRoZSBoYXNoIHRhYmxlIChhbmQgZmlsdGVyKSBiZWZv cmUgdGhlIG91dGVyIHNjYW4gc3RhcnRzLCBzbworCQkgKiB0aGUgZmlsdGVyIGlzIGF2YWls YWJsZSBvbiB0aGUgZmlyc3QgdHVwbGUgcmVxdWVzdCByYXRoZXIgdGhhbiBhZnRlcgorCQkg KiBhIGJhdGNoIGhhcyBhbHJlYWR5IGJlZW4gc2Nhbm5lZCB1bmZpbHRlcmVkLgorCQkgKi8K KwkJaGotPmJsb29tX2VhZ2VyID0gdHJ1ZTsKKworCQkvKgorCQkgKiBBbHNvIGJ1aWxkIGEg c2VwYXJhdGUgZmlsdGVyIHBlciBqb2luIGtleSwgc28gdGhlIHJlY2lwaWVudCBjYW4gdGVz dAorCQkgKiBhIHNpbmdsZSBjb2x1bW4gb24gaXRzIG93biAoZS5nLiBhZ2FpbnN0IGEgcGVy LWNvbHVtbiBkaWN0aW9uYXJ5IG9yCisJCSAqIHpvbmUgbWFwKS4gIFRoZSBjb21iaW5lZCBm aWx0ZXIgaXMgYWx3YXlzIGJ1aWx0IGFuZCBpcyB0aGUgbW9yZQorCQkgKiBzZWxlY3RpdmUg b25lIGZvciBhIHBlci1yb3cgcHJvYmU7IHRoZXJlIGlzIG5vdGhpbmcgdG8gZ2FpbiBmb3Ig YQorCQkgKiBzaW5nbGUta2V5IGpvaW4sIHdoZXJlIHRoZSB0d28gY29pbmNpZGUuCisJCSAq LworCQlpZiAobGlzdF9sZW5ndGgoaGFzaGtleXMpID4gMSkKKwkJCWhqLT5ibG9vbV9wZXJr ZXkgPSB0cnVlOworCX0KIAogCS8qCiAJICogWFhYIFdlJ3ZlIG1hbmdlZCB0byBwdXNoIHRo ZSBmaWx0ZXIgdG8gdGhlIHNjYW4gbm9kZSwgYnV0IG1heWJlCmRpZmYgLS1naXQgYS9zcmMv aW5jbHVkZS9ub2Rlcy9wbGFubm9kZXMuaCBiL3NyYy9pbmNsdWRlL25vZGVzL3BsYW5ub2Rl cy5oCmluZGV4IDIxZWM3ZmZhZTFhLi4wZTAxMWYzZDRlMiAxMDA2NDQKLS0tIGEvc3JjL2lu Y2x1ZGUvbm9kZXMvcGxhbm5vZGVzLmgKKysrIGIvc3JjL2luY2x1ZGUvbm9kZXMvcGxhbm5v ZGVzLmgKQEAgLTExMzUsNiArMTEzNSwxNiBAQCB0eXBlZGVmIHN0cnVjdCBIYXNoSm9pbgog CSAqIG9wdC1pbiBleHRyYSB0aGF0IG5vYm9keSBlbHNlIHBheXMgZm9yLgogCSAqLwogCWJv b2wJCWJsb29tX3BlcmtleTsKKworCS8qCisJICogV2hldGhlciB0byBidWlsZCB0aGUgaGFz aCB0YWJsZSAoYW5kIGJsb29tIGZpbHRlcikgYmVmb3JlIGZldGNoaW5nIHRoZQorCSAqIGZp cnN0IG91dGVyIHR1cGxlLCBza2lwcGluZyB0aGUgZW1wdHktb3V0ZXIgcHJlZmV0Y2ggb3B0 aW1pemF0aW9uLiAgU2V0CisJICogYXQgcGxhbiB0aW1lIHdoZW4gdGhlIGZpbHRlciBpcyBw dXNoZWQgdG8gYSBDdXN0b21TY2FuIHJlY2lwaWVudCwgd2hpY2gKKwkgKiBtYXkgd2FudCB0 byBhcHBseSB0aGUgZmlsdGVyIHRoZSBtb21lbnQgaXRzIHNjYW4gc3RhcnRzIChlLmcuIGEg Y29sdW1uCisJICogc3RvcmUgc2tpcHBpbmcgcm93IGdyb3VwcyBiZWZvcmUgZGVjb21wcmVz c2lvbikgcmF0aGVyIHRoYW4gYWZ0ZXIgaGF2aW5nCisJICogYWxyZWFkeSBwcm9kdWNlZCBh IGJhdGNoIHVuZmlsdGVyZWQuICBTZWUgRXhlY0hhc2hKb2luSW1wbC4KKwkgKi8KKwlib29s CQlibG9vbV9lYWdlcjsKIH0gSGFzaEpvaW47CiAKIC8qIC0tLS0tLS0tLS0tLS0tLS0KLS0g CjIuNDMuMAoK --------------W5bFIh3ctAXAmJgggZldxehu--