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 vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6BDCEC07545 for ; Wed, 25 Oct 2023 18:39:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232076AbjJYSi7 (ORCPT ); Wed, 25 Oct 2023 14:38:59 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42862 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234981AbjJYSiQ (ORCPT ); Wed, 25 Oct 2023 14:38:16 -0400 Received: from mail-pj1-x102c.google.com (mail-pj1-x102c.google.com [IPv6:2607:f8b0:4864:20::102c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0A5171715 for ; Wed, 25 Oct 2023 11:37:40 -0700 (PDT) Received: by mail-pj1-x102c.google.com with SMTP id 98e67ed59e1d1-27d5c71b4d7so952585a91.1 for ; Wed, 25 Oct 2023 11:37:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sifive.com; s=google; t=1698259060; x=1698863860; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=rFfELb5x/LsOrFQ7gUXamutHrvvgbPVGCPs6bAZYMRw=; b=mc72EvBvCoo0wAMqIOaKcleEPNK1lXG56y953+1akpcGLMz18a/eKlKrf++3/vEm9m IhaEWKTJePlIiBxKTCw8lP/APOnRWR282TE5RmHQBTTPvrf8mSOrfQ7GpmLSLcIDfHw+ d1xzzIg6tpZWtuFy2+RvHu0lhcQN7JVLXOgD3CQNBGAkvDKGcus7eRt1oeMkOia9QnQH 0LIA1ScvWDOaQ3XFQBZo6MUhHPqtyYgNOV+TxqSC6GoiZ0ap51pNyka9Z0bbqG4H1qFV Ls4mwnwOTi7pEwk68LIEnGKHUxpASF/+nF/hOy3b4z1jpm0P+ndNLKBw3G79v4ULNL6s 4RdA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698259060; x=1698863860; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=rFfELb5x/LsOrFQ7gUXamutHrvvgbPVGCPs6bAZYMRw=; b=dkWVtdxTIN3bQKi1oTajOAiNXIWBD1j69Guu6jLW+266/DJaMVWW4uAuhOZ0XBpprk TW2229BzMng6ag3o0N/mX6HVglIUajTvCRK48SaSR6NsorKJgxl2281xm3GBi25vma1p NlAUm2lRD1Ecrz5DUQxIvESAtvdfbuaa5VssbRsomY3ipOotawNpzzGs6DJBdabE39Rv DHyiEQ3dgogX7DkTsAXum+kvYUHx3aFjz99za90LaWZAYNCX1aNL1Adp7B0oD8asOxmj 1LN8WdFKqUa/t65YlaYMsNQnpUdhEH16ypnnVq36VybYPR9GJ+czC55An/ikeFYJ78fj 6pHQ== X-Gm-Message-State: AOJu0YwzPizuMC1lc+9z1CUINYBvJdXI4Oz6buofZ9Dp4mIVCb6UV4TX 1rebUa6vaSti6H9b+D/Dg0ghFA== X-Google-Smtp-Source: AGHT+IHABU2hd2qHwiwMTWq1S7m/e937VOUzR8QXiVJeSGfxSSxVPKGmahrvNlXL2eiKB3F4nLI5+Q== X-Received: by 2002:a17:90a:3f16:b0:27d:2d2f:9ca2 with SMTP id l22-20020a17090a3f1600b0027d2d2f9ca2mr462317pjc.24.1698259060209; Wed, 25 Oct 2023 11:37:40 -0700 (PDT) Received: from localhost.localdomain ([49.216.222.119]) by smtp.gmail.com with ESMTPSA id g3-20020a17090adb0300b00278f1512dd9sm212367pjv.32.2023.10.25.11.37.36 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Wed, 25 Oct 2023 11:37:39 -0700 (PDT) From: Jerry Shih To: paul.walmsley@sifive.com, palmer@dabbelt.com, aou@eecs.berkeley.edu, herbert@gondor.apana.org.au, davem@davemloft.net Cc: andy.chiu@sifive.com, greentime.hu@sifive.com, conor.dooley@microchip.com, guoren@kernel.org, bjorn@rivosinc.com, heiko@sntech.de, ebiggers@kernel.org, ardb@kernel.org, phoebe.chen@sifive.com, hongrong.hsu@sifive.com, linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, linux-crypto@vger.kernel.org Subject: [PATCH 11/12] RISC-V: crypto: add Zvksh accelerated SM3 implementation Date: Thu, 26 Oct 2023 02:36:43 +0800 Message-Id: <20231025183644.8735-12-jerry.shih@sifive.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20231025183644.8735-1-jerry.shih@sifive.com> References: <20231025183644.8735-1-jerry.shih@sifive.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-crypto@vger.kernel.org Add SM3 implementation using Zvksh vector crypto extension from OpenSSL (openssl/openssl#21923). 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 --- arch/riscv/crypto/Kconfig | 13 ++ arch/riscv/crypto/Makefile | 7 + arch/riscv/crypto/sm3-riscv64-glue.c | 121 +++++++++++++ arch/riscv/crypto/sm3-riscv64-zvksh.pl | 230 +++++++++++++++++++++++++ 4 files changed, 371 insertions(+) create mode 100644 arch/riscv/crypto/sm3-riscv64-glue.c create mode 100644 arch/riscv/crypto/sm3-riscv64-zvksh.pl diff --git a/arch/riscv/crypto/Kconfig b/arch/riscv/crypto/Kconfig index ff004afa2874..2797b37394bb 100644 --- a/arch/riscv/crypto/Kconfig +++ b/arch/riscv/crypto/Kconfig @@ -75,6 +75,19 @@ config CRYPTO_SHA512_RISCV64 - Zvkb vector crypto extension - Zvknhb vector crypto extension +config CRYPTO_SM3_RISCV64 + default y if RISCV_ISA_V + tristate "Hash functions: SM3 (ShangMi 3)" + depends on 64BIT && RISCV_ISA_V + select CRYPTO_HASH + select CRYPTO_SM3 + help + SM3 (ShangMi 3) secure hash function (OSCCA GM/T 0004-2012) + + Architecture: riscv64 using: + - Zvkb vector crypto extension + - Zvksh vector crypto extension + config CRYPTO_SM4_RISCV64 default y if RISCV_ISA_V tristate "Ciphers: SM4 (ShangMi 4)" diff --git a/arch/riscv/crypto/Makefile b/arch/riscv/crypto/Makefile index ffad095e531f..b772417703fd 100644 --- a/arch/riscv/crypto/Makefile +++ b/arch/riscv/crypto/Makefile @@ -18,6 +18,9 @@ sha256-riscv64-y := sha256-riscv64-glue.o sha256-riscv64-zvkb-zvknha_or_zvknhb.o obj-$(CONFIG_CRYPTO_SHA512_RISCV64) += sha512-riscv64.o sha512-riscv64-y := sha512-riscv64-glue.o sha512-riscv64-zvkb-zvknhb.o +obj-$(CONFIG_CRYPTO_SM3_RISCV64) += sm3-riscv64.o +sm3-riscv64-y := sm3-riscv64-glue.o sm3-riscv64-zvksh.o + obj-$(CONFIG_CRYPTO_SM4_RISCV64) += sm4-riscv64.o sm4-riscv64-y := sm4-riscv64-glue.o sm4-riscv64-zvksed.o @@ -42,6 +45,9 @@ $(obj)/sha256-riscv64-zvkb-zvknha_or_zvknhb.S: $(src)/sha256-riscv64-zvkb-zvknha $(obj)/sha512-riscv64-zvkb-zvknhb.S: $(src)/sha512-riscv64-zvkb-zvknhb.pl $(call cmd,perlasm) +$(obj)/sm3-riscv64-zvksh.S: $(src)/sm3-riscv64-zvksh.pl + $(call cmd,perlasm) + $(obj)/sm4-riscv64-zvksed.S: $(src)/sm4-riscv64-zvksed.pl $(call cmd,perlasm) @@ -51,4 +57,5 @@ clean-files += aes-riscv64-zvkb-zvkned.S clean-files += ghash-riscv64-zvkg.S clean-files += sha256-riscv64-zvkb-zvknha_or_zvknhb.S clean-files += sha512-riscv64-zvkb-zvknhb.S +clean-files += sm3-riscv64-zvksh.S clean-files += sm4-riscv64-zvksed.S diff --git a/arch/riscv/crypto/sm3-riscv64-glue.c b/arch/riscv/crypto/sm3-riscv64-glue.c new file mode 100644 index 000000000000..32d37b602e54 --- /dev/null +++ b/arch/riscv/crypto/sm3-riscv64-glue.c @@ -0,0 +1,121 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Linux/riscv64 port of the OpenSSL SM3 implementation for RISC-V 64 + * + * Copyright (C) 2023 VRULL GmbH + * Author: Heiko Stuebner + */ + +#include +#include +#include +#include +#include +#include +#include + +/* + * sm3 using zvksh vector crypto extension + * + * This asm function will just take the first 256-bit as the sm3 state from + * the pointer to `struct sm3_state`. + */ +void ossl_hwsm3_block_data_order_zvksh(struct sm3_state *digest, u8 const *o, + int num); + +static int riscv64_sm3_update(struct shash_desc *desc, const u8 *data, + unsigned int len) +{ + int ret = 0; + + /* + * Make sure struct sm3_state begins directly with the SM3 256-bit internal + * state, as this is what the asm function expect. + */ + BUILD_BUG_ON(offsetof(struct sm3_state, state) != 0); + + if (crypto_simd_usable()) { + kernel_vector_begin(); + ret = sm3_base_do_update(desc, data, len, + ossl_hwsm3_block_data_order_zvksh); + kernel_vector_end(); + } else { + sm3_update(shash_desc_ctx(desc), data, len); + } + + return ret; +} + +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, + ossl_hwsm3_block_data_order_zvksh); + sm3_base_do_finalize(desc, ossl_hwsm3_block_data_order_zvksh); + 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 sm3_alg = { + .digestsize = SM3_DIGEST_SIZE, + .init = sm3_base_init, + .update = riscv64_sm3_update, + .final = riscv64_sm3_final, + .finup = riscv64_sm3_finup, + .descsize = sizeof(struct sm3_state), + .base.cra_name = "sm3", + .base.cra_driver_name = "sm3-riscv64-zvkb-zvksh", + .base.cra_priority = 150, + .base.cra_blocksize = SM3_BLOCK_SIZE, + .base.cra_module = THIS_MODULE, +}; + +static inline bool check_sm3_ext(void) +{ + return riscv_isa_extension_available(NULL, ZVKSH) && + riscv_isa_extension_available(NULL, ZVKB) && + riscv_vector_vlen() >= 128; +} + +static int __init riscv64_riscv64_sm3_mod_init(void) +{ + if (check_sm3_ext()) + return crypto_register_shash(&sm3_alg); + + return -ENODEV; +} + +static void __exit riscv64_sm3_mod_fini(void) +{ + if (check_sm3_ext()) + crypto_unregister_shash(&sm3_alg); +} + +module_init(riscv64_riscv64_sm3_mod_init); +module_exit(riscv64_sm3_mod_fini); + +MODULE_DESCRIPTION("SM3 (RISC-V accelerated)"); +MODULE_AUTHOR("Andy Polyakov "); +MODULE_AUTHOR("Ard Biesheuvel "); +MODULE_AUTHOR("Heiko Stuebner "); +MODULE_LICENSE("GPL"); +MODULE_ALIAS_CRYPTO("sm3"); diff --git a/arch/riscv/crypto/sm3-riscv64-zvksh.pl b/arch/riscv/crypto/sm3-riscv64-zvksh.pl new file mode 100644 index 000000000000..942d78d982e9 --- /dev/null +++ b/arch/riscv/crypto/sm3-riscv64-zvksh.pl @@ -0,0 +1,230 @@ +#! /usr/bin/env perl +# 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 +# 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 Cryptography Bit-manipulation extension ('Zvkb') +# - RISC-V Vector SM3 Secure Hash extension ('Zvksh') + +use strict; +use warnings; + +use FindBin qw($Bin); +use lib "$Bin"; +use lib "$Bin/../../perlasm"; +use riscv; + +# $output is the last argument if it looks like a file (it has an extension) +# $flavour is the first argument if it doesn't look like a file +my $output = $#ARGV >= 0 && $ARGV[$#ARGV] =~ m|\.\w+$| ? pop : undef; +my $flavour = $#ARGV >= 0 && $ARGV[0] !~ m|\.| ? shift : undef; + +$output and open STDOUT,">$output"; + +my $code=<<___; +.text +___ + +################################################################################ +# ossl_hwsm3_block_data_order_zvksh(SM3_CTX *c, const void *p, size_t num); +{ +my ($CTX, $INPUT, $NUM) = ("a0", "a1", "a2"); +my ($V0, $V1, $V2, $V3, $V4, $V5, $V6, $V7, + $V8, $V9, $V10, $V11, $V12, $V13, $V14, $V15, + $V16, $V17, $V18, $V19, $V20, $V21, $V22, $V23, + $V24, $V25, $V26, $V27, $V28, $V29, $V30, $V31, +) = map("v$_",(0..31)); + +$code .= <<___; +.text +.p2align 3 +.globl ossl_hwsm3_block_data_order_zvksh +.type ossl_hwsm3_block_data_order_zvksh,\@function +ossl_hwsm3_block_data_order_zvksh: + @{[vsetivli "zero", 8, "e32", "m2", "ta", "ma"]} + + # Load initial state of hash context (c->A-H). + @{[vle32_v $V0, $CTX]} + @{[vrev8_v $V0, $V0]} + +L_sm3_loop: + # Copy the previous state to v2. + # It will be XOR'ed with the current state at the end of the round. + @{[vmv_v_v $V2, $V0]} + + # Load the 64B block in 2x32B chunks. + @{[vle32_v $V6, $INPUT]} # v6 := {w7, ..., w0} + addi $INPUT, $INPUT, 32 + + @{[vle32_v $V8, $INPUT]} # v8 := {w15, ..., w8} + addi $INPUT, $INPUT, 32 + + addi $NUM, $NUM, -1 + + # As vsm3c consumes only w0, w1, w4, w5 we need to slide the input + # 2 elements down so we process elements w2, w3, w6, w7 + # This will be repeated for each odd round. + @{[vslidedown_vi $V4, $V6, 2]} # v4 := {X, X, w7, ..., w2} + + @{[vsm3c_vi $V0, $V6, 0]} + @{[vsm3c_vi $V0, $V4, 1]} + + # Prepare a vector with {w11, ..., w4} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, X, X, w7, ..., w4} + @{[vslideup_vi $V4, $V8, 4]} # v4 := {w11, w10, w9, w8, w7, w6, w5, w4} + + @{[vsm3c_vi $V0, $V4, 2]} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, w11, w10, w9, w8, w7, w6} + @{[vsm3c_vi $V0, $V4, 3]} + + @{[vsm3c_vi $V0, $V8, 4]} + @{[vslidedown_vi $V4, $V8, 2]} # v4 := {X, X, w15, w14, w13, w12, w11, w10} + @{[vsm3c_vi $V0, $V4, 5]} + + @{[vsm3me_vv $V6, $V8, $V6]} # v6 := {w23, w22, w21, w20, w19, w18, w17, w16} + + # Prepare a register with {w19, w18, w17, w16, w15, w14, w13, w12} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, X, X, w15, w14, w13, w12} + @{[vslideup_vi $V4, $V6, 4]} # v4 := {w19, w18, w17, w16, w15, w14, w13, w12} + + @{[vsm3c_vi $V0, $V4, 6]} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, w19, w18, w17, w16, w15, w14} + @{[vsm3c_vi $V0, $V4, 7]} + + @{[vsm3c_vi $V0, $V6, 8]} + @{[vslidedown_vi $V4, $V6, 2]} # v4 := {X, X, w23, w22, w21, w20, w19, w18} + @{[vsm3c_vi $V0, $V4, 9]} + + @{[vsm3me_vv $V8, $V6, $V8]} # v8 := {w31, w30, w29, w28, w27, w26, w25, w24} + + # Prepare a register with {w27, w26, w25, w24, w23, w22, w21, w20} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, X, X, w23, w22, w21, w20} + @{[vslideup_vi $V4, $V8, 4]} # v4 := {w27, w26, w25, w24, w23, w22, w21, w20} + + @{[vsm3c_vi $V0, $V4, 10]} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, w27, w26, w25, w24, w23, w22} + @{[vsm3c_vi $V0, $V4, 11]} + + @{[vsm3c_vi $V0, $V8, 12]} + @{[vslidedown_vi $V4, $V8, 2]} # v4 := {x, X, w31, w30, w29, w28, w27, w26} + @{[vsm3c_vi $V0, $V4, 13]} + + @{[vsm3me_vv $V6, $V8, $V6]} # v6 := {w32, w33, w34, w35, w36, w37, w38, w39} + + # Prepare a register with {w35, w34, w33, w32, w31, w30, w29, w28} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, X, X, w31, w30, w29, w28} + @{[vslideup_vi $V4, $V6, 4]} # v4 := {w35, w34, w33, w32, w31, w30, w29, w28} + + @{[vsm3c_vi $V0, $V4, 14]} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, w35, w34, w33, w32, w31, w30} + @{[vsm3c_vi $V0, $V4, 15]} + + @{[vsm3c_vi $V0, $V6, 16]} + @{[vslidedown_vi $V4, $V6, 2]} # v4 := {X, X, w39, w38, w37, w36, w35, w34} + @{[vsm3c_vi $V0, $V4, 17]} + + @{[vsm3me_vv $V8, $V6, $V8]} # v8 := {w47, w46, w45, w44, w43, w42, w41, w40} + + # Prepare a register with {w43, w42, w41, w40, w39, w38, w37, w36} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, X, X, w39, w38, w37, w36} + @{[vslideup_vi $V4, $V8, 4]} # v4 := {w43, w42, w41, w40, w39, w38, w37, w36} + + @{[vsm3c_vi $V0, $V4, 18]} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, w43, w42, w41, w40, w39, w38} + @{[vsm3c_vi $V0, $V4, 19]} + + @{[vsm3c_vi $V0, $V8, 20]} + @{[vslidedown_vi $V4, $V8, 2]} # v4 := {X, X, w47, w46, w45, w44, w43, w42} + @{[vsm3c_vi $V0, $V4, 21]} + + @{[vsm3me_vv $V6, $V8, $V6]} # v6 := {w55, w54, w53, w52, w51, w50, w49, w48} + + # Prepare a register with {w51, w50, w49, w48, w47, w46, w45, w44} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, X, X, w47, w46, w45, w44} + @{[vslideup_vi $V4, $V6, 4]} # v4 := {w51, w50, w49, w48, w47, w46, w45, w44} + + @{[vsm3c_vi $V0, $V4, 22]} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, w51, w50, w49, w48, w47, w46} + @{[vsm3c_vi $V0, $V4, 23]} + + @{[vsm3c_vi $V0, $V6, 24]} + @{[vslidedown_vi $V4, $V6, 2]} # v4 := {X, X, w55, w54, w53, w52, w51, w50} + @{[vsm3c_vi $V0, $V4, 25]} + + @{[vsm3me_vv $V8, $V6, $V8]} # v8 := {w63, w62, w61, w60, w59, w58, w57, w56} + + # Prepare a register with {w59, w58, w57, w56, w55, w54, w53, w52} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, X, X, w55, w54, w53, w52} + @{[vslideup_vi $V4, $V8, 4]} # v4 := {w59, w58, w57, w56, w55, w54, w53, w52} + + @{[vsm3c_vi $V0, $V4, 26]} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, w59, w58, w57, w56, w55, w54} + @{[vsm3c_vi $V0, $V4, 27]} + + @{[vsm3c_vi $V0, $V8, 28]} + @{[vslidedown_vi $V4, $V8, 2]} # v4 := {X, X, w63, w62, w61, w60, w59, w58} + @{[vsm3c_vi $V0, $V4, 29]} + + @{[vsm3me_vv $V6, $V8, $V6]} # v6 := {w71, w70, w69, w68, w67, w66, w65, w64} + + # Prepare a register with {w67, w66, w65, w64, w63, w62, w61, w60} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, X, X, w63, w62, w61, w60} + @{[vslideup_vi $V4, $V6, 4]} # v4 := {w67, w66, w65, w64, w63, w62, w61, w60} + + @{[vsm3c_vi $V0, $V4, 30]} + @{[vslidedown_vi $V4, $V4, 2]} # v4 := {X, X, w67, w66, w65, w64, w63, w62} + @{[vsm3c_vi $V0, $V4, 31]} + + # XOR in the previous state. + @{[vxor_vv $V0, $V0, $V2]} + + bnez $NUM, L_sm3_loop # Check if there are any more block to process +L_sm3_end: + @{[vrev8_v $V0, $V0]} + @{[vse32_v $V0, $CTX]} + ret + +.size ossl_hwsm3_block_data_order_zvksh,.-ossl_hwsm3_block_data_order_zvksh +___ +} + +print $code; + +close STDOUT or die "error closing STDOUT: $!"; -- 2.28.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 B9F57C0032E for ; Wed, 25 Oct 2023 18:37: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=LsTzW/mpdhSYQ5s1J7rJaPfdxvadd2mOdWScaWjEjt0=; b=Cr6piZJRqYAKzn +yJ+E9fdLW7Qvqr/+XXQgAtOSMg/K7+VeSCG2xt2Z4h/+fWkEgL+IdVw1T82mNP4Pqic4H59fpKGf 7p63BQrKZYh/BGDOFYPkfi38fgS3g2/HPjF51ctzKpZVd+9DgFtAzfSy9lALY6H5NCgvOE6BWsj+s p4uBYMRve9cd8GhbSPkQArUfJBjyy2ZnaBFUcP3yBRNgtWZkOMVttfRXsJRoOMbDW78+4As9vZhA6 5ZMdTYZUNm0MdQykHGas5d/e5Ls9IzboCSOqE43nlMK7l4MnPapSi+T0B4Y2pyufQa404iKMOMvTB adgZ4OBm+3LVmUBX6hOg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1qvilH-00CsZq-2F; Wed, 25 Oct 2023 18:37:47 +0000 Received: from mail-pl1-x629.google.com ([2607:f8b0:4864:20::629]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1qvilD-00CsUX-0s for linux-riscv@lists.infradead.org; Wed, 25 Oct 2023 18:37:46 +0000 Received: by mail-pl1-x629.google.com with SMTP id d9443c01a7336-1ca74e77aecso9205405ad.1 for ; Wed, 25 Oct 2023 11:37:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sifive.com; s=google; t=1698259060; x=1698863860; darn=lists.infradead.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=rFfELb5x/LsOrFQ7gUXamutHrvvgbPVGCPs6bAZYMRw=; b=SX6Z2vrRgGF0CVKh8RXeupC68dLGr3LS6lza1jEJUr6JLRkVoXWsXpFcfsSK5GH9Bo dI51kqhJME+OvSqijpBjc0hrSG22DOm8uR8mbjowM7NRZkigTua7Fu+QAGQHo0V0KAkn 9ceeRuZP5bCohwB6hbbMcWFCzaksgUTYkfDoiki2VHhd/301o6Bt3HukOMMyY/A2txEM Ae+iiaTvr0SlLg4fyBSkEr0Y2q/ApivYiOiIAr6fjalDIZzlmy1ObArxAjcadEVVApDo dRG848Dox2pEcHotHY7jcZ7bzQlrwVWKG9BLhpqF1K3/6Y1QEJH519PLC6HlEv0bu07h mX4g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698259060; x=1698863860; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=rFfELb5x/LsOrFQ7gUXamutHrvvgbPVGCPs6bAZYMRw=; b=YAVUNxhCAe3rU5Fj2Eds9k6nHsP5EjpOhLV9slG7F5nhFEFq1Ixqw55Gd/06V+T8UP WwVl+sEDV1tVRTx20A66+6YFP+BjMeENt7etPiKUfFDvVJljI7VBCSuDaDSrAJXcTfSN Sm34eNRc1dXMG3VTuFZx6TLH3GLTRBs/KsdSQorQ3N0/+6+1+vg0ltTt0Scwsm3D5+sX DLI2urZoFYXVxPqwM/Q87atPgnNPDCQk6YS6TmlnQnGet8taTnrcWWCr6GbYT5PsKrea ZKJgVyQX1Vtl4wbJZdv6hkIunfOeXVR71RFh3rQXKE6ND0ipk8j4C/LFq6+p8anA1x9J IpWA== X-Gm-Message-State: AOJu0YwBajbieviTxEm7kzN1hLdAzjo3aCgLhvJkR2FeS19KMWI/GUcc /Dt7pccyOfAt+aRJpYhfBCi8WA== X-Google-Smtp-Source: AGHT+IHABU2hd2qHwiwMTWq1S7m/e937VOUzR8QXiVJeSGfxSSxVPKGmahrvNlXL2eiKB3F4nLI5+Q== X-Received: by 2002:a17:90a:3f16:b0:27d:2d2f:9ca2 with SMTP id l22-20020a17090a3f1600b0027d2d2f9ca2mr462317pjc.24.1698259060209; Wed, 25 Oct 2023 11:37:40 -0700 (PDT) Received: from localhost.localdomain ([49.216.222.119]) by smtp.gmail.com with ESMTPSA id g3-20020a17090adb0300b00278f1512dd9sm212367pjv.32.2023.10.25.11.37.36 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Wed, 25 Oct 2023 11:37:39 -0700 (PDT) From: Jerry Shih To: paul.walmsley@sifive.com, palmer@dabbelt.com, aou@eecs.berkeley.edu, herbert@gondor.apana.org.au, davem@davemloft.net Cc: andy.chiu@sifive.com, greentime.hu@sifive.com, conor.dooley@microchip.com, guoren@kernel.org, bjorn@rivosinc.com, heiko@sntech.de, ebiggers@kernel.org, ardb@kernel.org, phoebe.chen@sifive.com, hongrong.hsu@sifive.com, linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, linux-crypto@vger.kernel.org Subject: [PATCH 11/12] RISC-V: crypto: add Zvksh accelerated SM3 implementation Date: Thu, 26 Oct 2023 02:36:43 +0800 Message-Id: <20231025183644.8735-12-jerry.shih@sifive.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20231025183644.8735-1-jerry.shih@sifive.com> References: <20231025183644.8735-1-jerry.shih@sifive.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20231025_113743_321616_95BC8B61 X-CRM114-Status: GOOD ( 30.79 ) 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 QWRkIFNNMyBpbXBsZW1lbnRhdGlvbiB1c2luZyBadmtzaCB2ZWN0b3IgY3J5cHRvIGV4dGVuc2lv biBmcm9tIE9wZW5TU0wKKG9wZW5zc2wvb3BlbnNzbCMyMTkyMykuCgpDby1kZXZlbG9wZWQtYnk6 IENocmlzdG9waCBNw7xsbG5lciA8Y2hyaXN0b3BoLm11ZWxsbmVyQHZydWxsLmV1PgpTaWduZWQt b2ZmLWJ5OiBDaHJpc3RvcGggTcO8bGxuZXIgPGNocmlzdG9waC5tdWVsbG5lckB2cnVsbC5ldT4K Q28tZGV2ZWxvcGVkLWJ5OiBIZWlrbyBTdHVlYm5lciA8aGVpa28uc3R1ZWJuZXJAdnJ1bGwuZXU+ ClNpZ25lZC1vZmYtYnk6IEhlaWtvIFN0dWVibmVyIDxoZWlrby5zdHVlYm5lckB2cnVsbC5ldT4K U2lnbmVkLW9mZi1ieTogSmVycnkgU2hpaCA8amVycnkuc2hpaEBzaWZpdmUuY29tPgotLS0KIGFy Y2gvcmlzY3YvY3J5cHRvL0tjb25maWcgICAgICAgICAgICAgIHwgIDEzICsrCiBhcmNoL3Jpc2N2 L2NyeXB0by9NYWtlZmlsZSAgICAgICAgICAgICB8ICAgNyArCiBhcmNoL3Jpc2N2L2NyeXB0by9z bTMtcmlzY3Y2NC1nbHVlLmMgICB8IDEyMSArKysrKysrKysrKysrCiBhcmNoL3Jpc2N2L2NyeXB0 by9zbTMtcmlzY3Y2NC16dmtzaC5wbCB8IDIzMCArKysrKysrKysrKysrKysrKysrKysrKysrCiA0 IGZpbGVzIGNoYW5nZWQsIDM3MSBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgYXJj aC9yaXNjdi9jcnlwdG8vc20zLXJpc2N2NjQtZ2x1ZS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgYXJj aC9yaXNjdi9jcnlwdG8vc20zLXJpc2N2NjQtenZrc2gucGwKCmRpZmYgLS1naXQgYS9hcmNoL3Jp c2N2L2NyeXB0by9LY29uZmlnIGIvYXJjaC9yaXNjdi9jcnlwdG8vS2NvbmZpZwppbmRleCBmZjAw NGFmYTI4NzQuLjI3OTdiMzczOTRiYiAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9jcnlwdG8vS2Nv bmZpZworKysgYi9hcmNoL3Jpc2N2L2NyeXB0by9LY29uZmlnCkBAIC03NSw2ICs3NSwxOSBAQCBj b25maWcgQ1JZUFRPX1NIQTUxMl9SSVNDVjY0CiAJICAtIFp2a2IgdmVjdG9yIGNyeXB0byBleHRl bnNpb24KIAkgIC0gWnZrbmhiIHZlY3RvciBjcnlwdG8gZXh0ZW5zaW9uCiAKK2NvbmZpZyBDUllQ VE9fU00zX1JJU0NWNjQKKwlkZWZhdWx0IHkgaWYgUklTQ1ZfSVNBX1YKKwl0cmlzdGF0ZSAiSGFz aCBmdW5jdGlvbnM6IFNNMyAoU2hhbmdNaSAzKSIKKwlkZXBlbmRzIG9uIDY0QklUICYmIFJJU0NW X0lTQV9WCisJc2VsZWN0IENSWVBUT19IQVNICisJc2VsZWN0IENSWVBUT19TTTMKKwloZWxwCisJ ICBTTTMgKFNoYW5nTWkgMykgc2VjdXJlIGhhc2ggZnVuY3Rpb24gKE9TQ0NBIEdNL1QgMDAwNC0y MDEyKQorCisJICBBcmNoaXRlY3R1cmU6IHJpc2N2NjQgdXNpbmc6CisJICAtIFp2a2IgdmVjdG9y IGNyeXB0byBleHRlbnNpb24KKwkgIC0gWnZrc2ggdmVjdG9yIGNyeXB0byBleHRlbnNpb24KKwog Y29uZmlnIENSWVBUT19TTTRfUklTQ1Y2NAogCWRlZmF1bHQgeSBpZiBSSVNDVl9JU0FfVgogCXRy aXN0YXRlICJDaXBoZXJzOiBTTTQgKFNoYW5nTWkgNCkiCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2 L2NyeXB0by9NYWtlZmlsZSBiL2FyY2gvcmlzY3YvY3J5cHRvL01ha2VmaWxlCmluZGV4IGZmYWQw OTVlNTMxZi4uYjc3MjQxNzcwM2ZkIDEwMDY0NAotLS0gYS9hcmNoL3Jpc2N2L2NyeXB0by9NYWtl ZmlsZQorKysgYi9hcmNoL3Jpc2N2L2NyeXB0by9NYWtlZmlsZQpAQCAtMTgsNiArMTgsOSBAQCBz aGEyNTYtcmlzY3Y2NC15IDo9IHNoYTI1Ni1yaXNjdjY0LWdsdWUubyBzaGEyNTYtcmlzY3Y2NC16 dmtiLXp2a25oYV9vcl96dmtuaGIubwogb2JqLSQoQ09ORklHX0NSWVBUT19TSEE1MTJfUklTQ1Y2 NCkgKz0gc2hhNTEyLXJpc2N2NjQubwogc2hhNTEyLXJpc2N2NjQteSA6PSBzaGE1MTItcmlzY3Y2 NC1nbHVlLm8gc2hhNTEyLXJpc2N2NjQtenZrYi16dmtuaGIubwogCitvYmotJChDT05GSUdfQ1JZ UFRPX1NNM19SSVNDVjY0KSArPSBzbTMtcmlzY3Y2NC5vCitzbTMtcmlzY3Y2NC15IDo9IHNtMy1y aXNjdjY0LWdsdWUubyBzbTMtcmlzY3Y2NC16dmtzaC5vCisKIG9iai0kKENPTkZJR19DUllQVE9f U000X1JJU0NWNjQpICs9IHNtNC1yaXNjdjY0Lm8KIHNtNC1yaXNjdjY0LXkgOj0gc200LXJpc2N2 NjQtZ2x1ZS5vIHNtNC1yaXNjdjY0LXp2a3NlZC5vCiAKQEAgLTQyLDYgKzQ1LDkgQEAgJChvYmop L3NoYTI1Ni1yaXNjdjY0LXp2a2ItenZrbmhhX29yX3p2a25oYi5TOiAkKHNyYykvc2hhMjU2LXJp c2N2NjQtenZrYi16dmtuaGEKICQob2JqKS9zaGE1MTItcmlzY3Y2NC16dmtiLXp2a25oYi5TOiAk KHNyYykvc2hhNTEyLXJpc2N2NjQtenZrYi16dmtuaGIucGwKIAkkKGNhbGwgY21kLHBlcmxhc20p CiAKKyQob2JqKS9zbTMtcmlzY3Y2NC16dmtzaC5TOiAkKHNyYykvc20zLXJpc2N2NjQtenZrc2gu cGwKKwkkKGNhbGwgY21kLHBlcmxhc20pCisKICQob2JqKS9zbTQtcmlzY3Y2NC16dmtzZWQuUzog JChzcmMpL3NtNC1yaXNjdjY0LXp2a3NlZC5wbAogCSQoY2FsbCBjbWQscGVybGFzbSkKIApAQCAt NTEsNCArNTcsNSBAQCBjbGVhbi1maWxlcyArPSBhZXMtcmlzY3Y2NC16dmtiLXp2a25lZC5TCiBj bGVhbi1maWxlcyArPSBnaGFzaC1yaXNjdjY0LXp2a2cuUwogY2xlYW4tZmlsZXMgKz0gc2hhMjU2 LXJpc2N2NjQtenZrYi16dmtuaGFfb3JfenZrbmhiLlMKIGNsZWFuLWZpbGVzICs9IHNoYTUxMi1y aXNjdjY0LXp2a2ItenZrbmhiLlMKK2NsZWFuLWZpbGVzICs9IHNtMy1yaXNjdjY0LXp2a3NoLlMK IGNsZWFuLWZpbGVzICs9IHNtNC1yaXNjdjY0LXp2a3NlZC5TCmRpZmYgLS1naXQgYS9hcmNoL3Jp c2N2L2NyeXB0by9zbTMtcmlzY3Y2NC1nbHVlLmMgYi9hcmNoL3Jpc2N2L2NyeXB0by9zbTMtcmlz Y3Y2NC1nbHVlLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4zMmQz N2I2MDJlNTQKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL3Jpc2N2L2NyeXB0by9zbTMtcmlzY3Y2 NC1nbHVlLmMKQEAgLTAsMCArMSwxMjEgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBH UEwtMi4wLW9yLWxhdGVyCisvKgorICogTGludXgvcmlzY3Y2NCBwb3J0IG9mIHRoZSBPcGVuU1NM IFNNMyBpbXBsZW1lbnRhdGlvbiBmb3IgUklTQy1WIDY0CisgKgorICogQ29weXJpZ2h0IChDKSAy MDIzIFZSVUxMIEdtYkgKKyAqIEF1dGhvcjogSGVpa28gU3R1ZWJuZXIgPGhlaWtvLnN0dWVibmVy QHZydWxsLmV1PgorICovCisKKyNpbmNsdWRlIDxhc20vc2ltZC5oPgorI2luY2x1ZGUgPGFzbS92 ZWN0b3IuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC90eXBl cy5oPgorI2luY2x1ZGUgPGNyeXB0by9pbnRlcm5hbC9oYXNoLmg+CisjaW5jbHVkZSA8Y3J5cHRv L2ludGVybmFsL3NpbWQuaD4KKyNpbmNsdWRlIDxjcnlwdG8vc20zX2Jhc2UuaD4KKworLyoKKyAq IHNtMyB1c2luZyB6dmtzaCB2ZWN0b3IgY3J5cHRvIGV4dGVuc2lvbgorICoKKyAqIFRoaXMgYXNt IGZ1bmN0aW9uIHdpbGwganVzdCB0YWtlIHRoZSBmaXJzdCAyNTYtYml0IGFzIHRoZSBzbTMgc3Rh dGUgZnJvbQorICogdGhlIHBvaW50ZXIgdG8gYHN0cnVjdCBzbTNfc3RhdGVgLgorICovCit2b2lk IG9zc2xfaHdzbTNfYmxvY2tfZGF0YV9vcmRlcl96dmtzaChzdHJ1Y3Qgc20zX3N0YXRlICpkaWdl c3QsIHU4IGNvbnN0ICpvLAorCQkJCSAgICAgICBpbnQgbnVtKTsKKworc3RhdGljIGludCByaXNj djY0X3NtM191cGRhdGUoc3RydWN0IHNoYXNoX2Rlc2MgKmRlc2MsIGNvbnN0IHU4ICpkYXRhLAor CQkJICAgICAgdW5zaWduZWQgaW50IGxlbikKK3sKKwlpbnQgcmV0ID0gMDsKKworCS8qCisJICog TWFrZSBzdXJlIHN0cnVjdCBzbTNfc3RhdGUgYmVnaW5zIGRpcmVjdGx5IHdpdGggdGhlIFNNMyAy NTYtYml0IGludGVybmFsCisJICogc3RhdGUsIGFzIHRoaXMgaXMgd2hhdCB0aGUgYXNtIGZ1bmN0 aW9uIGV4cGVjdC4KKwkgKi8KKwlCVUlMRF9CVUdfT04ob2Zmc2V0b2Yoc3RydWN0IHNtM19zdGF0 ZSwgc3RhdGUpICE9IDApOworCisJaWYgKGNyeXB0b19zaW1kX3VzYWJsZSgpKSB7CisJCWtlcm5l bF92ZWN0b3JfYmVnaW4oKTsKKwkJcmV0ID0gc20zX2Jhc2VfZG9fdXBkYXRlKGRlc2MsIGRhdGEs IGxlbiwKKwkJCQkJIG9zc2xfaHdzbTNfYmxvY2tfZGF0YV9vcmRlcl96dmtzaCk7CisJCWtlcm5l bF92ZWN0b3JfZW5kKCk7CisJfSBlbHNlIHsKKwkJc20zX3VwZGF0ZShzaGFzaF9kZXNjX2N0eChk ZXNjKSwgZGF0YSwgbGVuKTsKKwl9CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IHJp c2N2NjRfc20zX2ZpbnVwKHN0cnVjdCBzaGFzaF9kZXNjICpkZXNjLCBjb25zdCB1OCAqZGF0YSwK KwkJCSAgICAgdW5zaWduZWQgaW50IGxlbiwgdTggKm91dCkKK3sKKwlzdHJ1Y3Qgc20zX3N0YXRl ICpjdHg7CisKKwlpZiAoY3J5cHRvX3NpbWRfdXNhYmxlKCkpIHsKKwkJa2VybmVsX3ZlY3Rvcl9i ZWdpbigpOworCQlpZiAobGVuKQorCQkJc20zX2Jhc2VfZG9fdXBkYXRlKGRlc2MsIGRhdGEsIGxl biwKKwkJCQkJICAgb3NzbF9od3NtM19ibG9ja19kYXRhX29yZGVyX3p2a3NoKTsKKwkJc20zX2Jh c2VfZG9fZmluYWxpemUoZGVzYywgb3NzbF9od3NtM19ibG9ja19kYXRhX29yZGVyX3p2a3NoKTsK KwkJa2VybmVsX3ZlY3Rvcl9lbmQoKTsKKworCQlyZXR1cm4gc20zX2Jhc2VfZmluaXNoKGRlc2Ms IG91dCk7CisJfQorCisJY3R4ID0gc2hhc2hfZGVzY19jdHgoZGVzYyk7CisJaWYgKGxlbikKKwkJ c20zX3VwZGF0ZShjdHgsIGRhdGEsIGxlbik7CisJc20zX2ZpbmFsKGN0eCwgb3V0KTsKKworCXJl dHVybiAwOworfQorCitzdGF0aWMgaW50IHJpc2N2NjRfc20zX2ZpbmFsKHN0cnVjdCBzaGFzaF9k ZXNjICpkZXNjLCB1OCAqb3V0KQoreworCXJldHVybiByaXNjdjY0X3NtM19maW51cChkZXNjLCBO VUxMLCAwLCBvdXQpOworfQorCitzdGF0aWMgc3RydWN0IHNoYXNoX2FsZyBzbTNfYWxnID0gewor CS5kaWdlc3RzaXplID0gU00zX0RJR0VTVF9TSVpFLAorCS5pbml0ID0gc20zX2Jhc2VfaW5pdCwK KwkudXBkYXRlID0gcmlzY3Y2NF9zbTNfdXBkYXRlLAorCS5maW5hbCA9IHJpc2N2NjRfc20zX2Zp bmFsLAorCS5maW51cCA9IHJpc2N2NjRfc20zX2ZpbnVwLAorCS5kZXNjc2l6ZSA9IHNpemVvZihz dHJ1Y3Qgc20zX3N0YXRlKSwKKwkuYmFzZS5jcmFfbmFtZSA9ICJzbTMiLAorCS5iYXNlLmNyYV9k cml2ZXJfbmFtZSA9ICJzbTMtcmlzY3Y2NC16dmtiLXp2a3NoIiwKKwkuYmFzZS5jcmFfcHJpb3Jp dHkgPSAxNTAsCisJLmJhc2UuY3JhX2Jsb2Nrc2l6ZSA9IFNNM19CTE9DS19TSVpFLAorCS5iYXNl LmNyYV9tb2R1bGUgPSBUSElTX01PRFVMRSwKK307CisKK3N0YXRpYyBpbmxpbmUgYm9vbCBjaGVj a19zbTNfZXh0KHZvaWQpCit7CisJcmV0dXJuIHJpc2N2X2lzYV9leHRlbnNpb25fYXZhaWxhYmxl KE5VTEwsIFpWS1NIKSAmJgorCSAgICAgICByaXNjdl9pc2FfZXh0ZW5zaW9uX2F2YWlsYWJsZShO VUxMLCBaVktCKSAmJgorCSAgICAgICByaXNjdl92ZWN0b3JfdmxlbigpID49IDEyODsKK30KKwor c3RhdGljIGludCBfX2luaXQgcmlzY3Y2NF9yaXNjdjY0X3NtM19tb2RfaW5pdCh2b2lkKQorewor CWlmIChjaGVja19zbTNfZXh0KCkpCisJCXJldHVybiBjcnlwdG9fcmVnaXN0ZXJfc2hhc2goJnNt M19hbGcpOworCisJcmV0dXJuIC1FTk9ERVY7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCByaXNj djY0X3NtM19tb2RfZmluaSh2b2lkKQoreworCWlmIChjaGVja19zbTNfZXh0KCkpCisJCWNyeXB0 b191bnJlZ2lzdGVyX3NoYXNoKCZzbTNfYWxnKTsKK30KKworbW9kdWxlX2luaXQocmlzY3Y2NF9y aXNjdjY0X3NtM19tb2RfaW5pdCk7Cittb2R1bGVfZXhpdChyaXNjdjY0X3NtM19tb2RfZmluaSk7 CisKK01PRFVMRV9ERVNDUklQVElPTigiU00zIChSSVNDLVYgYWNjZWxlcmF0ZWQpIik7CitNT0RV TEVfQVVUSE9SKCJBbmR5IFBvbHlha292IDxhcHByb0BvcGVuc3NsLm9yZz4iKTsKK01PRFVMRV9B VVRIT1IoIkFyZCBCaWVzaGV1dmVsIDxhcmQuYmllc2hldXZlbEBsaW5hcm8ub3JnPiIpOworTU9E VUxFX0FVVEhPUigiSGVpa28gU3R1ZWJuZXIgPGhlaWtvLnN0dWVibmVyQHZydWxsLmV1PiIpOwor TU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FMSUFTX0NSWVBUTygic20zIik7CmRpZmYg LS1naXQgYS9hcmNoL3Jpc2N2L2NyeXB0by9zbTMtcmlzY3Y2NC16dmtzaC5wbCBiL2FyY2gvcmlz Y3YvY3J5cHRvL3NtMy1yaXNjdjY0LXp2a3NoLnBsCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMC4uOTQyZDc4ZDk4MmU5Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9yaXNj di9jcnlwdG8vc20zLXJpc2N2NjQtenZrc2gucGwKQEAgLTAsMCArMSwyMzAgQEAKKyMhIC91c3Iv YmluL2VudiBwZXJsCisjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wIE9SIEJT RC0yLUNsYXVzZQorIworIyBUaGlzIGZpbGUgaXMgZHVhbC1saWNlbnNlZCwgbWVhbmluZyB0aGF0 IHlvdSBjYW4gdXNlIGl0IHVuZGVyIHlvdXIKKyMgY2hvaWNlIG9mIGVpdGhlciBvZiB0aGUgZm9s bG93aW5nIHR3byBsaWNlbnNlczoKKyMKKyMgQ29weXJpZ2h0IDIwMjMgVGhlIE9wZW5TU0wgUHJv amVjdCBBdXRob3JzLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorIworIyBMaWNlbnNlZCB1bmRlciB0 aGUgQXBhY2hlIExpY2Vuc2UgMi4wICh0aGUgIkxpY2Vuc2UiKS4gWW91IGNhbiBvYnRhaW4KKyMg YSBjb3B5IGluIHRoZSBmaWxlIExJQ0VOU0UgaW4gdGhlIHNvdXJjZSBkaXN0cmlidXRpb24gb3Ig YXQKKyMgaHR0cHM6Ly93d3cub3BlbnNzbC5vcmcvc291cmNlL2xpY2Vuc2UuaHRtbAorIworIyBv cgorIworIyBDb3B5cmlnaHQgKGMpIDIwMjMsIENocmlzdG9waCBNw7xsbG5lciA8Y2hyaXN0b3Bo Lm11ZWxsbmVyQHZydWxsLmV1PgorIyBDb3B5cmlnaHQgKGMpIDIwMjMsIEplcnJ5IFNoaWggPGpl cnJ5LnNoaWhAc2lmaXZlLmNvbT4KKyMgQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0CisjIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucworIyBhcmUgbWV0OgorIyAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291 cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjIDIu IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUg Y29weXJpZ2h0CisjICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyMgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3Ro ZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyMKKyMgVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJV VE9SUworIyAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElO Q0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9G IE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyMgQSBQQVJUSUNVTEFSIFBVUlBPU0Ug QVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyMgT1dORVIg T1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsCisjIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJ TkNMVURJTkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVU RSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisjIERBVEEsIE9SIFBST0ZJVFM7IE9S IEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorIyBUSEVP UlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBP UiBUT1JUCisjIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorCisjIFRoZSBnZW5lcmF0ZWQg Y29kZSBvZiB0aGlzIGZpbGUgZGVwZW5kcyBvbiB0aGUgZm9sbG93aW5nIFJJU0MtViBleHRlbnNp b25zOgorIyAtIFJWNjRJCisjIC0gUklTQy1WIFZlY3RvciAoJ1YnKSB3aXRoIFZMRU4gPj0gMTI4 CisjIC0gUklTQy1WIFZlY3RvciBDcnlwdG9ncmFwaHkgQml0LW1hbmlwdWxhdGlvbiBleHRlbnNp b24gKCdadmtiJykKKyMgLSBSSVNDLVYgVmVjdG9yIFNNMyBTZWN1cmUgSGFzaCBleHRlbnNpb24g KCdadmtzaCcpCisKK3VzZSBzdHJpY3Q7Cit1c2Ugd2FybmluZ3M7CisKK3VzZSBGaW5kQmluIHF3 KCRCaW4pOwordXNlIGxpYiAiJEJpbiI7Cit1c2UgbGliICIkQmluLy4uLy4uL3Blcmxhc20iOwor dXNlIHJpc2N2OworCisjICRvdXRwdXQgaXMgdGhlIGxhc3QgYXJndW1lbnQgaWYgaXQgbG9va3Mg bGlrZSBhIGZpbGUgKGl0IGhhcyBhbiBleHRlbnNpb24pCisjICRmbGF2b3VyIGlzIHRoZSBmaXJz dCBhcmd1bWVudCBpZiBpdCBkb2Vzbid0IGxvb2sgbGlrZSBhIGZpbGUKK215ICRvdXRwdXQgPSAk I0FSR1YgPj0gMCAmJiAkQVJHVlskI0FSR1ZdID1+IG18XC5cdyskfCA/IHBvcCA6IHVuZGVmOwor bXkgJGZsYXZvdXIgPSAkI0FSR1YgPj0gMCAmJiAkQVJHVlswXSAhfiBtfFwufCA/IHNoaWZ0IDog dW5kZWY7CisKKyRvdXRwdXQgYW5kIG9wZW4gU1RET1VULCI+JG91dHB1dCI7CisKK215ICRjb2Rl PTw8X19fOworLnRleHQKK19fXworCisjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMj IyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIworIyBvc3NsX2h3 c20zX2Jsb2NrX2RhdGFfb3JkZXJfenZrc2goU00zX0NUWCAqYywgY29uc3Qgdm9pZCAqcCwgc2l6 ZV90IG51bSk7Cit7CitteSAoJENUWCwgJElOUFVULCAkTlVNKSA9ICgiYTAiLCAiYTEiLCAiYTIi KTsKK215ICgkVjAsICRWMSwgJFYyLCAkVjMsICRWNCwgJFY1LCAkVjYsICRWNywKKyAgICAkVjgs ICRWOSwgJFYxMCwgJFYxMSwgJFYxMiwgJFYxMywgJFYxNCwgJFYxNSwKKyAgICAkVjE2LCAkVjE3 LCAkVjE4LCAkVjE5LCAkVjIwLCAkVjIxLCAkVjIyLCAkVjIzLAorICAgICRWMjQsICRWMjUsICRW MjYsICRWMjcsICRWMjgsICRWMjksICRWMzAsICRWMzEsCispID0gbWFwKCJ2JF8iLCgwLi4zMSkp OworCiskY29kZSAuPSA8PF9fXzsKKy50ZXh0CisucDJhbGlnbiAzCisuZ2xvYmwgb3NzbF9od3Nt M19ibG9ja19kYXRhX29yZGVyX3p2a3NoCisudHlwZSBvc3NsX2h3c20zX2Jsb2NrX2RhdGFfb3Jk ZXJfenZrc2gsXEBmdW5jdGlvbgorb3NzbF9od3NtM19ibG9ja19kYXRhX29yZGVyX3p2a3NoOgor ICAgIEB7W3ZzZXRpdmxpICJ6ZXJvIiwgOCwgImUzMiIsICJtMiIsICJ0YSIsICJtYSJdfQorCisg ICAgIyBMb2FkIGluaXRpYWwgc3RhdGUgb2YgaGFzaCBjb250ZXh0IChjLT5BLUgpLgorICAgIEB7 W3ZsZTMyX3YgJFYwLCAkQ1RYXX0KKyAgICBAe1t2cmV2OF92ICRWMCwgJFYwXX0KKworTF9zbTNf bG9vcDoKKyAgICAjIENvcHkgdGhlIHByZXZpb3VzIHN0YXRlIHRvIHYyLgorICAgICMgSXQgd2ls bCBiZSBYT1InZWQgd2l0aCB0aGUgY3VycmVudCBzdGF0ZSBhdCB0aGUgZW5kIG9mIHRoZSByb3Vu ZC4KKyAgICBAe1t2bXZfdl92ICRWMiwgJFYwXX0KKworICAgICMgTG9hZCB0aGUgNjRCIGJsb2Nr IGluIDJ4MzJCIGNodW5rcy4KKyAgICBAe1t2bGUzMl92ICRWNiwgJElOUFVUXX0gIyB2NiA6PSB7 dzcsIC4uLiwgdzB9CisgICAgYWRkaSAkSU5QVVQsICRJTlBVVCwgMzIKKworICAgIEB7W3ZsZTMy X3YgJFY4LCAkSU5QVVRdfSAjIHY4IDo9IHt3MTUsIC4uLiwgdzh9CisgICAgYWRkaSAkSU5QVVQs ICRJTlBVVCwgMzIKKworICAgIGFkZGkgJE5VTSwgJE5VTSwgLTEKKworICAgICMgQXMgdnNtM2Mg Y29uc3VtZXMgb25seSB3MCwgdzEsIHc0LCB3NSB3ZSBuZWVkIHRvIHNsaWRlIHRoZSBpbnB1dAor ICAgICMgMiBlbGVtZW50cyBkb3duIHNvIHdlIHByb2Nlc3MgZWxlbWVudHMgdzIsIHczLCB3Niwg dzcKKyAgICAjIFRoaXMgd2lsbCBiZSByZXBlYXRlZCBmb3IgZWFjaCBvZGQgcm91bmQuCisgICAg QHtbdnNsaWRlZG93bl92aSAkVjQsICRWNiwgMl19ICMgdjQgOj0ge1gsIFgsIHc3LCAuLi4sIHcy fQorCisgICAgQHtbdnNtM2NfdmkgJFYwLCAkVjYsIDBdfQorICAgIEB7W3ZzbTNjX3ZpICRWMCwg JFY0LCAxXX0KKworICAgICMgUHJlcGFyZSBhIHZlY3RvciB3aXRoIHt3MTEsIC4uLiwgdzR9Cisg ICAgQHtbdnNsaWRlZG93bl92aSAkVjQsICRWNCwgMl19ICMgdjQgOj0ge1gsIFgsIFgsIFgsIHc3 LCAuLi4sIHc0fQorICAgIEB7W3ZzbGlkZXVwX3ZpICRWNCwgJFY4LCA0XX0gICAjIHY0IDo9IHt3 MTEsIHcxMCwgdzksIHc4LCB3NywgdzYsIHc1LCB3NH0KKworICAgIEB7W3ZzbTNjX3ZpICRWMCwg JFY0LCAyXX0KKyAgICBAe1t2c2xpZGVkb3duX3ZpICRWNCwgJFY0LCAyXX0gIyB2NCA6PSB7WCwg WCwgdzExLCB3MTAsIHc5LCB3OCwgdzcsIHc2fQorICAgIEB7W3ZzbTNjX3ZpICRWMCwgJFY0LCAz XX0KKworICAgIEB7W3ZzbTNjX3ZpICRWMCwgJFY4LCA0XX0KKyAgICBAe1t2c2xpZGVkb3duX3Zp ICRWNCwgJFY4LCAyXX0gIyB2NCA6PSB7WCwgWCwgdzE1LCB3MTQsIHcxMywgdzEyLCB3MTEsIHcx MH0KKyAgICBAe1t2c20zY192aSAkVjAsICRWNCwgNV19CisKKyAgICBAe1t2c20zbWVfdnYgJFY2 LCAkVjgsICRWNl19ICAgIyB2NiA6PSB7dzIzLCB3MjIsIHcyMSwgdzIwLCB3MTksIHcxOCwgdzE3 LCB3MTZ9CisKKyAgICAjIFByZXBhcmUgYSByZWdpc3RlciB3aXRoIHt3MTksIHcxOCwgdzE3LCB3 MTYsIHcxNSwgdzE0LCB3MTMsIHcxMn0KKyAgICBAe1t2c2xpZGVkb3duX3ZpICRWNCwgJFY0LCAy XX0gIyB2NCA6PSB7WCwgWCwgWCwgWCwgdzE1LCB3MTQsIHcxMywgdzEyfQorICAgIEB7W3ZzbGlk ZXVwX3ZpICRWNCwgJFY2LCA0XX0gICAjIHY0IDo9IHt3MTksIHcxOCwgdzE3LCB3MTYsIHcxNSwg dzE0LCB3MTMsIHcxMn0KKworICAgIEB7W3ZzbTNjX3ZpICRWMCwgJFY0LCA2XX0KKyAgICBAe1t2 c2xpZGVkb3duX3ZpICRWNCwgJFY0LCAyXX0gIyB2NCA6PSB7WCwgWCwgdzE5LCB3MTgsIHcxNywg dzE2LCB3MTUsIHcxNH0KKyAgICBAe1t2c20zY192aSAkVjAsICRWNCwgN119CisKKyAgICBAe1t2 c20zY192aSAkVjAsICRWNiwgOF19CisgICAgQHtbdnNsaWRlZG93bl92aSAkVjQsICRWNiwgMl19 ICMgdjQgOj0ge1gsIFgsIHcyMywgdzIyLCB3MjEsIHcyMCwgdzE5LCB3MTh9CisgICAgQHtbdnNt M2NfdmkgJFYwLCAkVjQsIDldfQorCisgICAgQHtbdnNtM21lX3Z2ICRWOCwgJFY2LCAkVjhdfSAg ICMgdjggOj0ge3czMSwgdzMwLCB3MjksIHcyOCwgdzI3LCB3MjYsIHcyNSwgdzI0fQorCisgICAg IyBQcmVwYXJlIGEgcmVnaXN0ZXIgd2l0aCB7dzI3LCB3MjYsIHcyNSwgdzI0LCB3MjMsIHcyMiwg dzIxLCB3MjB9CisgICAgQHtbdnNsaWRlZG93bl92aSAkVjQsICRWNCwgMl19ICMgdjQgOj0ge1gs IFgsIFgsIFgsIHcyMywgdzIyLCB3MjEsIHcyMH0KKyAgICBAe1t2c2xpZGV1cF92aSAkVjQsICRW OCwgNF19ICAgIyB2NCA6PSB7dzI3LCB3MjYsIHcyNSwgdzI0LCB3MjMsIHcyMiwgdzIxLCB3MjB9 CisKKyAgICBAe1t2c20zY192aSAkVjAsICRWNCwgMTBdfQorICAgIEB7W3ZzbGlkZWRvd25fdmkg JFY0LCAkVjQsIDJdfSAjIHY0IDo9IHtYLCBYLCB3MjcsIHcyNiwgdzI1LCB3MjQsIHcyMywgdzIy fQorICAgIEB7W3ZzbTNjX3ZpICRWMCwgJFY0LCAxMV19CisKKyAgICBAe1t2c20zY192aSAkVjAs ICRWOCwgMTJdfQorICAgIEB7W3ZzbGlkZWRvd25fdmkgJFY0LCAkVjgsIDJdfSAjIHY0IDo9IHt4 LCBYLCB3MzEsIHczMCwgdzI5LCB3MjgsIHcyNywgdzI2fQorICAgIEB7W3ZzbTNjX3ZpICRWMCwg JFY0LCAxM119CisKKyAgICBAe1t2c20zbWVfdnYgJFY2LCAkVjgsICRWNl19ICAgIyB2NiA6PSB7 dzMyLCB3MzMsIHczNCwgdzM1LCB3MzYsIHczNywgdzM4LCB3Mzl9CisKKyAgICAjIFByZXBhcmUg YSByZWdpc3RlciB3aXRoIHt3MzUsIHczNCwgdzMzLCB3MzIsIHczMSwgdzMwLCB3MjksIHcyOH0K KyAgICBAe1t2c2xpZGVkb3duX3ZpICRWNCwgJFY0LCAyXX0gIyB2NCA6PSB7WCwgWCwgWCwgWCwg dzMxLCB3MzAsIHcyOSwgdzI4fQorICAgIEB7W3ZzbGlkZXVwX3ZpICRWNCwgJFY2LCA0XX0gICAj IHY0IDo9IHt3MzUsIHczNCwgdzMzLCB3MzIsIHczMSwgdzMwLCB3MjksIHcyOH0KKworICAgIEB7 W3ZzbTNjX3ZpICRWMCwgJFY0LCAxNF19CisgICAgQHtbdnNsaWRlZG93bl92aSAkVjQsICRWNCwg Ml19ICMgdjQgOj0ge1gsIFgsIHczNSwgdzM0LCB3MzMsIHczMiwgdzMxLCB3MzB9CisgICAgQHtb dnNtM2NfdmkgJFYwLCAkVjQsIDE1XX0KKworICAgIEB7W3ZzbTNjX3ZpICRWMCwgJFY2LCAxNl19 CisgICAgQHtbdnNsaWRlZG93bl92aSAkVjQsICRWNiwgMl19ICMgdjQgOj0ge1gsIFgsIHczOSwg dzM4LCB3MzcsIHczNiwgdzM1LCB3MzR9CisgICAgQHtbdnNtM2NfdmkgJFYwLCAkVjQsIDE3XX0K KworICAgIEB7W3ZzbTNtZV92diAkVjgsICRWNiwgJFY4XX0gICAjIHY4IDo9IHt3NDcsIHc0Niwg dzQ1LCB3NDQsIHc0MywgdzQyLCB3NDEsIHc0MH0KKworICAgICMgUHJlcGFyZSBhIHJlZ2lzdGVy IHdpdGgge3c0MywgdzQyLCB3NDEsIHc0MCwgdzM5LCB3MzgsIHczNywgdzM2fQorICAgIEB7W3Zz bGlkZWRvd25fdmkgJFY0LCAkVjQsIDJdfSAjIHY0IDo9IHtYLCBYLCBYLCBYLCB3MzksIHczOCwg dzM3LCB3MzZ9CisgICAgQHtbdnNsaWRldXBfdmkgJFY0LCAkVjgsIDRdfSAgICMgdjQgOj0ge3c0 MywgdzQyLCB3NDEsIHc0MCwgdzM5LCB3MzgsIHczNywgdzM2fQorCisgICAgQHtbdnNtM2Nfdmkg JFYwLCAkVjQsIDE4XX0KKyAgICBAe1t2c2xpZGVkb3duX3ZpICRWNCwgJFY0LCAyXX0gIyB2NCA6 PSB7WCwgWCwgdzQzLCB3NDIsIHc0MSwgdzQwLCB3MzksIHczOH0KKyAgICBAe1t2c20zY192aSAk VjAsICRWNCwgMTldfQorCisgICAgQHtbdnNtM2NfdmkgJFYwLCAkVjgsIDIwXX0KKyAgICBAe1t2 c2xpZGVkb3duX3ZpICRWNCwgJFY4LCAyXX0gIyB2NCA6PSB7WCwgWCwgdzQ3LCB3NDYsIHc0NSwg dzQ0LCB3NDMsIHc0Mn0KKyAgICBAe1t2c20zY192aSAkVjAsICRWNCwgMjFdfQorCisgICAgQHtb dnNtM21lX3Z2ICRWNiwgJFY4LCAkVjZdfSAgICMgdjYgOj0ge3c1NSwgdzU0LCB3NTMsIHc1Miwg dzUxLCB3NTAsIHc0OSwgdzQ4fQorCisgICAgIyBQcmVwYXJlIGEgcmVnaXN0ZXIgd2l0aCB7dzUx LCB3NTAsIHc0OSwgdzQ4LCB3NDcsIHc0NiwgdzQ1LCB3NDR9CisgICAgQHtbdnNsaWRlZG93bl92 aSAkVjQsICRWNCwgMl19ICMgdjQgOj0ge1gsIFgsIFgsIFgsIHc0NywgdzQ2LCB3NDUsIHc0NH0K KyAgICBAe1t2c2xpZGV1cF92aSAkVjQsICRWNiwgNF19ICAgIyB2NCA6PSB7dzUxLCB3NTAsIHc0 OSwgdzQ4LCB3NDcsIHc0NiwgdzQ1LCB3NDR9CisKKyAgICBAe1t2c20zY192aSAkVjAsICRWNCwg MjJdfQorICAgIEB7W3ZzbGlkZWRvd25fdmkgJFY0LCAkVjQsIDJdfSAjIHY0IDo9IHtYLCBYLCB3 NTEsIHc1MCwgdzQ5LCB3NDgsIHc0NywgdzQ2fQorICAgIEB7W3ZzbTNjX3ZpICRWMCwgJFY0LCAy M119CisKKyAgICBAe1t2c20zY192aSAkVjAsICRWNiwgMjRdfQorICAgIEB7W3ZzbGlkZWRvd25f dmkgJFY0LCAkVjYsIDJdfSAjIHY0IDo9IHtYLCBYLCB3NTUsIHc1NCwgdzUzLCB3NTIsIHc1MSwg dzUwfQorICAgIEB7W3ZzbTNjX3ZpICRWMCwgJFY0LCAyNV19CisKKyAgICBAe1t2c20zbWVfdnYg JFY4LCAkVjYsICRWOF19ICAgIyB2OCA6PSB7dzYzLCB3NjIsIHc2MSwgdzYwLCB3NTksIHc1OCwg dzU3LCB3NTZ9CisKKyAgICAjIFByZXBhcmUgYSByZWdpc3RlciB3aXRoIHt3NTksIHc1OCwgdzU3 LCB3NTYsIHc1NSwgdzU0LCB3NTMsIHc1Mn0KKyAgICBAe1t2c2xpZGVkb3duX3ZpICRWNCwgJFY0 LCAyXX0gIyB2NCA6PSB7WCwgWCwgWCwgWCwgdzU1LCB3NTQsIHc1MywgdzUyfQorICAgIEB7W3Zz bGlkZXVwX3ZpICRWNCwgJFY4LCA0XX0gICAjIHY0IDo9IHt3NTksIHc1OCwgdzU3LCB3NTYsIHc1 NSwgdzU0LCB3NTMsIHc1Mn0KKworICAgIEB7W3ZzbTNjX3ZpICRWMCwgJFY0LCAyNl19CisgICAg QHtbdnNsaWRlZG93bl92aSAkVjQsICRWNCwgMl19ICMgdjQgOj0ge1gsIFgsIHc1OSwgdzU4LCB3 NTcsIHc1NiwgdzU1LCB3NTR9CisgICAgQHtbdnNtM2NfdmkgJFYwLCAkVjQsIDI3XX0KKworICAg IEB7W3ZzbTNjX3ZpICRWMCwgJFY4LCAyOF19CisgICAgQHtbdnNsaWRlZG93bl92aSAkVjQsICRW OCwgMl19ICMgdjQgOj0ge1gsIFgsIHc2MywgdzYyLCB3NjEsIHc2MCwgdzU5LCB3NTh9CisgICAg QHtbdnNtM2NfdmkgJFYwLCAkVjQsIDI5XX0KKworICAgIEB7W3ZzbTNtZV92diAkVjYsICRWOCwg JFY2XX0gICAjIHY2IDo9IHt3NzEsIHc3MCwgdzY5LCB3NjgsIHc2NywgdzY2LCB3NjUsIHc2NH0K KworICAgICMgUHJlcGFyZSBhIHJlZ2lzdGVyIHdpdGgge3c2NywgdzY2LCB3NjUsIHc2NCwgdzYz LCB3NjIsIHc2MSwgdzYwfQorICAgIEB7W3ZzbGlkZWRvd25fdmkgJFY0LCAkVjQsIDJdfSAjIHY0 IDo9IHtYLCBYLCBYLCBYLCB3NjMsIHc2MiwgdzYxLCB3NjB9CisgICAgQHtbdnNsaWRldXBfdmkg JFY0LCAkVjYsIDRdfSAgICMgdjQgOj0ge3c2NywgdzY2LCB3NjUsIHc2NCwgdzYzLCB3NjIsIHc2 MSwgdzYwfQorCisgICAgQHtbdnNtM2NfdmkgJFYwLCAkVjQsIDMwXX0KKyAgICBAe1t2c2xpZGVk b3duX3ZpICRWNCwgJFY0LCAyXX0gIyB2NCA6PSB7WCwgWCwgdzY3LCB3NjYsIHc2NSwgdzY0LCB3 NjMsIHc2Mn0KKyAgICBAe1t2c20zY192aSAkVjAsICRWNCwgMzFdfQorCisgICAgIyBYT1IgaW4g dGhlIHByZXZpb3VzIHN0YXRlLgorICAgIEB7W3Z4b3JfdnYgJFYwLCAkVjAsICRWMl19CisKKyAg ICBibmV6ICROVU0sIExfc20zX2xvb3AgICAgICMgQ2hlY2sgaWYgdGhlcmUgYXJlIGFueSBtb3Jl IGJsb2NrIHRvIHByb2Nlc3MKK0xfc20zX2VuZDoKKyAgICBAe1t2cmV2OF92ICRWMCwgJFYwXX0K KyAgICBAe1t2c2UzMl92ICRWMCwgJENUWF19CisgICAgcmV0CisKKy5zaXplIG9zc2xfaHdzbTNf YmxvY2tfZGF0YV9vcmRlcl96dmtzaCwuLW9zc2xfaHdzbTNfYmxvY2tfZGF0YV9vcmRlcl96dmtz aAorX19fCit9CisKK3ByaW50ICRjb2RlOworCitjbG9zZSBTVERPVVQgb3IgZGllICJlcnJvciBj bG9zaW5nIFNURE9VVDogJCEiOwotLSAKMi4yOC4wCgoKX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX18KbGludXgtcmlzY3YgbWFpbGluZyBsaXN0CmxpbnV4LXJp c2N2QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1h bi9saXN0aW5mby9saW51eC1yaXNjdgo=