Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1pRcCp-0001VM-2R for pgsql-hackers@arkaria.postgresql.org; Mon, 13 Feb 2023 17:01:31 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.92) (envelope-from ) id 1pRcCn-0003tK-TX for pgsql-hackers@arkaria.postgresql.org; Mon, 13 Feb 2023 17:01:29 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1pRcCn-0003t2-3g for pgsql-hackers@lists.postgresql.org; Mon, 13 Feb 2023 17:01:29 +0000 Received: from mail-wm1-x329.google.com ([2a00:1450:4864:20::329]) by makus.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.92) (envelope-from ) id 1pRcCh-0003xA-Sy for pgsql-hackers@lists.postgresql.org; Mon, 13 Feb 2023 17:01:27 +0000 Received: by mail-wm1-x329.google.com with SMTP id c4-20020a1c3504000000b003d9e2f72093so11773956wma.1 for ; Mon, 13 Feb 2023 09:01:23 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=enterprisedb.com; s=google; h=subject:from:to:content-language:user-agent:mime-version:date :message-id:from:to:cc:subject:date:message-id:reply-to; bh=nswV4Isei97it1/S3tqeTIg5bWO5Dxkyi1qVJ7lym44=; b=kjfcHMZZfBpf8KQKlUanybF/GJQFY2ik9UsKPNBO/6b5kc0rFZJlGsw3iwkvbu99fo Fzq3jGrr0IZMb230hNbbAjgTchjYperucnX9V9YkkVjINtPD9T6Z2NeMSiCGQLcFvxwz 13E3d+3oQlcW2pOU+BoZBZt5npBGloLxs0YqdqxgDIFWMVHW+5eeeZJDkIhcFqA0BoTC qPgpWBR/gMECnzSiZw/BPlNyRO4tAXdMABxlWtjZavJR6YiTRrlPy4lza//5pCHfTRpm pI2jlVTOZ9EKpfMA0EAXhzpMUhBM+3NlhxRelQJypAk+mNoMQd20I9d5R0eWWHQF2tUn SNOA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=subject:from:to:content-language:user-agent:mime-version:date :message-id:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=nswV4Isei97it1/S3tqeTIg5bWO5Dxkyi1qVJ7lym44=; b=CnfjMR2htWL1u+qZmtqoGv7yyE47L1WuCbSbFjxFG4EmFf9iXj3/z3sRMhAZ0vPXa9 7Rdsw4V8QTCVIWwhV2PGvPrt2CaFHJ4+7ntFS2RstyAD/oEdnjcZJhEbsY9w1pH8kmRZ RaUDssaPhvHsxpma7+LUvcYLtQRHL4+/uQtUT/ryM8trgvUvWdEzGGVtivFSlNf8Af26 FTpEg5WwLeGNgh3BtJ2eyDPm3dDomKCvghlLJ+gqIqxFtAjEfh/5Sn2RRim5Ya1TPGT5 9kTgOye3OUIsst6JttoGnt4vEgG1R5in9AT8w849Z2sLTqi7ZnISmHPpLxVX9xjFEDvS MlEA== X-Gm-Message-State: AO0yUKUA9j4aTjj1ElpGuCLKNgsO0/vbc9cx4iyQfm5c2MKZfjGKiOB0 GS1IyXnMAkWrlFffvL+DthdlQqF65A9x4pwUacZgVnsyBakArPlkqc0AAm3nTaHy7qbREUNAl1i Syg4yAD5ttQGjlp4578S/IzxLzwhXU1g+TB7GfSOycFln0maD04Cn9FOKQJjK5HSi6pR9+L04Mw gLeIxT+0s3hKcK6CVOMgovlwXLoHjJfIIlgKWXyQTC/cLGTuEoUH4kVeRgidbT8q+094loqrx5S XbivBinTESupXpfHludsfiNuc2XwGlDn085KSLq3MF2iOpZ3Pa+GBaMamqsO73lgWMqh7nTLUNj wiHfZccsxh23Jin5OOBhb9GIFY0GkHFLUDVJtY3JgBUFh3xkOISsINrzt7cx X-Google-Smtp-Source: AK7set9XB9f9v0XDjCdiy1fLbxJ6gtACylOxKAsWUsjDx4Cv9CNijEdL4RRKG/m1UoGwv4PcsOK82A== X-Received: by 2002:a05:600c:4da2:b0:3df:e1d1:e14c with SMTP id v34-20020a05600c4da200b003dfe1d1e14cmr24092456wmp.20.1676307681722; Mon, 13 Feb 2023 09:01:21 -0800 (PST) Received: from [10.137.0.17] (ip-86-49-228-162.bb.vodafone.cz. [86.49.228.162]) by smtp.gmail.com with ESMTPSA id d5-20020a1c7305000000b003dc4baaedd3sm16999852wmb.37.2023.02.13.09.01.21 for (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 13 Feb 2023 09:01:21 -0800 (PST) Content-Type: multipart/mixed; boundary="------------vUwxfMJd601J0Yjedx8IQ3Mp" Message-ID: Date: Mon, 13 Feb 2023 18:01:20 +0100 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Thunderbird/102.6.0 Content-Language: en-US To: PostgreSQL Hackers From: Tomas Vondra Subject: BRIN indexes vs. SK_SEARCHARRAY (and preprocessing scan keys) X-CLOUD-SEC-AV-Info: enterprisedb,google_mail,monitor X-CLOUD-SEC-AV-Sent: true X-Gm-Spam: 0 X-Gm-Phishy: 0 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. --------------vUwxfMJd601J0Yjedx8IQ3Mp Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit Hi, while experimenting with BRIN indexes after a couple FOSDEM discussions, I ran into the existing limitation that BRIN indexes don't handle array scan keys. So BRIN indexes can be used for conditions like WHERE a IN (1,2,3,4,5) but we essentially treat the values as individual scan keys, and for each one we scan the BRIN index and build/update the bitmap. Which for large indexes may be fairly expensive - the cost is proportional to the number of values, so if building the bitmap for 1 value takes 10ms, for 100 values it'll take ~1000ms. It's not hard to construct cases like this (e.g. when using indexes with small pages_per_range values) etc. Of course, if the query does a lot of other expensive stuff, this cost may be insignificant. I'm not sure how often people do queries with such conditions. But I've been experimenting with features that'd build such paths, so I took a stab at a PoC, which can significantly reduce the time needed to build the bitmaps. And there's a couple more interesting opportunities. 0001 - Support SK_SEARCHARRAY in BRIN minmax -------------------------------------------- The 0001 part does a "naive" SK_SEARCHARRAY implementation for minmax. It simply sets amsearcharray=true and then tweaks the consistent function to handle both the scalar and array scan keys. This is obviously rather inefficient, because the array is searched linearly. So yes, we don't walk the index repeatedly, but we have to compare each range to (almost-)all values. 0002 - Sort the array in brinrescan() and do binsearch ------------------------------------------------------ There's a simple way to optimize the naive approach by sorting the array and then searching in this array. If the array is sorted, we can search for the first value >= minvalue, and see if that is consistent (i.e. if it's <= maxval). In my experiments this cuts the time needed to build the bitmap for array to pretty much the same as for a single value. I think this is similar to the preprocessing of scan keys in b-tree, so brinrescan() is a natural way to do the sort. The problem however is where to store the result. Ideally, we'd store it in BrinOpaque (just like BTScanOpaque in btree), but the problem is we don't pass that to the consistent functions. Those only get the ScanKeys and stuff extracted from BrinOpaque. We might add a parameter to the "consistent" function, but that conflicts with not wanting to break existing extensions implementing their own BRIN indexes. We allow the opclasses to define "consistent" with either 4 or 5 arguments. Adding an argument would mean 5 or 6 arguments, but because of the backwards compatibility we'd need to support existing opclasses, and 5 is ambiguous :-/ In hindsight, I would probably not chose supporting both 4 and 5 arguments again. It makes it harder for us to maintain the code to make life easier for extensions, but I'm not aware of any out-of-core BRIN opclasses anyway. So I'd probably just change the API, it's pretty easy to update existing extensions. This patch however does a much simpler thing - it just replaces the array in the SK_SEARCHARRAY scan key with a sorted one. That works for for minmax, but not for bloom/inclusion, because those are not based on sorting. And the ArrayType is not great for minmax either, because it means we need to deconstruct it again and again, for each range. It'd be much better to deconstruct the array once. I'll get back to this ... 0003 - Support SK_SEARCHARRAY in BRIN inclusion ----------------------------------------------- Trivial modification to support array scan keys, can't benefit from sorting the array. 0004 - Support SK_SEARCHARRAY in BRIN bloom ------------------------------------------- Trivial modification to support array scan keys, can't benefit from sorted array either. But we might "preprocess" the keys in a different way - bloom needs to calculate two hashes per key, and at the moment it happens again and again for each range. So if you have 1M ranges, and SK_SEARCHARRAY query with 100 values, we'll do 100M calls to PROCNUM_HASH and 200M calls to hash_uint32_extended(). And our hash functions are pretty expensive, certainly compared to the fast functions often used for bloom filters. So the preprocessing might actually calculate the hash functions once, and then only reuse those in the "consistent" function. 0005 is a dirty PoC illustrating the benefit of caching the hashes. Unfortunately, this complicates things, because it means: * The scan key preprocessing is not universal for all BRIN opclasses, because some opclasses, i.e. each BRIN opclass might have optional BRIN_PROCNUM_PREPROCESS which would preprocess the keys the way the opclass would like. * We can simply replace the array in the scan key the way minmax does that with the sorted array, because the data type is not the same (hashes are uint64). When I started to write this e-mail I thought there's pretty much just one way to move this forward: 1) Add a BRIN_PROCNUM_PREPROCESS to BRIN, doing the preprocessing (if not defined, the key is not preprocessed. 2) Store the preprocessed keys in BrinOpaque. 3) Modify the BRIN API to allow passing the preprocessed keys. As mentioned earlier, I'm not sure how difficult would it be to maintain backwards compatibility, considering the number of arguments of the consistent function would be ambiguous. Maybe the existence of BRIN_PROCNUM_PREPROCESS would be enough to decide this - if it's decided, no keys are preprocessed (and the opclass would not support SK_SEARCHARRAY). But now I realize maybe we can do without adding parameters to the "consistent" function. We might stash "preprocessed" scankeys into BrinOpaque, and pass them to the consistent function instead of the "original" scan keys (at least when the BRIN_PROCNUM_PREPROCESS). In fact, I see ScanKey even allows AM-specific flags, maybe it'd be useful to to mark the preprocessed keys. regards -- Tomas Vondra EnterpriseDB: http://www.enterprisedb.com The Enterprise PostgreSQL Company --------------vUwxfMJd601J0Yjedx8IQ3Mp Content-Type: text/x-patch; charset=UTF-8; name="0001-Support-SK_SEARCHARRAY-in-BRIN-minmax-20230213.patch" Content-Disposition: attachment; filename*0="0001-Support-SK_SEARCHARRAY-in-BRIN-minmax-20230213.patch" Content-Transfer-Encoding: base64 RnJvbSAzZGUyZjBjYmUyMzhjM2ZiYmNlY2ExZTNhOWVkM2MyMDU4NzBhNmRkIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb21hcyBWb25kcmEgPHRvbWFzLnZvbmRyYUBwb3N0 Z3Jlc3FsLm9yZz4KRGF0ZTogRnJpLCAxMCBGZWIgMjAyMyAxNjowNzo1NyArMDEwMApTdWJq ZWN0OiBbUEFUQ0ggMS82XSBTdXBwb3J0IFNLX1NFQVJDSEFSUkFZIGluIEJSSU4gbWlubWF4 CgpTZXQgImFtc2VhcmNoYXJyYXk9dHJ1ZSIgZm9yIEJSSU4sIGFuZCBleHRlbmQgdGhlIG1p bm1heCBvcGNsYXNzIHRvCmhhbmRsZSBib3RoIHNjYWxhciB2YWx1ZXMgYW5kIGFycmF5cy4g VGhpcyBhbGxvd3MgaGFuZGxpbmcgY29uZGl0aW9ucwoKICAgIC4uLiBXSEVSRSBhIElOICgx LCAyLCA0MywgMjEzMiwgMTM0KQoKICAgIC4uLiBXSEVSRSBhID0gQU5ZKEFSUkFZWzM0LCA0 NSwgLTEsIDIzNF0pCgogICAgLi4uIFdIRVJFIGEgPD0gQU5ZKEFSUkFZWzQ5MzgsIDI4Miwg MjkzNF0pCgptb3JlIGVmZmljaWVudGx5IC0gdW50aWwgbm93IHdlIHNpbXBseSBidWlsdCB0 aGUgYml0bWFwIGZvciBlYWNoCnNjYWxhciB2YWx1ZSwgc28gd2Ugd2Fsa2VkIHRoZSBCUklO IGluZGV4IG1hbnkgdGltZXMuIFdoaWNoIG1heSBiZSBxdWl0ZQpleHBlbnNpdmUgZm9yIGlu ZGV4ZXMgd2l0aCBtYW55IHJhbmdlcyAobGFyZ2UgdGFibGVzIGFuZC9vciBsb3cKcGFnZXNf cGVyX3JhbmdlKS4KClRoZXJlJ3MgYSBjb3VwbGUgcHJvYmxlbXMgLyBvcGVuIHF1ZXN0aW9u cyAvIFRPRE8gaXRlbXM6CgotIFRoZSBvdGhlciBvcGNsYXNzZXMgZG9uJ3QgaGFuZGxlIFNL X1NFQVJDSEFSUkFZIHlldC4KCi0gVGhlIGFycmF5IGlzIGFsd2F5cyBzZWFyY2hlZCBsaW5l YXJseSwgc28gdGhpcyBtYXkgYmUgY29zdGx5IGZvciBsYXJnZQogIGFycmF5cyAod2l0aCBt YW55IGVsZW1lbnRzKS4KCi0gVGhlIGFycmF5IGlzIGRlY29uc3RydWN0ZWQgYWdhaW4gZm9y IGVhY2ggcmFuZ2UuIFdlIHNob3VsZCByZXVzZSB0aGlzLAogIHNvbWVob3cuCi0tLQogc3Jj L2JhY2tlbmQvYWNjZXNzL2JyaW4vYnJpbi5jICAgICAgICB8ICAgMiArLQogc3JjL2JhY2tl bmQvYWNjZXNzL2JyaW4vYnJpbl9taW5tYXguYyB8IDE3NyArKysrKysrKysrKysrKysrKysr Ky0tLS0tLQogMiBmaWxlcyBjaGFuZ2VkLCAxNDAgaW5zZXJ0aW9ucygrKSwgMzkgZGVsZXRp b25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2JyaW4vYnJpbi5jIGIv c3JjL2JhY2tlbmQvYWNjZXNzL2JyaW4vYnJpbi5jCmluZGV4IGRlMTQyN2ExZTAuLmE2MDBm MzdjMTUgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9icmluL2JyaW4uYworKysg Yi9zcmMvYmFja2VuZC9hY2Nlc3MvYnJpbi9icmluLmMKQEAgLTEwMSw3ICsxMDEsNyBAQCBi cmluaGFuZGxlcihQR19GVU5DVElPTl9BUkdTKQogCWFtcm91dGluZS0+YW1jYW51bmlxdWUg PSBmYWxzZTsKIAlhbXJvdXRpbmUtPmFtY2FubXVsdGljb2wgPSB0cnVlOwogCWFtcm91dGlu ZS0+YW1vcHRpb25hbGtleSA9IHRydWU7Ci0JYW1yb3V0aW5lLT5hbXNlYXJjaGFycmF5ID0g ZmFsc2U7CisJYW1yb3V0aW5lLT5hbXNlYXJjaGFycmF5ID0gdHJ1ZTsKIAlhbXJvdXRpbmUt PmFtc2VhcmNobnVsbHMgPSB0cnVlOwogCWFtcm91dGluZS0+YW1zdG9yYWdlID0gdHJ1ZTsK IAlhbXJvdXRpbmUtPmFtY2x1c3RlcmFibGUgPSBmYWxzZTsKZGlmZiAtLWdpdCBhL3NyYy9i YWNrZW5kL2FjY2Vzcy9icmluL2JyaW5fbWlubWF4LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3Mv YnJpbi9icmluX21pbm1heC5jCmluZGV4IDI0MzE1OTFiZTYuLmMwNTRkOGZmNDIgMTAwNjQ0 Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9icmluL2JyaW5fbWlubWF4LmMKKysrIGIvc3Jj L2JhY2tlbmQvYWNjZXNzL2JyaW4vYnJpbl9taW5tYXguYwpAQCAtMTYsNiArMTYsNyBAQAog I2luY2x1ZGUgImFjY2Vzcy9zdHJhdG51bS5oIgogI2luY2x1ZGUgImNhdGFsb2cvcGdfYW1v cC5oIgogI2luY2x1ZGUgImNhdGFsb2cvcGdfdHlwZS5oIgorI2luY2x1ZGUgInV0aWxzL2Fy cmF5LmgiCiAjaW5jbHVkZSAidXRpbHMvYnVpbHRpbnMuaCIKICNpbmNsdWRlICJ1dGlscy9k YXR1bS5oIgogI2luY2x1ZGUgInV0aWxzL2xzeXNjYWNoZS5oIgpAQCAtMTU3LDQ2ICsxNTgs MTQ2IEBAIGJyaW5fbWlubWF4X2NvbnNpc3RlbnQoUEdfRlVOQ1RJT05fQVJHUykKIAlhdHRu byA9IGtleS0+c2tfYXR0bm87CiAJc3VidHlwZSA9IGtleS0+c2tfc3VidHlwZTsKIAl2YWx1 ZSA9IGtleS0+c2tfYXJndW1lbnQ7Ci0Jc3dpdGNoIChrZXktPnNrX3N0cmF0ZWd5KQorCisJ LyoKKwkgKiBGb3IgcmVndWxhciAoc2NhbGFyKSBzY2FuIGtleXMsIHdlIHNpbXBseSBjb21w YXJlIHRoZSB2YWx1ZSB0byB0aGUKKwkgKiByYW5nZSBtaW4vbWF4IHZhbHVlcywgYW5kIHdl J3JlIGRvbmUuIEZvciBTS19TRUFSQ0hBUlJBWSBrZXlzIHdlCisJICogbmVlZCB0byBkZXBh cnNlIHRoZSBhcnJheSBhbmQgbG9vcCB0aHJvdWdoIHRoZSB2YWx1ZXMuCisJICovCisJaWYg KGxpa2VseSghKGtleS0+c2tfZmxhZ3MgJiBTS19TRUFSQ0hBUlJBWSkpKQogCXsKLQkJY2Fz ZSBCVExlc3NTdHJhdGVneU51bWJlcjoKLQkJY2FzZSBCVExlc3NFcXVhbFN0cmF0ZWd5TnVt YmVyOgotCQkJZmluZm8gPSBtaW5tYXhfZ2V0X3N0cmF0ZWd5X3Byb2NpbmZvKGJkZXNjLCBh dHRubywgc3VidHlwZSwKLQkJCQkJCQkJCQkJCSBrZXktPnNrX3N0cmF0ZWd5KTsKLQkJCW1h dGNoZXMgPSBGdW5jdGlvbkNhbGwyQ29sbChmaW5mbywgY29sbG9pZCwgY29sdW1uLT5idl92 YWx1ZXNbMF0sCi0JCQkJCQkJCQkJdmFsdWUpOwotCQkJYnJlYWs7Ci0JCWNhc2UgQlRFcXVh bFN0cmF0ZWd5TnVtYmVyOgotCi0JCQkvKgotCQkJICogSW4gdGhlIGVxdWFsaXR5IGNhc2Ug KFdIRVJFIGNvbCA9IHNvbWV2YWwpLCB3ZSB3YW50IHRvIHJldHVybgotCQkJICogdGhlIGN1 cnJlbnQgcGFnZSByYW5nZSBpZiB0aGUgbWluaW11bSB2YWx1ZSBpbiB0aGUgcmFuZ2UgPD0K LQkJCSAqIHNjYW4ga2V5LCBhbmQgdGhlIG1heGltdW0gdmFsdWUgPj0gc2NhbiBrZXkuCi0J CQkgKi8KLQkJCWZpbmZvID0gbWlubWF4X2dldF9zdHJhdGVneV9wcm9jaW5mbyhiZGVzYywg YXR0bm8sIHN1YnR5cGUsCi0JCQkJCQkJCQkJCQkgQlRMZXNzRXF1YWxTdHJhdGVneU51bWJl cik7Ci0JCQltYXRjaGVzID0gRnVuY3Rpb25DYWxsMkNvbGwoZmluZm8sIGNvbGxvaWQsIGNv bHVtbi0+YnZfdmFsdWVzWzBdLAotCQkJCQkJCQkJCXZhbHVlKTsKLQkJCWlmICghRGF0dW1H ZXRCb29sKG1hdGNoZXMpKQorCQlzd2l0Y2ggKGtleS0+c2tfc3RyYXRlZ3kpCisJCXsKKwkJ CWNhc2UgQlRMZXNzU3RyYXRlZ3lOdW1iZXI6CisJCQljYXNlIEJUTGVzc0VxdWFsU3RyYXRl Z3lOdW1iZXI6CisJCQkJZmluZm8gPSBtaW5tYXhfZ2V0X3N0cmF0ZWd5X3Byb2NpbmZvKGJk ZXNjLCBhdHRubywgc3VidHlwZSwKKwkJCQkJCQkJCQkJCQkga2V5LT5za19zdHJhdGVneSk7 CisJCQkJbWF0Y2hlcyA9IEZ1bmN0aW9uQ2FsbDJDb2xsKGZpbmZvLCBjb2xsb2lkLCBjb2x1 bW4tPmJ2X3ZhbHVlc1swXSwKKwkJCQkJCQkJCQkJdmFsdWUpOworCQkJCWJyZWFrOworCQkJ Y2FzZSBCVEVxdWFsU3RyYXRlZ3lOdW1iZXI6CisKKwkJCQkvKgorCQkJCSAqIEluIHRoZSBl cXVhbGl0eSBjYXNlIChXSEVSRSBjb2wgPSBzb21ldmFsKSwgd2Ugd2FudCB0byByZXR1cm4K KwkJCQkgKiB0aGUgY3VycmVudCBwYWdlIHJhbmdlIGlmIHRoZSBtaW5pbXVtIHZhbHVlIGlu IHRoZSByYW5nZSA8PQorCQkJCSAqIHNjYW4ga2V5LCBhbmQgdGhlIG1heGltdW0gdmFsdWUg Pj0gc2NhbiBrZXkuCisJCQkJICovCisJCQkJZmluZm8gPSBtaW5tYXhfZ2V0X3N0cmF0ZWd5 X3Byb2NpbmZvKGJkZXNjLCBhdHRubywgc3VidHlwZSwKKwkJCQkJCQkJCQkJCQkgQlRMZXNz RXF1YWxTdHJhdGVneU51bWJlcik7CisJCQkJbWF0Y2hlcyA9IEZ1bmN0aW9uQ2FsbDJDb2xs KGZpbmZvLCBjb2xsb2lkLCBjb2x1bW4tPmJ2X3ZhbHVlc1swXSwKKwkJCQkJCQkJCQkJdmFs dWUpOworCQkJCWlmICghRGF0dW1HZXRCb29sKG1hdGNoZXMpKQorCQkJCQlicmVhazsKKwkJ CQkvKiBtYXgoKSA+PSBzY2Fua2V5ICovCisJCQkJZmluZm8gPSBtaW5tYXhfZ2V0X3N0cmF0 ZWd5X3Byb2NpbmZvKGJkZXNjLCBhdHRubywgc3VidHlwZSwKKwkJCQkJCQkJCQkJCQkgQlRH cmVhdGVyRXF1YWxTdHJhdGVneU51bWJlcik7CisJCQkJbWF0Y2hlcyA9IEZ1bmN0aW9uQ2Fs bDJDb2xsKGZpbmZvLCBjb2xsb2lkLCBjb2x1bW4tPmJ2X3ZhbHVlc1sxXSwKKwkJCQkJCQkJ CQkJdmFsdWUpOworCQkJCWJyZWFrOworCQkJY2FzZSBCVEdyZWF0ZXJFcXVhbFN0cmF0ZWd5 TnVtYmVyOgorCQkJY2FzZSBCVEdyZWF0ZXJTdHJhdGVneU51bWJlcjoKKwkJCQlmaW5mbyA9 IG1pbm1heF9nZXRfc3RyYXRlZ3lfcHJvY2luZm8oYmRlc2MsIGF0dG5vLCBzdWJ0eXBlLAor CQkJCQkJCQkJCQkJCSBrZXktPnNrX3N0cmF0ZWd5KTsKKwkJCQltYXRjaGVzID0gRnVuY3Rp b25DYWxsMkNvbGwoZmluZm8sIGNvbGxvaWQsIGNvbHVtbi0+YnZfdmFsdWVzWzFdLAorCQkJ CQkJCQkJCQl2YWx1ZSk7CisJCQkJYnJlYWs7CisJCQlkZWZhdWx0OgorCQkJCS8qIHNob3Vs ZG4ndCBoYXBwZW4gKi8KKwkJCQllbG9nKEVSUk9SLCAiaW52YWxpZCBzdHJhdGVneSBudW1i ZXIgJWQiLCBrZXktPnNrX3N0cmF0ZWd5KTsKKwkJCQltYXRjaGVzID0gMDsKKwkJCQlicmVh azsKKwkJfQorCX0KKwllbHNlCisJeworCQlBcnJheVR5cGUgICphcnJheXZhbDsKKwkJaW50 MTYJCWVsbWxlbjsKKwkJYm9vbAkJZWxtYnl2YWw7CisJCWNoYXIJCWVsbWFsaWduOworCQlp bnQJCQludW1fZWxlbXM7CisJCURhdHVtCSAgICplbGVtX3ZhbHVlczsKKwkJYm9vbAkgICAq ZWxlbV9udWxsczsKKworCQlhcnJheXZhbCA9IERhdHVtR2V0QXJyYXlUeXBlUChrZXktPnNr X2FyZ3VtZW50KTsKKworCQlnZXRfdHlwbGVuYnl2YWxhbGlnbihBUlJfRUxFTVRZUEUoYXJy YXl2YWwpLAorCQkJCQkJCSAmZWxtbGVuLCAmZWxtYnl2YWwsICZlbG1hbGlnbik7CisKKwkJ ZGVjb25zdHJ1Y3RfYXJyYXkoYXJyYXl2YWwsCisJCQkJCQkgIEFSUl9FTEVNVFlQRShhcnJh eXZhbCksCisJCQkJCQkgIGVsbWxlbiwgZWxtYnl2YWwsIGVsbWFsaWduLAorCQkJCQkJICAm ZWxlbV92YWx1ZXMsICZlbGVtX251bGxzLCAmbnVtX2VsZW1zKTsKKworCQlzd2l0Y2ggKGtl eS0+c2tfc3RyYXRlZ3kpCisJCXsKKwkJCWNhc2UgQlRMZXNzU3RyYXRlZ3lOdW1iZXI6CisJ CQljYXNlIEJUTGVzc0VxdWFsU3RyYXRlZ3lOdW1iZXI6CisKKwkJCQlmb3IgKGludCBqID0g MDsgaiA8IG51bV9lbGVtczsgaisrKQorCQkJCXsKKwkJCQkJRGF0dW0gdmFsID0gZWxlbV92 YWx1ZXNbal07CisKKwkJCQkJZmluZm8gPSBtaW5tYXhfZ2V0X3N0cmF0ZWd5X3Byb2NpbmZv KGJkZXNjLCBhdHRubywgc3VidHlwZSwKKwkJCQkJCQkJCQkJCQkJIGtleS0+c2tfc3RyYXRl Z3kpOworCQkJCQltYXRjaGVzID0gRnVuY3Rpb25DYWxsMkNvbGwoZmluZm8sIGNvbGxvaWQs IGNvbHVtbi0+YnZfdmFsdWVzWzBdLAorCQkJCQkJCQkJCQkJdmFsKTsKKworCQkJCQlpZiAo RGF0dW1HZXRCb29sKG1hdGNoZXMpKQorCQkJCQkJYnJlYWs7CisJCQkJfQorCQkJCWJyZWFr OworCQkJY2FzZSBCVEVxdWFsU3RyYXRlZ3lOdW1iZXI6CisKKwkJCQkvKgorCQkJCSAqIElu IHRoZSBlcXVhbGl0eSBjYXNlIChXSEVSRSBjb2wgPSBzb21ldmFsKSwgd2Ugd2FudCB0byBy ZXR1cm4KKwkJCQkgKiB0aGUgY3VycmVudCBwYWdlIHJhbmdlIGlmIHRoZSBtaW5pbXVtIHZh bHVlIGluIHRoZSByYW5nZSA8PQorCQkJCSAqIHNjYW4ga2V5LCBhbmQgdGhlIG1heGltdW0g dmFsdWUgPj0gc2NhbiBrZXkuCisJCQkJICoKKwkJCQkgKiBYWFggRm9yIGFueSBvZiB0aGUg YXJyYXkgdmFsdWVzLgorCQkJCSAqLworCQkJCWZvciAoaW50IGogPSAwOyBqIDwgbnVtX2Vs ZW1zOyBqKyspCisJCQkJeworCQkJCQlEYXR1bSB2YWwgPSBlbGVtX3ZhbHVlc1tqXTsKKwor CQkJCQlmaW5mbyA9IG1pbm1heF9nZXRfc3RyYXRlZ3lfcHJvY2luZm8oYmRlc2MsIGF0dG5v LCBzdWJ0eXBlLAorCQkJCQkJCQkJCQkJCQkgQlRMZXNzRXF1YWxTdHJhdGVneU51bWJlcik7 CisJCQkJCW1hdGNoZXMgPSBGdW5jdGlvbkNhbGwyQ29sbChmaW5mbywgY29sbG9pZCwgY29s dW1uLT5idl92YWx1ZXNbMF0sCisJCQkJCQkJCQkJCQl2YWwpOworCQkJCQlpZiAoIURhdHVt R2V0Qm9vbChtYXRjaGVzKSkKKwkJCQkJCWNvbnRpbnVlOworCisJCQkJCS8qIG1heCgpID49 IHNjYW5rZXkgKi8KKwkJCQkJZmluZm8gPSBtaW5tYXhfZ2V0X3N0cmF0ZWd5X3Byb2NpbmZv KGJkZXNjLCBhdHRubywgc3VidHlwZSwKKwkJCQkJCQkJCQkJCQkJIEJUR3JlYXRlckVxdWFs U3RyYXRlZ3lOdW1iZXIpOworCQkJCQltYXRjaGVzID0gRnVuY3Rpb25DYWxsMkNvbGwoZmlu Zm8sIGNvbGxvaWQsIGNvbHVtbi0+YnZfdmFsdWVzWzFdLAorCQkJCQkJCQkJCQkJdmFsKTsK KworCQkJCQlpZiAoRGF0dW1HZXRCb29sKG1hdGNoZXMpKQorCQkJCQkJYnJlYWs7CisJCQkJ fQorCQkJCWJyZWFrOworCQkJY2FzZSBCVEdyZWF0ZXJFcXVhbFN0cmF0ZWd5TnVtYmVyOgor CQkJY2FzZSBCVEdyZWF0ZXJTdHJhdGVneU51bWJlcjoKKworCQkJCWZvciAoaW50IGogPSAw OyBqIDwgbnVtX2VsZW1zOyBqKyspCisJCQkJeworCQkJCQlEYXR1bSB2YWwgPSBlbGVtX3Zh bHVlc1tqXTsKKworCQkJCQlmaW5mbyA9IG1pbm1heF9nZXRfc3RyYXRlZ3lfcHJvY2luZm8o YmRlc2MsIGF0dG5vLCBzdWJ0eXBlLAorCQkJCQkJCQkJCQkJCQkga2V5LT5za19zdHJhdGVn eSk7CisJCQkJCW1hdGNoZXMgPSBGdW5jdGlvbkNhbGwyQ29sbChmaW5mbywgY29sbG9pZCwg Y29sdW1uLT5idl92YWx1ZXNbMV0sCisJCQkJCQkJCQkJCQl2YWwpOworCisJCQkJCWlmIChE YXR1bUdldEJvb2wobWF0Y2hlcykpCisJCQkJCQlicmVhazsKKwkJCQl9CisJCQkJYnJlYWs7 CisJCQlkZWZhdWx0OgorCQkJCS8qIHNob3VsZG4ndCBoYXBwZW4gKi8KKwkJCQllbG9nKEVS Uk9SLCAiaW52YWxpZCBzdHJhdGVneSBudW1iZXIgJWQiLCBrZXktPnNrX3N0cmF0ZWd5KTsK KwkJCQltYXRjaGVzID0gMDsKIAkJCQlicmVhazsKLQkJCS8qIG1heCgpID49IHNjYW5rZXkg Ki8KLQkJCWZpbmZvID0gbWlubWF4X2dldF9zdHJhdGVneV9wcm9jaW5mbyhiZGVzYywgYXR0 bm8sIHN1YnR5cGUsCi0JCQkJCQkJCQkJCQkgQlRHcmVhdGVyRXF1YWxTdHJhdGVneU51bWJl cik7Ci0JCQltYXRjaGVzID0gRnVuY3Rpb25DYWxsMkNvbGwoZmluZm8sIGNvbGxvaWQsIGNv bHVtbi0+YnZfdmFsdWVzWzFdLAotCQkJCQkJCQkJCXZhbHVlKTsKLQkJCWJyZWFrOwotCQlj YXNlIEJUR3JlYXRlckVxdWFsU3RyYXRlZ3lOdW1iZXI6Ci0JCWNhc2UgQlRHcmVhdGVyU3Ry YXRlZ3lOdW1iZXI6Ci0JCQlmaW5mbyA9IG1pbm1heF9nZXRfc3RyYXRlZ3lfcHJvY2luZm8o YmRlc2MsIGF0dG5vLCBzdWJ0eXBlLAotCQkJCQkJCQkJCQkJIGtleS0+c2tfc3RyYXRlZ3kp OwotCQkJbWF0Y2hlcyA9IEZ1bmN0aW9uQ2FsbDJDb2xsKGZpbmZvLCBjb2xsb2lkLCBjb2x1 bW4tPmJ2X3ZhbHVlc1sxXSwKLQkJCQkJCQkJCQl2YWx1ZSk7Ci0JCQlicmVhazsKLQkJZGVm YXVsdDoKLQkJCS8qIHNob3VsZG4ndCBoYXBwZW4gKi8KLQkJCWVsb2coRVJST1IsICJpbnZh bGlkIHN0cmF0ZWd5IG51bWJlciAlZCIsIGtleS0+c2tfc3RyYXRlZ3kpOwotCQkJbWF0Y2hl cyA9IDA7Ci0JCQlicmVhazsKKwkJfQogCX0KIAogCVBHX1JFVFVSTl9EQVRVTShtYXRjaGVz KTsKLS0gCjIuMzkuMQoK --------------vUwxfMJd601J0Yjedx8IQ3Mp Content-Type: text/x-patch; charset=UTF-8; name="0002-Sort-the-array-in-brinrescan-and-do-binsear-20230213.patch" Content-Disposition: attachment; filename*0="0002-Sort-the-array-in-brinrescan-and-do-binsear-20230213.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSBiNTY3YThhMzRlYTliMzg0Y2QyMTE1NzAwZGU1NmVhMjBiODA1MTBmIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb21hcyBWb25kcmEgPHRvbWFzLnZvbmRyYUBwb3N0 Z3Jlc3FsLm9yZz4KRGF0ZTogRnJpLCAxMCBGZWIgMjAyMyAyMjozNTo0MyArMDEwMApTdWJq ZWN0OiBbUEFUQ0ggMi82XSBTb3J0IHRoZSBhcnJheSBpbiBicmlucmVzY2FuKCkgYW5kIGRv IGJpbnNlYXJjaAoKVGhpcyBhbGxvd3Mgb3B0aW1pemluZyB0aGUgY2hlY2sgaW4gYnJpbl9t aW5tYXhfY29uc2lzdGVudC4KLS0tCiBzcmMvYmFja2VuZC9hY2Nlc3MvYnJpbi9icmluLmMg ICAgICAgIHwgIDY5ICsrKysrKysrKysKIHNyYy9iYWNrZW5kL2FjY2Vzcy9icmluL2JyaW5f bWlubWF4LmMgfCAxNzUgKysrKysrKysrKysrKysrKysrKysrLS0tLS0KIDIgZmlsZXMgY2hh bmdlZCwgMjEwIGluc2VydGlvbnMoKyksIDM0IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBh L3NyYy9iYWNrZW5kL2FjY2Vzcy9icmluL2JyaW4uYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9i cmluL2JyaW4uYwppbmRleCBhNjAwZjM3YzE1Li40MGE2MzFkMzc2IDEwMDY0NAotLS0gYS9z cmMvYmFja2VuZC9hY2Nlc3MvYnJpbi9icmluLmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNz L2JyaW4vYnJpbi5jCkBAIC0zOCw2ICszOCw3IEBACiAjaW5jbHVkZSAidXRpbHMvZGF0dW0u aCIKICNpbmNsdWRlICJ1dGlscy9ndWMuaCIKICNpbmNsdWRlICJ1dGlscy9pbmRleF9zZWxm dW5jcy5oIgorI2luY2x1ZGUgInV0aWxzL2xzeXNjYWNoZS5oIgogI2luY2x1ZGUgInV0aWxz L21lbXV0aWxzLmgiCiAjaW5jbHVkZSAidXRpbHMvcmVsLmgiCiAKQEAgLTcyMSw2ICs3MjIs MTYgQEAgYnJpbmdldGJpdG1hcChJbmRleFNjYW5EZXNjIHNjYW4sIFRJREJpdG1hcCAqdGJt KQogCXJldHVybiB0b3RhbHBhZ2VzICogMTA7CiB9CiAKK3N0YXRpYyBpbnQKK2NvbXBhcmVf YXJyYXlfdmFsdWVzKGNvbnN0IHZvaWQgKmEsIGNvbnN0IHZvaWQgKmIsIHZvaWQgKmFyZykK K3sKKwlEYXR1bQlkYSA9ICogKERhdHVtICopIGE7CisJRGF0dW0JZGIgPSAqIChEYXR1bSAq KSBiOworCVNvcnRTdXBwb3J0CXNzdXAgPSAoU29ydFN1cHBvcnQpIGFyZzsKKworCXJldHVy biBBcHBseVNvcnRDb21wYXJhdG9yKGRhLCBmYWxzZSwgZGIsIGZhbHNlLCBzc3VwKTsKK30K KwogLyoKICAqIFJlLWluaXRpYWxpemUgc3RhdGUgZm9yIGEgQlJJTiBpbmRleCBzY2FuCiAg Ki8KQEAgLTczNiw2ICs3NDcsNjQgQEAgYnJpbnJlc2NhbihJbmRleFNjYW5EZXNjIHNjYW4s IFNjYW5LZXkgc2NhbmtleSwgaW50IG5zY2Fua2V5cywKIAkgKiBoZXJlIHNvbWVkYXksIHRv by4KIAkgKi8KIAorCS8qCisJICogUHJlc29ydCB0aGUgYXJyYXkgZm9yIFNLX1NFQVJDSEFS UkFZIHNjYW4ga2V5cy4KKwkgKgorCSAqIFdlIHNpbXBseSBzdGFzaCB0aGUgdmFsdWUgYmFj ayBpbnRvIHRoZSBTY2FuS2V5LCBiZWNhdXNlIHRoYXQgd2F5IGl0J3MKKwkgKiB0cmFuc3Bh cmVudCBmb3IgdGhlIG9wY2xhc3MuIEJ1dCB0aGVyZSdzIGEgY291cGxlIGlzc3VlcyB3aXRo IHRoaXM6CisJICoKKwkgKiAxKSBPbiByZXNjYW5zLCB3ZSdsbCBwcmVwcm9jZXNzIHRoZSBh cnJheSBhZ2FpbiwgdW5uZWNlc3NhcmlseS4gQW5kIHRoZQorCSAqIG1lbW9yeSBpcyBsaWtl bHkgcmV0YWluZWQgdG9vLCBzbyB0aGlzIG1heSBiZSBhIG1lbW9yeSBsZWFrLgorCSAqCisJ ICogMikgSXQgYXNzdW1lcyB3ZSB3YW50IHRvIHByZXByb2Nlc3MgdGhlIGtleXMgaW50byB0 aGUgc2FtZSBkYXRhIHR5cGUuCisJICogVGhhdCB3b3JrcyBmb3IgbWlubWF4ICh3aGVyZSB3 ZSBqdXN0IHNvcnQgdGhlIGFycmF5KSwgYnV0IG1heSBub3Qgd29yaworCSAqIGZvciBvdGhl ciBvcGNsYXNzZXMgLSBlLmcuIGZvciAiYmxvb20iIHdlIG1pZ2h0IHdhbnQgcHJlLWNvbXB1 dGUgdGhlCisJICogaDEvaDIgaGFzaGVzICh0d28gdWludDY0IHZhbHVlcykgYW5kICJpbmNs dXNpb24iIG1pZ2h0IHRyeSBidWlsZGluZworCSAqIGEgdW5pb24gb2YgdGhlIHZhbHVlcywg b3Igc29tZXRoaW5nIGxpa2UgdGhhdC4gQW5kIG5vbmUgb2YgdGhpcyBmaXRzCisJICogaW50 byBhbiBhcnJheSBvZiB0aGUgc2FtZSBkYXRhIHR5cGUgKHdoaWNoIG1heSBiZSBzd2FwcGVk IGludG8gU2NhbktleSkuCisJICoKKwkgKiBGSVhNRSBOZWVkcyB0byBoYW5kbGUgTlVMTHMg Y29ycmVjdGx5LgorCSAqLworCWZvciAoaW50IGkgPSAwOyBpIDwgbnNjYW5rZXlzOyBpKysp CisJeworCQlTY2FuS2V5CQlrZXkgPSAmc2NhbmtleVtpXTsKKwkJQXJyYXlUeXBlICAqYXJy YXl2YWw7CisJCWludDE2CQllbG1sZW47CisJCWJvb2wJCWVsbWJ5dmFsOworCQljaGFyCQll bG1hbGlnbjsKKwkJaW50CQkJbnVtX2VsZW1zOworCQlEYXR1bQkgICAqZWxlbV92YWx1ZXM7 CisJCWJvb2wJICAgKmVsZW1fbnVsbHM7CisJCVR5cGVDYWNoZUVudHJ5ICp0eXBlOworCQlT b3J0U3VwcG9ydERhdGEgc3N1cDsKKworCQlpZiAoIShrZXktPnNrX2ZsYWdzICYgU0tfU0VB UkNITlVMTCkpCisJCQljb250aW51ZTsKKworCQlhcnJheXZhbCA9IERhdHVtR2V0QXJyYXlU eXBlUChrZXktPnNrX2FyZ3VtZW50KTsKKworCQlnZXRfdHlwbGVuYnl2YWxhbGlnbihBUlJf RUxFTVRZUEUoYXJyYXl2YWwpLAorCQkJCQkJCSAmZWxtbGVuLCAmZWxtYnl2YWwsICZlbG1h bGlnbik7CisKKwkJZGVjb25zdHJ1Y3RfYXJyYXkoYXJyYXl2YWwsCisJCQkJCQkgIEFSUl9F TEVNVFlQRShhcnJheXZhbCksCisJCQkJCQkgIGVsbWxlbiwgZWxtYnl2YWwsIGVsbWFsaWdu LAorCQkJCQkJICAmZWxlbV92YWx1ZXMsICZlbGVtX251bGxzLCAmbnVtX2VsZW1zKTsKKwor CQl0eXBlID0gbG9va3VwX3R5cGVfY2FjaGUoQVJSX0VMRU1UWVBFKGFycmF5dmFsKSwgVFlQ RUNBQ0hFX0xUX09QUik7CisKKwkJbWVtc2V0KCZzc3VwLCAwLCBzaXplb2YoU29ydFN1cHBv cnREYXRhKSk7CisJCVByZXBhcmVTb3J0U3VwcG9ydEZyb21PcmRlcmluZ09wKHR5cGUtPmx0 X29wciwgJnNzdXApOworCisJCXFzb3J0X2ludGVycnVwdGlibGUoZWxlbV92YWx1ZXMsIG51 bV9lbGVtcywgc2l6ZW9mKERhdHVtKSwKKwkJCQkJCQljb21wYXJlX2FycmF5X3ZhbHVlcywg JnNzdXApOworCisJCWFycmF5dmFsID0gY29uc3RydWN0X2FycmF5X2J1aWx0aW4oZWxlbV92 YWx1ZXMsIG51bV9lbGVtcywKKwkJCQkJCQkJCQkgICBBUlJfRUxFTVRZUEUoYXJyYXl2YWwp KTsKKworCQlrZXktPnNrX2FyZ3VtZW50ID0gUG9pbnRlckdldERhdHVtKGFycmF5dmFsKTsK Kwl9CisKIAlpZiAoc2NhbmtleSAmJiBzY2FuLT5udW1iZXJPZktleXMgPiAwKQogCQltZW1t b3ZlKHNjYW4tPmtleURhdGEsIHNjYW5rZXksCiAJCQkJc2Nhbi0+bnVtYmVyT2ZLZXlzICog c2l6ZW9mKFNjYW5LZXlEYXRhKSk7CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3Mv YnJpbi9icmluX21pbm1heC5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2JyaW4vYnJpbl9taW5t YXguYwppbmRleCBjMDU0ZDhmZjQyLi5mYWNjMDE5MDFhIDEwMDY0NAotLS0gYS9zcmMvYmFj a2VuZC9hY2Nlc3MvYnJpbi9icmluX21pbm1heC5jCisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vz cy9icmluL2JyaW5fbWlubWF4LmMKQEAgLTIyLDYgKzIyLDcgQEAKICNpbmNsdWRlICJ1dGls cy9sc3lzY2FjaGUuaCIKICNpbmNsdWRlICJ1dGlscy9yZWwuaCIKICNpbmNsdWRlICJ1dGls cy9zeXNjYWNoZS5oIgorI2luY2x1ZGUgInV0aWxzL3NvcnRzdXBwb3J0LmgiCiAKIHR5cGVk ZWYgc3RydWN0IE1pbm1heE9wYXF1ZQogewpAQCAtMTI3LDYgKzEyOCw2MyBAQCBicmluX21p bm1heF9hZGRfdmFsdWUoUEdfRlVOQ1RJT05fQVJHUykKIAlQR19SRVRVUk5fQk9PTCh1cGRh dGVkKTsKIH0KIAorCitzdGF0aWMgaW50Citjb21wYXJlX2FycmF5X3ZhbHVlcyhjb25zdCB2 b2lkICphLCBjb25zdCB2b2lkICpiLCB2b2lkICphcmcpCit7CisJRGF0dW0JZGEgPSAqIChE YXR1bSAqKSBhOworCURhdHVtCWRiID0gKiAoRGF0dW0gKikgYjsKKwlTb3J0U3VwcG9ydAlz c3VwID0gKFNvcnRTdXBwb3J0KSBhcmc7CisKKwlyZXR1cm4gQXBwbHlTb3J0Q29tcGFyYXRv cihkYSwgZmFsc2UsIGRiLCBmYWxzZSwgc3N1cCk7Cit9CisKKy8qCisgKiBsb3dlcl9ib3Vu ZGFyeQorICoJCURldGVybWluZSBsb3dlc3QgaW5kZXggc28gdGhhdCAodmFsdWVzW2luZGV4 XSA+PSBtaW52YWx1ZSkuCisgKgorICogVGhlIGFycmF5IG9mIHZhbHVlcyBpcyBleHBlY3Rl ZCB0byBiZSBzb3J0ZWQsIHNvIHRoaXMgaXMgdGhlIGZpcnN0IHZhbHVlCisgKiB0aGF0IG1h eSBmYWxsIGludG8gdGhlIFttaW52YWx1ZSwgbWF4dmFsdWVdIHJhbmdlLCBhcyBpdCBleGNl ZWRzIG1pbnZhbC4KKyAqIEl0J3Mgbm90IGd1YXJhbnRlZWQsIHRob3VnaCwgYXMgaXQgbWln aHQgZXhjZWVkIG1heHZhbHVlIHRvby4KKyAqLworc3RhdGljIGludAorbG93ZXJfYm91bmRh cnkoRGF0dW0gKnZhbHVlcywgaW50IG52YWx1ZXMsIERhdHVtIG1pbnZhbHVlLCBTb3J0U3Vw cG9ydCBzc3VwKQoreworCWludAkJc3RhcnQgPSAwLAorCQkJZW5kID0gKG52YWx1ZXMgLSAx KTsKKworCS8qIGV2ZXJ5dGhpbmcgZXhjZWVkcyBtaW52YWwgYW5kIG1pZ2h0IG1hdGNoICov CisJaWYgKGNvbXBhcmVfYXJyYXlfdmFsdWVzKCZtaW52YWx1ZSwgJnZhbHVlc1tzdGFydF0s IHNzdXApIDw9IDApCisJCXJldHVybiAwOworCisJLyogbm90aGluZyBjb3VsZCBtYXRjaCAq LworCWlmIChjb21wYXJlX2FycmF5X3ZhbHVlcygmbWludmFsdWUsICZ2YWx1ZXNbZW5kXSwg c3N1cCkgPiAwKQorCQlyZXR1cm4gbnZhbHVlczsKKworCXdoaWxlICgoZW5kIC0gc3RhcnQp ID4gMCkKKwl7CisJCWludCBtaWRwb2ludDsKKwkJaW50IHI7CisKKwkJbWlkcG9pbnQgPSBz dGFydCArIChlbmQgLSBzdGFydCkgLyAyOworCisJCXIgPSBjb21wYXJlX2FycmF5X3ZhbHVl cygmbWludmFsdWUsICZ2YWx1ZXNbbWlkcG9pbnRdLCBzc3VwKTsKKworCQlpZiAociA+IDAp CisJCQlzdGFydCA9IE1heChtaWRwb2ludCwgc3RhcnQgKyAxKTsKKwkJZWxzZQorCQkJZW5k ID0gbWlkcG9pbnQ7CisJfQorCisJLyogdGhlIHZhbHVlIHNob3VsZCBtZWV0IHRoZSAodiA+ PW1pbnZhbHVlKSByZXF1aXJlbWVudCAqLworCUFzc2VydChjb21wYXJlX2FycmF5X3ZhbHVl cygmdmFsdWVzW3N0YXJ0XSwgJm1pbnZhbHVlLCBzc3VwKSA+PSAwKTsKKworCS8qIHdlIGtu b3cgc3RhcnQgY2FuJ3QgYmUgMCwgc28gaXQncyBsZWdhbCB0byBzdWJ0cmFjdCAxICovCisJ QXNzZXJ0KGNvbXBhcmVfYXJyYXlfdmFsdWVzKCZ2YWx1ZXNbc3RhcnQtMV0sICZtaW52YWx1 ZSwgc3N1cCkgPCAwKTsKKworCXJldHVybiBzdGFydDsKK30KKwogLyoKICAqIEdpdmVuIGFu IGluZGV4IHR1cGxlIGNvcnJlc3BvbmRpbmcgdG8gYSBjZXJ0YWluIHBhZ2UgcmFuZ2UgYW5k IGEgc2NhbiBrZXksCiAgKiByZXR1cm4gd2hldGhlciB0aGUgc2NhbiBrZXkgaXMgY29uc2lz dGVudCB3aXRoIHRoZSBpbmRleCB0dXBsZSdzIG1pbi9tYXgKQEAgLTIyMyw2ICsyODEsMTAg QEAgYnJpbl9taW5tYXhfY29uc2lzdGVudChQR19GVU5DVElPTl9BUkdTKQogCQlnZXRfdHlw bGVuYnl2YWxhbGlnbihBUlJfRUxFTVRZUEUoYXJyYXl2YWwpLAogCQkJCQkJCSAmZWxtbGVu LCAmZWxtYnl2YWwsICZlbG1hbGlnbik7CiAKKwkJLyoKKwkJICogRklYTUUgV2Ugc2hvdWxk bid0IGRlY29uc3RydWN0IHRoZSBhcnJheSBvdmVyIGFuZCBvdmVyIGZvciBlYWNoIHBhZ2UK KwkJICogcmFuZ2UuIFdlIHNob3VsZCBwcmVwcm9jZXNzIGl0IG9uY2UsIGFuZCB0aGVuIGp1 c3QgdXNlIGl0LgorCQkgKi8KIAkJZGVjb25zdHJ1Y3RfYXJyYXkoYXJyYXl2YWwsCiAJCQkJ CQkgIEFSUl9FTEVNVFlQRShhcnJheXZhbCksCiAJCQkJCQkgIGVsbWxlbiwgZWxtYnl2YWws IGVsbWFsaWduLApAQCAtMjMyLDE5ICsyOTQsMTQgQEAgYnJpbl9taW5tYXhfY29uc2lzdGVu dChQR19GVU5DVElPTl9BUkdTKQogCQl7CiAJCQljYXNlIEJUTGVzc1N0cmF0ZWd5TnVtYmVy OgogCQkJY2FzZSBCVExlc3NFcXVhbFN0cmF0ZWd5TnVtYmVyOgotCi0JCQkJZm9yIChpbnQg aiA9IDA7IGogPCBudW1fZWxlbXM7IGorKykKLQkJCQl7Ci0JCQkJCURhdHVtIHZhbCA9IGVs ZW1fdmFsdWVzW2pdOwotCi0JCQkJCWZpbmZvID0gbWlubWF4X2dldF9zdHJhdGVneV9wcm9j aW5mbyhiZGVzYywgYXR0bm8sIHN1YnR5cGUsCi0JCQkJCQkJCQkJCQkJCSBrZXktPnNrX3N0 cmF0ZWd5KTsKLQkJCQkJbWF0Y2hlcyA9IEZ1bmN0aW9uQ2FsbDJDb2xsKGZpbmZvLCBjb2xs b2lkLCBjb2x1bW4tPmJ2X3ZhbHVlc1swXSwKLQkJCQkJCQkJCQkJCXZhbCk7Ci0KLQkJCQkJ aWYgKERhdHVtR2V0Qm9vbChtYXRjaGVzKSkKLQkJCQkJCWJyZWFrOwotCQkJCX0KKwkJCQkv KgorCQkJCSAqIENoZWNrIHRoZSBsYXN0IChsYXJnZXN0KSB2YWx1ZSBpbiB0aGUgYXJyYXkg LSBhdCBsZWFzdCB0aGlzCisJCQkJICogdmFsdWUgaGFzIHRvIGV4Y2VlZCB0aGUgcmFuZ2Ug bWludmFsLgorCQkJCSAqLworCQkJCWZpbmZvID0gbWlubWF4X2dldF9zdHJhdGVneV9wcm9j aW5mbyhiZGVzYywgYXR0bm8sIHN1YnR5cGUsCisJCQkJCQkJCQkJCQkJIGtleS0+c2tfc3Ry YXRlZ3kpOworCQkJCW1hdGNoZXMgPSBGdW5jdGlvbkNhbGwyQ29sbChmaW5mbywgY29sbG9p ZCwgY29sdW1uLT5idl92YWx1ZXNbMF0sCisJCQkJCQkJCQkJCWVsZW1fdmFsdWVzW251bV9l bGVtcy0xXSk7CiAJCQkJYnJlYWs7CiAJCQljYXNlIEJURXF1YWxTdHJhdGVneU51bWJlcjoK IApAQCAtMjUzLDQ0ICszMTAsOTQgQEAgYnJpbl9taW5tYXhfY29uc2lzdGVudChQR19GVU5D VElPTl9BUkdTKQogCQkJCSAqIHRoZSBjdXJyZW50IHBhZ2UgcmFuZ2UgaWYgdGhlIG1pbmlt dW0gdmFsdWUgaW4gdGhlIHJhbmdlIDw9CiAJCQkJICogc2NhbiBrZXksIGFuZCB0aGUgbWF4 aW11bSB2YWx1ZSA+PSBzY2FuIGtleS4KIAkJCQkgKgotCQkJCSAqIFhYWCBGb3IgYW55IG9m IHRoZSBhcnJheSB2YWx1ZXMuCisJCQkJICogV2UgZG8gdGhpcyBpbiB0d28gcGhhc2VzLiBX ZSBjaGVjayB0aGUgYXJyYXkgbWluL21heCB2YWx1ZXMgdG8gc2VlCisJCQkJICogaWYgdGhl cmUgZXZlbiBjYW4gYmUgYSBtYXRjaGluZyB2YWx1ZSwgYW5kIGlmIHllcyB3ZSBkbyBhIGJp bmFyeQorCQkJCSAqIHNlYXJjaCB0byBmaW5kIHRoZSBmaXJzdCB2YWx1ZSB0aGF0IGV4Y2Vl ZHMgcmFuZ2UgbWludmFsLiBBbmQgdGhlbgorCQkJCSAqIHdlIGNoZWNrIGlmIGl0IGFjdHVh bGx5IG1hdGNoZXMgdGhlIHJhbmdlLgorCQkJCSAqCisJCQkJICogWFhYIFRoZSBmaXJzdCBw aGFzZSBpcyBwcm9iYWJseSB1bm5lY2Vzc2FyeSwgYmVjYXVzZSBsb3dlcl9ib3VuZCgpCisJ CQkJICogZG9lcyBwcmV0dHkgbXVjaCBleGFjdGx5IHRoYXQgdG9vLgogCQkJCSAqLwotCQkJ CWZvciAoaW50IGogPSAwOyBqIDwgbnVtX2VsZW1zOyBqKyspCiAJCQkJewotCQkJCQlEYXR1 bSB2YWwgPSBlbGVtX3ZhbHVlc1tqXTsKKwkJCQkJRGF0dW0gdmFsOworCQkJCQlTb3J0U3Vw cG9ydERhdGEgc3N1cDsKKwkJCQkJaW50CQkJbG93ZXI7CisJCQkJCVR5cGVDYWNoZUVudHJ5 ICp0eXBlOworCisJCQkJCS8qIElzIHRoZSBmaXJzdCAoc21hbGxlc3QpIHZhbHVlIGFmdGVy IHRoZSBCUklOIHJhbmdlPyAqLworCQkJCQl2YWwgPSBlbGVtX3ZhbHVlc1swXTsKIAogCQkJ CQlmaW5mbyA9IG1pbm1heF9nZXRfc3RyYXRlZ3lfcHJvY2luZm8oYmRlc2MsIGF0dG5vLCBz dWJ0eXBlLAogCQkJCQkJCQkJCQkJCQkgQlRMZXNzRXF1YWxTdHJhdGVneU51bWJlcik7Ci0J CQkJCW1hdGNoZXMgPSBGdW5jdGlvbkNhbGwyQ29sbChmaW5mbywgY29sbG9pZCwgY29sdW1u LT5idl92YWx1ZXNbMF0sCi0JCQkJCQkJCQkJCQl2YWwpOworCQkJCQltYXRjaGVzID0gRnVu Y3Rpb25DYWxsMkNvbGwoZmluZm8sIGNvbGxvaWQsIHZhbCwgY29sdW1uLT5idl92YWx1ZXNb MV0pOworCisJCQkJCS8qIG1pbnZhbCA+IG1heChyYW5nZSB2YWx1ZXMpICovCiAJCQkJCWlm ICghRGF0dW1HZXRCb29sKG1hdGNoZXMpKQotCQkJCQkJY29udGludWU7CisJCQkJCQlicmVh azsKKworCQkJCQkvKiBJcyB0aGUgbGFzdCAobGFyZ2VzdCkgdmFsdWUgYmVmb3JlIHRoZSBC UklOIHJhbmdlPyAqLworCQkJCQl2YWwgPSBlbGVtX3ZhbHVlc1tudW1fZWxlbXMtMV07CiAK LQkJCQkJLyogbWF4KCkgPj0gc2NhbmtleSAqLwogCQkJCQlmaW5mbyA9IG1pbm1heF9nZXRf c3RyYXRlZ3lfcHJvY2luZm8oYmRlc2MsIGF0dG5vLCBzdWJ0eXBlLAogCQkJCQkJCQkJCQkJ CQkgQlRHcmVhdGVyRXF1YWxTdHJhdGVneU51bWJlcik7Ci0JCQkJCW1hdGNoZXMgPSBGdW5j dGlvbkNhbGwyQ29sbChmaW5mbywgY29sbG9pZCwgY29sdW1uLT5idl92YWx1ZXNbMV0sCi0J CQkJCQkJCQkJCQl2YWwpOworCQkJCQltYXRjaGVzID0gRnVuY3Rpb25DYWxsMkNvbGwoZmlu Zm8sIGNvbGxvaWQsIHZhbCwgY29sdW1uLT5idl92YWx1ZXNbMF0pOwogCi0JCQkJCWlmIChE YXR1bUdldEJvb2wobWF0Y2hlcykpCisJCQkJCS8qIG1heHZhbCA8IG1pbihyYW5nZSB2YWx1 ZXMpICovCisJCQkJCWlmICghRGF0dW1HZXRCb29sKG1hdGNoZXMpKQogCQkJCQkJYnJlYWs7 Ci0JCQkJfQotCQkJCWJyZWFrOwotCQkJY2FzZSBCVEdyZWF0ZXJFcXVhbFN0cmF0ZWd5TnVt YmVyOgotCQkJY2FzZSBCVEdyZWF0ZXJTdHJhdGVneU51bWJlcjoKIAotCQkJCWZvciAoaW50 IGogPSAwOyBqIDwgbnVtX2VsZW1zOyBqKyspCi0JCQkJewotCQkJCQlEYXR1bSB2YWwgPSBl bGVtX3ZhbHVlc1tqXTsKKwkJCQkJLyoKKwkJCQkJICogT0ssIHRoZXJlIG1pZ2h0IGJlIHNv bWUgdmFsdWVzIG1hdGNoaW5nIHRoZSByYW5nZS4gV2UgaGF2ZQorCQkJCQkgKiB0byBzZWFy Y2ggdGhlbSBvbmUgYnkgb25lLCBvciBwZXJoYXBzIHRyeSBiaW5zZWFyY2guCisJCQkJCSAq LworCQkJCQl0eXBlID0gbG9va3VwX3R5cGVfY2FjaGUoQVJSX0VMRU1UWVBFKGFycmF5dmFs KSwgVFlQRUNBQ0hFX0xUX09QUik7CisKKwkJCQkJbWVtc2V0KCZzc3VwLCAwLCBzaXplb2Yo U29ydFN1cHBvcnREYXRhKSk7CisJCQkJCVByZXBhcmVTb3J0U3VwcG9ydEZyb21PcmRlcmlu Z09wKHR5cGUtPmx0X29wciwgJnNzdXApOwogCisJCQkJCWxvd2VyID0gbG93ZXJfYm91bmRh cnkoZWxlbV92YWx1ZXMsIG51bV9lbGVtcywgY29sdW1uLT5idl92YWx1ZXNbMF0sICZzc3Vw KTsKKworCQkJCQkvKiBubyBlbGVtZW50cyBjYW4gcG9zc2libHkgbWF0Y2ggKi8KKwkJCQkJ aWYgKGxvd2VyID09IG51bV9lbGVtcykKKwkJCQkJeworCQkJCQkJbWF0Y2hlcyA9IEJvb2xH ZXREYXR1bShmYWxzZSk7CisJCQkJCQlicmVhazsKKwkJCQkJfQorCisJCQkJCS8qCisJCQkJ CSAqIE9LLCB0aGUgZmlyc3QgZWxlbWVudCBtdXN0IG1hdGNoIHRoZSB1cHBlciBib3VuZGFy eSB0b28KKwkJCQkJICogKGlmIGl0IGRvZXMgbm90LCBubyBmb2xsb3dpbmcgZWxlbWVudHMg Y2FuKS4KKwkJCQkJICovCisJCQkJCXZhbCA9IGVsZW1fdmFsdWVzW2xvd2VyXTsKKworCQkJ CQkvKgorCQkJCQkgKiBJbiB0aGUgZXF1YWxpdHkgY2FzZSAoV0hFUkUgY29sID0gc29tZXZh bCksIHdlIHdhbnQgdG8gcmV0dXJuCisJCQkJCSAqIHRoZSBjdXJyZW50IHBhZ2UgcmFuZ2Ug aWYgdGhlIG1pbmltdW0gdmFsdWUgaW4gdGhlIHJhbmdlIDw9CisJCQkJCSAqIHNjYW4ga2V5 LCBhbmQgdGhlIG1heGltdW0gdmFsdWUgPj0gc2NhbiBrZXkuCisJCQkJCSAqLwogCQkJCQlm aW5mbyA9IG1pbm1heF9nZXRfc3RyYXRlZ3lfcHJvY2luZm8oYmRlc2MsIGF0dG5vLCBzdWJ0 eXBlLAotCQkJCQkJCQkJCQkJCQkga2V5LT5za19zdHJhdGVneSk7Ci0JCQkJCW1hdGNoZXMg PSBGdW5jdGlvbkNhbGwyQ29sbChmaW5mbywgY29sbG9pZCwgY29sdW1uLT5idl92YWx1ZXNb MV0sCisJCQkJCQkJCQkJCQkJCSBCVExlc3NFcXVhbFN0cmF0ZWd5TnVtYmVyKTsKKwkJCQkJ bWF0Y2hlcyA9IEZ1bmN0aW9uQ2FsbDJDb2xsKGZpbmZvLCBjb2xsb2lkLCBjb2x1bW4tPmJ2 X3ZhbHVlc1swXSwKIAkJCQkJCQkJCQkJCXZhbCk7Ci0KLQkJCQkJaWYgKERhdHVtR2V0Qm9v bChtYXRjaGVzKSkKKwkJCQkJaWYgKCFEYXR1bUdldEJvb2wobWF0Y2hlcykpCiAJCQkJCQli cmVhazsKKwkJCQkJLyogbWF4KCkgPj0gc2NhbmtleSAqLworCQkJCQlmaW5mbyA9IG1pbm1h eF9nZXRfc3RyYXRlZ3lfcHJvY2luZm8oYmRlc2MsIGF0dG5vLCBzdWJ0eXBlLAorCQkJCQkJ CQkJCQkJCQkgQlRHcmVhdGVyRXF1YWxTdHJhdGVneU51bWJlcik7CisJCQkJCW1hdGNoZXMg PSBGdW5jdGlvbkNhbGwyQ29sbChmaW5mbywgY29sbG9pZCwgY29sdW1uLT5idl92YWx1ZXNb MV0sCisJCQkJCQkJCQkJCQl2YWwpOworCQkJCQlicmVhazsKIAkJCQl9CisJCQljYXNlIEJU R3JlYXRlckVxdWFsU3RyYXRlZ3lOdW1iZXI6CisJCQljYXNlIEJUR3JlYXRlclN0cmF0ZWd5 TnVtYmVyOgorCQkJCS8qCisJCQkJICogQ2hlY2sgdGhlIGZpcnN0IChzbWFsbGVzdCkgdmFs dWUgaW4gdGhlIGFycmF5IC0gYXQgbGVhc3QgdGhpcworCQkJCSAqIHZhbHVlIGhhcyB0byBi ZSBzbWFsbGVyIHRoYW4gdGhlIHJhbmdlIG1heHZhbC4KKwkJCQkgKi8KKwkJCQlmaW5mbyA9 IG1pbm1heF9nZXRfc3RyYXRlZ3lfcHJvY2luZm8oYmRlc2MsIGF0dG5vLCBzdWJ0eXBlLAor CQkJCQkJCQkJCQkJCSBrZXktPnNrX3N0cmF0ZWd5KTsKKwkJCQltYXRjaGVzID0gRnVuY3Rp b25DYWxsMkNvbGwoZmluZm8sIGNvbGxvaWQsIGNvbHVtbi0+YnZfdmFsdWVzWzFdLAorCQkJ CQkJCQkJCQllbGVtX3ZhbHVlc1swXSk7CiAJCQkJYnJlYWs7CiAJCQlkZWZhdWx0OgogCQkJ CS8qIHNob3VsZG4ndCBoYXBwZW4gKi8KLS0gCjIuMzkuMQoK --------------vUwxfMJd601J0Yjedx8IQ3Mp Content-Type: text/x-patch; charset=UTF-8; name="0003-Support-SK_SEARCHARRAY-in-BRIN-minmax-multi-20230213.patch" Content-Disposition: attachment; filename*0="0003-Support-SK_SEARCHARRAY-in-BRIN-minmax-multi-20230213.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSBhMDEyNTU5NjI3NzY0N2I1OTNiYzdkMWI1ZGYyYmJiZmU4NTljYmQxIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb21hcyBWb25kcmEgPHRvbWFzLnZvbmRyYUBwb3N0 Z3Jlc3FsLm9yZz4KRGF0ZTogU2F0LCAxMSBGZWIgMjAyMyAxOTo0MzozOCArMDEwMApTdWJq ZWN0OiBbUEFUQ0ggMy82XSBTdXBwb3J0IFNLX1NFQVJDSEFSUkFZIGluIEJSSU4gbWlubWF4 LW11bHRpCgpTaW1pbGFyIGFwcHJvYWNoIHRvIG1pbm1heCwgYnV0IHRoZSBpc3N1ZXMgd2l0 aCBkZWNvbnN0cnVjdGluZyB0aGUgYXJyYXkKb3ZlciBhbmQgb3ZlciBhcmUgZXZlbiBtb3Jl IHNlcmlvdXMuCi0tLQogc3JjL2JhY2tlbmQvYWNjZXNzL2JyaW4vYnJpbl9taW5tYXhfbXVs dGkuYyB8IDM4OCArKysrKysrKysrKysrKysrLS0tLQogMSBmaWxlIGNoYW5nZWQsIDMyMiBp bnNlcnRpb25zKCspLCA2NiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2Vu ZC9hY2Nlc3MvYnJpbi9icmluX21pbm1heF9tdWx0aS5jIGIvc3JjL2JhY2tlbmQvYWNjZXNz L2JyaW4vYnJpbl9taW5tYXhfbXVsdGkuYwppbmRleCAwYWNlNjAzNWJlLi40M2U5MTQzZjJh IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvYnJpbi9icmluX21pbm1heF9tdWx0 aS5jCisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9icmluL2JyaW5fbWlubWF4X211bHRpLmMK QEAgLTI1NjIsNiArMjU2Miw2MyBAQCBicmluX21pbm1heF9tdWx0aV9hZGRfdmFsdWUoUEdf RlVOQ1RJT05fQVJHUykKIAlQR19SRVRVUk5fQk9PTChtb2RpZmllZCk7CiB9CiAKKworc3Rh dGljIGludAorY29tcGFyZV9hcnJheV92YWx1ZXMoY29uc3Qgdm9pZCAqYSwgY29uc3Qgdm9p ZCAqYiwgdm9pZCAqYXJnKQoreworCURhdHVtCWRhID0gKiAoRGF0dW0gKikgYTsKKwlEYXR1 bQlkYiA9ICogKERhdHVtICopIGI7CisJU29ydFN1cHBvcnQJc3N1cCA9IChTb3J0U3VwcG9y dCkgYXJnOworCisJcmV0dXJuIEFwcGx5U29ydENvbXBhcmF0b3IoZGEsIGZhbHNlLCBkYiwg ZmFsc2UsIHNzdXApOworfQorCisvKgorICogbG93ZXJfYm91bmRhcnkKKyAqCQlEZXRlcm1p bmUgbG93ZXN0IGluZGV4IHNvIHRoYXQgKHZhbHVlc1tpbmRleF0gPj0gbWludmFsdWUpLgor ICoKKyAqIFRoZSBhcnJheSBvZiB2YWx1ZXMgaXMgZXhwZWN0ZWQgdG8gYmUgc29ydGVkLCBz byB0aGlzIGlzIHRoZSBmaXJzdCB2YWx1ZQorICogdGhhdCBtYXkgZmFsbCBpbnRvIHRoZSBb bWludmFsdWUsIG1heHZhbHVlXSByYW5nZSwgYXMgaXQgZXhjZWVkcyBtaW52YWwuCisgKiBJ dCdzIG5vdCBndWFyYW50ZWVkLCB0aG91Z2gsIGFzIGl0IG1pZ2h0IGV4Y2VlZCBtYXh2YWx1 ZSB0b28uCisgKi8KK3N0YXRpYyBpbnQKK2xvd2VyX2JvdW5kYXJ5KERhdHVtICp2YWx1ZXMs IGludCBudmFsdWVzLCBEYXR1bSBtaW52YWx1ZSwgU29ydFN1cHBvcnQgc3N1cCkKK3sKKwlp bnQJCXN0YXJ0ID0gMCwKKwkJCWVuZCA9IChudmFsdWVzIC0gMSk7CisKKwkvKiBldmVyeXRo aW5nIGV4Y2VlZHMgbWludmFsIGFuZCBtaWdodCBtYXRjaCAqLworCWlmIChjb21wYXJlX2Fy cmF5X3ZhbHVlcygmbWludmFsdWUsICZ2YWx1ZXNbc3RhcnRdLCBzc3VwKSA8PSAwKQorCQly ZXR1cm4gMDsKKworCS8qIG5vdGhpbmcgY291bGQgbWF0Y2ggKi8KKwlpZiAoY29tcGFyZV9h cnJheV92YWx1ZXMoJm1pbnZhbHVlLCAmdmFsdWVzW2VuZF0sIHNzdXApID4gMCkKKwkJcmV0 dXJuIG52YWx1ZXM7CisKKwl3aGlsZSAoKGVuZCAtIHN0YXJ0KSA+IDApCisJeworCQlpbnQg bWlkcG9pbnQ7CisJCWludCByOworCisJCW1pZHBvaW50ID0gc3RhcnQgKyAoZW5kIC0gc3Rh cnQpIC8gMjsKKworCQlyID0gY29tcGFyZV9hcnJheV92YWx1ZXMoJm1pbnZhbHVlLCAmdmFs dWVzW21pZHBvaW50XSwgc3N1cCk7CisKKwkJaWYgKHIgPiAwKQorCQkJc3RhcnQgPSBNYXgo bWlkcG9pbnQsIHN0YXJ0ICsgMSk7CisJCWVsc2UKKwkJCWVuZCA9IG1pZHBvaW50OworCX0K KworCS8qIHRoZSB2YWx1ZSBzaG91bGQgbWVldCB0aGUgKHYgPj1taW52YWx1ZSkgcmVxdWly ZW1lbnQgKi8KKwlBc3NlcnQoY29tcGFyZV9hcnJheV92YWx1ZXMoJnZhbHVlc1tzdGFydF0s ICZtaW52YWx1ZSwgc3N1cCkgPj0gMCk7CisKKwkvKiB3ZSBrbm93IHN0YXJ0IGNhbid0IGJl IDAsIHNvIGl0J3MgbGVnYWwgdG8gc3VidHJhY3QgMSAqLworCUFzc2VydChjb21wYXJlX2Fy cmF5X3ZhbHVlcygmdmFsdWVzW3N0YXJ0LTFdLCAmbWludmFsdWUsIHNzdXApIDwgMCk7CisK KwlyZXR1cm4gc3RhcnQ7Cit9CisKIC8qCiAgKiBHaXZlbiBhbiBpbmRleCB0dXBsZSBjb3Jy ZXNwb25kaW5nIHRvIGEgY2VydGFpbiBwYWdlIHJhbmdlIGFuZCBhIHNjYW4ga2V5LAogICog cmV0dXJuIHdoZXRoZXIgdGhlIHNjYW4ga2V5IGlzIGNvbnNpc3RlbnQgd2l0aCB0aGUgaW5k ZXggdHVwbGUncyBtaW4vbWF4CkBAIC0yNTkxLDYgKzI2NDgsMTUgQEAgYnJpbl9taW5tYXhf bXVsdGlfY29uc2lzdGVudChQR19GVU5DVElPTl9BUkdTKQogCXNlcmlhbGl6ZWQgPSAoU2Vy aWFsaXplZFJhbmdlcyAqKSBQR19ERVRPQVNUX0RBVFVNKGNvbHVtbi0+YnZfdmFsdWVzWzBd KTsKIAlyYW5nZXMgPSBicmluX3JhbmdlX2Rlc2VyaWFsaXplKHNlcmlhbGl6ZWQtPm1heHZh bHVlcywgc2VyaWFsaXplZCk7CiAKKwkvKgorCSAqIFhYWCBXb3VsZCBpdCBtYWtlIHNlbnNl IHRvIGhhdmUgYSBxdWljayBpbml0aWFsIGNoZWNrIG9uIHRoZSB3aG9sZQorCSAqIHN1bW1h cnk/IFdlIGtub3cgbW9zdCBwYWdlIHJhbmdlcyBhcmUgbm90IGV4cGVjdGVkIHRvIG1hdGNo LCBhbmQgd2UKKwkgKiBrbm93IHRoZSByYW5nZXMvdmFsdWVzIGFyZSBzb3J0ZWQgc28gd2Ug Y291bGQgY2hlY2sgZ2xvYmFsIG1pbi9tYXgKKwkgKiAoZXNzZW50aWFsbHkgd2hhdCByZWd1 bGFyIG1pbm1heCBpcyBkb2luZykgYW5kIGJhaWwgaWYgbm8gbWF0Y2ggaXMKKwkgKiBwb3Nz aWJsZS4gVGhhdCBzaG91bGQgYmUgY2hlYXAgYW5kIG1pZ2h0IHNhdmUgYSBsb3Qgb24gaW5z cGVjdGluZworCSAqIHRoZSBpbmRpdmlkdWFsIHJhbmdlcy92YWx1ZXMuCisJICovCisKIAkv KiBpbnNwZWN0IHRoZSByYW5nZXMsIGFuZCBmb3IgZWFjaCBvbmUgZXZhbHVhdGUgdGhlIHNj YW4ga2V5cyAqLwogCWZvciAocmFuZ2VubyA9IDA7IHJhbmdlbm8gPCByYW5nZXMtPm5yYW5n ZXM7IHJhbmdlbm8rKykKIAl7CkBAIC0yNjExLDY3ICsyNjc3LDIwNSBAQCBicmluX21pbm1h eF9tdWx0aV9jb25zaXN0ZW50KFBHX0ZVTkNUSU9OX0FSR1MpCiAJCQlhdHRubyA9IGtleS0+ c2tfYXR0bm87CiAJCQlzdWJ0eXBlID0ga2V5LT5za19zdWJ0eXBlOwogCQkJdmFsdWUgPSBr ZXktPnNrX2FyZ3VtZW50OwotCQkJc3dpdGNoIChrZXktPnNrX3N0cmF0ZWd5KQorCisJCQlp ZiAobGlrZWx5KCEoa2V5LT5za19mbGFncyAmIFNLX1NFQVJDSEFSUkFZKSkpCiAJCQl7Ci0J CQkJY2FzZSBCVExlc3NTdHJhdGVneU51bWJlcjoKLQkJCQljYXNlIEJUTGVzc0VxdWFsU3Ry YXRlZ3lOdW1iZXI6Ci0JCQkJCWZpbmZvID0gbWlubWF4X211bHRpX2dldF9zdHJhdGVneV9w cm9jaW5mbyhiZGVzYywgYXR0bm8sIHN1YnR5cGUsCi0JCQkJCQkJCQkJCQkJCQkgICBrZXkt PnNrX3N0cmF0ZWd5KTsKLQkJCQkJLyogZmlyc3QgdmFsdWUgZnJvbSB0aGUgYXJyYXkgKi8K LQkJCQkJbWF0Y2hlcyA9IEZ1bmN0aW9uQ2FsbDJDb2xsKGZpbmZvLCBjb2xsb2lkLCBtaW52 YWwsIHZhbHVlKTsKLQkJCQkJYnJlYWs7CisJCQkJc3dpdGNoIChrZXktPnNrX3N0cmF0ZWd5 KQorCQkJCXsKKwkJCQkJY2FzZSBCVExlc3NTdHJhdGVneU51bWJlcjoKKwkJCQkJY2FzZSBC VExlc3NFcXVhbFN0cmF0ZWd5TnVtYmVyOgorCQkJCQkJZmluZm8gPSBtaW5tYXhfbXVsdGlf Z2V0X3N0cmF0ZWd5X3Byb2NpbmZvKGJkZXNjLCBhdHRubywgc3VidHlwZSwKKwkJCQkJCQkJ CQkJCQkJCQkgICBrZXktPnNrX3N0cmF0ZWd5KTsKKwkJCQkJCS8qIGZpcnN0IHZhbHVlIGZy b20gdGhlIGFycmF5ICovCisJCQkJCQltYXRjaGVzID0gRnVuY3Rpb25DYWxsMkNvbGwoZmlu Zm8sIGNvbGxvaWQsIG1pbnZhbCwgdmFsdWUpOworCQkJCQkJYnJlYWs7CiAKLQkJCQljYXNl IEJURXF1YWxTdHJhdGVneU51bWJlcjoKLQkJCQkJewotCQkJCQkJRGF0dW0JCWNvbXBhcjsK LQkJCQkJCUZtZ3JJbmZvICAgKmNtcEZuOworCQkJCQljYXNlIEJURXF1YWxTdHJhdGVneU51 bWJlcjoKKwkJCQkJCXsKKwkJCQkJCQlEYXR1bQkJY29tcGFyOworCQkJCQkJCUZtZ3JJbmZv ICAgKmNtcEZuOworCisJCQkJCQkJLyogYnkgZGVmYXVsdCB0aGlzIHJhbmdlIGRvZXMgbm90 IG1hdGNoICovCisJCQkJCQkJbWF0Y2hlcyA9IGZhbHNlOworCisJCQkJCQkJLyoKKwkJCQkJ CQkgKiBPdGhlcndpc2UsIG5lZWQgdG8gY29tcGFyZSB0aGUgbmV3IHZhbHVlIHdpdGgKKwkJ CQkJCQkgKiBib3VuZGFyaWVzIG9mIGFsbCB0aGUgcmFuZ2VzLiBGaXJzdCBjaGVjayBpZiBp dCdzCisJCQkJCQkJICogbGVzcyB0aGFuIHRoZSBhYnNvbHV0ZSBtaW5pbXVtLCB3aGljaCBp cyB0aGUgZmlyc3QKKwkJCQkJCQkgKiB2YWx1ZSBpbiB0aGUgYXJyYXkuCisJCQkJCQkJICov CisJCQkJCQkJY21wRm4gPSBtaW5tYXhfbXVsdGlfZ2V0X3N0cmF0ZWd5X3Byb2NpbmZvKGJk ZXNjLCBhdHRubywgc3VidHlwZSwKKwkJCQkJCQkJCQkJCQkJCQkJICAgQlRHcmVhdGVyU3Ry YXRlZ3lOdW1iZXIpOworCQkJCQkJCWNvbXBhciA9IEZ1bmN0aW9uQ2FsbDJDb2xsKGNtcEZu LCBjb2xsb2lkLCBtaW52YWwsIHZhbHVlKTsKKworCQkJCQkJCS8qIHNtYWxsZXIgdGhhbiB0 aGUgc21hbGxlc3QgdmFsdWUgaW4gdGhpcyByYW5nZSAqLworCQkJCQkJCWlmIChEYXR1bUdl dEJvb2woY29tcGFyKSkKKwkJCQkJCQkJYnJlYWs7CisKKwkJCQkJCQljbXBGbiA9IG1pbm1h eF9tdWx0aV9nZXRfc3RyYXRlZ3lfcHJvY2luZm8oYmRlc2MsIGF0dG5vLCBzdWJ0eXBlLAor CQkJCQkJCQkJCQkJCQkJCQkgICBCVExlc3NTdHJhdGVneU51bWJlcik7CisJCQkJCQkJY29t cGFyID0gRnVuY3Rpb25DYWxsMkNvbGwoY21wRm4sIGNvbGxvaWQsIG1heHZhbCwgdmFsdWUp OworCisJCQkJCQkJLyogbGFyZ2VyIHRoYW4gdGhlIGxhcmdlc3QgdmFsdWUgaW4gdGhpcyBy YW5nZSAqLworCQkJCQkJCWlmIChEYXR1bUdldEJvb2woY29tcGFyKSkKKwkJCQkJCQkJYnJl YWs7CisKKwkJCQkJCQkvKgorCQkJCQkJCSAqIFdlIGhhdmVuJ3QgbWFuYWdlZCB0byBlbGlt aW5hdGUgdGhpcyByYW5nZSwgc28KKwkJCQkJCQkgKiBjb25zaWRlciBpdCBtYXRjaGluZy4K KwkJCQkJCQkgKi8KKwkJCQkJCQltYXRjaGVzID0gdHJ1ZTsKIAotCQkJCQkJLyogYnkgZGVm YXVsdCB0aGlzIHJhbmdlIGRvZXMgbm90IG1hdGNoICovCi0JCQkJCQltYXRjaGVzID0gZmFs c2U7CisJCQkJCQkJYnJlYWs7CisJCQkJCQl9CisJCQkJCWNhc2UgQlRHcmVhdGVyRXF1YWxT dHJhdGVneU51bWJlcjoKKwkJCQkJY2FzZSBCVEdyZWF0ZXJTdHJhdGVneU51bWJlcjoKKwkJ CQkJCWZpbmZvID0gbWlubWF4X211bHRpX2dldF9zdHJhdGVneV9wcm9jaW5mbyhiZGVzYywg YXR0bm8sIHN1YnR5cGUsCisJCQkJCQkJCQkJCQkJCQkJICAga2V5LT5za19zdHJhdGVneSk7 CisJCQkJCQkvKiBsYXN0IHZhbHVlIGZyb20gdGhlIGFycmF5ICovCisJCQkJCQltYXRjaGVz ID0gRnVuY3Rpb25DYWxsMkNvbGwoZmluZm8sIGNvbGxvaWQsIG1heHZhbCwgdmFsdWUpOwor CQkJCQkJYnJlYWs7CiAKLQkJCQkJCS8qCi0JCQkJCQkgKiBPdGhlcndpc2UsIG5lZWQgdG8g Y29tcGFyZSB0aGUgbmV3IHZhbHVlIHdpdGgKLQkJCQkJCSAqIGJvdW5kYXJpZXMgb2YgYWxs IHRoZSByYW5nZXMuIEZpcnN0IGNoZWNrIGlmIGl0J3MKLQkJCQkJCSAqIGxlc3MgdGhhbiB0 aGUgYWJzb2x1dGUgbWluaW11bSwgd2hpY2ggaXMgdGhlIGZpcnN0Ci0JCQkJCQkgKiB2YWx1 ZSBpbiB0aGUgYXJyYXkuCi0JCQkJCQkgKi8KLQkJCQkJCWNtcEZuID0gbWlubWF4X211bHRp X2dldF9zdHJhdGVneV9wcm9jaW5mbyhiZGVzYywgYXR0bm8sIHN1YnR5cGUsCi0JCQkJCQkJ CQkJCQkJCQkJICAgQlRHcmVhdGVyU3RyYXRlZ3lOdW1iZXIpOwotCQkJCQkJY29tcGFyID0g RnVuY3Rpb25DYWxsMkNvbGwoY21wRm4sIGNvbGxvaWQsIG1pbnZhbCwgdmFsdWUpOworCQkJ CQlkZWZhdWx0OgorCQkJCQkJLyogc2hvdWxkbid0IGhhcHBlbiAqLworCQkJCQkJZWxvZyhF UlJPUiwgImludmFsaWQgc3RyYXRlZ3kgbnVtYmVyICVkIiwga2V5LT5za19zdHJhdGVneSk7 CisJCQkJCQltYXRjaGVzID0gMDsKKwkJCQkJCWJyZWFrOworCQkJCX0KKwkJCX0KKwkJCWVs c2UKKwkJCXsKKwkJCQkvKgorCQkJCSAqIEZJWE1FIFRoaXMgaXMgcmVhbGx5IHdyb25nLCBi ZWNhdXNlIGl0IGRlc2VyaWFsaXplcyB0aGUKKwkJCQkgKiBhcnJheSBvdmVyIGFuZCBvdmVy IGZvciBlYWNoIHZhbHVlIGluIHRoZSBtaW5tYXgtbXVsdGkKKwkJCQkgKiBzdW1tYXJ5IHJh bmdlLgorCQkJCSAqCisJCQkJICogRklYTUUgSW4gZmFjdCwgdGhpcyBpcyBldmVuIHdvcnNl IHRoYW4gZm9yIGJyaW5fbWlubWF4LmMKKwkJCQkgKiBiZWNhdXNlIHdlIGRlY29uc3RydWN0 IGl0IGZvciBldmVyeSByYW5nZSBpbiB0aGUgc3VtbWFyeQorCQkJCSAqIChzbyBpZiB0aGVy ZSBhcmUgMzIgdmFsdWVzLCB0aGF0J3MgMTYgcmFuZ2VzLCBhbmQgd2UnbGwKKwkJCQkgKiBk ZWNvbnN0cnVjdCBpdCBhZ2FpbiBmb3IgZWFjaCBvZiB0aG9zZSkuCisJCQkJICoKKwkJCQkg KiBYWFggV2UgY291bGQgZGVjb25zdHJ1Y3QgaXQgb25jZSwgd2hlbiB3ZSBuZWVkIGl0IGZv ciB0aGUKKwkJCQkgKiBmaXJzdCB0aW1lLiBCdXQgZXZlbiBiZXR0ZXIgd2Ugc2hvdWxkIGRv IGl0IG9ubHkgb25jZSB3aGlsZQorCQkJCSAqIHByZXByb2Nlc3NpbmcgdGhlIHNjYW4ga2V5 cy4KKwkJCQkgKi8KKwkJCQlBcnJheVR5cGUgICphcnJheXZhbDsKKwkJCQlpbnQxNgkJZWxt bGVuOworCQkJCWJvb2wJCWVsbWJ5dmFsOworCQkJCWNoYXIJCWVsbWFsaWduOworCQkJCWlu dAkJCW51bV9lbGVtczsKKwkJCQlEYXR1bQkgICAqZWxlbV92YWx1ZXM7CisJCQkJYm9vbAkg ICAqZWxlbV9udWxsczsKIAotCQkJCQkJLyogc21hbGxlciB0aGFuIHRoZSBzbWFsbGVzdCB2 YWx1ZSBpbiB0aGlzIHJhbmdlICovCi0JCQkJCQlpZiAoRGF0dW1HZXRCb29sKGNvbXBhcikp Ci0JCQkJCQkJYnJlYWs7CisJCQkJYXJyYXl2YWwgPSBEYXR1bUdldEFycmF5VHlwZVAoa2V5 LT5za19hcmd1bWVudCk7CiAKLQkJCQkJCWNtcEZuID0gbWlubWF4X211bHRpX2dldF9zdHJh dGVneV9wcm9jaW5mbyhiZGVzYywgYXR0bm8sIHN1YnR5cGUsCi0JCQkJCQkJCQkJCQkJCQkJ ICAgQlRMZXNzU3RyYXRlZ3lOdW1iZXIpOwotCQkJCQkJY29tcGFyID0gRnVuY3Rpb25DYWxs MkNvbGwoY21wRm4sIGNvbGxvaWQsIG1heHZhbCwgdmFsdWUpOworCQkJCWdldF90eXBsZW5i eXZhbGFsaWduKEFSUl9FTEVNVFlQRShhcnJheXZhbCksCisJCQkJCQkJCQkgJmVsbWxlbiwg JmVsbWJ5dmFsLCAmZWxtYWxpZ24pOwogCi0JCQkJCQkvKiBsYXJnZXIgdGhhbiB0aGUgbGFy Z2VzdCB2YWx1ZSBpbiB0aGlzIHJhbmdlICovCi0JCQkJCQlpZiAoRGF0dW1HZXRCb29sKGNv bXBhcikpCi0JCQkJCQkJYnJlYWs7CisJCQkJZGVjb25zdHJ1Y3RfYXJyYXkoYXJyYXl2YWws CisJCQkJCQkJCSAgQVJSX0VMRU1UWVBFKGFycmF5dmFsKSwKKwkJCQkJCQkJICBlbG1sZW4s IGVsbWJ5dmFsLCBlbG1hbGlnbiwKKwkJCQkJCQkJICAmZWxlbV92YWx1ZXMsICZlbGVtX251 bGxzLCAmbnVtX2VsZW1zKTsKKworCQkJCXN3aXRjaCAoa2V5LT5za19zdHJhdGVneSkKKwkJ CQl7CisJCQkJCWNhc2UgQlRMZXNzU3RyYXRlZ3lOdW1iZXI6CisJCQkJCWNhc2UgQlRMZXNz RXF1YWxTdHJhdGVneU51bWJlcjoKKwkJCQkJCWZpbmZvID0gbWlubWF4X211bHRpX2dldF9z dHJhdGVneV9wcm9jaW5mbyhiZGVzYywgYXR0bm8sIHN1YnR5cGUsCisJCQkJCQkJCQkJCQkJ CQkJICAga2V5LT5za19zdHJhdGVneSk7CisJCQkJCQkvKiBmaXJzdCB2YWx1ZSBmcm9tIHRo ZSBhcnJheSAqLworCQkJCQkJbWF0Y2hlcyA9IEZ1bmN0aW9uQ2FsbDJDb2xsKGZpbmZvLCBj b2xsb2lkLCBtaW52YWwsCisJCQkJCQkJCQkJCQkJZWxlbV92YWx1ZXNbbnVtX2VsZW1zLTFd KTsKKwkJCQkJCWJyZWFrOworCisJCQkJCWNhc2UgQlRFcXVhbFN0cmF0ZWd5TnVtYmVyOgog CiAJCQkJCQkvKgotCQkJCQkJICogV2UgaGF2ZW4ndCBtYW5hZ2VkIHRvIGVsaW1pbmF0ZSB0 aGlzIHJhbmdlLCBzbwotCQkJCQkJICogY29uc2lkZXIgaXQgbWF0Y2hpbmcuCisJCQkJCQkg KiBTZWUgYnJpbl9taW5tYXguYyBmb3IgZGVzY3JpcHRpb24gb2Ygd2hhdCB0aGlzIGlzIGRv aW5nLgogCQkJCQkJICovCi0JCQkJCQltYXRjaGVzID0gdHJ1ZTsKLQorCQkJCQkJeworCQkJ CQkJCURhdHVtIHZhbDsKKwkJCQkJCQlTb3J0U3VwcG9ydERhdGEgc3N1cDsKKwkJCQkJCQlp bnQJCQlsb3dlcjsKKwkJCQkJCQlUeXBlQ2FjaGVFbnRyeSAqdHlwZTsKKworCQkJCQkJCS8q IElzIHRoZSBmaXJzdCAoc21hbGxlc3QpIHZhbHVlIGFmdGVyIHRoZSBCUklOIHJhbmdlPyAq LworCQkJCQkJCXZhbCA9IGVsZW1fdmFsdWVzWzBdOworCisJCQkJCQkJZmluZm8gPSBtaW5t YXhfbXVsdGlfZ2V0X3N0cmF0ZWd5X3Byb2NpbmZvKGJkZXNjLCBhdHRubywgc3VidHlwZSwK KwkJCQkJCQkJCQkJCQkJCQkJICAgQlRMZXNzRXF1YWxTdHJhdGVneU51bWJlcik7CisJCQkJ CQkJbWF0Y2hlcyA9IEZ1bmN0aW9uQ2FsbDJDb2xsKGZpbmZvLCBjb2xsb2lkLCB2YWwsIG1h eHZhbCk7CisKKwkJCQkJCQkvKiBtaW52YWwgPiBtYXgocmFuZ2UgdmFsdWVzKSAqLworCQkJ CQkJCWlmICghRGF0dW1HZXRCb29sKG1hdGNoZXMpKQorCQkJCQkJCQlicmVhazsKKworCQkJ CQkJCS8qIElzIHRoZSBsYXN0IChsYXJnZXN0KSB2YWx1ZSBiZWZvcmUgdGhlIEJSSU4gcmFu Z2U/ICovCisJCQkJCQkJdmFsID0gZWxlbV92YWx1ZXNbbnVtX2VsZW1zLTFdOworCisJCQkJ CQkJZmluZm8gPSBtaW5tYXhfbXVsdGlfZ2V0X3N0cmF0ZWd5X3Byb2NpbmZvKGJkZXNjLCBh dHRubywgc3VidHlwZSwKKwkJCQkJCQkJCQkJCQkJCQkJICAgQlRHcmVhdGVyRXF1YWxTdHJh dGVneU51bWJlcik7CisJCQkJCQkJbWF0Y2hlcyA9IEZ1bmN0aW9uQ2FsbDJDb2xsKGZpbmZv LCBjb2xsb2lkLCB2YWwsIG1pbnZhbCk7CisKKwkJCQkJCQkvKiBtYXh2YWwgPCBtaW4ocmFu Z2UgdmFsdWVzKSAqLworCQkJCQkJCWlmICghRGF0dW1HZXRCb29sKG1hdGNoZXMpKQorCQkJ CQkJCQlicmVhazsKKworCQkJCQkJCS8qCisJCQkJCQkJICogT0ssIHRoZXJlIG1pZ2h0IGJl IHNvbWUgdmFsdWVzIG1hdGNoaW5nIHRoZSByYW5nZS4gV2UgaGF2ZQorCQkJCQkJCSAqIHRv IHNlYXJjaCB0aGVtIG9uZSBieSBvbmUsIG9yIHBlcmhhcHMgdHJ5IGJpbnNlYXJjaC4KKwkJ CQkJCQkgKi8KKwkJCQkJCQl0eXBlID0gbG9va3VwX3R5cGVfY2FjaGUoQVJSX0VMRU1UWVBF KGFycmF5dmFsKSwgVFlQRUNBQ0hFX0xUX09QUik7CisKKwkJCQkJCQltZW1zZXQoJnNzdXAs IDAsIHNpemVvZihTb3J0U3VwcG9ydERhdGEpKTsKKwkJCQkJCQlQcmVwYXJlU29ydFN1cHBv cnRGcm9tT3JkZXJpbmdPcCh0eXBlLT5sdF9vcHIsICZzc3VwKTsKKworCQkJCQkJCWxvd2Vy ID0gbG93ZXJfYm91bmRhcnkoZWxlbV92YWx1ZXMsIG51bV9lbGVtcywgbWludmFsLCAmc3N1 cCk7CisKKwkJCQkJCQkvKiBubyBlbGVtZW50cyBjYW4gcG9zc2libHkgbWF0Y2ggKi8KKwkJ CQkJCQlpZiAobG93ZXIgPT0gbnVtX2VsZW1zKQorCQkJCQkJCXsKKwkJCQkJCQkJbWF0Y2hl cyA9IEJvb2xHZXREYXR1bShmYWxzZSk7CisJCQkJCQkJCWJyZWFrOworCQkJCQkJCX0KKwor CQkJCQkJCS8qCisJCQkJCQkJICogT0ssIHRoZSBmaXJzdCBlbGVtZW50IG11c3QgbWF0Y2gg dGhlIHVwcGVyIGJvdW5kYXJ5IHRvbworCQkJCQkJCSAqIChpZiBpdCBkb2VzIG5vdCwgbm8g Zm9sbG93aW5nIGVsZW1lbnRzIGNhbikuCisJCQkJCQkJICovCisJCQkJCQkJdmFsID0gZWxl bV92YWx1ZXNbbG93ZXJdOworCisJCQkJCQkJLyoKKwkJCQkJCQkgKiBJbiB0aGUgZXF1YWxp dHkgY2FzZSAoV0hFUkUgY29sID0gc29tZXZhbCksIHdlIHdhbnQgdG8gcmV0dXJuCisJCQkJ CQkJICogdGhlIGN1cnJlbnQgcGFnZSByYW5nZSBpZiB0aGUgbWluaW11bSB2YWx1ZSBpbiB0 aGUgcmFuZ2UgPD0KKwkJCQkJCQkgKiBzY2FuIGtleSwgYW5kIHRoZSBtYXhpbXVtIHZhbHVl ID49IHNjYW4ga2V5LgorCQkJCQkJCSAqLworCQkJCQkJCWZpbmZvID0gbWlubWF4X211bHRp X2dldF9zdHJhdGVneV9wcm9jaW5mbyhiZGVzYywgYXR0bm8sIHN1YnR5cGUsCisJCQkJCQkJ CQkJCQkJCQkJCSAgIEJUTGVzc0VxdWFsU3RyYXRlZ3lOdW1iZXIpOworCQkJCQkJCW1hdGNo ZXMgPSBGdW5jdGlvbkNhbGwyQ29sbChmaW5mbywgY29sbG9pZCwgbWludmFsLCB2YWwpOwor CQkJCQkJCWlmICghRGF0dW1HZXRCb29sKG1hdGNoZXMpKQorCQkJCQkJCQlicmVhazsKKwkJ CQkJCQkvKiBtYXgoKSA+PSBzY2Fua2V5ICovCisJCQkJCQkJZmluZm8gPSBtaW5tYXhfbXVs dGlfZ2V0X3N0cmF0ZWd5X3Byb2NpbmZvKGJkZXNjLCBhdHRubywgc3VidHlwZSwKKwkJCQkJ CQkJCQkJCQkJCQkJICAgQlRHcmVhdGVyRXF1YWxTdHJhdGVneU51bWJlcik7CisJCQkJCQkJ bWF0Y2hlcyA9IEZ1bmN0aW9uQ2FsbDJDb2xsKGZpbmZvLCBjb2xsb2lkLCBtYXh2YWwsIHZh bCk7CisJCQkJCQkJYnJlYWs7CisJCQkJCQl9CisJCQkJCWNhc2UgQlRHcmVhdGVyRXF1YWxT dHJhdGVneU51bWJlcjoKKwkJCQkJY2FzZSBCVEdyZWF0ZXJTdHJhdGVneU51bWJlcjoKKwkJ CQkJCWZpbmZvID0gbWlubWF4X211bHRpX2dldF9zdHJhdGVneV9wcm9jaW5mbyhiZGVzYywg YXR0bm8sIHN1YnR5cGUsCisJCQkJCQkJCQkJCQkJCQkJICAga2V5LT5za19zdHJhdGVneSk7 CisJCQkJCQkvKiBsYXN0IHZhbHVlIGZyb20gdGhlIGFycmF5ICovCisJCQkJCQltYXRjaGVz ID0gRnVuY3Rpb25DYWxsMkNvbGwoZmluZm8sIGNvbGxvaWQsIG1heHZhbCwKKwkJCQkJCQkJ CQkJCQllbGVtX3ZhbHVlc1swXSk7CiAJCQkJCQlicmVhazsKLQkJCQkJfQotCQkJCWNhc2Ug QlRHcmVhdGVyRXF1YWxTdHJhdGVneU51bWJlcjoKLQkJCQljYXNlIEJUR3JlYXRlclN0cmF0 ZWd5TnVtYmVyOgotCQkJCQlmaW5mbyA9IG1pbm1heF9tdWx0aV9nZXRfc3RyYXRlZ3lfcHJv Y2luZm8oYmRlc2MsIGF0dG5vLCBzdWJ0eXBlLAotCQkJCQkJCQkJCQkJCQkJICAga2V5LT5z a19zdHJhdGVneSk7Ci0JCQkJCS8qIGxhc3QgdmFsdWUgZnJvbSB0aGUgYXJyYXkgKi8KLQkJ CQkJbWF0Y2hlcyA9IEZ1bmN0aW9uQ2FsbDJDb2xsKGZpbmZvLCBjb2xsb2lkLCBtYXh2YWws IHZhbHVlKTsKLQkJCQkJYnJlYWs7CiAKLQkJCQlkZWZhdWx0OgotCQkJCQkvKiBzaG91bGRu J3QgaGFwcGVuICovCi0JCQkJCWVsb2coRVJST1IsICJpbnZhbGlkIHN0cmF0ZWd5IG51bWJl ciAlZCIsIGtleS0+c2tfc3RyYXRlZ3kpOwotCQkJCQltYXRjaGVzID0gMDsKLQkJCQkJYnJl YWs7CisJCQkJCWRlZmF1bHQ6CisJCQkJCQkvKiBzaG91bGRuJ3QgaGFwcGVuICovCisJCQkJ CQllbG9nKEVSUk9SLCAiaW52YWxpZCBzdHJhdGVneSBudW1iZXIgJWQiLCBrZXktPnNrX3N0 cmF0ZWd5KTsKKwkJCQkJCW1hdGNoZXMgPSAwOworCQkJCQkJYnJlYWs7CisJCQkJfQogCQkJ fQogCiAJCQkvKiB0aGUgcmFuZ2UgaGFzIHRvIG1hdGNoIGFsbCB0aGUgc2NhbiBrZXlzICov CkBAIC0yNzEzLDI4ICsyOTE3LDgwIEBAIGJyaW5fbWlubWF4X211bHRpX2NvbnNpc3RlbnQo UEdfRlVOQ1RJT05fQVJHUykKIAkJCWF0dG5vID0ga2V5LT5za19hdHRubzsKIAkJCXN1YnR5 cGUgPSBrZXktPnNrX3N1YnR5cGU7CiAJCQl2YWx1ZSA9IGtleS0+c2tfYXJndW1lbnQ7Ci0J CQlzd2l0Y2ggKGtleS0+c2tfc3RyYXRlZ3kpCisJCQlpZiAobGlrZWx5KCEoa2V5LT5za19m bGFncyAmIFNLX1NFQVJDSEFSUkFZKSkpCiAJCQl7Ci0JCQkJY2FzZSBCVExlc3NTdHJhdGVn eU51bWJlcjoKLQkJCQljYXNlIEJUTGVzc0VxdWFsU3RyYXRlZ3lOdW1iZXI6Ci0JCQkJY2Fz ZSBCVEVxdWFsU3RyYXRlZ3lOdW1iZXI6Ci0JCQkJY2FzZSBCVEdyZWF0ZXJFcXVhbFN0cmF0 ZWd5TnVtYmVyOgotCQkJCWNhc2UgQlRHcmVhdGVyU3RyYXRlZ3lOdW1iZXI6Ci0KLQkJCQkJ ZmluZm8gPSBtaW5tYXhfbXVsdGlfZ2V0X3N0cmF0ZWd5X3Byb2NpbmZvKGJkZXNjLCBhdHRu bywgc3VidHlwZSwKLQkJCQkJCQkJCQkJCQkJCSAgIGtleS0+c2tfc3RyYXRlZ3kpOwotCQkJ CQltYXRjaGVzID0gRnVuY3Rpb25DYWxsMkNvbGwoZmluZm8sIGNvbGxvaWQsIHZhbCwgdmFs dWUpOwotCQkJCQlicmVhazsKKwkJCQlzd2l0Y2ggKGtleS0+c2tfc3RyYXRlZ3kpCisJCQkJ eworCQkJCQljYXNlIEJUTGVzc1N0cmF0ZWd5TnVtYmVyOgorCQkJCQljYXNlIEJUTGVzc0Vx dWFsU3RyYXRlZ3lOdW1iZXI6CisJCQkJCWNhc2UgQlRFcXVhbFN0cmF0ZWd5TnVtYmVyOgor CQkJCQljYXNlIEJUR3JlYXRlckVxdWFsU3RyYXRlZ3lOdW1iZXI6CisJCQkJCWNhc2UgQlRH cmVhdGVyU3RyYXRlZ3lOdW1iZXI6CisKKwkJCQkJCWZpbmZvID0gbWlubWF4X211bHRpX2dl dF9zdHJhdGVneV9wcm9jaW5mbyhiZGVzYywgYXR0bm8sIHN1YnR5cGUsCisJCQkJCQkJCQkJ CQkJCQkJICAga2V5LT5za19zdHJhdGVneSk7CisJCQkJCQltYXRjaGVzID0gRnVuY3Rpb25D YWxsMkNvbGwoZmluZm8sIGNvbGxvaWQsIHZhbCwgdmFsdWUpOworCQkJCQkJYnJlYWs7CiAK LQkJCQlkZWZhdWx0OgotCQkJCQkvKiBzaG91bGRuJ3QgaGFwcGVuICovCi0JCQkJCWVsb2co RVJST1IsICJpbnZhbGlkIHN0cmF0ZWd5IG51bWJlciAlZCIsIGtleS0+c2tfc3RyYXRlZ3kp OwotCQkJCQltYXRjaGVzID0gMDsKLQkJCQkJYnJlYWs7CisJCQkJCWRlZmF1bHQ6CisJCQkJ CQkvKiBzaG91bGRuJ3QgaGFwcGVuICovCisJCQkJCQllbG9nKEVSUk9SLCAiaW52YWxpZCBz dHJhdGVneSBudW1iZXIgJWQiLCBrZXktPnNrX3N0cmF0ZWd5KTsKKwkJCQkJCW1hdGNoZXMg PSAwOworCQkJCQkJYnJlYWs7CisJCQkJfQorCQkJfQorCQkJZWxzZQorCQkJeworCQkJCS8q CisJCQkJICogRklYTUUgVGhpcyBpcyByZWFsbHkgd3JvbmcsIGJlY2F1c2UgaXQgZGVzZXJp YWxpemVzIHRoZQorCQkJCSAqIGFycmF5IG92ZXIgYW5kIG92ZXIgZm9yIGVhY2ggdmFsdWUg aW4gdGhlIG1pbm1heC1tdWx0aQorCQkJCSAqIHN1bW1hcnkuCisJCQkJICovCisJCQkJQXJy YXlUeXBlICAqYXJyYXl2YWw7CisJCQkJaW50MTYJCWVsbWxlbjsKKwkJCQlib29sCQllbG1i eXZhbDsKKwkJCQljaGFyCQllbG1hbGlnbjsKKwkJCQlpbnQJCQludW1fZWxlbXM7CisJCQkJ RGF0dW0JICAgKmVsZW1fdmFsdWVzOworCQkJCWJvb2wJICAgKmVsZW1fbnVsbHM7CisKKwkJ CQlTb3J0U3VwcG9ydERhdGEgc3N1cDsKKwkJCQlpbnQJCQlsb3dlcjsKKwkJCQlUeXBlQ2Fj aGVFbnRyeSAqdHlwZTsKKworCQkJCWFycmF5dmFsID0gRGF0dW1HZXRBcnJheVR5cGVQKGtl eS0+c2tfYXJndW1lbnQpOworCisJCQkJZ2V0X3R5cGxlbmJ5dmFsYWxpZ24oQVJSX0VMRU1U WVBFKGFycmF5dmFsKSwKKwkJCQkJCQkJCSAmZWxtbGVuLCAmZWxtYnl2YWwsICZlbG1hbGln bik7CisKKwkJCQlkZWNvbnN0cnVjdF9hcnJheShhcnJheXZhbCwKKwkJCQkJCQkJICBBUlJf RUxFTVRZUEUoYXJyYXl2YWwpLAorCQkJCQkJCQkgIGVsbWxlbiwgZWxtYnl2YWwsIGVsbWFs aWduLAorCQkJCQkJCQkgICZlbGVtX3ZhbHVlcywgJmVsZW1fbnVsbHMsICZudW1fZWxlbXMp OworCisJCQkJLyogYXNzdW1lIG5vdCBtYWNoZXMgKi8KKwkJCQltYXRjaGVzID0gZmFsc2U7 CisKKwkJCQkvKgorCQkJCSAqIE9LLCB0aGVyZSBtaWdodCBiZSBzb21lIHZhbHVlcyBtYXRj aGluZyB0aGUgcmFuZ2UuIFdlIGhhdmUKKwkJCQkgKiB0byBzZWFyY2ggdGhlbSBvbmUgYnkg b25lLCBvciBwZXJoYXBzIHRyeSBiaW5zZWFyY2guCisJCQkJICovCisJCQkJdHlwZSA9IGxv b2t1cF90eXBlX2NhY2hlKEFSUl9FTEVNVFlQRShhcnJheXZhbCksIFRZUEVDQUNIRV9MVF9P UFIpOworCisJCQkJbWVtc2V0KCZzc3VwLCAwLCBzaXplb2YoU29ydFN1cHBvcnREYXRhKSk7 CisJCQkJUHJlcGFyZVNvcnRTdXBwb3J0RnJvbU9yZGVyaW5nT3AodHlwZS0+bHRfb3ByLCAm c3N1cCk7CisKKwkJCQlsb3dlciA9IGxvd2VyX2JvdW5kYXJ5KGVsZW1fdmFsdWVzLCBudW1f ZWxlbXMsIHZhbHVlLCAmc3N1cCk7CisKKwkJCQlpZiAoKGxvd2VyIDwgbnVtX2VsZW1zKSAm JgorCQkJCQkoY29tcGFyZV9hcnJheV92YWx1ZXMoJmVsZW1fdmFsdWVzW2xvd2VyXSwgJnZh bHVlLCAmc3N1cCkgPT0gMCkpCisJCQkJeworCQkJCQltYXRjaGVzID0gdHJ1ZTsKKwkJCQl9 CiAJCQl9CiAKIAkJCS8qIHRoZSByYW5nZSBoYXMgdG8gbWF0Y2ggYWxsIHRoZSBzY2FuIGtl eXMgKi8KLQkJCW1hdGNoaW5nICY9IERhdHVtR2V0Qm9vbChtYXRjaGVzKTsKKwkJCW1hdGNo aW5nICY9IG1hdGNoZXM7CiAKIAkJCS8qIG9uY2Ugd2UgZmluZCBhIG5vbi1tYXRjaGluZyBr ZXksIHdlJ3JlIGRvbmUgKi8KIAkJCWlmICghbWF0Y2hpbmcpCi0tIAoyLjM5LjEKCg== --------------vUwxfMJd601J0Yjedx8IQ3Mp Content-Type: text/x-patch; charset=UTF-8; name="0004-Support-SK_SEARCHARRAY-in-BRIN-inclusion-20230213.patch" Content-Disposition: attachment; filename*0="0004-Support-SK_SEARCHARRAY-in-BRIN-inclusion-20230213.patch" Content-Transfer-Encoding: base64 RnJvbSBmOWQ1YWVlMDcwZWVmNTRkNTg5OGQ0ZWU3ODYyZDc5MDBhYTU5MjA5IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb21hcyBWb25kcmEgPHRvbWFzLnZvbmRyYUBwb3N0 Z3Jlc3FsLm9yZz4KRGF0ZTogU2F0LCAxMSBGZWIgMjAyMyAxNToyMzoyNSArMDEwMApTdWJq ZWN0OiBbUEFUQ0ggNC82XSBTdXBwb3J0IFNLX1NFQVJDSEFSUkFZIGluIEJSSU4gaW5jbHVz aW9uCgotLS0KIHNyYy9iYWNrZW5kL2FjY2Vzcy9icmluL2JyaW5faW5jbHVzaW9uLmMgfCAx NzcgKysrKysrKysrKysrKysrKy0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCAxMjMgaW5zZXJ0 aW9ucygrKSwgNTQgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvYWNj ZXNzL2JyaW4vYnJpbl9pbmNsdXNpb24uYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9icmluL2Jy aW5faW5jbHVzaW9uLmMKaW5kZXggMjQ4MTE2YzE0OS4uOTM1NDUyZDA5ZCAxMDA2NDQKLS0t IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2JyaW4vYnJpbl9pbmNsdXNpb24uYworKysgYi9zcmMv YmFja2VuZC9hY2Nlc3MvYnJpbi9icmluX2luY2x1c2lvbi5jCkBAIC0zMCw2ICszMCw3IEBA CiAjaW5jbHVkZSAiYWNjZXNzL3NrZXkuaCIKICNpbmNsdWRlICJjYXRhbG9nL3BnX2Ftb3Au aCIKICNpbmNsdWRlICJjYXRhbG9nL3BnX3R5cGUuaCIKKyNpbmNsdWRlICJ1dGlscy9hcnJh eS5oIgogI2luY2x1ZGUgInV0aWxzL2J1aWx0aW5zLmgiCiAjaW5jbHVkZSAidXRpbHMvZGF0 dW0uaCIKICNpbmNsdWRlICJ1dGlscy9sc3lzY2FjaGUuaCIKQEAgLTIzOSw0MyArMjQwLDIw IEBAIGJyaW5faW5jbHVzaW9uX2FkZF92YWx1ZShQR19GVU5DVElPTl9BUkdTKQogfQogCiAv KgotICogQlJJTiBpbmNsdXNpb24gY29uc2lzdGVudCBmdW5jdGlvbgotICoKLSAqIFdlJ3Jl IG5vIGxvbmdlciBkZWFsaW5nIHdpdGggTlVMTCBrZXlzIGluIHRoZSBjb25zaXN0ZW50IGZ1 bmN0aW9uLCB0aGF0IGlzCi0gKiBub3cgaGFuZGxlZCBieSB0aGUgQU0gY29kZS4gVGhhdCBt ZWFucyB3ZSBzaG91bGQgbm90IGdldCBhbnkgYWxsLU5VTEwgcmFuZ2VzCi0gKiBlaXRoZXIs IGJlY2F1c2UgdGhvc2UgY2FuJ3QgYmUgY29uc2lzdGVudCB3aXRoIHJlZ3VsYXIgKG5vdCBb SVNdIE5VTEwpIGtleXMuCisgKiBDaGVjayBjb25zaXN0ZW5jeSBvZiBhIHNpbmdsZSBzY2Fs YXIgdmFsdWUgd2l0aCB0aGUgQlJJTiByYW5nZS4KICAqCi0gKiBBbGwgb2YgdGhlIHN0cmF0 ZWdpZXMgYXJlIG9wdGlvbmFsLgorICogQ2FsbGVkIGZvciBib3RoIHNjYWxhciBzY2Fua2V5 cyBhbmQgZm9yIGVhY2ggdmFsdWUgaW4gU0tfU0VBUkNIQVJSQVkuCiAgKi8KLURhdHVtCi1i cmluX2luY2x1c2lvbl9jb25zaXN0ZW50KFBHX0ZVTkNUSU9OX0FSR1MpCitzdGF0aWMgYm9v bAorYnJpbl9pbmNsdXNpb25fY29uc2lzdGVudF92YWx1ZShCcmluRGVzYyAqYmRlc2MsIEJy aW5WYWx1ZXMgKmNvbHVtbiwKKwkJCQkJCQkJQXR0ck51bWJlciBhdHRubywKKwkJCQkJCQkJ U3RyYXRlZ3lOdW1iZXIgc3RyYXRlZ3ksIE9pZCBzdWJ0eXBlLAorCQkJCQkJCQlPaWQgY29s bG9pZCwgRGF0dW0gdW5pb252YWwsIERhdHVtIHF1ZXJ5KQogewotCUJyaW5EZXNjICAgKmJk ZXNjID0gKEJyaW5EZXNjICopIFBHX0dFVEFSR19QT0lOVEVSKDApOwotCUJyaW5WYWx1ZXMg KmNvbHVtbiA9IChCcmluVmFsdWVzICopIFBHX0dFVEFSR19QT0lOVEVSKDEpOwotCVNjYW5L ZXkJCWtleSA9IChTY2FuS2V5KSBQR19HRVRBUkdfUE9JTlRFUigyKTsKLQlPaWQJCQljb2xs b2lkID0gUEdfR0VUX0NPTExBVElPTigpLAotCQkJCXN1YnR5cGU7Ci0JRGF0dW0JCXVuaW9u dmFsOwotCUF0dHJOdW1iZXIJYXR0bm87Ci0JRGF0dW0JCXF1ZXJ5OwogCUZtZ3JJbmZvICAg KmZpbmZvOwogCURhdHVtCQlyZXN1bHQ7CiAKLQkvKiBUaGlzIG9wY2xhc3MgdXNlcyB0aGUg b2xkIHNpZ25hdHVyZSB3aXRoIG9ubHkgdGhyZWUgYXJndW1lbnRzLiAqLwotCUFzc2VydChQ R19OQVJHUygpID09IDMpOwotCi0JLyogU2hvdWxkIG5vdCBiZSBkZWFsaW5nIHdpdGggYWxs LU5VTEwgcmFuZ2VzLiAqLwotCUFzc2VydCghY29sdW1uLT5idl9hbGxudWxscyk7Ci0KLQkv KiBJdCBoYXMgdG8gYmUgY2hlY2tlZCwgaWYgaXQgY29udGFpbnMgZWxlbWVudHMgdGhhdCBh cmUgbm90IG1lcmdlYWJsZS4gKi8KLQlpZiAoRGF0dW1HZXRCb29sKGNvbHVtbi0+YnZfdmFs dWVzW0lOQ0xVU0lPTl9VTk1FUkdFQUJMRV0pKQotCQlQR19SRVRVUk5fQk9PTCh0cnVlKTsK LQotCWF0dG5vID0ga2V5LT5za19hdHRubzsKLQlzdWJ0eXBlID0ga2V5LT5za19zdWJ0eXBl OwotCXF1ZXJ5ID0ga2V5LT5za19hcmd1bWVudDsKLQl1bmlvbnZhbCA9IGNvbHVtbi0+YnZf dmFsdWVzW0lOQ0xVU0lPTl9VTklPTl07Ci0Jc3dpdGNoIChrZXktPnNrX3N0cmF0ZWd5KQor CXN3aXRjaCAoc3RyYXRlZ3kpCiAJewogCQkJLyoKIAkJCSAqIFBsYWNlbWVudCBzdHJhdGVn aWVzCkBAIC0yOTQsNDkgKzI3Miw0OSBAQCBicmluX2luY2x1c2lvbl9jb25zaXN0ZW50KFBH X0ZVTkNUSU9OX0FSR1MpCiAJCQlmaW5mbyA9IGluY2x1c2lvbl9nZXRfc3RyYXRlZ3lfcHJv Y2luZm8oYmRlc2MsIGF0dG5vLCBzdWJ0eXBlLAogCQkJCQkJCQkJCQkJCVJUT3ZlclJpZ2h0 U3RyYXRlZ3lOdW1iZXIpOwogCQkJcmVzdWx0ID0gRnVuY3Rpb25DYWxsMkNvbGwoZmluZm8s IGNvbGxvaWQsIHVuaW9udmFsLCBxdWVyeSk7Ci0JCQlQR19SRVRVUk5fQk9PTCghRGF0dW1H ZXRCb29sKHJlc3VsdCkpOworCQkJcmV0dXJuICghRGF0dW1HZXRCb29sKHJlc3VsdCkpOwog CiAJCWNhc2UgUlRPdmVyTGVmdFN0cmF0ZWd5TnVtYmVyOgogCQkJZmluZm8gPSBpbmNsdXNp b25fZ2V0X3N0cmF0ZWd5X3Byb2NpbmZvKGJkZXNjLCBhdHRubywgc3VidHlwZSwKIAkJCQkJ CQkJCQkJCQlSVFJpZ2h0U3RyYXRlZ3lOdW1iZXIpOwogCQkJcmVzdWx0ID0gRnVuY3Rpb25D YWxsMkNvbGwoZmluZm8sIGNvbGxvaWQsIHVuaW9udmFsLCBxdWVyeSk7Ci0JCQlQR19SRVRV Uk5fQk9PTCghRGF0dW1HZXRCb29sKHJlc3VsdCkpOworCQkJcmV0dXJuICghRGF0dW1HZXRC b29sKHJlc3VsdCkpOwogCiAJCWNhc2UgUlRPdmVyUmlnaHRTdHJhdGVneU51bWJlcjoKIAkJ CWZpbmZvID0gaW5jbHVzaW9uX2dldF9zdHJhdGVneV9wcm9jaW5mbyhiZGVzYywgYXR0bm8s IHN1YnR5cGUsCiAJCQkJCQkJCQkJCQkJUlRMZWZ0U3RyYXRlZ3lOdW1iZXIpOwogCQkJcmVz dWx0ID0gRnVuY3Rpb25DYWxsMkNvbGwoZmluZm8sIGNvbGxvaWQsIHVuaW9udmFsLCBxdWVy eSk7Ci0JCQlQR19SRVRVUk5fQk9PTCghRGF0dW1HZXRCb29sKHJlc3VsdCkpOworCQkJcmV0 dXJuICghRGF0dW1HZXRCb29sKHJlc3VsdCkpOwogCiAJCWNhc2UgUlRSaWdodFN0cmF0ZWd5 TnVtYmVyOgogCQkJZmluZm8gPSBpbmNsdXNpb25fZ2V0X3N0cmF0ZWd5X3Byb2NpbmZvKGJk ZXNjLCBhdHRubywgc3VidHlwZSwKIAkJCQkJCQkJCQkJCQlSVE92ZXJMZWZ0U3RyYXRlZ3lO dW1iZXIpOwogCQkJcmVzdWx0ID0gRnVuY3Rpb25DYWxsMkNvbGwoZmluZm8sIGNvbGxvaWQs IHVuaW9udmFsLCBxdWVyeSk7Ci0JCQlQR19SRVRVUk5fQk9PTCghRGF0dW1HZXRCb29sKHJl c3VsdCkpOworCQkJcmV0dXJuICghRGF0dW1HZXRCb29sKHJlc3VsdCkpOwogCiAJCWNhc2Ug UlRCZWxvd1N0cmF0ZWd5TnVtYmVyOgogCQkJZmluZm8gPSBpbmNsdXNpb25fZ2V0X3N0cmF0 ZWd5X3Byb2NpbmZvKGJkZXNjLCBhdHRubywgc3VidHlwZSwKIAkJCQkJCQkJCQkJCQlSVE92 ZXJBYm92ZVN0cmF0ZWd5TnVtYmVyKTsKIAkJCXJlc3VsdCA9IEZ1bmN0aW9uQ2FsbDJDb2xs KGZpbmZvLCBjb2xsb2lkLCB1bmlvbnZhbCwgcXVlcnkpOwotCQkJUEdfUkVUVVJOX0JPT0wo IURhdHVtR2V0Qm9vbChyZXN1bHQpKTsKKwkJCXJldHVybiAoIURhdHVtR2V0Qm9vbChyZXN1 bHQpKTsKIAogCQljYXNlIFJUT3ZlckJlbG93U3RyYXRlZ3lOdW1iZXI6CiAJCQlmaW5mbyA9 IGluY2x1c2lvbl9nZXRfc3RyYXRlZ3lfcHJvY2luZm8oYmRlc2MsIGF0dG5vLCBzdWJ0eXBl LAogCQkJCQkJCQkJCQkJCVJUQWJvdmVTdHJhdGVneU51bWJlcik7CiAJCQlyZXN1bHQgPSBG dW5jdGlvbkNhbGwyQ29sbChmaW5mbywgY29sbG9pZCwgdW5pb252YWwsIHF1ZXJ5KTsKLQkJ CVBHX1JFVFVSTl9CT09MKCFEYXR1bUdldEJvb2wocmVzdWx0KSk7CisJCQlyZXR1cm4gKCFE YXR1bUdldEJvb2wocmVzdWx0KSk7CiAKIAkJY2FzZSBSVE92ZXJBYm92ZVN0cmF0ZWd5TnVt YmVyOgogCQkJZmluZm8gPSBpbmNsdXNpb25fZ2V0X3N0cmF0ZWd5X3Byb2NpbmZvKGJkZXNj LCBhdHRubywgc3VidHlwZSwKIAkJCQkJCQkJCQkJCQlSVEJlbG93U3RyYXRlZ3lOdW1iZXIp OwogCQkJcmVzdWx0ID0gRnVuY3Rpb25DYWxsMkNvbGwoZmluZm8sIGNvbGxvaWQsIHVuaW9u dmFsLCBxdWVyeSk7Ci0JCQlQR19SRVRVUk5fQk9PTCghRGF0dW1HZXRCb29sKHJlc3VsdCkp OworCQkJcmV0dXJuICghRGF0dW1HZXRCb29sKHJlc3VsdCkpOwogCiAJCWNhc2UgUlRBYm92 ZVN0cmF0ZWd5TnVtYmVyOgogCQkJZmluZm8gPSBpbmNsdXNpb25fZ2V0X3N0cmF0ZWd5X3By b2NpbmZvKGJkZXNjLCBhdHRubywgc3VidHlwZSwKIAkJCQkJCQkJCQkJCQlSVE92ZXJCZWxv d1N0cmF0ZWd5TnVtYmVyKTsKIAkJCXJlc3VsdCA9IEZ1bmN0aW9uQ2FsbDJDb2xsKGZpbmZv LCBjb2xsb2lkLCB1bmlvbnZhbCwgcXVlcnkpOwotCQkJUEdfUkVUVVJOX0JPT0woIURhdHVt R2V0Qm9vbChyZXN1bHQpKTsKKwkJCXJldHVybiAoIURhdHVtR2V0Qm9vbChyZXN1bHQpKTsK IAogCQkJLyoKIAkJCSAqIE92ZXJsYXAgYW5kIGNvbnRhaW5zIHN0cmF0ZWdpZXMKQEAgLTM1 Miw5ICszMzAsOSBAQCBicmluX2luY2x1c2lvbl9jb25zaXN0ZW50KFBHX0ZVTkNUSU9OX0FS R1MpCiAJCWNhc2UgUlRTdWJTdHJhdGVneU51bWJlcjoKIAkJY2FzZSBSVFN1YkVxdWFsU3Ry YXRlZ3lOdW1iZXI6CiAJCQlmaW5mbyA9IGluY2x1c2lvbl9nZXRfc3RyYXRlZ3lfcHJvY2lu Zm8oYmRlc2MsIGF0dG5vLCBzdWJ0eXBlLAotCQkJCQkJCQkJCQkJCWtleS0+c2tfc3RyYXRl Z3kpOworCQkJCQkJCQkJCQkJCXN0cmF0ZWd5KTsKIAkJCXJlc3VsdCA9IEZ1bmN0aW9uQ2Fs bDJDb2xsKGZpbmZvLCBjb2xsb2lkLCB1bmlvbnZhbCwgcXVlcnkpOwotCQkJUEdfUkVUVVJO X0RBVFVNKHJlc3VsdCk7CisJCQlyZXR1cm4gKERhdHVtR2V0Qm9vbChyZXN1bHQpKTsKIAog CQkJLyoKIAkJCSAqIENvbnRhaW5lZCBieSBzdHJhdGVnaWVzCkBAIC0zNzQsOSArMzUyLDkg QEAgYnJpbl9pbmNsdXNpb25fY29uc2lzdGVudChQR19GVU5DVElPTl9BUkdTKQogCQkJCQkJ CQkJCQkJCVJUT3ZlcmxhcFN0cmF0ZWd5TnVtYmVyKTsKIAkJCXJlc3VsdCA9IEZ1bmN0aW9u Q2FsbDJDb2xsKGZpbmZvLCBjb2xsb2lkLCB1bmlvbnZhbCwgcXVlcnkpOwogCQkJaWYgKERh dHVtR2V0Qm9vbChyZXN1bHQpKQotCQkJCVBHX1JFVFVSTl9CT09MKHRydWUpOworCQkJCXJl dHVybiAodHJ1ZSk7CiAKLQkJCVBHX1JFVFVSTl9EQVRVTShjb2x1bW4tPmJ2X3ZhbHVlc1tJ TkNMVVNJT05fQ09OVEFJTlNfRU1QVFldKTsKKwkJCXJldHVybiAoY29sdW1uLT5idl92YWx1 ZXNbSU5DTFVTSU9OX0NPTlRBSU5TX0VNUFRZXSk7CiAKIAkJCS8qCiAJCQkgKiBBZGphY2Vu dCBzdHJhdGVneQpAQCAtMzkzLDEyICszNzEsMTIgQEAgYnJpbl9pbmNsdXNpb25fY29uc2lz dGVudChQR19GVU5DVElPTl9BUkdTKQogCQkJCQkJCQkJCQkJCVJUT3ZlcmxhcFN0cmF0ZWd5 TnVtYmVyKTsKIAkJCXJlc3VsdCA9IEZ1bmN0aW9uQ2FsbDJDb2xsKGZpbmZvLCBjb2xsb2lk LCB1bmlvbnZhbCwgcXVlcnkpOwogCQkJaWYgKERhdHVtR2V0Qm9vbChyZXN1bHQpKQotCQkJ CVBHX1JFVFVSTl9CT09MKHRydWUpOworCQkJCXJldHVybiAodHJ1ZSk7CiAKIAkJCWZpbmZv ID0gaW5jbHVzaW9uX2dldF9zdHJhdGVneV9wcm9jaW5mbyhiZGVzYywgYXR0bm8sIHN1YnR5 cGUsCiAJCQkJCQkJCQkJCQkJUlRBZGphY2VudFN0cmF0ZWd5TnVtYmVyKTsKIAkJCXJlc3Vs dCA9IEZ1bmN0aW9uQ2FsbDJDb2xsKGZpbmZvLCBjb2xsb2lkLCB1bmlvbnZhbCwgcXVlcnkp OwotCQkJUEdfUkVUVVJOX0RBVFVNKHJlc3VsdCk7CisJCQlyZXR1cm4gKERhdHVtR2V0Qm9v bChyZXN1bHQpKTsKIAogCQkJLyoKIAkJCSAqIEJhc2ljIGNvbXBhcmlzb24gc3RyYXRlZ2ll cwpAQCAtNDI4LDkgKzQwNiw5IEBAIGJyaW5faW5jbHVzaW9uX2NvbnNpc3RlbnQoUEdfRlVO Q1RJT05fQVJHUykKIAkJCQkJCQkJCQkJCQlSVFJpZ2h0U3RyYXRlZ3lOdW1iZXIpOwogCQkJ cmVzdWx0ID0gRnVuY3Rpb25DYWxsMkNvbGwoZmluZm8sIGNvbGxvaWQsIHVuaW9udmFsLCBx dWVyeSk7CiAJCQlpZiAoIURhdHVtR2V0Qm9vbChyZXN1bHQpKQotCQkJCVBHX1JFVFVSTl9C T09MKHRydWUpOworCQkJCXJldHVybiAodHJ1ZSk7CiAKLQkJCVBHX1JFVFVSTl9EQVRVTShj b2x1bW4tPmJ2X3ZhbHVlc1tJTkNMVVNJT05fQ09OVEFJTlNfRU1QVFldKTsKKwkJCXJldHVy biAoY29sdW1uLT5idl92YWx1ZXNbSU5DTFVTSU9OX0NPTlRBSU5TX0VNUFRZXSk7CiAKIAkJ Y2FzZSBSVFNhbWVTdHJhdGVneU51bWJlcjoKIAkJY2FzZSBSVEVxdWFsU3RyYXRlZ3lOdW1i ZXI6CkBAIC00MzgsMzAgKzQxNiwxMjEgQEAgYnJpbl9pbmNsdXNpb25fY29uc2lzdGVudChQ R19GVU5DVElPTl9BUkdTKQogCQkJCQkJCQkJCQkJCVJUQ29udGFpbnNTdHJhdGVneU51bWJl cik7CiAJCQlyZXN1bHQgPSBGdW5jdGlvbkNhbGwyQ29sbChmaW5mbywgY29sbG9pZCwgdW5p b252YWwsIHF1ZXJ5KTsKIAkJCWlmIChEYXR1bUdldEJvb2wocmVzdWx0KSkKLQkJCQlQR19S RVRVUk5fQk9PTCh0cnVlKTsKKwkJCQlyZXR1cm4gKHRydWUpOwogCi0JCQlQR19SRVRVUk5f REFUVU0oY29sdW1uLT5idl92YWx1ZXNbSU5DTFVTSU9OX0NPTlRBSU5TX0VNUFRZXSk7CisJ CQlyZXR1cm4gKGNvbHVtbi0+YnZfdmFsdWVzW0lOQ0xVU0lPTl9DT05UQUlOU19FTVBUWV0p OwogCiAJCWNhc2UgUlRHcmVhdGVyRXF1YWxTdHJhdGVneU51bWJlcjoKIAkJCWZpbmZvID0g aW5jbHVzaW9uX2dldF9zdHJhdGVneV9wcm9jaW5mbyhiZGVzYywgYXR0bm8sIHN1YnR5cGUs CiAJCQkJCQkJCQkJCQkJUlRMZWZ0U3RyYXRlZ3lOdW1iZXIpOwogCQkJcmVzdWx0ID0gRnVu Y3Rpb25DYWxsMkNvbGwoZmluZm8sIGNvbGxvaWQsIHVuaW9udmFsLCBxdWVyeSk7CiAJCQlp ZiAoIURhdHVtR2V0Qm9vbChyZXN1bHQpKQotCQkJCVBHX1JFVFVSTl9CT09MKHRydWUpOwor CQkJCXJldHVybiAodHJ1ZSk7CiAKLQkJCVBHX1JFVFVSTl9EQVRVTShjb2x1bW4tPmJ2X3Zh bHVlc1tJTkNMVVNJT05fQ09OVEFJTlNfRU1QVFldKTsKKwkJCXJldHVybiAoY29sdW1uLT5i dl92YWx1ZXNbSU5DTFVTSU9OX0NPTlRBSU5TX0VNUFRZXSk7CiAKIAkJY2FzZSBSVEdyZWF0 ZXJTdHJhdGVneU51bWJlcjoKIAkJCS8qIG5vIG5lZWQgdG8gY2hlY2sgZm9yIGVtcHR5IGVs ZW1lbnRzICovCiAJCQlmaW5mbyA9IGluY2x1c2lvbl9nZXRfc3RyYXRlZ3lfcHJvY2luZm8o YmRlc2MsIGF0dG5vLCBzdWJ0eXBlLAogCQkJCQkJCQkJCQkJCVJUTGVmdFN0cmF0ZWd5TnVt YmVyKTsKIAkJCXJlc3VsdCA9IEZ1bmN0aW9uQ2FsbDJDb2xsKGZpbmZvLCBjb2xsb2lkLCB1 bmlvbnZhbCwgcXVlcnkpOwotCQkJUEdfUkVUVVJOX0JPT0woIURhdHVtR2V0Qm9vbChyZXN1 bHQpKTsKKwkJCXJldHVybiAoIURhdHVtR2V0Qm9vbChyZXN1bHQpKTsKIAogCQlkZWZhdWx0 OgogCQkJLyogc2hvdWxkbid0IGhhcHBlbiAqLwotCQkJZWxvZyhFUlJPUiwgImludmFsaWQg c3RyYXRlZ3kgbnVtYmVyICVkIiwga2V5LT5za19zdHJhdGVneSk7Ci0JCQlQR19SRVRVUk5f Qk9PTChmYWxzZSk7CisJCQllbG9nKEVSUk9SLCAiaW52YWxpZCBzdHJhdGVneSBudW1iZXIg JWQiLCBzdHJhdGVneSk7CisJCQlyZXR1cm4gKGZhbHNlKTsKKwl9Cit9CisKKy8qCisgKiBC UklOIGluY2x1c2lvbiBjb25zaXN0ZW50IGZ1bmN0aW9uCisgKgorICogV2UncmUgbm8gbG9u Z2VyIGRlYWxpbmcgd2l0aCBOVUxMIGtleXMgaW4gdGhlIGNvbnNpc3RlbnQgZnVuY3Rpb24s IHRoYXQgaXMKKyAqIG5vdyBoYW5kbGVkIGJ5IHRoZSBBTSBjb2RlLiBUaGF0IG1lYW5zIHdl IHNob3VsZCBub3QgZ2V0IGFueSBhbGwtTlVMTCByYW5nZXMKKyAqIGVpdGhlciwgYmVjYXVz ZSB0aG9zZSBjYW4ndCBiZSBjb25zaXN0ZW50IHdpdGggcmVndWxhciAobm90IFtJU10gTlVM TCkga2V5cy4KKyAqCisgKiBBbGwgb2YgdGhlIHN0cmF0ZWdpZXMgYXJlIG9wdGlvbmFsLgor ICovCitEYXR1bQorYnJpbl9pbmNsdXNpb25fY29uc2lzdGVudChQR19GVU5DVElPTl9BUkdT KQoreworCUJyaW5EZXNjICAgKmJkZXNjID0gKEJyaW5EZXNjICopIFBHX0dFVEFSR19QT0lO VEVSKDApOworCUJyaW5WYWx1ZXMgKmNvbHVtbiA9IChCcmluVmFsdWVzICopIFBHX0dFVEFS R19QT0lOVEVSKDEpOworCVNjYW5LZXkJCWtleSA9IChTY2FuS2V5KSBQR19HRVRBUkdfUE9J TlRFUigyKTsKKwlPaWQJCQljb2xsb2lkID0gUEdfR0VUX0NPTExBVElPTigpLAorCQkJCXN1 YnR5cGU7CisJRGF0dW0JCXVuaW9udmFsOworCUF0dHJOdW1iZXIJYXR0bm87CisJRGF0dW0J CXF1ZXJ5OworCisJLyogVGhpcyBvcGNsYXNzIHVzZXMgdGhlIG9sZCBzaWduYXR1cmUgd2l0 aCBvbmx5IHRocmVlIGFyZ3VtZW50cy4gKi8KKwlBc3NlcnQoUEdfTkFSR1MoKSA9PSAzKTsK KworCS8qIFNob3VsZCBub3QgYmUgZGVhbGluZyB3aXRoIGFsbC1OVUxMIHJhbmdlcy4gKi8K KwlBc3NlcnQoIWNvbHVtbi0+YnZfYWxsbnVsbHMpOworCisJLyogSXQgaGFzIHRvIGJlIGNo ZWNrZWQsIGlmIGl0IGNvbnRhaW5zIGVsZW1lbnRzIHRoYXQgYXJlIG5vdCBtZXJnZWFibGUu ICovCisJaWYgKERhdHVtR2V0Qm9vbChjb2x1bW4tPmJ2X3ZhbHVlc1tJTkNMVVNJT05fVU5N RVJHRUFCTEVdKSkKKwkJUEdfUkVUVVJOX0JPT0wodHJ1ZSk7CisKKwlhdHRubyA9IGtleS0+ c2tfYXR0bm87CisJc3VidHlwZSA9IGtleS0+c2tfc3VidHlwZTsKKwlxdWVyeSA9IGtleS0+ c2tfYXJndW1lbnQ7CisJdW5pb252YWwgPSBjb2x1bW4tPmJ2X3ZhbHVlc1tJTkNMVVNJT05f VU5JT05dOworCisJLyoKKwkgKiBGb3IgcmVndWxhciAoc2NhbGFyKSBzY2FuIGtleXMsIHdl IHNpbXBseSBjb21wYXJlIHRoZSB2YWx1ZSB0byB0aGUKKwkgKiByYW5nZSBtaW4vbWF4IHZh bHVlcywgYW5kIHdlJ3JlIGRvbmUuIEZvciBTS19TRUFSQ0hBUlJBWSBrZXlzIHdlCisJICog bmVlZCB0byBkZXBhcnNlIHRoZSBhcnJheSBhbmQgbG9vcCB0aHJvdWdoIHRoZSB2YWx1ZXMu CisJICovCisJaWYgKGxpa2VseSghKGtleS0+c2tfZmxhZ3MgJiBTS19TRUFSQ0hBUlJBWSkp KQorCXsKKwkJYm9vbCB0bXA7CisKKwkJdG1wID0gYnJpbl9pbmNsdXNpb25fY29uc2lzdGVu dF92YWx1ZShiZGVzYywgY29sdW1uLCBhdHRubywKKwkJCQkJCQkJCQkJICBrZXktPnNrX3N0 cmF0ZWd5LAorCQkJCQkJCQkJCQkgIHN1YnR5cGUsIGNvbGxvaWQsCisJCQkJCQkJCQkJCSAg dW5pb252YWwsIHF1ZXJ5KTsKKwkJUEdfUkVUVVJOX0JPT0wodG1wKTsKKwl9CisJZWxzZQor CXsKKwkJQXJyYXlUeXBlICAqYXJyYXl2YWw7CisJCWludDE2CQllbG1sZW47CisJCWJvb2wJ CWVsbWJ5dmFsOworCQljaGFyCQllbG1hbGlnbjsKKwkJaW50CQkJbnVtX2VsZW1zOworCQlE YXR1bQkgICAqZWxlbV92YWx1ZXM7CisJCWJvb2wJICAgKmVsZW1fbnVsbHM7CisJCWJvb2wJ CW1hdGNoZXMgPSBmYWxzZTsKKworCQlhcnJheXZhbCA9IERhdHVtR2V0QXJyYXlUeXBlUChr ZXktPnNrX2FyZ3VtZW50KTsKKworCQlnZXRfdHlwbGVuYnl2YWxhbGlnbihBUlJfRUxFTVRZ UEUoYXJyYXl2YWwpLAorCQkJCQkJCSAmZWxtbGVuLCAmZWxtYnl2YWwsICZlbG1hbGlnbik7 CisKKwkJZGVjb25zdHJ1Y3RfYXJyYXkoYXJyYXl2YWwsCisJCQkJCQkgIEFSUl9FTEVNVFlQ RShhcnJheXZhbCksCisJCQkJCQkgIGVsbWxlbiwgZWxtYnl2YWwsIGVsbWFsaWduLAorCQkJ CQkJICAmZWxlbV92YWx1ZXMsICZlbGVtX251bGxzLCAmbnVtX2VsZW1zKTsKKworCQkvKiBo YXZlIHRvIGxvb3AgdGhyb3VnaCBhbGwgZWxlbWVudHMsIGhhdmluZyB0aGVtIHNvcnRlZCBk b2VzIG5vdCBoZWxwICovCisJCWZvciAoaW50IGkgPSAwOyBpIDwgbnVtX2VsZW1zOyBpKysp CisJCXsKKwkJCURhdHVtIAlxdWVyeV9lbGVtZW50ID0gZWxlbV92YWx1ZXNbaV07CisKKwkJ CW1hdGNoZXMgPSBicmluX2luY2x1c2lvbl9jb25zaXN0ZW50X3ZhbHVlKGJkZXNjLCBjb2x1 bW4sIGF0dG5vLAorCQkJCQkJCQkJCQkJCSAga2V5LT5za19zdHJhdGVneSwKKwkJCQkJCQkJ CQkJCQkgIHN1YnR5cGUsIGNvbGxvaWQsCisJCQkJCQkJCQkJCQkJICB1bmlvbnZhbCwgcXVl cnlfZWxlbWVudCk7CisKKwkJCWlmIChtYXRjaGVzKQorCQkJCWJyZWFrOworCQl9CisKKwkJ Lyogd2UgY291bGQgZ2V0IGhlcmUgZm9yIGVtcHR5IGFycmF5LCBlLmcuIHdpdGggIkA+ICd7 fSc6OnBvaW50W10iICovCisJCVBHX1JFVFVSTl9CT09MKG1hdGNoZXMpOwogCX0KIH0KIAot LSAKMi4zOS4xCgo= --------------vUwxfMJd601J0Yjedx8IQ3Mp Content-Type: text/x-patch; charset=UTF-8; name="0005-Support-SK_SEARCHARRAY-in-BRIN-bloom-20230213.patch" Content-Disposition: attachment; filename="0005-Support-SK_SEARCHARRAY-in-BRIN-bloom-20230213.patch" Content-Transfer-Encoding: base64 RnJvbSBjNjdlMGQ5OTVkMWNmMWMxMDQyNzA5NzQ2MjQ4MzQ5NDBmYTVlZTE2IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb21hcyBWb25kcmEgPHRvbWFzLnZvbmRyYUBwb3N0 Z3Jlc3FsLm9yZz4KRGF0ZTogU2F0LCAxMSBGZWIgMjAyMyAyMDo1MDowMyArMDEwMApTdWJq ZWN0OiBbUEFUQ0ggNS82XSBTdXBwb3J0IFNLX1NFQVJDSEFSUkFZIGluIEJSSU4gYmxvb20K Ci0tLQogc3JjL2JhY2tlbmQvYWNjZXNzL2JyaW4vYnJpbl9ibG9vbS5jIHwgMTAwICsrKysr KysrKysrKysrKysrKysrKystLS0tLQogMSBmaWxlIGNoYW5nZWQsIDgxIGluc2VydGlvbnMo KyksIDE5IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9i cmluL2JyaW5fYmxvb20uYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9icmluL2JyaW5fYmxvb20u YwppbmRleCBlNDk1M2E5ZDM3Li5jMjkzOWFjODA5IDEwMDY0NAotLS0gYS9zcmMvYmFja2Vu ZC9hY2Nlc3MvYnJpbi9icmluX2Jsb29tLmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2Jy aW4vYnJpbl9ibG9vbS5jCkBAIC0xMjUsNiArMTI1LDcgQEAKICNpbmNsdWRlICJhY2Nlc3Mv c3RyYXRudW0uaCIKICNpbmNsdWRlICJjYXRhbG9nL3BnX3R5cGUuaCIKICNpbmNsdWRlICJj YXRhbG9nL3BnX2Ftb3AuaCIKKyNpbmNsdWRlICJ1dGlscy9hcnJheS5oIgogI2luY2x1ZGUg InV0aWxzL2J1aWx0aW5zLmgiCiAjaW5jbHVkZSAidXRpbHMvZGF0dW0uaCIKICNpbmNsdWRl ICJ1dGlscy9sc3lzY2FjaGUuaCIKQEAgLTU5NiwyNiArNTk3LDg3IEBAIGJyaW5fYmxvb21f Y29uc2lzdGVudChQR19GVU5DVElPTl9BUkdTKQogCQlhdHRubyA9IGtleS0+c2tfYXR0bm87 CiAJCXZhbHVlID0ga2V5LT5za19hcmd1bWVudDsKIAotCQlzd2l0Y2ggKGtleS0+c2tfc3Ry YXRlZ3kpCisJCWlmIChsaWtlbHkoIShrZXktPnNrX2ZsYWdzICYgU0tfU0VBUkNIQVJSQVkp KSkKIAkJewotCQkJY2FzZSBCbG9vbUVxdWFsU3RyYXRlZ3lOdW1iZXI6Ci0KLQkJCQkvKgot CQkJCSAqIEluIHRoZSBlcXVhbGl0eSBjYXNlIChXSEVSRSBjb2wgPSBzb21ldmFsKSwgd2Ug d2FudCB0bwotCQkJCSAqIHJldHVybiB0aGUgY3VycmVudCBwYWdlIHJhbmdlIGlmIHRoZSBt aW5pbXVtIHZhbHVlIGluIHRoZQotCQkJCSAqIHJhbmdlIDw9IHNjYW4ga2V5LCBhbmQgdGhl IG1heGltdW0gdmFsdWUgPj0gc2NhbiBrZXkuCi0JCQkJICovCi0JCQkJZmluZm8gPSBibG9v bV9nZXRfcHJvY2luZm8oYmRlc2MsIGF0dG5vLCBQUk9DTlVNX0hBU0gpOwotCi0JCQkJaGFz aFZhbHVlID0gRGF0dW1HZXRVSW50MzIoRnVuY3Rpb25DYWxsMUNvbGwoZmluZm8sIGNvbGxv aWQsIHZhbHVlKSk7Ci0JCQkJbWF0Y2hlcyAmPSBibG9vbV9jb250YWluc192YWx1ZShmaWx0 ZXIsIGhhc2hWYWx1ZSk7Ci0KLQkJCQlicmVhazsKLQkJCWRlZmF1bHQ6Ci0JCQkJLyogc2hv dWxkbid0IGhhcHBlbiAqLwotCQkJCWVsb2coRVJST1IsICJpbnZhbGlkIHN0cmF0ZWd5IG51 bWJlciAlZCIsIGtleS0+c2tfc3RyYXRlZ3kpOwotCQkJCW1hdGNoZXMgPSAwOwotCQkJCWJy ZWFrOworCQkJc3dpdGNoIChrZXktPnNrX3N0cmF0ZWd5KQorCQkJeworCQkJCWNhc2UgQmxv b21FcXVhbFN0cmF0ZWd5TnVtYmVyOgorCisJCQkJCS8qCisJCQkJCSAqIEluIHRoZSBlcXVh bGl0eSBjYXNlIChXSEVSRSBjb2wgPSBzb21ldmFsKSwgd2Ugd2FudCB0bworCQkJCQkgKiBy ZXR1cm4gdGhlIGN1cnJlbnQgcGFnZSByYW5nZSBpZiB0aGUgbWluaW11bSB2YWx1ZSBpbiB0 aGUKKwkJCQkJICogcmFuZ2UgPD0gc2NhbiBrZXksIGFuZCB0aGUgbWF4aW11bSB2YWx1ZSA+ PSBzY2FuIGtleS4KKwkJCQkJICovCisJCQkJCWZpbmZvID0gYmxvb21fZ2V0X3Byb2NpbmZv KGJkZXNjLCBhdHRubywgUFJPQ05VTV9IQVNIKTsKKworCQkJCQloYXNoVmFsdWUgPSBEYXR1 bUdldFVJbnQzMihGdW5jdGlvbkNhbGwxQ29sbChmaW5mbywgY29sbG9pZCwgdmFsdWUpKTsK KwkJCQkJbWF0Y2hlcyAmPSBibG9vbV9jb250YWluc192YWx1ZShmaWx0ZXIsIGhhc2hWYWx1 ZSk7CisKKwkJCQkJYnJlYWs7CisJCQkJZGVmYXVsdDoKKwkJCQkJLyogc2hvdWxkbid0IGhh cHBlbiAqLworCQkJCQllbG9nKEVSUk9SLCAiaW52YWxpZCBzdHJhdGVneSBudW1iZXIgJWQi LCBrZXktPnNrX3N0cmF0ZWd5KTsKKwkJCQkJbWF0Y2hlcyA9IDA7CisJCQkJCWJyZWFrOwor CQkJfQorCQl9CisJCWVsc2UKKwkJeworCQkJQXJyYXlUeXBlICAqYXJyYXl2YWw7CisJCQlp bnQxNgkJZWxtbGVuOworCQkJYm9vbAkJZWxtYnl2YWw7CisJCQljaGFyCQllbG1hbGlnbjsK KwkJCWludAkJCW51bV9lbGVtczsKKwkJCURhdHVtCSAgICplbGVtX3ZhbHVlczsKKwkJCWJv b2wJICAgKmVsZW1fbnVsbHM7CisKKwkJCWFycmF5dmFsID0gRGF0dW1HZXRBcnJheVR5cGVQ KGtleS0+c2tfYXJndW1lbnQpOworCisJCQlnZXRfdHlwbGVuYnl2YWxhbGlnbihBUlJfRUxF TVRZUEUoYXJyYXl2YWwpLAorCQkJCQkJCQkgJmVsbWxlbiwgJmVsbWJ5dmFsLCAmZWxtYWxp Z24pOworCisJCQlkZWNvbnN0cnVjdF9hcnJheShhcnJheXZhbCwKKwkJCQkJCQkgIEFSUl9F TEVNVFlQRShhcnJheXZhbCksCisJCQkJCQkJICBlbG1sZW4sIGVsbWJ5dmFsLCBlbG1hbGln biwKKwkJCQkJCQkgICZlbGVtX3ZhbHVlcywgJmVsZW1fbnVsbHMsICZudW1fZWxlbXMpOwor CisJCQlzd2l0Y2ggKGtleS0+c2tfc3RyYXRlZ3kpCisJCQl7CisJCQkJY2FzZSBCbG9vbUVx dWFsU3RyYXRlZ3lOdW1iZXI6CisJCQkJCXsKKwkJCQkJCS8qIGFzc3VtZSBubyBtYXRjaCAq LworCQkJCQkJbWF0Y2hlcyA9IEJvb2xHZXREYXR1bShmYWxzZSk7CisKKwkJCQkJCS8qCisJ CQkJCQkgKiBJbiB0aGUgZXF1YWxpdHkgY2FzZSAoV0hFUkUgY29sID0gc29tZXZhbCksIHdl IHdhbnQgdG8KKwkJCQkJCSAqIHJldHVybiB0aGUgY3VycmVudCBwYWdlIHJhbmdlIGlmIHRo ZSBtaW5pbXVtIHZhbHVlIGluIHRoZQorCQkJCQkJICogcmFuZ2UgPD0gc2NhbiBrZXksIGFu ZCB0aGUgbWF4aW11bSB2YWx1ZSA+PSBzY2FuIGtleS4KKwkJCQkJCSAqLworCQkJCQkJZmlu Zm8gPSBibG9vbV9nZXRfcHJvY2luZm8oYmRlc2MsIGF0dG5vLCBQUk9DTlVNX0hBU0gpOwor CisJCQkJCQlmb3IgKGludCBpID0gMDsgaSA8IG51bV9lbGVtczsgaSsrKQorCQkJCQkJewor CQkJCQkJCWJvb2wJdG1wID0gZmFsc2U7CisJCQkJCQkJRGF0dW0JZWxlbWVudCA9IGVsZW1f dmFsdWVzW2ldOworCisJCQkJCQkJaGFzaFZhbHVlID0gRGF0dW1HZXRVSW50MzIoRnVuY3Rp b25DYWxsMUNvbGwoZmluZm8sIGNvbGxvaWQsCisJCQkJCQkJCQkJCQkJCQkJCQkgZWxlbWVu dCkpOworCQkJCQkJCXRtcCA9IGJsb29tX2NvbnRhaW5zX3ZhbHVlKGZpbHRlciwgaGFzaFZh bHVlKTsKKworCQkJCQkJCWlmIChEYXR1bUdldEJvb2wodG1wKSkKKwkJCQkJCQl7CisJCQkJ CQkJCW1hdGNoZXMgPSBCb29sR2V0RGF0dW0odHJ1ZSk7CisJCQkJCQkJCWJyZWFrOworCQkJ CQkJCX0KKwkJCQkJCX0KKwkJCQkJfQorCQkJCQlicmVhazsKKwkJCQlkZWZhdWx0OgorCQkJ CQkvKiBzaG91bGRuJ3QgaGFwcGVuICovCisJCQkJCWVsb2coRVJST1IsICJpbnZhbGlkIHN0 cmF0ZWd5IG51bWJlciAlZCIsIGtleS0+c2tfc3RyYXRlZ3kpOworCQkJCQltYXRjaGVzID0g MDsKKwkJCQkJYnJlYWs7CisJCQl9CiAJCX0KIAogCQlpZiAoIW1hdGNoZXMpCi0tIAoyLjM5 LjEKCg== --------------vUwxfMJd601J0Yjedx8IQ3Mp Content-Type: text/x-patch; charset=UTF-8; name="0006-PoC-caching-hash-values-in-BRIN-bloom-20230213.patch" Content-Disposition: attachment; filename*0="0006-PoC-caching-hash-values-in-BRIN-bloom-20230213.patch" Content-Transfer-Encoding: base64 RnJvbSBkMGRlYWQ1ZGVkYzBmOTFkNzI3OWQzNTFhNjQzMmUyNTkyZjhkNTc4IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb21hcyBWb25kcmEgPHRvbWFzLnZvbmRyYUBwb3N0 Z3Jlc3FsLm9yZz4KRGF0ZTogU2F0LCAxMSBGZWIgMjAyMyAyMzo0NDoyMSArMDEwMApTdWJq ZWN0OiBbUEFUQ0ggNi82XSBQb0MgY2FjaGluZyBoYXNoIHZhbHVlcyBpbiBCUklOIGJsb29t CgpDYWNoZSBvZiBoYXNoIHZhbHVlcyBpbml0aWFsaXplZCB3aGVuIHByb2Nlc3NpbmcgdGhl IGZpcnN0IHBhZ2UgcmFuZ2UuClRoZSBjYWNoZSBpcyBub3QKLS0tCiBzcmMvYmFja2VuZC9h Y2Nlc3MvYnJpbi9icmluX2Jsb29tLmMgfCA1OSArKysrKysrKysrKysrKysrKysrKysrKysr Ky0tCiAxIGZpbGUgY2hhbmdlZCwgNTUgaW5zZXJ0aW9ucygrKSwgNCBkZWxldGlvbnMoLSkK CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvYnJpbi9icmluX2Jsb29tLmMgYi9z cmMvYmFja2VuZC9hY2Nlc3MvYnJpbi9icmluX2Jsb29tLmMKaW5kZXggYzI5MzlhYzgwOS4u YjU3ZGI2YmUxNCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvYWNjZXNzL2JyaW4vYnJpbl9i bG9vbS5jCisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9icmluL2JyaW5fYmxvb20uYwpAQCAt MTI5LDYgKzEyOSw3IEBACiAjaW5jbHVkZSAidXRpbHMvYnVpbHRpbnMuaCIKICNpbmNsdWRl ICJ1dGlscy9kYXR1bS5oIgogI2luY2x1ZGUgInV0aWxzL2xzeXNjYWNoZS5oIgorI2luY2x1 ZGUgInV0aWxzL21lbXV0aWxzLmgiCiAjaW5jbHVkZSAidXRpbHMvcmVsLmgiCiAjaW5jbHVk ZSAidXRpbHMvc3lzY2FjaGUuaCIKIApAQCAtMjYwLDYgKzI2MSw4IEBAIHR5cGVkZWYgc3Ry dWN0IEJsb29tRmlsdGVyCiAJY2hhcgkJZGF0YVtGTEVYSUJMRV9BUlJBWV9NRU1CRVJdOwog fSBCbG9vbUZpbHRlcjsKIAorc3RhdGljIHVpbnQ2NCAqY2FjaGVfaDEgPSBOVUxMOworc3Rh dGljIHVpbnQ2NCAqY2FjaGVfaDIgPSBOVUxMOwogCiAvKgogICogYmxvb21faW5pdApAQCAt NDA1LDYgKzQwOCwzMiBAQCBibG9vbV9jb250YWluc192YWx1ZShCbG9vbUZpbHRlciAqZmls dGVyLCB1aW50MzIgdmFsdWUpCiAJcmV0dXJuIHRydWU7CiB9CiAKKy8qCisgKiBibG9vbV9j b250YWluc192YWx1ZQorICogCQlDaGVjayBpZiB0aGUgYmxvb20gZmlsdGVyIGNvbnRhaW5z IGEgcGFydGljdWxhciB2YWx1ZS4KKyAqLworc3RhdGljIGJvb2wKK2Jsb29tX2NvbnRhaW5z X2hhc2hlcyhCbG9vbUZpbHRlciAqZmlsdGVyLCB1aW50NjQgaDEsIHVpbnQ2NCBoMikKK3sK KwlpbnQJCQlpOworCisJLyogY29tcHV0ZSB0aGUgcmVxdWVzdGVkIG51bWJlciBvZiBoYXNo ZXMgKi8KKwlmb3IgKGkgPSAwOyBpIDwgZmlsdGVyLT5uaGFzaGVzOyBpKyspCisJeworCQkv KiBoMSArIGgyICsgZihpKSAqLworCQl1aW50MzIJCWggPSAoaDEgKyBpICogaDIpICUgZmls dGVyLT5uYml0czsKKwkJdWludDMyCQlieXRlID0gKGggLyA4KTsKKwkJdWludDMyCQliaXQg PSAoaCAlIDgpOworCisJCS8qIGlmIHRoZSBiaXQgaXMgbm90IHNldCwgdGhlIHZhbHVlIGlz IG5vdCB0aGVyZSAqLworCQlpZiAoIShmaWx0ZXItPmRhdGFbYnl0ZV0gJiAoMHgwMSA8PCBi aXQpKSkKKwkJCXJldHVybiBmYWxzZTsKKwl9CisKKwkvKiBhbGwgaGFzaGVzIGZvdW5kIGlu IGJsb29tIGZpbHRlciAqLworCXJldHVybiB0cnVlOworfQorCiB0eXBlZGVmIHN0cnVjdCBC bG9vbU9wYXF1ZQogewogCS8qCkBAIC00NDAsNiArNDY5LDkgQEAgYnJpbl9ibG9vbV9vcGNp bmZvKFBHX0ZVTkNUSU9OX0FSR1MpCiAJCU1BWEFMSUdOKChjaGFyICopIHJlc3VsdCArIFNp emVvZkJyaW5PcGNJbmZvKDEpKTsKIAlyZXN1bHQtPm9pX3R5cGNhY2hlWzBdID0gbG9va3Vw X3R5cGVfY2FjaGUoUEdfQlJJTl9CTE9PTV9TVU1NQVJZT0lELCAwKTsKIAorCWNhY2hlX2gx ID0gTlVMTDsKKwljYWNoZV9oMiA9IE5VTEw7CisKIAlQR19SRVRVUk5fUE9JTlRFUihyZXN1 bHQpOwogfQogCkBAIC02NDEsNiArNjczLDI4IEBAIGJyaW5fYmxvb21fY29uc2lzdGVudChQ R19GVU5DVElPTl9BUkdTKQogCQkJCQkJCSAgZWxtbGVuLCBlbG1ieXZhbCwgZWxtYWxpZ24s CiAJCQkJCQkJICAmZWxlbV92YWx1ZXMsICZlbGVtX251bGxzLCAmbnVtX2VsZW1zKTsKIAor CQkJaWYgKGNhY2hlX2gxID09IE5VTEwgJiYgY2FjaGVfaDIgPT0gTlVMTCkKKwkJCXsKKwkJ CQlNZW1vcnlDb250ZXh0IG9sZGN4dDsKKworCQkJCW9sZGN4dCA9IE1lbW9yeUNvbnRleHRT d2l0Y2hUbyhiZGVzYy0+YmRfY29udGV4dCk7CisJCQkJY2FjaGVfaDEgPSBwYWxsb2MwKG51 bV9lbGVtcyAqIHNpemVvZih1aW50NjQpKTsKKwkJCQljYWNoZV9oMiA9IHBhbGxvYzAobnVt X2VsZW1zICogc2l6ZW9mKHVpbnQ2NCkpOworCQkJCU1lbW9yeUNvbnRleHRTd2l0Y2hUbyhv bGRjeHQpOworCisJCQkJZmluZm8gPSBibG9vbV9nZXRfcHJvY2luZm8oYmRlc2MsIGF0dG5v LCBQUk9DTlVNX0hBU0gpOworCisJCQkJZm9yIChpbnQgaSA9IDA7IGkgPCBudW1fZWxlbXM7 IGkrKykKKwkJCQl7CisJCQkJCURhdHVtCWVsZW1lbnQgPSBlbGVtX3ZhbHVlc1tpXTsKKwor CQkJCQloYXNoVmFsdWUgPSBEYXR1bUdldFVJbnQzMihGdW5jdGlvbkNhbGwxQ29sbChmaW5m bywgY29sbG9pZCwgZWxlbWVudCkpOworCisJCQkJCWNhY2hlX2gxW2ldID0gaGFzaF9ieXRl c191aW50MzJfZXh0ZW5kZWQoaGFzaFZhbHVlLCBCTE9PTV9TRUVEXzEpICUgZmlsdGVyLT5u Yml0czsKKwkJCQkJY2FjaGVfaDJbaV0gPSBoYXNoX2J5dGVzX3VpbnQzMl9leHRlbmRlZCho YXNoVmFsdWUsIEJMT09NX1NFRURfMikgJSBmaWx0ZXItPm5iaXRzOworCQkJCX0KKwkJCX0K KwogCQkJc3dpdGNoIChrZXktPnNrX3N0cmF0ZWd5KQogCQkJewogCQkJCWNhc2UgQmxvb21F cXVhbFN0cmF0ZWd5TnVtYmVyOgpAQCAtNjU4LDExICs3MTIsOCBAQCBicmluX2Jsb29tX2Nv bnNpc3RlbnQoUEdfRlVOQ1RJT05fQVJHUykKIAkJCQkJCWZvciAoaW50IGkgPSAwOyBpIDwg bnVtX2VsZW1zOyBpKyspCiAJCQkJCQl7CiAJCQkJCQkJYm9vbAl0bXAgPSBmYWxzZTsKLQkJ CQkJCQlEYXR1bQllbGVtZW50ID0gZWxlbV92YWx1ZXNbaV07CiAKLQkJCQkJCQloYXNoVmFs dWUgPSBEYXR1bUdldFVJbnQzMihGdW5jdGlvbkNhbGwxQ29sbChmaW5mbywgY29sbG9pZCwK LQkJCQkJCQkJCQkJCQkJCQkJCSBlbGVtZW50KSk7Ci0JCQkJCQkJdG1wID0gYmxvb21fY29u dGFpbnNfdmFsdWUoZmlsdGVyLCBoYXNoVmFsdWUpOworCQkJCQkJCXRtcCA9IGJsb29tX2Nv bnRhaW5zX2hhc2hlcyhmaWx0ZXIsIGNhY2hlX2gxW2ldLCBjYWNoZV9oMltpXSk7CiAKIAkJ CQkJCQlpZiAoRGF0dW1HZXRCb29sKHRtcCkpCiAJCQkJCQkJewotLSAKMi4zOS4xCgo= --------------vUwxfMJd601J0Yjedx8IQ3Mp--