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 mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B7365C433FE for ; Wed, 6 Oct 2021 07:33:29 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 9E7696115A for ; Wed, 6 Oct 2021 07:33:29 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237592AbhJFHfT (ORCPT ); Wed, 6 Oct 2021 03:35:19 -0400 Received: from vulcan.natalenko.name ([104.207.131.136]:58656 "EHLO vulcan.natalenko.name" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237389AbhJFHfS (ORCPT ); Wed, 6 Oct 2021 03:35:18 -0400 Received: from spock.localnet (unknown [151.237.229.131]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by vulcan.natalenko.name (Postfix) with ESMTPSA id 3E483C23CB3; Wed, 6 Oct 2021 09:33:23 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=natalenko.name; s=dkim-20170712; t=1633505603; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=kCaMpgYXPXXydkTsRi5p9icWnhbXT3w/9Sbrl4jpjvg=; b=CN1ew3MpM4LFHohH0158mpk/oc96vr+yAtIU58GIq21z8ryESCabmEs1ZkMBsW5zggkD8h InR8+ArzrqpVza6j8h6GzBW8zr2AKWxbzEqFwd4dxI7jR7NU+7M8p/uDA00iV6JS2ByWPL HeL5zBg5jkn2G37aN/JPGzNgcUnShfY= From: Oleksandr Natalenko To: Stephen Rothwell , Nick Terrell Cc: linux-next@vger.kernel.org, linux-crypto@vger.kernel.org, linux-btrfs@vger.kernel.org, squashfs-devel@lists.sourceforge.net, linux-f2fs-devel@lists.sourceforge.net, linux-kernel@vger.kernel.org, Kernel Team , Nick Terrell , Nick Terrell , Chris Mason , Petr Malat , Yann Collet , Christoph Hellwig , =?utf-8?B?TWljaGHFgiBNaXJvc8WCYXc=?= , David Sterba , Felix Handte , Eric Biggers , Randy Dunlap , Paul Jones , Tom Seewald Subject: Re: [GIT PULL][v12] zstd changes for linux-next Date: Wed, 06 Oct 2021 09:33:21 +0200 Message-ID: <1711282.gcEllRqJC2@natalenko.name> In-Reply-To: <20211005014118.3164585-1-nickrterrell@gmail.com> References: <20211005014118.3164585-1-nickrterrell@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="UTF-8" Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org Hello. On =C3=BAter=C3=BD 5. =C5=99=C3=ADjna 2021 3:41:18 CEST Nick Terrell wrote: > From: Nick Terrell >=20 > The following changes since commit a25006a77348ba06c7bc96520d331cd9dd3707= 15: >=20 > Add linux-next specific files for 20211001 (2021-10-01 17:07:37 +1000) >=20 > are available in the Git repository at: >=20 > git@github.com:terrelln/linux.git tags/v12-zstd-1.4.10 >=20 > for you to fetch changes up to 5210ca33b09bed5e09f72e9b46a3220f64597f8c: >=20 > MAINTAINERS: Add maintainer entry for zstd (2021-10-04 18:14:42 -0700) >=20 > I would like to merge this pull request into linux-next to bake, and then > submit the PR to Linux in the 5.16 merge window. If you have been a part = of > the discussion, are a maintainer of a caller of zstd, tested this code, or > otherwise been involved, thank you! And could you please respond below wi= th > an appropiate tag, so I can collect support for the PR >=20 > Best, > Nick Terrell On both 5.14 and 5.15: Tested-by: Oleksandr Natalenko >=20 > ---------------------------------------------------------------- > Update to zstd-1.4.10 >=20 > - The first commit adds a new kernel-style wrapper around zstd. This wrap= per > API is functionally equivalent to the subset of the current zstd API that > is currently used. The wrapper API changes to be kernel style so that the > symbols don't collide with zstd's symbols. The update to zstd-1.4.10 > maintains the same API and preserves the semantics, so that none of the > callers need to be updated. All callers are updated in the commit, because > there are zero functional changes. > - The second commit adds an indirection for `lib/decompress_unzstd.c` so = it > doesn't depend on the layout of `lib/zstd/` to include every source fil= e. > This allows the next patch to be automatically generated. > - The third commit is automatically generated, and imports the zstd-1.4.10 > source code. This commit is completely generated by automation. > - The fourth commit adds me (terrelln@fb.com) as the maintainer of > `lib/zstd`. >=20 > The discussion around this patchset has been pretty long, so I've include= d a > FAQ-style summary of the history of the patchset, and why we are taking > this approach. >=20 > Why do we need to update? > ------------------------- >=20 > The zstd version in the kernel is based off of zstd-1.3.1, which is was > released August 20, 2017. Since then zstd has seen many bug fixes and > performance improvements. And, importantly, upstream zstd is continuously > fuzzed by OSS-Fuzz, and bug fixes aren't backported to older versions. So > the only way to sanely get these fixes is to keep up to date with upstream > zstd. There are no known security issues that affect the kernel, but we > need to be able to update in case there are. And while there are no known > security issues, there are relevant bug fixes. For example the problem wi= th > large kernel decompression has been fixed upstream for over 2 years > https://lkml.org/lkml/2020/9/29/27. >=20 > Additionally the performance improvements for kernel use cases are > significant. Measured for x86_64 on my Intel i9-9900k @ 3.6 GHz: >=20 > - BtrFS zstd compression at levels 1 and 3 is 5% faster > - BtrFS zstd decompression+read is 15% faster > - SquashFS zstd decompression+read is 15% faster > - F2FS zstd compression+write at level 3 is 8% faster > - F2FS zstd decompression+read is 20% faster > - ZRAM decompression+read is 30% faster > - Kernel zstd decompression is 35% faster > - Initramfs zstd decompression+build is 5% faster >=20 > On top of this, there are significant performance improvements coming down > the line in the next zstd release, and the new automated update patch > generation will allow us to pull them easily. >=20 > How is the update patch generated? > ---------------------------------- >=20 > The first two patches are preparation for updating the zstd version. Then > the 3rd patch in the series imports upstream zstd into the kernel. This > patch is automatically generated from upstream. A script makes the > necessary changes and imports it into the kernel. The changes are: >=20 > - Replace all libc dependencies with kernel replacements and rewrite > includes. - Remove unncessary portability macros like: #if > defined(_MSC_VER). - Use the kernel xxhash instead of bundling it. >=20 > This automation gets tested every commit by upstream's continuous > integration. When we cut a new zstd release, we will submit a patch to the > kernel to update the zstd version in the kernel. >=20 > The automated process makes it easy to keep the kernel version of zstd up= to > date. The current zstd in the kernel shares the guts of the code, but has= a > lot of API and minor changes to work in the kernel. This is because at the > time upstream zstd was not ready to be used in the kernel envrionment > as-is. But, since then upstream zstd has evolved to support being used in > the kernel as-is. >=20 > Why are we updating in one big patch? > ------------------------------------- >=20 > The 3rd patch in the series is very large. This is because it is > restructuring the code, so it both deletes the existing zstd, and re-adds > the new structure. Future updates will be directly proportional to the > changes in upstream zstd since the last import. They will admittidly be > large, as zstd is an actively developed project, and has hundreds of > commits between every release. However, there is no other great > alternative. >=20 > One option ruled out is to replay every upstream zstd commit. This is not > feasible for several reasons: > - There are over 3500 upstream commits since the zstd version in the kern= el. > - The automation to automatically generate the kernel update was only add= ed > recently, so older commits cannot easily be imported. > - Not every upstream zstd commit builds. > - Only zstd releases are "supported", and individual commits may have bugs > that were fixed before a release. >=20 > Another option to reduce the patch size would be to first reorganize to t= he > new file structure, and then apply the patch. However, the current kernel > zstd is formatted with clang-format to be more "kernel-like". But, the new > method imports zstd as-is, without additional formatting, to allow for > closer correlation with upstream, and easier debugging. So the patch > wouldn't be any smaller. >=20 > It also doesn't make sense to import upstream zstd commit by commit going > forward. Upstream zstd doesn't support production use cases running of the > development branch. We have a lot of post-commit fuzzing that catches many > bugs, so indiviudal commits may be buggy, but fixed before a release. So > going forward, I intend to import every (important) zstd release into the > Kernel. >=20 > So, while it isn't ideal, updating in one big patch is the only patch I s= ee > forward. >=20 > Who is responsible for this code? > --------------------------------- >=20 > I am. This patchset adds me as the maintainer for zstd. Previously, there > was no tree for zstd patches. Because of that, there were several patches > that either got ignored, or took a long time to merge, since it wasn't > clear which tree should pick them up. I'm officially stepping up as > maintainer, and setting up my tree as the path through which zstd patches > get merged. I'll make sure that patches to the kernel zstd get ported > upstream, so they aren't erased when the next version update happens. >=20 > How is this code tested? > ------------------------ >=20 > I tested every caller of zstd on x86_64 (BtrFS, ZRAM, SquashFS, F2FS, > Kernel, InitRAMFS). I also tested Kernel & InitRAMFS on i386 and aarch64.= I > checked both performance and correctness. >=20 > Also, thanks to many people in the community who have tested these patches > locally. If you have tested the patches, please reply with a Tested-By so= I > can collect them for the PR I will send to Linus. >=20 > Lastly, this code will bake in linux-next before being merged into v5.16. >=20 > Why update to zstd-1.4.10 when zstd-1.5.0 has been released? > ------------------------------------------------------------ >=20 > This patchset has been outstanding since 2020, and zstd-1.4.10 was the > latest release when it was created. Since the update patch is automatical= ly > generated from upstream, I could generate it from zstd-1.5.0. However, > there were some large stack usage regressions in zstd-1.5.0, and are only > fixed in the latest development branch. And the latest development branch > contains some new code that needs to bake in the fuzzer before I would fe= el > comfortable releasing to the kernel. >=20 > Once this patchset has been merged, and we've released zstd-1.5.1, we can > update the kernel to zstd-1.5.1, and exercise the update process. >=20 > You may notice that zstd-1.4.10 doesn't exist upstream. This release is an > artifical release based off of zstd-1.4.9, with some fixes for the kernel > backported from the development branch. I will tag the zstd-1.4.10 release > after this patchset is merged, so the Linux Kernel is running a known > version of zstd that can be debugged upstream. >=20 > Why was a wrapper API added? > ---------------------------- >=20 > The first versions of this patchset migrated the kernel to the upstream z= std > API. It first added a shim API that supported the new upstream API with t= he > old code, then updated callers to use the new shim API, then transitioned > to the new code and deleted the shim API. However, Cristoph Hellwig > suggested that we transition to a kernel style API, and hide zstd's > upstream API behind that. This is because zstd's upstream API is supports > many other use cases, and does not follow the kernel style guide, while t= he > kernel API is focused on the kernel's use cases, and follows the kernel > style guide. >=20 > Changelog > --------- >=20 > v1 -> v2: > * Successfully tested F2FS with help from Chao Yu to fix my test. > * (1/9) Fix ZSTD_initCStream() wrapper to handle pledged_src_size=3D0 mea= ns > unknown. This fixes F2FS with the zstd-1.4.6 compatibility wrapper, expos= ed > by the test. >=20 > v2 -> v3: > * (3/9) Silence warnings by Kernel Test Robot: > https://github.com/facebook/zstd/pull/2324 > Stack size warnings remain, but these aren't new, and the functions it > warns on are either unused or not in the maximum stack path. This patchset > reduces zstd compression stack usage by 1 KB overall. I've gotten the low > hanging fruit, and more stack reduction would require significant changes > that have the potential to introduce new bugs. However, I do hope to > continue to reduce zstd stack usage in future versions. >=20 > v3 -> v4: > * (3/9) Fix errors and warnings reported by Kernel Test Robot: > https://github.com/facebook/zstd/pull/2326 > - Replace mem.h with a custom kernel implementation that matches the > current lib/zstd/mem.h in the kernel. This avoids calls to > __builtin_bswap*() which don't work on certain architectures, as exposed = by > the Kernel Test Robot. - Remove ASAN/MSAN (un)poisoning code which doesn't > work in the kernel, as exposed by the Kernel Test Robot. > - I've fixed all of the valid cppcheck warnings reported, but there were > many false positives, where cppcheck was incorrectly analyzing the > situation, which I did not fix. I don't believe it is reasonable to expect > that upstream zstd silences all the static analyzer false positives. > Upstream zstd uses clang scan-build for its static analysis. We find that > supporting multiple static analysis tools multiplies the burden of > silencing false positives, without providing enough marginal value over > running a single static analysis tool. >=20 > v4 -> v5: > * Rebase onto v5.10-rc2 > * (6/9) Merge with other F2FS changes (no functional change in patch). >=20 > v5 -> v6: > * Rebase onto v5.10-rc6. > * Switch to using a kernel style wrapper API as suggested by Cristoph. >=20 > v6 -> v7: > * Expose the upstream library header as `include/linux/zstd_lib.h`. > Instead of creating new structs mirroring the upstream zstd structs > use upstream's structs directly with a typedef to get a kernel style na= me. > This removes the memcpy cruft. > * (1/3) Undo ZSTD_WINDOWLOG_MAX and handle_zstd_error changes. > * (3/3) Expose zstd_errors.h as `include/linux/zstd_errors.h` because it > is needed by the kernel wrapper API. >=20 > v7 -> v8: > * (1/3) Fix typo in EXPORT_SYMBOL(). > * (1/3) Fix typo in zstd.h comments. > * (3/3) Update to latest zstd release: 1.4.6 -> 1.4.10 > This includes ~1KB of stack space reductions. >=20 > v8 -> v9: > * (1/3) Rebase onto v5.12-rc5 > * (1/3) Add zstd_min_clevel() & zstd_max_clevel() and use in f2fs. > Thanks to Oleksandr Natalenko for spotting it! > * (1/3) Move lib/decompress_unzstd.c usage of ZSTD_getErrorCode() > to zstd_get_error_code(). > * (1/3) Update modified zstd headers to yearless copyright. > * (2/3) Add copyright/license header to decompress_sources.h for > consistency. * (3/3) Update to yearless copyright for all zstd files. > Thanks to Mike Dolan for spotting it! >=20 > v9 -> v10: > * Add a 4th patch in the series which adds an entry for zstd to MAINTAINE= RS. >=20 > v10 -> v11: > * Rebase cleanly onto v5.12-rc8 > * (3/4) Replace invalid kernel style comments in zstd with regular commen= ts. > Thanks to Randy Dunlap for the suggestion. >=20 > v11 -> v12: > * Re-write the cover letter & send as a PR only. > * Rebase cleanly onto 5.15-rc4. > * (3/4) Clean up licensing to reflect that we're GPL-2.0+ OR BSD-3-Clause. > * (3/4) Reduce compression stack usage by 80 bytes. > * (3/4) Make upstream zstd `-Wfall-through` compliant and use the > FALLTHROUGH macro in the Linux Kernel. >=20 > Signed-off-by: Nick Terrell >=20 > ---------------------------------------------------------------- > Nick Terrell (4): > lib: zstd: Add kernel-specific API > lib: zstd: Add decompress_sources.h for decompress_unzstd > lib: zstd: Upgrade to latest upstream zstd version 1.4.10 > MAINTAINERS: Add maintainer entry for zstd >=20 > MAINTAINERS | 12 + > crypto/zstd.c | 28 +- > fs/btrfs/zstd.c | 68 +- > fs/f2fs/compress.c | 56 +- > fs/f2fs/super.c | 2 +- > fs/pstore/platform.c | 2 +- > fs/squashfs/zstd_wrapper.c | 16 +- > include/linux/zstd.h | 1252 ++---- > include/linux/zstd_errors.h | 77 + > include/linux/zstd_lib.h | 2432 +++++++++++ > lib/decompress_unzstd.c | 48 +- > lib/zstd/Makefile | 46 +- > lib/zstd/bitstream.h | 380 -- > lib/zstd/common/bitstream.h | 437 ++ > lib/zstd/common/compiler.h | 170 + > lib/zstd/common/cpu.h | 194 + > lib/zstd/common/debug.c | 24 + > lib/zstd/common/debug.h | 101 + > lib/zstd/common/entropy_common.c | 357 ++ > lib/zstd/common/error_private.c | 56 + > lib/zstd/common/error_private.h | 66 + > lib/zstd/common/fse.h | 710 ++++ > lib/zstd/common/fse_decompress.c | 390 ++ > lib/zstd/common/huf.h | 356 ++ > lib/zstd/common/mem.h | 259 ++ > lib/zstd/common/zstd_common.c | 83 + > lib/zstd/common/zstd_deps.h | 125 + > lib/zstd/common/zstd_internal.h | 450 +++ > lib/zstd/compress.c | 3485 ---------------- > lib/zstd/compress/fse_compress.c | 625 +++ > lib/zstd/compress/hist.c | 165 + > lib/zstd/compress/hist.h | 75 + > lib/zstd/compress/huf_compress.c | 905 +++++ > lib/zstd/compress/zstd_compress.c | 5109 > ++++++++++++++++++++++++ lib/zstd/compress/zstd_compress_internal.h | > 1188 ++++++ > lib/zstd/compress/zstd_compress_literals.c | 158 + > lib/zstd/compress/zstd_compress_literals.h | 29 + > lib/zstd/compress/zstd_compress_sequences.c | 439 ++ > lib/zstd/compress/zstd_compress_sequences.h | 54 + > lib/zstd/compress/zstd_compress_superblock.c | 850 ++++ > lib/zstd/compress/zstd_compress_superblock.h | 32 + > lib/zstd/compress/zstd_cwksp.h | 482 +++ > lib/zstd/compress/zstd_double_fast.c | 519 +++ > lib/zstd/compress/zstd_double_fast.h | 32 + > lib/zstd/compress/zstd_fast.c | 496 +++ > lib/zstd/compress/zstd_fast.h | 31 + > lib/zstd/compress/zstd_lazy.c | 1412 +++++++ > lib/zstd/compress/zstd_lazy.h | 81 + > lib/zstd/compress/zstd_ldm.c | 686 ++++ > lib/zstd/compress/zstd_ldm.h | 110 + > lib/zstd/compress/zstd_ldm_geartab.h | 103 + > lib/zstd/compress/zstd_opt.c | 1345 +++++++ > lib/zstd/compress/zstd_opt.h | 50 + > lib/zstd/decompress.c | 2531 ------------ > lib/zstd/decompress/huf_decompress.c | 1206 ++++++ > lib/zstd/decompress/zstd_ddict.c | 241 ++ > lib/zstd/decompress/zstd_ddict.h | 44 + > lib/zstd/decompress/zstd_decompress.c | 2082 ++++++++++ > lib/zstd/decompress/zstd_decompress_block.c | 1540 +++++++ > lib/zstd/decompress/zstd_decompress_block.h | 62 + > lib/zstd/decompress/zstd_decompress_internal.h | 202 + > lib/zstd/decompress_sources.h | 28 + > lib/zstd/entropy_common.c | 243 -- > lib/zstd/error_private.h | 53 - > lib/zstd/fse.h | 575 --- > lib/zstd/fse_compress.c | 795 ---- > lib/zstd/fse_decompress.c | 325 -- > lib/zstd/huf.h | 212 - > lib/zstd/huf_compress.c | 773 ---- > lib/zstd/huf_decompress.c | 960 ----- > lib/zstd/mem.h | 151 - > lib/zstd/zstd_common.c | 75 - > lib/zstd/zstd_compress_module.c | 160 + > lib/zstd/zstd_decompress_module.c | 105 + > lib/zstd/zstd_internal.h | 273 -- > lib/zstd/zstd_opt.h | 1014 ----- > 76 files changed, 27367 insertions(+), 12941 deletions(-) > create mode 100644 include/linux/zstd_errors.h > create mode 100644 include/linux/zstd_lib.h > delete mode 100644 lib/zstd/bitstream.h > create mode 100644 lib/zstd/common/bitstream.h > create mode 100644 lib/zstd/common/compiler.h > create mode 100644 lib/zstd/common/cpu.h > create mode 100644 lib/zstd/common/debug.c > create mode 100644 lib/zstd/common/debug.h > create mode 100644 lib/zstd/common/entropy_common.c > create mode 100644 lib/zstd/common/error_private.c > create mode 100644 lib/zstd/common/error_private.h > create mode 100644 lib/zstd/common/fse.h > create mode 100644 lib/zstd/common/fse_decompress.c > create mode 100644 lib/zstd/common/huf.h > create mode 100644 lib/zstd/common/mem.h > create mode 100644 lib/zstd/common/zstd_common.c > create mode 100644 lib/zstd/common/zstd_deps.h > create mode 100644 lib/zstd/common/zstd_internal.h > delete mode 100644 lib/zstd/compress.c > create mode 100644 lib/zstd/compress/fse_compress.c > create mode 100644 lib/zstd/compress/hist.c > create mode 100644 lib/zstd/compress/hist.h > create mode 100644 lib/zstd/compress/huf_compress.c > create mode 100644 lib/zstd/compress/zstd_compress.c > create mode 100644 lib/zstd/compress/zstd_compress_internal.h > create mode 100644 lib/zstd/compress/zstd_compress_literals.c > create mode 100644 lib/zstd/compress/zstd_compress_literals.h > create mode 100644 lib/zstd/compress/zstd_compress_sequences.c > create mode 100644 lib/zstd/compress/zstd_compress_sequences.h > create mode 100644 lib/zstd/compress/zstd_compress_superblock.c > create mode 100644 lib/zstd/compress/zstd_compress_superblock.h > create mode 100644 lib/zstd/compress/zstd_cwksp.h > create mode 100644 lib/zstd/compress/zstd_double_fast.c > create mode 100644 lib/zstd/compress/zstd_double_fast.h > create mode 100644 lib/zstd/compress/zstd_fast.c > create mode 100644 lib/zstd/compress/zstd_fast.h > create mode 100644 lib/zstd/compress/zstd_lazy.c > create mode 100644 lib/zstd/compress/zstd_lazy.h > create mode 100644 lib/zstd/compress/zstd_ldm.c > create mode 100644 lib/zstd/compress/zstd_ldm.h > create mode 100644 lib/zstd/compress/zstd_ldm_geartab.h > create mode 100644 lib/zstd/compress/zstd_opt.c > create mode 100644 lib/zstd/compress/zstd_opt.h > delete mode 100644 lib/zstd/decompress.c > create mode 100644 lib/zstd/decompress/huf_decompress.c > create mode 100644 lib/zstd/decompress/zstd_ddict.c > create mode 100644 lib/zstd/decompress/zstd_ddict.h > create mode 100644 lib/zstd/decompress/zstd_decompress.c > create mode 100644 lib/zstd/decompress/zstd_decompress_block.c > create mode 100644 lib/zstd/decompress/zstd_decompress_block.h > create mode 100644 lib/zstd/decompress/zstd_decompress_internal.h > create mode 100644 lib/zstd/decompress_sources.h > delete mode 100644 lib/zstd/entropy_common.c > delete mode 100644 lib/zstd/error_private.h > delete mode 100644 lib/zstd/fse.h > delete mode 100644 lib/zstd/fse_compress.c > delete mode 100644 lib/zstd/fse_decompress.c > delete mode 100644 lib/zstd/huf.h > delete mode 100644 lib/zstd/huf_compress.c > delete mode 100644 lib/zstd/huf_decompress.c > delete mode 100644 lib/zstd/mem.h > delete mode 100644 lib/zstd/zstd_common.c > create mode 100644 lib/zstd/zstd_compress_module.c > create mode 100644 lib/zstd/zstd_decompress_module.c > delete mode 100644 lib/zstd/zstd_internal.h > delete mode 100644 lib/zstd/zstd_opt.h =2D-=20 Oleksandr Natalenko (post-factum) 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 mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 367DDC433F5 for ; Wed, 6 Oct 2021 07:52:05 +0000 (UTC) Received: from lists.sourceforge.net (lists.sourceforge.net [216.105.38.7]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id C3A27600EF; Wed, 6 Oct 2021 07:52:04 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org C3A27600EF Authentication-Results: mail.kernel.org; dmarc=pass (p=none dis=none) header.from=lists.sourceforge.net Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=lists.sourceforge.net DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.sourceforge.net; s=beta; h=Content-Transfer-Encoding:Content-Type:Cc: Reply-To:From:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:Subject:MIME-Version:References:In-Reply-To: Message-ID:Date:To:Sender:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=b1r2Dni6gE9iWYltAyUAWW7GY6reAz2w1bDGxcXTWlg=; b=j+mhA7ewSfY+gbBr8wGYKcurw Zx14uGe/+GFa11U/UfZiXrbVEqXWVLikX7GMNEbGKIxGxrdwH0NS0luRETb2i1jV/Yx62mW0nLQKk Iv6xzV8wH05i4v5W7R+72NeCmCIjbVq2PK8eazVS4RGmDaHgd/fYakZuiXibT518ZB09c=; Received: from [127.0.0.1] (helo=sfs-ml-4.v29.lw.sourceforge.com) by sfs-ml-4.v29.lw.sourceforge.com with esmtp (Exim 4.90_1) (envelope-from ) id 1mY1ie-00036d-8C; Wed, 06 Oct 2021 07:52:04 +0000 Received: from [172.30.20.202] (helo=mx.sourceforge.net) by sfs-ml-4.v29.lw.sourceforge.com with esmtps (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.90_1) (envelope-from ) id 1mY1id-00036U-Au; Wed, 06 Oct 2021 07:52:03 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=sourceforge.net; s=x; h=Content-Type:Content-Transfer-Encoding:MIME-Version :References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From:Sender:Reply-To: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=kCaMpgYXPXXydkTsRi5p9icWnhbXT3w/9Sbrl4jpjvg=; b=H4YGKSmhr8a2tDkP1MHKmgfbEp 17n9BajhDGEyGhhK3n55uS8rpPZdUeJbAVImA5Bbxl2RDiHyu2K6a/FwsJyLtbLrpaCxeVT1tieT4 R0yWtvnaJSimLafnHfe/8eubPJwvyBZfEZNhR8daC2w3pR+eEM7x4nxsVQYI0EiiRoAc=; DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=sf.net; s=x ; h=Content-Type:Content-Transfer-Encoding:MIME-Version:References: In-Reply-To:Message-ID:Date:Subject:Cc:To:From:Sender:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Id:List-Help:List-Unsubscribe:List-Subscribe: List-Post:List-Owner:List-Archive; bh=kCaMpgYXPXXydkTsRi5p9icWnhbXT3w/9Sbrl4jpjvg=; b=UD+JhZIk5gP2mYwaksiuMwXYM0 kIYNZ1mouYqw52YjWKxJMo+KMNQrAExQs8tgc3SxCFhzIF/0SEZsOQHIlnPYorCULXB542NCV4NMo 5YavStz566C7mBod8cjbh8Bm8PzsKfbgZNn5z3JKEUDGHaqvmZ3Lz5UWsZARafqLzQVk=; Received: from vulcan.natalenko.name ([104.207.131.136]) by sfi-mx-2.v28.lw.sourceforge.com with esmtps (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.92.3) id 1mY1iX-000451-E1; Wed, 06 Oct 2021 07:52:03 +0000 Received: from spock.localnet (unknown [151.237.229.131]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by vulcan.natalenko.name (Postfix) with ESMTPSA id 3E483C23CB3; Wed, 6 Oct 2021 09:33:23 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=natalenko.name; s=dkim-20170712; t=1633505603; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=kCaMpgYXPXXydkTsRi5p9icWnhbXT3w/9Sbrl4jpjvg=; b=CN1ew3MpM4LFHohH0158mpk/oc96vr+yAtIU58GIq21z8ryESCabmEs1ZkMBsW5zggkD8h InR8+ArzrqpVza6j8h6GzBW8zr2AKWxbzEqFwd4dxI7jR7NU+7M8p/uDA00iV6JS2ByWPL HeL5zBg5jkn2G37aN/JPGzNgcUnShfY= To: Stephen Rothwell , Nick Terrell Date: Wed, 06 Oct 2021 09:33:21 +0200 Message-ID: <1711282.gcEllRqJC2@natalenko.name> In-Reply-To: <20211005014118.3164585-1-nickrterrell@gmail.com> References: <20211005014118.3164585-1-nickrterrell@gmail.com> MIME-Version: 1.0 X-Headers-End: 1mY1iX-000451-E1 Subject: Re: [f2fs-dev] [GIT PULL][v12] zstd changes for linux-next X-BeenThere: linux-f2fs-devel@lists.sourceforge.net X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , From: Oleksandr Natalenko via Linux-f2fs-devel Reply-To: Oleksandr Natalenko Cc: squashfs-devel@lists.sourceforge.net, Paul Jones , Randy Dunlap , Christoph Hellwig , Nick Terrell , Yann Collet , David Sterba , linux-kernel@vger.kernel.org, Tom Seewald , linux-f2fs-devel@lists.sourceforge.net, Petr Malat , Chris Mason , Nick Terrell , linux-next@vger.kernel.org, linux-crypto@vger.kernel.org, Felix Handte , Kernel Team , =?utf-8?B?TWljaGHFgiBNaXJvc8WCYXc=?= , Eric Biggers , linux-btrfs@vger.kernel.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: linux-f2fs-devel-bounces@lists.sourceforge.net SGVsbG8uCgpPbiDDunRlcsO9IDUuIMWZw61qbmEgMjAyMSAzOjQxOjE4IENFU1QgTmljayBUZXJy ZWxsIHdyb3RlOgo+IEZyb206IE5pY2sgVGVycmVsbCA8dGVycmVsbG5AZmIuY29tPgo+IAo+IFRo ZSBmb2xsb3dpbmcgY2hhbmdlcyBzaW5jZSBjb21taXQgYTI1MDA2YTc3MzQ4YmEwNmM3YmM5NjUy MGQzMzFjZDlkZDM3MDcxNToKPiAKPiAgIEFkZCBsaW51eC1uZXh0IHNwZWNpZmljIGZpbGVzIGZv ciAyMDIxMTAwMSAoMjAyMS0xMC0wMSAxNzowNzozNyArMTAwMCkKPiAKPiBhcmUgYXZhaWxhYmxl IGluIHRoZSBHaXQgcmVwb3NpdG9yeSBhdDoKPiAKPiAgIGdpdEBnaXRodWIuY29tOnRlcnJlbGxu L2xpbnV4LmdpdCB0YWdzL3YxMi16c3RkLTEuNC4xMAo+IAo+IGZvciB5b3UgdG8gZmV0Y2ggY2hh bmdlcyB1cCB0byA1MjEwY2EzM2IwOWJlZDVlMDlmNzJlOWI0NmEzMjIwZjY0NTk3ZjhjOgo+IAo+ ICAgTUFJTlRBSU5FUlM6IEFkZCBtYWludGFpbmVyIGVudHJ5IGZvciB6c3RkICgyMDIxLTEwLTA0 IDE4OjE0OjQyIC0wNzAwKQo+IAo+IEkgd291bGQgbGlrZSB0byBtZXJnZSB0aGlzIHB1bGwgcmVx dWVzdCBpbnRvIGxpbnV4LW5leHQgdG8gYmFrZSwgYW5kIHRoZW4KPiBzdWJtaXQgdGhlIFBSIHRv IExpbnV4IGluIHRoZSA1LjE2IG1lcmdlIHdpbmRvdy4gSWYgeW91IGhhdmUgYmVlbiBhIHBhcnQg b2YKPiB0aGUgZGlzY3Vzc2lvbiwgYXJlIGEgbWFpbnRhaW5lciBvZiBhIGNhbGxlciBvZiB6c3Rk LCB0ZXN0ZWQgdGhpcyBjb2RlLCBvcgo+IG90aGVyd2lzZSBiZWVuIGludm9sdmVkLCB0aGFuayB5 b3UhIEFuZCBjb3VsZCB5b3UgcGxlYXNlIHJlc3BvbmQgYmVsb3cgd2l0aAo+IGFuIGFwcHJvcGlh dGUgdGFnLCBzbyBJIGNhbiBjb2xsZWN0IHN1cHBvcnQgZm9yIHRoZSBQUgo+IAo+IEJlc3QsCj4g TmljayBUZXJyZWxsCgpPbiBib3RoIDUuMTQgYW5kIDUuMTU6CgpUZXN0ZWQtYnk6IE9sZWtzYW5k ciBOYXRhbGVua28gPG9sZWtzYW5kckBuYXRhbGVua28ubmFtZT4KCj4gCj4gLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+IFVw ZGF0ZSB0byB6c3RkLTEuNC4xMAo+IAo+IC0gVGhlIGZpcnN0IGNvbW1pdCBhZGRzIGEgbmV3IGtl cm5lbC1zdHlsZSB3cmFwcGVyIGFyb3VuZCB6c3RkLiBUaGlzIHdyYXBwZXIKPiBBUEkgaXMgZnVu Y3Rpb25hbGx5IGVxdWl2YWxlbnQgdG8gdGhlIHN1YnNldCBvZiB0aGUgY3VycmVudCB6c3RkIEFQ SSB0aGF0Cj4gaXMgY3VycmVudGx5IHVzZWQuIFRoZSB3cmFwcGVyIEFQSSBjaGFuZ2VzIHRvIGJl IGtlcm5lbCBzdHlsZSBzbyB0aGF0IHRoZQo+IHN5bWJvbHMgZG9uJ3QgY29sbGlkZSB3aXRoIHpz dGQncyBzeW1ib2xzLiBUaGUgdXBkYXRlIHRvIHpzdGQtMS40LjEwCj4gbWFpbnRhaW5zIHRoZSBz YW1lIEFQSSBhbmQgcHJlc2VydmVzIHRoZSBzZW1hbnRpY3MsIHNvIHRoYXQgbm9uZSBvZiB0aGUK PiBjYWxsZXJzIG5lZWQgdG8gYmUgdXBkYXRlZC4gQWxsIGNhbGxlcnMgYXJlIHVwZGF0ZWQgaW4g dGhlIGNvbW1pdCwgYmVjYXVzZQo+IHRoZXJlIGFyZSB6ZXJvIGZ1bmN0aW9uYWwgY2hhbmdlcy4K PiAtIFRoZSBzZWNvbmQgY29tbWl0IGFkZHMgYW4gaW5kaXJlY3Rpb24gZm9yIGBsaWIvZGVjb21w cmVzc191bnpzdGQuY2Agc28gaXQKPiAgIGRvZXNuJ3QgZGVwZW5kIG9uIHRoZSBsYXlvdXQgb2Yg YGxpYi96c3RkL2AgdG8gaW5jbHVkZSBldmVyeSBzb3VyY2UgZmlsZS4KPiAgIFRoaXMgYWxsb3dz IHRoZSBuZXh0IHBhdGNoIHRvIGJlIGF1dG9tYXRpY2FsbHkgZ2VuZXJhdGVkLgo+IC0gVGhlIHRo aXJkIGNvbW1pdCBpcyBhdXRvbWF0aWNhbGx5IGdlbmVyYXRlZCwgYW5kIGltcG9ydHMgdGhlIHpz dGQtMS40LjEwCj4gc291cmNlIGNvZGUuIFRoaXMgY29tbWl0IGlzIGNvbXBsZXRlbHkgZ2VuZXJh dGVkIGJ5IGF1dG9tYXRpb24uCj4gLSBUaGUgZm91cnRoIGNvbW1pdCBhZGRzIG1lICh0ZXJyZWxs bkBmYi5jb20pIGFzIHRoZSBtYWludGFpbmVyIG9mCj4gYGxpYi96c3RkYC4KPiAKPiBUaGUgZGlz Y3Vzc2lvbiBhcm91bmQgdGhpcyBwYXRjaHNldCBoYXMgYmVlbiBwcmV0dHkgbG9uZywgc28gSSd2 ZSBpbmNsdWRlZCBhCj4gRkFRLXN0eWxlIHN1bW1hcnkgb2YgdGhlIGhpc3Rvcnkgb2YgdGhlIHBh dGNoc2V0LCBhbmQgd2h5IHdlIGFyZSB0YWtpbmcKPiB0aGlzIGFwcHJvYWNoLgo+IAo+IFdoeSBk byB3ZSBuZWVkIHRvIHVwZGF0ZT8KPiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gCj4gVGhl IHpzdGQgdmVyc2lvbiBpbiB0aGUga2VybmVsIGlzIGJhc2VkIG9mZiBvZiB6c3RkLTEuMy4xLCB3 aGljaCBpcyB3YXMKPiByZWxlYXNlZCBBdWd1c3QgMjAsIDIwMTcuIFNpbmNlIHRoZW4genN0ZCBo YXMgc2VlbiBtYW55IGJ1ZyBmaXhlcyBhbmQKPiBwZXJmb3JtYW5jZSBpbXByb3ZlbWVudHMuIEFu ZCwgaW1wb3J0YW50bHksIHVwc3RyZWFtIHpzdGQgaXMgY29udGludW91c2x5Cj4gZnV6emVkIGJ5 IE9TUy1GdXp6LCBhbmQgYnVnIGZpeGVzIGFyZW4ndCBiYWNrcG9ydGVkIHRvIG9sZGVyIHZlcnNp b25zLiBTbwo+IHRoZSBvbmx5IHdheSB0byBzYW5lbHkgZ2V0IHRoZXNlIGZpeGVzIGlzIHRvIGtl ZXAgdXAgdG8gZGF0ZSB3aXRoIHVwc3RyZWFtCj4genN0ZC4gVGhlcmUgYXJlIG5vIGtub3duIHNl Y3VyaXR5IGlzc3VlcyB0aGF0IGFmZmVjdCB0aGUga2VybmVsLCBidXQgd2UKPiBuZWVkIHRvIGJl IGFibGUgdG8gdXBkYXRlIGluIGNhc2UgdGhlcmUgYXJlLiBBbmQgd2hpbGUgdGhlcmUgYXJlIG5v IGtub3duCj4gc2VjdXJpdHkgaXNzdWVzLCB0aGVyZSBhcmUgcmVsZXZhbnQgYnVnIGZpeGVzLiBG b3IgZXhhbXBsZSB0aGUgcHJvYmxlbSB3aXRoCj4gbGFyZ2Uga2VybmVsIGRlY29tcHJlc3Npb24g aGFzIGJlZW4gZml4ZWQgdXBzdHJlYW0gZm9yIG92ZXIgMiB5ZWFycwo+IGh0dHBzOi8vbGttbC5v cmcvbGttbC8yMDIwLzkvMjkvMjcuCj4gCj4gQWRkaXRpb25hbGx5IHRoZSBwZXJmb3JtYW5jZSBp bXByb3ZlbWVudHMgZm9yIGtlcm5lbCB1c2UgY2FzZXMgYXJlCj4gc2lnbmlmaWNhbnQuIE1lYXN1 cmVkIGZvciB4ODZfNjQgb24gbXkgSW50ZWwgaTktOTkwMGsgQCAzLjYgR0h6Ogo+IAo+IC0gQnRy RlMgenN0ZCBjb21wcmVzc2lvbiBhdCBsZXZlbHMgMSBhbmQgMyBpcyA1JSBmYXN0ZXIKPiAtIEJ0 ckZTIHpzdGQgZGVjb21wcmVzc2lvbityZWFkIGlzIDE1JSBmYXN0ZXIKPiAtIFNxdWFzaEZTIHpz dGQgZGVjb21wcmVzc2lvbityZWFkIGlzIDE1JSBmYXN0ZXIKPiAtIEYyRlMgenN0ZCBjb21wcmVz c2lvbit3cml0ZSBhdCBsZXZlbCAzIGlzIDglIGZhc3Rlcgo+IC0gRjJGUyB6c3RkIGRlY29tcHJl c3Npb24rcmVhZCBpcyAyMCUgZmFzdGVyCj4gLSBaUkFNIGRlY29tcHJlc3Npb24rcmVhZCBpcyAz MCUgZmFzdGVyCj4gLSBLZXJuZWwgenN0ZCBkZWNvbXByZXNzaW9uIGlzIDM1JSBmYXN0ZXIKPiAt IEluaXRyYW1mcyB6c3RkIGRlY29tcHJlc3Npb24rYnVpbGQgaXMgNSUgZmFzdGVyCj4gCj4gT24g dG9wIG9mIHRoaXMsIHRoZXJlIGFyZSBzaWduaWZpY2FudCBwZXJmb3JtYW5jZSBpbXByb3ZlbWVu dHMgY29taW5nIGRvd24KPiB0aGUgbGluZSBpbiB0aGUgbmV4dCB6c3RkIHJlbGVhc2UsIGFuZCB0 aGUgbmV3IGF1dG9tYXRlZCB1cGRhdGUgcGF0Y2gKPiBnZW5lcmF0aW9uIHdpbGwgYWxsb3cgdXMg dG8gcHVsbCB0aGVtIGVhc2lseS4KPiAKPiBIb3cgaXMgdGhlIHVwZGF0ZSBwYXRjaCBnZW5lcmF0 ZWQ/Cj4gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+IAo+IFRoZSBmaXJzdCB0 d28gcGF0Y2hlcyBhcmUgcHJlcGFyYXRpb24gZm9yIHVwZGF0aW5nIHRoZSB6c3RkIHZlcnNpb24u IFRoZW4KPiB0aGUgM3JkIHBhdGNoIGluIHRoZSBzZXJpZXMgaW1wb3J0cyB1cHN0cmVhbSB6c3Rk IGludG8gdGhlIGtlcm5lbC4gVGhpcwo+IHBhdGNoIGlzIGF1dG9tYXRpY2FsbHkgZ2VuZXJhdGVk IGZyb20gdXBzdHJlYW0uIEEgc2NyaXB0IG1ha2VzIHRoZQo+IG5lY2Vzc2FyeSBjaGFuZ2VzIGFu ZCBpbXBvcnRzIGl0IGludG8gdGhlIGtlcm5lbC4gVGhlIGNoYW5nZXMgYXJlOgo+IAo+IC0gUmVw bGFjZSBhbGwgbGliYyBkZXBlbmRlbmNpZXMgd2l0aCBrZXJuZWwgcmVwbGFjZW1lbnRzIGFuZCBy ZXdyaXRlCj4gaW5jbHVkZXMuIC0gUmVtb3ZlIHVubmNlc3NhcnkgcG9ydGFiaWxpdHkgbWFjcm9z IGxpa2U6ICNpZgo+IGRlZmluZWQoX01TQ19WRVIpLiAtIFVzZSB0aGUga2VybmVsIHh4aGFzaCBp bnN0ZWFkIG9mIGJ1bmRsaW5nIGl0Lgo+IAo+IFRoaXMgYXV0b21hdGlvbiBnZXRzIHRlc3RlZCBl dmVyeSBjb21taXQgYnkgdXBzdHJlYW0ncyBjb250aW51b3VzCj4gaW50ZWdyYXRpb24uIFdoZW4g d2UgY3V0IGEgbmV3IHpzdGQgcmVsZWFzZSwgd2Ugd2lsbCBzdWJtaXQgYSBwYXRjaCB0byB0aGUK PiBrZXJuZWwgdG8gdXBkYXRlIHRoZSB6c3RkIHZlcnNpb24gaW4gdGhlIGtlcm5lbC4KPiAKPiBU aGUgYXV0b21hdGVkIHByb2Nlc3MgbWFrZXMgaXQgZWFzeSB0byBrZWVwIHRoZSBrZXJuZWwgdmVy c2lvbiBvZiB6c3RkIHVwIHRvCj4gZGF0ZS4gVGhlIGN1cnJlbnQgenN0ZCBpbiB0aGUga2VybmVs IHNoYXJlcyB0aGUgZ3V0cyBvZiB0aGUgY29kZSwgYnV0IGhhcyBhCj4gbG90IG9mIEFQSSBhbmQg bWlub3IgY2hhbmdlcyB0byB3b3JrIGluIHRoZSBrZXJuZWwuIFRoaXMgaXMgYmVjYXVzZSBhdCB0 aGUKPiB0aW1lIHVwc3RyZWFtIHpzdGQgd2FzIG5vdCByZWFkeSB0byBiZSB1c2VkIGluIHRoZSBr ZXJuZWwgZW52cmlvbm1lbnQKPiBhcy1pcy4gQnV0LCBzaW5jZSB0aGVuIHVwc3RyZWFtIHpzdGQg aGFzIGV2b2x2ZWQgdG8gc3VwcG9ydCBiZWluZyB1c2VkIGluCj4gdGhlIGtlcm5lbCBhcy1pcy4K PiAKPiBXaHkgYXJlIHdlIHVwZGF0aW5nIGluIG9uZSBiaWcgcGF0Y2g/Cj4gLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+IAo+IFRoZSAzcmQgcGF0Y2ggaW4gdGhlIHNlcmll cyBpcyB2ZXJ5IGxhcmdlLiBUaGlzIGlzIGJlY2F1c2UgaXQgaXMKPiByZXN0cnVjdHVyaW5nIHRo ZSBjb2RlLCBzbyBpdCBib3RoIGRlbGV0ZXMgdGhlIGV4aXN0aW5nIHpzdGQsIGFuZCByZS1hZGRz Cj4gdGhlIG5ldyBzdHJ1Y3R1cmUuIEZ1dHVyZSB1cGRhdGVzIHdpbGwgYmUgZGlyZWN0bHkgcHJv cG9ydGlvbmFsIHRvIHRoZQo+IGNoYW5nZXMgaW4gdXBzdHJlYW0genN0ZCBzaW5jZSB0aGUgbGFz dCBpbXBvcnQuIFRoZXkgd2lsbCBhZG1pdHRpZGx5IGJlCj4gbGFyZ2UsIGFzIHpzdGQgaXMgYW4g YWN0aXZlbHkgZGV2ZWxvcGVkIHByb2plY3QsIGFuZCBoYXMgaHVuZHJlZHMgb2YKPiBjb21taXRz IGJldHdlZW4gZXZlcnkgcmVsZWFzZS4gSG93ZXZlciwgdGhlcmUgaXMgbm8gb3RoZXIgZ3JlYXQK PiBhbHRlcm5hdGl2ZS4KPiAKPiBPbmUgb3B0aW9uIHJ1bGVkIG91dCBpcyB0byByZXBsYXkgZXZl cnkgdXBzdHJlYW0genN0ZCBjb21taXQuIFRoaXMgaXMgbm90Cj4gZmVhc2libGUgZm9yIHNldmVy YWwgcmVhc29uczoKPiAtIFRoZXJlIGFyZSBvdmVyIDM1MDAgdXBzdHJlYW0gY29tbWl0cyBzaW5j ZSB0aGUgenN0ZCB2ZXJzaW9uIGluIHRoZSBrZXJuZWwuCj4gLSBUaGUgYXV0b21hdGlvbiB0byBh dXRvbWF0aWNhbGx5IGdlbmVyYXRlIHRoZSBrZXJuZWwgdXBkYXRlIHdhcyBvbmx5IGFkZGVkCj4g cmVjZW50bHksIHNvIG9sZGVyIGNvbW1pdHMgY2Fubm90IGVhc2lseSBiZSBpbXBvcnRlZC4KPiAt IE5vdCBldmVyeSB1cHN0cmVhbSB6c3RkIGNvbW1pdCBidWlsZHMuCj4gLSBPbmx5IHpzdGQgcmVs ZWFzZXMgYXJlICJzdXBwb3J0ZWQiLCBhbmQgaW5kaXZpZHVhbCBjb21taXRzIG1heSBoYXZlIGJ1 Z3MKPiB0aGF0IHdlcmUgZml4ZWQgYmVmb3JlIGEgcmVsZWFzZS4KPiAKPiBBbm90aGVyIG9wdGlv biB0byByZWR1Y2UgdGhlIHBhdGNoIHNpemUgd291bGQgYmUgdG8gZmlyc3QgcmVvcmdhbml6ZSB0 byB0aGUKPiBuZXcgZmlsZSBzdHJ1Y3R1cmUsIGFuZCB0aGVuIGFwcGx5IHRoZSBwYXRjaC4gSG93 ZXZlciwgdGhlIGN1cnJlbnQga2VybmVsCj4genN0ZCBpcyBmb3JtYXR0ZWQgd2l0aCBjbGFuZy1m b3JtYXQgdG8gYmUgbW9yZSAia2VybmVsLWxpa2UiLiBCdXQsIHRoZSBuZXcKPiBtZXRob2QgaW1w b3J0cyB6c3RkIGFzLWlzLCB3aXRob3V0IGFkZGl0aW9uYWwgZm9ybWF0dGluZywgdG8gYWxsb3cg Zm9yCj4gY2xvc2VyIGNvcnJlbGF0aW9uIHdpdGggdXBzdHJlYW0sIGFuZCBlYXNpZXIgZGVidWdn aW5nLiBTbyB0aGUgcGF0Y2gKPiB3b3VsZG4ndCBiZSBhbnkgc21hbGxlci4KPiAKPiBJdCBhbHNv IGRvZXNuJ3QgbWFrZSBzZW5zZSB0byBpbXBvcnQgdXBzdHJlYW0genN0ZCBjb21taXQgYnkgY29t bWl0IGdvaW5nCj4gZm9yd2FyZC4gVXBzdHJlYW0genN0ZCBkb2Vzbid0IHN1cHBvcnQgcHJvZHVj dGlvbiB1c2UgY2FzZXMgcnVubmluZyBvZiB0aGUKPiBkZXZlbG9wbWVudCBicmFuY2guIFdlIGhh dmUgYSBsb3Qgb2YgcG9zdC1jb21taXQgZnV6emluZyB0aGF0IGNhdGNoZXMgbWFueQo+IGJ1Z3Ms IHNvIGluZGl2aXVkYWwgY29tbWl0cyBtYXkgYmUgYnVnZ3ksIGJ1dCBmaXhlZCBiZWZvcmUgYSBy ZWxlYXNlLiBTbwo+IGdvaW5nIGZvcndhcmQsIEkgaW50ZW5kIHRvIGltcG9ydCBldmVyeSAoaW1w b3J0YW50KSB6c3RkIHJlbGVhc2UgaW50byB0aGUKPiBLZXJuZWwuCj4gCj4gU28sIHdoaWxlIGl0 IGlzbid0IGlkZWFsLCB1cGRhdGluZyBpbiBvbmUgYmlnIHBhdGNoIGlzIHRoZSBvbmx5IHBhdGNo IEkgc2VlCj4gZm9yd2FyZC4KPiAKPiBXaG8gaXMgcmVzcG9uc2libGUgZm9yIHRoaXMgY29kZT8K PiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiAKPiBJIGFtLiBUaGlzIHBhdGNo c2V0IGFkZHMgbWUgYXMgdGhlIG1haW50YWluZXIgZm9yIHpzdGQuIFByZXZpb3VzbHksIHRoZXJl Cj4gd2FzIG5vIHRyZWUgZm9yIHpzdGQgcGF0Y2hlcy4gQmVjYXVzZSBvZiB0aGF0LCB0aGVyZSB3 ZXJlIHNldmVyYWwgcGF0Y2hlcwo+IHRoYXQgZWl0aGVyIGdvdCBpZ25vcmVkLCBvciB0b29rIGEg bG9uZyB0aW1lIHRvIG1lcmdlLCBzaW5jZSBpdCB3YXNuJ3QKPiBjbGVhciB3aGljaCB0cmVlIHNo b3VsZCBwaWNrIHRoZW0gdXAuIEknbSBvZmZpY2lhbGx5IHN0ZXBwaW5nIHVwIGFzCj4gbWFpbnRh aW5lciwgYW5kIHNldHRpbmcgdXAgbXkgdHJlZSBhcyB0aGUgcGF0aCB0aHJvdWdoIHdoaWNoIHpz dGQgcGF0Y2hlcwo+IGdldCBtZXJnZWQuIEknbGwgbWFrZSBzdXJlIHRoYXQgcGF0Y2hlcyB0byB0 aGUga2VybmVsIHpzdGQgZ2V0IHBvcnRlZAo+IHVwc3RyZWFtLCBzbyB0aGV5IGFyZW4ndCBlcmFz ZWQgd2hlbiB0aGUgbmV4dCB2ZXJzaW9uIHVwZGF0ZSBoYXBwZW5zLgo+IAo+IEhvdyBpcyB0aGlz IGNvZGUgdGVzdGVkPwo+IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+IAo+IEkgdGVzdGVkIGV2 ZXJ5IGNhbGxlciBvZiB6c3RkIG9uIHg4Nl82NCAoQnRyRlMsIFpSQU0sIFNxdWFzaEZTLCBGMkZT LAo+IEtlcm5lbCwgSW5pdFJBTUZTKS4gSSBhbHNvIHRlc3RlZCBLZXJuZWwgJiBJbml0UkFNRlMg b24gaTM4NiBhbmQgYWFyY2g2NC4gSQo+IGNoZWNrZWQgYm90aCBwZXJmb3JtYW5jZSBhbmQgY29y cmVjdG5lc3MuCj4gCj4gQWxzbywgdGhhbmtzIHRvIG1hbnkgcGVvcGxlIGluIHRoZSBjb21tdW5p dHkgd2hvIGhhdmUgdGVzdGVkIHRoZXNlIHBhdGNoZXMKPiBsb2NhbGx5LiBJZiB5b3UgaGF2ZSB0 ZXN0ZWQgdGhlIHBhdGNoZXMsIHBsZWFzZSByZXBseSB3aXRoIGEgVGVzdGVkLUJ5IHNvIEkKPiBj YW4gY29sbGVjdCB0aGVtIGZvciB0aGUgUFIgSSB3aWxsIHNlbmQgdG8gTGludXMuCj4gCj4gTGFz dGx5LCB0aGlzIGNvZGUgd2lsbCBiYWtlIGluIGxpbnV4LW5leHQgYmVmb3JlIGJlaW5nIG1lcmdl ZCBpbnRvIHY1LjE2Lgo+IAo+IFdoeSB1cGRhdGUgdG8genN0ZC0xLjQuMTAgd2hlbiB6c3RkLTEu NS4wIGhhcyBiZWVuIHJlbGVhc2VkPwo+IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+IAo+IFRoaXMgcGF0Y2hzZXQgaGFzIGJlZW4g b3V0c3RhbmRpbmcgc2luY2UgMjAyMCwgYW5kIHpzdGQtMS40LjEwIHdhcyB0aGUKPiBsYXRlc3Qg cmVsZWFzZSB3aGVuIGl0IHdhcyBjcmVhdGVkLiBTaW5jZSB0aGUgdXBkYXRlIHBhdGNoIGlzIGF1 dG9tYXRpY2FsbHkKPiBnZW5lcmF0ZWQgZnJvbSB1cHN0cmVhbSwgSSBjb3VsZCBnZW5lcmF0ZSBp dCBmcm9tIHpzdGQtMS41LjAuIEhvd2V2ZXIsCj4gdGhlcmUgd2VyZSBzb21lIGxhcmdlIHN0YWNr IHVzYWdlIHJlZ3Jlc3Npb25zIGluIHpzdGQtMS41LjAsIGFuZCBhcmUgb25seQo+IGZpeGVkIGlu IHRoZSBsYXRlc3QgZGV2ZWxvcG1lbnQgYnJhbmNoLiBBbmQgdGhlIGxhdGVzdCBkZXZlbG9wbWVu dCBicmFuY2gKPiBjb250YWlucyBzb21lIG5ldyBjb2RlIHRoYXQgbmVlZHMgdG8gYmFrZSBpbiB0 aGUgZnV6emVyIGJlZm9yZSBJIHdvdWxkIGZlZWwKPiBjb21mb3J0YWJsZSByZWxlYXNpbmcgdG8g dGhlIGtlcm5lbC4KPiAKPiBPbmNlIHRoaXMgcGF0Y2hzZXQgaGFzIGJlZW4gbWVyZ2VkLCBhbmQg d2UndmUgcmVsZWFzZWQgenN0ZC0xLjUuMSwgd2UgY2FuCj4gdXBkYXRlIHRoZSBrZXJuZWwgdG8g enN0ZC0xLjUuMSwgYW5kIGV4ZXJjaXNlIHRoZSB1cGRhdGUgcHJvY2Vzcy4KPiAKPiBZb3UgbWF5 IG5vdGljZSB0aGF0IHpzdGQtMS40LjEwIGRvZXNuJ3QgZXhpc3QgdXBzdHJlYW0uIFRoaXMgcmVs ZWFzZSBpcyBhbgo+IGFydGlmaWNhbCByZWxlYXNlIGJhc2VkIG9mZiBvZiB6c3RkLTEuNC45LCB3 aXRoIHNvbWUgZml4ZXMgZm9yIHRoZSBrZXJuZWwKPiBiYWNrcG9ydGVkIGZyb20gdGhlIGRldmVs b3BtZW50IGJyYW5jaC4gSSB3aWxsIHRhZyB0aGUgenN0ZC0xLjQuMTAgcmVsZWFzZQo+IGFmdGVy IHRoaXMgcGF0Y2hzZXQgaXMgbWVyZ2VkLCBzbyB0aGUgTGludXggS2VybmVsIGlzIHJ1bm5pbmcg YSBrbm93bgo+IHZlcnNpb24gb2YgenN0ZCB0aGF0IGNhbiBiZSBkZWJ1Z2dlZCB1cHN0cmVhbS4K PiAKPiBXaHkgd2FzIGEgd3JhcHBlciBBUEkgYWRkZWQ/Cj4gLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLQo+IAo+IFRoZSBmaXJzdCB2ZXJzaW9ucyBvZiB0aGlzIHBhdGNoc2V0IG1pZ3JhdGVk IHRoZSBrZXJuZWwgdG8gdGhlIHVwc3RyZWFtIHpzdGQKPiBBUEkuIEl0IGZpcnN0IGFkZGVkIGEg c2hpbSBBUEkgdGhhdCBzdXBwb3J0ZWQgdGhlIG5ldyB1cHN0cmVhbSBBUEkgd2l0aCB0aGUKPiBv bGQgY29kZSwgdGhlbiB1cGRhdGVkIGNhbGxlcnMgdG8gdXNlIHRoZSBuZXcgc2hpbSBBUEksIHRo ZW4gdHJhbnNpdGlvbmVkCj4gdG8gdGhlIG5ldyBjb2RlIGFuZCBkZWxldGVkIHRoZSBzaGltIEFQ SS4gSG93ZXZlciwgQ3Jpc3RvcGggSGVsbHdpZwo+IHN1Z2dlc3RlZCB0aGF0IHdlIHRyYW5zaXRp b24gdG8gYSBrZXJuZWwgc3R5bGUgQVBJLCBhbmQgaGlkZSB6c3RkJ3MKPiB1cHN0cmVhbSBBUEkg YmVoaW5kIHRoYXQuIFRoaXMgaXMgYmVjYXVzZSB6c3RkJ3MgdXBzdHJlYW0gQVBJIGlzIHN1cHBv cnRzCj4gbWFueSBvdGhlciB1c2UgY2FzZXMsIGFuZCBkb2VzIG5vdCBmb2xsb3cgdGhlIGtlcm5l bCBzdHlsZSBndWlkZSwgd2hpbGUgdGhlCj4ga2VybmVsIEFQSSBpcyBmb2N1c2VkIG9uIHRoZSBr ZXJuZWwncyB1c2UgY2FzZXMsIGFuZCBmb2xsb3dzIHRoZSBrZXJuZWwKPiBzdHlsZSBndWlkZS4K PiAKPiBDaGFuZ2Vsb2cKPiAtLS0tLS0tLS0KPiAKPiB2MSAtPiB2MjoKPiAqIFN1Y2Nlc3NmdWxs eSB0ZXN0ZWQgRjJGUyB3aXRoIGhlbHAgZnJvbSBDaGFvIFl1IHRvIGZpeCBteSB0ZXN0Lgo+ICog KDEvOSkgRml4IFpTVERfaW5pdENTdHJlYW0oKSB3cmFwcGVyIHRvIGhhbmRsZSBwbGVkZ2VkX3Ny Y19zaXplPTAgbWVhbnMKPiB1bmtub3duLiBUaGlzIGZpeGVzIEYyRlMgd2l0aCB0aGUgenN0ZC0x LjQuNiBjb21wYXRpYmlsaXR5IHdyYXBwZXIsIGV4cG9zZWQKPiBieSB0aGUgdGVzdC4KPiAKPiB2 MiAtPiB2MzoKPiAqICgzLzkpIFNpbGVuY2Ugd2FybmluZ3MgYnkgS2VybmVsIFRlc3QgUm9ib3Q6 Cj4gICBodHRwczovL2dpdGh1Yi5jb20vZmFjZWJvb2svenN0ZC9wdWxsLzIzMjQKPiAgIFN0YWNr IHNpemUgd2FybmluZ3MgcmVtYWluLCBidXQgdGhlc2UgYXJlbid0IG5ldywgYW5kIHRoZSBmdW5j dGlvbnMgaXQKPiB3YXJucyBvbiBhcmUgZWl0aGVyIHVudXNlZCBvciBub3QgaW4gdGhlIG1heGlt dW0gc3RhY2sgcGF0aC4gVGhpcyBwYXRjaHNldAo+IHJlZHVjZXMgenN0ZCBjb21wcmVzc2lvbiBz dGFjayB1c2FnZSBieSAxIEtCIG92ZXJhbGwuIEkndmUgZ290dGVuIHRoZSBsb3cKPiBoYW5naW5n IGZydWl0LCBhbmQgbW9yZSBzdGFjayByZWR1Y3Rpb24gd291bGQgcmVxdWlyZSBzaWduaWZpY2Fu dCBjaGFuZ2VzCj4gdGhhdCBoYXZlIHRoZSBwb3RlbnRpYWwgdG8gaW50cm9kdWNlIG5ldyBidWdz LiBIb3dldmVyLCBJIGRvIGhvcGUgdG8KPiBjb250aW51ZSB0byByZWR1Y2UgenN0ZCBzdGFjayB1 c2FnZSBpbiBmdXR1cmUgdmVyc2lvbnMuCj4gCj4gdjMgLT4gdjQ6Cj4gKiAoMy85KSBGaXggZXJy b3JzIGFuZCB3YXJuaW5ncyByZXBvcnRlZCBieSBLZXJuZWwgVGVzdCBSb2JvdDoKPiAgIGh0dHBz Oi8vZ2l0aHViLmNvbS9mYWNlYm9vay96c3RkL3B1bGwvMjMyNgo+ICAgLSBSZXBsYWNlIG1lbS5o IHdpdGggYSBjdXN0b20ga2VybmVsIGltcGxlbWVudGF0aW9uIHRoYXQgbWF0Y2hlcyB0aGUKPiBj dXJyZW50IGxpYi96c3RkL21lbS5oIGluIHRoZSBrZXJuZWwuIFRoaXMgYXZvaWRzIGNhbGxzIHRv Cj4gX19idWlsdGluX2Jzd2FwKigpIHdoaWNoIGRvbid0IHdvcmsgb24gY2VydGFpbiBhcmNoaXRl Y3R1cmVzLCBhcyBleHBvc2VkIGJ5Cj4gdGhlIEtlcm5lbCBUZXN0IFJvYm90LiAtIFJlbW92ZSBB U0FOL01TQU4gKHVuKXBvaXNvbmluZyBjb2RlIHdoaWNoIGRvZXNuJ3QKPiB3b3JrIGluIHRoZSBr ZXJuZWwsIGFzIGV4cG9zZWQgYnkgdGhlIEtlcm5lbCBUZXN0IFJvYm90Lgo+ICAgLSBJJ3ZlIGZp eGVkIGFsbCBvZiB0aGUgdmFsaWQgY3BwY2hlY2sgd2FybmluZ3MgcmVwb3J0ZWQsIGJ1dCB0aGVy ZSB3ZXJlCj4gbWFueSBmYWxzZSBwb3NpdGl2ZXMsIHdoZXJlIGNwcGNoZWNrIHdhcyBpbmNvcnJl Y3RseSBhbmFseXppbmcgdGhlCj4gc2l0dWF0aW9uLCB3aGljaCBJIGRpZCBub3QgZml4LiBJIGRv bid0IGJlbGlldmUgaXQgaXMgcmVhc29uYWJsZSB0byBleHBlY3QKPiB0aGF0IHVwc3RyZWFtIHpz dGQgc2lsZW5jZXMgYWxsIHRoZSBzdGF0aWMgYW5hbHl6ZXIgZmFsc2UgcG9zaXRpdmVzLgo+IFVw c3RyZWFtIHpzdGQgdXNlcyBjbGFuZyBzY2FuLWJ1aWxkIGZvciBpdHMgc3RhdGljIGFuYWx5c2lz LiBXZSBmaW5kIHRoYXQKPiBzdXBwb3J0aW5nIG11bHRpcGxlIHN0YXRpYyBhbmFseXNpcyB0b29s cyBtdWx0aXBsaWVzIHRoZSBidXJkZW4gb2YKPiBzaWxlbmNpbmcgZmFsc2UgcG9zaXRpdmVzLCB3 aXRob3V0IHByb3ZpZGluZyBlbm91Z2ggbWFyZ2luYWwgdmFsdWUgb3Zlcgo+IHJ1bm5pbmcgYSBz aW5nbGUgc3RhdGljIGFuYWx5c2lzIHRvb2wuCj4gCj4gdjQgLT4gdjU6Cj4gKiBSZWJhc2Ugb250 byB2NS4xMC1yYzIKPiAqICg2LzkpIE1lcmdlIHdpdGggb3RoZXIgRjJGUyBjaGFuZ2VzIChubyBm dW5jdGlvbmFsIGNoYW5nZSBpbiBwYXRjaCkuCj4gCj4gdjUgLT4gdjY6Cj4gKiBSZWJhc2Ugb250 byB2NS4xMC1yYzYuCj4gKiBTd2l0Y2ggdG8gdXNpbmcgYSBrZXJuZWwgc3R5bGUgd3JhcHBlciBB UEkgYXMgc3VnZ2VzdGVkIGJ5IENyaXN0b3BoLgo+IAo+IHY2IC0+IHY3Ogo+ICogRXhwb3NlIHRo ZSB1cHN0cmVhbSBsaWJyYXJ5IGhlYWRlciBhcyBgaW5jbHVkZS9saW51eC96c3RkX2xpYi5oYC4K PiAgIEluc3RlYWQgb2YgY3JlYXRpbmcgbmV3IHN0cnVjdHMgbWlycm9yaW5nIHRoZSB1cHN0cmVh bSB6c3RkIHN0cnVjdHMKPiAgIHVzZSB1cHN0cmVhbSdzIHN0cnVjdHMgZGlyZWN0bHkgd2l0aCBh IHR5cGVkZWYgdG8gZ2V0IGEga2VybmVsIHN0eWxlIG5hbWUuCj4gVGhpcyByZW1vdmVzIHRoZSBt ZW1jcHkgY3J1ZnQuCj4gKiAoMS8zKSBVbmRvIFpTVERfV0lORE9XTE9HX01BWCBhbmQgaGFuZGxl X3pzdGRfZXJyb3IgY2hhbmdlcy4KPiAqICgzLzMpIEV4cG9zZSB6c3RkX2Vycm9ycy5oIGFzIGBp bmNsdWRlL2xpbnV4L3pzdGRfZXJyb3JzLmhgIGJlY2F1c2UgaXQKPiAgIGlzIG5lZWRlZCBieSB0 aGUga2VybmVsIHdyYXBwZXIgQVBJLgo+IAo+IHY3IC0+IHY4Ogo+ICogKDEvMykgRml4IHR5cG8g aW4gRVhQT1JUX1NZTUJPTCgpLgo+ICogKDEvMykgRml4IHR5cG8gaW4genN0ZC5oIGNvbW1lbnRz Lgo+ICogKDMvMykgVXBkYXRlIHRvIGxhdGVzdCB6c3RkIHJlbGVhc2U6IDEuNC42IC0+IDEuNC4x MAo+ICAgICAgICAgVGhpcyBpbmNsdWRlcyB+MUtCIG9mIHN0YWNrIHNwYWNlIHJlZHVjdGlvbnMu Cj4gCj4gdjggLT4gdjk6Cj4gKiAoMS8zKSBSZWJhc2Ugb250byB2NS4xMi1yYzUKPiAqICgxLzMp IEFkZCB6c3RkX21pbl9jbGV2ZWwoKSAmIHpzdGRfbWF4X2NsZXZlbCgpIGFuZCB1c2UgaW4gZjJm cy4KPiAgICAgICAgIFRoYW5rcyB0byBPbGVrc2FuZHIgTmF0YWxlbmtvIGZvciBzcG90dGluZyBp dCEKPiAqICgxLzMpIE1vdmUgbGliL2RlY29tcHJlc3NfdW56c3RkLmMgdXNhZ2Ugb2YgWlNURF9n ZXRFcnJvckNvZGUoKQo+ICAgICAgICAgdG8genN0ZF9nZXRfZXJyb3JfY29kZSgpLgo+ICogKDEv MykgVXBkYXRlIG1vZGlmaWVkIHpzdGQgaGVhZGVycyB0byB5ZWFybGVzcyBjb3B5cmlnaHQuCj4g KiAoMi8zKSBBZGQgY29weXJpZ2h0L2xpY2Vuc2UgaGVhZGVyIHRvIGRlY29tcHJlc3Nfc291cmNl cy5oIGZvcgo+IGNvbnNpc3RlbmN5LiAqICgzLzMpIFVwZGF0ZSB0byB5ZWFybGVzcyBjb3B5cmln aHQgZm9yIGFsbCB6c3RkIGZpbGVzLgo+IFRoYW5rcyB0byBNaWtlIERvbGFuIGZvciBzcG90dGlu ZyBpdCEKPiAKPiB2OSAtPiB2MTA6Cj4gKiBBZGQgYSA0dGggcGF0Y2ggaW4gdGhlIHNlcmllcyB3 aGljaCBhZGRzIGFuIGVudHJ5IGZvciB6c3RkIHRvIE1BSU5UQUlORVJTLgo+IAo+IHYxMCAtPiB2 MTE6Cj4gKiBSZWJhc2UgY2xlYW5seSBvbnRvIHY1LjEyLXJjOAo+ICogKDMvNCkgUmVwbGFjZSBp bnZhbGlkIGtlcm5lbCBzdHlsZSBjb21tZW50cyBpbiB6c3RkIHdpdGggcmVndWxhciBjb21tZW50 cy4KPiBUaGFua3MgdG8gUmFuZHkgRHVubGFwIGZvciB0aGUgc3VnZ2VzdGlvbi4KPiAKPiB2MTEg LT4gdjEyOgo+ICogUmUtd3JpdGUgdGhlIGNvdmVyIGxldHRlciAmIHNlbmQgYXMgYSBQUiBvbmx5 Lgo+ICogUmViYXNlIGNsZWFubHkgb250byA1LjE1LXJjNC4KPiAqICgzLzQpIENsZWFuIHVwIGxp Y2Vuc2luZyB0byByZWZsZWN0IHRoYXQgd2UncmUgR1BMLTIuMCsgT1IgQlNELTMtQ2xhdXNlLgo+ ICogKDMvNCkgUmVkdWNlIGNvbXByZXNzaW9uIHN0YWNrIHVzYWdlIGJ5IDgwIGJ5dGVzLgo+ICog KDMvNCkgTWFrZSB1cHN0cmVhbSB6c3RkIGAtV2ZhbGwtdGhyb3VnaGAgY29tcGxpYW50IGFuZCB1 c2UgdGhlCj4gRkFMTFRIUk9VR0ggbWFjcm8gaW4gdGhlIExpbnV4IEtlcm5lbC4KPiAKPiBTaWdu ZWQtb2ZmLWJ5OiBOaWNrIFRlcnJlbGwgPHRlcnJlbGxuQGZiLmNvbT4KPiAKPiAtLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4g TmljayBUZXJyZWxsICg0KToKPiAgICAgICBsaWI6IHpzdGQ6IEFkZCBrZXJuZWwtc3BlY2lmaWMg QVBJCj4gICAgICAgbGliOiB6c3RkOiBBZGQgZGVjb21wcmVzc19zb3VyY2VzLmggZm9yIGRlY29t cHJlc3NfdW56c3RkCj4gICAgICAgbGliOiB6c3RkOiBVcGdyYWRlIHRvIGxhdGVzdCB1cHN0cmVh bSB6c3RkIHZlcnNpb24gMS40LjEwCj4gICAgICAgTUFJTlRBSU5FUlM6IEFkZCBtYWludGFpbmVy IGVudHJ5IGZvciB6c3RkCj4gCj4gIE1BSU5UQUlORVJTICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgfCAgIDEyICsKPiAgY3J5cHRvL3pzdGQuYyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICB8ICAgMjggKy0KPiAgZnMvYnRyZnMvenN0ZC5jICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB8ICAgNjggKy0KPiAgZnMvZjJmcy9jb21wcmVzcy5jICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB8ICAgNTYgKy0KPiAgZnMvZjJmcy9zdXBlci5jICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKy0KPiAgZnMvcHN0b3JlL3BsYXRmb3JtLmMg ICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKy0KPiAgZnMvc3F1YXNoZnMvenN0ZF93 cmFwcGVyLmMgICAgICAgICAgICAgICAgICAgICB8ICAgMTYgKy0KPiAgaW5jbHVkZS9saW51eC96 c3RkLmggICAgICAgICAgICAgICAgICAgICAgICAgICB8IDEyNTIgKystLS0tCj4gIGluY2x1ZGUv bGludXgvenN0ZF9lcnJvcnMuaCAgICAgICAgICAgICAgICAgICAgfCAgIDc3ICsKPiAgaW5jbHVk ZS9saW51eC96c3RkX2xpYi5oICAgICAgICAgICAgICAgICAgICAgICB8IDI0MzIgKysrKysrKysr KysKPiAgbGliL2RlY29tcHJlc3NfdW56c3RkLmMgICAgICAgICAgICAgICAgICAgICAgICB8ICAg NDggKy0KPiAgbGliL3pzdGQvTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8 ICAgNDYgKy0KPiAgbGliL3pzdGQvYml0c3RyZWFtLmggICAgICAgICAgICAgICAgICAgICAgICAg ICB8ICAzODAgLS0KPiAgbGliL3pzdGQvY29tbW9uL2JpdHN0cmVhbS5oICAgICAgICAgICAgICAg ICAgICB8ICA0MzcgKysKPiAgbGliL3pzdGQvY29tbW9uL2NvbXBpbGVyLmggICAgICAgICAgICAg ICAgICAgICB8ICAxNzAgKwo+ICBsaWIvenN0ZC9jb21tb24vY3B1LmggICAgICAgICAgICAgICAg ICAgICAgICAgIHwgIDE5NCArCj4gIGxpYi96c3RkL2NvbW1vbi9kZWJ1Zy5jICAgICAgICAgICAg ICAgICAgICAgICAgfCAgIDI0ICsKPiAgbGliL3pzdGQvY29tbW9uL2RlYnVnLmggICAgICAgICAg ICAgICAgICAgICAgICB8ICAxMDEgKwo+ICBsaWIvenN0ZC9jb21tb24vZW50cm9weV9jb21tb24u YyAgICAgICAgICAgICAgIHwgIDM1NyArKwo+ICBsaWIvenN0ZC9jb21tb24vZXJyb3JfcHJpdmF0 ZS5jICAgICAgICAgICAgICAgIHwgICA1NiArCj4gIGxpYi96c3RkL2NvbW1vbi9lcnJvcl9wcml2 YXRlLmggICAgICAgICAgICAgICAgfCAgIDY2ICsKPiAgbGliL3pzdGQvY29tbW9uL2ZzZS5oICAg ICAgICAgICAgICAgICAgICAgICAgICB8ICA3MTAgKysrKwo+ICBsaWIvenN0ZC9jb21tb24vZnNl X2RlY29tcHJlc3MuYyAgICAgICAgICAgICAgIHwgIDM5MCArKwo+ICBsaWIvenN0ZC9jb21tb24v aHVmLmggICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDM1NiArKwo+ICBsaWIvenN0ZC9jb21t b24vbWVtLmggICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDI1OSArKwo+ICBsaWIvenN0ZC9j b21tb24venN0ZF9jb21tb24uYyAgICAgICAgICAgICAgICAgIHwgICA4MyArCj4gIGxpYi96c3Rk L2NvbW1vbi96c3RkX2RlcHMuaCAgICAgICAgICAgICAgICAgICAgfCAgMTI1ICsKPiAgbGliL3pz dGQvY29tbW9uL3pzdGRfaW50ZXJuYWwuaCAgICAgICAgICAgICAgICB8ICA0NTAgKysrCj4gIGxp Yi96c3RkL2NvbXByZXNzLmMgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAzNDg1IC0tLS0t LS0tLS0tLS0tLS0KPiAgbGliL3pzdGQvY29tcHJlc3MvZnNlX2NvbXByZXNzLmMgICAgICAgICAg ICAgICB8ICA2MjUgKysrCj4gIGxpYi96c3RkL2NvbXByZXNzL2hpc3QuYyAgICAgICAgICAgICAg ICAgICAgICAgfCAgMTY1ICsKPiAgbGliL3pzdGQvY29tcHJlc3MvaGlzdC5oICAgICAgICAgICAg ICAgICAgICAgICB8ICAgNzUgKwo+ICBsaWIvenN0ZC9jb21wcmVzcy9odWZfY29tcHJlc3MuYyAg ICAgICAgICAgICAgIHwgIDkwNSArKysrKwo+ICBsaWIvenN0ZC9jb21wcmVzcy96c3RkX2NvbXBy ZXNzLmMgICAgICAgICAgICAgIHwgNTEwOQo+ICsrKysrKysrKysrKysrKysrKysrKysrKyBsaWIv enN0ZC9jb21wcmVzcy96c3RkX2NvbXByZXNzX2ludGVybmFsLmggICAgIHwKPiAxMTg4ICsrKysr Kwo+ICBsaWIvenN0ZC9jb21wcmVzcy96c3RkX2NvbXByZXNzX2xpdGVyYWxzLmMgICAgIHwgIDE1 OCArCj4gIGxpYi96c3RkL2NvbXByZXNzL3pzdGRfY29tcHJlc3NfbGl0ZXJhbHMuaCAgICAgfCAg IDI5ICsKPiAgbGliL3pzdGQvY29tcHJlc3MvenN0ZF9jb21wcmVzc19zZXF1ZW5jZXMuYyAgICB8 ICA0MzkgKysKPiAgbGliL3pzdGQvY29tcHJlc3MvenN0ZF9jb21wcmVzc19zZXF1ZW5jZXMuaCAg ICB8ICAgNTQgKwo+ICBsaWIvenN0ZC9jb21wcmVzcy96c3RkX2NvbXByZXNzX3N1cGVyYmxvY2su YyAgIHwgIDg1MCArKysrCj4gIGxpYi96c3RkL2NvbXByZXNzL3pzdGRfY29tcHJlc3Nfc3VwZXJi bG9jay5oICAgfCAgIDMyICsKPiAgbGliL3pzdGQvY29tcHJlc3MvenN0ZF9jd2tzcC5oICAgICAg ICAgICAgICAgICB8ICA0ODIgKysrCj4gIGxpYi96c3RkL2NvbXByZXNzL3pzdGRfZG91YmxlX2Zh c3QuYyAgICAgICAgICAgfCAgNTE5ICsrKwo+ICBsaWIvenN0ZC9jb21wcmVzcy96c3RkX2RvdWJs ZV9mYXN0LmggICAgICAgICAgIHwgICAzMiArCj4gIGxpYi96c3RkL2NvbXByZXNzL3pzdGRfZmFz dC5jICAgICAgICAgICAgICAgICAgfCAgNDk2ICsrKwo+ICBsaWIvenN0ZC9jb21wcmVzcy96c3Rk X2Zhc3QuaCAgICAgICAgICAgICAgICAgIHwgICAzMSArCj4gIGxpYi96c3RkL2NvbXByZXNzL3pz dGRfbGF6eS5jICAgICAgICAgICAgICAgICAgfCAxNDEyICsrKysrKysKPiAgbGliL3pzdGQvY29t cHJlc3MvenN0ZF9sYXp5LmggICAgICAgICAgICAgICAgICB8ICAgODEgKwo+ICBsaWIvenN0ZC9j b21wcmVzcy96c3RkX2xkbS5jICAgICAgICAgICAgICAgICAgIHwgIDY4NiArKysrCj4gIGxpYi96 c3RkL2NvbXByZXNzL3pzdGRfbGRtLmggICAgICAgICAgICAgICAgICAgfCAgMTEwICsKPiAgbGli L3pzdGQvY29tcHJlc3MvenN0ZF9sZG1fZ2VhcnRhYi5oICAgICAgICAgICB8ICAxMDMgKwo+ICBs aWIvenN0ZC9jb21wcmVzcy96c3RkX29wdC5jICAgICAgICAgICAgICAgICAgIHwgMTM0NSArKysr KysrCj4gIGxpYi96c3RkL2NvbXByZXNzL3pzdGRfb3B0LmggICAgICAgICAgICAgICAgICAgfCAg IDUwICsKPiAgbGliL3pzdGQvZGVjb21wcmVzcy5jICAgICAgICAgICAgICAgICAgICAgICAgICB8 IDI1MzEgLS0tLS0tLS0tLS0tCj4gIGxpYi96c3RkL2RlY29tcHJlc3MvaHVmX2RlY29tcHJlc3Mu YyAgICAgICAgICAgfCAxMjA2ICsrKysrKwo+ICBsaWIvenN0ZC9kZWNvbXByZXNzL3pzdGRfZGRp Y3QuYyAgICAgICAgICAgICAgIHwgIDI0MSArKwo+ICBsaWIvenN0ZC9kZWNvbXByZXNzL3pzdGRf ZGRpY3QuaCAgICAgICAgICAgICAgIHwgICA0NCArCj4gIGxpYi96c3RkL2RlY29tcHJlc3MvenN0 ZF9kZWNvbXByZXNzLmMgICAgICAgICAgfCAyMDgyICsrKysrKysrKysKPiAgbGliL3pzdGQvZGVj b21wcmVzcy96c3RkX2RlY29tcHJlc3NfYmxvY2suYyAgICB8IDE1NDAgKysrKysrKwo+ICBsaWIv enN0ZC9kZWNvbXByZXNzL3pzdGRfZGVjb21wcmVzc19ibG9jay5oICAgIHwgICA2MiArCj4gIGxp Yi96c3RkL2RlY29tcHJlc3MvenN0ZF9kZWNvbXByZXNzX2ludGVybmFsLmggfCAgMjAyICsKPiAg bGliL3pzdGQvZGVjb21wcmVzc19zb3VyY2VzLmggICAgICAgICAgICAgICAgICB8ICAgMjggKwo+ ICBsaWIvenN0ZC9lbnRyb3B5X2NvbW1vbi5jICAgICAgICAgICAgICAgICAgICAgIHwgIDI0MyAt LQo+ICBsaWIvenN0ZC9lcnJvcl9wcml2YXRlLmggICAgICAgICAgICAgICAgICAgICAgIHwgICA1 MyAtCj4gIGxpYi96c3RkL2ZzZS5oICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAg NTc1IC0tLQo+ICBsaWIvenN0ZC9mc2VfY29tcHJlc3MuYyAgICAgICAgICAgICAgICAgICAgICAg IHwgIDc5NSAtLS0tCj4gIGxpYi96c3RkL2ZzZV9kZWNvbXByZXNzLmMgICAgICAgICAgICAgICAg ICAgICAgfCAgMzI1IC0tCj4gIGxpYi96c3RkL2h1Zi5oICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgfCAgMjEyIC0KPiAgbGliL3pzdGQvaHVmX2NvbXByZXNzLmMgICAgICAgICAgICAg ICAgICAgICAgICB8ICA3NzMgLS0tLQo+ICBsaWIvenN0ZC9odWZfZGVjb21wcmVzcy5jICAgICAg ICAgICAgICAgICAgICAgIHwgIDk2MCAtLS0tLQo+ICBsaWIvenN0ZC9tZW0uaCAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHwgIDE1MSAtCj4gIGxpYi96c3RkL3pzdGRfY29tbW9uLmMg ICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDc1IC0KPiAgbGliL3pzdGQvenN0ZF9jb21wcmVz c19tb2R1bGUuYyAgICAgICAgICAgICAgICB8ICAxNjAgKwo+ICBsaWIvenN0ZC96c3RkX2RlY29t cHJlc3NfbW9kdWxlLmMgICAgICAgICAgICAgIHwgIDEwNSArCj4gIGxpYi96c3RkL3pzdGRfaW50 ZXJuYWwuaCAgICAgICAgICAgICAgICAgICAgICAgfCAgMjczIC0tCj4gIGxpYi96c3RkL3pzdGRf b3B0LmggICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAxMDE0IC0tLS0tCj4gIDc2IGZpbGVz IGNoYW5nZWQsIDI3MzY3IGluc2VydGlvbnMoKyksIDEyOTQxIGRlbGV0aW9ucygtKQo+ICBjcmVh dGUgbW9kZSAxMDA2NDQgaW5jbHVkZS9saW51eC96c3RkX2Vycm9ycy5oCj4gIGNyZWF0ZSBtb2Rl IDEwMDY0NCBpbmNsdWRlL2xpbnV4L3pzdGRfbGliLmgKPiAgZGVsZXRlIG1vZGUgMTAwNjQ0IGxp Yi96c3RkL2JpdHN0cmVhbS5oCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBsaWIvenN0ZC9jb21tb24v Yml0c3RyZWFtLmgKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGxpYi96c3RkL2NvbW1vbi9jb21waWxl ci5oCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBsaWIvenN0ZC9jb21tb24vY3B1LmgKPiAgY3JlYXRl IG1vZGUgMTAwNjQ0IGxpYi96c3RkL2NvbW1vbi9kZWJ1Zy5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0 NCBsaWIvenN0ZC9jb21tb24vZGVidWcuaAo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgbGliL3pzdGQv Y29tbW9uL2VudHJvcHlfY29tbW9uLmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGxpYi96c3RkL2Nv bW1vbi9lcnJvcl9wcml2YXRlLmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGxpYi96c3RkL2NvbW1v bi9lcnJvcl9wcml2YXRlLmgKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGxpYi96c3RkL2NvbW1vbi9m c2UuaAo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgbGliL3pzdGQvY29tbW9uL2ZzZV9kZWNvbXByZXNz LmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGxpYi96c3RkL2NvbW1vbi9odWYuaAo+ICBjcmVhdGUg bW9kZSAxMDA2NDQgbGliL3pzdGQvY29tbW9uL21lbS5oCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBs aWIvenN0ZC9jb21tb24venN0ZF9jb21tb24uYwo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgbGliL3pz dGQvY29tbW9uL3pzdGRfZGVwcy5oCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBsaWIvenN0ZC9jb21t b24venN0ZF9pbnRlcm5hbC5oCj4gIGRlbGV0ZSBtb2RlIDEwMDY0NCBsaWIvenN0ZC9jb21wcmVz cy5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBsaWIvenN0ZC9jb21wcmVzcy9mc2VfY29tcHJlc3Mu Ywo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgbGliL3pzdGQvY29tcHJlc3MvaGlzdC5jCj4gIGNyZWF0 ZSBtb2RlIDEwMDY0NCBsaWIvenN0ZC9jb21wcmVzcy9oaXN0LmgKPiAgY3JlYXRlIG1vZGUgMTAw NjQ0IGxpYi96c3RkL2NvbXByZXNzL2h1Zl9jb21wcmVzcy5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0 NCBsaWIvenN0ZC9jb21wcmVzcy96c3RkX2NvbXByZXNzLmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0 IGxpYi96c3RkL2NvbXByZXNzL3pzdGRfY29tcHJlc3NfaW50ZXJuYWwuaAo+ICBjcmVhdGUgbW9k ZSAxMDA2NDQgbGliL3pzdGQvY29tcHJlc3MvenN0ZF9jb21wcmVzc19saXRlcmFscy5jCj4gIGNy ZWF0ZSBtb2RlIDEwMDY0NCBsaWIvenN0ZC9jb21wcmVzcy96c3RkX2NvbXByZXNzX2xpdGVyYWxz LmgKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGxpYi96c3RkL2NvbXByZXNzL3pzdGRfY29tcHJlc3Nf c2VxdWVuY2VzLmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGxpYi96c3RkL2NvbXByZXNzL3pzdGRf Y29tcHJlc3Nfc2VxdWVuY2VzLmgKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGxpYi96c3RkL2NvbXBy ZXNzL3pzdGRfY29tcHJlc3Nfc3VwZXJibG9jay5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBsaWIv enN0ZC9jb21wcmVzcy96c3RkX2NvbXByZXNzX3N1cGVyYmxvY2suaAo+ICBjcmVhdGUgbW9kZSAx MDA2NDQgbGliL3pzdGQvY29tcHJlc3MvenN0ZF9jd2tzcC5oCj4gIGNyZWF0ZSBtb2RlIDEwMDY0 NCBsaWIvenN0ZC9jb21wcmVzcy96c3RkX2RvdWJsZV9mYXN0LmMKPiAgY3JlYXRlIG1vZGUgMTAw NjQ0IGxpYi96c3RkL2NvbXByZXNzL3pzdGRfZG91YmxlX2Zhc3QuaAo+ICBjcmVhdGUgbW9kZSAx MDA2NDQgbGliL3pzdGQvY29tcHJlc3MvenN0ZF9mYXN0LmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0 IGxpYi96c3RkL2NvbXByZXNzL3pzdGRfZmFzdC5oCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBsaWIv enN0ZC9jb21wcmVzcy96c3RkX2xhenkuYwo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgbGliL3pzdGQv Y29tcHJlc3MvenN0ZF9sYXp5LmgKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGxpYi96c3RkL2NvbXBy ZXNzL3pzdGRfbGRtLmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGxpYi96c3RkL2NvbXByZXNzL3pz dGRfbGRtLmgKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGxpYi96c3RkL2NvbXByZXNzL3pzdGRfbGRt X2dlYXJ0YWIuaAo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgbGliL3pzdGQvY29tcHJlc3MvenN0ZF9v cHQuYwo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgbGliL3pzdGQvY29tcHJlc3MvenN0ZF9vcHQuaAo+ ICBkZWxldGUgbW9kZSAxMDA2NDQgbGliL3pzdGQvZGVjb21wcmVzcy5jCj4gIGNyZWF0ZSBtb2Rl IDEwMDY0NCBsaWIvenN0ZC9kZWNvbXByZXNzL2h1Zl9kZWNvbXByZXNzLmMKPiAgY3JlYXRlIG1v ZGUgMTAwNjQ0IGxpYi96c3RkL2RlY29tcHJlc3MvenN0ZF9kZGljdC5jCj4gIGNyZWF0ZSBtb2Rl IDEwMDY0NCBsaWIvenN0ZC9kZWNvbXByZXNzL3pzdGRfZGRpY3QuaAo+ICBjcmVhdGUgbW9kZSAx MDA2NDQgbGliL3pzdGQvZGVjb21wcmVzcy96c3RkX2RlY29tcHJlc3MuYwo+ICBjcmVhdGUgbW9k ZSAxMDA2NDQgbGliL3pzdGQvZGVjb21wcmVzcy96c3RkX2RlY29tcHJlc3NfYmxvY2suYwo+ICBj cmVhdGUgbW9kZSAxMDA2NDQgbGliL3pzdGQvZGVjb21wcmVzcy96c3RkX2RlY29tcHJlc3NfYmxv Y2suaAo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgbGliL3pzdGQvZGVjb21wcmVzcy96c3RkX2RlY29t cHJlc3NfaW50ZXJuYWwuaAo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgbGliL3pzdGQvZGVjb21wcmVz c19zb3VyY2VzLmgKPiAgZGVsZXRlIG1vZGUgMTAwNjQ0IGxpYi96c3RkL2VudHJvcHlfY29tbW9u LmMKPiAgZGVsZXRlIG1vZGUgMTAwNjQ0IGxpYi96c3RkL2Vycm9yX3ByaXZhdGUuaAo+ICBkZWxl dGUgbW9kZSAxMDA2NDQgbGliL3pzdGQvZnNlLmgKPiAgZGVsZXRlIG1vZGUgMTAwNjQ0IGxpYi96 c3RkL2ZzZV9jb21wcmVzcy5jCj4gIGRlbGV0ZSBtb2RlIDEwMDY0NCBsaWIvenN0ZC9mc2VfZGVj b21wcmVzcy5jCj4gIGRlbGV0ZSBtb2RlIDEwMDY0NCBsaWIvenN0ZC9odWYuaAo+ICBkZWxldGUg bW9kZSAxMDA2NDQgbGliL3pzdGQvaHVmX2NvbXByZXNzLmMKPiAgZGVsZXRlIG1vZGUgMTAwNjQ0 IGxpYi96c3RkL2h1Zl9kZWNvbXByZXNzLmMKPiAgZGVsZXRlIG1vZGUgMTAwNjQ0IGxpYi96c3Rk L21lbS5oCj4gIGRlbGV0ZSBtb2RlIDEwMDY0NCBsaWIvenN0ZC96c3RkX2NvbW1vbi5jCj4gIGNy ZWF0ZSBtb2RlIDEwMDY0NCBsaWIvenN0ZC96c3RkX2NvbXByZXNzX21vZHVsZS5jCj4gIGNyZWF0 ZSBtb2RlIDEwMDY0NCBsaWIvenN0ZC96c3RkX2RlY29tcHJlc3NfbW9kdWxlLmMKPiAgZGVsZXRl IG1vZGUgMTAwNjQ0IGxpYi96c3RkL3pzdGRfaW50ZXJuYWwuaAo+ICBkZWxldGUgbW9kZSAxMDA2 NDQgbGliL3pzdGQvenN0ZF9vcHQuaAoKCi0tIApPbGVrc2FuZHIgTmF0YWxlbmtvIChwb3N0LWZh Y3R1bSkKCgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CkxpbnV4LWYyZnMtZGV2ZWwgbWFpbGluZyBsaXN0CkxpbnV4LWYyZnMtZGV2ZWxAbGlzdHMuc291 cmNlZm9yZ2UubmV0Cmh0dHBzOi8vbGlzdHMuc291cmNlZm9yZ2UubmV0L2xpc3RzL2xpc3RpbmZv L2xpbnV4LWYyZnMtZGV2ZWwK