From debbugs-submit-bounces@debbugs.gnu.org Fri Feb 24 13:52:10 2023 Received: (at submit) by debbugs.gnu.org; 24 Feb 2023 18:52:10 +0000 Received: from localhost ([127.0.0.1]:38235 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pVdAu-0006pu-ND for submit@debbugs.gnu.org; Fri, 24 Feb 2023 13:52:09 -0500 Received: from lists.gnu.org ([209.51.188.17]:39508) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pVdAs-0006pl-HO for submit@debbugs.gnu.org; Fri, 24 Feb 2023 13:52:07 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pVdAs-0007ID-AW for guix-patches@gnu.org; Fri, 24 Feb 2023 13:52:06 -0500 Received: from mx1.librem.one ([138.201.176.93]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pVdAp-00077U-1u for guix-patches@gnu.org; Fri, 24 Feb 2023 13:52:06 -0500 Received: from smtp.librem.one (unknown [192.241.214.14]) by mx1.librem.one (Postfix) with ESMTPS id EB4D381E97 for ; Fri, 24 Feb 2023 10:51:59 -0800 (PST) Authentication-Results: name mx1.librem.one; dmarc=fail (p=reject dis=none) header.from=librem.one From: Mitchell Schmeisser To: guix-patches@gnu.org Subject: custom toolchain blog post Date: Fri, 24 Feb 2023 13:51:56 -0500 Message-ID: <87sfeuucab.fsf@librem.one> Content-Type: text/plain Received-SPF: pass client-ip=138.201.176.93; envelope-from=mitchellschmeisser@librem.one; helo=mx1.librem.one X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-Spam-Score: -1.3 (-) X-Debbugs-Envelope-To: submit X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -2.3 (--) Here is a rough draft of my toolchain post. I hope it can make an interesting contribution to the Guix literature. - Mitchell >From 4f6c43091ffd67cdbc5f041e496f61bc8a06070e Mon Sep 17 00:00:00 2001 From: Mitchell Schmeisser Date: Fri, 24 Feb 2023 13:02:05 -0500 Subject: [PATCH] website: Add custom toolchain blog post * website/posts/custom-toolchains-with-guix.md: New file. --- website/posts/custom-toolchains-with-guix.md | 557 +++++++++++++++++++ 1 file changed, 557 insertions(+) create mode 100644 website/posts/custom-toolchains-with-guix.md diff --git a/website/posts/custom-toolchains-with-guix.md b/website/posts/custom-toolchains-with-guix.md new file mode 100644 index 0000000..f73f1ab --- /dev/null +++ b/website/posts/custom-toolchains-with-guix.md @@ -0,0 +1,557 @@ +# Table of Contents + +1. [Overview](#org2633a51) +2. [Anatomy of a toolchain](#orgc440e9e) +3. [Bootstrapping a Toolchain](#orgd42b6c3) +4. [Defining the Packages](#org55042c5) + 1. [Binutils](#org67da1ec) + 2. [GCC sans libc](#org82d6f83) + 3. [Newlib(-nano)](#orgf6bafbc) + 4. [Complete toolchain](#org052f2a2) +5. [Integrating with Zephyr Build System](#orgc3f87f4) + 1. [Testing](#org9f3c314) + +All code is available at [guix-zephyr](https://github.com/paperclip4465/guix-zephyr) channel. + + + + +# Overview + +In order to deploy embedded software using Guix we first need to teach Guix +how to build it. Since Guix bootstraps everything this means we must teach Guix +how to build our toolchain. + +The [Zephyr Project](https://zephyrproject.org) uses its own fork of GCC with custom configs for +the architectures supported by the project. + + + + +# Anatomy of a toolchain + +Toolchains are responsible for taking high level descriptions of programs +and lowering them down to a series of equivalent machine instructions. +This process involves more than just a compiler. The compiler uses the `binutils` +to manipulate it's internal representation down to a given architecture. +It also needs the use of the C standard library as well as a few other libraries +needed for some compiler optimizations. + +The C library provides the interface to the underlying kernel. System calls like `write` +and `read` are provided by `Glibc` on most Linux distributions. + +In embedded systems smaller implementations like `newlib` and `newlib-nano` are used. + + + + +# Bootstrapping a Toolchain + +In order to compile GCC we need a C library that's been compiled for +our target architecture. How can we cross compile our C library if we +need our C library to build a cross compiler? The solution is to build +a simpler compiler that doesn't require the C library to function. +It will not be capable of as many optimizations and it will be very slow, +however it will be able to build the C libraries as well as the complete version +of GCC. + +In order to build the simpler compiler we need to compile the `binutils` to +work with our target architecture. +The `binutils` can be bootstrapped with our host GCC and have no target dependencies. + +[For more information read this.](https://crosstool-ng.github.io/docs/toolchain-construction/) + +Doesn't sound so bad right? It isn't… in theory. +However internet forums since time immemorial have been +littered with the laments of those who came before. +From incorrect versions of `ISL` to the wrong C library being linked +or the host linker being used, etc. +The one commonality between all of these issues is the environment. +Building a cross toolchain is difficult because isolating build +environments is difficult. + +In fact as of `v0.14.2` the zephyr SDK repository took down the build +instructions and posted a sign that read +"Building this is too complicated, don't worry about it."1 + +We will neatly side step all of these problems and not +risk destroying or polluting our host system with garbage +by using Guix to manage our environments for us. + +Our toolchain only requires the first pass compiler because +newlib(-nano) is statically linked and introduced to the toolchain +by normal package composition. + + + + +# Defining the Packages + +All of the base packages are defined in `zephyr/packages/zephyr.scm`. +Zephyr modules are defined in `zephyr/packages/zephyr-xyz.scm`, following +the pattern of other module systems implemented by Guix. + + + + +## Binutils + +First thing we need to build is the `arm-zephyr-eabi` binutils. +This is very easy in Guix. + + (define-module (zephyr packages zephyr) + #:use-module (guix packages)) + + (define-public arm-zephyr-eabi-binutils + (let ((xbinutils (cross-binutils "arm-zephyr-eabi"))) + (package + (inherit xbinutils) + (name "arm-zephyr-eabi-binutils") + (version "2.38") + (source + (origin (method git-fetch) + (uri (git-reference + (url "https://github.com/zephyrproject-rtos/binutils-gdb") + (commit "6a1be1a6a571957fea8b130e4ca2dcc65e753469"))) + (file-name (git-file-name name version)) + (sha256 (base32 "0ylnl48jj5jk3jrmvfx5zf8byvwg7g7my7jwwyqw3a95qcyh0isr")))) + (arguments + `(#:tests? #f + ,@(substitute-keyword-arguments (package-arguments xbinutils) + ((#:configure-flags flags) + `(cons "--program-prefix=arm-zephyr-eabi-" ,flags))))) + (native-inputs + (append + (list texinfo + bison + flex + gmp + dejagnu) + (package-native-inputs xbinutils))) + (home-page "https://zephyrproject.org") + (synopsis "binutils for zephyr RTOS")))) + +The function `cross-binutils` returns a package which has been +configured for the given gnu triplet. We simply inherit that package +and replace the source. +The zephyr build system expects the binutils to be prefixed with +`arm-zephyr-eabi-` which is accomplished by adding another flag to the +`#:configure-flags` argument. + +We can test our package definition using the `-L` flag with `guix build` +to add our packages. + + guix build -L guix-zephyr zephyr-binutils + + /gnu/store/...-zephyr-binutils-2.38 + +This directory contains the results of `make install`. + + + + +## GCC sans libc + +This one is a bit more involved. Don't be afraid! +This version of GCC wants ISL version 0.15. It's easy enough +to make that happen. Inherit the current version of ISL and swap +out the source and update the version. For most packages the build process doesn't +change that much between versions. + + (define-public isl-0.15 + (package + (inherit isl) + (version "0.15") + (source (origin + (method url-fetch) + (uri (list (string-append "mirror://sourceforge/libisl/isl-" + version ".tar.gz"))) + (sha256 + (base32 + "11vrpznpdh7w8jp4wm4i8zqhzq2h7nix71xfdddp8xnzhz26gyq2")))))) + +Like the binutils, there is a function for creating cross-gcc packages. +This one accepts keywords specifying which binutils and libc to use. +If libc isn't given (like here), gcc is configured with many options disabled +to facilitate being built without libc. Therefore we need to add the extra options +we want 2 + + (define-public gcc-arm-zephyr-eabi-12 + (let ((xgcc (cross-gcc "arm-zephyr-eabi" + #:xbinutils zephyr-binutils))) + (package + (inherit xgcc) + (version "12.1.0") + (source (origin (method git-fetch) + (uri (git-reference + (url "https://github.com/zephyrproject-rtos/gcc") + (commit "0218469df050c33479a1d5be3e5239ac0eb351bf"))) + (file-name (git-file-name (package-name xgcc) version)) + (sha256 + (base32 "1s409qmidlvzaw1ns6jaanigh3azcxisjplzwn7j2n3s33b76zjk")) + (patches + (search-patches "gcc-12-cross-environment-variables.patch" + "gcc-cross-gxx-include-dir.patch")))) + (native-inputs + (modify-inputs (package-native-inputs xgcc) + ;; Get rid of stock ISL + (delete "isl") + ;; Add additional dependencies that xgcc doesn't have + ;; including our special ISL + (prepend flex + perl + python-3 + gmp + isl-0.15 + texinfo + python + mpc + mpfr + zlib))) + (arguments + (substitute-keyword-arguments (package-arguments xgcc) + ((#:phases phases) + `(modify-phases ,phases + (add-after 'unpack 'fix-genmultilib + (lambda _ + (substitute* "gcc/genmultilib" + (("#!/bin/sh") (string-append "#!" (which "sh")))) + #t)) + + (add-after 'set-paths 'augment-CPLUS_INCLUDE_PATH + (lambda* (#:key inputs #:allow-other-keys) + (let ((gcc (assoc-ref inputs "gcc"))) + ;; Remove the default compiler from CPLUS_INCLUDE_PATH to + ;; prevent header conflict with the GCC from native-inputs. + (setenv "CPLUS_INCLUDE_PATH" + (string-join + (delete (string-append gcc "/include/c++") + (string-split (getenv "CPLUS_INCLUDE_PATH") + #\:)) + ":")) + (format #t + "environment variable `CPLUS_INCLUDE_PATH' changed to ~a~%" + (getenv "CPLUS_INCLUDE_PATH")) + #t))))) + + ((#:configure-flags flags) + ;; The configure flags are largely identical to the flags used by the + ;; "GCC ARM embedded" project. + `(append (list "--enable-multilib" + "--with-newlib" + "--with-multilib-list=rmprofile" + "--with-host-libstdcxx=-static-libgcc -Wl,-Bstatic,-lstdc++,-Bdynamic -lm" + "--enable-plugins" + "--disable-decimal-float" + "--disable-libffi" + "--disable-libgomp" + "--disable-libmudflap" + "--disable-libquadmath" + "--disable-libssp" + "--disable-libstdcxx-pch" + "--disable-nls" + "--disable-shared" + "--disable-threads" + "--disable-tls" + "--with-gnu-ld" + "--with-gnu-as" + "--enable-initfini-array") + (delete "--disable-multilib" ,flags))))) + (native-search-paths + (list (search-path-specification + (variable "CROSS_C_INCLUDE_PATH") + (files '("arm-zephyr-eabi/include"))) + (search-path-specification + (variable "CROSS_CPLUS_INCLUDE_PATH") + (files '("arm-zephyr-eabi/include" + "arm-zephyr-eabi/c++" + "arm-zephyr-eabi/c++/arm-zephyr-eabi"))) + (search-path-specification + (variable "CROSS_LIBRARY_PATH") + (files '("arm-zephyr-eabi/lib"))))) + (home-page "https://zephyrproject.org") + (synopsis "GCC for zephyr RTOS")))) + +This GCC can be built like so. + + guix build -L guix-zephyr gcc-cross-sans-libc-arm-zephyr-eabi + + /gnu/store/...-gcc-cross-sans-libc-arm-zephyr-eabi-12.1.0-lib + /gnu/store/...-gcc-cross-sans-libc-arm-zephyr-eabi-12.1.0 + +Great! We now have our stage-1 compiler. + + + + +## Newlib(-nano) + +The newlib package package is quite straight forward (relatively). +It is mostly adding in the relevent configuration flags and patching +the files the `patch-shebangs` phase missed. + + (define-public zephyr-newlib + (package + (name "zephyr-newlib") + (version "3.3") + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/zephyrproject-rtos/newlib-cygwin") + (commit "4e150303bcc1e44f4d90f3489a4417433980d5ff"))) + (sha256 + (base32 "08qwjpj5jhpc3p7a5mbl7n6z7rav5yqlydqanm6nny42qpa8kxij")))) + (build-system gnu-build-system) + (arguments + `(#:out-of-source? #t + #:configure-flags '("--target=arm-zephyr-eabi" + "--enable-newlib-io-long-long" + "--enable-newlib-io-float" + "--enable-newlib-io-c99-formats" + "--enable-newlib-retargetable-locking" + "--enable-newlib-lite-exit" + "--enable-newlib-multithread" + "--enable-newlib-register-fini" + "--enable-newlib-extra-sections" + "--disable-newlib-wide-orient" + "--disable-newlib-fseek-optimization" + "--disable-newlib-supplied-syscalls" + "--disable-newlib-target-optspace" + "--disable-nls") + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-references-to-/bin/sh + (lambda _ + (substitute* '("libgloss/arm/cpu-init/Makefile.in" + "libgloss/arm/Makefile.in" + "libgloss/libnosys/Makefile.in" + "libgloss/Makefile.in") + (("/bin/sh") (which "sh"))) + #t))))) + (native-inputs + `(("xbinutils" ,zephyr-binutils) + ("xgcc" ,gcc-arm-zephyr-eabi-12) + ("texinfo" ,texinfo))) + (home-page "https://www.sourceware.org/newlib/") + (synopsis "C library for use on embedded systems") + (description "Newlib is a C library intended for use on embedded + systems. It is a conglomeration of several library parts that are easily + usable on embedded products.") + (license (license:non-copyleft + "https://www.sourceware.org/newlib/COPYING.NEWLIB")))) + +And the build. + + guix build -L guix-zephyr zephyr-newlib + + /gnu/store/...-zephyr-newlib-3.3 + + + + +## Complete toolchain3 + +Now that we've got the individual tools it's time to create our complete toolchain. +For this we need to do some package transformations. +Because these transformations are going to have to be done for every combination of +gcc/newlib it is best to create a function which we can reuse for every version +of the SDK. + + (define (arm-zephyr-eabi-toolchain xgcc newlib version) + "Produce a cross-compiler zephyr toolchain package with the compiler XGCC and the C + library variant NEWLIB." + (let ((newlib-with-xgcc (package (inherit newlib) + (native-inputs + (alist-replace "xgcc" (list xgcc) + (package-native-inputs newlib)))))) + (package + (name (string-append "arm-zephyr-eabi" + (if (string=? (package-name newlib-with-xgcc) + "newlib-nano") + "-nano" "") + "-toolchain")) + (version version) + (source #f) + (build-system trivial-build-system) + (arguments + '(#:modules ((guix build union) + (guix build utils)) + #:builder + (begin + (use-modules (ice-9 match) + (guix build union) + (guix build utils)) + (let ((out (assoc-ref %outputs "out"))) + (mkdir-p out) + (match %build-inputs + (((names . directories) ...) + (union-build (string-append out "/arm-zephyr-eabi") + directories) + #t)))))) + (inputs + `(("binutils" ,zephyr-binutils) + ("gcc" ,xgcc) + ("newlib" ,newlib-with-xgcc))) + (synopsis "Complete GCC tool chain for ARM zephyrRTOS development") + (description "This package provides a complete GCC tool chain for ARM + bare metal development with zephyr rtos. This includes the GCC arm-zephyr-eabi cross compiler + and newlib (or newlib-nano) as the C library. The supported programming + language is C.") + (home-page (package-home-page xgcc)) + (license (package-license xgcc))))) + +This function creates a special package which consists of the toolchain in a special directory hierarchy, i.e `arm-zephyr-eabi/`. +Our complete toolchain definition looks like this. + + (define-public arm-zephyr-eabi-toolchain-0.15.0 + (arm-zephyr-eabi-toolchain + gcc-arm-zephyr-eabi-12 + zephyr-newlib + "0.15.0")) + +To build: + + guix build -L guix-zephyr arm-zephyr-eabi-toolchain + + /gnu/store/...-arm-zephyr-eabi-toolchain-0.15.0 + + + + +# Integrating with Zephyr Build System + +Zephyr uses CMake as it's build system. It contains numerous CMake +files in both the so-called `ZEPHYR_BASE`, the zephyr source code +repository, as well as a handful in the SDK +which help select the correct toolchain for a given board. + +There are standard locations the build system will look for the +SDK. We are not using any of them. Our SDK lives in the store, +immutable forever. According to [this](https://docs.zephyrproject.org/latest/develop/west/without-west.html) the variable +`ZEPHYR_SDK_INSTALL_DIR` needs to point to our custom spot. + +We also need to grab the cmake files from the [repository](https://github.com/zephyrproject-rtos/sdk-ng) and create a +file `sdk_version` which contains the version string `ZEPHYR_BASE` +uses to find a compatible SDK. + +Along with the SDK proper we need to include a number of python +packages required by the build system4. + + (define-public zephyr-sdk + (package + (name "zephyr-sdk") + (version "0.15.0") + (home-page "https://zephyrproject.org") + (source (origin (method git-fetch) + (uri (git-reference + (url "https://github.com/zephyrproject-rtos/sdk-ng") + (commit "v0.15.0"))) + (file-name (git-file-name name version)) + (sha256 (base32 "04gsvh20y820dkv5lrwppbj7w3wdqvd8hcanm8hl4wi907lwlmwi")))) + (build-system trivial-build-system) + (arguments + `(#:modules ((guix build union) + (guix build utils)) + #:builder + (begin + (use-modules (guix build union) + (ice-9 match) + (guix build utils)) + (let* ((out (assoc-ref %outputs "out")) + (cmake-scripts (string-append (assoc-ref %build-inputs "source") + "/cmake")) + (sdk-out (string-append out "/zephyr-sdk-0.15.0"))) + (mkdir-p out) + + (match (assoc-remove! %build-inputs "source") + (((names . directories) ...) + (union-build sdk-out directories))) + + (copy-recursively cmake-scripts + (string-append sdk-out "/cmake")) + + (with-directory-excursion sdk-out + (call-with-output-file "sdk_version" + (lambda (p) + (format p "0.15.0"))) + #t))))) + (propagated-inputs + (list + arm-zephyr-eabi-toolchain-0.15.0 + zephyr-binutils + python-3 + python-pyelftools + python-pykwalify + python-pyyaml + python-packaging + dtc)) + (native-search-paths + (list (search-path-specification + (variable "ZEPHYR_SDK_INSTALL_DIR") + (files '(""))))) + (synopsis "SDK for zephyrRTOS") + (description "zephyr-sdk contains bundles a complete gcc toolchain as well + as host tools like dtc, openocd, qemu, and required python packages.") + (license license:apsl2))) + + + + +## Testing + +In order to test we will need an environment with the SDK installed. +We can take advantage of `guix shell` to avoid installing test +packages into our home environment. This way if it causes problems we +can just exit the shell and try again. + + guix shell -L guix-zephyr zephyr-sdk cmake ninja git + +`ZEPHYR_BASE` can be cloned into a temporary workspace to test our +toolchain functionality.5 + + mkdir /tmp/zephyr-project + cd /tmp/zephyr-project + git clone https://github.com/zephyrproject-rtos/zephyr + export ZEPHYR_BASE=/tmp/zephyr-project/zephyr + +In order to build for the test board (k64f in this case) we need to +get a hold of the vendor Hardware Abstraction Layers and CMSIS.6 + + git clone https://github.com/zephyrproject-rtos/hal_nxp && + git clone https://github.com/zephyrproject-rtos/cmsis + +To inform the build system about this module we pass it in with +`-DZEPHYR_MODULES=` which is a semicolon separated list of paths +containing a module.yml file. + +To build the hello world sample we use the following incantation. + + cmake -Bbuild $ZEPHYR_BASE/samples/hello_world \ + -GNinja \ + -DBOARD=frdm_k64f \ + -DBUILD_VERSION=3.1.0 \ + -DZEPHYR_MODULES="/tmp/zephyr-project/hal_nxp;/tmp/zephyr-project/cmsis" \ + && ninja -Cbuild + +If everything is set up correctly we will end up with a `./build` +directory with all our build artifacts. The SDK is installed correctly! + + +# Footnotes + +1 I'm paraphrasing, but [not by much](https://github.com/zephyrproject-rtos/sdk-ng/tree/v0.14.2#build-process). + +2 I got them from the SDK configuration scripts on the [sdk github](https://github.com/zephyrproject-rtos/sdk-ng) as well as the +commits to use for each of the tools. + +3 *Mostly* complete. libstdc++ does not build because +\`arm-zephyr-eabi\` is not \`arm-none-eabi\` so a dynamic link check is +performed/failed. I cannot figure out how crosstool-ng handles this. + +4 This is no longer the case. Now python packages are provided by the zephyr package +which was not available when this was being developed. + +5 For now. Eventually we will need to create a package for `zephyr-base` that +our guix zephyr-build-system can use. + +6 These will also need to become guix packages to allow the build system to compose modules. -- 2.39.1 From debbugs-submit-bounces@debbugs.gnu.org Mon Feb 27 07:50:40 2023 Received: (at 61765) by debbugs.gnu.org; 27 Feb 2023 12:50:40 +0000 Received: from localhost ([127.0.0.1]:46322 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pWcxj-0007yE-Oy for submit@debbugs.gnu.org; Mon, 27 Feb 2023 07:50:40 -0500 Received: from eggs.gnu.org ([209.51.188.92]:56592) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pWcxf-0007xz-76 for 61765@debbugs.gnu.org; Mon, 27 Feb 2023 07:50:37 -0500 Received: from fencepost.gnu.org ([2001:470:142:3::e]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pWcxX-000549-Rq; Mon, 27 Feb 2023 07:50:29 -0500 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnu.org; s=fencepost-gnu-org; h=MIME-Version:In-Reply-To:Date:References:Subject:To: From; bh=m4LxqpM70vTqYlcOQzHLLm129vQLAZDx26OQndnNqwU=; b=j7jvrifrwXp0e3zJ5P8G XGPcLoCVPFiEOgTSqR5hS/qGWJdc7uChAiyaWyMoJUl0wQRQbvf7DXb84RXUvCrmJxIAD1Eyj6ABN yZk6FmwbK9MfdxWa7JgQnvjNUpbRETey+5OEV3Y+3GicJL/5GQtOkjAQLcpsYgdXf5JCz2zorAcN8 GtJ/tbkyqaUPHqcZVwTzrFUyzzIq9DzJo2yeQhs/56wlSPbdVH3UnnbDuIEeSlcHFcqn1R6mGPRDx WIWdS0e0SI5gEb6RvdLLNN36GPCfsuLgFc3EnCLCs8/rxw57Z3aAkSH956f72CcPILsxDpNBXvN+m eT17Fk039gYI2g==; Received: from [193.50.110.164] (helo=ribbon) by fencepost.gnu.org with esmtpsa (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pWcxP-0003ss-WF; Mon, 27 Feb 2023 07:50:27 -0500 From: =?utf-8?Q?Ludovic_Court=C3=A8s?= To: Mitchell Schmeisser Subject: Re: bug#61765: custom toolchain blog post References: <87sfeuucab.fsf@librem.one> Date: Mon, 27 Feb 2023 13:50:17 +0100 In-Reply-To: <87sfeuucab.fsf@librem.one> (Mitchell Schmeisser's message of "Fri, 24 Feb 2023 13:51:56 -0500") Message-ID: <87fsarmfw6.fsf@gnu.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/28.2 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 61765 Cc: 61765@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Hello Mitchell, Mitchell Schmeisser skribis: > Here is a rough draft of my toolchain post. > I hope it can make an interesting contribution to the Guix literature. Yay, definitely! >>>From 4f6c43091ffd67cdbc5f041e496f61bc8a06070e Mon Sep 17 00:00:00 2001 > From: Mitchell Schmeisser > Date: Fri, 24 Feb 2023 13:02:05 -0500 > Subject: [PATCH] website: Add custom toolchain blog post > > * website/posts/custom-toolchains-with-guix.md: New file. This looks great to me! It=E2=80=99s useful insight for anyone who might w= ant to add a cross-compilation target to Guix or simply learn how this is implemented. > +++ b/website/posts/custom-toolchains-with-guix.md > @@ -0,0 +1,557 @@ > +# Table of Contents > + > +1. [Overview](#org2633a51) > +2. [Anatomy of a toolchain](#orgc440e9e) > +3. [Bootstrapping a Toolchain](#orgd42b6c3) > +4. [Defining the Packages](#org55042c5) > + 1. [Binutils](#org67da1ec) > + 2. [GCC sans libc](#org82d6f83) > + 3. [Newlib(-nano)](#orgf6bafbc) > + 4. [Complete toolchain](#org052f2a2) > +5. [Integrating with Zephyr Build System](#orgc3f87f4) > + 1. [Testing](#org9f3c314) > + > +All code is available at [guix-zephyr](https://github.com/paperclip4465/= guix-zephyr) channel. > + > + > + You can remove the table of contents and all the HTML snippets that pandoc added=E2=80=94I don=E2=80=99t think that works as expected with Haun= t/CommonMark. > +# Overview You can drop the heading. > +In order to deploy embedded software using Guix we first need to teach G= uix > +how to build it. Since Guix bootstraps everything this means we must tea= ch Guix > +how to build our toolchain. > + > +The [Zephyr Project](https://zephyrproject.org) uses its own fork of GCC= with custom configs for > +the architectures supported by the project. We want blog posts to be widely accessible so I would recommend providing more context in the intro. In particular, I=E2=80=99d suggest: 1. Mentioning that Guix supports cross-compilation (not everyone is aware of that), with a link to . 2. Adding a couple of sentences saying what Zephyr is (I didn=E2=80=99t k= now about it before :-)). 3. Saying a few words as to why Zephyr uses a GCC fork. 4. Clearly stating that you added support for cross-compilation to Zephyr with Guix in a channel, linking to said channel, and that this is what the remainder of the post will describe. You can check out posts at for inspiration. > +# Anatomy of a toolchain > + > +Toolchains are responsible for taking high level descriptions of programs > +and lowering them down to a series of equivalent machine instructions. > +This process involves more than just a compiler. The compiler uses the `= binutils` > +to manipulate it's internal representation down to a given architecture. > +It also needs the use of the C standard library as well as a few other l= ibraries > +needed for some compiler optimizations. > + > +The C library provides the interface to the underlying kernel. System ca= lls like `write` > +and `read` are provided by `Glibc` on most Linux distributions. > > +In embedded systems smaller implementations like `newlib` and `newlib-na= no` are used. I=E2=80=99d suggest not using fixed-width font (backquotes) for proper noun= s; you can write =E2=80=9Cglibc=E2=80=9D or =E2=80=9Cthe GNU C Library (glibc)= =E2=80=9D, =E2=80=9CBinutils=E2=80=9D or =E2=80=9Cthe GNU Binary Utilities (Binutils)=E2=80=9D, etc. > +First thing we need to build is the `arm-zephyr-eabi` binutils. > +This is very easy in Guix. > + > + (define-module (zephyr packages zephyr) > + #:use-module (guix packages)) > + > + (define-public arm-zephyr-eabi-binutils > + (let ((xbinutils (cross-binutils "arm-zephyr-eabi"))) > + (package > + (inherit xbinutils) > + (name "arm-zephyr-eabi-binutils") > + (version "2.38") > + (source > + (origin (method git-fetch) > + (uri (git-reference > + (url "https://github.com/zephyrproject-rtos/binutils-gdb") > + (commit "6a1be1a6a571957fea8b130e4ca2dcc65e753469"))) > + (file-name (git-file-name name version)) > + (sha256 (base32 "0ylnl48jj5jk3jrmvfx5zf8byvwg7g7my7jwwyqw3a95qcyh= 0isr")))) > + (arguments > + `(#:tests? #f > + ,@(substitute-keyword-arguments (package-arguments xbinutils) > + ((#:configure-flags flags) > + `(cons "--program-prefix=3Darm-zephyr-eabi-" ,flags))))) > + (native-inputs > + (append > + (list texinfo > + bison > + flex > + gmp > + dejagnu) > + (package-native-inputs xbinutils))) > + (home-page "https://zephyrproject.org") > + (synopsis "binutils for zephyr RTOS")))) Code snippets should be written like this, without leading indentation: ```scheme (define =E2=80=A6) ``` This will enable syntax highlighting. > +We can test our package definition using the `-L` flag with `guix build` > +to add our packages. > + > + guix build -L guix-zephyr zephyr-binutils > + > + /gnu/store/...-zephyr-binutils-2.38 Likewise: ``` guix build foo ``` > +# Integrating with Zephyr Build System > + > +Zephyr uses CMake as it's build system. It contains numerous CMake s/it's/its/ One thing that=E2=80=99s not clear to me: with this in place, can you do = =E2=80=9Cguix build --target=3Darm-zephyr-eabi hello=E2=80=9D, for instance? If not, wha= t=E2=80=99s missing to support it? It would be great if you could finish with a short conclusion stating, for instance, the key takeaway message, lessons learned, and/or your thoughts on how this could benefit others in the broader community. I wonder if it would be worth mentioning too, and how one would go about adding a module. WDYT? Could you send an updated patch? Thanks for contributing this article! Ludo=E2=80=99. From debbugs-submit-bounces@debbugs.gnu.org Thu Mar 02 13:14:15 2023 Received: (at control) by debbugs.gnu.org; 2 Mar 2023 18:14:15 +0000 Received: from localhost ([127.0.0.1]:58350 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pXnRW-0000Vc-Sl for submit@debbugs.gnu.org; Thu, 02 Mar 2023 13:14:15 -0500 Received: from mail3-relais-sop.national.inria.fr ([192.134.164.104]:13626) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pXnRV-0000VG-24 for control@debbugs.gnu.org; Thu, 02 Mar 2023 13:14:13 -0500 Authentication-Results: mail3-relais-sop.national.inria.fr; dkim=none (message not signed) header.i=none; spf=SoftFail smtp.mailfrom=ludo@gnu.org; dmarc=fail (p=none dis=none) d=gnu.org X-IronPort-AV: E=Sophos;i="5.98,228,1673910000"; d="scan'208";a="49075245" Received: from 91-160-117-201.subs.proxad.net (HELO ribbon) ([91.160.117.201]) by mail3-relais-sop.national.inria.fr with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 02 Mar 2023 19:14:06 +0100 Date: Thu, 02 Mar 2023 19:14:05 +0100 Message-Id: <87o7pb3tsi.fsf@gnu.org> To: control@debbugs.gnu.org From: =?utf-8?Q?Ludovic_Court=C3=A8s?= Subject: control message for bug #61765 MIME-version: 1.0 Content-type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Spam-Score: 1.0 (+) X-Debbugs-Envelope-To: control X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -0.0 (/) tags 61765 + moreinfo quit From debbugs-submit-bounces@debbugs.gnu.org Fri Mar 03 04:56:34 2023 Received: (at 61765) by debbugs.gnu.org; 3 Mar 2023 09:56:34 +0000 Received: from localhost ([127.0.0.1]:59676 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pY29P-00065U-3H for submit@debbugs.gnu.org; Fri, 03 Mar 2023 04:56:34 -0500 Received: from eggs.gnu.org ([209.51.188.92]:35172) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pY29K-00065C-9e for 61765@debbugs.gnu.org; Fri, 03 Mar 2023 04:56:29 -0500 Received: from fencepost.gnu.org ([2001:470:142:3::e]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pY29F-0002UV-2r for 61765@debbugs.gnu.org; Fri, 03 Mar 2023 04:56:21 -0500 Received: from [2001:660:6102:320:e120:2c8f:8909:cdfe] (helo=ribbon) by fencepost.gnu.org with esmtpsa (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pY29E-0007kG-9s for 61765@debbugs.gnu.org; Fri, 03 Mar 2023 04:56:20 -0500 Resent-To: 61765@debbugs.gnu.org Resent-From: =?utf-8?Q?Ludovic_Court=C3=A8s?= Resent-Date: Fri, 03 Mar 2023 10:56:18 +0100 Resent-Message-ID: <87v8jiyx8d.fsf@gnu.org> Received: from taslin.fdn.fr by taslin.fdn.fr with LMTP id wL6+HuLN/GONQwAAZ6i9OQ (envelope-from ) for ; Mon, 27 Feb 2023 16:36:02 +0100 Received: from eggs.gnu.org (eggs.gnu.org [IPv6:2001:470:142:3::10]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by taslin.fdn.fr (Postfix) with ESMTPS id 898186033E for ; Mon, 27 Feb 2023 16:36:01 +0100 (CET) Received: from mx1.librem.one ([138.201.176.93]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pWfXe-0001cd-9x for ludo@gnu.org; Mon, 27 Feb 2023 10:35:59 -0500 Received: from smtp.librem.one (unknown [192.241.214.14]) by mx1.librem.one (Postfix) with ESMTPS id A67C481DDB for ; Mon, 27 Feb 2023 07:35:47 -0800 (PST) Authentication-Results: name mx1.librem.one; dmarc=fail (p=reject dis=none) header.from=librem.one From: Mitchell Schmeisser To: Ludovic =?utf-8?Q?Court=C3=A8s?= Subject: Re: bug#61765: custom toolchain blog post In-Reply-To: <87fsarmfw6.fsf@gnu.org> ("Ludovic =?utf-8?Q?Court=C3=A8s=22'?= =?utf-8?Q?s?= message of "Mon, 27 Feb 2023 13:50:17 +0100") References: <87sfeuucab.fsf@librem.one> <87fsarmfw6.fsf@gnu.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/28.2 (gnu/linux) Date: Mon, 27 Feb 2023 10:35:43 -0500 Message-ID: <87k003xgs0.fsf@librem.one> Received-SPF: pass client-ip=138.201.176.93; envelope-from=mitchellschmeisser@librem.one; helo=mx1.librem.one X-Spam_score_int: -17 X-Spam_score: -1.8 X-Spam_bar: - X-Spam_report: (-1.8 / 5.0 requ) BAYES_00=-1.9, MIME_HEADER_CTYPE_ONLY=0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, WEIRD_QUOTING=0.001 autolearn=no autolearn_force=no X-Spam_action: no action X-Rspamd-Queue-Id: 898186033E X-Spamd-Result: default: False [0.70 / 25.00]; BAYES_HAM(-3.00)[100.00%]; MISSING_MIME_VERSION(2.00)[]; DMARC_POLICY_REJECT(2.00)[librem.one : No valid SPF, No valid DKIM,reject]; RCVD_IN_DNSWL_MED(-0.20)[2001:470:142:3::10:from]; MIME_GOOD(-0.10)[multipart/mixed,text/plain]; R_SPF_SOFTFAIL(0.00)[~all]; FROM_EQ_ENVFROM(0.00)[]; R_DKIM_NA(0.00)[]; MIME_TRACE(0.00)[0:+,1:+,2:+,3:+,4:+]; SPF_FAIL_FORWARDING(0.00)[]; RCVD_TLS_ALL(0.00)[]; ASN(0.00)[asn:22989, ipnet:2001:470:142::/48, country:US]; ARC_NA(0.00)[]; RCVD_COUNT_THREE(0.00)[3]; MID_RHS_MATCH_FROM(0.00)[]; FORWARDED(0.00)[ludo@gnu.org]; FROM_HAS_DN(0.00)[]; FORGED_RECIPIENTS_FORWARDING(0.00)[]; TO_DN_ALL(0.00)[]; DNSWL_BLOCKED(0.00)[192.241.214.14:received]; HAS_ATTACHMENT(0.00)[]; PREVIOUSLY_DELIVERED(0.00)[ludo@gnu.org]; RCPT_COUNT_ONE(0.00)[1]; FORGED_RECIPIENTS(0.00)[m:ludo@gnu.org,s:ludovic.courtes@fdn.fr] X-Rspamd-Server: taslin.fdn.fr MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="=-=-=" Content-Transfer-Encoding: base64 X-Spam-Score: -1.3 (-) X-Debbugs-Envelope-To: 61765 X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -2.3 (--) LS09LT0tPQpDb250ZW50LVR5cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9dXRmLTgKQ29udGVudC1U cmFuc2Zlci1FbmNvZGluZzogcXVvdGVkLXByaW50YWJsZQoKCkhlbGxvIEx1ZG8sCgpUaGFuayB5 b3UgZm9yIHlvdXIgZmVlZGJhY2shCgo+IE9uZSB0aGluZyB0aGF0PUUyPTgwPTk5cyBub3QgY2xl YXIgdG8gbWU6IHdpdGggdGhpcyBpbiBwbGFjZSwgY2FuIHlvdSBkbyA9Cj1FMj04MD05Q2d1aXgK PiBidWlsZCAtLXRhcmdldD0zRGFybS16ZXBoeXItZWFiaSBoZWxsbz1FMj04MD05RCwgZm9yIGlu c3RhbmNlPyAgSWYgbm90LCB3PQpoYXQ9RTI9ODA9OTlzCj4gbWlzc2luZyB0byBzdXBwb3J0IGl0 PwoKWW91IGNhbm5vdC4gSSBkbyBub3Qga25vdyBob3cgdG8gZGVzY3JpYmUgaXQgaW4gYSBzdWNj aW5jdCB3YXkgYnV0CnN1ZmZpY2UgdG8gc2F5IHRoZSBhcHBsaWNhdGlvbnMgbmVlZCB0byBrbm93 IHRoZXkgYXJlIHRhcmdldGluZyBaZXBoeXIKd2hlbiB0aGV5IGFyZSB3cml0dGVuLiBUaGUgYXBw bGljYXRpb24gd2lsbCBpbmNsdWRlIGEgYHByai5jb25mYCB3aGljaAppcyBhbmFsb2dvdXMgdG8g YSBjdXN0b20gZGVmY29uZmlnIGluIHRoZSBMaW51eCBrZXJuZWwuCkVpdGhlciBpbiB0aGlzIGZp bGUsIG9yIHNvbWV3aGVyZSBpbiB0aGUgQ01ha2VMaXN0cy50eHQgYSBgQk9BUkRgCnZhcmlhYmxl IGlzIHNldCB0byBzcGVjaWZ5IGEgc3BlY2lmaWMgYm9hcmQgZGVmaW5pdGlvbi4KVGhlc2UgYm9h cmQgZGVmaW5pdGlvbnMgY29udGFpbiBpbmZvcm1hdGlvbiBhYm91dCB0aGUgYXJjaGl0ZWN0dXJl IGFuZAp0aGUgQ01ha2Ugc2NyaXB0cyB0aGVtc2VsdmVzIHBpY2sgdGhlIHRvb2xjaGFpbi4KCkl0 J3Mgbm90IHRoYXQgaXQncyBpbXBvc3NpYmxlIHRvIGltcGxlbWVudCBzb21ldGhpbmcgbGlrZSBg Z3VpeCBidWlsZAotLXRhcmdldD0zRGFybS16ZXBoeXItZWFiaSBrNjRmLWhlbGxvLXdvcmxkYCBi dXQgdGhlIGs2NGYtaGVsbG8td29ybGQKd291bGQgYmUgd3JpdHRlbiBpbiBzdWNoIGEgd2F5IHRo YXQgdGhlIHRhcmdldCBpcyBpbXBsaWNpdCBpbiB0aGUKcGFja2FnZS4KClRoZSB3YXkgSSBlbnZp c2lvbiB0aGUgYC0tdGFyZ2V0L3N5c3RlbWAgZmxhZ3MgYmVpbmcgdXNlZCBpbiB0aGlzCmNvbnRl eHQgaXMgYGd1aXggYnVpbGQgLS10YXJnZXQ9M0Rhcm0tbGludXgtZ251ZWFiaWhmIGs2NGYtaGVs bG8td29ybGRgCndoaWNoIHdpbGwgc3RpbGwgcHJvZHVjZSB0aGUgY29ycmVjdCBmaXJtd2FyZSBi dXQgd2lsbCBhbGxvdyB0aGUKZmlybXdhcmUgdG8gYmUgc3RhZ2VkIHRvIGFub3RoZXIgbWFjaGlu ZSB3aGljaCB3aWxsIGJlIHJlc3BvbnNpYmxlIGZvcgp0aGUgZmluYWwgZGVwbG95bWVudCBvdmVy IHNvbWUgdHJhbnNwb3J0LgoKPiBJIHdvbmRlciBpZiBpdCB3b3VsZCBiZSB3b3J0aCBtZW50aW9u aW5nCj4gPGh0dHBzOi8vZ3VpeC5nbnUub3JnL21hbnVhbC9lbi9odG1sX25vZGUvUGxhdGZvcm1z Lmh0bWw+IHRvbywgYW5kIGhvdwo+IG9uZSB3b3VsZCBnbyBhYm91dCBhZGRpbmcgYSAgbW9kdWxl LiAgV0RZVD8KCkkgY29uc2lkZXJlZCB0cnlpbmcgdG8gYWRkIFplcGh5ciBwbGF0Zm9ybXMgYnV0 IEknbSBub3Qgc3VyZSBpdCdzIHdvcnRoCnRoZSBlZmZvcnQuCkluIGFkZGl0aW9uIHRvIHRoZSBw YXRjaCB0byB0aGUgd2Vic2l0ZSBJIGF0dGFjaGVkIGFub3RoZXIgcG9zdChpbiBvcmcpCndoaWNo IGRlc2NyaWJlcyBob3cgSSBpbnRlZ3JhdGVkIHRoaXMgdG9vbGNoYWluIGludG8gdGhlIEd1aXgK aW5mcmFzdHJ1Y3R1cmUgdG8gYWxsb3cgZGVmaW5pbmcgZmlybXdhcmUgcGFja2FnZXMuCk1heWJl IHRoZXJlIHdpbGwgYmUgYWRkaXRpb25hbCBpbmZvcm1hdGlvbiBpbiB0aGVyZSB3aGljaCBjYW4g aGVscCB5b3UKdW5kZXJzdGFuZCB3aGVyZSBJJ20gZ29pbmcgd2l0aCBhbGwgb2YgdGhpcy4KClRo ZXJlIHdpbGwgYmUgYSBwYXJ0IDMgKGFuZCBwb3NzaWJseSBtb3JlKSBhYm91dCBob3cgdG8gcHJh Y3RpY2FsbHkgdXNlCnRoaXMgc3R1ZmYgaW4gYSByZWFsIHByb2plY3QuCgotIE1pdGNoZWxsCgoK LS09LT0tPQpDb250ZW50LVR5cGU6IHRleHQvcGxhaW4KQ29udGVudC1EaXNwb3NpdGlvbjogYXR0 YWNobWVudDsKIGZpbGVuYW1lPTAwMDEtd2Vic2l0ZS1BZGQtdG9vbGNoYWluLWJsb2ctcG9zdC5w YXRjaApDb250ZW50LURlc2NyaXB0aW9uOiBwYXRjaAoKRnJvbSAwOTIwZWM3ZDk1MTM1NGM5NGMz ZGEyNzdkNThlNTRiNTg3NTIyNjIyIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNaXRj aGVsbCBTY2htZWlzc2VyIDxtaXRjaGVsbHNjaG1laXNzZXJAbGlicmVtLm9uZT4KRGF0ZTogTW9u LCAyNyBGZWIgMjAyMyAxMDoyMDozMiAtMDUwMApTdWJqZWN0OiBbUEFUQ0hdIHdlYnNpdGU6IEFk ZCB0b29sY2hhaW4gYmxvZyBwb3N0Cgp3ZWJzaXRlL2Jsb2cvY3VzdG9tLXRvb2xjaGFpbnMtd2l0 aC1ndWl4Lm1kOiBOZXcgZmlsZQotLS0KIHdlYnNpdGUvcG9zdHMvY3VzdG9tLXRvb2xjaGFpbnMt d2l0aC1ndWl4Lm1kIHwgNTc2ICsrKysrKysrKysrKysrKysrKysKIDEgZmlsZSBjaGFuZ2VkLCA1 NzYgaW5zZXJ0aW9ucygrKQogY3JlYXRlIG1vZGUgMTAwNjQ0IHdlYnNpdGUvcG9zdHMvY3VzdG9t LXRvb2xjaGFpbnMtd2l0aC1ndWl4Lm1kCgpkaWZmIC0tZ2l0IGEvd2Vic2l0ZS9wb3N0cy9jdXN0 b20tdG9vbGNoYWlucy13aXRoLWd1aXgubWQgYi93ZWJzaXRlL3Bvc3RzL2N1c3RvbS10b29sY2hh aW5zLXdpdGgtZ3VpeC5tZApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zYmQz OGJlCi0tLSAvZGV2L251bGwKKysrIGIvd2Vic2l0ZS9wb3N0cy9jdXN0b20tdG9vbGNoYWlucy13 aXRoLWd1aXgubWQKQEAgLTAsMCArMSw1NzYgQEAKK3RpdGxlOiBCdWlsZGluZyBUb29sY2hhaW5z IHdpdGggR3VpeAorYXV0aG9yOiBNaXRjaGVsbCBTY2htZWlzc2VyIDxtaXRjaGVsbHNjaG1laXNz ZXJAbGlicmVtLm9uZT4KK2RhdGU6IDIwMjMtMDItMjQgMTI6MDAKK3RhZ3M6IFNvZnR3YXJlIERl dmVsb3BtZW50LCBFbWJlZGRlZCwgWmVwaHlyLCBTY2hlbWUgQVBJCistLS0KKworSW4gb3JkZXIg dG8gZGVwbG95IGVtYmVkZGVkIHNvZnR3YXJlIHVzaW5nIEd1aXggd2UgZmlyc3QgbmVlZCB0byB0 ZWFjaCBHdWl4Citob3cgdG8gYnVpbGQgaXQuIFNpbmNlIEd1aXggYm9vdHN0cmFwcyBldmVyeXRo aW5nIHRoaXMgbWVhbnMgd2UgbXVzdCB0ZWFjaCBHdWl4Citob3cgdG8gYnVpbGQgb3VyIHRvb2xj aGFpbi4KKworVGhlIFtaZXBoeXIgUHJvamVjdF0oaHR0cHM6Ly96ZXBoeXJwcm9qZWN0Lm9yZykg dXNlcyBpdHMgb3duIGZvcmsgb2YgR0NDIHdpdGggY3VzdG9tIGNvbmZpZ3MgZm9yCit0aGUgYXJj aGl0ZWN0dXJlcyBzdXBwb3J0ZWQgYnkgdGhlIHByb2plY3QuCisKK1RoaXMgaXMgaW1wbGVtZW50 ZWQgYXMgYSBHdWl4IENoYW5uZWwuCitBbGwgY29kZSBpcyBhdmFpbGFibGUgYXQgW2hlcmVdKGh0 dHBzOi8vZ2l0aHViLmNvbS9wYXBlcmNsaXA0NDY1L2d1aXgtemVwaHlyKS4KKworIyBBYm91dCBa ZXBoeXJSVE9TCisKK1plcGh5clJUT1MgaXMgYSBSZWFsIFRpbWUgT3BlcmF0aW5nIFN5c3RlbSBm cm9tIHRoZSBMaW51eCBGb3VuZGF0aW9uLgorSXQgYWltcyB0byBwcm92aWRlIGEgY29tbW9uIGVu dmlyb25tZW50IHdoaWNoIGNhbiB0YXJnZXQgZXZlbiB0aGUgbW9zdAorcmVzb3VyY2UgY29uc3Ry YWluZWQgZGV2aWNlcy4KKworWmVwaHlyIGludHJvZHVjZXMgYSBtb2R1bGUgc3lzdGVtIHdoaWNo IGFsbG93cyB0aGlyZCBwYXJ0aWVzIHRvIHNoYXJlIGNvZGUKK2luIGEgdW5pZm9ybSB3YXkuIFpl cGh5ciB1c2VzIENNYWtlIHRvIHBlcmZvcm0gX3BoeXNpY2FsIGNvbXBvbmVudCBjb21wb3NpdGlv bl8KK29mIHRoZXNlIG1vZHVsZXMuICBJdCBzZWFyY2hlcyB0aGUgZmlsZXN5c3RlbSBhbmQgZ2Vu ZXJhdGVzIHNjcmlwdHMgd2hpY2gKK3RoZSB0b29sY2hhaW4gd2lsbCB1c2UgdG8gc3VjY2Vzc2Z1 bGx5IGNvbWJpbmUgdGhvc2UgY29tcG9uZW50cyBpbnRvIGEKK2Zpcm13YXJlIGltYWdlLgorCitU aGUgZmFjdCB0aGF0IFplcGh5ciBwcm92aWRlcyB0aGlzIG1lY2hhbmlzbSBpcyBvbmUgcmVhc29u IEkgY2hvc2UgdG8KK3RhcmdldCBpdCBpbiB0aGUgZmlyc3QgcGxhY2UuCisKK1RoaXMgc2VwYXJh dGlvbiBvZiBtb2R1bGVzIGluIGFuIGVtYmVkZGVkIGNvbnRleHQgaXMgYSByZWFsbHkgZ3JlYXQg dGhpbmcuCitJdCBicmluZ3MgbWFueSBvZiB0aGUgYWR2YW50YWdlcyB0aGF0IGl0IGJyaW5ncyB0 byB0aGUgTGludXggd29ybGQgc3VjaCBhcworY29kZSByZS11c2UsIHNtYWxsZXIgYmluYXJpZXMs IG1vcmUgZWZmaWNpZW50IGNhY2hlL1JBTSB1c2FnZSwgZXRjLgorSXQgYWxzbyBhbGxvd3MgdXMg dG8gd29yayBhcyBpbmRlcGVuZGVudCBncm91cHMgYW5kIGNvbXBvc2UKK2NvbnRyaWJ1dGlvbnMg ZnJvbSBtYW55IHRlYW1zLgorCitJdCBhbHNvIGJyaW5ncyBhbGwgb2YgdGhlIGNvbXBsZXhpdHku IFN1ZGRlbmx5IG1vc3Qgb2YgdGhlIHByb2JsZW1zCit0aGF0IHBsYWd1ZSB0cmFkaXRpb25hbCBk ZXBsb3ltZW50IG5vdyBhcHBseSB0byBvdXIgZW1iZWRkZWQKK3N5c3RlbS4gVGhlIGZhY3QgdGhh dCB0aGUgbGlicmFyaWVzIGFyZSBzdGF0aWNhbGx5IGxpbmtlZCBhdCBjb21waWxlCit0aW1lIGlu c3RlYWQgb2YgZHluYW1pY2FsbHkgYXQgcnVudGltZSBpcyBzaW1wbHkgYW4gaW1wbGVtZW50YXRp b24gZGV0YWlsLgorSSBzYXkgbW9zdCBiZWNhdXNlIGV2ZXJ5dGhpbmcgaXMgc3RhdGljYWxseSBs aW5rZWQgc28gdGhlcmUgaXMgbm8gcnVudGltZQorY29tcG9uZW50IGRpc2NvdmVyeSB0aGF0IG5l ZWRzIHRvIGJlIGFjY291bnRlZCBmb3IuCisKKworIyBBbmF0b215IG9mIGEgVG9vbGNoYWluCisK K1Rvb2xjaGFpbnMgYXJlIHJlc3BvbnNpYmxlIGZvciB0YWtpbmcgaGlnaCBsZXZlbCBkZXNjcmlw dGlvbnMgb2YgcHJvZ3JhbXMKK2FuZCBsb3dlcmluZyB0aGVtIGRvd24gdG8gYSBzZXJpZXMgb2Yg ZXF1aXZhbGVudCBtYWNoaW5lIGluc3RydWN0aW9ucy4KK1RoaXMgcHJvY2VzcyBpbnZvbHZlcyBt b3JlIHRoYW4ganVzdCBhIGNvbXBpbGVyLiBUaGUgY29tcGlsZXIgdXNlcyB0aGUgYGJpbnV0aWxz YAordG8gbWFuaXB1bGF0ZSBpdCdzIGludGVybmFsIHJlcHJlc2VudGF0aW9uIGRvd24gdG8gYSBn aXZlbiBhcmNoaXRlY3R1cmUuCitJdCBhbHNvIG5lZWRzIHRoZSB1c2Ugb2YgdGhlIEMgc3RhbmRh cmQgbGlicmFyeSBhcyB3ZWxsIGFzIGEgZmV3IG90aGVyIGxpYnJhcmllcworbmVlZGVkIGZvciBz b21lIGNvbXBpbGVyIG9wdGltaXphdGlvbnMuCisKK1RoZSBDIGxpYnJhcnkgcHJvdmlkZXMgdGhl IGludGVyZmFjZSB0byB0aGUgdW5kZXJseWluZyBrZXJuZWwuIFN5c3RlbSBjYWxscyBsaWtlIGB3 cml0ZWAKK2FuZCBgcmVhZGAgYXJlIHByb3ZpZGVkIGJ5IEdsaWJjIG9uIG1vc3QgTGludXggZGlz dHJpYnV0aW9ucy4KKworSW4gZW1iZWRkZWQgc3lzdGVtcyBzbWFsbGVyIGltcGxlbWVudGF0aW9u cyBsaWtlIFJlZGhhdCdzIG5ld2xpYiBhbmQKK25ld2xpYi1uYW5vIGFyZSB1c2VkLgorCisjIEJv b3RzdHJhcHBpbmcgYSBUb29sY2hhaW4KKworSW4gb3JkZXIgdG8gY29tcGlsZSBHQ0Mgd2UgbmVl ZCBhIEMgbGlicmFyeSB0aGF0J3MgYmVlbiBjb21waWxlZCBmb3IKK291ciB0YXJnZXQgYXJjaGl0 ZWN0dXJlLiBIb3cgY2FuIHdlIGNyb3NzIGNvbXBpbGUgb3VyIEMgbGlicmFyeSBpZiB3ZQorbmVl ZCBvdXIgQyBsaWJyYXJ5IHRvIGJ1aWxkIGEgY3Jvc3MgY29tcGlsZXI/IFRoZSBzb2x1dGlvbiBp cyB0byBidWlsZAorYSBzaW1wbGVyIGNvbXBpbGVyIHRoYXQgZG9lc24ndCByZXF1aXJlIHRoZSBD IGxpYnJhcnkgdG8gZnVuY3Rpb24uCitJdCB3aWxsIG5vdCBiZSBjYXBhYmxlIG9mIGFzIG1hbnkg b3B0aW1pemF0aW9ucyBhbmQgaXQgd2lsbCBiZSB2ZXJ5IHNsb3csCitob3dldmVyIGl0IHdpbGwg YmUgYWJsZSB0byBidWlsZCB0aGUgQyBsaWJyYXJpZXMgYXMgd2VsbCBhcyB0aGUgY29tcGxldGUg dmVyc2lvbgorb2YgR0NDLgorCitJbiBvcmRlciB0byBidWlsZCB0aGUgc2ltcGxlciBjb21waWxl ciB3ZSBuZWVkIHRvIGNvbXBpbGUgdGhlIEJpbnV0aWxzIHRvCit3b3JrIHdpdGggb3VyIHRhcmdl dCBhcmNoaXRlY3R1cmUuCitUaGUgYGJpbnV0aWxzYCBjYW4gYmUgYm9vdHN0cmFwcGVkIHdpdGgg b3VyIGhvc3QgR0NDIGFuZCBoYXZlIG5vIHRhcmdldCBkZXBlbmRlbmNpZXMuCisKK1tGb3IgbW9y ZSBpbmZvcm1hdGlvbiByZWFkIHRoaXMuXShodHRwczovL2Nyb3NzdG9vbC1uZy5naXRodWIuaW8v ZG9jcy90b29sY2hhaW4tY29uc3RydWN0aW9uLykKKworRG9lc24ndCBzb3VuZCBzbyBiYWQgcmln aHQ/IEl0IGlzbid0Li4uIGluIHRoZW9yeS4KK0hvd2V2ZXIgaW50ZXJuZXQgZm9ydW1zIHNpbmNl IHRpbWUgaW1tZW1vcmlhbCBoYXZlIGJlZW4KK2xpdHRlcmVkIHdpdGggdGhlIGxhbWVudHMgb2Yg dGhvc2Ugd2hvIGNhbWUgYmVmb3JlLgorRnJvbSBpbmNvcnJlY3QgdmVyc2lvbnMgb2YgSVNMIHRv IHRoZSB3cm9uZyBDIGxpYnJhcnkgYmVpbmcgbGlua2VkCitvciB0aGUgaG9zdCBsaW5rZXIgYmVp bmcgdXNlZCwgZXRjLgorVGhlIG9uZSBjb21tb25hbGl0eSBiZXR3ZWVuIGFsbCBvZiB0aGVzZSBp c3N1ZXMgaXMgdGhlIGVudmlyb25tZW50LgorQnVpbGRpbmcgR0NDIGlzIGRpZmZpY3VsdCBiZWNh dXNlIGlzb2xhdGluZyBidWlsZCBlbnZpcm9ubWVudHMgaXMgaGFyZC4KKworSW4gZmFjdCBhcyBv ZiA9djAuMTQuMj0gdGhlIHplcGh5ciBTREsgcmVwb3NpdG9yeSB0b29rIGRvd24gdGhlIGJ1aWxk CitpbnN0cnVjdGlvbnMgYW5kIHBvc3RlZCBhIHNpZ24gdGhhdCByZWFkCisiQnVpbGRpbmcgdGhp cyBpcyB0b28gY29tcGxpY2F0ZWQsIGRvbid0IHdvcnJ5IGFib3V0IGl0LiIKKyhJJ20gcGFyYXBo cmFzaW5nLCBidXQKK1tub3QgYnkgbXVjaF0oaHR0cHM6Ly9naXRodWIuY29tL3plcGh5cnByb2pl Y3QtcnRvcy9zZGstbmcvdHJlZS92MC4xNC4yI2J1aWxkLXByb2Nlc3MpLikKKworV2Ugd2lsbCBu ZWF0bHkgc2lkZSBzdGVwIGFsbCBvZiB0aGVzZSBwcm9ibGVtcyBhbmQgbm90CityaXNrIGRlc3Ry b3lpbmcgb3IgcG9sbHV0aW5nIG91ciBob3N0IHN5c3RlbSB3aXRoIGdhcmJhZ2UKK2J5IHVzaW5n IEd1aXggdG8gbWFuYWdlIG91ciBlbnZpcm9ubWVudHMgZm9yIHVzLgorCitPdXIgdG9vbGNoYWlu IG9ubHkgcmVxdWlyZXMgdGhlIGZpcnN0IHBhc3MgY29tcGlsZXIgYmVjYXVzZQorbmV3bGliKC1u YW5vKSBpcyBzdGF0aWNhbGx5IGxpbmtlZCBhbmQgaW50cm9kdWNlZCB0byB0aGUgdG9vbGNoYWlu CitieSBub3JtYWwgcGFja2FnZSBjb21wb3NpdGlvbi4KKworCisjIERlZmluaW5nIHRoZSBQYWNr YWdlcworCitBbGwgb2YgdGhlIGJhc2UgcGFja2FnZXMgYXJlIGRlZmluZWQgaW4gYHplcGh5ci9w YWNrYWdlcy96ZXBoeXIuc2NtYC4KK1plcGh5ciBtb2R1bGVzIChjb21pbmcgc29vbiEpIGFyZSBk ZWZpbmVkIGluIGB6ZXBoeXIvcGFja2FnZXMvemVwaHlyLXh5ei5zY21gLAorZm9sbG93aW5nIHRo ZSBwYXR0ZXJuIG9mIG90aGVyIG1vZHVsZSBzeXN0ZW1zIGltcGxlbWVudGVkIGJ5IEd1aXguCisK KyMjIEJpbnV0aWxzCisKK0ZpcnN0IHRoaW5nIHdlIG5lZWQgdG8gYnVpbGQgaXMgdGhlIGBhcm0t emVwaHlyLWVhYmlgIGJpbnV0aWxzLgorVGhpcyBpcyB2ZXJ5IGVhc3kgaW4gR3VpeC4KKworYGBg c2NoZW1lCisoZGVmaW5lLXB1YmxpYyBhcm0temVwaHlyLWVhYmktYmludXRpbHMKKyAgKGxldCAo KHhiaW51dGlscyAoY3Jvc3MtYmludXRpbHMgImFybS16ZXBoeXItZWFiaSIpKSkKKyAgICAocGFj a2FnZSAoaW5oZXJpdCB4YmludXRpbHMpCisgICAgICAobmFtZSAiYXJtLXplcGh5ci1lYWJpLWJp bnV0aWxzIikKKyAgICAgICh2ZXJzaW9uICIyLjM4IikKKyAgICAgIChzb3VyY2UKKwkob3JpZ2lu IChtZXRob2QgZ2l0LWZldGNoKQorCQkodXJpIChnaXQtcmVmZXJlbmNlCisJCSAgICAgICh1cmwg Imh0dHBzOi8vZ2l0aHViLmNvbS96ZXBoeXJwcm9qZWN0LXJ0b3MvYmludXRpbHMtZ2RiIikKKwkJ ICAgICAgKGNvbW1pdCAiNmExYmUxYTZhNTcxOTU3ZmVhOGIxMzBlNGNhMmRjYzY1ZTc1MzQ2OSIp KSkKKwkJKGZpbGUtbmFtZSAoZ2l0LWZpbGUtbmFtZSBuYW1lIHZlcnNpb24pKQorCQkoc2hhMjU2 IChiYXNlMzIgIjB5bG5sNDhqajVqazNqcm12Zng1emY4Ynl2d2c3ZzdteTdqd3d5cXczYTk1cWN5 aDBpc3IiKSkpKQorCShhcmd1bWVudHMKKwkgYCgjOnRlc3RzPyAjZgorCSAgICxAKHN1YnN0aXR1 dGUta2V5d29yZC1hcmd1bWVudHMgKHBhY2thZ2UtYXJndW1lbnRzIHhiaW51dGlscykKKwkgICAg ICAgKCgjOmNvbmZpZ3VyZS1mbGFncyBmbGFncykKKwkJYChjb25zICItLXByb2dyYW0tcHJlZml4 PWFybS16ZXBoeXItZWFiaS0iICxmbGFncykpKSkpCisJKG5hdGl2ZS1pbnB1dHMKKwkgKGFwcGVu ZAorCSAgKGxpc3QgdGV4aW5mbworCQliaXNvbgorCQlmbGV4CisJCWdtcAorCQlkZWphZ251KQor CSAgKHBhY2thZ2UtbmF0aXZlLWlucHV0cyB4YmludXRpbHMpKSkKKwkoaG9tZS1wYWdlICJodHRw czovL3plcGh5cnByb2plY3Qub3JnIikKKwkoc3lub3BzaXMgImJpbnV0aWxzIGZvciB6ZXBoeXIg UlRPUyIpKSkpCitgYGAKKworVGhlIGZ1bmN0aW9uIGBjcm9zcy1iaW51dGlsc2AgcmV0dXJucyBh IHBhY2thZ2Ugd2hpY2ggaGFzIGJlZW4KK2NvbmZpZ3VyZWQgZm9yIHRoZSBnaXZlbiBnbnUgdHJp cGxldC4gIFdlIHNpbXBseSBpbmhlcml0IHRoYXQgcGFja2FnZQorYW5kIHJlcGxhY2UgdGhlIHNv dXJjZS4KK1RoZSB6ZXBoeXIgYnVpbGQgc3lzdGVtIGV4cGVjdHMgdGhlIGJpbnV0aWxzIHRvIGJl IHByZWZpeGVkIHdpdGgKK2Bhcm0temVwaHlyLWVhYmktYCB3aGljaCBpcyBhY2NvbXBsaXNoZWQg YnkgYWRkaW5nIGFub3RoZXIgZmxhZyB0byB0aGUKK2AjOmNvbmZpZ3VyZS1mbGFnc2AgYXJndW1l bnQuCisKK1dlIGNhbiB0ZXN0IG91ciBwYWNrYWdlIGRlZmluaXRpb24gdXNpbmcgdGhlID0tTD0g ZmxhZyB3aXRoIGBndWl4IGJ1aWxkYAordG8gYWRkIG91ciBwYWNrYWdlcy4KKworYGBgc2gKK2d1 aXggYnVpbGQgLUwgZ3VpeC16ZXBoeXIgemVwaHlyLWJpbnV0aWxzCisKKy9nbnUvc3RvcmUvLi4u LXplcGh5ci1iaW51dGlscy0yLjM4CitgYGAKKworVGhpcyBkaXJlY3RvcnkgY29udGFpbnMgdGhl IHJlc3VsdHMgb2YgYG1ha2UgaW5zdGFsbGAuCisKKyMjIEdDQyBzYW5zIGxpYmMKKworVGhpcyBv bmUgaXMgYSBiaXQgbW9yZSBpbnZvbHZlZC4gRG9uJ3QgYmUgYWZyYWlkIQorVGhpcyB2ZXJzaW9u IG9mIEdDQyB3YW50cyBJU0wgdmVyc2lvbiAwLjE1LiBJdCdzIGVhc3kgZW5vdWdoCit0byBtYWtl IHRoYXQgaGFwcGVuLiBJbmhlcml0IHRoZSBjdXJyZW50IHZlcnNpb24gb2YgSVNMIGFuZCBzd2Fw CitvdXQgdGhlIHNvdXJjZSBhbmQgdXBkYXRlIHRoZSB2ZXJzaW9uLiBGb3IgbW9zdCBwYWNrYWdl cyB0aGUgYnVpbGQgcHJvY2VzcyBkb2Vzbid0CitjaGFuZ2UgdGhhdCBtdWNoIGJldHdlZW4gdmVy c2lvbnMuCisKK2BgYHNjaGVtZQorKGRlZmluZS1wdWJsaWMgaXNsLTAuMTUKKyAgICAocGFja2Fn ZQorCShpbmhlcml0IGlzbCkKKwkodmVyc2lvbiAiMC4xNSIpCisJKHNvdXJjZSAob3JpZ2luCisJ CSAgKG1ldGhvZCB1cmwtZmV0Y2gpCisJCSAgKHVyaSAobGlzdCAoc3RyaW5nLWFwcGVuZCAibWly cm9yOi8vc291cmNlZm9yZ2UvbGliaXNsL2lzbC0iCisJCQkJCSAgICB2ZXJzaW9uICIudGFyLmd6 IikpKQorCQkgIChzaGEyNTYKKwkJICAgKGJhc2UzMgorCQkgICAgIjExdnJwem5wZGg3dzhqcDR3 bTRpOHpxaHpxMmg3bml4NzF4ZmRkZHA4eG56aHoyNmd5cTIiKSkpKSkpCisKK2BgYAorCitMaWtl IHRoZSBiaW51dGlscywgdGhlcmUgaXMgYSBmdW5jdGlvbiBmb3IgY3JlYXRpbmcgY3Jvc3MtZ2Nj IHBhY2thZ2VzLgorVGhpcyBvbmUgYWNjZXB0cyBrZXl3b3JkcyBzcGVjaWZ5aW5nIHdoaWNoIGJp bnV0aWxzIGFuZCBsaWJjIHRvIHVzZS4KK0lmIGxpYmMgaXNuJ3QgZ2l2ZW4gKGxpa2UgaGVyZSks IGdjYyBpcyBjb25maWd1cmVkIHdpdGggbWFueSBvcHRpb25zIGRpc2FibGVkCit0byBmYWNpbGl0 YXRlIGJlaW5nIGJ1aWx0IHdpdGhvdXQgbGliYy4gVGhlcmVmb3JlIHdlIG5lZWQgdG8gYWRkIHRo ZSBleHRyYSBvcHRpb25zCit3ZSB3YW50IChJIGdvdCB0aGVtIGZyb20gdGhlIFNESyBjb25maWd1 cmF0aW9uIHNjcmlwdHMgb24gdGhlCitbc2RrIGdpdGh1Yl0oaHR0cHM6Ly9naXRodWIuY29tL3pl cGh5cnByb2plY3QtcnRvcy9zZGstbmcpIGFzIHdlbGwgYXMgdGhlCitjb21taXRzIHRvIHVzZSBm b3IgZWFjaCBvZiB0aGUgdG9vbHMpLgorCisKK2BgYHNjaGVtZQorKGRlZmluZS1wdWJsaWMgZ2Nj LWFybS16ZXBoeXItZWFiaS0xMgorICAgIChsZXQgKCh4Z2NjIChjcm9zcy1nY2MgImFybS16ZXBo eXItZWFiaSIKKwkJCSAgICM6eGJpbnV0aWxzIHplcGh5ci1iaW51dGlscykpKQorICAgICAgKHBh Y2thZ2UKKwkoaW5oZXJpdCB4Z2NjKQorCSh2ZXJzaW9uICIxMi4xLjAiKQorCShzb3VyY2UgKG9y aWdpbiAobWV0aG9kIGdpdC1mZXRjaCkKKwkJCSh1cmkgKGdpdC1yZWZlcmVuY2UKKwkJCSAgICAg ICh1cmwgImh0dHBzOi8vZ2l0aHViLmNvbS96ZXBoeXJwcm9qZWN0LXJ0b3MvZ2NjIikKKwkJCSAg ICAgIChjb21taXQgIjAyMTg0NjlkZjA1MGMzMzQ3OWExZDViZTNlNTIzOWFjMGViMzUxYmYiKSkp CisJCQkoZmlsZS1uYW1lIChnaXQtZmlsZS1uYW1lIChwYWNrYWdlLW5hbWUgeGdjYykgdmVyc2lv bikpCisJCQkoc2hhMjU2CisJCQkgKGJhc2UzMiAiMXM0MDlxbWlkbHZ6YXcxbnM2amFhbmlnaDNh emN4aXNqcGx6d243ajJuM3MzM2I3NnpqayIpKQorCQkJKHBhdGNoZXMKKwkJCSAoc2VhcmNoLXBh dGNoZXMgImdjYy0xMi1jcm9zcy1lbnZpcm9ubWVudC12YXJpYWJsZXMucGF0Y2giCisJCQkJCSAi Z2NjLWNyb3NzLWd4eC1pbmNsdWRlLWRpci5wYXRjaCIpKSkpCisJKG5hdGl2ZS1pbnB1dHMKKwkg KG1vZGlmeS1pbnB1dHMgKHBhY2thZ2UtbmF0aXZlLWlucHV0cyB4Z2NjKQorCSAgIDs7IEdldCBy aWQgb2Ygc3RvY2sgSVNMCisJICAgKGRlbGV0ZSAiaXNsIikKKwkgICA7OyBBZGQgYWRkaXRpb25h bCBkZXBlbmRlbmNpZXMgdGhhdCB4Z2NjIGRvZXNuJ3QgaGF2ZQorCSAgIDs7IGluY2x1ZGluZyBv dXIgc3BlY2lhbCBJU0wKKwkgICAocHJlcGVuZCBmbGV4CisJCSAgICBwZXJsCisJCSAgICBweXRo b24tMworCQkgICAgZ21wCisJCSAgICBpc2wtMC4xNQorCQkgICAgdGV4aW5mbworCQkgICAgcHl0 aG9uCisJCSAgICBtcGMKKwkJICAgIG1wZnIKKwkJICAgIHpsaWIpKSkKKwkoYXJndW1lbnRzCisJ IChzdWJzdGl0dXRlLWtleXdvcmQtYXJndW1lbnRzIChwYWNrYWdlLWFyZ3VtZW50cyB4Z2NjKQor CSAgICgoIzpwaGFzZXMgcGhhc2VzKQorCSAgICBgKG1vZGlmeS1waGFzZXMgLHBoYXNlcworCSAg ICAgICAoYWRkLWFmdGVyICd1bnBhY2sgJ2ZpeC1nZW5tdWx0aWxpYgorCQkgKGxhbWJkYSBfCisJ CSAgIChzdWJzdGl0dXRlIyAiZ2NjL2dlbm11bHRpbGliIgorCQkgICAgICgoIiMhL2Jpbi9zaCIp IChzdHJpbmctYXBwZW5kICIjISIgKHdoaWNoICJzaCIpKSkpCisJCSAgICN0KSkKKworCSAgICAg ICAoYWRkLWFmdGVyICdzZXQtcGF0aHMgJ2F1Z21lbnQtQ1BMVVNfSU5DTFVERV9QQVRICisJCSAo bGFtYmRhIyAoIzprZXkgaW5wdXRzICM6YWxsb3ctb3RoZXIta2V5cykKKwkJICAgKGxldCAoKGdj YyAoYXNzb2MtcmVmIGlucHV0cyAgImdjYyIpKSkKKwkJICAgICA7OyBSZW1vdmUgdGhlIGRlZmF1 bHQgY29tcGlsZXIgZnJvbSBDUExVU19JTkNMVURFX1BBVEggdG8KKwkJICAgICA7OyBwcmV2ZW50 IGhlYWRlciBjb25mbGljdCB3aXRoIHRoZSBHQ0MgZnJvbSBuYXRpdmUtaW5wdXRzLgorCQkgICAg IChzZXRlbnYgIkNQTFVTX0lOQ0xVREVfUEFUSCIKKwkJCSAgICAgKHN0cmluZy1qb2luCisJCQkg ICAgICAoZGVsZXRlIChzdHJpbmctYXBwZW5kIGdjYyAiL2luY2x1ZGUvYysrIikKKwkJCQkgICAg ICAoc3RyaW5nLXNwbGl0IChnZXRlbnYgIkNQTFVTX0lOQ0xVREVfUEFUSCIpCisJCQkJCQkgICAg I1w6KSkKKwkJCSAgICAgICI6IikpCisJCSAgICAgKGZvcm1hdCAjdAorCQkJICAgICAiZW52aXJv bm1lbnQgdmFyaWFibGUgYENQTFVTX0lOQ0xVREVfUEFUSCcgY2hhbmdlZCB0byBgYWAlIgorCQkJ ICAgICAoZ2V0ZW52ICJDUExVU19JTkNMVURFX1BBVEgiKSkKKwkJICAgICAjdCkpKSkpCisKKwkg ICAoKCM6Y29uZmlndXJlLWZsYWdzIGZsYWdzKQorCSAgICA7OyBUaGUgY29uZmlndXJlIGZsYWdz IGFyZSBsYXJnZWx5IGlkZW50aWNhbCB0byB0aGUgZmxhZ3MgdXNlZCBieSB0aGUKKwkgICAgOzsg IkdDQyBBUk0gZW1iZWRkZWQiIHByb2plY3QuCisJICAgIGAoYXBwZW5kIChsaXN0ICItLWVuYWJs ZS1tdWx0aWxpYiIKKwkJCSAgICItLXdpdGgtbmV3bGliIgorCQkJICAgIi0td2l0aC1tdWx0aWxp Yi1saXN0PXJtcHJvZmlsZSIKKwkJCSAgICItLXdpdGgtaG9zdC1saWJzdGRjeHg9LXN0YXRpYy1s aWJnY2MgLVdsLC1Cc3RhdGljLC1sc3RkYysrLC1CZHluYW1pYyAtbG0iCisJCQkgICAiLS1lbmFi bGUtcGx1Z2lucyIKKwkJCSAgICItLWRpc2FibGUtZGVjaW1hbC1mbG9hdCIKKwkJCSAgICItLWRp c2FibGUtbGliZmZpIgorCQkJICAgIi0tZGlzYWJsZS1saWJnb21wIgorCQkJICAgIi0tZGlzYWJs ZS1saWJtdWRmbGFwIgorCQkJICAgIi0tZGlzYWJsZS1saWJxdWFkbWF0aCIKKwkJCSAgICItLWRp c2FibGUtbGlic3NwIgorCQkJICAgIi0tZGlzYWJsZS1saWJzdGRjeHgtcGNoIgorCQkJICAgIi0t ZGlzYWJsZS1ubHMiCisJCQkgICAiLS1kaXNhYmxlLXNoYXJlZCIKKwkJCSAgICItLWRpc2FibGUt dGhyZWFkcyIKKwkJCSAgICItLWRpc2FibGUtdGxzIgorCQkJICAgIi0td2l0aC1nbnUtbGQiCisJ CQkgICAiLS13aXRoLWdudS1hcyIKKwkJCSAgICItLWVuYWJsZS1pbml0ZmluaS1hcnJheSIpCisJ CSAgICAgKGRlbGV0ZSAiLS1kaXNhYmxlLW11bHRpbGliIiAsZmxhZ3MpKSkpKQorCShuYXRpdmUt c2VhcmNoLXBhdGhzCisJIChsaXN0IChzZWFyY2gtcGF0aC1zcGVjaWZpY2F0aW9uCisJCSh2YXJp YWJsZSAiQ1JPU1NfQ19JTkNMVURFX1BBVEgiKQorCQkoZmlsZXMgJygiYXJtLXplcGh5ci1lYWJp L2luY2x1ZGUiKSkpCisJICAgICAgIChzZWFyY2gtcGF0aC1zcGVjaWZpY2F0aW9uCisJCSh2YXJp YWJsZSAiQ1JPU1NfQ1BMVVNfSU5DTFVERV9QQVRIIikKKwkJKGZpbGVzICcoImFybS16ZXBoeXIt ZWFiaS9pbmNsdWRlIgorCQkJICJhcm0temVwaHlyLWVhYmkvYysrIgorCQkJICJhcm0temVwaHly LWVhYmkvYysrL2FybS16ZXBoeXItZWFiaSIpKSkKKwkgICAgICAgKHNlYXJjaC1wYXRoLXNwZWNp ZmljYXRpb24KKwkJKHZhcmlhYmxlICJDUk9TU19MSUJSQVJZX1BBVEgiKQorCQkoZmlsZXMgJygi YXJtLXplcGh5ci1lYWJpL2xpYiIpKSkpKQorCShob21lLXBhZ2UgImh0dHBzOi8vemVwaHlycHJv amVjdC5vcmciKQorCShzeW5vcHNpcyAiR0NDIGZvciB6ZXBoeXIgUlRPUyIpKSkpCitgYGAKKwor VGhpcyBHQ0MgY2FuIGJlIGJ1aWx0IGxpa2Ugc28uCisKK2BgYHNoCitndWl4IGJ1aWxkIC1MIGd1 aXgtemVwaHlyIGdjYy1jcm9zcy1zYW5zLWxpYmMtYXJtLXplcGh5ci1lYWJpCisKKy9nbnUvc3Rv cmUvLi4uLWdjYy1jcm9zcy1zYW5zLWxpYmMtYXJtLXplcGh5ci1lYWJpLTEyLjEuMC1saWIKKy9n bnUvc3RvcmUvLi4uLWdjYy1jcm9zcy1zYW5zLWxpYmMtYXJtLXplcGh5ci1lYWJpLTEyLjEuMAor CitgYGAKK0dyZWF0ISBXZSBub3cgaGF2ZSBvdXIgc3RhZ2UtMSBjb21waWxlci4KKworIyMgTmV3 bGliKC1uYW5vKQorCitUaGUgbmV3bGliIHBhY2thZ2UgcGFja2FnZSBpcyBxdWl0ZSBzdHJhaWdo dCBmb3J3YXJkIChyZWxhdGl2ZWx5KS4KK0l0IGlzIG1vc3RseSBhZGRpbmcgaW4gdGhlIHJlbGV2 ZW50IGNvbmZpZ3VyYXRpb24gZmxhZ3MgYW5kIHBhdGNoaW5nCit0aGUgZmlsZXMgdGhlIGBwYXRj aC1zaGViYW5nc2AgcGhhc2UgbWlzc2VkLgorCitgYGBzY2hlbWUKKyhkZWZpbmUtcHVibGljIHpl cGh5ci1uZXdsaWIKKyAgKHBhY2thZ2UKKyAgICAobmFtZSAiemVwaHlyLW5ld2xpYiIpCisgICAg KHZlcnNpb24gIjMuMyIpCisgICAgKHNvdXJjZSAob3JpZ2luCisJICAgICAgKG1ldGhvZCBnaXQt ZmV0Y2gpCisJICAgICAgKHVyaSAoZ2l0LXJlZmVyZW5jZQorCQkgICAgKHVybCAiaHR0cHM6Ly9n aXRodWIuY29tL3plcGh5cnByb2plY3QtcnRvcy9uZXdsaWItY3lnd2luIikKKwkJICAgIChjb21t aXQgIjRlMTUwMzAzYmNjMWU0NGY0ZDkwZjM0ODlhNDQxNzQzMzk4MGQ1ZmYiKSkpCisJICAgICAg KHNoYTI1NgorCSAgICAgICAoYmFzZTMyICIwOHF3anBqNWpocGMzcDdhNW1ibDduNno3cmF2NXlx bHlkcWFubTZubnk0MnFwYThreGlqIikpKSkKKyAgICAoYnVpbGQtc3lzdGVtIGdudS1idWlsZC1z eXN0ZW0pCisgICAgKGFyZ3VtZW50cworICAgICBgKCM6b3V0LW9mLXNvdXJjZT8gI3QKKyAgICAg ICAjOmNvbmZpZ3VyZS1mbGFncyAnKCItLXRhcmdldD1hcm0temVwaHlyLWVhYmkiCisJCQkgICAi LS1lbmFibGUtbmV3bGliLWlvLWxvbmctbG9uZyIKKwkJCSAgICItLWVuYWJsZS1uZXdsaWItaW8t ZmxvYXQiCisJCQkgICAiLS1lbmFibGUtbmV3bGliLWlvLWM5OS1mb3JtYXRzIgorCQkJICAgIi0t ZW5hYmxlLW5ld2xpYi1yZXRhcmdldGFibGUtbG9ja2luZyIKKwkJCSAgICItLWVuYWJsZS1uZXds aWItbGl0ZS1leGl0IgorCQkJICAgIi0tZW5hYmxlLW5ld2xpYi1tdWx0aXRocmVhZCIKKwkJCSAg ICItLWVuYWJsZS1uZXdsaWItcmVnaXN0ZXItZmluaSIKKwkJCSAgICItLWVuYWJsZS1uZXdsaWIt ZXh0cmEtc2VjdGlvbnMiCisJCQkgICAiLS1kaXNhYmxlLW5ld2xpYi13aWRlLW9yaWVudCIKKwkJ CSAgICItLWRpc2FibGUtbmV3bGliLWZzZWVrLW9wdGltaXphdGlvbiIKKwkJCSAgICItLWRpc2Fi bGUtbmV3bGliLXN1cHBsaWVkLXN5c2NhbGxzIgorCQkJICAgIi0tZGlzYWJsZS1uZXdsaWItdGFy Z2V0LW9wdHNwYWNlIgorCQkJICAgIi0tZGlzYWJsZS1ubHMiKQorICAgICAgICM6cGhhc2VzCisg ICAgICAgKG1vZGlmeS1waGFzZXMgJXN0YW5kYXJkLXBoYXNlcworCSAoYWRkLWFmdGVyICd1bnBh Y2sgJ2ZpeC1yZWZlcmVuY2VzLXRvLS9iaW4vc2gKKwkgICAobGFtYmRhIF8KKwkgICAgIChzdWJz dGl0dXRlIyAnKCJsaWJnbG9zcy9hcm0vY3B1LWluaXQvTWFrZWZpbGUuaW4iCisJCQkgICAgImxp Ymdsb3NzL2FybS9NYWtlZmlsZS5pbiIKKwkJCSAgICAibGliZ2xvc3MvbGlibm9zeXMvTWFrZWZp bGUuaW4iCisJCQkgICAgImxpYmdsb3NzL01ha2VmaWxlLmluIikKKwkgICAgICAgKCgiL2Jpbi9z aCIpICh3aGljaCAic2giKSkpCisJICAgICAjdCkpKSkpCisgICAgKG5hdGl2ZS1pbnB1dHMKKyAg ICAgYCgoInhiaW51dGlscyIgLHplcGh5ci1iaW51dGlscykKKyAgICAgICAoInhnY2MiICxnY2Mt YXJtLXplcGh5ci1lYWJpLTEyKQorICAgICAgICgidGV4aW5mbyIgLHRleGluZm8pKSkKKyAgICAo aG9tZS1wYWdlICJodHRwczovL3d3dy5zb3VyY2V3YXJlLm9yZy9uZXdsaWIvIikKKyAgICAoc3lu b3BzaXMgIkMgbGlicmFyeSBmb3IgdXNlIG9uIGVtYmVkZGVkIHN5c3RlbXMiKQorICAgIChkZXNj cmlwdGlvbiAiTmV3bGliIGlzIGEgQyBsaWJyYXJ5IGludGVuZGVkIGZvciB1c2Ugb24gZW1iZWRk ZWQKK3N5c3RlbXMuICBJdCBpcyBhIGNvbmdsb21lcmF0aW9uIG9mIHNldmVyYWwgbGlicmFyeSBw YXJ0cyB0aGF0IGFyZSBlYXNpbHkKK3VzYWJsZSBvbiBlbWJlZGRlZCBwcm9kdWN0cy4iKQorICAg IChsaWNlbnNlIChsaWNlbnNlOm5vbi1jb3B5bGVmdAorCSAgICAgICJodHRwczovL3d3dy5zb3Vy Y2V3YXJlLm9yZy9uZXdsaWIvQ09QWUlORy5ORVdMSUIiKSkpKQorYGBgCisKK0FuZCB0aGUgYnVp bGQuCisKK2BgYHNoIDpleHBvcnRzIGJvdGgKKyQgZ3VpeCBidWlsZCAtTCBndWl4LXplcGh5ciB6 ZXBoeXItbmV3bGliCisKKy9nbnUvc3RvcmUvLi4uLXplcGh5ci1uZXdsaWItMy4zCitgYGAKKwor IyMgQ29tcGxldGUgVG9vbGNoYWluCisKK19Nb3N0bHlfIGNvbXBsZXRlLiBsaWJzdGRjKysgZG9l cyBub3QgYnVpbGQgYmVjYXVzZQorYGFybS16ZXBoeXItZWFiaWAgaXMgbm90IGBhcm0tbm9uZS1l YWJpYCBzbyBhIGR5bmFtaWMgbGluayBjaGVjayBpcworcGVyZm9ybWVkL2ZhaWxlZC4gSSBjYW5u b3QgZmlndXJlIG91dCBob3cgY3Jvc3N0b29sLW5nIGhhbmRsZXMgdGhpcy4KKworTm93IHRoYXQg d2UndmUgZ290IHRoZSBpbmRpdmlkdWFsIHRvb2xzIGl0J3MgdGltZSB0byBjcmVhdGUgb3VyIGNv bXBsZXRlIHRvb2xjaGFpbi4KK0ZvciB0aGlzIHdlIG5lZWQgdG8gZG8gc29tZSBwYWNrYWdlIHRy YW5zZm9ybWF0aW9ucy4KK0JlY2F1c2UgdGhlc2UgdHJhbnNmb3JtYXRpb25zIGFyZSBnb2luZyB0 byBoYXZlIHRvIGJlIGRvbmUgZm9yIGV2ZXJ5IGNvbWJpbmF0aW9uIG9mCitiaW51dGlscy9nY2Mv bmV3bGliIGl0IGlzIGJlc3QgdG8gY3JlYXRlIGEgZnVuY3Rpb24gd2hpY2ggd2UgY2FuIHJldXNl IGZvciBldmVyeSB2ZXJzaW9uCitvZiB0aGUgU0RLLgorCitgYGBzY2hlbWUgOmV4cG9ydHMgY29k ZQorICAoZGVmaW5lIChhcm0temVwaHlyLWVhYmktdG9vbGNoYWluIHhnY2MgbmV3bGliIHZlcnNp b24pCisgICAgIlByb2R1Y2UgYSBjcm9zcy1jb21waWxlciB6ZXBoeXIgdG9vbGNoYWluIHBhY2th Z2Ugd2l0aCB0aGUgY29tcGlsZXIgWEdDQyBhbmQgdGhlIEMKKyAgbGlicmFyeSB2YXJpYW50IE5F V0xJQi4iCisgICAgKGxldCAoKG5ld2xpYi13aXRoLXhnY2MgKHBhY2thZ2UgKGluaGVyaXQgbmV3 bGliKQorCQkJCSAgICAgKG5hdGl2ZS1pbnB1dHMKKwkJCQkgICAgICAoYWxpc3QtcmVwbGFjZSAi eGdjYyIgKGxpc3QgeGdjYykKKwkJCQkJCSAgICAgKHBhY2thZ2UtbmF0aXZlLWlucHV0cyBuZXds aWIpKSkpKSkKKyAgICAgIChwYWNrYWdlCisJKG5hbWUgKHN0cmluZy1hcHBlbmQgImFybS16ZXBo eXItZWFiaSIKKwkJCSAgICAgKGlmIChzdHJpbmc9PyAocGFja2FnZS1uYW1lIG5ld2xpYi13aXRo LXhnY2MpCisJCQkJCSAgICJuZXdsaWItbmFubyIpCisJCQkJICItbmFubyIgIiIpCisJCQkgICAg ICItdG9vbGNoYWluIikpCisJKHZlcnNpb24gdmVyc2lvbikKKwkoc291cmNlICNmKQorCShidWls ZC1zeXN0ZW0gdHJpdmlhbC1idWlsZC1zeXN0ZW0pCisJKGFyZ3VtZW50cworCSAnKCM6bW9kdWxl cyAoKGd1aXggYnVpbGQgdW5pb24pCisJCSAgICAgIChndWl4IGJ1aWxkIHV0aWxzKSkKKwkgICAj OmJ1aWxkZXIKKwkgICAoYmVnaW4KKwkgICAgICh1c2UtbW9kdWxlcyAoaWNlLTkgbWF0Y2gpCisJ CQkgIChndWl4IGJ1aWxkIHVuaW9uKQorCQkJICAoZ3VpeCBidWlsZCB1dGlscykpCisJICAgICAo bGV0ICgob3V0IChhc3NvYy1yZWYgJW91dHB1dHMgIm91dCIpKSkKKwkgICAgICAgKG1rZGlyLXAg b3V0KQorCSAgICAgICAobWF0Y2ggJWJ1aWxkLWlucHV0cworCQkgKCgobmFtZXMgLiBkaXJlY3Rv cmllcykgLi4uKQorCQkgICh1bmlvbi1idWlsZCAoc3RyaW5nLWFwcGVuZCBvdXQgIi9hcm0temVw aHlyLWVhYmkiKQorCQkJICAgICAgIGRpcmVjdG9yaWVzKQorCQkgICN0KSkpKSkpCisJKGlucHV0 cworCSBgKCgiYmludXRpbHMiICx6ZXBoeXItYmludXRpbHMpCisJICAgKCJnY2MiICx4Z2NjKQor CSAgICgibmV3bGliIiAsbmV3bGliLXdpdGgteGdjYykpKQorCShzeW5vcHNpcyAiQ29tcGxldGUg R0NDIHRvb2wgY2hhaW4gZm9yIEFSTSB6ZXBoeXJSVE9TIGRldmVsb3BtZW50IikKKwkoZGVzY3Jp cHRpb24gIlRoaXMgcGFja2FnZSBwcm92aWRlcyBhIGNvbXBsZXRlIEdDQyB0b29sIGNoYWluIGZv ciBBUk0KKyAgYmFyZSBtZXRhbCBkZXZlbG9wbWVudCB3aXRoIHplcGh5ciBydG9zLiAgVGhpcyBp bmNsdWRlcyB0aGUgR0NDIGFybS16ZXBoeXItZWFiaSBjcm9zcyBjb21waWxlcgorICBhbmQgbmV3 bGliIChvciBuZXdsaWItbmFubykgYXMgdGhlIEMgbGlicmFyeS4gIFRoZSBzdXBwb3J0ZWQgcHJv Z3JhbW1pbmcKKyAgbGFuZ3VhZ2UgaXMgQy4iKQorCShob21lLXBhZ2UgKHBhY2thZ2UtaG9tZS1w YWdlIHhnY2MpKQorCShsaWNlbnNlIChwYWNrYWdlLWxpY2Vuc2UgeGdjYykpKSkpCitgYGAKKwor VGhpcyBmdW5jdGlvbiBjcmVhdGVzIGEgc3BlY2lhbCBwYWNrYWdlIHdoaWNoIGNvbnNpc3RzIG9m IHRoZSB0b29sY2hhaW4KK2luIGEgc3BlY2lhbCBkaXJlY3RvcnkgaGllcmFyY2h5LCBpLmUgYGFy bS16ZXBoeXItZWFiaS9gLgorT3VyIGNvbXBsZXRlIHRvb2xjaGFpbiBkZWZpbml0aW9uIGxvb2tz IGxpa2UgdGhpcy4KKworYGBgc2NoZW1lCisoZGVmaW5lLXB1YmxpYyBhcm0temVwaHlyLWVhYmkt dG9vbGNoYWluLTAuMTUuMAorICAoYXJtLXplcGh5ci1lYWJpLXRvb2xjaGFpbgorICAgZ2NjLWFy bS16ZXBoeXItZWFiaS0xMgorICAgemVwaHlyLW5ld2xpYgorICAgIjAuMTUuMCIpKQorYGBgCisK K1RvIGJ1aWxkOgorCitgYGBzaAorZ3VpeCBidWlsZCAtTCBndWl4LXplcGh5ciBhcm0temVwaHly LWVhYmktdG9vbGNoYWluCisvZ251L3N0b3JlLy4uLi1hcm0temVwaHlyLWVhYmktdG9vbGNoYWlu LTAuMTUuMAorYGBgCisKKyMgSW50ZWdyYXRpbmcgd2l0aCBaZXBoeXIgQnVpbGQgU3lzdGVtCisK K1plcGh5ciB1c2VzIENNYWtlIGFzIGl0cyBidWlsZCBzeXN0ZW0uIEl0IGNvbnRhaW5zIG51bWVy b3VzIENNYWtlIGZpbGVzIGluIGJvdGggdGhlIHNvLWNhbGxlZCBgWkVQSFlSX0JBU0VgLAordGhl IHplcGh5ciBzb3VyY2UgY29kZSByZXBvc2l0b3J5LCBhcyB3ZWxsIGFzIGEgaGFuZGZ1bCBpbiB0 aGUgU0RLIHdoaWNoIGhlbHAgc2VsZWN0IHRoZSBjb3JyZWN0IHRvb2xjaGFpbgorZm9yIGEgZ2l2 ZW4gYm9hcmQuCisKK1RoZXJlIGFyZSBzdGFuZGFyZCBsb2NhdGlvbnMgdGhlIGJ1aWxkIHN5c3Rl bSB3aWxsIGxvb2sgZm9yIHRoZSBTREsuIFdlIGFyZSBub3QgdXNpbmcgYW55IG9mIHRoZW0uCitP dXIgU0RLIGxpdmVzIGluIHRoZSBzdG9yZSwgaW1tdXRhYmxlIGZvcmV2ZXIuCitBY2NvcmRpbmcg dG8gW1todHRwczovL2RvY3MuemVwaHlycHJvamVjdC5vcmcvbGF0ZXN0L2RldmVsb3Avd2VzdC93 aXRob3V0LXdlc3QuaHRtbF1bdGhpc11dIHRoZSB2YXJpYWJsZSBgWkVQSFlSX1NES19JTlNUQUxM X0RJUmAgbmVlZHMgdG8gcG9pbnQgdG8gb3VyIGN1c3RvbSBzcG90LgorCitXZSBhbHNvIG5lZWQg dG8gZ3JhYiB0aGUgY21ha2UgZmlsZXMgZnJvbSB0aGUKK1tyZXBvc2l0b3J5XShodHRwczovL2dp dGh1Yi5jb20vemVwaHlycHJvamVjdC1ydG9zL3Nkay1uZykKK2FuZCBjcmVhdGUgYSBmaWxlLCBg c2RrX3ZlcnNpb25gLCB3aGljaAorY29udGFpbnMgdGhlIHZlcnNpb24gc3RyaW5nIGBaRVBIWVJf QkFTRWAgdXNlcyB0byBmaW5kIGEgY29tcGF0aWJsZSBTREsuCisKK0Fsb25nIHdpdGggdGhlIFNE SyBwcm9wZXIgd2UgbmVlZCB0byBpbmNsdWRlIGEgbnVtYmVyIG9mCitweXRob24gcGFja2FnZXMg cmVxdWlyZWQgYnkgdGhlIGJ1aWxkIHN5c3RlbS4KKworYGBgc2NoZW1lCisoZGVmaW5lLXB1Ymxp YyB6ZXBoeXItc2RrCisgIChwYWNrYWdlCisgICAgKG5hbWUgInplcGh5ci1zZGsiKQorICAgICh2 ZXJzaW9uICIwLjE1LjAiKQorICAgIChob21lLXBhZ2UgImh0dHBzOi8vemVwaHlycHJvamVjdC5v cmciKQorICAgIChzb3VyY2UgKG9yaWdpbiAobWV0aG9kIGdpdC1mZXRjaCkKKwkJICAgICh1cmkg KGdpdC1yZWZlcmVuY2UKKwkJCSAgKHVybCAiaHR0cHM6Ly9naXRodWIuY29tL3plcGh5cnByb2pl Y3QtcnRvcy9zZGstbmciKQorCQkJICAoY29tbWl0ICJ2MC4xNS4wIikpKQorCQkgICAgKGZpbGUt bmFtZSAoZ2l0LWZpbGUtbmFtZSBuYW1lIHZlcnNpb24pKQorCQkgICAgKHNoYTI1NiAoYmFzZTMy ICIwNGdzdmgyMHk4MjBka3Y1bHJ3cHBiajd3M3dkcXZkOGhjYW5tOGhsNHdpOTA3bHdsbXdpIikp KSkKKyAgICAoYnVpbGQtc3lzdGVtIHRyaXZpYWwtYnVpbGQtc3lzdGVtKQorICAgIChhcmd1bWVu dHMKKyAgICAgYCgjOm1vZHVsZXMgKChndWl4IGJ1aWxkIHVuaW9uKQorCQkgIChndWl4IGJ1aWxk IHV0aWxzKSkKKyAgICAgICAjOmJ1aWxkZXIKKyAgICAgICAoYmVnaW4KKwkgKHVzZS1tb2R1bGVz IChndWl4IGJ1aWxkIHVuaW9uKQorCQkgICAgICAoaWNlLTkgbWF0Y2gpCisJCSAgICAgIChndWl4 IGJ1aWxkIHV0aWxzKSkKKwkgKGxldCMgKChvdXQgKGFzc29jLXJlZiAlb3V0cHV0cyAib3V0Iikp CisJCShjbWFrZS1zY3JpcHRzIChzdHJpbmctYXBwZW5kIChhc3NvYy1yZWYgJWJ1aWxkLWlucHV0 cyAic291cmNlIikKKwkJCQkJICAgICAgIi9jbWFrZSIpKQorCQkoc2RrLW91dCAoc3RyaW5nLWFw cGVuZCBvdXQgIi96ZXBoeXItc2RrLTAuMTUuMCIpKSkKKwkgICAobWtkaXItcCBvdXQpCisKKwkg ICAobWF0Y2ggKGFzc29jLXJlbW92ZSEgJWJ1aWxkLWlucHV0cyAic291cmNlIikKKwkgICAgICgo KG5hbWVzIC4gZGlyZWN0b3JpZXMpIC4uLikKKwkgICAgICAodW5pb24tYnVpbGQgc2RrLW91dCBk aXJlY3RvcmllcykpKQorCisJICAgKGNvcHktcmVjdXJzaXZlbHkgY21ha2Utc2NyaXB0cworCQkJ ICAgICAoc3RyaW5nLWFwcGVuZCBzZGstb3V0ICIvY21ha2UiKSkKKworCSAgICh3aXRoLWRpcmVj dG9yeS1leGN1cnNpb24gc2RrLW91dAorCSAgICAgKGNhbGwtd2l0aC1vdXRwdXQtZmlsZSAic2Rr X3ZlcnNpb24iCisJICAgICAgIChsYW1iZGEgKHApCisJCSAoZm9ybWF0IHAgIjAuMTUuMCIpKSkK KwkgICAgICN0KSkpKSkKKyAgICAocHJvcGFnYXRlZC1pbnB1dHMKKyAgICAgKGxpc3QKKyAgICAg IGFybS16ZXBoeXItZWFiaS10b29sY2hhaW4tMC4xNS4wCisgICAgICB6ZXBoeXItYmludXRpbHMK KyAgICAgIGR0YworICAgICAgcHl0aG9uLTMKKyAgICAgIHB5dGhvbi1weWVsZnRvb2xzCisgICAg ICBweXRob24tcHlrd2FsaWZ5CisgICAgICBweXRob24tcHl5YW1sCisgICAgICBweXRob24tcGFj a2FnaW5nKSkKKyAgICAobmF0aXZlLXNlYXJjaC1wYXRocworICAgICAobGlzdCAoc2VhcmNoLXBh dGgtc3BlY2lmaWNhdGlvbgorCSAgICAodmFyaWFibGUgIlpFUEhZUl9TREtfSU5TVEFMTF9ESVIi KQorCSAgICAoZmlsZXMgJygiIikpKSkpCisgICAgKHN5bm9wc2lzICJTREsgZm9yIHplcGh5clJU T1MiKQorICAgIChkZXNjcmlwdGlvbiAiemVwaHlyLXNkayBjb250YWlucyBidW5kbGVzIGEgY29t cGxldGUgZ2NjIHRvb2xjaGFpbiBhcyB3ZWxsCithcyBob3N0IHRvb2xzIGxpa2UgZHRjLCBvcGVu b2NkLCBxZW11LCBhbmQgcmVxdWlyZWQgcHl0aG9uIHBhY2thZ2VzLiIpCisgICAgKGxpY2Vuc2Ug bGljZW5zZTphcHNsMikpKQorYGBgCisKKyMgVGVzdGluZworCitJbiBvcmRlciB0byB0ZXN0IHdl IHdpbGwgbmVlZCBhbiBlbnZpcm9ubWVudCB3aXRoIHRoZSBTREsgaW5zdGFsbGVkLgorV2UgY2Fu IHRha2UgYWR2YW50YWdlIG9mIGBndWl4IHNoZWxsYCB0byBhdm9pZCBpbnN0YWxsaW5nIHRlc3Qg cGFja2FnZXMgaW50bworb3VyIGhvbWUgZW52aXJvbm1lbnQuIFRoaXMgd2F5IGlmIGl0IGNhdXNl cyBwcm9ibGVtcyB3ZSBjYW4ganVzdCBleGl0IHRoZSBzaGVsbAorYW5kIHRyeSBhZ2Fpbi4KKwor YGBgc2gKK2d1aXggc2hlbGwgLUwgZ3VpeC16ZXBoeXIgemVwaHlyLXNkayBjbWFrZSBuaW5qYSBn aXQKK2BgYAorCitgWkVQSFlSX0JBU0VgIGNhbiBiZSBjbG9uZWQgaW50byBhIHRlbXBvcmFyeSB3 b3Jrc3BhY2UgdG8gdGVzdCBvdXIgdG9vbGNoYWluIGZ1bmN0aW9uYWxpdHkuCisoRm9yIG5vdy4g RXZlbnR1YWxseSB3ZSB3aWxsIG5lZWQgdG8gY3JlYXRlIGEgcGFja2FnZSBmb3IgYHplcGh5ci1i YXNlYCB0aGF0CitvdXIgZ3VpeCB6ZXBoeXItYnVpbGQtc3lzdGVtIGNhbiB1c2UuKQorCitgYGBz aAorbWtkaXIgL3RtcC96ZXBoeXItcHJvamVjdAorY2QgL3RtcC96ZXBoeXItcHJvamVjdAorZ2l0 IGNsb25lIGh0dHBzOi8vZ2l0aHViLmNvbS96ZXBoeXJwcm9qZWN0LXJ0b3MvemVwaHlyCitleHBv cnQgWkVQSFlSX0JBU0U9L3RtcC96ZXBoeXItcHJvamVjdC96ZXBoeXIKK2BgYAorCitJbiBvcmRl ciB0byBidWlsZCBmb3IgdGhlIHRlc3QgYm9hcmQgKGs2NGYgaW4gdGhpcyBjYXNlKSB3ZSBuZWVk IHRvIGdldCBhIGhvbGQgb2YgdGhlIHZlbmRvcgorSGFyZHdhcmUgQWJzdHJhY3Rpb24gTGF5ZXJz IGFuZCBDTVNJUy4KKyhUaGVzZSB3aWxsIGFsc28gbmVlZCB0byBiZWNvbWUgZ3VpeCBwYWNrYWdl cyB0byBhbGxvdyB0aGUgYnVpbGQgc3lzdGVtIHRvIGNvbXBvc2UgbW9kdWxlcykuCisKK2BgYHNo CitnaXQgY2xvbmUgaHR0cHM6Ly9naXRodWIuY29tL3plcGh5cnByb2plY3QtcnRvcy9oYWxfbnhw ICYmCitnaXQgY2xvbmUgaHR0cHM6Ly9naXRodWIuY29tL3plcGh5cnByb2plY3QtcnRvcy9jbXNp cworYGBgCisKK1RvIGluZm9ybSB0aGUgYnVpbGQgc3lzdGVtIGFib3V0IHRoaXMgbW9kdWxlIHdl IHBhc3MgaXQgaW4gd2l0aCBgLURaRVBIWVJfTU9EVUxFUz1gIHdoaWNoIGlzCithIHNlbWljb2xv biBzZXBhcmF0ZWQgbGlzdCBvZiBwYXRocyBjb250YWluaW5nIGEgbW9kdWxlLnltbCBmaWxlLgor CitUbyBidWlsZCB0aGUgaGVsbG8gd29ybGQgc2FtcGxlIHdlIHVzZSB0aGUgZm9sbG93aW5nIGlu Y2FudGF0aW9uLgorYGBgc2gKK2NtYWtlIC1CYnVpbGQgJFpFUEhZUl9CQVNFL3NhbXBsZXMvaGVs bG9fd29ybGQgXAorCS1HTmluamEgXAorCS1EQk9BUkQ9ZnJkbV9rNjRmIFwKKwktREJVSUxEX1ZF UlNJT049My4xLjAgXAorCS1EWkVQSFlSX01PRFVMRVM9Ii90bXAvemVwaHlyLXByb2plY3QvaGFs X254cDsvdG1wL3plcGh5ci1wcm9qZWN0L2Ntc2lzIiBcCisgICAgICAmJiBuaW5qYSAtQ2J1aWxk CitgYGAKKworSWYgZXZlcnl0aGluZyBpcyBzZXQgdXAgY29ycmVjdGx5IHdlIHdpbGwgZW5kIHVw IHdpdGggYSA9Li9idWlsZD0KK2RpcmVjdG9yeSB3aXRoIGFsbCBvdXIgYnVpbGQgYXJ0aWZhY3Rz LiBUaGUgU0RLIGlzIGluc3RhbGxlZCBjb3JyZWN0bHkhCisKKyMgQ29uY2x1c2lvbgorCitBIGN1 c3RvbWl6ZWQgY3Jvc3MgdG9vbGNoYWluIGlzIG9uZSBvZiB0aGUgbW9zdCBkaWZmaWN1bHQgcGll Y2VzIG9mCitzb2Z0d2FyZSB0byBidWlsZC4gVXNpbmcgR3VpeCwgd2UgZG8gbm90IG5lZWQgdG8g YmUgYWZyYWlkIG9mIHRoZQorY29tcGxleGl0eSEgV2UgY2FuIGZpZGRsZSB3aXRoIHNldHRpbmdz LCBzd2FwIG91dCBjb21wb25lbnRzLCBhbmQgZG8KK3RoZSBtb3N0IGJyYWluIGRlYWQgdGhpbmdz IHRvIG91ciBlbnZpcm9ubWVudHMgd2l0aG91dCBhIGNhcmUgaW4gdGhlCit3b3JsZC4gIEp1c3Qg ZXhpdCB0aGUgZW52aXJvbm1lbnQgYW5kIGl0J3MgbGlrZSBpdCBuZXZlciBoYXBwZW5lZCBhdAor YWxsLgorCitJdCBoaWdobGlnaHRzIG9uZSBvZiBteSBmYXZvcml0ZSBhc3BlY3RzIG9mIEd1aXgs IGV2ZXJ5IHBhY2thZ2UgaXMgYQord29ya2luZyByZWZlcmVuY2UgZGVzaWduIGZvciB5b3UgdG8g bW9kaWZ5IGFuZCBsZWFybiBmcm9tLgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKLS0gCjIu MzkuMQoKCi0tPS09LT0KQ29udGVudC1UeXBlOiB0ZXh0L3BsYWluCkNvbnRlbnQtRGlzcG9zaXRp b246IGF0dGFjaG1lbnQ7IGZpbGVuYW1lPWN1c3RvbS1idWlsZC1zeXN0ZW1zLXdpdGgtZ3VpeC5v cmcKQ29udGVudC1EZXNjcmlwdGlvbjogYnVpbGQtc3lzdGVtcwoKIyt0aXRsZTogQ3VzdG9tIEJ1 aWxkIFN5c3RlbXMgd2l0aCBHdWl4CiMrYXV0aG9yOiBNaXRjaGVsbCBTY2htZWlzc2VyIDxtaXRj aGVsbHNjaG1laXNzZXJAbGlicmVtLm9uZT4KCkFsbCBjb2RlIGlzIGF2YWlsYWJsZSBbW2h0dHBz Oi8vZ2l0aHViLmNvbS9wYXBlcmNsaXA0NDY1L2d1aXgtemVwaHlyXVtoZXJlXV0uCgoqIE92ZXJ2 aWV3CgpCZWZvcmUgc29mdHdhcmUgY2FuIGJlIGRlcGxveWVkLCBpdCBuZWVkcyB0byBiZSBidWls dC4KSW4gR3VpeCBlYWNoIHBhY2thZ2UgbXVzdCBzcGVjaWZ5IGEgc28tY2FsbGVkIH5idWlsZC1z eXN0ZW1+IHdoaWNoCmtub3dzIGhvdyB0byBicmluZyBhIHBhY2thZ2UgZnJvbSBpdHMgaW5wdXRz IHRvIGRlcGxveW1lbnQuCkJ1aWxkIHN5c3RlbXMgYXJlIHJlc3BvbnNpYmxlIGZvciBzZXR0aW5n IHVwIHRoZSBlbnZpcm9ubWVudCBhbmQgcGVyZm9ybWluZwpidWlsZCBhY3Rpb25zIHdpdGggaW4g dGhhdCBlbnZpcm9ubWVudC4gVGhlIG1vc3QgdWJpcXVpdG91cyBvZiB0aGVzZSBpcyB0aGUKW1to dHRwczovL3d3dy5nbnUub3JnL3NvZnR3YXJlL2F1dG9tYWtlL21hbnVhbC9odG1sX25vZGUvR05V LUJ1aWxkLVN5c3RlbS5odG1sXVt+Z251LWJ1aWxkLXN5c3RlbX5dXS4gUGFja2FnZXMgdXNpbmcg dGhpcyBidWlsZCBzeXN0ZW0gYXJlIGJ1aWxkIHVzaW5nIHRoZSB1c3VhbAp+Li9jb25maWd1cmUg JiYgbWFrZSAmJiBtYWtlIGluc3RhbGx+IHByb2Nlc3MuCgpBbnkgcGFja2FnZSBjYW4gYWx0ZXIg aXRzIGJ1aWxkIHN5c3RlbSBieSByZW1vdmluZyBzb21lIHN0ZXBzIG9yCmFkZGluZyBleHRyYSBv bmVzLiBUaGlzIGlzIGV4dHJlbWVseSBjb21tb24gYW5kIGFsbW9zdCBldmVyeSBwYWNrYWdlCm1h a2VzIHNvbWUgYWRqdXN0bWVudCB0byB0aGUgYnVpbGQgcHJvY2Vzcy4gQSB+YnVpbGQtc3lzdGVt fiBpbiBHdWl4CmhpZGVzIGF3YXkgc29tZSBvZiB0aGUgY29tbW9uIGNvbmZpZ3VyYXRpb24gY2hv aWNlcy4gRm9yIGV4YW1wbGUgdGhlcmUgaXMKbm8gbmVlZCB0byBzcGVjaWZ5IH5tYWtlfiBvciB+ Z2NjfiBhcyBuYXRpdmUgaW5wdXRzIHdoZW4gdXNpbmcgdGhlIH5nbnUtYnVpbGQtc3lzdGVtfgpi ZWNhdXNlIHRoZXkgYXJlIGFkZGVkIGltcGxpY2l0bHkgd2hlbiBvdXIgcGFja2FnZSBpcyBnZXRz IGxvd2VyZWQgaW50byBhIC9iYWcvLgoKKiBBbmF0b215IG9mIGEgR3VpeCBCdWlsZCBTeXN0ZW0K ClRoZSBqb2Igb2YgYSBidWlsZCBzeXN0ZW0gaXMgdG8gY29tcGlsZSBvdXIgL3BhY2thZ2VzLyBp bnRvIC9iYWdzLy4KQmFncyBhcmUgYSBsb3dlciBsZXZlbCByZXByZXNlbnRhdGlvbiBvZiBhIHBh Y2thZ2Ugd2l0aG91dCBhbGwgdGhlIGJlbGxzIGFuZCB3aGlzdGxlc1tmbjoxXSwKdGhleSBhcmUg dGhlbiB1c2VkIGJ5IHRoZSBidWlsZCBkYWVtb24gdG8gY3JlYXRlIGFuIGlzb2xhdGVkIGVudmly b25tZW50IHN1aXRhYmxlIHRvCnJ1biBvdXIgL2J1aWxkIHBoYXNlcy8gaW4uCgpCZWxvdyBpcyBo b3cgZ3VpeCBkZWZpbmVzIGEgYnVpbGQgc3lzdGVtLgpJdCdzIHN1cnByaXNpbmdseSBzaW1wbGUg d2l0aCBqdXN0IHRocmVlIGl0ZW1zLCB0d28gb2Ygd2hpY2ggYXJlIGZvciBodW1hbiBjb25zdW1w dGlvbi4KCiMrQkVHSU5fU1JDIHNjaGVtZQogIChkZWZpbmUtcmVjb3JkLXR5cGUqIDxidWlsZC1z eXN0ZW0+IGJ1aWxkLXN5c3RlbSBtYWtlLWJ1aWxkLXN5c3RlbQogICAgYnVpbGQtc3lzdGVtPwog ICAgKG5hbWUgICAgICAgIGJ1aWxkLXN5c3RlbS1uYW1lKSAgICAgICAgIDsgc3ltYm9sCiAgICAo ZGVzY3JpcHRpb24gYnVpbGQtc3lzdGVtLWRlc2NyaXB0aW9uKSAgOyBzaG9ydCBkZXNjcmlwdGlv bgogICAgKGxvd2VyICAgICAgIGJ1aWxkLXN5c3RlbS1sb3dlcikpICAgICAgIDsgYXJncyAuLi4g LT4gYmFncwojK0VORF9TUkMKClRoZSBsYXN0IGZpZWxkIH5sb3dlcn4gaXMgYSBmdW5jdGlvbiB3 aGljaCB0YWtlcyB0aGUgbGlzdCBvZiBhcmd1bWVudHMKZ2l2ZW4gaW4gdGhlIH4ocGFja2FnZSAu Li4gKGFyZ3VtZW50cyAuLi4pKX4gZmllbGQuClRoZSBrZXl3b3JkIGFyZ3VtZW50cyB0aGF0IHdl IGFyZSBhbGxvd2VkIHRvIHN1cHBseSB3aGVuIHdyaXRpbmcgdGhlCnBhY2thZ2UuCgoqKiBDb2Rl IFN0cmF0YQoKR3VpeCBidWlsZHMgYXJlIGltcGxlbWVudGVkIGluIHR3byBwYXJ0cy4KCjEuIENv ZGUgdGhhdCBjb21waWxlcyA9cGFja2FnZXMtPmRlcml2YXRpb25zPS4KICAgRGVyaXZhdGlvbnMg YXJlIHRoZSBsYW5ndWFnZSB0aGUgR3VpeCBEYWVtb24gc3BlYWtzLgogICBUaGV5IGRlc2NyaWJl IGV2ZXJ5dGhpbmcgYWJvdXQgaG93IHRvIC9kZXJpdmUvIG91ciBwYWNrYWdlCiAgIGZyb20gdGhl IGlucHV0cyB0byB0aGUgZW52aXJvbm1lbnQgYW5kIGFsbCB0aGUgY29kZSBvbgogICBob3cgdG8g ZHJpdmUgdGhlIGJ1aWxkIHRvb2xzLgoKMi4gQ29kZSB0aGUgYnVpbGRlciBhY3R1YWxseSBydW5z IGluIHRoZSBpc29sYXRpb24gdG8gcHJvZHVjZSB0aGUgcGFja2FnZSBmcm9tIGl0J3MgaW5wdXRz LgogICBUaGUgY29kZSB3aGljaCBwcm9kdWNlcyB0aGUgYWJvdmUgZGVyaXZhdGlvbnMgaXMgcnVu IG9uIHRoZSBkaXJ0eSwKICAgdW5yZXByb2R1Y2libGUgdXNlciBlbnZpcm9ubWVudC4KCkNvZGUg dGhhdCBydW5zIGluIHRoZSBob3N0IGVudmlyb25tZW50IC9zdGFnZXMvIGNvZGUgd2hpY2ggd2ls bCBydW4gaW4gaXNvbGF0aW9uLgpUaGlzIGlzIHdoZXJlIEctRXhwcmVzc2lvbnMgcmVhbGx5IHNo aW5lLgpUaGV5IHByb3ZpZGUgdGhlIHN5bnRheCB0byBkZXNjcmliZSB0aGlzIHJlbGF0aW9uc2hp cC4KCioqIEJ1aWxkIFBoYXNlcwoKQWxsIHByb2dyYW1zIGFyZSBidWlsdCBtb3JlIG9yIGxlc3Mg dGhlIHNhbWUgd2F5LgoKMS4gVW5wYWNrIHRoZSBzb3VyY2UgY29kZS4KICAgV2hldGhlciBpdCdz IHRhcmJhbGwgb3IgYSB2ZXJzaW9uIGNvbnRyb2xsZWQgcmVwb3NpdG9yeSB3ZSBtdXN0CiAgIGNv cHkgaXQncyBzb3VyY2UgdHJlZSBpbnRvIG91ciBidWlsZCBlbnZpcm9ubWVudC4KMi4gUGF0Y2gg dGhlIHNoZWJhbmdzLgogICBNYW55IHByb2plY3RzIGNvbnRhaW4gc2NyaXB0cyB3cml0dGVuIHRv IGFpZCB0aGUgYnVpbGQgcHJvY2Vzcy4KICAgSW4gbGludXggZXhlY3V0YWJsZSBzY3JpcHRzIGNh biBjb250YWluIGEgc28tY2FsbGVkIC9zaGViYW5nLwogICB3aGljaCBjb250YWlucyBhbiBhYnNv bHV0ZSBwYXRoIHRvIHRoZSBwcm9ncmFtIHdoaWNoIGlzIG1lYW50IHRvCiAgIGludGVycHJldCBp dC4gRS5nLiB+IyEvYmluL3Nofi4gTW9zdCBkaXN0cm9idXRpb25zIHByb3ZpZGUgYQogICBQT1NJ WCBjb21wbGlhbnQgc2hlbGwgaW50ZXJwcmV0ZXIgYXQgdGhpcyBsb2NhdGlvbi4gTm90IG9uIG91 cnMuCiAgIE91ciB+c2h+IGlzIHlldCBhbm90aGVyIGNvbXBvbmVudCBpbiB0aGUgc3RvcmUgc28g YWxsIG9mIHRoZXNlIGZpbGVzIG11c3QKICAgYmUgcGF0Y2hlZCB0byBwb2ludCB0byB0aGUgbmV3 IGxvY2F0aW9uIHdoaWNoIGlzIG9ubHkga25vd24gYXQKICAgYnVpbGQgdGltZS4gIFdlIGNhbm5v dCByZWx5IG9uIG91ciA9UEFUSD0gdG8gc3RvcmUgdGhpcyBpbmZvcm1hdGlvbgogICBiZWNhdXNl IHRoZSBrZXJuZWwgZG9lcyBub3QgcmVzcGVjdCBzdWNoIHRoaW5ncy4KMy4gQ29uZmlndXJlIHRo ZSBidWlsZC4KICAgV2hldGhlciBpdCdzIHRoZSBhdXRvdG9vbHMgb3IgQ01ha2Ugb3Igd2hhdGV2 ZXIsIGlmIHlvdSdyZSByZWx5aW5nCiAgIG9uIHRvb2xzIGZyb20gdGhlIGhvc3Qgc3lzdGVtLCB5 b3UgaGF2ZSBhIHN0ZXAgd2hpY2ggZW5hYmxlcyB0aGUKICAgaG9zdCBzeXN0ZW0gdG8gdGVsbCB5 b3Ugd2hlcmUgdG8gZmluZCB0aG9zZSB0b29scy4KNC4gUGF0Y2ggdGhlIGdlbmVyYXRlZCBzaGVi YW5ncy4KICAgU29tZXRpbWVzIHRoZSBjb25maWd1cmUgcGhhc2VzIGNyZWF0ZXMgc2NyaXB0cyB3 aGljaCBydW4gZHVyaW5nIHRoZSBidWlsZCBwaGFzZSwKICAgdGhlc2Ugb2Z0ZW4gY29udGFpbiBy ZWZlcmVuY2VzIHRvID0vYmluL3NoPSBhbmQgc28gbXVzdCBiZSBwYXRjaGVkIGFzIHdlbGwuCjUu IEJ1aWxkIQogICBUaGF0J3MgcmlnaHQgZm9sa3Mgd2UgYXJlIG9mZiB0byB0aGUgcmFjZXMgYW5k IHRoZSBwcm9ncmFtIGlzIGJ1aWxkaW5nLgogICBVc3VhbGx5IHRoaXMgdGFrZXMgdGhlIGZvcm0g b2YgYSBjYWxsIHRvIH5tYWtlfiB3aXRoIGEgaGFuZGZ1bCBvZgogICBmbGFncyBhbmQgbGFzdCBt aW51dGUgZGVmaW5pdGlvbnMsIGJ1dCB0aGVyZSBhcmUgb3RoZXIgbW9yZSAvZXhvdGljL1tmbjo1 XSBtZXRob2RzLgo2LiBUZXN0LgogICBOb3cgdGhhdCB3ZSBoYXZlIG91ciBzb2Z0d2FyZSBidWls dCB3ZSBzaG91bGQgdGVzdCBpdC4KICAgTm90IGFsbCBwYWNrYWdlcyBoYXZlIHRlc3RzIGJ1dCB3 aGF0IGNhbiBkbyB5b3U/CjguIEluc3RhbGwuCiAgIE5vdyB0aGF0IHdlJ3ZlIHZlcmlmaWVkIGV2 ZXJ5dGhpbmcgd29ya3MgYXMgZXhwZWN0ZWQgaXQncyB0aW1lIHRvIHJ1bgogICB+bWFrZSBpbnN0 YWxsfiBvciBlcXVpdmFsZW50LiBUaGlzIHBoYXNlIGNvcGllcyBvdXIgYnVpbGQgYXJ0aWZhY3Rz IGludG8KICAgdGhlaXIgZmluYWwgcmVzdGluZyBwbGFjZSBpbiB0aGUgc3RvcmUuCjcuIFZhbGlk YXRlIHRoZSBJbnN0YWxsYXRpb24uCiAgIEhlcmUgd2UgY2FuIG91ciBvdXRwdXRzIGFuZCBtYWtl IHN1cmUgdGhleSBkb24ndCBjb250YWluIGFueSBjb21wb25lbnQKICAgcGF0aHMgd2hpY2ggYXJl IG5vdCBzcGVjaWZpZWQgYnkgdGhlIHBhY2thZ2UgaW5wdXRzLiBUaGF0IHdvdWxkIGxlYWQKICAg dG8gaW5jb21wbGV0ZSBkZXBsb3ltZW50IGFuZCB3b3VsZCBiZSAiYmFkIi4KClRoZXJlIGFyZSBt b3JlIHN0ZXBzIGJ1dCB0aGV5IGFyZSBub3QgdW5pdmVyc2FsbHkgYXBwbGljYWJsZS4KT2YgY291 cnNlIG5vIGdlbmVyaWMgbW9kZWwgc3VjaCBhcyB0aGlzIGNhcHR1cmVzIGFsbCB0aGUgY2hhb3Mg b2YgdGhlCndvcmxkIGFuZCBldmVyeSBwYWNrYWdlIGhhcyBleGNlcHRpb25zIHRvIGl0LgoKR3Vp eCBpbXBsZW1lbnRzIC9idWlsZCBwaGFzZXMvIGFzIGEgbGlzdCBvZiBsYW1iZGFzLgpBcyBzdWNo IG91ciBwYWNrYWdlIGNhbiBtb2RpZnkgdGhpcyBsaXN0IGFuZCBhZGQvZGVsZXRlL3JlcGxhY2UK bGFtYmRhcyBhcyB0aGV5IHJlcXVpcmUuIEl0IGlzIHNvIGNvbW1vbiBHdWl4IHByb3ZpZGVzIGEg c3ludGF4CmZvciBtYW5pcHVsYXRpbmcgYnVpbGQgcGhhc2VzLCB+bW9kaWZ5LXBoYXNlc34uCgpB IGJ1aWxkIHN5c3RlbSBjb250YWlucyBhIGRlZmF1bHQgc2V0IG9mIHBoYXNlcyBjYWxsZWQgfiVz dGFuZGFyZC1waGFzZXN+LgpFdmVyeSBidWlsZCBzeXN0ZW0gc3RhcnRzIHdpdGggdGhlIH5nbnUt YnVpbGQtc3lzdGVtfiB+JXN0YW5kYXJkLXBoYXNlc34KYW5kIG1vZGlmaWVzIGl0IHRvIHRoZWly IG5lZWRzLiBJdCBpcyB0aGVuIHByb3ZpZGVkIHRvIHRoZSBhcHBsaWNhdGlvbnMKdXNpbmcgdGhh dCBidWlsZCBzeXN0ZW0uCgpUaGUgfmNtYWtlLWJ1aWxkLXN5c3RlbX4gaXMgbmVhcmx5IGlkZW50 aWNhbCB0byB0aGUgfmdudS1idWlsZC1zeXN0ZW1+CmV4Y2VwdCB0d28gcGhhc2VzLgoKIytCRUdJ Tl9TUkMgc2NoZW1lCiAgOzsKICA7OyBFeGNlcnB0IGZyb20gYGd1aXgvYnVpbGQvY21ha2UtYnVp bGQtc3lzdGVtLnNjbWAKICA7OwogIChkZWZpbmUgJXN0YW5kYXJkLXBoYXNlcwogICAgOzsgRXZl cnl0aGluZyBpcyBhcyB3aXRoIHRoZSBHTlUgQnVpbGQgU3lzdGVtIGV4Y2VwdCBmb3IgdGhlIGBj b25maWd1cmUnCiAgICA7OyBhbmQgJ2NoZWNrJyBwaGFzZXMuCiAgICAobW9kaWZ5LXBoYXNlcyBn bnU6JXN0YW5kYXJkLXBoYXNlcwogICAgICAoZGVsZXRlICdib290c3RyYXApCiAgICAgIChyZXBs YWNlICdjaGVjayBjaGVjaykKICAgICAgKHJlcGxhY2UgJ2NvbmZpZ3VyZSBjb25maWd1cmUpKSkK IytFTkRfU1JDCgoqIFRoZSBaZXBoeXIgQnVpbGQgU3lzdGVtCgpaZXBoeXIgdXNlcyB+Y21ha2V+ IHRvIHBlcmZvcm0gL3BoeXNpY2FsIGNvbXBvbmVudCBjb21wb3NpdGlvbi8uCkl0IHNlYXJjaGVz IHRoZSBmaWxlc3lzdGVtIGFuZCBnZW5lcmF0ZXMgc2NyaXB0cyB3aGljaCB0aGUgdG9vbGNoYWlu IHdpbGwKdXNlIHRvIHN1Y2Nlc3NmdWxseSBjb21iaW5lIHRob3NlIGNvbXBvbmVudHMgaW50byBh IGZpcm13YXJlIGltYWdlLgoKVGhlIGZhY3QgdGhhdCBaZXBoeXIgcHJvdmlkZXMgdGhpcyBtZWNo YW5pc20gaXMgb25lIHJlYXNvbiBJIGNob3NlIHRvCnRhcmdldCB6ZXBoeXIgaW4gdGhlIGZpcnN0 IHBsYWNlLgoKVGhpcyBzZXBhcmF0aW9uIG9mIHByb2plY3RzIGluIGFuIGVtYmVkZGVkIGNvbnRl eHQgaXMgYSByZWFsbHkgZ3JlYXQgdGhpbmcuCkl0IGJyaW5ncyBtYW55IG9mIHRoZSBhZHZhbnRh Z2VzIHRoYXQgaXQgYnJpbmdzIHRvIHRoZSBMaW51eCB3b3JsZCBzdWNoIGFzCmNvZGUgcmUtdXNl LCBzbWFsbGVyIGJpbmFyaWVzLCBtb3JlIGVmZmljaWVudCBjYWNoZS9SQU0gdXNhZ2UsIGV0Yy4K SXQgYWxzbyBhbGxvd3MgdXMgdG8gd29yayBhcyBpbmRlcGVuZGVudCBncm91cHMgYW5kIGNvbXBv c2UKY29udHJpYnV0aW9ucyBmcm9tIG1hbnkgdGVhbXMuCgpJdCBhbHNvIGJyaW5ncyBhbGwgb2Yg dGhlIGNvbXBsZXhpdHkuIFN1ZGRlbmx5IGFsbCBvZiB0aGUgcHJvYmxlbXMKdGhhdCBwbGFndWUg dHJhZGl0aW9uYWwgZGVwbG95bWVudCBub3cgYXBwbHkgdG8gb3VyIGVtYmVkZGVkCnN5c3RlbS4g VGhlIGZhY3QgdGhhdCB0aGUgbGlicmFyaWVzIGFyZSBzdGF0aWNhbGx5IGxpbmtlZCBhdCBjb21w aWxlCnRpbWUgaW5zdGVhZCBvZiBkeW5hbWljYWxseSBhdCBydW50aW1lIGlzIHNpbXBseSBhbiBp bXBsZW1lbnRhdGlvbiBkZXRhaWwuCgpXZSBub3cgaGF2ZSBkZXBlbmRlbmNpZXMgd2hpY2ggd2Ug bXVzdCB0cmFjayBhbmQgY29tcG9zZSBpbiB0aGUgY29ycmVjdCBlbnZpcm9ubWVudHMuClRoZSBa ZXBoeXIgUHJvamVjdCBvZmZlcnMgYSB0b29sIHRvIGhlbHAgbWFuYWdlIHRoaXMgbmV3IGNvbXBs ZXhpdHksIFtbaHR0cHM6Ly9kb2NzLnplcGh5cnByb2plY3Qub3JnL2xhdGVzdC9kZXZlbG9wL3dl c3QvaW5kZXguaHRtbF1bVGhlIFdlc3QgTWV0YS10b29sXV0hClRvIGNhbGwgaXQgYSAibWV0YS10 b29sIiBpcyBhbiBhYnVzZSBvZiBsYW5ndWFnZS4gIEl0J3Mgbm90IGV2ZW4gbWV0YQplbm91Z2gg dG8gYm9vdHN0cmFwIGl0c2VsZiBhbmQgcmVsaWVzIG9uIFtbaHR0cHM6Ly9kb2NzLnplcGh5cnBy b2plY3Qub3JnL2xhdGVzdC9kZXZlbG9wL2dldHRpbmdfc3RhcnRlZC9pbmRleC5odG1sXVtvdGhl ciBwYWNrYWdlIG1hbmFnZXJzXV0gdG8gZ2V0CnN0YXJ0ZWQuCkluIGZhY3QsIGl0IGlzbid0IGV2 ZW4gc3VpdGFibGUgZm9yIG1hbmFnaW5nIG11bHRpcGxlIGVtYmVkZGVkIHByb2plY3RzIGFzIGEg Y29tcG9zaXRpb24hClRoZSBwcm9qZWN0IHJlY29tbWVuZHMgW1todHRwczovL2RvY3MuemVwaHly cHJvamVjdC5vcmcvbGF0ZXN0L2J1aWxkL3N5c2J1aWxkL2luZGV4Lmh0bWxdW1lldCBBbm90aGVy IFRvb2xdXSBmb3IgdGhpcyB2ZXJ5IGNvbW1vbiB1c2UgY2FzZS4KCkluIGZhY3Qgfndlc3R+IGRv ZXMgbm90IHJlYWxseSBicmluZyBhbnl0aGluZyBuZXcgdG8gdGhlIHRhYmxlIGFuZCB3ZQpjYW4g cmVwbGFjZSBpdCBpbiB0aGUgc2FtZSB3YXkgd2UgY2FuIHJlcGxhY2UgZXZlcnkgb3RoZXIgcGFj a2FnZQptYW5hZ2VyLltmbjo0XSAqUFVUVElORyBTT0ZUV0FSRSBPTiBUSEUgU1lTVEVNIElTIFRI RSBKT0IgT0YgVEhFKDEpClBBQ0tBR0UgTUFOQUdFUiEqLgoKTGV0J3Mgc2VlIHdoYXQgaXQgdGFr ZXMgdG8gYWN0dWFsbHkgcHJvdmlkZSBhIG1ldGEtdG9vbCBhbmQgYm9vdHN0cmFwCnRoZXNlIGNv bXBsZXggZW1iZWRkZWQgc3lzdGVtcyBmcm9tIHRoZSBncm91bmQgdXAgaW4gYSBmbGV4aWJsZSwg Y29tcG9zYWJsZSwKYW5kIC9yZXByb2R1Y2libGUvIHdheS4KCioqIFdoeSBub3QgdXNlIH5jbWFr ZS1idWlsZC1zeXN0ZW1+PwoKQSBmYWlyIHF1ZXN0aW9uISBaZXBoeXIncyBDTWFrZSBzY3JpcHRz IHJlcXVpcmUgYWRkaXRpb25hbCBpbmZvcm1hdGlvbgphYm91dCB0aGUgYnVpbGQgdG8gYmUgcHJv dmlkZWQgYXQgY29uZmlndXJlIHRpbWUuIE1vc3QgdGVkaXVzIGZvcgp6ZXBoeXItcGFja2FnZXMg aXMgdGhlID1aRVBIWVJfTU9EVUxFUz0gdmFyaWFibGUgd2hpY2ggbXVzdCBiZSBmb3JtYXR0ZWQg YW5kCnBhc3NlZCB0byBDTWFrZSBvbiB0aGUgY29tbWFuZCBsaW5lW2ZuOjZdCgoqKiBIb3N0IFNp ZGUKCk91ciBqb2IgYXQgdGhpcyBsZXZlbCBpcyB0byB0YWtlIHBhY2thZ2VzIGRlc2NyaWJlZCB1 c2luZyB0aGUgfnBhY2thZ2V+IHN5bnRheCBhbmQKbG93ZXIgaXQgaW50byBhIGRlcml2YXRpb24g dGhhdCB0aGUgZGFlbW9uIGNhbiB1bmRlcnN0YW5kLgoKSGVyZSBpcyB0aGUgZGVyaXZhdGlvbiBm b3IgYnVpbGRpbmcgaGVsbG8gd29ybGQgZm9yIHRoZSA9ZnJkbV9rNjRmPSwgaGFzaGVzIHJlbW92 ZWQgZm9yIGJyZXZpdHkuClRoZSB+cGFja2FnZX4gc3ludGF4IHByb3ZpZGVzIGEgaHVtYW4gZnJp ZW5kbHkgdmVuZWVyIG92ZXIgdGhpcyBnYXJiYWdlLgoKIytCRUdJTl9TUkMKRGVyaXZlCihbKCJk ZWJ1ZyIsIi9nbnUvc3RvcmUvLi4uLXplcGh5ci1oZWxsby13b3JsZC1uZXdsaWItZnJkbS1rNjRm LTMuMS4wLTAuemVwaHlyLS1kZWJ1ZyIsIiIsIiIpCiAgLCgib3V0IiwiL2dudS9zdG9yZS8uLi4t emVwaHlyLWhlbGxvLXdvcmxkLW5ld2xpYi1mcmRtLWs2NGYtMy4xLjAtMC56ZXBoeXItIiwiIiwi IildCiAsWygiL2dudS9zdG9yZS8uLi4tbmV3bGliLW5hbm8tMy4zLmRydiIsWyJvdXQiXSkKICAg LCgiL2dudS9zdG9yZS8uLi4taGFsLW54cC0zLjEuMC0wLjcwOGM5NTguZHJ2IixbIm91dCJdKQog ICAsKCIvZ251L3N0b3JlLy4uLi1tYWtlLTQuMy5kcnYiLFsib3V0Il0pCiAgICwoIi9nbnUvc3Rv cmUvLi4uLWZpbmR1dGlscy00LjguMC5kcnYiLFsib3V0Il0pCiAgICwoIi9nbnUvc3RvcmUvLi4u LWdyZXAtMy42LmRydiIsWyJvdXQiXSkKICAgLCgiL2dudS9zdG9yZS8uLi4tc2VkLTQuOC5kcnYi LFsib3V0Il0pCiAgICwoIi9nbnUvc3RvcmUvLi4uLWxkLXdyYXBwZXItMC5kcnYiLFsib3V0Il0p CiAgICwoIi9nbnUvc3RvcmUvLi4uLWJhc2gtbWluaW1hbC01LjEuOC5kcnYiLFsib3V0Il0pCiAg ICwoIi9nbnUvc3RvcmUvLi4uLWhhbC1jbXNpcy01LjguMC0wLjA5M2RlNjEuZHJ2IixbIm91dCJd KQogICAsKCIvZ251L3N0b3JlLy4uLi1nYXdrLTUuMS4wLmRydiIsWyJvdXQiXSkKICAgLCgiL2du dS9zdG9yZS8uLi4tZ3ppcC0xLjEwLmRydiIsWyJvdXQiXSkKICAgLCgiL2dudS9zdG9yZS8uLi4t cHl0aG9uLXNpeC0xLjE2LjAuZHJ2IixbIm91dCJdKQogICAsKCIvZ251L3N0b3JlLy4uLi16ZXBo eXItMy4xLjAtMC56ZXBoeXItLWNoZWNrb3V0LmRydiIsWyJvdXQiXSkKICAgLCgiL2dudS9zdG9y ZS8uLi4tbGludXgtbGlicmUtaGVhZGVycy01LjEwLjM1LmRydiIsWyJvdXQiXSkKICAgLCgiL2du dS9zdG9yZS8uLi4tcHl0aG9uLTMuOS45LmRydiIsWyJvdXQiXSkKICAgLCgiL2dudS9zdG9yZS8u Li4tZGlmZnV0aWxzLTMuOC5kcnYiLFsib3V0Il0pCiAgICwoIi9nbnUvc3RvcmUvLi4uLWFybS16 ZXBoeXItZWFiaS1uYW5vLXRvb2xjaGFpbi0xMi4xLjAuZHJ2IixbIm91dCJdKQogICAsKCIvZ251 L3N0b3JlLy4uLi1weXRob24tcHllbGZ0b29scy0wLjI4LmRydiIsWyJvdXQiXSkKICAgLCgiL2du dS9zdG9yZS8uLi4tZ3VpbGUtMy4wLjcuZHJ2IixbIm91dCJdKQogICAsKCIvZ251L3N0b3JlLy4u Li1weXRob24tZGF0ZXV0aWwtMi44LjIuZHJ2IixbIm91dCJdKQogICAsKCIvZ251L3N0b3JlLy4u Li1wYXRjaC0yLjcuNi5kcnYiLFsib3V0Il0pCiAgICwoIi9nbnUvc3RvcmUvLi4uLWdjYy0xMC4z LjAuZHJ2IixbIm91dCJdKQogICAsKCIvZ251L3N0b3JlLy4uLi1iemlwMi0xLjAuOC5kcnYiLFsi b3V0Il0pCiAgICwoIi9nbnUvc3RvcmUvLi4uLWR0Yy0xLjYuMS5kcnYiLFsib3V0Il0pCiAgICwo Ii9nbnUvc3RvcmUvLi4uLWdjYy1jcm9zcy1zYW5zLWxpYmMtYXJtLXplcGh5ci1lYWJpLTEyLjEu MC5kcnYiLFsib3V0Il0pCiAgICwoIi9nbnUvc3RvcmUvLi4uLWNtYWtlLW1pbmltYWwtMy4yMS40 LmRydiIsWyJvdXQiXSkKICAgLCgiL2dudS9zdG9yZS8uLi4tcHl0aG9uLXB5eWFtbC02LjAuZHJ2 IixbIm91dCJdKQogICAsKCIvZ251L3N0b3JlLy4uLi1weXRob24tcGFja2FnaW5nLTIxLjMuZHJ2 IixbIm91dCJdKQogICAsKCIvZ251L3N0b3JlLy4uLi1hcm0temVwaHlyLWVhYmktYmludXRpbHMt Mi4zOC5kcnYiLFsib3V0Il0pCiAgICwoIi9nbnUvc3RvcmUvLi4uLWdsaWJjLTIuMzMuZHJ2Iixb Im91dCIsInN0YXRpYyJdKQogICAsKCIvZ251L3N0b3JlLy4uLi1xZW11LTcuMi4wLmRydiIsWyJv dXQiXSkKICAgLCgiL2dudS9zdG9yZS8uLi4tbmluamEtMS4xMC4yLmRydiIsWyJvdXQiXSkKICAg LCgiL2dudS9zdG9yZS8uLi4tdGFyLTEuMzQuZHJ2IixbIm91dCJdKQogICAsKCIvZ251L3N0b3Jl Ly4uLi14ei01LjIuNS5kcnYiLFsib3V0Il0pCiAgICwoIi9nbnUvc3RvcmUvLi4uLWJpbnV0aWxz LTIuMzcuZHJ2IixbIm91dCJdKQogICAsKCIvZ251L3N0b3JlLy4uLi1weXRob24tcHlrd2FsaWZ5 LTEuNy4wLmRydiIsWyJvdXQiXSkKICAgLCgiL2dudS9zdG9yZS8uLi4temVwaHlyLTMuMS4wLTAu emVwaHlyLS5kcnYiLFsib3V0Il0pCiAgICwoIi9nbnUvc3RvcmUvLi4uLWdsaWJjLXV0ZjgtbG9j YWxlcy0yLjMzLmRydiIsWyJvdXQiXSkKICAgLCgiL2dudS9zdG9yZS8uLi4tZ2RiLWFybS16ZXBo eXItZWFiaS0xMi4xLmRydiIsWyJvdXQiXSkKICAgLCgiL2dudS9zdG9yZS8uLi4tbW9kdWxlLWlt cG9ydC1jb21waWxlZC5kcnYiLFsib3V0Il0pCiAgICwoIi9nbnUvc3RvcmUvLi4uLWZpbGUtNS4z OS5kcnYiLFsib3V0Il0pCiAgICwoIi9nbnUvc3RvcmUvLi4uLXB5dGhvbi1weXBhcnNpbmctMy4w LjYuZHJ2IixbIm91dCJdKQogICAsKCIvZ251L3N0b3JlLy4uLi1weXRob24tZG9jb3B0LTAuNi4y LmRydiIsWyJvdXQiXSkKICAgLCgiL2dudS9zdG9yZS8uLi4tYXJtLXplcGh5ci1lYWJpLXNkay0w LjE1LjAuZHJ2IixbIm91dCJdKQogICAsKCIvZ251L3N0b3JlLy4uLi1jb3JldXRpbHMtOC4zMi5k cnYiLFsib3V0Il0pXQogLFsiL2dudS9zdG9yZS8uLi4temVwaHlyLWhlbGxvLXdvcmxkLW5ld2xp Yi1mcmRtLWs2NGYtMy4xLjAtMC56ZXBoeXItLWJ1aWxkZXIiLCIvZ251L3N0b3JlLy4uLi1tb2R1 bGUtaW1wb3J0Il0KICwieDg2XzY0LWxpbnV4IiwiL2dudS9zdG9yZS8uLi4tZ3VpbGUtMy4wLjcv YmluL2d1aWxlIixbIi0tbm8tYXV0by1jb21waWxlIgogLCItTCIsIi9nbnUvc3RvcmUvLi4uLW1v ZHVsZS1pbXBvcnQiCiAsIi1DIiwiL2dudS9zdG9yZS8uLi4tbW9kdWxlLWltcG9ydC1jb21waWxl ZCIKICwiL2dudS9zdG9yZS8uLi4temVwaHlyLWhlbGxvLXdvcmxkLW5ld2xpYi1mcmRtLWs2NGYt My4xLjAtMC56ZXBoeXItLWJ1aWxkZXIiXQogLFsoImRlYnVnIiwiL2dudS9zdG9yZS8uLi4temVw aHlyLWhlbGxvLXdvcmxkLW5ld2xpYi1mcmRtLWs2NGYtMy4xLjAtMC56ZXBoeXItLWRlYnVnIikK ICAgLCgib3V0IiwiL2dudS9zdG9yZS8uLi4temVwaHlyLWhlbGxvLXdvcmxkLW5ld2xpYi1mcmRt LWs2NGYtMy4xLjAtMC56ZXBoeXItIildKQojK0VORF9TUkMKCioqKiBMb3dlcmluZyBwYWNrYWdl cyB0byBiYWdzCgpXZSBtdXN0IHByb3ZpZGUgdGhlIGJ1aWxkIHN5c3RlbSB3aXRoIGEgZnVuY3Rp b24gd2hpY2ggdGhlIGZvbGxvd2luZyBsYW1iZGEgZm9ybS4KCiMrQkVHSU5fU1JDIHNjaGVtZQog IChsYW1iZGEqIChuYW1lICM6a2V5ICM6YWxsb3ctb3RoZXIta2V5cykgLi4uKQojK0VORF9TUkMK ClRoaXMgbWVhbnMgaXQgdGFrZXMgb25lIHJlcXVpcmVkIGFyZ3VtZW50IH5uYW1lfiBhbmQgYW55 IGFtb3VudCBvZiBrZXlzLgpJbmRpdmlkdWFsIHByb2NlZHVyZXMgY2FuIHNwZWNpZnkga2V5cyB0 aGV5IGFyZSBpbnRlcmVzdGVkIGluIHN1Y2ggYXMKfmlucHV0c34gb3Igfm91dHB1dHN+LgoKV2hp Y2gga2V5cyBhcmUgdWx0aW1hdGVseSBzdXBwb3J0ZWQgaXMgZGVmaW5lZCBieSBvdXIgfmxvd2Vy fiBmdW5jdGlvbgphbmQgb3VyIC9idWlsZCBwaGFzZXMvLgoKIytCRUdJTl9TUkMgc2NoZW1lCiAg OzsgVXNlIG1vZHVsZS1yZWYgaW5zdGVhZCBvZiByZWZlcmVuY2luZyB0aGUgdmFyaWFibGVzIGRp cmVjdGx5CiAgOzsgdG8gYXZvaWQgY2lyY3VsYXIgZGVwZW5kZW5jaWVzLgogIChkZWZpbmUgJXpl cGh5ci1idWlsZC1zeXN0ZW0tbW9kdWxlcwogICAgYCgobWZzIGJ1aWxkIHplcGh5ci1idWlsZC1z eXN0ZW0pCiAgICAgICxAJWNtYWtlLWJ1aWxkLXN5c3RlbS1tb2R1bGVzKSkKCiAgKGRlZmluZSBk ZWZhdWx0LXplcGh5ci1iYXNlCiAgICAobW9kdWxlLXJlZiAocmVzb2x2ZS1pbnRlcmZhY2UgJyht ZnMgcGFja2FnZXMgemVwaHlyKSkKCQknemVwaHlyKSkKCiAgKGRlZmluZSBkZWZhdWx0LXplcGh5 ci1zZGsKICAgIChtb2R1bGUtcmVmIChyZXNvbHZlLWludGVyZmFjZSAnKG1mcyBwYWNrYWdlcyB6 ZXBoeXIpKQoJCSdhcm0temVwaHlyLWVhYmktc2RrKSkKCiAgKGRlZmluZSBkZWZhdWx0LW5pbmph CiAgICAobW9kdWxlLXJlZiAocmVzb2x2ZS1pbnRlcmZhY2UgJyhnbnUgcGFja2FnZXMgbmluamEp KQoJCSduaW5qYSkpCgogIChkZWZpbmUgZGVmYXVsdC1jbWFrZQogICAgKG1vZHVsZS1yZWYgKHJl c29sdmUtaW50ZXJmYWNlICcoZ251IHBhY2thZ2VzIGNtYWtlKSkKCQknY21ha2UtbWluaW1hbCkp CgoKICAoZGVmaW5lKiAobG93ZXIgbmFtZQoJCSAgIzprZXkgc291cmNlIGlucHV0cyBuYXRpdmUt aW5wdXRzIG91dHB1dHMgc3lzdGVtIHRhcmdldAoJCSAgKHplcGh5ciBkZWZhdWx0LXplcGh5ci1i YXNlKQoJCSAgKHNkayBkZWZhdWx0LXplcGh5ci1zZGspCgkJICAobmluamEgZGVmYXVsdC1uaW5q YSkKCQkgIChjbWFrZSBkZWZhdWx0LWNtYWtlKQoJCSAgIzphbGxvdy1vdGhlci1rZXlzCgkJICAj OnJlc3QgYXJndW1lbnRzKQogICAgIlJldHVybiBhIGJhZyBmb3IgTkFNRS4iCiAgICAoZGVmaW5l IHByaXZhdGUta2V5d29yZHMgYCgjOnplcGh5ciAjOmlucHV0cyAjOm5hdGl2ZS1pbnB1dHMgIzp0 YXJnZXQpKQogICAgKGJhZwogICAgICAobmFtZSBuYW1lKQogICAgICAoc3lzdGVtIHN5c3RlbSkK ICAgICAgKHRhcmdldCB0YXJnZXQpCiAgICAgIChidWlsZC1pbnB1dHMgYCgsQChpZiBzb3VyY2Ug YCgoInNvdXJjZSIgLHNvdXJjZSkpICcoKSkKCQkgICAgICAsQGAoKCJjbWFrZSIgLGNtYWtlKSkK CQkgICAgICAsQGAoKCJ6ZXBoeXItc2RrIiAsc2RrKSkKCQkgICAgICAsQGAoKCJ6ZXBoeXIiICx6 ZXBoeXIpKQoJCSAgICAgICxAYCgoIm5pbmphIiAsbmluamEpKQoJCSAgICAgICxAbmF0aXZlLWlu cHV0cwoJCSAgICAgICxAKHN0YW5kYXJkLXBhY2thZ2VzKSkpCiAgICAgIDs7IElucHV0cyBuZWVk IHRvIGJlIGF2YWlsYWJsZSBhdCBidWlsZCB0aW1lCiAgICAgIDs7IHNpbmNlIGV2ZXJ5dGhpbmcg aXMgc3RhdGljYWxseSBsaW5rZWQuCiAgICAgIChob3N0LWlucHV0cyBpbnB1dHMpCiAgICAgIChv dXRwdXRzIG91dHB1dHMpCiAgICAgIChidWlsZCB6ZXBoeXItYnVpbGQpCiAgICAgIChhcmd1bWVu dHMgKHN0cmlwLWtleXdvcmQtYXJndW1lbnRzIHByaXZhdGUta2V5d29yZHMgYXJndW1lbnRzKSkp KQojK0VORF9TUkMKCkhlcmUgb3VyIH5sb3dlcn4gZnVuY3Rpb24gcHJvdmlkZXMgZGVmYXVsdCB2 YWx1ZXMgZm9yIHRoZSBwYWNrYWdlcwpldmVyeSB6ZXBoeXIgcGFja2FnZSBuZWVkcywgdGhlIFNE SywgY21ha2UsIGFuZCB6ZXBoeXItYmFzZSBhbmQgYWRkcwp0aGVtIHRvIHRoZSBidWlsZC1pbnB1 dHMuCgpOb3RpY2Ugd2UgYWxzbyBzdHJpcCBvdXQgc29tZSBrZXl3b3JkcyB3aGljaCBkbyBub3Qg Z2V0IHBhc3NlZCB0byB0aGUKYnVpbGQgZnVuY3Rpb24gYmVjYXVzZSB0aGV5IGdldCBpbmNsdWRl ZCBhcyBwYXJ0IG9mIHRoZSBicm9hZGVyCmFic3RyYWN0aW9ucyB0aGUgYnVpbGQgc3lzdGVtIHBy b3ZpZGVzLgoKKioqIExvd2VyaW5nIEJhZ3MgdG8gRGVyaXZhdGlvbnMKCkhlcmUgaXMgdGhlIGRl ZmluaXRpb24gZm9yIHRoZSBhY3R1YWwgYnVpbGQgcHJvY2VkdXJlLiBUaGVyZSBpcyBhIGxvdApv ZiBhYnN0cmFjdCBmdWNrZXJ5IGdvaW5nIG9uIGhlcmUgc28gZG8gbm90IHdvcnJ5IGlmIHlvdSBk b24ndCB1bmRlcnN0YW5kIGl0LgoKIytCRUdJTl9TUkMgc2NoZW1lCiAgKGRlZmluZSogKHplcGh5 ci1idWlsZCBuYW1lIGlucHV0cwoJCQkgIzprZXkgZ3VpbGUgc291cmNlCgkJCSBib2FyZAoJCQkg KG91dHB1dHMgJygib3V0IikpIChjb25maWd1cmUtZmxhZ3MgJycoKSkKCQkJIChzZWFyY2gtcGF0 aHMgJygpKQoJCQkgKG1ha2UtZmxhZ3MgJycoKSkKCQkJIChvdXQtb2Ytc291cmNlPyAjdCkKCQkJ ICh0ZXN0cz8gI2YpCgkJCSAodGVzdC10YXJnZXQgInRlc3QiKQoJCQkgKHBhcmFsbGVsLWJ1aWxk PyAjdCkgKHBhcmFsbGVsLXRlc3RzPyAjdCkKCQkJICh2YWxpZGF0ZS1ydW5wYXRoPyAjZikKCQkJ IChwYXRjaC1zaGViYW5ncz8gI3QpCgkJCSAocGhhc2VzICclc3RhbmRhcmQtcGhhc2VzKQoJCQkg KHN5c3RlbSAoJWN1cnJlbnQtc3lzdGVtKSkKCQkJIChzdWJzdGl0dXRhYmxlPyAjdCkKCQkJIChp bXBvcnRlZC1tb2R1bGVzICV6ZXBoeXItYnVpbGQtc3lzdGVtLW1vZHVsZXMpCgoJCQkgOzsgVGhl IG1vZHVsZXMgcmVmZXJlbmNlZCBoZXJlIGNvbnRhaW4gY29kZQoJCQkgOzsgd2hpY2ggd2lsbCBi ZSBzdGFnZWQgaW4gdGhlIGJ1aWxkIGVudmlyb25tZW50IHdpdGggdXMuCgkJCSA7OyBPdXIgYnVp bGQgZ2V4cCBkb3duIGJlbG93IHdpbGwgb25seSBiZSBhYmxlIHRvIGFjY2VzcyB0aGlzIGNvZGUK CQkJIDs7IGFuZCB3ZSBtdXN0IGJlIGNhcmVmdWwgbm90IHRvIHJlZmVyZW5jZSBhbnl0aGluZyBl bHNlLgoJCQkgKG1vZHVsZXMgJygobWZzIGJ1aWxkIHplcGh5ci1idWlsZC1zeXN0ZW0pCgkJCQkg ICAgKGd1aXggYnVpbGQgdXRpbHMpKSkpCiAgICAiQnVpbGQgU09VUkNFIHVzaW5nIENNQUtFLCBh bmQgd2l0aCBJTlBVVFMuIFRoaXMgYXNzdW1lcyB0aGF0IFNPVVJDRQogIHByb3ZpZGVzIGEgJ0NN YWtlTGlzdHMudHh0JyBmaWxlIGFzIGl0cyBidWlsZCBzeXN0ZW0uIgoKICAgIDs7IFRoaXMgaXMg dGhlIGJ1aWxkIGdleHAuIEl0IGhhbmRsZXMgc3RhZ2luZyB2YWx1ZXMgZnJvbSBvdXIgaG9zdAog ICAgOzsgc3lzdGVtIGludG8gY29kZSB0aGF0IG91ciBidWlsZCBzeXN0ZW0gY2FuIHJ1bi4KICAg IChkZWZpbmUgYnVpbGQKICAgICAgKHdpdGgtaW1wb3J0ZWQtbW9kdWxlcyBpbXBvcnRlZC1tb2R1 bGVzCgkjfihiZWdpbgoJICAgICh1c2UtbW9kdWxlcyAjJEAoc2V4cC0+Z2V4cCBtb2R1bGVzKSkK CSAgICAjJCh3aXRoLWJ1aWxkLXZhcmlhYmxlcyBpbnB1dHMgb3V0cHV0cwoJCSN+KHplcGh5ci1i dWlsZCAjOnNvdXJjZSAjK3NvdXJjZQoJCQkJIzpzeXN0ZW0gIyRzeXN0ZW0KCQkJCSM6b3V0cHV0 cyAlb3V0cHV0cwoJCQkJIzppbnB1dHMgJWJ1aWxkLWlucHV0cwoJCQkJIzpib2FyZCAjJGJvYXJk CgkJCQkjOnNlYXJjaC1wYXRocyAnIyQoc2V4cC0+Z2V4cAoJCQkJCQkgICAobWFwIHNlYXJjaC1w YXRoLXNwZWNpZmljYXRpb24tPnNleHAKCQkJCQkJCXNlYXJjaC1wYXRocykpCgkJCQkjOnBoYXNl cyAjJChpZiAocGFpcj8gcGhhc2VzKQoJCQkJCSAgICAgICAoc2V4cC0+Z2V4cCBwaGFzZXMpCgkJ CQkJICAgICAgIHBoYXNlcykKCQkJCSM6Y29uZmlndXJlLWZsYWdzICMkKGlmIChwYWlyPyBjb25m aWd1cmUtZmxhZ3MpCgkJCQkJCQkoc2V4cC0+Z2V4cCBjb25maWd1cmUtZmxhZ3MpCgkJCQkJCQlj b25maWd1cmUtZmxhZ3MpCgkJCQkjOm1ha2UtZmxhZ3MgIyRtYWtlLWZsYWdzCgkJCQkjOm91dC1v Zi1zb3VyY2U/ICMkb3V0LW9mLXNvdXJjZT8KCQkJCSM6dGVzdHM/ICMkdGVzdHM/CgkJCQkjOnRl c3QtdGFyZ2V0ICMkdGVzdC10YXJnZXQKCQkJCSM6cGFyYWxsZWwtYnVpbGQ/ICMkcGFyYWxsZWwt YnVpbGQ/CgkJCQkjOnBhcmFsbGVsLXRlc3RzPyAjJHBhcmFsbGVsLXRlc3RzPwoJCQkJIzp2YWxp ZGF0ZS1ydW5wYXRoPyAjJHZhbGlkYXRlLXJ1bnBhdGg/CgkJCQkjOnBhdGNoLXNoZWJhbmdzPyAj JHBhdGNoLXNoZWJhbmdzPwoJCQkJIzpzdHJpcC1iaW5hcmllcz8gI2YpKSkpKQoKICAgIDs7IGxv b2sgd2UgZXZlbiBoYXZlIG1vbmFkcyBsaWtlIHRoZSBjb29sIGtpZHMhCiAgICAobWxldCAlc3Rv cmUtbW9uYWQgKChndWlsZSAocGFja2FnZS0+ZGVyaXZhdGlvbiAob3IgZ3VpbGUgKGRlZmF1bHQt Z3VpbGUpKQoJCQkJCQkgICAgc3lzdGVtICM6Z3JhZnQ/ICNmKSkpCiAgICAgIChnZXhwLT5kZXJp dmF0aW9uIG5hbWUgYnVpbGQKCQkJIzpzeXN0ZW0gc3lzdGVtCgkJCSM6dGFyZ2V0ICNmCgkJCSM6 Z3JhZnQ/ICNmCgkJCSM6c3Vic3RpdHV0YWJsZT8gc3Vic3RpdHV0YWJsZT8KCQkJIzpndWlsZS1m b3ItYnVpbGQgZ3VpbGUpKSkKIytFTkRfU1JDCgpGaW5hbGx5IHdlIGRlZmluZSBvdXIgYnVpbGQg c3lzdGVtIHdoaWNoIHRoZSBwYWNrYWdlIGRlZmluaXRpb25zIGNhbiByZWZlcmVuY2UuCgojK0JF R0lOX1NSQyBzY2hlbWUKICAoZGVmaW5lIHplcGh5ci1idWlsZC1zeXN0ZW0KICAgIChidWlsZC1z eXN0ZW0KICAgICAgKG5hbWUgJ3plcGh5cikKICAgICAgKGRlc2NyaXB0aW9uICJUaGUgc3RhbmRh cmQgWmVwaHlyIGJ1aWxkIHN5c3RlbSIpCiAgICAgIChsb3dlciBsb3dlcikpKQojK0VORF9TUkMK CkVhc3kgcmlnaHQ/CgoqKiBCdWlsZCBTaWRlCgpUaGUgYnVpbGQgc2lkZSBpcyBub3QgYXMgY29t cGxleCBhcyB5b3UgbWlnaHQgaW5pdGlhbGx5IGV4cGVjdC4KT3VyIGJ1aWxkIHN5c3RlbSBpcyBh bG1vc3QgZXhhY3RseSB0aGUgc2FtZSBhcyB0aGUgQ01ha2UgYnVpbGQgc3lzdGVtIGV4Y2VwdCBv dXIgY29uZmlndXJlIHBoYXNlCnBhc3NlcyBkaWZmZXJlbnQgdmFsdWVzIHRvIENNYWtlLiBPdXIg am9iIGlzIG11Y2ggZWFzaWVyLgoKKioqIExvY2F0aW5nIE1vZHVsZXMKClplcGh5ciBDTWFrZSBy ZXF1aXJlcyB0aGUgemVwaHlyIC9tb2R1bGVzLyB3aGljaCBhcmUgbmVlZGVkIGZvciB0aGUKYnVp bGQgdG8gYmUgc3VwcGxpZWQgb24gdGhlIGNvbW1hbmQgbGluZS4KVW5mb3J0dW5hdGVseSBmb3Ig dXMgdGhlIFtbaHR0cHM6Ly9kb2NzLnplcGh5cnByb2plY3Qub3JnL2xhdGVzdC9kZXZlbG9wL2Fw cGxpY2F0aW9uL2luZGV4Lmh0bWwjaW1wb3J0YW50LWJ1aWxkLXZhcnNdW2RvY3VtZW50YXRpb25d XSBpcyB3cm9uZyBhbmQgdGhlID1aRVBIWVJfTU9EVUxFUz0KaXMgbm90IGhvbm9yZWQuIFRodXMg d2UgbXVzdCBpbXBsZW1lbnQgc29tZSBvdGhlciBzb2x1dGlvbiBmb3IKbG9jYXRpbmcgbW9kdWxl cyB1bnRpbCB0aGV5IGZpeCB0aGF0LgoKKklucHV0IFNjYW5uaW5nKiAtIEx1Y2t5IGZvciB1cyB3 ZSBhcmUga2VlcGluZyBkZXRhaWxlZCBpbmZvcm1hdGlvbgphYm91dCBvdXIgZGVwZW5kZW5jaWVz LiBJdCBpcyBhIHNpbXBsZSBtYXR0ZXIgdG8gd3JpdGUgYSBmaWxlIHRyZWUKd2Fsa2VyIHdoaWNo IGNvbGxlY3RzIGFsbCB0aGUgemVwaHlyIG1vZHVsZXMgaW4gb3VyIGlucHV0cy4KCgojK0JFR0lO X1NSQyBzY2hlbWUKICAoZGVmaW5lKiAoZmluZC16ZXBoeXItbW9kdWxlcyBkaXJlY3RvcmllcykK ICAgICJSZXR1cm4gdGhlIGxpc3Qgb2YgZGlyZWN0b3JpZXMgY29udGFpbmluZyB6ZXBoeXIvbW9k dWxlLnltbCBmb3VuZAogIHVuZGVyIERJUkVDVE9SWSwgcmVjdXJzaXZlbHkuIFJldHVybiB0aGUg ZW1wdHkgbGlzdCBpZiBESVJFQ1RPUlkgaXMKICBub3QgYWNjZXNzaWJsZS4iCiAgICAoZGVmaW5l IChtb2R1bGUtZGlyZWN0b3J5IGZpbGUpCiAgICAgIChkaXJuYW1lIChkaXJuYW1lIGZpbGUpKSkK CiAgICAoZGVmaW5lIChlbnRlcj8gbmFtZSBzdGF0IHJlc3VsdCkKICAgICAgOzsgU2tpcCB2ZXJz aW9uIGNvbnRyb2wgZGlyZWN0b3JpZXMuCiAgICAgIChub3QgKG1lbWJlciAoYmFzZW5hbWUgbmFt ZSkgJygiLmdpdCIgIi5zdm4iICJDVlMiKSkpKQoKICAgIChkZWZpbmUgKGxlYWYgbmFtZSBzdGF0 IHJlc3VsdCkKICAgICAgOzsgQWRkIG1vZHVsZSByb290IGRpcmVjdG9yeSB0byByZXN1bHRzCiAg ICAgIChpZiAoYW5kIChzdHJpbmc9ICJtb2R1bGUueW1sIiAoYmFzZW5hbWUgbmFtZSkpCgkgICAg ICAgKHN0cmluZz0gInplcGh5ciIgKGJhc2VuYW1lIChkaXJuYW1lIG5hbWUpKSkpCgkgIChjb25z IChtb2R1bGUtZGlyZWN0b3J5IG5hbWUpIHJlc3VsdCkKCSAgcmVzdWx0KSkKCiAgICAoZGVmaW5l IChkb3duIG5hbWUgc3RhdCByZXN1bHQpIHJlc3VsdCkKICAgIChkZWZpbmUgKHVwIG5hbWUgc3Rh dCByZXN1bHQpIHJlc3VsdCkKICAgIChkZWZpbmUgKHNraXAgbmFtZSBzdGF0IHJlc3VsdCkgcmVz dWx0KQoKICAgIChkZWZpbmUgKGZpbmQtbW9kdWxlcyBkaXJlY3RvcnkpCiAgICAgIChmaWxlLXN5 c3RlbS1mb2xkIGVudGVyPyBsZWFmIGRvd24gdXAgc2tpcCBlcnJvcgoJCQknKCkgKGNhbm9uaWNh bGl6ZS1wYXRoIGRpcmVjdG9yeSkpKQoKICAgIChhcHBlbmQtbWFwIGZpbmQtbW9kdWxlcyBkaXJl Y3RvcmllcykpCgogIChkZWZpbmUgKHplcGh5ci1tb2R1bGVzLWNtYWtlLWFyZ3VtZW50IG1vZHVs ZXMpCiAgICAiUmV0dXJuIGEgcHJvcGVyIENNYWtlIGxpc3QgZnJvbSBNT0RVTEVTLCBhIGxpc3Qg b2YgZmlsZXBhdGhzIgogICAgKGZvcm1hdCAjZiAiLURaRVBIWVJfTU9EVUxFUz0nfnt+YX5eO359 JyIgbW9kdWxlcykpCiMrRU5EX1NSQwoKSGVyZSBhcmUgdHdvIGZ1bmN0aW9ucy4gVGhlIGZpcnN0 IG9uZSB+ZmluZC16ZXBoeXItbW9kdWxlc34gd2Fsa3MgYSBkaXJlY3RvcnkgdHJlZSBhbmQKcmV0 dXJucyBhIGxpc3Qgb2YgZXZlcnkgbW9kdWxlIGl0IGZpbmRzLiBUaGUgc2Vjb25kIG9uZSBpcyBq dXN0IGZvcgpzeW50YWN0aWMgY29udmVuaWVuY2Ugd2hlbiB3cml0aW5nIHRoZSBDTWFrZSBpbnZv a2F0aW9uLgoKRnJvbSBoZXJlIHdlIGp1c3QgbmVlZCB0byBwcm92aWRlIGFsdGVybmF0ZSBpbXBs ZW1lbnRhdGlvbnMgb2YgfmNvbmZpZ3VyZX4gYW5kIH5pbnN0YWxsfltmbjo3XQoKIytCRUdJTl9T UkMgc2NoZW1lCiAgKGRlZmluZSogKGNvbmZpZ3VyZSAjOmtleSBvdXRwdXRzIChjb25maWd1cmUt ZmxhZ3MgJygpKQoJCSAgICAgIGlucHV0cyAob3V0LW9mLXNvdXJjZT8gI3QpCgkJICAgICAgYnVp bGQtdHlwZQoJCSAgICAgICM6YWxsb3ctb3RoZXIta2V5cykKICAgICJDb25maWd1cmUgdGhlIGdp dmVuIHBhY2thZ2UuIgogICAgKGxldCogKChvdXQgICAgICAgIChhc3NvYy1yZWYgb3V0cHV0cyAi b3V0IikpCgkgICAoYWJzLXNyY2RpciAoZ2V0Y3dkKSkKCSAgIChzcmNkaXIgICAgIChpZiBvdXQt b2Ytc291cmNlPwoJCQkgICAoc3RyaW5nLWFwcGVuZCAiLi4vIiAoYmFzZW5hbWUgYWJzLXNyY2Rp cikpCgkJCSAgICIuIikpKQogICAgICAoZm9ybWF0ICN0ICJzb3VyY2UgZGlyZWN0b3J5OiB+cyAo cmVsYXRpdmUgZnJvbSBidWlsZDogfnMpfiUiCgkgICAgICBhYnMtc3JjZGlyIHNyY2RpcikKICAg ICAgKHdoZW4gb3V0LW9mLXNvdXJjZT8KCShta2RpciAiLi4vYnVpbGQiKQoJKGNoZGlyICIuLi9i dWlsZCIpKQogICAgICAoZm9ybWF0ICN0ICJidWlsZCBkaXJlY3Rvcnk6IH5zfiUiIChnZXRjd2Qp KQoKICAgICAgOzsgdGhpcyBpcyByZXF1aXJlZCBiZWNhdXNlIHplcGh5ciB0cmllcyB0byBvcHRp bWl6ZQogICAgICA7OyBmdXR1cmUgY2FsbHMgdG8gdGhlIGJ1aWxkIHNjcmlwdHMgYnkga2VlcCBh IGNhY2hlLgogICAgICAoc2V0ZW52ICJYREdfQ0FDSEVfSE9NRSIgKGdldGN3ZCkpCgogICAgICAo bGV0ICgoYXJncyBgKCxzcmNkaXIKCQkgICAgLEAoaWYgYnVpbGQtdHlwZQoJCQkgIChsaXN0IChz dHJpbmctYXBwZW5kICItRENNQUtFX0JVSUxEX1RZUEU9IgoJCQkJCSAgICAgICBidWlsZC10eXBl KSkKCQkJICAnKCkpCgkJICAgIDs7IGVuYWJsZSB2ZXJib3NlIG91dHB1dCBmcm9tIGJ1aWxkcwoJ CSAgICAiLURDTUFLRV9WRVJCT1NFX01BS0VGSUxFPU9OIgoJCSAgICAsKHplcGh5ci1tb2R1bGVz LWNtYWtlLWFyZ3VtZW50CgkJICAgICAgKGZpbmQtemVwaHlyLW1vZHVsZXMgKG1hcCBjZHIgaW5w dXRzKSkpCgkJICAgICxAY29uZmlndXJlLWZsYWdzKSkpCgkoZm9ybWF0ICN0ICJydW5uaW5nICdj bWFrZScgd2l0aCBhcmd1bWVudHMgfnN+JSIgYXJncykKCShhcHBseSBpbnZva2UgImNtYWtlIiBh cmdzKSkpKQoKICAoZGVmaW5lKiAoaW5zdGFsbCAjOmtleSBvdXRwdXRzICM6YWxsb3ctb3RoZXIt a2V5cykKICAgIChsZXQqICgob3V0IChzdHJpbmctYXBwZW5kIChhc3NvYy1yZWYgb3V0cHV0cyAi b3V0IikgIi9maXJtd2FyZSIpKQoJICAgKGRiZyAoc3RyaW5nLWFwcGVuZCAoYXNzb2MtcmVmIG91 dHB1dHMgImRlYnVnIikgIi9zaGFyZS96ZXBoeXIiKSkpCiAgICAgIChta2Rpci1wIG91dCkKICAg ICAgKG1rZGlyLXAgZGJnKQogICAgICAoY29weS1maWxlICJ6ZXBoeXIvLmNvbmZpZyIgKHN0cmlu Zy1hcHBlbmQgZGJnICIvY29uZmlnIikpCiAgICAgIChjb3B5LWZpbGUgInplcGh5ci96ZXBoeXIu bWFwIiAoc3RyaW5nLWFwcGVuZCBkYmcgIi96ZXBoeXIubWFwIikpCiAgICAgIChjb3B5LWZpbGUg InplcGh5ci96ZXBoeXIuZWxmIiAoc3RyaW5nLWFwcGVuZCBvdXQgIi96ZXBoeXIuZWxmIikpCiAg ICAgIChjb3B5LWZpbGUgInplcGh5ci96ZXBoeXIuYmluIiAoc3RyaW5nLWFwcGVuZCBvdXQgIi96 ZXBoeXIuYmluIikpKSkKCiAgOzsgRGVmaW5lIG5ldyBzdGFuZGFyZC1waGFzZXMKICAoZGVmaW5l ICVzdGFuZGFyZC1waGFzZXMKICAgIChtb2RpZnktcGhhc2VzIGNtYWtlOiVzdGFuZGFyZC1waGFz ZXMKICAgICAgKHJlcGxhY2UgJ2NvbmZpZ3VyZSBjb25maWd1cmUpCiAgICAgIChyZXBsYWNlICdp bnN0YWxsIGluc3RhbGwpKSkKCiAgOzsgQ2FsbCBjbWFrZSBidWlsZCB3aXRoIG91ciBuZXcgcGhh c2VzCiAgKGRlZmluZSogKHplcGh5ci1idWlsZCAjOmtleSBpbnB1dHMgKHBoYXNlcyAlc3RhbmRh cmQtcGhhc2VzKQoJCQkgIzphbGxvdy1vdGhlci1rZXlzICM6cmVzdCBhcmdzKQogICAgKGFwcGx5 IGNtYWtlOmNtYWtlLWJ1aWxkCgkgICAjOmlucHV0cyBpbnB1dHMgIzpwaGFzZXMgcGhhc2VzIGFy Z3MpKQojK0VORF9TUkMKCk9uZSB0aGluZyB0byBub3RlIGlzIHRoZSAiZGVidWciIG91dHB1dC4g VGhpcyBleGlzdHMgc28gd2UgZG9uJ3QKcmV0YWluIHJlZmVyZW5jZXMgdG8gb3VyIGJ1aWxkIGVu dmlyb25tZW50IGFuZCBtYWtlIHRoZSBmaWxlIHN5c3RlbQpjbG9zdXJlIGh1Z2UuIElmIHlvdSBw dXQgYWxsIG9mIHRoZSBidWlsZCBvdXRwdXRzIGluIHRoZSBzYW1lIHN0b3JlCnBhdGggdGhlIGRl cGxveW1lbnQgY2xvc3VyZSBncm93cyBmcm9tIDJNQltmbjo4XSB0byA4MzNNQi4KCiogRGVmaW5p bmcgWmVwaHlyIFBhY2thZ2VzCgpOb3cgdGhhdCB3ZSBoYXZlIGEgcHJvcGVyIGJ1aWxkIHN5c3Rl bSwgaXQncyB0aW1lIHRvIGRlZmluZSBzb21lIHBhY2thZ2VzIQoKKiogWmVwaHlyIEJhc2UKWmVw aHlyIGJhc2UgY29udGFpbnMgdGhlIFplcGh5ciBzb3VyY2UgY29kZS4KSXQgaXMgZXF1aXZhbGVu dCAoaW4gbXkgbWluZCBhbnl3YXkpIHRvIHRoZSBsaW51eCBrZXJuZWwgaW4gdGhhdCBwYWNrYWdl cwp3aGljaCB0YXJnZXQgdGhlIGxpbnV4IGtlcm5lbCBkbyBub3QgbmVlZCB0byBzcGVjaWZ5IGFz IG11Y2ggaW4gdGhlaXIgZGVmaW5pdGlvbnMuCgpUaGUgc2VsZWN0aW9uIG9mIG9wZXJhdGluZyBz eXN0ZW0gYWN0dWFsbHkgY29tZXMgZnJvbSB0aGUgdG9vbGNoYWluLgpXaGVuIHdlIGJ1aWxkIGxp bnV4IHBhY2thZ2VzIHRoZSB3YXkgd2Ugc3BlY2lmeSB0aGlzIGlzIHdpdGggdGhlIFtbaHR0cHM6 Ly93d3cuZ251Lm9yZy9zb2Z0d2FyZS9hdXRvY29uZi9tYW51YWwvYXV0b2NvbmYtMi42NS9odG1s X25vZGUvU3BlY2lmeWluZy1UYXJnZXQtVHJpcGxldHMuaHRtbF1bZ251IHRyaXBsZXRdXS4KV2hl biB3ZSBzZWxlY3QgdGhlIH5hcm0tbGludXgtZ251ZWFiaWhmfiB3ZSBhcmUgc3BlY2lmeWluZyBv dXIgb3BlcmF0aW5nIHN5c3RlbS4KCkl0IGlzIHRoZSBzYW1lIGZvciBaZXBoeXIuIFdoZW4gd2Ug YnVpbGQgZm9yIHplcGh5ciB3ZSB1c2UgdGhlIH5hcm0temVwaHlyLWVhYml+CnRvb2xjaGFpbi4g SG93ZXZlciwgdW5saWtlIGxpbnV4IGFwcGxpY2F0aW9ucywgemVwaHlyIGFwcGxpY2F0aW9ucyBh cmUKZW1iZWRkZWQgZmlybXdhcmUgaW1hZ2VzIGFuZCBhcmUgZ2VuZXJhbGx5IHN0YXRpY2FsbHkg bGlua2VkLgpUaHVzIHRoaXMgcGFja2FnZSBqdXN0IGNvbnNpc3RzIG9mIGl0J3Mgc291cmNlIGNv ZGUgYW5kIGlzIG5vdCBjb21waWxlZCBkaXJlY3RseS4KCiMrQkVHSU5fU1JDIHNjaGVtZQogIChk ZWZpbmUtcHVibGljIHplcGh5cgogICAgKGxldCAoKHZlcnNpb24gIjMuMS4wIikKCSAgKGNvbW1p dCAiemVwaHlyLXYzLjEuMCIpKQogICAgICAocGFja2FnZQoJKG5hbWUgInplcGh5ciIpCgkodmVy c2lvbiB2ZXJzaW9uKQoJKGhvbWUtcGFnZSAiaHR0cHM6Ly96ZXBoeXJwcm9qZWN0Lm9yZyIpCgko c291cmNlIChvcmlnaW4gKG1ldGhvZCBnaXQtZmV0Y2gpCgkJCSh1cmkgKGdpdC1yZWZlcmVuY2UK CQkJICAgICAgKHVybCAiaHR0cHM6Ly9naXRodWIuY29tL3plcGh5cnByb2plY3QtcnRvcy96ZXBo eXIiKQoJCQkgICAgICAoY29tbWl0IGNvbW1pdCkpKQoJCQkoZmlsZS1uYW1lIChnaXQtZmlsZS1u YW1lIG5hbWUgdmVyc2lvbikpCgkJCShzaGEyNTYKCQkJIChiYXNlMzIgIjF5bDV5OTc1N3hjM2ww MzdrM2cxZHluaXNwdjZqNXpxZm56cmhzcWg5Y3g0cXpkNDg1bHgiKSkKCQkJKHBhdGNoZXMKCQkJ IDs7IHRoaXMgcGF0Y2ggbWFrZXMgdGhpcyBwYWNrYWdlIHdvcmsgaW4gYSBzeW1saW5rZWQgcHJv ZmlsZQoJCQkgKHNlYXJjaC1wYXRjaGVzICJ6ZXBoeXItMy4xLWxpbmtlci1nZW4tYWJzLXBhdGgu cGF0Y2giKSkpKQoJKGJ1aWxkLXN5c3RlbSBjb3B5LWJ1aWxkLXN5c3RlbSkKCShhcmd1bWVudHMK CSBgKCM6aW5zdGFsbC1wbGFuCgkgICAnKCgiLiIgInplcGh5ci13b3Jrc3BhY2UvemVwaHlyIikp CgkgICAjOnBoYXNlcwoJICAgKG1vZGlmeS1waGFzZXMgJXN0YW5kYXJkLXBoYXNlcwoJICAgICAo YWRkLWFmdGVyICd1bnBhY2sgJ3BhdGNoLWNtYWtlLXNjcmlwdHMKCSAgICAgICAobGFtYmRhKiBf CgkJIChmb3JtYXQgI3QgIn5hfiYiIChnZXRjd2QpKQoJCSA7OyBTb21lIGNtYWtlIHNjcmlwdHMg YXNzdW1lIHRoZSBwcmVzZW5jZSBvZiBhCgkJIDs7IGdpdCByZXBvc2l0b3J5IGluIHRoZSBzb3Vy Y2UgZGlyZWN0b3J5LgoJCSA7OyBXZSB3aWxsIGp1c3QgaGFyZC1jb2RlIHRoYXQgaW5mb3JtYXRp b24gbm93CgkJIChzdWJzdGl0dXRlKiAiQ01ha2VMaXN0cy50eHQiCgkJICAgKCgiaWZcXChERUZJ TkVEIEJVSUxEX1ZFUlNJT05cXCkiIGFsbCkKCQkgICAgKGZvcm1hdCAjZiAic2V0KEJVSUxEX1ZF UlNJT04gXCJ+YS1+YVwiKX4mfmEiCgkJCSAgICAsdmVyc2lvbiAsY29tbWl0IGFsbCkpKSkpKSkp CgkocHJvcGFnYXRlZC1pbnB1dHMKCSAobGlzdCBweXRob24tMwoJICAgICAgIHB5dGhvbi1weWVs ZnRvb2xzCgkgICAgICAgcHl0aG9uLXB5a3dhbGlmeQoJICAgICAgIHB5dGhvbi1weXlhbWwKCSAg ICAgICBweXRob24tcGFja2FnaW5nKSkKCShuYXRpdmUtc2VhcmNoLXBhdGhzCgkgKGxpc3QgKHNl YXJjaC1wYXRoLXNwZWNpZmljYXRpb24KCQkodmFyaWFibGUgIlpFUEhZUl9CQVNFIikKCQkoZmls ZXMgJygiemVwaHlyLXdvcmtzcGFjZS96ZXBoeXIiKSkpKSkKCShzeW5vcHNpcyAiU291cmNlIGNv ZGUgZm9yIHplcGh5ciBydG9zIikKCShkZXNjcmlwdGlvbiAiWmVwaHlyIHJ0b3Mgc291cmNlIGNv ZGUuIikKCShsaWNlbnNlIGxpY2Vuc2U6YXBzbDIpKSkpCgogIChkZWZpbmUtcHVibGljIHplcGh5 ci0zLjIuMC1yYzMKICAgIChwYWNrYWdlIChpbmhlcml0IHplcGh5cikKICAgICAgKHZlcnNpb24g IjMuMi4wLXJjMyIpCiAgICAgIChzb3VyY2UgKG9yaWdpbiAobWV0aG9kIGdpdC1mZXRjaCkKCQkg ICAgICAodXJpIChnaXQtcmVmZXJlbmNlCgkJCSAgICAodXJsICJodHRwczovL2dpdGh1Yi5jb20v emVwaHlycHJvamVjdC1ydG9zL3plcGh5ciIpCgkJCSAgICAoY29tbWl0ICJ2My4yLjAtcmMzIikp KQoJCSAgICAgIChmaWxlLW5hbWUgKGdpdC1maWxlLW5hbWUgInplcGh5ciIgdmVyc2lvbikpCgkJ ICAgICAgKHNoYTI1NgoJCSAgICAgICAoYmFzZTMyICIwNmtzZDl6ajRqMTlqcTB6ZzNsbXMxM2p4 MGd4empjNDE0MzN6Z2I5MWNuZDJjcW1uNWNiIikpCgkJICAgICAgKHBhdGNoZXMKCQkgICAgICAg KHNlYXJjaC1wYXRjaGVzICJ6ZXBoeXItMy4xLWxpbmtlci1nZW4tYWJzLXBhdGgucGF0Y2giKSkp KSkpCiMrRU5EX1NSQwoKSGVyZSB3ZSB1c2UgdGhlIH5jb3B5LWJ1aWxkLXN5c3RlbX4gd2hpY2gg dGFrZXMgYSBsaXN0IG9mIHNvdXJjZSBkZXN0aW5hdGlvbiBwYWlycy4KSW4gb3VyIGNhc2Ugd2Ug anVzdCBjb3B5IGV2ZXJ5dGhpbmcgdG8gdGhlIG91dHB1dCBkaXJlY3RvcnksIGJ1dCBub3QgYmVm b3JlIHBhdGNoaW5nIHNvbWUgZmlsZXMKdG8gYWNjb21vZGF0ZSBvdXIgc3BlY2lhbCBlbnZpcm9u bWVudC4KCldoaWxlIGRldmVsb3BpbmcgdGhpcyBJIHdhbnRlZCB0byB0ZXN0IHNvbWUgdG9vbGNo YWluL2JvYXJkIGZlYXR1cmVzCm9uIHRoZSBsYXRlc3QgcmVsZWFzZSBvZiBaZXBoeXIuIEkgaW5j bHVkZWQgYW4gZXhhbXBsZSBvZiB0aGF0IHBhY2thZ2UKZGVmaW5pdGlvbiB0byBzaG93IGhvdyB3 ZSBjYW4gZWFzaWx5IGFjY29tb2RhdGUgc2lkZSBieSBzaWRlIHBhY2thZ2UKdmFyaWFudHMgYW5k IGV4cGVyaW1lbnQgd2l0aG91dCBicmVha2luZyBhbnl0aGluZy5bZm46OV0KCioqIEhlbGxvIHdv cmxkCgpJdCdzIGZpbmFsbHkgdGltZSB0byBkZWZpbmUgc29tZSBmaXJtd2FyZSEKWmVwaHlyIHBh Y2thZ2VzIHNvbWUgZXhhbXBsZXMgaW4gfiRaRVBIWVJfQkFTRS9zYW1wbGVzfiBpbmNsdWRpbmcg YQpiYXNpYyBoZWxsbyB3b3JsZC4gVGhlIGs2NCBkZXZlbG9wbWVudCBib2FyZCBpcyBhbHJlYWR5 IHN1cHBvcnRlZApieSBaZXBoeXIgc28gYnVpbGRpbmcgdGhlIGV4YW1wbGUgaXMgdHJpdmlhbC4K CkluIG9yZGVyIHRvIGFjdHVhbGx5IHRhcmdldCB0aGUgazY0IHdlIG5lZWQgdG8gdHdvIG1vZHVs ZXMsIHRoZSBOWFAKaGFyZHdhcmUgYWJzdHJhY3Rpb24gbGF5ZXIsIGFuZCBDTVNJUy4KTG9va2lu ZyBhdCB+JFpFUEhZUl9CQVNFL3dlc3QueW1sfiB3ZSBjYW4gc2VlIHRoZSByZXBvc2l0b3JpZXMK YW5kIGNvbW1pdHMgd2hpY2ggY29udGFpbiB0aGVzZSBtb2R1bGVzLiBUaGlzIGlzIGhvdyBXZXN0 IGRvZXMKZGVwZW5kZW5jeSBtYW5hZ2VtZW50LgoKRGVmaW5pbmcgdGhlc2UgcGFja2FnZXMgaXMg bm90IHNvIGJhZC4KCipOT1QgU0hPV04qOiBJIG1hZGUgYSB+emVwaHlyLW1vZHVsZS1idWlsZC1z eXN0ZW1+IGFzIHdlbGwgd2hpY2ggaXMKanVzdCB0aGUgfmNvcHktYnVpbGQtc3lzdGVtfiB0aGF0 IG1pbWljcyB0aGUgZGVmYXVsdCB6ZXBoeXIgd29ya3NwYWNlIGxheW91dAphcyBwcm92aWRlZCBi eSB3ZXN0LiBUaGlzIHdheSB3ZSBkbyBub3QgbmVlZCB0byBwcm92aWRlIHRoZSBzYW1lIGluc3Rh bGwtcGxhbiBmb3IKZXZlcnkgbW9kdWxlIHdlIGV2ZXIgcGFja2FnZS4gSG93ZXZlciBhcyBJIHVz ZSBpdCBtb3JlIEkgdGhpbmsgaXQgZG9lc24ndCByZWFsbHkKcHJvdmlkZSBtdWNoIG92ZXIganVz dCB1c2luZyB0aGUgY29weS1idWlsZCBzeXN0ZW0uCgojK0JFR0lOX1NSQyBzY2hlbWUKICAoZGVm aW5lLXB1YmxpYyBoYWwtY21zaXMKICAgIChwYWNrYWdlCiAgICAgIChuYW1lICJoYWwtY21zaXMi KQogICAgICAodmVyc2lvbiAiNS44LjAiKQogICAgICAoaG9tZS1wYWdlICJodHRwczovL2RldmVs b3Blci5hcm0uY29tL3Rvb2xzLWFuZC1zb2Z0d2FyZS9lbWJlZGRlZC9jbXNpcyIpCiAgICAgIChz b3VyY2UgKG9yaWdpbgoJCShtZXRob2QgZ2l0LWZldGNoKQoJCSh1cmkgKGdpdC1yZWZlcmVuY2UK CQkgICAgICAodXJsICJodHRwczovL2dpdGh1Yi5jb20vemVwaHlycHJvamVjdC1ydG9zL2Ntc2lz IikKCQkgICAgICAoY29tbWl0ICIwOTNkZTYxYzJhN2QxMmRjOTI1M2RhZjg2OTJmNjFmNzkzYTky NTRhIikpKQoJCShmaWxlLW5hbWUgKGdpdC1maWxlLW5hbWUgbmFtZSB2ZXJzaW9uKSkKCQkoc2hh MjU2CgkJIChiYXNlMzIgIjBmN2NpcG53bGxuYTdpa25zbnoyNzNqa3ZybHkxNnlyNndtNHkyMDE4 aTZuanBxaDY3d2kiKSkpKQogICAgICAoYnVpbGQtc3lzdGVtIHplcGh5ci1tb2R1bGUtYnVpbGQt c3lzdGVtKQogICAgICAoYXJndW1lbnRzIGAoIzp3b3Jrc3BhY2UtcGF0aCAgIi9tb2R1bGVzL2hh bC9jbXNpcyIpKQogICAgICAoc3lub3BzaXMgIlplcGh5ciBtb2R1bGUgcHJvdmlkaW5nIHRoZSBD b21tb24gTWljcm9jb250cm9sbGVyCiAgU29mdHdhcmUgSW50ZXJmYWNlIFN0YW5kYXJkIikKICAg ICAgKGRlc2NyaXB0aW9uICJaZXBoeXIgbW9kdWxlIHByb3ZpZGluZyB0aGUgQ29tbW9uIE1pY3Jv Y29udHJvbGxlcgogIFNvZnR3YXJlIEludGVyZmFjZSBTdGFuZGFyZCIpCiAgICAgIChsaWNlbnNl IGxpY2Vuc2U6YXBzbDIpKSkKCiAgKGRlZmluZS1wdWJsaWMgaGFsLW54cAogICAgKHBhY2thZ2UK ICAgICAgKG5hbWUgImhhbC1ueHAiKQogICAgICAodmVyc2lvbiAiMy4xLjAiKQogICAgICAoaG9t ZS1wYWdlICJodHRwczovL254cC5jb20iKQogICAgICAoc291cmNlIChvcmlnaW4KCQkobWV0aG9k IGdpdC1mZXRjaCkKCQkodXJpIChnaXQtcmVmZXJlbmNlCgkJICAgICAgKHVybCAiaHR0cHM6Ly9n aXRodWIuY29tL3plcGh5cnByb2plY3QtcnRvcy9oYWxfbnhwIikKCQkgICAgICAoY29tbWl0ICI3 MDhjOTU4MjViMGQ1Mjc5NjIwOTM1YTEzNTYyOTlmZmY1ZGZiYzZlIikpKQoJCShmaWxlLW5hbWUg KGdpdC1maWxlLW5hbWUgbmFtZSB2ZXJzaW9uKSkKCQkoc2hhMjU2CgkJIChiYXNlMzIgIjFjMGky NmJwazZjeWhyMXE0YWYxODNqY2xmbXhzaHY0ZDE1aTdrM2N6N2JyemIxMm04cTEiKSkpKQogICAg ICAoYnVpbGQtc3lzdGVtIHplcGh5ci1tb2R1bGUtYnVpbGQtc3lzdGVtKQogICAgICAoYXJndW1l bnRzIGAoIzp3b3Jrc3BhY2UtcGF0aCAgIi9tb2R1bGVzL2hhbC9ueHAiKSkKICAgICAgKG5hdGl2 ZS1zZWFyY2gtcGF0aHMKICAgICAgIChsaXN0IChzZWFyY2gtcGF0aC1zcGVjaWZpY2F0aW9uCgkg ICAgICAodmFyaWFibGUgIlpFUEhZUl9NT0RVTEVTIikKCSAgICAgIChmaWxlcyBgKCwoc3RyaW5n LWFwcGVuZCAlemVwaHlyLXdvcmtzcGFjZS1uYW1lIG1vZHVsZS1wYXRoKSkpCgkgICAgICAoc2Vw YXJhdG9yICI7IikpKSkKICAgICAgKHN5bm9wc2lzICJaZXBoeXIgbW9kdWxlIGZvciBOWFAgSGFy ZHdhcmUgQWJzdHJhY3Rpb24gTGF5ZXIiKQogICAgICAoZGVzY3JpcHRpb24gIlByb3ZpZGVzIHNv dXJjZXMgZm9yIE5YUCBIQUwgemVwaHlyIG1vZHVsZSIpCiAgICAgIChsaWNlbnNlIGxpY2Vuc2U6 YnNkLTMpKSkKIytFTkRfU1JDCgoKV2l0aCB0aGVzZSB0d28gbW9kdWxlcyBkZWZpbmVkIHdlIGNh biB3cml0ZSB+emVwaHlyLWhlbGxvLXdvcmxkLWZyZG0tazY0Zn4uCgojK0JFR0lOX1NSQyBzY2hl bWUKICAoZGVmaW5lLXB1YmxpYyB6ZXBoeXItaGVsbG8td29ybGQtZnJkbS1rNjRmCiAgICAocGFj a2FnZQogICAgICAobmFtZSAiemVwaHlyLWhlbGxvLXdvcmxkLWZyZG0tazY0ZiIpCiAgICAgICh2 ZXJzaW9uIChwYWNrYWdlLXZlcnNpb24gemVwaHlyKSkKICAgICAgKGhvbWUtcGFnZSAiaHR0cHM6 Ly96ZXBoeXJwcm9qZWN0Lm9yZyIpCiAgICAgIChzb3VyY2UgKGZpbGUtYXBwZW5kIChwYWNrYWdl LXNvdXJjZSB6ZXBoeXIpCgkJCSAgICIvc2FtcGxlcy9oZWxsb193b3JsZCIpKQogICAgICAoYnVp bGQtc3lzdGVtIHplcGh5ci1idWlsZC1zeXN0ZW0pCiAgICAgIChhcmd1bWVudHMKICAgICAgICco Izpjb25maWd1cmUtZmxhZ3MgJygiLURCT0FSRD1mcmRtX2s2NGYiKSkpCiAgICAgIChvdXRwdXRz ICcoIm91dCIgImRlYnVnIikpCiAgICAgIChpbnB1dHMKICAgICAgIChsaXN0IGhhbC1jbXNpcwoJ ICAgICBoYWwtbnhwKSkKICAgICAgKHN5bm9wc2lzICJIZWxsbyB3b3JsZCBleGFtcGxlIGZyb20g WmVwaHlyIFByb2plY3QiKQogICAgICAoZGVzY3JpcHRpb24gIlNhbXBsZSBwYWNrYWdlIGZvciB6 ZXBoeXIgcHJvamVjdCIpCiAgICAgIChsaWNlbnNlIGxpY2Vuc2U6YXBzbDIpKSkKIytFTkRfU1JD CgpIb3cgZWxlZ2FudCBpcyB0aGF0PwoKKioqIEJ1aWxkaW5nCgpPdXIgYWJvdmUgZGVmaW5pdGlv biBjYW4gYmUgYnVpbGQgdXNpbmcgdGhlIGZvbGxvd2luZy4KV2hlbiB0ZXN0aW5nIHBhY2thZ2Ug ZGVmaW5pdGlvbnMgSSB1c2UgdGhlIH4tTH4gZmxhZyB0byBwb2ludCB0byB0aGUgbG9jYWwKcmVw b3NpdG9yeSB0byBsb2FkIHRoZSBuZXcgcGFja2FnZXMuIEkgd2lsbCBiZSBvbWl0dGluZyB0aGF0 IGZsYWcgYXMKaWYgSSBoYWQgfmd1aXggcHVsbH5lZCBzdWNjZXNzZnVsbHkgZnJvbSBteSBjaGFu bmVsLgoKIytCRUdJTl9TUkMgc2ggOmV4cG9ydHMgYm90aAogIGd1aXggYnVpbGQgemVwaHlyLWhl bGxvLXdvcmxkLWZyZG0tazY0ZgojK0VORF9TUkMKCiMrUkVTVUxUUzoKfCAvZ251L3N0b3JlLy4u Li16ZXBoeXItaGVsbG8td29ybGQtZnJkbS1rNjRmLTMuMS4wLWRlYnVnIHwKfCAvZ251L3N0b3Jl Ly4uLi16ZXBoeXItaGVsbG8td29ybGQtZnJkbS1rNjRmLTMuMS4wICAgICAgIHwKClRoaXMgYWN0 dWFsbHkgZG9lc24ndCBmdWxseSB0ZXN0IG91ciB0b29sY2hhaW4uIFRoZSBoZWxsbyB3b3JsZApl eGFtcGxlLCB1bmxlc3MgcHJvZGRlZCBub3QgdG8sIHdpbGwgdXNlIGEgemVwaHlyIHByb3ZpZGVk Cm1pbmltYWwgaW1wbGVtZW50YXRpb24gb2YgdGhlIEMgbGlicmFyeSBhbmQgd2lsbCBub3QgbGlu ayBhZ2FpbnN0Cm5ld2xpYi4KCiMrQkVHSU5fU1JDIHNjaGVtZQogIChkZWZpbmUtcHVibGljIHpl cGh5ci1oZWxsby13b3JsZC1uZXdsaWItZnJkbS1rNjRmCiAgICAocGFja2FnZQogICAgICAoaW5o ZXJpdCB6ZXBoeXItaGVsbG8td29ybGQtZnJkbS1rNjRmKQogICAgICAobmFtZSAiemVwaHlyLWhl bGxvLXdvcmxkLW5ld2xpYi1mcmRtLWs2NGYiKQogICAgICAoYXJndW1lbnRzCiAgICAgICAoc3Vi c3RpdHV0ZS1rZXl3b3JkLWFyZ3VtZW50cyAocGFja2FnZS1hcmd1bWVudHMgemVwaHlyLWhlbGxv LXdvcmxkLWZyZG0tazY0ZikKCSAoKCM6Y29uZmlndXJlLWZsYWdzIGZsYWdzKQoJICBgKGFwcGVu ZAoJICAgICcoIi1EQ09ORklHX01JTklNQUxfTElCQz1uIgoJICAgICAgIi1EQ09ORklHX05FV0xJ Ql9MSUJDPXkiKQoJICAgICxmbGFncykpKSkpKQojK0VORF9TUkMKCiMrQkVHSU5fU1JDIHNoIDpl eHBvcnRzIGJvdGgKICBndWl4IGJ1aWxkIHplcGh5ci1oZWxsby13b3JsZC1uZXdsaWItZnJkbS1r NjRmCiMrRU5EX1NSQwoKIytSRVNVTFRTOgp8IC9nbnUvc3RvcmUvLi4uLXplcGh5ci1oZWxsby13 b3JsZC1uZXdsaWItZnJkbS1rNjRmLTMuMS4wLWRlYnVnIHwKfCAvZ251L3N0b3JlLy4uLi16ZXBo eXItaGVsbG8td29ybGQtbmV3bGliLWZyZG0tazY0Zi0zLjEuMCAgICAgIHwKCldvb2hvbyEKCgoq IEZ1cnRoZXIgTXVzaW5ncwoKT25lIHRoaW5nIEkgbGVhcm5lZCB3aGlsZSBnb2luZyB0aHJvdWdo IHRoZSBwYWlucyBvZiBnZXR0aW5nIHRoaXMKd29ya2luZyBpcyB0aGF0IGV2ZW4gdGhvdWdoIHRo ZSBjb21wb25lbnRzIGFyZSAibW9kdWxhciIgdGhlcmUgaXMKc3RpbGwgYSBsb3QgcmlnaWQgaW50 ZXJkZXBlbmRlbmNpZXMsIGVzcGVjaWFsbHkgb24gdGhlIHplcGh5ciBiYXNlLgpKdXN0IGhhdmlu ZyB0d28gdmVyc2lvbnMgb2YgWmVwaHlyIGluIHRoZSBjb2RlIGJhc2UgbWFkZSBjb21wb25lbnQK Y29tcG9zaXRpb24gZnJhZ2lsZVtmbjoyXS4KTW9kdWxlcyByZWx5IG9uIHNwZWNpZmljIGZlYXR1 cmVzIGZyb20gdGhlIGtlcm5lbAoKVGhpcyBpcyBoaWRkZW4gZnJvbSBkZXZlbG9wZXJzIG5vcm1h bGx5IGJ5IHdlc3QgYXV0b21hZ2ljYWxseSB3YWxraW5nCnRoZSBgd2VzdC55bWxgIG9mIGFsbCBv ZiB0aGUgZGVjbGFyZWQgZGVwZW5kZW5jaWVzIHJlY3Vyc2l2ZWx5IHRvCmRpc2NvdmVyIHRoZSBn cmFwaC4KCgoKKiBGb290bm90ZXMKCltmbjoyXSBUbyBiZSBmYWlyOiAzLjIuMCB3YXMgYSBsYXJn ZSBhbmQgYmFja3dhcmRzIGJyZWFraW5nIHJlbGVhc2UuCgpbZm46OV0gSW4gbXkgb3BpbmlvbiB0 aGlzIGlzIHRoZSBtb3N0IGltcG9ydGFudCBmaW5kaW5nIG9mIHRoaXMgcmVzZWFyY2guClRoZSBh YmlsaXR5IHRvIGVhc2lseS9zYWZlbHkgZXhwZXJpbWVudCB3aXRoIGEgd29ya2luZyByZWZlcmVu Y2UgZGVzaWduIGlzIGV4dHJlbWVseSB2YWx1YWJsZS4KCltmbjo4XTJNQiBiZWNhdXNlIHdlIGFy ZSBwdXR0aW5nIHRoZSBlbGYgZmlsZSBpbiB0aGVyZSB3aGljaCBjb250YWlucyBsb3RzIG9mIGV4 dHJhIGluZm9ybWF0aW9uLiBUaGUKYmluYXJ5IGl0c2VsZiBpcyB+MTcwS0IuCgpbZm46N10gVGhl IGJ1aWxkIHNjcmlwdHMgZ2VuZXJhdGVkIGJ5IHplcGh5ciBkbyBub3QgY29udGFpbiBhbiAiaW5z dGFsbCIgdGFyZ2V0IGluIHRoZSB0cmFkaXRpb25hbCBzZW5zZS4KCltmbjo2XSBJIGFtIGdvaW5n IHRvIGltcGxlbWVudCBhIHBhdGNoIHNvIHRoYXQgdGhlIHplcGh5ciBjbWFrZSBzY3JpcHRzIGNh biB3b3JrIGNvcnJlY3RseSBmcm9tCmFuIGVudmlyb25tZW50IHZhcmlhYmxlLiBUaGlzIHdpbGwg bWFrZSBjb21wb25lbnQgZGlzY292ZXJ5IHRyYW5zbGF0ZSB3ZWxsIHRvIGRldmVsb3BtZW50IGVu dmlyb25tZW50cy4KTW9yZSBvbiB0aGlzIGxhdGVyLgoKW2ZuOjVdIFJlYWQ6IGJhZAoKW2ZuOjRd IFdlc3QgaXMgdGhlIHdheSBpdCBpcyBmb3IgYSByZWFzb24uIEl0IGlzIHZlcnkgcHJhY3RpY2Fs IHRvIGRlc2lnbiB0aGUgcGFja2FnZQptYW5hZ2VyIGluIHRoaXMgd2F5IGJlY2F1c2UgaXQgZW5h YmxlcyBXaW5kb3dzIHVzZXJzIHRvIGFjY2VzcyB0aGUKYnVpbGQgZW52aXJvbm1lbnQuIEEgbW9y ZSBpbi1kZXB0aCBkaXNjdXNzaW9uIG9uIHRoZSBtYXRlcmlhbCBjb25kaXRpb25zIHdoaWNoCmxl YWQgdG8gdGhpcyBvciB0aGF0IGRlc2lnbiBkZWNpc2lvbiBvZiB0aGUgV2VzdCB0b29sIGlzIGJl eW9uZCB0aGUgc2NvcGUgb2YgdGhpcwpkb2N1bWVudC4KCltmbjoxXSBNYWtlcyBzZW5zZSBzaW5j ZSB3ZSBhcmUgaW1wbGVtZW50aW5nIHRoZW0gaGVyZS4KCi0tPS09LT0KQ29udGVudC1UeXBlOiB0 ZXh0L3BsYWluOyBjaGFyc2V0PXV0Zi04CkNvbnRlbnQtVHJhbnNmZXItRW5jb2Rpbmc6IHF1b3Rl ZC1wcmludGFibGUKCgoKCkx1ZG92aWMgQ291cnQ9QzM9QThzIDxsdWRvQGdudS5vcmc+IHdyaXRl czoKCj4gSGVsbG8gTWl0Y2hlbGwsCj4KPiBNaXRjaGVsbCBTY2htZWlzc2VyIDxtaXRjaGVsbHNj aG1laXNzZXJAbGlicmVtLm9uZT4gc2tyaWJpczoKPgo+PiBIZXJlIGlzIGEgcm91Z2ggZHJhZnQg b2YgbXkgdG9vbGNoYWluIHBvc3QuCj4+IEkgaG9wZSBpdCBjYW4gbWFrZSBhbiBpbnRlcmVzdGlu ZyBjb250cmlidXRpb24gdG8gdGhlIEd1aXggbGl0ZXJhdHVyZS4KPgo+IFlheSwgZGVmaW5pdGVs eSEKPgo+Pj5Gcm9tIDRmNmM0MzA5MWZmZDY3Y2RiYzVmMDQxZTQ5NmY2MWJjOGEwNjA3MGUgTW9u IFNlcCAxNyAwMDowMDowMCAyMDAxCj4+IEZyb206IE1pdGNoZWxsIFNjaG1laXNzZXIgPG1pdGNo ZWxsc2NobWVpc3NlckBsaWJyZW0ub25lPgo+PiBEYXRlOiBGcmksIDI0IEZlYiAyMDIzIDEzOjAy OjA1IC0wNTAwCj4+IFN1YmplY3Q6IFtQQVRDSF0gd2Vic2l0ZTogQWRkIGN1c3RvbSB0b29sY2hh aW4gYmxvZyBwb3N0Cj4+Cj4+ICogd2Vic2l0ZS9wb3N0cy9jdXN0b20tdG9vbGNoYWlucy13aXRo LWd1aXgubWQ6IE5ldyBmaWxlLgo+Cj4gVGhpcyBsb29rcyBncmVhdCB0byBtZSEgIEl0PUUyPTgw PTk5cyB1c2VmdWwgaW5zaWdodCBmb3IgYW55b25lIHdobyBtaWdodD0KIHdhbnQKPiB0byBhZGQg YSBjcm9zcy1jb21waWxhdGlvbiB0YXJnZXQgdG8gR3VpeCBvciBzaW1wbHkgbGVhcm4gaG93IHRo aXMgaXMKPiBpbXBsZW1lbnRlZC4KPgo+PiArKysgYi93ZWJzaXRlL3Bvc3RzL2N1c3RvbS10b29s Y2hhaW5zLXdpdGgtZ3VpeC5tZAo+PiBAQCAtMCwwICsxLDU1NyBAQAo+PiArIyBUYWJsZSBvZiBD b250ZW50cwo+PiArCj4+ICsxLiAgW092ZXJ2aWV3XSgjb3JnMjYzM2E1MSkKPj4gKzIuICBbQW5h dG9teSBvZiBhIHRvb2xjaGFpbl0oI29yZ2M0NDBlOWUpCj4+ICszLiAgW0Jvb3RzdHJhcHBpbmcg YSBUb29sY2hhaW5dKCNvcmdkNDJiNmMzKQo+PiArNC4gIFtEZWZpbmluZyB0aGUgUGFja2FnZXNd KCNvcmc1NTA0MmM1KQo+PiArCTEuICBbQmludXRpbHNdKCNvcmc2N2RhMWVjKQo+PiArCTIuICBb R0NDIHNhbnMgbGliY10oI29yZzgyZDZmODMpCj4+ICsJMy4gIFtOZXdsaWIoLW5hbm8pXSgjb3Jn ZjZiYWZiYykKPj4gKwk0LiAgW0NvbXBsZXRlIHRvb2xjaGFpbl0oI29yZzA1MmYyYTIpCj4+ICs1 LiAgW0ludGVncmF0aW5nIHdpdGggWmVwaHlyIEJ1aWxkIFN5c3RlbV0oI29yZ2MzZjg3ZjQpCj4+ ICsJMS4gIFtUZXN0aW5nXSgjb3JnOWYzYzMxNCkKPj4gKwo+PiArQWxsIGNvZGUgaXMgYXZhaWxh YmxlIGF0IFtndWl4LXplcGh5cl0oaHR0cHM6Ly9naXRodWIuY29tL3BhcGVyY2xpcDQ0NjU9Ci9n dWl4LXplcGh5cikgY2hhbm5lbC4KPj4gKwo+PiArCj4+ICs8YSBpZD0zRCJvcmcyNjMzYTUxIj48 L2E+Cj4KPiBZb3UgY2FuIHJlbW92ZSB0aGUgdGFibGUgb2YgY29udGVudHMgYW5kIGFsbCB0aGUg SFRNTCBzbmlwcGV0cyB0aGF0Cj4gcGFuZG9jIGFkZGVkPUUyPTgwPTk0SSBkb249RTI9ODA9OTl0 IHRoaW5rIHRoYXQgd29ya3MgYXMgZXhwZWN0ZWQgd2l0aCBIYT0KdW50L0NvbW1vbk1hcmsuCj4K Pj4gKyMgT3ZlcnZpZXcKPgo+IFlvdSBjYW4gZHJvcCB0aGUgaGVhZGluZy4KPgo+PiArSW4gb3Jk ZXIgdG8gZGVwbG95IGVtYmVkZGVkIHNvZnR3YXJlIHVzaW5nIEd1aXggd2UgZmlyc3QgbmVlZCB0 byB0ZWFjaCA9Ckd1aXgKPj4gK2hvdyB0byBidWlsZCBpdC4gU2luY2UgR3VpeCBib290c3RyYXBz IGV2ZXJ5dGhpbmcgdGhpcyBtZWFucyB3ZSBtdXN0IHRlPQphY2ggR3VpeAo+PiAraG93IHRvIGJ1 aWxkIG91ciB0b29sY2hhaW4uCj4+ICsKPj4gK1RoZSBbWmVwaHlyIFByb2plY3RdKGh0dHBzOi8v emVwaHlycHJvamVjdC5vcmcpIHVzZXMgaXRzIG93biBmb3JrIG9mIEdDPQpDIHdpdGggY3VzdG9t IGNvbmZpZ3MgZm9yCj4+ICt0aGUgYXJjaGl0ZWN0dXJlcyBzdXBwb3J0ZWQgYnkgdGhlIHByb2pl Y3QuCj4KPiBXZSB3YW50IGJsb2cgcG9zdHMgdG8gYmUgd2lkZWx5IGFjY2Vzc2libGUgc28gSSB3 b3VsZCByZWNvbW1lbmQKPiBwcm92aWRpbmcgbW9yZSBjb250ZXh0IGluIHRoZSBpbnRyby4gIElu IHBhcnRpY3VsYXIsIEk9RTI9ODA9OTlkIHN1Z2dlc3Q6Cj4KPiAgIDEuIE1lbnRpb25pbmcgdGhh dCBHdWl4IHN1cHBvcnRzIGNyb3NzLWNvbXBpbGF0aW9uIChub3QgZXZlcnlvbmUgaXMKPiAgICAg IGF3YXJlIG9mIHRoYXQpLCB3aXRoIGEgbGluayB0bwo+ICAgICAgPGh0dHBzOi8vZ3VpeC5nbnUu b3JnL2VuL21hbnVhbC9lbi9odG1sX25vZGUvQ3Jvc3NfMDAyZENvbXBpbGF0aW9uLmg9CnRtbD4u Cj4KPiAgIDIuIEFkZGluZyBhIGNvdXBsZSBvZiBzZW50ZW5jZXMgc2F5aW5nIHdoYXQgWmVwaHly IGlzIChJIGRpZG49RTI9ODA9OTl0PQoga25vdwo+ICAgICAgYWJvdXQgaXQgYmVmb3JlIDotKSku Cj4KPiAgIDMuIFNheWluZyBhIGZldyB3b3JkcyBhcyB0byB3aHkgWmVwaHlyIHVzZXMgYSBHQ0Mg Zm9yay4KPgo+ICAgNC4gQ2xlYXJseSBzdGF0aW5nIHRoYXQgeW91IGFkZGVkIHN1cHBvcnQgZm9y IGNyb3NzLWNvbXBpbGF0aW9uIHRvCj4gICAgICBaZXBoeXIgd2l0aCBHdWl4IGluIGEgY2hhbm5l bCwgbGlua2luZyB0byBzYWlkIGNoYW5uZWwsIGFuZCB0aGF0Cj4gICAgICB0aGlzIGlzIHdoYXQg dGhlIHJlbWFpbmRlciBvZiB0aGUgcG9zdCB3aWxsIGRlc2NyaWJlLgo+Cj4gWW91IGNhbiBjaGVj ayBvdXQgcG9zdHMgYXQgPGh0dHBzOi8vZ3VpeC5nbnUub3JnL2Jsb2c+IGZvciBpbnNwaXJhdGlv bi4KPgo+PiArIyBBbmF0b215IG9mIGEgdG9vbGNoYWluCj4+ICsKPj4gK1Rvb2xjaGFpbnMgYXJl IHJlc3BvbnNpYmxlIGZvciB0YWtpbmcgaGlnaCBsZXZlbCBkZXNjcmlwdGlvbnMgb2YgcHJvZ3Jh PQptcwo+PiArYW5kIGxvd2VyaW5nIHRoZW0gZG93biB0byBhIHNlcmllcyBvZiBlcXVpdmFsZW50 IG1hY2hpbmUgaW5zdHJ1Y3Rpb25zLgo+PiArVGhpcyBwcm9jZXNzIGludm9sdmVzIG1vcmUgdGhh biBqdXN0IGEgY29tcGlsZXIuIFRoZSBjb21waWxlciB1c2VzIHRoZSA9CmBiaW51dGlsc2AKPj4g K3RvIG1hbmlwdWxhdGUgaXQncyBpbnRlcm5hbCByZXByZXNlbnRhdGlvbiBkb3duIHRvIGEgZ2l2 ZW4gYXJjaGl0ZWN0dXJlLgo+PiArSXQgYWxzbyBuZWVkcyB0aGUgdXNlIG9mIHRoZSBDIHN0YW5k YXJkIGxpYnJhcnkgYXMgd2VsbCBhcyBhIGZldyBvdGhlciA9CmxpYnJhcmllcwo+PiArbmVlZGVk IGZvciBzb21lIGNvbXBpbGVyIG9wdGltaXphdGlvbnMuCj4+ICsKPj4gK1RoZSBDIGxpYnJhcnkg cHJvdmlkZXMgdGhlIGludGVyZmFjZSB0byB0aGUgdW5kZXJseWluZyBrZXJuZWwuIFN5c3RlbSBj PQphbGxzIGxpa2UgYHdyaXRlYAo+PiArYW5kIGByZWFkYCBhcmUgcHJvdmlkZWQgYnkgYEdsaWJj YCBvbiBtb3N0IExpbnV4IGRpc3RyaWJ1dGlvbnMuCj4+Cj4+ICtJbiBlbWJlZGRlZCBzeXN0ZW1z IHNtYWxsZXIgaW1wbGVtZW50YXRpb25zIGxpa2UgYG5ld2xpYmAgYW5kIGBuZXdsaWItbj0KYW5v YCBhcmUgdXNlZC4KPgo+IEk9RTI9ODA9OTlkIHN1Z2dlc3Qgbm90IHVzaW5nIGZpeGVkLXdpZHRo IGZvbnQgKGJhY2txdW90ZXMpIGZvciBwcm9wZXIgbm89CnVuczsKPiB5b3UgY2FuIHdyaXRlID1F Mj04MD05Q2dsaWJjPUUyPTgwPTlEIG9yID1FMj04MD05Q3RoZSBHTlUgQyBMaWJyYXJ5IChnbGli PQpjKT1FMj04MD05RCwgPUUyPTgwPTlDQmludXRpbHM9RTI9ODA9OUQgb3IgPUUyPTgwPTlDdGhl Cj4gR05VIEJpbmFyeSBVdGlsaXRpZXMgKEJpbnV0aWxzKT1FMj04MD05RCwgZXRjLgo+Cj4+ICtG aXJzdCB0aGluZyB3ZSBuZWVkIHRvIGJ1aWxkIGlzIHRoZSBgYXJtLXplcGh5ci1lYWJpYCBiaW51 dGlscy4KPj4gK1RoaXMgaXMgdmVyeSBlYXN5IGluIEd1aXguCj4+ICsKPj4gKwkoZGVmaW5lLW1v ZHVsZSAoemVwaHlyIHBhY2thZ2VzIHplcGh5cikKPj4gKwkgICM6dXNlLW1vZHVsZSAoZ3VpeCBw YWNrYWdlcykpCj4+ICsKPj4gKwkoZGVmaW5lLXB1YmxpYyBhcm0temVwaHlyLWVhYmktYmludXRp bHMKPj4gKwkgIChsZXQgKCh4YmludXRpbHMgKGNyb3NzLWJpbnV0aWxzICJhcm0temVwaHlyLWVh YmkiKSkpCj4+ICsJCShwYWNrYWdlCj4+ICsJCSAgKGluaGVyaXQgeGJpbnV0aWxzKQo+PiArCQkg IChuYW1lICJhcm0temVwaHlyLWVhYmktYmludXRpbHMiKQo+PiArCQkgICh2ZXJzaW9uICIyLjM4 IikKPj4gKwkJICAoc291cmNlCj4+ICsJCSAgIChvcmlnaW4gKG1ldGhvZCBnaXQtZmV0Y2gpCj4+ ICsJCQkJICAgKHVyaSAoZ2l0LXJlZmVyZW5jZQo+PiArCQkJCQkJICh1cmwgImh0dHBzOi8vZ2l0 aHViLmNvbS96ZXBoeXJwcm9qZWN0LXJ0b3MvYmludXRpbHMtZ2RiIikKPj4gKwkJCQkJCSAoY29t bWl0ICI2YTFiZTFhNmE1NzE5NTdmZWE4YjEzMGU0Y2EyZGNjNjVlNzUzNDY5IikpKQo+PiArCQkJ CSAgIChmaWxlLW5hbWUgKGdpdC1maWxlLW5hbWUgbmFtZSB2ZXJzaW9uKSkKPj4gKwkJCQkgICAo c2hhMjU2IChiYXNlMzIgIjB5bG5sNDhqajVqazNqcm12Zng1emY4Ynl2d2c3ZzdteTdqd3d5cXcz YTk1cWN5PQpoMGlzciIpKSkpCj4+ICsJCSAgKGFyZ3VtZW50cwo+PiArCQkgICBgKCM6dGVzdHM/ ICNmCj4+ICsJCQkgLEAoc3Vic3RpdHV0ZS1rZXl3b3JkLWFyZ3VtZW50cyAocGFja2FnZS1hcmd1 bWVudHMgeGJpbnV0aWxzKQo+PiArCQkJCSAoKCM6Y29uZmlndXJlLWZsYWdzIGZsYWdzKQo+PiAr CQkJCSAgYChjb25zICItLXByb2dyYW0tcHJlZml4PTNEYXJtLXplcGh5ci1lYWJpLSIgLGZsYWdz KSkpKSkKPj4gKwkJICAobmF0aXZlLWlucHV0cwo+PiArCQkgICAoYXBwZW5kCj4+ICsJCQkobGlz dCB0ZXhpbmZvCj4+ICsJCQkJICBiaXNvbgo+PiArCQkJCSAgZmxleAo+PiArCQkJCSAgZ21wCj4+ ICsJCQkJICBkZWphZ251KQo+PiArCQkJKHBhY2thZ2UtbmF0aXZlLWlucHV0cyB4YmludXRpbHMp KSkKPj4gKwkJICAoaG9tZS1wYWdlICJodHRwczovL3plcGh5cnByb2plY3Qub3JnIikKPj4gKwkJ ICAoc3lub3BzaXMgImJpbnV0aWxzIGZvciB6ZXBoeXIgUlRPUyIpKSkpCj4KPiBDb2RlIHNuaXBw ZXRzIHNob3VsZCBiZSB3cml0dGVuIGxpa2UgdGhpcywgd2l0aG91dCBsZWFkaW5nIGluZGVudGF0 aW9uOgo+Cj4gICBgYGBzY2hlbWUKPiAgIChkZWZpbmUgPUUyPTgwPUE2KQo+ICAgYGBgCj4KPiBU aGlzIHdpbGwgZW5hYmxlIHN5bnRheCBoaWdobGlnaHRpbmcuCj4KPj4gK1dlIGNhbiB0ZXN0IG91 ciBwYWNrYWdlIGRlZmluaXRpb24gdXNpbmcgdGhlIGAtTGAgZmxhZyB3aXRoIGBndWl4IGJ1aWxk YAo+PiArdG8gYWRkIG91ciBwYWNrYWdlcy4KPj4gKwo+PiArCWd1aXggYnVpbGQgLUwgZ3VpeC16 ZXBoeXIgemVwaHlyLWJpbnV0aWxzCj4+ICsKPj4gKwkvZ251L3N0b3JlLy4uLi16ZXBoeXItYmlu dXRpbHMtMi4zOAo+Cj4gTGlrZXdpc2U6Cj4KPiAgIGBgYAo+ICAgZ3VpeCBidWlsZCBmb28KPiAg IGBgYAo+Cj4+ICsjIEludGVncmF0aW5nIHdpdGggWmVwaHlyIEJ1aWxkIFN5c3RlbQo+PiArCj4+ ICtaZXBoeXIgdXNlcyBDTWFrZSBhcyBpdCdzIGJ1aWxkIHN5c3RlbS4gSXQgY29udGFpbnMgbnVt ZXJvdXMgQ01ha2UKPgo+IHMvaXQncy9pdHMvCj4KPiBPbmUgdGhpbmcgdGhhdD1FMj04MD05OXMg bm90IGNsZWFyIHRvIG1lOiB3aXRoIHRoaXMgaW4gcGxhY2UsIGNhbiB5b3UgZG8gPQo9RTI9ODA9 OUNndWl4Cj4gYnVpbGQgLS10YXJnZXQ9M0Rhcm0temVwaHlyLWVhYmkgaGVsbG89RTI9ODA9OUQs IGZvciBpbnN0YW5jZT8gIElmIG5vdCwgdz0KaGF0PUUyPTgwPTk5cwo+IG1pc3NpbmcgdG8gc3Vw cG9ydCBpdD8KPgo+IEl0IHdvdWxkIGJlIGdyZWF0IGlmIHlvdSBjb3VsZCBmaW5pc2ggd2l0aCBh IHNob3J0IGNvbmNsdXNpb24gc3RhdGluZywKPiBmb3IgaW5zdGFuY2UsIHRoZSBrZXkgdGFrZWF3 YXkgbWVzc2FnZSwgbGVzc29ucyBsZWFybmVkLCBhbmQvb3IgeW91cgo+IHRob3VnaHRzIG9uIGhv dyB0aGlzIGNvdWxkIGJlbmVmaXQgb3RoZXJzIGluIHRoZSBicm9hZGVyIGNvbW11bml0eS4KPgo+ IEkgd29uZGVyIGlmIGl0IHdvdWxkIGJlIHdvcnRoIG1lbnRpb25pbmcKPiA8aHR0cHM6Ly9ndWl4 LmdudS5vcmcvbWFudWFsL2VuL2h0bWxfbm9kZS9QbGF0Zm9ybXMuaHRtbD4gdG9vLCBhbmQgaG93 Cj4gb25lIHdvdWxkIGdvIGFib3V0IGFkZGluZyBhICBtb2R1bGUuICBXRFlUPwo+Cj4gQ291bGQg eW91IHNlbmQgYW4gdXBkYXRlZCBwYXRjaD8KPgo+IFRoYW5rcyBmb3IgY29udHJpYnV0aW5nIHRo aXMgYXJ0aWNsZSEKPgo+IEx1ZG89RTI9ODA9OTkuCgotLT0tPS09LS0K From debbugs-submit-bounces@debbugs.gnu.org Sat Mar 11 07:12:07 2023 Received: (at 61765) by debbugs.gnu.org; 11 Mar 2023 12:12:07 +0000 Received: from localhost ([127.0.0.1]:56705 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pay50-0006Jc-PS for submit@debbugs.gnu.org; Sat, 11 Mar 2023 07:12:07 -0500 Received: from eggs.gnu.org ([209.51.188.92]:43146) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pay4y-0006Ik-Ce for 61765@debbugs.gnu.org; Sat, 11 Mar 2023 07:12:04 -0500 Received: from fencepost.gnu.org ([2001:470:142:3::e]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pay4s-00087X-Mr; Sat, 11 Mar 2023 07:11:58 -0500 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnu.org; s=fencepost-gnu-org; h=MIME-Version:In-Reply-To:Date:References:Subject:To: From; bh=1XYzJ/74Yn+BB7fAh5PLTRCuG/RiZQjDdIY2Xp3HvDo=; b=rU77wIu5o9mkCc9eePLi dL4nJqOdXBf47UbYEPCnBCVD1dBbaRsVy3W+586uyop0kzHeY7FHEaaXs8P2LQfJOm7MadDguAy5g gGNRWzlHwec/pCdlx8JhuMrc5O7L8ORbs8l8szSkKsoma2FY5NCcn20GtcSdzSDy+KL9aeZyHJAle TLB9AkT2gtOfUKTzNSTd+PATCrTwGKo+cZGMER5FnHXvjDFyaxRE2/+d1TOl8EqW4LHeQ7wcqp4CG vsH744q837QJX3p6TU1rcJKgDBW0qXgDTgv4VUzIIs/7yF8rPuf/MBZkaoBSiHFzolY3X6Kroqqds XlBNYPuaQqX71w==; Received: from 91-160-117-201.subs.proxad.net ([91.160.117.201] helo=ribbon) by fencepost.gnu.org with esmtpsa (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pay4s-0007aA-AC; Sat, 11 Mar 2023 07:11:58 -0500 From: =?utf-8?Q?Ludovic_Court=C3=A8s?= To: Mitchell Schmeisser Subject: Re: bug#61765: custom toolchain blog post References: <87sfeuucab.fsf@librem.one> <87fsarmfw6.fsf@gnu.org> <87k003xgs0.fsf@librem.one> X-URL: http://www.fdn.fr/~lcourtes/ X-Revolutionary-Date: Primidi 21 =?utf-8?Q?Vent=C3=B4se?= an 231 de la =?utf-8?Q?R=C3=A9volution=2C?= jour de la Mandragore X-PGP-Key-ID: 0x090B11993D9AEBB5 X-PGP-Key: http://www.fdn.fr/~lcourtes/ludovic.asc X-PGP-Fingerprint: 3CE4 6455 8A84 FDC6 9DB4 0CFB 090B 1199 3D9A EBB5 X-OS: x86_64-pc-linux-gnu Date: Sat, 11 Mar 2023 13:11:55 +0100 In-Reply-To: <87k003xgs0.fsf@librem.one> (Mitchell Schmeisser's message of "Mon, 27 Feb 2023 10:35:43 -0500") Message-ID: <87zg8jwkqc.fsf@gnu.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/28.2 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 61765 Cc: 61765@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Hi Mitchel, (Please keep the issue Cc=E2=80=99d.) Apologies for the delay! Mitchell Schmeisser skribis: >> One thing that=E2=80=99s not clear to me: with this in place, can you do= =E2=80=9Cguix >> build --target=3Darm-zephyr-eabi hello=E2=80=9D, for instance? If not, = what=E2=80=99s >> missing to support it? > > You cannot. I do not know how to describe it in a succinct way but > suffice to say the applications need to know they are targeting Zephyr > when they are written. The application will include a `prj.conf` which > is analogous to a custom defconfig in the Linux kernel. > Either in this file, or somewhere in the CMakeLists.txt a `BOARD` > variable is set to specify a specific board definition. > These board definitions contain information about the architecture and > the CMake scripts themselves pick the toolchain. > > It's not that it's impossible to implement something like `guix build > --target=3Darm-zephyr-eabi k64f-hello-world` but the k64f-hello-world > would be written in such a way that the target is implicit in the > package. OK. To put it differently, a typical POSIX program won=E2=80=99t work on Zephyr; programs have to target the Zephyr interfaces, right? > The way I envision the `--target/system` flags being used in this > context is `guix build --target=3Darm-linux-gnueabihf k64f-hello-world` > which will still produce the correct firmware but will allow the > firmware to be staged to another machine which will be responsible for > the final deployment over some transport. Or rather: guix build --target=3Darm-zephyr-eabi k64f-hello-world ? >> I wonder if it would be worth mentioning >> too, and how >> one would go about adding a module. WDYT? > > I considered trying to add Zephyr platforms but I'm not sure it's worth > the effort. > In addition to the patch to the website I attached another post(in org) > which describes how I integrated this toolchain into the Guix > infrastructure to allow defining firmware packages. > Maybe there will be additional information in there which can help you > understand where I'm going with all of this. > > There will be a part 3 (and possibly more) about how to practically use > this stuff in a real project. Woow. :-) > From 0920ec7d951354c94c3da277d58e54b587522622 Mon Sep 17 00:00:00 2001 > From: Mitchell Schmeisser > Date: Mon, 27 Feb 2023 10:20:32 -0500 > Subject: [PATCH] website: Add toolchain blog post > > website/blog/custom-toolchains-with-guix.md: New file I pushed it under the drafts directory for now, to leave others a bit more time to comment before we publish. I followed up with a commit editing things a bit, mostly fixing typographical issues, spelling/capitalization, code formatting, and removing tabs. https://git.savannah.gnu.org/cgit/guix/guix-artwork.git/tree/website/draf= ts/custom-toolchains-with-guix.md (BTW, I made slight modifications to some of the code snippets to! One package was using (append (list =E2=80=A6) (package-native-inputs =E2=80=A6= )), which really works =E2=80=9Cby chance=E2=80=9D I guess; you should use =E2=80=98m= odify-inputs=E2=80=99 instead.) Let me know if anything=E2=80=99s amiss! Thanks, Ludo=E2=80=99. From debbugs-submit-bounces@debbugs.gnu.org Sat Mar 11 11:50:43 2023 Received: (at 61765) by debbugs.gnu.org; 11 Mar 2023 16:50:43 +0000 Received: from localhost ([127.0.0.1]:58543 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pb2Qc-00020J-Av for submit@debbugs.gnu.org; Sat, 11 Mar 2023 11:50:43 -0500 Received: from mx1.librem.one ([138.201.176.93]:40354) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pb2QZ-000206-Uf for 61765@debbugs.gnu.org; Sat, 11 Mar 2023 11:50:40 -0500 Received: from smtp.librem.one (unknown [192.241.214.14]) by mx1.librem.one (Postfix) with ESMTPS id 132B981E8D; Sat, 11 Mar 2023 08:50:32 -0800 (PST) Authentication-Results: name mx1.librem.one; dmarc=fail (p=reject dis=none) header.from=librem.one Content-Type: multipart/alternative; boundary=Apple-Mail-C0B47D03-9E84-4226-8125-A6AD6DAB625D Content-Transfer-Encoding: 7bit From: Mitchell Schmeisser Subject: Re: bug#61765: custom toolchain blog post Date: Sat, 11 Mar 2023 11:50:28 -0500 Message-Id: References: <87zg8jwkqc.fsf@gnu.org> In-Reply-To: <87zg8jwkqc.fsf@gnu.org> To: =?utf-8?Q?Ludovic_Court=C3=A8s?= X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 61765 Cc: 61765@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) --Apple-Mail-C0B47D03-9E84-4226-8125-A6AD6DAB625D Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Hi Ludo, >=20 > OK. To put it differently, a typical POSIX program won=E2=80=99t work on > Zephyr; programs have to target the Zephyr interfaces, right? This is mostly correct. I think a lot of my conceptual difficulties come fro= m the fact that west/zephyr try to tackle the issues of software deployment a= nd dependency management at the project level. What I mean to say is that in= the rest of the software world we have things like auto tools or pkg-config= to help with component composition but Zephyr tries to do all composition t= hrough several thousands of lines of cmake. Every bit as complex as the kern= el kconfig but even more so since modules can be scattered across the file s= ystem. One of the selling points of zephyr is that your application is abstracted f= rom the hardware and can run on multiple boards without modification. Howeve= r to make this happen you need to do a lot of work on the application side.=20= Below you can see an example. You have to provide the proper kernel config f= or every target you want to support. https://github.com/zephyrproject-rtos/zephyr/tree/main/samples/net/mqtt_publ= isher Using guix there may be a more elegant solution to these problems but maybe n= ot. Thank you for all your feedback, Mitchell > On Mar 11, 2023, at 7:12 AM, Ludovic Court=C3=A8s wrote: >=20 > =EF=BB=BFHi Mitchel, >=20 > (Please keep the issue Cc=E2=80=99d.) >=20 > Apologies for the delay! >=20 > Mitchell Schmeisser skribis: >=20 >>> One thing that=E2=80=99s not clear to me: with this in place, can you do= =E2=80=9Cguix >>> build --target=3Darm-zephyr-eabi hello=E2=80=9D, for instance? If not, w= hat=E2=80=99s >>> missing to support it? >>=20 >> You cannot. I do not know how to describe it in a succinct way but >> suffice to say the applications need to know they are targeting Zephyr >> when they are written. The application will include a `prj.conf` which >> is analogous to a custom defconfig in the Linux kernel. >> Either in this file, or somewhere in the CMakeLists.txt a `BOARD` >> variable is set to specify a specific board definition. >> These board definitions contain information about the architecture and >> the CMake scripts themselves pick the toolchain. >>=20 >> It's not that it's impossible to implement something like `guix build >> --target=3Darm-zephyr-eabi k64f-hello-world` but the k64f-hello-world >> would be written in such a way that the target is implicit in the >> package. >=20 > OK. To put it differently, a typical POSIX program won=E2=80=99t work on > Zephyr; programs have to target the Zephyr interfaces, right? >=20 >> The way I envision the `--target/system` flags being used in this >> context is `guix build --target=3Darm-linux-gnueabihf k64f-hello-world` >> which will still produce the correct firmware but will allow the >> firmware to be staged to another machine which will be responsible for >> the final deployment over some transport. >=20 > Or rather: >=20 > guix build --target=3Darm-zephyr-eabi k64f-hello-world >=20 > ? >=20 >>> I wonder if it would be worth mentioning >>> too, and how >>> one would go about adding a module. WDYT? >>=20 >> I considered trying to add Zephyr platforms but I'm not sure it's worth >> the effort. >> In addition to the patch to the website I attached another post(in org) >> which describes how I integrated this toolchain into the Guix >> infrastructure to allow defining firmware packages. >> Maybe there will be additional information in there which can help you >> understand where I'm going with all of this. >>=20 >> There will be a part 3 (and possibly more) about how to practically use >> this stuff in a real project. >=20 > Woow. :-) >=20 >> =46rom 0920ec7d951354c94c3da277d58e54b587522622 Mon Sep 17 00:00:00 2001 >> From: Mitchell Schmeisser >> Date: Mon, 27 Feb 2023 10:20:32 -0500 >> Subject: [PATCH] website: Add toolchain blog post >>=20 >> website/blog/custom-toolchains-with-guix.md: New file >=20 > I pushed it under the drafts directory for now, to leave others a bit > more time to comment before we publish. I followed up with a commit > editing things a bit, mostly fixing typographical issues, > spelling/capitalization, code formatting, and removing tabs. >=20 > https://git.savannah.gnu.org/cgit/guix/guix-artwork.git/tree/website/draf= ts/custom-toolchains-with-guix.md >=20 > (BTW, I made slight modifications to some of the code snippets to! One > package was using (append (list =E2=80=A6) (package-native-inputs =E2=80=A6= )), which > really works =E2=80=9Cby chance=E2=80=9D I guess; you should use =E2=80=98= modify-inputs=E2=80=99 > instead.) >=20 > Let me know if anything=E2=80=99s amiss! >=20 > Thanks, > Ludo=E2=80=99. --Apple-Mail-C0B47D03-9E84-4226-8125-A6AD6DAB625D Content-Type: text/html; charset=utf-8 Content-Transfer-Encoding: quoted-printable Hi Ludo,

OK.  To put it differently, a t= ypical POSIX program won=E2=80=99t work on
Zephyr; programs have to targe= t the Zephyr interfaces, right?
This is mostly c= orrect. I think a lot of my conceptual difficulties come from the fact that w= est/zephyr try to tackle the issues of software deployment and dependency ma= nagement at the project level. What I mean to say is that in the rest of the= software world we have things like auto tools or pkg-config to help with co= mponent composition but Zephyr tries to do all composition through several t= housands of lines of cmake. Every bit as complex as the kernel kconfig but e= ven more so since modules can be scattered across the file system.
One of the selling points of zephyr is that your application is abstracted f= rom the hardware and can run on multiple boards without modification. Howeve= r to make this happen you need to do a lot of work on the application side.&= nbsp;
Below you can see an example. You have to provide the proper= kernel config for every target you want to support.

Using g= uix there may be a more elegant solution to these problems but maybe not.

Thank you for all your feedba= ck,
Mitchell


On Mar 11, 2023, at 7:12 AM, Ludovic Cou= rt=C3=A8s <ludo@gnu.org> wrote:

=EF=BB=BFHi Mitchel,

(Please keep the issue Cc=E2=80=99d.)
<= br>Apologies for the delay!

Mitchell S= chmeisser <mitchellschmeisser@librem.one> skribis:

One thing t= hat=E2=80=99s not clear to me: with this in place, can you do =E2=80=9Cguix<= /span>
build --target=3Darm-zephyr-eabi hello=E2=80=9D, for insta= nce?  If not, what=E2=80=99s
missing to support it?
You cannot. I do not know how= to describe it in a succinct way but
suffice to say the applications need to know they are targe= ting Zephyr
when they= are written. The application will include a `prj.conf` which
is analogous to a custom defconfig i= n the Linux kernel.
E= ither in this file, or somewhere in the CMakeLists.txt a `BOARD`
<= /blockquote>
variable is set to specify a spe= cific board definition.
These board definitions contain information about the architecture and
the CMake scripts thems= elves pick the toolchain.
<= span>
It's not that i= t's impossible to implement something like `guix build
--target=3Darm-zephyr-eabi k64f-hello-worl= d` but the k64f-hello-world
would be written in such a way that the target is implicit in the
package.

OK.  To put it differently, a typical PO= SIX program won=E2=80=99t work on
Zephyr; programs have to t= arget the Zephyr interfaces, right?

The way I envision the `--target/system` flags being used= in this
context is `= guix build --target=3Darm-linux-gnueabihf k64f-hello-world`
which will still produce the correct f= irmware but will allow the
= firmware to be staged to another machine which will be responsible for=
the final deployment= over some transport.

Or rathe= r:

 guix build --target=3Darm-zephyr-= eabi k64f-hello-world

?

I wonder i= f it would be worth mentioning
<https://guix.gnu.org/ma= nual/en/html_node/Platforms.html> too, and how
one woul= d go about adding a  module.  WDYT?

I considered trying to add Zephyr platforms but I'm not su= re it's worth
the eff= ort.
In addition to t= he patch to the website I attached another post(in org)
which describes how I integrated this too= lchain into the Guix
= infrastructure to allow defining firmware packages.
<= blockquote type=3D"cite">Maybe there will be additional information in= there which can help you
<= span>understand where I'm going with all of this.

There will be a part 3 (and possibly more) about how to practically= use
this stuff in a r= eal project.

Woow.  :-)

=46rom 0920ec7d951= 354c94c3da277d58e54b587522622 Mon Sep 17 00:00:00 2001
From: Mitchell Schmeisser <mitchellschm= eisser@librem.one>
Date: Mon, 27 Feb 2023 10:20:32 -0500
Subject: [PATCH] website: Add toolchain blog post

website/blog/custom-toolchains-with-guix.md: New f= ile

I pushed it under the draf= ts directory for now, to leave others a bit
more time to com= ment before we publish.  I followed up with a commit
ed= iting things a bit, mostly fixing typographical issues,
spel= ling/capitalization, code formatting, and removing tabs.

 https://git.savannah.gnu.org/cgit/guix/guix-artwork.git= /tree/website/drafts/custom-toolchains-with-guix.md
<= br>(BTW, I made slight modifications to some of the code snippets to! &= nbsp;One
package was using (append (list =E2=80=A6) (package= -native-inputs =E2=80=A6)), which
really works =E2=80=9Cby c= hance=E2=80=9D I guess; you should use =E2=80=98modify-inputs=E2=80=99
instead.)

Let me know if anythin= g=E2=80=99s amiss!

Thanks,
= Ludo=E2=80=99.
= --Apple-Mail-C0B47D03-9E84-4226-8125-A6AD6DAB625D-- From debbugs-submit-bounces@debbugs.gnu.org Mon Mar 13 09:52:45 2023 Received: (at 61765) by debbugs.gnu.org; 13 Mar 2023 13:52:46 +0000 Received: from localhost ([127.0.0.1]:33938 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pbibV-0005ET-2N for submit@debbugs.gnu.org; Mon, 13 Mar 2023 09:52:45 -0400 Received: from mx1.librem.one ([138.201.176.93]:59734) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pbibS-0005EE-7S for 61765@debbugs.gnu.org; Mon, 13 Mar 2023 09:52:43 -0400 Received: from smtp.librem.one (unknown [192.241.214.14]) by mx1.librem.one (Postfix) with ESMTPS id 1C64881E79; Mon, 13 Mar 2023 06:52:36 -0700 (PDT) Authentication-Results: name mx1.librem.one; dmarc=fail (p=reject dis=none) header.from=librem.one Content-Type: multipart/mixed; boundary="------------clpwK2anZkV7f4pX2Ft0XkOD" Message-ID: Date: Mon, 13 Mar 2023 09:52:32 -0400 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Thunderbird/102.6.0 Subject: Re: bug#61765: custom toolchain blog post Content-Language: en-US To: =?UTF-8?Q?Ludovic_Court=c3=a8s?= References: <87sfeuucab.fsf@librem.one> <87fsarmfw6.fsf@gnu.org> <87k003xgs0.fsf@librem.one> <87zg8jwkqc.fsf@gnu.org> From: Mitchell Schmeisser In-Reply-To: <87zg8jwkqc.fsf@gnu.org> X-Spam-Score: -1.0 (-) X-Debbugs-Envelope-To: 61765 Cc: 61765@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -2.0 (--) This is a multi-part message in MIME format. --------------clpwK2anZkV7f4pX2Ft0XkOD Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Here are two patches with minor fixes. Sorry about the code formatting... Does anyone have any tips for getting emacs to format scheme code in markdown? Thanks, Mitchell On 3/11/23 07:11, Ludovic Courtès wrote: > Hi Mitchel, > > (Please keep the issue Cc’d.) > > Apologies for the delay! > > Mitchell Schmeisser skribis: > >>> One thing that’s not clear to me: with this in place, can you do “guix >>> build --target=arm-zephyr-eabi hello”, for instance? If not, what’s >>> missing to support it? >> You cannot. I do not know how to describe it in a succinct way but >> suffice to say the applications need to know they are targeting Zephyr >> when they are written. The application will include a `prj.conf` which >> is analogous to a custom defconfig in the Linux kernel. >> Either in this file, or somewhere in the CMakeLists.txt a `BOARD` >> variable is set to specify a specific board definition. >> These board definitions contain information about the architecture and >> the CMake scripts themselves pick the toolchain. >> >> It's not that it's impossible to implement something like `guix build >> --target=arm-zephyr-eabi k64f-hello-world` but the k64f-hello-world >> would be written in such a way that the target is implicit in the >> package. > OK. To put it differently, a typical POSIX program won’t work on > Zephyr; programs have to target the Zephyr interfaces, right? > >> The way I envision the `--target/system` flags being used in this >> context is `guix build --target=arm-linux-gnueabihf k64f-hello-world` >> which will still produce the correct firmware but will allow the >> firmware to be staged to another machine which will be responsible for >> the final deployment over some transport. > Or rather: > > guix build --target=arm-zephyr-eabi k64f-hello-world > > ? > >>> I wonder if it would be worth mentioning >>> too, and how >>> one would go about adding a module. WDYT? >> I considered trying to add Zephyr platforms but I'm not sure it's worth >> the effort. >> In addition to the patch to the website I attached another post(in org) >> which describes how I integrated this toolchain into the Guix >> infrastructure to allow defining firmware packages. >> Maybe there will be additional information in there which can help you >> understand where I'm going with all of this. >> >> There will be a part 3 (and possibly more) about how to practically use >> this stuff in a real project. > Woow. :-) > >> From 0920ec7d951354c94c3da277d58e54b587522622 Mon Sep 17 00:00:00 2001 >> From: Mitchell Schmeisser >> Date: Mon, 27 Feb 2023 10:20:32 -0500 >> Subject: [PATCH] website: Add toolchain blog post >> >> website/blog/custom-toolchains-with-guix.md: New file > I pushed it under the drafts directory for now, to leave others a bit > more time to comment before we publish. I followed up with a commit > editing things a bit, mostly fixing typographical issues, > spelling/capitalization, code formatting, and removing tabs. > > https://git.savannah.gnu.org/cgit/guix/guix-artwork.git/tree/website/drafts/custom-toolchains-with-guix.md > > (BTW, I made slight modifications to some of the code snippets to! One > package was using (append (list …) (package-native-inputs …)), which > really works “by chance” I guess; you should use ‘modify-inputs’ > instead.) > > Let me know if anything’s amiss! > > Thanks, > Ludo’. --------------clpwK2anZkV7f4pX2Ft0XkOD Content-Type: text/x-patch; charset=UTF-8; name="0001-website-custom-toolchains-with-guix-Code-fix.patch" Content-Disposition: attachment; filename="0001-website-custom-toolchains-with-guix-Code-fix.patch" Content-Transfer-Encoding: base64 RnJvbSAwZjZjMjgzNDVhNTFlMjAwMDRiYzE2YjczYmRhMWMwZTVjY2I3ZjRjIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNaXRjaGVsbCBTY2htZWlzc2VyIDxtaXRjaGVsbHNj aG1laXNzZXJAbGlicmVtLm9uZT4KRGF0ZTogTW9uLCAxMyBNYXIgMjAyMyAwOTozNjozNiAt MDQwMApTdWJqZWN0OiBbUEFUQ0ggMS8yXSB3ZWJzaXRlOiBjdXN0b20tdG9vbGNoYWlucy13 aXRoLWd1aXg6IENvZGUgZml4CgoqIHdlYnNpdGUvZHJhZnRzL2N1c3RvbS10b29sY2hhaW5z LXdpdGgtZ3VpeC5tZDogUmVtb3ZlZCB1bm5lY2Vzc2FyeQpuYXRpdmUtaW5wdXRzIGZyb20g Z2NjLWFybS16ZXBoeXItZWFiaS10b29sY2hhaW4gY29kZSBibG9jay4KLS0tCiB3ZWJzaXRl L2RyYWZ0cy9jdXN0b20tdG9vbGNoYWlucy13aXRoLWd1aXgubWQgfCAxNzYgKysrKysrKysr LS0tLS0tLS0tCiAxIGZpbGUgY2hhbmdlZCwgODQgaW5zZXJ0aW9ucygrKSwgOTIgZGVsZXRp b25zKC0pCgpkaWZmIC0tZ2l0IGEvd2Vic2l0ZS9kcmFmdHMvY3VzdG9tLXRvb2xjaGFpbnMt d2l0aC1ndWl4Lm1kIGIvd2Vic2l0ZS9kcmFmdHMvY3VzdG9tLXRvb2xjaGFpbnMtd2l0aC1n dWl4Lm1kCmluZGV4IGNiYzQ5MWYuLmZiNDkxYzYgMTAwNjQ0Ci0tLSBhL3dlYnNpdGUvZHJh ZnRzL2N1c3RvbS10b29sY2hhaW5zLXdpdGgtZ3VpeC5tZAorKysgYi93ZWJzaXRlL2RyYWZ0 cy9jdXN0b20tdG9vbGNoYWlucy13aXRoLWd1aXgubWQKQEAgLTE5NSw5OCArMTk1LDkwIEBA IGNvbW1pdHMgdG8gdXNlIGZvciBlYWNoIG9mIHRoZSB0b29scykuCiBgYGBzY2hlbWUKIChk ZWZpbmUtcHVibGljIGdjYy1hcm0temVwaHlyLWVhYmktMTIKICAgKGxldCAoKHhnY2MgKGNy b3NzLWdjYyAiYXJtLXplcGh5ci1lYWJpIgotICAgICAgICAgICAgICAgICAgICAgICAgICM6 eGJpbnV0aWxzIHplcGh5ci1iaW51dGlscykpKQotICAgIChwYWNrYWdlCi0gICAgICAoaW5o ZXJpdCB4Z2NjKQotICAgICAgKHZlcnNpb24gIjEyLjEuMCIpCi0gICAgICAoc291cmNlIChv cmlnaW4KLSAgICAgICAgICAgICAgICAobWV0aG9kIGdpdC1mZXRjaCkKLSAgICAgICAgICAg ICAgICAodXJpIChnaXQtcmVmZXJlbmNlCi0gICAgICAgICAgICAgICAgICAgICAgKHVybCAi aHR0cHM6Ly9naXRodWIuY29tL3plcGh5cnByb2plY3QtcnRvcy9nY2MiKQotICAgICAgICAg ICAgICAgICAgICAgIChjb21taXQgIjAyMTg0NjlkZjA1MGMzMzQ3OWExZDViZTNlNTIzOWFj MGViMzUxYmYiKSkpCi0gICAgICAgICAgICAgICAgKGZpbGUtbmFtZSAoZ2l0LWZpbGUtbmFt ZSAocGFja2FnZS1uYW1lIHhnY2MpIHZlcnNpb24pKQotICAgICAgICAgICAgICAgIChzaGEy NTYKLSAgICAgICAgICAgICAgICAgKGJhc2UzMgotICAgICAgICAgICAgICAgICAgIjFzNDA5 cW1pZGx2emF3MW5zNmphYW5pZ2gzYXpjeGlzanBsenduN2oybjNzMzNiNzZ6amsiKSkKLSAg ICAgICAgICAgICAgICAocGF0Y2hlcyAoc2VhcmNoLXBhdGNoZXMKLSAgICAgICAgICAgICAg ICAgICAgICAgICAgImdjYy0xMi1jcm9zcy1lbnZpcm9ubWVudC12YXJpYWJsZXMucGF0Y2gi Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICJnY2MtY3Jvc3MtZ3h4LWluY2x1ZGUtZGly LnBhdGNoIikpKSkKLSAgICAgIChuYXRpdmUtaW5wdXRzIChtb2RpZnktaW5wdXRzIChwYWNr YWdlLW5hdGl2ZS1pbnB1dHMgeGdjYykKLSAgICAgICAgICAgICAgICAgICAgICAgOzsgR2V0 IHJpZCBvZiBzdG9jayBJU0wKLSAgICAgICAgICAgICAgICAgICAgICAgKGRlbGV0ZSAiaXNs IikKLSAgICAgICAgICAgICAgICAgICAgICAgOzsgQWRkIGFkZGl0aW9uYWwgZGVwZW5kZW5j aWVzIHRoYXQgeGdjYyBkb2Vzbid0IGhhdmUKLSAgICAgICAgICAgICAgICAgICAgICAgOzsg aW5jbHVkaW5nIG91ciBzcGVjaWFsIElTTAotICAgICAgICAgICAgICAgICAgICAgICAocHJl cGVuZCBmbGV4Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBlcmwKLSAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgcHl0aG9uLTMKLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgZ21wCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlz bC0wLjE1Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRleGluZm8KLSAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgcHl0aG9uCi0gICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIG1wYwotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtcGZy Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHpsaWIpKSkKLSAgICAgIChhcmd1 bWVudHMKLSAgICAgICAoc3Vic3RpdHV0ZS1rZXl3b3JkLWFyZ3VtZW50cyAocGFja2FnZS1h cmd1bWVudHMgeGdjYykKLSAgICAgICAgICgoIzpwaGFzZXMgcGhhc2VzKQotICAgICAgICAg IGAobW9kaWZ5LXBoYXNlcyAscGhhc2VzCi0gICAgICAgICAgICAgKGFkZC1hZnRlciAndW5w YWNrICdmaXgtZ2VubXVsdGlsaWIKLSAgICAgICAgICAgICAgIChsYW1iZGEgXwotICAgICAg ICAgICAgICAgICAocGF0Y2gtc2hlYmFuZyAiZ2NjL2dlbm11bHRpbGliIikpKQotCi0gICAg ICAgICAgICAgKGFkZC1hZnRlciAnc2V0LXBhdGhzICdhdWdtZW50LUNQTFVTX0lOQ0xVREVf UEFUSAotICAgICAgICAgICAgICAgKGxhbWJkYSogKCM6a2V5IGlucHV0cyAjOmFsbG93LW90 aGVyLWtleXMpCi0gICAgICAgICAgICAgICAgIChsZXQgKChnY2MgKGFzc29jLXJlZiBpbnB1 dHMgImdjYyIpKSkKLSAgICAgICAgICAgICAgICAgICA7OyBSZW1vdmUgdGhlIGRlZmF1bHQg Y29tcGlsZXIgZnJvbSBDUExVU19JTkNMVURFX1BBVEggdG8KLSAgICAgICAgICAgICAgICAg ICA7OyBwcmV2ZW50IGhlYWRlciBjb25mbGljdCB3aXRoIHRoZSBHQ0MgZnJvbSBuYXRpdmUt aW5wdXRzLgotICAgICAgICAgICAgICAgICAgIChzZXRlbnYgIkNQTFVTX0lOQ0xVREVfUEFU SCIKLSAgICAgICAgICAgICAgICAgICAgICAgICAgIChzdHJpbmctam9pbiAoZGVsZXRlIChz dHJpbmctYXBwZW5kIGdjYwotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIi9pbmNsdWRlL2MrKyIpCi0gICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoc3RyaW5nLXNwbGl0IChn ZXRlbnYKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICJDUExVU19JTkNMVURFX1BBVEgiKQotICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjXDopKSAi OiIpKQotICAgICAgICAgICAgICAgICAgIChmb3JtYXQgI3QKLSAgICAgICAgICAgICAgICAg ICAgImVudmlyb25tZW50IHZhcmlhYmxlIGBDUExVU19JTkNMVURFX1BBVEgnIGNoYW5nZWQg dG8gYGFgJSIKLSAgICAgICAgICAgICAgICAgICAgKGdldGVudiAiQ1BMVVNfSU5DTFVERV9Q QVRIIikpKSkpKSkKLQotICAgICAgICAgKCgjOmNvbmZpZ3VyZS1mbGFncyBmbGFncykKLSAg ICAgICAgICA7OyBUaGUgY29uZmlndXJlIGZsYWdzIGFyZSBsYXJnZWx5IGlkZW50aWNhbCB0 byB0aGUgZmxhZ3MgdXNlZCBieSB0aGUKLSAgICAgICAgICA7OyAiR0NDIEFSTSBlbWJlZGRl ZCIgcHJvamVjdC4KLSAgICAgICAgICBgKGFwcGVuZCAobGlzdAotICAgICAgICAgICAgICAg ICAgICAiLS1lbmFibGUtbXVsdGlsaWIiCi0gICAgICAgICAgICAgICAgICAgICItLXdpdGgt bmV3bGliIgotICAgICAgICAgICAgICAgICAgICAiLS13aXRoLW11bHRpbGliLWxpc3Q9cm1w cm9maWxlIgotICAgICAgICAgICAgICAgICAgICAiLS13aXRoLWhvc3QtbGlic3RkY3h4PS1z dGF0aWMtbGliZ2NjIC1XbCwtQnN0YXRpYywtbHN0ZGMrKywtQmR5bmFtaWMgLWxtIgotICAg ICAgICAgICAgICAgICAgICAiLS1lbmFibGUtcGx1Z2lucyIKLSAgICAgICAgICAgICAgICAg ICAgIi0tZGlzYWJsZS1kZWNpbWFsLWZsb2F0IgotICAgICAgICAgICAgICAgICAgICAiLS1k aXNhYmxlLWxpYmZmaSIKLSAgICAgICAgICAgICAgICAgICAgIi0tZGlzYWJsZS1saWJnb21w IgotICAgICAgICAgICAgICAgICAgICAiLS1kaXNhYmxlLWxpYm11ZGZsYXAiCi0gICAgICAg ICAgICAgICAgICAgICItLWRpc2FibGUtbGlicXVhZG1hdGgiCi0gICAgICAgICAgICAgICAg ICAgICItLWRpc2FibGUtbGlic3NwIgotICAgICAgICAgICAgICAgICAgICAiLS1kaXNhYmxl LWxpYnN0ZGN4eC1wY2giCi0gICAgICAgICAgICAgICAgICAgICItLWRpc2FibGUtbmxzIgot ICAgICAgICAgICAgICAgICAgICAiLS1kaXNhYmxlLXNoYXJlZCIKLSAgICAgICAgICAgICAg ICAgICAgIi0tZGlzYWJsZS10aHJlYWRzIgotICAgICAgICAgICAgICAgICAgICAiLS1kaXNh YmxlLXRscyIKLSAgICAgICAgICAgICAgICAgICAgIi0td2l0aC1nbnUtbGQiCi0gICAgICAg ICAgICAgICAgICAgICItLXdpdGgtZ251LWFzIgotICAgICAgICAgICAgICAgICAgICAiLS1l bmFibGUtaW5pdGZpbmktYXJyYXkiKQotICAgICAgICAgICAgICAgICAgIChkZWxldGUgIi0t ZGlzYWJsZS1tdWx0aWxpYiIKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICxmbGFncykp KSkpCi0gICAgICAobmF0aXZlLXNlYXJjaC1wYXRocwotICAgICAgIChsaXN0IChzZWFyY2gt cGF0aC1zcGVjaWZpY2F0aW9uCi0gICAgICAgICAgICAgICh2YXJpYWJsZSAiQ1JPU1NfQ19J TkNMVURFX1BBVEgiKQotICAgICAgICAgICAgICAoZmlsZXMgJygiYXJtLXplcGh5ci1lYWJp L2luY2x1ZGUiKSkpCi0gICAgICAgICAgICAgKHNlYXJjaC1wYXRoLXNwZWNpZmljYXRpb24K LSAgICAgICAgICAgICAgKHZhcmlhYmxlICJDUk9TU19DUExVU19JTkNMVURFX1BBVEgiKQot ICAgICAgICAgICAgICAoZmlsZXMgJygiYXJtLXplcGh5ci1lYWJpL2luY2x1ZGUiICJhcm0t emVwaHlyLWVhYmkvYysrIgotICAgICAgICAgICAgICAgICAgICAgICAiYXJtLXplcGh5ci1l YWJpL2MrKy9hcm0temVwaHlyLWVhYmkiKSkpCi0gICAgICAgICAgICAgKHNlYXJjaC1wYXRo LXNwZWNpZmljYXRpb24KLSAgICAgICAgICAgICAgKHZhcmlhYmxlICJDUk9TU19MSUJSQVJZ X1BBVEgiKQotICAgICAgICAgICAgICAoZmlsZXMgJygiYXJtLXplcGh5ci1lYWJpL2xpYiIp KSkpKQotICAgICAgKGhvbWUtcGFnZSAiaHR0cHM6Ly96ZXBoeXJwcm9qZWN0Lm9yZyIpCi0g ICAgICAoc3lub3BzaXMgIkdDQyBmb3IgdGhlIFplcGh5ciBSVE9TIikpKSkKKwkJCQkJCSAj OnhiaW51dGlscyB6ZXBoeXItYmludXRpbHMpKSkKKwkocGFja2FnZQorCSAgKGluaGVyaXQg eGdjYykKKwkgICh2ZXJzaW9uICIxMi4xLjAiKQorCSAgKHNvdXJjZSAob3JpZ2luCisJCQkJ KG1ldGhvZCBnaXQtZmV0Y2gpCisJCQkJKHVyaSAoZ2l0LXJlZmVyZW5jZQorCQkJCQkgICh1 cmwgImh0dHBzOi8vZ2l0aHViLmNvbS96ZXBoeXJwcm9qZWN0LXJ0b3MvZ2NjIikKKwkJCQkJ ICAoY29tbWl0ICIwMjE4NDY5ZGYwNTBjMzM0NzlhMWQ1YmUzZTUyMzlhYzBlYjM1MWJmIikp KQorCQkJCShmaWxlLW5hbWUgKGdpdC1maWxlLW5hbWUgKHBhY2thZ2UtbmFtZSB4Z2NjKSB2 ZXJzaW9uKSkKKwkJCQkoc2hhMjU2CisJCQkJIChiYXNlMzIKKwkJCQkgICIxczQwOXFtaWRs dnphdzFuczZqYWFuaWdoM2F6Y3hpc2pwbHp3bjdqMm4zczMzYjc2emprIikpCisJCQkJKHBh dGNoZXMgKHNlYXJjaC1wYXRjaGVzCisJCQkJCQkgICJnY2MtMTItY3Jvc3MtZW52aXJvbm1l bnQtdmFyaWFibGVzLnBhdGNoIgorCQkJCQkJICAiZ2NjLWNyb3NzLWd4eC1pbmNsdWRlLWRp ci5wYXRjaCIpKSkpCisJICAobmF0aXZlLWlucHV0cyAobW9kaWZ5LWlucHV0cyAocGFja2Fn ZS1uYXRpdmUtaW5wdXRzIHhnY2MpCisJCQkJCSAgIDs7IEdldCByaWQgb2Ygc3RvY2sgSVNM CisJCQkJCSAgIChkZWxldGUgImlzbCIpCisJCQkJCSAgIDs7IEFkZCBhZGRpdGlvbmFsIGRl cGVuZGVuY2llcyB0aGF0IHhnY2MgZG9lc24ndCBoYXZlCisJCQkJCSAgIDs7IGluY2x1ZGlu ZyBvdXIgc3BlY2lhbCBJU0wKKwkJCQkJICAgKHByZXBlbmQgZmxleAorCQkJCQkJCQlpc2wt MC4xNSkpKQorCSAgKGFyZ3VtZW50cworCSAgIChzdWJzdGl0dXRlLWtleXdvcmQtYXJndW1l bnRzIChwYWNrYWdlLWFyZ3VtZW50cyB4Z2NjKQorCQkgKCgjOnBoYXNlcyBwaGFzZXMpCisJ CSAgYChtb2RpZnktcGhhc2VzICxwaGFzZXMKKwkJCSAoYWRkLWFmdGVyICd1bnBhY2sgJ2Zp eC1nZW5tdWx0aWxpYgorCQkJICAgKGxhbWJkYSBfCisJCQkJIChwYXRjaC1zaGViYW5nICJn Y2MvZ2VubXVsdGlsaWIiKSkpCisKKwkJCSAoYWRkLWFmdGVyICdzZXQtcGF0aHMgJ2F1Z21l bnQtQ1BMVVNfSU5DTFVERV9QQVRICisJCQkgICAobGFtYmRhKiAoIzprZXkgaW5wdXRzICM6 YWxsb3ctb3RoZXIta2V5cykKKwkJCQkgKGxldCAoKGdjYyAoYXNzb2MtcmVmIGlucHV0cyAi Z2NjIikpKQorCQkJCSAgIDs7IFJlbW92ZSB0aGUgZGVmYXVsdCBjb21waWxlciBmcm9tIENQ TFVTX0lOQ0xVREVfUEFUSCB0bworCQkJCSAgIDs7IHByZXZlbnQgaGVhZGVyIGNvbmZsaWN0 IHdpdGggdGhlIEdDQyBmcm9tIG5hdGl2ZS1pbnB1dHMuCisJCQkJICAgKHNldGVudiAiQ1BM VVNfSU5DTFVERV9QQVRIIgorCQkJCQkJICAgKHN0cmluZy1qb2luIChkZWxldGUgKHN0cmlu Zy1hcHBlbmQgZ2NjCisJCQkJCQkJCQkJCQkJCQkgICAiL2luY2x1ZGUvYysrIikKKwkJCQkJ CQkJCQkJCShzdHJpbmctc3BsaXQgKGdldGVudgorCQkJCQkJCQkJCQkJCQkJICAgIkNQTFVT X0lOQ0xVREVfUEFUSCIpCisJCQkJCQkJCQkJCQkJCQkgICNcOikpICI6IikpCisJCQkJICAg KGZvcm1hdCAjdAorCQkJCQkiZW52aXJvbm1lbnQgdmFyaWFibGUgYENQTFVTX0lOQ0xVREVf UEFUSCcgY2hhbmdlZCB0byBgYWAlIgorCQkJCQkoZ2V0ZW52ICJDUExVU19JTkNMVURFX1BB VEgiKSkpKSkpKQorCisJCSAoKCM6Y29uZmlndXJlLWZsYWdzIGZsYWdzKQorCQkgIDs7IFRo ZSBjb25maWd1cmUgZmxhZ3MgYXJlIGxhcmdlbHkgaWRlbnRpY2FsIHRvIHRoZSBmbGFncyB1 c2VkIGJ5IHRoZQorCQkgIDs7ICJHQ0MgQVJNIGVtYmVkZGVkIiBwcm9qZWN0LgorCQkgIGAo YXBwZW5kIChsaXN0CisJCQkJCSItLWVuYWJsZS1tdWx0aWxpYiIKKwkJCQkJIi0td2l0aC1u ZXdsaWIiCisJCQkJCSItLXdpdGgtbXVsdGlsaWItbGlzdD1ybXByb2ZpbGUiCisJCQkJCSIt LXdpdGgtaG9zdC1saWJzdGRjeHg9LXN0YXRpYy1saWJnY2MgLVdsLC1Cc3RhdGljLC1sc3Rk YysrLC1CZHluYW1pYyAtbG0iCisJCQkJCSItLWVuYWJsZS1wbHVnaW5zIgorCQkJCQkiLS1k aXNhYmxlLWRlY2ltYWwtZmxvYXQiCisJCQkJCSItLWRpc2FibGUtbGliZmZpIgorCQkJCQki LS1kaXNhYmxlLWxpYmdvbXAiCisJCQkJCSItLWRpc2FibGUtbGlibXVkZmxhcCIKKwkJCQkJ Ii0tZGlzYWJsZS1saWJxdWFkbWF0aCIKKwkJCQkJIi0tZGlzYWJsZS1saWJzc3AiCisJCQkJ CSItLWRpc2FibGUtbGlic3RkY3h4LXBjaCIKKwkJCQkJIi0tZGlzYWJsZS1ubHMiCisJCQkJ CSItLWRpc2FibGUtc2hhcmVkIgorCQkJCQkiLS1kaXNhYmxlLXRocmVhZHMiCisJCQkJCSIt LWRpc2FibGUtdGxzIgorCQkJCQkiLS13aXRoLWdudS1sZCIKKwkJCQkJIi0td2l0aC1nbnUt YXMiCisJCQkJCSItLWVuYWJsZS1pbml0ZmluaS1hcnJheSIpCisJCQkJICAgKGRlbGV0ZSAi LS1kaXNhYmxlLW11bHRpbGliIgorCQkJCQkJICAgLGZsYWdzKSkpKSkKKwkgIChuYXRpdmUt c2VhcmNoLXBhdGhzCisJICAgKGxpc3QgKHNlYXJjaC1wYXRoLXNwZWNpZmljYXRpb24KKwkJ CSAgKHZhcmlhYmxlICJDUk9TU19DX0lOQ0xVREVfUEFUSCIpCisJCQkgIChmaWxlcyAnKCJh cm0temVwaHlyLWVhYmkvaW5jbHVkZSIpKSkKKwkJCSAoc2VhcmNoLXBhdGgtc3BlY2lmaWNh dGlvbgorCQkJICAodmFyaWFibGUgIkNST1NTX0NQTFVTX0lOQ0xVREVfUEFUSCIpCisJCQkg IChmaWxlcyAnKCJhcm0temVwaHlyLWVhYmkvaW5jbHVkZSIgImFybS16ZXBoeXItZWFiaS9j KysiCisJCQkJCSAgICJhcm0temVwaHlyLWVhYmkvYysrL2FybS16ZXBoeXItZWFiaSIpKSkK KwkJCSAoc2VhcmNoLXBhdGgtc3BlY2lmaWNhdGlvbgorCQkJICAodmFyaWFibGUgIkNST1NT X0xJQlJBUllfUEFUSCIpCisJCQkgIChmaWxlcyAnKCJhcm0temVwaHlyLWVhYmkvbGliIikp KSkpCisJICAoaG9tZS1wYWdlICJodHRwczovL3plcGh5cnByb2plY3Qub3JnIikKKwkgIChz eW5vcHNpcyAiR0NDIGZvciB0aGUgWmVwaHlyIFJUT1MiKSkpKQogYGBgCiAKIFRoaXMgR0ND IGNhbiBiZSBidWlsdCBsaWtlIHNvLgotLSAKMi4zOS4xCgo= --------------clpwK2anZkV7f4pX2Ft0XkOD Content-Type: text/x-patch; charset=UTF-8; name="0002-website-custom-toolchains-with-guix-Update-reference.patch" Content-Disposition: attachment; filename*0="0002-website-custom-toolchains-with-guix-Update-reference.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSAyNWE2NWM2YWNlMmEzZGY0M2Q2YzNjNmQ2ZTIzMDYyYTUxNDE5MDI1IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNaXRjaGVsbCBTY2htZWlzc2VyIDxtaXRjaGVsbHNj aG1laXNzZXJAbGlicmVtLm9uZT4KRGF0ZTogTW9uLCAxMyBNYXIgMjAyMyAwOTozOToyMiAt MDQwMApTdWJqZWN0OiBbUEFUQ0ggMi8yXSB3ZWJzaXRlOiBjdXN0b20tdG9vbGNoYWlucy13 aXRoLWd1aXg6IFVwZGF0ZSByZWZlcmVuY2UKIFVSTAoKKiB3ZWJzaXRlL2RyYWZ0cy9jdXN0 b20tdG9vbGNoYWlucy13aXRoLWd1aXgubWQ6IENoYW5nZWQgdXJsIGZyb20KImxhdGVzdCIg dG8gMy4xIHdoaWNoIHdhcyB0aGUgY3VycmVudCB2ZXJzaW9uIGF0IHRoZSB0aW1lIG9mIHdy aXR0aW5nLgotLS0KIHdlYnNpdGUvZHJhZnRzL2N1c3RvbS10b29sY2hhaW5zLXdpdGgtZ3Vp eC5tZCB8IDIgKy0KIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKSwgMSBkZWxldGlv bigtKQoKZGlmZiAtLWdpdCBhL3dlYnNpdGUvZHJhZnRzL2N1c3RvbS10b29sY2hhaW5zLXdp dGgtZ3VpeC5tZCBiL3dlYnNpdGUvZHJhZnRzL2N1c3RvbS10b29sY2hhaW5zLXdpdGgtZ3Vp eC5tZAppbmRleCBmYjQ5MWM2Li5mZmMzYjFhIDEwMDY0NAotLS0gYS93ZWJzaXRlL2RyYWZ0 cy9jdXN0b20tdG9vbGNoYWlucy13aXRoLWd1aXgubWQKKysrIGIvd2Vic2l0ZS9kcmFmdHMv Y3VzdG9tLXRvb2xjaGFpbnMtd2l0aC1ndWl4Lm1kCkBAIC00NDcsNyArNDQ3LDcgQEAgZm9y IGEgZ2l2ZW4gYm9hcmQuCiAKIFRoZXJlIGFyZSBzdGFuZGFyZCBsb2NhdGlvbnMgdGhlIGJ1 aWxkIHN5c3RlbSB3aWxsIGxvb2sgZm9yIHRoZSBTREsuIFdlIGFyZSBub3QgdXNpbmcgYW55 IG9mIHRoZW0uCiBPdXIgU0RLIGxpdmVzIGluIHRoZSBzdG9yZSwgaW1tdXRhYmxlIGZvcmV2 ZXIuCi1BY2NvcmRpbmcgdG8gW3RoZSBaZXBoeXIgZG9jdW1lbnRhdGlvbl0oaHR0cHM6Ly9k b2NzLnplcGh5cnByb2plY3Qub3JnL2xhdGVzdC9kZXZlbG9wL3dlc3Qvd2l0aG91dC13ZXN0 Lmh0bWwpLCB0aGUgdmFyaWFibGUgYFpFUEhZUl9TREtfSU5TVEFMTF9ESVJgIG5lZWRzIHRv IHBvaW50IHRvIG91ciBjdXN0b20gc3BvdC4KK0FjY29yZGluZyB0byBbdGhlIFplcGh5ciBk b2N1bWVudGF0aW9uXShodHRwczovL2RvY3MuemVwaHlycHJvamVjdC5vcmcvMy4xLjAvZGV2 ZWxvcC93ZXN0L3dpdGhvdXQtd2VzdC5odG1sKSwgdGhlIHZhcmlhYmxlIGBaRVBIWVJfU0RL X0lOU1RBTExfRElSYCBuZWVkcyB0byBwb2ludCB0byBvdXIgY3VzdG9tIHNwb3QuCiAKIFdl IGFsc28gbmVlZCB0byBncmFiIHRoZSBDTWFrZSBmaWxlcyBmcm9tIHRoZQogW3JlcG9zaXRv cnldKGh0dHBzOi8vZ2l0aHViLmNvbS96ZXBoeXJwcm9qZWN0LXJ0b3Mvc2RrLW5nKQotLSAK Mi4zOS4xCgo= --------------clpwK2anZkV7f4pX2Ft0XkOD-- From debbugs-submit-bounces@debbugs.gnu.org Wed Mar 15 10:45:54 2023 Received: (at 61765) by debbugs.gnu.org; 15 Mar 2023 14:45:54 +0000 Received: from localhost ([127.0.0.1]:40327 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pcSO1-0004mz-Qp for submit@debbugs.gnu.org; Wed, 15 Mar 2023 10:45:54 -0400 Received: from eggs.gnu.org ([209.51.188.92]:34734) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pcSNz-0004mn-S9 for 61765@debbugs.gnu.org; Wed, 15 Mar 2023 10:45:52 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pcSNu-0001O9-2m; Wed, 15 Mar 2023 10:45:46 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnu.org; s=fencepost-gnu-org; h=MIME-Version:In-Reply-To:Date:References:Subject:To: From; bh=A/RUmR3FrWwxr5g0mHPhPsH65rT3g/XKZ1eU6Rva+Zg=; b=MzI5BwsH4KrJ8rwHqlxT sNmTjqHv4lUj5dehm6DNkVJ7Fp7gEne8RkbUWwxybbZ25Z1JkESBh8sVG/MR1x2jNhH+dsJGwsEpo ZbOmwZj8FuHm0cCwY3iBMe2CUtuudP/+nDWMTfP/v6jF5dnWA7KmSox0MViK8y3gOUgZ2vzmUDcYF B9aR5VYq+3ZuR4o3qA5QQHGLXoM7AjXK4q99iaudpdAyMCRgtWuPmVjrmAnfLAiFURMV5OEWja5em EstGG7SHTT4dI8FRJUDeIFasXIYh7yA8ZVOG0gmmjJJ0A6dch2/z9+PhRegp8lq8sxRChvP95mMkQ 7FJ4YvzsBDZC2A==; Received: from 91-160-117-201.subs.proxad.net ([91.160.117.201] helo=ribbon) by fencepost.gnu.org with esmtpsa (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pcSNt-00077K-I1; Wed, 15 Mar 2023 10:45:45 -0400 From: =?utf-8?Q?Ludovic_Court=C3=A8s?= To: Mitchell Schmeisser Subject: Re: bug#61765: custom toolchain blog post References: <87sfeuucab.fsf@librem.one> <87fsarmfw6.fsf@gnu.org> <87k003xgs0.fsf@librem.one> <87zg8jwkqc.fsf@gnu.org> Date: Wed, 15 Mar 2023 15:45:43 +0100 In-Reply-To: (Mitchell Schmeisser's message of "Mon, 13 Mar 2023 09:52:32 -0400") Message-ID: <87r0tq3wfc.fsf_-_@gnu.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/28.2 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 61765 Cc: 61765@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Hi, Mitchell Schmeisser skribis: > Sorry about the code formatting... Does anyone have any tips for > getting emacs to format scheme code in markdown? No tips, other than making sure to untabify. :-) > From 0f6c28345a51e20004bc16b73bda1c0e5ccb7f4c Mon Sep 17 00:00:00 2001 > From: Mitchell Schmeisser > Date: Mon, 13 Mar 2023 09:36:36 -0400 > Subject: [PATCH 1/2] website: custom-toolchains-with-guix: Code fix > > * website/drafts/custom-toolchains-with-guix.md: Removed unnecessary > native-inputs from gcc-arm-zephyr-eabi-toolchain code block. [...] > From 25a65c6ace2a3df43d6c3c6d6e23062a51419025 Mon Sep 17 00:00:00 2001 > From: Mitchell Schmeisser > Date: Mon, 13 Mar 2023 09:39:22 -0400 > Subject: [PATCH 2/2] website: custom-toolchains-with-guix: Update referen= ce > URL > > * website/drafts/custom-toolchains-with-guix.md: Changed url from > "latest" to 3.1 which was the current version at the time of writting. Applied, and finally published: https://guix.gnu.org/en/blog/2023/building-toolchains-with-guix/ Thank you! Ludo=E2=80=99. From debbugs-submit-bounces@debbugs.gnu.org Wed Mar 15 10:46:17 2023 Received: (at control) by debbugs.gnu.org; 15 Mar 2023 14:46:17 +0000 Received: from localhost ([127.0.0.1]:40332 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pcSOP-0004oI-DB for submit@debbugs.gnu.org; Wed, 15 Mar 2023 10:46:17 -0400 Received: from eggs.gnu.org ([209.51.188.92]:47330) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pcSOO-0004o7-Al for control@debbugs.gnu.org; Wed, 15 Mar 2023 10:46:16 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pcSOJ-0001VP-4X for control@debbugs.gnu.org; Wed, 15 Mar 2023 10:46:11 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnu.org; s=fencepost-gnu-org; h=MIME-version:Subject:From:To:Date:in-reply-to: references; bh=Wa3psUsSBNT99Wj4KylAhc7ZdJypxiW7SoeSwrF5dMU=; b=sB0n8Rh2aWpQ+N qFO8z8oEDqNrhgrp323wx3BFi1/2Be+famOr2flz61N+r1y+FDAxbK6Dmd/41Tl0L9ULx2w+ryosR EsQ9+Slj5N2Rp+aZFCdstcN6ruTeyMtiPrfWX+Do/pq/RIHFB0XHCjzH4MCgp5u5Q+DL+m05XPYsO 0dTDGdmeU/bzM8FWHVOMvnjKf2caB5TLrTVvRaHC7hQeOpnL8LPHGegp5wZ9JzlKVc2I7fdS4Tia3 8b39bRoiq5p7kUHzqECMEEsFbjQT2j9w2SAFAIuo25BvEraQOloF32A8AVoAG6sgKjYJYSrDgvK7k 11DaMTLGdEKxhDA7xmxw==; Received: from 91-160-117-201.subs.proxad.net ([91.160.117.201] helo=ribbon) by fencepost.gnu.org with esmtpsa (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pcSOI-0007Ak-Ln for control@debbugs.gnu.org; Wed, 15 Mar 2023 10:46:10 -0400 Date: Wed, 15 Mar 2023 15:46:08 +0100 Message-Id: <87pm9a3wen.fsf@gnu.org> To: control@debbugs.gnu.org From: =?utf-8?Q?Ludovic_Court=C3=A8s?= Subject: control message for bug #61765 MIME-version: 1.0 Content-type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: control X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) close 61765 quit From debbugs-submit-bounces@debbugs.gnu.org Wed Mar 15 21:55:33 2023 Received: (at 61765) by debbugs.gnu.org; 16 Mar 2023 01:55:33 +0000 Received: from localhost ([127.0.0.1]:40862 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pccq5-0001El-6s for submit@debbugs.gnu.org; Wed, 15 Mar 2023 21:55:33 -0400 Received: from mx1.librem.one ([138.201.176.93]:38484) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pccq3-0001ES-UF for 61765@debbugs.gnu.org; Wed, 15 Mar 2023 21:55:32 -0400 Received: from smtp.librem.one (unknown [192.241.214.14]) by mx1.librem.one (Postfix) with ESMTPS id 8957D81E89; Wed, 15 Mar 2023 18:55:25 -0700 (PDT) Authentication-Results: name mx1.librem.one; dmarc=fail (p=reject dis=none) header.from=librem.one Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable From: Mitchell Schmeisser Subject: Re: bug#61765: custom toolchain blog post Date: Wed, 15 Mar 2023 21:55:21 -0400 Message-Id: <717EED68-1B47-4BEE-A47F-762702439926@librem.one> References: <87r0tq3wfc.fsf_-_@gnu.org> In-Reply-To: <87r0tq3wfc.fsf_-_@gnu.org> To: =?utf-8?Q?Ludovic_Court=C3=A8s?= X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 61765 Cc: 61765@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) Ah I=E2=80=99m so honored, thank you for the encouragement! -Mitchell=20 > On Mar 15, 2023, at 10:46 AM, Ludovic Court=C3=A8s wrote: >=20 > =EF=BB=BFHi, >=20 > Mitchell Schmeisser skribis: >=20 >> Sorry about the code formatting... Does anyone have any tips for >> getting emacs to format scheme code in markdown? >=20 > No tips, other than making sure to untabify. :-) >=20 >> =46rom 0f6c28345a51e20004bc16b73bda1c0e5ccb7f4c Mon Sep 17 00:00:00 2001 >> From: Mitchell Schmeisser >> Date: Mon, 13 Mar 2023 09:36:36 -0400 >> Subject: [PATCH 1/2] website: custom-toolchains-with-guix: Code fix >>=20 >> * website/drafts/custom-toolchains-with-guix.md: Removed unnecessary >> native-inputs from gcc-arm-zephyr-eabi-toolchain code block. >=20 > [...] >=20 >> =46rom 25a65c6ace2a3df43d6c3c6d6e23062a51419025 Mon Sep 17 00:00:00 2001 >> From: Mitchell Schmeisser >> Date: Mon, 13 Mar 2023 09:39:22 -0400 >> Subject: [PATCH 2/2] website: custom-toolchains-with-guix: Update referen= ce >> URL >>=20 >> * website/drafts/custom-toolchains-with-guix.md: Changed url from >> "latest" to 3.1 which was the current version at the time of writting. >=20 > Applied, and finally published: >=20 > https://guix.gnu.org/en/blog/2023/building-toolchains-with-guix/ >=20 > Thank you! >=20 > Ludo=E2=80=99. From unknown Mon Jun 23 04:11:23 2025 Received: (at fakecontrol) by fakecontrolmessage; To: internal_control@debbugs.gnu.org From: Debbugs Internal Request Subject: Internal Control Message-Id: bug archived. Date: Thu, 13 Apr 2023 11:24:09 +0000 User-Agent: Fakemail v42.6.9 # This is a fake control message. # # The action: # bug archived. thanks # This fakemail brought to you by your local debbugs # administrator