X-Original-To: alpine-devel@lists.alpinelinux.org Delivered-To: alpine-devel@mail.alpinelinux.org Received: from apollo.thewebhostserver.com (apollomail.thewebhostserver.com [46.23.65.248]) (using TLSv1 with cipher ECDHE-RSA-AES256-SHA (256/256 bits)) (No client certificate requested) by mail.alpinelinux.org (Postfix) with ESMTPS id A0842DC00C0 for ; Mon, 2 Mar 2015 12:49:28 +0000 (UTC) Received: from localhost ([::1]:34541 helo=apollo.thewebhostserver.com) by apollo.thewebhostserver.com with esmtpa (Exim 4.85) (envelope-from ) id 1YSPmn-001plD-2z for alpine-devel@lists.alpinelinux.org; Mon, 02 Mar 2015 12:49:25 +0000 X-Mailinglist: alpine-devel Precedence: list List-Id: Alpine Development List-Unsubscribe: List-Post: List-Help: List-Subscribe: MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="=_2041ad7312c0d2b872948b21e3d2ffa0" Date: Mon, 02 Mar 2015 12:49:25 +0000 From: developer@it-offshore.co.uk To: alpine-devel@lists.alpinelinux.org Subject: [alpine-devel] [PATCH] main/alpine-conf: setup-disk + support for LUKS installs Message-ID: <73d18b671f2fb6008af1bf7e04ffcccd@it-offshore.co.uk> X-Sender: developer@it-offshore.co.uk User-Agent: Roundcube Webmail/1.0.5 X-AntiAbuse: This header was added to track abuse, please include it with any abuse report X-AntiAbuse: Primary Hostname - apollo.thewebhostserver.com X-AntiAbuse: Original Domain - lists.alpinelinux.org X-AntiAbuse: Originator/Caller UID/GID - [47 12] / [47 12] X-AntiAbuse: Sender Address Domain - it-offshore.co.uk X-Get-Message-Sender-Via: apollo.thewebhostserver.com: authenticated_id: developer@it-offshore.co.uk X-Source: X-Source-Args: X-Source-Dir: --=_2041ad7312c0d2b872948b21e3d2ffa0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset=US-ASCII; format=flowed Adds support for installing Alpine to multiple LUKS partitions (& optionally set up keys for auto mounting non root partitions). Also supports installing to LVM on LUKS. Mount the LUKS devices & 'setup-disk -E $MNT' or just 'setup-disk -E' It shouldn't affect any other type of installation as any changes rely on $CRYPTDM being set. I've attached the complete script to test. --- .../0002-setup-disk-add-luks-support.patch | 242 +++++++++++++++++++++ main/alpine-conf/APKBUILD | 12 +- 2 files changed, 250 insertions(+), 4 deletions(-) create mode 100644 main/alpine-conf/0002-setup-disk-add-luks-support.patch diff --git a/main/alpine-conf/0002-setup-disk-add-luks-support.patch b/main/alpine-conf/0002-setup-disk-add-luks-support.patch new file mode 100644 index 0000000..9ef2d90 --- /dev/null +++ b/main/alpine-conf/0002-setup-disk-add-luks-support.patch @@ -0,0 +1,242 @@ +--- alpine-conf*/setup-disk.in ++++ alpine-conf*/setup-disk.new +@@ -43,6 +43,14 @@ + case "$1" in + /dev/md*) echo "$1" && return 0;; + esac ++ # crypted devices need a device mapper in fstab not an LVM volume ++ if [ -n "$CRYPTDM" ]; then ++ if echo $1| grep "^/dev/$(find_luks_vg)/" 1> /dev/null; then ++ echo "$(convert_vg_to_mapper $1)" && return 0 ++ elif echo $1| grep "^/dev/mapper/" 1>/dev/null; then ++ echo "$1" && return 0 ++ fi ++ fi + for i in $(_blkid "$1"); do + case "$i" in + UUID=*) eval $i;; +@@ -214,6 +222,14 @@ + pvs=$(find_pvs_in_vg $vg) + fi + ++ if [ -n "$CRYPTDM" ]; then ++ initfs_features="$initfs_features cryptsetup" ++ if is_luks_pv "$CRYPTDM" && [ -z $(echo $initfs_features| grep -w "lvm") ]; then ++ initfs_features="$initfs_features lvm" ++ local vg=$(find_luks_vg) ++ pvs=$(find_pvs_in_vg $vg) ++ fi ++ fi + + bootdev=$(find_mount_dev "$mnt"/boot) + if [ -z "$bootdev" ]; then +@@ -287,6 +303,10 @@ + if has_bootopt nomodeset; then + kernel_opts="nomodeset $kernel_opts" + fi ++ if [ -n "$CRYPTDM" ]; then ++ kernel_opts="$kernel_opts cryptroot=$CRYPTROOT cryptdm=$CRYPTDM" ++ setup_crypttab ++ fi + modules="sd-mod,usb-storage,${root_fs}${raidmod}" + sed -e "s:^root=.*:root=$root:" \ + -e "s:^default_kernel_opts=.*:default_kernel_opts=\"$kernel_opts\":" \ +@@ -460,7 +480,7 @@ + local answer= + local erasedisks="$@" + if [ "$ERASE_DISKS" = "$erasedisks" ]; then +- reeturn 0 ++ return 0 + fi + echo "WARNING: The following disk(s) will be erased:" + show_disk_info $@ +@@ -506,7 +526,7 @@ + + # find the bootable partition on given disk + find_boot_partition() { +- sfdisk -d $1 | awk '/bootable/ {print $1}' ++ sfdisk -L -d $1 | awk '/bootable/ {print $1}' + } + + # find the partition(s) for LVM +@@ -659,6 +679,95 @@ + fi + } + ++find_mount_point() { ++ local device=$1 ++ awk "\$1 == \"$device\" {print \$2}" /proc/mounts | tail -n 1 ++} ++ ++find_mapper_disk() { ++ cryptsetup status $1|grep device|awk '{ print $2 }' ++} ++ ++find_luks_vg() { ++ if is_luks_pv; then ++ pvs --noheadings /dev/mapper/$CRYPTDM |awk '{ print $2 }' ++ fi ++} ++ ++is_luks_pv() { ++ pvs --noheadings|awk '{ print $1 }'| grep -w $CRYPTDM &>/dev/null ++} ++ ++convert_vg_to_mapper() { ++ local mapper="${1##*/}" local vg=$(find_luks_vg) ++ echo "/dev/mapper/$vg-$mapper" ++} ++ ++convert_lv_to_device() { ++ local lv="${1##*/}" local vg=$(find_luks_vg) ++ if [ -n "$(find_mount_point /dev/$vg/$lv)" ]; then ++ echo "/dev/$vg/$lv" ++ elif [ -n "$(find_mount_point /dev/mapper/$vg-$lv)" ]; then ++ echo "/dev/mapper/$vg-$lv" ++ fi ++} ++ ++setup_crypttab() { ++ local keysdir=${keysdir:-$mnt/etc/luks-keys} ++ local keyfile= local answer= local i= ++ local config=$mnt/etc/conf.d/dmcrypt ++ ++ if [ -f "$mnt"/etc/crypttab ]; then ++ mv "$mnt"/etc/crypttab "$mnt"/etc/crypttab.old ++ fi ++ ++ if [ $(echo $DMLIST|wc -w) -gt 1 ]; then ++ read -p "Setup LUKS keyfiles for automatic mounting? [y/N]: " answer ++ case "$answer" in ++ y*|Y*) mkdir -p $mnt/etc/conf.d; cp ${config#$mnt} $config ++ ln -s /etc/init.d/dmcrypt $mnt/etc/runlevels/boot/dmcrypt 2>/dev/null ++ read -p "Enter directory for keys [ ${keysdir#$mnt} ]: " answer ++ until [ -d "$keysdir" ]; do ++ if [ -n "$answer" ]; then keysdir=$mnt$answer; fi ++ mkdir -p $keysdir ++ done; echo "Creating $keysdir" ++ for i in $DMLIST; do ++ if [ "$i" != "$CRYPTDM" ]; then ++ read -p "Create key for /dev/mapper/$i [y/N]? : " answer ++ case "$answer" in ++ y*|Y*) if ! cryptsetup luksDump $(find_mapper_disk $i)|grep ": DISABLED" 1>/dev/null; then ++ echo "All keyslots full: Choose slot to wipe? [1-7]:" ++ until [ $answer -ge 1 2>/dev/null ] && [ $answer -le 7 2>/dev/null ]; do ++ echo -en "\033[1;31m>>>\033[37m: \033[0m"; read answer ++ echo -en "\033[1A\033[K" #move the cursor & clear the line ++ done ++ cryptsetup luksKillSlot $(find_mapper_disk $i) $answer ++ fi ++ dd if=/dev/urandom of=$keysdir/$i bs=1024 count=4 ++ cryptsetup luksAddKey $(find_mapper_disk $i) $keysdir/$i ++ echo -e "\n## Settings from /sbin/setup-disk" >> $config ++ echo "target=$i" >> $config ++ echo "source=$(find_mapper_disk $i)" >> $config ++ echo "key=${keysdir#$mnt}/$i" >> $config ++ esac ++ fi ++ done ++ chmod -R 400 $keysdir;chown -R root:root $keysdir ++ esac ++ fi ++ ++ for i in $DMLIST; do ++ if [ -f "$keysdir/$i" ];then ++ keyfile="$keysdir/$i" ++ else ++ keyfile="none" ++ fi ++ # crypttab needs the UUID of the physical device ++ echo "# $i is on $(find_mapper_disk $i)" >> $mnt/etc/crypttab ++ echo "$i $(_blkid $(find_mapper_disk $i)|awk '{ print $2 }') $keyfile luks" >> $mnt/etc/crypttab ++ done ++} ++ + data_only_disk_install_lvm() { + local diskdev= + local vgname=vg0 +@@ -902,6 +1011,7 @@ + -q Exit quietly if no disks are found + -r Enable software raid1 with single disk + -s Use SWAPSIZE MB instead of autodetecting swap size (Use 0 to disable swap) ++ -E Use Encrypted LUKS devices (LVM or Standard Partitions are supported) + -v Be more verbose about what is happening + + __EOF__ +@@ -918,7 +1028,7 @@ + DISK_MODE= + USE_LVM= + # Parse args +-while getopts "hk:Lm:o:qrs:v" opt; do ++while getopts "hk:Lm:o:qrs:vE" opt; do + case $opt in + m) DISK_MODE="$OPTARG";; + k) KERNEL_FLAVOR="$OPTARG";; +@@ -928,10 +1038,67 @@ + r) USE_RAID=1;; + s) SWAP_SIZE="$OPTARG";; + v) VERBOSE=1;; ++ E) CRYPTROOT=1;; + *) usage;; + esac + done + shift $(( $OPTIND - 1)) ++ ++if [ -n "$CRYPTROOT" ]; then ++ DMLIST=$(dmsetup ls --target crypt|awk '{ print $1 }') ++ if [ -z "$DMLIST" ]; then echo "No Crypt Devices found."; exit 1; fi ++ echo -en "\033[1;4m\nSelect LUKS ROOT Device Mapper:\033[0m\n\n\033[1m$DMLIST\033[0m\n\n" ++ ++ until echo "$DMLIST" | grep -w "$CRYPTDM" 1>/dev/null; do ++ echo -en "\033[1;32m>>>\033[37m: \033[0m"; read CRYPTDM; ++ echo -en "\033[1A\033[K" #move the cursor & clear the line ++ done ++ ++ CRYPTROOT=$(find_mapper_disk $CRYPTDM) ++ CRYPTDISK=$(echo $CRYPTROOT | tr -d '[:digit:]') ++ ++ apk add --quiet sfdisk ++ if [ -z $(find_boot_partition) ]; then ++ echo "No Boot Device detected."; exit 1 ++ fi ++ if ! grep "$(find_boot_partition)" /proc/mounts 1>/dev/null; then ++ echo "Boot Device '$(find_boot_partition)' is not mounted."; exit 1 ++ fi ++ ++ if is_luks_pv; then ++ if [ -z "$(find_lvm_partition $CRYPTDISK)" ]; then ++ echo "$CRYPTROOT partition is not set to type 8e."; exit 1 ++ fi ++ fi ++ ++ if [ ! "$1" ]; then ++ if is_luks_pv; then ++ lvscan |awk '{ print $2,$3,$4 }' |sed "s/'//g" ++ echo -en "\nSelect root device?\n\n" # rows to columns ++ part_list=$(lvscan |awk '{ print $2 }' |sed "s:/dev/$(find_luks_vg)/::g"|tr "\n" " ") ++ until [ -n "$(find_mount_point $(convert_lv_to_device $answer))" &>/dev/null ]; do ++ if [ -n "$answer" ]; then echo -e "\033[1;31m$answer: not mounted";sleep 1;echo -en "\033[1A\033[K";fi ++ echo -en "\033[1;32m>>>\033[37m[ $part_list]: \033[0m"; read answer ++ echo -en "\033[1A\033[K" ++ done ++ SYSROOT=$(find_mount_point $(convert_lv_to_device $answer)) ++ rc-update add lvm boot ++ else ++ SYSROOT=$(find_mount_point /dev/mapper/$CRYPTDM) ++ fi ++ if [ -n "$SYSROOT" ]; then ++ set $SYSROOT ++ else ++ echo "Device '$CRYPTDM' is not mounted."; exit 1 ++ fi ++ fi ++ ++ if is_luks_pv; then ++ echo "root device = $(convert_lv_to_device $answer)" ++ fi ++ echo "cryptdm = $CRYPTDM" ++ echo "cryptroot = $CRYPTROOT mounted@: $1" ++fi + + if [ -d "$1" ]; then + # install to given mounted root diff --git a/main/alpine-conf/APKBUILD b/main/alpine-conf/APKBUILD index fad1892..9583f83 100644 --- a/main/alpine-conf/APKBUILD +++ b/main/alpine-conf/APKBUILD @@ -1,7 +1,7 @@ # Maintainer: Natanael Copa pkgname=alpine-conf pkgver=3.1.0 -pkgrel=2 +pkgrel=3 pkgdesc="Alpine configuration management scripts" url=http://git.alpinelinux.org/cgit/$pkgname arch="all" @@ -10,6 +10,7 @@ depends="openrc" source="http://dev.alpinelinux.org/archive/alpine-conf/alpine-conf-$pkgver.tar.xz 0001-update-kernel-fix-typo.patch 0001-setup-disk-pass-nomodeset-boot-option.patch + 0002-setup-disk-add-luks-support.patch " _builddir="$srcdir"/$pkgname-$pkgver @@ -38,10 +39,13 @@ package() { md5sums="d48adaa13dbba0e4c461b39a59fb1c10 alpine-conf-3.1.0.tar.xz fe4a81cdf9d30c1f0bbcc9977e96410a 0001-update-kernel-fix-typo.patch -4b7844387da57e3ffdcd1e09c0a45fb6 0001-setup-disk-pass-nomodeset-boot-option.patch" +4b7844387da57e3ffdcd1e09c0a45fb6 0001-setup-disk-pass-nomodeset-boot-option.patch +b5f04d1ebe1f4dcbb8a520f1184d9a41 0002-setup-disk-add-luks-support.patch" sha256sums="5c5c3081fba18c0303bd29ccf8caab5d550c0a767f9b3b1e6a0644b717661122 alpine-conf-3.1.0.tar.xz cc1a2254eae01c2cde362cc7cf65d6e5ba7d53a7ced8a170b0502130af6877be 0001-update-kernel-fix-typo.patch -a5e486f41dafdca904e1d67b2bb26d871e6ec9597295e1fc21ea5d8995986570 0001-setup-disk-pass-nomodeset-boot-option.patch" +a5e486f41dafdca904e1d67b2bb26d871e6ec9597295e1fc21ea5d8995986570 0001-setup-disk-pass-nomodeset-boot-option.patch +8befff4156c1f6155ad0b59082bb60d9d418806151d7450977c01b2cbac6c2bd 0002-setup-disk-add-luks-support.patch" sha512sums="22ce9a149171cf8503937b60d36ec2b69fb95123d3e3f7776cc3c9e0f14cdc8a9a2338be8c223233652cd1456f6b55bbc71ed0deda2efb75f0e62b67a4c40088 alpine-conf-3.1.0.tar.xz 7f30c7ecb696b4fbf815802bd9d369f2d21a2b2502efdeac3af260df72195c19199fddc81702eb204746146433a23c0649bcf1b8a71c57a34971c4457f0ac33f 0001-update-kernel-fix-typo.patch -3ff38ab78bc0a07762c7c3668cf4daaa4ca2d030ef148e61de6dbb1df4589fd2c844c992f35ce64aa9cc3125d7422ba9deb727259cc68a61e7f6d6ff22de16f7 0001-setup-disk-pass-nomodeset-boot-option.patch" +3ff38ab78bc0a07762c7c3668cf4daaa4ca2d030ef148e61de6dbb1df4589fd2c844c992f35ce64aa9cc3125d7422ba9deb727259cc68a61e7f6d6ff22de16f7 0001-setup-disk-pass-nomodeset-boot-option.patch +96a7e993879a676d32d41a0c29b31803b04731f64107eb651147560aef8de9c179883d1d55eb23fad0ad4347b535c5fe94ccd2135f3b744ecddfa6f34ee22c99 0002-setup-disk-add-luks-support.patch" --=_2041ad7312c0d2b872948b21e3d2ffa0 Content-Transfer-Encoding: base64 Content-Type: text/x-shellscript; name=setup-disk.new Content-Disposition: attachment; filename=setup-disk.new; size=29899 IyEvYmluL3NoCgpQUkVGSVg9Ci4gIiRQUkVGSVgvbGliL2xpYmFscGluZS5zaCIKCk1CUj0ke01C UjotIi91c3Ivc2hhcmUvc3lzbGludXgvbWJyLmJpbiJ9ClJPT1RGUz0ke1JPT1RGUzotZXh0NH0K Qk9PVEZTPSR7Qk9PVEZTOi1leHQ0fQpWQVJGUz0ke1ZBUkZTOi1leHQ0fQoKIyBkZWZhdWx0IGxv Y2F0aW9uIGZvciBtb3VudGVkIHJvb3QKU1lTUk9PVD0ke1NZU1JPT1Q6LS9tbnR9Cgppbl9saXN0 KCkgewoJbG9jYWwgaT0iJDEiCglzaGlmdAoJd2hpbGUgWyAkIyAtZ3QgMCBdOyBkbwoJCVsgIiRp IiA9ICIkMSIgXSAmJiByZXR1cm4gMAoJCXNoaWZ0Cglkb25lCglyZXR1cm4gMQp9CgphbGxfaW5f bGlzdCgpIHsKCWxvY2FsIG5lZWRsZT0iJDEiCglsb2NhbCBpCglbIC16ICIkbmVlZGxlIiBdICYm IHJldHVybiAxCglzaGlmdAoJZm9yIGkgaW4gJG5lZWRsZTsgZG8KCQlpbl9saXN0ICIkaSIgJEAg fHwgcmV0dXJuIDEKCWRvbmUKCXJldHVybiAwCn0KCiMgd3JhcHBlciB0byBvbmx5IHNob3cgZ2l2 ZW4gZGV2aWNlCl9ibGtpZCgpIHsKCWJsa2lkIHwgZ3JlcCAiXiQxOiIKfQoKIyBpZiBnaXZlbiBk ZXZpY2UgaGF2ZSBhbiBVVUlEIGRpc3BsYXkgaXQsIG90aGVyd2lzZSByZXR1cm4gdGhlIGRldmlj ZQp1dWlkX29yX2RldmljZSgpIHsKCWxvY2FsIGk9CgljYXNlICIkMSIgaW4KCQkvZGV2L21kKikg ZWNobyAiJDEiICYmIHJldHVybiAwOzsKCWVzYWMKCSMgY3J5cHRlZCBkZXZpY2VzIG5lZWQgYSBk ZXZpY2UgbWFwcGVyIGluIGZzdGFiIG5vdCBhbiBMVk0gdm9sdW1lCglpZiBbIC1uICIkQ1JZUFRE TSIgXTsgdGhlbgoJCWlmIGVjaG8gJDF8IGdyZXAgIl4vZGV2LyQoZmluZF9sdWtzX3ZnKS8iIDE+ IC9kZXYvbnVsbDsgdGhlbgoJICAgICAgICAgICAgICAgIGVjaG8gIiQoY29udmVydF92Z190b19t YXBwZXIgJDEpIiAmJiByZXR1cm4gMAoJCWVsaWYgZWNobyAkMXwgZ3JlcCAiXi9kZXYvbWFwcGVy LyIgMT4vZGV2L251bGw7IHRoZW4KCQkJZWNobyAiJDEiICYmIHJldHVybiAwCgkJZmkKIAlmaQoJ Zm9yIGkgaW4gJChfYmxraWQgIiQxIik7IGRvCgkJY2FzZSAiJGkiIGluCgkJCVVVSUQ9KikgZXZh bCAkaTs7CgkJZXNhYwoJZG9uZQoJaWYgWyAtbiAiJFVVSUQiIF07IHRoZW4KCQllY2hvICJVVUlE PSRVVUlEIgoJZWxzZQoJCWVjaG8gIiQxIgoJZmkKfQoKIyBnZW5lcmF0ZSBhbiBmc3RhYiBmcm9t IGEgZ2l2ZW4gbW91bnRwb2ludC4gQ29udmVydCB0byBVVUlEIGlmIHBvc3NpYmxlCmVudW1lcmF0 ZV9mc3RhYigpIHsKCWxvY2FsIG1udD0iJDEiCglsb2NhbCBmc19zcGVjPSBmc19maWxlPSBmc192 ZnN0eXBlPSBmc19tbnRvcHM9IGZzX2ZyZXE9IGZzX3Bhc3Nubz0KCVsgLXogIiRtbnQiIF0gJiYg cmV0dXJuCglsb2NhbCBlc2NhcGVkX21udD0kKGVjaG8gJG1udCB8IHNlZCAtZSAnczovKiQ6Oicg LWUgJ3M6LzpcXC86ZycpCglhd2sgIlwkMiB+IC9eJGVzY2FwZWRfbW50KFwvfFwkKS8ge3ByaW50 IFwkMH0iIC9wcm9jL21vdW50cyB8IFwKCQlzZWQgInM6JG1udDovOmc7IHM6IDpcdDpnIiB8IHNl ZCAtRSAnczovKzovOmcnIHwgXAoJCXdoaWxlIHJlYWQgZnNfc3BlYyBmc19maWxlIGZzX3Zmc3R5 cGUgZnNfbW50b3BzIGZzX2ZyZXEgZnNfcGFzc25vOyBkbwoJCQllY2hvIC1lICIkKHV1aWRfb3Jf ZGV2aWNlICRmc19zcGVjKVx0JHtmc19maWxlfVx0JHtmc192ZnN0eXBlfVx0JHtmc19tbnRvcHN9 ICR7ZnNfZnJlcX0gJHtmc19wYXNzbm99IgoJCWRvbmUKfQoKaXNfdm13YXJlKCkgewoJZ3JlcCAt cSBWTXdhcmUgL3Byb2Mvc2NzaS9zY3NpIDI+L2Rldi9udWxsIFwKCQl8fCBncmVwIC1xIFZNd2Fy ZSAvcHJvYy9pZGUvaGQqL21vZGVsIDI+L2Rldi9udWxsCn0KCiMgcmV0dXJuIHRydWUgKDApIGlm IGdpdmVuIGRldmljZSBpcyBsdm0KaXNfbHZtKCkgewoJbHZzICIkMSIgPi9kZXYvbnVsbCAyPiYx Cn0KCiMgRmluZCB0aGUgZGlzayBkZXZpY2UgZnJvbSBnaXZlbiBwYXJ0aXRpb24KZGlza19mcm9t X3BhcnQoKSB7CgkjIHdlIG5lZWQgY29udmVydCBjY2lzcy9jMGQwKiBjY2lzcyFjMGQwKi4uLgoJ bG9jYWwgaT0gcGFydD0kKGVjaG8gJHsxIy9kZXYvfSB8IHNlZCAnczovOiE6ZycpCglmb3IgaSBp biAvc3lzL2Jsb2NrLyovJHBhcnQ7IGRvCgkJaT0ke2klLyp9CgkJIyAuLi5hbmQgYmFjayBmcm9t IGNjaXNzIWMwZDAgdG8gY2Npc3MvYzBkMAoJCWlmIFsgLWIgIi9kZXYvJHtpIyMqL30iIF07IHRo ZW4KCQkJZWNobyAiL2Rldi8ke2kjIyovfSIgfCBzZWQgJ3M6ITovOmcnCgkJCXJldHVybiAwCgkJ ZmkKCWRvbmUKCXJldHVybiAxCn0KCnVucGFja19hcGtvdmwoKSB7Cglsb2NhbCBvdmw9IiQxIgoJ bG9jYWwgZGVzdD0iJDIiCglsb2NhbCBzdWZmaXg9JHtvdmwjIyoufQoJbG9jYWwgaQoJb3ZsZmls ZXM9L3RtcC9vdmxmaWxlcwoJaWYgWyAiJHN1ZmZpeCIgPSAiZ3oiIF07IHRoZW4KCQlpZiAhIHRh ciAtQyAiJGRlc3QiIC0tbnVtZXJpYy1vd25lciAtenh2ZiAiJG92bCIgPiAkb3ZsZmlsZXM7IHRo ZW4KCQkJZWNobyAtbiAiQ29udGludWUgYW55d2F5PyBbWS9uXTogIgoJCQlyZWFkIGkKCQkJY2Fz ZSAiJGkiIGluCgkJCQluKnxOKikgcmV0dXJuIDE7OwoJCQllc2FjCgkJZmkKCQlyZXR1cm4gMAoJ ZmkKCglhcGsgYWRkIC0tcXVpZXQgb3BlbnNzbAoKCWlmICEgb3BlbnNzbCBsaXN0LWNpcGhlci1j b21tYW5kcyB8IGdyZXAgIl4kc3VmZml4JCIgPiAvZGV2L251bGw7IHRoZW4KCQllcnJzdHI9IkNp cGhlciAkc3VmZml4IGlzIG5vdCBzdXBwb3J0ZWQiCgkJcmV0dXJuIDEKCWZpCglsb2NhbCBjb3Vu dD0wCgkjIGJlZXAKCWVjaG8gLWUgIlwwMDciCgl3aGlsZSBbICRjb3VudCAtbHQgMyBdOyBkbwoJ CW9wZW5zc2wgZW5jIC1kIC0kc3VmZml4IC1pbiAiJG92bCIgfCB0YXIgLS1udW1lcmljLW93bmVy IFwKCQkJLUMgIiRkZXN0IiAtenh2ID4kb3ZsZmlsZXMgMj4vZGV2L251bGwgJiYgcmV0dXJuIDAK CQljb3VudD0kKCggJGNvdW50ICsgMSApKQoJZG9uZQoJb3ZsZmlsZXM9CglyZXR1cm4gMQp9Cgoj IGZpbmQgZmlsZXN5c3RlbSBvZiBnaXZlbiBtb3VudGVkIGRpcgpmaW5kX21vdW50X2ZzKCkgewoJ bG9jYWwgbW91bnRfcG9pbnQ9IiQxIgoJYXdrICJcJDIgPT0gXCIkbW91bnRfcG9pbnRcIiB7cHJp bnQgXCQzfSIgL3Byb2MvbW91bnRzIHwgdGFpbCAtbiAxCn0KCiMgZmluZCBkZXZpY2UgZm9yIGdp dmVuIG1vdW50ZWQgZGlyCmZpbmRfbW91bnRfZGV2KCkgewoJbG9jYWwgbW50PSIkMSIKCWF3ayAi XCQyID09IFwiJG1udFwiIHsgcHJpbnQgXCQxIH0iIC9wcm9jL21vdW50cyB8IHRhaWwgLW4gMQp9 CgpzdXBwb3J0ZWRfYm9vdF9mcygpIHsKCWxvY2FsIHN1cHBvcnRlZD0iZXh0MiBleHQzIGV4dDQg YnRyZnMiCglsb2NhbCBmcz0KCWZvciBmcyBpbiAkc3VwcG9ydGVkOyBkbwoJCVsgIiRmcyIgPSAi JDEiIF0gJiYgcmV0dXJuIDAKCWRvbmUKCWVjaG8gIiQxIGlzIG5vdCBzdXBwb3J0ZWQuIE9ubHkg c3VwcG9ydGVkIGFyZTogJHN1cHBvcnRlZCIgPiYyCglyZXR1cm4gMQp9CgpmaW5kX3ZvbHVtZV9n cm91cCgpIHsKCWxvY2FsIGx2PSR7MSMjKi99CglsdnMgLS1ub2hlYWRpbmdzICIkMSIgfCBhd2sg IlwkMSA9PSBcIiRsdlwiIHtwcmludCBcJDJ9Igp9CgpmaW5kX3B2c19pbl92ZygpIHsKCWxvY2Fs IHZnPSIkMSIKCXB2cyAtLW5vaGVhZGluZ3MgfCBhd2sgIlwkMiA9PSBcIiR2Z1wiIHtwcmludCBc JDF9Igp9CgojIGVjaG8gY3VycmVudCBncnNlY3VyaXR5IG9wdGlvbiBhbmQgc2V0IG5ldwpzZXRf Z3JzZWMoKSB7Cglsb2NhbCBrZXk9IiQxIiB2YWx1ZT0iJDIiCglpZiAhIFsgLWUgL3Byb2Mvc3lz L2tlcm5lbC9ncnNlY3VyaXR5LyRrZXkgXTsgdGhlbgoJCXJldHVybiAwCglmaQoJY2F0IC9wcm9j L3N5cy9rZXJuZWwvZ3JzZWN1cml0eS8ka2V5CgllY2hvICR2YWx1ZSA+IC9wcm9jL3N5cy9rZXJu ZWwvZ3JzZWN1cml0eS8ka2V5Cn0KCmluaXRfY2hyb290X21vdW50cygpIHsKCWxvY2FsIG1udD0i JDEiIGk9Cglmb3IgaSBpbiBwcm9jIGRldjsgZG8KCQlta2RpciAtcCAiJG1udCIvJGkKCQltb3Vu dCAtLWJpbmQgLyRpICIkbW50Ii8kaQoJZG9uZQp9CgpjbGVhbnVwX2Nocm9vdF9tb3VudHMoKSB7 Cglsb2NhbCBtbnQ9IiQxIiBpPQoJZm9yIGkgaW4gcHJvYyBkZXY7IGRvCgkJdW1vdW50ICIkbW50 Ii8kaQoJZG9uZQp9CgpoYXNfYm9vdG9wdCgpIHsKCWxvY2FsIG9wdD0iJDEiCglzZXQgLS0gJChj YXQgL3Byb2MvY21kbGluZSkKCWZvciBpOyBkbwoJCVsgIiRpIiA9ICIkb3B0IiBdICYmIHJldHVy biAwCglkb25lCglyZXR1cm4gMQp9CgppbnN0YWxsX21vdW50ZWRfcm9vdCgpIHsKCWxvY2FsIG1u dD0iJDEiIG1udF9ib290PSBib290X2ZzPSByb290X2ZzPQoJbG9jYWwgaW5pdGZzX2ZlYXR1cmVz PSJhdGEgYmFzZSBpZGUgc2NzaSB1c2IgdmlydGlvIgoJbG9jYWwgcHZzPSBkZXY9IHJvb3RkZXY9 IGJvb3RkZXY9IGV4dGxpbnV4X3JhaWRvcHQ9IHJvb3Q9IG1vZHVsZXM9Cglsb2NhbCBrZXJuZWxf b3B0cz0icXVpZXQiCgoJcm9vdGRldj0kKGZpbmRfbW91bnRfZGV2ICIkbW50IikKCWlmIFsgLXog IiRyb290ZGV2IiBdOyB0aGVuCgkJZWNobyAiJG1udCBkb2VzIG5vdCBzZWVtIHRvIGJlIGEgbW91 bnQgcG9pbnQiID4mMgoJCXJldHVybiAxCglmaQoJcm9vdF9mcz0kKGZpbmRfbW91bnRfZnMgIiRt bnQiKQoJaW5pdGZzX2ZlYXR1cmVzPSIkaW5pdGZzX2ZlYXR1cmVzICRyb290X2ZzIgoKCWlmIGlz X2x2bSAiJHJvb3RkZXYiOyB0aGVuCgkJaW5pdGZzX2ZlYXR1cmVzPSIkaW5pdGZzX2ZlYXR1cmVz IGx2bSIKCQlsb2NhbCB2Zz0kKGZpbmRfdm9sdW1lX2dyb3VwICIkcm9vdGRldiIpCgkJcHZzPSQo ZmluZF9wdnNfaW5fdmcgJHZnKQoJZmkKCglpZiBbIC1uICIkQ1JZUFRETSIgXTsgdGhlbgoJCWlu aXRmc19mZWF0dXJlcz0iJGluaXRmc19mZWF0dXJlcyBjcnlwdHNldHVwIgoJCWlmIGlzX2x1a3Nf cHYgIiRDUllQVERNIiAmJiBbIC16ICQoZWNobyAkaW5pdGZzX2ZlYXR1cmVzfCBncmVwIC13ICJs dm0iKSBdOyB0aGVuCgkJCWluaXRmc19mZWF0dXJlcz0iJGluaXRmc19mZWF0dXJlcyBsdm0iCgkJ CWxvY2FsIHZnPSQoZmluZF9sdWtzX3ZnKQoJCQlwdnM9JChmaW5kX3B2c19pbl92ZyAkdmcpCgkJ ZmkJCQkKCWZpCgoJYm9vdGRldj0kKGZpbmRfbW91bnRfZGV2ICIkbW50Ii9ib290KQoJaWYgWyAt eiAiJGJvb3RkZXYiIF07IHRoZW4KCQlib290ZGV2PSRyb290ZGV2CgkJbW50X2Jvb3Q9IiRtbnQi CgllbHNlCgkJbW50X2Jvb3Q9IiRtbnQiL2Jvb3QKCWZpCglib290X2ZzPSQoZmluZF9tb3VudF9m cyAiJG1udF9ib290IikKCXN1cHBvcnRlZF9ib290X2ZzICIkYm9vdF9mcyIgfHwgcmV0dXJuIDEK CgkjIENoZWNrIGlmIHdlIGJvb3QgZnJvbSByYWlkIHNvIHdlIGNhbiBwYXNzIHByb3BlciBvcHRp b24gdG8KCSMgZXh0bGludXggbGF0ZXIuCglpZiBbIC1lICIvc3lzL2Jsb2NrLyR7Ym9vdGRldiMv ZGV2L30vbWQiIF07IHRoZW4KCQlleHRsaW51eF9yYWlkb3B0PSItLXJhaWQiCglmaQoKCSMgY2hl Y2sgaWYgb3VyIHJvb3QgaXMgb24gcmFpZCBzbyB3ZSBjYW4gZmVlZCBta2luaXRmcyBhbmQKCSMg dXBkYXRlLWV4bGludXguY29uZiB3aXRoIHRoZSBwcm9wZXIga2VybmVsIG1vZHVsZSBwYXJhbXMK CWZvciBkZXYgaW4gJHJvb3RkZXYgJHB2czsgZG8KCQlbIC1lICIvc3lzL2Jsb2NrLyR7ZGV2Iy9k ZXYvfS9tZCIgXSB8fCBjb250aW51ZQoKCQlsb2NhbCBtZD0ke2RldiMvZGV2L30KCQlpbml0ZnNf ZmVhdHVyZXM9IiR7aW5pdGZzX2ZlYXR1cmVzJSByYWlkfSByYWlkIgoJCWxvY2FsIGxldmVsPSQo Y2F0IC9zeXMvYmxvY2svJG1kL21kL2xldmVsKQoJCWNhc2UgIiRsZXZlbCIgaW4KCQkJcmFpZDEp IHJhaWRtb2Q9IiR7cmFpZG1vZCUscmFpZDF9LHJhaWQxIjs7CgkJCXJhaWRbNDU2XSkgcmFpZG1v ZD0iJHtyYWlkbW9kJSxyYWlkNDU2fSxyYWlkNDU2Ijs7CgkJZXNhYwoJZG9uZQoKCSMgY2hlY2sg aWYgd2UgbmVlZCBoYXJkd2FyZSByYWlkIGRyaXZlcnMKCWNhc2UgJHJvb3RkZXYgaW4KCQkvZGV2 L2NjaXNzLyopCgkJCWluaXRmc19mZWF0dXJlcz0iJHtpbml0ZnNfZmVhdHVyZXMlIHJhaWR9IHJh aWQiCgkJCTs7Cgllc2FjCgoJaWYgWyAtbiAiJFZFUkJPU0UiIF07IHRoZW4KCQllY2hvICJSb290 IGRldmljZTogICAgICRyb290ZGV2IgoJCWVjaG8gIlJvb3QgZmlsZXN5c3RlbTogJHJvb3RfZnMi CgkJZWNobyAiQm9vdCBkZXZpY2U6ICAgICAkYm9vdGRldiIKCQllY2hvICJCb290IGZpbGVzeXN0 ZW06ICRib290X2ZzIgoJZmkKCglpZiBbIC16ICIkQVBLT1ZMIiBdOyB0aGVuCgkJb3ZsZmlsZXM9 L3RtcC9vdmxmaWxlcwoJCWxidSBwYWNrYWdlIC0gfCB0YXIgLUMgIiRtbnQiIC16eHYgPiAiJG92 bGZpbGVzIgoJCSMgY29tbWVudCBvdXQgbG9jYWwgcmVwb3NpdG9yaWVzCgkJaWYgWyAtZiAiJG1u dCIvZXRjL2Fway9yZXBvc2l0b3JpZXMgXTsgdGhlbgoJCQlzZWQgLWkgLWUgJ3M6Xi86Iy86JyAi JG1udCIvZXRjL2Fway9yZXBvc2l0b3JpZXMKCQlmaQoJZWxzZQoJCWVjaG8gIlJlc3RvcmluZyBi YWNrdXAgZnJvbSAkQVBLT1ZMIHRvICRyb290ZGV2Li4uIgoJCXVucGFja19hcGtvdmwgIiRBUEtP VkwiICIkbW50IiB8fCByZXR1cm4gMQoJZmkKCgkjIGdlbmVyYXRlIG1raW5pdGZzLmNvbmYKCW1r ZGlyIC1wICIkbW50Ii9ldGMvbWtpbml0ZnMvZmVhdHVyZXMuZAoJZWNobyAiZmVhdHVyZXM9XCIk aW5pdGZzX2ZlYXR1cmVzXCIiID4gIiRtbnQiL2V0Yy9ta2luaXRmcy9ta2luaXRmcy5jb25mCglp ZiBbIC1uICIkcmFpZG1vZCIgXTsgdGhlbgoJCWVjaG8gIi9zYmluL21kYWRtIiA+ICIkbW50Ii9l dGMvbWtpbml0ZnMvZmVhdHVyZXMuZC9yYWlkLmZpbGVzCgkJZWNobyAiL2V0Yy9tZGFkbS5jb25m IiA+PiAiJG1udCIvZXRjL21raW5pdGZzL2ZlYXR1cmVzLmQvcmFpZC5maWxlcwoJZmkKCgkjIGdl bmVyYXRlIHVwZGF0ZS1leHRsaW51eC5jb25mCglyb290PSQodXVpZF9vcl9kZXZpY2UgJHJvb3Rk ZXYpCglpZiBpc192bXdhcmU7IHRoZW4KCQlrZXJuZWxfb3B0cz0icGF4X25vdWRlcmVmICRrZXJu ZWxfb3B0cyIKCWZpCglpZiBoYXNfYm9vdG9wdCBub21vZGVzZXQ7IHRoZW4KCQlrZXJuZWxfb3B0 cz0ibm9tb2Rlc2V0ICRrZXJuZWxfb3B0cyIKCWZpCglpZiBbIC1uICIkQ1JZUFRETSIgXTsgdGhl bgoJCWtlcm5lbF9vcHRzPSIka2VybmVsX29wdHMgY3J5cHRyb290PSRDUllQVFJPT1QgY3J5cHRk bT0kQ1JZUFRETSIKCQlzZXR1cF9jcnlwdHRhYgoJZmkKCW1vZHVsZXM9InNkLW1vZCx1c2Itc3Rv cmFnZSwke3Jvb3RfZnN9JHtyYWlkbW9kfSIKCXNlZCAtZSAiczpecm9vdD0uKjpyb290PSRyb290 OiIgXAoJCS1lICJzOl5kZWZhdWx0X2tlcm5lbF9vcHRzPS4qOmRlZmF1bHRfa2VybmVsX29wdHM9 XCIka2VybmVsX29wdHNcIjoiIFwKCQktZSAiczpebW9kdWxlcz0uKjptb2R1bGVzPSRtb2R1bGVz OiIgXAoJCS9ldGMvdXBkYXRlLWV4dGxpbnV4LmNvbmYgPiAiJG1udCIvZXRjL3VwZGF0ZS1leHRs aW51eC5jb25mCglpZiBbICIkKHJjIC0tc3lzKSIgPSAiWEVOMCIgXTsgdGhlbgoJCXNlZCAtaSAt ZSAiczpeZGVmYXVsdD0uKjpkZWZhdWx0PXhlbi1ncnNlYzoiIFwKCQkJIiRtbnQiL2V0Yy91cGRh dGUtZXh0bGludXguY29uZgoJZmkKCgkjIGdlbmVyYXRlIHRoZSBmc3RhYgoJaWYgWyAtZiAiJG1u dCIvZXRjL2ZzdGFiIF07IHRoZW4KCQltdiAiJG1udCIvZXRjL2ZzdGFiICIkbW50Ii9ldGMvZnN0 YWIub2xkCglmaQoJZW51bWVyYXRlX2ZzdGFiICIkbW50IiA+PiAiJG1udCIvZXRjL2ZzdGFiCglp ZiBbIC1uICIkU1dBUF9ERVZJQ0UiIF07IHRoZW4KCQllY2hvIC1lICIke1NXQVBfREVWSUNFfVx0 c3dhcFx0c3dhcFx0ZGVmYXVsdHNcdDAgMCIgXAoJCQk+PiAiJG1udCIvZXRjL2ZzdGFiCglmaQoJ Y2F0ID4+IiRtbnQiL2V0Yy9mc3RhYiA8PEVPRgovZGV2L2Nkcm9tCS9tZWRpYS9jZHJvbQlpc285 NjYwCW5vYXV0byxybyAwIDAKL2Rldi9mZDAJL21lZGlhL2Zsb3BweQl2ZmF0CW5vYXV0bwkwIDAK L2Rldi91c2JkaXNrCS9tZWRpYS91c2IJdmZhdAlub2F1dG8JMCAwCkVPRgoJIyByZW1vdmUgdGhl IGluc3RhbGxlZCBkYiBpbiBjYXNlIGl0cyB0aGVyZSBzbyB3ZSBmb3JjZSByZS1pbnN0YWxsCgly bSAtZiAiJG1udCIvdmFyL2xpYi9hcGsvaW5zdGFsbGVkICIkbW50Ii9saWIvYXBrL2RiL2luc3Rh bGxlZAoJZWNobyAiSW5zdGFsbGluZyBzeXN0ZW0gb24gJHJvb3RkZXY6IgoJZXh0bGludXggJGV4 dGxpbnV4X3JhaWRvcHQgLS1pbnN0YWxsICIkbW50Ii9ib290CgoJIyBhcGsgcmVhZHMgY29uZmln IGZyb20gdGFyZ2V0IHJvb3Qgc28gd2UgbmVlZCB0byBjb3B5IHRoZSBjb25maWcKCW1rZGlyIC1w ICIkbW50Ii9ldGMvYXBrL2tleXMvCgljcCAvZXRjL2Fway9rZXlzLyogIiRtbnQiL2V0Yy9hcGsv a2V5cy8KCglsb2NhbCBhcGtmbGFncz0iLS1pbml0ZGIgLS1xdWlldCAtLXByb2dyZXNzIC0tdXBk YXRlLWNhY2hlIC0tY2xlYW4tcHJvdGVjdGVkIgoJbG9jYWwgcGtncz0kKGNhdCAiJG1udCIvZXRj L2Fway93b3JsZCAiJG1udCIvdmFyL2xpYi9hcGsvd29ybGQgMj4vZGV2L251bGwpCglwa2dzPSIk cGtncyBhY2N0IGxpbnV4LSRLRVJORUxfRkxBVk9SIGFscGluZS1iYXNlIgoJaWYgWyAiJChyYyAt LXN5cykiID0gIlhFTjAiIF07IHRoZW4KCQlwa2dzPSIkcGtncyB4ZW4taHlwZXJ2aXNvciIKCWZp Cglsb2NhbCByZXBvcz0kKHNlZCAtZSAncy9cIy4qLy8nIC9ldGMvYXBrL3JlcG9zaXRvcmllcykK CWxvY2FsIHJlcG9mbGFncz0KCWZvciBpIGluICRyZXBvczsgZG8KCQlyZXBvZmxhZ3M9IiRyZXBv ZmxhZ3MgLS1yZXBvc2l0b3J5ICRpIgoJZG9uZQoKCWNocm9vdF9jYXBzPSQoc2V0X2dyc2VjIGNo cm9vdF9jYXBzIDApCglpbml0X2Nocm9vdF9tb3VudHMgIiRtbnQiCglhcGsgYWRkIC0tcm9vdCAi JG1udCIgJGFwa2ZsYWdzIC0tb3ZlcmxheS1mcm9tLXN0ZGluIFwKCQkkcmVwb2ZsYWdzICRwa2dz IDwkb3ZsZmlsZXMKCWxvY2FsIHJldD0kPwoJY2xlYW51cF9jaHJvb3RfbW91bnRzICIkbW50IgoJ c2V0X2dyc2VjIGNocm9vdF9jYXBzICRjaHJvb3RfY2FwcyA+IC9kZXYvbnVsbAoJcmV0dXJuICRy ZXQKfQoKdW5tb3VudF9wYXJ0aXRpb25zKCkgewoJbG9jYWwgbW50PSIkMSIKCgkjIHVubW91bnQg dGhlIHBhcnRpdGlvbnMKCXVtb3VudCAkKGF3ayAne3ByaW50ICQyfScgL3Byb2MvbW91bnRzIHwg ZWdyZXAgIl4kbW50KC98XCQpIiB8IHNvcnQgLXIpCn0KCiMgZmlndXJlIG91dCBkZWNlbnQgZGVm YXVsdCBzd2FwIHNpemUgaW4gbWVnYSBieXRlcwpmaW5kX3N3YXBfc2l6ZSgpIHsKCWxvY2FsIG1l bXRvdGFsX2tiPSQoYXdrICckMSA9PSAiTWVtVG90YWw6IiB7cHJpbnQgJDJ9JyAvcHJvYy9tZW1p bmZvKQoJIyB1c2UgMiAqIGF2YWlhYmxlIHJhbSBvciBubyBtb3JlIHRoYW4gMS8zIG9mIHNtYWxs ZXN0IGRpc2sgc3BhY2UKCWxvY2FsIHNpemU9JCgoICRtZW10b3RhbF9rYiAqIDIgLyAxMDI0ICkp Cglsb2NhbCBkaXNrPSBkaXNrc2l6ZT0KCWZvciBkaXNrIGluICRAOyBkbwoJCWxvY2FsIHN5c2Zz ZGV2PSQoZWNobyAke2Rpc2sjL2Rldi99IHwgc2VkICdzOi86ITpnJykKCQlsb2NhbCBzeXNmc3Bh dGg9L3N5cy9ibG9jay8kc3lzZnNkZXYvc2l6ZQoJCSMgZGlza3NpemUgPSB4ICogNTEyIC8gKDEw MjQgKiAxMDI0KSA9IHggLyAyMDQ4CgkJIyBtYXhzaXplID0gJGRpc2tzaXplIC8gNCA9IHggLyAo MjA0OCAqIDQpID0geCAvIDgxOTIKCQltYXhzaXplPSQoYXdrICd7IHByaW50ZiAiJWkiLCAkMCAv IDgxOTIgfScgJHN5c2ZzcGF0aCApCgkJaWYgWyAkc2l6ZSAtZ3QgJG1heHNpemUgXTsgdGhlbgoJ CQlzaXplPSRtYXhzaXplCgkJZmkKCWRvbmUKCWlmIFsgJHNpemUgLWd0IDQwOTYgXTsgdGhlbgoJ CSMgZG9udCBldmVyIHVzZSBtb3JlIHRoYW4gNEcKCQlzaXplPTQwOTYKCWVsaWYgWyAkc2l6ZSAt bHQgNjQgXTsgdGhlbgoJCSMgZG9udCBib3RoZXIgY3JlYXRlIHN3YXAgc21hbGxlciB0aGFuIDY0 TUIKCQlzaXplPTAKCWZpCgllY2hvICRzaXplCn0KCmhhc19tb3VudGVkX3BhcnQoKSB7Cglsb2Nh bCBwCglsb2NhbCBzeXNmc2Rldj0kKGVjaG8gJHsxIy9kZXYvfSB8IHNlZCAnczovOiE6ZycpCgkj IHBhcnNlIC9wcm9jL21vdW50cyBmb3IgbW91bnRlZCBkZXZpY2VzCglmb3IgcCBpbiAkKGF3ayAn JDEgfiAvXlwvZGV2XC8vIHtnc3ViKCIvZGV2LyIsICIiLCAkMSk7IGdzdWIoIi8iLCAiISIsICQx KTsgcHJpbnQgJDF9JyBcCgkJCS9wcm9jL21vdW50cyk7IGRvCgkJWyAiJHAiID0gIiRzeXNmc2Rl diIgXSAmJiByZXR1cm4gMAoJCVsgLWUgL3N5cy9ibG9jay8kc3lzZnNkZXYvJHAgXSAmJiByZXR1 cm4gMAoJZG9uZQoJcmV0dXJuIDEKfQoKaGFzX2hvbGRlcnMoKSB7Cglsb2NhbCBpCgkjIGNoZWNr IGlmIGRldmljZSBpcyB1c2VkIGJ5IGFueSBtZCBkZXZpY2VzCglmb3IgaSBpbiAkMS9ob2xkZXJz LyogJDEvKi9ob2xkZXJzLyo7IGRvCgkJWyAtZSAiJGkiIF0gJiYgcmV0dXJuIDAKCWRvbmUKCXJl dHVybiAxCn0KCmlzX2F2YWlsYWJsZV9kaXNrKCkgewoJbG9jYWwgZGV2PSQxCglsb2NhbCBiPSQo ZWNobyAkcCB8IHNlZCAnczovOiE6ZycpCgoJIyBjaGVjayBpZiBpdHMgYSAicm9vdCIgYmxvY2sg ZGV2aWNlIGFuZCBub3QgYSBwYXJ0aXRpb24KCVsgLWUgL3N5cy9ibG9jay8kYiBdIHx8IHJldHVy biAxCgoJIyBjaGVjayBzbyBpdCBkb2VzIG5vdCBoYXZlIG1vdW50ZWQgcGFydGl0aW9ucwoJaGFz X21vdW50ZWRfcGFydCAkZGV2ICYmIHJldHVybiAxCgoJIyBjaGVjayBzbyBpdHMgbm90IHBhcnQg b2YgYW4gbWQgc2V0dXAKCWlmIGhhc19ob2xkZXJzIC9zeXMvYmxvY2svJGI7IHRoZW4KCQlbIC1u ICIkVVNFX1JBSUQiIF0gJiYgZWNobyAiV2FybmluZzogJGRldiBpcyBwYXJ0IG9mIGEgcnVubmlu ZyByYWlkIiA+JjIKCQlyZXR1cm4gMQoJZmkKCgkjIGNoZWNrIHNvIGl0cyBub3QgYW4gbWQgZGV2 aWNlCglbIC1lIC9zeXMvYmxvY2svJGIvbWQgXSAmJiByZXR1cm4gMQoKCXJldHVybiAwCn0KCmZp bmRfZGlza3MoKSB7Cglsb2NhbCBwPQoJZm9yIHAgaW4gJChhd2sgJyQxIH4gL1swLTldKy8ge3By aW50ICQ0fScgL3Byb2MvcGFydGl0aW9ucyk7IGRvCgkJaXNfYXZhaWxhYmxlX2Rpc2sgJHAgJiYg ZWNobyAtbiAiICRwIgoJZG9uZQp9CgpzdG9wX2FsbF9yYWlkKCkgewoJbG9jYWwgcmQKCWZvciBy ZCBpbiAvZGV2L21kKjsgZG8KCQlbIC1iICRyZCBdICYmIG1kYWRtIC0tc3RvcCAkcmQKCWRvbmUK fQoKIyBpbnN0YWxsIG5lZWRlZCBwcm9ncmFtcwppbml0X3Byb2dzKCkgewoJbG9jYWwgcmFpZHBr Zz0KCVsgLW4gIiRVU0VfUkFJRCIgXSAmJiByYWlkcGtnPSJtZGFkbSIKCWNhc2UgJFJPT1RGUyBp bgoJZXh0KikgZnN0b29scz1lMmZzcHJvZ3M7IG1rZnNfYXJncz0iLXEiOzsKCXhmcykgZnN0b29s cz14ZnNwcm9nczsgbWtmc19hcmdzPSItcSI7OwoJYnRyZnMpIGZzdG9vbHM9YnRycy1wcm9nczsg bWtmc19hcmdzPSIiOzsKCWVzYWMKCWFwayBhZGQgLS1xdWlldCBzZmRpc2sgZTJmc3Byb2dzIGx2 bTIgJHJhaWRwa2cgc3lzbGludXggJGZzdG9vbHMgJEAKfQoKc2hvd19kaXNrX2luZm8oKSB7Cgls b2NhbCBkaXNrPSB2ZW5kb3I9IG1vZGVsPSBkPSBzaXplPQoJZm9yIGRpc2sgaW4gJEA7IGRvCgkJ bG9jYWwgZGV2PSR7ZGlzayMvZGV2L30KCQlkPSQoZWNobyAkZGV2IHwgc2VkICdzOi86ITpnJykK CQl2ZW5kb3I9JChjYXQgL3N5cy9ibG9jay8kZC9kZXZpY2UvdmVuZG9yIDI+L2Rldi9udWxsKQoJ CW1vZGVsPSQoY2F0IC9zeXMvYmxvY2svJGQvZGV2aWNlL21vZGVsIDI+L2Rldi9udWxsKQoJCXNp emU9JChhd2sgJ3tnYiA9ICgkMSAqIDUxMikvMTAwMDAwMDAwMDsgcHJpbnRmICIlLjFmIEdCXG4i LCBnYn0nIC9zeXMvYmxvY2svJGQvc2l6ZSAyPi9kZXYvbnVsbCkKCQllY2hvICIgICRkZXYJKCRz aXplICR2ZW5kb3IgJG1vZGVsKSIKCWRvbmUKfQoKY29uZmlybV9lcmFzZSgpIHsKCWxvY2FsIGFu c3dlcj0KCWxvY2FsIGVyYXNlZGlza3M9IiRAIgoJaWYgWyAiJEVSQVNFX0RJU0tTIiA9ICIkZXJh c2VkaXNrcyIgXTsgdGhlbgoJCXJldHVybiAwCglmaQoJZWNobyAiV0FSTklORzogVGhlIGZvbGxv d2luZyBkaXNrKHMpIHdpbGwgYmUgZXJhc2VkOiIKCXNob3dfZGlza19pbmZvICRACgllY2hvIC1u ICJXQVJOSU5HOiBFcmFzZSB0aGUgYWJvdmUgZGlzayhzKSBhbmQgY29udGludWU/IFt5L05dOiAi CgoJcmVhZCBhbnN3ZXIKCWNhc2UgIiRhbnN3ZXIiIGluCgkJeSp8WSopIHJldHVybiAwOzsKCWVz YWMKCXJldHVybiAxCn0KCiMgc2V0dXAgcGFydGl0aW9ucyBvbiBnaXZlbiBkaXNrIGRldiBpbiAk MS4KIyB1c2FnZTogc2V0dXBfcGFydGl0aW9ucyA8ZGlza2Rldj4gc2l6ZTEsdHlwZTEgW3NpemUy LHR5cGUyIC4uLl0Kc2V0dXBfcGFydGl0aW9ucygpIHsKCWxvY2FsIGRpc2tkZXY9IiQxIgoJc2hp ZnQKCgllY2hvICJJbml0aWFsaXppbmcgcGFydGl0aW9ucyBvbiAkZGlza2Rldi4uLiIKCgkjIG5l dyBkaXNrcyBkb2VzIG5vdCBoYXZlIGFuIERPUyBzaWduYXR1cmUgaW4gc2VjdG9yIDAKCSMgdGhp cyBtYWtlcyBzZmRpc2sgY29tcGxhaW4uIFdlIGNhbiB3b3JrYXJvdW5kIHRoaXMgYnkgbGV0dGlu ZwoJIyBmZGlzayBjcmVhdGUgdGhhdCBET1Mgc2lnbmF0dXJlLCBieSBqdXN0IGRvIGEgInciLCBh IHdyaXRlLgoJIyBodHRwOi8vYnVncy5hbHBpbmVsaW51eC5vcmcvaXNzdWVzL3Nob3cvMTQ1Cgll Y2hvICJ3IiB8IGZkaXNrICRkaXNrZGV2ID4vZGV2L251bGwKCgkjIGZpeCB0aGUgTUJSIHdoaWxl IGhlcmUgc28gZXh0bGludXggY2FuIGJvb3QKCWNhdCAiJE1CUiIgPiAkZGlza2RldgoKCWxvY2Fs IHN0YXJ0PTAKCWxvY2FsIGxpbmU9CgkjIGNyZWF0ZSBuZXcgcGFydGl0aW9ucwoJKAoJCWZvciBs aW5lIGluICIkQCI7IGRvCgkJCWVjaG8gIiRzdGFydCwkbGluZSIKCQkJc3RhcnQ9CgkJZG9uZQoJ KSB8IHNmZGlzayAtcSAtTCAtdU0gJGRpc2tkZXYgPi9kZXYvbnVsbCB8fCByZXR1cm4gMQoKCSMg Y3JlYXRlIGRldmljZSBub2RlcyBpZiBub3QgZXhpc3QKCW1kZXYgLXMKfQoKIyBmaW5kIHRoZSBi b290YWJsZSBwYXJ0aXRpb24gb24gZ2l2ZW4gZGlzawpmaW5kX2Jvb3RfcGFydGl0aW9uKCkgewoJ c2ZkaXNrIC1MIC1kICQxIHwgYXdrICcvYm9vdGFibGUvIHtwcmludCAkMX0nCn0KCiMgZmluZCB0 aGUgcGFydGl0aW9uKHMpIGZvciBMVk0KIyB0aGlzIGlzIG5vdCBtYXJrZWQgYXMgYm9vdGFibGUg YW5kIGlzIHR5cGUgOGUKZmluZF9sdm1fcGFydGl0aW9uKCkgewoJbG9jYWwgdHlwZT04ZQoJc2Zk aXNrIC1kICQxIHwgZ3JlcCAtdiBib290YWJsZSB8IGF3ayAiL0lkPSR0eXBlLyB7cHJpbnQgXCQx fSIKfQoKIyBzZXQgdXAgb3B0aW9uYWwgcmFpZCBhbmQgY3JlYXRlIGZpbGVzeXN0ZW0gb24gYm9v dCBkZXZpY2UuCnNldHVwX2Jvb3RfZGV2KCkgewoJbG9jYWwgZGlzaz0gYm9vdGRldj0KCWxvY2Fs IHBhcnQ9JChmb3IgZGlzayBpbiAkQDsgZG8gZmluZF9ib290X3BhcnRpdGlvbiAkZGlzazsgZG9u ZSkKCXNldCAtLSAkcGFydAoJYm9vdGRldj0kMQoJWyAteiAiJGJvb3RkZXYiIF0gJiYgcmV0dXJu IDEKCWVjaG8gIkNyZWF0aW5nIGZpbGUgc3lzdGVtcy4uLiIKCWlmIFsgLW4gIiRVU0VfUkFJRCIg XTsgdGhlbgoJCWxvY2FsIG1pc3Npbmc9CgkJbG9jYWwgbnVtPSQjCgkJaWYgWyAkIyAtZXEgMSBd OyB0aGVuCgkJCW1pc3Npbmc9Im1pc3NpbmciCgkJCW51bT0yCgkJZmkKCQkjIHdlIG9ubHkgdXNl IHJhaWQgbGV2ZWwgMSBmb3IgYm9vdCBkZXZpY2VzCgkJbWRhZG0gLS1jcmVhdGUgL2Rldi9tZDAg LS1sZXZlbD0xIC0tcmFpZC1kZXZpY2VzPSRudW0gXAoJCQktLW1ldGFkYXRhPTAuOTAgLS1xdWll dCAtLXJ1biAkQCAkbWlzc2luZyB8fCByZXR1cm4gMQoJCWJvb3RkZXY9L2Rldi9tZDAKCWZpCglt a2ZzLiRCT09URlMgLXEgJGJvb3RkZXYKCUJPT1RfREVWPSIkYm9vdGRldiIKfQoKIyAkMSA9IGlu ZGV4CiMgJDIgPSBwYXJ0aXRpb24gdHlwZQojICQzLi4uID0gZGlzayBkZXZpY2VzCmZpbmRfbnRo X25vbl9ib290X3BhcnRzKCkgewoJbG9jYWwgaWR4PSQxCglsb2NhbCBpZD0kMgoJbG9jYWwgZGlz az0KCXNoaWZ0CglzaGlmdAoJZm9yIGRpc2sgaW4gJEA7IGRvCgkJc2ZkaXNrIC1kICRkaXNrIHwg Z3JlcCAtdiBib290YWJsZSBcCgkJCXwgYXdrICIvSWQ9JGlkLyB7IGkrKzsgaWYgKGk9PSRpZHgp IHByaW50IFwkMSB9IgoJZG9uZQp9CgpzZXR1cF9ub25fYm9vdF9yYWlkX2RldigpIHsKCWxvY2Fs IG1kX2Rldj0kMQoJbG9jYWwgaWR4PSR7bWRfZGV2Iy9kZXYvbWR9CglzaGlmdAoJbG9jYWwgbGV2 ZWw9MQoJbG9jYWwgbWlzc2luZz0KCWxvY2FsIHJhaWRfcGFydHM9JChmaW5kX250aF9ub25fYm9v dF9wYXJ0cyAkaWR4ICJmZCIgJEApCglzZXQgLS0gJHJhaWRfcGFydHMKCSMgaG93IG1hbnkgZGlz a3MgZG8gd2UgaGF2ZT8KCWNhc2UgJCMgaW4KCQkwKSBlY2hvICJObyBSYWlkIHBhcnRpdGlvbnMg Zm91bmQiID4mMjsgcmV0dXJuIDE7OwoJCTEpIGxldmVsPTE7IG1pc3Npbmc9Im1pc3NpbmciOyBu dW09Mjs7CgkJMikgbGV2ZWw9MTsgbWlzc2luZz0gIDsgbnVtPTI7OwoJCSopIGxldmVsPTU7IG1p c3Npbmc9ICA7IG51bT0kIzs7Cgllc2FjCgltZGFkbSAtLWNyZWF0ZSAvZGV2L21kJGlkeCAtLWxl dmVsPSRsZXZlbCAtLXJhaWQtZGV2aWNlcz0kbnVtIFwKCQktLXF1aWV0IC0tcnVuICRAICRtaXNz aW5nIHx8IHJldHVybiAxCn0KCiMgc2V0dXAgZGV2aWNlIGZvciBsdm0sIGNyZWF0ZSByYWlkIGFy cmF5IGlmIG5lZWRlZApzZXR1cF9sdm1fdm9sdW1lX2dyb3VwKCkgewoJbG9jYWwgdmduYW1lPSIk MSIKCXNoaWZ0Cglsb2NhbCBsdm1kZXY9CgoJaWYgWyAtbiAiJFVTRV9SQUlEIiBdOyB0aGVuCgkJ c2V0dXBfbm9uX2Jvb3RfcmFpZF9kZXYgL2Rldi9tZDEgJEAgfHwgcmV0dXJuIDEKCQlsdm1kZXY9 L2Rldi9tZDEKCWVsc2UKCQlsdm1kZXY9JChmaW5kX2x2bV9wYXJ0aXRpb24gJDEpCglmaQoKCSMg YmUgcXVpZXQgb24gc3VjY2VzcwoJbG9jYWwgZXJybXNnPSQoZGQgaWY9L2Rldi96ZXJvIG9mPSRs dm1kZXYgYnM9MWsgY291bnQ9MSAyPiYxKSBcCgkJfHwgZWNobyAiJGVycm1zZyIKCXB2Y3JlYXRl IC0tcXVpZXQgJGx2bWRldiBcCgkJJiYgdmdjcmVhdGUgLS1xdWlldCAkdmduYW1lICRsdm1kZXYg Pi9kZXYvbnVsbAp9CgojIHNldCB1cCBzd2FwIG9uIGdpdmVuIGRldmljZShzKQpzZXR1cF9zd2Fw X2RldigpIHsKCWxvY2FsIHN3YXBfZGV2PQoJc2VkIC1pIC1lICcvc3dhcC9kJyAvZXRjL2ZzdGFi Cglmb3Igc3dhcF9kZXYgaW4gIiRAIjsgZG8KCQlta3N3YXAgJHN3YXBfZGV2ID4vZGV2L251bGwK CQllY2hvIC1lICIkc3dhcF9kZXZcdHN3YXBcdFx0c3dhcFx0ZGVmYXVsdHMgMCAwIiA+PiAvZXRj L2ZzdGFiCglkb25lCglTV0FQX0RFVklDRT0iJCh1dWlkX29yX2RldmljZSAkc3dhcF9kZXYpIgoJ c3dhcG9uIC1hCglyYy11cGRhdGUgLS1xdWlldCBhZGQgc3dhcCBib290Cn0KCiMgc2V0dXAgYW5k IGVuYWJsZSBzd2FwIG9uIGdpdmVuIHZvbHVtZWdyb3VwIGlmIG5lZWRlZApzZXR1cF9sdm1fc3dh cCgpIHsKCWxvY2FsIHZnbmFtZT0iJDEiCglsb2NhbCBzd2FwbmFtZT1sdl9zd2FwCglpZiBbIC16 ICIkU1dBUF9TSVpFIiBdIHx8IFsgIiRTV0FQX1NJWkUiIC1lcSAwIF07IHRoZW4KCQlyZXR1cm4K CWZpCglsdmNyZWF0ZSAtLXF1aWV0IC1uICRzd2FwbmFtZSAtTCAke1NXQVBfU0laRX1NQiAkdmdu YW1lCglzZXR1cF9zd2FwX2RldiAvZGV2LyR2Z25hbWUvJHN3YXBuYW1lCn0KCiMgaWYgL3ZhciBp cyBtb3VudGVkLCBtb3ZlIG91dCBkYXRhIGFuZCB1bW91bnQgaXQKcmVzZXRfdmFyKCkgewoJWyAt eiAiJChmaW5kX21vdW50X2RldiAvdmFyKSIgXSAmJiByZXR1cm4gMAoJbWtkaXIgLy52YXIKCW12 IC92YXIvKiAvLnZhci8gMj4vZGV2L251bGwKCXVtb3VudCAvdmFyICYmIAlybSAtcmYgL3ZhciAm JiBtdiAvLnZhciAvdmFyICYmIHJtIC1yZiAvdmFyL2xvc3QrZm91bmQKfQoKIyBzZXQgdXAgL3Zh ciBvbiBnaXZlbiBkZXZpY2UKc2V0dXBfdmFyKCkgewoJbG9jYWwgdmFyX2Rldj0iJDEiCglsb2Nh bCB2YXJmcz0ke1ZBUkZTfQoJZWNobyAiQ3JlYXRpbmcgZmlsZSBzeXN0ZW1zLi4uIgoJbWtmcy4k dmFyZnMgJHZhcl9kZXYgPi9kZXYvbnVsbCB8fCByZXR1cm4gMQoJc2VkIC1pIC1lICcvW1s6c3Bh Y2U6XV1cL3ZhcltbOnNwYWNlOl1dL2QnIC9ldGMvZnN0YWIKCWVjaG8gLWUgIiR7dmFyX2Rldn1c dC92YXJcdFx0JHt2YXJmc31cdGRlZmF1bHRzIDEgMiIgPj4gL2V0Yy9mc3RhYgoKCW12IC92YXIg Ly52YXIKCW1rZGlyIC92YXIKCW1vdW50IC92YXIKCW12IC8udmFyLyogL3Zhci8KCXJtZGlyIC8u dmFyCgoJL2V0Yy9pbml0LmQvc3lzbG9nIC0tcXVpZXQgcmVzdGFydAoJc2V0dXBfbWRhZG1fY29u Zgp9CgpzZXR1cF9tZGFkbV9jb25mKCkgewoJbG9jYWwgbW9kcz0gbW9kPQoJaWYgWyAtbiAiJFVT RV9SQUlEIiBdOyB0aGVuCgkJbWRhZG0gLS1kZXRhaWwgLS1zY2FuID4gL2V0Yy9tZGFkbS5jb25m CgkJcmMtdXBkYXRlIC0tcXVpZXQgYWRkIG1kYWRtLXJhaWQgYm9vdAoJCW1vZHM9JChhd2sgJy9e cmFpZC8ge3ByaW50ICQxfScgL3Byb2MvbW9kdWxlcykKCQlmb3IgbW9kIGluICRtb2RzOyBkbwoJ CQlpZiAhIGdyZXAgLXEgIl4kbW9kIiAvZXRjL21vZHVsZXM7IHRoZW4KCQkJCWVjaG8gJG1vZCA+ PiAvZXRjL21vZHVsZXMKCQkJZmkKCQlkb25lCglmaQp9CgoKCmZpbmRfbW91bnRfcG9pbnQoKSB7 Cglsb2NhbCBkZXZpY2U9JDEKCWF3ayAiXCQxID09IFwiJGRldmljZVwiIHtwcmludCBcJDJ9IiAv cHJvYy9tb3VudHMgfCB0YWlsIC1uIDEKfQoKZmluZF9tYXBwZXJfZGlzaygpIHsKCWNyeXB0c2V0 dXAgc3RhdHVzICQxfGdyZXAgZGV2aWNlfGF3ayAneyBwcmludCAkMiB9Jwp9CgpmaW5kX2x1a3Nf dmcoKSB7CglpZiBpc19sdWtzX3B2OyB0aGVuCgkJcHZzIC0tbm9oZWFkaW5ncyAvZGV2L21hcHBl ci8kQ1JZUFRETSB8YXdrICd7IHByaW50ICQyIH0nCglmaQp9Cgppc19sdWtzX3B2KCkgewoJcHZz IC0tbm9oZWFkaW5nc3xhd2sgJ3sgcHJpbnQgJDEgfSd8IGdyZXAgLXcgJENSWVBURE0gJj4vZGV2 L251bGwKfQoKY29udmVydF92Z190b19tYXBwZXIoKSB7Cglsb2NhbCBtYXBwZXI9JHsxIyMqL30K CWxvY2FsIHZnPSQoZmluZF9sdWtzX3ZnKQoJZWNobyAiL2Rldi9tYXBwZXIvJHZnLSRtYXBwZXIi Cn0KCmNvbnZlcnRfbHZfdG9fZGV2aWNlKCkgewoJbG9jYWwgbHY9JHsxIyMqL30JbG9jYWwgdmc9 JChmaW5kX2x1a3NfdmcpCglpZiBbIC1uICIkKGZpbmRfbW91bnRfcG9pbnQgL2Rldi8kdmcvJGx2 KSIgXTsgdGhlbgogICAgICAgIGVjaG8gIi9kZXYvJHZnLyRsdiIKCWVsaWYgWyAtbiAiJChmaW5k X21vdW50X3BvaW50IC9kZXYvbWFwcGVyLyR2Zy0kbHYpIiBdOyB0aGVuCgkJZWNobyAiL2Rldi9t YXBwZXIvJHZnLSRsdiIKCWZpCn0KCnNldHVwX2NyeXB0dGFiKCkgewoJbG9jYWwga2V5c2Rpcj0k e2tleXNkaXI6LSRtbnQvZXRjL2x1a3Mta2V5c30KCWxvY2FsIGtleWZpbGU9IGxvY2FsIGFuc3dl cj0gbG9jYWwgaT0KCWxvY2FsIGNvbmZpZz0kbW50L2V0Yy9jb25mLmQvZG1jcnlwdAoKCWlmIFsg LWYgIiRtbnQiL2V0Yy9jcnlwdHRhYiBdOyB0aGVuCiAgICAJCW12ICIkbW50Ii9ldGMvY3J5cHR0 YWIgIiRtbnQiL2V0Yy9jcnlwdHRhYi5vbGQKICAgIGZpCgoJaWYgWyAkKGVjaG8gJERNTElTVHx3 YyAtdykgLWd0IDEgXTsgdGhlbgoJCXJlYWQgLXAgIlNldHVwIExVS1Mga2V5ZmlsZXMgZm9yIGF1 dG9tYXRpYyBtb3VudGluZz8gW3kvTl06ICIgYW5zd2VyCgkJY2FzZSAiJGFuc3dlciIgaW4KCSAg ICAgICAgeSp8WSopIG1rZGlyIC1wICRtbnQvZXRjL2NvbmYuZDsgY3AgJHtjb25maWcjJG1udH0g JGNvbmZpZwoJCQkJbG4gLXMgL2V0Yy9pbml0LmQvZG1jcnlwdCAkbW50L2V0Yy9ydW5sZXZlbHMv Ym9vdC9kbWNyeXB0IDI+L2Rldi9udWxsCgkJCQlyZWFkIC1wICJFbnRlciBkaXJlY3RvcnkgZm9y IGtleXMgWyAke2tleXNkaXIjJG1udH0gXTogIiBhbnN3ZXIKCQkJCXVudGlsIFsgLWQgIiRrZXlz ZGlyIiBdOyBkbwoJCQkJCWlmIFsgLW4gIiRhbnN3ZXIiIF07IHRoZW4ga2V5c2Rpcj0kbW50JGFu c3dlcjsgZmkKCQkJCQlta2RpciAtcCAka2V5c2RpcgoJCQkJZG9uZTsgZWNobyAiQ3JlYXRpbmcg JGtleXNkaXIiCgkJCQlmb3IgaSBpbiAkRE1MSVNUOyBkbwoJCQkJCWlmIFsgIiRpIiAhPSAiJENS WVBURE0iIF07IHRoZW4KCSAgICAgICAgICAgICAgICAJcmVhZCAtcCAiQ3JlYXRlIGtleSBmb3Ig L2Rldi9tYXBwZXIvJGkgW3kvTl0/IDogIiBhbnN3ZXIKICAgICAgICAgICAgICAJCQljYXNlICIk YW5zd2VyIiBpbgogICAgICAgICAgICAgICAJCSAgICAgICB5KnxZKikgaWYgISBjcnlwdHNldHVw IGx1a3NEdW1wICQoZmluZF9tYXBwZXJfZGlzayAkaSl8Z3JlcCAiOiBESVNBQkxFRCIgMT4vZGV2 L251bGw7IHRoZW4KCQkJCQkJCQllY2hvICJBbGwga2V5c2xvdHMgZnVsbDogQ2hvb3NlIHNsb3Qg dG8gd2lwZT8gWzEtN106IgoJCQkJCQkJCXVudGlsIFsgJGFuc3dlciAtZ2UgMSAyPi9kZXYvbnVs bCBdICYmIFsgJGFuc3dlciAtbGUgNyAyPi9kZXYvbnVsbCBdOyBkbwoJCQkJCQkJCQllY2hvIC1l biAiXDAzM1sxOzMxbT4+PlwwMzNbMzdtOiBcMDMzWzBtIjsgcmVhZCBhbnN3ZXIKCQkJCQkJCQkJ ZWNobyAtZW4gIlwwMzNbMUFcMDMzW0siICNtb3ZlIHRoZSBjdXJzb3IgJiBjbGVhciB0aGUgbGlu ZQoJCQkJCQkJCWRvbmUKCQkJCQkJCQljcnlwdHNldHVwIGx1a3NLaWxsU2xvdCAkKGZpbmRfbWFw cGVyX2Rpc2sgJGkpICRhbnN3ZXIKCQkJCQkJCQlmaQoJCQkJCQkJCWRkIGlmPS9kZXYvdXJhbmRv bSBvZj0ka2V5c2Rpci8kaSBicz0xMDI0IGNvdW50PTQKCQkJCQkJCQljcnlwdHNldHVwIGx1a3NB ZGRLZXkgJChmaW5kX21hcHBlcl9kaXNrICRpKSAka2V5c2Rpci8kaQoJCQkJCQkJCWVjaG8gLWUg IlxuIyMgU2V0dGluZ3MgZnJvbSAvc2Jpbi9zZXR1cC1kaXNrIiA+PiAkY29uZmlnCgkJCQkJCQkJ ZWNobyAidGFyZ2V0PSRpIiA+PiAkY29uZmlnCgkJCQkJCQkJZWNobyAic291cmNlPSQoZmluZF9t YXBwZXJfZGlzayAkaSkiID4+ICRjb25maWcKCQkJCQkJCQllY2hvICJrZXk9JHtrZXlzZGlyIyRt bnR9LyRpIiA+PiAkY29uZmlnCgkJCQkJCWVzYWMKCQkJCQlmaQogICAgICAgCQkJZG9uZQoJCWNo bW9kIC1SIDQwMCAka2V5c2RpcjtjaG93biAtUiByb290OnJvb3QgJGtleXNkaXIKCQllc2FjCglm aQoKCWZvciBpIGluICRETUxJU1Q7IGRvCgkJaWYgWyAtZiAiJGtleXNkaXIvJGkiIF07dGhlbgoJ CQlrZXlmaWxlPSIka2V5c2Rpci8kaSIKCQllbHNlCgkJCWtleWZpbGU9Im5vbmUiCgkJZmkKCQkj IGNyeXB0dGFiIG5lZWRzIHRoZSBVVUlEIG9mIHRoZSBwaHlzaWNhbCBkZXZpY2UKICAgICAJZWNo byAiIyAkaSBpcyBvbiAkKGZpbmRfbWFwcGVyX2Rpc2sgJGkpIiA+PiAkbW50L2V0Yy9jcnlwdHRh YgoJCWVjaG8gIiRpICQoX2Jsa2lkICQoZmluZF9tYXBwZXJfZGlzayAkaSl8YXdrICd7IHByaW50 ICQyIH0nKSAka2V5ZmlsZSBsdWtzIiA+PiAkbW50L2V0Yy9jcnlwdHRhYgogICAgZG9uZQp9CgoK ZGF0YV9vbmx5X2Rpc2tfaW5zdGFsbF9sdm0oKSB7Cglsb2NhbCBkaXNrZGV2PQoJbG9jYWwgdmdu YW1lPXZnMAoJbG9jYWwgdmFyX2Rldj0vZGV2LyR2Z25hbWUvbHZfdmFyCglsb2NhbCBsdm1fcGFy dF90eXBlPSI4ZSIKCWxvY2FsIHBhcnRfdHlwZT0kbHZtX3BhcnRfdHlwZQoJbG9jYWwgc2l6ZT0K Cglpbml0X3Byb2dzIHx8IHJldHVybiAxCgljb25maXJtX2VyYXNlICRAIHx8IHJldHVybiAxCgoJ aWYgWyAiJFVTRV9SQUlEIiBdOyB0aGVuCgkJIyB0aGUgcGFyaXRpdGlvbiB0eXBlIGZvciByYWlk IGlzICJmZCIKCQlwYXJ0X3R5cGU9ImZkIgoJCXN0b3BfYWxsX3JhaWQKCWZpCgoJZm9yIGRpc2tk ZXYgaW4gIiRAIjsgZG8KCQlzZXR1cF9wYXJ0aXRpb25zICRkaXNrZGV2ICIkc2l6ZSwkcGFydF90 eXBlIiB8fCByZXR1cm4gMQoJZG9uZQoKCXNldHVwX2x2bV92b2x1bWVfZ3JvdXAgJHZnbmFtZSAk QCB8fCByZXR1cm4gMQoJc2V0dXBfbHZtX3N3YXAgJHZnbmFtZQoJbHZjcmVhdGUgLS1xdWlldCAt biAke3Zhcl9kZXYjIyovfSAtbCAxMDAlRlJFRSAkdmduYW1lCglzZXR1cF9tZGFkbV9jb25mCgly Yy11cGRhdGUgYWRkIGx2bSBib290CglzZXR1cF92YXIgJHZhcl9kZXYKfQoKZGF0YV9vbmx5X2Rp c2tfaW5zdGFsbCgpIHsKCWxvY2FsIGRpc2tkZXY9Cglsb2NhbCB2YXJfZGV2PQoJbG9jYWwgdmFy X3BhcnRfdHlwZT0iODMiCglsb2NhbCBzd2FwX3BhcnRfdHlwZT04MgoJbG9jYWwgc2l6ZT0KCWxv Y2FsIHN3YXBfZGV2PSB2YXJfZGV2PQoKCWluaXRfcHJvZ3MgfHwgcmV0dXJuIDEKCWNvbmZpcm1f ZXJhc2UgJEAgfHwgcmV0dXJuIDEKCglpZiBbICIkVVNFX1JBSUQiIF07IHRoZW4KCQl2YXJfcGFy dF90eXBlPSJmZCIKCQlzd2FwX3BhcnRfdHlwZT0iZmQiCgkJc3RvcF9hbGxfcmFpZAoJZmkKCglm b3IgZGlza2RldiBpbiAiJEAiOyBkbwoJCXNldHVwX3BhcnRpdGlvbnMgJGRpc2tkZXYgXAoJCQki JFNXQVBfU0laRSwkc3dhcF9wYXJ0X3R5cGUiIFwKCQkJIiRzaXplLCR2YXJfcGFydF90eXBlIiB8 fCByZXR1cm4gMQoJZG9uZQoKCWlmIFsgIiRVU0VfUkFJRCIgXTsgdGhlbgoJCVsgJFNXQVBfU0la RSAtZ3QgMCBdICYmIHNldHVwX25vbl9ib290X3JhaWRfZGV2IC9kZXYvbWQxICRACgkJc2V0dXBf bm9uX2Jvb3RfcmFpZF9kZXYgL2Rldi9tZDIgJEAgfHwgcmV0dXJuIDEKCQlzd2FwX2Rldj0vZGV2 L21kMQoJCXZhcl9kZXY9L2Rldi9tZDIKCWVsc2UKCQlzd2FwX2Rldj0kKGZpbmRfbnRoX25vbl9i b290X3BhcnRzIDEgODIgJEApCgkJdmFyX2Rldj0kKGZpbmRfbnRoX25vbl9ib290X3BhcnRzIDEg ODMgJEApCglmaQoJWyAkU1dBUF9TSVpFIC1ndCAwIF0gJiYgc2V0dXBfc3dhcF9kZXYgJHN3YXBf ZGV2CglzZXR1cF92YXIgJHZhcl9kZXYKfQoKIyBzZXR1cApzZXR1cF9yb290KCkgewoJbG9jYWwg cm9vdF9kZXY9IiQxIiBib290X2Rldj0iJDIiCglta2ZzLiRST09URlMgJG1rZnNfYXJncyAiJHJv b3RfZGV2IgoJbWtkaXIgLXAgIiRTWVNST09UIgoJbW91bnQgLXQgJFJPT1RGUyAkcm9vdF9kZXYg IiRTWVNST09UIiB8fCByZXR1cm4gMQoJaWYgWyAtbiAiJGJvb3RfZGV2IiBdOyB0aGVuCgkJbWtk aXIgLXAgIiRTWVNST09UIi9ib290CgkJbW91bnQgLXQgJEJPT1RGUyAkYm9vdF9kZXYgIiRTWVNS T09UIi9ib290IHx8IHJldHVybiAxCglmaQoKCXNldHVwX21kYWRtX2NvbmYKCWluc3RhbGxfbW91 bnRlZF9yb290ICIkU1lTUk9PVCIgfHwgcmV0dXJuIDEKCXVubW91bnRfcGFydGl0aW9ucyAiJFNZ U1JPT1QiCglzd2Fwb2ZmIC1hCgoJZWNobyAiIgoJZWNobyAiSW5zdGFsbGF0aW9uIGlzIGNvbXBs ZXRlLiBQbGVhc2UgcmVib290LiIKfQoKbmF0aXZlX2Rpc2tfaW5zdGFsbF9sdm0oKSB7Cglsb2Nh bCBkaXNrZGV2PSB2Z25hbWU9dmcwCglsb2NhbCBsdm1fcGFydF90eXBlPSI4ZSIKCWxvY2FsIGJv b3RfcGFydF90eXBlPSI4MyIKCWxvY2FsIGJvb3Rfc2l6ZT0ke0JPT1RfU0laRTotMTAwfQoJbG9j YWwgbHZtX3NpemU9Cglsb2NhbCByb290X2Rldj0vZGV2LyR2Z25hbWUvbHZfcm9vdAoKCWluaXRf cHJvZ3MgfHwgcmV0dXJuIDEKCWNvbmZpcm1fZXJhc2UgJEAgfHwgcmV0dXJuIDEKCglpZiBbIC1u ICIkVVNFX1JBSUQiIF07IHRoZW4KCQlib290X3BhcnRfdHlwZT0iZmQiCgkJbHZtX3BhcnRfdHlw ZT0iZmQiCgkJc3RvcF9hbGxfcmFpZAoJZmkKCWZvciBkaXNrZGV2IGluICIkQCI7IGRvCgkJc2V0 dXBfcGFydGl0aW9ucyAkZGlza2RldiBcCgkJCSIkYm9vdF9zaXplLCRib290X3BhcnRfdHlwZSwq IiBcCgkJCSIkbHZtX3NpemUsJGx2bV9wYXJ0X3R5cGUiIHx8IHJldHVybiAxCglkb25lCgoJIyB3 aWxsIGZpbmQgQk9PVF9ERVYgZm9yIHVzCglzZXR1cF9ib290X2RldiAkQAoKCXNldHVwX2x2bV92 b2x1bWVfZ3JvdXAgJHZnbmFtZSAkQCB8fCByZXR1cm4gMQoJc2V0dXBfbHZtX3N3YXAgJHZnbmFt ZQoJbHZjcmVhdGUgLS1xdWlldCAtbiAke3Jvb3RfZGV2IyMqL30gLWwgMTAwJUZSRUUgJHZnbmFt ZQoJcmMtdXBkYXRlIGFkZCBsdm0gYm9vdAoJc2V0dXBfcm9vdCAkcm9vdF9kZXYgJEJPT1RfREVW Cn0KCm5hdGl2ZV9kaXNrX2luc3RhbGwoKSB7Cglsb2NhbCByb290X3BhcnRfdHlwZT0iODMiIHN3 YXBfcGFydF90eXBlPSI4MiIgYm9vdF9wYXJ0X3R5cGU9IjgzIgoJbG9jYWwgYm9vdF9zaXplPSR7 Qk9PVF9TSVpFOi0xMDB9Cglsb2NhbCBzd2FwX3NpemU9JHtTV0FQX1NJWkV9Cglsb2NhbCByb290 X3NpemU9Cglsb2NhbCByb290X2Rldj0gYm9vdF9kZXY9IHN3YXBfZGV2PQoKCWluaXRfcHJvZ3Mg fHwgcmV0dXJuIDEKCWNvbmZpcm1fZXJhc2UgJEAgfHwgcmV0dXJuIDEKCglpZiBbIC1uICIkVVNF X1JBSUQiIF07IHRoZW4KCQlib290X3BhcnRfdHlwZT0iZmQiCgkJcm9vdF9wYXJ0X3R5cGU9ImZk IgoJCXN3YXBfcGFydF90eXBlPSJmZCIKCQlzdG9wX2FsbF9yYWlkCglmaQoJZm9yIGRpc2tkZXYg aW4gIiRAIjsgZG8KCQlzZXR1cF9wYXJ0aXRpb25zICRkaXNrZGV2IFwKCQkJIiRib290X3NpemUs JGJvb3RfcGFydF90eXBlLCoiIFwKCQkJIiRzd2FwX3NpemUsJHN3YXBfcGFydF90eXBlIiBcCgkJ CSIkcm9vdF9zaXplLCRyb290X3BhcnRfdHlwZSIgXAoJCQl8fCByZXR1cm4gMQoJZG9uZQoKCSMg d2lsbCBmaW5kIEJPT1RfREVWIGZvciB1cwoJc2V0dXBfYm9vdF9kZXYgJEAKCglpZiBbICIkVVNF X1JBSUQiIF07IHRoZW4KCQlbICRTV0FQX1NJWkUgLWd0IDAgXSAmJiBzZXR1cF9ub25fYm9vdF9y YWlkX2RldiAvZGV2L21kMSAkQAoJCXNldHVwX25vbl9ib290X3JhaWRfZGV2IC9kZXYvbWQyICRA IHx8IHJldHVybiAxCgkJc3dhcF9kZXY9L2Rldi9tZDEKCQlyb290X2Rldj0vZGV2L21kMgoJZWxz ZQoJCXN3YXBfZGV2PSQoZmluZF9udGhfbm9uX2Jvb3RfcGFydHMgMSA4MiAkQCkKCQlyb290X2Rl dj0kKGZpbmRfbnRoX25vbl9ib290X3BhcnRzIDEgODMgJEApCglmaQoJWyAkU1dBUF9TSVpFIC1n dCAwIF0gJiYgc2V0dXBfc3dhcF9kZXYgJHN3YXBfZGV2CglzZXR1cF9yb290ICRyb290X2RldiAk Qk9PVF9ERVYKfQoKZGlza3NlbGVjdF9oZWxwKCkgewoJY2F0IDw8X19FT0ZfXwoKVGhlIGRpc2sg eW91IHNlbGVjdCBjYW4gYmUgdXNlZCBmb3IgYSB0cmFkaXRpb25hbCBkaXNrIGluc3RhbGwgb3Ig Zm9yIGEKZGF0YS1vbmx5IGluc3RhbGwuCgpUaGUgZGlzayB3aWxsIGJlIGVyYXNlZC4KCkVudGVy ICdub25lJyBpZiB5b3Ugd2FudCB0byBydW4gZGlza2xlc3MuCgpfX0VPRl9fCn0KCmRpc2ttb2Rl X2hlbHAoKSB7CgljYXQgPDxfX0VPRl9fCgpZb3UgY2FuIHNlbGVjdCBiZXR3ZWVuICdzeXMnIG9y ICdkYXRhJy4KCnN5czoKICBUaGlzIG1vZGUgaXMgYSB0cmFkaXRpb25hbCBkaXNrIGluc3RhbGwu IFRoZSBmb2xsb3dpbmcgcGFydGl0aW9ucyB3aWxsIGJlCiAgY3JlYXRlZCBvbiB0aGUgZGlzazog L2Jvb3QsIC8gKGZpbGVzeXN0ZW0gcm9vdCkgYW5kIHN3YXAuCgogIFRoaXMgbW9kZSBtYXkgYmUg dXNlZCBmb3IgZGV2ZWxvcG1lbnQgYm94ZXMsIGRlc2t0b3BzLCB2aXJ0dWFsIHNlcnZlcnMsIGV0 Yy4KCmRhdGE6CiAgVGhpcyBtb2RlIHVzZXMgeW91ciBkaXNrKHMpIGZvciBkYXRhIHN0b3JhZ2Us IG5vdCBmb3IgdGhlIG9wZXJhdGluZyBzeXN0ZW0uCiAgVGhlIHN5c3RlbSBpdHNlbGYgd2lsbCBy dW4gZnJvbSB0bXBmcyAoUkFNKS4KCiAgVXNlIHRoaXMgbW9kZSBpZiB5b3Ugb25seSB3YW50IHRv IHVzZSB0aGUgZGlzayhzKSBmb3IgYSBtYWlsc3Bvb2wsIGRhdGFiYXNlcywKICBsb2dzLCBldGMu CgpfX0VPRl9fCn0KCiMgYXNrIGZvciBhIHJvb3Qgb3IgZGF0YSBkaXNrCiMgcmV0dXJucyBhbnN3 ZXIgaW4gZ2xvYmFsIHZhcmlhYmxlICRhbnN3ZXIKYXNrX2Rpc2soKSB7Cglsb2NhbCBwcm9tcHQ9 IiQxIgoJbG9jYWwgaGVscF9mdW5jPSIkMiIKCWxvY2FsIGk9CglzaGlmdCAyCglhbnN3ZXI9Cgls b2NhbCBkZWZhdWx0X2Rpc2s9JHtERUZBVUxUX0RJU0s6LSQxfQoKCXdoaWxlICEgYWxsX2luX2xp c3QgIiRhbnN3ZXIiICRAICJub25lIiAiYWJvcnQiOyBkbwoJCWVjaG8gIkF2YWlsYWJsZSBkaXNr cyBhcmU6IgoJCXNob3dfZGlza19pbmZvICIkQCIKCQllY2hvbiAiJHByb21wdCBbJGRlZmF1bHRf ZGlza10gIgoJCWRlZmF1bHRfcmVhZCBhbnN3ZXIgJGRlZmF1bHRfZGlzawoJCWNhc2UgIiRhbnN3 ZXIiIGluCgkJCSdhYm9ydCcpIGV4aXQgMDs7CgkJCSdub25lJykgcmV0dXJuIDA7OwoJCQknPycp ICRoZWxwX2Z1bmM7OwoJCQkqKSBmb3IgaSBpbiAkYW5zd2VyOyBkbwoJCQkJaWYgISBbIC1iICIv ZGV2LyRpIiBdOyB0aGVuCgkJCQkJZWNobyAiL2Rldi8kaSBpcyBub3QgYSBibG9jayBkZXZpY2Ui ID4mMgoJCQkJCWFuc3dlcj0KCQkJCSAgIGZpCgkJCWRvbmU7OwoJCWVzYWMKCWRvbmUKfQoKdXNh Z2UoKSB7CgljYXQgPDxfX0VPRl9fCnVzYWdlOiBzZXR1cC1kaXNrIFstaExxcnZdIFstayBrZXJu ZWxmbGF2b3JdIFstbSBNT0RFXSBbLW8gYXBrb3ZsXSBbLXMgU1dBUFNJWkVdCgkJICBbTU9VTlRQ T0lOVCB8IERJU0tERVYuLi5dCgpJbnN0YWxsIGFscGluZSBvbiBoYXJkZGlzay4KCklmIE1PVU5U UE9JTlQgaXMgc3BlY2lmaWVkLCB0aGVuIGRvIGEgdHJhZGl0aW9uYWwgZGlzayBpbnN0YWxsIHdp dGggTU9VTlRQT0lOVAphcyByb290LgoKSWYgRElTS0RFViBpcyBzcGVjaWZpZWQsIHRoZW4gdXNl IHRoZSBzcGVjaWZpZWQgZGlzayhzKSB3aXRob3V0IGFza2luZy4gSWYKbXVsdGlwbGUgZGlza3Mg YXJlIHNwZWNpZmllZCB0aGVuIHNldCB0aGVtIHVwIGluIGEgUkFJRCBhcnJheS4gSWYgdGhlcmUg YXJlCm1vZGUgdGhhbiAyIGRpc2tzLCB0aGVuIHVzZSByYWlkIGxldmVsIDUgaW5zdGVhZCBvZiBy YWlkIGxldmVsIDEuCgpvcHRpb25zOgogLWggIFNob3cgdGhpcyBoZWxwCiAtbSAgVXNlIGRpc2sg Zm9yIE1PREUgd2l0aG91dCBhc2tpbmcsIHdoZXJlIE1PREUgaXMgZWl0aGVyICdkYXRhJyBvciAn c3lzJwogLW8gIFJlc3RvcmUgc3lzdGVtIGZyb20gZ2l2ZW4gYXBrb3ZsIGZpbGUKIC1rICBVc2Ug a2VybmVsZmxhdm9yIGluc3RlYWQgb2YgJEtFUk5FTF9GTEFWT1IKIC1MICBVc2UgTFZNIHRvIG1h bmFnZSBwYXJ0aXRpb25zCiAtcSAgRXhpdCBxdWlldGx5IGlmIG5vIGRpc2tzIGFyZSBmb3VuZAog LXIgIEVuYWJsZSBzb2Z0d2FyZSByYWlkMSB3aXRoIHNpbmdsZSBkaXNrCiAtcyAgVXNlIFNXQVBT SVpFIE1CIGluc3RlYWQgb2YgYXV0b2RldGVjdGluZyBzd2FwIHNpemUgKFVzZSAwIHRvIGRpc2Fi bGUgc3dhcCkKIC1FICBVc2UgRW5jcnlwdGVkIExVS1MgZGV2aWNlcyAoTFZNIG9yIFN0YW5kYXJk IFBhcnRpdGlvbnMgYXJlIHN1cHBvcnRlZCkKIC12ICBCZSBtb3JlIHZlcmJvc2UgYWJvdXQgd2hh dCBpcyBoYXBwZW5pbmcKCl9fRU9GX18KCWV4aXQgMQp9CgprdmVyPSQodW5hbWUgLXIpCmNhc2Ug JGt2ZXIgaW4KICAgICAgICAqLXJjWzAtOV0qKSBLRVJORUxfRkxBVk9SPXZhbmlsbGE7OwogICAg ICAgICotW2Etel0qKSBLRVJORUxfRkxBVk9SPSR7a3ZlciMjKi19OzsKICAgICAgICAqKSBLRVJO RUxfRkxBVk9SPXZhbmlsbGE7Owplc2FjCgpESVNLX01PREU9ClVTRV9MVk09CiMgUGFyc2UgYXJn cwp3aGlsZSBnZXRvcHRzICJoazpMbTpvOnFyczp2RSIgb3B0OyBkbwoJY2FzZSAkb3B0IGluCgkJ bSkgRElTS19NT0RFPSIkT1BUQVJHIjs7CgkJaykgS0VSTkVMX0ZMQVZPUj0iJE9QVEFSRyI7OwoJ CUwpIFVTRV9MVk09Il9sdm0iOzsKCQlvKSBBUEtPVkw9IiRPUFRBUkciOzsKCQlxKSBRVUlFVD0x OzsKCQlyKSBVU0VfUkFJRD0xOzsKCQlzKSBTV0FQX1NJWkU9IiRPUFRBUkciOzsKCQl2KSBWRVJC T1NFPTE7OwoJCUUpIENSWVBUUk9PVD0xOzsKCQkqKSB1c2FnZTs7Cgllc2FjCmRvbmUKc2hpZnQg JCgoICRPUFRJTkQgLSAxKSkKCmlmIFsgLW4gIiRDUllQVFJPT1QiIF07IHRoZW4KCURNTElTVD0k KGRtc2V0dXAgbHMgLS10YXJnZXQgY3J5cHR8YXdrICd7IHByaW50ICQxIH0nKQoJaWYgWyAteiAi JERNTElTVCIgXTsgdGhlbiBlY2hvICJObyBDcnlwdCBEZXZpY2VzIGZvdW5kLiI7IGV4aXQgMTsg ZmkKCWVjaG8gLWVuICJcMDMzWzE7NG1cblNlbGVjdCBMVUtTIFJPT1QgRGV2aWNlIE1hcHBlcjpc MDMzWzBtXG5cblwwMzNbMW0kRE1MSVNUXDAzM1swbVxuXG4iCgoJdW50aWwgZWNobyAiJERNTElT VCIgfCBncmVwIC13ICIkQ1JZUFRETSIgMT4vZGV2L251bGw7IGRvCgkJZWNobyAtZW4gIlwwMzNb MTszMm0+Pj5cMDMzWzM3bTogXDAzM1swbSI7IHJlYWQgQ1JZUFRETTsKCQllY2hvIC1lbiAiXDAz M1sxQVwwMzNbSyIgI21vdmUgdGhlIGN1cnNvciAmIGNsZWFyIHRoZSBsaW5lCglkb25lCgoJQ1JZ UFRST09UPSQoZmluZF9tYXBwZXJfZGlzayAkQ1JZUFRETSkKCUNSWVBURElTSz0kKGVjaG8gJENS WVBUUk9PVCB8IHRyIC1kICdbOmRpZ2l0Ol0nKQoKCWFwayBhZGQgLS1xdWlldCBzZmRpc2sKICAg IGlmIFsgLXogJChmaW5kX2Jvb3RfcGFydGl0aW9uKSBdOyB0aGVuCgkJZWNobyAiTm8gQm9vdCBE ZXZpY2UgZGV0ZWN0ZWQuIjsgZXhpdCAxCiAgICBmaQogICAgaWYgISBncmVwICIkKGZpbmRfYm9v dF9wYXJ0aXRpb24pIiAvcHJvYy9tb3VudHMgMT4vZGV2L251bGw7IHRoZW4KCQllY2hvICJCb290 IERldmljZSAnJChmaW5kX2Jvb3RfcGFydGl0aW9uKScgaXMgbm90IG1vdW50ZWQuIjsgZXhpdCAx CiAgICBmaQoKCWlmIGlzX2x1a3NfcHY7IHRoZW4KCQlpZiBbIC16ICIkKGZpbmRfbHZtX3BhcnRp dGlvbiAkQ1JZUFRESVNLKSIgXTsgdGhlbgoJCQllY2hvICIkQ1JZUFRST09UIHBhcnRpdGlvbiBp cyBub3Qgc2V0IHRvIHR5cGUgOGUuIjsgZXhpdCAxCiAgICAgICAgZmkKICAgIGZpCgoJaWYgWyAh ICIkMSIgXTsgdGhlbgoJCWlmIGlzX2x1a3NfcHY7IHRoZW4KCQkJbHZzY2FuIHxhd2sgJ3sgcHJp bnQgJDIsJDMsJDQgfScgfHNlZCAicy8nLy9nIgoJCQllY2hvIC1lbiAiXG5TZWxlY3Qgcm9vdCBk ZXZpY2U/XG5cbiIJCQkJCSMgcm93cyB0byBjb2x1bW5zCgkJCXBhcnRfbGlzdD0kKGx2c2NhbiB8 YXdrICd7IHByaW50ICQyIH0nIHxzZWQgInM6L2Rldi8kKGZpbmRfbHVrc192ZykvOjpnInx0ciAi XG4iICIgIikKCQkJdW50aWwgWyAtbiAiJChmaW5kX21vdW50X3BvaW50ICQoY29udmVydF9sdl90 b19kZXZpY2UgJGFuc3dlcikpIiAmPi9kZXYvbnVsbCBdOyBkbwoJCQkJaWYgWyAtbiAiJGFuc3dl ciIgXTsgdGhlbiBlY2hvIC1lICJcMDMzWzE7MzFtJGFuc3dlcjogbm90IG1vdW50ZWQiO3NsZWVw IDE7ZWNobyAtZW4gIlwwMzNbMUFcMDMzW0siO2ZpCgkJCQllY2hvIC1lbiAiXDAzM1sxOzMybT4+ PlwwMzNbMzdtWyAkcGFydF9saXN0XTogXDAzM1swbSI7IHJlYWQgYW5zd2VyCgkJCQllY2hvIC1l biAiXDAzM1sxQVwwMzNbSyIKCQkJZG9uZQoJCQlTWVNST09UPSQoZmluZF9tb3VudF9wb2ludCAk KGNvbnZlcnRfbHZfdG9fZGV2aWNlICRhbnN3ZXIpKQoJCQlyYy11cGRhdGUgYWRkIGx2bSBib290 CgkJZWxzZQoJCQlTWVNST09UPSQoZmluZF9tb3VudF9wb2ludCAvZGV2L21hcHBlci8kQ1JZUFRE TSkKCQlmaQoJCWlmIFsgLW4gIiRTWVNST09UIiBdOyB0aGVuCgkJICAgIHNldCAkU1lTUk9PVAoJ CWVsc2UKICAgICAgICAJZWNobyAiRGV2aWNlICckQ1JZUFRETScgaXMgbm90IG1vdW50ZWQuIjsg ZXhpdCAxCgkJZmkKCWZpCgppZiBpc19sdWtzX3B2OyB0aGVuCgllY2hvICJyb290IGRldmljZSA9 ICQoY29udmVydF9sdl90b19kZXZpY2UgJGFuc3dlcikiCmZpCmVjaG8gImNyeXB0ZG0gPSAkQ1JZ UFRETSIKZWNobyAiY3J5cHRyb290ID0gJENSWVBUUk9PVCBtb3VudGVkQDogJDEiCmZpCgoKaWYg WyAtZCAiJDEiIF07IHRoZW4KCSMgaW5zdGFsbCB0byBnaXZlbiBtb3VudGVkIHJvb3QKCWFwayBh ZGQgLS1xdWlldCBzeXNsaW51eAoJaW5zdGFsbF9tb3VudGVkX3Jvb3QgIiR7MSUvfSIgXAoJCSYm IGVjaG8gIllvdSBtaWdodCBuZWVkIGZpeCB0aGUgTUJSIHRvIGJlIGFibGUgdG8gYm9vdCIgPiYy CglleGl0ICQ/CmZpCgpyZXNldF92YXIKc3dhcG9mZiAtYQoKIyBzdG9wIGFsbCB2b2x1bWUgZ3Jv dXBzIGluIHVzZQp2Z2NoYW5nZSAtLWlnbm9yZWxvY2tpbmdmYWlsdXJlIC1hIG4gPi9kZXYvbnVs bCAyPiYxCgppZiBbIC1uICIkVVNFX1JBSUQiIF07IHRoZW4KCXN0b3BfYWxsX3JhaWQKZmkKCmRp c2tzPSQoZmluZF9kaXNrcykKZGlza2RldnM9CgojIG5vIGRpc2tzIHNvIGxldHMgZXhpdCBxdWll dGx5LgppZiBbIC16ICIkZGlza3MiIF07IHRoZW4KCVsgLXogIiRRVUlFVCIgXSAmJiBlY2hvICJO byBkaXNrcyBmb3VuZC4iID4mMgoJZXhpdCAwCmZpCgppZiBbICQjIC1ndCAwIF07IHRoZW4KCSMg Y2hlY2sgdGhhdCB0aGV5IGFyZQoJZm9yIGkgaW4gIiRAIjsgZG8KCQlqPSQocmVhZGxpbmsgLWYg IiRpIiB8IHNlZCAnczpeL2Rldi86OjsgczovOiE6ZycpCgkJaWYgISBbIC1lICIvc3lzL2Jsb2Nr LyRqL2RldmljZSIgXTsgdGhlbgoJCQllY2hvICIkaSBpcyBub3QgYSBzdWl0YWJsZSBmb3IgcGFy dGl0aW9uaW5nIgoJCQlleGl0IDEKCQlmaQoJCWRpc2tkZXZzPSIkZGlza2RldnMgL2Rldi8ke2ov LyEvL30iCglkb25lCmVsc2UKCWFza19kaXNrICJXaGljaCBkaXNrKHMpIHdvdWxkIHlvdSBsaWtl IHRvIHVzZT8gKG9yICc/JyBmb3IgaGVscCBvciAnbm9uZScpIiBcCgkJZGlza3NlbGVjdF9oZWxw ICRkaXNrcwoJaWYgWyAiJGFuc3dlciIgIT0gbm9uZSBdOyB0aGVuCgkJZm9yIGkgaW4gJGFuc3dl cjsgZG8KCQkJZGlza2RldnM9IiRkaXNrZGV2cyAvZGV2LyRpIgoJCWRvbmUKCWVsc2UKCQlESVNL X01PREU9Im5vbmUiCglmaQpmaQoKaWYgWyAtbiAiJGRpc2tkZXZzIiBdICYmIFsgLXogIiRESVNL X01PREUiIF07IHRoZW4KCWFuc3dlcj0KCWRpc2tfaXNfb3JfZGlza3NfYXJlPSJkaXNrIGlzIgoJ aXRfdGhlbT0iaXQiCglzZXQgLS0gJGRpc2tkZXZzCglpZiBbICQjIC1ndCAxIF07IHRoZW4KCQlk aXNrX2lzX29yX2Rpc2tzX2FyZT0iZGlza3MgYXJlIgoJCWl0X3RoZW09InRoZW0iCglmaQoKCXdo aWxlIHRydWU7IGRvCgkJZWNobyAiVGhlIGZvbGxvd2luZyAkZGlza19pc19vcl9kaXNrc19hcmUg c2VsZWN0ZWQ6IgoJCXNob3dfZGlza19pbmZvICRkaXNrZGV2cwoJCWVjaG9uICJIb3cgd291bGQg eW91IGxpa2UgdG8gdXNlICRpdF90aGVtPyAoJ3N5cycsICdkYXRhJyBvciAnPycgZm9yIGhlbHAp IFs/XSAiCgkJZGVmYXVsdF9yZWFkIGFuc3dlciAnPycKCQljYXNlICIkYW5zd2VyIiBpbgoJCSc/ JykgZGlza21vZGVfaGVscDs7CgkJc3lzfGRhdGEpIGJyZWFrOzsKCQllc2FjCglkb25lCglESVNL X01PREU9IiRhbnN3ZXIiCmZpCgppZiBbIC16ICIkU1dBUF9TSVpFIiBdOyB0aGVuCglTV0FQX1NJ WkU9JChmaW5kX3N3YXBfc2l6ZSAkZGlza2RldnMpCmZpCgpzZXQgLS0gJGRpc2tkZXZzCmlmIFsg JCMgLWd0IDEgXTsgdGhlbgoJVVNFX1JBSUQ9MQpmaQoKZG1lc2cgLW4xCgojIG5hdGl2ZSBkaXNr IGluc3RhbGwKY2FzZSAiJERJU0tfTU9ERSIgaW4Kc3lzKSBuYXRpdmVfZGlza19pbnN0YWxsJFVT RV9MVk0gJGRpc2tkZXZzOzsKZGF0YSkgZGF0YV9vbmx5X2Rpc2tfaW5zdGFsbCRVU0VfTFZNICRk aXNrZGV2czs7Cm5vbmUpIGV4aXQgMDs7CiopIGVjaG8gIk5vdCBhIHZhbGlkIGluc3RhbGwgbW9k ZTogJERJU0tfTU9ERSIgPiYyOyBleGl0IDE7Owplc2FjCgplY2hvICIkRElTS19NT0RFIiA+IC90 bXAvYWxwaW5lLWluc3RhbGwtZGlza21vZGUub3V0Cg== --=_2041ad7312c0d2b872948b21e3d2ffa0-- --- Unsubscribe: alpine-devel+unsubscribe@lists.alpinelinux.org Help: alpine-devel+help@lists.alpinelinux.org ---