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 207A563CC; Mon, 22 Jan 2024 00:23:04 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1705882984; cv=none; b=fpkMisJgdZlIUYow+UoBPmyyKBShQ+VRaccJQp5u6trpqGdaqM6TpOD9Jkp6Wu1+U0Lbpg4UEfcuNi9QsieOwYjcUcAAtf89sWo+ot3Jf8oia4EFgRgof6LM1Dbymo4TLPrt/QPbOId1VRerbAiIA8xlkwfCcy+GmfRtLdWo830= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1705882984; c=relaxed/simple; bh=Ei0WLAOtuylbVJI7bbHk34A8CQdflN66b55iymb2Bh0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=nj74oXXP5ltwZJL4xHE9MkMLdGBalabEpmlDqkLXkld0N4X+uCV5YsQ0P6F5R/vl95jX5siYKmG2HOIAyQVNAgScGeyJoxPJ/qQqWg9GdZrOBLDjoVCiM57/IyhivwcwzIZOQMLzwtFjApWrgF6hnJRpB4DIxHCGoaI42q3UfeY= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=d34f8+8c; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="d34f8+8c" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6A357C433F1; Mon, 22 Jan 2024 00:23:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1705882984; bh=Ei0WLAOtuylbVJI7bbHk34A8CQdflN66b55iymb2Bh0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=d34f8+8cTYWUsDeWf2F881a6+n13yKxGXK6q/+8ATbW6NL8MR2Jc2NvchvBZVxfgz FnnIzRi22DVKVMiigvF1Ql+g5CAaKz/RkiCrCrUPu3X0holrAnhIHrLfb0n5DcE74R M+3oVcJQ3IqBoVGcrFR/4hOx5brrVVaAjvc+Is7UoHXeY7XtzBQfwLoWnL/738f1Fz ZKhs0M8Cq43kIuzFERRTGMoDc1jXjUczmvq9VpbS7Dwre4VZT/8HxpBdpuCwzZo8M0 K82onB+nKLVjPazR54UoYTznGzVgAxzWqFyJpANjhctT79xoW39QzC0mNDsG39LpCB doPc8CnP7l/5g== From: Eric Biggers To: linux-crypto@vger.kernel.org, linux-riscv@lists.infradead.org Cc: linux-kernel@vger.kernel.org, Albert Ou , Andy Chiu , Ard Biesheuvel , =?UTF-8?q?Christoph=20M=C3=BCllner?= , Heiko Stuebner , Jerry Shih , Palmer Dabbelt , Paul Walmsley , Phoebe Chen , hongrong.hsu@sifive.com, Heiko Stuebner Subject: [PATCH v3 09/10] crypto: riscv - add vector crypto accelerated SM3 Date: Sun, 21 Jan 2024 16:19:20 -0800 Message-ID: <20240122002024.27477-10-ebiggers@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240122002024.27477-1-ebiggers@kernel.org> References: <20240122002024.27477-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 356a931db0eb7..da48977e96f58 100644 --- a/arch/riscv/crypto/Makefile +++ b/arch/riscv/crypto/Makefile @@ -8,10 +8,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 332E6C47DD9 for ; Mon, 22 Jan 2024 00:23:32 +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=l6CkhyPGV2eoYYg/HLRAp9T/GAkk6n0lorcHd9y0JCo=; b=gikD7ay+xs31j+ MP66YqfBtasOeHk3bEeZXdmioaxPiEGE7ZHd3hbVwdSH400CE80L5LJwnY+3ctMgj/b+DILcxkPw1 9ydB2/0nh5BaIfwY2o3nHdwF+IGSnIuaWYMxemjHqMdsPnUStfDRdqAFp3XLHgQX8qt5q8xLIY0e6 YiblOl6oXqYUPlhJC0IGKa0Mo+/Rf3JuNFeFPu9q2qGwFqVLg6LVSYxLd0JNnsWWcwtJF5zAp4Gzm klN0KfZ3WvNJWOFzHewUrVHeyXMu0KWMBrljgIpUqThJwY6ATZ7ghzoU4DqBy51l/m7oIagc+1qAf 5Sx/tX2UYlinDIGoxaQg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1rRi5p-00AFq9-1A; Mon, 22 Jan 2024 00:23:13 +0000 Received: from sin.source.kernel.org ([145.40.73.55]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1rRi5i-00AFnh-1Q for linux-riscv@lists.infradead.org; Mon, 22 Jan 2024 00:23:11 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by sin.source.kernel.org (Postfix) with ESMTP id ABEEFCE28AF; Mon, 22 Jan 2024 00:23:04 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6A357C433F1; Mon, 22 Jan 2024 00:23:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1705882984; bh=Ei0WLAOtuylbVJI7bbHk34A8CQdflN66b55iymb2Bh0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=d34f8+8cTYWUsDeWf2F881a6+n13yKxGXK6q/+8ATbW6NL8MR2Jc2NvchvBZVxfgz FnnIzRi22DVKVMiigvF1Ql+g5CAaKz/RkiCrCrUPu3X0holrAnhIHrLfb0n5DcE74R M+3oVcJQ3IqBoVGcrFR/4hOx5brrVVaAjvc+Is7UoHXeY7XtzBQfwLoWnL/738f1Fz ZKhs0M8Cq43kIuzFERRTGMoDc1jXjUczmvq9VpbS7Dwre4VZT/8HxpBdpuCwzZo8M0 K82onB+nKLVjPazR54UoYTznGzVgAxzWqFyJpANjhctT79xoW39QzC0mNDsG39LpCB doPc8CnP7l/5g== From: Eric Biggers To: linux-crypto@vger.kernel.org, linux-riscv@lists.infradead.org Cc: linux-kernel@vger.kernel.org, Albert Ou , Andy Chiu , Ard Biesheuvel , =?UTF-8?q?Christoph=20M=C3=BCllner?= , Heiko Stuebner , Jerry Shih , Palmer Dabbelt , Paul Walmsley , Phoebe Chen , hongrong.hsu@sifive.com, Heiko Stuebner Subject: [PATCH v3 09/10] crypto: riscv - add vector crypto accelerated SM3 Date: Sun, 21 Jan 2024 16:19:20 -0800 Message-ID: <20240122002024.27477-10-ebiggers@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240122002024.27477-1-ebiggers@kernel.org> References: <20240122002024.27477-1-ebiggers@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240121_162306_845000_EB755837 X-CRM114-Status: GOOD ( 28.82 ) 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 ZmlsZSBiL2FyY2gvcmlzY3YvY3J5cHRvL01ha2VmaWxlCmluZGV4IDM1NmE5MzFkYjBlYjcuLmRh NDg5NzdlOTZmNTggMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3YvY3J5cHRvL01ha2VmaWxlCisrKyBi L2FyY2gvcmlzY3YvY3J5cHRvL01ha2VmaWxlCkBAIC04LDEwICs4LDEzIEBAIG9iai0kKENPTkZJ R19DUllQVE9fQ0hBQ0hBX1JJU0NWNjQpICs9IGNoYWNoYS1yaXNjdjY0Lm8KIGNoYWNoYS1yaXNj djY0LXkgOj0gY2hhY2hhLXJpc2N2NjQtZ2x1ZS5vIGNoYWNoYS1yaXNjdjY0LXp2a2IubwogCiBv YmotJChDT05GSUdfQ1JZUFRPX0dIQVNIX1JJU0NWNjQpICs9IGdoYXNoLXJpc2N2NjQubwogZ2hh c2gtcmlzY3Y2NC15IDo9IGdoYXNoLXJpc2N2NjQtZ2x1ZS5vIGdoYXNoLXJpc2N2NjQtenZrZy5v CiAKIG9iai0kKENPTkZJR19DUllQVE9fU0hBMjU2X1JJU0NWNjQpICs9IHNoYTI1Ni1yaXNjdjY0 Lm8KIHNoYTI1Ni1yaXNjdjY0LXkgOj0gc2hhMjU2LXJpc2N2NjQtZ2x1ZS5vIHNoYTI1Ni1yaXNj djY0LXp2a25oYV9vcl96dmtuaGItenZrYi5vCiAKIG9iai0kKENPTkZJR19DUllQVE9fU0hBNTEy X1JJU0NWNjQpICs9IHNoYTUxMi1yaXNjdjY0Lm8KIHNoYTUxMi1yaXNjdjY0LXkgOj0gc2hhNTEy LXJpc2N2NjQtZ2x1ZS5vIHNoYTUxMi1yaXNjdjY0LXp2a25oYi16dmtiLm8KKworb2JqLSQoQ09O RklHX0NSWVBUT19TTTNfUklTQ1Y2NCkgKz0gc20zLXJpc2N2NjQubworc20zLXJpc2N2NjQteSA6 PSBzbTMtcmlzY3Y2NC1nbHVlLm8gc20zLXJpc2N2NjQtenZrc2gtenZrYi5vCmRpZmYgLS1naXQg YS9hcmNoL3Jpc2N2L2NyeXB0by9zbTMtcmlzY3Y2NC1nbHVlLmMgYi9hcmNoL3Jpc2N2L2NyeXB0 by9zbTMtcmlzY3Y2NC1nbHVlLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMC4uZTE3MzdhOTcwYzdjOQotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvcmlzY3YvY3J5cHRv L3NtMy1yaXNjdjY0LWdsdWUuYwpAQCAtMCwwICsxLDExMiBAQAorLy8gU1BEWC1MaWNlbnNlLUlk ZW50aWZpZXI6IEdQTC0yLjAtb3ItbGF0ZXIKKy8qCisgKiBTTTMgdXNpbmcgdGhlIFJJU0MtViB2 ZWN0b3IgY3J5cHRvIGV4dGVuc2lvbnMKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgVlJVTEwg R21iSAorICogQXV0aG9yOiBIZWlrbyBTdHVlYm5lciA8aGVpa28uc3R1ZWJuZXJAdnJ1bGwuZXU+ CisgKgorICogQ29weXJpZ2h0IChDKSAyMDIzIFNpRml2ZSwgSW5jLgorICogQXV0aG9yOiBKZXJy eSBTaGloIDxqZXJyeS5zaGloQHNpZml2ZS5jb20+CisgKi8KKworI2luY2x1ZGUgPGFzbS9zaW1k Lmg+CisjaW5jbHVkZSA8YXNtL3ZlY3Rvci5oPgorI2luY2x1ZGUgPGNyeXB0by9pbnRlcm5hbC9o YXNoLmg+CisjaW5jbHVkZSA8Y3J5cHRvL2ludGVybmFsL3NpbWQuaD4KKyNpbmNsdWRlIDxjcnlw dG8vc20zX2Jhc2UuaD4KKyNpbmNsdWRlIDxsaW51eC9saW5rYWdlLmg+CisjaW5jbHVkZSA8bGlu dXgvbW9kdWxlLmg+CisKKy8qCisgKiBOb3RlOiB0aGUgYXNtIGZ1bmN0aW9uIG9ubHkgdXNlcyB0 aGUgJ3N0YXRlJyBmaWVsZCBvZiBzdHJ1Y3Qgc20zX3N0YXRlLgorICogSXQgaXMgYXNzdW1lZCB0 byBiZSB0aGUgZmlyc3QgZmllbGQuCisgKi8KK2FzbWxpbmthZ2Ugdm9pZCBzbTNfdHJhbnNmb3Jt X3p2a3NoX3p2a2IoCisJc3RydWN0IHNtM19zdGF0ZSAqc3RhdGUsIGNvbnN0IHU4ICpkYXRhLCBp bnQgbnVtX2Jsb2Nrcyk7CisKK3N0YXRpYyBpbnQgcmlzY3Y2NF9zbTNfdXBkYXRlKHN0cnVjdCBz aGFzaF9kZXNjICpkZXNjLCBjb25zdCB1OCAqZGF0YSwKKwkJCSAgICAgIHVuc2lnbmVkIGludCBs ZW4pCit7CisJLyoKKwkgKiBFbnN1cmUgc3RydWN0IHNtM19zdGF0ZSBiZWdpbnMgZGlyZWN0bHkg d2l0aCB0aGUgU00zCisJICogMjU2LWJpdCBpbnRlcm5hbCBzdGF0ZSwgYXMgdGhpcyBpcyB3aGF0 IHRoZSBhc20gZnVuY3Rpb24gZXhwZWN0cy4KKwkgKi8KKwlCVUlMRF9CVUdfT04ob2Zmc2V0b2Yo c3RydWN0IHNtM19zdGF0ZSwgc3RhdGUpICE9IDApOworCisJaWYgKGNyeXB0b19zaW1kX3VzYWJs ZSgpKSB7CisJCWtlcm5lbF92ZWN0b3JfYmVnaW4oKTsKKwkJc20zX2Jhc2VfZG9fdXBkYXRlKGRl c2MsIGRhdGEsIGxlbiwgc20zX3RyYW5zZm9ybV96dmtzaF96dmtiKTsKKwkJa2VybmVsX3ZlY3Rv cl9lbmQoKTsKKwl9IGVsc2UgeworCQlzbTNfdXBkYXRlKHNoYXNoX2Rlc2NfY3R4KGRlc2MpLCBk YXRhLCBsZW4pOworCX0KKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCByaXNjdjY0X3NtM19m aW51cChzdHJ1Y3Qgc2hhc2hfZGVzYyAqZGVzYywgY29uc3QgdTggKmRhdGEsCisJCQkgICAgIHVu c2lnbmVkIGludCBsZW4sIHU4ICpvdXQpCit7CisJc3RydWN0IHNtM19zdGF0ZSAqY3R4OworCisJ aWYgKGNyeXB0b19zaW1kX3VzYWJsZSgpKSB7CisJCWtlcm5lbF92ZWN0b3JfYmVnaW4oKTsKKwkJ aWYgKGxlbikKKwkJCXNtM19iYXNlX2RvX3VwZGF0ZShkZXNjLCBkYXRhLCBsZW4sCisJCQkJCSAg IHNtM190cmFuc2Zvcm1fenZrc2hfenZrYik7CisJCXNtM19iYXNlX2RvX2ZpbmFsaXplKGRlc2Ms IHNtM190cmFuc2Zvcm1fenZrc2hfenZrYik7CisJCWtlcm5lbF92ZWN0b3JfZW5kKCk7CisKKwkJ cmV0dXJuIHNtM19iYXNlX2ZpbmlzaChkZXNjLCBvdXQpOworCX0KKworCWN0eCA9IHNoYXNoX2Rl c2NfY3R4KGRlc2MpOworCWlmIChsZW4pCisJCXNtM191cGRhdGUoY3R4LCBkYXRhLCBsZW4pOwor CXNtM19maW5hbChjdHgsIG91dCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCByaXNj djY0X3NtM19maW5hbChzdHJ1Y3Qgc2hhc2hfZGVzYyAqZGVzYywgdTggKm91dCkKK3sKKwlyZXR1 cm4gcmlzY3Y2NF9zbTNfZmludXAoZGVzYywgTlVMTCwgMCwgb3V0KTsKK30KKworc3RhdGljIHN0 cnVjdCBzaGFzaF9hbGcgcmlzY3Y2NF9zbTNfYWxnID0geworCS5pbml0ID0gc20zX2Jhc2VfaW5p dCwKKwkudXBkYXRlID0gcmlzY3Y2NF9zbTNfdXBkYXRlLAorCS5maW5hbCA9IHJpc2N2NjRfc20z X2ZpbmFsLAorCS5maW51cCA9IHJpc2N2NjRfc20zX2ZpbnVwLAorCS5kZXNjc2l6ZSA9IHNpemVv ZihzdHJ1Y3Qgc20zX3N0YXRlKSwKKwkuZGlnZXN0c2l6ZSA9IFNNM19ESUdFU1RfU0laRSwKKwku YmFzZSA9IHsKKwkJLmNyYV9ibG9ja3NpemUgPSBTTTNfQkxPQ0tfU0laRSwKKwkJLmNyYV9wcmlv cml0eSA9IDMwMCwKKwkJLmNyYV9uYW1lID0gInNtMyIsCisJCS5jcmFfZHJpdmVyX25hbWUgPSAi c20zLXJpc2N2NjQtenZrc2gtenZrYiIsCisJCS5jcmFfbW9kdWxlID0gVEhJU19NT0RVTEUsCisJ fSwKK307CisKK3N0YXRpYyBpbnQgX19pbml0IHJpc2N2NjRfc20zX21vZF9pbml0KHZvaWQpCit7 CisJaWYgKHJpc2N2X2lzYV9leHRlbnNpb25fYXZhaWxhYmxlKE5VTEwsIFpWS1NIKSAmJgorCSAg ICByaXNjdl9pc2FfZXh0ZW5zaW9uX2F2YWlsYWJsZShOVUxMLCBaVktCKSAmJgorCSAgICByaXNj dl92ZWN0b3JfdmxlbigpID49IDEyOCkKKwkJcmV0dXJuIGNyeXB0b19yZWdpc3Rlcl9zaGFzaCgm cmlzY3Y2NF9zbTNfYWxnKTsKKworCXJldHVybiAtRU5PREVWOworfQorCitzdGF0aWMgdm9pZCBf X2V4aXQgcmlzY3Y2NF9zbTNfbW9kX2V4aXQodm9pZCkKK3sKKwljcnlwdG9fdW5yZWdpc3Rlcl9z aGFzaCgmcmlzY3Y2NF9zbTNfYWxnKTsKK30KKworbW9kdWxlX2luaXQocmlzY3Y2NF9zbTNfbW9k X2luaXQpOworbW9kdWxlX2V4aXQocmlzY3Y2NF9zbTNfbW9kX2V4aXQpOworCitNT0RVTEVfREVT Q1JJUFRJT04oIlNNMyAoUklTQy1WIGFjY2VsZXJhdGVkKSIpOworTU9EVUxFX0FVVEhPUigiSGVp a28gU3R1ZWJuZXIgPGhlaWtvLnN0dWVibmVyQHZydWxsLmV1PiIpOworTU9EVUxFX0xJQ0VOU0Uo IkdQTCIpOworTU9EVUxFX0FMSUFTX0NSWVBUTygic20zIik7CmRpZmYgLS1naXQgYS9hcmNoL3Jp c2N2L2NyeXB0by9zbTMtcmlzY3Y2NC16dmtzaC16dmtiLlMgYi9hcmNoL3Jpc2N2L2NyeXB0by9z bTMtcmlzY3Y2NC16dmtzaC16dmtiLlMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMC4uYTJiNjVkOTYxYzA0YQotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvcmlzY3YvY3J5 cHRvL3NtMy1yaXNjdjY0LXp2a3NoLXp2a2IuUwpAQCAtMCwwICsxLDEyMyBAQAorLyogU1BEWC1M aWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjAgT1IgQlNELTItQ2xhdXNlICovCisvLworLy8g VGhpcyBmaWxlIGlzIGR1YWwtbGljZW5zZWQsIG1lYW5pbmcgdGhhdCB5b3UgY2FuIHVzZSBpdCB1 bmRlciB5b3VyCisvLyBjaG9pY2Ugb2YgZWl0aGVyIG9mIHRoZSBmb2xsb3dpbmcgdHdvIGxpY2Vu c2VzOgorLy8KKy8vIENvcHlyaWdodCAyMDIzIFRoZSBPcGVuU1NMIFByb2plY3QgQXV0aG9ycy4g QWxsIFJpZ2h0cyBSZXNlcnZlZC4KKy8vCisvLyBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExp Y2Vuc2UgMi4wICh0aGUgIkxpY2Vuc2UiKS4gWW91IGNhbiBvYnRhaW4KKy8vIGEgY29weSBpbiB0 aGUgZmlsZSBMSUNFTlNFIGluIHRoZSBzb3VyY2UgZGlzdHJpYnV0aW9uIG9yIGF0CisvLyBodHRw czovL3d3dy5vcGVuc3NsLm9yZy9zb3VyY2UvbGljZW5zZS5odG1sCisvLworLy8gb3IKKy8vCisv LyBDb3B5cmlnaHQgKGMpIDIwMjMsIENocmlzdG9waCBNw7xsbG5lciA8Y2hyaXN0b3BoLm11ZWxs bmVyQHZydWxsLmV1PgorLy8gQ29weXJpZ2h0IChjKSAyMDIzLCBKZXJyeSBTaGloIDxqZXJyeS5z aGloQHNpZml2ZS5jb20+CisvLyBDb3B5cmlnaHQgMjAyNCBHb29nbGUgTExDCisvLyBBbGwgcmln aHRzIHJlc2VydmVkLgorLy8KKy8vIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorLy8gbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisvLyBhcmUgbWV0 OgorLy8gMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKy8vICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKy8vIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5h cnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisvLyAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4g dGhlCisvLyAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQg d2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorLy8KKy8vIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKy8vICJBUyBJUyIgQU5E IEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisv LyBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IKKy8vIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJ TiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisvLyBPV05FUiBPUiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKy8vIFNQRUNJ QUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QKKy8vIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLAorLy8gREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisvLyBUSEVPUlkgT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisvLyAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKKy8vIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisKKy8vIFRoZSBnZW5lcmF0ZWQgY29kZSBvZiB0 aGlzIGZpbGUgZGVwZW5kcyBvbiB0aGUgZm9sbG93aW5nIFJJU0MtViBleHRlbnNpb25zOgorLy8g LSBSVjY0SQorLy8gLSBSSVNDLVYgVmVjdG9yICgnVicpIHdpdGggVkxFTiA+PSAxMjgKKy8vIC0g UklTQy1WIFZlY3RvciBTTTMgU2VjdXJlIEhhc2ggZXh0ZW5zaW9uICgnWnZrc2gnKQorLy8gLSBS SVNDLVYgVmVjdG9yIENyeXB0b2dyYXBoeSBCaXQtbWFuaXB1bGF0aW9uIGV4dGVuc2lvbiAoJ1p2 a2InKQorCisjaW5jbHVkZSA8bGludXgvY2ZpX3R5cGVzLmg+CisKKy50ZXh0Cisub3B0aW9uIGFy Y2gsICt6dmtzaCwgK3p2a2IKKworI2RlZmluZSBTVEFURVAJCWEwCisjZGVmaW5lIERBVEEJCWEx CisjZGVmaW5lIE5VTV9CTE9DS1MJYTIKKworI2RlZmluZSBTVEFURQkJdjAJLy8gTE1VTD0yCisj ZGVmaW5lIFBSRVZfU1RBVEUJdjIJLy8gTE1VTD0yCisjZGVmaW5lIFcwCQl2NAkvLyBMTVVMPTIK KyNkZWZpbmUgVzEJCXY2CS8vIExNVUw9MgorI2RlZmluZSBWVE1QCQl2OAkvLyBMTVVMPTIKKwor Lm1hY3JvCXNtM184cm91bmRzCWksIHcwLCB3MQorCS8vIERvIDQgcm91bmRzIHVzaW5nIFdfezAr aX0uLldfezcraX0uCisJdnNtM2MudmkJU1RBVEUsIFx3MCwgXGkgKyAwCisJdnNsaWRlZG93bi52 aQlWVE1QLCBcdzAsIDIKKwl2c20zYy52aQlTVEFURSwgVlRNUCwgXGkgKyAxCisKKwkvLyBDb21w dXRlIFdfezQraX0uLldfezExK2l9LgorCXZzbGlkZWRvd24udmkJVlRNUCwgXHcwLCA0CisJdnNs aWRldXAudmkJVlRNUCwgXHcxLCA0CisKKwkvLyBEbyA0IHJvdW5kcyB1c2luZyBXX3s0K2l9Li5X X3sxMStpfS4KKwl2c20zYy52aQlTVEFURSwgVlRNUCwgXGkgKyAyCisJdnNsaWRlZG93bi52aQlW VE1QLCBWVE1QLCAyCisJdnNtM2MudmkJU1RBVEUsIFZUTVAsIFxpICsgMworCisuaWYgXGkgPCAy OAorCS8vIENvbXB1dGUgV197MTYraX0uLldfezIzK2l9LgorCXZzbTNtZS52dglcdzAsIFx3MSwg XHcwCisuZW5kaWYKKwkvLyBGb3IgdGhlIG5leHQgOCByb3VuZHMsIHcwIGFuZCB3MSBhcmUgc3dh cHBlZC4KKy5lbmRtCisKKy8vIHZvaWQgc20zX3RyYW5zZm9ybV96dmtzaF96dmtiKHUzMiBzdGF0 ZVs4XSwgY29uc3QgdTggKmRhdGEsIGludCBudW1fYmxvY2tzKTsKK1NZTV9UWVBFRF9GVU5DX1NU QVJUKHNtM190cmFuc2Zvcm1fenZrc2hfenZrYikKKworCS8vIExvYWQgdGhlIHN0YXRlIGFuZCBl bmRpYW4tc3dhcCBlYWNoIDMyLWJpdCB3b3JkLgorCXZzZXRpdmxpCXplcm8sIDgsIGUzMiwgbTIs IHRhLCBtYQorCXZsZTMyLnYJCVNUQVRFLCAoU1RBVEVQKQorCXZyZXY4LnYJCVNUQVRFLCBTVEFU RQorCisuTG5leHRfYmxvY2s6CisJYWRkaQkJTlVNX0JMT0NLUywgTlVNX0JMT0NLUywgLTEKKwor CS8vIFNhdmUgdGhlIHByZXZpb3VzIHN0YXRlLCBhcyBpdCdzIG5lZWRlZCBsYXRlci4KKwl2bXYu di52CQlQUkVWX1NUQVRFLCBTVEFURQorCisJLy8gTG9hZCB0aGUgbmV4dCA1MTItYml0IG1lc3Nh Z2UgYmxvY2sgaW50byBXMC1XMS4KKwl2bGUzMi52CQlXMCwgKERBVEEpCisJYWRkaQkJREFUQSwg REFUQSwgMzIKKwl2bGUzMi52CQlXMSwgKERBVEEpCisJYWRkaQkJREFUQSwgREFUQSwgMzIKKwor CS8vIERvIHRoZSA2NCByb3VuZHMgb2YgU00zLgorCXNtM184cm91bmRzCTAsIFcwLCBXMQorCXNt M184cm91bmRzCTQsIFcxLCBXMAorCXNtM184cm91bmRzCTgsIFcwLCBXMQorCXNtM184cm91bmRz CTEyLCBXMSwgVzAKKwlzbTNfOHJvdW5kcwkxNiwgVzAsIFcxCisJc20zXzhyb3VuZHMJMjAsIFcx LCBXMAorCXNtM184cm91bmRzCTI0LCBXMCwgVzEKKwlzbTNfOHJvdW5kcwkyOCwgVzEsIFcwCisK KwkvLyBYT1IgaW4gdGhlIHByZXZpb3VzIHN0YXRlLgorCXZ4b3IudnYJCVNUQVRFLCBTVEFURSwg UFJFVl9TVEFURQorCisJLy8gUmVwZWF0IGlmIG1vcmUgYmxvY2tzIHJlbWFpbi4KKwlibmV6CQlO VU1fQkxPQ0tTLCAuTG5leHRfYmxvY2sKKworCS8vIFN0b3JlIHRoZSBuZXcgc3RhdGUgYW5kIHJl dHVybi4KKwl2cmV2OC52CQlTVEFURSwgU1RBVEUKKwl2c2UzMi52CQlTVEFURSwgKFNUQVRFUCkK KwlyZXQKK1NZTV9GVU5DX0VORChzbTNfdHJhbnNmb3JtX3p2a3NoX3p2a2IpCi0tIAoyLjQzLjAK CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1y aXNjdiBtYWlsaW5nIGxpc3QKbGludXgtcmlzY3ZAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8v bGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXJpc2N2Cg==