From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 0624B381C3; Fri, 5 Jan 2024 18:51:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="WHB8Ba60" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 696CDC433CD; Fri, 5 Jan 2024 18:51:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1704480693; bh=T3+y/jWg1Z/7qHTP0Vdh0JG7I7zyaLVxiK2RQ3H64ms=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=WHB8Ba60HWAUk/o003Fxse6F+oFNc07u3GoK+AkmJIsYzCrXHLWmXW+LFTlt/eHC9 2lDT5Xr+poe5jXbTnSVKRQ+/McwTnxbuRFqlXdjVi7H1g2VpivSO98h9gjMsNHPXnu Nhd8TFMaz3ziUxqAi3BaAD9y2yCUdLnRCK+q2dL7HBQ5ApOH6e7J5k87xK1qqGBTBP d1D5aE17HUXkrygC1aNb7gzwrUx+iIXXo+tgfTsgSZZXm3arGnhVbnoZK1Z8/zpDjg ewONGC4+F3bqVl9kbp8F864NETe+i68JSk+sj8RZ9XHUXApcNAZrQRImCscPBnruAO 6Xtuzs/FzxHKQ== From: Eric Biggers To: linux-crypto@vger.kernel.org, linux-riscv@lists.infradead.org, Jerry Shih Cc: linux-kernel@vger.kernel.org, Ard Biesheuvel , Heiko Stuebner , Phoebe Chen , hongrong.hsu@sifive.com, Paul Walmsley , Palmer Dabbelt , Albert Ou , Andy Chiu , =?UTF-8?q?Christoph=20M=C3=BCllner?= , Heiko Stuebner Subject: [PATCH v2 11/12] crypto: riscv - add vector crypto accelerated SM3 Date: Fri, 5 Jan 2024 10:49:47 -0800 Message-ID: <20240105184950.43181-12-ebiggers@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240105184950.43181-1-ebiggers@kernel.org> References: <20240105184950.43181-1-ebiggers@kernel.org> Precedence: bulk X-Mailing-List: linux-crypto@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit From: Jerry Shih Add an implementation of SM3 using the Zvksh extension. The assembly code is derived from OpenSSL code (openssl/openssl#21923) that was dual-licensed so that it could be reused in the kernel. Nevertheless, the assembly has been significantly reworked for integration with the kernel, for example by using a regular .S file instead of the so-called perlasm, using the assembler instead of bare '.inst', and greatly reducing code duplication. Co-developed-by: Christoph Müllner Signed-off-by: Christoph Müllner Co-developed-by: Heiko Stuebner Signed-off-by: Heiko Stuebner Signed-off-by: Jerry Shih Co-developed-by: Eric Biggers Signed-off-by: Eric Biggers --- arch/riscv/crypto/Kconfig | 12 ++ arch/riscv/crypto/Makefile | 3 + arch/riscv/crypto/sm3-riscv64-glue.c | 112 +++++++++++++++++++ arch/riscv/crypto/sm3-riscv64-zvksh-zvkb.S | 123 +++++++++++++++++++++ 4 files changed, 250 insertions(+) create mode 100644 arch/riscv/crypto/sm3-riscv64-glue.c create mode 100644 arch/riscv/crypto/sm3-riscv64-zvksh-zvkb.S diff --git a/arch/riscv/crypto/Kconfig b/arch/riscv/crypto/Kconfig index 0fd0bf46c9099..179d09df8e0ca 100644 --- a/arch/riscv/crypto/Kconfig +++ b/arch/riscv/crypto/Kconfig @@ -54,11 +54,23 @@ config CRYPTO_SHA512_RISCV64 tristate "Hash functions: SHA-384 and SHA-512" depends on 64BIT && RISCV_ISA_V && TOOLCHAIN_HAS_VECTOR_CRYPTO select CRYPTO_SHA512 help SHA-384 and SHA-512 secure hash algorithm (FIPS 180) Architecture: riscv64 using: - Zvknhb vector crypto extension - Zvkb vector crypto extension +config CRYPTO_SM3_RISCV64 + tristate "Hash functions: SM3 (ShangMi 3)" + depends on 64BIT && RISCV_ISA_V && TOOLCHAIN_HAS_VECTOR_CRYPTO + select CRYPTO_HASH + select CRYPTO_SM3 + help + SM3 (ShangMi 3) secure hash function (OSCCA GM/T 0004-2012) + + Architecture: riscv64 using: + - Zvksh vector crypto extension + - Zvkb vector crypto extension + endmenu diff --git a/arch/riscv/crypto/Makefile b/arch/riscv/crypto/Makefile index 8dbfda1918990..3b154f893e6e2 100644 --- a/arch/riscv/crypto/Makefile +++ b/arch/riscv/crypto/Makefile @@ -11,10 +11,13 @@ obj-$(CONFIG_CRYPTO_CHACHA_RISCV64) += chacha-riscv64.o chacha-riscv64-y := chacha-riscv64-glue.o chacha-riscv64-zvkb.o obj-$(CONFIG_CRYPTO_GHASH_RISCV64) += ghash-riscv64.o ghash-riscv64-y := ghash-riscv64-glue.o ghash-riscv64-zvkg.o obj-$(CONFIG_CRYPTO_SHA256_RISCV64) += sha256-riscv64.o sha256-riscv64-y := sha256-riscv64-glue.o sha256-riscv64-zvknha_or_zvknhb-zvkb.o obj-$(CONFIG_CRYPTO_SHA512_RISCV64) += sha512-riscv64.o sha512-riscv64-y := sha512-riscv64-glue.o sha512-riscv64-zvknhb-zvkb.o + +obj-$(CONFIG_CRYPTO_SM3_RISCV64) += sm3-riscv64.o +sm3-riscv64-y := sm3-riscv64-glue.o sm3-riscv64-zvksh-zvkb.o diff --git a/arch/riscv/crypto/sm3-riscv64-glue.c b/arch/riscv/crypto/sm3-riscv64-glue.c new file mode 100644 index 0000000000000..e1737a970c7c9 --- /dev/null +++ b/arch/riscv/crypto/sm3-riscv64-glue.c @@ -0,0 +1,112 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * SM3 using the RISC-V vector crypto extensions + * + * Copyright (C) 2023 VRULL GmbH + * Author: Heiko Stuebner + * + * Copyright (C) 2023 SiFive, Inc. + * Author: Jerry Shih + */ + +#include +#include +#include +#include +#include +#include +#include + +/* + * Note: the asm function only uses the 'state' field of struct sm3_state. + * It is assumed to be the first field. + */ +asmlinkage void sm3_transform_zvksh_zvkb( + struct sm3_state *state, const u8 *data, int num_blocks); + +static int riscv64_sm3_update(struct shash_desc *desc, const u8 *data, + unsigned int len) +{ + /* + * Ensure struct sm3_state begins directly with the SM3 + * 256-bit internal state, as this is what the asm function expects. + */ + BUILD_BUG_ON(offsetof(struct sm3_state, state) != 0); + + if (crypto_simd_usable()) { + kernel_vector_begin(); + sm3_base_do_update(desc, data, len, sm3_transform_zvksh_zvkb); + kernel_vector_end(); + } else { + sm3_update(shash_desc_ctx(desc), data, len); + } + return 0; +} + +static int riscv64_sm3_finup(struct shash_desc *desc, const u8 *data, + unsigned int len, u8 *out) +{ + struct sm3_state *ctx; + + if (crypto_simd_usable()) { + kernel_vector_begin(); + if (len) + sm3_base_do_update(desc, data, len, + sm3_transform_zvksh_zvkb); + sm3_base_do_finalize(desc, sm3_transform_zvksh_zvkb); + kernel_vector_end(); + + return sm3_base_finish(desc, out); + } + + ctx = shash_desc_ctx(desc); + if (len) + sm3_update(ctx, data, len); + sm3_final(ctx, out); + + return 0; +} + +static int riscv64_sm3_final(struct shash_desc *desc, u8 *out) +{ + return riscv64_sm3_finup(desc, NULL, 0, out); +} + +static struct shash_alg riscv64_sm3_alg = { + .init = sm3_base_init, + .update = riscv64_sm3_update, + .final = riscv64_sm3_final, + .finup = riscv64_sm3_finup, + .descsize = sizeof(struct sm3_state), + .digestsize = SM3_DIGEST_SIZE, + .base = { + .cra_blocksize = SM3_BLOCK_SIZE, + .cra_priority = 300, + .cra_name = "sm3", + .cra_driver_name = "sm3-riscv64-zvksh-zvkb", + .cra_module = THIS_MODULE, + }, +}; + +static int __init riscv64_sm3_mod_init(void) +{ + if (riscv_isa_extension_available(NULL, ZVKSH) && + riscv_isa_extension_available(NULL, ZVKB) && + riscv_vector_vlen() >= 128) + return crypto_register_shash(&riscv64_sm3_alg); + + return -ENODEV; +} + +static void __exit riscv64_sm3_mod_exit(void) +{ + crypto_unregister_shash(&riscv64_sm3_alg); +} + +module_init(riscv64_sm3_mod_init); +module_exit(riscv64_sm3_mod_exit); + +MODULE_DESCRIPTION("SM3 (RISC-V accelerated)"); +MODULE_AUTHOR("Heiko Stuebner "); +MODULE_LICENSE("GPL"); +MODULE_ALIAS_CRYPTO("sm3"); diff --git a/arch/riscv/crypto/sm3-riscv64-zvksh-zvkb.S b/arch/riscv/crypto/sm3-riscv64-zvksh-zvkb.S new file mode 100644 index 0000000000000..a2b65d961c04a --- /dev/null +++ b/arch/riscv/crypto/sm3-riscv64-zvksh-zvkb.S @@ -0,0 +1,123 @@ +/* SPDX-License-Identifier: Apache-2.0 OR BSD-2-Clause */ +// +// This file is dual-licensed, meaning that you can use it under your +// choice of either of the following two licenses: +// +// Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. +// +// Licensed under the Apache License 2.0 (the "License"). You can obtain +// a copy in the file LICENSE in the source distribution or at +// https://www.openssl.org/source/license.html +// +// or +// +// Copyright (c) 2023, Christoph Müllner +// Copyright (c) 2023, Jerry Shih +// Copyright 2024 Google LLC +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// The generated code of this file depends on the following RISC-V extensions: +// - RV64I +// - RISC-V Vector ('V') with VLEN >= 128 +// - RISC-V Vector SM3 Secure Hash extension ('Zvksh') +// - RISC-V Vector Cryptography Bit-manipulation extension ('Zvkb') + +#include + +.text +.option arch, +zvksh, +zvkb + +#define STATEP a0 +#define DATA a1 +#define NUM_BLOCKS a2 + +#define STATE v0 // LMUL=2 +#define PREV_STATE v2 // LMUL=2 +#define W0 v4 // LMUL=2 +#define W1 v6 // LMUL=2 +#define VTMP v8 // LMUL=2 + +.macro sm3_8rounds i, w0, w1 + // Do 4 rounds using W_{0+i}..W_{7+i}. + vsm3c.vi STATE, \w0, \i + 0 + vslidedown.vi VTMP, \w0, 2 + vsm3c.vi STATE, VTMP, \i + 1 + + // Compute W_{4+i}..W_{11+i}. + vslidedown.vi VTMP, \w0, 4 + vslideup.vi VTMP, \w1, 4 + + // Do 4 rounds using W_{4+i}..W_{11+i}. + vsm3c.vi STATE, VTMP, \i + 2 + vslidedown.vi VTMP, VTMP, 2 + vsm3c.vi STATE, VTMP, \i + 3 + +.if \i < 28 + // Compute W_{16+i}..W_{23+i}. + vsm3me.vv \w0, \w1, \w0 +.endif + // For the next 8 rounds, w0 and w1 are swapped. +.endm + +// void sm3_transform_zvksh_zvkb(u32 state[8], const u8 *data, int num_blocks); +SYM_TYPED_FUNC_START(sm3_transform_zvksh_zvkb) + + // Load the state and endian-swap each 32-bit word. + vsetivli zero, 8, e32, m2, ta, ma + vle32.v STATE, (STATEP) + vrev8.v STATE, STATE + +.Lnext_block: + addi NUM_BLOCKS, NUM_BLOCKS, -1 + + // Save the previous state, as it's needed later. + vmv.v.v PREV_STATE, STATE + + // Load the next 512-bit message block into W0-W1. + vle32.v W0, (DATA) + addi DATA, DATA, 32 + vle32.v W1, (DATA) + addi DATA, DATA, 32 + + // Do the 64 rounds of SM3. + sm3_8rounds 0, W0, W1 + sm3_8rounds 4, W1, W0 + sm3_8rounds 8, W0, W1 + sm3_8rounds 12, W1, W0 + sm3_8rounds 16, W0, W1 + sm3_8rounds 20, W1, W0 + sm3_8rounds 24, W0, W1 + sm3_8rounds 28, W1, W0 + + // XOR in the previous state. + vxor.vv STATE, STATE, PREV_STATE + + // Repeat if more blocks remain. + bnez NUM_BLOCKS, .Lnext_block + + // Store the new state and return. + vrev8.v STATE, STATE + vse32.v STATE, (STATEP) + ret +SYM_FUNC_END(sm3_transform_zvksh_zvkb) -- 2.43.0 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 585ECC4707B for ; Fri, 5 Jan 2024 18:51:52 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=MFC9IWNnHKEqNuR7t7kOmH32cfJT2LaWzDkqZQOz8d4=; b=rT6bXmKwbyXUZJ j4rO06ZsVzIhNxJdEuRYNOYRvw14goYK171S70+WlhmRyUhA3xkHEcAYuxJ+7EtjEH9TZmnalcFKq xB61drT6poFWzWBOGQFjz4yKtejYJU8H7piDPYYAT/9+Azfc6RaySN9O4GufVHtz3KV8upBLU+IfF xDzm/9jgW1VM+XiURbNWQbTBxlevWD3w8041Z4+uTk/0ZcvbRz047sDdOc285H0oUiNmZenwhVX06 Q9W0XEo8K46vEFaGjuCPmHK8QHZsYo1+60Pg5eCmTzRSEEqyeLCOgANpBae84iAPKEXZtcXp0dQ3z 20Q66z1LPWa6GiJLcHqg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1rLpIG-0001QX-2r; Fri, 05 Jan 2024 18:51:44 +0000 Received: from dfw.source.kernel.org ([2604:1380:4641:c500::1]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1rLpI8-0001Ki-2l for linux-riscv@lists.infradead.org; Fri, 05 Jan 2024 18:51:40 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by dfw.source.kernel.org (Postfix) with ESMTP id 102D361BDC; Fri, 5 Jan 2024 18:51:34 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 696CDC433CD; Fri, 5 Jan 2024 18:51:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1704480693; bh=T3+y/jWg1Z/7qHTP0Vdh0JG7I7zyaLVxiK2RQ3H64ms=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=WHB8Ba60HWAUk/o003Fxse6F+oFNc07u3GoK+AkmJIsYzCrXHLWmXW+LFTlt/eHC9 2lDT5Xr+poe5jXbTnSVKRQ+/McwTnxbuRFqlXdjVi7H1g2VpivSO98h9gjMsNHPXnu Nhd8TFMaz3ziUxqAi3BaAD9y2yCUdLnRCK+q2dL7HBQ5ApOH6e7J5k87xK1qqGBTBP d1D5aE17HUXkrygC1aNb7gzwrUx+iIXXo+tgfTsgSZZXm3arGnhVbnoZK1Z8/zpDjg ewONGC4+F3bqVl9kbp8F864NETe+i68JSk+sj8RZ9XHUXApcNAZrQRImCscPBnruAO 6Xtuzs/FzxHKQ== From: Eric Biggers To: linux-crypto@vger.kernel.org, linux-riscv@lists.infradead.org, Jerry Shih Cc: linux-kernel@vger.kernel.org, Ard Biesheuvel , Heiko Stuebner , Phoebe Chen , hongrong.hsu@sifive.com, Paul Walmsley , Palmer Dabbelt , Albert Ou , Andy Chiu , =?UTF-8?q?Christoph=20M=C3=BCllner?= , Heiko Stuebner Subject: [PATCH v2 11/12] crypto: riscv - add vector crypto accelerated SM3 Date: Fri, 5 Jan 2024 10:49:47 -0800 Message-ID: <20240105184950.43181-12-ebiggers@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240105184950.43181-1-ebiggers@kernel.org> References: <20240105184950.43181-1-ebiggers@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240105_105136_978806_B5D23776 X-CRM114-Status: GOOD ( 28.90 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org RnJvbTogSmVycnkgU2hpaCA8amVycnkuc2hpaEBzaWZpdmUuY29tPgoKQWRkIGFuIGltcGxlbWVu dGF0aW9uIG9mIFNNMyB1c2luZyB0aGUgWnZrc2ggZXh0ZW5zaW9uLiAgVGhlIGFzc2VtYmx5CmNv ZGUgaXMgZGVyaXZlZCBmcm9tIE9wZW5TU0wgY29kZSAob3BlbnNzbC9vcGVuc3NsIzIxOTIzKSB0 aGF0IHdhcwpkdWFsLWxpY2Vuc2VkIHNvIHRoYXQgaXQgY291bGQgYmUgcmV1c2VkIGluIHRoZSBr ZXJuZWwuICBOZXZlcnRoZWxlc3MsCnRoZSBhc3NlbWJseSBoYXMgYmVlbiBzaWduaWZpY2FudGx5 IHJld29ya2VkIGZvciBpbnRlZ3JhdGlvbiB3aXRoIHRoZQprZXJuZWwsIGZvciBleGFtcGxlIGJ5 IHVzaW5nIGEgcmVndWxhciAuUyBmaWxlIGluc3RlYWQgb2YgdGhlIHNvLWNhbGxlZApwZXJsYXNt LCB1c2luZyB0aGUgYXNzZW1ibGVyIGluc3RlYWQgb2YgYmFyZSAnLmluc3QnLCBhbmQgZ3JlYXRs eQpyZWR1Y2luZyBjb2RlIGR1cGxpY2F0aW9uLgoKQ28tZGV2ZWxvcGVkLWJ5OiBDaHJpc3RvcGgg TcO8bGxuZXIgPGNocmlzdG9waC5tdWVsbG5lckB2cnVsbC5ldT4KU2lnbmVkLW9mZi1ieTogQ2hy aXN0b3BoIE3DvGxsbmVyIDxjaHJpc3RvcGgubXVlbGxuZXJAdnJ1bGwuZXU+CkNvLWRldmVsb3Bl ZC1ieTogSGVpa28gU3R1ZWJuZXIgPGhlaWtvLnN0dWVibmVyQHZydWxsLmV1PgpTaWduZWQtb2Zm LWJ5OiBIZWlrbyBTdHVlYm5lciA8aGVpa28uc3R1ZWJuZXJAdnJ1bGwuZXU+ClNpZ25lZC1vZmYt Ynk6IEplcnJ5IFNoaWggPGplcnJ5LnNoaWhAc2lmaXZlLmNvbT4KQ28tZGV2ZWxvcGVkLWJ5OiBF cmljIEJpZ2dlcnMgPGViaWdnZXJzQGdvb2dsZS5jb20+ClNpZ25lZC1vZmYtYnk6IEVyaWMgQmln Z2VycyA8ZWJpZ2dlcnNAZ29vZ2xlLmNvbT4KLS0tCiBhcmNoL3Jpc2N2L2NyeXB0by9LY29uZmln ICAgICAgICAgICAgICAgICAgfCAgMTIgKysKIGFyY2gvcmlzY3YvY3J5cHRvL01ha2VmaWxlICAg ICAgICAgICAgICAgICB8ICAgMyArCiBhcmNoL3Jpc2N2L2NyeXB0by9zbTMtcmlzY3Y2NC1nbHVl LmMgICAgICAgfCAxMTIgKysrKysrKysrKysrKysrKysrKwogYXJjaC9yaXNjdi9jcnlwdG8vc20z LXJpc2N2NjQtenZrc2gtenZrYi5TIHwgMTIzICsrKysrKysrKysrKysrKysrKysrKwogNCBmaWxl cyBjaGFuZ2VkLCAyNTAgaW5zZXJ0aW9ucygrKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGFyY2gvcmlz Y3YvY3J5cHRvL3NtMy1yaXNjdjY0LWdsdWUuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGFyY2gvcmlz Y3YvY3J5cHRvL3NtMy1yaXNjdjY0LXp2a3NoLXp2a2IuUwoKZGlmZiAtLWdpdCBhL2FyY2gvcmlz Y3YvY3J5cHRvL0tjb25maWcgYi9hcmNoL3Jpc2N2L2NyeXB0by9LY29uZmlnCmluZGV4IDBmZDBi ZjQ2YzkwOTkuLjE3OWQwOWRmOGUwY2EgMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3YvY3J5cHRvL0tj b25maWcKKysrIGIvYXJjaC9yaXNjdi9jcnlwdG8vS2NvbmZpZwpAQCAtNTQsMTEgKzU0LDIzIEBA IGNvbmZpZyBDUllQVE9fU0hBNTEyX1JJU0NWNjQKIAl0cmlzdGF0ZSAiSGFzaCBmdW5jdGlvbnM6 IFNIQS0zODQgYW5kIFNIQS01MTIiCiAJZGVwZW5kcyBvbiA2NEJJVCAmJiBSSVNDVl9JU0FfViAm JiBUT09MQ0hBSU5fSEFTX1ZFQ1RPUl9DUllQVE8KIAlzZWxlY3QgQ1JZUFRPX1NIQTUxMgogCWhl bHAKIAkgIFNIQS0zODQgYW5kIFNIQS01MTIgc2VjdXJlIGhhc2ggYWxnb3JpdGhtIChGSVBTIDE4 MCkKIAogCSAgQXJjaGl0ZWN0dXJlOiByaXNjdjY0IHVzaW5nOgogCSAgLSBadmtuaGIgdmVjdG9y IGNyeXB0byBleHRlbnNpb24KIAkgIC0gWnZrYiB2ZWN0b3IgY3J5cHRvIGV4dGVuc2lvbgogCitj b25maWcgQ1JZUFRPX1NNM19SSVNDVjY0CisJdHJpc3RhdGUgIkhhc2ggZnVuY3Rpb25zOiBTTTMg KFNoYW5nTWkgMykiCisJZGVwZW5kcyBvbiA2NEJJVCAmJiBSSVNDVl9JU0FfViAmJiBUT09MQ0hB SU5fSEFTX1ZFQ1RPUl9DUllQVE8KKwlzZWxlY3QgQ1JZUFRPX0hBU0gKKwlzZWxlY3QgQ1JZUFRP X1NNMworCWhlbHAKKwkgIFNNMyAoU2hhbmdNaSAzKSBzZWN1cmUgaGFzaCBmdW5jdGlvbiAoT1ND Q0EgR00vVCAwMDA0LTIwMTIpCisKKwkgIEFyY2hpdGVjdHVyZTogcmlzY3Y2NCB1c2luZzoKKwkg IC0gWnZrc2ggdmVjdG9yIGNyeXB0byBleHRlbnNpb24KKwkgIC0gWnZrYiB2ZWN0b3IgY3J5cHRv IGV4dGVuc2lvbgorCiBlbmRtZW51CmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2NyeXB0by9NYWtl ZmlsZSBiL2FyY2gvcmlzY3YvY3J5cHRvL01ha2VmaWxlCmluZGV4IDhkYmZkYTE5MTg5OTAuLjNi MTU0Zjg5M2U2ZTIgMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3YvY3J5cHRvL01ha2VmaWxlCisrKyBi L2FyY2gvcmlzY3YvY3J5cHRvL01ha2VmaWxlCkBAIC0xMSwxMCArMTEsMTMgQEAgb2JqLSQoQ09O RklHX0NSWVBUT19DSEFDSEFfUklTQ1Y2NCkgKz0gY2hhY2hhLXJpc2N2NjQubwogY2hhY2hhLXJp c2N2NjQteSA6PSBjaGFjaGEtcmlzY3Y2NC1nbHVlLm8gY2hhY2hhLXJpc2N2NjQtenZrYi5vCiAK IG9iai0kKENPTkZJR19DUllQVE9fR0hBU0hfUklTQ1Y2NCkgKz0gZ2hhc2gtcmlzY3Y2NC5vCiBn aGFzaC1yaXNjdjY0LXkgOj0gZ2hhc2gtcmlzY3Y2NC1nbHVlLm8gZ2hhc2gtcmlzY3Y2NC16dmtn Lm8KIAogb2JqLSQoQ09ORklHX0NSWVBUT19TSEEyNTZfUklTQ1Y2NCkgKz0gc2hhMjU2LXJpc2N2 NjQubwogc2hhMjU2LXJpc2N2NjQteSA6PSBzaGEyNTYtcmlzY3Y2NC1nbHVlLm8gc2hhMjU2LXJp c2N2NjQtenZrbmhhX29yX3p2a25oYi16dmtiLm8KIAogb2JqLSQoQ09ORklHX0NSWVBUT19TSEE1 MTJfUklTQ1Y2NCkgKz0gc2hhNTEyLXJpc2N2NjQubwogc2hhNTEyLXJpc2N2NjQteSA6PSBzaGE1 MTItcmlzY3Y2NC1nbHVlLm8gc2hhNTEyLXJpc2N2NjQtenZrbmhiLXp2a2IubworCitvYmotJChD T05GSUdfQ1JZUFRPX1NNM19SSVNDVjY0KSArPSBzbTMtcmlzY3Y2NC5vCitzbTMtcmlzY3Y2NC15 IDo9IHNtMy1yaXNjdjY0LWdsdWUubyBzbTMtcmlzY3Y2NC16dmtzaC16dmtiLm8KZGlmZiAtLWdp dCBhL2FyY2gvcmlzY3YvY3J5cHRvL3NtMy1yaXNjdjY0LWdsdWUuYyBiL2FyY2gvcmlzY3YvY3J5 cHRvL3NtMy1yaXNjdjY0LWdsdWUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwLi5lMTczN2E5NzBjN2M5Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9yaXNjdi9jcnlw dG8vc20zLXJpc2N2NjQtZ2x1ZS5jCkBAIC0wLDAgKzEsMTEyIEBACisvLyBTUERYLUxpY2Vuc2Ut SWRlbnRpZmllcjogR1BMLTIuMC1vci1sYXRlcgorLyoKKyAqIFNNMyB1c2luZyB0aGUgUklTQy1W IHZlY3RvciBjcnlwdG8gZXh0ZW5zaW9ucworICoKKyAqIENvcHlyaWdodCAoQykgMjAyMyBWUlVM TCBHbWJICisgKiBBdXRob3I6IEhlaWtvIFN0dWVibmVyIDxoZWlrby5zdHVlYm5lckB2cnVsbC5l dT4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgU2lGaXZlLCBJbmMuCisgKiBBdXRob3I6IEpl cnJ5IFNoaWggPGplcnJ5LnNoaWhAc2lmaXZlLmNvbT4KKyAqLworCisjaW5jbHVkZSA8YXNtL3Np bWQuaD4KKyNpbmNsdWRlIDxhc20vdmVjdG9yLmg+CisjaW5jbHVkZSA8Y3J5cHRvL2ludGVybmFs L2hhc2guaD4KKyNpbmNsdWRlIDxjcnlwdG8vaW50ZXJuYWwvc2ltZC5oPgorI2luY2x1ZGUgPGNy eXB0by9zbTNfYmFzZS5oPgorI2luY2x1ZGUgPGxpbnV4L2xpbmthZ2UuaD4KKyNpbmNsdWRlIDxs aW51eC9tb2R1bGUuaD4KKworLyoKKyAqIE5vdGU6IHRoZSBhc20gZnVuY3Rpb24gb25seSB1c2Vz IHRoZSAnc3RhdGUnIGZpZWxkIG9mIHN0cnVjdCBzbTNfc3RhdGUuCisgKiBJdCBpcyBhc3N1bWVk IHRvIGJlIHRoZSBmaXJzdCBmaWVsZC4KKyAqLworYXNtbGlua2FnZSB2b2lkIHNtM190cmFuc2Zv cm1fenZrc2hfenZrYigKKwlzdHJ1Y3Qgc20zX3N0YXRlICpzdGF0ZSwgY29uc3QgdTggKmRhdGEs IGludCBudW1fYmxvY2tzKTsKKworc3RhdGljIGludCByaXNjdjY0X3NtM191cGRhdGUoc3RydWN0 IHNoYXNoX2Rlc2MgKmRlc2MsIGNvbnN0IHU4ICpkYXRhLAorCQkJICAgICAgdW5zaWduZWQgaW50 IGxlbikKK3sKKwkvKgorCSAqIEVuc3VyZSBzdHJ1Y3Qgc20zX3N0YXRlIGJlZ2lucyBkaXJlY3Rs eSB3aXRoIHRoZSBTTTMKKwkgKiAyNTYtYml0IGludGVybmFsIHN0YXRlLCBhcyB0aGlzIGlzIHdo YXQgdGhlIGFzbSBmdW5jdGlvbiBleHBlY3RzLgorCSAqLworCUJVSUxEX0JVR19PTihvZmZzZXRv ZihzdHJ1Y3Qgc20zX3N0YXRlLCBzdGF0ZSkgIT0gMCk7CisKKwlpZiAoY3J5cHRvX3NpbWRfdXNh YmxlKCkpIHsKKwkJa2VybmVsX3ZlY3Rvcl9iZWdpbigpOworCQlzbTNfYmFzZV9kb191cGRhdGUo ZGVzYywgZGF0YSwgbGVuLCBzbTNfdHJhbnNmb3JtX3p2a3NoX3p2a2IpOworCQlrZXJuZWxfdmVj dG9yX2VuZCgpOworCX0gZWxzZSB7CisJCXNtM191cGRhdGUoc2hhc2hfZGVzY19jdHgoZGVzYyks IGRhdGEsIGxlbik7CisJfQorCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHJpc2N2NjRfc20z X2ZpbnVwKHN0cnVjdCBzaGFzaF9kZXNjICpkZXNjLCBjb25zdCB1OCAqZGF0YSwKKwkJCSAgICAg dW5zaWduZWQgaW50IGxlbiwgdTggKm91dCkKK3sKKwlzdHJ1Y3Qgc20zX3N0YXRlICpjdHg7CisK KwlpZiAoY3J5cHRvX3NpbWRfdXNhYmxlKCkpIHsKKwkJa2VybmVsX3ZlY3Rvcl9iZWdpbigpOwor CQlpZiAobGVuKQorCQkJc20zX2Jhc2VfZG9fdXBkYXRlKGRlc2MsIGRhdGEsIGxlbiwKKwkJCQkJ ICAgc20zX3RyYW5zZm9ybV96dmtzaF96dmtiKTsKKwkJc20zX2Jhc2VfZG9fZmluYWxpemUoZGVz Yywgc20zX3RyYW5zZm9ybV96dmtzaF96dmtiKTsKKwkJa2VybmVsX3ZlY3Rvcl9lbmQoKTsKKwor CQlyZXR1cm4gc20zX2Jhc2VfZmluaXNoKGRlc2MsIG91dCk7CisJfQorCisJY3R4ID0gc2hhc2hf ZGVzY19jdHgoZGVzYyk7CisJaWYgKGxlbikKKwkJc20zX3VwZGF0ZShjdHgsIGRhdGEsIGxlbik7 CisJc20zX2ZpbmFsKGN0eCwgb3V0KTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHJp c2N2NjRfc20zX2ZpbmFsKHN0cnVjdCBzaGFzaF9kZXNjICpkZXNjLCB1OCAqb3V0KQoreworCXJl dHVybiByaXNjdjY0X3NtM19maW51cChkZXNjLCBOVUxMLCAwLCBvdXQpOworfQorCitzdGF0aWMg c3RydWN0IHNoYXNoX2FsZyByaXNjdjY0X3NtM19hbGcgPSB7CisJLmluaXQgPSBzbTNfYmFzZV9p bml0LAorCS51cGRhdGUgPSByaXNjdjY0X3NtM191cGRhdGUsCisJLmZpbmFsID0gcmlzY3Y2NF9z bTNfZmluYWwsCisJLmZpbnVwID0gcmlzY3Y2NF9zbTNfZmludXAsCisJLmRlc2NzaXplID0gc2l6 ZW9mKHN0cnVjdCBzbTNfc3RhdGUpLAorCS5kaWdlc3RzaXplID0gU00zX0RJR0VTVF9TSVpFLAor CS5iYXNlID0geworCQkuY3JhX2Jsb2Nrc2l6ZSA9IFNNM19CTE9DS19TSVpFLAorCQkuY3JhX3By aW9yaXR5ID0gMzAwLAorCQkuY3JhX25hbWUgPSAic20zIiwKKwkJLmNyYV9kcml2ZXJfbmFtZSA9 ICJzbTMtcmlzY3Y2NC16dmtzaC16dmtiIiwKKwkJLmNyYV9tb2R1bGUgPSBUSElTX01PRFVMRSwK Kwl9LAorfTsKKworc3RhdGljIGludCBfX2luaXQgcmlzY3Y2NF9zbTNfbW9kX2luaXQodm9pZCkK K3sKKwlpZiAocmlzY3ZfaXNhX2V4dGVuc2lvbl9hdmFpbGFibGUoTlVMTCwgWlZLU0gpICYmCisJ ICAgIHJpc2N2X2lzYV9leHRlbnNpb25fYXZhaWxhYmxlKE5VTEwsIFpWS0IpICYmCisJICAgIHJp c2N2X3ZlY3Rvcl92bGVuKCkgPj0gMTI4KQorCQlyZXR1cm4gY3J5cHRvX3JlZ2lzdGVyX3NoYXNo KCZyaXNjdjY0X3NtM19hbGcpOworCisJcmV0dXJuIC1FTk9ERVY7Cit9CisKK3N0YXRpYyB2b2lk IF9fZXhpdCByaXNjdjY0X3NtM19tb2RfZXhpdCh2b2lkKQoreworCWNyeXB0b191bnJlZ2lzdGVy X3NoYXNoKCZyaXNjdjY0X3NtM19hbGcpOworfQorCittb2R1bGVfaW5pdChyaXNjdjY0X3NtM19t b2RfaW5pdCk7Cittb2R1bGVfZXhpdChyaXNjdjY0X3NtM19tb2RfZXhpdCk7CisKK01PRFVMRV9E RVNDUklQVElPTigiU00zIChSSVNDLVYgYWNjZWxlcmF0ZWQpIik7CitNT0RVTEVfQVVUSE9SKCJI ZWlrbyBTdHVlYm5lciA8aGVpa28uc3R1ZWJuZXJAdnJ1bGwuZXU+Iik7CitNT0RVTEVfTElDRU5T RSgiR1BMIik7CitNT0RVTEVfQUxJQVNfQ1JZUFRPKCJzbTMiKTsKZGlmZiAtLWdpdCBhL2FyY2gv cmlzY3YvY3J5cHRvL3NtMy1yaXNjdjY0LXp2a3NoLXp2a2IuUyBiL2FyY2gvcmlzY3YvY3J5cHRv L3NtMy1yaXNjdjY0LXp2a3NoLXp2a2IuUwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwLi5hMmI2NWQ5NjFjMDRhCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9yaXNjdi9j cnlwdG8vc20zLXJpc2N2NjQtenZrc2gtenZrYi5TCkBAIC0wLDAgKzEsMTIzIEBACisvKiBTUERY LUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMCBPUiBCU0QtMi1DbGF1c2UgKi8KKy8vCisv LyBUaGlzIGZpbGUgaXMgZHVhbC1saWNlbnNlZCwgbWVhbmluZyB0aGF0IHlvdSBjYW4gdXNlIGl0 IHVuZGVyIHlvdXIKKy8vIGNob2ljZSBvZiBlaXRoZXIgb2YgdGhlIGZvbGxvd2luZyB0d28gbGlj ZW5zZXM6CisvLworLy8gQ29weXJpZ2h0IDIwMjMgVGhlIE9wZW5TU0wgUHJvamVjdCBBdXRob3Jz LiBBbGwgUmlnaHRzIFJlc2VydmVkLgorLy8KKy8vIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUg TGljZW5zZSAyLjAgKHRoZSAiTGljZW5zZSIpLiBZb3UgY2FuIG9idGFpbgorLy8gYSBjb3B5IGlu IHRoZSBmaWxlIExJQ0VOU0UgaW4gdGhlIHNvdXJjZSBkaXN0cmlidXRpb24gb3IgYXQKKy8vIGh0 dHBzOi8vd3d3Lm9wZW5zc2wub3JnL3NvdXJjZS9saWNlbnNlLmh0bWwKKy8vCisvLyBvcgorLy8K Ky8vIENvcHlyaWdodCAoYykgMjAyMywgQ2hyaXN0b3BoIE3DvGxsbmVyIDxjaHJpc3RvcGgubXVl bGxuZXJAdnJ1bGwuZXU+CisvLyBDb3B5cmlnaHQgKGMpIDIwMjMsIEplcnJ5IFNoaWggPGplcnJ5 LnNoaWhAc2lmaXZlLmNvbT4KKy8vIENvcHlyaWdodCAyMDI0IEdvb2dsZSBMTEMKKy8vIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisvLworLy8gUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisvLyBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKy8vIGFyZSBt ZXQ6CisvLyAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhl IGFib3ZlIGNvcHlyaWdodAorLy8gICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorLy8gMi4gUmVkaXN0cmlidXRpb25zIGluIGJp bmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKy8vICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBp biB0aGUKKy8vICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRl ZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisvLworLy8gVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworLy8gIkFTIElTIiBB TkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QK Ky8vIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUgorLy8gQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKy8vIE9XTkVSIE9SIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorLy8gU1BF Q0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVAorLy8gTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsCisvLyBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKy8vIFRIRU9SWSBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKy8v IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRQorLy8gT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKworLy8gVGhlIGdlbmVyYXRlZCBjb2RlIG9m IHRoaXMgZmlsZSBkZXBlbmRzIG9uIHRoZSBmb2xsb3dpbmcgUklTQy1WIGV4dGVuc2lvbnM6Cisv LyAtIFJWNjRJCisvLyAtIFJJU0MtViBWZWN0b3IgKCdWJykgd2l0aCBWTEVOID49IDEyOAorLy8g LSBSSVNDLVYgVmVjdG9yIFNNMyBTZWN1cmUgSGFzaCBleHRlbnNpb24gKCdadmtzaCcpCisvLyAt IFJJU0MtViBWZWN0b3IgQ3J5cHRvZ3JhcGh5IEJpdC1tYW5pcHVsYXRpb24gZXh0ZW5zaW9uICgn WnZrYicpCisKKyNpbmNsdWRlIDxsaW51eC9jZmlfdHlwZXMuaD4KKworLnRleHQKKy5vcHRpb24g YXJjaCwgK3p2a3NoLCArenZrYgorCisjZGVmaW5lIFNUQVRFUAkJYTAKKyNkZWZpbmUgREFUQQkJ YTEKKyNkZWZpbmUgTlVNX0JMT0NLUwlhMgorCisjZGVmaW5lIFNUQVRFCQl2MAkvLyBMTVVMPTIK KyNkZWZpbmUgUFJFVl9TVEFURQl2MgkvLyBMTVVMPTIKKyNkZWZpbmUgVzAJCXY0CS8vIExNVUw9 MgorI2RlZmluZSBXMQkJdjYJLy8gTE1VTD0yCisjZGVmaW5lIFZUTVAJCXY4CS8vIExNVUw9Mgor CisubWFjcm8Jc20zXzhyb3VuZHMJaSwgdzAsIHcxCisJLy8gRG8gNCByb3VuZHMgdXNpbmcgV197 MCtpfS4uV197NytpfS4KKwl2c20zYy52aQlTVEFURSwgXHcwLCBcaSArIDAKKwl2c2xpZGVkb3du LnZpCVZUTVAsIFx3MCwgMgorCXZzbTNjLnZpCVNUQVRFLCBWVE1QLCBcaSArIDEKKworCS8vIENv bXB1dGUgV197NCtpfS4uV197MTEraX0uCisJdnNsaWRlZG93bi52aQlWVE1QLCBcdzAsIDQKKwl2 c2xpZGV1cC52aQlWVE1QLCBcdzEsIDQKKworCS8vIERvIDQgcm91bmRzIHVzaW5nIFdfezQraX0u LldfezExK2l9LgorCXZzbTNjLnZpCVNUQVRFLCBWVE1QLCBcaSArIDIKKwl2c2xpZGVkb3duLnZp CVZUTVAsIFZUTVAsIDIKKwl2c20zYy52aQlTVEFURSwgVlRNUCwgXGkgKyAzCisKKy5pZiBcaSA8 IDI4CisJLy8gQ29tcHV0ZSBXX3sxNitpfS4uV197MjMraX0uCisJdnNtM21lLnZ2CVx3MCwgXHcx LCBcdzAKKy5lbmRpZgorCS8vIEZvciB0aGUgbmV4dCA4IHJvdW5kcywgdzAgYW5kIHcxIGFyZSBz d2FwcGVkLgorLmVuZG0KKworLy8gdm9pZCBzbTNfdHJhbnNmb3JtX3p2a3NoX3p2a2IodTMyIHN0 YXRlWzhdLCBjb25zdCB1OCAqZGF0YSwgaW50IG51bV9ibG9ja3MpOworU1lNX1RZUEVEX0ZVTkNf U1RBUlQoc20zX3RyYW5zZm9ybV96dmtzaF96dmtiKQorCisJLy8gTG9hZCB0aGUgc3RhdGUgYW5k IGVuZGlhbi1zd2FwIGVhY2ggMzItYml0IHdvcmQuCisJdnNldGl2bGkJemVybywgOCwgZTMyLCBt MiwgdGEsIG1hCisJdmxlMzIudgkJU1RBVEUsIChTVEFURVApCisJdnJldjgudgkJU1RBVEUsIFNU QVRFCisKKy5MbmV4dF9ibG9jazoKKwlhZGRpCQlOVU1fQkxPQ0tTLCBOVU1fQkxPQ0tTLCAtMQor CisJLy8gU2F2ZSB0aGUgcHJldmlvdXMgc3RhdGUsIGFzIGl0J3MgbmVlZGVkIGxhdGVyLgorCXZt di52LnYJCVBSRVZfU1RBVEUsIFNUQVRFCisKKwkvLyBMb2FkIHRoZSBuZXh0IDUxMi1iaXQgbWVz c2FnZSBibG9jayBpbnRvIFcwLVcxLgorCXZsZTMyLnYJCVcwLCAoREFUQSkKKwlhZGRpCQlEQVRB LCBEQVRBLCAzMgorCXZsZTMyLnYJCVcxLCAoREFUQSkKKwlhZGRpCQlEQVRBLCBEQVRBLCAzMgor CisJLy8gRG8gdGhlIDY0IHJvdW5kcyBvZiBTTTMuCisJc20zXzhyb3VuZHMJMCwgVzAsIFcxCisJ c20zXzhyb3VuZHMJNCwgVzEsIFcwCisJc20zXzhyb3VuZHMJOCwgVzAsIFcxCisJc20zXzhyb3Vu ZHMJMTIsIFcxLCBXMAorCXNtM184cm91bmRzCTE2LCBXMCwgVzEKKwlzbTNfOHJvdW5kcwkyMCwg VzEsIFcwCisJc20zXzhyb3VuZHMJMjQsIFcwLCBXMQorCXNtM184cm91bmRzCTI4LCBXMSwgVzAK KworCS8vIFhPUiBpbiB0aGUgcHJldmlvdXMgc3RhdGUuCisJdnhvci52dgkJU1RBVEUsIFNUQVRF LCBQUkVWX1NUQVRFCisKKwkvLyBSZXBlYXQgaWYgbW9yZSBibG9ja3MgcmVtYWluLgorCWJuZXoJ CU5VTV9CTE9DS1MsIC5MbmV4dF9ibG9jaworCisJLy8gU3RvcmUgdGhlIG5ldyBzdGF0ZSBhbmQg cmV0dXJuLgorCXZyZXY4LnYJCVNUQVRFLCBTVEFURQorCXZzZTMyLnYJCVNUQVRFLCAoU1RBVEVQ KQorCXJldAorU1lNX0ZVTkNfRU5EKHNtM190cmFuc2Zvcm1fenZrc2hfenZrYikKLS0gCjIuNDMu MAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4 LXJpc2N2IG1haWxpbmcgbGlzdApsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6 Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtcmlzY3YK