Script to statically cross compile various useful binaries (dropbear, socat, rsync, rpcapd, tcpdump, openssl, zstd) using musl-libc via musl.cc toolchains,

builder.sh

#!/bin/bash
# From https://gist.github.com/ryancdotorg/84275935f0b82578d8c222e2e915fc78
# built binaries at https://ryanc-musl-bins.s3.amazonaws.com/SHA256SUMS.html

set -eo pipefail
set -x

export BUILD_SCRIPT_DATE="$(date -r "$0" -Iseconds)"

PV_VERSION=1.8.5
SOCAT_VERSION=1.8.0.0
NCURSES_VERSION=6.4
READLINE_VERSION=8.2
OPENSSL_VERSION=1.1.1w
LIBPCAP_VERSION=1.10.4
ZLIB_VERSION=1.3.1
TCPDUMP_VERSION=4.99.4
RSYNC_VERSION=3.3.0
XZ_VERSION=5.4.5
LZ4_VERSION=v1.9.4
ZSTD_VERSION=v1.5.6
XXHASH_VERSION=v0.8.2
DROPBEAR_VERSION=2022.83
GPGERROR_VERSION=1.48
GCRYPT_VERSION=1.10.2
GLIB_VERSION=2.80.0
CARES_VERSION=1.28.1
PCRE_VERSION=8.45
WIRESHARK_VERSION=4.0.11
LIBSODIUM_VERSION=1.0.19-RELEASE
MINISIGN_VERSION=v0.11-ryanc.4
SHA2SUM_VERSION=v0.3.1
MULTICALL_VERSION=v0.0.6

BASE_DIR=/dev/shm/arm-bins
SOURCE_DIR="$BASE_DIR/source"
BUILD_DIR="$BASE_DIR/build"
SCRIPT_DIR="`pwd`"
OUTPUT_DIR="$SCRIPT_DIR/output"

ORIG_PATH=$PATH

function setcross() {
    MUSL_CROSS=${1:-armv7l-linux-musleabihf}
    CROSS_BIN="$BUILD_DIR/$MUSL_CROSS-cross/bin"
    CROSS_PFX="$CROSS_BIN/$MUSL_CROSS"
    BIN_DIR="$OUTPUT_DIR/$MUSL_CROSS"

    if command -v _ccache > /dev/null; then
        export CC="ccache $CROSS_PFX-gcc"
        export CXX="ccache $CROSS_PFX-g++"
    else
        export CC=$CROSS_PFX-gcc
        export CXX=$CROSS_PFX-g++
    fi

    export AR=$CROSS_PFX-ar
    export AS=$CROSS_PFX-as
    export LD=$CROSS_PFX-ld
    export RANLIB=$CROSS_PFX-ranlib

    export PATH=$CROSS_BIN:$ORIG_PATH
    export STRIP="$CROSS_PFX-strip -s -R .comment -R .hash -R .gnu.hash"
    export LDFLAGS="-flto -Wl,--gc-sections"
    export CFLAGS="-flto -fno-inline-small-functions -ffunction-sections -fdata-sections -Wl,--gc-sections -static -Os"
    export CXXFLAGS="$CFLAGS"
    export MAKEFLAGS="-sj$((`grep -c '^processor' /proc/cpuinfo` * 125 / 100))"
}

function extract() {
    PACKAGE="$1"
    BASEURL="$2"
    FILEEXT="$3"
    VERSION="${4:-}"

    export PS4="+$arch:$PACKAGE+ "

    # Clean/Download/Extract
    cd "$BUILD_DIR"

    if [ "$FILEEXT" = "git" ]; then
        if [ -d "$PACKAGE" ]; then
            cd "$PACKAGE"
            git clean -fdx
            git reset --hard HEAD
            if [[ ! -z "$VERSION" ]]; then
                git checkout "$VERSION" \
                || git fetch --depth 1 origin tag "$VERSION" --no-tags \
                && git checkout "$VERSION"
            else
                git pull
            fi
        else
            if [[ ! -z "$VERSION" ]]; then
                git clone --depth 1 --branch "$VERSION" "$BASEURL/$PACKAGE.$FILEEXT"
            else
                git clone --depth 1 "$BASEURL/$PACKAGE.$FILEEXT"
            fi
            cd "$PACKAGE"
        fi
        printf '%s  %s.git\n' $(git rev-parse HEAD) "$PACKAGE" >> "$BUILD_DIR/hashes"
    else
        if [ -d "$PACKAGE-$VERSION" ]; then rm -rf "$PACKAGE-$VERSION"; fi
        if ! tar -xaf "$PACKAGE-$VERSION.$FILEEXT" > /dev/null 2> /dev/null; then
            curl -LO "$BASEURL/$PACKAGE-$VERSION.$FILEEXT"
            if [ -d "$PACKAGE-$VERSION" ]; then rm -rf "$PACKAGE-$VERSION"; fi
            tar -xaf "$PACKAGE-$VERSION.$FILEEXT"
        fi
        ln -fs "$PACKAGE-$VERSION" "$PACKAGE"
        sha256sum "$PACKAGE-$VERSION.$FILEEXT" >> "$BUILD_DIR/hashes"
        cd "$PACKAGE-$VERSION"
    fi

    # Patch
    if [ -d "$BUILD_DIR/patches" ]; then
        for f in "$BUILD_DIR/patches/$PACKAGE"-*.diff; do
            [ -e "$f" ] || continue
            patch -p1 < "$f"
        done
        for f in "$BUILD_DIR/patches/$PACKAGE"-*.sh; do
            [ -e "$f" ] || continue
            "$f"
        done
    fi
}

function output() {
    BIN="$1"
    DST="${2:-}"
    mkdir -p "$BIN_DIR"
    chmod 755 "$BIN"
    $STRIP "$BIN"
    cp "$BIN" "$BIN_DIR/$DST"
}

function get_musl() {
    cd "$BUILD_DIR"

    HASHES="musl.SHA512SUMS"
    FLAGS="-L -o $HASHES"
    if [ -e "$HASHES" ]; then
        FLAGS="$FLAGS -z $HASHES"
    fi
    curl $FLAGS https://musl.cc/SHA512SUMS

    if [ ! -e "$MUSL_CROSS-cross.tgz" ]; then
        if [ -d "$MUSL_CROSS-cross" ]; then
           rm -rf "$MUSL_CROSS-cross"
        fi
        curl -LO "https://musl.cc/$MUSL_CROSS-cross.tgz"
    fi

    if (fgrep "$MUSL_CROSS-cross.tgz" "$HASHES" | sha512sum --strict --warn --status -c -); then
        if [ ! -d "$MUSL_CROSS-cross" ]; then
            tar -xzf "$MUSL_CROSS-cross.tgz"
        fi
    else
        rm "$MUSL_CROSS-cross.tgz"
        get_musl
    fi
}

function build_pv() {
    # Download/extract
    extract pv https://www.ivarch.com/programs/sources tar.gz $PV_VERSION

    # Configure
    ./configure \
        --enable-static \
        --disable-nls \
        --disable-dependency-tracking

    # Build
    make
    output pv
    echo "** Finished building pv"
}

function build_openssl() {
    # Download/extract
    extract openssl https://www.openssl.org/source tar.gz $OPENSSL_VERSION

    TARGET="$1"
    if [ -z "$TARGET" ]; then
        case $MUSL_CROSS in
            x86_64-linux-musl)
            TARGET=linux-x86_64
            ;;
            aarch64-linux-musl)
            TARGET=linux-aarch64
            ;;
            armv*-linux-*)
            TARGET=linux-armv4
            ;;
            mips-linux-*)
            TARGET=linux-mips32
            ;;
            mipsel-linux-*)
            TARGET=linux-mips32
            ;;
            *)
            TARGET=linux-generic32
            ;;
        esac
    fi

    # Configure
    SOURCE_DATE_EPOCH="$(date -r CHANGES '+%s')" \
    ./Configure \
        --openssldir=/etc/ssl \
        no-shared no-async no-threads no-err no-hw no-engine no-dso \
        no-static-engine no-capieng no-comp \
        no-tests no-unit-test \
        no-ts no-cms \
        no-rfc3779 \
        no-srtp \
        no-ssl-trace no-ct no-multiblock \
        no-cmac no-blake2 no-asm \
        no-siphash \
        no-scrypt no-ocb no-egd \
        no-md4 no-whirlpool no-rmd160 \
        no-des no-bf no-rc2 no-rc4 no-rc5 \
        no-sm2 no-sm3 no-sm4 \
        no-gost no-idea no-cast no-seed no-camellia no-aria \
        no-chacha no-poly1305 \
        no-dh no-dsa no-psk no-srp \
        no-ec2m \
        no-weak-ssl-ciphers \
        no-dgram no-sctp \
        no-dtls no-ssl2 no-ssl3 no-tls1 no-tls1_1 \
        no-ssl3-method no-tls1-method no-tls1_1-method \
        no-dtls1-method no-dtls1_2-method \
        no-crypto-mdebug \
        $TARGET

    # Build
    SOURCE_DATE_EPOCH="$(date -r CHANGES '+%s')" \
    make
    output apps/openssl
    echo "** Finished building OpenSSL"
}

function build_gpgerror(){
    # Download/extract
    extract libgpg-error https://www.gnupg.org/ftp/gcrypt/libgpg-error tar.gz $GPGERROR_VERSION

    # Configure
    ./configure \
        --enable-silent-rules \
        --disable-languages \
        --disable-doc \
        --disable-tests \
        --disable-nls \
        --disable-dependency-tracking \
        --enable-static --disable-shared \
        --prefix="$BUILD_DIR/install" \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS

    # Build
    make install
    # no idea why this needs to be done...
    mkdir -p "$BUILD_DIR/install/bin"
    cp src/gpg-error-config "$BUILD_DIR/install/bin/"
    echo "** Finished building libgpg-error"
}

function build_gcrypt(){
    # Download/extract
    extract libgcrypt https://www.gnupg.org/ftp/gcrypt/libgcrypt tar.gz $GCRYPT_VERSION

    # Configure
    ./configure \
        --enable-silent-rules \
        --disable-doc \
        --disable-dependency-tracking \
        --enable-static --disable-shared \
        --enable-ciphers="aes chacha20" \
        --enable-pubkey-ciphers="ecc rsa" \
        --enable-digests="sha256 sha512" \
        --enable-kdfs="pkdf2" \
        --with-libgpg-error-prefix="$BUILD_DIR/install" \
        --prefix="$BUILD_DIR/install" \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS

    # Disable tests
    sed -Ei 's/(SUBDIRS\s*=.*)\s+tests(\s+.+)?/\1\2/' Makefile*

    # Build
    make install
    echo "** Finished building libgcrypt"
}

function build_cares(){
    # Download/extract
    extract c-ares https://c-ares.org/download tar.gz $CARES_VERSION

    # Configure
    ./configure \
        --prefix="$BUILD_DIR/install" \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS

    # Build
    make install
    echo "** Finished building c-ares"
}

function build_pcre(){
    # Download/extract
    extract pcre https://downloads.sourceforge.net/project/pcre/pcre/$PCRE_VERSION tar.gz $PCRE_VERSION

    # Configure
    ./configure \
        --prefix="$BUILD_DIR/install" \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS

    # Build
    make install
    echo "** Finished building pcre"
}

function build_glib(){
    # https://download.gnome.org/sources/glib/2.74/glib-2.74.5.tar.xz
    # Download/extract
    extract glib https://download.gnome.org/sources/glib/$(echo $GLIB_VERSION | cut -d . -f 1-2) tar.xz $GLIB_VERSION

    MESON_CROSS_FILE="cross_$MUSL_CROSS.txt"
    MESON_CROSS_OS=linux
    MESON_CROSS_ENDIAN=little
    MESON_CROSS_CPU=$(echo "$MUSL_CROSS" | cut -d - -f 1)
    case $MUSL_CROSS in
        x86_64-linux-musl)
        MESON_CROSS_FAMILY=x86_64
        #MESON_CROSS_WRAPPER=qemu-x86_64-static
        ;;
        aarch64-linux-musl)
        MESON_CROSS_FAMILY=aarch64
        MESON_CROSS_WRAPPER=qemu-aarch64-static
        ;;
        armv*-linux-musl*)
        MESON_CROSS_FAMILY=arm
        MESON_CROSS_WRAPPER=qemu-arm-static
        ;;
        mips-linux-musl*)
        MESON_CROSS_ENDIAN=big
        MESON_CROSS_FAMILY=mips
        MESON_CROSS_WRAPPER=qemu-mips-static
        ;;
        mipsel-linux-musl*)
        MESON_CROSS_FAMILY=mipsel
        MESON_CROSS_WRAPPER=qemu-mipsel-static
        ;;
        *)
        MESON_CROSS_FAMILY=unknown
        ;;
    esac

    cat > "$MESON_CROSS_FILE" <<EoF
[binaries]
c = '$CROSS_PFX-gcc'
cpp = '$CROSS_PFX-g++'
ar = '$CROSS_PFX-ar'
as = '$CROSS_PFX-as'
ld = '$CROSS_PFX-ld'
strip = '$CROSS_PFX-strip'

[host_machine]
system = '$MESON_CROSS_OS'
cpu_family = '$MESON_CROSS_FAMILY'
cpu = '$MESON_CROSS_CPU'
endian = '$MESON_CROSS_ENDIAN'
${MESON_CROSS_WRAPPER+exe_wrapper = "'$MESON_CROSS_WRAPPER'"}
EoF

    # XXX this is probably a terrible idea...
    if [ "$MESON_CROSS_FAMILY" = "x86_64" ]; then
        # insert lines overriding check
        sed -i '0,/^if not gl_cv_func_frexpl_works and/s//gl_cv_func_frexpl_broken_beyond_repair = false\n&/' glib/gnulib/meson.build
    fi

    # Configure
    CFLAGS="" CPPFLAGS="" LDFLAGS="" \
    meson setup \
        --prefix "$BUILD_DIR/install" \
        --buildtype minsize \
        --prefer-static \
        --default-library static \
        --cross-file "$MESON_CROSS_FILE" \
        -Dtests=false \
        "build_$MUSL_CROSS"

    # Build
    pushd "build_$MUSL_CROSS"
    meson compile
    meson install
    popd
    echo "** Finished building glib"
}

function build_wireshark(){
    # Download/extract
    extract wireshark https://www.wireshark.org/download/src/all-versions tar.xz $WIRESHARK_VERSION


    # Configure
    #sed -Ei \
    #    "s!/opt/local/lib!$BUILD_DIR/glib-$GLIB_VERSION/build_$MUSL_CROSS/install/usr/local/lib!" \
    #    cmake/modules/Find{GLIB2,GMODULE2,GTHREAD2}.cmake
    mkdir build
    pushd build
    PKG_CONFIG_LIBDIR="$BUILD_DIR/install/lib/pkgconfig" \
    CMAKE_PREFIX_PATH="$BUILD_DIR/install" \
    CFLAGS="-I$BUILD_DIR/install/include $CFLAGS" \
    CPPFLAGS="-I$BUILD_DIR/install/include $CPPFLAGS" \
    LDFLAGS="-L$BUILD_DIR/install/lib $CPPFLAGS" \
    cmake \
        -DBUILD_wireshark=OFF -DBUILD_sharkd=OFF -DBUILD_tshark=OFF \
        -DBUILD_capinfos=OFF -DBUILD_captype=OFF -DBUILD_dftest=OFF \
        -DBUILD_randpkt=OFF -DBUILD_dumpcap=OFF -DBUILD_rawshark=OFF \
        -DUSE_STATIC=ON -DENABLE_STATIC=ON -DENABLE_PLUGINS=OFF \
        -DBUILD_editcap=ON \
        -DBUILD_mergecap=ON \
        -DBUILD_reordercap=ON \
        -DBUILD_text2pcap=ON \
        -DENABLE_ZLIB=ON \
        ..

    # Build
    make
    output run/editcap
    output run/mergecap
    output run/text2pcap
    output run/reordercap
    popd
    echo "** Finished building wireshark"
}

function build_libpcap(){
    # Download/extract
    extract libpcap https://www.tcpdump.org/release tar.gz $LIBPCAP_VERSION

    # Configure
    CFLAGS="-I$BUILD_DIR/openssl-$OPENSSL_VERSION/include -DNETDB_INTERNAL=-1 $CFLAGS" \
    LDFLAGS="-L$BUILD_DIR/openssl-$OPENSSL_VERSION $LDFLAGS" \
    ./configure \
        --enable-remote \
        --disable-usb \
        --disable-netmap \
        --disable-bluetooth \
        --disable-dbus \
        --disable-rdma \
        --disable-shared \
        --prefix="$BUILD_DIR/install" \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS

    # Build
    make
    make install
    output rpcapd/rpcapd
    echo "** Finished building libpcap"
}

function build_tcpdump(){
    # Download/extract
    extract tcpdump https://www.tcpdump.org/release tar.gz $TCPDUMP_VERSION

    # The configure script fails to detect OpenSSL if DES is disabled...
    fgrep -rl DES_cbc_encrypt . \
    | xargs perl -i -pe 's/DES_cbc_encrypt/AES_cbc_encrypt/g'

    # Configure
    CFLAGS="-I$BUILD_DIR/openssl-$OPENSSL_VERSION/include -DNETDB_INTERNAL=-1 $CFLAGS" \
    LDFLAGS="-L$BUILD_DIR/openssl-$OPENSSL_VERSION $LDFLAGS" \
    ./configure \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS

    # Build
    make
    output tcpdump
    echo "** Finished building tcpdump"
}

function build_proberelay(){
    $CROSS_PFX-gcc \
        -I$BUILD_DIR/install/include $CFLAGS \
        -L$BUILD_DIR/install/lib $LDFLAGS \
        -o "$BIN_DIR/proberelay" \
        "$BUILD_DIR/proberelay.c" \
        -lpcap
    $STRIP "$BIN_DIR/proberelay"

    echo "** Finished building proberelay"
}

function build_ncurses() {
    # Download/extract
    extract ncurses https://invisible-mirror.net/archives/ncurses tar.gz $NCURSES_VERSION

    # Configure
    ./configure \
        --disable-shared \
        --enable-static \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS

    # Build
    make libs
    echo "** Finished building ncurses"
}

function build_zlib() {
    extract zlib https://zlib.net tar.gz $ZLIB_VERSION

    # Configure
    ./configure --static

    # Build
    make libz.a
    echo "** Finished building zlib"
}

function build_xz() {
    # Download/extract
    extract xz https://tukaani.org/xz tar.xz $XZ_VERSION

    # Configure
    ./configure \
        --disable-debug \
        --disable-dependency-tracking \
        --disable-silent-rules \
        --disable-shared \
        --disable-nls \
        --disable-lzmadec \
        --disable-lzmainfo \
        --disable-microlzma \
        --disable-lzip-decoder \
        --disable-scripts \
        --disable-doc \
        --enable-small \
        --enable-static \
        --prefix="$BUILD_DIR/install" \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS

    # fuck it, we'll use violence to get static binaries
    sed -Ei \
        's/^(\s+..LIBTOOLFLAGS.\s+--mode=link.*)\\$/\1-all-static \\/' \
        src/xz{,dec}/Makefile

    # Build
    make install
    output "$BUILD_DIR/install/bin/xz"
}

function build_xzdec() {
    # Download/extract
    extract xz https://tukaani.org/xz tar.xz $XZ_VERSION

    # Configure for barebones xzdec
    ./configure \
        --disable-debug \
        --disable-dependency-tracking \
        --disable-silent-rules \
        --disable-shared \
        --disable-nls \
        --disable-lzmadec \
        --disable-lzmainfo \
        --disable-microlzma \
        --disable-lzip-decoder \
        --disable-scripts \
        --disable-doc \
        --enable-small \
        --enable-static \
        --enable-checks=crc32 \
        --enable-decoders=lzma1,lzma2,delta,x86,arm,armthumb,arm64 \
        --prefix="$BUILD_DIR/install" \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS

    # fuck it, we'll use violence to get static binaries
    sed -Ei \
        's/^(\s+..LIBTOOLFLAGS.\s+--mode=link.*)\\$/\1-all-static \\/' \
        src/xz{,dec}/Makefile

    # Rebuild
    make clean
    make install
    output "$BUILD_DIR/install/bin/xzdec"

    # Multicall object
    cd src/xzdec
    sed -E 's/^[ ]*//' <<EoF >> Makefile

    xzdec-main.o: xzdec.c
    	\$(AM_V_CC)\$(CC) \$(DEFS) \$(DEFAULT_INCLUDES) \$(INCLUDES) \$(xzdec_CPPFLAGS) \$(CPPFLAGS) \$(AM_CFLAGS) \$(CFLAGS) -c -DXZDEC_MAIN=xzdec_main -o xzdec-main.o `test -f 'xzdec.c' || echo '\$(srcdir)/'`xzdec.c

    xzdec-multicall.o: xzdec-main.o \$(xzdec_DEPENDENCIES) \$(EXTRA_xzdec_DEPENDENCIES)
    	\$(AM_V_CCLD)\$(LINK) --entry xzdec_main -r xzdec-main.o \$(filter-out xzdec-xzdec.o,\$(xzdec_OBJECTS)) ../../src/liblzma/.libs/liblzma.a
EoF

    make xzdec-main.o xzdec-multicall.o
    echo "** Finished building xzdec"
}

function build_lz4() {
    extract lz4 https://github.com/lz4 git $LZ4_VERSION
    make
    #output programs/lz4
    echo "** Finished building lz4"
}

function build_xxHash() {
    extract xxHash https://github.com/Cyan4973 git $XXHASH_VERSION
    make
    #output xxhsum
    echo "** Finished building xxHash"
}

function build_zstd() {
    extract zstd https://github.com/facebook git $ZSTD_VERSION

    make clean
    CFLAGS="-I$BUILD_DIR/zlib-$ZLIB_VERSION -I$BUILD_DIR/lz4/lib $CFLAGS" \
    LDFLAGS="-L$BUILD_DIR/zlib-$ZLIB_VERSION -L$BUILD_DIR/lz4/lib $LDFLAGS" \
    FLAGS="$CFLAGS $LDFLAGS -Os" \
    make zstd ZSTD_LEGACY_SUPPORT=0 \
              HAVE_ZLIB=0 HAVE_LZMA=0 HAVE_LZ4=0 BACKTRACE=0
    output programs/zstd zstd-only
    CFLAGS="-I$BUILD_DIR/zlib-$ZLIB_VERSION -I$BUILD_DIR/lz4/lib $CFLAGS" \
    LDFLAGS="-L$BUILD_DIR/zlib-$ZLIB_VERSION -L$BUILD_DIR/lz4/lib $LDFLAGS" \
    FLAGS="$CFLAGS $LDFLAGS -Os" \
    make -C programs zstd-decompress ZSTD_LEGACY_SUPPORT=0 \
              HAVE_ZLIB=0 HAVE_LZMA=0 HAVE_LZ4=0 BACKTRACE=0
    output programs/zstd-decompress unzstd

    make clean
    CFLAGS="-I$BUILD_DIR/zlib-$ZLIB_VERSION -I$BUILD_DIR/lz4/lib $CFLAGS" \
    LDFLAGS="-L$BUILD_DIR/zlib-$ZLIB_VERSION -L$BUILD_DIR/lz4/lib $LDFLAGS" \
    FLAGS="$CFLAGS $LDFLAGS -DZSTD_NO_UNUSED_FUNCTIONS -Os" \
    make zstd ZSTD_LEGACY_SUPPORT=0 \
              HAVE_ZLIB=0 HAVE_LZMA=0 HAVE_LZ4=0 \
              HAVE_THREAD=0 ZSTD_LIB_MINIFY=1 BACKTRACE=0 ZSTD_NO_INLINE=1
    output programs/zstd zstd-mini
    CFLAGS="-I$BUILD_DIR/zlib-$ZLIB_VERSION -I$BUILD_DIR/lz4/lib $CFLAGS" \
    LDFLAGS="-L$BUILD_DIR/zlib-$ZLIB_VERSION -L$BUILD_DIR/lz4/lib $LDFLAGS" \
    FLAGS="$CFLAGS $LDFLAGS -DZSTD_NO_UNUSED_FUNCTIONS -Os" \
    make -C programs zstd-decompress ZSTD_LEGACY_SUPPORT=0 ZSTD_NOCOMPRESS=1 \
              HAVE_ZLIB=0 HAVE_LZMA=0 HAVE_LZ4=0 \
              HAVE_THREAD=0 ZSTD_LIB_MINIFY=1 BACKTRACE=0 ZSTD_NO_INLINE=1
    output programs/zstd-decompress unzstd-mini

    make clean
    CFLAGS="-I$BUILD_DIR/install/include $CFLAGS" \
    LDFLAGS="-L$BUILD_DIR/install/lib $LDFLAGS" \
    FLAGS="$CFLAGS $LDFLAGS -DZSTD_NO_UNUSED_FUNCTIONS -Os" \
    make zstd ZSTD_LEGACY_SUPPORT=0 \
              HAVE_ZLIB=0 HAVE_LZMA=1 HAVE_LZ4=0 \
              HAVE_THREAD=0 ZSTD_LIB_MINIFY=1 BACKTRACE=0 ZSTD_NO_INLINE=1
    output programs/zstd zstd-xz-mini

    make clean
    CFLAGS="-I$BUILD_DIR/zlib-$ZLIB_VERSION -I$BUILD_DIR/lz4/lib $CFLAGS" \
    LDFLAGS="-L$BUILD_DIR/zlib-$ZLIB_VERSION -L$BUILD_DIR/lz4/lib $LDFLAGS" \
    FLAGS="$CFLAGS $LDFLAGS -O3" \
    make zstd BACKTRACE=0 ZSTD_LEGACY_SUPPORT=2
    output programs/zstd zstd-fast

    make clean
    CFLAGS="-I$BUILD_DIR/install/include -I$BUILD_DIR/zlib-$ZLIB_VERSION -I$BUILD_DIR/lz4/lib $CFLAGS" \
    LDFLAGS="-L$BUILD_DIR/install/lib -L$BUILD_DIR/zlib-$ZLIB_VERSION -L$BUILD_DIR/lz4/lib $LDFLAGS" \
    FLAGS="$CFLAGS $LDFLAGS -O3" \
    make zstd BACKTRACE=0 ZSTD_LEGACY_SUPPORT=2
    output programs/zstd zstd-full

    make clean
    CFLAGS="-I$BUILD_DIR/zlib-$ZLIB_VERSION -I$BUILD_DIR/lz4/lib $CFLAGS" \
    LDFLAGS="-L$BUILD_DIR/zlib-$ZLIB_VERSION -L$BUILD_DIR/lz4/lib $LDFLAGS" \
    FLAGS="$CFLAGS $LDFLAGS -Os" \
    make
    output programs/zstd

    echo "** Finished building zstd"
}

function build_readline() {
    # Download/extract
    extract readline https://ftp.gnu.org/gnu/readline tar.gz $READLINE_VERSION

    # Prevent building examples (which can't be done when cross-compiling)
    sed -i -e 's|examples/Makefile||g' configure.ac

    # Configure
    autoconf
    ./configure \
        --disable-shared \
        --enable-static \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS

    # Build
    make

    # Note that socat looks for readline in <readline/readline.h>, so we need
    # that directory to exist.
    ln -s "$BUILD_DIR/readline-$READLINE_VERSION" "$BUILD_DIR/readline"
    echo "** Finished building readline"
}

function build_dropbear() {
    # Download/extract
    extract dropbear https://github.com/mkj git DROPBEAR_$DROPBEAR_VERSION

    if [ ! -e configure ]; then
        autoconf; autoheader
    fi

    SAVED_CFLAGS="$CFLAGS"
    CFLAGS="$CFLAGS -Wno-undef"

    # Configure
    ./configure \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS \
        --enable-static \
        --prefix=/ \
        --exec-prefix=/usr \
        --disable-zlib \
        --disable-lastlog \
        --disable-utmp --disable-utmpx \
        --disable-wtmp --disable-wtmpx \
        --disable-pututline --disable-pututxline \
        --enable-bundled-libtom

    # Set build options
    sed -E 's/^\s*//' <<EoF > localoptions.h
        #define INETD_MODE 0

        #define DROPBEAR_SVR_LOCALTCPFWD 0
        #define DROPBEAR_SVR_REMOTETCPFWD 0
        #define DROPBEAR_SVR_AGENTFWD 0

        #define DROPBEAR_USER_ALGO_LIST 0
        #define DROPBEAR_CHACHA20POLY1305 0
        #define DROPBEAR_AES128 1
        #define DROPBEAR_AES256 1

        #define DROPBEAR_ENABLE_CTR_MODE 1
        #define DROPBEAR_ENABLE_CBC_MODE 0
        #define DROPBEAR_ENABLE_GCM_MODE 1

        #define DROPBEAR_SHA1_HMAC 0
        #define DROPBEAR_SHA1_96_HMAC 0
        #define DROPBEAR_SHA2_256_HMAC 1

        #define DROPBEAR_RSA 0
        #define DROPBEAR_DSS 0
        #define DROPBEAR_ECDSA 0
        #define DROPBEAR_ED25519 1

        #define DROPBEAR_SK_RSA DROPBEAR_RSA
        #define DROPBEAR_SK_DSS DROPBEAR_DSS
        #define DROPBEAR_SK_ECDSA DROPBEAR_ECDSA
        #define DROPBEAR_SK_ED25519 DROPBEAR_ED25519

        #define DROPBEAR_DH_GROUP14_SHA1 0
        #define DROPBEAR_DH_GROUP14_SHA256 0
        #define DROPBEAR_DH_GROUP16 0
        #define DROPBEAR_DH_GROUP1 0
        #define DROPBEAR_ECDH 0
        #define DROPBEAR_CURVE25519 1

        #define DROPBEAR_SFTPSERVER 0
        #define DO_MOTD 0
EoF
    # update version string
    sed -En "s/^(#define\s+DROPBEAR_VERSION\s+\"[0-9.]+).*/\1+$(git log -1 --format=%h)\"/p" \
        sysoptions.h >> localoptions.h
    # hide version banner
    sed -Ei 's/^(#define\s+LOCAL_IDENT).*/\1 "SSH-2.0-dropbear"/' sysoptions.h
    # Enable the delay hostkey option by default
    sed -Ei 's/^(\s*svr_opts.delay_hostkey\s*=\s*)0;/\11;/' svr-runopts.c
    # fully disable RSA
    sed -Ei 's/^(#define DROPBEAR_RSA_SHA1) 1$/\1 DROPBEAR_RSA/' default_options.h
    # fully disable DSA
    sed -Ei 's/^(#define DROPBEAR_DSS) 1$/\1 0/' sysoptions.h

    # actually compile
    if [ "$MUSL_CROSS" = "x86_64-linux-musl" ]; then
        sed -Ei 's/^(#define DROPBEAR_RSA) 0$/\1 1/' localoptions.h
        sed -Ei 's/^(#define DROPBEAR_ECDSA) 0$/\1 1/' localoptions.h
        sed -Ei 's/^(#define DROPBEAR_DSS) 0$/\1 1/' localoptions.h
        sed -Ei 's/^(#define DROPBEAR_DSS) 0$/\1 1/' sysoptions.h
        make PROGRAMS='dropbearconvert dropbearkey' MULTI=1
        output dropbearmulti dbkeyconv
    else
        export LTM_CFLAGS='-Os'
        make PROGRAMS='dropbear'
        output dropbear

        make PROGRAMS='dbclient'
        output dbclient

        make clean
        CFLAGS="$CFLAGS -DDROPBEARKEY_RETURN_TRUE=1" \
        make PROGRAMS='dropbear dropbearkey' MULTI=1
        output dropbearmulti dbmulti

        make clean
        CFLAGS="$CFLAGS -DDROPBEARKEY_RETURN_TRUE=1" \
        make PROGRAMS='dropbear dbclient dropbearkey' MULTI=1
        output dropbearmulti dbmulti-cli

        make clean
        CFLAGS="$CFLAGS -DDROPBEARKEY_RETURN_TRUE=1" \
        make PROGRAMS='dropbear dropbearconvert dropbearkey' MULTI=1
        output dropbearmulti dbmulti-conv

        make clean
        make PROGRAMS='dropbear dropbearkey' MULTI=1
        output dropbearmulti dbmulti-key

        make clean
        CFLAGS="$CFLAGS -DDROPBEARKEY_RETURN_TRUE=1" \
        make PROGRAMS='dropbear scp dropbearkey' MULTI=1
        output dropbearmulti dbmulti-scp

        make clean
        CFLAGS="$CFLAGS -DDROPBEARKEY_RETURN_TRUE=1" \
        make PROGRAMS='dropbear dbclient dropbearconvert dropbearkey' MULTI=1
        output dropbearmulti dbmulti-cli-conv

        make clean
        make PROGRAMS='dropbear dbclient dropbearkey' MULTI=1
        output dropbearmulti dbmulti-cli-key

        make clean
        CFLAGS="$CFLAGS -DDROPBEARKEY_RETURN_TRUE=1" \
        make PROGRAMS='dropbear dbclient scp dropbearkey' MULTI=1
        output dropbearmulti dbmulti-cli-scp

        make clean
        make PROGRAMS='dropbear dropbearconvert dropbearkey' MULTI=1
        output dropbearmulti dbmulti-conv-key

        make clean
        CFLAGS="$CFLAGS -DDROPBEARKEY_RETURN_TRUE=1" \
        make PROGRAMS='dropbear dropbearconvert scp dropbearkey' MULTI=1
        output dropbearmulti dbmulti-conv-scp

        make clean
        make PROGRAMS='dropbear dropbearkey scp' MULTI=1
        output dropbearmulti dbmulti-key-scp

        make clean
        make PROGRAMS='dropbear dbclient dropbearconvert dropbearkey' MULTI=1
        output dropbearmulti dbmulti-cli-conv-key

        make clean
        CFLAGS="$CFLAGS -DDROPBEARKEY_RETURN_TRUE=1" \
        make PROGRAMS='dropbear dbclient dropbearconvert scp dropbearkey' MULTI=1
        output dropbearmulti dbmulti-cli-conv-scp

        make clean
        make PROGRAMS='dropbear dbclient dropbearkey scp' MULTI=1
        output dropbearmulti dbmulti-cli-key-scp

        make clean
        make PROGRAMS='dropbear dropbearconvert dropbearkey scp' MULTI=1
        output dropbearmulti dbmulti-conv-key-scp

        make clean
        make PROGRAMS='dropbear dbclient dropbearconvert dropbearkey scp' MULTI=1
        output dropbearmulti dbmulti-cli-conv-key-scp
    fi
    echo "** Finished building dropbear"
    CFLAGS="$SAVED_CFLAGS"
}

function build_socat() {
    # Download/extract
    extract socat http://www.dest-unreach.org/socat/download tar.gz $SOCAT_VERSION

    # Configure
    SOURCE_DATE_EPOCH="$(date -r CHANGES '+%s')" \
    BUILD_DATE="$(date -r CHANGES '+%b %e %Y %H:%M:%S')" \
    CFLAGS="-I$BUILD_DIR -I$BUILD_DIR/openssl-$OPENSSL_VERSION/include -DNETDB_INTERNAL=-1 $CFLAGS" \
    LDFLAGS="-L$BUILD_DIR/readline-$READLINE_VERSION -L$BUILD_DIR/ncurses-$NCURSES_VERSION/lib -L$BUILD_DIR/openssl-$OPENSSL_VERSION $LDFLAGS" \
    LIBS="$BUILD_DIR/ncurses-$NCURSES_VERSION/lib/libncurses.a" \
    ./configure \
        --enable-openssl-base=$BUILD_DIR/openssl-$OPENSSL_VERSION \
        --enable-openssl \
        --enable-msglevel=info \
        --disable-tun \
        --disable-sctp \
        --disable-vsock \
        --disable-readline \
        --disable-sycls \
        --disable-filan \
        --disable-udplite \
        --disable-dccp \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS

    sed -Ei 's/#define\s+HAVE_GETPROTOBYNUMBER_R.*/#define HAVE_GETPROTOBYNUMBER_R 0/' config.h

    # Build
    SOURCE_DATE_EPOCH="$(date -r CHANGES '+%s')" \
    BUILD_DATE="$(date -r CHANGES '+%b %e %Y %H:%M:%S')" \
    make
    output socat socat-openssl

    make clean
    SOURCE_DATE_EPOCH="$(date -r CHANGES '+%s')" \
    BUILD_DATE="$(date -r CHANGES '+%b %e %Y %H:%M:%S')" \
    CFLAGS="-I$BUILD_DIR -DNETDB_INTERNAL=-1 $CFLAGS" \
    LDFLAGS="-L$BUILD_DIR/readline-$READLINE_VERSION -L$BUILD_DIR/ncurses-$NCURSES_VERSION/lib $LDFLAGS" \
    LIBS="$BUILD_DIR/ncurses-$NCURSES_VERSION/lib/libncurses.a" \
    ./configure \
        --disable-openssl \
        --enable-msglevel=info \
        --disable-tun \
        --disable-sctp \
        --disable-vsock \
        --disable-readline \
        --disable-sycls \
        --disable-filan \
        --disable-udplite \
        --disable-dccp \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS

    sed -Ei 's/#define\s+HAVE_GETPROTOBYNUMBER_R.*/#define HAVE_GETPROTOBYNUMBER_R 0/' config.h

    # Build
    SOURCE_DATE_EPOCH="$(date -r CHANGES '+%s')" \
    BUILD_DATE="$(date -r CHANGES '+%b %e %Y %H:%M:%S')" \
    make
    output socat

    echo "** Finished building socat"
}

function build_rsync() {
    # Download/extract
    extract rsync https://download.samba.org/pub/rsync/src tar.gz $RSYNC_VERSION

    OPTS="--disable-roll-simd --disable-roll-asm --disable-md2man --disable-debug --disable-locale"
    if [ "$MUSL_CROSS" != "x86_64-linux-musl" ]; then
        OPTS="$OPTS"
    else
        OPTS="$OPTS"
    fi

    # Configure
    CFLAGS="-I$BUILD_DIR/openssl-$OPENSSL_VERSION/include -I$BUILD_DIR/zlib-$ZLIB_VERSION -I$BUILD_DIR/xxHash -I$BUILD_DIR/zstd/lib -I$BUILD_DIR/lz4/lib $CFLAGS" \
    CXXFLAGS="$CFLAGS" \
    LDFLAGS="-L$BUILD_DIR/openssl-$OPENSSL_VERSION -L$BUILD_DIR/zlib-$ZLIB_VERSION -L$BUILD_DIR/xxHash -L$BUILD_DIR/zstd/lib -L$BUILD_DIR/lz4/lib $LDFLAGS" \
    ./configure \
        --disable-debug $OPTS \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS

    # Build
    make
    output rsync rsync-openssl

    make clean
    # Configure
    CFLAGS="-I$BUILD_DIR/zlib-$ZLIB_VERSION -I$BUILD_DIR/xxHash -I$BUILD_DIR/zstd/lib -I$BUILD_DIR/lz4/lib $CFLAGS" \
    CXXFLAGS="$CFLAGS" \
    LDFLAGS="-L$BUILD_DIR/zlib-$ZLIB_VERSION -L$BUILD_DIR/xxHash -L$BUILD_DIR/zstd/lib -L$BUILD_DIR/lz4/lib $LDFLAGS" \
    ./configure \
        --disable-debug $OPTS \
        --disable-openssl \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS

    # Build
    make
    output rsync

    echo "** Finished building rsync"
}

function build_libsodium(){
    # Download/extract
    extract libsodium https://github.com/jedisct1 git $LIBSODIUM_VERSION

    # Configure
    ./configure \
        --enable-static \
        --disable-shared \
        --disable-asm \
        --disable-ssp \
        --without-pthreads \
        --prefix="$BUILD_DIR/install" \
        --build=x86_64-linux-gnu \
        --host=$MUSL_CROSS

    # Build
    make install
    echo "** Finished building libsodium"
}

function build_minisign(){
    # Download/extract
    extract minisign https://github.com/ryancdotorg git $MINISIGN_VERSION

    # Build
    WITH_PTHREADS=0 \
    CC="$CROSS_PFX-gcc" \
    CFLAGS="-I$BUILD_DIR/install/include $CFLAGS" \
    LDFLAGS="-L$BUILD_DIR/install/lib $LDFLAGS" \
    make bin/miniverify bin/minisign \
         obj/miniverify_multicall.o \
         obj/minisign_multicall.o
    output bin/miniverify
    output bin/minisign
    echo "** Finished building minisign"
}

function build_sha2sum(){
    # Download/extract
    extract sha2sum https://github.com/ryancdotorg git $SHA2SUM_VERSION

    # Build
    CFLAGS="-I$BUILD_DIR/install/include $CFLAGS" \
    make bin/sha2sum bin/sha256sum \
        obj/sha256sum_multicall.o \
        obj/sha2sum_nacl_sha512_multicall.o
    output bin/sha2sum
    output bin/sha256sum
    echo "** Finished building sha2sum"
}

function build_multicall(){
    # Download/extract
    extract multicall https://github.com/ryancdotorg git $MULTICALL_VERSION

    # Build
    LDFLAGS="-L$BUILD_DIR/install/lib $LDFLAGS" \
    make bin/multicall-miniverify-sha256sum{,-xzdec} \
         bin/multicall-mini{verify,sign}-sha2sum{,-xzdec}
    output bin/multicall-miniverify-sha256sum
    output bin/multicall-miniverify-sha256sum-xzdec
    output bin/multicall-miniverify-sha2sum
    output bin/multicall-miniverify-sha2sum-xzdec
    output bin/multicall-minisign-sha2sum
    output bin/multicall-minisign-sha2sum-xzdec
    echo "** Finished building multicall"
}



function unpack_patches() {
# tar -C BUILD_DIR -cz --owner=0 --group=0 patches xxd.c | base64 -w79 \
# | sed -e '/[<]_eof/,/^_eof/{//!d;r /dev/stdin' -e '}' builder.sh \
# | sponge builder.sh
base64 -d <<_eof | tar -C "$1" -xvz
H4sIAAAAAAAAA+w8a3PayJb5in9Fj7cmAVvCevIwSWocG8fc+FWAM8lkplRCaowqIHEl4dgzk9+z/2N
/2Z7T3RKSEDae+OburR0lBqkfp0+fPu9uMbdjZ0KjvWf/wkuBq9k02TdcxW92rxoNpdHU4Go8U1RVU4
1nxPxXIpVciyi2Q0KehUEQ39fuofr/0Gsu1v/2d/n2d5c68mwxjT3Hnk7rrjceP8kYuMCNhrF2/Zumu
Vx/WHhFNRuq9owoTzL6A9f/8/XHRSayfO3FxN6LQmePcQH/rDtktFq25fkuvSWm2XBMo1WvO1R3XNcm
KiyyYWzJslwGaWt3d7cU2k8/EVlralKb7OKXahAoWfhOMJuHNIqq099nthXFIbVnZAe+ZxI57p12yc7
Ym1KJOIEfxcSZwBqyEt+e0doWqXzdIvB/a/e/vDGgOyYffjnqHlpnB71zKIMCz6eZMjKzPR8q6DSiW7
ueH2fqqvhoh9eOJIbZgYebWgeb+0A+GIVAky0ZYaxpvLX7ILwt8gegvbdHer4Xe/bU+52SeRhc44TIl
4nnTMgXuPGmUzKiZBFRF0YlNAyDkMyAUPY1jeoAIV58nnojK+lqeQCuKjAuWf9E/t0wmI+oHcrhwo+9
GZU9l/rx0+iA++VfbTSbOsi/aahqU2/qGsg/MJLxt/x/j+uN59vhHUHRiUjCBPUg9K736qAU9riw276
bVmbLkT1ouMWVSLg4L0A4sz9ThFwHTk27ZwqZsljbpaIpmi6rmqypRNX3TX1fadSNpqGBplFBXSDzML
VSBjrXubVv6PuqWW+1lZaitxpJZ9Q9piI1yS77/OknkJ+KM/VkexFP5ovRZ3pXDwgWxM58/MUVDyC2v
k+n4gnbgkjT0HZiKPo1hXENAsQ7gYqQD097g/f9izf/GLwC3TYLfDkCqfUCH+rntvOZYmdRY0+vg+XT
Z3rL4O5+KwjxwCVbYFoRhZk5LQuW4GF6MydwQcUEZBpce34IyjsBAcSRbcehc4Q69aKY+jREnMLAAQh
yips7sa7DYDGPiqOD0gnmMRY7XuiMFshVAhZ8+TT22GQmNvyfB1NclWtnVg/Wcl5uqs6SQ/LlJfyXb1
BR201FVlT4TxR1X1Hgfz11WoGL1CILFvqnXKgRRUMuVJp1U20aZhtc3AwXKhJAU6VmG5kQjJbvTBcuJ
dviJqpPtrPF7mgRe9NCIR8Ty5jZI0f9i8s33YO+1b86H/bOulbvqHs+3Nrd2yH940NiaKZO/ue/iVHX
SGTfRSSeUMJgeGNwAGOQWTC3nn9Nzq4GQzA6W7tkhwwGJzKsaxzc0BB5Q46CcfzFDql4JoNLxkEAJiK
HfXJ6zLoxEOcXQ7TXMdhJYhN/MZ1KTLMI+MSOySwAa46IoWkEgQKg2H9vaxfUNPil4BlE3rXPjF9Mom
hiMYwtMPzkFWl10nbMtKb1nwDkb9DgjxeDFxL7O4E/Gf40+KvDn8Kev3aQeEAgP4iBHuB0uECbMWUYs
BFpbKVQq9x+JxSwBAkSu56QoQaWfbdShmslNxuffsm1yPXA1hH4BBb4Dje2N8V6eAzG1bRZjch5GGwy
FeCEahFF8uoVOb86PeWoVVariZhbrVpdAG7zOLTiWvX04vDglLNRjeySFjpB4GnhKGNwQ5hn40FnpdM
RkBkUB5EtDPHJ2939jSPIMHQQpRe/Ki9Ex8oIiP8Z4Ve+EnTLCLYSU4cRyJ9/AtyXcHeriYfX+NA85g
8ITU6BhTRehD6R1Q6BxQ0WMQnGJAK9RAng7fk34G+5S55jy10RM1uu3KccdQF/mJfDUJRlhtmSHGxKi
Rj8kCM2VhWWumQtN8B8cyRfkBcFNPFpzZIt1yyZQHatyhcrs1r3LRfr5S97/bVlSaa8ycJkVwb7ib5F
YSyKTYKZAvesR05Qr0uUANgsiQgB9fkEmeDlBnqNqk3M3rJGCw9Cbd9agDFFwzaa0iqXqCUFffIyrwd
E78TeWPQW3Pvt0wAidq68iRuAJ4f6awwxHWhabk23GeQNR81jDULWShQFn6DQT3EINzmlwMaY0Zkzv6
syimQqJezGWwjqVrNUrQnKCzT+KEJKcZIKBFkPcUWB8sXPr60I4h5wJNCBWnUjWOl6J4JVr/FiW5rSb
qitMi92be/2vtrYV/R6w1Tbbd1sZB0IvSU1yC58cjd26RVQx0GfIFPiLMIbqpkApFgR3s3jwAJ3w1nn
WoArKwzsTQCiCTh6IlyNaBWLYDlyLcAJtlC6wJWOkgaIr9E00e82mg1J1bnnDf9zYgbAJ3Y0gdUXUgo
rVmgS0lkQ05woQyM532iKwlFsc6+HxFVgph/zH1YM9irgvGbI1EuJhs+U1XgOgaUc+Ig7mVqAlhGeDc
YuF8dljqIy7B8cdqvV7Zcyedf90DvvDbdrtUw5xSAGSOrcWLPo2hJri23YgrV1HigpwGhsvb4yqKC4M
YKOmfsIfQiuGWpqubIhjqRSsoyiJUQgdV7LSdZhY65wRnGk3RXOELFei81BNdJoD108nKqFAVNUFQPg
rN5bhxKbFARzAORFRBLvSLjFVXBv0X09PyX0lgmKW+MTryBm80XMG7JJLFEuKsU86lyd3d8/x1er/RP
0Bxz9iIK4h5ujTx4avrAm0gqtGREZvbU2o7dupvT+FsI+DWbfRp1/++KKCfQSIs7tu2kAYQp4TjmaQq
BmnQ3eWkLUM/SDGGYOrI4Di86ccuLBGlGI733ADYZ7wCwmCYJV05jWrDePaZO/bCLLIbT3NQy162bTN
HVNMRpZM2kyM2mumMkk/5G3iEleIl/K8xGbWUhnQp3PmFAF7zYqWshpAJwW0Sl1Yku0ydpI3WxJLcS2
Lakaw5epXAY3Ar1uiflb2ag98KvorMkV7veRnS+hF1N4ADWJqw/GuLqqhsn2r+Gv/jZGdWqtw3sjk47
uYhpVExASBjWYb09NkYgSySooqUTZJ6MwOSixsebT21iIiTU2XHakAlARJP0avtiwoc8a3kPgVXuk1k
SXx1D1QUWfgLCo/88FXdAUJtYis6yTX8GuS4kSBSXSKmoenwpLOhZcWAVls620DBWcP2M1B8bdwXTjJ
vXRGAdZJ9Zy/6asqjxz9vQ5nc6jY8KOyMvlZ1XwPFemlqsnaurQ7T4YuUQ3YZpXzejnXHHJcufqc2vX
2NdAtSp1TdUNXW229DLNvKY7S3/q5r5p1JVmUzUUQ9czSw9+Aqhl5i3k1fIy0ZkpZLntfBF13Mi+RyW
npS+vw3l98lo4KKrSwIFVpSmpCht602tbPiAv2TbBdAHm8vUn6SXMGTglev0bqLhHACo8d30MycHpAG
fch6B+vhhNwVRA/ERwOOTgYHE9yQ3OBkwY497ABq9t+RfyUvD168oF3IVAKnQY0ixdwRtC+EnfQ/IyE
YLXlQGNSd74JP5T0oZ1TYIQAeI9zvM9H4Gjjih331y9tVgskja8wYaAyiiIKKmGdE7tmGDaahZwHLGi
hiDYYhoKW0zDTBaT2Zgd8ALpLXWssWvZ4TXhybhOWguUxT2jQjnLHz0YI+6s5DVTMEmDNAuYViTUyEG
/PL162ztfsg3vzPegLL7MSwwFBOYjqGzSutrmW+ebM54PLAYgn+fG6GzeX6T8NuY7x4ZFfPHLi33BSs
n4RQp2RH0mpSj6Hq70TYhb7JMjcZGxOLAbAMb5zAWDeW3Foe3Q3d3E8+J+Ih5I0ETkUqnYrjsJohioV
RVMw+OJSmWVh0SW8gGisGRbznKUGJ50G+GHV0RJc6eFDGBPJEt57gD4fIGdRNav8jUrg19F7M72f1f2
/2EqMs+QyXG4oE9xAuCh8z/gpj9TDRWaKIaiqbj/31Qbf+//f49r1QFInnDzm1lwlVlwnWj6vqqB/1Z
vGU08rKGXhmYr3TXmNLaIpoL139f0etPUzaZuMKcxcQBUU2W6G76E7uaJMeZblR+sIexQC56aKdNA77
ofrX53eNU/B9G/6uIO1RwMUzyG4McFiyeBb7HENE2aT8B2gc+2cHDjeryYTu9+IFW0OHgeyY7R1tQK+
wOZDBvbTEktCKAo9BRXCv/upS69EvmPILqIZT9wJ0937i+5Hjj/09QaTZR/xlNaA89/wt3f8v9driR6
IJwB1HqzbtS1vSiaOlOMG3LFjD/SOhY8lHfjagPlXsfTN6A5NC0XLCZq4x7wqeoB3aGqqHrMNsDQmkp
Db+VyOqrKXSBVhA9wCfkMabSYxp3CWcCLy+75YHBqnV9YRydcxUR3DpYcDj9gesyKZ3PLnVRFEYR98a
1Ejk7IjjthGgcuvv0gwMN1hF6EVt0uAfPjXCI/zmvboLoQDsAQXobaSny3FHEGRi0FUyPya/Kjuy2Jc
WudNVPNH0xM5oaQHG8+oaGF52pwchDnRtP8GUpw38tmyHYAtCaia6Rh2tdU9a4nLhINELjsnlks1T7y
Aiif26E9i6pvehcQJc85aXeANHM6s+Z2FH0JQtdyRkD4kcTzXTuLBC1su0J4o7pdPgSnffIHa8CnwkM
Fw9CXlP/6MDUZvjAb+GabWujzVctOoOZpOgtcmmDPQCTQ7xe+yT3SMVkvfJMnEL5JUfiMfcOog9lvqy
2tnd13NDS2jYfnd5GOBVlaRNS6DL0bO6bvIMZg9MoLVZF6EgMR382Zb81TnXnZBMfYG98VwDA3AcgsM
ddbMG91h7e18Dj7yHY+19CLkMgHU2lbg+FFv8sh8I24J1EOGX+gpGdB/NaQAUWw8xdFF/rxpDLveJ3S
y+I8l3YVKshkG2INRSxflt5jCJuzzROE+gfnRxa9dnOMD27EhO1OfAc90HkqkexkskBABVVNyJBk4Qq
c7NBQJDrgfgJOqRhNGtfIhu3Wwi5KCTSW4jzY8ialEDNy4kgz6WYJaKVm7YqtASu435HcPNBMeSb+Lo
eR5WVHivKAipUrUIqNooRQZRUrvVdFQoxfVsHZQ2M6TtVa5ezBBEUAEfe5NqnAzGskc3+PsGQ6lwvMS
LqV5hKYxPurs4KSgZmTlbE0q5GVkszWQdHK3EXL1HqpCck2KDNT2fpvslWrgFKDBYDAYDVaSsM0Gmo2
1ay2DHzXBL9UNZ9tfhnMqQ/KDq0gyxGv1kDkuKYmtH0Xq9au6UoPCLXKQY18XpGEtZlk1snB+6512ju
/+mC9P7MGF4fvusOBlQM/9fzF7d7NzAKSfaa4ebmEtWZNb71AFoOXu/y5BiVrmqsXS6GAf4trqjT2lf
ama1oGKLOmWqOutBqm2Wi3sxGAqqlcQlUhoVzVg0FcODEJ5jEeacJvS8AWgs7ymK/IH2RblMu8HFxsv
LaXTxeXQytZ0Pfdfu/4I2/ytn9xdZnUSOTyxBpcdg8lMvx42bXeXFycYrOL46vzQ1ZBvnY2QC5jP/LY
ZSoAqW18LCJ32O0Pe8e9w4NhV7ofO3yL6vzgDJo9Fj9MmCRXDj+oEKRj5Eses/i9635ctvhL+K0TsAf
RdidMPa6iLSqSVXcn/C6L9tHJ5UH/4GyDRV+PthDjh5ffZrnkVTx5RYJm+pRb/gMcX/oG8m6CH3p7pf
hhxRI/8ZTH7/JgePKvxQ/Mazl7QsWSPbfTpyx+3bdH38ieqI/aKnMoIVgS+oiQxO+k+C5jkhLEgzwzG
k8CN9k2w1M6aWPHE423T3pvT/Zl7LMvXw7e7cs23m8zANzjKQWAVGHCmhmP8RZ7qTAYi9NCZM49S7bJ
iLviayQsBzeRpnWgwZXn3giHKJg/B0IwegZCVvPh/mYQejF/OW11YoINH+zteiF14iC8WwWBnJLpD6Q
Ig/kduQa4lFHTtekM9zSZJSVsPADClpgdtd1tp5Evzx2ECFac7MI98HLpfL6c/TKJ81BXLjjPl1PftC
tTuc8FL9wT6m4CK9WDzzM8kI3INgHChOy5WIDCLEZBMOVdsj0uB92rowvRaR7RhRtgP/SIMlZ50Ls4t
86vzt50+/xlEEXBF/4U5ZR7CWqbbzKo7WZy0IBhjS8fMMcqCSJm9q3FXnJKd3X//JNw/9mtrm3Ezyiy
2fxxH5HhKr7MxFjSnWiK0bLmn9ibSlukwmYgKbeuAx/g2yi3DQM+zAZ8jFz4aGPFSIMPm91R+HDaWNG
CDzrGOxM+dJYXwVdlsOvYxrZYbjbxDru62ItibRMrHBzW0BEwQlexSRO7tbDWHUvC7eLbpKrW0JZ5NJ
Kk0uACws7Jc3JN8EwBxkYuGd2BauBxUo0EvoOvfcW2M4EqIZ+EpC3yGRV8d8wKFvF+0qwjEncMGV3jU
byuG0IkeRZzTKpMZkA5JEk4IvJwEDTdKw6EiLxOLuXAL7Z1u1l+ABM8SxReil1cWJC9nR8I23cm44Xv
sNMjiX5RdYNlW1XdTJi1kiQnB8ODIW5u9T+egpvX72TI/sBsEmKkynv5ZhKAz6v15A2wBPPMMBzBhkC
w2UoR5EhUlgzwNacZvgry4Zlx1KfAFKnvEPg+5QY9IcMGwUppAJpr8ECwsgxAVYXgFkNzXzf/SrCyEo
Ca+7pa14E6htFUtOxZJ5ZN0BK7wQ/6bBqxdDbvkOHGR/QCE7FeJDYFIpgoIzUbI82M4mNmyUzhIzqAy
VmbeIcFFcflylc7c2huTcdvyWcUgGRZCQJoVdUUtaEZ+Zd+WC5DX+YyKr1jkRUg1W33GhZBxuNdPri6
FWY8o8BixRYvrpV1eahHZr+9jEsQoCiqsmCKwykwR22loQjCHtM6Wts8mzVhOFpHvX73cLiEA3oI4DD
nMIVi8eda7oiVqjYVPIcN31p6OmFTz4M8f05+SFyHDKEOL84ui5Na6kL+2yfFySXlj1yClTB3IwoXem
1A6dLuLMrK90Snj1Pw597wBAKpy8GazmNvvjIultX+b56l+E+8Vs5/uXRq38ninNt3+f0X+Ie//4S//
aU3VKPBfv9F/fv3X77LlVjCW4I/61I4Cpa+/rI83pUWlRwdT+vKT4012yb4ik2l7NTYuq6ahifO2622
0WwajawbpaomV8qmeB8RdAhGUyzhsSP4F3f4ZHYsi7G1lRbL6SEtUcRc9ejT2cEH6+RiMISYefBbRxz
p8hczK9esk9keKSUcnoIvvDKcFq05c5++7vs4wq3rqqn7RrtuakajabRzr1morRZasV38Fn774Un38N
3hafegP7z4ud8bdsV7kLnTq0fd04OPCXGQqhgA3YQWW7cceWtQi28gVbAatPYipElVlb1chC/il9eRz
IZVdvDjq19+eZjkT/G6w+PJv647vu7QqLdUQ28bWjt72pHtt+OueyN1JtKZdo/Yq9nJGfhKRSbUZUXk
xyh70F++d3X4Afp+pXIYUsyHCRpHxI4gjPznAvwcF6CBeBQO5x9XKkeB/4Kds/+Me/4BwaMT+Ls9vsv
GFw1ppXJpRxHB/Bh7iTL5vR9C/RsvDHw8gExi/Nkeb+omlcl5f/YSTG9w8Oa0aw0+Dk4v3nLmbPC9Vr
OdvGWcshh4ULGL+/bJm+BpzTwIYwfQi1dqxKzTI5hypZxjV0F6rshN0tu57bvQcEbBObQw2qguT+33j
jCjl+Si0vLB+77F3nsbHl4e/3z0v+xd63fbtpL/bP8ViO/JFZWIiiQ/EjvZtIqspG79OpbzaNMcXYqi
ZDYUqUNSsZVt//ed3wxAQg/bac/t7n64zkMWCQyAmcHMYDAY2JDjhA9y5f5UGuUlYZPt+FazOFtdhKm
nRZi6iXnXseY68tyEvLtllQuqIgxw62CbuoKpbTX4umiwqA1OGIwNjqxqHEHS3Ebfdxt7ekGr5arGm/
bRrsOiHUMfkIxVEN+QsYj+4RAgqlii9OjNKYJ626c/P99k4YN9byM6rNYQHsdnuuc19U8OJIKbo5Qk7
aPjtxddOSPJcB7cIsW0F089cNbPsiojo4jDj5KxQ2zcf9++OD06fVNTW689Gt5Q4VAtnMkPyZZVVkdZ
FC6E5v+xIvcuem0tMXgJsru/Xexa25Ue3yELHm948ZzzLwjhdcqB1Xbcu7DB65jleeW+TDPPoGqp9po
ihK5hmOF4E0i2QlnqA/NCkQGEyi92XTDBp2FJeu6azBG36IzDXu8vjWmYZfeNqSxyz5ioD/eMiQm4uN
UP/9h6YmoP86LC6BwS8TgRw/tAXXsidL3hF/h/qE2P5lU8xpEynJFTODyXhvnVhE8m1gWn27u1bbIR9
rZbtW1z3uX339XqwAPfp8/dVtNiwI3n98+TYsy//xfPh2DYxyPuEqwxF90/S5UX626CPCTTSXEMAiQR
CVLSYkOkCNMJKuUwvg13PZGf21i9tYsasehFW2chS+LA6guQVWTfjIJRTloOVB+aDbO7hr9Er06/tbu
3wppLOJYiG8Sit7IvUWgZl3jGDEF9eN1+e3xJnPhLFyeHCJ6q3snURbvfwNfSxulR7/IcFRbZeHW828
927huvFPn3jZfgfdN4qdyfGy8q3DdeTJB7xitF/n3jJXjfNF4q9+fGiwq3iqm7J9QaccaAZba5a+3ev
yKxtYFsK21nGTBXva231TuwtgD7PrRJW9+ixp5yBPrenlm+2seI0BNTRRsqS8f9ThPLokeCM3Spriqm
mHIvKmrizXWu4NEsQkY1Ep3KPp+ljwd+G+yLNZV1nuX/ayfGf37+8s/NzbDu/81t3O3/292hFTKf/9p
+urv7dAfnPxu7u43/+P/+N35INhMLHKjJXF0FN8PZZKpGnh9GYT6vq9+uN9Uj+qtUq95s1PcbCFSIx2
T0kIWJ2HzkbJzOci6yXW9s1/e3kUtRITs0Tgvkc5zoIKgDNZiN6XFGRinMuHioRuFNMKxTVd42dn299
VtTkygDQMR67tT3d0iE5UhMJq8RVERAasqdZvRfRP9ISg2HAkqpZr3xFJXcVA28YTSn7gTDTLnwe4Qx
9ZWjiepKnRPIYTDyZlGOYKEk+xxOFbLamh4hUiihDvuzPPxCNl8YBxkCm74GaRJQ2wRwFoc3Khny6dF
yJGRwXyXXnE93QohKyjehYgRTTd9l3FgZLLhbSFbBg2g26/u72K7fIupQxS31OdYwVXmigazlymIMiX
nXH4R59vFTxTTtpSkpgzBTSBCTBzESQ/pJis0u9GUe595N2U9C1WSaEjKGNUXNGjxlvLAYZEk0y5E5K
/iMtXbkMX60U4mIoSqPKyWsdAkWPSD4buOmXq+jQ9lsCv+NxQoSokVs9gTvsOFFBrcsoZFzVHH2nLKB
SMVFEwfEcsk0o1W25+dEfG8EzomXq9h90txFDQ4jNEEUJhZDSkNN8usQWTdS0oN4PfbSgTcO7h7fFJP
jM6Fi7IXxg7VFIwxrFM0yOXE8mflXNPEy7m5y/UA5+RWtda6JVTJadMyrZorRjNhj3pVsGER3ID7IOH
VqsdSbBmmWxAclY9sUTEYjnivN3XpjF+DcL3oGqcsrsrHMEhIcxwyn45tsDufJW0Mp8LqKqOeMLuKrk
cTrkTmDGUfrzYinjIX+mTR3oM5xIlsRkWk87H0iEeRGTBCZYET9UUBcymFDPNsGfgnnSuCgFzPcf2Du
Qairt/ZXDg2IhxaHnVKXZxlTe5Zzb0PknQ38cBQSvOCLTJA4SSfEBnyuTHkBTWcLAp+zon5PwhvNNiG
yfECy4U1WVyceZGpEyE9wl0OQTKOSb9rc80EYIww9TIhbObFJhujJNPCIenXldGNO9XKI+rgCAyxDhZ
r7+3sPmCOae4aEU4u3kPWOflGJT0glwtEYaCYFKbFbMsuYTqNAC8xWw0CIVEPLZOL2UNDKyZLIEr325
lK6aUqHpiyY5CqhjqY0q2eS0HsK5gT9+31AiWeTIA39QjiVrIAdbaDfPXx/dLrd4tGdXsJUfb+/W1dv
giQl+r0j4zPALKhRF4hZzUjVgVs1kLQYwVUm8SzMrlwQ4SpJY1dHFHH3DceftDtFDc2LHaLyexKTITX
uRRj4HJZzpv71L2IS4KxSAVNczqd8sEW3KzdzhGB1yRIITj3x/B8IAHGxcto3QaR+CoMInaliJEABsG
tAkIQHeKcqGuxpvbGnUcwZC6hshT7QOIkHyfRXgbCv1NWjASTIo0LKM1O9Sr1JJVNnvZZiP3tGkpaZ5
Rnrxj019n3lvsfE/F71ZvFZbwcDACEzUChfYtIkg3MfpDnpHZ71nhz++Ob8/AkTTJhiv954BrhSXCe8
gmjI09ifTJ0qV25PwrEnFXbYVHiq3pOdAK1GJDfUcM6vwkj94MWxR8jqkOCPFZYlJQj1/pVyXknEwiP
VaLFMfKobd7uFGUEduPJIMXVfdQ6POpDgcRZJjiILk+1e5+jIjNfxvvrNxvdz74q0NvEmt4AAnl20IN
h1x8rhSwxoeuUB0rJow8T5zU+Sz9+DusTsXv1z5DEMGTKJ7v36/jMVk6ScY7q6EB3ZiGT4DLGRmEykv
aJwfAXFdZ0mIp3IYqkRk5FAIguJ1IHpKtUVAZZK2boxmbiV1wKuIsYDhDJmmRZ2FTUMh5INjRaEHC2t
3wiQp2zrFUBowAumV7F9pAaRF38umEUXcgdmRiEjHHb3IeVwx4iMxhKsI3zk9VKQNRqajO/aHzraCMg
woXp5MAUOzusKfLtQ48hIg5OTnqgeiCAiAkkOMM07ekwgfkminHipnU694Wg0F9nXbNJcTWkCq1diBs
h9OoUxQPVeR0kaUsVfyIgNg6uoXtRs0/SMlHrNo8h1cTCmOkkSSDovZQ59hglNNbaVOibjKwpcLPUJp
DG4HTeocqdJMyMu0nGTKmC9I6Nnot7Nx0mMc1w8ahLATQDb59mpkKJE7e08IdlJFp9KgTFwvpsIQEE5
wepcpSFbFz8GZNOyLlc0cWj6tBqthgBzh4ywIelBkEd6w/hve9NEXZBd4EVk0QSxXhY4fhXKqOHSf89
Q7scZ0B6r90FIupFG8lt8zb9+P56QAWXmFOoe0fDTgOqMU9gbpJ6YpYmDqPvDEMHjA5iZGAbJYUhJVJ
uRIk/Vh2bTPTliRfHm/NilGUpzV1IQU1mkc/WvktAPePKhWieJBSAHl67QSRHWPSbtk81NpIcNsxlho
JfPhmFC1G7sIq2xqgwDUm2YMUN4V+K5ybpKa8h46NF6qHNxuRjLC19U/6TXQZQYQsOaO43G5j90MLnq
U/l+r9t5e9Hl0K3u+UUXR7eWSpyenfYuDztLRcRhxK5nE2DW+fkNyeUqfF3mUb8vD/v9aglVHhkQm+X
hwSwfIrXpy029RYuJSNWK97JKode8h2S/8OM8kjdFt0wXWFVU7Rh63U8bADfLp0hgBgU5rC6H3YhFW9
yjt6dHH+hLWZHMQuo1N61026YL1qiicCDDKp/hdILdZqGtmGymnI8tRKtYmHkRGTTLxaJwEspZS6Z4/
+R99+KnHtk/dvzfq+6rsw8Lo4ZNawEfDRHmxoHxbKPw6IVGYEuyz0lR63WbLAZJ9g0iWmcSIxqVwIcS
0GuxFhEHjBtXCrZkKwO3uyRka745fcvqkKSqJ0zrBPVxXewCtVNv1m+0XXJIxhFN7R/CYICp/WLI37+
/moSY1i+Vk5F+oLXkLMa/JEPd7f7b5pNW/WmdxEx108yHkjWp9Q4x5iK/Mqszt+rgxn7/bQ8Hrj50D/
vnF2eXZziARbgFG5hpcnuRBZ7Y/Md9MJ+wvGBE01/6yBPYrhBDsqhLYtLPoc62LPYrdCIhcM5CIk4sC
hwYaacJvkQbwrJiNN9oJS+rEuip095RAZ4JwLfeUZc0osAipip0OX3drd8op5dEHol6IRqzYu/dxY5d
0WHC63JmcZdVa7ROQdyH4c2cxl5foRmRdoFcHP6wwOTS4K00LSl27nik9sDXwQ0x6ZRsvDSZwBNFjfT
NnEUHdGw3Fos6ixdXd+QiQJMRrKbI0EUuj4XiM5ooSoqbYlJtqWR/FGVI4sslF5wqt1YIo6LC2hIjXt
+ru0r4EVJb3lUCbhalFseLtQ3nPFkqnAbXZFGvgDNFOIHGVEwcCyEosjxNdA3OJcJ5P/I0TyKnbK54M
8qDiF9sMjRzvQ/OMLHvyhwGb7XWGQiid7eeG33DqkIg8bJD4CiHVgqkQlCOlcFyAX5RTPAlxVOqvVek
Bi+67UNnHpDdrhz5/E5tpYMtdUAf+dZSaYmG42Jl6Wspfb1SukPAL5dKO2fy+PezPhVpX/xcpbr62VL
1dg/7SM5oWlNc2WhBXjcn9JzmqAFroDGwy+4HGxZOCpJVca4qv/5aAcYslJSa9+/Byd+MkhIG50lfiy
Ibqi6GF2sR9KSyZF7QasESUgVyyE6fzAk9W+nW0mvBhn5P4196LePXr/UYl4pYY9TlRlOrSNnZTxXrM
aa3PK7jsR7E/8+OP6msCBjc90SmDmtM1qhwLeuspRxTCPV64vmFDV1YVCUZcV7AEU+4+OhmEy/7XGXA
1vNqQeI/V888t0ULWKR9cvSmXULrXV6cdk7OnaxZU1mLhHO1MCXNI0d8ItVopSvfUDmqrjFezplhVxW
sbWQX0m9F5a6wi37jVFftJV3i8uJnomX3J1iqtNoNJtNc/K6BimQnACY0XM1k11xjKUTSPtVue9DQrD
zOjnuIReHz2rzA53VgDaOZJzP4XlPes5Ecz34SzSZ6JaUhHB93T0kOtB45fMeTpPwvFDb0UhXXGOzQP
2f/Edpzm3jALT9WhBFRH7T6vvFEfTSare2d3b2nz/a9gU/NlN/brzqH3ddbNfUIxaks13rO/AsOlQtQ
sddFL8Sug9scOw5sQPEVvrTUPLBH8EP3Ay3lLk7ax6qx8PD8rHfZ61wcnSPTu/2ic3TaOX572FWthce
vji57apvvA4EJeIWbWnmLqaYGWPbTigRuGPppNJrLPTg+urw87nZPD4/ap2pn06IQPbo8Ojtt86nzo8
v28dEvXSz1Hd+bhrlcTfwdUZ8d9w6TwYew9Qm19vWLj6aYTIQsZV+JsQl3Xh+7Kn322ouI3sTJ3JUUr
ezHP/g11ttCDzP1UbtzP6mP2qv1UTuvPn3iWye4TT5UvgKNvVSpDc1N1UeXgLqfxNlBUF0fTAf47vQv
tXImHTyQVLG3dMP1VPGTJ2Ps2Zi9mgPVNts4lUcV7PNEno/stLPI5R2pujrU+5bYybm7mUHZjPbCDUO
OnWe/UxhLWtsQGed5nwu7qm5Yc9Nq2Qqx1T2tdMpWLBb5QusLzmXPPn+sODvF4oJxKlugjhtW74EvJG
H44jNEDvooe6ldsLBpeVej7HNzD3APVLPFO8UHartxXyNBOYhowU33Dbi6G/JY9h/xezybDLCXPbK7L
u7k0i8qXrtyMC14CA/Uzn3tXJUj4PcigTJSzUT4e+qGZd3ST7uOXvfAifhyQP7BVqzegX1BDw217gHA
+5MCwBsO1Qv69hKaRqRtRpNhHgylP9MkCzHX7oE4zdYMjermmZ+GpMam8GkWzthvGWRaIksuvuVz7Ck
7UA4QNfCFnZ+kEfl4XbUALscpeCLe24SbaUxwE7nwnKCj2PZcQANcCrOYr4XX7d3TRpkmR3ZxtfsZl3
VrF7C1UXK/FMhIospqVS6EwzTF95ea/b0Bia6HmdmM4MYAsmYMK2NjbG6Qvfrx8ScSy0hzBTw+PkCkQ
Z0M1apZA6IQXssTnWNgfc9m5UBhsCxuOCu94XzP6L4sIUsvdA/Ur1sPs4fZr1s8FFWk7efVKcPjqDrE
UP6xrAllLS5hd7J+z29RhA9JhC2oHanqcPaGohHUX9PMaivGZTLJxnc0yOeNdKNkEmfju1qi6pvjIPf
71NQwDLT7YTQNpQE07MvtTb6DpwBV3CXbPXsNf9FIBoXXVU4UYSOoxVV0Cgx/HTZnZevcnHHcjKaJ7g
S1h1IOvcJD3fRqW9vr0Mi+JNOATrm6tgku6GTf1gbZbm85Sn/i+WnCy6AoIv7inZjCuiyWRnXbjHt9f
nF0evm6f3bRPzzqOlSI1sbSA/GS4Yl6gXwjiy2vDI39UCukWz86Luvw2PhGirUjWyob3la2ZbDAXtKR
2vK34Kv0eGayrVIzNOdQFC+ayTblGXI0XeOAQ3GLsHgrFziStyz7BKvPsIQvZCzmyli+OLrSqIAB+Ub
pyn4FHgZfuXi8uXFgynhWmVFZhh4/Vs2GVbBtFXxdFmyXBd2mPexxjLVOjgNetPLdInRtKZxyiLAYc5
MR231YYOmvxV7tRYkZ3EqGIphKxY3JXOg9HMvYRmfHX4jzeXxaLsAeLu+ts2opSpgomlVswjzt50k/S
CKbSSykXl9BthMaHsg9aYKHB9YUMELAMJuRBQsTW/By4t3UxfLTtmt5KTwnFCItlUARstuYb6/nAD9E
yniT0ihkf/41jsT8RoY07uqSGK4FcGymBGAvDqoaermHM8PY1VFyswoeMawuCfY53xRBmsSYJnw6Lw6
uJQgqg6ni0ypYomxkR0HnRlveVfDxkIdQIe2dyME3WuWoq8oaElwR4aiAQ09LClhfkpoRtoQ387tem+
Ir+20HHib7aGSJZqLiOO4DM4hRr6m4SZ8ufmnh4B99bpMm4EvBI5x/FkAIsAAgKYLAMfONV33ij9YkL
rnDWVAE1QX2MAmarGvG00oVK1wdBYUlQxnI+R0QtIHEUGE8k6UmfnCMh6XohOzncArbFbeKk/SUnR0E
bGKvAzs6svECaRJIGAzb4JiMJonRI80eoDPEEriO1zN4UIa+ccRelCSfEWL1mYviis6ZOLhKYDBBdED
LOVmhPbFCdTBEmQQLGNCEAx6W/AM4NyL4oT/25erWl7xCanQVOfE2bjxvmXxOTOC4Wb4G5Zflpl99bn
ULRcAd6IVhm3UtWSzVKB/idIMZGIYxhcwEW6G3/w27TrcBxbW5IVyhI0P1oVn9rWxQp56iD4sJneL3F
y9o9aR+52FuLNT7w+6WmRckpouqxJyGy+3uyd6OrQU31qnBNZYt14ZdjMo1ta5Nt2iyplCt33l7UeXE
MroZa96tqV/Ywxu3D+uFPSqAtDq+S/ZfL0nTOZmJXgzPEpv1OAYOz17GRz82eC2unOdlZ16s7Uzx/vF
jgyTLUGuIlbRMCWJKDBf8QYygR87ItyujWEnaApKymnxu84T+qmXbc4OfBW58/HiBH7U0Yc8mpnuqQ2
156mPWe1mhTyCKjIqzVSUrSV/GKEPkk0Ell/MwW8Vv28L5ZrkBj6sOSMzy2YQPHfJCUrdbk96hN5DBJ
FqgVohkIhtv68yqoI0rNocbrGgkLAr3DWUpg42Fmd4sxvnH5m1z5VumilLWLGkc65nQPT1cWO8tGK48
NmGCwqBoWAaFxBsz2aI6rM34K0T+yCNy1EwcJlUcg8stEstHMgIMCf/n2qIzYIngWlE20LTT+vZjAwC
RI8oa1bRvj33lnu30WzDgtGWM7mj/BcfWstHG7ZHiIV1EFs7KGYV5MkNtWrDiJC2uwShGybHpAgRnWm
HNLKozMFH8FdVjQggGUxflKVk7MtF3i3XgbrqC+5tDqKFYOQohZ5NeB4JL+K8elBDAi669eaYdGV+IF
DIQoCjmDQFzEEDMKcsk4tWLCaA1NpBZ3UZimsZfxc6xXdNfP2Ib4XETOV4s84o72Ce2iwuVxVOBukkT
03pJbC5cTMamP507X7FPU5Sn4qSFHxTlIfmWjRv0ytJ2Xy1tV9Rz3UJGLbTd0gUXVqRfwfrVNRVeri+
/9YhX91Lnj4WeieylIdhA0LsFAJGuvDSmJRSKIKApKJbm5trL3HCV28dPQqaSijBnn5cGaiAGaIMPnb
BGEks1GOsv/IZ9ZbplYwdrCzaJ0Tf5UpyM4G+FnWXtzRQASo82l9W+sb72lllNJX6ekVQbp1PRL7wvs
+zwZWcvS3Azm5mf+Q7hlCzV+Dnv5+QJtcnYER8x19aeYq7A9jcVH3N+DbbUpX9ARiGnlVrYGTMeVOu9
PSuiYlaI0pNXg8D3tM2qT5TmCbyY/9Pesyy3kSS3V/IrWpiQiCYBEgBBSkuMqKBISoOVRNJ8aBSroVt
NoCH2CkQj0AAleSSHf8Cxd198dPjsi8/+lP0B+xOcr3p1N0BK2nkc0F5riOqqrKrsrKx8VdZbCZsDsY
CHJE6focJH2O2O+M7uP7Yy3lOCf2o5yApEcrIi2urdj5iHBJTXS0EZUBwSEa4I2VO0qU25Lz22XsEQi
MRqtN5JbhniR2IHFY3ZYwgIFH6urCBU5cFWe7GChVOU6Sg3/FSwCMsBjYBVKwUY+AC9oQNOsBxVWhaP
V4+ZjWhQNO1tYgQ2XyEQNNH6Obo/7yj3spSBXFetwppvUHSWFL5unDPXYFanmgyHWDuk2r69XOp4mE5
+qiFqeSbT/EKau+sL3ZY3tYwKW9o+y5sgTAwE7bhF+8vmTQ2HhV0b3eum9nFhe+XCvan1rrR22E79pl
ZdaZVjTje2HElL5pwoIc+uf831Ze8qsBuL1ThnCF+Q5VkrFIQzvXScXshuOwRCpUBDVbOkMYRG6iH69
iveH5XQnsXfgtWZhqVBwSZhAVnXQHjz4EgDDoFTddDyDnKpryFnNFU+xI9LDNbX4sJC1uvtW1psrhNp
l+kFH3wjaoz87IiUQPrvTXh9Ox2vGhe4x1jIaCpkONvbL4uSqV39YohJXMSQm6Rvb/FSCtJGtrQQiVT
HwuKGwqKzA9OsJn9XDNpVpSZse6TgrSz56q2ZncGZ3UK/5pZVq6XGALa0mupyU9WZ69nzw4OnwYudV7
B/qHlLdzB5Mx4Nx6AD2bYapcHKNGTeEqhB1TeSTuqQjpFNmTws8XQGucBeSsSyQtzHeQWNrVfaIFZgW
VJfgsHrL74gQ7KmqGqtyCvrKy/IgLG2MSPhYwRLZ90rGCvSsKIyxy/7mUX6+eupesZsi4h8ypQt6v76
WTvkdbuJfzOJ9W/BtqOBxW4ailC0hpDh1cVD/Samne1K8+q/I1pQ3b4aClaqJd/ne1soQsG6OoDxZEG
3IItsnQcOKK0pkkDMwu/6OXUwGXBQnxxxxA4K0GDAKQEeUyVKbF5ot150Zi+1wu51iNdh4IFpdCYpl6
/xCKhJMHaUbYIslWyLgPGAclTWhjtuprQDCnhwRdmtBRE+1mstz1E6dGUlt+qq9ca0qijXby2oepvTq
rF6vZUttmV79VLSFmwtaKj1LFiNCEtm0ObT22JERu6IHfUbxp+pPhUrzrzcNs1pbawvNPV75FHkwM5+
UI0nQuT3oMZ9+uSVsx4mCUuFV5kXFGqaL7Ynh9yBHuyO/FPY0zYF3vq+q6kWxpvEA/a0GpuJCv8tX6E
r+G7XX7UjUgiwXndK9Z9OFDRlq2TbM2vHwZ3ycWrWMGPWNFOrtfOrWlcTt4zddZjujDjAq0k6RiNL6A
2T91ynIQGHEXlebNPHNogE2vKRlQRdEwl/cKX0O5zujioFfsfgnPB+YundGHS5O6wl+go5Oasm1+5RJ
L02OujDCKq57+ubZ4r1yGy804IOeBKgXCYm/oblcbAn/b23bubcKJxzY9qcE550Mhkro+KUSeMRqG7L
+iUpisUSiSd1fjw+PHiOJ3XKh8Hp8dnB7idV5rphAHt4HxkdT9CbJ4H7ZB3JkNHAPrq5uQmYpPCeT58
QHzJuOUXa61asgx63RX0u1iyD+4aL+3VrJ9Xu/iS7DKXzHLnYjjf1952svQVFGWv5oKkz454UXFO4K4
dP9FQIZEkzCBmwCqBAAzO5lihQwoRIaFEQPl1VCX9bSgzMTkxVADJTzdDyL5KhmnDetaUQoCsuIM0oh
5cxaheNwfIJu0LHF4AQVm3qKOca1KE/T/ZPHdN+pL2T3MT9Js1Cj/FqKQNC/LhGpObDg5YXgc+liABO
5MnXmeNq5FastokdNK1WRc7FDtywIhN55wq0txu2K4Lq753ZCNRmnKds4IN3hG2qhZaJ1mPHZsnN30U
5ouOUgy7I8GEYNp2zCwI6Z1fyLRc8Z0QnN6426kbn7GtteVGh310dY+8g1OlHPra8pWDJcqy7HiS+qU
7cSK4Tf2i8P+wQ1z9UEJCoC9+zpwn3Zy7xVWxLJkzMChSagc8ym3vF3ksou5vWPtytNT4Q4uDHK/jxq
oRLoDz07rIMgPUw0hd49J0h/vDoR6mCp0VKPnrMhRWSQuHEKgyzjrGShZHZJOE2+9yyUXkjweBm83un
l+IpBHdxQd/t8nydU0Wl5/sHNOI+67O+Q1VZd7/x9lscvtaauWatjcV1nliC33Q6HWToNLqZTm00IlW
+Rk64jVEr97zah965ha5c1ShfZyAqLSl/1eowFyJlwcCYDqupO82slk20DNNjoXhhGpyv/BKg4cqH2L
I1DaBHrV7I3450zdqy/RnvGIWEPyC7TWFalhS+4v5gX+wMbyruOwtmiI7WI/q37uaBt5yFbgc3fgO9O
JsIrO4PDv8YiqNTjBvauZqKANfP+aaR+dUe9LtbzPrgzw9bJd778aS3e2iyPICpqK15xTKt+jbvIJ7B
XbcwwpmOY7a8/uvOygruBkveku3fEc/bVOXpEdDjP2Y0Jhjr0N451EwB0ejUlO+w7H3wvTXrQ9iixm2
12oz6ygLH686554nHMLtWW1xjZaVzrmpE5pVjUppOTcbHEBvExgDvfsuLSUiC/2rJRqO2jD2V6xjxhl
Gzj7yl+hIyXPIY24sYQ7Yk2MH489YkEJwO3XK0D0jLk2EX83/ReQI6RISiM52wDS8SjPjRxif3S6w7X
4IU/apX99ecdaE/iZqCEoSD4MVLPMmNVEhS4WbTN6d6sMhbp+BSlDrrjfu+ZZN9BIVbeOhdx6+aOeLk
MX7v4UPFxMwX5QA39/uJt92k4KPtqW9FhzzSUSNbXl34rwkj0XFwtVzM29Bdzc4QVJEzClkvmYEYg4Z
ljVCj4y6yTWAFEbejqCz82mxT5FwkCcbH62AqibNiHjudo2ci6bzreAu5yzh9+MBL3z9sgkyTPmx4nX
iQrDz8Wf0xqDY8Ovb8W6c4nj8znjS8/nXyfzen3v+3sbHZ+EO92VxvrN+v1zY3Kf/3+jz/96/yrGFuv
OHHEead9P7nPxu1RsM7/hgOvF1MRtzvTzqduMKpwqgO3h5G131x+tgfJZ00563CgxG0m70ZR9EbDtzC
BGOdZBRNxnFfbh/rjSJgSqucBZBS52EALOZ9AnGE82GiAWc8HqZba2ujq5RuWZbEwHj12+XkYjVO1hD
A87iDCQ27mAfwulHRwWptSnLZj6EFZebqwCQ9OrST8rhoiDSG//v3v/7X//73X//2L//6t3/7D/iD+G
FhSjxdhOPsT8kn5zbF++xzhblkdFYOO10WjUaDTL86yZ4+AXh0fPj0eOdFcLDzYt8rwWIu6VfqWtoXO
386PLYSTejyNohFVp4JVX60c7r7A9TXL4KT0+PyK9/77pUukhJ5YxKTCIwsTKrvjMf3SqsltxiHky+m
0ZgMKFbYr9eZjODDl302sFH/j89OgzZIdc/20Tx2sr+3mLNv0p5Zep4k7ypAJJLjWgKZXVrtJf13KdH
MOy8eL0EBRdhf0AFyoCvYRDHrJ91ohzBD7wIjltG+HOIJRpXumKMZAVo/ec+x3glGjmt/JR137EfXEa
bc9H4q8bx+KmnAF9FleB0nkxGPtL105U0GeBcRiXGJOAvC0Riz6KxyM3NUd/9V+1Tfeqa9259dXLLTQ
Afj1iqS9QtWI91AYqMRy8i2hoBPznZ3909OQFBiaznaGG1EcwYPytxxeIQmg3PM+04xvq/xX/ypJ4qc
yOTS5FNeML8o7Fxyk2pVWAtmjBuOMSRVx40CJ4o46zCOQ8NsDzj5N6ezpnh7OoEFqH6TTvC8XRRh4ji
QOde60fXaYNLvv2F/C7+HocPrNzBKDRPzd4CgVQ2HmObacx4pk2OBb2MMhMexp5hfjzP1XUcjGq0NL0
Z4MR0ErRJ1jSZDylzHZZ4uYybZT63G+FSrHE1cJfPm64cvDvf2zzE9lifUM8KjpYwkqrLqeScwc6wHV
YA07dFc4mgod3nmEa2QlQeqgNwb6cxu/hKbSwCg01wintWreMCn3vBvA0dDorF1ozGmhkU5Vc+Evo41
F50wiuFT7hU1mKX34WiwZE0gBISmuiFCkWVE+VwJQLZ5dZAM42EEUCg/O2aCJagVk/WbMm1KghC6PUN
ICKnVBodTNKOh07eJOnh741iwesFYCOaXjgXPo6r7LwjRsZqVXo8Vj1kB/uuwFOELLYuLSJLAK8x3Uc
YDMGMJB8c0Vs7vhvATVHolVzirUC1f1CVyrNRfD8/JXtqAP3ytSGUsS0Yp4gZkIfF+9tbWMEt8P6ak2
uoNgUJhhv+iypTJczSJXPB1B7zqG1RLo419zk4+vObLgelwA+W4SNXxhmX5hcIAsv2AmYRVgGjlSfLx
h26UdirQEP+bqnj6Af3iKH8hX/pbqF5H9AtW1ZWoVZoNjeRi0nv9+OzJSfvP59o/XFZQ8XhQ0imroUt
mLR6C7TcUfOT8htze6/GtlwTWVzk1ivciMQ2y/QPNIWyYjkHr51G0AOexTRYEVXuY+c7mGL6pQSoavU
KVizA3aPyIjDptyMxOY5/WIsLHtfjmbvpGZ8Iw/eEZc/KJkpTmO34u8z2L55yjKzz39CHohd3rONWpD
Al9Ffy88L+jw5P2KwCy9zI42f+Hs/2D0/bOc90pcPlr+LJlJhoOsgpgq338hIOthPPhd3zNNMQGJfyz
pdEiVGRTuLFqykuFRkVaeCqxfHK61z4IkG4PDlE86mnagb8VajjyBFuJH5EQR2JE++D02HwfczY3s8C
lNS9wqWxFuIiPoJCWeBV58cqK7zjpGCXxuaESt3dPjdJ4r8iRQ1tPmWZKo6rgOSQFjMy5ddNRnuQKiE
6uisVrlWhb+0KyKxholhaFs9nUaKoaRMhFyeqFEiv02D+75OF8VjVnd75kkaThTo/+oXtGqJGedPFUM
ytnBiDDefRgb0kbt6GMDLqtXCcOGdS+gO8YEuCkwF9EAmaOo0jGYJvuZLd45Hx+4JG2CE+7OQWwzDih
R9PJbGPIjvkELZYNEmg6cstIzJGSlgKAylLQDdNL+w0F3stxPZqzwrG9kbbUzqVqyM7F41X7Fr38in2
L291q4wIpA6+K8EaJ6GKSNTwK05jyRYQDnQOzm3Q453doNBy+UMOmzAGfacQX0ChQE2T8kDMJJ4nb4k
DzYsIMJgwRb+7g3BAlFGPY0x0Oe0I/uw3ZWpFEX4xy3hygZeGSU1DrHEz1U23JZnUz4BC/tr45Sl2aq
xg2b8GuOqA5k4G097X27/A7espaDi0pFQ1WkPVAF3hTqvc2wcWGKQvClvdZwzEipQUnp5qVKgVw4hvh
oM7kjqZoPJc3whEVygGVh/PyRjjZsdhwslRIX8wCuLYsKu2lJHmd2ZOtn2rkmednw2FvGrMN6SGqLC6
4n/M854shVlHHsj7xt0HEljPGmMXr7QDOGOIsgJRbOAuPwYAYs+GLCjXle1Aw/CjqJG8HwGa7Vky705
dZtVPiC4uALN1Nl2izk6O6PLWWBYqtVPp1gWSNz2eXqZixEKfstG7PUTRblnhw8n4jgxry9k6eO1QLf
WfGKuq84xZLEPdSuLS1yFxnS8qdvdTmi+pxIrltWLGCFduw9B78RbAuFaxLBasI3yIt+LcG+1KBfanA
CkGUKHjJtWDD/ymbcclsweaxpVgtt9w4EKBa5t9FthGLds2gh0tbFv0XgFRh95nOZ8a1qxuyqkDqnQy
pd3JTvR2xT5nzZ5RNmA4XnbIe6bZsjFm0yvkeOxU8CzUW9atY/bYBiPhzFI0uw2Gqb17y3lOmEcp/BZ
uQGC9P2k9ByfPKu+NRv7rrP1o0ygmTqi9WzTLXrGCLoP30gFNdOuqxq23epB7jEPGluZ6U7cd0OdygC
6ot+fKVySPBDe19BP/i/XEJCtAYYKNNO8o2Iv+xTTla02opKZxFLEmERmQ7Qhn7t/b4uQ/eHxThJa4f
fzk38Oz7n+v31+83/1BvbjQazcb9zSaU1xv1+tz/+6s8wBpPjvZeVcWPWm3jxc14DSpo4o9P9qrr1d0
+OlQXM17i9Vt7iem2ycOGVwWe+LBTr8vVk9Ufow/jUehVh1E3HKAV1SZFr9ofdsIhpoM2xd53dD3bmh
dKyJtxUT49OAtODs+Od/cXv9InC/Bu9tNCGTDkr/LdajeyVfZ2NMyUpB/TtTTpvIuyg4FyuiU2XzzmC
0mzxWiazgBHjK7hP44L+cXpGch9Ncvh2z5qBj/sHQcYBtaoWcWburhpis/2jnSx98CC2z4o71S8x3hp
yw4eUyk/potbduhelsd4H4uqufPKrrmdr2n83bs7R8HuD/u7z8pPgO/zlU8gq/5ElotgdN3CP9E2AH8
D635ShjpB8HIn2Dl+ehIEvjbLQD3YWgAZgZxugYrfPfFbVC78WuB95rCnZk0SWVe1oh8SBE7DfUk3vn
rD/oTKQ/yIHkq5oOjLOyBfIMlJZywFQUoC4gTGvt4Ixp53Fb6NOwEfDmvJm/omvhF9L7gK/5JMexUP+
JUGR+P8p2QQtZxeYK/txW/TTOEgpOxDTuEgGmM+HrdwnAZp1MmVTXKFSHhBDmYCHIJLP7doNSOlgtRx
8Re8jLxHSdMJd7xBj8i6g7kHFe5QzsBkrII9+oZjbxn/S+4ProWxiuhf9JbD2BiQ4EuNI4UkObglOeH
e4ULSb/rh25RzKVpj1zjCkWvfj9x7DR97HOh2aTQWNxi2fkADfCcuHqcDj5M3DVWuFt3Z8igEjjEOKQ
WGKfUBTEukr85l1KFkSRRPgBeA1r0yQfYpFRsnc6fMuOMAY/7wODFUw2ttRAZTnaA/DKNLv/++7iu1p
bCHmlcep73xrToQS99lmAbYBh0Gue5q6pAEGtNg76BO4kE3xms28T5tDpbIw0+plfgn8nDXcR7aYwfA
5ZR4ESC2C1pfpEkXyCx7pjWNH6b8QCWzxztm1UnNPodRo9/WZJyFvqSytsYpRPhOZ2XzY4U0cJjAP98
3VkZhRhZJfqZ104d9gnDPRI3SK8WHxJizDEMiLiJzFfhIbtvpFtAtAgoYSNleTYZaqSuyTMqSIesraq
tUX1xW1Ma3PQE2f8W/QSGyGij1Tk2wy1PWBXj7LHQMkjWdZTw5fA57/O6zfdQPDoPn8CfqAaf7xxXvH
o5Q237xh59zT/MMAwx0LudZyfJE+anlHY/93fiyC3zjUr3Mr2apfjHsBSqXWQ8zB5AeMKxuX/Sgy3SQ
Wr4VHM37fjjQ658WfnXbZQq0LkAf0YsxTlXKSb2OZCN5pEkMoChehjvd3vPToL2/v/+g1gjq9eB4Z69
96Ct1UcHt4aWBREjYv76FGMDJSjH5y8qZUWZZHmJFKMDSSa25LpfLeuda9rE+3cmkmIBMQSg657yFwb
Iq3euA+kWSIWl2UTqm/H7Vi1ESdkGFH+sGpiVGPJyctPcQj/oOaw6f4lU0gu97+vwlLKDoSvE1tw8DD
Ne/Om1aW/We86GPmncVhYM03xLr6rFZYBKdxZ4SaTIUWL04qHp1vcFBHSkm3yycEYA9+ji+TAYce4nJ
N7l35KLj93GX77E2t8Zumda41X7AedKt0eXNjY31Td96r77HBwrt51MOvahGBsJMNVrrKJKXofb2tvf
ArwBobqGSLlDkujqrcs98ZV+hAy+pQ7J+fbd7Tm2b3BfhujStUo/z/2HlTL2yqrjVOC+YQsn0axN1RV
Or+QtJtCm1Hf5G+0bOn0QmEIz0upjE/a7wHdea5WQrcLyqakeTfRH5fJSmXtTrxZ040mwMWVcXcUrnn
4UbLN6wgKwXXgknh74hg0RBIb1oNKdgTW9LdMoBeaTcUovdMo/HswO6K/KNk9h+sH/6YufkWXB28Ozg
8McD10Fq7xQaUMmG7/jj6n5+HMB/ZBOzRnLrXnTrWf3YO6W0z3TAsEtWxWnwcnSDTJebaLevWSSKGEa
Tgb3nUxbfVI6+s9y8qNKXjdX2DBSMe70aOH4e2M+QVbeU/IwGqw5dpDl0LVbRmLZRChIVgbys90DcPr
9y11QlGJFEnOdc7onL78soIhWU+/jDEvi1SrWMfZs2ptyHzqgXLU13QjnTh8rqZXWbfxPeRdbXiMevM
xkqvCd0qkbvGqKxhKMRcOrUWoZmq7SIhKIFLGFkor+HVGPkE6UY340DbttAQ6KISHfiUUhm6IuQdknd
IYB/bYNQLNbpzZqrqKyIbSgElFa3be0U/fIfwvpFo7PebbZUDUdLpaQ4uTeopFLqG/VG6ajK00+FoqK
6ZQP1tczn0S9FU+WXtjbHfZDKiif28O/V8bXSYNXbSeb1xH6v9FiKNHB6VbosN6U3opnxcYNIUQbla6
d9eYJX+kClq+gKE0fjDdIrSm7NUKxPRFGRTmmxqtg+OflZ3AwAqnGq7ykCnuYQCg5BgbfjhOirK/Fbt
AhqtA7CGP8/QHU6+1sNirL/IRvEAvQbCxNkwMD/OFiS1Ek0o1Zk1XRAQqSA126MokkyonvVlWhmi+7d
JOCmEqIODYxyQoYek6w77HRgwyxDlYp3HBw++/QK/nG5NJkQ08lVxAHkFD8O7Dkdr66uGlGX4F69A0A
MrLaxsWHZj9QsqQZOUrHM65aE49hwZPg48DwIflkAw26P4yitlQqbF43AYuLXSmUkJhZ3197GJPkOko
uk+3FtkNBJaAfho2RIA56K5rcAO8bTFw9dxBKo1GigCGlI19UDx0ypEYmjYb8fdZXLBWjziokig35ow
ADxoggSZXD6Nc8lM6lTgMAsLBgx7jbNAizy6yI0ehb9ldauw9EaXn/7sWQrLbqLyewuJgVdeEVf61aR
WFQCwHEXJRlr//j48dmT4KT9531nQ9XWsEsAB6rT8gj9V2Iay2+uE9Jf1YLiXEpNDB+SpFMbU4OpzHm
P9pOd3X3vh8OTU+/o8PiUjnuArn5u+z1dAwDrwdaWp1JXNYsEWKVMF9TfKKpPXTbP9T7H2Ix7eCBE58
EwlsLLJNURVQ2rfJiMdPk6IwlYOeq+9wS3NW2HoAIO0aM/V4Fx9sKruP8RIOw8AUn45Gh/13mNBg/JG
o22jmAPneMuAFLSoX072NnbO949PHjSfkrjgCWpvnMZhw/bBwy24qmB3RspfyQatEYf+QZJ2BpCdDbj
vabYHJjnooQ+hDHF+KYtD/66Iyj3qFS2AcxUaCMbTULsvyhLDZ5vRTVQ89MFwGbGSSfpW3HCAghtIHb
cJb3XVgWT6iu+McJvV2tkdOe4OFhKhdS3yKYYmaRZBPZssEP4fG3QaKzJG/kEXSpVr2z7UVYcP8nUHd
/PUvSUbjdn97v5Lf1OW9nwrYewTQMvFzLxeFiw2ru8qO3BTkWubWFUGgpJAlGZFmNFGBpTquXwUWpaI
BOueKy/OcJ6cQsgsqsYg+O5RX1qxXF8FVHON6lYq02tGl9dRd0Yhh3wZfEGtN4wtamUNgdqGXbG8TXO
VYyl07RTWzVVbTIEy/CVzE5JRjvjCZ92RbM9R6SGohyidBx1WcAxu/s0HLNERvnbeSRUZw9oj5uI8iu
zEvOlNjzKXHEzwTKea4GNs2YpV2N1A40wbLylLcILQYHe+C7EGeqWYIR67SfJUNCHjpV7orVWPKO3+h
P/9xeJ8ds8Q3Tu/8IZAGaf/6/VmhT/sVnb3KjXmusY/wH/rc/jP36NZ1b8R+3xyZ53eIz/e9E+rdbwj
93dWrW+WlvBg/O3SBwwSArTBtx85P5WR+Tpek6KfSDlku2Ekit1kND9MRSExeargArK1vHDzFmQdTlu
xgc5+FpSvuOu5XtpP4qG5bP2wSnmsJ/zj/kzf+bP/Jk/82f+zJ/5M3/mz/yZP/Nn/syf+TN/5s/8mT/
zZ/78bp//B3xMHIIAGAEA
_eof
}

function buildall() {
    [ -d "$BUILD_DIR/install" ] && rm -rf "$BUILD_DIR/install"
    setcross "$1"

    DISABLE_WIRESHARK=""

    if [ "$MUSL_CROSS" = "mips-linux-muslsf" ]; then
        DISABLE_WIRESHARK="1"
    fi

    get_musl

    $CROSS_PFX-gcc $CFLAGS $LDFLAGS -o "$BIN_DIR/xxd" "$BUILD_DIR/xxd.c"
    $STRIP "$BIN_DIR/xxd"

    $CROSS_PFX-gcc $CFLAGS $LDFLAGS -o "$BIN_DIR/sav" "$BUILD_DIR/sav.c"
    $STRIP "$BIN_DIR/sav"

    $CROSS_PFX-gcc $CFLAGS $LDFLAGS -o "$BIN_DIR/pause" "$BUILD_DIR/pause.c" -nostartfiles
    $STRIP "$BIN_DIR/pause"

    build_libsodium
    build_minisign

    build_sha2sum

    build_xzdec

    build_multicall

    build_pv

    build_zlib

    build_dropbear

    build_xz
    build_lz4
    build_xxHash
    build_zstd

    build_openssl
    build_libpcap
    build_tcpdump
    build_proberelay

    build_rsync

    build_ncurses
    #build_readline
    build_socat

    if [ -z "$DISABLE_WIRESHARK" ]; then
        build_glib
        build_gpgerror
        build_gcrypt
        build_cares
        build_pcre

        build_wireshark
    fi
}

function main() {
    HASH=$(sha256sum $0|head -c16)
    mkdir -p "$BUILD_DIR"

    if [ ! -f .gitignore ]; then
        echo -e 'output\npatches\n.gitignore' > .gitignore
    fi

    if [ ! -d "$BUILD_DIR/patches" ]; then
        unpack_patches "$BUILD_DIR"
    fi

    if [ ! -z "$1" ]; then
        if [ "$1" = "unpack" ]; then
            true
        elif [ "$1" = "repack" -a -d "$BUILD_DIR/patches" ]; then
            cp -a $0 $0.bak
            tar -C $BUILD_DIR -cz --owner=0 --group=0 patches xxd.c sav.c proberelay.c pause.c | base64 -w79 \
            | sed -e '/[<]_eof/,/^_eof/{//!d;r /dev/stdin' -e '}' $0 \
            | sponge $0
        else
            buildall "$1"
        fi
        exit 0
    fi

    # armel-linux-musleabihf
    # mips-linux-musl mips-linux-muslsf # mipsel-linux-musl mipsel-linux-muslsf mipsel-linux-musln32 mipsel-linux-musln32sf
    for arch in armv7l-linux-musleabihf x86_64-linux-musl mips-linux-muslsf armv5l-linux-musleabihf aarch64-linux-musl
    do
        echo "** building for $arch **"
        export arch
        export PS4="+$arch+ "
        buildall "$arch"
        echo "** finished $arch bins **"
    done

    echo "** Finished **"
}

main "$@"
# vim:sw=4:ts=4:et: