From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from [140.186.70.92] (port=52699 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1PInU5-0007RC-LX for qemu-devel@nongnu.org; Wed, 17 Nov 2010 14:16:02 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1PInU2-0001Q0-4d for qemu-devel@nongnu.org; Wed, 17 Nov 2010 14:15:57 -0500 Received: from mail-vw0-f45.google.com ([209.85.212.45]:49123) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1PInU1-0001Pi-SC for qemu-devel@nongnu.org; Wed, 17 Nov 2010 14:15:54 -0500 Received: by vws5 with SMTP id 5so1248910vws.4 for ; Wed, 17 Nov 2010 11:15:53 -0800 (PST) MIME-Version: 1.0 From: Blue Swirl Date: Wed, 17 Nov 2010 19:15:32 +0000 Message-ID: Content-Type: multipart/mixed; boundary=0016e641dc6680179204954480c5 Subject: [Qemu-devel] [PATCH v2] Force object directory use List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel --0016e641dc6680179204954480c5 Content-Type: text/plain; charset=UTF-8 If the user attempts to run 'configure' in the source tree, create an object directory and configure that instead. Rename topmost Makefile to Makefile.top. Add a new Makefile, which is only used when user attempts to run 'make' in the source tree. Signed-off-by: Blue Swirl --- Makefile | 373 +--------------------------------------------------------- Makefile.top | 367 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ configure | 51 ++++---- 3 files changed, 400 insertions(+), 391 deletions(-) create mode 100644 Makefile.top diff --git a/Makefile b/Makefile index 747e47c..56016fa 100644 --- a/Makefile +++ b/Makefile @@ -1,367 +1,6 @@ -# Makefile for QEMU. - -GENERATED_HEADERS = config-host.h trace.h qemu-options.def -ifeq ($(TRACE_BACKEND),dtrace) -GENERATED_HEADERS += trace-dtrace.h -endif - -ifneq ($(wildcard config-host.mak),) -# Put the all: rule here so that config-host.mak can contain dependencies. -all: build-all -include config-host.mak -include $(SRC_PATH)/rules.mak -config-host.mak: $(SRC_PATH)/configure - @echo $@ is out-of-date, running configure - @sed -n "/.*Configured with/s/[^:]*: //p" $@ | sh -else -config-host.mak: - @echo "Please call configure before running make!" - @exit 1 -endif - -# Don't try to regenerate Makefile or configure -# We don't generate any of them -Makefile: ; -configure: ; - -.PHONY: all clean cscope distclean dvi html info install install-doc \ - pdf recurse-all speed tar tarbin test build-all - -$(call set-vpath, $(SRC_PATH):$(SRC_PATH)/hw) - -LIBS+=-lz $(LIBS_TOOLS) - -ifdef BUILD_DOCS -DOCS=qemu-doc.html qemu-tech.html qemu.1 qemu-img.1 qemu-nbd.8 QMP/qmp-commands.txt -else -DOCS= -endif - -SUBDIR_MAKEFLAGS=$(if $(V),,--no-print-directory) -SUBDIR_DEVICES_MAK=$(patsubst %, %/config-devices.mak, $(TARGET_DIRS)) - -config-all-devices.mak: $(SUBDIR_DEVICES_MAK) - $(call quiet-command,cat $(SUBDIR_DEVICES_MAK) | grep =y | sort -u > $@," GEN $@") - -%/config-devices.mak: default-configs/%.mak - $(call quiet-command,cat $< > $@.tmp, " GEN $@") - @if test -f $@; then \ - if cmp -s $@.old $@; then \ - if ! cmp -s $@ $@.tmp; then \ - mv $@.tmp $@; \ - cp -p $@ $@.old; \ - fi; \ - else \ - if test -f $@.old; then \ - echo "WARNING: $@ (user modified) out of date.";\ - else \ - echo "WARNING: $@ out of date.";\ - fi; \ - echo "Run \"make defconfig\" to regenerate."; \ - rm $@.tmp; \ - fi; \ - else \ - mv $@.tmp $@; \ - cp -p $@ $@.old; \ - fi - -defconfig: - rm -f config-all-devices.mak $(SUBDIR_DEVICES_MAK) - --include config-all-devices.mak - -build-all: $(DOCS) $(TOOLS) recurse-all - -config-host.h: config-host.h-timestamp -config-host.h-timestamp: config-host.mak -qemu-options.def: $(SRC_PATH)/qemu-options.hx - $(call quiet-command,sh $(SRC_PATH)/hxtool -h < $< > $@," GEN $@") - -SUBDIR_RULES=$(patsubst %,subdir-%, $(TARGET_DIRS)) - -subdir-%: $(GENERATED_HEADERS) - $(call quiet-command,$(MAKE) $(SUBDIR_MAKEFLAGS) -C $* V="$(V)" TARGET_DIR="$*/" all,) - -ifneq ($(wildcard config-host.mak),) -include $(SRC_PATH)/Makefile.objs -endif - -$(common-obj-y): $(GENERATED_HEADERS) -$(filter %-softmmu,$(SUBDIR_RULES)): $(trace-obj-y) $(common-obj-y) subdir-libdis - -$(filter %-user,$(SUBDIR_RULES)): $(GENERATED_HEADERS) $(trace-obj-y) subdir-libdis-user subdir-libuser - -ROMSUBDIR_RULES=$(patsubst %,romsubdir-%, $(ROMS)) -romsubdir-%: - $(call quiet-command,$(MAKE) $(SUBDIR_MAKEFLAGS) -C pc-bios/$* V="$(V)" TARGET_DIR="$*/",) - -ALL_SUBDIRS=$(TARGET_DIRS) $(patsubst %,pc-bios/%, $(ROMS)) - -recurse-all: $(SUBDIR_RULES) $(ROMSUBDIR_RULES) - -audio/audio.o audio/fmodaudio.o: QEMU_CFLAGS += $(FMOD_CFLAGS) - -QEMU_CFLAGS+=$(CURL_CFLAGS) - -ui/cocoa.o: ui/cocoa.m - -ui/sdl.o audio/sdlaudio.o ui/sdl_zoom.o baum.o: QEMU_CFLAGS += $(SDL_CFLAGS) - -ui/vnc.o: QEMU_CFLAGS += $(VNC_TLS_CFLAGS) - -bt-host.o: QEMU_CFLAGS += $(BLUEZ_CFLAGS) - -ifeq ($(TRACE_BACKEND),dtrace) -trace.h: trace.h-timestamp trace-dtrace.h -else -trace.h: trace.h-timestamp -endif -trace.h-timestamp: $(SRC_PATH)/trace-events config-host.mak - $(call quiet-command,sh $(SRC_PATH)/tracetool --$(TRACE_BACKEND) -h < $< > $@," GEN trace.h") - @cmp -s $@ trace.h || cp $@ trace.h - -trace.c: trace.c-timestamp -trace.c-timestamp: $(SRC_PATH)/trace-events config-host.mak - $(call quiet-command,sh $(SRC_PATH)/tracetool --$(TRACE_BACKEND) -c < $< > $@," GEN trace.c") - @cmp -s $@ trace.c || cp $@ trace.c - -trace.o: trace.c $(GENERATED_HEADERS) - -trace-dtrace.h: trace-dtrace.dtrace - $(call quiet-command,dtrace -o $@ -h -s $<, " GEN trace-dtrace.h") - -# Normal practice is to name DTrace probe file with a '.d' extension -# but that gets picked up by QEMU's Makefile as an external dependancy -# rule file. So we use '.dtrace' instead -trace-dtrace.dtrace: trace-dtrace.dtrace-timestamp -trace-dtrace.dtrace-timestamp: $(SRC_PATH)/trace-events config-host.mak - $(call quiet-command,sh $(SRC_PATH)/tracetool --$(TRACE_BACKEND) -d < $< > $@," GEN trace-dtrace.dtrace") - @cmp -s $@ trace-dtrace.dtrace || cp $@ trace-dtrace.dtrace - -trace-dtrace.o: trace-dtrace.dtrace $(GENERATED_HEADERS) - $(call quiet-command,dtrace -o $@ -G -s $<, " GEN trace-dtrace.o") - -simpletrace.o: simpletrace.c $(GENERATED_HEADERS) - -version.o: $(SRC_PATH)/version.rc config-host.mak - $(call quiet-command,$(WINDRES) -I. -o $@ $<," RC $(TARGET_DIR)$@") - -version-obj-$(CONFIG_WIN32) += version.o -###################################################################### - -qemu-img.o: qemu-img-cmds.h -qemu-img.o qemu-tool.o qemu-nbd.o qemu-io.o: $(GENERATED_HEADERS) - -qemu-img$(EXESUF): qemu-img.o qemu-tool.o qemu-error.o $(oslib-obj-y) $(trace-obj-y) $(block-obj-y) $(qobject-obj-y) $(version-obj-y) qemu-timer-common.o - -qemu-nbd$(EXESUF): qemu-nbd.o qemu-tool.o qemu-error.o $(oslib-obj-y) $(trace-obj-y) $(block-obj-y) $(qobject-obj-y) $(version-obj-y) qemu-timer-common.o - -qemu-io$(EXESUF): qemu-io.o cmd.o qemu-tool.o qemu-error.o $(oslib-obj-y) $(trace-obj-y) $(block-obj-y) $(qobject-obj-y) $(version-obj-y) qemu-timer-common.o - -qemu-img-cmds.h: $(SRC_PATH)/qemu-img-cmds.hx - $(call quiet-command,sh $(SRC_PATH)/hxtool -h < $< > $@," GEN $@") - -check-qint.o check-qstring.o check-qdict.o check-qlist.o check-qfloat.o check-qjson.o: $(GENERATED_HEADERS) - -check-qint: check-qint.o qint.o qemu-malloc.o $(trace-obj-y) -check-qstring: check-qstring.o qstring.o qemu-malloc.o $(trace-obj-y) -check-qdict: check-qdict.o qdict.o qfloat.o qint.o qstring.o qbool.o qemu-malloc.o qlist.o $(trace-obj-y) -check-qlist: check-qlist.o qlist.o qint.o qemu-malloc.o $(trace-obj-y) -check-qfloat: check-qfloat.o qfloat.o qemu-malloc.o $(trace-obj-y) -check-qjson: check-qjson.o qfloat.o qint.o qdict.o qstring.o qlist.o qbool.o qjson.o json-streamer.o json-lexer.o json-parser.o qemu-malloc.o $(trace-obj-y) - -clean: -# avoid old build problems by removing potentially incorrect old files - rm -f config.mak op-i386.h opc-i386.h gen-op-i386.h op-arm.h opc-arm.h gen-op-arm.h - rm -f qemu-options.def - rm -f *.o *.d *.a $(TOOLS) TAGS cscope.* *.pod *~ */*~ - rm -f slirp/*.o slirp/*.d audio/*.o audio/*.d block/*.o block/*.d net/*.o net/*.d fsdev/*.o fsdev/*.d ui/*.o ui/*.d - rm -f qemu-img-cmds.h - rm -f trace.c trace.h trace.c-timestamp trace.h-timestamp - rm -f trace-dtrace.dtrace trace-dtrace.dtrace-timestamp - rm -f trace-dtrace.h trace-dtrace.h-timestamp - $(MAKE) -C tests clean - for d in $(ALL_SUBDIRS) libhw32 libhw64 libuser libdis libdis-user; do \ - if test -d $$d; then $(MAKE) -C $$d $@ || exit 1; fi; \ - rm -f $$d/qemu-options.def; \ - done - -distclean: clean - rm -f config-host.mak config-host.h* config-host.ld $(DOCS) qemu-options.texi qemu-img-cmds.texi qemu-monitor.texi - rm -f config-all-devices.mak - rm -f roms/seabios/config.mak roms/vgabios/config.mak - rm -f qemu-doc.info qemu-doc.aux qemu-doc.cp qemu-doc.dvi qemu-doc.fn qemu-doc.info qemu-doc.ky qemu-doc.log qemu-doc.pdf qemu-doc.pg qemu-doc.toc qemu-doc.tp qemu-doc.vr - rm -f qemu-tech.info qemu-tech.aux qemu-tech.cp qemu-tech.dvi qemu-tech.fn qemu-tech.info qemu-tech.ky qemu-tech.log qemu-tech.pdf qemu-tech.pg qemu-tech.toc qemu-tech.tp qemu-tech.vr - for d in $(TARGET_DIRS) libhw32 libhw64 libuser libdis libdis-user; do \ - rm -rf $$d || exit 1 ; \ - done - -KEYMAPS=da en-gb et fr fr-ch is lt modifiers no pt-br sv \ -ar de en-us fi fr-be hr it lv nl pl ru th \ -common de-ch es fo fr-ca hu ja mk nl-be pt sl tr - -ifdef INSTALL_BLOBS -BLOBS=bios.bin vgabios.bin vgabios-cirrus.bin \ -vgabios-stdvga.bin vgabios-vmware.bin \ -ppc_rom.bin openbios-sparc32 openbios-sparc64 openbios-ppc \ -gpxe-eepro100-80861209.rom \ -gpxe-eepro100-80861229.rom \ -pxe-e1000.bin \ -pxe-ne2k_pci.bin pxe-pcnet.bin \ -pxe-rtl8139.bin pxe-virtio.bin \ -bamboo.dtb petalogix-s3adsp1800.dtb \ -multiboot.bin linuxboot.bin \ -s390-zipl.rom -else -BLOBS= -endif - -install-doc: $(DOCS) - $(INSTALL_DIR) "$(DESTDIR)$(docdir)" - $(INSTALL_DATA) qemu-doc.html qemu-tech.html "$(DESTDIR)$(docdir)" -ifdef CONFIG_POSIX - $(INSTALL_DIR) "$(DESTDIR)$(mandir)/man1" - $(INSTALL_DATA) qemu.1 qemu-img.1 "$(DESTDIR)$(mandir)/man1" - $(INSTALL_DIR) "$(DESTDIR)$(mandir)/man8" - $(INSTALL_DATA) qemu-nbd.8 "$(DESTDIR)$(mandir)/man8" -endif - -install-sysconfig: - $(INSTALL_DIR) "$(DESTDIR)$(sysconfdir)/qemu" - $(INSTALL_DATA) $(SRC_PATH)/sysconfigs/target/target-x86_64.conf "$(DESTDIR)$(sysconfdir)/qemu" - -install: all $(if $(BUILD_DOCS),install-doc) install-sysconfig - $(INSTALL_DIR) "$(DESTDIR)$(bindir)" -ifneq ($(TOOLS),) - $(INSTALL_PROG) $(STRIP_OPT) $(TOOLS) "$(DESTDIR)$(bindir)" -endif -ifneq ($(BLOBS),) - $(INSTALL_DIR) "$(DESTDIR)$(datadir)" - set -e; for x in $(BLOBS); do \ - $(INSTALL_DATA) $(SRC_PATH)/pc-bios/$$x "$(DESTDIR)$(datadir)"; \ - done -endif - $(INSTALL_DIR) "$(DESTDIR)$(datadir)/keymaps" - set -e; for x in $(KEYMAPS); do \ - $(INSTALL_DATA) $(SRC_PATH)/pc-bios/keymaps/$$x "$(DESTDIR)$(datadir)/keymaps"; \ - done - for d in $(TARGET_DIRS); do \ - $(MAKE) -C $$d $@ || exit 1 ; \ - done - -# various test targets -test speed: all - $(MAKE) -C tests $@ - -.PHONY: TAGS -TAGS: - find "$(SRC_PATH)" -name '*.[hc]' -print0 | xargs -0 etags - -cscope: - rm -f ./cscope.* - find . -name "*.[ch]" -print | sed 's,^\./,,' > ./cscope.files - cscope -b - -# documentation -MAKEINFO=makeinfo -MAKEINFOFLAGS=--no-headers --no-split --number-sections -TEXIFLAG=$(if $(V),,--quiet) -%.dvi: %.texi - $(call quiet-command,texi2dvi $(TEXIFLAG) -I . $<," GEN $@") - -%.html: %.texi - $(call quiet-command,$(MAKEINFO) $(MAKEINFOFLAGS) --html $< -o $@, \ - " GEN $@") - -%.info: %.texi - $(call quiet-command,$(MAKEINFO) $< -o $@," GEN $@") - -%.pdf: %.texi - $(call quiet-command,texi2pdf $(TEXIFLAG) -I . $<," GEN $@") - -qemu-options.texi: $(SRC_PATH)/qemu-options.hx - $(call quiet-command,sh $(SRC_PATH)/hxtool -t < $< > $@," GEN $@") - -qemu-monitor.texi: $(SRC_PATH)/hmp-commands.hx - $(call quiet-command,sh $(SRC_PATH)/hxtool -t < $< > $@," GEN $@") - -QMP/qmp-commands.txt: $(SRC_PATH)/qmp-commands.hx - $(call quiet-command,sh $(SRC_PATH)/hxtool -q < $< > $@," GEN $@") - -qemu-img-cmds.texi: $(SRC_PATH)/qemu-img-cmds.hx - $(call quiet-command,sh $(SRC_PATH)/hxtool -t < $< > $@," GEN $@") - -qemu.1: qemu-doc.texi qemu-options.texi qemu-monitor.texi - $(call quiet-command, \ - perl -Ww -- $(SRC_PATH)/texi2pod.pl $< qemu.pod && \ - pod2man --section=1 --center=" " --release=" " qemu.pod > $@, \ - " GEN $@") - -qemu-img.1: qemu-img.texi qemu-img-cmds.texi - $(call quiet-command, \ - perl -Ww -- $(SRC_PATH)/texi2pod.pl $< qemu-img.pod && \ - pod2man --section=1 --center=" " --release=" " qemu-img.pod > $@, \ - " GEN $@") - -qemu-nbd.8: qemu-nbd.texi - $(call quiet-command, \ - perl -Ww -- $(SRC_PATH)/texi2pod.pl $< qemu-nbd.pod && \ - pod2man --section=8 --center=" " --release=" " qemu-nbd.pod > $@, \ - " GEN $@") - -dvi: qemu-doc.dvi qemu-tech.dvi -html: qemu-doc.html qemu-tech.html -info: qemu-doc.info qemu-tech.info -pdf: qemu-doc.pdf qemu-tech.pdf - -qemu-doc.dvi qemu-doc.html qemu-doc.info qemu-doc.pdf: \ - qemu-img.texi qemu-nbd.texi qemu-options.texi \ - qemu-monitor.texi qemu-img-cmds.texi - -VERSION ?= $(shell cat VERSION) -FILE = qemu-$(VERSION) - -# tar release (use 'make -k tar' on a checkouted tree) -tar: - rm -rf /tmp/$(FILE) - cp -r . /tmp/$(FILE) - cd /tmp && tar zcvf ~/$(FILE).tar.gz $(FILE) --exclude CVS --exclude .git --exclude .svn - rm -rf /tmp/$(FILE) - -SYSTEM_TARGETS=$(filter %-softmmu,$(TARGET_DIRS)) -SYSTEM_PROGS=$(patsubst qemu-system-i386,qemu, \ - $(patsubst %-softmmu,qemu-system-%, \ - $(SYSTEM_TARGETS))) - -USER_TARGETS=$(filter %-user,$(TARGET_DIRS)) -USER_PROGS=$(patsubst %-bsd-user,qemu-%, \ - $(patsubst %-darwin-user,qemu-%, \ - $(patsubst %-linux-user,qemu-%, \ - $(USER_TARGETS)))) - -# generate a binary distribution -tarbin: - cd / && tar zcvf ~/qemu-$(VERSION)-$(ARCH).tar.gz \ - $(patsubst %,$(bindir)/%, $(SYSTEM_PROGS)) \ - $(patsubst %,$(bindir)/%, $(USER_PROGS)) \ - $(bindir)/qemu-img \ - $(bindir)/qemu-nbd \ - $(datadir)/bios.bin \ - $(datadir)/vgabios.bin \ - $(datadir)/vgabios-cirrus.bin \ - $(datadir)/ppc_rom.bin \ - $(datadir)/openbios-sparc32 \ - $(datadir)/openbios-sparc64 \ - $(datadir)/openbios-ppc \ - $(datadir)/pxe-ne2k_pci.bin \ - $(datadir)/pxe-rtl8139.bin \ - $(datadir)/pxe-pcnet.bin \ - $(datadir)/pxe-e1000.bin \ - $(docdir)/qemu-doc.html \ - $(docdir)/qemu-tech.html \ - $(mandir)/man1/qemu.1 \ - $(mandir)/man1/qemu-img.1 \ - $(mandir)/man8/qemu-nbd.8 - -# Include automatically generated dependency files --include $(wildcard *.d audio/*.d slirp/*.d block/*.d net/*.d ui/*.d) +all clean distclean defconfig install install-doc install-sysconfig test speed TAGS cscope tar tarbin: + @if ! test -d obj; then \ + echo "Please call 'configure' before running 'make'"; \ + else \ + $(MAKE) -C obj $@; \ + fi diff --git a/Makefile.top b/Makefile.top new file mode 100644 index 0000000..747e47c --- /dev/null +++ b/Makefile.top @@ -0,0 +1,367 @@ +# Makefile for QEMU. + +GENERATED_HEADERS = config-host.h trace.h qemu-options.def +ifeq ($(TRACE_BACKEND),dtrace) +GENERATED_HEADERS += trace-dtrace.h +endif + +ifneq ($(wildcard config-host.mak),) +# Put the all: rule here so that config-host.mak can contain dependencies. +all: build-all +include config-host.mak +include $(SRC_PATH)/rules.mak +config-host.mak: $(SRC_PATH)/configure + @echo $@ is out-of-date, running configure + @sed -n "/.*Configured with/s/[^:]*: //p" $@ | sh +else +config-host.mak: + @echo "Please call configure before running make!" + @exit 1 +endif + +# Don't try to regenerate Makefile or configure +# We don't generate any of them +Makefile: ; +configure: ; + +.PHONY: all clean cscope distclean dvi html info install install-doc \ + pdf recurse-all speed tar tarbin test build-all + +$(call set-vpath, $(SRC_PATH):$(SRC_PATH)/hw) + +LIBS+=-lz $(LIBS_TOOLS) + +ifdef BUILD_DOCS +DOCS=qemu-doc.html qemu-tech.html qemu.1 qemu-img.1 qemu-nbd.8 QMP/qmp-commands.txt +else +DOCS= +endif + +SUBDIR_MAKEFLAGS=$(if $(V),,--no-print-directory) +SUBDIR_DEVICES_MAK=$(patsubst %, %/config-devices.mak, $(TARGET_DIRS)) + +config-all-devices.mak: $(SUBDIR_DEVICES_MAK) + $(call quiet-command,cat $(SUBDIR_DEVICES_MAK) | grep =y | sort -u > $@," GEN $@") + +%/config-devices.mak: default-configs/%.mak + $(call quiet-command,cat $< > $@.tmp, " GEN $@") + @if test -f $@; then \ + if cmp -s $@.old $@; then \ + if ! cmp -s $@ $@.tmp; then \ + mv $@.tmp $@; \ + cp -p $@ $@.old; \ + fi; \ + else \ + if test -f $@.old; then \ + echo "WARNING: $@ (user modified) out of date.";\ + else \ + echo "WARNING: $@ out of date.";\ + fi; \ + echo "Run \"make defconfig\" to regenerate."; \ + rm $@.tmp; \ + fi; \ + else \ + mv $@.tmp $@; \ + cp -p $@ $@.old; \ + fi + +defconfig: + rm -f config-all-devices.mak $(SUBDIR_DEVICES_MAK) + +-include config-all-devices.mak + +build-all: $(DOCS) $(TOOLS) recurse-all + +config-host.h: config-host.h-timestamp +config-host.h-timestamp: config-host.mak +qemu-options.def: $(SRC_PATH)/qemu-options.hx + $(call quiet-command,sh $(SRC_PATH)/hxtool -h < $< > $@," GEN $@") + +SUBDIR_RULES=$(patsubst %,subdir-%, $(TARGET_DIRS)) + +subdir-%: $(GENERATED_HEADERS) + $(call quiet-command,$(MAKE) $(SUBDIR_MAKEFLAGS) -C $* V="$(V)" TARGET_DIR="$*/" all,) + +ifneq ($(wildcard config-host.mak),) +include $(SRC_PATH)/Makefile.objs +endif + +$(common-obj-y): $(GENERATED_HEADERS) +$(filter %-softmmu,$(SUBDIR_RULES)): $(trace-obj-y) $(common-obj-y) subdir-libdis + +$(filter %-user,$(SUBDIR_RULES)): $(GENERATED_HEADERS) $(trace-obj-y) subdir-libdis-user subdir-libuser + +ROMSUBDIR_RULES=$(patsubst %,romsubdir-%, $(ROMS)) +romsubdir-%: + $(call quiet-command,$(MAKE) $(SUBDIR_MAKEFLAGS) -C pc-bios/$* V="$(V)" TARGET_DIR="$*/",) + +ALL_SUBDIRS=$(TARGET_DIRS) $(patsubst %,pc-bios/%, $(ROMS)) + +recurse-all: $(SUBDIR_RULES) $(ROMSUBDIR_RULES) + +audio/audio.o audio/fmodaudio.o: QEMU_CFLAGS += $(FMOD_CFLAGS) + +QEMU_CFLAGS+=$(CURL_CFLAGS) + +ui/cocoa.o: ui/cocoa.m + +ui/sdl.o audio/sdlaudio.o ui/sdl_zoom.o baum.o: QEMU_CFLAGS += $(SDL_CFLAGS) + +ui/vnc.o: QEMU_CFLAGS += $(VNC_TLS_CFLAGS) + +bt-host.o: QEMU_CFLAGS += $(BLUEZ_CFLAGS) + +ifeq ($(TRACE_BACKEND),dtrace) +trace.h: trace.h-timestamp trace-dtrace.h +else +trace.h: trace.h-timestamp +endif +trace.h-timestamp: $(SRC_PATH)/trace-events config-host.mak + $(call quiet-command,sh $(SRC_PATH)/tracetool --$(TRACE_BACKEND) -h < $< > $@," GEN trace.h") + @cmp -s $@ trace.h || cp $@ trace.h + +trace.c: trace.c-timestamp +trace.c-timestamp: $(SRC_PATH)/trace-events config-host.mak + $(call quiet-command,sh $(SRC_PATH)/tracetool --$(TRACE_BACKEND) -c < $< > $@," GEN trace.c") + @cmp -s $@ trace.c || cp $@ trace.c + +trace.o: trace.c $(GENERATED_HEADERS) + +trace-dtrace.h: trace-dtrace.dtrace + $(call quiet-command,dtrace -o $@ -h -s $<, " GEN trace-dtrace.h") + +# Normal practice is to name DTrace probe file with a '.d' extension +# but that gets picked up by QEMU's Makefile as an external dependancy +# rule file. So we use '.dtrace' instead +trace-dtrace.dtrace: trace-dtrace.dtrace-timestamp +trace-dtrace.dtrace-timestamp: $(SRC_PATH)/trace-events config-host.mak + $(call quiet-command,sh $(SRC_PATH)/tracetool --$(TRACE_BACKEND) -d < $< > $@," GEN trace-dtrace.dtrace") + @cmp -s $@ trace-dtrace.dtrace || cp $@ trace-dtrace.dtrace + +trace-dtrace.o: trace-dtrace.dtrace $(GENERATED_HEADERS) + $(call quiet-command,dtrace -o $@ -G -s $<, " GEN trace-dtrace.o") + +simpletrace.o: simpletrace.c $(GENERATED_HEADERS) + +version.o: $(SRC_PATH)/version.rc config-host.mak + $(call quiet-command,$(WINDRES) -I. -o $@ $<," RC $(TARGET_DIR)$@") + +version-obj-$(CONFIG_WIN32) += version.o +###################################################################### + +qemu-img.o: qemu-img-cmds.h +qemu-img.o qemu-tool.o qemu-nbd.o qemu-io.o: $(GENERATED_HEADERS) + +qemu-img$(EXESUF): qemu-img.o qemu-tool.o qemu-error.o $(oslib-obj-y) $(trace-obj-y) $(block-obj-y) $(qobject-obj-y) $(version-obj-y) qemu-timer-common.o + +qemu-nbd$(EXESUF): qemu-nbd.o qemu-tool.o qemu-error.o $(oslib-obj-y) $(trace-obj-y) $(block-obj-y) $(qobject-obj-y) $(version-obj-y) qemu-timer-common.o + +qemu-io$(EXESUF): qemu-io.o cmd.o qemu-tool.o qemu-error.o $(oslib-obj-y) $(trace-obj-y) $(block-obj-y) $(qobject-obj-y) $(version-obj-y) qemu-timer-common.o + +qemu-img-cmds.h: $(SRC_PATH)/qemu-img-cmds.hx + $(call quiet-command,sh $(SRC_PATH)/hxtool -h < $< > $@," GEN $@") + +check-qint.o check-qstring.o check-qdict.o check-qlist.o check-qfloat.o check-qjson.o: $(GENERATED_HEADERS) + +check-qint: check-qint.o qint.o qemu-malloc.o $(trace-obj-y) +check-qstring: check-qstring.o qstring.o qemu-malloc.o $(trace-obj-y) +check-qdict: check-qdict.o qdict.o qfloat.o qint.o qstring.o qbool.o qemu-malloc.o qlist.o $(trace-obj-y) +check-qlist: check-qlist.o qlist.o qint.o qemu-malloc.o $(trace-obj-y) +check-qfloat: check-qfloat.o qfloat.o qemu-malloc.o $(trace-obj-y) +check-qjson: check-qjson.o qfloat.o qint.o qdict.o qstring.o qlist.o qbool.o qjson.o json-streamer.o json-lexer.o json-parser.o qemu-malloc.o $(trace-obj-y) + +clean: +# avoid old build problems by removing potentially incorrect old files + rm -f config.mak op-i386.h opc-i386.h gen-op-i386.h op-arm.h opc-arm.h gen-op-arm.h + rm -f qemu-options.def + rm -f *.o *.d *.a $(TOOLS) TAGS cscope.* *.pod *~ */*~ + rm -f slirp/*.o slirp/*.d audio/*.o audio/*.d block/*.o block/*.d net/*.o net/*.d fsdev/*.o fsdev/*.d ui/*.o ui/*.d + rm -f qemu-img-cmds.h + rm -f trace.c trace.h trace.c-timestamp trace.h-timestamp + rm -f trace-dtrace.dtrace trace-dtrace.dtrace-timestamp + rm -f trace-dtrace.h trace-dtrace.h-timestamp + $(MAKE) -C tests clean + for d in $(ALL_SUBDIRS) libhw32 libhw64 libuser libdis libdis-user; do \ + if test -d $$d; then $(MAKE) -C $$d $@ || exit 1; fi; \ + rm -f $$d/qemu-options.def; \ + done + +distclean: clean + rm -f config-host.mak config-host.h* config-host.ld $(DOCS) qemu-options.texi qemu-img-cmds.texi qemu-monitor.texi + rm -f config-all-devices.mak + rm -f roms/seabios/config.mak roms/vgabios/config.mak + rm -f qemu-doc.info qemu-doc.aux qemu-doc.cp qemu-doc.dvi qemu-doc.fn qemu-doc.info qemu-doc.ky qemu-doc.log qemu-doc.pdf qemu-doc.pg qemu-doc.toc qemu-doc.tp qemu-doc.vr + rm -f qemu-tech.info qemu-tech.aux qemu-tech.cp qemu-tech.dvi qemu-tech.fn qemu-tech.info qemu-tech.ky qemu-tech.log qemu-tech.pdf qemu-tech.pg qemu-tech.toc qemu-tech.tp qemu-tech.vr + for d in $(TARGET_DIRS) libhw32 libhw64 libuser libdis libdis-user; do \ + rm -rf $$d || exit 1 ; \ + done + +KEYMAPS=da en-gb et fr fr-ch is lt modifiers no pt-br sv \ +ar de en-us fi fr-be hr it lv nl pl ru th \ +common de-ch es fo fr-ca hu ja mk nl-be pt sl tr + +ifdef INSTALL_BLOBS +BLOBS=bios.bin vgabios.bin vgabios-cirrus.bin \ +vgabios-stdvga.bin vgabios-vmware.bin \ +ppc_rom.bin openbios-sparc32 openbios-sparc64 openbios-ppc \ +gpxe-eepro100-80861209.rom \ +gpxe-eepro100-80861229.rom \ +pxe-e1000.bin \ +pxe-ne2k_pci.bin pxe-pcnet.bin \ +pxe-rtl8139.bin pxe-virtio.bin \ +bamboo.dtb petalogix-s3adsp1800.dtb \ +multiboot.bin linuxboot.bin \ +s390-zipl.rom +else +BLOBS= +endif + +install-doc: $(DOCS) + $(INSTALL_DIR) "$(DESTDIR)$(docdir)" + $(INSTALL_DATA) qemu-doc.html qemu-tech.html "$(DESTDIR)$(docdir)" +ifdef CONFIG_POSIX + $(INSTALL_DIR) "$(DESTDIR)$(mandir)/man1" + $(INSTALL_DATA) qemu.1 qemu-img.1 "$(DESTDIR)$(mandir)/man1" + $(INSTALL_DIR) "$(DESTDIR)$(mandir)/man8" + $(INSTALL_DATA) qemu-nbd.8 "$(DESTDIR)$(mandir)/man8" +endif + +install-sysconfig: + $(INSTALL_DIR) "$(DESTDIR)$(sysconfdir)/qemu" + $(INSTALL_DATA) $(SRC_PATH)/sysconfigs/target/target-x86_64.conf "$(DESTDIR)$(sysconfdir)/qemu" + +install: all $(if $(BUILD_DOCS),install-doc) install-sysconfig + $(INSTALL_DIR) "$(DESTDIR)$(bindir)" +ifneq ($(TOOLS),) + $(INSTALL_PROG) $(STRIP_OPT) $(TOOLS) "$(DESTDIR)$(bindir)" +endif +ifneq ($(BLOBS),) + $(INSTALL_DIR) "$(DESTDIR)$(datadir)" + set -e; for x in $(BLOBS); do \ + $(INSTALL_DATA) $(SRC_PATH)/pc-bios/$$x "$(DESTDIR)$(datadir)"; \ + done +endif + $(INSTALL_DIR) "$(DESTDIR)$(datadir)/keymaps" + set -e; for x in $(KEYMAPS); do \ + $(INSTALL_DATA) $(SRC_PATH)/pc-bios/keymaps/$$x "$(DESTDIR)$(datadir)/keymaps"; \ + done + for d in $(TARGET_DIRS); do \ + $(MAKE) -C $$d $@ || exit 1 ; \ + done + +# various test targets +test speed: all + $(MAKE) -C tests $@ + +.PHONY: TAGS +TAGS: + find "$(SRC_PATH)" -name '*.[hc]' -print0 | xargs -0 etags + +cscope: + rm -f ./cscope.* + find . -name "*.[ch]" -print | sed 's,^\./,,' > ./cscope.files + cscope -b + +# documentation +MAKEINFO=makeinfo +MAKEINFOFLAGS=--no-headers --no-split --number-sections +TEXIFLAG=$(if $(V),,--quiet) +%.dvi: %.texi + $(call quiet-command,texi2dvi $(TEXIFLAG) -I . $<," GEN $@") + +%.html: %.texi + $(call quiet-command,$(MAKEINFO) $(MAKEINFOFLAGS) --html $< -o $@, \ + " GEN $@") + +%.info: %.texi + $(call quiet-command,$(MAKEINFO) $< -o $@," GEN $@") + +%.pdf: %.texi + $(call quiet-command,texi2pdf $(TEXIFLAG) -I . $<," GEN $@") + +qemu-options.texi: $(SRC_PATH)/qemu-options.hx + $(call quiet-command,sh $(SRC_PATH)/hxtool -t < $< > $@," GEN $@") + +qemu-monitor.texi: $(SRC_PATH)/hmp-commands.hx + $(call quiet-command,sh $(SRC_PATH)/hxtool -t < $< > $@," GEN $@") + +QMP/qmp-commands.txt: $(SRC_PATH)/qmp-commands.hx + $(call quiet-command,sh $(SRC_PATH)/hxtool -q < $< > $@," GEN $@") + +qemu-img-cmds.texi: $(SRC_PATH)/qemu-img-cmds.hx + $(call quiet-command,sh $(SRC_PATH)/hxtool -t < $< > $@," GEN $@") + +qemu.1: qemu-doc.texi qemu-options.texi qemu-monitor.texi + $(call quiet-command, \ + perl -Ww -- $(SRC_PATH)/texi2pod.pl $< qemu.pod && \ + pod2man --section=1 --center=" " --release=" " qemu.pod > $@, \ + " GEN $@") + +qemu-img.1: qemu-img.texi qemu-img-cmds.texi + $(call quiet-command, \ + perl -Ww -- $(SRC_PATH)/texi2pod.pl $< qemu-img.pod && \ + pod2man --section=1 --center=" " --release=" " qemu-img.pod > $@, \ + " GEN $@") + +qemu-nbd.8: qemu-nbd.texi + $(call quiet-command, \ + perl -Ww -- $(SRC_PATH)/texi2pod.pl $< qemu-nbd.pod && \ + pod2man --section=8 --center=" " --release=" " qemu-nbd.pod > $@, \ + " GEN $@") + +dvi: qemu-doc.dvi qemu-tech.dvi +html: qemu-doc.html qemu-tech.html +info: qemu-doc.info qemu-tech.info +pdf: qemu-doc.pdf qemu-tech.pdf + +qemu-doc.dvi qemu-doc.html qemu-doc.info qemu-doc.pdf: \ + qemu-img.texi qemu-nbd.texi qemu-options.texi \ + qemu-monitor.texi qemu-img-cmds.texi + +VERSION ?= $(shell cat VERSION) +FILE = qemu-$(VERSION) + +# tar release (use 'make -k tar' on a checkouted tree) +tar: + rm -rf /tmp/$(FILE) + cp -r . /tmp/$(FILE) + cd /tmp && tar zcvf ~/$(FILE).tar.gz $(FILE) --exclude CVS --exclude .git --exclude .svn + rm -rf /tmp/$(FILE) + +SYSTEM_TARGETS=$(filter %-softmmu,$(TARGET_DIRS)) +SYSTEM_PROGS=$(patsubst qemu-system-i386,qemu, \ + $(patsubst %-softmmu,qemu-system-%, \ + $(SYSTEM_TARGETS))) + +USER_TARGETS=$(filter %-user,$(TARGET_DIRS)) +USER_PROGS=$(patsubst %-bsd-user,qemu-%, \ + $(patsubst %-darwin-user,qemu-%, \ + $(patsubst %-linux-user,qemu-%, \ + $(USER_TARGETS)))) + +# generate a binary distribution +tarbin: + cd / && tar zcvf ~/qemu-$(VERSION)-$(ARCH).tar.gz \ + $(patsubst %,$(bindir)/%, $(SYSTEM_PROGS)) \ + $(patsubst %,$(bindir)/%, $(USER_PROGS)) \ + $(bindir)/qemu-img \ + $(bindir)/qemu-nbd \ + $(datadir)/bios.bin \ + $(datadir)/vgabios.bin \ + $(datadir)/vgabios-cirrus.bin \ + $(datadir)/ppc_rom.bin \ + $(datadir)/openbios-sparc32 \ + $(datadir)/openbios-sparc64 \ + $(datadir)/openbios-ppc \ + $(datadir)/pxe-ne2k_pci.bin \ + $(datadir)/pxe-rtl8139.bin \ + $(datadir)/pxe-pcnet.bin \ + $(datadir)/pxe-e1000.bin \ + $(docdir)/qemu-doc.html \ + $(docdir)/qemu-tech.html \ + $(mandir)/man1/qemu.1 \ + $(mandir)/man1/qemu-img.1 \ + $(mandir)/man8/qemu-nbd.8 + +# Include automatically generated dependency files +-include $(wildcard *.d audio/*.d slirp/*.d block/*.d net/*.d ui/*.d) diff --git a/configure b/configure index e560f87..ac7e220 100755 --- a/configure +++ b/configure @@ -500,14 +500,17 @@ fi # find source path source_path=`dirname "$0"` -source_path_used="no" workdir=`pwd` if [ -z "$source_path" ]; then source_path=$workdir else source_path=`cd "$source_path"; pwd` fi -[ -f "$workdir/vl.c" ] || source_path_used="yes" +if [ "$source_path" = "$workdir" ]; then + # Force object directory use + mkdir -p obj + cd obj +fi werror="" @@ -521,7 +524,6 @@ for opt do --interp-prefix=*) interp_prefix="$optarg" ;; --source-path=*) source_path="$optarg" - source_path_used="yes" ;; --cross-prefix=*) ;; @@ -3119,27 +3121,28 @@ echo "QEMU_CFLAGS+=$cflags" >> $config_target_mak done # for target in $targets # build tree in object directory if source path is different from current one -if test "$source_path_used" = "yes" ; then - DIRS="tests tests/cris slirp audio block net pc-bios/optionrom" - DIRS="$DIRS roms/seabios roms/vgabios" - DIRS="$DIRS fsdev ui" - FILES="Makefile tests/Makefile" - FILES="$FILES tests/cris/Makefile tests/cris/.gdbinit" - FILES="$FILES tests/test-mmap.c" - FILES="$FILES pc-bios/optionrom/Makefile pc-bios/keymaps" - FILES="$FILES roms/seabios/Makefile roms/vgabios/Makefile" - for bios_file in $source_path/pc-bios/*.bin $source_path/pc-bios/*.dtb $source_path/pc-bios/openbios-*; do - FILES="$FILES pc-bios/`basename $bios_file`" - done - for dir in $DIRS ; do - mkdir -p $dir - done - # remove the link and recreate it, as not all "ln -sf" overwrite the link - for f in $FILES ; do - rm -f $f - ln -s $source_path/$f $f - done -fi +DIRS="tests tests/cris slirp audio block net pc-bios/optionrom" +DIRS="$DIRS roms/seabios roms/vgabios" +DIRS="$DIRS fsdev ui" +FILES="tests/Makefile" +FILES="$FILES tests/cris/Makefile tests/cris/.gdbinit" +FILES="$FILES tests/test-mmap.c" +FILES="$FILES pc-bios/optionrom/Makefile pc-bios/keymaps" +FILES="$FILES roms/seabios/Makefile roms/vgabios/Makefile" +for bios_file in $source_path/pc-bios/*.bin $source_path/pc-bios/*.dtb $source_path/pc-bios/openbios-*; do + FILES="$FILES pc-bios/`basename $bios_file`" +done +for dir in $DIRS ; do + mkdir -p $dir +done + +ln -s $source_path/Makefile.top Makefile + +# remove the link and recreate it, as not all "ln -sf" overwrite the link +for f in $FILES ; do + rm -f $f + ln -s $source_path/$f $f +done # temporary config to build submodules for rom in seabios vgabios ; do -- 1.6.2.4 --0016e641dc6680179204954480c5 Content-Type: application/x-patch; name="0001-Force-object-directory-use.patch" Content-Disposition: attachment; filename="0001-Force-object-directory-use.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_ggmlbtq20 RnJvbSA0YTRmYmM4MGQ4ODJkOGE2MTM4ZTMwZTY3Mzk3NzM0ZmY0Nzg1OWE5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBCbHVlIFN3aXJsIDxibGF1d2lyYmVsQGdtYWlsLmNvbT4KRGF0 ZTogV2VkLCAxNyBOb3YgMjAxMCAxOToxMTo0OSArMDAwMApTdWJqZWN0OiBbUEFUQ0hdIEZvcmNl IG9iamVjdCBkaXJlY3RvcnkgdXNlCgpJZiB0aGUgdXNlciBhdHRlbXB0cyB0byBydW4gJ2NvbmZp Z3VyZScgaW4gdGhlIHNvdXJjZSB0cmVlLApjcmVhdGUgYW4gb2JqZWN0IGRpcmVjdG9yeSBhbmQg Y29uZmlndXJlIHRoYXQgaW5zdGVhZC4KClJlbmFtZSB0b3Btb3N0IE1ha2VmaWxlIHRvIE1ha2Vm aWxlLnRvcC4gQWRkIGEgbmV3IE1ha2VmaWxlLCB3aGljaAppcyBvbmx5IHVzZWQgd2hlbiB1c2Vy IGF0dGVtcHRzIHRvIHJ1biAnbWFrZScgaW4gdGhlIHNvdXJjZSB0cmVlLgoKU2lnbmVkLW9mZi1i eTogQmx1ZSBTd2lybCA8YmxhdXdpcmJlbEBnbWFpbC5jb20+Ci0tLQogTWFrZWZpbGUgICAgIHwg IDM3MyArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tCiBNYWtlZmlsZS50b3AgfCAgMzY3ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKwogY29uZmlndXJlICAgIHwgICA1MSArKysrLS0t LQogMyBmaWxlcyBjaGFuZ2VkLCA0MDAgaW5zZXJ0aW9ucygrKSwgMzkxIGRlbGV0aW9ucygtKQog Y3JlYXRlIG1vZGUgMTAwNjQ0IE1ha2VmaWxlLnRvcAoKZGlmZiAtLWdpdCBhL01ha2VmaWxlIGIv TWFrZWZpbGUKaW5kZXggNzQ3ZTQ3Yy4uNTYwMTZmYSAxMDA2NDQKLS0tIGEvTWFrZWZpbGUKKysr IGIvTWFrZWZpbGUKQEAgLTEsMzY3ICsxLDYgQEAKLSMgTWFrZWZpbGUgZm9yIFFFTVUuCi0KLUdF TkVSQVRFRF9IRUFERVJTID0gY29uZmlnLWhvc3QuaCB0cmFjZS5oIHFlbXUtb3B0aW9ucy5kZWYK LWlmZXEgKCQoVFJBQ0VfQkFDS0VORCksZHRyYWNlKQotR0VORVJBVEVEX0hFQURFUlMgKz0gdHJh Y2UtZHRyYWNlLmgKLWVuZGlmCi0KLWlmbmVxICgkKHdpbGRjYXJkIGNvbmZpZy1ob3N0Lm1hayks KQotIyBQdXQgdGhlIGFsbDogcnVsZSBoZXJlIHNvIHRoYXQgY29uZmlnLWhvc3QubWFrIGNhbiBj b250YWluIGRlcGVuZGVuY2llcy4KLWFsbDogYnVpbGQtYWxsCi1pbmNsdWRlIGNvbmZpZy1ob3N0 Lm1hawotaW5jbHVkZSAkKFNSQ19QQVRIKS9ydWxlcy5tYWsKLWNvbmZpZy1ob3N0Lm1hazogJChT UkNfUEFUSCkvY29uZmlndXJlCi0JQGVjaG8gJEAgaXMgb3V0LW9mLWRhdGUsIHJ1bm5pbmcgY29u ZmlndXJlCi0JQHNlZCAtbiAiLy4qQ29uZmlndXJlZCB3aXRoL3MvW146XSo6IC8vcCIgJEAgfCBz aAotZWxzZQotY29uZmlnLWhvc3QubWFrOgotCUBlY2hvICJQbGVhc2UgY2FsbCBjb25maWd1cmUg YmVmb3JlIHJ1bm5pbmcgbWFrZSEiCi0JQGV4aXQgMQotZW5kaWYKLQotIyBEb24ndCB0cnkgdG8g cmVnZW5lcmF0ZSBNYWtlZmlsZSBvciBjb25maWd1cmUKLSMgV2UgZG9uJ3QgZ2VuZXJhdGUgYW55 IG9mIHRoZW0KLU1ha2VmaWxlOiA7Ci1jb25maWd1cmU6IDsKLQotLlBIT05ZOiBhbGwgY2xlYW4g Y3Njb3BlIGRpc3RjbGVhbiBkdmkgaHRtbCBpbmZvIGluc3RhbGwgaW5zdGFsbC1kb2MgXAotCXBk ZiByZWN1cnNlLWFsbCBzcGVlZCB0YXIgdGFyYmluIHRlc3QgYnVpbGQtYWxsCi0KLSQoY2FsbCBz ZXQtdnBhdGgsICQoU1JDX1BBVEgpOiQoU1JDX1BBVEgpL2h3KQotCi1MSUJTKz0tbHogJChMSUJT X1RPT0xTKQotCi1pZmRlZiBCVUlMRF9ET0NTCi1ET0NTPXFlbXUtZG9jLmh0bWwgcWVtdS10ZWNo Lmh0bWwgcWVtdS4xIHFlbXUtaW1nLjEgcWVtdS1uYmQuOCBRTVAvcW1wLWNvbW1hbmRzLnR4dAot ZWxzZQotRE9DUz0KLWVuZGlmCi0KLVNVQkRJUl9NQUtFRkxBR1M9JChpZiAkKFYpLCwtLW5vLXBy aW50LWRpcmVjdG9yeSkKLVNVQkRJUl9ERVZJQ0VTX01BSz0kKHBhdHN1YnN0ICUsICUvY29uZmln LWRldmljZXMubWFrLCAkKFRBUkdFVF9ESVJTKSkKLQotY29uZmlnLWFsbC1kZXZpY2VzLm1hazog JChTVUJESVJfREVWSUNFU19NQUspCi0JJChjYWxsIHF1aWV0LWNvbW1hbmQsY2F0ICQoU1VCRElS X0RFVklDRVNfTUFLKSB8IGdyZXAgPXkgfCBzb3J0IC11ID4gJEAsIiAgR0VOICAgJEAiKQotCi0l L2NvbmZpZy1kZXZpY2VzLm1hazogZGVmYXVsdC1jb25maWdzLyUubWFrCi0JJChjYWxsIHF1aWV0 LWNvbW1hbmQsY2F0ICQ8ID4gJEAudG1wLCAiICBHRU4gICAkQCIpCi0JQGlmIHRlc3QgLWYgJEA7 IHRoZW4gXAotCSAgaWYgY21wIC1zICRALm9sZCAkQDsgdGhlbiBcCi0JICAgIGlmICEgY21wIC1z ICRAICRALnRtcDsgdGhlbiBcCi0JICAgICAgbXYgJEAudG1wICRAOyBcCi0JICAgICAgY3AgLXAg JEAgJEAub2xkOyBcCi0JICAgIGZpOyBcCi0JICBlbHNlIFwKLQkgICAgaWYgdGVzdCAtZiAkQC5v bGQ7IHRoZW4gXAotCSAgICAgIGVjaG8gIldBUk5JTkc6ICRAICh1c2VyIG1vZGlmaWVkKSBvdXQg b2YgZGF0ZS4iO1wKLQkgICAgZWxzZSBcCi0JICAgICAgZWNobyAiV0FSTklORzogJEAgb3V0IG9m IGRhdGUuIjtcCi0JICAgIGZpOyBcCi0JICAgIGVjaG8gIlJ1biBcIm1ha2UgZGVmY29uZmlnXCIg dG8gcmVnZW5lcmF0ZS4iOyBcCi0JICAgIHJtICRALnRtcDsgXAotCSAgZmk7IFwKLQkgZWxzZSBc Ci0JICBtdiAkQC50bXAgJEA7IFwKLQkgIGNwIC1wICRAICRALm9sZDsgXAotCSBmaQotCi1kZWZj b25maWc6Ci0Jcm0gLWYgY29uZmlnLWFsbC1kZXZpY2VzLm1hayAkKFNVQkRJUl9ERVZJQ0VTX01B SykKLQotLWluY2x1ZGUgY29uZmlnLWFsbC1kZXZpY2VzLm1hawotCi1idWlsZC1hbGw6ICQoRE9D UykgJChUT09MUykgcmVjdXJzZS1hbGwKLQotY29uZmlnLWhvc3QuaDogY29uZmlnLWhvc3QuaC10 aW1lc3RhbXAKLWNvbmZpZy1ob3N0LmgtdGltZXN0YW1wOiBjb25maWctaG9zdC5tYWsKLXFlbXUt b3B0aW9ucy5kZWY6ICQoU1JDX1BBVEgpL3FlbXUtb3B0aW9ucy5oeAotCSQoY2FsbCBxdWlldC1j b21tYW5kLHNoICQoU1JDX1BBVEgpL2h4dG9vbCAtaCA8ICQ8ID4gJEAsIiAgR0VOICAgJEAiKQot Ci1TVUJESVJfUlVMRVM9JChwYXRzdWJzdCAlLHN1YmRpci0lLCAkKFRBUkdFVF9ESVJTKSkKLQot c3ViZGlyLSU6ICQoR0VORVJBVEVEX0hFQURFUlMpCi0JJChjYWxsIHF1aWV0LWNvbW1hbmQsJChN QUtFKSAkKFNVQkRJUl9NQUtFRkxBR1MpIC1DICQqIFY9IiQoVikiIFRBUkdFVF9ESVI9IiQqLyIg YWxsLCkKLQotaWZuZXEgKCQod2lsZGNhcmQgY29uZmlnLWhvc3QubWFrKSwpCi1pbmNsdWRlICQo U1JDX1BBVEgpL01ha2VmaWxlLm9ianMKLWVuZGlmCi0KLSQoY29tbW9uLW9iai15KTogJChHRU5F UkFURURfSEVBREVSUykKLSQoZmlsdGVyICUtc29mdG1tdSwkKFNVQkRJUl9SVUxFUykpOiAkKHRy YWNlLW9iai15KSAkKGNvbW1vbi1vYmoteSkgc3ViZGlyLWxpYmRpcwotCi0kKGZpbHRlciAlLXVz ZXIsJChTVUJESVJfUlVMRVMpKTogJChHRU5FUkFURURfSEVBREVSUykgJCh0cmFjZS1vYmoteSkg c3ViZGlyLWxpYmRpcy11c2VyIHN1YmRpci1saWJ1c2VyCi0KLVJPTVNVQkRJUl9SVUxFUz0kKHBh dHN1YnN0ICUscm9tc3ViZGlyLSUsICQoUk9NUykpCi1yb21zdWJkaXItJToKLQkkKGNhbGwgcXVp ZXQtY29tbWFuZCwkKE1BS0UpICQoU1VCRElSX01BS0VGTEFHUykgLUMgcGMtYmlvcy8kKiBWPSIk KFYpIiBUQVJHRVRfRElSPSIkKi8iLCkKLQotQUxMX1NVQkRJUlM9JChUQVJHRVRfRElSUykgJChw YXRzdWJzdCAlLHBjLWJpb3MvJSwgJChST01TKSkKLQotcmVjdXJzZS1hbGw6ICQoU1VCRElSX1JV TEVTKSAkKFJPTVNVQkRJUl9SVUxFUykKLQotYXVkaW8vYXVkaW8ubyBhdWRpby9mbW9kYXVkaW8u bzogUUVNVV9DRkxBR1MgKz0gJChGTU9EX0NGTEFHUykKLQotUUVNVV9DRkxBR1MrPSQoQ1VSTF9D RkxBR1MpCi0KLXVpL2NvY29hLm86IHVpL2NvY29hLm0KLQotdWkvc2RsLm8gYXVkaW8vc2RsYXVk aW8ubyB1aS9zZGxfem9vbS5vIGJhdW0ubzogUUVNVV9DRkxBR1MgKz0gJChTRExfQ0ZMQUdTKQot Ci11aS92bmMubzogUUVNVV9DRkxBR1MgKz0gJChWTkNfVExTX0NGTEFHUykKLQotYnQtaG9zdC5v OiBRRU1VX0NGTEFHUyArPSAkKEJMVUVaX0NGTEFHUykKLQotaWZlcSAoJChUUkFDRV9CQUNLRU5E KSxkdHJhY2UpCi10cmFjZS5oOiB0cmFjZS5oLXRpbWVzdGFtcCB0cmFjZS1kdHJhY2UuaAotZWxz ZQotdHJhY2UuaDogdHJhY2UuaC10aW1lc3RhbXAKLWVuZGlmCi10cmFjZS5oLXRpbWVzdGFtcDog JChTUkNfUEFUSCkvdHJhY2UtZXZlbnRzIGNvbmZpZy1ob3N0Lm1hawotCSQoY2FsbCBxdWlldC1j b21tYW5kLHNoICQoU1JDX1BBVEgpL3RyYWNldG9vbCAtLSQoVFJBQ0VfQkFDS0VORCkgLWggPCAk PCA+ICRALCIgIEdFTiAgIHRyYWNlLmgiKQotCUBjbXAgLXMgJEAgdHJhY2UuaCB8fCBjcCAkQCB0 cmFjZS5oCi0KLXRyYWNlLmM6IHRyYWNlLmMtdGltZXN0YW1wCi10cmFjZS5jLXRpbWVzdGFtcDog JChTUkNfUEFUSCkvdHJhY2UtZXZlbnRzIGNvbmZpZy1ob3N0Lm1hawotCSQoY2FsbCBxdWlldC1j b21tYW5kLHNoICQoU1JDX1BBVEgpL3RyYWNldG9vbCAtLSQoVFJBQ0VfQkFDS0VORCkgLWMgPCAk PCA+ICRALCIgIEdFTiAgIHRyYWNlLmMiKQotCUBjbXAgLXMgJEAgdHJhY2UuYyB8fCBjcCAkQCB0 cmFjZS5jCi0KLXRyYWNlLm86IHRyYWNlLmMgJChHRU5FUkFURURfSEVBREVSUykKLQotdHJhY2Ut ZHRyYWNlLmg6IHRyYWNlLWR0cmFjZS5kdHJhY2UKLQkkKGNhbGwgcXVpZXQtY29tbWFuZCxkdHJh Y2UgLW8gJEAgLWggLXMgJDwsICIgIEdFTiAgIHRyYWNlLWR0cmFjZS5oIikKLQotIyBOb3JtYWwg cHJhY3RpY2UgaXMgdG8gbmFtZSBEVHJhY2UgcHJvYmUgZmlsZSB3aXRoIGEgJy5kJyBleHRlbnNp b24KLSMgYnV0IHRoYXQgZ2V0cyBwaWNrZWQgdXAgYnkgUUVNVSdzIE1ha2VmaWxlIGFzIGFuIGV4 dGVybmFsIGRlcGVuZGFuY3kKLSMgcnVsZSBmaWxlLiBTbyB3ZSB1c2UgJy5kdHJhY2UnIGluc3Rl YWQKLXRyYWNlLWR0cmFjZS5kdHJhY2U6IHRyYWNlLWR0cmFjZS5kdHJhY2UtdGltZXN0YW1wCi10 cmFjZS1kdHJhY2UuZHRyYWNlLXRpbWVzdGFtcDogJChTUkNfUEFUSCkvdHJhY2UtZXZlbnRzIGNv bmZpZy1ob3N0Lm1hawotCSQoY2FsbCBxdWlldC1jb21tYW5kLHNoICQoU1JDX1BBVEgpL3RyYWNl dG9vbCAtLSQoVFJBQ0VfQkFDS0VORCkgLWQgPCAkPCA+ICRALCIgIEdFTiAgIHRyYWNlLWR0cmFj ZS5kdHJhY2UiKQotCUBjbXAgLXMgJEAgdHJhY2UtZHRyYWNlLmR0cmFjZSB8fCBjcCAkQCB0cmFj ZS1kdHJhY2UuZHRyYWNlCi0KLXRyYWNlLWR0cmFjZS5vOiB0cmFjZS1kdHJhY2UuZHRyYWNlICQo R0VORVJBVEVEX0hFQURFUlMpCi0JJChjYWxsIHF1aWV0LWNvbW1hbmQsZHRyYWNlIC1vICRAIC1H IC1zICQ8LCAiICBHRU4gdHJhY2UtZHRyYWNlLm8iKQotCi1zaW1wbGV0cmFjZS5vOiBzaW1wbGV0 cmFjZS5jICQoR0VORVJBVEVEX0hFQURFUlMpCi0KLXZlcnNpb24ubzogJChTUkNfUEFUSCkvdmVy c2lvbi5yYyBjb25maWctaG9zdC5tYWsKLQkkKGNhbGwgcXVpZXQtY29tbWFuZCwkKFdJTkRSRVMp IC1JLiAtbyAkQCAkPCwiICBSQyAgICAkKFRBUkdFVF9ESVIpJEAiKQotCi12ZXJzaW9uLW9iai0k KENPTkZJR19XSU4zMikgKz0gdmVyc2lvbi5vCi0jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMj IyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0KLXFlbXUtaW1nLm86 IHFlbXUtaW1nLWNtZHMuaAotcWVtdS1pbWcubyBxZW11LXRvb2wubyBxZW11LW5iZC5vIHFlbXUt aW8ubzogJChHRU5FUkFURURfSEVBREVSUykKLQotcWVtdS1pbWckKEVYRVNVRik6IHFlbXUtaW1n Lm8gcWVtdS10b29sLm8gcWVtdS1lcnJvci5vICQob3NsaWItb2JqLXkpICQodHJhY2Utb2JqLXkp ICQoYmxvY2stb2JqLXkpICQocW9iamVjdC1vYmoteSkgJCh2ZXJzaW9uLW9iai15KSBxZW11LXRp bWVyLWNvbW1vbi5vCi0KLXFlbXUtbmJkJChFWEVTVUYpOiBxZW11LW5iZC5vIHFlbXUtdG9vbC5v IHFlbXUtZXJyb3IubyAkKG9zbGliLW9iai15KSAkKHRyYWNlLW9iai15KSAkKGJsb2NrLW9iai15 KSAkKHFvYmplY3Qtb2JqLXkpICQodmVyc2lvbi1vYmoteSkgcWVtdS10aW1lci1jb21tb24ubwot Ci1xZW11LWlvJChFWEVTVUYpOiBxZW11LWlvLm8gY21kLm8gcWVtdS10b29sLm8gcWVtdS1lcnJv ci5vICQob3NsaWItb2JqLXkpICQodHJhY2Utb2JqLXkpICQoYmxvY2stb2JqLXkpICQocW9iamVj dC1vYmoteSkgJCh2ZXJzaW9uLW9iai15KSBxZW11LXRpbWVyLWNvbW1vbi5vCi0KLXFlbXUtaW1n LWNtZHMuaDogJChTUkNfUEFUSCkvcWVtdS1pbWctY21kcy5oeAotCSQoY2FsbCBxdWlldC1jb21t YW5kLHNoICQoU1JDX1BBVEgpL2h4dG9vbCAtaCA8ICQ8ID4gJEAsIiAgR0VOICAgJEAiKQotCi1j aGVjay1xaW50Lm8gY2hlY2stcXN0cmluZy5vIGNoZWNrLXFkaWN0Lm8gY2hlY2stcWxpc3QubyBj aGVjay1xZmxvYXQubyBjaGVjay1xanNvbi5vOiAkKEdFTkVSQVRFRF9IRUFERVJTKQotCi1jaGVj ay1xaW50OiBjaGVjay1xaW50Lm8gcWludC5vIHFlbXUtbWFsbG9jLm8gJCh0cmFjZS1vYmoteSkK LWNoZWNrLXFzdHJpbmc6IGNoZWNrLXFzdHJpbmcubyBxc3RyaW5nLm8gcWVtdS1tYWxsb2MubyAk KHRyYWNlLW9iai15KQotY2hlY2stcWRpY3Q6IGNoZWNrLXFkaWN0Lm8gcWRpY3QubyBxZmxvYXQu byBxaW50Lm8gcXN0cmluZy5vIHFib29sLm8gcWVtdS1tYWxsb2MubyBxbGlzdC5vICQodHJhY2Ut b2JqLXkpCi1jaGVjay1xbGlzdDogY2hlY2stcWxpc3QubyBxbGlzdC5vIHFpbnQubyBxZW11LW1h bGxvYy5vICQodHJhY2Utb2JqLXkpCi1jaGVjay1xZmxvYXQ6IGNoZWNrLXFmbG9hdC5vIHFmbG9h dC5vIHFlbXUtbWFsbG9jLm8gJCh0cmFjZS1vYmoteSkKLWNoZWNrLXFqc29uOiBjaGVjay1xanNv bi5vIHFmbG9hdC5vIHFpbnQubyBxZGljdC5vIHFzdHJpbmcubyBxbGlzdC5vIHFib29sLm8gcWpz b24ubyBqc29uLXN0cmVhbWVyLm8ganNvbi1sZXhlci5vIGpzb24tcGFyc2VyLm8gcWVtdS1tYWxs b2MubyAkKHRyYWNlLW9iai15KQotCi1jbGVhbjoKLSMgYXZvaWQgb2xkIGJ1aWxkIHByb2JsZW1z IGJ5IHJlbW92aW5nIHBvdGVudGlhbGx5IGluY29ycmVjdCBvbGQgZmlsZXMKLQlybSAtZiBjb25m aWcubWFrIG9wLWkzODYuaCBvcGMtaTM4Ni5oIGdlbi1vcC1pMzg2Lmggb3AtYXJtLmggb3BjLWFy bS5oIGdlbi1vcC1hcm0uaAotCXJtIC1mIHFlbXUtb3B0aW9ucy5kZWYKLQlybSAtZiAqLm8gKi5k ICouYSAkKFRPT0xTKSBUQUdTIGNzY29wZS4qICoucG9kICp+ICovKn4KLQlybSAtZiBzbGlycC8q Lm8gc2xpcnAvKi5kIGF1ZGlvLyoubyBhdWRpby8qLmQgYmxvY2svKi5vIGJsb2NrLyouZCBuZXQv Ki5vIG5ldC8qLmQgZnNkZXYvKi5vIGZzZGV2LyouZCB1aS8qLm8gdWkvKi5kCi0Jcm0gLWYgcWVt dS1pbWctY21kcy5oCi0Jcm0gLWYgdHJhY2UuYyB0cmFjZS5oIHRyYWNlLmMtdGltZXN0YW1wIHRy YWNlLmgtdGltZXN0YW1wCi0Jcm0gLWYgdHJhY2UtZHRyYWNlLmR0cmFjZSB0cmFjZS1kdHJhY2Uu ZHRyYWNlLXRpbWVzdGFtcAotCXJtIC1mIHRyYWNlLWR0cmFjZS5oIHRyYWNlLWR0cmFjZS5oLXRp bWVzdGFtcAotCSQoTUFLRSkgLUMgdGVzdHMgY2xlYW4KLQlmb3IgZCBpbiAkKEFMTF9TVUJESVJT KSBsaWJodzMyIGxpYmh3NjQgbGlidXNlciBsaWJkaXMgbGliZGlzLXVzZXI7IGRvIFwKLQlpZiB0 ZXN0IC1kICQkZDsgdGhlbiAkKE1BS0UpIC1DICQkZCAkQCB8fCBleGl0IDE7IGZpOyBcCi0Jcm0g LWYgJCRkL3FlbXUtb3B0aW9ucy5kZWY7IFwKLSAgICAgICAgZG9uZQotCi1kaXN0Y2xlYW46IGNs ZWFuCi0Jcm0gLWYgY29uZmlnLWhvc3QubWFrIGNvbmZpZy1ob3N0LmgqIGNvbmZpZy1ob3N0Lmxk ICQoRE9DUykgcWVtdS1vcHRpb25zLnRleGkgcWVtdS1pbWctY21kcy50ZXhpIHFlbXUtbW9uaXRv ci50ZXhpCi0Jcm0gLWYgY29uZmlnLWFsbC1kZXZpY2VzLm1hawotCXJtIC1mIHJvbXMvc2VhYmlv cy9jb25maWcubWFrIHJvbXMvdmdhYmlvcy9jb25maWcubWFrCi0Jcm0gLWYgcWVtdS1kb2MuaW5m byBxZW11LWRvYy5hdXggcWVtdS1kb2MuY3AgcWVtdS1kb2MuZHZpIHFlbXUtZG9jLmZuIHFlbXUt ZG9jLmluZm8gcWVtdS1kb2Mua3kgcWVtdS1kb2MubG9nIHFlbXUtZG9jLnBkZiBxZW11LWRvYy5w ZyBxZW11LWRvYy50b2MgcWVtdS1kb2MudHAgcWVtdS1kb2MudnIKLQlybSAtZiBxZW11LXRlY2gu aW5mbyBxZW11LXRlY2guYXV4IHFlbXUtdGVjaC5jcCBxZW11LXRlY2guZHZpIHFlbXUtdGVjaC5m biBxZW11LXRlY2guaW5mbyBxZW11LXRlY2gua3kgcWVtdS10ZWNoLmxvZyBxZW11LXRlY2gucGRm IHFlbXUtdGVjaC5wZyBxZW11LXRlY2gudG9jIHFlbXUtdGVjaC50cCBxZW11LXRlY2gudnIKLQlm b3IgZCBpbiAkKFRBUkdFVF9ESVJTKSBsaWJodzMyIGxpYmh3NjQgbGlidXNlciBsaWJkaXMgbGli ZGlzLXVzZXI7IGRvIFwKLQlybSAtcmYgJCRkIHx8IGV4aXQgMSA7IFwKLSAgICAgICAgZG9uZQot Ci1LRVlNQVBTPWRhICAgICBlbi1nYiAgZXQgIGZyICAgICBmci1jaCAgaXMgIGx0ICBtb2RpZmll cnMgIG5vICBwdC1iciAgc3YgXAotYXIgICAgICBkZSAgICAgZW4tdXMgIGZpICBmci1iZSAgaHIg ICAgIGl0ICBsdiAgbmwgICAgICAgICBwbCAgcnUgICAgIHRoIFwKLWNvbW1vbiAgZGUtY2ggIGVz ICAgICBmbyAgZnItY2EgIGh1ICAgICBqYSAgbWsgIG5sLWJlICAgICAgcHQgIHNsICAgICB0cgot Ci1pZmRlZiBJTlNUQUxMX0JMT0JTCi1CTE9CUz1iaW9zLmJpbiB2Z2FiaW9zLmJpbiB2Z2FiaW9z LWNpcnJ1cy5iaW4gXAotdmdhYmlvcy1zdGR2Z2EuYmluIHZnYWJpb3Mtdm13YXJlLmJpbiBcCi1w cGNfcm9tLmJpbiBvcGVuYmlvcy1zcGFyYzMyIG9wZW5iaW9zLXNwYXJjNjQgb3BlbmJpb3MtcHBj IFwKLWdweGUtZWVwcm8xMDAtODA4NjEyMDkucm9tIFwKLWdweGUtZWVwcm8xMDAtODA4NjEyMjku cm9tIFwKLXB4ZS1lMTAwMC5iaW4gXAotcHhlLW5lMmtfcGNpLmJpbiBweGUtcGNuZXQuYmluIFwK LXB4ZS1ydGw4MTM5LmJpbiBweGUtdmlydGlvLmJpbiBcCi1iYW1ib28uZHRiIHBldGFsb2dpeC1z M2Fkc3AxODAwLmR0YiBcCi1tdWx0aWJvb3QuYmluIGxpbnV4Ym9vdC5iaW4gXAotczM5MC16aXBs LnJvbQotZWxzZQotQkxPQlM9Ci1lbmRpZgotCi1pbnN0YWxsLWRvYzogJChET0NTKQotCSQoSU5T VEFMTF9ESVIpICIkKERFU1RESVIpJChkb2NkaXIpIgotCSQoSU5TVEFMTF9EQVRBKSBxZW11LWRv Yy5odG1sICBxZW11LXRlY2guaHRtbCAiJChERVNURElSKSQoZG9jZGlyKSIKLWlmZGVmIENPTkZJ R19QT1NJWAotCSQoSU5TVEFMTF9ESVIpICIkKERFU1RESVIpJChtYW5kaXIpL21hbjEiCi0JJChJ TlNUQUxMX0RBVEEpIHFlbXUuMSBxZW11LWltZy4xICIkKERFU1RESVIpJChtYW5kaXIpL21hbjEi Ci0JJChJTlNUQUxMX0RJUikgIiQoREVTVERJUikkKG1hbmRpcikvbWFuOCIKLQkkKElOU1RBTExf REFUQSkgcWVtdS1uYmQuOCAiJChERVNURElSKSQobWFuZGlyKS9tYW44IgotZW5kaWYKLQotaW5z dGFsbC1zeXNjb25maWc6Ci0JJChJTlNUQUxMX0RJUikgIiQoREVTVERJUikkKHN5c2NvbmZkaXIp L3FlbXUiCi0JJChJTlNUQUxMX0RBVEEpICQoU1JDX1BBVEgpL3N5c2NvbmZpZ3MvdGFyZ2V0L3Rh cmdldC14ODZfNjQuY29uZiAiJChERVNURElSKSQoc3lzY29uZmRpcikvcWVtdSIKLQotaW5zdGFs bDogYWxsICQoaWYgJChCVUlMRF9ET0NTKSxpbnN0YWxsLWRvYykgaW5zdGFsbC1zeXNjb25maWcK LQkkKElOU1RBTExfRElSKSAiJChERVNURElSKSQoYmluZGlyKSIKLWlmbmVxICgkKFRPT0xTKSwp Ci0JJChJTlNUQUxMX1BST0cpICQoU1RSSVBfT1BUKSAkKFRPT0xTKSAiJChERVNURElSKSQoYmlu ZGlyKSIKLWVuZGlmCi1pZm5lcSAoJChCTE9CUyksKQotCSQoSU5TVEFMTF9ESVIpICIkKERFU1RE SVIpJChkYXRhZGlyKSIKLQlzZXQgLWU7IGZvciB4IGluICQoQkxPQlMpOyBkbyBcCi0JCSQoSU5T VEFMTF9EQVRBKSAkKFNSQ19QQVRIKS9wYy1iaW9zLyQkeCAiJChERVNURElSKSQoZGF0YWRpciki OyBcCi0JZG9uZQotZW5kaWYKLQkkKElOU1RBTExfRElSKSAiJChERVNURElSKSQoZGF0YWRpcikv a2V5bWFwcyIKLQlzZXQgLWU7IGZvciB4IGluICQoS0VZTUFQUyk7IGRvIFwKLQkJJChJTlNUQUxM X0RBVEEpICQoU1JDX1BBVEgpL3BjLWJpb3Mva2V5bWFwcy8kJHggIiQoREVTVERJUikkKGRhdGFk aXIpL2tleW1hcHMiOyBcCi0JZG9uZQotCWZvciBkIGluICQoVEFSR0VUX0RJUlMpOyBkbyBcCi0J JChNQUtFKSAtQyAkJGQgJEAgfHwgZXhpdCAxIDsgXAotICAgICAgICBkb25lCi0KLSMgdmFyaW91 cyB0ZXN0IHRhcmdldHMKLXRlc3Qgc3BlZWQ6IGFsbAotCSQoTUFLRSkgLUMgdGVzdHMgJEAKLQot LlBIT05ZOiBUQUdTCi1UQUdTOgotCWZpbmQgIiQoU1JDX1BBVEgpIiAtbmFtZSAnKi5baGNdJyAt cHJpbnQwIHwgeGFyZ3MgLTAgZXRhZ3MKLQotY3Njb3BlOgotCXJtIC1mIC4vY3Njb3BlLioKLQlm aW5kIC4gLW5hbWUgIiouW2NoXSIgLXByaW50IHwgc2VkICdzLF5cLi8sLCcgPiAuL2NzY29wZS5m aWxlcwotCWNzY29wZSAtYgotCi0jIGRvY3VtZW50YXRpb24KLU1BS0VJTkZPPW1ha2VpbmZvCi1N QUtFSU5GT0ZMQUdTPS0tbm8taGVhZGVycyAtLW5vLXNwbGl0IC0tbnVtYmVyLXNlY3Rpb25zCi1U RVhJRkxBRz0kKGlmICQoViksLC0tcXVpZXQpCi0lLmR2aTogJS50ZXhpCi0JJChjYWxsIHF1aWV0 LWNvbW1hbmQsdGV4aTJkdmkgJChURVhJRkxBRykgLUkgLiAkPCwiICBHRU4gICAkQCIpCi0KLSUu aHRtbDogJS50ZXhpCi0JJChjYWxsIHF1aWV0LWNvbW1hbmQsJChNQUtFSU5GTykgJChNQUtFSU5G T0ZMQUdTKSAtLWh0bWwgJDwgLW8gJEAsIFwKLQkiICBHRU4gICAkQCIpCi0KLSUuaW5mbzogJS50 ZXhpCi0JJChjYWxsIHF1aWV0LWNvbW1hbmQsJChNQUtFSU5GTykgJDwgLW8gJEAsIiAgR0VOICAg JEAiKQotCi0lLnBkZjogJS50ZXhpCi0JJChjYWxsIHF1aWV0LWNvbW1hbmQsdGV4aTJwZGYgJChU RVhJRkxBRykgLUkgLiAkPCwiICBHRU4gICAkQCIpCi0KLXFlbXUtb3B0aW9ucy50ZXhpOiAkKFNS Q19QQVRIKS9xZW11LW9wdGlvbnMuaHgKLQkkKGNhbGwgcXVpZXQtY29tbWFuZCxzaCAkKFNSQ19Q QVRIKS9oeHRvb2wgLXQgPCAkPCA+ICRALCIgIEdFTiAgICRAIikKLQotcWVtdS1tb25pdG9yLnRl eGk6ICQoU1JDX1BBVEgpL2htcC1jb21tYW5kcy5oeAotCSQoY2FsbCBxdWlldC1jb21tYW5kLHNo ICQoU1JDX1BBVEgpL2h4dG9vbCAtdCA8ICQ8ID4gJEAsIiAgR0VOICAgJEAiKQotCi1RTVAvcW1w LWNvbW1hbmRzLnR4dDogJChTUkNfUEFUSCkvcW1wLWNvbW1hbmRzLmh4Ci0JJChjYWxsIHF1aWV0 LWNvbW1hbmQsc2ggJChTUkNfUEFUSCkvaHh0b29sIC1xIDwgJDwgPiAkQCwiICBHRU4gICAkQCIp Ci0KLXFlbXUtaW1nLWNtZHMudGV4aTogJChTUkNfUEFUSCkvcWVtdS1pbWctY21kcy5oeAotCSQo Y2FsbCBxdWlldC1jb21tYW5kLHNoICQoU1JDX1BBVEgpL2h4dG9vbCAtdCA8ICQ8ID4gJEAsIiAg R0VOICAgJEAiKQotCi1xZW11LjE6IHFlbXUtZG9jLnRleGkgcWVtdS1vcHRpb25zLnRleGkgcWVt dS1tb25pdG9yLnRleGkKLQkkKGNhbGwgcXVpZXQtY29tbWFuZCwgXAotCSAgcGVybCAtV3cgLS0g JChTUkNfUEFUSCkvdGV4aTJwb2QucGwgJDwgcWVtdS5wb2QgJiYgXAotCSAgcG9kMm1hbiAtLXNl Y3Rpb249MSAtLWNlbnRlcj0iICIgLS1yZWxlYXNlPSIgIiBxZW11LnBvZCA+ICRALCBcCi0JICAi ICBHRU4gICAkQCIpCi0KLXFlbXUtaW1nLjE6IHFlbXUtaW1nLnRleGkgcWVtdS1pbWctY21kcy50 ZXhpCi0JJChjYWxsIHF1aWV0LWNvbW1hbmQsIFwKLQkgIHBlcmwgLVd3IC0tICQoU1JDX1BBVEgp L3RleGkycG9kLnBsICQ8IHFlbXUtaW1nLnBvZCAmJiBcCi0JICBwb2QybWFuIC0tc2VjdGlvbj0x IC0tY2VudGVyPSIgIiAtLXJlbGVhc2U9IiAiIHFlbXUtaW1nLnBvZCA+ICRALCBcCi0JICAiICBH RU4gICAkQCIpCi0KLXFlbXUtbmJkLjg6IHFlbXUtbmJkLnRleGkKLQkkKGNhbGwgcXVpZXQtY29t bWFuZCwgXAotCSAgcGVybCAtV3cgLS0gJChTUkNfUEFUSCkvdGV4aTJwb2QucGwgJDwgcWVtdS1u YmQucG9kICYmIFwKLQkgIHBvZDJtYW4gLS1zZWN0aW9uPTggLS1jZW50ZXI9IiAiIC0tcmVsZWFz ZT0iICIgcWVtdS1uYmQucG9kID4gJEAsIFwKLQkgICIgIEdFTiAgICRAIikKLQotZHZpOiBxZW11 LWRvYy5kdmkgcWVtdS10ZWNoLmR2aQotaHRtbDogcWVtdS1kb2MuaHRtbCBxZW11LXRlY2guaHRt bAotaW5mbzogcWVtdS1kb2MuaW5mbyBxZW11LXRlY2guaW5mbwotcGRmOiBxZW11LWRvYy5wZGYg cWVtdS10ZWNoLnBkZgotCi1xZW11LWRvYy5kdmkgcWVtdS1kb2MuaHRtbCBxZW11LWRvYy5pbmZv IHFlbXUtZG9jLnBkZjogXAotCXFlbXUtaW1nLnRleGkgcWVtdS1uYmQudGV4aSBxZW11LW9wdGlv bnMudGV4aSBcCi0JcWVtdS1tb25pdG9yLnRleGkgcWVtdS1pbWctY21kcy50ZXhpCi0KLVZFUlNJ T04gPz0gJChzaGVsbCBjYXQgVkVSU0lPTikKLUZJTEUgPSBxZW11LSQoVkVSU0lPTikKLQotIyB0 YXIgcmVsZWFzZSAodXNlICdtYWtlIC1rIHRhcicgb24gYSBjaGVja291dGVkIHRyZWUpCi10YXI6 Ci0Jcm0gLXJmIC90bXAvJChGSUxFKQotCWNwIC1yIC4gL3RtcC8kKEZJTEUpCi0JY2QgL3RtcCAm JiB0YXIgemN2ZiB+LyQoRklMRSkudGFyLmd6ICQoRklMRSkgLS1leGNsdWRlIENWUyAtLWV4Y2x1 ZGUgLmdpdCAtLWV4Y2x1ZGUgLnN2bgotCXJtIC1yZiAvdG1wLyQoRklMRSkKLQotU1lTVEVNX1RB UkdFVFM9JChmaWx0ZXIgJS1zb2Z0bW11LCQoVEFSR0VUX0RJUlMpKQotU1lTVEVNX1BST0dTPSQo cGF0c3Vic3QgcWVtdS1zeXN0ZW0taTM4NixxZW11LCBcCi0gICAgICAgICAgICAgJChwYXRzdWJz dCAlLXNvZnRtbXUscWVtdS1zeXN0ZW0tJSwgXAotICAgICAgICAgICAgICQoU1lTVEVNX1RBUkdF VFMpKSkKLQotVVNFUl9UQVJHRVRTPSQoZmlsdGVyICUtdXNlciwkKFRBUkdFVF9ESVJTKSkKLVVT RVJfUFJPR1M9JChwYXRzdWJzdCAlLWJzZC11c2VyLHFlbXUtJSwgXAotICAgICAgICAgICAkKHBh dHN1YnN0ICUtZGFyd2luLXVzZXIscWVtdS0lLCBcCi0gICAgICAgICAgICQocGF0c3Vic3QgJS1s aW51eC11c2VyLHFlbXUtJSwgXAotICAgICAgICAgICAkKFVTRVJfVEFSR0VUUykpKSkKLQotIyBn ZW5lcmF0ZSBhIGJpbmFyeSBkaXN0cmlidXRpb24KLXRhcmJpbjoKLQljZCAvICYmIHRhciB6Y3Zm IH4vcWVtdS0kKFZFUlNJT04pLSQoQVJDSCkudGFyLmd6IFwKLQkkKHBhdHN1YnN0ICUsJChiaW5k aXIpLyUsICQoU1lTVEVNX1BST0dTKSkgXAotCSQocGF0c3Vic3QgJSwkKGJpbmRpcikvJSwgJChV U0VSX1BST0dTKSkgXAotCSQoYmluZGlyKS9xZW11LWltZyBcCi0JJChiaW5kaXIpL3FlbXUtbmJk IFwKLQkkKGRhdGFkaXIpL2Jpb3MuYmluIFwKLQkkKGRhdGFkaXIpL3ZnYWJpb3MuYmluIFwKLQkk KGRhdGFkaXIpL3ZnYWJpb3MtY2lycnVzLmJpbiBcCi0JJChkYXRhZGlyKS9wcGNfcm9tLmJpbiBc Ci0JJChkYXRhZGlyKS9vcGVuYmlvcy1zcGFyYzMyIFwKLQkkKGRhdGFkaXIpL29wZW5iaW9zLXNw YXJjNjQgXAotCSQoZGF0YWRpcikvb3BlbmJpb3MtcHBjIFwKLQkkKGRhdGFkaXIpL3B4ZS1uZTJr X3BjaS5iaW4gXAotCSQoZGF0YWRpcikvcHhlLXJ0bDgxMzkuYmluIFwKLQkkKGRhdGFkaXIpL3B4 ZS1wY25ldC5iaW4gXAotCSQoZGF0YWRpcikvcHhlLWUxMDAwLmJpbiBcCi0JJChkb2NkaXIpL3Fl bXUtZG9jLmh0bWwgXAotCSQoZG9jZGlyKS9xZW11LXRlY2guaHRtbCBcCi0JJChtYW5kaXIpL21h bjEvcWVtdS4xIFwKLQkkKG1hbmRpcikvbWFuMS9xZW11LWltZy4xIFwKLQkkKG1hbmRpcikvbWFu OC9xZW11LW5iZC44Ci0KLSMgSW5jbHVkZSBhdXRvbWF0aWNhbGx5IGdlbmVyYXRlZCBkZXBlbmRl bmN5IGZpbGVzCi0taW5jbHVkZSAkKHdpbGRjYXJkICouZCBhdWRpby8qLmQgc2xpcnAvKi5kIGJs b2NrLyouZCBuZXQvKi5kIHVpLyouZCkKK2FsbCBjbGVhbiBkaXN0Y2xlYW4gZGVmY29uZmlnIGlu c3RhbGwgaW5zdGFsbC1kb2MgaW5zdGFsbC1zeXNjb25maWcgdGVzdCBzcGVlZCBUQUdTIGNzY29w ZSB0YXIgdGFyYmluOgorCUBpZiAhIHRlc3QgLWQgb2JqOyB0aGVuIFwKKwkgIGVjaG8gIlBsZWFz ZSBjYWxsICdjb25maWd1cmUnIGJlZm9yZSBydW5uaW5nICdtYWtlJyI7IFwKKwllbHNlIFwKKwkg ICQoTUFLRSkgLUMgb2JqICRAOyBcCisJZmkKZGlmZiAtLWdpdCBhL01ha2VmaWxlLnRvcCBiL01h a2VmaWxlLnRvcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43NDdlNDdjCi0t LSAvZGV2L251bGwKKysrIGIvTWFrZWZpbGUudG9wCkBAIC0wLDAgKzEsMzY3IEBACisjIE1ha2Vm aWxlIGZvciBRRU1VLgorCitHRU5FUkFURURfSEVBREVSUyA9IGNvbmZpZy1ob3N0LmggdHJhY2Uu aCBxZW11LW9wdGlvbnMuZGVmCitpZmVxICgkKFRSQUNFX0JBQ0tFTkQpLGR0cmFjZSkKK0dFTkVS QVRFRF9IRUFERVJTICs9IHRyYWNlLWR0cmFjZS5oCitlbmRpZgorCitpZm5lcSAoJCh3aWxkY2Fy ZCBjb25maWctaG9zdC5tYWspLCkKKyMgUHV0IHRoZSBhbGw6IHJ1bGUgaGVyZSBzbyB0aGF0IGNv bmZpZy1ob3N0Lm1hayBjYW4gY29udGFpbiBkZXBlbmRlbmNpZXMuCithbGw6IGJ1aWxkLWFsbAor aW5jbHVkZSBjb25maWctaG9zdC5tYWsKK2luY2x1ZGUgJChTUkNfUEFUSCkvcnVsZXMubWFrCitj b25maWctaG9zdC5tYWs6ICQoU1JDX1BBVEgpL2NvbmZpZ3VyZQorCUBlY2hvICRAIGlzIG91dC1v Zi1kYXRlLCBydW5uaW5nIGNvbmZpZ3VyZQorCUBzZWQgLW4gIi8uKkNvbmZpZ3VyZWQgd2l0aC9z L1teOl0qOiAvL3AiICRAIHwgc2gKK2Vsc2UKK2NvbmZpZy1ob3N0Lm1hazoKKwlAZWNobyAiUGxl YXNlIGNhbGwgY29uZmlndXJlIGJlZm9yZSBydW5uaW5nIG1ha2UhIgorCUBleGl0IDEKK2VuZGlm CisKKyMgRG9uJ3QgdHJ5IHRvIHJlZ2VuZXJhdGUgTWFrZWZpbGUgb3IgY29uZmlndXJlCisjIFdl IGRvbid0IGdlbmVyYXRlIGFueSBvZiB0aGVtCitNYWtlZmlsZTogOworY29uZmlndXJlOiA7CisK Ky5QSE9OWTogYWxsIGNsZWFuIGNzY29wZSBkaXN0Y2xlYW4gZHZpIGh0bWwgaW5mbyBpbnN0YWxs IGluc3RhbGwtZG9jIFwKKwlwZGYgcmVjdXJzZS1hbGwgc3BlZWQgdGFyIHRhcmJpbiB0ZXN0IGJ1 aWxkLWFsbAorCiskKGNhbGwgc2V0LXZwYXRoLCAkKFNSQ19QQVRIKTokKFNSQ19QQVRIKS9odykK KworTElCUys9LWx6ICQoTElCU19UT09MUykKKworaWZkZWYgQlVJTERfRE9DUworRE9DUz1xZW11 LWRvYy5odG1sIHFlbXUtdGVjaC5odG1sIHFlbXUuMSBxZW11LWltZy4xIHFlbXUtbmJkLjggUU1Q L3FtcC1jb21tYW5kcy50eHQKK2Vsc2UKK0RPQ1M9CitlbmRpZgorCitTVUJESVJfTUFLRUZMQUdT PSQoaWYgJChWKSwsLS1uby1wcmludC1kaXJlY3RvcnkpCitTVUJESVJfREVWSUNFU19NQUs9JChw YXRzdWJzdCAlLCAlL2NvbmZpZy1kZXZpY2VzLm1haywgJChUQVJHRVRfRElSUykpCisKK2NvbmZp Zy1hbGwtZGV2aWNlcy5tYWs6ICQoU1VCRElSX0RFVklDRVNfTUFLKQorCSQoY2FsbCBxdWlldC1j b21tYW5kLGNhdCAkKFNVQkRJUl9ERVZJQ0VTX01BSykgfCBncmVwID15IHwgc29ydCAtdSA+ICRA LCIgIEdFTiAgICRAIikKKworJS9jb25maWctZGV2aWNlcy5tYWs6IGRlZmF1bHQtY29uZmlncy8l Lm1haworCSQoY2FsbCBxdWlldC1jb21tYW5kLGNhdCAkPCA+ICRALnRtcCwgIiAgR0VOICAgJEAi KQorCUBpZiB0ZXN0IC1mICRAOyB0aGVuIFwKKwkgIGlmIGNtcCAtcyAkQC5vbGQgJEA7IHRoZW4g XAorCSAgICBpZiAhIGNtcCAtcyAkQCAkQC50bXA7IHRoZW4gXAorCSAgICAgIG12ICRALnRtcCAk QDsgXAorCSAgICAgIGNwIC1wICRAICRALm9sZDsgXAorCSAgICBmaTsgXAorCSAgZWxzZSBcCisJ ICAgIGlmIHRlc3QgLWYgJEAub2xkOyB0aGVuIFwKKwkgICAgICBlY2hvICJXQVJOSU5HOiAkQCAo dXNlciBtb2RpZmllZCkgb3V0IG9mIGRhdGUuIjtcCisJICAgIGVsc2UgXAorCSAgICAgIGVjaG8g IldBUk5JTkc6ICRAIG91dCBvZiBkYXRlLiI7XAorCSAgICBmaTsgXAorCSAgICBlY2hvICJSdW4g XCJtYWtlIGRlZmNvbmZpZ1wiIHRvIHJlZ2VuZXJhdGUuIjsgXAorCSAgICBybSAkQC50bXA7IFwK KwkgIGZpOyBcCisJIGVsc2UgXAorCSAgbXYgJEAudG1wICRAOyBcCisJICBjcCAtcCAkQCAkQC5v bGQ7IFwKKwkgZmkKKworZGVmY29uZmlnOgorCXJtIC1mIGNvbmZpZy1hbGwtZGV2aWNlcy5tYWsg JChTVUJESVJfREVWSUNFU19NQUspCisKKy1pbmNsdWRlIGNvbmZpZy1hbGwtZGV2aWNlcy5tYWsK KworYnVpbGQtYWxsOiAkKERPQ1MpICQoVE9PTFMpIHJlY3Vyc2UtYWxsCisKK2NvbmZpZy1ob3N0 Lmg6IGNvbmZpZy1ob3N0LmgtdGltZXN0YW1wCitjb25maWctaG9zdC5oLXRpbWVzdGFtcDogY29u ZmlnLWhvc3QubWFrCitxZW11LW9wdGlvbnMuZGVmOiAkKFNSQ19QQVRIKS9xZW11LW9wdGlvbnMu aHgKKwkkKGNhbGwgcXVpZXQtY29tbWFuZCxzaCAkKFNSQ19QQVRIKS9oeHRvb2wgLWggPCAkPCA+ ICRALCIgIEdFTiAgICRAIikKKworU1VCRElSX1JVTEVTPSQocGF0c3Vic3QgJSxzdWJkaXItJSwg JChUQVJHRVRfRElSUykpCisKK3N1YmRpci0lOiAkKEdFTkVSQVRFRF9IRUFERVJTKQorCSQoY2Fs bCBxdWlldC1jb21tYW5kLCQoTUFLRSkgJChTVUJESVJfTUFLRUZMQUdTKSAtQyAkKiBWPSIkKFYp IiBUQVJHRVRfRElSPSIkKi8iIGFsbCwpCisKK2lmbmVxICgkKHdpbGRjYXJkIGNvbmZpZy1ob3N0 Lm1hayksKQoraW5jbHVkZSAkKFNSQ19QQVRIKS9NYWtlZmlsZS5vYmpzCitlbmRpZgorCiskKGNv bW1vbi1vYmoteSk6ICQoR0VORVJBVEVEX0hFQURFUlMpCiskKGZpbHRlciAlLXNvZnRtbXUsJChT VUJESVJfUlVMRVMpKTogJCh0cmFjZS1vYmoteSkgJChjb21tb24tb2JqLXkpIHN1YmRpci1saWJk aXMKKworJChmaWx0ZXIgJS11c2VyLCQoU1VCRElSX1JVTEVTKSk6ICQoR0VORVJBVEVEX0hFQURF UlMpICQodHJhY2Utb2JqLXkpIHN1YmRpci1saWJkaXMtdXNlciBzdWJkaXItbGlidXNlcgorCitS T01TVUJESVJfUlVMRVM9JChwYXRzdWJzdCAlLHJvbXN1YmRpci0lLCAkKFJPTVMpKQorcm9tc3Vi ZGlyLSU6CisJJChjYWxsIHF1aWV0LWNvbW1hbmQsJChNQUtFKSAkKFNVQkRJUl9NQUtFRkxBR1Mp IC1DIHBjLWJpb3MvJCogVj0iJChWKSIgVEFSR0VUX0RJUj0iJCovIiwpCisKK0FMTF9TVUJESVJT PSQoVEFSR0VUX0RJUlMpICQocGF0c3Vic3QgJSxwYy1iaW9zLyUsICQoUk9NUykpCisKK3JlY3Vy c2UtYWxsOiAkKFNVQkRJUl9SVUxFUykgJChST01TVUJESVJfUlVMRVMpCisKK2F1ZGlvL2F1ZGlv Lm8gYXVkaW8vZm1vZGF1ZGlvLm86IFFFTVVfQ0ZMQUdTICs9ICQoRk1PRF9DRkxBR1MpCisKK1FF TVVfQ0ZMQUdTKz0kKENVUkxfQ0ZMQUdTKQorCit1aS9jb2NvYS5vOiB1aS9jb2NvYS5tCisKK3Vp L3NkbC5vIGF1ZGlvL3NkbGF1ZGlvLm8gdWkvc2RsX3pvb20ubyBiYXVtLm86IFFFTVVfQ0ZMQUdT ICs9ICQoU0RMX0NGTEFHUykKKwordWkvdm5jLm86IFFFTVVfQ0ZMQUdTICs9ICQoVk5DX1RMU19D RkxBR1MpCisKK2J0LWhvc3QubzogUUVNVV9DRkxBR1MgKz0gJChCTFVFWl9DRkxBR1MpCisKK2lm ZXEgKCQoVFJBQ0VfQkFDS0VORCksZHRyYWNlKQordHJhY2UuaDogdHJhY2UuaC10aW1lc3RhbXAg dHJhY2UtZHRyYWNlLmgKK2Vsc2UKK3RyYWNlLmg6IHRyYWNlLmgtdGltZXN0YW1wCitlbmRpZgor dHJhY2UuaC10aW1lc3RhbXA6ICQoU1JDX1BBVEgpL3RyYWNlLWV2ZW50cyBjb25maWctaG9zdC5t YWsKKwkkKGNhbGwgcXVpZXQtY29tbWFuZCxzaCAkKFNSQ19QQVRIKS90cmFjZXRvb2wgLS0kKFRS QUNFX0JBQ0tFTkQpIC1oIDwgJDwgPiAkQCwiICBHRU4gICB0cmFjZS5oIikKKwlAY21wIC1zICRA IHRyYWNlLmggfHwgY3AgJEAgdHJhY2UuaAorCit0cmFjZS5jOiB0cmFjZS5jLXRpbWVzdGFtcAor dHJhY2UuYy10aW1lc3RhbXA6ICQoU1JDX1BBVEgpL3RyYWNlLWV2ZW50cyBjb25maWctaG9zdC5t YWsKKwkkKGNhbGwgcXVpZXQtY29tbWFuZCxzaCAkKFNSQ19QQVRIKS90cmFjZXRvb2wgLS0kKFRS QUNFX0JBQ0tFTkQpIC1jIDwgJDwgPiAkQCwiICBHRU4gICB0cmFjZS5jIikKKwlAY21wIC1zICRA IHRyYWNlLmMgfHwgY3AgJEAgdHJhY2UuYworCit0cmFjZS5vOiB0cmFjZS5jICQoR0VORVJBVEVE X0hFQURFUlMpCisKK3RyYWNlLWR0cmFjZS5oOiB0cmFjZS1kdHJhY2UuZHRyYWNlCisJJChjYWxs IHF1aWV0LWNvbW1hbmQsZHRyYWNlIC1vICRAIC1oIC1zICQ8LCAiICBHRU4gICB0cmFjZS1kdHJh Y2UuaCIpCisKKyMgTm9ybWFsIHByYWN0aWNlIGlzIHRvIG5hbWUgRFRyYWNlIHByb2JlIGZpbGUg d2l0aCBhICcuZCcgZXh0ZW5zaW9uCisjIGJ1dCB0aGF0IGdldHMgcGlja2VkIHVwIGJ5IFFFTVUn cyBNYWtlZmlsZSBhcyBhbiBleHRlcm5hbCBkZXBlbmRhbmN5CisjIHJ1bGUgZmlsZS4gU28gd2Ug dXNlICcuZHRyYWNlJyBpbnN0ZWFkCit0cmFjZS1kdHJhY2UuZHRyYWNlOiB0cmFjZS1kdHJhY2Uu ZHRyYWNlLXRpbWVzdGFtcAordHJhY2UtZHRyYWNlLmR0cmFjZS10aW1lc3RhbXA6ICQoU1JDX1BB VEgpL3RyYWNlLWV2ZW50cyBjb25maWctaG9zdC5tYWsKKwkkKGNhbGwgcXVpZXQtY29tbWFuZCxz aCAkKFNSQ19QQVRIKS90cmFjZXRvb2wgLS0kKFRSQUNFX0JBQ0tFTkQpIC1kIDwgJDwgPiAkQCwi ICBHRU4gICB0cmFjZS1kdHJhY2UuZHRyYWNlIikKKwlAY21wIC1zICRAIHRyYWNlLWR0cmFjZS5k dHJhY2UgfHwgY3AgJEAgdHJhY2UtZHRyYWNlLmR0cmFjZQorCit0cmFjZS1kdHJhY2UubzogdHJh Y2UtZHRyYWNlLmR0cmFjZSAkKEdFTkVSQVRFRF9IRUFERVJTKQorCSQoY2FsbCBxdWlldC1jb21t YW5kLGR0cmFjZSAtbyAkQCAtRyAtcyAkPCwgIiAgR0VOIHRyYWNlLWR0cmFjZS5vIikKKworc2lt cGxldHJhY2Uubzogc2ltcGxldHJhY2UuYyAkKEdFTkVSQVRFRF9IRUFERVJTKQorCit2ZXJzaW9u Lm86ICQoU1JDX1BBVEgpL3ZlcnNpb24ucmMgY29uZmlnLWhvc3QubWFrCisJJChjYWxsIHF1aWV0 LWNvbW1hbmQsJChXSU5EUkVTKSAtSS4gLW8gJEAgJDwsIiAgUkMgICAgJChUQVJHRVRfRElSKSRA IikKKwordmVyc2lvbi1vYmotJChDT05GSUdfV0lOMzIpICs9IHZlcnNpb24ubworIyMjIyMjIyMj IyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMj IyMjIworCitxZW11LWltZy5vOiBxZW11LWltZy1jbWRzLmgKK3FlbXUtaW1nLm8gcWVtdS10b29s Lm8gcWVtdS1uYmQubyBxZW11LWlvLm86ICQoR0VORVJBVEVEX0hFQURFUlMpCisKK3FlbXUtaW1n JChFWEVTVUYpOiBxZW11LWltZy5vIHFlbXUtdG9vbC5vIHFlbXUtZXJyb3IubyAkKG9zbGliLW9i ai15KSAkKHRyYWNlLW9iai15KSAkKGJsb2NrLW9iai15KSAkKHFvYmplY3Qtb2JqLXkpICQodmVy c2lvbi1vYmoteSkgcWVtdS10aW1lci1jb21tb24ubworCitxZW11LW5iZCQoRVhFU1VGKTogcWVt dS1uYmQubyBxZW11LXRvb2wubyBxZW11LWVycm9yLm8gJChvc2xpYi1vYmoteSkgJCh0cmFjZS1v YmoteSkgJChibG9jay1vYmoteSkgJChxb2JqZWN0LW9iai15KSAkKHZlcnNpb24tb2JqLXkpIHFl bXUtdGltZXItY29tbW9uLm8KKworcWVtdS1pbyQoRVhFU1VGKTogcWVtdS1pby5vIGNtZC5vIHFl bXUtdG9vbC5vIHFlbXUtZXJyb3IubyAkKG9zbGliLW9iai15KSAkKHRyYWNlLW9iai15KSAkKGJs b2NrLW9iai15KSAkKHFvYmplY3Qtb2JqLXkpICQodmVyc2lvbi1vYmoteSkgcWVtdS10aW1lci1j b21tb24ubworCitxZW11LWltZy1jbWRzLmg6ICQoU1JDX1BBVEgpL3FlbXUtaW1nLWNtZHMuaHgK KwkkKGNhbGwgcXVpZXQtY29tbWFuZCxzaCAkKFNSQ19QQVRIKS9oeHRvb2wgLWggPCAkPCA+ICRA LCIgIEdFTiAgICRAIikKKworY2hlY2stcWludC5vIGNoZWNrLXFzdHJpbmcubyBjaGVjay1xZGlj dC5vIGNoZWNrLXFsaXN0Lm8gY2hlY2stcWZsb2F0Lm8gY2hlY2stcWpzb24ubzogJChHRU5FUkFU RURfSEVBREVSUykKKworY2hlY2stcWludDogY2hlY2stcWludC5vIHFpbnQubyBxZW11LW1hbGxv Yy5vICQodHJhY2Utb2JqLXkpCitjaGVjay1xc3RyaW5nOiBjaGVjay1xc3RyaW5nLm8gcXN0cmlu Zy5vIHFlbXUtbWFsbG9jLm8gJCh0cmFjZS1vYmoteSkKK2NoZWNrLXFkaWN0OiBjaGVjay1xZGlj dC5vIHFkaWN0Lm8gcWZsb2F0Lm8gcWludC5vIHFzdHJpbmcubyBxYm9vbC5vIHFlbXUtbWFsbG9j Lm8gcWxpc3QubyAkKHRyYWNlLW9iai15KQorY2hlY2stcWxpc3Q6IGNoZWNrLXFsaXN0Lm8gcWxp c3QubyBxaW50Lm8gcWVtdS1tYWxsb2MubyAkKHRyYWNlLW9iai15KQorY2hlY2stcWZsb2F0OiBj aGVjay1xZmxvYXQubyBxZmxvYXQubyBxZW11LW1hbGxvYy5vICQodHJhY2Utb2JqLXkpCitjaGVj ay1xanNvbjogY2hlY2stcWpzb24ubyBxZmxvYXQubyBxaW50Lm8gcWRpY3QubyBxc3RyaW5nLm8g cWxpc3QubyBxYm9vbC5vIHFqc29uLm8ganNvbi1zdHJlYW1lci5vIGpzb24tbGV4ZXIubyBqc29u LXBhcnNlci5vIHFlbXUtbWFsbG9jLm8gJCh0cmFjZS1vYmoteSkKKworY2xlYW46CisjIGF2b2lk IG9sZCBidWlsZCBwcm9ibGVtcyBieSByZW1vdmluZyBwb3RlbnRpYWxseSBpbmNvcnJlY3Qgb2xk IGZpbGVzCisJcm0gLWYgY29uZmlnLm1hayBvcC1pMzg2Lmggb3BjLWkzODYuaCBnZW4tb3AtaTM4 Ni5oIG9wLWFybS5oIG9wYy1hcm0uaCBnZW4tb3AtYXJtLmgKKwlybSAtZiBxZW11LW9wdGlvbnMu ZGVmCisJcm0gLWYgKi5vICouZCAqLmEgJChUT09MUykgVEFHUyBjc2NvcGUuKiAqLnBvZCAqfiAq Lyp+CisJcm0gLWYgc2xpcnAvKi5vIHNsaXJwLyouZCBhdWRpby8qLm8gYXVkaW8vKi5kIGJsb2Nr LyoubyBibG9jay8qLmQgbmV0LyoubyBuZXQvKi5kIGZzZGV2LyoubyBmc2Rldi8qLmQgdWkvKi5v IHVpLyouZAorCXJtIC1mIHFlbXUtaW1nLWNtZHMuaAorCXJtIC1mIHRyYWNlLmMgdHJhY2UuaCB0 cmFjZS5jLXRpbWVzdGFtcCB0cmFjZS5oLXRpbWVzdGFtcAorCXJtIC1mIHRyYWNlLWR0cmFjZS5k dHJhY2UgdHJhY2UtZHRyYWNlLmR0cmFjZS10aW1lc3RhbXAKKwlybSAtZiB0cmFjZS1kdHJhY2Uu aCB0cmFjZS1kdHJhY2UuaC10aW1lc3RhbXAKKwkkKE1BS0UpIC1DIHRlc3RzIGNsZWFuCisJZm9y IGQgaW4gJChBTExfU1VCRElSUykgbGliaHczMiBsaWJodzY0IGxpYnVzZXIgbGliZGlzIGxpYmRp cy11c2VyOyBkbyBcCisJaWYgdGVzdCAtZCAkJGQ7IHRoZW4gJChNQUtFKSAtQyAkJGQgJEAgfHwg ZXhpdCAxOyBmaTsgXAorCXJtIC1mICQkZC9xZW11LW9wdGlvbnMuZGVmOyBcCisgICAgICAgIGRv bmUKKworZGlzdGNsZWFuOiBjbGVhbgorCXJtIC1mIGNvbmZpZy1ob3N0Lm1hayBjb25maWctaG9z dC5oKiBjb25maWctaG9zdC5sZCAkKERPQ1MpIHFlbXUtb3B0aW9ucy50ZXhpIHFlbXUtaW1nLWNt ZHMudGV4aSBxZW11LW1vbml0b3IudGV4aQorCXJtIC1mIGNvbmZpZy1hbGwtZGV2aWNlcy5tYWsK KwlybSAtZiByb21zL3NlYWJpb3MvY29uZmlnLm1hayByb21zL3ZnYWJpb3MvY29uZmlnLm1hawor CXJtIC1mIHFlbXUtZG9jLmluZm8gcWVtdS1kb2MuYXV4IHFlbXUtZG9jLmNwIHFlbXUtZG9jLmR2 aSBxZW11LWRvYy5mbiBxZW11LWRvYy5pbmZvIHFlbXUtZG9jLmt5IHFlbXUtZG9jLmxvZyBxZW11 LWRvYy5wZGYgcWVtdS1kb2MucGcgcWVtdS1kb2MudG9jIHFlbXUtZG9jLnRwIHFlbXUtZG9jLnZy CisJcm0gLWYgcWVtdS10ZWNoLmluZm8gcWVtdS10ZWNoLmF1eCBxZW11LXRlY2guY3AgcWVtdS10 ZWNoLmR2aSBxZW11LXRlY2guZm4gcWVtdS10ZWNoLmluZm8gcWVtdS10ZWNoLmt5IHFlbXUtdGVj aC5sb2cgcWVtdS10ZWNoLnBkZiBxZW11LXRlY2gucGcgcWVtdS10ZWNoLnRvYyBxZW11LXRlY2gu dHAgcWVtdS10ZWNoLnZyCisJZm9yIGQgaW4gJChUQVJHRVRfRElSUykgbGliaHczMiBsaWJodzY0 IGxpYnVzZXIgbGliZGlzIGxpYmRpcy11c2VyOyBkbyBcCisJcm0gLXJmICQkZCB8fCBleGl0IDEg OyBcCisgICAgICAgIGRvbmUKKworS0VZTUFQUz1kYSAgICAgZW4tZ2IgIGV0ICBmciAgICAgZnIt Y2ggIGlzICBsdCAgbW9kaWZpZXJzICBubyAgcHQtYnIgIHN2IFwKK2FyICAgICAgZGUgICAgIGVu LXVzICBmaSAgZnItYmUgIGhyICAgICBpdCAgbHYgIG5sICAgICAgICAgcGwgIHJ1ICAgICB0aCBc Citjb21tb24gIGRlLWNoICBlcyAgICAgZm8gIGZyLWNhICBodSAgICAgamEgIG1rICBubC1iZSAg ICAgIHB0ICBzbCAgICAgdHIKKworaWZkZWYgSU5TVEFMTF9CTE9CUworQkxPQlM9Ymlvcy5iaW4g dmdhYmlvcy5iaW4gdmdhYmlvcy1jaXJydXMuYmluIFwKK3ZnYWJpb3Mtc3RkdmdhLmJpbiB2Z2Fi aW9zLXZtd2FyZS5iaW4gXAorcHBjX3JvbS5iaW4gb3BlbmJpb3Mtc3BhcmMzMiBvcGVuYmlvcy1z cGFyYzY0IG9wZW5iaW9zLXBwYyBcCitncHhlLWVlcHJvMTAwLTgwODYxMjA5LnJvbSBcCitncHhl LWVlcHJvMTAwLTgwODYxMjI5LnJvbSBcCitweGUtZTEwMDAuYmluIFwKK3B4ZS1uZTJrX3BjaS5i aW4gcHhlLXBjbmV0LmJpbiBcCitweGUtcnRsODEzOS5iaW4gcHhlLXZpcnRpby5iaW4gXAorYmFt Ym9vLmR0YiBwZXRhbG9naXgtczNhZHNwMTgwMC5kdGIgXAorbXVsdGlib290LmJpbiBsaW51eGJv b3QuYmluIFwKK3MzOTAtemlwbC5yb20KK2Vsc2UKK0JMT0JTPQorZW5kaWYKKworaW5zdGFsbC1k b2M6ICQoRE9DUykKKwkkKElOU1RBTExfRElSKSAiJChERVNURElSKSQoZG9jZGlyKSIKKwkkKElO U1RBTExfREFUQSkgcWVtdS1kb2MuaHRtbCAgcWVtdS10ZWNoLmh0bWwgIiQoREVTVERJUikkKGRv Y2RpcikiCitpZmRlZiBDT05GSUdfUE9TSVgKKwkkKElOU1RBTExfRElSKSAiJChERVNURElSKSQo bWFuZGlyKS9tYW4xIgorCSQoSU5TVEFMTF9EQVRBKSBxZW11LjEgcWVtdS1pbWcuMSAiJChERVNU RElSKSQobWFuZGlyKS9tYW4xIgorCSQoSU5TVEFMTF9ESVIpICIkKERFU1RESVIpJChtYW5kaXIp L21hbjgiCisJJChJTlNUQUxMX0RBVEEpIHFlbXUtbmJkLjggIiQoREVTVERJUikkKG1hbmRpcikv bWFuOCIKK2VuZGlmCisKK2luc3RhbGwtc3lzY29uZmlnOgorCSQoSU5TVEFMTF9ESVIpICIkKERF U1RESVIpJChzeXNjb25mZGlyKS9xZW11IgorCSQoSU5TVEFMTF9EQVRBKSAkKFNSQ19QQVRIKS9z eXNjb25maWdzL3RhcmdldC90YXJnZXQteDg2XzY0LmNvbmYgIiQoREVTVERJUikkKHN5c2NvbmZk aXIpL3FlbXUiCisKK2luc3RhbGw6IGFsbCAkKGlmICQoQlVJTERfRE9DUyksaW5zdGFsbC1kb2Mp IGluc3RhbGwtc3lzY29uZmlnCisJJChJTlNUQUxMX0RJUikgIiQoREVTVERJUikkKGJpbmRpciki CitpZm5lcSAoJChUT09MUyksKQorCSQoSU5TVEFMTF9QUk9HKSAkKFNUUklQX09QVCkgJChUT09M UykgIiQoREVTVERJUikkKGJpbmRpcikiCitlbmRpZgoraWZuZXEgKCQoQkxPQlMpLCkKKwkkKElO U1RBTExfRElSKSAiJChERVNURElSKSQoZGF0YWRpcikiCisJc2V0IC1lOyBmb3IgeCBpbiAkKEJM T0JTKTsgZG8gXAorCQkkKElOU1RBTExfREFUQSkgJChTUkNfUEFUSCkvcGMtYmlvcy8kJHggIiQo REVTVERJUikkKGRhdGFkaXIpIjsgXAorCWRvbmUKK2VuZGlmCisJJChJTlNUQUxMX0RJUikgIiQo REVTVERJUikkKGRhdGFkaXIpL2tleW1hcHMiCisJc2V0IC1lOyBmb3IgeCBpbiAkKEtFWU1BUFMp OyBkbyBcCisJCSQoSU5TVEFMTF9EQVRBKSAkKFNSQ19QQVRIKS9wYy1iaW9zL2tleW1hcHMvJCR4 ICIkKERFU1RESVIpJChkYXRhZGlyKS9rZXltYXBzIjsgXAorCWRvbmUKKwlmb3IgZCBpbiAkKFRB UkdFVF9ESVJTKTsgZG8gXAorCSQoTUFLRSkgLUMgJCRkICRAIHx8IGV4aXQgMSA7IFwKKyAgICAg ICAgZG9uZQorCisjIHZhcmlvdXMgdGVzdCB0YXJnZXRzCit0ZXN0IHNwZWVkOiBhbGwKKwkkKE1B S0UpIC1DIHRlc3RzICRACisKKy5QSE9OWTogVEFHUworVEFHUzoKKwlmaW5kICIkKFNSQ19QQVRI KSIgLW5hbWUgJyouW2hjXScgLXByaW50MCB8IHhhcmdzIC0wIGV0YWdzCisKK2NzY29wZToKKwly bSAtZiAuL2NzY29wZS4qCisJZmluZCAuIC1uYW1lICIqLltjaF0iIC1wcmludCB8IHNlZCAncyxe XC4vLCwnID4gLi9jc2NvcGUuZmlsZXMKKwljc2NvcGUgLWIKKworIyBkb2N1bWVudGF0aW9uCitN QUtFSU5GTz1tYWtlaW5mbworTUFLRUlORk9GTEFHUz0tLW5vLWhlYWRlcnMgLS1uby1zcGxpdCAt LW51bWJlci1zZWN0aW9ucworVEVYSUZMQUc9JChpZiAkKFYpLCwtLXF1aWV0KQorJS5kdmk6ICUu dGV4aQorCSQoY2FsbCBxdWlldC1jb21tYW5kLHRleGkyZHZpICQoVEVYSUZMQUcpIC1JIC4gJDws IiAgR0VOICAgJEAiKQorCislLmh0bWw6ICUudGV4aQorCSQoY2FsbCBxdWlldC1jb21tYW5kLCQo TUFLRUlORk8pICQoTUFLRUlORk9GTEFHUykgLS1odG1sICQ8IC1vICRALCBcCisJIiAgR0VOICAg JEAiKQorCislLmluZm86ICUudGV4aQorCSQoY2FsbCBxdWlldC1jb21tYW5kLCQoTUFLRUlORk8p ICQ8IC1vICRALCIgIEdFTiAgICRAIikKKworJS5wZGY6ICUudGV4aQorCSQoY2FsbCBxdWlldC1j b21tYW5kLHRleGkycGRmICQoVEVYSUZMQUcpIC1JIC4gJDwsIiAgR0VOICAgJEAiKQorCitxZW11 LW9wdGlvbnMudGV4aTogJChTUkNfUEFUSCkvcWVtdS1vcHRpb25zLmh4CisJJChjYWxsIHF1aWV0 LWNvbW1hbmQsc2ggJChTUkNfUEFUSCkvaHh0b29sIC10IDwgJDwgPiAkQCwiICBHRU4gICAkQCIp CisKK3FlbXUtbW9uaXRvci50ZXhpOiAkKFNSQ19QQVRIKS9obXAtY29tbWFuZHMuaHgKKwkkKGNh bGwgcXVpZXQtY29tbWFuZCxzaCAkKFNSQ19QQVRIKS9oeHRvb2wgLXQgPCAkPCA+ICRALCIgIEdF TiAgICRAIikKKworUU1QL3FtcC1jb21tYW5kcy50eHQ6ICQoU1JDX1BBVEgpL3FtcC1jb21tYW5k cy5oeAorCSQoY2FsbCBxdWlldC1jb21tYW5kLHNoICQoU1JDX1BBVEgpL2h4dG9vbCAtcSA8ICQ8 ID4gJEAsIiAgR0VOICAgJEAiKQorCitxZW11LWltZy1jbWRzLnRleGk6ICQoU1JDX1BBVEgpL3Fl bXUtaW1nLWNtZHMuaHgKKwkkKGNhbGwgcXVpZXQtY29tbWFuZCxzaCAkKFNSQ19QQVRIKS9oeHRv b2wgLXQgPCAkPCA+ICRALCIgIEdFTiAgICRAIikKKworcWVtdS4xOiBxZW11LWRvYy50ZXhpIHFl bXUtb3B0aW9ucy50ZXhpIHFlbXUtbW9uaXRvci50ZXhpCisJJChjYWxsIHF1aWV0LWNvbW1hbmQs IFwKKwkgIHBlcmwgLVd3IC0tICQoU1JDX1BBVEgpL3RleGkycG9kLnBsICQ8IHFlbXUucG9kICYm IFwKKwkgIHBvZDJtYW4gLS1zZWN0aW9uPTEgLS1jZW50ZXI9IiAiIC0tcmVsZWFzZT0iICIgcWVt dS5wb2QgPiAkQCwgXAorCSAgIiAgR0VOICAgJEAiKQorCitxZW11LWltZy4xOiBxZW11LWltZy50 ZXhpIHFlbXUtaW1nLWNtZHMudGV4aQorCSQoY2FsbCBxdWlldC1jb21tYW5kLCBcCisJICBwZXJs IC1XdyAtLSAkKFNSQ19QQVRIKS90ZXhpMnBvZC5wbCAkPCBxZW11LWltZy5wb2QgJiYgXAorCSAg cG9kMm1hbiAtLXNlY3Rpb249MSAtLWNlbnRlcj0iICIgLS1yZWxlYXNlPSIgIiBxZW11LWltZy5w b2QgPiAkQCwgXAorCSAgIiAgR0VOICAgJEAiKQorCitxZW11LW5iZC44OiBxZW11LW5iZC50ZXhp CisJJChjYWxsIHF1aWV0LWNvbW1hbmQsIFwKKwkgIHBlcmwgLVd3IC0tICQoU1JDX1BBVEgpL3Rl eGkycG9kLnBsICQ8IHFlbXUtbmJkLnBvZCAmJiBcCisJICBwb2QybWFuIC0tc2VjdGlvbj04IC0t Y2VudGVyPSIgIiAtLXJlbGVhc2U9IiAiIHFlbXUtbmJkLnBvZCA+ICRALCBcCisJICAiICBHRU4g ICAkQCIpCisKK2R2aTogcWVtdS1kb2MuZHZpIHFlbXUtdGVjaC5kdmkKK2h0bWw6IHFlbXUtZG9j Lmh0bWwgcWVtdS10ZWNoLmh0bWwKK2luZm86IHFlbXUtZG9jLmluZm8gcWVtdS10ZWNoLmluZm8K K3BkZjogcWVtdS1kb2MucGRmIHFlbXUtdGVjaC5wZGYKKworcWVtdS1kb2MuZHZpIHFlbXUtZG9j Lmh0bWwgcWVtdS1kb2MuaW5mbyBxZW11LWRvYy5wZGY6IFwKKwlxZW11LWltZy50ZXhpIHFlbXUt bmJkLnRleGkgcWVtdS1vcHRpb25zLnRleGkgXAorCXFlbXUtbW9uaXRvci50ZXhpIHFlbXUtaW1n LWNtZHMudGV4aQorCitWRVJTSU9OID89ICQoc2hlbGwgY2F0IFZFUlNJT04pCitGSUxFID0gcWVt dS0kKFZFUlNJT04pCisKKyMgdGFyIHJlbGVhc2UgKHVzZSAnbWFrZSAtayB0YXInIG9uIGEgY2hl Y2tvdXRlZCB0cmVlKQordGFyOgorCXJtIC1yZiAvdG1wLyQoRklMRSkKKwljcCAtciAuIC90bXAv JChGSUxFKQorCWNkIC90bXAgJiYgdGFyIHpjdmYgfi8kKEZJTEUpLnRhci5neiAkKEZJTEUpIC0t ZXhjbHVkZSBDVlMgLS1leGNsdWRlIC5naXQgLS1leGNsdWRlIC5zdm4KKwlybSAtcmYgL3RtcC8k KEZJTEUpCisKK1NZU1RFTV9UQVJHRVRTPSQoZmlsdGVyICUtc29mdG1tdSwkKFRBUkdFVF9ESVJT KSkKK1NZU1RFTV9QUk9HUz0kKHBhdHN1YnN0IHFlbXUtc3lzdGVtLWkzODYscWVtdSwgXAorICAg ICAgICAgICAgICQocGF0c3Vic3QgJS1zb2Z0bW11LHFlbXUtc3lzdGVtLSUsIFwKKyAgICAgICAg ICAgICAkKFNZU1RFTV9UQVJHRVRTKSkpCisKK1VTRVJfVEFSR0VUUz0kKGZpbHRlciAlLXVzZXIs JChUQVJHRVRfRElSUykpCitVU0VSX1BST0dTPSQocGF0c3Vic3QgJS1ic2QtdXNlcixxZW11LSUs IFwKKyAgICAgICAgICAgJChwYXRzdWJzdCAlLWRhcndpbi11c2VyLHFlbXUtJSwgXAorICAgICAg ICAgICAkKHBhdHN1YnN0ICUtbGludXgtdXNlcixxZW11LSUsIFwKKyAgICAgICAgICAgJChVU0VS X1RBUkdFVFMpKSkpCisKKyMgZ2VuZXJhdGUgYSBiaW5hcnkgZGlzdHJpYnV0aW9uCit0YXJiaW46 CisJY2QgLyAmJiB0YXIgemN2ZiB+L3FlbXUtJChWRVJTSU9OKS0kKEFSQ0gpLnRhci5neiBcCisJ JChwYXRzdWJzdCAlLCQoYmluZGlyKS8lLCAkKFNZU1RFTV9QUk9HUykpIFwKKwkkKHBhdHN1YnN0 ICUsJChiaW5kaXIpLyUsICQoVVNFUl9QUk9HUykpIFwKKwkkKGJpbmRpcikvcWVtdS1pbWcgXAor CSQoYmluZGlyKS9xZW11LW5iZCBcCisJJChkYXRhZGlyKS9iaW9zLmJpbiBcCisJJChkYXRhZGly KS92Z2FiaW9zLmJpbiBcCisJJChkYXRhZGlyKS92Z2FiaW9zLWNpcnJ1cy5iaW4gXAorCSQoZGF0 YWRpcikvcHBjX3JvbS5iaW4gXAorCSQoZGF0YWRpcikvb3BlbmJpb3Mtc3BhcmMzMiBcCisJJChk YXRhZGlyKS9vcGVuYmlvcy1zcGFyYzY0IFwKKwkkKGRhdGFkaXIpL29wZW5iaW9zLXBwYyBcCisJ JChkYXRhZGlyKS9weGUtbmUya19wY2kuYmluIFwKKwkkKGRhdGFkaXIpL3B4ZS1ydGw4MTM5LmJp biBcCisJJChkYXRhZGlyKS9weGUtcGNuZXQuYmluIFwKKwkkKGRhdGFkaXIpL3B4ZS1lMTAwMC5i aW4gXAorCSQoZG9jZGlyKS9xZW11LWRvYy5odG1sIFwKKwkkKGRvY2RpcikvcWVtdS10ZWNoLmh0 bWwgXAorCSQobWFuZGlyKS9tYW4xL3FlbXUuMSBcCisJJChtYW5kaXIpL21hbjEvcWVtdS1pbWcu MSBcCisJJChtYW5kaXIpL21hbjgvcWVtdS1uYmQuOAorCisjIEluY2x1ZGUgYXV0b21hdGljYWxs eSBnZW5lcmF0ZWQgZGVwZW5kZW5jeSBmaWxlcworLWluY2x1ZGUgJCh3aWxkY2FyZCAqLmQgYXVk aW8vKi5kIHNsaXJwLyouZCBibG9jay8qLmQgbmV0LyouZCB1aS8qLmQpCmRpZmYgLS1naXQgYS9j b25maWd1cmUgYi9jb25maWd1cmUKaW5kZXggZTU2MGY4Ny4uYWM3ZTIyMCAxMDA3NTUKLS0tIGEv Y29uZmlndXJlCisrKyBiL2NvbmZpZ3VyZQpAQCAtNTAwLDE0ICs1MDAsMTcgQEAgZmkKIAogIyBm aW5kIHNvdXJjZSBwYXRoCiBzb3VyY2VfcGF0aD1gZGlybmFtZSAiJDAiYAotc291cmNlX3BhdGhf dXNlZD0ibm8iCiB3b3JrZGlyPWBwd2RgCiBpZiBbIC16ICIkc291cmNlX3BhdGgiIF07IHRoZW4K ICAgICBzb3VyY2VfcGF0aD0kd29ya2RpcgogZWxzZQogICAgIHNvdXJjZV9wYXRoPWBjZCAiJHNv dXJjZV9wYXRoIjsgcHdkYAogZmkKLVsgLWYgIiR3b3JrZGlyL3ZsLmMiIF0gfHwgc291cmNlX3Bh dGhfdXNlZD0ieWVzIgoraWYgWyAiJHNvdXJjZV9wYXRoIiA9ICIkd29ya2RpciIgXTsgdGhlbgor ICAgICMgRm9yY2Ugb2JqZWN0IGRpcmVjdG9yeSB1c2UKKyAgICBta2RpciAtcCBvYmoKKyAgICBj ZCBvYmoKK2ZpCiAKIHdlcnJvcj0iIgogCkBAIC01MjEsNyArNTI0LDYgQEAgZm9yIG9wdCBkbwog ICAtLWludGVycC1wcmVmaXg9KikgaW50ZXJwX3ByZWZpeD0iJG9wdGFyZyIKICAgOzsKICAgLS1z b3VyY2UtcGF0aD0qKSBzb3VyY2VfcGF0aD0iJG9wdGFyZyIKLSAgc291cmNlX3BhdGhfdXNlZD0i eWVzIgogICA7OwogICAtLWNyb3NzLXByZWZpeD0qKQogICA7OwpAQCAtMzExOSwyNyArMzEyMSwy OCBAQCBlY2hvICJRRU1VX0NGTEFHUys9JGNmbGFncyIgPj4gJGNvbmZpZ190YXJnZXRfbWFrCiBk b25lICMgZm9yIHRhcmdldCBpbiAkdGFyZ2V0cwogCiAjIGJ1aWxkIHRyZWUgaW4gb2JqZWN0IGRp cmVjdG9yeSBpZiBzb3VyY2UgcGF0aCBpcyBkaWZmZXJlbnQgZnJvbSBjdXJyZW50IG9uZQotaWYg dGVzdCAiJHNvdXJjZV9wYXRoX3VzZWQiID0gInllcyIgOyB0aGVuCi0gICAgRElSUz0idGVzdHMg dGVzdHMvY3JpcyBzbGlycCBhdWRpbyBibG9jayBuZXQgcGMtYmlvcy9vcHRpb25yb20iCi0gICAg RElSUz0iJERJUlMgcm9tcy9zZWFiaW9zIHJvbXMvdmdhYmlvcyIKLSAgICBESVJTPSIkRElSUyBm c2RldiB1aSIKLSAgICBGSUxFUz0iTWFrZWZpbGUgdGVzdHMvTWFrZWZpbGUiCi0gICAgRklMRVM9 IiRGSUxFUyB0ZXN0cy9jcmlzL01ha2VmaWxlIHRlc3RzL2NyaXMvLmdkYmluaXQiCi0gICAgRklM RVM9IiRGSUxFUyB0ZXN0cy90ZXN0LW1tYXAuYyIKLSAgICBGSUxFUz0iJEZJTEVTIHBjLWJpb3Mv b3B0aW9ucm9tL01ha2VmaWxlIHBjLWJpb3Mva2V5bWFwcyIKLSAgICBGSUxFUz0iJEZJTEVTIHJv bXMvc2VhYmlvcy9NYWtlZmlsZSByb21zL3ZnYWJpb3MvTWFrZWZpbGUiCi0gICAgZm9yIGJpb3Nf ZmlsZSBpbiAkc291cmNlX3BhdGgvcGMtYmlvcy8qLmJpbiAkc291cmNlX3BhdGgvcGMtYmlvcy8q LmR0YiAkc291cmNlX3BhdGgvcGMtYmlvcy9vcGVuYmlvcy0qOyBkbwotICAgICAgICBGSUxFUz0i JEZJTEVTIHBjLWJpb3MvYGJhc2VuYW1lICRiaW9zX2ZpbGVgIgotICAgIGRvbmUKLSAgICBmb3Ig ZGlyIGluICRESVJTIDsgZG8KLSAgICAgICAgICAgIG1rZGlyIC1wICRkaXIKLSAgICBkb25lCi0g ICAgIyByZW1vdmUgdGhlIGxpbmsgYW5kIHJlY3JlYXRlIGl0LCBhcyBub3QgYWxsICJsbiAtc2Yi IG92ZXJ3cml0ZSB0aGUgbGluawotICAgIGZvciBmIGluICRGSUxFUyA7IGRvCi0gICAgICAgIHJt IC1mICRmCi0gICAgICAgIGxuIC1zICRzb3VyY2VfcGF0aC8kZiAkZgotICAgIGRvbmUKLWZpCitE SVJTPSJ0ZXN0cyB0ZXN0cy9jcmlzIHNsaXJwIGF1ZGlvIGJsb2NrIG5ldCBwYy1iaW9zL29wdGlv bnJvbSIKK0RJUlM9IiRESVJTIHJvbXMvc2VhYmlvcyByb21zL3ZnYWJpb3MiCitESVJTPSIkRElS UyBmc2RldiB1aSIKK0ZJTEVTPSJ0ZXN0cy9NYWtlZmlsZSIKK0ZJTEVTPSIkRklMRVMgdGVzdHMv Y3Jpcy9NYWtlZmlsZSB0ZXN0cy9jcmlzLy5nZGJpbml0IgorRklMRVM9IiRGSUxFUyB0ZXN0cy90 ZXN0LW1tYXAuYyIKK0ZJTEVTPSIkRklMRVMgcGMtYmlvcy9vcHRpb25yb20vTWFrZWZpbGUgcGMt Ymlvcy9rZXltYXBzIgorRklMRVM9IiRGSUxFUyByb21zL3NlYWJpb3MvTWFrZWZpbGUgcm9tcy92 Z2FiaW9zL01ha2VmaWxlIgorZm9yIGJpb3NfZmlsZSBpbiAkc291cmNlX3BhdGgvcGMtYmlvcy8q LmJpbiAkc291cmNlX3BhdGgvcGMtYmlvcy8qLmR0YiAkc291cmNlX3BhdGgvcGMtYmlvcy9vcGVu Ymlvcy0qOyBkbworICAgIEZJTEVTPSIkRklMRVMgcGMtYmlvcy9gYmFzZW5hbWUgJGJpb3NfZmls ZWAiCitkb25lCitmb3IgZGlyIGluICRESVJTIDsgZG8KKyAgICBta2RpciAtcCAkZGlyCitkb25l CisKK2xuIC1zICRzb3VyY2VfcGF0aC9NYWtlZmlsZS50b3AgTWFrZWZpbGUKKworIyByZW1vdmUg dGhlIGxpbmsgYW5kIHJlY3JlYXRlIGl0LCBhcyBub3QgYWxsICJsbiAtc2YiIG92ZXJ3cml0ZSB0 aGUgbGluaworZm9yIGYgaW4gJEZJTEVTIDsgZG8KKyAgICBybSAtZiAkZgorICAgIGxuIC1zICRz b3VyY2VfcGF0aC8kZiAkZgorZG9uZQogCiAjIHRlbXBvcmFyeSBjb25maWcgdG8gYnVpbGQgc3Vi bW9kdWxlcwogZm9yIHJvbSBpbiBzZWFiaW9zIHZnYWJpb3MgOyBkbwotLSAKMS41LjYuNQoK --0016e641dc6680179204954480c5--