From nobody@FreeBSD.org  Thu Feb  9 20:24:09 2012
Return-Path: <nobody@FreeBSD.org>
Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34])
	by hub.freebsd.org (Postfix) with ESMTP id 7CD85106564A
	for <freebsd-gnats-submit@FreeBSD.org>; Thu,  9 Feb 2012 20:24:09 +0000 (UTC)
	(envelope-from nobody@FreeBSD.org)
Received: from red.freebsd.org (red.freebsd.org [IPv6:2001:4f8:fff6::22])
	by mx1.freebsd.org (Postfix) with ESMTP id 6A88E8FC0A
	for <freebsd-gnats-submit@FreeBSD.org>; Thu,  9 Feb 2012 20:24:09 +0000 (UTC)
Received: from red.freebsd.org (localhost [127.0.0.1])
	by red.freebsd.org (8.14.4/8.14.4) with ESMTP id q19KO9dt049072
	for <freebsd-gnats-submit@FreeBSD.org>; Thu, 9 Feb 2012 20:24:09 GMT
	(envelope-from nobody@red.freebsd.org)
Received: (from nobody@localhost)
	by red.freebsd.org (8.14.4/8.14.4/Submit) id q19KO98D049044;
	Thu, 9 Feb 2012 20:24:09 GMT
	(envelope-from nobody)
Message-Id: <201202092024.q19KO98D049044@red.freebsd.org>
Date: Thu, 9 Feb 2012 20:24:09 GMT
From: Per Ola Ingvarsson <skrabban@gmail.com>
To: freebsd-gnats-submit@FreeBSD.org
Subject: [UPDATE/NEW PORTS] jamvm/classpath w/o jdk
X-Send-Pr-Version: www-3.1
X-GNATS-Notify: bkoenig@alpha-tierchen.de

>Number:         164941
>Category:       ports
>Synopsis:       [UPDATE] [NEW PORTS] java/classpath-initial, including rework of java/classpath
>Confidential:   no
>Severity:       non-critical
>Priority:       low
>Responsible:    freebsd-java
>State:          open
>Quarter:        
>Keywords:       
>Date-Required:  
>Class:          change-request
>Submitter-Id:   current-users
>Arrival-Date:   Thu Feb 09 20:30:12 UTC 2012
>Closed-Date:    
>Last-Modified:  Tue Feb 19 21:40:00 UTC 2013
>Originator:     Per Ola Ingvarsson
>Release:        FreeBSD 8.1-RELEASE/9.0-RELEASE
>Organization:
N/A
>Environment:
FreeBSD funk.my.domain 8.1-RELEASE FreeBSD 8.1-RELEASE #0: Mon Jul 19 06:53:42 UTC 2010     root@araz.cse.buffalo.edu:/usr/obj/usr/src/sys/GENERIC  sparc64
>Description:
Version 1.5.4, jamvm has support for sparc64, but also depends on a
version of classpath that cannot be compiled without some kind of java,
which is not available on sparc64.

The patches attached contain:
1. Update jamvm to 1.5.4
2. Update classpath to 0.98
3. Use ecj + antlr + jamvm-initial instead of jdk when building classpath-0.98
4. New package jamvm-initial-1.5.1 patched for sparc64 which is the jvm used
   when running ecj above
5. New package classpath-initial-0.93 which is the java library used by
   jamvm-initial

jamvm-initial and classpath-initial are not useful once jamvm and classpath are built.

The packages have been successfully built/installed on sparc64/amd64/i386.
Chances are that it also works on powerpc/arm.
>How-To-Repeat:

>Fix:


Patch attached with submission follows:

diff --git a/java/classpath-initial/Makefile b/java/classpath-initial/Makefile
new file mode 100644
index 0000000..da11ac1
--- /dev/null
+++ b/java/classpath-initial/Makefile
@@ -0,0 +1,32 @@
+# New ports collection makefile for:    classpath-initial
+# Date created:                         2012-02-08
+# Whom:                                 Per Ola Ingvarsson
+#
+# $FreeBSD: ports/java/classpath/Makefile,v 1.40 2011/09/23 22:23:40 amdmi3 Exp $
+#
+
+PORTNAME=	classpath
+PORTVERSION=	0.93
+CATEGORIES=	java devel
+MASTER_SITES=	${MASTER_SITE_GNU} \
+		${MASTER_SITE_SAVANNAH}
+MASTER_SITE_SUBDIR=	classpath
+PKGNAMESUFFIX=	-initial
+
+MAINTAINER=	skrabban@gmail.com
+COMMENT=	Java libraries to be used with jamvm-initial to build newer classpath
+
+BUILD_DEPENDS=	zip:${PORTSDIR}/archivers/zip \
+		jikes:${PORTSDIR}/java/jikes
+
+USE_LDCONFIG=	yes
+GNU_CONFIGURE=	yes
+CXXFLAGS+=	-I${LOCALBASE}/include
+
+CONFIGURE_ARGS=	--enable-jni --disable-alsa --disable-dssi \
+		--disable-plugin --disable-gtk-peer --with-jikes \
+		--disable-examples --disable-gconf-peer
+
+USE_GMAKE=	yes
+
+.include <bsd.port.mk>
diff --git a/java/classpath-initial/distinfo b/java/classpath-initial/distinfo
new file mode 100644
index 0000000..c06896d
--- /dev/null
+++ b/java/classpath-initial/distinfo
@@ -0,0 +1,2 @@
+SHA256 (classpath-0.93.tar.gz) = df2d093612abd23fe67e9409d89bb2a8e79b1664fe2b2da40e1c8ed693e32945
+SIZE (classpath-0.93.tar.gz) = 9534222
diff --git a/java/classpath-initial/files/patch-configure b/java/classpath-initial/files/patch-configure
new file mode 100644
index 0000000..89cb7b9
--- /dev/null
+++ b/java/classpath-initial/files/patch-configure
@@ -0,0 +1,11 @@
+--- configure.orig	2012-01-17 20:50:46.000000000 +0100
++++ configure	2012-01-17 20:50:31.000000000 +0100
+@@ -1998,7 +1998,7 @@ fi
+ 
+ 
+ # Define the identity of the package.
+- PACKAGE='classpath'
++ PACKAGE='classpath-initial'
+  VERSION='0.93'
+ 
+ 
diff --git a/java/classpath-initial/files/patch-doc_Makefile.in b/java/classpath-initial/files/patch-doc_Makefile.in
new file mode 100644
index 0000000..8cb4e30
--- /dev/null
+++ b/java/classpath-initial/files/patch-doc_Makefile.in
@@ -0,0 +1,16 @@
+--- doc/Makefile.in.orig	2012-01-25 20:21:40.000000000 +0100
++++ doc/Makefile.in	2012-01-25 20:22:20.000000000 +0100
+@@ -707,11 +707,11 @@ info: info-recursive
+ 
+ info-am: $(INFO_DEPS)
+ 
+-install-data-am: install-info-am
++install-data-am: 
+ 
+ install-exec-am:
+ 
+-install-info: install-info-recursive
++install-info: 
+ 
+ install-info-am: $(INFO_DEPS)
+ 	@$(NORMAL_INSTALL)
diff --git a/java/classpath-initial/files/patch-include_Makefile.in b/java/classpath-initial/files/patch-include_Makefile.in
new file mode 100644
index 0000000..f3cd2ed
--- /dev/null
+++ b/java/classpath-initial/files/patch-include_Makefile.in
@@ -0,0 +1,11 @@
+--- include/Makefile.in.orig	2012-01-25 20:13:18.000000000 +0100
++++ include/Makefile.in	2012-01-25 20:13:37.000000000 +0100
+@@ -655,7 +655,7 @@ info: info-am
+ 
+ info-am:
+ 
+-install-data-am: install-includeHEADERS
++install-data-am:
+ 
+ install-exec-am:
+ 
diff --git a/java/classpath-initial/files/patch-native_jni_native-lib_cpnet.h b/java/classpath-initial/files/patch-native_jni_native-lib_cpnet.h
new file mode 100644
index 0000000..7b18afc
--- /dev/null
+++ b/java/classpath-initial/files/patch-native_jni_native-lib_cpnet.h
@@ -0,0 +1,10 @@
+--- native/jni/native-lib/cpnet.h.orig	2012-01-16 22:34:30.000000000 +0100
++++ native/jni/native-lib/cpnet.h	2012-01-16 22:35:05.000000000 +0100
+@@ -42,6 +42,7 @@ exception statement from your version. *
+ #include <jcl.h>
+ #include <string.h>
+ 
++#include <sys/types.h>
+ #include <sys/socket.h>
+ #include <netinet/in.h>
+ #include <netinet/ip.h>
diff --git a/java/classpath-initial/files/patch-resource_Makefile.in b/java/classpath-initial/files/patch-resource_Makefile.in
new file mode 100644
index 0000000..3571af2
--- /dev/null
+++ b/java/classpath-initial/files/patch-resource_Makefile.in
@@ -0,0 +1,11 @@
+--- resource/Makefile.in.orig	2012-01-25 20:23:52.000000000 +0100
++++ resource/Makefile.in	2012-01-25 20:24:18.000000000 +0100
+@@ -461,7 +461,7 @@ info: info-am
+ 
+ info-am:
+ 
+-install-data-am: install-loggingDATA install-securityDATA
++install-data-am:
+ 
+ install-exec-am:
+ 
diff --git a/java/classpath-initial/files/patch-tools_Makefile.in b/java/classpath-initial/files/patch-tools_Makefile.in
new file mode 100644
index 0000000..556c0e2
--- /dev/null
+++ b/java/classpath-initial/files/patch-tools_Makefile.in
@@ -0,0 +1,11 @@
+--- tools/Makefile.in.orig	2012-01-25 11:06:03.000000000 +0100
++++ tools/Makefile.in	2012-01-25 11:06:39.000000000 +0100
+@@ -1043,7 +1043,7 @@ info-am:
+ 
+ install-data-am: install-TOOLSDATA
+ 
+-install-exec-am: install-binPROGRAMS install-binSCRIPTS
++install-exec-am:
+ 
+ install-info: install-info-am
+ 
diff --git a/java/classpath-initial/pkg-descr b/java/classpath-initial/pkg-descr
new file mode 100644
index 0000000..c0dcfc6
--- /dev/null
+++ b/java/classpath-initial/pkg-descr
@@ -0,0 +1,8 @@
+The purpose of this package is to provide a java library for jamvm-initial which 
+is used when building classpath with generics.
+
+GNU Classpath, Essential Libraries for Java, is a GNU project to create free
+core class libraries for use with virtual machines and compilers for the Java
+programming language.
+
+WWW: http://www.classpath.org/
diff --git a/java/classpath-initial/pkg-plist b/java/classpath-initial/pkg-plist
new file mode 100644
index 0000000..80d18b3
--- /dev/null
+++ b/java/classpath-initial/pkg-plist
@@ -0,0 +1,22 @@
+lib/classpath-initial/libjavaio.la
+lib/classpath-initial/libjavaio.so
+lib/classpath-initial/libjavaio.so.0
+lib/classpath-initial/libjavalang.la
+lib/classpath-initial/libjavalang.so
+lib/classpath-initial/libjavalang.so.0
+lib/classpath-initial/libjavalangreflect.la
+lib/classpath-initial/libjavalangreflect.so
+lib/classpath-initial/libjavalangreflect.so.0
+lib/classpath-initial/libjavanet.la
+lib/classpath-initial/libjavanet.so
+lib/classpath-initial/libjavanet.so.0
+lib/classpath-initial/libjavanio.la
+lib/classpath-initial/libjavanio.so
+lib/classpath-initial/libjavanio.so.0
+lib/classpath-initial/libjavautil.la
+lib/classpath-initial/libjavautil.so
+lib/classpath-initial/libjavautil.so.0
+@dirrm lib/classpath-initial
+share/classpath-initial/glibj.zip
+share/classpath-initial/tools.zip
+@dirrm share/classpath-initial
diff --git a/java/classpath/Makefile b/java/classpath/Makefile
index 11384ae..e960d51 100644
--- a/java/classpath/Makefile
+++ b/java/classpath/Makefile
@@ -7,27 +7,38 @@
 #
 
 PORTNAME=	classpath
-PORTVERSION=	0.97.2
-PORTREVISION=	4
+PORTVERSION=	0.98
+PORTREVISION=	5
 CATEGORIES=	java devel
-MASTER_SITES=	${MASTER_SITE_GNU} \
-		${MASTER_SITE_SAVANNAH}
-MASTER_SITE_SUBDIR=	${PORTNAME}
+MASTER_SITES=	${MASTER_SITE_GNU}:s0 \
+		${MASTER_SITE_SAVANNAH}:s0 \
+		http://archive.eclipse.org/eclipse/downloads/drops/R-3.2.2-200702121330/:s1 \
+		http://www.antlr2.org/download/:s2
+MASTER_SITE_SUBDIR=	${PORTNAME}/:s0
+DISTFILES=	${DISTNAME}.tar.gz:s0 \
+		ecj.jar:s1 \
+		antlr-2.7.5.jar:s2
+DIST_SUBDIR=	${PORTNAME}
+EXTRACT_ONLY=	${DISTNAME}.tar.gz
 
 MAINTAINER=	bkoenig@alpha-tierchen.de
 COMMENT=	A GNU project to create a free Java class library
 
-BUILD_DEPENDS=	zip:${PORTSDIR}/archivers/zip
+BUILD_DEPENDS=	zip:${PORTSDIR}/archivers/zip \
+		jamvm-initial:${PORTSDIR}/java/jamvm-initial \
+		fastjar:${PORTSDIR}/archivers/fastjar
 
-USE_JAVA=	yes
-JAVA_VERSION=	1.5+
 USE_XORG=	x11 ice xtst xaw xproto xext
 WANT_GNOME=	yes
 USE_LDCONFIG=	yes
 GNU_CONFIGURE=	yes
 CXXFLAGS+=	-I${LOCALBASE}/include
-CONFIGURE_ARGS=	--enable-jni --disable-alsa --disable-dssi --disable-plugin
+CONFIGURE_ENV=	JAVA=jamvm-initial PATH=${PATH}:${WRKDIR}/bin
+CONFIGURE_ARGS=	--enable-jni --disable-alsa --disable-dssi --disable-plugin \
+		--with-antlr-jar=${DISTDIR}/${DIST_SUBDIR}/antlr-2.7.5.jar
+
 USE_GMAKE=	yes
+MAKE_ENV+=	PATH=${PATH}:${WRKDIR}/bin
 
 MAN1=		gappletviewer.1 \
 		gjar.1 \
@@ -44,13 +55,20 @@ MAN1=		gappletviewer.1 \
 
 INFO=		cp-hacking cp-tools cp-vmintegration
 
-CONFLICTS=	sablevm-classpath-*
+CONFLICTS=	sablevm-classpath-[0-9]*
 
 OPTIONS=	GCONF "Use GConf based preferences backend" OFF \
 		GTK2 "Enable Gtk+ AWT peer" ON \
 		CAIRO "Use Gtk+ Cairo based Graphics2D" OFF \
 		QT4 "Enable Qt AWT peer" OFF
 
+pre-patch:
+	@${MKDIR} ${WRKDIR}/bin
+	@${SED} -e 's,%%DISTDIR%%,${DISTDIR}/${DIST_SUBDIR},' \
+		< ${FILESDIR}/ecj.in \
+		> ${WRKDIR}/bin/ecj
+	@${CHMOD} +x ${WRKDIR}/bin/ecj
+
 .include <bsd.port.pre.mk>
 
 .if defined(WITH_GCONF)
diff --git a/java/classpath/distinfo b/java/classpath/distinfo
index 60d7eba..dff43c6 100644
--- a/java/classpath/distinfo
+++ b/java/classpath/distinfo
@@ -1,2 +1,6 @@
-SHA256 (classpath-0.97.2.tar.gz) = 001fee5ad3ddd043783d59593153510f09064b0d9b5aea82f535266f62f02db4
-SIZE (classpath-0.97.2.tar.gz) = 10318014
+SHA256 (classpath/classpath-0.98.tar.gz) = 501b5acd4dff79b6100da22cef15080f31071821ce3cea6f1b739bc1b56fac3f
+SIZE (classpath/classpath-0.98.tar.gz) = 11021342
+SHA256 (classpath/ecj.jar) = 3b26627f4c998c67f147392dc3355f38b05769e400925a7c4f9ff68819f1c303
+SIZE (classpath/ecj.jar) = 1323277
+SHA256 (classpath/antlr-2.7.5.jar) = 2433e7e36ebbebe72390036ec555f4c6771eaed33d507b3d5d65497804093a0d
+SIZE (classpath/antlr-2.7.5.jar) = 435563
diff --git a/java/classpath/files/ecj.in b/java/classpath/files/ecj.in
new file mode 100644
index 0000000..165ee36
--- /dev/null
+++ b/java/classpath/files/ecj.in
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+CLASSPATH=%%DISTDIR%%/ecj.jar${CLASSPATH:+:}$CLASSPATH \
+exec jamvm-initial -Xmx768m org.eclipse.jdt.internal.compiler.batch.Main -nowarn "$@"
diff --git a/java/jamvm-initial/Makefile b/java/jamvm-initial/Makefile
new file mode 100644
index 0000000..b9bf3be
--- /dev/null
+++ b/java/jamvm-initial/Makefile
@@ -0,0 +1,38 @@
+# New ports collection makefile for:	jamvm-initial
+# Date created:				2012-02-08
+# Whom:					Per Ola Ingvarsson
+#
+# $FreeBSD: ports/java/jamvm/Makefile,v 1.8 2011/09/23 22:23:40 amdmi3 Exp $
+
+PORTNAME=	jamvm
+PORTVERSION=	1.5.1
+CATEGORIES=	java devel
+MASTER_SITES=	SF/jamvm/jamvm/JamVM%20${PORTVERSION}
+PKGNAMESUFFIX=	-initial
+
+MAINTAINER=	skrabban@gmail.com
+COMMENT=	Bootstrap jamvm to compile classpath with ecj
+
+RUN_DEPENDS=	${LOCALBASE}/share/classpath-initial/glibj.zip:${PORTSDIR}/java/classpath-initial
+
+GNU_CONFIGURE=	yes
+CONFIGURE_ARGS=	--with-classpath-install-dir=${LOCALBASE}
+USE_GMAKE=	yes
+
+.include <bsd.port.pre.mk>
+
+LIB_DEPENDS+=		ffi:${PORTSDIR}/devel/libffi
+CONFIGURE_ARGS+=	--enable-ffi
+LDFLAGS+=	-L${LOCALBASE}/lib
+CFLAGS+=	`pkg-config libffi --cflags`
+
+BUILD_DEPENDS+=		zip:${PORTSDIR}/archivers/zip
+PLIST_SUB+=		WITH_ZIP="" WITHOUT_ZIP="@comment "
+
+do-install:
+	${INSTALL_PROGRAM} -s ${WRKSRC}/src/jamvm-initial ${PREFIX}/bin
+	${MKDIR} ${PREFIX}/share/jamvm-initial
+	${INSTALL_DATA} ${WRKSRC}/lib/classes.zip \
+		${PREFIX}/share/jamvm-initial
+
+.include <bsd.port.post.mk>
diff --git a/java/jamvm-initial/distinfo b/java/jamvm-initial/distinfo
new file mode 100644
index 0000000..2b59b45
--- /dev/null
+++ b/java/jamvm-initial/distinfo
@@ -0,0 +1,2 @@
+SHA256 (jamvm-1.5.1.tar.gz) = 663895bd69caf3a1fda6af5eea8263d90a5fd35ca8f4c32e2210ac410788901a
+SIZE (jamvm-1.5.1.tar.gz) = 599084
diff --git a/java/jamvm-initial/files/patch-configure b/java/jamvm-initial/files/patch-configure
new file mode 100644
index 0000000..62ff08d
--- /dev/null
+++ b/java/jamvm-initial/files/patch-configure
@@ -0,0 +1,32 @@
+--- configure.orig	2008-03-02 05:16:07.000000000 +0100
++++ configure	2012-01-27 15:03:21.000000000 +0100
+@@ -2552,8 +2552,10 @@ i386-*-freebsd*) host_os=bsd libdl_neede
+ x86_64-*-linux*) host_os=linux ;;
+ hppa*-*-linux*) host_cpu=parisc host_os=linux ;;
+ mipsel-*-linux*) host_cpu=mips host_os=linux ;;
+-amd64-*-openbsd*) host_os=bsd libdl_needed=no ;;
+-amd64-*-freebsd*) host_os=bsd libdl_needed=no ;;
++amd64-*-openbsd*) host_os=bsd host_cpu=x86_64 libdl_needed=no ;;
++amd64-*-freebsd*) host_os=bsd host_cpu=x86_64 libdl_needed=no ;;
++sparc64*-*-openbsd*) host_cpu=sparc64 host_os=bsd libdl_needed=no ;;
++sparc64*-*-freebsd*) host_cpu=sparc64 host_os=bsd libdl_needed=no ;;
+ arm*-*-linux*) host_cpu=arm host_os=linux ;;
+ arm*-*-openbsd*) host_cpu=arm host_os=bsd libdl_needed=no ;;
+ arm*-*-freebsd*) host_cpu=arm host_os=bsd libdl_needed=no ;;
+@@ -22839,7 +22841,7 @@ fi
+ ac_config_links="$ac_config_links src/arch.h:src/arch/$arch.h"
+ 
+ 
+-ac_config_files="$ac_config_files Makefile src/Makefile src/interp/Makefile src/interp/engine/Makefile src/arch/Makefile src/os/Makefile src/os/linux/Makefile src/os/darwin/Makefile src/os/bsd/Makefile src/os/linux/powerpc/Makefile src/os/linux/arm/Makefile src/os/linux/i386/Makefile src/os/linux/x86_64/Makefile src/os/linux/parisc/Makefile src/os/linux/mips/Makefile src/os/darwin/i386/Makefile src/os/darwin/arm/Makefile src/os/darwin/powerpc/Makefile src/os/bsd/powerpc/Makefile src/os/bsd/arm/Makefile src/os/bsd/i386/Makefile src/os/bsd/x86_64/Makefile lib/Makefile lib/java/Makefile lib/java/lang/Makefile lib/jamvm/Makefile lib/jamvm/java/Makefile lib/jamvm/java/lang/Makefile lib/java/lang/reflect/Makefile lib/java/security/Makefile lib/gnu/Makefile lib/sun/reflect/annotation/Makefile lib/sun/reflect/Makefile lib/sun/Makefile lib/gnu/classpath/Makefile"
++ac_config_files="$ac_config_files Makefile src/Makefile src/interp/Makefile src/interp/engine/Makefile src/arch/Makefile src/os/Makefile src/os/linux/Makefile src/os/darwin/Makefile src/os/bsd/Makefile src/os/linux/powerpc/Makefile src/os/linux/arm/Makefile src/os/linux/i386/Makefile src/os/linux/x86_64/Makefile src/os/linux/parisc/Makefile src/os/linux/mips/Makefile src/os/darwin/i386/Makefile src/os/darwin/arm/Makefile src/os/darwin/powerpc/Makefile src/os/bsd/powerpc/Makefile src/os/bsd/arm/Makefile src/os/bsd/i386/Makefile src/os/bsd/x86_64/Makefile src/os/bsd/sparc64/Makefile lib/Makefile lib/java/Makefile lib/java/lang/Makefile lib/jamvm/Makefile lib/jamvm/java/Makefile lib/jamvm/java/lang/Makefile lib/java/lang/reflect/Makefile lib/java/security/Makefile lib/gnu/Makefile lib/sun/reflect/annotation/Makefile lib/sun/reflect/Makefile lib/sun/Makefile lib/gnu/classpath/Makefile"
+ 
+ 
+ cat >confcache <<\_ACEOF
+@@ -23483,6 +23485,7 @@ do
+     "src/os/bsd/arm/Makefile") CONFIG_FILES="$CONFIG_FILES src/os/bsd/arm/Makefile" ;;
+     "src/os/bsd/i386/Makefile") CONFIG_FILES="$CONFIG_FILES src/os/bsd/i386/Makefile" ;;
+     "src/os/bsd/x86_64/Makefile") CONFIG_FILES="$CONFIG_FILES src/os/bsd/x86_64/Makefile" ;;
++    "src/os/bsd/sparc64/Makefile") CONFIG_FILES="$CONFIG_FILES src/os/bsd/x86_64/Makefile" ;;
+     "lib/Makefile") CONFIG_FILES="$CONFIG_FILES lib/Makefile" ;;
+     "lib/java/Makefile") CONFIG_FILES="$CONFIG_FILES lib/java/Makefile" ;;
+     "lib/java/lang/Makefile") CONFIG_FILES="$CONFIG_FILES lib/java/lang/Makefile" ;;
diff --git a/java/jamvm-initial/files/patch-lib_Makefile.in b/java/jamvm-initial/files/patch-lib_Makefile.in
new file mode 100644
index 0000000..3fafe0a
--- /dev/null
+++ b/java/jamvm-initial/files/patch-lib_Makefile.in
@@ -0,0 +1,11 @@
+--- lib/Makefile.in.orig	2012-01-17 21:05:26.000000000 +0100
++++ lib/Makefile.in	2012-01-17 21:06:18.000000000 +0100
+@@ -176,7 +176,7 @@ top_srcdir = @top_srcdir@
+ use_zip_no = @use_zip_no@
+ use_zip_yes = @use_zip_yes@
+ with_classpath_install_dir = @with_classpath_install_dir@
+-CP_LIB_DIR = ${with_classpath_install_dir}/share/classpath
++CP_LIB_DIR = ${with_classpath_install_dir}/share/classpath-initial
+ GLIBJ_ZIP = ${CP_LIB_DIR}/glibj.zip
+ SUBDIRS = jamvm java gnu sun
+ EXTRA_DIST = classes.zip README
diff --git a/java/jamvm-initial/files/patch-src_Makefile.in b/java/jamvm-initial/files/patch-src_Makefile.in
new file mode 100644
index 0000000..d159703
--- /dev/null
+++ b/java/jamvm-initial/files/patch-src_Makefile.in
@@ -0,0 +1,21 @@
+--- src/Makefile.in.orig	2012-01-17 21:53:44.000000000 +0100
++++ src/Makefile.in	2012-01-17 21:50:39.000000000 +0100
+@@ -34,7 +34,7 @@ PRE_UNINSTALL = :
+ POST_UNINSTALL = :
+ build_triplet = @build@
+ host_triplet = @host@
+-bin_PROGRAMS = jamvm$(EXEEXT)
++bin_PROGRAMS = jamvm$(EXEEXT) jamvm-initial$(EXEEXT)
+ subdir = src
+ DIST_COMMON = $(include_HEADERS) $(srcdir)/Makefile.am \
+ 	$(srcdir)/Makefile.in $(srcdir)/config.h.in
+@@ -360,6 +360,9 @@ jamvm$(EXEEXT): $(jamvm_OBJECTS) $(jamvm
+ 	@rm -f jamvm$(EXEEXT)
+ 	$(LINK) $(jamvm_OBJECTS) $(jamvm_LDADD) $(LIBS)
+ 
++jamvm-initial$(EXEEXT): jamvm$(EXEEXT)
++	@cp jamvm$(EXEEXT) jamvm-initial$(EXEEXT)
++
+ mostlyclean-compile:
+ 	-rm -f *.$(OBJEXT)
+ 
diff --git a/java/jamvm-initial/files/patch-src_alloc.c b/java/jamvm-initial/files/patch-src_alloc.c
new file mode 100644
index 0000000..a14b720
--- /dev/null
+++ b/java/jamvm-initial/files/patch-src_alloc.c
@@ -0,0 +1,46 @@
+--- src/alloc.c.orig	2008-02-22 02:57:42.000000000 +0100
++++ src/alloc.c	2012-01-26 19:32:40.000000000 +0100
+@@ -2134,8 +2134,8 @@ unsigned long maxHeapMem() {
+     suspended while holding the malloc lock */
+ 
+ void *gcMemMalloc(int n) {
+-    int size = n + sizeof(int);
+-    int *mem = mmap(0, size, PROT_READ|PROT_WRITE,
++    uintptr_t size = n + sizeof(uintptr_t);
++    uintptr_t *mem = mmap(0, size, PROT_READ|PROT_WRITE,
+                              MAP_PRIVATE|MAP_ANON, -1, 0);
+ 
+     if(mem == MAP_FAILED) {
+@@ -2151,9 +2151,9 @@ void *gcMemRealloc(void *addr, int size)
+     if(addr == NULL)
+         return gcMemMalloc(size);
+     else {
+-        int *mem = addr;
+-        int old_size = *--mem;
+-        int new_size = size + sizeof(int);
++        uintptr_t *mem = addr;
++        uintptr_t old_size = *--mem;
++        uintptr_t new_size = size + sizeof(uintptr_t);
+ 
+         if(old_size/sys_page_size == new_size/sys_page_size) {
+             *mem = new_size;
+@@ -2162,7 +2162,7 @@ void *gcMemRealloc(void *addr, int size)
+             int copy_size = new_size > old_size ? old_size : new_size;
+             void *new_mem = gcMemMalloc(size);
+ 
+-            memcpy(new_mem, addr, copy_size - sizeof(int));
++            memcpy(new_mem, addr, copy_size - sizeof(uintptr_t));
+             munmap(mem, old_size);
+ 
+             return new_mem;
+@@ -2172,8 +2172,8 @@ void *gcMemRealloc(void *addr, int size)
+ 
+ void gcMemFree(void *addr) {
+     if(addr != NULL) {
+-        int *mem = addr;
+-        int size = *--mem;
++        uintptr_t *mem = addr;
++        uintptr_t size = *--mem;
+         munmap(mem, size);
+     }
+ }
diff --git a/java/jamvm-initial/files/patch-src_arch_sparc64.h b/java/jamvm-initial/files/patch-src_arch_sparc64.h
new file mode 100644
index 0000000..c4af4c1
--- /dev/null
+++ b/java/jamvm-initial/files/patch-src_arch_sparc64.h
@@ -0,0 +1,137 @@
+--- src/arch/sparc64.h.orig	2012-01-26 19:32:40.000000000 +0100
++++ src/arch/sparc64.h	2012-01-26 19:32:40.000000000 +0100
+@@ -0,0 +1,134 @@
++/*
++ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
++ * Robert Lougher <rob@lougher.org.uk>.
++ *
++ * This file is part of JamVM.
++ *
++ * This program is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License
++ * as published by the Free Software Foundation; either version 2,
++ * or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
++ */
++
++#define OS_ARCH "sparc64"
++
++#define HANDLER_TABLE_T static const void
++#define DOUBLE_1_BITS 0x3ff0000000000000LL
++
++#define READ_DBL(v,p,l)	v = ((u8)p[0]<<56)|((u8)p[1]<<48)|((u8)p[2]<<40)  \
++                            |((u8)p[3]<<32)|((u8)p[4]<<24)|((u8)p[5]<<16) \
++                            |((u8)p[6]<<8)|(u8)p[7]; p+=8
++
++#define FPU_HACK
++
++static inline uint32_t
++compare_and_swap_32(volatile uint32_t *addr, uint32_t oldval, uint32_t newval)
++{
++   uint32_t result;
++   __asm__ __volatile__ ("cas [%4], %2, %0"
++   			: "=r" (result), "=m" (*addr)
++			: "r" (oldval), "m" (*addr), "r" (addr),
++			"0" (newval));
++  return result == oldval;
++}
++
++#define COMPARE_AND_SWAP32 compare_and_swap_32
++
++static inline uint64_t
++compare_and_swap_64( volatile uint64_t *addr, 
++                     volatile uint64_t oldval, 
++                     volatile uint64_t newval )
++{
++#if 1
++   uint64_t result;
++   __asm__ __volatile__ ("casx [%4], %2, %0"
++   			: "=r" (result), "=m" (*addr)
++			: "r" (oldval), "m" (*addr), "r" (addr),
++			"0" (newval));
++  return result == oldval;
++#else
++  if(*addr == oldval) {                       
++        *addr = newval;                        
++        return 1;
++    } else {
++        return 0;
++    }
++  
++#endif
++}
++
++#define COMPARE_AND_SWAP64 compare_and_swap_64    
++#ifdef __arch64__
++#  define COMPARE_AND_SWAP COMPARE_AND_SWAP64
++#else
++#  define COMPARE_AND_SWAP COMPARE_AND_SWAP32
++#endif
++
++#define STORE_LOAD __asm__ __volatile__ ("membar #StoreLoad" : : : "memory")
++
++
++#define LOCKWORD_READ(addr) ({ STORE_LOAD; *addr; })
++#define LOCKWORD_WRITE(addr, value) ({ STORE_LOAD; *addr = value; })
++#define LOCKWORD_COMPARE_AND_SWAP COMPARE_AND_SWAP
++
++#define __GEN_REL_JMP(target_addr, patch_addr, opcode,       \
++                      type, patch_size)                      \
++({                                                           \
++    int patched = FALSE;                                     \
++                                                             \
++    if(patch_size >= 1 + sizeof(type)) {                     \
++        char *nxt_ins_ptr = (patch_addr) + 1 + sizeof(type); \
++        uintptr_t limit = 1ULL<<((sizeof(type) * 8) - 1);    \
++                                                             \
++        /* The check is done in two parts to ensure the      \
++           result is always positive, to guard against       \
++           the pointer difference being larger than the      \
++           signed range */                                   \
++        if(target_addr > nxt_ins_ptr) {                      \
++            uintptr_t disp = (target_addr) - (nxt_ins_ptr);  \
++                                                             \
++            if(disp < limit) {                               \
++                *(patch_addr) = opcode;                      \
++                *(type*)&(patch_addr)[1] = disp;             \
++                patched = TRUE;                              \
++            }                                                \
++        } else {                                             \
++            uintptr_t disp = (nxt_ins_ptr) - (target_addr);  \
++                                                             \
++            if(disp <= limit) {                              \
++                *(patch_addr) = opcode;                      \
++                *(type*)&(patch_addr)[1] = -disp;            \
++                patched = TRUE;                              \
++            }                                                \
++        }                                                    \
++    }                                                        \
++    patched;                                                 \
++})
++
++#define GEN_REL_JMP(target_addr, patch_addr, patch_size) \
++({                                                       \
++    __GEN_REL_JMP(target_addr, patch_addr, 0xeb,         \
++                  signed char, patch_size) ||            \
++    __GEN_REL_JMP(target_addr, patch_addr, 0xe9,         \
++                  signed int, patch_size);               \
++})
++
++#ifdef INLINING
++#error "I don't know how to flush"
++#define FLUSH_CACHE(addr, length)
++#endif
++#define MBARRIER() __asm__ __volatile__ ("membar #LoadLoad | #LoadStore"\
++                        " | #StoreLoad | #StoreStore" : : : "memory")
++#define UNLOCK_MBARRIER() MBARRIER()
++#define JMM_LOCK_MBARRIER() MBARRIER()
++#define JMM_UNLOCK_MBARRIER() MBARRIER()
++
diff --git a/java/jamvm-initial/files/patch-src_class.h b/java/jamvm-initial/files/patch-src_class.h
new file mode 100644
index 0000000..47cab95
--- /dev/null
+++ b/java/jamvm-initial/files/patch-src_class.h
@@ -0,0 +1,18 @@
+--- src/class.h.orig	2012-01-17 22:03:07.000000000 +0100
++++ src/class.h	2012-01-17 22:04:12.000000000 +0100
+@@ -39,11 +39,11 @@
+    separate class files in a directory structure */
+ 
+ #ifdef USE_ZIP
+-#define JAMVM_CLASSES INSTALL_DIR"/share/jamvm/classes.zip"
+-#define CLASSPATH_CLASSES CLASSPATH_INSTALL_DIR"/share/classpath/glibj.zip"
++#define JAMVM_CLASSES INSTALL_DIR"/share/jamvm-initial/classes.zip"
++#define CLASSPATH_CLASSES CLASSPATH_INSTALL_DIR"/share/classpath-initial/glibj.zip"
+ #else
+-#define JAMVM_CLASSES INSTALL_DIR"/share/jamvm/classes"
+-#define CLASSPATH_CLASSES CLASSPATH_INSTALL_DIR"/share/classpath"
++#define JAMVM_CLASSES INSTALL_DIR"/share/jamvm-initial/classes"
++#define CLASSPATH_CLASSES CLASSPATH_INSTALL_DIR"/share/classpath-initial"
+ #endif
+ 
+ #define DFLT_BCP JAMVM_CLASSES":"CLASSPATH_CLASSES
diff --git a/java/jamvm-initial/files/patch-src_dll.c b/java/jamvm-initial/files/patch-src_dll.c
new file mode 100644
index 0000000..3311a6d
--- /dev/null
+++ b/java/jamvm-initial/files/patch-src_dll.c
@@ -0,0 +1,11 @@
+--- src/dll.c.orig	2012-01-17 22:28:27.000000000 +0100
++++ src/dll.c	2012-01-17 22:28:40.000000000 +0100
+@@ -306,7 +306,7 @@ char *getDllPath() {
+ }
+ 
+ char *getBootDllPath() {
+-    return CLASSPATH_INSTALL_DIR"/lib/classpath";
++    return CLASSPATH_INSTALL_DIR"/lib/classpath-initial";
+ }
+ 
+ char *getDllName(char *name) {
diff --git a/java/jamvm-initial/files/patch-src_dll_ffi.c b/java/jamvm-initial/files/patch-src_dll_ffi.c
new file mode 100644
index 0000000..bcab484
--- /dev/null
+++ b/java/jamvm-initial/files/patch-src_dll_ffi.c
@@ -0,0 +1,13 @@
+--- src/dll_ffi.c.orig	2007-11-12 05:04:37.000000000 +0100
++++ src/dll_ffi.c	2012-01-26 19:32:40.000000000 +0100
+@@ -72,8 +72,8 @@ int nativeExtraArg(MethodBlock *mb) {
+ uintptr_t *callJNIMethod(void *env, Class *class, char *sig, int num_args, uintptr_t *ostack,
+                          unsigned char *func) {
+     ffi_cif cif;
+-    void *values[num_args];
+-    ffi_type *types[num_args];
++    void *values[num_args + 1];
++    ffi_type *types[num_args + 1];
+     uintptr_t *opntr = ostack;
+     void **values_pntr = &values[2];
+     ffi_type **types_pntr = &types[2];
diff --git a/java/jamvm-initial/files/patch-src_frame.h b/java/jamvm-initial/files/patch-src_frame.h
new file mode 100644
index 0000000..014e8c0
--- /dev/null
+++ b/java/jamvm-initial/files/patch-src_frame.h
@@ -0,0 +1,22 @@
+--- src/frame.h.orig	2008-01-26 02:15:41.000000000 +0100
++++ src/frame.h	2012-01-26 19:32:40.000000000 +0100
+@@ -19,6 +19,10 @@
+  * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+  */
+ 
++/* Ensure operand stack is double-word aligned.  This leads to
++   better double floating-point performance */
++#define ALIGN_OSTACK(pntr) (uintptr_t*)(((uintptr_t)(pntr) + 7) & ~7)
++
+ #define CREATE_TOP_FRAME(ee, class, mb, sp, ret)                \
+ {                                                               \
+     Frame *last = ee->last_frame;                               \
+@@ -28,7 +32,7 @@
+                                                                 \
+     ret = (void*) (sp = (uintptr_t*)(dummy+1));                 \
+     new_frame = (Frame *)(sp + mb->max_locals);                 \
+-    new_ostack = (uintptr_t *)(new_frame + 1);                  \
++    new_ostack = ALIGN_OSTACK(new_frame + 1);                  \
+                                                                 \
+     if((char*)(new_ostack + mb->max_stack) > ee->stack_end) {   \
+         if(ee->overflow++) {                                    \
diff --git a/java/jamvm-initial/files/patch-src_os_bsd_os.c b/java/jamvm-initial/files/patch-src_os_bsd_os.c
new file mode 100644
index 0000000..8c06335
--- /dev/null
+++ b/java/jamvm-initial/files/patch-src_os_bsd_os.c
@@ -0,0 +1,11 @@
+--- src/os/bsd/os.c.orig	2007-02-24 17:13:12.000000000 +0100
++++ src/os/bsd/os.c	2012-01-26 19:32:40.000000000 +0100
+@@ -48,7 +48,7 @@ void *nativeStackBase() {
+ void *nativeStackBase() {
+     pthread_attr_t attr;
+     void *addr;
+-    int size;
++    size_t size;
+ 
+     pthread_attr_init(&attr);
+     pthread_attr_get_np(pthread_self(), &attr);
diff --git a/java/jamvm-initial/files/patch-src_os_bsd_sparc64_Makefile.in b/java/jamvm-initial/files/patch-src_os_bsd_sparc64_Makefile.in
new file mode 100644
index 0000000..eec7006
--- /dev/null
+++ b/java/jamvm-initial/files/patch-src_os_bsd_sparc64_Makefile.in
@@ -0,0 +1,449 @@
+--- src/os/bsd/sparc64/Makefile.in.orig	2012-01-27 21:36:14.000000000 +0100
++++ src/os/bsd/sparc64/Makefile.in	2012-01-27 21:39:14.000000000 +0100
+@@ -0,0 +1,446 @@
++# Makefile.in generated by automake 1.10.1 from Makefile.am.
++# @configure_input@
++
++# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
++# 2003, 2004, 2005, 2006, 2007, 2008  Free Software Foundation, Inc.
++# This Makefile.in is free software; the Free Software Foundation
++# gives unlimited permission to copy and/or distribute it,
++# with or without modifications, as long as this notice is preserved.
++
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
++# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
++# PARTICULAR PURPOSE.
++
++@SET_MAKE@
++
++VPATH = @srcdir@
++pkgdatadir = $(datadir)/@PACKAGE@
++pkglibdir = $(libdir)/@PACKAGE@
++pkgincludedir = $(includedir)/@PACKAGE@
++am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
++install_sh_DATA = $(install_sh) -c -m 644
++install_sh_PROGRAM = $(install_sh) -c
++install_sh_SCRIPT = $(install_sh) -c
++INSTALL_HEADER = $(INSTALL_DATA)
++transform = $(program_transform_name)
++NORMAL_INSTALL = :
++PRE_INSTALL = :
++POST_INSTALL = :
++NORMAL_UNINSTALL = :
++PRE_UNINSTALL = :
++POST_UNINSTALL = :
++build_triplet = @build@
++host_triplet = @host@
++subdir = src/os/bsd/sparc64
++DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
++ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
++am__aclocal_m4_deps = $(top_srcdir)/acinclude.m4 \
++	$(top_srcdir)/configure.ac
++am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
++	$(ACLOCAL_M4)
++mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
++CONFIG_HEADER = $(top_builddir)/src/config.h
++CONFIG_CLEAN_FILES =
++LTLIBRARIES = $(noinst_LTLIBRARIES)
++libnative_la_LIBADD =
++am_libnative_la_OBJECTS = init.lo
++libnative_la_OBJECTS = $(am_libnative_la_OBJECTS)
++DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)/src
++depcomp = $(SHELL) $(top_srcdir)/depcomp
++am__depfiles_maybe = depfiles
++COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
++	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
++LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
++	--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
++	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
++CCLD = $(CC)
++LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
++	--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
++	$(LDFLAGS) -o $@
++SOURCES = $(libnative_la_SOURCES)
++DIST_SOURCES = $(libnative_la_SOURCES)
++ETAGS = etags
++CTAGS = ctags
++DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
++ACLOCAL = @ACLOCAL@
++ALLOCA = @ALLOCA@
++AMTAR = @AMTAR@
++AR = @AR@
++AUTOCONF = @AUTOCONF@
++AUTOHEADER = @AUTOHEADER@
++AUTOMAKE = @AUTOMAKE@
++AWK = @AWK@
++CC = @CC@
++CCAS = @CCAS@
++CCASDEPMODE = @CCASDEPMODE@
++CCASFLAGS = @CCASFLAGS@
++CCDEPMODE = @CCDEPMODE@
++CFLAGS = @CFLAGS@
++CPP = @CPP@
++CPPFLAGS = @CPPFLAGS@
++CXX = @CXX@
++CXXCPP = @CXXCPP@
++CXXDEPMODE = @CXXDEPMODE@
++CXXFLAGS = @CXXFLAGS@
++CYGPATH_W = @CYGPATH_W@
++DEFS = @DEFS@
++DEPDIR = @DEPDIR@
++DSYMUTIL = @DSYMUTIL@
++ECHO = @ECHO@
++ECHO_C = @ECHO_C@
++ECHO_N = @ECHO_N@
++ECHO_T = @ECHO_T@
++EGREP = @EGREP@
++EXEEXT = @EXEEXT@
++F77 = @F77@
++FFLAGS = @FFLAGS@
++GREP = @GREP@
++INSTALL = @INSTALL@
++INSTALL_DATA = @INSTALL_DATA@
++INSTALL_PROGRAM = @INSTALL_PROGRAM@
++INSTALL_SCRIPT = @INSTALL_SCRIPT@
++INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
++JAVAC = @JAVAC@
++LDFLAGS = @LDFLAGS@
++LIBOBJS = @LIBOBJS@
++LIBS = @LIBS@
++LIBTOOL = @LIBTOOL@
++LN_S = @LN_S@
++LTLIBOBJS = @LTLIBOBJS@
++MAINT = @MAINT@
++MAKEINFO = @MAKEINFO@
++MKDIR_P = @MKDIR_P@
++NMEDIT = @NMEDIT@
++OBJEXT = @OBJEXT@
++PACKAGE = @PACKAGE@
++PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
++PACKAGE_NAME = @PACKAGE_NAME@
++PACKAGE_STRING = @PACKAGE_STRING@
++PACKAGE_TARNAME = @PACKAGE_TARNAME@
++PACKAGE_VERSION = @PACKAGE_VERSION@
++PATH_SEPARATOR = @PATH_SEPARATOR@
++RANLIB = @RANLIB@
++SED = @SED@
++SET_MAKE = @SET_MAKE@
++SHELL = @SHELL@
++STRIP = @STRIP@
++VERSION = @VERSION@
++abs_builddir = @abs_builddir@
++abs_srcdir = @abs_srcdir@
++abs_top_builddir = @abs_top_builddir@
++abs_top_srcdir = @abs_top_srcdir@
++ac_ct_CC = @ac_ct_CC@
++ac_ct_CXX = @ac_ct_CXX@
++ac_ct_F77 = @ac_ct_F77@
++am__include = @am__include@
++am__leading_dot = @am__leading_dot@
++am__quote = @am__quote@
++am__tar = @am__tar@
++am__untar = @am__untar@
++arch = @arch@
++bindir = @bindir@
++build = @build@
++build_alias = @build_alias@
++build_cpu = @build_cpu@
++build_os = @build_os@
++build_vendor = @build_vendor@
++builddir = @builddir@
++datadir = @datadir@
++datarootdir = @datarootdir@
++docdir = @docdir@
++dvidir = @dvidir@
++exec_prefix = @exec_prefix@
++host = @host@
++host_alias = @host_alias@
++host_cpu = @host_cpu@
++host_os = @host_os@
++host_vendor = @host_vendor@
++htmldir = @htmldir@
++includedir = @includedir@
++infodir = @infodir@
++install_sh = @install_sh@
++interp_cflags = @interp_cflags@
++libdir = @libdir@
++libexecdir = @libexecdir@
++localedir = @localedir@
++localstatedir = @localstatedir@
++mandir = @mandir@
++mkdir_p = @mkdir_p@
++oldincludedir = @oldincludedir@
++os = @os@
++pdfdir = @pdfdir@
++prefix = @prefix@
++program_transform_name = @program_transform_name@
++psdir = @psdir@
++sbindir = @sbindir@
++sharedstatedir = @sharedstatedir@
++srcdir = @srcdir@
++sysconfdir = @sysconfdir@
++target_alias = @target_alias@
++top_builddir = @top_builddir@
++top_srcdir = @top_srcdir@
++use_zip_no = @use_zip_no@
++use_zip_yes = @use_zip_yes@
++with_classpath_install_dir = @with_classpath_install_dir@
++noinst_LTLIBRARIES = libnative.la
++libnative_la_SOURCES = init.c
++AM_CPPFLAGS = -I$(top_builddir)/src
++all: all-am
++
++.SUFFIXES:
++.SUFFIXES: .c .lo .o .obj
++$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
++	@for dep in $?; do \
++	  case '$(am__configure_deps)' in \
++	    *$$dep*) \
++	      cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \
++		&& exit 0; \
++	      exit 1;; \
++	  esac; \
++	done; \
++	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu  src/os/bsd/spar64/Makefile'; \
++	cd $(top_srcdir) && \
++	  $(AUTOMAKE) --gnu  src/os/bsd/sparc64/Makefile
++.PRECIOUS: Makefile
++Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
++	@case '$?' in \
++	  *config.status*) \
++	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
++	  *) \
++	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
++	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
++	esac;
++
++$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
++	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
++
++$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
++	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
++$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
++	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
++
++clean-noinstLTLIBRARIES:
++	-test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES)
++	@list='$(noinst_LTLIBRARIES)'; for p in $$list; do \
++	  dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
++	  test "$$dir" != "$$p" || dir=.; \
++	  echo "rm -f \"$${dir}/so_locations\""; \
++	  rm -f "$${dir}/so_locations"; \
++	done
++libnative.la: $(libnative_la_OBJECTS) $(libnative_la_DEPENDENCIES) 
++	$(LINK)  $(libnative_la_OBJECTS) $(libnative_la_LIBADD) $(LIBS)
++
++mostlyclean-compile:
++	-rm -f *.$(OBJEXT)
++
++distclean-compile:
++	-rm -f *.tab.c
++
++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/init.Plo@am__quote@
++
++.c.o:
++@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
++@am__fastdepCC_TRUE@	mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
++@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
++@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
++@am__fastdepCC_FALSE@	$(COMPILE) -c $<
++
++.c.obj:
++@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
++@am__fastdepCC_TRUE@	mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
++@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
++@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
++@am__fastdepCC_FALSE@	$(COMPILE) -c `$(CYGPATH_W) '$<'`
++
++.c.lo:
++@am__fastdepCC_TRUE@	$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
++@am__fastdepCC_TRUE@	mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
++@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
++@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
++@am__fastdepCC_FALSE@	$(LTCOMPILE) -c -o $@ $<
++
++mostlyclean-libtool:
++	-rm -f *.lo
++
++clean-libtool:
++	-rm -rf .libs _libs
++
++ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
++	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
++	unique=`for i in $$list; do \
++	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
++	  done | \
++	  $(AWK) '{ files[$$0] = 1; nonemtpy = 1; } \
++	      END { if (nonempty) { for (i in files) print i; }; }'`; \
++	mkid -fID $$unique
++tags: TAGS
++
++TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
++		$(TAGS_FILES) $(LISP)
++	tags=; \
++	here=`pwd`; \
++	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
++	unique=`for i in $$list; do \
++	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
++	  done | \
++	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
++	      END { if (nonempty) { for (i in files) print i; }; }'`; \
++	if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
++	  test -n "$$unique" || unique=$$empty_fix; \
++	  $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
++	    $$tags $$unique; \
++	fi
++ctags: CTAGS
++CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
++		$(TAGS_FILES) $(LISP)
++	tags=; \
++	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
++	unique=`for i in $$list; do \
++	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
++	  done | \
++	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
++	      END { if (nonempty) { for (i in files) print i; }; }'`; \
++	test -z "$(CTAGS_ARGS)$$tags$$unique" \
++	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
++	     $$tags $$unique
++
++GTAGS:
++	here=`$(am__cd) $(top_builddir) && pwd` \
++	  && cd $(top_srcdir) \
++	  && gtags -i $(GTAGS_ARGS) $$here
++
++distclean-tags:
++	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
++
++distdir: $(DISTFILES)
++	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
++	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
++	list='$(DISTFILES)'; \
++	  dist_files=`for file in $$list; do echo $$file; done | \
++	  sed -e "s|^$$srcdirstrip/||;t" \
++	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
++	case $$dist_files in \
++	  */*) $(MKDIR_P) `echo "$$dist_files" | \
++			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
++			   sort -u` ;; \
++	esac; \
++	for file in $$dist_files; do \
++	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
++	  if test -d $$d/$$file; then \
++	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
++	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
++	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
++	    fi; \
++	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
++	  else \
++	    test -f $(distdir)/$$file \
++	    || cp -p $$d/$$file $(distdir)/$$file \
++	    || exit 1; \
++	  fi; \
++	done
++check-am: all-am
++check: check-am
++all-am: Makefile $(LTLIBRARIES)
++installdirs:
++install: install-am
++install-exec: install-exec-am
++install-data: install-data-am
++uninstall: uninstall-am
++
++install-am: all-am
++	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
++
++installcheck: installcheck-am
++install-strip:
++	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
++	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
++	  `test -z '$(STRIP)' || \
++	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
++mostlyclean-generic:
++
++clean-generic:
++
++distclean-generic:
++	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
++
++maintainer-clean-generic:
++	@echo "This command is intended for maintainers to use"
++	@echo "it deletes files that may require special tools to rebuild."
++clean: clean-am
++
++clean-am: clean-generic clean-libtool clean-noinstLTLIBRARIES \
++	mostlyclean-am
++
++distclean: distclean-am
++	-rm -rf ./$(DEPDIR)
++	-rm -f Makefile
++distclean-am: clean-am distclean-compile distclean-generic \
++	distclean-tags
++
++dvi: dvi-am
++
++dvi-am:
++
++html: html-am
++
++info: info-am
++
++info-am:
++
++install-data-am:
++
++install-dvi: install-dvi-am
++
++install-exec-am:
++
++install-html: install-html-am
++
++install-info: install-info-am
++
++install-man:
++
++install-pdf: install-pdf-am
++
++install-ps: install-ps-am
++
++installcheck-am:
++
++maintainer-clean: maintainer-clean-am
++	-rm -rf ./$(DEPDIR)
++	-rm -f Makefile
++maintainer-clean-am: distclean-am maintainer-clean-generic
++
++mostlyclean: mostlyclean-am
++
++mostlyclean-am: mostlyclean-compile mostlyclean-generic \
++	mostlyclean-libtool
++
++pdf: pdf-am
++
++pdf-am:
++
++ps: ps-am
++
++ps-am:
++
++uninstall-am:
++
++.MAKE: install-am install-strip
++
++.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
++	clean-libtool clean-noinstLTLIBRARIES ctags distclean \
++	distclean-compile distclean-generic distclean-libtool \
++	distclean-tags distdir dvi dvi-am html html-am info info-am \
++	install install-am install-data install-data-am install-dvi \
++	install-dvi-am install-exec install-exec-am install-html \
++	install-html-am install-info install-info-am install-man \
++	install-pdf install-pdf-am install-ps install-ps-am \
++	install-strip installcheck installcheck-am installdirs \
++	maintainer-clean maintainer-clean-generic mostlyclean \
++	mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
++	pdf pdf-am ps ps-am tags uninstall uninstall-am
++
++# Tell versions [3.59,3.63) of GNU make to not export all variables.
++# Otherwise a system limit (for SysV at least) may be exceeded.
++.NOEXPORT:
diff --git a/java/jamvm-initial/files/patch-src_os_bsd_sparc64_init.c b/java/jamvm-initial/files/patch-src_os_bsd_sparc64_init.c
new file mode 100644
index 0000000..0769194
--- /dev/null
+++ b/java/jamvm-initial/files/patch-src_os_bsd_sparc64_init.c
@@ -0,0 +1,29 @@
+--- src/os/bsd/sparc64/init.c.orig	2012-01-26 19:32:40.000000000 +0100
++++ src/os/bsd/sparc64/init.c	2012-01-26 19:32:40.000000000 +0100
+@@ -0,0 +1,26 @@
++/*
++ * Copyright (C) 2003, 2004, 2006, 2007
++ * Robert Lougher <rob@lougher.org.uk>.
++ *
++ * This file is part of JamVM.
++ *
++ * This program is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License
++ * as published by the Free Software Foundation; either version 2,
++ * or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
++ */
++
++void setDoublePrecision() {
++}
++
++void initialisePlatform() {
++}
diff --git a/java/jamvm-initial/files/patch-src_thread.c b/java/jamvm-initial/files/patch-src_thread.c
new file mode 100644
index 0000000..516e0f9
--- /dev/null
+++ b/java/jamvm-initial/files/patch-src_thread.c
@@ -0,0 +1,11 @@
+--- src/thread.c.orig	2008-02-22 02:58:43.000000000 +0100
++++ src/thread.c	2012-01-26 19:32:40.000000000 +0100
+@@ -283,7 +283,7 @@ void resetPeakThreadsCount() {
+ void initialiseJavaStack(ExecEnv *ee) {
+    int stack_size = ee->stack_size ?
+            (ee->stack_size > MIN_STACK ? ee->stack_size : MIN_STACK) : dflt_stack_size;
+-   char *stack = sysMalloc(stack_size);
++   void *stack = sysMalloc(stack_size);
+    MethodBlock *mb = (MethodBlock *) stack;
+    Frame *top = (Frame *) (mb+1);
+ 
diff --git a/java/jamvm-initial/pkg-descr b/java/jamvm-initial/pkg-descr
new file mode 100644
index 0000000..0ffe412
--- /dev/null
+++ b/java/jamvm-initial/pkg-descr
@@ -0,0 +1,11 @@
+This package is for bootstrapping classpath > 0.93 which cannot be
+compiled with jikes.
+
+JamVM is an extremely small Java Virtual Machine which conforms to the
+JVM specification version 2 (blue book).
+
+It is designed to support the full specification, and includes support
+for object finalisation, Soft/Weak/Phantom References, class-unloading,
+the Java Native Interface (JNI) and the Reflection API.
+
+WWW: http://jamvm.sourceforge.net/
diff --git a/java/jamvm-initial/pkg-plist b/java/jamvm-initial/pkg-plist
new file mode 100644
index 0000000..41a0860
--- /dev/null
+++ b/java/jamvm-initial/pkg-plist
@@ -0,0 +1,3 @@
+bin/jamvm-initial
+share/jamvm-initial/classes.zip
+@dirrm share/jamvm-initial
diff --git a/java/jamvm/Makefile b/java/jamvm/Makefile
index 1a7f376..e41d8da 100644
--- a/java/jamvm/Makefile
+++ b/java/jamvm/Makefile
@@ -5,7 +5,7 @@
 # $FreeBSD: ports/java/jamvm/Makefile,v 1.8 2011/09/23 22:23:40 amdmi3 Exp $
 
 PORTNAME=	jamvm
-PORTVERSION=	1.5.1
+PORTVERSION=	1.5.4
 PORTREVISION=	4
 CATEGORIES=	java devel
 MASTER_SITES=	SF/${PORTNAME}/${PORTNAME}/JamVM%20${PORTVERSION}
@@ -19,8 +19,16 @@ GNU_CONFIGURE=	yes
 CONFIGURE_ARGS=	--with-classpath-install-dir=${LOCALBASE}
 USE_GMAKE=	yes
 
-OPTIONS=	FFI "use libffi to call native methods" ON \
-		ZIP "turn-on zip support in the bootstrap loader" ON
+OPTIONS=	ZIP "turn-on zip support in the bootstrap loader" ON
+
+.include <bsd.port.options.mk>
+
+# sparc64 always needs libffi
+.if (${ARCH} == sparc64)
+WITH_FFI=	1
+.else
+OPTIONS+=	FFI "use libffi to call native methods" ON
+.endif
 
 .include <bsd.port.pre.mk>
 
@@ -39,15 +47,7 @@ CONFIGURE_ARGS+=	--disable-zip
 PLIST_SUB+=		WITH_ZIP="@comment " WITHOUT_ZIP=""
 .endif
 
-.if ${ARCH} == "sparc64"
-BROKEN=		Does not configure on sparc64
-.endif
-
 post-extract:
-	@${MV} ${WRKSRC}/src/arch/x86_64.h ${WRKSRC}/src/arch/amd64.h
 	@${REINPLACE_CMD} -e "s,\(^include_HEADERS = .*\)jni.h\(.*\),\1\2," ${WRKSRC}/src/Makefile.in
 
-post-configure:
-	@${MV} ${WRKSRC}/src/os/bsd/x86_64 ${WRKSRC}/src/os/bsd/amd64
-
 .include <bsd.port.post.mk>
diff --git a/java/jamvm/distinfo b/java/jamvm/distinfo
index 2b59b45..410facf 100644
--- a/java/jamvm/distinfo
+++ b/java/jamvm/distinfo
@@ -1,2 +1,2 @@
-SHA256 (jamvm-1.5.1.tar.gz) = 663895bd69caf3a1fda6af5eea8263d90a5fd35ca8f4c32e2210ac410788901a
-SIZE (jamvm-1.5.1.tar.gz) = 599084
+SHA256 (jamvm-1.5.4.tar.gz) = 7865693698bc4322cabe1014a4b7ebdec1bc1daf45f1a4457b6e908a4446b124
+SIZE (jamvm-1.5.4.tar.gz) = 656283
diff --git a/java/jamvm/files/patch-configure b/java/jamvm/files/patch-configure
new file mode 100644
index 0000000..4b39713
--- /dev/null
+++ b/java/jamvm/files/patch-configure
@@ -0,0 +1,11 @@
+--- configure.orig	2012-01-27 13:55:49.000000000 +0100
++++ configure	2012-01-27 13:56:43.000000000 +0100
+@@ -2689,7 +2689,7 @@ x86_64-*-linux*) host_os=linux ;;
+ hppa*-*-linux*) host_cpu=parisc host_os=linux ;;
+ mipsel-*-linux*) host_cpu=mips host_os=linux ;;
+ x86_64-*-openbsd*) host_os=bsd libdl_needed=no ;;
+-x86_64-*-freebsd*) host_os=bsd libdl_needed=no ;;
++amd64-*-freebsd*) host_os=bsd host_cpu=x86_64 libdl_needed=no ;;
+ arm*-*-linux*) host_cpu=arm host_os=linux ;;
+ arm*-*-openbsd*) host_cpu=arm host_os=bsd libdl_needed=no ;;
+ arm*-*-freebsd*) host_cpu=arm host_os=bsd libdl_needed=no ;;


>Release-Note:
>Audit-Trail:

From: Per Ola Ingvarsson <skrabban@gmail.com>
To: bug-followup@FreeBSD.org, skrabban@gmail.com
Cc:  
Subject: Re: ports/164941: [UPDATE/NEW PORTS] jamvm/classpath w/o jdk
Date: Tue, 14 Feb 2012 20:19:00 +0100

 --20cf303b3af1a58c4104b8f1775a
 Content-Type: text/plain; charset=ISO-8859-1
 
 Original patch did not build on 10-CURRENT and left gjdoc/gjdoc.1
 behind from classpath.
 Build jars with zip instead of fastjar and add gjdoc/gjdoc.1 to
 pkg-plist/Makefile.
 
 Updated patch, new status:
 
 Sucessfully built on:
 10-CURRENT/amd64
 10-CURRENT/i386
 9.0-RELEASE/amd64
 9.0-RELEASE/i386
 8.2-RELEASE/amd64
 8.2-RELEASE/i386
 7.4-RELEASE/amd64
 7.4-RELEASE/i386
 and
 8.1-RELEASE/sparc64
 
 --20cf303b3af1a58c4104b8f1775a
 Content-Type: text/plain; charset=US-ASCII; name="patch_v2.txt"
 Content-Disposition: attachment; filename="patch_v2.txt"
 Content-Transfer-Encoding: base64
 X-Attachment-Id: f_gyn9vh240
 
 ZGlmZiAtLWdpdCBhL2phdmEvY2xhc3NwYXRoLWluaXRpYWwvTWFrZWZpbGUgYi9qYXZhL2NsYXNz
 cGF0aC1pbml0aWFsL01ha2VmaWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu
 LmRhMTFhYzEKLS0tIC9kZXYvbnVsbAorKysgYi9qYXZhL2NsYXNzcGF0aC1pbml0aWFsL01ha2Vm
 aWxlCkBAIC0wLDAgKzEsMzIgQEAKKyMgTmV3IHBvcnRzIGNvbGxlY3Rpb24gbWFrZWZpbGUgZm9y
 OiAgICBjbGFzc3BhdGgtaW5pdGlhbAorIyBEYXRlIGNyZWF0ZWQ6ICAgICAgICAgICAgICAgICAg
 ICAgICAgIDIwMTItMDItMDgKKyMgV2hvbTogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICBQZXIgT2xhIEluZ3ZhcnNzb24KKyMKKyMgJEZyZWVCU0Q6IHBvcnRzL2phdmEvY2xhc3NwYXRo
 L01ha2VmaWxlLHYgMS40MCAyMDExLzA5LzIzIDIyOjIzOjQwIGFtZG1pMyBFeHAgJAorIworCitQ
 T1JUTkFNRT0JY2xhc3NwYXRoCitQT1JUVkVSU0lPTj0JMC45MworQ0FURUdPUklFUz0JamF2YSBk
 ZXZlbAorTUFTVEVSX1NJVEVTPQkke01BU1RFUl9TSVRFX0dOVX0gXAorCQkke01BU1RFUl9TSVRF
 X1NBVkFOTkFIfQorTUFTVEVSX1NJVEVfU1VCRElSPQljbGFzc3BhdGgKK1BLR05BTUVTVUZGSVg9
 CS1pbml0aWFsCisKK01BSU5UQUlORVI9CXNrcmFiYmFuQGdtYWlsLmNvbQorQ09NTUVOVD0JSmF2
 YSBsaWJyYXJpZXMgdG8gYmUgdXNlZCB3aXRoIGphbXZtLWluaXRpYWwgdG8gYnVpbGQgbmV3ZXIg
 Y2xhc3NwYXRoCisKK0JVSUxEX0RFUEVORFM9CXppcDoke1BPUlRTRElSfS9hcmNoaXZlcnMvemlw
 IFwKKwkJamlrZXM6JHtQT1JUU0RJUn0vamF2YS9qaWtlcworCitVU0VfTERDT05GSUc9CXllcwor
 R05VX0NPTkZJR1VSRT0JeWVzCitDWFhGTEFHUys9CS1JJHtMT0NBTEJBU0V9L2luY2x1ZGUKKwor
 Q09ORklHVVJFX0FSR1M9CS0tZW5hYmxlLWpuaSAtLWRpc2FibGUtYWxzYSAtLWRpc2FibGUtZHNz
 aSBcCisJCS0tZGlzYWJsZS1wbHVnaW4gLS1kaXNhYmxlLWd0ay1wZWVyIC0td2l0aC1qaWtlcyBc
 CisJCS0tZGlzYWJsZS1leGFtcGxlcyAtLWRpc2FibGUtZ2NvbmYtcGVlcgorCitVU0VfR01BS0U9
 CXllcworCisuaW5jbHVkZSA8YnNkLnBvcnQubWs+CmRpZmYgLS1naXQgYS9qYXZhL2NsYXNzcGF0
 aC1pbml0aWFsL2Rpc3RpbmZvIGIvamF2YS9jbGFzc3BhdGgtaW5pdGlhbC9kaXN0aW5mbwpuZXcg
 ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jMDY4OTZkCi0tLSAvZGV2L251bGwKKysr
 IGIvamF2YS9jbGFzc3BhdGgtaW5pdGlhbC9kaXN0aW5mbwpAQCAtMCwwICsxLDIgQEAKK1NIQTI1
 NiAoY2xhc3NwYXRoLTAuOTMudGFyLmd6KSA9IGRmMmQwOTM2MTJhYmQyM2ZlNjdlOTQwOWQ4OWJi
 MmE4ZTc5YjE2NjRmZTJiMmRhNDBlMWM4ZWQ2OTNlMzI5NDUKK1NJWkUgKGNsYXNzcGF0aC0wLjkz
 LnRhci5neikgPSA5NTM0MjIyCmRpZmYgLS1naXQgYS9qYXZhL2NsYXNzcGF0aC1pbml0aWFsL2Zp
 bGVzL3BhdGNoLWNvbmZpZ3VyZSBiL2phdmEvY2xhc3NwYXRoLWluaXRpYWwvZmlsZXMvcGF0Y2gt
 Y29uZmlndXJlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjg5Y2I3YjkKLS0t
 IC9kZXYvbnVsbAorKysgYi9qYXZhL2NsYXNzcGF0aC1pbml0aWFsL2ZpbGVzL3BhdGNoLWNvbmZp
 Z3VyZQpAQCAtMCwwICsxLDExIEBACistLS0gY29uZmlndXJlLm9yaWcJMjAxMi0wMS0xNyAyMDo1
 MDo0Ni4wMDAwMDAwMDAgKzAxMDAKKysrKyBjb25maWd1cmUJMjAxMi0wMS0xNyAyMDo1MDozMS4w
 MDAwMDAwMDAgKzAxMDAKK0BAIC0xOTk4LDcgKzE5OTgsNyBAQCBmaQorIAorIAorICMgRGVmaW5l
 IHRoZSBpZGVudGl0eSBvZiB0aGUgcGFja2FnZS4KKy0gUEFDS0FHRT0nY2xhc3NwYXRoJworKyBQ
 QUNLQUdFPSdjbGFzc3BhdGgtaW5pdGlhbCcKKyAgVkVSU0lPTj0nMC45MycKKyAKKyAKZGlmZiAt
 LWdpdCBhL2phdmEvY2xhc3NwYXRoLWluaXRpYWwvZmlsZXMvcGF0Y2gtZG9jX01ha2VmaWxlLmlu
 IGIvamF2YS9jbGFzc3BhdGgtaW5pdGlhbC9maWxlcy9wYXRjaC1kb2NfTWFrZWZpbGUuaW4KbmV3
 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOGNiNGUzMAotLS0gL2Rldi9udWxsCisr
 KyBiL2phdmEvY2xhc3NwYXRoLWluaXRpYWwvZmlsZXMvcGF0Y2gtZG9jX01ha2VmaWxlLmluCkBA
 IC0wLDAgKzEsMTYgQEAKKy0tLSBkb2MvTWFrZWZpbGUuaW4ub3JpZwkyMDEyLTAxLTI1IDIwOjIx
 OjQwLjAwMDAwMDAwMCArMDEwMAorKysrIGRvYy9NYWtlZmlsZS5pbgkyMDEyLTAxLTI1IDIwOjIy
 OjIwLjAwMDAwMDAwMCArMDEwMAorQEAgLTcwNywxMSArNzA3LDExIEBAIGluZm86IGluZm8tcmVj
 dXJzaXZlCisgCisgaW5mby1hbTogJChJTkZPX0RFUFMpCisgCistaW5zdGFsbC1kYXRhLWFtOiBp
 bnN0YWxsLWluZm8tYW0KKytpbnN0YWxsLWRhdGEtYW06IAorIAorIGluc3RhbGwtZXhlYy1hbToK
 KyAKKy1pbnN0YWxsLWluZm86IGluc3RhbGwtaW5mby1yZWN1cnNpdmUKKytpbnN0YWxsLWluZm86
 IAorIAorIGluc3RhbGwtaW5mby1hbTogJChJTkZPX0RFUFMpCisgCUAkKE5PUk1BTF9JTlNUQUxM
 KQpkaWZmIC0tZ2l0IGEvamF2YS9jbGFzc3BhdGgtaW5pdGlhbC9maWxlcy9wYXRjaC1pbmNsdWRl
 X01ha2VmaWxlLmluIGIvamF2YS9jbGFzc3BhdGgtaW5pdGlhbC9maWxlcy9wYXRjaC1pbmNsdWRl
 X01ha2VmaWxlLmluCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmYzY2QyZWQK
 LS0tIC9kZXYvbnVsbAorKysgYi9qYXZhL2NsYXNzcGF0aC1pbml0aWFsL2ZpbGVzL3BhdGNoLWlu
 Y2x1ZGVfTWFrZWZpbGUuaW4KQEAgLTAsMCArMSwxMSBAQAorLS0tIGluY2x1ZGUvTWFrZWZpbGUu
 aW4ub3JpZwkyMDEyLTAxLTI1IDIwOjEzOjE4LjAwMDAwMDAwMCArMDEwMAorKysrIGluY2x1ZGUv
 TWFrZWZpbGUuaW4JMjAxMi0wMS0yNSAyMDoxMzozNy4wMDAwMDAwMDAgKzAxMDAKK0BAIC02NTUs
 NyArNjU1LDcgQEAgaW5mbzogaW5mby1hbQorIAorIGluZm8tYW06CisgCistaW5zdGFsbC1kYXRh
 LWFtOiBpbnN0YWxsLWluY2x1ZGVIRUFERVJTCisraW5zdGFsbC1kYXRhLWFtOgorIAorIGluc3Rh
 bGwtZXhlYy1hbToKKyAKZGlmZiAtLWdpdCBhL2phdmEvY2xhc3NwYXRoLWluaXRpYWwvZmlsZXMv
 cGF0Y2gtbmF0aXZlX2puaV9uYXRpdmUtbGliX2NwbmV0LmggYi9qYXZhL2NsYXNzcGF0aC1pbml0
 aWFsL2ZpbGVzL3BhdGNoLW5hdGl2ZV9qbmlfbmF0aXZlLWxpYl9jcG5ldC5oCm5ldyBmaWxlIG1v
 ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdiMThhZmMKLS0tIC9kZXYvbnVsbAorKysgYi9qYXZh
 L2NsYXNzcGF0aC1pbml0aWFsL2ZpbGVzL3BhdGNoLW5hdGl2ZV9qbmlfbmF0aXZlLWxpYl9jcG5l
 dC5oCkBAIC0wLDAgKzEsMTAgQEAKKy0tLSBuYXRpdmUvam5pL25hdGl2ZS1saWIvY3BuZXQuaC5v
 cmlnCTIwMTItMDEtMTYgMjI6MzQ6MzAuMDAwMDAwMDAwICswMTAwCisrKysgbmF0aXZlL2puaS9u
 YXRpdmUtbGliL2NwbmV0LmgJMjAxMi0wMS0xNiAyMjozNTowNS4wMDAwMDAwMDAgKzAxMDAKK0BA
 IC00Miw2ICs0Miw3IEBAIGV4Y2VwdGlvbiBzdGF0ZW1lbnQgZnJvbSB5b3VyIHZlcnNpb24uICoK
 KyAjaW5jbHVkZSA8amNsLmg+CisgI2luY2x1ZGUgPHN0cmluZy5oPgorIAorKyNpbmNsdWRlIDxz
 eXMvdHlwZXMuaD4KKyAjaW5jbHVkZSA8c3lzL3NvY2tldC5oPgorICNpbmNsdWRlIDxuZXRpbmV0
 L2luLmg+CisgI2luY2x1ZGUgPG5ldGluZXQvaXAuaD4KZGlmZiAtLWdpdCBhL2phdmEvY2xhc3Nw
 YXRoLWluaXRpYWwvZmlsZXMvcGF0Y2gtcmVzb3VyY2VfTWFrZWZpbGUuaW4gYi9qYXZhL2NsYXNz
 cGF0aC1pbml0aWFsL2ZpbGVzL3BhdGNoLXJlc291cmNlX01ha2VmaWxlLmluCm5ldyBmaWxlIG1v
 ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjM1NzFhZjIKLS0tIC9kZXYvbnVsbAorKysgYi9qYXZh
 L2NsYXNzcGF0aC1pbml0aWFsL2ZpbGVzL3BhdGNoLXJlc291cmNlX01ha2VmaWxlLmluCkBAIC0w
 LDAgKzEsMTEgQEAKKy0tLSByZXNvdXJjZS9NYWtlZmlsZS5pbi5vcmlnCTIwMTItMDEtMjUgMjA6
 MjM6NTIuMDAwMDAwMDAwICswMTAwCisrKysgcmVzb3VyY2UvTWFrZWZpbGUuaW4JMjAxMi0wMS0y
 NSAyMDoyNDoxOC4wMDAwMDAwMDAgKzAxMDAKK0BAIC00NjEsNyArNDYxLDcgQEAgaW5mbzogaW5m
 by1hbQorIAorIGluZm8tYW06CisgCistaW5zdGFsbC1kYXRhLWFtOiBpbnN0YWxsLWxvZ2dpbmdE
 QVRBIGluc3RhbGwtc2VjdXJpdHlEQVRBCisraW5zdGFsbC1kYXRhLWFtOgorIAorIGluc3RhbGwt
 ZXhlYy1hbToKKyAKZGlmZiAtLWdpdCBhL2phdmEvY2xhc3NwYXRoLWluaXRpYWwvZmlsZXMvcGF0
 Y2gtdG9vbHNfTWFrZWZpbGUuaW4gYi9qYXZhL2NsYXNzcGF0aC1pbml0aWFsL2ZpbGVzL3BhdGNo
 LXRvb2xzX01ha2VmaWxlLmluCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU1
 NmMwZTIKLS0tIC9kZXYvbnVsbAorKysgYi9qYXZhL2NsYXNzcGF0aC1pbml0aWFsL2ZpbGVzL3Bh
 dGNoLXRvb2xzX01ha2VmaWxlLmluCkBAIC0wLDAgKzEsMTEgQEAKKy0tLSB0b29scy9NYWtlZmls
 ZS5pbi5vcmlnCTIwMTItMDEtMjUgMTE6MDY6MDMuMDAwMDAwMDAwICswMTAwCisrKysgdG9vbHMv
 TWFrZWZpbGUuaW4JMjAxMi0wMS0yNSAxMTowNjozOS4wMDAwMDAwMDAgKzAxMDAKK0BAIC0xMDQz
 LDcgKzEwNDMsNyBAQCBpbmZvLWFtOgorIAorIGluc3RhbGwtZGF0YS1hbTogaW5zdGFsbC1UT09M
 U0RBVEEKKyAKKy1pbnN0YWxsLWV4ZWMtYW06IGluc3RhbGwtYmluUFJPR1JBTVMgaW5zdGFsbC1i
 aW5TQ1JJUFRTCisraW5zdGFsbC1leGVjLWFtOgorIAorIGluc3RhbGwtaW5mbzogaW5zdGFsbC1p
 bmZvLWFtCisgCmRpZmYgLS1naXQgYS9qYXZhL2NsYXNzcGF0aC1pbml0aWFsL3BrZy1kZXNjciBi
 L2phdmEvY2xhc3NwYXRoLWluaXRpYWwvcGtnLWRlc2NyCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu
 ZGV4IDAwMDAwMDAuLmMwZGNmYzYKLS0tIC9kZXYvbnVsbAorKysgYi9qYXZhL2NsYXNzcGF0aC1p
 bml0aWFsL3BrZy1kZXNjcgpAQCAtMCwwICsxLDggQEAKK1RoZSBwdXJwb3NlIG9mIHRoaXMgcGFj
 a2FnZSBpcyB0byBwcm92aWRlIGEgamF2YSBsaWJyYXJ5IGZvciBqYW12bS1pbml0aWFsIHdoaWNo
 IAoraXMgdXNlZCB3aGVuIGJ1aWxkaW5nIGNsYXNzcGF0aCB3aXRoIGdlbmVyaWNzLgorCitHTlUg
 Q2xhc3NwYXRoLCBFc3NlbnRpYWwgTGlicmFyaWVzIGZvciBKYXZhLCBpcyBhIEdOVSBwcm9qZWN0
 IHRvIGNyZWF0ZSBmcmVlCitjb3JlIGNsYXNzIGxpYnJhcmllcyBmb3IgdXNlIHdpdGggdmlydHVh
 bCBtYWNoaW5lcyBhbmQgY29tcGlsZXJzIGZvciB0aGUgSmF2YQorcHJvZ3JhbW1pbmcgbGFuZ3Vh
 Z2UuCisKK1dXVzogaHR0cDovL3d3dy5jbGFzc3BhdGgub3JnLwpkaWZmIC0tZ2l0IGEvamF2YS9j
 bGFzc3BhdGgtaW5pdGlhbC9wa2ctcGxpc3QgYi9qYXZhL2NsYXNzcGF0aC1pbml0aWFsL3BrZy1w
 bGlzdApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44MGQxOGIzCi0tLSAvZGV2
 L251bGwKKysrIGIvamF2YS9jbGFzc3BhdGgtaW5pdGlhbC9wa2ctcGxpc3QKQEAgLTAsMCArMSwy
 MiBAQAorbGliL2NsYXNzcGF0aC1pbml0aWFsL2xpYmphdmFpby5sYQorbGliL2NsYXNzcGF0aC1p
 bml0aWFsL2xpYmphdmFpby5zbworbGliL2NsYXNzcGF0aC1pbml0aWFsL2xpYmphdmFpby5zby4w
 CitsaWIvY2xhc3NwYXRoLWluaXRpYWwvbGliamF2YWxhbmcubGEKK2xpYi9jbGFzc3BhdGgtaW5p
 dGlhbC9saWJqYXZhbGFuZy5zbworbGliL2NsYXNzcGF0aC1pbml0aWFsL2xpYmphdmFsYW5nLnNv
 LjAKK2xpYi9jbGFzc3BhdGgtaW5pdGlhbC9saWJqYXZhbGFuZ3JlZmxlY3QubGEKK2xpYi9jbGFz
 c3BhdGgtaW5pdGlhbC9saWJqYXZhbGFuZ3JlZmxlY3Quc28KK2xpYi9jbGFzc3BhdGgtaW5pdGlh
 bC9saWJqYXZhbGFuZ3JlZmxlY3Quc28uMAorbGliL2NsYXNzcGF0aC1pbml0aWFsL2xpYmphdmFu
 ZXQubGEKK2xpYi9jbGFzc3BhdGgtaW5pdGlhbC9saWJqYXZhbmV0LnNvCitsaWIvY2xhc3NwYXRo
 LWluaXRpYWwvbGliamF2YW5ldC5zby4wCitsaWIvY2xhc3NwYXRoLWluaXRpYWwvbGliamF2YW5p
 by5sYQorbGliL2NsYXNzcGF0aC1pbml0aWFsL2xpYmphdmFuaW8uc28KK2xpYi9jbGFzc3BhdGgt
 aW5pdGlhbC9saWJqYXZhbmlvLnNvLjAKK2xpYi9jbGFzc3BhdGgtaW5pdGlhbC9saWJqYXZhdXRp
 bC5sYQorbGliL2NsYXNzcGF0aC1pbml0aWFsL2xpYmphdmF1dGlsLnNvCitsaWIvY2xhc3NwYXRo
 LWluaXRpYWwvbGliamF2YXV0aWwuc28uMAorQGRpcnJtIGxpYi9jbGFzc3BhdGgtaW5pdGlhbAor
 c2hhcmUvY2xhc3NwYXRoLWluaXRpYWwvZ2xpYmouemlwCitzaGFyZS9jbGFzc3BhdGgtaW5pdGlh
 bC90b29scy56aXAKK0BkaXJybSBzaGFyZS9jbGFzc3BhdGgtaW5pdGlhbApkaWZmIC0tZ2l0IGEv
 amF2YS9jbGFzc3BhdGgvTWFrZWZpbGUgYi9qYXZhL2NsYXNzcGF0aC9NYWtlZmlsZQppbmRleCAx
 MTM4NGFlLi5iM2E5Yjk5IDEwMDY0NAotLS0gYS9qYXZhL2NsYXNzcGF0aC9NYWtlZmlsZQorKysg
 Yi9qYXZhL2NsYXNzcGF0aC9NYWtlZmlsZQpAQCAtNywzMiArNyw0NCBAQAogIwogCiBQT1JUTkFN
 RT0JY2xhc3NwYXRoCi1QT1JUVkVSU0lPTj0JMC45Ny4yCi1QT1JUUkVWSVNJT049CTQKK1BPUlRW
 RVJTSU9OPQkwLjk4CitQT1JUUkVWSVNJT049CTUKIENBVEVHT1JJRVM9CWphdmEgZGV2ZWwKLU1B
 U1RFUl9TSVRFUz0JJHtNQVNURVJfU0lURV9HTlV9IFwKLQkJJHtNQVNURVJfU0lURV9TQVZBTk5B
 SH0KLU1BU1RFUl9TSVRFX1NVQkRJUj0JJHtQT1JUTkFNRX0KK01BU1RFUl9TSVRFUz0JJHtNQVNU
 RVJfU0lURV9HTlV9OnMwIFwKKwkJJHtNQVNURVJfU0lURV9TQVZBTk5BSH06czAgXAorCQlodHRw
 Oi8vYXJjaGl2ZS5lY2xpcHNlLm9yZy9lY2xpcHNlL2Rvd25sb2Fkcy9kcm9wcy9SLTMuMi4yLTIw
 MDcwMjEyMTMzMC86czEgXAorCQlodHRwOi8vd3d3LmFudGxyMi5vcmcvZG93bmxvYWQvOnMyCitN
 QVNURVJfU0lURV9TVUJESVI9CSR7UE9SVE5BTUV9LzpzMAorRElTVEZJTEVTPQkke0RJU1ROQU1F
 fS50YXIuZ3o6czAgXAorCQllY2ouamFyOnMxIFwKKwkJYW50bHItMi43LjUuamFyOnMyCitESVNU
 X1NVQkRJUj0JJHtQT1JUTkFNRX0KK0VYVFJBQ1RfT05MWT0JJHtESVNUTkFNRX0udGFyLmd6CiAK
 IE1BSU5UQUlORVI9CWJrb2VuaWdAYWxwaGEtdGllcmNoZW4uZGUKIENPTU1FTlQ9CUEgR05VIHBy
 b2plY3QgdG8gY3JlYXRlIGEgZnJlZSBKYXZhIGNsYXNzIGxpYnJhcnkKIAotQlVJTERfREVQRU5E
 Uz0JemlwOiR7UE9SVFNESVJ9L2FyY2hpdmVycy96aXAKK0JVSUxEX0RFUEVORFM9CXppcDoke1BP
 UlRTRElSfS9hcmNoaXZlcnMvemlwIFwKKwkJamFtdm0taW5pdGlhbDoke1BPUlRTRElSfS9qYXZh
 L2phbXZtLWluaXRpYWwKIAotVVNFX0pBVkE9CXllcwotSkFWQV9WRVJTSU9OPQkxLjUrCiBVU0Vf
 WE9SRz0JeDExIGljZSB4dHN0IHhhdyB4cHJvdG8geGV4dAogV0FOVF9HTk9NRT0JeWVzCiBVU0Vf
 TERDT05GSUc9CXllcwogR05VX0NPTkZJR1VSRT0JeWVzCiBDWFhGTEFHUys9CS1JJHtMT0NBTEJB
 U0V9L2luY2x1ZGUKLUNPTkZJR1VSRV9BUkdTPQktLWVuYWJsZS1qbmkgLS1kaXNhYmxlLWFsc2Eg
 LS1kaXNhYmxlLWRzc2kgLS1kaXNhYmxlLXBsdWdpbgorQ09ORklHVVJFX0VOVj0JSkFWQT1qYW12
 bS1pbml0aWFsIFBBVEg9JHtQQVRIfToke1dSS0RJUn0vYmluCitDT05GSUdVUkVfQVJHUz0JLS1l
 bmFibGUtam5pIC0tZGlzYWJsZS1hbHNhIC0tZGlzYWJsZS1kc3NpIC0tZGlzYWJsZS1wbHVnaW4g
 XAorCQktLXdpdGgtYW50bHItamFyPSR7RElTVERJUn0vJHtESVNUX1NVQkRJUn0vYW50bHItMi43
 LjUuamFyIFwKKwkJLS13aXRoLWphcj1ubworCiBVU0VfR01BS0U9CXllcworTUFLRV9FTlYrPQlQ
 QVRIPSR7UEFUSH06JHtXUktESVJ9L2JpbgogCiBNQU4xPQkJZ2FwcGxldHZpZXdlci4xIFwKIAkJ
 Z2phci4xIFwKIAkJZ2phcnNpZ25lci4xIFwKIAkJZ2phdmFoLjEgXAorCQlnamRvYy4xIFwKIAkJ
 Z2NqaC4xIFwKIAkJZ2tleXRvb2wuMSBcCiAJCWduYXRpdmUyYXNjaWkuMSBcCkBAIC00NCwxMyAr
 NTYsMjAgQEAgTUFOMT0JCWdhcHBsZXR2aWV3ZXIuMSBcCiAKIElORk89CQljcC1oYWNraW5nIGNw
 LXRvb2xzIGNwLXZtaW50ZWdyYXRpb24KIAotQ09ORkxJQ1RTPQlzYWJsZXZtLWNsYXNzcGF0aC0q
 CitDT05GTElDVFM9CXNhYmxldm0tY2xhc3NwYXRoLVswLTldKgogCiBPUFRJT05TPQlHQ09ORiAi
 VXNlIEdDb25mIGJhc2VkIHByZWZlcmVuY2VzIGJhY2tlbmQiIE9GRiBcCiAJCUdUSzIgIkVuYWJs
 ZSBHdGsrIEFXVCBwZWVyIiBPTiBcCiAJCUNBSVJPICJVc2UgR3RrKyBDYWlybyBiYXNlZCBHcmFw
 aGljczJEIiBPRkYgXAogCQlRVDQgIkVuYWJsZSBRdCBBV1QgcGVlciIgT0ZGCiAKK3ByZS1wYXRj
 aDoKKwlAJHtNS0RJUn0gJHtXUktESVJ9L2JpbgorCUAke1NFRH0gLWUgJ3MsJSVESVNURElSJSUs
 JHtESVNURElSfS8ke0RJU1RfU1VCRElSfSwnIFwKKwkJPCAke0ZJTEVTRElSfS9lY2ouaW4gXAor
 CQk+ICR7V1JLRElSfS9iaW4vZWNqCisJQCR7Q0hNT0R9ICt4ICR7V1JLRElSfS9iaW4vZWNqCisK
 IC5pbmNsdWRlIDxic2QucG9ydC5wcmUubWs+CiAKIC5pZiBkZWZpbmVkKFdJVEhfR0NPTkYpCmRp
 ZmYgLS1naXQgYS9qYXZhL2NsYXNzcGF0aC9kaXN0aW5mbyBiL2phdmEvY2xhc3NwYXRoL2Rpc3Rp
 bmZvCmluZGV4IDYwZDdlYmEuLmRmZjQzYzYgMTAwNjQ0Ci0tLSBhL2phdmEvY2xhc3NwYXRoL2Rp
 c3RpbmZvCisrKyBiL2phdmEvY2xhc3NwYXRoL2Rpc3RpbmZvCkBAIC0xLDIgKzEsNiBAQAotU0hB
 MjU2IChjbGFzc3BhdGgtMC45Ny4yLnRhci5neikgPSAwMDFmZWU1YWQzZGRkMDQzNzgzZDU5NTkz
 MTUzNTEwZjA5MDY0YjBkOWI1YWVhODJmNTM1MjY2ZjYyZjAyZGI0Ci1TSVpFIChjbGFzc3BhdGgt
 MC45Ny4yLnRhci5neikgPSAxMDMxODAxNAorU0hBMjU2IChjbGFzc3BhdGgvY2xhc3NwYXRoLTAu
 OTgudGFyLmd6KSA9IDUwMWI1YWNkNGRmZjc5YjYxMDBkYTIyY2VmMTUwODBmMzEwNzE4MjFjZTNj
 ZWE2ZjFiNzM5YmMxYjU2ZmFjM2YKK1NJWkUgKGNsYXNzcGF0aC9jbGFzc3BhdGgtMC45OC50YXIu
 Z3opID0gMTEwMjEzNDIKK1NIQTI1NiAoY2xhc3NwYXRoL2Vjai5qYXIpID0gM2IyNjYyN2Y0Yzk5
 OGM2N2YxNDczOTJkYzMzNTVmMzhiMDU3NjllNDAwOTI1YTdjNGY5ZmY2ODgxOWYxYzMwMworU0la
 RSAoY2xhc3NwYXRoL2Vjai5qYXIpID0gMTMyMzI3NworU0hBMjU2IChjbGFzc3BhdGgvYW50bHIt
 Mi43LjUuamFyKSA9IDI0MzNlN2UzNmViYmViZTcyMzkwMDM2ZWM1NTVmNGM2NzcxZWFlZDMzZDUw
 N2IzZDVkNjU0OTc4MDQwOTNhMGQKK1NJWkUgKGNsYXNzcGF0aC9hbnRsci0yLjcuNS5qYXIpID0g
 NDM1NTYzCmRpZmYgLS1naXQgYS9qYXZhL2NsYXNzcGF0aC9maWxlcy9lY2ouaW4gYi9qYXZhL2Ns
 YXNzcGF0aC9maWxlcy9lY2ouaW4KbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u
 MTY1ZWUzNgotLS0gL2Rldi9udWxsCisrKyBiL2phdmEvY2xhc3NwYXRoL2ZpbGVzL2Vjai5pbgpA
 QCAtMCwwICsxLDQgQEAKKyMhL2Jpbi9zaAorCitDTEFTU1BBVEg9JSVESVNURElSJSUvZWNqLmph
 ciR7Q0xBU1NQQVRIOis6fSRDTEFTU1BBVEggXAorZXhlYyBqYW12bS1pbml0aWFsIC1YbXg3Njht
 IG9yZy5lY2xpcHNlLmpkdC5pbnRlcm5hbC5jb21waWxlci5iYXRjaC5NYWluIC1ub3dhcm4gIiRA
 IgpkaWZmIC0tZ2l0IGEvamF2YS9jbGFzc3BhdGgvcGtnLXBsaXN0IGIvamF2YS9jbGFzc3BhdGgv
 cGtnLXBsaXN0CmluZGV4IDhkNmFiZjUuLjk5MjY2ZGUgMTAwNjQ0Ci0tLSBhL2phdmEvY2xhc3Nw
 YXRoL3BrZy1wbGlzdAorKysgYi9qYXZhL2NsYXNzcGF0aC9wa2ctcGxpc3QKQEAgLTIsNiArMiw3
 IEBAIGJpbi9nYXBwbGV0dmlld2VyCiBiaW4vZ2phdmFoCiBiaW4vZ2phcgogYmluL2dqYXJzaWdu
 ZXIKK2Jpbi9namRvYwogYmluL2drZXl0b29sCiBiaW4vZ25hdGl2ZTJhc2NpaQogYmluL2dvcmJk
 CmRpZmYgLS1naXQgYS9qYXZhL2phbXZtLWluaXRpYWwvTWFrZWZpbGUgYi9qYXZhL2phbXZtLWlu
 aXRpYWwvTWFrZWZpbGUKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjliZjNi
 ZQotLS0gL2Rldi9udWxsCisrKyBiL2phdmEvamFtdm0taW5pdGlhbC9NYWtlZmlsZQpAQCAtMCww
 ICsxLDM4IEBACisjIE5ldyBwb3J0cyBjb2xsZWN0aW9uIG1ha2VmaWxlIGZvcjoJamFtdm0taW5p
 dGlhbAorIyBEYXRlIGNyZWF0ZWQ6CQkJCTIwMTItMDItMDgKKyMgV2hvbToJCQkJCVBlciBPbGEg
 SW5ndmFyc3NvbgorIworIyAkRnJlZUJTRDogcG9ydHMvamF2YS9qYW12bS9NYWtlZmlsZSx2IDEu
 OCAyMDExLzA5LzIzIDIyOjIzOjQwIGFtZG1pMyBFeHAgJAorCitQT1JUTkFNRT0JamFtdm0KK1BP
 UlRWRVJTSU9OPQkxLjUuMQorQ0FURUdPUklFUz0JamF2YSBkZXZlbAorTUFTVEVSX1NJVEVTPQlT
 Ri9qYW12bS9qYW12bS9KYW1WTSUyMCR7UE9SVFZFUlNJT059CitQS0dOQU1FU1VGRklYPQktaW5p
 dGlhbAorCitNQUlOVEFJTkVSPQlza3JhYmJhbkBnbWFpbC5jb20KK0NPTU1FTlQ9CUJvb3RzdHJh
 cCBqYW12bSB0byBjb21waWxlIGNsYXNzcGF0aCB3aXRoIGVjagorCitSVU5fREVQRU5EUz0JJHtM
 T0NBTEJBU0V9L3NoYXJlL2NsYXNzcGF0aC1pbml0aWFsL2dsaWJqLnppcDoke1BPUlRTRElSfS9q
 YXZhL2NsYXNzcGF0aC1pbml0aWFsCisKK0dOVV9DT05GSUdVUkU9CXllcworQ09ORklHVVJFX0FS
 R1M9CS0td2l0aC1jbGFzc3BhdGgtaW5zdGFsbC1kaXI9JHtMT0NBTEJBU0V9CitVU0VfR01BS0U9
 CXllcworCisuaW5jbHVkZSA8YnNkLnBvcnQucHJlLm1rPgorCitMSUJfREVQRU5EUys9CQlmZmk6
 JHtQT1JUU0RJUn0vZGV2ZWwvbGliZmZpCitDT05GSUdVUkVfQVJHUys9CS0tZW5hYmxlLWZmaQor
 TERGTEFHUys9CS1MJHtMT0NBTEJBU0V9L2xpYgorQ0ZMQUdTKz0JYHBrZy1jb25maWcgbGliZmZp
 IC0tY2ZsYWdzYAorCitCVUlMRF9ERVBFTkRTKz0JCXppcDoke1BPUlRTRElSfS9hcmNoaXZlcnMv
 emlwCitQTElTVF9TVUIrPQkJV0lUSF9aSVA9IiIgV0lUSE9VVF9aSVA9IkBjb21tZW50ICIKKwor
 ZG8taW5zdGFsbDoKKwkke0lOU1RBTExfUFJPR1JBTX0gLXMgJHtXUktTUkN9L3NyYy9qYW12bS1p
 bml0aWFsICR7UFJFRklYfS9iaW4KKwkke01LRElSfSAke1BSRUZJWH0vc2hhcmUvamFtdm0taW5p
 dGlhbAorCSR7SU5TVEFMTF9EQVRBfSAke1dSS1NSQ30vbGliL2NsYXNzZXMuemlwIFwKKwkJJHtQ
 UkVGSVh9L3NoYXJlL2phbXZtLWluaXRpYWwKKworLmluY2x1ZGUgPGJzZC5wb3J0LnBvc3QubWs+
 CmRpZmYgLS1naXQgYS9qYXZhL2phbXZtLWluaXRpYWwvZGlzdGluZm8gYi9qYXZhL2phbXZtLWlu
 aXRpYWwvZGlzdGluZm8KbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMmI1OWI0
 NQotLS0gL2Rldi9udWxsCisrKyBiL2phdmEvamFtdm0taW5pdGlhbC9kaXN0aW5mbwpAQCAtMCww
 ICsxLDIgQEAKK1NIQTI1NiAoamFtdm0tMS41LjEudGFyLmd6KSA9IDY2Mzg5NWJkNjljYWYzYTFm
 ZGE2YWY1ZWVhODI2M2Q5MGE1ZmQzNWNhOGY0YzMyZTIyMTBhYzQxMDc4ODkwMWEKK1NJWkUgKGph
 bXZtLTEuNS4xLnRhci5neikgPSA1OTkwODQKZGlmZiAtLWdpdCBhL2phdmEvamFtdm0taW5pdGlh
 bC9maWxlcy9wYXRjaC1jb25maWd1cmUgYi9qYXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gt
 Y29uZmlndXJlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjYyZmYwOGQKLS0t
 IC9kZXYvbnVsbAorKysgYi9qYXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtY29uZmlndXJl
 CkBAIC0wLDAgKzEsMzIgQEAKKy0tLSBjb25maWd1cmUub3JpZwkyMDA4LTAzLTAyIDA1OjE2OjA3
 LjAwMDAwMDAwMCArMDEwMAorKysrIGNvbmZpZ3VyZQkyMDEyLTAxLTI3IDE1OjAzOjIxLjAwMDAw
 MDAwMCArMDEwMAorQEAgLTI1NTIsOCArMjU1MiwxMCBAQCBpMzg2LSotZnJlZWJzZCopIGhvc3Rf
 b3M9YnNkIGxpYmRsX25lZWRlCisgeDg2XzY0LSotbGludXgqKSBob3N0X29zPWxpbnV4IDs7Cisg
 aHBwYSotKi1saW51eCopIGhvc3RfY3B1PXBhcmlzYyBob3N0X29zPWxpbnV4IDs7CisgbWlwc2Vs
 LSotbGludXgqKSBob3N0X2NwdT1taXBzIGhvc3Rfb3M9bGludXggOzsKKy1hbWQ2NC0qLW9wZW5i
 c2QqKSBob3N0X29zPWJzZCBsaWJkbF9uZWVkZWQ9bm8gOzsKKy1hbWQ2NC0qLWZyZWVic2QqKSBo
 b3N0X29zPWJzZCBsaWJkbF9uZWVkZWQ9bm8gOzsKKythbWQ2NC0qLW9wZW5ic2QqKSBob3N0X29z
 PWJzZCBob3N0X2NwdT14ODZfNjQgbGliZGxfbmVlZGVkPW5vIDs7CisrYW1kNjQtKi1mcmVlYnNk
 KikgaG9zdF9vcz1ic2QgaG9zdF9jcHU9eDg2XzY0IGxpYmRsX25lZWRlZD1ubyA7OworK3NwYXJj
 NjQqLSotb3BlbmJzZCopIGhvc3RfY3B1PXNwYXJjNjQgaG9zdF9vcz1ic2QgbGliZGxfbmVlZGVk
 PW5vIDs7Cisrc3BhcmM2NCotKi1mcmVlYnNkKikgaG9zdF9jcHU9c3BhcmM2NCBob3N0X29zPWJz
 ZCBsaWJkbF9uZWVkZWQ9bm8gOzsKKyBhcm0qLSotbGludXgqKSBob3N0X2NwdT1hcm0gaG9zdF9v
 cz1saW51eCA7OworIGFybSotKi1vcGVuYnNkKikgaG9zdF9jcHU9YXJtIGhvc3Rfb3M9YnNkIGxp
 YmRsX25lZWRlZD1ubyA7OworIGFybSotKi1mcmVlYnNkKikgaG9zdF9jcHU9YXJtIGhvc3Rfb3M9
 YnNkIGxpYmRsX25lZWRlZD1ubyA7OworQEAgLTIyODM5LDcgKzIyODQxLDcgQEAgZmkKKyBhY19j
 b25maWdfbGlua3M9IiRhY19jb25maWdfbGlua3Mgc3JjL2FyY2guaDpzcmMvYXJjaC8kYXJjaC5o
 IgorIAorIAorLWFjX2NvbmZpZ19maWxlcz0iJGFjX2NvbmZpZ19maWxlcyBNYWtlZmlsZSBzcmMv
 TWFrZWZpbGUgc3JjL2ludGVycC9NYWtlZmlsZSBzcmMvaW50ZXJwL2VuZ2luZS9NYWtlZmlsZSBz
 cmMvYXJjaC9NYWtlZmlsZSBzcmMvb3MvTWFrZWZpbGUgc3JjL29zL2xpbnV4L01ha2VmaWxlIHNy
 Yy9vcy9kYXJ3aW4vTWFrZWZpbGUgc3JjL29zL2JzZC9NYWtlZmlsZSBzcmMvb3MvbGludXgvcG93
 ZXJwYy9NYWtlZmlsZSBzcmMvb3MvbGludXgvYXJtL01ha2VmaWxlIHNyYy9vcy9saW51eC9pMzg2
 L01ha2VmaWxlIHNyYy9vcy9saW51eC94ODZfNjQvTWFrZWZpbGUgc3JjL29zL2xpbnV4L3Bhcmlz
 Yy9NYWtlZmlsZSBzcmMvb3MvbGludXgvbWlwcy9NYWtlZmlsZSBzcmMvb3MvZGFyd2luL2kzODYv
 TWFrZWZpbGUgc3JjL29zL2Rhcndpbi9hcm0vTWFrZWZpbGUgc3JjL29zL2Rhcndpbi9wb3dlcnBj
 L01ha2VmaWxlIHNyYy9vcy9ic2QvcG93ZXJwYy9NYWtlZmlsZSBzcmMvb3MvYnNkL2FybS9NYWtl
 ZmlsZSBzcmMvb3MvYnNkL2kzODYvTWFrZWZpbGUgc3JjL29zL2JzZC94ODZfNjQvTWFrZWZpbGUg
 bGliL01ha2VmaWxlIGxpYi9qYXZhL01ha2VmaWxlIGxpYi9qYXZhL2xhbmcvTWFrZWZpbGUgbGli
 L2phbXZtL01ha2VmaWxlIGxpYi9qYW12bS9qYXZhL01ha2VmaWxlIGxpYi9qYW12bS9qYXZhL2xh
 bmcvTWFrZWZpbGUgbGliL2phdmEvbGFuZy9yZWZsZWN0L01ha2VmaWxlIGxpYi9qYXZhL3NlY3Vy
 aXR5L01ha2VmaWxlIGxpYi9nbnUvTWFrZWZpbGUgbGliL3N1bi9yZWZsZWN0L2Fubm90YXRpb24v
 TWFrZWZpbGUgbGliL3N1bi9yZWZsZWN0L01ha2VmaWxlIGxpYi9zdW4vTWFrZWZpbGUgbGliL2du
 dS9jbGFzc3BhdGgvTWFrZWZpbGUiCisrYWNfY29uZmlnX2ZpbGVzPSIkYWNfY29uZmlnX2ZpbGVz
 IE1ha2VmaWxlIHNyYy9NYWtlZmlsZSBzcmMvaW50ZXJwL01ha2VmaWxlIHNyYy9pbnRlcnAvZW5n
 aW5lL01ha2VmaWxlIHNyYy9hcmNoL01ha2VmaWxlIHNyYy9vcy9NYWtlZmlsZSBzcmMvb3MvbGlu
 dXgvTWFrZWZpbGUgc3JjL29zL2Rhcndpbi9NYWtlZmlsZSBzcmMvb3MvYnNkL01ha2VmaWxlIHNy
 Yy9vcy9saW51eC9wb3dlcnBjL01ha2VmaWxlIHNyYy9vcy9saW51eC9hcm0vTWFrZWZpbGUgc3Jj
 L29zL2xpbnV4L2kzODYvTWFrZWZpbGUgc3JjL29zL2xpbnV4L3g4Nl82NC9NYWtlZmlsZSBzcmMv
 b3MvbGludXgvcGFyaXNjL01ha2VmaWxlIHNyYy9vcy9saW51eC9taXBzL01ha2VmaWxlIHNyYy9v
 cy9kYXJ3aW4vaTM4Ni9NYWtlZmlsZSBzcmMvb3MvZGFyd2luL2FybS9NYWtlZmlsZSBzcmMvb3Mv
 ZGFyd2luL3Bvd2VycGMvTWFrZWZpbGUgc3JjL29zL2JzZC9wb3dlcnBjL01ha2VmaWxlIHNyYy9v
 cy9ic2QvYXJtL01ha2VmaWxlIHNyYy9vcy9ic2QvaTM4Ni9NYWtlZmlsZSBzcmMvb3MvYnNkL3g4
 Nl82NC9NYWtlZmlsZSBzcmMvb3MvYnNkL3NwYXJjNjQvTWFrZWZpbGUgbGliL01ha2VmaWxlIGxp
 Yi9qYXZhL01ha2VmaWxlIGxpYi9qYXZhL2xhbmcvTWFrZWZpbGUgbGliL2phbXZtL01ha2VmaWxl
 IGxpYi9qYW12bS9qYXZhL01ha2VmaWxlIGxpYi9qYW12bS9qYXZhL2xhbmcvTWFrZWZpbGUgbGli
 L2phdmEvbGFuZy9yZWZsZWN0L01ha2VmaWxlIGxpYi9qYXZhL3NlY3VyaXR5L01ha2VmaWxlIGxp
 Yi9nbnUvTWFrZWZpbGUgbGliL3N1bi9yZWZsZWN0L2Fubm90YXRpb24vTWFrZWZpbGUgbGliL3N1
 bi9yZWZsZWN0L01ha2VmaWxlIGxpYi9zdW4vTWFrZWZpbGUgbGliL2dudS9jbGFzc3BhdGgvTWFr
 ZWZpbGUiCisgCisgCisgY2F0ID5jb25mY2FjaGUgPDxcX0FDRU9GCitAQCAtMjM0ODMsNiArMjM0
 ODUsNyBAQCBkbworICAgICAic3JjL29zL2JzZC9hcm0vTWFrZWZpbGUiKSBDT05GSUdfRklMRVM9
 IiRDT05GSUdfRklMRVMgc3JjL29zL2JzZC9hcm0vTWFrZWZpbGUiIDs7CisgICAgICJzcmMvb3Mv
 YnNkL2kzODYvTWFrZWZpbGUiKSBDT05GSUdfRklMRVM9IiRDT05GSUdfRklMRVMgc3JjL29zL2Jz
 ZC9pMzg2L01ha2VmaWxlIiA7OworICAgICAic3JjL29zL2JzZC94ODZfNjQvTWFrZWZpbGUiKSBD
 T05GSUdfRklMRVM9IiRDT05GSUdfRklMRVMgc3JjL29zL2JzZC94ODZfNjQvTWFrZWZpbGUiIDs7
 CisrICAgICJzcmMvb3MvYnNkL3NwYXJjNjQvTWFrZWZpbGUiKSBDT05GSUdfRklMRVM9IiRDT05G
 SUdfRklMRVMgc3JjL29zL2JzZC94ODZfNjQvTWFrZWZpbGUiIDs7CisgICAgICJsaWIvTWFrZWZp
 bGUiKSBDT05GSUdfRklMRVM9IiRDT05GSUdfRklMRVMgbGliL01ha2VmaWxlIiA7OworICAgICAi
 bGliL2phdmEvTWFrZWZpbGUiKSBDT05GSUdfRklMRVM9IiRDT05GSUdfRklMRVMgbGliL2phdmEv
 TWFrZWZpbGUiIDs7CisgICAgICJsaWIvamF2YS9sYW5nL01ha2VmaWxlIikgQ09ORklHX0ZJTEVT
 PSIkQ09ORklHX0ZJTEVTIGxpYi9qYXZhL2xhbmcvTWFrZWZpbGUiIDs7CmRpZmYgLS1naXQgYS9q
 YXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtbGliX01ha2VmaWxlLmluIGIvamF2YS9qYW12
 bS1pbml0aWFsL2ZpbGVzL3BhdGNoLWxpYl9NYWtlZmlsZS5pbgpuZXcgZmlsZSBtb2RlIDEwMDY0
 NAppbmRleCAwMDAwMDAwLi4zZmFmZTBhCi0tLSAvZGV2L251bGwKKysrIGIvamF2YS9qYW12bS1p
 bml0aWFsL2ZpbGVzL3BhdGNoLWxpYl9NYWtlZmlsZS5pbgpAQCAtMCwwICsxLDExIEBACistLS0g
 bGliL01ha2VmaWxlLmluLm9yaWcJMjAxMi0wMS0xNyAyMTowNToyNi4wMDAwMDAwMDAgKzAxMDAK
 KysrKyBsaWIvTWFrZWZpbGUuaW4JMjAxMi0wMS0xNyAyMTowNjoxOC4wMDAwMDAwMDAgKzAxMDAK
 K0BAIC0xNzYsNyArMTc2LDcgQEAgdG9wX3NyY2RpciA9IEB0b3Bfc3JjZGlyQAorIHVzZV96aXBf
 bm8gPSBAdXNlX3ppcF9ub0AKKyB1c2VfemlwX3llcyA9IEB1c2VfemlwX3llc0AKKyB3aXRoX2Ns
 YXNzcGF0aF9pbnN0YWxsX2RpciA9IEB3aXRoX2NsYXNzcGF0aF9pbnN0YWxsX2RpckAKKy1DUF9M
 SUJfRElSID0gJHt3aXRoX2NsYXNzcGF0aF9pbnN0YWxsX2Rpcn0vc2hhcmUvY2xhc3NwYXRoCisr
 Q1BfTElCX0RJUiA9ICR7d2l0aF9jbGFzc3BhdGhfaW5zdGFsbF9kaXJ9L3NoYXJlL2NsYXNzcGF0
 aC1pbml0aWFsCisgR0xJQkpfWklQID0gJHtDUF9MSUJfRElSfS9nbGliai56aXAKKyBTVUJESVJT
 ID0gamFtdm0gamF2YSBnbnUgc3VuCisgRVhUUkFfRElTVCA9IGNsYXNzZXMuemlwIFJFQURNRQpk
 aWZmIC0tZ2l0IGEvamF2YS9qYW12bS1pbml0aWFsL2ZpbGVzL3BhdGNoLXNyY19NYWtlZmlsZS5p
 biBiL2phdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfTWFrZWZpbGUuaW4KbmV3IGZp
 bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZDE1OTcwMwotLS0gL2Rldi9udWxsCisrKyBi
 L2phdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfTWFrZWZpbGUuaW4KQEAgLTAsMCAr
 MSwyMSBAQAorLS0tIHNyYy9NYWtlZmlsZS5pbi5vcmlnCTIwMTItMDEtMTcgMjE6NTM6NDQuMDAw
 MDAwMDAwICswMTAwCisrKysgc3JjL01ha2VmaWxlLmluCTIwMTItMDEtMTcgMjE6NTA6MzkuMDAw
 MDAwMDAwICswMTAwCitAQCAtMzQsNyArMzQsNyBAQCBQUkVfVU5JTlNUQUxMID0gOgorIFBPU1Rf
 VU5JTlNUQUxMID0gOgorIGJ1aWxkX3RyaXBsZXQgPSBAYnVpbGRACisgaG9zdF90cmlwbGV0ID0g
 QGhvc3RACistYmluX1BST0dSQU1TID0gamFtdm0kKEVYRUVYVCkKKytiaW5fUFJPR1JBTVMgPSBq
 YW12bSQoRVhFRVhUKSBqYW12bS1pbml0aWFsJChFWEVFWFQpCisgc3ViZGlyID0gc3JjCisgRElT
 VF9DT01NT04gPSAkKGluY2x1ZGVfSEVBREVSUykgJChzcmNkaXIpL01ha2VmaWxlLmFtIFwKKyAJ
 JChzcmNkaXIpL01ha2VmaWxlLmluICQoc3JjZGlyKS9jb25maWcuaC5pbgorQEAgLTM2MCw2ICsz
 NjAsOSBAQCBqYW12bSQoRVhFRVhUKTogJChqYW12bV9PQkpFQ1RTKSAkKGphbXZtCisgCUBybSAt
 ZiBqYW12bSQoRVhFRVhUKQorIAkkKExJTkspICQoamFtdm1fT0JKRUNUUykgJChqYW12bV9MREFE
 RCkgJChMSUJTKQorIAorK2phbXZtLWluaXRpYWwkKEVYRUVYVCk6IGphbXZtJChFWEVFWFQpCisr
 CUBjcCBqYW12bSQoRVhFRVhUKSBqYW12bS1pbml0aWFsJChFWEVFWFQpCisrCisgbW9zdGx5Y2xl
 YW4tY29tcGlsZToKKyAJLXJtIC1mICouJChPQkpFWFQpCisgCmRpZmYgLS1naXQgYS9qYXZhL2ph
 bXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtc3JjX2FsbG9jLmMgYi9qYXZhL2phbXZtLWluaXRpYWwv
 ZmlsZXMvcGF0Y2gtc3JjX2FsbG9jLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw
 MC4uYTE0YjcyMAotLS0gL2Rldi9udWxsCisrKyBiL2phdmEvamFtdm0taW5pdGlhbC9maWxlcy9w
 YXRjaC1zcmNfYWxsb2MuYwpAQCAtMCwwICsxLDQ2IEBACistLS0gc3JjL2FsbG9jLmMub3JpZwky
 MDA4LTAyLTIyIDAyOjU3OjQyLjAwMDAwMDAwMCArMDEwMAorKysrIHNyYy9hbGxvYy5jCTIwMTIt
 MDEtMjYgMTk6MzI6NDAuMDAwMDAwMDAwICswMTAwCitAQCAtMjEzNCw4ICsyMTM0LDggQEAgdW5z
 aWduZWQgbG9uZyBtYXhIZWFwTWVtKCkgeworICAgICBzdXNwZW5kZWQgd2hpbGUgaG9sZGluZyB0
 aGUgbWFsbG9jIGxvY2sgKi8KKyAKKyB2b2lkICpnY01lbU1hbGxvYyhpbnQgbikgeworLSAgICBp
 bnQgc2l6ZSA9IG4gKyBzaXplb2YoaW50KTsKKy0gICAgaW50ICptZW0gPSBtbWFwKDAsIHNpemUs
 IFBST1RfUkVBRHxQUk9UX1dSSVRFLAorKyAgICB1aW50cHRyX3Qgc2l6ZSA9IG4gKyBzaXplb2Yo
 dWludHB0cl90KTsKKysgICAgdWludHB0cl90ICptZW0gPSBtbWFwKDAsIHNpemUsIFBST1RfUkVB
 RHxQUk9UX1dSSVRFLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTUFQX1BSSVZBVEV8
 TUFQX0FOT04sIC0xLCAwKTsKKyAKKyAgICAgaWYobWVtID09IE1BUF9GQUlMRUQpIHsKK0BAIC0y
 MTUxLDkgKzIxNTEsOSBAQCB2b2lkICpnY01lbVJlYWxsb2Modm9pZCAqYWRkciwgaW50IHNpemUp
 CisgICAgIGlmKGFkZHIgPT0gTlVMTCkKKyAgICAgICAgIHJldHVybiBnY01lbU1hbGxvYyhzaXpl
 KTsKKyAgICAgZWxzZSB7CistICAgICAgICBpbnQgKm1lbSA9IGFkZHI7CistICAgICAgICBpbnQg
 b2xkX3NpemUgPSAqLS1tZW07CistICAgICAgICBpbnQgbmV3X3NpemUgPSBzaXplICsgc2l6ZW9m
 KGludCk7CisrICAgICAgICB1aW50cHRyX3QgKm1lbSA9IGFkZHI7CisrICAgICAgICB1aW50cHRy
 X3Qgb2xkX3NpemUgPSAqLS1tZW07CisrICAgICAgICB1aW50cHRyX3QgbmV3X3NpemUgPSBzaXpl
 ICsgc2l6ZW9mKHVpbnRwdHJfdCk7CisgCisgICAgICAgICBpZihvbGRfc2l6ZS9zeXNfcGFnZV9z
 aXplID09IG5ld19zaXplL3N5c19wYWdlX3NpemUpIHsKKyAgICAgICAgICAgICAqbWVtID0gbmV3
 X3NpemU7CitAQCAtMjE2Miw3ICsyMTYyLDcgQEAgdm9pZCAqZ2NNZW1SZWFsbG9jKHZvaWQgKmFk
 ZHIsIGludCBzaXplKQorICAgICAgICAgICAgIGludCBjb3B5X3NpemUgPSBuZXdfc2l6ZSA+IG9s
 ZF9zaXplID8gb2xkX3NpemUgOiBuZXdfc2l6ZTsKKyAgICAgICAgICAgICB2b2lkICpuZXdfbWVt
 ID0gZ2NNZW1NYWxsb2Moc2l6ZSk7CisgCistICAgICAgICAgICAgbWVtY3B5KG5ld19tZW0sIGFk
 ZHIsIGNvcHlfc2l6ZSAtIHNpemVvZihpbnQpKTsKKysgICAgICAgICAgICBtZW1jcHkobmV3X21l
 bSwgYWRkciwgY29weV9zaXplIC0gc2l6ZW9mKHVpbnRwdHJfdCkpOworICAgICAgICAgICAgIG11
 bm1hcChtZW0sIG9sZF9zaXplKTsKKyAKKyAgICAgICAgICAgICByZXR1cm4gbmV3X21lbTsKK0BA
 IC0yMTcyLDggKzIxNzIsOCBAQCB2b2lkICpnY01lbVJlYWxsb2Modm9pZCAqYWRkciwgaW50IHNp
 emUpCisgCisgdm9pZCBnY01lbUZyZWUodm9pZCAqYWRkcikgeworICAgICBpZihhZGRyICE9IE5V
 TEwpIHsKKy0gICAgICAgIGludCAqbWVtID0gYWRkcjsKKy0gICAgICAgIGludCBzaXplID0gKi0t
 bWVtOworKyAgICAgICAgdWludHB0cl90ICptZW0gPSBhZGRyOworKyAgICAgICAgdWludHB0cl90
 IHNpemUgPSAqLS1tZW07CisgICAgICAgICBtdW5tYXAobWVtLCBzaXplKTsKKyAgICAgfQorIH0K
 ZGlmZiAtLWdpdCBhL2phdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfYXJjaF9zcGFy
 YzY0LmggYi9qYXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtc3JjX2FyY2hfc3BhcmM2NC5o
 Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmM0YWY0YzEKLS0tIC9kZXYvbnVs
 bAorKysgYi9qYXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtc3JjX2FyY2hfc3BhcmM2NC5o
 CkBAIC0wLDAgKzEsMTM3IEBACistLS0gc3JjL2FyY2gvc3BhcmM2NC5oLm9yaWcJMjAxMi0wMS0y
 NiAxOTozMjo0MC4wMDAwMDAwMDAgKzAxMDAKKysrKyBzcmMvYXJjaC9zcGFyYzY0LmgJMjAxMi0w
 MS0yNiAxOTozMjo0MC4wMDAwMDAwMDAgKzAxMDAKK0BAIC0wLDAgKzEsMTM0IEBACisrLyoKKysg
 KiBDb3B5cmlnaHQgKEMpIDIwMDMsIDIwMDQsIDIwMDUsIDIwMDYsIDIwMDcsIDIwMDgKKysgKiBS
 b2JlcnQgTG91Z2hlciA8cm9iQGxvdWdoZXIub3JnLnVrPi4KKysgKgorKyAqIFRoaXMgZmlsZSBp
 cyBwYXJ0IG9mIEphbVZNLgorKyAqCisrICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7
 IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUg
 dGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisrICogYXMgcHVibGlzaGVk
 IGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsCisrICog
 b3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKysgKgorKyAqIFRoaXMgcHJv
 Z3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAor
 KyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh
 cnJhbnR5IG9mCisrICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB
 UiBQVVJQT1NFLiAgU2VlIHRoZQorKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt
 b3JlIGRldGFpbHMuCisrICoKKysgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9m
 IHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorKyAqIGFsb25nIHdpdGggdGhpcyBwcm9n
 cmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisrICogRm91bmRhdGlvbiwg
 NTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBV
 U0EuCisrICovCisrCisrI2RlZmluZSBPU19BUkNIICJzcGFyYzY0IgorKworKyNkZWZpbmUgSEFO
 RExFUl9UQUJMRV9UIHN0YXRpYyBjb25zdCB2b2lkCisrI2RlZmluZSBET1VCTEVfMV9CSVRTIDB4
 M2ZmMDAwMDAwMDAwMDAwMExMCisrCisrI2RlZmluZSBSRUFEX0RCTCh2LHAsbCkJdiA9ICgodTgp
 cFswXTw8NTYpfCgodTgpcFsxXTw8NDgpfCgodTgpcFsyXTw8NDApICBcCisrICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgIHwoKHU4KXBbM108PDMyKXwoKHU4KXBbNF08PDI0KXwoKHU4KXBbNV08
 PDE2KSBcCisrICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwoKHU4KXBbNl08PDgpfCh1OClw
 WzddOyBwKz04CisrCisrI2RlZmluZSBGUFVfSEFDSworKworK3N0YXRpYyBpbmxpbmUgdWludDMy
 X3QKKytjb21wYXJlX2FuZF9zd2FwXzMyKHZvbGF0aWxlIHVpbnQzMl90ICphZGRyLCB1aW50MzJf
 dCBvbGR2YWwsIHVpbnQzMl90IG5ld3ZhbCkKKyt7CisrICAgdWludDMyX3QgcmVzdWx0OworKyAg
 IF9fYXNtX18gX192b2xhdGlsZV9fICgiY2FzIFslNF0sICUyLCAlMCIKKysgICAJCQk6ICI9ciIg
 KHJlc3VsdCksICI9bSIgKCphZGRyKQorKwkJCTogInIiIChvbGR2YWwpLCAibSIgKCphZGRyKSwg
 InIiIChhZGRyKSwKKysJCQkiMCIgKG5ld3ZhbCkpOworKyAgcmV0dXJuIHJlc3VsdCA9PSBvbGR2
 YWw7CisrfQorKworKyNkZWZpbmUgQ09NUEFSRV9BTkRfU1dBUDMyIGNvbXBhcmVfYW5kX3N3YXBf
 MzIKKysKKytzdGF0aWMgaW5saW5lIHVpbnQ2NF90CisrY29tcGFyZV9hbmRfc3dhcF82NCggdm9s
 YXRpbGUgdWludDY0X3QgKmFkZHIsIAorKyAgICAgICAgICAgICAgICAgICAgIHZvbGF0aWxlIHVp
 bnQ2NF90IG9sZHZhbCwgCisrICAgICAgICAgICAgICAgICAgICAgdm9sYXRpbGUgdWludDY0X3Qg
 bmV3dmFsICkKKyt7CisrI2lmIDEKKysgICB1aW50NjRfdCByZXN1bHQ7CisrICAgX19hc21fXyBf
 X3ZvbGF0aWxlX18gKCJjYXN4IFslNF0sICUyLCAlMCIKKysgICAJCQk6ICI9ciIgKHJlc3VsdCks
 ICI9bSIgKCphZGRyKQorKwkJCTogInIiIChvbGR2YWwpLCAibSIgKCphZGRyKSwgInIiIChhZGRy
 KSwKKysJCQkiMCIgKG5ld3ZhbCkpOworKyAgcmV0dXJuIHJlc3VsdCA9PSBvbGR2YWw7CisrI2Vs
 c2UKKysgIGlmKCphZGRyID09IG9sZHZhbCkgeyAgICAgICAgICAgICAgICAgICAgICAgCisrICAg
 ICAgICAqYWRkciA9IG5ld3ZhbDsgICAgICAgICAgICAgICAgICAgICAgICAKKysgICAgICAgIHJl
 dHVybiAxOworKyAgICB9IGVsc2UgeworKyAgICAgICAgcmV0dXJuIDA7CisrICAgIH0KKysgIAor
 KyNlbmRpZgorK30KKysKKysjZGVmaW5lIENPTVBBUkVfQU5EX1NXQVA2NCBjb21wYXJlX2FuZF9z
 d2FwXzY0ICAgIAorKyNpZmRlZiBfX2FyY2g2NF9fCisrIyAgZGVmaW5lIENPTVBBUkVfQU5EX1NX
 QVAgQ09NUEFSRV9BTkRfU1dBUDY0CisrI2Vsc2UKKysjICBkZWZpbmUgQ09NUEFSRV9BTkRfU1dB
 UCBDT01QQVJFX0FORF9TV0FQMzIKKysjZW5kaWYKKysKKysjZGVmaW5lIFNUT1JFX0xPQUQgX19h
 c21fXyBfX3ZvbGF0aWxlX18gKCJtZW1iYXIgI1N0b3JlTG9hZCIgOiA6IDogIm1lbW9yeSIpCisr
 CisrCisrI2RlZmluZSBMT0NLV09SRF9SRUFEKGFkZHIpICh7IFNUT1JFX0xPQUQ7ICphZGRyOyB9
 KQorKyNkZWZpbmUgTE9DS1dPUkRfV1JJVEUoYWRkciwgdmFsdWUpICh7IFNUT1JFX0xPQUQ7ICph
 ZGRyID0gdmFsdWU7IH0pCisrI2RlZmluZSBMT0NLV09SRF9DT01QQVJFX0FORF9TV0FQIENPTVBB
 UkVfQU5EX1NXQVAKKysKKysjZGVmaW5lIF9fR0VOX1JFTF9KTVAodGFyZ2V0X2FkZHIsIHBhdGNo
 X2FkZHIsIG9wY29kZSwgICAgICAgXAorKyAgICAgICAgICAgICAgICAgICAgICB0eXBlLCBwYXRj
 aF9zaXplKSAgICAgICAgICAgICAgICAgICAgICBcCisrKHsgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKysgICAgaW50IHBhdGNoZWQg
 PSBGQUxTRTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorKyAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisr
 ICAgIGlmKHBhdGNoX3NpemUgPj0gMSArIHNpemVvZih0eXBlKSkgeyAgICAgICAgICAgICAgICAg
 ICAgIFwKKysgICAgICAgIGNoYXIgKm54dF9pbnNfcHRyID0gKHBhdGNoX2FkZHIpICsgMSArIHNp
 emVvZih0eXBlKTsgXAorKyAgICAgICAgdWludHB0cl90IGxpbWl0ID0gMVVMTDw8KChzaXplb2Yo
 dHlwZSkgKiA4KSAtIDEpOyAgICBcCisrICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKysgICAgICAgIC8qIFRoZSBjaGVjayBpcyBk
 b25lIGluIHR3byBwYXJ0cyB0byBlbnN1cmUgdGhlICAgICAgXAorKyAgICAgICAgICAgcmVzdWx0
 IGlzIGFsd2F5cyBwb3NpdGl2ZSwgdG8gZ3VhcmQgYWdhaW5zdCAgICAgICBcCisrICAgICAgICAg
 ICB0aGUgcG9pbnRlciBkaWZmZXJlbmNlIGJlaW5nIGxhcmdlciB0aGFuIHRoZSAgICAgIFwKKysg
 ICAgICAgICAgIHNpZ25lZCByYW5nZSAqLyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAgXAorKyAgICAgICAgaWYodGFyZ2V0X2FkZHIgPiBueHRfaW5zX3B0cikgeyAgICAgICAgICAg
 ICAgICAgICAgICBcCisrICAgICAgICAgICAgdWludHB0cl90IGRpc3AgPSAodGFyZ2V0X2FkZHIp
 IC0gKG54dF9pbnNfcHRyKTsgIFwKKysgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorKyAgICAgICAgICAgIGlmKGRpc3AgPCBsaW1p
 dCkgeyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisrICAgICAgICAgICAgICAgICoo
 cGF0Y2hfYWRkcikgPSBvcGNvZGU7ICAgICAgICAgICAgICAgICAgICAgIFwKKysgICAgICAgICAg
 ICAgICAgKih0eXBlKikmKHBhdGNoX2FkZHIpWzFdID0gZGlzcDsgICAgICAgICAgICAgXAorKyAg
 ICAgICAgICAgICAgICBwYXRjaGVkID0gVFJVRTsgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICBcCisrICAgICAgICAgICAgfSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgIFwKKysgICAgICAgIH0gZWxzZSB7ICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgXAorKyAgICAgICAgICAgIHVpbnRwdHJfdCBkaXNwID0gKG54dF9p
 bnNfcHRyKSAtICh0YXJnZXRfYWRkcik7ICBcCisrICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKysgICAgICAgICAgICBpZihkaXNw
 IDw9IGxpbWl0KSB7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorKyAgICAgICAgICAg
 ICAgICAqKHBhdGNoX2FkZHIpID0gb3Bjb2RlOyAgICAgICAgICAgICAgICAgICAgICBcCisrICAg
 ICAgICAgICAgICAgICoodHlwZSopJihwYXRjaF9hZGRyKVsxXSA9IC1kaXNwOyAgICAgICAgICAg
 IFwKKysgICAgICAgICAgICAgICAgcGF0Y2hlZCA9IFRSVUU7ICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgXAorKyAgICAgICAgICAgIH0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICBcCisrICAgICAgICB9ICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgIFwKKysgICAgfSAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorKyAgICBwYXRjaGVkOyAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisrfSkKKysKKysjZGVm
 aW5lIEdFTl9SRUxfSk1QKHRhcmdldF9hZGRyLCBwYXRjaF9hZGRyLCBwYXRjaF9zaXplKSBcCisr
 KHsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 XAorKyAgICBfX0dFTl9SRUxfSk1QKHRhcmdldF9hZGRyLCBwYXRjaF9hZGRyLCAweGViLCAgICAg
 ICAgIFwKKysgICAgICAgICAgICAgICAgICBzaWduZWQgY2hhciwgcGF0Y2hfc2l6ZSkgfHwgICAg
 ICAgICAgICBcCisrICAgIF9fR0VOX1JFTF9KTVAodGFyZ2V0X2FkZHIsIHBhdGNoX2FkZHIsIDB4
 ZTksICAgICAgICAgXAorKyAgICAgICAgICAgICAgICAgIHNpZ25lZCBpbnQsIHBhdGNoX3NpemUp
 OyAgICAgICAgICAgICAgIFwKKyt9KQorKworKyNpZmRlZiBJTkxJTklORworKyNlcnJvciAiSSBk
 b24ndCBrbm93IGhvdyB0byBmbHVzaCIKKysjZGVmaW5lIEZMVVNIX0NBQ0hFKGFkZHIsIGxlbmd0
 aCkKKysjZW5kaWYKKysjZGVmaW5lIE1CQVJSSUVSKCkgX19hc21fXyBfX3ZvbGF0aWxlX18gKCJt
 ZW1iYXIgI0xvYWRMb2FkIHwgI0xvYWRTdG9yZSJcCisrICAgICAgICAgICAgICAgICAgICAgICAg
 IiB8ICNTdG9yZUxvYWQgfCAjU3RvcmVTdG9yZSIgOiA6IDogIm1lbW9yeSIpCisrI2RlZmluZSBV
 TkxPQ0tfTUJBUlJJRVIoKSBNQkFSUklFUigpCisrI2RlZmluZSBKTU1fTE9DS19NQkFSUklFUigp
 IE1CQVJSSUVSKCkKKysjZGVmaW5lIEpNTV9VTkxPQ0tfTUJBUlJJRVIoKSBNQkFSUklFUigpCisr
 CmRpZmYgLS1naXQgYS9qYXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtc3JjX2NsYXNzLmgg
 Yi9qYXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtc3JjX2NsYXNzLmgKbmV3IGZpbGUgbW9k
 ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDdjYWI5NQotLS0gL2Rldi9udWxsCisrKyBiL2phdmEv
 amFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfY2xhc3MuaApAQCAtMCwwICsxLDE4IEBACist
 LS0gc3JjL2NsYXNzLmgub3JpZwkyMDEyLTAxLTE3IDIyOjAzOjA3LjAwMDAwMDAwMCArMDEwMAor
 KysrIHNyYy9jbGFzcy5oCTIwMTItMDEtMTcgMjI6MDQ6MTIuMDAwMDAwMDAwICswMTAwCitAQCAt
 MzksMTEgKzM5LDExIEBACisgICAgc2VwYXJhdGUgY2xhc3MgZmlsZXMgaW4gYSBkaXJlY3Rvcnkg
 c3RydWN0dXJlICovCisgCisgI2lmZGVmIFVTRV9aSVAKKy0jZGVmaW5lIEpBTVZNX0NMQVNTRVMg
 SU5TVEFMTF9ESVIiL3NoYXJlL2phbXZtL2NsYXNzZXMuemlwIgorLSNkZWZpbmUgQ0xBU1NQQVRI
 X0NMQVNTRVMgQ0xBU1NQQVRIX0lOU1RBTExfRElSIi9zaGFyZS9jbGFzc3BhdGgvZ2xpYmouemlw
 IgorKyNkZWZpbmUgSkFNVk1fQ0xBU1NFUyBJTlNUQUxMX0RJUiIvc2hhcmUvamFtdm0taW5pdGlh
 bC9jbGFzc2VzLnppcCIKKysjZGVmaW5lIENMQVNTUEFUSF9DTEFTU0VTIENMQVNTUEFUSF9JTlNU
 QUxMX0RJUiIvc2hhcmUvY2xhc3NwYXRoLWluaXRpYWwvZ2xpYmouemlwIgorICNlbHNlCistI2Rl
 ZmluZSBKQU1WTV9DTEFTU0VTIElOU1RBTExfRElSIi9zaGFyZS9qYW12bS9jbGFzc2VzIgorLSNk
 ZWZpbmUgQ0xBU1NQQVRIX0NMQVNTRVMgQ0xBU1NQQVRIX0lOU1RBTExfRElSIi9zaGFyZS9jbGFz
 c3BhdGgiCisrI2RlZmluZSBKQU1WTV9DTEFTU0VTIElOU1RBTExfRElSIi9zaGFyZS9qYW12bS1p
 bml0aWFsL2NsYXNzZXMiCisrI2RlZmluZSBDTEFTU1BBVEhfQ0xBU1NFUyBDTEFTU1BBVEhfSU5T
 VEFMTF9ESVIiL3NoYXJlL2NsYXNzcGF0aC1pbml0aWFsIgorICNlbmRpZgorIAorICNkZWZpbmUg
 REZMVF9CQ1AgSkFNVk1fQ0xBU1NFUyI6IkNMQVNTUEFUSF9DTEFTU0VTCmRpZmYgLS1naXQgYS9q
 YXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtc3JjX2RsbC5jIGIvamF2YS9qYW12bS1pbml0
 aWFsL2ZpbGVzL3BhdGNoLXNyY19kbGwuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw
 MDAwLi4zMzExYTZkCi0tLSAvZGV2L251bGwKKysrIGIvamF2YS9qYW12bS1pbml0aWFsL2ZpbGVz
 L3BhdGNoLXNyY19kbGwuYwpAQCAtMCwwICsxLDExIEBACistLS0gc3JjL2RsbC5jLm9yaWcJMjAx
 Mi0wMS0xNyAyMjoyODoyNy4wMDAwMDAwMDAgKzAxMDAKKysrKyBzcmMvZGxsLmMJMjAxMi0wMS0x
 NyAyMjoyODo0MC4wMDAwMDAwMDAgKzAxMDAKK0BAIC0zMDYsNyArMzA2LDcgQEAgY2hhciAqZ2V0
 RGxsUGF0aCgpIHsKKyB9CisgCisgY2hhciAqZ2V0Qm9vdERsbFBhdGgoKSB7CistICAgIHJldHVy
 biBDTEFTU1BBVEhfSU5TVEFMTF9ESVIiL2xpYi9jbGFzc3BhdGgiOworKyAgICByZXR1cm4gQ0xB
 U1NQQVRIX0lOU1RBTExfRElSIi9saWIvY2xhc3NwYXRoLWluaXRpYWwiOworIH0KKyAKKyBjaGFy
 ICpnZXREbGxOYW1lKGNoYXIgKm5hbWUpIHsKZGlmZiAtLWdpdCBhL2phdmEvamFtdm0taW5pdGlh
 bC9maWxlcy9wYXRjaC1zcmNfZGxsX2ZmaS5jIGIvamF2YS9qYW12bS1pbml0aWFsL2ZpbGVzL3Bh
 dGNoLXNyY19kbGxfZmZpLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYmNh
 YjQ4NAotLS0gL2Rldi9udWxsCisrKyBiL2phdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1z
 cmNfZGxsX2ZmaS5jCkBAIC0wLDAgKzEsMTMgQEAKKy0tLSBzcmMvZGxsX2ZmaS5jLm9yaWcJMjAw
 Ny0xMS0xMiAwNTowNDozNy4wMDAwMDAwMDAgKzAxMDAKKysrKyBzcmMvZGxsX2ZmaS5jCTIwMTIt
 MDEtMjYgMTk6MzI6NDAuMDAwMDAwMDAwICswMTAwCitAQCAtNzIsOCArNzIsOCBAQCBpbnQgbmF0
 aXZlRXh0cmFBcmcoTWV0aG9kQmxvY2sgKm1iKSB7CisgdWludHB0cl90ICpjYWxsSk5JTWV0aG9k
 KHZvaWQgKmVudiwgQ2xhc3MgKmNsYXNzLCBjaGFyICpzaWcsIGludCBudW1fYXJncywgdWludHB0
 cl90ICpvc3RhY2ssCisgICAgICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGNoYXIgKmZ1
 bmMpIHsKKyAgICAgZmZpX2NpZiBjaWY7CistICAgIHZvaWQgKnZhbHVlc1tudW1fYXJnc107Cist
 ICAgIGZmaV90eXBlICp0eXBlc1tudW1fYXJnc107CisrICAgIHZvaWQgKnZhbHVlc1tudW1fYXJn
 cyArIDFdOworKyAgICBmZmlfdHlwZSAqdHlwZXNbbnVtX2FyZ3MgKyAxXTsKKyAgICAgdWludHB0
 cl90ICpvcG50ciA9IG9zdGFjazsKKyAgICAgdm9pZCAqKnZhbHVlc19wbnRyID0gJnZhbHVlc1sy
 XTsKKyAgICAgZmZpX3R5cGUgKip0eXBlc19wbnRyID0gJnR5cGVzWzJdOwpkaWZmIC0tZ2l0IGEv
 amF2YS9qYW12bS1pbml0aWFsL2ZpbGVzL3BhdGNoLXNyY19mcmFtZS5oIGIvamF2YS9qYW12bS1p
 bml0aWFsL2ZpbGVzL3BhdGNoLXNyY19mcmFtZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4
 IDAwMDAwMDAuLjAxNGU4YzAKLS0tIC9kZXYvbnVsbAorKysgYi9qYXZhL2phbXZtLWluaXRpYWwv
 ZmlsZXMvcGF0Y2gtc3JjX2ZyYW1lLmgKQEAgLTAsMCArMSwyMiBAQAorLS0tIHNyYy9mcmFtZS5o
 Lm9yaWcJMjAwOC0wMS0yNiAwMjoxNTo0MS4wMDAwMDAwMDAgKzAxMDAKKysrKyBzcmMvZnJhbWUu
 aAkyMDEyLTAxLTI2IDE5OjMyOjQwLjAwMDAwMDAwMCArMDEwMAorQEAgLTE5LDYgKzE5LDEwIEBA
 CisgICogRm91bmRhdGlvbiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwgQm9zdG9u
 LCBNQSAwMjExMC0xMzAxLCBVU0EuCisgICovCisgCisrLyogRW5zdXJlIG9wZXJhbmQgc3RhY2sg
 aXMgZG91YmxlLXdvcmQgYWxpZ25lZC4gIFRoaXMgbGVhZHMgdG8KKysgICBiZXR0ZXIgZG91Ymxl
 IGZsb2F0aW5nLXBvaW50IHBlcmZvcm1hbmNlICovCisrI2RlZmluZSBBTElHTl9PU1RBQ0socG50
 cikgKHVpbnRwdHJfdCopKCgodWludHB0cl90KShwbnRyKSArIDcpICYgfjcpCisrCisgI2RlZmlu
 ZSBDUkVBVEVfVE9QX0ZSQU1FKGVlLCBjbGFzcywgbWIsIHNwLCByZXQpICAgICAgICAgICAgICAg
 IFwKKyB7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgXAorICAgICBGcmFtZSAqbGFzdCA9IGVlLT5sYXN0X2ZyYW1lOyAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICBcCitAQCAtMjgsNyArMzIsNyBAQAorICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisg
 ICAgIHJldCA9ICh2b2lkKikgKHNwID0gKHVpbnRwdHJfdCopKGR1bW15KzEpKTsgICAgICAgICAg
 ICAgICAgIFwKKyAgICAgbmV3X2ZyYW1lID0gKEZyYW1lICopKHNwICsgbWItPm1heF9sb2NhbHMp
 OyAgICAgICAgICAgICAgICAgXAorLSAgICBuZXdfb3N0YWNrID0gKHVpbnRwdHJfdCAqKShuZXdf
 ZnJhbWUgKyAxKTsgICAgICAgICAgICAgICAgICBcCisrICAgIG5ld19vc3RhY2sgPSBBTElHTl9P
 U1RBQ0sobmV3X2ZyYW1lICsgMSk7ICAgICAgICAgICAgICAgICAgXAorICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAg
 IGlmKChjaGFyKikobmV3X29zdGFjayArIG1iLT5tYXhfc3RhY2spID4gZWUtPnN0YWNrX2VuZCkg
 eyAgIFwKKyAgICAgICAgIGlmKGVlLT5vdmVyZmxvdysrKSB7ICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgXApkaWZmIC0tZ2l0IGEvamF2YS9qYW12bS1pbml0aWFsL2ZpbGVzL3Bh
 dGNoLXNyY19vc19ic2Rfb3MuYyBiL2phdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNf
 b3NfYnNkX29zLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOGMwNjMzNQot
 LS0gL2Rldi9udWxsCisrKyBiL2phdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfb3Nf
 YnNkX29zLmMKQEAgLTAsMCArMSwxMSBAQAorLS0tIHNyYy9vcy9ic2Qvb3MuYy5vcmlnCTIwMDct
 MDItMjQgMTc6MTM6MTIuMDAwMDAwMDAwICswMTAwCisrKysgc3JjL29zL2JzZC9vcy5jCTIwMTIt
 MDEtMjYgMTk6MzI6NDAuMDAwMDAwMDAwICswMTAwCitAQCAtNDgsNyArNDgsNyBAQCB2b2lkICpu
 YXRpdmVTdGFja0Jhc2UoKSB7Cisgdm9pZCAqbmF0aXZlU3RhY2tCYXNlKCkgeworICAgICBwdGhy
 ZWFkX2F0dHJfdCBhdHRyOworICAgICB2b2lkICphZGRyOworLSAgICBpbnQgc2l6ZTsKKysgICAg
 c2l6ZV90IHNpemU7CisgCisgICAgIHB0aHJlYWRfYXR0cl9pbml0KCZhdHRyKTsKKyAgICAgcHRo
 cmVhZF9hdHRyX2dldF9ucChwdGhyZWFkX3NlbGYoKSwgJmF0dHIpOwpkaWZmIC0tZ2l0IGEvamF2
 YS9qYW12bS1pbml0aWFsL2ZpbGVzL3BhdGNoLXNyY19vc19ic2Rfc3BhcmM2NF9NYWtlZmlsZS5p
 biBiL2phdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfb3NfYnNkX3NwYXJjNjRfTWFr
 ZWZpbGUuaW4KbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZWVjNzAwNgotLS0g
 L2Rldi9udWxsCisrKyBiL2phdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfb3NfYnNk
 X3NwYXJjNjRfTWFrZWZpbGUuaW4KQEAgLTAsMCArMSw0NDkgQEAKKy0tLSBzcmMvb3MvYnNkL3Nw
 YXJjNjQvTWFrZWZpbGUuaW4ub3JpZwkyMDEyLTAxLTI3IDIxOjM2OjE0LjAwMDAwMDAwMCArMDEw
 MAorKysrIHNyYy9vcy9ic2Qvc3BhcmM2NC9NYWtlZmlsZS5pbgkyMDEyLTAxLTI3IDIxOjM5OjE0
 LjAwMDAwMDAwMCArMDEwMAorQEAgLTAsMCArMSw0NDYgQEAKKysjIE1ha2VmaWxlLmluIGdlbmVy
 YXRlZCBieSBhdXRvbWFrZSAxLjEwLjEgZnJvbSBNYWtlZmlsZS5hbS4KKysjIEBjb25maWd1cmVf
 aW5wdXRACisrCisrIyBDb3B5cmlnaHQgKEMpIDE5OTQsIDE5OTUsIDE5OTYsIDE5OTcsIDE5OTgs
 IDE5OTksIDIwMDAsIDIwMDEsIDIwMDIsCisrIyAyMDAzLCAyMDA0LCAyMDA1LCAyMDA2LCAyMDA3
 LCAyMDA4ICBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4KKysjIFRoaXMgTWFrZWZpbGUu
 aW4gaXMgZnJlZSBzb2Z0d2FyZTsgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorKyMgZ2l2
 ZXMgdW5saW1pdGVkIHBlcm1pc3Npb24gdG8gY29weSBhbmQvb3IgZGlzdHJpYnV0ZSBpdCwKKysj
 IHdpdGggb3Igd2l0aG91dCBtb2RpZmljYXRpb25zLCBhcyBsb25nIGFzIHRoaXMgbm90aWNlIGlz
 IHByZXNlcnZlZC4KKysKKysjIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9w
 ZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorKyMgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZLCB0
 byB0aGUgZXh0ZW50IHBlcm1pdHRlZCBieSBsYXc7IHdpdGhvdXQKKysjIGV2ZW4gdGhlIGltcGxp
 ZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEKKysjIFBBUlRJ
 Q1VMQVIgUFVSUE9TRS4KKysKKytAU0VUX01BS0VACisrCisrVlBBVEggPSBAc3JjZGlyQAorK3Br
 Z2RhdGFkaXIgPSAkKGRhdGFkaXIpL0BQQUNLQUdFQAorK3BrZ2xpYmRpciA9ICQobGliZGlyKS9A
 UEFDS0FHRUAKKytwa2dpbmNsdWRlZGlyID0gJChpbmNsdWRlZGlyKS9AUEFDS0FHRUAKKythbV9f
 Y2QgPSBDRFBBVEg9IiQke1pTSF9WRVJTSU9OKy59JChQQVRIX1NFUEFSQVRPUikiICYmIGNkCisr
 aW5zdGFsbF9zaF9EQVRBID0gJChpbnN0YWxsX3NoKSAtYyAtbSA2NDQKKytpbnN0YWxsX3NoX1BS
 T0dSQU0gPSAkKGluc3RhbGxfc2gpIC1jCisraW5zdGFsbF9zaF9TQ1JJUFQgPSAkKGluc3RhbGxf
 c2gpIC1jCisrSU5TVEFMTF9IRUFERVIgPSAkKElOU1RBTExfREFUQSkKKyt0cmFuc2Zvcm0gPSAk
 KHByb2dyYW1fdHJhbnNmb3JtX25hbWUpCisrTk9STUFMX0lOU1RBTEwgPSA6CisrUFJFX0lOU1RB
 TEwgPSA6CisrUE9TVF9JTlNUQUxMID0gOgorK05PUk1BTF9VTklOU1RBTEwgPSA6CisrUFJFX1VO
 SU5TVEFMTCA9IDoKKytQT1NUX1VOSU5TVEFMTCA9IDoKKytidWlsZF90cmlwbGV0ID0gQGJ1aWxk
 QAorK2hvc3RfdHJpcGxldCA9IEBob3N0QAorK3N1YmRpciA9IHNyYy9vcy9ic2Qvc3BhcmM2NAor
 K0RJU1RfQ09NTU9OID0gJChzcmNkaXIpL01ha2VmaWxlLmFtICQoc3JjZGlyKS9NYWtlZmlsZS5p
 bgorK0FDTE9DQUxfTTQgPSAkKHRvcF9zcmNkaXIpL2FjbG9jYWwubTQKKythbV9fYWNsb2NhbF9t
 NF9kZXBzID0gJCh0b3Bfc3JjZGlyKS9hY2luY2x1ZGUubTQgXAorKwkkKHRvcF9zcmNkaXIpL2Nv
 bmZpZ3VyZS5hYworK2FtX19jb25maWd1cmVfZGVwcyA9ICQoYW1fX2FjbG9jYWxfbTRfZGVwcykg
 JChDT05GSUdVUkVfREVQRU5ERU5DSUVTKSBcCisrCSQoQUNMT0NBTF9NNCkKKytta2luc3RhbGxk
 aXJzID0gJChTSEVMTCkgJCh0b3Bfc3JjZGlyKS9ta2luc3RhbGxkaXJzCisrQ09ORklHX0hFQURF
 UiA9ICQodG9wX2J1aWxkZGlyKS9zcmMvY29uZmlnLmgKKytDT05GSUdfQ0xFQU5fRklMRVMgPQor
 K0xUTElCUkFSSUVTID0gJChub2luc3RfTFRMSUJSQVJJRVMpCisrbGlibmF0aXZlX2xhX0xJQkFE
 RCA9CisrYW1fbGlibmF0aXZlX2xhX09CSkVDVFMgPSBpbml0LmxvCisrbGlibmF0aXZlX2xhX09C
 SkVDVFMgPSAkKGFtX2xpYm5hdGl2ZV9sYV9PQkpFQ1RTKQorK0RFRkFVTFRfSU5DTFVERVMgPSAt
 SS5AYW1fX2lzcmNAIC1JJCh0b3BfYnVpbGRkaXIpL3NyYworK2RlcGNvbXAgPSAkKFNIRUxMKSAk
 KHRvcF9zcmNkaXIpL2RlcGNvbXAKKythbV9fZGVwZmlsZXNfbWF5YmUgPSBkZXBmaWxlcworK0NP
 TVBJTEUgPSAkKENDKSAkKERFRlMpICQoREVGQVVMVF9JTkNMVURFUykgJChJTkNMVURFUykgJChB
 TV9DUFBGTEFHUykgXAorKwkkKENQUEZMQUdTKSAkKEFNX0NGTEFHUykgJChDRkxBR1MpCisrTFRD
 T01QSUxFID0gJChMSUJUT09MKSAtLXRhZz1DQyAkKEFNX0xJQlRPT0xGTEFHUykgJChMSUJUT09M
 RkxBR1MpIFwKKysJLS1tb2RlPWNvbXBpbGUgJChDQykgJChERUZTKSAkKERFRkFVTFRfSU5DTFVE
 RVMpICQoSU5DTFVERVMpIFwKKysJJChBTV9DUFBGTEFHUykgJChDUFBGTEFHUykgJChBTV9DRkxB
 R1MpICQoQ0ZMQUdTKQorK0NDTEQgPSAkKENDKQorK0xJTksgPSAkKExJQlRPT0wpIC0tdGFnPUND
 ICQoQU1fTElCVE9PTEZMQUdTKSAkKExJQlRPT0xGTEFHUykgXAorKwktLW1vZGU9bGluayAkKEND
 TEQpICQoQU1fQ0ZMQUdTKSAkKENGTEFHUykgJChBTV9MREZMQUdTKSBcCisrCSQoTERGTEFHUykg
 LW8gJEAKKytTT1VSQ0VTID0gJChsaWJuYXRpdmVfbGFfU09VUkNFUykKKytESVNUX1NPVVJDRVMg
 PSAkKGxpYm5hdGl2ZV9sYV9TT1VSQ0VTKQorK0VUQUdTID0gZXRhZ3MKKytDVEFHUyA9IGN0YWdz
 CisrRElTVEZJTEVTID0gJChESVNUX0NPTU1PTikgJChESVNUX1NPVVJDRVMpICQoVEVYSU5GT1Mp
 ICQoRVhUUkFfRElTVCkKKytBQ0xPQ0FMID0gQEFDTE9DQUxACisrQUxMT0NBID0gQEFMTE9DQUAK
 KytBTVRBUiA9IEBBTVRBUkAKKytBUiA9IEBBUkAKKytBVVRPQ09ORiA9IEBBVVRPQ09ORkAKKytB
 VVRPSEVBREVSID0gQEFVVE9IRUFERVJACisrQVVUT01BS0UgPSBAQVVUT01BS0VACisrQVdLID0g
 QEFXS0AKKytDQyA9IEBDQ0AKKytDQ0FTID0gQENDQVNACisrQ0NBU0RFUE1PREUgPSBAQ0NBU0RF
 UE1PREVACisrQ0NBU0ZMQUdTID0gQENDQVNGTEFHU0AKKytDQ0RFUE1PREUgPSBAQ0NERVBNT0RF
 QAorK0NGTEFHUyA9IEBDRkxBR1NACisrQ1BQID0gQENQUEAKKytDUFBGTEFHUyA9IEBDUFBGTEFH
 U0AKKytDWFggPSBAQ1hYQAorK0NYWENQUCA9IEBDWFhDUFBACisrQ1hYREVQTU9ERSA9IEBDWFhE
 RVBNT0RFQAorK0NYWEZMQUdTID0gQENYWEZMQUdTQAorK0NZR1BBVEhfVyA9IEBDWUdQQVRIX1dA
 CisrREVGUyA9IEBERUZTQAorK0RFUERJUiA9IEBERVBESVJACisrRFNZTVVUSUwgPSBARFNZTVVU
 SUxACisrRUNITyA9IEBFQ0hPQAorK0VDSE9fQyA9IEBFQ0hPX0NACisrRUNIT19OID0gQEVDSE9f
 TkAKKytFQ0hPX1QgPSBARUNIT19UQAorK0VHUkVQID0gQEVHUkVQQAorK0VYRUVYVCA9IEBFWEVF
 WFRACisrRjc3ID0gQEY3N0AKKytGRkxBR1MgPSBARkZMQUdTQAorK0dSRVAgPSBAR1JFUEAKKytJ
 TlNUQUxMID0gQElOU1RBTExACisrSU5TVEFMTF9EQVRBID0gQElOU1RBTExfREFUQUAKKytJTlNU
 QUxMX1BST0dSQU0gPSBASU5TVEFMTF9QUk9HUkFNQAorK0lOU1RBTExfU0NSSVBUID0gQElOU1RB
 TExfU0NSSVBUQAorK0lOU1RBTExfU1RSSVBfUFJPR1JBTSA9IEBJTlNUQUxMX1NUUklQX1BST0dS
 QU1ACisrSkFWQUMgPSBASkFWQUNACisrTERGTEFHUyA9IEBMREZMQUdTQAorK0xJQk9CSlMgPSBA
 TElCT0JKU0AKKytMSUJTID0gQExJQlNACisrTElCVE9PTCA9IEBMSUJUT09MQAorK0xOX1MgPSBA
 TE5fU0AKKytMVExJQk9CSlMgPSBATFRMSUJPQkpTQAorK01BSU5UID0gQE1BSU5UQAorK01BS0VJ
 TkZPID0gQE1BS0VJTkZPQAorK01LRElSX1AgPSBATUtESVJfUEAKKytOTUVESVQgPSBATk1FRElU
 QAorK09CSkVYVCA9IEBPQkpFWFRACisrUEFDS0FHRSA9IEBQQUNLQUdFQAorK1BBQ0tBR0VfQlVH
 UkVQT1JUID0gQFBBQ0tBR0VfQlVHUkVQT1JUQAorK1BBQ0tBR0VfTkFNRSA9IEBQQUNLQUdFX05B
 TUVACisrUEFDS0FHRV9TVFJJTkcgPSBAUEFDS0FHRV9TVFJJTkdACisrUEFDS0FHRV9UQVJOQU1F
 ID0gQFBBQ0tBR0VfVEFSTkFNRUAKKytQQUNLQUdFX1ZFUlNJT04gPSBAUEFDS0FHRV9WRVJTSU9O
 QAorK1BBVEhfU0VQQVJBVE9SID0gQFBBVEhfU0VQQVJBVE9SQAorK1JBTkxJQiA9IEBSQU5MSUJA
 CisrU0VEID0gQFNFREAKKytTRVRfTUFLRSA9IEBTRVRfTUFLRUAKKytTSEVMTCA9IEBTSEVMTEAK
 KytTVFJJUCA9IEBTVFJJUEAKKytWRVJTSU9OID0gQFZFUlNJT05ACisrYWJzX2J1aWxkZGlyID0g
 QGFic19idWlsZGRpckAKKythYnNfc3JjZGlyID0gQGFic19zcmNkaXJACisrYWJzX3RvcF9idWls
 ZGRpciA9IEBhYnNfdG9wX2J1aWxkZGlyQAorK2Fic190b3Bfc3JjZGlyID0gQGFic190b3Bfc3Jj
 ZGlyQAorK2FjX2N0X0NDID0gQGFjX2N0X0NDQAorK2FjX2N0X0NYWCA9IEBhY19jdF9DWFhACisr
 YWNfY3RfRjc3ID0gQGFjX2N0X0Y3N0AKKythbV9faW5jbHVkZSA9IEBhbV9faW5jbHVkZUAKKyth
 bV9fbGVhZGluZ19kb3QgPSBAYW1fX2xlYWRpbmdfZG90QAorK2FtX19xdW90ZSA9IEBhbV9fcXVv
 dGVACisrYW1fX3RhciA9IEBhbV9fdGFyQAorK2FtX191bnRhciA9IEBhbV9fdW50YXJACisrYXJj
 aCA9IEBhcmNoQAorK2JpbmRpciA9IEBiaW5kaXJACisrYnVpbGQgPSBAYnVpbGRACisrYnVpbGRf
 YWxpYXMgPSBAYnVpbGRfYWxpYXNACisrYnVpbGRfY3B1ID0gQGJ1aWxkX2NwdUAKKytidWlsZF9v
 cyA9IEBidWlsZF9vc0AKKytidWlsZF92ZW5kb3IgPSBAYnVpbGRfdmVuZG9yQAorK2J1aWxkZGly
 ID0gQGJ1aWxkZGlyQAorK2RhdGFkaXIgPSBAZGF0YWRpckAKKytkYXRhcm9vdGRpciA9IEBkYXRh
 cm9vdGRpckAKKytkb2NkaXIgPSBAZG9jZGlyQAorK2R2aWRpciA9IEBkdmlkaXJACisrZXhlY19w
 cmVmaXggPSBAZXhlY19wcmVmaXhACisraG9zdCA9IEBob3N0QAorK2hvc3RfYWxpYXMgPSBAaG9z
 dF9hbGlhc0AKKytob3N0X2NwdSA9IEBob3N0X2NwdUAKKytob3N0X29zID0gQGhvc3Rfb3NACisr
 aG9zdF92ZW5kb3IgPSBAaG9zdF92ZW5kb3JACisraHRtbGRpciA9IEBodG1sZGlyQAorK2luY2x1
 ZGVkaXIgPSBAaW5jbHVkZWRpckAKKytpbmZvZGlyID0gQGluZm9kaXJACisraW5zdGFsbF9zaCA9
 IEBpbnN0YWxsX3NoQAorK2ludGVycF9jZmxhZ3MgPSBAaW50ZXJwX2NmbGFnc0AKKytsaWJkaXIg
 PSBAbGliZGlyQAorK2xpYmV4ZWNkaXIgPSBAbGliZXhlY2RpckAKKytsb2NhbGVkaXIgPSBAbG9j
 YWxlZGlyQAorK2xvY2Fsc3RhdGVkaXIgPSBAbG9jYWxzdGF0ZWRpckAKKyttYW5kaXIgPSBAbWFu
 ZGlyQAorK21rZGlyX3AgPSBAbWtkaXJfcEAKKytvbGRpbmNsdWRlZGlyID0gQG9sZGluY2x1ZGVk
 aXJACisrb3MgPSBAb3NACisrcGRmZGlyID0gQHBkZmRpckAKKytwcmVmaXggPSBAcHJlZml4QAor
 K3Byb2dyYW1fdHJhbnNmb3JtX25hbWUgPSBAcHJvZ3JhbV90cmFuc2Zvcm1fbmFtZUAKKytwc2Rp
 ciA9IEBwc2RpckAKKytzYmluZGlyID0gQHNiaW5kaXJACisrc2hhcmVkc3RhdGVkaXIgPSBAc2hh
 cmVkc3RhdGVkaXJACisrc3JjZGlyID0gQHNyY2RpckAKKytzeXNjb25mZGlyID0gQHN5c2NvbmZk
 aXJACisrdGFyZ2V0X2FsaWFzID0gQHRhcmdldF9hbGlhc0AKKyt0b3BfYnVpbGRkaXIgPSBAdG9w
 X2J1aWxkZGlyQAorK3RvcF9zcmNkaXIgPSBAdG9wX3NyY2RpckAKKyt1c2VfemlwX25vID0gQHVz
 ZV96aXBfbm9ACisrdXNlX3ppcF95ZXMgPSBAdXNlX3ppcF95ZXNACisrd2l0aF9jbGFzc3BhdGhf
 aW5zdGFsbF9kaXIgPSBAd2l0aF9jbGFzc3BhdGhfaW5zdGFsbF9kaXJACisrbm9pbnN0X0xUTElC
 UkFSSUVTID0gbGlibmF0aXZlLmxhCisrbGlibmF0aXZlX2xhX1NPVVJDRVMgPSBpbml0LmMKKytB
 TV9DUFBGTEFHUyA9IC1JJCh0b3BfYnVpbGRkaXIpL3NyYworK2FsbDogYWxsLWFtCisrCisrLlNV
 RkZJWEVTOgorKy5TVUZGSVhFUzogLmMgLmxvIC5vIC5vYmoKKyskKHNyY2RpcikvTWFrZWZpbGUu
 aW46IEBNQUlOVEFJTkVSX01PREVfVFJVRUAgJChzcmNkaXIpL01ha2VmaWxlLmFtICAkKGFtX19j
 b25maWd1cmVfZGVwcykKKysJQGZvciBkZXAgaW4gJD87IGRvIFwKKysJICBjYXNlICckKGFtX19j
 b25maWd1cmVfZGVwcyknIGluIFwKKysJICAgICokJGRlcCopIFwKKysJICAgICAgY2QgJCh0b3Bf
 YnVpbGRkaXIpICYmICQoTUFLRSkgJChBTV9NQUtFRkxBR1MpIGFtLS1yZWZyZXNoIFwKKysJCSYm
 IGV4aXQgMDsgXAorKwkgICAgICBleGl0IDE7OyBcCisrCSAgZXNhYzsgXAorKwlkb25lOyBcCisr
 CWVjaG8gJyBjZCAkKHRvcF9zcmNkaXIpICYmICQoQVVUT01BS0UpIC0tZ251ICBzcmMvb3MvYnNk
 L3NwYXI2NC9NYWtlZmlsZSc7IFwKKysJY2QgJCh0b3Bfc3JjZGlyKSAmJiBcCisrCSAgJChBVVRP
 TUFLRSkgLS1nbnUgIHNyYy9vcy9ic2Qvc3BhcmM2NC9NYWtlZmlsZQorKy5QUkVDSU9VUzogTWFr
 ZWZpbGUKKytNYWtlZmlsZTogJChzcmNkaXIpL01ha2VmaWxlLmluICQodG9wX2J1aWxkZGlyKS9j
 b25maWcuc3RhdHVzCisrCUBjYXNlICckPycgaW4gXAorKwkgICpjb25maWcuc3RhdHVzKikgXAor
 KwkgICAgY2QgJCh0b3BfYnVpbGRkaXIpICYmICQoTUFLRSkgJChBTV9NQUtFRkxBR1MpIGFtLS1y
 ZWZyZXNoOzsgXAorKwkgICopIFwKKysJICAgIGVjaG8gJyBjZCAkKHRvcF9idWlsZGRpcikgJiYg
 JChTSEVMTCkgLi9jb25maWcuc3RhdHVzICQoc3ViZGlyKS8kQCAkKGFtX19kZXBmaWxlc19tYXli
 ZSknOyBcCisrCSAgICBjZCAkKHRvcF9idWlsZGRpcikgJiYgJChTSEVMTCkgLi9jb25maWcuc3Rh
 dHVzICQoc3ViZGlyKS8kQCAkKGFtX19kZXBmaWxlc19tYXliZSk7OyBcCisrCWVzYWM7CisrCisr
 JCh0b3BfYnVpbGRkaXIpL2NvbmZpZy5zdGF0dXM6ICQodG9wX3NyY2RpcikvY29uZmlndXJlICQo
 Q09ORklHX1NUQVRVU19ERVBFTkRFTkNJRVMpCisrCWNkICQodG9wX2J1aWxkZGlyKSAmJiAkKE1B
 S0UpICQoQU1fTUFLRUZMQUdTKSBhbS0tcmVmcmVzaAorKworKyQodG9wX3NyY2RpcikvY29uZmln
 dXJlOiBATUFJTlRBSU5FUl9NT0RFX1RSVUVAICQoYW1fX2NvbmZpZ3VyZV9kZXBzKQorKwljZCAk
 KHRvcF9idWlsZGRpcikgJiYgJChNQUtFKSAkKEFNX01BS0VGTEFHUykgYW0tLXJlZnJlc2gKKysk
 KEFDTE9DQUxfTTQpOiBATUFJTlRBSU5FUl9NT0RFX1RSVUVAICQoYW1fX2FjbG9jYWxfbTRfZGVw
 cykKKysJY2QgJCh0b3BfYnVpbGRkaXIpICYmICQoTUFLRSkgJChBTV9NQUtFRkxBR1MpIGFtLS1y
 ZWZyZXNoCisrCisrY2xlYW4tbm9pbnN0TFRMSUJSQVJJRVM6CisrCS10ZXN0IC16ICIkKG5vaW5z
 dF9MVExJQlJBUklFUykiIHx8IHJtIC1mICQobm9pbnN0X0xUTElCUkFSSUVTKQorKwlAbGlzdD0n
 JChub2luc3RfTFRMSUJSQVJJRVMpJzsgZm9yIHAgaW4gJCRsaXN0OyBkbyBcCisrCSAgZGlyPSJg
 ZWNobyAkJHAgfCBzZWQgLWUgJ3N8L1teL10qJCR8fCdgIjsgXAorKwkgIHRlc3QgIiQkZGlyIiAh
 PSAiJCRwIiB8fCBkaXI9LjsgXAorKwkgIGVjaG8gInJtIC1mIFwiJCR7ZGlyfS9zb19sb2NhdGlv
 bnNcIiI7IFwKKysJICBybSAtZiAiJCR7ZGlyfS9zb19sb2NhdGlvbnMiOyBcCisrCWRvbmUKKyts
 aWJuYXRpdmUubGE6ICQobGlibmF0aXZlX2xhX09CSkVDVFMpICQobGlibmF0aXZlX2xhX0RFUEVO
 REVOQ0lFUykgCisrCSQoTElOSykgICQobGlibmF0aXZlX2xhX09CSkVDVFMpICQobGlibmF0aXZl
 X2xhX0xJQkFERCkgJChMSUJTKQorKworK21vc3RseWNsZWFuLWNvbXBpbGU6CisrCS1ybSAtZiAq
 LiQoT0JKRVhUKQorKworK2Rpc3RjbGVhbi1jb21waWxlOgorKwktcm0gLWYgKi50YWIuYworKwor
 K0BBTURFUF9UUlVFQEBhbV9faW5jbHVkZUAgQGFtX19xdW90ZUAuLyQoREVQRElSKS9pbml0LlBs
 b0BhbV9fcXVvdGVACisrCisrLmMubzoKKytAYW1fX2Zhc3RkZXBDQ19UUlVFQAkkKENPTVBJTEUp
 IC1NVCAkQCAtTUQgLU1QIC1NRiAkKERFUERJUikvJCouVHBvIC1jIC1vICRAICQ8CisrQGFtX19m
 YXN0ZGVwQ0NfVFJVRUAJbXYgLWYgJChERVBESVIpLyQqLlRwbyAkKERFUERJUikvJCouUG8KKytA
 QU1ERVBfVFJVRUBAYW1fX2Zhc3RkZXBDQ19GQUxTRUAJc291cmNlPSckPCcgb2JqZWN0PSckQCcg
 bGlidG9vbD1ubyBAQU1ERVBCQUNLU0xBU0hACisrQEFNREVQX1RSVUVAQGFtX19mYXN0ZGVwQ0Nf
 RkFMU0VACURFUERJUj0kKERFUERJUikgJChDQ0RFUE1PREUpICQoZGVwY29tcCkgQEFNREVQQkFD
 S1NMQVNIQAorK0BhbV9fZmFzdGRlcENDX0ZBTFNFQAkkKENPTVBJTEUpIC1jICQ8CisrCisrLmMu
 b2JqOgorK0BhbV9fZmFzdGRlcENDX1RSVUVACSQoQ09NUElMRSkgLU1UICRAIC1NRCAtTVAgLU1G
 ICQoREVQRElSKS8kKi5UcG8gLWMgLW8gJEAgYCQoQ1lHUEFUSF9XKSAnJDwnYAorK0BhbV9fZmFz
 dGRlcENDX1RSVUVACW12IC1mICQoREVQRElSKS8kKi5UcG8gJChERVBESVIpLyQqLlBvCisrQEFN
 REVQX1RSVUVAQGFtX19mYXN0ZGVwQ0NfRkFMU0VACXNvdXJjZT0nJDwnIG9iamVjdD0nJEAnIGxp
 YnRvb2w9bm8gQEFNREVQQkFDS1NMQVNIQAorK0BBTURFUF9UUlVFQEBhbV9fZmFzdGRlcENDX0ZB
 TFNFQAlERVBESVI9JChERVBESVIpICQoQ0NERVBNT0RFKSAkKGRlcGNvbXApIEBBTURFUEJBQ0tT
 TEFTSEAKKytAYW1fX2Zhc3RkZXBDQ19GQUxTRUAJJChDT01QSUxFKSAtYyBgJChDWUdQQVRIX1cp
 ICckPCdgCisrCisrLmMubG86CisrQGFtX19mYXN0ZGVwQ0NfVFJVRUAJJChMVENPTVBJTEUpIC1N
 VCAkQCAtTUQgLU1QIC1NRiAkKERFUERJUikvJCouVHBvIC1jIC1vICRAICQ8CisrQGFtX19mYXN0
 ZGVwQ0NfVFJVRUAJbXYgLWYgJChERVBESVIpLyQqLlRwbyAkKERFUERJUikvJCouUGxvCisrQEFN
 REVQX1RSVUVAQGFtX19mYXN0ZGVwQ0NfRkFMU0VACXNvdXJjZT0nJDwnIG9iamVjdD0nJEAnIGxp
 YnRvb2w9eWVzIEBBTURFUEJBQ0tTTEFTSEAKKytAQU1ERVBfVFJVRUBAYW1fX2Zhc3RkZXBDQ19G
 QUxTRUAJREVQRElSPSQoREVQRElSKSAkKENDREVQTU9ERSkgJChkZXBjb21wKSBAQU1ERVBCQUNL
 U0xBU0hACisrQGFtX19mYXN0ZGVwQ0NfRkFMU0VACSQoTFRDT01QSUxFKSAtYyAtbyAkQCAkPAor
 KworK21vc3RseWNsZWFuLWxpYnRvb2w6CisrCS1ybSAtZiAqLmxvCisrCisrY2xlYW4tbGlidG9v
 bDoKKysJLXJtIC1yZiAubGlicyBfbGlicworKworK0lEOiAkKEhFQURFUlMpICQoU09VUkNFUykg
 JChMSVNQKSAkKFRBR1NfRklMRVMpCisrCWxpc3Q9JyQoU09VUkNFUykgJChIRUFERVJTKSAkKExJ
 U1ApICQoVEFHU19GSUxFUyknOyBcCisrCXVuaXF1ZT1gZm9yIGkgaW4gJCRsaXN0OyBkbyBcCisr
 CSAgICBpZiB0ZXN0IC1mICIkJGkiOyB0aGVuIGVjaG8gJCRpOyBlbHNlIGVjaG8gJChzcmNkaXIp
 LyQkaTsgZmk7IFwKKysJICBkb25lIHwgXAorKwkgICQoQVdLKSAneyBmaWxlc1skJDBdID0gMTsg
 bm9uZW10cHkgPSAxOyB9IFwKKysJICAgICAgRU5EIHsgaWYgKG5vbmVtcHR5KSB7IGZvciAoaSBp
 biBmaWxlcykgcHJpbnQgaTsgfTsgfSdgOyBcCisrCW1raWQgLWZJRCAkJHVuaXF1ZQorK3RhZ3M6
 IFRBR1MKKysKKytUQUdTOiAgJChIRUFERVJTKSAkKFNPVVJDRVMpICAkKFRBR1NfREVQRU5ERU5D
 SUVTKSBcCisrCQkkKFRBR1NfRklMRVMpICQoTElTUCkKKysJdGFncz07IFwKKysJaGVyZT1gcHdk
 YDsgXAorKwlsaXN0PSckKFNPVVJDRVMpICQoSEVBREVSUykgICQoTElTUCkgJChUQUdTX0ZJTEVT
 KSc7IFwKKysJdW5pcXVlPWBmb3IgaSBpbiAkJGxpc3Q7IGRvIFwKKysJICAgIGlmIHRlc3QgLWYg
 IiQkaSI7IHRoZW4gZWNobyAkJGk7IGVsc2UgZWNobyAkKHNyY2RpcikvJCRpOyBmaTsgXAorKwkg
 IGRvbmUgfCBcCisrCSAgJChBV0spICd7IGZpbGVzWyQkMF0gPSAxOyBub25lbXB0eSA9IDE7IH0g
 XAorKwkgICAgICBFTkQgeyBpZiAobm9uZW1wdHkpIHsgZm9yIChpIGluIGZpbGVzKSBwcmludCBp
 OyB9OyB9J2A7IFwKKysJaWYgdGVzdCAteiAiJChFVEFHU19BUkdTKSQkdGFncyQkdW5pcXVlIjsg
 dGhlbiA6OyBlbHNlIFwKKysJICB0ZXN0IC1uICIkJHVuaXF1ZSIgfHwgdW5pcXVlPSQkZW1wdHlf
 Zml4OyBcCisrCSAgJChFVEFHUykgJChFVEFHU0ZMQUdTKSAkKEFNX0VUQUdTRkxBR1MpICQoRVRB
 R1NfQVJHUykgXAorKwkgICAgJCR0YWdzICQkdW5pcXVlOyBcCisrCWZpCisrY3RhZ3M6IENUQUdT
 CisrQ1RBR1M6ICAkKEhFQURFUlMpICQoU09VUkNFUykgICQoVEFHU19ERVBFTkRFTkNJRVMpIFwK
 KysJCSQoVEFHU19GSUxFUykgJChMSVNQKQorKwl0YWdzPTsgXAorKwlsaXN0PSckKFNPVVJDRVMp
 ICQoSEVBREVSUykgICQoTElTUCkgJChUQUdTX0ZJTEVTKSc7IFwKKysJdW5pcXVlPWBmb3IgaSBp
 biAkJGxpc3Q7IGRvIFwKKysJICAgIGlmIHRlc3QgLWYgIiQkaSI7IHRoZW4gZWNobyAkJGk7IGVs
 c2UgZWNobyAkKHNyY2RpcikvJCRpOyBmaTsgXAorKwkgIGRvbmUgfCBcCisrCSAgJChBV0spICd7
 IGZpbGVzWyQkMF0gPSAxOyBub25lbXB0eSA9IDE7IH0gXAorKwkgICAgICBFTkQgeyBpZiAobm9u
 ZW1wdHkpIHsgZm9yIChpIGluIGZpbGVzKSBwcmludCBpOyB9OyB9J2A7IFwKKysJdGVzdCAteiAi
 JChDVEFHU19BUkdTKSQkdGFncyQkdW5pcXVlIiBcCisrCSAgfHwgJChDVEFHUykgJChDVEFHU0ZM
 QUdTKSAkKEFNX0NUQUdTRkxBR1MpICQoQ1RBR1NfQVJHUykgXAorKwkgICAgICQkdGFncyAkJHVu
 aXF1ZQorKworK0dUQUdTOgorKwloZXJlPWAkKGFtX19jZCkgJCh0b3BfYnVpbGRkaXIpICYmIHB3
 ZGAgXAorKwkgICYmIGNkICQodG9wX3NyY2RpcikgXAorKwkgICYmIGd0YWdzIC1pICQoR1RBR1Nf
 QVJHUykgJCRoZXJlCisrCisrZGlzdGNsZWFuLXRhZ3M6CisrCS1ybSAtZiBUQUdTIElEIEdUQUdT
 IEdSVEFHUyBHU1lNUyBHUEFUSCB0YWdzCisrCisrZGlzdGRpcjogJChESVNURklMRVMpCisrCUBz
 cmNkaXJzdHJpcD1gZWNobyAiJChzcmNkaXIpIiB8IHNlZCAncy9bXS5bXiQkXFwqXS9cXFxcJi9n
 J2A7IFwKKysJdG9wc3JjZGlyc3RyaXA9YGVjaG8gIiQodG9wX3NyY2RpcikiIHwgc2VkICdzL1td
 LlteJCRcXCpdL1xcXFwmL2cnYDsgXAorKwlsaXN0PSckKERJU1RGSUxFUyknOyBcCisrCSAgZGlz
 dF9maWxlcz1gZm9yIGZpbGUgaW4gJCRsaXN0OyBkbyBlY2hvICQkZmlsZTsgZG9uZSB8IFwKKysJ
 ICBzZWQgLWUgInN8XiQkc3JjZGlyc3RyaXAvfHw7dCIgXAorKwkgICAgICAtZSAic3xeJCR0b3Bz
 cmNkaXJzdHJpcC98JCh0b3BfYnVpbGRkaXIpL3w7dCJgOyBcCisrCWNhc2UgJCRkaXN0X2ZpbGVz
 IGluIFwKKysJICAqLyopICQoTUtESVJfUCkgYGVjaG8gIiQkZGlzdF9maWxlcyIgfCBcCisrCQkJ
 ICAgc2VkICcvXC8vIWQ7c3xefCQoZGlzdGRpcikvfDtzLC9bXi9dKiQkLCwnIHwgXAorKwkJCSAg
 IHNvcnQgLXVgIDs7IFwKKysJZXNhYzsgXAorKwlmb3IgZmlsZSBpbiAkJGRpc3RfZmlsZXM7IGRv
 IFwKKysJICBpZiB0ZXN0IC1mICQkZmlsZSB8fCB0ZXN0IC1kICQkZmlsZTsgdGhlbiBkPS47IGVs
 c2UgZD0kKHNyY2Rpcik7IGZpOyBcCisrCSAgaWYgdGVzdCAtZCAkJGQvJCRmaWxlOyB0aGVuIFwK
 KysJICAgIGRpcj1gZWNobyAiLyQkZmlsZSIgfCBzZWQgLWUgJ3MsL1teL10qJCQsLCdgOyBcCisr
 CSAgICBpZiB0ZXN0IC1kICQoc3JjZGlyKS8kJGZpbGUgJiYgdGVzdCAkJGQgIT0gJChzcmNkaXIp
 OyB0aGVuIFwKKysJICAgICAgY3AgLXBSICQoc3JjZGlyKS8kJGZpbGUgJChkaXN0ZGlyKSQkZGly
 IHx8IGV4aXQgMTsgXAorKwkgICAgZmk7IFwKKysJICAgIGNwIC1wUiAkJGQvJCRmaWxlICQoZGlz
 dGRpcikkJGRpciB8fCBleGl0IDE7IFwKKysJICBlbHNlIFwKKysJICAgIHRlc3QgLWYgJChkaXN0
 ZGlyKS8kJGZpbGUgXAorKwkgICAgfHwgY3AgLXAgJCRkLyQkZmlsZSAkKGRpc3RkaXIpLyQkZmls
 ZSBcCisrCSAgICB8fCBleGl0IDE7IFwKKysJICBmaTsgXAorKwlkb25lCisrY2hlY2stYW06IGFs
 bC1hbQorK2NoZWNrOiBjaGVjay1hbQorK2FsbC1hbTogTWFrZWZpbGUgJChMVExJQlJBUklFUykK
 KytpbnN0YWxsZGlyczoKKytpbnN0YWxsOiBpbnN0YWxsLWFtCisraW5zdGFsbC1leGVjOiBpbnN0
 YWxsLWV4ZWMtYW0KKytpbnN0YWxsLWRhdGE6IGluc3RhbGwtZGF0YS1hbQorK3VuaW5zdGFsbDog
 dW5pbnN0YWxsLWFtCisrCisraW5zdGFsbC1hbTogYWxsLWFtCisrCUAkKE1BS0UpICQoQU1fTUFL
 RUZMQUdTKSBpbnN0YWxsLWV4ZWMtYW0gaW5zdGFsbC1kYXRhLWFtCisrCisraW5zdGFsbGNoZWNr
 OiBpbnN0YWxsY2hlY2stYW0KKytpbnN0YWxsLXN0cmlwOgorKwkkKE1BS0UpICQoQU1fTUFLRUZM
 QUdTKSBJTlNUQUxMX1BST0dSQU09IiQoSU5TVEFMTF9TVFJJUF9QUk9HUkFNKSIgXAorKwkgIGlu
 c3RhbGxfc2hfUFJPR1JBTT0iJChJTlNUQUxMX1NUUklQX1BST0dSQU0pIiBJTlNUQUxMX1NUUklQ
 X0ZMQUc9LXMgXAorKwkgIGB0ZXN0IC16ICckKFNUUklQKScgfHwgXAorKwkgICAgZWNobyAiSU5T
 VEFMTF9QUk9HUkFNX0VOVj1TVFJJUFBST0c9JyQoU1RSSVApJyJgIGluc3RhbGwKKyttb3N0bHlj
 bGVhbi1nZW5lcmljOgorKworK2NsZWFuLWdlbmVyaWM6CisrCisrZGlzdGNsZWFuLWdlbmVyaWM6
 CisrCS10ZXN0IC16ICIkKENPTkZJR19DTEVBTl9GSUxFUykiIHx8IHJtIC1mICQoQ09ORklHX0NM
 RUFOX0ZJTEVTKQorKworK21haW50YWluZXItY2xlYW4tZ2VuZXJpYzoKKysJQGVjaG8gIlRoaXMg
 Y29tbWFuZCBpcyBpbnRlbmRlZCBmb3IgbWFpbnRhaW5lcnMgdG8gdXNlIgorKwlAZWNobyAiaXQg
 ZGVsZXRlcyBmaWxlcyB0aGF0IG1heSByZXF1aXJlIHNwZWNpYWwgdG9vbHMgdG8gcmVidWlsZC4i
 CisrY2xlYW46IGNsZWFuLWFtCisrCisrY2xlYW4tYW06IGNsZWFuLWdlbmVyaWMgY2xlYW4tbGli
 dG9vbCBjbGVhbi1ub2luc3RMVExJQlJBUklFUyBcCisrCW1vc3RseWNsZWFuLWFtCisrCisrZGlz
 dGNsZWFuOiBkaXN0Y2xlYW4tYW0KKysJLXJtIC1yZiAuLyQoREVQRElSKQorKwktcm0gLWYgTWFr
 ZWZpbGUKKytkaXN0Y2xlYW4tYW06IGNsZWFuLWFtIGRpc3RjbGVhbi1jb21waWxlIGRpc3RjbGVh
 bi1nZW5lcmljIFwKKysJZGlzdGNsZWFuLXRhZ3MKKysKKytkdmk6IGR2aS1hbQorKworK2R2aS1h
 bToKKysKKytodG1sOiBodG1sLWFtCisrCisraW5mbzogaW5mby1hbQorKworK2luZm8tYW06Cisr
 CisraW5zdGFsbC1kYXRhLWFtOgorKworK2luc3RhbGwtZHZpOiBpbnN0YWxsLWR2aS1hbQorKwor
 K2luc3RhbGwtZXhlYy1hbToKKysKKytpbnN0YWxsLWh0bWw6IGluc3RhbGwtaHRtbC1hbQorKwor
 K2luc3RhbGwtaW5mbzogaW5zdGFsbC1pbmZvLWFtCisrCisraW5zdGFsbC1tYW46CisrCisraW5z
 dGFsbC1wZGY6IGluc3RhbGwtcGRmLWFtCisrCisraW5zdGFsbC1wczogaW5zdGFsbC1wcy1hbQor
 KworK2luc3RhbGxjaGVjay1hbToKKysKKyttYWludGFpbmVyLWNsZWFuOiBtYWludGFpbmVyLWNs
 ZWFuLWFtCisrCS1ybSAtcmYgLi8kKERFUERJUikKKysJLXJtIC1mIE1ha2VmaWxlCisrbWFpbnRh
 aW5lci1jbGVhbi1hbTogZGlzdGNsZWFuLWFtIG1haW50YWluZXItY2xlYW4tZ2VuZXJpYworKwor
 K21vc3RseWNsZWFuOiBtb3N0bHljbGVhbi1hbQorKworK21vc3RseWNsZWFuLWFtOiBtb3N0bHlj
 bGVhbi1jb21waWxlIG1vc3RseWNsZWFuLWdlbmVyaWMgXAorKwltb3N0bHljbGVhbi1saWJ0b29s
 CisrCisrcGRmOiBwZGYtYW0KKysKKytwZGYtYW06CisrCisrcHM6IHBzLWFtCisrCisrcHMtYW06
 CisrCisrdW5pbnN0YWxsLWFtOgorKworKy5NQUtFOiBpbnN0YWxsLWFtIGluc3RhbGwtc3RyaXAK
 KysKKysuUEhPTlk6IENUQUdTIEdUQUdTIGFsbCBhbGwtYW0gY2hlY2sgY2hlY2stYW0gY2xlYW4g
 Y2xlYW4tZ2VuZXJpYyBcCisrCWNsZWFuLWxpYnRvb2wgY2xlYW4tbm9pbnN0TFRMSUJSQVJJRVMg
 Y3RhZ3MgZGlzdGNsZWFuIFwKKysJZGlzdGNsZWFuLWNvbXBpbGUgZGlzdGNsZWFuLWdlbmVyaWMg
 ZGlzdGNsZWFuLWxpYnRvb2wgXAorKwlkaXN0Y2xlYW4tdGFncyBkaXN0ZGlyIGR2aSBkdmktYW0g
 aHRtbCBodG1sLWFtIGluZm8gaW5mby1hbSBcCisrCWluc3RhbGwgaW5zdGFsbC1hbSBpbnN0YWxs
 LWRhdGEgaW5zdGFsbC1kYXRhLWFtIGluc3RhbGwtZHZpIFwKKysJaW5zdGFsbC1kdmktYW0gaW5z
 dGFsbC1leGVjIGluc3RhbGwtZXhlYy1hbSBpbnN0YWxsLWh0bWwgXAorKwlpbnN0YWxsLWh0bWwt
 YW0gaW5zdGFsbC1pbmZvIGluc3RhbGwtaW5mby1hbSBpbnN0YWxsLW1hbiBcCisrCWluc3RhbGwt
 cGRmIGluc3RhbGwtcGRmLWFtIGluc3RhbGwtcHMgaW5zdGFsbC1wcy1hbSBcCisrCWluc3RhbGwt
 c3RyaXAgaW5zdGFsbGNoZWNrIGluc3RhbGxjaGVjay1hbSBpbnN0YWxsZGlycyBcCisrCW1haW50
 YWluZXItY2xlYW4gbWFpbnRhaW5lci1jbGVhbi1nZW5lcmljIG1vc3RseWNsZWFuIFwKKysJbW9z
 dGx5Y2xlYW4tY29tcGlsZSBtb3N0bHljbGVhbi1nZW5lcmljIG1vc3RseWNsZWFuLWxpYnRvb2wg
 XAorKwlwZGYgcGRmLWFtIHBzIHBzLWFtIHRhZ3MgdW5pbnN0YWxsIHVuaW5zdGFsbC1hbQorKwor
 KyMgVGVsbCB2ZXJzaW9ucyBbMy41OSwzLjYzKSBvZiBHTlUgbWFrZSB0byBub3QgZXhwb3J0IGFs
 bCB2YXJpYWJsZXMuCisrIyBPdGhlcndpc2UgYSBzeXN0ZW0gbGltaXQgKGZvciBTeXNWIGF0IGxl
 YXN0KSBtYXkgYmUgZXhjZWVkZWQuCisrLk5PRVhQT1JUOgpkaWZmIC0tZ2l0IGEvamF2YS9qYW12
 bS1pbml0aWFsL2ZpbGVzL3BhdGNoLXNyY19vc19ic2Rfc3BhcmM2NF9pbml0LmMgYi9qYXZhL2ph
 bXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtc3JjX29zX2JzZF9zcGFyYzY0X2luaXQuYwpuZXcgZmls
 ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wNzY5MTk0Ci0tLSAvZGV2L251bGwKKysrIGIv
 amF2YS9qYW12bS1pbml0aWFsL2ZpbGVzL3BhdGNoLXNyY19vc19ic2Rfc3BhcmM2NF9pbml0LmMK
 QEAgLTAsMCArMSwyOSBAQAorLS0tIHNyYy9vcy9ic2Qvc3BhcmM2NC9pbml0LmMub3JpZwkyMDEy
 LTAxLTI2IDE5OjMyOjQwLjAwMDAwMDAwMCArMDEwMAorKysrIHNyYy9vcy9ic2Qvc3BhcmM2NC9p
 bml0LmMJMjAxMi0wMS0yNiAxOTozMjo0MC4wMDAwMDAwMDAgKzAxMDAKK0BAIC0wLDAgKzEsMjYg
 QEAKKysvKgorKyAqIENvcHlyaWdodCAoQykgMjAwMywgMjAwNCwgMjAwNiwgMjAwNworKyAqIFJv
 YmVydCBMb3VnaGVyIDxyb2JAbG91Z2hlci5vcmcudWs+LgorKyAqCisrICogVGhpcyBmaWxlIGlz
 IHBhcnQgb2YgSmFtVk0uCisrICoKKysgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsg
 eW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisrICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0
 ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKysgKiBhcyBwdWJsaXNoZWQg
 YnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwKKysgKiBv
 ciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorKyAqCisrICogVGhpcyBwcm9n
 cmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisr
 ICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2Fy
 cmFudHkgb2YKKysgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS
 IFBVUlBPU0UuICBTZWUgdGhlCisrICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1v
 cmUgZGV0YWlscy4KKysgKgorKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2Yg
 dGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisrICogYWxvbmcgd2l0aCB0aGlzIHByb2dy
 YW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKysgKiBGb3VuZGF0aW9uLCA1
 MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVT
 QS4KKysgKi8KKysKKyt2b2lkIHNldERvdWJsZVByZWNpc2lvbigpIHsKKyt9CisrCisrdm9pZCBp
 bml0aWFsaXNlUGxhdGZvcm0oKSB7CisrfQpkaWZmIC0tZ2l0IGEvamF2YS9qYW12bS1pbml0aWFs
 L2ZpbGVzL3BhdGNoLXNyY190aHJlYWQuYyBiL2phdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRj
 aC1zcmNfdGhyZWFkLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNTE2ZTBm
 OQotLS0gL2Rldi9udWxsCisrKyBiL2phdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNf
 dGhyZWFkLmMKQEAgLTAsMCArMSwxMSBAQAorLS0tIHNyYy90aHJlYWQuYy5vcmlnCTIwMDgtMDIt
 MjIgMDI6NTg6NDMuMDAwMDAwMDAwICswMTAwCisrKysgc3JjL3RocmVhZC5jCTIwMTItMDEtMjYg
 MTk6MzI6NDAuMDAwMDAwMDAwICswMTAwCitAQCAtMjgzLDcgKzI4Myw3IEBAIHZvaWQgcmVzZXRQ
 ZWFrVGhyZWFkc0NvdW50KCkgeworIHZvaWQgaW5pdGlhbGlzZUphdmFTdGFjayhFeGVjRW52ICpl
 ZSkgeworICAgIGludCBzdGFja19zaXplID0gZWUtPnN0YWNrX3NpemUgPworICAgICAgICAgICAg
 KGVlLT5zdGFja19zaXplID4gTUlOX1NUQUNLID8gZWUtPnN0YWNrX3NpemUgOiBNSU5fU1RBQ0sp
 IDogZGZsdF9zdGFja19zaXplOworLSAgIGNoYXIgKnN0YWNrID0gc3lzTWFsbG9jKHN0YWNrX3Np
 emUpOworKyAgIHZvaWQgKnN0YWNrID0gc3lzTWFsbG9jKHN0YWNrX3NpemUpOworICAgIE1ldGhv
 ZEJsb2NrICptYiA9IChNZXRob2RCbG9jayAqKSBzdGFjazsKKyAgICBGcmFtZSAqdG9wID0gKEZy
 YW1lICopIChtYisxKTsKKyAKZGlmZiAtLWdpdCBhL2phdmEvamFtdm0taW5pdGlhbC9wa2ctZGVz
 Y3IgYi9qYXZhL2phbXZtLWluaXRpYWwvcGtnLWRlc2NyCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu
 ZGV4IDAwMDAwMDAuLjBmZmU0MTIKLS0tIC9kZXYvbnVsbAorKysgYi9qYXZhL2phbXZtLWluaXRp
 YWwvcGtnLWRlc2NyCkBAIC0wLDAgKzEsMTEgQEAKK1RoaXMgcGFja2FnZSBpcyBmb3IgYm9vdHN0
 cmFwcGluZyBjbGFzc3BhdGggPiAwLjkzIHdoaWNoIGNhbm5vdCBiZQorY29tcGlsZWQgd2l0aCBq
 aWtlcy4KKworSmFtVk0gaXMgYW4gZXh0cmVtZWx5IHNtYWxsIEphdmEgVmlydHVhbCBNYWNoaW5l
 IHdoaWNoIGNvbmZvcm1zIHRvIHRoZQorSlZNIHNwZWNpZmljYXRpb24gdmVyc2lvbiAyIChibHVl
 IGJvb2spLgorCitJdCBpcyBkZXNpZ25lZCB0byBzdXBwb3J0IHRoZSBmdWxsIHNwZWNpZmljYXRp
 b24sIGFuZCBpbmNsdWRlcyBzdXBwb3J0Citmb3Igb2JqZWN0IGZpbmFsaXNhdGlvbiwgU29mdC9X
 ZWFrL1BoYW50b20gUmVmZXJlbmNlcywgY2xhc3MtdW5sb2FkaW5nLAordGhlIEphdmEgTmF0aXZl
 IEludGVyZmFjZSAoSk5JKSBhbmQgdGhlIFJlZmxlY3Rpb24gQVBJLgorCitXV1c6IGh0dHA6Ly9q
 YW12bS5zb3VyY2Vmb3JnZS5uZXQvCmRpZmYgLS1naXQgYS9qYXZhL2phbXZtLWluaXRpYWwvcGtn
 LXBsaXN0IGIvamF2YS9qYW12bS1pbml0aWFsL3BrZy1wbGlzdApuZXcgZmlsZSBtb2RlIDEwMDY0
 NAppbmRleCAwMDAwMDAwLi40MWEwODYwCi0tLSAvZGV2L251bGwKKysrIGIvamF2YS9qYW12bS1p
 bml0aWFsL3BrZy1wbGlzdApAQCAtMCwwICsxLDMgQEAKK2Jpbi9qYW12bS1pbml0aWFsCitzaGFy
 ZS9qYW12bS1pbml0aWFsL2NsYXNzZXMuemlwCitAZGlycm0gc2hhcmUvamFtdm0taW5pdGlhbApk
 aWZmIC0tZ2l0IGEvamF2YS9qYW12bS9NYWtlZmlsZSBiL2phdmEvamFtdm0vTWFrZWZpbGUKaW5k
 ZXggMWE3ZjM3Ni4uZTQxZDhkYSAxMDA2NDQKLS0tIGEvamF2YS9qYW12bS9NYWtlZmlsZQorKysg
 Yi9qYXZhL2phbXZtL01ha2VmaWxlCkBAIC01LDcgKzUsNyBAQAogIyAkRnJlZUJTRDogcG9ydHMv
 amF2YS9qYW12bS9NYWtlZmlsZSx2IDEuOCAyMDExLzA5LzIzIDIyOjIzOjQwIGFtZG1pMyBFeHAg
 JAogCiBQT1JUTkFNRT0JamFtdm0KLVBPUlRWRVJTSU9OPQkxLjUuMQorUE9SVFZFUlNJT049CTEu
 NS40CiBQT1JUUkVWSVNJT049CTQKIENBVEVHT1JJRVM9CWphdmEgZGV2ZWwKIE1BU1RFUl9TSVRF
 Uz0JU0YvJHtQT1JUTkFNRX0vJHtQT1JUTkFNRX0vSmFtVk0lMjAke1BPUlRWRVJTSU9OfQpAQCAt
 MTksOCArMTksMTYgQEAgR05VX0NPTkZJR1VSRT0JeWVzCiBDT05GSUdVUkVfQVJHUz0JLS13aXRo
 LWNsYXNzcGF0aC1pbnN0YWxsLWRpcj0ke0xPQ0FMQkFTRX0KIFVTRV9HTUFLRT0JeWVzCiAKLU9Q
 VElPTlM9CUZGSSAidXNlIGxpYmZmaSB0byBjYWxsIG5hdGl2ZSBtZXRob2RzIiBPTiBcCi0JCVpJ
 UCAidHVybi1vbiB6aXAgc3VwcG9ydCBpbiB0aGUgYm9vdHN0cmFwIGxvYWRlciIgT04KK09QVElP
 TlM9CVpJUCAidHVybi1vbiB6aXAgc3VwcG9ydCBpbiB0aGUgYm9vdHN0cmFwIGxvYWRlciIgT04K
 KworLmluY2x1ZGUgPGJzZC5wb3J0Lm9wdGlvbnMubWs+CisKKyMgc3BhcmM2NCBhbHdheXMgbmVl
 ZHMgbGliZmZpCisuaWYgKCR7QVJDSH0gPT0gc3BhcmM2NCkKK1dJVEhfRkZJPQkxCisuZWxzZQor
 T1BUSU9OUys9CUZGSSAidXNlIGxpYmZmaSB0byBjYWxsIG5hdGl2ZSBtZXRob2RzIiBPTgorLmVu
 ZGlmCiAKIC5pbmNsdWRlIDxic2QucG9ydC5wcmUubWs+CiAKQEAgLTM5LDE1ICs0Nyw3IEBAIENP
 TkZJR1VSRV9BUkdTKz0JLS1kaXNhYmxlLXppcAogUExJU1RfU1VCKz0JCVdJVEhfWklQPSJAY29t
 bWVudCAiIFdJVEhPVVRfWklQPSIiCiAuZW5kaWYKIAotLmlmICR7QVJDSH0gPT0gInNwYXJjNjQi
 Ci1CUk9LRU49CQlEb2VzIG5vdCBjb25maWd1cmUgb24gc3BhcmM2NAotLmVuZGlmCi0KIHBvc3Qt
 ZXh0cmFjdDoKLQlAJHtNVn0gJHtXUktTUkN9L3NyYy9hcmNoL3g4Nl82NC5oICR7V1JLU1JDfS9z
 cmMvYXJjaC9hbWQ2NC5oCiAJQCR7UkVJTlBMQUNFX0NNRH0gLWUgInMsXCheaW5jbHVkZV9IRUFE
 RVJTID0gLipcKWpuaS5oXCguKlwpLFwxXDIsIiAke1dSS1NSQ30vc3JjL01ha2VmaWxlLmluCiAK
 LXBvc3QtY29uZmlndXJlOgotCUAke01WfSAke1dSS1NSQ30vc3JjL29zL2JzZC94ODZfNjQgJHtX
 UktTUkN9L3NyYy9vcy9ic2QvYW1kNjQKLQogLmluY2x1ZGUgPGJzZC5wb3J0LnBvc3QubWs+CmRp
 ZmYgLS1naXQgYS9qYXZhL2phbXZtL2Rpc3RpbmZvIGIvamF2YS9qYW12bS9kaXN0aW5mbwppbmRl
 eCAyYjU5YjQ1Li40MTBmYWNmIDEwMDY0NAotLS0gYS9qYXZhL2phbXZtL2Rpc3RpbmZvCisrKyBi
 L2phdmEvamFtdm0vZGlzdGluZm8KQEAgLTEsMiArMSwyIEBACi1TSEEyNTYgKGphbXZtLTEuNS4x
 LnRhci5neikgPSA2NjM4OTViZDY5Y2FmM2ExZmRhNmFmNWVlYTgyNjNkOTBhNWZkMzVjYThmNGMz
 MmUyMjEwYWM0MTA3ODg5MDFhCi1TSVpFIChqYW12bS0xLjUuMS50YXIuZ3opID0gNTk5MDg0CitT
 SEEyNTYgKGphbXZtLTEuNS40LnRhci5neikgPSA3ODY1NjkzNjk4YmM0MzIyY2FiZTEwMTRhNGI3
 ZWJkZWMxYmMxZGFmNDVmMWE0NDU3YjZlOTA4YTQ0NDZiMTI0CitTSVpFIChqYW12bS0xLjUuNC50
 YXIuZ3opID0gNjU2MjgzCmRpZmYgLS1naXQgYS9qYXZhL2phbXZtL2ZpbGVzL3BhdGNoLWNvbmZp
 Z3VyZSBiL2phdmEvamFtdm0vZmlsZXMvcGF0Y2gtY29uZmlndXJlCm5ldyBmaWxlIG1vZGUgMTAw
 NjQ0CmluZGV4IDAwMDAwMDAuLjRiMzk3MTMKLS0tIC9kZXYvbnVsbAorKysgYi9qYXZhL2phbXZt
 L2ZpbGVzL3BhdGNoLWNvbmZpZ3VyZQpAQCAtMCwwICsxLDExIEBACistLS0gY29uZmlndXJlLm9y
 aWcJMjAxMi0wMS0yNyAxMzo1NTo0OS4wMDAwMDAwMDAgKzAxMDAKKysrKyBjb25maWd1cmUJMjAx
 Mi0wMS0yNyAxMzo1Njo0My4wMDAwMDAwMDAgKzAxMDAKK0BAIC0yNjg5LDcgKzI2ODksNyBAQCB4
 ODZfNjQtKi1saW51eCopIGhvc3Rfb3M9bGludXggOzsKKyBocHBhKi0qLWxpbnV4KikgaG9zdF9j
 cHU9cGFyaXNjIGhvc3Rfb3M9bGludXggOzsKKyBtaXBzZWwtKi1saW51eCopIGhvc3RfY3B1PW1p
 cHMgaG9zdF9vcz1saW51eCA7OworIHg4Nl82NC0qLW9wZW5ic2QqKSBob3N0X29zPWJzZCBsaWJk
 bF9uZWVkZWQ9bm8gOzsKKy14ODZfNjQtKi1mcmVlYnNkKikgaG9zdF9vcz1ic2QgbGliZGxfbmVl
 ZGVkPW5vIDs7CisrYW1kNjQtKi1mcmVlYnNkKikgaG9zdF9vcz1ic2QgaG9zdF9jcHU9eDg2XzY0
 IGxpYmRsX25lZWRlZD1ubyA7OworIGFybSotKi1saW51eCopIGhvc3RfY3B1PWFybSBob3N0X29z
 PWxpbnV4IDs7CisgYXJtKi0qLW9wZW5ic2QqKSBob3N0X2NwdT1hcm0gaG9zdF9vcz1ic2QgbGli
 ZGxfbmVlZGVkPW5vIDs7CisgYXJtKi0qLWZyZWVic2QqKSBob3N0X2NwdT1hcm0gaG9zdF9vcz1i
 c2QgbGliZGxfbmVlZGVkPW5vIDs7Cg==
 --20cf303b3af1a58c4104b8f1775a--
State-Changed-From-To: open->feedback 
State-Changed-By: linimon 
State-Changed-When: Fri Feb 17 04:29:25 UTC 2012 
State-Changed-Why:  
Attempt to notify maintainer of both java/jamvm and java/classpath 
about the proposed changes to those 2 ports.  After approval, we 
need to do the new ports, perhaps separately. 

http://www.freebsd.org/cgi/query-pr.cgi?pr=164941 

From: =?ISO-8859-15?Q?Bj=F6rn_K=F6nig?= <bkoenig@alpha-tierchen.de>
To: bug-followup@FreeBSD.org, skrabban@gmail.com
Cc:  
Subject: Re: ports/164941: [UPDATE] [NEW PORTS] jamvm/classpath w/o jdk
Date: Thu, 01 Mar 2012 07:29:00 +0100

 This is a cryptographically signed message in MIME format.
 
 --------------ms080700020908080804000609
 Content-Type: text/plain; charset=ISO-8859-15; format=flowed
 Content-Transfer-Encoding: quoted-printable
 
 Due to private affairs I can't maintain the ports at the moment. Since I =
 
 don't want to block updates and improvements I would like to pass the=20
 maintainership of all ports that are involved.
 
 
 --------------ms080700020908080804000609
 Content-Type: application/pkcs7-signature; name="smime.p7s"
 Content-Transfer-Encoding: base64
 Content-Disposition: attachment; filename="smime.p7s"
 Content-Description: S/MIME Cryptographic Signature
 
 MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEHAQAAoIIUkjCC
 BjQwggQcoAMCAQICAR4wDQYJKoZIhvcNAQEFBQAwfTELMAkGA1UEBhMCSUwxFjAUBgNVBAoT
 DVN0YXJ0Q29tIEx0ZC4xKzApBgNVBAsTIlNlY3VyZSBEaWdpdGFsIENlcnRpZmljYXRlIFNp
 Z25pbmcxKTAnBgNVBAMTIFN0YXJ0Q29tIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA3
 MTAyNDIxMDE1NVoXDTE3MTAyNDIxMDE1NVowgYwxCzAJBgNVBAYTAklMMRYwFAYDVQQKEw1T
 dGFydENvbSBMdGQuMSswKQYDVQQLEyJTZWN1cmUgRGlnaXRhbCBDZXJ0aWZpY2F0ZSBTaWdu
 aW5nMTgwNgYDVQQDEy9TdGFydENvbSBDbGFzcyAxIFByaW1hcnkgSW50ZXJtZWRpYXRlIENs
 aWVudCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMcJg8zOLdgasSmkLhOr
 lr6KMoOMpohBllVHrdRvEg/q6r8jR+EK75xCGhR8ToREoqe7zM9/UnC6TS2y9UKTpT1v7RSM
 zR0t6ndl0TWBuUr/UXBhPk+Kmy7bI4yW4urC+y7P3/1/X7U8ocb8VpH/Clt+4iq7nirMcNh6
 qJR+xjOhV+VHzQMALuGYn5KZmc1NbJQYclsGkDxDz2UbFqE2+6vIZoL+jb9x4Pa5gNf1TwSD
 kOkikZB1xtB4ZqtXThaABSONdfmv/Z1pua3FYxnCFmdr/+N2JLKutIxMYqQOJebr/f/h5t95
 m4JgrM3Y/w7YX9d7YAL9jvN4SydHsU6n65cCAwEAAaOCAa0wggGpMA8GA1UdEwEB/wQFMAMB
 Af8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRTcu2SnODaywFcfH6WNU7y1LhRgjAfBgNV
 HSMEGDAWgBROC+8apEBbpRdphzDKNGhD0EGu8jBmBggrBgEFBQcBAQRaMFgwJwYIKwYBBQUH
 MAGGG2h0dHA6Ly9vY3NwLnN0YXJ0c3NsLmNvbS9jYTAtBggrBgEFBQcwAoYhaHR0cDovL3d3
 dy5zdGFydHNzbC5jb20vc2ZzY2EuY3J0MFsGA1UdHwRUMFIwJ6AloCOGIWh0dHA6Ly93d3cu
 c3RhcnRzc2wuY29tL3Nmc2NhLmNybDAnoCWgI4YhaHR0cDovL2NybC5zdGFydHNzbC5jb20v
 c2ZzY2EuY3JsMIGABgNVHSAEeTB3MHUGCysGAQQBgbU3AQIBMGYwLgYIKwYBBQUHAgEWImh0
 dHA6Ly93d3cuc3RhcnRzc2wuY29tL3BvbGljeS5wZGYwNAYIKwYBBQUHAgEWKGh0dHA6Ly93
 d3cuc3RhcnRzc2wuY29tL2ludGVybWVkaWF0ZS5wZGYwDQYJKoZIhvcNAQEFBQADggIBAAqD
 CH14qywGXLhjjF6uHLkjd02hcdh9hrw+VUsv+q1eeQWB21jWj3kJ96AUlPCoEGZ/ynJNScWy
 6QMVQjbbMXltUfO4n4bGGdKo3awPWp61tjAFgraLJgDk+DsSvUD6EowjMTNx25GQgyYJ5RPI
 zKKR9tQW8gGK+2+RHxkUCTbYFnL6kl8Ch507rUdPPipJ9CgJFws3kDS3gOS5WFMxcjO5DwKf
 KSETEPrHh7p5shuuNktvsv6hxHTLhiMKX893gxdT3XLS9OKmCv87vkINQcNEcIIoFWbP9HOR
 z9v3vQwR4e3ksLc2JZOAFK+ssS5XMEoznzpihEP0PLc4dCBYjbvSD7kxgDwZ+Aj8Q9PkbvE9
 sIPP7ON0fz095HdThKjiVJe6vofq+n6b1NBc8XdrQvBmunwxD5nvtTW4vtN6VY7mUCmxsCie
 uoBJ9OlqmsVWQvifIYf40dJPZkk9YgGTzWLpXDSfLSplbY2LL9C9U0ptvjcDjefLTvqSFc7t
 w1sEhF0n/qpA2r0GpvkLRDmcSwVyPvmjFBGqUp/pNy8ZuPGQmHwFi2/14+xeSUDG2bwnsYJQ
 G2EdJCB6luQ57GEnTA/yKZSTKI8dDQa8Sd3zfXb19mOgSF0bBdXbuKhEpuP9wirslFe6fQ1t
 5j5R0xi72MZ8ikMu1RQZKCyDbMwazlHiMIIHKTCCBhGgAwIBAgIDA5AwMA0GCSqGSIb3DQEB
 BQUAMIGMMQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMi
 U2VjdXJlIERpZ2l0YWwgQ2VydGlmaWNhdGUgU2lnbmluZzE4MDYGA1UEAxMvU3RhcnRDb20g
 Q2xhc3MgMSBQcmltYXJ5IEludGVybWVkaWF0ZSBDbGllbnQgQ0EwHhcNMTIwMTE5MDY0MjAw
 WhcNMTMwMTE4MTkwOTA4WjBpMRkwFwYDVQQNExAxVTZ5MzVJT0FFVWY1Z3pEMSIwIAYDVQQD
 DBlia29lbmlnQGFscGhhLXRpZXJjaGVuLmRlMSgwJgYJKoZIhvcNAQkBFhlia29lbmlnQGFs
 cGhhLXRpZXJjaGVuLmRlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA12dR+gfg
 IPOzXzNWD5ZiFqYGDXlDlNShMjLngNUEXANtUFPjKsfO1jriK0j/zt11UkCs4xPj62klb/WN
 wV3IHp5mpgUr7RmJydHdaF/f161csWj09hTOy/hVzyOZNoSqcTiXwgP5rGUM5Auoop5devur
 qwsoAOZsW5dEyifM657b/H5g7p4HAC0k9YosGyjAs75SuygfvdVFRoO3hFVXFZiiMoGWkao8
 rZPeyqEziHvCdHgeojRBEiqwHkKOpbVWACDGVi6RIM1LfSufrplbf4n0dFc8QTSfP28TDUKk
 L1ruLUSJe5uaLBvCQtk+2FMT4VFcAGE1hsBLFonLBxKy9QIDAQABo4IDtDCCA7AwCQYDVR0T
 BAIwADALBgNVHQ8EBAMCBLAwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMEMB0GA1Ud
 DgQWBBQWSHYvmKVD9OZUaXeD6wqrzR4xIjAfBgNVHSMEGDAWgBRTcu2SnODaywFcfH6WNU7y
 1LhRgjAkBgNVHREEHTAbgRlia29lbmlnQGFscGhhLXRpZXJjaGVuLmRlMIICIQYDVR0gBIIC
 GDCCAhQwggIQBgsrBgEEAYG1NwECAjCCAf8wLgYIKwYBBQUHAgEWImh0dHA6Ly93d3cuc3Rh
 cnRzc2wuY29tL3BvbGljeS5wZGYwNAYIKwYBBQUHAgEWKGh0dHA6Ly93d3cuc3RhcnRzc2wu
 Y29tL2ludGVybWVkaWF0ZS5wZGYwgfcGCCsGAQUFBwICMIHqMCcWIFN0YXJ0Q29tIENlcnRp
 ZmljYXRpb24gQXV0aG9yaXR5MAMCAQEagb5UaGlzIGNlcnRpZmljYXRlIHdhcyBpc3N1ZWQg
 YWNjb3JkaW5nIHRvIHRoZSBDbGFzcyAxIFZhbGlkYXRpb24gcmVxdWlyZW1lbnRzIG9mIHRo
 ZSBTdGFydENvbSBDQSBwb2xpY3ksIHJlbGlhbmNlIG9ubHkgZm9yIHRoZSBpbnRlbmRlZCBw
 dXJwb3NlIGluIGNvbXBsaWFuY2Ugb2YgdGhlIHJlbHlpbmcgcGFydHkgb2JsaWdhdGlvbnMu
 MIGcBggrBgEFBQcCAjCBjzAnFiBTdGFydENvbSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAD
 AgECGmRMaWFiaWxpdHkgYW5kIHdhcnJhbnRpZXMgYXJlIGxpbWl0ZWQhIFNlZSBzZWN0aW9u
 ICJMZWdhbCBhbmQgTGltaXRhdGlvbnMiIG9mIHRoZSBTdGFydENvbSBDQSBwb2xpY3kuMDYG
 A1UdHwQvMC0wK6ApoCeGJWh0dHA6Ly9jcmwuc3RhcnRzc2wuY29tL2NydHUxLWNybC5jcmww
 gY4GCCsGAQUFBwEBBIGBMH8wOQYIKwYBBQUHMAGGLWh0dHA6Ly9vY3NwLnN0YXJ0c3NsLmNv
 bS9zdWIvY2xhc3MxL2NsaWVudC9jYTBCBggrBgEFBQcwAoY2aHR0cDovL2FpYS5zdGFydHNz
 bC5jb20vY2VydHMvc3ViLmNsYXNzMS5jbGllbnQuY2EuY3J0MCMGA1UdEgQcMBqGGGh0dHA6
 Ly93d3cuc3RhcnRzc2wuY29tLzANBgkqhkiG9w0BAQUFAAOCAQEAr10J6KKp+r/p06hxF87/
 58OCcv71yREYQBfhDxB78LE1MVO1xNjWdH/Dh+QtigGuEEOWUsJ1HbKQU8aC3L4nT8eFeVlv
 vNAjXMS5EsDAqG3YG3H9Gqgr8rx8OcJE4tMcDTGXICVOKcV/3k/7j+iRX2iE9+dwj5WSWbPm
 Vn8pZ262x2ix3YRgUIfEOWk7rBIx4xh5kYB3qMbfo3p2laNcqqi6cMM8cp7JhVhr2tWIY+Ez
 O2f1YBLXmOsPEKCRavZuf1YiJIShMa1SqGshnpqnLl5QG3O0NNDEQj22XrQce3g17P7pp4MQ
 KA274LI5D/ZXJbws3AVn/4RNNnmw1To09DCCBykwggYRoAMCAQICAwOQMDANBgkqhkiG9w0B
 AQUFADCBjDELMAkGA1UEBhMCSUwxFjAUBgNVBAoTDVN0YXJ0Q29tIEx0ZC4xKzApBgNVBAsT
 IlNlY3VyZSBEaWdpdGFsIENlcnRpZmljYXRlIFNpZ25pbmcxODA2BgNVBAMTL1N0YXJ0Q29t
 IENsYXNzIDEgUHJpbWFyeSBJbnRlcm1lZGlhdGUgQ2xpZW50IENBMB4XDTEyMDExOTA2NDIw
 MFoXDTEzMDExODE5MDkwOFowaTEZMBcGA1UEDRMQMVU2eTM1SU9BRVVmNWd6RDEiMCAGA1UE
 AwwZYmtvZW5pZ0BhbHBoYS10aWVyY2hlbi5kZTEoMCYGCSqGSIb3DQEJARYZYmtvZW5pZ0Bh
 bHBoYS10aWVyY2hlbi5kZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANdnUfoH
 4CDzs18zVg+WYhamBg15Q5TUoTIy54DVBFwDbVBT4yrHztY64itI/87ddVJArOMT4+tpJW/1
 jcFdyB6eZqYFK+0ZicnR3Whf39etXLFo9PYUzsv4Vc8jmTaEqnE4l8ID+axlDOQLqKKeXXr7
 q6sLKADmbFuXRMonzOue2/x+YO6eBwAtJPWKLBsowLO+UrsoH73VRUaDt4RVVxWYojKBlpGq
 PK2T3sqhM4h7wnR4HqI0QRIqsB5CjqW1VgAgxlYukSDNS30rn66ZW3+J9HRXPEE0nz9vEw1C
 pC9a7i1EiXubmiwbwkLZPthTE+FRXABhNYbASxaJywcSsvUCAwEAAaOCA7QwggOwMAkGA1Ud
 EwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDBDAdBgNV
 HQ4EFgQUFkh2L5ilQ/TmVGl3g+sKq80eMSIwHwYDVR0jBBgwFoAUU3Ltkpzg2ssBXHx+ljVO
 8tS4UYIwJAYDVR0RBB0wG4EZYmtvZW5pZ0BhbHBoYS10aWVyY2hlbi5kZTCCAiEGA1UdIASC
 AhgwggIUMIICEAYLKwYBBAGBtTcBAgIwggH/MC4GCCsGAQUFBwIBFiJodHRwOi8vd3d3LnN0
 YXJ0c3NsLmNvbS9wb2xpY3kucGRmMDQGCCsGAQUFBwIBFihodHRwOi8vd3d3LnN0YXJ0c3Ns
 LmNvbS9pbnRlcm1lZGlhdGUucGRmMIH3BggrBgEFBQcCAjCB6jAnFiBTdGFydENvbSBDZXJ0
 aWZpY2F0aW9uIEF1dGhvcml0eTADAgEBGoG+VGhpcyBjZXJ0aWZpY2F0ZSB3YXMgaXNzdWVk
 IGFjY29yZGluZyB0byB0aGUgQ2xhc3MgMSBWYWxpZGF0aW9uIHJlcXVpcmVtZW50cyBvZiB0
 aGUgU3RhcnRDb20gQ0EgcG9saWN5LCByZWxpYW5jZSBvbmx5IGZvciB0aGUgaW50ZW5kZWQg
 cHVycG9zZSBpbiBjb21wbGlhbmNlIG9mIHRoZSByZWx5aW5nIHBhcnR5IG9ibGlnYXRpb25z
 LjCBnAYIKwYBBQUHAgIwgY8wJxYgU3RhcnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkw
 AwIBAhpkTGlhYmlsaXR5IGFuZCB3YXJyYW50aWVzIGFyZSBsaW1pdGVkISBTZWUgc2VjdGlv
 biAiTGVnYWwgYW5kIExpbWl0YXRpb25zIiBvZiB0aGUgU3RhcnRDb20gQ0EgcG9saWN5LjA2
 BgNVHR8ELzAtMCugKaAnhiVodHRwOi8vY3JsLnN0YXJ0c3NsLmNvbS9jcnR1MS1jcmwuY3Js
 MIGOBggrBgEFBQcBAQSBgTB/MDkGCCsGAQUFBzABhi1odHRwOi8vb2NzcC5zdGFydHNzbC5j
 b20vc3ViL2NsYXNzMS9jbGllbnQvY2EwQgYIKwYBBQUHMAKGNmh0dHA6Ly9haWEuc3RhcnRz
 c2wuY29tL2NlcnRzL3N1Yi5jbGFzczEuY2xpZW50LmNhLmNydDAjBgNVHRIEHDAahhhodHRw
 Oi8vd3d3LnN0YXJ0c3NsLmNvbS8wDQYJKoZIhvcNAQEFBQADggEBAK9dCeiiqfq/6dOocRfO
 /+fDgnL+9ckRGEAX4Q8Qe/CxNTFTtcTY1nR/w4fkLYoBrhBDllLCdR2ykFPGgty+J0/HhXlZ
 b7zQI1zEuRLAwKht2Btx/RqoK/K8fDnCROLTHA0xlyAlTinFf95P+4/okV9ohPfncI+Vklmz
 5lZ/KWdutsdosd2EYFCHxDlpO6wSMeMYeZGAd6jG36N6dpWjXKqounDDPHKeyYVYa9rViGPh
 Mztn9WAS15jrDxCgkWr2bn9WIiSEoTGtUqhrIZ6apy5eUBtztDTQxEI9tl60HHt4Nez+6aeD
 ECgNu+CyOQ/2VyW8LNwFZ/+ETTZ5sNU6NPQxggPQMIIDzAIBATCBlDCBjDELMAkGA1UEBhMC
 SUwxFjAUBgNVBAoTDVN0YXJ0Q29tIEx0ZC4xKzApBgNVBAsTIlNlY3VyZSBEaWdpdGFsIENl
 cnRpZmljYXRlIFNpZ25pbmcxODA2BgNVBAMTL1N0YXJ0Q29tIENsYXNzIDEgUHJpbWFyeSBJ
 bnRlcm1lZGlhdGUgQ2xpZW50IENBAgMDkDAwCQYFKw4DAhoFAKCCAhAwGAYJKoZIhvcNAQkD
 MQsGCSqGSIb3DQEHATAcBgkqhkiG9w0BCQUxDxcNMTIwMzAxMDYyOTAwWjAjBgkqhkiG9w0B
 CQQxFgQUua0JP1qGgzl/2HJktEYNzjq1dnQwXwYJKoZIhvcNAQkPMVIwUDALBglghkgBZQME
 AQIwCgYIKoZIhvcNAwcwDgYIKoZIhvcNAwICAgCAMA0GCCqGSIb3DQMCAgFAMAcGBSsOAwIH
 MA0GCCqGSIb3DQMCAgEoMIGlBgkrBgEEAYI3EAQxgZcwgZQwgYwxCzAJBgNVBAYTAklMMRYw
 FAYDVQQKEw1TdGFydENvbSBMdGQuMSswKQYDVQQLEyJTZWN1cmUgRGlnaXRhbCBDZXJ0aWZp
 Y2F0ZSBTaWduaW5nMTgwNgYDVQQDEy9TdGFydENvbSBDbGFzcyAxIFByaW1hcnkgSW50ZXJt
 ZWRpYXRlIENsaWVudCBDQQIDA5AwMIGnBgsqhkiG9w0BCRACCzGBl6CBlDCBjDELMAkGA1UE
 BhMCSUwxFjAUBgNVBAoTDVN0YXJ0Q29tIEx0ZC4xKzApBgNVBAsTIlNlY3VyZSBEaWdpdGFs
 IENlcnRpZmljYXRlIFNpZ25pbmcxODA2BgNVBAMTL1N0YXJ0Q29tIENsYXNzIDEgUHJpbWFy
 eSBJbnRlcm1lZGlhdGUgQ2xpZW50IENBAgMDkDAwDQYJKoZIhvcNAQEBBQAEggEAwE/3Jlbs
 G+kg3QMIGOfM/ES1HuCcFE/8KclV/K8QjEKSmLNvmEsWbENSaFcKrUKirO7UADDSVL09LX7N
 7SSqoev7V4OorgqAwDfmXUQZFHd6tym/gKzvH3zj4xp6YLpq0Nbmv8qxu8ydYbnYhF+BPepi
 BENAXMm5YbkA/k9F1gv4P/S/aT1XS4Ky57UzkvRSSps0UzKaZEyFYDX+LbTGaT4YV8chacAd
 w0YrBRl22lfC6xEpjscPF8LAwmJOZGMPDaBzCrS+a5WmrLQqw1ftTWsoi84ow1xWp6QTGSeE
 fkKHYULWDoW33LmIC/o/w4P8IIKNM7uaWQKyjfGkj8GszAAAAAAAAA==
 --------------ms080700020908080804000609--

From: dfilter@FreeBSD.ORG (dfilter service)
To: bug-followup@FreeBSD.org
Cc:  
Subject: Re: ports/164941: commit references a PR
Date: Fri, 14 Sep 2012 22:02:25 +0000 (UTC)

 Author: jkim
 Date: Fri Sep 14 22:02:09 2012
 New Revision: 304300
 URL: http://svn.freebsd.org/changeset/ports/304300
 
 Log:
   - Update to 1.5.4.
   - Reset maintainer to java.
   - Convert to optionsNG and add license.
   - Unbreak sparc64.
   
   PR:	ports/164941 (partial)
 
 Added:
   head/java/jamvm/files/
   head/java/jamvm/files/patch-configure   (contents, props changed)
 Modified:
   head/java/jamvm/Makefile
   head/java/jamvm/distinfo
   head/java/jamvm/pkg-plist
 
 Modified: head/java/jamvm/Makefile
 ==============================================================================
 --- head/java/jamvm/Makefile	Fri Sep 14 21:56:20 2012	(r304299)
 +++ head/java/jamvm/Makefile	Fri Sep 14 22:02:09 2012	(r304300)
 @@ -5,33 +5,41 @@
  # $FreeBSD$
  
  PORTNAME=	jamvm
 -PORTVERSION=	1.5.1
 -PORTREVISION=	5
 +PORTVERSION=	1.5.4
  CATEGORIES=	java devel
  MASTER_SITES=	SF/${PORTNAME}/${PORTNAME}/JamVM%20${PORTVERSION}
  
 -MAINTAINER=	bkoenig@alpha-tierchen.de
 +MAINTAINER=	java@FreeBSD.org
  COMMENT=	A compact Java virtual machine
  
 +LICENSE=	GPLv2
 +
  RUN_DEPENDS=	${LOCALBASE}/share/classpath/glibj.zip:${PORTSDIR}/java/classpath
  
  GNU_CONFIGURE=	yes
  CONFIGURE_ARGS=	--with-classpath-install-dir=${LOCALBASE}
  USE_GMAKE=	yes
 +USE_PKGCONFIG=	build
  
 -OPTIONS=	FFI "use libffi to call native methods" ON \
 -		ZIP "turn-on zip support in the bootstrap loader" ON
 +OPTIONS_DEFINE=	FFI ZIP
 +OPTIONS_DEFAULT=FFI ZIP
 +FFI_DESC=	use libffi to call native methods
 +ZIP_DESC=	turn-on zip support in the bootstrap loader
  
 -.include <bsd.port.pre.mk>
 +.include <bsd.port.options.mk>
  
 -.if defined(WITH_FFI)
 +.if ${PORT_OPTIONS:MFFI}
  LIB_DEPENDS+=		ffi:${PORTSDIR}/devel/libffi
  CONFIGURE_ARGS+=	--enable-ffi
 -LDFLAGS+=	-L${LOCALBASE}/lib
 -CFLAGS+=	`pkg-config libffi --cflags`
 +FFI_CFLAGS!=	pkgconf libffi --cflags
 +FFI_LDFLAGS!=	pkgconf libffi --libs-only-L
 +CFLAGS+=	${FFI_CFLAGS}
 +LDFLAGS+=	${FFI_LDFLAGS}
 +.elif ${ARCH} == "sparc64"
 +IGNORE=		for ${ARCH} requires libffi
  .endif
  
 -.if defined(WITH_ZIP)
 +.if ${PORT_OPTIONS:MZIP}
  BUILD_DEPENDS+=		zip:${PORTSDIR}/archivers/zip
  PLIST_SUB+=		WITH_ZIP="" WITHOUT_ZIP="@comment "
  .else
 @@ -39,15 +47,9 @@ CONFIGURE_ARGS+=	--disable-zip
  PLIST_SUB+=		WITH_ZIP="@comment " WITHOUT_ZIP=""
  .endif
  
 -.if ${ARCH} == "sparc64"
 -BROKEN=		Does not configure on sparc64
 -.endif
 +.include <bsd.port.pre.mk>
  
  post-extract:
 -	@${MV} ${WRKSRC}/src/arch/x86_64.h ${WRKSRC}/src/arch/amd64.h
  	@${REINPLACE_CMD} -e "s,\(^include_HEADERS = .*\)jni.h\(.*\),\1\2," ${WRKSRC}/src/Makefile.in
  
 -post-configure:
 -	@${MV} ${WRKSRC}/src/os/bsd/x86_64 ${WRKSRC}/src/os/bsd/amd64
 -
  .include <bsd.port.post.mk>
 
 Modified: head/java/jamvm/distinfo
 ==============================================================================
 --- head/java/jamvm/distinfo	Fri Sep 14 21:56:20 2012	(r304299)
 +++ head/java/jamvm/distinfo	Fri Sep 14 22:02:09 2012	(r304300)
 @@ -1,2 +1,2 @@
 -SHA256 (jamvm-1.5.1.tar.gz) = 663895bd69caf3a1fda6af5eea8263d90a5fd35ca8f4c32e2210ac410788901a
 -SIZE (jamvm-1.5.1.tar.gz) = 599084
 +SHA256 (jamvm-1.5.4.tar.gz) = 7865693698bc4322cabe1014a4b7ebdec1bc1daf45f1a4457b6e908a4446b124
 +SIZE (jamvm-1.5.4.tar.gz) = 656283
 
 Added: head/java/jamvm/files/patch-configure
 ==============================================================================
 --- /dev/null	00:00:00 1970	(empty, because file is newly added)
 +++ head/java/jamvm/files/patch-configure	Fri Sep 14 22:02:09 2012	(r304300)
 @@ -0,0 +1,11 @@
 +--- configure.orig	2009-12-31 13:41:44.000000000 -0500
 ++++ configure	2012-09-12 20:07:36.000000000 -0400
 +@@ -2689,7 +2689,7 @@
 + hppa*-*-linux*) host_cpu=parisc host_os=linux ;;
 + mipsel-*-linux*) host_cpu=mips host_os=linux ;;
 + x86_64-*-openbsd*) host_os=bsd libdl_needed=no ;;
 +-x86_64-*-freebsd*) host_os=bsd libdl_needed=no ;;
 ++amd64-*-freebsd*) host_os=bsd host_cpu=x86_64 libdl_needed=no ;;
 + arm*-*-linux*) host_cpu=arm host_os=linux ;;
 + arm*-*-openbsd*) host_cpu=arm host_os=bsd libdl_needed=no ;;
 + arm*-*-freebsd*) host_cpu=arm host_os=bsd libdl_needed=no ;;
 
 Modified: head/java/jamvm/pkg-plist
 ==============================================================================
 --- head/java/jamvm/pkg-plist	Fri Sep 14 21:56:20 2012	(r304299)
 +++ head/java/jamvm/pkg-plist	Fri Sep 14 22:02:09 2012	(r304300)
 @@ -2,33 +2,36 @@ bin/jamvm
  lib/libjvm.la
  lib/libjvm.a
  %%WITH_ZIP%%lib/rt.jar
 -%%WITH_ZIP%%share/jamvm/classes.zip
 -%%WITHOUT_ZIP%%share/jamvm/classes/jamvm/java/lang/VMClassLoaderData.class
 -%%WITHOUT_ZIP%%share/jamvm/classes/jamvm/java/lang/JarLauncher.class
 -%%WITHOUT_ZIP%%share/jamvm/classes/jamvm/java/lang/VMClassLoaderData$Unloader.class
 -%%WITHOUT_ZIP%%share/jamvm/classes/sun/reflect/annotation/AnnotationInvocationHandler.class
 -%%WITHOUT_ZIP%%share/jamvm/classes/java/security/VMAccessController.class
 -%%WITHOUT_ZIP%%share/jamvm/classes/java/lang/reflect/Field.class
 -%%WITHOUT_ZIP%%share/jamvm/classes/java/lang/reflect/Constructor.class
 -%%WITHOUT_ZIP%%share/jamvm/classes/java/lang/reflect/Method.class
 -%%WITHOUT_ZIP%%share/jamvm/classes/java/lang/VMClassLoader.class
 -%%WITHOUT_ZIP%%share/jamvm/classes/java/lang/VMThrowable.class
 -%%WITHOUT_ZIP%%share/jamvm/classes/java/lang/VMString.class
 -%%WITHOUT_ZIP%%share/jamvm/classes/java/lang/VMThread.class
 -%%WITHOUT_ZIP%%share/jamvm/classes/java/lang/VMRuntime.class
 -%%WITHOUT_ZIP%%share/jamvm/classes/gnu/classpath/VMSystemProperties.class
 -%%WITHOUT_ZIP%%share/jamvm/classes/gnu/classpath/VMStackWalker.class
 -%%WITHOUT_ZIP%%@dirrm share/jamvm/classes/gnu/classpath
 -%%WITHOUT_ZIP%%@dirrm share/jamvm/classes/gnu
 -%%WITHOUT_ZIP%%@dirrm share/jamvm/classes/java/lang/reflect
 -%%WITHOUT_ZIP%%@dirrm share/jamvm/classes/java/lang
 -%%WITHOUT_ZIP%%@dirrm share/jamvm/classes/java/security
 -%%WITHOUT_ZIP%%@dirrm share/jamvm/classes/java
 -%%WITHOUT_ZIP%%@dirrm share/jamvm/classes/sun/reflect/annotation
 -%%WITHOUT_ZIP%%@dirrm share/jamvm/classes/sun/reflect
 -%%WITHOUT_ZIP%%@dirrm share/jamvm/classes/sun
 -%%WITHOUT_ZIP%%@dirrm share/jamvm/classes/jamvm/java/lang
 -%%WITHOUT_ZIP%%@dirrm share/jamvm/classes/jamvm/java
 -%%WITHOUT_ZIP%%@dirrm share/jamvm/classes/jamvm
 -%%WITHOUT_ZIP%%@dirrm share/jamvm/classes
 -@dirrm share/jamvm
 +%%WITH_ZIP%%%%DATADIR%%/classes.zip
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/gnu/classpath/VMStackWalker.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/gnu/classpath/VMSystemProperties.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/jamvm/ThreadInfoHelper.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/jamvm/java/lang/JarLauncher.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/jamvm/java/lang/VMClassLoaderData$Unloader.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/jamvm/java/lang/VMClassLoaderData.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/java/lang/VMClass.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/java/lang/VMClassLoader$PackageInfo.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/java/lang/VMClassLoader.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/java/lang/VMRuntime.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/java/lang/VMString.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/java/lang/VMThread.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/java/lang/VMThrowable.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/java/lang/reflect/VMConstructor.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/java/lang/reflect/VMField.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/java/lang/reflect/VMMethod.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/java/security/VMAccessController.class
 +%%WITHOUT_ZIP%%%%DATADIR%%/classes/sun/reflect/annotation/AnnotationInvocationHandler.class
 +%%WITHOUT_ZIP%%@dirrm %%DATADIR%%/classes/gnu/classpath
 +%%WITHOUT_ZIP%%@dirrm %%DATADIR%%/classes/gnu
 +%%WITHOUT_ZIP%%@dirrm %%DATADIR%%/classes/java/lang/reflect
 +%%WITHOUT_ZIP%%@dirrm %%DATADIR%%/classes/java/lang
 +%%WITHOUT_ZIP%%@dirrm %%DATADIR%%/classes/java/security
 +%%WITHOUT_ZIP%%@dirrm %%DATADIR%%/classes/java
 +%%WITHOUT_ZIP%%@dirrm %%DATADIR%%/classes/sun/reflect/annotation
 +%%WITHOUT_ZIP%%@dirrm %%DATADIR%%/classes/sun/reflect
 +%%WITHOUT_ZIP%%@dirrm %%DATADIR%%/classes/sun
 +%%WITHOUT_ZIP%%@dirrm %%DATADIR%%/classes/jamvm/java/lang
 +%%WITHOUT_ZIP%%@dirrm %%DATADIR%%/classes/jamvm/java
 +%%WITHOUT_ZIP%%@dirrm %%DATADIR%%/classes/jamvm
 +%%WITHOUT_ZIP%%@dirrm %%DATADIR%%/classes
 +@dirrm %%DATADIR%%
 _______________________________________________
 svn-ports-all@freebsd.org mailing list
 http://lists.freebsd.org/mailman/listinfo/svn-ports-all
 To unsubscribe, send any mail to "svn-ports-all-unsubscribe@freebsd.org"
 
State-Changed-From-To: feedback->open 
State-Changed-By: linimon 
State-Changed-When: Sun Jan 20 00:28:08 UTC 2013 
State-Changed-Why:  
The changes to java/jamvm have been committed, but AFAICT no one has 
looked at the classpath changes yet. 


Responsible-Changed-From-To: freebsd-ports-bugs->freebsd-java 
Responsible-Changed-By: linimon 
Responsible-Changed-When: Sun Jan 20 00:28:08 UTC 2013 
Responsible-Changed-Why:  

http://www.freebsd.org/cgi/query-pr.cgi?pr=164941 

From: Per Ola Ingvarsson <skrabban@gmail.com>
To: bug-followup@FreeBSD.org
Cc:  
Subject: Re: ports/164941: [UPDATE] [NEW PORTS] java/classpath-initial,
 including rework of java/classpath
Date: Tue, 19 Feb 2013 22:30:09 +0100

 --bcaec554d84ccfbbd504d61a8b2e
 Content-Type: multipart/alternative; boundary=bcaec554d84ccfbbc004d61a8b2c
 
 --bcaec554d84ccfbbc004d61a8b2c
 Content-Type: text/plain; charset=ISO-8859-1
 
 New patch which works on recent head.
 
 Builds on:
 9.1-RELEASE/amd64
 9.1-RELEASE/i386
 8.2-RELEASE/amd64
 8.2-RELEASE/i386
 8.1-RELEASE/sparc64
 
 All jdk and gjc dependecies have been removed and the build process is the
 same for all archs.
 
 --bcaec554d84ccfbbc004d61a8b2c
 Content-Type: text/html; charset=ISO-8859-1
 
 <div dir="ltr"><div><div><div><div><div><div>New patch which works on recent head.<br><br></div>Builds on:<br>9.1-RELEASE/amd64<br>9.1-RELEASE/i386<br></div>8.2-RELEASE/amd64<br></div>8.2-RELEASE/i386<br></div>8.1-RELEASE/sparc64<br>
 <br></div>All jdk and gjc dependecies have been removed and the build process is the same for all archs.<br><br></div><div><br></div><div><br><br><br><br><br></div></div>
 
 --bcaec554d84ccfbbc004d61a8b2c--
 --bcaec554d84ccfbbd504d61a8b2e
 Content-Type: application/octet-stream; name="classpath_jamvm.patch2"
 Content-Disposition: attachment; filename="classpath_jamvm.patch2"
 Content-Transfer-Encoding: base64
 X-Attachment-Id: f_hddk24g30
 
 SW5kZXg6IGphdmEvTWFrZWZpbGUKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gamF2YS9NYWtlZmlsZQkocmV2aXNp
 b24gMzExMjU2KQorKysgamF2YS9NYWtlZmlsZQkoYXJiZXRza29waWEpCkBAIC0xMSw2ICsxMSw3
 IEBACiAgICAgU1VCRElSICs9IGNhY2FvCiAgICAgU1VCRElSICs9IGNhc3RvcgogICAgIFNVQkRJ
 UiArPSBjbGFzc3BhdGgKKyAgICBTVUJESVIgKz0gY2xhc3NwYXRoLWluaXRpYWwKICAgICBTVUJE
 SVIgKz0gY29tbW9uY2xpcHNlCiAgICAgU1VCRElSICs9IGNvcwogICAgIFNVQkRJUiArPSBjcnlw
 dGl4LWpjZQpAQCAtNzYsNiArNzcsNyBAQAogICAgIFNVQkRJUiArPSBqYWthcnRhLXJlZ2V4cAog
 ICAgIFNVQkRJUiArPSBqYWthcnRhLXN0cnV0cwogICAgIFNVQkRJUiArPSBqYW12bQorICAgIFNV
 QkRJUiArPSBqYW12bS1pbml0aWFsCiAgICAgU1VCRElSICs9IGphc21pbgogICAgIFNVQkRJUiAr
 PSBqYXZhLWNoZWNrc3R5bGUKICAgICBTVUJESVIgKz0gamF2YS1jdXAKSW5kZXg6IGphdmEvY2xh
 c3NwYXRoL01ha2VmaWxlCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGphdmEvY2xhc3NwYXRoL01ha2VmaWxlCShy
 ZXZpc2lvbiAzMTI0MTgpCisrKyBqYXZhL2NsYXNzcGF0aC9NYWtlZmlsZQkoYXJiZXRza29waWEp
 CkBAIC0xLDkgKzEsOSBAQAogIyBDcmVhdGVkIGJ5OiBZaW5nLUNoaWVoIExpYW8gPGlqbGlhb0BG
 cmVlQlNELm9yZz4KLSMgJEZyZWVCU0QkCisjICRGcmVlQlNEOiBoZWFkL2phdmEvY2xhc3NwYXRo
 L01ha2VmaWxlIDMxMjEzNCAyMDEzLTAyLTEyIDIyOjIxOjMyWiBqa2ltICQKIAogUE9SVE5BTUU9
 CWNsYXNzcGF0aAogUE9SVFZFUlNJT049CTAuOTkKLVBPUlRSRVZJU0lPTj0JMQorUE9SVFJFVklT
 SU9OPQkzCiBDQVRFR09SSUVTPQlqYXZhIGRldmVsCiBNQVNURVJfU0lURVM9CSR7TUFTVEVSX1NJ
 VEVfR05VfSBcCiAJCSR7TUFTVEVSX1NJVEVfU0FWQU5OQUh9CkBAIC02Miw2ICs2Miw3IEBACiAK
 IC5pbmNsdWRlIDxic2QucG9ydC5vcHRpb25zLm1rPgogCisjIGVjaiB0byBpbmNsdWRlIGFzIGNv
 bS5zdW4udG9vbHMuamF2YWMKIC5pZiAke1BPUlRfT1BUSU9OUzpNRUNKfQogTUFTVEVSX1NJVEVT
 Kz0JCSR7TUFTVEVSX1NJVEVfRUNMSVBTRTpTfCR8OmVjanx9CiBNQVNURVJfU0lURV9TVUJESVIr
 PQlSLSR7RUNKX1ZFUlNJT059LSR7RUNKX0RST1BEQVRFfS86ZWNqCkBAIC02OSw2ICs3MCwyMiBA
 QAogRUNKX1ZFUlNJT049CQkzLjguMQogRUNKX0RST1BEQVRFPQkJMjAxMjA5MTQxNTQwCiBFQ0pf
 SkFSPQkJZWNqLSR7RUNKX1ZFUlNJT059LmphcgorLmVuZGlmCisKKyMgamFtdm0taW5pdGlhbCB3
 b3JrcyB3aXRoIHRoaXMgdmVyc2lvbiBvZiBlY2oKK01BU1RFUl9TSVRFUys9CQlodHRwOi8vd3d3
 LmRmLmx0aC5zZS9+cGkvZWNsaXBzZV9hcmNoaXZlL2Ryb3BzLyVTVUJESVIlLzplY2pjCitNQVNU
 RVJfU0lURVMrPQkJaHR0cDovL2FyY2hpdmUuZWNsaXBzZS5vcmcvZWNsaXBzZS9kb3dubG9hZHMv
 ZHJvcHMvJVNVQkRJUiUvOmVjamMKK01BU1RFUl9TSVRFX1NVQkRJUis9CVItJHtFQ0pfQ09NUElM
 RV9WRVJTSU9OfS0ke0VDSl9DT01QSUxFX0RST1BEQVRFfS86ZWNqYworRElTVEZJTEVTKz0JCSR7
 RUNKX0NPTVBJTEVfSkFSfTplY2pjCitFQ0pfQ09NUElMRV9WRVJTSU9OPQkzLjIuMgorRUNKX0NP
 TVBJTEVfRFJPUERBVEU9CTIwMDcwMjEyMTMzMAorRUNKX0NPTVBJTEVfSkFSPQllY2ouamFyCisK
 K0JVSUxEX0RFUEVORFMrPQkJamFtdm0taW5pdGlhbDoke1BPUlRTRElSfS9qYXZhL2phbXZtLWlu
 aXRpYWwKK0JVSUxEX0RFUEVORFMrPQkJemlwOiR7UE9SVFNESVJ9L2FyY2hpdmVycy96aXAKK0pB
 Uj0JCQlubworCisuaWYgJHtQT1JUX09QVElPTlM6TUVDSn0KIENPTkZJR1VSRV9BUkdTKz0JLS13
 aXRoLWVjai1qYXI9JHtESVNURElSfS8ke0VDSl9KQVJ9CiAuZW5kaWYKIApAQCAtMTIzLDYgKzE0
 MCw5IEBACiAuZW5kaWYKIC5lbmRpZgogCitKQVZBPQkJCSR7TE9DQUxCQVNFfS9iaW4vamFtdm0t
 aW5pdGlhbAorSkFWQUM9CQkJJHtXUktESVJ9L2Vjai5zaAorCiAuaWYgJHtQT1JUX09QVElPTlM6
 TVFUNH0KIENPTkZJR1VSRV9BUkdTKz0JLS1lbmFibGUtcXQtcGVlcgogLmlmIGVtcHR5KFBPUlRf
 T1BUSU9OUzpNR1RLMikKQEAgLTEzNSwyMyArMTU1LDE4IEBACiBQTElTVF9TVUIrPQkJUVQ0PSJA
 Y29tbWVudCAiCiAuZW5kaWYKIAotLmlmICFkZWZpbmVkKFdJVEhfR0NKKSAmJiAoJHtBUkNIfSA9
 PSAiYW1kNjQiIHx8ICR7QVJDSH0gPT0gImkzODYiKQotQlVJTERfREVQRU5EUys9CQkke0xPQ0FM
 QkFTRX0vYm9vdHN0cmFwLW9wZW5qZGsvYmluL2phdmFjOiR7UE9SVFNESVJ9L2phdmEvYm9vdHN0
 cmFwLW9wZW5qZGsKLUpBUj89CQkJJHtMT0NBTEJBU0V9L2Jvb3RzdHJhcC1vcGVuamRrL2Jpbi9q
 YXIKLUpBVkE/PQkJCSR7TE9DQUxCQVNFfS9ib290c3RyYXAtb3Blbmpkay9iaW4vamF2YQotSkFW
 QUM/PQkJCSR7TE9DQUxCQVNFfS9ib290c3RyYXAtb3Blbmpkay9iaW4vamF2YWMKLS5lbHNlCi1V
 U0VfQklOVVRJTFM9CQl5ZXMKLVVTRV9HQ0M9CQk0LjYrCi1HQ0NfU1VGWD0JCSR7X1VTRV9HQ0M6
 Uy8uLy99Ci1KQVI/PQkJCSR7TE9DQUxCQVNFfS9iaW4vZ2phciR7R0NDX1NVRlh9Ci1KQVZBPz0J
 CQkke0xPQ0FMQkFTRX0vYmluL2dpaiR7R0NDX1NVRlh9Ci1KQVZBQz89CQkJJHtMT0NBTEJBU0V9
 L2Jpbi9nY2oke0dDQ19TVUZYfQotSkFWQUNGTEFHUz89CQktQwotLmVuZGlmCi0KIHBvc3QtcGF0
 Y2g6CiAJQCR7UkVJTlBMQUNFX0NNRH0gLWkuYmFrIC1lICdzfEBKQVZBQHwkJHtKQVZBQ01EOi1q
 YXZhfXxnJyBcCiAJICAgICR7V1JLU1JDfS90b29scy9nKi5pbgogCitwcmUtY29uZmlndXJlOgor
 CUBpZiBbICEgLXggJHtKQVZBQ30gXTsgdGhlbiBcCisJCSR7UFJJTlRGfSAiJXNcbiVzXG4lc1xu
 JXNcbiIgXAorCQkgICAgJyMhL2Jpbi9zaCcgXAorCQkgICAgJyIke0pBVkF9IiAtWG14NzY4TSAt
 Y2xhc3NwYXRoICIke0RJU1RESVJ9LyR7RUNKX0NPTVBJTEVfSkFSfSIgXCcgXAorCQkgICAgJyAg
 ICBvcmcuZWNsaXBzZS5qZHQuaW50ZXJuYWwuY29tcGlsZXIuYmF0Y2guTWFpbiAtbm93YXJuIFwn
 IFwKKwkJICAgICcgICAgIiQke0A6LS1oZWxwfSInID4gJHtKQVZBQ307IFwKKwkJJHtDSE1PRH0g
 NzU1ICR7SkFWQUN9OyBcCisJZmkKKwogLmluY2x1ZGUgPGJzZC5wb3J0Lm1rPgpJbmRleDogamF2
 YS9jbGFzc3BhdGgvZGlzdGluZm8KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gamF2YS9jbGFzc3BhdGgvZGlzdGlu
 Zm8JKHJldmlzaW9uIDMxMjQxOCkKKysrIGphdmEvY2xhc3NwYXRoL2Rpc3RpbmZvCShhcmJldHNr
 b3BpYSkKQEAgLTEsNiArMSw4IEBACiBTSEEyNTYgKGNsYXNzcGF0aC0wLjk5LnRhci5neikgPSBm
 OTI5Mjk3ZjhhZTliNjEzYTFhMTY3ZTIzMTU2Njg2MTg5MzI2MDY1MWQ5MTNhZDliNmMxMTkzMzg5
 NWZlY2M4CiBTSVpFIChjbGFzc3BhdGgtMC45OS50YXIuZ3opID0gMTEwNzgyMzIKK1NIQTI1NiAo
 ZWNqLmphcikgPSAzYjI2NjI3ZjRjOTk4YzY3ZjE0NzM5MmRjMzM1NWYzOGIwNTc2OWU0MDA5MjVh
 N2M0ZjlmZjY4ODE5ZjFjMzAzCitTSVpFIChlY2ouamFyKSA9IDEzMjMyNzcKK1NIQTI1NiAoYW50
 bHItMi43LjcuamFyKSA9IDg4ZmJkYTRiOTEyNTk2YjlmNTZlOGUxMmU1ODBjYzk1NGJhY2ZiNTE3
 NzZlY2ZkZGQzZTE4ZmMxY2Y1NmRjNGMKK1NJWkUgKGFudGxyLTIuNy43LmphcikgPSA0NDUyODgK
 IFNIQTI1NiAoZWNqLTMuOC4xLmphcikgPSBmNTk4MDg4NDVhZmFmMWFhYTVlZTM1YmNmNGVjNzBk
 NDY1MDczMzIwZmU3NjhmNzFjMWI5ZmJiM2EyMjBjZWVmCiBTSVpFIChlY2otMy44LjEuamFyKSA9
 IDE3OTYzMjUKLVNIQTI1NiAoYW50bHItMi43LjcuamFyKSA9IDg4ZmJkYTRiOTEyNTk2YjlmNTZl
 OGUxMmU1ODBjYzk1NGJhY2ZiNTE3NzZlY2ZkZGQzZTE4ZmMxY2Y1NmRjNGMKLVNJWkUgKGFudGxy
 LTIuNy43LmphcikgPSA0NDUyODgKSW5kZXg6IGphdmEvY2xhc3NwYXRoLWluaXRpYWwvTWFrZWZp
 bGUKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PQotLS0gamF2YS9jbGFzc3BhdGgtaW5pdGlhbC9NYWtlZmlsZQkocmV2aXNp
 b24gMCkKKysrIGphdmEvY2xhc3NwYXRoLWluaXRpYWwvTWFrZWZpbGUJKGFyYmV0c2tvcGlhKQpA
 QCAtMCwwICsxLDI4IEBACisjIENyZWF0ZWQgYnk6IFBlciBPbGEgSW5ndmFyc3NvbiA8c2tyYWJi
 YW5AZ21haWwuY29tPgorIyAkRnJlZUJTRCQKKworUE9SVE5BTUU9CWNsYXNzcGF0aAorUE9SVFZF
 UlNJT049CTAuOTMKK0NBVEVHT1JJRVM9CWphdmEgZGV2ZWwKK01BU1RFUl9TSVRFUz0JJHtNQVNU
 RVJfU0lURV9HTlV9IFwKKwkJJHtNQVNURVJfU0lURV9TQVZBTk5BSH0KK01BU1RFUl9TSVRFX1NV
 QkRJUj0JY2xhc3NwYXRoCitQS0dOQU1FU1VGRklYPQktaW5pdGlhbAorCitNQUlOVEFJTkVSPQlz
 a3JhYmJhbkBnbWFpbC5jb20KK0NPTU1FTlQ9CUNsYXNzcGF0aCB0byBiZSB1c2VkIHdpdGggamFt
 dm0taW5pdGlhbCB0byBidWlsZCBuZXdlciBjbGFzc3BhdGgKKworQlVJTERfREVQRU5EUz0Jemlw
 OiR7UE9SVFNESVJ9L2FyY2hpdmVycy96aXAgXAorCQlqaWtlczoke1BPUlRTRElSfS9qYXZhL2pp
 a2VzCisKK1VTRV9MRENPTkZJRz0JeWVzCitHTlVfQ09ORklHVVJFPQl5ZXMKK0NYWEZMQUdTKz0J
 LUkke0xPQ0FMQkFTRX0vaW5jbHVkZQorCitDT05GSUdVUkVfQVJHUz0JLS1lbmFibGUtam5pIC0t
 ZGlzYWJsZS1hbHNhIC0tZGlzYWJsZS1kc3NpIFwKKwkJLS1kaXNhYmxlLXBsdWdpbiAtLWRpc2Fi
 bGUtZ3RrLXBlZXIgLS13aXRoLWppa2VzIFwKKwkJLS1kaXNhYmxlLWV4YW1wbGVzIC0tZGlzYWJs
 ZS1nY29uZi1wZWVyCisKK1VTRV9HTUFLRT0JeWVzCisKKy5pbmNsdWRlIDxic2QucG9ydC5taz4K
 SW5kZXg6IGphdmEvY2xhc3NwYXRoLWluaXRpYWwvZGlzdGluZm8KPT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gamF2
 YS9jbGFzc3BhdGgtaW5pdGlhbC9kaXN0aW5mbwkocmV2aXNpb24gMCkKKysrIGphdmEvY2xhc3Nw
 YXRoLWluaXRpYWwvZGlzdGluZm8JKGFyYmV0c2tvcGlhKQpAQCAtMCwwICsxLDIgQEAKK1NIQTI1
 NiAoY2xhc3NwYXRoLTAuOTMudGFyLmd6KSA9IGRmMmQwOTM2MTJhYmQyM2ZlNjdlOTQwOWQ4OWJi
 MmE4ZTc5YjE2NjRmZTJiMmRhNDBlMWM4ZWQ2OTNlMzI5NDUKK1NJWkUgKGNsYXNzcGF0aC0wLjkz
 LnRhci5neikgPSA5NTM0MjIyCkluZGV4OiBqYXZhL2NsYXNzcGF0aC1pbml0aWFsL2ZpbGVzL3Bh
 dGNoLWNvbmZpZ3VyZQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBqYXZhL2NsYXNzcGF0aC1pbml0aWFsL2ZpbGVz
 L3BhdGNoLWNvbmZpZ3VyZQkocmV2aXNpb24gMCkKKysrIGphdmEvY2xhc3NwYXRoLWluaXRpYWwv
 ZmlsZXMvcGF0Y2gtY29uZmlndXJlCShhcmJldHNrb3BpYSkKQEAgLTAsMCArMSwxMSBAQAorLS0t
 IGNvbmZpZ3VyZS5vcmlnCTIwMTItMDEtMTcgMjA6NTA6NDYuMDAwMDAwMDAwICswMTAwCisrKysg
 Y29uZmlndXJlCTIwMTItMDEtMTcgMjA6NTA6MzEuMDAwMDAwMDAwICswMTAwCitAQCAtMTk5OCw3
 ICsxOTk4LDcgQEAgZmkKKyAKKyAKKyAjIERlZmluZSB0aGUgaWRlbnRpdHkgb2YgdGhlIHBhY2th
 Z2UuCistIFBBQ0tBR0U9J2NsYXNzcGF0aCcKKysgUEFDS0FHRT0nY2xhc3NwYXRoLWluaXRpYWwn
 CisgIFZFUlNJT049JzAuOTMnCisgCisgCkluZGV4OiBqYXZhL2NsYXNzcGF0aC1pbml0aWFsL2Zp
 bGVzL3BhdGNoLWRvY19NYWtlZmlsZS5pbgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBqYXZhL2NsYXNzcGF0aC1p
 bml0aWFsL2ZpbGVzL3BhdGNoLWRvY19NYWtlZmlsZS5pbgkocmV2aXNpb24gMCkKKysrIGphdmEv
 Y2xhc3NwYXRoLWluaXRpYWwvZmlsZXMvcGF0Y2gtZG9jX01ha2VmaWxlLmluCShhcmJldHNrb3Bp
 YSkKQEAgLTAsMCArMSwxNiBAQAorLS0tIGRvYy9NYWtlZmlsZS5pbi5vcmlnCTIwMTItMDEtMjUg
 MjA6MjE6NDAuMDAwMDAwMDAwICswMTAwCisrKysgZG9jL01ha2VmaWxlLmluCTIwMTItMDEtMjUg
 MjA6MjI6MjAuMDAwMDAwMDAwICswMTAwCitAQCAtNzA3LDExICs3MDcsMTEgQEAgaW5mbzogaW5m
 by1yZWN1cnNpdmUKKyAKKyBpbmZvLWFtOiAkKElORk9fREVQUykKKyAKKy1pbnN0YWxsLWRhdGEt
 YW06IGluc3RhbGwtaW5mby1hbQorK2luc3RhbGwtZGF0YS1hbTogCisgCisgaW5zdGFsbC1leGVj
 LWFtOgorIAorLWluc3RhbGwtaW5mbzogaW5zdGFsbC1pbmZvLXJlY3Vyc2l2ZQorK2luc3RhbGwt
 aW5mbzogCisgCisgaW5zdGFsbC1pbmZvLWFtOiAkKElORk9fREVQUykKKyAJQCQoTk9STUFMX0lO
 U1RBTEwpCkluZGV4OiBqYXZhL2NsYXNzcGF0aC1pbml0aWFsL2ZpbGVzL3BhdGNoLWluY2x1ZGVf
 TWFrZWZpbGUuaW4KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PQotLS0gamF2YS9jbGFzc3BhdGgtaW5pdGlhbC9maWxlcy9w
 YXRjaC1pbmNsdWRlX01ha2VmaWxlLmluCShyZXZpc2lvbiAwKQorKysgamF2YS9jbGFzc3BhdGgt
 aW5pdGlhbC9maWxlcy9wYXRjaC1pbmNsdWRlX01ha2VmaWxlLmluCShhcmJldHNrb3BpYSkKQEAg
 LTAsMCArMSwxMSBAQAorLS0tIGluY2x1ZGUvTWFrZWZpbGUuaW4ub3JpZwkyMDEyLTAxLTI1IDIw
 OjEzOjE4LjAwMDAwMDAwMCArMDEwMAorKysrIGluY2x1ZGUvTWFrZWZpbGUuaW4JMjAxMi0wMS0y
 NSAyMDoxMzozNy4wMDAwMDAwMDAgKzAxMDAKK0BAIC02NTUsNyArNjU1LDcgQEAgaW5mbzogaW5m
 by1hbQorIAorIGluZm8tYW06CisgCistaW5zdGFsbC1kYXRhLWFtOiBpbnN0YWxsLWluY2x1ZGVI
 RUFERVJTCisraW5zdGFsbC1kYXRhLWFtOgorIAorIGluc3RhbGwtZXhlYy1hbToKKyAKSW5kZXg6
 IGphdmEvY2xhc3NwYXRoLWluaXRpYWwvZmlsZXMvcGF0Y2gtbmF0aXZlX2puaV9uYXRpdmUtbGli
 X2NwbmV0LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PQotLS0gamF2YS9jbGFzc3BhdGgtaW5pdGlhbC9maWxlcy9wYXRj
 aC1uYXRpdmVfam5pX25hdGl2ZS1saWJfY3BuZXQuaAkocmV2aXNpb24gMCkKKysrIGphdmEvY2xh
 c3NwYXRoLWluaXRpYWwvZmlsZXMvcGF0Y2gtbmF0aXZlX2puaV9uYXRpdmUtbGliX2NwbmV0LmgJ
 KGFyYmV0c2tvcGlhKQpAQCAtMCwwICsxLDEwIEBACistLS0gbmF0aXZlL2puaS9uYXRpdmUtbGli
 L2NwbmV0Lmgub3JpZwkyMDEyLTAxLTE2IDIyOjM0OjMwLjAwMDAwMDAwMCArMDEwMAorKysrIG5h
 dGl2ZS9qbmkvbmF0aXZlLWxpYi9jcG5ldC5oCTIwMTItMDEtMTYgMjI6MzU6MDUuMDAwMDAwMDAw
 ICswMTAwCitAQCAtNDIsNiArNDIsNyBAQCBleGNlcHRpb24gc3RhdGVtZW50IGZyb20geW91ciB2
 ZXJzaW9uLiAqCisgI2luY2x1ZGUgPGpjbC5oPgorICNpbmNsdWRlIDxzdHJpbmcuaD4KKyAKKysj
 aW5jbHVkZSA8c3lzL3R5cGVzLmg+CisgI2luY2x1ZGUgPHN5cy9zb2NrZXQuaD4KKyAjaW5jbHVk
 ZSA8bmV0aW5ldC9pbi5oPgorICNpbmNsdWRlIDxuZXRpbmV0L2lwLmg+CkluZGV4OiBqYXZhL2Ns
 YXNzcGF0aC1pbml0aWFsL2ZpbGVzL3BhdGNoLXJlc291cmNlX01ha2VmaWxlLmluCj09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT0KLS0tIGphdmEvY2xhc3NwYXRoLWluaXRpYWwvZmlsZXMvcGF0Y2gtcmVzb3VyY2VfTWFrZWZp
 bGUuaW4JKHJldmlzaW9uIDApCisrKyBqYXZhL2NsYXNzcGF0aC1pbml0aWFsL2ZpbGVzL3BhdGNo
 LXJlc291cmNlX01ha2VmaWxlLmluCShhcmJldHNrb3BpYSkKQEAgLTAsMCArMSwxMSBAQAorLS0t
 IHJlc291cmNlL01ha2VmaWxlLmluLm9yaWcJMjAxMi0wMS0yNSAyMDoyMzo1Mi4wMDAwMDAwMDAg
 KzAxMDAKKysrKyByZXNvdXJjZS9NYWtlZmlsZS5pbgkyMDEyLTAxLTI1IDIwOjI0OjE4LjAwMDAw
 MDAwMCArMDEwMAorQEAgLTQ2MSw3ICs0NjEsNyBAQCBpbmZvOiBpbmZvLWFtCisgCisgaW5mby1h
 bToKKyAKKy1pbnN0YWxsLWRhdGEtYW06IGluc3RhbGwtbG9nZ2luZ0RBVEEgaW5zdGFsbC1zZWN1
 cml0eURBVEEKKytpbnN0YWxsLWRhdGEtYW06CisgCisgaW5zdGFsbC1leGVjLWFtOgorIApJbmRl
 eDogamF2YS9jbGFzc3BhdGgtaW5pdGlhbC9maWxlcy9wYXRjaC10b29sc19NYWtlZmlsZS5pbgo9
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09Ci0tLSBqYXZhL2NsYXNzcGF0aC1pbml0aWFsL2ZpbGVzL3BhdGNoLXRvb2xzX01h
 a2VmaWxlLmluCShyZXZpc2lvbiAwKQorKysgamF2YS9jbGFzc3BhdGgtaW5pdGlhbC9maWxlcy9w
 YXRjaC10b29sc19NYWtlZmlsZS5pbgkoYXJiZXRza29waWEpCkBAIC0wLDAgKzEsMTEgQEAKKy0t
 LSB0b29scy9NYWtlZmlsZS5pbi5vcmlnCTIwMTItMDEtMjUgMTE6MDY6MDMuMDAwMDAwMDAwICsw
 MTAwCisrKysgdG9vbHMvTWFrZWZpbGUuaW4JMjAxMi0wMS0yNSAxMTowNjozOS4wMDAwMDAwMDAg
 KzAxMDAKK0BAIC0xMDQzLDcgKzEwNDMsNyBAQCBpbmZvLWFtOgorIAorIGluc3RhbGwtZGF0YS1h
 bTogaW5zdGFsbC1UT09MU0RBVEEKKyAKKy1pbnN0YWxsLWV4ZWMtYW06IGluc3RhbGwtYmluUFJP
 R1JBTVMgaW5zdGFsbC1iaW5TQ1JJUFRTCisraW5zdGFsbC1leGVjLWFtOgorIAorIGluc3RhbGwt
 aW5mbzogaW5zdGFsbC1pbmZvLWFtCisgCkluZGV4OiBqYXZhL2NsYXNzcGF0aC1pbml0aWFsL3Br
 Zy1kZXNjcgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09Ci0tLSBqYXZhL2NsYXNzcGF0aC1pbml0aWFsL3BrZy1kZXNjcgko
 cmV2aXNpb24gMCkKKysrIGphdmEvY2xhc3NwYXRoLWluaXRpYWwvcGtnLWRlc2NyCShhcmJldHNr
 b3BpYSkKQEAgLTAsMCArMSw5IEBACitUaGUgcHVycG9zZSBvZiB0aGlzIHBhY2thZ2UgaXMgdG8g
 cHJvdmlkZSBhIGphdmEgbGlicmFyeSBmb3IgamFtdm0taW5pdGlhbCAKK3doaWNoIGlzIHR1cm4g
 aXMgdXNlZCB0byBidWlsZCB0aGUgbmV3ZXIgdmVyc2lvbiBvZiBjbGFzc3BhdGggd2hpY2ggaW4g
 dHVybgorY2FuIGJlIHVzZWQgdG9nZXRoZXIgd2l0aCBhIG5ld2VyIHZlcnNpb24gb2YgamFtdm0u
 CisKK0dOVSBDbGFzc3BhdGgsIEVzc2VudGlhbCBMaWJyYXJpZXMgZm9yIEphdmEsIGlzIGEgR05V
 IHByb2plY3QgdG8gY3JlYXRlIGZyZWUKK2NvcmUgY2xhc3MgbGlicmFyaWVzIGZvciB1c2Ugd2l0
 aCB2aXJ0dWFsIG1hY2hpbmVzIGFuZCBjb21waWxlcnMgZm9yIHRoZSBKYXZhCitwcm9ncmFtbWlu
 ZyBsYW5ndWFnZS4KKworV1dXOiBodHRwOi8vd3d3LmNsYXNzcGF0aC5vcmcvCkluZGV4OiBqYXZh
 L2NsYXNzcGF0aC1pbml0aWFsL3BrZy1wbGlzdAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBqYXZhL2NsYXNzcGF0
 aC1pbml0aWFsL3BrZy1wbGlzdAkocmV2aXNpb24gMCkKKysrIGphdmEvY2xhc3NwYXRoLWluaXRp
 YWwvcGtnLXBsaXN0CShhcmJldHNrb3BpYSkKQEAgLTAsMCArMSwyMiBAQAorbGliL2NsYXNzcGF0
 aC1pbml0aWFsL2xpYmphdmFpby5sYQorbGliL2NsYXNzcGF0aC1pbml0aWFsL2xpYmphdmFpby5z
 bworbGliL2NsYXNzcGF0aC1pbml0aWFsL2xpYmphdmFpby5zby4wCitsaWIvY2xhc3NwYXRoLWlu
 aXRpYWwvbGliamF2YWxhbmcubGEKK2xpYi9jbGFzc3BhdGgtaW5pdGlhbC9saWJqYXZhbGFuZy5z
 bworbGliL2NsYXNzcGF0aC1pbml0aWFsL2xpYmphdmFsYW5nLnNvLjAKK2xpYi9jbGFzc3BhdGgt
 aW5pdGlhbC9saWJqYXZhbGFuZ3JlZmxlY3QubGEKK2xpYi9jbGFzc3BhdGgtaW5pdGlhbC9saWJq
 YXZhbGFuZ3JlZmxlY3Quc28KK2xpYi9jbGFzc3BhdGgtaW5pdGlhbC9saWJqYXZhbGFuZ3JlZmxl
 Y3Quc28uMAorbGliL2NsYXNzcGF0aC1pbml0aWFsL2xpYmphdmFuZXQubGEKK2xpYi9jbGFzc3Bh
 dGgtaW5pdGlhbC9saWJqYXZhbmV0LnNvCitsaWIvY2xhc3NwYXRoLWluaXRpYWwvbGliamF2YW5l
 dC5zby4wCitsaWIvY2xhc3NwYXRoLWluaXRpYWwvbGliamF2YW5pby5sYQorbGliL2NsYXNzcGF0
 aC1pbml0aWFsL2xpYmphdmFuaW8uc28KK2xpYi9jbGFzc3BhdGgtaW5pdGlhbC9saWJqYXZhbmlv
 LnNvLjAKK2xpYi9jbGFzc3BhdGgtaW5pdGlhbC9saWJqYXZhdXRpbC5sYQorbGliL2NsYXNzcGF0
 aC1pbml0aWFsL2xpYmphdmF1dGlsLnNvCitsaWIvY2xhc3NwYXRoLWluaXRpYWwvbGliamF2YXV0
 aWwuc28uMAorQGRpcnJtIGxpYi9jbGFzc3BhdGgtaW5pdGlhbAorc2hhcmUvY2xhc3NwYXRoLWlu
 aXRpYWwvZ2xpYmouemlwCitzaGFyZS9jbGFzc3BhdGgtaW5pdGlhbC90b29scy56aXAKK0BkaXJy
 bSBzaGFyZS9jbGFzc3BhdGgtaW5pdGlhbApJbmRleDogamF2YS9qYW12bS1pbml0aWFsL01ha2Vm
 aWxlCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT0KLS0tIGphdmEvamFtdm0taW5pdGlhbC9NYWtlZmlsZQkocmV2aXNpb24g
 MCkKKysrIGphdmEvamFtdm0taW5pdGlhbC9NYWtlZmlsZQkoYXJiZXRza29waWEpCkBAIC0wLDAg
 KzEsMzYgQEAKKyMgQ3JlYXRlZCBieTogUGVyIE9sYSBJbmd2YXJzc29uIDxza3JhYmJhbkBnbWFp
 bC5jb20+CisjICRGcmVlQlNEJAorCitQT1JUTkFNRT0JamFtdm0KK1BPUlRWRVJTSU9OPQkxLjUu
 MQorQ0FURUdPUklFUz0JamF2YSBkZXZlbAorTUFTVEVSX1NJVEVTPQlTRi9qYW12bS9qYW12bS9K
 YW1WTSUyMCR7UE9SVFZFUlNJT059CitQS0dOQU1FU1VGRklYPQktaW5pdGlhbAorCitNQUlOVEFJ
 TkVSPQlza3JhYmJhbkBnbWFpbC5jb20KK0NPTU1FTlQ9CUJvb3RzdHJhcCBqYW12bSB0byBjb21w
 aWxlIGNsYXNzcGF0aCB3aXRoIGVjagorCitSVU5fREVQRU5EUz0JJHtMT0NBTEJBU0V9L3NoYXJl
 L2NsYXNzcGF0aC1pbml0aWFsL2dsaWJqLnppcDoke1BPUlRTRElSfS9qYXZhL2NsYXNzcGF0aC1p
 bml0aWFsCisKK0dOVV9DT05GSUdVUkU9CXllcworQ09ORklHVVJFX0FSR1M9CS0td2l0aC1jbGFz
 c3BhdGgtaW5zdGFsbC1kaXI9JHtMT0NBTEJBU0V9CitVU0VfR01BS0U9CXllcworVVNFX1BLR0NP
 TkZJRz0JYnVpbGQKKworLmluY2x1ZGUgPGJzZC5wb3J0LnByZS5taz4KKworTElCX0RFUEVORFMr
 PQkJZmZpOiR7UE9SVFNESVJ9L2RldmVsL2xpYmZmaQorQ09ORklHVVJFX0FSR1MrPQktLWVuYWJs
 ZS1mZmkKK0xERkxBR1MrPQktTCR7TE9DQUxCQVNFfS9saWIKK0NGTEFHUys9CWBwa2ctY29uZmln
 IGxpYmZmaSAtLWNmbGFnc2AKKworQlVJTERfREVQRU5EUys9CQl6aXA6JHtQT1JUU0RJUn0vYXJj
 aGl2ZXJzL3ppcAorUExJU1RfU1VCKz0JCVdJVEhfWklQPSIiIFdJVEhPVVRfWklQPSJAY29tbWVu
 dCAiCisKK2RvLWluc3RhbGw6CisJJHtJTlNUQUxMX1BST0dSQU19IC1zICR7V1JLU1JDfS9zcmMv
 amFtdm0taW5pdGlhbCAke1BSRUZJWH0vYmluCisJJHtNS0RJUn0gJHtQUkVGSVh9L3NoYXJlL2ph
 bXZtLWluaXRpYWwKKwkke0lOU1RBTExfREFUQX0gJHtXUktTUkN9L2xpYi9jbGFzc2VzLnppcCBc
 CisJCSR7UFJFRklYfS9zaGFyZS9qYW12bS1pbml0aWFsCisKKy5pbmNsdWRlIDxic2QucG9ydC5w
 b3N0Lm1rPgpJbmRleDogamF2YS9qYW12bS1pbml0aWFsL2Rpc3RpbmZvCj09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t
 IGphdmEvamFtdm0taW5pdGlhbC9kaXN0aW5mbwkocmV2aXNpb24gMCkKKysrIGphdmEvamFtdm0t
 aW5pdGlhbC9kaXN0aW5mbwkoYXJiZXRza29waWEpCkBAIC0wLDAgKzEsMiBAQAorU0hBMjU2IChq
 YW12bS0xLjUuMS50YXIuZ3opID0gNjYzODk1YmQ2OWNhZjNhMWZkYTZhZjVlZWE4MjYzZDkwYTVm
 ZDM1Y2E4ZjRjMzJlMjIxMGFjNDEwNzg4OTAxYQorU0laRSAoamFtdm0tMS41LjEudGFyLmd6KSA9
 IDU5OTA4NApJbmRleDogamF2YS9qYW12bS1pbml0aWFsL2ZpbGVzL3BhdGNoLWNvbmZpZ3VyZQo9
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09Ci0tLSBqYXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtY29uZmlndXJlCShy
 ZXZpc2lvbiAwKQorKysgamF2YS9qYW12bS1pbml0aWFsL2ZpbGVzL3BhdGNoLWNvbmZpZ3VyZQko
 YXJiZXRza29waWEpCkBAIC0wLDAgKzEsMzIgQEAKKy0tLSBjb25maWd1cmUub3JpZwkyMDA4LTAz
 LTAyIDA1OjE2OjA3LjAwMDAwMDAwMCArMDEwMAorKysrIGNvbmZpZ3VyZQkyMDEyLTAxLTI3IDE1
 OjAzOjIxLjAwMDAwMDAwMCArMDEwMAorQEAgLTI1NTIsOCArMjU1MiwxMCBAQCBpMzg2LSotZnJl
 ZWJzZCopIGhvc3Rfb3M9YnNkIGxpYmRsX25lZWRlCisgeDg2XzY0LSotbGludXgqKSBob3N0X29z
 PWxpbnV4IDs7CisgaHBwYSotKi1saW51eCopIGhvc3RfY3B1PXBhcmlzYyBob3N0X29zPWxpbnV4
 IDs7CisgbWlwc2VsLSotbGludXgqKSBob3N0X2NwdT1taXBzIGhvc3Rfb3M9bGludXggOzsKKy1h
 bWQ2NC0qLW9wZW5ic2QqKSBob3N0X29zPWJzZCBsaWJkbF9uZWVkZWQ9bm8gOzsKKy1hbWQ2NC0q
 LWZyZWVic2QqKSBob3N0X29zPWJzZCBsaWJkbF9uZWVkZWQ9bm8gOzsKKythbWQ2NC0qLW9wZW5i
 c2QqKSBob3N0X29zPWJzZCBob3N0X2NwdT14ODZfNjQgbGliZGxfbmVlZGVkPW5vIDs7CisrYW1k
 NjQtKi1mcmVlYnNkKikgaG9zdF9vcz1ic2QgaG9zdF9jcHU9eDg2XzY0IGxpYmRsX25lZWRlZD1u
 byA7OworK3NwYXJjNjQqLSotb3BlbmJzZCopIGhvc3RfY3B1PXNwYXJjNjQgaG9zdF9vcz1ic2Qg
 bGliZGxfbmVlZGVkPW5vIDs7Cisrc3BhcmM2NCotKi1mcmVlYnNkKikgaG9zdF9jcHU9c3BhcmM2
 NCBob3N0X29zPWJzZCBsaWJkbF9uZWVkZWQ9bm8gOzsKKyBhcm0qLSotbGludXgqKSBob3N0X2Nw
 dT1hcm0gaG9zdF9vcz1saW51eCA7OworIGFybSotKi1vcGVuYnNkKikgaG9zdF9jcHU9YXJtIGhv
 c3Rfb3M9YnNkIGxpYmRsX25lZWRlZD1ubyA7OworIGFybSotKi1mcmVlYnNkKikgaG9zdF9jcHU9
 YXJtIGhvc3Rfb3M9YnNkIGxpYmRsX25lZWRlZD1ubyA7OworQEAgLTIyODM5LDcgKzIyODQxLDcg
 QEAgZmkKKyBhY19jb25maWdfbGlua3M9IiRhY19jb25maWdfbGlua3Mgc3JjL2FyY2guaDpzcmMv
 YXJjaC8kYXJjaC5oIgorIAorIAorLWFjX2NvbmZpZ19maWxlcz0iJGFjX2NvbmZpZ19maWxlcyBN
 YWtlZmlsZSBzcmMvTWFrZWZpbGUgc3JjL2ludGVycC9NYWtlZmlsZSBzcmMvaW50ZXJwL2VuZ2lu
 ZS9NYWtlZmlsZSBzcmMvYXJjaC9NYWtlZmlsZSBzcmMvb3MvTWFrZWZpbGUgc3JjL29zL2xpbnV4
 L01ha2VmaWxlIHNyYy9vcy9kYXJ3aW4vTWFrZWZpbGUgc3JjL29zL2JzZC9NYWtlZmlsZSBzcmMv
 b3MvbGludXgvcG93ZXJwYy9NYWtlZmlsZSBzcmMvb3MvbGludXgvYXJtL01ha2VmaWxlIHNyYy9v
 cy9saW51eC9pMzg2L01ha2VmaWxlIHNyYy9vcy9saW51eC94ODZfNjQvTWFrZWZpbGUgc3JjL29z
 L2xpbnV4L3BhcmlzYy9NYWtlZmlsZSBzcmMvb3MvbGludXgvbWlwcy9NYWtlZmlsZSBzcmMvb3Mv
 ZGFyd2luL2kzODYvTWFrZWZpbGUgc3JjL29zL2Rhcndpbi9hcm0vTWFrZWZpbGUgc3JjL29zL2Rh
 cndpbi9wb3dlcnBjL01ha2VmaWxlIHNyYy9vcy9ic2QvcG93ZXJwYy9NYWtlZmlsZSBzcmMvb3Mv
 YnNkL2FybS9NYWtlZmlsZSBzcmMvb3MvYnNkL2kzODYvTWFrZWZpbGUgc3JjL29zL2JzZC94ODZf
 NjQvTWFrZWZpbGUgbGliL01ha2VmaWxlIGxpYi9qYXZhL01ha2VmaWxlIGxpYi9qYXZhL2xhbmcv
 TWFrZWZpbGUgbGliL2phbXZtL01ha2VmaWxlIGxpYi9qYW12bS9qYXZhL01ha2VmaWxlIGxpYi9q
 YW12bS9qYXZhL2xhbmcvTWFrZWZpbGUgbGliL2phdmEvbGFuZy9yZWZsZWN0L01ha2VmaWxlIGxp
 Yi9qYXZhL3NlY3VyaXR5L01ha2VmaWxlIGxpYi9nbnUvTWFrZWZpbGUgbGliL3N1bi9yZWZsZWN0
 L2Fubm90YXRpb24vTWFrZWZpbGUgbGliL3N1bi9yZWZsZWN0L01ha2VmaWxlIGxpYi9zdW4vTWFr
 ZWZpbGUgbGliL2dudS9jbGFzc3BhdGgvTWFrZWZpbGUiCisrYWNfY29uZmlnX2ZpbGVzPSIkYWNf
 Y29uZmlnX2ZpbGVzIE1ha2VmaWxlIHNyYy9NYWtlZmlsZSBzcmMvaW50ZXJwL01ha2VmaWxlIHNy
 Yy9pbnRlcnAvZW5naW5lL01ha2VmaWxlIHNyYy9hcmNoL01ha2VmaWxlIHNyYy9vcy9NYWtlZmls
 ZSBzcmMvb3MvbGludXgvTWFrZWZpbGUgc3JjL29zL2Rhcndpbi9NYWtlZmlsZSBzcmMvb3MvYnNk
 L01ha2VmaWxlIHNyYy9vcy9saW51eC9wb3dlcnBjL01ha2VmaWxlIHNyYy9vcy9saW51eC9hcm0v
 TWFrZWZpbGUgc3JjL29zL2xpbnV4L2kzODYvTWFrZWZpbGUgc3JjL29zL2xpbnV4L3g4Nl82NC9N
 YWtlZmlsZSBzcmMvb3MvbGludXgvcGFyaXNjL01ha2VmaWxlIHNyYy9vcy9saW51eC9taXBzL01h
 a2VmaWxlIHNyYy9vcy9kYXJ3aW4vaTM4Ni9NYWtlZmlsZSBzcmMvb3MvZGFyd2luL2FybS9NYWtl
 ZmlsZSBzcmMvb3MvZGFyd2luL3Bvd2VycGMvTWFrZWZpbGUgc3JjL29zL2JzZC9wb3dlcnBjL01h
 a2VmaWxlIHNyYy9vcy9ic2QvYXJtL01ha2VmaWxlIHNyYy9vcy9ic2QvaTM4Ni9NYWtlZmlsZSBz
 cmMvb3MvYnNkL3g4Nl82NC9NYWtlZmlsZSBzcmMvb3MvYnNkL3NwYXJjNjQvTWFrZWZpbGUgbGli
 L01ha2VmaWxlIGxpYi9qYXZhL01ha2VmaWxlIGxpYi9qYXZhL2xhbmcvTWFrZWZpbGUgbGliL2ph
 bXZtL01ha2VmaWxlIGxpYi9qYW12bS9qYXZhL01ha2VmaWxlIGxpYi9qYW12bS9qYXZhL2xhbmcv
 TWFrZWZpbGUgbGliL2phdmEvbGFuZy9yZWZsZWN0L01ha2VmaWxlIGxpYi9qYXZhL3NlY3VyaXR5
 L01ha2VmaWxlIGxpYi9nbnUvTWFrZWZpbGUgbGliL3N1bi9yZWZsZWN0L2Fubm90YXRpb24vTWFr
 ZWZpbGUgbGliL3N1bi9yZWZsZWN0L01ha2VmaWxlIGxpYi9zdW4vTWFrZWZpbGUgbGliL2dudS9j
 bGFzc3BhdGgvTWFrZWZpbGUiCisgCisgCisgY2F0ID5jb25mY2FjaGUgPDxcX0FDRU9GCitAQCAt
 MjM0ODMsNiArMjM0ODUsNyBAQCBkbworICAgICAic3JjL29zL2JzZC9hcm0vTWFrZWZpbGUiKSBD
 T05GSUdfRklMRVM9IiRDT05GSUdfRklMRVMgc3JjL29zL2JzZC9hcm0vTWFrZWZpbGUiIDs7Cisg
 ICAgICJzcmMvb3MvYnNkL2kzODYvTWFrZWZpbGUiKSBDT05GSUdfRklMRVM9IiRDT05GSUdfRklM
 RVMgc3JjL29zL2JzZC9pMzg2L01ha2VmaWxlIiA7OworICAgICAic3JjL29zL2JzZC94ODZfNjQv
 TWFrZWZpbGUiKSBDT05GSUdfRklMRVM9IiRDT05GSUdfRklMRVMgc3JjL29zL2JzZC94ODZfNjQv
 TWFrZWZpbGUiIDs7CisrICAgICJzcmMvb3MvYnNkL3NwYXJjNjQvTWFrZWZpbGUiKSBDT05GSUdf
 RklMRVM9IiRDT05GSUdfRklMRVMgc3JjL29zL2JzZC94ODZfNjQvTWFrZWZpbGUiIDs7CisgICAg
 ICJsaWIvTWFrZWZpbGUiKSBDT05GSUdfRklMRVM9IiRDT05GSUdfRklMRVMgbGliL01ha2VmaWxl
 IiA7OworICAgICAibGliL2phdmEvTWFrZWZpbGUiKSBDT05GSUdfRklMRVM9IiRDT05GSUdfRklM
 RVMgbGliL2phdmEvTWFrZWZpbGUiIDs7CisgICAgICJsaWIvamF2YS9sYW5nL01ha2VmaWxlIikg
 Q09ORklHX0ZJTEVTPSIkQ09ORklHX0ZJTEVTIGxpYi9qYXZhL2xhbmcvTWFrZWZpbGUiIDs7Cklu
 ZGV4OiBqYXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtbGliX01ha2VmaWxlLmluCj09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT0KLS0tIGphdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1saWJfTWFrZWZpbGUuaW4J
 KHJldmlzaW9uIDApCisrKyBqYXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtbGliX01ha2Vm
 aWxlLmluCShhcmJldHNrb3BpYSkKQEAgLTAsMCArMSwxMSBAQAorLS0tIGxpYi9NYWtlZmlsZS5p
 bi5vcmlnCTIwMTItMDEtMTcgMjE6MDU6MjYuMDAwMDAwMDAwICswMTAwCisrKysgbGliL01ha2Vm
 aWxlLmluCTIwMTItMDEtMTcgMjE6MDY6MTguMDAwMDAwMDAwICswMTAwCitAQCAtMTc2LDcgKzE3
 Niw3IEBAIHRvcF9zcmNkaXIgPSBAdG9wX3NyY2RpckAKKyB1c2VfemlwX25vID0gQHVzZV96aXBf
 bm9ACisgdXNlX3ppcF95ZXMgPSBAdXNlX3ppcF95ZXNACisgd2l0aF9jbGFzc3BhdGhfaW5zdGFs
 bF9kaXIgPSBAd2l0aF9jbGFzc3BhdGhfaW5zdGFsbF9kaXJACistQ1BfTElCX0RJUiA9ICR7d2l0
 aF9jbGFzc3BhdGhfaW5zdGFsbF9kaXJ9L3NoYXJlL2NsYXNzcGF0aAorK0NQX0xJQl9ESVIgPSAk
 e3dpdGhfY2xhc3NwYXRoX2luc3RhbGxfZGlyfS9zaGFyZS9jbGFzc3BhdGgtaW5pdGlhbAorIEdM
 SUJKX1pJUCA9ICR7Q1BfTElCX0RJUn0vZ2xpYmouemlwCisgU1VCRElSUyA9IGphbXZtIGphdmEg
 Z251IHN1bgorIEVYVFJBX0RJU1QgPSBjbGFzc2VzLnppcCBSRUFETUUKSW5kZXg6IGphdmEvamFt
 dm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfTWFrZWZpbGUuaW4KPT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gamF2
 YS9qYW12bS1pbml0aWFsL2ZpbGVzL3BhdGNoLXNyY19NYWtlZmlsZS5pbgkocmV2aXNpb24gMCkK
 KysrIGphdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfTWFrZWZpbGUuaW4JKGFyYmV0
 c2tvcGlhKQpAQCAtMCwwICsxLDIxIEBACistLS0gc3JjL01ha2VmaWxlLmluLm9yaWcJMjAxMi0w
 MS0xNyAyMTo1Mzo0NC4wMDAwMDAwMDAgKzAxMDAKKysrKyBzcmMvTWFrZWZpbGUuaW4JMjAxMi0w
 MS0xNyAyMTo1MDozOS4wMDAwMDAwMDAgKzAxMDAKK0BAIC0zNCw3ICszNCw3IEBAIFBSRV9VTklO
 U1RBTEwgPSA6CisgUE9TVF9VTklOU1RBTEwgPSA6CisgYnVpbGRfdHJpcGxldCA9IEBidWlsZEAK
 KyBob3N0X3RyaXBsZXQgPSBAaG9zdEAKKy1iaW5fUFJPR1JBTVMgPSBqYW12bSQoRVhFRVhUKQor
 K2Jpbl9QUk9HUkFNUyA9IGphbXZtJChFWEVFWFQpIGphbXZtLWluaXRpYWwkKEVYRUVYVCkKKyBz
 dWJkaXIgPSBzcmMKKyBESVNUX0NPTU1PTiA9ICQoaW5jbHVkZV9IRUFERVJTKSAkKHNyY2Rpcikv
 TWFrZWZpbGUuYW0gXAorIAkkKHNyY2RpcikvTWFrZWZpbGUuaW4gJChzcmNkaXIpL2NvbmZpZy5o
 LmluCitAQCAtMzYwLDYgKzM2MCw5IEBAIGphbXZtJChFWEVFWFQpOiAkKGphbXZtX09CSkVDVFMp
 ICQoamFtdm0KKyAJQHJtIC1mIGphbXZtJChFWEVFWFQpCisgCSQoTElOSykgJChqYW12bV9PQkpF
 Q1RTKSAkKGphbXZtX0xEQUREKSAkKExJQlMpCisgCisramFtdm0taW5pdGlhbCQoRVhFRVhUKTog
 amFtdm0kKEVYRUVYVCkKKysJQGNwIGphbXZtJChFWEVFWFQpIGphbXZtLWluaXRpYWwkKEVYRUVY
 VCkKKysKKyBtb3N0bHljbGVhbi1jb21waWxlOgorIAktcm0gLWYgKi4kKE9CSkVYVCkKKyAKSW5k
 ZXg6IGphdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfYWxsb2MuYwo9PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 Ci0tLSBqYXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtc3JjX2FsbG9jLmMJKHJldmlzaW9u
 IDApCisrKyBqYXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtc3JjX2FsbG9jLmMJKGFyYmV0
 c2tvcGlhKQpAQCAtMCwwICsxLDQ2IEBACistLS0gc3JjL2FsbG9jLmMub3JpZwkyMDA4LTAyLTIy
 IDAyOjU3OjQyLjAwMDAwMDAwMCArMDEwMAorKysrIHNyYy9hbGxvYy5jCTIwMTItMDEtMjYgMTk6
 MzI6NDAuMDAwMDAwMDAwICswMTAwCitAQCAtMjEzNCw4ICsyMTM0LDggQEAgdW5zaWduZWQgbG9u
 ZyBtYXhIZWFwTWVtKCkgeworICAgICBzdXNwZW5kZWQgd2hpbGUgaG9sZGluZyB0aGUgbWFsbG9j
 IGxvY2sgKi8KKyAKKyB2b2lkICpnY01lbU1hbGxvYyhpbnQgbikgeworLSAgICBpbnQgc2l6ZSA9
 IG4gKyBzaXplb2YoaW50KTsKKy0gICAgaW50ICptZW0gPSBtbWFwKDAsIHNpemUsIFBST1RfUkVB
 RHxQUk9UX1dSSVRFLAorKyAgICB1aW50cHRyX3Qgc2l6ZSA9IG4gKyBzaXplb2YodWludHB0cl90
 KTsKKysgICAgdWludHB0cl90ICptZW0gPSBtbWFwKDAsIHNpemUsIFBST1RfUkVBRHxQUk9UX1dS
 SVRFLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTUFQX1BSSVZBVEV8TUFQX0FOT04s
 IC0xLCAwKTsKKyAKKyAgICAgaWYobWVtID09IE1BUF9GQUlMRUQpIHsKK0BAIC0yMTUxLDkgKzIx
 NTEsOSBAQCB2b2lkICpnY01lbVJlYWxsb2Modm9pZCAqYWRkciwgaW50IHNpemUpCisgICAgIGlm
 KGFkZHIgPT0gTlVMTCkKKyAgICAgICAgIHJldHVybiBnY01lbU1hbGxvYyhzaXplKTsKKyAgICAg
 ZWxzZSB7CistICAgICAgICBpbnQgKm1lbSA9IGFkZHI7CistICAgICAgICBpbnQgb2xkX3NpemUg
 PSAqLS1tZW07CistICAgICAgICBpbnQgbmV3X3NpemUgPSBzaXplICsgc2l6ZW9mKGludCk7Cisr
 ICAgICAgICB1aW50cHRyX3QgKm1lbSA9IGFkZHI7CisrICAgICAgICB1aW50cHRyX3Qgb2xkX3Np
 emUgPSAqLS1tZW07CisrICAgICAgICB1aW50cHRyX3QgbmV3X3NpemUgPSBzaXplICsgc2l6ZW9m
 KHVpbnRwdHJfdCk7CisgCisgICAgICAgICBpZihvbGRfc2l6ZS9zeXNfcGFnZV9zaXplID09IG5l
 d19zaXplL3N5c19wYWdlX3NpemUpIHsKKyAgICAgICAgICAgICAqbWVtID0gbmV3X3NpemU7CitA
 QCAtMjE2Miw3ICsyMTYyLDcgQEAgdm9pZCAqZ2NNZW1SZWFsbG9jKHZvaWQgKmFkZHIsIGludCBz
 aXplKQorICAgICAgICAgICAgIGludCBjb3B5X3NpemUgPSBuZXdfc2l6ZSA+IG9sZF9zaXplID8g
 b2xkX3NpemUgOiBuZXdfc2l6ZTsKKyAgICAgICAgICAgICB2b2lkICpuZXdfbWVtID0gZ2NNZW1N
 YWxsb2Moc2l6ZSk7CisgCistICAgICAgICAgICAgbWVtY3B5KG5ld19tZW0sIGFkZHIsIGNvcHlf
 c2l6ZSAtIHNpemVvZihpbnQpKTsKKysgICAgICAgICAgICBtZW1jcHkobmV3X21lbSwgYWRkciwg
 Y29weV9zaXplIC0gc2l6ZW9mKHVpbnRwdHJfdCkpOworICAgICAgICAgICAgIG11bm1hcChtZW0s
 IG9sZF9zaXplKTsKKyAKKyAgICAgICAgICAgICByZXR1cm4gbmV3X21lbTsKK0BAIC0yMTcyLDgg
 KzIxNzIsOCBAQCB2b2lkICpnY01lbVJlYWxsb2Modm9pZCAqYWRkciwgaW50IHNpemUpCisgCisg
 dm9pZCBnY01lbUZyZWUodm9pZCAqYWRkcikgeworICAgICBpZihhZGRyICE9IE5VTEwpIHsKKy0g
 ICAgICAgIGludCAqbWVtID0gYWRkcjsKKy0gICAgICAgIGludCBzaXplID0gKi0tbWVtOworKyAg
 ICAgICAgdWludHB0cl90ICptZW0gPSBhZGRyOworKyAgICAgICAgdWludHB0cl90IHNpemUgPSAq
 LS1tZW07CisgICAgICAgICBtdW5tYXAobWVtLCBzaXplKTsKKyAgICAgfQorIH0KSW5kZXg6IGph
 dmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfYXJjaF9zcGFyYzY0LmgKPT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PQotLS0gamF2YS9qYW12bS1pbml0aWFsL2ZpbGVzL3BhdGNoLXNyY19hcmNoX3NwYXJjNjQuaAko
 cmV2aXNpb24gMCkKKysrIGphdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfYXJjaF9z
 cGFyYzY0LmgJKGFyYmV0c2tvcGlhKQpAQCAtMCwwICsxLDEzNyBAQAorLS0tIHNyYy9hcmNoL3Nw
 YXJjNjQuaC5vcmlnCTIwMTItMDEtMjYgMTk6MzI6NDAuMDAwMDAwMDAwICswMTAwCisrKysgc3Jj
 L2FyY2gvc3BhcmM2NC5oCTIwMTItMDEtMjYgMTk6MzI6NDAuMDAwMDAwMDAwICswMTAwCitAQCAt
 MCwwICsxLDEzNCBAQAorKy8qCisrICogQ29weXJpZ2h0IChDKSAyMDAzLCAyMDA0LCAyMDA1LCAy
 MDA2LCAyMDA3LCAyMDA4CisrICogUm9iZXJ0IExvdWdoZXIgPHJvYkBsb3VnaGVyLm9yZy51az4u
 CisrICoKKysgKiBUaGlzIGZpbGUgaXMgcGFydCBvZiBKYW1WTS4KKysgKgorKyAqIFRoaXMgcHJv
 Z3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKysg
 KiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGlj
 ZW5zZQorKyAqIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBl
 aXRoZXIgdmVyc2lvbiAyLAorKyAqIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNp
 b24uCisrICoKKysgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhh
 dCBpdCB3aWxsIGJlIHVzZWZ1bCwKKysgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhv
 dXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorKyAqIE1FUkNIQU5UQUJJTElUWSBvciBG
 SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKysgKiBHTlUgR2VuZXJh
 bCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorKyAqCisrICogWW91IHNob3VsZCBo
 YXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKysg
 KiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0
 d2FyZQorKyAqIEZvdW5kYXRpb24sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsIEJv
 c3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorKyAqLworKworKyNkZWZpbmUgT1NfQVJDSCAic3Bh
 cmM2NCIKKysKKysjZGVmaW5lIEhBTkRMRVJfVEFCTEVfVCBzdGF0aWMgY29uc3Qgdm9pZAorKyNk
 ZWZpbmUgRE9VQkxFXzFfQklUUyAweDNmZjAwMDAwMDAwMDAwMDBMTAorKworKyNkZWZpbmUgUkVB
 RF9EQkwodixwLGwpCXYgPSAoKHU4KXBbMF08PDU2KXwoKHU4KXBbMV08PDQ4KXwoKHU4KXBbMl08
 PDQwKSAgXAorKyAgICAgICAgICAgICAgICAgICAgICAgICAgICB8KCh1OClwWzNdPDwzMil8KCh1
 OClwWzRdPDwyNCl8KCh1OClwWzVdPDwxNikgXAorKyAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICB8KCh1OClwWzZdPDw4KXwodTgpcFs3XTsgcCs9OAorKworKyNkZWZpbmUgRlBVX0hBQ0sKKysK
 KytzdGF0aWMgaW5saW5lIHVpbnQzMl90CisrY29tcGFyZV9hbmRfc3dhcF8zMih2b2xhdGlsZSB1
 aW50MzJfdCAqYWRkciwgdWludDMyX3Qgb2xkdmFsLCB1aW50MzJfdCBuZXd2YWwpCisreworKyAg
 IHVpbnQzMl90IHJlc3VsdDsKKysgICBfX2FzbV9fIF9fdm9sYXRpbGVfXyAoImNhcyBbJTRdLCAl
 MiwgJTAiCisrICAgCQkJOiAiPXIiIChyZXN1bHQpLCAiPW0iICgqYWRkcikKKysJCQk6ICJyIiAo
 b2xkdmFsKSwgIm0iICgqYWRkciksICJyIiAoYWRkciksCisrCQkJIjAiIChuZXd2YWwpKTsKKysg
 IHJldHVybiByZXN1bHQgPT0gb2xkdmFsOworK30KKysKKysjZGVmaW5lIENPTVBBUkVfQU5EX1NX
 QVAzMiBjb21wYXJlX2FuZF9zd2FwXzMyCisrCisrc3RhdGljIGlubGluZSB1aW50NjRfdAorK2Nv
 bXBhcmVfYW5kX3N3YXBfNjQoIHZvbGF0aWxlIHVpbnQ2NF90ICphZGRyLCAKKysgICAgICAgICAg
 ICAgICAgICAgICB2b2xhdGlsZSB1aW50NjRfdCBvbGR2YWwsIAorKyAgICAgICAgICAgICAgICAg
 ICAgIHZvbGF0aWxlIHVpbnQ2NF90IG5ld3ZhbCApCisreworKyNpZiAxCisrICAgdWludDY0X3Qg
 cmVzdWx0OworKyAgIF9fYXNtX18gX192b2xhdGlsZV9fICgiY2FzeCBbJTRdLCAlMiwgJTAiCisr
 ICAgCQkJOiAiPXIiIChyZXN1bHQpLCAiPW0iICgqYWRkcikKKysJCQk6ICJyIiAob2xkdmFsKSwg
 Im0iICgqYWRkciksICJyIiAoYWRkciksCisrCQkJIjAiIChuZXd2YWwpKTsKKysgIHJldHVybiBy
 ZXN1bHQgPT0gb2xkdmFsOworKyNlbHNlCisrICBpZigqYWRkciA9PSBvbGR2YWwpIHsgICAgICAg
 ICAgICAgICAgICAgICAgIAorKyAgICAgICAgKmFkZHIgPSBuZXd2YWw7ICAgICAgICAgICAgICAg
 ICAgICAgICAgCisrICAgICAgICByZXR1cm4gMTsKKysgICAgfSBlbHNlIHsKKysgICAgICAgIHJl
 dHVybiAwOworKyAgICB9CisrICAKKysjZW5kaWYKKyt9CisrCisrI2RlZmluZSBDT01QQVJFX0FO
 RF9TV0FQNjQgY29tcGFyZV9hbmRfc3dhcF82NCAgICAKKysjaWZkZWYgX19hcmNoNjRfXworKyMg
 IGRlZmluZSBDT01QQVJFX0FORF9TV0FQIENPTVBBUkVfQU5EX1NXQVA2NAorKyNlbHNlCisrIyAg
 ZGVmaW5lIENPTVBBUkVfQU5EX1NXQVAgQ09NUEFSRV9BTkRfU1dBUDMyCisrI2VuZGlmCisrCisr
 I2RlZmluZSBTVE9SRV9MT0FEIF9fYXNtX18gX192b2xhdGlsZV9fICgibWVtYmFyICNTdG9yZUxv
 YWQiIDogOiA6ICJtZW1vcnkiKQorKworKworKyNkZWZpbmUgTE9DS1dPUkRfUkVBRChhZGRyKSAo
 eyBTVE9SRV9MT0FEOyAqYWRkcjsgfSkKKysjZGVmaW5lIExPQ0tXT1JEX1dSSVRFKGFkZHIsIHZh
 bHVlKSAoeyBTVE9SRV9MT0FEOyAqYWRkciA9IHZhbHVlOyB9KQorKyNkZWZpbmUgTE9DS1dPUkRf
 Q09NUEFSRV9BTkRfU1dBUCBDT01QQVJFX0FORF9TV0FQCisrCisrI2RlZmluZSBfX0dFTl9SRUxf
 Sk1QKHRhcmdldF9hZGRyLCBwYXRjaF9hZGRyLCBvcGNvZGUsICAgICAgIFwKKysgICAgICAgICAg
 ICAgICAgICAgICAgdHlwZSwgcGF0Y2hfc2l6ZSkgICAgICAgICAgICAgICAgICAgICAgXAorKyh7
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICBcCisrICAgIGludCBwYXRjaGVkID0gRkFMU0U7ICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgIFwKKysgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgXAorKyAgICBpZihwYXRjaF9zaXplID49IDEgKyBzaXplb2YodHlw
 ZSkpIHsgICAgICAgICAgICAgICAgICAgICBcCisrICAgICAgICBjaGFyICpueHRfaW5zX3B0ciA9
 IChwYXRjaF9hZGRyKSArIDEgKyBzaXplb2YodHlwZSk7IFwKKysgICAgICAgIHVpbnRwdHJfdCBs
 aW1pdCA9IDFVTEw8PCgoc2l6ZW9mKHR5cGUpICogOCkgLSAxKTsgICAgXAorKyAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisrICAg
 ICAgICAvKiBUaGUgY2hlY2sgaXMgZG9uZSBpbiB0d28gcGFydHMgdG8gZW5zdXJlIHRoZSAgICAg
 IFwKKysgICAgICAgICAgIHJlc3VsdCBpcyBhbHdheXMgcG9zaXRpdmUsIHRvIGd1YXJkIGFnYWlu
 c3QgICAgICAgXAorKyAgICAgICAgICAgdGhlIHBvaW50ZXIgZGlmZmVyZW5jZSBiZWluZyBsYXJn
 ZXIgdGhhbiB0aGUgICAgICBcCisrICAgICAgICAgICBzaWduZWQgcmFuZ2UgKi8gICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgIFwKKysgICAgICAgIGlmKHRhcmdldF9hZGRyID4gbnh0
 X2luc19wdHIpIHsgICAgICAgICAgICAgICAgICAgICAgXAorKyAgICAgICAgICAgIHVpbnRwdHJf
 dCBkaXNwID0gKHRhcmdldF9hZGRyKSAtIChueHRfaW5zX3B0cik7ICBcCisrICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKysgICAg
 ICAgICAgICBpZihkaXNwIDwgbGltaXQpIHsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 XAorKyAgICAgICAgICAgICAgICAqKHBhdGNoX2FkZHIpID0gb3Bjb2RlOyAgICAgICAgICAgICAg
 ICAgICAgICBcCisrICAgICAgICAgICAgICAgICoodHlwZSopJihwYXRjaF9hZGRyKVsxXSA9IGRp
 c3A7ICAgICAgICAgICAgIFwKKysgICAgICAgICAgICAgICAgcGF0Y2hlZCA9IFRSVUU7ICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgXAorKyAgICAgICAgICAgIH0gICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisrICAgICAgICB9IGVsc2UgeyAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKysgICAgICAgICAgICB1
 aW50cHRyX3QgZGlzcCA9IChueHRfaW5zX3B0cikgLSAodGFyZ2V0X2FkZHIpOyAgXAorKyAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBc
 CisrICAgICAgICAgICAgaWYoZGlzcCA8PSBsaW1pdCkgeyAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgIFwKKysgICAgICAgICAgICAgICAgKihwYXRjaF9hZGRyKSA9IG9wY29kZTsgICAgICAg
 ICAgICAgICAgICAgICAgXAorKyAgICAgICAgICAgICAgICAqKHR5cGUqKSYocGF0Y2hfYWRkcilb
 MV0gPSAtZGlzcDsgICAgICAgICAgICBcCisrICAgICAgICAgICAgICAgIHBhdGNoZWQgPSBUUlVF
 OyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKysgICAgICAgICAgICB9ICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorKyAgICAgICAgfSAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisrICAgIH0g
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwK
 KysgICAgcGF0Y2hlZDsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgXAorK30pCisrCisrI2RlZmluZSBHRU5fUkVMX0pNUCh0YXJnZXRfYWRkciwgcGF0Y2hf
 YWRkciwgcGF0Y2hfc2l6ZSkgXAorKyh7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgIFwKKysgICAgX19HRU5fUkVMX0pNUCh0YXJnZXRfYWRkciwg
 cGF0Y2hfYWRkciwgMHhlYiwgICAgICAgICBcCisrICAgICAgICAgICAgICAgICAgc2lnbmVkIGNo
 YXIsIHBhdGNoX3NpemUpIHx8ICAgICAgICAgICAgXAorKyAgICBfX0dFTl9SRUxfSk1QKHRhcmdl
 dF9hZGRyLCBwYXRjaF9hZGRyLCAweGU5LCAgICAgICAgIFwKKysgICAgICAgICAgICAgICAgICBz
 aWduZWQgaW50LCBwYXRjaF9zaXplKTsgICAgICAgICAgICAgICBcCisrfSkKKysKKysjaWZkZWYg
 SU5MSU5JTkcKKysjZXJyb3IgIkkgZG9uJ3Qga25vdyBob3cgdG8gZmx1c2giCisrI2RlZmluZSBG
 TFVTSF9DQUNIRShhZGRyLCBsZW5ndGgpCisrI2VuZGlmCisrI2RlZmluZSBNQkFSUklFUigpIF9f
 YXNtX18gX192b2xhdGlsZV9fICgibWVtYmFyICNMb2FkTG9hZCB8ICNMb2FkU3RvcmUiXAorKyAg
 ICAgICAgICAgICAgICAgICAgICAgICIgfCAjU3RvcmVMb2FkIHwgI1N0b3JlU3RvcmUiIDogOiA6
 ICJtZW1vcnkiKQorKyNkZWZpbmUgVU5MT0NLX01CQVJSSUVSKCkgTUJBUlJJRVIoKQorKyNkZWZp
 bmUgSk1NX0xPQ0tfTUJBUlJJRVIoKSBNQkFSUklFUigpCisrI2RlZmluZSBKTU1fVU5MT0NLX01C
 QVJSSUVSKCkgTUJBUlJJRVIoKQorKwpJbmRleDogamF2YS9qYW12bS1pbml0aWFsL2ZpbGVzL3Bh
 dGNoLXNyY19jbGFzcy5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGphdmEvamFtdm0taW5pdGlhbC9maWxlcy9w
 YXRjaC1zcmNfY2xhc3MuaAkocmV2aXNpb24gMCkKKysrIGphdmEvamFtdm0taW5pdGlhbC9maWxl
 cy9wYXRjaC1zcmNfY2xhc3MuaAkoYXJiZXRza29waWEpCkBAIC0wLDAgKzEsMTggQEAKKy0tLSBz
 cmMvY2xhc3MuaC5vcmlnCTIwMTItMDEtMTcgMjI6MDM6MDcuMDAwMDAwMDAwICswMTAwCisrKysg
 c3JjL2NsYXNzLmgJMjAxMi0wMS0xNyAyMjowNDoxMi4wMDAwMDAwMDAgKzAxMDAKK0BAIC0zOSwx
 MSArMzksMTEgQEAKKyAgICBzZXBhcmF0ZSBjbGFzcyBmaWxlcyBpbiBhIGRpcmVjdG9yeSBzdHJ1
 Y3R1cmUgKi8KKyAKKyAjaWZkZWYgVVNFX1pJUAorLSNkZWZpbmUgSkFNVk1fQ0xBU1NFUyBJTlNU
 QUxMX0RJUiIvc2hhcmUvamFtdm0vY2xhc3Nlcy56aXAiCistI2RlZmluZSBDTEFTU1BBVEhfQ0xB
 U1NFUyBDTEFTU1BBVEhfSU5TVEFMTF9ESVIiL3NoYXJlL2NsYXNzcGF0aC9nbGliai56aXAiCisr
 I2RlZmluZSBKQU1WTV9DTEFTU0VTIElOU1RBTExfRElSIi9zaGFyZS9qYW12bS1pbml0aWFsL2Ns
 YXNzZXMuemlwIgorKyNkZWZpbmUgQ0xBU1NQQVRIX0NMQVNTRVMgQ0xBU1NQQVRIX0lOU1RBTExf
 RElSIi9zaGFyZS9jbGFzc3BhdGgtaW5pdGlhbC9nbGliai56aXAiCisgI2Vsc2UKKy0jZGVmaW5l
 IEpBTVZNX0NMQVNTRVMgSU5TVEFMTF9ESVIiL3NoYXJlL2phbXZtL2NsYXNzZXMiCistI2RlZmlu
 ZSBDTEFTU1BBVEhfQ0xBU1NFUyBDTEFTU1BBVEhfSU5TVEFMTF9ESVIiL3NoYXJlL2NsYXNzcGF0
 aCIKKysjZGVmaW5lIEpBTVZNX0NMQVNTRVMgSU5TVEFMTF9ESVIiL3NoYXJlL2phbXZtLWluaXRp
 YWwvY2xhc3NlcyIKKysjZGVmaW5lIENMQVNTUEFUSF9DTEFTU0VTIENMQVNTUEFUSF9JTlNUQUxM
 X0RJUiIvc2hhcmUvY2xhc3NwYXRoLWluaXRpYWwiCisgI2VuZGlmCisgCisgI2RlZmluZSBERkxU
 X0JDUCBKQU1WTV9DTEFTU0VTIjoiQ0xBU1NQQVRIX0NMQVNTRVMKSW5kZXg6IGphdmEvamFtdm0t
 aW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfZGxsLmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gamF2YS9qYW12bS1p
 bml0aWFsL2ZpbGVzL3BhdGNoLXNyY19kbGwuYwkocmV2aXNpb24gMCkKKysrIGphdmEvamFtdm0t
 aW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfZGxsLmMJKGFyYmV0c2tvcGlhKQpAQCAtMCwwICsxLDEx
 IEBACistLS0gc3JjL2RsbC5jLm9yaWcJMjAxMi0wMS0xNyAyMjoyODoyNy4wMDAwMDAwMDAgKzAx
 MDAKKysrKyBzcmMvZGxsLmMJMjAxMi0wMS0xNyAyMjoyODo0MC4wMDAwMDAwMDAgKzAxMDAKK0BA
 IC0zMDYsNyArMzA2LDcgQEAgY2hhciAqZ2V0RGxsUGF0aCgpIHsKKyB9CisgCisgY2hhciAqZ2V0
 Qm9vdERsbFBhdGgoKSB7CistICAgIHJldHVybiBDTEFTU1BBVEhfSU5TVEFMTF9ESVIiL2xpYi9j
 bGFzc3BhdGgiOworKyAgICByZXR1cm4gQ0xBU1NQQVRIX0lOU1RBTExfRElSIi9saWIvY2xhc3Nw
 YXRoLWluaXRpYWwiOworIH0KKyAKKyBjaGFyICpnZXREbGxOYW1lKGNoYXIgKm5hbWUpIHsKSW5k
 ZXg6IGphdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfZGxsX2ZmaS5jCj09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT0KLS0tIGphdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfZGxsX2ZmaS5jCShyZXZp
 c2lvbiAwKQorKysgamF2YS9qYW12bS1pbml0aWFsL2ZpbGVzL3BhdGNoLXNyY19kbGxfZmZpLmMJ
 KGFyYmV0c2tvcGlhKQpAQCAtMCwwICsxLDEzIEBACistLS0gc3JjL2RsbF9mZmkuYy5vcmlnCTIw
 MDctMTEtMTIgMDU6MDQ6MzcuMDAwMDAwMDAwICswMTAwCisrKysgc3JjL2RsbF9mZmkuYwkyMDEy
 LTAxLTI2IDE5OjMyOjQwLjAwMDAwMDAwMCArMDEwMAorQEAgLTcyLDggKzcyLDggQEAgaW50IG5h
 dGl2ZUV4dHJhQXJnKE1ldGhvZEJsb2NrICptYikgeworIHVpbnRwdHJfdCAqY2FsbEpOSU1ldGhv
 ZCh2b2lkICplbnYsIENsYXNzICpjbGFzcywgY2hhciAqc2lnLCBpbnQgbnVtX2FyZ3MsIHVpbnRw
 dHJfdCAqb3N0YWNrLAorICAgICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBjaGFyICpm
 dW5jKSB7CisgICAgIGZmaV9jaWYgY2lmOworLSAgICB2b2lkICp2YWx1ZXNbbnVtX2FyZ3NdOwor
 LSAgICBmZmlfdHlwZSAqdHlwZXNbbnVtX2FyZ3NdOworKyAgICB2b2lkICp2YWx1ZXNbbnVtX2Fy
 Z3MgKyAxXTsKKysgICAgZmZpX3R5cGUgKnR5cGVzW251bV9hcmdzICsgMV07CisgICAgIHVpbnRw
 dHJfdCAqb3BudHIgPSBvc3RhY2s7CisgICAgIHZvaWQgKip2YWx1ZXNfcG50ciA9ICZ2YWx1ZXNb
 Ml07CisgICAgIGZmaV90eXBlICoqdHlwZXNfcG50ciA9ICZ0eXBlc1syXTsKSW5kZXg6IGphdmEv
 amFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfZnJhbWUuaAo9PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBqYXZh
 L2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtc3JjX2ZyYW1lLmgJKHJldmlzaW9uIDApCisrKyBq
 YXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtc3JjX2ZyYW1lLmgJKGFyYmV0c2tvcGlhKQpA
 QCAtMCwwICsxLDIyIEBACistLS0gc3JjL2ZyYW1lLmgub3JpZwkyMDA4LTAxLTI2IDAyOjE1OjQx
 LjAwMDAwMDAwMCArMDEwMAorKysrIHNyYy9mcmFtZS5oCTIwMTItMDEtMjYgMTk6MzI6NDAuMDAw
 MDAwMDAwICswMTAwCitAQCAtMTksNiArMTksMTAgQEAKKyAgKiBGb3VuZGF0aW9uLCA1MSBGcmFu
 a2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAg
 Ki8KKyAKKysvKiBFbnN1cmUgb3BlcmFuZCBzdGFjayBpcyBkb3VibGUtd29yZCBhbGlnbmVkLiAg
 VGhpcyBsZWFkcyB0bworKyAgIGJldHRlciBkb3VibGUgZmxvYXRpbmctcG9pbnQgcGVyZm9ybWFu
 Y2UgKi8KKysjZGVmaW5lIEFMSUdOX09TVEFDSyhwbnRyKSAodWludHB0cl90KikoKCh1aW50cHRy
 X3QpKHBudHIpICsgNykgJiB+NykKKysKKyAjZGVmaW5lIENSRUFURV9UT1BfRlJBTUUoZWUsIGNs
 YXNzLCBtYiwgc3AsIHJldCkgICAgICAgICAgICAgICAgXAorIHsgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgIEZyYW1l
 ICpsYXN0ID0gZWUtPmxhc3RfZnJhbWU7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwK
 K0BAIC0yOCw3ICszMiw3IEBACisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgcmV0ID0gKHZvaWQqKSAoc3AgPSAo
 dWludHB0cl90KikoZHVtbXkrMSkpOyAgICAgICAgICAgICAgICAgXAorICAgICBuZXdfZnJhbWUg
 PSAoRnJhbWUgKikoc3AgKyBtYi0+bWF4X2xvY2Fscyk7ICAgICAgICAgICAgICAgICBcCistICAg
 IG5ld19vc3RhY2sgPSAodWludHB0cl90ICopKG5ld19mcmFtZSArIDEpOyAgICAgICAgICAgICAg
 ICAgIFwKKysgICAgbmV3X29zdGFjayA9IEFMSUdOX09TVEFDSyhuZXdfZnJhbWUgKyAxKTsgICAg
 ICAgICAgICAgICAgICBcCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgaWYoKGNoYXIqKShuZXdfb3N0YWNrICsg
 bWItPm1heF9zdGFjaykgPiBlZS0+c3RhY2tfZW5kKSB7ICAgXAorICAgICAgICAgaWYoZWUtPm92
 ZXJmbG93KyspIHsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCkluZGV4OiBq
 YXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtc3JjX29zX2JzZF9vcy5jCj09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K
 LS0tIGphdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfb3NfYnNkX29zLmMJKHJldmlz
 aW9uIDApCisrKyBqYXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtc3JjX29zX2JzZF9vcy5j
 CShhcmJldHNrb3BpYSkKQEAgLTAsMCArMSwxMSBAQAorLS0tIHNyYy9vcy9ic2Qvb3MuYy5vcmln
 CTIwMDctMDItMjQgMTc6MTM6MTIuMDAwMDAwMDAwICswMTAwCisrKysgc3JjL29zL2JzZC9vcy5j
 CTIwMTItMDEtMjYgMTk6MzI6NDAuMDAwMDAwMDAwICswMTAwCitAQCAtNDgsNyArNDgsNyBAQCB2
 b2lkICpuYXRpdmVTdGFja0Jhc2UoKSB7Cisgdm9pZCAqbmF0aXZlU3RhY2tCYXNlKCkgeworICAg
 ICBwdGhyZWFkX2F0dHJfdCBhdHRyOworICAgICB2b2lkICphZGRyOworLSAgICBpbnQgc2l6ZTsK
 KysgICAgc2l6ZV90IHNpemU7CisgCisgICAgIHB0aHJlYWRfYXR0cl9pbml0KCZhdHRyKTsKKyAg
 ICAgcHRocmVhZF9hdHRyX2dldF9ucChwdGhyZWFkX3NlbGYoKSwgJmF0dHIpOwpJbmRleDogamF2
 YS9qYW12bS1pbml0aWFsL2ZpbGVzL3BhdGNoLXNyY19vc19ic2Rfc3BhcmM2NF9NYWtlZmlsZS5p
 bgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09Ci0tLSBqYXZhL2phbXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtc3JjX29zX2Jz
 ZF9zcGFyYzY0X01ha2VmaWxlLmluCShyZXZpc2lvbiAwKQorKysgamF2YS9qYW12bS1pbml0aWFs
 L2ZpbGVzL3BhdGNoLXNyY19vc19ic2Rfc3BhcmM2NF9NYWtlZmlsZS5pbgkoYXJiZXRza29waWEp
 CkBAIC0wLDAgKzEsNDQ5IEBACistLS0gc3JjL29zL2JzZC9zcGFyYzY0L01ha2VmaWxlLmluLm9y
 aWcJMjAxMi0wMS0yNyAyMTozNjoxNC4wMDAwMDAwMDAgKzAxMDAKKysrKyBzcmMvb3MvYnNkL3Nw
 YXJjNjQvTWFrZWZpbGUuaW4JMjAxMi0wMS0yNyAyMTozOToxNC4wMDAwMDAwMDAgKzAxMDAKK0BA
 IC0wLDAgKzEsNDQ2IEBACisrIyBNYWtlZmlsZS5pbiBnZW5lcmF0ZWQgYnkgYXV0b21ha2UgMS4x
 MC4xIGZyb20gTWFrZWZpbGUuYW0uCisrIyBAY29uZmlndXJlX2lucHV0QAorKworKyMgQ29weXJp
 Z2h0IChDKSAxOTk0LCAxOTk1LCAxOTk2LCAxOTk3LCAxOTk4LCAxOTk5LCAyMDAwLCAyMDAxLCAy
 MDAyLAorKyMgMjAwMywgMjAwNCwgMjAwNSwgMjAwNiwgMjAwNywgMjAwOCAgRnJlZSBTb2Z0d2Fy
 ZSBGb3VuZGF0aW9uLCBJbmMuCisrIyBUaGlzIE1ha2VmaWxlLmluIGlzIGZyZWUgc29mdHdhcmU7
 IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKysjIGdpdmVzIHVubGltaXRlZCBwZXJtaXNz
 aW9uIHRvIGNvcHkgYW5kL29yIGRpc3RyaWJ1dGUgaXQsCisrIyB3aXRoIG9yIHdpdGhvdXQgbW9k
 aWZpY2F0aW9ucywgYXMgbG9uZyBhcyB0aGlzIG5vdGljZSBpcyBwcmVzZXJ2ZWQuCisrCisrIyBU
 aGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVz
 ZWZ1bCwKKysjIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWSwgdG8gdGhlIGV4dGVudCBwZXJtaXR0
 ZWQgYnkgbGF3OyB3aXRob3V0CisrIyBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mIE1FUkNI
 QU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBCisrIyBQQVJUSUNVTEFSIFBVUlBPU0UuCisrCisr
 QFNFVF9NQUtFQAorKworK1ZQQVRIID0gQHNyY2RpckAKKytwa2dkYXRhZGlyID0gJChkYXRhZGly
 KS9AUEFDS0FHRUAKKytwa2dsaWJkaXIgPSAkKGxpYmRpcikvQFBBQ0tBR0VACisrcGtnaW5jbHVk
 ZWRpciA9ICQoaW5jbHVkZWRpcikvQFBBQ0tBR0VACisrYW1fX2NkID0gQ0RQQVRIPSIkJHtaU0hf
 VkVSU0lPTisufSQoUEFUSF9TRVBBUkFUT1IpIiAmJiBjZAorK2luc3RhbGxfc2hfREFUQSA9ICQo
 aW5zdGFsbF9zaCkgLWMgLW0gNjQ0CisraW5zdGFsbF9zaF9QUk9HUkFNID0gJChpbnN0YWxsX3No
 KSAtYworK2luc3RhbGxfc2hfU0NSSVBUID0gJChpbnN0YWxsX3NoKSAtYworK0lOU1RBTExfSEVB
 REVSID0gJChJTlNUQUxMX0RBVEEpCisrdHJhbnNmb3JtID0gJChwcm9ncmFtX3RyYW5zZm9ybV9u
 YW1lKQorK05PUk1BTF9JTlNUQUxMID0gOgorK1BSRV9JTlNUQUxMID0gOgorK1BPU1RfSU5TVEFM
 TCA9IDoKKytOT1JNQUxfVU5JTlNUQUxMID0gOgorK1BSRV9VTklOU1RBTEwgPSA6CisrUE9TVF9V
 TklOU1RBTEwgPSA6CisrYnVpbGRfdHJpcGxldCA9IEBidWlsZEAKKytob3N0X3RyaXBsZXQgPSBA
 aG9zdEAKKytzdWJkaXIgPSBzcmMvb3MvYnNkL3NwYXJjNjQKKytESVNUX0NPTU1PTiA9ICQoc3Jj
 ZGlyKS9NYWtlZmlsZS5hbSAkKHNyY2RpcikvTWFrZWZpbGUuaW4KKytBQ0xPQ0FMX000ID0gJCh0
 b3Bfc3JjZGlyKS9hY2xvY2FsLm00CisrYW1fX2FjbG9jYWxfbTRfZGVwcyA9ICQodG9wX3NyY2Rp
 cikvYWNpbmNsdWRlLm00IFwKKysJJCh0b3Bfc3JjZGlyKS9jb25maWd1cmUuYWMKKythbV9fY29u
 ZmlndXJlX2RlcHMgPSAkKGFtX19hY2xvY2FsX200X2RlcHMpICQoQ09ORklHVVJFX0RFUEVOREVO
 Q0lFUykgXAorKwkkKEFDTE9DQUxfTTQpCisrbWtpbnN0YWxsZGlycyA9ICQoU0hFTEwpICQodG9w
 X3NyY2RpcikvbWtpbnN0YWxsZGlycworK0NPTkZJR19IRUFERVIgPSAkKHRvcF9idWlsZGRpcikv
 c3JjL2NvbmZpZy5oCisrQ09ORklHX0NMRUFOX0ZJTEVTID0KKytMVExJQlJBUklFUyA9ICQobm9p
 bnN0X0xUTElCUkFSSUVTKQorK2xpYm5hdGl2ZV9sYV9MSUJBREQgPQorK2FtX2xpYm5hdGl2ZV9s
 YV9PQkpFQ1RTID0gaW5pdC5sbworK2xpYm5hdGl2ZV9sYV9PQkpFQ1RTID0gJChhbV9saWJuYXRp
 dmVfbGFfT0JKRUNUUykKKytERUZBVUxUX0lOQ0xVREVTID0gLUkuQGFtX19pc3JjQCAtSSQodG9w
 X2J1aWxkZGlyKS9zcmMKKytkZXBjb21wID0gJChTSEVMTCkgJCh0b3Bfc3JjZGlyKS9kZXBjb21w
 CisrYW1fX2RlcGZpbGVzX21heWJlID0gZGVwZmlsZXMKKytDT01QSUxFID0gJChDQykgJChERUZT
 KSAkKERFRkFVTFRfSU5DTFVERVMpICQoSU5DTFVERVMpICQoQU1fQ1BQRkxBR1MpIFwKKysJJChD
 UFBGTEFHUykgJChBTV9DRkxBR1MpICQoQ0ZMQUdTKQorK0xUQ09NUElMRSA9ICQoTElCVE9PTCkg
 LS10YWc9Q0MgJChBTV9MSUJUT09MRkxBR1MpICQoTElCVE9PTEZMQUdTKSBcCisrCS0tbW9kZT1j
 b21waWxlICQoQ0MpICQoREVGUykgJChERUZBVUxUX0lOQ0xVREVTKSAkKElOQ0xVREVTKSBcCisr
 CSQoQU1fQ1BQRkxBR1MpICQoQ1BQRkxBR1MpICQoQU1fQ0ZMQUdTKSAkKENGTEFHUykKKytDQ0xE
 ID0gJChDQykKKytMSU5LID0gJChMSUJUT09MKSAtLXRhZz1DQyAkKEFNX0xJQlRPT0xGTEFHUykg
 JChMSUJUT09MRkxBR1MpIFwKKysJLS1tb2RlPWxpbmsgJChDQ0xEKSAkKEFNX0NGTEFHUykgJChD
 RkxBR1MpICQoQU1fTERGTEFHUykgXAorKwkkKExERkxBR1MpIC1vICRACisrU09VUkNFUyA9ICQo
 bGlibmF0aXZlX2xhX1NPVVJDRVMpCisrRElTVF9TT1VSQ0VTID0gJChsaWJuYXRpdmVfbGFfU09V
 UkNFUykKKytFVEFHUyA9IGV0YWdzCisrQ1RBR1MgPSBjdGFncworK0RJU1RGSUxFUyA9ICQoRElT
 VF9DT01NT04pICQoRElTVF9TT1VSQ0VTKSAkKFRFWElORk9TKSAkKEVYVFJBX0RJU1QpCisrQUNM
 T0NBTCA9IEBBQ0xPQ0FMQAorK0FMTE9DQSA9IEBBTExPQ0FACisrQU1UQVIgPSBAQU1UQVJACisr
 QVIgPSBAQVJACisrQVVUT0NPTkYgPSBAQVVUT0NPTkZACisrQVVUT0hFQURFUiA9IEBBVVRPSEVB
 REVSQAorK0FVVE9NQUtFID0gQEFVVE9NQUtFQAorK0FXSyA9IEBBV0tACisrQ0MgPSBAQ0NACisr
 Q0NBUyA9IEBDQ0FTQAorK0NDQVNERVBNT0RFID0gQENDQVNERVBNT0RFQAorK0NDQVNGTEFHUyA9
 IEBDQ0FTRkxBR1NACisrQ0NERVBNT0RFID0gQENDREVQTU9ERUAKKytDRkxBR1MgPSBAQ0ZMQUdT
 QAorK0NQUCA9IEBDUFBACisrQ1BQRkxBR1MgPSBAQ1BQRkxBR1NACisrQ1hYID0gQENYWEAKKytD
 WFhDUFAgPSBAQ1hYQ1BQQAorK0NYWERFUE1PREUgPSBAQ1hYREVQTU9ERUAKKytDWFhGTEFHUyA9
 IEBDWFhGTEFHU0AKKytDWUdQQVRIX1cgPSBAQ1lHUEFUSF9XQAorK0RFRlMgPSBAREVGU0AKKytE
 RVBESVIgPSBAREVQRElSQAorK0RTWU1VVElMID0gQERTWU1VVElMQAorK0VDSE8gPSBARUNIT0AK
 KytFQ0hPX0MgPSBARUNIT19DQAorK0VDSE9fTiA9IEBFQ0hPX05ACisrRUNIT19UID0gQEVDSE9f
 VEAKKytFR1JFUCA9IEBFR1JFUEAKKytFWEVFWFQgPSBARVhFRVhUQAorK0Y3NyA9IEBGNzdACisr
 RkZMQUdTID0gQEZGTEFHU0AKKytHUkVQID0gQEdSRVBACisrSU5TVEFMTCA9IEBJTlNUQUxMQAor
 K0lOU1RBTExfREFUQSA9IEBJTlNUQUxMX0RBVEFACisrSU5TVEFMTF9QUk9HUkFNID0gQElOU1RB
 TExfUFJPR1JBTUAKKytJTlNUQUxMX1NDUklQVCA9IEBJTlNUQUxMX1NDUklQVEAKKytJTlNUQUxM
 X1NUUklQX1BST0dSQU0gPSBASU5TVEFMTF9TVFJJUF9QUk9HUkFNQAorK0pBVkFDID0gQEpBVkFD
 QAorK0xERkxBR1MgPSBATERGTEFHU0AKKytMSUJPQkpTID0gQExJQk9CSlNACisrTElCUyA9IEBM
 SUJTQAorK0xJQlRPT0wgPSBATElCVE9PTEAKKytMTl9TID0gQExOX1NACisrTFRMSUJPQkpTID0g
 QExUTElCT0JKU0AKKytNQUlOVCA9IEBNQUlOVEAKKytNQUtFSU5GTyA9IEBNQUtFSU5GT0AKKytN
 S0RJUl9QID0gQE1LRElSX1BACisrTk1FRElUID0gQE5NRURJVEAKKytPQkpFWFQgPSBAT0JKRVhU
 QAorK1BBQ0tBR0UgPSBAUEFDS0FHRUAKKytQQUNLQUdFX0JVR1JFUE9SVCA9IEBQQUNLQUdFX0JV
 R1JFUE9SVEAKKytQQUNLQUdFX05BTUUgPSBAUEFDS0FHRV9OQU1FQAorK1BBQ0tBR0VfU1RSSU5H
 ID0gQFBBQ0tBR0VfU1RSSU5HQAorK1BBQ0tBR0VfVEFSTkFNRSA9IEBQQUNLQUdFX1RBUk5BTUVA
 CisrUEFDS0FHRV9WRVJTSU9OID0gQFBBQ0tBR0VfVkVSU0lPTkAKKytQQVRIX1NFUEFSQVRPUiA9
 IEBQQVRIX1NFUEFSQVRPUkAKKytSQU5MSUIgPSBAUkFOTElCQAorK1NFRCA9IEBTRURACisrU0VU
 X01BS0UgPSBAU0VUX01BS0VACisrU0hFTEwgPSBAU0hFTExACisrU1RSSVAgPSBAU1RSSVBACisr
 VkVSU0lPTiA9IEBWRVJTSU9OQAorK2Fic19idWlsZGRpciA9IEBhYnNfYnVpbGRkaXJACisrYWJz
 X3NyY2RpciA9IEBhYnNfc3JjZGlyQAorK2Fic190b3BfYnVpbGRkaXIgPSBAYWJzX3RvcF9idWls
 ZGRpckAKKythYnNfdG9wX3NyY2RpciA9IEBhYnNfdG9wX3NyY2RpckAKKythY19jdF9DQyA9IEBh
 Y19jdF9DQ0AKKythY19jdF9DWFggPSBAYWNfY3RfQ1hYQAorK2FjX2N0X0Y3NyA9IEBhY19jdF9G
 NzdACisrYW1fX2luY2x1ZGUgPSBAYW1fX2luY2x1ZGVACisrYW1fX2xlYWRpbmdfZG90ID0gQGFt
 X19sZWFkaW5nX2RvdEAKKythbV9fcXVvdGUgPSBAYW1fX3F1b3RlQAorK2FtX190YXIgPSBAYW1f
 X3RhckAKKythbV9fdW50YXIgPSBAYW1fX3VudGFyQAorK2FyY2ggPSBAYXJjaEAKKytiaW5kaXIg
 PSBAYmluZGlyQAorK2J1aWxkID0gQGJ1aWxkQAorK2J1aWxkX2FsaWFzID0gQGJ1aWxkX2FsaWFz
 QAorK2J1aWxkX2NwdSA9IEBidWlsZF9jcHVACisrYnVpbGRfb3MgPSBAYnVpbGRfb3NACisrYnVp
 bGRfdmVuZG9yID0gQGJ1aWxkX3ZlbmRvckAKKytidWlsZGRpciA9IEBidWlsZGRpckAKKytkYXRh
 ZGlyID0gQGRhdGFkaXJACisrZGF0YXJvb3RkaXIgPSBAZGF0YXJvb3RkaXJACisrZG9jZGlyID0g
 QGRvY2RpckAKKytkdmlkaXIgPSBAZHZpZGlyQAorK2V4ZWNfcHJlZml4ID0gQGV4ZWNfcHJlZml4
 QAorK2hvc3QgPSBAaG9zdEAKKytob3N0X2FsaWFzID0gQGhvc3RfYWxpYXNACisraG9zdF9jcHUg
 PSBAaG9zdF9jcHVACisraG9zdF9vcyA9IEBob3N0X29zQAorK2hvc3RfdmVuZG9yID0gQGhvc3Rf
 dmVuZG9yQAorK2h0bWxkaXIgPSBAaHRtbGRpckAKKytpbmNsdWRlZGlyID0gQGluY2x1ZGVkaXJA
 CisraW5mb2RpciA9IEBpbmZvZGlyQAorK2luc3RhbGxfc2ggPSBAaW5zdGFsbF9zaEAKKytpbnRl
 cnBfY2ZsYWdzID0gQGludGVycF9jZmxhZ3NACisrbGliZGlyID0gQGxpYmRpckAKKytsaWJleGVj
 ZGlyID0gQGxpYmV4ZWNkaXJACisrbG9jYWxlZGlyID0gQGxvY2FsZWRpckAKKytsb2NhbHN0YXRl
 ZGlyID0gQGxvY2Fsc3RhdGVkaXJACisrbWFuZGlyID0gQG1hbmRpckAKKytta2Rpcl9wID0gQG1r
 ZGlyX3BACisrb2xkaW5jbHVkZWRpciA9IEBvbGRpbmNsdWRlZGlyQAorK29zID0gQG9zQAorK3Bk
 ZmRpciA9IEBwZGZkaXJACisrcHJlZml4ID0gQHByZWZpeEAKKytwcm9ncmFtX3RyYW5zZm9ybV9u
 YW1lID0gQHByb2dyYW1fdHJhbnNmb3JtX25hbWVACisrcHNkaXIgPSBAcHNkaXJACisrc2JpbmRp
 ciA9IEBzYmluZGlyQAorK3NoYXJlZHN0YXRlZGlyID0gQHNoYXJlZHN0YXRlZGlyQAorK3NyY2Rp
 ciA9IEBzcmNkaXJACisrc3lzY29uZmRpciA9IEBzeXNjb25mZGlyQAorK3RhcmdldF9hbGlhcyA9
 IEB0YXJnZXRfYWxpYXNACisrdG9wX2J1aWxkZGlyID0gQHRvcF9idWlsZGRpckAKKyt0b3Bfc3Jj
 ZGlyID0gQHRvcF9zcmNkaXJACisrdXNlX3ppcF9ubyA9IEB1c2VfemlwX25vQAorK3VzZV96aXBf
 eWVzID0gQHVzZV96aXBfeWVzQAorK3dpdGhfY2xhc3NwYXRoX2luc3RhbGxfZGlyID0gQHdpdGhf
 Y2xhc3NwYXRoX2luc3RhbGxfZGlyQAorK25vaW5zdF9MVExJQlJBUklFUyA9IGxpYm5hdGl2ZS5s
 YQorK2xpYm5hdGl2ZV9sYV9TT1VSQ0VTID0gaW5pdC5jCisrQU1fQ1BQRkxBR1MgPSAtSSQodG9w
 X2J1aWxkZGlyKS9zcmMKKythbGw6IGFsbC1hbQorKworKy5TVUZGSVhFUzoKKysuU1VGRklYRVM6
 IC5jIC5sbyAubyAub2JqCisrJChzcmNkaXIpL01ha2VmaWxlLmluOiBATUFJTlRBSU5FUl9NT0RF
 X1RSVUVAICQoc3JjZGlyKS9NYWtlZmlsZS5hbSAgJChhbV9fY29uZmlndXJlX2RlcHMpCisrCUBm
 b3IgZGVwIGluICQ/OyBkbyBcCisrCSAgY2FzZSAnJChhbV9fY29uZmlndXJlX2RlcHMpJyBpbiBc
 CisrCSAgICAqJCRkZXAqKSBcCisrCSAgICAgIGNkICQodG9wX2J1aWxkZGlyKSAmJiAkKE1BS0Up
 ICQoQU1fTUFLRUZMQUdTKSBhbS0tcmVmcmVzaCBcCisrCQkmJiBleGl0IDA7IFwKKysJICAgICAg
 ZXhpdCAxOzsgXAorKwkgIGVzYWM7IFwKKysJZG9uZTsgXAorKwllY2hvICcgY2QgJCh0b3Bfc3Jj
 ZGlyKSAmJiAkKEFVVE9NQUtFKSAtLWdudSAgc3JjL29zL2JzZC9zcGFyNjQvTWFrZWZpbGUnOyBc
 CisrCWNkICQodG9wX3NyY2RpcikgJiYgXAorKwkgICQoQVVUT01BS0UpIC0tZ251ICBzcmMvb3Mv
 YnNkL3NwYXJjNjQvTWFrZWZpbGUKKysuUFJFQ0lPVVM6IE1ha2VmaWxlCisrTWFrZWZpbGU6ICQo
 c3JjZGlyKS9NYWtlZmlsZS5pbiAkKHRvcF9idWlsZGRpcikvY29uZmlnLnN0YXR1cworKwlAY2Fz
 ZSAnJD8nIGluIFwKKysJICAqY29uZmlnLnN0YXR1cyopIFwKKysJICAgIGNkICQodG9wX2J1aWxk
 ZGlyKSAmJiAkKE1BS0UpICQoQU1fTUFLRUZMQUdTKSBhbS0tcmVmcmVzaDs7IFwKKysJICAqKSBc
 CisrCSAgICBlY2hvICcgY2QgJCh0b3BfYnVpbGRkaXIpICYmICQoU0hFTEwpIC4vY29uZmlnLnN0
 YXR1cyAkKHN1YmRpcikvJEAgJChhbV9fZGVwZmlsZXNfbWF5YmUpJzsgXAorKwkgICAgY2QgJCh0
 b3BfYnVpbGRkaXIpICYmICQoU0hFTEwpIC4vY29uZmlnLnN0YXR1cyAkKHN1YmRpcikvJEAgJChh
 bV9fZGVwZmlsZXNfbWF5YmUpOzsgXAorKwllc2FjOworKworKyQodG9wX2J1aWxkZGlyKS9jb25m
 aWcuc3RhdHVzOiAkKHRvcF9zcmNkaXIpL2NvbmZpZ3VyZSAkKENPTkZJR19TVEFUVVNfREVQRU5E
 RU5DSUVTKQorKwljZCAkKHRvcF9idWlsZGRpcikgJiYgJChNQUtFKSAkKEFNX01BS0VGTEFHUykg
 YW0tLXJlZnJlc2gKKysKKyskKHRvcF9zcmNkaXIpL2NvbmZpZ3VyZTogQE1BSU5UQUlORVJfTU9E
 RV9UUlVFQCAkKGFtX19jb25maWd1cmVfZGVwcykKKysJY2QgJCh0b3BfYnVpbGRkaXIpICYmICQo
 TUFLRSkgJChBTV9NQUtFRkxBR1MpIGFtLS1yZWZyZXNoCisrJChBQ0xPQ0FMX000KTogQE1BSU5U
 QUlORVJfTU9ERV9UUlVFQCAkKGFtX19hY2xvY2FsX200X2RlcHMpCisrCWNkICQodG9wX2J1aWxk
 ZGlyKSAmJiAkKE1BS0UpICQoQU1fTUFLRUZMQUdTKSBhbS0tcmVmcmVzaAorKworK2NsZWFuLW5v
 aW5zdExUTElCUkFSSUVTOgorKwktdGVzdCAteiAiJChub2luc3RfTFRMSUJSQVJJRVMpIiB8fCBy
 bSAtZiAkKG5vaW5zdF9MVExJQlJBUklFUykKKysJQGxpc3Q9JyQobm9pbnN0X0xUTElCUkFSSUVT
 KSc7IGZvciBwIGluICQkbGlzdDsgZG8gXAorKwkgIGRpcj0iYGVjaG8gJCRwIHwgc2VkIC1lICdz
 fC9bXi9dKiQkfHwnYCI7IFwKKysJICB0ZXN0ICIkJGRpciIgIT0gIiQkcCIgfHwgZGlyPS47IFwK
 KysJICBlY2hvICJybSAtZiBcIiQke2Rpcn0vc29fbG9jYXRpb25zXCIiOyBcCisrCSAgcm0gLWYg
 IiQke2Rpcn0vc29fbG9jYXRpb25zIjsgXAorKwlkb25lCisrbGlibmF0aXZlLmxhOiAkKGxpYm5h
 dGl2ZV9sYV9PQkpFQ1RTKSAkKGxpYm5hdGl2ZV9sYV9ERVBFTkRFTkNJRVMpIAorKwkkKExJTksp
 ICAkKGxpYm5hdGl2ZV9sYV9PQkpFQ1RTKSAkKGxpYm5hdGl2ZV9sYV9MSUJBREQpICQoTElCUykK
 KysKKyttb3N0bHljbGVhbi1jb21waWxlOgorKwktcm0gLWYgKi4kKE9CSkVYVCkKKysKKytkaXN0
 Y2xlYW4tY29tcGlsZToKKysJLXJtIC1mICoudGFiLmMKKysKKytAQU1ERVBfVFJVRUBAYW1fX2lu
 Y2x1ZGVAIEBhbV9fcXVvdGVALi8kKERFUERJUikvaW5pdC5QbG9AYW1fX3F1b3RlQAorKworKy5j
 Lm86CisrQGFtX19mYXN0ZGVwQ0NfVFJVRUAJJChDT01QSUxFKSAtTVQgJEAgLU1EIC1NUCAtTUYg
 JChERVBESVIpLyQqLlRwbyAtYyAtbyAkQCAkPAorK0BhbV9fZmFzdGRlcENDX1RSVUVACW12IC1m
 ICQoREVQRElSKS8kKi5UcG8gJChERVBESVIpLyQqLlBvCisrQEFNREVQX1RSVUVAQGFtX19mYXN0
 ZGVwQ0NfRkFMU0VACXNvdXJjZT0nJDwnIG9iamVjdD0nJEAnIGxpYnRvb2w9bm8gQEFNREVQQkFD
 S1NMQVNIQAorK0BBTURFUF9UUlVFQEBhbV9fZmFzdGRlcENDX0ZBTFNFQAlERVBESVI9JChERVBE
 SVIpICQoQ0NERVBNT0RFKSAkKGRlcGNvbXApIEBBTURFUEJBQ0tTTEFTSEAKKytAYW1fX2Zhc3Rk
 ZXBDQ19GQUxTRUAJJChDT01QSUxFKSAtYyAkPAorKworKy5jLm9iajoKKytAYW1fX2Zhc3RkZXBD
 Q19UUlVFQAkkKENPTVBJTEUpIC1NVCAkQCAtTUQgLU1QIC1NRiAkKERFUERJUikvJCouVHBvIC1j
 IC1vICRAIGAkKENZR1BBVEhfVykgJyQ8J2AKKytAYW1fX2Zhc3RkZXBDQ19UUlVFQAltdiAtZiAk
 KERFUERJUikvJCouVHBvICQoREVQRElSKS8kKi5QbworK0BBTURFUF9UUlVFQEBhbV9fZmFzdGRl
 cENDX0ZBTFNFQAlzb3VyY2U9JyQ8JyBvYmplY3Q9JyRAJyBsaWJ0b29sPW5vIEBBTURFUEJBQ0tT
 TEFTSEAKKytAQU1ERVBfVFJVRUBAYW1fX2Zhc3RkZXBDQ19GQUxTRUAJREVQRElSPSQoREVQRElS
 KSAkKENDREVQTU9ERSkgJChkZXBjb21wKSBAQU1ERVBCQUNLU0xBU0hACisrQGFtX19mYXN0ZGVw
 Q0NfRkFMU0VACSQoQ09NUElMRSkgLWMgYCQoQ1lHUEFUSF9XKSAnJDwnYAorKworKy5jLmxvOgor
 K0BhbV9fZmFzdGRlcENDX1RSVUVACSQoTFRDT01QSUxFKSAtTVQgJEAgLU1EIC1NUCAtTUYgJChE
 RVBESVIpLyQqLlRwbyAtYyAtbyAkQCAkPAorK0BhbV9fZmFzdGRlcENDX1RSVUVACW12IC1mICQo
 REVQRElSKS8kKi5UcG8gJChERVBESVIpLyQqLlBsbworK0BBTURFUF9UUlVFQEBhbV9fZmFzdGRl
 cENDX0ZBTFNFQAlzb3VyY2U9JyQ8JyBvYmplY3Q9JyRAJyBsaWJ0b29sPXllcyBAQU1ERVBCQUNL
 U0xBU0hACisrQEFNREVQX1RSVUVAQGFtX19mYXN0ZGVwQ0NfRkFMU0VACURFUERJUj0kKERFUERJ
 UikgJChDQ0RFUE1PREUpICQoZGVwY29tcCkgQEFNREVQQkFDS1NMQVNIQAorK0BhbV9fZmFzdGRl
 cENDX0ZBTFNFQAkkKExUQ09NUElMRSkgLWMgLW8gJEAgJDwKKysKKyttb3N0bHljbGVhbi1saWJ0
 b29sOgorKwktcm0gLWYgKi5sbworKworK2NsZWFuLWxpYnRvb2w6CisrCS1ybSAtcmYgLmxpYnMg
 X2xpYnMKKysKKytJRDogJChIRUFERVJTKSAkKFNPVVJDRVMpICQoTElTUCkgJChUQUdTX0ZJTEVT
 KQorKwlsaXN0PSckKFNPVVJDRVMpICQoSEVBREVSUykgJChMSVNQKSAkKFRBR1NfRklMRVMpJzsg
 XAorKwl1bmlxdWU9YGZvciBpIGluICQkbGlzdDsgZG8gXAorKwkgICAgaWYgdGVzdCAtZiAiJCRp
 IjsgdGhlbiBlY2hvICQkaTsgZWxzZSBlY2hvICQoc3JjZGlyKS8kJGk7IGZpOyBcCisrCSAgZG9u
 ZSB8IFwKKysJICAkKEFXSykgJ3sgZmlsZXNbJCQwXSA9IDE7IG5vbmVtdHB5ID0gMTsgfSBcCisr
 CSAgICAgIEVORCB7IGlmIChub25lbXB0eSkgeyBmb3IgKGkgaW4gZmlsZXMpIHByaW50IGk7IH07
 IH0nYDsgXAorKwlta2lkIC1mSUQgJCR1bmlxdWUKKyt0YWdzOiBUQUdTCisrCisrVEFHUzogICQo
 SEVBREVSUykgJChTT1VSQ0VTKSAgJChUQUdTX0RFUEVOREVOQ0lFUykgXAorKwkJJChUQUdTX0ZJ
 TEVTKSAkKExJU1ApCisrCXRhZ3M9OyBcCisrCWhlcmU9YHB3ZGA7IFwKKysJbGlzdD0nJChTT1VS
 Q0VTKSAkKEhFQURFUlMpICAkKExJU1ApICQoVEFHU19GSUxFUyknOyBcCisrCXVuaXF1ZT1gZm9y
 IGkgaW4gJCRsaXN0OyBkbyBcCisrCSAgICBpZiB0ZXN0IC1mICIkJGkiOyB0aGVuIGVjaG8gJCRp
 OyBlbHNlIGVjaG8gJChzcmNkaXIpLyQkaTsgZmk7IFwKKysJICBkb25lIHwgXAorKwkgICQoQVdL
 KSAneyBmaWxlc1skJDBdID0gMTsgbm9uZW1wdHkgPSAxOyB9IFwKKysJICAgICAgRU5EIHsgaWYg
 KG5vbmVtcHR5KSB7IGZvciAoaSBpbiBmaWxlcykgcHJpbnQgaTsgfTsgfSdgOyBcCisrCWlmIHRl
 c3QgLXogIiQoRVRBR1NfQVJHUykkJHRhZ3MkJHVuaXF1ZSI7IHRoZW4gOjsgZWxzZSBcCisrCSAg
 dGVzdCAtbiAiJCR1bmlxdWUiIHx8IHVuaXF1ZT0kJGVtcHR5X2ZpeDsgXAorKwkgICQoRVRBR1Mp
 ICQoRVRBR1NGTEFHUykgJChBTV9FVEFHU0ZMQUdTKSAkKEVUQUdTX0FSR1MpIFwKKysJICAgICQk
 dGFncyAkJHVuaXF1ZTsgXAorKwlmaQorK2N0YWdzOiBDVEFHUworK0NUQUdTOiAgJChIRUFERVJT
 KSAkKFNPVVJDRVMpICAkKFRBR1NfREVQRU5ERU5DSUVTKSBcCisrCQkkKFRBR1NfRklMRVMpICQo
 TElTUCkKKysJdGFncz07IFwKKysJbGlzdD0nJChTT1VSQ0VTKSAkKEhFQURFUlMpICAkKExJU1Ap
 ICQoVEFHU19GSUxFUyknOyBcCisrCXVuaXF1ZT1gZm9yIGkgaW4gJCRsaXN0OyBkbyBcCisrCSAg
 ICBpZiB0ZXN0IC1mICIkJGkiOyB0aGVuIGVjaG8gJCRpOyBlbHNlIGVjaG8gJChzcmNkaXIpLyQk
 aTsgZmk7IFwKKysJICBkb25lIHwgXAorKwkgICQoQVdLKSAneyBmaWxlc1skJDBdID0gMTsgbm9u
 ZW1wdHkgPSAxOyB9IFwKKysJICAgICAgRU5EIHsgaWYgKG5vbmVtcHR5KSB7IGZvciAoaSBpbiBm
 aWxlcykgcHJpbnQgaTsgfTsgfSdgOyBcCisrCXRlc3QgLXogIiQoQ1RBR1NfQVJHUykkJHRhZ3Mk
 JHVuaXF1ZSIgXAorKwkgIHx8ICQoQ1RBR1MpICQoQ1RBR1NGTEFHUykgJChBTV9DVEFHU0ZMQUdT
 KSAkKENUQUdTX0FSR1MpIFwKKysJICAgICAkJHRhZ3MgJCR1bmlxdWUKKysKKytHVEFHUzoKKysJ
 aGVyZT1gJChhbV9fY2QpICQodG9wX2J1aWxkZGlyKSAmJiBwd2RgIFwKKysJICAmJiBjZCAkKHRv
 cF9zcmNkaXIpIFwKKysJICAmJiBndGFncyAtaSAkKEdUQUdTX0FSR1MpICQkaGVyZQorKworK2Rp
 c3RjbGVhbi10YWdzOgorKwktcm0gLWYgVEFHUyBJRCBHVEFHUyBHUlRBR1MgR1NZTVMgR1BBVEgg
 dGFncworKworK2Rpc3RkaXI6ICQoRElTVEZJTEVTKQorKwlAc3JjZGlyc3RyaXA9YGVjaG8gIiQo
 c3JjZGlyKSIgfCBzZWQgJ3MvW10uW14kJFxcKl0vXFxcXCYvZydgOyBcCisrCXRvcHNyY2RpcnN0
 cmlwPWBlY2hvICIkKHRvcF9zcmNkaXIpIiB8IHNlZCAncy9bXS5bXiQkXFwqXS9cXFxcJi9nJ2A7
 IFwKKysJbGlzdD0nJChESVNURklMRVMpJzsgXAorKwkgIGRpc3RfZmlsZXM9YGZvciBmaWxlIGlu
 ICQkbGlzdDsgZG8gZWNobyAkJGZpbGU7IGRvbmUgfCBcCisrCSAgc2VkIC1lICJzfF4kJHNyY2Rp
 cnN0cmlwL3x8O3QiIFwKKysJICAgICAgLWUgInN8XiQkdG9wc3JjZGlyc3RyaXAvfCQodG9wX2J1
 aWxkZGlyKS98O3QiYDsgXAorKwljYXNlICQkZGlzdF9maWxlcyBpbiBcCisrCSAgKi8qKSAkKE1L
 RElSX1ApIGBlY2hvICIkJGRpc3RfZmlsZXMiIHwgXAorKwkJCSAgIHNlZCAnL1wvLyFkO3N8Xnwk
 KGRpc3RkaXIpL3w7cywvW14vXSokJCwsJyB8IFwKKysJCQkgICBzb3J0IC11YCA7OyBcCisrCWVz
 YWM7IFwKKysJZm9yIGZpbGUgaW4gJCRkaXN0X2ZpbGVzOyBkbyBcCisrCSAgaWYgdGVzdCAtZiAk
 JGZpbGUgfHwgdGVzdCAtZCAkJGZpbGU7IHRoZW4gZD0uOyBlbHNlIGQ9JChzcmNkaXIpOyBmaTsg
 XAorKwkgIGlmIHRlc3QgLWQgJCRkLyQkZmlsZTsgdGhlbiBcCisrCSAgICBkaXI9YGVjaG8gIi8k
 JGZpbGUiIHwgc2VkIC1lICdzLC9bXi9dKiQkLCwnYDsgXAorKwkgICAgaWYgdGVzdCAtZCAkKHNy
 Y2RpcikvJCRmaWxlICYmIHRlc3QgJCRkICE9ICQoc3JjZGlyKTsgdGhlbiBcCisrCSAgICAgIGNw
 IC1wUiAkKHNyY2RpcikvJCRmaWxlICQoZGlzdGRpcikkJGRpciB8fCBleGl0IDE7IFwKKysJICAg
 IGZpOyBcCisrCSAgICBjcCAtcFIgJCRkLyQkZmlsZSAkKGRpc3RkaXIpJCRkaXIgfHwgZXhpdCAx
 OyBcCisrCSAgZWxzZSBcCisrCSAgICB0ZXN0IC1mICQoZGlzdGRpcikvJCRmaWxlIFwKKysJICAg
 IHx8IGNwIC1wICQkZC8kJGZpbGUgJChkaXN0ZGlyKS8kJGZpbGUgXAorKwkgICAgfHwgZXhpdCAx
 OyBcCisrCSAgZmk7IFwKKysJZG9uZQorK2NoZWNrLWFtOiBhbGwtYW0KKytjaGVjazogY2hlY2st
 YW0KKythbGwtYW06IE1ha2VmaWxlICQoTFRMSUJSQVJJRVMpCisraW5zdGFsbGRpcnM6CisraW5z
 dGFsbDogaW5zdGFsbC1hbQorK2luc3RhbGwtZXhlYzogaW5zdGFsbC1leGVjLWFtCisraW5zdGFs
 bC1kYXRhOiBpbnN0YWxsLWRhdGEtYW0KKyt1bmluc3RhbGw6IHVuaW5zdGFsbC1hbQorKworK2lu
 c3RhbGwtYW06IGFsbC1hbQorKwlAJChNQUtFKSAkKEFNX01BS0VGTEFHUykgaW5zdGFsbC1leGVj
 LWFtIGluc3RhbGwtZGF0YS1hbQorKworK2luc3RhbGxjaGVjazogaW5zdGFsbGNoZWNrLWFtCisr
 aW5zdGFsbC1zdHJpcDoKKysJJChNQUtFKSAkKEFNX01BS0VGTEFHUykgSU5TVEFMTF9QUk9HUkFN
 PSIkKElOU1RBTExfU1RSSVBfUFJPR1JBTSkiIFwKKysJICBpbnN0YWxsX3NoX1BST0dSQU09IiQo
 SU5TVEFMTF9TVFJJUF9QUk9HUkFNKSIgSU5TVEFMTF9TVFJJUF9GTEFHPS1zIFwKKysJICBgdGVz
 dCAteiAnJChTVFJJUCknIHx8IFwKKysJICAgIGVjaG8gIklOU1RBTExfUFJPR1JBTV9FTlY9U1RS
 SVBQUk9HPSckKFNUUklQKSciYCBpbnN0YWxsCisrbW9zdGx5Y2xlYW4tZ2VuZXJpYzoKKysKKytj
 bGVhbi1nZW5lcmljOgorKworK2Rpc3RjbGVhbi1nZW5lcmljOgorKwktdGVzdCAteiAiJChDT05G
 SUdfQ0xFQU5fRklMRVMpIiB8fCBybSAtZiAkKENPTkZJR19DTEVBTl9GSUxFUykKKysKKyttYWlu
 dGFpbmVyLWNsZWFuLWdlbmVyaWM6CisrCUBlY2hvICJUaGlzIGNvbW1hbmQgaXMgaW50ZW5kZWQg
 Zm9yIG1haW50YWluZXJzIHRvIHVzZSIKKysJQGVjaG8gIml0IGRlbGV0ZXMgZmlsZXMgdGhhdCBt
 YXkgcmVxdWlyZSBzcGVjaWFsIHRvb2xzIHRvIHJlYnVpbGQuIgorK2NsZWFuOiBjbGVhbi1hbQor
 KworK2NsZWFuLWFtOiBjbGVhbi1nZW5lcmljIGNsZWFuLWxpYnRvb2wgY2xlYW4tbm9pbnN0TFRM
 SUJSQVJJRVMgXAorKwltb3N0bHljbGVhbi1hbQorKworK2Rpc3RjbGVhbjogZGlzdGNsZWFuLWFt
 CisrCS1ybSAtcmYgLi8kKERFUERJUikKKysJLXJtIC1mIE1ha2VmaWxlCisrZGlzdGNsZWFuLWFt
 OiBjbGVhbi1hbSBkaXN0Y2xlYW4tY29tcGlsZSBkaXN0Y2xlYW4tZ2VuZXJpYyBcCisrCWRpc3Rj
 bGVhbi10YWdzCisrCisrZHZpOiBkdmktYW0KKysKKytkdmktYW06CisrCisraHRtbDogaHRtbC1h
 bQorKworK2luZm86IGluZm8tYW0KKysKKytpbmZvLWFtOgorKworK2luc3RhbGwtZGF0YS1hbToK
 KysKKytpbnN0YWxsLWR2aTogaW5zdGFsbC1kdmktYW0KKysKKytpbnN0YWxsLWV4ZWMtYW06Cisr
 CisraW5zdGFsbC1odG1sOiBpbnN0YWxsLWh0bWwtYW0KKysKKytpbnN0YWxsLWluZm86IGluc3Rh
 bGwtaW5mby1hbQorKworK2luc3RhbGwtbWFuOgorKworK2luc3RhbGwtcGRmOiBpbnN0YWxsLXBk
 Zi1hbQorKworK2luc3RhbGwtcHM6IGluc3RhbGwtcHMtYW0KKysKKytpbnN0YWxsY2hlY2stYW06
 CisrCisrbWFpbnRhaW5lci1jbGVhbjogbWFpbnRhaW5lci1jbGVhbi1hbQorKwktcm0gLXJmIC4v
 JChERVBESVIpCisrCS1ybSAtZiBNYWtlZmlsZQorK21haW50YWluZXItY2xlYW4tYW06IGRpc3Rj
 bGVhbi1hbSBtYWludGFpbmVyLWNsZWFuLWdlbmVyaWMKKysKKyttb3N0bHljbGVhbjogbW9zdGx5
 Y2xlYW4tYW0KKysKKyttb3N0bHljbGVhbi1hbTogbW9zdGx5Y2xlYW4tY29tcGlsZSBtb3N0bHlj
 bGVhbi1nZW5lcmljIFwKKysJbW9zdGx5Y2xlYW4tbGlidG9vbAorKworK3BkZjogcGRmLWFtCisr
 CisrcGRmLWFtOgorKworK3BzOiBwcy1hbQorKworK3BzLWFtOgorKworK3VuaW5zdGFsbC1hbToK
 KysKKysuTUFLRTogaW5zdGFsbC1hbSBpbnN0YWxsLXN0cmlwCisrCisrLlBIT05ZOiBDVEFHUyBH
 VEFHUyBhbGwgYWxsLWFtIGNoZWNrIGNoZWNrLWFtIGNsZWFuIGNsZWFuLWdlbmVyaWMgXAorKwlj
 bGVhbi1saWJ0b29sIGNsZWFuLW5vaW5zdExUTElCUkFSSUVTIGN0YWdzIGRpc3RjbGVhbiBcCisr
 CWRpc3RjbGVhbi1jb21waWxlIGRpc3RjbGVhbi1nZW5lcmljIGRpc3RjbGVhbi1saWJ0b29sIFwK
 KysJZGlzdGNsZWFuLXRhZ3MgZGlzdGRpciBkdmkgZHZpLWFtIGh0bWwgaHRtbC1hbSBpbmZvIGlu
 Zm8tYW0gXAorKwlpbnN0YWxsIGluc3RhbGwtYW0gaW5zdGFsbC1kYXRhIGluc3RhbGwtZGF0YS1h
 bSBpbnN0YWxsLWR2aSBcCisrCWluc3RhbGwtZHZpLWFtIGluc3RhbGwtZXhlYyBpbnN0YWxsLWV4
 ZWMtYW0gaW5zdGFsbC1odG1sIFwKKysJaW5zdGFsbC1odG1sLWFtIGluc3RhbGwtaW5mbyBpbnN0
 YWxsLWluZm8tYW0gaW5zdGFsbC1tYW4gXAorKwlpbnN0YWxsLXBkZiBpbnN0YWxsLXBkZi1hbSBp
 bnN0YWxsLXBzIGluc3RhbGwtcHMtYW0gXAorKwlpbnN0YWxsLXN0cmlwIGluc3RhbGxjaGVjayBp
 bnN0YWxsY2hlY2stYW0gaW5zdGFsbGRpcnMgXAorKwltYWludGFpbmVyLWNsZWFuIG1haW50YWlu
 ZXItY2xlYW4tZ2VuZXJpYyBtb3N0bHljbGVhbiBcCisrCW1vc3RseWNsZWFuLWNvbXBpbGUgbW9z
 dGx5Y2xlYW4tZ2VuZXJpYyBtb3N0bHljbGVhbi1saWJ0b29sIFwKKysJcGRmIHBkZi1hbSBwcyBw
 cy1hbSB0YWdzIHVuaW5zdGFsbCB1bmluc3RhbGwtYW0KKysKKysjIFRlbGwgdmVyc2lvbnMgWzMu
 NTksMy42Mykgb2YgR05VIG1ha2UgdG8gbm90IGV4cG9ydCBhbGwgdmFyaWFibGVzLgorKyMgT3Ro
 ZXJ3aXNlIGEgc3lzdGVtIGxpbWl0IChmb3IgU3lzViBhdCBsZWFzdCkgbWF5IGJlIGV4Y2VlZGVk
 LgorKy5OT0VYUE9SVDoKSW5kZXg6IGphdmEvamFtdm0taW5pdGlhbC9maWxlcy9wYXRjaC1zcmNf
 b3NfYnNkX3NwYXJjNjRfaW5pdC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGphdmEvamFtdm0taW5pdGlhbC9m
 aWxlcy9wYXRjaC1zcmNfb3NfYnNkX3NwYXJjNjRfaW5pdC5jCShyZXZpc2lvbiAwKQorKysgamF2
 YS9qYW12bS1pbml0aWFsL2ZpbGVzL3BhdGNoLXNyY19vc19ic2Rfc3BhcmM2NF9pbml0LmMJKGFy
 YmV0c2tvcGlhKQpAQCAtMCwwICsxLDI5IEBACistLS0gc3JjL29zL2JzZC9zcGFyYzY0L2luaXQu
 Yy5vcmlnCTIwMTItMDEtMjYgMTk6MzI6NDAuMDAwMDAwMDAwICswMTAwCisrKysgc3JjL29zL2Jz
 ZC9zcGFyYzY0L2luaXQuYwkyMDEyLTAxLTI2IDE5OjMyOjQwLjAwMDAwMDAwMCArMDEwMAorQEAg
 LTAsMCArMSwyNiBAQAorKy8qCisrICogQ29weXJpZ2h0IChDKSAyMDAzLCAyMDA0LCAyMDA2LCAy
 MDA3CisrICogUm9iZXJ0IExvdWdoZXIgPHJvYkBsb3VnaGVyLm9yZy51az4uCisrICoKKysgKiBU
 aGlzIGZpbGUgaXMgcGFydCBvZiBKYW1WTS4KKysgKgorKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVl
 IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKysgKiBtb2RpZnkgaXQg
 dW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorKyAqIGFz
 IHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lv
 biAyLAorKyAqIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisrICoKKysg
 KiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl
 IHVzZWZ1bCwKKysgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUg
 aW1wbGllZCB3YXJyYW50eSBvZgorKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBB
 IFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKysgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGlj
 ZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorKyAqCisrICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVk
 IGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKysgKiBhbG9uZyB3aXRo
 IHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorKyAqIEZv
 dW5kYXRpb24sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIx
 MTAtMTMwMSwgVVNBLgorKyAqLworKworK3ZvaWQgc2V0RG91YmxlUHJlY2lzaW9uKCkgeworK30K
 KysKKyt2b2lkIGluaXRpYWxpc2VQbGF0Zm9ybSgpIHsKKyt9CkluZGV4OiBqYXZhL2phbXZtLWlu
 aXRpYWwvZmlsZXMvcGF0Y2gtc3JjX3RocmVhZC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGphdmEvamFtdm0t
 aW5pdGlhbC9maWxlcy9wYXRjaC1zcmNfdGhyZWFkLmMJKHJldmlzaW9uIDApCisrKyBqYXZhL2ph
 bXZtLWluaXRpYWwvZmlsZXMvcGF0Y2gtc3JjX3RocmVhZC5jCShhcmJldHNrb3BpYSkKQEAgLTAs
 MCArMSwxMSBAQAorLS0tIHNyYy90aHJlYWQuYy5vcmlnCTIwMDgtMDItMjIgMDI6NTg6NDMuMDAw
 MDAwMDAwICswMTAwCisrKysgc3JjL3RocmVhZC5jCTIwMTItMDEtMjYgMTk6MzI6NDAuMDAwMDAw
 MDAwICswMTAwCitAQCAtMjgzLDcgKzI4Myw3IEBAIHZvaWQgcmVzZXRQZWFrVGhyZWFkc0NvdW50
 KCkgeworIHZvaWQgaW5pdGlhbGlzZUphdmFTdGFjayhFeGVjRW52ICplZSkgeworICAgIGludCBz
 dGFja19zaXplID0gZWUtPnN0YWNrX3NpemUgPworICAgICAgICAgICAgKGVlLT5zdGFja19zaXpl
 ID4gTUlOX1NUQUNLID8gZWUtPnN0YWNrX3NpemUgOiBNSU5fU1RBQ0spIDogZGZsdF9zdGFja19z
 aXplOworLSAgIGNoYXIgKnN0YWNrID0gc3lzTWFsbG9jKHN0YWNrX3NpemUpOworKyAgIHZvaWQg
 KnN0YWNrID0gc3lzTWFsbG9jKHN0YWNrX3NpemUpOworICAgIE1ldGhvZEJsb2NrICptYiA9IChN
 ZXRob2RCbG9jayAqKSBzdGFjazsKKyAgICBGcmFtZSAqdG9wID0gKEZyYW1lICopIChtYisxKTsK
 KyAKSW5kZXg6IGphdmEvamFtdm0taW5pdGlhbC9wa2ctZGVzY3IKPT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gamF2
 YS9qYW12bS1pbml0aWFsL3BrZy1kZXNjcgkocmV2aXNpb24gMCkKKysrIGphdmEvamFtdm0taW5p
 dGlhbC9wa2ctZGVzY3IJKGFyYmV0c2tvcGlhKQpAQCAtMCwwICsxLDExIEBACitUaGlzIHBhY2th
 Z2UgaXMgZm9yIGJvb3RzdHJhcHBpbmcgY2xhc3NwYXRoID4gMC45MyB3aGljaCBjYW5ub3QgYmUK
 K2NvbXBpbGVkIHdpdGggamlrZXMuCisKK0phbVZNIGlzIGFuIGV4dHJlbWVseSBzbWFsbCBKYXZh
 IFZpcnR1YWwgTWFjaGluZSB3aGljaCBjb25mb3JtcyB0byB0aGUKK0pWTSBzcGVjaWZpY2F0aW9u
 IHZlcnNpb24gMiAoYmx1ZSBib29rKS4KKworSXQgaXMgZGVzaWduZWQgdG8gc3VwcG9ydCB0aGUg
 ZnVsbCBzcGVjaWZpY2F0aW9uLCBhbmQgaW5jbHVkZXMgc3VwcG9ydAorZm9yIG9iamVjdCBmaW5h
 bGlzYXRpb24sIFNvZnQvV2Vhay9QaGFudG9tIFJlZmVyZW5jZXMsIGNsYXNzLXVubG9hZGluZywK
 K3RoZSBKYXZhIE5hdGl2ZSBJbnRlcmZhY2UgKEpOSSkgYW5kIHRoZSBSZWZsZWN0aW9uIEFQSS4K
 KworV1dXOiBodHRwOi8vamFtdm0uc291cmNlZm9yZ2UubmV0LwpJbmRleDogamF2YS9qYW12bS1p
 bml0aWFsL3BrZy1wbGlzdAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBqYXZhL2phbXZtLWluaXRpYWwvcGtnLXBs
 aXN0CShyZXZpc2lvbiAwKQorKysgamF2YS9qYW12bS1pbml0aWFsL3BrZy1wbGlzdAkoYXJiZXRz
 a29waWEpCkBAIC0wLDAgKzEsMyBAQAorYmluL2phbXZtLWluaXRpYWwKK3NoYXJlL2phbXZtLWlu
 aXRpYWwvY2xhc3Nlcy56aXAKK0BkaXJybSBzaGFyZS9qYW12bS1pbml0aWFsCg==
 --bcaec554d84ccfbbd504d61a8b2e--
>Unformatted:
